在 现有Python 代码加密方案 篇中所述的几个方案，均是从源码的加工入手，或多或少都有些不足。假设我们从解释器的改造入手，会不会能够更好的保护代码呢？由于发行商业 Python 程序到客户环境时通常会包含一个 Python 解释器，如果改造解释器能解决源码保护的问题，那么也是可选的一条路。其具体思路如下：

假定我们有一个算法，能够加密原始的 Python 代码，这些加密后代码随发行程序一起，可被任何人看到，却难以破解。另一方面，有一个定制好的 Python 解释器，它能够解密这些被加密的代码，然后解释执行。而由于 Python 解释器本身是二进制文件，人们也就无法从解释器中获取解密的关键数据。从而达到了保护源码的目的。

要实现上述的设想，我们首先需要掌握基本的加解密算法，其次探究 Python 执行代码的方式从而了解在何处进行加解密，最后禁用字节码用以防止通过 .pyc 反编译。

一、加解密算法

1、 对称密钥加密算法

对称密钥加密（Symmetric-key algorithm）又称为对称加密、私钥加密、共享密钥加密，是密码学中的一类加密算法。这类算法在加密和解密时使用相同的密钥，或是使用两个可以简单地相互推算的密钥。对称加密算法的特点是算法公开、计算量小、加密速度快、加密效率高。常见的对称加密算法有：DES、3DES、AES、Blowfish、IDEA、RC5、RC6 等。对称密钥加解密过程如下：

明文 —–秘钥—–>密文
明文 <—–秘钥—–密文

明文通过密钥加密成密文，密文也可通过相同的密钥解密为明文。通过 openssl 工具，我们能够方便选择对称加密算法进行加解密。下面我们以 AES 算法为例，介绍其用法。

AES 加密

1# 指定密码进行对称加密
2$ openssl enc -aes-128-cbc -in test.py -out entest.py -pass pass:123456
3# 指定文件进行对称加密
4$ openssl enc -aes-128-cbc -in test.py -out entest.py -pass file:passwd.txt
5# 指定环境变量进行对称加密
6$ openssl enc -aes-128-cbc -in test.py -out entest.py -pass env:passwd

AES 解密

1# 指定密码进行对称解密
2$ openssl enc -aes-128-cbc -d -in entest.py -out test.py -pass pass:123456
3# 指定文件进行对称解密
4$ openssl enc -aes-128-cbc -d -in entest.py -out test.py -pass file:passwd.txt
5# 指定环境变量进行对称解密
6$ openssl enc -aes-128-cbc -d -in entest.py -out test.py -pass env:passwd

2 、非对称密钥加密算法

密钥加密（英语：public-key cryptography，又译为公开密钥加密），也称为非对称加密（asymmetric cryptography），一种密码学算法类型，在这种密码学方法中，需要一对密钥，一个是私钥，另一个则是公钥。这两个密钥是数学相关，用某用户公钥加密后所得的信息，只能用该用户的私钥才能解密。

非对称加密算法的特点是算法强度复杂、安全性依赖于算法与密钥但是由于其算法复杂，而使得加密解密速度没有对称加密解密的速度快。常见的对称加密算法有：RSA、Elgamal、背包算法、Rabin、D-H、ECC 等。非对称密钥加解密过程如下：

明文 —–公钥—–>密文—–私钥—–>明文

明文通过公钥加密成密文，密文通过与公钥对应的私钥解密为明文。通过 openssl 工具，我们能够方便选择非对称加密算法进行加解密。下面我们以 RSA 算法为例，介绍其用法。

生成私钥、公钥

1# 辅以 AES-128 算法，生成 2048 比特长度的私钥
2$ openssl genrsa -aes128 -out private.pem 2048
3# 根据私钥来生成公钥
4$ openssl rsa -in private.pem -outform PEM -pubout -out public.pem

RSA 加解密

1# 使用公钥进行加密
2openssl rsautl -encrypt -in passwd.txt -inkey public.pem -pubin -out enpasswd.txt
3# 使用私钥进行解密
4openssl rsautl -decrypt -in enpasswd.txt -inkey private.pem -out passwd.txt

