异常篇—— VEH 与 SEH
写在前面
此系列是本人一个字一个字码出来的,包括示例和实验截图。由于系统内核的复杂性,故可能有错误或者不全面的地方,如有错误,欢迎批评指正,本教程将会长期更新。 如有好的建议,欢迎反馈。码字不易,如果本篇文章有帮助你的,如有闲钱,可以打赏支持我的创作。如想转载,请把我的转载信息附在文章后面,并声明我的个人信息和本人博客地址即可,但必须事先通知我。
你如果是从中间插过来看的,请仔细阅读 羽夏看Win系统内核——简述 ,方便学习本教程。
看此教程之前,问几个问题,基础知识储备好了吗?保护模式篇学会了吗?练习做完了吗?没有的话就不要继续了。
🔒 华丽的分割线 🔒
概述
当用户异常产生后,内核函数
KiDispatchException并不是像处理内核异常那样在0环直接进行处理 ,而是修正3环EIP为
KiUserExceptionDispatcher函数后就结束了。这样,当线程再次回到3环时,将会从
KiUserExceptionDispatcher函数开始执行,这个函数就是我们重点关注对象,我们先看一下它的流程:
- 调用
RtlDispatchException
,查找并执行异常处理函数。 - 如果
RtlDispatchException
返回真,调用ZwContinue
再次进入0环,但线程再次返回3环时,会从修正后的位置开始执行。 - 如果
RtlDispatchException
返回假,调用ZwRaiseException
进行第二轮异常分发。
看完上面的流程之后,我们看看其反汇编:
; void __stdcall __noreturn KiUserExceptionDispatcher(PEXCEPTION_RECORD ExceptionRecord, PCONTEXT ContextFrame) public _KiUserExceptionDispatcher@8 _KiUserExceptionDispatcher@8 proc near ; DATA XREF: .text:off_7C923428↑o var_C = dword ptr -0Ch var_8 = dword ptr -8 var_4 = dword ptr -4 ExceptionRecord = dword ptr 4 ContextFrame = dword ptr 8 mov ecx, [esp+ExceptionRecord] mov ebx, [esp] push ec 56c x ; ContextRecord push ebx ; ExceptionRecord call _RtlDispatchException@8 ; RtlDispatchException(x,x) or al, al jz short loc_7C92E47A pop ebx pop ecx push 0 push ecx call _ZwContinue@8 ; ZwContinue(x,x) jmp short loc_7C92E485 ; --------------------------------------------------------------------------- loc_7C92E47A: ; CODE XREF: KiUserExceptionDispatcher(x,x)+10↑j pop ebx pop ecx push 0 ; FirstChance push ecx ; ContextRecord push ebx ; ExceptionRecord call _ZwRaiseException@12 ; ZwRaiseException(x,x,x) loc_7C92E485: ; CODE XREF: KiUserExceptionDispatcher(x,x)+1C↑j add esp, -14h mov [esp+EXCEPTION_RECORD.ExceptionCode], eax mov [esp+EXCEPTION_RECORD.ExceptionFlags], 1 mov [esp+EXCEPTION_RECORD.ExceptionRecord], ebx mov [esp+EXCEPTION_RECORD.NumberParameters], 0 push esp ; ExceptionRecord call 56c _RtlRaiseException@4 ; RtlRaiseException(x) _KiUserExceptionDispatcher@8 endp ; sp-analysis failed
可以看出该函数会调用
RtlDispatchException,为了节省篇幅用伪代码如下:
BOOLEAN __stdcall RtlDispatchException(PEXCEPTION_RECORD ExceptionRecord, PCONTEXT ContextRecord) { // [COLLAPSED LOCAL DECLARATIONS. PRESS KEYPAD CTRL-"+" TO EXPAND] result = 0; if ( RtlCallVectoredExceptionHandlers(ExceptionRecord, ContextRecord) ) return 1; RtlpGetStackLimits(&LowLimit, &HighLimit); ExceptionRecorda = 0; exRecord = RtlpGetRegistrationHead(); // ExceptionList if ( exRecord != -1 ) { while ( 1 ) { if ( exRecord < LowLimit || &exRecord[1] > HighLimit || (exRecord & 3) != 0 || (handler = exRecord->Handler, handler >= LowLimit) && handler < HighLimit || !RtlIsValidHandler(exRecord->Handler) ) { ExceptionRecord->ExceptionFlags |= EXCEPTION_STACK_INVALID; return result; } if ( byte_7C99B3FA < 0 ) v11 = RtlpLogExceptionHandler(ExceptionRecord, ContextRecord, 0, exRecord, 0x10u); RtlpExecuteHandlerForException(ExceptionRecord, exRecord, ContextRecord, &a4, exRecord->Handler); v6 = v5; if ( byte_7C99B3FA < 0 56c ) RtlpLogLastExceptionDisposition(v11, v5); if ( ExceptionRecorda == exRecord ) { ExceptionRecord->ExceptionFlags &= 0xFFFFFFEF; ExceptionRecorda = 0; } if ( !v6 ) break; if ( v6 == 1 ) { if ( (ExceptionRecord->ExceptionFlags & 8) != 0 ) return result; } else { if ( v6 != 2 ) { e.ExceptionCode = EXCEPTION_INVALID_DISPOSITION; e.ExceptionFlags = 1; e.ExceptionRecord = ExceptionRecord; e.NumberParameters = 0; RtlRaiseException(&e); } v8 = a4; ExceptionRecord->ExceptionFlags |= EXCEPTION_NESTED_CALL; if ( v8 > ExceptionRecorda ) ExceptionRecorda = v8; } exRecord = exRecord->Next; if ( exRecord == -1 ) return result; } if ( (ExceptionRecord->ExceptionFlags & 1) != 0 ) { e.ExceptionCode = EXCEPTION_NONCONTINUABLE_EXCEPTION; e.ExceptionFlags = EXCEPTION_NONCONTINUABLE; e.ExceptionRecord = ExceptionRecord; e.NumberParameters = 0; RtlRaiseException(&e); } result = 1; } return result; }
RtlCallVectoredExceptionHandlers这个函数就是用来执行
VEH的。如果返回假,则说明没有,后面的< ad0 code>RtlpGetRegistrationHead就会获取
SEH,如果有就执行,它是在堆栈中的。
有了这些铺垫后,我们来介绍
VEH和
SEH。
VEH
对于
VEH,这个是
XP及其之后才有的,中文为向量化异常结构处理。我们先看看它的处理流程:
CPU
捕获异常信息;- 通过
KiDispatchException
进行分发; KiUserExceptionDispatcher
调用RtlDispatchException
;RtlDispatchException
查找VEH
处理函数链表 并调用相关处理函数;- 代码返回到
KiUserExceptionDispatcher
; - 调用
ZwContinue
再次进入0环(ZwContinue
调用NtContinue
,主要作用就是恢复_TRAP_FRAME
然后通过KiServiceExit
返回到3环); - 线程再次返回3环后,从修正后的位置开始执行;
如下是执行
VEH的伪代码:
BOOLEAN __stdcall RtlCallVectoredExceptionHandlers(PEXCEPTION_RECORD ExceptionRecord, PCONTEXT ContextRecord) { PRTL_VECTORED_HANDLER_ENTRY p; // esi int (__stdcall *VectoredHandler)(EXCEPTION_POINTERS *); // eax EXCEPTION_POINTERS ExceptionInfo; // [esp+4h] [ebp-8h] BYREF BOOLEAN v6; // [esp+17h] [ebp+Bh] if ( IsListEmpty(&RtlpCalloutEntryList) ) return 0; ExceptionInfo.ExceptionRecord = ExceptionRecord; ExceptionInfo.ContextRecord = ContextRecord; RtlEnterCriticalSection(&RtlpCalloutEntryLock); for ( p = RtlpCalloutEntryList.Flink; ; p = p->ListEntry.Flink ) { if ( p == &RtlpCalloutEntryList ) { v6 = 0; goto EndProc; } VectoredHandler = RtlDecodePointer(p->VectoredHandler); if ( VectoredHandler(&ExceptionInfo) == -1 ) break; } v6 = 1; EndProc: RtlLeaveCriticalSection(&RtlpCalloutEntryLock); return v6; }
剩余的细节将会在总结与提升进行讲解,下面我们来看看如何使用
VEH,如下是实验代码:
#include "stdafx.h" #include <windows.h> #include <stdlib.h> typedef PVOID (NTAPI *VectoredExceptionHandler)(ULONG,_EXCEPTION_POINTERS*); LONG NTAPI MyVectoredExceptionHandler(PEXCEPTION_POINTERS pExceptionInfo) { puts("进入异常处理函数……"); if (pExceptionInfo->ExceptionRecord->ExceptionCode==0xC0000094) { puts("异常函数处理了……"); pExceptionInfo->ContextRecord->Ecx = 1; return EXCEPTION_CONTINUE_EXECUTION; } 3ba4 return EXCEPTION_CONTINUE_SEARCH; } int main(int argc, char* argv[]) { HMODULE lib = LoadLibrary("kernel32.dll"); VectoredExceptionHandler AddVectoredExceptionHandler = (VectoredExceptionHandler)GetProcAddress(lib,"AddVectoredExceptionHandler"); AddVectoredExceptionHandler(1,(_EXCEPTION_POINTERS*)&MyVectoredExceptionHandler); _asm { xor edx,edx; xor ecx,ecx; mov eax,0x10; idiv ecx; } puts("继续执行……"); system("pause"); return 0; }
执行后会正常执行,并显示异常处理信息。
SEH
SEH意为结构化异常处理,它的结构如下图所示:
也就是说包装的异常处理项目是以单向链表的形式管理的。必须具有两个如上图所示的成员,也就是说,这个结构是可以扩展的,有关扩展的将会在后续介绍,下面我们来看实验代码:
#include "stdafx.h" #include <windows.h> #include <stdlib.h> struct MyException { MyException* prev; DWORD handle; }; EXCEPTION_DISPOSITION MyExceptionHandler(_EXCEPTION_RECORD* ExceptionRecord,void* Establisherframe,CONTEXT* context,void* DispatcherContext) { puts("进入异常处理……"); if (ExceptionRecord->ExceptionCode==0xC0000094) { puts("开始处理异常……"); context->Eip+=2; return ExceptionContinueExecution; } return ExceptionContinueSearch; } int main(int argc, char* argv[]) { DWORD tmp; //初始化异常结构 MyException ex={(MyException*)tmp,(DWORD)MyExceptionHandler}; //加入 SEH _asm { mov eax,fs:[0]; mov tmp,eax; lea ecx,ex; mov fs:[0],ecx; } //制造异常 _asm { xor edx,edx; xor ecx,ecx; mov eax,0x10; idiv ecx; } //撤掉 SEH _asm { mov eax,tmp; mov fs:[0],eax; } puts("正常运行……"); system("pause"); return 0; }
该程序正常执行,并打印异常处理结果。
编译器扩展 SEH
初识
前面我们用自己的方式实现了
SEH的使用。异常处理很重要,但是,这个对于开发者很不友好。每次都要构造
SEH,退出函数要撤掉。编译器提供了关键字,并对
SEH进行了扩充,使用如下图所示:
_try // 挂入 SEH 链表 { } _except(/*过滤表达式*/) //异常过滤 { //异常处理程序 }
对于过滤表达式的结果值,只能是
-1、
0、
1,它们表示的含义如下:
EXCEPTION_EXECUTE_HANDLER
(1) 执行except
里面的代码EXCEPTION_CONTINUE_SEARCH
(0) 寻找下一个异常处理函数EXCEPTION_CONTINUE_EXECUTION
(-1) 返回出错位置重新执行
我说只能是这三值,并没有说只能写这三个数字,你可以写入表达式或者函数,使其得到的结果或者返回值是这仨值其中之一就可以,如下是我们的实验程序:
#include "stdafx.h" #include <stdlib.h> int main(int argc, char* argv[]) { _try { _asm { xor edx,edx; xor ecx,ecx; mov eax,0x10; idiv ecx; } puts("继续跑……"); }_except(1) { puts("异常处理……"); } system("pause"); return 0; }
运行该程序,只打印了
except里面的,得到正确结果。
初步深入
我们接下来在汇编层面查看它是如何实现的,首先我们查看一下编译器为我们扩展的结构,否则看代码是看不懂的。
struct _EXCEPTION_REGISTRATION { struct _EXCEPTION_REGISTRATION *prev; void (*handler)(PEXCEPTION_RECORD, PEXCEPTION_REGISTRATION, PCONTEXT, PEXCEPTION_RECORD); struct scopetable_entry *scopetable; int trylevel; int _ebp; };
然后我们所谓的结构就成立这样子:
图中的
_except_handler3是啥我们看它的反汇编是什么就知道了:
#include "stdafx.h" #include <stdlib.h> int main(int argc, char* argv[]) { 00401010 push ebp 00401011 mov ebp,esp 00401013 push 0FFh 00401015 push offset string "\xd2\xec\xb3\xa3\xb4\xa6\xc0\xed"+0Ch (00424030) 0040101A push offset __except_handler3 (00401400) 0040101F mov eax,fs:[00000000] 00401025 push eax 00401026 mov dword ptr fs:[0],esp 0040102D add esp,0B8h 00401030 push ebx 00401031 push esi 00401032 push edi 00401033 mov dword ptr [ebp-18h],esp 00401036 lea edi,[ebp-58h] 00401039 mov ecx,10h 0040103E mov eax,0CCCCCCCCh 00401043 rep stos dword ptr [edi] _try 00401045 mov dword ptr [ebp-4],0 { _asm { xor edx,edx; 0040104C xor edx,edx xor ecx,ecx; 0040104E xor ecx,ecx mov eax,0x10; 00401050 mov eax,10h idiv ecx; 00401055 idiv eax,ecx } puts("继续跑……"); 00401057 push offset string "\xd2\xec\xb3\xa3\xb4\xa6\xc0\xed" (00424024) 0040105C call puts (004011e0) 00401061 add esp,4 }_except(1) 00401064 mov dword ptr [ebp-4],0FFFFFFFFh 0040106B jmp $L865+17h (0040108a) $L864: 0040106D mov eax,1 $L866: 00401072 ret $L865: 00401073 mov esp,dword ptr [ebp-18h] { puts("异常处理……"); 00401076 push offset string "\xd2\xec\xb3\xa3\xb4\xa6\xc0\xed\xa1\xad\xa1\xad" (00425140) 0040107B call puts (004011e0) 00401080 add esp,4 } 00401083 mov dword ptr [ebp-4],0FFFFFFFFh system("pause"); 0040108A push offset string "pause" (0042401c) 0040108F call system (004010d0) 00401094 add esp,4 return 0; 00401097 xor eax,eax } 00401099 mov ecx,dword ptr [ebp-10h] 0040109C mov dword ptr fs:[0],ecx 004010A3 pop edi 004010A4 pop esi 004010A5 pop ebx 004010A6 add esp,58h 004010A9 cmp ebp,esp 004010AB call __chkesp (004012d0) 004010B0 mov esp,ebp 004010B2 pop ebp 004010B3 ret
看不懂吗?我们来画个堆栈图,如下所示:
标注
*的表示原来的值,是不是和结构体的成员对应起来了?注意不要以为只有黄色的区域,由于通常的函数采用
ebp寻址,所以我没有把
ebp*打上黄色底色。
下面我们来看看
scopetable成员,它的结构如下:
struct scopetable_entry { DWORD previousTryLevel; //上一个try{}结构编号 PDWRD lpfnFilter; //过滤函数的起始地址 PDWRD lpfnHandler; //异常处理程序的地址 }
我们来看看这个结构的内容是啥,最终它的成员如下:
scopetable.previousTryLevel = -1; scopetable.lpfnFilter = 0x40106D; scopetable.lpfnHandler = 0x401073;
正好把代码指令和地址逐个对应起来了。
继续深入
如果异常处理有嵌套调用的情况会是怎么样呢?如下是测试代码:
#include "stdafx.h" #include <stdlib.h> int main(int argc, char* argv[]) { _try { _try { _asm { xor edx,edx; xor ecx,ecx; mov eax,0x10; idiv ecx; } }_except(1) { puts("测试"); } puts("继续跑……"); }_except(1) { puts("异常处理……"); } system("pause"); return 0; }
然后查看反汇编结果:
#include "stdafx.h" #include <stdlib.h> int main(int argc, char* argv[]) { 00401010 push ebp 00401011 mov ebp,esp 00401013 push 0FFh 00401015 push offset string "\xb2\xe2\xca\xd4"+0Ch (00424050) 0040101A push offset __except_handler3 (00401450) 0040101F mov eax,fs:[00000000] 00401025 push eax 00401026 mov dword ptr fs:[0],esp 0040102D add esp,0B8h 00401030 push ebx 00401031 push esi 00401032 push edi 00401033 mov dword ptr [ebp-18h],esp 00401036 lea edi,[ebp-58h] 00401039 mov ecx,10h 0040103E mov eax,0CCCCCCCCh 00401043 rep stos dword ptr [edi] _try 00401045 mov dword ptr [ebp-4],0 { _try 0040104C mov dword ptr [ebp-4],1 { _asm { xor edx,edx; 00401053 xor edx,edx xor ecx,ecx; 00401055 xor ecx,ecx mov eax,0x10; 00401057 mov eax,10h idiv ecx; 0040105C idiv eax,ecx } }_except(1) 0040105E mov dword ptr [ebp-4],0 00401065 jmp $L872+17h (0040f5d4) $L871: 00401067 mov eax,1 $L873: 0040106C ret $L872: 0040106D mov esp,dword ptr [ebp-18h] { puts("测试"); 00401070 push offset string "\xb2\xe2\xca\xd4" (00424044) 00401075 call puts (00401230) 0040107A add esp,4 } 0040107D mov dword ptr [ebp-4],0 puts("继续跑……"); 00401084 push offset string "\xbc\xcc\xd0\xf8\xc5\xdc\xa1\xad\xa1\xad" (00424034) 00401089 call puts (00401230) 0040108E add esp,4 }_except(1) 00401091 mov dword ptr [ebp-4],0FFFFFFFFh 00401098 jmp $L868+17h (004010b7) $L867: 0040109A mov eax,1 $L869: 0040109F ret $L868: 004010A0 mov esp,dword ptr [ebp-18h] { puts("异常处理……"); 004010A3 push offset string "\xd2\xec\xb3\xa3\xb4\xa6\xc0\xed\xa1\xad\xa1\xad" (00424024) 004010A8 call puts (00401230) 004010AD add esp,4 } 004010B0 mov dword ptr [ebp-4],0FFFFFFFFh system("pause"); 004010B7 push offset string "pause" (0042401c) 004010BC call system (00401120) 004010C1 add esp,4 return 0; 004010C4 xor eax,eax } 004010C6 mov ecx,dword ptr [ebp-10h] 004010C9 mov dword ptr fs:[0],ecx 004010D0 pop edi 004010D1 pop esi 004010D2 pop ebx 004010D3 add esp,58h 004010D6 cmp ebp,esp 004010D8 call __chkesp (00401320) 004010DD mov esp,ebp 004010DF pop ebp 004010E0 ret
看代码发现还是只是挂了一次,我们得看看
scopetable的内容是啥了:
00425168 FFFFFFFF 0040109A 004010A0 00425174 00000000 00401067 0040106D 00425180 00000000 00000000 00000000 0042518C 00000000 00000000 00000000
可以看到,这里有两个成员了。
finally 关键字
当然不仅仅有
try_except,还可以使用
finally,该关键字的作用就是只要退出
try就执行里面的函数,无论通过那种方式,如下是我们的实验代码:
#include "stdafx.h" #include <stdlib.h> int main(int argc, char* argv[]) { _try { return 0; }__finally { puts("异常处理……"); system("pause"); } return 0; }
执行结果如下:
异常处理…… 请按任意键继续. . .
然后我们看看它在汇编层面是如何实现的,其反汇编如下:
#include "stdafx.h" #include <stdlib.h> int main(int argc, char* argv[]) { 00401010 push ebp 00401011 mov ebp,esp 00401013 push 0FFh 00401015 push offset string "stream != NULL"+10h (00425168) 0040101A push offset __except_handler3 (00401450) 0040101F mov eax,fs:[00000000] 00401025 push eax 00401026 mov dword ptr fs:[0],esp 0040102D add esp,0B4h 00401030 push ebx 00401031 push esi 00401032 push edi 00401033 lea edi,[ebp-5Ch] 00401036 mov ecx,11h 0040103B mov eax,0CCCCCCCCh 00401040 rep stos dword ptr [edi] _try 00401042 mov dword ptr [ebp-4],0 00401049 push 0FFh 0040104B mov dword ptr [ebp-1Ch],0 { 00401052 lea eax,[ebp-10h] 00401055 push eax 00401056 call __local_unwind2 (0040139a) 0040105B add esp,8 return 0; 0040105E mov eax,dword ptr [ebp-1Ch] 00401061 jmp $L865+2 (00401080) }__finally { puts("异常处理……"); 00401063 push offset string "\xd2\xec\xb3\xa3\xb4\xa6\xc0\xed\xa1\xad\xa1\xad" (00424024) 00401068 call puts (00401230) 0040106D add esp,4 system("pause"); 00401070 push offset string "pause" (0042401c) 00401075 call system (00401120) 0040107A add esp,4 $L863: 0040107D ret } 17: return 0; 0040107E xor eax,eax } 00401080 mov ecx,dword ptr [ebp-10h] 00401083 mov dword ptr fs:[0],ecx 0040108A pop edi 0040108B pop esi 0040108C pop ebx 0040108D add esp,5Ch 00401090 cmp ebp,esp 00401092 call __chkesp (00401320) 00401097 mov esp,ebp 00401099 pop ebp 0040109A ret
可以看到在调用
return 0;之前,被插入了调用
__local_unwind2函数,正是这个函数能够调用
finally里面的代码的:
__local_unwind2: 0040139A push ebx 0040139B push esi 0040139C push edi 0040139D mov eax,dword ptr [esp+10h] 004013A1 push eax 004013A2 push 0FEh 004013A4 push offset __global_unwind2+20h (00401378) 004013A9 push dword ptr fs:[0] 004013B0 mov dword ptr fs:[0],esp 004013B7 mov ad0 eax,dword ptr [esp+20h] 004013BB mov ebx,dword ptr [eax+8] 004013BE mov esi,dword ptr [eax+0Ch] 004013C1 cmp esi,0FFh 004013C4 je __NLG_Return2+2 (004013f4) 004013C6 cmp esi,dword ptr [esp+24h] 004013CA je __NLG_Return2+2 (004013f4) 004013CC lea esi,[esi+esi*2] 004013CF mov ecx,dword ptr [ebx+esi*4] 004013D2 mov dword ptr [esp+8],ecx 004013D6 mov dword ptr [eax+0Ch],ecx 004013D9 cmp dword ptr [ebx+esi*4+4],0 004013DE jne __NLG_Return2 (004013f2) 004013E0 push 101h 004013E5 mov eax,dword ptr [ebx+esi*4+8] 004013E9 call __NLG_Notify (0040142e) 004013EE call dword ptr [ebx+esi*4+8] __NLG_Return2: 004013F2 jmp __local_unwind2+1Dh (004013b7) 004013F4 pop dword ptr fs:[0] 004013FB add esp,0Ch 004013FE pop edi 004013FF pop esi 00401400 pop ebx 00401401 ret
关键调用在
call dword ptr [ebx+esi*4+8],执行这个就会调用
finally里的代码,这个调用流程又被成为异常展开。具体详细的其他细节将会在总结与提升进行介绍。
下一篇
异常篇——总结与提升
- 采用Win32结构化异常(SEH)捕捉所有未捕捉的异常[C++]
- MFC异常打印调用堆栈整合SEH异常和日志文件类
- Win32 SEH异常深度探索_9 总结
- Win32 SEH异常深度探索_5 一个异常帧链表遍历例子
- 总结 • SEH 与 C++ 异常模型
- Windows 系统编程初探 (四)结构化异常处理之一:SEH的基本原理与进程相关异常处理
- SEH 与 C++ 异常模型的混合使用
- SEH(结构异常处理)
- 用c++ try-catch 异常处理模块实现SEH底层异常处理。
- 如何把SEH类型的系统异常转化为C++类型的异常
- windows核心编程--SEH(结构异常处理)
- windows核心编程--SEH(结构异常处理)
- Win32 SEH异常深度探索_6 回退
- 把SEH类型的系统异常转化为C++类型的异常
- 异常处理与MiniDump详解 SEH(Structured Exception Handling)
- Win32 SEH异常深度探索_7 对未处理异常的默认处理
- 如何把SEH类型的系统异常转化为C++类型的异常
- SEH不能捕获异常
- Win32 SEH异常深度探索_8 异常处理是如何开始的
- System.Runtime.InteropService.SEHException外部组件发生异常