windows.h : 2.DLL注入技术

深碍√TFBOYSˉ_ 2023-01-06 01:16 259阅读 0赞

windows中的大部分应用程序都是基于消息机制的，根据不同的消息完成不同的功能。 钩子这个机制就是由windows操作系统提供的可以用来截获和监视系统中这些消息的。

钩子又可以分为局部钩子和全局钩子。其中局部钩子是针对某个线程的，全局钩子是作用于整个系统的基于消息的应用。全局钩子需要使用DLL文件，在DLL中实现相应的钩子函数。

# 一. 全局钩子注入 #

首先介绍稍后用到的函数

### SetWindowsHookEX 函数 ###

//将程序定义的钩子函数安装到挂钩链中，安装钩子程序可以监视系统是否存在某些类型的事件，这些事件
    //和特定线程或调用线程所在的桌面所有线程相关联
    
    HHOOK WINAPI SetWindowsHookEX(
        _In_ int idHook, //要安装的钩子程序的类型
        _In_ HOOKPROC lpfn, //一个指向钩子程序的指针，如果dwThreadId=0或者指定不同进程创建线程，则
                            //lpfn必须指向DLL中的钩子过程，否则lpfn可以指向与当前进程关联的代码函数
        _In_ HINSANCE hMod, //包含由lpfn参数指向的函数的DLL句柄，如果是当前进程则hMod必须为NULL
        _In_ DWORD dwThreadId) //与钩子程序关联的线程标识符。如果为0，则与所有系统中的线程相关联
    
    //函数成功返回钩子函数的句柄
    //失败返回NULL

其中钩子类型（第一个参数idhook）分为以下几种：

[钩子类型][Link 1]

**全局钩子函数的代码需要在独立的DLL中，这样在一个进程执行时才可以加载这个DLL，并运行其中的钩子函数。这个加载DLL到特定进程的过程就是DLL注入**

**为了让DLL注入到所有进程中，设置WH\_GETMESSAGE监视消息队列。windows系统基于消息驱动，所以所有进程都有自己的一个消息队列，都会加载WH\_GETMESSAGE类型的全局钩子DLL**

设置全局钩子的代码：

//设置全局钩子
    BOOL SetGlobalHook() {
    	g_hHook = ::SetWindowsHookEx(WH_GETMESSAGE, (HOOKPROC)GetMsgProc, g_hDllModule, 0);
    	if (NULL == g_hHook) {
    		return FALSE;
    	}
    	return TRUE;
    }

回调函数代码

//回调函数代码
    LRESULT GetMsgProc(int code, WPARAM wParam, LPARAM lParam) {
    	return ::CallNextHookEx(g_hHook, code, wParam, lParam);
    }

其中回调函数的参数和返回值的数据类型时固定的。 callnexthookex表示把当前钩子传递给钩子链中的下一个钩子。

卸载钩子代码：

//卸载钩子
    BOOL UnsetGlobalHook() {
    	if (g_hHook) {
    		UnhookWindowsHookEx(g_hHook);
    	}
    	return TRUE;
    }

本程序中使用的方法是在DLL中创建一块共享内存由多个进程共用。具体的实现方法如下

//共享内存
    #pragma data_seg("mydata")
    HHOOK g_hHook = NULL;
    #pragma data_seg()
    #pragma comment(linker,"/SECTION:mydata,RWS")

使用data\_seg()创建数据段，然后通过设置连接器的RWS参数设置为 可读可写可共享的共享数据段。

## 实现： ##

### 1.创建DLL工程项目 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pZF9GYWtlcg_size_16_color_FFFFFF_t_70][]

新建项目中选择windows桌面项目向导，选择动态链接库dll

定义dll入口函数如下

// dllmain.cpp : 定义 DLL 应用程序的入口点。
    #include "mydll.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;
    }

点击生成之后在debug目录下生成dll文件

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pZF9GYWtlcg_size_16_color_FFFFFF_t_70 1][]

可以在其他程序中对dll进行加载调用

