0
0

Windows 动态注入（远程线程、消息钩子、APC）

Windows PC端动态注入（远程线程、消息钩子、APC）

说明：实现注入进程“FlappyBird.exe”，实现弹窗。完整代码在文末。

文章目录

远程线程注入

注入DLL

首先需要一个事先准备好的DLL文件testDLL.dll，用vs2019创建一个DLL工程，在程序入口调用MessageBoxA()。

远程线程DLL注入的基本原理是利用Windows提供的API函数**CreateRemoteThread()**，实现在另外一个进程中注入一个线程，后续只要在线程体中执行加载testDLL.dll的操作，目标进程就会执行testDLL.dll中的代码了。

一个比较关键的问题是创建的远程线程是在目标进程中执行，无法调用本地函数，因此要利用系统API实现加载dll文件的操作。Win32程序在运行时都会加载kernel32.dll，而Windows默认同一个系统中dll的文件加载位置是固定的，因此kernel32.dll中的导出函数在任何进程的地址空间中的位置是固定的。动态加载dll文件需要系统API **LoadLibraryA()**，这个函数正好是kernel32.dll的导出函数。因此我们只需要在注射器程序中获取LoadLibraryA()的地址，令创建的远程线程执行LoadLibraryA()，传入参数testDLL.dll的路径，即可实现远程线程DLL注入。

具体实现步骤及部分源码如下（所有完整代码见文末）：

1、根据进程名（“FlappyBird.exe”）查找进程ID

自己实现函数FindProcess()，入口参数：进程名、进程ID(出参)；步骤如下：

调用CreateToolhelp32Snapshot()获取进程快照；传入参数Th32CS_SNAPPROCESS用于指定“在快照中包含系统中所有的进程”

调用**Process32First()、Process32Next()**遍历进程信息，对进程名进行字符串比较直至与目标进程名相等。

  1. //由进程名获取进程ID
  2. bool FindProcess(const wchar_t* processName, DWORD& dwProcess) {
  3.     PROCESSENTRY32 pe32;  
  4.     pe32.dwSize = sizeof(PROCESSENTRY32);      
  5.     //获取进程快照
  6.     HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);     
  7.     if (hProcessSnap == INVALID_HANDLE_VALUE) {
  8.         return false;
  9.     }
  10.     if (Process32First(hProcessSnap, &pe32)) {
  11.         do {
  12.             if (wcscmp(pe32.szExeFile, processName) == 0) {
  13.                 dwProcess = pe32.th32ProcessID;
  14.                 break;
  15.             }
  16.         } while (Process32Next(hProcessSnap, &pe32));
  17.     }
  18.     CloseHandle(hProcessSnap);
  19.     if(dwProcess == 0) {
  20.         return false;
  21.     }
  22.     return true;
  23. }

2、调用OpenProcess()获取进程句柄，传入参数dwProcess(进程ID)；调用VirtualAllocEx()在目标进程中为testDLL.dll的路径（字符串）分配内存空间（用于之后作为LoadLibraryA的参数）；调用**WriteProcessMemory()**将testDLL.dll的路径写入内存。

调用LoadLibrary()加载动态链接库“kernel32.dll”，调用GetProcAddress()获取“LoadLibraryA”的地址。

调用CreateRemoteThread()创建远程线程，传入参数LoadLibraryA()地址和存放testDLL.dll路径的内存地址。等待线程结束关闭句柄，释放内存空间。

  1. //DLL远程线程注入
  2. void CreateRemoteThread_Inject(){
  3.     DWORD dwProcess = 0;
  4.     char myDLL[] = "C:\\testDLL.dll";
  5.     //查找进程FlappyBird.exe
  6.     if(FindProcess(L"FlappyBird.exe", dwProcess)){
  7.         HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcess);    //打开进程
  8.         LPVOID allocatedMem = VirtualAllocEx(hProcess, NULL, sizeof(myDLL), MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);  //在进程中分配内存
  9.         WriteProcessMemory(hProcess, allocatedMem, myDLL, sizeof(myDLL), NULL); //写入DLL路径
  10.         HMODULE hModule = LoadLibrary(L"kernel32.dll");                //获取kernel32.dll模块句柄
  11.         //获取LoadLibraryA函数地址
  12.         LPTHREAD_START_ROUTINE pfnStarAddress = (LPTHREAD_START_ROUTINE)GetProcAddress(hModule, "LoadLibraryA");
  13.         if(pfnStarAddress == NULL){
  14.             cout << "GetProcAddress failed" << endl;
  15.             return;
  16.         }
  17.         HANDLE hRemoteThread = CreateRemoteThread(hProcess, NULL, NULL, pfnStarAddress, allocatedMem, NULL, NULL);  //创建远程线程
  18.         if(hRemoteThread == NULL){
  19.             cout << "CreateRemoteThread failed" << endl;
  20.             return;
  21.         }
  22.         WaitForSingleObject(hRemoteThread, INFINITE);  //等待远程线程结束
  23.         CloseHandle(hRemoteThread);                                
  24.         VirtualFreeEx(hProcess, allocatedMem, 0, MEM_FREE);
  25.     }
  26.     return;
  27. }

