64位环境下32位进程获取64位进程的命令行参数和当前目录

shuchang

1. 
   
2. BOOL GetProcessCurDir(HANDLE hProcess,mystring&strCurDir)
   
3. {
   
4.     BOOL bSuccess = FALSE;
   
5.     PROCESS_BASIC_INFORMATION pbi;
   
6.     TNtQueryInformationProcess pfnNtQueryInformationProcess = NULL;
   
7.     TNtReadVirtualMemory pfnNtReadVirtualMemory = NULL;
   
8. 
   
9.     pfnNtQueryInformationProcess = (TNtQueryInformationProcess)GetProcAddress(GetModuleHandle(_T("ntdll.dll")),"NtQueryInformationProcess");
   
10.     pfnNtReadVirtualMemory = (TNtReadVirtualMemory)GetProcAddress(GetModuleHandle(_T("ntdll.dll")),"NtReadVirtualMemory");
    
11. 
    
12.     if ( pfnNtQueryInformationProcess!=NULL ){
    
13.         DWORD dwSize;
    
14.         SIZE_T size;
    
15.         int iReturn;
    
16.         PVOID pAddrPEB = NULL;
    
17. 
    
18.         iReturn = pfnNtQueryInformationProcess( hProcess,ProcessBasicInformation,&pbi,sizeof(pbi),&dwSize);
    
19.         pAddrPEB = pbi.PebBaseAddress;     
    
20. 
    
21.         // NtQueryInformationProcess returns a negative value if it fails
    
22.         if (iReturn >= 0) {
    
23.             // 1. Find the Process Environment Block
    
24.             __PEB PEB;
    
25.             size = dwSize;
    
26.             if ( ERROR_SUCCESS != pfnNtReadVirtualMemory(hProcess, pAddrPEB, &PEB, sizeof(PEB), &size) ) {
    
27.                 // Call GetLastError() if you need to know why
    
28.                 return bSuccess;
    
29.             }
    
30. 
    
31.             // 2. From this PEB, get the address of the block containing
    
32.             // a pointer to the CmdLine
    
33.             _RTL_USER_PROCESS_PARAMETERS stBlock;
    
34.             if ( ERROR_SUCCESS != pfnNtReadVirtualMemory(hProcess, (LPVOID)PEB.ProcessParameters, &stBlock, sizeof(stBlock), &size)) {
    
35.                 // Call GetLastError() if you need to know why
    
36.                 return bSuccess;
    
37.             }
    
38. 
    
39.             // 3. Get the CurDir
    
40.             wchar_t wszCurDir[MAX_PATH+1];
    
41.             if ( ERROR_SUCCESS != pfnNtReadVirtualMemory(hProcess, (LPVOID)stBlock.DosPath.Buffer,
    
42.                 wszCurDir, stBlock.DosPath.Length*sizeof(wchar_t), &size)) {
    
43.                     // Call GetLastError() if you need to know why
    
44.                     return bSuccess;
    
45.             }
    
46. 
    
47. #ifdef UNICODE
    
48.             // Both strings are in UNICODE.
    
49.             strCurDir.assign(wszCurDir);
    
50. #else
    
51.             CHAR szCurDir[MAX_PATH+1];
    
52.             WideCharToMultiByte(CP_ACP,0,wszCurDir,size/sizeof(wchar_t),szCurDir,MAX_PATH,NULL,NULL);
    
53.             strCurDir.assign(szCurDir);
    
54. #endif
    
55.             bSuccess = TRUE;
    
56.         }
    
57.     }
    
58.     return bSuccess;
    
59. }
    
60. 
    
61. 
    
62. BOOL GetProcessCurDir64(HANDLE hProcess,mystring&strCurDir)
    
