纯驱动恢复SSDT

天道酬勤

*  SDT恢复是一个古老的技术了,这些天复习以前的知识,发现东西都忘了.正好找到了这份源码.
*  于是开始边注释边复习起来. 现在终于又把RING3下恢复SSDT的东西温习了一下,感觉很充实.
*  偶很菜,一开始看代码的时候,不知道如何下手,因为原作者的代码风格很乱,看得糊涂.于是偶
*  按照 M$ 的代码风格重新注释了一遍,方便以后温习. 如果你还木有看过这份源码的话,在偶注释
*  的基础上应该会理解的更快些了.
*  
*  搜索了下坛子,发现没有关于这份源码的相关细节.于是偶来补充下.
*  存档的主要目的是方便以后学习这些知识的同学更快的找到资源,少走弯路. 老鸟飘过~
*
* Description:
*  
*  在RING3获得 \device\physicalmemory 的读写权限(前提必须是Administrator). 从磁盘读取
*  ntoskrnl.exe,对齐后映射进内存(这需要我们自己来做),在其EAT中得到KeServiceDescriptorTable
*  相对于ntoskrnl.exe的偏移.把系统高端加载的ntoskrnl.exe 的SSDT地址映射到进程的虚拟地址空间里
*  推算出ServiseTable的地址后,把其所有内容映射到进程的虚拟地址空间里. 得到了ServiseTable的地址
*  但它里面的函数是否被HOOK过,并不知道.所以需要参照我们自己映射的ntoskrnl.exe中的ServiseTable
*  里函数的偏移来作比较.不相同,则被HOOK了,然后恢复之.
头文件

1. 
   
2. 
   
3. #ifndef GLOBAL_NATIVE_API_DEF_SUDAMI
   
4. #define GLOBAL_NATIVE_API_DEF_SUDAMI
   
5. 
   
6. #ifdef __cplusplus
   
