对idt hook的处理

forwe

现在有一些驱动保护对idt中断描述符表进行了一些处理，导致我们附加游戏的时候会直接重启或者蓝屏或者游戏退出的情况。那么本篇的内容实际是对教程中的知识点进行实践的内容，看本篇前希望你们明白第二十课的内容，不然会觉得莫名其妙。

好了，我们直接步入主题。

驱动保护既然hook了idt，自然会检测它hook的位置是否恢复，和对它自身函数做crc等等。那么我们直接恢复hook是没用的，就要另想方法了。
一般比较通用的方法有两种，对段基址进行处理和用vt，本篇就是用段基址处理hook后的idt。
在第二十课的时候我说过，windows中的虚拟地址是这样的：
段基址 + 段内偏移 = 虚拟地址
一般情况下段基址是0，所以段内偏移就相当于虚拟地址了。idt中所有中断函数的段基址也是默认为零的，而驱动保护就是对段内偏移进行修改，而达到hook的作用。由于段基址是零，所以修改段内偏移就等于修改了虚拟地址。我们要想办法绕过的话，就要对段基址动手脚，因为驱动保护基本没对段基址进行检测的，如果有的话，那这种办法就失灵了。但是我一般看到的都没有.......
怎么动手脚呢，我们可以这样处理：当段内偏移改变的时候，我们让段基址跟着改变。比如原始的段基址是0，段内偏移是0x1000，虚拟地址是0x1000，那就是：
0 + 0x1000 = 0x1000;
现在驱动保护修改了段内偏移，假如变成了0x500。那么：
0 + 0x500 = 0x500;
这样就实现了hook的目的。我们要绕过，就要这样做：
? + 0x500 = 0x1000;
就是段基址为多少的时候，使驱动保护提供的段内偏移和段基址相加还是等于以前的虚拟地址。
那么狠明显，0x1000 - 0x500 = 0x500;
段基址赋值为0x500就可以了。思路很简单的，但是由于概念本身就比较多，所以很多人被卡主了。
那好，现在问题解决了，只要发现改变了段内偏移，那我们就跟着改变段基址，使：
新段基址 + 新段内偏移 = 原始的虚拟地址
只要做到这样，就可以绕过游戏的hook。
但是另外一个问题来了，当驱动保护修改了段内偏移的时候，我们如何发现段内偏移给修改了呢？
一般最简单的方法是设置个定时器，要设置的尽量小点，不断的检测是否驱动保护修改了段内偏移，是的话就马上处理段基址。
还有其他的办法就是hook比较频繁被调用的函数，然后在过滤函数中对段内偏移做判断工作。系统中频繁被调用的函数有很多很多，大家可以根据需要去hook。
因为过驱动保护的时候我们为了简单，都会使用重载内核过掉内核hook，所以都会对kifastcallentry函数做手脚。而这个函数调用是非常非常频繁的，比定时器的最小周期还要频繁。如果你hook了kifastcallentry函数，又不想使代码量变多，你可以考虑在这个函数里面判断是够段内偏移被修改了。
我就是在kifastcallentry函数里面判断的，实际最好用定时器（思路清晰）！
下面我直接上代码把，实际这些代码都是写过的，我改动的地方不超过20行！由于我只为了表达思路，所以我简单的把以前的拼凑了一下，代码难看希望大家多多谅解。

1. #ifndef _PUBLIC_H_
   
2. #define _PUBLIC_H_
   
3. 
   
4. #include "ntddk.h"
   
5. 
   
6. #define WORD    USHORT
   
7. #define DWORD   ULONG
   
8. 
   
9. #define MAKELONG(a, b)      ((LONG)(((WORD)(((DWORD_PTR)(a)) & 0xffff)) \
   
10.     | ((DWORD)((WORD)(((DWORD_PTR)(b)) & 0xffff))) << 16))
    
11. 
    
12. typedef struct _IDTR{
    
13.     USHORT   IDT_limit;
    
14.     USHORT   IDT_LOWbase;
    
15.     USHORT   IDT_HIGbase;
    
16. }IDTR,*PIDTR;
    
