Copy Fail — CVE-2026-31431

CVE-2026-31431 (Copy Fail) è una vulnerabilità di escalation dei privilegi locali nel modulo algif_aead del kernel Linux (sottosistema AF_ALG). Un difetto logico introdotto ad agosto 2017 consente a qualsiasi utente locale non privilegiato di scrivere 4 byte controllati nella cache delle pagine di qualsiasi file leggibile tramite AF_ALG + splice(), per poi eseguire un binario setuid corrotto e ottenere i privilegi di root. L'exploit è deterministico — nessuna race condition, nessun offset del kernel, nessun crash di sistema. Colpisce tutte le principali distribuzioni Linux che includono kernel dalla versione 4.14 alla 7.0-rc.

CVSS: 7.8 | Corretto in: kernel 7.0, 6.19.12, 6.18.22 | Fix mainline: commit a664bf3d603d

Fonti: copy.fail, The Hacker News, avviso CloudLinux

Struttura del progetto

crates/
├── exp/                            # Exploit PoC (reimplementazione in Rust)
├── copy_fail_guard/                # Loader eBPF in userspace — modalità LSM
├── copy_fail_guard-ebpf/           # Programma eBPF LSM (non nel workspace)
├── copy_fail_guard_kprobe/         # Loader eBPF in userspace — modalità kprobe
└── copy_fail_guard_kprobe-ebpf/    # Programma eBPF kprobe (non nel workspace)
scripts/
└── build_guard.sh                  # Build con un clic → output in dist/

Panoramica della vulnerabilità

La causa principale è una catena di tre funzionalità indipendenti del kernel che interagiscono in modo non sicuro:

1. Socket AF_ALG — espone l'API crittografica del kernel a utenti non privilegiati
2. splice() — trasferisce i dati dei file a copia zero come riferimenti alla cache delle pagine (non copie) nello scatterlist crittografico
3. Template AEAD authencesn — usa il buffer di output del chiamante come spazio di lavoro, scrivendo 4 byte in dst[assoclen + cryptlen]

Nel 2017, un'ottimizzazione in-place in algif_aead.c (72548b093ee3) ha reso req->src == req->dst, concatenando le pagine della cache delle pagine nello scatterlist di destinazione scrivibile. Quando authencesn scrive i suoi byte di lavoro, oltrepassa il buffer di output entrando nelle pagine della cache delle pagine concatenate. L'attaccante controlla:

• Quale file: qualsiasi file leggibile dall'utente corrente
• Quale offset: determinato dall'offset di splice, dalla lunghezza di splice e da assoclen
• Quali 4 byte: provengono dai byte AAD 4–7 (seqno_lo), impostati in sendmsg()

La pagina corrotta non viene mai marcata come sporca — il file su disco non viene toccato, ma execve() legge dalla cache delle pagine. Corrompi un binario setuid → root.

crates/exp — Exploit PoC

Reimplementazione in Rust del PoC Python pubblico di 732 byte. Prende di mira /usr/bin/su, esegue lo splice delle sue pagine nella cache delle pagine in un socket AEAD AF_ALG e le sovrascrive con un payload shell compresso.

Compilazione

Richiede Rust 1.85+ (edition 2024).

cargo build --release -p copy_fail

Il binario è solo per Linux. Su altre piattaforme termina con un errore Unsupported.

Esecuzione

Avvertenza: questo sfrutta una reale vulnerabilità del kernel. Eseguilo solo su sistemi di tua proprietà e sotto il tuo controllo, idealmente una VM usa e getta.

1. Avvia una VM con un kernel vulnerabile (qualsiasi distribuzione mainstream con kernel < 7.0 / < 6.19.12 / < 6.18.22).

2. Copia il binario compilato nella VM ed eseguilo come utente non root:

   ./target/release/copy_fail
   

