240802-Python代码混淆及加密的一些工具

1. 有哪些开源免费的工具，可以对Python代码加密

加密Python代码可以通过多种方法实现，尽管这些方法主要是为了保护代码不被轻易阅读或修改，但无法完全防止逆向工程。以下是一些开源免费的工具和方法，可以用于加密Python代码：

1. PyArmor：
   PyArmor是一款用于保护Python脚本的工具。它通过加密和混淆代码来保护Python脚本。PyArmor是一个开源工具，但也有一些高级功能需要购买许可证。

   官方链接：PyArmor

2. Cython：
   Cython是一种将Python代码编译为C扩展模块的工具，通过将Python代码转换为C代码并编译为二进制文件，可以增加代码的安全性和执行效率。

   官方链接：Cython

3. py2exe：
   py2exe可以将Python脚本打包成Windows可执行文件（.exe），从而保护代码。虽然py2exe并不直接加密代码，但通过将代码打包成二进制文件，增加了代码的安全性。

   官方链接：py2exe

4. PyInstaller：
   PyInstaller是一款将Python应用程序打包为独立可执行文件的工具，支持Windows、Mac和Linux平台。通过将代码打包成二进制文件，能起到一定的保护作用。

   官方链接：PyInstaller

5. pyobfuscate：
   pyobfuscate是一款Python代码混淆工具，通过混淆代码，使其变得难以阅读和理解。虽然这不是加密，但可以在一定程度上保护代码。

   官方链接：pyobfuscate

6. shroud：
   shroud是一个Python代码混淆和加密工具，可以混淆和加密Python代码以防止逆向工程和未经授权的使用。

   官方链接：shroud

这些工具都可以帮助你在一定程度上保护你的Python代码，但需要注意的是，任何形式的代码保护都不是绝对安全的，有经验的攻击者仍有可能通过逆向工程或其他技术手段破解代码。因此，除了代码加密外，还可以考虑其他安全措施，如代码审查、访问控制和监控等。

---

2. 哪些可以商业免费使用

以下是一些可以商业免费使用的Python代码保护工具和方法：

1. Cython：
   Cython 是一种将 Python 代码编译为 C 扩展模块的工具。它是开源的，并且可以商业免费使用。通过将 Python 代码转换为 C 代码并编译为二进制文件，可以增加代码的安全性和执行效率。

   官方链接：Cython

2. PyInstaller：
   PyInstaller 是一款将 Python 应用程序打包为独立可执行文件的工具，支持 Windows、Mac 和 Linux 平台。它是开源的，并且可以商业免费使用。通过将代码打包成二进制文件，能起到一定的保护作用。

   官方链接：PyInstaller

3. py2exe：
   py2exe 可以将 Python 脚本打包成 Windows 可执行文件（.exe），从而保护代码。py2exe 是开源的，并且可以商业免费使用。

   官方链接：py2exe

4. PyArmor（基础功能）：
   PyArmor 是一款用于保护 Python 脚本的工具，虽然它有高级功能需要购买许可证，但其基本功能是开源的，可以商业免费使用。PyArmor 通过加密和混淆代码来保护 Python 脚本。

   官方链接：PyArmor

5. pyobfuscate：
   pyobfuscate 是一款 Python 代码混淆工具，通过混淆代码，使其变得难以阅读和理解。虽然这不是加密，但可以在一定程度上保护代码。pyobfuscate 是开源的，并且可以商业免费使用。

   官方链接：pyobfuscate

6. Shroud：
   Shroud 是一个 Python 代码混淆和加密工具，可以混淆和加密 Python 代码以防止逆向工程和未经授权的使用。它是开源的，并且可以商业免费使用。

   官方链接：Shroud

这些工具和方法均为开源项目，可以在商业环境中免费使用。尽管如此，使用这些工具时请务必仔细阅读相关的许可协议，以确保符合所有许可要求和条件。

---

3. Pyarmor需要联网使用吗

Pyarmor 在某些功能上可能需要联网使用，但它的基本功能通常不需要联网。例如，你可以在本地使用 Pyarmor 来对 Python 脚本进行加密和保护，而不需要互联网连接。然而，以下情况可能需要联网：

