
Java4Shell: 65 byte di Base64, un'allocazione di 50 byte e 62 byte scritti oltre la sua fine
- GoogleNUOVOGoogle: Gemini 4 Carbon2026-11-10$2.00 / $10.00 per 1M di token · 89 tok/s
- AnthropicNUOVOAnthropic: Claude Fable 5.22026-11-09$8.00 / $40.00 per 1M di token · 97 tok/s
- orcaNUOVOOrca: OrcaC2 1.02026-11-079 tok/s
- OrcaNUOVOOrcaCyber: GLM 5.3 Abliterated / Uncensored2026-11-04$3.00 / $5.00 per 1M di token · 88 tok/s
- OrcaNUOVOOrcaCyber: Hy4 Abliterated / Uncensored2026-11-04$0.80 / $1.60 per 1M di token · 134 tok/s
- OrcaNUOVOOrcaCyber: Kimi K3.1 Pro Abliterated / Uncensored2026-11-04$2.00 / $5.00 per 1M di token · 87 tok/s
- OrcaOrcaCyber: MiniMax M3.1 Flash Abliterated / Uncensored2026-10-29$0.80 / $1.60 per 1M di token · 121 tok/s
- OrcaOrcaCyber: GLM 5.3 Flash Abliterated / Uncensored2026-10-27$0.80 / $1.60 per 1M di token · 68 tok/s
- OrcaOrcaCyber: Qwen3.8 Flash Next Abliterated / Uncensored2026-10-26$0.80 / $1.60 per 1M di token · 90 tok/s
- OrcaOrcaCyber: MiMo V2.6 Flash Abliterated / Uncensored2026-10-26$0.80 / $1.60 per 1M di token · 44 tok/s
- MoonshotMoonshotAI: Kimi K3.1 Pro2026-10-2447Intelligenza
- OrcaOrcaCyber: DeepSeek V4.1 Flash Abliterated / Uncensored2026-10-23$0.80 / $1.60 per 1M di token · 195 tok/s
- minimaxMiniMax: M3.1 Flash2026-10-1929Intelligenza
- OrcaOrca: OrcaCyber Ultra 1.02026-10-17$5.00 / $10.00 per 1M di token · 120 tok/s
- deepseekDeepSeek: DeepSeek V4.1 Flash 10172026-10-1733Intelligenza
- DeepSeekDeepSeek: DeepSeek V4.1 Flash2026-10-1740Intelligenza
- DeepSeekDeepSeek: DeepSeek V4.1 Flash 09102026-10-17$0.15 / $0.60 per 1M di token · 187 tok/s
- OrcaOrca: OrcaCyber Zero 1.52026-10-10$3.00 / $7.50 per 1M di token · 143 tok/s
- openaiOpenAI: GPT-6.1 Sol2026-09-2955Intelligenza
- anthropicAnthropic: Claude Sonnet 5.52026-09-2855Intelligenza
L'input è lungo 65 byte: 64 "A" maiuscole e un singolo segno di uguale. OpenJDK lo decodifica in un buffer a cui assegna una dimensione di 50 byte, quindi l'intrinseca Base64 di HotSpot scrive 64 byte, a partire dall'offset 48. Sessantadue di essi finiscono nell'heap, al di fuori dell'array a cui erano destinati, in un linguaggio la cui promessa centrale è che questo non può accaderti. Calif ha pubblicato la catena il 17 novembre 2026 come Java4Shell, tracciata come CVE-2026-114938, e OpenJDK e Oracle hanno distribuito le correzioni lo stesso pomeriggio. La scoperta viene riportata come assistita dall'IA; il modello specifico nominato nei resoconti è GPT-6 Cyber, il modello OpenAI ottimizzato per la sicurezza rilasciato il 5 novembre 2026. Questa attribuzione è la parte più interessante e meno assestata della storia, e vale la pena tenerla separata dal bug, che è accertato e grave.
Cosa ha sbagliato l'intrinseco
Java è memory-safe a livello di linguaggio e non al livello che contava qui. HotSpot accelera Base64 con assembly x86-64 scritto a mano, perché il normale Java compilato non è abbastanza veloce per il carico di lavoro in cui il throughput di decodifica è il collo di bottiglia. La routine elabora l'input in blocchi da 256 byte, ripiega su blocchi da 64 byte e, per code più corte di 64 byte, usa evmovdqub — la forma AVX-512 di VMOVDQU8 — con una maschera di scrittura a 64 bit che decide quali dei 64 byte nel registro vettoriale raggiungono effettivamente la memoria.
Quella maschera viene costruita a partire dalle lunghezze di input e output, poi adattata per il padding Base64. La spiegazione illustra passo passo l'aritmetica: la lunghezza di output è (input_length / 4) * 3, poi viene decrementata una volta per un = finale e ancora una volta per un secondo =. Per le code con padding =, ==, X=, X==, XY= e ===, la lunghezza decodificata è zero, e la correzione del padding sottrae quindi da zero. Il valore va in underflow a -1 o -2. Il calcolo della maschera non lo limita, quindi la maschera diventa tutta a uno e vengono scritti tutti i 64 byte.
Il buffer era dimensionato correttamente. L'allocazione a runtime per un input di 65 byte è (ceil(65 / 4) * 3) - 1, ovvero 50 byte. Lo spill inizia all'offset 48 — la posizione in cui sarebbero finiti i byte decodificati finali — quindi vengono sovrascritti 62 byte dell'heap adiacente. I byte da 48 a 63 di quello spill sono sempre 0x9a. Solo i primi due byte sono sotto il controllo dell'attaccante, e solo parzialmente. Il decoder rifiuta comunque l'input e Java lancia comunque IllegalArgumentException. La scrittura avviene prima del rifiuto. Su OpenJDK 17 la soglia per raggiungere il percorso di codice interessato è più alta, quindi il trigger pubblicato lì è 128 A più il segno di uguale.
Una scrittura fissa di 62 byte di dati perlopiù costanti non sembra una primitiva di esecuzione remota di codice, e di per sé non lo è. Quella costruita da Calif è una catena:
• Prima, organizza l'heap in modo che lo spill finisca sul campo length di un array adiacente. Quell'array diventa un writer la cui lunghezza dichiarata è ora molto più grande del suo contenuto, il che trasforma la scrittura fissa in una scrittura limitata e a valore scelto.
• In secondo luogo, corrompere la lunghezza di un secondo array i cui dati vengono ricopiati nella risposta HTTP. Tale array è un lettore, e i contenuti dell'heap che restituisce diventano la primitiva di divulgazione. Calif definisce la fase che precede l'esecuzione del codice di questa JavaBleed: memoria heap che può contenere dati personalmente identificabili, chiavi private, token di sessione o altri segreti.
In terzo luogo, ripara gli oggetti danneggiati dalla scrittura lineare affinché la JVM continui a funzionare, usa gli originali divulgati per ripristinare header e elementi adiacenti, ed escala la scrittura limitata in scritture arbitrarie che raggiungono la Code Cache e gli hook della JVM.
• Quarto, apportare la modifica specifica per l'applicazione e verificarla tramite una richiesta live. Il documento si ferma prima di quest'ultimo passaggio per i singoli prodotti e afferma che le catene weaponizzate restano private finché gli utenti non hanno avuto la possibilità di aggiornare.
Il livello di grooming è la parte che rende questo attacco remoto anziché locale. G1 divide l'heap in regioni fisse, HotSpot assegna a ogni thread un buffer di allocazione privato, e l'attaccante non può vedere nulla di tutto ciò. La risposta di Calif è quella vecchia — spruzzare coppie di writer e reader finché l'output del decoder non finisce accanto a una di esse — più un trucco specifico per HTTP: inviare il corpo della richiesta fino al punto in cui avviene l'allocazione critica, attendere l'acknowledgement TCP, poi inviare il resto. I pacchetti piccoli sono più stabili di uno grande, il che offre sia controllo sull'allocazione sia controllo sui tempi. L'attacco è sensibile al round-trip time e al jitter; nel loro ambiente di test l'hanno risolto affittando una VM nella stessa regione del target invece di ottimizzare uno stack TCP.
Serio, e più ristretto di quanto il nome suggerisca.
Due vincoli riducono drasticamente l’esposizione, ed entrambi vale la pena dichiararli prima che qualcuno apra un incident bridge.
Il primo è la versione. Java4Shell colpisce OpenJDK 17.0.6 e le versioni successive, e quindi ogni distribuzione basata su di esso: Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, BellSoft Liberica, SAP SapMachine, Red Hat OpenJDK, Oracle OpenJDK, Oracle Java SE e Oracle GraalVM for JDK. L'elenco di Oracle delle build Java SE interessate è 8u511b33-perf, 17.0.21.0.3, 21.0.13.0.3, 25.0.5.0.3 e 27.0.1.0.3. Qualsiasi versione precedente alla 17.0.6 nella linea OpenJDK non rientra nel percorso di codice interessato.
Il secondo è il silicio. La routine vulnerabile è assembly AVX-512 VBMI, quindi esiste solo su chip x86-64 che implementano quelle istruzioni. ARM64 non è affatto interessato, il che elimina in una riga ogni deployment Graviton, Ampere e Apple silicon dalla popolazione. Sul fronte Intel l'elenco è Xeon Ice Lake, Sapphire Rapids, Emerald Rapids e Granite Rapids; su AMD è EPYC e Ryzen da Zen 4 in poi. Calif pubblica il controllo:
grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'
Tutti e quattro i flag devono comparire. Questa è una vera riduzione del perimetro, ma i chip interessati sono esattamente quelli che hanno popolato le flotte cloud tra il 2021 e il 2025, quindi «richiede Sapphire Rapids» non è rassicurante come sembra. Un servizio Java su Graviton è al sicuro. Lo stesso servizio su un'istanza Intel di generazione corrente rientra nel perimetro, e così anche l'istanza Jira, Confluence, Keycloak, Jenkins, Artifactory o PingFederate che si trova dietro di esso, perché Calif ha dimostrato RCE pre-autenticazione nella configurazione predefinita di ciascuna.
L'elenco degli impatti dimostrati si suddivide nettamente. Pre-autenticazione: Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins e PingFederate. Post-autenticazione: Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit e Netflix Spinnaker. Sono state sfruttate anche applicazioni di esempio Apache Struts e Spring Boot. Gli elenchi sono esplicitamente non esaustivi, e un dettaglio conta più dei nomi dei prodotti: una JVM vulnerabile non deve necessariamente esporre un servizio proprio. Il ricercatore samczsun ha condiviso con Calif una catena lato client in cui un programma Java che si limita ad aprire una connessione TLS verso un server malevolo viene compromesso dalla risposta.

