Table of Contents

I container condividono un unico kernel. Nel 2026 quattro famiglie distinte di vulnerabilità hanno dimostrato che basta un solo bug del kernel per uscire da un container e raggiungere l’host. Copy Fail, Dirty Frag, Fragnesia e CVE-2026-80521 assegnano i privilegi di root a un utente locale non privilegiato. Tutte superano il confine del container.

La parte scomoda non sono i bug in sé. È il costo sempre più basso con cui l’AI li trova e il fatto che una patch abbia creato un nuovo bug.

Questo articolo spiega come i container isolano i carichi di lavoro, perché oggi l’isolamento poggia su fondamenta sempre più limitate, cosa fa ogni vulnerabilità del 2026 e quale tecnologia di isolamento conviene usare.

Risultato per il lettore: mappa chi fornisce il codice per ogni carico di lavoro, identifica le funzioni del kernel necessarie e scegli tra container rafforzati e un confine basato su microVM. Considera i casi di studio del 2026 come prove di ricerca datate. Controlla gli avvisi aggiornati dei fornitori prima di cambiare un kernel di produzione.

La risposta breve

DomandaRisposta breve
I container isolano?Sì, per processi e file system. Tutti condividono un kernel, quindi i bug del kernel sono un rischio comune
Perché proprio adesso?L’AI ha ridotto il costo della ricerca di difetti nel kernel. A settembre 2026 risultano pubblicate quasi 6.000 CVE del kernel
Cosa supera il confine?Qualsiasi escalation locale dei privilegi nel kernel. L’evasione non richiede una configurazione errata del container
Basta applicare le patch?È necessario, ma la velocità non basta più. Una patch del 2026 ha introdotto un nuovo bug sfruttabile
Cosa funziona meglio?MicroVM come Firecracker o Kata Containers, che assegnano un kernel separato a ogni carico di lavoro
L’alternativa è perfetta?No. Anche l’hypervisor è codice. La superficie di attacco è inferiore di molti ordini di grandezza, e la differenza conta

Come isolano i container

Per capire il confine, occorre capire cosa non è un container.

Un container non è una macchina virtuale. Tra il processo e l’hardware non ci sono un secondo kernel, hardware emulato o un hypervisor. Quando esegui un’immagine container, avvii un processo sul kernel esistente con una vista modificata del sistema.

Il meccanismo è la system call clone. Mentre fork copia lo spazio degli indirizzi di un processo, clone crea un processo figlio e dà al chiamante un controllo preciso su quali parti del contesto di esecuzione condividere e quali sostituire. Docker passa a clone un insieme di namespace:

NamespaceCosa simula
MountUna radice privata del file system, così il container vede il proprio albero invece del tuo
PIDUna numerazione dei processi separata, quindi PID 1 è il primo processo del container, non systemd
UserUna mappatura delle identità in cui il “root” del container corrisponde a un utente host non privilegiato
NetworkInterfacce, tabelle di routing e porte private
IPCMemoria condivisa e code di messaggi isolate
UTSIl proprio nome host e nome di dominio
CgroupUna vista privata dei limiti delle risorse

Aggiungi un file system union sopra un’immagine e il risultato sembra un computer separato. id nel container restituisce uid=0(root). Il file system sembra un’installazione minima di Ubuntu. L’elenco dei processi mostra soltanto i processi del container.

A livello di system call, nulla di tutto questo è un confine di sicurezza. Quando un processo nel container apre un file, alloca memoria o tocca un socket di rete, lo stesso kernel gestisce la richiesta per ogni container sull’host. I namespace cambiano ciò che il processo vede, non ciò che il kernel farà per lui.

Il kernel è il vero confine tra container e host. Tutto il resto è presentazione.

Diagramma di tre container costruiti sullo stesso kernel. I namespace mount, PID, user e network separano le rispettive viste, mentre tutte le system call continuano a raggiungere un unico kernel condiviso.

Il confine è codice e il codice contiene bug

