简洁有力的纯win32的SSDT List

diddom

很棒的入门款式

纯win32的唷,有ListView且双色item

Hook地方还用红色字标示

ListS_SSDT_win32.rar (22.33 KB, 下载次数: 6)

2012-5-18 16:10 上传

点击文件名下载附件
阅读权限: 10

1. 
   
2. // SystemTool.cpp : Defines the entry point for the application.
   
3. //
   
4. 
   
5. #include "stdafx.h"
   
6. #include "resource.h"
   
7. #include <stdio.h>
   
8. #include <windows.h>   
   
9. #include <winnt.h>   
   
10. #include <WindowsX.h>   
    
11. #include <commctrl.h>   
    
12. 
    
13. #pragma comment(lib,"comctl32")
    
14. 
    
15. typedef ULONG NTSTATUS;
    
16. #define MAX_LOADSTRING 100
    
17. #define SystemModuleInformation 11   
    
18. #define ibaseDD *(PDWORD)&ibase   
    
19.       
    
20. HINSTANCE g_hInst;   
    
21. HWND hWinMain;
    
22. HWND hList;
    
23. #define ID_LISTVIEW 1001
    
24.   
    
25. #define RVATOVA(base,offset) ((PVOID)((DWORD)(base)+(DWORD)(offset)))   
    
26. #define ibaseDD *(PDWORD)&ibase   
    
27. #define STATUS_INFO_LENGTH_MISMATCH ((NTSTATUS)0xC0000004L)   
    
28. #define NT_SUCCESS(Status) ((NTSTATUS)(Status) >= 0)   
    
29.       
    
30. typedef struct
    
31. {   
    
32.         WORD    offset:12;   
    
33.         WORD    type:4;   
    
34. } IMAGE_FIXUP_ENTRY, *PIMAGE_FIXUP_ENTRY;   
    
35.       
    
36.       
    
37. typedef
    
38. ULONG
    
39. (WINAPI *ZWQUERYSYSTEMINFORMATION)
    
40. (   
    
41.         DWORD    SystemInformationClass,   
    
42.         PVOID    SystemInformation,   
    
43.         ULONG    SystemInformationLength,   
    
44.         PULONG   ReturnLength
    
45. );   
    
46. 
    
47. ZWQUERYSYSTEMINFORMATION ZwQuerySystemInformation = NULL;   
    
48.       
    
49. typedef enum _SYSDBG_COMMAND {   
    
50.         SysDbgReadVirtualMemory = 8,   
    
51.         SysDbgWriteVirtualMemory = 9,   
    
52. } SYSDBG_COMMAND, *PSYSDBG_COMMAND;   
    
53.       
    
54. typedef struct _MEMORY_CHUNKS
    
55. {   
    
56.         ULONG Address;
    
57.         PVOID Data;
    
58.         ULONG Length;
    
59. } MEMORY_CHUNKS, *PMEMORY_CHUNKS;   
    
60.       
    
61. typedef
    
62. NTSTATUS
    
63. (NTAPI * ZWSYSTEMDEBUGCONTROL)
    
64. (
    
65.         SYSDBG_COMMAND ControlCode,   
    
66.         PVOID InputBuffer,   
    
67.         ULONG InputBufferLength,   
    
68.         PVOID OutputBuffer,   
    
69.         ULONG OutputBufferLength,   
    
70.         PULONG ReturnLength
    
71. );   
    
72.       
    
73. ZWSYSTEMDEBUGCONTROL ZwSystemDebugControl = NULL;   
    
74.       
    
75. typedef struct _SYSTEM_MODULE_INFORMATION { //Information Class 11   
    
76.         ULONG    Reserved[2];   
    
77.         PVOID    Base;   
    
78.         ULONG    Size;   
    
79.         ULONG    Flags;   
    
80.         USHORT   Index;   
    
81.         USHORT   Unknown;   
    
82.         USHORT   LoadCount;   
    
83.         USHORT   ModuleNameOffset;   
    
84.         CHAR     ImageName[256];   
    
85. } SYSTEM_MODULE_INFORMATION,*PSYSTEM_MODULE_INFORMATION;   
    
86.       
    
87.       
    
88. typedef struct   
    
89. {   
    
90.         CHAR fname[100];   
    
91.         ULONG address1;   
    
92.         ULONG address2;   
    
93. } SSDT_LIST_ENTRY;   
    
