Usuario sin privilegios  ──►  AF_ALG + splice()  ──►  Escritura de 4 bytes en el caché de páginas  ──►  ROOT

AF_ALG (API criptográfica de espacio de usuario)
└── módulo algif_aead
    └── plantilla authencesn  ◄── VULNERABLE
        └── optimización in situ (2017)
            └── req->src == req->dst  ◄── páginas de splice() encadenadas en una lista de dispersión de dst escribible

Paso 1: Abrir socket AF_ALG AEAD
        socket(AF_ALG, SOCK_SEQPACKET, 0)

Paso 2: Enviar páginas de splice() que referencian el archivo objetivo
        (páginas del caché de páginas de un binario privilegiado, p.ej. /usr/bin/sudo)

Paso 3: Activar escritura temporal de authencesn
        authencesn usa el buffer dst como área de trabajo →
        escribe 4 bytes controlados MÁS ALLÁ de la región de salida legítima

Paso 4: La entrada del caché de páginas para el archivo objetivo ahora está corrupta
        (archivo en disco intacto — solo se modificó la copia en memoria)

Paso 5: Ejecutar el binario modificado → ROOT

# Corregido en el commit: a664bf3d603d
git show a664bf3d603d

CVE-2026-31431-CopyFail/
│
├── 📄 README.md                          ← Usted está aquí
├── 📄 LICENSE                            ← Licencia de investigación/educativa
├── 📄 DISCLAIMER.md                      ← Política de uso legal y ético
├── 📄 CHANGELOG.md                       ← Historial de versiones
│
├── 📂 docs/
│   ├── vulnerability-analysis.md         ← Análisis profundo: causa raíz y mecánica
│   ├── exploitation-walkthrough.md       ← Metodología paso a paso
│   ├── affected-kernels.md               ← Matriz completa de versiones de kernel/distribuciones
│   ├── detection.md                      ← Cobertura de Defender, Tenable, Wazuh
│   └── references.md                     ← Todos los CVEs, blogs, avisos
│
├── 📂 exploit/
│   ├── README.md                         ← Uso, requisitos previos, distribuciones probadas
│   ├── copyfail.py                       ← PoC de referencia (educativo)
│   ├── trigger.c                         ← Disparador C de AF_ALG + splice()
│   └── variants/
│       ├── ubuntu.py                     ← Variante específica para Ubuntu
│       ├── rhel.py                       ← Variante para RHEL/CentOS
│       └── amazon_linux.py              ← Variante para Amazon Linux
│
├── 📂 detection/
│   ├── yara/
│   │   └── copyfail.yar                  ← Regla YARA para artefactos del exploit
│   ├── sigma/
│   │   └── copyfail_lpe.yml              ← Regla Sigma para SIEM/SOC
│   └── scripts/
│       ├── check_vulnerable.sh           ← Verificación rápida de vulnerabilidad del kernel
│       └── detect_algif_aead.sh         ← Verificar si el módulo está cargado/activo
│
├── 📂 mitigation/
│   ├── README.md                         ← Resumen de mitigación
│   ├── disable_algif_aead.sh             ← Deshabilitar el módulo del kernel afectado
│   ├── patch-notes.md                    ← Detalles del parche ascendente
│   └── kubernetes-hardening.md          ← Endurecimiento de K8s / contenedores
│
├── 📂 lab/
│   ├── Vagrantfile                       ← MV vulnerable reproducible
│   ├── setup.sh                          ← Script de arranque del laboratorio
│   └── docker/
│       └── Dockerfile                    ← Contenedor Ubuntu vulnerable
│
├── 📂 reports/
│   ├── pentest-report-template.md        ← Plantilla de informe lista para el cliente
│   └── sample-finding.md                ← Ejemplo de redacción de hallazgo
│
└── 📂 assets/
    ├── demo.gif                          ← (Opcional) demostración en terminal
    └── diagrams/
        └── page-cache-write.png         ← Diagrama del flujo del ataque

# Clonar el repositorio
git clone https://github.com/0xFuffM3/CVE-2026-31431-CopyFail.git
cd CVE-2026-31431-CopyFail

# Iniciar la MV de laboratorio vulnerable
cd lab/
vagrant up

# SSH al laboratorio
vagrant ssh

# Verificar la versión del kernel (debería ser vulnerable)
uname -r

cd lab/docker/

# Construir la imagen del contenedor vulnerable
docker build -t copyfail-lab .

