基于visual c++之windows核心编程代码分析 远程代码注入执行

我们进行系统级别的安全监控的时候，防范木马的时候，经常需要进行远程代码注入执行。

执行步骤如下

1. 提升进程权限，如果权限不够的话，很容易造成 OpenProcess 失败;
2. 确定你的宿主进程，即你所要注入代码的进程，这个其实很好办，你要是不想你的木马或者病毒被别个一下子就结束了的话，
   最好是选择系统要想运行，则必须开启的那种进程，比如资源管理器进程 Explorer.exe,

   Windows 子系统进程 csrss.exe 等等，但是这里注意的是，我注入 System 进程的时候造成了失败哦，

   所以最好还是别拿 System 做实验，而且如果你注入失败了的话，是会造成宿主进程崩溃的，

   等下一不小心把 System 进程给弄崩溃了就不好了;
3. 打开宿主进程了(我这里打开的是 Explorer.exe 进程),思路是首先变量当前系统下运行的所有的进程,

   然后遍历获取到得所有的进程的 PID,再调用 ProcessIsExplorer 函数来判断这个进程是否为 Explorer.exe 进程，

   如果是则记录下这个进程的 PID 就可以了,这样就获得了 Explorer.exe 进程的 PID 了,

   再通过 OpenProcess 来打开这个 Explorer.exe 进程就 OK 了;
4. 在宿主进程中分配好存储空间，这个存储空间是用来存放我们将要创建的远程线程的线程处理例程的,

   这里需要注意的是：我们分配的内存必须标记必须带有 EXECUTE,因为分配的这块内存是用来存放线程处理例程的,

   而线程处理例程必须得执行，所以必须得带有 EXECUTE 标记,而至于 WRITE 标记的话,很明显是需要的,

   因为我们在后面的代码中还必须调用 WriteProcessMemory 来将线程处理例程写入到这块内存中,自然其必须可写;
5. 将远程线程处理例程写入到 4 中在宿主进程中所分配的内存中,这个可以直接调用 WriteProcessMemory 来实现;
6. 在宿主进程中分配好存储空间，这个存储空间是用来存放我们将要传递给远程线程线程处理例程的参数,

   从下面的结构体中可以看出，其由三个参数组成，第一个参数代表要在对话框中显示的内容，

   第二个参数代表要在对话框中显示的标题，第三个参数则是 MessageBox 这个 API 的地址，

   因为在 Explorer.exe 中 MessageBox 的地址会发生重定向，所以需要将其地址通过参数传递给线程处理例程;

7. 将参数写入到 6 中在宿主进程中所分配的内存中,同样是调用 WriteProcessMemory 来完成;
8. 调用 CreateRemoteThread 在 Explorer.exe(宿主进程)中创建远程线程;

   注意，当远程线程没有执行完时，不能够通过 VirtualFreeEx 来将远程进程中的内存释放掉，

   你想啊，我他妈的线程都还在 Explorer.exe 里面执行，你他妈的在外面把我占的内存给释放掉了，我还执行个屁啊 !

   所以这里调用了 WaitForSingleObject 来等待这个远程线程执行完毕，

   其执行完毕后再释放在 Explorer.exe 中所分配的存储空间 !

[cpp] view plaincopyprint?

