Python 代码加密与保护

Python 代码加密与保护手册

1. 简介

Python作为一种解释型语言，其源代码容易被反编译和修改，尤其是在开源或部署后，用户可以很容易访问源代码。为了保护知识产权，防止非法复制、篡改、反编译和破解，我们需要结合多种技术对代码进行保护。

本手册详细介绍了如何通过PyInstaller、Cython、PyArmor等工具进行打包和加密，同时也介绍了如何利用加密狗、代码签名、动态加载、云服务授权等高级技术来提升代码的安全性和破解难度。

在 Windows 平台上，将 Python 程序“打包”为可执行程序（.exe）的方案很多有如下几种：

2. 使用 PyInstaller 打包成 EXE

PyInstaller 可以将 Python 程序打包为可执行文件，防止源代码被直接查看。它还可以将所有依赖打包成一个文件，方便部署。

操作步骤：

安装 PyInstaller
1
pip install pyinstaller

打包程序

在命令行中执行以下命令：

1	pyinstaller --onefile --noconsole your_program.py

部署

打包完成后，你会在 dist 文件夹下找到 your_program.exe，可以分发给用户。

优缺点：

优点：简单，生成一个独立的 EXE 文件，方便部署和分发。
缺点：不能完全防止逆向工程，打包的程序仍然可能被反编译。

3. 使用 PyArmor 进行代码加密

PyArmor 是一个强大的工具，可以对 Python 脚本进行加密，使其难以被反编译和逆向。它通过将源代码加密并生成加密后的 .py 文件，使破解变得更加困难。

操作步骤：

安装 PyArmor
1
pip install pyarmor
加密代码

使用以下命令加密代码：
1
pyarmor obfuscate your_program.py
运行加密代码

在部署时，用户运行加密的脚本，pyarmor 会在运行时解密并执行代码。
加密后的文件

dist 文件夹下生成的加密文件可与用户一起分发。

优缺点：

优点：能够有效阻止源代码被逆向，使用加密算法和保护机制大大提升破解难度。
缺点：加密过程可能导致一定的性能损耗，并且需要安装 pyarmor 库。

4. 使用 Cython 编译为 C 扩展

Cython 可以将 Python 代码转化为 C 代码，然后编译为二进制 .so 或 .pyd 文件。这种方式可以保护代码并提高执行效率。

操作步骤：

安装 Cython
1
pip install cython

编写 Cython 配置

创建一个 setup.py 文件，将 Python 代码转化为 C 语言扩展：

from setuptools import setup
from Cython.Build import cythonize

setup(
    ext_modules=cythonize("your_program.py")
)

编译

在命令行中运行以下命令生成 C 扩展：
1
python setup.py build_ext --inplace
部署

生成的 .pyd 文件是编译后的二进制文件，分发给用户时无需 Python 环境。

优缺点：

优点：生成的二进制代码可以有效防止源代码泄露，且性能较纯 Python 代码更高。
缺点：仍然有可能被通过反编译还原，但破解难度更高。

5. 使用 PyInstaller 与 Nuitka 混合打包

通过将 Nuitka 用于编译 .pyd 文件，并结合 PyInstaller 打包，可以提升保护的效果。

操作步骤：

安装 Nuitka
1
pip install nuitka
用 Nuitka 编译

使用以下命令编译 .pyd 文件：
1
nuitka --module your_program.py
用 PyInstaller 打包

将 .pyd 文件通过 PyInstaller 打包：
1
pyinstaller --onefile your_program.pyd
部署

生成的 EXE 文件可以分发给用户，并且源代码的保护得到了加强。

优缺点：

优点：多重保护，破解难度增加。
缺点：开发和打包过程更复杂，增加了构建时间。

6. 使用硬件加密狗保护

硬件加密狗提供了一种强大的方式来防止未授权的复制和使用。加密狗通过物理设备与软件绑定，程序运行时需要验证加密狗的合法性。

操作步骤：

选择加密狗

选择合适的加密狗，例如 Sentinel HASP。

集成 SDK

使用加密狗厂商提供的 SDK 集成到你的 Python 程序中。假设我们使用 Sentinel HASP，你可以通过以下方式验证加密狗的连接：

from hasp import hasp

def check_dongle():
    try:
        if hasp.login(0x12345678) == hasp.HASP_STATUS_OK:
            print("加密狗验证成功")
            return True
        else:
            print("加密狗验证失败")
            return False
    except Exception as e:
        print(f"加密狗错误: {e}")
        return False

验证与保护

用户在运行程序时，程序会检查加密狗是否正确连接，并且可以执行相应的授权逻辑。

