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.
**Superficie d'attacco:** L'unica interfaccia necessaria è il **tc filter** con un'azione `pedit`, che normalmente richiede la capacità **CAP_NET_ADMIN**. Tuttavia, gli utenti normali possono ottenere CAP_NET_ADMIN all'interno di un namespace di rete privato (clonazione di namespace utente) senza privilegi reali. Pertanto, un utente non privilegiato può entrare in un namespace utente+rete e creare una regola `tc pedit` su loopback. La scrittura avviene quando un pacchetto viene elaborato (l'attaccante genera tipicamente traffico su loopback per attivarla). Il confine di fiducia (utente vs kernel) viene superato perché il kernel si fidava della propria configurazione COW, ma gli offset forniti dall'utente hanno infranto tale presupposto.
**Meccanismo interno:** Dal lato del kernel, la vulnerabilità si manifesta come una **scrittura fuori dai limiti** (CWE-787). Corrompe la memoria del kernel mappata nello spazio utente (cache delle pagine dei file). In particolare, può sovrascrivere il contenuto di qualsiasi pagina di file che si trova mappata nel buffer del socket. Nel proof-of-concept, `/bin/su` viene mappato in memoria (mmapped) inviandolo nel buffer del socket, quindi l'exploit modifica i byte del punto di ingresso in memoria. Questo non modifica il file su disco, ma qualsiasi successiva esecuzione di quel binario legge l'immagine avvelenata dalla cache. L'analisi del blog osserva:
> “Poiché lo skb può fare riferimento a pagine zero-copy caricate tramite sendfile, quella scrittura fuori dai limiti può finire nella memoria condivisa della cache delle pagine che supporta un file reale. Il kernel ritiene di aver reso la memoria del pacchetto sicura da modificare; in realtà, la successiva scrittura arriva al di fuori della regione che ha effettivamente reso privata.”
**Confini di fiducia:** Il kernel ha assunto erroneamente che `skb_ensure_writable()` (COW a percorso rapido) avrebbe garantito la sicurezza per tutte le scritture successive. Non ha ricontrollato per ogni chiave. L'utente controlla solo la configurazione del filtro dei pacchetti e il contenuto dei pacchetti; il kernel lo ha concesso (attraverso i namespace di rete). Una volta violata quella fiducia, la scrittura è sfuggita nella memoria supportata da file che avrebbe dovuto essere protetta.
## Analisi della causa principale
La causa principale è il **calcolo errato dell'intervallo COW nell'azione pedit**. In termini di codice, è stata effettuata una singola chiamata a `skb_ensure_writable()` con una lunghezza basata su `tcfp_off_max_hint`, quindi all'interno del ciclo gli offset effettivi potevano superarla. Una piccola patch (maggio 2026) la risolve spostando `skb_ensure_writable()` *all'interno* del ciclo, dopo che il vero offset è noto, e aggiungendo controlli e gestione speciale per offset negativi. In altre parole:
- **Codice con bug:** ```c
skb_ensure_writable(skb, action->tcfp_off_max_hint);
for each key:
// compute offset (hdr_off + key_offset)
skb_store_bits(skb, write_off, ...);
Inoltre, la correzione garantisce che per gli offset negativi (modifiche all'intestazione Ethernet) utilizzi skb_cow() sull'headroom e si protegge dai casi INT_MIN. Il messaggio di commit (riepilogo di stack.watch) afferma: "Correzione spostando skb_ensure_writable() all'interno del ciclo per-chiave dove è noto l'offset di scrittura effettivo e aggiungendo il controllo di overflow sull'aritmetica degli offset.".
Pertanto, perché esiste: durante la revisione del codice o la progettazione, il ricalcolo per-chiave è stato trascurato. L'ottimizzazione dell'hint statico ha bypassato la necessità di rivalutare per chiave. Sembra essere un bug onesto piuttosto che una svista malevola, ma il suo effetto è grave perché viola l'assunzione COW. Come nota TuxCare, questo bug è stato unito sotto le sembianze di una normale correzione di "corruzione dati", senza contesto immediato di sicurezza.
La vulnerabilità è stata introdotta dal commit del kernel 8b796475fd78 (maggio 2022) ed è rimasta inosservata fino all'inizio del 2026. Secondo le fonti, la correzione (commit 899ee91156e5 del 31 maggio 2026) è stata inviata alla mailing list netdev come una normale patch di corruzione dati. I manutentori del kernel hanno unito la correzione (net-7.1-rc7) il 4 giugno 2026. Solo il 16 giugno 2026 è stato formalmente assegnato CVE-2026-46331 (circa due settimane dopo l'apparizione della patch). Un exploit pubblico completamente armato è apparso il 17 giugno 2026 (il PoC packet_edit_meme).
In pratica, la sequenza è stata:
Diverse parti hanno notato il bug dalla patch aperta. Ad esempio, Massimiliano Oldani (ricercatore di cybersecurity) ha pubblicato un'analisi dettagliata e un exploit poco dopo, notando che "un exploit proof-of-concept pubblico e funzionante chiamato packet_edit_meme è apparso su GitHub entro 24 ore dall'assegnazione del CVE". CloudLinux, TuxCare e SentinelOne hanno pubblicato analisi una volta che il PoC era pubblico e i CVE assegnati. Il tracker di sicurezza Debian e PT DBugs hanno anche riassunto il problema e gli advisory disponibili (vedi Riferimenti).
Un attacco realistico richiede prerequisiti minimi:
Capacità dell'attaccante: Un utente locale senza privilegi sulla macchina target. L'utente deve essere in grado di creare un nuovo user namespace con network namespace (tramite unshare(CLONE_NEWUSER|CLONE_NEWNET)), che concede CAP_NET_ADMIN all'interno di quel namespace senza privilegi di root reali. Gli user namespace non privilegiati sono abilitati per impostazione predefinita su molti kernel (ad es. RHEL, Debian) e possono essere riabilitati su Ubuntu con un workaround aa-exec.
Condizioni target: Il target deve eseguire un kernel Linux vulnerabile (circa 5.18–7.1-rc6) con il modulo act_pedit disponibile. Se act_pedit è integrato o già caricato, è immediatamente sfruttabile. Se è un modulo, si carica automaticamente quando viene configurata una regola tc pedit. Il target non deve aver applicato la patch a monte. In particolare, non è necessario che l'attaccante abbia accesso in scrittura a nessun file; l'exploit funziona scrivendo attraverso i filtri dei pacchetti.
Catena di attacco:
unshare --map-root-user --net --pid bash per creare un nuovo user+net namespace. Questo concede CAP_NET_ADMIN in quel namespace (utente mappato a root all'interno).ifconfig lo up) e opzionalmente avvia un listener (ad es. nc -l 127.0.0.1 9999). Questo fornisce un flusso di pacchetti da utilizzare per le azioni TC.Impatto: Se ha successo, l'attaccante ottiene pieno privilegio di root localmente. L'exploit può essere eseguito con un singolo comando ed è deterministico. Inoltre, la corruzione di pagine arbitrarie backing-file potrebbe causare denial-of-service (crash del sistema) se utilizzata diversamente. Il PoC pubblicato ha sovrascritto specificamente il punto di ingresso di /bin/su con shellcode, ma qualsiasi file che l'attaccante possa mappare potrebbe essere preso di mira. La catena non richiede tempistiche speciali o race ed è stata dimostrata su molte distribuzioni (RHEL, Ubuntu, Debian, ecc.).
Un exploit pubblico, packet_edit_meme, è disponibile su GitHub (sgkdev/packet_edit_meme) e prende di mira /bin/su. Descriviamo la sua logica essenziale senza payload distruttivi:```c
/* Pseudocode outline of the exploit (simplified) /
int main() {
/ 1. Identify a setuid binary (su) and its ELF entry offset */
int fd = open("/bin/su", O_RDONLY);
long entry = elf_entry_offset(fd);
if (entry < 0) abort();
printf("Target %s (UID=%d), entry offset 0x%lx\n", "/bin/su", getuid(), entry);
/* 2. Unshare user+net namespace to get CAP_NET_ADMIN locally */
if (unshare(CLONE_NEWUSER | CLONE_NEWNET) < 0) abort();
/* Map UID/GID to root (handled via /proc/self/uid_map, /gid_map) */
// (omit details: write "0 <uid> 1" to /proc/self/uid_map and gid_map, and deny setgroups)
/* 3. Setup environment: bring up loopback and listener */
if (system("ip link set lo up") < 0) abort();
if (system("nc -l 127.0.0.1 9999 &") < 0) abort();
/* 4. Configure a tc pedit action via netlink (simplified) */
// Assume 'pedit_write' sends a packet-edit command to the kernel.
// The key offsets below are chosen such that they exceed the initial COW range.
char shellcode[/*size=48*/] = {
// (assembly for setgid(0); setuid(0); execve("/bin/sh").., padded to 36 or 48 bytes)
};
size_t total = sizeof(shellcode), sent = 0;
while (sent < total) {
int chunk = min(PEDIT_MAX_WRITE, total - sent);
/* Issue TC pedit action to write next chunk */
if (pedit_write(fd, entry + sent, &shellcode[sent], chunk) != 0) {
fprintf(stderr, "pedit_write failed\n");
exit(1);
}
sent += chunk;
}
/* 5. Trigger execution of su (in original namespace) */
execl("/bin/su", "su", NULL); // This will run the poisoned binary as root
return 0;
}
Questo pseudocodice illustra il flusso: apri `/bin/su`, esegui unshare dei namespace per ottenere CAP_NET_ADMIN, configura il loopback e le regole TC pedit, quindi chiama una funzione `pedit_write(fd, offset, data, len)` (nel PoC reale questo utilizza chiamate netlink sottostanti) per sovrascrivere la cache delle pagine del target. Infine, il binario viene eseguito, generando una shell root.
Il PoC effettivo è più elaborato (gestisce mappe UID/GID, ascolto di rete e byte shellcode a livello di syscall), ma il concetto centrale è quanto sopra. Sottolineiamo **di non eseguire questo exploit** se non in un ambiente di test sicuro e di non prendere di mira alcun sistema reale. Quanto sopra è solo a scopo dimostrativo.
**Nota:** Se non esistesse alcun PoC pubblico sicuro da usare, lo dichiareremmo esplicitamente. In questo caso, il PoC è pubblico e lo descriviamo concettualmente. Abbiamo omesso i byte grezzi dello shellcode e i dettagli effettivi di netlink per brevità e sicurezza.
## Flusso di sfruttamento
1. **Punto di ingresso:** L'attaccante deve prima ottenere CAP_NET_ADMIN. Tipicamente, ciò significa creare un namespace utente+rete (`unshare`) da un processo non privilegiato, che concede CAP_NET_ADMIN locale al namespace.
2. **Accesso iniziale:** All'interno di questo namespace, l'attaccante può utilizzare strumenti normali (`ip`, `tc`) per configurare il controllo del traffico. Il percorso del codice `act_pedit` del kernel diventa ora raggiungibile per i pacchetti.
3. **Attivazione:** L'attaccante imposta un `tc filter ... action pedit` sull'interfaccia di loopback. Questo filtro corrisponde ai pacchetti (ad esempio 0-match) e specifica una o più **typed keys** con tipi di intestazione (IP, TCP) e offset. Gli offset sono scelti in modo tale che *dopo che il kernel ha calcolato la base dell'intestazione all'interno del ciclo*, l'offset finale di scrittura superi l'intervallo COW iniziale.
4. **Sfruttamento:** Quando un pacchetto che corrisponde al filtro viene elaborato, il kernel chiama `tcf_pedit_act()`. Esegue un *insufficiente* `skb_ensure_writable()` e poi itera le chiavi. Per almeno una chiave, la scrittura atterra su una pagina che *non* è stata clonata in una copia privata. Ciò causa una **scrittura fuori dai limiti** nella cache delle pagine condivisa. Se il buffer del socket è stato preparato per fare riferimento alle pagine di un file (tramite sendfile/splice), quella scrittura corrompe quelle pagine del file.
5. **Post-sfruttamento:** Lo shellcode dell'attaccante è stato scritto nella pagecache del binario target (ad es. `/bin/su`). L'attaccante (nel namespace originale) esegue quindi `/bin/su`. Il kernel legge l'immagine in memoria (con il carico iniettato) ed esegue lo shellcode, fornendo all'attaccante una shell root. A questo punto, si è verificato un compromesso completo del sistema.
6. **Impatto:** L'attaccante ottiene privilegi di root. I dati riservati potrebbero essere sovrascritti ma non divulgati direttamente. L'integrità è completamente compromessa (l'attaccante può modificare l'immagine in memoria di qualsiasi file). Anche la disponibilità può essere influenzata (la scrittura errata di pagine critiche potrebbe causare il crash di processi o del sistema). Metriche CVSS: Medio complessivo (CVSS 3.1=6.0), ma l'impatto effettivo è root locale grave.
Questo flusso è riassunto schematicamente:```mermaid
flowchart LR
A[Attacker (unprivileged user)] --> B[Unshare into user+net namespace<br>(gains CAP_NET_ADMIN)]
B --> C[Configure TC pedit filter on lo]
C --> D{Packet processing by kernel}
D --> E[act_pedit computes wrong COW range]
E --> F[skb_store_bits writes beyond COW'd region]
F --> G[Page cache of target file is corrupted]
G --> H[Attacker executes poisoned setuid binary]
H --> I[Root shell obtained]
act_pedit appare in lsmod inaspettatamente su sistemi che normalmente non usano tc pedit. (Ad esempio, lsmod | grep act_pedit non vuoto su server web.)tc: Comandi tc insoliti o messaggi netlink da processi non privilegiati. I log di audit potrebbero mostrare CAP_NET_ADMIN concesso a un processo non root.netstat -tulnp che mostra nc o un listener personalizzato su 127.0.0.1 potrebbe essere un segno.tcf_pedit_act, skb_ensure_writable o soft lockup durante traffico intenso su loopback o errori nell'elaborazione tc. (Questi sarebbero insoliti e indicativi di corruzione.)Ad esempio, un IOA è file corrotti nella cache delle pagine: una checklist di triage potrebbe includere la verifica del contenuto dei file in memoria rispetto al disco, specialmente per i binari setuid dopo un'intensa attività tc. Un altro è creazione di nuovi namespace: il monitoraggio delle chiamate a unshare(CLONE_NEWUSER|CLONE_NEWNET) potrebbe essere segnalato. In breve, i difensori dovrebbero monitorare qualsiasi di: uso di act_pedit, uso di userns e modifiche improvvise degli eseguibili in RAM.
Per rilevare tentativi di sfruttamento:
tc o messaggi netlink che aggiungono un filtro act_pedit. Ad esempio, le regole Sigma potrebbero cercare eventi contenenti TCA_ACT_KIND: pedit o simili. Monitorare i log di audit per capset CAP_NET_ADMIN da processi non root, o scritture in /proc/*/uid_map./bin/su (o altri binari sensibili) e li eseguono improvvisamente in concomitanza con syscall namespace/unshare. Avvisare su qualsiasi processo che apre un binario setuid e crea un userns.skb_ensure_writable() non possa essere ingannato (sebbene non esista alcun controllo integrato noto).In sintesi, i difensori dovrebbero registrare e auditare l'uso dei namespace utente, i comandi tc e i caricamenti dei moduli. Un approccio chiave: rifiutare o registrare qualsiasi invocazione di tc pedit da parte di utenti non fidati. Su host compromessi, verificare se /etc/modprobe.d/disable-act_pedit.conf è stato applicato (dovrebbe essere pre-emptivamente).
Applicare le Patch: La correzione principale è un aggiornamento del kernel. Tutte le principali distribuzioni hanno rilasciato aggiornamenti a giugno 2026. L'aggiornamento a un kernel patchato (Linux 7.1.0 o successivo, o backport delle distribuzioni) è la soluzione definitiva.
Modifiche di Configurazione: Se l'applicazione delle patch non è immediatamente possibile, implementare mitigazioni:
act_pedit: Se i tuoi carichi di lavoro non richiedono tc pedit, blacklistare il modulo. Ad esempio:echo "blacklist act_pedit" > /etc/modprobe.d/disable-act_pedit.conf
``` ```
echo 'install act_pedit /bin/true' | sudo tee /etc/modprobe.d/disable-act_pedit.conf
lsmod | grep -w act_pedit && sudo rmmod act_pedit
Questo assicura che l'azione non possa essere caricata. (Raccomandato da CloudLinux e TuxCare.) Non applicare su host che usano legittimamente tc pedit.
Su Ubuntu 22.04+: ``` sudo sysctl -w kernel.unprivileged_userns_clone=0 echo 'kernel.unprivileged_userns_clone = 0' | sudo tee /etc/sysctl.d/99-pedit-cow.conf
Questo impedisce agli utenti non privilegiati di creare il namespace utente necessario per ottenere CAP_NET_ADMIN. Nota: disabilitare i namespace potrebbe rompere i container rootless e alcune applicazioni sandbox.
- **Drop Page Cache (Contenimento):** Se sospetti che l'exploit sia stato eseguito, le copie in memoria dei binari potrebbero essere compromesse. Elimina immediatamente le cache per rimuoverle: ```
sudo sh -c "echo 3 > /proc/sys/vm/drop_caches"
Questo forza il ricaricamento delle pagine dal disco. Avvertenza: Se un intruso ha già ottenuto i privilegi di root, lo svuotamento delle cache non rimuoverà alcuna persistenza installata. Tratta tali host come compromessi.
Privilegio minimo: Controlla e limita chi può usare tc. L'exploit richiede solo CAP_NET_ADMIN; assicurati che solo amministratori fidati abbiano questa capacità. Usa RBAC o containerizzazione per limitare le concessioni di capacità.
Controlli di rete: Sebbene non sia direttamente sfruttabile in rete, assicurati che l'uso del loopback sia monitorato. Applicare firewall a 127.0.0.1 è poco pratico, ma assicurati che solo il traffico localhost sia utilizzato per le manipolazioni TC.
Avvisi dei vendor: Fai riferimento agli avvisi ufficiali per il tuo OS. Red Hat ha RHSA-2026:27354 (e correlati) per RHEL 8/9/10, Debian ha DSA-6355-1, la pagina CVE di Ubuntu elenca i kernel corretti, ecc. (Vedi Riferimenti.)
La remediation a lungo termine prevede di assicurarsi che tutti i sistemi interessati abbiano kernel aggiornati. I pacchetti del kernel che contengono la correzione devono essere installati e i sistemi riavviati. Per container o sistemi che non possono essere riavviati, considera soluzioni livepatch (es. KernelCare) che hanno preparato patch.
Inoltre, la progettazione del sistema dovrebbe presumere che le interfacce del kernel accessibili dallo spazio utente possano cambiare nel tempo. Limitare CAP_NET_ADMIN e filtrare l'uso di tc sono buone pratiche al di là di questo bug.
Se si è verificata una compromissione, ricostruisci il sistema. La vulnerabilità avvelena solo la cache delle pagine, ma un intruso con privilegi di root potrebbe aver compiuto altre azioni malevole; è necessaria una validazione forense. Non fare affidamento sulle scansioni di integrità dei file dopo l'exploit, perché come notato il PoC lascia intatti i file su disco. Riavviare e applicare le patch è la via sicura per la remediation.
Considerando questi fattori, un tipico vettore CVSS v3.1 è AV:L/AC:L/PR:H/UI:N/S:U/C:N/I:H/A:H, che produce un Punteggio Base di 6.0 (Medio). Nota comunque che CVSS non cattura il fatto che questa vulnerabilità conceda privilege escalation a root, che in pratica è critico. (Alcune fonti hanno calcolato CVSSv4 per bug simili; es. PT DBugs elenca 8.5 su CVSSv4.)
La gravità è spesso valutata come Importante/Critica dai vendor. L'avviso di Red Hat per questa CVE la etichetta come Importante, e AWS la segna come Media (CVSS 6.0). In ogni caso, poiché si ottengono i privilegi di root, il rischio pratico è più alto su sistemi multiutente o condivisi.
Questa vulnerabilità appartiene a una famiglia di bug di page-cache poisoning. Altre CVE notevoli includono:
splice() su una pipe poteva scrivere nella cache delle pagine oltre i limiti COW. Permetteva anche di sovrascrivere file in memoria (senza modifica su disco)./proc/self/mem copy-on-write che permetteva la scrittura locale su mappature di sola lettura.Ciascuno di questi coinvolge un fast-path del kernel che scrive in memoria che credeva di possedere esclusivamente, ma non era così. CVE-2026-46331 è unico in quanto si verifica in net/sched pedit action e sfrutta i namespace utente per aggirare le restrizioni sui privilegi. A differenza di DirtyPipe o Dirty COW, non è necessario alcun processo privilegiato ausiliario (come un sistema malfunzionante) – un singolo utente non privilegiato può innescarlo.
Tutti i riferimenti provengono da fonti attendibili (avvisi vendor, analisi pubblicate, voci CVE/NVD).
act_pedit, calcolare la scrivibilità troppo presto ha permesso la corruzione della cache delle pagine.tc o netlink, l'attaccante crea un qdisc e un filtro su lo che corrisponde a tutti i pacchetti (ad es. match u32 0 0) e allega un'azione pedit con chiavi appositamente create. Ogni chiave ha un tipo di intestazione dinamica (ad es. intestazione IP per un offset L4) e un offset scelto in modo che la posizione di scrittura effettiva (inizio intestazione + offset) si trovi appena oltre l'intervallo coperto da skb_ensure_writable().echo '' > /dev/udp/127.0.0.1/53) per attivare il filtro. Il kernel chiama tcf_pedit_act(), alloca un intervallo COW, quindi itera le chiavi. Almeno una scrittura di una chiave cade al di fuori della regione pre-COW'd, causando la scrittura nella pagecache condivisa./bin/su nel socket tramite sendfile o simile, in modo che il buffer del pacchetto faccia riferimento alle pagine di quel file. La scrittura fuori limite corrompe quindi la copia in memoria di /bin/su (in particolare il punto di ingresso ELF)./bin/su). Poiché il kernel ha iniettato inadvertitamente shellcode che esegue setgid(0); setuid(0); execve("/bin/sh"), eseguire su fornisce una shell di root. Il file su disco non è mai stato alterato, quindi nessuno strumento di integrità dei file su disco mostrerà una modifica.auditd) che mostrano programmi che ottengono CAP_NET_ADMIN tramite userns o che scrivono in /proc/[pid]/uid_map.