EnumCallback

forwe

1. #pragma once
   
2. #include "common.h"
   
3. 
   
4. #define PSP_MAX_CREATE_PROCESS_NOTIFY 8
   
5. 
   
6. typedef
   
7. VOID
   
8. (*PCREATE_PROCESS_NOTIFY_ROUTINE)(
   
9.                                   IN HANDLE ParentId,
   
10.                                   IN HANDLE ProcessId,
    
11.                                   IN BOOLEAN Create
    
12.                                   );
    
13. 
    
14. typedef PVOID
    
15. (*PFN_ExReferenceCallBackBlock) (
    
16.                           IN OUT PVOID CallBack
    
17.                           );
    
18. 
    
19. typedef PVOID
    
20. (*PFN_ExGetCallBackBlockRoutine) (
    
21.                            IN PVOID CallBackBlock
    
22.                            );
    
23. 
    
24. typedef PVOID
    
25. (*PFN_ExDereferenceCallBackBlock) (
    
26.                             IN OUT PVOID CallBack,
    
27.                             IN PVOID CallBackBlock
    
28.                             );
    
29. 
    
30. ULONG GetPspCreateProcessNotifyRoutineAddr();
    
31. 
    
32. ULONG GetExReferenceCallBackBlockAddr();
    
33. 
    
34. ULONG GetExGetCallBackBlockRoutineAddr();
    
35. 
    
36. ULONG GetExDereferenceCallBackBlockAddr();
    
37. 
    
38. BOOLEAN EnumProcessCallBack();

复制代码

1. #include "StdAfx.h"
   
2. #include "EnumCallback.h"
   
3. 
   
4. ULONG g_PspCreateProcessNotifyRoutine = NULL;
   
5. ULONG g_ExReferenceCallBackBlock = NULL;
   
6. ULONG g_ExGetCallBackBlockRoutine = NULL;
   
7. ULONG g_ExDereferenceCallBackBlock = NULL;
   
8. 
   
9. ULONG GetPspCreateProcessNotifyRoutineAddr()
   
10. {
    
11.     ULONG uPsSetCreateProcessNotifyRoutineAddr = (ULONG)PsSetCreateProcessNotifyRoutine;
    
12. 
    
13.     //nt!PsSetCreateProcessNotifyRoutine:
    
14.     //8062e77e 8bff            mov     edi,edi
    
15.     //8062e780 55              push    ebp
    
16.     //8062e781 8bec            mov     ebp,esp
    
17.     //8062e783 53              push    ebx
    
18.     //8062e784 33db            xor     ebx,ebx
    
19.     //8062e786 385d0c          cmp     byte ptr [ebp+0Ch],bl
    
20.     //8062e789 56              push    esi
    
21.     //8062e78a 57              push    edi
    
22.     //8062e78b 7465            je      nt!PsSetCreateProcessNotifyRoutine+0x74 (8062e7f2)
    
23.     //8062e78d bfe0245680      mov     edi,offset nt!PspCreateProcessNotifyRoutine (805624e0)
    
24.     //8062e792 57              push    edi
    
25.     //8062e793 e8487d0100      call    nt!ExReferenceCallBackBlock (806464e0)
    
26.     //8062e798 8bf0            mov     esi,eax
    
27.     //8062e79a 85f6            test    esi,esi
    
28.     PUCHAR pTemp = (PUCHAR)uPsSetCreateProcessNotifyRoutineAddr;
    
29. 
    
30.     for (int i = 0; i < 0x50; i++)
    
31.     {
    
32.         if (*(pTemp-3) == 0x74 &&
    
33.             *(pTemp-1) == 0xbf &&
    
34.             *(pTemp+4) == 0x57 &&
    
35.             *(pTemp+5) == 0xe8)
    
36.         {
    
37.             //DbgPrint("PspCreateProcessNotifyRoutine Addr: 0x%x\n", pTemp);
    
38.             g_PspCreateProcessNotifyRoutine = *(PULONG)pTemp;
    
39.             return *(PULONG)pTemp;
    
40.         }
    
41. 
    
42.         pTemp++;
    
43.     }
    
44. 
    
45.     return NULL;
    
46. }
    
47. 
    
48. ULONG GetExReferenceCallBackBlockAddr()
    
