使用ZwQueryVirtualMemory枚举进程模块支持x64

塞翁364

使用ZwQueryVirtualMemory枚举进程模块支持x64

1. #include "stdio.h"
   
2. #include "windows.h"
   
3. 
   
4. typedef struct _LSA_UNICODE_STRING {
   
5.   USHORT Length;
   
6.   USHORT MaximumLength;
   
7.   PWSTR  Buffer;
   
8. } LSA_UNICODE_STRING, *PLSA_UNICODE_STRING, UNICODE_STRING, *PUNICODE_STRING;
   
9. 
   
10. //typedef struct _MEMORY_BASIC_INFORMATION {
    
11. //  PVOID  BaseAddress;
    
12. //  PVOID  AllocationBase;
    
13. //  DWORD  AllocationProtect;
    
14. //  SIZE_T RegionSize;
    
15. //  DWORD  State;
    
16. //  DWORD  Protect;
    
17. //  DWORD  Type;
    
18. //} MEMORY_BASIC_INFORMATION, *PMEMORY_BASIC_INFORMATION;
    
19. 
    
20. typedef long (*RTLADJUSTPRIVILEGE)(ULONG,ULONG,ULONG,PVOID);
    
21. RTLADJUSTPRIVILEGE RtlAdjustPrivilege;
    
22. 
    
23. typedef enum _MEMORY_INFORMATION_CLASS
    
24. {
    
25.    MemoryBasicInformation,
    
26.    MemoryWorkingSetList,
    
27.    MemorySectionName
    
28. }MEMORY_INFORMATION_CLASS;
    
29. 
    
30. 
    
31. NTSTATUS ZwQueryVirtualMemory(
    
32.   _In_      HANDLE                   ProcessHandle,
    
33.   _In_opt_  PVOID                    BaseAddress,
    
34.   _In_      MEMORY_INFORMATION_CLASS MemoryInformationClass,
    
35.   _Out_     PVOID                    MemoryInformation,
    
36.   _In_      SIZE_T                   MemoryInformationLength,
    
37.   _Out_opt_ PSIZE_T                  ReturnLength
    
38. );
    
39. 
    
40. 
    
41. typedef
    
42. NTSTATUS
    
43. (WINAPI *ZWQUERYVIRTUALMEMORY) (
    
44.                          IN HANDLE ProcessHandle,
    
45.                          IN PVOID BaseAddress,
    
46.                          IN MEMORY_INFORMATION_CLASS MemoryInformationClass,
    
47.                          OUT PVOID MemoryInformation,
    
48.                          IN SIZE_T MemoryInformationLength,
    
49.                          OUT PSIZE_T ReturnLength OPTIONAL
    
50.                          );
    
51. 
    
52. 
    
53. BOOLEAN NtPathToDosPathW(WCHAR *FullNtPath, WCHAR *FullDosPath)
    
54. {
    
55.         WCHAR DosDevice[4]= {0};       //dos设备名最大长度为4
    
56.         WCHAR NtPath[64]= {0};       //nt设备名最大长度为64
    
57.         WCHAR *RetStr=NULL;
    
58.         size_t NtPathLen=0;
    
59.         short i = 0;
    
60.         if (!FullNtPath || !FullDosPath)
    
61.         {
    
62.                 return FALSE;
    
63.         }
    
64.         for(i=65; i<26+65; i++)
    
65.         {
    
66.                 DosDevice[0]=i;
    
67.                 DosDevice[1]=L':';
    
68.                 if(QueryDosDeviceW(DosDevice,NtPath,64))
    
69.                 {
    
70.                         if (NtPath)
    
71.                         {
    
72.                                 NtPathLen=wcslen(NtPath);
    
73.                                 if (!wcsnicmp(NtPath,FullNtPath,NtPathLen))
    
74.                                 {
    
75.                                         wcscpy(FullDosPath,DosDevice);
    
76.                                         wcscat(FullDosPath,FullNtPath+NtPathLen);
    
77.                                         return TRUE;
    
78.                                 }
    
79.                         }
    
80.                 }
    
81.         }
    
82.         return FALSE;
    
83. }
    
84. 
    
85. void EnumProcessModules(IN DWORD dwProcessId)
    
