[原创]深入浅出 Capstone 框架学习-Android安全-看雪安全社区

# 深入浅出 Capstone 框架学习

## 一、前言：为什么我们需要 Capstone？

通过前面的文章：[[原创]深入浅出 Unicorn 框架学习](https://bbs.kanxue.com/thread-289502.htm)

我们已经掌握了 Unicorn 框架的基础，你会发现它虽然强大，但有一个明显的缺陷——它是一个**只有大脑，没有眼睛**的模拟器。

### 1. Unicorn 的局限性

Unicorn 是一个纯粹的 CPU 模拟执行引擎。它极其擅长执行二进制流，改变寄存器和内存的状态。  
在 Unicorn 的眼中，一切皆是 0 和 1。它不知道当前是在做加法（`ADD`）还是在跳转（`JMP`），这使得我们在调试和分析时如同盲人摸象。

### 2. Capstone 的角色

**Capstone** 就是我们为模拟器安装的 **“眼睛”** （反汇编引擎）。

- **核心能力**：将枯燥晦涩的机器码（Machine Code，如 `\x55\x48\x89\xe5`）翻译成人类可读的汇编语言（Assembly，如 `push rbp; mov rbp, rsp`）。
- **多架构支持**：它支持几乎所有主流架构（x86, ARM, MIPS, RISC-V 等），这与 Unicorn 的多架构特性完美契合。

### 3. Unicorn + Capstone

将 Capstone 引入 Unicorn 的 Hook 回调中，我们就能实现从“黑盒运行”到“白盒监控”的质变：

- **实时追踪**：打印每一条正在执行的汇编指令，生成 Trace Log。
- **语义分析**：识别出 `CALL` 指令并自动跳过，或识别 `SYSCALL` 并模拟系统调用。
- **辅助修改**：结合 Keystone（汇编引擎），实现“边执行、边分析、边 Patch”的动态调试效果。

---

## 二、环境准备与基础概念

在开始编写代码之前，我们需要先搭建环境，并理解 Capstone 的几个核心概念。

### 1. 环境安装

Capstone 提供了完美的 Python 绑定，安装非常简单：

```bash
pip install capstone
```

> **注**：建议在与 Unicorn 相同的虚拟环境（conda/venv）中安装，确保两者可以无缝协作。
>
> ![image](upload/attach/202512/1036360_2F4ZFVDKN5CDGE6.png)

### 2. 核心类解析

在使用 Capstone 时，我们主要会和以下两个类打交道：

- **`Cs`**  **(Capstone Engine)**   
  这是反汇编引擎的核心类。你需要实例化它来创建一个反汇编器对象。

- *作用*：配置架构、模式，执行反汇编操作。
- **`CsInsn`**  **(Capstone Instruction)**   
  这是“指令对象”。每当你反汇编一条机器码，Capstone 就会返回一个 `CsInsn` 实例。

- *关键属性*：

- `.address`: 指令的内存地址 (int)。
    - `.mnemonic`: 助记符 (str)，如 `mov`, `xor`, `call`。
    - `.op_str`: 操作数 (str)，如 `rax, rbx` 或 `[rsp+8]`。
    - `.bytes`: 原始机器码 (bytes)。

### 3. 架构与模式 (Architecture & Mode)

Capstone 的架构常量命名规范与 Unicorn 高度相似，**使用时必须保持一致**。

**初始化原型**：`md = Cs(arch, mode)`

|架构|Unicorn 常量|Capstone 常量|说明|
| ------| --------------| ---------------| ---------------------|
|**x86 / x64**|`UC_ARCH_X86`|**`CS_ARCH_X86`**|通用 Intel/AMD 架构|
|**ARM**|`UC_ARCH_ARM`|**`CS_ARCH_ARM`**|32位 ARM|
|**ARM64**|`UC_ARCH_ARM64`|**`CS_ARCH_ARM64`**|64位 ARM (AArch64)|

**模式对应表**：

|模式|Unicorn 常量|Capstone 常量|
| ------| --------------| ---------------|
|**32位**|`UC_MODE_32`|**`CS_MODE_32`**|
|**64位**|`UC_MODE_64`|**`CS_MODE_64`**|
|**Thumb**|`UC_MODE_THUMB`|**`CS_MODE_THUMB`**|
|**Little Endian**|`UC_MODE_LITTLE_ENDIAN`|**`CS_MODE_LITTLE_ENDIAN`**|

---

## 三、静态反汇编初体验

在将 Capstone 集成到 Unicorn 之前，我们先单独运行它，体验一下如何将一段纯粹的二进制数据（Bytes）还原为汇编代码。

### 目标

反汇编一段 x64 机器码：`\x55\x48\x8b\x05\xb8\x13\x00\x00`。

### 完整代码示例

```python
from capstone import *

# 1. 准备机器码 (Shellcode)
# 这是一段 x64 机器码
CODE = b"\x55\x48\x8b\x05\xb8\x13\x00\x00"

# 2. 初始化反汇编引擎
# 架构: x86, 模式: 64位
cs = Cs(CS_ARCH_X86, CS_MODE_64)

print(f"Disassembly result:")
print("-" * 30)

# 3. 执行反汇编
# md.disasm(code, offset)
# code:   要反汇编的二进制数据 (bytes)
# offset: 这段代码在内存中的起始地址 (int)，用于计算相对跳转等地址
# 返回值: 一个生成器 (generator)，每次迭代返回一个 CsInsn 对象
for insn in cs.disasm(CODE, 0x1000):
    # 4. 打印指令详情
    # address:  指令地址
    # mnemonic: 助记符 (如 mov, call)
    # op_str:   操作数字符串 (如 rax, 1)
    print(f"0x{insn.address:x}:\t{insn.mnemonic}\t{insn.op_str}")
    print("Machine code: ", end="")
    for i in insn.bytes:
        print(f"{i:02x}", end=" ")
    print()

print("-" * 30)
```

### 运行结果解析

运行上述脚本，你将看到如下输出：

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

**关键点解读**：

- **0x1000**: 第一条指令 `push rbp` (机器码 `0x55`) 的地址。这是因为我们在 `disasm` 函数中指定了基址为 `0x1000`。
- **0x1001**: 第二条指令的地址。注意它自动计算了上一条指令的长度（1字节），所以地址顺延到了 `1001`。
- **RIP 相对寻址**: Capstone 足够智能，它根据当前的地址 `0x1001` 和机器码中的偏移 `0x13b8`，正确解析出了 RIP 相对寻址的语法 `[rip + 0x13b8]`。

---

## 四、核心实战：在 Unicorn Hook 中集成 Capstone

这部分我们将打通 Unicorn（大脑）和 Capstone（眼睛）的连接。通过在 Unicorn 的 `UC_HOOK_CODE` 回调中调用 Capstone，我们可以实时打印出 CPU 正在执行的每一条汇编指令，实现类似 GDB 或 x64dbg 的 **Trace** 功能。

### 1. 标准工作流 (Workflow)

要在 Hook 中高效使用 Capstone，必须遵循以下步骤：

1. **全局初始化**：在调用 `emu_start` 之前，先初始化好 `Cs` 实例。

- **性能警报**：**千万不要在 Hook 回调函数内部实例化** **`Cs`** **！**  重复创建对象会大大地拖慢模拟速度。
2. **Hook 注入**：编写 `hook_code` 回调函数。
3. **读取指令**：在 Hook 中，利用 `address` 和 `size` 参数，通过 `uc.mem_read` 从内存中取出当前指令的机器码。
4. **反汇编**：将取出的机器码喂给 `cs.disasm`。
5. **输出日志**：格式化打印指令的地址、助记符和操作数。

### 2. 完整代码演示

下面的脚本模拟了一段 x64 汇编代码，该代码通过 Linux 系统调用 (`syscall`) 打印 "Hello Unicorn"。我们将通过 Capstone 实时监控这一过程。

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

# ==========================================
# 1. 准备代码 (x64 Linux Syscall: write)
# ==========================================
# 汇编逻辑：
#   mov rdi, 1          ; fd = stdout
#   lea rsi, [msg]      ; buf = "Hello Unicorn"
#   mov rdx, 13         ; count = 13
#   mov rax, 1          ; syscall_write
#   syscall
#   ... (msg string) ...
CODE = b"\x48\xc7\xc7\x01\x00\x00\x00\x48\x8d\x35\x10\x00\x00\x00\x48\xc7\xc2\x0d\x00\x00\x00\x48\xc7\xc0\x01\x00\x00\x00\x0f\x05"
DATA = b"Hello Unicorn" # 放在代码后面

# 内存布局
ADDRESS = 0x400000
MEM_SIZE = 2 * 1024 * 1024

# ==========================================
# 2. 初始化引擎 (Unicorn + Capstone)
# ==========================================
# 初始化 Unicorn (大脑)
uc = Uc(UC_ARCH_X86, UC_MODE_64)

# 初始化 Capstone (眼睛)
# 注意：架构必须与 Unicorn 保持一致！
cs = Cs(CS_ARCH_X86, CS_MODE_64)

# ==========================================
# 3. 编写 Hook 回调 (Trace Logger)
# ==========================================
def hook_code(uc, address, size, user_data):
    """
    指令级 Hook，每条指令执行前触发
    """
    # 3.1 从内存读取当前指令的机器码
    # size 参数由 Unicorn 提供，表示当前指令长度
    try:
        code = uc.mem_read(address, size)
    except:
        return # 读取失败忽略

# 3.2 使用 Capstone 反汇编
    # disasm 返回一个生成器，这里每次只反汇编一条指令
    for insn in cs.disasm(code, address):
        # 3.3 打印 Trace 日志
        # 格式：地址  助记符  操作数
        print(f"0x{insn.address:x}:\t{insn.mnemonic}\t{insn.op_str}")
        print("Machine code: ", end="")
        for i in range(len(insn.bytes)):
            print(f"{insn.bytes[i]:02x} ", end="")
        print()

if insn.mnemonic == "syscall":
            print(">>> Syscall: write")
            print("-" * 20)
            return

# ==========================================
# 4. 环境设置与启动
# ==========================================
# 映射内存
uc.mem_map(ADDRESS, MEM_SIZE)

# 写入代码和数据
uc.mem_write(ADDRESS, CODE)
uc.mem_write(ADDRESS + len(CODE), DATA)

# 注册 Hook
uc.hook_add(UC_HOOK_CODE, hook_code)

print(">>> Start Tracing...")
print("-" * 20)

# 开始模拟
# 注意：syscall 可能会抛出异常，这里仅演示反汇编，忽略 syscall 错误
try:
    uc.emu_start(ADDRESS, ADDRESS + len(CODE))
except UcError as e:
    print("-" * 20)
    print(f">>> Emulation stopped: {e}")
```

### 3. 运行效果

运行上述脚本，你将看到如下输出。每一条指令在被 CPU 执行前，都被 Capstone 捕获并翻译了出来：

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

通过这种方式，我们成功构建了一个可视化的执行流监视器！

---

## 五、进阶功能：Detail Mode

在基础用法中，我们只能拿到指令的字符串（如 `"mov rax, 1"`）。虽然我们可以用 `if "mov" in mnemonic` 来做判断，但这种字符串匹配是非常脆弱且不严谨的。

Capstone 提供了强大的 **Detail Mode（详细模式）** ，开启后，它会帮我们把指令“解剖”成结构化的数据，让我们能理解指令的**语义**。

### 1. 开启详细模式

默认情况下，为了性能，Capstone 不会分析指令细节。我们需要手动开启：

```python
md = Cs(CS_ARCH_X86, CS_MODE_64)
# 开启上帝视角
md.detail = True
```

### 2. 语义分析的三大神器

开启详细模式后，`CsInsn` 对象会多出几个关键属性：

#### A. 隐式读写 (Implicit R/W)

很多指令在表面上看不出它修改了谁。例如 `push rax`，它不仅读取了 `rax`，还隐式修改了 `rsp`（栈指针）。

- `insn.regs_read`: 指令隐式读取的寄存器列表。
- `insn.regs_write`: 指令隐式写入的寄存器列表。

#### B. 指令分组 (Groups)

在逆向分析中，我们往往不需要关心具体的指令是 `JE` 还是 `JNE`，是 `CALL` 还是 `SYSCALL`，而只需要知道它们的**行为类别**。Capstone 的 `Groups` 机制提供了一种与架构无关的通用分类方法。

- **常用组常量**：  
  这些常量定义在 `capstone` 模块中。

- **`CS_GRP_JUMP`**: 所有的分支跳转指令。不仅包括无条件跳转 `JMP`，也包括条件跳转 `JE`, `JNZ`, `LOOP` 等。
  - **`CS_GRP_CALL`**: 函数调用指令 (`CALL`)。
  - **`CS_GRP_RET`**: 函数返回指令 (`RET`, `RETN`)。
  - **`CS_GRP_INT`**: 中断指令 (`INT`, `SYSCALL`, `SYSENTER`)。
  - **`CS_GRP_IRET`**: 中断返回指令。
- **实战用法**：

```python
  # 假设 insn 是当前反汇编得到的指令对象
  if insn.group(CS_GRP_JUMP):
      print(f"Detected a jump at 0x{insn.address:x}")
      
  elif insn.group(CS_GRP_CALL):
      print(f"Detected a function call at 0x{insn.address:x}")
      
  elif insn.group(CS_GRP_RET):
      print("End of function detected")
  ```

#### C. 操作数分析 (Operands)

这是详细模式中最强大的功能。通过遍历 `insn.operands` 列表，我们可以精准地提取每一个操作数的类型和值。

对于 x86 架构，操作数主要分为三类。我们需要引入 `capstone.x86` 模块来使用相关常量。

##### 1. 寄存器 (X86\_OP\_REG)

- **结构**：操作数包含一个 `reg` 属性，存储寄存器的 ID。
- **示例**：`inc rax` 中的 `rax`。
- **代码**：

```python
  if op.type == X86_OP_REG:
      print(f"Register: {insn.reg_name(op.reg)}")
  ```

##### 2. 立即数 (X86\_OP\_IMM)

- **结构**：操作数包含一个 `imm` 属性，存储具体的数值。
- **示例**：`mov rax, 0x100` 中的 `0x100`。
- **代码**：

```python
  if op.type == X86_OP_IMM:
      print(f"Immediate: 0x{op.imm:x}")
  ```

##### 3. 内存引用 (X86\_OP\_MEM)

这是 x86 汇编中最灵活、也最复杂的操作数类型。一条典型的内存访问指令（如 `LEA` 或 `MOV`）可能包含极其复杂的寻址模式。

**典型格式**：`[Base + Index * Scale + Displacement]`  
例如：`mov eax, [rbp + rbx*4 - 0x10]`

Capstone 将这种结构解析为一个 `op.mem` 对象，包含以下四个核心字段：

|字段|类型|说明|示例 (`[rbp+rbx*4-0x10]`)|
| ------| --------------| -----------------------------------| -----------|
|**`base`**|int (Reg ID)|**基址寄存器**。若无基址，值为 0 (`X86_REG_INVALID`)。|`rbp`|
|**`index`**|int (Reg ID)|**变址寄存器**。若无变址，值为 0。|`rbx`|
|**`scale`**|int|**比例因子**。通常为 1, 2, 4, 8。默认 1。|`4`|
|**`disp`**|int|**偏移量**(Displacement)。正负整数。|`-0x10`|

**关键 API 解析**

- **`insn.reg_name(reg_id)`**

- **作用**：将寄存器的数字 ID（如 `43`）转换为人类可读的字符串（如 `"rbx"`）。
  - **注意**：`op.mem.base` 存储的是整数 ID，直接打印没有任何意义。必须调用此方法进行转换。
  - **空值处理**：如果寄存器 ID 为 0（即无此寄存器），该方法通常返回 `None` 或抛出异常，因此在调用前最好判断 `reg_id != 0`。

**深度解析示例**

```python
from capstone import *
from capstone.x86 import *

# 机器码: mov eax, dword ptr [rbp + rbx*4 - 0x10]
CODE = b"\x8b\x44\x9d\xf0"

md = Cs(CS_ARCH_X86, CS_MODE_64)
md.detail = True  # 必须开启详细模式

for insn in md.disasm(CODE, 0x1000):
    print(f"Instruction: {insn.mnemonic} {insn.op_str}")
    
    for i, op in enumerate(insn.operands):
        if op.type == X86_OP_MEM:
            print(f"--- Operand {i} is MEMORY ---")
            mem = op.mem  # 获取内存结构体
            
            # 1. 解析基址 (Base)
            if mem.base != 0:
                print(f"    Base : {insn.reg_name(mem.base)}")
            else:
                print(f"    Base : None")
                
            # 2. 解析变址 (Index)
            if mem.index != 0:
                print(f"    Index: {insn.reg_name(mem.index)}")
                print(f"    Scale: {mem.scale}")
            
            # 3. 解析偏移 (Displacement)
            # 注意：disp 是有符号整数，可能为负
            if mem.disp != 0:
                print(f"    Disp : {mem.disp:#x}")
```

**运行输出**：

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

---

### 3. 实战示例：

下面的脚本演示了如何利用详细模式，精准捕捉所有**显式或隐式**写入了 `RAX` 寄存器的指令。

```python
from capstone import *
from capstone.x86 import *  # 导入 x86 专用常量

CODE = b"\x48\xc7\xc0\x01\x00\x00\x00\x90\x48\x31\xc0\x50\x58"
# 汇编内容:
# mov rax, 1    (显式写入 RAX)
# nop           (无)
# xor rax, rax  (显式写入 RAX)
# push rax      (读取 RAX, 修改 RSP)
# pop rax       (显式写入 RAX, 修改 RSP)

md = Cs(CS_ARCH_X86, CS_MODE_64)
md.detail = True  # 关键步骤！

print("Searching for instructions that WRITE to RAX...")
print("-" * 40)

for insn in md.disasm(CODE, 0x1000):
    is_modified = False

# 1. 检查隐式写入 (Implicit Write)
    # regs_write 返回的是寄存器 ID 列表
    if X86_REG_RAX in insn.regs_write:
        is_modified = True

for op in insn.operands:
        if op.type == X86_OP_REG and op.reg == X86_REG_RAX:
            # 2. 检查显式写入 (Explicit Write)
            # op.access 返回的是访问类型，包含 CS_AC_READ、CS_AC_WRITE 等
            if op.access & CS_AC_WRITE:
                is_modified = True

if is_modified:
        print(f"[FOUND] 0x{insn.address:x}: {insn.mnemonic} {insn.op_str}")
    else:
        print(f"[PASS ] 0x{insn.address:x}: {insn.mnemonic} {insn.op_str}")
```

**运行结果**：

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

> push rax 读取了 rax 但没进行写入，所以结果是 PASS

---

## 六、场景化应用

将 Capstone 与 Unicorn 结合，我们可以解决逆向工程中许多棘手的难题。以下是三个最经典的应用场景。

### 场景 1：通用 Call 跳过器 (Generic Call Skipper)

**痛点**：在模拟执行大体积二进制文件时，程序往往会调用大量的外部库函数（如 `printf`, `memcpy`）。如果我们不想去模拟这些函数的具体逻辑，也不想程序因为跳到非法地址而 Crash，最好的办法就是统统跳过。

**解决方案**：  
在 Hook 中实时检测当前指令。如果是 `CALL` 类型指令，直接修改 RIP 指针到下一条指令，从而实现“视而不见”。

```python
def hook_skip_calls(uc, address, size, user_data):
    # 读取指令
    code = uc.mem_read(address, size)
    
    # 反汇编 (注意：这里假设 cs 已在外部初始化并开启 detail)
    for insn in cs.disasm(code, address):
        
        # 判断是否为 CALL 指令组
        if insn.group(CS_GRP_CALL):
            print(f"[Skipper] Skipping call at 0x{address:x}: {insn.mnemonic} {insn.op_str}")
            
            # 1. 计算下一条指令地址
            next_rip = address + size
            
            # 2. 修改 RIP，强行跳过当前指令
            uc.reg_write(UC_X86_REG_RIP, next_rip)
            
            # 3. (可选) 伪造返回值 RAX = 0，防止逻辑错误
            uc.reg_write(UC_X86_REG_RAX, 0)
            
            # 4. 模拟平栈 (对于 x86 cdecl 等需要平栈的约定，可能需要额外处理)
            # x64 下通常不需要，因为参数是通过寄存器传递的
```

---

### 场景 2：基本块追踪 (Block Tracer)

**痛点**：在分析混淆代码（如 OLLVM）或去除非法路径时，我们需要知道程序到底走了哪些分支。

**解决方案**：  
基本块（Basic Block）通常以跳转指令结束。通过监控 `CS_GRP_JUMP`（跳转）和 `CS_GRP_RET`（返回）指令，我们可以精准捕捉程序的每一次“变道”，从而绘制出真实的执行流图（CFG）。

```python
# 记录执行过的基本块起始地址
visited_blocks = set()

def hook_trace_block(uc, address, size, user_data):
    code = uc.mem_read(address, size)
    
    for insn in cs.disasm(code, address):
        # 如果是分支指令 (JMP, JE, CALL, RET...)
        if insn.group(CS_GRP_JUMP) or insn.group(CS_GRP_RET):
            
            # 获取跳转目标 (这里简化处理，假设是直接跳转)
            # 实际场景需分析操作数是立即数还是寄存器
            target = "???"
            if len(insn.operands) > 0 and insn.operands[0].type == X86_OP_IMM:
                target = hex(insn.operands[0].imm)
                
            print(f"[Trace] Block Edge: 0x{address:x} ({insn.mnemonic}) -> {target}")
```

---

### 场景 3：敏感指令监控 (Malware Analysis)

**痛点**：恶意软件往往会通过 `RDTSC` 检测调试器，通过 `CPUID` 检测虚拟机，或者通过 `SYSCALL` 进行文件操作。

**解决方案**：  
利用 Capstone 的助记符匹配或指令分组，建立一个“敏感指令黑名单”。一旦模拟执行到这些指令，立即报警或暂停。

```python
def hook_monitor_malware(uc, address, size, user_data):
    code = uc.mem_read(address, size)
    
    for insn in cs.disasm(code, address):
        
        # 1. 检测时间戳读取 (常用于反调试)
        if insn.mnemonic == "rdtsc":
            print(f"[Alert] RDTSC detected at 0x{address:x}. Possible anti-debug.")
            
        # 2. 检测 CPU 信息读取 (常用于反虚拟机)
        elif insn.mnemonic == "cpuid":
            print(f"[Alert] CPUID detected at 0x{address:x}. Possible anti-vm.")
            
        # 3. 检测系统调用 (文件/网络操作)
        elif insn.group(CS_GRP_INT):
            print(f"[Alert] SYSCALL/INT detected at 0x{address:x}.")
```

---

## 七、性能优化与避坑

Capstone 虽然强大，但如果使用不当，很容易成为整个模拟器的性能瓶颈。以下是几个关键的优化技巧和避坑建议。

### 1. 切勿在 Hook 中实例化

这是最容易犯的致命错误。

- **错误写法**：

```python
  def hook_code(uc, address, size, user_data):
      # 每次回调都创建新对象，极大浪费内存和CPU
      md = Cs(CS_ARCH_X86, CS_MODE_64) 
      md.disasm(...)
  ```
- **后果**：Unicorn 每秒可能执行数万条指令。如果在 Hook 中实例化 `Cs`，模拟速度将下降 100 倍以上。
- **正确做法**：在 `emu_start` 之前全局初始化 `Cs` 实例，并在 Hook 中重复使用。

### 2. 轻量级反汇编：`disasm_lite`

在大多数场景下（例如仅打印指令 Trace），我们并不需要分析操作数类型（寄存器还是内存）或指令分组。我们只需要知道“这是一条 `MOV` 指令”就够了。

此时可以使用 **`disasm_lite`**。

#### 核心区别

- **`disasm`**  **(标准模式)** ：

- 为每条指令创建一个完整的 `CsInsn` 类实例。
  - 包含所有属性（bytes, id, groups, operands 等）。
  - **开销大**，适合深度分析。
- **`disasm_lite`**  **(轻量模式)** ：

- 仅返回一个简单的 Python 元组 (Tuple)。
  - 仅包含 4 个基础字段：`(address, size, mnemonic, op_str)`。
  - **速度快**（通常快 20%\~30%），适合高频调用。

#### 实战代码：性能对比

```python
from capstone import *
import time

CODE = b"\x90" * 1000000  # 100万条 NOP 指令
md = Cs(CS_ARCH_X86, CS_MODE_64)

# --- 方式 A: 标准反汇编 ---
start = time.time()
count = 0
for insn in md.disasm(CODE, 0x1000):
    # 这里 insn 是一个对象，访问属性需要开销
    _ = insn.mnemonic 
    count += 1
print(f"[Standard] Processed {count} insns in {time.time() - start:.4f}s")

# --- 方式 B: 轻量级反汇编 ---
start = time.time()
count = 0
# 直接解包元组，无需对象创建开销
for (address, size, mnemonic, op_str) in md.disasm_lite(CODE, 0x1000):
    _ = mnemonic
    count += 1
print(f"[Lite    ] Processed {count} insns in {time.time() - start:.4f}s")
```

**输出**：

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

> 在 Unicorn 的 Hook 回调中，如果你的目的仅仅是打印 `0x4000: mov rax, 1` 这样的日志，**首选** **`disasm_lite`**。只有当你需要判断 `insn.group(CS_GRP_CALL)` 或分析操作数时，才使用标准模式。

---

## 八、总结

通过学习了解，我们得知：

- **Unicorn** 提供了强大的执行能力。
- **Capstone** 提供了详尽的语义分析能力。

两者的结合，让我们不仅能“跑”代码，更能“看懂”代码，进而实现从自动化追踪到恶意代码分析的各种高级功能。接下来的文章，将引入 **Keystone**（汇编框架/引擎），实现动态代码修改。

---

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

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

最后于 2025-12-23 22:32 被xiusi编辑，原因：

#逆向分析 #HOOK注入 #工具脚本 #其他

最新回复 (41) 1 2 ▶
lllluffyx 雪币： 5 能力值： ( LV1，RANK：0 ) 在线值：发帖 1 回帖 3 粉丝 2 关注私信	lllluffyx 2 楼 666，good ideas 2025-12-23 22:19 1
mb_ldbucrik 雪币： 6 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 707 粉丝 7 关注私信	mb_ldbucrik 3 楼感谢分享 2025-12-23 22:34 0
ak58 雪币： 8 活跃值： (1329) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 25 粉丝 0 关注私信	ak58 4 楼谢谢大佬分享，很细致的教程。 2025-12-24 03:37 0
haogl 雪币： 4593 活跃值： (5876) 能力值： ( LV3，RANK：30 ) 在线值：发帖 7 回帖 87 粉丝 16 关注私信	haogl 5 楼回复来看看，先谢过楼主！ 2025-12-24 08:02 0
mb_asiwnxyv 雪币： 6 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 100 粉丝 0 关注私信	mb_asiwnxyv 6 楼感谢分享 2025-12-24 10:14 0
tigericon 雪币： 90 活跃值： (930) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 53 粉丝 0 关注私信	tigericon 7 楼感谢分享 2025-12-24 11:48 0
Imxz 雪币： 110 活跃值： (9571) 能力值： ( LV2，RANK：10 ) 在线值：发帖 6 回帖 775 粉丝 9 关注私信	Imxz 8 楼 tql 2025-12-24 16:58 0
memoriaru 雪币： 14 活跃值： (664) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 25 粉丝 0 关注私信	memoriaru 9 楼感谢分享 2025-12-25 11:38 0
PayPoc 雪币： 1922 活跃值： (2598) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 4 粉丝 1 关注私信	PayPoc 10 楼学习 2025-12-25 13:54 0
zylyy 雪币： 144 活跃值： (2738) 能力值： ( LV2，RANK：10 ) 在线值：发帖 11 回帖 491 粉丝 3 关注私信	zylyy 11 楼 666 2025-12-25 14:03 0
fangliangz 雪币： 5717 活跃值： (4104) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 112 粉丝 1 关注私信	fangliangz 12 楼 666 2025-12-26 10:26 0
mb_lizfxfno 雪币： 518 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 24 粉丝 0 关注私信	mb_lizfxfno 13 楼 6 2025-12-26 10:27 0
LQ6H 雪币： 530 活跃值： (2627) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 80 粉丝 1 关注私信	LQ6H 14 楼 666 2025-12-26 15:38 0
uni7corn 雪币： 0 活跃值： (2485) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 182 粉丝 0 关注私信	uni7corn 15 楼感谢分享 2025-12-29 10:10 0
Snark 雪币： 4072 活跃值： (5140) 能力值： ( LV5，RANK：70 ) 在线值：发帖 8 回帖 139 粉丝 87 关注私信	Snark 1 16 楼 1 2025-12-29 10:15 0
神奇的人鱼雪币： 34 活跃值： (726) 能力值： ( LV2，RANK：15 ) 在线值：发帖 1 回帖 29 粉丝 2 关注私信	神奇的人鱼 17 楼感谢分享 2025-12-30 13:38 0
mb_dcjxxhsk 雪币： 200 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 79 粉丝 0 关注私信	mb_dcjxxhsk 18 楼 6666 2025-12-30 16:07 0
tjytjy 雪币： 115 活跃值： (1943) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 102 粉丝 0 关注私信	tjytjy 19 楼 666 2025-12-30 19:53 0
mb_uvyukvot 雪币： 209 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 144 粉丝 1 关注私信	mb_uvyukvot 20 楼 666 2025-12-31 18:03 0
l1s00t 雪币： 424 活跃值： (2227) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 30 粉丝 1 关注私信	l1s00t 21 楼感谢分享！ 2026-1-10 18:21 0
Snowman_Liam 雪币： 2 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 142 粉丝 1 关注私信	Snowman_Liam 22 楼 666 2026-1-21 06:17 0
a7dd 雪币： 634 活跃值： (1561) 能力值： ( LV2，RANK：15 ) 在线值：发帖 0 回帖 5 粉丝 0 关注私信	a7dd 23 楼 tql 2026-1-21 09:49 0
mb_qqihqaoo 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 58 粉丝 0 关注私信	mb_qqihqaoo 24 楼 66666666666 2026-1-22 13:01 0
mb_gcjwsflo 雪币： 4 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 14 粉丝 0 关注私信	mb_gcjwsflo 25 楼 666 2026-1-23 15:20 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复