3. Vulnerabile: appare una shell root (#). Esegui whoami per confermare root.

4. Non vulnerabile (kernel patchato): l'operazione AF_ALG fallisce oppure il binario su si comporta normalmente. Vedrai un errore o il normale prompt della password di su.

Strumento di difesa — copy_fail_guard

Una difesa runtime del kernel che blocca CVE-2026-31431 senza aggiornare il kernel o riavviare. Usa eBPF per intercettare la creazione dei socket AF_ALG, interrompendo il primo passo dell'exploit.

Sono disponibili due modalità. Il loader con un clic seleziona automaticamente la migliore modalità disponibile:

	Modalità LSM	Modalità kprobe
Come blocca	Restituisce -EPERM (creazione socket negata)	SIGKILL (processo terminato)
Requisito kernel	≥ 5.7 con parametro di avvio lsm=bpf	≥ 5.3, nessun parametro speciale
Richiede riavvio per attivarsi	Forse (se lsm=bpf non è già impostato)	No
Punto di hook	Hook LSM socket_create	kprobe __sys_socket

Come funziona

┌──────────────────────────────────────────────────┐
│  run_guard.sh                                    │
│  • Rileva il supporto BPF LSM                    │
│  • LSM disponibile  → copy_fail_guard (EPERM)    │
│  • LSM non disponibile → copy_fail_guard_kprobe (KILL)│
└──────────────┬───────────────────────────────────┘
               │
┌──────────────▼───────────────────────────────────┐
│  Programma eBPF                                  │
│  se famiglia socket == 38 (AF_ALG)               │
│     → blocca (EPERM o SIGKILL)                   │
│  altrimenti                                      │
│     → consenti                                   │
└──────────────────────────────────────────────────┘

Impatto sul sistema

Bloccare AF_ALG ha un impatto quasi nullo sui sistemi tipici:

• Non interessati: dm-crypt/LUKS, kTLS, IPsec/XFRM, OpenSSL/GnuTLS/NSS (build predefinite), SSH, crittografia del keyring del kernel — questi usano l'API crittografica del kernel direttamente, non tramite AF_ALG
• Potenzialmente interessati: applicazioni configurate esplicitamente per usare AF_ALG (ad es. OpenSSL con l'engine afalg abilitato, alcuni percorsi di offload crittografico embedded)
• Prestazioni: zero overhead per qualsiasi cosa che non chiami socket(AF_ALG, ...)

Compilazione

Build con un clic (consigliata):

./scripts/build_guard.sh

Questo installa automaticamente le toolchain mancanti (nightly, bpf-linker), compila tutti i programmi eBPF e i loader in userspace e produce tutto in dist/:

dist/
├── copy_fail_guard.bpf.o          # Programma eBPF LSM
├── copy_fail_guard_kprobe.bpf.o   # Programma eBPF kprobe
├── copy_fail_guard                 # Loader in userspace (LSM)
├── copy_fail_guard_kprobe          # Loader in userspace (kprobe)
└── run_guard.sh                    # Selezione automatica: sudo ./run_guard.sh

Copia la directory dist/ su qualsiasi macchina di destinazione ed esegui sudo ./run_guard.sh per attivare la protezione.

Build manuale (passo per passo):

Passo 1: Compila i programmi eBPF (deve essere fatto su Linux):

# Variante LSM
cd crates/copy_fail_guard-ebpf
cargo +nightly build --target bpfel-unknown-none -Z build-std=core --release

# Variante kprobe
cd crates/copy_fail_guard_kprobe-ebpf
cargo +nightly build --target bpfel-unknown-none -Z build-std=core --release

Passo 2: Compila i loader in userspace:

cargo build --release -p copy_fail_guard -p copy_fail_guard_kprobe

Esecuzione

Consigliato — seleziona automaticamente la modalità migliore:

sudo ./dist/run_guard.sh

Manuale — esegui una modalità specifica:

# Modalità LSM (richiede lsm=bpf)
sudo GUARD_BPF_OBJ=path/to/copy_fail_guard.bpf.o RUST_LOG=info ./copy_fail_guard

# Modalità kprobe (funziona ovunque)
sudo GUARD_BPF_OBJ=path/to/copy_fail_guard_kprobe.bpf.o RUST_LOG=info ./copy_fail_guard_kprobe

Premi Ctrl-C per scollegare il programma eBPF e ripristinare il comportamento normale.

Verifica della difesa

Con la guardia attiva in un terminale: