Detección de DIRTY FRAG con Wazuh 4.14.4 - CVE-2026-43284 / CVE-2026-43500

Ingeniería de detección para la LPE del kernel Dirty Frag - Ubuntu / RHEL / Debian / Amazon Linux

¿Qué es Dirty Frag?

CVE-2026-43284 / CVE-2026-43500 es una escalada de privilegios local (LPE) del kernel de Linux que encadena dos primitivas de escritura independientes de la caché de páginas para lograr acceso root desde una cuenta de usuario no privilegiada. Un único binario compilado consigue root en todas las principales distribuciones de Linux. Sin condición de carrera. Sin heap spray. Sin necesidad de desplazamiento del kernel.

Variante 1 - CVE-2026-43284 (xfrm-ESP):``` unshare(CLONE_NEWUSER|CLONE_NEWNET) -> register XFRM SA via netlink (CAP_NET_ADMIN inside new namespace) -> vmsplice(ESP header into pipe) -> splice(target file into pipe) -> splice(pipe to UDP socket) -> esp_input() in-place AEAD decrypt writes 4 bytes into page cache

**Variante 2 - CVE-2026-43500 (RxRPC):**```
add_key("rxrpc", ...)       no privileges required
-> socket(AF_RXRPC=35)
-> RxRPC handshake + forged DATA packet
-> vmsplice(RxRPC wire header into pipe)
-> splice(target file into pipe)
-> splice(pipe to UDP socket)
-> rxkad_verify_packet_1() in-place pcbc(fcrypt) decrypt writes 8 bytes into page cache

Cuando CLONE_NEWUSER está bloqueado por AppArmor (predeterminado en Ubuntu 24.04+), el exploit retrocede automáticamente de la variante ESP a la variante RxRPC. El mismo binario obtiene root en ambos casos.

CRÍTICO: La mitigación de Copy Fail (lista negra de algif_aead) no protege contra Dirty Frag. Ambas vulnerabilidades comparten el mismo sumidero authencesn, pero Dirty Frag se desencadena a través de una ruta de código completamente diferente. Si implementó la mitigación de Copy Fail, aún está expuesto.

Descubierto y publicado por V4bel - https://github.com/V4bel/dirtyfrag

Referencias Oficiales

Por qué falla FIM - Por qué existe este repositorio

Dirty Frag escribe directamente en la caché de páginas en memoria. El binario en disco nunca se modifica. El kernel nunca marca la página corrupta como sucia, por lo que el writeback nunca se ejecuta. El archivo en disco es idéntico byte por byte al original antes y después de la explotación.``` Traditional FIM approach: read file from disk -> compute hash -> compare -> no anomaly reported

Dirty Frag reality: on-disk /usr/bin/su = UNCHANGED page cache of /usr/bin/su = CONTAINS ROOT SHELL ELF FIM result = BLIND

La única detección efectiva es conductual, mediante la monitorización de syscalls a nivel del kernel. Este repositorio proporciona reglas de Wazuh validadas en producción que detectan ambas variantes de exploit a nivel de syscall, independientemente de la versión del kernel o del estado del parche.

---

## Cadena de Explotación```
ESP variant (CVE-2026-43284):
  unshare(CLONE_NEWUSER)    privilege boundary bypass via user namespace
  -> XFRM SA registration  CAP_NET_ADMIN gained inside new netns
  -> vmsplice()        [!]  ESP header planted into pipe
  -> splice()          [!]  /usr/bin/su page cache enters pipe
  -> splice()               pipe delivered to UDP socket
  -> esp_input() decrypt    4 bytes written deterministically into page cache
  -> execve(/usr/bin/su)    corrupted setuid binary runs shellcode as UID 0

RxRPC variant (CVE-2026-43500):
  add_key("rxrpc")          session key K planted - no privileges needed
  -> socket(AF_RXRPC)       rxrpc.ko auto-loaded
  -> vmsplice()        [!]  RxRPC wire header planted into pipe
  -> splice()          [!]  /etc/passwd page cache enters pipe
  -> splice()               pipe delivered to UDP socket
  -> rxkad_verify_packet_1() 8 bytes written deterministically into page cache
  -> su -                   /etc/passwd root entry has empty password field

