SindriKit

Lo sviluppo offensivo merita un'architettura migliore.
Una libreria C per costruire capacità offensive.

Concetto Principale

La maggior parte degli strumenti offensivi codifica duramente i propri meccanismi di esecuzione all'interno della logica della tecnica. Un loader riflessivo non si limita a mappare un'immagine; la mappa usando una specifica catena hardcoded di chiamate VirtualAlloc o NTAPI native. Quando un EDR inizia a monitorare quella specifica catena, sei costretto a riscrivere l'intero strumento.

SindriKit risolve questo problema imponendo una separazione delle responsabilità tramite tabelle di astrazione delle interfacce:

1. La Logica della Tecnica: (es., loader, injection, patcher) si occupa del tracciamento dello stato e dell'orchestrazione dei dati. Non ha alcuna conoscenza di come la memoria viene allocata o di come i thread vengono creati.
2. I Meccanismi di Esecuzione: (es., API Win32, NTAPI native, Syscall Dirette) sono contenuti in tabelle API indipendenti e iniettati nella tecnica a runtime.

Spostando i meccanismi di esecuzione su function pointer runtime, puoi cambiare l'intera strategia dalle chiamate Win32 a syscall dirette con una singola riga di codice — senza modificare la logica di esecuzione del payload.

Architettura di Progetto

• Profili di Esecuzione Disaccoppiati: Scambia i comportamenti sottostanti di manipolazione di memoria, moduli e thread tramite tabelle di function pointer senza rompere la tecnica chiamante.
• Fallback a Cascata per le Syscall: Resolver SSN pluggabili (snd_syscall_resolve_ssn_scan, snd_syscall_resolve_ssn_sort) con una catena di priorità — scambia o estendi le strategie senza toccare il codice di dominio.
• Obfuscation in Fase di Compilazione: Gli algoritmi di hashing di stringhe e API (DJB2, FNV1A) possono essere cambiati globalmente tramite CMake. La compilazione randomizza automaticamente il seed globale per alterare le firme statiche.
• Motore di Mutazione: Abilita un polimorfismo profondo tramite SND_MORPH. Genera firme binarie uniche a ogni build iniettando predicati opachi volatili nel codice C, NOP/matematica funzionalmente equivalenti negli stub Assembly e rimescolando il layout in memoria delle struct principali.
• Build di Rilascio: Un livello silenzioso rimuove tutte le stringhe diagnostiche, i descrittori di file e i frame di tracciamento dal binario finale, riducendo la tua impronta statica a primitivi essenziali.

Integrare SindriKit

cmake_minimum_required(VERSION 3.16)
project(MyTool C ASM_MASM)

set(SND_BUILD_PAYLOADS  OFF    CACHE BOOL   "")
set(SND_ENABLE_DEBUG    OFF    CACHE BOOL   "")
set(SND_HASH_ALGO      "DJB2"  CACHE STRING "")
set(SND_RANDOMIZE_SEED  ON     CACHE BOOL   "")
set(SND_MORPH           ON     CACHE BOOL   "")

add_subdirectory(libs/SindriKit)

add_executable(my_tool src/main.c)
target_link_libraries(my_tool PRIVATE sindri::engine)

cmake -B build && cmake --build build --config Release

Solo due righe e il tuo strumento eredita tutte le capacità di SindriKit: parsing PE, risoluzione syscall, caricamento riflessivo...

Il Motore

Livello di Astrazione API

        ┌────────────────────────────────────────────────────────────────────────────┐
        │                          QUALSIASI INTENTO OFFENSIVO                       │
        │    Loader · Injector · Spoofer · Patcher · Bypasser · Harvester · ...      │
        ├────────────────────────────────────────────────────────────────────────────┤
        │                    LIVELLO DI ASTRAZIONE API SINDRIKIT                    │
        │      snd_memory_api_t  ->  alloc · free · protect                          │
        │      snd_module_api_t  ->  load_library · get_proc_address · ...           │
        │      snd_process_api_t ->  open · alloc_remote · write · protect · thread  │
        │      [ tabelle future ] ->  thread · object · ...                          │
        ├──────────────────┬──────────────────────┬──────────────────────────────────┤
        │   Profilo Win32  │    Profilo Native    │    Porta il Tuo Meccanismo       │
        │  VirtualAlloc    │  NtAllocateVirtual   │  Driver · ROP · Esotico          │
        │  LoadLibraryA    │  PEB Walk + EAT      │  Funzioni definite dall'operatore│
        └──────────────────┴──────────────────────┴──────────────────────────────────┘

