远程注入代码利用SetTimer函数实现异常处理

丛林宝宝

windows默认会用异常处理程序包含SetTimer的回调函数TimerProc，所以可以利用这一点给远程注入代码加上异常处理过程，防止注入代码导致远程程序异常崩溃。并且异常处理过程由windows自动处理，不需要编写额外代码，非常方便。

微软文档所述：
Windows 会将其对 TimerProc 的 调用括起来，其中包含使用和放弃所有异常的异常处理程序。 这是自 Windows 2000 以来的默认行为，但在 Windows 的未来版本中，这一行为可能会更改。 https://learn.microsoft.com/zh-cn/windows/win32/api/winuser/nf-winuser-setuserobjectinformationw

验证SetTimer函数自带异常处理
首先必须知道的是由windows消息队列来调用TimerProc函数。具体的说是SetTimer函数带回调函数时，由DispatchMessage函数调用TimerProc函数，且触发异常后，异常以后的代码不会被执行。

新建VS工程，选windows控制台程序，完整代码如下。

1. #include <windows.h>
   
2. #include <iostream>
   
3. 
   
4. using namespace std;
   
5. 
   
6. // 计时器回调函数
   
7. VOID CALLBACK Timerproc(
   
8.   HWND hwnd,        // handle to window for timer messages
   
9.   UINT message,     // WM_TIMER message
   
10.   UINT idTimer,     // timer identifier
    
11.   DWORD dwTime)     // current system time
    
12. {
    
13.   cout << "Timerproc" << endl;
    
14.   int a = 1, b = 0, c = 0;
    
15.   c = a / b;  // 这句代码会引发异常，除数为零
    
16.   cout << c << endl;
    
17. }
    
18. 
    
19. int main() {
    
20.   //const HWND hwnd = GetConsoleWindow(); // 获取本进程句柄
    
21. 
    
22.   const UINT_PTR timer_id = SetTimer(nullptr,      // 绑定的窗口句柄
    
23.                                      0,            // timer ID
    
24.                                      0x0,          // 倒计时数，毫秒
    
25.                                      Timerproc);   // 回调函数
    
26.   int Counter = 0;
    
27.   MSG msg;
    
28.   while (GetMessage(&msg, nullptr, 0, 0)) {
    
29.     ++Counter;
    
30.     cout << "Counter: " << Counter << "; message: " << msg.message << '\n';
    
31.     DispatchMessage(&msg);
    
32.   }
    
33.   return 0;
    
34. }

复制代码

调试运行，VS输出标签里重复提示除数为零异常，但程序仍然正常运行，没有显示cout << c << endl;这句代码，说明异常处理程序确实包含了TimerProc函数。


新线程内执行TimerProc函数
控制台程序
远程注入的代码是通过CreateRemoteThread函数执行，也就是新建一个线程。所以先来模拟本地新线程执行情景。

1. #include <windows.h>
   
2. #include <iostream>
   
3. #include <process.h>
   
4. 
   
5. using namespace std;
   
6. 
   
7. HANDLE hEvent;
   
8. // 计时器回调函数
   
9. VOID CALLBACK Timerproc(
   
10.   HWND hwnd,        // handle to window for timer messages
    
11.   UINT message,     // WM_TIMER message
    
12.   UINT idTimer,     // timer identifier
    
13.   DWORD dwTime)     // current system time
    
14. {
    
15.   cout << "Timerproc" << endl;
    
16.   KillTimer(hwnd, idTimer);
    
17.   int a = 1, b = 0, c = 0;
    
18.   c = a / b;  // 这句代码会引发异常，除数为零
    
19.   cout << c << endl;
    
20.   SetEvent(hEvent);
    
21. }
    
22. 
    
23. DWORD WINAPI thread(_In_ LPVOID lpParameter) {
    
24.   HWND process_hwnd = *(HWND*)lpParameter;
    
25.   cout << "process_hwnd=" << process_hwnd << endl;
    
26.   cout << "thread start PID=" << GetCurrentThreadId() << endl;
    
27.   UINT_PTR timer_id;
    
28.   const HANDLE thread_hwnd = GetCurrentThread();
    
29.   timer_id = SetTimer(nullptr, 0, 0, nullptr);
    
30.   timer_id = SetTimer(process_hwnd,      // 绑定的窗口句柄
    
31.                       timer_id,     // timer ID
    
32.                       0x0,          // 倒计时数，毫秒
    
33.                       Timerproc);   // 回调函数
    
34. 
    
35.   hEvent = CreateEvent(nullptr, FALSE, FALSE, nullptr);
    
36.   WaitForSingleObject(hEvent, 5000);
    
37.   cout << "WaitForSingleObject end" << endl;
    
38.   CloseHandle(hEvent);
    
39.   return 0;
    
40. }
    