7. extern "C" {
   
8. #endif
   
9. 
   
10. ////////////////////////////////////////////////////////////////////////
    
11. ////////////////////////////////////////////////////////////////////////
    
12. 
    
13. typedef long NTSTATUS, *PNTSTATUS;
    
14. 
    
15. typedef unsigned long DWORD;
    
16. typedef DWORD * PDWORD;
    
17. typedef unsigned long ULONG;
    
18. typedef unsigned long ULONG_PTR;
    
19. typedef ULONG *PULONG;
    
20. typedef unsigned short WORD;
    
21. typedef unsigned char BYTE;
    
22. typedef unsigned char UCHAR;
    
23. typedef unsigned short USHORT;
    
24. typedef void *PVOID;
    
25. typedef int BOOL;
    
26. typedef BYTE BOOLEAN;
    
27. 
    
28. 
    
29. #define NT_SUCCESS(Status)                            ((NTSTATUS)(Status) >= 0)
    
30. #define STATUS_SUCCESS                                        0x00000000
    
31. #define STATUS_UNSUCCESSFUL                                0xC0000001
    
32. #define STATUS_NOT_IMPLEMENTED          0xC0000002
    
33. #define STATUS_INFO_LENGTH_MISMATCH     0xC0000004
    
34. #define STATUS_INVALID_PARAMETER                0xC000000D
    
35. #define STATUS_ACCESS_DENIED                        0xC0000022
    
36. #define STATUS_BUFFER_TOO_SMALL                        0xC0000023
    
37. #define STATUS_IO_DEVICE_ERROR          ((NTSTATUS) 0xC0000185)
    
38. #define OBJ_KERNEL_HANDLE                                0x00000200
    
39. 
    
40. #ifndef  LOWORD
    
41. #define LOWORD(l)           ((unsigned short)(unsigned int)(l))
    
42. #endif
    
43. 
    
44. #ifndef HIWORD
    
45. #define HIWORD(l)           ((unsigned short)((((unsigned int)(l)) >> 16) & 0xFFFF))
    
46. #endif
    
47. 
    
48. // 定义ioctl相关的，用于R3和R0间的通信
    
49. #ifndef MAKELONG
    
50. #define MAKELONG(a, b) ((LONG) (((WORD) (a)) | ((DWORD) ((WORD) (b))) << 16))
    
51. #endif
    
52. 
    
53. #define MY_DEVICE_TYPE                 0x0000AA71   // 这地方可以自己改
    
54. #define DRIVER_IO(code)         CTL_CODE (MY_DEVICE_TYPE, code, METHOD_BUFFERED, FILE_ANY_ACCESS)
    
55. 
    
56. typedef LARGE_INTEGER PHYSICAL_ADDRESS, *PPHYSICAL_ADDRESS;
    
57. 
    
58. 
    
59. /////////////////////////////////////////////////////////////////         --          --     
    
60. //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//     --     -      -     --
    
61. //+                                                           +//     --      -   -       --
    
62. //+                      结构体声明                           +//      --       -        --  
    
63. //+                                                           +//       -     sudami     -   
    
64. //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//        --            --   
    
65. /////////////////////////////////////////////////////////////////          --        --      
    
66. //                                                                           --    --        
    
67. //                                                                              --   
    
68. 
    
69. #ifndef  ANSI_STRING
    
70. typedef struct _STRING {
    
71.   USHORT  Length;
    
72.   USHORT  MaximumLength;
    
73.   PCHAR  Buffer;
    
74. } ANSI_STRING, *PANSI_STRING;
    
75. #endif
    
76. 
    
77. #ifndef  UNICODE_STRING
    
78. typedef struct _UNICODE_STRING {
    
79.   USHORT  Length;
    
80.   USHORT  MaximumLength;
    
81.   PWSTR  Buffer;
    
82. } UNICODE_STRING, *PUNICODE_STRING;
    
83. #endif
    
84. 
    
85. /* SSDT */
    
86. #pragma pack(1)
    
87. typedef struct ServiceDescriptorEntry {
    
88.         unsigned int        *ServiceTableBase;
    
89.         unsigned int        *ServiceCounterTableBase;
    
90.         unsigned int        NumberOfServices;
    
91.         unsigned char   *ParamTableBase;
    
92. } ServiceDescriptorTableEntry_t, *PServiceDescriptorTableEntry_t;
    
93. 
    
94. typedef struct ServiceDescriptorShadowEntry {
    
95.         unsigned int        *Win32kTableBase;
    
96.         unsigned int        *Win32kCounterTableBase;
    
97.         unsigned int        NumberofWin32kServices;
    
98.         unsigned char   *Win32kParamTableBase;
    
99. } ServiceDescriptorTableShadowEntry_t, *PServiceDescriptorTableShadowEntry_t;
    
100. #pragma pack()
     
101. 
     
102. __declspec(dllimport)  ServiceDescriptorTableEntry_t    KeServiceDescriptorTable;
     
103. PServiceDescriptorTableShadowEntry_t                                        KeServiceDescriptorTableShadow;
     
104. 
     
105. // OBJECT_ATTRIBUTES
     
106. typedef struct _OBJECT_ATTRIBUTES {
     
107.         DWORD                         Length;
     
108.         HANDLE                        RootDirectory;
     
109.         PUNICODE_STRING               ObjectName;
     
110.         DWORD                         Attributes;
     
111.         PSECURITY_DESCRIPTOR          SecurityDescriptor;
     
112.         PSECURITY_QUALITY_OF_SERVICE  SecurityQualityOfService;
     
113. } OBJECT_ATTRIBUTES, *POBJECT_ATTRIBUTES;
     
114. 
     
115. 
     
116. 
     
117. // CLIENT_ID
     
118. #ifndef  CLIENT_ID
     
119. typedef struct _CLIENT_ID {
     
120.         HANDLE     UniqueProcess;
     
121.         HANDLE     UniqueThread;
     
122. } CLIENT_ID, *PCLIENT_ID;
     
123. #endif
     
124. 
     
125. /*
     
126. struct _SYSTEM_THREADS
     
127. {
     
128.         LARGE_INTEGER                KernelTime;
     
129.         LARGE_INTEGER                UserTime;
     
130.         LARGE_INTEGER                CreateTime;
     
131.         ULONG                                WaitTime;
     
132.         PVOID                                StartAddress;
     
133.         CLIENT_ID                        ClientIs;
     
134.         KPRIORITY                        Priority;
     
135.         KPRIORITY                        BasePriority;
     
136.         ULONG                                ContextSwitchCount;
     
137.         ULONG                                ThreadState;
     
138.         KWAIT_REASON                WaitReason;
     
139. };
     
140. 
     
141. struct _SYSTEM_PROCESSES
     
142. {
     
143.         ULONG                                NextEntryDelta;
     
144.         ULONG                                ThreadCount;
     
145.         ULONG                                Reserved[6];
     
146.         LARGE_INTEGER                CreateTime;
     
147.         LARGE_INTEGER                UserTime;
     
148.         LARGE_INTEGER                KernelTime;
     
149.         UNICODE_STRING                ProcessName;
     
150.         KPRIORITY                        BasePriority;
     
151.         ULONG                                ProcessId;
     
152.         ULONG                                InheritedFromProcessId;
     
153.         ULONG                                HandleCount;
     
154.         ULONG                                Reserved2[2];
     
155.         VM_COUNTERS                        VmCounters;
     
156.         IO_COUNTERS                        IoCounters; //windows 2000 only
     
157.         struct _SYSTEM_THREADS                Threads[1];
     
158. };
     
159. 
     
160. 
     
161. // PROCESS_BASIC_INFORMATION
     
162. #ifdef  PROCESS_BASIC_INFORMATION
     
163. #undef  PROCESS_BASIC_INFORMATION
     
164. typedef struct _PROCESS_BASIC_INFORMATION {
     
165.         NTSTATUS                ExitStatus;
     
166.         ULONG                        PebBaseAddress;
     
167.         ULONG_PTR                AffinityMask;
     
168.         LONG                        BasePriority;
     
169.         ULONG_PTR                UniqueProcessId;
     
170.         ULONG_PTR                InheritedFromUniqueProcessId;
     
171. } PROCESS_BASIC_INFORMATION, *PPROCESS_BASIC_INFORMATION;
     
172. #endif
     
173. 
     
174. 
     
175. // SYSTEM_HANDLE_INFORMATION
     
176. typedef struct _SYSTEM_HANDLE_TABLE_ENTRY_INFO {
     
177.      USHORT UniqueProcessId;
     
178.      USHORT CreatorBackTraceIndex;
     
179.      UCHAR ObjectTypeIndex;
     
180.      UCHAR HandleAttributes;
     
181.      USHORT HandleValue;   // 句柄
     
182.      PVOID Object;         // 若HANDLE类型为线程,则它是ETHREAD结构
     
183.      ULONG GrantedAccess;
     
184. } SYSTEM_HANDLE_TABLE_ENTRY_INFO, *PSYSTEM_HANDLE_TABLE_ENTRY_INFO;
     
185. 
     
186. typedef struct _SYSTEM_HANDLE_INFORMATION {
     
187.      ULONG NumberOfHandles;
     
188.      SYSTEM_HANDLE_TABLE_ENTRY_INFO Handles[1];
     
189. } SYSTEM_HANDLE_INFORMATION, *PSYSTEM_HANDLE_INFORMATION;
     
190. */
     
191. 
     
192. // SYSTEM_MODULE_INFORMATION
     
193. typedef struct _SYSTEM_MODULE_INFORMATION {
     
194.         ULONG        Reserved[2];
     
195.         PVOID        Base;
     
196.         ULONG        Size;
     
197.         ULONG        Flags;
     
198.         USHORT  Index;
     
199.         USHORT  Unknown;
     
200.         USHORT  LoadCount;
     
201.         USHORT  ModuleNameOffset;
     
202.         CHAR    ImageName[256];
     
203. } SYSTEM_MODULE_INFORMATION, *PSYSTEM_MODULE_INFORMATION;
     
204. 
     
205. 
     
206. typedef struct {
     
207.     ULONG   dwNumberOfModules;
     
208.     SYSTEM_MODULE_INFORMATION   smi;
     
209. } MODULES, *PMODULES;
     
210. 
     
211. 
     
212. // SYSTEM_BASIC_INFORMATION
     
213. typedef struct _SYSTEM_BASIC_INFORMATION {
     
214.         ULONG Unknown;                  //Always contains zero
     
215.         ULONG MaximumIncrement;         //一个时钟的计量单位
     
216.         ULONG PhysicalPageSize;         //一个内存页的大小
     
217.         ULONG NumberOfPhysicalPages;    //系统管理着多少个页
     
218.         ULONG LowestPhysicalPage;       //低端内存页
     
219.         ULONG HighestPhysicalPage;      //高端内存页
     
220.         ULONG AllocationGranularity;
     
221.         ULONG LowestUserAddress;        //地端用户地址
     
222.         ULONG HighestUserAddress;       //高端用户地址
     
223.         ULONG ActiveProcessors;         //激活的处理器
     
224.         UCHAR NumberProcessors;         //有多少个处理器
     
225. } SYSTEM_BASIC_INFORMATION, *PSYSTEM_BASIC_INFORMATION;
     
226. 
     
227. 
     
228. // SYSTEM_INFORMATION_CLASS
     
229. typedef enum _SYSTEM_INFORMATION_CLASS {
     
230.     SystemBasicInformation,
     
231.     SystemProcessorInformation,
     
232.     SystemPerformanceInformation,
     
233.     SystemTimeOfDayInformation,
     
234.     SystemPathInformation,
     
235.     SystemProcessInformation,
     
236.     SystemCallCountInformation,
     
237.     SystemDeviceInformation,
     
238.     SystemProcessorPerformanceInformation,
     
239.     SystemFlagsInformation,
     
240.     SystemCallTimeInformation,
     
241.     SystemModuleInformation,  // 11
     
242.     SystemLocksInformation,
     
243.     SystemStackTraceInformation,
     
244.     SystemPagedPoolInformation,
     
245.     SystemNonPagedPoolInformation,
     
246.     SystemHandleInformation,  // 0x10 -- 16
     
247.     SystemObjectInformation,
     
248.     SystemPageFileInformation,
     
249.     SystemVdmInstemulInformation,
     
250.     SystemVdmBopInformation,
     
251.     SystemFileCacheInformation,
     
252.     SystemPoolTagInformation,
     
253.     SystemInterruptInformation,
     
254.     SystemDpcBehaviorInformation,
     
255.     SystemFullMemoryInformation,
     
256.     SystemLoadGdiDriverInformation,
     
257.     SystemUnloadGdiDriverInformation,
     
258.     SystemTimeAdjustmentInformation,
     
259.     SystemSummaryMemoryInformation,
     
260.     SystemUnused1,
     
261.     SystemPerformanceTraceInformation,
     
262.     SystemCrashDumpInformation,
     
263.     SystemExceptionInformation,
     
264.     SystemCrashDumpStateInformation,
     
265.     SystemKernelDebuggerInformation,
     
266.     SystemContextSwitchInformation,
     
267.     SystemRegistryQuotaInformation,
     
268.     SystemExtendServiceTableInformation,
     
269.     SystemPrioritySeperation,
     
270.     SystemUnused3,
     
271.     SystemUnused4,
     
272.     SystemUnused5,
     
273.     SystemUnused6,
     
274.     SystemCurrentTimeZoneInformation,
     
275.     SystemLookasideInformation,
     
276.     SystemTimeSlipNotification,
     
277.     SystemSessionCreate,
     
278.     SystemSessionDetach,
     
279.     SystemSessionInformation
     
280. } SYSTEM_INFORMATION_CLASS;
     
281. 
     
282. 
     
283. #ifndef  SECTION_INHERIT
     
284. typedef enum _SECTION_INHERIT {
     
285.         ViewShare = 1,
     
286.         ViewUnmap = 2
     
287. } SECTION_INHERIT;
     
288. #endif
     
289. 
     
290. 
     
291. 
     
292. /******************************************************
     
293. *                                                     *
     
294. *                   部分 PE 结构                      *
     
295. *                                                     *
     
296. ******************************************************/
     
297. 
     
298. #ifndef IMAGE_DOS_SIGNATURE
     
299. #define IMAGE_DOS_SIGNATURE 0x5a4d      // MZ
     
300. #endif
     
301. 
     
302. #ifndef IMAGE_NT_SIGNATURE
     
303. #define IMAGE_NT_SIGNATURE  0x00004550  // PE00
     
304. #endif
     
305. 
     
306. // _IMAGE_DOS_HEADER
     
307. struct MZHeader
     
308. {
     
309.         unsigned short signature; // "MZ"
     
310.         unsigned short partPag;
     
311.         unsigned short pageCnt;
     
312.         unsigned short reloCnt;
     
313.         unsigned short hdrSize;
     
314.         unsigned short minMem;
     
315.         unsigned short maxMem;
     
316.         unsigned short reloSS;
     
317.         unsigned short exeSP;
     
318.         unsigned short chksum;
     
319.         unsigned short exeIP;
     
320.         unsigned short reloCS;
     
321.         unsigned short tablOff;
     
322.         unsigned short overlay;
     
323.         unsigned char reserved[32];
     
324.         unsigned long offsetToPE;
     
325. };
     
326. 
     
327. // DWORD signature + _IMAGE_FILE_HEADER. 不是完全的IMAGE_FILE_HEADER.
     
328. struct PE_Header
     
329. {
     
330.         unsigned long signature; // "PE\0\0"
     
331.         unsigned short machine;
     
332.         unsigned short numSections;
     
333.         unsigned long timeDateStamp;
     
334.         unsigned long pointerToSymbolTable;
     
335.         unsigned long numOfSymbols;
     
336.         unsigned short sizeOfOptionHeader;
     
337.         unsigned short characteristics;
     
338. };
     
339. 
     
340. // _IMAGE_OPTIONAL_HEADER
     
341. struct PE_ExtHeader
     
342. {
     
343.         unsigned short magic;
     
344.         unsigned char majorLinkerVersion;
     
345.         unsigned char minorLinkerVersion;
     
346.         unsigned long sizeOfCode;
     
347.         unsigned long sizeOfInitializedData;
     
348.         unsigned long sizeOfUninitializedData;
     
349.         unsigned long addressOfEntryPoint;
     
350.         unsigned long baseOfCode;
     
351.         unsigned long baseOfData;
     
352.         unsigned long imageBase;
     
353.         unsigned long sectionAlignment;
     
354.         unsigned long fileAlignment;
     
355.         unsigned short majorOSVersion;
     
356.         unsigned short minorOSVersion;
     
357.         unsigned short majorImageVersion;
     
358.         unsigned short minorImageVersion;
     
359.         unsigned short majorSubsystemVersion;
     
360.         unsigned short minorSubsystemVersion;
     
361.         unsigned long reserved1;
     
362.         unsigned long sizeOfImage;
     
363.         unsigned long sizeOfHeaders;
     
364.         unsigned long checksum;
     
365.         unsigned short subsystem;
     
366.         unsigned short DLLCharacteristics;
     
367.         unsigned long sizeOfStackReserve;
     
368.         unsigned long sizeOfStackCommit;
     
369.         unsigned long sizeOfHeapReserve;
     
370.         unsigned long sizeOfHeapCommit;
     
371.         unsigned long loaderFlags;
     
372.         unsigned long numberOfRVAAndSizes;
     
373.         unsigned long exportTableAddress;
     
374.         unsigned long exportTableSize;
     
375.         unsigned long importTableAddress;
     
376.         unsigned long importTableSize;
     
377.         unsigned long resourceTableAddress;
     
378.         unsigned long resourceTableSize;
     
379.         unsigned long exceptionTableAddress;
     
380.         unsigned long exceptionTableSize;
     
381.         unsigned long certFilePointer;
     
382.         unsigned long certTableSize;
     
383.         unsigned long relocationTableAddress;
     
384.         unsigned long relocationTableSize;
     
385.         unsigned long debugDataAddress;
     
386.         unsigned long debugDataSize;
     
387.         unsigned long archDataAddress;
     
388.         unsigned long archDataSize;
     
389.         unsigned long globalPtrAddress;
     
390.         unsigned long globalPtrSize;
     
391.         unsigned long TLSTableAddress;
     
392.         unsigned long TLSTableSize;
     
393.         unsigned long loadConfigTableAddress;
     
394.         unsigned long loadConfigTableSize;
     
395.         unsigned long boundImportTableAddress;
     
396.         unsigned long boundImportTableSize;
     
397.         unsigned long importAddressTableAddress;
     
398.         unsigned long importAddressTableSize;
     
399.         unsigned long delayImportDescAddress;
     
400.         unsigned long delayImportDescSize;
     
401.         unsigned long COMHeaderAddress;
     
402.         unsigned long COMHeaderSize;
     
403.         unsigned long reserved2;
     
404.         unsigned long reserved3;
     
405. };
     
406. 
     
407. // _IMAGE_SECTION_HEADER
     
408. struct SectionHeader
     
409. {
     
410.         unsigned char sectionName[8];
     
411.         unsigned long virtualSize;
     
412.         unsigned long virtualAddress;
     
413.         unsigned long sizeOfRawData;
     
414.         unsigned long pointerToRawData;
     
415.         unsigned long pointerToRelocations;
     
416.         unsigned long pointerToLineNumbers;
     
417.         unsigned short numberOfRelocations;
     
418.         unsigned short numberOfLineNumbers;
     
419.         unsigned long characteristics;
     
420. };
     
421. 
     
422. struct ImportDirEntry
     
423. {
     
424.         DWORD importLookupTable;
     
425.         DWORD timeDateStamp;
     
426.         DWORD fowarderChain;
     
427.         DWORD nameRVA;
     
428.         DWORD importAddressTable;
     
429. };
     
430. 
     
431. 
     
432. /******************************************************
     
433. *                                                     *
     
434. *                 结构体自定义区域                    *
     
435. *                                                     *
     
436. ******************************************************/
     
437. 
     
438. 
     
439. typedef struct _MY_PROCESS_INFO {
     
440.         ULONG     PID;
     
441.         ULONG          KPEB;
     
442.         ULONG     CR3;
     
443.         CHAR      Name[16];
     
444.         ULONG     Reserved;
     
445. } MY_PROCESS_INFO, *PMY_PROCESS_INFO;
     
446. 
     
447. 
     
448. 
     
449. /////////////////////////////////////////////////////////////////         --          --     
     
450. //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//     --     -      -     --
     
451. //+                                                           +//     --      -   -       --
     
452. //+                      函数原型声明                         +//      --       -        --  
     
453. //+                                                           +//       -     sudami     -   
     
454. //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//        --            --   
     
455. /////////////////////////////////////////////////////////////////          --        --      
     
456. //                                                                           --    --        
     
457. //                                                                              --
     
458. 
     
459. NTSYSAPI
     
460. NTSTATUS
     
461. NTAPI
     
462. NtCreateFile(
     
463.   OUT PHANDLE             FileHandle,
     
464.   IN ACCESS_MASK          DesiredAccess,
     
465.   IN POBJECT_ATTRIBUTES   ObjectAttributes,
     
466. //  OUT PIO_STATUS_BLOCK    IoStatusBlock,
     
467.   IN PLARGE_INTEGER       AllocationSize OPTIONAL,
     
468.   IN ULONG                FileAttributes,
     
469.   IN ULONG                ShareAccess,
     
470.   IN ULONG                CreateDisposition,
     
471.   IN ULONG                CreateOptions,
     
472.   IN PVOID                EaBuffer OPTIONAL,
     
473.   IN ULONG                EaLength
     
474.   );
     
475. 
     
476. 
     
477. NTSYSAPI
     
478. VOID
     
479. NTAPI
     
480. RtlInitUnicodeString(
     
481.      PUNICODE_STRING DestinationString,
     
482.      PCWSTR SourceString
     
483.      );
     
484. 
     
485. NTSYSAPI
     
486. NTSTATUS
     
487. NTAPI
     
488. ZwOpenSection(
     
489.      OUT PHANDLE SectionHandle,
     
490.      IN ACCESS_MASK DesiredAccess,
     
491.      IN POBJECT_ATTRIBUTES objectAttributes
     
492.      );
     
493. 
     
494. 
     
495. NTSYSAPI
     
496. NTSTATUS
     
497. NTAPI
     
498. ZwMapViewOfSection(
     
499.      IN HANDLE SectionHandle,
     
500.      IN HANDLE ProcessHandle,
     
501.      IN OUT PVOID *BaseAddress,
     
502.      IN ULONG ZeroBits,
     
503.      IN ULONG CommitSize,
     
504.      IN OUT PLARGE_INTEGER SectionOffset OPTIONAL,
     
505.      IN OUT PULONG ViewSize,
     
506.      IN SECTION_INHERIT InheritDisposition,
     
507.      IN ULONG AllocationType,
     
508.      IN ULONG Protect
     
509.      );
     
510. 
     
511. 
     
512. NTSYSAPI
     
513. NTSTATUS
     
514. NTAPI
     
515. ZwUnmapViewOfSection(
     
516.      IN HANDLE ProcessHandle,
     
517.      IN PVOID BaseAddress
     
518.      );
     
519. 
     
520. /*
     
521. NTSYSAPI
     
522. NTSTATUS
     
523. NTAPI
     
524. NtVdmControl(
     
525.      IN ULONG ControlCode,
     
526.      IN PVOID ControlData
     
527.      );
     
528. 
     
529. NTSYSAPI
     
530. NTSTATUS
     
531. PsLookupProcessByProcessId (
     
532.     IN HANDLE ProcessId,
     
533.     OUT PEPROCESS *Process
     
534.     );
     
535. 
     
536. NTSYSAPI
     
537. NTSTATUS
     
538. PsLookupThreadByThreadId (
     
539.     IN HANDLE ThreadId,
     
540.     OUT PETHREAD *Thread
     
541.     );
     
542. */
     
543. 
     
544. 
     
545. NTSYSAPI
     
546. NTSTATUS
     
547. NTAPI
     
548. NtQuerySystemInformation(
     
549. 
     
550.   IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
     
551.   OUT PVOID               SystemInformation,
     
552.   IN ULONG                SystemInformationLength,
     
553.   OUT PULONG              ReturnLength OPTIONAL
     
554.   );
     
555. 
     
556. 
     
557. 
     
558. 
     
559. //
     
560. //
     
561. //
     
562. //
     
563. 
     
564. VOID
     
565. RtlFreeUnicodeString(
     
566.     IN PUNICODE_STRING  UnicodeString
     
567.     );
     
568. 
     
569. NTSTATUS (WINAPI * _RtlAnsiStringToUnicodeString)
     
570.         (PUNICODE_STRING  DestinationString,
     
571.          IN PANSI_STRING  SourceString,
     
572.          IN BOOLEAN);
     
573. 
     
574. VOID (WINAPI *_RtlInitAnsiString)
     
575.         (IN OUT PANSI_STRING  DestinationString,
     
576.          IN PCHAR  SourceString);
     
577. 
     
578. /////////////////////////////////////////////////////////////////         --          --     
     
579. //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//     --     -      -     --
     
580. //+                                                           +//     --      -   -       --
     
581. //+                    一些自定义必备函数                     +//      --       -        --  
     
582. //+                                                           +//       -     sudami     -   
     
583. //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//        --            --   
     
584. /////////////////////////////////////////////////////////////////          --        --      
     
585. //                                                                           --    --        
     
586. //                                                                              --
     
587. 
     
588. 
     
589. // 写保护的开&关
     
590. void WPOFF()
     
591. {
     
592.         __asm {   //去掉内存保护
     
593.                 cli
     
594.                 mov  eax,cr0
     
595.                 and  eax,not 10000h
     
596.                 mov  cr0,eax
     
597.         }
     
598. }
     
599. 
     
600. void WPON()
     
601. {
     
602.         __asm {   //恢复内存保护  
     
603.                 mov  eax,cr0
     
604.                 or   eax,10000h
     
605.                 mov  cr0,eax
     
606.                 sti
     
607.         }
     
608. }
     
609. 
     
610. //////////////////////////////////////////////////////////////////////////////////
     
611. //////////////////////////////////////////////////////////////////////////////////
     
612. 
     
613. #ifdef __cplusplus
     
614. }
     
