Windows进程

た入场券 2023-02-20 03:27 17阅读 0赞

# 一. 进程的创建 #

BOOL CreateProcess(						
      LPCTSTR lpApplicationName,                 // name of executable module 					
      LPTSTR lpCommandLine,                      // command line string 命令行参数				
      LPSECURITY_ATTRIBUTES lpProcessAttributes, // SD 
      LPSECURITY_ATTRIBUTES lpThreadAttributes,  // SD
      BOOL bInheritHandles,                      // handle inheritance option						
      DWORD dwCreationFlags,                     // creation flags						
      LPVOID lpEnvironment,                      // new environment block						
      LPCTSTR lpCurrentDirectory,                // current directory name						
      LPSTARTUPINFO lpStartupInfo,               // startup information						
      LPPROCESS_INFORMATION lpProcessInformation // process information						
    );

第一个参数也可以只传入程序名称自动进行检索，但不推荐。第一个参数可以为常量。

第二个参数不可以直接传字符串常量，因为系统可能会对第二个参数直接进行修改；可以通过第二个参数来创建进程，第一个赋值为NULL，这样可以直接打开一个网址；单独传参数的时候要在最前面留一个空格，否则不会识别此参数。

第三个参数：此进程的进程句柄是否可以被继承。

第四个参数：此线程的进程句柄是否可以被继承。

第五个参数：是否可以继承父进程的句柄表(句柄表为1的句柄才可以执行)。

第六个参数：传NULL使用父进程控制台；传CREATE\_NEW\_CONSOLE创建新的控制台；CREATE\_SUSPENDED以挂起的方式创建进程。

第八个参数：传NULL 在子进程中调用GetCurrentDirectory函数获取的是父进程的目录，如果创建时添加目录那么GetCurrentDirectory函数获取的就是给定的目录。

第九个参数：  
1. 用来设定要创建的应用程序的属性，比如可以指定新创建的控制台程序的标题等待。  
2. STARTUPINFO si = \{ 0 \}; si.cb = sizeof(si);是一个全零的结构，只需要给第一个字段赋值，就是这个结构的大小，这样可以考虑到可拓展，微软可以选择改变以下结构体。

typedef struct _STARTUPINFO			
    {			
       DWORD cb;			
       PSTR lpReserved;			
       PSTR lpDesktop;			
       PSTR lpTitle;			
       DWORD dwX;			
       DWORD dwY;			
       DWORD dwXSize;			
       DWORD dwYSize;			
       DWORD dwXCountChars;			
       DWORD dwYCountChars;			
       DWORD dwFillAttribute;			
       DWORD dwFlags;			
       WORD wShowWindow;			
       WORD cbReserved2;			
       PBYTE lpReserved2;			
       HANDLE hStdInput;			
       HANDLE hStdOutput;			
       HANDLE hStdError;			
    } STARTUPINFO, *LPSTARTUPINFO;

第十个参数：Out类型参数，成功创建进程后，会返回以下结构。

typedef struct _PROCESS_INFORMATION				
    	{				
    	   HANDLE hProcess;				//进程句柄
    	   HANDLE hThread;				//主线程句柄
    	   DWORD dwProcessId;				//进程ID
    	   DWORD dwThreadId;				//线程ID
    	} PROCESS_INFORMATION;

创建一个进程：

int main(int argc, char* argv[])
    {
    	STARTUPINFO si = { 0 };
    	PROCESS_INFORMATION pi;
    
    	si.cb = sizeof(si);
    
    	TCHAR szApplicationName[] = TEXT(" https://www.baidu.com");
    
    	BOOL res = CreateProcess(
    		TEXT("C:\\Program Files\\Mozilla Firefox\\firefox.exe"),
    		szApplicationName,
    		NULL,
    		NULL,
    		FALSE,
    		CREATE_NEW_CONSOLE,
    		NULL,
    		NULL, &si, &pi);
    
    	cout << res << endl;
    	cout << pi.dwProcessId << endl << pi.dwThreadId << endl << pi.hProcess << endl << pi.hThread << endl;
    
    
    	system("pause");
    	return 0;
    }