优缺点：

优点：硬件加密狗提供了强力的保护，几乎不可破解。
缺点：依赖物理设备，用户需要携带加密狗才能使用程序，增加了使用的不便。

7. 云服务验证与许可证管理

通过在云端实现许可证验证，你可以确保软件只有在授权的情况下才能运行。

操作步骤：

创建云服务

你可以选择 AWS、Azure 或 自建服务器 来管理许可证和验证。

集成许可证验证

在 Python 程序中向云服务发出请求来验证许可证。

import requests

def validate_license(license_key):
    url = "https://your-cloud-service.com/validate"
    response = requests.post(url, data={"license_key": license_key})
    if response.status_code == 200:
        if response.json().get('valid') == True:
            print("许可证有效")
            return True
        else:
            print("许可证无效")
            return False
    else:
        print("无法连接到授权服务器")
        return False

部署

只要程序能够连接到云服务，它就会在运行时检查许可证的有效性。

优缺点：

优点：高效的云端验证和许可证管理，适合大规模部署。
缺点：需要依赖网络连接，可能会增加服务器成本。

8. 使用动态加载与代码加解密

通过加密和动态加载代码，程序在运行时才进行解密执行，增强了防破解能力。

操作步骤：

加密代码

使用加密算法对 Python 代码进行加密。以下是一个基于 AES 的加密代码示例：

from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
import os

key = os.urandom(32)
iv = os.urandom(16)

def encrypt_code(code):
    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
    encryptor = cipher.encryptor()
    return encryptor.update(code.encode()) + encryptor.finalize()

动态加载并解密代码

使用 exec 动态加载解密后的代码：

def decrypt_code(encrypted_code):
    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
    decryptor = cipher.decryptor()
    return decryptor.update(encrypted_code) + decryptor.finalize()

decrypted_code = decrypt_code(encrypted_code)
exec(decrypted_code)

部署

解密过程只在程序运行时进行，保证源代码不会被静态存储，增加破解难度。

优缺点：

优点：动态加载和加密解密使代码在运行时才解密执行，保护了源代码。
缺点：加密解密会导致一定的性能开销。

9. 代码签名

代码签名确保程序在分发时未被篡改，并且能够证明程序来源可信。

操作步骤：

购买代码签名证书

从认证机构（如 DigiCert）购买证书。

签署代码

使用 SignTool 对 .exe 文件进行签名：

1	signtool sign /f mycert.pfx /p mypassword /tr http://timestamp.digicert.com /td sha256 my_program.exe

部署

部署签名后的程序文件，用户可以通过验证签名来确认程序未被篡改。

优缺点：

优点：增强用户对程序的信任，确保程序来源可信。
缺点：需要购买证书，并管理签名过程。

10. 防止反编译：增加反调试与反反编译保护

反编译保护 是对 Python 程序进行额外保护，使其难以通过反编译工具（如 uncompyle6）还原代码。通过增加 反调试 和 反反编译 机制，可以让攻击者在尝试破解时更加困难。

操作步骤：

添加反调试代码

反调试可以防止调试工具（如 OllyDbg 或 IDA Pro）的调试功能。通过检查是否存在调试程序，程序可以避免在被调试的情况下执行。

import ctypes
import sys

def anti_debugging():
    try:
        is_debugger_present = ctypes.windll.kernel32.IsDebuggerPresent()
        if is_debugger_present:
            print("调试器检测到，程序将退出！")
            sys.exit()
    except Exception as e:
        print(f"反调试错误: {e}")

anti_debugging()

添加反反编译机制

通过代码混淆和增加控制流混乱，增加反编译的难度。你可以通过 PyArmor 或手动混淆代码，例如在程序中引入无用的代码和复杂的控制流结构，使其变得难以被逆向。

使用 Cython 和 C 扩展

编译 Python 文件为 C 扩展不仅使代码更难被反编译，还能通过复杂的 C 语言指令集使得破解难度大大增加。

# 使用 Cython 编译
from Cython.Build import cythonize
from setuptools import setup

setup(
    ext_modules=cythonize("your_program.pyx", compiler_directives={'language_level': 3})
)

优缺点：

优点：通过反调试与反反编译机制，增加了攻击者破解程序的难度。
缺点：实现较为复杂，并且可能会对程序的执行性能产生一定影响。

11. 动态加载与加解密保护

动态加载保护代码会使得 Python 程序的执行更加灵活。通过 动态加载 和 加解密 技术，源代码不会在磁盘上以明文形式存储，从而进一步增强程序的保护。

操作步骤：

加密代码并存储

