复习
异常分发过程使用的函数以及具体的功能(int 3)
_Kitrap03.asm
CommonDispatchException.asm
KiDispatchException.c
KiUserExceptionDispatcher.c
KiUserExceptionDispatcher[3].c
RtlDispatchException[0].c
RtlDispatchException[3].c

复习

1. 如果所有的 SEH 都不能处理异常，那么最后会由谁处理异常

如果 SEH 不能处理异常，异常就会传递给 UEH，UEH 实际上是系统默认的 SEH 调用的。

2. VCH 处理程序会在什么情况下被调用

只有之前的 SEH VEH 或者 UEH 中的任何一个处理异常，这个函数才会被调用

3. SEH 是全局有效的么，它们被保存在什么地方

SEH 是线程相关的，保存在了 FS:[0] 内，对应的就是 TEB.NT_TIB.ExceptionList 字段。
UEH 是进程相关，如果任何一个异常处理程序无法处理，就被调用，实际被保存在一个全局的函数指针中。
VEH 和 VCH 是进程相关的，被保存在全局的链表中，两个函数只是保存的标志位不同。

4. 什么是异常，什么是中断

中断通常是由外部设置产生的，例如鼠标键盘等，是一个异步的事件，可以不进行处理。
异常通常是在CPU满足特定的条件时，内部产生的，是一个同步的事件，必须立即进行处理。

5. 异常的种类有哪些，有什么特点？

错误类：通常可修复，异常产生时，eip 指向的是产生异常的指令。
陷阱类：通常可修复，异常产生时，eip 指向的是下一条指令。
终止类：无法修复的，寄存器的指向时没有意义的。

6. windbg 中分别使用哪些系列的指令查看数据、修改数据、设置断点。

查看数据的指令：db dq da du dw dd dt(查看结构体)
修改数据的指令：eb eq ea eu ew
断点相关的指令：bp bu bl be bd bc
为指定模块加载符号：.reload /f /i demo.exe -> ml
流程相关的一些指令：t(F11) p(F10) g(F5)

7. 陷阱处理器被保存在哪里，windbg中使用什么指令可以查看它。

在 windows 中中断和异常是统一管理的，所有的处理函数都被保存在 CPU相关的 IDT 中，使用 !IDT 可以进行查看。

8. 异常的产生方式有几种，分别是什么？

指令满足特定的条件，CPU 自动触发
用户使用 RaiseException 函数主动的抛出异常

异常分发过程使用的函数以及具体的功能(int 3)

异常分发流程-1.jpg
用户层的异常分发.png

一、KiTrap03

谁调用的：CPU 产生了异常，从 IDT[3] 找到这个函数并且调用了
调用了谁：ENTER_TRAP(宏) CommonDispatchException(函数)
功能：
1. 使用 ENTER_TRAP 宏填充了一个陷阱帧，目的是为了处理异常后继续执行
2. 调用了 CommonDispatchException 并传递了相关的参数(异常类型\异常地址\异常参数)

二、 CommonDispatchException

谁调用的：KiTrap03 调用的
调用了谁：KiDispatchException
功能：
1. 构建了一个 EXCEPTION_RECORD 结构体，并使用接受的参数填充
2. 调用了 KiDispatchException 并传递了相关的参数(先前模式\分发次数\陷阱帧\异常记录)

三、 KiDispatchException

谁调用的：CommonDispatchException 调用的
调用了谁：RtlDispatchException(R0) \ 间接调用 RtlDispatchException(R3) \ KiUserExceptionDispatcher
功能：
1. 当前接收到的异常产生于内核态
  1. 尝试将异常信息发送给内核调试器(KD\WINDBG)
  2. 通过 RtlDispatchException(R0) 函数调用 SEH
  3. 再次尝试将异常信息发送给内核调试器(KD\WINDBG)
  4. 调用 KeDebugCheck 函数使系统蓝屏并显示错误码
2. 当前接收到的异常产生于用户态
  1. 如果没有被R3调试，就尝试将异常发送给内核调试器
  2. 通过 DbgkForwardException 将异常传递给 R3 调试器(OD\x64)
  3. 在用户栈中填充一个 EXCEPTION_POINTER 结构
    - 设置 eip 指向 ntdll 中的函数 KiUserExceptionDispatcher
  4. 执行到用户代码，在 KiUserExceptionDispatcher 调用 RtlDispatchException[R3]
    - 在这个函数的内部会依次调用 VEH SEH UEH (VCH)
  5. 依然无法处理就执行第二次分发，将异常发送到调试端口(调试器)\异常端口(子系统)
  6. 仍然无法处理，就结束进程
    _Kitrap03.asm