1. /* 头文件　*/  
2. #include <windows.h>  
3. #include <Tlhelp32.h>  
4.   
5. /************************************* 
6. * BOOL EnablePrivilege (PCSTR name) 
7. * 功能    提升本权限 
8. * 
9. * 参数    PCSTR name  所需的权限 
10. * 返回是否成功 
11. **************************************/  
12. DWORD EnablePrivilege (PCSTR name)  
13. {  
14.     HANDLE hToken;  
15.     BOOL rv;  
16.     //设置结构  
17.     TOKEN_PRIVILEGES priv = { 1, {0, 0, SE_PRIVILEGE_ENABLED} };  
18.     // 查找权限值  
19.     LookupPrivilegeValue (  
20.         0,  
21.         name,  
22.         &priv.Privileges[0].Luid  
23.         );  
24.     // 打开本进程Token  
25.     OpenProcessToken(  
26.         GetCurrentProcess (),  
27.         TOKEN_ADJUST_PRIVILEGES,  
28.         &hToken  
29.         );  
30.     // 提权  
31.     AdjustTokenPrivileges (  
32.         hToken,  
33.         FALSE,  
34.         &priv,  
35.         sizeof priv,  
36.         0,  
37.         0  
38.         );  
39.     // 返回值，错误信息，如果操作成功，则应为ERROR_SUCCESS，为O  
40.     rv = GetLastError();  
41.     // 关闭Token  
42.     CloseHandle (hToken);  
43.     return rv;  
44. }  
45.   
46. /************************************* 
47. * BOOL LoadRometeDll(DWORD dwProcessId, LPTSTR lpszLibName) 
48. * 功能    通过创建远程线程给其他进程加载Dll 
49. * 
50. * 参数    DWORD dwProcessId   目标进程PID 
51. *       LPTSTR lpszLibName  Dll的路径 
52. * 返回是否成功 
53. **************************************/  
54. BOOL LoadRometeDll(DWORD dwProcessId, LPTSTR lpszLibName)  
55. {  
56.     BOOL   bResult          = FALSE;   
57.     HANDLE hProcess         = NULL;  
58.     HANDLE hThread          = NULL;  
59.     PSTR   pszLibFileRemote = NULL;  
60.     DWORD  cch;  
61.     PTHREAD_START_ROUTINE pfnThreadRtn;  
62.   
63.     __try   
64.     {  
65.         // 获得想要注入代码的进程的句柄.  
66.         hProcess = OpenProcess(  
67.             PROCESS_ALL_ACCESS,   
68.             FALSE,   
69.             dwProcessId  
70.             );  
71.   
72.         if (hProcess == NULL)  
73.             __leave;  
74.   
75.         // 计算DLL路径名需要的字节数.  
76.         cch = 1 + lstrlen(lpszLibName);  
77.   
78.         // 在远程线程中为路径名分配空间.  
79.         pszLibFileRemote = (PSTR)VirtualAllocEx(  
80.             hProcess,   
81.             NULL,   
82.             cch,   
83.             MEM_COMMIT,   
84.             PAGE_READWRITE  
85.             );  
86.   
87.         if (pszLibFileRemote == NULL)   
88.             __leave;  
89.   
90.         // 将DLL的路径名复制到远程进程的内存空间.  
91.         if (!WriteProcessMemory(  
92.             hProcess,   
93.             (PVOID)pszLibFileRemote,   
94.             (PVOID)lpszLibName,   
95.             cch,   
96.             NULL))   
97.             __leave;  
98.   
99.         // 获得LoadLibraryA在Kernel32.dll中的真正地址.   
100.         pfnThreadRtn = (PTHREAD_START_ROUTINE)GetProcAddress(  
101.             GetModuleHandle(TEXT("Kernel32")), TEXT("LoadLibraryA"));  
102.   
103.         if (pfnThreadRtn == NULL)   
104.             __leave;  
105.   
106.         // 创建远程线程，并通过远程线程调用用户的DLL文件.   
107.         hThread = CreateRemoteThread(  
108.             hProcess,   
109.             NULL,   
110.             0,   
111.             pfnThreadRtn,   
112.             (PVOID)pszLibFileRemote,   
113.             0,   
114.             NULL  
115.             );  
116.         if (hThread == NULL)   
117.             __leave;  
118.   
119.         // 等待远程线程终止.  
120.         WaitForSingleObject(hThread, INFINITE);  
121.         bResult = TRUE;   
122.     }  
123.     __finally   
124.     {   
125.         // 关闭句柄.   
126.         if (pszLibFileRemote != NULL)   
127.             VirtualFreeEx(hProcess, (PVOID)pszLibFileRemote, 0, MEM_RELEASE);  
128.         if (hThread  != NULL)   
129.             CloseHandle(hThread);  
130.         if (hProcess != NULL)   
131.             CloseHandle(hProcess);  
132.     }  
133.     return bResult;  
134. }  
135. /************************************* 
136. * BOOL GetProcessIdByName(LPSTR szProcessName, LPDWORD lpPID) 
137. * 功能    通过进程名获取进程PID 
138. * 
139. * 参数    LPSTR szProcessName 进程名 
140. *       LPDWORD lpPID       指向保存PID的变量 
141. * 返回是否成功 
142. **************************************/  
143. BOOL GetProcessIdByName(LPSTR szProcessName, LPDWORD lpPID)  
144. {  
145.     // 变量及初始化  
146.     STARTUPINFO st;  
147.     PROCESS_INFORMATION pi;  
148.     PROCESSENTRY32 ps;  
149.     HANDLE hSnapshot;  
150.     ZeroMemory(&st, sizeof(STARTUPINFO));  
151.     ZeroMemory(&pi, sizeof(PROCESS_INFORMATION));  
152.     st.cb = sizeof(STARTUPINFO);  
153.     ZeroMemory(&ps,sizeof(PROCESSENTRY32));  
154.     ps.dwSize = sizeof(PROCESSENTRY32);  
155.     // 遍历进程  
156.     hSnapshot = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0);  
157.     if(hSnapshot == INVALID_HANDLE_VALUE)  
158.     {  
159.         return FALSE;  
160.     }  
161.   
162.     if(!Process32First(hSnapshot,&ps))  
163.     {  
164.         return FALSE;  
165.     }  
166.     do  
167.     {  
168.         // 比较进程名  
169.         if(lstrcmpi(ps.szExeFile,"explorer.exe")==0)  
170.         {  
171.             // 找到了  
172.             *lpPID = ps.th32ProcessID;  
173.             CloseHandle(hSnapshot);  
174.             return TRUE;  
175.         }  
176.     }  
177.     while(Process32Next(hSnapshot,&ps));  
178.     // 没有找到  
179.     CloseHandle(hSnapshot);  
180.     return FALSE;  
181. }  
182. /************************************* 
183. * int WinMain( 
184. *           HINSTANCE hInstance, 
185. *           HINSTANCE hPrevInstance, 
186. *           LPSTR lpCmdLine, 
187. *           int nCmdShow 
188. *           ) 
189. **************************************/  
190. int WinMain(  
191.             HINSTANCE hInstance,  
192.             HINSTANCE hPrevInstance,  
193.             LPSTR lpCmdLine,  
194.             int nCmdShow  
195.             )  
196. {  
197.     DWORD dwPID;  
198.     // 提权，获取SE_DEBUG_NAME权限，  
199.     // 可以在其他进程的内存空间中写入、创建线程  
200.     if(0!=EnablePrivilege (SE_DEBUG_NAME))  
201.         return 0;  
202.     // 获取目录进程的PID  
203.     if(!GetProcessIdByName("explorer.exe",&dwPID))  
204.         return 0;  
205.     // 通过创建远程线程加载DLL  
206.     // 将msg.dll放置在系统目录下  
207.     if(!LoadRometeDll(dwPID,"msg.dll"))  
208.         return 0;  
209.     return 1;  
210. }