lacuna-rs

Suplantación de pila de llamadas de fotogramas fantasma + llamadas al sistema indirectas en tiempo de ejecución para Windows x64 — portado a Rust.

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

lacuna-rs es una crate Rust reutilizable que proporciona las mismas primitivas que el TTP original en C, estructurada para que pueda integrarse en cualquier proyecto Rust — como wsyscall-rs o syscalls-rs, pero con resolución de SSN en tiempo de ejecución, direccionamiento syscall;ret por función y suplantación de pila de fotogramas fantasma.

Crítico: Requisito del puntero de marco

La característica stack-spoof fallará silenciosamente si la crate consumidora no se compila con punteros de marco.

Las primitivas de pisoteo de pila en chain.rs localizan la ranura de dirección de retorno de la persona que llama mediante mov rbp, {x} en ensamblador en línea. Esto requiere que la cadena RBP esté intacta. Rust (y la mayoría de los compiladores en modo release) omiten los punteros de marco por defecto.

build.rs establece force-frame-pointers=yes para la generación de código de esta propia crate, pero Cargo no puede propagar banderas del compilador a crates descendentes. Debes agregar esto a tu propio proyecto:

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

Sin esto, stomp_plant() leerá basura de RBP y no hará nada (mejor caso) o corromperá la pila (peor caso). La crate no tiene forma de detectar en tiempo de ejecución si los punteros de marco están habilitados — simplemente no funcionará.

Si solo necesitas las primitivas de escaneo, resolución de SSN o inyección (sin suplantación de pila), puedes omitir la característica stack-spoof y este requisito no aplica.

Qué hace

Banderas de características

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

Cuando no hay características habilitadas, solo están disponibles las capas de escaneo/PE/NT.

Inicio rápido

Escanear regiones fantasma

cargo run --example scan

Construir + verificar la cadena de fotogramas fantasma

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

Inyectar shellcode mediante sección + APC

Ejemplo de inyección con implante real - C2 estaba desconectado pero el Shellcode se ejecutó

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

Agrega --verbose para habilitar la salida de diagnóstico de VEH (volcados de pila, impresiones de registros):

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

Algoritmo de puntuación de hilos

En lugar de encolar APC a todos los hilos del proceso objetivo (lo que puede bloquear el proceso cuando demasiados hilos son alertados simultáneamente), inject_sapc utiliza un algoritmo de puntuación para seleccionar los mejores MAX_APC_THREADS (5) candidatos:

• Tiempo de ciclo — NtQueryInformationThread(ThreadCycleTime) — indicador principal de actividad
• Tiempo de CPU — NtQueryInformationThread(ThreadTimes) — tiempo de kernel + usuario
• Contador de suspensión — NtQueryInformationThread(ThreadSuspendCount) — los hilos no suspendidos reciben +300 de bonificación; los suspendidos obtienen -150 por cada suspensión
• Prioridad — NtQueryInformationThread(ThreadBasicInformation) — los hilos con prioridad 8-10 reciben +150 de bonificación; las prioridades fuera de rango reciben -100 de penalización

Los hilos completamente inactivos (cero ciclos y cero tiempo de CPU) se omiten por completo. Los candidatos restantes se ordenan por puntuación (mayor primero, desempate por ciclos) y se truncan a los 5 primeros.

Uso como biblioteca

Básico: escaneo + resolución de SSN

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

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

// Escanear regiones fantasma
let mut ghosts = [scan::Ghost::default(); 512];
let n = scan::scan_ghosts(ntdll, &[b"NtAllocateVirtualMemory\0"], &mut ghosts);
println!("{} regiones fantasma en ntdll", n);

// Resolver SSN + syscall;ret para una función específica
let (ssn, syscall_ret) = nt::resolve(ntdll, b"NtOpenProcess\0");
println!("NtOpenProcess: ssn={:#x}, syscall;ret={:#x}", ssn, syscall_ret);

Emitir un stub de syscall indirecto para cualquier API de NT

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

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