Ogni azione di un container passa dall’interfaccia delle system call. Aprire un file, leggere la memoria, scrivere su un socket, cambiare un UID: il kernel media tutto, perché non vuole che i processi tocchino direttamente CPU, file system o rete.

La mediazione è il modello di sicurezza, e la mediazione è implementata nel codice. Si tratta di circa 30 milioni di righe.

Un’escalation locale dei privilegi (LPE) si verifica quando un processo sfrutta un difetto nel codice di mediazione per ottenere privilegi mai concessi. Le LPE non sono una novità. Esistono dai primi meccanismi di mediazione del kernel e per decenni il settore ha convissuto con un flusso costante ma contenuto.

Dirty Pipe del 2022 è il riferimento noto a molti. Sfruttava un difetto nella gestione dei pipe buffer per sovrascrivere file di sola lettura. Fece notizia perché bug di questa gravità comparivano all’incirca ogni uno o due anni. Si applicava la patch, si riprendeva il lavoro e si dava per scontato che non ci fossero grandi difetti ancora nascosti nel codice letto da un milione di persone.

Questa ipotesi non regge più.

Cosa è cambiato nel 2026

Il cambiamento non riguarda la bravura degli attaccanti. Trovare bug di corruzione della memoria nel kernel è diventato un’attività ingegneristica invece che una carriera di ricerca.

Tre dati di quest’anno rendono concreto il cambiamento:

Vulnerabilità trovataChi l’ha trovataCome
Copy Fail (CVE-2026-31431)Taeyang Lee, TheoriCon l’aiuto di Xint Code, uno strumento di analisi statica basato sull’AI. Circa un’ora di scansione del sottosistema crittografico Linux
CVE-2026-80521Zhenpeng (Leo) Lin, DepthFirstTrovata con dfs-large1, un modello AI interno addestrato per rilevare vulnerabilità
CVE-2026-80521, indipendentementeKyle, OpenAILo stesso bug, trovato separatamente e segnalato lo stesso giorno

Rileggi la terza riga. Due organizzazioni che usavano strumenti AI diversi hanno trovato lo stesso use-after-free di AF_UNIX e lo hanno segnalato a [email protected] lo stesso giorno. Non è una coincidenza di talento. Un processo ripetibile ha prodotto due volte la stessa risposta.

DepthFirst indica direttamente la portata: quasi 6.000 CVE del kernel erano pubblicate a settembre 2026. Il conteggio cresce in linea con la disponibilità dell’AI, non con il numero di sviluppatori del kernel.

Quando un’ora di scansione AI trova un bug decennale nel sottosistema crittografico, l’economia dello sfruttamento del kernel si è capovolta.

Quattro evasioni in un anno

Ognuna di queste vulnerabilità consente di ottenere root da un account locale non privilegiato. Nessuna richiede una configurazione errata del container, un flag privileged o un accesso iniziale dalla rete.

VulnerabilitàCVESottosistemaPrimitivaScoperta da
Copy FailCVE-2026-31431algif_aead / AF_ALGScrittura di 4 byte nella page cache di qualsiasi file leggibileTheori, con AI
Dirty FragCVE-2026-43284 + CVE-2026-43500XFRM ESP, RxRPCScrittura di 4 byte nella page cache tramite due varianti concatenateHyunwoo Kim
FragnesiaCVE-2026-46300XFRM ESP-in-TCPScritture di singoli byte nella page cacheHyunwoo Kim
AF_UNIX UAFCVE-2026-80521Socket AF_UNIXUse-after-free nel garbage collection di unix_vertexDepthFirst, con AI

Tutte e quattro condividono un modello che merita attenzione. Attaccano la page cache, non il disco.

Copy Fail: un difetto logico senza race

Copy Fail è la più semplice delle quattro ed è la più allarmante.

Quasi tutte le LPE Linux richiedono una finestra temporale o un offset di memoria specifico del kernel. Copy Fail non richiede né l’una né l’altro. È un difetto logico lineare in algif_aead, il modulo che fornisce ai processi utente l’accesso alla cifratura autenticata tramite AF_ALG.

