隐藏 IDT Hook （段基址 + 段内偏移）

forwe

1. #include "ntddk.h"
   
2. 
   
3. #define PAGEDCODE code_seg("PAGE")
   
4. #define LOCKEDCODE code_seg()
   
5. #define INITCODE code_seg("INIT")
   
6. 
   
7. #define PAGEDDATA data_seg("PAGE")
   
8. #define LOCKEDDATA data_seg()
   
9. #define INITDATA data_seg("INIT")
   
10. 
    
11. 
    
12. #define WORD USHORT
    
13. #define DWORD ULONG
    
14. #define MAKELONG(a, b) ((LONG)(((WORD)(((DWORD_PTR)(a)) & 0xffff)) | ((DWORD)((WORD)(((DWORD_PTR)(b)) & 0xffff))) << 16))
    
15. 
    
16. #pragma pack(push)
    
17. #pragma pack(1) // 1字节对齐
    
18. typedef struct _IDTR //IDT基址
    
19. {
    
20.         USHORT IDT_limit; //范围占位
    
21.         USHORT IDT_LOWbase;//基地址占位_IDT_ENTRY类型指针
    
22.         USHORT IDT_HIGbase;
    
23. }IDTR,*PIDTR;
    
24. 
    
25. typedef struct _IDT_ENTRY
    
26. {
    
27.         USHORT LowOffset; //中断处理函数地址低位
    
28.         USHORT selector;
    
29.         UCHAR  reserved;
    
30.         UCHAR  type:4;         //4位
    
31.         UCHAR  always0:1;        //1位
    
32.         UCHAR  dpl:2;                //2位
    
33.         UCHAR  present:1;        //1位
    
34.         USHORT HigOffset;//中断处理函数地址高位
    
35. }IDTENTRY,*PIDTENTRY;//获取基址实际上是这个类型
    
36. 
    
37. typedef struct _KGDTENTRY
    
38. {
    
39.         USHORT  LimitLow;
    
40.         USHORT  BaseLow;
    
41.         union {
    
42.                 struct {
    
43.                         UCHAR   BaseMid;
    
44.                         UCHAR   Flags1;     // Declare as bytes to avoid alignment
    
45.                         UCHAR   Flags2;     // Problems.
    
46.                         UCHAR   BaseHi;
    
47.                 } Bytes;
    
48.                 struct {
    
49.                         ULONG   BaseMid : 8;
    
50.                         ULONG   Type : 5;
    
51.                         ULONG   Dpl : 2;
    
52.                         ULONG   Pres : 1;
    
53.                         ULONG   LimitHi : 4;
    
54.                         ULONG   Sys : 1;
    
55.                         ULONG   Reserved_0 : 1;
    
56.                         ULONG   Default_Big : 1;
    
57.                         ULONG   Granularity : 1;
    
58.                         ULONG   BaseHi : 8;
    
59.                 } Bits;
    
60.         } HighWord;
    
61. } KGDTENTRY, *PKGDTENTRY;
    
62. #pragma pack(pop)
    
63. 
    
64. 
    
65. typedef KAFFINITY (*KESETAFFINITYTHREAD)(
    
66.         __inout PKTHREAD Thread,
    
67.         __in KAFFINITY Affinity
    
68.         );
    
69. 
    
70. //global
    
71. USHORT g_FilterJmp[3];
    
72. ULONG g_OrigInterruptFunc3;
    
73. 
    
74. 
    
75. void PageProtectOn()
    
76. {
    
77.         //恢复内存保护
    
78.         __asm
    
79.         {
    
80.                 mov eax, cr0
    
81.                         or eax, 10000h
    
82.                         mov cr0, eax
    
83.                         sti
    
84.         }
    
85. }
    
86. 
    
87. void PageProtectOff()
    
88. {
    
89.         //去掉内存保护
    
90.         __asm
    
91.         {
    
92.                 cli
    
93.                         mov eax, cr0
    
94.                         and eax, not 10000h
    
95.                         mov cr0, eax
    
96.         }
    
97. }
    
