C++ 获取x64和x86程序PEB，及环境变量。

hellfirehj

本程序可完美获得x64和x86程序PEB，及环境变量等信息。

程序首先用OpenProcess打开目标进程，然后用Ntddl.dll导入表中微软未公开函数NtWow64QueryInformationProcess64（NtQueryInformationProcess）、NtWow64ReadVirtualMemory64（ReadProcessMemory）来获得目标进程信息。

1. 
   
2. // EnumPEB.cpp : 定义控制台应用程序的入口点。
   
3. 
   
4. #include "stdafx.h"
   
5. #include<Windows.h>
   
6. #include<iostream>
   
7. #include <Strsafe.h>
   
8. using namespace std;
   
9. 
   
10. #define NT_SUCCESS(x) ((x) >= 0)
    
11. 
    
12. #define ProcessBasicInformation 0
    
13. typedef
    
14. NTSTATUS(WINAPI *pfnNtWow64QueryInformationProcess64)
    
15. (HANDLE ProcessHandle, UINT32 ProcessInformationClass,
    
16.         PVOID ProcessInformation, UINT32 ProcessInformationLength,
    
17.         UINT32* ReturnLength);
    
18. 
    
19. typedef
    
20. NTSTATUS(WINAPI *pfnNtWow64ReadVirtualMemory64)
    
21. (HANDLE ProcessHandle, PVOID64 BaseAddress,
    
22.         PVOID BufferData, UINT64 BufferLength,
    
23.         PUINT64 ReturnLength);
    
24. 
    
25. typedef
    
26. NTSTATUS(WINAPI *pfnNtQueryInformationProcess)
    
27. (HANDLE ProcessHandle, ULONG ProcessInformationClass,
    
28.         PVOID ProcessInformation, UINT32 ProcessInformationLength,
    
29.         UINT32* ReturnLength);
    
30. 
    
31. template <typename T>
    
32. struct _UNICODE_STRING_T
    
33. {
    
34.         WORD Length;
    
35.         WORD MaximumLength;
    
36.         T Buffer;
    
37. };
    
38. 
    
39. template <typename T>
    
40. struct _LIST_ENTRY_T
    
41. {
    
42.         T Flink;
    
43.         T Blink;
    
44. };
    
45. 
    
46. template <typename T, typename NGF, int A>
    
47. struct _PEB_T
    
48. {
    
49.         typedef T type;
    
50. 
    
51.         union
    
52.         {
    
53.                 struct
    
54.                 {
    
55.                         BYTE InheritedAddressSpace;
    
56.                         BYTE ReadImageFileExecOptions;
    
57.                         BYTE BeingDebugged;
    
58.                         BYTE BitField;
    
59.                 };
    
60.                 T dummy01;
    
61.         };
    
62.         T Mutant;
    
63.         T ImageBaseAddress;     //进程加载基地址
    
64.         T Ldr;                                    
    
65.         T ProcessParameters;    //各种信息，环境变量，命令行等等
    
66.         T SubSystemData;
    
67.         T ProcessHeap;
    
68.         T FastPebLock;
    
69.         T AtlThunkSListPtr;
    
70.         T IFEOKey;
    
71.         T CrossProcessFlags;
    
72.         T UserSharedInfoPtr;
    
73.         DWORD SystemReserved;
    
74.         DWORD AtlThunkSListPtr32;
    
75.         T ApiSetMap;
    
76.         T TlsExpansionCounter;
    
77.         T TlsBitmap;
    
78.         DWORD TlsBitmapBits[2];
    
79.         T ReadOnlySharedMemoryBase;
    
80.         T HotpatchInformation;
    
81.         T ReadOnlyStaticServerData;
    
82.         T AnsiCodePageData;
    
83.         T OemCodePageData;
    
84.         T UnicodeCaseTableData;
    
85.         DWORD NumberOfProcessors;
    
86.         union
    
87.         {
    
88.                 DWORD NtGlobalFlag;
    
89.                 NGF dummy02;
    
90.         };
    
91.         LARGE_INTEGER CriticalSectionTimeout;
    
92.         T HeapSegmentReserve;
    
93.         T HeapSegmentCommit;
    
94.         T HeapDeCommitTotalFreeThreshold;
    
95.         T HeapDeCommitFreeBlockThreshold;
    
96.         DWORD NumberOfHeaps;
    
97.         DWORD MaximumNumberOfHeaps;
    
98.         T ProcessHeaps;
    
99.         T GdiSharedHandleTable;
    
100.         T ProcessStarterHelper;
     
101.         T GdiDCAttributeList;
     
102.         T LoaderLock;
     
103.         DWORD OSMajorVersion;
     
104.         DWORD OSMinorVersion;
     
105.         WORD OSBuildNumber;
     
106.         WORD OSCSDVersion;
     
107.         DWORD OSPlatformId;
     
108.         DWORD ImageSubsystem;
     
109.         DWORD ImageSubsystemMajorVersion;
     
110.         T ImageSubsystemMinorVersion;
     
111.         T ActiveProcessAffinityMask;
     
112.         T GdiHandleBuffer[A];
     
113.         T PostProcessInitRoutine;
     
114.         T TlsExpansionBitmap;
     
115.         DWORD TlsExpansionBitmapBits[32];
     
116.         T SessionId;
     
117.         ULARGE_INTEGER AppCompatFlags;
     
118.         ULARGE_INTEGER AppCompatFlagsUser;
     
119.         T pShimData;
     
120.         T AppCompatInfo;
     
121.         _UNICODE_STRING_T<T> CSDVersion;
     
122.         T ActivationContextData;
     
123.         T ProcessAssemblyStorageMap;
     
124.         T SystemDefaultActivationContextData;
     
125.         T SystemAssemblyStorageMap;
     
126.         T MinimumStackCommit;
     
127.         T FlsCallback;
     
128.         _LIST_ENTRY_T<T> FlsListHead;
     
129.         T FlsBitmap;
     
130.         DWORD FlsBitmapBits[4];
     
131.         T FlsHighIndex;
     
132.         T WerRegistrationData;
     
133.         T WerShipAssertPtr;
     
134.         T pContextData;
     
135.         T pImageHeaderHash;
     
136.         T TracingFlags;
     
137.         T CsrServerReadOnlySharedMemoryBase;
     
138. };
     