41. 
    
42. int main() {
    
43.   //HANDLE process_handle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, GetCurrentProcessId());
    
44.   //cout << "process_handle=" << process_handle << endl;
    
45. 
    
46.   HWND process_hwnd = GetConsoleWindow();
    
47.   cout << "process_hwnd=" << process_hwnd << endl;
    
48.   const HANDLE thread_handle = CreateThread(nullptr, 0, thread, &process_hwnd, 0, nullptr);
    
49.   cout << "CreateThread thread_handle=" << thread_handle << endl;
    
50.   BOOL bRet;
    
51.   int Counter = 0;
    
52.   MSG msg;
    
53.   while ((bRet = GetMessage(&msg, nullptr, 0, 0)) != 0) {
    
54.     if (bRet == -1) {
    
55.       // handle the error and possibly exit
    
56.     }
    
57.     else {
    
58.       ++Counter;
    
59.       cout << "Counter: " << Counter << "; message: " << msg.message << '\n';
    
60.       TranslateMessage(&msg);
    
61.       DispatchMessage(&msg);
    
62.     }
    
63. 
    
64.   }
    
65.   return 0;
    
66. }

复制代码

上面的代码无法运行成功，原因是TimeProc函数并未执行。没有执行是因为消息队列没有消息，那么GetMessage就会阻塞进程，不执行while循环体。不进入循环体，DispatchMessage函数就无法调用TimeProc函数。

至于为什么这里SetTimer函数没有触发消息……我也不知道。

窗口程序
控制台程序无法成功运行，但是换窗口程序却可以成功运行。

代码流程：

WinMain函数是主函数，主函数中创建新线程执行thread函数。

thread函数中创建事件，新建空计时器。新建空计时器是为了避免覆盖注入进程中已有的计时器（当SetTimer函数的第1、2参数为0时，windows会自动在当前进程创建新的计时器ID）。然后再次设置计时器，传入注入进程句柄、新建空计时器ID、Timerproc回调函数。最后执行WaitForSingleObject函数阻塞等待事件信号，如果Timerproc函数触发异常了，则会超时指定时间后继续执行。
Timerproc函数可以自动处理异常，需要注意的是触发异常后的代码不会被执行。函数首先关闭计时器，接着直接插入注入代码或调用call函数，最后设置信号为有状态，以便让WaitForSingleObject函数接收信号。

call函数有没有都可以，单独的call函数方便编程和调试。

改进的代码如下：

1. #include <iostream>
   
2. #include <windows.h>
   
3. 
   
4. using namespace std;
   
5. 
   
6. static const TCHAR gc_szClassName[] = TEXT("Test");
   
7. static const TCHAR gc_szWindowTitle[] = TEXT("Test");
   
8. 
   
9. HANDLE hEvent;
   
10. 
    
11. void call() {
    
12.   int a = 1, b = 0, c = 0;
    
13.   c = a / b;  // 这句代码会引发异常，除数为零
    
14.   cout << c << endl;
    
15. }
    
16. 
    
17. // 计时器回调函数
    
18. VOID CALLBACK Timerproc(
    
19.   HWND hwnd,        // handle to window for timer messages
    
20.   UINT message,     // WM_TIMER message
    
21.   UINT idTimer,     // timer identifier
    
22.   DWORD dwTime)     // current system time
    
23. {
    
24.   cout << "Timerproc" << endl;
    
25.   if (KillTimer(hwnd, idTimer))
    
26.     cout << "KillTimer done" << endl;
    
27.   else
    
28.     cout << "KillTimer error" << endl;
    
29.   call(); // 如果函数内异常导致退出，则不会执行下面的代码
    
30.   SetEvent(hEvent);
    
31. }
    
32. 
    
