KiDispatchException

woaidaima2016

1. KiDispatchException
   
2. VOID
   
3.         KiDispatchException (
   
4.         IN PEXCEPTION_RECORD ExceptionRecord,
   
5.         IN PKEXCEPTION_FRAME ExceptionFrame,
   
6.         IN PKTRAP_FRAME TrapFrame,
   
7.         IN KPROCESSOR_MODE PreviousMode,
   
8.         IN BOOLEAN FirstChance
   
9.         )
   
10. {
    
11.         CONTEXT ExtendedContext;
    
12.         ULONG   Flags;
    
13.         ULONG   ContextLength;
    
14.         PEXTEND_CONTEXT_AREA ExtenContextArea;
    
15.         NTSTATUS status;
    
16.         ULONG64 FaultingRsp;
    
17.         BOOLEAN bText;
    
18.         EXCEPTION_RECORD ExceptionRecord1;
    
19.         PMACHINE_FRAME MachineFrame1;
    
20.         ULONG64 UserStack1;
    
21.         ULONG64 UserStack2;
    
22.         ULONG64 UserStack3;
    
23.         ULONG64 FaultingRspTemp;
    
24.         CONTEXT_EX UserContextEx1;
    
25.         CONTEXT_EX UserContextEx2;
    
26. 
    
27.         *(PBYTE)((ULONGLONG)&ExtendedContext) = PreviousMode;
    
28.         KeGetCurrentPrcb()->KeExceptionDispatchCount += 1;
    
29.         Flags = 0x10001F;
    
30. 
    
31.         if (PreviousMode)
    
32.         {
    
33.                 if (_bittest((long*)&(*(ULONGLONG*)KeFeatureBits), 0x17u))
    
34.                 {
    
35.                         if ( *(ULONGLONG*)KeEnabledXStateFeatures & 0xFFFFFFFFFFFFFFFCui64 )
    
36.                                 Flags = 0x10005F;
    
37.                 }
    
38.         }
    
39.         ((Old_RtlGetExtendedContextLength)RtlGetExtendedContextLength)(Flags,&ContextLength);
    
40.         //*(PDWORD)((ULONGLONG)&ExtendedContext+4) = Flags;
    
41.         ExtendedContext.ContextFlags = Flags;
    
42.         status = ((Old_RtlInitializeExtendedContext)RtlInitializeExtendedContext)(&ExtendedContext,Flags,&ExtenContextArea);
    
43.         if ((Flags&0x10040) == 0x10040)
    
44.         {
    
45.                 *(ULONGLONG*)(*(PDWORD)((ULONGLONG)ExtenContextArea+0x10)+(ULONGLONG)ExtenContextArea) = \
    
46.                         *(ULONGLONG*)KeEnabledXStateFeatures & 0xFFFFFFFFFFFFFFFCui64;
    
47.         }
    
48. 
    
49.         ((Old_KeContextFromKframes)KeContextFromKframes)(TrapFrame,ExceptionFrame,&ExtendedContext);
    
50. 
    
51.         if (ExceptionRecord->ExceptionCode == STATUS_BREAKPOINT)
    
52.                 ExtendedContext.Rip--;
    
53. 
    
54.         if (((Old_KiPreprocessFault)KiPreprocessFault)(
    
55.                 ExceptionRecord,
    
56.                 TrapFrame,
    
57.                 &ExtendedContext,
    
58.                 PreviousMode) != FALSE)
    
59.         {
    
60.                 goto Handled1;
    
61.         }
    
62. 
    
63.         if (PreviousMode == KernelMode)
    
64.         {
    
65.                 if (FirstChance != PreviousMode)
    
66.                 {
    
67. 
    
68.                         if (((PKDEBUG_ROUTINE)(*(PULONG64)KiDebugRoutine))(TrapFrame,
    
69.                                 ExceptionFrame,
    
70.                                 ExceptionRecord,
    
71.                                 &ExtendedContext,
    
72.                                 PreviousMode,
    
73.                                 FALSE) != FALSE)
    
74.                         {
    
75.                                 goto Handled1;
    
76.                         }
    
77. 
    
78.                         if (((Old_RtlDispatchException)RtlDispatchException)(ExceptionRecord, &ExtendedContext) != FALSE)
    
79.                         {
    
80.                                 goto Handled1;
    
81.                         }
    
82.                 }
    
83. 
    
84.                 if (((PKDEBUG_ROUTINE)(*(PULONG64)KiDebugRoutine))(
    
85.                         TrapFrame,
    
86.                         ExceptionFrame,
    
87.                         ExceptionRecord,
    
88.                         &ExtendedContext,
    
89.                         FALSE,
    
90.                         TRUE) != FALSE)
    
91.                 {
    
92.                         goto Handled1;
    
93.                 }
    
94. 
    
95.                 KeBugCheckEx(KMODE_EXCEPTION_NOT_HANDLED,
    
96.                         ExceptionRecord->ExceptionCode,
    
97.                         (ULONG64)ExceptionRecord->ExceptionAddress,
    
98.                         ExceptionRecord->ExceptionInformation[0],
    
99.                         ExceptionRecord->ExceptionInformation[1]);
    
100.         }
     
101.         else
     
102.         {
     
103.                 if (( ((PEPROCESS_S)PsGetCurrentProcess())->Wow64Process != NULL) &&
     
104.                         (ExceptionRecord->ExceptionCode == STATUS_DATATYPE_MISALIGNMENT) &&
     
105.                         ((TrapFrame->EFlags & EFLAGS_AC_MASK) != 0))
     
106.                 {
     
107.                                 TrapFrame->EFlags &= ~EFLAGS_AC_MASK;
     
108.                                 goto TheEnd1;
     
109.                 }
     
110. 
     
111.                 if ((ExtendedContext.SegCs & 0xfff8) == KGDT64_R3_CMCODE)
     
112.                 {
     
113.                         switch (ExceptionRecord->ExceptionCode)
     
114.                         {
     
115.                         case STATUS_BREAKPOINT:
     
116.                                 ExceptionRecord->ExceptionCode = STATUS_WX86_BREAKPOINT;
     
117.                                 break;
     
118. 
     
119.                         case STATUS_SINGLE_STEP:
     
120.                                 ExceptionRecord->ExceptionCode = STATUS_WX86_SINGLE_STEP;
     
121.                                 break;
     
122.                         }
     
123. 
     
124.                         FaultingRsp = (ExtendedContext.Rsp & 0xfffffff0UI64);
     
125. 
     
126.                 } else {
     
127.                         FaultingRsp = ExtendedContext.Rsp;
     
128.                 }
     
129. 
     
130.                 if (STATUS_SINGLE_STEP == ExceptionRecord->ExceptionCode)
     
131.                 {
     
132.                         PETHREAD_S CurThread;
     
133.                         CurThread = (PETHREAD_S)PsGetCurrentThread();
     
134.                         if (CurThread)
     
135.                         {
     
136.                                 if ((*(PBYTE)((ULONGLONG)CurThread+3))&0x40)
     
137.                                 {
     
138.                                         *(PULONGLONG)(*(PULONGLONG)((ULONGLONG)CurThread + 0x1B8) + 0x58) |= 0x10;
     
139.                                 }
     
140.                         }
     
141.                 }
     
142. 
     
143.                 memset(&ExceptionRecord->ExceptionInformation[ExceptionRecord->NumberParameters],
     
144.                         0,
     
145.                         ExceptionRecord - &ExceptionRecord->ExceptionInformation[ExceptionRecord->NumberParameters] + sizeof(EXCEPTION_RECORD));
     
146. 
     
147.                 if (FirstChance == TRUE)
     
148.                 {
     
149.                         bText = FALSE;
     
150.                         if (ExceptionRecord->ExceptionCode == STATUS_BREAKPOINT ||
     
151.                                 ExceptionRecord->ExceptionCode == STATUS_WX86_BREAKPOINT)
     
152.                         {
     
153.                                 if (ExceptionRecord->NumberParameters  > 0 &&
     
154.                                         ExceptionRecord->ExceptionInformation[0] != NULL)
     
155.                                 {
     
156.                                         bText = TRUE;
     
157.                                 }
     
158.                         }
     
159.                         //KiDispatchException + 0x241  eb KiDispatchException + 0x241 0x90 0xe9
     
160.                         if (((PEPROCESS_S)PsGetCurrentProcess())->DebugPort != NULL ||
     
161.                                 *(ULONGLONG*)KdIgnoreUmExceptions != 0)
     
162.                         {
     
163.                                 if (bText == FALSE)
     
164.                                 {
     
165.                                         goto __Leep2;
     
166.                                 }
     
167.                         }
     
168. 
     
169.                         if (((PKDEBUG_ROUTINE)(*(PULONG64)KiDebugRoutine))(
     
170.                                 TrapFrame,
     
171.                                 ExceptionFrame,
     
172.                                 ExceptionRecord,
     
173.                                 &ExtendedContext,
     
174.                                 PreviousMode,
     
175.                                 NULL) != FALSE)
     
176.                         {
     
177.                                 goto Handled1;
     
178.                         }
     
179. 
     
180.             __Leep2:
     
181.                         if (DbgkForwardException(ExceptionRecord, TRUE, FALSE)) {
     
182.                                 goto TheEnd1;
     
183.                         }
     
184. 
     
185.                         TrapFrame->EFlags &= ~EFLAGS_TF_MASK;
     
186. 
     
187.                         ExceptionRecord1.ExceptionCode = STATUS_ACCESS_VIOLATION;
     
188. 
     
189.                         memmove(&ExceptionRecord->ExceptionCode,&ExceptionRecord1.ExceptionCode,sizeof(EXCEPTION_RECORD));
     
190. 
     
191.                         FaultingRspTemp = FaultingRsp;//r15
     
192.                         if ((Flags&0x10040) == 0x10040)
     
193.                         {
     
194.                                 FaultingRspTemp -= ExtenContextArea->Unkwon5;
     
195.                                 FaultingRspTemp = FaultingRspTemp&0x0FFFFFFFFFFFFFFC0;
     
196.                         }
     
197.                         repeat:
     
198.                         __try
     
199.                         {
     
200.                                 MachineFrame1 =
     
201.                                         (PMACHINE_FRAME)((FaultingRspTemp - sizeof(MACHINE_FRAME)) & ~STACK_ROUND);
     
202. 
     
203.                                 UserStack1 = (ULONG64)MachineFrame1 - EXCEPTION_RECORD_LENGTH;
     
204.                                 UserContextEx1.All.Offset = (UserStack1 - 0x20);
     
205.                                 UserStack2 = UserContextEx1.All.Offset - CONTEXT_LENGTH;
     
206.                                 UserContextEx2.All.Offset = UserStack2 - UserContextEx1.All.Offset;
     
207.                                 UserContextEx2.All.Length = FaultingRsp - UserStack2;
     
208.                                 UserContextEx2.Legacy.Offset = UserStack2 - UserContextEx1.All.Offset;
     
209.                                 UserContextEx2.Legacy.Length = 0x4D0;
     
210.                                 UserContextEx2.XState.Offset = FaultingRspTemp - UserContextEx1.All.Offset;
     
211.                                 UserContextEx2.XState.Length = FaultingRsp - FaultingRspTemp;
     
212. 
     
213.                                 ProbeForWriteSmallStructure((PVOID)UserStack2,
     
214.                                         sizeof(MACHINE_FRAME) + EXCEPTION_RECORD_LENGTH + CONTEXT_LENGTH,
     
215.                                         STACK_ALIGN);
     
216. 
     
217.                                 MachineFrame1->Rsp = FaultingRsp;
     
218.                                 MachineFrame1->Rip = ExtendedContext.Rip;
     
219. 
     
220.                                 //*(PEXCEPTION_RECORD)UserStack1 = *ExceptionRecord;
     
221.                                 memmove((PVOID)UserStack1,ExceptionRecord,0x98);
     
222.                                 ((Old_RtlpCopyExtendedContext)RtlpCopyExtendedContext)(
     
223.                                         TRUE,
     
224.                                         UserContextEx1.All.Offset,
     
225.                                         &UserContextEx2.All.Offset,
     
226.                                         Flags,
     
227.                                         ExtenContextArea,
     
228.                                         0);
     
229.                                 //*(PCONTEXT)UserContextEx1 = *(PCONTEXT)UserContextEx2.All.Offset;
     
230.                                 memmove(&UserContextEx1,&UserContextEx2,0x18);
     
231. 
     
232.                                 TrapFrame->Rsp = UserStack2; //+0x180  r14       
     
233.                                 _disable();
     
234.                                 TrapFrame->SegCs = KGDT64_R3_CODE | RPL_MASK; // +0x170
     
235.                                 TrapFrame->Rip = (ULONG64)KeUserExceptionDispatcher;
     
236.                                 if (((PEPROCESS_S)PsGetCurrentProcess())->Pcb.InstrumentationCallback)
     
237.                                 {
     
238.                                         TrapFrame->R10 = TrapFrame->Rip;
     
239.                                         TrapFrame->Rip = (ULONG64)((PEPROCESS_S)PsGetCurrentProcess())->Pcb.InstrumentationCallback;
     
240.                                 }
     
241.                                 _enable();
     
242.                                 goto TheEnd1;
     
243.                         } __except (KiCopyInformation(&ExceptionRecord1,
     
244.                                 (GetExceptionInformation())->ExceptionRecord))
     
245.                         {
     
246.                                 if (ExceptionRecord1.ExceptionCode == STATUS_STACK_OVERFLOW)
     
247.                                 {
     
248.                                         ExceptionRecord1.ExceptionAddress = ExceptionRecord->ExceptionAddress;
     
249.                                         *ExceptionRecord = ExceptionRecord1;
     
250.                                         goto repeat;
     
251.                                 }
     
252.                         }
     
253.                 }
     
254.                 else
     
255.                 {
     
256.                         if (DbgkForwardException(ExceptionRecord, TRUE, TRUE)) {
     
257.                                 goto TheEnd1;
     
258.                         }else if (DbgkForwardException(ExceptionRecord, FALSE, TRUE)){
     
259.                                 goto TheEnd1;
     
260.                         }else{
     
261.                                 ZwTerminateProcess(NtCurrentProcess(), ExceptionRecord->ExceptionCode);
     
262.                                 KeBugCheckEx(
     
263.                                         KERNEL_MODE_EXCEPTION_NOT_HANDLED,
     
264.                                         ExceptionRecord->ExceptionCode,
     
265.                                         (ULONG)ExceptionRecord->ExceptionAddress,
     
266.                                         (ULONG)TrapFrame,
     
267.                                         0);
     
268.                         }
     
269.                 }
     
270.         }
     
271. 
     
272. 
     
273. Handled1:
     
274.         ((Old_KeContextToKframes)KeContextToKframes)(
     
275.                 TrapFrame,
     
276.                 ExceptionFrame,
     
277.                 &ExtendedContext,
     
278.                 ExtendedContext.ContextFlags,
     
279.                 PreviousMode);
     
280. TheEnd1:;
     
281. }

复制代码

liupengfei1

帅哥  头文件呢