La corrupción de la caché de páginas es la primitiva central en ambas variantes. vmsplice inserta el encabezado de protocolo controlado por el atacante en una tubería. splice entrega las páginas de la caché de páginas del archivo objetivo en la misma tubería sin copiarlas. Cuando el kernel procesa el búfer combinado a través de la ruta de descifrado, escribe los bytes controlados por el atacante en la caché de páginas del archivo objetivo.

Sistemas Afectados

Confirmado por @m0us3r - Laboratorio de detección de Ubuntu 24.04.2 LTS

Confirmado por el autor (github.com/V4bel/dirtyfrag)

Todos los kernels de Linux desde 2017 están afectados. La restricción unprivileged_userns de AppArmor en Ubuntu 24.04+ bloquea la variante ESP, pero la variante RxRPC la evita por completo.

CVE-2026-43284 (ESP): en alcance desde el commit cac2661c53f3 (2017-01-17) hasta f4c50a4034e6 (2026-05-05) - PARCHEADO en mainline

CVE-2026-43500 (RxRPC): en alcance desde el commit 2dc334f1a63a (2023-06-08) hasta upstream - AÚN NO EXISTE PARCHE

Estructura del Repositorio```

DIRTY-FRAG-Detection-with-Wazuh-4.14.4/ | |- rules/ | '- local_rules.xml # 9 Wazuh detection rules (200000-200008) | |- auditd/ | '- cve-dirty-frag.rules # auditd syscall sensor rules (v2 - auid fix) | |- sca/ | '- cve-dirty-frag.yml # SCA policy - kernel-version independent | '- docs/ |- dirty_frag_dash_rules.png # Wazuh Rules Management - 200000-200008 deployed and active |- SCA.png # SCA policy score 50% - 3 passed / 3 failed |- SCA-hits.png # Wazuh Discover - SCA check results across 3 scan cycles |- discover-dirty-frag.png # Wazuh Discover - 52 hits - initial validation run (May 8) '- discover-dirty-frag_more.png # Wazuh Discover - 13 hits - chain rule 200007 level 15 (May 15)

> **Nota sobre local_rules.xml:** Las reglas se entregan en `local_rules.xml`, que es el archivo estándar de Wazuh para reglas personalizadas en `/var/ossec/etc/rules/local_rules.xml`. Si prefieres mantener tus reglas de detección organizadas por CVE, puedes desplegar el contenido como un archivo independiente (p.ej., `cve-2026-43284_rules.xml`) en el mismo directorio. Ambos enfoques funcionan igualmente.

---

## Arquitectura de detección

Dos capas independientes - ninguna depende de la versión del kernel o del estado del parche.

### Capa 1 - Detección conductual (auditd + Wazuh)

**Nota importante sobre uid vs auid:** El proceso hijo de la variante ESP llama a `unshare(CLONE_NEWUSER)` y se mapea a sí mismo como `uid=0` dentro del nuevo espacio de nombres de usuario. El subsistema de auditoría de Linux registra el uid local del espacio de nombres en los eventos SYSCALL, lo que significa que los filtros `-F uid!=0` no capturan los eventos `vmsplice` y `splice` del hijo del exploit. `auid` (uid de auditoría / uid de inicio de sesión) se establece al iniciar sesión y nunca cambia con el reasignación de espacios de nombres. Las reglas del sensor para `vmsplice` y `splice` usan `-F auid>=1000` para capturar correctamente el usuario de inicio de sesión real independientemente de lo que haga el exploit dentro de un espacio de nombres.

**Reglas del sensor Auditd** (`auditd/cve-dirty-frag.rules`):```
-a always,exit -F arch=b64 -S vmsplice -F auid>=1000 -F auid!=-1 -k dirty_frag_vmsplice
-a always,exit -F arch=b32 -S vmsplice -F auid>=1000 -F auid!=-1 -k dirty_frag_vmsplice
-a always,exit -F arch=b64 -S splice   -F auid>=1000 -F auid!=-1 -k dirty_frag_splice
-a always,exit -F arch=b32 -S splice   -F auid>=1000 -F auid!=-1 -k dirty_frag_splice
-a always,exit -F arch=b64 -S unshare  -F uid!=0                  -k dirty_frag_ns_escape
-a always,exit -F arch=b64 -S add_key  -F uid!=0                  -k dirty_frag_add_key
-a always,exit -F arch=b64 -S socket   -F a0=0x23 -F uid!=0       -k dirty_frag_rxrpc_socket
-w /usr/bin/kmod -p x                                             -k dirty_frag_modload
-a always,exit -F arch=b64 -S execve -F exe=/usr/bin/su -F auid>=1000 -F auid!=-1 -k dirty_frag_execve_su

