逆向分析实战

← 返回指南列表

逆向分析实战

逆向工程(Reverse Engineering) 是从程序的最终形态(二进制代码、字节码、机器码)出发,通过反汇编、反编译、动态调试、行为观察等手段,逐步还原其原始设计逻辑、算法实现、数据结构和运行流程的过程。逆向分析广泛应用于恶意软件分析、漏洞挖掘、协议还原、软件兼容性与安全审计等领域。


一、逆向分析概述

1.1 什么是逆向分析?

逆向分析是一门”从结果推导过程”的技术科学。在软件开发中,正向工程是从需求出发,经过设计、编码、编译,最终生成可执行程序。逆向分析则完全相反——你手中只有编译好的二进制文件,需要还原出它的源代码逻辑。

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

1.2 逆向分析的分类

分类维度 类型 说明
分析方式 静态分析 不执行程序,通过反汇编/反编译阅读代码
分析方式 动态分析 运行程序,通过调试器观察运行时行为
分析对象 二进制逆向 对编译后的机器码进行反汇编分析
分析对象 字节码逆向 对Java .class、Python .pyc等中间代码分析
分析目标 恶意软件分析 分析病毒/木马/勒索软件的行为与特征
分析目标 漏洞挖掘 通过逆向发现软件中的安全漏洞
分析目标 协议分析 还原私有通信协议的格式与逻辑
分析目标 竞品分析 合法范围内的技术研究

1.3 逆向分析的法律边界

逆向分析本身是技术中立的行为,但其合法性取决于目的和地域法律:

  • 合法场景:安全研究、恶意软件分析、兼容性开发(DMCA豁免条款)、学术研究、CTF竞赛
  • 灰色地带:竞品分析中的代码复用
  • 非法场景:破解商业软件、绕过DRM保护、窃取知识产权
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

二、CPU架构与汇编基础

2.1 主流CPU架构对比

逆向分析需要深入理解目标程序的CPU架构。不同架构的指令集、寄存器、调用约定各不相同。

特性 x86/x86-64 (CISC) ARM (RISC) MIPS (RISC) RISC-V (RISC)
指令长度 变长 (1-15字节) 定长 (32位/16位Thumb) 定长 (32位) 变长 (16/32/48/64位)
通用寄存器数 x86:8, x64:16 31 (x0-x30) 32 ($0-$31) 32 (x0-x31)
寻址方式 复杂多样 加载/存储架构 加载/存储架构 加载/存储架构
主要应用 PC/服务器 移动设备/IoT/Apple Silicon 路由器/嵌入式 新兴/IoT/学术
字节序 小端 双端 (通常小端) 双端 小端

2.2 x86/x86-64 汇编核心知识

2.2.1 寄存器体系

x86 (32位) 通用寄存器:

CODE
EAX (累加器)   - 算术运算、函数返回值
EBX (基址)     - 基址指针
ECX (计数器)   - 循环计数、字符串操作
EDX (数据)     - I/O操作、扩展累加
ESI (源变址)   - 字符串/内存操作源指针
EDI (目的变址) - 字符串/内存操作目的指针
EBP (基指针)   - 栈帧基址
ESP (栈指针)   - 栈顶指针
EIP (指令指针) - 下一条指令地址

**x86-64 扩展寄存器 (R8-R15)**:

CODE
RAX, RBX, RCX, RDX, RSI, RDI, RBP, RSP  (64位扩展)
R8, R9, R10, R11, R12, R13, R14, R15    (新增8个通用寄存器)
RIP (64位指令指针)

**标志寄存器 (EFLAGS/RFLAGS)**:

标志位 含义 说明
ZF (Zero Flag) 零标志 运算结果为0时置1
SF (Sign Flag) 符号标志 结果为负数时置1
CF (Carry Flag) 进位标志 无符号运算进位/借位
OF (Overflow Flag) 溢出标志 有符号运算溢出
PF (Parity Flag) 奇偶标志 低8位中1的个数为偶数
AF (Auxiliary Flag) 辅助进位 BCD运算使用

2.2.2 关键指令详解

数据传送指令:

ASSEMBLY
; MOV - 数据传送
mov eax, 0x1234          ; 立即数 -> 寄存器
mov eax, [ebp-4]         ; 内存 -> 寄存器
mov [esi], ebx           ; 寄存器 -> 内存
mov eax, dword ptr [edx] ; 指定操作数大小

; PUSH/POP - 栈操作
push ebp                 ; ESP-=4, [ESP]=EBP
pop ebp                  ; EBP=[ESP], ESP+=4
pushad / popad           ; 保存/恢复所有通用寄存器

; LEA - 加载有效地址 (不访问内存)
lea eax, [ebp-0x10]      ; 计算地址但不解引用

; XCHG - 交换
xchg eax, ebx            ; 交换两个操作数

; MOVSX/MOVZX - 符号/零扩展
movsx eax, bl            ; 符号扩展字节到双字
movzx eax, bl            ; 零扩展字节到双字

算术运算指令:

ASSEMBLY
; ADD/SUB - 加减
add eax, 0x10            ; eax = eax + 0x10
sub esp, 0x20            ; esp = esp - 0x20

; MUL/IMUL - 乘法
mul ecx                  ; EDX:EAX = EAX * ECX (无符号)
imul eax, ecx, 0x5       ; eax = ecx * 5 (有符号)

; DIV/IDIV - 除法
div ecx                  ; EAX = EDX:EAX / ECX, EDX = 余数
idiv ecx                 ; 有符号除法

; INC/DEC - 自增/自减
inc eax                  ; eax++
dec ecx                  ; ecx--

; CDQ/CQO - 符号扩展用于除法
cdq                      ; EDX:EAX = EAX 符号扩展
cqo                      ; RDX:RAX = RAX 符号扩展

逻辑与位操作指令:

ASSEMBLY
; AND/OR/XOR/NOT
xor eax, eax             ; eax = 0 (最常见的清零方式)
and eax, 0xFF            ; 保留低8位
or  eax, 0x80            ; 设置最高位

; SHL/SHR/SAL/SAR - 移位
shl eax, 2               ; 左移2位 (相当于乘4)
shr eax, 1               ; 逻辑右移 (高位补0)
sar eax, 1               ; 算术右移 (高位补符号位)

; ROL/ROR - 循环移位
rol eax, 8               ; 循环左移8位
ror eax, 4               ; 循环右移4位

; TEST - 按位与测试 (不修改目标,只设置标志位)
test eax, eax            ; 常用于判断eax是否为0
test al, 0x80            ; 测试最高位

控制流指令:

ASSEMBLY
; 无条件跳转
jmp 0x401000             ; 直接跳转
jmp eax                  ; 间接跳转 (常用于switch/case)

; 条件跳转
je  / jz   label         ; ZF=1 时跳转 (相等/为零)
jne / jnz  label         ; ZF=0 时跳转 (不等/非零)
jg  / jnle label         ; 有符号大于
jl  / jnge label         ; 有符号小于
ja  / jnbe label         ; 无符号大于
jb  / jnae label         ; 无符号小于

; 函数调用
call 0x401000            ; PUSH 返回地址, JMP 目标
ret                      ; POP EIP (返回)
ret 0x8                  ; 返回并清理栈 (stdcall)

; 循环
loop label               ; ECX--, ECX!=0 则跳转
loope/loopz label        ; ECX--, ECX!=0 且 ZF=1 则跳转

; 中断与系统调用
int 0x80                 ; Linux 32位系统调用
syscall                  ; Linux 64位系统调用
sysenter                 ; Windows 快速系统调用

2.2.3 调用约定 (Calling Convention)

调用约定定义了函数参数传递方式、栈清理责任和返回值传递方式。

约定 适用平台 参数传递 栈清理 返回值 特点
cdecl x86 C/C++ 从右向左入栈 调用者 EAX C默认,支持可变参数
stdcall x86 Win32 API 从右向左入栈 被调用者 EAX Win32 API标准
fastcall x86 优化 ECX,EDX,栈 被调用者 EAX 前两个参数用寄存器
thiscall x86 C++成员 ECX(this),栈 被调用者 EAX this指针用ECX
System V AMD64 x86-64 Linux/macOS RDI,RSI,RDX,RCX,R8,R9,栈 调用者 RAX 6个寄存器传参
Microsoft x64 x86-64 Windows RCX,RDX,R8,R9,栈 调用者 RAX 4个寄存器传参

x86-64 Windows调用约定栈布局示例:

ASSEMBLY
; void func(int a, int b, int c, int d, int e, int f)
; RCX=a, RDX=b, R8=c, R9=d, [RSP+0x28]=e, [RSP+0x30]=f
; 调用者需要在栈上预留32字节(0x20)的shadow space

sub rsp, 0x48           ; 分配栈空间 (shadow+参数+对齐)
mov dword ptr [rsp+0x28], 5  ; 第5个参数
mov dword ptr [rsp+0x30], 6  ; 第6个参数
mov r9d, 4               ; 第4个参数
mov r8d, 3               ; 第3个参数
mov edx, 2               ; 第2个参数
mov ecx, 1               ; 第1个参数
call func
add rsp, 0x48           ; 清理栈

2.2.4 栈帧结构

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

2.3 ARM 汇编基础

2.3.1 ARM寄存器

CODE
X0-X7   : 参数寄存器 (AAPCS64)
X8      : 间接结果寄存器
X9-X15  : 临时寄存器 (调用者保存)
X16-X17 : 内部过程调用暂存寄存器
X18     : 平台寄存器
X19-X28 : 被调用者保存寄存器
X29     : 帧指针 (FP)
X30     : 链接寄存器 (LR, 返回地址)
XZR/WZR : 零寄存器 (读取为0, 写入丢弃)
SP      : 栈指针
PC      : 程序计数器

2.3.2 ARM指令示例