La catena usa splice() per inserire una pagina della page cache nell’operazione, poi sfrutta il percorso AEAD in-place per scrivere quattro byte controllati in quella pagina. La pagina corrotta non viene mai contrassegnata come dirty, quindi non viene mai riscritta sul disco. Il file su disco resta intatto, perciò i controlli di checksum e integrità passano anche se la copia in memoria contiene la modifica.

Un programma Python di 732 byte ottiene root su ogni distribuzione Linux rilasciata dal 2017. Il bug fu introdotto da un’ottimizzazione del 2017 in algif_aead; la patch del 2026 si limita a rimuoverla. Commit mainline a664bf3d603d.

Il bug è rimasto in ogni distribuzione principale per quasi un decennio. Uno strumento AI l’ha trovato in circa un’ora.

Dirty Frag: due varianti che si completano a vicenda

Il nome Dirty Frag ne descrive con precisione la parentela. Dirty Pipe sovrascrive struct pipe_buffer. Dirty Frag sovrascrive il campo frag di struct sk_buff.

Sono due vulnerabilità concatenate, ed è proprio questa concatenazione la parte intelligente:

  • CVE-2026-43284 sfrutta esp_input() che salta il percorso copy-on-write prima di eseguire la decrittazione in-place su un frammento inserito con splice. Richiede il privilegio di creare uno user namespace, limitato da alcune distribuzioni.
  • CVE-2026-43500 sfrutta rxkad_verify_packet_1() che esegue una decrittazione in-place sul frammento. Non richiede privilegi per gli namespace, ma il modulo rxrpc manca nella maggior parte delle distribuzioni. Ubuntu lo carica per impostazione predefinita.

Ogni variante, da sola, ha un punto cieco. Insieme si completano. Se gli user namespace sono consentiti, agisce prima il percorso ESP. Se è bloccato ma rxrpc è presente, agisce il percorso RxRPC. Un solo eseguibile funziona quindi su diverse distribuzioni. La variante RxRPC ottiene root azzerando un campo in /etc/passwd e lasciando che PAM con nullok accetti una password vuota.

Il dato più importante per chi difende: Dirty Frag funziona indipendentemente dalla disponibilità di algif_aead. La diffusa mitigazione di Copy Fail che blocca il modulo non protegge affatto da Dirty Frag.

Fragnesia: la patch che ha creato un bug

Fragnesia appartiene alla stessa classe di Dirty Frag, ma attacca il percorso XFRM ESP-in-TCP. È il caso più istruttivo del gruppo.

La vulnerabilità sfrutta una gestione errata dei frammenti di pagina condivisi durante la coalescenza di skb. Un attaccante inserisce pagine supportate da file nella coda di ricezione TCP con splice(), prima che il socket passi alla modalità di protocollo di livello superiore espintcp. Quando ESP si attiva, il kernel decritta i dati accodati in-place e la manipolazione del keystream AES-GCM corrompe la page cache. L’attaccante ottiene scritture ripetute di un singolo byte nelle pagine dei file in cache.

L’exploit ottiene root sovrascrivendo i primi byte di /usr/bin/su con un piccolo payload ELF. La modifica esiste solo in memoria e non tocca mai il binario su disco.

Gli user e network namespace non privilegiati forniscono CAP_NET_ADMIN all’interno di uno namespace isolato; poi NETLINK_XFRM installa una security association preparata ad hoc.

Fermati su questa frase: Fragnesia è emersa come effetto collaterale involontario di una delle patch per le vulnerabilità Dirty Frag originali. La correzione di Dirty Frag ha prodotto un nuovo bug root sfruttabile in modo indipendente.

CVE-2026-80521: l’evasione dal container che ha vinto kernelCTF

La race di AF_UNIX chiude ogni discussione sul fatto che sia solo teorica.

La vulnerabilità è un heap use-after-free nel garbage collector dei messaggi SCM_RIGHTS, che i processi usano per passarsi i file descriptor. Durante la raccolta di un riferimento circolare a un socket, una race libera struct unix_vertex mentre l’anello SCC di un socket sopravvissuto conserva ancora un puntatore all’oggetto. Il passaggio di raccolta successivo percorre l’anello obsoleto e dereferenzia memoria liberata.