# Ejecutar con los privilegios necesarios para la interacción con el kernel
docker run --rm -it --privileged copyfail-lab /bin/bash

# Ejecutar el script de verificación rápida
chmod +x detection/scripts/check_vulnerable.sh
./detection/scripts/check_vulnerable.sh

[!] Versión del kernel: 5.15.0-91-generic
[!] Módulo algif_aead: CARGADO
[✗] El sistema parece VULNERABLE a CVE-2026-31431 (Copy Fail)
[*] Acción recomendada: Aplicar actualización del kernel o deshabilitar algif_aead

[✓] Versión del kernel: 6.1.132
[✓] El sistema parece PARCHEADO contra CVE-2026-31431 (Copy Fail)

# Python 3.6+
python3 --version

# Módulos del kernel requeridos presentes
lsmod | grep algif_aead

# Verificar que el binario objetivo sea legible
ls -la /usr/bin/sudo

cd exploit/

# Verificar el nivel de privilegio actual
id
# uid=1000(usuario) gid=1000(usuario) groups=1000(usuario)

# Ejecutar PoC de Copy Fail
python3 copyfail.py

# Verificar la escalada de privilegios
id
# uid=0(root) gid=0(root) groups=0(root)

1. Enumerar la versión del kernel
   └─► uname -r / cat /proc/version

2. Verificar si algif_aead está cargado
   └─► lsmod | grep algif_aead

3. Confirmar punto de apoyo con bajos privilegios
   └─► id / whoami

4. Ejecutar PoC de Copy Fail
   └─► python3 exploit/copyfail.py

5. Verificar acceso root
   └─► id && cat /etc/shadow

6. Documentar evidencia
   └─► Captura de pantalla + registrar versión del kernel, distribución, hash del exploit

7. Aplicar mitigación (después de la prueba)
   └─► sudo bash mitigation/disable_algif_aead.sh

8. Incluir en el informe de pentest
   └─► Usar reports/pentest-report-template.md

// detection/yara/copyfail.yar
rule CopyFail_CVE_2026_31431 {
    meta:
        description = "Detecta artefactos del exploit Copy Fail (CVE-2026-31431)"
        author      = "0xFuffM3"
        date        = "2026-04-30"
        reference   = "https://copy.fail"
    strings:
        $py1 = "algif_aead" ascii
        $py2 = "AF_ALG" ascii
        $py3 = "splice" ascii
        $py4 = "page_cache" ascii
        $py5 = "authencesn" ascii
    condition:
        3 of them
}

yara detection/yara/copyfail.yar /tmp/ -r

# detection/sigma/copyfail_lpe.yml
title: Ejecución de Exploit LPE Copy Fail (CVE-2026-31431)
status: stable
logsource:
    category: process_creation
    product: linux
detection:
    selection:
        CommandLine|contains:
            - 'AF_ALG'
            - 'algif_aead'
            - 'authencesn'
    condition: selection
falsepositives:
    - Pruebas legítimas de API criptográfica
level: high

chmod +x detection/scripts/detect_algif_aead.sh
./detection/scripts/detect_algif_aead.sh

# Ubuntu / Debian
sudo apt-get update && sudo apt-get upgrade linux-image-generic

# RHEL / CentOS
sudo yum update kernel

# Amazon Linux
sudo yum update kernel

# Después de la actualización, reiniciar
sudo reboot

# Ejecutar el script de mitigación
chmod +x mitigation/disable_algif_aead.sh
sudo bash mitigation/disable_algif_aead.sh

echo "install algif_aead /bin/false" > /etc/modprobe.d/disable-algif.conf
rmmod algif_aead 2>/dev/null || echo "[*] Módulo no cargado actualmente"
echo "[✓] algif_aead deshabilitado. Reiniciar para confirmar persistencia."

Hallazgo:    Escalada Local de Privilegios mediante Copy Fail (CVE-2026-31431)
Severidad:   ALTA (CVSS 7.8)
Host:       10.10.10.55 (ubuntu-prod-01)
Kernel:     5.15.0-91-generic

Evidencia:
  - Shell sin privilegios (uid=1000) escalado a root (uid=0)
  - Módulo del kernel algif_aead confirmado como cargado
  - Sin artefactos en disco — solo caché de páginas

Recomendación:
  1. Aplicar el parche del kernel del proveedor inmediatamente
  2. Temporal: deshabilitar el módulo algif_aead
  3. Revisar nodos de Kubernetes y ejecutores de CI/CD