Vulnerabilidad de Local Privilege Escalation en el kernel de Linux

Copy Fail es una vulnerabilidad lógica en el subsistema criptográfico del kernel de Linux que permite a cualquier usuario local — incluso cuentas sin privilegios — ejecutar código arbitrario como root en cuestión de segundos.

¿Por qué es grave?

• Sin fricción: El exploit no requiere race conditions, información filtrada del kernel ni adaptaciones por distribución. Funciona "out of the box" en Ubuntu, Amazon Linux, RHEL y SUSE con el mismo script.
• Extremadamente sigiloso: La modificación ocurre únicamente en la page cache (RAM). El fichero en disco no cambia, los hashes on-disk no se alteran, y tras un reinicio desaparece toda evidencia.
• ** cross-container**: La page cache es compartida entre todos los procesos del host, incluyendo contenedores. Un atacante dentro de un pod puede escapar al nodo.
• Superficie masiva: El bug se introdujo en 2017 y ha estado presente en prácticamente todas las distribuciones Linux durante casi una década.

¿Qué puede hacer un atacante?

Un usuario con acceso shell básico (por ejemplo, un usuario de sistema, un servicio comprometido, o incluso un contenedor) puede:

1. Ejecutar un script Python de 732 bytes
2. Modificar en memoria un binario SUID (como /usr/bin/su)
3. Obtener una shell con UID 0 (root)
4. Desde ahí, pivotar a otros contenedores, acceder a datos de otros tenants, o tomar el control total del nodo

Mitigación prioritaria: Deshabilitar el módulo algif_aead mientras se aplica el parche de kernel. La corrección oficial revierte una optimización introduced in 2017 en algif_aead.c.

Copy Fail es una vulnerabilidad en la plantilla AEAD authencesn del kernel de Linux, usada principalmente en IPsec para manejar Extended Sequence Numbers (ESN). El bug se combina con el socket de la familia AF_ALG y la syscall splice() para crear un primitive de escritura controlada de 4 bytes en la page cache de cualquier fichero legible — sin modificar el fichero en disco.

El flujo explotable:

1. Se abre un socket AF_ALG y se bindea a la plantilla authencesn(hmac(sha256),cbc(aes))
2. Se usa splice() para mapear páginas de un binario SUID (ej. /usr/bin/su) directamente en el scatterlist de entrada del kernel
3. Durante el decrypt, la plantilla authencesn escribe 4 bytes más allá de la región de tag válida (en posición assoclen + cryptlen)
4. Como el scatterlist de destino está "encadenado" con páginas de page cache del fichero original, esos 4 bytes se escriben dentro de la page cache del binario SUID
5. El exploit repite este proceso para cada chunk de 4 bytes, modificando el binario en memoria para que ejecute shellcode arbitrario
6. Al ejecutar execve("/usr/bin/su"), el proceso corriendo el binario modificado obtiene root

La escritura es controlada por el atacante: elige los 4 bytes y el offset donde se escriben. No es una escritura arbitraria de memoria del kernel, sino exactamente donde quiere dentro del fichero objetivo.

El bug fue introduced en la serie 4.14 con el commit 72548b093ee3 (optimización in-place de 2017) y afecta a cualquier kernel que incluya esa optimización.

La misma vulnerabilidad ha sido verificada por múltiples fuentes (The Hacker News, HelpNetSecurity, OVHcloud, SUSE) en Ubuntu, Amazon Linux, RHEL y SUSE. En la práctica, cualquier distribución que haya actualizado kernels regularmente desde 2017 es vulnerable hasta que aplique los parches específicos.

Copy Fail es particularmente crítico en:

• Hypervisores y nodos Kubernetes multi-tenant: un usuario comprometido en una VM o pod puede escapar al host
• Runners de CI/CD compartidos: los atacantes pueden obtener root en el nodo y mover laterally
• Plataformas de擬工业化 donde múltiples clientes comparten infraestructura

