先看一个很奇怪的现场。程序申请一块内存,写入字符串,调用 free 释放,然后把同一个指针交给 printf,终端居然还能打印出原来的内容。把这段代码放进一个长期运行的服务里,表现就更离谱:有时候正常,有时候打印出完全不相干的字符串,还有时候在某个和这段逻辑毫无关系的 malloc 里崩掉。

这不是 free 没生效,也不是编译器在骗人。堆上的内存释放后并不会立刻被清空或归还给系统,它只是被标记成「可以复用」。理解这块内存的生命周期、理解分配器在空闲块里放了什么,才能看懂这些现象。这篇就把 glibc 的堆拆开,再讲三类最常见的错误。

边界提醒:堆上的错误往往能组合成很强的利用原语,所以更要守住范围。本文只在自编译程序上复现和观察,不给出针对真实服务的利用步骤;把堆漏洞当成「练手素材」去碰别人的系统,后果和其他几篇一样,是法律问题。

堆从哪里来

程序启动时,内核会给它分配一段可读写的地址空间。glibc 的分配器在这段空间上做二级管理:小块内存通过 brk 从数据段末尾往上扩展,大块内存(默认阈值通常是 128KB)直接用 mmap 另开一块。你在代码里看到的 malloc 返回的指针,指向的是分配器切出来的「用户区」,不是页的起始地址。

这也解释了两个常见现象。第一,连续 malloc 两次,地址不一定相邻,因为中间可能隔着管理信息;第二,free 之后地址仍然可以访问,因为这块虚拟内存还在进程的地址空间里,只是分配器把它记成了空闲。

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    char *a = malloc(32);
    char *b = malloc(32);
    printf("a=%p b=%p diff=%ld\n", (void*)a, (void*)b, (long)((char*)b - (char*)a));
    free(a);
    free(b);
    return 0;
}

在 64 位 glibc 上,两次分配 32 字节,返回地址之间的差值通常大于 32,因为每个块前面有 16 字节的管理头,块大小还会按 16 字节对齐。差值具体是多少,取决于分配器版本和当前堆的状态,不要把它当成固定公式。

一个堆块长什么样

glibc 把每个堆块描述成一段带元数据的结构。可以把它理解成三层:前一个块的尾部、当前块的管理头、当前块的用户数据。管理头里最关键的是 size 字段,它记录这个块有多大,低三位还被借用来存标志。

上一个块的用户数据(如果上一个块空闲,这里可能存上一个块的 prev_size)
当前块的 prev_size:只有前一个块空闲时才会用到
当前块的 size:块大小,低三位是标志位
用户数据区:malloc 返回的指针就指在这里
下一个块的管理头:用户数据越界写时最先遭殃的地方

size 的低三位分别是:PREV_INUSE(前一个块是否在使用)、IS_MMAPPED(是否由 mmap 分配)、NON_MAIN_ARENA(是否属于非主线程的分配区)。分配器判断相邻块、合并空闲块、计算下一个块的位置,都依赖这个字段。所以一旦越界写把 size 改坏,分配器在之后的某次操作里就会读到错误的地址,崩溃点离你的代码可能很远。

在本机 glibc 2.36 上连续 malloc(32) 三块,在第一次 free 前用 gdb 看第一块前方的两个字,得到的是:

(gdb) p/x a
$1 = 0x4052a0
(gdb) x/8gx (char*)a-0x10
0x405290:	0x0000000000000000	0x0000000000000031	<- prev_size=0, size=0x31
0x4052a0:	0x0000000000000000	0x0000000000000000	<- 用户区起点
0x4052b0:	0x0000000000000000	0x0000000000000000
0x4052c0:	0x0000000000000000	0x0000000000000031	<- 第二块的 prev_size 与 size

0x31 就是 48:低三位是 001,PREV_INUSE=1 表示前一块还在使用,另外两位为 0。用户区拿到 40 字节(malloc_usable_size 返回 40),但相邻两块地址差 48,多出的 8 字节正是下一块的 prev_size 被借给上一块使用的结果。所以写第 33 到 40 个字节其实落在下一块的 prev_size 里,这属于允许范围;第 41 个字节起才碰到下一块的 size,写满 56 字节就会把它整个改掉——这也解释了为什么「多写 8 字节」经常毫无反应。