Capa 2 - Superficie de vulnerabilidad (Política SCA)

Verificaciones automáticas de configuración mediante sca/cve-dirty-frag.yml. Se ejecuta cada 12 horas en todos los agentes registrados. No se requiere verificación de versión del kernel.

Arquitectura de cadena de reglas

Nota de ingeniería: Las reglas de cadena (200007/200008) se activan cuando dos señales del mismo proceso llegan dentro de 120 segundos. vmsplice seguido de splice desde el mismo pid es la secuencia central de plantación de tubería de ambas variantes. El socket AF_RXRPC seguido de splice desde el mismo pid es específico de la ruta RxRPC. Ambas cadenas se validan mediante wazuh-logtest con 9/9 aprobados.

Panel de Wazuh - Reglas desplegadas

Reglas 200000-200008 desplegadas y activas. Etiquetas de cumplimiento: PCI_DSS, HIPAA, GDPR, NIST_800_53, MITRE ATT&CK. Las reglas 200007 y 200008 alcanzan el nivel 15 (Crítico) en detección de cadenas correlacionadas.

Despliegue

Paso 1 - Instalar auditd```bash

Ubuntu / Debian

apt install auditd audispd-plugins -y systemctl enable --now auditd auditctl -s | grep enabled

RHEL / Amazon Linux

yum install audit -y systemctl enable --now auditd

SUSE

zypper install audit -y systemctl enable --now auditd

### Paso 2 - Desplegar reglas del sensor auditd```bash
cp auditd/cve-dirty-frag.rules /etc/audit/rules.d/
augenrules --load
auditctl -l | grep dirty_frag

5.4 Desinstalar usando frameworks de Instrumentación Binaria Dinámica (DBI)

Los frameworks DBI (por ejemplo, Intel Pin y DynamoRIO) se pueden utilizar para instrumentar funciones específicas y eludir mecanismos de seguridad. En el siguiente ejemplo, utilizamos Intel Pin para instrumentar la función _dl_open y desinstalar el rootkit LKM, que se comporta de manera similar a Diamorphine.

$ make uninstall

-a always,exit -F arch=b64 -S vmsplice -F auid>=1000 -F auid!=-1 -F key=dirty_frag_vmsplice -a always,exit -F arch=b32 -S vmsplice -F auid>=1000 -F auid!=-1 -F key=dirty_frag_vmsplice -a always,exit -F arch=b64 -S splice -F auid>=1000 -F auid!=-1 -F key=dirty_frag_splice -a always,exit -F arch=b32 -S splice -F auid>=1000 -F auid!=-1 -F key=dirty_frag_splice -a always,exit -F arch=b64 -S unshare -F uid!=0 -F key=dirty_frag_ns_escape -a always,exit -F arch=b64 -S add_key -F uid!=0 -F key=dirty_frag_add_key -a always,exit -F arch=b64 -S socket -F a0=0x23 -F uid!=0 -F key=dirty_frag_rxrpc_socket -w /usr/bin/kmod -p x -k dirty_frag_modload -a always,exit -F arch=b64 -S execve -F exe=/usr/bin/su -F auid>=1000 -F auid!=-1 -F key=dirty_frag_execve_su

### Paso 3 - Implementar reglas de detección de Wazuh