94.       
    
95. SSDT_LIST_ENTRY ssdt_list[500];
    
96. 
    
97. //ssdt_list = new SSDT_LIST_ENTRY[500];
    
98. 
    
99. // Global Variables:
    
100. HINSTANCE hInst;                                                                // current instance
     
101. TCHAR szTitle[MAX_LOADSTRING];                                        // The title bar text
     
102. TCHAR szWindowClass[MAX_LOADSTRING];                        // The title bar text
     
103. 
     
104. // Foward declarations of functions included in this code module:
     
105. ATOM                                MyRegisterClass(HINSTANCE hInstance);
     
106. BOOL                                InitInstance(HINSTANCE, int);
     
107. LRESULT CALLBACK        WndProc(HWND, UINT, WPARAM, LPARAM);
     
108. LRESULT CALLBACK        About(HWND, UINT, WPARAM, LPARAM);
     
109. 
     
110. BOOL LocateNtdllEntry();
     
111. BOOL DebugPrivilege(TCHAR *PName,BOOL bEnable);
     
112. void InitListView();
     
113. void GetSSDT();
     
114. void FindExport();
     
115. 
     
116. int APIENTRY WinMain(HINSTANCE hInstance,
     
117.                      HINSTANCE hPrevInstance,
     
118.                      LPSTR     lpCmdLine,
     
119.                      int       nCmdShow)
     
120. {
     
121.         // TODO: Place code here.
     
122.         MSG msg;
     
123.         HACCEL hAccelTable;
     
124. 
     
125.         // Initialize global strings
     
126.         LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
     
127.         LoadString(hInstance, IDC_SYSTEMTOOL, szWindowClass, MAX_LOADSTRING);
     
128.         MyRegisterClass(hInstance);
     
129. 
     
130.         // Perform application initialization:
     
131.         if (!InitInstance (hInstance, nCmdShow))
     
132.         {
     
133.                 return FALSE;
     
134.         }
     
135. 
     
136.         hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_SYSTEMTOOL);
     
137. 
     
138.         // Main message loop:
     
139.         while (GetMessage(&msg, NULL, 0, 0))
     
140.         {
     
141.                 if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
     
142.                 {
     
143.                         TranslateMessage(&msg);
     
144.                         DispatchMessage(&msg);
     
145.                 }
     
146.         }
     
147. 
     
148.         //delete [] ssdt_list;
     
149.         return msg.wParam;
     
150. }
     
151. 
     
152. 
     
153. 
     
154. //
     
155. //  FUNCTION: MyRegisterClass()
     
156. //
     
157. //  PURPOSE: Registers the window class.
     
158. //
     
159. //  COMMENTS:
     
160. //
     
161. //    This function and its usage is only necessary if you want this code
     
162. //    to be compatible with Win32 systems prior to the 'RegisterClassEx'
     
163. //    function that was added to Windows 95. It is important to call this function
     
164. //    so that the application will get 'well formed' small icons associated
     
165. //    with it.
     
166. //
     
167. ATOM MyRegisterClass(HINSTANCE hInstance)
     
168. {
     
169.         WNDCLASSEX wcex;
     
170. 
     
171.         wcex.cbSize = sizeof(WNDCLASSEX);
     
172. 
     
173.         wcex.style                        = CS_HREDRAW | CS_VREDRAW;
     
174.         wcex.lpfnWndProc        = (WNDPROC)WndProc;
     
175.         wcex.cbClsExtra                = 0;
     
176.         wcex.cbWndExtra                = 0;
     
177.         wcex.hInstance                = hInstance;
     
178.         wcex.hIcon                        = LoadIcon(hInstance, (LPCTSTR)IDI_SYSTEMTOOL);
     
179.         wcex.hCursor                = LoadCursor(NULL, IDC_ARROW);
     
180.         wcex.hbrBackground        = (HBRUSH)(COLOR_WINDOW+1);
     
181.         wcex.lpszMenuName        = (LPCSTR)IDC_SYSTEMTOOL;
     
182.         wcex.lpszClassName        = szWindowClass;
     
183.         wcex.hIconSm                = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);
     
184. 
     
185.         return RegisterClassEx(&wcex);
     
186. }
     
