Win32结构化异常处理（SEH）探秘(下)

核心提示：展开在挖掘展开（Unwinding）的实现代码之前让我们先来搞清楚它的意思，我在前面已经讲过所有可能的异常处理程序是如何被组织在一个由线程信息块的第一个DWORD（FS:[0]）所指向的链表中的，Win32结构化异常处理（SEH）探秘(下)，由于针对某个特定异常的处理程序可能不在这个链表的开头，因此就需要从链表中依次移

展开

在挖掘展开（Unwinding）的实现代码之前让我们先来搞清楚它的意思。我在前面已经讲过所有可能的异常处理程序是如何被组织在一个由线程信息块的第一个DWORD（FS:[0]）所指向的链表中的。由于针对某个特定异常的处理程序可能不在这个链表的开头，因此就需要从链表中依次移除实际处理异常的那个异常处理程序之前的所有异常处理程序。

正如你在Visual C++的__except_handler3函数中看到的那样，展开是由__global_unwind2这个运行时库（RTL）函数来完成的。这个函数只是对RtlUnwind这个未公开的API进行了非常简单的封装。（现在这个API已经被公开了，但给出的信息极其简单，详细信息可以参考最新的Platform SDK文档。）

__global_unwind2(void　*　pRegistFrame)
{

_RtlUnwind(　pRegistFrame,　&__ret_label,　0,　0　);
__ret_label:
}

虽然从技术上讲RtlUnwind是一个KERNEL32函数，但它只是转发到了NTDLL.DLL中的同名函数上。下面是我为此函数写的伪代码。

RtlUnwind 函数的伪代码：

　void　_RtlUnwind(　PEXCEPTION_REGISTRATION　pRegistrationFrame,

　PVOID　returnAddr,　//　并未使用！（至少是在i386机器上）

　PEXCEPTION_RECORD　pExcptRec,

　DWORD　_eax_value)
　{　

　DWORD　stackUserBase;

　DWORD　stackUserTop;

　PEXCEPTION_RECORD　pExcptRec;

　EXCEPTION_RECORD　exceptRec;

　CONTEXT　context;

　//　从FS:[4]和FS:[8]处获取堆栈的界限

　RtlpGetStackLimits(　&stackUserBase,　&stackUserTop　);

　if　(　0　==　pExcptRec　)　//　正常情况

　{

　pExcptRec　=　&excptRec;

　pExcptRec->ExceptionFlags　=　0;

　pExcptRec->ExceptionCode　=　STATUS_UNWIND;

　pExcptRec->ExceptionRecord　=　0;

　pExcptRec->ExceptionAddress　=　[ebp+4];　//　RtlpGetReturnAddress()—获取返回地址

　pExcptRec->ExceptionInformation[0]　=　0;

　}

　if　(　pRegistrationFrame　)

　pExcptRec->ExceptionFlags　|=　EXCEPTION_UNWINDING;

　else　　　　　　　//　这两个标志合起来被定义为EXCEPTION_UNWIND_CONTEXT

　pExcptRec->ExceptionFlags|=(EXCEPTION_UNWINDING|EXCEPTION_EXIT_UNWIND);

　context.ContextFlags　=(　CONTEXT_i486　|　CONTEXT_CONTROL　|

　CONTEXT_INTEGER　|　CONTEXT_SEGMENTS);

　RtlpCaptureContext(　&context　);

　context.Esp　+=　0x10;

　context.Eax　=　_eax_value;

　PEXCEPTION_REGISTRATION　pExcptRegHead;

　pExcptRegHead　=　RtlpGetRegistrationHead();　//　返回FS:[0]的值

　//　开始遍历EXCEPTION_REGISTRATION结构链表

　while　(　-1　!=　pExcptRegHead　)

　{

　EXCEPTION_RECORD　excptRec2;

　if　(　pExcptRegHead　==　pRegistrationFrame　)

　{


　NtContinue(　&context,　0　);

　}

　else

　{


　//　如果存在某个异常帧在堆栈上的位置比异常链表的头部还低


　//　说明一定出现了错误


　if　(　pRegistrationFrame　&&　(pRegistrationFrame　<=　pExcptRegHead)　)


　{


　//　生成一个异常


　excptRec2.ExceptionRecord　=　pExcptRec;


　excptRec2.NumberParameters　=　0;


　excptRec2.ExceptionCode　=　STATUS_INVALID_UNWIND_TARGET;


　excptRec2.ExceptionFlags　=　EXCEPTION_NONCONTINUABLE;


　RtlRaiseException(　&exceptRec2　);


　}

　}

　PVOID　pStack　=　pExcptRegHead　+　8;　//　8　=　sizeof(EXCEPTION_REGISTRATION)

　//　确保pExcptRegHead在堆栈范围内，并且是4的倍数

　if　(　(stackUserBase　<=　pExcptRegHead　)


　&&　(stackUserTop　>=　pStack　)


　&&　(0　==　(pExcptRegHead　&　3))　)

　{


　DWORD　pNewRegistHead;


　DWORD　retValue;


　retValue　=　RtlpExecutehandlerForUnwind(pExcptRec,　pExcptRegHead,　&context,


　&pNewRegistHead,　pExceptRegHead->handler　);


　if　(　retValue　!=　DISPOSITION_CONTINUE_SEARCH　)


　{


　if　(　retValue　!=　DISPOSITION_COLLIDED_UNWIND　)


　{



　excptRec2.ExceptionRecord　=　pExcptRec;



　excptRec2.NumberParameters　=　0;



　excptRec2.ExceptionCode　=　STATUS_INVALID_DISPOSITION;



　excptRec2.ExceptionFlags　=　EXCEPTION_NONCONTINUABLE;



　RtlRaiseException(　&excptRec2　);


　}


　else



　pExcptRegHead　=　pNewRegistHead;


　}


　PEXCEPTION_REGISTRATION　pCurrExcptReg　=　pExcptRegHead;


　pExcptRegHead　=　pExcptRegHead->prev;


　RtlpUnlinkHandler(　pCurrExcptReg　);

　}

　else　//　堆栈已经被破坏！生成一个异常

　{


　excptRec2.ExceptionRecord　=　pExcptRec;


　excptRec2.NumberParameters　=　0;


　excptRec2.ExceptionCode　=　STATUS_BAD_STACK;


　excptRec2.ExceptionFlags　=　EXCEPTION_NONCONTINUABLE;


　RtlRaiseException(　&excptRec2　);

　}

　}

　//　如果执行到这里，说明已经到了EXCEPTION_REGISTRATION

　//　结构链表的末尾，正常情况下不应该发生这种情况。

　//（因为正常情况下异常应该被处理，这样就不会到链表末尾）

　if　(　-1　==　pRegistrationFrame　)

　NtContinue(　&context,　0　);

　else

　NtRaiseException(　pExcptRec,　&context,　0　);
　}