; 处理由单字节指令 INT 3 引起的软件断点异常，并且提供相应的附加参数
; 当异常产生的时候，寄存器 cs:eip 会立即指向 INT 3 的下一条指令。
_KiTrap03       proc
        ; 填充一个 _KTRAP_FRAME 结构体，提供相关的变量，会被用于恢复执行
        ; 其中 INT 3 不提供错误代码，需要手动进行填充
        push    0
        ENTER_TRAP      kit3_a, kit3_t  
kit03_01:
        ; 填充软件断点对应的异常信息
        mov     eax, BREAKPOINT_BREAK(0)
kit03_05:
        ; 开启中断标志位
        sti
kit03_10:                               ; 当前函数的终点(重点)
        ; 设置断点类异常的附加参数
        mov     esi, ecx                ; 2: 保存产生异常的线程对应的 ETHREAD
        mov     edi, edx                ; 3: 没保存有意义的值，可能是 V86Ds
        mov     edx, eax                ; 1: 保存的是软件断点相关的异常信息
        ; 陷阱类异常发生时，eip 指向下一条，实际产生异常的位置在 eip - 1
        mov     ebx, [ebp].Eip          ; ebx = 异常地址(int 3)
        dec     ebx
        mov     ecx, 3                  ; ecx = 参数个数
        mov     eax, STATUS_BREAKPOINT  ; eax = 异常类型
        ; 调用函数执行异常的分发，函数永远不会返回
        call    CommonDispatchException ; Never return
_KiTrap03       endp
;----------------------------------------------------------------------------
; 宏：用于构建陷阱帧并设置异常需要用到的寄存器
;   - 保存: (非)易失性寄存器、段寄存器[DS\ES\GS\FS]、异常链表、先前模式等
;   - 设置: 段寄存器[DS\ES\FS] 以及 DF 方向标志位等，esp=ebp=KTRAP_FRAME
ENTER_TRAP macro    kit3_a, kit3_t
        ; 当产生异常的时候，CPU会自动保存下列的寄存器
        ; +0x068 Eip              : Uint4B
        ; +0x06c SegCs            : Uint4B
        ; +0x070 EFlags           : Uint4B
        mov     word ptr [esp+2], 0 ; 清除 ErrorCode 的低两位
        push    ebp                 ; 保存非易失性寄存器[基址\变址]
        push    ebx
        push    esi
        push    edi
        push    fs                  ; 保存 FS 并将 FS 指向 KPCR[R0]
        mov     ebx, KGDT_R0_PCR    ; 使 fs 指向 KPCR 结构体
        mov     fs, bx
                                    ; 保存 SEH 异常链表
        mov     ebx, fs:[PcExceptionList] 
        push    ebx
        sub     esp, 4              ; 开辟空间，用于填充 [先前模式] 字段
        push    eax                 ; 保存易失性寄存器
        push    ecx
        push    edx
        push    ds                  ; 保存段寄存器
        push    es
        push    gs
        ; 直接开辟堆栈，跳过其它字段的填充并设置 ds 和 es 段寄存器的值      
        mov     ax, KGDT_R3_DATA OR RPL_MASK
        sub     esp, SegGs(偏移 0x30)
        mov     ds, ax
        mov     es, ax
        ; 此时 esp 和 ebp 都指向 KTRAP_FRAME 结构体
        mov     ebp, esp
        ; 获取对应当前的 ETHREAD 结构体的地址，并清除方向标志
        mov     ecx, PCR[PcPrcbData+PbCurrentThread] 
        cld
        ; 关闭所有的硬件断点，当 ThDebugActive 的值为 ff 时保存所有的调试寄存器(被调试)
        ; win8 以上取消了 ETHREAD.DISPATCHER_HEADER.DebugActive 这个字段的使用
        and     dword ptr [ebp].Dr7, 0
        test    byte ptr [ecx].DebugActive, 0ffh;
        jnz     Dr_kit3_a
Dr_kit3_t:
        ; 设置调试相关信息
        SET_DEBUG_DATA
ENTER_TRAP      endm

CommonDispatchException.asm

