想要调试一个程序有两种方法，第一种是使用CreateProcess函数创建进程并调试它，另一种是使用DebugActiveProcess函数附加到目标进程调试。这两个函数内部都会创建一个调试对象，将调试对象的句柄保存在调试线程的TEB中，将调试对象保存在目标进程的debugport中，这样两个进程就建立起了联系。当发生调试事件的时候，操作系统会将调试事件结构体挂入调试对象的事件链表中，调试器通过获取调试事件数据来达到调试的目的。
至此，我们已经与目标进程建立起了调试关系，接下来，我们主要来分析操作系统是怎么处理用户态调试事件的。
系统：Win10 1511 Build:10586.
0x0:IDT表
在保护模式下，当有中断或异常发生时，CPU是通过中断描述符表（Interrupt Descriptor Table,简称IDT）来寻找处理函数的。因此，可以说IDT表是CPU（硬件）与操作系统（软件）交接中断和异常的关口（Gate）。
简单来说，IDT表是一张位于物理内存中的线性表，共有256个表项。在IA-32E(64位)模式下，每个IDT表项长度是16个字节，IDT表的总长的是4096字节（4KB）。在32位模式下，每个IDT表项长度是8个字节，IDT表的总长度是2048字节（2KB）。32位与64位主要差异在于地址长度的变化。
IDT表的每个表项是一个所谓的门描述符（Gate Descriptor）结构。之所以这样称呼，是因为IDT表项的基本用途就是引领CPU从一个空间到另一个空间去执行，每个表项好像一个从一个空间到另一个空间的大门（Gate）。在穿越这扇门的时候，CPU会做必要的安全检查和准备工作。
IDT表可以包含以下3种描述符。
任务门（Task-gate）描述符：用于任务切换，里面包含用于选择任务状态段（TSS）的段选择子。可以使用JMP或CALL指令通过任务门来切换到任务门所指向的任务，当CPU因为中断或异常转移到任务门的时候，也会切换到指定的任务。
中断门（interrupt-gate）描述符：用于描述中断处理例程的入口。
陷阱们（trap-gate）描述符：用于描述异常处理例程的入口。
下图描述了3种门描述符内容布局:
0x1：调试的本质
调试的本质其实就是异常的处理，当异常发生时，会调用IDT表中对应的异常处理函数。
日常调试中主要用的有三种异常，硬件断点（设置调试寄存器产生的断点），软件断点（int3断点），内存断点（内存异常产生的断点）。不同类型的异常调用的处理程序略有不同，但是差别不大。
不同的异常（或中断）有不同的中断向量号。
当异常发生时，处理器会根据向量号去IDT表中查找对应的门描述符并且调用其处理程序。调用处理程序时，会根据门描述符的 TYPE位来确定要压栈的参数，根据CPL和DPL来判断需不需要切换栈。
当处理器调用异常处理程序时，如果CPL小于DPL，则会发生栈切换，也就是从用户栈切换到内核栈，内核栈的SS,ESP从TSS中获取。有关这方面的细节，请参考保护模式相关知识，这里不再详细说明。
本篇文章的重点在于异常发生后，操作系统的处理流程是什么样的，下面以int3断点的处理流程进行分析。
0x2:异常处理的起点
当代码运行到Int3时，会引发一个int3中断，CPU会去IDT找到3号中断所对应的IDT表项，执行对应的处理代码：
sub rsp, 8 push rbp sub rsp, 158h lea rbp, [rsp+80h] mov byte ptr [rbp-_KTRAP_FRAME.ExceptionActive], 1 mov [rbp-_KTRAP_FRAME.rax], rax mov [rbp-_KTRAP_FRAME.rcx], rcx mov [rbp-_KTRAP_FRAME.rdx], rdx mov [rbp-_KTRAP_FRAME.r8], r8 mov [rbp-_KTRAP_FRAME.r9], r9 mov [rbp-_KTRAP_FRAME.r10], r10 mov [rbp-_KTRAP_FRAME.r11], r11 test byte ptr [rbp+_KTRAP_FRAME.SegCs], 1 ; 判断CPL确定当前特权级别，如果是内核模式就跳转 jz short loc_14014A3E1 swapgs ; 切换GS寄存器，相当于x32的FS寄存器，在应用层指向的是TEB，在内核模式下应指向KPCR mov r10, gs:_KPCR.Prcb.CurrentThread test byte ptr [r10+CurrentThread.Header.DebugActive], 80h ; 判断UmsPrimary是否置位 jz short loc_14014A3CC mov ecx, 0C0000102h rdmsr shl rdx, 20h or rax, rdx cmp [r10+CurrentThread.Teb], rax jz short loc_14014A3CC cmp [r10+CurrentThread.TebMappedLowVa], rax jz short loc_14014A3CC mov rdx, [r10+CurrentThread.Ucb] bts dword ptr [r10+.CurrentThread.SystemAffinityActive], 8 dec word ptr [r10+CurrentThread.SpecialApcDisable] mov [rdx+80h], rax loc_14014A3CC: ; CODE XREF: KiBreakpointTrap+4E↑j ; KiBreakpointTrap+65↑j ... test byte ptr [r10+CurrentThread.Header.DebugActive], 3 ; 判断ActiveDR7或Instrumented是否置位 mov word ptr [rbp+_KTRAP_FRAME.ErrorCode], 0 jz short loc_14014A3E1 ; 如果ActiveDR7和Instrumented都没置位，则不保存调试寄存器 call KiSaveDebugRegisterState loc_14014A3E1: ; CODE XREF: KiBreakpointTrap+3B↑j 内核模式 ; KiBreakpointTrap+9A↑j cld ; stmxcsr dword ptr [rbp-_KTRAP_FRAME.MxCsr] ldmxcsr dword ptr gs:_KPCR.Prcb movaps xmmword ptr [rbp-_KTRAP_FRAME.Xmm0], xmm0 movaps xmmword ptr [rbp+_KTRAP_FRAME.xmm1], xmm1 movaps xmmword ptr [rbp+_KTRAP_FRAME.xmm2], xmm2 movaps xmmword ptr [rbp+_KTRAP_FRAME.xmm3], xmm3 movaps xmmword ptr [rbp+_KTRAP_FRAME.xmm4], xmm4 movaps xmmword ptr [rbp+_KTRAP_FRAME.xmm5], xmm5 test dword ptr [rbp+_KTRAP_FRAME.EFlags], 200h ; 判断Eflags寄存器的IF位，是否响应可屏蔽中断，置位则响应 jz short loc_14014A414 sti ; 将Eflags寄存器的IF位置位 loc_14014A414: ; CODE XREF: KiBreakpointTrap+D1↑j mov ecx, 80000003h ; 参数1：异常代码 mov edx, 1 参数2 mov r8, [rbp+0E8h] ; 触发异常的下一条指令 dec r8 参数3：重新指向Int3那条指令 mov r9d, 0 参数4 <strong>call KiExceptionDispatch</strong> nop retn</span>
可以看到，处理函数的主要工作就是构建了一个_KTRAP_FRAME结构体，操作系统用这个结构体保存异常处的执行环境，当异常处理完成的时候操作系统要根据这个结构体返回三环。
第一个sub rsp,8是因为要空出来一个ErrorCode的空间，因为处理器调用中断处理程序时会自动像栈中压入一些参数，int3中断压入的参数是SS,RSP,Eflags,CS,RIP,但是有的中断会在此之上在压入一个ErrorCode，所以Int3的处理程序为了统一，需要在入口处sub Rsp,8空出来一个ErrorCode的位置。
然后将rbp压栈，继续提升栈顶开始构建_KTRAP_FRAME结构体，保存好一些通用寄存器后，判断CPL是否为内核态，如果不是内核态则切换GS寄存器。在X64中，由GS寄存器替代了FS寄存器的作用，在应用层GS指向TEB，到内核层GS指向KPCR，所以如果不是应用层的话就需要切换GS寄存器。
然后根据CurrentThread.Header.DebugActive的ActiveDR7和Instrumented来判断是否要保存调试寄存器，当结构体构建完成后，就准备调用KiExceptionDispatch函数进行异常分发。
0x3:KiExceptionDispatch
需要指出的是nt!KiExceptionDispatch (和nt!KiBreakpointTrap一样)是用手工汇编写成。它假设ecx包含异常代码，edx是异常参数的数量(最多3个)，r8包含异常发生的地址，r9是第一个异常参数(如果有存在)，r10是第二个异常参数(如果存在)，r11是第三个异常参数(如果存在)，rbp指向_KTRAP_FRAME结构体中的一个段(位于偏移+0x80处)
sub rsp, 1D8h ; 提升栈顶，构建_KEXCEPTION_FRAME和_EXCEPTION_RECORD结构体 lea rax, [rsp+100h] movaps xmmword ptr [rsp+_KEXCEPTION_FRAME.xmm6], xmm6 movaps xmmword ptr [rsp+_KEXCEPTION_FRAME.xmm7], xmm7 movaps xmmword ptr [rsp+_KEXCEPTION_FRAME.xmm8], xmm8 movaps xmmword ptr [rsp+_KEXCEPTION_FRAME.xmm9], xmm9 movaps xmmword ptr [rsp+_KEXCEPTION_FRAME.xmm10], xmm10 movaps xmmword ptr [rax-_KEXCEPTION_FRAME.xmm11], xmm11 movaps xmmword ptr [rax-_KEXCEPTION_FRAME.xmm12], xmm12 movaps xmmword ptr [rax-_KEXCEPTION_FRAME.xmm13], xmm13 movaps xmmword ptr [rax-_KEXCEPTION_FRAME.xmm14], xmm14 movaps xmmword ptr [rax-_KEXCEPTION_FRAME.xmm15], xmm15 mov [rax+_KEXCEPTION_FRAME.rbx], rbx mov [rax+_KEXCEPTION_FRAME.rdi], rdi mov [rax+_KEXCEPTION_FRAME.rsi], rsi mov [rax+_KEXCEPTION_FRAME.r12], r12 mov [rax+_KEXCEPTION_FRAME.r13], r13 mov [rax+_KEXCEPTION_FRAME.r14], r14 mov [rax+_KEXCEPTION_FRAME.r15], r15 mov rax, gs:_KPCR.Prcb.CurrentThread bt dword ptr [rax+CurrentThread.SystemAffinityActive], 8 jnb short loc_14014CB7D test byte ptr [rbp+_KTRAP_FRAME.SegCs], 1 ; 通过CPL判断Previous mode,如果是内核模式则跳转 jz short loc_14014CB7D call KiUmsExceptionEntry ; ums线程相关 loc_14014CB7D: ; CODE XREF: KiExceptionDispatch+6D↑j ; KiExceptionDispatch+76↑j lea rax, [rsp+138h] ; rax指向_EXCEPTION_RECORD结构体 mov [rax+_EXCEPTION_RECORD.ExceptionCode], ecx xor ecx, ecx mov [rax+_EXCEPTION_RECORD.ExceptionFlags], ecx mov [rax+_EXCEPTION_RECORD.ExceptionRecord], rcx mov [rax+_EXCEPTION_RECORD.ExceptionAddress], r8 mov [rax+_EXCEPTION_RECORD.NumberParameters], edx mov [rax+_EXCEPTION_RECORD.ExceptionInformation[0]], r9 mov [rax+_EXCEPTION_RECORD.ExceptionInformation[1]], r10 mov [rax+_EXCEPTION_RECORD.ExceptionInformation[2]], r11 mov r9b, [rbp+_KTRAP_FRAME.SegCs] and r9b, 1 ; PreviousMode mov byte ptr [rsp+20h], 1 ; BOOLEAN FirstChance lea r8, [rbp-80h] ; PKTRAP_FRAME TrapFrame。Rbp指向的还是IDT函数中封装的TrapFrame结构体的腰部，RBP-80指向的就是TrapFrame结构体头部 mov rdx, rsp ; PKEXCEPTION_FRAME ExceptionFrame mov rcx, rax ; PEXCEPTION_RECORD ExceptionRecord call KiDispatchException 异常分发主函数
这个函数的逻辑很简单，函数入口首先就是提升栈顶，留出两个结构体的空间，分别是_KEXCEPTION_FRAME结构体和_EXCEPTION_RECORD结构体。构建完结构体后就调用了KiDispatchException函数用来进行异常分发。
0x4:KiDispatchException
KiDispatchException是异常分发的主函数，函数代码也比较复杂，汇编层次不清晰，所以直接放IDA伪代码了。
__fastcall KiDispatchException(_EXCEPTION_RECORD *ExceptionRecord, KEXCEPTION_FRAME *ExceptionFrame, KTRAP_FRAME *TrapFrame, char PreviousMode, char FirstChance) { char PreviousMode_1; // r15 KTRAP_FRAME *TrapFrame_1; // rsi KEXCEPTION_FRAME *ExceptionFrame_1; // r12 _EXCEPTION_RECORD *ExceptionRecord_1; // rbx signed int Contextflag; // er13 unsigned __int64 v10; // rcx signed __int64 v11; // rcx void *v12; // rsp void *v13; // rsp int v14; // edx unsigned __int64 result; // rax __int64 v16; // r8 bool DebugService; // al __int64 user.rsp; // r12 unsigned __int64 user.rsp_1; // rdx _BYTE *user_context; // r15 SIZE_T size; // rcx _QWORD *v22; // rdx _OWORD *v23; // rcx signed __int64 v24; // rcx __int64 v25; // rbx __int64 CurrentProcess_2; // r14 __int64 v27; // r8 ULONG_PTR PreviousMode_2; // [rsp+20h] [rbp-10h] __int64 SecondChance; // [rsp+28h] [rbp-8h] CONTEXT *Context; // [rsp+30h] [rbp+0h] __int64 CurrentProcess; // [rsp+38h] [rbp+8h] int Contextflag_1; // [rsp+40h] [rbp+10h] __int64 context.P4Home; // [rsp+48h] [rbp+18h] int v35; // [rsp+50h] [rbp+20h] unsigned int ContextLength; // [rsp+54h] [rbp+24h] __int64 ExceptionRecord_2; // [rsp+60h] [rbp+30h] __int64 context.SegCs; // [rsp+68h] [rbp+38h] __int64 ContextEx; // [rsp+70h] [rbp+40h] unsigned __int64 user.rsp_2; // [rsp+78h] [rbp+48h] __int64 TrapFrame_2; // [rsp+88h] [rbp+58h] _BYTE *user_context_1; // [rsp+90h] [rbp+60h] CONTEXT **v43; // [rsp+98h] [rbp+68h] __int64 CurrentProcess_1; // [rsp+A0h] [rbp+70h] MACHINE_FRAME *MachineFrame; // [rsp+A8h] [rbp+78h] __int64 ExceptionFrame_2; // [rsp+B0h] [rbp+80h] __int64 pDesBuffer; // [rsp+C0h] [rbp+90h] _OWORD *context.Rsp; // [rsp+C8h] [rbp+98h] int v49; // [rsp+E0h] [rbp+B0h] __int64 Context.rip; // [rsp+128h] [rbp+F8h] __int64 a3[2]; // [rsp+180h] [rbp+150h] __int64 v52; // [rsp+190h] [rbp+160h] PreviousMode_1 = PreviousMode; TrapFrame_1 = TrapFrame; ExceptionFrame_1 = ExceptionFrame; ExceptionRecord_1 = ExceptionRecord; ExceptionRecord_2 = (__int64)ExceptionRecord; ExceptionFrame_2 = (__int64)ExceptionFrame; TrapFrame_2 = (__int64)TrapFrame; LOBYTE(Context) = PreviousMode; CurrentProcess = *(_QWORD *)(__readgsqword(0x188u) + 0xB8);// CurrentThread.ApcState.Process CurrentProcess_1 = CurrentProcess; __incgsdword(0x5CB4u); // kpcr.kprcb.KeExceptionDispatchCount++ Contextflag = 0x10001F; Contextflag_1 = 0x10001F; if ( PreviousMode ) { if ( KeFeatureBits & 0x800000 ) Contextflag = 0x10005F; Contextflag_1 = Contextflag; } RtlGetExtendedContextLength(Contextflag); // 获取ExtendContext长度 v10 = ContextLength + 15i64; if ( v10 <= ContextLength ) v10 = 0xFFFFFFFFFFFFFF0i64; v11 = v10 & 0xFFFFFFFFFFFFFFF0ui64; v12 = alloca(v11); // 分配CONTEXT_EX内存 v13 = alloca(v11); v43 = &Context; v35 = RtlInitializeExtendedContext((__int64)&Context, Contextflag, (int **)&ContextEx); KeContextFromKframes(TrapFrame_1, ExceptionFrame_1, &Context);// 根据ExceptionFrame和TrapFrame结构体构造Context结构体 if ( ExceptionRecord_1->ExceptionCode == 0x80000003 ) --Context.rip; if ( PreviousMode_1 && *(_QWORD *)(CurrentProcess + 0x6F8) )// CurrentProcess.PicoContext 可能用于windows下的linux子系统 { LOBYTE(result) = PspPicoProviderRoutines_0(ExceptionRecord_1, ExceptionFrame_1, TrapFrame_1, 0i64, PreviousMode_1);// PspPicoProviderRoutines函数 if ( (_BYTE)result ) return result; // 如果异常解决了，就将Context转换成KFrames并返回 } else if ( (unsigned __int8)KiPreprocessFault(ExceptionRecord_1) )// 如果异常是内部通用保护错误、无效操作码或整数除以0，则尝试在不实际引发异常的情况下解决问题。 { LABEL_39: LOBYTE(result) = KeContextToKframes((__int64)TrapFrame_1); return result; } if ( !PreviousMode_1 ) // 判断PreviousMode，正式开始异常分发。 { if ( !FirstChance || (LOBYTE(SecondChance) = 0, LOBYTE(PreviousMode_2) = 0, !(unsigned __int8)KiDebugRoutine( // 第一次分发先交给调试器 TrapFrame_1, ExceptionFrame_1, ExceptionRecord_1, &Context, PreviousMode_2, SecondChance)) && !(unsigned __int8)RtlDispatchException(ExceptionRecord_1, &Context) )// 如果调试器不出来开始调用异常处理函数处理异常 { // 二次分发执行块 LOBYTE(SecondChance) = 1; LOBYTE(PreviousMode_2) = 0; if ( !(unsigned __int8)KiDebugRoutine( TrapFrame_1, ExceptionFrame_1, ExceptionRecord_1, &Context, PreviousMode_2, SecondChance) ) KeBugCheckEx( // 二次分发还没被调试器处理则蓝屏 0x1Eu, ExceptionRecord_1->ExceptionCode, (ULONG_PTR)ExceptionRecord_1->ExceptionAddress, ExceptionRecord_1->ExceptionInformation[0], ExceptionRecord_1->ExceptionInformation[1]); } goto LABEL_39; } v14 = (signed int)context.Rsp; context.P4Home = (__int64)context.Rsp; context.SegCs = (__int64)context.Rsp; // 这里IDA有错误，动态调试是存储在其他变量中的 if ( !(*(_DWORD *)(CurrentProcess + 0x6B4) & 1) )// CurrentProcess.Flags3.Minimal { result = __readgsqword(0x188u); if ( *(_QWORD *)(*(_QWORD *)(result + 0xB8) + 0x428i64)// CurrentThread.Apcstate.Process.WoW64Process && ExceptionRecord_1->ExceptionCode == 0x80000002 && TrapFrame_1->EFlags & 0x40000 ) { _disable(); TrapFrame_1->EFlags &= 0xFFFBFFFF; _enable(); return result; } if ( (context.SegCs & 0xFFF8) == 0x20 ) // 如果在执行32位代码时发生异常，则将异常转换为wow64异常 { if ( ExceptionRecord_1->ExceptionCode == 0x80000003 ) { ExceptionRecord_1->ExceptionCode = 0x4000001F; } else if ( ExceptionRecord_1->ExceptionCode == 0x80000004 ) { ExceptionRecord_1->ExceptionCode = 0x4000001E; } context.P4Home = v14 & 0xFFFFFFF0; context.SegCs = v14 & 0xFFFFFFF0; } } memset( (char *)ExceptionRecord_1 + 8 * (ExceptionRecord_1->NumberParameters + 4i64), 0, -8 * (ExceptionRecord_1->NumberParameters + 4i64) + 0x98);// 将exceptionrecord参数后面的内存清零，为了KdIsThisAKdTrap做准备 if ( FirstChance ) // 用户态第一次分发 { DebugService = KdIsThisAKdTrap(ExceptionRecord_1); if ( !*(_QWORD *)(*(_QWORD *)(__readgsqword(0x188u) + 0xB8) + 0x420i64) && !KdIgnoreUmExceptions || DebugService )// 如果当前进程没有被调试，并且没有设置忽略用户态异常，或者这是一个调试服务则执行下面代码 { LOBYTE(SecondChance) = 0; LOBYTE(PreviousMode_2) = PreviousMode_1; if ( (unsigned __int8)KiDebugRoutine( // 如果异常被调试器处理则返回 TrapFrame_1, ExceptionFrame_1, ExceptionRecord_1, &Context, PreviousMode_2, SecondChance) ) goto LABEL_39; } LOBYTE(result) = DbgkForwardException(ExceptionRecord_1, 1, 0i64); if ( !(_BYTE)result ) // 如果异常没被处理 { if ( !*(_QWORD *)(CurrentProcess + 0x6F8) // CurrentProcess.PicoContext || (LOBYTE(PreviousMode_2) = PreviousMode_1, LOBYTE(result) = PspPicoProviderRoutines_0(// PspPicoProviderRoutines ExceptionRecord_1, ExceptionFrame_1, TrapFrame_1, 1i64, PreviousMode_2), // CurrentProcess.PicoContext如果为零或者PspPicoProviderRoutines返回True执行 !(_BYTE)result) ) { _disable(); TrapFrame_1->EFlags &= 0xFFFFFEFF; // 清空TF标志位，调试标志位 _enable(); v49 = 0xC0000005; user.rsp = context.P4Home; user.rsp_1 = context.P4Home; user.rsp_2 = context.P4Home; if ( (Contextflag & 0x100040) == 0x100040 ) { user.rsp_1 = (context.P4Home - *(unsigned int *)(ContextEx + 0x14)) & 0xFFFFFFFFFFFFFFC0ui64; user.rsp_2 = (context.P4Home - *(unsigned int *)(ContextEx + 0x14)) & 0xFFFFFFFFFFFFFFC0ui64; } CurrentProcess = (user.rsp_1 - 0x28) & 0xFFFFFFFFFFFFFFF0ui64; MachineFrame = (MACHINE_FRAME *)((user.rsp_1 - 0x28) & 0xFFFFFFFFFFFFFFF0ui64);// 这里是开辟用户栈空间 -0x28是_MACHINE_FRAME大小 context.P4Home = CurrentProcess - 0xA0; // MachineFrame - EXCEPTION_RECORD_LENGTH;EXCEPTION_RECORD_LENGTH=sizeof(EXCEPTION_RECORD) + STACK_ROUND) & ~STACK_ROUND context.Rsp = (_OWORD *)(CurrentProcess - 0xA0); pDesBuffer = CurrentProcess - 0xC0; user_context = (_BYTE *)(CurrentProcess - 0x590);// context user_context_1 = (_BYTE *)(CurrentProcess - 0x590); LODWORD(a3[0]) = 0xFFFFFB30; size = user.rsp - (CurrentProcess - 0x590);// 计算出一共栈顶提升了多少字节 HIDWORD(a3[0]) = user.rsp - (CurrentProcess - 0x590); a3[1] = 0x4D0FFFFFB30i64; LODWORD(v52) = user.rsp_1 - (CurrentProcess - 0xC0); HIDWORD(v52) = user.rsp - user.rsp_1; if ( (unsigned __int64)(user.rsp - (CurrentProcess - 0x590) - 1) > 0xFFE ) { ProbeForWrite(user_context, size, 0x10u);// 检测内存地址是否正常，可写，并且不越界 v23 = (_OWORD *)context.P4Home; v22 = (_QWORD *)CurrentProcess; } else { if ( ((_BYTE)CurrentProcess + 0x70) & 0xF ) ExRaiseDatatypeMisalignment(); if ( user_context >= MmUserProbeAddress ) user_context = MmUserProbeAddress; *user_context = *user_context; user_context[size - 1] = user_context[size - 1]; v22 = &MachineFrame->Rip; v23 = context.Rsp; user_context = user_context_1; } v22[3] = user.rsp; *v22 = Context.rip; *v23 = *(_OWORD *)&ExceptionRecord_1->ExceptionCode; v23[1] = *(_OWORD *)&ExceptionRecord_1->ExceptionAddress; v23[2] = *(_OWORD *)ExceptionRecord_1->ExceptionInformation; v23[3] = *(_OWORD *)&ExceptionRecord_1->ExceptionInformation[2]; v23[4] = *(_OWORD *)&ExceptionRecord_1->ExceptionInformation[4]; v23[5] = *(_OWORD *)&ExceptionRecord_1->ExceptionInformation[6]; v23[6] = *(_OWORD *)&ExceptionRecord_1->ExceptionInformation[8]; v24 = (signed __int64)(v23 + 8); *(_OWORD *)(v24 - 16) = *(_OWORD *)&ExceptionRecord_1->ExceptionInformation[10]; *(_OWORD *)v24 = *(_OWORD *)&ExceptionRecord_1->ExceptionInformation[12]; *(_QWORD *)(v24 + 16) = ExceptionRecord_1->ExceptionInformation[14]; v25 = pDesBuffer; v35 = RtlpCopyExtendedContext(1, pDesBuffer, (__int64)a3, Contextflag, ContextEx, 0i64); *(_OWORD *)v25 = *(_OWORD *)a3; *(_QWORD *)(v25 + 16) = v52; _disable(); TrapFrame_1->Rsp = (ULONG64)user_context;// TrapFrame中的RSP设置为新的栈顶 TrapFrame_1->SegCs = 0x33; // 新的CS寄存器 TrapFrame_1->Rip = KeUserExceptionDispatcher;// 返回三环的落脚点，KeUserExceptionDispatcher调用三环的异常处理函数 LOBYTE(result) = KiSetupForInstrumentationReturn((__int64)TrapFrame_1); _enable(); } } } else // 用户态第二次分发 { CurrentProcess_2 = CurrentProcess; LOBYTE(v16) = 1; // SecondChance LOBYTE(result) = DbgkForwardException(ExceptionRecord_1, 1, v16);// 将SecondChance设置为True再次发送给调试器 if ( !(_BYTE)result ) // 如果还是没被处理，判断进程是不是一个Pico进程，如果是的话调用PspPicoProviderRoutines函数 { if ( !*(_QWORD *)(CurrentProcess_2 + 0x6F8)// CurrentProcess.PicoContext || (LOBYTE(PreviousMode_2) = PreviousMode_1, LOBYTE(result) = PspPicoProviderRoutines_0( ExceptionRecord_1, ExceptionFrame_1, TrapFrame_1, 2i64, PreviousMode_2), !(_BYTE)result) ) { LOBYTE(v27) = 1; LOBYTE(result) = DbgkForwardException(ExceptionRecord_1, 0, v27);// 发送给异常端口 if ( !(_BYTE)result ) LOBYTE(result) = ZwTerminateProcess(-1i64, (unsigned int)ExceptionRecord_1->ExceptionCode); } } } return result; }
前面说过，当异常处理完成时，系统要根据TrapFrame结构返回三环，所以该函数首先要备份一下TrapFrame和ExceptionFrame结构体到Context结构体。
if ( PreviousMode ) { if ( KeFeatureBits & 0x800000 ) Contextflag = 0x10005F; Contextflag_1 = Contextflag; } RtlGetExtendedContextLength(Contextflag); // 获取ExtendContext长度 v10 = ContextLength + 15i64; if ( v10 <= ContextLength ) v10 = 0xFFFFFFFFFFFFFF0i64; v11 = v10 & 0xFFFFFFFFFFFFFFF0ui64; v12 = alloca(v11); // 分配CONTEXT_EX内存 v13 = alloca(v11); v43 = &Context; v35 = RtlInitializeExtendedContext((__int64)&Context, Contextflag, (int **)&ContextEx); KeContextFromKframes(TrapFrame_1, ExceptionFrame_1, &Context);// 根据ExceptionFrame和TrapFrame结构体构造Context结构体
如果是int3异常呢，操作系统默认int3指令为cc，占1字节，所以将RIP减一指向触发异常的指令地址。但是其实INT3并不是只有1字节，也有2字节的。
if ( ExceptionRecord_1->ExceptionCode == 0x80000003 ) --Context.rip;
然后判断一下该进程是不是Pico进程，经过查阅资料得知，Pico应该是windows下的linux子系统的进程。PspPicoProviderRoutines可能是负责解决pico进程异常的函数，这是一个函数指针，在windbg中看当前指针为空，可能是由于调试系统并没有安装linux子系统组件的缘故。
如果不是pico进程，则尝试调用KiPreprocessFault处理异常，如果异常是内部通用保护错误，无效操作码或者除零错误，则尝试在不实际引发异常的情况下解决问题。
if ( PreviousMode_1 && *(_QWORD *)(CurrentProcess + 0x6F8) )// CurrentProcess.PicoContext 可能用于windows下的linux子系统 { LOBYTE(result) = PspPicoProviderRoutines_0(ExceptionRecord_1, ExceptionFrame_1, TrapFrame_1, 0i64, PreviousMode_1);// PspPicoProviderRoutines函数 if ( (_BYTE)result ) return result; // 如果异常解决了，就将Context转换成KFrames并返回 } else if ( (unsigned __int8)KiPreprocessFault(ExceptionRecord_1) )// 如果异常是内部通用保护错误、无效操作码或整数除以0，则尝试在不实际引发异常的情况下解决问题。 { LABEL_39: LOBYTE(result) = KeContextToKframes((__int64)TrapFrame_1); return result; }
之后就开始进行正式的异常分发，如果先前模式为内核模式，则调用KiDebugRoutine尝试将异常发给调试器。KiDebugRoutine这是内核的全局变量函数指针，当系统在被调试的状态下指向KdpTrap函数，非调试下指向KdpStub函数。KdpStub函数非常简单，只是做了一些简单的处理就返回了False。KdpTrap函数会将异常发送给内核调试器，如果返回True，代表调试器处理了这个异常，如果返回False，则代表没有处理这个异常。
在第一次分发的时候，首先把异常发给调试器，如果调试器处理了异常则直接返回。如果调试器没有处理异常，则调用RtlDispatchException执行内核异常处理函数。RtlDispatchException的返回值和KiDebugRoutine一样，如果返回True代表异常处理函数处理了异常，如果返回False则代表异常没被处理。
如果异常没被处理，操作系统会将SecondChance设置为True，并且再一次调用KiDebugRoutine，一般调试器在收到SecondChance为True的异常时都会中断，哪怕这个异常不是用户设置的异常。
因为当第二次分发KiDebugRoutine依旧返回False的时候，系统会直接调用KeBugCheckEx引发BSOD！也就是蓝屏~
if ( !PreviousMode_1 ) // 判断PreviousMode，正式开始异常分发。 { if ( !FirstChance || (LOBYTE(SecondChance) = 0, LOBYTE(PreviousMode_2) = 0, !(unsigned __int8)KiDebugRoutine( // 第一次分发先交给调试器 TrapFrame_1, ExceptionFrame_1, ExceptionRecord_1, &Context, PreviousMode_2, SecondChance)) && !(unsigned __int8)RtlDispatchException(ExceptionRecord_1, &Context) )// 如果调试器不出来开始调用异常处理函数处理异常 { // 二次分发执行块 LOBYTE(SecondChance) = 1; LOBYTE(PreviousMode_2) = 0; if ( !(unsigned __int8)KiDebugRoutine( TrapFrame_1, ExceptionFrame_1, ExceptionRecord_1, &Context, PreviousMode_2, SecondChance) ) KeBugCheckEx( // 二次分发还没被调试器处理则蓝屏 0x1Eu, ExceptionRecord_1->ExceptionCode, (ULONG_PTR)ExceptionRecord_1->ExceptionAddress, ExceptionRecord_1->ExceptionInformation[0], ExceptionRecord_1->ExceptionInformation[1]); } goto LABEL_39; }
当先前模式不是内核模式的时候，就要开始进行应用层的异常分发
首先判断了一下CurrentProcess.Flags3.Minimal，这个标志为零才会运行代码块里的内容，不知道这个标志代表什么。
然后判断如果进程是Wow64进程，也就是x32进程的话，并且异常代码是0x80000002，并且Eflag寄存器AC被置位，则这个异常可能是一个对齐异常，将Eflag的AC位清空然后返回。
然后判断通过CS判断如果是一个x32异常，则将异常转换为Wow64的异常代码。
if ( !(*(_DWORD *)(CurrentProcess + 0x6B4) & 1) )// CurrentProcess.Flags3.Minimal { result = __readgsqword(0x188u); if ( *(_QWORD *)(*(_QWORD *)(result + 0xB8) + 0x428i64)// CurrentThread.Apcstate.Process.WoW64Process && ExceptionRecord_1->ExceptionCode == 0x80000002 && TrapFrame_1->EFlags & 0x40000 ) { _disable(); TrapFrame_1->EFlags &= 0xFFFBFFFF; _enable(); return result; } if ( (context.SegCs & 0xFFF8) == 0x20 ) // 如果在执行32位代码时发生异常，则将异常转换为wow64异常 { if ( ExceptionRecord_1->ExceptionCode == 0x80000003 ) { ExceptionRecord_1->ExceptionCode = 0x4000001F; } else if ( ExceptionRecord_1->ExceptionCode == 0x80000004 ) { ExceptionRecord_1->ExceptionCode = 0x4000001E; } context.P4Home = v14 & 0xFFFFFFF0; context.SegCs = v14 & 0xFFFFFFF0; } }
然后将ExceptionRecord没有数据的内存清零，为了后面调用KdIsThisAKdTrap做准备。
调用KdIsThisAKdTrap判断这个异常是不是一个调试服务,当需要打印调试，征求用户输入，报告模块加载卸载时，系统会触发一个异常，编号为0x2D。通常把这个异常称之为调试服务（DebugService)异常。观察IDT表，可以看到这个异常的处理函数是KiDebugService,这个函数做了一些预处理工作后就跳转到了Int3中断处理函数，我们知道int3是断点异常的处理函数，因此，从KiDebugService跳转到int3后，要传递的调试信息会被当作断点异常的参数传给异常分发函数。ExceptionRecord结构中的ExceptionInfomation[0]标识了这个异常是一个真正的断点异常，还是一个调试服务异常，它可以是以下几个值之一：
BREAKPOINT_BREAK(0):真正的断点异常。
BREAKPOINT_PRINT(1):打印调试信息，ExceptionInformation[1]为要打印的字符串。
BREAKPOINT_PROMPT(2):提示并要求用户输入，ExceptionInformation[1]指向提示字符串，ExceptionInformation[2]用来指向存放用户输入的缓冲区。
BREAKPOINT_LOAD_SYMBOLS(3):加载符号文件，ExceptionInformation[1]指向模块文件名称，ExceptionInformation[2]是模块的基地址。
BREAKPOINT_UNLOAD_SYMBOLS(4):卸载符号文件：ExceptionInformation[1]指向模块文件名称，ExceptionInformation[2]是模块的基地址。
如果当前进程没有被调试，并且系统没有设置忽略用户态异常，或者这是一个调试服务则把异常发送给内核调试器，如果异常被内核调试器处理则直接返回。
memset( (char *)ExceptionRecord_1 + 8 * (ExceptionRecord_1->NumberParameters + 4i64), 0, -8 * (ExceptionRecord_1->NumberParameters + 4i64) + 0x98);// 将exceptionrecord参数后面的内存清零，为了KdIsThisAKdTrap做准备 if ( FirstChance ) // 用户态第一次分发 { DebugService = KdIsThisAKdTrap(ExceptionRecord_1); if ( !*(_QWORD *)(*(_QWORD *)(__readgsqword(0x188) + 0xB8) + 0x420) && !KdIgnoreUmExceptions || DebugService )// 如果当前进程没有被调试，并且没有设置忽略用户态异常，或者这是一个调试服务则执行下面代码 { LOBYTE(SecondChance) = 0; LOBYTE(PreviousMode_2) = PreviousMode_1; if ( (unsigned __int8)KiDebugRoutine( // 如果异常被调试器处理则返回 TrapFrame_1, ExceptionFrame_1, ExceptionRecord_1, &Context, PreviousMode_2, SecondChance) ) goto LABEL_39; }
如果没被内核调试器处理则开始调用DbgkForwardException尝试将异常发送给三环调试器，如果调试器返回False则代表异常没有被处理。
当调试器没有处理异常的时候，还是判断当前进程是不是pico进程，如果是调用PspPicoProviderRoutines处理异常，或者DbgkForwardException返回False的之后向下执行。
if代码块中代码主要任务就是将异常信息拷贝到三环栈中，然后返回三环去执行异常处理函数。
首先要清空TrapFrame_1中Eflag寄存器的调试标志位，避免回到三环的时候循环出发异常
由于Context多了一个扩展结构，这个结构的定义不太清楚，所以不能分析的太详细，能力有限。
数据拷贝完成后设置三环的落脚点为KeUserExceptionDispatcher，也就是三环的异常分发函数。
值得一提的是KiSetupForInstrumentationReturn函数将_kprocess结构体中的InstrumentationCallback设置成了RIP的地址，然后将原本的RIP保存在了R10寄存器中，百度查询说这个字段指向一个回调函数，每次从内核层返回用户层的时候会调用。
LOBYTE(result) = DbgkForwardException(ExceptionRecord_1, 1, 0); if ( !(_BYTE)result ) // 如果异常没被处理 { if ( !*(_QWORD *)(CurrentProcess + 0x6F8) // CurrentProcess.PicoContext || (LOBYTE(PreviousMode_2) = PreviousMode_1, LOBYTE(result) = PspPicoProviderRoutines_0(// PspPicoProviderRoutines ExceptionRecord_1, ExceptionFrame_1, TrapFrame_1, 1i64, PreviousMode_2), // CurrentProcess.PicoContext如果为零或者PspPicoProviderRoutines返回True执行 !(_BYTE)result) ) { _disable(); TrapFrame_1->EFlags &= 0xFFFFFEFF; // 清空TF标志位，调试标志位 _enable(); v49 = 0xC0000005; user.rsp = context.P4Home; user.rsp_1 = context.P4Home; user.rsp_2 = context.P4Home; if ( (Contextflag & 0x100040) == 0x100040 ) { user.rsp_1 = (context.P4Home - *(unsigned int *)(ContextEx + 0x14)) & 0xFFFFFFFFFFFFFFC0ui64; user.rsp_2 = (context.P4Home - *(unsigned int *)(ContextEx + 0x14)) & 0xFFFFFFFFFFFFFFC0ui64; } CurrentProcess = (user.rsp_1 - 0x28) & 0xFFFFFFFFFFFFFFF0ui64; MachineFrame = (MACHINE_FRAME *)((user.rsp_1 - 0x28) & 0xFFFFFFFFFFFFFFF0ui64);// 这里是开辟用户栈空间 -0x28是_MACHINE_FRAME大小 context.P4Home = CurrentProcess - 0xA0; // MachineFrame - EXCEPTION_RECORD_LENGTH;EXCEPTION_RECORD_LENGTH=sizeof(EXCEPTION_RECORD) + STACK_ROUND) & ~STACK_ROUND context.Rsp = (_OWORD *)(CurrentProcess - 0xA0); pDesBuffer = CurrentProcess - 0xC0; user_context = (_BYTE *)(CurrentProcess - 0x590);// context user_context_1 = (_BYTE *)(CurrentProcess - 0x590); LODWORD(a3[0]) = 0xFFFFFB30; size = user.rsp - (CurrentProcess - 0x590);// 计算出一共栈顶提升了多少字节 HIDWORD(a3[0]) = user.rsp - (CurrentProcess - 0x590); a3[1] = 0x4D0FFFFFB30i64; LODWORD(v52) = user.rsp_1 - (CurrentProcess - 0xC0); HIDWORD(v52) = user.rsp - user.rsp_1; if ( (unsigned __int64)(user.rsp - (CurrentProcess - 0x590) - 1) > 0xFFE ) { ProbeForWrite(user_context, size, 0x10u);// 检测内存地址是否正常，可写，并且不越界 v23 = (_OWORD *)context.P4Home; v22 = (_QWORD *)CurrentProcess; } else { if ( ((_BYTE)CurrentProcess + 0x70) & 0xF ) ExRaiseDatatypeMisalignment(); if ( user_context >= MmUserProbeAddress ) user_context = MmUserProbeAddress; *user_context = *user_context; user_context[size - 1] = user_context[size - 1]; v22 = &MachineFrame->Rip; v23 = context.Rsp; user_context = user_context_1; } v22[3] = user.rsp; *v22 = Context.rip; *v23 = *(_OWORD *)&ExceptionRecord_1->ExceptionCode; v23[1] = *(_OWORD *)&ExceptionRecord_1->ExceptionAddress; v23[2] = *(_OWORD *)ExceptionRecord_1->ExceptionInformation; v23[3] = *(_OWORD *)&ExceptionRecord_1->ExceptionInformation[2]; v23[4] = *(_OWORD *)&ExceptionRecord_1->ExceptionInformation[4]; v23[5] = *(_OWORD *)&ExceptionRecord_1->ExceptionInformation[6]; v23[6] = *(_OWORD *)&ExceptionRecord_1->ExceptionInformation[8]; v24 = (signed __int64)(v23 + 8); *(_OWORD *)(v24 - 16) = *(_OWORD *)&ExceptionRecord_1->ExceptionInformation[10]; *(_OWORD *)v24 = *(_OWORD *)&ExceptionRecord_1->ExceptionInformation[12]; *(_QWORD *)(v24 + 16) = ExceptionRecord_1->ExceptionInformation[14]; v25 = pDesBuffer; v35 = RtlpCopyExtendedContext(1, pDesBuffer, (__int64)a3, Contextflag, ContextEx, 0i64); *(_OWORD *)v25 = *(_OWORD *)a3; *(_QWORD *)(v25 + 16) = v52; _disable(); TrapFrame_1->Rsp = (ULONG64)user_context;// TrapFrame中的RSP设置为新的栈顶 TrapFrame_1->SegCs = 0x33; // 新的CS寄存器 TrapFrame_1->Rip = KeUserExceptionDispatcher;// 返回三环的落脚点，KeUserExceptionDispatcher调用三环的异常处理函数 LOBYTE(result) = KiSetupForInstrumentationReturn((__int64)TrapFrame_1); _enable(); }
用户层的第一次异常分发到这里就结束了。
下面就是用户层的第二次异常分发。
第二次用户层异常分发先是将SecondChance设置为True，然后调用DbgkForwardException尝试将异常发送给调试器，跟内核调试器一样，应用层调试器一般也都会处理SecondChance为True的异常。
如果DbgkForwardException还是返回False，那么系统会再次调用DbgkForwardException将这个异常发送给异常端口。
如果还是返回False的话，直接调用ZwTerminateProcess结束进程！
else // 用户态第二次分发 { CurrentProcess_2 = CurrentProcess; LOBYTE(v16) = 1; // SecondChance LOBYTE(result) = DbgkForwardException(ExceptionRecord_1, 1, v16);// 将SecondChance设置为True再次发送给调试器 if ( !(_BYTE)result ) // 如果还是没被处理，判断进程是不是一个Pico进程，如果是的话调用PspPicoProviderRoutines函数 { if ( !*(_QWORD *)(CurrentProcess_2 + 0x6F8)// CurrentProcess.PicoContext || (LOBYTE(PreviousMode_2) = PreviousMode_1, LOBYTE(result) = PspPicoProviderRoutines_0( ExceptionRecord_1, ExceptionFrame_1, TrapFrame_1, 2i64, PreviousMode_2), !(_BYTE)result) ) { LOBYTE(v27) = 1; LOBYTE(result) = DbgkForwardException(ExceptionRecord_1, 0, v27);// 发送给异常端口 if ( !(_BYTE)result ) LOBYTE(result) = ZwTerminateProcess(-1i64, (unsigned int)ExceptionRecord_1->ExceptionCode); } } } return result; }
0x5:DbgkForwardException
在经历KiDispatchException的异常分发后，用户态异常终于来到了DbgkForwardException函数，这个函数主要的任务是将异常结构转换为DBGKM_MSG结构，然后根据不同的参数选择发送给异常端口还是调试端口，废话不多说，直接上代码：
bool __fastcall DbgkForwardException(EXCEPTION_RECORD *ExceptionRecord, char DebugPort, __int64 SecondChance) { char SecondChance_1; // r15 char DebugPort_1; // di EXCEPTION_RECORD *ExceptionRecord_1; // r12 char UseLpc; // r14 unsigned __int64 CurrentThrad; // rax ULONG_PTR CurrentProcess; // rsi void *DebugObject; // rbx __int128 v11; // xmm1 ULONG_PTR v12; // rax __int128 v13; // xmm0 __int128 v14; // xmm1 __int128 v15; // xmm0 __int128 v16; // xmm1 __int128 v17; // xmm0 __int128 v18; // xmm1 int result; // esi signed int ReturnedStatus; // eax __int64 v21; // [rsp+20h] [rbp-E0h] DBGKM_MSG ApiMessage; // [rsp+30h] [rbp-D0h] SecondChance_1 = SecondChance; DebugPort_1 = DebugPort; ExceptionRecord_1 = ExceptionRecord; UseLpc = 1; if ( (_BYTE)SecondChance ) { v21 = 1i64; PsSetProcessFaultInformation(*(_QWORD *)(__readgsqword(0x188u) + 0xB8), &v21);// 如果是第二次分发，调用PsSetProcessFaultInformation设置进程故障信息 } ApiMessage.ApiNumber = 0; ApiMessage.h.u1.Length = 0xD000A8; ApiMessage.h.u2.ZeroInit = 8; CurrentThrad = __readgsqword(0x188u); CurrentProcess = *(_QWORD *)(CurrentThrad + 0xB8); if ( DebugPort_1 ) // 是否发送给调试端口 { if ( *(_DWORD *)(__readgsqword(0x188u) + 0x6BC) & 4 )// 判断是否设置了CrossThreadFlags.HideFromDebugger,如果设置了HideFromDebugger标志位，则将调试对象清零 DebugObject = 0i64; else DebugObject = *(void **)(CurrentProcess + 0x420);// 如果没有设置HideFromDebugger位则获取调试对象 UseLpc = 0; } else { DebugObject = (void *)PsCaptureExceptionPort(*(_QWORD *)(CurrentThrad + 0xB8));// 获取异常端口对象 ApiMessage.h.u2.ZeroInit = 7; } if ( !DebugObject && DebugPort_1 ) // 如果DebugObject为空则返回False return 0; v11 = *(_OWORD *)&ExceptionRecord_1->ExceptionAddress;// 开始构建ApiMessage结构 *(_OWORD *)&ApiMessage.u.Exception.ExceptionRecord.ExceptionCode = *(_OWORD *)&ExceptionRecord_1->ExceptionCode; v12 = ExceptionRecord_1->ExceptionInformation[14]; v13 = *(_OWORD *)ExceptionRecord_1->ExceptionInformation; *((_OWORD *)&ApiMessage.u.UnloadDll + 1) = v11; v14 = *(_OWORD *)&ExceptionRecord_1->ExceptionInformation[2]; *((_OWORD *)&ApiMessage.u.UnloadDll + 2) = v13; v15 = *(_OWORD *)&ExceptionRecord_1->ExceptionInformation[4]; *((_OWORD *)&ApiMessage.u.UnloadDll + 3) = v14; v16 = *(_OWORD *)&ExceptionRecord_1->ExceptionInformation[6]; *((_OWORD *)&ApiMessage.u.UnloadDll + 4) = v15; v17 = *(_OWORD *)&ExceptionRecord_1->ExceptionInformation[8]; *((_OWORD *)&ApiMessage.u.UnloadDll + 5) = v16; v18 = *(_OWORD *)&ExceptionRecord_1->ExceptionInformation[12]; *((_OWORD *)&ApiMessage.u.UnloadDll + 6) = v17; *((_OWORD *)&ApiMessage.u.UnloadDll + 7) = *(_OWORD *)&ExceptionRecord_1->ExceptionInformation[10]; *((_OWORD *)&ApiMessage.u.UnloadDll + 8) = v18; ApiMessage.u.Exception.ExceptionRecord.ExceptionInformation[14] = v12; ApiMessage.u.Exception.FirstChance = SecondChance_1 == 0; if ( !UseLpc ) { result = DbgkpSendApiMessage(CurrentProcess, DebugPort_1 != 0, (__int64)&ApiMessage);// 调用DbgkpSendApiMessage发送刚才构建的结构体，如果是发送给调试端口，则挂起进程 goto LABEL_15; } if ( DebugObject ) { // 如果执行到这里，代表是发送给异常端口的 LOBYTE(SecondChance) = DebugPort_1; result = DbgkpSendApiMessageLpc(&ApiMessage, DebugObject, SecondChance); ObfDereferenceObject(DebugObject); LABEL_15: ReturnedStatus = ApiMessage.ReturnedStatus; // 获取ApiMessage中的ReturnStatus，判断异常是否处理。 goto LABEL_16; } ReturnedStatus = 0x80010001; result = 0; ApiMessage.ReturnedStatus = 0x80010001; LABEL_16: if ( result < 0 ) // 返回值是NTSTATUS类型，如果小于0则代表失败，直接返回0代表异常未处理。 return 0; if ( ReturnedStatus == 0x80010001 ) // 如果返回值不小于零，代表函数没有出错，这种情况下通过ApiMessage的ReturnStatus判断异常是否被处理，如果等于0x80010001代表异常没被处理。 { if ( !DebugPort_1 ) // 如果Debugport为0，代表这是要发送给异常端口的异常，对于这种异常，调用DbgkpSendErrorMessage发送错误消息。 { ReturnedStatus = DbgkpSendErrorMessage(ExceptionRecord_1, 2i64, &ApiMessage); return ReturnedStatus >= 0; } return 0; } return ReturnedStatus >= 0; // 如果DbgkpSendApiMessage返回值正常，并且ApiMessage.ReturnStatus的值也不等于0x80010001,这代表异常被成功处理，直接返回True. }
函数首先显示判断了是否是第二次分发，如果是第二次分发则设置进程故障信息，毕竟如果这次异常还是没被处理的话进程就直接被干掉了~
if ( (_BYTE)SecondChance ) { v21 = 1i64; PsSetProcessFaultInformation(*(_QWORD *)(__readgsqword(0x188u) + 0xB8), &v21);// 如果是第二次分发，调用PsSetProcessFaultInformation设置进程故障信息 }
接下来就开始简单的初始化DBGKM_MSG结构了，然后根据是是发送给异常端口还是调试端口，开始获取对应的对象。
如果是要发送给调试端口，则首先要检测一下CurrentThread.CrossThreadFlags.HideFromDebugger标志位是否被置位，如果这个标志被置位则直接将存储调试对象的变量置为零。这个标志位可以让这个线程的异常不走调试器，走正常的异常分发，这也是一个反调试的手段。
这个标志位可以调用ZwSetInformationThread函数来设置，这个函数是windows未公开的一个函数，在NTDLL模块导出，可以使用GetProcAddress来获取，这里不详细说明，有兴趣的可以去查资料。
如果HideFromDebugger没被置零，则通过进程结构体获取调试对象（CurrentProcess.DebugPort）.
如果不是发送给调试端口的，则调用PsCaptureExceptionPort获取异常端口对象。
ApiMessage.ApiNumber = 0; ApiMessage.h.u1.Length = 0xD000A8; ApiMessage.h.u2.ZeroInit = 8; CurrentThrad = __readgsqword(0x188u); CurrentProcess = *(_QWORD *)(CurrentThrad + 0xB8); if ( DebugPort_1 ) // 是否发送给调试端口 { if ( *(_DWORD *)(__readgsqword(0x188u) + 0x6BC) & 4 )// 判断是否设置了CrossThreadFlags.HideFromDebugger,如果设置了HideFromDebugger标志位，则将调试对象清零 DebugObject = 0i64; else DebugObject = *(void **)(CurrentProcess + 0x420);// 如果没有设置HideFromDebugger位则获取调试对象 UseLpc = 0; } else { DebugObject = (void *)PsCaptureExceptionPort(*(_QWORD *)(CurrentThrad + 0xB8));// 获取异常端口对象 ApiMessage.h.u2.ZeroInit = 7; }</span> 然后开始判断调试对象是否获取成功，如果调试对象为零，并且参数是要发送给调试对象，则直接返回False. 然后开始根据ExceptionRecord开始构建DBGKM_MSG结构体。 <span style="font-family:Courier New,Courier,monospace">if ( !DebugObject && DebugPort_1 ) // 如果DebugObject为空则返回False return 0; v11 = *(_OWORD *)&ExceptionRecord_1->ExceptionAddress;// 开始构建ApiMessage结构 *(_OWORD *)&ApiMessage.u.Exception.ExceptionRecord.ExceptionCode = *(_OWORD *)&ExceptionRecord_1->ExceptionCode; v12 = ExceptionRecord_1->ExceptionInformation[14]; v13 = *(_OWORD *)ExceptionRecord_1->ExceptionInformation; *((_OWORD *)&ApiMessage.u.UnloadDll + 1) = v11; v14 = *(_OWORD *)&ExceptionRecord_1->ExceptionInformation[2]; *((_OWORD *)&ApiMessage.u.UnloadDll + 2) = v13; v15 = *(_OWORD *)&ExceptionRecord_1->ExceptionInformation[4]; *((_OWORD *)&ApiMessage.u.UnloadDll + 3) = v14; v16 = *(_OWORD *)&ExceptionRecord_1->ExceptionInformation[6]; *((_OWORD *)&ApiMessage.u.UnloadDll + 4) = v15; v17 = *(_OWORD *)&ExceptionRecord_1->ExceptionInformation[8]; *((_OWORD *)&ApiMessage.u.UnloadDll + 5) = v16; v18 = *(_OWORD *)&ExceptionRecord_1->ExceptionInformation[12]; *((_OWORD *)&ApiMessage.u.UnloadDll + 6) = v17; *((_OWORD *)&ApiMessage.u.UnloadDll + 7) = *(_OWORD *)&ExceptionRecord_1->ExceptionInformation[10]; *((_OWORD *)&ApiMessage.u.UnloadDll + 8) = v18; ApiMessage.u.Exception.ExceptionRecord.ExceptionInformation[14] = v12; ApiMessage.u.Exception.FirstChance = SecondChance_1 == 0;
然后就开始调用函数发送刚才构建的结构体了。
这里判断是否使用LPC，这个UseLPC变量是一个内部变量，初始化赋值为True，在获取调试对象时候赋值为False。
如果不使用LPC则调用DbgkpSendApiMessage函数发送结构体，函数中参数并没有调试对象，需要在函数内部获取。函数的第二个参数代表是否挂起进程。
如果不是发送给调试端口则判断DebugObject是否为零，这个变量中存储的不一定是调试对象，如果是发送给异常端口的话这个变量中存储的就是异常端口对象。
函数返回后首先判断函数返回值是否正常，如果函数返回值不正常则直接返回False.如果函数返回值正常，则判断ApiMessage.ReturnedStatus是否等于0x80010001，这个成员代表异常是否被调试器处理，如果等于0x80010001代表调试器未处理。
如果调试器 未处理异常，判断是否是发送给异常端口的，如果发送给异常端口则调用DbgkpSendErrorMessage发送错误消息，如果DbgkpSendErrorMessage返回值大于等于0，则返回True，否则返回False.
if ( !UseLpc ) { result = DbgkpSendApiMessage(CurrentProcess, DebugPort_1 != 0, (__int64)&ApiMessage);// 调用DbgkpSendApiMessage发送刚才构建的结构体，如果是发送给调试端口，则挂起进程 goto LABEL_15; } if ( DebugObject ) { // 如果执行到这里，代表是发送给异常端口的 LOBYTE(SecondChance) = DebugPort_1; result = DbgkpSendApiMessageLpc(&ApiMessage, DebugObject, SecondChance); ObfDereferenceObject(DebugObject); LABEL_15: ReturnedStatus = ApiMessage.ReturnedStatus; // 获取ApiMessage中的ReturnStatus，判断异常是否处理。 goto LABEL_16; } ReturnedStatus = 0x80010001; result = 0; ApiMessage.ReturnedStatus = 0x80010001; LABEL_16: if ( result < 0 ) // 返回值是NTSTATUS类型，如果小于0则代表失败，直接返回0代表异常未处理。 return 0; if ( ReturnedStatus == 0x80010001 ) // 如果返回值不小于零，代表函数没有出错，这种情况下通过ApiMessage的ReturnStatus判断异常是否被处理，如果等于0x80010001代表异常没被处理。 { if ( !DebugPort_1 ) // 如果Debugport为0，代表这是要发送给异常端口的异常，对于这种异常，调用DbgkpSendErrorMessage发送错误消息。 { ReturnedStatus = DbgkpSendErrorMessage(ExceptionRecord_1, 2i64, &ApiMessage); return ReturnedStatus >= 0; } return 0; } return ReturnedStatus >= 0; // 如果DbgkpSendApiMessage返回值正常，并且ApiMessage.ReturnStatus的值也不等于0x80010001,这代表异常被成功处理，直接返回True. }
0x6:DbgkpSendApiMessage
DbgkForwardException函数根据异常结构体构造了一个DBGKM_MSG结构体后，通过DbgkpSendApiMessage函数来发送调试事件。
函数首先判断PerfGlobalGroupMask是否开启了调试事件追踪，如果是就调用EtwTraceDebuggerEvent。
判断如果当前进程是指定进程，并且指定要挂起进程，则调用DbgkpSuspendProcess挂起进程，然后调用DbgkpQueueMessage将调试消息插入队列。
然后调用ZwFlushInstructionCache刷新指令缓存，这个函数的意思不太了解，百度说是刷新指令缓存。
然后恢复进程运行，判断DbgkpQueueMessage返回值和ApiMessage返回值，如果都正常就返回了，不正常在循环调用一次。
这个函数的工作主要就是挂起进程，主要的工作都是调用DbgkpQueueMessage来做的。
__int64 __fastcall DbgkpSendApiMessage(ULONG_PTR CurrentProcess, char SuspendProcess, DBGKM_MSG *ApiMessage) { DBGKM_MSG *ApiMessage_1; // r15 char SuspendProcess_1; // bp ULONG_PTR CurrentProcess_1; // rbx int v6; // er14 unsigned int v7; // esi ApiMessage_1 = ApiMessage; SuspendProcess_1 = SuspendProcess; CurrentProcess_1 = CurrentProcess; if ( PerfGlobalGroupMask & 0x400000 ) EtwTraceDebuggerEvent(*(_QWORD *)(__readgsqword(0x188u) + 0xB8), __readgsqword(0x188u), 1); do { v6 = 0; if ( CurrentProcess_1 == *(_QWORD *)(__readgsqword(0x188u) + 0xB8) && SuspendProcess_1 & 1 )// 如果参数指定的进程等于当前进程，并且设置挂起进程，则调用DbgkpSuspendProcess挂起进程。 v6 = (unsigned __int8)DbgkpSuspendProcess(CurrentProcess_1); ApiMessage_1->ReturnedStatus = 0x103; v7 = DbgkpQueueMessage( CurrentProcess_1, __readgsqword(0x188u), ApiMessage_1, (SuspendProcess_1 & 2) != 0 ? 0x40 : 0, 0i64); ZwFlushInstructionCache(); // 刷新指令缓存 if ( v6 ) // 根据是否冻结进程判定是否解冻进程 { PsThawProcess(CurrentProcess_1, 0i64); KeLeaveCriticalRegion(); } } while ( (v7 & 0x80000000) == 0 && ApiMessage_1->ReturnedStatus == 0x40010001 );// 如果返回值没出错，并且ApiMessage的返回状态为0x40010001，则创新调用DbgkpQueueMessage函数 return v7; }
0x7:DbgkpQueueMessage
这个函数的主要任务就是根据DBGKM_MSG构建一个调试事件，并且将这个事件挂入事件链表中，这也是用户态调试的最后一个函数。
__int64 __usercall DbgkpQueueMessage@<rax>(ULONG_PTR CurrentProcess@<rcx>, ULONG_PTR CurrentThrad@<rdx>, DBGKM_MSG *ApiMessage@<r8>, int Flags@<r9d>, PRKEVENT a5) { _DEBUG_OBJECT *DebugObject; // rbx signed __int64 v6; // r12 int Flags_1; // esi DBGKM_MSG *ApiMessage_1; // rbp ULONG_PTR CurrentThrad_1; // r15 ULONG_PTR CurrentProcess_1; // r13 _DEBUG_EVENT *DebugEvent; // rax _DEBUG_EVENT *DebugEvent_1; // r14 DBGKM_APINUMBER ApiNumber; // ecx DBGKM_MSG *v15; // rsi DBGKM_MSG *v16; // rax DBGKM_MSG *v17; // rcx signed __int64 v18; // rdx __int128 v19; // xmm1 signed int result; // ebx struct _FAST_MUTEX *debug_Mutex; // r12 _LIST_ENTRY *v22; // rcx __int128 v23; // xmm1 int NOWAIT; // [rsp+30h] [rbp-1C8h] _DEBUG_EVENT v25; // [rsp+40h] [rbp-1B8h] DebugObject = (_DEBUG_OBJECT *)a5; v6 = 2i64; Flags_1 = Flags; ApiMessage_1 = ApiMessage; NOWAIT = Flags & 2; // NOWAIT CurrentThrad_1 = CurrentThrad; CurrentProcess_1 = CurrentProcess; if ( Flags & 2 ) // DEBUG_EVENT_NOWAIT,检查Flag是否设置了NOWAIT标志，如果没有设置，函数需要等待调试器回复，如果设置了这个标志，则不需要等待调试器 { DebugEvent = (_DEBUG_EVENT *)ExAllocatePoolWithQuotaTag((POOL_TYPE)0x208, 0x168ui64, 0x45676244u);// 如果不需要等待调试器回复，则不能使用栈中的内存构建DEBUG_EVENT结构体，需要分配堆内存 DebugEvent_1 = DebugEvent; if ( !DebugEvent ) return 0xC000009Ai64; DebugEvent->Flags = Flags_1 | 4; ObfReferenceObjectWithTag(CurrentProcess_1, 1332175428i64); ObfReferenceObjectWithTag(CurrentThrad_1, 1332175428i64); DebugEvent_1->BackoutThread = (PETHREAD)__readgsqword(0x188u); } else { // 等待调试器回复 v25.Flags = Flags; DebugEvent_1 = &v25; ExAcquireFastMutex(&DbgkpProcessDebugPortMutex); ApiNumber = ApiMessage_1->ApiNumber; DebugObject = *(_DEBUG_OBJECT **)(CurrentProcess_1 + 0x420); if ( (unsigned int)(ApiNumber - 1) <= 1 && *(_BYTE *)(CurrentThrad_1 + 0x6BC) & 0x40 )// 判断这个事件如果是线程进程创建，并且线程设置了SkipCreationMsg，则将DebugObject设置为零 DebugObject = 0i64; if ( ApiNumber == 5 && (unsigned __int8)Flags_1 & *(_BYTE *)(CurrentThrad_1 + 0x6BC) & 0x40 )// 判断这个事件如果是模块加载，并且线程设置了SkipCreationMsg，则将DebugObject设置为零 DebugObject = 0i64; if ( (unsigned int)(ApiNumber - 3) <= 1 && *(_BYTE *)(CurrentThrad_1 + 0x6BC) < 0 )// 判断这个事件如果是线程进程退出，并且线程设置了SkipTerminationMsg，则将DebugObject设置为零，这里F5有错误，实际上后面会&0x80 DebugObject = 0i64; KeInitializeEvent(&v25.ContinueEvent, SynchronizationEvent, 0);// 初始化一个同步对象，为了等待调试器回复 } v15 = &DebugEvent_1->ApiMsg; DebugEvent_1->Process = (PEPROCESS)CurrentProcess_1; v16 = &DebugEvent_1->ApiMsg; DebugEvent_1->Thread = (PETHREAD)CurrentThrad_1; v17 = ApiMessage_1; v18 = 2i64; do { *(_OWORD *)&v16->h.u1.s1.DataLength = *(_OWORD *)&v17->h.u1.s1.DataLength; *(union _PORT_MESSAGE::$C6BC508B531A81D74C33985719C23F49 *)((char *)&v16->h.8 + 8) = *(union _PORT_MESSAGE::$C6BC508B531A81D74C33985719C23F49 *)((char *)&v17->h.8 + 8); *(_OWORD *)&v16->h.ClientViewSize = *(_OWORD *)&v17->h.ClientViewSize; *(_OWORD *)&v16->u.Exception.ExceptionRecord.ExceptionCode = *(_OWORD *)&v17->u.Exception.ExceptionRecord.ExceptionCode; *((_OWORD *)&v16->u.UnloadDll + 1) = *((_OWORD *)&v17->u.UnloadDll + 1); *((_OWORD *)&v16->u.UnloadDll + 2) = *((_OWORD *)&v17->u.UnloadDll + 2); *((_OWORD *)&v16->u.UnloadDll + 3) = *((_OWORD *)&v17->u.UnloadDll + 3); v16 = (DBGKM_MSG *)((char *)v16 + 128); v19 = *((_OWORD *)&v17->u.UnloadDll + 4); v17 = (DBGKM_MSG *)((char *)v17 + 128); *((_OWORD *)&v16[-1].u.UnloadDll + 9) = v19; --v18; } while ( v18 ); *(_OWORD *)&v16->h.u1.s1.DataLength = *(_OWORD *)&v17->h.u1.s1.DataLength; _mm_storeu_si128((__m128i *)&DebugEvent_1->ClientId, *(__m128i *)(CurrentThrad_1 + 0x628)); if ( DebugObject ) // 判断获取调试对象是否正常 { debug_Mutex = &DebugObject->Mutex; ExAcquireFastMutex(&DebugObject->Mutex); // 获取调试对象的互斥体 if ( DebugObject->Flags & 1 ) // 判断调试器是否处于活跃状态，如果不是则返回c0000354 { result = 0xC0000354; } else { v22 = DebugObject->EventList.Blink; // 将调试事件挂入到调试对象的事件链表中 DebugEvent_1->EventList.Flink = &DebugObject->EventList; DebugEvent_1->EventList.Blink = v22; if ( v22->Flink != &DebugObject->EventList ) __fastfail(3u); v22->Flink = &DebugEvent_1->EventList; DebugObject->EventList.Blink = &DebugEvent_1->EventList; if ( !NOWAIT ) KeSetEvent(&DebugObject->EventsPresent, 0, 0);// 如果不是NOWAIT状态，触发EventsPresent这个事件，通知调试器来处理调试事件。 result = 0; } KeReleaseGuardedMutex(debug_Mutex); // 释放调试对象的互斥体 v6 = 2i64; } else { // 如果调试对象获取失败，则返回c00000353 result = 0xC0000353; } if ( NOWAIT ) { if ( result < 0 ) // 如果返回值出错，则释放引用的进程线程对象，释放分配的DebugEvent内存 { ObfDereferenceObjectWithTag(CurrentProcess_1); ObfDereferenceObjectWithTag(CurrentThrad_1); ExFreePoolWithTag(DebugEvent_1, 0); } } else { KeReleaseGuardedMutex(&DbgkpProcessDebugPortMutex);// 释放DbgkpProcessDebugPortMutex互斥锁 if ( result >= 0 ) { KeWaitForSingleObject(&DebugEvent_1->ContinueEvent, 0, 0, 0, 0i64);// 等待调试事件的ContinueEvent，当事件被调试器处理完成的时候这个对象会被触发，当前线程也会被唤醒。 result = DebugEvent_1->Status; do // 通过调试事件的状态来设置ApiMessage，因为上一个函数需要通过ApiMessage的返回值决定下一步的行为。 { *(_OWORD *)&ApiMessage_1->h.u1.s1.DataLength = *(_OWORD *)&v15->h.u1.s1.DataLength; *(union _PORT_MESSAGE::$C6BC508B531A81D74C33985719C23F49 *)((char *)&ApiMessage_1->h.8 + 8) = *(union _PORT_MESSAGE::$C6BC508B531A81D74C33985719C23F49 *)((char *)&v15->h.8 + 8); *(_OWORD *)&ApiMessage_1->h.ClientViewSize = *(_OWORD *)&v15->h.ClientViewSize; *(_OWORD *)&ApiMessage_1->u.Exception.ExceptionRecord.ExceptionCode = *(_OWORD *)&v15->u.Exception.ExceptionRecord.ExceptionCode; *((_OWORD *)&ApiMessage_1->u.UnloadDll + 1) = *((_OWORD *)&v15->u.UnloadDll + 1); *((_OWORD *)&ApiMessage_1->u.UnloadDll + 2) = *((_OWORD *)&v15->u.UnloadDll + 2); *((_OWORD *)&ApiMessage_1->u.UnloadDll + 3) = *((_OWORD *)&v15->u.UnloadDll + 3); ApiMessage_1 = (DBGKM_MSG *)((char *)ApiMessage_1 + 128); v23 = *((_OWORD *)&v15->u.UnloadDll + 4); v15 = (DBGKM_MSG *)((char *)v15 + 128); *((_OWORD *)&ApiMessage_1[-1].u.UnloadDll + 9) = v23; --v6; } while ( v6 ); *(_OWORD *)&ApiMessage_1->h.u1.s1.DataLength = *(_OWORD *)&v15->h.u1.s1.DataLength; } } return (unsigned int)result; }
首先判断了参数中Flags是否指定了NOWAIT标志，如果指定了NOWAIT标志代表不需要等待调试器处理完直接返回。
如果指定了NOWAIT标志，就调用ExAllocatePoolWithQuotaTag分配DebugEvent的内存，因为如果不等待直接返回就不能用栈内存。
分配完内存后检查是否分配成功，如果未分配成功则直接返回。
if ( Flags & 2 ) // DEBUG_EVENT_NOWAIT,检查Flag是否设置了NOWAIT标志，如果没有设置，函数需要等待调试器回复，如果设置了这个标志，则不需要等待调试器 { DebugEvent = (_DEBUG_EVENT *)ExAllocatePoolWithQuotaTag((POOL_TYPE)0x208, 0x168ui64, 0x45676244u);// 如果不需要等待调试器回复，则不能使用栈中的内存构建DEBUG_EVENT结构体，需要分配堆内存 DebugEvent_1 = DebugEvent; if ( !DebugEvent ) return 0xC000009Ai64; DebugEvent->Flags = Flags_1 | 4; ObfReferenceObjectWithTag(CurrentProcess_1, 1332175428i64); ObfReferenceObjectWithTag(CurrentThrad_1, 1332175428i64); DebugEvent_1->BackoutThread = (PETHREAD)__readgsqword(0x188u); }
如果没有指定NOWAIT标志，则首先获取DbgkpProcessDebugPortMutex，这是一个全局互斥锁，来保证将调试事件挂入链表的时候不会发生多线程问题。
然后通过进程结构体获取调试对象，并且判断这个事件是否被设置了跳过，如果是的话则将调试对象设置为零。
经历这些判断后，调用KeInitializeEvent初始化一个事件，用于等待调试器回复用。
else { // 等待调试器回复 v25.Flags = Flags; DebugEvent_1 = &v25; ExAcquireFastMutex(&DbgkpProcessDebugPortMutex); ApiNumber = ApiMessage_1->ApiNumber; DebugObject = *(_DEBUG_OBJECT **)(CurrentProcess_1 + 0x420); if ( (unsigned int)(ApiNumber - 1) <= 1 && *(_BYTE *)(CurrentThrad_1 + 0x6BC) & 0x40 )// 判断这个事件如果是线程进程创建，并且线程设置了SkipCreationMsg，则将DebugObject设置为零 DebugObject = 0i64; if ( ApiNumber == 5 && (unsigned __int8)Flags_1 & *(_BYTE *)(CurrentThrad_1 + 0x6BC) & 0x40 )// 判断这个事件如果是模块加载，并且线程设置了SkipCreationMsg，则将DebugObject设置为零 DebugObject = 0i64; if ( (unsigned int)(ApiNumber - 3) <= 1 && *(_BYTE *)(CurrentThrad_1 + 0x6BC) < 0 )// 判断这个事件如果是线程进程退出，并且线程设置了SkipTerminationMsg，则将DebugObject设置为零，这里F5有错误，实际上后面会&0x80 DebugObject = 0i64; KeInitializeEvent(&v25.ContinueEvent, SynchronizationEvent, 0);// 初始化一个同步对象，为了等待调试器回复 }
然后就开始通过ApiMessage来构造DebugEvent结构体。
构建完结构体之后，检查调试对象是否不为零，如果为零直接返回错误，如果调试对象正常，则检查调试对象是否是活跃的。
然后获取调试对象的互斥锁，并且将调试事件挂入到调试对象的事件列表中。（其实这里有一点疑惑，如果只是为了在挂入链表时保证多线程安全的话，获取一个调试对象的互斥锁就可以了，为什么还要获取DbgkpProcessDebugPortMutex）
然后把调试事件挂入到事件链表中，挂入完成后，如果没指定NOWAIT标志，则调用KeSetEvent设置DebugObject->EventsPresent事件，用来通知调试器处理调试事件，然后释放调试对象的互斥锁。
v15 = &DebugEvent_1->ApiMsg; DebugEvent_1->Process = (PEPROCESS)CurrentProcess_1; v16 = &DebugEvent_1->ApiMsg; DebugEvent_1->Thread = (PETHREAD)CurrentThrad_1; v17 = ApiMessage_1; v18 = 2i64; do { *(_OWORD *)&v16->h.u1.s1.DataLength = *(_OWORD *)&v17->h.u1.s1.DataLength; *(union _PORT_MESSAGE::$C6BC508B531A81D74C33985719C23F49 *)((char *)&v16->h.8 + 8) = *(union _PORT_MESSAGE::$C6BC508B531A81D74C33985719C23F49 *)((char *)&v17->h.8 + 8); *(_OWORD *)&v16->h.ClientViewSize = *(_OWORD *)&v17->h.ClientViewSize; *(_OWORD *)&v16->u.Exception.ExceptionRecord.ExceptionCode = *(_OWORD *)&v17->u.Exception.ExceptionRecord.ExceptionCode; *((_OWORD *)&v16->u.UnloadDll + 1) = *((_OWORD *)&v17->u.UnloadDll + 1); *((_OWORD *)&v16->u.UnloadDll + 2) = *((_OWORD *)&v17->u.UnloadDll + 2); *((_OWORD *)&v16->u.UnloadDll + 3) = *((_OWORD *)&v17->u.UnloadDll + 3); v16 = (DBGKM_MSG *)((char *)v16 + 128); v19 = *((_OWORD *)&v17->u.UnloadDll + 4); v17 = (DBGKM_MSG *)((char *)v17 + 128); *((_OWORD *)&v16[-1].u.UnloadDll + 9) = v19; --v18; } while ( v18 ); *(_OWORD *)&v16->h.u1.s1.DataLength = *(_OWORD *)&v17->h.u1.s1.DataLength; _mm_storeu_si128((__m128i *)&DebugEvent_1->ClientId, *(__m128i *)(CurrentThrad_1 + 0x628)); if ( DebugObject ) // 判断获取调试对象是否正常 { debug_Mutex = &DebugObject->Mutex; ExAcquireFastMutex(&DebugObject->Mutex); // 获取调试对象的互斥体 if ( DebugObject->Flags & 1 ) // 判断调试器是否处于活跃状态，如果不是则返回c0000354 { result = 0xC0000354; } else { v22 = DebugObject->EventList.Blink; // 将调试事件挂入到调试对象的事件链表中 DebugEvent_1->EventList.Flink = &DebugObject->EventList; DebugEvent_1->EventList.Blink = v22; if ( v22->Flink != &DebugObject->EventList ) __fastfail(3u); v22->Flink = &DebugEvent_1->EventList; DebugObject->EventList.Blink = &DebugEvent_1->EventList; if ( !NOWAIT ) KeSetEvent(&DebugObject->EventsPresent, 0, 0);// 如果不是NOWAIT状态，触发EventsPresent这个事件，通知调试器来处理调试事件。 result = 0; } KeReleaseGuardedMutex(debug_Mutex); // 释放调试对象的互斥体 v6 = 2i64; } else { // 如果调试对象获取失败，则返回c00000353 result = 0xC0000353; }
继续判断，如果指定了NOWAIT标志，并且返回值小于零，也就是代表出现错误，则释放申请的内存，并且将引用的对象解引用。
如果没指定NOWAIT标志，则释放DbgkpProcessDebugPortMutex全局互斥锁，然后调用KeWaitForSingleObject等待DebugEvent_1->ContinueEvent，当事件被调试器处理完成后会触发这个事件，当前线程会被唤醒继续执行。
然后通过调试事件的信息来填充ApiMessage，用于通知上一层函数事件处理的结果。
if ( NOWAIT ) { if ( result < 0 ) // 如果返回值出错，则释放引用的进程线程对象，释放分配的DebugEvent内存 { ObfDereferenceObjectWithTag(CurrentProcess_1); ObfDereferenceObjectWithTag(CurrentThrad_1); ExFreePoolWithTag(DebugEvent_1, 0); } } else { KeReleaseGuardedMutex(&DbgkpProcessDebugPortMutex);// 释放DbgkpProcessDebugPortMutex互斥锁 if ( result >= 0 ) { KeWaitForSingleObject(&DebugEvent_1->ContinueEvent, 0, 0, 0, 0i64);// 等待调试事件的ContinueEvent，当事件被调试器处理完成的时候这个对象会被触发，当前线程也会被唤醒。 result = DebugEvent_1->Status; do // 通过调试事件的状态来设置ApiMessage，因为上一个函数需要通过ApiMessage的返回值决定下一步的行为。 { *(_OWORD *)&ApiMessage_1->h.u1.s1.DataLength = *(_OWORD *)&v15->h.u1.s1.DataLength; *(union _PORT_MESSAGE::$C6BC508B531A81D74C33985719C23F49 *)((char *)&ApiMessage_1->h.8 + 8) = *(union _PORT_MESSAGE::$C6BC508B531A81D74C33985719C23F49 *)((char *)&v15->h.8 + 8); *(_OWORD *)&ApiMessage_1->h.ClientViewSize = *(_OWORD *)&v15->h.ClientViewSize; *(_OWORD *)&ApiMessage_1->u.Exception.ExceptionRecord.ExceptionCode = *(_OWORD *)&v15->u.Exception.ExceptionRecord.ExceptionCode; *((_OWORD *)&ApiMessage_1->u.UnloadDll + 1) = *((_OWORD *)&v15->u.UnloadDll + 1); *((_OWORD *)&ApiMessage_1->u.UnloadDll + 2) = *((_OWORD *)&v15->u.UnloadDll + 2); *((_OWORD *)&ApiMessage_1->u.UnloadDll + 3) = *((_OWORD *)&v15->u.UnloadDll + 3); ApiMessage_1 = (DBGKM_MSG *)((char *)ApiMessage_1 + 128); v23 = *((_OWORD *)&v15->u.UnloadDll + 4); v15 = (DBGKM_MSG *)((char *)v15 + 128); *((_OWORD *)&ApiMessage_1[-1].u.UnloadDll + 9) = v23; --v6; } while ( v6 ); *(_OWORD *)&ApiMessage_1->h.u1.s1.DataLength = *(_OWORD *)&v15->h.u1.s1.DataLength; } } return (unsigned int)result;
以上，就是用户态调试流程的全部内容，能力有限，有些地方分析的不是很细致~
