1. 项目概述：为什么我们需要PyArmor-Unpacker？

在Python生态里，代码保护一直是个让人又爱又恨的话题。爱的是，作为开发者，我们当然希望自己的核心算法和业务逻辑不被轻易窥探；恨的是，Python作为一门解释型语言，其源码（.py文件）或字节码（.pyc文件）的“裸露”特性，使得保护变得异常困难。PyArmor作为目前最流行的Python代码混淆和加密工具之一，应运而生。它通过代码混淆、字节码加密、绑定特定机器等多种手段，为Python脚本穿上了一层“盔甲”。

然而，有“矛”就有“盾”。在实际工作中，我们接触PyArmor加密的代码，往往不是出于恶意破解的目的，而是源于一些完全正当且迫切的需求。比如，你接手了一个遗留项目，核心模块被前同事用PyArmor加密了，现在需要修复一个紧急Bug，但源码和授权文件都已丢失；又或者，你负责软件合规审计，需要验证第三方提供的加密模块中是否包含不安全的代码或后门；再比如，你正在学习软件安全，希望通过研究成熟的保护方案来设计更健壮的自家产品。在这些场景下，一个能够理解、分析乃至还原PyArmor加密逻辑的工具，就成了解决问题的关键钥匙。这就是“PyArmor-Unpacker”类工具存在的核心价值——它不是鼓励侵权，而是为特定、合法的技术分析和应急处理提供可能性。

本文将深入探讨三种主流的、经过实践验证的PyArmor解密思路与方法。我们将从原理入手，详细拆解每一步操作，并分享大量从实际对抗中总结出的经验和避坑指南。无论你是安全研究人员、逆向工程师，还是遇到上述困境的开发者，这篇文章都将为你提供一套清晰、可操作的行动路线图。

2. 核心思路拆解：逆向PyArmor的三种路径

面对一个PyArmor加密的脚本或包，我们首先需要理解它的保护机制，才能找到突破口。PyArmor的保护是分层级的，从外到内大致可以理解为：加载器壳 -> 加密的字节码 -> 运行时保护。我们的解密目标，最终是获取到能够被标准Python解释器直接或间接执行的、可读性更高的代码形式（通常是还原的字节码或反编译后的源码）。以下是三种从易到难、从通用到定制化的核心思路。

2.1 方法一：内存DUMP法——利用运行时漏洞

这是最经典、也往往是门槛最低的一种方法。其核心思想是“借鸡生蛋”：让PyArmor自己的加载器完成最复杂的解密和字节码重构工作，我们只需要在内存中，当代码已经被解密并准备执行时，将其“捕获”下来。

原理剖析：PyArmor加密后的脚本，入口点是一个轻量级的“引导加载器”。这个加载器的职责是检查运行环境（如机器指纹、许可文件），初始化PyArmor的运行时环境（一个扩展模块，通常是pytransform或pyarmor_runtime），然后由这个运行时模块负责在内存中解密真正的字节码并交给Python虚拟机执行。内存DUMP法的目标，就是在字节码被交给Python虚拟机执行前的那一刻，将其从内存对象中提取出来。

为什么这种方法经常有效？因为PyArmor的防御重点在于防止静态分析（即直接查看磁盘上的文件），而对动态运行时的保护，在默认配置或早期版本中可能存在“可乘之机”。例如，Python的marshal模块用于序列化和反序列化代码对象，而解密后的字节码正是通过marshal.loads()加载的。如果我们能拦截到这个调用，或者直接访问到已经构建好的代码对象，就能实现DUMP。

该方法的优势与局限：

