Reversing Microsoft Visual C++ Part I: Exception Handling

译自OpenRCE: http://www.openrce.org/articles/full_view/21

概要

Microsoft Visual C++是win32下使用最广的编译器, 所以熟悉它的内部工作原理对win32逆向非常重要. 能认出编译器自动生成的"粘合代码"(辅助代码)可以帮助你快速集中于那些由程序员编写的实际代码. 同样也有助于把握程序的高层结构.

在两部分文章中的第一部分, 我会集中于栈布局(stack layout), 异常处理(exception handling) 和MSVC编译的程序里的相关结构. 假设读者已了解汇编程序,寄存器调用约定等的一些知识.

 

术语:

• Stack frame: 栈帧, 被某个函数使用的一段堆栈段. 通常包含函数参数, 返回地址, 保存的寄存器现场, 局部变量和其他一些特定于这个函数的数据. 在x86(和大多数的其他架构)上, 调用者与被调用者的栈帧是相邻的.
• Frame pointer: 栈帧指针, 一个指向栈帧里固定地址的寄存器或其他变量. 通常栈帧里的所有数据都是用它来作相对寻址. 在x86上它通常是ebp而且通常是指向返回地址的下面.
• Object: 对象, 一个(C++)类的实例.
• Unwindable Object: 可展开对象, 一个被指定为auto存储级别(auto storage-class)的局部对象, 它被分配在栈里, 而且在离开作用范围之后被销毁.
• Stack Unwinding: 栈展开, 自动销毁上面那些对象, 在因异常使程序流离开它们的作用范围时发生.

 

在C或C++程序里可以使用两种异常:

• SEH(Structured Exception Handling) 异常, 结构化异常处理异常. 就是平常说的Win32或系统异常. 在著名的Matt Pietrek的文章[1]里有详尽的描述. 他们是C程序里唯一有效的异常. 编译器级支持包括关键字__try, __except, __finally 还有其他一些.
• C++异常(有时称为"EH"). 在SEH之上实现. C++异常允许抛出和捕获任意类型. 它的一个十分重要的特性就是在异常处理期间自动展开堆栈, 而且MSVC用了一个非常复杂的底层框架来保证它在任何情况下都能工作.

 

在下面的图示中, 内存地址是从上往下增长的, 于是堆栈是"越长越高"的. 这也是IDA中表示堆栈的方法, 和大多数其他的文章相反.

基本栈帧布局:

大多数的基本栈帧看起来像下面这样:

    ...

    局部变量

    保存的其他寄存器值

    保存的ebp值

    返回地址

    函数参数

    ...

注意: 如果允许省略栈帧指针, 那么可能会没有保存ebp.

 

 

SEH

在使用了编译器级SEH的情况下, 堆栈布局可能会有一点复杂. SEH3 Stack Layout 当在一个函数里没有__except块的时候, Saved ESP是没有用的. Scope table是一个描述了每个__try块和它们之间关系的结构的数组:

struct  _SCOPETABLE_ENTRY {
    DWORD EnclosingLevel;
     void *  FilterFunc;
     void *  HandlerFunc;
}

更多的关于SEH实现的细节参考[1].了解try块就看try level变量是怎么被更新的.每个try块都有分配到一个唯一数字,嵌套关系则对应于两个ScopeTable间的关系.比如,一个ScopeTable i 的EnclosingLevel=j, 那么try块j包含try块i. 函数体的try level看成是-1. 例子看附录1.

缓冲区溢出保护

Whidbey(MSVC 2005)编译器在SEH帧里添加了一些缓冲区溢出的保护措施. 它的完整栈帧布局看起来像下面这样: SEH4 Stack Layout GS Cookie只在函数用/GS开关编译的时候出现. EH Cookie则总是出现. SEH4的ScopeTable和SEH3的基本一样, 只是增加了头部: 

struct  _EH4_SCOPETABLE {
    DWORD GSCookieOffset;
    DWORD GSCookieXOROffset;
    DWORD EHCookieOffset;
    DWORD EHCookieXOROffset;
    _EH4_SCOPETABLE_RECORD ScopeRecord[ 1 ];
};

struct  _EH4_SCOPETABLE_RECORD {
    DWORD EnclosingLevel;
     long  ( * FilterFunc)();
    union {
         void  ( * HandlerAddress)();
         void  ( * FinallyFunc)();
    };
};

GSCookieOffset=-2表示GS Cookie没有使用. EH Cookie总是出现. 偏移都相对于ebp. 检查的时候计算:(ebp+CookieXOROffset) ^ [ebp+CookieOffset] == 和_security_cookie异或之后的一个栈里的ScopeTable的指针. 在SEH4里, 最外层的块等级(Scope level)是-2, 而不是像SEH3一样的-1.

C++异常模型实现

当C++异常处理(try/catch)或者可展开对象出现在函数里的时候,事情开始变得复杂. C++ EH Stack Layout EH处理程序对每个函数都不同(不像SEH), 通常是下面这样:

;(VC7+)
mov  eax OFFSET __ehfuncinfo
jmp ___CxxFrameHandler

__ehfuncinfo是一个FuncInfo类型的结构, 他完整描述了函数中所有try/catch块和可展开对象.

 

struct  FuncInfo {
     //  compiler version.
     //  0x19930520: up to VC6, 0x19930521: VC7.x(2002-2003), 0x19930522: VC8 (2005)
    DWORD magicNumber;

     //  number of entries in unwind table
     int  maxState;

     //  table of unwind destructors
    UnwindMapEntry *  pUnwindMap;

     //  number of try blocks in the function
    DWORD nTryBlocks;

     //  mapping of catch blocks to try blocks
    TryBlockMapEntry *  pTryBlockMap;

     //  not used on x86
    DWORD nIPMapEntries;

     //  not used on x86
     void *  pIPtoStateMap;

     //  VC7+ only, expected exceptions list (function "throw" specifier) 
    ESTypeList *  pESTypeList;

     //  VC8+ only, bit 0 set if function was compiled with /EHs
     int  EHFlags;
};

Unwind map类似于SEH的ScopeTable, 只是没有过滤函数:

struct  UnwindMapEntry {
     int  toState;         //  target state
     void  ( * action)();    //  action to perform (unwind funclet address)
};

Try块描述符. 描述了一个try{}块, 包括相关的catch块.

struct  TryBlockMapEntry {
     int  tryLow;
     int  tryHigh;     //  this try {} covers states ranging from tryLow to tryHigh
     int  catchHigh;   //  highest state inside catch handlers of this try
     int  nCatches;    //  number of catch handlers
    HandlerType *  pHandlerArray;  // catch handlers table
};

catch块描述符. 描述了try块中的其中一个catch()

struct  HandlerType {
     //  0x01: const, 0x02: volatile, 0x08: reference
    DWORD adjectives;

     //  RTTI descriptor of the exception type. 0=any (ellipsis)
    TypeDescriptor *  pType;

     //  ebp-based offset of the exception object in the function stack.
     //  0 = no object (catch by type)
     int  dispCatchObj;

     //  address of the catch handler code.
     //  returns address where to continues execution (i.e. code after the try block)
     void *  addressOfHandler;
};

期望捕获异常的列表(在MSVC中实现了但是默认被禁止, 用/d1ESrt开启):

struct  ESTypeList {
     //  number of entries in the list
     int  nCount;

     //  list of exceptions; it seems only pType field in HandlerType is used
    HandlerType *  pTypeArray;
};

 

RTTI类型描述符. 描述了一个C++类型. 在这里用来匹配抛出的异常类型和catch的类型.

struct  TypeDescriptor {
     //  vtable of type_info class
     const   void   *  pVFTable;

     //  used to keep the demangled name returned by type_info::name()
     void *  spare;

     //  mangled type name, e.g. ".H" = "int", ".?AUA@@" = "struct A", ".?AVA@@" = "class A"
     char  name[ 0 ];
};

不像SEH, 每个try块不会有一个关联状态值. 编译器不仅会在进入/离开try块的时候改变状态值, 在创建/销毁对象时也会. 这样就有可能知道哪些对象在异常发生时需要展开. 你仍然可以通过检查关联状态范围和catch处理器返回的地址来得知try块的边界.(见附录2)

抛出C++异常

throw语句被转化为调用_CxxThrowException(), 它实际上抛出一个win32(SEH)异常, 代码是0xE06D7363 ('msc'|0xE0000000). 自定义参数包括异常对象指针和它的ThrowInfo结构(被异常处理程序用来匹配抛出异常的类型).

struct  ThrowInfo {
     //  0x01: const, 0x02: volatile
    DWORD attributes;

     //  exception destructor
     void  ( * pmfnUnwind)();

     //  forward compatibility handler
     int  ( * pForwardCompat)();

     //  list of types that can catch this exception.
     //  i.e. the actual type and all its ancestors.
    CatchableTypeArray *  pCatchableTypeArray;
};

struct  CatchableTypeArray {
     //  number of entries in the following array
     int  nCatchableTypes; 
    CatchableType *  arrayOfCatchableTypes[ 0 ];
};

描述一个可以捕获这次异常的类型:

struct  CatchableType {
     //  0x01: simple type (can be copied by memmove), 0x02: can be caught by reference only, 0x04: has virtual bases
    DWORD properties;

     //  see above
    TypeDescriptor *  pType;

     //  how to cast the thrown object to this type
    PMD thisDisplacement;

     //  object size
     int  sizeOrOffset;

     //  copy constructor address
     void  ( * copyFunction)();
};

//  Pointer-to-member descriptor.
struct  PMD {
     //  member offset
     int  mdisp;

     //  offset of the vbtable (-1 if not a virtual base)
     int  pdisp;