63. {
    
64.     BOOL bSuccess = FALSE;
    
65.     PROCESS_BASIC_INFORMATION64 pbi64;
    
66.     TNtQueryInformationProcess pfnNtQueryInformationProcess = NULL;
    
67.     TNtReadVirtualMemory64 pfnNtReadVirtualMemory = NULL;
    
68. 
    
69.     pfnNtQueryInformationProcess = (TNtQueryInformationProcess)GetProcAddress(GetModuleHandle(_T("ntdll.dll")),"NtWow64QueryInformationProcess64");
    
70.     pfnNtReadVirtualMemory = (TNtReadVirtualMemory64)GetProcAddress(GetModuleHandle(_T("ntdll.dll")),"NtWow64ReadVirtualMemory64");
    
71. 
    
72.     if ( pfnNtQueryInformationProcess!=NULL ){
    
73.         DWORD dwSize;
    
74.         UINT64 size;
    
75.         int iReturn;
    
76.         PVOID64 pAddrPEB = NULL;
    
77.         
    
78.         iReturn = pfnNtQueryInformationProcess( hProcess,ProcessBasicInformation,&pbi64,sizeof(pbi64),&dwSize);
    
79.         pAddrPEB = pbi64.PebBaseAddress;
    
80. 
    
81.         // NtQueryInformationProcess returns a negative value if it fails
    
82.         if (iReturn >= 0) {
    
83.             // 1. Find the Process Environment Block
    
84.             __PEB64 PEB;
    
85.             size = dwSize;
    
86.             if ( ERROR_SUCCESS != pfnNtReadVirtualMemory(hProcess, pAddrPEB, &PEB, sizeof(PEB), &size) ) {
    
87.                 // Call GetLastError() if you need to know why
    
88.                 return bSuccess;
    
89.             }
    
90. 
    
91.             // 2. From this PEB, get the address of the block containing
    
92.             // a pointer to the CmdLine
    
93.             _RTL_USER_PROCESS_PARAMETERS64 stBlock;
    
94.             if ( ERROR_SUCCESS != pfnNtReadVirtualMemory(hProcess, PEB.ProcessParameters, &stBlock, sizeof(stBlock),&size)) {
    
95.                 // Call GetLastError() if you need to know why
    
96.                 return bSuccess;
    
97.             }
    
98. 
    
99.             // 3. Get the CurDir
    
100.             wchar_t wszCurDir[MAX_PATH+1];
     
101.             if ( ERROR_SUCCESS != pfnNtReadVirtualMemory(hProcess, stBlock.DosPath.Buffer,
     
102.                 wszCurDir, stBlock.DosPath.Length*sizeof(wchar_t), &size)) {
     
103.                     // Call GetLastError() if you need to know why
     
104.                     return bSuccess;
     
105.             }
     
106. 
     
107. #ifdef UNICODE
     
108.             // Both strings are in UNICODE.
     
109.             strCurDir.assign(wszCurDir);
     
110. #else
     
111.             CHAR szCurDir[MAX_PATH+1];
     
112.             WideCharToMultiByte(CP_ACP,0,wszCurDir,size/sizeof(wchar_t),szCurDir,MAX_PATH,NULL,NULL);
     
113.             strCurDir.assign(szCurDir);
     
114. #endif
     
115.             bSuccess = TRUE;
     
116.         }
     
117.     }
     
118.     return bSuccess;
     
119. }
     
120. 
     
121. 
     
122. BOOL GetProcessCmdLine(HANDLE hProcess,mystring&strCmdLine)
     