139. 
     
140. template <typename T>
     
141. struct _STRING_T
     
142. {
     
143.         WORD Length;
     
144.         WORD MaximumLength;
     
145.         T    Buffer;
     
146. };
     
147. 
     
148. template <typename T>
     
149. struct _RTL_DRIVE_LETTER_CURDIR_T
     
150. {
     
151.         WORD         Flags;
     
152.         WORD         Length;
     
153.         ULONG        TimeStamp;
     
154.         _STRING_T<T> DosPath;
     
155. };
     
156. 
     
157. template <typename T>
     
158. struct _CURDIR_T
     
159. {
     
160.         _UNICODE_STRING_T<T> DosPath;
     
161.         T                                 Handle;
     
162. };
     
163. 
     
164. template <typename T>
     
165. struct _RTL_USER_PROCESS_PARAMETERS_T
     
166. {
     
167.         ULONG MaximumLength;
     
168.         ULONG Length;
     
169.         ULONG Flags;
     
170.         ULONG DebugFlags;
     
171.         T ConsoleHandle;
     
172.         ULONG  ConsoleFlags;
     
173.         T StandardInput;
     
174.         T StandardOutput;
     
175.         T StandardError;
     
176.         _CURDIR_T<T> CurrentDirectory;
     
177.         _UNICODE_STRING_T<T> DllPath;
     
178.         _UNICODE_STRING_T<T> ImagePathName; //进程完整路径
     
179.         _UNICODE_STRING_T<T> CommandLine;   //进程命令行
     
180.         T Environment;             //环境变量（地址）
     
181.         ULONG StartingX;
     
182.         ULONG StartingY;
     
183.         ULONG CountX;
     
184.         ULONG CountY;
     
185.         ULONG CountCharsX;
     
186.         ULONG CountCharsY;
     
187.         ULONG FillAttribute;
     
188.         ULONG WindowFlags;
     
189.         ULONG ShowWindowFlags;
     
190.         _UNICODE_STRING_T<T> WindowTitle;
     
191.         _UNICODE_STRING_T<T> DesktopInfo;
     
192.         _UNICODE_STRING_T<T> ShellInfo;
     
193.         _UNICODE_STRING_T<T> RuntimeData;
     
194.         _RTL_DRIVE_LETTER_CURDIR_T<T> CurrentDirectores[32];
     
195.         ULONG EnvironmentSize;
     
196. };
     
197. 
     
198. typedef _PEB_T<DWORD, DWORD64, 34> _PEB32;
     
199. typedef _PEB_T<DWORD64, DWORD, 30> _PEB64;
     
200. typedef _RTL_USER_PROCESS_PARAMETERS_T<UINT32> _RTL_USER_PROCESS_PARAMETERS32;
     
201. typedef _RTL_USER_PROCESS_PARAMETERS_T<UINT64> _RTL_USER_PROCESS_PARAMETERS64;
     