In pratica, questo significa che ogni dominio segue lo stesso contratto:

// Loader riflessivo
snd_ldr_pe_ctx_t ctx = {0};
ctx.raw_source = &payload;
ctx.mem_api    = &snd_mem_win;   // oppure snd_mem_nt / snd_mem_sys
ctx.mod_api    = &snd_mod_win;   // oppure snd_mod_nt
snd_ldr_pe_prepare_image(&ctx);
snd_ldr_pe_execute_image(&ctx);

// Iniezione classica
snd_inj_ctx_t inj = {0};
inj.target_pid = 1337;
inj.payload    = &shellcode;
inj.proc_api   = &snd_proc_sys;  // oppure snd_proc_win / snd_proc_nt
snd_inj_classic_shell(&inj);
snd_inj_cleanup(&inj);

Pipeline Syscall a Cascata

SindriKit tratta la risoluzione delle syscall come un meccanismo iniettabile, impilando le strategie in ordine di priorità. Il motore scende a cascata finché una non ha successo:

snd_syscall_set_ntdll(clean_ntdll);
snd_syscall_set_resolver(snd_syscall_resolve_ssn_scan);
snd_syscall_add_resolver(snd_syscall_resolve_ssn_sort);
snd_syscall_set_invoker(snd_syscall_direct_invoke_asm);
// oppure per syscall indirette:
// snd_syscall_set_invoker(snd_syscall_indirect_invoke_asm);
// snd_syscall_set_gadget_finder(snd_syscall_find_gadget_scan);

L'invoker è disaccoppiato dalla risoluzione SSN — passa da syscall dirette a indirette senza modificare il codice di dominio. L'invocazione indiretta salta a un gadget legittimo di NTDLL, mantenendo l'indirizzo di ritorno della syscall all'interno di ntdll.dll.

Agilità Algoritmica in Fase di Compilazione

Ogni nome API e stringa di modulo viene rimosso dal binario finale in fase di compilazione tramite una singola variabile CMake:

set(SND_HASH_ALGO "FNV1A")  # oppure DJB2 ricalcola tutto automaticamente
set(SND_RANDOMIZE_SEED ON)  # genera un nuovo seed a 32 bit alla prossima configurazione

Ogni hash viene calcolato con un seed generato casualmente (se SND_RANDOMIZE_SEED=ON). L'impronta statica cambia completamente tra una compilazione e l'altra senza toccare una riga di C.

FFI Dinamico Consapevole dell'Architettura

Un ponte assembly MASM personalizzato per l'invocazione arbitraria di funzioni a runtime. Le build x64 seguono precisamente la convenzione di chiamata Microsoft x64 (shadow space, posizionamento degli argomenti nei registri, allineamento dello stack). Le build x86 inseriscono gli argomenti in ordine inverso con supporto sia per target cdecl che stdcall.

Parser PE con Controllo dei Limiti

Un parser unificato PE32/PE32+ con un flag is_mapped che gestisce correttamente sia le immagini raw su disco che le viste mappate in memoria. Ogni accesso alle data directory è validato rispetto ai limiti tracciati del buffer prima della dereferenziazione. La risoluzione delle export supporta catene di forwarder fino a profondità 4 con lookup basato su hash.

Testato contro:

• 40+ combinazioni di test core che mirano a EXE, DLL casi limite, argomenti errati, export mancanti e callback TLS su x86 e x64.
• 100+ mutazioni PE dinamiche generate dal modulo pe_mutator: nomi di sezioni azzerati, integer overflow, limiti e_lfanew non validi, import danneggiati.
• Corpus completo di Corkami: carica correttamente i campioni validi, rifiuta senza crash quelli malformati nel 99% dei campioni.

Contesti di Dominio con Stato Tracciato