; 此函数在栈上分配并填充 ExceptionRecord 结构，最后调用异常分发函数
; 只有在 ExceptionCode = 0、参数个数小于 3 或 ExceptionRecord 为空才调用
CommonDispatchException proc
        ; esi = 附加参数2            edi = 附加参数3
        ; edx = 附加参数1            ebx = 异常地址
        ; ecx = 参数个数             eax = 异常类型
        ; esp = EXCEPTION_RECORD    ebp = _KTRAP_FRAME
        ; 在栈中开辟记录异常所需的栈空间 EXCEPTION_RECORD
        sub     esp, ExceptionRecordLength
        ; 使用 _KiTrap03 传入的参数构建异常结构
        mov     dword ptr [esp].ExceptionCode, eax    ; *异常类型
        xor     eax, eax
        mov     dword ptr [esp].ExceptionFlags, eax     ; 异常标志，为 0 则可以处理
        mov     dword ptr [esp].ExceptionRecord, eax    ; 指向下一个异常结构
        mov     dword ptr [esp].ExceptionAddress, ebx   ; *异常产生时的地址 
        mov     dword ptr [esp].NumberParameters, ecx   ; 异常的附加参数个数
        ; 如果附加参数个数为 0，则跳转到目标位置
        cmp     ecx, 0
        je      short de00
        ; 如果存在附加参数，则填充异常的附加参数
        lea     ebx, [esp + ErExceptionInformation]
        mov     [ebx + 0], edx
        mov     [ebx + 4], esi
        mov     [ebx + 8], edi
de00:
        mov     ecx, esp                ; (ecx)->exception record
        ; 如果当前不是 V86 模式下的异常，则获取 CS 寄存器（重点）
de10:   mov     eax, [ebp].SegCs
        ; 获取 CS 寄存器的最低位用作先前模式，用于判断处于 R0 还是 R3
de20:   and     eax, MODE_MASK(3)
        ; 将设置好的值作为参数调用 KiDispatchException 函数进行异常的分发
        push    True                    ; first chance: 表示是否是第一次处理异常
        push    eax                     ; PreviousMode: 先前模式，当前异常由 R0 产生还是 R3 产生
        push    ebp                     ; TrapFrame: 陷阱帧，保存的是异常产生的寄存器环境
        push    0                       ; ExceptionFrame: 空的异常栈帧（不重要）
        push    ecx                     ; EXCEPTION_RECORD: 填充的 EXCEPTION_RECORD
        call    KiDispatchException
        ; 结束异常处理，根据 _KTRAP_FRAME 通过 iret 指令返回用户层代码
        mov     esp, ebp                ; (esp) -> trap frame
                                        ; 用于返回 R3 并且根据陷阱帧设置 R3 的寄存器
        jmp     Kei386EoiHelper(_KiExceptionExit)
CommonDispatchException endp

KiDispatchException.c