49. {
    
50.     //8062e78b 7465            je      nt!PsSetCreateProcessNotifyRoutine+0x74 (8062e7f2)
    
51.     //8062e78d bfe0245680      mov     edi,offset nt!PspCreateProcessNotifyRoutine (805624e0)
    
52.     //8062e792 57              push    edi
    
53.     //8062e793 e8487d0100      call    nt!ExReferenceCallBackBlock (806464e0)
    
54.     //8062e798 8bf0            mov     esi,eax
    
55.     //8062e79a 85f6            test    esi,esi
    
56.     //8062e79c 741f            je      nt!PsSetCreateProcessNotifyRoutine+0x3f (8062e7bd)
    
57.     //8062e79e 56              push    esi
    
58. 
    
59.     ULONG uPsSetCreateProcessNotifyRoutineAddr = (ULONG)PsSetCreateProcessNotifyRoutine;
    
60. 
    
61.     PUCHAR pTemp = (PUCHAR)uPsSetCreateProcessNotifyRoutineAddr;
    
62. 
    
63.     ULONG uAddr = NULL;
    
64. 
    
65.     for (int i = 0; i < 0x50; i++)
    
66.     {
    
67.         if (*(pTemp-2) == 0x57 &&
    
68.             *(pTemp-1) == 0xe8 &&
    
69.             *(pTemp+4) == 0x8b &&
    
70.             *(pTemp+5) == 0xf0)
    
71.         {
    
72.             uAddr = *(PULONG)pTemp + (ULONG)(pTemp-1) + 5;
    
73.             g_ExReferenceCallBackBlock = uAddr;
    
74.             DbgPrint("ExReferenceCallBackBlock Addr: 0x%x\n", uAddr);
    
75.             return uAddr;
    
76.         }
    
77. 
    
78.         pTemp++;
    
79.     }
    
80. 
    
81.     return NULL;
    
82. }
    
83. 
    
84. 
    
85. ULONG GetExGetCallBackBlockRoutineAddr()
    
86. {
    
87.     //8062e798 8bf0            mov     esi,eax
    
88.     //8062e79a 85f6            test    esi,esi
    
89.     //8062e79c 741f            je      nt!PsSetCreateProcessNotifyRoutine+0x3f (8062e7bd)
    
90.     //8062e79e 56              push    esi
    
91.     //8062e79f e8ec7b0100      call    nt!IopGetRelationsTaggedCount (80646390)     ExGetCallBackBlockRoutine
    
92.     //8062e7a4 3b4508          cmp     eax,dword ptr [ebp+8]
    
93.     //8062e7a7 750d            jne     nt!PsSetCreateProcessNotifyRoutine+0x38 (8062e7b6)
    
94.     //8062e7a9 56              push    esi
    
95.     //8062e7aa 6a00            push    0
    
96.     //8062e7ac 57              push    edi
    
97. 
    
98.     ULONG uPsSetCreateProcessNotifyRoutineAddr = (ULONG)PsSetCreateProcessNotifyRoutine;
    
99. 
    
100.     PUCHAR pTemp = (PUCHAR)uPsSetCreateProcessNotifyRoutineAddr;
     
101. 
     
102.     ULONG uAddr = NULL;
     
103. 
     
104.     for (int i = 0; i < 0x50; i++)
     
105.     {
     
106.         if (*(pTemp-2) == 0x56 &&
     
107.             *(pTemp-1) == 0xe8 &&
     
108.             *(pTemp+4) == 0x3b &&
     
109.             *(pTemp+5) == 0x45 &&
     
110.             *(pTemp+6) == 0x08)
     
111.         {
     
112.             uAddr = *(PULONG)pTemp + (ULONG)(pTemp-1) + 5;
     
113.             g_ExGetCallBackBlockRoutine = uAddr;
     
114.             DbgPrint("ExGetCallBackBlockRoutine Addr: 0x%x\n", uAddr);
     
115.             return uAddr;
     
116.         }
     
117. 
     
118.         pTemp++;
     
119.     }
     
120. 
     
121.     return NULL;
     
122. }
     
123. 
     
124. 
     
125. 
     
126. 
     
127. ULONG GetExDereferenceCallBackBlockAddr()
     
