重读《0day安全》(三)SEH 劫持,以及 GS、SafeSEH、SEHOP

4497 字
22 分钟
重读《0day安全》(三)SEH 劫持,以及 GS、SafeSEH、SEHOP
这篇文章也有English版。

《重读〈0day安全〉》系列第三篇,基于《0day安全:软件漏洞分析技术(第2版)》(failwest 等著)的实验笔记,2020 年写,2026 年整理。这一篇把异常处理相关的四五篇笔记并在一起,先讲怎么覆盖 SEH 劫持流程,再依次看针对它的三道保护 GS、SafeSEH、SEHOP 是怎么工作、又能怎么绕的。书里好几段弹窗用的都是第一篇那段动态找 API 的 shellcode,这里就不重复整段贴了。

SEH 是什么#

  • SEH 是异常处理结构体(Structured Exception Handler),是 Windows 异常处理机制里的重要数据结构。每个 SEH 记录包含两个 DWORD,一个指向下一个 SEH 记录,一个是异常处理函数的地址,一共 8 个字节
  • SEH 结构存放在栈中
  • 线程初始化时,自动向栈中安装一个 SEH 作为线程默认的异常处理
  • 如果源代码里用了 try-except 这类异常处理,编译器最终是通过向当前函数栈帧里安装一个 SEH 来实现的
  • 栈中一般会同时存在多个 SEH
  • 栈里的多个 SEH 通过”下一个”指针由栈顶向栈底串成单向链表,链表最顶端(离栈顶最近)的那个由 TEB 偏移 0 处的指针标识
  • 异常发生时,系统从 TEB 的 0 偏移处取出离栈顶最近的 SEH,用它的处理函数来处理异常
  • 当离事故现场最近的处理函数失败时,顺着链表依次尝试后面的
  • 如果所有自己安装的都处理不了,系统采用默认处理函数,弹出错误对话框然后强制关闭程序

覆盖 SEH 的思路#

  • SEH 存放在栈内,溢出缓冲区的数据可以淹没它
  • 把 SEH 记录里的处理函数地址改成 shellcode 的起始地址
  • 溢出后错误的栈帧或堆块数据会触发异常
  • 系统开始处理异常后,就把 shellcode 当成异常处理函数执行了

好处很明显,不用等到函数 ret,只要制造一个异常就能触发。像下面这样一段除 0 就够了。

栈上覆盖 SEH#

实验环境是 Windows 2000。先用一段全 NOP 的”shellcode”看看覆盖到哪里。

void test(char* input)
{
char buf[200];
int zero = 0;
__asm int 3 // break for debug
__try
{
strcpy(buf, input); // overrun the stack
zero = 4 / zero; // generate an exception
}
__except(MyExceptionhandler()){}
}

调试的时候看到这么几条:

  • 0x0012FE98 是 shellcode 的起始位置
  • 当前线程一共安装了 3 个 SEH,离栈顶最近的位于 0x0012FF68,这是最先被调用的
  • 要覆盖的是 0x0012FF6C,也就是它的处理函数地址,把这里填成 shellcode 起始地址 0x0012FE98 即可

然后把 input 换成”真 shellcode + 覆盖到 SEH 的尾巴”:前面放第一篇那段弹窗 shellcode,末尾这样接:

... (前面是弹窗 shellcode,省略) ...
90 90 90 90 ; 下一个 SEH 记录,随便填
98 FE 12 00 ; SEH 处理函数地址 = 0x0012FE98,指向 shellcode

strcpy 溢出盖掉 SEH,zero = 4 / zero 触发除 0 异常,系统就去”处理”我们的 shellcode,弹窗成功。

堆上覆盖 SEH#

同样的思路也能用在堆溢出上。shellcode 放在堆里,用 DWORD SHOOT 把 SEH 记录改成堆里 shellcode 的地址,再制造异常触发。结构和第二篇的 DWORD SHOOT 一样,只是打击目标从 PEB 函数指针换成了 SEH。


深入异常分发#

把整条路走一遍,后面讲绕过才有参照。