注入Shellcode

DLL注入实现虽然简单，但是会在目标进程加载一个模块，已经能够被多数杀软主动拦截；我们用**CreateRemoteThread()**函数实现DLL远程线程注入，也可以自己编写Shellcode实现注入，相对DLL来说隐蔽性更强。

注入shellcode的难点是，由于注入的代码要“写入”其他进程空间当中，因此不能使用任何全局变量、不能调用本地定义的函数、不能调用一些库函数等等。当然，shellcode使用栈空间的局部变量、使用系统API（kernel32.dll）都是没有问题的，如果使用其他dll库的函数可以用kernel32.dll导出函数**LoadLibraryA()加载对应的dll后，再使用GetProcAddress()**获取函数地址。

远程线程注入shellcode的原理与注入DLL原理类似，都是使用**OpenProcess + VirtualAllocEx + WriteProcessMemory + CreateRemoteThread **的框架，关键在于shellcode的编写，以在目标进程执行MessageBox()为例，具体步骤和部分代码如下：

1、定义线程参数结构体，用于接收API（LoadLibraryA()和GetProcAddress()的地址）和参数（加载的dll名、调用的API、API的参数）；定义函数指针；

  1. //该结构体用于接收API和4个字符串
  2. typedef struct _THREAD_PARAM {
  3.     FARPROC pFunc[2];
  4.     char szBuf[4][128];
  5. } THREAD_PARAM, *PTHREAD_PARAM;
  6. typedef HMODULE (WINAPI *PFLOADLIBRARYA)    
  7. (
  8.     LPCSTR lpLibFileName
  9. );  //定义LoadLibraryA函数指针
  10. typedef FARPROC (WINAPI *PFGETPROCADDRESS)
  11. (
  12.     HMODULE hModule,
  13.     LPCSTR lpProcName
  14. ); //定义GetProcAddress函数指针
  15. typedef int (WINAPI *PFMESSAGEBOXA)
  16. (
  17.     HWND hWnd,
  18.     LPCSTR lpText,
  19.     LPCSTR lpCaption,
  20.     UINT uType
  21. ); //定义MessageBoxA函数指针

2、编写shellcode，以上述结构体类型作为参数，依次调用API，实现调用MessageBoxA()；

  1. //线程函数
  2. //未直接调用相关API和未直接定义使用字符串，而通过THREAD_PARAM结构体以线程参数的形式传递使用
  3. DWORD WINAPI ThreadProc(LPVOID lpParam)
  4. {   
  5.     PTHREAD_PARAM pParam = (PTHREAD_PARAM)lpParam;
  6.     HMODULE hMod = NULL;
  7.     FARPROC pFunc = NULL;
  8.     hMod = ((PFLOADLIBRARYA)pParam->pFunc[0])(pParam->szBuf[0]);        //调用LoadLibraryA函数
  9.     if (hMod == NULL)
  10.     {
  11.         return 1;
  12.     }
  13.     pFunc = ((PFGETPROCADDRESS)pParam->pFunc[1])(hMod, pParam->szBuf[1]);   //获取MessageBoxA函数地址
  14.     if (pFunc == NULL)
  15.     {
  16.         return 1;
  17.     }
  18.     ((PFMESSAGEBOXA)pFunc)(NULL, pParam->szBuf[2], pParam->szBuf[3], 0);    //调用MessageBoxA函数
  19.     return 0;
  20. }

3、实现提权函数EnableDebugPrivilege()

  1. bool EnableDebugPrivilege() {
  2.     HANDLE hToken;
  3.     TOKEN_PRIVILEGES tp;
  4.     //打开进程令牌
  5.     if(!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) {
  6.         cout<<"OpenProcessToken failed"<<endl;
  7.         return false;
  8.     }
  9.     //获取LUID
  10.     if(!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &tp.Privileges[0].Luid)) {
  11.         cout<<"LookupPrivilegeValue failed"<<endl;
  12.         return false ;
  13.     }
  14.     //设置权限
  15.     tp.PrivilegeCount = 1;  //只设置一个权限
  16.     tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;     //设置权限为启用，如果为SE_PRIVILEGE_REMOVED则为禁用
  17.     //修改进程令牌，提升权限，使得能够访问受保护的进程，如系统进程，其他用户进程等
  18.     if(!AdjustTokenPrivileges(hToken, FALSE, &tp, sizeof(tp), NULL, NULL)) {
  19.         cout<<"AdjustTokenPrivileges failed"<<endl;
  20.         return false;
  21.     }
  22.     return true;
  23. }

4、实现注入

