想要调试一个程序有两种方法，第一种是使用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;
以上，就是用户态调试流程的全部内容，能力有限，有些地方分析的不是很细致~