ASSEMBLY
; ARM64 关键指令
ldr x0, [x29, #-8]      ; 从栈加载到x0
str x0, [sp, #16]        ; 存储x0到栈
add x1, x2, x3           ; x1 = x2 + x3
sub sp, sp, #0x30        ; 分配栈空间
cmp w0, #0x5             ; 比较
b.eq label               ; 相等则跳转
bl _printf               ; 调用函数 (BL = Branch with Link)
ret                      ; 返回 (实际是 BR LR)
mov x0, x1               ; x0 = x1

; 条件执行 (ARM32特色)
addeq r0, r1, r2         ; 如果EQ则执行
movne r0, #0             ; 如果NE则执行

; 桶形移位器
add r0, r1, r2, lsl #2   ; r0 = r1 + (r2 << 2)

三、可执行文件格式

3.1 PE (Portable Executable) - Windows

PE格式是Windows操作系统的标准可执行文件格式,衍生于早期的COFF格式。

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

3.1.1 关键PE头结构

IMAGE_DOS_HEADER:

CODE
Offset  Size  Field
0x00    2     e_magic         "MZ" (0x5A4D)
0x3C    4     e_lfanew        PE签名偏移 (指向PE\0\0)

IMAGE_NT_HEADERS:

CODE
Signature: "PE\0\0" (0x00004550)

IMAGE_FILE_HEADER:
- Machine:          0x014C (x86), 0x8664 (x64), 0xAA64 (ARM64)
- NumberOfSections: 节区数量
- TimeDateStamp:    编译时间戳
- SizeOfOptionalHeader: Optional Header大小
- Characteristics:  文件属性 (EXE/DLL等)

IMAGE_OPTIONAL_HEADER:
- Magic:            0x10B (PE32), 0x20B (PE32+)
- AddressOfEntryPoint: 程序入口点RVA
- ImageBase:        默认加载基址
- SectionAlignment: 内存中节对齐
- FileAlignment:    文件中节对齐
- SizeOfImage:      内存中映像总大小
- SizeOfHeaders:    所有头+节表的总大小
- Subsystem:        子系统类型 (GUI/CUI/Native/Driver)
- DLLCharacteristics: DLL特性 (ASLR/DEP/NX)
- DataDirectory[16]: 数据目录表

3.1.2 数据目录表 (Data Directory)

索引 名称 说明 逆向关注点
0 Export Table 导出函数表 DLL提供的API
1 Import Table 导入函数表 依赖的DLL和API,行为分析关键
2 Resource Table 资源表 图标/字符串/配置/嵌入文件
5 Base Relocation Table 基址重定位表 ASLR相关
6 Debug Directory 调试信息 PDB路径/调试符号
9 TLS Directory 线程局部存储 TLS回调 (反调试常用)
12 Import Address Table 导入地址表(IAT) 运行时填充的实际API地址
14 CLR Header .NET头 .NET程序集信息

3.1.3 导入表 (Import Table) 深度解析

导入表是逆向分析中最关键的结构之一,它告诉分析者程序使用了哪些外部API。

C
// IMAGE_IMPORT_DESCRIPTOR 结构
typedef struct _IMAGE_IMPORT_DESCRIPTOR {
    DWORD OriginalFirstThunk;  // INT (导入名称表) RVA
    DWORD TimeDateStamp;       // 时间戳
    DWORD ForwarderChain;      // 转发链
    DWORD Name;                // DLL名称字符串 RVA
    DWORD FirstThunk;          // IAT (导入地址表) RVA
} IMAGE_IMPORT_DESCRIPTOR;
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

3.2 ELF (Executable and Linkable Format) - Linux/Unix

ELF是Linux、Android、BSD等Unix-like系统的标准可执行格式。

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

3.2.1 ELF Header 关键字段

C
typedef struct {
    unsigned char e_ident[16];  // 魔数: \x7fELF
    uint16_t e_type;            // 类型: ET_EXEC/ET_DYN/ET_REL
    uint16_t e_machine;         // 架构: EM_X86_64/EM_ARM/EM_AARCH64
    uint32_t e_version;         // 版本
    uint64_t e_entry;           // 入口点虚拟地址
    uint64_t e_phoff;           // Program Header偏移
    uint64_t e_shoff;           // Section Header偏移
    uint32_t e_flags;           // 处理器特定标志
    uint16_t e_ehsize;          // ELF Header大小
    uint16_t e_phentsize;       // Program Header条目大小
    uint16_t e_phnum;           // Program Header条目数
    uint16_t e_shentsize;       // Section Header条目大小
    uint16_t e_shnum;           // Section Header条目数
    uint16_t e_shstrndx;        // 节名称字符串表索引
} Elf64_Ehdr;

3.2.2 Program Header (Segment)

类型 含义 说明
PT_LOAD 可加载段 需要映射到内存的段
PT_DYNAMIC 动态链接信息 .dynamic节
PT_INTERP 解释器路径 /lib64/ld-linux-x86-64.so.2
PT_NOTE 注释信息 ABI标签/版本信息
PT_GNU_RELRO 只读重定位 Full RELRO保护
PT_GNU_STACK 栈执行权限 NX bit控制
PT_GNU_EH_FRAME 异常处理帧 .eh_frame_hdr

3.2.3 ELF关键节区

节名 说明 逆向关注点
.text 代码节 核心分析目标
.rodata 只读数据 字符串/常量
.data 已初始化读写数据 全局变量
.bss 未初始化数据 大小信息
.plt 过程链接表 动态调用跳板
.got / .got.plt 全局偏移表 API地址解析
.init /.fini 初始化/终止代码 入口/析构逻辑
.dynamic 动态链接信息 依赖库/重定位
.symtab 符号表 函数/变量名
.strtab 字符串表 符号名称
.dynsym 动态符号表 动态链接符号
.rel.dyn / .rel.plt 重定位表 重定位信息
.eh_frame 异常处理帧 CFI信息
.note 注释节 build-id/ABI信息

3.3 Mach-O - macOS / iOS

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

3.4 DEX (Dalvik Executable) - Android

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

四、主流逆向工具链

4.1 反汇编器 (Disassembler)

4.1.1 IDA Pro

IDA Pro (Interactive Disassembler) 是逆向分析领域的行业标准工具。

核心功能:

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

常用快捷键:

快捷键 功能 说明
Space 切换文本/图形视图 图形视图便于理解控制流
G 跳转到地址 快速导航
X 交叉引用 查看谁引用了当前位置
N 重命名 给函数/变量命名
Y 设置类型 修改变量/函数类型
; 注释 添加分析注释
P 创建函数 将代码区域定义为函数
U 取消定义 转换为未定义数据
C 转换为代码 将数据解释为代码
D 转换为数据 将代码解释为数据
A 转换为字符串 将数据解释为字符串
Shift+F12 字符串窗口 查看所有字符串
Ctrl+F12 函数窗口 查看所有函数

IDAPython 常用脚本:

PYTHON
# 遍历所有函数
import idaapi
for func_ea in Functions():
    func_name = get_func_name(func_ea)
    print(f"0x{func_ea:X}: {func_name}")

# 查找交叉引用
for xref in XrefsTo(0x401000):
    print(f"Referenced by: 0x{xref.frm:X} (type: {xref.type})")

# 修改注释
set_cmt(0x401000, "C2服务器地址解密函数", 0)

# 搜索字节模式
import ida_search
ea = ida_search.find_binary(0, 0xFFFFFFFF, "48 8B 05 ?? ?? ?? ??", 16, 1)
if ea != BADADDR:
    print(f"Pattern found at: 0x{ea:X}")

# 导出所有函数名到文件
with open("exports.txt", "w") as f:
    for func_ea in Functions():
        f.write(f"{get_func_name(func_ea)}\n")

4.1.2 Ghidra

Ghidra 是NSA开源的反汇编框架,提供了强大的反汇编和反编译能力,且完全免费。

核心特性:

  • 多架构支持 (x86, ARM, MIPS, PowerPC, SPARC等)
  • 内置反编译器 (生成类C伪代码)
  • 协作式逆向 (多用户共享项目)
  • 版本跟踪 (二进制对比分析)
  • 强大的脚本接口 (Java/Python)

**Ghidra脚本示例 (Python)**:

PYTHON
# 查找所有使用特定API的函数
from ghidra.program.model.symbol import RefType

api_name = "CreateProcessW"
api_addr = None

# 找到API地址
for sym in currentProgram.getSymbolTable().getExternalSymbols():
    if sym.getName() == api_name:
        api_addr = sym.getAddress()
        break

if api_addr:
    refs = getReferencesTo(api_addr)
    for ref in refs:
        func = getFunctionContaining(ref.getFromAddress())
        if func:
            print(f"Function '{func.getName()}' at {func.getEntryPoint()} calls {api_name}")

4.1.3 radare2 / rizin

radare2 是命令行导向的逆向框架,适合脚本化和自动化分析。

BASH
# 基本用法
r2 binary                           # 打开文件
> aaa                               # 自动分析
> afl                               # 列出所有函数
> pdf @main                         # 反汇编main函数
> pd 20 @0x401000                   # 反汇编20条指令
> iz                                # 列出字符串
> ii                                # 列出导入
> ie                                # 查看入口点
> pdc @main                         # 伪代码
> s 0x401000                        # 跳转到地址
> wx 9090 @0x401000                 # 写入NOP
> oo+                               # 以读写模式重新打开

# 使用rz-ghidra反编译器
r2 -e cmd.pdc=rz-ghidra binary
> pdg @main                         # Ghidra风格反编译

# Cutter (图形界面)
cutter binary                       # 启动图形化IDE

4.1.4 Binary Ninja

Binary Ninja 是现代化的逆向平台,以出色的反编译器和API设计著称。

核心优势:

  • 高质量的中间语言 (IL) 表示
  • 多种IL级别:LLIL (Low Level IL)、MLIL (Medium Level IL)、HLIL (High Level IL)
  • 强大的Python/C++ API
  • 协作分析功能

4.2 反编译器 (Decompiler)

反编译器 支持平台 适用架构 特点
Hex-Rays Decompiler IDA Pro x86/x64/ARM/ARM64/PPC 行业最成熟,伪代码可读性高
Ghidra Decompiler Ghidra 多架构 开源免费,质量接近商业产品
RetDec 独立/Web x86/ARM/MIPS/PowerPC 基于LLVM,在线服务
JEB Decompiler JEB Dalvik/Native/ARM 移动端逆向,支持ARM原生反编译
angr decompiler angr框架 x86/x64 基于符号执行的提升

4.3 动态调试器 (Debugger)

4.3.1 x64dbg (Windows)

ASSEMBLY
; x64dbg 常用命令
bp CreateFileW         ; 在API上设断点
bp 0x401000            ; 在地址上设断点
bc *                   ; 清除所有断点
bl                     ; 列出断点
hard bp 0x401000       ; 硬件断点
mem bp 0x404000,rw     ; 内存断点 (读写)
erun                   ; 跳过异常继续执行
dump ds:[eax]          ; 查看内存
alloc 0x1000           ; 分配内存

4.3.2 GDB (Linux/Unix)

BASH
# GDB 常用命令
gdb ./binary
(gdb) set disassembly-flavor intel          # Intel语法
(gdb) break *0x400100                        # 地址断点
(gdb) break main                             # 函数断点
(gdb) run arg1 arg2                          # 运行
(gdb) continue                               # 继续
(gdb) stepi                                  # 单步指令
(gdb) nexti                                  # 单步步过
(gdb) info registers                         # 查看寄存器
(gdb) x/10x $rsp                             # 查看栈
(gdb) x/s 0x400200                           # 查看字符串
(gdb) disassemble main                       # 反汇编
(gdb) set $eax = 0x1234                      # 修改寄存器
(gdb) set {int}0x601050 = 0x12345678         # 修改内存

# GDB扩展
(gdb) gef                                    # GDB Enhanced Features
(gdb) source ~/peda/peda.py                  # PEDA扩展
(gdb) source ~/pwndbg/gdbinit.py             # pwndbg扩展

4.3.3 LLDB (macOS/iOS)

BASH
# LLDB 常用命令
lldb ./binary
(lldb) b main                                # 断点
(lldb) r                                     # 运行
(lldb) register read                         # 读寄存器
(lldb) register write rax 0x1234             # 写寄存器
(lldb) memory read 0x100001000               # 读内存
(lldb) memory write 0x100001000 0x90909090   # 写内存
(lldb) dis -f                                # 反汇编当前函数
(lldb) image list                            # 查看加载模块
(lldb) thread backtrace                      # 调用栈

4.3.4 Frida (动态插桩)

Frida 是最强大的跨平台动态插桩框架,支持Windows/macOS/Linux/iOS/Android。

JAVASCRIPT
// Frida 基础 Hook 脚本
// hook_native.js - Hook原生函数

// 1. Hook 地址上的函数
Interceptor.attach(Module.findExportByName(null, "CreateFileW"), {
    onEnter: function(args) {
        // args[0] = lpFileName (LPCWSTR)
        console.log("CreateFileW called:");
        console.log("  FileName: " + args[0].readUtf16String());
        console.log("  dwDesiredAccess: " + args[1]);
        
        // 保存调用信息
        this.fileName = args[0].readUtf16String();
    },
    onLeave: function(retval) {
        console.log("  -> Handle: " + retval);
        if (this.fileName && this.fileName.includes("secret")) {
            console.log("  [!] Suspicious file access detected!");
        }
    }
});

// 2. Hook 地址上的任意函数
var targetAddr = Module.findBaseAddress("target.dll").add(0x1234);
Interceptor.attach(targetAddr, {
    onEnter: function(args) {
        console.log("Encryption function called");
        console.log("  arg0: " + args[0]);
        console.log("  arg1 (buf): " + hexdump(args[1], { length: 32 }));
    }
});

// 3. 替换函数实现
var originalFunc = new NativeFunction(
    Module.findExportByName(null, "MessageBoxW"),
    'int', ['pointer', 'pointer', 'pointer', 'int']
);

Interceptor.replace(Module.findExportByName(null, "MessageBoxW"), 
    new NativeCallback(function(hwnd, text, caption, type) {
        console.log("MessageBox blocked: " + text.readUtf16String());
        return 1; // IDOK
    }, 'int', ['pointer', 'pointer', 'pointer', 'int'])
);

// 4. Stalker - 指令级跟踪
Stalker.follow(Process.getCurrentThreadId(), {
    events: {
        call: true,
        ret: true
    },
    onReceive: function(events) {
        console.log("Stalker events: " + JSON.stringify(events));
    }
});

五、静态分析技术

5.1 字符串分析

字符串是最直接的信息来源。通过分析程序中的字符串可以快速了解程序功能。

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

字符串提取工具:

BASH
# Linux strings命令
strings -n 8 binary.exe                # 最小长度8的字符串
strings -e l binary.exe                # 小端16位编码 (UTF-16LE)
strings -t x binary.exe                # 显示字符串偏移

# 使用FLOSS提取混淆字符串
floss binary.exe                       # 提取静态+栈字符串
floss -n 6 binary.exe                  # 最小长度6
floss --no static_strings binary.exe   # 仅提取Tight/栈字符串

字符串搜索技巧:

CODE
高价值字符串模式:
- URL模式:     https?://[^\s]+
- IP模式:      \d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}
- Base64模式:  [A-Za-z0-9+/]{40,}={0,2}
- 注册表模式:  (HKLM|HKCU|HKCR|HKU)\\SOFTWARE\\.+
- 文件路径模式: [A-Z]:\\[^\\]+\\..{2,4}
- PE头模式:    MZ|This program cannot be run in DOS mode

5.2 导入导出表分析

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

5.3 控制流分析

5.3.1 函数识别

识别函数边界是反汇编的第一步。主流方法包括:

  • 符号信息:.symtab / PDB中的函数符号
  • 调用目标:CALL指令的目标地址
  • 函数序言/结语模式:
ASSEMBLY
; x86 典型函数序言
push ebp                 ; 保存旧帧指针
mov ebp, esp             ; 建立新栈帧
sub esp, 0x40            ; 分配局部变量空间

; x86 典型函数结语
mov esp, ebp             ; 恢复栈指针
pop ebp                  ; 恢复帧指针
ret                      ; 返回

; x86-64 典型函数序言
push rbp
mov rbp, rsp
sub rsp, 0x50

; 编译器优化后可能没有标准序言

5.3.2 控制流图 (CFG)

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

5.4 数据流分析

数据流分析跟踪数据在程序中的流动路径,理解变量间的关系。

Def-Use分析:

C
// 定义-使用链示例
int x = GetSecretValue();    // Def: x (line 1)
int y = x ^ 0x12345678;      // Use: x, Def: y (line 2)
int z = y + 0x41414141;      // Use: y, Def: z (line 3)
SendToServer(z);             // Use: z (line 4)

// Def-Use Chain:
// x: Def@1 -> Use@2
// y: Def@2 -> Use@3
// z: Def@3 -> Use@4

5.5 符号执行

符号执行是一种将程序输入表示为符号值而非具体值的分析技术。

PYTHON
# angr 符号执行示例
import angr
import claripy

# 加载二进制文件
proj = angr.Project('./crackme', auto_load_libs=False)

# 创建符号变量 (假设输入是8字节字符串)
input_len = 8
input_bytes = [claripy.BVS(f'input_{i}', 8) for i in range(input_len)]

# 创建初始状态
state = proj.factory.entry_state(
    stdin=angr.SimFile('/dev/stdin', claripy.Concat(*input_bytes))
)

# 创建模拟管理器
simgr = proj.factory.simulation_manager(state)

# 探索:寻找成功路径
simgr.explore(find=0x401200, avoid=0x401300)  # find=成功, avoid=失败

if simgr.found:
    found_state = simgr.found[0]
    # 求解正确的输入
    solution = found_state.solver.eval(claripy.Concat(*input_bytes), cast_to=bytes)
    print(f"Correct input: {solution}")

六、动态分析技术

6.1 断点技术

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

**软件断点 (int3)**:

架构 断点指令 大小 说明
x86/x86-64 INT3 (0xCC) 1字节 最常用,单字节不会破坏多字节指令对齐
ARM (32bit) BKPT 2/4字节 ARM调试监视点
ARM64 BRK 4字节 AArch64断点指令

INT3 实现细节:

CODE
设置断点过程:
1. 读取目标地址处的原始字节
2. 保存原始字节到断点表
3. 将目标地址首字节替换为0xCC

断点触发过程:
1. CPU执行到0xCC
2. 触发INT3异常 (中断向量3)
3. OS将异常分发给调试器
4. 调试器停在断点处
5. EIP指向int3指令的下一条指令

恢复执行过程:
1. 将0xCC替换回原始字节
2. 将EIP回退1 (指向原始指令起始)
3. 设置TF标志 (单步执行)
4. 执行原始指令
5. 触发单步异常
6. 重新写入0xCC
7. 继续执行

硬件断点:

CODE
x86 DR寄存器:
DR0 - 断点地址1
DR1 - 断点地址2
DR2 - 断点地址3
DR3 - 断点地址4
DR6 - 调试状态 (指示哪个断点触发)
DR7 - 调试控制 (启用/禁用, 条件配置)

DR7配置:
- L0-L3 (bit 0,2,4,6): 局部断点启用
- G0-G3 (bit 1,3,5,7): 全局断点启用
- RW0-RW3: 断点类型
  00 = 执行
  01 = 写入 (1字节)
  10 = I/O读写
  11 = 读写

硬件断点优点: 不被软件修改影响, 不修改代码
硬件断点缺点: 最多4个, 可被检测

6.2 API监控与行为分析

6.2.1 进程监控 (Windows)

BASH
# Sysinternals Process Monitor - 实时系统活动监控
procmon.exe /BackingFile C:\logs\procmon.pml    # 保存日志
procmon.exe /LoadConfig C:\filters.pmc           # 加载过滤规则

# 常见过滤规则
# Operation contains "WriteFile"
# Operation contains "RegSetValue"
# Path contains "Run"
# Process Name is "suspicious.exe"

# Analyze命令行
analyze.exe -file procmon.pml                    # 分析日志文件

6.2.2 沙箱分析

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

在线沙箱服务:

服务 功能 特点
Any.Run 交互式沙箱 实时桌面交互,支持手动操作
Joe Sandbox 全自动分析 深度行为分析,YARA规则匹配
VirusTotal 多引擎扫描 快速检测,社区信息丰富
Hybrid Analysis Falcon沙箱 免费API,VxStream
Triage 恶意软件分析 配置提取,行为评分
CAPE Sandbox 开源沙箱 可自建,支持Payload提取

6.2.3 API钩子监控

PYTHON
# Frida API监控脚本
import frida
import sys

script_code = """
// 监控常见恶意API
var apis = [
    'CreateFileW', 'WriteFile', 'ReadFile',
    'RegOpenKeyExW', 'RegSetValueExW',
    'VirtualAlloc', 'VirtualProtect', 'CreateThread',
    'OpenProcess', 'WriteProcessMemory',
    'socket', 'connect', 'send', 'recv',
    'WinHttpOpen', 'WinHttpConnect', 'WinHttpOpenRequest'
];

apis.forEach(function(api) {
    var addr = Module.findExportByName(null, api);
    if (addr) {
        Interceptor.attach(addr, {
            onEnter: function(args) {
                console.log('[+] ' + api + ' called');
                console.log('    Return address: ' + this.returnAddress);
            }
        });
    }
});
"""

session = frida.attach("target.exe")
script = session.create_script(script_code)
script.load()
sys.stdin.read()

6.3 动态跟踪技术

PYTHON
# Frida Stalker - 指令级跟踪
import frida
import sys

code = """
var threadIds = [];

Process.enumerateThreads().forEach(function(thread) {
    Stalker.follow(thread.id, {
        events: {
            call: true,
            ret: true,
            exec: true
        },
        transform: function(iterator) {
            var instruction = iterator.next();
            do {
                if (instruction.mnemonic === 'call') {
                    // 在函数调用前插入日志
                    iterator.putCallout(function(context) {
                        console.log('call from: ' + context.pc);
                    });
                }
                iterator.keep();
            } while ((instruction = iterator.next()) !== null);
        },
        onReceive: function(events) {
            console.log('Events: ' + JSON.stringify(events));
        }
    });
    threadIds.push(thread.id);
});

setTimeout(function() {
    threadIds.forEach(function(id) {
        Stalker.unfollow(id);
    });
}, 5000);
"""

session = frida.attach("target")
script = session.create_script(code)
script.load()

七、PE文件深度分析

7.1 PE加载过程

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

7.2 重定位表 (Base Relocation)

当PE文件无法加载到其默认的ImageBase时,需要通过重定位表修正所有绝对地址引用。

C
// IMAGE_BASE_RELOCATION 结构
typedef struct {
    DWORD VirtualAddress;    // 页起始RVA (4KB对齐)
    DWORD SizeOfBlock;       // 块大小 (含头)
    // WORD TypeOffset[];    // 重定位项数组
} IMAGE_BASE_RELOCATION;

// TypeOffset (2字节)
// 高4位: 类型 (3=IMAGE_REL_BASED_HIGHLOW, 10=IMAGE_REL_BASED_DIR64)
// 低12位: 页内偏移
PYTHON
# 手动应用重定位的Python脚本
import struct

def apply_relocations(data, image_base, new_base, reloc_rva, reloc_size):
    delta = new_base - image_base
    offset = reloc_rva
    
    while offset < reloc_rva + reloc_size:
        block_va, block_size = struct.unpack_from('<II', data, offset)
        count = (block_size - 8) // 2
        
        for i in range(count):
            entry = struct.unpack_from('<H', data, offset + 8 + i * 2)[0]
            entry_type = entry >> 12
            entry_offset = entry & 0xFFF
            
            if entry_type == 0:  # IMAGE_REL_BASED_ABSOLUTE
                continue
            
            patch_addr = block_va + entry_offset
            
            if entry_type == 3:  # IMAGE_REL_BASED_HIGHLOW (x86)
                old_val = struct.unpack_from('<I', data, patch_addr)[0]
                struct.pack_into('<I', data, patch_addr, old_val + delta)
            elif entry_type == 10:  # IMAGE_REL_BASED_DIR64 (x64)
                old_val = struct.unpack_from('<Q', data, patch_addr)[0]
                struct.pack_into('<Q', data, patch_addr, old_val + delta)
        
        offset += block_size

7.3 TLS回调

TLS (Thread Local Storage) 回调是PE文件在入口点之前执行的代码,是反调试和恶意代码常用的隐藏技术。

C
// TLS回调声明
#pragma section(".CRT$XLB", read)
void __stdcall TlsCallback(PVOID DllHandle, DWORD Reason, PVOID Reserved) {
    if (Reason == DLL_PROCESS_ATTACH) {
        // 此代码在main()之前执行
        // 常用于反调试检查
        if (IsDebuggerPresent()) {
            ExitProcess(0);
        }
    }
}

// 使用链接器指令注册
__declspec(allocate(".CRT$XLB"))
PIMAGE_TLS_CALLBACK TlsCallbacks[] = { TlsCallback, NULL };

TLS数据结构:

C
// IMAGE_TLS_DIRECTORY (数据目录索引9)
typedef struct {
    DWORD StartAddressOfRawData;   // TLS模板起始VA
    DWORD EndAddressOfRawData;     // TLS模板结束VA
    DWORD AddressOfIndex;          // TLS索引VA
    DWORD AddressOfCallBacks;      // TLS回调函数数组VA (关键!)
    DWORD SizeOfZeroFill;          // 零填充大小
    DWORD Characteristics;         // 保留
} IMAGE_TLS_DIRECTORY32;

7.4 资源节分析

PE资源节可以包含图标、位图、对话框模板、字符串表、清单文件,甚至是嵌入的可执行文件。

PYTHON
# Python pefile 资源提取
import pefile

pe = pefile.PE("malware.exe")

for resource_type in pe.DIRECTORY_ENTRY_RESOURCE.entries:
    if resource_type.name:
        print(f"Type: {resource_type.name}")
    else:
        print(f"Type: {pefile.RESOURCE_TYPE.get(resource_type.struct.Id)}")
    
    for resource_id in resource_type.directory.entries:
        for resource_lang in resource_id.directory.entries:
            rva = resource_lang.data.struct.OffsetToData
            size = resource_lang.data.struct.Size
            data = pe.get_data(rva, size)
            
            # 检测嵌入的PE文件
            if data[:2] == b'MZ':
                print(f"  [!] Embedded PE found! Size: {size}")
                with open(f"extracted_{resource_id.struct.Id}.exe", "wb") as f:
                    f.write(data)

八、ELF文件深度分析

8.1 ELF动态链接过程

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

8.2 GOT与PLT机制

GOT/PLT是实现延迟绑定的核心机制。

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

关键重定位类型:

重定位类型 值 说明 计算公式
R_X86_64_GLOB_DAT 6 GOT全局数据 GOT[offset] = S
R_X86_64_JUMP_SLOT 7 PLT跳转 GOT[offset] = S
R_X86_64_RELATIVE 8 相对重定位 *(B + A) = B + A
R_X86_64_64 1 64位绝对 S + A
R_X86_64_PC32 2 32位相对 S + A - P
R_X86_64_COPY 5 复制重定位 从共享对象复制到BSS

8.3 ELF保护机制

保护机制 标志/段 绕过难度 说明
NX (No-Execute) GNU_STACK RWE缺失 中 栈/堆不可执行,需ROP
PIE (位置无关) ET_DYN (共享对象) 低 地址随机化,需泄露基址
Full RELRO GNU_RELRO (BIND_NOW) 高 GOT只读,无法覆写
Stack Canary __stack_chk_fail 中 栈溢出检测
FORTIFY_SOURCE _chk函数变体 中 编译时缓冲区保护
ASLR /proc/sys/kernel/randomize_va_space 低 地址空间随机化
BASH
# checksec - 检查ELF保护
checksec --file=binary
# 输出:
# RELRO:    Full RELRO
# STACK CANARY: Found
# NX:       NX enabled
# PIE:      PIE enabled

九、Hook与代码注入

9.1 Hook技术分类

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

9.2 IAT Hook

C
// IAT Hook (Windows)
// 修改导入地址表中目标API的地址

void IATHook(HMODULE hModule, LPCSTR targetDll, LPCSTR targetFunc, LPVOID hookFunc) {
    PIMAGE_DOS_HEADER dosHeader = (PIMAGE_DOS_HEADER)hModule;
    PIMAGE_NT_HEADERS ntHeaders = (PIMAGE_NT_HEADERS)((BYTE*)hModule + dosHeader->e_lfanew);
    
    IMAGE_DATA_DIRECTORY importDir = 
        ntHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];
    
    PIMAGE_IMPORT_DESCRIPTOR importDesc = 
        (PIMAGE_IMPORT_DESCRIPTOR)((BYTE*)hModule + importDir.VirtualAddress);
    
    while (importDesc->Name) {
        LPCSTR dllName = (LPCSTR)((BYTE*)hModule + importDesc->Name);
        if (_stricmp(dllName, targetDll) == 0) {
            PIMAGE_THUNK_DATA thunk = 
                (PIMAGE_THUNK_DATA)((BYTE*)hModule + importDesc->FirstThunk);
            
            while (thunk->u1.Function) {
                if (thunk->u1.Function == (ULONGLONG)GetProcAddress(
                    GetModuleHandleA(targetDll), targetFunc)) {
                    
                    DWORD oldProtect;
                    VirtualProtect(&thunk->u1.Function, sizeof(ULONGLONG), 
                                  PAGE_READWRITE, &oldProtect);
                    thunk->u1.Function = (ULONGLONG)hookFunc;
                    VirtualProtect(&thunk->u1.Function, sizeof(ULONGLONG), 
                                  oldProtect, &oldProtect);
                    return;
                }
                thunk++;
            }
        }
        importDesc++;
    }
}