17. 
    
18. //idt结构定义
    
19. typedef struct _IDTENTRY
    
20. {
    
21.     unsigned short LowOffset;
    
22.     unsigned short selector;
    
23.     unsigned char retention:5;
    
24.     unsigned char zero1:3;
    
25.     unsigned char gate_type:1;
    
26.     unsigned char zero2:1;
    
27.     unsigned char interrupt_gate_size:1;
    
28.     unsigned char zero3:1;
    
29.     unsigned char zero4:1;
    
30.     unsigned char DPL:2;
    
31.     unsigned char P:1;
    
32.     unsigned short HiOffset;
    
33. } IDTENTRY,*PIDTENTRY;
    
34. 
    
35. //gdt结构定义
    
36. typedef struct _KGDTENTRY {
    
37.     USHORT  LimitLow;
    
38.     USHORT  BaseLow;
    
39.     union {
    
40.         struct {
    
41.             UCHAR   BaseMid;
    
42.             UCHAR   Flags1;     // Declare as bytes to avoid alignment
    
43.             UCHAR   Flags2;     // Problems.
    
44.             UCHAR   BaseHi;
    
45.         } Bytes;
    
46.         struct {
    
47.             ULONG   BaseMid : 8;
    
48.             ULONG   Type : 5;
    
49.             ULONG   Dpl : 2;
    
50.             ULONG   Pres : 1;
    
51. 
    
52.             ULONG   LimitHi : 4;
    
53.             ULONG   Sys : 1;
    
54.             ULONG   Reserved_0 : 1;
    
55.             ULONG   Default_Big : 1;
    
56.             ULONG   Granularity : 1;
    
57.             ULONG   BaseHi : 8;
    
58.         } Bits;
    
59.     } HighWord;
    
60. } KGDTENTRY, *PKGDTENTRY;
    
61. 
    
62. //系统服务描述表定义
    
63. #pragma pack(1)
    
64. typedef struct ServiceDescriptorEntry {
    
65.     unsigned int *ServiceTableBase;
    
66.     unsigned int *ServiceCounterTableBase; //仅适用于checked build版本
    
67.     unsigned int NumberOfServices;
    
68.     unsigned char *ParamTableBase;
    
69. } ServiceDescriptorTableEntry_t, *PServiceDescriptorTableEntry_t;
    
70. #pragma pack()
    
71. 
    
72. __declspec(dllimport) ServiceDescriptorTableEntry_t KeServiceDescriptorTable;
    
73. 
    
74. //global
    
75. USHORT g_FilterJmp[3];
    
76. ULONG  g_uOrigInterruptFunc;
    
77. 
    
78. BOOLEAN g_bHookInterrupt;
    
79. //global
    
80. ULONG   g_ntcreatefile;
    
81. ULONG   g_fastcall_hookpointer;
    
82. ULONG   g_goto_origfunc;
    
83. 
    
84. //等会儿就用它做栈回溯吧
    
85. typedef NTSTATUS
    
86. (*NTCREATEFILE) (
    
87.     __out PHANDLE FileHandle,
    
88.     __in ACCESS_MASK DesiredAccess,
    
89.     __in POBJECT_ATTRIBUTES ObjectAttributes,
    
90.     __out PIO_STATUS_BLOCK IoStatusBlock,
    
91.     __in_opt PLARGE_INTEGER AllocationSize,
    
92.     __in ULONG FileAttributes,
    
93.     __in ULONG ShareAccess,
    
94.     __in ULONG CreateDisposition,
    
95.     __in ULONG CreateOptions,
    
96.     __in_bcount_opt(EaLength) PVOID EaBuffer,
    
97.     __in ULONG EaLength
    
98.     );
    
99. 
    
100. //各种函数乱声明下:D
     
101. void PageProtectOn();
     
102. void PageProtectOff();
     
103. ULONG SearchHookPointer(ULONG StartAddress);
     
104. void __stdcall FilterInterruptFunc3();
     
105. ULONG   GetInterruptFuncAddress(ULONG InterruptIndex);
     
106. 
     
107. VOID HookInterruptFunc(ULONG InterruptIndex,ULONG NewInterruptFunc);
     
108. 
     
109. void NewInterrupt3();
     
110. 
     
111. #endif

复制代码

以上是头文件，下面才是重点：

1. #include "public.h"
   
2. 
   
3. void PageProtectOn()
   
4. {
   
5.     __asm{//恢复内存保护  
   
6.         mov  eax,cr0
   
7.         or   eax,10000h
   
8.         mov  cr0,eax
   
9.         sti
   
10.     }
    
11. }
    
12. 
    
13. void PageProtectOff()
    
14. {
    
15.     __asm{//去掉内存保护
    
16.         cli
    
17.         mov  eax,cr0
    
18.         and  eax,not 10000h
    
19.         mov  cr0,eax
    
20.     }
    
21. }
    
22. 
    
23. ULONG SearchHookPointer(ULONG StartAddress)
    
24. {
    
25.     ULONG   u_index;
    
26. 
    
27.     UCHAR   *p = (UCHAR*)StartAddress;
    
28. 
    
29.     for (u_index = 0;u_index < 200;u_index++)
    
30.     {
    
31.         if (*p==0x2B&&
    
32.             *(p+1)==0xE1&&
    
33.             *(p+2)==0xC1&&
    
34.             *(p+3)==0xE9&&
    
35.             *(p+4)==0x02)
    
36.         {
    
37.             return (ULONG)p;
    
38.         }
    
39. 
    
40.         p--;
    
41.     }
    
42. 
    
43.     return 0;
    
44. }
    
45. 
    
46. //过滤kifastcallentry函数
    
47. void FilterKiFastCallEntry(ULONG ServiceTableBase,ULONG FuncIndex)
    
48. {
    
49. //这里就是不断的检测
    
50.     HookInterruptFunc(3,(ULONG)NewInterrupt3);
    
51. }
    
52. 
    
53. __declspec(naked)
    
54. void NewKiFastCallEntry()
    
55. {
    
56.     __asm{
    
57.         pushad
    
58.         pushfd
    
59.          
    
60.         push    eax
    
61.         push    edi
    
62.         call    FilterKiFastCallEntry
    
63. 
    
64.         popfd
    
65.         popad
    
66. 
    
67.         sub     esp,ecx
    
68.         shr     ecx,2
    
69.         jmp     g_goto_origfunc
    
70.     }
    
71. }
    
72. 
    
73. void UnHookKiFastCallEntry()
    
74. {
    
75.     UCHAR   str_origfuncode[5] = {0x2B,0xE1,0xC1,0xE9,0x02};
    
76. 
    
77.     if (g_fastcall_hookpointer==0)
    
78.     {   return; }
    
79. 
    
80.     PageProtectOff();
    
81.     RtlCopyMemory((PVOID)g_fastcall_hookpointer,str_origfuncode,5);
    
82.     PageProtectOn();
    
83. }
    
84. 
    
85. void HookKiFastCallEntry(ULONG HookPointer)
    
86. {
    
87.     ULONG   u_temp;
    
88.     UCHAR   str_jmp_code[5];
    
89. 
    
90.     str_jmp_code[0] = 0xE9;
    
91. 
    
92.     u_temp = (ULONG)NewKiFastCallEntry - HookPointer - 5;
    
93.     *(ULONG*)&str_jmp_code[1] = u_temp;
    
94. 
    
95.     PageProtectOff();
    
96. 
    
97.     RtlCopyMemory((PVOID)HookPointer,str_jmp_code,5);
    
98. 
    
99.     PageProtectOn();
    
100. 
     
101. }
     
102. 
     