二、基于加密算法实现源码保护

1、 在构建环境进行加密

我们发行出去安装包中，源码应该是被加密过的，那么就需要在构建阶段对源码进行加密。加密的过程如下：

随机生成对称密钥A、非对称公钥B
源代码—-密钥A—->加密代码
密钥A —-公钥B—->加密密钥

  1. 随机生成一个密钥。这个密钥实际上是一个用于对称加密的密码。
  2. 使用该密钥对源代码进行对称加密，生成加密后的代码。
  3. 使用公钥（生成方法见 非对称密钥加密算法）对该密钥进行非对称加密，生成加密后的密钥。

不论是加密后的代码还是加密后的密钥，都会放在安装包中。它们能够被用户看到，却无法被破译。而 Python 解释器该如何执行加密后的代码呢？

2 、Python 解释器进行解密

假定我们发行的 Python 解释器中内置了与公钥相对应的私钥，有了它就有了解密的可能。而由于 Python 解释器本身是二进制文件，所以不需要担心内置的私钥会被看到。解密的过程如下：

1python解释器
2----------------------------
3|加密密钥----私钥---->密钥   |
4|加密代码----密钥---->源代码 |
5--------------------------
  1. Python 解释器执行加密代码时需要被传入指示加密密钥的参数，通过这个参数，解释器获取到了加密密钥
  2. Python 解释器使用内置的私钥，对该加密密钥进行非对称解密，得到原始密钥
  3. Python 解释器使用原始密钥对加密代码进行对称解密，得到原始代码
  4. Python 解释器执行这段原始代码

可以看到，通过改造构建环节、定制 Python 解释器的执行过程，便可以实现保护源码的目的。改造构建环节是容易的，但是如何定制 Python 解释器呢？我们需要深入了解解释器执行脚本和模块的方式，才能在特定的入口进行控制。

三、脚本、模块的执行与解密

1、 执行 Python 代码的几种方式

为了找到 Python 解释器执行 Python 代码时的所有入口，我们需要首先执行 Python 解释器都能以怎样的方式执行代码。

 1直接运行脚本
 2python test.py
 3
 4直接运行语句
 5python -c "print 'hello'"
 6
 7直接运行模块
 8python -m test
 9
10导入、重载模块
11python
12>>> import test  # 导入模块
13>>> reload(test)  # 重载模块

直接运行语句 的方式接收的就是明文的代码，我们也无需对这种方式做额外处理。 直接运行模块和导入、重载模块这两种方式在流程上是殊途同归的，所以接下来会一起来看。 因此我们将分两种情况：运行脚本和加载模块来进一步探究各自的过程和解密方式。

2 、运行脚本时解密

运行脚本的过程 Python 解释器在运行脚本时的代码调用逻辑如下：

1       main            WinMain
2[Modules/python.c] [PC/WinMain.c]
3             \         /
4              \       /
5               \     /
6                \   /
7                 \ /
8               Py_Main
9           [Moduls/main.c]

Python 解释器运行脚本的入口函数因操作系统而异，在 Linux/Unix 系统上，主入口函数是 Modules/python.c 中的 main 函数，在 Windows系统上，则是 PC/WinMain.c 中的 WinMain 函数。不过这两个函数最终都会调用 Moduls/main.c 中的 Py_Main 函数。我们不妨来看看 Py_Main 函数中的相关逻辑：

 1[Modules/Main.c]
 2--------------------------------------
 3int
 4Py_Main(int argc, char **argv)
 5{
 6    if (command) {
 7        // 处理 python -c <command>
 8    } else if (module) {
 9        // 处理 python -m <module>
10    }
11    else {
12        // 处理 python <file>
13        ...
14        fp = fopen(filename, "r");
15        ...
16    }
17}