202. 
     
203. typedef struct _PROCESS_BASIC_INFORMATION64 {
     
204.         NTSTATUS ExitStatus;
     
205.         UINT32 Reserved0;
     
206.         UINT64 PebBaseAddress;
     
207.         UINT64 AffinityMask;
     
208.         UINT32 BasePriority;
     
209.         UINT32 Reserved1;
     
210.         UINT64 UniqueProcessId;
     
211.         UINT64 InheritedFromUniqueProcessId;
     
212. } PROCESS_BASIC_INFORMATION64;
     
213. 
     
214. typedef struct _PROCESS_BASIC_INFORMATION32 {
     
215.         NTSTATUS ExitStatus;
     
216.         UINT32 PebBaseAddress;
     
217.         UINT32 AffinityMask;
     
218.         UINT32 BasePriority;
     
219.         UINT32 UniqueProcessId;
     
220.         UINT32 InheritedFromUniqueProcessId;
     
221. } PROCESS_BASIC_INFORMATION32;
     
222. 
     
223. 
     
224. typedef struct _PEB_INFO {
     
225.         UINT64 ImageBaseAddress;  //进程加载基地址
     
226.         UINT64 Ldr;               //模块加载基地址
     
227.         UINT64 ProcessHeap;       //进程默认堆
     
228.         UINT64 ProcessParameters; //进程信息
     
229.         UINT64 Environment;       //环境变量
     
230. }PEBInfo,*PPEBInfo;
     
231. 
     
232. int main()
     
233. {
     
234.         printf("输入进程ID\r\n");
     
235.         UINT32 ProcessID;
     
236.         cin >> ProcessID;
     
237.         HANDLE ProcessHandle = NULL;
     
238.         //获得进程句柄
     
239.         ProcessHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, ProcessID);
     
240.         PEBInfo PebInfo = {0};
     
241.         BOOL bSource = FALSE;
     
242.         BOOL bTarget = FALSE;
     
243.         //判断自己的位数
     
244.         IsWow64Process(GetCurrentProcess(), &bSource);
     
245.         //判断目标的位数
     
246.         IsWow64Process(ProcessHandle, &bTarget);
     
247. 
     
248.         //自己是32  目标64
     
249.         if (bTarget == FALSE && bSource == TRUE)
     