Añada el contenido de `rules/local_rules.xml` a su archivo existente `/var/ossec/etc/rules/local_rules.xml`, o impleméntelo como un archivo independiente si prefiere mantener las reglas organizadas por CVE:```bash
# Option A - append to local_rules.xml (recommended)
cat rules/local_rules.xml >> /var/ossec/etc/rules/local_rules.xml

# Option B - standalone file
cp rules/local_rules.xml /var/ossec/etc/rules/cve-2026-43284_rules.xml

Ayuda

Kage 🐱‍👤 es una herramienta GUI para generar, desplegar y gestionar payloads de Metasploit (con y sin etapas), así como un controlador de listeners. Está construida sobre Gustavo y la API de Metasploit con un toque de Artois.

Configuración de Desarrollo

Requisitos: git, npm (Node.js), python3, pip3, Metasploit instalado y en PATH

Clona el repositorio e instala las dependencias:

git clone https://github.com/Wayzit/Kage.git
cd Kage
npm install
pip3 install -r requirements.txt
``````bash
# Validate syntax - must exit 0 with zero warnings
/var/ossec/bin/wazuh-analysisd -t 2>&1 | tail -5

# Restart manager
systemctl restart wazuh-manager

Paso 4 - Desplegar política SCA```bash

On the Wazuh manager - distribute to all agents via shared group

cp sca/cve-dirty-frag.yml /var/ossec/etc/shared/default/ chown root:wazuh /var/ossec/etc/shared/default/cve-dirty-frag.yml chmod 660 /var/ossec/etc/shared/default/cve-dirty-frag.yml

Agregue a la configuración del grupo de agentes (`/var/ossec/etc/shared/default/agent.conf`):```xml
<agent_config>
  <sca>
    <policies>
      <policy>/var/ossec/etc/shared/cve-dirty-frag.yml</policy>
    </policies>
  </sca>
</agent_config>

Requerido: La ejecución remota de comandos debe estar habilitada en cada agente para que las comprobaciones c:lsmod y c:systemctl se ejecuten:
echo "sca.remote_commands=1" >> /var/ossec/etc/local_internal_options.conf
systemctl restart wazuh-agent
``````bash

systemctl restart wazuh-manager

### Paso 5 - Configurar ossec.conf localfile

Asegúrese de que el agente Wazuh ingiera el log de auditd. Añada dentro de `<ossec_config>` en `/var/ossec/etc/ossec.conf` en cada host monitoreado, o distribuya a través de `agent.conf`:```xml
<localfile>
  <log_format>audit</log_format>
  <location>/var/log/audit/audit.log</location>
</localfile>

Validación

wazuh-logtest - todas las 9 reglas```bash

SIGNAL 1 - vmsplice (rule 200000)

echo 'type=SYSCALL msg=audit(1778261582.230:1155): arch=c000003e syscall=316 success=yes exit=8 a0=3 a1=7fff00000000 a2=1 a3=0 items=0 ppid=1000 pid=93321 auid=1000 uid=1000 gid=1000 euid=1000 suid=1000 fsuid=1000 egid=1000 sgid=1000 fsgid=1000 tty=pts0 ses=58 comm="exp" exe="/home/kr/exp" subj=unconfined key="dirty_frag_vmsplice"' | /var/ossec/bin/wazuh-logtest 2>&1 | grep -E "rule|level|200"

SIGNAL 7 - CHAIN ESP (rules 200000 + 200007, same pid)

printf 'type=SYSCALL msg=audit(1777570010.000:200): arch=c000003e syscall=316 success=yes exit=8 a0=3 a1=7fff00000000 a2=1 a3=0 items=0 ppid=1000 pid=55001 auid=1000 uid=1000 gid=1000 euid=1000 suid=1000 fsuid=1000 egid=1000 sgid=1000 fsgid=1000 tty=pts0 ses=58 comm="exp" exe="/home/kr/exp" key="dirty_frag_vmsplice"\ntype=SYSCALL msg=audit(1777570011.000:201): arch=c000003e syscall=275 success=yes exit=4 a0=4 a1=5 a2=6 a3=0 items=0 ppid=1000 pid=55001 auid=1000 uid=1000 gid=1000 euid=1000 suid=1000 fsuid=1000 egid=1000 sgid=1000 fsgid=1000 tty=pts0 ses=58 comm="exp" exe="/home/kr/exp" key="dirty_frag_splice"\n' | /var/ossec/bin/wazuh-logtest 2>&1 | grep -E "rule|level|200"

Esperado para la prueba de cadena:```
id: '200000' level: '10'   <- vmsplice signal
id: '200007' level: '15'   <- CHAIN ESP confirmed - IMMEDIATE INVESTIGATION REQUIRED