123. {
     
124.     BOOL bSuccess = FALSE;
     
125.     PROCESS_BASIC_INFORMATION pbi;
     
126.     TNtQueryInformationProcess pfnNtQueryInformationProcess = NULL;
     
127.     TNtReadVirtualMemory pfnNtReadVirtualMemory = NULL;
     
128. 
     
129.     pfnNtQueryInformationProcess = (TNtQueryInformationProcess)GetProcAddress(GetModuleHandle(_T("ntdll.dll")),"NtQueryInformationProcess");
     
130.     pfnNtReadVirtualMemory = (TNtReadVirtualMemory)GetProcAddress(GetModuleHandle(_T("ntdll.dll")),"NtReadVirtualMemory");
     
131. 
     
132.     if ( pfnNtQueryInformationProcess!=NULL ){
     
133.         DWORD dwSize;
     
134.         SIZE_T size;
     
135.         int iReturn;
     
136.         PVOID pAddrPEB = NULL;
     
137. 
     
138.         iReturn = pfnNtQueryInformationProcess( hProcess,ProcessBasicInformation,&pbi,sizeof(pbi),&dwSize);
     
139.         pAddrPEB = pbi.PebBaseAddress;
     
140. 
     
141.         // NtQueryInformationProcess returns a negative value if it fails
     
142.         if (iReturn >= 0) {
     
143.             // 1. Find the Process Environment Block
     
144.             __PEB PEB;
     
145.             size = dwSize;
     
146.             if ( ERROR_SUCCESS != pfnNtReadVirtualMemory(hProcess, pAddrPEB, &PEB, sizeof(PEB), &size) ) {
     
147.                 // Call GetLastError() if you need to know why
     
148.                 return bSuccess;
     
149.             }
     
150. 
     
151.             // 2. From this PEB, get the address of the block containing
     
152.             // a pointer to the CmdLine
     
153.             _RTL_USER_PROCESS_PARAMETERS Block;
     
154.             if ( ERROR_SUCCESS != pfnNtReadVirtualMemory(hProcess, (LPVOID)PEB.ProcessParameters, &Block, sizeof(Block), &size)) {
     
155.                     // Call GetLastError() if you need to know why
     
156.                     return(FALSE);
     
157.             }
     
158. 
     
159.             // 3. Get the CmdLine
     
160.             wchar_t wszCmdLine[MAX_PATH+1] = {0};
     
161.             if ( ERROR_SUCCESS != pfnNtReadVirtualMemory(hProcess, (LPVOID)Block.CmdLine.Buffer,
     
162.                 wszCmdLine, MAX_PATH*sizeof(wchar_t), &size)) {
     
163.                     // Call GetLastError() if you need to know why
     
164.                     return(FALSE);
     
165.             }
     
166. 
     
167.             // 4. Skip the application pathname
     
168.             //    it can be empty, "c:\...\app.exe" or c:\...\app.exe
     
169.             wchar_t* pPos = wszCmdLine;
     
170.             if (*pPos != L'\0') {
     
171.                 if (*pPos == L'"') {
     
172.                     // Find the next " character
     
173.                     pPos = wcschr(&pPos[1], L'"');
     
174.                 } else {
     
175.                     // Find the next SPACE character
     
176.                     pPos = wcschr(&pPos[1], L'');
     
177.                 }
     
178. 
     
179.                 // Skip it
     
180.                 if (pPos != NULL)
     
181.                     pPos++;
     
182.             }
     
183. 
     
184.             // Copy it back
     
185.             if (pPos != NULL) {
     
186. 
     
187.                 if (*pPos != L'\0') {
     
188. #ifdef UNICODE
     
189.                     // Both strings are in UNICODE.
     
190.                     strCmdLine.assign(wszCmdLine);
     
191. #else
     
192.                     CHAR szCmdLine[MAX_PATH+1] = {0};
     
193.                     WideCharToMultiByte(CP_ACP,0,wszCmdLine,size/sizeof(wchar_t),szCmdLine,MAX_PATH,NULL,NULL);
     
194.                     strCmdLine = szCmdLine;
     
195. #endif
     
196.                     bSuccess = TRUE;
     
197.                 }
     
198.             }
     
199.         }
     
200.     }
     
201.     return bSuccess;
     
202. }
     
203. 
     
204. 
     
205. BOOL GetProcessCmdLine64(HANDLE hProcess,mystring&strCmdLine)
     
