[原创]深入浅出 Ollvm 混淆原理及反混淆技术-Android安全-看雪安全社区

[原创]深入浅出 Ollvm 混淆原理及反混淆技术

发表于: 2025-12-20 21:39 106374

[原创]深入浅出 Ollvm 混淆原理及反混淆技术

xiusi

2025-12-20 21:39

106374

# 深入浅出 Ollvm 混淆原理及反混淆技术

## 一、前言

在对抗 OLLVM（Obfuscator-LLVM）混淆的征途中，理解其混淆原理是制定还原策略的第一步。本文将深入探讨 OLLVM 的三大核心混淆手段：**指令替换、虚假控制流、控制流平坦化**，并分享实用的还原技巧。

**所用附件：**<a href="elink@28dK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6G2j5h3y4A6j5g2)9J5k6h3N6A6N6r3S2#2j5W2)9J5k6h3W2G2i4K6u0r3L8$3I4D9N6X3#2Q4x3X3c8K6N6s2g2V1P5g2)9J5c8X3!0D9L8s2k6E0i4K6g2X3j5X3y4X3i4K6u0V1k6X3I4S2i4K6u0V1M7%4g2T1i4K6u0W2P5X3W2H3">测试样本 (ollvm_bcf-fla-sub.zip)</a>

---

## 二、指令替换 SUB（Substitution）

### 1. 核心原理

**指令替换（Instruction Substitution）**  是一种通过数学等价变换来增加代码复杂度的混淆技术。它的核心思想是将程序中原本简单的指令（如加法、异或），替换为一段功能等效但逻辑极其晦涩的指令序列。

#### 本质：MBA 混淆

OLLVM 的指令替换大量采用了 **MBA（Mixed Boolean-Arithmetic，混合布尔算术）**  表达式。

- **定义**：简单来说，MBA 混淆将基础的算术运算（如 `x + y`）替换为复杂的位运算（And, Or, Xor, Not）与算术运算的组合。
- **示例**：  
  原本一条简单的异或指令：

```c
  r = x ^ y;
  ```

在经过 OLLVM 混淆后，可能会变成如下形式（基于数学公式 `(x + y) - 2 * (x & y) == x ^ y`）：

```c
  r = (x + y) - 2 * (x & y);
  ```

甚至更复杂的嵌套多项式：

```c
  r = (x | y) - (x & y); // 也是异或的一种表现形式
  ```

#### 混淆后果

这种变换在保持数学结果绝对不变的前提下，带来了两个显著的恶果：

1. **代码膨胀**：一条指令变成数十条甚至上百条指令，导致二进制体积剧增。
2. **对抗分析**：极大地干扰了 IDA Pro、Ghidra 等反编译器的分析引擎，生成的伪代码（Pseudocode）充斥着大量冗余的位运算逻辑，让人眼花缭乱，难以识别其真实的业务含义。

---

### 2. 对抗方法

面对“指令替换”带来的垃圾代码，手动分析显然是不现实的。我们主要依赖自动化工具来进行代数简化。

#### 方法 A：使用 IDA 插件 D-810 (推荐首选)

**D-810** 是一款基于 IDA 的强大反混淆插件，它能在反编译阶段动态地优化指令流。

- **工作原理**：D-810 挂载在 IDA 的 Hex-Rays 流程中，利用预定义的模式匹配（Pattern Matching）和启发式规则，自动识别常见的 OLLVM 混淆模式（如上述的 `(x|y)-(x&y)`），并将其折叠回原始指令（如 `x^y`）。
- **优势**：集成度高，安装配置后，F5 刷新即可看到简化后的代码，无需离开 IDA 环境。
- **局限性**：对于某些极其复杂或非标准的 MBA 表达式，D-810 可能无法完全识别。

**案例：test-sub**

以下是一段经过 OLLVM 指令替换混淆后的 RC4 算法代码，可以看到逻辑极其复杂，充斥着大量冗余的位运算：

**混淆前**：

![image](upload/attach/202512/1036360_9UXDCQTSUAXEZDH.png)

**开启 D-810 后 (F5 刷新)** ：

![image](upload/attach/202512/1036360_H83N5VVNH7FMQRN.png)

可以看到，虽然 D-810 成功去除了一部分混淆，但核心逻辑（RC4 的异或操作）依然被更深层次的 MBA 表达式掩盖，未能完全还原。

---

#### 方法 B：使用 GAMBA (深度清理)

当 D-810 无法完全还原，或者你需要处理极高强度的 MBA 表达式时，**GAMBA** 是你的终极武器。

- **工具定位**：GAMBA 是一款基于代数重写和 SMT 求解技术的自动化简化工具。它不依赖于模式匹配，而是通过数学证明的方式进行化简。
- **核心优势**：它像剥洋葱一样，能将那些冗长晦涩的位运算公式还原为最原始、最直观的算术形式。特别是在处理 D-810 遗留的“顽固”表达式时，GAMBA 往往能给出令人惊喜的简洁结果。
- **处理技巧**：  
  由于 GAMBA 是 Python 脚本，无法直接识别 IDA 中的指针符号 `*()` 或数组索引 `[]`。在使用前，建议将这些复杂的内存访问表达式**重命名为简单的变量名**（例如将 `v12[v9]` 替换为 `V12_v9` ，`*(v16 + i)` 替换为 `V16_i` ），以避免解析错误。