// 该函数是异常的分发函数，会根据异常产生的位置对异常进行相应的处理。
VOID KiDispatchException (
    IN PEXCEPTION_RECORD ExceptionRecord,   // 指向异常信息结构体
    IN PKEXCEPTION_FRAME ExceptionFrame,    // 指向异常帧，0
    IN PKTRAP_FRAME TrapFrame,              // 指向陷阱帧，寄存器环境 
    IN KPROCESSOR_MODE PreviousMode,        // 异常产生的位置 R0/R3
    IN BOOLEAN FirstChance                  // 是否是第一次分发异常
    )
{
    // 递增异常分发计数器
    KeGetCurrentPrcb()->KeExceptionDispatchCount++;
    // 创建保存线程环境的结构体，第一个参数标识要操作的寄存器类型
    // 根据设置的标志，将指定类型的陷阱帧和异常帧信息传递到上下文中(关键)
    CONTEXT Context = { CONTEXT_FULL | CONTEXT_DEBUG_REGISTERS };
    KeTrapFrameToContext(TrapFrame, ExceptionFrame, &Context);
    // 根据异常产生的位置选择不同的处理方式
    if (PreviousMode == KernelMode(0))
    {
        // 如果异常产生于内核模式下，先判断内核调试器是否存在，存在则交给内核调试器进行第一次处理，
        // 如果处理失败，则将异常传递给内核中的结构化异常处理程序进行处理，若仍然处理失败，交由内
        // 核调试器进行第二次的处理。如果还是无法处理，则调用 KeBugCheckEx 使系统崩溃。
         if (FirstChance == TRUE)
         {
            // KiDebugRoutine 是一个保存在内核中的全局指针，通常情况下被指向 KdpStub 函数，这
            // 个函数基本不执行任何操作。当存在内核调试器时(windbg\kd)，该指针指向函数 KdpTrap，
            // 作用是将调用方传入的异常信息发送给内核调试器进行处理并获得处理结果
            if ((KiDebugRoutine != NULL) &&
               (((KiDebugRoutine)(TrapFrame,
                                   ExceptionFrame,
                                   ExceptionRecord,
                                   &Context, 
                                   PreviousMode, 
                                   FALSE)) != FALSE)) {
                // 如果异常处理成功，则跳转到函数末尾恢复执行
                goto Handled1;
            }
            // 如果不存在内核调试器或内核调试器没有处理成功，则传递给 SEH 处理
            if (RtlDispatchException(ExceptionRecord, &Context) == TRUE) {
                goto Handled1;
            }
        }
        // 如果调试器和SEH异常处理都没有处理得了异常, 则给内核调试器第二次的处理机会
        if ((KiDebugRoutine != NULL) &&
            (((KiDebugRoutine) (TrapFrame,
                                ExceptionFrame,
                                ExceptionRecord,
                                &Context,
                                PreviousMode,
                                TRUE)) != FALSE)) {
            goto Handled1;
        }
        // 如果，异常仍然没有被处理，则调用 KeBugCheckEx 引发系统的蓝屏崩溃
        KeBugCheckEx(
            KERNEL_MODE_EXCEPTION_NOT_HANDLED,
            ExceptionRecord->ExceptionCode,
            (ULONG)ExceptionRecord->ExceptionAddress,
            (ULONG)TrapFrame,
            0);
    }
    // 如果异常在用户模式下触发 
    else 
    {   
        // 如果异常是第一次分发并且进程[具有调试端口](处于被调试状态), 则发送一个消息
        // 到调试端口,并等待回复. 如果调试器处理了这个异常, 则结束异常的分发. 否则,
        // 将异常信息拷贝到用户态的栈中, 并转到用户模式 , 在用户模式下尝试将异常派发
        // 给异常处理程序. 如果异常处理程序处理了异常, 则结束异常分发. 如果用户层的
        // 异常处理程序处理不了, 则调用 NtRaiseException 函数主动触发异常, 并将
        // FirstChance 设置为 TRUE. 这个函数(KiDispatchException) 将会被第二次调用以
        // 继续处理异常.  如果这次处理是第二次异常处理,并且进程有一个调试端口, 则发送
        // 一个消息到调试端口,并等待调试器回复.如果调试器回复已经处理了异常, 则结束异
        // 常分发. 否则发送给进程的异常端口, 并等其回复. 若异常被处理, 则异常分发结束
        // 否则直接结束掉当前进程.
        if (FirstChance == TRUE) {
            // 除非存在用户模式调试器或处理器忽略用户模式下的异常，(否则在确认当前进程
            // 不是一个调试服务后)，将异常发送给内核调试器进行处理
            // 当进程处于被调试状态时 DebugPort 保存的是一个调试对象
            // (指针非空 && 当前没有被调试 && 没有忽略异常)
            if ((KiDebugRoutine != NULL)  &&
                ((PsGetCurrentProcess()->DebugPort == NULL &&
                  !KdIgnoreUmExceptions) ||
                 (KdIsThisAKdTrap(ExceptionRecord, &Context, UserMode)))) {
                if ((((KiDebugRoutine) (TrapFrame,
                                        ExceptionFrame,
                                        ExceptionRecord,
                                        &Context,
                                        PreviousMode,
                                        FALSE)) != FALSE)) {
                    // 如果没有被三环调试器调试调试，就发送异常信息给内核调试器
                    goto Handled1;
                }
            }
            // 通过函数 DbgkForwardException 将异常发送给用户层调试器并等待用户调试器的处理结果，
            // 该函数用于组合消息，并在内部调用 DbgkpSendApiMessage() 进行消息的传递 
            if (DbgkForwardException(ExceptionRecord, TRUE, FALSE)) {
                goto Handled2;
            }
        repeat:
            try {                
                // 在栈上开辟一块空间用于存储 CONTEXT: sub esp, sizeof(CONTEXT)
                // 检查用户栈上对应的空间是否是可写的，不可写则产生异常
                // 如果可以写如，则将填充的异常线程上下文拷贝到对应的区域
                // 在栈中开辟一个 CONTEXT 结构并且填充
                // esp -> UserStack1 -> CONTEXT
                // --------------
                UserStack1 = (Context.Esp& ~CONTEXT_ROUND) - CONTEXT_ALIGNED_SIZE;
                ProbeForWrite((PCHAR)UserStack1, CONTEXT_ALIGNED_SIZE, CONTEXT_ALIGN);
                RtlCopyMemory((PULONG)UserStack1, &Context, sizeof(CONTEXT));
                // 继续在栈中已分配的空间后开辟空间用于存储 EXCEPTION_RECORD 结构体
                // 探测目标区域是否可写，并将数据填充到对应的栈空间位置
                // 在栈中再次开辟一个 EXCEPTION_RECORD 结构体并填充
                // UserStack2 -> EXCEPTION_RECORD
                // --------------
                // UserStack1 -> CONTEXT
                // --------------
                Length = (sizeof(EXCEPTION_RECORD) - (EXCEPTION_MAXIMUM_PARAMETERS -
                         ExceptionRecord->NumberParameters) * sizeof(ULONG) + 3) & (~3);
                UserStack2 = UserStack1 - Length;
                // 探测的位置为结构体大小加8，因为还需要通过栈传递两个参数
                // UserStack2 - 8
                // UserStack2 - 4
                // UserStack2 -> EXCEPTION_RECORD
                // --------------
                // UserStack1 -> CONTEXT
                // --------------
                ProbeForWrite((PCHAR)(UserStack2 - 8), Length + 8, sizeof(ULONG));
                RtlCopyMemory((PULONG)UserStack2, ExceptionRecord, Length);
                // 将两个结构体的地址作为函数(KiUserExceptionDispatcher)的参数传递到栈中
                // UserStack2 - 8       ->      UserStack2(EXCEPTION_RECORD)
                // UserStack2 - 4       ->      UserStack1(CONTEXT)
                // UserStack2 -> EXCEPTION_RECORD
                // --------------
                // UserStack1 -> CONTEXT
                // --------------
                *(PULONG)(UserStack2 - sizeof(ULONG)) = UserStack1;
                *(PULONG)(UserStack2 - 2*sizeof(ULONG)) = UserStack2;
                // 设置新的 SS 寄存器和 ESP 寄存器到 KTRAP_FRAME 结构中，设置 R3 的环境
                KiSegSsToTrapFrame(TrapFrame, KGDT_R3_DATA);
                KiEspToTrapFrame(TrapFrame, (UserStack2 - sizeof(ULONG)*2));
                // 为用户模式下的段寄存器填充指定的段选择子
                TrapFrame->SegCs = SANITIZE_SEG(KGDT_R3_CODE, PreviousMode);
                TrapFrame->SegDs = SANITIZE_SEG(KGDT_R3_DATA, PreviousMode);
                TrapFrame->SegEs = SANITIZE_SEG(KGDT_R3_DATA, PreviousMode);
                TrapFrame->SegFs = SANITIZE_SEG(KGDT_R3_TEB, PreviousMode);
                TrapFrame->SegGs = 0;
                // 将发生异常的线程 eip 地址设置为 KeUserExceptionDispatcher 函数的地址。
                // 然后程序会进行 return 操作，并根据新设置的线程环境切换到用户层继续执行。
                TrapFrame->Eip = (ULONG)KeUserExceptionDispatcher;
                // KeUserExceptionDispatcher: 内核内的一个全局指针，总是会指向一个 ntdll
                // 中保存的函数 KiUserExceptionDispatcher， 这个函数主要被用于进行用于层
                // 异常处理函数的调用。
                return;
            } except (KiCopyInformation(&ExceptionRecord1,
                (GetExceptionInformation())->ExceptionRecord)) {
                // 如果这些代码产生了栈溢出错误，就构建一个栈溢出异常进行分发
                if (ExceptionRecord1.ExceptionCode == STATUS_STACK_OVERFLOW) {
                    ExceptionRecord1.ExceptionAddress = ExceptionRecord->ExceptionAddress;
                    RtlCopyMemory((PVOID)ExceptionRecord,
                                  &ExceptionRecord1, sizeof(EXCEPTION_RECORD));
                    // 如果产生了栈异常，则再次尝试进行第二次操作
                    goto repeat;
                }
            }
        }
        }
        // 如果是第二次进行异常分发，则分别将异常信息再次发送给异常程序的调试端口和异常端口。
        // DbgkForwardException 的第二个参数表示端口类型，第三个参数表示是否是第二次分发
        if (DbgkForwardException(ExceptionRecord, TRUE, TRUE)) {
            goto Handled2;
        } else if (DbgkForwardException(ExceptionRecord, FALSE, TRUE)) {
            goto Handled2;
        } else {
            // 如果两次异常处理都没有成功，则结束产生异常的进程
            ZwTerminateProcess(NtCurrentProcess(), ExceptionRecord->ExceptionCode);
            KeBugCheckEx(
                KERNEL_MODE_EXCEPTION_NOT_HANDLED,
                ExceptionRecord->ExceptionCode,
                (ULONG)ExceptionRecord->ExceptionAddress,
                (ULONG)TrapFrame,
                0);
        }
    }
