获得目标进程PEB，并获得进程各种信息

Jacqueline季

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

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

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

复制代码