枚举进程、线程创建回调，枚举映像加载回调，枚举DPC时钟

forwe

Driver.h

1. #ifdef __cplusplus
   
2. extern "C"
   
3. {
   
4. #endif
   
5. #include <ntddk.h>
   
6. NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath);
   
7. 
   
8. #ifdef __cplusplus
   
9. }
   
10. #endif
    
11. 
    
12. #define PAGEDCODE code_seg("PAGE")
    
13. #define LOCKEDCODE code_seg()
    
14. #define INITCODE code_seg("INIT")
    
15. 
    
16. #define PAGEDDATA data_seg("PAGE")
    
17. #define LOCKEDDATA data_seg()
    
18. #define INITDATA data_seg("INIT")
    
19. 
    
20. #define arraysize(p) (sizeof(p)/sizeof((p)[0]))
    
21. 
    
22. VOID DriverUnload(IN PDRIVER_OBJECT DriverObject);
    
23. 
    
24. VOID MyCreateProcessNotifyRoutine(
    
25.                                                                   IN HANDLE  ParentId,
    
26.                                                                   IN HANDLE  ProcessId,
    
27.                                                                   IN BOOLEAN  Create
    
28.                                                                   );
    
29. 
    
30. VOID MyCreateThreadNotifyRoutine(
    
31.                                                                   IN HANDLE  ProcessId,
    
32.                                                                   IN HANDLE  ThreadId,
    
33.                                                                   IN BOOLEAN  Create
    
34.                                                                   );
    
35. 
    
36. VOID MyLoadImageNotifyRoutine(
    
37.                                                            IN PUNICODE_STRING  FullImageName,
    
38.                                                            IN HANDLE  ProcessId, // where image is mapped
    
39.                                                            IN PIMAGE_INFO  ImageInfo
    
40.                                                            );
    
41. 
    
42. typedef PVOID (*pExReferenceCallBackBlock) (PVOID CallBack);
    
43. typedef PVOID (*pExGetCallBackBlockRoutine) (PVOID CallBackBlock);
    
44. typedef VOID (*pExDereferenceCallBackBlock) (PVOID CallBack, PVOID CallBackBlock);
    
45. 
    
46. BOOLEAN GetNotifyRoutineAddr();
    
47. void EnumNotifyRoutine(ULONG uNotifyRoutineAddr);
    
48. 
    
49. ULONG GetKiTimerTableListHeadAddr();
    
50. void EnumDpcTimer();

复制代码

Driver.cpp

1. #include "Driver.h"
   
2. 
   
3. ULONG g_uPspCreateProcessNotifyRoutineAddr = 0;
   
4. ULONG g_uPspCreateThreadNotifyRoutineAddr = 0;
   
5. ULONG g_uPspLoadImageNotifyRoutineAddr = 0;
   
6. 
   
7. ULONG g_uKiTimerTableListHeadAddr = 0;
   
8. 
   
9. pExReferenceCallBackBlock g_pfnExReferenceCallBackBlock = NULL;
   
10. pExGetCallBackBlockRoutine g_pfnExGetCallBackBlockRoutine = NULL;
    
11. pExDereferenceCallBackBlock g_pfnExDereferenceCallBackBlock = NULL;
    
12. 
    
13. BOOLEAN GetNotifyRoutineAddr()
    