33. DWORD WINAPI thread(_In_ LPVOID lpParameter) {
    
34.   HWND process_hwnd = *(HWND*)lpParameter;
    
35.   cout << "process_hwnd=" << process_hwnd << endl;
    
36.   cout << "thread start PID=" << GetCurrentThreadId() << endl;
    
37.   UINT_PTR timer_id;
    
38.   const HANDLE thread_hwnd = GetCurrentThread();
    
39.   hEvent = CreateEvent(nullptr, FALSE, FALSE, nullptr);
    
40.   timer_id = SetTimer(nullptr, 0, 0, nullptr);
    
41.   timer_id = SetTimer(process_hwnd,      // 绑定的窗口句柄
    
42.                       timer_id,     // timer ID
    
43.                       0x0,          // 倒计时数，毫秒
    
44.                       Timerproc);   // 回调函数
    
45.   cout << "timer_id=" << timer_id << endl;
    
46.   WaitForSingleObject(hEvent, 5000);
    
47.   cout << "WaitForSingleObject end" << endl;
    
48.   CloseHandle(hEvent);
    
49.   return 0;
    
50. }
    
51. 
    
52. LRESULT CALLBACK WndProc(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam) {
    
53.   switch (uMessage) {
    
54.   case WM_CREATE:
    
55.     break;
    
56. 
    
57.   case WM_CLOSE:
    
58.     DestroyWindow(hWnd);
    
59.     break;
    
60. 
    
61.   case WM_DESTROY:
    
62.     PostQuitMessage(EXIT_SUCCESS);
    
63.     break;
    
64.   default:;
    
65.   }
    
66. 
    
67.   return DefWindowProc(hWnd, uMessage, wParam, lParam);
    
68. }
    
69. 
    
70. int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCommandLine, int nShowCommand) {
    
71.   // define variables
    
72.   HWND hWnd;
    
73.   WNDCLASS wc;
    
74.   MSG msg;
    
75. 
    
76.   // unused parameters
    
77.   UNREFERENCED_PARAMETER(hPrevInstance);
    
78.   UNREFERENCED_PARAMETER(lpszCommandLine);
    
79.   UNREFERENCED_PARAMETER(nShowCommand);
    
80. 
    
81.   // initialize WNDCLASS structure
    
82.   ZeroMemory(&wc, sizeof(wc));
    
83.   wc.lpfnWndProc = WndProc;
    
84.   wc.hInstance = hInstance;
    
85.   wc.lpszClassName = gc_szClassName;
    
86. 
    
87.   // attempt to register the class
    
88.   if (RegisterClass(&wc) != 0) {
    
89.     // show console
    
90.     AllocConsole();
    
91.     std::ignore = freopen_s((FILE**)stdout, "CONOUT$", "w", stdout);
    
92.     std::ignore = freopen_s((FILE**)stdout, "CONOUT$", "w", stderr);
    
93.     std::ignore = freopen_s((FILE**)stdout, "CONIN$", "r", stdin);
    
94.     std::cout.clear();
    
95.     std::clog.clear();
    
96.     std::cerr.clear();
    
97.     std::cin.clear();
    
98. 
    
99.     // attempt to create the window
    
100.     hWnd = CreateWindow(gc_szClassName, gc_szWindowTitle, WS_CAPTION | WS_SYSMENU | WS_VISIBLE, 100, 100, 100, 100, NULL, NULL, hInstance, NULL);
     
101.     cout << "window hwnd=" << hWnd << endl;
     
102. 
     
103.     const HANDLE thread_handle = CreateThread(nullptr, 0, thread, &hWnd, 0, nullptr);
     
104. 
     
105.     int Counter = 0;
     
106.     // retrieve messages
     
107.     while (GetMessage(&msg, NULL, 0, 0) > 0) {
     
108.       ++Counter;
     
109.       std::cout << "Counter: " << Counter << "; message: " << msg.message << '\n';
     
110.       TranslateMessage(&msg);
     
111.       DispatchMessage(&msg);
     
112.     }
     
113.     // use the return-code from the window
     
114.     return (int)msg.wParam;
     
115.   }
     
116.   return EXIT_FAILURE;
     
117. }

复制代码

将注入函数转为汇编语言
转为汇编语言这一步骤我卡住好几天。转为汇编语言本进程执行很简单，但如果要把thread()、timerproc()、call()三个函数在远程进程运行则有难度。主要难度为注入到远程进程后，由于没有基址重定位，无法执行call系统函数语句CALL KillTimer，也无法执行call自有函数语句CALL call。

研究了几天之后发现受限于内联汇编的功能局限性，不能用内联汇编完成目的。所以简单学习了一下asmjit，改用asmjit汇编引擎实现功能。

