CallRemoteAPI - 调用远程进程中的函数

梦幻的彼岸

翻译
原文地址：https://www.x86matthew.com/view_post?id=call_remote_api
功能：调用远程进程中的函数
目前我们可以使用CreateRemoteThread来调用一个远程进程中的函数，但这只限于以下格式的函数：

1. DWORD __stdcall ThreadProc(LPVOID lpParameter);

复制代码

我开发了一个通用函数，可以远程调用任何API。首先，自动生成代码存根并将其写入目标进程：

1. push param_1
   
2. push param_2
   
3. push param_3
   
4. ...
   
5. mov eax, TargetFunction
   
6. call eax
   
7. push eax
   
8. mov eax, RtlExitUserThread
   
9. call eax

复制代码

这段代码调用目标函数，然后用原函数的返回值调用RtlExitUserThread。

我们可以使用CreateRemoteThread在目标进程中执行上述代码，使用WaitForSingleObject等待线程退出，并使用GetExitCodeThread获取返回值。

下面是完整的代码：

1. #include <stdio.h>
   
2. #include <windows.h>
   
3. 
   
4. DWORD CallRemoteAPI(HANDLE hProcess, DWORD dwAddr, DWORD *pdwParamList, DWORD dwParamCount, DWORD *pdwReturnValue)
   
