通过字节码混淆来保护Python代码

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 "<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 0x01>虚假分支

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

#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 -- --]

以上展示的是欺骗机器（反编译器和反汇编器）的技术，但是并不存在一种技术可以欺骗人类。对于愿意进行手动逆向的人来说，唯一可行的手段是增加其逆向的难度和时间成本。引入更复杂的控制流可以略微增加逆向的难度，但也不会太多， 有经验的破解者通常会对你的代码使用控制流分析软件。
代码扰乱可以在对抗人类的路上走得更远一些。真正的应用代码可以被加密存储在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上，其他使用字节码/汇编代码的编程语言应该都可以采用同样的原理进行代码保护。