本进程执行代码
接下来需要将thread()、Timerproc()、call()函数转换为汇编语言。转换后的完整代码如下：

1. #include <iostream>
   
2. #include <windows.h>
   
3. 
   
4. using namespace std;
   
5. 
   
6. HANDLE hEvent;
   
7. 
   
8. void call() {
   
9.   //cout << "func call start" << endl;
   
10.   //int a = 1, b = 0, c = 0;
    
11.   //c = a / b;  // 这句代码会引发异常，除数为零
    
12.   //cout << "func call end" << endl;
    
13. 
    
14.   char start[] = "func call start\n";
    
15.   char end[] = "func call end\n";
    
16.   __asm {
    
17.     lea eax, start
    
18.     push eax
    
19.     call printf
    
20.     xor eax, eax
    
21.     div eax // 0除以0 异常语句
    
22.     lea eax, end
    
23.     push eax
    
24.     call printf
    
25.   }
    
26. }
    
27. 
    
28. // 计时器回调函数
    
29. VOID CALLBACK Timerproc(
    
30.   HWND hwnd,        // handle to window for timer messages
    
31.   UINT message,     // WM_TIMER message
    
32.   UINT idTimer,     // timer identifier
    
33.   DWORD dwTime)     // current system time
    
34. {
    
35.   //cout << "Timerproc" << endl;
    
36.   //if (KillTimer(hwnd, idTimer))
    
37.   //  cout << "KillTimer done" << endl;
    
38.   //else
    
39.   //  cout << "KillTimer error" << endl;
    
40.   //call(); // 如果函数内异常导致退出，则不会执行下面的代码
    
41.   //SetEvent(hEvent);
    
42. 
    
43.   __asm {
    
44.     push idTimer
    
45.     push hwnd
    
46.     call KillTimer
    
47.     call call
    
48.     //mov dword ptr ds : [0x12345678] , eax;  // 把call函数的返回值结果存放到指定的内存地址
    
49.     push hEvent
    
50.     call SetEvent
    
51.   }
    
52. }
    
53. 
    
54. DWORD WINAPI thread(_In_ LPVOID lpParameter) {
    
55.   HWND process_hwnd = *(HWND*)lpParameter;
    
56.   UINT_PTR timer_id;
    
57.   //cout << "process_hwnd=" << process_hwnd << endl;
    
58.   //cout << "thread start PID=" << GetCurrentThreadId() << endl;
    
59.   //const HANDLE thread_hwnd = GetCurrentThread();
    
60.   ////hEvent = CreateEvent(nullptr, FALSE, FALSE, nullptr);
    
61.   //timer_id = SetTimer(nullptr, 0, 0, nullptr);
    
62.   //timer_id = SetTimer(process_hwnd,      // 绑定的窗口句柄
    
63.   //                    timer_id,     // timer ID
    
64.   //                    0x0,          // 倒计时数，毫秒
    
65.   //                    Timerproc);   // 回调函数
    
66.   //cout << "timer_id=" << timer_id << endl;
    
67.   //WaitForSingleObject(hEvent, 5000);
    
68.   //cout << "WaitForSingleObject end" << endl;
    
69.   //CloseHandle(hEvent);
    
70. 
    
71.   char start[] = "func thread start\n";
    
72.   char end[] = "func thread end\n";
    
73.   __asm {
    
74.     lea eax, start
    
75.     push eax
    
76.     call printf
    
77.     push 0
    
78.     push 0
    
79.     push 0
    
80.     push 0
    
81.     call CreateEvent
    
82.     mov hEvent, eax
    
83.     push 0
    
84.     push 0
    
85.     push 0
    
86.     push 0
    
87.     call SetTimer
    
88.     push Timerproc
    
89.     push 0
    
90.     push eax
    
91.     push process_hwnd
    
92.     call SetTimer
    
93.     mov timer_id, eax
    
94.     push 0x1388; 5000毫秒
    
95.     push hEvent
    
96.     call WaitForSingleObject
    
97.     push hEvent
    
98.     call CloseHandle
    
99.     lea eax, end
    
100.     push eax
     
101.     call printf
     
102.   }
     
103.   return 0;
     
104. }
     
105. 
     