OVHcloud, SUSE y otros proveedores han publicado advisories específicos warniendo sobre la capacidad de comprometer nodos desde dentro de contenedores.

1. Portabilidad total: El mismo exploit funciona sin modificaciones en todas las distros probadas. No requiere adaptaciones por kernel, distribución ni versión de libc.

2. Sigilo extrema: La escritura ocurre solo en page cache. El fichero en disco no cambia, los hashes on-disk no se alteran, las herramientas de integridad basadas en checksums (AIDE, Tripwire) no lo detectan si se ejecutan tras el desalojo de páginas o reinicio.

3. No requiere info leaks: No necesitasfffdf de direcciones del kernel,fffdf de offsets de estructuras, ni nada de eso. El exploit es determinista.

4. Cross-container por diseño: La page cache es compartida a nivel host. Un proceso dentro de un contenedor puede modificar binarios SUID del host.

5. Sin race conditions: Es un exploit síncrono, sin timing dependencies. Funciona en la primera ejecución.

Dado que la escritura es exclusivamente en RAM (page cache) y nunca se marca la página como "dirty", no hay:

• Cambios en hashes de ficheros en disco
• Cambios en timestamps de acceso/modificación
• Evidencia tras reinicio (las páginas se desalojan)

Las herramientas de integridad basadas en verificación on-disk (AIDE, Tripwire, etc.) no detectarán el ataque si se ejecutan después de que las páginas hayan sido desalojadas.

Detección en tiempo real (durante el exploit):

• Monitorizar uso de sockets AF_ALG por parte de procesos no privilegiados
• Detectar patrones de splice() hacia sockets de tipo crypto (authencesn)
• Alertar sobre ejecuciones anómalas de binarios SUID desde usuarios sin privilegios

Detección post-incidente (memoria):

• Dump de memoria del sistema mientras el exploit está corriendo
• Análisis de page cache para identificar binarios SUID con modificaciones
• Comparación de código activo en memoria contra hashes known-good

Indicadores de compromiso (IoCs):

• Uso de la familia de sockets AF_ALG (número 38) por procesos fuera de expected list
• Operaciones de splice hacia fds de sockets crypto
• Ejecución de /usr/bin/su o similar desde cuentas de usuario normales que no deberían tener acceso

Si no puedes actualizar el kernel inmediatamente, la mitigación más efectiva es deshabilitar el módulo algif_aead.

# Crear regla para impedir la carga del módulo
echo "install algif_aead /bin/false" > /etc/modprobe.d/disable-algif-aead.conf

# Descargar el módulo si ya está cargado (requiere root)
rmmod algif_aead 2>/dev/null

# Verificar que no está cargado
lsmod | grep algif_aead  # No debe mostrar nada

Esto rompe la cadena de ataque porque el socket AF_ALG no podrá usar la plantilla authencesn si el módulo no está disponible.

Bloquear la creación de sockets AF_ALG por procesos no privilegiados reduce la superficie de ataque aunque el módulo siga presente:

# Ejemplo con seccomp (usar en contenedores o perfiles restringidos)
# Bloquear la syscall socketcall con dominio AF_ALG
# Esto es efectivo pero puede romper aplicaciones que legítimamente usen AF_ALG

Para Kubernetes:

# Ejemplo de PodSecurityPolicy / OPA Gatekeeper rule para denegar AF_ALG
apiVersion: policy/v1beta1
kind: PodSecurityPolicy
spec:
  seLinux:
    rule: RunAsAny
  seccomp:
    type: RuntimeDefault
  # Considerar bloquear syscalls relacionados con AF_ALG

• Deshabilitar la familia de sockets AF_ALG en el runtime de contenedor (requiere configuración de seccomp)
• Usar perfiles AppArmor/SELinux que bloqueen la creación de sockets crypto
• En Kubernetes, usar Pod Security Standards restrictivos