9.3 Inline Hook

C
// Inline Hook - 修改目标函数的前几个字节为跳转指令
// x86 (5字节 JMP): E9 [相对偏移 4字节]
// x64 (14字节): 需要更长跳转 + 寄存器

void InlineHook(BYTE* targetFunc, BYTE* hookFunc, BYTE* trampoline) {
    DWORD oldProtect;
    
    // 1. 保存原始指令 (至少5字节)
    memcpy(trampoline, targetFunc, 5);
    
    // 2. 在跳板末尾添加跳回目标函数的JMP
    trampoline[5] = 0xE9;  // JMP
    *(DWORD*)(trampoline + 6) = (DWORD)(targetFunc + 5 - trampoline - 10);
    
    // 3. 修改目标函数开头为 JMP hookFunc
    VirtualProtect(targetFunc, 5, PAGE_EXECUTE_READWRITE, &oldProtect);
    targetFunc[0] = 0xE9;  // JMP
    *(DWORD*)(targetFunc + 1) = (DWORD)(hookFunc - targetFunc - 5);
    VirtualProtect(targetFunc, 5, oldProtect, &oldProtect);
}

// 使用示例
BYTE trampoline[10];  // 5 + 5 (JMP + offset)

void MyMessageBoxW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType) {
    // 修改参数
    lpText = L"[Hooked]";
    
    // 调用原始函数
    typedef int (WINAPI *MsgBoxType)(HWND, LPCWSTR, LPCWSTR, UINT);
    MsgBoxType original = (MsgBoxType)trampoline;
    return original(hWnd, lpText, lpCaption, uType);
}