1. 更新软件：如果你需要更新 Pyarmor 到最新版本，可能需要联网下载更新包。
2. 激活和验证许可证：如果你使用的是 Pyarmor 的商业版本，可能需要联网来激活和验证许可证。
3. 下载依赖项：在某些情况下，如果 Pyarmor 需要额外的依赖项，这些依赖项可能需要从网络上下载。

对于本地加密和保护 Python 脚本的日常操作，通常不需要互联网连接。如果你需要使用高级功能或激活许可证，可能需要临时联网。

---

4. Pyarmor是商业软件吗

是的，Pyarmor 是一款商业软件。虽然它提供了免费试用版本，但其许多高级功能和全面使用都需要购买许可证。Pyarmor 的商业版本提供了更多的功能，例如：

1. 无数量限制：保护的脚本数量不受限制。
2. 自定义扩展：可以创建和使用自定义的扩展和插件。
3. 更高级的保护措施：提供更强的脚本保护功能，防止反编译和破解。
4. 支持更新和技术支持：购买许可证后，可以获得软件更新和官方技术支持。

你可以访问 Pyarmor 的官方网站 了解更多关于价格和许可证的信息。

5. 如何使用Pyarmor

看起来你在使用 Pyarmor 进行打包时遇到了参数不足的问题。pyarmor pack 命令需要指定一个要打包的脚本。以下是一个更详细的步骤来打包你的项目：

步骤 1：初始化项目

假设你的源代码在 source 目录下，主入口脚本是 main.py。首先初始化项目：

pyarmor init --src=source --entry=main.py

步骤 2：加密代码

你需要指定要加密的脚本文件。例如，如果你要打包并加密 main.py 文件，可以这样做：

pyarmor pack -x " --exclude config" -e " --onefile" main.py

在上述命令中，main.py 是你要打包的脚本文件。

详细命令解释

• pyarmor pack：打包命令。
• -x " --exclude config"：排除 config 目录（可选，根据你的项目结构调整）。
• -e " --onefile"：生成一个单文件的可执行文件。
• main.py：你要打包的主脚本文件。

完整示例

假设你的项目结构如下：

/Projects/test_pyarmor/
├── source/
│   ├── module1.py
│   ├── module2.py
│   └── main.py
├── config/
│   ├── settings.py
│   └── config.json
└── pyarmor_config.json

在项目根目录下运行以下命令：

pyarmor init --src=source --entry=main.py
pyarmor pack -x " --exclude config" -e " --onefile" source/main.py

注意事项

1. 确认安装的 Pyarmor 版本：确认你使用的是正确的版本（在命令行输入 pyarmor --version 查看版本号）。
2. 许可证生成（可选）：如果需要许可证控制，可以生成许可证并在打包时指定许可证文件。
3. 路径正确性：确保路径和文件名正确无误。

运行打包后的文件

打包后，生成的文件通常会位于 dist 目录中，可以通过以下命令运行：

python dist/main.py

通过上述步骤，你应该能够成功使用 Pyarmor 8.0+ 进行代码加密和打包。如果还有其他问题，请提供更多的错误信息或上下文。

6. 我把dist文件夹给别人使用，别人可以破解我的python代码吗

使用 Pyarmor 加密 Python 代码确实可以提升代码的安全性，但是没有任何加密方法是完全不可破解的。使用 Pyarmor 加密代码主要是为了增加破解的难度和成本。以下是一些提高 Pyarmor 加密代码安全性的方法和注意事项：

提高 Pyarmor 加密代码的安全性

1. 启用高级混淆模式：
   在加密时启用高级混淆模式，增加破解难度。

   pyarmor pack -x " --exclude config" -e " --onefile" --advanced 2 source/main.py
   

2. 使用强力加密选项：
   配置 Pyarmor 使用更强的加密选项。

   {
       "obf_code": 1,
       "obf_mod": 2,
       "wrap_mode": 1,
       "advanced_mode": 1,
       "enable_runtime": 1
   }
   

   在 pyarmor_config.json 文件中添加这些选项。

3. 生成绑定机器的许可证：
   生成绑定特定机器的许可证，这样即使代码被破解，也只能在特定的机器上运行。

   pyarmor licenses -e 2024-12-31 -b "mac_address"
   pyarmor pack -x " --exclude config" -e " --onefile" --with-license licenses/license.lic source/main.py
   