Handled1:
    // 将线程上下文的改动填充到陷阱和异常帧，然后返回以恢复状态继续执行。
    KeContextToKframes(TrapFrame, ExceptionFrame, &Context,
                       Context.ContextFlags, PreviousMode);
    // 如果用户调试器已经处理了异常，则不需要进行 eip 的设置
Handled2:
    return;
}

KiUserExceptionDispatcher.c

VOID NTAPI KiUserExceptionDispatcher(
    PEXCEPTION_RECORD ExceptionRecord,      // 
    PCONTEXT Context)
{
    EXCEPTION_RECORD NestedExceptionRecord;
    NTSTATUS Status;
    // 分发异常给 VEH SEH UEH 和 VCH 函数，并检查是否处理成功
    if (RtlDispatchException(ExceptionRecord, Context))
    {
        // 如果异常被处理了，通过 NtContinue 返回 R0 并继续执行
        Status = NtContinue(Context, FALSE);
    }
    else
    {
        // 通过将 NtRaiseException 的参数三设置为 FALSE 第二次抛出异常
        Status = NtRaiseException(ExceptionRecord, Context, FALSE);
    }
    // 如果上面的操作都执行失败，则生成一个新的异常并抛出
    NestedExceptionRecord.ExceptionCode = Status;
    NestedExceptionRecord.ExceptionFlags = EXCEPTION_NONCONTINUABLE;
    NestedExceptionRecord.ExceptionRecord = ExceptionRecord;
    NestedExceptionRecord.NumberParameters = Status;
    RtlRaiseException(&NestedExceptionRecord);
}