InlineHook((BYTE*)MessageBoxW, (BYTE*)MyMessageBoxW, trampoline);

9.4 Linux PLT/GOT Hook

C
// LD_PRELOAD Hook
// hook.c - 编译为共享库: gcc -shared -fPIC hook.c -o hook.so -ldl

#define _GNU_SOURCE
#include <dlfcn.h>
#include <stdio.h>

// 保存原始函数指针
typedef FILE* (*orig_fopen_t)(const char*, const char*);
orig_fopen_t orig_fopen = NULL;

FILE* fopen(const char* pathname, const char* mode) {
    // 首次调用时获取原始函数
    if (!orig_fopen) {
        orig_fopen = (orig_fopen_t)dlsym(RTLD_NEXT, "fopen");
    }
    
    printf("[Hook] fopen called: %s (mode: %s)\n", pathname, mode);
    
    // 可以修改参数
    if (strstr(pathname, "evil")) {
        printf("[Hook] Blocked access to evil file!\n");
        return NULL;
    }
    
    // 调用原始函数
    return orig_fopen(pathname, mode);
}

// 使用方法:
// LD_PRELOAD=./hook.so ./target

9.5 进程注入技术

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

经典远程线程注入:

C
BOOL InjectDLL(DWORD pid, const char* dllPath) {
    // 1. 打开目标进程
    HANDLE hProcess = OpenProcess(
        PROCESS_ALL_ACCESS, FALSE, pid);
    if (!hProcess) return FALSE;
    
    // 2. 在目标进程分配内存
    SIZE_T dllPathLen = strlen(dllPath) + 1;
    LPVOID remoteMem = VirtualAllocEx(
        hProcess, NULL, dllPathLen,
        MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
    
    // 3. 写入DLL路径
    WriteProcessMemory(hProcess, remoteMem, 
        dllPath, dllPathLen, NULL);
    
    // 4. 获取LoadLibraryA地址
    LPVOID loadLibAddr = GetProcAddress(
        GetModuleHandleA("kernel32.dll"), "LoadLibraryA");
    
    // 5. 创建远程线程
    HANDLE hThread = CreateRemoteThread(
        hProcess, NULL, 0,
        (LPTHREAD_START_ROUTINE)loadLibAddr,
        remoteMem, 0, NULL);
    
    if (hThread) {
        WaitForSingleObject(hThread, INFINITE);
        CloseHandle(hThread);
    }
    
    // 6. 清理
    VirtualFreeEx(hProcess, remoteMem, 0, MEM_RELEASE);
    CloseHandle(hProcess);
    return TRUE;
}

十、壳与脱壳技术

10.1 壳的分类

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

10.2 壳的识别

BASH
# Detect It Easy (DIE) - 壳检测
diec.exe sample.exe

# PEiD - 基于签名的壳识别
peid.exe sample.exe

# 手动检测特征
# UPX特征: UPX0/UPX1段名
# Themida特征: 大段名 .themida
# VMProtect特征: .vmp0/.vmp1段名

手动静态识别技巧:

PYTHON
import pefile

def detect_packer(pe):
    """基于特征检测壳"""
    indicators = []
    
    # 1. 检查段名
    section_names = [s.Name.decode().rstrip('\\x00') for s in pe.sections]
    packer_sections = ['UPX0', 'UPX1', '.vmp0', '.vmp1', '.themida', 
                       '.aspack', '.enigma1', '.enigma2']
    for name in section_names:
        for ps in packer_sections:
            if ps.lower() in name.lower():
                indicators.append(f"Packer section: {name}")
    
    # 2. 检查熵值 (压缩/加密段通常高熵)
    for section in pe.sections:
        entropy = section.get_entropy()
        if entropy > 7.0:
            status = "High entropy (encrypted)"
        elif entropy > 6.5:
            status = "Suspicious entropy (packed)"
        else:
            continue
        indicators.append(f"Section {section.Name.decode().rstrip()}: {status} ({entropy:.2f})")
    
    # 3. 检查入口点是否在代码段之外
    ep = pe.OPTIONAL_HEADER.AddressOfEntryPoint
    text_section = next((s for s in pe.sections if b'.text' in s.Name), None)
    if text_section:
        if not (text_section.VirtualAddress <= ep < 
                text_section.VirtualAddress + text_section.Misc_VirtualSize):
            indicators.append(f"EntryPoint outside .text section")
    
    # 4. 异常的资源节大小
    rsrc = next((s for s in pe.sections if b'.rsrc' in s.Name), None)
    if rsrc and rsrc.Misc_VirtualSize > 5 * 1024 * 1024:
        indicators.append("Abnormally large resource section")
    
    return indicators

10.3 通用脱壳技术

10.3.1 寻找OEP (Original Entry Point)

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

10.3.2 ESP定律

ESP定律是最经典的脱壳方法,适用于绝大多数压缩壳。

CODE
ESP定律原理:
1. 壳在执行解压过程中需要保存寄存器状态 (pushad)
2. 在OEP之前会恢复寄存器状态 (popad)
3. 在pushad之后对ESP指向的内存设置硬件访问断点
4. 壳执行到popad时会触发断点
5. 在popad附近通常就是OEP跳转

操作步骤:
1. F8单步到pushad之后
2. 对ESP指向的地址设硬件访问断点 (dword)
3. F9运行
4. 在硬件断点停下
5. 附近找JMP EAX / JMP [EAX] / RETN 等跳向OEP的指令
6. F7跟入 -> OEP

十一、反调试与反反调试

11.1 反调试技术分类

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

11.2 常见反调试代码

C
// ===== 1. PEB检测 =====
// x86 PEB.BeingDebugged
BOOL IsDebugged_PEB() {
    BOOL bDebugged = FALSE;
    __asm {
        mov eax, fs:[0x30]      // PEB地址
        movzx eax, byte ptr [eax + 2]  // BeingDebugged (offset 0x2)
        mov bDebugged, eax
    }
    return bDebugged;
}

// x64 PEB.BeingDebugged
BOOL IsDebugged_PEB_x64() {
    BOOL bDebugged = FALSE;
    __asm {
        mov rax, gs:[0x60]      // PEB地址 (x64)
        movzx rax, byte ptr [rax + 2]
        mov bDebugged, eax
    }
    return bDebugged;
}

// ===== 2. NtGlobalFlag检测 =====
BOOL IsDebugged_NtGlobalFlag() {
    DWORD NtGlobalFlag;
    __asm {
        mov eax, fs:[0x30]
        mov eax, [eax + 0x68]   // NtGlobalFlag offset
        mov NtGlobalFlag, eax
    }
    // 调试器通常设置: FLG_HEAP_ENABLE_TAIL_CHECK (0x10)
    //                 FLG_HEAP_ENABLE_FREE_CHECK (0x20)
    //                 FLG_HEAP_VALIDATE_PARAMETERS (0x40)
    return (NtGlobalFlag & 0x70) != 0;
}

// ===== 3. ProcessHeap Flags检测 =====
BOOL IsDebugged_HeapFlags() {
    DWORD Flags, ForceFlags;
    __asm {
        mov eax, fs:[0x30]
        mov eax, [eax + 0x18]   // ProcessHeap
        mov ecx, [eax + 0x0C]   // Flags
        mov Flags, ecx
        mov ecx, [eax + 0x10]   // ForceFlags
        mov ForceFlags, ecx
    }
    return Flags != 2 || ForceFlags != 0;
}

// ===== 4. 时间差检测 =====
BOOL IsDebugged_Timing() {
    LARGE_INTEGER start, end, freq;
    QueryPerformanceFrequency(&freq);
    QueryPerformanceCounter(&start);
    
    // 执行一段正常代码
    volatile int x = 0;
    for (int i = 0; i < 1000; i++) x += i;
    
    QueryPerformanceCounter(&end);
    double elapsed = (double)(end.QuadPart - start.QuadPart) / freq.QuadPart * 1000.0;
    
    // 如果执行时间异常长 (>100ms),可能被调试
    return elapsed > 100.0;
}

// RDTSC时间检测
BOOL IsDebugged_RDTSC() {
    unsigned __int64 start, end;
    start = __rdtsc();
    // 一些正常操作
    volatile int x = 0;
    for (int i = 0; i < 100; i++) x += i;
    end = __rdtsc();
    // 单步执行或中间设断点会显著增加时间
    return (end - start) > 10000;
}

// ===== 5. INT3扫描 (检测软件断点) =====
BOOL IsDebugged_Int3Scan() {
    BYTE* funcStart = (BYTE*)&IsDebugged_Int3Scan;
    for (int i = 0; i < 100; i++) {
        if (funcStart[i] == 0xCC) {
            return TRUE;  // 检测到int3断点
        }
    }
    return FALSE;
}

// ===== 6. 硬件断点检测 =====
BOOL IsDebugged_HardwareBP() {
    CONTEXT ctx = {0};
    ctx.ContextFlags = CONTEXT_DEBUG_REGISTERS;
    GetThreadContext(GetCurrentThread(), &ctx);
    
    return (ctx.Dr0 || ctx.Dr1 || ctx.Dr2 || ctx.Dr3);
}

// ===== 7. NtQueryInformationProcess =====
BOOL IsDebugged_NtQuery() {
    typedef NTSTATUS (NTAPI *pNtQueryInformationProcess)(
        HANDLE, DWORD, PVOID, ULONG, PULONG);
    
    HMODULE hNtdll = GetModuleHandleA("ntdll.dll");
    pNtQueryInformationProcess NtQueryInformationProcess = 
        (pNtQueryInformationProcess)GetProcAddress(hNtdll, "NtQueryInformationProcess");
    
    DWORD debugPort = 0;
    NtQueryInformationProcess(
        GetCurrentProcess(),
        7,  // ProcessDebugPort
        &debugPort, sizeof(debugPort), NULL);
    
    return debugPort != 0;
}

// ===== 8. 异常反调试 =====
BOOL IsDebugged_Exception() {
    __try {
        __asm { int 3 }  // 故意触发断点
        return FALSE;
    } __except(EXCEPTION_EXECUTE_HANDLER) {
        return FALSE;
    }
    return TRUE;  // 如果int3被调试器处理
}

// CloseHandle异常检测 (仅Windows XP/2003)
BOOL IsDebugged_CloseHandle() {
    __try {
        CloseHandle((HANDLE)0xBAADF00D);
        return FALSE;
    } __except(EXCEPTION_EXECUTE_HANDLER) {
        return TRUE;
    }
}

11.3 虚拟机检测

C
// VMware检测
BOOL IsVMware() {
    __try {
        __asm {
            mov eax, 'VMXh'
            mov ebx, 0
            mov ecx, 10       // VMWARE_CMD_GETVERSION
            mov edx, 'VX'
            in eax, dx         // 触发VMware后门
            cmp ebx, 'VMXh'
        }
        return TRUE;
    } __except(EXCEPTION_EXECUTE_HANDLER) {
    }
    return FALSE;
}

// VirtualBox检测
BOOL IsVirtualBox() {
    HKEY hKey;
    if (RegOpenKeyExA(HKEY_LOCAL_MACHINE,
        "SYSTEM\\CurrentControlSet\\Services\\VBoxGuest", 
        0, KEY_READ, &hKey) == ERROR_SUCCESS) {
        RegCloseKey(hKey);
        return TRUE;
    }
    
    if (GetFileAttributesA("C:\\Windows\\System32\\drivers\\VBoxMouse.sys") 
        != INVALID_FILE_ATTRIBUTES) {
        return TRUE;
    }
    
    return FALSE;
}

// 通用虚拟机检测 - MAC地址
BOOL IsVM_MacAddress() {
    IP_ADAPTER_INFO adapterInfo[16];
    DWORD dwBufLen = sizeof(adapterInfo);
    
    if (GetAdaptersInfo(adapterInfo, &dwBufLen) == ERROR_SUCCESS) {
        PIP_ADAPTER_INFO pAdapter = adapterInfo;
        while (pAdapter) {
            BYTE vmware_prefixes[][3] = {
                {0x00, 0x0C, 0x29}, {0x00, 0x50, 0x56}, {0x00, 0x05, 0x69}
            };
            BYTE vbox_prefix[] = {0x08, 0x00, 0x27};
            
            for (int i = 0; i < 3; i++) {
                if (memcmp(pAdapter->Address, vmware_prefixes[i], 3) == 0)
                    return TRUE;
            }
            if (memcmp(pAdapter->Address, vbox_prefix, 3) == 0)
                return TRUE;
            
            pAdapter = pAdapter->Next;
        }
    }
    return FALSE;
}

11.4 反反调试技术

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

反反调试实战技巧:

PYTHON
# Frida脚本 - 绕过常见反调试
import frida

code = """
// 1. 绕过 IsDebuggerPresent
var isDebuggerPresent = Module.findExportByName("kernel32.dll", "IsDebuggerPresent");
Interceptor.replace(isDebuggerPresent, new NativeCallback(function() {
    return 0;
}, 'int', []));

// 2. 绕过 CheckRemoteDebuggerPresent
var checkRemote = Module.findExportByName("kernel32.dll", "CheckRemoteDebuggerPresent");
Interceptor.attach(checkRemote, {
    onLeave: function(retval) {
        var pbDebuggerPresent = this.context.rdx;
        if (pbDebuggerPresent && !pbDebuggerPresent.isNull()) {
            pbDebuggerPresent.writeU32(0);
        }
    }
});

// 3. 绕过 NtQueryInformationProcess (DebugPort)
var NtQueryInfo = Module.findExportByName("ntdll.dll", "NtQueryInformationProcess");
Interceptor.attach(NtQueryInfo, {
    onEnter: function(args) {
        this.queryClass = args[1].toInt32();
    },
    onLeave: function(retval) {
        if (this.queryClass === 7) {
            var outBuf = this.context.rdx;
            if (outBuf && !outBuf.isNull()) {
                outBuf.writeU64(0);
            }
        }
    }
});

// 4. 清除硬件断点
var NtSetContextThread = Module.findExportByName("ntdll.dll", "NtSetContextThread");
Interceptor.attach(NtSetContextThread, {
    onEnter: function(args) {
        var ctx = args[1];
        if (ctx && !ctx.isNull()) {
            ctx.add(0x90).writeU64(0);  // Dr0
            ctx.add(0x98).writeU64(0);  // Dr1
            ctx.add(0xA0).writeU64(0);  // Dr2
            ctx.add(0xA8).writeU64(0);  // Dr3
            ctx.add(0xB0).writeU64(0);  // Dr6
            ctx.add(0xB8).writeU64(0);  // Dr7
        }
    }
});

// 5. 绕过 RDTSC 时间检测 - Hook QueryPerformanceCounter
var QPC = Module.findExportByName("kernel32.dll", "QueryPerformanceCounter");
Interceptor.attach(QPC, {
    onLeave: function(retval) {
        var lpCounter = this.context.rcx;
        if (lpCounter && !lpCounter.isNull()) {
            lpCounter.writeU64(0);
        }
    }
});

console.log("[+] Anti-anti-debug hooks installed");
"""

session = frida.attach("target.exe")
script = session.create_script(code)
script.load()

十二、加密算法识别

12.1 常见加密算法特征

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

12.2 算法特征常量表

算法 特征常量 字节序列
AES (Rijndael) S-Box (256字节) 63 7C 77 7B F2 6B 6F C5…
AES Inverse S-Box 52 09 6A D5 30 36 A5 38…
AES Rcon 01 02 04 08 10 20 40 80 1B 36
MD5 IV (4个32位) 01 23 45 67 89 AB CD EF FE DC BA 98 76 54 32 10
SHA-1 IV (5个32位) 67 45 23 01 EF CD AB 89 98 BA DC FE 10 32 54 76 C3 D2 E1 F0
SHA-256 IV (8个32位) 6A 09 E6 67 BB 67 AE 85 3C 6E F3 72…
RC4 KSA 256次循环 初始化 00-FF 的数组
Base64 编码表 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/
DES IP置换表 58 50 42 34 26 18 10 02…
ChaCha20 “expand 32-byte k” 65 78 70 61 6E 64 20 33 32 2D 62 79 74 65 20 6B
TEA Delta 0x9E3779B9 B9 79 37 9E
XTEA Delta 0x9E3779B9 B9 79 37 9E
SM4 (国密) S-Box D6 90 E9 FE CC E1 3D B7…

12.3 AES算法逆向实战

C
// AES-128 加密函数特征识别
// 典型AES密钥扩展 (KeyExpansion)
// 特征: 对Rcon数组的访问, rot_word, sub_word操作
void AES_KeyExpansion(uint8_t* key, uint32_t* w) {
    static const uint8_t Rcon[11] = {
        0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1B, 0x36
    };
    // Rcon是IDA中识别AES的关键特征!
}

// 典型AES S-Box (256字节查找表)
static const uint8_t sbox[256] = {
    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b,
    0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
};
// 在IDA中,sbox通常显示为大块的十六进制数组

IDA中识别AES的常见模式:

ASSEMBLY
; AES密钥扩展中的RotWord操作 - 循环左移
; 常见模式: shl/shr/or 组合实现32位循环左移8位
mov     edx, [esi]        ; 读取一个字
mov     ecx, edx
shl     ecx, 8            ; 左移8位
shr     edx, 24           ; 右移24位 (取出高8位放到低8位)
or      edx, ecx          ; 合并

; SubBytes操作 - S-Box查表
movzx   eax, byte ptr [ebx]    ; 取一个字节
movzx   eax, byte ptr [eax+0xAABBCCDD]  ; S-Box查表

; MixColumns中的GF(2^8)乘法
; 特征: 大量xor和位运算, xtime宏 (x << 1 ^ ((x >> 7) * 0x1B))

12.4 FindCrypt插件使用

PYTHON
# IDA Pro FindCrypt插件 - 自动识别sbox和加密常量
# 手动搜索加密常量 (IDAPython)
import ida_bytes
import ida_search
import idc

# 搜索AES S-Box首部
aes_sbox_head = "63 7C 77 7B F2 6B 6F C5"
ea = ida_search.find_binary(0, 0xFFFFFFFF, aes_sbox_head, 16, 1)
if ea != ida_idaapi.BADADDR:
    print(f"AES S-Box found at: 0x{ea:X}")
    idc.set_name(ea, "AES_SBox", idc.SN_NOCHECK)

# 搜索MD5 IV
md5_iv = "01 23 45 67 89 AB CD EF FE DC BA 98 76 54 32 10"
ea = ida_search.find_binary(0, 0xFFFFFFFF, md5_iv, 16, 1)
if ea != ida_idaapi.BADADDR:
    print(f"MD5 IV found at: 0x{ea:X}")

12.5 加密模式识别

模式 特征 逆向识别点
ECB 块独立加密 无IV, 相同明文->相同密文
CBC 前块密文XOR当前明文 IV (16字节随机数) + 链式异或
CTR 计数器加密 Nonce + 递增计数器
GCM 认证加密 GHASH操作 (GF乘法) + IV/Nonce
OFB/CFB 流密码模式 IV初始化 + 反馈链
C
// AES-CBC 解密函数特征
void AES_CBC_Decrypt(uint8_t* ciphertext, uint8_t* plaintext, int len,
                     uint8_t* key, uint8_t* iv) {
    // 特征1: 有IV参数 (16字节)
    // 特征2: 循环中对每个块进行AES解密
    for (int i = 0; i < len; i += 16) {
        AES_DecryptBlock(ciphertext + i, key, temp);
        // 特征3: XOR操作 (CBC模式的异或)
        for (int j = 0; j < 16; j++) {
            plaintext[i + j] = temp[j] ^ (i == 0 ? iv[j] : ciphertext[i - 16 + j]);
        }
    }
}

十三、网络协议还原

13.1 协议还原流程

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

13.2 定位网络函数

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

Frida网络监控Hook:

PYTHON
# Frida - 监控网络发送数据
import frida

code = """
// Windows - Hook send
var sendAddr = Module.findExportByName("ws2_32.dll", "send");
Interceptor.attach(sendAddr, {
    onEnter: function(args) {
        this.sock = args[0];
        this.buf = args[1];
        this.len = args[2].toInt32();
        
        if (this.len > 0 && this.len < 0x10000) {
            console.log("\\n[send] len=" + this.len);
            console.log(hexdump(this.buf, { length: Math.min(this.len, 256) }));
        }
    }
});

// Linux - Hook send
var sendAddr = Module.findExportByName(null, "send");
Interceptor.attach(sendAddr, {
    onEnter: function(args) {
        var len = args[2].toInt32();
        if (len > 0 && len < 0x10000) {
            console.log("\\n[send] fd=" + args[0] + " len=" + len);
            console.log(hexdump(args[1], { length: Math.min(len, 256) }));
        }
    }
});
"""

session = frida.attach("target")
script = session.create_script(code)
script.load()

13.3 协议格式分析方法

13.3.1 基于数据流跟踪

PYTHON
# IDAPython - 跟踪send函数的参数来源
import idautils
import idc
import idaapi

def trace_send_buffer(func_ea):
    """跟踪send调用的缓冲区来源"""
    for xref in idautils.XrefsTo(func_ea):
        caller_ea = xref.frm
        func = idaapi.get_func(caller_ea)
        if func:
            for head in idautils.Heads(func.start_ea, func.end_ea):
                if idc.print_insn_mnem(head) == 'push':
                    op = idc.print_operand(head, 0)
                    print(f"0x{head:X}: push {op}")

13.3.2 常见协议格式模式

协议特征 解析方式 常见场景
固定长度包头 + 可变负载 PacketLen:4B + CmdId:4B + Payload C2通信
TLV (Type-Length-Value) Type:1B + Len:2B + Value 配置协议
JSON/XML文本协议 文本解析 Web/API通信
Protobuf Varint编码 + Field标签 gRPC/移动App
二进制流 固定偏移 + 预设格式 IoT/嵌入式

13.4 TLS加密流量处理

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

**SSL Pinning Bypass (Frida)**:

JAVASCRIPT
// Android SSL Pinning Bypass
Java.perform(function() {
    var TrustManager = Java.registerClass({
        name: 'com.badguy.TrustManager',
        implements: [Java.use('javax.net.ssl.X509TrustManager')],
        methods: {
            checkClientTrusted: function(chain, authType) {},
            checkServerTrusted: function(chain, authType) {},
            getAcceptedIssuers: function() { return []; }
        }
    });
    
    var SSLContext = Java.use('javax.net.ssl.SSLContext');
    var TrustManagers = Java.array('Ljavax.net.ssl.TrustManager;', [TrustManager.$new()]);
    var sslContext = SSLContext.getInstance('TLS');
    sslContext.init(null, TrustManagers, null);
});

// iOS SSL Pinning Bypass
var sec = Process.findModuleByName("Security");
var SSLHandshake = sec.findExportByName("SSLHandshake");

Interceptor.attach(SSLHandshake, {
    onEnter: function(args) { this.ctx = args[0]; },
    onLeave: function(retval) {
        retval.replace(0);  // errSecSuccess
    }
});

十四、恶意软件逆向实战

14.1 恶意软件逆向分析流程

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

14.2 勒索软件分析

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

勒索软件分析重点:

CODE
1. 加密算法识别 - 是否有密钥恢复可能
2. 密钥生成逻辑 - 本地生成 vs 从C2获取
3. 文件遍历范围 - 哪些目录/扩展名
4. C2通信 - 是否已失效
5. 释放器逻辑 - 投放的其他Payload

14.3 远控木马 (RAT) 分析

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

14.4 YARA规则编写

YARA
rule Malware_Family_X {
    meta:
        description = "Detects Malware Family X"
        author = "Security Researcher"
        date = "2024-01-01"
        severity = "high"
        hash = "d41d8cd98f00b204e9800998ecf8427e"
        
    strings:
        $str1 = "C2_DOMAIN_PLACEHOLDER" ascii wide
        $str2 = "regsvr32.exe /s /i" ascii
        $str3 = "SeDebugPrivilege" ascii
        $str4 = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run" ascii wide
        
        $hex1 = { 8B 45 ?? 83 F8 01 75 ?? 33 C0 }
        $hex2 = { 68 [4] 68 [4] FF [4] 83 C4 0C }
        
        $aes_sbox = { 63 7C 77 7B F2 6B 6F C5 }
        $base64_table = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
        
        $c2_pattern = /https?:\/\/[a-z0-9.-]+\.[a-z]{2,}\/(api|gate|cmd)\.php/
        $reg_pattern = /HKEY_(LOCAL_MACHINE|CURRENT_USER)\\\\SOFTWARE\\\\Microsoft\\\\Windows/

    condition:
        uint16(0) == 0x5A4D and
        (
            (3 of ($str*)) or 
            ($aes_sbox and $base64_table) or
            (all of ($hex*))
        )
}

rule Suspicious_API_Patterns {
    meta:
        description = "Detects suspicious API combinations"
        
    strings:
        $va1 = "VirtualAllocEx" ascii
        $wpm = "WriteProcessMemory" ascii
        $crt = "CreateRemoteThread" ascii
        
        $reg_open = "RegOpenKeyEx" ascii
        $reg_set = "RegSetValueEx" ascii
        $run_key = "Run" ascii
        
        $idp = "IsDebuggerPresent" ascii
        $nt_qi = "NtQueryInformationProcess" ascii
        
    condition:
        uint16(0) == 0x5A4D and
        (
            (all of ($va*)) or
            ($reg_open and $reg_set) or
            (2 of ($idp, $nt_qi))
        )
}

14.5 恶意软件配置提取

PYTHON
class MalwareConfigExtractor:
    """通用恶意软件配置提取器"""
    
    def __init__(self, binary_path):
        self.data = open(binary_path, 'rb').read()
        self.config = {}
    
    def extract_strings(self, min_len=4):
        import re
        pattern = re.compile(b'[\\x20-\\x7E]{%d,}' % min_len)
        return [m.group().decode('ascii', errors='ignore') 
                for m in pattern.finditer(self.data)]
    
    def find_urls(self):
        import re
        pattern = re.compile(
            b'https?://[a-zA-Z0-9][-a-zA-Z0-9.]*\\.[a-zA-Z]{2,}[^\\s"\\'<>]*'
        )
        self.config['urls'] = [m.group().decode() for m in pattern.finditer(self.data)]
        return self.config['urls']
    
    def find_ips(self):
        import re
        pattern = re.compile(b'\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}')
        self.config['ips'] = list(set(
            m.group().decode() for m in pattern.finditer(self.data)
        ))
        return self.config['ips']
    
    def find_base64_strings(self):
        import re, base64
        pattern = re.compile(b'[A-Za-z0-9+/]{40,}={0,2}')
        candidates = []
        for m in pattern.finditer(self.data):
            try:
                decoded = base64.b64decode(m.group())
                candidates.append({
                    'encoded': m.group().decode(),
                    'decoded': decoded,
                    'offset': m.start()
                })
            except:
                pass
        self.config['base64'] = candidates
        return candidates
    
    def xor_decrypt(self, offset, length, key):
        result = bytearray(length)
        for i in range(length):
            result[i] = self.data[offset + i] ^ key[i % len(key)]
        return bytes(result)