Verificar que auditd capturó eventos después de la ejecución del exploit```bash

### Verificar alertas generadas por Wazuh```bash
grep -E "200002|200005|200006" /var/ossec/logs/alerts/alerts.log | tail -10

Puntuación SCA esperada (sistema base sin sensor ni auditd desplegado): 50% (3 aprobados / 3 fallidos).

Evidencia de Validación en Producción

Ejecución de exploit - agent wazuh5beta (Ubuntu 24.04.2 LTS kernel 6.8.0-111-generic)```

kr@wazuh5beta:~~$ ./exp root@wazuh5beta:~~# date ; uname -a ; id ; whoami Sat May 9 04:59:08 AM UTC 2026 Linux wazuh5beta 6.8.0-111-generic #111-Ubuntu SMP PREEMPT_DYNAMIC Sat Apr 11 23:16:02 UTC 2026 x86_64 uid=0(root) gid=0(root) groups=0(root) root

Usuario `kr` (uid=1000) sin privilegios ejecutó el binario PoC y obtuvo una shell de root (uid=0). Wazuh capturó y alertó en tiempo real.

### Ejecución de validación inicial - 8 de mayo de 2026 (52 aciertos)

[![Descubrir alertas - 52 aciertos](https://assets.kitploit.com/production/public/readmes/29704/339df2550c55e9537597dcc566e7081c4fa3e5c111322e29c112d6d9f5c8914f.png)](docs/discover-dirty-frag.png)

| Regla | Aciertos | Descripción |
| --- | --- | --- |
| 200002 | confirmado | unshare(CLONE_NEWUSER) - AppArmor AUDIT - intento ESP capturado |
| 200005 | confirmado | ejecución kmod/modprobe - carga de módulos esp4/esp6/rxrpc |
| 200006 | confirmado | execve /usr/bin/su - uid=kr euid=root - LPE confirmado |

> **Contexto:** Esta ejecución se realizó antes de que se desplegaran las reglas completas del sensor auditd. Las reglas 200002, 200005 y 200006 se activaron mediante la cobertura base de auditd. La regla de cadena completa (200007) requiere que el archivo sensor `cve-dirty-frag.rules` esté activo; consulte la ejecución de validación completa a continuación.

### Ejecución de validación completa - activación de regla de cadena 200007 (15 de mayo de 2026)

[![Descubrir alertas - 13 aciertos - regla de cadena 200007](https://assets.kitploit.com/production/public/readmes/29704/f17710d6a7162e404979ad4db6afe3f0739dacbbcec42d59ce17df5df791ed77.png)](docs/discover-dirty-frag_more.png)

| Regla | Nivel | Clave | Nota |
| --- | --- | --- | --- |
| 200002 | 12 | dirty_frag_ns_escape | unshare(CLONE_NEWUSER) - escape de namespace ESP |
| 200003 | 8 | dirty_frag_add_key | add_key() - plantación de clave de sesión RxRPC |
| 200000 | 10 | dirty_frag_vmsplice | vmsplice() - plantación de cabecera de protocolo |
| **200007** | **15** | dirty_frag_splice | **CADENA DE EXPLOIT DETECTADA: vmsplice + splice mismo pid/120s - INVESTIGACIÓN INMEDIATA REQUERIDA** |

La regla 200007 se activó después de desplegar las reglas completas del sensor auditd (`cve-dirty-frag.rules`). La cadena correlacionó `vmsplice()` + `splice()` de `pid=5670` (`exe=/home/kr/exp`) dentro de la ventana de 120 segundos. Esta es la señal de mayor confianza en el conjunto de detección.

### Política SCA - Puntuación 50% (línea base sin sensor desplegado)

[![Resumen de política SCA](https://assets.kitploit.com/production/public/readmes/29704/452e77ba876b73d2891291b317bed14961fbba0e43bfbc971f4fb04172e2bba9.png)](docs/SCA.png)

[![Descubrir SCA](https://assets.kitploit.com/production/public/readmes/29704/37b829919fccada1cb711ca7b9030746076913c3f1cb57464cb83d0ff22456f1.png)](docs/SCA-hits.png)

| Verificación | Título | Resultado |
| --- | --- | --- |
| 43284001 | Módulo kernel esp4 no cargado | Aprobado |
| 43284002 | Módulo kernel esp6 no cargado | Aprobado |
| 43284003 | Módulo kernel rxrpc no cargado | Aprobado |
| 43284004 | esp4/esp6/rxrpc deshabilitados mediante modprobe.d | Fallido |
| 43284005 | auditd activo y en ejecución | Fallido |
| 43284006 | Reglas del sensor auditd para CVE-2026-43284 desplegadas | Fallido |

> La puntuación del 50% representa un sistema base limpio con los módulos vulnerables ausentes (descargados) pero sin la pila de detección y endurecimiento desplegada. Este es el punto de partida esperado para un sistema que aún no ha aplicado los pasos de remediación en este repositorio.

`wazuh-analysisd -t`: exit 0 - zero warnings - all 9 rules loaded.

---

## Nota sobre Ubuntu 24.04 - AppArmor y Retroceso de Variante

Ubuntu 24.04 incluye `apparmor_restrict_unprivileged_userns=1` por defecto (kernel 6.1+). Esta configuración restringe `unshare(CLONE_NEWUSER)` para procesos no privilegiados, lo que mitiga parcialmente la variante ESP (CVE-2026-43284). El kernel registra un evento AppArmor AUDIT para el intento, que es lo que activa la regla 200002 en nuestro laboratorio.

El binario exploit retrocede automáticamente a la variante RxRPC (CVE-2026-43500) cuando falla la ruta ESP. La variante RxRPC no requiere `CLONE_NEWUSER` y omite esta restricción.```bash
# Check if your Ubuntu system has this restriction active
cat /proc/sys/kernel/apparmor_restrict_unprivileged_userns
# 1 = restricted (ESP variant blocked, RxRPC still active)
# 0 = not restricted (both variants active)