103. NTSTATUS NewNtCreateFile (
     
104.     __out PHANDLE FileHandle,
     
105.     __in ACCESS_MASK DesiredAccess,
     
106.     __in POBJECT_ATTRIBUTES ObjectAttributes,
     
107.     __out PIO_STATUS_BLOCK IoStatusBlock,
     
108.     __in_opt PLARGE_INTEGER AllocationSize,
     
109.     __in ULONG FileAttributes,
     
110.     __in ULONG ShareAccess,
     
111.     __in ULONG CreateDisposition,
     
112.     __in ULONG CreateOptions,
     
113.     __in_bcount_opt(EaLength) PVOID EaBuffer,
     
114.     __in ULONG EaLength
     
115.     )
     
116. {
     
117.     ULONG   u_call_retaddr;
     
118. 
     
119.     __asm{
     
120.         pushad
     
121.         mov     eax,[ebp+0x4]
     
122.         mov     u_call_retaddr,eax
     
123.         popad
     
124.     }
     
125. 
     
126.     g_fastcall_hookpointer = SearchHookPointer(u_call_retaddr);
     
127.     if (g_fastcall_hookpointer==0)
     
128.     {
     
129.         KdPrint(("search failed."));
     
130.     }else{
     
131.         KdPrint(("search success."));
     
132.     }
     
133. 
     
134.     g_goto_origfunc = g_fastcall_hookpointer + 5;
     
135.     HookKiFastCallEntry(g_fastcall_hookpointer);
     
136. 
     
137.     PageProtectOff();
     
138.     KeServiceDescriptorTable.ServiceTableBase[66] = (unsigned int)g_ntcreatefile;
     
139.     PageProtectOn();
     
140. 
     
141.     return ((NTCREATEFILE)g_ntcreatefile)(
     
142.         FileHandle,\
     
143.         DesiredAccess,\
     
144.         ObjectAttributes,\
     
145.         IoStatusBlock,\
     
146.         AllocationSize,\
     
147.         FileAttributes,\
     
148.         ShareAccess,\
     
149.         CreateDisposition,\
     
150.         CreateOptions,\
     
151.         EaBuffer,\
     
152.         EaLength);
     
153. }
     
154. 
     
155. 
     
156. void SearchKiFastCallEntry()
     
157. {
     
158. 
     
159.     g_ntcreatefile = KeServiceDescriptorTable.ServiceTableBase[66];
     
160.     PageProtectOff();
     
161.     KeServiceDescriptorTable.ServiceTableBase[66] = (unsigned int)NewNtCreateFile;
     
162.     PageProtectOn();
     
163. }
     
164. 
     
165. //////////////////////////////////////////////////////////////////////////
     
166. //////////////////////////////////////////////////////////////////////////
     
167. 
     
168. void __stdcall FilterInterrupt()
     
169. {
     
170.     KdPrint(("%s",(char*)PsGetCurrentProcess()+0x16c));
     
171. }
     
172. 
     
173. __declspec(naked)
     
174. void NewInterrupt3OfOrigBase()
     
175. {
     
176.     __asm{
     
177.         pushad
     
178.         pushfd
     
179. 
     
180.         push    fs
     
181.         push    0x30
     
182.         pop     fs
     
183. 
     
184.         call    FilterInterrupt
     
185. 
     
186.         pop     fs
     
187. 
     
188.         popfd
     
189.         popad
     
190. 
     
191.         jmp     g_uOrigInterruptFunc
     
192.     }
     
193. }
     
194. 
     
195. __declspec(naked)
     
196. void NewInterrupt3()
     
197. {
     
198.     __asm{
     
199.         jmp fword ptr[g_FilterJmp]
     
200.     }
     
201. }
     
202. 
     
203. //这个函数功能是输入一个下标，返回该下标对应的中断地址
     
204. ULONG   GetInterruptFuncAddress(ULONG InterruptIndex)
     
205. {
     
206.     IDTR        idtr;
     
207.     IDTENTRY    *pIdtEntry;
     
208. 
     
209.     __asm   SIDT    idtr;
     
210. 
     
211.     pIdtEntry = (IDTENTRY *)MAKELONG(idtr.IDT_LOWbase,idtr.IDT_HIGbase);
     
212. 
     
213.     return MAKELONG(pIdtEntry[InterruptIndex].LowOffset,pIdtEntry[InterruptIndex].HiOffset);
     
214. }
     