86. {
    
87.    DWORD64 dwStartAddr = 0x00000000;
    
88.    ULONG    num = 0;
    
89.    BYTE szBuffer[MAX_PATH * 2 + 4] = {0};
    
90.    WCHAR szModuleName[MAX_PATH] = {0};
    
91.    WCHAR szPathName[MAX_PATH] = {0};
    
92.    MEMORY_BASIC_INFORMATION mbi;
    
93.    PUNICODE_STRING usSectionName;   
    
94.    ZWQUERYVIRTUALMEMORY fnZwQueryVirtualMemory;
    
95.    BOOL modulex64 = FALSE;
    
96.    HANDLE hProcess =NULL;
    
97.    ULONG    dwRetVal=0;
    
98. 
    
99. 
    
100.    RtlAdjustPrivilege=(RTLADJUSTPRIVILEGE)GetProcAddress(LoadLibraryW(L"ntdll.dll"),"RtlAdjustPrivilege");
     
101.    RtlAdjustPrivilege(20,1,0,&dwRetVal);//debug
     
102.    RtlAdjustPrivilege(19,1,0,&dwRetVal);
     
103.    hProcess = OpenProcess(PROCESS_ALL_ACCESS, TRUE, dwProcessId);
     
104. 
     
105.    if (hProcess == NULL)
     
106.    {
     
107.       wprintf(L"Open Process %d Error\n", dwProcessId);
     
108.       return;
     
109.    }
     
110. 
     
111.    //dwStartAddr = 0x000007fef4530000;
     
112.    dwStartAddr = 0x0000000000000000;
     
113. 
     
114.    fnZwQueryVirtualMemory = (ZWQUERYVIRTUALMEMORY)GetProcAddress(GetModuleHandleA("ntdll.dll"),"ZwQueryVirtualMemory" );
     
115. 
     
116.    if(fnZwQueryVirtualMemory)
     
117.    {
     
118.       do
     
119.       {
     
120.          if (fnZwQueryVirtualMemory(
     
121.             hProcess,
     
122.             (PVOID64)dwStartAddr,
     
123.             MemoryBasicInformation,
     
124.             &mbi,
     
125.             sizeof(mbi),
     
126.             0) >= 0 )
     
127.          {
     
128.             if(mbi.Type == MEM_IMAGE)
     
129.             {
     
130.                 if (fnZwQueryVirtualMemory(
     
131.                    hProcess,
     
132.                    (PVOID64)dwStartAddr,
     
133.                    MemorySectionName,
     
134.                    szBuffer,
     
135.                    sizeof(szBuffer),
     
136.                    0) >= 0 )
     
137.                 {
     
138.                    usSectionName = (PUNICODE_STRING)szBuffer;
     
139.                    if( _wcsnicmp(szModuleName, usSectionName->Buffer, usSectionName->Length / sizeof(WCHAR)) )
     
140.                    {
     
141.                       wcsncpy(szModuleName,usSectionName->Buffer,usSectionName->Length/sizeof(WCHAR));
     
142.                       szModuleName[usSectionName->Length / sizeof(WCHAR)] = UNICODE_NULL;
     
143.                      // DeviceName2PathName(szPathName, szModuleName);
     
144.                       NtPathToDosPathW(szModuleName,szPathName);
     
145.                       wprintf(L"[0x%.8llx]\t%s\n", dwStartAddr, szPathName);
     
146.                       num++;
     
147.                   }
     
148.                 }
     
149.             }
     
150. 
     
151.          }
     
152.          // 递增基址,开始下一轮查询!
     
153.          dwStartAddr += (ULONGLONG)0x1000;
     
154.          if(!modulex64){
     
155.              if(dwStartAddr>0x0000000200000000)
     
156.              {
     
157.                  modulex64 = TRUE;
     
158.                  dwStartAddr = 0x000007fe00000000;
     
159.              }
     
160.          }
     
161.       }while( dwStartAddr < 0x000007ff00000000 );
     
162.    }
     
163. 
     
164.    CloseHandle(hProcess);
     
165.    printf("module num :%d\n",num);
     
166. }
     
167. 
     
168. void  main()
     
169. {
     
170.     int pid = 0;
     
171.     printf("Input Pid:");
     
172.     scanf("%d",&pid);
     
173.     EnumProcessModules(pid);
     
174.     printf("ok!");
     
175.     getchar();
     
176.     getchar();
     
177.     getchar();
     
178.     return;
     
179. }

复制代码