// Test.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include <Windows.h>
    
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	typedef BOOL(*typedef_SetGlobalHook)();
    	typedef BOOL(*typedef_UnsetGlobalHook)();
    	HMODULE hDll = NULL;
    	typedef_SetGlobalHook SetGlobalHook = NULL;
    	typedef_UnsetGlobalHook UnsetGlobalHook = NULL;
    	BOOL bRet = FALSE;
    
    	do
    	{
    		hDll = ::LoadLibrary("GlobalHook_Test.dll");
    		if (NULL == hDll)
    		{
    			printf("LoadLibrary Error[%d]\n", ::GetLastError());
    			break;
    		}
    		SetGlobalHook = (typedef_SetGlobalHook)::GetProcAddress(hDll, "SetGlobalHook");
    		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, "UnsetGlobalHook");
    		if (NULL == UnsetGlobalHook)
    		{
    			printf("GetProcAddress Error[%d]\n", ::GetLastError());
    			break;
    		}
    		UnsetGlobalHook();
    		printf("UnsetGlobalHook OK.\n");
    
    	}while(FALSE);
    
    	system("pause");
    	return 0;
    }

加载完毕发现再执行其他exe文件时，使用进程查看器发现加载模块里加载了之前生成的dll文件，说明dll注入成功。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pZF9GYWtlcg_size_16_color_FFFFFF_t_70 2][]

继续执行卸载钩子后发现相应的dll没有被加载，说明钩子卸载成功：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pZF9GYWtlcg_size_16_color_FFFFFF_t_70 3][]

# 二. 远线程注入 #

所谓远线程注入是指一个进程在另一个进程中创建线程的技术。

函数介绍：

### OpenProcess函数 ###

//打开现有的本地进程对象
    HANDLE WINAPI OpenProcess(
        _In_ DWORD dwDesiredAccess, //访问进程对象
        _In_ BOOL bInheritHandle,    //是否继承该进程的句柄
        _In_ DWORD dwProcessId)        //要打开的本地进程的PID

### VirtualAllocEx函数 ###

//在指定进程的虚拟地址空间内保留，提交或更改内存的状态
    LPVOID WINAPI VirtualAllocEx(
        _In_ HANDLE hProcess,  //过程句柄
        _In_opt_ LPVOID lpAddress,  //指定要分配页面所需的起始地址的指针
        _In_ SIZE_T dwSize，  //要分配的内存大小，以字节为单位
        _In_ DWORD flAllocationType,  //内存分配类型
        _In_ DWORD flProtect)  //要分配的页面区域的内存保护
    
    //如果成功，返回分配页面的基址
    //失败返回NULL

flAllocationType 可取下列值：

**MEM\_COMMIT：为特定的页面区域分配内存中或磁盘的[页面文件][Link 2]中的物理存储**

MEM\_PHYSICAL ：分配[物理内存][Link 3]（仅用于地址窗口[扩展内存][Link 4]）

MEM\_RESERVE：保留进程的虚拟地址空间，而不分配任何物理存储。保留页面可通过继续调用VirtualAlloc（）而被占用

MEM\_RESET ：指明在内存中由参数lpAddress和dwSize指定的数据无效

MEM\_TOP\_DOWN：在尽可能高的地址上分配内存（Windows 98忽略此标志）

MEM\_WRITE\_WATCH：必须与MEM\_RESERVE一起指定，使系统跟踪那些被写入分配区域的页面（仅针对Windows 98）

flProtect可取下列值：

PAGE\_READONLY： 该区域为只读。如果应用程序试图访问区域中的页的时候，将会被拒绝访

PAGE\_READWRITE 区域可被应用程序读写

PAGE\_EXECUTE： 区域包含可被系统执行的代码。试图读写该区域的操作将被拒绝。

PAGE\_EXECUTE\_READ ：区域包含可执行代码，应用程序可以读该区域。

PAGE\_EXECUTE\_READWRITE： 区域包含可执行代码，应用程序可以读写该区域。

PAGE\_GUARD： 区域第一次被访问时进入一个STATUS\_GUARD\_PAGE异常，这个标志要和其他保护标志合并使用，表明区域被第一次访问的权限

PAGE\_NOACCESS： 任何访问该区域的操作将被拒绝

PAGE\_NOCACHE： RAM中的页映射到该区域时将不会被微处理器缓存（cached)

### WriteProcessMemory 函数 ###

