在 现有Python 代码加密方案 篇中所述的几个方案，均是从源码的加工入手，或多或少都有些不足。假设我们从解释器的改造入手，会不会能够更好的保护代码呢？由于发行商业 Python 程序到客户环境时通常会包含一个 Python 解释器，如果改造解释器能解决源码保护的问题，那么也是可选的一条路。其具体思路如下：
假定我们有一个算法，能够加密原始的 Python 代码，这些加密后代码随发行程序一起，可被任何人看到，却难以破解。另一方面，有一个定制好的 Python 解释器，它能够解密这些被加密的代码，然后解释执行。而由于 Python 解释器本身是二进制文件，人们也就无法从解释器中获取解密的关键数据。从而达到了保护源码的目的。
要实现上述的设想，我们首先需要掌握基本的加解密算法，其次探究 Python 执行代码的方式从而了解在何处进行加解密，最后禁用字节码用以防止通过 .pyc 反编译。
一、加解密算法
1、 对称密钥加密算法
对称密钥加密（Symmetric-key algorithm）又称为对称加密、私钥加密、共享密钥加密，是密码学中的一类加密算法。这类算法在加密和解密时使用相同的密钥，或是使用两个可以简单地相互推算的密钥。对称加密算法的特点是算法公开、计算量小、加密速度快、加密效率高。常见的对称加密算法有：DES、3DES、AES、Blowfish、IDEA、RC5、RC6 等。对称密钥加解密过程如下：
明文 -----秘钥----->密文 明文 <-----秘钥-----密文
明文通过密钥加密成密文，密文也可通过相同的密钥解密为明文。通过 openssl 工具，我们能够方便选择对称加密算法进行加解密。下面我们以 AES 算法为例，介绍其用法。
AES 加密
# 指定密码进行对称加密 $ openssl enc -aes-128-cbc -in test.py -out entest.py -pass pass:123456 # 指定文件进行对称加密 $ openssl enc -aes-128-cbc -in test.py -out entest.py -pass file:passwd.txt # 指定环境变量进行对称加密 $ openssl enc -aes-128-cbc -in test.py -out entest.py -pass env:passwd
AES 解密
# 指定密码进行对称解密 $ openssl enc -aes-128-cbc -d -in entest.py -out test.py -pass pass:123456 # 指定文件进行对称解密 $ openssl enc -aes-128-cbc -d -in entest.py -out test.py -pass file:passwd.txt # 指定环境变量进行对称解密 $ 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 算法为例，介绍其用法。
生成私钥、公钥
# 辅以 AES-128 算法，生成 2048 比特长度的私钥 $ openssl genrsa -aes128 -out private.pem 2048 # 根据私钥来生成公钥 $ openssl rsa -in private.pem -outform PEM -pubout -out public.pem
RSA 加解密
# 使用公钥进行加密 openssl rsautl -encrypt -in passwd.txt -inkey public.pem -pubin -out enpasswd.txt # 使用私钥进行解密 openssl rsautl -decrypt -in enpasswd.txt -inkey private.pem -out passwd.txt
二、基于加密算法实现源码保护
1、 在构建环境进行加密
我们发行出去安装包中，源码应该是被加密过的，那么就需要在构建阶段对源码进行加密。加密的过程如下：
随机生成对称密钥A、非对称公钥B 源代码----密钥A---->加密代码 密钥A ----公钥B---->加密密钥
- 随机生成一个密钥。这个密钥实际上是一个用于对称加密的密码。
- 使用该密钥对源代码进行对称加密，生成加密后的代码。
- 使用公钥（生成方法见 非对称密钥加密算法）对该密钥进行非对称加密，生成加密后的密钥。
不论是加密后的代码还是加密后的密钥，都会放在安装包中。它们能够被用户看到，却无法被破译。而 Python 解释器该如何执行加密后的代码呢？
2 、Python 解释器进行解密
假定我们发行的 Python 解释器中内置了与公钥相对应的私钥，有了它就有了解密的可能。而由于 Python 解释器本身是二进制文件，所以不需要担心内置的私钥会被看到。解密的过程如下：
python解释器 ---------------------------- |加密密钥----私钥---->密钥 | |加密代码----密钥---->源代码 | --------------------------
- Python 解释器执行加密代码时需要被传入指示加密密钥的参数，通过这个参数，解释器获取到了加密密钥
- Python 解释器使用内置的私钥，对该加密密钥进行非对称解密，得到原始密钥
- Python 解释器使用原始密钥对加密代码进行对称解密，得到原始代码
- Python 解释器执行这段原始代码
可以看到，通过改造构建环节、定制 Python 解释器的执行过程，便可以实现保护源码的目的。改造构建环节是容易的，但是如何定制 Python 解释器呢？我们需要深入了解解释器执行脚本和模块的方式，才能在特定的入口进行控制。
三、脚本、模块的执行与解密
1、 执行 Python 代码的几种方式
为了找到 Python 解释器执行 Python 代码时的所有入口，我们需要首先执行 Python 解释器都能以怎样的方式执行代码。
直接运行脚本 python test.py 直接运行语句 python -c "print 'hello'" 直接运行模块 python -m test 导入、重载模块 python >>> import test # 导入模块 >>> reload(test) # 重载模块
直接运行语句 的方式接收的就是明文的代码，我们也无需对这种方式做额外处理。 直接运行模块和导入、重载模块这两种方式在流程上是殊途同归的，所以接下来会一起来看。 因此我们将分两种情况：运行脚本和加载模块来进一步探究各自的过程和解密方式。
2 、运行脚本时解密
运行脚本的过程 Python 解释器在运行脚本时的代码调用逻辑如下：
main WinMain
[Modules/python.c] [PC/WinMain.c]
\ /
\ /
\ /
\ /
\ /
Py_Main
[Moduls/main.c]Python 解释器运行脚本的入口函数因操作系统而异，在 Linux/Unix 系统上，主入口函数是 Modules/python.c 中的 main 函数，在 Windows系统上，则是 PC/WinMain.c 中的 WinMain 函数。不过这两个函数最终都会调用 Moduls/main.c 中的 Py_Main 函数。我们不妨来看看 Py_Main 函数中的相关逻辑：
[Modules/Main.c]
--------------------------------------
int
Py_Main(int argc, char **argv)
{
if (command) {
// 处理 python -c <command>
} else if (module) {
// 处理 python -m <module>
}
else {
// 处理 python <file>
...
fp = fopen(filename, "r");
...
}
}处理<command>和<module>的部分我们暂且先不管，在处理文件（通过直接运行脚本的方式）的逻辑中，可以看到解释打开了文件，获得了文件指针。那么如果我们把这里的 fopen 换成是自定义的 decrypt_open 函数，这个函数用来打开一个加密文件，然后进行解密，并返回一个文件指针，这个指针指向解密后的文件。那么，不就可以实现解密脚本的目的了吗？
自定义 decrypt_open 我们不妨新增一个 Modules/crypt.c 文件，用来存放一些自定义的加解密函数。decrypt_open 函数大概实现如下：
[Modules/crypt.c]
--------------------------------------
/* 以解密方式打开文件 */
FILE *
decrypt_open(const char *filename, const char *mode)
{
int plainlen = -1;
char *plaintext = NULL;
FILE *fp = NULL;
if (aes_passwd == NULL)
fp = fopen(filename, "r");
else {
plainlen = aes_decrypt(filename, aes_passwd, &plaintext);
// 如果无法解密，返回源文件描述符
if (plainlen < 0)
fp = fopen(filename, "r");
// 否则，转换为内存文件描述符
else
fp = fmemopen(plaintext, plainlen, "r");
}
return fp;
}这里的 aes_passwd 是一个全局变量，代表对称加密算法中的密钥。我们暂时假定已经获取该密钥了，后文会说明如何获得。而 aes_decrypt 是自定义的一个使用AES算法进行对称解密的函数，限于篇幅，此函数的实现不再贴出。
decrypt_open 逻辑如下： – 判断是否获得了对称密钥，如果没获得，直接打开该文件并返回文件指针 – 如果获得了，则尝试使用对称算法进行解密 – 如果解密失败，可能就是一段非加密的脚本，直接打开该文件并返回文件指针 – 如果解密成功，我们通过解密后的内容创建一个内存文件对象，并返回该文件指针。实现了上述这些函数后，我们就能够实现在直接运行脚本时，解密执行被加密代码的目的。
3 、加载模块时解密
加载模块的过程 加载模块的逻辑主要实现在 Python/import.c 文件中，其过程如下：
Py_Main
[Moduls/main.c]
|
builtin___import__ RunModule
| |
PyImport_ImportModuleLevel <----┐ PyImport_ImportModule
| | |
import_module_level └------- PyImport_Import
|
load_next builtin_reload
| |
import_submodule PyImport_ReloadModule
| |
find_module <---------------------------┘- 通过 python -m <module> 的方式来加载模块时，其入口函数是 Py_Main 函数
- 通过 import <module> 的方式来加载模块时，其入口函数是 builtin___import__ 函数
- 通过 reload(<module>) 的方式来加载模块时，其入口函数是 builtin_reload 函数
但不论是哪种方式，最终都会调用 find_module 函数，我们看看这个函数中是否暗藏乾坤呢？
[Python/import.c]
--------------------------------------
static struct filedescr *
find_module(char *fullname, char *subname, PyObject *path, char *buf,
size_t buflen, FILE **p_fp, PyObject **p_loader)
{
...
fp = fopen(buf, filemode);
...
}我们在 find_module 函数中找到了打开文件的逻辑，如果直接改成前文实现的 decrypt_open，岂不是就能达成加载模块时解密的目的了？
总体思路是这样的，但有个细节需要注意，buf 不一定就是 .py 文件，也可能是 .pyc 文件，我们只对 .py 文件做改动，则可以这么写：
[Python/import.c]
--------------------------------------
static struct filedescr *
find_module(char *fullname, char *subname, PyObject *path, char *buf,
size_t buflen, FILE **p_fp, PyObject **p_loader)
{
...
if (fdp->type == PY_SOURCE) {
fp = decrypt_open(buf, filemode);
}
else {
fp = fopen(buf, filemode);
}
...
}经过上述改动，就实现了加载模块时解密的目的了。
4 、支持指定密钥文件
前文中还留有一个待解决的问题：我们一开始是假定解释器已获取到了密钥内容并存放在了全局变量 aes_passwd 中，那么密钥内容怎么获取呢？
我们需要 Python 解释器能支持一个新的参数选项，通过它来指定已加密的密钥文件，然后再通过非对称算法进行解密，得到 aes_passed。 假定这个参数选项是 -k <filename>，则可使用如 python -k enpasswd.txt 的方式来告知解释器加密密钥的文件路径。其实现如下：
[Modules/main.c]
--------------------------------------
/* 命令行选项，注意k:是新增的内容 */
#define BASE_OPTS "3bBc:dEhiJk:m:OQ:RsStuUvVW:xX?"
...
/* Long usage message, split into parts < 512 bytes */
static char *usage_1 = "\
...
-k key : decrypt source file by using key file\n\
...
";
...
int
Py_Main(int argc, char **argv)
{
...
char *keyfilename = NULL;
...
while ((c = _PyOS_GetOpt(argc, argv, PROGRAM_OPTS)) != EOF) {
...
case 'k':
keyfilename = (char *)malloc(strlen(_PyOS_optarg) + 1);
if (keyfilename == NULL)
Py_FatalError(
"not enough memory to copy -k argument");
strcpy(keyfilename, _PyOS_optarg);
keyfilename[strlen(_PyOS_optarg)] = '\0';
break;
...
}
...
if (keyfilename != NULL) {
int passwdlen;
char *passwd = NULL;
passwdlen = rsa_decrypt(keyfilename, &passwd);
set_aes_passwd(passwd);
if (passwdlen < 0) {
fprintf(stderr, "%s: parsing key file '%s' error\n", argv[0], keyfilename);
free(keyfilename);
return 2;
} else {
free(keyfilename);
}
}
...
}其逻辑如下： – k:中的 k 表示支持 -k 选项；: 表示选项后跟一个参数，即这里的已加密密钥文件的路径 – 解释器在处理到 -k 参数时，获取其后所跟的文件路径，记录在 keyfilename 中 – 使用自定义的 rsa_decrypt 函数（限于篇幅，不列出如何实现的逻辑）对已加密密钥文件进行非对称解密，获得密钥的原始内容 – 将该密钥内容写入到 aes_passwd 中。
由此，通过显示地指定已加密密钥文件，解释器获得了原始密钥，进而通过该密钥解密已加密代码，再执行原始代码。但是，这里面还潜藏着一个风险：执行代码的过程中会生成 .pyc 文件，通过它反编译出的 .py 文件是未加密的。换句话说，恶意用户可以通过这种手段绕过限制。所以，我们需要 禁用字节码。
四、禁用字节码
1、不生成 .pyc 文件
首先要做的就是不生成 .pyc 文件，这样，恶意用户就没法直接根据 .pyc 文件来得到源码。我们知道，通过 -B 选项可以告知 Python 解释器不生成 .pyc 文件。既然定制的 Python 解释器就不生成 .pyc 我们干脆禁用这个选项：
[Modules/main.c]
--------------------------------------
/* 命令行选项，注意移除了B */
#define BASE_OPTS "3bc:dEhiJm:OQ:RsStuUvVW:xX?"
...
/* Long usage message, split into parts < 512 bytes */
static char *usage_1 = "\
...
//-B : don't write .py[co] files on import; also PYTHONDONTWRITEBYTECODE=x\n\
...
";
...
int
Py_Main(int argc, char **argv)
{
...
// 不生成 py[co]
Py_DontWriteBytecodeFlag++;
...
}除此以外，Python 解释器还会从环境变量中获取是否不生成 .pyc 文件，因此也需要做处理：
[Python/pythonrun.c]
--------------------------------------
void
Py_InitializeEx(int install_sigs)
{
...
f ((p = Py_GETENV("PYTHONDEBUG")) && *p != '\0')
Py_DebugFlag = add_flag(Py_DebugFlag, p);
if ((p = Py_GETENV("PYTHONVERBOSE")) && *p != '\0')
Py_VerboseFlag = add_flag(Py_VerboseFlag, p);
if ((p = Py_GETENV("PYTHONOPTIMIZE")) && *p != '\0')
Py_OptimizeFlag = add_flag(Py_OptimizeFlag, p);
// 移除对 PYTHONDONTWRITEBYTECODE 的处理
if ((p = Py_GETENV("PYTHONDONTWRITEBYTECODE")) && *p != '\0')
Py_DontWriteBytecodeFlag = add_flag(Py_DontWriteBytecodeFlag, p);
...
} 2、禁止访问字节码对象 co_code
仅仅是不生成 .pyc 文件还是不够的，恶意用户已然可以访问对象的 co_code 属性来获取字节码，进而通过反编译的手段获取到源码。因此，我们也需要禁止用户访问字节码对象：
[Objects/codeobject.c]
--------------------------------------
static PyMemberDef code_memberlist[] = {
{"co_argcount", T_INT, OFF(co_argcount), READONLY},
{"co_nlocals", T_INT, OFF(co_nlocals), READONLY},
{"co_stacksize",T_INT, OFF(co_stacksize), READONLY},
{"co_flags", T_INT, OFF(co_flags), READONLY},
// {"co_code", T_OBJECT, OFF(co_code), READONLY},
{"co_consts", T_OBJECT, OFF(co_consts), READONLY},
{"co_names", T_OBJECT, OFF(co_names), READONLY},
{"co_varnames", T_OBJECT, OFF(co_varnames), READONLY},
{"co_freevars", T_OBJECT, OFF(co_freevars), READONLY},
{"co_cellvars", T_OBJECT, OFF(co_cellvars), READONLY},
{"co_filename", T_OBJECT, OFF(co_filename), READONLY},
{"co_name", T_OBJECT, OFF(co_name), READONLY},
{"co_firstlineno", T_INT, OFF(co_firstlineno), READONLY},
{"co_lnotab", T_OBJECT, OFF(co_lnotab), READONLY},
{NULL} /* Sentinel */
};到此，一个定制的 Python 解释器完成了。
五、运行效果
1、运行脚本
通过 -k 选项执行已加密密钥文件，Python 解释器可以运行已加密和未加密的 Python 文件。
2、加载模块
可以通过 -m <module> 的方式加载已加密和未加密的模块，也可以通过 import <module> 的方式来加载已加密和未加密的模块。
3、禁用字节码
通过禁用字节码，我们达到以下效果： – 不会生成 .pyc 文件 – 可以访问函数的 func_code – 无法访问代码对象的 co_code，即本示例中的 f.func_code.co_code – 无法使用dis模块来获取字节码
4、异常堆栈信息
尽管代码是加密的，但是不会影响异常时的堆栈信息。
5 、调试
加密的代码也是允许调试的，但是输出的代码内容会是加密的，这正是我们所期望的。
六，其他
如何防止通过内存操作的方式找到对象的co_code?
如何进一步提升私钥被逆向工程探知的难度？
如何能在调试并希望看到源码的时候看到?