十五、CTF逆向解题技巧

15.1 常见CTF逆向题型

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

15.2 注册机编写

PYTHON
# CTF注册机编写示例
# 题目: 验证算法为: username[i] ^ 0xAB + 0x12 == serial[i]
# 需要根据username生成serial

def keygen(username):
    serial = bytearray()
    for ch in username.encode():
        s = (ch ^ 0xAB) + 0x12
        serial.append(s & 0xFF)
    return serial.hex().upper()

print(keygen("admin"))    # 输出序列号
print(keygen("test123"))  # 另一个用户的序列号

15.3 angr自动化解题

PYTHON
import angr
import claripy

def solve_crackme(binary_path, find_addr, avoid_addr, input_len=16):
    """使用angr自动化求解crackme"""
    proj = angr.Project(binary_path, auto_load_libs=False)
    
    flag_chars = [claripy.BVS(f'flag_{i}', 8) for i in range(input_len)]
    flag = claripy.Concat(*flag_chars + [claripy.BVV(b'\\n')])
    
    state = proj.factory.entry_state(
        stdin=angr.SimFile('/dev/stdin', content=flag),
        add_options={
            angr.options.ZERO_FILL_UNCONSTRAINED_MEMORY,
            angr.options.ZERO_FILL_UNCONSTRAINED_REGISTERS,
        }
    )
    
    for c in flag_chars:
        state.solver.add(c >= 0x20)
        state.solver.add(c <= 0x7E)
    
    simgr = proj.factory.simulation_manager(state)
    simgr.explore(find=find_addr, avoid=avoid_addr)
    
    if simgr.found:
        found_state = simgr.found[0]
        solution = found_state.solver.eval(flag, cast_to=bytes)
        return solution.decode().strip()
    
    return None