206. {
     
207.     BOOL bSuccess = FALSE;
     
208.     PROCESS_BASIC_INFORMATION64 pbi64;
     
209.     TNtQueryInformationProcess pfnNtQueryInformationProcess = NULL;
     
210.     TNtReadVirtualMemory64 pfnNtReadVirtualMemory = NULL;
     
211. 
     
212.     pfnNtQueryInformationProcess = (TNtQueryInformationProcess)GetProcAddress(GetModuleHandle(_T("ntdll.dll")),"NtWow64QueryInformationProcess64");
     
213.     pfnNtReadVirtualMemory = (TNtReadVirtualMemory64)GetProcAddress(GetModuleHandle(_T("ntdll.dll")),"NtWow64ReadVirtualMemory64");
     
214. 
     
215.     if ( pfnNtQueryInformationProcess!=NULL ){
     
216.         DWORD dwSize;
     
217.         UINT64 size;
     
218.         int iReturn;
     
219.         PVOID64 pAddrPEB = NULL;
     
220. 
     
221.         iReturn = pfnNtQueryInformationProcess( hProcess,ProcessBasicInformation,&pbi64,sizeof(pbi64),&dwSize);
     
222.         pAddrPEB = pbi64.PebBaseAddress;
     
223. 
     
224.         // NtQueryInformationProcess returns a negative value if it fails
     
225.         if (iReturn >= 0) {
     
226.             // 1. Find the Process Environment Block
     
227.             __PEB64 PEB;
     
228.             size = dwSize;
     
229.             if ( ERROR_SUCCESS != pfnNtReadVirtualMemory(hProcess, pAddrPEB, &PEB, sizeof(PEB), &size) ) {
     
230.                 // Call GetLastError() if you need to know why
     
231.                 return bSuccess;
     
232.             }
     
233. 
     
234.             // 2. From this PEB, get the address of the block containing
     
235.             // a pointer to the CmdLine
     
236.             _RTL_USER_PROCESS_PARAMETERS64 stBlock;
     
237.             if ( ERROR_SUCCESS != pfnNtReadVirtualMemory(hProcess, (LPVOID)PEB.ProcessParameters, &stBlock, sizeof(stBlock), &size)) {
     
238.                 // Call GetLastError() if you need to know why
     
239.                 return(FALSE);
     
240.             }
     
241. 
     
242.             // 3. Get the CmdLine
     
243.             wchar_t wszCmdLine[MAX_PATH+1] = {0};
     
244.             if ( ERROR_SUCCESS != pfnNtReadVirtualMemory(hProcess, (LPVOID)stBlock.CmdLine.Buffer,
     
245.                 wszCmdLine, MAX_PATH*sizeof(wchar_t), &size)) {
     
246.                     // Call GetLastError() if you need to know why
     
247.                     return(FALSE);
     
248.             }
     
249. 
     
250.             // 4. Skip the application pathname
     
251.             //    it can be empty, "c:\...\app.exe" or c:\...\app.exe
     
252.             wchar_t* pPos = wszCmdLine;
     
253.             if (*pPos != L'\0') {
     
254.                 if (*pPos == L'"') {
     
255.                     // Find the next " character
     
256.                     pPos = wcschr(&pPos[1], L'"');
     
257.                 } else {
     
258.                     // Find the next SPACE character
     
259.                     pPos = wcschr(&pPos[1], L'');
     
260.                 }
     
261. 
     
262.                 // Skip it
     
263.                 if (pPos != NULL)
     
264.                     pPos++;
     
265.             }
     
266. 
     
267.             // Copy it back
     
268.             if (pPos != NULL) {
     
269. 
     
270.                 if (*pPos != L'\0') {
     
271. #ifdef UNICODE
     
272.                     // Both strings are in UNICODE.
     
273.                     strCmdLine.assign(wszCmdLine);
     
274. #else
     
275.                     CHAR szCmdLine[MAX_PATH+1] = {0};
     
276.                     WideCharToMultiByte(CP_ACP,0,wszCmdLine,size/sizeof(wchar_t),szCmdLine,MAX_PATH,NULL,NULL);
     
277.                     strCmdLine.assign(szCmdLine);
     
278. 
     
279. #endif
     
280.                     bSuccess = TRUE;
     
281.                 }
     
282.             }
     
283.         }
     
284.     }
     
285.     return bSuccess;
     
286. }
     
287. 
     
288. 
     
289. #include <TlHelp32.h>
     
290. #include <winternl.h>   // for Windows internal declarations.
     
291. #include "Toolhelp/Toolhelp.h"
     
292. 
     
293. //////////////////////////////////////////////////////////////////////////
     
294. #define WOW64
     
295. 
     
296. #ifdef _UNICODE
     
297. #define mystring wstring
     
298. #else
     
299. #define mystring string
     
300. #endif
     
301. 
     
302. typedef struct
     
303. {
     
304.     DWORD Filler[4];
     
305.     DWORD ProcessParameters;
     
306. } __PEB;
     
307. 
     
308. typedef struct
     
309. {
     
310.     PVOID64 Filler[4];
     
311.     PVOID64 ProcessParameters;
     
312. } __PEB64;
     
313. 
     
314. //
     
315. // Current Directory Structures
     
316. //
     