187. 
     
188. //
     
189. //   FUNCTION: InitInstance(HANDLE, int)
     
190. //
     
191. //   PURPOSE: Saves instance handle and creates main window
     
192. //
     
193. //   COMMENTS:
     
194. //
     
195. //        In this function, we save the instance handle in a global variable and
     
196. //        create and display the main program window.
     
197. //
     
198. BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
     
199. {
     
200.         HWND hWnd;
     
201. 
     
202.         hInst = hInstance; // Store instance handle in our global variable
     
203. 
     
204.         hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
     
205.                                                 CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,
     
206.                                                 NULL, NULL, hInstance, NULL);
     
207. 
     
208.         if (!hWnd)
     
209.         {
     
210.                 return FALSE;
     
211.         }
     
212. 
     
213.         hWinMain = hWnd;
     
214. 
     
215.         ShowWindow(hWnd, nCmdShow);
     
216.         UpdateWindow(hWnd);
     
217.         return TRUE;
     
218. }
     
219. 
     
220. //
     
221. //  FUNCTION: WndProc(HWND, unsigned, WORD, LONG)
     
222. //
     
223. //  PURPOSE:  Processes messages for the main window.
     
224. //
     
225. //  WM_COMMAND        - process the application menu
     
226. //  WM_PAINT        - Paint the main window
     
227. //  WM_DESTROY        - post a quit message and return
     
228. //
     
229. //
     
230. LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
     
231. {
     
232.         int wmId, wmEvent;
     
233.         PAINTSTRUCT ps;
     
234.         HDC hdc;
     
235.         TCHAR szHello[MAX_LOADSTRING];
     
236.         LoadString(hInst, IDS_HELLO, szHello, MAX_LOADSTRING);
     
237. 
     
238.         switch (message)
     
239.         {
     
240.                 case WM_NOTIFY:   
     
241.             switch (LOWORD(wParam))   
     
242.             {   
     
243.             case ID_LISTVIEW:
     
244.                                 //LPNMHDR pnm = (LPNMHDR)lParam;   
     
245.                                 //if(pnm->hwndFrom != m_hWnd)   
     
246.                                         //SendMessage(pnm->hwndFrom,msg,wParam,lParam);
     
247. 
     
248.                                 //LPNMHDR pnm = (LPNMHDR) lParam;   
     
249.                                 //if(pnm->code == NM_CUSTOMDRAW)
     
250.                                 if(((LPNMHDR)lParam)->code == NM_CUSTOMDRAW)
     
251.                 {                    
     
252.                                         //LPNMLVCUSTOMDRAW lpLVCD = (LPNMLVCUSTOMDRAW) lParam;
     
253.                                         //switch(lpLVCD->nmcd.dwDrawStage)
     
254.                                         switch(((LPNMLVCUSTOMDRAW)lParam)->nmcd.dwDrawStage)
     
255.                     {   
     
256.                     case CDDS_PREPAINT:   
     
257.                         return CDRF_NOTIFYITEMDRAW;
     
258. 
     
259.                     case CDDS_ITEMPREPAINT:   
     
260.                         {   //設置不同顏色
     
261.                             LPNMLVCUSTOMDRAW customDraw = (LPNMLVCUSTOMDRAW) lParam;
     
262.                             customDraw->clrTextBk=customDraw->nmcd.dwItemSpec%2?RGB(250, 250, 250):RGB(0xFF, 0xFF, 0xFF);   
     
263.                                                         if (ssdt_list[customDraw->nmcd.dwItemSpec].address1 != ssdt_list[customDraw->nmcd.dwItemSpec].address2) customDraw->clrText = RGB(255, 0, 0) ;   
     
264.                             else customDraw->clrText = RGB(0, 0, 0) ;   
     
265.                             return CDRF_NEWFONT;   
     
266.                         }   
     
267.                         break;   
     
268.                     default:   
     
269.                         return CDRF_DODEFAULT;   
     
270.                     }   
     
271.                 }
     
272. 
     
273.                                 if(((LPNMHDR)lParam)->code == WM_ERASEBKGND)   
     
274.                 {
     
275.                                         int ii;
     
276.                                         ii = 0;
     
277.                                 }
     
278. 
     
279.                 break;
     
280. 
     
281.                                
     
282. 
     
283.             }   
     
284.             break;   
     
285. 
     
286.                 case WM_COMMAND:
     
287.                         wmId    = LOWORD(wParam);
     
288.                         wmEvent = HIWORD(wParam);
     
289.                         // Parse the menu selections:
     
290.                         switch (wmId)
     
291.                         {
     
292.                                 case IDM_ABOUT:
     
293.                                    DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);
     
294.                                    break;
     
295.                                 case IDM_EXIT:
     
296.                                    DestroyWindow(hWnd);
     
297.                                    break;
     
298.                                 default:
     
299.                                    return DefWindowProc(hWnd, message, wParam, lParam);
     
300.                         }
     
301.                         break;
     
302.                
     
303.                 case WM_ERASEBKGND:
     
304.                         //return TRUE;
     
305.                         break;
     
306.                
     
307.                 case WM_SIZE:
     
308.             MoveWindow(hList, 0, 0, LOWORD(lParam), HIWORD(lParam), TRUE);
     
309.                         break;
     
310. 
     
311.                 case WM_CREATE:   
     
312.             hWinMain = hWnd;   
     
313.             InitListView();   
     
314.             LocateNtdllEntry();
     
315.             FindExport();
     
316.             DebugPrivilege(SE_DEBUG_NAME,TRUE);   
     
317.             GetSSDT();   
     
318.             return 0;   
     
319.                         break;
     
320. 
     
321.                 case WM_PAINT:
     
322.                         hdc = BeginPaint(hWnd, &ps);
     
323.                         // TODO: Add any drawing code here...
     
324.                         RECT rt;
     
325.                         GetClientRect(hWnd, &rt);
     
326.                         DrawText(hdc, szHello, strlen(szHello), &rt, DT_CENTER);
     
327.                         EndPaint(hWnd, &ps);
     
328.                         break;
     
329. 
     
330.                 case WM_DESTROY:
     
331.                         PostQuitMessage(0);
     
332.                         break;
     
333. 
     
334.                 default:
     
335.                         return DefWindowProc(hWnd, message, wParam, lParam);
     
336.    }
     