result = solve_crackme('./crackme', 0x401200, 0x401300, 32)
print(f"Flag: {result}")

15.4 VM逆向解题

PYTHON
class VMCrackme:
    def __init__(self, bytecode):
        self.code = bytecode
        self.ip = 0
        self.regs = [0] * 16
        self.stack = []
        self.memory = bytearray(0x10000)
    
    def step(self):
        opcode = self.code[self.ip]
        
        if opcode == 0x01:  # MOV reg, imm
            reg = self.code[self.ip + 1]
            val = int.from_bytes(self.code[self.ip + 2:self.ip + 6], 'little')
            self.regs[reg] = val
            self.ip += 6
        elif opcode == 0x02:  # XOR reg1, reg2
            r1 = self.code[self.ip + 1]
            r2 = self.code[self.ip + 2]
            self.regs[r1] ^= self.regs[r2]
            self.ip += 3
        elif opcode == 0x03:  # CMP reg1, reg2
            r1 = self.code[self.ip + 1]
            r2 = self.code[self.ip + 2]
            self.cmp_result = self.regs[r1] - self.regs[r2]
            self.ip += 3
        elif opcode == 0x04:  # JNE offset
            if self.cmp_result != 0:
                self.ip += self.code[self.ip + 1]
            else:
                self.ip += 2
        elif opcode == 0xFF:  # HALT
            return False
        else:
            raise ValueError(f"Unknown opcode: {opcode}")
        
        return True
    
    def run(self):
        while self.step():
            pass
        return self.regs[0]

