v0idnetwork/cve-2026-46331pedit COW
CVE-2026-46331 (soprannominato “pedit COW”) è un difetto locale di escalation dei privilegi nel kernel Linux, situato nel sottosistema di controllo del traffico. Un utente non privilegiato (in un namespace di rete non privilegiato) può configurare il filtro act_pedit (editor di pacchetti) per innescare una scrittura copy-on-write (COW) parziale nella cache di pagina. In pratica, il kernel scrive dati controllati dall'attaccante nell'immagine in memoria di un file senza contrassegnare la pagina come privata, corrompendo la copia cache di quel file. Fondamentalmente, lo sfruttamento richiede solo CAP_NET_ADMIN (ottenibile in un namespace utente) e non modifica il file su disco. In concreto, una prova di concetto (PoC) funzionante chiamata packet_edit_meme è stata pubblicata il 17 giugno 2026, dimostrando come sovrascrivere l'immagine nella cache di pagina di un binario setuid (es. /bin/su) per ottenere una shell di root. La vulnerabilità deriva da un calcolo errato dell'intervallo COW in tcf_pedit_act() ed è stata corretta upstream (4 giugno 2026) spostando il controllo della regione scrivibile all'interno del ciclo per chiave.
act_pedit. Le versioni stabili non aggiornate (inclusi molti kernel di distribuzione) sono vulnerabili.tc pedit e sovrascrive il punto di ingresso ELF di un binario setuid in memoria con shellcode.skb_ensure_writable() all'interno del ciclo chiave). Come soluzione alternativa, bloccare o rimuovere il modulo act_pedit oppure disabilitare i namespace utente non privilegiati (es. sysctl user.max_user_namespaces=0). Dopo la mitigazione, svuotare le cache (echo 3 > /proc/sys/vm/drop_caches) per rimuovere eventuali pagine avvelenate.Questo rapporto fornisce un'analisi tecnica dettagliata di CVE-2026-46331: causa, sfruttamento, rilevamento e strategie di remediation, con riferimenti ad advisory dei vendor, CVE e all'exploit pubblico.
Definizione: CVE-2026-46331 è un bug di scrittura fuori dai limiti nel sottosistema Traffic Control (net/sched) del kernel Linux, specificamente nell'azione act_pedit (editor di pacchetti). La funzione tcf_pedit_act() calcola un intervallo “copy-on-write” per le operazioni di modifica dei pacchetti prima di iterare sulle chiavi tipizzate, utilizzando un suggerimento statico tcfp_off_max_hint. Tuttavia, alcune chiavi (es. modifiche agli header TCP/UDP) determinano il loro offset finale solo a runtime. Il codice non ricontrolla mai la scrivibilità per questi offset dinamici. Di conseguenza, le scritture possono avvenire al di fuori della regione pre-COW: parte della scrittura del pacchetto non viene mai resa privata, portando a un COW parziale. Questa scrittura erronea si propaga nella memoria condivisa della cache di pagina di un file (se i buffer dei pacchetti fanno riferimento a pagine di file), corrompendo l'immagine cache del file.
Contesto: L'azione editor di pacchetti (pedit) di Linux consente agli amministratori di riscrivere byte arbitrari all'interno degli header dei pacchetti (livello collegamento, rete o trasporto) mentre i pacchetti attraversano un filtro tc configurato. Funziona specificando un offset (possibilmente ancorato a un header) e un valore/maschera a 32 bit. Internamente, pedit opera su socket-buffer (sk_buff) e deve rendere scrivibile la memoria del pacchetto target prima di modificarlo (tramite skb_ensure_writable() in modalità COW). Idealmente, il kernel dovrebbe clonare (copiare privatamente) qualsiasi pagina condivisa prima di scrivere, per evitare di alterare la memoria usata altrove.
Causa principale: In tcf_pedit_act(), il codice calcola erroneamente l'intervallo scrivibile una sola volta in anticipo, utilizzando tcfp_off_max_hint (l'offset statico massimo). Questo suggerimento non include alcun offset di header runtime che le chiavi tipizzate aggiungono durante l'elaborazione del pacchetto. Chiavi come TCP o UDP possono calcolare un offset basato sulla posizione dell'header IP a runtime (per esempio, se una chiave precedente sposta l'header di rete). Pertanto, durante il ciclo per chiave, l'offset effettivo per una chiave può superare l'intervallo che era stato preallocato come scrivibile. Il codice scrive quindi nella memoria del pacchetto tramite skb_store_bits(), ma poiché la pagina oltre la regione pre-COW non è stata resa privata, la scrittura corrompe una pagina ancora condivisa con la cache di pagina. In breve, “calcolare l'intervallo scrivibile del pacchetto troppo presto” provoca una scrittura fuori dai limiti, attraverso le pagine. Anche gli offset negativi (es. modifica degli header Ethernet su ingresso) sono gestiti male, e persino offset_valid() mancava di una protezione per INT_MIN, aggravando il difetto.
Perché accade: Questo bug è essenzialmente un errore logico nel calcolo dell'intervallo copy-on-write. Il kernel presumeva che l'offset massimo statico (noto al caricamento) fosse sufficiente per tutte le modifiche. Non aggiornava l'intervallo COW quando le chiavi con offset dinamici venivano effettivamente applicate. Dopo una serie di modifiche in coda, la scrittura finale poteva trovarsi al di fuori della regione pre-controllata. Poiché i buffer dei pacchetti possono fare riferimento a pagine di file mappate in memoria (es. tramite meccanismi zero-copy), questa scrittura “COW parziale” può raggiungere la cache di pagina di un file su disco. In pratica, l'azione dell'editor di pacchetti può ricevere pagine da sendfile o splice; quindi una singola operazione di filtro dei pacchetti può scrivere indirettamente dati scelti dall'attaccante nell'immagine in memoria di un file, senza alterare il disco.
Componenti e flusso dei dati: Il codice vulnerabile risiede nel sottosistema net/sched di Linux (act_pedit.c). Quando un pacchetto corrisponde a una regola pedit configurata, viene invocata tcf_pedit_act(). Internamente chiama skb_ensure_writable(skb, X) una sola volta, dove X = tcfp_off_max_hint. Questo rende privati (COW) i primi X byte del pacchetto. Poi, in un ciclo su ogni chiave (operazione di modifica), calcola l'offset di scrittura effettivo della chiave aggiungendo l'offset di header runtime all'offset specificato dalla chiave, e scrive un valore a 32 bit nel pacchetto. In pseudocodice:```c
u32 off_max = action->tcfp_off_max_hint;
skb_ensure_writable(skb, off_max);
for (i = 0; i < num_keys; i++) {
u32 hdr_off = compute_header_offset(skb, key[i].hdr_type);
u32 write_off = hdr_off + key[i].offset;
skb_store_bits(skb, write_off, &key[i].value, 4);
}
Poiché `hdr_off` viene calcolato solo durante l'elaborazione di ogni chiave, la chiamata iniziale a `skb_ensure_writable()` non ne teneva conto. Se `hdr_off + key[i].offset` supera `off_max`, il codice ripiega su `skb_store_bits()` sui frammenti anziché sull'area lineare principale, il che significa che scrive in una pagina non resa privata. Questo è il punto di fallimento.