337.    return 0;
     
338. }
     
339. 
     
340. // Mesage handler for about box.
     
341. LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
     
342. {
     
343.         switch (message)
     
344.         {
     
345.                 case WM_INITDIALOG:
     
346.                                 return TRUE;
     
347. 
     
348.                 case WM_COMMAND:
     
349.                         if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
     
350.                         {
     
351.                                 EndDialog(hDlg, LOWORD(wParam));
     
352.                                 return TRUE;
     
353.                         }
     
354.                         break;
     
355.         }
     
356.     return FALSE;
     
357. }
     
358. 
     
359. 
     
360. //////////////////////////////////////////////////////////////////////////
     
361. //
     
362. //  
     
363. BOOL LocateNtdllEntry()   
     
364. {   
     
365.     HMODULE ntdll_dll   = NULL;   
     
366.    
     
367.     if (!(ntdll_dll = GetModuleHandle("ntdll.dll"))) return FALSE;
     
368. 
     
369.     if (!( ZwQuerySystemInformation = (ZWQUERYSYSTEMINFORMATION)GetProcAddress(ntdll_dll, "ZwQuerySystemInformation" )))   
     
370.         return FALSE;
     
371. 
     
372.     if (!( ZwSystemDebugControl = (ZWSYSTEMDEBUGCONTROL)GetProcAddress(ntdll_dll, "ZwSystemDebugControl" )))   
     
373.         return FALSE;   
     
374.       
     
375.     return TRUE;   
     
376. }
     
377. 
     
378.    
     
379. //////////////////////////////////////////////////////////////////////////
     
380. //
     
381. //
     
382. BOOL DebugPrivilege(TCHAR *PName,BOOL bEnable)   
     
383. {   
     
384.     BOOL              fOk = FALSE;   
     
385.     HANDLE            hToken;   
     
386.     TOKEN_PRIVILEGES  tp;   
     
387.    
     
388.     if(OpenProcessToken(GetCurrentProcess(),TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,&hToken))   
     
389.     {         
     
390.         tp.PrivilegeCount           = 1;   
     
391.         tp.Privileges[0].Attributes = bEnable ? SE_PRIVILEGE_ENABLED : 0;   
     
392.         LookupPrivilegeValue(NULL,PName,&tp.Privileges[0].Luid);   
     
393.         AdjustTokenPrivileges(hToken,FALSE,&tp,sizeof(TOKEN_PRIVILEGES),NULL,NULL);   
     
394.         fOk=(GetLastError() == ERROR_SUCCESS);         
     
395.         CloseHandle(hToken);   
     
396.     }   
     
397.     return fOk;   
     
398. }   
     