4. 定期更新和变更加密策略：
   定期更改加密策略和重新加密代码，以防止长期使用同一套加密方案被破解。

5. 隐藏关键数据和逻辑：
   在代码中将关键数据和逻辑进行分散和混淆，避免重要信息集中暴露。

使用 Pyarmor 加密的代码仍然存在风险

尽管以上方法可以提高加密代码的安全性，但仍然不能完全杜绝被破解的风险。熟练的攻击者仍然有可能通过各种手段（如反编译、动态分析等）破解加密代码。因此，除了技术手段外，还可以考虑以下策略：

• 法律手段：通过版权声明和许可证协议来保护代码，增加法律层面的保护。
• 商业手段：采用软件即服务（SaaS）的模式，将关键业务逻辑放在服务器端，通过 API 提供服务，而不是将所有代码分发到客户端。

7. Cthon应用举例

Cython是一个可以将Python代码转换为C代码的工具，从而提高性能和实现代码混淆（即代码加密）。以下是使用Cython对Python代码进行加密的基本步骤：

安装Cython

首先，确保你已经安装了Cython。你可以使用pip来安装它：

pip install cython

创建Python代码文件

假设你有一个名为my_script.py的Python文件，你希望加密这个文件。

# my_script.py
def hello():
    print("Hello, world!")

编写Cython配置文件

创建一个名为setup.py的文件，用于配置Cython的构建过程：

# setup.py
from setuptools import setup
from Cython.Build import cythonize

setup(
    ext_modules=cythonize("my_script.py"),
)

编译Python代码

在命令行中运行以下命令，将Python代码编译为C扩展模块：

python setup.py build_ext --inplace

这将生成一个共享库文件（例如my_script.cpython-<version>-<platform>.so），你可以使用这个文件而不是原始的Python脚本。

使用编译后的代码

你可以在Python代码中直接导入并使用编译后的模块：

# 使用编译后的模块
import my_script
my_script.hello()

删除原始Python文件

为了确保代码加密，你可以删除原始的my_script.py文件，只保留编译后的共享库文件。

完整示例

1. 创建my_script.py文件：

   def hello():
       print("Hello, world!")
   

2. 创建setup.py文件：

   from setuptools import setup
   from Cython.Build import cythonize
   
   setup(
       ext_modules=cythonize("my_script.py"),
   )
   

3. 运行编译命令：

   python setup.py build_ext --inplace
   

4. 导入并使用编译后的模块：

   import my_script
   my_script.hello()
   

通过这种方式，你可以实现对Python代码的基本加密，虽然这种方法主要用于性能优化，但也提供了一定程度的代码保护。

总结

Pyarmor 可以显著增加破解代码的难度，但无法完全杜绝破解的可能性。通过结合技术手段、法律手段和商业模式，可以最大限度地保护你的 Python 代码。

8. Py2exe应用举例

py2exe 是一个将 Python 脚本转换为独立的 Windows 可执行文件的工具。以下是一个简单的示例，展示如何使用 py2exe 将一个 Python 脚本打包成可执行文件。

安装 py2exe

首先，确保你已经安装了 py2exe。你可以使用 pip 来安装它：

pip install py2exe

创建 Python 脚本

假设你有一个名为 my_script.py 的 Python 脚本，你希望将其转换为可执行文件。

# my_script.py
def main():
    print("Hello, world!")

if __name__ == "__main__":
    main()

创建 setup.py 文件

创建一个名为 setup.py 的文件，用于配置 py2exe 的打包过程：

# setup.py
from distutils.core import setup
import py2exe

setup(
    console=['my_script.py']
)

运行 py2exe

在命令行中运行以下命令，将 Python 脚本打包为可执行文件：

python setup.py py2exe

检查生成的可执行文件

运行上述命令后，你会在项目目录下看到一个 dist 文件夹，其中包含生成的 my_script.exe 文件。

完整示例

1. 创建 my_script.py 文件：

   def main():
       print("Hello, world!")
   
   if __name__ == "__main__":
       main()
   