> 关于句柄和ID  
>   
> 1、都是系统分配的一个编号，句柄是客户程序使用 ID主要是系统调度时使用。  
>   
> 2、调用CloseHandle关闭进程或者线程句柄的时候，只是让内核计数器减少一个，并不是终止进程或者线程。进程或线程将继续运行，直到它自己终止运行。  
>   
> 3、进程ID与线程ID 是不可能相同。但不要通过进程或者线程的ID来操作进程或者线程，因为，这个编号是会重复使用的，也就是说，当你通过ID=100这个编号去访问一个进程的时候，它已经结束了，而且系统将这个编号赋给了另外一个进程或者线程。

# 二. 终止进程 #

> 终止进程的三种方式：
> 
> 1、VOID　ExitProcess(UINT fuExitCode) //进程自己调用
> 
> 2、BOOL TerminateProcess(HANDLE hProcess, UINT fuExitCode); //终止其他进程
> 
> 3、ExitThread //终止进程中的所有线程，进程也会终止  
>

> 获取进程的退出码：  
> BOOL GetExitCodeProcess(HANDLE hProcess,PDWORD pdwExitCode);  
>   
> 进程终止时相关操作：  
> 1、进程中剩余的所有线程全部终止运行  
> 2、进程指定的所有用户对象均被释放，所有内核对象均被关闭  
> 3、进程内核对象的状态**变成已通知的状态(不同的内核对象微软赋予状态意义不同，但是这里与线程相同)**  
> 4、进程内核对象的使用计数递减1

# 三. 进程的继承 #

创建内核对象时需要设置为可继承，这样会在进程的句柄表中赋值为1，这是子进程可以继承父进程句柄表的前提。之后在子进程创建时将第五个参数设置为TRUE即可。

另外，虽然子进程继承可句柄，但是无法直接使用，需要父进程传递才能使用，下面选择的是通过命令行参数传递事件句柄。

父进程： 在SetEvent处下断点，单补观察。

子进程：

#define _CRT_SECURE_NO_WARNINGS
    #include <iostream>
    #include <locale.h>
    #include <Windows.h>
    using namespace std;
    
    int main(int argc, char* argv[])
    {
    	char szBuffer[256] = {0};				
    
    	memcpy(szBuffer,argv[1],8);				
    
    	DWORD dwHandle = 0;				
    
    	sscanf(szBuffer,"%x",&dwHandle);				
    
    	printf("%s\n",argv[0]);				
    
    	printf("%x\n",dwHandle);				
    
    	HANDLE g_hEvent = (HANDLE)dwHandle;				
    
    	printf("开始等待.....\n");				
    	//当事件变成已通知时 				
    	WaitForSingleObject(g_hEvent, INFINITE);				
    
    	DWORD dwCode = GetLastError();				
    
    	printf("等到消息.....%x\n",dwCode);				
    
    	getchar();				
    	system("pause");
    	return 0;
    }

# 四. 挂起方式创建进程——进程创建的第三第四个参数 #

### 一. 创建并挂起进程 ###

main.cpp：进程创建的第三第四个参数表示此进程的进程句柄和线程句柄是否可以被子进程继承。内核对象都有此类安全参数，用来设置是否可以被继承句柄。如下代码创建一个父进程(随意一个软件)，子进程继承其句柄设置父进程挂起，软件一般会显示未响应。但测试了Firefox，挂起后仍能进行操作。

