Articoli approfonditi sulla tecnologia che plasma il futuro.

Java4Shell: bug Base64 in OpenJDK, 65 byte portano a RCE

Java4Shell: difetto di corruzione della memoria nel decoder Base64 AVX-512 di OpenJDK. Come 65 byte scatenano RCE e come mitigarlo subito.

Illustrazione di un minuscolo difetto luminoso su un nastro trasportatore che corrompe un'enorme macchina industriale
Il componente più piccolo dello stack, un percorso veloce per Base64, si è rivelato quello che cede per primo.

Sessantaquattro lettere A e un singolo segno di uguale. È tutto l'input necessario per corrompere l'heap di un server OpenJDK non aggiornato: una stringa Base64 di 65 caratteri che aggira la famosa sicurezza della memoria di Java e scrive 62 byte oltre la fine di un array. La vulnerabilità, divulgata dalla società di sicurezza Calif come Java4Shell (CVE-2026-114938, CVSS 9.2), non risiede nel codice applicativo ma in assembly scritto a mano, nascosto nel decoder Base64 della JVM. È stata dimostrata un'esecuzione di codice remoto pre-autenticazione contro Keycloak, Jenkins, Jira, Confluence, Artifactory e PingFederate. Se la tua organizzazione usa Java su server x86-64 (e statisticamente succede), questo problema è anche tuo.

Mi occupo di vulnerabilità per lavoro, e la maggior parte si confonde: un altro bug di deserializzazione, un altro bypass dell'autenticazione, un altro path traversal. Java4Shell è diversa, e non per il punteggio. È diversa per dove si trova. Il bug sta in un'ottimizzazione, un'accelerazione per decodificare Base64 con le istruzioni vettoriali AVX-512, di cui quasi nessuna applicazione al mondo ha davvero bisogno. La storia di come è stata trovata, come è stata sfruttata e perché i tuoi proxy potrebbero già proteggerti dice molto su dove sta andando la sicurezza del software.

Il problema: un intrinseco JIT con una maschera difettosa

Per capire il bug, bisogna sapere come OpenJDK rende veloce Base64. La JVM HotSpot tiene d'occhio i metodi più usati e lascia che il suo compilatore C2 li trasformi in codice nativo. Per alcune operazioni va oltre, sostituendo routine assembly ottimizzate a mano, chiamate intrinseche, che usano istruzioni specializzate della CPU. Sui chip x86-64 con supporto AVX-512 VBMI, la decodifica Base64 riceve esattamente questo trattamento: l'intrinseco elabora l'input a blocchi da 256 o 64 byte, usando l'istruzione VMOVDQU8 con una maschera a 64 bit che decide quali byte scrivere nel buffer di destinazione.

Il difetto sta in come viene calcolata quella maschera per la coda con padding dell'input. Base64 riempie l'output con caratteri =, e l'assembly riduce la lunghezza dell'output per ogni byte di padding che incontra. Per certi input malformati, come un = isolato alla fine di un blocco, la lunghezza calcolata va in underflow, diventando -1 o -2. Questo valore negativo finisce in un'istruzione di manipolazione dei bit (bzhiq) che, per input di 64 o più caratteri, lascia la maschera invariata: tutti e 64 i bit a uno. Tutti i bit a uno significano che ogni byte viene scritto.

Vediamo il trigger concreto. Invii 64 A seguite da =, 65 caratteri in totale. La JVM calcola la lunghezza decodificata in 50 byte e alloca un array di 50 byte. L'intrinseco decodifica correttamente i primi 64 caratteri, poi incontra il segno di uguale di troppo, va in underflow sulla lunghezza, imposta la maschera completa e scatena una scrittura vettorializzata di 64 byte che parte vicino alla fine di un buffer di 50 byte. Sessantadue byte di oggetti heap vicini vengono sovrascritti con dati costanti influenzati dall'attaccante. Il codice di validazione di Java alla fine si accorge che l'input non è valido e lancia IllegalArgumentException, ma a quel punto il danno è fatto. Il gestore delle eccezioni sta asciugando il pavimento mentre la casa è già in fiamme.

// Pseudocode of the mask calculation (after Calif's write-up)
input_mask := bzhiq(-1, input_length)
output_len := (input_length / 4) * 3
// handle padding
if input[input_length - 1] == '=':
output_len -= 1
input_mask >>= 1
if input[input_length - 2] == '=':
output_len -= 1
input_mask >>= 1
// For a lone '=' tail, output_len was already 0
// -> now it's -1, and bzhiq(-1, 255) leaves all bits set
output_mask := bzhiq(-1, output_len)   // == -1u64, all 64 bits 1
// evmovdqub then writes all 64 bytes where ~50 were allocated