     //  offset to the displacement value inside the vbtable
     int  vdisp;
};

 

我们会在下一篇文章更深入研究这个.

序言和结语(Prologs and Epilogs)

相比把建立栈帧的代码放在函数体, 编译器可能会调用指定的"序言和结语"(prolog and epilog)函数. 这里有几种用于不同函数类型的变量:

Name	Type	EH Cookie	GS Cookie	Catch Handlers
_SEH_prolog/_SEH_epilog	SEH3	-	-
_SEH_prolog4/_SEH_epilog4 S	EH4	+	-
_SEH_prolog4_GS/_SEH_epilog4_GS	SEH4	+	+
_EH_prolog	C++ EH	-	-	+/-
_EH_prolog3/_EH_epilog3	C++ EH	+	-	-
_EH_prolog3_catch/_EH_epilog3	C++ EH	+	-	+
_EH_prolog3_GS/_EH_epilog3_GS	C++ EH	+	+	-
_EH_prolog3_catch_GS/_EH_epilog3_catch_GS	C++ EH	+	+	+

SEH2

显然被用在MSVC 1.xx(由crtdll.dll导出). 在某些旧的NT程序下会见到.

    ...

    Saved edi

    Saved esi

    Saved ebx

    Next SEH frame

    Current SEH handler (__except_handler2)

    Pointer to the scopetable

    Try level

    Saved ebp (of this function)

    Exception pointers

    Local variables

    Saved ESP

    Local variables

    Callee EBP

    Return address

    Function arguments

    ...

 

 

附录1: 示例SEH程序

考虑以下反汇编:

func1 proc near

_excCode = dword ptr -28h
buf = byte ptr -24h
_saved_esp = dword ptr -18h
_exception_info = dword ptr -14h
_next = dword ptr -10h
_handler = dword ptr -0Ch
_scopetable = dword ptr -8
_trylevel = dword ptr -4
str = dword ptr 8

push ebp
mov ebp, esp
push -1
push offset _func1_scopetable
push offset _except_handler3
mov eax, large fs:0
push eax
mov large fs:0, esp
add esp, -18h
push ebx
push esi
push edi

; --- end of prolog ---

mov [ ebp+_trylevel], 0 ;trylevel -1 -> 0: beginning of try block 0
mov [ ebp+_trylevel], 1 ;trylevel 0 -> 1: beginning of try block 1
mov large dword ptr ds:123, 456
mov [ ebp+_trylevel], 0 ;trylevel 1 -> 0: end of try block 1
jmp short _endoftry1

_func1_filter1: ; __except() filter of try block 1
mov ecx, [ ebp+_exception_info]
mov edx, [ ecx+EXCEPTION_POINTERS.ExceptionRecord]
mov eax, [ edx+EXCEPTION_RECORD.ExceptionCode]
mov [ ebp+_excCode], eax
mov ecx, [ ebp+_excCode]
xor eax, eax
cmp ecx, EXCEPTION_ACCESS_VIOLATION
setz al
retn

_func1_handler1: ; beginning of handler for try block 1
mov esp, [ ebp+_saved_esp]
push offset aAccessViolatio ; "Access violation"
call _printf
add esp, 4
mov [ ebp+_trylevel], 0 ;trylevel 1 -> 0: end of try block 1

_endoftry1:
mov edx, [ ebp+str]
push edx
lea eax, [ ebp+buf]
push eax
call _strcpy
add esp, 8
mov [ ebp+_trylevel], -1 ; trylevel 0 -> -1: end of try block 0
call _func1_handler0 ; execute __finally of try block 0
jmp short _endoftry0

_func1_handler0: ; __finally handler of try block 0
push offset aInFinally ; "in finally"
call _puts
add esp, 4
retn

_endoftry0:
; --- epilog ---
mov ecx, [ ebp+_next]
mov large fs:0, ecx
pop edi
pop esi
pop ebx
mov esp, ebp
pop ebp
retn
func1 endp

_func1_scopetable
;try block 0
dd -1 ;EnclosingLevel
dd 0 ;FilterFunc
dd offset _func1_handler0 ;HandlerFunc

;try block 1
dd 0 ;EnclosingLevel
dd offset _func1_filter1 ;FilterFunc
dd offset _func1_handler1 ;HandlerFunc

try块0没有过滤器, 所以它是一个__finally{}块. try块1的EnclosingLevel是0, 所以它在try块0的里面. 综上, 我们可以写出以下代码:

void  func1 ( char *  str)
{
     char  buf[ 12 ];
    __try  //  try block 0
    {
         __try  //  try block 1
        {
             * ( int * ) 123 = 456 ;
        }
         __except (GetExceptCode()  ==  EXCEPTION_ACCESS_VIOLATION)
        {
            printf( " Access violation " );
        }
        strcpy(buf,str);
    }
    __finally
    {
        puts( " in finally " );
    }
}

附录2: C++异常的示例

 

未完待续...