98. 
    
99. VOID __stdcall FilterInterruptFunc3()
    
100. {
     
101.         KdPrint(("CurrentProcess:%s\n", (char*)PsGetCurrentProcess() + 0x174));
     
102. }
     
103. 
     
104. __declspec(naked)void NewInterrupt3OfOrigBase()
     
105. {
     
106.         __asm
     
107.         {
     
108.                 pushad
     
109.                 pushfd
     
110.                 push fs
     
111. 
     
112.                 push 0x30
     
113.                 pop fs
     
114.                 mov ax, 0x23
     
115.                 mov ds, ax
     
116.                 mov es, ax
     
117.                 call FilterInterruptFunc3
     
118. 
     
119.                 pop fs
     
120.                 popfd
     
121.                 popad
     
122. 
     
123.                 jmp g_OrigInterruptFunc3
     
124.         }
     
125. }
     
126. 
     
127. __declspec(naked) void NewInterrupt3()
     
128. {
     
129.         __asm
     
130.         {
     
131.                 jmp fword ptr [g_FilterJmp]
     
132.         }
     
133. }
     
134. 
     
135. 
     
136. #pragma PAGEDCODE
     
137. ULONG GetInterruptFuncAddress(ULONG InterruptIndex)
     
138. {
     
139.         IDTR idtr;
     
140.         PIDTENTRY pIdtEntry;
     
141. 
     
142.         __asm SIDT idtr;
     
143. 
     
144.         pIdtEntry = (PIDTENTRY)MAKELONG(idtr.IDT_LOWbase, idtr.IDT_HIGbase);
     
145. 
     
146.         return MAKELONG(pIdtEntry[InterruptIndex].LowOffset, pIdtEntry[InterruptIndex].HigOffset);
     
147. }
     
148. 
     
149. 
     
150. #pragma PAGEDCODE
     
151. void SetInterrupt(ULONG InterruptIndex, ULONG uNewBase, BOOLEAN bIsNew)
     