//在指定进程中将数据写入内存区域，整个区域必须可访问
    BOOL WINAPI WriteProcessMemory(
        _In_ HANDLE hProcess,  //要修改的进程内存的句柄
        _In_ LPVOID lpBaseAddress,  //指向指定进程中写入数据的基地址指针
        _In_ LPCVOID lpBuffer，  //指向缓冲区的指针，包含要写入指定进程地址空间的数据
        _In_ SIZE_T nSize,
        _In_ SIZE_T *lpNumberOfBytesWritten) //指向变量的指针
    //函数成功返回值不为零
    //失败返回值为零

### CreateRemoteThread 函数 ###

HANDLE WINAPI CreateRemoteThread(
        _In_ HANDLE hProcess,  //创建线程的进程句柄    
        _In_ LPSECURITY_ATTRIBUTES lpThreadAttributes, //指向安全属性的指针
        _In_ SIZE_T dwStackSize,  //堆栈的初始大小
        _In_ LPTHREAD_START_ROUTING lpStartAddress,  //指向远程进程中线程的起始地址
        _In_ LPVOID lpParameter,  //传递给线程函数的变量的指针
        _In_ DWORD dwCreationFlags,  //控制线程创建的标志，若为0，表示线程在创建后立即运行
        _Out_ LPDWORD lpThreadId)  //指向接收线程标识符的变量的指针
    
    //返回新线程句柄或者 NULL

**实现原理：**进程需要加载的自身原本需要的动态dll 使用的函数时LoadLibrary(lpFilename); 其中参数是要加载的dll 路径

而createRemoteThread函数需要指定多线程函数地址和多线程参数地址。因为loadLibrary函数是目标进程一定会执行的，并且把参数作为要加载的dll

所以在机器指令中相当与存在一条指令，从Loadlibrary函数入口地址开始运行，如果把这个函数地址作为要创建的多线程的地址，并把dll路径作为函数的参数，就可以利用loadLibrary加载相应的dll了

但是 windows使用基址随机化，所以每次开机系统DLL加载基址不一样，所以LoadLibrary函数基址不一样，但是有些系统DLL 要求开机之后地址是固定的，所以自己程序的LoadLibrary函数地址与其他

进程中的地址是相同的。

**代码实现 ：**

#include<Windows.h>
    #include<iostream>
    #include<tchar.h>
    using namespace std;
    //定义函数showError
    void ShowError(const char* content) {
    	cout << content << endl;
    }
    //使用CreateRemoteThread 实现远线程注入
    BOOL CreateRemoteThreadInjiectDll(DWORD dwProcessId, LPCWSTR pszDllFileName) {
    	HANDLE hProcess = NULL;
    	DWORD dwSize = 0;
    	LPVOID pDllAddr = NULL;
    	FARPROC pFuncProcAddr = NULL;
    	//打开注入进程，获取进程句柄
    	hProcess = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcessId);
    	if (NULL == hProcess) {
    		ShowError("OpenProcess");
    		return FALSE;
    	}
    	//再注入进程中申请内存
    	dwSize = 1 + ::lstrlen(pszDllFileName);
    	pDllAddr = ::VirtualAllocEx(hProcess, NULL, dwSize, MEM_COMMIT, PAGE_READWRITE);
    	if (NULL == pDllAddr) {
    		ShowError("VirtualAllocEX");
    		return FALSE;
    	}
    	//向申请的内存中写入数据
    	if (FALSE == ::WriteProcessMemory(hProcess, pDllAddr, pszDllFileName, dwSize, NULL)) {
    		ShowError("WriteProcessMemory");
    		return FALSE;
    	}
    	//获取LoadLibrary函数地址
    	pFuncProcAddr = ::GetProcAddress(::GetModuleHandle(_T("kernel32.dll")), "LoadLibraryA");
    	if (NULL == pFuncProcAddr) {
    		ShowError("GetProcAddress_LoadLibraryA");
    		return FALSE;
    	}
    	//使用CreateRemoteThread创建远线程，实现DLL注入
    	HANDLE hRemoteThread = ::CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)pFuncProcAddr,pDllAddr,0,NULL);
    	if (NULL == hRemoteThread) {
    		ShowError("CreateRemoteThread");
    		return FALSE;
    	}
    	//关闭句柄
    	::CloseHandle(hProcess);
    	return TRUE;
    }

下面来做一个测试，打算做一个打开电脑qq就自动弹出一个框，里面有文字内容，弹窗需要写成一个DLL模块供目标进程加载。

**1. 首先是根据程序名称“qq.exe”找到进程号**