// Resolver SSN + la dirección syscall;ret de la propia función
let (ssn, syscall_ret) = nt::resolve(ntdll, b"NtAllocateVirtualMemory\0");
assert!(ssn != nt::SSN_INVALID && syscall_ret != 0);

// Emitir JIT un stub: mov r10,rcx; mov eax,SSN; jmp [syscall;ret]
// (o jmp [ghost_gadget] -> JMP [RBX] -> syscall;ret si se llamó a build_chain)
let stub = stub::make_stub(ssn, syscall_ret).expect("falló la asignación del stub");

// Convertir al tipo de puntero de función correspondiente y llamar
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 la cadena de fotogramas fantasma + registrar VEH

// Escanear ntdll/kernelbase/wow64/win32u en busca de regiones fantasma y construir
// la pila de llamadas falsa de seis capas. Establece G_GHOST_GADGET para que los stubs
// direccionen a través de JMP [RBX] en una DLL firmada.
lacuna::chain::build_chain();

// Registrar manejadores VEH (cifrado de parámetros + guardián de cadena)
let _veh = lacuna::veh::VehGuard::register().expect("Falló el registro de VEH");

// Opcional: habilitar diagnóstico detallado en tiempo de ejecución
lacuna::veh::set_verbose(true);

Envolver una syscall sensible con suplantación de pila + cifrado de parámetros

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

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

// Plantar fotogramas fantasma (reemplaza las direcciones de retorno con fantasmas de DLL firmada)
lacuna::chain::stomp_plant();

// Armar DR0 en syscall;ret — VEH descifrará XOR los parámetros en el límite
lacuna::veh::pcrypt_arm(key, syscall_ret, true);

// Llamar a través del stub indirecto — RIP aterriza dentro de ntdll en la entrada del kernel
let _status = unsafe { open_proc(/* parámetros cifrados con XOR */) };

// Siempre desarmar antes de cualquier llamada no protegida
lacuna::veh::pcrypt_disarm();
lacuna::chain::stomp_restore();

OPSEC: Qué ocultar detrás de los fotogramas fantasma

No toda llamada a la API necesita el tratamiento completo de LACUNA. El principio clave es: ocultar las llamadas que un EDR correlacionaría como actividad de inyección o post-explotación.

Deben estar detrás de syscalls indirectos + fotogramas fantasma + cifrado de parámetros

Estas son las syscalls NT "joya de la corona" que los EDR enganchan y correlacionan:

Para cada una de estas:

1. Resolver con nt::resolve(ntdll, b"NtXxx\0")
2. Emitir un stub con stub::make_stub(ssn, syscall_ret)
3. Cifrar con XOR los parámetros sensibles con veh::pcrypt_arm(key, syscall_ret, true)
4. Envolver la llamada entre chain::stomp_plant() y chain::stomp_restore()

Pueden ser directas (sin necesidad de fotogramas fantasma)

Principios clave

1. Resolver cualquier syscall de NT con nt::resolve(ntdll, b"NtXxx\0") — devuelve (SSN, syscall_ret_VA).
2. Emitir un stub JIT con stub::make_stub(ssn, syscall_ret) — devuelve un puntero de función invocable.
3. Convertir el stub al tipo extern "system" fn(...) apropiado mediante core::mem::transmute.
4. (Solo para llamadas sensibles) Construir la cadena de fotogramas fantasma con chain::build_chain() y llamar a chain::stomp_plant() / chain::stomp_restore() alrededor de la llamada.
5. (Solo para llamadas sensibles) Armar el cifrado de parámetros con veh::pcrypt_arm(key, syscall_ret, true) antes de la llamada, y veh::pcrypt_disarm() después.
6. Siempre desarmar el VEH antes de hacer llamadas no protegidas — un golpe de DR0 accidental en una syscall desarmada bloqueará el proceso.