615. #endif
     
616. 
     
617. #endif
     

复制代码

.c文件

1. 
   
2. 
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. #include <windows.h>
   
6. #include <aclapi.h>
   
7. #include "rootkit.h"
   
8. 
   
9. ////////////////////////////////////////////////////////////////////
   
10. 
    
11. #pragma comment (lib, "F:\\WINDDK\\lib\\wxp\\i386\\ntdll.lib")
    
12. 
    
13. ////////////////////////////////////////////////////////////////////
    
14. 
    
15. #define OBJ_CASE_INSENSITIVE                        0x00000040L
    
16. #define PAGE_READONLY                                        0x02
    
17. #define PAGE_READWRITE                                        0x04
    
18. #define DEF_KERNEL_BASE                                        0x80400000L
    
19. #define PROT_MEMBASE                                        0x80000000
    
20. 
    
21. 
    
22. DWORD gWinVersion;
    
23. 
    
24. struct FixupBlock
    
25. {
    
26.         ULONG pageRVA;
    
27.         ULONG blockSize;
    
28. };
    
29. 
    
30. /*++
    
31. 
    
32. 3个函数,就不用注解了
    
33. 
    
34. --*/
    
35. BOOL GetNativeAPIs ()
    
36. {
    
37.         HMODULE hntdll;
    
38. 
    
39.         hntdll = GetModuleHandle("ntdll.dll");
    
40.                        
    
41.         *(FARPROC *)&_RtlAnsiStringToUnicodeString =
    
42.                         GetProcAddress(hntdll, "RtlAnsiStringToUnicodeString");
    
43. 
    
44.         *(FARPROC *)&_RtlInitAnsiString =
    
45.                         GetProcAddress(hntdll, "RtlInitAnsiString");
    
46. 
    
47.         if (_RtlAnsiStringToUnicodeString && _RtlInitAnsiString) {
    
48.                 return TRUE;
    
49.         }
    
50. 
    
51.         return FALSE;
    
52. }
    
53. 
    
54. DWORD myStrlenA (char *ptr)
    
55. {
    
56.         DWORD len = 0;
    
57.         while(*ptr) {
    
58.                 len++;
    
59.                 ptr++;
    
60.         }
    
61. 
    
62.         return len;
    
63. }
    
64. 
    
65. BOOL myStrcmpA (char *str1, char *str2)
    