采用 AES 或其他加密算法对 Python 文件进行加密。可以使用 Python 的 cryptography 库来加密脚本。

from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
import os

def encrypt_code(file_path, key, iv):
    with open(file_path, "rb") as f:
        data = f.read()

    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
    encryptor = cipher.encryptor()
    encrypted_data = encryptor.update(data) + encryptor.finalize()

    with open(f"{file_path}.enc", "wb") as enc_file:
        enc_file.write(encrypted_data)

# 使用 AES 加密脚本
encrypt_code("your_program.py", os.urandom(32), os.urandom(16))

动态加载加密文件

在程序运行时通过解密和动态加载文件。通过 exec() 函数执行解密后的代码。

def decrypt_code(file_path, key, iv):
    with open(file_path, "rb") as enc_file:
        encrypted_data = enc_file.read()

    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
    decryptor = cipher.decryptor()
    decrypted_data = decryptor.update(encrypted_data) + decryptor.finalize()

    return decrypted_data

# 解密并动态加载
decrypted_code = decrypt_code("your_program.py.enc", os.urandom(32), os.urandom(16))
exec(decrypted_code)

部署

部署时，程序仅存储加密后的文件，并且程序运行时会进行解密，动态加载并执行。

优缺点：

优点：有效增加源代码的保护，难以通过反编译恢复源代码。
缺点：增加了执行时的加密与解密开销，可能影响性能。

12. 使用自定义加密算法

自定义加密算法不仅能使代码更加安全，还能使攻击者更难以分析加密方案。你可以设计自己独特的加密解密算法，增强程序的防破解能力。

操作步骤：

设计自定义加密算法

例如，你可以设计基于字符替换的简单加密方案，在代码执行时进行加密和解密。

def encrypt(text, key):
    return ''.join([chr(ord(c) + key) for c in text])

def decrypt(text, key):
    return ''.join([chr(ord(c) - key) for c in text])

# 示例加密和解密
encrypted_text = encrypt("Hello World!", 3)
decrypted_text = decrypt(encrypted_text, 3)

将自定义加密应用于脚本

在代码中实现加密保护并在运行时动态解密。
部署

通过将加密和解密过程嵌入到程序中，部署时你可以分发加密后的脚本，程序运行时动态解密并执行。

优缺点：

优点：攻击者需要分析并破解自定义加密算法，相较于标准加密算法难度更大。
缺点：自定义加密算法可能影响性能，且容易被反复破解，因此需要足够的安全设计。

13. 使用多层加密

通过多层加密（比如加密 Python 文件、加密传输数据、加密内存数据等），你可以增强程序的安全性，增加破解的复杂性。

操作步骤：

加密 Python 文件

使用 PyArmor 或 Cython 对 Python 文件进行加密和编译。
加密传输数据

对程序和服务器之间的通信数据进行加密。比如，使用 TLS/SSL 或 加密协议 来加密客户端与服务器之间的数据传输。

加密内存数据

在程序中对敏感数据进行内存加密，避免内存被直接读取。

from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend

def encrypt_memory_data(data, key, iv):
    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
    encryptor = cipher.encryptor()
    return encryptor.update(data.encode()) + encryptor.finalize()

sensitive_data = "This is sensitive"
encrypted_data = encrypt_memory_data(sensitive_data, os.urandom(32), os.urandom(16))

部署

部署时采用多层加密保护，确保每一层都能增强程序的安全性。

优缺点：

优点：通过多层加密，增加了破解的复杂度和攻击者的工作量。
缺点：可能会带来较大的性能开销，尤其是在处理大量加密和解密操作时。

14. 代码混淆与变形

代码混淆是通过将代码变形，使得代码的原意不易理解，从而提高破解的难度。你可以使用工具如 PyArmor、pyobfuscate 或 xoreos 进行混淆。

操作步骤：

安装混淆工具
1
pip install pyobfuscate
混淆代码

使用混淆工具对 Python 代码进行混淆，增加破解难度。
1
pyobfuscate your_program.py --output your_program_obfuscated.py
部署

将混淆后的代码部署给用户，增加程序的安全性。

优缺点：

优点：通过将代码结构混淆，使得源代码难以理解和破解。
缺点：可能影响程序的可读性，调试过程较为困难。

15. 使用 PyStand 进行打包和加密保护

PyStand 是一个用于将 Python 脚本打包为可执行文件的工具，可以方便地将 Python 程序打包为 .pyd 或 .exe 文件。与 PyInstaller 和其他工具相比，PyStand 的优势在于，它能够提供更多的定制选项，能够灵活地进行加密保护。

操作步骤：

安装 PyStand