Il motivo per cui conta oltre Linux in generale: AF_UNIX è alla base dell’IPC locale. Database locali, systemd e Docker stesso dipendono da AF_UNIX. DepthFirst segnala che la vulnerabilità colpisce la maggior parte dei sandbox a livello di sistema operativo basati sul kernel, inclusi nsjail, Firejail e Bubblewrap, oltre ai runtime container moderni.

DepthFirst ha ottenuto uno slot Google kernelCTF con questo bug il 24 luglio 2026, ha ricevuto conferma nello slot lts-6.12.95 il 5 agosto, l’ha segnalato a [email protected] quello stesso giorno e ha scoperto che Kyle di OpenAI aveva segnalato lo stesso bug. La patch upstream è arrivata il 6 agosto. La ricerca è stata pubblicata il 22 settembre.

Il gruppo ha rilasciato un exploit funzionante per Ubuntu 26.04 e un secondo exploit per evadere da Ubuntu 24.04 tramite CVE-2026-52910.

Diagramma di un processo non privilegiato dentro un container che corrompe una pagina della page cache per modificare in memoria un binario setuid. Il processo ottiene root e supera il confine del container fino al kernel host.

Perché i consigli di mitigazione continuano a fallire

Quest’anno chi difende ha ricevuto tre serie di workaround, e ciascuna era in parte errata.

MitigazioneCosa bloccaCosa non risolve
Bloccare algif_aeadCopy FailNulla di Dirty Frag, che ignora completamente il modulo
Bloccare esp4, esp6 e rxrpcDirty Frag e FragnesiaI team che hanno bisogno di IPsec. Inoltre non copre nuovi sottosistemi
Limitare gli user namespace non privilegiatiLe varianti ESPLa variante RxRPC non richiede uno namespace. La policy AppArmor è solo una mitigazione parziale
Applicare la patch al kernelIl bug correttoIl bug successivo e quelli introdotti da una patch

Emergono due modelli.

Primo, i workaround sono in conflitto. Copy Fail si mitiga disabilitando algif_aead. Dirty Frag si attiva anche quando il modulo è assente. Fragnesia richiede di disabilitare esp4 e esp6, un problema per chi usa IPsec. Non esiste una singola blacklist di moduli che copra l’intera famiglia.

Secondo, e peggio, applicare patch non è una vittoria sicura. Fragnesia è stata introdotta dalla patch per Dirty Frag. Ogni patch può portare nuovi errori logici e, in questo sottosistema, un errore logico diventa un exploit root.

La conclusione scomoda: tutte queste vulnerabilità sono nella page cache, raggiungibili da codice non privilegiato e trovate con strumenti che migliorano ogni trimestre. Nessuna blacklist resta completa.

La controargomentazione, affrontata con onestà

C’è un’obiezione legittima a cui dare una risposta diretta: anche gli hypervisor hanno bug.

La superficie di attacco KVM è reale. Google gestisce kvmCTF proprio per trovare questi bug e offre premi consistenti:

LivelloRicompensa
Evasione completa dalla VM$250,000
Scrittura arbitraria in memoria$100,000
Lettura arbitraria della memoria$50,000
Scrittura relativa in memoria$50,000
Denial of Service$20,000
Lettura relativa della memoria$10,000

I premi non si sommano. Il bersaglio è un kernel Linux LTS con KVM, il guest è Debian 12.5. L’obiettivo è un attacco dal guest all’host.

Hyunwoo Kim, lo stesso ricercatore che ha trovato Dirty Frag, raccoglie anche premi KVM e ha vinto i $250,000 per un’evasione completa dalla VM. La sintesi onesta è che entrambe le componenti hanno difetti e che a volte li trova la stessa persona.

Ma confronta le dimensioni:

Kernel LinuxHypervisor KVM
CVE nel 2026Quasi 6.000Poche, con singoli ricercatori che ne trovano alcune ogni anno
Raggiungibile daQualsiasi processo non privilegiato tramite l’interfaccia delle system callSolo codice già in esecuzione dentro un guest
Superficie di attaccoTutto: rete, file system, crittografia, IPC, driverInterfaccia dei dispositivi virtuali e hypercall
Classe di bugQualsiasi difetto di memoria o logica in 30 milioni di righeLimitata al confine della virtualizzazione

La differenza è di molti ordini di grandezza, non un fattore due. È per questo che le microVM cambiano il calcolo del rischio.

Cosa offre un confine reale

Una microVM fornisce a ogni carico di lavoro una propria istanza del kernel, in esecuzione su virtualizzazione imposta dall’hardware, invece di condividere il kernel host tramite namespace.

Lo stack ha tre livelli da conoscere:

  • La CPU fornisce meccanismi hardware per isolare regioni di memoria.
  • KVM espone questi meccanismi al kernel Linux, che opera così come hypervisor.
  • Una VMM (virtual machine monitor), come Firecracker o QEMU, controlla KVM per creare ed eseguire il guest.

Poiché il guest esegue un proprio kernel, un exploit del kernel dentro il guest compromette solo il guest. Non c’è un kernel condiviso da attaccare. L’attaccante dovrebbe poi evadere dall’hypervisor, la superficie più piccola in cui si trovano i bug KVM.

Nella pratica contano due implementazioni, entrambe citate nelle raccomandazioni DepthFirst:

TecnologiaApproccioNote
FirecrackerVMM progettata appositamente, con modello dei dispositivi minimoRealizzata da AWS per l’isolamento multi-tenant su larga scala
Kata ContainersRuntime compatibile OCI che racchiude una microVMEsegue immagini container standard con un confine VM sottostante

Per la maggior parte dei team Kata è la migrazione più semplice, perché accetta le immagini e gli strumenti container già in uso. Firecracker ha una superficie di attacco più piccola, perché emula molti meno dispositivi di una VMM generica.

Diagramma che confronta l'isolamento dei container tramite namespace su un kernel condiviso con quello delle microVM, dove ogni carico di lavoro esegue un proprio kernel sopra KVM e un virtual machine monitor.

Cosa fare adesso

Non tutti i container richiedono una microVM. La scelta dipende da chi esegue il codice al loro interno.

SituazioneRischioAzione
Esegui codice tuo, single tenantBassoMantieni i container. Applica subito le patch, rimuovi le capability e usa un file system root in sola lettura
Host multi-tenant, accesso shell per utentiAltoSposta i carichi di lavoro non attendibili nelle microVM. È il primo caso indicato da DepthFirst
Runner CI che eseguono PR non attendibiliAltoUna pull request può diventare root sul runner. Isola ogni job nella propria VM
Notebook, sandbox per agenti e serverlessAltoIl codice del tenant diventa root sull’host. Una microVM per tenant
Cluster KubernetesElevatoLa page cache è condivisa sull’host. Un pod con le primitive corrette compromette il nodo e supera i confini tra tenant

Il principio comune è semplice. I container sono ottimi per packaging e isolamento dei processi. Non sono mai stati progettati per contenere codice ostile; il settore li ha usati silenziosamente per questo scopo perché erano comodi ed economici.

Rafforzamenti sempre utili

Nessuna di queste misure sostituisce un confine VM, ma tutte eliminano percorsi d’attacco facili:

# Disable the modules the page-cache family abuses, where they are not needed
printf 'install algif_aead /bin/false\ninstall esp4 /bin/false\ninstall esp6 /bin/false\ninstall rxrpc /bin/false\n' \
  > /etc/modprobe.d/harden-pagecache-family.conf
rmmod algif_aead esp4 esp6 rxrpc 2>/dev/null || true
# Restrict unprivileged user namespaces, which gates the ESP variants
# Debian and Ubuntu: this is a partial mitigation, not a complete one
sysctl -w kernel.unprivileged_userns_clone=0