• 优势：通常不依赖PyArmor的具体版本或加密密钥，只要加密脚本能成功运行，就有机会获取解密后的代码。它绕过了复杂的密码学对抗，直击运行结果。
• 局限：
  1. 依赖可执行环境：目标加密脚本必须能在你的分析环境中成功运行。如果它绑定了特定硬件、存在强完整性校验或依赖特定许可证，你可能无法让其运行起来。
  2. 对抗升级：新版本的PyArmor会不断增强运行时保护，例如混淆对marshal、dis等模块的调用，或清除内存中的敏感对象，使得DUMP难度加大。
  3. 可能不完整：对于分模块加密、动态加载代码的情况，一次运行可能无法捕获所有代码，需要构造不同的执行路径来触发。

2.2 方法二：调试与Hook法——主动干预执行流程

当内存DUMP因为环境或保护原因无法直接进行时，我们需要更主动地介入程序的执行过程。这就是调试与Hook法的用武之地。这种方法从“被动捕获”升级为“主动控制”。

原理剖析：通过调试器（如Python内置的pdb、sys.settrace，或外部调试器gdb/lldb附加到Python进程）或代码注入Hook（例如利用sys.meta_path导入钩子、或直接使用uncompyle6、decompyle3等反编译工具提供的API），在关键函数（如pytransform模块的解密函数、marshal.loads）被调用时中断执行，检查或修改其参数和返回值。

技术实现细分：

1. Python层Hook：利用sys.settrace设置全局跟踪函数，可以监控每一行代码的执行。通过精心编写跟踪函数，我们可以检测到对pyarmor_runtime模块中特定函数的调用，并打印或保存其参数（即加密数据）。也可以利用importlib的机制，在模块导入时替换掉关键的类或函数。
2. 本地调试器附加：对于将关键逻辑放在C扩展（pytransform）中的情况，Python层的Hook可能失效。此时需要使用系统级的调试器，如gdb（Linux）或x64dbg/OllyDbg（Windows）。在调试器中，我们可以在C扩展模块的入口函数（如PyInit_pytransform）或标准库函数（如PyMarshal_ReadObjectFromString）上设置断点，当断点命中时，直接从寄存器或内存中提取解密后的字节码数据。
3. 反编译工具集成Hook：一些高级的反编译工具本身就提供了运行时分析模式。它们可以像调试器一样附着到进程，监听代码对象的创建事件，并自动进行反编译和保存。

该方法的优势与局限：

• 优势：灵活性高，可以应对更复杂的保护手段。通过调试器，我们能够观察到底层的C/C++级别的操作，这是纯Python层Hook无法触及的。
• 局限：
  1. 技术门槛高：尤其是使用原生调试器，需要具备一定的逆向工程和操作系统知识。
  2. 可能触发反调试：一些保护方案会检测调试器的存在，一旦发现就改变行为或直接退出，导致分析失败。
  3. 过程繁琐：需要一步步跟踪执行流，定位关键点，对耐心和分析能力要求较高。

2.3 方法三：静态分析与密钥提取法——正面攻克加密算法

这是最彻底、但也最困难的方法。它不依赖于运行目标代码，而是尝试通过逆向分析PyArmor的加密工具（pyarmor命令本身）或生成的加密文件结构，来推导出加密算法和密钥，从而编写一个对应的解密器。

原理剖析：PyArmor在加密一个项目时，会生成一个“密钥”或“加密种子”，并用它来加密所有字节码。这个密钥可能被硬编码在pyarmor_runtime扩展模块中，也可能被加密后存放在license.lic或加密脚本的头部。静态分析的目标就是找到这个密钥，并理解其使用的加密算法（通常是AES、DES或XOR等）。

关键步骤：

1. 分析pyarmor命令行工具：使用反编译工具分析pyarmor这个Python包，查看其obfuscate、encrypt等核心函数的实现逻辑，了解密钥生成和处理的流程。
2. 逆向pytransform扩展模块：这是一个用C编写的模块，包含了核心的加密解密例程。需要使用反汇编工具（如IDA Pro, Ghidra, Hopper）或调试器进行逆向工程，分析其初始化过程，寻找密钥常量或密钥推导算法。
3. 分析加密文件格式：PyArmor加密后的.py文件或pytransform模块中的数据段，有其特定的格式。通过对比加密前后的文件，分析文件头结构，可能找到密钥的线索或加密数据的偏移量。

