异常篇—— VEH 与 SEH

写在前面

  此系列是本人一个字一个字码出来的，包括示例和实验截图。由于系统内核的复杂性，故可能有错误或者不全面的地方，如有错误，欢迎批评指正，本教程将会长期更新。 如有好的建议，欢迎反馈。码字不易，如果本篇文章有帮助你的，如有闲钱，可以打赏支持我的创作。如想转载，请把我的转载信息附在文章后面，并声明我的个人信息和本人博客地址即可，但必须事先通知我。

你如果是从中间插过来看的，请仔细阅读 羽夏看Win系统内核——简述 ，方便学习本教程。

  看此教程之前，问几个问题，基础知识储备好了吗？保护模式篇学会了吗？练习做完了吗？没有的话就不要继续了。

 

---

华丽的分割线

---

 

概述

  当用户异常产生后，内核函数KiDispatchException并不是像处理内核异常那样在0环直接进行处理 ，而是修正3环EIP为KiUserExceptionDispatcher函数后就结束了。这样，当线程再次回到3环时，将会从KiUserExceptionDispatcher函数开始执行，这个函数就是我们重点关注对象，我们先看一下它的流程：

1. 调用RtlDispatchException，查找并执行异常处理函数。
2. 如果RtlDispatchException返回真，调用ZwContinue再次进入0环，但线程再次返回3环时，会从修正后的位置开始执行。
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    ecx             ; 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    _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 )
        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的。如果返回假，则说明没有，后面的RtlpGetRegistrationHead就会获取SEH，如果有就执行，它是在堆栈中的。

  有了这些铺垫后，我们来介绍VEH和SEH。

VEH

  对于VEH，这个是XP及其之后才有的，中文为向量化异常结构处理。我们先看看它的处理流程：

1. CPU捕获异常信息；
2. 通过KiDispatchException进行分发；
3. KiUserExceptionDispatcher调用RtlDispatchException；
4. RtlDispatchException查找VEH处理函数链表 并调用相关处理函数；
5. 代码返回到KiUserExceptionDispatcher；
6. 调用ZwContinue再次进入0环（ZwContinue调用NtContinue,主要作用就是恢复_TRAP_FRAME然后通过KiServiceExit返回到3环）；
7. 线程再次返回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;
    }
    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，它们表示的含义如下：

1. EXCEPTION_EXECUTE_HANDLER (1) 执行except里面的代码
2. EXCEPTION_CONTINUE_SEARCH (0) 寻找下一个异常处理函数
3. 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         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里的代码。具体详细的其他细节将会在总结与提升进行介绍。

下一篇

  异常篇——总结与提升