250.         {
     
251.                 HMODULE NtdllModule = GetModuleHandle("ntdll.dll");
     
252.                 pfnNtWow64QueryInformationProcess64 NtWow64QueryInformationProcess64 = (pfnNtWow64QueryInformationProcess64)GetProcAddress(NtdllModule,
     
253.                         "NtWow64QueryInformationProcess64");
     
254.         
     
255.                 pfnNtWow64ReadVirtualMemory64 NtWow64ReadVirtualMemory64 = (pfnNtWow64ReadVirtualMemory64)GetProcAddress(NtdllModule, "NtWow64ReadVirtualMemory64");
     
256.                 PROCESS_BASIC_INFORMATION64 pbi = { 0 };
     
257.                 UINT64 ReturnLength = 0;
     
258.                 NTSTATUS Status = NtWow64QueryInformationProcess64(ProcessHandle, ProcessBasicInformation,
     
259.                         &pbi, (UINT32)sizeof(pbi), (UINT32*)&ReturnLength);
     
260. 
     
261.                 if (NT_SUCCESS(Status))
     
262.                 {
     
263.                         
     
264.                         _PEB64* Peb = (_PEB64*)malloc(sizeof(_PEB64));
     
265.                         Status = NtWow64ReadVirtualMemory64(ProcessHandle, (PVOID64)pbi.PebBaseAddress,
     
266.                                 (_PEB64*)Peb, sizeof(_PEB64), &ReturnLength);        
     
267.                         _RTL_USER_PROCESS_PARAMETERS64 Parameters64;
     
268.                         Status = NtWow64ReadVirtualMemory64(ProcessHandle, (PVOID64)Peb->ProcessParameters,
     
269.                                 &Parameters64, sizeof(_RTL_USER_PROCESS_PARAMETERS64), &ReturnLength);
     
270. 
     
271.                         BYTE* Environment = new BYTE[Parameters64.EnvironmentSize * 2];
     
272.                         Status = NtWow64ReadVirtualMemory64(ProcessHandle, (PVOID64)Parameters64.Environment, Environment, Parameters64.EnvironmentSize, NULL);
     
273.                         //赋值
     
274.                         PebInfo.ImageBaseAddress = Peb->ImageBaseAddress;
     
275.                         PebInfo.Ldr = Peb->Ldr;
     
276.                         PebInfo.ProcessHeap = Peb->ProcessHeap;
     
277.                         PebInfo.ProcessParameters = Peb->ProcessParameters;
     
278.                         PebInfo.Environment = Parameters64.Environment;
     
279. 
     
280.                         printf("ImageBaseAddress:0x%x\r\n", PebInfo.ImageBaseAddress);
     
281.                         printf("Ldr:0x%x\r\n", PebInfo.Ldr);
     
282.                         printf("ProcessHeap:0x%x\r\n", PebInfo.ProcessHeap);
     
283.                         printf("ProcessParameters:0x%x\r\n", PebInfo.ProcessParameters);
     
284.                         printf("Environment:0x%x\r\n", PebInfo.Environment);
     
285.                         while (Environment != NULL)
     
286.                         {
     
287.                                 char* v1 = NULL;
     
288.                                 int DataLength = WideCharToMultiByte(CP_ACP, NULL, (WCHAR*)Environment, -1, NULL, 0, NULL, FALSE);
     
289.                                 v1 = new char[DataLength + 1];
     
290.                                 WideCharToMultiByte(CP_OEMCP, NULL, (WCHAR*)Environment, -1, v1, Parameters64.EnvironmentSize * 2, NULL, FALSE);
     
291.                                 printf("%s\r\n", v1);
     
292.                                 // 指针移动到字符串末尾  
     
293.                                 while (*(WCHAR*)Environment != '\0')
     
294.                                         Environment += 2;
     
295.                                 Environment += 2;
     
296.                                 // 是否是最后一个字符串  
     
297.                                 if (*Environment == '\0')
     
298.                                         break;
     
299.                         }
     
300.                         BYTE* CommandLine = new BYTE[Parameters64.CommandLine.Length];
     
301.                         Status = NtWow64ReadVirtualMemory64(ProcessHandle, (PVOID64)Parameters64.CommandLine.Buffer, CommandLine, Parameters64.CommandLine.Length, NULL);
     
302.                         if (CommandLine != NULL)
     
303.                         {
     
304.                                 char* v1 = NULL;
     
305.                                 int DataLength = WideCharToMultiByte(CP_ACP, NULL, (WCHAR*)CommandLine, -1, NULL, 0, NULL, FALSE);
     
306.                                 v1 = new char[DataLength];
     
307.                                 WideCharToMultiByte(CP_OEMCP, NULL, (WCHAR*)CommandLine, -1, v1, Parameters64.CommandLine.Length, NULL, FALSE);
     
308.                                 printf("CommandLine:%s\r\n", v1);
     
309.                         }
     
310.                         BYTE* ImagePathName = new BYTE[Parameters64.ImagePathName.Length];
     
311.                         Status = NtWow64ReadVirtualMemory64(ProcessHandle, (PVOID64)Parameters64.ImagePathName.Buffer, ImagePathName, Parameters64.ImagePathName.Length, NULL);
     
312.                         if (ImagePathName != NULL)
     
313.                         {
     
314.                                 char* v1 = NULL;
     
315.                                 int DataLength = WideCharToMultiByte(CP_ACP, NULL, (WCHAR*)ImagePathName, -1, NULL, 0, NULL, FALSE);
     
316.                                 v1 = new char[DataLength];
     
317.                                 WideCharToMultiByte(CP_OEMCP, NULL, (WCHAR*)ImagePathName, -1, v1, Parameters64.ImagePathName.Length, NULL, FALSE);
     
318.                                 printf("ImagePathName:%s\r\n", v1);
     
319.                         }
     
320.                 }
     
321.                
     
322.         }
     
323.         //自己是32  目标是32
     
324.         else if (bTarget == TRUE && bSource == TRUE)
     