不同级别的异常处理#

  • 异常处理的最小作用域是线程,每个线程有自己的 SEH 链,出错时先用自己的链处理
  • 一个进程里可能有很多线程,进程也有一个能处理全局的异常处理。线程自己的 SEH 修不好时,交给进程的处理
  • 系统还给所有程序兜底,当所有处理函数都失败,系统默认的异常处理函数被调用,一般就是弹个崩溃框

线程级的回调函数和 unwind#

用于异常处理的回调函数有 4 个参数:

  • pExcept:指向 EXCEPTION_RECORD,含异常类型、发生地址等
  • pFrame:指向栈帧里的 SEH 结构体
  • pContext:指向 CONTEXT,含所有寄存器状态
  • pDispatch:dispatcher context

回调返回值有两种:

  • 0 (ExceptionContinueExecution):异常处理成功,回到出错处继续执行
  • 1 (ExceptionContinueSearch):处理失败,顺着链找下一个

还有一个 UNWIND 操作,系统顺着链找到能处理的句柄后,会把之前遍历过(但处理失败)的那些 SEH 再调用一遍,通知它们”你被放弃了,清理现场释放资源”,然后把它们从链表里摘掉。unwind 调用时 EXCEPTION_RECORD 的 ExceptionFlags 会被设成 EH_UNWINDING(0x2),由 ntdll 的 RtlUnwind 实现。另外,调用回调之前系统会先判断是不是调试态,是的话把异常先交给调试器。

进程级与 UEF#

线程链都失败后,交给进程异常处理(用 SetUnhandledExceptionFilter 注册)。再失败,就到系统默认的 UnhandledExceptionFilter(),也就是顶层异常处理 UEF(Unhandled Exception Filter)。在 2000/XP 上,这个函数会查注册表 HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\AeDebug,Auto 项决定弹不弹框,Debugger 项指定默认调试器。

整条流程#

  • CPU 捕获异常,内核接过去做内核态处理
  • 内核处理完,交还用户态
  • 用户态第一个处理异常的是 ntdll 的 KiUserExceptionDispatcher()
  • 它先看是否调试态,是就交给调试器
  • 然后走 VEH(向量化异常处理)
  • 非调试态,调用 RtlDispatchException() 遍历线程 SEH 链,找到处理函数后做 unwind
  • 栈里的 SEH 都失败,调进程异常处理
  • 还失败,调 UEF

顺带几个别的下手点#

  • VEH,XP 起新增的向量化异常处理,基于进程、用 API 注册、串成双向链表、保存在堆里,优先级高于 SEH。用堆溢出 DWORD SHOOT 改指向 VEH 头节点的指针,异常开始后就能引导到 shellcode
  • 攻击 TEB 里的 SEH 头指针,也就是改 TEB 第一个 DWORD。局限是多线程程序里 TEB 不好定位(第一个 TEB 在 0x7FFDE000,之后每个相隔 0x1000 向低地址增长),所以一般只对单线程程序用
  • 攻击 UEF。DWORD SHOOT 的 target 指向 UEF 入口,data 填 shellcode 入口,再造一个只能由 UEF 处理的异常。异常发生时 EDI 往往指向堆中离 shellcode 不远处,把 UEF 句柄覆盖成一条 CALL DWORD PTR [EDI + 0x78](或 [ESI + 0x4C]、[EBP + 0x74])的指令地址,往往就能跳进去
  • 攻击 PEB 里的函数指针。ExitProcess 清理现场时要进临界区同步,最终会调 RtlEnterCriticalSection,而 PEB 地址在 XP SP2 前固定不变,比 TEB 更好用(见第二篇)

off-by-one#

利用技术大致分几层,从基础栈溢出(改返回地址) → 高级栈溢出(只能盖到部分 EBP,够不到返回地址,比如 strncpy 误用造成的 off-by-one) → 堆溢出和格式化串。

void off_by_one(char * input)
{
char buf[200];
int i = 0, len = 0;
len = sizeof(buf);
for(i = 0; input[i] && (i <= len); i++) // i <= len 多走一步
{
buf[i] = input[i];
}
}

