<think>
APC注入（Asynchronous Procedure Call Injection）是一种将代码注入到目标进程并执行的技术。它利用Windows提供的异步过程调用（
APC）机制，将注入的代码作为
APC对象加入到目标线程的
APC队列中。当目标线程进入可警告状态（alertable state）时，就会执行
APC队列中的函数。
实现步骤：
1. 打开目标进程，获取进程句柄。
2. 在目标进程中分配内存，用于存放注入的代码（通常是DLL路径或者shellcode）。
3. 将注入的代码写入目标进程的内存中。
4. 枚举目标进程的所有线程，选择目标线程（通常选择主线程）。
5. 将
APC函数（这里使用`LoadLibraryA`或`LoadLibraryW`）的地址和参数（即DLL路径的地址）加入到目标线程的
APC队列中。
6. 当目标线程进入可警告状态时，就会执行`LoadLibrary`，从而加载我们注入的DLL。
注意：如果目标线程长时间不进入可警告状态，我们可以使用`QueueUser
APC`函数强制线程进入可警告状态（例如通过`SleepEx`或`WaitForSingleObjectEx`等函数）。
下面是
一个简单的
APC注入类的实现，该类将指定的DLL注入到目标进程中。
```cpp
#include <Windows.h>
#include <TlHelp32.h>
#include <string>
#include <vector>
class C
APCInjector {
public:
// 构造函数，传入目标进程ID
C
APCInjector(DWORD dwProcessId) : m_dwProcessId(dwProcessId), m_hProcess(NULL) {}
// 析构函数，关闭句柄
~C
APCInjector() {
if (m_hProcess != NULL) {
CloseHandle(m_hProcess);
}
}
// 打开目标进程
BOOL OpenTargetProcess() {
m_hProcess = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_WRITE | PROCESS_QUERY_INFORMATION, FALSE, m_dwProcessId);
return (m_hProcess != NULL);
}
// 注入DLL
BOOL InjectDLL(const std::string& dllPath) {
// 在目标进程中分配内存
LPVOID pRemoteAddress = VirtualAllocEx(m_hProcess, NULL, dllPath.length() + 1, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (pRemoteAddress == NULL) {
return FALSE;
}
// 将DLL路径写入目标进程
SIZE_T written = 0;
if (!WriteProcessMemory(m_hProcess, pRemoteAddress, dllPath.c_str(), dllPath.length() + 1, &written) || written != dllPath.length() + 1) {
VirtualFreeEx(m_hProcess, pRemoteAddress, 0, MEM_RELEASE);
return FALSE;
}
// 获取LoadLibraryA函数的地址（在kernel32.dll中，所有进程的地址相同）
LPTHREAD_START_ROUTINE pLoadLibrary = (LPTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandleA("kernel32.dll"), "LoadLibraryA");
if (pLoadLibrary == NULL) {
VirtualFreeEx(m_hProcess, pRemoteAddress, 0, MEM_RELEASE);
return FALSE;
}
// 枚举目标进程的所有线程
std::vector<DWORD> threadIds;
if (!GetThreadList(m_dwProcessId, threadIds)) {
VirtualFreeEx(m_hProcess, pRemoteAddress, 0, MEM_RELEASE);
return FALSE;
}
// 对每个线程尝试加入
APC
BOOL bSuccess = FALSE;
for (DWORD tid : threadIds) {
HANDLE hThread = OpenThread(THREAD_SET_CONTEXT, FALSE, tid);
if (hThread != NULL) {
// 将
APC加入队列
if (QueueUser
APC((P
APCFUNC)pLoadLibrary, hThread, (ULONG_PTR)pRemoteAddress)) {
bSuccess = TRUE;
}
CloseHandle(hThread);
}
}
// 注意：这里不释放分配的内存，因为
APC执行后，LoadLibrary会使用该内存，需要目标进程自己释放（或者后续处理）
// 如果注入失败，释放内存
if (!bSuccess) {
VirtualFreeEx(m_hProcess, pRemoteAddress, 0, MEM_RELEASE);
}
return bSuccess;
}
private:
// 获取目标进程的线程列表
BOOL GetThreadList(DWORD dwOwnerPID, std::vector<DWORD>& threadIds) {
threadIds.clear();
HANDLE hThreadSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
if (hThreadSnap == INVALID_HANDLE_VALUE) {
return FALSE;
}
THREADENTRY32 te32;
te32.dwSize = sizeof(THREADENTRY32);
if (!Thread32First(hThreadSnap, &te32)) {
CloseHandle(hThreadSnap);
return FALSE;
}
do {
if (te32.th32OwnerProcessID == dwOwnerPID) {
threadIds.push_back(te32.th32ThreadID);
}
} while (Thread32Next(hThreadSnap, &te32));
CloseHandle(hThreadSnap);
return !threadIds.empty();
}
private:
DWORD m_dwProcessId;
HANDLE m_hProcess;
};
```
使用示例：
```cpp
int main() {
DWORD pid = 1234; // 目标进程ID
C
APCInjector injector(pid);
if (injector.OpenTargetProcess()) {
if (injector.InjectDLL("C:\\Path\\To\\Your\\DLL.dll")) {
printf("Inject success!\n");
} else {
printf("Inject failed!\n");
}
} else {
printf("Open process failed!\n");
}
return 0;
}
```
注意事项：
1. 需要确保目标进程中的线程会进入可警告状态，否则
APC不会被执行。有时可能需要等待或触发目标线程进入可警告状态。
2. 注入的DLL路径长度不能太长，否则分配内存可能失败。
3. 如果目标进程是64位，而注入器是32位（或反之），则需要注意跨体系结构的问题。通常，注入器进程的位数应与目标进程相同。
4. 由于向多个线程插入了
APC，所以同
一个DLL可能会被多次加载。如果希望只加载一次，需要额外的处理（例如只选择
一个线程）。
5. 在注入后，分配的内存（存放DLL路径）不会被释放，因为注入的DLL加载后，可能会在DLL_PROCESS_DETACH中释放，或者由目标进程的其他机制释放。但如果不释放，会造成内存泄漏。因此，可以在DLL的入口函数（DllMain）中，当DLL被加载后，释放这块内存（需要将地址传递给DLL，例如通过创建远程线程传递地址，然后释放）。但
APC注入中，由于是异步执行，很难在注入器中释放，因此通常由目标进程的LoadLibrary执行后，在DLL中释放。但这样需要DLL配合，不太通用。另一种做法是，注入后等待一段时间，然后注入器释放内存，但这样有风险，因为可能
APC还未执行。
相关问题：
1.
APC注入和远程线程注入有什么区别？
2. 什么是可警告状态？哪些函数可以使线程进入可警告状态？
3. 在
APC注入中，如果目标线程长时间不进入可警告状态，有什么办法可以解决？
4. 如何避免同
一个DLL被多次加载？
注意：上述代码仅用于学习和研究目的，请勿用于非法用途。</think>###
APC注入类实现
APC注入（Asynchronous Procedure Call Injection）是一种利用Windows异步过程调用机制将代码注入目标进程的技术。以下是完整的C++实现：
```cpp
#include <Windows.h>
#include <TlHelp32.h>
#include <string>
#include <vector>
class
APCInjector {
public:
APCInjector(DWORD pid) : m_targetPid(pid), m_hProcess(nullptr) {}
~
APCInjector() {
if (m_hProcess) CloseHandle(m_hProcess);
}
// 打开目标进程
bool OpenTarget() {
m_hProcess = OpenProcess(
PROCESS_VM_OPERATION | PROCESS_VM_WRITE | PROCESS_QUERY_INFORMATION,
FALSE,
m_targetPid
);
return m_hProcess != nullptr;
}
// 执行DLL注入
bool InjectDLL(const std::wstring& dllPath) {
// 1. 在目标进程分配内存
SIZE_T memSize = (dllPath.size() + 1) * sizeof(wchar_t);
LPVOID remoteMem = VirtualAllocEx(
m_hProcess,
nullptr,
memSize,
MEM_COMMIT | MEM_RESERVE,
PAGE_READWRITE
);
if (!remoteMem) return false;
// 2. 写入DLL路径
SIZE_T bytesWritten;
if (!WriteProcessMemory(
m_hProcess,
remoteMem,
dllPath.c_str(),
memSize,
&bytesWritten
)) {
VirtualFreeEx(m_hProcess, remoteMem, 0, MEM_RELEASE);
return false;
}
// 3. 获取LoadLibrary地址
LPTHREAD_START_ROUTINE pLoadLibrary = reinterpret_cast<LPTHREAD_START_ROUTINE>(
GetProcAddress(GetModuleHandleW(L"kernel32.dll"), "LoadLibraryW")
);
if (!pLoadLibrary) return false;
// 4. 枚举线程并添加
APC
bool injectionSuccess = false;
std::vector<DWORD> threadIds = GetThreadIds(m_targetPid);
for (DWORD tid : threadIds) {
HANDLE hThread = OpenThread(THREAD_SET_CONTEXT | THREAD_SUSPEND_RESUME, FALSE, tid);
if (hThread) {
// 挂起线程确保执行环境稳定
if (SuspendThread(hThread) != (DWORD)-1) {
// 添加
APC到队列
if (QueueUser
APC(
reinterpret_cast<P
APCFUNC>(pLoadLibrary),
hThread,
reinterpret_cast<ULONG_PTR>(remoteMem)
)) {
injectionSuccess = true;
}
ResumeThread(hThread);
}
CloseHandle(hThread);
}
}
// 5. 清理资源
if (!injectionSuccess) {
VirtualFreeEx(m_hProcess, remoteMem, 0, MEM_RELEASE);
}
return injectionSuccess;
}
private:
// 获取进程的所有线程ID
std::vector<DWORD> GetThreadIds(DWORD pid) {
std::vector<DWORD> tids;
HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
if (hSnapshot == INVALID_HANDLE_VALUE)
return tids;
THREADENTRY32 te32 = { sizeof(THREADENTRY32) };
if (Thread32First(hSnapshot, &te32)) {
do {
if (te32.th32OwnerProcessID == pid) {
tids.push_back(te32.th32ThreadID);
}
} while (Thread32Next(hSnapshot, &te32));
}
CloseHandle(hSnapshot);
return tids;
}
DWORD m_targetPid;
HANDLE m_hProcess;
};
// 使用示例
int main() {
DWORD targetPid = 1234; // 替换为目标进程ID
APCInjector injector(targetPid);
if (!injector.OpenTarget()) {
// 处理错误
return 1;
}
if (injector.InjectDLL(L"C:\\Path\\To\\Your\\DLL.dll")) {
// 注入成功
} else {
// 注入失败
}
return 0;
}
```
### 实现原理详解
1. **
APC机制基础**：
-
APC是异步过程调用(Asynchronous Procedure Call)的缩写
- 每个线程都有
APC队列，当线程进入可警告状态(alertable state)时执行队列中的
APC
- 使用`QueueUser
APC()`将函数指针加入目标线程的
APC队列
2. **注入流程**：
- **打开目标进程**：获取PROCESS_VM_OPERATION等权限
- **分配远程内存**：使用`VirtualAllocEx`在目标进程分配可写内存
- **写入DLL路径**：将Unicode格式的DLL路径写入目标进程
- **获取LoadLibrary地址**：kernel32.dll在所有进程中的加载地址相同
- **枚举目标线程**：获取目标进程的所有线程ID
- **挂起并注入**：挂起线程→添加
APC→恢复线程
3. **关键API**：
- `OpenProcess`：获取目标进程句柄
- `VirtualAllocEx`：在远程进程分配内存
- `WriteProcessMemory`：向远程进程写入数据
- `QueueUser
APC`：添加
APC到线程队列
- `CreateToolhelp32Snapshot`：获取系统线程快照
4. **注意事项**：
- 需要目标线程进入可警告状态（如调用SleepEx）
- 64/32位进程需匹配（不能跨架构注入）
- 防病毒软件可能拦截此类操作
- 注入失败需清理已分配内存
- 实际使用中需考虑线程同步问题
### 相关问题
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
