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

丛林宝宝

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

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

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

复制代码