Patch, e le due flag che fanno guadagnare tempo
OpenJDK ha pubblicato il proprio avviso il 17 novembre 2026 e Oracle ha rilasciato il suo Critical Patch Update alle 13:00 PT dello stesso giorno, con 11 nuove patch per Java SE. Oracle attribuisce Quang Luong di Calif.io e Albert Yang per CVE-2026-114938. La correzione principale di OpenJDK è piccola: una protezione di quattro righe che indirizza una coda Base64 con padding più corta di un blocco completo al gestore Java invece che alla routine ottimizzata. Questa è la forma del bug in una frase: un'ottimizzazione per le applicazioni che decodificano enormi volumi di dati è stata distribuita a ogni runtime e ha esposto applicazioni che non ne traevano alcun vantaggio.
Fino a quando l'aggiornamento non viene applicato, due flag JVM disattivano gli intrinsics:
• -XX:-UseBASE64Intrinsics disabilita la codifica e la decodifica Base64 accelerata dall'hardware. Questa è la più sicura delle due perché è indipendente dall'architettura.
• -XX:UseAVX=2 disattiva AVX-512. Funziona solo su x86-64: OpenJDK su ARM non riconosce il flag e rifiuterà di avviarsi, quindi una flotta che mescola architetture non può applicarlo in modo generalizzato.
Nessuno dei due flag è una correzione, ed entrambi riducono il throughput esattamente sui carichi di lavoro che rendevano l'intrinseca meritevole di essere scritta. La cosa utile da notare è che nessuno dei due richiede un nuovo deployment del codice applicativo, che è la differenza tra una mitigazione che puoi mettere in atto stasera e una che non puoi.
La copertura del 17 e 18 novembre è stata insolitamente ampia per un bug di runtime: il New York Times l'ha riportata con il titolo "L'IA aiuta a trovare un grave bug di sicurezza in Java, una piattaforma software vitale per Internet", sia la BBC sia Politico ne hanno parlato, l'ufficio federale tedesco per la cybersicurezza ha emesso un avviso, e si è riferito che le indicazioni della CISA esortavano a eseguire immediatamente le patch, osservando al contempo che la vulnerabilità non era nel suo elenco Known Exploited Vulnerabilities. È quest'ultima distinzione quella da tenere a mente. Un'ampia copertura non è prova di sfruttamento e, al momento in cui scriviamo, non esiste alcuna segnalazione pubblica secondo cui Java4Shell sia stato usato in natura.
Il credito del modello, e ciò che dice e non dice
Qui la storia richiede cautela, perché la versione che circola è più pulita di quanto non dica la documentazione.
Il resoconto di Calif non nomina GPT-6 Cyber. Dice che le aree da verificare sono state scelte da una persona e poi affidate: "Ho detto a Codex di esaminare quelle aree come farebbe qualsiasi serio ricercatore di sicurezza nel 2026". Codex è l'agente di programmazione di OpenAI e può essere indirizzato a modelli sottostanti diversi, quindi un ricercatore che eseguisse Codex con GPT-6 Cyber selezionato produrrebbe esattamente quella frase. Ma il resoconto non dice mai quale modello ci fosse dietro e non indica mai un costo o un conteggio di token. I numeri che sono stati ripetuti — circa un'ora per la scoperta, due ore per un exploit funzionante, meno di 200 dollari in token — provengono dai resoconti sulla divulgazione, non dal paper di Calif.