14. {
    
15.         ULONG uAddr = (ULONG)PsSetCreateProcessNotifyRoutine;
    
16.        
    
17.         PUCHAR p = (PUCHAR)uAddr;
    
18.         ULONG i = 0;
    
19.         BOOLEAN bFind = FALSE;
    
20. 
    
21.         while(i < 0x50)
    
22.         {
    
23.                 if (*p == 0xbf
    
24.                         && *(p + 5) == 0x57
    
25.                         && *(p + 6) == 0xe8
    
26.                         && *(p - 2) == 0x74)
    
27.                 {
    
28.                         bFind = TRUE;
    
29.                         break;
    
30.                 }
    
31.                 i++;
    
32.                 p++;
    
33.         }
    
34.        
    
35.         if (!bFind)
    
36.         {
    
37.                 KdPrint(("Find g_uPspCreateProcessNotifyRoutineAddr faile!\n"));
    
38.                 return FALSE;
    
39.         }
    
40. 
    
41.         g_uPspCreateProcessNotifyRoutineAddr = *(PULONG)(p + 1);
    
42. 
    
43.        
    
44.         p = (PUCHAR)uAddr;
    
45.         i = 0;
    
46.         bFind = FALSE;
    
47. 
    
48.         while(i < 0x100)
    
49.         {
    
50.                 if (*p == 0xe8
    
51.                         && *(p + 5) == 0x8b
    
52.                         && *(p + 6) == 0xf0
    
53.                         && *(p - 1) == 0x57)
    
54.                 {
    
55.                         bFind = TRUE;
    
56.                         break;
    
57.                 }
    
58.                 i++;
    
59.                 p++;
    
60.         }
    
61. 
    
62.         if (!bFind)
    
63.         {
    
64.                 KdPrint(("Find uExReferenceCallBackBlockAddr faile!\n"));
    
65.                 return FALSE;
    
66.         }
    
67.        
    
68.         ULONG uExReferenceCallBackBlockAddr = (ULONG)(*(PULONG)(p + 1) + p + 5);
    
69. 
    
70. 
    
71.         p = (PUCHAR)uAddr;
    
72.         i = 0;
    
73.         bFind = FALSE;
    
74. 
    
75.         while(i < 0x100)
    
76.         {
    
77.                 if (*p == 0xe8
    
78.                         && *(p + 5) == 0x3b
    
79.                         && *(p + 6) == 0x45
    
80.                         && *(p - 1) == 0x56)
    
81.                 {
    
82.                         bFind = TRUE;
    
83.                         break;
    
84.                 }
    
85.                 i++;
    
86.                 p++;
    
87.         }
    
88. 
    
89.         if (!bFind)
    
90.         {
    
91.                 KdPrint(("Find uExGetCallBackBlockRoutineAddr faile!\n"));
    
92.                 return FALSE;
    
93.         }
    
94. 
    
95.         ULONG uExGetCallBackBlockRoutineAddr = (ULONG)(*(PULONG)(p + 1) + p + 5);
    
96. 
    
97. 
    
98.         p = (PUCHAR)uAddr;
    
99.         i = 0;
    
100.         bFind = FALSE;
     
101. 
     
102.         while(i < 0x100)
     
103.         {
     
104.                 if (*p == 0xe8
     
105.                         && *(p + 5) == 0x43
     
106.                         && *(p + 6) == 0x83
     
107.                         && *(p - 1) == 0x57)
     
108.                 {
     
109.                         bFind = TRUE;
     
110.                         break;
     
111.                 }
     
112.                 i++;
     
113.                 p++;
     
114.         }
     
115. 
     
116.         if (!bFind)
     
117.         {
     
118.                 KdPrint(("Find uExDereferenceCallBackBlockAddr faile!\n"));
     
119.                 return FALSE;
     
120.         }
     
121. 
     
122.         ULONG uExDereferenceCallBackBlockAddr = (ULONG)(*(PULONG)(p + 1) + p + 5);
     
123. 
     
124.         g_pfnExReferenceCallBackBlock = (pExReferenceCallBackBlock)uExReferenceCallBackBlockAddr;
     
125.         g_pfnExGetCallBackBlockRoutine = (pExGetCallBackBlockRoutine)uExGetCallBackBlockRoutineAddr;
     
126.         g_pfnExDereferenceCallBackBlock = (pExDereferenceCallBackBlock)uExDereferenceCallBackBlockAddr;
     
127. 
     
128. 
     
129. 
     
130.         uAddr = (ULONG)PsRemoveCreateThreadNotifyRoutine;
     
131. 
     
132.         p = (PUCHAR)uAddr;
     
133.         i = 0;
     
134.         bFind = FALSE;
     
135. 
     
136.         while(i < 0x50)
     
137.         {
     
138.                 if (*p == 0xbf
     
139.                         && *(p + 5) == 0x57
     
140.                         && *(p + 6) == 0xe8
     
141.                         && *(p - 2) == 0x33)
     
142.                 {
     
143.                         bFind = TRUE;
     
144.                         break;
     
145.                 }
     
146.                 i++;
     
147.                 p++;
     
148.         }
     
149. 
     
150.         if (!bFind)
     
151.         {
     
152.                 KdPrint(("Find g_uPspCreateThreadNotifyRoutineAddr faile!\n"));
     
153.                 return FALSE;
     
154.         }
     
155.        
     
156.         g_uPspCreateThreadNotifyRoutineAddr = *(PULONG)(p + 1);
     
157. 
     
158. 
     
159.         uAddr = (ULONG)PsRemoveLoadImageNotifyRoutine;
     
160. 
     
161.         p = (PUCHAR)uAddr;
     
162.         i = 0;
     
163.         bFind = FALSE;
     
164. 
     
165.         while(i < 0x50)
     
166.         {
     
167.                 if (*p == 0xbf
     
168.                         && *(p + 5) == 0x57
     
169.                         && *(p + 6) == 0xe8
     
170.                         && *(p - 2) == 0x33)
     
171.                 {
     
172.                         bFind = TRUE;
     
173.                         break;
     
174.                 }
     
175.                 i++;
     
176.                 p++;
     
177.         }
     
178. 
     
179.         if (!bFind)
     
180.         {
     
181.                 KdPrint(("Find g_uPspLoadImageNotifyRoutineAddr faile!\n"));
     
182.                 return FALSE;
     
183.         }
     
184. 
     
185.         g_uPspLoadImageNotifyRoutineAddr = *(PULONG)(p + 1);
     
186. 
     
187. 
     
188.         return TRUE;
     
189. }
     