KiUserExceptionDispatcher[3].c

VOID NTAPI KiUserExceptionDispatcher(
    PEXCEPTION_RECORD ExceptionRecord,      // 
    PCONTEXT Context)
{
    EXCEPTION_RECORD NestedExceptionRecord;
    NTSTATUS Status;
    // 分发异常给 VEH SEH UEH 和 VCH 函数，并检查是否处理成功
    if (RtlDispatchException(ExceptionRecord, Context))
    {
        // 如果异常被处理了，通过 NtContinue 返回 R0 并继续执行
        Status = NtContinue(Context, FALSE);
    }
    else
    {
        // 通过将 NtRaiseException 的参数三设置为 FALSE 第二次抛出异常
        // 内部会直接调用 KiDispatchException 执行第二次分发
        Status = NtRaiseException(ExceptionRecord, Context, FALSE);
    }
    // 如果上面的操作都执行失败，则生成一个新的异常并抛出
    NestedExceptionRecord.ExceptionCode = Status;
    NestedExceptionRecord.ExceptionFlags = EXCEPTION_NONCONTINUABLE;
    NestedExceptionRecord.ExceptionRecord = ExceptionRecord;
    NestedExceptionRecord.NumberParameters = Status;
    RtlRaiseException(&NestedExceptionRecord);
}

RtlDispatchException[0].c