处理和的部分我们暂且先不管，在处理文件（通过直接运行脚本的方式）的逻辑中，可以看到解释打开了文件，获得了文件指针。那么如果我们把这里的 fopen 换成是自定义的 decrypt_open 函数，这个函数用来打开一个加密文件，然后进行解密，并返回一个文件指针，这个指针指向解密后的文件。那么，不就可以实现解密脚本的目的了吗？

自定义 decrypt_open 我们不妨新增一个 Modules/crypt.c 文件，用来存放一些自定义的加解密函数。decrypt_open 函数大概实现如下：

 1[Modules/crypt.c]
 2--------------------------------------
 3/* 以解密方式打开文件 */
 4FILE *
 5decrypt_open(const char *filename, const char *mode)
 6{
 7    int plainlen = -1;
 8    char *plaintext = NULL;
 9    FILE *fp = NULL;
10    if (aes_passwd == NULL)
11        fp = fopen(filename, "r");
12    else {
13        plainlen = aes_decrypt(filename, aes_passwd, &plaintext);
14        // 如果无法解密，返回源文件描述符
15        if (plainlen < 0)
16            fp = fopen(filename, "r");
17        // 否则，转换为内存文件描述符
18        else
19            fp = fmemopen(plaintext, plainlen, "r");
20    }
21    return fp;
22}

这里的 aes_passwd 是一个全局变量，代表对称加密算法中的密钥。我们暂时假定已经获取该密钥了，后文会说明如何获得。而 aes_decrypt 是自定义的一个使用AES算法进行对称解密的函数，限于篇幅，此函数的实现不再贴出。

decrypt_open 逻辑如下： – 判断是否获得了对称密钥，如果没获得，直接打开该文件并返回文件指针 – 如果获得了，则尝试使用对称算法进行解密 – 如果解密失败，可能就是一段非加密的脚本，直接打开该文件并返回文件指针 – 如果解密成功，我们通过解密后的内容创建一个内存文件对象，并返回该文件指针。实现了上述这些函数后，我们就能够实现在直接运行脚本时，解密执行被加密代码的目的。

3 、加载模块时解密

加载模块的过程 加载模块的逻辑主要实现在 Python/import.c 文件中，其过程如下：

 1Py_Main
 2                                         [Moduls/main.c]
 3                                                |
 4    builtin___import__                      RunModule
 5            |                                   |
 6PyImport_ImportModuleLevel <----┐     PyImport_ImportModule
 7            |                   |               |
 8    import_module_level         └------- PyImport_Import
 9            |
10         load_next                         builtin_reload
11            |                                   |
12      import_submodule                PyImport_ReloadModule
13            |                                   |
14        find_module <---------------------------┘
  • 通过 python -m 的方式来加载模块时，其入口函数是 Py_Main 函数
  • 通过 import 的方式来加载模块时，其入口函数是 builtin___import__ 函数
  • 通过 reload() 的方式来加载模块时，其入口函数是 builtin_reload 函数

但不论是哪种方式，最终都会调用 find_module 函数，我们看看这个函数中是否暗藏乾坤呢？

 1[Python/import.c]
 2--------------------------------------
 3static struct filedescr *
 4find_module(char *fullname, char *subname, PyObject *path, char *buf,
 5            size_t buflen, FILE **p_fp, PyObject **p_loader)
 6{
 7    ...
 8    fp = fopen(buf, filemode);
 9    ...
10}

我们在 find_module 函数中找到了打开文件的逻辑，如果直接改成前文实现的 decrypt_open，岂不是就能达成加载模块时解密的目的了？

总体思路是这样的，但有个细节需要注意，buf 不一定就是 .py 文件，也可能是 .pyc 文件，我们只对 .py 文件做改动，则可以这么写：

 1[Python/import.c]
 2--------------------------------------
 3static struct filedescr *
 4find_module(char *fullname, char *subname, PyObject *path, char *buf,
 5            size_t buflen, FILE **p_fp, PyObject **p_loader)
 6{
 7    ...
 8    if (fdp->type == PY_SOURCE) {
 9        fp = decrypt_open(buf, filemode);
10    }
11    else {
12        fp = fopen(buf, filemode);
13    }
14    ...
15}