190. 
     
191. void EnumNotifyRoutine(ULONG uNotifyRoutineAddr)
     
192. {
     
193.         if (uNotifyRoutineAddr == 0
     
194.                 || g_pfnExReferenceCallBackBlock == NULL
     
195.                 || g_pfnExGetCallBackBlockRoutine == NULL
     
196.                 || g_pfnExDereferenceCallBackBlock == NULL)
     
197.         {
     
198.                 return;
     
199.         }
     
200. 
     
201.         for (ULONG i = 0; i < 8; i++)
     
202.         {
     
203.                 PVOID CallBack = g_pfnExReferenceCallBackBlock((PVOID)&((PULONG)uNotifyRoutineAddr)[i]);
     
204. 
     
205.                 if (CallBack != NULL)
     
206.                 {
     
207.                         PVOID NotifyRoutine = g_pfnExGetCallBackBlockRoutine(CallBack);
     
208.                         if (NotifyRoutine != NULL)
     
209.                         {
     
210.                                 KdPrint(("NotifyRoutine : 0x%08x\n", NotifyRoutine));
     
211.                                 g_pfnExDereferenceCallBackBlock((PVOID)&((PULONG)uNotifyRoutineAddr)[i], CallBack);
     
212.                         }
     
213.                 }
     
214.         }
     
215. }
     
216. 
     
217. VOID MyCreateProcessNotifyRoutine(
     
218.     IN HANDLE  ParentId,
     
219.     IN HANDLE  ProcessId,
     
220.     IN BOOLEAN  Create
     
221.     )
     
222. {
     
223.         KdPrint(("MyCreateProcessNotifyRoutine\n"));
     
224.         return;
     
225. }
     
226. 
     
227. VOID MyCreateThreadNotifyRoutine(
     
228.                                                                  IN HANDLE  ProcessId,
     
229.                                                                  IN HANDLE  ThreadId,
     
230.                                                                  IN BOOLEAN  Create
     
231.                                                                  )
     
232. {
     
233.         KdPrint(("MyCreateThreadNotifyRoutine\n"));
     
234.         return;
     
235. }
     
236. 
     
237. VOID MyLoadImageNotifyRoutine(
     
238.                                                           IN PUNICODE_STRING  FullImageName,
     
239.                                                           IN HANDLE  ProcessId, // where image is mapped
     
240.                                                           IN PIMAGE_INFO  ImageInfo
     
241.                                                           )
     
242. {
     
243.         KdPrint(("MyLoadImageNotifyRoutine\n"));
     
244.         return;
     
245. }
     
246. 
     
247. 
     
248. 
     
249. ULONG GetKiTimerTableListHeadAddr()
     
250. {
     
251.         UNICODE_STRING ustrFuncName;
     
252.         RtlInitUnicodeString(&ustrFuncName, L"KeUpdateSystemTime");
     
253. 
     
254.         PVOID pfn = MmGetSystemRoutineAddress(&ustrFuncName);
     
255.         if (pfn == NULL)
     
256.         {
     
257.                 return 0;
     
258.         }
     
259. 
     
260.         ULONG uAddr = (ULONG)pfn;
     
261. 
     
262. 
     
263.         PUCHAR p = (PUCHAR)uAddr;
     
264.         ULONG i = 0;
     
265.         BOOLEAN bFind = FALSE;
     
266. 
     
267.         while(i < 0x200)
     
268.         {
     
269.                 if (*p == 0x8d
     
270.                         && *(p + 1) == 0x0c
     
271.                         && *(p + 2) == 0xc5
     
272.                         && *(p - 5) == 0x25)
     
273.                 {
     
274.                         bFind = TRUE;
     
275.                         break;
     
276.                 }
     
277.                 i++;
     
278.                 p++;
     
279.         }
     
280. 
     
281.         if (!bFind)
     
282.         {
     
283.                 KdPrint(("Find faile!\n"));
     
284.                 return 0;
     
285.         }
     
286. 
     
287.         uAddr = *(PULONG)(p + 3);
     
288. 
     
289.         return uAddr;
     
290. }
     
