hook IDT

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. #define WORD USHORT
    
12. #define DWORD ULONG
    
13. #define MAKELONG(a, b) ((LONG)(((WORD)(((DWORD_PTR)(a)) & 0xffff)) | ((DWORD)((WORD)(((DWORD_PTR)(b)) & 0xffff))) << 16))
    
14. 
    
15. #pragma pack(push)
    
16. #pragma pack(1) // 1字节对齐
    
17. typedef struct _IDTR //IDT基址
    
18. {
    
19.         USHORT IDT_limit; //范围占位
    
20.         USHORT IDT_LOWbase;//基地址占位_IDT_ENTRY类型指针
    
21.         USHORT IDT_HIGbase;
    
22. }IDTR,*PIDTR;
    
23. 
    
24. typedef struct _IDT_ENTRY
    
25. {
    
26.         USHORT LowOffset; //中断处理函数地址低位
    
27.         USHORT selector;
    
28.         UCHAR  reserved;
    
29.         UCHAR  type:4;         //4位
    
30.         UCHAR  always0:1;        //1位
    
31.         UCHAR  dpl:2;                //2位
    
32.         UCHAR  present:1;        //1位
    
33.         USHORT HigOffset;//中断处理函数地址高位
    
34. }IDTENTRY,*PIDTENTRY;//获取基址实际上是这个类型
    
35. #pragma pack(pop)
    
36. 
    
37. 
    
38. typedef KAFFINITY (*KESETAFFINITYTHREAD)(
    
39.     __inout PKTHREAD Thread,
    
40.     __in KAFFINITY Affinity
    
41.     );
    
42. 
    
43. //Global
    
44. ULONG g_InterruptFunc3;
    
45. 
    
46. 
    
47. void PageProtectOn()
    
48. {
    
49.         //恢复内存保护
    
50.         __asm
    
51.         {
    
52.                 mov eax, cr0
    
53.                         or eax, 10000h
    
54.                         mov cr0, eax
    
55.                         sti
    
56.         }
    
57. }
    
58. 
    
59. void PageProtectOff()
    
60. {
    
61.         //去掉内存保护
    
62.         __asm
    
63.         {
    
64.                 cli
    
65.                         mov eax, cr0
    
66.                         and eax, not 10000h
    
67.                         mov cr0, eax
    
68.         }
    
69. }
    
70. 
    
71. 
    
72. #pragma PAGEDCODE
    
73. VOID GetIdt()
    
74. {
    
75.         IDTR idtr;
    
76. 
    
77.         ULONG uIndex;
    
78.         PIDTENTRY pIdt_Entry;
    
79. 
    
80.         __asm
    
81.         {
    
82.                 SIDT idtr;
    
83.         }
    
84. 
    
85.         KdPrint(("%d\n", idtr.IDT_limit));
    
86. 
    
87.         pIdt_Entry = (PIDTENTRY)MAKELONG(idtr.IDT_LOWbase, idtr.IDT_HIGbase);
    
88.         KdPrint(("%X\n", pIdt_Entry));
    
89. 
    
90.         for (uIndex = 0; uIndex <= idtr.IDT_limit / sizeof(IDTENTRY); uIndex++)
    
91.         {
    
92.                 KdPrint(("pIdt_Entry[%d]:%X", uIndex, MAKELONG(pIdt_Entry[uIndex].LowOffset, pIdt_Entry[uIndex].HigOffset)));
    
93.         }
    
94. }
    
95. 
    
96. #pragma PAGEDCODE
    
97. ULONG GetInterruptFuncAddress(ULONG InterruptIndex)
    
98. {
    
99.         IDTR idtr;
    
100.         PIDTENTRY pIdtEntry;
     
101. 
     
102.         __asm SIDT idtr;
     
103. 
     
104.         pIdtEntry = (PIDTENTRY)MAKELONG(idtr.IDT_LOWbase, idtr.IDT_HIGbase);
     
105. 
     
106.         return MAKELONG(pIdtEntry[InterruptIndex].LowOffset, pIdtEntry[InterruptIndex].HigOffset);
     
107. }
     
108. 
     
109. VOID __stdcall FilterInterruptFunc3()
     
110. {
     
111.         KdPrint(("CurrentProcess:%s\n", (char*)PsGetCurrentProcess() + 0x174));
     
112. }
     