128. {
     
129.     //8062e7cd b8ffffffff      mov     eax,0FFFFFFFFh
     
130.     //8062e7d2 b900255680      mov     ecx,offset nt!PspCreateProcessNotifyRoutineCount (80562500)
     
131.     //8062e7d7 0fc101          xadd    dword ptr [ecx],eax
     
132.     //8062e7da 56              push    esi
     
133.     //8062e7db 8d049de0245680  lea     eax,nt!PspCreateProcessNotifyRoutine (805624e0)[ebx*4]
     
134.     //8062e7e2 50              push    eax
     
135.     //8062e7e3 e82b7e0100      call    nt!ExDereferenceCallBackBlock (80646613)
     
136.     //8062e7e8 56              push    esi
     
137.     //8062e7e9 e8877b0100      call    nt!ExWaitForCallBacks (80646375)
     
138.     //8062e7ee 33ff            xor     edi,edi
     
139. 
     
140.     ULONG uPsSetCreateProcessNotifyRoutineAddr = (ULONG)PsSetCreateProcessNotifyRoutine;
     
141. 
     
142.     PUCHAR pTemp = (PUCHAR)uPsSetCreateProcessNotifyRoutineAddr;
     
143. 
     
144.     ULONG uAddr = NULL;
     
145. 
     
146.     for (int i = 0; i < 0x100; i++)
     
147.     {
     
148.         if (*(pTemp-2) == 0x50 &&
     
149.             *(pTemp-1) == 0xe8 &&
     
150.             *(pTemp+4) == 0x56 &&
     
151.             *(pTemp+5) == 0xe8)
     
152.         {
     
153.             uAddr = *(PULONG)pTemp + (ULONG)(pTemp-1) + 5;
     
154.             g_ExDereferenceCallBackBlock = uAddr;
     
155.             DbgPrint("ExGetCallBackBlockRoutine Addr: 0x%x\n", uAddr);
     
156.             return uAddr;
     
157.         }
     
158. 
     
159.         pTemp++;
     
160.     }
     
161. 
     
162.     return NULL;
     
163. }
     
164. 
     
165. VOID InitNtFunction()
     
166. {
     
167.     if (NULL == g_ExReferenceCallBackBlock ||
     
168.         NULL == g_ExGetCallBackBlockRoutine ||
     
169.         NULL == g_ExDereferenceCallBackBlock ||
     
170.         NULL == g_PspCreateProcessNotifyRoutine)
     
171.     {
     
172.         GetPspCreateProcessNotifyRoutineAddr();
     
173.         GetExReferenceCallBackBlockAddr();
     
174.         GetExGetCallBackBlockRoutineAddr();
     
175.         GetExDereferenceCallBackBlockAddr();
     
176.     }
     
177. }
     
178. 
     
179. BOOLEAN EnumProcessCallBack()
     
180. {
     
181.     InitNtFunction();
     
182. 
     
183.     if (NULL == g_ExReferenceCallBackBlock ||
     
184.         NULL == g_ExGetCallBackBlockRoutine ||
     
185.         NULL == g_ExDereferenceCallBackBlock ||
     
186.         NULL == g_PspCreateProcessNotifyRoutine)
     
187.     {
     
188.         return FALSE;
     
189.     }
     
190. 
     
191.     PVOID CallBack = NULL;
     
192.     PVOID NotifyRoutine = NULL;
     
193. 
     
194.     for (int i = 0; i < PSP_MAX_CREATE_PROCESS_NOTIFY; i++)
     
195.     {
     
196. 
     
197.         //
     
198.         // Reference the callback so we can check its routine address.
     
199.         //
     
200.         CallBack = ((PFN_ExReferenceCallBackBlock)g_ExReferenceCallBackBlock) (&((PULONG)g_PspCreateProcessNotifyRoutine)[i]);
     
201. 
     
202.         if (CallBack != NULL)
     
203.         {
     
204.             NotifyRoutine = ((PFN_ExGetCallBackBlockRoutine)g_ExGetCallBackBlockRoutine) (CallBack);
     
205. 
     
206.             DbgPrint("ProcessCallBack Addr: 0x%x\n", NotifyRoutine);
     
207. 
     
208.             ((PFN_ExDereferenceCallBackBlock)g_ExDereferenceCallBackBlock) (&((PULONG)g_PspCreateProcessNotifyRoutine)[i], CallBack);
     
209. 
     
210.         }
     
211.     }
     
212. 
     
213.         return TRUE;
     
214. }

复制代码