// 此函数通过搜索结构化异常处理链表，尝试将异常分派给相应的处理程序。搜索从上下文记录中指定的位置开始
// 并向后继续，直到找到处理异常的处理程序、发现堆栈无效（即超出限制或未对齐）或到达调用层次结构的末尾。
BOOLEAN RtlDispatchException (
    IN PEXCEPTION_RECORD ExceptionRecord,
    IN PCONTEXT ContextRecord
    )
{
    ULONG Index;
    BOOLEAN Completion = FALSE;
    EXCEPTION_RECORD ExceptionRecord1;
    DISPATCHER_CONTEXT DispatcherContext;
    PEXCEPTION_REGISTRATION_RECORD RegistrationPointer;
    PEXCEPTION_REGISTRATION_RECORD NestedRegistration = 0;
    // 从线程的 TIB(线程信息块) 中获取栈的基址和栈的结束位置
    // 从 TIB 中取出保存 SEH 函数的 ExceptionList 头节点
    ULONG LowLimit, HighLimit;
    RtlpGetStackLimits(&LowLimit, &HighLimit);
    // mov RegistrationPointer, fs:[0]
    RegistrationPointer = RtlpGetRegistrationHead();
    // 遍历 SEH，当值为 EXCEPTION_CHAIN_END(-1) 表示链表遍历结束
    while (RegistrationPointer != EXCEPTION_CHAIN_END) {
        // 计算出整个结构体所占用到的最大地址(结束位置)
        ULONG HighAddress = (ULONG)RegistrationPointer +
            sizeof(EXCEPTION_REGISTRATION_RECORD);
        // 如果起始地址小于栈底，结束位置大于栈顶，或者结构体地址没有对齐就尝试对地址进行修复
        if ( ((ULONG)RegistrationPointer < LowLimit) ||
             (HighAddress > HighLimit) ||
             (((ULONG)RegistrationPointer & 0x3) != 0)) 
        {
            // 退出当前函数，即异常处理失败
            ExceptionRecord->ExceptionFlags |= EXCEPTION_STACK_INVALID;
            break;
        }
        // 查看当前异常处理程序是否合理（能否访问到）
        if (!RtlIsValidHandler(RegistrationPointer->Handler)) {
            ExceptionRecord->ExceptionFlags |= EXCEPTION_STACK_INVALID;
            break;
        }
        // 调用异常处理函数，能够调用 except_handler4 -> 调用了 __except()/过滤函数
        EXCEPTION_DISPOSITION Disposition = RtlpExecuteHandlerForException(
            ExceptionRecord,
            (PVOID)RegistrationPointer,
            ContextRecord,
            (PVOID)&DispatcherContext,
            (PEXCEPTION_ROUTINE)RegistrationPointer->Handler);
        // 根据返回的不同值进行处理
        switch (Disposition) {
        // 如果返回的是继续执行，则在没有产生异常的情况下返回
        case ExceptionContinueExecution:
            if ((ExceptionRecord->ExceptionFlags &
               EXCEPTION_NONCONTINUABLE) != 0) {
                ExceptionRecord1.ExceptionCode =
                                        STATUS_NONCONTINUABLE_EXCEPTION;
                ExceptionRecord1.ExceptionFlags = EXCEPTION_NONCONTINUABLE;
                ExceptionRecord1.ExceptionRecord = ExceptionRecord;
                ExceptionRecord1.NumberParameters = 0;
                RtlRaiseException(&ExceptionRecord1);
            } else {
                Completion = TRUE;
                goto DispatchExit;
            }
        // 如果返回向上搜索，则继续进行循环
        case ExceptionContinueSearch :
            if (ExceptionRecord->ExceptionFlags & EXCEPTION_STACK_INVALID)
                goto DispatchExit;
            break;
        // 如果返回的不是以上任意一个值，则抛出 EXCEPTION_NONCONTINUABLE 异常
        default :
            ExceptionRecord1.ExceptionCode = STATUS_INVALID_DISPOSITION;
            ExceptionRecord1.ExceptionFlags = EXCEPTION_NONCONTINUABLE(1);
            ExceptionRecord1.ExceptionRecord = ExceptionRecord;
            ExceptionRecord1.NumberParameters = 0;
            RtlRaiseException(&ExceptionRecord1);
            break;
        }
        // 如果链表遍历过程中没有发生任何错误，则继续遍历下一层
        RegistrationPointer = RegistrationPointer->Next;
    }
    Completion = FALSE;
DispatchExit:
    return Completion;
}

RtlDispatchException[3].c