5. {
   
6.         DWORD dwThreadID = 0;
   
7.         HANDLE hThread = NULL;
   
8.         DWORD dwExitCode = 0;
   
9.         DWORD dwRtlExitUserThread = 0;
   
10.         DWORD dwExecFunctionCodeLength = 0;
    
11.         BYTE bPushParamCode[] = { 0x68, 0x00, 0x00, 0x00, 0x00 };
    
12.         BYTE bExecFunctionCode[] = { 0xB8, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xD0, 0x50, 0xB8, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xD0 };
    
13.         BYTE *pRemoteExecFunctionCode = NULL;
    
14. 
    
15.         // get RtlExitUserThread address
    
16.         dwRtlExitUserThread = (DWORD)GetProcAddress(GetModuleHandle("ntdll.dll"), "RtlExitUserThread");
    
17.         if(dwRtlExitUserThread == 0)
    
18.         {
    
19.                 return 1;
    
20.         }
    
21. 
    
22.         // calculate code length:
    
23.         // push param_1
    
24.         // push param_2
    
25.         // push param_3
    
26.         // ...
    
27.         // mov eax, TargetFunction
    
28.         // call eax
    
29.         // push eax
    
30.         // mov eax, RtlExitUserThread
    
31.         // call eax
    
32.         dwExecFunctionCodeLength = (dwParamCount * sizeof(bPushParamCode)) + sizeof(bExecFunctionCode);
    
33. 
    
34.         // allocate memory in remote process
    
35.         pRemoteExecFunctionCode = (BYTE*)VirtualAllocEx(hProcess, NULL, dwExecFunctionCodeLength, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    
36.         if(pRemoteExecFunctionCode == NULL)
    
37.         {
    
38.                 return 1;
    
39.         }
    
40. 
    
41.         // write function parameter values
    
42.         for(DWORD i = 0; i < dwParamCount; i++)
    
43.         {
    
44.                 // set current param value
    
45.                 *(DWORD*)&bPushParamCode[1] = pdwParamList[dwParamCount - 1 - i];
    
46.                 if(WriteProcessMemory(hProcess, (BYTE*)(pRemoteExecFunctionCode + (i * sizeof(bPushParamCode))), (void*)bPushParamCode, sizeof(bPushParamCode), NULL) == 0)
    
47.                 {
    
48.                         // error
    
49.                         VirtualFreeEx(hProcess, pRemoteExecFunctionCode, 0, MEM_RELEASE);
    
50. 
    
51.                         return 1;
    
52.                 }
    
53.         }
    
54. 
    
55.         // set target function address
    
56.         *(DWORD*)&bExecFunctionCode[1] = dwAddr;
    
57. 
    
58.         // set RtlExitUserThread function address
    
59.         *(DWORD*)&bExecFunctionCode[9] = dwRtlExitUserThread;
    
60. 
    
61.         // write function execution code
    
62.         if(WriteProcessMemory(hProcess, (BYTE*)(pRemoteExecFunctionCode + (dwParamCount * sizeof(bPushParamCode))), (void*)bExecFunctionCode, sizeof(bExecFunctionCode), NULL) == 0)
    
63.         {
    
64.                 // error
    
65.                 VirtualFreeEx(hProcess, pRemoteExecFunctionCode, 0, MEM_RELEASE);
    
66. 
    
67.                 return 1;
    
68.         }
    
69. 
    
70.         // create a thread in the remote process
    
71.         hThread = CreateRemoteThread(hProcess, NULL, (128 * 1024), (LPTHREAD_START_ROUTINE)pRemoteExecFunctionCode, NULL, 0, &dwThreadID);
    
72.         if(hThread == NULL)
    
73.         {
    
74.                 // error
    
75.                 VirtualFreeEx(hProcess, pRemoteExecFunctionCode, 0, MEM_RELEASE);
    
76. 
    
77.                 return 1;
    
78.         }
    
79. 
    
80.         // wait for thread to complete
    
81.         WaitForSingleObject(hThread, INFINITE);
    
82. 
    
83.         // get thread exit code (api return value)
    
84.         if(GetExitCodeThread(hThread, &dwExitCode) == 0)
    
85.         {
    
86.                 // error
    
87.                 CloseHandle(hThread);
    
88.                 VirtualFreeEx(hProcess, pRemoteExecFunctionCode, 0, MEM_RELEASE);
    
89. 
    
90.                 return 1;
    
91.         }
    
92. 
    
93.         // close thread handle
    
94.         CloseHandle(hThread);
    
95. 
    
96.         // free remote code block
    
97.         VirtualFreeEx(hProcess, pRemoteExecFunctionCode, 0, MEM_RELEASE);
    
98. 
    
99.         // store return value
    
100.         *pdwReturnValue = dwExitCode;
     
101. 
     
102.         return 0;
     
103. }

复制代码

如果我们需要在远程进程中分配更多的数据（例如字符串参数），我们可以使用以下函数：

1. BYTE *AllocateRemoteData(HANDLE hProcess, BYTE *pData, DWORD dwDataLength)
   
2. {
   
3.         BYTE *pRemoteDataAddr = NULL;
   
4. 
   
5.         // allocate memory in remote process
   
6.         pRemoteDataAddr = (BYTE*)VirtualAllocEx(hProcess, NULL, dwDataLength, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
   
7.         if(pRemoteDataAddr == NULL)
   
8.         {
   
9.                 return NULL;
   
10.         }
    
11. 
    
12.         if(pData != NULL)
    
13.         {
    
14.                 // write data to remote process
    
15.                 if(WriteProcessMemory(hProcess, pRemoteDataAddr, (void*)pData, dwDataLength, NULL) == 0)
    
16.                 {
    
17.                         // error
    
18.                         VirtualFreeEx(hProcess, pRemoteDataAddr, 0, MEM_RELEASE);
    
19. 
    
20.                         return NULL;
    
21.                 }
    
22.         }
    
23. 
    
24.         return pRemoteDataAddr;
    
25. }
    
26. 
    
27. BYTE *AllocateRemoteString(HANDLE hProcess, char *pData)
    
28. {
    
29.         // allocate string data
    
30.         return AllocateRemoteData(hProcess, (BYTE*)pData, strlen(pData) + 1);
    
31. }

复制代码

例子 #1 - 在一个远程进程中调用MessageBoxA

1. int main(int argc, char *argv[])
   
2. {
   
3.         DWORD dwPID = 0;
   
4.         char *pMsgTextParam = NULL;
   
5.         DWORD dwReturnValue = 0;
   
6.         DWORD dwParamList[4];
   
7.         HANDLE hProcess = NULL;
   
8.         void *pMsgTitle = NULL;
   
9.         void *pMsgText = NULL;
   
10. 
    
11.         if(argc != 3)
    
12.         {
    
13.                 printf("Usage: %s [target_pid] [msg]\n\n", argv[0]);
    
14. 
    
15.                 return 1;
    
16.         }
    
17. 
    
18.         // get command-line param values
    
19.         dwPID = atoi(argv[1]);
    
20.         pMsgTextParam = argv[2];
    
21. 
    
22.         printf("Opening process: %u...\n", dwPID);
    
23. 
    
24.         // open target process
    
25.         hProcess = OpenProcess(PROCESS_ALL_ACCESS, 0, dwPID);
    
26.         if(hProcess == NULL)
    
27.         {
    
28.                 // error
    
29.                 printf("Failed to open process: %u\n", dwPID);
    
30. 
    
31.                 return 1;
    
32.         }
    
33. 
    
34.         printf("Allocating strings in remote process...\n\n");
    
35. 
    
36.         // allocate string in remote process
    
37.         pMsgTitle = AllocateRemoteString(hProcess, "CallRemoteAPI");
    
38.         if(pMsgTitle == NULL)
    
39.         {
    
40.                 printf("Failed to allocate string\n");
    
41. 
    
42.                 // error
    
43.                 CloseHandle(hProcess);
    
44. 
    
45.                 return 1;
    
46.         }
    
47. 
    
48.         // allocate string in remote process
    
49.         pMsgText = AllocateRemoteString(hProcess, pMsgTextParam);
    
50.         if(pMsgText == NULL)
    
51.         {
    
52.                 printf("Failed to allocate string\n");
    
53. 
    
54.                 // error
    
55.                 VirtualFreeEx(hProcess, pMsgTitle, 0, MEM_RELEASE);
    
56.                 CloseHandle(hProcess);
    
57. 
    
58.                 return 1;
    
59.         }
    
60. 
    
61.         // set MessageBox parameters
    
62.         dwParamList[0] = 0;
    
63.         dwParamList[1] = (DWORD)pMsgText;
    
64.         dwParamList[2] = (DWORD)pMsgTitle;
    
65.         dwParamList[3] = MB_OK;
    
66. 
    
67.         printf("Calling MessageBoxA in remote process...\n");
    
68. 
    
69.         // call MessageBox in target process
    
70.         if(CallRemoteAPI(hProcess, (DWORD)MessageBoxA, dwParamList, 4, &dwReturnValue) != 0)
    
71.         {
    
72.                 printf("Failed to call remote API\n");
    
73. 
    
74.                 // error
    
75.                 VirtualFreeEx(hProcess, pMsgTitle, 0, MEM_RELEASE);
    
76.                 VirtualFreeEx(hProcess, pMsgText, 0, MEM_RELEASE);
    
77.                 CloseHandle(hProcess);
    
78. 
    
79.                 return 1;
    
80.         }
    
81. 
    
82.         printf("MessageBoxA returned: %u\n", dwReturnValue);
    
83. 
    
84.         // free remote memory
    
85.         VirtualFreeEx(hProcess, pMsgTitle, 0, MEM_RELEASE);
    
86.         VirtualFreeEx(hProcess, pMsgText, 0, MEM_RELEASE);
    
87.         CloseHandle(hProcess);
    
88. 
    
89.         return 0;
    
90. }

复制代码

例子#2 - 在一个远程进程中创建一个文件

1. int main(int argc, char *argv[])
   
2. {
   
3.         DWORD dwPID = 0;
   
4.         char *pFilePathParam = NULL;
   
5.         char *pContentParam = NULL;
   
6.         DWORD dwReturnValue = 0;
   
7.         DWORD dwParamList[16];
   
8.         HANDLE hProcess = NULL;
   
9.         void *pFilePath = NULL;
   
10.         void *pContent = NULL;
    
11.         void *pBytesWritten = NULL;
    
12.         HANDLE hFile = NULL;
    
13. 
    
14.         printf("CallRemoteAPI - www.x86matthew.com\n\n");
    
15. 
    
16.         if(argc != 4)
    
17.         {
    
18.                 printf("Usage: %s [target_pid] [file_path] [content]\n\n", argv[0]);
    
19. 
    
20.                 return 1;
    
21.         }
    
22. 
    
23.         // get command-line param values
    
24.         dwPID = atoi(argv[1]);
    
25.         pFilePathParam = argv[2];
    
26.         pContentParam = argv[3];
    
27. 
    
28.         printf("Opening process: %u...\n", dwPID);
    
29. 
    
30.         // open target process
    
31.         hProcess = OpenProcess(PROCESS_ALL_ACCESS, 0, dwPID);
    
32.         if(hProcess == NULL)
    
33.         {
    
34.                 // error
    
35.                 printf("Failed to open process: %u\n", dwPID);
    
36. 
    
37.                 return 1;
    
38.         }
    
39. 
    
40.         printf("Allocating data in remote process...\n\n");
    
41. 
    
42.         // allocate string in remote process
    
43.         pFilePath = AllocateRemoteString(hProcess, pFilePathParam);
    
44.         if(pFilePath == NULL)
    
45.         {
    
46.                 printf("Failed to allocate string\n");
    
47. 
    
48.                 // error
    
49.                 CloseHandle(hProcess);
    
50. 
    
51.                 return 1;
    
52.         }
    
53. 
    
54.         // allocate string in remote process
    
55.         pContent = AllocateRemoteString(hProcess, pContentParam);
    
56.         if(pContent == NULL)
    
57.         {
    
58.                 printf("Failed to allocate string\n");
    
59. 
    
60.                 // error
    
61.                 VirtualFreeEx(hProcess, pFilePath, 0, MEM_RELEASE);
    
62.                 CloseHandle(hProcess);
    
63. 
    
64.                 return 1;
    
65.         }
    
66. 
    
67.         // allocate dword value (BytesWritten) in remote process
    
68.         pBytesWritten = AllocateRemoteData(hProcess, NULL, sizeof(DWORD));
    
69.         if(pBytesWritten == NULL)
    
70.         {
    
71.                 printf("Failed to allocate value\n");
    
72. 
    
73.                 // error
    
74.                 VirtualFreeEx(hProcess, pContent, 0, MEM_RELEASE);
    
75.                 VirtualFreeEx(hProcess, pFilePath, 0, MEM_RELEASE);
    
76.                 CloseHandle(hProcess);
    
77. 
    
78.                 return 1;
    
79.         }
    
80. 
    
81.         // set CreateFile parameters
    
82.         dwParamList[0] = (DWORD)pFilePath;
    
83.         dwParamList[1] = GENERIC_WRITE;
    
84.         dwParamList[2] = 0;
    
85.         dwParamList[3] = 0;
    
86.         dwParamList[4] = CREATE_ALWAYS;
    
87.         dwParamList[5] = FILE_ATTRIBUTE_NORMAL;
    
88.         dwParamList[6] = 0;
    
89. 
    
90.         printf("Calling CreateFileA...\n");
    
91. 
    
92.         // call CreateFileA
    
93.         if(CallRemoteAPI(hProcess, (DWORD)CreateFileA, dwParamList, 7, &dwReturnValue) != 0)
    
94.         {
    
95.                 printf("Failed to call remote API\n");
    
96. 
    
97.                 // error
    
98.                 VirtualFreeEx(hProcess, pBytesWritten, 0, MEM_RELEASE);
    
99.                 VirtualFreeEx(hProcess, pContent, 0, MEM_RELEASE);
    
100.                 VirtualFreeEx(hProcess, pFilePath, 0, MEM_RELEASE);
     
101.                 CloseHandle(hProcess);
     
102. 
     
103.                 return 1;
     
104.         }
     
105. 
     
106.         printf("CreateFileA returned 0x%08x\n\n", dwReturnValue);
     
107. 
     
108.         // store the returned file handle
     
109.         hFile = (HANDLE)dwReturnValue;
     
110. 
     
111.         // check if CreateFile failed
     
112.         if(hFile == INVALID_HANDLE_VALUE)
     
113.         {
     
114.                 printf("CreateFileA failed\n");
     
115. 
     
116.                 // error
     
117.                 VirtualFreeEx(hProcess, pBytesWritten, 0, MEM_RELEASE);
     
118.                 VirtualFreeEx(hProcess, pContent, 0, MEM_RELEASE);
     
119.                 VirtualFreeEx(hProcess, pFilePath, 0, MEM_RELEASE);
     
120.                 CloseHandle(hProcess);
     
121. 
     
122.                 return 1;
     
123.         }
     
124. 
     
125.         // set WriteFile parameters
     
126.         dwParamList[0] = (DWORD)hFile;
     
127.         dwParamList[1] = (DWORD)pContent;
     
128.         dwParamList[2] = strlen(pContentParam);
     
129.         dwParamList[3] = (DWORD)pBytesWritten;
     
130.         dwParamList[4] = 0;
     
131. 
     
132.         printf("Calling WriteFile...\n");
     
133. 
     
134.         // call WriteFile
     
135.         if(CallRemoteAPI(hProcess, (DWORD)WriteFile, dwParamList, 5, &dwReturnValue) != 0)
     
136.         {
     
137.                 printf("Failed to call remote API\n");
     
138. 
     
139.                 // error
     
140.                 VirtualFreeEx(hProcess, pBytesWritten, 0, MEM_RELEASE);
     
141.                 VirtualFreeEx(hProcess, pContent, 0, MEM_RELEASE);
     
142.                 VirtualFreeEx(hProcess, pFilePath, 0, MEM_RELEASE);
     
143.                 CloseHandle(hProcess);
     
144. 
     
145.                 return 1;
     
146.         }
     
147. 
     
148.         printf("WriteFile returned 0x%08x\n\n", dwReturnValue);
     
149. 
     
150.         // set CloseHandle parameters
     
151.         dwParamList[0] = (DWORD)hFile;
     
152. 
     
153.         printf("Calling CloseHandle...\n");
     
154. 
     
155.         // call CloseHandle
     
156.         if(CallRemoteAPI(hProcess, (DWORD)CloseHandle, dwParamList, 1, &dwReturnValue) != 0)
     
157.         {
     
158.                 printf("Failed to call remote API\n");
     
159. 
     
160.                 // error
     
161.                 VirtualFreeEx(hProcess, pBytesWritten, 0, MEM_RELEASE);
     
162.                 VirtualFreeEx(hProcess, pContent, 0, MEM_RELEASE);
     
163.                 VirtualFreeEx(hProcess, pFilePath, 0, MEM_RELEASE);
     
164.                 CloseHandle(hProcess);
     
165. 
     
166.                 return 1;
     
167.         }
     
168. 
     
169.         printf("CloseHandle returned 0x%08x\n\n", dwReturnValue);
     
170. 
     
171.         // clean up
     
172.         VirtualFreeEx(hProcess, pBytesWritten, 0, MEM_RELEASE);
     
173.         VirtualFreeEx(hProcess, pContent, 0, MEM_RELEASE);
     
174.         VirtualFreeEx(hProcess, pFilePath, 0, MEM_RELEASE);
     
175.         CloseHandle(hProcess);
     
176. 
     
177.         return 0;
     
178. }

复制代码