2. 创建 setup.py 文件：

   from distutils.core import setup
   import py2exe
   
   setup(
       console=['my_script.py']
   )
   

3. 运行打包命令：

   python setup.py py2exe
   

4. 运行生成的可执行文件：
   在 dist 文件夹中找到 my_script.exe，双击运行它，或者在命令行中运行：

   dist\my_script.exe
   

这样，你就可以将 Python 脚本打包为一个独立的 Windows 可执行文件。这个可执行文件可以在没有 Python 环境的机器上运行。

8. Pyinstaller应用举例

PyInstaller 是一个将 Python 程序打包成独立的可执行文件的工具。以下是一个简单的示例，展示如何使用 PyInstaller 将一个 Python 脚本打包成可执行文件。

安装 PyInstaller

首先，确保你已经安装了 PyInstaller。你可以使用 pip 来安装它：

pip install pyinstaller

创建 Python 脚本

假设你有一个名为 my_script.py 的 Python 脚本，你希望将其转换为可执行文件。

# my_script.py
def main():
    print("Hello, world!")

if __name__ == "__main__":
    main()

使用 PyInstaller 打包脚本

在命令行中运行以下命令，将 Python 脚本打包为可执行文件：

pyinstaller --onefile my_script.py

这个命令将创建一个单个可执行文件，其中 --onefile 参数指定将所有文件打包到一个独立的可执行文件中。

检查生成的可执行文件

运行上述命令后，你会在项目目录下看到一个 dist 文件夹，其中包含生成的 my_script.exe 文件。

完整示例

1. 创建 my_script.py 文件：

   def main():
       print("Hello, world!")
   
   if __name__ == "__main__":
       main()
   

2. 使用 PyInstaller 进行打包：

   pyinstaller --onefile my_script.py
   

3. 运行生成的可执行文件：
   在 dist 文件夹中找到 my_script.exe，双击运行它，或者在命令行中运行：

   dist\my_script.exe
   

更多选项

PyInstaller 提供了许多选项来定制生成的可执行文件。以下是一些常用选项：

• --onefile：将所有文件打包到一个独立的可执行文件中。
• --windowed：生成一个没有控制台窗口的 GUI 应用程序（仅适用于 GUI 应用）。
• --add-data：将额外的数据文件打包到可执行文件中。例如，--add-data 'data.txt;.'。

使用配置文件

你还可以通过配置文件（spec 文件）来定制打包过程。以下是一个简单的 spec 文件示例：

1. 生成 spec 文件：

   pyinstaller my_script.py --onefile --name my_application
   

2. 编辑生成的 my_script.spec 文件：

   # -*- mode: python ; coding: utf-8 -*-
   
   block_cipher = None
   
   a = Analysis(
       ['my_script.py'],
       pathex=[],
       binaries=[],
       datas=[],
       hiddenimports=[],
       hookspath=[],
       runtime_hooks=[],
       excludes=[],
       win_no_prefer_redirects=False,
       win_private_assemblies=False,
       cipher=block_cipher,
   )
   pyz = PYZ(a.pure, a.zipped_data, cipher=block_cipher)
   
   exe = EXE(
       pyz,
       a.scripts,
       [],
       exclude_binaries=True,
       name='my_application',
       debug=False,
       bootloader_ignore_signals=False,
       strip=False,
       upx=True,
       console=True,
   )
   coll = COLLECT(
       exe,
       a.binaries,
       a.zipfiles,
       a.datas,
       strip=False,
       upx=True,
       upx_exclude=[],
       name='my_application',
   )
   

3. 使用 spec 文件进行打包：

   pyinstaller my_script.spec
   

通过这种方式，你可以将 Python 脚本打包为一个独立的可执行文件，可以在没有 Python 环境的机器上运行。

9. pyobfuscate应用举例

pyobfuscate 是一个用于混淆 Python 代码的工具，目的是使代码更难以阅读和理解，从而保护代码的知识产权。以下是一个使用 pyobfuscate 进行代码混淆的示例。

安装 pyobfuscate

首先，确保你已经安装了 pyobfuscate。你可以使用 pip 来安装它：

pip install pyobfuscate

创建 Python 脚本