399. 
     
400. 
     
401. //////////////////////////////////////////////////////////////////////////
     
402. //
     
403. //
     
404. DWORD GetHeaders(PCHAR ibase,   
     
405.                  PIMAGE_FILE_HEADER *pfh,   
     
406.                  PIMAGE_OPTIONAL_HEADER *poh,   
     
407.                  PIMAGE_SECTION_HEADER *psh)   
     
408.    
     
409. {   
     
410.     PIMAGE_DOS_HEADER mzhead = (PIMAGE_DOS_HEADER)ibase;   
     
411.    
     
412.     if ((mzhead->e_magic != IMAGE_DOS_SIGNATURE) || (ibaseDD[mzhead->e_lfanew] != IMAGE_NT_SIGNATURE))   
     
413.         return FALSE;   
     
414.    
     
415.     *pfh = (PIMAGE_FILE_HEADER)&ibase[mzhead->e_lfanew];
     
416. 
     
417.     if (((PIMAGE_NT_HEADERS)*pfh)->Signature != IMAGE_NT_SIGNATURE)   
     
418.         return FALSE;
     
419. 
     
420.     *pfh = (PIMAGE_FILE_HEADER)((PBYTE)*pfh + sizeof(IMAGE_NT_SIGNATURE));   
     
421.    
     
422.     *poh = (PIMAGE_OPTIONAL_HEADER)((PBYTE)*pfh + sizeof(IMAGE_FILE_HEADER));
     
423. 
     
424.     if ((*poh)->Magic != IMAGE_NT_OPTIONAL_HDR32_MAGIC)   
     
425.         return FALSE;
     
426.    
     
427.     *psh = (PIMAGE_SECTION_HEADER)((PBYTE)*poh + sizeof(IMAGE_OPTIONAL_HEADER));   
     
428.        
     
429.         return TRUE;
     
430. 
     
431. }   
     
432.    
     
433.    
     
434. //////////////////////////////////////////////////////////////////////////
     
435. //
     
436. //
     
437. void FindExport()
     
438. {   
     
439.     PIMAGE_FILE_HEADER                        pfh;   
     
440.     PIMAGE_OPTIONAL_HEADER                poh;   
     
441.     PIMAGE_SECTION_HEADER                psh;   
     
442.     PIMAGE_EXPORT_DIRECTORY                ped;
     
443. 
     
444.     DWORD*        arrayOfFunctionNames;   
     
445.     DWORD*        arrayOfFunctionAddresses;   
     
446.     WORD*        arrayOfFunctionOrdinals;   
     
447.     DWORD        functionOrdinal;
     
448.         DWORD        functionAddress;   
     
449. 
     
450.     HMODULE hNtdll = GetModuleHandle(TEXT("ntdll.dll"));
     
451. 
     
452.     GetHeaders((PCHAR)hNtdll, &pfh, &poh, &psh);
     
453. 
     
454.     if (poh->DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress)   
     
455.     {   
     
456.         ped = (PIMAGE_EXPORT_DIRECTORY)(poh->DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress + (BYTE*)hNtdll);   
     
457.         
     
458.                 arrayOfFunctionNames = (DWORD*)(ped->AddressOfNames + (BYTE*)hNtdll);
     
459. 
     
460.         arrayOfFunctionAddresses = (DWORD*)((BYTE*)hNtdll + ped->AddressOfFunctions);
     
461. 
     
462.         arrayOfFunctionNames = (DWORD*)((BYTE*)hNtdll + ped->AddressOfNames);
     
463. 
     
464.         arrayOfFunctionOrdinals = (WORD*)((BYTE*)hNtdll + ped->AddressOfNameOrdinals);   
     
465.                   
     
466.         for (int i=0; i < ped->NumberOfNames; i++)   
     
467.         {   
     
468.             char* fun_name = (char*)((BYTE*)hNtdll + arrayOfFunctionNames[i]);
     
469.                        
     
470.             functionOrdinal = arrayOfFunctionOrdinals[i] + ped->Base - 1;
     
471.                        
     
472.             functionAddress = (DWORD)((BYTE*)hNtdll + arrayOfFunctionAddresses[functionOrdinal]);
     
473.                        
     
474.             if (fun_name[0] == 'N' && fun_name[1] == 't')   
     
475.             {   
     
476.                 WORD number = *((WORD*)(functionAddress + 1));
     
477.                                
     
478.                 if (number>ped->NumberOfNames) continue;
     
479.                                
     
480.                 lstrcpy(ssdt_list[number].fname, fun_name);   
     
481.             }   
     
482.         }   
     
483.     }   
     
484. }   
     