这函数想防越界,但 i <= len 在边界上错了一位,可能溢出一个字节,刚好能盖到 EBP 最低字节,从而在一定范围内控制 EBP。


到这里都是”怎么打”。XP SP2 以后,针对上面这几条路,微软加了 GS、SafeSEH、SEHOP 三道保护,下面一道一道看。

原理#

  • Visual Studio 2003(VС7.0)起默认启用(Buffer Security Check)
  • 每次函数调用时,向栈帧里压一个额外的随机 DWORD,叫 canary 或 Security Cookie
  • cookie 位于 EBP 之前,系统还在 .data 里存了一份副本
  • 栈溢出时,cookie 会先于 EBP 和返回地址被盖掉
  • 函数返回前做一次 Security Check,比较栈里的 cookie 和 .data 副本,不一致就说明溢出了,进异常流程,函数不正常返回,ret 也不执行
  • 有性能代价,所以以下情况不加 GS:函数不含缓冲区;变参函数;用 naked 等关键字标记;第一条语句是内嵌汇编;缓冲区不是 8 字节类型且不大于 4 字节
  • 因为这些例外出过问题,VS2005 SP1 引入 #pragma strict_gs_check 给任意函数加 cookie
  • 还有变量重排,按局部变量类型调整它们在栈帧里的位置,把字符串挪到高地址,避免字符串溢出破坏其它变量;把指针和字符串参数复制到低地址

cookie 的细节是这样的。以 .data 第一个 DWORD 作为种子(原始 cookie),每次运行不同;栈帧初始化后用 ESP 异或种子得到当前函数的 cookie,增加随机性;返回前再用 ESP 异或还原出种子来比较。反汇编看得很清楚:

; 函数开头计算 cookie
mov eax, dword ptr ds:[__security_cookie] ; 从 .data 取原 cookie
xor eax, ebp ; 和 ebp 异或
mov [ebp-0x4], eax ; 放在 ebp-0x4
; 函数返回前验证
mov ecx, [ebp-0x4]
xor ecx, ebp
call __security_check_cookie
; __security_check_cookie:
cmp ecx, dword ptr ds:[__security_cookie] ; 和 .data 副本比
jnz __report_gsfailure ; 不等就报错
rep retn

GS 的缺口#

GS 只保护栈帧返回地址这一块,所以有几个它管不到的地方:

  1. 改函数指针。GS 很难防基于改写函数指针的攻击
  2. 异常处理。GS 并不保护 SEH,所以可以在 cookie 检查之前,用覆盖 SEH 加制造异常来提前劫持流程。strcat 取到非法地址触发异常,根本等不到函数返回那次 cookie 检查
  3. 虚函数。只有函数返回时才检查栈,那就在返回前劫持。覆写 C++ 对象的虚表指针让它指向一个 pop/pop/ret 跳板,在调用虚函数的那一刻就跳进 shellcode。虚表攻击这部分放到第四篇细讲
  4. 正面硬刚。既然 cookie = .data 原始 cookie xor ebp,要是溢出能同时改掉栈里的 cookie 和 .data 里的原始 cookie,让它俩算出来还一致,检查就过了。书里构造了一个 i 为负数时能指到 .data 的例子来做这件事

书里”利用未保护内存突破 GS”那个例子(char arry[4] 本该不受保护却被保护了)我当年没搞清楚。按说 4 字节缓冲区不该加 GS,实测却有。现在回头看,是因为 GS 的判定不只看大小,arry 被当作数组、而且它的地址被取用(传给 strcpy),编译器的启发式就认为它有风险而加了保护。所以”缓冲区不大于 4 字节不保护”这条不能机械套。


SafeSEH 校验异常处理函数#