Un dettaglio conta per la triage: questo codice viene eseguito solo su host x86-64 la cui CPU supporta AVX-512 VBMI. I server ARM come AWS Graviton non eseguono mai lo stub vulnerabile, e nemmeno i Xeon più vecchi. Il percorso di codice vulnerabile compare solo nelle JVM basate su HotSpot: OpenJDK, Oracle JDK, GraalVM. OpenJ9 e Azul Prime, che usano architetture JIT diverse, non sono interessati. Su OpenJDK 17, tra l'altro, il trigger è 128 A più = invece di 64, perché la soglia per entrare nel percorso veloce è più alta. Differenze piccole, ma contano se stai scrivendo regole di rilevamento.

Primo tentativo fallito: «Java è sicuro sulla memoria»

La prima reazione nei canali Slack degli ingegneri, quando la notizia è uscita, è stata di incredulità. Corruzione della memoria, in Java? Non è proprio la sicurezza della memoria il punto? Questa intuizione, secondo cui il runtime è una fortezza e solo il codice applicativo può tradirti, è il primo modello sbagliato, e vale la pena esaminarlo perché condiziona il modo in cui i team verificano i propri stack.

Il linguaggio Java controlla ogni accesso agli array e gestisce ogni allocazione. Ma il runtime Java è un'enorme base di codice C, C++ e assembly. I compilatori JIT, i garbage collector, gli intrinseci, il codice delle native image: tutto viene eseguito con il pieno e non mediato potere del processo, e nulla di tutto questo gode delle garanzie che offre al tuo bytecode. Ogni intrinseco è un piccolo buco aperto nel muro di sicurezza in nome della velocità, e quei buchi sono mantenuti da un numero relativamente ridotto di ingegneri della VM. È la stessa lezione strutturale di il bug dell'asterisco SSH in Alpine Linux, vecchio di un decennio: i difetti più spaventosi vivono nel codice da cui tutti dipendono e che quasi nessuno legge.

C'è un punto cieco negli audit di sicurezza che vedo continuamente. I team fanno fuzzing sui propri parser JSON, pen-test sui gestori REST e analisi statica su ogni riga che hanno scritto, poi trattano il JDK come una scatola nera perché è maturo, largamente diffuso e mantenuto da persone brillanti. La maturità non è una difesa. Spesso è l'opposto: decenni di ottimizzazioni accumulate, ognuna sensata al momento, ognuna delle quali aggiunge superficie d'attacco distribuita a tutti, che ne traggano beneficio o no. L'intrinseco AVX-512 per Base64 esiste per accelerare applicazioni che decodificano enormi volumi di dati. La tua API REST che decodifica un header di autenticazione da 200 byte eredita il rischio e ottiene praticamente nessun vantaggio. Calif lo chiama «tragedia dei beni comuni», e ha ragione: tutti quelli che avevano bisogno della funzione ne hanno tratto beneficio, tutti gli altri hanno ricevuto solo il bug.

Secondo tentativo fallito: «La scrittura è troppo vincolata per essere sfruttata»

Il secondo modello sbagliato è venuto da chi ha letto i dettagli tecnici e si è rilassato. Una sovrascrittura con valore costante, a offset fisso, senza controllo sui byte scritti? Molti bug del genere finiscono archiviati come «solo crash» e declassati. Questa liquidazione è comprensibile ma sbagliata, e il motivo per cui è sbagliata è la parte più istruttiva di tutta la vicenda.

Lo sfruttamento moderno non riguarda ciò che una singola primitiva può fare, ma ciò che il sistema circostante può essere spinto a organizzare intorno ad essa. La tecnica di Calif è stata l'heap grooming: modellare da remoto il comportamento dell'allocatore in modo che un oggetto prevedibile e utile finisca subito dopo il buffer sovrascritto. L'hanno fatto via rete, usando i tempi delle richieste per controllare quando avvengono allocazioni e deallocazioni sul bersaglio. La scrittura può avere un valore costante, ma se controlli quale oggetto si trova nel raggio d'esplosione, controlli cosa viene corrotto. Da lì hanno costruito una divulgazione di memoria in stile Heartbleed, hanno estratto abbastanza dati da aggirare ASLR e li hanno concatenati fino a un'esecuzione di codice remoto completa.