106. LRESULT CALLBACK WndProc(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam) {
     
107.   switch (uMessage) {
     
108.   case WM_CREATE:
     
109.     break;
     
110. 
     
111.   case WM_CLOSE:
     
112.     DestroyWindow(hWnd);
     
113.     break;
     
114. 
     
115.   case WM_DESTROY:
     
116.     PostQuitMessage(EXIT_SUCCESS);
     
117.     break;
     
118.   default:;
     
119.   }
     
120. 
     
121.   return DefWindowProc(hWnd, uMessage, wParam, lParam);
     
122. }
     
123. 
     
124. int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCommandLine, int nShowCommand) {
     
125.   // define variables
     
126.   HWND hWnd;
     
127.   WNDCLASS wc;
     
128.   MSG msg;
     
129. 
     
130.   // unused parameters
     
131.   UNREFERENCED_PARAMETER(hPrevInstance);
     
132.   UNREFERENCED_PARAMETER(lpszCommandLine);
     
133.   UNREFERENCED_PARAMETER(nShowCommand);
     
134. 
     
135.   // initialize WNDCLASS structure
     
136.   ZeroMemory(&wc, sizeof(wc));
     
137.   wc.lpfnWndProc = WndProc;
     
138.   wc.hInstance = hInstance;
     
139.   wc.lpszClassName = TEXT("class name");
     
140. 
     
141.   // attempt to register the class
     
142.   if (RegisterClass(&wc) != 0) {
     
143.     AllocConsole();
     
144.     std::ignore = freopen_s((FILE**)stdout, "CONOUT$", "w", stdout);
     
145.     std::ignore = freopen_s((FILE**)stdout, "CONOUT$", "w", stderr);
     
146.     std::ignore = freopen_s((FILE**)stdout, "CONIN$", "r", stdin);
     
147.     std::cout.clear();
     
148.     std::clog.clear();
     
149.     std::cerr.clear();
     
150.     std::cin.clear();
     
151. 
     
152.     // attempt to create the window
     
153.     hWnd = CreateWindow(TEXT("class name"), TEXT("window title"), WS_CAPTION | WS_SYSMENU | WS_VISIBLE, 1100, 600, 100, 100, NULL, NULL, hInstance, NULL);
     
154.     cout << "window hwnd=" << hWnd << endl;
     
155. 
     
156.     const HANDLE thread_handle = CreateThread(nullptr, 0, thread, &hWnd, 0, nullptr);
     
157. 
     
158.     int Counter = 0;
     
159.     // retrieve messages
     
160.     while (GetMessage(&msg, NULL, 0, 0) > 0) {
     
161.       ++Counter;
     
162.       std::cout << "Counter: " << Counter << "; message: " << msg.message << '\n';
     
163.       TranslateMessage(&msg);
     
164.       DispatchMessage(&msg);
     
165.     }
     
166.     // use the return-code from the window
     
167.     return (int)msg.wParam;
     
168.   }
     
169.   return EXIT_FAILURE;
     
170. }

复制代码

运行成功。实际应用时可以把call函数里的两个调试printf语句删了。

远程进程执行代码
代码只适用于x86程序，如果你系统是64位系统，测试用的笔记本程序需要使用c:\windows\SysWOW64\notepad.exe

1. #include <algorithm>
   
2. #include <format>
   
3. #include <iomanip>
   
4. #include <windows.h>
   
5. #include <iostream>
   
6. #include <psapi.h>
   
7. #include <string>
   
8. #include <asmjit/asmjit.h>
   
9. 
   
10. using namespace std;
    
11. using namespace asmjit;
    
12. using namespace x86;
    
13. 
    
14. struct THREAD_PARAM {
    
15.   DWORD ret_value;    // alloc_addr + 0x0
    
16.   FARPROC settimer;   // alloc_addr + 0x4
    
17.   FARPROC killtimer;  // alloc_addr + 0x8
    
18.   HWND remote_hwnd;   // alloc_addr + 0xC
    
19.   DWORD timerproc;    // alloc_addr + 0x10
    
20.   DWORD timer_id;     // alloc_addr + 0x14
    
21.   DWORD custom_call;  // alloc_addr + 0x18
    
22. };
    
23. 
    
24. /**
    
25. * \brief 获取指定进程中的模块函数句柄
    
26. * \param hRemoteProcess 指定进程句柄
    
27. * \param lpModuleName 指定函数名所在的模块名，大小写任意
    
28. * \param lpProcName 指定要获取的函数名，大小写必须匹配
    
29. * \return 成功则返回指定的函数地址，未找到返回空指针
    
30. * \note 可至微软learn网站查询函数所在的模块
    
31. */
    