Il nome del modello proviene dallo stesso luogo. I resoconti pubblicati il 17 e 18 novembre attribuiscono specificamente la scoperta a GPT-6 Cyber, e l’inquadramento del New York Times è quello più ampio de “l’AI ha aiutato”. OpenAI, al 18 novembre, non ha pubblicato un proprio resoconto della scoperta. I suoi due post più recenti sulla cybersicurezza — l’aggiornamento NATO del 17 novembre e la partnership con Cogent del 10 novembre — non menzionano Java. Quindi l’affermazione onesta è: la scoperta assistita dall’AI è confermata dal resoconto dello stesso ricercatore, il modello specifico è riportato anziché documentato, e i dati sull’efficienza sono di seconda mano.
Quel divario non sminuisce il risultato. Cambia ciò che se ne può inferire. Una scoperta in un'ora su un runtime vecchio di 30 anni è un'affermazione sul costo della ricerca, e l'unica parte in grado di comprovarla è quella che possiede i documenti di fatturazione. Finché una di esse non li pubblica, la versione difendibile è che una piccola azienda ha fatto puntare un agente su una base di codice matura e ne è tornata con un bug critico di corruzione della memoria in un'area — assembly scritto a mano all'interno del JIT — con cui sia la revisione del codice sia il fuzzing si sono scontrati per anni.
La metà del write-up dedicata allo sviluppo dell'exploit è più interessante di quella dedicata alla scoperta, ed è anche più chiaramente umana. Calif descrive l'agente che si blocca sulle primitive di heap grooming, e la soluzione consistente in un heap tracer e visualizzatore che il team ha scritto affinché l'agente potesse vedere lo stato dell'heap. Questa è una divisione del lavoro che vale la pena nominare: il modello ha ampliato la ricerca, e le persone hanno costruito la strumentazione che ha trasformato una scoperta in una catena.
Patch the Planet è la cornice, non la pratica.
La divulgazione di Java4Shell viene descritta come parte di Patch the Planet, l'iniziativa Daybreak di OpenAI a sostegno dei manutentori open source, condotta con Trail of Bits. Il programma è reale e Calif ne è un partner esplicitamente indicato — la descrizione di Patch the Planet stessa afferma che OpenAI «collabora con HackerOne e Calif, che ci stanno aiutando a portare avanti i nostri sforzi con il triage delle vulnerabilità, la divulgazione coordinata e ulteriori sforzi mirati di scoperta delle vulnerabilità». Quindi il percorso di coordinamento è esattamente quello descritto dall'iniziativa.
Quello che non esiste ancora è la segnalazione. Il sito Patch the Planet elenca attualmente due divulgazioni: CVE-2026-111497 in Brotli, e CVE-2026-109618 e CVE-2026-109619, le falle PHP note come php2shell. Java4Shell non è tra queste. Il post di OpenAI stesso su Patch the Planet del 21 ottobre descrive la risposta a PHP — e nomina il modello che l'ha individuata, ovvero GPT-5.6 Sol, non GPT-6 Cyber. Il primo bug di punta del programma è stato trovato con il predecessore.