485. 
     
486. 
     
487. //////////////////////////////////////////////////////////////////////////
     
488. //
     
489. //
     
490. DWORD FindKiServiceTable(HMODULE hModule, DWORD dwKSDT)   
     
491. {   
     
492.     PIMAGE_FILE_HEADER                        pfh;   
     
493.     PIMAGE_OPTIONAL_HEADER                poh;   
     
494.     PIMAGE_SECTION_HEADER                psh;   
     
495.     PIMAGE_BASE_RELOCATION                pbr;   
     
496.     PIMAGE_FIXUP_ENTRY                        pfe;   
     
497.       
     
498.     DWORD    dwFixups = 0, i, dwPointerRva, dwPointsToRva, dwKiServiceTable;   
     
499.     BOOL     bFirstChunk;   
     
500.       
     
501.     GetHeaders((PCHAR)hModule, &pfh, &poh, &psh);   
     
502.       
     
503.     // loop thru relocs to speed up the search   
     
504.     if ((poh->DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress) &&   
     
505.         (!((pfh->Characteristics)&IMAGE_FILE_RELOCS_STRIPPED)))
     
506.         {   
     
507.            
     
508.         pbr = (PIMAGE_BASE_RELOCATION) RVATOVA(poh->DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress, hModule);   
     
509.            
     
510.         bFirstChunk = TRUE;
     
511.                
     
512.         // 1st IMAGE_BASE_RELOCATION.VirtualAddress of ntoskrnl is 0   
     
513.         while (bFirstChunk || pbr->VirtualAddress)
     
514.                 {   
     
515.             bFirstChunk = FALSE;   
     
516.                
     
517.             pfe=(PIMAGE_FIXUP_ENTRY)((DWORD)pbr+sizeof(IMAGE_BASE_RELOCATION));   
     
518.                
     
519.             for (i=0; i < (pbr->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION)) >> 1; i++, pfe++)
     
520.                         {   
     
521.                 if (pfe->type == IMAGE_REL_BASED_HIGHLOW)
     
522.                                 {   
     
523.                     dwFixups++;
     
524. 
     
525.                     dwPointerRva = pbr->VirtualAddress + pfe->offset;
     
526. 
     
527.                     // DONT_RESOLVE_DLL_REFERENCES flag means relocs aren't fixed   
     
528.                     dwPointsToRva = *(PDWORD)((DWORD)hModule+dwPointerRva)-(DWORD)poh->ImageBase;   
     
529.                        
     
530.                     // does this reloc point to KeServiceDescriptorTable.Base?   
     
531.                     if (dwPointsToRva == dwKSDT)
     
532.                                         {   
     
533.                         // check for mov [mem32],imm32. we are trying to find   
     
534.                         // "mov ds:_KeServiceDescriptorTable.Base, offset _KiServiceTable"   
     
535.                         // from the KiInitSystem.   
     
536.                         if (*(PWORD)((DWORD)hModule + dwPointerRva-2) == 0x05c7)
     
537.                                                 {   
     
538.                             // should check for a reloc presence on KiServiceTable here   
     
539.                             // but forget it   
     
540.                             dwKiServiceTable = *(PDWORD)((DWORD)hModule + dwPointerRva + 4) - poh->ImageBase;   
     
541.                             return dwKiServiceTable;   
     
542.                         }   
     
543.                     }   
     
544.                        
     
545.                 }   
     
546.                         // should never get here   
     
547.             }
     
548. 
     
549.             *(PDWORD)&pbr += pbr->SizeOfBlock;   
     
550.         }   
     
551.     }      
     
