Bitdefender Hypervisor Memory Introspection
winhkhnd.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2020 Bitdefender
3  * SPDX-License-Identifier: Apache-2.0
4  */
47 
48 #include "introcore.h"
49 #include "winbugcheck.h"
50 #include "winpool.h"
51 #include "winpower.h"
52 #include "winthread.h"
53 #include "winumcrash.h"
54 #include "winvad.h"
55 #include "drivers.h"
56 
60 API_HOOK_DESCRIPTOR gHookableApisX86[]
61 __section(".detours") =
62 {
63  {
64  .ModuleName = u"ntoskrnl.exe",
65  .FunctionName = "ExAllocatePoolWithTag",
66  .MinVersion = DETOUR_MIN_VERSION_ANY,
67  .MaxVersion = DETOUR_MAX_VERSION_ANY,
68  .Callback = IntWinPoolHandleAlloc,
69  .Tag = detTagPoolAlloc,
70  .Exported = TRUE,
71  .NotCritical = FALSE,
72  .DisableFlags = 0,
73  .EnableFlags = DETOUR_ENABLE_ALWAYS,
74  .Arguments = DET_ARGS_DEFAULT_WIN86,
75  .HandlersCount = 1,
76  .Handlers =
77  {
78  {
79  .MinVersion = DETOUR_MIN_VERSION_ANY,
80  .MaxVersion = DETOUR_MAX_VERSION_ANY,
81  .HypercallType = hypercallTypeInt3,
82 
83  .CodeLength = 0x3c,
84  .Code =
85  {
86  // 0x00: CMP dword ptr [esp+0xc], 0xf6697244
87  0x81, 0x7C, 0x24, 0x0c, 0x44, 0x72, 0x69, 0xF6,
88  // 0x08: JZ 0x34
89  0x74, 0x2a,
90  // 0x0A: CMP dword ptr [esp+0xc], 0x76697244
91  0x81, 0x7C, 0x24, 0x0c, 0x44, 0x72, 0x69, 0x76,
92  // 0x12: JZ 0x34
93  0x74, 0x20,
94  // 0x14: CMP dword ptr [esp+0xc], 0x69664d46
95  0x81, 0x7C, 0x24, 0x0c, 0x46, 0x4D, 0x66, 0x69,
96  // 0x1C: JZ 0x34
97  0x74, 0x16,
98  // 0x1E: CMP dword ptr [esp+0xc], 0x656b6f54
99  0x81, 0x7C, 0x24, 0x0c, 0x54, 0x6f, 0x6b, 0x65,
100  // 0x26: JZ 0x34
101  0x74, 0x0C,
102  // 0x28: CMP dword ptr [esp+0xc], 0xe56b6f54
103  0x81, 0x7C, 0x24, 0x0c, 0x54, 0x6f, 0x6b, 0xe5,
104  // 0x30: JZ 0x34
105  0x74, 0x02,
106  // 0x32: JMP 0x37
107  0xEB, 0x03,
108  // 0x34: INT3
109  0xCC,
110  // 0x35: NOP
111  0x90,
112  // 0x36: NOP
113  0x90,
114  // 0x37: JMP 0x3c
115  0xE9, 0x00, 0x00, 0x00, 0x00,
116  },
117  .HypercallOffset = 0x34,
118  .RelocatedCodeOffset = 0x37,
119  },
120  },
121  },
122 
123  {
124  .ModuleName = u"ntoskrnl.exe",
125  .FunctionName = "ExFreePoolWithTag",
126  .MinVersion = DETOUR_MIN_VERSION_ANY,
127  .MaxVersion = DETOUR_MAX_VERSION_ANY,
128  .Callback = IntWinPoolHandleFree,
129  .Tag = detTagPoolFree,
130  .Exported = TRUE,
131  .NotCritical = FALSE,
132  .DisableFlags = 0,
133  .EnableFlags = DETOUR_ENABLE_ALWAYS,
134  .Arguments = DET_ARGS_DEFAULT_WIN86,
135  .HandlersCount = 1,
136  .Handlers =
137  {
138  {
139  .MinVersion = DETOUR_MIN_VERSION_ANY,
140  .MaxVersion = DETOUR_MAX_VERSION_ANY,
141  .HypercallType = hypercallTypeInt3,
142 
143  .CodeLength = 0x28,
144  .Code =
145  {
146  // 0x00: CMP dword ptr [esp+0x8], 0xf6697244
147  0x81, 0x7C, 0x24, 0x08, 0x44, 0x72, 0x69, 0xF6,
148  // 0x08: JZ 0x20
149  0x74, 0x16,
150  // 0x0A: CMP dword ptr [esp+0x8], 0x76697244
151  0x81, 0x7C, 0x24, 0x08, 0x44, 0x72, 0x69, 0x76,
152  // 0x12: JZ 0x20
153  0x74, 0x0C,
154  // 0x14: CMP dword ptr [esp+0x8], 0x69664d46
155  0x81, 0x7C, 0x24, 0x08, 0x46, 0x4D, 0x66, 0x69,
156  // 0x1C: JZ 0x20
157  0x74, 0x02,
158  // 0x1E: JMP 0x23
159  0xEB, 0x03,
160  // 0x20: INT3
161  0xCC,
162  // 0x21: NOP
163  0x90,
164  // 0x22: NOP
165  0x90,
166  // 0x23: JMP 0x28
167  0xE9, 0x00, 0x00, 0x00, 0x00
168  },
169  .HypercallOffset = 0x20,
170  .RelocatedCodeOffset = 0x23,
171  },
172  },
173  },
174 
175  {
176  .ModuleName = u"ntoskrnl.exe",
177  .FunctionName = "KeBugCheck2",
178  .MinVersion = DETOUR_MIN_VERSION_ANY,
179  .MaxVersion = DETOUR_MAX_VERSION_ANY,
180  .Callback = IntWinBcHandleBugCheck,
181  .Tag = detTagBugcheck,
182  .Exported = FALSE,
183  .NotCritical = FALSE,
184  .DisableFlags = 0,
185  .EnableFlags = INTRO_OPT_BUGCHECK_CLEANUP | INTRO_OPT_EVENT_OS_CRASH,
186  .Arguments = DET_ARGS_DEFAULT_WIN86,
187  .HandlersCount = 1,
188  .Handlers =
189  {
190  {
191  .MinVersion = DETOUR_MIN_VERSION_ANY,
192  .MaxVersion = DETOUR_MAX_VERSION_ANY,
193  .HypercallType = hypercallTypeInt3,
194 
195  .CodeLength = 0x8,
196  .Code =
197  {
198  // 0x00: INT3
199  0xCC,
200  // 0x01: NOP
201  0x90,
202  // 0x02: NOP
203  0x90,
204  // 0x03: JMP 0x8
205  0xE9, 0x00, 0x00, 0x00, 0x00
206  },
207  .HypercallOffset = 0x0,
208  .RelocatedCodeOffset = 0x3,
209  },
210  },
211  },
212 
213  {
214  .ModuleName = u"ntoskrnl.exe",
215  .FunctionName = "MiProcessLoaderEntry",
216  .MinVersion = DETOUR_MIN_VERSION_ANY,
217  .MaxVersion = DETOUR_MAX_VERSION_ANY,
218  .Callback = IntDriverLoadHandler,
219  .Tag = detTagModuleLoad,
220  .Exported = FALSE,
221  .NotCritical = FALSE,
222  .DisableFlags = 0,
223  .EnableFlags = DETOUR_ENABLE_ALWAYS,
224  .Arguments = DET_ARGS_DEFAULT_WIN86,
225  .HandlersCount = 1,
226  .Handlers =
227  {
228  {
229  .MinVersion = DETOUR_MIN_VERSION_ANY,
230  .MaxVersion = DETOUR_MAX_VERSION_ANY,
231  .HypercallType = hypercallTypeInt3,
232 
233  .CodeLength = 0x8,
234  .Code =
235  {
236  // 0x00: INT3
237  0xCC,
238  // 0x01: NOP
239  0x90,
240  // 0x02: NOP
241  0x90,
242  // 0x03: JMP 0x8
243  0xE9, 0x00, 0x00, 0x00, 0x00
244  },
245  .HypercallOffset = 0x0,
246  .RelocatedCodeOffset = 0x3,
247  },
248  },
249  },
250 
251  {
252  .ModuleName = u"ntoskrnl.exe",
253  .FunctionName = "MiUnloadSystemImage",
254  .MinVersion = DETOUR_MIN_VERSION_ANY,
255  .MaxVersion = DETOUR_MAX_VERSION_ANY,
256  .Callback = IntDriverUnloadHandler,
257  .Tag = detTagModuleUnload,
258  .Exported = FALSE,
259  .NotCritical = FALSE,
260  .DisableFlags = 0,
261  .EnableFlags = DETOUR_ENABLE_ALWAYS,
262  .Arguments = DET_ARGS_DEFAULT_WIN86,
263  .HandlersCount = 1,
264  .Handlers =
265  {
266  {
267  .MinVersion = DETOUR_MIN_VERSION_ANY,
268  .MaxVersion = DETOUR_MAX_VERSION_ANY,
269  .HypercallType = hypercallTypeInt3,
270 
271  .CodeLength = 0x8,
272  .Code =
273  {
274  // 0x00: INT3
275  0xCC,
276  // 0x01: NOP
277  0x90,
278  // 0x02: NOP
279  0x90,
280  // 0x03: JMP 0x8
281  0xE9, 0x00, 0x00, 0x00, 0x00
282  },
283  .HypercallOffset = 0x0,
284  .RelocatedCodeOffset = 0x3,
285  },
286  },
287  },
288 
289  {
290  .ModuleName = u"ntoskrnl.exe",
291  .FunctionName = "PspInsertProcess",
292  .MinVersion = DETOUR_MIN_VERSION_ANY,
293  .MaxVersion = DETOUR_MAX_VERSION_ANY,
294  .PreCallback = IntWinProcPatchPspInsertProcess86,
295  .Callback = IntWinProcHandleCreate,
296  .Tag = detTagProcCreate,
297  .Exported = FALSE,
298  .NotCritical = FALSE,
299  .DisableFlags = 0,
300  .EnableFlags = DETOUR_ENABLE_ALWAYS,
301  .Arguments = DET_ARGS_DEFAULT_WIN86,
302  .HandlersCount = 1,
303  .Handlers =
304  {
305  {
306  .MinVersion = DETOUR_MIN_VERSION_ANY,
307  .MaxVersion = DETOUR_MAX_VERSION_ANY,
308  .HypercallType = hypercallTypeInt3,
309 
310  .CodeLength = 0x10,
311  .Code =
312  {
313  // 0x00: INT3
314  0xCC,
315  // 0x01: JMP 0xb
316  0xEB, 0x08,
317  // If we want to block a process, we increment the RIP from IntWinProcHandleCreate
318  // so that it points here.
319  // 0x03: MOV eax, 0xc0000022
320  0xB8, 0x22, 0x00, 0x00, 0xC0,
321  // 0x08: RETN 0x0018
322  0xC2, 0x18, 0x00,
323  // <call PspInsertProcess>
324  // 0x0B: JMP 0x10
325  0xE9, 0x00, 0x00, 0x00, 0x00
326  },
327  .HypercallOffset = 0x00,
328  .RelocatedCodeOffset = 0x0B,
329  },
330  },
331  },
332 
333  {
334  .ModuleName = u"ntoskrnl.exe",
335  .FunctionName = "MmCleanProcessAddressSpace",
336  .MinVersion = DETOUR_MIN_VERSION_ANY,
337  .MaxVersion = DETOUR_MAX_VERSION_ANY,
338  .Callback = IntWinProcHandleTerminate,
339  .Tag = detTagProcTerminate,
340  .Exported = FALSE,
341  .NotCritical = FALSE,
342  .DisableFlags = 0,
343  .EnableFlags = DETOUR_ENABLE_ALWAYS,
344  .Arguments = DET_ARGS_DEFAULT_WIN86,
345  .HandlersCount = 1,
346  .Handlers =
347  {
348  {
349  .MinVersion = DETOUR_MIN_VERSION_ANY,
350  .MaxVersion = DETOUR_MAX_VERSION_ANY,
351  .HypercallType = hypercallTypeInt3,
352 
353  .CodeLength = 0x8,
354  .Code =
355  {
356  // 0x00: INT3
357  0xCC,
358  // 0x01: NOP
359  0x90,
360  // 0x02: NOP
361  0x90,
362  // 0x03: JMP 0x8
363  0xE9, 0x00, 0x00, 0x00, 0x00
364  },
365  .HypercallOffset = 0x0,
366  .RelocatedCodeOffset = 0x3,
367  },
368  },
369  },
370 
371 
372  {
373  .ModuleName = u"ntoskrnl.exe",
374  .FunctionName = "MmCopyVirtualMemory",
375  .MinVersion = DETOUR_MIN_VERSION_ANY,
376  .MaxVersion = DETOUR_MAX_VERSION_ANY,
377  .Callback = IntWinProcHandleCopyMemory,
378  .PreCallback = IntWinProcPatchCopyMemoryDetour,
379  .Tag = detTagProcInject,
380  .Exported = FALSE,
381  .NotCritical = FALSE,
382  .DisableFlags = 0,
383  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION,
384  .Arguments = DET_ARGS_DEFAULT_WIN86,
385  .HandlersCount = 1,
386  .Handlers =
387  {
388  {
389  .MinVersion = DETOUR_MIN_VERSION_ANY,
390  .MaxVersion = DETOUR_MAX_VERSION_ANY,
391  .HypercallType = hypercallTypeInt3,
392 
393  .CodeLength = 0x55,
394  .Code =
395  {
396  // 0x00: PUSH eax
397  0x50,
398  // 0x01: PUSH ebx
399  0x53,
400  // 0x02: PUSH ecx
401  0x51,
402  // 0x03: MOV eax, dword ptr [esp+0x10]
403  0x8b, 0x44, 0x24, 0x10,
404  // 0x07: MOV ebx, dword ptr [esp+0x18]
405  0x8b, 0x5c, 0x24, 0x18,
406  // 0x0B: CMP eax, ebx
407  0x39, 0xd8,
408  // 0x0D: JZ 0x4d
409  0x74, 0x3e,
410  // 0x0F: MOV ecx, cr3
411  0x0f, 0x20, 0xd9,
412  // 0x12: CMP ecx, dword ptr [ebx+0x0]
413  0x3b, 0x8b, 0x00, 0x00, 0x00, 0x00,
414  // 0x18: JZ 0x2d
415  0x74, 0x13,
416  // is_write:
417  // 0x1A: MOV ebx, dword ptr [ebx+0x0]
418  0x8b, 0x9b, 0x00, 0x00, 0x00, 0x00,
419  // 0x20: CMP bl, 0x2a
420  0x80, 0xfb, 0x2a,
421  // 0x23: JNZ 0x4d
422  0x75, 0x28,
423  // 0x25: BT ebx, 0x09
424  0x0f, 0xba, 0xe3, 0x09,
425  // 0x29: JNC 0x4d
426  0x73, 0x22,
427  // 0x2B: JMP 0x3d
428  0xeb, 0x10,
429  // _is_read:
430  // 0x2D: MOV eax, dword ptr [eax+0x0]
431  0x8b, 0x80, 0x00, 0x00, 0x00, 0x00,
432  // 0x33: CMP al, 0x2a
433  0x3c, 0x2a,
434  // 0x35: JNZ 0x4d
435  0x75, 0x16,
436  // 0x37: BT eax, 0x0a
437  0x0f, 0xba, 0xe0, 0x0a,
438  // 0x3B: JNC 0x4d
439  0x73, 0x10,
440  // _do_int3:
441  // 0x3D: INT3
442  0xcc,
443  // 0x3E: CMP eax, 0xc0000022
444  0x3d, 0x22, 0x00, 0x00, 0xc0,
445  // 0x43: JNZ 0x4d
446  0x75, 0x08,
447  // 0x45: POP ecx
448  0x59,
449  // 0x46: POP ebx
450  0x5b,
451  // 0x47: ADD esp, 0x04
452  0x83, 0xc4, 0x04,
453  // 0x4A: RETN 0x001c
454  0xc2, 0x1c, 0x00,
455  // _continue_function:
456  // 0x4D: POP ecx
457  0x59,
458  // 0x4E: POP ebx
459  0x5b,
460  // 0x4F: POP eax
461  0x58,
462  // _leave:
463  // 0x50: JMP 0x55
464  0xe9, 0x00, 0x00, 0x00, 0x00,
465  },
466  .HypercallOffset = 0x3d,
467  .RelocatedCodeOffset = 0x50,
468  },
469  },
470  },
471 
472  {
473  .ModuleName = u"ntoskrnl.exe",
474  .FunctionName = "NtSetInformationProcess",
475  .MinVersion = DETOUR_MIN_VERSION_ANY,
476  .MaxVersion = DETOUR_MAX_VERSION_ANY,
477  .Callback = IntWinProcHandleInstrument,
478  .PreCallback = IntWinProcPrepareInstrument,
479  .Tag = detTagSetProcInformation,
480  .Exported = TRUE,
481  .NotCritical = FALSE,
482  .DisableFlags = 0,
483  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION,
484  .Arguments = DET_ARGS_DEFAULT_WIN86,
485  .HandlersCount = 1,
486  .Handlers =
487  {
488  {
489  .MinVersion = DETOUR_MIN_VERSION_ANY,
490  .MaxVersion = DETOUR_MAX_VERSION_ANY,
491  .HypercallType = hypercallTypeInt3,
492 
493  .CodeLength = 0x84,
494  .Code =
495  {
496  // 0x00: cmp DWORD PTR [esp+0x8],0x28
497  0x83, 0x7c, 0x24, 0x08, 0x28,
498  // 0x05: jne 0x7f <_irelevant>
499  0x75, 0x78,
500  // 0x07: push eax
501  0x50,
502  // 0x08: push ecx
503  0x51,
504  // 0x09: push edx
505  0x52,
506  // 0x0a: mov ecx,DWORD PTR [esp+0x10]
507  0x8b, 0x4c, 0x24, 0x10,
508  // 0x0e: sub esp,0x10
509  0x83, 0xec, 0x10,
510  // Save everything early on the stack in the location where intro expects them
511  // 0x11: mov eax,DWORD PTR [esp+0x24]
512  0x8b, 0x44, 0x24, 0x24,
513  // 0x15: mov DWORD PTR [esp+0x8],eax
514  0x89, 0x44, 0x24, 0x08,
515  // 0x19: mov eax,DWORD PTR [esp+0x28]
516  0x8b, 0x44, 0x24, 0x28,
517  // 0x1d: mov DWORD PTR [esp+0xc],eax
518  0x89, 0x44, 0x24, 0x0c,
519  // 0x21: lea eax,[esp+0x4]
520  0x8d, 0x44, 0x24, 0x04,
521  // 0x25: mov DWORD PTR [esp+0x4],0x0
522  0xc7, 0x44, 0x24, 0x04, 0x00, 0x00, 0x00, 0x00,
523  // 0x2d: push 0x0
524  0x6a, 0x00,
525  // 0x2f: push eax
526  0x50,
527  // 0x30: push 0x1
528  0x6a, 0x01,
529  // PsProcessType
530  // 0x32: push DWORD PTR ds:0xfffff800
531  0xff, 0x35, 0x00, 0xf8, 0xff, 0xff,
532  // 0x38: push 0x0
533  0x6a, 0x0,
534  // 0x3a: push ecx
535  0x51,
536  // ObReferenceObjectByHandle
537  // 0x3b: mov eax,0xfffff800
538  0xb8, 0x00, 0xf8, 0xff, 0xff,
539  // 0x40: call eax
540  0xff, 0xd0,
541  // 0x42: test eax,eax
542  0x85, 0xc0,
543  // 0x44: mov eax, 0
544  0xb8, 0x00, 0x00, 0x00, 0x00,
545  // 0x49: jne 0x6c <_exit>
546  0x75, 0x21,
547  // 0x4b: mov ecx,DWORD PTR [esp+0x4]
548  0x8b, 0x4c, 0x24, 0x04,
549  // This offset will be patched by intro with the offset of `_EPROCESS.Spare`
550  // 0x4f: mov eax,DWORD PTR [ecx+0x150]
551  0x8b, 0x81, 0x50, 0x01, 0x00, 0x00,
552  // 0x55: cmp al,0x2a
553  0x3c, 0x2a,
554  // 0x57: bt eax,0xd
555  0x0f, 0xba, 0xe0, 0x0d,
556  // 0x5b: jne 62 <_dereference_and_exit>
557  0x75, 0x05,
558  // 0x5d: jae 62 <_dereference_and_exit>
559  0x73, 0x03,
560 
561  // 0x5f <_hypercall>:
562  // 0x5f: int3
563  0xcc,
564  // 0x60: nop
565  0x90,
566  // 0x61: nop
567  0x90,
568 
569  // 0x62 <_dereference_and_exit>:
570  // 0x62: push eax
571  0x50,
572  // 0x63: push ecx
573  0x51,
574  // ObDereferenceObject
575  // 0x64: mov eax,0xfffff800
576  0xb8, 0x00, 0xf8, 0xff, 0xff,
577  // 0x69: call eax
578  0xff, 0xd0,
579  // 0x6b: pop eax
580  0x58,
581 
582  // 0x6c <_exit>:
583  // 0x6c: add esp,0x10
584  0x83, 0xc4, 0x10,
585  // 0x6f: pop edx
586  0x5a,
587  // 0x70: pop ecx
588  0x59,
589  // 0x71: cmp eax,0xc0000022
590  0x3d, 0x22, 0x00, 0x00, 0xc0,
591  // 0x76: jne 0x7e <_allow>
592  0x75, 0x06,
593  // 0x78: add esp,0x4
594  0x83, 0xc4, 0x04,
595  // 0x8b: ret 0x10
596  0xc2, 0x10, 0x00,
597 
598  // 0x7e <_allow>:
599  // 0x7e: pop eax
600  0x58,
601 
602  // 0x7f <_irelevant>:
603  // 0x7f: jmp 0
604  0xe9, 0xfc, 0xff, 0xff, 0xff,
605 
606  },
607  .HypercallOffset = 0x5f,
608  .RelocatedCodeOffset = 0x7f,
609  },
610  },
611  },
612 
613  {
614  .ModuleName = u"ntoskrnl.exe",
615  .FunctionName = "NtQueueApcThreadEx",
616  .MinVersion = DETOUR_MIN_VERSION_ANY,
617  .MaxVersion = DETOUR_MAX_VERSION_ANY,
618  .Callback = IntWinThrHandleQueueApc,
619  .PreCallback = IntWinThrPrepareApcHandler,
620  .Tag = detTagProcQueueApc,
621  .Exported = FALSE,
622  .NotCritical = FALSE,
623  .DisableFlags = 0,
624  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION,
625  .Arguments = DET_ARGS_DEFAULT_WIN86,
626  .HandlersCount = 1,
627  .Handlers =
628  {
629  {
630  .MinVersion = DETOUR_MIN_VERSION_ANY,
631  .MaxVersion = DETOUR_MAX_VERSION_ANY,
632  .HypercallType = hypercallTypeInt3,
633 
634  .CodeLength = 0x89,
635  .Code =
636  {
637  // 0x00: PUSH eax
638  0x50,
639  // 0x01: PUSH ecx
640  0x51,
641  // 0x02: PUSH edx
642  0x52,
643  // 0x03: MOV ecx, dword ptr [esp+0x10]
644  0x8b, 0x4c, 0x24, 0x10,
645  // 0x07: SUB esp, 0x10
646  0x83, 0xec, 0x10,
647  // 0x0A: LEA eax, [esp+0x4]
648  0x8d, 0x44, 0x24, 0x04,
649  // 0x0E: MOV dword ptr [esp+0x4], 0x00000000
650  0xc7, 0x44, 0x24, 0x04, 0x00, 0x00, 0x00, 0x00,
651  // 0x16: PUSH 0x00
652  0x6a, 0x00,
653  // 0x18: PUSH eax
654  0x50,
655  // 0x19: PUSH 0x01
656  0x6a, 0x01,
657  // 0x1B: PUSH dword ptr [0xfffff800]
658  0xff, 0x35, 0x00, 0xf8, 0xff, 0xff,
659  // PsThreadType
660  // 0x21: PUSH 0x10
661  0x6a, 0x10,
662  // 0x23: PUSH ecx
663  0x51,
664  // 0x24: MOV eax, 0xfffff800
665  0xb8, 0x00, 0xf8, 0xff, 0xff,
666  // ObReferenceObjectByHandle
667  // 0x29: CALL eax
668  0xff, 0xd0,
669  // 0x2B: TEST eax, eax
670  0x85, 0xc0,
671  // 0x2D: JNZ 0x71
672  0x75, 0x42,
673  // 0x2F: MOV ecx, dword ptr [esp+0x4]
674  0x8b, 0x4c, 0x24, 0x04,
675  // Victim thread obj
676  // 0x33: MOV eax, dword ptr [ecx+0x150]
677  0x8b, 0x81, 0x50, 0x01, 0x00, 0x00,
678  // AttachedProcess
679  // 0x39: TEST eax, eax
680  0x85, 0xc0,
681  // 0x3B: JNZ 0x43
682  0x75, 0x06,
683  // 0x3D: MOV eax, dword ptr [ecx+0x150]
684  0x8b, 0x81, 0x50, 0x01, 0x00, 0x00,
685  // _attached:
686  // 0x43: MOV eax, dword ptr [eax+0x150]
687  0x8b, 0x80, 0x50, 0x01, 0x00, 0x00,
688  // ImageFileName
689  // 0x49: CMP al, 0x2a
690  0x3c, 0x2a,
691  // Check for '*' in process name
692  // 0x4B: BT eax, 0x0c
693  0x0f, 0xba, 0xe0, 0x0c,
694  // Check QueueApc protection flag
695  // 0x4F: MOV eax, 0x00000000
696  0xb8, 0x00, 0x00, 0x00, 0x00,
697  // 0x54: JNZ 0x61
698  0x75, 0x0b,
699  // 0x56: JNC 0x61
700  0x73, 0x09,
701  // 0x58: MOV eax, dword ptr fs:[0x124]
702  0x64, 0xa1, 0x24, 0x01, 0x00, 0x00,
703  // 0x5E: INT3
704  0xcc,
705  // 0x5F: NOP
706  0x90,
707  // 0x60: NOP
708  0x90,
709  // _skip_exit:
710  // 0x61: MOV dword ptr [esp+0x8], eax
711  0x89, 0x44, 0x24, 0x08,
712  // 0x65: PUSH ecx
713  0x51,
714  // 0x66: MOV eax, 0xfffff800
715  0xb8, 0x00, 0xf8, 0xff, 0xff,
716  // ObDereferenceObject
717  // 0x6B: CALL eax
718  0xff, 0xd0,
719  // 0x6D: MOV eax, dword ptr [esp+0x8]
720  0x8b, 0x44, 0x24, 0x08,
721  // _cleanup_and_exit:
722  // 0x71: ADD esp, 0x10
723  0x83, 0xc4, 0x10,
724  // 0x74: POP edx
725  0x5a,
726  // 0x75: POP ecx
727  0x59,
728  // 0x76: CMP eax, 0xc0000022
729  0x3d, 0x22, 0x00, 0x00, 0xc0,
730  // 0x7B: JNZ 0x83
731  0x75, 0x06,
732  // 0x7D: ADD esp, 0x04
733  0x83, 0xc4, 0x04,
734  // 0x80: RETN 0x0018
735  0xc2, 0x18, 0x00,
736  // _skip:
737  // 0x83: POP eax
738  0x58,
739  // 0x84: JMP 0x85
740  0xe9, 0xfc, 0xff, 0xff, 0xff,
741  },
742  .HypercallOffset = 0x5e,
743  .RelocatedCodeOffset = 0x84,
744  },
745  },
746  },
747 
748  {
749  .ModuleName = u"ntoskrnl.exe",
750  .FunctionName = "PspSetContextThreadInternal",
751  .MinVersion = DETOUR_MIN_VERSION_ANY,
752  .MaxVersion = DETOUR_MAX_VERSION_ANY,
753  .Callback = IntWinThrHandleThreadHijack,
754  .PreCallback = IntWinThrPatchThreadHijackHandler,
755  .Tag = detTagProcThrHijack,
756  .Exported = FALSE,
757  .NotCritical = FALSE,
758  .DisableFlags = 0,
759  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION,
760  .Arguments = DET_ARGS_DEFAULT_WIN86,
761  .HandlersCount = 1,
762  .Handlers =
763  {
764  {
765  .MinVersion = DETOUR_MIN_VERSION_ANY,
766  .MaxVersion = DETOUR_MAX_VERSION_ANY,
767  .HypercallType = hypercallTypeInt3,
768 
769  .CodeLength = 0x4a,
770  .Code =
771  {
772  // 0x00: PUSH eax
773  0x50,
774  // 0x01: PUSH ecx
775  0x51,
776  // 0x02: MOV ecx, dword ptr [esp+0xc]
777  0x8b, 0x4c, 0x24, 0x0c,
778  // 0x06: MOV eax, dword ptr [ecx+0x80]
779  0x8b, 0x81, 0x80, 0x00, 0x00, 0x00,
780  // 0x0C: TEST eax, eax
781  0x85, 0xc0,
782  // 0x0E: JNZ 0x16
783  0x75, 0x06,
784  // 0x10: MOV eax, dword ptr [ecx+0x150]
785  0x8b, 0x81, 0x50, 0x01, 0x00, 0x00,
786  // _attached:
787  // 0x16: MOV eax, dword ptr [eax+0x170]
788  0x8b, 0x80, 0x70, 0x01, 0x00, 0x00,
789  // 0x1C: CMP al, 0x2a
790  0x3c, 0x2a,
791  // 0x1E: BT eax, 0x0b
792  0x0f, 0xba, 0xe0, 0x0b,
793  // 0x22: JNZ 0x43
794  0x75, 0x1f,
795  // 0x24: JNC 0x43
796  0x73, 0x1d,
797  // 0x26: MOV eax, dword ptr fs:[0x124]
798  0x64, 0xa1, 0x24, 0x01, 0x00, 0x00,
799  // 0x2C: CMP eax, dword ptr [esp+0xc]
800  0x3b, 0x44, 0x24, 0x0c,
801  // 0x30: JZ 0x43
802  0x74, 0x11,
803  // 0x32: INT3
804  0xcc,
805  // 0x33: NOP
806  0x90,
807  // 0x34: NOP
808  0x90,
809  // 0x35: CMP eax, 0xc0000022
810  0x3d, 0x22, 0x00, 0x00, 0xc0,
811  // 0x3A: JNZ 0x43
812  0x75, 0x07,
813  // 0x3C: POP ecx
814  0x59,
815  // 0x3D: ADD esp, 0x04
816  0x83, 0xc4, 0x04,
817  // 0x40: RETN 0x0000
818  0xc2, 0x00, 0x00,
819  // <skip>:
820  // 0x43: POP ecx
821  0x59,
822  // 0x44: POP eax
823  0x58,
824  // 0x45: JMP 0x4a
825  0xe9, 0x00, 0x00, 0x00, 0x00,
826  },
827  .HypercallOffset = 0x32,
828  .RelocatedCodeOffset = 0x45,
829  },
830  }
831 
832  },
833 
834  {
835  .ModuleName = u"ntoskrnl.exe",
836  .FunctionName = "KiDispatchException",
837  .MinVersion = DETOUR_MIN_VERSION_ANY,
838  .MaxVersion = DETOUR_MAX_VERSION_ANY,
839  .Callback = IntWinHandleException,
840  .Tag = detTagException,
841  .Exported = FALSE,
842  .NotCritical = FALSE,
843  .DisableFlags = 0,
844  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION | INTRO_OPT_EVENT_PROCESS_CRASH,
845  .Arguments = DET_ARGS_DEFAULT_WIN86,
846  .HandlersCount = 1,
847  .Handlers =
848  {
849  {
850  .MinVersion = DETOUR_MIN_VERSION_ANY,
851  .MaxVersion = DETOUR_MAX_VERSION_ANY,
852  .HypercallType = hypercallTypeInt3,
853 
854  .CodeLength = 0x0F,
855  .Code =
856  {
857  // 0x00: CMP dword ptr [esp+0x10], 0x01
858  0x83, 0x7C, 0x24, 0x10, 0x01,
859  // 0x05: JNZ 0xa
860  0x75, 0x03,
861  // 0x07: INT3
862  0xCC,
863  // 0x08: NOP
864  0x90,
865  // 0x09: NOP
866  0x90,
867  // 0x0A: JMP 0xf
868  0xE9, 0x00, 0x00, 0x00, 0x00
869  },
870  .HypercallOffset = 0x07,
871  .RelocatedCodeOffset = 0x0A,
872  },
873  },
874  },
875 
876  {
877  .ModuleName = u"ntoskrnl.exe",
878  .FunctionName = "MiInsertPrivateVad",
879  .MinVersion = DETOUR_MIN_VERSION_ANY,
880  .MaxVersion = 18362,
881  .Callback = IntWinVadHandleInsertPrivate,
882  .PreCallback = IntWinVadPatchInsertPrivate,
883  .Tag = detTagVadInsertPriv,
884  .Exported = FALSE,
885  .NotCritical = FALSE,
886  .DisableFlags = 0,
887  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION | INTRO_OPT_ENABLE_MISC_EVENTS,
888  .Arguments = DET_ARGS_DEFAULT_WIN86,
889  .HandlersCount = 4,
890  .Handlers =
891  {
892  {
893  .MinVersion = 7600,
894  .MaxVersion = 7602,
895  .HypercallType = hypercallTypeInt3,
896 
897  .CodeLength = 0x34,
898  .Code =
899  {
900  // 0x00: TEST byte ptr [edi+0x17], 0x02
901  0xF6, 0x47, 0x17, 0x02,
902  // 0x04: JZ 0x2f
903  0x74, 0x29,
904  // 0x06: PUSH eax
905  0x50,
906  // 0x07: PUSH ecx
907  0x51,
908  // 0x08: MOV ecx, dword ptr fs:[0x124]
909  0x64, 0x8b, 0x0d, 0x24, 0x01, 0x00, 0x00,
910  // 0x0F: MOV eax, dword ptr [ecx+0x50]
911  0x8b, 0x41, 0x50,
912  // 0x12: TEST eax, eax
913  0x85, 0xc0,
914  // 0x14: JNZ 0x1c
915  0x75, 0x06,
916  // 0x16: MOV eax, dword ptr [ecx+0x150]
917  0x8B, 0x81, 0x50, 0x01, 0x00, 0x00,
918  // 0x1C: MOV eax, dword ptr [eax+0x16c]
919  0x8b, 0x80, 0x6c, 0x01, 0x00, 0x00,
920  // 0x22: CMP al, 0x2a
921  0x3c, 0x2a,
922  // 0x24: BT eax, 0x08
923  0x0f, 0xba, 0xe0, 0x08,
924  // 0x28: POP ecx
925  0x59,
926  // 0x29: POP eax
927  0x58,
928  // 0x2A: JNZ 0x2f
929  0x75, 0x03,
930  // 0x2C: JNC 0x2f
931  0x73, 0x01,
932  // 0x2E: INT3
933  0xCC,
934  // 0x2F: JMP 0x34
935  0xE9, 0x00, 0x00, 0x00, 0x00
936  },
937  .HypercallOffset = 0x2e,
938  .RelocatedCodeOffset = 0x2f,
939  },
940 
941  {
942  .MinVersion = 9200,
943  .MaxVersion = 9200,
944  .HypercallType = hypercallTypeInt3,
945 
946  .CodeLength = 0x1c,
947  .Code =
948  {
949  // 0x00: PUSH eax
950  0x50,
951  // 0x01: MOV eax, dword ptr [esp+0x10]
952  0x8b, 0x44, 0x24, 0x10,
953  // 0x05: MOV eax, dword ptr [eax+0x170]
954  0x8b, 0x80, 0x70, 0x01, 0x00, 0x00,
955  // 0x0B: CMP al, 0x2a
956  0x3c, 0x2a,
957  // 0x0D: BT eax, 0x08
958  0x0f, 0xba, 0xe0, 0x08,
959  // 0x11: POP eax
960  0x58,
961  // 0x12: JNZ 0x17
962  0x75, 0x03,
963  // 0x14: JNC 0x17
964  0x73, 0x01,
965  // 0x16: INT3
966  0xcc,
967  // 0x17: JMP 0x1c
968  0xe9, 0x00, 0x00, 0x00, 0x00,
969  },
970  .HypercallOffset = 0x16,
971  .RelocatedCodeOffset = 0x17,
972  },
973 
974  {
975  .MinVersion = 9600,
976  .MaxVersion = 17763,
977  .HypercallType = hypercallTypeInt3,
978 
979  .CodeLength = 0x22,
980  .Code =
981  {
982  // 0x00: TEST byte ptr [ecx+0x1c], 0x10
983  0xF6, 0x41, 0x1C, 0x10,
984  // 0x04: JZ 0x1d
985  0x74, 0x17,
986  // 0x06: PUSH eax
987  0x50,
988  // 0x07: MOV eax, dword ptr [esp+0x8]
989  0x8b, 0x44, 0x24, 0x08,
990  // 0x0B: MOV eax, dword ptr [eax+0x170]
991  0x8b, 0x80, 0x70, 0x01, 0x00, 0x00,
992  // 0x11: CMP al, 0x2a
993  0x3c, 0x2a,
994  // 0x13: BT eax, 0x08
995  0x0f, 0xba, 0xe0, 0x08,
996  // 0x17: POP eax
997  0x58,
998  // 0x18: JNZ 0x1d
999  0x75, 0x03,
1000  // 0x1A: JNC 0x1d
1001  0x73, 0x01,
1002  // 0x1C: INT3
1003  0xcc,
1004  // 0x1D: JMP 0x22
1005  0xe9, 0x00, 0x00, 0x00, 0x00,
1006  },
1007  .HypercallOffset = 0x1c,
1008  .RelocatedCodeOffset = 0x1d,
1009  },
1010 
1011  {
1012  .MinVersion = 18362,
1013  .MaxVersion = 18362,
1014  .HypercallType = hypercallTypeInt3,
1015 
1016  .CodeLength = 0x22,
1017  .Code =
1018  {
1019  // 0x00: TEST byte ptr [ecx+0x1d], 0x01
1020  0xF6, 0x41, 0x1d, 0x01,
1021  // Flag is set in the MMVAD.MMVAD_SHORT.u (flags)
1022  // 0x04: JZ 0x1d
1023  0x74, 0x17,
1024  // 0x06: PUSH eax
1025  0x50,
1026  // 0x07: MOV eax, dword ptr [esp+0x8]
1027  0x8b, 0x44, 0x24, 0x08,
1028  // 0x0B: MOV eax, dword ptr [eax+0x17c]
1029  0x8b, 0x80, 0x7c, 0x01, 0x00, 0x00,
1030  // 0x11: CMP al, 0x2a
1031  0x3c, 0x2a,
1032  // 0x13: BT eax, 0x08
1033  0x0f, 0xba, 0xe0, 0x08,
1034  // 0x17: POP eax
1035  0x58,
1036  // 0x18: JNZ 0x1d
1037  0x75, 0x03,
1038  // 0x1A: JNC 0x1d
1039  0x73, 0x01,
1040  // 0x1C: INT3
1041  0xcc,
1042  // 0x1D: JMP 0x22
1043  0xe9, 0x00, 0x00, 0x00, 0x00,
1044  },
1045  .HypercallOffset = 0x1c,
1046  .RelocatedCodeOffset = 0x1d,
1047  },
1048  },
1049  },
1050 
1051  {
1052  .ModuleName = u"ntoskrnl.exe",
1053  .FunctionName = "MiInsertVad",
1054  .MinVersion = 18363,
1055  .MaxVersion = DETOUR_MAX_VERSION_ANY,
1056  .Callback = IntWinVadHandleInsert,
1057  .PreCallback = IntWinVadPatchInsert,
1058  .Tag = detTagVadInsert,
1059  .Exported = FALSE,
1060  .NotCritical = FALSE,
1061  .DisableFlags = 0,
1062  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION | INTRO_OPT_ENABLE_MISC_EVENTS,
1063  .Arguments = DET_ARGS_DEFAULT_WIN86,
1064  .HandlersCount = 1,
1065  .Handlers =
1066  {
1067  {
1068  .MinVersion = 18363,
1069  .MaxVersion = DETOUR_MAX_VERSION_ANY,
1070  .HypercallType = hypercallTypeInt3,
1071 
1072  .CodeLength = 0x1e,
1073  .Code =
1074  {
1075  // 0x00: TEST byte ptr [ecx+0x1d], 0x01
1076  0xF6, 0x41, 0x1D, 0x01,
1077  // Flag is set in the MMVAD.MMVAD_SHORT.u (flags)
1078  // 0x04: JZ 0x19
1079  0x74, 0x13,
1080  // 0x06: PUSH eax
1081  0x50,
1082  // 0x07: MOV eax, dword ptr [edx+0x17c]
1083  0x8b, 0x82, 0x7c, 0x01, 0x00, 0x00,
1084  // 0x0D: CMP al, 0x2a
1085  0x3c, 0x2a,
1086  // 0x0F: BT eax, 0x08
1087  0x0f, 0xba, 0xe0, 0x08,
1088  // 0x13: POP eax
1089  0x58,
1090  // 0x14: JNZ 0x19
1091  0x75, 0x03,
1092  // 0x16: JNC 0x19
1093  0x73, 0x01,
1094  // 0x18: INT3
1095  0xcc,
1096  // 0x19: JMP 0x1e
1097  0xe9, 0x00, 0x00, 0x00, 0x00,
1098  },
1099  .HypercallOffset = 0x18,
1100  .RelocatedCodeOffset = 0x19,
1101  },
1102  },
1103  },
1104 
1105  {
1106  .ModuleName = u"ntoskrnl.exe",
1107  .FunctionName = "MiGetWsAndInsertVad",
1108  .MinVersion = DETOUR_MIN_VERSION_ANY,
1109  .MaxVersion = 18362,
1110  .Callback = IntWinVadHandleInsertMap,
1111  .PreCallback = IntWinVadPatchInsertMap,
1112  .Tag = detTagVadInsertMap,
1113  .Exported = FALSE,
1114  .NotCritical = FALSE,
1115  .DisableFlags = 0,
1116  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION | INTRO_OPT_ENABLE_MISC_EVENTS,
1117  .Arguments = DET_ARGS_DEFAULT_WIN86,
1118  .HandlersCount = 6,
1119  .Handlers =
1120  {
1121  {
1122  .MinVersion = 7600,
1123  .MaxVersion = 7602,
1124  .HypercallType = hypercallTypeInt3,
1125 
1126  .CodeLength = 0x34,
1127  .Code =
1128  {
1129  // 0x00: TEST byte ptr [edi+0x17], 0x02
1130  0xf6, 0x47, 0x17, 0x02,
1131  // 0x04: JZ 0x2f
1132  0x74, 0x29,
1133  // 0x06: PUSH eax
1134  0x50,
1135  // 0x07: PUSH ecx
1136  0x51,
1137  // 0x08: MOV ecx, dword ptr fs:[0x124]
1138  0x64, 0x8b, 0x0d, 0x24, 0x01, 0x00, 0x00,
1139  // 0x0F: MOV eax, dword ptr [ecx+0x50]
1140  0x8b, 0x41, 0x50,
1141  // 0x12: TEST eax, eax
1142  0x85, 0xc0,
1143  // 0x14: JNZ 0x1c
1144  0x75, 0x06,
1145  // 0x16: MOV eax, dword ptr [ecx+0x150]
1146  0x8B, 0x81, 0x50, 0x01, 0x00, 0x00,
1147  // 0x1C: MOV eax, dword ptr [eax+0x16c]
1148  0x8b, 0x80, 0x6c, 0x01, 0x00, 0x00,
1149  // 0x22: CMP al, 0x2a
1150  0x3c, 0x2a,
1151  // 0x24: BT eax, 0x08
1152  0x0f, 0xba, 0xe0, 0x08,
1153  // 0x28: POP ecx
1154  0x59,
1155  // 0x29: POP eax
1156  0x58,
1157  // 0x2A: JNZ 0x2f
1158  0x75, 0x03,
1159  // 0x2C: JNC 0x2f
1160  0x73, 0x01,
1161  // 0x2E: INT3
1162  0xCC,
1163  // 0x2F: JMP 0x34
1164  0xE9, 0x00, 0x00, 0x00, 0x00
1165  },
1166  .HypercallOffset = 0x2e,
1167  .RelocatedCodeOffset = 0x2f,
1168  },
1169 
1170  {
1171  .MinVersion = 9200,
1172  .MaxVersion = 9200,
1173  .HypercallType = hypercallTypeInt3,
1174 
1175  .CodeLength = 0x37,
1176  .Code =
1177  {
1178  // 0x00: TEST byte ptr [eax+0x18], 0x10
1179  0xf6, 0x40, 0x18, 0x10,
1180  // 0x04: JZ 0x32
1181  0x74, 0x2c,
1182  // 0x06: PUSH eax
1183  0x50,
1184  // 0x07: PUSH ecx
1185  0x51,
1186  // 0x08: MOV ecx, dword ptr fs:[0x124]
1187  0x64, 0x8b, 0x0d, 0x24, 0x01, 0x00, 0x00,
1188  // 0x0F: MOV eax, dword ptr [ecx+0x80]
1189  0x8b, 0x81, 0x80, 0x00, 0x00, 0x00,
1190  // 0x15: TEST eax, eax
1191  0x85, 0xc0,
1192  // 0x17: JNZ 0x1f
1193  0x75, 0x06,
1194  // 0x19: MOV eax, dword ptr [ecx+0x150]
1195  0x8B, 0x81, 0x50, 0x01, 0x00, 0x00,
1196  // 0x1F: MOV eax, dword ptr [eax+0x170]
1197  0x8b, 0x80, 0x70, 0x01, 0x00, 0x00,
1198  // 0x25: CMP al, 0x2a
1199  0x3c, 0x2a,
1200  // 0x27: BT eax, 0x08
1201  0x0f, 0xba, 0xe0, 0x08,
1202  // 0x2B: POP ecx
1203  0x59,
1204  // 0x2C: POP eax
1205  0x58,
1206  // 0x2D: JNZ 0x32
1207  0x75, 0x03,
1208  // 0x2F: JNC 0x32
1209  0x73, 0x01,
1210  // 0x31: INT3
1211  0xCC,
1212  // 0x32: JMP 0x37
1213  0xE9, 0x00, 0x00, 0x00, 0x00
1214  },
1215  .HypercallOffset = 0x31,
1216  .RelocatedCodeOffset = 0x32,
1217  },
1218 
1219  {
1220  .MinVersion = 9600,
1221  .MaxVersion = 17763,
1222  .HypercallType = hypercallTypeInt3,
1223 
1224  .CodeLength = 0x37,
1225  .Code =
1226  {
1227  // 0x00: TEST byte ptr [ecx+0x1c], 0x10
1228  0xf6, 0x41, 0x1c, 0x10,
1229  // 0x04: JZ 0x32
1230  0x74, 0x2c,
1231  // 0x06: PUSH eax
1232  0x50,
1233  // 0x07: PUSH ecx
1234  0x51,
1235  // 0x08: MOV ecx, dword ptr fs:[0x124]
1236  0x64, 0x8b, 0x0d, 0x24, 0x01, 0x00, 0x00,
1237  // 0x0F: MOV eax, dword ptr [ecx+0x80]
1238  0x8b, 0x81, 0x80, 0x00, 0x00, 0x00,
1239  // 0x15: TEST eax, eax
1240  0x85, 0xc0,
1241  // 0x17: JNZ 0x1f
1242  0x75, 0x06,
1243  // 0x19: MOV eax, dword ptr [ecx+0x150]
1244  0x8B, 0x81, 0x50, 0x01, 0x00, 0x00,
1245  // 0x1F: MOV eax, dword ptr [eax+0x170]
1246  0x8b, 0x80, 0x70, 0x01, 0x00, 0x00,
1247  // 0x25: CMP al, 0x2a
1248  0x3c, 0x2a,
1249  // 0x27: BT eax, 0x08
1250  0x0f, 0xba, 0xe0, 0x08,
1251  // 0x2B: POP ecx
1252  0x59,
1253  // 0x2C: POP eax
1254  0x58,
1255  // 0x2D: JNZ 0x32
1256  0x75, 0x03,
1257  // 0x2F: JNC 0x32
1258  0x73, 0x01,
1259  // 0x31: INT3
1260  0xCC,
1261  // 0x32: JMP 0x37
1262  0xE9, 0x00, 0x00, 0x00, 0x00
1263  },
1264  .HypercallOffset = 0x31,
1265  .RelocatedCodeOffset = 0x32,
1266  },
1267 
1268  {
1269  .MinVersion = 18362,
1270  .MaxVersion = DETOUR_MAX_VERSION_ANY,
1271  .HypercallType = hypercallTypeInt3,
1272 
1273  .CodeLength = 0x37,
1274  .Code =
1275  {
1276  // 0x00: TEST byte ptr [ecx+0x1d], 0x01
1277  0xf6, 0x41, 0x1d, 0x1,
1278  // 0x04: JZ 0x32
1279  0x74, 0x2c,
1280  // 0x06: PUSH eax
1281  0x50,
1282  // 0x07: PUSH ecx
1283  0x51,
1284  // 0x08: MOV ecx, dword ptr fs:[0x124]
1285  0x64, 0x8b, 0x0d, 0x24, 0x01, 0x00, 0x00,
1286  // 0x0F: MOV eax, dword ptr [ecx+0x80]
1287  0x8b, 0x81, 0x80, 0x00, 0x00, 0x00,
1288  // 0x15: TEST eax, eax
1289  0x85, 0xc0,
1290  // 0x17: JNZ 0x1f
1291  0x75, 0x06,
1292  // 0x19: MOV eax, dword ptr [ecx+0x150]
1293  0x8b, 0x81, 0x50, 0x01, 0x00, 0x00,
1294  // 0x1F: MOV eax, dword ptr [eax+0x17c]
1295  0x8b, 0x80, 0x7c, 0x01, 0x00, 0x00,
1296  // 0x25: CMP al, 0x2a
1297  0x3c, 0x2a,
1298  // 0x27: BT eax, 0x08
1299  0x0f, 0xba, 0xe0, 0x08,
1300  // 0x2B: POP ecx
1301  0x59,
1302  // 0x2C: POP eax
1303  0x58,
1304  // 0x2D: JNZ 0x32
1305  0x75, 0x03,
1306  // 0x2F: JNC 0x32
1307  0x73, 0x01,
1308  // 0x31: INT3
1309  0xcc,
1310  // 0x32: JMP 0x37
1311  0xe9, 0x00, 0x00, 0x00, 0x00,
1312  },
1313  .HypercallOffset = 0x31,
1314  .RelocatedCodeOffset = 0x32,
1315  },
1316  },
1317  },
1318 
1319  {
1320  .ModuleName = u"ntoskrnl.exe",
1321  .FunctionName = "MiCommitExistingVad",
1322  .MinVersion = DETOUR_MIN_VERSION_ANY,
1323  .MaxVersion = DETOUR_MAX_VERSION_ANY,
1324  .PreCallback = IntWinPatchVadHandleCommit,
1325  .Callback = IntWinVadHandleCommit,
1326  .Tag = detTagVadCommit,
1327  .Exported = FALSE,
1328  .NotCritical = FALSE,
1329  .DisableFlags = 0,
1330  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION,
1331  .Arguments = DET_ARGS_DEFAULT_WIN86,
1332  .HandlersCount = 1,
1333  .Handlers =
1334  {
1335  {
1336  .MinVersion = DETOUR_MIN_VERSION_ANY,
1337  .MaxVersion = DETOUR_MAX_VERSION_ANY,
1338  .HypercallType = hypercallTypeInt3,
1339  .CodeLength = 0x3b,
1340  .Code =
1341  {
1342  // VmProtection & (PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READWRITE |
1343  // PAGE_EXECUTE_READ | PAGE_EXECUTE)
1344  // 0x00: TEST byte ptr [esp+0x0], 0xf0
1345  0xf6, 0x44, 0x24, 0x00, 0xf0,
1346  // 0x05: JZ 0x36
1347  0x74, 0x2f,
1348  // 0x07: PUSH ecx
1349  0x51,
1350  // 0x08: PUSH eax
1351  0x50,
1352  // ecx = Kpcr.Prcb.CurrentThread
1353  // 0x09: MOV ecx, dword ptr fs:[0x0]
1354  0x64, 0x8b, 0x0d, 0x00, 0x00, 0x00, 0x00,
1355  // eax = Thread.ApcState.AttachedProcess
1356  // 0x10: MOV eax, dword ptr [ecx+0x0]
1357  0x8b, 0x81, 0x00, 0x00, 0x00, 0x00,
1358  // 0x16: TEST eax, eax
1359  0x85, 0xc0,
1360  // 0x18: JNZ 0x20
1361  0x75, 0x06,
1362  // eax = Thread.Process
1363  // 0x1A: MOV eax, dword ptr [ecx+0x0]
1364  0x8b, 0x81, 0x00, 0x00, 0x00, 0x00,
1365  // cmp Process.ImageFileName[0], '*'
1366  // 0x20: CMP byte ptr [eax+0x0], 0x2a
1367  0x80, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x2a,
1368  // check if 0 != (Process.ImageFileName[1] & winProcExitVad)
1369  // 0x27: BT dword ptr [eax+0x0], 0x08
1370  0x0f, 0xba, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x08,
1371  // 0x2F: POP eax
1372  0x58,
1373  // 0x30: POP ecx
1374  0x59,
1375  // 0x31: JNZ 0x36
1376  0x75, 0x03,
1377  // 0x33: JNC 0x36
1378  0x73, 0x01,
1379  // 0x35: INT3
1380  0xcc,
1381  // 0x36: JMP 0x3b
1382  0xe9, 0x00, 0x00, 0x00, 0x00
1383  },
1384  .HypercallOffset = 0x35,
1385  .RelocatedCodeOffset = 0x36,
1386  },
1387  },
1388  },
1389 
1390  {
1391  .ModuleName = u"ntoskrnl.exe",
1392  .FunctionName = "MiProtectVirtualMemory",
1393  .MinVersion = DETOUR_MIN_VERSION_ANY,
1394  .MaxVersion = DETOUR_MAX_VERSION_ANY,
1395  .Callback = IntWinVadHandleVirtualProtect,
1396  .PreCallback = IntWinVadPatchVirtualProtect,
1397  .Tag = detTagVmProtect,
1398  .Exported = FALSE,
1399  .NotCritical = FALSE,
1400  .DisableFlags = 0,
1401  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION | INTRO_OPT_ENABLE_MISC_EVENTS,
1402  .Arguments = DET_ARGS_DEFAULT_WIN86,
1403  .HandlersCount = 5,
1404  .Handlers =
1405  {
1406  {
1407  .MinVersion = 7600,
1408  .MaxVersion = 9200,
1409  .HypercallType = hypercallTypeInt3,
1410 
1411  .CodeLength = 0x23,
1412  .Code =
1413  {
1414  // 0x00: TEST byte ptr [esp+0x10], 0xf0
1415  0xF6, 0x44, 0x24, 0x10, 0xF0,
1416  // 0x05: JZ 0x1e
1417  0x74, 0x17,
1418  // 0x07: PUSH eax
1419  0x50,
1420  // 0x08: MOV eax, dword ptr [esp+0x8]
1421  0x8b, 0x44, 0x24, 0x08,
1422  // 0x0C: MOV eax, dword ptr [eax+0x16c]
1423  0x8b, 0x80, 0x6c, 0x01, 0x00, 0x00,
1424  // 0x12: CMP al, 0x2a
1425  0x3c, 0x2a,
1426  // 0x14: BT eax, 0x08
1427  0x0f, 0xba, 0xe0, 0x08,
1428  // 0x18: POP eax
1429  0x58,
1430  // 0x19: JNZ 0x1e
1431  0x75, 0x03,
1432  // 0x1B: JNC 0x1e
1433  0x73, 0x01,
1434  // 0x1D: INT3
1435  0xcc,
1436  // 0x1E: JMP 0x23
1437  0xe9, 0x00, 0x00, 0x00, 0x00,
1438  },
1439  .HypercallOffset = 0x1d,
1440  .RelocatedCodeOffset = 0x1e,
1441  },
1442 
1443  {
1444  .MinVersion = 9600,
1445  .MaxVersion = DETOUR_MAX_VERSION_ANY,
1446  .HypercallType = hypercallTypeInt3,
1447 
1448  .CodeLength = 0x20,
1449  .Code =
1450  {
1451  // 0x00: TEST byte ptr [esp+0xc], 0xf0
1452  0xF6, 0x44, 0x24, 0x0C, 0xF0,
1453  // 0x05: JZ 0x1b
1454  0x74, 0x14,
1455  // 0x07: CMP byte ptr [edx+0x170], 0x2a
1456  0x80, 0xba, 0x70, 0x01, 0x00, 0x00, 0x2a,
1457  // 0x0E: BT dword ptr [edx+0x170], 0x08
1458  0x0f, 0xba, 0xa2, 0x70, 0x01, 0x00, 0x00, 0x08,
1459  // 0x16: JNZ 0x1b
1460  0x75, 0x03,
1461  // 0x18: JNC 0x1b
1462  0x73, 0x01,
1463  // 0x1A: INT3
1464  0xcc,
1465  // 0x1B: JMP 0x20
1466  0xe9, 0x00, 0x00, 0x00, 0x00,
1467  },
1468  .HypercallOffset = 0x1a,
1469  .RelocatedCodeOffset = 0x1b,
1470  },
1471  },
1472  },
1473 
1474  {
1475  .ModuleName = u"ntoskrnl.exe",
1476  .FunctionName = "MiDeleteVirtualAddresses",
1477  .MinVersion = DETOUR_MIN_VERSION_ANY,
1478  .MaxVersion = 16299,
1479  .Callback = IntWinVadHandleDeleteVaRange,
1480  .PreCallback = IntWinVadPatchDeleteVaRange,
1481  .Tag = detTagVaDelete,
1482  .Exported = FALSE,
1483  .NotCritical = FALSE,
1484  .DisableFlags = 0,
1485  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION | INTRO_OPT_ENABLE_MISC_EVENTS,
1486  .Arguments = DET_ARGS_DEFAULT_WIN86,
1487  .HandlersCount = 4,
1488  .Handlers =
1489  {
1490  {
1491  .MinVersion = 7600,
1492  .MaxVersion = 7602,
1493  .HypercallType = hypercallTypeInt3,
1494 
1495  .CodeLength = 0x2e,
1496  .Code =
1497  {
1498  // 0x00: PUSH eax
1499  0x50,
1500  // 0x01: PUSH ecx
1501  0x51,
1502  // 0x02: MOV ecx, dword ptr fs:[0x124]
1503  0x64, 0x8b, 0x0d, 0x24, 0x01, 0x00, 0x00,
1504  // 0x09: MOV eax, dword ptr [ecx+0x50]
1505  0x8b, 0x41, 0x50,
1506  // 0x0C: TEST eax, eax
1507  0x85, 0xc0,
1508  // 0x0E: JNZ 0x16
1509  0x75, 0x06,
1510  // 0x10: MOV eax, dword ptr [ecx+0x150]
1511  0x8B, 0x81, 0x50, 0x01, 0x00, 0x00,
1512  // 0x16: MOV eax, dword ptr [eax+0x16c]
1513  0x8b, 0x80, 0x6c, 0x01, 0x00, 0x00,
1514  // 0x1C: CMP al, 0x2a
1515  0x3c, 0x2a,
1516  // 0x1E: BT eax, 0x08
1517  0x0f, 0xba, 0xe0, 0x08,
1518  // 0x22: POP ecx
1519  0x59,
1520  // 0x23: POP eax
1521  0x58,
1522  // 0x24: JNZ 0x29
1523  0x75, 0x03,
1524  // 0x26: JNC 0x29
1525  0x73, 0x01,
1526  // 0x28: INT3
1527  0xCC,
1528  // 0x29: JMP 0x2e
1529  0xE9, 0x00, 0x00, 0x00, 0x00
1530  },
1531  .HypercallOffset = 0x28,
1532  .RelocatedCodeOffset = 0x29,
1533  },
1534 
1535  {
1536  .MinVersion = 9200,
1537  .MaxVersion = 16299,
1538  .HypercallType = hypercallTypeInt3,
1539 
1540  .CodeLength = 0x31,
1541  .Code =
1542  {
1543  // 0x00: PUSH eax
1544  0x50,
1545  // 0x01: PUSH ecx
1546  0x51,
1547  // 0x02: MOV ecx, dword ptr fs:[0x124]
1548  0x64, 0x8b, 0x0d, 0x24, 0x01, 0x00, 0x00,
1549  // 0x09: MOV eax, dword ptr [ecx+0x80]
1550  0x8b, 0x81, 0x80, 0x00, 0x00, 0x00,
1551  // 0x0F: TEST eax, eax
1552  0x85, 0xc0,
1553  // 0x11: JNZ 0x19
1554  0x75, 0x06,
1555  // 0x13: MOV eax, dword ptr [ecx+0x150]
1556  0x8B, 0x81, 0x50, 0x01, 0x00, 0x00,
1557  // 0x19: MOV eax, dword ptr [eax+0x170]
1558  0x8b, 0x80, 0x70, 0x01, 0x00, 0x00,
1559  // 0x1F: CMP al, 0x2a
1560  0x3c, 0x2a,
1561  // 0x21: BT eax, 0x08
1562  0x0f, 0xba, 0xe0, 0x08,
1563  // 0x25: POP ecx
1564  0x59,
1565  // 0x26: POP eax
1566  0x58,
1567  // 0x27: JNZ 0x2c
1568  0x75, 0x03,
1569  // 0x29: JNC 0x2c
1570  0x73, 0x01,
1571  // 0x2B: INT3
1572  0xCC,
1573  // 0x2C: JMP 0x31
1574  0xE9, 0x00, 0x00, 0x00, 0x00
1575  },
1576  .HypercallOffset = 0x2b,
1577  .RelocatedCodeOffset = 0x2c,
1578  },
1579  },
1580  },
1581 
1582  {
1583  .ModuleName = u"ntoskrnl.exe",
1584  .FunctionName = "MiFinishVadDeletion",
1585  .MinVersion = 17134,
1586  .MaxVersion = DETOUR_MAX_VERSION_ANY,
1587  .Callback = IntWinVadHandleFinishVadDeletion,
1588  .PreCallback = IntWinVadPatchFinishVadDeletion,
1589  .Tag = detTagFinishVadDeletion,
1590  .Exported = FALSE,
1591  .NotCritical = FALSE,
1592  .DisableFlags = 0,
1593  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION | INTRO_OPT_ENABLE_MISC_EVENTS,
1594  .Arguments = DET_ARGS_DEFAULT_WIN86,
1595  .HandlersCount = 1,
1596  .Handlers =
1597  {
1598  {
1599  .MinVersion = 17134,
1600  .MaxVersion = DETOUR_MAX_VERSION_ANY,
1601  .HypercallType = hypercallTypeInt3,
1602 
1603  .CodeLength = 0x31,
1604  .Code =
1605  {
1606  // 0x00: PUSH eax
1607  0x50,
1608  // 0x01: PUSH ecx
1609  0x51,
1610  // 0x02: MOV ecx, dword ptr fs:[0x124]
1611  0x64, 0x8b, 0x0d, 0x24, 0x01, 0x00, 0x00,
1612  // 0x09: MOV eax, dword ptr [ecx+0x80]
1613  0x8b, 0x81, 0x80, 0x00, 0x00, 0x00,
1614  // 0x0F: TEST eax, eax
1615  0x85, 0xc0,
1616  // 0x11: JNZ 0x19
1617  0x75, 0x06,
1618  // 0x13: MOV eax, dword ptr [ecx+0x150]
1619  0x8b, 0x81, 0x50, 0x01, 0x00, 0x00,
1620  // 0x19: MOV eax, dword ptr [eax+0x17c]
1621  0x8b, 0x80, 0x7c, 0x01, 0x00, 0x00,
1622  // 0x1F: CMP al, 0x2a
1623  0x3c, 0x2a,
1624  // 0x21: BT eax, 0x08
1625  0x0f, 0xba, 0xe0, 0x08,
1626  // 0x25: POP ecx
1627  0x59,
1628  // 0x26: POP eax
1629  0x58,
1630  // 0x27: JNZ 0x2c
1631  0x75, 0x03,
1632  // 0x29: JNC 0x2c
1633  0x73, 0x01,
1634  // 0x2B: INT3
1635  0xcc,
1636  // 0x2C: JMP 0x31
1637  0xE9, 0x00, 0x00, 0x00, 0x00
1638  },
1639  .HypercallOffset = 0x2b,
1640  .RelocatedCodeOffset = 0x2c,
1641  },
1642  },
1643  },
1644 
1645  {
1646  .ModuleName = u"ntoskrnl.exe",
1647  .FunctionName = "NtSetSystemPowerState",
1648  .MinVersion = DETOUR_MIN_VERSION_ANY,
1649  .MaxVersion = DETOUR_MAX_VERSION_ANY,
1650  .Callback = IntWinPowHandlePowerStateChange,
1651  .Tag = detTagPowerState,
1652  .Exported = FALSE,
1653  .NotCritical = TRUE,
1654  .DisableFlags = 0,
1655  .EnableFlags = DETOUR_ENABLE_ALWAYS,
1656  .Arguments = DET_ARGS_DEFAULT_WIN86,
1657  .HandlersCount = 1,
1658  .Handlers =
1659  {
1660  {
1661  .MinVersion = DETOUR_MIN_VERSION_ANY,
1662  .MaxVersion = DETOUR_MAX_VERSION_ANY,
1663  .HypercallType = hypercallTypeInt3,
1664 
1665  .CodeLength = 0xF,
1666  .Code =
1667  {
1668  // 0x00: INT3
1669  0xcc,
1670  // 0x01: NOP
1671  0x66, 0x66, 0x66, 0x66, 0x90,
1672  // 0x06: NOP
1673  0x66, 0x90,
1674  // 0x08: NOP
1675  0x66, 0x90,
1676  // 0x0A: JMP 0xf
1677  0xe9, 0x00, 0x00, 0x00, 0x00
1678  },
1679  .HypercallOffset = 0x0,
1680  .RelocatedCodeOffset = 0xA,
1681  },
1682  },
1683  },
1684 
1685  {
1686  .ModuleName = u"ntoskrnl.exe",
1687  .FunctionName = "KiDisplayBlueScreen",
1688  .MinVersion = DETOUR_MIN_VERSION_ANY,
1689  .MaxVersion = DETOUR_MAX_VERSION_ANY,
1690  .Callback = IntGuestUninitOnBugcheck,
1691  .Tag = detTagCleanupMemDump,
1692  .Exported = FALSE,
1693  .NotCritical = TRUE,
1694  .DisableFlags = 0,
1695  .EnableFlags = INTRO_OPT_BUGCHECK_CLEANUP,
1696  .Arguments = DET_ARGS_DEFAULT_WIN86,
1697  .HandlersCount = 1,
1698  .Handlers =
1699  {
1700  {
1701  .MinVersion = DETOUR_MIN_VERSION_ANY,
1702  .MaxVersion = DETOUR_MAX_VERSION_ANY,
1703  .HypercallType = hypercallTypeInt3,
1704 
1705  .CodeLength = 0x8,
1706  .Code =
1707  {
1708  // 0x00: INT3
1709  0xCC,
1710  // 0x01: NOP
1711  0x90,
1712  // 0x02: NOP
1713  0x90,
1714  // 0x03: JMP 0x8
1715  0xE9, 0x00, 0x00, 0x00, 0x00
1716  },
1717  .HypercallOffset = 0x0,
1718  .RelocatedCodeOffset = 0x3,
1719  },
1720  },
1721  },
1722 
1723  {
1724  .ModuleName = u"ntoskrnl.exe",
1725  .FunctionName = "MmInSwapProcessHijack",
1726  .MinVersion = DETOUR_MIN_VERSION_ANY,
1727  .MaxVersion = DETOUR_MAX_VERSION_ANY,
1728  .Callback = IntWinProcSwapIn,
1729  .Tag = detTagProcSwapIn,
1730  .Exported = FALSE,
1731  .NotCritical = FALSE,
1732  .DisableFlags = 0,
1733  .EnableFlags = DETOUR_ENABLE_ALWAYS,
1734  .Arguments = DET_ARGS_DEFAULT_WIN86,
1735  .HandlersCount = 1,
1736  .Handlers =
1737  {
1738  {
1739  .MinVersion = DETOUR_MIN_VERSION_ANY,
1740  .MaxVersion = DETOUR_MAX_VERSION_ANY,
1741  .HypercallType = hypercallTypeInt3,
1742 
1743  .CodeLength = 0x8,
1744  .Code =
1745  {
1746 
1747  // 0x00: INT3
1748  0xCC,
1749  // 0x01: NOP
1750  0x90,
1751  // 0x02: NOP
1752  0x90,
1753  // 0x03: JMP 0x8
1754  0xE9, 0x00, 0x00, 0x00, 0x00
1755  },
1756  .HypercallOffset = 0x0,
1757  .RelocatedCodeOffset = 0x3,
1758  },
1759  },
1760  },
1761 
1762  {
1763  .ModuleName = u"ntoskrnl.exe",
1764  .FunctionName = "KiOutSwapProcessesHijack",
1765  .MinVersion = DETOUR_MIN_VERSION_ANY,
1766  .MaxVersion = DETOUR_MAX_VERSION_ANY,
1767  .PreCallback = IntWinProcPatchSwapOut32,
1768  .Callback = IntWinProcSwapOut,
1769  .Tag = detTagProcSwapOut,
1770  .Exported = FALSE,
1771  .NotCritical = FALSE,
1772  .DisableFlags = 0,
1773  .EnableFlags = DETOUR_ENABLE_ALWAYS,
1774  .Arguments = DET_ARGS_DEFAULT_WIN86,
1775  .HandlersCount = 1,
1776  .Handlers =
1777  {
1778  {
1779  .MinVersion = DETOUR_MIN_VERSION_ANY,
1780  .MaxVersion = DETOUR_MAX_VERSION_ANY,
1781  .HypercallType = hypercallTypeInt3,
1782 
1783  .CodeLength = 0x14,
1784  .Code =
1785  {
1786  // 0x00: PUSH eax
1787  0x50,
1788  // 0x01: MOV eax, DWORD PTR [edi + _EPROCESS.Flags]
1789  0x8B, 0x87, 0x00, 0x00, 0x00, 0x00,
1790  // 0x07: BT eax, 0x07
1791  0x0f, 0xba, 0xe0, 0x07,
1792  // 0x0B: JNC 0x0E
1793  0x73, 0x01,
1794  // 0x0D: INT3
1795  0xCC,
1796  // 0x0E: POP eax
1797  0x58,
1798  // 0x0F: JMP 0x10
1799  0xE9, 0x00, 0x00, 0x00, 0x00
1800  },
1801  .HypercallOffset = 0x0D,
1802  .RelocatedCodeOffset = 0x0F,
1803  },
1804  },
1805  },
1806 };
1807 
1809 const size_t gHookableApisX86Size = ARRAYSIZE(gHookableApisX86);
1810 
1811 
1815 API_HOOK_DESCRIPTOR gHookableApisX64[]
1816 __section(".detours") =
1817 {
1818  {
1819  .ModuleName = u"ntoskrnl.exe",
1820  .FunctionName = "ExAllocatePoolWithTag",
1821  .MinVersion = DETOUR_MIN_VERSION_ANY,
1822  .MaxVersion = DETOUR_MAX_VERSION_ANY,
1823  .Callback = IntWinPoolHandleAlloc,
1824  .Tag = detTagPoolAlloc,
1825  .Exported = TRUE,
1826  .NotCritical = FALSE,
1827  .DisableFlags = 0,
1828  .EnableFlags = DETOUR_ENABLE_ALWAYS,
1829  .Arguments = DET_ARGS_DEFAULT_WIN64,
1830  .HandlersCount = 1,
1831  .Handlers =
1832  {
1833  {
1834  .MinVersion = DETOUR_MIN_VERSION_ANY,
1835  .MaxVersion = DETOUR_MAX_VERSION_ANY,
1836  .HypercallType = hypercallTypeInt3,
1837 
1838  .CodeLength = 0x37,
1839  .Code =
1840  {
1841  // 0x00: CMP r8d, 0xf6697244
1842  0x41, 0x81, 0xF8, 0x44, 0x72, 0x69, 0xF6,
1843  // 0x07: JZ 0x2f
1844  0x74, 0x26,
1845  // 0x09: CMP r8d, 0x76697244
1846  0x41, 0x81, 0xF8, 0x44, 0x72, 0x69, 0x76,
1847  // 0x10: JZ 0x2f
1848  0x74, 0x1D,
1849  // 0x12: CMP r8d, 0x69664d46
1850  0x41, 0x81, 0xF8, 0x46, 0x4D, 0x66, 0x69,
1851  // 0x19: JZ 0x2f
1852  0x74, 0x14,
1853  // 0x1B: CMP r8d, 0x656b6f54
1854  0x41, 0x81, 0xF8, 0x54, 0x6f, 0x6b, 0x65,
1855  // 0x22: JZ 0x2f
1856  0x74, 0x0B,
1857  // 0x24: CMP r8d, 0xe56b6f54
1858  0x41, 0x81, 0xF8, 0x54, 0x6f, 0x6b, 0xe5,
1859  // 0x2B: JZ 0x2f
1860  0x74, 0x02,
1861  // 0x2D: JMP 0x32
1862  0xEB, 0x03,
1863  // 0x2F: INT3
1864  0xCC,
1865  // 0x30: NOP
1866  0x90,
1867  // 0x31: NOP
1868  0x90,
1869  // 0x32: JMP 0x37
1870  0xE9, 0x00, 0x00, 0x00, 0x00,
1871  },
1872  .HypercallOffset = 0x2F,
1873  .RelocatedCodeOffset = 0x32,
1874  },
1875  },
1876  },
1877 
1878  {
1879  .ModuleName = u"ntoskrnl.exe",
1880  .FunctionName = "ExFreePoolWithTag",
1881  .MinVersion = DETOUR_MIN_VERSION_ANY,
1882  .MaxVersion = DETOUR_MAX_VERSION_ANY,
1883  .Callback = IntWinPoolHandleFree,
1884  .Tag = detTagPoolFree,
1885  .Exported = TRUE,
1886  .NotCritical = FALSE,
1887  .DisableFlags = 0,
1888  .EnableFlags = DETOUR_ENABLE_ALWAYS,
1889  .Arguments = DET_ARGS_DEFAULT_WIN64,
1890  .HandlersCount = 1,
1891  .Handlers =
1892  {
1893  {
1894  .MinVersion = DETOUR_MIN_VERSION_ANY,
1895  .MaxVersion = DETOUR_MAX_VERSION_ANY,
1896  .HypercallType = hypercallTypeInt3,
1897 
1898  .CodeLength = 0x22,
1899  .Code =
1900  {
1901  // 0x00: CMP edx, 0xf6697244
1902  0x81, 0xFA, 0x44, 0x72, 0x69, 0xF6,
1903  // 0x06: JZ 0x1a
1904  0x74, 0x12,
1905  // 0x08: CMP edx, 0x76697244
1906  0x81, 0xFA, 0x44, 0x72, 0x69, 0x76,
1907  // 0x0E: JZ 0x1a
1908  0x74, 0x0A,
1909  // 0x10: CMP edx, 0x69664d46
1910  0x81, 0xFA, 0x46, 0x4D, 0x66, 0x69,
1911  // 0x16: JZ 0x1a
1912  0x74, 0x02,
1913  // 0x18: JMP 0x1d
1914  0xEB, 0x03,
1915  // 0x1A: INT3
1916  0xCC,
1917  // 0x1B: NOP
1918  0x90,
1919  // 0x1C: NOP
1920  0x90,
1921  // 0x1D: JMP 0x22
1922  0xE9, 0x00, 0x00, 0x00, 0x00,
1923  },
1924  .HypercallOffset = 0x1A,
1925  .RelocatedCodeOffset = 0x1D,
1926  },
1927  },
1928  },
1929 
1930  {
1931  .ModuleName = u"ntoskrnl.exe",
1932  .FunctionName = "KeBugCheckEx",
1933  .MinVersion = DETOUR_MIN_VERSION_ANY,
1934  .MaxVersion = DETOUR_MAX_VERSION_ANY,
1935  .Callback = IntWinBcHandleBugCheck,
1936  .Tag = detTagBugcheck,
1937  .Exported = TRUE,
1938  .NotCritical = FALSE,
1939  .DisableFlags = 0,
1940  .EnableFlags = INTRO_OPT_BUGCHECK_CLEANUP | INTRO_OPT_EVENT_OS_CRASH,
1941  .Arguments = DET_ARGS_DEFAULT_WIN64,
1942  .HandlersCount = 1,
1943  .Handlers =
1944  {
1945  {
1946  .MinVersion = DETOUR_MIN_VERSION_ANY,
1947  .MaxVersion = DETOUR_MAX_VERSION_ANY,
1948  .HypercallType = hypercallTypeInt3,
1949 
1950  .CodeLength = 0x8,
1951  .Code =
1952  {
1953  // 0x00: INT3
1954  0xCC,
1955  // 0x01: NOP
1956  0x90,
1957  // 0x02: NOP
1958  0x90,
1959  // 0x03: JMP 0x8
1960  0xE9, 0x00, 0x00, 0x00, 0x00
1961  },
1962  .HypercallOffset = 0x0,
1963  .RelocatedCodeOffset = 0x3,
1964  },
1965  },
1966  },
1967 
1968  {
1969  .ModuleName = u"ntoskrnl.exe",
1970  .FunctionName = "NtSetInformationProcess",
1971  .MinVersion = DETOUR_MIN_VERSION_ANY,
1972  .MaxVersion = DETOUR_MAX_VERSION_ANY,
1973  .Callback = IntWinProcHandleInstrument,
1974  .PreCallback = IntWinProcPrepareInstrument,
1975  .Tag = detTagSetProcInformation,
1976  .Exported = TRUE,
1977  .NotCritical = FALSE,
1978  .DisableFlags = 0,
1979  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION,
1980  .Arguments = DET_ARGS_DEFAULT_WIN64,
1981  .HandlersCount = 1,
1982  .Handlers =
1983  {
1984  {
1985  .MinVersion = DETOUR_MIN_VERSION_ANY,
1986  .MaxVersion = DETOUR_MAX_VERSION_ANY,
1987  .HypercallType = hypercallTypeInt3,
1988 
1989  .CodeLength = 0xbd,
1990  .Code =
1991  {
1992  // 0x00: cmp edx,0x28
1993  0x83, 0xfa, 0x28,
1994  // 0x03: jne 0xb8 <_irelevant>
1995  0x0f, 0x85, 0xaf, 0x00, 0x00, 0x00,
1996  // 0x09: push rax
1997  0x50,
1998  // 0x0a: push rcx
1999  0x51,
2000  // 0x0b: push rdx
2001  0x52,
2002  // 0x0c: push r8
2003  0x41, 0x50,
2004  // 0x0e: push r9
2005  0x41, 0x51,
2006  // 0x10: push r10
2007  0x41, 0x52,
2008  // 0x12: push r11
2009  0x41, 0x53,
2010  // reserve space for locals
2011  // 0x14: sub rsp,0x10
2012  0x48, 0x83, 0xec, 0x10,
2013  // 0x18: mov edx,0x0
2014  0xba, 0x00, 0x00, 0x00, 0x00,
2015  // PsProcessType
2016  // 0x1d: movabs rax,0xfffff00000000000
2017  0x48, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff,
2018  // 0x27: mov r8,QWORD PTR [rax]
2019  0x4c, 0x8b, 0x00,
2020  // 0x2a: mov r9,0x1
2021  0x49, 0xc7, 0xc1, 0x01, 0x00, 0x00, 0x00,
2022  // 0x31: lea rax,[rsp+0x8]
2023  0x48, 0x8d, 0x44, 0x24, 0x08,
2024  // 0x36: push 0x0
2025  0x6a, 0x00,
2026  // 0x38: push rax
2027  0x50,
2028  // ObReferenceObjectByHandle
2029  // 0x39: movabs rax,0xfffff00000000000
2030  0x48, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff,
2031  // 0x43: sub rsp,0x20
2032  0x48, 0x83, 0xec, 0x20,
2033  // 0x47: call rax
2034  0xff, 0xd0,
2035  // 0x49: add rsp,0x30
2036  0x48, 0x83, 0xc4, 0x30,
2037  // 0x4d: test eax,eax
2038  0x85, 0xc0,
2039  // 0x4f: mov eax, 0
2040  0xb8, 0x00, 0x00, 0x00, 0x00,
2041  // 0x54: jne 0x9d <_exit>
2042  0x75, 0x47,
2043  // 0x56: mov rcx,QWORD PTR [rsp+0x8]
2044  0x48, 0x8b, 0x4c, 0x24, 0x08,
2045  // This offset will be overwritten by intro with the offset of `_EPROCESS.Spare`
2046  // 0x5b: mov rax,QWORD PTR [rcx+0x150]
2047  0x48, 0x8b, 0x81, 0x50, 0x01, 0x00, 0x00,
2048  // 0x62: cmp al,0x2a
2049  0x3c, 0x2a,
2050  // 0x64: bt rax,0xd
2051  0x48, 0x0f, 0xba, 0xe0, 0x0d,
2052  // 0x69: jne 7a <_dereference_and_exit>
2053  0x75, 0x0f,
2054  // 0x6b: jae 7a <_dereference_and_exit>
2055  0x73, 0x0d,
2056  // 0x6d: mov rdx,QWORD PTR [rsp+0x30]
2057  0x48, 0x8b, 0x54, 0x24, 0x30,
2058  // 0x72: mov r8,QWORD PTR [rsp+0x28]
2059  0x4c, 0x8b, 0x44, 0x24, 0x28,
2060 
2061  // 0x77 <_hypercall>:
2062  // 0x77: int3
2063  0xcc,
2064  // 0x78: nop
2065  0x90,
2066  // 0x79: nop
2067  0x90,
2068 
2069  // 0x7a <_dereference_and_exit>:
2070  // 0x7a: mov rcx,QWORD PTR [rsp+0x08]
2071  0x48, 0x8b, 0x4c, 0x24, 0x08,
2072  // 0x7f: mov QWORD PTR [rsp+0x08],rax
2073  0x48, 0x89, 0x44, 0x24, 0x08,
2074  // ObDereferenceObject
2075  // 0x84: movabs rax,0xfffff00000000000
2076  0x48, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff,
2077  // 0x8e: sub rsp,0x20
2078  0x48, 0x83, 0xec, 0x20,
2079  // 0x92: call rax
2080  0xff, 0xd0,
2081  // 0x94: add rsp,0x20
2082  0x48, 0x83, 0xc4, 0x20,
2083  // 0x98: mov rax,QWORD PTR[rsp+0x08]
2084  0x48, 0x8b, 0x44, 0x24, 0x08,
2085 
2086  // 0x9d <_exit>:
2087  // 0x9d: add rsp,0x10
2088  0x48, 0x83, 0xc4, 0x10,
2089  // 0xa1: pop r11
2090  0x41, 0x5b,
2091  // 0xa3: pop r10
2092  0x41, 0x5a,
2093  // 0xa5: pop r9
2094  0x41, 0x59,
2095  // 0xa7: pop r8
2096  0x41, 0x58,
2097  // 0xa9: pop rdx
2098  0x5a,
2099  // 0xaa: pop rcx
2100  0x59,
2101  // 0xab: cmp eax,0xc0000022
2102  0x3d, 0x22, 0x00, 0x00, 0xc0,
2103  // 0xb0: jne b7 <_allow>
2104  0x75, 0x05,
2105  // 0xb2: add rsp,0x8
2106  0x48, 0x83, 0xc4, 0x08,
2107  // 0xb6: ret
2108  0xc3,
2109 
2110  // 0xb7 <_allow>:
2111  // 0xb7: pop rax
2112  0x58,
2113 
2114  // 0xb8 <_irelevant>:
2115  // 0xb8: jmp a8 <_irelevant+0x5>
2116  0xe9, 0x00, 0x00, 0x00, 0x00,
2117 
2118  },
2119  .HypercallOffset = 0x77,
2120  .RelocatedCodeOffset = 0xb8,
2121  },
2122  },
2123  },
2124 
2125  {
2126  .ModuleName = u"ntoskrnl.exe",
2127  .FunctionName = "MiProcessLoaderEntry",
2128  .MinVersion = DETOUR_MIN_VERSION_ANY,
2129  .MaxVersion = DETOUR_MAX_VERSION_ANY,
2130  .Callback = IntDriverLoadHandler,
2131  .Tag = detTagModuleLoad,
2132  .Exported = FALSE,
2133  .NotCritical = FALSE,
2134  .DisableFlags = 0,
2135  .EnableFlags = DETOUR_ENABLE_ALWAYS,
2136  .Arguments = DET_ARGS_DEFAULT_WIN64,
2137  .HandlersCount = 1,
2138  .Handlers =
2139  {
2140  {
2141  .MinVersion = DETOUR_MIN_VERSION_ANY,
2142  .MaxVersion = DETOUR_MAX_VERSION_ANY,
2143  .HypercallType = hypercallTypeInt3,
2144 
2145  .CodeLength = 0x8,
2146  .Code =
2147  {
2148  // 0x00: INT3
2149  0xCC,
2150  // 0x01: NOP
2151  0x90,
2152  // 0x02: NOP
2153  0x90,
2154  // 0x03: JMP 0x8
2155  0xE9, 0x00, 0x00, 0x00, 0x00
2156  },
2157  .HypercallOffset = 0x0,
2158  .RelocatedCodeOffset = 0x3,
2159  },
2160  },
2161  },
2162 
2163  {
2164  .ModuleName = u"ntoskrnl.exe",
2165  .FunctionName = "MiUnloadSystemImage",
2166  .MinVersion = DETOUR_MIN_VERSION_ANY,
2167  .MaxVersion = DETOUR_MAX_VERSION_ANY,
2168  .Callback = IntDriverUnloadHandler,
2169  .Tag = detTagModuleUnload,
2170  .Exported = FALSE,
2171  .NotCritical = FALSE,
2172  .DisableFlags = 0,
2173  .EnableFlags = DETOUR_ENABLE_ALWAYS,
2174  .Arguments = DET_ARGS_DEFAULT_WIN64,
2175  .HandlersCount = 1,
2176  .Handlers =
2177  {
2178  {
2179  .MinVersion = DETOUR_MIN_VERSION_ANY,
2180  .MaxVersion = DETOUR_MAX_VERSION_ANY,
2181  .HypercallType = hypercallTypeInt3,
2182 
2183  .CodeLength = 0x0F,
2184  .Code =
2185  {
2186  // cmp LoadCount, 1
2187  // 0x00: CMP word ptr [rcx+0x6c], 0x01
2188  0x66, 0x83, 0x79, 0x6C, 0x01,
2189  // 0x05: JNZ 0xa
2190  0x75, 0x03,
2191  // 0x07: INT3
2192  0xCC,
2193  // 0x08: NOP
2194  0x90,
2195  // 0x09: NOP
2196  0x90,
2197  // 0x0A: JMP 0xf
2198  0xE9, 0x00, 0x00, 0x00, 0x00,
2199  },
2200  .HypercallOffset = 0x07,
2201  .RelocatedCodeOffset = 0x0A,
2202  },
2203  },
2204  },
2205 
2206  {
2207  .ModuleName = u"ntoskrnl.exe",
2208  .FunctionName = "PspInsertProcess",
2209  .MinVersion = DETOUR_MIN_VERSION_ANY,
2210  .MaxVersion = DETOUR_MAX_VERSION_ANY,
2211  .Callback = IntWinProcHandleCreate,
2212  .Tag = detTagProcCreate,
2213  .Exported = FALSE,
2214  .NotCritical = FALSE,
2215  .DisableFlags = 0,
2216  .EnableFlags = DETOUR_ENABLE_ALWAYS,
2217  .Arguments = DET_ARGS_DEFAULT_WIN64,
2218  .HandlersCount = 1,
2219  .Handlers =
2220  {
2221  {
2222  .MinVersion = DETOUR_MIN_VERSION_ANY,
2223  .MaxVersion = DETOUR_MAX_VERSION_ANY,
2224  .HypercallType = hypercallTypeInt3,
2225 
2226  .CodeLength = 0x0E,
2227  .Code =
2228  {
2229  // 0x00: INT3
2230  0xCC,
2231  // 0x01: JMP 0x9
2232  0xEB, 0x06,
2233  // If we want to block a process, we increment the RIP from
2234  // IntWinProcHandleCreate so that it points here.
2235  // 0x03: MOV eax, 0xc0000022
2236  0xB8, 0x22, 0x00, 0x00, 0xC0,
2237  // 0x08: RETN
2238  0xC3,
2239  // <call PspInsertProcess>
2240  // 0x09: JMP 0xe
2241  0xE9, 0x00, 0x00, 0x00, 0x00,
2242  },
2243  .HypercallOffset = 0x00,
2244  .RelocatedCodeOffset = 0x09,
2245  },
2246  },
2247  },
2248 
2249  {
2250  .ModuleName = u"ntoskrnl.exe",
2251  .FunctionName = "MmCleanProcessAddressSpace",
2252  .MinVersion = DETOUR_MIN_VERSION_ANY,
2253  .MaxVersion = DETOUR_MAX_VERSION_ANY,
2254  .Callback = IntWinProcHandleTerminate,
2255  .Tag = detTagProcTerminate,
2256  .Exported = FALSE,
2257  .NotCritical = FALSE,
2258  .DisableFlags = 0,
2259  .EnableFlags = DETOUR_ENABLE_ALWAYS,
2260  .Arguments = DET_ARGS_DEFAULT_WIN64,
2261  .HandlersCount = 1,
2262  .Handlers =
2263  {
2264  {
2265  .MinVersion = DETOUR_MIN_VERSION_ANY,
2266  .MaxVersion = DETOUR_MAX_VERSION_ANY,
2267  .HypercallType = hypercallTypeInt3,
2268 
2269  .CodeLength = 0x8,
2270  .Code =
2271  {
2272  // 0x00: INT3
2273  0xCC,
2274  // 0x01: NOP
2275  0x90,
2276  // 0x02: NOP
2277  0x90,
2278  // 0x03: JMP 0x8
2279  0xE9, 0x00, 0x00, 0x00, 0x00
2280  },
2281  .HypercallOffset = 0x0,
2282  .RelocatedCodeOffset = 0x3,
2283  },
2284  },
2285  },
2286 
2287  {
2288  .ModuleName = u"ntoskrnl.exe",
2289  .FunctionName = "MmCopyVirtualMemory",
2290  .MinVersion = DETOUR_MIN_VERSION_ANY,
2291  .MaxVersion = DETOUR_MAX_VERSION_ANY,
2292  .Callback = IntWinProcHandleCopyMemory,
2293  .PreCallback = IntWinProcPatchCopyMemoryDetour,
2294  .Tag = detTagProcInject,
2295  .Exported = FALSE,
2296  .NotCritical = FALSE,
2297  .DisableFlags = 0,
2298  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION,
2299  .Arguments = DET_ARGS_DEFAULT_WIN64,
2300  .HandlersCount = 1,
2301  .Handlers =
2302  {
2303  {
2304  .MinVersion = DETOUR_MIN_VERSION_ANY,
2305  .MaxVersion = DETOUR_MAX_VERSION_ANY,
2306  .HypercallType = hypercallTypeInt3,
2307 
2308  .CodeLength = 0x53,
2309  .Code =
2310  {
2311  // 0x00: CMP rcx, r8
2312  0x4c, 0x39, 0xc1,
2313  // 0x03: JZ 0x4e
2314  0x74, 0x49,
2315  // 0x05: PUSH rax
2316  0x50,
2317  // 0x06: PUSH rbx
2318  0x53,
2319  // Is this a read or a write
2320  // 0x07: MOV rax, cr3
2321  0x0f, 0x20, 0xd8,
2322  // 0x0A: CMP rax, qword ptr [r8+0x0]
2323  0x49, 0x3b, 0x80, 0x00, 0x00, 0x00, 0x00,
2324  // 0x11: JZ 0x2a
2325  0x74, 0x17,
2326  // _is_write:
2327  // 0x13: CMP byte ptr [r8+0x0], 0x2a
2328  0x41, 0x80, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x2a,
2329  // 0x1B: JNZ 0x4c
2330  0x75, 0x2f,
2331  // 0x1D: BT dword ptr [r8+0x0], 0x09
2332  0x41, 0x0f, 0xba, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x09,
2333  // 0x26: JNC 0x4c
2334  0x73, 0x24,
2335  // 0x28: JMP 0x3d
2336  0xeb, 0x13,
2337  // _is_read:
2338  // 0x2A: CMP byte ptr [rcx+0x0], 0x2a
2339  0x80, 0xb9, 0x00, 0x00, 0x00, 0x00, 0x2a,
2340  // 0x31: JNZ 0x4c
2341  0x75, 0x19,
2342  // 0x33: BT dword ptr [rcx+0x0], 0x0a
2343  0x0f, 0xba, 0xa1, 0x00, 0x00, 0x00, 0x00, 0x0a,
2344  // 0x3B: JNC 0x4c
2345  0x73, 0x0f,
2346  // _do_int3:
2347  // 0x3D: INT3
2348  0xcc,
2349  // 0x3E: NOP
2350  0x90,
2351  // 0x3F: NOP
2352  0x90,
2353  // 0x40: CMP eax, 0xc0000022
2354  0x3d, 0x22, 0x00, 0x00, 0xc0,
2355  // 0x45: JNZ 0x4c
2356  0x75, 0x05,
2357  // 0x47: ADD rsp, 0x10
2358  0x48, 0x83, 0xc4, 0x10,
2359  // 0x4B: RETN
2360  0xc3,
2361  // _continue_function:
2362  // 0x4C: POP rbx
2363  0x5b,
2364  // 0x4D: POP rax
2365  0x58,
2366  // _skip_detour:
2367  // 0x4E: JMP 0x53
2368  0xe9, 0x00, 0x00, 0x00, 0x00,
2369  },
2370  .HypercallOffset = 0x3d,
2371  .RelocatedCodeOffset = 0x4e,
2372  },
2373  },
2374  },
2375 
2376  {
2377  .ModuleName = u"ntoskrnl.exe",
2378  .FunctionName = "NtQueueApcThreadEx",
2379  .MinVersion = DETOUR_MIN_VERSION_ANY,
2380  .MaxVersion = DETOUR_MAX_VERSION_ANY,
2381  .Callback = IntWinThrHandleQueueApc,
2382  .PreCallback = IntWinThrPrepareApcHandler,
2383  .Tag = detTagProcQueueApc,
2384  .Exported = FALSE,
2385  .NotCritical = FALSE,
2386  .DisableFlags = 0,
2387  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION,
2388  .Arguments = DET_ARGS_DEFAULT_WIN64,
2389  .HandlersCount = 1,
2390  .Handlers =
2391  {
2392  {
2393  .MinVersion = DETOUR_MIN_VERSION_ANY,
2394  .MaxVersion = DETOUR_MAX_VERSION_ANY,
2395  .HypercallType = hypercallTypeInt3,
2396 
2397  .CodeLength = 0xcf,
2398  .Code =
2399  {
2400  // 0x00: PUSH rax
2401  0x50,
2402  // 0x01: PUSH rcx
2403  0x51,
2404  // 0x02: PUSH rdx
2405  0x52,
2406  // 0x03: PUSH r8
2407  0x41, 0x50,
2408  // 0x05: PUSH r9
2409  0x41, 0x51,
2410  // 0x07: PUSH r10
2411  0x41, 0x52,
2412  // 0x09: PUSH r11
2413  0x41, 0x53,
2414  // 0x0B: SUB rsp, 0x20
2415  0x48, 0x83, 0xec, 0x20,
2416  // 0x0F: MOV rax, 0xfffff80000000000
2417  0x48, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff,
2418  // PsThreadType
2419  // 0x19: MOV r8, qword ptr [rax]
2420  0x4c, 0x8b, 0x00,
2421  // 0x1C: MOV r9b, 0x01
2422  0x41, 0xb1, 0x01,
2423  // 0x1F: MOV edx, 0x00000010
2424  0xba, 0x10, 0x00, 0x00, 0x00,
2425  // 0x24: LEA rax, [rsp+0x8]
2426  0x48, 0x8d, 0x44, 0x24, 0x08,
2427  // 0x29: MOV qword ptr [rsp+0x8], 0x00000000
2428  0x48, 0xc7, 0x44, 0x24, 0x08, 0x00, 0x00, 0x00, 0x00,
2429  // 0x32: PUSH 0x00
2430  0x6a, 0x00,
2431  // 0x34: PUSH rax
2432  0x50,
2433  // 0x35: SUB rsp, 0x20
2434  0x48, 0x83, 0xec, 0x20,
2435  // 0x39: MOV rax, 0xfffff80000000000
2436  0x48, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff,
2437  // ObReferenceObject
2438  // 0x43: CALL rax
2439  0xff, 0xd0,
2440  // 0x45: ADD rsp, 0x30
2441  0x48, 0x83, 0xc4, 0x30,
2442  // 0x49: TEST eax, eax
2443  0x85, 0xc0,
2444  // 0x4B: JNZ 0xaf
2445  0x75, 0x62,
2446  // 0x4D: MOV rcx, qword ptr [rsp+0x8]
2447  0x48, 0x8b, 0x4c, 0x24, 0x08,
2448  // Victim thread obj
2449  // 0x52: MOV r9, qword ptr [rsp+0x30]
2450  0x4c, 0x8b, 0x4c, 0x24, 0x30,
2451  // 0x57: MOV r8, qword ptr [rsp+0x38]
2452  0x4c, 0x8b, 0x44, 0x24, 0x38,
2453  // 0x5C: MOV rax, qword ptr [rcx+0x150]
2454  0x48, 0x8b, 0x81, 0x50, 0x01, 0x00, 0x00,
2455  // AttachedProcess
2456  // 0x63: TEST rax, rax
2457  0x48, 0x85, 0xc0,
2458  // 0x66: JNZ 0x6f
2459  0x75, 0x07,
2460  // 0x68: MOV rax, qword ptr [rcx+0x150]
2461  0x48, 0x8b, 0x81, 0x50, 0x01, 0x00, 0x00,
2462  // Process
2463  // _attached:
2464  // 0x6F: MOV rax, qword ptr [rax+0x150]
2465  0x48, 0x8b, 0x80, 0x50, 0x01, 0x00, 0x00,
2466  // ImageFileName
2467  // 0x76: CMP al, 0x2a
2468  0x3c, 0x2a,
2469  // Check for '*' in process name
2470  // 0x78: BT rax, 0x0c
2471  0x48, 0x0f, 0xba, 0xe0, 0x0c,
2472  // Check QueueApc protection flag
2473  // 0x7D: MOV rax, 0x00000000
2474  0x48, 0xc7, 0xc0, 0x00, 0x00, 0x00, 0x00,
2475  // 0x84: JNZ 0x94
2476  0x75, 0x0e,
2477  // 0x86: JNC 0x94
2478  0x73, 0x0c,
2479  // 0x88: MOV rax, qword ptr gs:[0x188]
2480  0x65, 0x48, 0x8b, 0x04, 0x25, 0x88, 0x01, 0x00, 0x00,
2481  // 0x91: INT3
2482  0xcc,
2483  // 0x92: NOP
2484  0x90,
2485  // 0x93: NOP
2486  0x90,
2487  // _skip_exit:
2488  // 0x94: MOV qword ptr [rsp+0x10], rax
2489  0x48, 0x89, 0x44, 0x24, 0x10,
2490  // 0x99: MOV rcx, qword ptr [rsp+0x8]
2491  0x48, 0x8b, 0x4c, 0x24, 0x08,
2492  // 0x9E: MOV rax, 0xfffff80000000000
2493  0x48, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff,
2494  // ObDereference
2495  // 0xA8: CALL rax
2496  0xff, 0xd0,
2497  // 0xAA: MOV rax, qword ptr [rsp+0x10]
2498  0x48, 0x8b, 0x44, 0x24, 0x10,
2499  // _cleanup_and_exit:
2500  // 0xAF: ADD rsp, 0x20
2501  0x48, 0x83, 0xc4, 0x20,
2502  // 0xB3: POP r11
2503  0x41, 0x5b,
2504  // 0xB5: POP r10
2505  0x41, 0x5a,
2506  // 0xB7: POP r9
2507  0x41, 0x59,
2508  // 0xB9: POP r8
2509  0x41, 0x58,
2510  // 0xBB: POP rdx
2511  0x5a,
2512  // 0xBC: POP rcx
2513  0x59,
2514  // 0xBD: CMP eax, 0xc0000022
2515  0x3d, 0x22, 0x00, 0x00, 0xc0,
2516  // 0xC2: JNZ 0xc9
2517  0x75, 0x05,
2518  // 0xC4: ADD rsp, 0x08
2519  0x48, 0x83, 0xc4, 0x08,
2520  // 0xC8: RETN
2521  0xc3,
2522  // _skip:
2523  // 0xC9: POP rax
2524  0x58,
2525  // 0xCA: JMP 0xcf
2526  0xe9, 0x00, 0x00, 0x00, 0x00,
2527  },
2528  .HypercallOffset = 0x91,
2529  .RelocatedCodeOffset = 0xca,
2530  },
2531  },
2532  },
2533 
2534  {
2535  .ModuleName = u"ntoskrnl.exe",
2536  .FunctionName = "PspSetContextThreadInternal",
2537  .MinVersion = DETOUR_MIN_VERSION_ANY,
2538  .MaxVersion = DETOUR_MAX_VERSION_ANY,
2539  .Callback = IntWinThrHandleThreadHijack,
2540  .PreCallback = IntWinThrPatchThreadHijackHandler,
2541  .Tag = detTagProcThrHijack,
2542  .Exported = FALSE,
2543  .NotCritical = FALSE,
2544  .DisableFlags = 0,
2545  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION,
2546  .Arguments = DET_ARGS_DEFAULT_WIN64,
2547  .HandlersCount = 1,
2548  .Handlers =
2549  {
2550  {
2551  .MinVersion = DETOUR_MIN_VERSION_ANY,
2552  .MaxVersion = DETOUR_MAX_VERSION_ANY,
2553  .HypercallType = hypercallTypeInt3,
2554 
2555  .CodeLength = 0x49,
2556  .Code =
2557  {
2558  // 0x00: PUSH rax
2559  0x50,
2560  // 0x01: MOV rax, qword ptr [rcx+0x150]
2561  0x48, 0x8b, 0x81, 0x50, 0x01, 0x00, 0x00,
2562  // AttachedProcess
2563  // 0x08: TEST rax, rax
2564  0x48, 0x85, 0xc0,
2565  // 0x0B: JNZ 0x14
2566  0x75, 0x07,
2567  // 0x0D: MOV rax, qword ptr [rcx+0x150]
2568  0x48, 0x8b, 0x81, 0x50, 0x01, 0x00, 0x00,
2569  // Process
2570  // _attached:
2571  // 0x14: MOV rax, qword ptr [rax+0x150]
2572  0x48, 0x8b, 0x80, 0x50, 0x01, 0x00, 0x00,
2573  // ImageFileName
2574  // 0x1B: CMP al, 0x2a
2575  0x3c, 0x2a,
2576  // Check for "*" in process name
2577  // 0x1D: BT rax, 0x0b
2578  0x48, 0x0f, 0xba, 0xe0, 0x0b,
2579  // ThreadCtx protection flag
2580  // 0x22: JNZ 0x43
2581  0x75, 0x1f,
2582  // 0x24: JNC 0x43
2583  0x73, 0x1d,
2584  // 0x26: MOV rax, qword ptr gs:[0x188]
2585  0x65, 0x48, 0x8b, 0x04, 0x25, 0x88, 0x01, 0x00, 0x00,
2586  // 0x2F: CMP rax, rcx
2587  0x48, 0x39, 0xc8,
2588  // 0x32: JZ 0x43
2589  0x74, 0x0f,
2590  // 0x34: INT3
2591  0xcc,
2592  // 0x35: NOP
2593  0x90,
2594  // 0x36: NOP
2595  0x90,
2596  // 0x37: CMP eax, 0xc0000022
2597  0x3d, 0x22, 0x00, 0x00, 0xc0,
2598  // 0x3C: JNZ 0x43
2599  0x75, 0x05,
2600  // 0x3E: ADD rsp, 0x08
2601  0x48, 0x83, 0xc4, 0x08,
2602  // 0x42: RETN
2603  0xc3,
2604  // <skip>:
2605  // 0x43: POP rax
2606  0x58,
2607  // 0x44: JMP 0x49
2608  0xe9, 0x00, 0x00, 0x00, 0x00,
2609  },
2610  .HypercallOffset = 0x34,
2611  .RelocatedCodeOffset = 0x44,
2612  },
2613  },
2614  },
2615 
2616  // This has the same functionality as PspSetContextThreadInternal, but for a WOW64 Process setting context on a
2617  // WOW64 victim, PspSetContextThreadInternal is saved only when XSAVE_STATE is set.
2618  // This function has the same PspWow64SetContextThreadOnAmd64 for NtBuildNumber < 10240, PspWowSetContextThread
2619  // for NtBuildNumber == 10240 and PspWow64SetContextThread for NtBuildNumber > 10240
2620  {
2621  .ModuleName = u"ntoskrnl.exe",
2622  .FunctionName = "PspWow64SetContextThread",
2623  .MinVersion = DETOUR_MIN_VERSION_ANY,
2624  .MaxVersion = DETOUR_MAX_VERSION_ANY,
2625  .Callback = IntWinThrHandleThreadHijack,
2626  .PreCallback = IntWinThrPatchThreadHijackHandler,
2627  .Tag = detTagProcThrHijackWow64,
2628  .Exported = FALSE,
2629  .NotCritical = FALSE,
2630  .DisableFlags = 0,
2631  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION,
2632  .Arguments = DET_ARGS_DEFAULT_WIN64,
2633  .HandlersCount = 1,
2634  .Handlers =
2635  {
2636  {
2637  .MinVersion = DETOUR_MIN_VERSION_ANY,
2638  .MaxVersion = DETOUR_MAX_VERSION_ANY,
2639  .HypercallType = hypercallTypeInt3,
2640 
2641  .CodeLength = 0x49,
2642  .Code =
2643  {
2644  // 0x00: PUSH rax
2645  0x50,
2646  // 0x01: MOV rax, qword ptr [rcx+0x150]
2647  0x48, 0x8b, 0x81, 0x50, 0x01, 0x00, 0x00,
2648  // AttachedProcess
2649  // 0x08: TEST rax, rax
2650  0x48, 0x85, 0xc0,
2651  // 0x0B: JNZ 0x14
2652  0x75, 0x07,
2653  // 0x0D: MOV rax, qword ptr [rcx+0x150]
2654  0x48, 0x8b, 0x81, 0x50, 0x01, 0x00, 0x00,
2655  // Process
2656  // _attached
2657  // 0x14: MOV rax, qword ptr [rax+0x150]
2658  0x48, 0x8b, 0x80, 0x50, 0x01, 0x00, 0x00,
2659  // ImageFileName
2660  // 0x1B: CMP al, 0x2a
2661  0x3c, 0x2a,
2662  // 0x1D: BT rax, 0x0b
2663  0x48, 0x0f, 0xba, 0xe0, 0x0b,
2664  // ThreadCtx protection flag
2665  // 0x22: JNZ 0x43
2666  0x75, 0x1f,
2667  // 0x24: JNC 0x43
2668  0x73, 0x1d,
2669  // 0x26: MOV rax, qword ptr gs:[0x188]
2670  0x65, 0x48, 0x8b, 0x04, 0x25, 0x88, 0x01, 0x00, 0x00,
2671  // 0x2F: CMP rax, rcx
2672  0x48, 0x39, 0xc8,
2673  // 0x32: JZ 0x43
2674  0x74, 0x0f,
2675  // 0x34: INT3
2676  0xcc,
2677  // 0x35: NOP
2678  0x90,
2679  // 0x36: NOP
2680  0x90,
2681  // 0x37: CMP eax, 0xc0000022
2682  0x3d, 0x22, 0x00, 0x00, 0xc0,
2683  // 0x3C: JNZ 0x43
2684  0x75, 0x05,
2685  // 0x3E: ADD rsp, 0x08
2686  0x48, 0x83, 0xc4, 0x08,
2687  // 0x42: RETN
2688  0xc3,
2689  // _skip:
2690  // 0x43: POP rax
2691  0x58,
2692  // 0x44: JMP 0x49
2693  0xe9, 0x00, 0x00, 0x00, 0x00,
2694  },
2695  .HypercallOffset = 0x34,
2696  .RelocatedCodeOffset = 0x44,
2697  },
2698  },
2699  },
2700 
2701  {
2702  .ModuleName = u"ntoskrnl.exe",
2703  .FunctionName = "KiDispatchException",
2704  .MinVersion = DETOUR_MIN_VERSION_ANY,
2705  .MaxVersion = DETOUR_MAX_VERSION_ANY,
2706  .Callback = IntWinHandleException,
2707  .Tag = detTagException,
2708  .Exported = FALSE,
2709  .NotCritical = FALSE,
2710  .DisableFlags = 0,
2711  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION | INTRO_OPT_EVENT_PROCESS_CRASH,
2712  .Arguments = DET_ARGS_DEFAULT_WIN64,
2713  .HandlersCount = 1,
2714  .Handlers =
2715  {
2716  {
2717  .MinVersion = DETOUR_MIN_VERSION_ANY,
2718  .MaxVersion = DETOUR_MAX_VERSION_ANY,
2719  .HypercallType = hypercallTypeInt3,
2720 
2721  .CodeLength = 0x0E,
2722  .Code =
2723  {
2724  // 0x00: CMP r9d, 0x00
2725  0x41, 0x83, 0xf9, 0x00,
2726  // 0x04: JZ 0x9
2727  0x74, 0x03,
2728  // 0x06: INT3
2729  0xCC,
2730  // 0x07: NOP
2731  0x90,
2732  // 0x08: NOP
2733  0x90,
2734  // 0x09: JMP 0xe
2735  0xE9, 0x00, 0x00, 0x00, 0x00
2736  },
2737  .HypercallOffset = 0x06,
2738  .RelocatedCodeOffset = 0x09,
2739  },
2740  },
2741  },
2742 
2743  {
2744  .ModuleName = u"ntoskrnl.exe",
2745  .FunctionName = "MiInsertVad",
2746  .MinVersion = 10240,
2747  .MaxVersion = DETOUR_MAX_VERSION_ANY,
2748  .Callback = IntWinVadHandleInsert,
2749  .PreCallback = IntWinVadPatchInsert,
2750  .Tag = detTagVadInsert,
2751  .Exported = FALSE,
2752  .NotCritical = FALSE,
2753  .DisableFlags = 0,
2754  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION | INTRO_OPT_ENABLE_MISC_EVENTS,
2755  .Arguments = DET_ARGS_DEFAULT_WIN64,
2756  .HandlersCount = 2,
2757  .Handlers =
2758  {
2759  {
2760  .MinVersion = 10240,
2761  .MaxVersion = 17763,
2762  .HypercallType = hypercallTypeInt3,
2763 
2764  .CodeLength = 0x1f,
2765  .Code =
2766  {
2767  // 0x00: TEST byte ptr [rcx+0x30], 0x10
2768  0xF6, 0x41, 0x30, 0x10,
2769  // 0x04: JZ 0x1a
2770  0x74, 0x14,
2771  // 0x06: CMP byte ptr [rdx+0x448], 0x2a
2772  0x80, 0xBA, 0x48, 0x04, 0x00, 0x00, 0x2A,
2773  // 0x0D: BT dword ptr [rdx+0x448], 0x08
2774  0x0f, 0xba, 0xa2, 0x48, 0x04, 0x00, 0x00, 0x08,
2775  // 0x15: JNZ 0x1a
2776  0x75, 0x03,
2777  // 0x17: JNC 0x1a
2778  0x73, 0x01,
2779  // 0x19: INT3
2780  0xCC,
2781  // 0x1A: JMP 0x1f
2782  0xE9, 0x00, 0x00, 0x00, 0x00,
2783  },
2784  .HypercallOffset = 0x19,
2785  .RelocatedCodeOffset = 0x1a,
2786  },
2787 
2788  {
2789  .MinVersion = 18362,
2790  .MaxVersion = DETOUR_MAX_VERSION_ANY,
2791  .HypercallType = hypercallTypeInt3,
2792 
2793  .CodeLength = 0x1f,
2794  .Code =
2795  {
2796  // 0x00: TEST byte ptr [rcx+0x31], 0x01
2797  0xF6, 0x41, 0x31, 0x01,
2798  // 0x04: JZ 0x1a
2799  0x74, 0x14,
2800  // 0x06: CMP byte ptr [rdx+0x448], 0x2a
2801  0x80, 0xBA, 0x48, 0x04, 0x00, 0x00, 0x2A,
2802  // 0x0D: BT dword ptr [rdx+0x448], 0x08
2803  0x0f, 0xba, 0xa2, 0x48, 0x04, 0x00, 0x00, 0x08,
2804  // 0x15: JNZ 0x1a
2805  0x75, 0x03,
2806  // 0x17: JNC 0x1a
2807  0x73, 0x01,
2808  // 0x19: INT3
2809  0xCC,
2810  // 0x1A: JMP 0x1f
2811  0xE9, 0x00, 0x00, 0x00, 0x00,
2812  },
2813  .HypercallOffset = 0x19,
2814  .RelocatedCodeOffset = 0x1a,
2815  },
2816  },
2817  },
2818 
2819 
2820  {
2821  .ModuleName = u"ntoskrnl.exe",
2822  .FunctionName = "MiInsertPrivateVad",
2823  .MinVersion = DETOUR_MIN_VERSION_ANY,
2824  .MaxVersion = 9600,
2825  .Callback = IntWinVadHandleInsertPrivate,
2826  .PreCallback = IntWinVadPatchInsertPrivate,
2827  .Tag = detTagVadInsertPriv,
2828  .Exported = FALSE,
2829  .NotCritical = FALSE,
2830  .DisableFlags = 0,
2831  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION | INTRO_OPT_ENABLE_MISC_EVENTS,
2832  .Arguments = DET_ARGS_DEFAULT_WIN64,
2833  .HandlersCount = 3,
2834  .Handlers =
2835  {
2836  {
2837  .MinVersion = 7600,
2838  .MaxVersion = 7602,
2839  .HypercallType = hypercallTypeInt3,
2840 
2841  .CodeLength = 0x3e,
2842  .Code =
2843  {
2844  // 0x00: TEST byte ptr [rcx+0x2f], 0x02
2845  0xF6, 0x41, 0x2F, 0x02,
2846  // 0x04: JZ 0x39
2847  0x74, 0x33,
2848  // 0x06: PUSH rax
2849  0x50,
2850  // 0x07: PUSH rcx
2851  0x51,
2852  // 0x08: MOV rcx, qword ptr gs:[0x188]
2853  0x65, 0x48, 0x8B, 0x0C, 0x25, 0x88, 0x01, 0x00, 0x00,
2854  // 0x11: MOV rax, qword ptr [rcx+0x70]
2855  0x48, 0x8B, 0x81, 0x70, 0x00, 0x00, 0x00,
2856  // 0x18: TEST eax, eax
2857  0x85, 0xC0,
2858  // 0x1A: JNZ 0x23
2859  0x75, 0x07,
2860  // 0x1C: MOV rax, qword ptr [rcx+0x210]
2861  0x48, 0x8B, 0x81, 0x10, 0x02, 0x00, 0x00,
2862  // 0x23: CMP byte ptr [rax+0x2e0], 0x2a
2863  0x80, 0xB8, 0xE0, 0x02, 0x00, 0x00, 0x2A,
2864  // 0x2A: BT dword ptr [rax+0x2e0], 0x08
2865  0x0f, 0xba, 0xa0, 0xe0, 0x02, 0x00, 0x00, 0x08,
2866  // 0x32: POP rcx
2867  0x59,
2868  // 0x33: POP rax
2869  0x58,
2870  // 0x34: JNZ 0x39
2871  0x75, 0x03,
2872  // 0x36: JNC 0x39
2873  0x73, 0x01,
2874  // 0x38: INT3
2875  0xCC,
2876  // 0x39: JMP 0x3e
2877  0xE9, 0x00, 0x00, 0x00, 0x00
2878  },
2879  .HypercallOffset = 0x38,
2880  .RelocatedCodeOffset = 0x39,
2881  },
2882 
2883  {
2884  .MinVersion = 9200,
2885  .MaxVersion = 9200,
2886  .HypercallType = hypercallTypeInt3,
2887 
2888  .CodeLength = 0x3e,
2889  .Code =
2890  {
2891  // 0x00: TEST byte ptr [rcx+0x28], 0x10
2892  0xF6, 0x41, 0x28, 0x10,
2893  // 0x04: JZ 0x39
2894  0x74, 0x33,
2895  // 0x06: PUSH rax
2896  0x50,
2897  // 0x07: PUSH rcx
2898  0x51,
2899  // 0x08: MOV rcx, qword ptr gs:[0x188]
2900  0x65, 0x48, 0x8B, 0x0C, 0x25, 0x88, 0x01, 0x00, 0x00,
2901  // 0x11: MOV rax, qword ptr [rcx+0xb8]
2902  0x48, 0x8B, 0x81, 0xB8, 0x00, 0x00, 0x00,
2903  // 0x18: TEST eax, eax
2904  0x85, 0xC0,
2905  // 0x1A: JNZ 0x23
2906  0x75, 0x07,
2907  // 0x1C: MOV rax, qword ptr [rcx+0x220]
2908  0x48, 0x8B, 0x81, 0x20, 0x02, 0x00, 0x00,
2909  // 0x23: CMP byte ptr [rax+0x438], 0x2a
2910  0x80, 0xB8, 0x38, 0x04, 0x00, 0x00, 0x2A,
2911  // 0x2A: BT dword ptr [rax+0x438], 0x08
2912  0x0f, 0xba, 0xa0, 0x38, 0x04, 0x00, 0x00, 0x08,
2913  // 0x32: POP rcx
2914  0x59,
2915  // 0x33: POP rax
2916  0x58,
2917  // 0x34: JNZ 0x39
2918  0x75, 0x03,
2919  // 0x36: JNC 0x39
2920  0x73, 0x01,
2921  // 0x38: INT3
2922  0xCC,
2923  // 0x39: JMP 0x3e
2924  0xE9, 0x00, 0x00, 0x00, 0x00
2925  },
2926  .HypercallOffset = 0x38,
2927  .RelocatedCodeOffset = 0x39,
2928  },
2929 
2930  {
2931  .MinVersion = 9600,
2932  .MaxVersion = 9600,
2933  .HypercallType = hypercallTypeInt3,
2934 
2935  .CodeLength = 0x21,
2936  .Code =
2937  {
2938  // 0x00: TEST byte ptr [rcx+0x30], 0x10
2939  0xF6, 0x41, 0x30, 0x10,
2940  // 0x04: JZ 0x1b
2941  0x74, 0x15,
2942  // 0x06: CMP byte ptr [r8+0x438], 0x2a
2943  0x41, 0x80, 0xB8, 0x38, 0x04, 0x00, 0x00, 0x2A,
2944  // 0x0E: BT dword ptr [r8+0x438], 0x08
2945  0x41, 0x0f, 0xba, 0xa0, 0x38, 0x04, 0x00, 0x00, 0x08,
2946  // 0x17: JNZ 0x1c
2947  0x75, 0x03,
2948  // 0x19: JNC 0x1c
2949  0x73, 0x01,
2950  // 0x1B: INT3
2951  0xCC,
2952  // 0x1C: JMP 0x21
2953  0xE9, 0x00, 0x00, 0x00, 0x00,
2954  },
2955  .HypercallOffset = 0x1b,
2956  .RelocatedCodeOffset = 0x1c,
2957  },
2958  },
2959  },
2960 
2961  {
2962  .ModuleName = u"ntoskrnl.exe",
2963  .FunctionName = "MiInsertPrivateVad",
2964  .MinVersion = 17763,
2965  .MaxVersion = 18362,
2966  .Callback = IntWinVadHandleInsertPrivate,
2967  .PreCallback = IntWinVadPatchInsertPrivate,
2968  .Tag = detTagVadInsertPriv,
2969  .Exported = FALSE,
2970  .NotCritical = FALSE,
2971  .DisableFlags = 0,
2972  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION | INTRO_OPT_ENABLE_MISC_EVENTS,
2973  .Arguments = DET_ARGS_DEFAULT_WIN64,
2974  .HandlersCount = 2,
2975  .Handlers = {
2976  // Windows 10 RS5 17763
2977  {
2978  .MinVersion = 17763,
2979  .MaxVersion = 17763,
2980  .HypercallType = hypercallTypeInt3,
2981 
2982  .CodeLength = 0x3e,
2983  .Code =
2984  {
2985  // 0x00: TEST byte ptr [rcx+0x30], 0x10
2986  0xF6, 0x41, 0x30, 0x10,
2987  // 0x04: JZ 0x39
2988  0x74, 0x33,
2989  // 0x06: PUSH rax
2990  0x50,
2991  // 0x07: PUSH rcx
2992  0x51,
2993  // 0x08: MOV rcx, qword ptr gs:[0x188]
2994  0x65, 0x48, 0x8B, 0x0C, 0x25, 0x88, 0x01, 0x00, 0x00,
2995  // 0x11: MOV rax, qword ptr [rcx+0xb8]
2996  0x48, 0x8B, 0x81, 0xB8, 0x00, 0x00, 0x00,
2997  // 0x18: TEST eax, eax
2998  0x85, 0xC0,
2999  // 0x1A: JNZ 0x23
3000  0x75, 0x07,
3001  // 0x1C: MOV rax, qword ptr [rcx+0x220]
3002  0x48, 0x8B, 0x81, 0x20, 0x02, 0x00, 0x00,
3003  // 0x23: CMP byte ptr [rax+0x450], 0x2a
3004  0x80, 0xB8, 0x50, 0x04, 0x00, 0x00, 0x2A,
3005  // 0x2A: BT dword ptr [rax+0x450], 0x08
3006  0x0f, 0xba, 0xa0, 0x50, 0x04, 0x00, 0x00, 0x08,
3007  // 0x32: POP rcx
3008  0x59,
3009  // 0x33: POP rax
3010  0x58,
3011  // 0x34: JNZ 0x39
3012  0x75, 0x03,
3013  // 0x36: JNC 0x39
3014  0x73, 0x01,
3015  // 0x38: INT3
3016  0xCC,
3017  // 0x39: JMP 0x3e
3018  0xE9, 0x00, 0x00, 0x00, 0x00
3019  },
3020  .HypercallOffset = 0x38,
3021  .RelocatedCodeOffset = 0x39,
3022  },
3023  // Windows 10 19H1
3024  {
3025  .MinVersion = 18362,
3026  .MaxVersion = 18362,
3027  .HypercallType = hypercallTypeInt3,
3028 
3029  .CodeLength = 0x3e,
3030  .Code =
3031  {
3032  // 0x00: TEST byte ptr [rcx+0x31], 0x01
3033  0xf6, 0x41, 0x31, 0x01,
3034  // 0x04: JZ 0x39
3035  0x74, 0x33,
3036  // 0x06: PUSH rax
3037  0x50,
3038  // 0x07: PUSH rcx
3039  0x51,
3040  // 0x08: MOV rcx, qword ptr gs:[0x188]
3041  0x65, 0x48, 0x8B, 0x0C, 0x25, 0x88, 0x01, 0x00, 0x00,
3042  // 0x11: MOV rax, qword ptr [rcx+0xb8]
3043  0x48, 0x8B, 0x81, 0xB8, 0x00, 0x00, 0x00,
3044  // 0x18: TEST eax, eax
3045  0x85, 0xC0,
3046  // 0x1A: JNZ 0x23
3047  0x75, 0x07,
3048  // 0x1C: MOV rax, qword ptr [rcx+0x220]
3049  0x48, 0x8B, 0x81, 0x20, 0x02, 0x00, 0x00,
3050  // 0x23: CMP byte ptr [rax+0x450], 0x2a
3051  0x80, 0xB8, 0x50, 0x04, 0x00, 0x00, 0x2A,
3052  // 0x2A: BT dword ptr [rax+0x450], 0x08
3053  0x0f, 0xba, 0xa0, 0x50, 0x04, 0x00, 0x00, 0x08,
3054  // 0x32: POP rcx
3055  0x59,
3056  // 0x33: POP rax
3057  0x58,
3058  // 0x34: JNZ 0x39
3059  0x75, 0x03,
3060  // 0x36: JNC 0x39
3061  0x73, 0x01,
3062  // 0x38: INT3
3063  0xCC,
3064  // 0x39: JMP 0x3e
3065  0xE9, 0x00, 0x00, 0x00, 0x00
3066  },
3067  .HypercallOffset = 0x38,
3068  .RelocatedCodeOffset = 0x39,
3069  },
3070  },
3071  },
3072 
3073  {
3074  .ModuleName = u"ntoskrnl.exe",
3075  .FunctionName = "MiGetWsAndInsertVad",
3076  .MinVersion = DETOUR_MIN_VERSION_ANY,
3077  .MaxVersion = 9600,
3078  .Callback = IntWinVadHandleInsertMap,
3079  .PreCallback = IntWinVadPatchInsertMap,
3080  .Tag = detTagVadInsertMap,
3081  .Exported = FALSE,
3082  .NotCritical = FALSE,
3083  .DisableFlags = 0,
3084  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION | INTRO_OPT_ENABLE_MISC_EVENTS,
3085  .Arguments = DET_ARGS_DEFAULT_WIN64,
3086  .HandlersCount = 3,
3087  .Handlers =
3088  {
3089  {
3090  .MinVersion = 7600,
3091  .MaxVersion = 7602,
3092  .HypercallType = hypercallTypeInt3,
3093 
3094  .CodeLength = 0x3e,
3095  .Code =
3096  {
3097  // 0x00: TEST byte ptr [rcx+0x2f], 0x02
3098  0xF6, 0x41, 0x2F, 0x02,
3099  // 0x04: JZ 0x39
3100  0x74, 0x33,
3101  // 0x06: PUSH rax
3102  0x50,
3103  // 0x07: PUSH rcx
3104  0x51,
3105  // 0x08: MOV rcx, qword ptr gs:[0x188]
3106  0x65, 0x48, 0x8B, 0x0C, 0x25, 0x88, 0x01, 0x00, 0x00,
3107  // 0x11: MOV rax, qword ptr [rcx+0x70]
3108  0x48, 0x8B, 0x81, 0x70, 0x00, 0x00, 0x00,
3109  // 0x18: TEST eax, eax
3110  0x85, 0xC0,
3111  // 0x1A: JNZ 0x23
3112  0x75, 0x07,
3113  // 0x1C: MOV rax, qword ptr [rcx+0x210]
3114  0x48, 0x8B, 0x81, 0x10, 0x02, 0x00, 0x00,
3115  // 0x23: CMP byte ptr [rax+0x2e0], 0x2a
3116  0x80, 0xB8, 0xE0, 0x02, 0x00, 0x00, 0x2A,
3117  // 0x2A: BT dword ptr [rax+0x2e0], 0x08
3118  0x0f, 0xba, 0xa0, 0xe0, 0x02, 0x00, 0x00, 0x08,
3119  // 0x32: POP rcx
3120  0x59,
3121  // 0x33: POP rax
3122  0x58,
3123  // 0x34: JNZ 0x39
3124  0x75, 0x03,
3125  // 0x36: JNC 0x39
3126  0x73, 0x01,
3127  // 0x38: INT3
3128  0xCC,
3129  // 0x39: JMP 0x3e
3130  0xE9, 0x00, 0x00, 0x00, 0x00
3131  },
3132  .HypercallOffset = 0x38,
3133  .RelocatedCodeOffset = 0x39,
3134  },
3135 
3136  {
3137  .MinVersion = 9200,
3138  .MaxVersion = 9200,
3139  .HypercallType = hypercallTypeInt3,
3140 
3141  .CodeLength = 0x3e,
3142  .Code =
3143  {
3144  // 0x00: TEST byte ptr [rcx+0x28], 0x10
3145  0xF6, 0x41, 0x28, 0x10,
3146  // 0x04: JZ 0x39
3147  0x74, 0x33,
3148  // 0x06: PUSH rax
3149  0x50,
3150  // 0x07: PUSH rcx
3151  0x51,
3152  // 0x08: MOV rcx, qword ptr gs:[0x188]
3153  0x65, 0x48, 0x8B, 0x0C, 0x25, 0x88, 0x01, 0x00, 0x00,
3154  // 0x11: MOV rax, qword ptr [rcx+0xb8]
3155  0x48, 0x8B, 0x81, 0xB8, 0x00, 0x00, 0x00,
3156  // 0x18: TEST eax, eax
3157  0x85, 0xC0,
3158  // 0x1A: JNZ 0x23
3159  0x75, 0x07,
3160  // 0x1C: MOV rax, qword ptr [rcx+0x220]
3161  0x48, 0x8B, 0x81, 0x20, 0x02, 0x00, 0x00,
3162  // 0x23: CMP byte ptr [rax+0x438], 0x2a
3163  0x80, 0xB8, 0x38, 0x04, 0x00, 0x00, 0x2A,
3164  // 0x2A: BT dword ptr [rax+0x438], 0x08
3165  0x0f, 0xba, 0xa0, 0x38, 0x04, 0x00, 0x00, 0x08,
3166  // 0x32: POP rcx
3167  0x59,
3168  // 0x33: POP rax
3169  0x58,
3170  // 0x34: JNZ 0x39
3171  0x75, 0x03,
3172  // 0x36: JNC 0x39
3173  0x73, 0x01,
3174  // 0x38: INT3
3175  0xCC,
3176  // 0x39: JMP 0x3e
3177  0xE9, 0x00, 0x00, 0x00, 0x00
3178  },
3179  .HypercallOffset = 0x38,
3180  .RelocatedCodeOffset = 0x39,
3181  },
3182 
3183  {
3184  .MinVersion = 9600,
3185  .MaxVersion = 9600,
3186  .HypercallType = hypercallTypeInt3,
3187 
3188  .CodeLength = 0x3e,
3189  .Code =
3190  {
3191  // 0x00: TEST byte ptr [rcx+0x30], 0x10
3192  0xF6, 0x41, 0x30, 0x10,
3193  // 0x04: JZ 0x39
3194  0x74, 0x33,
3195  // 0x06: PUSH rax
3196  0x50,
3197  // 0x07: PUSH rcx
3198  0x51,
3199  // 0x08: MOV rcx, qword ptr gs:[0x188]
3200  0x65, 0x48, 0x8B, 0x0C, 0x25, 0x88, 0x01, 0x00, 0x00,
3201  // 0x11: MOV rax, qword ptr [rcx+0xb8]
3202  0x48, 0x8B, 0x81, 0xB8, 0x00, 0x00, 0x00,
3203  // 0x18: TEST eax, eax
3204  0x85, 0xC0,
3205  // 0x1A: JNZ 0x23
3206  0x75, 0x07,
3207  // 0x1C: MOV rax, qword ptr [rcx+0x220]
3208  0x48, 0x8B, 0x81, 0x20, 0x02, 0x00, 0x00,
3209  // 0x23: CMP byte ptr [rax+0x438], 0x2a
3210  0x80, 0xB8, 0x38, 0x04, 0x00, 0x00, 0x2A,
3211  // 0x2A: BT dword ptr [rax+0x438], 0x08
3212  0x0f, 0xba, 0xa0, 0x38, 0x04, 0x00, 0x00, 0x08,
3213  // 0x32: POP rcx
3214  0x59,
3215  // 0x33: POP rax
3216  0x58,
3217  // 0x34: JNZ 0x39
3218  0x75, 0x03,
3219  // 0x36: JNC 0x39
3220  0x73, 0x01,
3221  // 0x38: INT3
3222  0xCC,
3223  // 0x39: JMP 0x3e
3224  0xE9, 0x00, 0x00, 0x00, 0x00
3225  },
3226  .HypercallOffset = 0x38,
3227  .RelocatedCodeOffset = 0x39,
3228  },
3229  },
3230  },
3231 
3232  {
3233  .ModuleName = u"ntoskrnl.exe",
3234  .FunctionName = "MiGetWsAndInsertVad",
3235  .MinVersion = 17763,
3236  .MaxVersion = 18362,
3237  .Callback = IntWinVadHandleInsertMap,
3238  .PreCallback = IntWinVadPatchInsertMap,
3239  .Tag = detTagVadInsertMap,
3240  .Exported = FALSE,
3241  .NotCritical = FALSE,
3242  .DisableFlags = 0,
3243  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION | INTRO_OPT_ENABLE_MISC_EVENTS,
3244  .Arguments = DET_ARGS_DEFAULT_WIN64,
3245  .HandlersCount = 2,
3246  .Handlers = {
3247  // Windows 10 RS5 17763
3248  {
3249  .MinVersion = 17763,
3250  .MaxVersion = 17763,
3251  .HypercallType = hypercallTypeInt3,
3252 
3253  .CodeLength = 0x3e,
3254  .Code =
3255  {
3256  // 0x00: TEST byte ptr [rcx+0x30], 0x10
3257  0xF6, 0x41, 0x30, 0x10,
3258  // 0x04: JZ 0x39
3259  0x74, 0x33,
3260  // 0x06: PUSH rax
3261  0x50,
3262  // 0x07: PUSH rcx
3263  0x51,
3264  // 0x08: MOV rcx, qword ptr gs:[0x188]
3265  0x65, 0x48, 0x8B, 0x0C, 0x25, 0x88, 0x01, 0x00, 0x00,
3266  // 0x11: MOV rax, qword ptr [rcx+0xb8]
3267  0x48, 0x8B, 0x81, 0xB8, 0x00, 0x00, 0x00,
3268  // 0x18: TEST eax, eax
3269  0x85, 0xC0,
3270  // 0x1A: JNZ 0x23
3271  0x75, 0x07,
3272  // 0x1C: MOV rax, qword ptr [rcx+0x220]
3273  0x48, 0x8B, 0x81, 0x20, 0x02, 0x00, 0x00,
3274  // 0x23: CMP byte ptr [rax+0x450], 0x2a
3275  0x80, 0xB8, 0x50, 0x04, 0x00, 0x00, 0x2A,
3276  // 0x2A: BT dword ptr [rax+0x450], 0x08
3277  0x0f, 0xba, 0xa0, 0x50, 0x04, 0x00, 0x00, 0x08,
3278  // 0x32: POP rcx
3279  0x59,
3280  // 0x33: POP rax
3281  0x58,
3282  // 0x34: JNZ 0x39
3283  0x75, 0x03,
3284  // 0x36: JNC 0x39
3285  0x73, 0x01,
3286  // 0x38: INT3
3287  0xCC,
3288  // 0x39: JMP 0x3e
3289  0xE9, 0x00, 0x00, 0x00, 0x00
3290  },
3291  .HypercallOffset = 0x38,
3292  .RelocatedCodeOffset = 0x39,
3293  },
3294  {
3295  .MinVersion = 18362,
3296  .MaxVersion = 18362,
3297  .HypercallType = hypercallTypeInt3,
3298 
3299  .CodeLength = 0x3e,
3300  .Code =
3301  {
3302  // 0x00: TEST byte ptr [rcx+0x31], 0x01
3303  0xf6, 0x41, 0x31, 0x01,
3304  // 0x04: JZ 0x39
3305  0x74, 0x33,
3306  // 0x06: PUSH rax
3307  0x50,
3308  // 0x07: PUSH rcx
3309  0x51,
3310  // 0x08: MOV rcx, qword ptr gs:[0x188]
3311  0x65, 0x48, 0x8B, 0x0C, 0x25, 0x88, 0x01, 0x00, 0x00,
3312  // 0x11: MOV rax, qword ptr [rcx+0xb8]
3313  0x48, 0x8B, 0x81, 0xB8, 0x00, 0x00, 0x00,
3314  // 0x18: TEST eax, eax
3315  0x85, 0xC0,
3316  // 0x1A: JNZ 0x23
3317  0x75, 0x07,
3318  // 0x1C: MOV rax, qword ptr [rcx+0x220]
3319  0x48, 0x8B, 0x81, 0x20, 0x02, 0x00, 0x00,
3320  // 0x23: CMP byte ptr [rax+0x450], 0x2a
3321  0x80, 0xB8, 0x50, 0x04, 0x00, 0x00, 0x2A,
3322  // 0x2A: BT dword ptr [rax+0x450], 0x08
3323  0x0f, 0xba, 0xa0, 0x50, 0x04, 0x00, 0x00, 0x08,
3324  // 0x32: POP rcx
3325  0x59,
3326  // 0x33: POP rax
3327  0x58,
3328  // 0x34: JNZ 0x39
3329  0x75, 0x03,
3330  // 0x36: JNC 0x39
3331  0x73, 0x01,
3332  // 0x38: INT3
3333  0xCC,
3334  // 0x39: JMP 0x3e
3335  0xE9, 0x00, 0x00, 0x00, 0x00
3336  },
3337  .HypercallOffset = 0x38,
3338  .RelocatedCodeOffset = 0x39,
3339  },
3340  },
3341  },
3342 
3343  {
3344  .ModuleName = u"ntoskrnl.exe",
3345  .FunctionName = "MiCommitExistingVad",
3346  .MinVersion = DETOUR_MIN_VERSION_ANY,
3347  .MaxVersion = DETOUR_MAX_VERSION_ANY,
3348  .PreCallback = IntWinPatchVadHandleCommit,
3349  .Callback = IntWinVadHandleCommit,
3350  .Tag = detTagVadCommit,
3351  .Exported = FALSE,
3352  .NotCritical = FALSE,
3353  .DisableFlags = 0,
3354  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION,
3355  .Arguments = DET_ARGS_DEFAULT_WIN64,
3356  .HandlersCount = 1,
3357  .Handlers =
3358  {
3359  {
3360  .MinVersion = DETOUR_MIN_VERSION_ANY,
3361  .MaxVersion = DETOUR_MAX_VERSION_ANY,
3362  .HypercallType = hypercallTypeInt3,
3363  .CodeLength = 0x3e,
3364  .Code =
3365  {
3366  // VmProtection & (PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READWRITE |
3367  // PAGE_EXECUTE_READ | PAGE_EXECUTE)
3368  // 0x00: TEST r9b, 0xf0
3369  0x41, 0xf6, 0xc1, 0xf0,
3370  // not executable, skip hook
3371  // 0x04: JZ 0x39
3372  0x74, 0x33,
3373  // 0x06: PUSH rcx
3374  0x51,
3375  // 0x07: PUSH rax
3376  0x50,
3377  // rcx = Kpcr.Prcb.CurrentThread
3378  // 0x08: MOV rcx, qword ptr gs:[0x0]
3379  0x65, 0x48, 0x8b, 0x0c, 0x25, 0x00, 0x00, 0x00, 0x00,
3380  // rax = Thread.ApcState.AttachedProcess
3381  // 0x11: MOV rax, qword ptr [rcx+0x0]
3382  0x48, 0x8b, 0x81, 0x00, 0x00, 0x00, 0x00,
3383  // 0x18: TEST eax, eax
3384  0x85, 0xc0,
3385  // 0x1A: JNZ 0x23
3386  0x75, 0x07,
3387  // rax = Thread.Process
3388  // 0x1C: MOV rax, qword ptr [rcx+0x0]
3389  0x48, 0x8b, 0x81, 0x00, 0x00, 0x00, 0x00,
3390  // cmp Process.ImageFileName[0], '*'
3391  // 0x23: CMP byte ptr [rax+0x0], 0x2a
3392  0x80, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x2a,
3393  // check if 0 != (Process.ImageFileName[1] & winProcExitVad)
3394  // 0x2A: BT dword ptr [rax+0x0], 0x08
3395  0x0f, 0xba, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x08,
3396  // 0x32: POP rax
3397  0x58,
3398  // 0x33: POP rcx
3399  0x59,
3400  // 0x34: JNZ 0x39
3401  0x75, 0x03,
3402  // 0x36: JNC 0x39
3403  0x73, 0x01,
3404  // 0x38: INT3
3405  0xcc,
3406  // 0x39: JMP 0x3e
3407  0xe9, 0x00, 0x00, 0x00, 0x00
3408  },
3409  .HypercallOffset = 0x38,
3410  .RelocatedCodeOffset = 0x39,
3411  }
3412  },
3413  },
3414 
3415  {
3416  .ModuleName = u"ntoskrnl.exe",
3417  .FunctionName = "MiProtectVirtualMemory",
3418  .MinVersion = DETOUR_MIN_VERSION_ANY,
3419  .MaxVersion = DETOUR_MAX_VERSION_ANY,
3420  .Callback = IntWinVadHandleVirtualProtect,
3421  .PreCallback = IntWinVadPatchVirtualProtect,
3422  .Tag = detTagVmProtect,
3423  .Exported = FALSE,
3424  .NotCritical = FALSE,
3425  .DisableFlags = 0,
3426  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION,
3427  .Arguments = DET_ARGS_DEFAULT_WIN64,
3428  .HandlersCount = 5,
3429  .Handlers =
3430  {
3431  {
3432  .MinVersion = 7600,
3433  .MaxVersion = 9200,
3434  .HypercallType = hypercallTypeInt3,
3435 
3436  .CodeLength = 0x1f,
3437  .Code =
3438  {
3439  // 0x00: TEST r9b, 0xf0
3440  0x41, 0xF6, 0xC1, 0xF0,
3441  // 0x04: JZ 0x1a
3442  0x74, 0x14,
3443  // 0x06: CMP byte ptr [rcx+0x2e0], 0x2a
3444  0x80, 0xB9, 0xe0, 0x02, 0x00, 0x00, 0x2A,
3445  // 0x0D: BT dword ptr [rcx+0x2e0], 0x08
3446  0x0f, 0xba, 0xa1, 0xe0, 0x02, 0x00, 0x00, 0x08,
3447  // 0x15: JNZ 0x1a
3448  0x75, 0x03,
3449  // 0x17: JNC 0x1a
3450  0x73, 0x01,
3451  // 0x19: INT3
3452  0xCC,
3453  // 0x1A: JMP 0x1f
3454  0xE9, 0x00, 0x00, 0x00, 0x00,
3455  },
3456  .HypercallOffset = 0x19,
3457  .RelocatedCodeOffset = 0x1a,
3458  },
3459 
3460  {
3461  .MinVersion = 9600,
3462  .MaxVersion = DETOUR_MAX_VERSION_ANY,
3463  .HypercallType = hypercallTypeInt3,
3464 
3465  .CodeLength = 0x20,
3466  .Code =
3467  {
3468  // 0x00: TEST byte ptr [rsp+0x28], 0xf0
3469  0xF6, 0x44, 0x24, 0x28, 0xF0,
3470  // 0x05: JZ 0x1b
3471  0x74, 0x14,
3472  // 0x07: CMP byte ptr [rdx+0x438], 0x2a
3473  0x80, 0xBA, 0x38, 0x04, 0x00, 0x00, 0x2A,
3474  // 0x0E: BT dword ptr [rdx+0x438], 0x08
3475  0x0f, 0xba, 0xa2, 0x38, 0x04, 0x00, 0x00, 0x08,
3476  // 0x16: JNZ 0x1b
3477  0x75, 0x03,
3478  // 0x18: JNC 0x1b
3479  0x73, 0x01,
3480  // 0x1A: INT3
3481  0xCC,
3482  // 0x1B: JMP 0x20
3483  0xE9, 0x00, 0x00, 0x00, 0x00,
3484  },
3485  .HypercallOffset = 0x1a,
3486  .RelocatedCodeOffset = 0x1b,
3487  },
3488  },
3489  },
3490 
3491  {
3492  .ModuleName = u"ntoskrnl.exe",
3493  .FunctionName = "MiDeleteVirtualAddresses",
3494  .MinVersion = DETOUR_MIN_VERSION_ANY,
3495  .MaxVersion = 16299,
3496  .Callback = IntWinVadHandleDeleteVaRange,
3497  .PreCallback = IntWinVadPatchDeleteVaRange,
3498  .Tag = detTagVaDelete,
3499  .Exported = FALSE,
3500  .NotCritical = FALSE,
3501  .DisableFlags = 0,
3502  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION | INTRO_OPT_ENABLE_MISC_EVENTS,
3503  .Arguments = DET_ARGS_DEFAULT_WIN64,
3504  .HandlersCount = 4,
3505  .Handlers =
3506  {
3507  {
3508  .MinVersion = 7600,
3509  .MaxVersion = 7602,
3510  .HypercallType = hypercallTypeInt3,
3511 
3512  .CodeLength = 0x38,
3513  .Code =
3514  {
3515  // 0x00: PUSH rax
3516  0x50,
3517  // 0x01: PUSH rcx
3518  0x51,
3519  // 0x02: MOV rcx, qword ptr gs:[0x188]
3520  0x65, 0x48, 0x8B, 0x0C, 0x25, 0x88, 0x01, 0x00, 0x00,
3521  // 0x0B: MOV rax, qword ptr [rcx+0x70]
3522  0x48, 0x8B, 0x81, 0x70, 0x00, 0x00, 0x00,
3523  // 0x12: TEST eax, eax
3524  0x85, 0xC0,
3525  // 0x14: JNZ 0x1d
3526  0x75, 0x07,
3527  // 0x16: MOV rax, qword ptr [rcx+0x210]
3528  0x48, 0x8B, 0x81, 0x10, 0x02, 0x00, 0x00,
3529  // 0x1D: CMP byte ptr [rax+0x2e0], 0x2a
3530  0x80, 0xB8, 0xE0, 0x02, 0x00, 0x00, 0x2A,
3531  // 0x24: BT dword ptr [rax+0x2e0], 0x08
3532  0x0f, 0xba, 0xa0, 0xe0, 0x02, 0x00, 0x00, 0x08,
3533  // 0x2C: POP rcx
3534  0x59,
3535  // 0x2D: POP rax
3536  0x58,
3537  // 0x2E: JNZ 0x33
3538  0x75, 0x03,
3539  // 0x30: JNC 0x33
3540  0x73, 0x01,
3541  // 0x32: INT3
3542  0xCC,
3543  // 0x33: JMP 0x38
3544  0xE9, 0x00, 0x00, 0x00, 0x00
3545  },
3546  .HypercallOffset = 0x32,
3547  .RelocatedCodeOffset = 0x33,
3548  },
3549 
3550  {
3551  .MinVersion = 9200,
3552  .MaxVersion = 9600,
3553  .HypercallType = hypercallTypeInt3,
3554 
3555  .CodeLength = 0x38,
3556  .Code =
3557  {
3558  // 0x00: PUSH rax
3559  0x50,
3560  // 0x01: PUSH rcx
3561  0x51,
3562  // 0x02: MOV rcx, qword ptr gs:[0x188]
3563  0x65, 0x48, 0x8B, 0x0C, 0x25, 0x88, 0x01, 0x00, 0x00,
3564  // 0x0B: MOV rax, qword ptr [rcx+0xb8]
3565  0x48, 0x8B, 0x81, 0xB8, 0x00, 0x00, 0x00,
3566  // 0x12: TEST eax, eax
3567  0x85, 0xC0,
3568  // 0x14: JNZ 0x1d
3569  0x75, 0x07,
3570  // 0x16: MOV rax, qword ptr [rcx+0x220]
3571  0x48, 0x8B, 0x81, 0x20, 0x02, 0x00, 0x00,
3572  // 0x1D: CMP byte ptr [rax+0x438], 0x2a
3573  0x80, 0xB8, 0x38, 0x04, 0x00, 0x00, 0x2A,
3574  // 0x24: BT dword ptr [rax+0x438], 0x08
3575  0x0f, 0xba, 0xa0, 0x38, 0x04, 0x00, 0x00, 0x08,
3576  // 0x2C: POP rcx
3577  0x59,
3578  // 0x2D: POP rax
3579  0x58,
3580  // 0x2E: JNZ 0x33
3581  0x75, 0x03,
3582  // 0x30: JNC 0x33
3583  0x73, 0x01,
3584  // 0x32: INT3
3585  0xCC,
3586  // 0x33: JMP 0x38
3587  0xE9, 0x00, 0x00, 0x00, 0x00
3588  },
3589  .HypercallOffset = 0x32,
3590  .RelocatedCodeOffset = 0x33,
3591  },
3592 
3593  {
3594  .MinVersion = 10240,
3595  .MaxVersion = 10240,
3596  .HypercallType = hypercallTypeInt3,
3597 
3598  .CodeLength = 0x38,
3599  .Code =
3600  {
3601  // 0x00: PUSH rax
3602  0x50,
3603  // 0x01: PUSH rcx
3604  0x51,
3605  // 0x02: MOV rcx, qword ptr gs:[0x188]
3606  0x65, 0x48, 0x8B, 0x0C, 0x25, 0x88, 0x01, 0x00, 0x00,
3607  // 0x0B: MOV rax, qword ptr [rcx+0xb8]
3608  0x48, 0x8B, 0x81, 0xB8, 0x00, 0x00, 0x00,
3609  // 0x12: TEST eax, eax
3610  0x85, 0xC0,
3611  // 0x14: JNZ 0x1d
3612  0x75, 0x07,
3613  // 0x16: MOV rax, qword ptr [rcx+0x220]
3614  0x48, 0x8B, 0x81, 0x20, 0x02, 0x00, 0x00,
3615  // 0x1D: CMP byte ptr [rax+0x448], 0x2a
3616  0x80, 0xB8, 0x48, 0x04, 0x00, 0x00, 0x2A,
3617  // 0x24: BT dword ptr [rax+0x448], 0x08
3618  0x0f, 0xba, 0xa0, 0x48, 0x04, 0x00, 0x00, 0x08,
3619  // 0x2C: POP rcx
3620  0x59,
3621  // 0x2D: POP rax
3622  0x58,
3623  // 0x2E: JNZ 0x33
3624  0x75, 0x03,
3625  // 0x30: JNC 0x33
3626  0x73, 0x01,
3627  // 0x32: INT3
3628  0xCC,
3629  // 0x33: JMP 0x38
3630  0xE9, 0x00, 0x00, 0x00, 0x00
3631  },
3632  .HypercallOffset = 0x32,
3633  .RelocatedCodeOffset = 0x33,
3634  },
3635 
3636  {
3637  .MinVersion = 10586,
3638  .MaxVersion = 16299,
3639  .HypercallType = hypercallTypeInt3,
3640 
3641  .CodeLength = 0x38,
3642  .Code =
3643  {
3644  // 0x00: PUSH rax
3645  0x50,
3646  // 0x01: PUSH rcx
3647  0x51,
3648  // 0x02: MOV rcx, qword ptr gs:[0x188]
3649  0x65, 0x48, 0x8B, 0x0C, 0x25, 0x88, 0x01, 0x00, 0x00,
3650  // 0x0B: MOV rax, qword ptr [rcx+0xb8]
3651  0x48, 0x8B, 0x81, 0xB8, 0x00, 0x00, 0x00,
3652  // 0x12: TEST eax, eax
3653  0x85, 0xC0,
3654  // 0x14: JNZ 0x1d
3655  0x75, 0x07,
3656  // 0x16: MOV rax, qword ptr [rcx+0x220]
3657  0x48, 0x8B, 0x81, 0x20, 0x02, 0x00, 0x00,
3658  // 0x1D: CMP byte ptr [rax+0x450], 0x2a
3659  0x80, 0xB8, 0x50, 0x04, 0x00, 0x00, 0x2A,
3660  // 0x24: BT dword ptr [rax+0x450], 0x08
3661  0x0f, 0xba, 0xa0, 0x50, 0x04, 0x00, 0x00, 0x08,
3662  // 0x2C: POP rcx
3663  0x59,
3664  // 0x2D: POP rax
3665  0x58,
3666  // 0x2E: JNZ 0x33
3667  0x75, 0x03,
3668  // 0x30: JNC 0x33
3669  0x73, 0x01,
3670  // 0x32: INT3
3671  0xCC,
3672  // 0x33: JMP 0x38
3673  0xE9, 0x00, 0x00, 0x00, 0x00
3674  },
3675  .HypercallOffset = 0x32,
3676  .RelocatedCodeOffset = 0x33,
3677  },
3678  },
3679  },
3680 
3681  {
3682  .ModuleName = u"ntoskrnl.exe",
3683  .FunctionName = "MiFinishVadDeletion",
3684  .MinVersion = 17134,
3685  .MaxVersion = DETOUR_MAX_VERSION_ANY,
3686  .Callback = IntWinVadHandleFinishVadDeletion,
3687  .PreCallback = IntWinVadPatchFinishVadDeletion,
3688  .Tag = detTagFinishVadDeletion,
3689  .Exported = FALSE,
3690  .NotCritical = FALSE,
3691  .DisableFlags = 0,
3692  .EnableFlags = INTRO_OPT_ENABLE_UM_PROTECTION | INTRO_OPT_ENABLE_MISC_EVENTS,
3693  .Arguments = DET_ARGS_DEFAULT_WIN64,
3694  .HandlersCount = 2,
3695  .Handlers =
3696  {
3697  {
3698  .MinVersion = 17134,
3699  .MaxVersion = 17763,
3700  .HypercallType = hypercallTypeInt3,
3701 
3702  .CodeLength = 0x3e,
3703  .Code =
3704  {
3705  // 0x00: TEST byte ptr [rcx+0x30], 0x10
3706  0xF6, 0x41, 0x30, 0x10,
3707  // 0x04: JZ 0x39
3708  0x74, 0x33,
3709  // 0x06: PUSH rax
3710  0x50,
3711  // 0x07: PUSH rcx
3712  0x51,
3713  // 0x08: MOV rcx, qword ptr gs:[0x188]
3714  0x65, 0x48, 0x8B, 0x0C, 0x25, 0x88, 0x01, 0x00, 0x00,
3715  // 0x11: MOV rax, qword ptr [rcx+0xb8]
3716  0x48, 0x8B, 0x81, 0xB8, 0x00, 0x00, 0x00,
3717  // 0x18: TEST eax, eax
3718  0x85, 0xC0,
3719  // 0x1A: JNZ 0x23
3720  0x75, 0x07,
3721  // 0x1C: MOV rax, qword ptr [rcx+0x220]
3722  0x48, 0x8B, 0x81, 0x20, 0x02, 0x00, 0x00,
3723  // 0x23: CMP byte ptr [rax+0x450], 0x2a
3724  0x80, 0xB8, 0x50, 0x04, 0x00, 0x00, 0x2A,
3725  // 0x2A: BT dword ptr [rax+0x450], 0x08
3726  0x0f, 0xba, 0xa0, 0x50, 0x04, 0x00, 0x00, 0x08,
3727  // 0x32: POP rcx
3728  0x59,
3729  // 0x33: POP rax
3730  0x58,
3731  // 0x34: JNZ 0x39
3732  0x75, 0x03,
3733  // 0x36: JNC 0x39
3734  0x73, 0x01,
3735  // 0x38: INT3
3736  0xCC,
3737  // 0x39: JMP 0x3e
3738  0xE9, 0x00, 0x00, 0x00, 0x00
3739  },
3740  .HypercallOffset = 0x38,
3741  .RelocatedCodeOffset = 0x39,
3742  },
3743  // 19H1
3744  {
3745  .MinVersion = 18362,
3746  .MaxVersion = DETOUR_MAX_VERSION_ANY,
3747  .HypercallType = hypercallTypeInt3,
3748 
3749  .CodeLength = 0x3e,
3750  .Code =
3751  {
3752  // 0x00: TEST byte ptr [rcx+0x31], 0x01
3753  0xf6, 0x41, 0x31, 0x01,
3754  // 0x04: JZ 0x39
3755  0x74, 0x33,
3756  // 0x06: PUSH rax
3757  0x50,
3758  // 0x07: PUSH rcx
3759  0x51,
3760  // 0x08: MOV rcx, qword ptr gs:[0x188]
3761  0x65, 0x48, 0x8B, 0x0C, 0x25, 0x88, 0x01, 0x00, 0x00,
3762  // 0x11: MOV rax, qword ptr [rcx+0xb8]
3763  0x48, 0x8B, 0x81, 0xB8, 0x00, 0x00, 0x00,
3764  // 0x18: TEST eax, eax
3765  0x85, 0xC0,
3766  // 0x1A: JNZ 0x23
3767  0x75, 0x07,
3768  // 0x1C: MOV rax, qword ptr [rcx+0x220]
3769  0x48, 0x8B, 0x81, 0x20, 0x02, 0x00, 0x00,
3770  // 0x23: CMP byte ptr [rax+0x450], 0x2a
3771  0x80, 0xB8, 0x50, 0x04, 0x00, 0x00, 0x2A,
3772  // 0x2A: BT dword ptr [rax+0x450], 0x08
3773  0x0f, 0xba, 0xa0, 0x50, 0x04, 0x00, 0x00, 0x08,
3774  // 0x32: POP rcx
3775  0x59,
3776  // 0x33: POP rax
3777  0x58,
3778  // 0x34: JNZ 0x39
3779  0x75, 0x03,
3780  // 0x36: JNC 0x39
3781  0x73, 0x01,
3782  // 0x38: INT3
3783  0xCC,
3784  // 0x39: JMP 0x3e
3785  0xE9, 0x00, 0x00, 0x00, 0x00
3786  },
3787  .HypercallOffset = 0x38,
3788  .RelocatedCodeOffset = 0x39,
3789  },
3790  },
3791  },
3792 
3793  {
3794  .ModuleName = u"ntoskrnl.exe",
3795  .FunctionName = "NtSetSystemPowerState",
3796  .MinVersion = DETOUR_MIN_VERSION_ANY,
3797  .MaxVersion = DETOUR_MAX_VERSION_ANY,
3798  .Callback = IntWinPowHandlePowerStateChange,
3799  .Tag = detTagPowerState,
3800  .Exported = FALSE,
3801  .NotCritical = TRUE,
3802  .DisableFlags = 0,
3803  .EnableFlags = DETOUR_ENABLE_ALWAYS,
3804  .Arguments = DET_ARGS_DEFAULT_WIN64,
3805  .HandlersCount = 1,
3806  .Handlers =
3807  {
3808  {
3809  .MinVersion = DETOUR_MIN_VERSION_ANY,
3810  .MaxVersion = DETOUR_MAX_VERSION_ANY,
3811  .HypercallType = hypercallTypeInt3,
3812 
3813  .CodeLength = 0xF,
3814  .Code =
3815  {
3816  // 0x00: INT3
3817  0xcc,
3818  // 0x01: NOP
3819  0x66, 0x66, 0x66, 0x66, 0x90,
3820  // 0x06: NOP
3821  0x66, 0x90,
3822  // 0x08: NOP
3823  0x66, 0x90,
3824  // 0x0A: JMP 0xf
3825  0xe9, 0x00, 0x00, 0x00, 0x00
3826  },
3827  .HypercallOffset = 0x0,
3828  .RelocatedCodeOffset = 0xA,
3829  .PublicDataOffsets = {
3830  {
3831  .PublicDataName = "5bytenop",
3832  .PublicDataOffset = 0x1,
3833  .PublicDataSize = 0x5
3834  },
3835  {
3836  .PublicDataName = "spinwait",
3837  .PublicDataOffset = 0x6,
3838  .PublicDataSize = 0x4
3839  },
3840  },
3841  .NrPublicDataOffsets = 2,
3842  },
3843  },
3844  },
3845 
3850 
3851  //
3852  // Monstrous hack on order to avoid reads made by RtlpVirtualUnwind...
3853  //
3854  {
3855  .ModuleName = u"ntoskrnl.exe",
3856  .FunctionName = "RtlpVirtualUnwind1",
3857  .MinVersion = 7600,
3858  .MaxVersion = 7602,
3859  .Callback = NULL,
3860  .Tag = detTagRtlVirtualUnwind1,
3861  .Exported = FALSE,
3862  .NotCritical = TRUE,
3863  .DisableFlags = 0,
3864  .EnableFlags = DETOUR_ENABLE_ALWAYS,
3865  .Arguments = DET_ARGS_DEFAULT_WIN64,
3866  .HandlersCount = 1,
3867  .Handlers =
3868  {
3869  {
3870  .MinVersion = 7600,
3871  .MaxVersion = 7602,
3872  .HypercallType = hypercallTypeInt3,
3873 
3874  .CodeLength = 0x81,
3875  .Code =
3876  {
3877  // 0x00: CLI
3878  0xFA,
3879  // 0x01: MOV al, 0x00
3880  0xB0, 0x00,
3881  // 0x03: CMP ecx, 0x00000000
3882  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
3883  // 0x09: JZ 0x79
3884  0x74, 0x6E,
3885  // 0x0B: MOV al, 0x00
3886  0xB0, 0x00,
3887  // 0x0D: CMP ecx, 0x00000000
3888  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
3889  // 0x13: JZ 0x79
3890  0x74, 0x64,
3891  // 0x15: MOV al, 0x00
3892  0xB0, 0x00,
3893  // 0x17: CMP ecx, 0x00000000
3894  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
3895  // 0x1D: JZ 0x79
3896  0x74, 0x5A,
3897  // 0x1F: MOV al, 0x00
3898  0xB0, 0x00,
3899  // 0x21: CMP ecx, 0x00000000
3900  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
3901  // 0x27: JZ 0x79
3902  0x74, 0x50,
3903  // 0x29: MOV al, 0x00
3904  0xB0, 0x00,
3905  // 0x2B: CMP ecx, 0x00000000
3906  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
3907  // 0x31: JZ 0x79
3908  0x74, 0x46,
3909  // 0x33: MOV al, 0x00
3910  0xB0, 0x00,
3911  // 0x35: CMP ecx, 0x00000000
3912  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
3913  // 0x3B: JZ 0x79
3914  0x74, 0x3C,
3915  // 0x3D: MOV al, 0x00
3916  0xB0, 0x00,
3917  // 0x3F: CMP ecx, 0x00000000
3918  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
3919  // 0x45: JZ 0x79
3920  0x74, 0x32,
3921  // 0x47: MOV al, 0x00
3922  0xB0, 0x00,
3923  // 0x49: CMP ecx, 0x00000000
3924  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
3925  // 0x4F: JZ 0x79
3926  0x74, 0x28,
3927  // 0x51: MOV al, 0x00
3928  0xB0, 0x00,
3929  // 0x53: CMP ecx, 0x00000000
3930  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
3931  // 0x59: JZ 0x79
3932  0x74, 0x1E,
3933  // 0x5B: MOV al, 0x00
3934  0xB0, 0x00,
3935  // 0x5D: CMP ecx, 0x00000000
3936  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
3937  // 0x63: JZ 0x79
3938  0x74, 0x14,
3939  // 0x65: MOV al, 0x00
3940  0xB0, 0x00,
3941  // 0x67: CMP ecx, 0x00000000
3942  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
3943  // 0x6D: JZ 0x79
3944  0x74, 0x0A,
3945  // 0x6F: MOV al, 0x00
3946  0xB0, 0x00,
3947  // 0x71: CMP ecx, 0x00000000
3948  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
3949  // 0x77: JZ 0x79
3950  0x74, 0x00,
3951  // 0x79: STI
3952  0xFB,
3953  // 0x7A: JZ 0x7e
3954  0x74, 0x02,
3955  // mov al, [rcx] comes here, it is two bytes
3956  // the rest of the instructions come here.
3957  // 0x7C: JMP 0x81
3958  0xE9, 0x00, 0x00, 0x00, 0x00
3959  },
3960  .HypercallOffset = 0xFF,
3961  .RelocatedCodeOffset = 0x7C,
3962  },
3963  },
3964  },
3965 
3966  {
3967  .ModuleName = u"ntoskrnl.exe",
3968  .FunctionName = "RtlpVirtualUnwind2",
3969  .MinVersion = 7600,
3970  .MaxVersion = 7602,
3971  .Callback = NULL,
3972  .Tag = detTagRtlVirtualUnwind2,
3973  .Exported = FALSE,
3974  .NotCritical = TRUE,
3975  .DisableFlags = 0,
3976  .EnableFlags = DETOUR_ENABLE_ALWAYS,
3977  .Arguments = DET_ARGS_DEFAULT_WIN64,
3978  .HandlersCount = 1,
3979  .Handlers =
3980  {
3981  {
3982  .MinVersion = 7600,
3983  .MaxVersion = 7602,
3984  .HypercallType = hypercallTypeInt3,
3985 
3986  .CodeLength = 0x81,
3987  .Code =
3988  {
3989  // 0x00: CLI
3990  0xFA,
3991  // 0x01: MOV al, 0x00
3992  0xB0, 0x00,
3993  // 0x03: CMP ecx, 0x00000000
3994  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
3995  // 0x09: JZ 0x79
3996  0x74, 0x6E,
3997  // 0x0B: MOV al, 0x00
3998  0xB0, 0x00,
3999  // 0x0D: CMP ecx, 0x00000000
4000  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
4001  // 0x13: JZ 0x79
4002  0x74, 0x64,
4003  // 0x15: MOV al, 0x00
4004  0xB0, 0x00,
4005  // 0x17: CMP ecx, 0x00000000
4006  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
4007  // 0x1D: JZ 0x79
4008  0x74, 0x5A,
4009  // 0x1F: MOV al, 0x00
4010  0xB0, 0x00,
4011  // 0x21: CMP ecx, 0x00000000
4012  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
4013  // 0x27: JZ 0x79
4014  0x74, 0x50,
4015  // 0x29: MOV al, 0x00
4016  0xB0, 0x00,
4017  // 0x2B: CMP ecx, 0x00000000
4018  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
4019  // 0x31: JZ 0x79
4020  0x74, 0x46,
4021  // 0x33: MOV al, 0x00
4022  0xB0, 0x00,
4023  // 0x35: CMP ecx, 0x00000000
4024  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
4025  // 0x3B: JZ 0x79
4026  0x74, 0x3C,
4027  // 0x3D: MOV al, 0x00
4028  0xB0, 0x00,
4029  // 0x3F: CMP ecx, 0x00000000
4030  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
4031  // 0x45: JZ 0x79
4032  0x74, 0x32,
4033  // 0x47: MOV al, 0x00
4034  0xB0, 0x00,
4035  // 0x49: CMP ecx, 0x00000000
4036  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
4037  // 0x4F: JZ 0x79
4038  0x74, 0x28,
4039  // 0x51: MOV al, 0x00
4040  0xB0, 0x00,
4041  // 0x53: CMP ecx, 0x00000000
4042  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
4043  // 0x59: JZ 0x79
4044  0x74, 0x1E,
4045  // 0x5B: MOV al, 0x00
4046  0xB0, 0x00,
4047  // 0x5D: CMP ecx, 0x00000000
4048  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
4049  // 0x63: JZ 0x79
4050  0x74, 0x14,
4051  // 0x65: MOV al, 0x00
4052  0xB0, 0x00,
4053  // 0x67: CMP ecx, 0x00000000
4054  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
4055  // 0x6D: JZ 0x79
4056  0x74, 0x0A,
4057  // 0x6F: MOV al, 0x00
4058  0xB0, 0x00,
4059  // 0x71: CMP ecx, 0x00000000
4060  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
4061  // 0x77: JZ 0x79
4062  0x74, 0x00,
4063  // 0x79: STI
4064  0xFB,
4065  // 0x7A: JZ 0x7f
4066  0x74, 0x03,
4067  // mov al, [rcx+1] comes here, 3 bytes
4068  // 0x7C: JMP 0x81
4069  0xE9, 0x00, 0x00, 0x00, 0x00
4070  },
4071  .HypercallOffset = 0xFF,
4072  .RelocatedCodeOffset = 0x7C,
4073  },
4074  },
4075  },
4076 
4077  {
4078  .ModuleName = u"ntoskrnl.exe",
4079  .FunctionName = "RtlpVirtualUnwind3",
4080  .MinVersion = 7600,
4081  .MaxVersion = 7602,
4082  .Callback = NULL,
4083  .Tag = detTagRtlVirtualUnwind3,
4084  .Exported = FALSE,
4085  .NotCritical = TRUE,
4086  .DisableFlags = 0,
4087  .EnableFlags = DETOUR_ENABLE_ALWAYS,
4088  .Arguments = DET_ARGS_DEFAULT_WIN64,
4089  .HandlersCount = 1,
4090  .Handlers =
4091  {
4092  {
4093  .MinVersion = 7600,
4094  .MaxVersion = 7602,
4095 
4096  .HypercallType = hypercallTypeInt3,
4097  .CodeLength = 0x81,
4098  .Code =
4099  {
4100  // 0x00: CLI
4101  0xFA,
4102  // 0x01: MOV dl, 0x00
4103  0xB2, 0x00,
4104  // 0x03: CMP ecx, 0x00000000
4105  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
4106  // 0x09: JZ 0x79
4107  0x74, 0x6E,
4108  // 0x0B: MOV dl, 0x00
4109  0xB2, 0x00,
4110  // 0x0D: CMP ecx, 0x00000000
4111  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
4112  // 0x13: JZ 0x79
4113  0x74, 0x64,
4114  // 0x15: MOV dl, 0x00
4115  0xB2, 0x00,
4116  // 0x17: CMP ecx, 0x00000000
4117  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
4118  // 0x1D: JZ 0x79
4119  0x74, 0x5A,
4120  // 0x1F: MOV dl, 0x00
4121  0xB2, 0x00,
4122  // 0x21: CMP ecx, 0x00000000
4123  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
4124  // 0x27: JZ 0x79
4125  0x74, 0x50,
4126  // 0x29: MOV dl, 0x00
4127  0xB2, 0x00,
4128  // 0x2B: CMP ecx, 0x00000000
4129  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
4130  // 0x31: JZ 0x79
4131  0x74, 0x46,
4132  // 0x33: MOV dl, 0x00
4133  0xB2, 0x00,
4134  // 0x35: CMP ecx, 0x00000000
4135  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
4136  // 0x3B: JZ 0x79
4137  0x74, 0x3C,
4138  // 0x3D: MOV dl, 0x00
4139  0xB2, 0x00,
4140  // 0x3F: CMP ecx, 0x00000000
4141  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
4142  // 0x45: JZ 0x79
4143  0x74, 0x32,
4144  // 0x47: MOV dl, 0x00
4145  0xB2, 0x00,
4146  // 0x49: CMP ecx, 0x00000000
4147  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
4148  // 0x4F: JZ 0x79
4149  0x74, 0x28,
4150  // 0x51: MOV dl, 0x00
4151  0xB2, 0x00,
4152  // 0x53: CMP ecx, 0x00000000
4153  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
4154  // 0x59: JZ 0x79
4155  0x74, 0x1E,
4156  // 0x5B: MOV dl, 0x00
4157  0xB2, 0x00,
4158  // 0x5D: CMP ecx, 0x00000000
4159  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
4160  // 0x63: JZ 0x79
4161  0x74, 0x14,
4162  // 0x65: MOV dl, 0x00
4163  0xB2, 0x00,
4164  // 0x67: CMP ecx, 0x00000000
4165  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
4166  // 0x6D: JZ 0x79
4167  0x74, 0x0A,
4168  // 0x6F: MOV dl, 0x00
4169  0xB2, 0x00,
4170  // 0x71: CMP ecx, 0x00000000
4171  0x81, 0xF9, 0x00, 0x00, 0x00, 0x00,
4172  // 0x77: JZ 0x79
4173  0x74, 0x00,
4174  // 0x79: STI
4175  0xFB,
4176  // 0x7A: JZ 0x7e
4177  0x74, 0x02,
4178  // mov dl, [rcx] 2 bytes
4179  // 0x7C: JMP 0x81
4180  0xE9, 0x00, 0x00, 0x00, 0x00
4181  },
4182  .HypercallOffset = 0xFF,
4183  .RelocatedCodeOffset = 0x7C,
4184  },
4185  },
4186  },
4187 
4188  {
4189  .ModuleName = u"ntoskrnl.exe",
4190  .FunctionName = "RtlpVirtualUnwind4",
4191  .MinVersion = 7600,
4192  .MaxVersion = 7602,
4193  .Callback = NULL,
4194  .Tag = detTagRtlVirtualUnwind4,
4195  .Exported = FALSE,
4196  .NotCritical = TRUE,
4197  .DisableFlags = 0,
4198  .EnableFlags = DETOUR_ENABLE_ALWAYS,
4199  .Arguments = DET_ARGS_DEFAULT_WIN64,
4200  .HandlersCount = 1,
4201  .Handlers =
4202  {
4203  {
4204  .MinVersion = 7600,
4205  .MaxVersion = 7602,
4206  .HypercallType = hypercallTypeInt3,
4207 
4208  .CodeLength = 0x81,
4209  .Code =
4210  {
4211  // 0x00: CLI
4212  0xFA,
4213  // 0x01: MOV al, 0x00
4214  0xB0, 0x00,
4215  // 0x03: CMP ebp, 0x00000000
4216  0x81, 0xFD, 0x00, 0x00, 0x00, 0x00,
4217  // 0x09: JZ 0x79
4218  0x74, 0x6E,
4219  // 0x0B: MOV al, 0x00
4220  0xB0, 0x00,
4221  // 0x0D: CMP ebp, 0x00000000
4222  0x81, 0xFD, 0x00, 0x00, 0x00, 0x00,
4223  // 0x13: JZ 0x79
4224  0x74, 0x64,
4225  // 0x15: MOV al, 0x00
4226  0xB0, 0x00,
4227  // 0x17: CMP ebp, 0x00000000
4228  0x81, 0xFD, 0x00, 0x00, 0x00, 0x00,
4229  // 0x1D: JZ 0x79
4230  0x74, 0x5A,
4231  // 0x1F: MOV al, 0x00
4232  0xB0, 0x00,
4233  // 0x21: CMP ebp, 0x00000000
4234  0x81, 0xFD, 0x00, 0x00, 0x00, 0x00,
4235  // 0x27: JZ 0x79
4236  0x74, 0x50,
4237  // 0x29: MOV al, 0x00
4238  0xB0, 0x00,
4239  // 0x2B: CMP ebp, 0x00000000
4240  0x81, 0xFD, 0x00, 0x00, 0x00, 0x00,
4241  // 0x31: JZ 0x79
4242  0x74, 0x46,
4243  // 0x33: MOV al, 0x00
4244  0xB0, 0x00,
4245  // 0x35: CMP ebp, 0x00000000
4246  0x81, 0xFD, 0x00, 0x00, 0x00, 0x00,
4247  // 0x3B: JZ 0x79
4248  0x74, 0x3C,
4249  // 0x3D: MOV al, 0x00
4250  0xB0, 0x00,
4251  // 0x3F: CMP ebp, 0x00000000
4252  0x81, 0xFD, 0x00, 0x00, 0x00, 0x00,
4253  // 0x45: JZ 0x79
4254  0x74, 0x32,
4255  // 0x47: MOV al, 0x00
4256  0xB0, 0x00,
4257  // 0x49: CMP ebp, 0x00000000
4258  0x81, 0xFD, 0x00, 0x00, 0x00, 0x00,
4259  // 0x4F: JZ 0x79
4260  0x74, 0x28,
4261  // 0x51: MOV al, 0x00
4262  0xB0, 0x00,
4263  // 0x53: CMP ebp, 0x00000000
4264  0x81, 0xFD, 0x00, 0x00, 0x00, 0x00,
4265  // 0x59: JZ 0x79
4266  0x74, 0x1E,
4267  // 0x5B: MOV al, 0x00
4268  0xB0, 0x00,
4269  // 0x5D: CMP ebp, 0x00000000
4270  0x81, 0xFD, 0x00, 0x00, 0x00, 0x00,
4271  // 0x63: JZ 0x79
4272  0x74, 0x14,
4273  // 0x65: MOV al, 0x00
4274  0xB0, 0x00,
4275  // 0x67: CMP ebp, 0x00000000
4276  0x81, 0xFD, 0x00, 0x00, 0x00, 0x00,
4277  // 0x6D: JZ 0x79
4278  0x74, 0x0A,
4279  // 0x6F: MOV al, 0x00
4280  0xB0, 0x00,
4281  // 0x71: CMP ebp, 0x00000000
4282  0x81, 0xFD, 0x00, 0x00, 0x00, 0x00,
4283  // 0x77: JZ 0x79
4284  0x74, 0x00,
4285  // 0x79: STI
4286  0xFB,
4287  // 0x7A: JZ 0x7f
4288  0x74, 0x03,
4289  // mov al, [rbp+1]
4290  // 0x7C: JMP 0x81
4291  0xE9, 0x00, 0x00, 0x00, 0x00
4292  },
4293  .HypercallOffset = 0xFF,
4294  .RelocatedCodeOffset = 0x7C,
4295  },
4296  },
4297  },
4298 
4299  {
4300  .ModuleName = u"ntoskrnl.exe",
4301  .FunctionName = "RtlpVirtualUnwind5",
4302  .MinVersion = 7600,
4303  .MaxVersion = 7602,
4304  .Callback = NULL,
4305  .Tag = detTagRtlVirtualUnwind5,
4306  .Exported = FALSE,
4307  .NotCritical = TRUE,
4308  .DisableFlags = 0,
4309  .EnableFlags = DETOUR_ENABLE_ALWAYS,
4310  .Arguments = DET_ARGS_DEFAULT_WIN64,
4311  .HandlersCount = 1,
4312  .Handlers =
4313  {
4314  {
4315  .MinVersion = 7600,
4316  .MaxVersion = 7602,
4317 
4318  .HypercallType = hypercallTypeInt3,
4319  .CodeLength = 0x89,
4320  .Code =
4321  {
4322  // 0x00: PUSH rax
4323  0x50,
4324  // 0x01: CLI
4325  0xFA,
4326  // 0x02: CMP ebp, 0xbdbdbdbd
4327  0x81, 0xFD, 0xBD, 0xBD, 0xBD, 0xBD,
4328  // 0x08: JNZ 0x12
4329  0x75, 0x08,
4330  // 0x0A: MOV al, 0xbd
4331  0xB0, 0xBD,
4332  // 0x0C: CMP al, 0x48
4333  0x3C, 0x48,
4334  // 0x0E: STI
4335  0xFB,
4336  // 0x0F: POP rax
4337  0x58,
4338  // 0x10: JMP 0x88
4339  0xEB, 0x76,
4340  // 0x12: CMP ebp, 0xbdbdbdbd
4341  0x81, 0xFD, 0xBD, 0xBD, 0xBD, 0xBD,
4342  // 0x18: JNZ 0x22
4343  0x75, 0x08,
4344  // 0x1A: MOV al, 0xbd
4345  0xB0, 0xBD,
4346  // 0x1C: CMP al, 0x48
4347  0x3C, 0x48,
4348  // 0x1E: STI
4349  0xFB,
4350  // 0x1F: POP rax
4351  0x58,
4352  // 0x20: JMP 0x88
4353  0xEB, 0x66,
4354  // 0x22: CMP ebp, 0xbdbdbdbd
4355  0x81, 0xFD, 0xBD, 0xBD, 0xBD, 0xBD,
4356  // 0x28: JNZ 0x32
4357  0x75, 0x08,
4358  // 0x2A: MOV al, 0xbd
4359  0xB0, 0xBD,
4360  // 0x2C: CMP al, 0x48
4361  0x3C, 0x48,
4362  // 0x2E: STI
4363  0xFB,
4364  // 0x2F: POP rax
4365  0x58,
4366  // 0x30: JMP 0x88
4367  0xEB, 0x56,
4368  // 0x32: CMP ebp, 0xbdbdbdbd
4369  0x81, 0xFD, 0xBD, 0xBD, 0xBD, 0xBD,
4370  // 0x38: JNZ 0x42
4371  0x75, 0x08,
4372  // 0x3A: MOV al, 0xbd
4373  0xB0, 0xBD,
4374  // 0x3C: CMP al, 0x48
4375  0x3C, 0x48,
4376  // 0x3E: STI
4377  0xFB,
4378  // 0x3F: POP rax
4379  0x58,
4380  // 0x40: JMP 0x88
4381  0xEB, 0x46,
4382  // 0x42: CMP ebp, 0xbdbdbdbd
4383  0x81, 0xFD, 0xBD, 0xBD, 0xBD, 0xBD,
4384  // 0x48: JNZ 0x52
4385  0x75, 0x08,
4386  // 0x4A: MOV al, 0xbd
4387  0xB0, 0xBD,
4388  // 0x4C: CMP al, 0x48
4389  0x3C, 0x48,
4390  // 0x4E: STI
4391  0xFB,
4392  // 0x4F: POP rax
4393  0x58,
4394  // 0x50: JMP 0x88
4395  0xEB, 0x36,
4396  // 0x52: CMP ebp, 0xbdbdbdbd
4397  0x81, 0xFD, 0xBD, 0xBD, 0xBD, 0xBD,
4398  // 0x58: JNZ 0x62
4399  0x75, 0x08,
4400  // 0x5A: MOV al, 0xbd
4401  0xB0, 0xBD,
4402  // 0x5C: CMP al, 0x48
4403  0x3C, 0x48,
4404  // 0x5E: STI
4405  0xFB,
4406  // 0x5F: POP rax
4407  0x58,
4408  // 0x60: JMP 0x88
4409  0xEB, 0x26,
4410  // 0x62: CMP ebp, 0xbdbdbdbd
4411  0x81, 0xFD, 0xBD, 0xBD, 0xBD, 0xBD,
4412  // 0x68: JNZ 0x72
4413  0x75, 0x08,
4414  // 0x6A: MOV al, 0xbd
4415  0xB0, 0xBD,
4416  // 0x6C: CMP al, 0x48
4417  0x3C, 0x48,
4418  // 0x6E: STI
4419  0xFB,
4420  // 0x6F: POP rax
4421  0x58,
4422  // 0x70: JMP 0x88
4423  0xEB, 0x16,
4424  // 0x72: CMP ebp, 0xbdbdbdbd
4425  0x81, 0xFD, 0xBD, 0xBD, 0xBD, 0xBD,
4426  // 0x78: JNZ 0x82
4427  0x75, 0x08,
4428  // 0x7A: MOV al, 0xbd
4429  0xB0, 0xBD,
4430  // 0x7C: CMP al, 0x48
4431  0x3C, 0x48,
4432  // 0x7E: STI
4433  0xFB,
4434  // 0x7F: POP rax
4435  0x58,
4436  // 0x80: JMP 0x88
4437  0xEB, 0x06,
4438  // 0x82: STI
4439  0xFB,
4440  // 0x83: POP rax
4441  0x58,
4442  // 4 bytes of CMP [rbp], imm comes here
4443  // 0x84: JMP 0x89
4444  0xE9, 0x00, 0x00, 0x00, 0x00
4445  },
4446  .HypercallOffset = 0xFF,
4447  .RelocatedCodeOffset = 0x84,
4448  },
4449  },
4450  },
4451 
4452  {
4453  .ModuleName = u"ntoskrnl.exe",
4454  .FunctionName = "RtlpVirtualUnwind6",
4455  .MinVersion = 7600,
4456  .MaxVersion = 7602,
4457  .Callback = NULL,
4458  .Tag = detTagRtlVirtualUnwind6,
4459  .Exported = FALSE,
4460  .NotCritical = TRUE,
4461  .DisableFlags = 0,
4462  .EnableFlags = DETOUR_ENABLE_ALWAYS,
4463  .Arguments = DET_ARGS_DEFAULT_WIN64,
4464  .HandlersCount = 1,
4465  .Handlers =
4466  {
4467  {
4468  .MinVersion = 7600,
4469  .MaxVersion = 7602,
4470  .HypercallType = hypercallTypeInt3,
4471 
4472  .CodeLength = 0x81,
4473  .Code =
4474  {
4475  // 0x00: CLI
4476  0xFA,
4477  // 0x01: MOV al, 0x00
4478  0xB0, 0x00,
4479  // 0x03: CMP ebp, 0x00000000
4480  0x81, 0xFD, 0x00, 0x00, 0x00, 0x00,
4481  // 0x09: JZ 0x79
4482  0x74, 0x6E,
4483  // 0x0B: MOV al, 0x00
4484  0xB0, 0x00,
4485  // 0x0D: CMP ebp, 0x00000000
4486  0x81, 0xFD, 0x00, 0x00, 0x00, 0x00,
4487  // 0x13: JZ 0x79
4488  0x74, 0x64,
4489  // 0x15: MOV al, 0x00
4490  0xB0, 0x00,
4491  // 0x17: CMP ebp, 0x00000000
4492  0x81, 0xFD, 0x00, 0x00, 0x00, 0x00,
4493  // 0x1D: JZ 0x79
4494  0x74, 0x5A,
4495  // 0x1F: MOV al, 0x00
4496  0xB0, 0x00,
4497  // 0x21: CMP ebp, 0x00000000
4498  0x81, 0xFD, 0x00, 0x00, 0x00, 0x00,
4499  // 0x27: JZ 0x79
4500  0x74, 0x50,
4501  // 0x29: MOV al, 0x00
4502  0xB0, 0x00,
4503  // 0x2B: CMP ebp, 0x00000000
4504  0x81, 0xFD, 0x00, 0x00, 0x00, 0x00,
4505  // 0x31: JZ 0x79
4506  0x74, 0x46,
4507  // 0x33: MOV al, 0x00
4508  0xB0, 0x00,
4509  // 0x35: CMP ebp, 0x00000000
4510  0x81, 0xFD, 0x00, 0x00, 0x00, 0x00,
4511  // 0x3B: JZ 0x79
4512  0x74, 0x3C,
4513  // 0x3D: MOV al, 0x00
4514  0xB0, 0x00,
4515  // 0x3F: CMP ebp, 0x00000000
4516  0x81, 0xFD, 0x00, 0x00, 0x00, 0x00,
4517  // 0x45: JZ 0x79
4518  0x74, 0x32,
4519  // 0x47: MOV al, 0x00
4520  0xB0, 0x00,
4521  // 0x49: CMP ebp, 0x00000000
4522  0x81, 0xFD, 0x00, 0x00, 0x00, 0x00,
4523  // 0x4F: JZ 0x79
4524  0x74, 0x28,
4525  // 0x51: MOV al, 0x00
4526  0xB0, 0x00,
4527  // 0x53: CMP ebp, 0x00000000
4528  0x81, 0xFD, 0x00, 0x00, 0x00, 0x00,
4529  // 0x59: JZ 0x79
4530  0x74, 0x1E,
4531  // 0x5B: MOV al, 0x00
4532  0xB0, 0x00,
4533  // 0x5D: CMP ebp, 0x00000000
4534  0x81, 0xFD, 0x00, 0x00, 0x00, 0x00,
4535  // 0x63: JZ 0x79
4536  0x74, 0x14,
4537  // 0x65: MOV al, 0x00
4538  0xB0, 0x00,
4539  // 0x67: CMP ebp, 0x00000000
4540  0x81, 0xFD, 0x00, 0x00, 0x00, 0x00,
4541  // 0x6D: JZ 0x79
4542  0x74, 0x0A,
4543  // 0x6F: MOV al, 0x00
4544  0xB0, 0x00,
4545  // 0x71: CMP ebp, 0x00000000
4546  0x81, 0xFD, 0x00, 0x00, 0x00, 0x00,
4547  // 0x77: JZ 0x79
4548  0x74, 0x00,
4549  // 0x79: STI
4550  0xFB,
4551  // 0x7A: JZ 0x7f
4552  0x74, 0x03,
4553  // mov al, [rbp + 0]
4554  // 0x7C: JMP 0x81
4555  0xE9, 0x00, 0x00, 0x00, 0x00
4556  },
4557  .HypercallOffset = 0xFF,
4558  .RelocatedCodeOffset = 0x7C,
4559  },
4560  },
4561  },
4562 
4563  {
4564  .ModuleName = u"ntoskrnl.exe",
4565  .FunctionName = "RtlpVirtualUnwind7",
4566  .MinVersion = 7600,
4567  .MaxVersion = 7602,
4568  .Callback = NULL,
4569  .Tag = detTagRtlVirtualUnwind7,
4570  .Exported = FALSE,
4571  .NotCritical = TRUE,
4572  .DisableFlags = 0,
4573  .EnableFlags = DETOUR_ENABLE_ALWAYS,
4574  .Arguments = DET_ARGS_DEFAULT_WIN64,
4575  .HandlersCount = 1,
4576  .Handlers =
4577  {
4578  {
4579  .MinVersion = 7600,
4580  .MaxVersion = 7602,
4581  .HypercallType = hypercallTypeInt3,
4582 
4583  .CodeLength = 0x89,
4584  .Code =
4585  {
4586  // 0x00: PUSH rax
4587  0x50,
4588  // 0x01: CLI
4589  0xFA,
4590  // 0x02: CMP ebp, 0xbdbdbdbd
4591  0x81, 0xFD, 0xBD, 0xBD, 0xBD, 0xBD,
4592  // 0x08: JNZ 0x12
4593  0x75, 0x08,
4594  // 0x0A: MOV al, 0xbd
4595  0xB0, 0xBD,
4596  // 0x0C: CMP al, 0x8d
4597  0x3C, 0x8D,
4598  // 0x0E: STI
4599  0xFB,
4600  // 0x0F: POP rax
4601  0x58,
4602  // 0x10: JMP 0x88
4603  0xEB, 0x76,
4604  // 0x12: CMP ebp, 0xbdbdbdbd
4605  0x81, 0xFD, 0xBD, 0xBD, 0xBD, 0xBD,
4606  // 0x18: JNZ 0x22
4607  0x75, 0x08,
4608  // 0x1A: MOV al, 0xbd
4609  0xB0, 0xBD,
4610  // 0x1C: CMP al, 0x8d
4611  0x3C, 0x8D,
4612  // 0x1E: STI
4613  0xFB,
4614  // 0x1F: POP rax
4615  0x58,
4616  // 0x20: JMP 0x88
4617  0xEB, 0x66,
4618  // 0x22: CMP ebp, 0xbdbdbdbd
4619  0x81, 0xFD, 0xBD, 0xBD, 0xBD, 0xBD,
4620  // 0x28: JNZ 0x32
4621  0x75, 0x08,
4622  // 0x2A: MOV al, 0xbd
4623  0xB0, 0xBD,
4624  // 0x2C: CMP al, 0x8d
4625  0x3C, 0x8D,
4626  // 0x2E: STI
4627  0xFB,
4628  // 0x2F: POP rax
4629  0x58,
4630  // 0x30: JMP 0x88
4631  0xEB, 0x56,
4632  // 0x32: CMP ebp, 0xbdbdbdbd
4633  0x81, 0xFD, 0xBD, 0xBD, 0xBD, 0xBD,
4634  // 0x38: JNZ 0x42
4635  0x75, 0x08,
4636  // 0x3A: MOV al, 0xbd
4637  0xB0, 0xBD,
4638  // 0x3C: CMP al, 0x8d
4639  0x3C, 0x8D,
4640  // 0x3E: STI
4641  0xFB,
4642  // 0x3F: POP rax
4643  0x58,
4644  // 0x40: JMP 0x88
4645  0xEB, 0x46,
4646  // 0x42: CMP ebp, 0xbdbdbdbd
4647  0x81, 0xFD, 0xBD, 0xBD, 0xBD, 0xBD,
4648  // 0x48: JNZ 0x52
4649  0x75, 0x08,
4650  // 0x4A: MOV al, 0xbd
4651  0xB0, 0xBD,
4652  // 0x4C: CMP al, 0x8d
4653  0x3C, 0x8D,
4654  // 0x4E: STI
4655  0xFB,
4656  // 0x4F: POP rax
4657  0x58,
4658  // 0x50: JMP 0x88
4659  0xEB, 0x36,
4660  // 0x52: CMP ebp, 0xbdbdbdbd
4661  0x81, 0xFD, 0xBD, 0xBD, 0xBD, 0xBD,
4662  // 0x58: JNZ 0x62
4663  0x75, 0x08,
4664  // 0x5A: MOV al, 0xbd
4665  0xB0, 0xBD,
4666  // 0x5C: CMP al, 0x8d
4667  0x3C, 0x8D,
4668  // 0x5E: STI
4669  0xFB,
4670  // 0x5F: POP rax
4671  0x58,
4672  // 0x60: JMP 0x88
4673  0xEB, 0x26,
4674  // 0x62: CMP ebp, 0xbdbdbdbd
4675  0x81, 0xFD, 0xBD, 0xBD, 0xBD, 0xBD,
4676  // 0x68: JNZ 0x72
4677  0x75, 0x08,
4678  // 0x6A: MOV al, 0xbd
4679  0xB0, 0xBD,
4680  // 0x6C: CMP al, 0x8d
4681  0x3C, 0x8D,
4682  // 0x6E: STI
4683  0xFB,
4684  // 0x6F: POP rax
4685  0x58,
4686  // 0x70: JMP 0x88
4687  0xEB, 0x16,
4688  // 0x72: CMP ebp, 0xbdbdbdbd
4689  0x81, 0xFD, 0xBD, 0xBD, 0xBD, 0xBD,
4690  // 0x78: JNZ 0x82
4691  0x75, 0x08,
4692  // 0x7A: MOV al, 0xbd
4693  0xB0, 0xBD,
4694  // 0x7C: CMP al, 0x8d
4695  0x3C, 0x8D,
4696  // 0x7E: STI
4697  0xFB,
4698  // 0x7F: POP rax
4699  0x58,
4700  // 0x80: JMP 0x88
4701  0xEB, 0x06,
4702  // 0x82: STI
4703  0xFB,
4704  // 0x83: POP rax
4705  0x58,
4706  // 4 bytes of CMP [rbp], imm comes here
4707  // 0x84: JMP 0x89
4708  0xE9, 0x00, 0x00, 0x00, 0x00
4709  },
4710  .HypercallOffset = 0xFF,
4711  .RelocatedCodeOffset = 0x84,
4712  },
4713  },
4714  },
4715 
4716  {
4717  .ModuleName = u"ntoskrnl.exe",
4718  .FunctionName = "RtlpVirtualUnwind8",
4719  .MinVersion = 7600,
4720  .MaxVersion = 7602,
4721  .Callback = NULL,
4722  .Tag = detTagRtlVirtualUnwind8,
4723  .Exported = FALSE,
4724  .NotCritical = TRUE,
4725  .DisableFlags = 0,
4726  .EnableFlags = DETOUR_ENABLE_ALWAYS,
4727  .Arguments = DET_ARGS_DEFAULT_WIN64,
4728  .HandlersCount = 1,
4729  .Handlers =
4730  {
4731  {
4732  .MinVersion = 7600,
4733  .MaxVersion = 7602,
4734  .HypercallType = hypercallTypeInt3,
4735 
4736  .CodeLength = 0x89,
4737  .Code =
4738  {
4739  // 0x00: PUSH rax
4740  0x50,
4741  // 0x01: CLI
4742  0xFA,
4743  // 0x02: CMP ecx, 0xbdbdbdbd
4744  0x81, 0xF9, 0xBD, 0xBD, 0xBD, 0xBD,
4745  // 0x08: JNZ 0x12
4746  0x75, 0x08,
4747  // 0x0A: MOV al, 0xbd
4748  0xB0, 0xBD,
4749  // 0x0C: CMP al, 0xff
4750  0x3C, 0xFF,
4751  // 0x0E: STI
4752  0xFB,
4753  // 0x0F: POP rax
4754  0x58,
4755  // 0x10: JMP 0x88
4756  0xEB, 0x76,
4757  // 0x12: CMP ecx, 0xbdbdbdbd
4758  0x81, 0xF9, 0xBD, 0xBD, 0xBD, 0xBD,
4759  // 0x18: JNZ 0x22
4760  0x75, 0x08,
4761  // 0x1A: MOV al, 0xbd
4762  0xB0, 0xBD,
4763  // 0x1C: CMP al, 0xff
4764  0x3C, 0xFF,
4765  // 0x1E: STI
4766  0xFB,
4767  // 0x1F: POP rax
4768  0x58,
4769  // 0x20: JMP 0x88
4770  0xEB, 0x66,
4771  // 0x22: CMP ecx, 0xbdbdbdbd
4772  0x81, 0xF9, 0xBD, 0xBD, 0xBD, 0xBD,
4773  // 0x28: JNZ 0x32
4774  0x75, 0x08,
4775  // 0x2A: MOV al, 0xbd
4776  0xB0, 0xBD,
4777  // 0x2C: CMP al, 0xff
4778  0x3C, 0xFF,
4779  // 0x2E: STI
4780  0xFB,
4781  // 0x2F: POP rax
4782  0x58,
4783  // 0x30: JMP 0x88
4784  0xEB, 0x56,
4785  // 0x32: CMP ecx, 0xbdbdbdbd
4786  0x81, 0xF9, 0xBD, 0xBD, 0xBD, 0xBD,
4787  // 0x38: JNZ 0x42
4788  0x75, 0x08,
4789  // 0x3A: MOV al, 0xbd
4790  0xB0, 0xBD,
4791  // 0x3C: CMP al, 0xff
4792  0x3C, 0xFF,
4793  // 0x3E: STI
4794  0xFB,
4795  // 0x3F: POP rax
4796  0x58,
4797  // 0x40: JMP 0x88
4798  0xEB, 0x46,
4799  // 0x42: CMP ecx, 0xbdbdbdbd
4800  0x81, 0xF9, 0xBD, 0xBD, 0xBD, 0xBD,
4801  // 0x48: JNZ 0x52
4802  0x75, 0x08,
4803  // 0x4A: MOV al, 0xbd
4804  0xB0, 0xBD,
4805  // 0x4C: CMP al, 0xff
4806  0x3C, 0xFF,
4807  // 0x4E: STI
4808  0xFB,
4809  // 0x4F: POP rax
4810  0x58,
4811  // 0x50: JMP 0x88
4812  0xEB, 0x36,
4813  // 0x52: CMP ecx, 0xbdbdbdbd
4814  0x81, 0xF9, 0xBD, 0xBD, 0xBD, 0xBD,
4815  // 0x58: JNZ 0x62
4816  0x75, 0x08,
4817  // 0x5A: MOV al, 0xbd
4818  0xB0, 0xBD,
4819  // 0x5C: CMP al, 0xff
4820  0x3C, 0xFF,
4821  // 0x5E: STI
4822  0xFB,
4823  // 0x5F: POP rax
4824  0x58,
4825  // 0x60: JMP 0x88
4826  0xEB, 0x26,
4827  // 0x62: CMP ecx, 0xbdbdbdbd
4828  0x81, 0xF9, 0xBD, 0xBD, 0xBD, 0xBD,
4829  // 0x68: JNZ 0x72
4830  0x75, 0x08,
4831  // 0x6A: MOV al, 0xbd
4832  0xB0, 0xBD,
4833  // 0x6C: CMP al, 0xff
4834  0x3C, 0xFF,
4835  // 0x6E: STI
4836  0xFB,
4837  // 0x6F: POP rax
4838  0x58,
4839  // 0x70: JMP 0x88
4840  0xEB, 0x16,
4841  // 0x72: CMP ecx, 0xbdbdbdbd
4842  0x81, 0xF9, 0xBD, 0xBD, 0xBD, 0xBD,
4843  // 0x78: JNZ 0x82
4844  0x75, 0x08,
4845  // 0x7A: MOV al, 0xbd
4846  0xB0, 0xBD,
4847  // 0x7C: CMP al, 0xff
4848  0x3C, 0xFF,
4849  // 0x7E: STI
4850  0xFB,
4851  // 0x7F: POP rax
4852  0x58,
4853  // 0x80: JMP 0x88
4854  0xEB, 0x06,
4855  // 0x82: STI
4856  0xFB,
4857  // 0x83: POP rax
4858  0x58,
4859  // 4 bytes of CMP [rbp], imm comes here
4860  // 0x84: JMP 0x89
4861  0xE9, 0x00, 0x00, 0x00, 0x00
4862  },
4863  .HypercallOffset = 0xFF,
4864  .RelocatedCodeOffset = 0x84,
4865  },
4866  },
4867  },
4868 
4869  {
4870  .ModuleName = u"ntoskrnl.exe",
4871  .FunctionName = "KiDisplayBlueScreen",
4872  .MinVersion = DETOUR_MIN_VERSION_ANY,
4873  .MaxVersion = DETOUR_MAX_VERSION_ANY,
4874  .Callback = IntGuestUninitOnBugcheck,
4875  .Tag = detTagCleanupMemDump,
4876  .Exported = FALSE,
4877  .NotCritical = TRUE,
4878  .DisableFlags = 0,
4879  .EnableFlags = INTRO_OPT_BUGCHECK_CLEANUP,
4880  .Arguments = DET_ARGS_DEFAULT_WIN64,
4881  .HandlersCount = 1,
4882  .Handlers =
4883  {
4884  {
4885  .MinVersion = DETOUR_MIN_VERSION_ANY,
4886  .MaxVersion = DETOUR_MAX_VERSION_ANY,
4887  .HypercallType = hypercallTypeInt3,
4888 
4889  .CodeLength = 0x8,
4890  .Code =
4891  {
4892  // 0x00: INT3
4893  0xCC,
4894  // 0x01: NOP
4895  0x90,
4896  // 0x02: NOP
4897  0x90,
4898  // 0x03: JMP 0x8
4899  0xE9, 0x00, 0x00, 0x00, 0x00
4900  },
4901  .HypercallOffset = 0x0,
4902  .RelocatedCodeOffset = 0x3,
4903  },
4904  },
4905  },
4906 
4907  {
4908  .ModuleName = u"ntoskrnl.exe",
4909  .FunctionName = "MmInSwapProcessHijack",
4910  .MinVersion = DETOUR_MIN_VERSION_ANY,
4911  .MaxVersion = DETOUR_MAX_VERSION_ANY,
4912  .Callback = IntWinProcSwapIn,
4913  .Tag = detTagProcSwapIn,
4914  .Exported = FALSE,
4915  .NotCritical = FALSE,
4916  .DisableFlags = 0,
4917  .EnableFlags = DETOUR_ENABLE_ALWAYS,
4918  .Arguments = DET_ARGS_DEFAULT_WIN64,
4919  .HandlersCount = 1,
4920  .Handlers =
4921  {
4922  {
4923  .MinVersion = DETOUR_MIN_VERSION_ANY,
4924  .MaxVersion = DETOUR_MAX_VERSION_ANY,
4925  .HypercallType = hypercallTypeInt3,
4926 
4927  .CodeLength = 0x8,
4928  .Code =
4929  {
4930  // 0x00: INT3
4931  0xCC,
4932  // 0x01: NOP
4933  0x90,
4934  // 0x02: NOP
4935  0x90,
4936  // 0x03: JMP 0x8
4937  0xE9, 0x00, 0x00, 0x00, 0x00
4938  },
4939  .HypercallOffset = 0x0,
4940  .RelocatedCodeOffset = 0x3,
4941  },
4942  },
4943  },
4944 
4945  {
4946  .ModuleName = u"ntoskrnl.exe",
4947  .FunctionName = "KiOutSwapProcessesHijack",
4948  .MinVersion = DETOUR_MIN_VERSION_ANY,
4949  .MaxVersion = DETOUR_MAX_VERSION_ANY,
4950  .PreCallback = IntWinProcPatchSwapOut64,
4951  .Callback = IntWinProcSwapOut,
4952  .Tag = detTagProcSwapOut,
4953  .Exported = FALSE,
4954  .NotCritical = FALSE,
4955  .DisableFlags = 0,
4956  .EnableFlags = DETOUR_ENABLE_ALWAYS,
4957  .Arguments = DET_ARGS_DEFAULT_WIN64,
4958  .HandlersCount = 1,
4959  .Handlers =
4960  {
4961  {
4962  .MinVersion = DETOUR_MIN_VERSION_ANY,
4963  .MaxVersion = DETOUR_MAX_VERSION_ANY,
4964  .HypercallType = hypercallTypeInt3,
4965 
4966  .CodeLength = 0x16,
4967  .Code =
4968  {
4969  // 0x00: PUSH rax
4970  0x50,
4971  // 0x01: MOV rax, QWORD PTR [rbx + _EPROCESS.Flags]
4972  0x48, 0x8B, 0x83, 0x00, 0x00, 0x00, 0x00,
4973  // 0x08: BT rax, 0x07
4974  0x48, 0x0f, 0xba, 0xe0, 0x07,
4975  // 0x0D: JNC 0x10
4976  0x73, 0x01,
4977  // 0x0F: INT3
4978  0xCC,
4979  // 0x10: POP rax
4980  0x58,
4981  // 0x11: JMP 0x16
4982  0xE9, 0x00, 0x00, 0x00, 0x00
4983  },
4984  .HypercallOffset = 0x0F,
4985  .RelocatedCodeOffset = 0x11,
4986  },
4987  },
4988  },
4989 };
4990 
4992 const size_t gHookableApisX64Size = ARRAYSIZE(gHookableApisX64);
4993 
IntWinProcPatchPspInsertProcess86
INTSTATUS IntWinProcPatchPspInsertProcess86(QWORD FunctionAddress, void *Handler, void *Descriptor)
This functions is responsible for patching the detour that handles the "PspInsertProcess".
Definition: winprocess.c:2346
IntWinVadPatchInsert
INTSTATUS IntWinVadPatchInsert(QWORD FunctionAddress, API_HOOK_HANDLER *Handler, void *Descriptor)
This is the PFUNC_PreDetourCallback for the MiInsertVad guest API detour.It will be invoked before th...
Definition: winvad.c:3770
DETOUR_ENABLE_ALWAYS
#define DETOUR_ENABLE_ALWAYS
Can be used as the API_HOOK_DESCRIPTOR.EnableFlags to always enable the detour.
Definition: detours.h:429
IntWinProcHandleInstrument
INTSTATUS IntWinProcHandleInstrument(void *Detour)
Handles an exit on NtSetInformationProcess calls where the InformationClass argument is 40 (instrumen...
Definition: winprocess.c:4433
IntWinPowHandlePowerStateChange
INTSTATUS IntWinPowHandlePowerStateChange(void *Detour)
Detour callback which is called whenever NtSetSystemPowerState is called, resulting in a hypercall to...
Definition: winpower.c:273
IntWinVadHandleInsert
INTSTATUS IntWinVadHandleInsert(void const *Detour)
The detour handler that will be invoked when the guest inserts a new VAD in the tree.This is the detour handler for the MiInsertVad guest API.
Definition: winvad.c:2825
IntWinVadHandleDeleteVaRange
INTSTATUS IntWinVadHandleDeleteVaRange(void const *Detour)
The detour handler that will be invoked when a memory range contained by a VAD is deleted...
Definition: winvad.c:3197
IntWinHandleException
INTSTATUS IntWinHandleException(void *Detour)
Handles a hardware exception triggered inside the guestThis is the detour handler for the guest KiDis...
Definition: winumcrash.c:544
IntWinVadPatchInsertMap
INTSTATUS IntWinVadPatchInsertMap(QWORD FunctionAddress, API_HOOK_HANDLER *Handler, void *Descriptor)
This is the PFUNC_PreDetourCallback for the MiGetWsAndInsertVad guest API detour.It will be invoked b...
Definition: winvad.c:3572
IntWinThrPatchThreadHijackHandler
INTSTATUS IntWinThrPatchThreadHijackHandler(QWORD FunctionAddress, void *Handler, void *Descriptor)
This functions is responsible for patching the detour that handles the "PspSetContextThreadInternal"...
Definition: winthread.c:1036
IntWinProcSwapOut
INTSTATUS IntWinProcSwapOut(void *Detour)
Detour handler for the KiOutSwapProcess Windows kernel API.The detour on KiOutSwapProcess is set afte...
Definition: winprocess.c:4318
IntWinThrHandleQueueApc
INTSTATUS IntWinThrHandleQueueApc(void *Detour)
Handles a NtQueueApcThreadEx call - blocking process injections.Asynchronous Procedure Call (APC) inj...
Definition: winthread.c:758
IntWinProcSwapIn
INTSTATUS IntWinProcSwapIn(void *Detour)
Detour handler for the MmInSwapProcess Windows kernel API.The detour on MmInSwapProcess is set inside...
Definition: winprocess.c:4214
ARRAYSIZE
#define ARRAYSIZE(A)
Definition: introdefs.h:101
IntWinVadHandleVirtualProtect
INTSTATUS IntWinVadHandleVirtualProtect(void const *Detour)
The detour handler that will be invoked when a memory range contained by a VAD has the protection rig...
Definition: winvad.c:3339
IntDriverUnloadHandler
INTSTATUS IntDriverUnloadHandler(void const *Detour)
The detour handler that will be invoked when a guest driver is unloaded.This handles driver unloading...
Definition: drivers.c:110
IntWinProcHandleTerminate
INTSTATUS IntWinProcHandleTerminate(void *Detour)
This functions handles the termination of a Windows process.This function is invoked every time "MmCl...
Definition: winprocess.c:2682
IntWinProcPrepareInstrument
INTSTATUS IntWinProcPrepareInstrument(QWORD FunctionAddress, void *Handler, void *Descriptor)
This function is responsible for patching the detour that handles "NtSetInformationProcess".
Definition: winprocess.c:4623
DETOUR_MAX_VERSION_ANY
#define DETOUR_MAX_VERSION_ANY
Specifies that the first OS version for which a detour handler is available is the latest OS version ...
Definition: detours.h:317
IntWinVadHandleCommit
INTSTATUS IntWinVadHandleCommit(void const *Detour)
The detour handler that will be invoked when an existing VAD is committed by the guest.This is the detour handler for the MiCommitExistingVad guest API. Due to the way we ignore certain VADs, this can be invoked either when protection is changed for a known VAD, in which case we have to adjust our protection; or, when protection is changed for a previously unknown VAD in a way that makes it relevant for Introcore, in which case we treat as a newly created VAD.
Definition: winvad.c:3026
hypercallTypeInt3
The detour will use a INT3 instruction in order to notify introcore about an event.
Definition: detours.h:189
gHookableApisX64Size
const size_t gHookableApisX64Size
The number of functions to be hooked for 64-bit Windows guests.
Definition: winhkhnd.c:4992
INTRO_OPT_EVENT_PROCESS_CRASH
#define INTRO_OPT_EVENT_PROCESS_CRASH
Enable application crash events (generates introEventExceptionEvent).
Definition: intro_types.h:449
IntWinPoolHandleAlloc
INTSTATUS IntWinPoolHandleAlloc(void *Detour)
Detour callback for ExAllocatePoolWithTag.Handles allocations within a Windows guest, executed using the ExAllocatePoolWithTag API. Basically, it will check the tag of the allocation, and if it identifies an allocation for a driver object or a fast I/O dispatch, it will patch the Size argument of the call so that it&#39;s almost a page. This ensures us that critical structures protected by the introspection will be allocated alone in each page, which gives us an enormous performance boost.
Definition: winpool.c:13
IntWinThrHandleThreadHijack
INTSTATUS IntWinThrHandleThreadHijack(void *Detour)
Handles a SetContextThread call - blocking thread hijacking.Thread hijacking (amongst others) is an a...
Definition: winthread.c:429
IntDriverLoadHandler
INTSTATUS IntDriverLoadHandler(void const *Detour)
The detour handler that will be invoked when a guest loads a new driver.This handles driver loading i...
Definition: drivers.c:45
IntGuestUninitOnBugcheck
INTSTATUS IntGuestUninitOnBugcheck(void const *Detour)
Prepares Introcore unload in case of a guest crash in order to clean up the code and data injected in...
Definition: introcore.c:2522
winthread.h
Exposes the functions used to provide Windows Threads related support.
gHookableApisX86Size
const size_t gHookableApisX86Size
The number of functions to be hooked for 32-bit Windows guests.
Definition: winhkhnd.c:1809
IntWinProcPatchCopyMemoryDetour
INTSTATUS IntWinProcPatchCopyMemoryDetour(QWORD FunctionAddress, void *Handler, void *Descriptor)
This functions is responsible for patching the detour that handles the "MmCopyVirtualMemory".This function is invoked every time "MmCopyVirtualMemory" is called (a process is writing/reading another process) but before the actual handler IntWinProcHandleCopyMemory, its purpose being to modify the hook code (see winhkhnd.c).
Definition: winprocess.c:2746
DETOUR_MIN_VERSION_ANY
#define DETOUR_MIN_VERSION_ANY
Specifies that the first OS version for which a detour handler is available is the first OS version s...
Definition: detours.h:314
IntWinVadPatchVirtualProtect
INTSTATUS IntWinVadPatchVirtualProtect(QWORD FunctionAddress, API_HOOK_HANDLER *Handler, void *Descriptor)
This is the PFUNC_PreDetourCallback for the MiProtectVirtualMemory guest API detour.It will be invoked before the detour is placed inside the guest and will patch the detour handler with the value of winKmFieldProcessSpare.
Definition: winvad.c:3621
winbugcheck.h
Information about Windows kernel crashes.
DET_ARGS_DEFAULT_WIN86
#define DET_ARGS_DEFAULT_WIN86
Default argument passing convention for 32-bit Windows guests.
Definition: detours.h:86
IntWinVadPatchDeleteVaRange
INTSTATUS IntWinVadPatchDeleteVaRange(QWORD FunctionAddress, API_HOOK_HANDLER *Handler, void *Descriptor)
This is the PFUNC_PreDetourCallback for the MiDeleteVirtualAddresses guest API detour.It will be invoked before the detour is placed inside the guest and will patch the detour handler with the value of winKmFieldProcessSpare.
Definition: winvad.c:3678
INTRO_OPT_ENABLE_MISC_EVENTS
#define INTRO_OPT_ENABLE_MISC_EVENTS
Aggregates all the miscellaneous protection flags.
Definition: intro_types.h:603
__section
#define __section(S)
Definition: common.h:76
TRUE
#define TRUE
Definition: intro_types.h:30
IntWinVadHandleInsertPrivate
INTSTATUS IntWinVadHandleInsertPrivate(void const *Detour)
The detour handler that will be invoked when the guest inserts a new VAD in the tree.This is the detour handler for the MiInsertPrivateVad guest API.
Definition: winvad.c:2897
IntWinVadPatchFinishVadDeletion
INTSTATUS IntWinVadPatchFinishVadDeletion(QWORD FunctionAddress, API_HOOK_HANDLER *Handler, void *Descriptor)
This is the PFUNC_PreDetourCallback for the MiFinishVadDeletion guest API detour.It will be invoked b...
Definition: winvad.c:3726
IntWinBcHandleBugCheck
INTSTATUS IntWinBcHandleBugCheck(void const *Detour)
Handles a Windows OS crash.This is the detour handle for the KeBugCheck2 32-bit Windows kernel API an...
Definition: winbugcheck.c:932
IntWinProcPatchSwapOut64
INTSTATUS IntWinProcPatchSwapOut64(QWORD FunctionAddress, void *Handler, void *Descriptor)
This functions is responsible for patching the detour that handles the "KiOutSwapProcesses".
Definition: winprocess.c:2387
IntWinPoolHandleFree
INTSTATUS IntWinPoolHandleFree(void *Detour)
Detour callback for ExFreePoolWithTag.This function handles de-allocation requests executed by the gu...
Definition: winpool.c:106
IntWinPatchVadHandleCommit
INTSTATUS IntWinPatchVadHandleCommit(QWORD FunctionAddress, API_HOOK_HANDLER *Handler, void *Descriptor)
This is the PFUNC_PreDetourCallback for the MiCommitExistingVad guest API detour.It will be invoked b...
Definition: winvad.c:2960
INTRO_OPT_ENABLE_UM_PROTECTION
#define INTRO_OPT_ENABLE_UM_PROTECTION
Aggregates all the user mode protection flags.
Definition: intro_types.h:561
IntWinVadHandleInsertMap
INTSTATUS IntWinVadHandleInsertMap(void const *Detour)
The detour handler that will be invoked when a VAD is inserted in the guest VAD tree.This is the detour handler for the MiGetWsAndInsertVad guest API.
Definition: winvad.c:3142
IntWinVadPatchInsertPrivate
INTSTATUS IntWinVadPatchInsertPrivate(QWORD FunctionAddress, API_HOOK_HANDLER *Handler, void *Descriptor)
This is the PFUNC_PreDetourCallback for the MiInsertPrivateVad guest API detour.It will be invoked be...
Definition: winvad.c:3512
IntWinVadHandleFinishVadDeletion
INTSTATUS IntWinVadHandleFinishVadDeletion(void const *Detour)
The detour handler that will be invoked when a memory range contained by a VAD is deleted...
Definition: winvad.c:3268
gHookableApisX64
API_HOOK_DESCRIPTOR gHookableApisX64[]
The functions to be hooked for 64-bit Windows guests.
Definition: winhkhnd.c:1816
IntWinProcPatchSwapOut32
INTSTATUS IntWinProcPatchSwapOut32(QWORD FunctionAddress, void *Handler, void *Descriptor)
This functions is responsible for patching the detour that handles the "KiOutSwapProcesses".
Definition: winprocess.c:2443
IntWinProcHandleCopyMemory
INTSTATUS IntWinProcHandleCopyMemory(void *Detour)
This functions is responsible handling process read/write operations.This function is invoked every t...
Definition: winprocess.c:2870
INTRO_OPT_BUGCHECK_CLEANUP
#define INTRO_OPT_BUGCHECK_CLEANUP
Enable memory cleanup after an OS crash (Windows).
Definition: intro_types.h:466
IntWinThrPrepareApcHandler
INTSTATUS IntWinThrPrepareApcHandler(QWORD FunctionAddress, void *Handler, void *Descriptor)
This functions is responsible for patching the detour that handles the "NtQueueApcThreadEx".This function is called before the hook is placed into memory in order to "patch" the addresses of guest functions or guest file offsets that are used by the hook handler. Specifically, this patches the addresses of PsThreadType, ObReferenceObjectByHandle, ObDereferenceObject and the offsets of the AttachedProcess and Process fields of _KTHREAD and the Spare field of _KPROCESS, but also patches the "retn" instruction accordingly.
Definition: winthread.c:1108
INTRO_OPT_EVENT_OS_CRASH
#define INTRO_OPT_EVENT_OS_CRASH
Enable OS crash events (generates introEventCrashEvent events).
Definition: intro_types.h:447
IntWinProcHandleCreate
INTSTATUS IntWinProcHandleCreate(void *Detour)
Detour handler for the PspInsertProcess Windows kernel API.The actual process creation is handled by ...
Definition: winprocess.c:2610
DET_ARGS_DEFAULT_WIN64
#define DET_ARGS_DEFAULT_WIN64
Default argument passing convention for 64-bit Windows guests.
Definition: detours.h:80
gHookableApisX86
API_HOOK_DESCRIPTOR gHookableApisX86[]
The functions to be hooked for 32-bit Windows guests.
Definition: winhkhnd.c:61
_API_HOOK_DESCRIPTOR
Describes a function to be hooked.
Definition: detours.h:329
FALSE
#define FALSE
Definition: intro_types.h:34