32. FARPROC GetRemoteModule(_In_ const HANDLE hRemoteProcess, _In_ const LPCWSTR lpModuleName, _In_ const LPCSTR lpProcName) {
    
33.   // https://learn.microsoft.com/zh-cn/windows/win32/psapi/enumerating-all-modules-for-a-process
    
34. 
    
35.   // 获取远程模块信息
    
36.   HMODULE hModule[MAX_PATH];
    
37.   DWORD cbNeeded;
    
38.   if (!EnumProcessModules(hRemoteProcess, hModule, MAX_PATH, &cbNeeded))
    
39.     return nullptr;
    
40. 
    
41.   // 遍历枚举到的模块
    
42.   for (size_t i = 0; i < cbNeeded / sizeof(HMODULE); i++) {
    
43.     TCHAR szModName[MAX_PATH];
    
44. 
    
45.     // Get the full path to the module's file.
    
46.     if (GetModuleFileNameEx(hRemoteProcess, hModule[i], szModName,
    
47.                             sizeof(szModName) / sizeof(TCHAR))) {
    
48.       // 转为wstring字符串，并全部转换为小写以便比较
    
49.       wstring ModName(szModName);
    
50.       wstring ModuleName(lpModuleName);
    
51.       ranges::transform(ModName, ModName.begin(), ::tolower);
    
52.       ranges::transform(ModuleName, ModuleName.begin(), ::tolower);
    
53. 
    
54.       //wcout << format(L"\t0x{:08X} {}\n", (DWORD)hModule[i], ModName);
    
55. 
    
56.       // 如果是要找的模块
    
57.       if (ModName.find(ModuleName) != wstring::npos)
    
58.         // 如果GetProcAddress函数成功，则返回值是导出的函数或变量的地址。如果GetProcAddress函数失败，则返回值为 NULL。 要获得更多的错误信息，请调用 GetLastError。
    
59.         return GetProcAddress(hModule[i], lpProcName);
    
60.     }
    
61.   }
    
62.   return nullptr;
    
63. }
    
64. 
    