# If exploitation is suspected, drop the page cache to discard modified in-memory binaries
echo 1 | tee /proc/sys/vm/drop_caches
# Detection starting points
- Unexpected unshare(CLONE_NEWUSER) from a workload with no legitimate reason
- NETLINK_XFRM activity, or XFRM security associations appearing outside IPsec hosts
- Requests to bind AF_ALG sockets
- Loads of esp4, esp6, or rxrpc on hosts running neither IPsec nor AFS

Avviso: drop_caches scarta la copia modificata in memoria e rimuove la corruzione, ma non elimina un attaccante che ha già ottenuto root. Trattalo come risposta agli incidenti, non come rimedio.

Il problema della cadenza delle patch

Anche con le migliori intenzioni, applicare patch al kernel è diventato una corsa:

  • Quasi 6.000 CVE pubblicate quest’anno superano per volume la maggior parte delle finestre di manutenzione.
  • Una patch introduce un bug. Fragnesia l’ha dimostrato proprio in questo sottosistema.
  • L’elenco delle mitigazioni scade. Ad aprile la risposta era algif_aead. A maggio non copriva più nulla in Dirty Frag.

Applicare le patch rapidamente è necessario e insufficiente. L’architettura decide se una patch mancata comporta un incidente contenuto o la compromissione dell’host.

La domanda più difficile: chi è l’avversario?

La risposta tecnica è chiara. Quella strategica dipende da una domanda che molti team saltano.

Se il tuo modello di minaccia comprende un utente curioso o uno sviluppatore distratto, i container restano adeguati. Un’evasione richiede l’esecuzione di codice locale e un exploit del kernel. Nessuna delle due è banale, e i costi operativi per trasferire tutto alle microVM sono reali.

Se il tuo modello di minaccia comprende un avversario che esegue codice sulla tua infrastruttura, oggi i container sono solo un rallentatore. Vale la pena citare direttamente la conclusione di DepthFirst:

“La barriera d’ingresso per trasformare queste vulnerabilità in armi è scesa così tanto che dobbiamo presumere che gli attaccanti possano evadere dai container standard a piacimento.”

È un fornitore di sicurezza con un prodotto da vendere che sostiene una specifica architettura, e lo scetticismo è giustificato. L’argomento, però, non dipende dal fornitore. Il conteggio di 6.000 CVE è pubblico, gli exploit sono stati pubblicati e il kernel è condiviso per progetto.

La formulazione onesta: il valore dei container come confine diminuisce contro un attaccante già presente, ma resta invariato contro tutto il resto.

Il verdetto

I container restano lo strumento giusto per packaging, deployment e separazione dei processi. Non sono più un confine di sicurezza affidabile contro codice ostile.

Tre affermazioni, ordinate per livello di certezza:

  1. La premessa tecnica è assodata. I container condividono il kernel host. Tutte e quattro le vulnerabilità di questo articolo hanno superato il confine da un account non privilegiato e gli exploit sono pubblici.
  2. L’AI ha cambiato il ritmo, non il principio. Le LPE del kernel sono sempre esistite. Ora trovarne una costa circa un’ora di scansione AI invece di mesi di lavoro esperto e due organizzazioni hanno scoperto in modo indipendente lo stesso zero-day lo stesso giorno.
  3. La migrazione ha un costo, così come non migrare. Firecracker e Kata comportano overhead, complessità operativa e nuove competenze. La scelta è semplice: accetta l’overhead oppure accetta che un bug del kernel comprometta l’host.

Se gestisci infrastruttura multi-tenant o esegui codice non attendibile, pianifica ora la migrazione alle microVM. Non perché il cielo stia crollando, ma perché la traiettoria è chiara e la migrazione richiede trimestri, non settimane.

Se esegui container single-tenant con codice tuo, mantienili. Applica le patch al kernel più rapidamente, disabilita i moduli che non servono e rivedi la decisione quando entra in gioco codice non attendibile.

L’era in cui il kernel era considerato un confine affidabile senza condizioni sta finendo. Un’infrastruttura che presume che il kernel verrà violato è un’infrastruttura che sopravvive alla violazione.

