OpenProcess()函数

方法名称：OpenProcess

位置：Kernel32.dll

OpenProcess 函数用来打开一个已存在的进程对象，并返回进程的句柄。

1.函数原型

HANDLE OpenProcess(

DWORD dwDesiredAccess, 

BOOL bInheritHandle, 

DWORD dwProcessId

);
2.参数
a.dwDesiredAccess：想拥有的该 进程访问权限
PROCESS_ALL_ACCESS  //所有能获得的权限
PROCESS_CREATE_PROCESS  //需要创建一个进程
PROCESS_CREATE_THREAD   //需要创建一个线程
PROCESS_DUP_HANDLE      //重复使用DuplicateHandle句柄
PROCESS_QUERY_INFORMATION   //获得进程信息的权限，如它的退出代码、优先级
PROCESS_QUERY_LIMITED_INFORMATION  /*获得某些信息的权限，如果获得了PROCESS_QUERY_INFORMATION，也拥有PROCESS_QUERY_LIMITED_INFORMATION权限*/
PROCESS_SET_INFORMATION    //设置某些信息的权限，如进程优先级
PROCESS_SET_QUOTA          //设置内存限制的权限，使用SetProcessWorkingSetSize
PROCESS_SUSPEND_RESUME     //暂停或恢复进程的权限
PROCESS_TERMINATE          //终止一个进程的权限，使用TerminateProcess
PROCESS_VM_OPERATION       //操作进程内存空间的权限(可用VirtualProtectEx和WriteProcessMemory) 
PROCESS_VM_READ            //读取进程内存空间的权限，可使用ReadProcessMemory
PROCESS_VM_WRITE           //读取进程内存空间的权限，可使用WriteProcessMemory
SYNCHRONIZE                //等待进程终止
b.bInheritHandle：表示所得到的进程句柄是否可以被继承
c.dwProcessId：被打开进程的PID

3.返回类型

如成功，返回值为指定进程的句柄。

如失败，返回值为NULL，可调用GetLastError()获得错误代码。

通过一个进程关闭另外一个进程的时候，一般的做法就是枚举系统打开的所用进程的标识符（PID），使用OpenProcess函数获得进程的句柄，该函数可以通过第一个参数来设置句柄的新的访问权限（不清楚句柄是不是和原来的一模一样？有待证明和学习），比如如果打开的句柄不具备终止句柄的权限，直线终止进程操作会失败，返回的错误代码为5（意思为拒绝访问）。通过获得的句柄就可以获得进程名字（通过GetModuleBaseName函数），通过比对进程名字就可以获得我们指定要关闭的进程。注：要使用closeHandle函数来削减进程计数器。

[cpp]  view plain  copy