66. {
    
67.         while(*str1 && *str2) {
    
68.                 if(*str1 == *str2) {
    
69.                         str1++;
    
70.                         str2++;
    
71.                 } else {
    
72.                         return FALSE;
    
73.                 }
    
74.         }
    
75. 
    
76.         if (*str1 && !*str2) {
    
77.                 return FALSE;
    
78.         } else if (*str2 && !*str1){
    
79.                 return FALSE;
    
80.         }
    
81. 
    
82.         return TRUE;       
    
83. }
    
84. 
    
85. 
    
86. //----------------------                         ----------------------                    
    
87. //                      -------------------------                      ---------------------
    
88. BOOL
    
89. ReadPEInfo (
    
90.   char *modulePos,
    
91.   MZHeader *outMZ,
    
92.   PE_Header *outPE,
    
93.   PE_ExtHeader *outpeXH,
    
94.   SectionHeader **outSecHdr
    
95.   )
    
96. 
    
97. /*++
    
98. 
    
99. 学习者 : sudami [xiao_rui_119@163.com]
    
100. 时间   : 08/01/11
     
101. 
     
102. 功能   :
     
103.   得到映射到内存的PE结构中各部分的地址
     
104. 
     
105. 参数   :
     
106.   
     
107.   modulePos - [IN] 将磁盘上的文件读出来后,映射到进程的虚拟地址空间中,对齐后得到其起始地址.
     
108.   outMZ - [OUT] 保存MZ头 IMAGE_DOS_HEADER
     
109.   outPE - [OUT] 保存PE头 IMAGE_FILE_HEADER
     
110.   outpeXH - [OUT] 保存扩展PE头 IMAGE_OPTIONAL_HEADER
     
111.   outSecHdr - [OUT] 2级指针,保存Section头 IMAGE_SECTION_HEADER
     
112. 
     
113. 返回 :
     
114.   
     
115.   TRUE -  读取成功
     
116.   FALSE - 不是有效的PE文件,读取失败
     
117. 
     
118. --*/
     
119. {
     
120.         MZHeader *mzH = (MZHeader *)modulePos;
     
121. 
     
122.         if (mzH->signature != IMAGE_DOS_SIGNATURE) {
     
123.                 printf("File does not have MZ header\n");
     
124.                 return false;
     
125.         }
     
126. 
     
127.         PE_Header *peH = (PE_Header *)(modulePos + mzH->offsetToPE);
     
128. 
     
129.         // 通过 sizeOfOptionHeader 验证PE文件的合法性(它是 _IMAGE_OPTIONAL_HEADER 的尺寸)
     
130.         if (peH->sizeOfOptionHeader != sizeof (PE_ExtHeader)) {
     
131.                 printf("Unexpected option header size.\n");
     
132.                 return false;
     
133.         }
     
134. 
     
135.         PE_ExtHeader *peXH = (PE_ExtHeader *)((char *)peH + sizeof(PE_Header));
     
136.         SectionHeader *secHdr = (SectionHeader *)((char *)peXH + sizeof(PE_ExtHeader));
     
137. 
     
138.         *outMZ      =  *mzH;
     
139.         *outPE      =  *peH;
     
140.         *outpeXH    =  *peXH;
     
141.         *outSecHdr  =  secHdr;
     
142. 
     
143.         return true;
     
144. }
     
145. 
     
146. //----------------------                         ----------------------                    
     
147. //                      -------------------------                      ---------------------
     
148. int
     
149. CalcTotalImageSize (
     
150.   MZHeader *inMZ,
     
151.   PE_Header *inPE,
     
152.   PE_ExtHeader *inpeXH,
     
153.   SectionHeader *inSecHdr
     
154.   )
     
155. 
     
156. /*++
     
157. 
     
158. 学习者 : sudami [xiao_rui_119@163.com]
     
159. 时间   : 08/01/11
     
160. 
     
161. 功能 :
     
162.   计算PE文件加载到内存所需要占用的空间: 所有的文件头长度　＋　所有的节长度
     
163. 
     
164. 返回 :
     
165.   PE在内存中对齐后需要的大小
     
166. 
     
167. --*/
     
168. {
     
169.         int result = 0;
     
170.         int val    = 0;
     
171. 
     
172.         /* (1) 统计所有文件头在内存中对齐后所需空间 */
     
173.         // sectionAlignment 为段加载后在内存中的对齐方式 4KB
     
174.         int alignment = inpeXH->sectionAlignment;
     
175. 
     
176.         // 如果所有的文件头长度之和 是4KB整数倍。则留给它的空间就是sizeOfHeaders
     
177.         if (inpeXH->sizeOfHeaders % alignment == 0) {
     
178. 
     
179.                 result += inpeXH->sizeOfHeaders;
     
180.         } else { // 如果所有的文件头长度之和 非4KB整数倍。则需要对齐后申请空间
     
181. 
     
182.             val = inpeXH->sizeOfHeaders / alignment;
     
183.                 val++;
     
184.                 result += (val * alignment);
     
185.         }
     
186. 
     
187.         /* (2) 统计所有节在内存中对齐后所需空间 */
     
188.         for (int i = 0; i < inPE->numSections; i++) {
     
189. 
     
190.                 // virtualSize 是 块对齐前的真实长度
     
191.                 if (inSecHdr[i].virtualSize) {
     
192.                         if (inSecHdr[i].virtualSize % alignment == 0) {
     
193.                                 result += inSecHdr[i].virtualSize;
     
194.                         } else {
     
195.                                 val = inSecHdr[i].virtualSize / alignment;
     
196.                                 val++;
     
197.                                 result += (val * alignment);
     
198.                         }
     
199.                 }
     
200.         }
     
201. 
     
202.         return result;
     
203. }
     
204. 
     
205. //----------------------                         ----------------------                    
     
206. //                      -------------------------                      ---------------------
     
207. ULONG
     
208. GetAlignedSize (
     
209.   ULONG curSize,
     
210.   ULONG alignment
     
211.   )
     
212. 
     
213. /*++
     
214. 
     
215. 功能 :
     
216.   得到对齐后的文件大小
     
217. 
     
218. 参数 :
     
219.   curSize - 未对齐前的大小
     
220.   alignment - 段加载后在内存中的对齐方式,一般为4KB
     
221. 
     
222. 返回 :
     
223.   对齐后的大小
     
224. 
     
225. --*/
     
226. {       
     
227.         if (curSize % alignment == 0) { // 如果不存在对齐方式,则不对齐,直接返回原大小
     
228.                 return curSize;
     
229.         } else {
     
230.                 int val = curSize / alignment;
     
231.                 val++;
     
232.                 return (val * alignment);
     
233.         }
     
234. }
     
235. 
     
236. //----------------------                         ----------------------                    
     
237. //                      -------------------------                      ---------------------
     
238. BOOL
     
239. LoadPE (
     
240.   char *exePtr,
     
241.   MZHeader *inMZ,
     
242.   PE_Header *inPE,
     
243.   PE_ExtHeader *inpeXH,
     
244.   SectionHeader *inSecHdr,
     
245.   LPVOID ptrLoc
     
246.   )
     
247. 
     
248. /*++
     
249. 
     
250. 学习者 : sudami [xiao_rui_119@163.com]
     
251. 时间   : 08/01/11
     
252. 
     
253. 功能 :
     
254.   加载从磁盘读取的文件到内存,需要自己对齐
     
255. 
     
256.            <PE加载到内存对齐后的示意图>
     
257.           所有文件头      节1      节2     ...     节N
     
258.          ------------------------------------------------
     
259.         |aa...aa######| a...a##| a...a###| ... | a...a##|
     
260.          ------------------------------------------------
     
261.   注: a 表示实际数据; # 表示空隙,是内存中对齐后留出的空隙
     
262. 
     
263. 参数 :
     
264.   exePtr - PE文件在磁盘中时起始的地址.还没有经过对齐.所以需要把它映射到内存
     
265.   ...
     
266.   ptrLoc - 根据内存中PE的大小调用HeapAlloc而分配的一块空闲内存区域.
     
267. 
     
268. 返回 : TRUE
     
269. 
     
270. --*/
     
271. {
     
272.         char *outPtr = (char *)ptrLoc;
     
273. 
     
274.         // 把所有文件头的数据全部拷贝到ptrLoc指向的地址处
     
275.         // 然后地址按照PE在内存中的对齐方式往后挪
     
276.         memcpy (outPtr, exePtr, inpeXH->sizeOfHeaders);
     
277.         outPtr += GetAlignedSize (inpeXH->sizeOfHeaders, inpeXH->sectionAlignment);
     
278. 
     
279.         // 拷贝所有的节数据到新的地址处. 复制的时候要知道每个节在文件中的实际大小.而不是在内存在对齐后的大小
     
280.         for (int i = 0; i < inPE->numSections; i++) {
     
281. 
     
282.                 if (inSecHdr[i].sizeOfRawData > 0) { // sizeOfRawData 是节对齐后的长度
     
283.                         ULONG toRead = inSecHdr[i].sizeOfRawData;
     
284. 
     
285.                         if (toRead > inSecHdr[i].virtualSize) {
     
286.                                 toRead = inSecHdr[i].virtualSize;
     
287.                         }
     
288. 
     
289.                         // 拷贝没个节的实际数据,然后把指针挪到每个节在内存中对齐后的位置处
     
290.                         memcpy (outPtr, exePtr + inSecHdr[i].pointerToRawData, toRead);
     
291. 
     
292.                         outPtr += GetAlignedSize (inSecHdr[i].virtualSize, inpeXH->sectionAlignment);
     
293.                 }
     
294.         }
     
295. 
     
296.         return true;
     
297. }
     
298. 
     
299. //----------------------                         ----------------------                    
     
300. //                      -------------------------                      ---------------------
     
301. LPVOID
     
302. LoadDLL (
     
303.   char *dllName
     
304.   )
     
305. 
     