152. {
     
153.         ULONG Index, Affinity, CurrentAffinity;
     
154.         ULONG fnKeSetAffinityThread;
     
155.         ULONG *pKiProcessorBlock;
     
156.         UNICODE_STRING usFuncName;
     
157.         ULONG kPrcb;
     
158. 
     
159.         PIDTENTRY pIdtEntry;
     
160.         PKGDTENTRY pGdt;
     
161. 
     
162. 
     
163.         RtlInitUnicodeString(&usFuncName,L"KeSetAffinityThread");
     
164. 
     
165.         fnKeSetAffinityThread = (ULONG)MmGetSystemRoutineAddress(&usFuncName);
     
166. 
     
167.         if (!MmIsAddressValid((PVOID)fnKeSetAffinityThread))
     
168.         {
     
169.                 return;
     
170.         }
     
171. 
     
172. 
     
173.         Affinity = KeQueryActiveProcessors();
     
174. 
     
175.         CurrentAffinity = 1;
     
176.         Index = 0;
     
177.         while(Affinity)
     
178.         {
     
179.                 Affinity &= ~CurrentAffinity;
     
180.                 ((KESETAFFINITYTHREAD)fnKeSetAffinityThread)((PKTHREAD)PsGetCurrentThread(),(KAFFINITY)CurrentAffinity);
     
181.                 CurrentAffinity <<= 1;
     
182. 
     
183.                 __asm
     
184.                 {
     
185.                         push eax
     
186.                         mov  eax,fs:[0x20]
     
187.                         mov  kPrcb,eax
     
188.                         pop  eax
     
189.                 }
     
190. 
     
191.                
     
192.                 pKiProcessorBlock = &kPrcb;
     
193.                
     
194.                
     
195.                 //KdPrint(("pKiProcessorBlock[%d]:%X\n", Index, *(ULONG*)(pKiProcessorBlock[Index] - 0xe8)));
     
196.                 //KdPrint(("pKiProcessorBlock[%d]:%X\n", Index, *(ULONG*)(pKiProcessorBlock[Index] - 0xe4)));
     
197.                
     
198.                
     
199.                
     
200.                 pIdtEntry = *(PIDTENTRY*)(pKiProcessorBlock[Index] - 0xe8);
     
201.                 KdPrint(("pIdtEntry:%X\n", pIdtEntry));
     
202. 
     
203.                 pGdt = *(PKGDTENTRY*)(pKiProcessorBlock[Index] - 0xe4);
     
204.                 KdPrint(("pGdt:%X--%X--%X--%X\n", pGdt, pGdt[1].BaseLow, pGdt[1].HighWord.Bits.BaseMid, pGdt[1].HighWord.Bits.BaseHi));
     
205. 
     
206. 
     
207.                 PageProtectOff();
     
208. 
     
209.                 if (bIsNew)
     
210.                 {
     
211.                         pIdtEntry[InterruptIndex].selector = 168;
     
212.                         RtlCopyMemory(&pGdt[21], &pGdt[1], sizeof(KGDTENTRY));
     
213.                         pGdt[21].BaseLow = (USHORT) (uNewBase & 0xffff);
     
214.                         pGdt[21].HighWord.Bytes.BaseMid = (UCHAR)((uNewBase >> 16) & 0xff);
     
215.                         pGdt[21].HighWord.Bytes.BaseHi = (UCHAR)(uNewBase >> 24);
     
216.                 }
     
217.                 else
     
218.                 {
     
219.                         pIdtEntry[InterruptIndex].selector = 8;
     
220.                         memset(&pGdt[21], 0, sizeof(KGDTENTRY));
     
221.                 }
     
222. 
     
223.                 PageProtectOn();
     
224.        
     
225. 
     
226.                 Index++;
     
227.         }
     
228. 
     
229.         KdPrint(("Index:%d\n", Index));
     
230.         return;
     
231. }
     
232. 
     
233. #pragma PAGEDCODE
     
234. void HookInterruptFunc(ULONG InterruptIndex, ULONG NewInterruptFunc)
     
235. {
     
236.         ULONG uNewBase;
     
237. 
     
238.         g_OrigInterruptFunc3 = GetInterruptFuncAddress(InterruptIndex);
     
239.         uNewBase = NewInterruptFunc - g_OrigInterruptFunc3;
     
240. 
     
241.         *(ULONG*)g_FilterJmp = (ULONG)NewInterrupt3OfOrigBase;
     
242.         g_FilterJmp[2] = 0x8;
     
243. 
     
244.         SetInterrupt(InterruptIndex, uNewBase, TRUE);
     
245. }
     
246. 
     
247. #pragma PAGEDCODE
     
248. void UnHookInterruptFunc(ULONG InterruptIndex)
     
249. {
     
250.         SetInterrupt(InterruptIndex, 0, FALSE);
     
251. }
     
252. 
     
253. #pragma PAGEDCODE
     
254. VOID MyDriverUnload(IN PDRIVER_OBJECT pDriverObject)
     
255. {
     
256. 
     
257.         UnHookInterruptFunc(3);
     
258.         KdPrint(("DriverEntry unLoading...\n"));
     
259. 
     
260. }
     
261. 
     
262. 
     
263. #pragma INITCODE
     
264. NTSTATUS DriverEntry(IN PDRIVER_OBJECT pDriverObject, IN PUNICODE_STRING RegistryPath)
     
265. {
     
266.         NTSTATUS status = STATUS_SUCCESS;
     
267. 
     
268.         HookInterruptFunc(3, (ULONG)NewInterrupt3);
     
269. 
     
270.         pDriverObject->DriverUnload = MyDriverUnload;
     
271.         return status;
     
272. }

复制代码