Find an English version of this topic here.
转载请保留原文地址http://blog.csdn.net/ir0nf1st/article/details/61650984
Python开发者常常面临这样一个难题,即如何保护代码中的技术秘密。笔者尝试过的一些Python代码保护工具要么难以有效实现该目标,要么有效但是有着不可忽视的缺点。最近笔者也遇到了这个问题,在难以找到一个有效解决方案的情况下,不得不自行开发了一个字节码混淆器。本文首先对常见的Python代码保护机制以及几个比较容易获得的Python代码保护工具进行了简单的分析,然后展示了通过字节码混淆来保护Python代码的技术原理。
笔者尝试过两个源码混淆工具。一个是pyminifier,另一个是提供在线源码混淆服务的http://pyob.oxyry.com/。这两个工具的工作方法类似,他们对类名/函数名/变量名进行重新命名,pyminifier甚至能够对部分Python常量进行扰乱(如True/False/None),然而代码的逻辑与控制流并没有被改变。阅读被混淆过的源码对于读者的眼睛来说是一种摧残,也带来了理解上的困难,但是简单的改名甚至无法对抗基本的文本查找与替换。源码混淆如果只在名字替换上下功夫,要实现代码保护无异于缘木求鱼。笔者认为:源码混淆要实现代码保护,则必须提取目标程序的抽象语法树(Abstract Syntax Tree)并对语法树进行修改,再根据修改后的语法树生成新的源码。然而这么做的工作量不会比实现一个编译器来得更少。这篇英文文章更深入的介绍了基于AST分析的Python源码混淆方法,有兴趣的读者可参考。
以下是pyminifier试用结果,读者可以评估一下名字替换是否可以有效保护源码。http://pyob.oryry.com提供的服务要比pyminifier来得更简单,这里就不提供试用效果了。
混淆前的样例代码:
class SampleClass:
def __init__(self):
self.data = None
def method1SampleClass(self, arg):
self.data = arg
def function_with_if(arg):
if arg == True:
pass
else:
pass
def function_with_if1(arg=True):
if arg == True:
print('True')
else:
print('False')
def function_with_if2():
if True:
print('True')
else:
print('False')
def function_with_try_except1():
try:
data = 1/0
except:
print('Constructed Control Flow')
def function_with_try_except2():
try:
pass
print('Constructed Control Flow')
except:
pass
global_var1, global_var2, global_var3
pass
a = SampleClass()
a.method1SampleClass()
function_with_if(False)
function_with_if1()
del global_var1, global_var2, global_var3
混淆后的代码:
class N:
y=None
T=True
H=False
def __init__(P):
P.data=y
def b(P,R):
P.data=R
def x(R):
if R==T:
pass
else:
pass
def L(arg=T):
if arg==T:
print('True')
else:
print('False')
def I():
if T:
print('True')
else:
print('False')
def d():
try:
n=1/0
except:
print('Constructed Control Flow')
def E():
try:
pass
print('Constructed Control Flow')
except:
pass
global_var1,global_var2,global_var3
pass
a=N()
a.method1SampleClass()
x(H)
L()
del global_var1,global_var2,global_var3
# Created by pyminifier (https://github.com/liftoff/pyminifier)
值得一提的是pyminifier在对None/True/False进行扰乱的时候似乎有一个bug。
class N:
y=None
T=True
H=False
def __init__(P):
P.data=y
def b(P,R):
P.data=R
def x(R):
if R==T:
pass
else:
pass
其中变量y/T/H的作用域在class N内部,然而下面的函数并不是class N的方法,函数中对T/H的引用超出了其作用域。
def L(arg=T):
if arg==T:
print('True')
else:
print('False')
def I():
if T:
print('True')
else:
print('False')
如果读者使用pyminifier,需要注意这个问题。
py2exe, PyInstaller将Python代码以及Python运行环境(如Python解释器,应用依赖的标准模块等)打包为可执行文件,这样你的Python代码就可以在一个没有事先安装Python的目标机器上运行。py2exe将Python代码及其依赖文件打包成一个zip包,解压后你会发现所有文件都在那等着被反编译。PyInstaller比py2exe更安全一些,它支持对Python代码进行AES加密,然而明文的AES密钥也被存储在打包文件中。
另外一个选择是Cython。这是是一个将Python扩展到C的模块,开发者可以在Python中直接使用类似于C的语法进行开发,或者间接使用C语言进行开发。开发者开发的C模块可以被Python代码调用,同时该C模块在运行环境上是native binary code(x86 Windows平台上就是x86_PE格式,ARM Linux平台则为 arm_elf,arm_eabi或者其他)。一定程度上native binary code对逆向工程者提出了更高的技术要求,增加了逆向工程的难度,从而实现了对开发者代码的保护。但是本质上来说,它保护的不过是开发者的C代码,而不是Python代码。而使用Cython的缺点也是显而易见的,C语言开发难度要显著高于Python,C语言开发的模块也导致整个软件丧失了跨平台的特性。
如果你不在意Cython带来的缺点,使用Cython来保护你的C代码不失为一个好的选择。
对于同一个版本的Python,Python编译器、解释器、反汇编器以及反编译器都使用同样的Bytecode指令集。不同版本的Python则使用不同的Bytecode指令集,这也是为何Python 2.X编译器产生的pyc文件无法被Python 3.x解释器执行的原因之一。
如果使用私有的Bytecode指令集,那么通常的Python反汇编器和反编译器无法工作在由你私有Python编译器产生的pyc文件上,也相当于保护了你的Python代码。这么做的代价是你的Python应用只能在你的私有Python解释器上运行。
字节码混淆可以非常容易的欺骗通常的反汇编器和反编译器,同时不影响代码的正常执行。下面这个例子展示了如何欺骗Uncompyle6反编译器以及dis反汇编器:
#一个简单的Python应用 sample1.py
print 'Hello World'
对其进行编译:
python -m py_compile sample1.py
对编译后的sample1.pyc使用Python内置dis模块反汇编:
>>> import marshal,dis
>>> fd = open('sample1.pyc', 'rb')
>>> fd.seek(8)
>>> sample1_code_obj = marshal.load(fd)
>>> fd.close()
>>> dis.dis(sample1_code_obj)
1 0 LOAD_CONST 0 ('Hello World')
3 PRINT_ITEM
4 PRINT_NEWLINE
5 LOAD_CONST 1 (None)
8 RETURN_VALUE
>>>
以上的汇编代码笔者肉眼反汇编的结果如下:
0 LOAD_CONST 0 ('Hello World') #加载co_consts[0]到栈顶,co_consts[0]存储着常量字符串'Hello World'
3 PRINT_ITEM #打印栈顶到sys.stdout,即print 'Hello World'
4 PRINT_NEWLINE #打印新行到sys.stdout,此指令因print语句而由编译器自动生成
5 LOAD_CONST 1 (None) #加载co_consts[1]到栈顶,co_consts[1]存储着None
8 RETURN_VALUE #将栈顶返回给调用者,此两条指令为编译器自动生成
现在我们修改sample1.pyc,在程序入口增加一条绝对跳转指令(可以使用UltraEdit 16进制插入功能修改pyc文件,”JUMP_ABSOLUTE 3”在Python 2.7中对应的字节码为 0x71 0x03 0x00。修改code string内容的同时应修改code string的长度,此处增加了一个3字节指令),使用内置dis模块反汇编的结果如下:
1 0 JUMP_ABSOLUTE 3 #自行添加
>> 3 LOAD_CONST 0 ('Hello World')
6 PRINT_ITEM
7 PRINT_NEWLINE
8 LOAD_CONST 1 (None)
11 RETURN_VALUE
如果读者对汇编代码有一定认识,就会明白此处的绝对跳转对Python虚拟机执行此程序基本没有影响(除了增加一个指令执行周期),然而这个绝对跳转将成功欺骗反编译器。使用Uncompyle6反编译的结果如下:
<<< Error: Decompiling stopped due to <class 'uncompyle6.semantics.pysource.ParserError'>
如果一个pyc文件无法被反编译,初级的破解者可能就会止步于此了,但对于有经验的工程师来说这还远远不够。同样的,我们还要让通常的反汇编器也无法工作才行。按下面的汇编代码继续加工上面的sample1.pyc。
| 1 0 JUMP_ABSOLUTE [71 06 00] 6
| 3 LOAD_CONST [64 FF FF] 65535 (FAKE!)
| >> 6 LOAD_CONST [64 00 00] 0 (Hello World)
| 9 PRINT_ITEM [47 -- --]
| 10 PRINT_NEWLINE [48 -- --]
| 11 LOAD_CONST [64 01 00] 1 (None)
| 14 RETURN_VALUE [53 -- --]
以上第二条指令的意思是加载code object常量表的第65535项到栈顶。在上述sample1.pyc中,常量表的长度为2,下标65535已超出常量表的范围,所以这是条非法指令。但由于第一条绝对跳转的存在,第二条指令永远都不会被执行。通常的反汇编器如dis会尽全力列举有用的信息,但并不能理解实际执行的控制流,当反汇编器尝试反汇编第二条指令时,会试着去读取code object常量表的第65535项并且抛出一个’tuple index out of range’的意外。Python内置dis模块的出错信息如下:
>>> fd = open('sample1.pyc', 'rb')
>>> fd.seek(8)
>>> import marshal,dis
>>> sample1_code_obj = marshal.load(fd)
>>> dis.dis(sample1_code_obj)
1 0 JUMP_ABSOLUTE 6
3 LOAD_CONST 65535
Traceback (most recent call last):
File "" , line 1, in
File "C:\Python27\lib\dis.py", line 43, in dis
disassemble(x)
File "C:\Python27\lib\dis.py", line 96, in disassemble
print '(' + repr(co.co_consts[oparg]) + ')',
IndexError: tuple index out of range
>>>
现在Uncompyle6和dis都被欺骗了,代码得到了有效的保护。
开发者可以故意构造复杂的分支结构,然而通过预置条件来实现仅覆盖特定分支,可以有效的浪费手动逆向者的时间与精力,即便逆向者使用控制流分析软件也无济于事。
#flag可以是一些计算的结果
#或者是隐藏在某处的预置常量
#也可以是某次函数调用的返回值
if flag is condition:
normal_processing()
else
useless_but_complicated_obfuscating_code()
or_even_invalid_code()
try:
some_processing()
raise_exeception = __import__('module_does_not_exist')
#上面的调用将抛出一个'ImportError'的意外,控制流将转向except分支
useless_but_complicated_obfuscating_code()
except:
continue_normal_processing()
try:
some_processing()
raise_exeception = __import__('sys').non_exist_function()
#上面的调用将抛出一个'AttributeError'的意外,控制流将转向except分支
useless_but_complicated_obfuscating_code()
except:
continue_normal_processing()
try:
some_processing()
raise_exeception = 1/0
#上面的语句将抛出一个'ZeroDivisionError'的意外,控制流将转向except分支
useless_but_complicated_obfuscating_code()
except:
continue_normal_processing()
重叠指令(Overlapping Instruction)在有变长指令的CISC机器(如X86)上有广泛应用。以x86汇编举例说明重叠指令:
#例1单重叠指令
00: EB 01 jmp 3
02: 68 c3 90 90 90 push 0x909090c3
#例1实际执行
00: EB 01 jmp 3
03: C3 retn
#例2多重叠指令
00: EB02 jmp 4
02: 69846A40682C104000EB02 imul eax, [edx + ebp*2 + 0102C6840], 0x002EB0040
#例2实际执行
00: EB02 jmp 4
04: 6A40 push 040
06: 682C104000 push 0x40102C
0B: EB02 jmp 0xF
#例3跳转至自身
00: EBFF jmp 1
02: C0C300 rol bl, 0
#例3实际执行
00: EBFF jmp 1
01: FFC0 inc eax
03: C3 retn
与单一跳转指令相比,重叠指令是在跳转基础上进一步混淆控制流的技术手段,可以有效对抗逆向者。Python字节码类似于RISC指令(如ARM),其指令长度要么是三字节要么是一字节,但任然可以构造重叠指令:
#例1 Python单重叠指令
0 JUMP_ABSOLUTE [71 05 00] 5
3 PRINT_ITEM [47 -- --]
4 LOAD_CONST [64 64 01] 356
7 STOP_CODE [00 -- --]
#例1 实际执行
0 JUMP_ABSOLUTE [71 05 00] 5
5 LOAD_CONST [64 01 00] 1
#例2 Python多重叠指令
0 EXTENDED_ARG [91 00 64]
3 EXTENDED_ARG [91 00 53]
6 JUMP_ABSOLUTE [71 02 00]
#例2 实际执行
0 EXTENDED_ARG [91 00 64]
3 EXTENDED_ARG [91 00 53]
6 JUMP_ABSOLUTE [71 02 00]
2 LOAD_CONST [64 91 00]
5 RETURN_VALUE [53 -- --]
以上展示的是欺骗机器(反编译器和反汇编器)的技术,但是并不存在一种技术可以欺骗人类。对于愿意进行手动逆向的人来说,唯一可行的手段是增加其逆向的难度和时间成本。引入更复杂的控制流可以略微增加逆向的难度,但也不会太多, 有经验的破解者通常会对你的代码使用控制流分析软件。
代码扰乱可以在对抗人类的路上走得更远一些。真正的应用代码可以被加密存储在pyc文件的一个或者多个字符串常量中,程序执行时首先有一段解扰代码对加密存储的应用代码进行解扰,然后真正的应用代码被执行。精心设计的扰码算法可以对抗破解者静态分析你的应用代码。下面是一个简单的代码扰乱例子。
仍以上面的sample1.pyc为例,对其进行加扰:
>>> fd = open('sample1.pyc', 'rb')
>>> fd.seek(8)
>>> import marshal
>>> co = marshal.load(fd)
>>> fd.close()
>>> code_string = marshal.dumps(co)
>>> scrambled_code = code_string.encode('zlib').encode('base64')
>>> print scrambled_code
eJxLZoACRiB2AOJifiBRyMaQ8v9/CgODu0cKI0OwBhNIghtIeKTm5OQrhOcX5aT4aYC0oRHFXCAi
MbcgJ9VIr6CyhAPItcnNTynNSbUD2VACUgQAIHcTlg==
>>>
将加扰后的代码串拷贝到下面的descramble.py中
scrambled_code_string='eJxLZoACRiB2AOJifiBRyMaQ8v9/CgODu0cKI0OwBhNIghtIeKTm5OQrhOcX5aT4aYC0oRHFXCAiMbcgJ9VIr6CyhAPItcnNTynNSbUD2VACUgQAIHcTlg=='
exec __import__('marshal').loads(scrambled_code_string.decode('base64').decode('zlib'))
执行descrmble.py
>python descramble.py
Hello World
不要在意这个简单的加扰算法,本例只是展示加扰的概念。
字节码混淆(汇编混淆)在x86平台上早已广泛应用,并不是什么新技术,除了应用在Python上,其他使用字节码/汇编代码的编程语言应该都可以采用同样的原理进行代码保护。