一次pyarmor解密分析
一次pyarmor解密分析
一、原理：
1.概述：
笔者分析的样本pyarmor一共有两层加密，第一层加密co_object,第二层加密co_code，在执行的过程中，每一个函数（代码块）一旦被调用，首先会执行函数__pyarmor__解密第一层co_object,然后执行__pyarmor__或__pyarmor__解密第二层，它们负责恢复代码指令，代码块执行完之后，在返回上一级之前，会调用__armor_exit__把代码恢复成加密状态，那么解密的关键就是找到函数__pyarmor__、pyarmor、__pyarmor__并下断分析其解密逻辑，再编写脚本解密还原python代码即可。
2.相关结构体如下：
可能有些不准，具体情况具体分析
// ============================================================
// 1. PYC 文件头结构 (Python 3.7+)
// ============================================================
typedef struct {uint32_t magic; // 魔数: 标识 Python 版本 (如 0x610d0d0a)uint32_t bit_field; // 比特位字段: 校验模式标志 (PEP 552)uint32_t timestamp; // 源文件修改时间 (Unix 时间戳)uint32_t file_size; // 源文件大小 (字节)
} PycHeader;// 对于 Python 3.7 之前的版本 (12字节头)
typedef struct {uint32_t magic; // 魔数uint32_t timestamp; // 源文件修改时间uint32_t file_size; // 源文件大小
} PycHeaderLegacy;// ============================================================
// 2. 代码对象结构 (CodeObject) - 核心载荷
// ============================================================
// 注意: 这是逻辑结构，实际存储使用 marshal 序列化格式
struct PyCodeObject {PyObject_HEAD // 包含 ob_refcnt (引用计数) 和 ob_type (类型指针)// [偏移 +0x00] 8字节: Py_ssize_t ob_refcnt// [偏移 +0x08] 8字节: PyTypeObject* ob_type// 核心执行字段int co_argcount; // 位置参数（Positional arguments）的总个数// [偏移 +0x10] 4字节int co_posonlyargcount; // 仅限位置参数（Positional-only arguments）的个数 (Python 3.8+)// [偏移 +0x14] 4字节int co_kwonlyargcount; // 仅限关键字参数（Keyword-only arguments）的个数// [偏移 +0x18] 4字节int co_nlocals; // 局部变量的总数量（包括参数和内部定义的局部变量）// [偏移 +0x1C] 4字节int co_stacksize; // 虚拟机执行此代码时需要的最大栈空间大小（用于评估栈的分配）// [偏移 +0x20] 4字节int co_flags; // 标志位（比如 CO_GENERATOR, CO_COROUTINE 等）// [偏移 +0x24] 4字节 (此处编译器自动插入 4 字节 Padding 对齐到 0x28 的 8 字节边界)// 数据和代码指针PyObject *co_code; // 核心！指向字节码序列（通常是 bytes 对象，即 .pyc 里的指令部分）// [偏移 +0x28] 8字节PyObject *co_consts; // 常量元组（Tuple）：代码中用到的字面量（数字、字符串、None 等）// [偏移 +0x30] 8字节PyObject *co_names; // 名称元组（Tuple）：代码中用到的全局变量名和函数名（按顺序）// [偏移 +0x38] 8字节PyObject *co_varnames; // 变量名元组（Tuple）：局部变量名（包括参数名）// [偏移 +0x40] 8字节PyObject *co_freevars; // 自由变量元组（Tuple）：闭包用到的外层变量名// [偏移 +0x48] 8字节PyObject *co_cellvars; // 单元格变量元组（Tuple）：被内部嵌套函数引用的局部变量名// [偏移 +0x50] 8字节// 调试与元信息PyObject *co_filename; // 包含该代码的源文件路径（字符串对象）// [偏移 +0x58] 8字节PyObject *co_name; // 函数名或模块名（字符串对象）// [偏移 +0x60] 8字节int co_firstlineno; // 该代码块在源文件中的起始行号// [偏移 +0x68] 4字节 (此处编译器自动插入 4 字节 Padding 对齐到 0x70 的 8 字节边界)PyObject *co_lnotab; // 字节码偏移到源代码行号的映射表（字节串，用于报错和调试）// [偏移 +0x70] 8字节 (注: Python 3.11 中已变为 co_linetable)// 类型注解及其他（Py3.11 之前）PyObject *co_exceptiontable; // 异常处理表（Python 3.11 引入了更加优化的异常表）// [偏移 +0x78] 8字节PyObject *co_qualname; // 完全限定名称（如 `MyClass.my_method`），Python 3.11+ 新增// [偏移 +0x80] 8字节
};// ============================================================
// 3. Marshal 序列化标记 (用于解析嵌套结构)
// ============================================================
// marshal 格式使用类型标记来标识数据类型
typedef enum {TYPE_NULL = '0',TYPE_NONE = 'N',TYPE_FALSE = 'F',TYPE_TRUE = 'T',TYPE_STOPITER = 'S',TYPE_ELLIPSIS = '.',TYPE_INT = 'i',TYPE_INT64 = 'I',TYPE_FLOAT = 'f',TYPE_BINARY_FLOAT = 'g',TYPE_COMPLEX = 'x',TYPE_BINARY_COMPLEX = 'y',TYPE_LONG = 'l',TYPE_STRING = 's',TYPE_INTERNED = 't',TYPE_STRINGREF = 'R',TYPE_TUPLE = '(',TYPE_LIST = '[',TYPE_DICT = '{',TYPE_CODE = 'c',TYPE_UNICODE = 'u',TYPE_UNKNOWN = '?',TYPE_SET = '<',TYPE_FROZENSET = '>',TYPE_ASCII = 'a',TYPE_ASCII_INTERNED = 'A',TYPE_SMALL_TUPLE = ')',TYPE_SHORT_ASCII = 'z',TYPE_SHORT_ASCII_INTERNED = 'Z',
} MarshalType;// ============================================================
// 4. 完整的 PYC 文件结构
// ============================================================
typedef struct {PycHeader header; // 文件头 (16字节)PycCodeObject code_object; // 代码对象 (序列化存储)
} PycFile;// ============================================================
// 5. 实际解析示例 (C语言风格)
// ============================================================
#include <stdio.h>
#include <stdlib.h>// 读取 PYC 文件头
int read_pyc_header(FILE *fp, PycHeader *header) {size_t read = fread(header, sizeof(PycHeader), 1, fp);if (read != 1) return -1;// 验证魔数 (以 Python 3.10 为例: 0x610d0d0a)// 注意: 魔数会因 Python 版本而异printf("Magic: 0x%08X\n", header->magic);printf("Bit field: 0x%08X\n", header->bit_field);printf("Timestamp: %s", ctime(&header->timestamp));printf("File size: %u bytes\n", header->file_size);return 0;
}// 简化的 marshal 解析器 (仅示意)
int parse_marshal_object(FILE *fp, PyObject **obj) {uint8_t type;if (fread(&type, 1, 1, fp) != 1) return -1;switch (type) {case TYPE_CODE: {// 解析代码对象...// 这里需要递归解析所有字段break;}case TYPE_INT: {int32_t val;fread(&val, 4, 1, fp);break;}case TYPE_STRING: {uint32_t len;fread(&len, 4, 1, fp);char *str = malloc(len + 1);fread(str, 1, len, fp);str[len] = '\0';break;}// ... 其他类型}return 0;
}// ============================================================
// 6. Python 字节码指令结构 (反汇编用)
// ============================================================
typedef struct {uint8_t opcode; // 操作码 (如 LOAD_FAST, STORE_FAST)uint16_t arg; // 操作数 (参数)uint32_t offset; // 字节码偏移量
} BytecodeInstruction;// 常用操作码 (Python 3.10+)
#define OP_LOAD_FAST 124
#define OP_STORE_FAST 125
#define OP_LOAD_CONST 100
#define OP_LOAD_NAME 101
#define OP_STORE_NAME 102
#define OP_BINARY_OP 122
#define OP_RETURN_VALUE 83
#define OP_CALL_FUNCTION 131
#define OP_MAKE_FUNCTION 132
// ... 更多操作码// ============================================================
// 7. PyFrameObject结构
// ============================================================
typedef struct _frame {PyObject_VAR_HEAD // 对象头部，包含引用计数和类型信息struct _frame *f_back; // 上一级（调用者）的帧，若为 NULL 则是最外层帧PyCodeObject *f_code; // 0x18，指向当前执行的代码对象PyObject *f_builtins; // 当前帧的内置命名空间（builtins 字典）PyObject *f_globals; // 当前帧的全局命名空间（globals 字典）PyObject *f_locals; // 当前帧的局部命名空间（locals 字典/代理）PyObject **f_valuestack; // 指向值栈底部（第一个局部变量之后的位置）PyObject **f_stacktop; // 指向当前值栈的栈顶，用于栈的扩展PyObject *f_trace; // 关联的跟踪函数（用于调试和性能分析）// 异常相关字段，用于记录当前帧正在处理的异常PyObject *f_exc_type, *f_exc_value, *f_exc_traceback;PyThreadState *f_tstate; // 指向所属的线程状态int f_lasti; // 最后执行的字节码指令偏移量int f_lineno; // 当前正在执行的行号（仅当跟踪激活时有效）int f_iblock; // f_blockstack 数组的当前索引PyTryBlock f_blockstack[CO_MAXBLOCKS]; // 用于 try/except/finally 和循环的块栈PyObject *f_localsplus[1]; // 动态数组，存储局部变量和值栈元素
} PyFrameObject;
// ============================================================
// 8. libtomcrypt.dll库用到的ctr_state结构
// ============================================================
typedef struct {int cipher; // 使用的加密算法索引 (如 AES)int blocklen; // 加密算法的分组大小 (字节)int padlen; // 当前已使用的 "pad" 缓冲区字节数int mode; // 计数器递增模式 (大端/小端)，通常为 0unsigned char ctr[MAXBLOCKSIZE]; // 当前计数器值 (Counter)unsigned char pad[MAXBLOCKSIZE]; // 当前计数器加密后的密钥流 (Keystream)symmetric_key key; // 加密算法的扩展密钥调度表
} symmetric_CTR;
pyc文件结构关系图：
.pyc 文件结构
│
├── [文件头] (16字节)
│ ├── magic (4B) - Python版本标识
│ ├── bit_field (4B) - 校验模式标志
│ ├── timestamp (4B) - 源文件修改时间
│ └── file_size (4B) - 源文件大小
│
└── [序列化数据] (marshal格式)│└── CodeObject (递归结构)├── 元数据│ ├── argcount, kwonlyargcount│ ├── nlocals, stacksize, flags│ ├── filename, name│ └── firstlineno│├── 字节码│ ├── co_code (变长字节数组)│ └── co_lnotab (行号映射)│├── 常量表 (tuple)│ ├── 整数/浮点数│ ├── 字符串│ ├── 嵌套的 CodeObject│ └── ...│├── 名称表 (tuple)│ ├── 全局变量名│ └── 导入的模块名│├── 局部变量表│ ├── varnames (局部变量名)│ ├── cellvars (闭包变量)│ └── freevars (自由变量)│└── (Python 3.11+) 异常表└── 异常处理条目
关于魔数 (Magic Number)：不同 Python 主版本的魔数不同，例如：
Python 3.7: 0x420d0d0a
Python 3.8: 0x4d0d0d0a
Python 3.9: 0x5d0d0d0a
Python 3.10: 0x610d0d0a
Python 3.11: 0x6a0d0d0a
笔者这里是3.10版本的
二、逆向分析：
1.样本初步分析：
将我们打包好的加密文件拖进我们逆向分析的大哥——Exeinfo，可以发现64位，Pyinstaller打包，Python310模块
用解包工具解包，这里GitHub上有开源工具
- extremecoders-re/pyinstxtractor: PyInstaller Extractor
解包工具更推荐ng这个，不用匹配Python版本，而且是exe版本，方便使用
- pyinstxtractor/pyinstxtractor-ng: PyInstaller Extractor Next Generation
成功解包后用反编译工具pycdas和pycdc来反编译，这里Github上有开源工具，下载下来后用Cmake编译生成exe，并自行添加环境变量路径，后续既可以使用了，熟悉了基础指令，后续就可以交给AI，让AI来将pyc文件进行批量反编译核心文件，毕竟解包出来可能很多没有用的文件，只需要反编译核心文件即可
这里笔者样本里的核心pyc文件有五个，但是反编译出来都被加密了，如下截图
通过查阅学习是pyarmor加密，那么我们直接分析加密的5个文件即可，看看能不能逆向分析出来编写解密脚本，当然这里也有可取巧的方式不用解密，使用github上一个开源脚本工具PyArmor-Unpacker直接就可以静态dump出来，小白不会的，我就是哈哈，可以参考这篇帖子
- https://blog.csdn.net/gitblog_00120/article/details/157160790
github项目地址：
- https://www.bing.com/search?q=PyArmor-Unpacker&form=ANNTH1&refig=6a6f10b356f641a38cf2795aa7680cac&pc=CNNDDB
言归正传，继续逆向分析解密机制：
2.样本具体加解密流程：
（1）启动IDA、dbg：
现在该我们的二哥和三哥出场了，IDA、dbg，启动！
通过大致分析（这里包括但不限于IDA和dbg查找exe和相关dll的字符串和导出函数，关于逆向功底方面，笔者目前初出茅庐，就不过多谈前置分析），笔者觉得重要的是样本加载的一个重要模块_pytransform.dll，该模块是具体加解密模块，这个模块的导出函数如下：
可以看到关键的encrypt等函数，通过查阅官方文档和调试分析，该模块的执行流程如下：
（2）前置不重要的流程如下：
加载_pytransform.dll——调用init_module初始化并导入各类需要的模块，获取后续需要调用的关键函数（如marshal.loads，marshal.dumps），初始化一些加密算法用于后续校验本地license.lic文件的product.key——校验本地文件中的product.key——调用init_runtime函数，初始化各类函数地址和模块获取
（3）主要加解密流程：
在init_runtime函数里会获取6个重要的结构体，"armor","wraparmor","pyarmor","armor_enter","armor_exit","armor_wrap"
通过分析其结构体定义和内存布局如下，在下面这个结构体中可以寻址到他们对应的函数地址
struct PyMethod{char *name;PyCFunction *FunctionAddress;int flags;const char *doc_attribute;
}
我们先来看__pyarmor__这个函数
a.pyarmor：
单步步过会发现开始匹配入口头Pyarmor，并校验了头部
然后进入一个比较关键的函数Sub_70A0DC10
进入之后挨着dbg和ida同步调试分析，获取了一下当前调用栈帧PyFrameObject结构体
随后会发现走到一个这个LABEL_16分支里，这里就是最关键的解密co_object处，看到这些异或是不是很兴奋很激动，异或涉及一般都是密钥组成，哈哈那么我们来慢慢看看这个逻辑
通过分析，在调用Sub_70A26C50之前，做了四次异或操作，每次都是一个DWORD全局常量异或一个*(基地址+偏移)，一共4个，其中3个加了一些固定常量值，简化一下密钥逻辑：
k0=dword_70B227A6 ^ (DWORD)(v6+40);
k1=dword_70B227AA ^ (DWORD)(v6+44);
k2=dword_70B227AE^ (DWORD)(v6+48);
k3=dword_70B227B2^ (DWORD)(v6+52);
后面的三个函数j进去之后就是初始化AES-GCM状态、设置IV、调用解密函数，那么根据这个大致就能得出解密脚本编写用AES-GCM解密
b.armor_enter:
先断到这个函数
后面就是基本功了，慢慢看每个函数的作用，之后获得了Frame，然后来到了解密函数
进入这个函数，用dbg和ida同步调试，最终到这个分支，这个就是关键的密钥生成和异或数据位置
简化伪代码如下，v26是解密代码起始处，v29是解密代码结束处，全局常量70B227B2
// 初始化
v53 = xmmword_70B227B2
v54 = qword_70B227C2
v29 = &v26[(unsigned int)v28 >> 2] // 循环结束地址// 用 v14 的 4 个 DWORD 异或更新 v53 的四个字段
v53.d0 = v14[0] ^ xmmword_70B227B2.d0
v53.d1 = (v14[1] - 2869) ^ xmmword_70B227B2.d1
v53.d2 = (v14[2] + 54958) ^ xmmword_70B227B2.d2
v53.d3 = (v14[3] + 59843) ^ xmmword_70B227B2.d3v30 = &v53// 循环处理 v26 指向的数组
while (v26 != v29) {v31 = *(DWORD *)v30 ^ *v26 // 取 v30 指向的 4 字节与当前 v26 值异或*v26 = v31 + 56597 // 加常数后写回v26++ // 移动目标指针v30 += 4 // 移动源指针（4字节）if (v30 == &v55) // 若超出 v53 范围，则回绕v30 = &v53
}
c.armor：
armor分支稍微难弄一点，里面有一个魔改，这个弄了有点久，让我们细细看看吧
先断到该函数处
然后依旧是dbg动态调试观察数据什么时候被解密，定位解密位置
先是获取Frame，这个rax就是获取Frame的函数，因为截图接不上，就i索性直接描述了，这个函数就是帮我们定位加密数据的，后续就是看哪个函数或者哪串代码在解密这个数据
在慢长的过程中定位到这个函数
进去之后最终定位到解密关键位置，如下图，
伪代码如下，经过分析，计算4个值生成16字节key，然后传入Sub_70A3E650初始化AES-CTR状态，然后将CTR状态传入Sub_70A2E020
// 计算4个值
v33 = qword_70B22799 ^ v14;
v34 = (v15 - 62069) ^ HI32(qword_70B22799);
v36 = (v17 + 52569) ^ HI32(qword_70B227A1);
v35 = qword_70B227A1 ^ (v16 + 45232);// 两个函数调用都必须返回0
if (!sub_70A2E650(dword_70B227E8, a5, &v33, 16, 0, 0, v39) &&!sub_70A2E020(&v8[v12], v8, v11, v39)) {// 成功路径
}
起初直接用还原key算法后调用官方加解密库函数，发现数据跟解密后的数据完全不一样，后不调用py层加解密库函数，调用c层，为此还找了github源码编译了libtomcrypt.dll模块，然后调用里面的C层函数，结果还是有问题，最后经过排除Sub_70A2E650初始化CTR状态是正常的，但是sub_70A2E020里进行了魔改，先说一下函数原型
// CTR加密函数原型
int ctr_encrypt(const unsigned char* pt, // 明文unsigned char* ct, // [out] 密文unsigned long len, // 明文长度symmetric_CTR* ctr); // CTR状态// 原代码调用
if (!sub_70A2E650(dword_70B227E8, a5, &v33, 16, 0, 0, v39) &&!sub_70A2E020(&v8[v12], v8, v11, v39)) {// 成功
}
然后在dbg传参时，明文数据往后移了两位，密文输出是正常的，笔者写到这里发现自己写的解密脚本似乎不用进入函数来修改异或往后移动2位，不过就当学习了
另外有兴趣的友友可以看看在这个函数内部，异或数据是通过CTR状态里的密钥流来异或数据的，CTR状态在调用sub_70A2E650初始化时生成了第一串16字节密钥流，这个16字节密钥流就是IV，然后调用sub_70A2E020函数，每次异或8字节，如下图
异或2次用完16字节密钥流后，随后调用回调函数ptr_3DES函数生成新的密钥流，最后剩余加密数据不足8字节的时候就是逐字节异或的，如下图
三、编写解密脚本：
1.解密对象体co_object：
import struct, sys
from pathlib import Path
from Crypto.Cipher import AES
from Crypto.Util import Counter# 运行时常量 (从 _pytransform.dll 动态调试提取)
C0, C1, C2, C3 = 0x88A79C6E, 0x8E7DBF79, 0xFD4A0D05, 0xE73E7FD6
M1, M2, M3=15138,32815,9498def decrypt(pyc_path, out_path):data = Path(pyc_path).read_bytes()pos = data.find(b'PYARMOR') # 定位 PyArmor 头h = data[pos:]off, size = struct.unpack_from('<II', h, 28) # 密文偏移和长度H = struct.unpack_from('<IIII', h, 40) # 4个密钥iv = h[40:52] # 12字节 IV# 派生 AES-128 密钥: K=C^f(H)key = struct.pack('<IIII',C0 ^ H[0],C1 ^ ((H[1] - M1) & 0xFFFFFFFF),C2 ^ ((H[2] + M2) & 0xFFFFFFFF),C3 ^ ((H[3] + M3) & 0xFFFFFFFF))print(f"[-] Key: {key.hex()}")print(f"[-] IV: {iv.hex()}")# AES-CTR 解密ct = data[pos + off : pos + off + size]pt = AES.new(key, AES.MODE_CTR,counter=Counter.new(32, prefix=iv, initial_value=2)).decrypt(ct)# 重建 pyc (Python 3.10 魔数 + 12字节零头 + marshal数据)Path(out_path).write_bytes(b'\x6f\x0d\x0d\x0a' + b'\x00' * 12 + pt)print(f"[+] {pyc_path} -> {out_path} ({len(pt) + 16} bytes)")if __name__ == '__main__':if len(sys.argv) > 1:decrypt(sys.argv[1], sys.argv[2] if len(sys.argv) > 2 else 'decrypted.pyc')else:for f in ['core', 'crypto', 'error_codes', 'mitmp', 'task_automation']:decrypt(f'{f}.pyc', f'decrypted_{f}.pyc')2.解密字节码co_code：
（1）decrypt2.py：
import struct, sys, marshal, types, opcode, ctypes
import decrypt2_help
from Crypto.Cipher import AES_aes_ecb = None # AES ECB cipher 对象, 在 ctr_init 中创建def _ecb_encrypt_callback(counter_addr, stream_addr, key_state_addr):"""回调: AES_ECB(counter) -> keystream, 写入 stream_addr"""counter = ctypes.string_at(counter_addr, 16)keystream = _aes_ecb.encrypt(counter)ctypes.memmove(stream_addr, keystream, 16)return 0decrypt2_help.ECB_ENCRYPT_CALLBACK = _ecb_encrypt_callbackdef ctr_init(key_material, key):"""初始化 CTR 状态 (替代 libtomcrypt ctr_start).key_material: 16 字节 IV key: 16 字节 AES key返回: ctypes 缓冲区 (CTR_State)"""global _aes_ecb_aes_ecb = AES.new(key, AES.MODE_ECB)ctr_state = (ctypes.c_ubyte * 512)()state = ctypes.cast(ctr_state, ctypes.POINTER(decrypt2_help.CTR_State)).contents# 手动初始化 CTR_State (对应 ctr_start 的行为)state.algo_idx = 0state.block_len = 16state.buf_used = 0 # padlen=0: keystream 已就绪state.ctr_mode = 0 # little-endian counterstate.ctr_len = 16for i in range(16):state.counter[i] = key_material[i]# 生成第一个 keystream block (ctr_start 会做这一步)first_ks = _aes_ecb.encrypt(bytes(key_material))for i in range(16):state.stream[i] = first_ks[i]return ctr_state# ==================== __armor_enter__ 常量 ====================
C = [0xE73E7FD6, 0x2A9892B0, 0x21E0FAB7, 0x5DFF679C]
V54 = [0xB2FE28F4, 0xE6206DF4]
M1, M2, M3, M4=2869, 52819, 9498, 56597# ==================== __armor__ AES-CTR 常量 ====================
#
# K0 = C0 ^ H0, K1 = C1 ^ (H1 - M1), K2 = C2 ^ (H2 + M2), K3 = C3 ^ (H3 + M3)
_AES_C0 = 0x574E0BA8
_AES_C1 = 0x8729235D
_AES_C2 = 0x8419C034
_AES_C3 = 0xA79C6EA5
_AES_M1, _AES_M2, _AES_M3 = 62069, 45232, 52569 # 0xF275, 0xB0B0, 0xCD59# ==================== Opcode 常量 ====================
LOAD_GLOBAL = opcode.opmap["LOAD_GLOBAL"]
RETURN_OPCODE = opcode.opmap["RETURN_VALUE"].to_bytes(2, byteorder='little')
SETUP_FINALLY = opcode.opmap["SETUP_FINALLY"]
EXTENDED_ARG = opcode.opmap["EXTENDED_ARG"]
JUMP_FORWARD = opcode.opmap["JUMP_FORWARD"]
JUMP_ABSOLUTE = opcode.opmap.get("JUMP_ABSOLUTE", -1)
POP_JUMP_IF_FALSE = opcode.opmap.get("POP_JUMP_IF_FALSE", -1)
POP_JUMP_IF_TRUE = opcode.opmap.get("POP_JUMP_IF_TRUE", -1)
JUMP_IF_FALSE_OR_POP = opcode.opmap.get("JUMP_IF_FALSE_OR_POP", -1)
JUMP_IF_TRUE_OR_POP = opcode.opmap.get("JUMP_IF_TRUE_OR_POP", -1)
CONTINUE_LOOP = opcode.opmap.get("CONTINUE_LOOP", -1)ABSOLUTE_JUMPS = [op for op in [JUMP_ABSOLUTE, CONTINUE_LOOP, POP_JUMP_IF_FALSE,POP_JUMP_IF_TRUE, JUMP_IF_FALSE_OR_POP, JUMP_IF_TRUE_OR_POP] if op >= 0]
DOUBLE_JUMP = sys.version_info >= (3, 10)# ==================== 路径 ====================
_path=''def bootstrap_mode_decrypt(co_code_bytes):"""Bootstrap Mode 解密: plaintext[i] = ciphertext[i] ^ ks[i%6]"""# ==================== Super Mode 解密 ====================def super_mode_decrypt(co_code_bytes, bootstrap_len=32, tail_len=16):"""Super Mode 解密: plaintext = (ciphertext ^ ks[i%6]) + 56597"""code = bytearray(co_code_bytes)t = struct.unpack('<4I', code[-tail_len:])ks = [t[0] ^ C[0],((t[1] - M1) & 0xFFFFFFFF) ^ C[1],((t[2] + M2) & 0xFFFFFFFF) ^ C[2],((t[3] + M3) & 0xFFFFFFFF) ^ C[3],V54[0],V54[1]]enc_body = code[bootstrap_len:-tail_len]dec_body = bytearray(len(enc_body))for i in range(0, len(enc_body) - len(enc_body) % 4, 4):cdw = struct.unpack_from('<I', enc_body, i)[0]pdw = ((cdw ^ ks[(i // 4) % 6]) + M4) & 0xFFFFFFFFstruct.pack_into('<I', dec_body, i, pdw)rem = len(enc_body) % 4if rem:dec_body[-rem:] = enc_body[-rem:]code[bootstrap_len:-tail_len] = dec_bodyreturn bytes(code)# ==================== 字节码工具 ====================def find_first_opcode(co, op_code):for i in range(0, len(co), 2):if co[i] == op_code:return iraise ValueError("Could not find the opcode")def get_arg_bytes(co, op_code_index):result = bytearray()result.append(co[op_code_index + 1])checked = op_code_index - 2while checked >= 0 and co[checked] == EXTENDED_ARG:result.insert(0, co[checked + 1])checked -= 2return resultdef calculate_arg(co, op_code_index):return int.from_bytes(get_arg_bytes(co, op_code_index), 'big')def calculate_extended_args(arg):extended_args = []new_arg = argif arg > 255:ext = arg >> 8while True:if ext > 255:extended_args.append(ext & 255)ext >>= 8else:extended_args.append(ext)extended_args.reverse()breaknew_arg = arg & 255return extended_args, new_arg# ==================== 代码对象处理 ====================code_attrs = ['co_argcount', 'co_posonlyargcount', 'co_kwonlyargcount','co_nlocals', 'co_stacksize', 'co_flags', 'co_code','co_consts', 'co_names', 'co_varnames', 'co_filename','co_name', 'co_firstlineno', 'co_lnotab','co_freevars', 'co_cellvars'
]def copy_code_obj(obj, **kwargs):args = [kwargs.get(name, getattr(obj, name)) for name in code_attrs]return types.CodeType(*args)def handle_armor_enter(obj):"""Super Mode 解密 + try 框架移除 + 跳转重计算"""# 1. Super Mode 静态解密dec_code = super_mode_decrypt(obj.co_code)# 2. 计算 fake_exit (__armor_exit__ 调用位置)exit_idx = obj.co_names.index("__armor_exit__")load_exit = bytes([LOAD_GLOBAL, exit_idx])exit_pos = dec_code.find(load_exit)fake_exit = exit_pos - 2# 3. 找到 SETUP_FINALLY，计算 try 块大小try_start = find_first_opcode(dec_code, SETUP_FINALLY)size = calculate_arg(dec_code, try_start)if DOUBLE_JUMP:size *= 2# 4. 提取 try 块体 (移除 try 框架)raw_code = bytearray(dec_code[try_start + 2 : try_start + size])raw_code += RETURN_OPCODE# 5. 调整绝对跳转i = 0while i < len(raw_code):op = raw_code[i]if op in ABSOLUTE_JUMPS:argument = calculate_arg(raw_code, i)# 移除前导 EXTENDED_ARGwhile i >= 2 and raw_code[i - 2] == EXTENDED_ARG:raw_code.pop(i - 2)raw_code.pop(i - 2)i -= 2if DOUBLE_JUMP:argument *= 2# 跳转到 __armor_exit__ -> 替换为 RETURN_VALUEif argument == fake_exit:raw_code[i] = opcode.opmap["RETURN_VALUE"]i += 2continue# 调整跳转目标: 减去移除的偏移量new_arg = argument - (try_start + 2)ext_args, new_arg = calculate_extended_args(new_arg)for ea in ext_args:raw_code.insert(i, EXTENDED_ARG)raw_code.insert(i + 1, ea if not DOUBLE_JUMP else ea // 2)i += 2raw_code[i + 1] = new_arg if not DOUBLE_JUMP else new_arg // 2i += 2# 6. 移除 __armor* 名称new_names = tuple(n for n in obj.co_names if not n.startswith("__armor"))return copy_code_obj(obj, co_names=new_names, co_code=bytes(raw_code))def handle_under_armor(obj):"""处理 __armor__ 代码对象: AES-128-CTR 静态解密"""# 1. 找 JUMP_FORWARD, 计算 jumping_arg (加密体与 exit_handler 分界线)i = find_first_opcode(obj.co_code, JUMP_FORWARD)jumping_arg = i + calculate_arg(obj.co_code, i)if DOUBLE_JUMP:jumping_arg *= 2# 2. 末尾 16 字节 = IV, 前面 jumping_arg 字节 = 密文 (含 2 字节 JUMP_FORWARD)key_material = obj.co_code[-16:]ciphertext = obj.co_code[:jumping_arg]# 3. 派生 AES-128 keyH0, H1, H2, H3 = struct.unpack('<4I', key_material)K0 = _AES_C0 ^ H0K1 = _AES_C1 ^ ((H1 - _AES_M1) & 0xFFFFFFFF)K2 = _AES_C2 ^ ((H2 + _AES_M2) & 0xFFFFFFFF)K3 = _AES_C3 ^ ((H3 + _AES_M3) & 0xFFFFFFFF)key = struct.pack('<IIII', K0, K1, K2, K3)# 4. 初始化 CTR 状态 (PyCryptodome AES ECB 替代 libtomcrypt)ctr_state = ctr_init(key_material, key)# 5. 解密 (重新实现的魔改ctr_encrypt)ct_buf = (ctypes.c_ubyte * len(ciphertext))(*ciphertext)pt_buf = (ctypes.c_ubyte * len(ciphertext))()decrypt2_help.ctr_encrypt(ct_buf, pt_buf, len(ciphertext), ctr_state)dec_code = bytes(pt_buf)# 6. 移除 __armor__ 名称new_names = tuple(n for n in obj.co_names if n != "__armor__")return copy_code_obj(obj, co_names=new_names, co_code=dec_code)def output_code(obj):"""递归处理代码对象"""if not isinstance(obj, types.CodeType):return obj# protect_pytransform -> 替换为 fake 函数if obj.co_name == "protect_pytransform":return types.CodeType(0, 0, 0, 0, 1, 83, b'd\x00S\x00', (None,), (), (),_path,'fake', 202, b'\x00\x01', (), ())# 递归处理子对象obj = copy_code_obj(obj,co_consts=tuple(output_code(c) for c in obj.co_consts),)# 检测解密策略并应用if "__armor_enter__" in obj.co_names:obj = handle_armor_enter(obj)elif "__armor__" in obj.co_names:obj = handle_under_armor(obj)return obj# ==================== pyc 重构 ====================def code_to_bytecode(code, mtime=0, source_size=0):data = bytearray(b'\x6f\x0d\x0d\x0a') # Python 3.10 magicdata.extend(struct.pack('<I', 0)) # flagsdata.extend(struct.pack('<I', int(mtime)))data.extend(struct.pack('<I', source_size))data.extend(marshal.dumps(code))return data# ==================== 主入口 ====================if __name__ == '__main__':infile = sys.argv[1] if len(sys.argv) > 1 else 'decrypted_core.pyc'outfile = sys.argv[2] if len(sys.argv) > 2 else 'Test_output.pyc'with open(infile, 'rb') as f:data = f.read()code = marshal.loads(data[16:])result = output_code(code)pyc = code_to_bytecode(result)with open(outfile, 'wb') as f:f.write(pyc)print(f"输出: {outfile} ({len(pyc)} bytes)")（2）decrypt2_help.py：
import ctypes# ==================== CTR 状态结构 (对应 libtomcrypt symmetric_CTR) ====================
# 逆向自 _pytransform.dll sub_70A2E090, 偏移以 int* 为基准 (a4[N])
class CTR_State(ctypes.Structure):_pack_ = 1_fields_ = [("algo_idx", ctypes.c_int), # a4[0] cipher index("block_len", ctypes.c_int), # a4[1] block size (16)("buf_used", ctypes.c_uint), # a4[2] keystream 已用字节数("ctr_mode", ctypes.c_int), # a4[3] 0=little-endian, 1=big-endian("ctr_len", ctypes.c_int), # a4[4] counter 宽度("counter", ctypes.c_ubyte * 128), # a4[5] counter / IV("stream", ctypes.c_ubyte * 128), # a4[37] keystream block("last_block", ctypes.c_ubyte * 128), # a4[70] symmetric_key (未使用, 保留对齐)]# 外部注入: AES_ECB(counter_ptr, stream_ptr, key_ptr) -> int
ECB_ENCRYPT_CALLBACK = None# ==================== CTR 加密/解密 (严格还原 sub_70A2E090) ====================
# 执行流程:
# buf_used=0 -> LABEL_34: 用预生成的 keystream 整块 XOR 16 字节
# buf_used=16 -> 递增 counter -> 回调生成新 keystream -> buf_used=0 -> LABEL_34
# LABEL_34 剩余不足 16 -> v11=0, goto LABEL_4 逐字节
# LABEL_4: XOR stream[buf_used] 一个字节, buf_used++def ctr_encrypt(ct_buf, pt_buf, length, ctr_state):"""CTR 加密/解密 (CTR 模式下两者相同), 直接操作外部 ctypes 数组内存."""if length == 0:return 0if ECB_ENCRYPT_CALLBACK is None:raise RuntimeError("未设置 ECB_ENCRYPT_CALLBACK")state = ctypes.cast(ctr_state, ctypes.POINTER(CTR_State)).contentsstream_addr = ctypes.addressof(state.stream)remaining = lengthpt_addr = ctypes.addressof(pt_buf) if isinstance(pt_buf, ctypes.Array) else pt_bufct_addr = ctypes.addressof(ct_buf) if isinstance(ct_buf, ctypes.Array) else ct_bufwhile True:block_len = state.block_len# ---- buf_used == block_len: 递增 counter + 回调生成 keystream ----if state.buf_used == block_len:ctr_len = state.ctr_lenif state.ctr_mode: # 大端idx = block_len - 1while idx >= ctr_len:val = (state.counter[idx] + 1) & 0xFFstate.counter[idx] = valif val != 0: breakidx -= 1else: # 小端 (默认)idx = 0while idx < ctr_len:val = (state.counter[idx] + 1) & 0xFFstate.counter[idx] = valif val != 0: breakidx += 1result = ECB_ENCRYPT_CALLBACK(ctypes.addressof(state.counter),stream_addr,ctypes.addressof(state.last_block))if result != 0:return resultstate.buf_used = 0# fall through -> LABEL_34# ---- LABEL_34: 整块 XOR (buf_used == 0) ----if state.buf_used == 0:if block_len > remaining:# 剩余不足一块 -> 逐字节 (LABEL_4: v11=0)ct_byte = ctypes.c_uint8.from_address(ct_addr).valuestream_byte = ctypes.c_uint8.from_address(stream_addr).valuectypes.c_uint8.from_address(pt_addr).value = ct_byte ^ stream_byteremaining -= 1ct_addr += 1pt_addr += 1state.buf_used = 1if remaining == 0:return 0else:# 满块 XOR (每次 8 字节 QWORD)for i in range(0, block_len, 8):if i + 8 > block_len:break# 此处的+2即加密魔改处ct_q = ctypes.c_uint64.from_address(ct_addr + i + 2).valuest_q = ctypes.c_uint64.from_address(stream_addr + i).valuectypes.c_uint64.from_address(pt_addr + i).value = ct_q ^ st_qremaining -= block_lenstate.buf_used = block_lenct_addr += block_lenpt_addr += block_lenif remaining == 0:return 0else:# ---- LABEL_4: 逐字节 XOR (0 < buf_used < block_len) ----# 此处的+2即加密魔改处ct_byte = ctypes.c_uint8.from_address(ct_addr + 2).valuestream_byte = ctypes.c_uint8.from_address(stream_addr + state.buf_used).valuectypes.c_uint8.from_address(pt_addr).value = ct_byte ^ stream_byteremaining -= 1ct_addr += 1pt_addr += 1state.buf_used += 1if remaining == 0:return 0四、解密密钥常量溯源：
1.解密密钥的常量为这些：
有C标注的是动态生成的全局常量，有M标注的是直接的数据
这些数据的常量基地址如下：
第一层解密：70b227a6
第二层解密：70b227b2，70b22799
2.定位函数：
赋值常量的函数为如下这个，这个函数里面是一个巨大的switch-case结构，相信大家听到这个词应该就知道这是一个的VM了吧哈哈，单纯自己手动静态动态肯定是不行的，那么把静态反编译的这个函数扔给AI，让AI给我们筛选一下重要逻辑
经过分析，这里列举一些比较重要的，有检测debugger字段的、有设置线程信息的、有异常退出的、最重要的是一个循环异或很多次数据生成全局常量的case，如下图v10==2即为该逻辑
经过分析v13内部有一个时间校验，每次异或常量数据的时候都会调用clock获得当前时间来跟下一次作比对，小于1s就进入异常分支。
这里笔者先是才用临时patch的方法来看看后面逻辑
patch几次后，找到了常量的生成的异或逻辑，如下图
第一次：278C26B1790是模块里的.data数据
伪代码如下：
// 循环24次，根据输入参数查表生成字节
uint64_t base = 0x278C26B1790; // 密钥表
uint8_t* dest = 0x70B22780; // 输出缓冲区
uint64_t idx = input; // 初始索引for (int i = 0; i < 0x18; i++) {uint64_t offset = (idx * 4 + 0x10) % 0x8C; // 计算表偏移dest[i] = *(uint8_t*)(base + offset); // 查表写入
}
后续有很多这种异或逻辑，都是这种框架，且数值在变化，不可能人工还原算法，索性就hook一下时间校验函数，然后直接F9拿到最终的常量数据
hook脚本用的是dbg内自带脚本功能，代码可能不太好看，如果用Python写脚本的话可以参考这个项目，不过要装VS2015和Python2.7
- x64dbg/x64dbgpy: Automating x64dbg using Python, Snapshots:
这里笔者就只用了一下自带的脚本功能来编写脚本，脚本如下，注意用下面这个脚本需要写入一个txt文档让dbg加载
// ============================================================
// Hook Script for kernelbase.dll!GetSystemTimeAsFileTime
// 兼容 x64dbg 脚本引擎
// ============================================================// ==== 配置：固定时间 (2023-06-15 12:00:00 UTC) ====
$fixedHigh = 0x01D941A0
$fixedLow = 0xEBC3D800// 拼接为完整的 64 位立即数 (高位左移32位 + 低位)
$fixedTime = $fixedHigh * 0x100000000 + $fixedLow// ==== 获取 API 地址 ====
$apiAddr = kernelbase.dll:GetSystemTimeAsFileTime
cmp $apiAddr, 0
je exit_scriptlog "[+] 目标函数 VA: 0x{$apiAddr}"// ==== 分配执行内存并写入 Fake 函数 ====
alloc 100
$fakeAddr = $result
cmp $fakeAddr, 0
je exit_scriptlog "[+] 分配的 Fake 内存: 0x{$fakeAddr}"// 写入 Fake 函数逻辑 (直接载入64位立即数并写入RCX传参缓冲区)
// API 原型: VOID GetSystemTimeAsFileTime(LPFILETIME lpSystemTimeAsFileTime)
// RCX 指向调用方提供的缓冲区，将伪造时间直接写入该缓冲区
asm $fakeAddr, "mov rax, 0x{$fixedTime}" // 长度 5 (B8 + 4字节)
asm $fakeAddr+0A, "mov qword ptr [rcx], rax" // 长度 3 (48 89 01)
asm $fakeAddr+0D, "ret" // 长度 1 (C3)// ==== 安装 Hook ====
// 覆盖原函数开头 16 字节为 NOP，防止多线程竞争时残留部分原指令
fill $apiAddr, 16, 0x90// 写入绝对跳转指令 (跨模块跳转超出 rel32 范围，使用寄存器间接跳转)
asm $apiAddr, "mov rax, 0x{$fakeAddr}" // 长度 10 (48:B8 + 8字节)
asm $apiAddr+0A, "jmp rax" // 长度 2 (FF E0)log "[+] HOOK 安装成功! 返回固定时间: 0x{$fixedTime}"exit_script:
ret
最终获取的常量数据如下
五、相关贴子参考学习：
-
https://blog.betamao.me/posts/2022/python-pyarmor-crack/
-
https://zhuanlan.zhihu.com/p/609709232
-
Python常见的各种加密解密算法 - 吾爱破解 - 52pojie.cn
 - 热点品牌推荐)