准备好参数，使用CreatRemoteThread()框架实现注入，注意为代码申请的内存必须设置为可读可写可执行，注意将参数和shellcode都写入目标进程。

  1. void CreateRemoteThread_shellcode()
  2. {
  3.     EnableDebugPrivilege(); //提升权限
  4.     DWORD dwProcess = 0;
  5.     //查找进程FlappyBird.exe
  6.     if(FindProcess(L"FlappyBird.exe", dwProcess)){
  7.         HMODULE hMod = NULL;
  8.         THREAD_PARAM param = {0,};  //定义线程结构体变量
  9.         HANDLE hProcess = NULL;
  10.         HANDLE hThread = NULL;
  11.         LPVOID pRemoteBuf[2] = {0,};
  12.         DWORD dwSize = 0;
  14.         hMod = GetModuleHandleA("kernel32.dll");
  16.         //设置THREAD_PARAM结构体
  17.         //加载到所有进程的kernel32.dll的地址都相同，因此从本进程获取的API与在目标进程中获取的API地址是一样的
  18.         param.pFunc[0] = GetProcAddress(hMod, "LoadLibraryA");
  19.         param.pFunc[1] = GetProcAddress(hMod, "GetProcAddress");
  20.         strcpy_s(param.szBuf[0], "user32.dll");
  21.         strcpy_s(param.szBuf[1], "MessageBoxA");
  22.         strcpy_s(param.szBuf[2], "shellcode Success");
  23.         strcpy_s(param.szBuf[3], "inject");
  24.         
  25.         hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcess);
  26.         if (hProcess == NULL)
  27.         {
  28.             cout<<"OpenProcess failed"<<endl;
  29.             return;
  30.         }
  31.         //分配内存
  32.         dwSize = sizeof(THREAD_PARAM);
  33.         pRemoteBuf[0] = VirtualAllocEx(hProcess, NULL, dwSize, MEM_COMMIT, PAGE_READWRITE);
  34.         if (pRemoteBuf[0] == NULL)
  35.         {
  36.             cout<<"VirtualAllocEx failed"<<endl;
  37.             return;
  38.         }
  39.         //将线程参数写入目标进程
  40.         if (!WriteProcessMemory(hProcess, pRemoteBuf[0], (LPVOID)&param, dwSize, NULL))
  41.         {
  42.             cout<<"WriteProcessMemory failed"<<endl;
  43.             return;
  44.         }
  45.         dwSize = (DWORD)CreateRemoteThread_shellcode - (DWORD)ThreadProc;  //计算shellcode大小
  46.         pRemoteBuf[1] = VirtualAllocEx(hProcess, NULL, dwSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
  47.         if (pRemoteBuf[1] == NULL)
  48.         {
  49.             cout<<"VirtualAllocEx failed"<<endl;
  50.             return;
  51.         }
  52.         //将shellcode写入目标进程
  53.         if (!WriteProcessMemory(hProcess, pRemoteBuf[1], (LPVOID)ThreadProc, dwSize, NULL))
  54.         {
  55.             cout<<"WriteProcessMemory failed"<<endl;
  56.             return;
  57.         }
  58.         //创建远程线程
  59.         hThread = CreateRemoteThread(
  60.             hProcess, 
  61.             NULL, 
  62.             0, 
  63.             (LPTHREAD_START_ROUTINE)pRemoteBuf[1], //线程函数地址
  64.             pRemoteBuf[0],                     //线程参数地址
  65.             0, NULL
  66.         );
  67.         if (hThread == NULL)
  68.         {
  69.             cout<<"CreateRemoteThread failed"<<endl;
  70.             return;
  71.         }
  72.         WaitForSingleObject(hThread, INFINITE);
  73.         CloseHandle(hThread);
  74.         CloseHandle(hProcess);
  75.     }
  76. }

消息钩子注入DLL

消息钩子注入原理是利用Windows提供的**SetWindowsHookEx()**函数，它可以拦截进程的消息到指定的DLL中导出的函数，目标进程就会自动加载我们指定的DLL，利用这个特性可以实现消息钩子注入。

具体实现步骤和部分源码如下：

1、编写一个testDLL.dll用于Hook，在其中显式导出一个函数**NextHook()**；

  1. //导出函数
  2. extern "C" __declspec(dllexport) int NextHook(int code, WPARAM wParam, LPARAM lParam){
  3.     return CallNextHookEx(NULL, code, wParam, lParam);
  4. }