Las reglas 200000/200001 (vmsplice/splice) permanecen activas y relevantes para:

Ubuntu 22.04 y versiones anteriores
Debian 11/12
RHEL 8/9
Cualquier kernel con apparmor_restrict_unprivileged_userns=0

La cobertura completa de las 9/9 reglas fue validada mediante wazuh-logtest en Wazuh 4.14.4.

Mitigación

Mitigación inmediata (antes del parche del kernel)

Para la variante RxRPC (CVE-2026-43500):```bash echo 'install rxrpc /bin/false' >> /etc/modprobe.d/dirty-frag.conf rmmod rxrpc 2>/dev/null || true

Seguro en todos los sistemas que no son AFS. No afecta a IPsec, kTLS, SSH ni a la pila de red general.

**Para la variante ESP (CVE-2026-43284) - solo si no se están utilizando túneles IPsec:**```bash
echo 'install esp4 /bin/false' >> /etc/modprobe.d/dirty-frag.conf
echo 'install esp6 /bin/false' >> /etc/modprobe.d/dirty-frag.conf
rmmod esp4 esp6 2>/dev/null || true

ADVERTENCIA: Incluir esp4/esp6 en listas negras rompe los túneles IPsec de strongSwan/Libreswan. No aplicar en hosts que ejecuten conexiones IPsec activas.

Solución permanente