空闲块去了哪里:tcache 与 bin

free 之后,块不会凭空消失,而是被放进某个「回收站」等待下次分配。glibc 的回收站分层:最快的是线程本地的 tcache,其次是 fastbin、unsorted bin、small bin、large bin。

tcache

glibc 2.26 引入,每个线程一份,按块大小分档,默认每档最多缓存 7 个块。分配和释放都走后进先出(LIFO),速度很快。它不检查块是否真的属于当前线程,也不做复杂的一致性校验,因此也是很多堆问题的发源地。

fastbin 与其他 bin

fastbin 处理较小的块,同样是 LIFO;unsorted bin 是释放后暂时没归类的块,下次分配时会先在这里找合适尺寸;更大的块进入 small/large bin,按大小排序,释放时还会尝试与相邻空闲块合并。

从 glibc 2.32 开始,tcache 的空闲链表指针加入了 safe-linking:存进去的不是原始地址,而是「当前位置右移 12 位」再与指针异或的结果。这样即使能读到空闲块的 next,也不能直接得到真实地址,必须先知道当前块的位置才能解码。这个变化让很多老教程里的堆利用手法失效,也是「为什么我的链在靶场上不工作」的常见原因。

你不需要背所有 bin 的细节,但要知道一件事:堆的行为和 glibc 版本强绑定。2.26 之前没有 tcache,2.32 之后有 safe-linking,2.35 又调整了部分校验。看堆题之前,先用 ldd --version 确认版本,比背技巧重要。

错误一:越界写把邻居的管理头改坏

堆上两块内存相邻时,对第一块的越界写会先碰到第二块的管理头。如果只是多写一个字节,可能改到第二块 size 的最低位;如果多写几十个字节,就可能把整个 size 改成一个荒谬的值。分配器下次处理第二块时,会按这个错误的尺寸去算下一个块的位置,于是读到一段不属于堆的内存。

char *a = malloc(24);
char *b = malloc(24);
memset(a, 'A', 40);   /* 越过 a 的用户区,写进 b 的管理头 */
free(b);              /* 分配器这时才发现 b 的 size 不对 */

典型提示是 malloc(): corrupted top size、free(): invalid next size (normal) 或 malloc(): memory corruption。这些提示出现的位置,往往不是你越界写的那一行,而是之后某次 malloc 或 free。排查时不能只盯着崩溃点,要往回找「最近一次写超出边界的操作」。

这类错误还有一个隐蔽版本:只越界一个字节(off-by-one),改掉 size 的最低位 PREV_INUSE。程序可能很久都不崩,直到某次释放触发块合并,才在完全不相干的地方出问题。这也是堆问题比栈问题难查的原因之一。

错误二:释放后继续使用

释放后使用(use-after-free,UAF)指的是 free 之后仍然通过旧指针读写。因为块只是被标记为空闲,内容还在,读操作通常能拿到旧数据;如果这块内存被重新分配给别人,旧指针读写的就成了别人的数据。

char *p = malloc(32);
strcpy(p, "secret");
free(p);
printf("%s\n", p);    /* UAF:内容可能还在,也可能已经被复用 */
char *q = malloc(32);  /* 很可能拿到同一块 */
strcpy(q, "other");
printf("%s\n", p);     /* 现在 p 和 q 指向同一块,输出 other */

UAF 的危险不在于「读到旧数据」,而在于「旧指针仍然能被写」。如果这块内存后来被用来存一个函数指针、一个对象虚表、一个链表节点,攻击者就能通过旧指针改写它,等程序调用时劫持控制流。堆上没有返回地址,但函数指针和虚表同样能决定程序去哪。

排查 UAF 最有效的工具是 AddressSanitizer(ASAN)。编译时加 -fsanitize=address -g,它会在 free 后把内存标记为不可访问,一旦旧指针读写就立刻报错,并给出分配、释放、使用三处的调用栈。比等到线上崩溃再猜要快得多。