Punti chiave

  • I container condividono il kernel host. L’isolamento deriva dai namespace della system call clone, non dalla virtualizzazione hardware: un bug del kernel è anche un bug del container.
  • Quattro vulnerabilità del 2026 hanno superato il confine da account locali non privilegiati: Copy Fail, Dirty Frag, Fragnesia e CVE-2026-80521. Tutte attaccano la page cache.
  • A settembre 2026 erano pubblicate quasi 6.000 CVE del kernel, accelerate dagli strumenti AI. Copy Fail è stata trovata in circa un’ora di scansione.
  • Fragnesia è stata introdotta dalla patch per Dirty Frag. Una patch ha creato un nuovo bug root nello stesso sottosistema.
  • Il workaround per Copy Fail non blocca Dirty Frag. Bloccare algif_aead copre una vulnerabilità e nessun’altra della famiglia.
  • CVE-2026-80521 ha compromesso anche nsjail, Firejail e Bubblewrap, non solo i runtime container.
  • Le microVM cambiano il calcolo del rischio fornendo a ogni carico di lavoro un kernel proprio. KVM ha bug, ma la superficie di attacco è inferiore di molti ordini di grandezza.
  • Scegli in base a chi esegue il codice. Codice tuo in un container single-tenant comporta un rischio basso. Codice non attendibile su un host condiviso comporta un rischio di compromissione dell’host.

Prossimi passi

  1. Leggi l’analisi che inquadra il problema e l’exploit pubblicato: I container non sono più un confine di sicurezza - DepthFirst
  2. Consulta l’avviso autorevole e le mitigazioni per la famiglia Copy Fail: CERT/CC VU#260001
  3. Leggi l’analisi tecnica di Dirty Frag per capire la concatenazione e perché la mitigazione algif_aead non funziona: Analisi tecnica di Dirty Frag
  4. Consulta le regole e i premi di kvmCTF per valutare la superficie di attacco dell’hypervisor: Panoramica di kvmCTF
  5. Valuta queste CVE nel tuo ambiente con il nostro strumento lato client: Calcolatore CVSS v3.1
  6. Rafforza ciò che esegui ora: Come proteggere l’ambiente Docker e Kubernetes
  7. Approfondisci il compromesso dell’isolamento: Docker contro macchine virtuali 2026
  8. Riduci i privilegi dove non puoi aggiungere un confine: Gestire il minimo privilegio su Linux

Articoli correlati

ArticoloContenuto
Docker contro macchine virtuali 2026Il confronto architetturale alla base di questo articolo, con i compromessi in termini di prestazioni e sicurezza
Come proteggere l’ambiente Docker e KubernetesRafforzamento pratico del livello container, ancora utile anche dentro una microVM
Docker in LXC su Proxmox: affidabilità, prove e migrazione a VMContainer annidati, prove e indicazioni su quando spostare un carico di lavoro su una VM completa
Capire la virtualizzazione: concetti e applicazioniFondamenti degli hypervisor, incluse le funzionalità CPU necessarie alle microVM
Gestire il minimo privilegio su LinuxRiduzione dei privilegi ottenibili con un’evasione per limitare l’impatto

Riferimenti

  1. I container non sono più un confine di sicurezza - DepthFirst (Zhenpeng Lin, 22 settembre 2026)
  2. CERT/CC Vulnerability Note VU#260001 - Copy Fail (CVE-2026-31431)
  3. Sito ufficiale Copy Fail e analisi dell’exploit
  4. Analisi tecnica di Dirty Frag - Hyunwoo Kim (CVE-2026-43284, CVE-2026-43500)
  5. Fragnesia: escalation locale dei privilegi nel kernel Linux tramite ESP-in-TCP - Wiz (CVE-2026-46300)
  6. Panoramica e premi di kvmCTF - Google
  7. Voce NVD per CVE-2026-31431
  8. Commit upstream mainline della correzione Copy Fail
  9. Avviso di sicurezza Ubuntu: correzioni disponibili per Copy Fail
  10. Exploit kernelCTF e segnalazioni - Google Security Research