65. int main() {
    
66.   const HWND remote_hwnd =
    
67.     FindWindow(L"Notepad", nullptr);
    
68.   cout << "remote_hwnd=" << remote_hwnd << endl;
    
69. 
    
70.   DWORD remote_pid = 0;
    
71.   GetWindowThreadProcessId(remote_hwnd, &remote_pid);
    
72.   cout << "remote_pid=" << remote_pid << endl;
    
73. 
    
74.   const HANDLE remote_handle = OpenProcess(PROCESS_ALL_ACCESS, false, remote_pid);
    
75.   if (!remote_handle)
    
76.     return 0;
    
77. 
    
78.   // 获取远程进程模块函数信息
    
79.   auto settimer = GetRemoteModule(remote_handle, TEXT("User32.dll"), "SetTimer");
    
80.   auto killtimer = GetRemoteModule(remote_handle, TEXT("User32.dll"), "KillTimer");
    
81.   //cout << format("SetTimer addr=0x{:08X}\n", (DWORD)settimer);
    
82.   //cout << format("KillTimer addr=0x{:08X}\n", (DWORD)killtimer);
    
83. 
    
84.   // 申请远程空间，写入和执行权限
    
85.   DWORD alloc_addr = (DWORD)VirtualAllocEx(remote_handle, nullptr, MAX_PATH, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    
86.   if (!alloc_addr) {
    
87.     cout << "GetLastError()=" << GetLastError() << endl;
    
88.     return 0;
    
89.   }
    
90.   cout << setw(8) << setfill('0') << hex << "VirtualAlloc addr=0x" << alloc_addr << endl;
    
91.   DWORD addr_param = alloc_addr;  // 参数内存地址
    
92.   DWORD addr_call = alloc_addr + 0x21;  // 函数地址
    
93. 
    
94.   // 构造和写入函数
    
95.   THREAD_PARAM thread_param{};
    
96.   thread_param.remote_hwnd = remote_hwnd;
    
97.   thread_param.settimer = settimer;
    
98.   thread_param.killtimer = killtimer;
    
99. 
    
100.   // 生成代码
     
101.   JitRuntime rt;
     
102.   auto a = x86::Assembler();
     
103.   CodeHolder code;
     
104.   code.init(rt.environment(), rt.cpuFeatures());
     
105.   code.attach(&a);
     
106. 
     
107.   // 构造thread函数
     
108.   a.push(0);
     
109.   a.push(0);
     
110.   a.push(0);
     
111.   a.push(0);
     
112.   a.call(dword_ptr(alloc_addr + 0x4));  // settimer
     
113.   a.mov(dword_ptr(alloc_addr + 0x14), eax); //timer_id
     
114.   a.push(dword_ptr(alloc_addr + 0x10));  // timerproc
     
115.   a.push(0);
     
116.   a.push(eax);
     
117.   a.push(dword_ptr(alloc_addr + 0xC));  // remote_hwnd
     
118.   a.call(dword_ptr(alloc_addr + 0x4));  // settimer
     
119.   a.ret();
     
120.   CodeBuffer& thread = code.textSection()->buffer();  // 获取对应的机器码
     
121.   // 打印生成的机器码
     
122.   //cout << "assembly=";
     
123.   //for (auto& i : thread)
     
124.   //  cout << format("{:02X} ", i);
     
125.   //cout << endl;
     
126. 
     
127.   size_t nSize = thread.size();
     
128.   cout << format("线程函数写入地址=0x{:08X} 大小=0x{:08X}\n", addr_call, nSize);
     
129.   WriteProcessMemory(remote_handle, (LPVOID)addr_call, thread.data(), nSize, nullptr);
     
130.   DWORD thread_addr = addr_call; // 记录线程函数地址
     
131.   addr_call = addr_call + nSize + 0x8;
     
132. 
     
133.   // 重置并复用CodeHolder变量code
     
134.   code.reset();
     
135.   code.init(rt.environment(), rt.cpuFeatures());
     
136.   code.attach(&a);
     
137. 
     
138.   // 构造timerproc
     
139.   a.push(dword_ptr(alloc_addr + 0x14)); // idTimer
     
140.   a.push(dword_ptr(alloc_addr + 0xC));  // hwnd
     
141.   a.call(dword_ptr(alloc_addr + 0x8)); // call KillTimer
     
142.   a.call(dword_ptr(alloc_addr + 0x18)); // custom_call
     
143.   a.ret();
     
144.   CodeBuffer& timerproc = code.textSection()->buffer();
     
145. 
     
146.   thread_param.timerproc = addr_call; // 记录therad地址
     
147.   nSize = timerproc.size();
     
148.   cout << format("回调函数写入地址=0x{:08X} 大小=0x{:08X}\n", addr_call, nSize);
     
149.   WriteProcessMemory(remote_handle, (LPVOID)addr_call, timerproc.data(), nSize, nullptr);
     
150.   addr_call = addr_call + nSize + 0x8;
     
151. 
     
152.   // 重置并复用CodeHolder变量code
     
153.   code.reset();
     
154.   code.init(rt.environment(), rt.cpuFeatures());
     
155.   code.attach(&a);
     
156. 
     
157.   // 构造自定函数
     
158.   a.xor_(eax, eax);
     
159.   a.div(eax); // 异常语句
     
160.   a.mov(dword_ptr(alloc_addr), eax);  // 写入返回值到alloc_addr，程序读取alloc_addr地址的数值即可知道返回值
     
161.   a.ret();
     
162.   CodeBuffer& custom_call = code.textSection()->buffer();
     
163. 
     
164.   thread_param.custom_call = addr_call; // 记录custom_call地址
     
165.   nSize = custom_call.size();
     
166.   cout << format("自定函数写入地址=0x{:08X} 大小=0x{:08X}\n", addr_call, nSize);
     
167.   WriteProcessMemory(remote_handle, (LPVOID)addr_call, custom_call.data(), nSize, nullptr);
     
168.   addr_call = addr_call + nSize + 0x8;
     
169. 
     
170.   // 写入参数
     
171.   cout << format("线程参数写入地址=0x{:08X} 大小=0x{:08X}\n", addr_param, sizeof(THREAD_PARAM));
     
172.   WriteProcessMemory(remote_handle, (LPVOID)addr_param, &thread_param, sizeof(THREAD_PARAM), nullptr);
     
173. 
     
174.   const HANDLE hRemoteThread = CreateRemoteThread(remote_handle, nullptr, 0, (LPTHREAD_START_ROUTINE)thread_addr, (LPVOID)addr_param, 0, nullptr);
     
175. 
     
176.   //system("pause");
     
177.   return 0;
     
178. }

复制代码

vipsnadong

远程注入代码利用SetTimer函数实现异常处理