Ogni operazione offensiva è gestita tramite una struttura di contesto discreta con enumerazione degli stadi. Le operazioni possono essere messe in pausa tra gli stadi per l'obfuscation del sonno o la distribuzione a stadi, riprese senza problemi e ispezionate per individuare il punto di errore esatto fino al sottosistema e al motivo.

La Filosofia di Progettazione delle API

Avvia la pipeline syscall una sola volta (schema tipico):

PVOID clean_ntdll = NULL;
snd_om_knowndll_map(&snd_map_nt, L"ntdll.dll", &clean_ntdll);
snd_syscall_set_ntdll(clean_ntdll);
snd_syscall_set_resolver(snd_syscall_resolve_ssn_scan);
snd_syscall_add_resolver(snd_syscall_resolve_ssn_sort);
snd_syscall_set_invoker(snd_syscall_direct_invoke_asm);
// oppure per syscall indirette:
// snd_syscall_set_invoker(snd_syscall_indirect_invoke_asm);
// snd_syscall_set_gadget_finder(snd_syscall_find_gadget_scan);

L'invoker è disaccoppiato dalla risoluzione SSN — passa da syscall dirette a indirette senza modificare il codice di dominio. L'invocazione indiretta salta a un gadget legittimo di NTDLL, mantenendo l'indirizzo di ritorno della syscall all'interno di ntdll.dll.

Cambia profilo di esecuzione con una sola assegnazione:

ctx.mem_api = &snd_mem_win;   // diagnostico
ctx.mem_api = &snd_mem_nt;    // stub NT via PEB + EAT
ctx.mem_api = &snd_mem_sys;   // syscall dirette (pipeline richiesta)

La risoluzione dei moduli segue lo stesso schema (snd_mod_win vs snd_mod_nt). Non esiste un backend di moduli basato su syscall — le import usano PEB walk + EAT anche nei profili completamente _sys.

Livelli di Build

Livello Debug — SND_ENABLE_DEBUG=ON

Per lo sviluppo locale. snd_status_t si espande per includere file, line e un buffer di contesto di 128 byte. SND_ERR_CTX e SND_DEBUG_PRINT emettono le transizioni della macchina a stati, i valori dei campi PE parsati e gli esiti della risoluzione delle syscall. Usa SND_USE_PRINTF=ON per indirizzare l'output a stdout invece che alla console di debug.

Livello Silenzioso — SND_ENABLE_DEBUG=OFF

La configurazione di distribuzione standard per i binari operativi. Ogni stringa diagnostica, riferimento a file e numero di riga viene completamente eliminato in compilazione. snd_status_t si riduce a due interi. Nient'altro.

set(SND_ENABLE_DEBUG   OFF   CACHE BOOL   "")
set(SND_BUILD_PAYLOADS OFF   CACHE BOOL   "")
set(SND_RANDOMIZE_SEED ON    CACHE BOOL   "")
set(SND_USE_DEFAULTS   ON    CACHE BOOL   "")
set(SND_HASH_ALGO    "DJB2"  CACHE STRING "")
add_subdirectory(vendor/SindriKit)
target_link_libraries(my_tool PRIVATE sindri::engine)

Documentazione

Riferimento completo in docs/:

• Getting Started — CMake, livelli di build, bootstrap DI, primo flusso di lavoro loader/iniezione
• Architettura — Dependency injection, macchine a stati, sistema di stato
• Primitive — Memoria, moduli, processi, mapping, syscall, esecuzione (FFI)
• Loader — Pipeline PE riflessiva
• Iniezione — Iniezione classica di shellcode e PE
• Parser — Sottodomini PE ed env (PEB)
• Comuni — Helper senza CRT, buffer, hashing, stato
• Esempi e PoC — loader_winapi, loader_nowinapi, inject_pe, inject_shell, heavens_gate
• Test — Runner di integrazione, mutatore PE

Previsto: dominio Evasion.

Disclaimer

SindriKit è stato creato esclusivamente per scopi educativi, di ricerca e di Red Teaming autorizzato. Per il disclaimer legale completo e le informazioni riguardanti le considerazioni OpSec, consulta la Security Policy.

Licenza

MIT