在终端中使用 pip 安装 pystand：
1
pip install pystand
创建 .pyd 文件

pystand 允许你将 Python 脚本编译为 .pyd 文件，并且支持自定义设置，使得 .pyd 文件可以方便地动态加载。
1
pystand your_script.py --output your_script.pyd
这里的 your_script.py 是你希望打包的 Python 脚本文件，--output 参数指定了生成的 .pyd 文件的名称。

加载加密的 .pyd 文件

在程序运行时，你可以使用 import 或 ctypes 动态加载加密后的 .pyd 文件。以下是一个使用 import 动态加载的示例：

import importlib.util
import sys

def load_pyd(pyd_path):
    spec = importlib.util.spec_from_file_location("module_name", pyd_path)
    foo = importlib.util.module_from_spec(spec)
    sys.modules["module_name"] = foo
    spec.loader.exec_module(foo)

load_pyd("your_script.pyd")

加密 .pyd 文件

在生成 .pyd 文件后，你可以使用加密手段对 .pyd 文件进行加密。在加密时，你可以选择使用 AES 或其他加密算法来保护 .pyd 文件内容。

from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend

def encrypt_pyd(pyd_file, key, iv):
    with open(pyd_file, "rb") as f:
        data = f.read()

    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
    encryptor = cipher.encryptor()
    encrypted_data = encryptor.update(data) + encryptor.finalize()

    with open(f"{pyd_file}.enc", "wb") as enc_file:
        enc_file.write(encrypted_data)

encrypt_pyd("your_script.pyd", os.urandom(32), os.urandom(16))

解密并执行

解密后的 .pyd 文件可以在运行时通过 exec 或 import 加载执行，增加了加密保护。

def decrypt_and_execute(pyd_file, key, iv):
    encrypted_data = decrypt_file(pyd_file, key, iv)
    exec(encrypted_data)

decrypt_and_execute("your_script.pyd.enc", os.urandom(32), os.urandom(16))

优缺点：

优点：
- 通过加密 .pyd 文件，增加了破解的难度。
- 支持动态加载，增强灵活性。
- 可以结合硬件加密狗、云验证等进行多重保护。
缺点：
- 增加了开发的复杂度。
- 解密和加载操作可能会影响程序性能。

16. 将 PyInstaller 和 PyStand 结合使用

如果你希望通过 PyInstaller 进行打包，同时使用 PyStand 进行加密保护，可以将两者结合，创建一个更加安全且具有高灵活性的打包方案。首先使用 PyInstaller 打包程序，然后使用 PyStand 对 .pyd 文件进行加密保护。

操作步骤：

使用 PyInstaller 打包

先通过 PyInstaller 打包你的程序，生成 .exe 文件。
1
pyinstaller --onefile your_script.py
将 .pyd 文件加密并动态加载

使用 PyStand 将 .pyd 文件加密，并在运行时动态加载和解密。
1
encrypt_pyd("your_script.pyd", os.urandom(32), os.urandom(16))
运行时解密并执行

在程序中加载并解密 .pyd 文件，使其具备更高的安全性。
1
decrypt_and_execute("your_script.pyd.enc", os.urandom(32), os.urandom(16))

优缺点：

优点：
- 可以结合 PyInstaller 的打包功能和 PyStand 的加密保护，增强程序的安全性。
- 使用动态加载的方式，使得源代码不容易被破解。
缺点：
- 开发和部署更加复杂。
- 加密和解密的过程可能影响程序执行效率。

17. 使用 Cython 和 PyStand 的结合方案

结合 Cython 和 PyStand，不仅可以通过 C 语言的方式将 Python 代码编译为 .pyd 文件，还可以使用 PyStand 进行加密保护。这样的方案能有效提高程序的安全性，防止反编译和破解。

操作步骤：

安装 Cython

使用以下命令安装 Cython，然后将 Python 代码编译为 C 扩展文件。
1
pip install cython

编译为 C 扩展文件

使用 Cython 将 .py 文件编译为 .c 文件，再编译为 .pyd 文件。

1 2	cython --embed -o your_program.c your_program.py gcc -o your_program.exe your_program.c $(python3-config --cflags --ldflags)

使用 PyStand 加密 .pyd 文件

使用 PyStand 对生成的 .pyd 文件进行加密保护。
1
2
3
4
5
python

复制编辑
encrypt_pyd("your_program.pyd", os.urandom(32), os.urandom(16))
加载加密的 .pyd 文件

动态加载加密后的 .pyd 文件，确保程序运行时的安全性。
1
decrypt_and_execute("your_program.pyd.enc", os.urandom(32), os.urandom(16))