317. typedef struct
     
318. {
     
319.     UNICODE_STRING DosPath;
     
320.     HANDLE Handle;
     
321. }_CURDIR;
     
322. 
     
323. typedef struct _UNICODE_STRING64 {
     
324.     SHORT Length;
     
325.     SHORT MaximumLength;
     
326.     DWORD Fill;
     
327.     PVOID64  Buffer;
     
328. } UNICODE_STRING64;
     
329. 
     
330. typedef struct
     
331. {
     
332.     DWORD MaximumLength;
     
333.     DWORD Length;
     
334.     DWORD Flags;
     
335.     DWORD DebugFlags;
     
336.     PVOID ConsoleHandle;
     
337.     DWORD ConsoleFlags;
     
338.     PVOID StandardInput;
     
339.     PVOID StandardOutput;
     
340.     PVOID StandardError;
     
341.     //////////////////////////
     
342.     UNICODE_STRING DosPath;    //CurrentDirectory
     
343.     HANDLE Handle;
     
344.     //////////////////////////
     
345.     UNICODE_STRING DllPath;
     
346.     UNICODE_STRING ImagePathName;
     
347.     UNICODE_STRING CmdLine;
     
348.     //……
     
349. }_RTL_USER_PROCESS_PARAMETERS;
     
350. 
     
351. typedef struct
     
352. {
     
353.     DWORD MaximumLength;
     
354.     DWORD Length;
     
355.     DWORD Flags;
     
356.     DWORD DebugFlags;
     
357.     PVOID64 ConsoleHandle;
     
358.     DWORD ConsoleFlags;
     
359.     PVOID64 StandardInput;
     
360.     PVOID64 StandardOutput;
     
361.     PVOID64 StandardError;
     
362.     //////////////////////////
     
363.     UNICODE_STRING64 DosPath;//CurrentDirectory
     
364.     HANDLE Handle;
     
365.     //////////////////////////
     
366.     UNICODE_STRING64 DllPath;
     
367.     UNICODE_STRING64 ImagePathName;
     
368.     UNICODE_STRING64 CmdLine;
     
369.     //……
     
370. }_RTL_USER_PROCESS_PARAMETERS64;
     
371. 
     
372. 
     
373. 
     
374. // end_ntddk end_ntifs
     
375. typedef struct _PROCESS_BASIC_INFORMATION64 {
     
376.     PVOID64 Reserved1;
     
377.     PVOID64 PebBaseAddress;
     
378.     PVOID64 Reserved2[2];
     
379.     PVOID64 UniqueProcessId;
     
380.     PVOID64 Reserved3;
     
381. } PROCESS_BASIC_INFORMATION64,*PPROCESS_BASIC_INFORMATION64;
     
382. 
     
383. typedef LONG (WINAPI *TNtQueryInformationProcess)(HANDLE,UINT,PVOID,ULONG,PULONG);
     
384. typedef LONG (WINAPI *TNtReadVirtualMemory)(HANDLE ProcessHandle, PVOID BaseAddress, PVOID Buffer, ULONG NumberOfBytesToRead, PULONG NumberOfBytesReaded);
     
385. typedef LONG (WINAPI *TNtReadVirtualMemory64)(HANDLE ProcessHandle, PVOID64 BaseAddress, PVOID Buffer, UINT64 NumberOfBytesToRead, PUINT64 NumberOfBytesReaded);
     
386. //////////////////////////////////////////////////////////////////////////
     
387. 
     
388. 
     
389. typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS) (HANDLE, PBOOL);
     
390. 
     
391. BOOL IsWow64()
     
392. {
     
393.     BOOL bIsWow64 = FALSE;
     
394. 
     
395.     LPFN_ISWOW64PROCESS
     
396.         fnIsWow64Process = (LPFN_ISWOW64PROCESS)GetProcAddress(
     
397.         GetModuleHandle("kernel32"),"IsWow64Process");
     
398. 
     
399.     if (NULL != fnIsWow64Process)
     
400.     {
     
401.         if (!fnIsWow64Process(GetCurrentProcess(),&bIsWow64))
     
402.         {
     
403.             // handle error
     
404.         }
     
405.     }
     
406.     return bIsWow64;
     
407. }
     

复制代码