通过字节码混淆来保护Python代码!这样别人就盗不了你的代码了!

<0x00> 前言

Python开发者常常面临这样一个难题，即如何保护代码中的技术秘密。笔者尝试过的一些Python代码保护工具要么难以有效实现该目标，要么有效但是有着不可忽视的缺点。最近笔者也遇到了这个问题，在难以找到一个有效解决方案的情况下，不得不自行开发了一个字节码混淆器。本文首先对常见的Python代码保护机制以及几个比较容易获得的Python代码保护工具进行了简单的分析，然后展示了通过字节码混淆来保护Python代码的技术原理。

<0x01> 源码混淆

笔者尝试过两个源码混淆工具。一个是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

1

2

3

4

5

6

7

8

9

10

11

12

13

其中变量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，需要注意这个问题。

<0x02> 将Python代码打包为可执行文件

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代码不失为一个好的选择。

<0x03> 使用私有Python Bytecode指令集

对于同一个版本的Python，Python编译器、解释器、反汇编器以及反编译器都使用同样的Bytecode指令集。不同版本的Python则使用不同的Bytecode指令集，这也是为何Python 2.X编译器产生的pyc文件无法被Python 3.x解释器执行的原因之一。

如果使用私有的Bytecode指令集，那么通常的Python反汇编器和反编译器无法工作在由你私有Python编译器产生的pyc文件上，也相当于保护了你的Python代码。这么做的代价是你的Python应用只能在你的私有Python解释器上运行。

<0x04> 字节码混淆

字节码混淆可以非常容易的欺骗通常的反汇编器和反编译器，同时不影响代码的正常执行。下面这个例子展示了如何欺骗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)

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。

| 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 "<stdin>", line 1, in <module>

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都被欺骗了，代码得到了有效的保护。

<0x05> 更多的字节码混淆技术

<0x05 0x01>虚假分支

私信小编007即可获取数十套PDF的下载地址哦！

开发者可以故意构造复杂的分支结构，然而通过预置条件来实现仅覆盖特定分支，可以有效的浪费手动逆向者的时间与精力，即便逆向者使用控制流分析软件也无济于事。

#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()

<0x05 0x02>重叠指令

重叠指令(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 -- --]

<0x06>对抗手动逆向工程

以上展示的是欺骗机器（反编译器和反汇编器）的技术，但是并不存在一种技术可以欺骗人类。对于愿意进行手动逆向的人来说，唯一可行的手段是增加其逆向的难度和时间成本。引入更复杂的控制流可以略微增加逆向的难度，但也不会太多， 有经验的破解者通常会对你的代码使用控制流分析软件。

代码扰乱可以在对抗人类的路上走得更远一些。真正的应用代码可以被加密存储在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

不要在意这个简单的加扰算法，本例只是展示加扰的概念。

<0x07>后记

字节码混淆（汇编混淆）在x86平台上早已广泛应用，并不是什么新技术，除了应用在Python上，其他使用字节码/汇编代码的编程语言应该都可以采用同样的原理进行代码保护。