2、在注射器中首先调用FindWindow()查找窗口“FlappyBird”获取窗口句柄；调用GetWindowThreadProcessId()获取进程ID和线程ID；调用LoadLibraryEx()加载testDLL.dll到自身进程，传入参数DONT_RESOLVE_DLL_REFERENCES用于指定“不对DLL初始化”；调用**GetProcAddress()获取钩子函数NextHook()**的地址；

  1. int SetWindowHookEx_inject() {
  2.     HWND hwnd = FindWindow(NULL, L"FlappyBird"); //查找窗口
  3.     if (hwnd == NULL) {
  4.         cout << "FindWindow failed" << endl;
  5.         return 1;
  6.     }
  7.     DWORD pid = NULL;
  8.     DWORD tid = GetWindowThreadProcessId(hwnd, &pid); //获取进程ID
  9.     if (tid == NULL) {
  10.         cout << "GetWindow tid/pid failed" << endl;
  11.         return 1;
  12.     }
  13.     
  14.     HMODULE dll = LoadLibraryEx(L"C:\\testDLL.dll", NULL, DONT_RESOLVE_DLL_REFERENCES); //加载DLL
  15.     if (dll == NULL) {
  16.         cout << "LoadLibraryEx DLL failed" << endl;
  17.         return 1;
  18.     }
  19.     
  20.     HOOKPROC addr = (HOOKPROC)GetProcAddress(dll, "NextHook"); //获取钩子函数地址
  21.     if (addr == NULL) {
  22.         cout << "GetProcAddress failed" << endl;
  23.         return 1;
  24.     }
  25.     
  26.     HHOOK handle = SetWindowsHookEx(WH_GETMESSAGE, addr, dll, tid); //设置钩子
  27.     if (handle == NULL) {
  28.         cout << "SetWindowsHookEx failed" << endl;
  29.         return EXIT_FAILURE;
  30.     }
  31.     
  32.     PostThreadMessage(tid, WM_NULL, 0, 0); //发送消息,触发钩子
  33.     cout<<"SetWindowsHookEx_inject success"<<endl;
  34.     cout<<"Press any key to unhook"<<endl;
  35.     getchar();
  37.     BOOL unhook = UnhookWindowsHookEx(handle); //卸载钩子
  38.     if (unhook == NULL) {
  39.         cout << "UnhookWindowsHookEx failed" << endl;
  40.         return EXIT_FAILURE;
  41.     }
  42.     return 0;
  43. }

APC注入DLL

APC全称Asynchronous Procedure Call，叫异步过程调用，是指函数在特定现场中被异步执行，在操作系统中，APC是一种并发机制。

APC注入实现原理核心是利用QueueUserApc()这个API添加制定的回调函数到目标线程的APC队列中，系统会产生一个软中断，在线程下一次被调度/唤醒的时候，就会执行回调函数，因此我们只需要令LoadLibraryW作为回调函数，并且传入参数dll路径，即可实现注入。

当然APC注入是有条件的，用户态下的APC请求想要执行，必须等待线程进入“Alertable”状态，而只有当线程调用特定函数（SleepEx, SignalObjectAndWait, MsgWaitForMultipleObjectsEx, WaitForMultipleObjectsEx或WaitForSingleObjectEx）时，才会进入Alertable状态，所以为了应对这种苛刻的条件，提高注入成功的机率同时缩短等待时间，我们需要遍历进程的所有线程，并对每一个线程进行APC注入。

具体实现步骤和部分源码如下：

1、根据进程名（“FlappyBird.exe”）查找进程ID并且获取所有的线程ID，获取线程ID的方法与查找进程ID类似；

  1. //根据进程名获取进程ID及其所有线程ID
  2. bool FindProcess2(const wchar_t* processName, DWORD& dwProcess, vector<DWORD>& dwThreads) {
  3.     PROCESSENTRY32 pe32;
  4.     pe32.dwSize = sizeof(PROCESSENTRY32);
  5.     HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);  //创建进程快照
  6.     if (hProcessSnap == INVALID_HANDLE_VALUE) {
  7.         cout << "CreateToolhelp32Snapshot failed" << endl;
  8.         return false;
  9.     }
  10.     if (!Process32First(hProcessSnap, &pe32)) {     //获取第一个进程信息
  11.         cout << "Process32First failed" << endl;
  12.         CloseHandle(hProcessSnap);
  13.         return false;
  14.     }
  15.     do {
  16.         if (wcscmp(pe32.szExeFile, processName) == 0) {
  17.             dwProcess = pe32.th32ProcessID;
  18.             break;
  19.         }
  20.     } while (Process32Next(hProcessSnap, &pe32));
  21.     CloseHandle(hProcessSnap);
  22.     if (dwProcess == NULL) {
  23.         cout << "FindProcess failed" << endl;
  24.         return false;
  25.     }
  26.     THREADENTRY32 te32;
  27.     te32.dwSize = sizeof(THREADENTRY32);
  28.     HANDLE hThreadSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);    //创建线程快照
  29.     if (hThreadSnap == INVALID_HANDLE_VALUE) {
  30.         cout << "CreateToolhelp32Snapshot failed" << endl;
  31.         return false;
  32.     }
  33.     if (!Thread32First(hThreadSnap, &te32)) {
  34.         cout << "Thread32First failed" << endl;
  35.         CloseHandle(hThreadSnap);
  36.         return false;
  37.     }
  38.     do {
  39.         if (te32.th32OwnerProcessID == dwProcess) {
  40.             dwThreads.push_back(te32.th32ThreadID);     //获取目标进程的所有线程ID
  41.         }
  42.     } while (Thread32Next(hThreadSnap, &te32));
  43.     CloseHandle(hThreadSnap);
  44.     if (dwThreads.size() == 0) {
  45.         cout << "FindThread failed" << endl;
  46.         return false;
  47.     }
  48.     return true;
  49. }