该方法的优势与局限：

• 优势：一旦成功，可以通杀使用同一密钥加密的所有文件，是最根本的解决方案。也最具有学术和研究价值。
• 局限：
  1. 难度极大：需要深厚的逆向工程、密码学和程序分析功底。
  2. 版本差异：PyArmor不同版本间的加密方案和模块结构可能发生变化，为一个版本写的分析脚本可能不适用于另一个版本。
  3. 法律风险：此方法最接近对软件保护机制的“破解”，需确保在合法授权的范围内进行。

重要提示与伦理边界：无论采用哪种方法，都必须牢记其应用边界。这些技术应仅用于自己拥有合法版权或已获明确授权的代码分析、安全研究、数字取证或解决上述的紧急维护问题。任何用于非法破解、盗版他人软件的行为，都是违法且不道德的。本文分享的知识旨在提升技术理解和应急处理能力，请读者务必遵守法律法规和软件许可协议。

3. 方法一实战：基于uncompyle6与xdis的内存DUMP

让我们从最实用的内存DUMP法开始，手把手完成一次解密。这里我们以一个使用PyArmor 7.x版本加密的简单脚本encrypted_script.py为例。

3.1 环境准备与工具选择

首先，你需要一个能让目标脚本运行起来的环境。如果脚本绑定了特定机器，你可能需要在原机器上操作，或者尝试使用PyArmor的--no-bootstrap等选项（如果加密时未使用）来绕过某些检查，但这部分涉及对加密参数的了解，情况复杂。

我们将主要使用两个Python库：

1. uncompyle6：一个强大的Python字节码反编译器，可以将.pyc文件或代码对象反编译成Python源码。它同时也提供了强大的运行时代码对象捕获功能。
2. xdis：uncompyle6依赖的跨Python版本的字节码处理库。

安装命令非常简单：

pip install uncompyle6 xdis

3.2 编写DUMP脚本

单纯运行uncompyle6命令行工具可能无法直接拦截运行时代码。我们需要编写一个小的Python脚本来充当“拦截器”。以下是一个高度可用的示例脚本dump_loader.py：

#!/usr/bin/env python3 """ PyArmor运行时字节码DUMP工具 将本脚本与待解密的脚本放在同一目录，通过本脚本导入目标模块来触发DUMP。 """ import sys import os import marshal import uncompyle6 from xdis.magics import sysinfo2float from xdis import IS_PYPY, PYTHON_VERSION_TRIPLE # 1. 关键Hook：替换marshal.loads original_marshal_loads = marshal.loads def hooked_marshal_loads(data): """ 尝试DUMP每一个被marshal.loads加载的代码对象。 PyArmor运行时解密后的字节码很可能通过此函数加载。 """ try: # 尝试反序列化，如果失败则不是代码对象，直接返回原结果 code_obj = original_marshal_loads(data) if hasattr(code_obj, 'co_code'): # 简单判断是否为代码对象 print(f"[+] 捕获到代码对象: {code_obj.co_name} in {code_obj.co_filename}") # 生成文件名 filename = f"dumped_{code_obj.co_name}_{hash(data) & 0xffffffff:08x}.pyc" with open(filename, 'wb') as f: # 写入Pyc头部（魔数、时间戳等），这里简化处理，对于反编译可能不是必须的 # 更稳妥的方式是使用xdis直接保存代码对象 f.write(marshal.dumps(code_obj)) print(f" [>] 字节码已保存至: {filename}") # 尝试立即反编译 try: source_filename = filename.replace('.pyc', '.py') with open(source_filename, 'w', encoding='utf-8') as sf: uncompyle6.deparse_code(code_obj, out=sf) print(f" [>] 源码已反编译至: {source_filename}") except Exception as e: print(f" [!] 反编译失败: {e}") except Exception as e: # 如果不是有效的marshal数据，则忽略 pass # 无论如何，返回原始调用结果，确保程序正常执行 return original_marshal_loads(data) # 应用Hook marshal.loads = hooked_marshal_loads # 2. 另一种方式：Hook import机制（捕获通过pytransform加载的模块） import importlib.abc import importlib.util class PyArmorFinder(importlib.abc.MetaPathFinder): def find_spec(self, fullname, path, target=None): # 这里可以过滤只处理你关心的模块，例如来自加密包内的模块 # 本例中我们打印所有查找的模块，观察PyArmor如何加载 # print(f"[Finder] 查找模块: {fullname}, path={path}") return None # 将Finder插入到元路径最前面 sys.meta_path.insert(0, PyArmorFinder()) # 3. 执行目标脚本 if __name__ == '__main__': if len(sys.argv) < 2: print("用法: python dump_loader.py <要导入的加密模块名（不含.py）>") sys.exit(1) target_module = sys.argv[1] print(f"[*] 开始尝试导入并DUMP模块: {target_module}") print(f"[*] marshal.loads Hook已安装") try: __import__(target_module) print(f"[*] 模块导入完成。请检查当前目录下生成的 .pyc 和 .py 文件。") except Exception as e: print(f"[!] 导入过程中发生错误: {e}") import traceback traceback.print_exc()