291. 
     
292. void EnumDpcTimer()
     
293. {
     
294.         PLIST_ENTRY ListHead;
     
295.         PLIST_ENTRY NextEntry;
     
296.         PKTIMER NextTimer;
     
297.         ULONG uDpcAddr;
     
298. 
     
299.         for (ULONG i = 0; i < 0x100; i++)
     
300.         {
     
301.                 ListHead = (PLIST_ENTRY)(&((PLIST_ENTRY)g_uKiTimerTableListHeadAddr)[i]);
     
302. 
     
303.                 if (!MmIsAddressValid(ListHead->Blink))
     
304.                 {
     
305.                         continue;
     
306.                 }
     
307. 
     
308.                 if (!MmIsAddressValid(ListHead->Flink))
     
309.                 {
     
310.                         continue;
     
311.                 }
     
312. 
     
313.                 NextEntry = ListHead->Blink;
     
314. 
     
315.                 while (NextEntry != ListHead)
     
316.                 {
     
317.                         NextTimer = CONTAINING_RECORD(NextEntry, KTIMER, TimerListEntry);
     
318. 
     
319.                         if (NextEntry->Blink == NextEntry->Flink)
     
320.                         {
     
321.                                 break;
     
322.                         }
     
323. 
     
324.                         if (MmIsAddressValid(NextTimer)
     
325.                                 && MmIsAddressValid(NextTimer->Dpc)
     
326.                                 && MmIsAddressValid(NextTimer->Dpc->DeferredRoutine)
     
327.                                 && MmIsAddressValid(&NextTimer->Period))
     
328.                         {
     
329.                                         uDpcAddr = (ULONG)NextTimer->Dpc->DeferredRoutine;
     
330.                                         ULONG uTimer = NextTimer->Period / 1000;
     
331.                                         KdPrint(("uDpcAddr : 0x%08x %d\n", uDpcAddr, uTimer));
     
332.                         }
     
333.                
     
334.                         if (!MmIsAddressValid(NextEntry->Blink))
     
335.                         {
     
336.                                 break;
     
337.                         }
     
338.                         NextEntry = NextEntry->Blink;
     
339.                 }
     
340. 
     
341.         }
     
342. 
     
343.        
     
344. }
     
345. 
     
346. 
     
347. 
     
348. #pragma INITCODE
     
349. NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
     
350. {
     
351.     NTSTATUS status = STATUS_SUCCESS;
     
352. 
     
353.         PsSetCreateProcessNotifyRoutine(MyCreateProcessNotifyRoutine, FALSE);
     
354.         PsSetCreateThreadNotifyRoutine(MyCreateThreadNotifyRoutine);
     
355.         PsSetLoadImageNotifyRoutine(MyLoadImageNotifyRoutine);
     
356. 
     
357.         if (GetNotifyRoutineAddr())
     
358.         {
     
359.                 EnumNotifyRoutine(g_uPspCreateProcessNotifyRoutineAddr);
     
360.                 EnumNotifyRoutine(g_uPspCreateThreadNotifyRoutineAddr);
     
361.                 EnumNotifyRoutine(g_uPspLoadImageNotifyRoutineAddr);
     
362.         }
     
363. 
     
364. 
     
365. 
     
366.         g_uKiTimerTableListHeadAddr = GetKiTimerTableListHeadAddr();
     
367.         if (g_uKiTimerTableListHeadAddr != 0)
     
368.         {
     
369.                 EnumDpcTimer();
     
370.         }
     
371. 
     
372.     DriverObject->DriverUnload = DriverUnload;
     
373.     return status;
     
374. }
     
375. 
     
376. #pragma PAGEDCODE
     
377. VOID DriverUnload(IN PDRIVER_OBJECT DriverObject)
     
378. {
     
379.   
     
380.         PsSetCreateProcessNotifyRoutine(MyCreateProcessNotifyRoutine, TRUE);
     
381.         PsRemoveCreateThreadNotifyRoutine(MyCreateThreadNotifyRoutine);
     
382.         PsRemoveLoadImageNotifyRoutine(MyLoadImageNotifyRoutine);
     
383. 
     
384.     KdPrint(("DriverEntry unLoading...\n"));
     
385.    
     
386. }

复制代码