获取所有进程的映像路径以及命令VC源代码

1. http://code1.okbase.net/codefile/CommandLine.cpp_201211112590_1.htm
   
   /*****************************************************************************************
2. 在网上，我们似乎很难找到关于获取其他进程命令行的方案或源代码，呵呵~，反正我找了很久还是找不着~~~。废话就不说了，开始进入正题。
3. 我们知道，如果获取本进程命令行的话，可以通过调用 GetCommandLine 获得， GetCommandLine 返回的是LPTSTR类型的数据，该返回值便是本进程命令行的内存首地址。那么，我们可以让远程执行 GetCommandLine 这个函数，然后获取远程进程中这个函数的返回值，再通过 ReadProcessMemory 把远程进程的命令行读出来就得到我们想要的了。
4. 具体实现步骤如下：
5. 1、通过 GetProcAddress 取得 GetCommandLineA 的地址。
6. 2、用 CreateRemoteThread 启动远程线程，使远程进程执行 GetCommandLineA 。
7. 3、用 WaitForSingleObject 等待远程线程结束。
8. 4、用 GetExitCodeThread 取得远程线程退出代码，其实就是远程进程中 GetCommandLineA 函数的返回值，这是远程进程命令行的首地址。
9. 5、通过 GetProcAddress 取得 lstrlenA 的地址。
10. 6、用 CreateRemoteThread 启动远程线程，使远程进程执行 lstrlenA 。
11. 7、用 WaitForSingleObject 等待远程线程结束。
12. 8、用 GetExitCodeThread 取得远程线程退出代码，其实就是远程进程中 lstrlenA 函数的返回值，这是远程进程命令行的文本长度。
13. 9、使用 ReadProcessMemory 把远程进程的命令行读取出来。
14. 10、收工！
15. ·若要转载，请保持该文章的完整性。
16. ******************************************************************************************/
18. //
19. //功能：获取所有进程的映像路径以及命令行参数
20. //作者：梁增健(lzj85@163.com)
21. //MyQQ：184186651
22. //日期：2007.06.11
23. //
24. #include <windows.h>
25. #include <tlhelp32.h>
26. #include <iostream.h>
28. //定义命令行信息结构体
29. typedef struct tagCOMMANDLINEINFO {
30. DWORD dwDestCommand_addr;//目标进程命令行的起始地址
31. DWORD iDestCommandLength;//目标进程命令行的长度
32. } COMMANDLINEINFO;
34. //函数声明
35. BOOLUpgradeProcessPrivilege(HANDLE,LPCTSTR);
36. BOOLGetProcessCommandLineInfo(HANDLE,COMMANDLINEINFO*);
38. //主函数
39. intmain(int argc,char*argv[ ],char*envp[ ] )
40. {
41. UpgradeProcessPrivilege(GetCurrentProcess(),SE_DEBUG_NAME);//提升本进程的权限
43. HANDLE hSnapshot, hProcess;
44. hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,NULL);//创建进程快照
46. PROCESSENTRY32 pe;
47. ZeroMemory(&pe,sizeof(PROCESSENTRY32));
48. pe.dwSize=sizeof(PROCESSENTRY32);
49. BOOL bFirstProcess=TRUE, bSucceed=FALSE;
50. do
51. {
52. if(bFirstProcess)
53. bFirstProcess = !(bSucceed=Process32First(hSnapshot,&pe));//获取第一个进程的信息
54. else
55. bSucceed = Process32Next(hSnapshot, &pe); //获取下一个进程的信息
56. if(bSucceed)
57. {
58. hProcess = OpenProcess (PROCESS_ALL_ACCESS,FALSE, pe.th32ProcessID);//打开进程
59. if(hProcess!=0)
60. {
61. char*strDestCommand;
62. COMMANDLINEINFO cli;
63. ZeroMemory(&cli,sizeof(COMMANDLINEINFO));
64. if(GetProcessCommandLineInfo(hProcess,&cli))//获取进程的命令行信息
65. {
66. try
67. {
68. strDestCommand = new char[cli.iDestCommandLength+1];
69. ZeroMemory(strDestCommand, cli.iDestCommandLength+1);
70. //读取目标进程的命令行文本
71. ReadProcessMemory ( hProcess,
72. (constvoid*)cli.dwDestCommand_addr,
73. strDestCommand,
74. cli.iDestCommandLength,
75. NULL);
76. cout<<"程序名："<<pe.szExeFile<<"n命令行："<<strDestCommand<<"n"<<endl;
77. delete []strDestCommand;
78. }
79. catch(...)
80. {
81. cout<<"发生异常！n"<<endl;
82. }
83. }
84. else
85. {
86. cout<<"程序名："<<pe.szExeFile<<"n"<<endl;
87. }
88. CloseHandle(hProcess);//关闭进程句柄
89. }
90. }
91. }while(bSucceed);
92. CloseHandle(hSnapshot);//关闭快照句柄
94. return0;
95. }
97. /****************************************************************************************/
98. /*****************************************子程序*****************************************/
99. /****************************************************************************************/
100. //
101. //名称：UpgradeProcessPrivilege
102. //功能：提升进程权限
103. //作者：梁增健(lzj85@163.com)
104. //MyQQ：184186651
105. //日期：2007.06.11
106. //
107. BOOLUpgradeProcessPrivilege(HANDLE hProcess,
108. LPCTSTR lpPrivilegeName=SE_DEBUG_NAME)
109. {
110. HANDLE hToken=NULL;
111. if(OpenProcessToken(hProcess,TOKEN_ALL_ACCESS,&hToken))
112. {
113. LUIDLuid;
114. if(LookupPrivilegeValue(NULL, lpPrivilegeName, &Luid))
115. {
116. TOKEN_PRIVILEGES tp;
117. tp.PrivilegeCount=1;
118. tp.Privileges[0].Attributes=SE_PRIVILEGE_ENABLED;
119. tp.Privileges[0].Luid=Luid;
120. return(AdjustTokenPrivileges(hToken,FALSE,&tp,0,NULL,NULL) );
121. }
122. }
123. returnFALSE;
124. }
126. //
127. //名称：GetProcessCommandLineInfo
128. //功能：获取进程命令行信息
129. //作者：梁增健(lzj85@163.com)
130. //MyQQ：184186651
131. //日期：2007.06.11
132. //
133. BOOLGetProcessCommandLineInfo(HANDLE hProcess,COMMANDLINEINFO*CommandLineInfo)
134. {
135. if(IsBadReadPtr(CommandLineInfo,sizeof(COMMANDLINEINFO)))//判断指针是否有效
136. returnFALSE;
138. FARPROCGetCommandLineA_addr, lstrlenA_addr;
139. HANDLE hThread;
141. //获取 GetCommandLineA 的地址
142. GetCommandLineA_addr=GetProcAddress(GetModuleHandle("Kernel32.dll"),"GetCommandLineA");
143. if(GetCommandLineA_addr==0)
144. returnFALSE;
145. //启动远程线程，使远程进程执行 GetCommandLineA 函数
146. hThread = CreateRemoteThread(hProcess, NULL, 0,
147. (LPTHREAD_START_ROUTINE)GetCommandLineA_addr,NULL,0,NULL);
148. if(hThread==0)
149. returnFALSE;
150. WaitForSingleObject (hThread,INFINITE);//等待远程线程结束
151. //作者：梁增健 Email：lzj85@163.com MyQQ：184186651
152. //获取远程 GetCommandLineA 的返回值，若正常返回，则该值为远程进程命令行的首地址
153. GetExitCodeThread (hThread,&(CommandLineInfo->dwDestCommand_addr));
154. CloseHandle (hThread);
155. if(CommandLineInfo->dwDestCommand_addr==0)
156. returnFALSE;
158. //获取 lstrlenA 的地址
159. lstrlenA_addr = GetProcAddress( GetModuleHandle ("Kernel32.dll"),"lstrlenA");
160. if(GetCommandLineA_addr==0)
161. returnFALSE;
162. //启动远程线程，使远程进程执行 lstrlenA 函数
163. hThread = CreateRemoteThread(hProcess, NULL, 0,(LPTHREAD_START_ROUTINE)lstrlenA_addr,
164. (void*)CommandLineInfo->dwDestCommand_addr,0,NULL);
165. if(hThread==0)
166. returnFALSE;
167. WaitForSingleObject (hThread,INFINITE);
168. //获取远程 lstrlenA 的返回值，若正常返回，则该值为远程进程命令行文本的长度
169. GetExitCodeThread (hThread,&(CommandLineInfo->iDestCommandLength));
170. CloseHandle (hThread);
172. returnTRUE;
173. }
174. /*************************************************************************************/
175. /****************************************子程序***************************************/
176. /*************************************************************************************/
     
     

     开发环境： VC6 Windows XP

     测试环境： WindowsXP

     我们都知道，在程序里获取命令行参数很简单，WinMain函数会以参数的形式传递给我们，或者可以调用API GetCommandLine 获取。但是GetCommandLine函数不接受参数，获取的只是自己程序的命令行参数。那么如果我们想获取别的应用程序的命令行参数应该怎么办呢？
     有的同学说，既然GetCommandLine只能获取本程序的命令行参数，我们可以在其它进程里插入一个Dll，在那个进程的地址空间调用GetCommandLine函数，然后传回来就可以了。这样好像有点儿不太友好。让我们想想还有没有别的办法。

     我们想，自己的命令行参数既然随时都可以获取到，那么在该进程里一定有一个地方存放它。那么在哪儿呢？看一下GetCommandLine函数的反汇编代码，我们发现，原来世界是如此的美好！

     以下是WinXP系统的GetCommandLine函数反汇编代码：

     1. .text:7C812C8D GetCommandLineA proc near

     2. .text:7C812C8D mov eax, dword_7C8835F4     //dword_7C8835F4 就是命令行参数字符串的地址

     3. //该指令机器码为 A1 F4 35 88 7C，从第2个字节开始的4个字节就是我们要的地址

     4. .text:7C812C92 retn

     5. .text:7C812C92 GetCommandLineA endp

     既然知道了放在哪儿了，我们自己去拿就可以了。因为GetCommandLine函数的地址在各个进程内都是一样的，所以可以直接用我们进程里的地址。 win2000/xp系统很简单，98下稍微麻烦一点儿，需要进行一些简单的计算。 以下是GetCommandLine函数在win98下的汇编代码：

     01. .text:BFF8C907 GetCommandLineA proc near

     02. .text:BFF8C907 mov eax, dword_BFFCADE4

     03. .text:BFF8C90C mov ecx, [eax]

     04. .text:BFF8C90E mov eax, [ecx+0C0h]

     05. .text:BFF8C914 test eax, eax

     06. .text:BFF8C916 jnz short locret_BFF8C91E

     07. .text:BFF8C918 mov eax, [ecx+40h]

     08. .text:BFF8C91B mov eax, [eax+8] //算到这儿，才是我们想要的地址

     09. .text:BFF8C91E

     10. .text:BFF8C91E locret_BFF8C91E: ; CODE XREF: GetCommandLineA+F.

     11. .text:BFF8C91E retn

     这样，我们就可以调用OpenProcess函数打开其它进程，然后用ReadProcessMemory读取相应的数据即可。 示例代码：

     view source

     print ?

     01. DWORD g_GetCmdLine(DWORD dwPID,TCHAR* pCmdLine,DWORD dwBufLen)

     02. {

     03. #define BUFFER_LEN    512        //reading buffer for the commandline

     04.  

     05. HANDLE hProc = OpenProcess(PROCESS_VM_READ,FALSE,dwPID);

     06. if(hProc == NULL)

     07. {

     08. return GetLastError();

     09. }

     10.  

     11. DWORD dwRet = -1;

     12. DWORD dwAddr = *(DWORD*)((DWORD)GetCommandLine + 1);//第2个字节开始才是我们要读的地址

     13. TCHAR tcBuf[BUFFER_LEN] = {0};

     14. DWORD dwRead = 0;

     15.  

     16. //判断平台

     17. DWORD dwVer = GetVersion();

     18. try

     19. {

     20. if(dwVer < 0x80000000)        // Windows NT/2000/XP

     21. {

     22. if(ReadProcessMemory(hProc,(LPVOID)dwAddr,&dwAddr,4,&dwRead))

     23. {

     24. if(ReadProcessMemory(hProc,(LPVOID)dwAddr,tcBuf,BUFFER_LEN,&dwRead))

     25. {

     26. _tcsncpy(pCmdLine,tcBuf,dwBufLen);    //最好检查一下dwRead和dwBufLen的大小，使用较小的那个

     27. dwRet = 0;

     28. }

     29. }        

     30. }

     31. else                        // Windows 95/98/Me    and Win32s

     32. {

     33. while(true)                //使用while是为了出错时方便跳出循环

     34. {

     35. if(!ReadProcessMemory(hProc,(LPVOID)dwAddr,&dwAddr,4,&dwRead))break;

     36. if(!ReadProcessMemory(hProc,(LPVOID)dwAddr,&dwAddr,4,&dwRead))break;

     37.  

     38. if(!ReadProcessMemory(hProc,(LPVOID)(dwAddr + 0xC0),tcBuf,BUFFER_LEN,&dwRead)) break;

     39. if(*tcBuf == 0)

     40. {

     41. if(!ReadProcessMemory(hProc,(LPVOID)(dwAddr + 0x40),&dwAddr,4,&dwRead)) break;

     42. if(!ReadProcessMemory(hProc,(LPVOID)(dwAddr + 0x8),&dwAddr,4,&dwRead)) break;

     43. if(!ReadProcessMemory(hProc,(LPVOID)dwAddr,tcBuf,BUFFER_LEN,&dwRead)) break;

     44. }

     45.  

     46. _tcsncpy(pCmdLine,tcBuf,dwBufLen);    //最好检查一下dwRead和dwBufLen的大小，使用较小的那个

     47. dwRet = 0;

     48. break;

     49. }

     50. }

     51. }

     52. catch(...)

     53. {

     54. dwRet = ERROR_INVALID_ACCESS;    //exception

     55. }

     56. CloseHandle(hProc);

     57.  

     58. return dwRet;

     59. }

     全文完

     
     

     1. #include "stdafx.h"
        
     2. #include <windows.h>
        
     3. #include <stdio.h>
        
     4. #include <conio.h>
        
     5. 
        
     6. //UNICODE_STRING结构定义
        
     7. typedef struct
        
     8. {
        
     9.         USHORT Length;
        
     10.         USHORT MaximumLength;
         
     11.         PWSTR Buffer;
         
     12. }UNICODE_STRING, *PUNICODE_STRING;
         
     13. 
         
     14. 
         
     15. //进程参数结构定义,必有和NativeAPI规范相符和
         
     16. typedef struct
         
     17. {
         
     18.         ULONG AllocationSize;
         
     19.         ULONG ActualSize;
         
     20.         ULONG Flags;
         
     21.         ULONG Unknown1;
         
     22.         UNICODE_STRING Unknown2;
         
     23.         HANDLE InputHandle;
         
     24.         HANDLE OutputHandle;
         
     25.         HANDLE ErrorHandle;
         
     26.         UNICODE_STRING CurrentDirectory;
         
     27.         HANDLE CurrentDirectoryHandle;
         
     28.         UNICODE_STRING SearchPaths;
         
     29.         UNICODE_STRING ApplicationName;
         
     30.         UNICODE_STRING CommandLine;
         
     31.         PVOID EnvironmentBlock;
         
     32.         ULONG Unknown[9];
         
     33.         UNICODE_STRING Unknown3;
         
     34.         UNICODE_STRING Unknown4;
         
     35.         UNICODE_STRING Unknown5;
         
     36.         UNICODE_STRING Unknown6;
         
     37. }PROCESS_PARAMETERS, *PPROCESS_PARAMETERS;
         
     38. 
         
     39. //PEB: Process Environment Block, 进程环境变量块
         
     40. typedef struct
         
     41. {
         
     42.         ULONG AllocationSize;
         
     43.         ULONG Unknown1;
         
     44.         HINSTANCE ProcessHinstance;
         
     45.         PVOID ListDlls;
         
     46.         PPROCESS_PARAMETERS ProcessParameters;
         
     47.         ULONG Unknown2;
         
     48.         HANDLE Heap;
         
     49. }PEB,*PPEB;
         
     50. 
         
     51. //进程基本信息结构定义
         
     52. typedef struct
         
     53. {
         
     54.         DWORD ExitStatus;
         
     55.         PPEB PebBaseAddress;
         
     56.         DWORD AffinityMask;
         
     57.         DWORD BasePriority;
         
     58.         ULONG UniqueProcessId;
         
     59.         ULONG InheritedFromUniqueProcessId;
         
     60. }PROCESS_BASIC_INFORMATION;
         
     61. 
         
     62. //函数指针定义,类型为WINDOWS Native API, 用于获取NtQueryInformationProcess的地址
         
     63. typedef LONG(WINAPI *PROCNTQSIP)(HANDLE,UINT,PVOID,ULONG,PULONG);
         
     64. 
         
     65. //函数指针声明
         
     66. PROCNTQSIP NtQueryInformationProcess;
         
     67. 
         
     68. //获取进程的命令行参数
         
     69. //dwId:输入参数,进程ID
         
     70. //wBuf:输出参数,用于存储命令行参数的缓冲区指针
         
     71. //dwBufLen:输入参数,缓冲区的大小
         
     72. //返回值:TRUE,成功FALSE,失败
         
     73. BOOL GetProcessCmdLine(DWORD dwId,LPWSTR wBuf,DWORD dwBufLen);
         
     74. 
         
     75. //提升权限的函数
         
     76. void EnableDebugPriv(void);
         
     77. 
         
     78. //主函数,程序入口
         
     79. void main(int argc,char* argv[])
         
     80. {
         
     81.         //命令行参数合法性判断
         
     82.         if(argc!=2)
         
     83.         {
         
     84.                 printf("usage:nt%s <PID>n",argv[0]);
         
     85.                 return;
         
     86.         }
         
     87.         //提升权限,否则无法读取其它进程信息
         
     88.         EnableDebugPriv();
         
     89.         //获取WINDOWS Native API NtQueryInformationProcess的入口地址
         
     90.         NtQueryInformationProcess=(PROCNTQSIP)GetProcAddress(GetModuleHandle("ntdll"),"NtQueryInformationProcess");
         
     91.         //获取的函数入口的合法性检查
         
     92.         if(!NtQueryInformationProcess)
         
     93.         {
         
     94.                 return;
         
     95.         }
         
     96.         //从命令行获取目标进程的PID
         
     97.         DWORD dwId;
         
     98.         sscanf(argv[1],"%lu",&dwId);
         
     99.         //定义缓冲区,用于获得目标进程的命令行参数
         
     100.         WCHAR wstr[2048];
          
     101.         //清空缓冲区
          
     102.         ZeroMemory(wstr,sizeof(wstr));
          
     103.         //获取目标进程的命令行参数
          
     104.         if(GetProcessCmdLine(dwId,wstr,sizeof(wstr)))
          
     105.         {
          
     106.                 //获取成功,打印结果
          
     107.                 wprintf(L"commandline for process %lu is:n %sn",dwId,wstr);
          
     108.         }
          
     109.         else
          
     110.         {
          
     111.                 //获取失败,打印提示信息
          
     112.                 wprintf(L"Could not Get Command Line!");
          
     113.         }
          
     114. }
          
     115. //获取进程的命令行参数
          
     116. BOOL GetProcessCmdLine(DWORD dwId,LPWSTR wBuf,DWORD dwBufLen)
          
     117. {
          
     118.         LONG status;
          
     119.         HANDLE hProcess;
          
     120.         PROCESS_BASIC_INFORMATION pbi;
          
     121.         PEB Peb;
          
     122.         PROCESS_PARAMETERS ProcParam;
          
     123.         DWORD dwDummy;
          
     124.         DWORD dwSize;
          
     125.         LPVOID IpAddress;
          
     126.         BOOL bRet=FALSE;
          
     127. 
          
     128.         //打开进程,获取查询和毒虚拟内存的权限
          
     129.         hProcess=OpenProcess(PROCESS_QUERY_INFORMATION| PROCESS_VM_READ,FALSE,dwId);
          
     130.         if(!hProcess)
          
     131.         {
          
     132.                 return FALSE;
          
     133.         }
          
     134. 
          
     135.         //查询进程的基本信息,获取PEB
          
     136.         status=NtQueryInformationProcess(hProcess,0,(PVOID)&pbi,sizeof(PROCESS_BASIC_INFORMATION),NULL);
          
     137.         if(status)
          
     138.         {
          
     139.                 goto EndGet;
          
     140.         }
          
     141.         //读取进程的PEB指针
          
     142.         if(!ReadProcessMemory(hProcess,pbi.PebBaseAddress,&Peb,sizeof(PEB),&dwDummy))
          
     143.         {
          
     144.                 goto EndGet;
          
     145.         }
          
     146.         //获取目标进程空间存储的命令行参数字符串的指针
          
     147.         if(!ReadProcessMemory(hProcess,Peb.ProcessParameters,&ProcParam,sizeof(PROCESS_PARAMETERS),&dwDummy))
          
     148.         {
          
     149.                 goto EndGet;
          
     150.         }
          
     151.         IpAddress=ProcParam.CommandLine.Buffer;
          
     152.         dwSize=ProcParam.CommandLine.Length;
          
     153.         if(dwBufLen<dwSize)
          
     154.         {
          
     155.                 goto EndGet;
          
     156.         }
          
     157.         //读取目标进程的命令行参数到本进程的缓冲区
          
     158.         if(!ReadProcessMemory(hProcess,IpAddress,wBuf,dwSize,&dwDummy))
          
     159.         {
          
     160.                 goto EndGet;
          
     161.         }
          
     162.         bRet=TRUE;
          
     163. 
          
     164. EndGet:
          
     165.         //关闭目标进程的句柄
          
     166.         CloseHandle(hProcess);
          
     167.         return bRet;
          
     168. }
          
     169. //提升本进程权限
          
     170. void EnableDebugPriv(void)
          
     171. {
          
     172.         HANDLE hToken;
          
     173.         LUID sedebugnameValue;
          
     174.         TOKEN_PRIVILEGES tkp;
          
     175. 
          
     176.         //打开本进程,获得调整权限的权限
          
     177.         if(!OpenProcessToken(GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY,&hToken))
          
     178.         {
          
     179.         return;
          
     180.         }
          
     181.         //查询EBUG权限的值
          
     182.         if(!LookupPrivilegeValue(NULL,SE_DEBUG_NAME,&sedebugnameValue))
          
     183.         {
          
     184.         CloseHandle(hToken);
          
     185.         return;
          
     186.         }
          
     187.         tkp.PrivilegeCount=1;
          
     188.         tkp.Privileges[0].Luid=sedebugnameValue;
          
     189.         tkp.Privileges[0].Attributes=SE_PRIVILEGE_ENABLED;
          
     190.         //调整本进程的权限,使之具有可以高度其它进程的权限
          
     191.         AdjustTokenPrivileges(hToken,FALSE,&tkp,sizeof tkp,NULL,NULL);
          
     192.         //关闭本进程句柄 
          
     193.         CloseHandle(hToken);
          
     194. }

     
     

     
     

最后

以上就是美好唇彩为你收集整理的获取所有进程的映像路径以及命令VC源代码的全部内容，希望文章能够帮你解决获取所有进程的映像路径以及命令VC源代码所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。