306. /*++
     
307. 
     
308. 学习者 : sudami [xiao_rui_119@163.com]
     
309. 时间   : 08/01/11
     
310. 
     
311. 功能 :
     
312.   将指定模块从磁盘读取,然后映射进内存,按照对齐的方式映射.这需要我们自己来做.
     
313.   这个过程是调用 自定义函数 LoadPE
     
314. 
     
315. 流程 :
     
316.   CreateFile 打开指定的文件 --> GetFileInformationByHandle 获得文件的大小信息a -->
     
317.   HeapAlloc 分配大小为a的内存 --> ReadFile 将文件读入此内存区域中 --> ReadPEInfo 获得
     
318.   PE文件各结构地址 --> CalcTotalImageSize 计算此文件映射到内存对齐后的总大小b  -->
     
319.   HeapAlloc 分配大小为b的内存 --> LoadPE加载之
     
320. 
     
321. 参数 :
     
322.   exePtr - 指定的模块名称,不包含路径.所以一般是系统目录下的文件
     
323. 
     
324. 
     
325. 返回 : 完成加载后,对齐后的PE在进程空间中一段内存的起始地址
     
326. 
     
327. --*/
     
328. {
     
329.         MZHeader mzH2;
     
330.         PE_Header peH2;
     
331.         PE_ExtHeader peXH2;
     
332.         SectionHeader *secHdr2;
     
333.         char moduleFilename[MAX_PATH + 1];
     
334.         LPVOID ptrLoc = NULL;
     
335. 
     
336.         GetSystemDirectory (moduleFilename, MAX_PATH);
     
337.         if (moduleFilename[MAX_PATH - 1] != '\\') {
     
338.                 strcat (moduleFilename, "\");
     
339.         }
     
340. 
     
341.         if ((myStrlenA (moduleFilename) + myStrlenA (dllName)) >= MAX_PATH)
     
342.                 return NULL;
     
343. 
     
344.         strcat (moduleFilename, dllName);
     
345. 
     
346.     // 调用CreateFile打开要映射的文件
     
347.         HANDLE fp = CreateFile (moduleFilename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
     
348.        
     
349.         if (fp != INVALID_HANDLE_VALUE) {
     
350. 
     
351.                 // 通过打开的文件句柄得到文件的信息: 主要是文件的大小
     
352.                 BY_HANDLE_FILE_INFORMATION  fileInfo;
     
353.                 GetFileInformationByHandle (fp, &fileInfo);
     
354.                 DWORD fileSize = fileInfo.nFileSizeLow;
     
355.                
     
356.                 // 得到了磁盘文件的大小后,为其分配内存
     
357.                 if (fileSize) {
     
358.                         // 在当前进程的Heap中为其分配一段空间
     
359.                         LPVOID exePtr = HeapAlloc (GetProcessHeap(), 0, fileSize);
     
360. 
     
361.                         if (exePtr) {
     
362.                                 DWORD read;
     
363. 
     
364.                                 // read = 保存的是实际读入的大小. 如果完全读完了.就计算PE在内存中对齐后的大小.
     
365.                                 if ( ReadFile (fp, exePtr, fileSize, &read, NULL) && read == fileSize) {                                       
     
366.                                         if ( ReadPEInfo ((char *)exePtr, &mzH2, &peH2, &peXH2, &secHdr2)) {
     
367.                                                 int imageSize = CalcTotalImageSize(&mzH2, &peH2, &peXH2, secHdr2);                                       
     
368.                                                 ptrLoc = HeapAlloc(GetProcessHeap(), 0, imageSize);
     
369. 
     
370.                                                 if (ptrLoc) {       
     
371.                                                         LoadPE ((char *)exePtr, &mzH2, &peH2, &peXH2, secHdr2, ptrLoc);
     
372.                                                 }
     
373.                                         }
     
374. 
     
375.                                 }
     
376.                         }
     
377. 
     
378.                         HeapFree (GetProcessHeap(), 0, exePtr);
     
379.                 }
     
380. 
     
381.                 CloseHandle (fp);
     
382.         }
     
383. 
     
384.         return ptrLoc;
     
385. }
     
386. 
     
387. 
     
388. //----------------------                         ----------------------                    
     
389. //                      -------------------------                      ---------------------
     
390. DWORD
     
391. ProcAPIExportAddr (
     
392.   DWORD hModule,
     
393.   char *apiName
     
394.   )
     
395. 
     
396. /*++
     
397. 
     
398. 学习者 : sudami [xiao_rui_119@163.com]
     
399. 时间   : 08/01/11
     
400. 
     
401. 功能 :
     
402.   得到指定模块EAT中的指定函数相对于ntoskrnl.exe的偏移
     
403. 
     
404. 参数 :
     
405.   hModule - 模块地址
     
406. 
     
407.   apiName - 指定函数名
     
408. 
     
409. 返回 :
     
410. 
     
411.   0 - 如果传进来的参数不正确,则返回0
     
412.   # - 指定模块EAT中的指定函数相对于ntoskrnl.exe的偏移
     
413. 
     
414. --*/
     
415. {       
     
416.         if (!hModule || !apiName) {
     
417.                 return 0;
     
418.         }
     
419. 
     
420.         char *ptr = (char *)hModule;
     
421.         ptr += 0x3c;
     
422.        
     
423.         ptr = (char *)(*(DWORD *)ptr) + hModule + 0x78; // 此时ptr保存的是EAT的偏移
     
424.         ptr = (char *)(*(DWORD *)ptr) + hModule;                // 此时ptr指向EAT
     
425. 
     
426.         DWORD numEntries = *(DWORD *)(ptr + 24);        // 24-->0x18 NumberOfNames
     
427.         DWORD *ExportNamePointerTable = (DWORD *)(*(DWORD *)(ptr + 32) + hModule); // 32-->0x20  AddressOfNames       
     
428.         DWORD ordinalBase = *((DWORD *)(ptr + 16));         // 16-->0x10  Base
     
429.         WORD *ExportOrdinalTable = (WORD *)((*(DWORD *)(ptr + 36)) + hModule);           // 36-->0x24  AddressOfNameOrdinals
     
430.         DWORD *ExportAddrTable = (DWORD *)((*(DWORD *)(ptr + 28)) + hModule);      // 28-->0x1C  AddressOfFunctions
     
431. 
     
432.         // 遍历每个有名字的函数 (有的函数没有名字)
     
433.         for(DWORD i = 0; i < numEntries; i++)
     
434.         {
     
435.                 // 得到函数的名字
     
436.                 char *exportName = (char *)(ExportNamePointerTable[i] + hModule);
     
437. 
     
438.                 if (myStrcmpA (exportName, apiName) == TRUE) {               
     
439.                         // 得到函数在AddressOfFunctions中的索引号
     
440.                         WORD ordinal = ExportOrdinalTable[i];
     
441. 
     
442.                         return (DWORD)(ExportAddrTable[ordinal]);
     
443.                 }               
     
444.         }
     
445. 
     
446.         return 0;
     
447. }
     
448. 
     
449. 
     
450. //----------------------                         ----------------------                    
     
451. //                      -------------------------                      ---------------------
     
452. BOOL
     
453. BuildNativeAPITable (
     
454.   DWORD hModule,
     
455.   char *nativeAPINames[],
     
456.   DWORD numNames
     
457.   )
     
458. 
     
459. /*++
     
460. 
     
461. 学习者 : sudami [xiao_rui_119@163.com]
     
462. 时间   : 08/01/11
     
463. 
     
464. 功能 :
     
465.   从ntdll.dll的EAT中搜索，建立一张 API 函数表
     
466. 
     
467. 参数 :
     
468.   hModule - 模块地址
     
469. 
     
470.   nativeAPINames[] - [OUT]保存函数名的数组
     
471. 
     
472.   numNames -
     
473. 
     
474. 返回 : TRUE | FALSE  
     
475. 
     
476. --*/
     
477. {
     
478.         if(!hModule) {
     
479.                 return FALSE;
     
480.         }
     
481. 
     
482.         char *ptr = (char *)hModule;
     
483.         ptr += 0x3c;
     
484.        
     
485.         ptr = (char *)(*(DWORD *)ptr) + hModule + 0x78; // 此时ptr保存的是EAT的偏移
     
486. 
     
487.         ptr = (char *)(*(DWORD *)ptr) + hModule;                // 此时ptr指向EAT
     
488. 
     
489.         DWORD numEntries = *(DWORD *)(ptr + 24);        // 24-->0x18 NumberOfNames
     
490.         DWORD *ExportNamePointerTable = (DWORD *)(*(DWORD *)(ptr + 32) + hModule); // 32-->0x20  AddressOfNames       
     
491.         DWORD ordinalBase = *((DWORD *)(ptr + 16));                                    // 16-->0x10  Base
     
492.         WORD *ExportOrdinalTable = (WORD *)((*(DWORD *)(ptr + 36)) + hModule);           // 36-->0x24  AddressOfNameOrdinals
     
493.         DWORD *ExportAddrTable = (DWORD *)((*(DWORD *)(ptr + 28)) + hModule);      // 28-->0x1C  AddressOfFunctions
     
494. 
     
495. 
     
496.         for (DWORD i = 0; i < numEntries; i++)
     
497.         {               
     
498.                 // i now contains the index of the API in the Ordinal Table
     
499.                 // ptr points to Export directory table
     
500. 
     
501.                 WORD ordinalValue = ExportOrdinalTable[i];               
     
502.                 DWORD apiAddr = (DWORD)ExportAddrTable[ordinalValue] + hModule;
     
503.                 char *exportName = (char *)(ExportNamePointerTable[i] + hModule);
     
504.                
     
505.                 // Win2K
     
506.                 if (gWinVersion == 0 &&
     
507.                    *((UCHAR *)apiAddr) == 0xB8 &&
     
508.                    *((UCHAR *)apiAddr + 9) == 0xCD &&
     
509.                    *((UCHAR *)apiAddr + 10) == 0x2E) {
     
510. 
     
511.                         DWORD serviceNum = *(DWORD *)((char *)apiAddr + 1);
     
512. 
     
513.                         if(serviceNum < numNames){
     
514.                                 nativeAPINames[serviceNum] = exportName;
     
515.                         }
     
516.                 }
     
517.                
     
518.                 // WinXP
     
519.                 else if (gWinVersion == 1 &&
     
520.                                 *((UCHAR *)apiAddr) == 0xB8 &&
     
521.                                 *((UCHAR *)apiAddr + 5) == 0xBA &&
     
522.                                 *((UCHAR *)apiAddr + 6) == 0x00 &&
     
523.                                 *((UCHAR *)apiAddr + 7) == 0x03 &&
     
524.                                 *((UCHAR *)apiAddr + 8) == 0xFE &&
     
525.                                 *((UCHAR *)apiAddr + 9) == 0x7F) {
     
526. 
     
527.                         DWORD serviceNum = *(DWORD *)((char *)apiAddr + 1);
     
528. 
     
529.                         if(serviceNum < numNames) {
     
530.                                 nativeAPINames[serviceNum] = exportName;
     
531.                         }
     
532.                 }
     
533.         }
     
534. 
     
535.         return TRUE;
     
536. }
     
537. 
     
538. 
     
539. 
     
540. 
     
541. //----------------------                         ----------------------                    
     
542. //                      -------------------------                      ---------------------
     
543. HANDLE
     
544. OpenPhyMem(
     
545.                    )
     
546. 
     
547. /*++
     
548. 
     
549. 学习者 : sudami [xiao_rui_119@163.com]
     
550. 时间   : 08/01/11
     
551. 
     
552. 功能 :
     
553.   从用户态获得 \device\physicalmemory 的句柄
     
554. 
     
555. 参数 : NULL
     
556. 
     
557. 返回 : \device\physicalmemory 的句柄
     
558.   
     
559. --*/
     
560. {
     
561.         HANDLE hPhyMem;
     
562.         OBJECT_ATTRIBUTES oAttr;
     
563.         ANSI_STRING aStr;
     
564.                
     
565.         _RtlInitAnsiString (&aStr, "\\device\\physicalmemory");
     
566.                                                
     
567.         UNICODE_STRING uStr;
     
568. 
     
569.         if (_RtlAnsiStringToUnicodeString (&uStr, &aStr, TRUE) != STATUS_SUCCESS){               
     
570.                 return INVALID_HANDLE_VALUE;       
     
571.         }
     
572. 
     
573.     oAttr.Length                         =  sizeof(OBJECT_ATTRIBUTES);
     
574.     oAttr.RootDirectory                 =  NULL;
     
575.     oAttr.Attributes                 =  OBJ_CASE_INSENSITIVE;
     
576.     oAttr.ObjectName                 =  &uStr;
     
577.     oAttr.SecurityDescriptor =  NULL;
     
578.     oAttr.SecurityQualityOfService = NULL;
     
579. 
     
580.         if (ZwOpenSection (&hPhyMem, SECTION_MAP_READ | SECTION_MAP_WRITE, &oAttr ) != STATUS_SUCCESS) {               
     
581.                 return INVALID_HANDLE_VALUE;
     
582.         }
     
583. 
     
584.         return hPhyMem;
     
585. }
     
586. 
     
587. //----------------------                         ----------------------                    
     
588. //                      -------------------------                      ---------------------
     
589. BOOL
     
590. MapPhyMem (
     
591.   HANDLE hPhyMem,
     
592.   DWORD *phyAddr,
     
593.   DWORD *length,
     
594.   PVOID *virtualAddr
     
595.   )
     
596. 
     
597. /*++
     
598. 
     
599. 学习者 : sudami [xiao_rui_119@163.com]
     
600. 时间   : 08/01/11
     
601. 
     
602. 功能 :
     
603.   从用户态获得 \device\physicalmemory 的句柄
     
604.   映射系统地址空间内的一部分数据到用户的地址空间.前提当然是用户对这段空间有读写权限
     
605.   映射结束后 phyAddr 的值发生了变化,它挪到了映射结束的地方
     
606. 
     
607. 参数 :  
     
608.   hPhyMem - \device\physicalmemory 的句柄
     
609.   phyAddr - [IN OUT] 从系统地址范围内的指定位置处开始映射
     
610.   length  - 指定映射的大小
     
611.   virtualAddr - 进程的虚拟地址空间中保存映射的起始地址
     
612. 
     
613. 返回 :
     
614.   
     
615. --*/
     
616. {
     
617.         NTSTATUS                        ntStatus;
     
618.         PHYSICAL_ADDRESS        viewBase;
     
619. 
     
620.         *virtualAddr = 0;
     
621.         viewBase.QuadPart = (ULONGLONG) (*phyAddr);
     
622. 
     
623.         ntStatus = ZwMapViewOfSection (
     
624.                 hPhyMem,
     
625.                 (HANDLE)-1,
     
626.                 virtualAddr, // 指定接收映射的起始地址
     
627.                 0,
     
628.                 *length,     // 指定映射的大小
     
629.                 &viewBase,   // 指定从哪儿开始映射
     
630.                 length,      // 保存实际的映射大小
     
631.                 ViewShare,   // 指定继承性
     
632.                 0,
     
633.                 PAGE_READWRITE
     
634.                 );
     
635. 
     
636.         if (ntStatus != STATUS_SUCCESS) {
     
637.                 printf("Failed to map physical memory view of length %X at %X!", *length, *phyAddr);
     
638.                 return FALSE;                                       
     
639.         }
     
640. 
     
641.         *phyAddr = viewBase.LowPart;
     
642.         return TRUE;
     
643. }
     
644. 
     
645. 
     
646. // Unmap section of physical memory
     
647. void UnMapPhyMem(DWORD virtualAddr)
     
648. {
     
649.         NTSTATUS status;
     
650. 
     
651.         status = ZwUnmapViewOfSection ((HANDLE)-1, (PVOID)virtualAddr);
     
652.         if (status != STATUS_SUCCESS) {
     
653.                 printf("Unmapping view failed!\n");
     
654.         }
     
655. }
     
656. 
     
657. //----------------------                         ----------------------                    
     
658. //                      -------------------------                      ---------------------
     
659. BOOL
     
660. AssignACL (
     
661.                    )
     
662. 
     
663. /*++
     
664. 
     
665. 学习者 : sudami [xiao_rui_119@163.com]
     
666. 时间   : 08/01/11
     
667. 
     
668. 功能 :
     
669.   使当前的用户对 \device\physicalmemory 有写的权限
     
670.   btw: 此部分需要参考MSDN,里面的数据结构太多.
     
671. 
     
672. 参数 :  NULL
     
673. 
     
674. 返回 : TRUE | FALSE
     
675.   
     
676. --*/
     
677. {
     
678.         HANDLE             hPhyMem;
     
679.         ANSI_STRING        aStr;
     
680.         UNICODE_STRING     uStr;
     
681.         OBJECT_ATTRIBUTES  oAttr;
     
682.         BOOL               result = FALSE;
     
683.                
     
684.         _RtlInitAnsiString(&aStr, "\\device\\physicalmemory");
     
685. 
     
686.         if (_RtlAnsiStringToUnicodeString (&uStr, &aStr, TRUE) != STATUS_SUCCESS) {               
     
687.                 return FALSE;
     
688.         }
     
689. 
     
690.     oAttr.Length                                   = sizeof(OBJECT_ATTRIBUTES);
     
691.     oAttr.RootDirectory                           = NULL;
     
692.     oAttr.Attributes                           = OBJ_CASE_INSENSITIVE;
     
693.     oAttr.ObjectName                           = &uStr;
     
694.     oAttr.SecurityDescriptor           = NULL;
     
695.     oAttr.SecurityQualityOfService = NULL;
     
696. 
     
697.         if (ZwOpenSection (&hPhyMem, READ_CONTROL | WRITE_DAC, &oAttr ) != STATUS_SUCCESS) {               
     
698.                 return FALSE;
     
699.         } else {
     
700.                 PACL dacl;
     
701.                 PSECURITY_DESCRIPTOR  sd;
     
702. 
     
703.                 if ( GetSecurityInfo (hPhyMem, SE_KERNEL_OBJECT, DACL_SECURITY_INFORMATION, NULL, NULL,
     
704.                                                 &dacl, NULL, &sd) == ERROR_SUCCESS) {
     
705. 
     
706.                         EXPLICIT_ACCESS ea;
     
707. 
     
708.                         // 得到当前进程的用户名
     
709.                         char userName[MAX_PATH];
     
710.                         DWORD userNameSize = MAX_PATH-1;
     
711.                         GetUserName (userName, &userNameSize);
     
712. 
     
713.                         // 设置精确的权限
     
714.                         ea.grfAccessPermissions                = SECTION_MAP_WRITE;
     
715.                         ea.grfAccessMode                        = GRANT_ACCESS;
     
716.                         ea.grfInheritance                        = NO_INHERITANCE;
     
717.                         ea.Trustee.pMultipleTrustee = NULL;
     
718.                         ea.Trustee.MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
     
719.                         ea.Trustee.TrusteeForm                = TRUSTEE_IS_NAME;
     
720.                         ea.Trustee.TrusteeType                = TRUSTEE_IS_USER;
     
721.                         ea.Trustee.ptstrName                = userName;
     
722. 
     
723.                         // 建立新的ACL
     
724.                         PACL newDacl;
     
725.                         if ( SetEntriesInAcl(1, &ea, dacl, &newDacl) == ERROR_SUCCESS)        {
     
726.                                 // 用新的DACL重新设置当前对象的安全权限
     
727.                                 if( SetSecurityInfo (hPhyMem, SE_KERNEL_OBJECT, DACL_SECURITY_INFORMATION, NULL, NULL,
     
728.                                                                 newDacl, NULL) == ERROR_SUCCESS) {               
     
729.                                         result = TRUE;
     
730.                                 }
     
731. 
     
732.                                 LocalFree(newDacl);
     
733.                         }
     
734.                 }
     
735.         }
     
736. 
     
737.         return result;       
     
738. }
     
739. 
     
740. //----------------------                         ----------------------                    
     
741. //                      -------------------------                      ---------------------
     
742. DWORD
     
743. GetKernelBase (
     
744.                            void
     
745.                            )
     
746. 
     
747. /*++
     
748. 
     
749. 学习者 : sudami [xiao_rui_119@163.com]
     
750. 时间   : 08/01/11
     
751. 
     
752. 功能 :
     
753.   为NtQuerySystemInformation传递11号参数,得到SYSTEM_MODULE_INFORMATION信息,遍历之,得到ntoskrnl.exe的基址
     
754. 
     
755. 参数 :  NULL
     
756. 
     
757. 返回 : TRUE | FALSE
     
758.   
     
759. --*/
     
760. {
     
761.         HANDLE hHeap = GetProcessHeap();
     
762.        
     
763.         NTSTATUS Status;
     
764.     ULONG cbBuffer = 0x8000;
     
765.     PVOID pBuffer = NULL;
     
766.         DWORD retVal = DEF_KERNEL_BASE; // 0x80400000
     
767. 
     
768.         // 这样申请内存 - cbBuffer *= 2;,不错不错.学习~
     
769.     do {
     
770.                 pBuffer = HeapAlloc (hHeap, 0, cbBuffer);
     
771.                 if (pBuffer == NULL) {
     
772.                         return DEF_KERNEL_BASE;
     
773.                 }
     
774. 
     
775.                 Status = NtQuerySystemInformation (SystemModuleInformation,        pBuffer, cbBuffer, NULL);
     
776. 
     
777.                 if (Status == STATUS_INFO_LENGTH_MISMATCH) {
     
778.                         HeapFree (hHeap, 0, pBuffer);
     
779.                         cbBuffer *= 2;
     
780.                 } else if (Status != STATUS_SUCCESS) {
     
781.                         HeapFree(hHeap, 0, pBuffer);
     
782.                         return DEF_KERNEL_BASE;
     
783.                 }
     
784.     }
     
785.     while (Status == STATUS_INFO_LENGTH_MISMATCH);
     
786. 
     
787.         // 其实没必要这样写哦. 得到系统模块的地址后,第一个就是ntoskrnl.exe的了
     
788.         DWORD numEntries = *((DWORD *)pBuffer);
     
789.         SYSTEM_MODULE_INFORMATION *smi = (SYSTEM_MODULE_INFORMATION *)((char *)pBuffer + sizeof(DWORD));
     
790. 
     
791.         for (DWORD i = 0; i < numEntries; i++) {
     
792.                 if (strcmpi(smi->ImageName, "ntoskrnl.exe")) {
     
793.                         retVal = (DWORD)(smi->Base);
     
794.                         break;
     
795.                 }
     
796. 
     
797.                 smi++;
     
798.         }
     
799. 
     
800.         HeapFree(hHeap, 0, pBuffer);
     
801. 
     
802.         return retVal;
     
803. }
     
804. 
     
805. //----------------------                         ----------------------                    
     
806. //                      -------------------------                      ---------------------
     
807. // Thanks to 90210 for this excellent way of getting the KiServiceTable address from the disk image of
     
808. // ntoskrnl.exe
     
809. // http://www.rootkit.com/newsread.php?newsid=176
     
810. DWORD
     
811. getKiServiceTableAddr (
     
812.   PVOID exeAddr,
     
813.   DWORD sdtAddr,
     
814.   PE_ExtHeader *peXH2
     
815.   )
     
816. 
     
817. /*--
     
818. 学习者 :  sudami [xiao_rui_119@163.com]
     
819. 时间   :  08/01/11
     
820. 
     
821. 参数   :  
     
822.   exeAddr - 从磁盘中读取指定的文件.在进程的heap当中分配一段空间,按照PE在内存中的对齐方式
     
823.             将文件映射到内存.得到的这个地址(这里用的是PVOID exeAddr = LoadDLL("\\ntoskrnl.exe"))
     
824. 
     
825.   sdtAddr - sdt在ntoskrnl.exe中的偏移量
     
826. 
     
827.   peXH2 - IMAGE_OPTIONAL_HEADER
     
828. 
     
829. 返回  :  TRUE | FALSE
     
830. 
     
831. 功能    :  得到真实的SDT地址
     
832.            btw: 此方法得到的不一定准确.系统出问题,后果自负~
     
833. 
     
834. --*/
     
835. {
     
836.         // 如果重定位表存在
     
837.         if ( peXH2->relocationTableAddress && peXH2->relocationTableSize ) {
     
838.                 //
     
839.                 // fixBlk保存的是当前数据块BLOCK[0]的起始地址
     
840.                 // fixBlk+1 所指向的内容便是这个数据块BLOCK[0]的 VirtualAddress。它指向第一个数据包
     
841.                 //
     
842.                 FixupBlock *fixBlk = (FixupBlock *)((char *)exeAddr + peXH2->relocationTableAddress);               
     
843. 
     
844.                 // 其实是一个BLOCK[n]数组。当fixBlk->blockSize不存在时，数组就遍历完了
     
845.                 while(fixBlk->blockSize) {
     
846.                         // 一个BLOCK数组中数据包的个数 = (一个数据块的大小 - 8) / 2
     
847.                         int numEntries = (fixBlk->blockSize - sizeof(FixupBlock)) >> 1;
     
848.        
     
849.                         //
     
850.                         // offsetPtr指向的是这个BLOCK数组中第一个数据包开始处的地址，然后依次+1。
     
851.                         // 直到把一个BLOCK遍历完。对每个数据包，判断里面的Type是否为3。如果是，把地址
     
852.                         // 转化为重定位后的地址
     
853.                         //
     
854.                         unsigned short *offsetPtr = (unsigned short *)(fixBlk + 1);
     
855. 
     
856.                         for(int i = 0; i < numEntries; i++)        {               
     
857.                                 // 得到每个数据包的重定位类型
     
858.                                 // *offsetPtr & 0xF000 得到的正是Type，右移12位得到它的大小
     
859.                                 int relocType = (*offsetPtr & 0xF000) >> 12;
     
860.                                
     
861.                                 if(relocType == 3) { // 如果是 IMAGE_REL_BASED_HIGHLOW (3)       
     
862. 
     
863.                                         // 计算代码的重定位地址
     
864.                                         // *offsetPtr & 0x0FFF 保存的是偏移量
     
865.                                         DWORD sudami  = (DWORD) (fixBlk->pageRVA + (*offsetPtr & 0x0FFF));
     
866.                                         DWORD *codeLoc = (DWORD *)((char *)exeAddr + sudami);                                       
     
867. 
     
868.                                         // *codeLoc 保存的是重定位后sdt在内存中的地址
     
869.                                         if (*codeLoc == sdtAddr + peXH2->imageBase &&
     
870.                                                 *(WORD *)((DWORD)codeLoc - 2) == 0x05c7) {
     
871. 
     
872.                                                 DWORD kiServiceTableAddr = *(DWORD *)((DWORD)codeLoc + 4);
     
873.                                                
     
874.                                                 // checks for presence of found address in the relocation table
     
875.                                                 if( sudami  + peXH2->imageBase == kiServiceTableAddr) {
     
876.                                                         return sudami ;
     
877.                                                 }
     
878.                                         }                                               
     
879.                                 }
     
880. 
     
881.                                 offsetPtr++;
     
882.                         }
     
883. 
     
884.                         fixBlk = (FixupBlock *)offsetPtr;
     
885.                 }
     
886.         }
     
887.         return 0;
     
888. }
     
889. 
     
890. //
     
891. // 主函数入口
     
892. //
     
893. int main (int argc, char* argv[])
     
894. {
     
895.         MZHeader mzH2;
     
896.         PE_Header peH2;
     
897.         PE_ExtHeader peXH2;
     
898.         SectionHeader *secHdr2;
     
899. 
     
900.         ::system ("title = SDTrestore V 0.2 [Learned by sudami] 08/01/12");
     
901.         printf("Author : SIG^2 G-TEC (www.security.org.sg)\n");
     
902.         printf("Learner: sudami [xiao_rui_119@163.com] \n\n");
     
903. 
     
904.         // 得到系统的版本信息
     
905.         OSVERSIONINFO ov;
     
906.         ov.dwOSVersionInfoSize = sizeof(ov);
     
907.         GetVersionEx (&ov);
     
908. 
     
909.         if (ov.dwMajorVersion != 5) {
     
910.                 printf("Sorry, this version supports only Win2K and WinXP.\n");
     
911.                 return 1;
     
912.         }
     
913. 
     
914.         if (ov.dwMinorVersion != 0 && ov.dwMinorVersion != 1) {
     
915.                 printf("Sorry, this version supports only Win2K and WinXP.\n");
     
916.                 return 1;
     
917.         }
     
918. 
     
919.         gWinVersion = ov.dwMinorVersion;
     
920. 
     
921.         if (!GetNativeAPIs()) {
     
922.                 printf("Failed to get addresses of Native APIs!\n");
     
923.                 return 1;
     
924.         }
     
925. 
     
926.         // 提升权限。使user能读写内存
     
927.         AssignACL();
     
928.         HANDLE hPhyMem = OpenPhyMem();
     
929. 
     
930.         if ( hPhyMem == INVALID_HANDLE_VALUE) {
     
931.                 AssignACL();
     
932.         }
     
933. 
     
934.         hPhyMem = OpenPhyMem();
     
935.         if (hPhyMem == INVALID_HANDLE_VALUE) {
     
936.                         printf("Could not open physical memory device!\n \
     
937.                                    Make sure you are running as Administrator.\n");
     
938.                         return 1;
     
939.         }
     
940. 
     
941.         // 映射 ntoskrnl.exe 到用户的进程空间中。对齐
     
942.         PVOID exeAddr = LoadDLL("ntoskrnl.exe");
     
943.         if (!exeAddr){
     
944.                 printf("Failed to load ntoskrnl.exe!\n");
     
945.                 return 1;
     
946.         }
     
947. 
     
948.         // 在其的EAT中得到SDT相对于ntoskrnl.exe的偏移
     
949.         DWORD sdtAddr = ProcAPIExportAddr ((DWORD)exeAddr, "KeServiceDescriptorTable");
     
950.         if (!sdtAddr) {
     
951.                 printf("Failed to get address of KeServiceDescriptorTable!\n");
     
952.                 return 1;
     
953.         }
     
954.        
     
955.         // 得到其映射后各部分的地址
     
956.         if (!ReadPEInfo((char *)exeAddr, &mzH2, &peH2, &peXH2, &secHdr2)) {
     
957.                 printf("Failed to get PE header of ntoskrnl.exe!\n");
     
958.                 return 1;
     
959.         }
     
960. 
     
961.         // kernelPhyBase 为系统加载ntoskrnl.exe后，相对于0x80000000的偏移（对齐了的）
     
962.         DWORD kernelPhyBase = GetKernelBase() - PROT_MEMBASE; //#define PROT_MEMBASE 0x80000000
     
963. 
     
964.         // kernelOffset 即是RVA
     
965.         DWORD kernelOffset = kernelPhyBase - peXH2.imageBase;
     
966.         printf ("KeServiceDescriptorTable\t\t%X\n", sdtAddr + GetKernelBase());
     
967. 
     
968.         /**********************************************************************************
     
969. 
     
970.         此时已经得到SSDT相对于ntoskrnl.exe的偏移了,保存于sdtAddr.采用普通的方法-->
     
971. 
     
972.         从磁盘读ntoskrnl.exe,计算对齐后的大小.将其对齐后映射到用户进程空间.在其EAT中得到
     
973.         SSDT相对于ntoskrnl.exe的偏移
     
974. 
     
975.         ***********************************************************************************/
     
976.         UCHAR *ptr = NULL;
     
977.         DWORD pAddr = sdtAddr + kernelPhyBase;
     
978.         DWORD wantedAddr = pAddr;
     
979.         DWORD len = 0x2000;
     
980. 
     
981.         // 第一次映射
     
982.         // 把系统加载的ntoskrnl.exe的SSDT地址映射到进程的虚拟地址空间里面去
     
983.         if (MapPhyMem(hPhyMem, &pAddr, &len, (LPVOID *)&ptr)) {
     
984.                
     
985.                 DWORD serviceTableAddr, sdtCount;
     
986. 
     
987.                 // 现在start保存的是 已经映射的内容的大小
     
988.                 // 其实是KeServiceDecriptorTable.base从开始到结束的这段大小
     
989.                 DWORD start        = wantedAddr - pAddr;
     
990. 
     
991.                 // 本来要映射len = 0x2000大小的,但实际上只映射了start大小
     
992.                 // wantedBytes 是没有按期望映射的差值
     
993.                 DWORD wantedBytes  = len - start;
     
994. /*--
     
995. typedef struct _KSERVICE_TABLE_DESCRIPTOR {
     
996.     PULONG_PTR Base;
     
997.     PULONG Count;
     
998.     ULONG Limit;
     
999.     PUCHAR Number;
     
1000. } KSERVICE_TABLE_DESCRIPTOR, *PKSERVICE_TABLE_DESCRIPTOR;
      
1001. ++*/
      
1002. 
      
1003.                 if (wantedBytes >= 4) {
      
1004. 
      
1005.                         serviceTableAddr = *((DWORD *)(&ptr[start]));
      
1006.                         printf("KeServiceDecriptorTable.ServiceTable\t%X\n", serviceTableAddr);
      
1007. 
      
1008.                         if (wantedBytes >= 12) {
      
1009. 
      
1010.                                 // &ptr[start] 是指针,此时指向Base结束的地方,Base中保存了很长一段的数据
      
1011.                                 // ((DWORD *)(&ptr[start])) + 2也是指针,指向KeServiceDescriptorTable.ServiceLimit
      
1012.                                 sdtCount = *(((DWORD *)(&ptr[start])) + 2);
      
1013.                                 printf("KeServiceDescriptorTable.ServiceLimit\t%d\n", sdtCount);
      
1014.                         }
      
1015.                 } else {
      
1016.                         printf("Sorry, an unexpected situation occurred!\n");
      
1017.                         return 1;
      
1018.                 }
      
1019. 
      
1020.                 UnMapPhyMem ((DWORD)ptr);
      
1021. 
      
1022.                 printf("\n");
      
1023. 
      
1024.                 if (sdtCount >= 300)        {
      
1025.                         printf("Sorry, an unexpected error occurred! SDT Count > 300???\n");
      
1026.                         return 1;
      
1027.                 }
      
1028. 
      
1029.                 pAddr = serviceTableAddr - PROT_MEMBASE; // 0x80000000
      
1030.                 wantedAddr = pAddr;
      
1031.                 ptr = NULL;
      
1032.                 len = 0x2000;
      
1033. 
      
1034.                 // 第2次映射
      
1035.                 // 把系统加载的ntoskrnl.exe的KeServiceDecriptorTable.base中的所有内容映射到进程的虚拟地址空间里面去
      
1036.                 if (MapPhyMem(hPhyMem, &pAddr, &len, (LPVOID *)&ptr)) {
      
1037. 
      
1038.                         //
      
1039.                         start = wantedAddr - pAddr;
      
1040.                         DWORD numEntries = (len - start) >> 2;
      
1041. 
      
1042.                         if (numEntries >= sdtCount) {
      
1043. 
      
1044.                                 // 为ST表分配名字所占用的空间
      
1045.                                 char **nativeApiNames = NULL;
      
1046.                                 nativeApiNames = (char **)malloc(sizeof(char *) * sdtCount);
      
1047. 
      
1048.                                 if(!nativeApiNames) {
      
1049.                                         printf("Failed to allocate memory for Native API name table.\n");
      
1050.                                         return 1;
      
1051.                                 }
      
1052. 
      
1053.                                 memset (nativeApiNames, 0, sizeof(char *) * sdtCount);
      
1054. 
      
1055.                                 // 映射ntdll.dll到内存,对齐
      
1056.                                 PVOID ntdll = LoadDLL("\\ntdll.dll");
      
1057. 
      
1058.                                 if(!ntdll) {
      
1059.                                         printf("Failed to load ntdll.dll!\n");
      
1060.                                         return 1;
      
1061.                                 }
      
1062. 
      
1063.                                 // 建立API名称表表
      
1064.                                 BuildNativeAPITable ((DWORD)ntdll, nativeApiNames, sdtCount);
      
1065. 
      
1066.                                 // *serviceTable 是系统地址空间内的ST表的地址.它是否被HOOK过还不晓得.
      
1067.                                 // 所以要拿它和我们自己从文件中读到的偏移相比较
      
1068.                                 DWORD *serviceTable = (DWORD *)(&ptr[start]);
      
1069. 
      
1070.                                 /***********************************
      
1071.                                 *                                  *
      
1072.                 *    这里得到了真实的ST地址啦      *
      
1073.                                 *                                  *
      
1074.                                 ***********************************/
      
1075.                                 // wantedAddr = serviceTableAddr - 0x80000000;
      
1076.                     // wantedAddr - kernelOffset. 即是ST表中系统范围内的地址 - RVA = ST在文件中的偏移
      
1077.                                 // *fileServiceTable 保存的是真实的ST表中每个函数的偏移
      
1078.                                 DWORD *fileServiceTable = (DWORD *)((DWORD)exeAddr + wantedAddr - kernelOffset - peXH2.imageBase);
      
1079.                                
      
1080.                                 // calculate address based on 90210's suggestion
      
1081.                                 DWORD fileAddr2 = (DWORD)exeAddr + getKiServiceTableAddr(exeAddr, sdtAddr, &peXH2);                               
      
1082.                                
      
1083.                             // start...
      
1084.                                 if (!IsBadReadPtr(fileServiceTable, sizeof(DWORD)) &&
      
1085.                                    !IsBadReadPtr(&fileServiceTable[sdtCount-1], sizeof(DWORD)))        {
      
1086. 
      
1087.                                         DWORD hookCount = 0;
      
1088.                                         for (DWORD i = 0; i < sdtCount; i++) {       
      
1089. 
      
1090.                                                 // 这里就是真正判断是否被HOOK 的地方
      
1091.                                                 if ( (serviceTable[i] - PROT_MEMBASE - kernelOffset) != fileServiceTable[i]) {
      
1092.                                                         printf("%-25s %3X --[hooked by unknown at %X]--\n",
      
1093.                                                                   (nativeApiNames[i] ? nativeApiNames[i] : "Unknown API"),
      
1094.                                                                   i, serviceTable[i]);
      
1095.                                                         hookCount++;
      
1096.                                                 }
      
1097.                                                
      
1098.                                         }
      
1099. 
      
1100.                                         printf("\nNumber of Service Table entries hooked = %u\n", hookCount);
      
1101.                                        
      
1102.                                         if (hookCount) {
      
1103.                                                 printf("\nFix SDT Entries (Y/N)? : ");
      
1104.        
      
1105.                                                 char inputReply[10];
      
1106.                                                 memset(inputReply, 0, sizeof(inputReply));
      
1107.                                                 fgets(inputReply, sizeof(inputReply) - 1, stdin);
      
1108.                                                 printf("\n");
      
1109.                                                                                
      
1110.                                                 // 恢复被HOOK的SDT
      
1111.                                                 if (stricmp(inputReply, "y\n") == 0) {
      
1112. 
      
1113.                                                         ::system ("cls");
      
1114.                                                         for(DWORD i = 0; i < sdtCount; i++)        {
      
1115. 
      
1116.                                                                 if((serviceTable[i] - PROT_MEMBASE - kernelOffset) != fileServiceTable[i]) {
      
1117.                                                                        
      
1118.                                                                         // 就这一句就搞定啦~
      
1119.                                                                         serviceTable[i] = fileServiceTable[i] + PROT_MEMBASE + kernelOffset;
      
1120. 
      
1121.                                                                         printf("[+] Patched SDT entry %.2X to %.8X\n", i,
      
1122.                                                                                 fileServiceTable[i] + PROT_MEMBASE + kernelOffset);
      
1123.                                                                 }
      
1124.                                                         }
      
1125. 
      
1126.                                                         printf("\n\n[+] SDT Recover is done,but if there is a KTIMER,the SDT may be re-HOOKED again\n");
      
1127.                                                         ::getchar ();
      
1128.                                                 } else {
      
1129.                                                         printf("[-] SDT Entries NOT fixed.\n");
      
1130.                                                         ::getchar ();
      
1131.                                                 }
      
1132.                                         }
      
1133.                                 } else {
      
1134.                                         printf("It's likely that the SDT service table has been relocated.\n"
      
1135.                                                    "This POC code cannot support patching of relocated SDT service table.\n");
      
1136.                                         ::getchar ();
      
1137.                                 }
      
1138. 
      
1139.                         }
      
1140. 
      
1141.                         UnMapPhyMem((DWORD)ptr);
      
1142.                 }
      
1143.         }
      
1144. 
      
1145.         return 0;
      
1146. }
      
1147. 
      
1148. //////////////////////////////////// END OF FILE /////////////////////////////////////////////

复制代码