BOOLEAN RtlDispatchException (
    IN PEXCEPTION_RECORD ExceptionRecord,
    IN PCONTEXT ContextRecord
    )
{
     PEXCEPTION_REGISTRATION_RECORD RegistrationFrame；
     PEXCEPTION_REGISTRATION_RECORD NestedFrame = NULL;
     DISPATCHER_CONTEXT DispatcherContext;
     EXCEPTION_RECORD ExceptionRecord2;
     EXCEPTION_DISPOSITION Disposition;
     ULONG_PTR StackLow, StackHigh;
     ULONG_PTR RegistrationFrameEnd;
    // 调用向量化异常处理程序(VEH)
    if (RtlCallVectoredExceptionHandlers(ExceptionRecord, Context))
    {
        // 异常被处理了就调用向量化异常处理程序(VCH)
        RtlCallVectoredContinueHandlers(ExceptionRecord, Context);
        // 返回已处理
        return TRUE;
    }
    // 获取当前栈顶以及栈限长
     RtlpGetStackLimits(&StackLow, &StackHigh);
     RegistrationFrame = RtlpGetExceptionList();
     // 不断循环遍历所有的 SEH 结构
    while (RegistrationFrame != EXCEPTION_CHAIN_END)
    {
        // 检查是否为空，一个被注册的异常结构永远不为空
        ASSERT(RegistrationFrame != NULL);
        // 获取异常结构的结束位置
        RegistrationFrameEnd = (ULONG_PTR)RegistrationFrame +
                                sizeof(EXCEPTION_REGISTRATION_RECORD);
        // 检查异常结构是否在栈内，并且是否对齐
        if ((RegistrationFrameEnd > StackHigh) ||
            ((ULONG_PTR)RegistrationFrame < StackLow) ||
            ((ULONG_PTR)RegistrationFrame & 0x3) ||
            !RtlIsValidHandler(SehBase->Handler))
        {
            // 如果不满足条件
            ExceptionRecord->ExceptionFlags |= EXCEPTION_STACK_INVALID;
            // 返回处理失败
            return FALSE;
        }
        // 如果启用了调试异常的记录，则记录异常
        RtlpCheckLogException(ExceptionRecord,
                            Context,
                            RegistrationFrame,
                            sizeof(*RegistrationFrame));
        // 调用异常处理函数， exception_handler4
        Disposition = RtlpExecuteHandlerForException(ExceptionRecord,
                                                    RegistrationFrame,
                                                    Context,
                                                    &DispatcherContext,
                                                    RegistrationFrame->Handler);
        // 如果是嵌套异常处理结构体
        if (RegistrationFrame == NestedFrame)
        {
            // 屏蔽嵌套标志位
            ExceptionRecord->ExceptionFlags &= ~EXCEPTION_NESTED_CALL;
            NestedFrame = NULL;
        }
        // 根据 SEH 函数的处理结果进行性对应的操作
        switch (Disposition)
        {
            // 继续执行
            case ExceptionContinueExecution:
                // 如果是一个不可继续的异常
                if (ExceptionRecord->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
                {
                    // 设置异常信息
                    ExceptionRecord2.ExceptionRecord = ExceptionRecord;
                    ExceptionRecord2.ExceptionCode = STATUS_NONCONTINUABLE_EXCEPTION;
                    ExceptionRecord2.ExceptionFlags = EXCEPTION_NONCONTINUABLE;
                    ExceptionRecord2.NumberParameters = 0;
                    RtlRaiseException(&ExceptionRecord2);
                }
                else
                {
                    // 调用向量化异常处理程序(VCH)
                    RtlCallVectoredContinueHandlers(ExceptionRecord,
                                                    Context);
                    return TRUE;
                }
            // 搜索下一层异常处理函数
            case ExceptionContinueSearch:
                break;
            // 如果是嵌套异常
            case ExceptionNestedException:
                ExceptionRecord->ExceptionFlags |= EXCEPTION_NESTED_CALL;
                if (DispatcherContext.RegistrationPointer > NestedFrame)
                {
                    NestedFrame = DispatcherContext.RegistrationPointer;
                }
                break;
            // 其它操作
            default:
                // 设置异常信息结构
                ExceptionRecord2.ExceptionRecord = ExceptionRecord;
                ExceptionRecord2.ExceptionCode = STATUS_INVALID_DISPOSITION;
                ExceptionRecord2.ExceptionFlags = EXCEPTION_NONCONTINUABLE;
                ExceptionRecord2.NumberParameters = 0;
                RtlRaiseException(&ExceptionRecord2);
                break;
        }
        // 获取下一个异常处理函数
        RegistrationFrame = RegistrationFrame->Next;
    }
    // 如果没有处理就返回 FALSE
    return FALSE;
}

windows逆向大师之路

20191231

复习

1. 如果所有的 SEH 都不能处理异常，那么最后会由谁处理异常

2. VCH 处理程序会在什么情况下被调用

3. SEH 是全局有效的么，它们被保存在什么地方

4. 什么是异常，什么是中断

5. 异常的种类有哪些，有什么特点？

6. windbg 中分别使用哪些系列的指令查看数据、修改数据、设置断点。

7. 陷阱处理器被保存在哪里，windbg中使用什么指令可以查看它。

8. 异常的产生方式有几种，分别是什么？

异常分发过程使用的函数以及具体的功能(int 3)

一、KiTrap03

二、 CommonDispatchException

三、 KiDispatchException

_Kitrap03.asm

CommonDispatchException.asm

KiDispatchException.c

KiUserExceptionDispatcher.c

KiUserExceptionDispatcher[3].c

RtlDispatchException[0].c

RtlDispatchException[3].c