3.3 执行与结果分析

假设你的加密脚本名为my_encrypted.py，其内容是一个简单的函数。你可以这样操作：

1. 将dump_loader.py和my_encrypted.py放在同一目录。
2. 运行命令：python dump_loader.py my_encrypted。
3. 观察控制台输出。如果PyArmor运行时通过marshal.loads加载了解密后的代码，你会看到类似下面的输出：

   [+] 捕获到代码对象: my_secret_function in /path/to/protected_code.py [>] 字节码已保存至: dumped_my_secret_function_5a3f8c12.pyc [>] 源码已反编译至: dumped_my_secret_function_5a3f8c12.py

4. 打开生成的.py文件，你很可能就看到反编译后的Python源代码了。

实操心得与注意事项：

• Hook的时机：务必在导入目标加密模块之前安装Hook。我们的脚本通过先定义Hook函数，再导入目标模块的方式确保了这一点。
• 错误处理：Hook函数内部的try...except必须足够宽泛，并且最终要调用原始函数返回结果。任何异常导致原始调用失败，都可能使加密脚本运行崩溃，从而无法触发后续的解密流程。
• PyArmor版本差异：PyArmor 8.x及以后的版本，运行时保护更强，可能不再使用简单的marshal.loads，或者对代码对象进行了更深度的包装和混淆。此时，上述脚本可能捕获不到内容，或者捕获到的是被二次混淆的对象。
• 多模块处理：一个复杂的项目可能包含多个加密模块。我们的简单Finder会打印所有模块导入请求，你可以根据路径或模块名特征，修改Finder来针对性地DUMP特定模块的代码对象，这需要更精细的分析。

4. 方法二实战：使用sys.settrace进行精细跟踪

当简单的marshal.loadsHook失效时，我们需要一个更强大的跟踪工具。Python标准库中的sys.settrace允许我们设置一个全局跟踪函数，该函数会在程序执行时被频繁调用，报告调用事件、行事件、返回事件和异常事件。我们可以利用它来监控pyarmor_runtime模块的一举一动。

4.1 理解sys.settrace的工作原理

跟踪函数接收三个参数：frame（当前栈帧对象）、event（事件类型，如'call','line','return','exception'）和arg（事件相关参数）。通过检查frame对象，我们可以获取当前执行的函数名、文件名、行号以及局部变量等信息。

我们的策略是：在跟踪函数中，过滤出发生在pyarmor_runtime相关模块内的事件，特别是函数调用（'call'）事件，然后记录或检查其参数。