15.5 常用CTF工具速查

工具 用途 命令示例
angr 符号执行 angr_solve.py binary
z3 SMT约束求解 solve.py
gdb+peda 动态调试 gdb -q ./binary
strace 系统调用跟踪 strace -f ./binary
ltrace 库函数跟踪 ltrace ./binary
objdump 反汇编 objdump -d -M intel binary
readelf ELF分析 readelf -a binary
strings 字符串提取 strings -n 8 binary
xxd 十六进制查看 xxd binary
file 文件类型 file unknown.dat
binwalk 固件提取 binwalk -e firmware.bin
jadx APK反编译 jadx-gui app.apk
dex2jar DEX转JAR d2j-dex2jar classes.dex
apktool APK拆包 apktool d app.apk
Frida 动态插桩 frida -U -l script.js com.app

十六、逆向分析防御与对抗

16.1 代码保护技术

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

16.2 最佳实践 - 安全开发

CODE
防御层次模型:

第1层: 编译选项
  - /GS (Stack Canary)
  - /DYNAMICBASE (ASLR)
  - /NXCOMPAT (DEP)
  - /HIGHENTROPYVA (高熵ASLR, x64)
  - /guard:cf (Control Flow Guard)
  - /CETCOMPAT (Intel CET)

第2层: 代码混淆
  - 控制流平坦化
  - 虚假控制流
  - 指令替换
  - 字符串加密
  - 常量展开