**使用如下程序可以将QQ,exe的进程号给揪出来**

#include"inject.h"
    #include<tlhelp32.h>//声明快照bai函数的头文件
    #include<stdio.h>
    
    
    int main(int argc, char *argv[])
    {
    	DWORD QQid; //记录qq 的进程号
    
    	PROCESSENTRY32 pe32;
    	//在使用这个结构之前，先设置它的大小
    	pe32.dwSize = sizeof(pe32);
    	//给系统内的所有进程拍一个快照
    	HANDLE hProcessSnap = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    	//遍历进程快照，轮流显示每个进程的信息
    	BOOL bMore = ::Process32First(hProcessSnap, &pe32);
    	while (bMore)
    	{
    		char output[256];
    		const WCHAR* wc = pe32.szExeFile;
    		sprintf_s(output, "%ws", wc);
    		if (strcmp("QQ.exe", output) == 0)//如果找到进程名为abc.exe
    		{
    			
    			QQid = pe32.th32ProcessID;
    			break;
    			//HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pe32.th32ProcessID);//获取句柄
    			/*这里已经打开那个进程的句柄了*/
    		}
    		printf("next  %ls\n",pe32.szExeFile);
    	
    		
    		bMore = ::Process32Next(hProcessSnap, &pe32);//寻找下一个
    	}
    	// 远线程注入 DLL
    #ifndef _WIN64
    	BOOL bRet = CreateRemoteThreadInjectDll(QQid, "C:\\Users\\DemonGan\\Desktop\\CreateRemoteThread_Test\\Debug\\TestDll.dll");
    #else 
    	BOOL bRet = CreateRemoteThreadInjectDll(1144, "C:\\Users\\DemonGan\\Desktop\\CreateRemoteThread_Test\\x64\\Debug\\TestDll.dll");
    #endif
    
    	if (FALSE == bRet)
    	{
    		printf("Inject Dll Error.\n");
    	}
    	printf("Inject Dll OK.\n");
    	system("pause");
    	return 0;
    	return 0;
    }

**2. 把dll文件做好运行效果如图**

**下面是dll弹窗代码：**

// dllmain.cpp : 定义 DLL 应用程序的入口点。
    #include "stdafx.h"
    #include<tchar.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;
    		::MessageBox(NULL, _T("hhh."), _T("OK"), MB_OK);
    		break;
    	}
    	case DLL_THREAD_ATTACH:
    	case DLL_THREAD_DETACH:
    	case DLL_PROCESS_DETACH:
    		break;
    	}
    	return TRUE;
    }

突破sission 0 隔离：

在进行系统进程的注入时，会遇到一个叫session 0 的隔离机制，这时候需要使用更为底层的函数ZwCreateThreadEx来创建远线程，具体原理与CreateRemoteThread相同

# 三. APC注入 #

**apc是 asynchronous procedure call 异步程序调用。 在windows系统中，每一个线程有一个APC队列，把我们自己定义的apc函数压入到这个队列中就可以得到执行机会**

**函数介绍：**

### **QueueUserAPC 函数** ###

DWORD WINAPI QueueUserAPC(
        _In_ PAPCFUNC pfnAPC, //当指定线程执行可警告的等待操作时，指向应用程序提供的APC函数指针
        _In_ HANDLE hThread,  //线程句柄，该句柄必须有THREAD_SET_CONTEXT访问权限
        _In_ ULONG_PTR dwData) //传递有pfnAPC参数指向的APC函数的单个值

函数实现：