　RtlUnwind函数的伪代码到这里就结束了，以下是它调用的几个函数的伪代码：

　PEXCEPTION_REGISTRATION　RtlpGetRegistrationHead(　void　)
　{

　return　FS:[0];
　}
　RtlpUnlinkHandler(　PEXCEPTION_REGISTRATION　pRegistrationFrame　)
　{

FS:[0]　=　pRegistrationFrame->prev;
　}
　void　RtlpCaptureContext(　CONTEXT　*　pContext　)
　{

　pContext->Eax　=　0;

　pContext->Ecx　=　0;

　pContext->Edx　=　0;

　pContext->Ebx　=　0;

　pContext->Esi　=　0;

　pContext->Edi　=　0;

　pContext->SegCs　=　CS;

　pContext->SegDs　=　DS;

　pContext->SegEs　=　ES;

　pContext->SegFs　=　FS;

　pContext->SegGs　=　GS;

　pContext->SegSs　=　SS;

　pContext->EFlags　=　flags;　//　它对应的汇编代码为__asm{　PUSHFD　/　pop　[xxxxxxxx]　}

　pContext->Eip　=　此函数的调用者的调用者的返回地址　　//　读者看一下这个函数的

　pContext->Ebp　=　此函数的调用者的调用者的EBP　　　　//　汇编代码就会清楚这一点

　pContext->Esp　=　pContext->Ebp　+　8;
　}

虽然 RtlUnwind 函数的规模看起来很大，但是如果你按一定方法把它分开，其实并不难理解。它首先从FS:[4]和FS:[8]处获取当前线程堆栈的界限。它们对于后面要进行的合法性检查非常重要，以确保所有将要被展开的异常帧都在堆栈范围内。

RtlUnwind 接着在堆栈上创建了一个空的EXCEPTION_RECORD结构并把STATUS_UNWIND赋给它的ExceptionCode域，同时把 EXCEPTION_UNWINDING标志赋给它的 ExceptionFlags 域。指向这个结构的指针作为其中一个参数被传递给每个异常回调函数。然后，这个函数调用RtlCaptureContext函数来创建一个空的CONTEXT结构，这个结构也变成了在展开阶段调用每个异常回调函数时传递给它们的一个参数。

RtlUnwind函数的其余部分遍历EXCEPTION_REGISTRATION结构链表。对于其中的每个帧，它都调用 RtlpExecuteHandlerForUnwind 函数，后面我会讲到这个函数。正是这个函数带 EXCEPTION_UNWINDING 标志调用了异常处理回调函数。每次回调之后，它调用RtlpUnlinkHandler 移除相应的异常帧。

RtlUnwind 函数的第一个参数是一个帧的地址，当它遍历到这个帧时就停止展开异常帧。上面所说的这些代码之间还有一些安全性检查代码，它们用来确保不出问题。如果出现任何问题，RtlUnwind 就引发一个异常，指示出了什么问题，并且这个异常带有EXCEPTION_NONCONTINUABLE 标志。当一个进程被设置了这个标志时，它就不允许再运行，必须终止。