经过上述改动，就实现了加载模块时解密的目的了。

4 、支持指定密钥文件

前文中还留有一个待解决的问题：我们一开始是假定解释器已获取到了密钥内容并存放在了全局变量 aes_passwd 中，那么密钥内容怎么获取呢？

我们需要 Python 解释器能支持一个新的参数选项，通过它来指定已加密的密钥文件，然后再通过非对称算法进行解密，得到 aes_passed。 假定这个参数选项是 -k ，则可使用如 python -k enpasswd.txt 的方式来告知解释器加密密钥的文件路径。其实现如下：

 1[Modules/main.c]
 2--------------------------------------
 3/* 命令行选项，注意k:是新增的内容 */
 4#define BASE_OPTS "3bBc:dEhiJk:m:OQ:RsStuUvVW:xX?"
 5...
 6/* Long usage message, split into parts < 512 bytes */
 7static char *usage_1 = "\
 8...
 9-k key : decrypt source file by using key file\n\
10...
11";
12...
13int
14Py_Main(int argc, char **argv)
15{
16    ...
17    char *keyfilename = NULL;
18    ...
19    while ((c = _PyOS_GetOpt(argc, argv, PROGRAM_OPTS)) != EOF) {
20        ...
21        case 'k':
22            keyfilename = (char *)malloc(strlen(_PyOS_optarg) + 1);
23            if (keyfilename == NULL)
24                Py_FatalError(
25                   "not enough memory to copy -k argument");
26            strcpy(keyfilename, _PyOS_optarg);
27            keyfilename[strlen(_PyOS_optarg)] = '\0';
28            break;
29        ...
30    }
31    ...
32    if (keyfilename != NULL) {
33        int passwdlen;
34        char *passwd = NULL;
35        passwdlen = rsa_decrypt(keyfilename, &passwd);
36        set_aes_passwd(passwd);
37        if (passwdlen < 0) {
38            fprintf(stderr, "%s: parsing key file '%s' error\n", argv[0], keyfilename);
39            free(keyfilename);
40            return 2;
41        } else {
42            free(keyfilename);
43        }
44    }
45    ...
46}

其逻辑如下： – k:中的 k 表示支持 -k 选项；: 表示选项后跟一个参数，即这里的已加密密钥文件的路径 – 解释器在处理到 -k 参数时，获取其后所跟的文件路径，记录在 keyfilename 中 – 使用自定义的 rsa_decrypt 函数（限于篇幅，不列出如何实现的逻辑）对已加密密钥文件进行非对称解密，获得密钥的原始内容 – 将该密钥内容写入到 aes_passwd 中。

由此，通过显示地指定已加密密钥文件，解释器获得了原始密钥，进而通过该密钥解密已加密代码，再执行原始代码。但是，这里面还潜藏着一个风险：执行代码的过程中会生成 .pyc 文件，通过它反编译出的 .py 文件是未加密的。换句话说，恶意用户可以通过这种手段绕过限制。所以，我们需要 禁用字节码。

四、禁用字节码

1、不生成 .pyc 文件

首先要做的就是不生成 .pyc 文件，这样，恶意用户就没法直接根据 .pyc 文件来得到源码。我们知道，通过 -B 选项可以告知 Python 解释器不生成 .pyc 文件。既然定制的 Python 解释器就不生成 .pyc 我们干脆禁用这个选项：

 1[Modules/main.c]
 2--------------------------------------
 3/* 命令行选项，注意移除了B */
 4#define BASE_OPTS "3bc:dEhiJm:OQ:RsStuUvVW:xX?"
 5...
 6/* Long usage message, split into parts < 512 bytes */
 7static char *usage_1 = "\
 8...
 9//-B     : don't write .py[co] files on import; also PYTHONDONTWRITEBYTECODE=x\n\
10...
11";
12...
13int
14Py_Main(int argc, char **argv)
15{
16    ...
17    // 不生成 py[co]
18    Py_DontWriteBytecodeFlag++;
19    ...
20}