错误三:重复释放

对同一个指针调用两次 free,就是 double free。glibc 在 tcache 里会做检查,第二次释放同一个块时通常直接报 free(): double free detected in tcache 2 并终止进程。注意这里的 tcache 2 指的是线程编号或缓存序号,不是「释放了两次」的字面意思,具体编号随实现变化。

char *p = malloc(32);
free(p);
free(p);   /* 同一指针释放两次 */

重复释放的危害是让同一个块在空闲链表里出现两次。之后连续两次分配可能拿到同一个地址,两个「不同」的指针指向同一块内存,改一个就会影响另一个。这类「别名」问题是很多堆利用的起点,也是检测工具重点盯的对象。

还有一种变体:释放的是块内部的指针,或者释放了一个不是 malloc 返回的地址。这类错误通常报 munmap_chunk(): invalid pointer 或 free(): invalid pointer。看到这两个提示,先去核对传给 free 的地址是不是原始返回值,中间有没有做过指针运算。

为什么堆比栈难

栈溢出的目标很明确:返回地址就在缓冲区上面固定偏移处。堆上没有这样的固定目标,你能改的是分配器的元数据、相邻块的内容、空闲链表里的指针。这些结构在不同 glibc 版本里不一样,还受线程、分配顺序、块大小影响。同一段越界写,在 2.31 上可能立刻崩,在 2.35 上可能被 safe-linking 拦下,在另一个程序里可能完全不触发。

所以堆的学习顺序应该是:先能稳定复现错误,再能解释错误发生在哪个块、哪个字段,最后才谈「这个错误能变成什么」。跳过前两步直接背利用技巧,换一个版本就会全部作废。

现象对照表

现象真实原因第一步查什么
free 之后还能打印出旧字符串块被标记为空闲但内容未清空,地址仍映射ASAN 编译,或在 gdb 里看该地址的 chunk 状态
提示 free(): double free detected in tcache 2同一个块在 tcache 中被释放两次,触发一致性检查给每次 free 打日志,核对指针来源和释放次数
提示 malloc(): corrupted top size越界写破坏了堆顶块的 size 字段检查所有写操作的长度,gdb 里 x/8gx 看 chunk 头
提示 munmap_chunk(): invalid pointerfree 收到一个不是分配器返回的地址核对指针是否被偏移、是否指向栈或全局区
崩溃发生在不相干的 malloc 里之前的越界写破坏了空闲链表或块尺寸,延迟到这次分配才暴露用 ASAN 或 valgrind 复现,拿到第一次非法写的调用栈
同样的代码换 glibc 版本行为完全不同tcache、safe-linking、校验逻辑随版本变化ldd --version,核对靶场与本地版本

这张表里的前三条,用一段二十行的自编译程序就能复现。复现时记得把 glibc 版本、编译命令、输入顺序记下来,否则过两天你自己也复现不出来。

边界与代价

堆漏洞的利用能力通常比栈溢出更强,因为它能构造「重叠块」「任意地址分配」这类原语,进而改写任意函数指针。也正因为如此,边界必须更清楚:只在自编译程序和官方靶场里实验;不要用堆技巧去测试任何线上服务;不要把他人的二进制带进自己的实验环境做未授权分析。技术的杀伤力和法律后果是成正比的。

代价方面,第一是版本敏感:glibc 一升级,原来的偏移、校验、可用 gadget 全变,维护成本很高。第二是可复现性差:分配顺序、线程、环境变量都会影响堆布局,同一个输入在不同时间可能得到不同结果。第三是排查成本高:崩溃点常常远离错误点,必须借助 ASAN、valgrind 或自定义日志。第四是防御在进步:safe-linking、更多一致性检查、内存分配器加固,让老手法持续失效。

防御侧的建议很具体:所有 free 之后把指针置空;所有写入前检查长度;对来自外部的索引做边界校验;用 ASAN 跑单元测试;对长期运行的服务定期做堆一致性检查。这些做法比事后分析一个堆崩溃便宜得多。

真实踩坑与判断方法