GS 既然管不住 SEH,微软就专门给 SEH 加了 SafeSEH。覆盖 SEH 时,它会在真正调用处理函数前做校验:

  • 检查异常处理链是否位于当前栈中,不在就终止调用
  • 检查处理函数指针是否指向当前栈中,指向栈中就终止调用(shellcode 常在栈上,这一条就挺致命)
  • 前两项过了,再调 RtlIsValidHandler() 验证处理函数的有效性:
    • 如果处理函数地址落在某个加载模块的内存范围内:
      • 该模块设了 IMAGE_DLLCHARACTERISTICS_NO_SEH?是则校验失败
      • 该模块有安全 SEH 表?有则拿处理函数地址去表里匹配,匹配上才算成功
      • 该模块是纯 IL(.NET)?是则校验失败
      • 处理函数在不可执行页上?是则看 DEP,没开 DEP 返回成功,开了就抛访问违例
    • 如果处理函数地址在所有加载模块之外:
      • 在不可执行页上?看 DEP,同上
      • 系统是否允许跳到模块外执行?允许返回成功,否则失败

下面这张是当年调试时截的 RtlIsValidHandler 判断过程里找到的跳板(CALL [EBP+0xC]):

找到的 CALL [EBP+0xC] 跳板
找到的 CALL [EBP+0xC] 跳板

绕过 SafeSEH 的三条路#

顺着上面的校验树,缺口也就出来了:

  1. 把 shellcode 放堆里。即使 SEH 校验判定处理函数”无效”,在某些路径下仍会被调用;更稳的是栈溢出只负责把 SEH 指向堆里的 shellcode,绕开对栈上地址的那条检查
  2. 借一个没开 SafeSEH 的模块当跳板。VC6 编译的 DLL 默认不开 SafeSEH。在这种模块里找一条 pop/pop/ret,用它的地址覆盖 SEH 处理函数,校验看到地址落在”一个没有安全 SEH 表的模块”里,判定通过,执行 pop/pop/ret 后 ret 又把我们带回 shellcode。(VC6 的 DLL 默认加载基址 0x10000000 带 0x00,会被 strcpy 截断,所以要用 /base:"0x11120000" 改一下基址)
  3. 借加载模块以外的地址。在模块范围外的内存里找 call/jmp dword ptr[ebp+N] 这类指令当跳板,绕过”必须是有效模块内句柄”的检查
注意

实现里有两个坑。一是 VS2008 编译的 __try{} 函数会在 Security Cookie+4 处压一个 -2(VC6 是 -1)作标记,异常处理时会改这个值,可能破坏 shellcode,所以跳板后面要垫 8 个 NOP;二是跳板 ret 回来的地方和 shellcode 本体之间常差几个字节,需要一次短跳(有时还要再一次长跳)跳进真正的入口。

浏览器版,借 Flash ActiveX 绕 SafeSEH#

第 2 条的浏览器版本。Flash Player ActiveX 在 9.0.124 之前不支持 SafeSEH,所以只要在这个控件里找到合适的跳板地址,就能绕过 SafeSEH:

  • 自己写一个有栈溢出的 MFC ActiveX 控件,用网页调用它触发溢出
  • 溢出盖掉 SEH 后,跳进 Flash 控件里找好的跳板
  • 从跳板再跳回栈上的 shellcode

当年实测,溢出字符串起始 0x01DCF4FC,离栈顶最近的异常函数地址在 0x01DCF610,填 0x114(276 字节)刚好盖到处理函数地址,第 277-280 字节放跳板。用 OllyFindAddr 的 Find CALL/JMP[EBP+N] 找到 0x300B2D1C 的 CALL [EBP+0xC](就是上面那张图)。跳板会跳到地址前 4 字节处,所以在那放一个短跳,shellcode 接在后面:

01DCF60C EB 06 jmp short 01DCF614 ; 跳过 4 字节到 shellcode
01DCF60E 90 90 nop nop
01DCF610 1C 2D (跳板地址低位)
01DCF612 0B 30 (跳板地址高位)
01DCF614 90 ; shellcode 从这开始

POC 页面用 JavaScript 把一串 邐(NOP)和跳板地址拼成 Unicode 字符串喂给控件的 test(),触发除 0 异常后在跳板断下,成功跳进 shellcode。


SEHOP 和整条链的完整性#