第3层: 反调试
  - PEB检测
  - 时间差检测
  - 断点扫描
  - 异常处理检测

第4层: 完整性保护
  - CRC校验
  - 数字签名验证
  - 内存页哈希校验

第5层: 加壳保护
  - 压缩壳 (增大分析难度)
  - 加密壳 (防止静态分析)
  - 虚拟机壳 (最大保护)

16.3 检测逆向分析行为

C
class AntiReverse {
public:
    static bool IsDebugged() {
        if (IsDebuggerPresent()) return true;
        if (IsDebugged_PEB()) return true;
        if (IsDebugged_NtQuery()) return true;
        if (IsDebugged_HardwareBP()) return true;
        if (IsDebugged_Timing()) return true;
        return false;
    }
    
    static bool IsAnalyzed() {
        const char* tools[] = {
            "x64dbg.exe", "x32dbg.exe",
            "ollydbg.exe", "ida.exe", "ida64.exe",
            "ghidra", "windbg.exe",
            "procmon.exe", "processhacker.exe",
            "wireshark.exe", "frida-server",
            "httpdebugger", "charles.exe"
        };
        
        HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        PROCESSENTRY32 pe32 = { sizeof(PROCESSENTRY32) };
        
        if (Process32First(snapshot, &pe32)) {
            do {
                for (const char* tool : tools) {
                    if (_stricmp(pe32.szExeFile, tool) == 0)
                        return true;
                }
            } while (Process32Next(snapshot, &pe32));
        }
        CloseHandle(snapshot);
        return false;
    }
    
    static void AntiDump() {
        HMODULE hMod = GetModuleHandle(NULL);
        PIMAGE_DOS_HEADER dos = (PIMAGE_DOS_HEADER)hMod;
        DWORD oldProtect;
        VirtualProtect(dos, 0x1000, PAGE_READWRITE, &oldProtect);
        memset(dos, 0, 0x1000);
    }
    
    static void AntiHook() {
        HMODULE hNtdll = GetModuleHandleA("ntdll.dll");
        BYTE* funcStart = (BYTE*)GetProcAddress(hNtdll, "NtQueryInformationProcess");
        
        if (funcStart[0] == 0xE9 || funcStart[0] == 0xE8 || 
            (funcStart[0] == 0x68 && funcStart[5] == 0xC3)) {
            TerminateProcess(GetCurrentProcess(), 0);
        }
    }
};

16.4 加固工具对比

工具 类型 保护强度 性能影响 平台
UPX 压缩 低 极小 Win/Linux
ASPack 压缩+轻度保护 低 小 Windows
VMProtect 虚拟机保护 极高 大 Win/Mac/Linux
Themida 多态+虚拟机 极高 大 Windows
OLLVM 编译混淆 中 中 跨平台
Tigress C源码混淆 高 中 跨平台
ConfuserEx .NET保护 高 小 Windows (.NET)
DexGuard Android保护 高 中 Android
LLVM Obfuscator LLVM混淆 中 中 跨平台
Enigma Protector 文件保护 高 中 Windows

附录:逆向分析工具速查表

A.1 Windows平台工具

工具 类型 说明
IDA Pro 反汇编器 行业标准,交互式反汇编
Ghidra 反汇编器 NSA开源,内置反编译器
x64dbg 调试器 开源Windows调试器
OllyDbg 调试器 经典32位调试器
WinDbg 调试器 微软官方内核/用户态调试器
PE-bear PE查看器 现代PE文件分析器
CFF Explorer PE编辑器 PE结构查看编辑
Detect It Easy 文件识别 文件类型/壳检测
PEiD 壳检测 经典壳识别工具
Process Monitor 系统监控 文件/注册表/进程实时监控
Process Hacker 进程管理 高级任务管理器
API Monitor API监控 实时API调用监控
HxD 十六进制编辑器 磁盘/内存编辑
ScyllaHide 反反调试 x64dbg插件,隐藏调试器
Cheat Engine 内存修改 内存扫描/修改/调试

A.2 Linux/macOS平台工具

工具 类型 说明
GDB + GEF/PEDA/pwndbg 调试器 Linux标准调试器+增强
LLDB 调试器 macOS标准调试器
radare2/rizin 反汇编框架 命令行逆向框架
Hopper 反汇编器 macOS GUI反汇编器
objdump 反汇编 GNU binutils
ltrace/strace 跟踪 库调用/系统调用跟踪
readelf ELF分析 ELF结构查看
checksec 安全检查 pwntools ELF保护检查
Ropper/ROPgadget ROP ROP gadget搜索

A.3 跨平台/框架工具

工具 类型 说明
Frida 动态插桩 跨平台运行时Instrumentation
angr 符号执行 二进制分析框架
Binary Ninja 反汇编器 现代化逆向平台
dnSpy .NET调试器 .NET反编译+调试
JEB 反编译器 Android/Native
Unicorn Engine CPU模拟 轻量级多架构CPU模拟
Capstone 反汇编框架 多架构反汇编引擎
Keystone 汇编框架 多架构汇编引擎
Z3 Theorem Prover 约束求解 SMT求解器
Kaitai Struct 文件格式 声明式二进制解析
ImHex 十六进制编辑器 模式匹配/数据检查
Wireshark 网络分析 协议分析

逆向工程不仅仅是一门技术,更是一种思维方式的训练。它教会你从结果出发,通过层层推理还原设计者的原始意图。在网络安全领域,逆向分析能力直接影响着漏洞挖掘的深度、恶意软件分析的准确度以及安全防护的有效性。面对日益复杂的威胁态势,掌握扎实的逆向分析功底是每一位安全研究者必备的核心竞争力。

不断变化的对抗格局提醒我们,逆向工程永远是一场攻防博弈——攻击者用壳、混淆、反调试武装自己,防御者用更先进的分析工具和方法武装自己。在这场没有终点的竞赛中,持续学习和实践是唯一的护城河。