#define _CRT_SECURE_NO_WARNINGS
    #include <iostream>
    #include <locale.h>
    #include <Windows.h>
    using namespace std;
    #include <atlconv.h>
    
    int main(int argc, char* argv[])
    {
    	char szBuffer[256] = { 0 };
    	char szHandle[8] = { 0 };
    
    	SECURITY_ATTRIBUTES ie_sa_p;
    	ie_sa_p.nLength = sizeof(ie_sa_p);
    	ie_sa_p.lpSecurityDescriptor = NULL;
    	ie_sa_p.bInheritHandle = TRUE;
    
    	SECURITY_ATTRIBUTES ie_sa_t;
    	ie_sa_t.nLength = sizeof(ie_sa_t);
    	ie_sa_t.lpSecurityDescriptor = NULL;
    	ie_sa_t.bInheritHandle = TRUE;
    	//创建一个可以被继承的内核对象,此处是个进程						
    	STARTUPINFO ie_si = { 0 };
    	PROCESS_INFORMATION ie_pi;
    	ie_si.cb = sizeof(ie_si);
    
    	TCHAR szCmdline[] = TEXT("C:\\Users\\lenovo\\Desktop\\DTDebug\\DTDebug.exe");
    	CreateProcess(
    		NULL,
    		szCmdline,
    		&ie_sa_p,
    		&ie_sa_t,
    		FALSE,
    		CREATE_NEW_CONSOLE,
    		NULL,
    		NULL, &ie_si, &ie_pi);
    
    	//组织命令行参数						
    	sprintf(szHandle, "%x %x", ie_pi.hProcess, ie_pi.hThread);
    	sprintf(szBuffer, "D:/aaa.exe %s", szHandle);
    
    	//定义创建进程需要用的结构体						
    	STARTUPINFO si = { 0 };
    	PROCESS_INFORMATION pi;
    	si.cb = sizeof(si);
    
    	USES_CONVERSION;
    	TCHAR *str = new TCHAR[256];
    	str = A2T(szBuffer);
    
    	//创建子进程						
    	BOOL res = CreateProcess(
    		NULL,
    		str,
    		NULL,
    		NULL,
    		TRUE,
    		CREATE_NEW_CONSOLE,
    		NULL,
    		NULL, &si, &pi);
    	if (res)
    		cout << "B创建成功" << endl;
    	else
    		cout << "B创建失败" << endl;
    
    
    	system("pause");
    	return 0;
    }

aaa.cpp：

#define _CRT_SECURE_NO_WARNINGS
    #include <iostream>
    #include <locale.h>
    #include <Windows.h>
    using namespace std;
    
    
    int main(int argc, char *argv[])
    {
    	DWORD dwProcessHandle = -1;
    	DWORD dwThreadHandle = -1;
    	char szBuffer[256] = { 0 };
    
    
    	memcpy(szBuffer, argv[1], 8);
    	sscanf(szBuffer, "%x", &dwProcessHandle);
    
    	memset(szBuffer, 0, 256);
    	memcpy(szBuffer, argv[2], 8);
    	sscanf(szBuffer, "%x", &dwThreadHandle);
    
    	printf("获取IE进程、主线程句柄\n");
    	Sleep(1000);
    	//挂起主线程						
    	printf("挂起主线程\n");
    	::SuspendThread((HANDLE)dwThreadHandle);
    
    	Sleep(30000);
    
    	//恢复主线程						
    	::ResumeThread((HANDLE)dwThreadHandle);
    	printf("恢复主线程\n");
    
    	Sleep(5000);
    
    	//关闭ID进程						
    	::TerminateProcess((HANDLE)dwProcessHandle, 1);
    	::WaitForSingleObject((HANDLE)dwProcessHandle, INFINITE);
    
    	printf("ID进程已经关闭.....\n");
    
    
    
    	system("pause");
    	return 0;
    }

### 二. 以挂起的方式创建进程 ###

int main(int argc, char* argv[])
    {
    	STARTUPINFO ie_si = { 0 };
    	PROCESS_INFORMATION ie_pi;
    	ie_si.cb = sizeof(ie_si);
    
    	//以挂起的方式创建进程								
    	TCHAR szBuffer[256] = TEXT("C:\\Users\\lenovo\\Desktop\\DTDebug\\DTDebug.exe");
    	CreateProcess(
    		NULL,                    // name of executable module							
    		szBuffer,                // command line string							
    		NULL, 					 // SD		
    		NULL,  		             // SD					
    		FALSE,                   // handle inheritance option							
    		CREATE_SUSPENDED,     	 // creation flags  						
    		NULL,                    // new environment block							
    		NULL,                    // current directory name							
    		&ie_si,                  // startup information							
    		&ie_pi                   // process information							
    	);
    
    
    	CONTEXT contx;
    	contx.ContextFlags = CONTEXT_FULL;
    	GetThreadContext(ie_pi.hThread, &contx);
    
    	//获取入口点								
    	DWORD dwEntryPoint = contx.Eax;
    	printf("%x\n", dwEntryPoint);
    
    	//获取ImageBase								
    	char* baseAddress = (CHAR *)contx.Ebx + 8;
    
    	memset(szBuffer, 0, 256);
    
    	ReadProcessMemory(ie_pi.hProcess, baseAddress, szBuffer, 4, NULL);
    	printf("%p\n", szBuffer);
    
    	ResumeThread(ie_pi.hThread);
    
    
    
    	system("pause");
    	return 0;
    }