El stub maneja automáticamente la secuencia mov r10, rcx / mov eax, SSN / jmp [syscall;ret]. Si se registró un gadget fantasma, el stub direcciona a través de JMP [RBX] para redirección de ejecución de doble uso + marco puente sin artefactos.

Cobertura de verificación del artículo técnico

Las 9 contribuciones clave del artículo técnico de LACUNA Chain están representadas en el código:

Cobertura de superficie de detección

¿Por qué no usar simplemente syscalls-rs?

syscalls-rs y wsyscall-rs generan una tabla de SSN en tiempo de compilación a partir de la ntdll de una versión específica de Windows. Si la máquina objetivo ejecuta una versión diferente, los SSN son incorrectos y las syscalls fallan (o activan heurísticas de EDR).

lacuna-rs resuelve los SSN en tiempo de ejecución leyendo directamente los stubs de ntdll, y apunta a la instrucción syscall;ret de la propia función de modo que RIP está dentro de ntdll en la entrada del kernel — derrotando las heurísticas de "desajuste de SSN" y "syscall indirecto desde memoria no respaldada" de los EDR.

Además, lacuna-rs proporciona la cadena de suplantación de pila de fotogramas fantasma que syscalls-rs no ofrece.

Requisitos de compilación

• Objetivo: x86_64-pc-windows-msvc (o x86_64-pc-windows-gnu)
• Edición de Rust: 2021
• Dependencias: litcrypt2 (ofuscación de cadenas en tiempo de compilación)

Configuración de puntero de marco (solo para stack-spoof)

La característica stack-spoof requiere punteros de marco. build.rs establece force-frame-pointers=yes automáticamente para esta crate, pero las crates consumidoras también deben configurarlo en su .cargo/config.toml:

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

Ofuscación de cadenas con litcrypt2

Todos los literales de cadena en la crate y los ejemplos están envueltos en macros lc!(), que los cifran en tiempo de compilación y los descifran en tiempo de ejecución. La clave de cifrado se lee de la variable de entorno LITCRYPT_ENCRYPT_KEY; si no está configurada, litcrypt2 genera automáticamente una clave aleatoria.

Para fijar una clave para compilaciones reproducibles:

set LITCRYPT_ENCRYPT_KEY=tu-clave-secreta
cargo build

Arquitectura

lacuna-rs/
├── Cargo.toml
├── build.rs              # Establece force-frame-pointers para stack-spoof
├── src/
│   ├── lib.rs            # Raíz de la crate + reexportaciones + scan_all() + configuración de litcrypt2
│   ├── win.rs            # Enlaces FFI de Win32/NT (compatible con no_std)
│   ├── pe.rs             # Análisis de secciones PE + exportaciones
│   ├── scan.rs           # Escaneo de regiones fantasma .pdata + gadgets
│   ├── nt.rs             # Resolución de SSN + direccionamiento syscall;ret
│   ├── stub.rs           # Emisión de stub de syscall indirecto JIT
│   ├── veh.rs            # Cifrado de parámetros con VEH + breakpoint hardware
│   ├── chain.rs          # Cadena de fotogramas fantasma LACUNA + pisoteo
│   └── inject.rs         # Inyección APC basada en secciones
├── 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 + objetivo windows-msvc

Créditos

• Investigación original e implementación en C: Mohamed Alzhrani (0xmaz) — LACUNA Chain
• Técnica: Ghost Frames: Forging Plausible Call Stacks from .pdata Lacunae
• Lógica de búsqueda del mejor hilo APC: Adaptada de FrankensteinAPCInjection por S12cybersecurity
• Ofuscación de cadenas: litcrypt2 v0.1.3

Divulgación completa

Este proyecto fue asistido activamente por un chatbot de IA. Tuve la oportunidad de probar un modelo de Código Abierto más nuevo y muy capaz (GLM-5.2 de Z.ai (Zhipu AI)) y quería darle una tarea desafiante. Lecciones aprendidas: Funcionó bien si el humano sabe cómo deben ser los resultados. Si no... solo basura.

Licencia

MIT