2、调用OpenProcess()获取进程句柄，调用VirtuealAllocEx()为参数dll路径远程申请内存，调用WriteProcessMemory()写入dll路径；遍历所有线程，插入APC；具体插入步骤为：调用OpenThread()获取线程句柄，调用GetProcAddress()和GetModuleHandle()获取LoadLibraryW()地址，调用QueueUserAPC()实现插入APC。

  1. void APC_Inject(){
  2.     DWORD pid;
  3.     vector<DWORD> tids;     //需要获取进程所有的线程ID
  4.     if (FindProcess2(L"FlappyBird.exe", pid, tids)) {
  5.         HANDLE hProcess = OpenProcess(PROCESS_VM_WRITE | PROCESS_VM_OPERATION, FALSE, pid);
  6.         if (hProcess == NULL) {
  7.             cout << "OpenProcess failed" << endl;
  8.             return;
  9.         }
  10.         auto p = VirtualAllocEx(hProcess, NULL, 1<<12, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); //在目标进程中申请内存
  11.         wchar_t buffer[] = L"C:\\testDLL.dll";
  12.         WriteProcessMemory(hProcess, p, buffer, sizeof(buffer), NULL); //将DLL路径写入目标进程中
  13.         for(const auto& tid: tids){
  14.             HANDLE hThread = ::OpenThread(THREAD_SET_CONTEXT, FALSE, tid);
  15.             if (hThread == NULL) {
  16.                 cout << "OpenThread failed" << endl;
  17.                 return;
  18.             }
  19.             QueueUserAPC((PAPCFUNC)GetProcAddress(GetModuleHandle(L"kernel32"),"LoadLibraryW"),hThread,(ULONG_PTR)p); //将APC注入到目标进程中
  20.         }
  21.         VirtualFreeEx(hProcess, p, 0, MEM_RELEASE | MEM_DECOMMIT);
  22.     }
  23. }

完整代码