Griglia astratta di blocchi di memoria disposti secondo uno schema deliberato, con un unico blocco rosso al centro
Il heap grooming trasforma una scrittura vincolata e a valore costante in un'arma, controllando su cosa finisce la scrittura.

C'è un dettaglio deliziosamente pragmatico nel write-up su come farlo funzionare su internet vera. Il heap grooming remoto è sensibile al round-trip time e al jitter: servono richieste che arrivino con un ritmo preciso perché l'allocatore si trovi nello stato desiderato. Invece di fare reverse engineering dello stack TCP, i ricercatori hanno noleggiato una VM nella stessa regione cloud del bersaglio. Hanno risolto un problema di fisica con i soldi. Ho visto sviluppatori di exploit d'élite fare versioni di questo per anni, ed è un buon promemoria del fatto che i vincoli dell'attaccante sono economici tanto quanto tecnici. Un avversario ben finanziato considera il jitter di rete una voce di bilancio.

Va notato anche che non esiste un exploit universale. Ogni applicazione (Jira, Jenkins, Keycloak) usa Base64 in modo diverso, alloca in modo diverso, espone superfici di grooming diverse. È la buona notizia. La cattiva è l'enorme varietà di punti d'ingresso. Header di autenticazione, campi di upload di file, gestione dei certificati client, payload dei messaggi: ovunque il testo Base64 entri nella JVM è un potenziale trigger. Un contributore ha persino dimostrato una variante lato client: un'applicazione Java che apre una connessione TLS verso un server malevolo può essere compromessa senza esporre alcun servizio. I tuoi job batch e gli strumenti interni rientrano nel perimetro, non solo i gateway esposti su internet.

Il centauro nella stanza: l'IA ha trovato questo in un'ora

Ora la parte che dovrebbe ricalibrare il modello di minaccia di ogni team di sicurezza. Il ricercatore Quang Luong ha trovato la vulnerabilità in circa un'ora e aveva un exploit funzionante circa due ore dopo. Costo totale dei token IA: meno di 200 dollari. Il suo metodo è stato indirizzare un agente di programmazione IA verso le aree di HotSpot dove la complessità attraversa i confini (il JIT, gli intrinseci, le API raggiungibili da molti punti, la crittografia) e poi filtrare il rumore. La maggior parte di ciò che l'agente ha segnalato era codice irraggiungibile e spazzatura. Ha continuato a dare istruzioni e, dopo venti minuti di insistenza, è comparso il problema di Base64.

Calif lo descrive come «hacker centauro»: l'essere umano fornisce l'intuito su dove i sistemi complessi sbagliano, l'IA fornisce la resistenza. Penso che sia un'osservazione accurata, e penso che le implicazioni vadano in entrambe le direzioni. Lo stesso ciclo che ha trovato Java4Shell è accessibile a chiunque abbia una chiave API, e la fase di sviluppo dell'exploit (costruire pipeline di grooming riutilizzabili e poi lasciare che gli agenti macinino catene specifiche per ogni applicazione) è sempre più automatizzabile. L'economia della ricerca di bug in C e assembly maturi e ampiamente diffusi è appena crollata. I difensori dovrebbero dare per scontato che la prossima decina di bug di classe Java4Shell sia già cercata da persone che non inviano segnalazioni. È la pressione dietro dibattiti come le scadenze di divulgazione sempre più corte di Project Zero: quando la scoperta diventa economica, la finestra per la patch è tutta la partita.

La contromossa proposta da Calif è provocatoria e in gran parte la condivido: usare la stessa leva dell'IA per eliminare codice invece di aggiungerne. La chiamano «vibe-uncoding», cioè verificare una codebase alla ricerca di funzionalità morte, supporto a protocolli antichi e ottimizzazioni inutili, per poi rimuoverli e ridurre la superficie d'attacco. L'obiezione onesta è che eliminare è rischioso: funzionalità apparentemente inutilizzate hanno dipendenze nascoste, e la rimozione richiede test che i team sottofinanziano cronicamente. Ma la direzione è giusta. Se il tuo JDK include un percorso veloce in assembly scritto a mano per un carico di lavoro che non avrai mai, la postura di sicurezza ottimale è non distribuire affatto quel percorso. In alternativa, la JVM ti offre almeno un interruttore per disattivarlo. Il che ci porta a ciò che funziona davvero.

Cosa funziona davvero: patch, flag, proxy