第一个坑是「free 之后还能读到内容,就以为块没被释放」。你读的是自己保存的指针,分配器只把块标记为空闲,用户区一般不清零,地址也仍然映射,所以旧字符串照样打印得出来。判断不能靠观察内容,要看分配器状态:用 -fsanitize=address 重编,同样的代码会直接报 heap-use-after-free 并给出释放和使用的两处调用栈;或者在 gdb 里看该块 size 字段的最低位是否被标成空闲。

第二个坑是把「越界 8 字节没崩」当成安全。块大小按 16 字节对齐,malloc_usable_size 往往比请求的字节数大,多出来的那几字节还在本块内部,写进去当然不报错。真正的越界要越过块尾、碰到下一块的 size 字段才显现。判断方法:打印 malloc_usable_size 的结果和请求值对比,确认你的写入落在块内还是块外。

第三个坑是崩溃点离错误点太远。堆错误常常在「下一次 malloc」或「进程退出时」才暴露,此时调用栈里只有分配器函数,看不到你自己的代码。判断顺序:先读提示语,corrupted top size 指向堆顶块被改坏,double free detected in tcache 2 指向重复释放,munmap_chunk(): invalid pointer 指向传了非法地址;再用 ASAN 或 valgrind 复现,拿第一次非法访问的栈,而不是最后一次崩溃的栈。

防御点在工程上很具体:free 之后立刻把指针置空,避免悬垂指针被再次使用;对象生命周期交给 RAII 或智能指针管理,减少手工配对;所有写操作前校验长度和索引,尤其是从外部解析来的偏移;CI 里让 ASAN 跑一遍单测,把 heap-use-after-free、heap-buffer-overflow 拦在合并前;长期运行的服务定期做内存一致性检查,关注分配量随时间的变化。glibc 的 safe-linking 和一致性校验只能提高门槛,替代不了这些代码层面的约束。

靶场里能验证的练习

  1. 写一个程序,连续 malloc 三块 32 字节内存,打印地址和 malloc_usable_size,在 gdb 里用 x/8gx 查看每块前方的 size 字段,确认块大小的对齐规律。
  2. 复现 UAF:分配、写入、释放、打印旧指针;再分配同样大小的一块,比较两个指针是否相同,解释为什么。
  3. 复现 double free,记录终端提示和退出码;再用 GLIBC_TUNABLES=glibc.malloc.tcache_count=0 关闭 tcache 重跑,比较提示差异。
  4. 写一个越界 8 字节的堆写,观察是否立刻崩溃;用 -fsanitize=address -g 编译同一段代码,对比 ASAN 报出的调用栈。
  5. 用 ldd --version 记录本机 glibc 版本,再查该版本是否启用 safe-linking,说明它对「直接改写空闲块 next 指针」这类做法的影响。
环境说明:本文的 glibc 行为都在 Debian 12 虚拟机上实测,glibc 2.36(ldd (Debian GLIBC 2.36-9+deb12u14)),gcc 12.2.0。三个 malloc(32) 的地址间隔是 48,malloc_usable_size 返回 40,chunk 头 8 字节是 0x31;double free 默认报 free(): double free detected in tcache 2、退出码 134,关掉 tcache 后改报 double free or corruption (fasttop);越界写报 double free or corruption (out);ASAN 版本报 heap-buffer-overflow 与 WRITE of size 40。不同发行版的 glibc 差异很大,请以靶场上的实际输出为准。

小结

三句话收一下:堆块由管理头和用户区组成,size 字段决定分配器怎么找下一块,越界写改坏它就是大多数堆崩溃的源头;free 只标记空闲、不清空内容,所以 UAF 和 double free 都能在之后很久才暴露;堆的行为和 glibc 版本强绑定,先确认版本,再谈现象。

下一篇回到工具:前面几篇一直在说「用 gdb 看」「用 checksec 查」「用 pwntools 算」,但真正坐到机器前,第一步该敲什么、断点下在哪、输出怎么读,仍然容易乱。下一篇把这些动作串成一条固定的调试工作流,开头就给出在 Windows 上装 WSL2 或 Docker 的完整步骤(环境一节),装好再回来复现堆错误。