batmanpriv/PyObfuscator
GitHub: batmanpriv/PyObfuscator
一款专业级 Python 源代码混淆引擎，通过编码压缩、AST 转换、多层加密和死代码注入等手段大幅增加逆向分析与反编译的难度。
Stars: 0 | Forks: 0
# PyObfuscator
**高级 Python 代码混淆引擎**
*通过多层加密和 AST 级别转换来保护 Python 源代码的综合工具包*
[](https://www.python.org/)
[](LICENSE)
[]()
## 📌 概述
PyObfuscator 是一款专业级的 Python 混淆工具，提供 **45 种不同的保护方法**，从简单的编码到高级的 AST 操作和多层加密保护。每种技术都旨在显著增加逆向工程、反编译和代码分析的难度。
## 📸 界面预览
## ⚡ 混淆方法
### 基于编码的方法（选项 1–40）
| 方法 | 描述 | 保护级别 |
|--------|-------------|------------------|
| 1–7 | **单层**（Marshal, Zlib, GZIP, LZMA, Base16/32/64） | 低 |
| 8–16 | **双层**（压缩 + 编码组合） | 中 |
| 17–31 | **Marshal + 压缩/编码** | 中高 |
| 32–40 | **多层**（结合 Marshal, Zlib, LZMA, GZIP, Base64 的 3-5 层） | 高 |
### 高级混淆方法（选项 41–45）
| 选项 | 方法 | 描述 |
|--------|--------|-------------|
| **41** | 简单混淆 | 5 层嵌套压缩 + marshaling，并带有动态解码 |
| **42** | 深度 XOR 混淆 | 采用 XOR 加密，带有递归包装层和防篡改检查 |
| **43** | AST 混淆 | 控制流平坦化，变量重命名，字符串加密 (AES-256-CBC) |
| **44** | CJK 混淆 | 带有 CJK 变量名的 AST 转换 + 死代码注入 + 10 层保护流水线 |
| **45** | 极致混淆 | 四层加密保护 (AES-256-GCM + ChaCha20 + Salsa20 + XOR) |
## 🧠 技术深入解析
### 1. AST 级别转换（选项 43）
在编译前直接操作 Python 的抽象语法树：
**控制流平坦化**
将具有嵌套条件和循环的结构化代码转换为平坦的状态机：
```
# 原始
if x > 0:
do_something()
else:
do_other()
# 转换后
state = 0
while state < 2:
if state == 0:
if x > 0:
do_something()
state = 1
elif state == 1:
do_other()
state = 2
```
这消除了可预测的控制流，使得手动分析和自动化反混淆变得极其困难。
**变量重命名**
所有用户定义的变量名都会被替换为确定性但无意义的标识符（`v_3a8f2b1c`），从而破坏语义理解。
**字符串加密**
所有字符串文字均使用 AES-256-CBC 进行加密，每个字符串都有唯一的初始化向量。运行时解密通过注入的解密函数完成。
### 2. CJK 混淆（选项 44）
这种方法旨在通过大量的代码注入来击败反编译器并迷惑人类阅读者：
**CJK 变量名**
变量使用韩文、中文和日语字符命名：
```
홁 = [2847 for _ in range(45)]
鰿 = {(lambda 鍘: 鍘 ^ 127)(i) for i in range(30)}
桽 = [(lambda 鼜, 鰪: 鼜 * 鰪)(i, j) for i in range(67)]
```
这些字符是有效的 Python 标识符，但在视觉上容易引起混淆，并会导致语法高亮显示和反编译器出现故障。
**死代码注入**
注入数百行无意义的操作：列表推导式、嵌套 lambda、字典推导式以及冗长的 CJK 注释块。这会使代码大小增加 15-30 倍，并为分析工具制造需要处理的海量垃圾数据。
**多层保护流水线**
```
Original Source Code
↓
AST Transformation (Flatten + Rename + String Encryption)
↓
Marshal Serialization
↓
Zlib Compression (Level 9) — First pass
↓
Zlib Compression (Level 9) — Second pass
↓
BZ2 Compression
↓
LZMA Compression
↓
Base85 Encoding
↓
XOR-32 (32-byte random key)
↓
Shuffle Permutation (random index reordering)
↓
RC4 Encryption (16-byte random key)
↓
LCG-XOR (Linear Congruential Generator)
↓
Base64 Encoding
↓
Final Protected Code
```
**核心特性：**
- 每一层使用不同的算法，防止单点解密
- 打乱层破坏了压缩数据中的模式识别
- LCG-XOR 产生抗统计分析的伪随机输出
- 加密前进行压缩以消除数据冗余
### 3. 极致混淆（选项 45）
**四层加密架构：**
| 层 | 算法 | 密钥大小 | Nonce/IV | 目的 |
|-------|-----------|----------|----------|---------|
| 1 | AES-256-GCM | 256 位 | 96 位 | 提供完整性的认证加密 |
| 2 | ChaCha20 | 256 位 | 96 位 | 高性能流密码 |
| 3 | Salsa20 | 256 位 | 64 位 | 额外的混淆层 |
| 4 | XOR | 256 字节 | N/A | 最终转换层 |
**密钥派生：**
所有加密密钥均使用 **scrypt** 从 64 字节的主熵中派生出来：
```
scrypt(master_entropy, salt, N=65536, r=8, p=1)
```
使用这些参数，单次密钥派生大约需要 ~100ms 的 CPU 时间，这使得暴力破解攻击在计算上是不可行的。
**运行时保护：**
生成的加载器包括：
- 诱饵函数的随机打乱
- 随机化的执行模式
- 用于反调试的秘密 token 生成
- 如果缺失，自动安装 pycryptodome
### 4. 深度 XOR 混淆（选项 42）
实现基于 XOR 的加密，具有：
- 16 字节或自定义的 XOR 密钥
- 可配置的递归包装层（默认：4 层）
- 加密前的 Zlib 压缩
- 加密数据的 Base64 编码
- 带有反调试检查的运行时解密
- 用于逃避检测的后台线程执行
### 5. 编码链系统（选项 1–40）
CodecEngine 提供了一条灵活的编码流水线，支持以下组合：
每种组合都使用逆序解码，并且所有编码的数据都进行了字节反转以实现额外的混淆。
## 🚀 安装
```
# Clone the repository
git clone https://github.com/batmanpriv/PyObfuscator.git
cd PyObfuscator
# Run the tool (auto-installs pycryptodome if missing)
python PyObfuscator.py
```
**环境要求：**
- Python 3.6 或更高版本
- pycryptodome（如缺失会自动安装）
- 标准库模块（均包含在 Python 发行版中）
## 📖 使用指南
### 基本用法
```
python PyObfuscator.py
```
1. 选择一种混淆方法 (1–45)
2. 输入你的 Python 文件路径
3. 对于需要额外输入的方法：
- **选项 42：** 自定义密钥（可选）和层数
- 所有其他方法：编码循环次数（重复编码的次数）
### 示例
**示例 1：基本保护**
```
$ python PyObfuscator.py
[+] Option: 10
[+] File Name: script.py
[+] Encode Count: 5
[+] Obfuscation complete: script_obfuscated.py
[+] Size: 12.3 KB
```
**示例 2：最高保护**
```
$ python PyObfuscator.py
[+] Option: 45
[+] File Name: sensitive.py
[+] Encode Count: 3
[+] Obfuscation complete: sensitive_ultra.py
[+] Size: 184.7 KB
```
### 方法选择指南
| 使用场景 | 推荐方法 |
|----------|----------------------|
| 快速的基本保护 | 1–7 |
| 适度保护且体积增加最小 | 8–16 |
| 商业软件保护 | 17–40, 43 |
| 抵抗反编译器的保护 | 44 |
| 最高安全性 | 45 |
| API 密钥 / 凭据保护 | 42–45 |
## 📊 性能特征
| 方法组 | 体积膨胀 | 处理时间 | 内存占用 | 安全级别 |
|--------------|---------------|-----------------|--------------|----------------|
| 选项 1–7 | 1.5–2 倍 | <1秒 | <50MB | 基础 |
| 选项 8–16 | 2–3 倍 | <2秒 | <100MB | 中等 |
| 选项 17–31 | 3–4 倍 | 2–4秒 | <150MB | 高 |
| 选项 32–40 | 4–5 倍 | 3–5秒 | <200MB | 极高 |
| 选项 41 | 2–3 倍 | <2秒 | <100MB | 中等 |
| 选项 42 | 5–8 倍 | 3–7秒 | <200MB | 高 |
| 选项 43 | 8–12 倍 | 4–8秒 | <250MB | 极高 |
| 选项 44 | 15–30 倍 | 5–10秒 | <500MB | 极限 |
| 选项 45 | 10–20 倍 | 3–6秒 | <300MB | 军事级 |
## 🔧 技术规格
**支持的 Python 版本：** 3.6 – 3.13
**依赖项：**
- `pycryptodome` >= 3.15.0（自动安装）
**输入文件限制：**
- 编码方法：无限制
- AST 方法：建议 < 10MB
- CJK 方法：建议 < 5MB
**输出文件特征：**
- 方法 44：注入了 200–500 行垃圾代码
- 方法 45：受 AES-256-GCM + ChaCha20 + Salsa20 + XOR 保护
- 所有输出：使用 `py_compile` 编译以生成 .pyc
**反分析特性：**
- 所有 AST 转换均保留原有功能
- 无外部 API 调用（pycryptodome 安装除外）
- 自包含的混淆输出
## 🎯 对比表
| 特性 | 选项 1–40 | 选项 41 | 选项 42 | 选项 43 | 选项 44 | 选项 45 |
|---------|-------------|-----------|-----------|-----------|-----------|-----------|
| 编码/压缩 | ✅ | ✅ | ✅ | ❌ | ❌ | ❌ |
| XOR 加密 | ❌ | ❌ | ✅ | ❌ | ✅ | ✅ |
| 控制流平坦化 | ❌ | ❌ | ❌ | ✅ | ✅ | ❌ |
| 变量重命名 | ❌ | ❌ | ❌ | ✅ | ✅ | ❌ |
| 字符串加密 | ❌ | ❌ | ❌ | ✅ | ✅ | ❌ |
| CJK 变量 | ❌ | ❌ | ❌ | ❌ | ✅ | ❌ |
| 死代码注入 | ❌ | ❌ | ❌ | ❌ | ✅ | ❌ |
| 多密码加密 | ❌ | ❌ | ❌ | ❌ | ✅ | ✅ |
| 抵抗反编译能力 | 低 | 中等 | 高 | 极高 | 极限 | 极限 |
## 🛠️ 架构
```
PyObfuscator.py
├── EnvironmentValidator # Python version & import validation
├── CodecEngine # Encoding/decoding operations
├── XOREngine # XOR encryption utilities
├── ASTObfuscator # AST-level transformations
│ ├── VariableCollector
│ ├── VariableRenamer
│ ├── ControlFlowFlattener
│ └── StringEncryptor
├── CJKObfuscator # CJK-based obfuscation
├── UltraObfuscator # Multi-layer encryption
├── ObfuscatorEngine # Core obfuscation logic
├── Interface # CLI menu & display
└── PyObfuscator # Main application entry
```
## ⚠️ 重要说明
**性能考量：**
- 方法 44–45 会显著增加文件体积（15-30 倍）
- 处理时间随代码复杂性而增加
- AST 转换期间内存使用量达到峰值
**兼容性：**
- 输出文件需要 Python 3.6+
- 某些混淆代码可能会触发杀毒软件的误报
- 输出中需要使用 `exec()` 进行动态解码
**安全性：**
- 没有任何方法能提供绝对的保护
- 混淆只会增加分析的难度，并非不可能被破解
- 在部署前务必测试混淆后的代码
## 📝 许可证
该项目基于 MIT 许可证授权。
**由 [@BatmanPriv](https://t.me/BatmanPriv) 开发**
*仅供教育和合法保护目的使用。*
## ⚡ 混淆方法
### 基于编码的方法（选项 1–40）
| 方法 | 描述 | 保护级别 |
|--------|-------------|------------------|
| 1–7 | **单层**（Marshal, Zlib, GZIP, LZMA, Base16/32/64） | 低 |
| 8–16 | **双层**（压缩 + 编码组合） | 中 |
| 17–31 | **Marshal + 压缩/编码** | 中高 |
| 32–40 | **多层**（结合 Marshal, Zlib, LZMA, GZIP, Base64 的 3-5 层） | 高 |
### 高级混淆方法（选项 41–45）
| 选项 | 方法 | 描述 |
|--------|--------|-------------|
| **41** | 简单混淆 | 5 层嵌套压缩 + marshaling，并带有动态解码 |
| **42** | 深度 XOR 混淆 | 采用 XOR 加密，带有递归包装层和防篡改检查 |
| **43** | AST 混淆 | 控制流平坦化，变量重命名，字符串加密 (AES-256-CBC) |
| **44** | CJK 混淆 | 带有 CJK 变量名的 AST 转换 + 死代码注入 + 10 层保护流水线 |
| **45** | 极致混淆 | 四层加密保护 (AES-256-GCM + ChaCha20 + Salsa20 + XOR) |
## 🧠 技术深入解析
### 1. AST 级别转换（选项 43）
在编译前直接操作 Python 的抽象语法树：
**控制流平坦化**
将具有嵌套条件和循环的结构化代码转换为平坦的状态机：
```
# 原始
if x > 0:
do_something()
else:
do_other()
# 转换后
state = 0
while state < 2:
if state == 0:
if x > 0:
do_something()
state = 1
elif state == 1:
do_other()
state = 2
```
这消除了可预测的控制流，使得手动分析和自动化反混淆变得极其困难。
**变量重命名**
所有用户定义的变量名都会被替换为确定性但无意义的标识符（`v_3a8f2b1c`），从而破坏语义理解。
**字符串加密**
所有字符串文字均使用 AES-256-CBC 进行加密，每个字符串都有唯一的初始化向量。运行时解密通过注入的解密函数完成。
### 2. CJK 混淆（选项 44）
这种方法旨在通过大量的代码注入来击败反编译器并迷惑人类阅读者：
**CJK 变量名**
变量使用韩文、中文和日语字符命名：
```
홁 = [2847 for _ in range(45)]
鰿 = {(lambda 鍘: 鍘 ^ 127)(i) for i in range(30)}
桽 = [(lambda 鼜, 鰪: 鼜 * 鰪)(i, j) for i in range(67)]
```
这些字符是有效的 Python 标识符，但在视觉上容易引起混淆，并会导致语法高亮显示和反编译器出现故障。
**死代码注入**
注入数百行无意义的操作：列表推导式、嵌套 lambda、字典推导式以及冗长的 CJK 注释块。这会使代码大小增加 15-30 倍，并为分析工具制造需要处理的海量垃圾数据。
**多层保护流水线**
```
Original Source Code
↓
AST Transformation (Flatten + Rename + String Encryption)
↓
Marshal Serialization
↓
Zlib Compression (Level 9) — First pass
↓
Zlib Compression (Level 9) — Second pass
↓
BZ2 Compression
↓
LZMA Compression
↓
Base85 Encoding
↓
XOR-32 (32-byte random key)
↓
Shuffle Permutation (random index reordering)
↓
RC4 Encryption (16-byte random key)
↓
LCG-XOR (Linear Congruential Generator)
↓
Base64 Encoding
↓
Final Protected Code
```
**核心特性：**
- 每一层使用不同的算法，防止单点解密
- 打乱层破坏了压缩数据中的模式识别
- LCG-XOR 产生抗统计分析的伪随机输出
- 加密前进行压缩以消除数据冗余
### 3. 极致混淆（选项 45）
**四层加密架构：**
| 层 | 算法 | 密钥大小 | Nonce/IV | 目的 |
|-------|-----------|----------|----------|---------|
| 1 | AES-256-GCM | 256 位 | 96 位 | 提供完整性的认证加密 |
| 2 | ChaCha20 | 256 位 | 96 位 | 高性能流密码 |
| 3 | Salsa20 | 256 位 | 64 位 | 额外的混淆层 |
| 4 | XOR | 256 字节 | N/A | 最终转换层 |
**密钥派生：**
所有加密密钥均使用 **scrypt** 从 64 字节的主熵中派生出来：
```
scrypt(master_entropy, salt, N=65536, r=8, p=1)
```
使用这些参数，单次密钥派生大约需要 ~100ms 的 CPU 时间，这使得暴力破解攻击在计算上是不可行的。
**运行时保护：**
生成的加载器包括：
- 诱饵函数的随机打乱
- 随机化的执行模式
- 用于反调试的秘密 token 生成
- 如果缺失，自动安装 pycryptodome
### 4. 深度 XOR 混淆（选项 42）
实现基于 XOR 的加密，具有：
- 16 字节或自定义的 XOR 密钥
- 可配置的递归包装层（默认：4 层）
- 加密前的 Zlib 压缩
- 加密数据的 Base64 编码
- 带有反调试检查的运行时解密
- 用于逃避检测的后台线程执行
### 5. 编码链系统（选项 1–40）
CodecEngine 提供了一条灵活的编码流水线，支持以下组合：
每种组合都使用逆序解码，并且所有编码的数据都进行了字节反转以实现额外的混淆。
## 🚀 安装
```
# Clone the repository
git clone https://github.com/batmanpriv/PyObfuscator.git
cd PyObfuscator
# Run the tool (auto-installs pycryptodome if missing)
python PyObfuscator.py
```
**环境要求：**
- Python 3.6 或更高版本
- pycryptodome（如缺失会自动安装）
- 标准库模块（均包含在 Python 发行版中）
## 📖 使用指南
### 基本用法
```
python PyObfuscator.py
```
1. 选择一种混淆方法 (1–45)
2. 输入你的 Python 文件路径
3. 对于需要额外输入的方法：
- **选项 42：** 自定义密钥（可选）和层数
- 所有其他方法：编码循环次数（重复编码的次数）
### 示例
**示例 1：基本保护**
```
$ python PyObfuscator.py
[+] Option: 10
[+] File Name: script.py
[+] Encode Count: 5
[+] Obfuscation complete: script_obfuscated.py
[+] Size: 12.3 KB
```
**示例 2：最高保护**
```
$ python PyObfuscator.py
[+] Option: 45
[+] File Name: sensitive.py
[+] Encode Count: 3
[+] Obfuscation complete: sensitive_ultra.py
[+] Size: 184.7 KB
```
### 方法选择指南
| 使用场景 | 推荐方法 |
|----------|----------------------|
| 快速的基本保护 | 1–7 |
| 适度保护且体积增加最小 | 8–16 |
| 商业软件保护 | 17–40, 43 |
| 抵抗反编译器的保护 | 44 |
| 最高安全性 | 45 |
| API 密钥 / 凭据保护 | 42–45 |
## 📊 性能特征
| 方法组 | 体积膨胀 | 处理时间 | 内存占用 | 安全级别 |
|--------------|---------------|-----------------|--------------|----------------|
| 选项 1–7 | 1.5–2 倍 | <1秒 | <50MB | 基础 |
| 选项 8–16 | 2–3 倍 | <2秒 | <100MB | 中等 |
| 选项 17–31 | 3–4 倍 | 2–4秒 | <150MB | 高 |
| 选项 32–40 | 4–5 倍 | 3–5秒 | <200MB | 极高 |
| 选项 41 | 2–3 倍 | <2秒 | <100MB | 中等 |
| 选项 42 | 5–8 倍 | 3–7秒 | <200MB | 高 |
| 选项 43 | 8–12 倍 | 4–8秒 | <250MB | 极高 |
| 选项 44 | 15–30 倍 | 5–10秒 | <500MB | 极限 |
| 选项 45 | 10–20 倍 | 3–6秒 | <300MB | 军事级 |
## 🔧 技术规格
**支持的 Python 版本：** 3.6 – 3.13
**依赖项：**
- `pycryptodome` >= 3.15.0（自动安装）
**输入文件限制：**
- 编码方法：无限制
- AST 方法：建议 < 10MB
- CJK 方法：建议 < 5MB
**输出文件特征：**
- 方法 44：注入了 200–500 行垃圾代码
- 方法 45：受 AES-256-GCM + ChaCha20 + Salsa20 + XOR 保护
- 所有输出：使用 `py_compile` 编译以生成 .pyc
**反分析特性：**
- 所有 AST 转换均保留原有功能
- 无外部 API 调用（pycryptodome 安装除外）
- 自包含的混淆输出
## 🎯 对比表
| 特性 | 选项 1–40 | 选项 41 | 选项 42 | 选项 43 | 选项 44 | 选项 45 |
|---------|-------------|-----------|-----------|-----------|-----------|-----------|
| 编码/压缩 | ✅ | ✅ | ✅ | ❌ | ❌ | ❌ |
| XOR 加密 | ❌ | ❌ | ✅ | ❌ | ✅ | ✅ |
| 控制流平坦化 | ❌ | ❌ | ❌ | ✅ | ✅ | ❌ |
| 变量重命名 | ❌ | ❌ | ❌ | ✅ | ✅ | ❌ |
| 字符串加密 | ❌ | ❌ | ❌ | ✅ | ✅ | ❌ |
| CJK 变量 | ❌ | ❌ | ❌ | ❌ | ✅ | ❌ |
| 死代码注入 | ❌ | ❌ | ❌ | ❌ | ✅ | ❌ |
| 多密码加密 | ❌ | ❌ | ❌ | ❌ | ✅ | ✅ |
| 抵抗反编译能力 | 低 | 中等 | 高 | 极高 | 极限 | 极限 |
## 🛠️ 架构
```
PyObfuscator.py
├── EnvironmentValidator # Python version & import validation
├── CodecEngine # Encoding/decoding operations
├── XOREngine # XOR encryption utilities
├── ASTObfuscator # AST-level transformations
│ ├── VariableCollector
│ ├── VariableRenamer
│ ├── ControlFlowFlattener
│ └── StringEncryptor
├── CJKObfuscator # CJK-based obfuscation
├── UltraObfuscator # Multi-layer encryption
├── ObfuscatorEngine # Core obfuscation logic
├── Interface # CLI menu & display
└── PyObfuscator # Main application entry
```
## ⚠️ 重要说明
**性能考量：**
- 方法 44–45 会显著增加文件体积（15-30 倍）
- 处理时间随代码复杂性而增加
- AST 转换期间内存使用量达到峰值
**兼容性：**
- 输出文件需要 Python 3.6+
- 某些混淆代码可能会触发杀毒软件的误报
- 输出中需要使用 `exec()` 进行动态解码
**安全性：**
- 没有任何方法能提供绝对的保护
- 混淆只会增加分析的难度，并非不可能被破解
- 在部署前务必测试混淆后的代码
## 📝 许可证
该项目基于 MIT 许可证授权。
**由 [@BatmanPriv](https://t.me/BatmanPriv) 开发**
*仅供教育和合法保护目的使用。*标签：自动化payload嵌入, 逆向工具