113. 
     
114. __declspec(naked) void NewInterruptFun3()
     
115. {
     
116.         __asm
     
117.         {
     
118.                 pushad
     
119.                 pushfd
     
120.                 push fs
     
121. 
     
122.                 push 0x30
     
123.                 pop fs
     
124.                 mov ax, 0x23
     
125.                 mov ds, ax
     
126.                 mov es, ax
     
127.                 call FilterInterruptFunc3
     
128. 
     
129.                 pop fs
     
130.                 popfd
     
131.                 popad
     
132. 
     
133.                 jmp g_InterruptFunc3
     
134.         }
     
135. }
     
136. 
     
137. #pragma PAGEDCODE
     
138. void HookInterrupt(ULONG InterruptIndex, ULONG NewInterruptFunc)
     
139. {
     
140.         ULONG Index, Affinity, CurrentAffinity;
     
141.         ULONG fnKeSetAffinityThread;
     
142.         ULONG * pKiProcessorBlock;
     
143.         UNICODE_STRING usFuncName;
     
144.         ULONG kPrcb;
     
145. 
     
146.         PIDTENTRY pIdtEntry;
     
147. 
     
148. 
     
149.         RtlInitUnicodeString(&usFuncName,L"KeSetAffinityThread");
     
150. 
     
151.         fnKeSetAffinityThread = (ULONG)MmGetSystemRoutineAddress(&usFuncName);
     
152. 
     
153.         if (!MmIsAddressValid((PVOID)fnKeSetAffinityThread))
     
154.         {
     
155.                 return;
     
156.         }
     
157. 
     
158. 
     
159.         Affinity = KeQueryActiveProcessors();
     
160. 
     
161.         CurrentAffinity = 1;
     
162.         Index = 0;
     
163.         while(Affinity)
     
164.         {
     
165.                 Affinity &= ~CurrentAffinity;
     
166.                 ((KESETAFFINITYTHREAD)fnKeSetAffinityThread)((PKTHREAD)PsGetCurrentThread(),(KAFFINITY)CurrentAffinity);
     
167.                 CurrentAffinity <<= 1;
     
168. 
     
169.                 __asm
     
170.                 {
     
171.                         push eax
     
172.                         mov         eax,fs:[0x20]
     
173.                         mov         kPrcb,eax
     
174.                         pop         eax
     
175.                 }
     
176. 
     
177.                 pKiProcessorBlock = &kPrcb;
     
178.                 pIdtEntry = *(PIDTENTRY*)(pKiProcessorBlock[Index] - 0xe8);
     
179.                 KdPrint(("pIdtEntry:%X\n", pIdtEntry));
     
180. 
     
181.                 PageProtectOff();
     
182.        
     
183.                 pIdtEntry[InterruptIndex].LowOffset =(USHORT)((ULONG)NewInterruptFunc & 0xffff);
     
184.                 pIdtEntry[InterruptIndex].HigOffset = (USHORT)((ULONG)NewInterruptFunc >> 16);
     
185. 
     
186.                 PageProtectOn();
     
187. 
     
188.                 Index++;
     
189.         }
     
190. 
     
191.         KdPrint(("Index:%d\n", Index));
     
192.         return;
     
193. }
     
194. 
     
195. 
     
196. 
     
197. #pragma PAGEDCODE
     
198. VOID MyDriverUnload(IN PDRIVER_OBJECT pDriverObject)
     
199. {
     
200.         HookInterrupt(3, g_InterruptFunc3);
     
201. 
     
202.         KdPrint(("DriverEntry unLoading...\n"));
     
203. 
     
204. }
     
205. 
     
206. 
     
207. 
     
208. #pragma INITCODE
     
209. NTSTATUS DriverEntry(IN PDRIVER_OBJECT pDriverObject, IN PUNICODE_STRING RegistryPath)
     
210. {
     
211.         NTSTATUS status = STATUS_SUCCESS;
     
212.        
     
213.         g_InterruptFunc3 = GetInterruptFuncAddress(3);
     
214. 
     
215.         HookInterrupt(3, (ULONG)NewInterruptFun3);
     
216.        
     
217.         pDriverObject->DriverUnload = MyDriverUnload;
     
218.         return status;
     
219. }

复制代码