4.2 编写高级跟踪脚本

以下脚本trace_pyarmor.py演示了如何利用sys.settrace进行针对性跟踪：

#!/usr/bin/env python3 """ 使用sys.settrace跟踪PyArmor运行时模块的执行。 """ import sys import os # 定义一个集合，存放我们感兴趣的模块路径关键词 INTERESTED_MODULES = {'pyarmor_runtime', 'pytransform', 'dist' + os.sep + 'pytransform'} # 根据实际情况调整 def trace_calls(frame, event, arg): if event != 'call': return trace_calls # 只关心函数调用事件，但返回自身以继续跟踪 co = frame.f_code func_name = co.co_name filename = co.co_filename # 检查是否来自我们感兴趣的模块 is_interested = any(key in filename for key in INTERESTED_MODULES) if is_interested: # 打印调用信息 print(f"[TRACE] Call -> {func_name:30} in {filename}:{co.co_firstlineno}") # 尝试获取并打印局部变量中的潜在关键参数 # 注意：在`call`事件时，函数参数刚被压入，局部变量`locals()`包含的就是参数 locals_dict = frame.f_locals for var_name, var_value in locals_dict.items(): # 过滤掉一些无关紧要的变量，或者只关注特定类型的值 if var_name.startswith('__'): # 忽略魔术方法参数 continue # 重点关注可能是加密数据（bytes类型）或重要字符串的参数 if isinstance(var_value, bytes): print(f" | Param '{var_name}': bytes, length={len(var_value)}, hex preview: {var_value[:32].hex()}...") elif isinstance(var_value, str): if len(var_value) < 100: # 避免打印过长的字符串 print(f" | Param '{var_name}': '{var_value}'") else: print(f" | Param '{var_name}': str, length={len(var_value)}") # 可以添加其他感兴趣的类型判断 # 返回跟踪函数本身，表示继续跟踪这个新进入的函数内部的调用 return trace_calls def main(): if len(sys.argv) < 2: print("用法: python trace_pyarmor.py <加密脚本路径>") sys.exit(1) target_script = sys.argv[1] # 设置全局跟踪函数 sys.settrace(trace_calls) print(f"[*] 开始跟踪执行: {target_script}") print(f"[*] 感兴趣的模块关键词: {INTERESTED_MODULES}") print("-" * 60) try: # 使用exec来执行目标脚本，以便跟踪全局作用域 with open(target_script, 'r', encoding='utf-8') as f: script_code = f.read() # 创建一个新的命名空间来执行，避免污染当前环境 namespace = {'__name__': '__main__', '__file__': target_script} exec(script_code, namespace) except Exception as e: print(f"[!] 执行过程中发生错误: {e}") import traceback traceback.print_exc() finally: # 清除跟踪 sys.settrace(None) print("-" * 60) print("[*] 跟踪结束。") if __name__ == '__main__': main()

4.3 执行分析与关键点捕捉

运行命令：python trace_pyarmor.py my_encrypted.py。脚本会开始执行加密脚本，并打印出所有发生在pyarmor_runtime或pytransform模块中的函数调用。

你需要关注什么？

1. 函数名：寻找像decrypt、loads、restore_code、_load_module、_exec_script这样的函数名。
2. 参数：重点关注类型为bytes的参数。这些很可能就是加密后的字节码数据。记录下这些字节数据（可以从hex预览中复制），或者修改脚本，在发现特定函数时，直接将参数值保存到文件。
3. 调用栈：观察函数的调用顺序，理解PyArmor运行时的初始化、解密、加载流程。

示例输出片段分析：

[TRACE] Call -> _load_module in .../pyarmor_runtime/__init__.py:123 | Param 'filename': 'protected_module' | Param 'data': bytes, length=2048, hex preview: 1f8b0800000000000000edbd0760... [TRACE] Call -> _restore_code in .../pyarmor_runtime/__init__.py:456 | Param 'obfuscated_code': bytes, length=1024, hex preview: 789c65540b0c...