Questa è la parte che interessa al tuo turno di reperibilità. Le correzioni si dividono in tre livelli, e direi che dovresti farne almeno due oggi, non dopo la prossima finestra di modifica.

  1. Applica la patch a una build OpenJDK corretta. La correzione upstream (commit JDK 5177a70) sistema il calcolo della maschera. È l'unica soluzione completa. Le versioni interessate partono dalla 17.0.6 nella linea 17 e continuano fino alle release attuali della 21 e successive; controlla la lista delle versioni corrette per la tua specifica linea e tratta ogni JVM HotSpot (OpenJDK, Oracle JDK, GraalVM) come interessata finché non è verificato il contrario.
  2. Disabilita l'intrinseco come controllo provvisorio. Avvia la JVM con -XX:-UseBASE64Intrinsics per disattivare completamente la decodifica Base64 accelerata via hardware. Il costo in prestazioni è trascurabile, a meno che tu non decodifichi gigabyte di Base64, cosa che quasi nessuno fa. In alternativa, -XX:UseAVX=2 disabilita AVX-512 su x86-64, ma non impostare questo flag su ARM, dove la JVM si rifiuterà di avviarsi. È la stessa filosofia del playbook per le CVE di PHP: quando il componente vulnerabile è un percorso veloce ristretto e sostituibile, eliminare il percorso veloce batte aspettare.
  3. Usa i proxy per rompere la temporizzazione dell'exploit. La sezione dei limiti di Calif osserva che gli attuali profili di grooming remoto si basano su corpi di richiesta parziali che raggiungono l'applicazione con tempi precisi. Un reverse proxy che bufferizza l'intero corpo della richiesta, cosa che nginx fa di default, distrugge quella temporizzazione. Non è affatto una correzione, ma degrada in modo significativo il percorso d'attacco più pratico mentre applichi le patch.

Anche il rilevamento merita una frase. Semgrep ha pubblicato script gratuiti che verificano la combinazione di condizioni che rende un host sfruttabile: una VM della famiglia HotSpot, hardware x86-64 con il supporto alle istruzioni rilevanti e una versione nell'intervallo vulnerabile. Eseguili sull'intera flotta prima di dare per scontato di essere esposto: i container basati su ARM e gli ultimi server OpenJ9 sono al sicuro, e saperlo subito fa risparmiare un weekend. Quando fai la scansione, ricorda che le linee di versione contano: la correzione è arrivata in specifiche release di patch per ogni linea, quindi «siamo sulla 21» non è una risposta.

Tre livelli difensivi concentrici che proteggono un nucleo luminoso, con una mano che aziona un interruttore sull'anello più interno
Stratifica le difese: applica la patch al nucleo, elimina il percorso veloce e lascia che il proxy rompa la temporizzazione dell'attaccante.

La lezione più grande: le ottimizzazioni sono passività che non hai verificato

Allontanandoci dalla risposta all'incidente, Java4Shell lascia un residuo scomodo. Il bug non stava in qualche angolo oscuro di una funzione secondaria. Stava in Base64, probabilmente l'operazione più noiosa, più onnipresente e più «sicuramente va bene ormai» dell'informatica. La vulnerabilità esisteva proprio perché qualcuno ha reso veloce la cosa noiosa, usando le istruzioni vettoriali più recenti, in assembly, con un caso limite nella gestione della coda sopravvissuto alla code review. Ogni runtime maturo è pieno di queste cose. Ognuna di esse ora è cacciata da agenti instancabili che costano meno di una bella cena.

Tutti chiedono cosa può costruire l'IA. La domanda di sicurezza migliore potrebbe essere cosa può aiutarci a eliminare.

La mia opinione: il settore sta per imparare la differenza tra codice verificato e codice dato per sicuro, e la lezione costerà cara. Le librerie standard, gli intrinseci delle VM, i codec di compressione, i decoder di immagini (gli strati fondamentali che non mettiamo mai in discussione) sono esattamente dove l'attenzione umana è più scarsa e dove la caccia assistita dall'IA paga le taglie più alte. Il modello centauro non trova solo bug più in fretta; li trova in punti che i ricercatori umani hanno saltato perché il valore atteso di auditare codice «risolto» sembrava troppo basso.

Quindi applica le patch alle tue JVM, attiva il flag dell'intrinseco dove non puoi aggiornare, e lascia che nginx ti compri tempo. Ma vai anche a guardare il tuo albero delle dipendenze e fatti la domanda da uncoding: quali di queste funzionalità abbiamo ereditato invece di sceglierle? La stringa di 65 caratteri che ti brucerà il weekend è probabilmente già stata scritta. L'unica domanda è se chi la tiene in mano invierà una segnalazione o no.