#include"inject.h"
    
    //定义函数showError
    void ShowError(const char* content) {
    	printf("%s\n", content);
    }
    //使用CreateRemoteThread 实现远线程注入
    BOOL CreateRemoteThreadInjiectDll(DWORD dwProcessId, LPCWSTR pszDllFileName) {
    	HANDLE hProcess = NULL;
    	DWORD dwSize = 0;
    	LPVOID pDllAddr = NULL;
    	FARPROC pFuncProcAddr = NULL;
    	//打开注入进程，获取进程句柄
    	hProcess = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcessId);
    	if (NULL == hProcess) {
    		ShowError("OpenProcess");
    		return FALSE;
    	}
    	
    	//再注入进程中申请内存
    	dwSize = 1 + ::lstrlen(pszDllFileName);
    	pDllAddr = ::VirtualAllocEx(hProcess, NULL, dwSize, MEM_COMMIT, PAGE_READWRITE);
    	if (NULL == pDllAddr) {
    		ShowError("VirtualAllocEX");
    		return FALSE;
    	}
    	//向申请的内存中写入数据
    	if (FALSE == ::WriteProcessMemory(hProcess, pDllAddr, pszDllFileName, dwSize, NULL)) {
    		ShowError("WriteProcessMemory");
    		return FALSE;
    	}
    	//获取LoadLibrary函数地址
    	pFuncProcAddr = ::GetProcAddress(::GetModuleHandle(_T("kernel32.dll")), "LoadLibraryA");
    	if (NULL == pFuncProcAddr) {
    		ShowError("GetProcAddress_LoadLibraryA");
    		return FALSE;
    	}
    	//使用CreateRemoteThread创建远线程，实现DLL注入
    	HANDLE hRemoteThread = ::CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)pFuncProcAddr,pDllAddr,0,NULL);
    	if (NULL == hRemoteThread) {
    		ShowError("CreateRemoteThread");
    		return FALSE;
    	}
    	//关闭句柄
    	::CloseHandle(hProcess);
    	return TRUE;
    }
    // 根据进程名称获取PID
    DWORD GetProcessIdByProcessName(LPCWSTR pszProcessName)
    {
    	DWORD dwProcessId = 0;
    	PROCESSENTRY32 pe32 = { 0 };
    	HANDLE hSnapshot = NULL;
    	BOOL bRet = FALSE;
    	::RtlZeroMemory(&pe32, sizeof(pe32));
    	pe32.dwSize = sizeof(pe32);
    
    	// 获取进程快照
    	hSnapshot = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    	if (NULL == hSnapshot)
    	{
    		ShowError("CreateToolhelp32Snapshot");
    		return dwProcessId;
    	}
    
    	// 获取第一条进程快照信息
    	bRet = ::Process32First(hSnapshot, &pe32);
    	while (bRet)
    	{
    		// 获取快照信息
    		if (0 == ::lstrcmpi(pe32.szExeFile, pszProcessName))
    		{
    			dwProcessId = pe32.th32ProcessID;
    			break;
    		}
    
    		// 遍历下一个进程快照信息
    		bRet = ::Process32Next(hSnapshot, &pe32);
    	}
    
    	return dwProcessId;
    }
    
    // 根据PID获取所有的相应线程ID
    BOOL GetAllThreadIdByProcessId(DWORD dwProcessId, DWORD **ppThreadId, DWORD *pdwThreadIdLength)
    {
    	DWORD *pThreadId = NULL;
    	DWORD dwThreadIdLength = 0;
    	DWORD dwBufferLength = 1000;
    	THREADENTRY32 te32 = { 0 };
    	HANDLE hSnapshot = NULL;
    	BOOL bRet = TRUE;
    
    	do
    	{
    		// 申请内存
    		pThreadId = new DWORD[dwBufferLength];
    		if (NULL == pThreadId)
    		{
    			ShowError("new");
    			bRet = FALSE;
    			break;
    		}
    		::RtlZeroMemory(pThreadId, (dwBufferLength * sizeof(DWORD)));
    
    		// 获取线程快照
    		::RtlZeroMemory(&te32, sizeof(te32));
    		te32.dwSize = sizeof(te32);
    		hSnapshot = ::CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
    		if (NULL == hSnapshot)
    		{
    			ShowError("CreateToolhelp32Snapshot");
    			bRet = FALSE;
    			break;
    		}
    
    		// 获取第一条线程快照信息
    		bRet = ::Thread32First(hSnapshot, &te32);
    		while (bRet)
    		{
    			// 获取进程对应的线程ID
    			if (te32.th32OwnerProcessID == dwProcessId)
    			{
    				pThreadId[dwThreadIdLength] = te32.th32ThreadID;
    				dwThreadIdLength++;
    			}
    
    			// 遍历下一个线程快照信息
    			bRet = ::Thread32Next(hSnapshot, &te32);
    		}
    
    		// 返回
    		*ppThreadId = pThreadId;
    		*pdwThreadIdLength = dwThreadIdLength;
    		bRet = TRUE;
    
    	} while (FALSE);
    
    	if (FALSE == bRet)
    	{
    		if (pThreadId)
    		{
    			delete[]pThreadId;
    			pThreadId = NULL;
    		}
    	}
    
    	return bRet;
    }
    
    //APC 注入
    BOOL ApcInjectDll(LPCTSTR pszProcessName, LPCTSTR pszDLLName) {
    	BOOL bRet = FALSE;
    	DWORD dwProcessId = 0;
    	DWORD *pThreadId = NULL;
    	DWORD dwThreadIdLength = 0;
    
    	HANDLE hProcess = NULL, hThread = NULL;
    	PVOID pBaseAddress = NULL;
    	PVOID pLoadLibraryAFunc = NULL;
    	SIZE_T dwRet = 0, dwDllPathLen = 1 + ::lstrlen(pszDLLName);
    	DWORD i = 0;
    	do {
    		//根据进程名获取pid
    		dwProcessId = GetProcessIdByProcessName(pszProcessName);
    		if (0 >= dwProcessId) {
    			//获取出错了
    			bRet = FALSE;
    			break;
    		}
    		//根据PID获取所有相应的线程ID
    		bRet = GetAllThreadIdByProcessId(dwProcessId, &pThreadId, &dwThreadIdLength);
    		if (FALSE == bRet) {
    			bRet = false;
    			break;
    		}
    
    		//打开注入进程
    		hProcess = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcessId);
    		if (NULL == hProcess) {
    			ShowError("OpenProcess");
    			bRet = FALSE;
    			break;
    		}
    
    		//在注入进程空间中申请内存
    		pBaseAddress = ::VirtualAllocEx(hProcess, NULL, dwDllPathLen, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    		if (NULL == pBaseAddress) {
    			ShowError("virtualAllocEX");
    			bRet = FALSE;
    			break;
    		}
    		//向申请的空间中写入DLL 路径数据
    		::WriteProcessMemory(hProcess, pBaseAddress, pszDLLName, dwDllPathLen, &dwRet);
    		if (dwRet != dwDllPathLen) {
    			ShowError("WriteProcessMemory");
    			bRet = FALSE;
    			break;
    		}
    		//获取loadlibrarya地址
    		pLoadLibraryAFunc = ::GetProcAddress(::GetModuleHandle(L"kernel32.dll"), "LoadLibraryA");
    		if (NULL == pLoadLibraryAFunc) {
    			ShowError("GetProcessAddress");
    			bRet = FALSE;
    			break;
    		}
    
    		//遍历线程，插入APC
    		for (i = 0; i < dwThreadIdLength; i++) {
    			//打开线程
    			hThread = ::OpenThread(THREAD_ALL_ACCESS, FALSE, pThreadId[i]);
    			if (hThread) {
    				//打开成功
    				//插入APC 
    				::QueueUserAPC((PAPCFUNC)pLoadLibraryAFunc, hThread, (ULONG_PTR)pBaseAddress);
    				//关闭线程句柄
    				::CloseHandle(hThread);
    				hThread = NULL;
    			}
    		}
    		bRet = TRUE;
    	} while (FALSE);
    	//释放内存
    	if (hProcess)
    	{
    		::CloseHandle(hProcess);
    		hProcess = NULL;
    	}
    	if (pThreadId)
    	{
    		delete[]pThreadId;
    		pThreadId = NULL;
    	}
    
    	return bRet;
    }

[Link 1]: https://blog.csdn.net/mid_Faker/article/details/112569461
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pZF9GYWtlcg_size_16_color_FFFFFF_t_70]: /images/20221119/b2e287ea055541a3aaba36580020854b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pZF9GYWtlcg_size_16_color_FFFFFF_t_70 1]: /images/20221119/e585ebdbceeb4cc8b9c8fb2d4ea10ef5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pZF9GYWtlcg_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210113174634145.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pZF9GYWtlcg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pZF9GYWtlcg_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20210113174838673.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pZF9GYWtlcg==,size_16,color_FFFFFF,t_70
[Link 2]: https://baike.baidu.com/item/%E9%A1%B5%E9%9D%A2%E6%96%87%E4%BB%B6
[Link 3]: https://baike.baidu.com/item/%E7%89%A9%E7%90%86%E5%86%85%E5%AD%98
[Link 4]: https://baike.baidu.com/item/%E6%89%A9%E5%B1%95%E5%86%85%E5%AD%98