abdelkabirouadoukou/cve-2026-31431-analysis-and-fixAnalisi tecnica approfondita della CVE-2026-31431 del kernel Linux (Copy Fail), una escalation locale dei privilegi tramite il bug della scatterlist in-place di AF_ALG, inclusi causa principale, percorso di sfruttamento e guida all'invio della patch.
Gravità: CVSS 7.8 (Alta)
Classe: Escalation dei Privilegi Locale
Introdotta: Linux 4.14 (2017)
Corretta: commit a664bf3d603d
CVE-2026-31431 è una vulnerabilità di escalation dei privilegi locale nel modulo algif_aead del kernel Linux — l'interfaccia socket AEAD dell'API crittografica userspace del kernel (AF_ALG).
La vulnerabilità consente a un utente non privilegiato di utilizzare la famiglia di indirizzi AF_ALG nell'API crittografica del kernel Linux per eseguire scritture controllate di 4 byte nella page cache, che supporta le copie in memoria dei file. Sostituendo il codice nella copia in memoria di un eseguibile leggibile archiviato nella page cache, un attaccante può aumentare i privilegi utente quando qualsiasi processo privilegiato esegue successivamente quella versione corrotta del file.
A differenza di Dirty Cow (CVE-2016-5195), che richiedeva di vincere una race condition, Copy Fail è un difetto logico lineare. Si attiva senza race, tentativi o finestre temporali soggette a crash.
Il commit 72548b093ee3 ("crypto: algif_aead - switch to in-place processing") ha introdotto un'ottimizzazione che impostava req->src == req->dst all'interno di aead_recvmsg(), eliminando un'allocazione separata del buffer di output.
Questa ottimizzazione ha fatto sì che req->src e req->dst puntassero a uno scatterlist combinato. Per questo motivo, le pagine della page cache provenienti dalla chiamata splice() venivano concatenate in modo improprio direttamente nello scatterlist di destinazione scrivibile.
L'API AEAD del kernel definisce un chiaro contratto di output: il buffer di destinazione riceve AAD || plaintext, esattamente assoclen + (cryptlen - authsize) byte. Nulla nell'API impone questo contratto e nulla lo documenta come requisito. Il design presuppone che ogni algoritmo AEAD confini le proprie scritture alla destinazione prevista. Un algoritmo non lo ha fatto.
crypto/
├── algif_aead.c ← bug dello scatterlist in-place (principale)
└── authencesn.c ← scrittura scratch fuori dai limiti (trigger)
crypto/algif_aead.c — L'Assegnazione In-Place/* VULNERABILE — percorso in-place post-2017 */
static int aead_recvmsg(struct socket *sock, struct msghdr *msg,
size_t ignored, int flags)
{
/* ... */
/*
* Quando userspace chiama splice(2) su un file, areq->tsgl contiene
* le pagine della page cache di quel file. Impostando dst = src si consegnano
* quelle pagine della page cache al motore crittografico come buffer
* di output scrivibile.
*/
aead_request_set_crypt(req,
areq->tsgl, /* src */
areq->tsgl, /* dst — puntatore identico; causa principale */
areq->cryptlen, iv);
}
crypto/authencesn.c — La Scrittura Scratch Fuori dai LimitiIl template authencesn è un wrapper AEAD utilizzato da IPsec per il supporto Extended Sequence Number (ESN). IPsec utilizza numeri di sequenza a 64 bit suddivisi in una metà alta (seqno_hi, byte 0–3 dell'AAD) e una metà bassa (seqno_lo, byte 4–7). Il formato wire trasporta solo seqno_lo; seqno_hi è implicito.
/* crypto/authencesn.c — scrittura scratch oltre il limite di output */
static int crypto_authenc_esn_decrypt(struct aead_request *req)
{
/* ... */
/*
* authencesn memorizza temporaneamente seqno_hi all'offset
* (assoclen + cryptlen) in req->dst — una parola oltre la
* regione di output legittima.
*
* In condizioni normali: colpisce memoria di proprietà del kernel.
* Con scatterlist in-place: colpisce una pagina della page cache.
*/
scatterwalk_map_and_copy(&seqno_hi,
req->dst,
req->assoclen + req->cryptlen, /* offset fuori dai limiti */
sizeof(seqno_hi), /* 4 byte */
1 /* scrittura */);
/* authencesn non ripristina questi byte sul percorso di errore */
}
Correzione upstream: commit a664bf3d603d — annulla l'ottimizzazione del 2017.
crypto/algif_aead.c — Scatterlist Separati/* CORRETTO — src e dst separati */
aead_request_set_crypt(req,
areq->tsgl, /* src — può contenere pagine della page cache; sola lettura */
areq->rsgl, /* dst — buffer kernel appena allocato; scrivibile */
areq->cryptlen, iv);
Effetto: Le pagine della page cache rimangono in src, che il motore crittografico legge soltanto. La scrittura scratch di authencesn all'offset assoclen + cryptlen ora finisce in un buffer allocato dal kernel di proprietà del processo. Nessuna pagina della page cache è mai raggiungibile dal percorso di scrittura.
Quanto segue descrive come la scrittura di 4 byte ottiene la piena escalation dei privilegi.
| Passo | Azione |
|---|---|
| 1 | Aprire un socket AF_ALG configurato per authencesn(hmac(sha256),cbc(aes)) |
| 2 | splice() un binario setuid leggibile (es., /usr/bin/sudo) nel socket — questo inserisce le sue pagine della page cache in areq->tsgl |
| 3 | Creare assoclen + cryptlen in modo che l'offset della scrittura scratch si allinei con un byte target all'interno dell'immagine cache del binario |
| 4 | Chiamare recvmsg() — attiva il percorso di decrittazione, authencesn scrive 4 byte controllati dall'attaccante nella page cache |
| 5 | Il file su disco è invariato; i controllori di integrità, inotify e i timestamp inode non sono interessati |
| 6 | Qualsiasi esecuzione successiva del binario mappa le pagine della page cache già modificate — il codice patchato viene eseguito con euid=0 |
La scrittura finisce all'interno dei dati cache del file spliced in memoria, bypassando completamente i permessi del file.
./scripts/get_maintainer.pl crypto/algif_aead.c
# Herbert Xu <[email protected]>
# [email protected]
./scripts/checkpatch.pl 0001-crypto-algif_aead-revert-inplace.patch
crypto: algif_aead - ripristina scatterlist src/dst separati in recvmsg
Il commit 72548b093ee3 ("crypto: algif_aead - switch to in-place
processing") ha impostato req->src == req->dst all'interno di
aead_recvmsg(). Quando il chiamante usa splice(2), lo scatterlist
sorgente contiene pagine della page cache del file spliced. Con
l'ottimizzazione in-place, quelle stesse pagine diventano la
destinazione scrivibile passata alla trasformazione AEAD.
authencesn scrive 4 byte all'offset (assoclen + cryptlen) in
req->dst come spazio scratch per il riarrangiamento dell'Extended
Sequence Number e non li ripristina sul percorso di errore. Con
pagine della page cache presenti in dst, questa scrittura bypassa
il livello di permessi VFS e corrompe l'immagine in memoria del
file spliced senza modificare l'inode su disco.
Un utente locale non privilegiato può sfruttare questo per
sovrascrivere byte arbitrari nella page cache di qualsiasi binario
setuid leggibile e aumentare i privilegi a root.
Ripristina scatterlist src e dst separati in modo che le pagine
della page cache siano confinate al percorso sorgente in sola
lettura.
Fixes: 72548b093ee3 ("crypto: algif_aead - switch to in-place processing")
Cc: [email protected] # 4.14+
Reported-by: Taeyang Lee <[email protected]>
Signed-off-by: Il Tuo Nome <[email protected]>
git send-emailgit send-email \
[email protected] \
[email protected] \
[email protected] \
0001-crypto-algif_aead-revert-inplace.patch
| Elemento | Scopo |
|---|---|
Oggetto sottosistema: file - frase verbale | Formato richiesto; sotto i 72 caratteri |
Fixes: <sha> ("titolo originale") | Attiva lo strumento automatico di backport stabile |
Cc: [email protected] | Segnala la patch per i backport dei rami LTS |
Reported-by: | Attribuzione allo scopritore |
Signed-off-by: | Developer Certificate of Origin — obbligatorio |
I kernel vulnerabili coprono Linux 4.14 fino a 7.0-rc, tutti i 6.18.x precedenti a 6.18.22 e i 6.19.x precedenti a 6.19.12.
Mitigazione provvisoria (nessun riavvio richiesto sulla maggior parte dei sistemi):
echo "install algif_aead /bin/false" > /etc/modprobe.d/disable-algif.conf
rmmod algif_aead 2>/dev/null || true
Questa soluzione alternativa non influisce su dm-crypt/LUKS, kTLS, IPsec/XFRM, OpenSSL, GnuTLS, NSS o SSH.
xint.io/blog/copy-fail-linux-distributionsnvd.nist.gov/vuln/detail/CVE-2026-31431a664bf3d603d (mainline)72548b093ee3 (Linux 4.14, 2017)