SafeSEH 校验单个处理函数,SEHOP 换个角度,检查整条 SEH 链有没有被破坏。核心是看链上最后一个处理函数是不是系统固定的那个终极异常处理函数。如果是,说明链没断;如果不是,说明中间被覆盖过,可能发生了 SEH 覆盖攻击,就不执行当前处理函数。

if (process_flags & 0x40 == 0) // 有 SEH 记录才检测
{
if (record != 0xFFFFFFFF)
{
do
{
if (record < stack_bottom || record > stack_top) // 记录必须在栈中
goto corruption;
if ((char *)record + sizeof(EXCEPTION_REGISTRATION) > stack_top) // 必须完整在栈中
goto corruption;
if ((record & 3) != 0) // 必须 4 字节对齐
goto corruption;
handler = record->handler;
if (handler >= stack_bottom && handler < stack_top) // 处理函数不能在栈中
goto corruption;
record = record->next;
} while (record != 0xFFFFFFFF); // 遍历整条链
}
if ((TEB->word_at_offset_0xFCA & 0x200) != 0)
{
if (handler != &FinalExceptionHandler) // 核心:最后一个必须是终极处理函数
goto corruption;
}
}

绕过思路#

  • 直接打返回地址或虚函数。如果函数开了 SEHOP 但没开 GS(或者刚好没加 GS),直接攻击返回地址即可;SEHOP 也不保护虚函数表,攻击虚函数照样成
  • 借没开 SEHOP 的模块。系统会按 PE 头里的 MajorLinkerVersion/MinorLinkerVersion 判断是否为某程序禁用 SEHOP(微软给一些加密壳如穿山甲 Armadillo 禁了)。把这两个值设成 0x53 和 0x52 就能模拟成 Armadillo 加壳程序,从而禁用 SEHOP
  • 伪造整条 SEH 链(前提是 ASLR 没开)。既然 SEHOP 就看”最后一个是不是终极处理函数”,那我就伪造一条链,让它末尾正好接上系统的终极处理函数地址,造成”链没断”的假象。配合一个没开 SafeSEH 的模块里的 pop/pop/ret 一起用,就能同时骗过 SafeSEH 和 SEHOP

一个实现细节,Win7 起 PEB_LDR_DATA 里第二个模块变成了 KernelBase,所以第一篇那段”取第二个节点当 kernel32”的 shellcode 要在中间加一条 mov ecx, [ecx](机器码 \x8B\x09)多走一个节点,才能在 Win7 上拿到 kernel32。


今天再看#

这一整篇,到 64 位时代基本改头换面了。

最根本的变化是,x64 上 SEH 不再放在栈里。64 位用的是表驱动异常处理,每个函数的 unwind 信息和异常处理器登记在 PE 的 .pdata/.xdata 里,是只读的,运行时栈上根本没有那条可以被溢出覆盖的 SEH 链。所以”覆盖 SEH 记录”这整类攻击,连同上面讲的 SafeSEH、SEHOP,都只在 32 位进程里才有意义。今天还能碰到 32 位 SEH 覆盖的场合,基本就是老的 32 位程序和某些嵌入式/工控软件。

GS cookie 还在,而且一直在加强,但它从来不是单独防线,只是纵深里的一层。真正让”改返回地址”这条路在现代 64 位进程上基本走不通的,是硬件强制的影子栈(Intel CET / Windows Hardware-enforced Stack Protection),ret 时 CPU 拿影子栈里那份返回地址对一下,对不上直接异常,改了栈上的返回地址也没用。

而第 3 点那个”GS 管不住虚函数指针”的缺口,恰恰是现代利用的主战场,所以微软专门加了 CFG(Control Flow Guard)和更严的 XFG 来管间接调用的目标。这块和虚表攻击一起,放到下一篇讲 DEP/ASLR 时再接着说。

文章分享

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

重读《0day安全》(三)SEH 劫持,以及 GS、SafeSEH、SEHOP
https://blog.lumysia.net/zh-cn/posts/reread-0day-3-seh-gs-safeseh-sehop/
作者
Livia
发布于
2020-10-25
许可协议
CC BY-NC 4.0

评论区

文章目录