Aplicar el commit del kernel f4c50a4034e6 mediante la actualización del kernel de su distribución.```bash

Ubuntu / Debian

apt update && apt upgrade linux-generic

RHEL / Amazon Linux

dnf update kernel

SUSE

zypper update kernel-default

---

## Relación con Copy Fail (CVE-2026-31431)

Ambas vulnerabilidades explotan el mismo sumidero de descifrado authencesn en el kernel de Linux para escribir bytes controlados por el atacante en la caché de páginas. La diferencia está en cómo alcanzan ese sumidero.

| | Copy Fail (CVE-2026-31431) | Dirty Frag (CVE-2026-43284/43500) |
| --- | --- | --- |
| Ruta de activación | socket AF_ALG + splice vía algif_aead | vmsplice + splice vía esp_input o rxkad |
| Privilegios requeridos | Ninguno | Ninguno (RxRPC) / Namespace de usuario (ESP) |
| Superposición de mitigación | Lista negra de algif_aead | Lista negra de rxrpc / esp4 / esp6 |
| Mitigación cruzada | La lista negra de algif_aead NO detiene Dirty Frag | La lista negra de rxrpc NO detiene Copy Fail |
| Detección FIM | No | No |
| Claves de auditd | copy_fail_* | dirty_frag_* |
| Reglas de Wazuh | 199600-199607 | 200000-200008 |

Ambos conjuntos de reglas pueden coexistir de forma segura en el mismo gestor de Wazuh. Los espacios de nombres de las claves de auditd son independientes y no hay conflictos de ID de reglas.

---

## Cronología de divulgación

| Fecha | Evento |
| --- | --- |
| 2026-04-29 | Divulgación pública de Copy Fail (CVE-2026-31431) |
| 2026-05-07 | Divulgación pública de Dirty Frag por V4bel - PoC publicado |
| 2026-05-08 | Laboratorio de detección completado - Reglas de Wazuh 4.14.4 validadas |
| 2026-05-08 | Entregable comunitario publicado |

---

## Resumen de la política SCA

| ID de verificación | Título | Riesgo |
| --- | --- | --- |
| 43284001 | Módulo del kernel esp4 no cargado en memoria | ALTO |
| 43284002 | Módulo del kernel esp6 no cargado en memoria | ALTO |
| 43284003 | Módulo del kernel rxrpc no cargado en memoria | ALTO |
| 43284004 | esp4/esp6/rxrpc deshabilitados vía modprobe.d | ALTO |
| 43284005 | auditd activo y en ejecución | ALTO |
| 43284006 | Reglas del sensor auditd para Dirty Frag desplegadas | ALTO |

---

*Reglas de detección, configuración del sensor auditd y política SCA validadas en Wazuh 4.14.4, Ubuntu 24.04.2 LTS (kernel 6.8.0-111-generic).*

---

## Autor

**Kislley Rodrigues (m0us3r)**
Embajador de Wazuh | Ingeniería de detección | Blue Team

---

## Agradecimientos

- **V4bel** por el descubrimiento, divulgación pública y PoC de CVE-2026-43284 / CVE-2026-43500 - https://github.com/V4bel/dirtyfrag
- **Equipo de Wazuh** por la plataforma SIEM/XDR de código abierto
- **Anthony Faruna y Katia Bukcovac** - Programa de Embajadores de Wazuh, por la revisión y comentarios sobre este entregable de detección
- **CloudLinux** por la referencia de mitigación temprana en https://blog.cloudlinux.com/dirty-frag-mitigation-and-kernel-update

---

## Wazuh

Este proyecto fue desarrollado como parte del [Programa de Embajadores de Wazuh](https://wazuh.com/ambassadors-program/?utm_source=ambassadors&utm_medium=referral&utm_campaign=ambassadors+program).

Wazuh es una plataforma de seguridad gratuita y de código abierto que proporciona protección unificada XDR y SIEM.
Para más información, visite [wazuh.com](https://wazuh.com/?utm_source=ambassadors&utm_medium=referral&utm_campaign=ambassadors+program).

PoC - dirtyfrag (exp.c)	https://github.com/V4bel/dirtyfrag
CVE-2026-43284	https://github.com/V4bel/dirtyfrag
CVE-2026-43500	https://github.com/V4bel/dirtyfrag
Kernel Fix - commit f4c50a4034e6	https://github.com/torvalds/linux/commit/f4c50a4034e6
Mitigation Reference - CloudLinux	https://blog.cloudlinux.com/dirty-frag-mitigation-and-kernel-update
Related - Copy Fail (CVE-2026-31431)	https://github.com/mym0us3r/COPY-FAIL-Detection-with-Wazuh-4.14.4
MITRE ATT&CK T1068	https://attack.mitre.org/techniques/T1068/

Wazuh Server - Ubuntu 24.04.2 LTS	6.8.0-111-generic	Restringido (predeterminado)	RxRPC	AppArmor bloquea ESP, rxrpc.ko cargado por defecto	VULNERABLE
Wazuh Beta 5 - Ubuntu 24.04.2 LTS	6.8.0-111-generic	Restringido (predeterminado)	RxRPC	AppArmor bloquea ESP, rxrpc.ko cargado por defecto	VULNERABLE

Ubuntu 24.04.4	6.17.0-23-generic	Restringido (predeterminado)	RxRPC	AppArmor bloquea ESP + ESP parcheado en kernel 6.17
RHEL 10.1	6.12.0-124.49.1.el10_1.x86_64	No restringido	ESP + RxRPC	Sin restricción de espacio de nombres, kernel anterior al parche ESP
openSUSE Tumbleweed	7.0.2-1-default	No restringido	ESP + RxRPC	Sin restricción de espacio de nombres
CentOS Stream 10	6.12.0-224.el10.x86_64	No restringido	ESP + RxRPC	Sin restricción de espacio de nombres
AlmaLinux 10	6.12.0-124.52.3.el10_1.x86_64	No restringido	ESP + RxRPC	Sin restricción de espacio de nombres
Fedora 44	6.19.14-300.fc44.x86_64	No restringido	ESP + RxRPC	Sin restricción de espacio de nombres

80700	decoded_as=auditd	ancla auditd (integrada en Wazuh)	-	0	0
200000	80700	vmsplice() - plantilla de cabecera de protocolo	dirty_frag_vmsplice	1	10
200001	80700	splice() - plantilla de caché de páginas	dirty_frag_splice	1	10
200002	80700	unshare(CLONE_NEWUSER) - ruta ESP	dirty_frag_ns_escape	1	12
200003	80700	add_key("rxrpc") - plantilla de clave RxRPC	dirty_frag_add_key	1	8
200004	80700	socket(AF_RXRPC) - disparador RxRPC	dirty_frag_rxrpc_socket	1	10
200005	80700	ejecución de kmod/modprobe	dirty_frag_modload	1	12
200006	80700	execve /usr/bin/su euid=root	dirty_frag_execve_su	1	6
200007	200001 + if_matched=200000	CADENA ESP: vmsplice + splice mismo pid/120s	-	2	15
200008	200001 + if_matched=200004	CADENA RXRPC: AF_RXRPC + splice mismo pid/120s	-	2	15

Más Populares

DIRTY-FRAG-Detection-with-Wazuh-4.14.4

Detección de DIRTY FRAG con Wazuh 4.14.4 - CVE-2026-43284 / CVE-2026-43500

¿Qué es Dirty Frag?

Referencias Oficiales

Por qué falla FIM - Por qué existe este repositorio

Sistemas Afectados

Confirmado por @m0us3r - Laboratorio de detección de Ubuntu 24.04.2 LTS

Confirmado por el autor (github.com/V4bel/dirtyfrag)

Estructura del Repositorio```

Capa 2 - Superficie de vulnerabilidad (Política SCA)

Arquitectura de cadena de reglas

Panel de Wazuh - Reglas desplegadas

Despliegue

Paso 1 - Instalar auditd```bash

Ubuntu / Debian

RHEL / Amazon Linux

SUSE

5.4 Desinstalar usando frameworks de Instrumentación Binaria Dinámica (DBI)

Configuración de Desarrollo

Paso 4 - Desplegar política SCA```bash

On the Wazuh manager - distribute to all agents via shared group

Validación

wazuh-logtest - todas las 9 reglas```bash

SIGNAL 1 - vmsplice (rule 200000)

SIGNAL 7 - CHAIN ESP (rules 200000 + 200007, same pid)

Verificar que auditd capturó eventos después de la ejecución del exploit```bash

Evidencia de Validación en Producción

Ejecución de exploit - agent wazuh5beta (Ubuntu 24.04.2 LTS kernel 6.8.0-111-generic)```

Mitigación

Mitigación inmediata (antes del parche del kernel)

Solución permanente

Ubuntu / Debian

RHEL / Amazon Linux

SUSE