552.       
     
553.     return 0;   
     
554. }   
     
555.    
     
556. DWORD    dwKSDT;              // rva of KeServiceDescriptorTable   
     
557. DWORD    dwKiServiceTable;    // rva of KiServiceTable   
     
558. DWORD    dwKernelBase, dwServices = 0;   
     
559. 
     
560. //////////////////////////////////////////////////////////////////////////
     
561. //
     
562. //  
     
563. void GetSSDT()   
     
564. {        
     
565.     HMODULE                                        hKernel;   
     
566.     PCHAR                                        pKernelName;   
     
567.     PDWORD                                        pService;   
     
568.     PIMAGE_FILE_HEADER                pfh;   
     
569.     PIMAGE_OPTIONAL_HEADER  poh;   
     
570.     PIMAGE_SECTION_HEADER   psh;
     
571.     ULONG n;   
     
572.       
     
573. 
     
574.     // get system modules - ntoskrnl is always first there   
     
575.     ZwQuerySystemInformation(SystemModuleInformation, &n, 0, &n);
     
576.        
     
577.     PULONG p = new ULONG[n];
     
578. 
     
579.     ZwQuerySystemInformation(SystemModuleInformation, p, n * sizeof(*p), 0);
     
580.        
     
581.     PSYSTEM_MODULE_INFORMATION module = PSYSTEM_MODULE_INFORMATION(p+1);   
     
582.    
     
583.     // imagebase   
     
584.     dwKernelBase = (DWORD)module->Base;
     
585.        
     
586.         USHORT ofs = module->ModuleNameOffset;
     
587. 
     
588.         char* imgName = (char*)module->ImageName;
     
589. 
     
590.         pKernelName = ofs + imgName;
     
591.     // filename - it may be renamed in the boot.ini   
     
592.     pKernelName = module->ModuleNameOffset + module->ImageName;   
     
593.       
     
594.     // map ntoskrnl - hopefully it has relocs   
     
595.     hKernel = LoadLibraryEx(pKernelName, 0, DONT_RESOLVE_DLL_REFERENCES);
     
596.        
     
597.     if(!hKernel) {   
     
598.         return;   
     
599.     }   
     
600.       
     
601.     // our own export walker is useless here - we have GetProcAddress :)   
     
602.     if (!(dwKSDT = (DWORD)GetProcAddress(hKernel, "KeServiceDescriptorTable"))) {   
     
603.         return;   
     
604.     }   
     
605.       
     
606.     // get KeServiceDescriptorTable rva   
     
607.     dwKSDT -= (DWORD)hKernel;
     
608. 
     
609.     // find KiServiceTable   
     
610.     if (!(dwKiServiceTable = FindKiServiceTable(hKernel, dwKSDT))) {
     
611.         return;   
     
612.     }   
     
613.       
     
614.     // let's dump KiServiceTable contents   
     
615.       
     
616.     // MAY FAIL!!!   
     
617.     // should get right ServiceLimit here, but this is trivial in the kernel mode   
     
618.     GetHeaders((PCHAR)hKernel, &pfh, &poh, &psh);
     
619. 
     
620.     dwServices = 0;   
     
621.    
     
622.     for (pService = (PDWORD)((DWORD)hKernel+dwKiServiceTable);
     
623.                 *pService - poh->ImageBase < poh->SizeOfImage;   
     
624.                 pService++, dwServices++)   
     
625.     {   
     
626.         ssdt_list[dwServices].address1 = *pService - poh->ImageBase + dwKernelBase;   
     
627.     }
     
628. 
     
629.     FreeLibrary(hKernel);
     
630. 
     
631.     MEMORY_CHUNKS QueryBuff;
     
632. 
     
633.     DWORD *address2 = new DWORD[dwServices];
     
634. 
     
635.     QueryBuff.Address = dwKernelBase+dwKiServiceTable;
     
636. 
     
637.     QueryBuff.Data = address2;
     
638. 
     
639.     QueryBuff.Length = sizeof(DWORD)*dwServices;
     
640.        
     
641.     DWORD ReturnLength;
     
642. 
     
643.     ZwSystemDebugControl(
     
644.                 SysDbgReadVirtualMemory,   
     
645.         &QueryBuff, sizeof(MEMORY_CHUNKS), NULL,   
     
646.         0, &ReturnLength);   
     
647.       
     
648.     LV_ITEM lvi;
     
649. 
     
650.     lvi.mask = LVIF_TEXT;
     
651. 
     
652.     char tmp[10];
     
653. 
     
654.     ListView_DeleteAllItems(hList);
     
655. 
     
656.     for (int j=0; j < dwServices; j++)   
     
657.     {   
     
658.         lvi.iItem = j;   
     
659.         lvi.iSubItem = 0;   
     
660.         lvi.pszText = tmp;
     
661. 
     
662.         wsprintf(tmp, "0x%02X", j);
     
663. 
     
664.         ListView_InsertItem(hList, &lvi);
     
665. 
     
666.         ListView_SetItemText(hList, j, 1, ssdt_list[j].fname);
     
667. 
     
668.         wsprintf(tmp, "0x%08X", ssdt_list[j].address1);
     
669. 
     
670.         ListView_SetItemText(hList, j, 2, tmp);
     
671. 
     
672.         wsprintf(tmp,"0x%08X", address2[j]);
     
673. 
     
674.         ssdt_list[j].address2 = address2[j];
     
675. 
     
676.         ListView_SetItemText(hList, j, 3, tmp);  
     
677. 
     
678.         for(int i=0; i < *p; i++)
     
679.         {   
     
680.             if (ssdt_list[j].address2 > (DWORD)module[i].Base&&ssdt_list[j].address2 < (DWORD)module[i].Base+module[i].Size)   
     
681.             {   
     
682.                 ListView_SetItemText(hList, j, 4, module[i].ImageName);   
     
683.                 break;   
     
684.             }   
     
685.         }   
     
686.     }   
     
687.       
     
688.     delete [] p;   
     
689.     delete [] address2;   
     
690. }
     