inject.cpp

  1. #include <iostream>
  2. #include <vector>
  3. #include <Windows.h>
  4. #include <TlHelp32.h>
  5. #include <Psapi.h>
  6. #include <string>
  7. #include <tchar.h>
  8. using namespace std;
  10. //由进程名获取进程ID
  11. bool FindProcess(const wchar_t* processName, DWORD& dwProcess) {
  12.     PROCESSENTRY32 pe32;  
  13.     pe32.dwSize = sizeof(PROCESSENTRY32);      
  14.     //获取进程快照
  15.     HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);     
  16.     if (hProcessSnap == INVALID_HANDLE_VALUE) {
  17.         return false;
  18.     }
  19.     if (Process32First(hProcessSnap, &pe32)) {
  20.         do {
  21.             if (wcscmp(pe32.szExeFile, processName) == 0) {
  22.                 dwProcess = pe32.th32ProcessID;
  23.                 break;
  24.             }
  25.         } while (Process32Next(hProcessSnap, &pe32));
  26.     }
  27.     CloseHandle(hProcessSnap);
  28.     if(dwProcess == 0) {
  29.         return false;
  30.     }
  31.     return true;
  32. }
  34. //DLL远程线程注入
  35. void CreateRemoteThread_Inject(){
  36.     DWORD dwProcess = 0;
  37.     char myDLL[] = "C:\\testDLL.dll";
  38.     //查找进程FlappyBird.exe
  39.     if(FindProcess(L"FlappyBird.exe", dwProcess)){
  40.         HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcess);    //打开进程
  41.         LPVOID allocatedMem = VirtualAllocEx(hProcess, NULL, sizeof(myDLL), MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);  //在进程中分配内存
  42.         WriteProcessMemory(hProcess, allocatedMem, myDLL, sizeof(myDLL), NULL); //写入DLL路径
  43.         HMODULE hModule = LoadLibrary(L"kernel32.dll");                //获取kernel32.dll模块句柄
  44.         //获取LoadLibraryA函数地址
  45.         LPTHREAD_START_ROUTINE pfnStarAddress = (LPTHREAD_START_ROUTINE)GetProcAddress(hModule, "LoadLibraryA");
  46.         if(pfnStarAddress == NULL){
  47.             cout << "GetProcAddress failed" << endl;
  48.             return;
  49.         }
  50.         HANDLE hRemoteThread = CreateRemoteThread(hProcess, NULL, NULL, pfnStarAddress, allocatedMem, NULL, NULL);  //创建远程线程
  51.         if(hRemoteThread == NULL){
  52.             cout << "CreateRemoteThread failed" << endl;
  53.             return;
  54.         }
  55.         WaitForSingleObject(hRemoteThread, INFINITE);  //等待远程线程结束
  56.         CloseHandle(hRemoteThread);                                
  57.         VirtualFreeEx(hProcess, allocatedMem, 0, MEM_FREE);
  58.     }
  59.     return;
  60. }
  62. //***********************************************Shellcode远程线程注入***********************************************
  63. bool EnableDebugPrivilege() {
  64.     HANDLE hToken;
  65.     TOKEN_PRIVILEGES tp;
  66.     //打开进程令牌
  67.     if(!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) {
  68.         cout<<"OpenProcessToken failed"<<endl;
  69.         return false;
  70.     }
  71.     //获取LUID
  72.     if(!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &tp.Privileges[0].Luid)) {
  73.         cout<<"LookupPrivilegeValue failed"<<endl;
  74.         return false ;
  75.     }
  76.     //设置权限
  77.     tp.PrivilegeCount = 1;  //只设置一个权限
  78.     tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;     //设置权限为启用，如果为SE_PRIVILEGE_REMOVED则为禁用
  79.     //修改进程令牌，提升权限，使得能够访问受保护的进程，如系统进程，其他用户进程等
  80.     if(!AdjustTokenPrivileges(hToken, FALSE, &tp, sizeof(tp), NULL, NULL)) {
  81.         cout<<"AdjustTokenPrivileges failed"<<endl;
  82.         return false;
  83.     }
  84.     return true;
  85. }
  86. //该结构体用于接收API和4个字符串
  87. typedef struct _THREAD_PARAM {
  88.     FARPROC pFunc[2];
  89.     char szBuf[4][128];
  90. } THREAD_PARAM, *PTHREAD_PARAM;
  91. typedef HMODULE (WINAPI *PFLOADLIBRARYA)    
  92. (
  93.     LPCSTR lpLibFileName
  94. );  //定义LoadLibraryA函数指针
  95. typedef FARPROC (WINAPI *PFGETPROCADDRESS)
  96. (
  97.     HMODULE hModule,
  98.     LPCSTR lpProcName
  99. ); //定义GetProcAddress函数指针
  100. typedef int (WINAPI *PFMESSAGEBOXA)
  101. (
  102.     HWND hWnd,
  103.     LPCSTR lpText,
  104.     LPCSTR lpCaption,
  105.     UINT uType
  106. ); //定义MessageBoxA函数指针
  108. //线程函数
  109. //未直接调用相关API和未直接定义使用字符串，而通过THREAD_PARAM结构体以线程参数的形式传递使用
  110. DWORD WINAPI ThreadProc(LPVOID lpParam)
  111. {   
  112.     PTHREAD_PARAM pParam = (PTHREAD_PARAM)lpParam;
  113.     HMODULE hMod = NULL;
  114.     FARPROC pFunc = NULL;
  115.     hMod = ((PFLOADLIBRARYA)pParam->pFunc[0])(pParam->szBuf[0]);        //调用LoadLibraryA函数
  116.     if (hMod == NULL)
  117.     {
  118.         return 1;
  119.     }
  120.     pFunc = ((PFGETPROCADDRESS)pParam->pFunc[1])(hMod, pParam->szBuf[1]);   //获取MessageBoxA函数地址
  121.     if (pFunc == NULL)
  122.     {
  123.         return 1;
  124.     }
  125.     ((PFMESSAGEBOXA)pFunc)(NULL, pParam->szBuf[2], pParam->szBuf[3], 0);    //调用MessageBoxA函数
  126.     return 0;
  127. }
  129. //shellcode 注入
  130. void CreateRemoteThread_shellcode()
  131. {
  132.     EnableDebugPrivilege(); //提升权限
  133.     DWORD dwProcess = 0;
  134.     //查找进程FlappyBird.exe
  135.     if(FindProcess(L"FlappyBird.exe", dwProcess)){
  136.         HMODULE hMod = NULL;
  137.         THREAD_PARAM param = {0,};  //定义线程结构体变量
  138.         HANDLE hProcess = NULL;
  139.         HANDLE hThread = NULL;
  140.         LPVOID pRemoteBuf[2] = {0,};
  141.         DWORD dwSize = 0;
  143.         hMod = GetModuleHandleA("kernel32.dll");
  145.         //设置THREAD_PARAM结构体
  146.         //加载到所有进程的kernel32.dll的地址都相同，因此从本进程获取的API与在目标进程中获取的API地址是一样的
  147.         param.pFunc[0] = GetProcAddress(hMod, "LoadLibraryA");
  148.         param.pFunc[1] = GetProcAddress(hMod, "GetProcAddress");
  149.         strcpy_s(param.szBuf[0], "user32.dll");
  150.         strcpy_s(param.szBuf[1], "MessageBoxA");
  151.         strcpy_s(param.szBuf[2], "shellcode Success");
  152.         strcpy_s(param.szBuf[3], "inject");
  153.         
  154.         hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcess);
  155.         if (hProcess == NULL)
  156.         {
  157.             cout<<"OpenProcess failed"<<endl;
  158.             return;
  159.         }
  160.         //分配内存
  161.         dwSize = sizeof(THREAD_PARAM);
  162.         pRemoteBuf[0] = VirtualAllocEx(hProcess, NULL, dwSize, MEM_COMMIT, PAGE_READWRITE);
  163.         if (pRemoteBuf[0] == NULL)
  164.         {
  165.             cout<<"VirtualAllocEx failed"<<endl;
  166.             return;
  167.         }
  168.         //将线程参数写入目标进程
  169.         if (!WriteProcessMemory(hProcess, pRemoteBuf[0], (LPVOID)&param, dwSize, NULL))
  170.         {
  171.             cout<<"WriteProcessMemory failed"<<endl;
  172.             return;
  173.         }
  174.         dwSize = (DWORD)CreateRemoteThread_shellcode - (DWORD)ThreadProc;  //计算shellcode大小
  175.         pRemoteBuf[1] = VirtualAllocEx(hProcess, NULL, dwSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
  176.         if (pRemoteBuf[1] == NULL)
  177.         {
  178.             cout<<"VirtualAllocEx failed"<<endl;
  179.             return;
  180.         }
  181.         //将shellcode写入目标进程
  182.         if (!WriteProcessMemory(hProcess, pRemoteBuf[1], (LPVOID)ThreadProc, dwSize, NULL))
  183.         {
  184.             cout<<"WriteProcessMemory failed"<<endl;
  185.             return;
  186.         }
  187.         //创建远程线程
  188.         hThread = CreateRemoteThread(
  189.             hProcess, 
  190.             NULL, 
  191.             0, 
  192.             (LPTHREAD_START_ROUTINE)pRemoteBuf[1], //线程函数地址
  193.             pRemoteBuf[0],                     //线程参数地址
  194.             0, NULL
  195.         );
  196.         if (hThread == NULL)
  197.         {
  198.             cout<<"CreateRemoteThread failed"<<endl;
  199.             return;
  200.         }
  201.         WaitForSingleObject(hThread, INFINITE);
  202.         CloseHandle(hThread);
  203.         CloseHandle(hProcess);
  204.     }
  205. }
  207. //***********************************************消息钩子注入***********************************************
  209. int SetWindowHookEx_inject() {
  210.     HWND hwnd = FindWindow(NULL, L"FlappyBird"); //查找窗口
  211.     if (hwnd == NULL) {
  212.         cout << "FindWindow failed" << endl;
  213.         return 1;
  214.     }
  215.     DWORD pid = NULL;
  216.     DWORD tid = GetWindowThreadProcessId(hwnd, &pid); //获取进程ID
  217.     if (tid == NULL) {
  218.         cout << "GetWindow tid/pid failed" << endl;
  219.         return 1;
  220.     }
  221.     
  222.     HMODULE dll = LoadLibraryEx(L"C:\\testDLL.dll", NULL, DONT_RESOLVE_DLL_REFERENCES); //加载DLL
  223.     if (dll == NULL) {
  224.         cout << "LoadLibraryEx DLL failed" << endl;
  225.         return 1;
  226.     }
  227.     
  228.     HOOKPROC addr = (HOOKPROC)GetProcAddress(dll, "NextHook"); //获取钩子函数地址
  229.     if (addr == NULL) {
  230.         cout << "GetProcAddress failed" << endl;
  231.         return 1;
  232.     }
  233.     
  234.     HHOOK handle = SetWindowsHookEx(WH_GETMESSAGE, addr, dll, tid); //设置钩子
  235.     if (handle == NULL) {
  236.         cout << "SetWindowsHookEx failed" << endl;
  237.         return EXIT_FAILURE;
  238.     }
  239.     
  240.     PostThreadMessage(tid, WM_NULL, 0, 0); //发送消息,触发钩子
  241.     cout<<"SetWindowsHookEx_inject success"<<endl;
  242.     cout<<"Press any key to unhook"<<endl;
  243.     getchar();
  245.     BOOL unhook = UnhookWindowsHookEx(handle); //卸载钩子
  246.     if (unhook == NULL) {
  247.         cout << "UnhookWindowsHookEx failed" << endl;
  248.         return EXIT_FAILURE;
  249.     }
  250.     return 0;
  251. }
  253. //***********************************************APC注入***********************************************
  255. //根据进程名获取进程ID及其所有线程ID
  256. bool FindProcess2(const wchar_t* processName, DWORD& dwProcess, vector<DWORD>& dwThreads) {
  257.     PROCESSENTRY32 pe32;
  258.     pe32.dwSize = sizeof(PROCESSENTRY32);
  259.     HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);  //创建进程快照
  260.     if (hProcessSnap == INVALID_HANDLE_VALUE) {
  261.         cout << "CreateToolhelp32Snapshot failed" << endl;
  262.         return false;
  263.     }
  264.     if (!Process32First(hProcessSnap, &pe32)) {     //获取第一个进程信息
  265.         cout << "Process32First failed" << endl;
  266.         CloseHandle(hProcessSnap);
  267.         return false;
  268.     }
  269.     do {
  270.         if (wcscmp(pe32.szExeFile, processName) == 0) {
  271.             dwProcess = pe32.th32ProcessID;
  272.             break;
  273.         }
  274.     } while (Process32Next(hProcessSnap, &pe32));
  275.     CloseHandle(hProcessSnap);
  276.     if (dwProcess == NULL) {
  277.         cout << "FindProcess failed" << endl;
  278.         return false;
  279.     }
  280.     THREADENTRY32 te32;
  281.     te32.dwSize = sizeof(THREADENTRY32);
  282.     HANDLE hThreadSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);    //创建线程快照
  283.     if (hThreadSnap == INVALID_HANDLE_VALUE) {
  284.         cout << "CreateToolhelp32Snapshot failed" << endl;
  285.         return false;
  286.     }
  287.     if (!Thread32First(hThreadSnap, &te32)) {
  288.         cout << "Thread32First failed" << endl;
  289.         CloseHandle(hThreadSnap);
  290.         return false;
  291.     }
  292.     do {
  293.         if (te32.th32OwnerProcessID == dwProcess) {
  294.             dwThreads.push_back(te32.th32ThreadID);     //获取目标进程的所有线程ID
  295.         }
  296.     } while (Thread32Next(hThreadSnap, &te32));
  297.     CloseHandle(hThreadSnap);
  298.     if (dwThreads.size() == 0) {
  299.         cout << "FindThread failed" << endl;
  300.         return false;
  301.     }
  302.     return true;
  303. }
  305. void APC_Inject(){
  306.     DWORD pid;
  307.     vector<DWORD> tids;     //需要获取进程所有的线程ID
  308.     if (FindProcess2(L"FlappyBird.exe", pid, tids)) {
  309.         HANDLE hProcess = OpenProcess(PROCESS_VM_WRITE | PROCESS_VM_OPERATION, FALSE, pid);
  310.         if (hProcess == NULL) {
  311.             cout << "OpenProcess failed" << endl;
  312.             return;
  313.         }
  314.         auto p = VirtualAllocEx(hProcess, NULL, 1<<12, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); //在目标进程中申请内存
  315.         wchar_t buffer[] = L"C:\\testDLL.dll";
  316.         WriteProcessMemory(hProcess, p, buffer, sizeof(buffer), NULL); //将DLL路径写入目标进程中
  317.         for(const auto& tid: tids){
  318.             HANDLE hThread = ::OpenThread(THREAD_SET_CONTEXT, FALSE, tid);
  319.             if (hThread == NULL) {
  320.                 cout << "OpenThread failed" << endl;
  321.                 return;
  322.             }
  323.             QueueUserAPC((PAPCFUNC)GetProcAddress(GetModuleHandle(L"kernel32"),"LoadLibraryW"),hThread,(ULONG_PTR)p); //将APC注入到目标进程中
  324.         }
  325.         VirtualFreeEx(hProcess, p, 0, MEM_RELEASE | MEM_DECOMMIT);
  326.     }
  327. }
  329. int main()
  330. {
  331.     printf("Inject\n");
  332.     CreateRemoteThread_Inject();
  333.     //CreateRemoteThread_shellcode();
  334.     //SetWindowHookEx_inject();
  335.     //APC_Inject();
  336.     printf("执行结束\n");
  337.     getchar();
  338.     return 0;
  339. }