假设你有一个名为 my_script.py 的 Python 脚本，你希望将其混淆。

# my_script.py
def greet(name):
    print(f"Hello, {name}!")

if __name__ == "__main__":
    greet("world")

使用 pyobfuscate 进行混淆

运行以下命令对 my_script.py 进行混淆：

pyobfuscate my_script.py -o obfuscated_script.py

这个命令将生成一个名为 obfuscated_script.py 的文件，其中包含混淆后的代码。

检查混淆后的代码

打开 obfuscated_script.py 文件，你会看到混淆后的代码，它变得更加难以阅读和理解。

完整示例

1. 创建 my_script.py 文件：

   def greet(name):
       print(f"Hello, {name}!")
   
   if __name__ == "__main__":
       greet("world")
   

2. 运行混淆命令：

   pyobfuscate my_script.py -o obfuscated_script.py
   

3. 检查混淆后的代码：
   打开 obfuscated_script.py 文件，内容可能类似于：

   # obfuscated_script.py
   def _obf_1(name):
       print(f"Hello, {name}!")
   
   if __name__ == "__main__":
       _obf_1("world")
   

使用混淆后的代码

你可以像使用原始代码一样使用混淆后的代码。它的功能应该与原始代码完全相同，只是变量名和函数名被混淆了。

# 使用混淆后的代码
import obfuscated_script

obfuscated_script._obf_1("world")

通过这种方式，你可以使用 pyobfuscate 对 Python 代码进行混淆，从而保护你的代码不被轻易理解和复制。

10. shroud应用举例

Shroud 是一个用于混淆 Python 代码的工具，旨在保护代码的知识产权和敏感信息。以下是如何使用 Shroud 进行代码混淆的示例。

安装 Shroud

首先，确保你已经安装了 Shroud。你可以从 Shroud 的 GitHub 页面 下载并安装它。以下是安装步骤：

1. 克隆 Shroud 仓库：

   git clone https://github.com/ovidiucp/Shroud.git
   

2. 进入 Shroud 目录并安装：

   cd Shroud
   python setup.py install
   

创建 Python 脚本

假设你有一个名为 my_script.py 的 Python 脚本，你希望将其混淆。

# my_script.py
def greet(name):
    print(f"Hello, {name}!")

if __name__ == "__main__":
    greet("world")

使用 Shroud 进行混淆

运行以下命令对 my_script.py 进行混淆：

shroud my_script.py -o obfuscated_script.py

这个命令将生成一个名为 obfuscated_script.py 的文件，其中包含混淆后的代码。

检查混淆后的代码

打开 obfuscated_script.py 文件，你会看到混淆后的代码，它变得更加难以阅读和理解。

完整示例

1. 创建 my_script.py 文件：

   def greet(name):
       print(f"Hello, {name}!")
   
   if __name__ == "__main__":
       greet("world")
   

2. 运行混淆命令：

   shroud my_script.py -o obfuscated_script.py
   

3. 检查混淆后的代码：
   打开 obfuscated_script.py 文件，内容可能类似于：

   # obfuscated_script.py
   def _shroud_1(name):
       print(f"Hello, {name}!")
   
   if __name__ == "__main__":
       _shroud_1("world")
   

使用混淆后的代码

你可以像使用原始代码一样使用混淆后的代码。它的功能应该与原始代码完全相同，只是变量名和函数名被混淆了。

# 使用混淆后的代码
import obfuscated_script

obfuscated_script._shroud_1("world")

通过这种方式，你可以使用 Shroud 对 Python 代码进行混淆，从而保护你的代码不被轻易理解和复制。如果在安装和使用 Shroud 过程中遇到问题，可以参考 Shroud 的 GitHub 页面 上的文档和问题讨论。

参考文献

• pyarmor，一个超级厉害的 Python 库！ - 知乎
• 5. 许可模式和许可证 — Pyarmor 8.5.10 文档
• Pyarmor 8.5 Documentation — Pyarmor 8.5.11 documentation
• Tuple index out of range with Python 3.10 and pyinstaller 5.0.dev0 · Issue #6301 · pyinstaller/pyinstaller · GitHub
  
• Exe packaging issue · Issue #6954 · gradio-app/gradio · GitHub