从上面可以看出，_load_module接收了一个模块名和一段数据，紧接着_restore_code接收了一段混淆的代码（obfuscated_code）。_restore_code的参数极有可能就是解密函数的关键输入！

下一步行动：修改跟踪脚本，在检测到_restore_code函数被调用时，不仅打印参数，还将其obfuscated_code参数（即字节数据）完整地写入一个文件（例如obfuscated_code.bin）。然后，我们可以尝试分析这个二进制数据，或者结合方法三的思路，去寻找解密这个数据的函数。

注意事项：

• 性能影响：sys.settrace会极大降低程序运行速度，但对于分析脚本来说通常可以接受。
• 代码混淆：PyArmor可能会重命名内部的函数和变量，使得_restore_code这样的名字变得不可读。你需要根据上下文和参数类型来猜测关键函数。
• 嵌套跟踪：我们的跟踪函数返回了自身，这意味着它会跟踪所有被调用函数内部的调用。这会产生海量输出。在生产分析中，你可能需要实现更智能的过滤逻辑，例如只跟踪到某一深度，或者在找到关键函数后停止跟踪其内部调用。

5. 方法三探索：静态分析pytransform扩展模块

当动态方法都遇到阻碍时，我们不得不转向静态分析。这通常意味着要面对C语言编写的二进制扩展模块（如pytransform.cpython-39-x86_64-linux-gnu.so）。这里我们不会深入到汇编指令级别，而是探讨一些更高级、更可行的切入点。

5.1 寻找字符串与符号信息

即使模块被剥离了调试符号，其中仍然会包含许多有用的字符串常量。使用strings命令（Linux/macOS）或使用PE工具查看字符串（Windows）是第一步。

# Linux/macOS 示例 strings pytransform.cpython-39-x86_64-linux-gnu.so | grep -i -E "(key|iv|aes|des|seed|license|decrypt|encrypt|xor)"

你可能会发现一些有趣的字符串，比如硬编码的密钥片段、算法标识（如"AES-128-CBC"）、或与许可证检查相关的错误信息。这些字符串可以作为在反汇编工具中定位关键函数的线索。

5.2 使用反汇编工具进行初步分析

对于更深入的分析，你需要使用像Ghidra（免费）、IDA Pro（商业）或Hopper（商业）这样的反汇编器/反编译器。

1. 导入模块：将pytransform.so或pytransform.pyd文件导入工具。
2. 识别初始化函数：Python C扩展模块的入口函数通常命名为PyInit_<模块名>，例如PyInit_pytransform。找到这个函数是分析的起点。
3. 查找导出函数：查看模块的导出函数表。PyArmor可能会导出一些供Python调用的函数，如pyarmor_decrypt、pyarmor_check等。这些函数是连接Python层和C层加密逻辑的桥梁。
4. 交叉引用分析：在找到的字符串（如"decrypt"）或疑似密钥的常量数据上，使用工具的“交叉引用”（Xrefs）功能，查找哪些代码访问了这些数据。这能带你找到使用这些数据的函数。
5. 识别加密算法：在反编译出的C代码中，寻找常见的加密库函数调用模式，例如OpenSSL的AES_set_decrypt_key、AES_cbc_encrypt，或者自定义的XOR循环。识别算法是编写解密器的关键。

5.3 一个可行的混合思路：从Python层推导密钥

完全逆向C模块难度很大。一个更聪明的混合思路是：利用Python层的漏洞或设计来间接获取密钥。

PyArmor的加密密钥通常在加密时生成，并可能以某种形式嵌入到运行时模块或加密脚本的头部。有时，为了在目标机器上运行，密钥需要被传输或推导出来。我们可以思考：