215. 
     
216. ULONG GetNewBase(ULONG NewInterruptFunc,ULONG OrigInterruptOffset)
     
217. {
     
218.     return (NewInterruptFunc - OrigInterruptOffset);
     
219. }
     
220. 
     
221. //这个函数负责具体的修改工作，实际这些函数我20课中都一个个写过一遍的
     
222. VOID SetInterrupt(ULONG InterruptIndex,ULONG uNewBase,BOOLEAN bIsNew)
     
223. {
     
224.     ULONG           u_fnKeSetTimeIncrement;
     
225.     UNICODE_STRING  usFuncName;
     
226.     ULONG           u_index;
     
227.     ULONG           *u_KiProcessorBlock;
     
228. 
     
229.     IDTENTRY        *pIdtEntry;
     
230.     PKGDTENTRY      pGdt;
     
231. 
     
232.     RtlInitUnicodeString(&usFuncName,L"KeSetTimeIncrement");
     
233. 
     
234.     u_fnKeSetTimeIncrement = (ULONG)MmGetSystemRoutineAddress(&usFuncName);
     
235.     if (!MmIsAddressValid((PVOID)u_fnKeSetTimeIncrement))
     
236.     {
     
237.         return;
     
238.     }
     
239. 
     
240.     u_KiProcessorBlock = *(ULONG**)(u_fnKeSetTimeIncrement + 44);
     
241. 
     
242.     u_index = 0;
     
243.     while (u_KiProcessorBlock[u_index])
     
244.     {
     
245.         pIdtEntry = *(IDTENTRY**)(u_KiProcessorBlock[u_index] - 0xE8);
     
246.         pGdt = *(PKGDTENTRY*)(u_KiProcessorBlock[u_index] - 0xE4);
     
247.          
     
248.         KdPrint(("%X-----%X",pIdtEntry,pGdt));
     
249. 
     
250.         PageProtectOff();
     
251. 
     
252.         if (bIsNew)
     
253.         {
     
254.             pIdtEntry[InterruptIndex].selector = 0xA8;
     
255.             RtlCopyMemory(&pGdt[21],&pGdt[1],sizeof(KGDTENTRY));
     
256.             pGdt[21].BaseLow = (USHORT)(uNewBase&0xffff);
     
257.             pGdt[21].HighWord.Bytes.BaseMid = (UCHAR)((uNewBase>>16)&0xff);
     
258.             pGdt[21].HighWord.Bytes.BaseHi = (UCHAR)(uNewBase>>24);
     
259.         }else{
     
260.             pIdtEntry[InterruptIndex].selector = 0x8;
     
261.             memset(&pGdt[21],0,sizeof(KGDTENTRY));
     
262.         }
     
263. 
     
264.         PageProtectOn();
     
265. 
     
266.         u_index++;
     
267.     }
     
268. }
     
269. 
     
270. //注意这个函数，我是判断段内偏移是否修改完成或者恢复完成。就是说防止修改了一半或者恢复了一半我们就进行干涉，那样会马上悲剧的......所以这个函数很重要
     
271. BOOLEAN QueryInterruptIsModify(ULONG uInterruptFunc,BOOLEAN bIsOrig)
     