该工具的详细使用方法请移步：[[分享]Ollvm 指令替换混淆还原神器：GAMBA 使用指南](https://bbs.kanxue.com/thread-289418.htm)

**还原 RC4 核心：**

我们继续处理 D-810 遗留的那三行“残渣”代码：

**原始残渣**：

**第一步：变量代换**  
为了方便 GAMBA 处理，我们进行如下重命名：

- `v12[v9]`  -\> **`V12_v9`**
- `*(v16 + i)` -\> **`V16_i`**

替换后的表达式：

**第二步：逐个击破**  
使用 GAMBA 依次简化这三个表达式：

1. **简化** **`V16_i`** **的赋值逻辑**：

```javascript
    python simplify.py "v6 & v5 | v5 & 0x23 ^ (v5 & 0x14 | ~v5 & 0xC8) ^ v6 ^ 0xC8" -v 3
    ```

![image](upload/attach/202512/1036360_YDVTQHVJBN5VNCT.png)

> **输出结果**：`v5 | v6`
    >
2. **简化** **`v5`** **的逻辑**：

```javascript
    python simplify.py "~(~V12_v9 | (V16_i & 0x9A | ~V16_i & 5) ^ (~V16_i & 0x60 | 5) ^ 0x60)" -v 3
    ```

![image](upload/attach/202512/1036360_3YUPYD4UNYPVTSA.png)

> **输出结果**：`~V16_i & V12_v9`
    >
3. **简化** **`v6`** **的逻辑**：

```javascript
    python simplify.py "V16_i & ((V12_v9 & 0x21 | ~V12_v9 & 2 | 0xC8) ^ (~V12_v9 & 0x14 | (V12_v9 & 0xC0 | ~V12_v9 & 8) ^ 8 | 2) ^ 0x23)" -v 3
    ```

![image](upload/attach/202512/1036360_C4CA7QRQ9TN4M9J.png)

> **输出结果**：`V16_i & ~V12_v9`
    >

**第三步：终极合并**  
现在我们将简化后的结果代回原逻辑：

- `V16_i = v5 | v6`
- `v5 = ~V16_i & V12_v9`
- `v6 = V16_i & ~V12_v9`

合并后的表达式为：

```c
V16_i = (~V16_i & V12_v9) | (V16_i & ~V12_v9)
```

再次交给 GAMBA 进行最终简化：

```bash
python simplify.py "(~V16_i&V12_v9) | (V16_i&~V12_v9)" -v 3
```

![image](upload/attach/202512/1036360_22RZYMK4NR2WD9Z.png)

> **输出结果**：`V16_i ^ V12_v9`

**结论**：  
经过 GAMBA 的层层抽丝剥茧，这段复杂的代码最终还原为：

```c
*(v16 + i) = *(v16 + i) ^ v12[v9];
```

这正是 **RC4 加密算法** 中最经典的异或操作！通过 **D-810 初步清洗 + GAMBA 深度还原** 的组合拳，我们成功击穿了 OLLVM 的指令替换混淆。

---

## 三、虚假控制流 BCF（Bogus Control Flow）

### 1. 核心原理

**虚假控制流（Bogus Control Flow）**  是 OLLVM 通过向代码中注入永远不会执行的“死代码”块和难以预测的条件跳转，来干扰控制流图（CFG）分析的一种混淆技术。

#### 两个关键概念：

1. **不透明谓词 (Opaque Predicate)** ：

- 这是一个在编译时或运行时其值已知，但对于静态分析工具（如 IDA）而言看似未知的条件表达式。
    - **示例**：`if (x * (x + 1) % 2 != 0) { ... }`。数学上任意整数 **x**，其 **x(x+1)**  必然是偶数，因此条件永远为假。但 IDA 在不进行深度代数分析的情况下，会认为这是一条合法的分支。
2. **不可达块 (Unreachable Block)** ：

- 由永假的不透明谓词保护的代码块。由于条件永远不满足，这些代码在实际运行时永远不会执行，但在静态反编译时会生成大量干扰逻辑，极大地增加了分析工作量。

---

### 2. 对抗方法

#### 方法 A：使用 IDA 插件 D-810 (推荐)

**D-810** 内置了强大的不透明谓词匹配器，能够自动识别常见的 OLLVM 谓词模式并将其优化掉，这里不再做演示。

---

#### 方法 B：修改数据段属性与初值 (利用编译器优化)

OLLVM 常使用全局变量（通常未初始化，位于 `.bss` 段）作为不透明谓词的判断条件。  
**核心思路**：既然 IDA 不知道这些变量的值，我们就人为地给它赋予一个定值，并告诉 IDA 这个值是“只读”的。这样 IDA 的反编译器就会触发**常量传播（Constant Propagation）** 优化，自动剪除死代码分支。

**案例：test-bcf**

![image](upload/attach/202512/1036360_D9R3AAHBK9E9V7N.png)

**实战步骤**：

1. **定位变量**：在伪代码中找到干扰判断的全局变量（如 `x_9`, `y_10`），双击进入 `.bss` 段。

![image](upload/attach/202512/1036360_WZJBHHPZQ8Z5SKV.png)
2. **修改段属性**：

- 按 `Alt + S` 打开段编辑窗口。
    - 勾选 "Read-only" 或去掉 "Write" 权限，确保 IDA 认为该段不可写。

![image](upload/attach/202512/1036360_5SKH8E6CEYBTKHT.png)
3. **赋予初值**：将这些变量批量赋值（例如全改为2）。

![image](upload/attach/202512/1036360_GFF3AZH7AD5WQ52.png)

**辅助脚本 (IDA Python)** ：

```python
import ida_segment
import ida_bytes

# 获取 .bss 段
seg = ida_segment.get_segm_by_name('.bss')

# 1. 批量赋值：将该段所有变量初始化为 2 (或其他固定值)
# 步长为 4 (int类型)
for ea in range(seg.start_ea, seg.end_ea, 4):
    ida_bytes.patch_bytes(ea, int(2).to_bytes(4, 'little'))

# 2. 修改段权限为只读 (Read Only)
# seg.perm 格式: 4=Read, 2=Write, 1=Execute
seg.perm = 0b100  # 只保留读权限 (R--)
ida_segment.update_segm(seg)

print("[+] BSS segment patched: Read-only & Initialized.")
```

**最后一步**：  
在 `.bss` 段对相关变量执行  **"Convert to data"** （快捷键 `D`），然后回到反编译界面按 `F5` 刷新。你会发现大量分支因条件确定而被 IDA 自动优化消失了。

![image](upload/attach/202512/1036360_AYBS24WQNZF979G.png)

**简化效果：**

![image](upload/attach/202512/1036360_QKSPT8GNBRJ74Z7.png)

---

#### 方法 C：汇编指令修补 (Patch Instruction)

如果你不想修改段属性，或者变量分布比较零散，可以直接修改汇编指令，将对全局变量的读取替换为**立即数（常量）** 。

![image](upload/attach/202512/1036360_T6W3QZC3FKGM694.png)

**原理**：  
原指令：`mov eax, ds:x_9` （从内存读值，值不确定）  
修改后：`mov eax, 0` （直接赋常量）

**IDA Python 自动化脚本**：

```python
import ida_xref
import ida_idaapi
from ida_bytes import get_bytes, patch_bytes
import ida_segment

def do_patch(ea):
    # 检查指令特征：mov reg, [mem] (通常是 8B 开头)
    # 注意：这里仅适配了特定的 mov 指令格式，实战需根据具体指令调整
    if get_bytes(ea, 1) == b"\x8B": 
        # 解析目标寄存器
        reg = (ord(get_bytes(ea + 1, 1)) & 0b00111000) >> 3
        
        # 构造新指令：mov reg, 0
        # 操作码：0xB8 + reg
        # 填充 nop 保持指令长度一致
        new_code = (0xB8 + reg).to_bytes(1, 'little') + b'\x00\x00\x00\x00\x90\x90'
        
        patch_bytes(ea, new_code)
        print(f"[+] Patched at {hex(ea)}: mov reg, 0")
    else:
        print(f"[-] Skip unknown instruction at {hex(ea)}")

# 遍历 .bss 段中的不透明谓词变量
seg = ida_segment.get_segm_by_name('.bss')
for addr in range(seg.start_ea, seg.end_ea, 4):
    # 获取所有引用了该变量的代码位置
    ref = ida_xref.get_first_dref_to(addr)
    while ref != ida_idaapi.BADADDR:
        do_patch(ref)
        ref = ida_xref.get_next_dref_to(addr, ref)

print("[+] All opaque predicates patched.")
```

此方法直接从汇编层面切断了不透明谓词的来源，IDA 在重新分析时会发现这些寄存器都是定值，从而优化掉虚假分支。简化效果和方法B一样。

---

## 四、控制流平坦化 FLA (Control Flow Flattening)

### 1. 核心原理

**控制流平坦化（Control Flow Flattening，简称 FLA 或 CFF）**  是一种旨在摧毁程序结构信息的重度混淆技术。它通过引入一个中央分发器，将原函数中原本层级分明、先后有序的基本块（Basic Blocks）全部“拍扁”，使得它们在控制流图（CFG）上看起来像是在同一个层级上。

#### 图解：CFG 的崩塌

- **原始 CFG**：

![image](upload/attach/202512/1036360_XPW8DYR8V4EVJUC.png)
- **混淆后 CFG**：

![image](upload/attach/202512/1036360_M6R3TEMANSC4ZZH.png)

#### 六大核心组件

要理解并还原 FLA，必须识别出以下组件：

![image](upload/attach/202512/1036360_TUPXM6G6EPHPA6F.png)

1. **序言 (Prologue)** ：  
    函数的入口。它的核心任务是初始化**状态变量 (State Variable)** ，例如 `state = START_KEY`。
2. **主分发器 (Main Dispatcher)** ：  
    混淆的心脏。通常是一个巨大的 `while(true)` 循环，内部包裹着 `switch(state)`。它不断读取当前状态值，决定下一个要执行哪个块。
3. **子分发器 (Sub-Dispatcher) (变种)** ：  
    更复杂的 FLA 会嵌套多层 switch，或者使用数学公式计算跳转目标，进一步隐藏状态转移关系。
4. **真实块 (Relevant Blocks)** ：  
    包含原始业务逻辑的代码块。它们不再直接跳转到下一个真实块，而是被“隔离”成了 switch 的一个个 case。
5. **预处理块 (Predispatcher) / 状态更新**：  
    每个真实块执行完后，不会直接跳转。而是通过更新 `state` 变量（例如 `state = NEXT_KEY`），然后无条件跳转回主分发器，由分发器在下一轮循环中根据新状态进行调度。
6. **返回块 (Return)** ：  
    函数的出口，当状态变量达到特定值时，跳出循环并返回。

#### 执行流程演示

1. **初始化**：序言设置 `state = 1`。
2. **分发**：主分发器检查 `state`，跳转到 `case 1`（真实块 A）。
3. **执行与更新**：真实块 A 执行业务逻辑，并在末尾将 `state` 更新为 `2`。
4. **回环**：跳转回主分发器。
5. **再分发**：主分发器检查 `state`（此时为 2），跳转到 `case 2`（真实块 B）。
6. **循环往复**... 直到 `state` 变为结束标志。

---

### 2. 对抗方法

面对 FLA 混淆，我们的目标是**重建真实块之间的直接跳转关系**，即：如果块 A 执行完后 `state` 变成了 2，而 `state=2` 对应的是块 B，那么我们就把块 A 的结尾直接修改为 `JMP Block_B`，从而绕过分发器。

---

#### 方法 A：使用 IDA 插件 D-810 (静态分析首选)

**D-810** 的强大之处在于它不仅能处理 MBA混淆 和 不透明谓词，还内置了针对 FLA 的启发式去混淆规则。

去混淆前：

![image](upload/attach/202512/1036360_RF3ZWMVNWQ3QG6Z.png)

去混淆后：

![image](upload/attach/202512/1036360_KZE7FPN6399PDWD.png)

可以看到去混淆程度是很大的，十分接近原逻辑。

---

#### 方法 B：使用 Deflat 脚本 (基于 Angr)

**Deflat** 是经典的基于符号执行的去混淆工具。它利用 Angr 框架模拟执行，能够精准地计算出每个基本块的“下一跳”目标。

> **项目地址**: <a href="elink@572K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6%4N6%4N6Q4x3X3g2Y4L8$3!0Y4L8r3g2Q4x3X3g2U0L8$3#2Q4x3V1k6#2M7X3I4Q4x3@1k6I4i4K6y4p5K9s2c8@1M7s2y4Q4x3U0f1K6b7g2)9J5y4e0u0r3i4K6t1#2x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3U0f1J5c8X3y4I4y4U0M7@1x3K6f1H3y4e0t1&6i4K6t1#2x3V1k6V1k6h3k6D9j5i4b7`.">fdbK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6U0M7e0j5%4y4o6x3#2x3o6f1J5z5g2)9J5c8X3c8W2k6X3I4S2N6l9`.`.</a>

**使用命令**：

```bash
# -f: 目标二进制文件
# --addr: 混淆函数的起始地址 (十六进制)
python deflat.py -f test-fla --addr 0x400660
```

**原理**：

1. **识别组件**：自动寻找序言、分发器、真实块和返回块。
2. **符号执行**：从每个真实块开始，符号执行到分发器，求解出 `state` 的值以及对应的目标块。
3. **二进制修补 (Patch)** ：直接修改 ELF/PE 文件，将真实块末尾的跳转指令修改为直连目标块，并 NOP 掉分发器相关指令。

**示例：test-fla**

![image](upload/attach/202512/1036360_C82MKC2BSBF52H9.png)

![image](upload/attach/202512/1036360_GXKGDXKGZJ9SAAF.png)

查看去混淆后的文件 `test-fla_recovered` ：

![image](upload/attach/202512/1036360_4KGHPU2CV27YBX8.png)

可以看到还原程度还是不错的，部分残留可以手动 `NOP` 清除一下：

![image](upload/attach/202512/1036360_F3E5XDZXDBW8UJU.png)

---

#### 方法 C：使用 Unicorn 框架 (动态模拟还原)

通过模拟执行，我们可以记录程序在运行时的**真实轨迹 (Trace)** ，从而无视复杂的静态混淆逻辑。

**核心技术路径**：

1. **静态提取**：利用 IDA 识别并提取所有基本块信息（真实块、虚假块、分发器）。
2. **动态模拟**：使用 Unicorn 运行程序，记录块与块之间的跳转关系及上下文（ZF 标志位）。
3. **静态修复**：根据记录的关系，Patch 二进制代码，短路分发器，重建 CFG。

**案例：test-fla**

我们先查看ida的流程图，可以很明显的看出该程序的序言、分发器、return块、真实块、预处理器

![image](upload/attach/202512/1036360_TPT3WG49E7S74Q3.png)

---

##### 第一步：静态提取 (IDA Python)

我们需要先让 IDA 告诉我们哪些是“真实块”，哪些是“分发器/虚假块”。

**分析逻辑**：

- **序言块**：函数的入口。
- **真实块 (True Block)** ：预处理器前的块。
- **Return 块：** 无后续块。
- **虚假块 (Fake Block)** ：除了上述块以外的其他块。

**提取脚本 (Extract Blocks)** ：

```python
import idaapi
import idc

# ================= 配置 =================
TARGET_FUNC_EA = 0x401E80      # 目标函数入口
PREPROCESSOR_EA = 0x402697     # 分发器/预处理器地址

# ================= 数据结构 =================
true_blocks = set()   # 真实块集合
fake_blocks = set()   # 虚假块集合

func = idaapi.get_func(TARGET_FUNC_EA)
flowchart = idaapi.FlowChart(func, flags=idaapi.FC_PREDS)

print(f"[*] Analyzing function at 0x{TARGET_FUNC_EA:x}...")

# ================= CFG 分析 =================
for block in flowchart:
    start_ea = block.start_ea
    # 获取块的实际结束地址（排除对齐填充）
    end_ea = idc.prev_head(block.end_ea)

# 1. 识别分发器 (Dispatcher)
    # 分发器本身归类为虚假块
    if start_ea == PREPROCESSOR_EA:
        fake_blocks.add((start_ea, end_ea))
        
        # 分发器的前驱通常是真实块（因为真实块执行完要跳回来）
        for pred in block.preds():
            true_blocks.add((pred.start_ea, idc.prev_head(pred.end_ea)))
        continue

# 2. 识别返回块 (Return Block)
    # 没有后继的块通常是函数出口
    succs = list(block.succs())
    if not succs:
        print(f"[+] Found Return Block: 0x{start_ea:x}")
        # 返回块算作真实逻辑的一部分，但不参与循环
        continue

# 3. 识别真实块 (True Block)
    # 如果当前块的后继是分发器，说明它是参与调度的真实块
    if any(succ.start_ea == PREPROCESSOR_EA for succ in succs):
        true_blocks.add((start_ea, end_ea))
        continue

# 4. 识别序言 (Prologue)
    if start_ea == TARGET_FUNC_EA:
        print(f"[+] Found Prologue: 0x{start_ea:x}")
        print(f"[+] Prologue_end: 0x{end_ea:x}")
        continue

# 5. 其他块归类为虚假块 (Fake Block)
    # 排除掉已经被标记为真实的块
    if (start_ea, end_ea) not in true_blocks:
        fake_blocks.add((start_ea, end_ea))

# ================= 输出 =================
print(f"\n[+] True Blocks Count: {len(true_blocks)}")
print("TBS =", sorted(true_blocks))

print(f"\n[+] Fake Blocks Count: {len(fake_blocks)}")
print("FBS =", sorted(fake_blocks))
```

---

##### 第二步：动态模拟 (Unicorn Trace)

有了块列表，我们使用 Unicorn 模拟执行，记录真实的跳转路径。

具体的 Unicorn 框架学习文章：[[原创]深入浅出 Unicorn 框架学习](https://bbs.kanxue.com/thread-289502.htm)  
**关键点**：不仅要记录跳到了哪里，还要记录跳转时的 **ZF (Zero Flag)**  标志位。因为条件跳转（`JZ`/`JNZ`）完全依赖它。

**模拟脚本 (Unicorn Tracer)** ：

```python
from unicorn import *
from unicorn.x86_const import *
from capstone import *

# ============================================================
# 1. 全局配置（地址布局 & 目标函数）
# ============================================================
BASE_ADDR = 0x400000
CODE_ADDR = BASE_ADDR
CODE_SIZE = 1024 * 1024
STACK_ADDR = 0x0
STACK_SIZE = 1024 * 1024

MAIN_ADDR = 0x401E80
MAIN_END = 0x40269C

# ============================================================
# 2. 基本块信息（IDA 静态分析得到）
# ============================================================
# 从第一步脚本中获取的真实块列表
TBS = [
(4203066, 4203066), (4203071, 4203098), (4203103, 4203157), 
(4203162, 4203314), (4203319, 4203341), (4203346, 4203366), 
(4203371, 4203398), (4203403, 4203428), (4203433, 4203457), 
(4203462, 4203490), (4203495, 4203514), (4203519, 4203558), 
(4203563, 4203585), (4203590, 4203609), (4203614, 4203636), 
(4203641, 4203651), (4203656, 4203689), (4203694, 4203737), 
(4203742, 4203776), (4203781, 4203804), (4203809, 4203831), 
(4203836, 4203856), (4203861, 4203888), (4203893, 4203918), 
(4203923, 4203957), (4203962, 4203981), (4203986, 4204025), 
(4204030, 4204040), (4204045, 4204067), (4204072, 4204091), 
(4204096, 4204118), (4204123, 4204133), (4204138, 4204171)]

# 结果记录: [(tb_start, tb_end), zf_value]
tb_trace = []

# ============================================================
# 3. 反汇编 & 模拟器初始化
# ============================================================
cs = Cs(CS_ARCH_X86, CS_MODE_64)
uc = Uc(UC_ARCH_X86, UC_MODE_64)

# ============================================================
# 4. Hook：指令级 Hook（核心）
# ============================================================
def hook_code(uc, address, size, user_data):
    # 1. 模拟环境修补
    # 读取指令，处理 call 和 ret
    try:
        code = uc.mem_read(address, size)
    except: return

for insn in cs.disasm(code, address):
        # 跳过 Call：FLA 通常只在当前函数内，无需跟进子函数
        if insn.mnemonic == "call":
            # print(f"[Skip Call] 0x{address:x}")
            uc.reg_write(UC_X86_REG_RIP, address + size)
            return

# 遇到 Ret：函数结束，停止模拟
        if insn.mnemonic == "ret":
            print("[*] Function Return hit. Stopping...")
            uc.emu_stop()
            
            # 输出最终 Trace 供下一步使用
            print("\n" + "="*30)
            print("real_flow = [")
            for item in tb_trace:
                print(f"    {item},")
            print("]")
            print("="*30 + "\n")
            return

# 2. 记录执行轨迹
    # 检查当前地址是否是某个真实块的“结束地址”
    for tb_start, tb_end in TBS:
        if address == tb_end:
            # 记录此时的 ZF 标志位 (EFLAGS 第 6 位)
            eflags = uc.reg_read(UC_X86_REG_EFLAGS)
            zf = (eflags >> 6) & 1
            
            tb_trace.append(((tb_start, tb_end), zf))
            break

# ============================================================
# 5. Hook：非法内存访问 / 中断（调试用）
# ============================================================
def hook_mem_invalid(uc, access, address, size, value, user_data):
    access_type = {
        UC_MEM_READ_UNMAPPED: "READ",
        UC_MEM_WRITE_UNMAPPED: "WRITE",
        UC_MEM_FETCH_UNMAPPED: "FETCH",
    }.get(access, "UNKNOWN")
    # 打印内存错误信息
    print(f"[MEM {access_type}] 0x{address:x}, size={size}")
    return False

def hook_intr(uc, intno, user_data):
    print(f"[INT] interrupt {intno}")
    return False

# ============================================================
# 6. Unicorn 初始化
# ============================================================
def init_unicorn(uc, code_data):
	# 映射内存
    uc.mem_map(CODE_ADDR, CODE_SIZE, UC_PROT_ALL)
    uc.mem_map(STACK_ADDR, STACK_SIZE, UC_PROT_ALL)

# 写入代码
    uc.mem_write(CODE_ADDR, code_data)

# 初始化栈
    uc.reg_write(UC_X86_REG_RSP, STACK_ADDR + STACK_SIZE // 2)
    
	# 添加 hook 逻辑
    uc.hook_add(UC_HOOK_CODE, hook_code)
    
	# 未映射内存访问
    uc.hook_add(UC_HOOK_MEM_UNMAPPED, hook_mem_invalid)

# 中断（int 0x80 / syscall / ud2 等）
    uc.hook_add(UC_HOOK_INTR, hook_intr)

# ============================================================
# 7. 主流程
# ============================================================
if __name__ == "__main__":
    # 读取二进制文件
    with open(r"C:\Users\24510\Downloads\ollvm_bcf-fla-sub\ollvm_bcf-fla-sub\test-fla", "rb") as f:
        CODE_DATA = f.read()

init_unicorn(uc, CODE_DATA)
    
    print("[*] Starting Emulation...")
    try:
        uc.emu_start(MAIN_ADDR, MAIN_END)
    except UcError as e:
        print(f"[Error] {e}")
```

---

##### 第三步：静态修复 (IDA Python Patch)

拿到 `real_flow`（真实执行流）后，我们就可以在 IDA 中重建 CFG 了。

**修复策略**：

1. **单后继块**：如果块 A 后面永远只跟块 B，直接修改块 A 结尾为 `JMP Block_B`。
2. **双后继块（条件跳转）** ：如果块 A 后面有时跟 B（ZF\=1），有时跟 C（ZF\=0），说明它是条件跳转。

- **难题**：原始块 A 结尾空间可能不够写 `JZ + JMP` 指令。
    - **巧解**：利用无用的 **虚假块 (Fake Blocks)**  作为“跳板”。
    - **操作**：`Block_A -> JMP Fake_Block -> [JZ Target_True; JMP Target_False]`。

**修复脚本 (Patch CFG)** ：

```python
import idaapi
import ida_bytes
import ida_ua
import ida_kernwin
from collections import defaultdict, deque

# ============================================================
# 输入数据区
# ============================================================
# fake_blocks:
#   第一步分析 CFG / dispatcher 后得到的「虚假块列表」
#   每一项格式为 (start_ea, end_ea)
#   这些块在最终逻辑中只作为“跳板”或被 NOP 掉
fake_blocks = [(4202133, 4202159), (4202165, 4202165), (4202170, 4202187), (4202193, 4202193), (4202198, 4202215),
               (4202221, 4202221), (4202226, 4202243), (4202249, 4202249), (4202254, 4202271), (4202277, 4202277),
               (4202282, 4202299), (4202305, 4202305), (4202310, 4202327), (4202333, 4202333), (4202338, 4202355),
               (4202361, 4202361), (4202366, 4202383), (4202389, 4202389), (4202394, 4202411), (4202417, 4202417),
               (4202422, 4202439), (4202445, 4202445), (4202450, 4202467), (4202473, 4202473), (4202478, 4202495),
               (4202501, 4202501), (4202506, 4202523), (4202529, 4202529), (4202534, 4202551), (4202557, 4202557),
               (4202562, 4202579), (4202585, 4202585), (4202590, 4202607), (4202613, 4202613), (4202618, 4202635),
               (4202641, 4202641), (4202646, 4202663), (4202669, 4202669), (4202674, 4202691), (4202697, 4202697),
               (4202702, 4202719), (4202725, 4202725), (4202730, 4202747), (4202753, 4202753), (4202758, 4202775),
               (4202781, 4202781), (4202786, 4202803), (4202809, 4202809), (4202814, 4202831), (4202837, 4202837),
               (4202842, 4202859), (4202865, 4202865), (4202870, 4202887), (4202893, 4202893), (4202898, 4202915),
               (4202921, 4202921), (4202926, 4202943), (4202949, 4202949), (4202954, 4202971), (4202977, 4202977),
               (4202982, 4202999), (4203005, 4203005), (4203010, 4203027), (4203033, 4203033), (4203038, 4203055),
               (4203061, 4203061), (4204183, 4204183)]

# real_flow:
#   第二步通过动态 / 符号执行 / 手工跟踪得到的真实执行路径
#   每一项格式为:
#       ((block_start, block_end), zf)
#   含义是：
#       执行到该真实块时，ZF 的取值为 zf
real_flow = [
    ((4203071, 4203098), 0), ((4203103, 4203157), 0), ((4203162, 4203314), 1), ((4203319, 4203341), 1),
    ((4203346, 4203366), 1), ((4203371, 4203398), 0), ((4203403, 4203428), 0), ((4203433, 4203457), 1),
    ((4203462, 4203490), 0), ((4203495, 4203514), 1), ((4203519, 4203558), 1), ((4203563, 4203585), 1),
    ((4203590, 4203609), 0), ((4203614, 4203636), 1), ((4203641, 4203651), 1), ((4203319, 4203341), 1),
    ((4203346, 4203366), 1), ((4203371, 4203398), 0), ((4203403, 4203428), 0), ((4203433, 4203457), 1),
    ((4203462, 4203490), 0), ((4203495, 4203514), 1), ((4203519, 4203558), 1), ((4203563, 4203585), 1),
    ((4203590, 4203609), 0), ((4203614, 4203636), 1), ((4203641, 4203651), 1), ((4203319, 4203341), 1),
    ((4203346, 4203366), 1), ((4203371, 4203398), 0), ((4203403, 4203428), 0), ((4203433, 4203457), 1),
    ((4203462, 4203490), 0), ((4203495, 4203514), 1), ((4203519, 4203558), 1), ((4203563, 4203585), 1),
    ((4203590, 4203609), 0), ((4203614, 4203636), 1), ((4203641, 4203651), 1), ((4203319, 4203341), 1),
    ((4203346, 4203366), 1), ((4203371, 4203398), 0), ((4203403, 4203428), 0), ((4203433, 4203457), 1),
    ((4203462, 4203490), 0), ((4203495, 4203514), 1), ((4203519, 4203558), 1), ((4203563, 4203585), 1),
    ((4203590, 4203609), 0), ((4203614, 4203636), 1), ((4203641, 4203651), 1), ((4203319, 4203341), 1),
    ((4203346, 4203366), 1), ((4203371, 4203398), 0), ((4203403, 4203428), 0), ((4203433, 4203457), 1),
    ((4203462, 4203490), 0), ((4203495, 4203514), 1), ((4203519, 4203558), 1), ((4203563, 4203585), 1),
    ((4203590, 4203609), 0), ((4203614, 4203636), 1), ((4203641, 4203651), 1), ((4203319, 4203341), 1),
    ((4203346, 4203366), 1), ((4203371, 4203398), 0), ((4203403, 4203428), 0), ((4203433, 4203457), 1),
    ((4203462, 4203490), 0), ((4203495, 4203514), 1), ((4203519, 4203558), 1), ((4203563, 4203585), 1),
    ((4203590, 4203609), 0), ((4203614, 4203636), 1), ((4203641, 4203651), 1), ((4203319, 4203341), 1),
    ((4203346, 4203366), 1), ((4203371, 4203398), 0), ((4203403, 4203428), 0), ((4203433, 4203457), 1),
    ((4203462, 4203490), 0), ((4203495, 4203514), 1), ((4203519, 4203558), 1), ((4203563, 4203585), 1),
    ((4203590, 4203609), 0), ((4203614, 4203636), 1), ((4203641, 4203651), 1), ((4203319, 4203341), 1),
    ((4203346, 4203366), 1), ((4203371, 4203398), 0), ((4203403, 4203428), 0), ((4203433, 4203457), 1),
    ((4203462, 4203490), 0), ((4203495, 4203514), 1), ((4203519, 4203558), 1), ((4203563, 4203585), 1),
    ((4203590, 4203609), 0), ((4203614, 4203636), 1), ((4203641, 4203651), 1), ((4203319, 4203341), 1),
    ((4203346, 4203366), 1), ((4203371, 4203398), 0), ((4203403, 4203428), 0), ((4203433, 4203457), 1),
    ((4203462, 4203490), 0), ((4203495, 4203514), 1), ((4203519, 4203558), 1), ((4203563, 4203585), 1),
    ((4203590, 4203609), 0), ((4203614, 4203636), 1), ((4203641, 4203651), 1), ((4203319, 4203341), 1),
    ((4203346, 4203366), 1), ((4203371, 4203398), 0), ((4203403, 4203428), 0), ((4203433, 4203457), 1),
    ((4203462, 4203490), 0), ((4203495, 4203514), 1), ((4203519, 4203558), 1), ((4203563, 4203585), 1),
    ((4203590, 4203609), 0), ((4203614, 4203636), 1), ((4203641, 4203651), 1), ((4203319, 4203341), 1),
    ((4203346, 4203366), 1), ((4203371, 4203398), 0), ((4203403, 4203428), 0), ((4203433, 4203457), 1),
    ((4203462, 4203490), 0), ((4203495, 4203514), 1), ((4203519, 4203558), 1), ((4203563, 4203585), 1),
    ((4203590, 4203609), 0), ((4203614, 4203636), 1), ((4203641, 4203651), 1), ((4203319, 4203341), 1),
    ((4203346, 4203366), 1), ((4203371, 4203398), 0), ((4203403, 4203428), 0), ((4203433, 4203457), 1),
    ((4203462, 4203490), 0), ((4203495, 4203514), 1), ((4203519, 4203558), 1), ((4203563, 4203585), 1),
    ((4203590, 4203609), 0), ((4203614, 4203636), 1), ((4203641, 4203651), 1), ((4203319, 4203341), 1),
    ((4203346, 4203366), 1), ((4203371, 4203398), 0), ((4203403, 4203428), 0), ((4203433, 4203457), 1),
    ((4203462, 4203490), 0), ((4203495, 4203514), 1), ((4203519, 4203558), 1), ((4203563, 4203585), 1),
    ((4203590, 4203609), 0), ((4203614, 4203636), 1), ((4203641, 4203651), 1), ((4203319, 4203341), 1),
    ((4203346, 4203366), 1), ((4203371, 4203398), 0), ((4203403, 4203428), 0), ((4203433, 4203457), 1),
    ((4203462, 4203490), 0), ((4203495, 4203514), 1), ((4203519, 4203558), 1), ((4203563, 4203585), 1),
    ((4203590, 4203609), 0), ((4203614, 4203636), 1), ((4203641, 4203651), 1), ((4203319, 4203341), 1),
    ((4203346, 4203366), 1), ((4203371, 4203398), 0), ((4203403, 4203428), 0), ((4203433, 4203457), 1),
    ((4203462, 4203490), 0), ((4203495, 4203514), 1), ((4203519, 4203558), 1), ((4203563, 4203585), 1),
    ((4203590, 4203609), 0), ((4203614, 4203636), 1), ((4203641, 4203651), 1), ((4203319, 4203341), 1),
    ((4203346, 4203366), 1), ((4203371, 4203398), 0), ((4203403, 4203428), 0), ((4203433, 4203457), 1),
    ((4203462, 4203490), 0), ((4203495, 4203514), 1), ((4203519, 4203558), 1), ((4203563, 4203585), 1),
    ((4203590, 4203609), 0), ((4203614, 4203636), 1), ((4203641, 4203651), 1), ((4203319, 4203341), 1),
    ((4203346, 4203366), 1), ((4203371, 4203398), 0), ((4203403, 4203428), 0), ((4203433, 4203457), 1),
    ((4203462, 4203490), 0), ((4203495, 4203514), 1), ((4203519, 4203558), 1), ((4203563, 4203585), 1),
    ((4203590, 4203609), 0), ((4203614, 4203636), 1), ((4203641, 4203651), 1), ((4203319, 4203341), 1),
    ((4203346, 4203366), 1), ((4203371, 4203398), 1), ((4203403, 4203428), 1), ((4203656, 4203689), 1),
    ((4203694, 4203737), 1), ((4203742, 4203776), 1), ((4203781, 4203804), 1), ((4203809, 4203831), 1),
    ((4203836, 4203856), 1), ((4203861, 4203888), 0), ((4203893, 4203918), 0), ((4203923, 4203957), 0),
    ((4203962, 4203981), 1), ((4203986, 4204025), 1), ((4204030, 4204040), 1), ((4204045, 4204067), 1),
    ((4204072, 4204091), 0), ((4204096, 4204118), 1), ((4204123, 4204133), 1), ((4203809, 4203831), 1),
    ((4203836, 4203856), 1), ((4203861, 4203888), 0), ((4203893, 4203918), 0), ((4203923, 4203957), 0),
    ((4203962, 4203981), 1), ((4203986, 4204025), 1), ((4204030, 4204040), 1), ((4204045, 4204067), 1),
    ((4204072, 4204091), 0), ((4204096, 4204118), 1), ((4204123, 4204133), 1), ((4203809, 4203831), 1),
    ((4203836, 4203856), 1), ((4203861, 4203888), 0), ((4203893, 4203918), 0), ((4203923, 4203957), 0),
    ((4203962, 4203981), 1), ((4203986, 4204025), 1), ((4204030, 4204040), 1), ((4204045, 4204067), 1),
    ((4204072, 4204091), 0), ((4204096, 4204118), 1), ((4204123, 4204133), 1), ((4203809, 4203831), 1),
    ((4203836, 4203856), 1), ((4203861, 4203888), 0), ((4203893, 4203918), 0), ((4203923, 4203957), 0),
    ((4203962, 4203981), 1), ((4203986, 4204025), 1), ((4204030, 4204040), 1), ((4204045, 4204067), 1),
    ((4204072, 4204091), 0), ((4204096, 4204118), 1), ((4204123, 4204133), 1), ((4203809, 4203831), 1),
    ((4203836, 4203856), 1), ((4203861, 4203888), 0), ((4203893, 4203918), 0), ((4203923, 4203957), 0),
    ((4203962, 4203981), 1), ((4203986, 4204025), 1), ((4204030, 4204040), 1), ((4204045, 4204067), 1),
    ((4204072, 4204091), 0), ((4204096, 4204118), 1), ((4204123, 4204133), 1), ((4203809, 4203831), 1),
    ((4203836, 4203856), 1), ((4203861, 4203888), 0), ((4203893, 4203918), 0), ((4203923, 4203957), 0),
    ((4203962, 4203981), 1), ((4203986, 4204025), 1), ((4204030, 4204040), 1), ((4204045, 4204067), 1),
    ((4204072, 4204091), 0), ((4204096, 4204118), 1), ((4204123, 4204133), 1), ((4203809, 4203831), 1),
    ((4203836, 4203856), 1), ((4203861, 4203888), 0), ((4203893, 4203918), 0), ((4203923, 4203957), 0),
    ((4203962, 4203981), 1), ((4203986, 4204025), 1), ((4204030, 4204040), 1), ((4204045, 4204067), 1),
    ((4204072, 4204091), 0), ((4204096, 4204118), 1), ((4204123, 4204133), 1), ((4203809, 4203831), 1),
    ((4203836, 4203856), 1), ((4203861, 4203888), 0), ((4203893, 4203918), 0), ((4203923, 4203957), 0),
    ((4203962, 4203981), 1), ((4203986, 4204025), 1), ((4204030, 4204040), 1), ((4204045, 4204067), 1),
    ((4204072, 4204091), 0), ((4204096, 4204118), 1), ((4204123, 4204133), 1), ((4203809, 4203831), 1),
    ((4203836, 4203856), 1), ((4203861, 4203888), 0), ((4203893, 4203918), 0), ((4203923, 4203957), 0),
    ((4203962, 4203981), 1), ((4203986, 4204025), 1), ((4204030, 4204040), 1), ((4204045, 4204067), 1),
    ((4204072, 4204091), 0), ((4204096, 4204118), 1), ((4204123, 4204133), 1), ((4203809, 4203831), 1),
    ((4203836, 4203856), 1), ((4203861, 4203888), 0), ((4203893, 4203918), 0), ((4203923, 4203957), 0),
    ((4203962, 4203981), 1), ((4203986, 4204025), 1), ((4204030, 4204040), 1), ((4204045, 4204067), 1),
    ((4204072, 4204091), 0), ((4204096, 4204118), 1), ((4204123, 4204133), 1), ((4203809, 4203831), 1),
    ((4203836, 4203856), 1), ((4203861, 4203888), 0), ((4203893, 4203918), 0), ((4203923, 4203957), 0),
    ((4203962, 4203981), 1), ((4203986, 4204025), 1), ((4204030, 4204040), 1), ((4204045, 4204067), 1),
    ((4204072, 4204091), 0), ((4204096, 4204118), 1), ((4204123, 4204133), 1), ((4203809, 4203831), 1),
    ((4203836, 4203856), 1), ((4203861, 4203888), 0), ((4203893, 4203918), 0), ((4203923, 4203957), 0),
    ((4203962, 4203981), 1), ((4203986, 4204025), 1), ((4204030, 4204040), 1), ((4204045, 4204067), 1),
    ((4204072, 4204091), 0), ((4204096, 4204118), 1), ((4204123, 4204133), 1), ((4203809, 4203831), 1),
    ((4203836, 4203856), 1), ((4203861, 4203888), 0), ((4203893, 4203918), 0), ((4203923, 4203957), 0),
    ((4203962, 4203981), 1), ((4203986, 4204025), 1), ((4204030, 4204040), 1), ((4204045, 4204067), 1),
    ((4204072, 4204091), 0), ((4204096, 4204118), 1), ((4204123, 4204133), 1), ((4203809, 4203831), 1),
    ((4203836, 4203856), 1), ((4203861, 4203888), 0), ((4203893, 4203918), 0), ((4203923, 4203957), 0),
    ((4203962, 4203981), 1), ((4203986, 4204025), 1), ((4204030, 4204040), 1), ((4204045, 4204067), 1),
    ((4204072, 4204091), 0), ((4204096, 4204118), 1), ((4204123, 4204133), 1), ((4203809, 4203831), 1),
    ((4203836, 4203856), 1), ((4203861, 4203888), 0), ((4203893, 4203918), 0), ((4203923, 4203957), 0),
    ((4203962, 4203981), 1), ((4203986, 4204025), 1), ((4204030, 4204040), 1), ((4204045, 4204067), 1),
    ((4204072, 4204091), 0), ((4204096, 4204118), 1), ((4204123, 4204133), 1), ((4203809, 4203831), 1),
    ((4203836, 4203856), 1), ((4203861, 4203888), 0), ((4203893, 4203918), 0), ((4203923, 4203957), 0),
    ((4203962, 4203981), 1), ((4203986, 4204025), 1), ((4204030, 4204040), 1), ((4204045, 4204067), 1),
    ((4204072, 4204091), 0), ((4204096, 4204118), 1), ((4204123, 4204133), 1), ((4203809, 4203831), 1),
    ((4203836, 4203856), 1), ((4203861, 4203888), 0), ((4203893, 4203918), 0), ((4203923, 4203957), 0),
    ((4203962, 4203981), 1), ((4203986, 4204025), 1), ((4204030, 4204040), 1), ((4204045, 4204067), 1),
    ((4204072, 4204091), 0), ((4204096, 4204118), 1), ((4204123, 4204133), 1), ((4203809, 4203831), 1),
    ((4203836, 4203856), 1), ((4203861, 4203888), 1), ((4203893, 4203918), 1), ((4204138, 4204171), 1)
]

# 函数序言块的起止地址
# 用于修复 main 入口，直接跳转到第一个真实块
PROLOGUE_STAR = 0x401E80
PROLOGUE_END = 0x401E8B

# 最终 return 块（例如 epilogue / leave; ret 所在块）
RETURN_BLOCK = 0x402690

# ============================================================
# 逻辑处理区
# ============================================================

# ------------------------------------------------------------
# 1. 构建真实控制流映射
# ------------------------------------------------------------

# block_next_map:
#   结构为：
#     block_next_map[block][zf] = {next_block1, next_block2, ...}
#
#   表示：
#     当执行到 block 且 ZF == zf 时
#     下一跳可能进入哪些真实块
block_next_map = defaultdict(lambda: defaultdict(set))

# block_zf_map:
#   block_zf_map[block] = {0, 1}
#
#   表示：
#     该真实块在执行过程中，ZF 出现过哪些取值
block_zf_map = defaultdict(set)

# 根据 real_flow 构建上述两个映射
for i in range(len(real_flow) - 1):
    cur_block, zf = real_flow[i]  # 当前真实块及其 ZF
    next_block, _ = real_flow[i + 1]  # 下一个真实块（ZF 无关）

block_zf_map[cur_block].add(zf)
    block_next_map[cur_block][zf].add(next_block)

# ------------------------------------------------------------
# 2. 准备虚假块资源池
# ------------------------------------------------------------

# 使用 deque：
#   - 顺序分配 fake block
#   - 避免重复使用
fake_queue = deque(fake_blocks)

# 记录哪些 fake block 被用作跳板
used_fake = set()

def alloc_fake_block(min_size=10):
    """
    从 fake_blocks 中分配一个可用的虚假块

要求：
        - 尚未使用
        - 空间足够大（至少能容纳 jz + jmp，约 11 字节）

返回：
        (start_ea, end_ea)
    """
    while fake_queue:
        fb = fake_queue.popleft()
        if (fb[1] - fb[0]) >= min_size:
            used_fake.add(fb)
            return fb
    raise Exception("No more fake blocks available!")

# ------------------------------------------------------------
# 通用工具函数
# ------------------------------------------------------------

def nop_range(start, end):
 """
 将 [start, end] 区间全部填充为 NOP
 用于：
 - 清除原 FLA 垃圾代码
 - 防止残留逻辑被误执行
 """
 ea = start
 while ea <= end:
 ida_bytes.patch_byte(ea, 0x90)
 ea += 1

def get_last_insn_ea(block_start, block_end):
    """
    在一个 block 内，反向查找最后一条“有效指令”

目的：
        FLA 中 block 末尾通常是 dispatcher 跳转
        我们需要精准定位并 patch 这条指令
    """
    ea = ida_bytes.prev_head(block_end + 1, block_start)
    while ea != idaapi.BADADDR and ea >= block_start:
        if ida_bytes.is_code(ida_bytes.get_full_flags(ea)):
            return ea
        ea = ida_bytes.prev_head(ea, block_start)
    return idaapi.BADADDR

def patch_jmp(frm, to):
    """
    在 frm 地址处，强制 patch 成：
        jmp to

用途：
        - 替换原 dispatcher 跳转
        - 替换原 jcc / 间接跳转
    """
    ida_bytes.del_items(frm, ida_bytes.DELIT_SIMPLE)
    ida_ua.create_insn(frm)
    ida_bytes.patch_byte(frm, 0xE9)
    rel = to - (frm + 5)
    ida_bytes.patch_dword(frm + 1, rel)

def emit_jz_jmp(ea, true_target, false_target):
    """
    在 fake block 中构造如下逻辑：

jz  true_target
        jmp false_target

用于：
        - 恢复真实 if / while / for 条件分支
        - ZF == 1 → true_target
        - ZF == 0 → false_target
    """

# jz true_target
    ida_bytes.del_items(ea, ida_bytes.DELIT_SIMPLE)
    ida_ua.create_insn(ea)
    ida_bytes.patch_byte(ea, 0x0F)
    ida_bytes.patch_byte(ea + 1, 0x84)
    rel = true_target - (ea + 6)
    ida_bytes.patch_dword(ea + 2, rel)
    ea += 6

# jmp false_target
    ida_bytes.del_items(ea, ida_bytes.DELIT_SIMPLE)
    ida_ua.create_insn(ea)
    ida_bytes.patch_byte(ea, 0xE9)
    rel = false_target - (ea + 5)
    ida_bytes.patch_dword(ea + 1, rel)
    ea += 5

return ea

print("[*] Starting Patching...")

# ------------------------------------------------------------
# 3. 修复函数序言块
# ------------------------------------------------------------
# main 的序言块不应再进入 dispatcher
# 直接跳转到第一个真实块
first_real_block = real_flow[0][0][0]
patch_jmp(
    get_last_insn_ea(PROLOGUE_STAR, PROLOGUE_END),
    first_real_block
)

# ------------------------------------------------------------
# 4. 修复所有真实块
# ------------------------------------------------------------
for block, zf_set in block_zf_map.items():
    start, end = block
    last_insn = get_last_insn_ea(start, end)
    branches = block_next_map[block]

# --------------------------------------------------------
    # 情况 A：该真实块只出现过一种 ZF
    # → 实际是“退化条件”或“直跳块”
    # --------------------------------------------------------
    if len(zf_set) == 1:
        zf = list(zf_set)[0]
        target = list(branches[zf])[0][0]
        patch_jmp(last_insn, target)

# --------------------------------------------------------
    # 情况 B：该真实块同时出现 ZF=0 / ZF=1
    # → 真正的条件分支
    # --------------------------------------------------------
    else:
        # 分配一个 fake block 作为条件跳板
        fb_start, fb_end = alloc_fake_block()

# 原真实块无条件跳到 fake block
        patch_jmp(last_insn, fb_start)

# 确定 ZF=1 / ZF=0 的真实目标
        true_target = list(branches[1])[0][0]
        false_target = list(branches[0])[0][0]

# 清空 fake block
        nop_range(fb_start, fb_end)

# 写入：
        #   if (ZF) goto true_target
        #   else    goto false_target
        emit_jz_jmp(fb_start, true_target, false_target)

# ------------------------------------------------------------
# 5. 修复最后一个真实块 → return block
# ------------------------------------------------------------
last_true_block_start = real_flow[-1][0][0]
last_true_block_end = real_flow[-1][0][1]
patch_jmp(
    get_last_insn_ea(last_true_block_start, last_true_block_end),
    RETURN_BLOCK
)

# ------------------------------------------------------------
# 6. 清理所有未使用的 fake blocks
# ------------------------------------------------------------
# 防止残留 FLA 垃圾逻辑
for fb in fake_blocks:
    if fb not in used_fake:
        nop_range(fb[0], fb[1])

print("[+] Patching Done! Press F5 to decompile.")
```

**效果验证**：  
![image](upload/attach/202512/1036360_5TXZ974UFB53X2H.png)

![image](upload/attach/202512/1036360_RDX89WP7UKZBB8D.png)

可以看到到了这一步已经很接近原程序的逻辑了，接下来我们可以手动进行一些修复

例如：去掉残留的控制代码流程变量 **`i`** 等

以下修复后的代码：

![image](upload/attach/202512/1036360_D6E8FS7UDKBR5R4.png)

---

## 参考文章

[https://bbs.kanxue.com/thread-289179.htm](https://bbs.kanxue.com/thread-289179.htm)

[https://bbs.kanxue.com/thread-274532.htm](https://bbs.kanxue.com/thread-274532.htm)

---

‍

回复或点赞可查看完整内容

传递专业知识、拓宽行业人脉——看雪讲师团队等你加入！！

#基础理论 #逆向分析 #脱壳反混淆 #HOOK注入 #工具脚本 #其他

收藏・84

点赞・228

打赏

赞赏记录

参与人

雪币

留言

时间

eappple

感谢你的积极参与，期待更多精彩内容！

2天前

mb_djytmgxy

为你点赞！

4天前

地奇

感谢你的积极参与，期待更多精彩内容！

6天前

窗外的三脚猫

感谢你分享这么好的资源！

2026-10-4 18:01

mb_elqwyvnm

为你点赞！

2026-9-30 01:17

git_99440qimingminimax

为你点赞！

2026-9-23 11:18

mb_dvqqrcce

谢谢你的细致分析，受益匪浅！

2026-9-11 17:16

git_51951meggadf3df

非常支持你的观点！

2026-9-11 09:10

晨曦。

为你点赞！

2026-9-9 07:39

张楚岚.

为你点赞！

2026-9-8 14:06

铭信

你的帖子非常有用，感谢分享！

2026-9-7 21:56

mb_pnztjmio

谢谢你的细致分析，受益匪浅！

2026-9-6 16:22

Love 2016

为你点赞！

2026-8-27 00:51

LeoChen..

你的帖子非常有用，感谢分享！

2026-8-25 20:32

mb_lthgjpwj

为你点赞！

2026-8-20 17:25

wx_Mark_449

为你点赞！

2026-8-18 18:12

2beNo2

这个讨论对我很有帮助，谢谢！

2026-8-18 14:26

mb_cebxltxx

为你点赞！

2026-8-16 13:53

tuosen

为你点赞！

2026-8-15 11:06

Red

为你点赞！

2026-8-12 14:16

mb_wsoacceo

为你点赞！

2026-8-7 23:31

Wika

感谢你的贡献，论坛因你而更加精彩！

2026-7-31 15:19

aut0run

期待更多优质内容的分享，论坛有你更精彩！

2026-7-30 17:27

TheLuckyOne

感谢你分享这么好的资源！

2026-7-29 18:14

北袅

你的分享对大家帮助很大，非常感谢！

2026-7-25 16:25

mb_qmomcleg

感谢你分享这么好的资源！

2026-7-23 12:56

学会规则

为你点赞！

2026-7-22 19:14

mb_voovcenu

这个讨论对我很有帮助，谢谢！

2026-7-22 11:42

mb_ovmxbmhd

谢谢你的细致分析，受益匪浅！

2026-7-22 11:35

QWQ_next

感谢你的贡献，论坛因你而更加精彩！

2026-7-21 09:41

Seem_Black

感谢你的积极参与，期待更多精彩内容！

2026-7-17 15:11

fishod

谢谢你的细致分析，受益匪浅！

2026-7-17 10:01

qianfeng_mi

为你点赞！

2026-7-16 15:54

一叶梦花

非常支持你的观点！

2026-7-16 14:53

mb_gvpkossd

谢谢你的细致分析，受益匪浅！

2026-7-16 09:50

wx_晨梦

感谢你分享这么好的资源！

2026-7-16 06:14

wx_kx92911

为你点赞！

2026-7-15 11:43

afishlong

你的分享对大家帮助很大，非常感谢！

2026-7-14 01:21

mb_hsscwjpz

你的分享对大家帮助很大，非常感谢！

2026-7-9 10:23

mb_hivqmkwr

非常支持你的观点！

2026-7-7 22:40

mb_mmodulik

这个讨论对我很有帮助，谢谢！

2026-7-7 18:57

x1a0f3n9

谢谢你的细致分析，受益匪浅！

2026-7-2 02:46

ulong9527

为你点赞！

2026-6-26 11:00

hacker521

谢谢你的细致分析，受益匪浅！

2026-6-25 11:18

zhongdong

为你点赞！

2026-6-19 13:35

xxxark

这个讨论对我很有帮助，谢谢！

2026-6-16 11:13

Itachi_

非常支持你的观点！

2026-6-6 03:38

zhnnmsl

谢谢你的细致分析，受益匪浅！

2026-6-4 18:37

Ms135

你的分享对大家帮助很大，非常感谢！

2026-6-4 17:55

Ayuer

这个讨论对我很有帮助，谢谢！

2026-6-3 15:17

马来

期待更多优质内容的分享，论坛有你更精彩！

2026-6-3 10:42

ycdear

为你点赞！

2026-6-1 08:31

Mengz3

为你点赞！

2026-6-1 00:02

g-yan

非常支持你的观点！

2026-5-31 11:20

木志本柯

非常支持你的观点！

2026-5-30 13:15

pexillove

为你点赞！

2026-5-30 13:04

番茄丶

这个讨论对我很有帮助，谢谢！

2026-5-27 20:43

zengsunsan

非常支持你的观点！

2026-5-26 23:24

linchuan0

为你点赞！

2026-5-19 21:54

yeshuibo

这个讨论对我很有帮助，谢谢！

2026-5-17 17:30

Gift1a

期待更多优质内容的分享，论坛有你更精彩！

2026-5-14 09:21

git_94536luohuaweishui

感谢你的积极参与，期待更多精彩内容！

2026-5-13 16:57

mb_icbgiifu

为你点赞！

2026-5-9 09:46

JaniQuiz

感谢你分享这么好的资源！

2026-5-8 10:39

linkin5epk

为你点赞！

2026-5-7 16:56

wjdidi

感谢你的积极参与，期待更多精彩内容！

2026-5-7 00:17

Melanthe

期待更多优质内容的分享，论坛有你更精彩！

2026-5-3 14:10

SX_DomOne

谢谢你的细致分析，受益匪浅！

2026-5-1 20:28

周游列国

期待更多优质内容的分享，论坛有你更精彩！

2026-4-28 21:55

吖銮

感谢你的积极参与，期待更多精彩内容！

2026-4-27 22:40

npc0vo

这个讨论对我很有帮助，谢谢！

2026-4-26 05:18

autorun886

你的帖子非常有用，感谢分享！

2026-4-25 21:52

fzyspark

非常支持你的观点！

2026-4-23 12:24

lzx060917

感谢你分享这么好的资源！

2026-4-22 23:54

mb_ecayuquu

感谢你的积极参与，期待更多精彩内容！

2026-4-21 17:10

wake0p

感谢你的贡献，论坛因你而更加精彩！

2026-4-20 15:46

wx_来时路

这个讨论对我很有帮助，谢谢！

2026-4-16 12:21

euw

期待更多优质内容的分享，论坛有你更精彩！

2026-4-15 14:28

mb_iqcojgcb

感谢你分享这么好的资源！

2026-4-8 09:40

mb_pfsyglzv

期待更多优质内容的分享，论坛有你更精彩！

2026-4-3 01:28

BeanSpy

为你点赞！

2026-4-1 15:53

倔强石头

感谢你分享这么好的资源！

2026-3-30 19:20

Liv_T

你的帖子非常有用，感谢分享！

2026-3-28 02:40

Xhani

期待更多优质内容的分享，论坛有你更精彩！

2026-3-22 20:05

qig

为你点赞！

2026-3-21 20:38

whohh

为你点赞！

2026-3-20 20:34

mb_ndmoqzht

你的分享对大家帮助很大，非常感谢！

2026-3-20 00:18

zhzhz

为你点赞！

2026-3-18 09:11

mb_czjtaqrb

感谢你分享这么好的资源！

2026-3-16 11:32

哄哄嘛

感谢你的积极参与，期待更多精彩内容！

2026-3-14 00:11

mb_dqtugcyf

为你点赞！

2026-3-12 14:38

wx_Q道长

这个讨论对我很有帮助，谢谢！

2026-3-11 17:39

coNg叶

为你点赞！

2026-3-11 15:23

mb_ppqrapka

为你点赞！

2026-3-11 12:53

天水姜伯约

为你点赞！

2026-3-10 20:11

张延清

你的分享对大家帮助很大，非常感谢！

2026-3-7 02:14

mb_koixqizd

感谢你分享这么好的资源！

2026-3-6 14:09

mb_iekomvyy

感谢你的积极参与，期待更多精彩内容！

2026-3-4 10:10

nekomiao

你的帖子非常有用，感谢分享！

2026-3-3 22:40

Matriy

你的分享对大家帮助很大，非常感谢！

2026-3-3 22:37

Ram98

为你点赞！

2026-3-3 17:29

mb_mrjjcxgk

期待更多优质内容的分享，论坛有你更精彩！

2026-3-3 09:58

coderL

谢谢你的细致分析，受益匪浅！

2026-3-3 09:35

mb_zpvlfkkg

感谢你分享这么好的资源！

2026-3-3 06:23

烬奇小云

这个讨论对我很有帮助，谢谢！

2026-2-28 15:42

mb_ltpfmbod

感谢你分享这么好的资源！

2026-2-27 02:32

wx_浓情淡如你

感谢你分享这么好的资源！

2026-2-25 16:43

沫水.

你的帖子非常有用，感谢分享！

2026-2-24 16:32

龙幽

谢谢你的细致分析，受益匪浅！

2026-2-24 09:16

mb_yqvhzrvm

谢谢你的细致分析，受益匪浅！

2026-2-24 08:33

5m10v3

感谢你分享这么好的资源！

2026-2-22 23:30

青丝梦

为你点赞！

2026-2-22 17:29

ovo.kx

感谢你分享这么好的资源！

2026-2-21 15:02

值得怀疑

非常支持你的观点！

2026-2-20 11:11

mb_fxpsmzfr

为你点赞！

2026-2-20 09:42

xhan8

期待更多优质内容的分享，论坛有你更精彩！

2026-2-19 19:26

黎明与黄昏

谢谢你的细致分析，受益匪浅！

2026-2-17 21:16

mb_hyhlwyeo

感谢你分享这么好的资源！

2026-2-13 01:48

wx_funcrever

你的分享对大家帮助很大，非常感谢！

2026-2-12 14:44

beimingyouyu

你的分享对大家帮助很大，非常感谢！

2026-2-12 11:05

mb_wyefudor

这个讨论对我很有帮助，谢谢！

2026-2-12 04:04

taeyeon_ss

感谢你的贡献，论坛因你而更加精彩！

2026-2-10 17:59

bluegatar

感谢你的积极参与，期待更多精彩内容！

2026-2-8 21:12

袁伟业

为你点赞！

2026-2-8 07:08

scp000000

你的分享对大家帮助很大，非常感谢！

2026-2-6 16:48

镜中人24

你的分享对大家帮助很大，非常感谢！

2026-2-6 11:04

xinhu

为你点赞！

2026-2-5 16:14

APT_华生

为你点赞！

2026-2-5 15:02

lanoche

谢谢你的细致分析，受益匪浅！

2026-2-3 14:24

gladly

谢谢你的细致分析，受益匪浅！

2026-1-31 15:39

lingyi223

为你点赞！

2026-1-30 17:16

onwyc123

感谢你分享这么好的资源！

2026-1-29 22:31

拉不利多

你的帖子非常有用，感谢分享！

2026-1-28 22:11

wx_ㅤ_683

为你点赞！

2026-1-28 11:07

fatkun

感谢你的积极参与，期待更多精彩内容！

2026-1-22 16:26

h01mes

期待更多优质内容的分享，论坛有你更精彩！

2026-1-22 13:24

sunkc99

非常支持你的观点！

2026-1-22 08:31

git_76767Zhangzy-54

感谢你分享这么好的资源！

2026-1-21 21:36

mb_mvziuxxh

感谢你的积极参与，期待更多精彩内容！

2026-1-21 20:15

maxfire

谢谢你的细致分析，受益匪浅！

2026-1-20 05:29

沐泽

你的帖子非常有用，感谢分享！

2026-1-19 15:31

x1aob1n

你的分享对大家帮助很大，非常感谢！

2026-1-18 22:34

烟花易冷丶

这个讨论对我很有帮助，谢谢！

2026-1-14 17:19

er胡

你的帖子非常有用，感谢分享！

2026-1-12 14:44

webfker

感谢你的贡献，论坛因你而更加精彩！

2026-1-11 21:46

苦瓜.

你的帖子非常有用，感谢分享！

2026-1-11 15:53

mb_nofqtpir

为你点赞！

2026-1-8 08:54

mb_ynpgeaep

这个讨论对我很有帮助，谢谢！

2026-1-6 14:39

L0x1c

感谢你的积极参与，期待更多精彩内容！

2026-1-4 17:22

wx_突突兔

感谢你的积极参与，期待更多精彩内容！

2026-1-4 07:04

Bileton

为你点赞！

2026-1-3 00:48

git_94983linye9999

为你点赞！

2026-1-2 19:28

mb_fhgouhuy

这个讨论对我很有帮助，谢谢！

2025-12-31 20:35

小傲骨

非常支持你的观点！

2025-12-31 19:57

taoying

为你点赞！

2025-12-31 09:54

wx_kx89282

你的分享对大家帮助很大，非常感谢！

2025-12-30 20:00

MsScotch

非常支持你的观点！

2025-12-30 10:21

Old_Yuan

这个讨论对我很有帮助，谢谢！

2025-12-29 16:34

homea_qwq

谢谢你的细致分析，受益匪浅！

2025-12-29 14:58

she.

感谢你分享这么好的资源！

2025-12-28 17:51

wangkaicj

感谢你的贡献，论坛因你而更加精彩！

2025-12-28 16:07

mb_pnrjfxiv

感谢你的贡献，论坛因你而更加精彩！

2025-12-26 22:52

逆天而行

感谢你分享这么好的资源！

2025-12-26 21:23

ty1937

这个讨论对我很有帮助，谢谢！

2025-12-26 17:57

Bxb0

谢谢你的细致分析，受益匪浅！

2025-12-26 17:43

小菜鸭

谢谢你的细致分析，受益匪浅！

2025-12-26 14:29

扒饭海铃

感谢你分享这么好的资源！

2025-12-26 14:14

gaybc

这个讨论对我很有帮助，谢谢！

2025-12-26 14:11

下雨天sana

期待更多优质内容的分享，论坛有你更精彩！

2025-12-25 16:42

零_721409

这个讨论对我很有帮助，谢谢！

2025-12-25 15:08

alienhe

这个讨论对我很有帮助，谢谢！

2025-12-25 11:11

bfloat16

你的分享对大家帮助很大，非常感谢！

2025-12-25 08:02

zzage

你的帖子非常有用，感谢分享！

2025-12-24 14:59

lvcoffee

非常支持你的观点！

2025-12-24 11:16

mb_izfxicrp

为你点赞！

2025-12-24 11:08

mb_eiufitqh

感谢你的积极参与，期待更多精彩内容！

2025-12-23 20:27

z221x

感谢你的贡献，论坛因你而更加精彩！

2025-12-23 19:48

lqfcugo

你的分享对大家帮助很大，非常感谢！

2025-12-23 17:20

xianyuuuan

感谢你的积极参与，期待更多精彩内容！

2025-12-23 17:02

mb_nxicnwnb

期待更多优质内容的分享，论坛有你更精彩！

2025-12-23 16:41

yezheyu

谢谢你的细致分析，受益匪浅！

2025-12-23 15:07

LIU.YZ

感谢你的贡献，论坛因你而更加精彩！

2025-12-23 14:22

令狐双

这个讨论对我很有帮助，谢谢！

2025-12-23 11:57

丁海洋

感谢你分享这么好的资源！

2025-12-23 11:28

tamori丶

你的分享对大家帮助很大，非常感谢！

2025-12-23 11:08

nothing233

期待更多优质内容的分享，论坛有你更精彩！

2025-12-23 09:45

qqizai

期待更多优质内容的分享，论坛有你更精彩！

2025-12-23 09:33

git_47499test-look

谢谢你的细致分析，受益匪浅！

2025-12-23 05:13

mb_mywnpifi

谢谢你的细致分析，受益匪浅！

2025-12-23 02:43

MochaCo

感谢你的积极参与，期待更多精彩内容！

2025-12-22 21:46

wx_　　　　　　　　_937851

非常支持你的观点！

2025-12-22 20:56

mb_wpitiize

为你点赞！

2025-12-22 19:53

NshIdE

非常支持你的观点！

2025-12-22 19:42

快乐的小跳蛙

你的分享对大家帮助很大，非常感谢！

2025-12-22 18:12

b!@nk

这个讨论对我很有帮助，谢谢！

2025-12-22 17:25

Forgo7ten

这个讨论对我很有帮助，谢谢！

2025-12-22 15:59

cydian

为你点赞！

2025-12-22 15:41

寻影星尘

为你点赞！

2025-12-22 14:16

shutterbug

为你点赞！

2025-12-22 14:03

小向i小葵

感谢你的积极参与，期待更多精彩内容！

2025-12-22 13:49

dofla

感谢你的积极参与，期待更多精彩内容！

2025-12-22 13:05

Y6blNU1L

这个讨论对我很有帮助，谢谢！

2025-12-22 11:37

rettozero

期待更多优质内容的分享，论坛有你更精彩！

2025-12-22 11:26

[軍]

这个讨论对我很有帮助，谢谢！

2025-12-22 11:05

皮皮虾啊

谢谢你的细致分析，受益匪浅！

2025-12-22 10:12

Catmeow

你的分享对大家帮助很大，非常感谢！

2025-12-22 09:57

fyrlove

这个讨论对我很有帮助，谢谢！

2025-12-22 09:54

醉染

你的分享对大家帮助很大，非常感谢！

2025-12-22 09:42

wogao

谢谢你的细致分析，受益匪浅！

2025-12-22 09:40

逆向小玖

谢谢你的细致分析，受益匪浅！

2025-12-22 09:33

Vincent_sec

谢谢你的细致分析，受益匪浅！

2025-12-22 09:27

Hawcett

为你点赞！

2025-12-22 09:22

mb_bppcorlj

你的分享对大家帮助很大，非常感谢！

2025-12-21 23:36

loveqiao

谢谢你的细致分析，受益匪浅！

2025-12-21 23:36

清风jw

谢谢你的细致分析，受益匪浅！

2025-12-21 21:42

juice4fun

你的帖子非常有用，感谢分享！

2025-12-21 21:02

梧桐生

感谢你的积极参与，期待更多精彩内容！

2025-12-21 19:48

东方玻璃

你的帖子非常有用，感谢分享！

2025-12-21 18:45

aeolusw

感谢你分享这么好的资源！

2025-12-21 15:24

mb_rjdrqvpa

感谢你的积极参与，期待更多精彩内容！

2025-12-21 14:32

mb_tmbvnlxt

非常支持你的观点！

2025-12-21 13:44

孤独的街

你的分享对大家帮助很大，非常感谢！

2025-12-21 11:38

chaoxi72

为你点赞！

2025-12-21 10:05

我的小拇指啊

这个讨论对我很有帮助，谢谢！

2025-12-21 02:18

doduhuang

感谢你分享这么好的资源！

2025-12-21 00:06

huangyalei

你的帖子非常有用，感谢分享！

2025-12-20 23:21

岁月。

你的帖子非常有用，感谢分享！

2025-12-20 22:15

顽劣

为你点赞！

2025-12-20 21:45

最新回复 (151) 1 2 3 4 5 6 7 ▶
lllluffyx 雪币： 5 能力值： ( LV1，RANK：0 ) 在线值：发帖 1 回帖 3 粉丝 2 关注私信	lllluffyx 2 楼 XiuSi神太帅了 2025-12-20 21:44 0
mb_asiwnxyv 雪币： 6 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 100 粉丝 0 关注私信	mb_asiwnxyv 3 楼感谢分享 2025-12-20 21:54 0
xianhuimin 雪币： 9341 活跃值： (6228) 能力值： ( LV2，RANK：10 ) 在线值：发帖 5 回帖 231 粉丝 2 关注私信	xianhuimin 4 楼 666 2025-12-21 00:02 0
KanXue_NG 雪币： 679 能力值： ( LV1，RANK：0 ) 在线值：发帖 7 回帖 100 粉丝 66 关注私信	KanXue_NG 5 楼学习一下 2025-12-21 09:37 0
mb_ldbucrik 雪币： 6 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 708 粉丝 7 关注私信	mb_ldbucrik 6 楼 666 2025-12-21 11:31 0
LQ6H 雪币： 530 活跃值： (2627) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 80 粉丝 1 关注私信	LQ6H 7 楼 666 2025-12-21 14:39 0
MaYil 雪币： 9448 活跃值： (8077) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 485 粉丝 2 关注私信	MaYil 8 楼感谢分享 2025-12-21 21:16 0
mb_dcjxxhsk 雪币： 200 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 79 粉丝 0 关注私信	mb_dcjxxhsk 9 楼 6666 2025-12-21 23:13 0
GEKEZYX 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 157 粉丝 0 关注私信	GEKEZYX 10 楼 666 2025-12-22 09:48 0
PayPoc 雪币： 1922 活跃值： (2598) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 4 粉丝 1 关注私信	PayPoc 11 楼学习学习 2025-12-22 10:12 0
iBa0 雪币： 1901 活跃值： (5948) 能力值： ( LV4，RANK：40 ) 在线值：发帖 6 回帖 493 粉丝 37 关注私信	iBa0 12 楼 123 2025-12-22 10:15 0
Imxz 雪币： 110 活跃值： (9576) 能力值： ( LV2，RANK：10 ) 在线值：发帖 6 回帖 775 粉丝 9 关注私信	Imxz 13 楼 tql 2025-12-22 10:53 0
hswizy 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 1 回帖 5 粉丝 0 关注私信	hswizy 14 楼高级 2025-12-22 10:57 0
xiaoc996 雪币： 938 活跃值： (2265) 能力值： ( LV3，RANK：30 ) 在线值：发帖 4 回帖 48 粉丝 35 关注私信	xiaoc996 15 楼 tql 2025-12-22 11:17 0
B1t3 雪币： 648 活跃值： (479) 能力值： ( LV2，RANK：10 ) 在线值：发帖 2 回帖 12 粉丝 2 关注私信	B1t3 16 楼 666 2025-12-22 20:10 0
G0Fl1er 雪币： 192 活跃值： (825) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 24 粉丝 0 关注私信	G0Fl1er 17 楼正好分析了一个样本遇上了，学习一下 2025-12-22 21:11 0
fangliangz 雪币： 5717 活跃值： (4104) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 112 粉丝 1 关注私信	fangliangz 18 楼学习学习 2025-12-23 09:13 0
__Shinn 雪币： 2743 活跃值： (1515) 能力值： ( LV7，RANK：100 ) 在线值：发帖 4 回帖 74 粉丝 85 关注私信	__Shinn 2 19 楼学习一下 2025-12-23 10:26 0
mb_cbgtaveo 雪币： 292 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 259 粉丝 0 关注私信	mb_cbgtaveo 20 楼 6666666666 2025-12-23 11:05 0
梧桐生雪币： 2437 活跃值： (6452) 能力值： ( LV4，RANK：50 ) 在线值：发帖 5 回帖 9 粉丝 23 关注私信	梧桐生 21 楼 666 2025-12-23 18:00 0
tigericon 雪币： 90 活跃值： (930) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 53 粉丝 0 关注私信	tigericon 22 楼 66 2025-12-24 11:38 0
lvchalove 雪币： 47 活跃值： (2386) 能力值： ( LV2，RANK：10 ) 在线值：发帖 4 回帖 47 粉丝 0 关注私信	lvchalove 23 楼 6666666666 2025-12-24 15:21 0
mJqalJqN 雪币： 16 能力值： ( LV1，RANK：0 ) 在线值：发帖 4 回帖 124 粉丝 4 关注私信	mJqalJqN 24 楼 1 2025-12-24 15:59 0
memoriaru 雪币： 14 活跃值： (664) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 25 粉丝 0 关注私信	memoriaru 25 楼 666 2025-12-25 10:36 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复

xiusi

发帖

回帖

170

RANK

关注

私信

他的文章

关于我们

联系我们

企业服务

看雪公众号

最新回复 (151) 1 2 3 4 5 6 7 ▶
lllluffyx 雪币： 5 能力值： ( LV1，RANK：0 ) 在线值：发帖 1 回帖 3 粉丝 2 关注私信	lllluffyx 2 楼 XiuSi神太帅了 2025-12-20 21:44 0
mb_asiwnxyv 雪币： 6 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 100 粉丝 0 关注私信	mb_asiwnxyv 3 楼感谢分享 2025-12-20 21:54 0
xianhuimin 雪币： 9341 活跃值： (6228) 能力值： ( LV2，RANK：10 ) 在线值：发帖 5 回帖 231 粉丝 2 关注私信	xianhuimin 4 楼 666 2025-12-21 00:02 0
KanXue_NG 雪币： 679 能力值： ( LV1，RANK：0 ) 在线值：发帖 7 回帖 100 粉丝 66 关注私信	KanXue_NG 5 楼学习一下 2025-12-21 09:37 0
mb_ldbucrik 雪币： 6 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 708 粉丝 7 关注私信	mb_ldbucrik 6 楼 666 2025-12-21 11:31 0
LQ6H 雪币： 530 活跃值： (2627) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 80 粉丝 1 关注私信	LQ6H 7 楼 666 2025-12-21 14:39 0
MaYil 雪币： 9448 活跃值： (8077) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 485 粉丝 2 关注私信	MaYil 8 楼感谢分享 2025-12-21 21:16 0
mb_dcjxxhsk 雪币： 200 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 79 粉丝 0 关注私信	mb_dcjxxhsk 9 楼 6666 2025-12-21 23:13 0
GEKEZYX 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 157 粉丝 0 关注私信	GEKEZYX 10 楼 666 2025-12-22 09:48 0
PayPoc 雪币： 1922 活跃值： (2598) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 4 粉丝 1 关注私信	PayPoc 11 楼学习学习 2025-12-22 10:12 0
iBa0 雪币： 1901 活跃值： (5948) 能力值： ( LV4，RANK：40 ) 在线值：发帖 6 回帖 493 粉丝 37 关注私信	iBa0 12 楼 123 2025-12-22 10:15 0
Imxz 雪币： 110 活跃值： (9576) 能力值： ( LV2，RANK：10 ) 在线值：发帖 6 回帖 775 粉丝 9 关注私信	Imxz 13 楼 tql 2025-12-22 10:53 0
hswizy 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 1 回帖 5 粉丝 0 关注私信	hswizy 14 楼高级 2025-12-22 10:57 0
xiaoc996 雪币： 938 活跃值： (2265) 能力值： ( LV3，RANK：30 ) 在线值：发帖 4 回帖 48 粉丝 35 关注私信	xiaoc996 15 楼 tql 2025-12-22 11:17 0
B1t3 雪币： 648 活跃值： (479) 能力值： ( LV2，RANK：10 ) 在线值：发帖 2 回帖 12 粉丝 2 关注私信	B1t3 16 楼 666 2025-12-22 20:10 0
G0Fl1er 雪币： 192 活跃值： (825) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 24 粉丝 0 关注私信	G0Fl1er 17 楼正好分析了一个样本遇上了，学习一下 2025-12-22 21:11 0
fangliangz 雪币： 5717 活跃值： (4104) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 112 粉丝 1 关注私信	fangliangz 18 楼学习学习 2025-12-23 09:13 0
__Shinn 雪币： 2743 活跃值： (1515) 能力值： ( LV7，RANK：100 ) 在线值：发帖 4 回帖 74 粉丝 85 关注私信	__Shinn 2 19 楼学习一下 2025-12-23 10:26 0
mb_cbgtaveo 雪币： 292 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 259 粉丝 0 关注私信	mb_cbgtaveo 20 楼 6666666666 2025-12-23 11:05 0
梧桐生雪币： 2437 活跃值： (6452) 能力值： ( LV4，RANK：50 ) 在线值：发帖 5 回帖 9 粉丝 23 关注私信	梧桐生 21 楼 666 2025-12-23 18:00 0
tigericon 雪币： 90 活跃值： (930) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 53 粉丝 0 关注私信	tigericon 22 楼 66 2025-12-24 11:38 0
lvchalove 雪币： 47 活跃值： (2386) 能力值： ( LV2，RANK：10 ) 在线值：发帖 4 回帖 47 粉丝 0 关注私信	lvchalove 23 楼 6666666666 2025-12-24 15:21 0
mJqalJqN 雪币： 16 能力值： ( LV1，RANK：0 ) 在线值：发帖 4 回帖 124 粉丝 4 关注私信	mJqalJqN 24 楼 1 2025-12-24 15:59 0
memoriaru 雪币： 14 活跃值： (664) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 25 粉丝 0 关注私信	memoriaru 25 楼 666 2025-12-25 10:36 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复