1. #include <windows.h>  
2. #include <Psapi.h>  
3. #include <iostream>  
4. #include <tchar.h>  
5. using std::cout;  
6. using std::endl;  
7.   
8. HANDLE hDesProcess = NULL;  
9. //根据进程的名字（image name）来查找该进程是否是打开的  
10. bool FindProcess( LPCTSTR lpszProcessName )  
11. {  
12.     DWORD dwProcessIdentify[MAX_PATH] = { 0 };  
13.     DWORD dwTrueBytes = 0;  
14.     HANDLE hProcess = NULL;  
15.     if ( !EnumProcesses( dwProcessIdentify, MAX_PATH*sizeof(DWORD), &dwTrueBytes ))  
16.     {  
17.         cout << "enum process fail " << endl;  
18.         return false;  
19.     }  
20.     int nProcessNum = dwTrueBytes/sizeof(DWORD);  
21.     HMODULE hModuleInProcess[MAX_PATH] = { 0 };  
22.     DWORD dwModuleBytes = 0;  
23.     TCHAR moduleBaseName[MAX_PATH] = { 0 };  
24.     for ( int nIndex = 0; nIndex < nProcessNum; ++nIndex )  
25.     {  
26.         hProcess = OpenProcess(  PROCESS_ALL_ACCESS, false, dwProcessIdentify[nIndex] );  
27. //      if ( hProcess == NULL )  
28. //      {  
29. //          continue;  
30. //      }  
31. //      memset( hModuleInProcess, 0, MAX_PATH*sizeof(HMODULE));  
32. //      dwModuleBytes = 0;  
33. //      if ( !EnumProcessModules( hProcess, hModuleInProcess, MAX_PATH*sizeof(HMODULE),&dwModuleBytes ))  
34. //      {  
35. //          cout << "Enum modules in process failed " << endl;  
36. //          DWORD dwErrorCode = GetLastError();  
37. //          //return false;  
38. //          continue;  
39. //      }  
40.         //int nModulesNumInProcess = dwModuleBytes/sizeof(DWORD);  
41.         memset( moduleBaseName, 0, MAX_PATH*sizeof(TCHAR));  
42.         //for ( int nModuleIndex = 0; nModuleIndex < nModulesNumInProcess; ++nModuleIndex )  
43.         {  
44.             GetModuleBaseName( hProcess, NULL,moduleBaseName,MAX_PATH );  
45.             if ( !_tcscmp( moduleBaseName, lpszProcessName))  
46.             {  
47.                 cout << "查找的进程存在" << endl;  
48.                 hDesProcess = hProcess;  
49.                 return true;  
50.             }  
51.   
52.         }  
53.           
54.   
55.     }  
56.     return false;  
57.       
58. }  
59. const LPCTSTR lpszProcessName = _T("DriveTheLife.exe");  
60. int main()  
61. {  
62.     if ( !FindProcess( lpszProcessName ))  
63.     {  
64.         cout << "进程不存在" << endl;  
65.         return EXIT_FAILURE;  
66.     }  
67.   
68.     //终止目标进程  
69.     UINT unExitCode = 0;  
70.     if ( hDesProcess != NULL )  
71.     {  
72.         BOOL bRet = TerminateProcess( hDesProcess, unExitCode );  
73.         if ( !bRet )  
74.         {  
75.             DWORD dwErrorCode = GetLastError();  
76.             cout << "进程终止失败" << endl;  
77.         }  
78.     }  
79.     DWORD dw = WaitForSingleObject( hDesProcess, INFINITE );  
80.     switch ( dw )  
81.     {  
82.     case WAIT_OBJECT_0:  
83.         cout << 1 << endl;  
84.         break;  
85.     case WAIT_FAILED:  
86.         {  
87.             DWORD dw1 = GetLastError();  
88.             cout << 2 << endl;  
89.         }  
90.           
91.         break  ;  
92.     default:  
93.         cout << 3 << endl;  
94.     }  
95.     return EXIT_SUCCESS;  
96. }  

在使用此函数时会发现不能成功获得有些系统进程的句柄，原因是没有权限。解决办法是在调用此函数前让我们的进程提升权限。

提升权限的函数（当然不会是所以地方都起作用，视情况而定）

[cpp]  view plain  copy

1. bool AdjustProcessTokenPrivilege()  
2. {  
3.     LUID luidTmp;  
4.     HANDLE hToken;  
5.     TOKEN_PRIVILEGES tkp;  
6.     if(!OpenProcessToken(GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,&hToken))  
7.     {  
8.         OutputDebugString("AdjustProcessTokenPrivilege OpenProcessToken Failed ! \n");  
9.         cout<<"AdjustProcessTokenPrivilege OpenProcessToken Failed !"<<endl;  
10.     }  
11.   
12.     if(!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &luidTmp))  
13.     {  
14.         OutputDebugString("AdjustProcessTokenPrivilege LookupPrivilegeValue Failed !");  
15.         cout<<"AdjustProcessTokenPrivilege LookupPrivilegeValue Failed !"<<endl;  
16.         CloseHandle(hToken);  
17.         return FALSE;  
18.     }  
19.   
20.     tkp.PrivilegeCount = 1;  
21.     tkp.Privileges[0].Luid = luidTmp;  
22.     tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;  
23.   
24.     if(!AdjustTokenPrivileges(hToken, FALSE, &tkp, sizeof(tkp), NULL, NULL))  
25.     {  
26.         OutputDebugString("AdjustProcessTokenPrivilege AdjustTokenPrivileges Failed ! \n");  
27.         cout<<"AdjustProcessTokenPrivilege AdjustTokenPrivileges Failed !"<<endl;  
28.         CloseHandle(hToken);  
29.         return FALSE;  
30.     }  
31.     CloseHandle(hToken);  
32.     return true;  
33. }