• 许可证文件（license.lic）：它是否包含加密后的密钥？其格式是否可以解析？
• 运行时初始化：pyarmor_runtime在初始化时，是否从某个地方（环境变量、文件、脚本本身）读取了密钥？我们可以用方法二的跟踪技术，监控初始化过程中的所有文件读取和网络请求。
• 密钥推导：密钥是否由机器指纹（如硬盘序列号、MAC地址）通过一个固定算法推导而来？如果是，并且你能在另一台受控机器上运行，你或许可以计算出密钥。

举例：假设通过跟踪，你发现pyarmor_runtime在初始化时调用了一个函数_get_key_from_license()，并从license.lic文件中读取了一段数据。你可以修改跟踪脚本，在这个函数返回时，打印或保存其返回值。这个返回值很可能就是解密用的密钥。

5.4 编写解密器的基本框架

假设通过上述某种方法，你获得了一个密钥（key）和可能知道的算法（例如AES-128-CBC）。那么你可以编写一个独立的Python解密器：

#!/usr/bin/env python3 """ 假设已知密钥和算法后的解密器示例 """ import os from Crypto.Cipher import AES # 需要安装pycryptodome: pip install pycryptodome from Crypto.Util.Padding import unpad def decrypt_pyarmor_file(encrypted_file_path, key, iv): """ 解密一个PyArmor加密的模块文件（假设是纯加密数据部分）。 注意：真实文件通常有自定义的头部，需要先剥离。 """ with open(encrypted_file_path, 'rb') as f: data = f.read() # 步骤1：解析文件格式，跳过PyArmor自定义的头部（需要根据实际分析确定偏移量） # 例如，头部可能是固定长度，或者包含长度字段。 # header_size = parse_header(data) # 这是一个需要你实现的函数 # ciphertext = data[header_size:] # 为了示例，我们假设ciphertext就是去头部后的数据 ciphertext = data # 警告：这通常不正确！ # 步骤2：使用已知算法解密 cipher = AES.new(key, AES.MODE_CBC, iv=iv) decrypted_padded = cipher.decrypt(ciphertext) # 步骤3：去除填充（例如PKCS#7） decrypted_data = unpad(decrypted_padded, AES.block_size) # 步骤4：解密后的数据应该是marshal格式的代码对象 import marshal try: code_obj = marshal.loads(decrypted_data) return code_obj except Exception as e: print(f"反序列化失败，解密数据可能不正确: {e}") # 可能是解密失败，或者数据格式不是直接的marshal return None # 使用示例（假设的key和iv） key = b'this-is-a-16bytekey' # 16字节 for AES-128 iv = b'16-bytes-iv-here' # CBC模式需要IV encrypted_file = 'protected_module.pyc.encrypted' # 你提取出的加密数据部分 code_obj = decrypt_pyarmor_file(encrypted_file, key, iv) if code_obj: # 反编译或保存 import uncompyle6 with open('decrypted.py', 'w') as f: uncompyle6.deparse_code(code_obj, out=f) print("解密和反编译成功！")

警告：这个示例高度简化，真实情况复杂得多。encrypted_file_path指向的应该是你从加密脚本或模块中提取出的纯加密数据块，而不是原始文件。提取这个数据块本身就需要对PyArmor的文件格式进行逆向分析。

6. 常见问题、排查技巧与高级对抗

在实际操作中，你几乎一定会遇到各种问题。下面是一些常见场景及其应对思路。

6.1 加密脚本无法运行

• 现象：导入或运行加密脚本时，提示“PyArmor is not initialized”、“License is not valid”或直接崩溃。
• 排查：
  1. 检查运行环境：确保pyarmor_runtime模块在Python路径中。加密脚本通常依赖同目录下的pytransform扩展模块和pyarmor_runtime包。
  2. 检查许可证：如果有license.lic文件，确保它在正确的位置（通常是脚本同目录或用户主目录下的.pyarmor目录）。
  3. 机器绑定：如果脚本绑定了特定机器，你需要在原机器上分析，或者尝试寻找绕过绑定检查的方法（这通常涉及更深的逆向，可能需修改pytransform模块或伪造硬件信息）。
  4. 版本兼容性：确保Python解释器版本与加密时使用的版本兼容。PyArmor加密的模块通常对Python小版本敏感。