691. 
     
692. 
     
693. void InitListView()   
     
694. {
     
695.         INITCOMMONCONTROLSEX iex;
     
696.         iex.dwSize = sizeof(iex);   
     
697.         iex.dwICC=ICC_LISTVIEW_CLASSES;   
     
698.         InitCommonControlsEx(&iex);
     
699. 
     
700.     hList = CreateWindowEx(WS_EX_CLIENTEDGE, WC_LISTVIEW, NULL,   
     
701.         WS_CHILD | WS_VISIBLE | LVS_REPORT | LVS_SINGLESEL | LVS_SHAREIMAGELISTS,   
     
702.         0, 0, 0, 0, hWinMain, (HMENU)ID_LISTVIEW, g_hInst, NULL);
     
703. 
     
704.     SendMessage(hList, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT | LVS_EX_HEADERDRAGDROP | LVS_EX_GRIDLINES);   
     
705. 
     
706.         LV_COLUMN lvc;
     
707. 
     
708.     lvc.mask = LVCF_TEXT | LVCF_WIDTH ;   
     
709.     lvc.fmt = LVCFMT_RIGHT;   
     
710. 
     
711.         lvc.pszText = "No.";
     
712.         lvc.cx = 50;   
     
713.         SendMessage(hList, LVM_INSERTCOLUMN, 0, (LPARAM)&lvc);   
     
714.            
     
715.         lvc.mask |= LVCF_FMT;
     
716.         lvc.fmt = LVCFMT_LEFT;
     
717.            
     
718.         lvc.pszText = "Function Name";
     
719.         lvc.cx = 350;   
     
720.         SendMessage(hList, LVM_INSERTCOLUMN, 1, (LPARAM)&lvc);
     
721. 
     
722.         lvc.pszText = "OrgAddr";
     
723.         lvc.cx = 100;   
     
724.         SendMessage(hList, LVM_INSERTCOLUMN, 2, (LPARAM)&lvc);   
     
725. 
     
726.         lvc.pszText = "HookAddr";   
     
727.         lvc.cx = 100;   
     
728.         SendMessage(hList, LVM_INSERTCOLUMN, 3, (LPARAM)&lvc);   
     
729. 
     
730.         lvc.pszText = "Module";
     
731.         lvc.cx = 200;
     
732.         SendMessage(hList, LVM_INSERTCOLUMN, 4, (LPARAM)&lvc);
     
733. }   
     
734.       
     

复制代码