272. {
     
273.     ULONG           u_fnKeSetTimeIncrement;
     
274.     UNICODE_STRING  usFuncName;
     
275.     ULONG           u_index;
     
276.     ULONG           *u_KiProcessorBlock;
     
277. 
     
278.     IDTENTRY        *pIdtEntry;
     
279.     PKGDTENTRY      pGdt;
     
280. 
     
281.     RtlInitUnicodeString(&usFuncName,L"KeSetTimeIncrement");
     
282. 
     
283.     u_fnKeSetTimeIncrement = (ULONG)MmGetSystemRoutineAddress(&usFuncName);
     
284.     if (!MmIsAddressValid((PVOID)u_fnKeSetTimeIncrement))
     
285.     {
     
286.         return FALSE;
     
287.     }
     
288. 
     
289.     u_KiProcessorBlock = *(ULONG**)(u_fnKeSetTimeIncrement + 44);
     
290. 
     
291.     u_index = 0;
     
292.     while (u_KiProcessorBlock[u_index])
     
293.     {
     
294.         pIdtEntry = *(IDTENTRY**)(u_KiProcessorBlock[u_index] - 0xE8);
     
295.         pGdt = *(PKGDTENTRY*)(u_KiProcessorBlock[u_index] - 0xE4);
     
296.          
     
297.         if (bIsOrig)
     
298.         {
     
299.             if ((uInterruptFunc>>16)!=pIdtEntry[3].HiOffset||
     
300.                 (uInterruptFunc & 0xffff)!=pIdtEntry[3].LowOffset)
     
301.             {
     
302.                 return FALSE;
     
303.             }
     
304.         }else{
     
305.             if ((uInterruptFunc>>16)==pIdtEntry[3].HiOffset||
     
306.                 (uInterruptFunc & 0xffff)==pIdtEntry[3].LowOffset)
     
307.             {
     
308.                 return FALSE;
     
309.             }
     
310.         }
     
311.         u_index++;
     
312.     }
     
313. 
     
314.     return TRUE;
     
315. }
     
316. 
     
317. //这个函数先进行查询是否被修改，段内偏移修改了的话我们就跟着修改，这里我们使用一个变量g_bHookInterrupt来标记我们是否修改过段基址
     
318. VOID HookInterruptFunc(ULONG InterruptIndex,ULONG NewInterruptFunc)
     
319. {
     
320.     ULONG   uNewBase;
     
321.     ULONG   uInterrupFunc;
     
322. 
     
323.     uInterrupFunc = GetInterruptFuncAddress(InterruptIndex);
     
324. 
     
325.     if (QueryInterruptIsModify(g_uOrigInterruptFunc,TRUE)&&
     
326.         g_bHookInterrupt==TRUE)
     
327.     {
     
328.         SetInterrupt(InterruptIndex,0,FALSE);
     
329.         g_bHookInterrupt = FALSE;
     
330.     }
     
331. 
     
332.     if (QueryInterruptIsModify(g_uOrigInterruptFunc,FALSE)&&
     
333.         g_bHookInterrupt==FALSE)
     
334.     {
     
335.         KdPrint(("hook!"));
     
336.         uNewBase = NewInterruptFunc - uInterrupFunc;
     
337. 
     
338.         *(ULONG*)g_FilterJmp = (ULONG)NewInterrupt3OfOrigBase;
     
339.         g_FilterJmp[2] = 0x8;
     
340. 
     
341.         SetInterrupt(InterruptIndex,uNewBase,TRUE);
     
342.         g_bHookInterrupt = TRUE;
     
343.     }
     
344. }
     
345. 
     
346. void UnHookInterruptFunc(ULONG InterruptIndex)
     
347. {
     
348.     SetInterrupt(InterruptIndex,0,FALSE);
     
349. }
     
350. 
     
351. VOID MyUnload(PDRIVER_OBJECT    pDriverObject)
     
352. {
     
353.     UnHookInterruptFunc(3);
     
354.     UnHookKiFastCallEntry();
     
355. }
     
356. 
     
357. NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObject,PUNICODE_STRING Reg_Path)
     
358. {
     
359.     g_bHookInterrupt = FALSE;
     
360. 
     
361.     g_uOrigInterruptFunc = GetInterruptFuncAddress(3);
     
362.      
     
363.     SearchKiFastCallEntry();
     
364.      
     
365.     SetInterrupt(3,0,FALSE);
     
366. 
     
367.     pDriverObject->DriverUnload = MyUnload;
     
368.     return STATUS_SUCCESS;
     
369. }
     
370. 
     
371. //////////////////////////////////////////////////////////////////////////
     
372. //////////////////////////////////////////////////////////////////////////

复制代码