325.         {
     
326.                 HMODULE NtdllModule = GetModuleHandle("ntdll.dll");
     
327.                 pfnNtQueryInformationProcess NtQueryInformationProcess = (pfnNtQueryInformationProcess)GetProcAddress(NtdllModule,
     
328.                         "NtQueryInformationProcess");
     
329.                 PROCESS_BASIC_INFORMATION32 pbi = { 0 };
     
330.                 UINT32  ReturnLength = 0;
     
331.                 NTSTATUS Status = NtQueryInformationProcess(ProcessHandle,
     
332.                         ProcessBasicInformation, &pbi, (UINT32)sizeof(pbi), (UINT32*)&ReturnLength);
     
333. 
     
334.                 if (NT_SUCCESS(Status))
     
335.                 {
     
336.                         _PEB32* Peb = (_PEB32*)malloc(sizeof(_PEB32));
     
337.                         Status  = ReadProcessMemory(ProcessHandle, (PVOID)pbi.PebBaseAddress, (_PEB32*)Peb, sizeof(_PEB32), NULL);
     
338. 
     
339.                         _RTL_USER_PROCESS_PARAMETERS32 Parameters32;
     
340. 
     
341.                         Status = ReadProcessMemory(ProcessHandle, (PVOID)Peb->ProcessParameters, &Parameters32, sizeof(_RTL_USER_PROCESS_PARAMETERS32), NULL);
     
342.                         BYTE* Environment = new BYTE[Parameters32.EnvironmentSize*2];
     
343.                         Status = ReadProcessMemory(ProcessHandle, (PVOID)Parameters32.Environment, Environment, Parameters32.EnvironmentSize, NULL);
     
344. 
     
345.                         //赋值
     
346.                         PebInfo.ImageBaseAddress = Peb->ImageBaseAddress;
     
347.                         PebInfo.Ldr = Peb->Ldr;
     
348.                         PebInfo.ProcessHeap = Peb->ProcessHeap;
     
349.                         PebInfo.ProcessParameters = Peb->ProcessParameters;
     
350.                         PebInfo.Environment = Parameters32.Environment;
     
351.                         printf("ImageBaseAddress:0x%x\r\n", PebInfo.ImageBaseAddress);
     
352.                         printf("Ldr:0x%x\r\n", PebInfo.Ldr);
     
353.                         printf("ProcessHeap:0x%x\r\n", PebInfo.ProcessHeap);
     
354.                         printf("ProcessParameters:0x%x\r\n", PebInfo.ProcessParameters);
     
355.                         printf("Environment:0x%x\r\n", PebInfo.Environment);
     
356.                         while (Environment !=NULL)
     
357.                         {
     
358.                                 char* v1 = NULL;
     
359.                                 int DataLength = WideCharToMultiByte(CP_ACP, NULL, (WCHAR*)Environment, -1, NULL, 0, NULL, FALSE);
     
360.                                 v1 = new char[DataLength + 1];
     
361.                                 WideCharToMultiByte(CP_OEMCP, NULL, (WCHAR*)Environment, -1, v1, Parameters32.EnvironmentSize * 2, NULL, FALSE);
     
362.                                 printf("%s\r\n", v1);
     
363.                                 // 指针移动到字符串末尾  
     
364.                                 while (*(WCHAR*)Environment != '\0')
     
365.                                         Environment +=2;
     
366.                                 Environment += 2;
     
367.                                 // 是否是最后一个字符串  
     
368.                                 if (*Environment == '\0')
     
369.                                         break;
     
370.                         }
     
371.                         
     
372.                         BYTE* CommandLine = new BYTE[Parameters32.CommandLine.Length];
     
373.                         Status = ReadProcessMemory(ProcessHandle, (PVOID)Parameters32.CommandLine.Buffer, CommandLine, Parameters32.CommandLine.Length, NULL);
     
374.                         if (CommandLine != NULL)
     
375.                         {
     
376.                                 char* v1 = NULL;
     
377.                                 int DataLength = WideCharToMultiByte(CP_ACP, NULL, (WCHAR*)CommandLine, -1, NULL, 0, NULL, FALSE);
     
378.                                 v1 = new char[DataLength];
     
379.                                 WideCharToMultiByte(CP_OEMCP, NULL, (WCHAR*)CommandLine, -1, v1, Parameters32.CommandLine.Length, NULL, FALSE);
     
380.                                 printf("CommandLine:%s\r\n", v1);
     
381.                         }
     
382.                         BYTE* ImagePathName = new BYTE[Parameters32.ImagePathName.Length];
     
383.                         Status = ReadProcessMemory(ProcessHandle, (PVOID)Parameters32.ImagePathName.Buffer, ImagePathName, Parameters32.ImagePathName.Length, NULL);
     
384.                         if (ImagePathName != NULL)
     
385.                         {
     
386.                                 char* v1 = NULL;
     
387.                                 int DataLength = WideCharToMultiByte(CP_ACP, NULL, (WCHAR*)ImagePathName, -1, NULL, 0, NULL, FALSE);
     
388.                                 v1 = new char[DataLength];
     
389.                                 WideCharToMultiByte(CP_OEMCP, NULL, (WCHAR*)ImagePathName, -1, v1, Parameters32.ImagePathName.Length, NULL, FALSE);
     
390.                                 printf("ImagePathName:%s\r\n", v1);
     
391.                         }
     
392.                 }
     
393.         }        
     
394. }
     

复制代码