dllmain.cpp

  1. // dllmain.cpp : 定义 DLL 应用程序的入口点。
  2. #include "pch.h"
  3. #include <Windows.h>
  5. //在DLL入口点中调用MessageBoxA
  6. BOOL APIENTRY DllMain( HMODULE hModule,
  7.                        DWORD  ul_reason_for_call,
  8.                        LPVOID lpReserved
  9.                      )
  10. {
  11.     switch (ul_reason_for_call)
  12.     {
  13.     case DLL_PROCESS_ATTACH:
  14.         MessageBox(NULL, L"Inject", L"注射成功", MB_OK);
  15.         break;
  16.     case DLL_THREAD_ATTACH:
  17.     case DLL_THREAD_DETACH:
  18.     case DLL_PROCESS_DETACH:
  19.         break;
  20.     }
  21.     return TRUE;
  22. }
  24. //导出函数
  25. extern "C" __declspec(dllexport) int NextHook(int code, WPARAM wParam, LPARAM lParam){
  26.     return CallNextHookEx(NULL, code, wParam, lParam);
  27. }
标签： c++ 安全
本文转载自: https://blog.csdn.net/m0_51762452/article/details/128939325
版权归原作者 晚安靴子 所有， 如有侵权，请联系我们删除。
登录后发布评论

“Windows 动态注入（远程线程、消息钩子、APC）”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？