除此以外，Python 解释器还会从环境变量中获取是否不生成 .pyc 文件，因此也需要做处理：

 1[Python/pythonrun.c]
 2--------------------------------------
 3void
 4Py_InitializeEx(int install_sigs)
 5{
 6    ...
 7    f ((p = Py_GETENV("PYTHONDEBUG")) && *p != '\0')
 8        Py_DebugFlag = add_flag(Py_DebugFlag, p);
 9    if ((p = Py_GETENV("PYTHONVERBOSE")) && *p != '\0')
10        Py_VerboseFlag = add_flag(Py_VerboseFlag, p);
11    if ((p = Py_GETENV("PYTHONOPTIMIZE")) && *p != '\0')
12        Py_OptimizeFlag = add_flag(Py_OptimizeFlag, p);
13    // 移除对 PYTHONDONTWRITEBYTECODE 的处理
14    if ((p = Py_GETENV("PYTHONDONTWRITEBYTECODE")) && *p != '\0')
15        Py_DontWriteBytecodeFlag = add_flag(Py_DontWriteBytecodeFlag, p);
16    ...
17}

2、禁止访问字节码对象 co_code

仅仅是不生成 .pyc 文件还是不够的，恶意用户已然可以访问对象的 co_code 属性来获取字节码，进而通过反编译的手段获取到源码。因此，我们也需要禁止用户访问字节码对象：

 1[Objects/codeobject.c]
 2--------------------------------------
 3static PyMemberDef code_memberlist[] = {
 4    {"co_argcount",     T_INT,          OFF(co_argcount),       READONLY},
 5    {"co_nlocals",      T_INT,          OFF(co_nlocals),        READONLY},
 6    {"co_stacksize",T_INT,              OFF(co_stacksize),      READONLY},
 7    {"co_flags",        T_INT,          OFF(co_flags),          READONLY},
 8    // {"co_code",         T_OBJECT,       OFF(co_code),           READONLY},
 9    {"co_consts",       T_OBJECT,       OFF(co_consts),         READONLY},
10    {"co_names",        T_OBJECT,       OFF(co_names),          READONLY},
11    {"co_varnames",     T_OBJECT,       OFF(co_varnames),       READONLY},
12    {"co_freevars",     T_OBJECT,       OFF(co_freevars),       READONLY},
13    {"co_cellvars",     T_OBJECT,       OFF(co_cellvars),       READONLY},
14    {"co_filename",     T_OBJECT,       OFF(co_filename),       READONLY},
15    {"co_name",         T_OBJECT,       OFF(co_name),           READONLY},
16    {"co_firstlineno", T_INT,           OFF(co_firstlineno),    READONLY},
17    {"co_lnotab",       T_OBJECT,       OFF(co_lnotab),         READONLY},
18    {NULL}      /* Sentinel */
19};

到此，一个定制的 Python 解释器完成了。

五、运行效果

1、运行脚本

通过 -k 选项执行已加密密钥文件，Python 解释器可以运行已加密和未加密的 Python 文件。

python-run-key
python-run-key

2、加载模块

可以通过 -m 的方式加载已加密和未加密的模块，也可以通过 import 的方式来加载已加密和未加密的模块。

spython-module
spython-module

3、禁用字节码

通过禁用字节码，我们达到以下效果： – 不会生成 .pyc 文件 – 可以访问函数的 func_code – 无法访问代码对象的 co_code，即本示例中的 f.func_code.co_code – 无法使用dis模块来获取字节码

spython-discode
spython-discode

4、异常堆栈信息

尽管代码是加密的，但是不会影响异常时的堆栈信息。

spython-enraise
spython-enraise

5 、调试

加密的代码也是允许调试的，但是输出的代码内容会是加密的，这正是我们所期望的。

spython-strace
spython-strace

六，其他

如何防止通过内存操作的方式找到对象的co_code?
如何进一步提升私钥被逆向工程探知的难度？
如何能在调试并希望看到源码的时候看到?