El fix oficial revierte la optimización "in-place" introduced in 2017. El modelo out-of-place original aseguraba que req->src apuntara al scatterlist de TX (con páginas de page cache) y req->dst apuntara al RX SGL (buffer de usuario), eliminando la posibilidad de que la escritura toque páginas de page cache.

Versiones corregidas confirmadas:

• Kernel 6.18.22+
• Kernel 6.19.12+
• Kernel 7.0+

Para verificar tu kernel:

uname -r
# Si el resultado es menor a 6.18.22, 6.19.12 o 7.0 (según rama),
# y no es una versión que tu distro haya backporteado el fix,
# estás vulnerable.

Después de actualizar, confirma que el módulo está cargable y que el kernel tiene el fix:

# Verificar versión del kernel
uname -r

# Verificar que algif_aead sigue disponible (el módulo ya no es vulnerable)
modinfo algif_aead

# En distros que no cargan módulos criptográficos dinámicamente,
# verificar que el módulo no está blacklisteado y que el kernel es patched

• Identificar todos los hosts con kernel 4.14+ sin parchear según advisory de tu distro
• Priorizar: hypervisores, nodos Kubernetes, runners CI/CD compartidos, bastiones
• Para cada host, verificar si el módulo algif_aead está cargado (lsmod | grep algif_aead)

• En todos los hosts vulnerables: aplicar regla modprobe para bloquear carga de algif_aead
• Si algif_aead ya está cargado: ejecutar rmmod algif_aead
• Endurecer políticas de contenedores/LSM para bloquear sockets AF_ALG
• Documentar hosts donde se aplicó la mitigación

• Obtener kernel actualizado de tu proveedor (Amazon, Red Hat, SUSE, Canonical)
• Validar que el paquete incluye los commits de fix (fafe0fa2995a, ce42ee423e58, a664bf3d603d)
• Planificar ventana de mantenimiento para reinicio
• Aplicar parche y reiniciar
• Verificar versión de kernel post-reinicio

• Mantener algif_aead deshabilitado donde no sea estrictamente necesario
• Implementar reglas de monitorización para uso anómalo de AF_ALG
• Incluir en tu SIEM alertas para:
  • Operaciones splice() hacia sockets crypto
  • Ejecución de binarios SUID desde cuentas no privilegiadas
  • Carga del módulo algif_aead en hosts que lo tenían deshabilitado

Si estás evaluando esta vulnerabilidad en un engagement:

1. Verificar exposición del target: Comprueba que puedes abrir sockets AF_ALG (los contenedores con perfiles restrictivos pueden bloquearlo)

2. Identificar objetivo: Localiza binarios SUID modificables en memoria. /usr/bin/su es el objetivo clásico, pero también puedes apuntar a sudo, passwd, etc.

3. Ejecutar el exploit: El PoC público de 732 bytes modifica /usr/bin/su e inyecta shellcode que hace setuid(0) antes de invocar la shell.

4. Validar impacto: Después de correr el exploit, cualquier usuario que ejecute su (o el binario que modificaste) obtendrá root.

5. Importante — sigilo:

   • La modificación es en RAM. Reinicia el sistema para restaurar el binario original.
   • No dejes el binario modificado si estás en un compromiso real (after-action restore).
   • El exploit no deja huella en disco, pero sí modifica la page cache en tiempo real.

6. Documentar hallazgos: Recomienda deshabilitar algif_aead como mitigación inmediata y actualizar el kernel como corrección definitiva.

• Xint / Theori — Technical Writeup
• OpenWall — oss-security mailing list
• The Hacker News — Coverage
• Heise — Copy Fail Linux root with 732 bytes
• HelpNet Security — Analysis
• Bugcrowd — What We Know
• OVHcloud — Rapid Protection Guide
• SUSE — Addressing Copy Fail in SUSE Virtualization
• NVD — CVE-2026-31431
• Amazon Linux — ALAS-2026-0002