Non è una contraddizione; è un fatto di sequenza temporale, e conta per chiunque legga la copertura come un'affermazione di capacità relativa a un singolo modello. Patch the Planet è un framework di coordinamento con partner nominati e una risposta pubblicata in cinque fasi: validare e correggere a monte, dare tempo alle organizzazioni colpite, coordinarsi con il governo, preparare gli aggiornamenti per tutti i prodotti, pubblicare linee guida. Java4Shell ha attraversato le parti di quel framework che riguardano un singolo upstream: OpenJDK e Oracle hanno rilasciato le patch il giorno della divulgazione, e Calif ha trattenuto le catene specifiche per prodotto. Ciò che manca è il post di OpenAI che inserirebbe ufficialmente il ritrovamento nel programma.
Quanto costa eseguire una ricerca come questa
L'economia è l'aspetto su cui un difensore può effettivamente intervenire, e ribalta l'intuizione che la maggior parte dei team si porta dietro. Se le cifre riportate sono corrette, la scoperta è costata qualche centinaio di dollari e l'exploit altre due ore dello stesso lavoro. La parte costosa dell'operazione non è mai stata l'inferenza.
Ciò è coerente con quanto OpenAI ha pubblicato sulla scansione del proprio kernel Linux due settimane prima del lancio di Cyber: 2.308 candidati, 1.724 riprodotti, 948 exploit unici di escalation dei privilegi, $1.213.430 in crediti API e 61 correzioni upstream dieci giorni dopo. Trovare costa poco rispetto a correggere, e il vincolo sta nel triage e nella divulgazione, non nella bolletta dei token. Un team che pianifica un budget per questa classe di lavoro dovrebbe prevedere per la revisione umana una cifra pari a diverse volte la spesa per i modelli.
È anche il punto in cui un livello di routing dimostra la propria utilità invece di restare uno slogan. La pipeline ha fasi con requisiti di modello davvero diversi: la generazione di ipotesi vuole la ricerca più ampia ed economica che ci si può permettere; la validazione vuole un modello in grado di eseguire e leggere un crash; la generazione di patch vuole un contesto lungo su un repository. Eseguire tutte e tre su un unico modello significa pagare la tariffa della fase più costosa per il lavoro della fase più economica. Indirizzare ogni fase verso un modello diverso attraversoun'unica chiave API per oltre 200 modelli, al prezzo di listino del provider con 0% di ricarico, mantiene la pipeline su un'unica fattura e un'unica credenziale invece di tre contratti.
Una cosa da chiarire: GPT-6 Cyber non è nel catalogo OrcaRouter e non potrà esserlo finché non esiste un'approvazione Daybreak Red per l'account che lo chiama. Quello che invece offriamo è la scala generale da cui è stato derivato — GPT-6 Astra a $10/$50 per milione di token, tra gli altri — che è la parte di una pipeline di sicurezza che si occupa di triage, generazione di patch e revisione del codice anziché di sviluppo di exploit. Il failover automatico è più importante proprio nella fase in cui un modello è nuovo e i suoi limiti di frequenza sono sconosciuti, il che descrive la fase di discovery di una pipeline come questa.
Cosa guardare
Tre cose decideranno come verrà letto tra sei mesi.
Il primo è se le catene non divulgate emergono in natura prima di comparire in un articolo. La decisione di Calif di pubblicare la vulnerabilità e la tecnica generale ma trattenere gli exploit specifici per prodotto è la versione responsabile della divulgazione, e funziona solo se il tasso di applicazione delle patch supera il tasso di reverse engineering. L'aggiornamento di Oracle è disponibile; la popolazione di build 17.0.x non aggiornate è la variabile.
Il secondo è se {{1}}Java4Shell{{/1}} raggiunge l'elenco Known Exploited Vulnerabilities della CISA. Al momento non è presente, e il divario tra "critico" e "sfruttato" è dove si concentrano la maggior parte delle discussioni aziendali sulla prioritizzazione.
Il terzo punto è se OpenAI mette agli atti la propria versione dei fatti. Un resoconto tecnico che indichi il modello, i prompt e il costo trasformerebbe un’affermazione riportata in un’affermazione documentata, e sarebbe la prima prova pubblica di ciò che un modello di classe Cyber fa su un bersaglio che nessuno ha scelto in anticipo per lui. Fino ad allora, il bug è il fatto e l’attribuzione è la narrazione.
Confrontati in questo articolo2
Rilevato da questo articolo · Benchmark: Artificial Analysis · aggiornato ogni giorno