6.2 DUMP或Hook不到任何内容

• 现象：使用了内存DUMP或跟踪脚本，但控制台没有输出任何感兴趣的调用，或者程序行为异常。
• 排查：
  1. Hook是否生效：在Hook脚本开头打印一条信息，确认脚本被正确执行。
  2. PyArmor版本：高版本PyArmor（8.0+）使用了更强的虚拟机（VMP）保护，核心解密逻辑可能被移到VMP保护的代码区内，标准的函数调用跟踪可能失效。此时需要考虑方法三，或者寻找该版本VMP的已知分析思路（社区可能有相关讨论）。
  3. 反Hook/反调试：PyArmor运行时可能检测了sys.settrace或调试器。尝试在设置跟踪后再导入pyarmor_runtime，或者使用更底层的调试技术（如ptrace）。
  4. 代码流混淆：关键的解密操作可能被分散在多个函数或线程中，使得简单的入口点Hook难以捕获全部。需要更全面的执行流分析。

6.3 反编译出的代码可读性差

• 现象：成功DUMP并反编译出了.py文件，但里面变量名都是a,b,c，控制流混乱。
• 原因与应对：这是代码混淆的典型效果。PyArmor默认会进行标识符重命名、控制流扁平化等混淆。
• 处理：
  1. 接受现状：对于逻辑简单的脚本，即使混淆了，通过仔细阅读也能理解其功能。
  2. 手动分析：结合动态调试，在关键位置打印变量值，来理解混淆后的逻辑。
  3. 使用反混淆工具（如果存在）：社区中有时会出现针对特定PyArmor混淆模式的简单反混淆脚本，可以搜索尝试。但通用性强的不多。

6.4 面对VMP（虚拟机保护）的高级版本

PyArmor的商业版或高版本集成了VMP保护，这是最大的挑战。VMP会将原始的字节码指令转换为一套自定义的指令集，并在一个软件模拟的虚拟机中执行，使得静态分析和动态跟踪都极其困难。

• 应对思路：
  1. 放弃完全静态还原：对于强VMP，完全还原出原始Python源码几乎不可能。
  2. 动态黑盒分析：将加密模块视为一个黑盒，通过大量的输入输出测试来推断其功能。结合sys.settrace跟踪其与外界（文件、网络、其他模块）的交互。
  3. 提取核心算法：如果目标只是获取其中的某个算法（如一个加密函数、一个校验逻辑），可以尝试通过反复调用和监控，记录其输入输出映射，然后用其他语言重新实现，或者直接将其封装为一个服务来调用。
  4. 关注供应链：如果这个加密模块是你必须依赖的第三方库，最根本的解决方式是联系供应商，要求其提供源码或未加密版本。技术手段应是最后的选择。

6.5 工具与资源推荐

• 反编译与字节码工具：uncompyle6,decompyle3,pycdc,xdis,marshal。
• 动态分析工具：sys.settrace,pdb(Python Debugger),gdb/lldb(系统调试器),Frida(动态插桩工具，非常强大)。
• 静态分析工具：strings,objdump,Ghidra(免费开源),IDA Pro,Hopper。
• 社区与论坛：GitHub, Reverse Engineering Stack Exchange, 看雪论坛等安全社区，有时会有针对特定版本PyArmor的讨论和脚本。搜索时可以使用“pyarmor unpack”、“pyarmor decrypt”、“pyarmor reverse”等关键词。

最后必须再次强调，所有这些技术都应在法律允许和道德规范的范围内使用。对于自己拥有合法权利的代码，这些方法是强大的分析和维护工具；对于他人的知识产权，它们则是不可逾越的红线。希望这篇指南能帮助你在遇到合法需求时，找到正确的技术路径。