l'analisi tecnica

Java4Shell, la falla nel cuore di Java era pubblica da settembre: a rischio server, identità digitali e container


Indirizzo copiato

Java4Shell è una corruzione di memoria nel decoder Base64 di OpenJDK che può portare a esecuzione di codice da remoto senza autenticazione. Colpisce le JVM dalla 17.0.6 su CPU Intel e AMD. Le patch ci sono dal 17 novembre, ma la correzione era stata proposta in chiaro già a settembre. Cosa controllare, come mitigare e quali tracce cercare nei log

Pubblicato il 18 nov 2026



Riassumi questo articolo
Approfondisci con altre fonti
Java4Shell




Sessantaquattro lettere A seguite da un segno di uguale. Tanto basta per corrompere la memoria di una Java Virtual Machine, cioè di quel pezzo di software che dalla corruzione di memoria dovrebbe proteggerci per contratto. La vulnerabilità si chiama Java4Shell, è tracciata come CVE-2026-114938 e, nelle condizioni giuste, permette a un attaccante remoto senza credenziali di leggere la memoria del processo e di arrivare all’esecuzione di codice.

La divulgazione è del 17 novembre 2026 e porta la firma dei ricercatori di Calif, che hanno dimostrato l’esecuzione di codice senza autenticazione su Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins e PingFederate, tutti nella configurazione di default. Lo stesso giorno Oracle ha pubblicato le correzioni all’interno del Critical Security Patch Update di novembre, che contiene 655 nuove patch di sicurezza, 11 delle quali per Java SE. Sempre il 17 sono arrivate le allerte di CISA e del Canadian Centre for Cyber Security, il 18 quella del Centro nazionale svizzero per la cybersicurezza.

Il difetto non sta in una libreria che qualcuno ha aggiunto al progetto, sta nel runtime OpenJDK. Lo slogan storico di Java era write once, run anywhere; Calif lo ha aggiornato con un certo senso dell’umorismo in write once, RCE everywhere. La battuta funziona perché è vera: applicazioni che non hanno nulla in comune ereditano lo stesso problema per il solo fatto di girare sulla stessa JVM.

Detto questo, niente panico da titolo: non tutte le installazioni Java sono vulnerabili. Servono tre condizioni insieme, cioè una versione del runtime che contenga il codice difettoso, un processore con un set di istruzioni preciso e un percorso applicativo che faccia arrivare al decoder dati controllati dall’attaccante. Capire quali delle tre valgono in casa propria è il lavoro di queste ore.

Sulla gravità i numeri non coincidono. Oracle e l’OpenJDK Vulnerability Group assegnano 8.1 su CVSS 3.1, con complessità d’attacco alta; Calif indica 9.2 su CVSS 4.0; Red Hat classifica l’impatto come critico. Chi vuole discutere del decimale è libero di farlo, possibilmente dopo aver aggiornato.

“Ma il dettaglio che dovrebbe togliere il sonno non è il punteggio, su cui Oracle e Calif non concordano nemmeno”, sottolinea Maurizio Siracusa, Ethical Hacker, Executive Trainer e Security Transformation Leader. “È il calendario. La correzione era stata proposta in chiaro a settembre, in una pull request pubblica, ed è rimasta lì quasi due mesi prima di essere chiusa senza merge. Nel frattempo chiunque sapesse leggere poteva studiarsela con calma”.

“Poi c’è l’inventario”, continua ancora l’esperto. “Questa falla non sta nel codice che avete scritto, sta nel runtime che vi siete portati dietro dentro un container, un’appliance o il prodotto di un fornitore. E dipende dal processore, quindi la stessa immagine è innocua su un host e bucabile su quello accanto. Chi oggi risponde “noi Java lo abbiamo aggiornato” sta parlando del pacchetto di sistema, non delle JVM che girano davvero”.

“Sapete dire, adesso, quante sono e su quale CPU?”, è la conclusione critica di Maurizio Siracusa.

Come funziona Java4Shell: l’errore nella coda del decoder Base64

Java gestisce la memoria al posto dello sviluppatore e controlla gli accessi: è uno dei suoi argomenti di vendita più solidi. Ma la JVM stessa è scritta in C, C++ e, in alcuni punti, in assembly. Lì le garanzie del linguaggio non arrivano, e la corruzione di memoria torna a essere un rischio del mestiere.

Base64 è il sistema con cui si rappresentano dati binari come testo, ed è ovunque: credenziali, token, upload di file, messaggi di rete. Per decodificarlo più in fretta, HotSpot sostituisce il ciclo interno del decoder con una routine scritta a mano in assembly, un cosiddetto intrinsic, che sui processori compatibili usa le istruzioni AVX-512 VBMI per elaborare 64 byte alla volta. L’errore sta nel punto in cui quella routine gestisce gli ultimi caratteri, quelli con il padding.

Pillola tecnica: sessantadue byte fuori posto

Per l’input da 65 caratteri citato in apertura, Java calcola correttamente un buffer di uscita da 50 byte. La routine accelerata decodifica i primi 64 caratteri in 48 byte, poi incontra il segno di uguale rimasto solo. La lunghezza residua da scrivere viene calcolata come zero, il ramo che gestisce il padding sottrae ancora uno e il valore diventa negativo. Quel numero serve a costruire la maschera che dice al processore quali byte scrivere: con un valore fuori scala la maschera resta tutta a uno, e la scrittura diventa di 64 byte pieni a partire dalla posizione 48. Due finiscono dentro il buffer, sessantadue finiscono oltre.

Java si accorge che l’input non è valido e lancia l’eccezione, ma solo dopo. A quel punto gli oggetti vicini in memoria possono essere già stati sovrascritti. È il motivo per cui un controllo applicativo a valle, da solo, non serve a nulla: il danno precede il rifiuto. Sulle build OpenJDK 17 la soglia per entrare nel percorso accelerato è più alta e l’input che innesca il difetto è di 128 lettere A più il segno di uguale.

La correzione, per la cronaca, è di quattro righe: se la coda è più corta di un gruppo completo di quattro caratteri, la routine la lascia al decoder Java ordinario, che la rifiuta prima di qualunque scrittura vettoriale.

Dalla scrittura fuori confine al controllo del processo

I byte scritti fuori dal buffer non sono scelti dall’attaccante, che controlla soltanto il punto in cui atterrano. Sembra poco, ed è proprio su questo che Calif ha lavorato. La tecnica, presa in prestito dallo sfruttamento dei motori JavaScript, consiste nel far cadere la scrittura sul campo lunghezza di un array vicino: l’array ingrandito diventa uno strumento di scrittura con valori scelti, un secondo array corrotto diventa uno strumento di lettura che riporta pezzi di heap dentro la risposta dell’applicazione.

Quella lettura ha già un nome, JavaBleed, in omaggio a Heartbleed: prima ancora di eseguire codice, l’attaccante può farsi restituire porzioni di memoria che contengono chiavi private, token e dati personali. Da lì la catena prosegue fino alla scrittura arbitraria e all’esecuzione di codice nel processo Java.

Va detto con la stessa chiarezza che non esiste un exploit universale. Ogni applicazione richiede una catena su misura, una disposizione favorevole dell’heap, tempi di rete stabili e più tentativi. Un tentativo sbagliato può mandare in crash la JVM, ma spesso si può semplicemente riprovare. Non è un attacco da un clic, è un attacco da professionisti. Il che, per chi difende un identity provider, non è esattamente una consolazione.

Quali applicazioni sono esposte: da Keycloak a Jira e Jenkins

Oltre ai sei prodotti colpiti senza autenticazione, Calif ha dimostrato l’esecuzione di codice dopo il login su Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit e Spinnaker, e su applicazioni di esempio costruite con Apache Struts e Spring Boot. Gli elenchi sono dichiaratamente non esaustivi.

Il punto è che il decoder si raggiunge attraverso funzioni del tutto ordinarie. Red Hat ne elenca alcune: credenziali HTTP Basic, artefatti SAML, token CSRF, intestazioni MIME codificate. Sono tutti dati in Base64 che un’applicazione decodifica abitualmente prima di aver completato l’autenticazione. Kevin Breen di Immersive, che ha lavorato in modo indipendente sulla falla, indica come vie d’ingresso pre-autenticazione anche la Basic auth di Apache Tomcat e la libreria java-jwt.

Guardate di nuovo la lista dei prodotti e chiedetevi cosa fanno in azienda. Keycloak e PingFederate autenticano dipendenti e applicazioni. Jenkins, Artifactory e Gerrit costruiscono e distribuiscono il software. Jira e Confluence contengono la documentazione interna, comprese spesso le password che non dovrebbero esserci. Chi compromette uno di questi sistemi non ottiene un server web: ottiene le chiavi di casa e, nel caso della filiera di sviluppo, la possibilità di mettere mano a ciò che verrà rilasciato domani.

Pillola tecnica: si può essere colpiti anche senza esporre nulla

Calif riferisce di aver ricevuto dal ricercatore samczsun un exploit lato client: un programma Java che apre una connessione TLS verso un server controllato dall’attaccante può essere compromesso anche se non offre alcun servizio in ascolto. I dettagli del percorso non sono stati pubblicati. La conseguenza pratica è che l’assenza di porte Java esposte su Internet non garantisce da sola che un sistema sia al sicuro: contano anche le connessioni in uscita.

Le tre condizioni: versione della JVM, processore e percorso applicativo

Prima condizione, la versione. Sono interessate le build OpenJDK dalla 17.0.6 in poi sul ramo 17 e i rami 21, 25 e 27, fino alle correzioni del 17 novembre. Java 8 standard e Java 11 non contengono il decoder AVX-512 e non sono coinvolti. L’eccezione sul ramo 8 è l’Enterprise Performance Pack di Oracle, build 8u511b33-perf, che invece è nell’elenco dei prodotti affetti. Essendo codice OpenJDK, il problema riguarda tutte le distribuzioni che ne derivano: Oracle Java SE, Oracle GraalVM, Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, BellSoft Liberica, SAP SapMachine, Red Hat.

Seconda condizione, il processore. Il percorso vulnerabile viene selezionato automaticamente dalla JVM solo su CPU x86-64 con AVX-512 VBMI: Intel Xeon delle generazioni Ice Lake, Sapphire Rapids, Emerald Rapids e Granite Rapids, AMD EPYC e Ryzen da Zen 4 in avanti. I sistemi ARM64 non sono interessati, anche quando eseguono la stessa identica build di Java. Su Linux la verifica richiede dieci secondi:

grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'

Secondo Calif l’output deve contenere tutti e quattro i flag. Se ne manca uno, quella macchina non esegue il codice difettoso.

Pillola tecnica: in cloud la stessa immagine può essere sana o vulnerabile

Poiché la scelta dipende dall’hardware, un’immagine container può essere innocua su un nodo e sfruttabile su quello accanto, e una macchina virtuale migrata su un host di generazione più recente può diventare vulnerabile senza che nessuno abbia toccato una riga di configurazione. Red Hat indica come più probabilmente interessate le famiglie AWS C6i, M6i, R6i, C7i, M7i e R7a, le GCP C3, C3D, C4, C4D, N4, N4D, M3 e M4, e le Azure Dsv5, Dsv6, Dasv6 e Dasv7 con le relative serie D dalla v5 alla v7. Un cluster Kubernetes con nodi misti va quindi verificato nodo per nodo, non a campione.

Terza condizione, il percorso. L’applicazione deve passare a java.util.Base64.Decoder dati controllabili dall’esterno, e il decoder deve essere già stato compilato dal JIT, cosa che su un servizio con traffico reale avviene da sola. Qui c’è una trappola per chi fa i test: la dimostrazione pubblicata da Calif “scalda” il decoder con 200.000 decodifiche valide prima di inviare l’input malformato. Come osserva Tenable, quel test dice se la coppia Java più processore riproduce il difetto, non se una specifica applicazione è esposta. Ne consegue che una prova a freddo andata a vuoto non è un certificato di buona salute.

Le patch: versioni corrette e runtime che nessuno ricorda di avere

Queste sono le build corrette pubblicate da Oracle il 17 novembre:

Ramo JavaBuild Oracle affettaBuild Oracle corretta
Java 1717.0.21.0.317.0.21.1
Java 2121.0.13.0.321.0.13.1
Java 2525.0.5.0.325.0.5.1
Java 2727.0.1.0.327.0.1.1
Java 8 Enterprise Performance Pack8u511b33-perf8u513-perf

Oracle elenca solo le versioni che supporta e avverte che anche quelle precedenti sono probabilmente affette. I numeri in tabella valgono per Oracle e per gli aggiornamenti OpenJDK corrispondenti, e non vanno trasferiti alle altre distribuzioni, che hanno numerazioni proprie. Secondo la ricognizione di Ostorlab, Amazon Corretto ha già rilasciato le build 17.0.21.1.2, 21.0.13.1.2, 25.0.5.1.2 e 27.0.1.1.4, e Azul le Zulu 17.70.201, 21.54.201, 25.38.201 e 27.30.201. Per ogni altro fornitore fa fede il suo bollettino.

Capitolo a parte per Red Hat, che in Italia significa una buona fetta di pubblica amministrazione e banche. Il bollettino RHSB-2026-018, nella versione del 17 novembre, indica come affetti RHEL 8, 9 e 10 e le build Red Hat di OpenJDK 17, 21 e 25, dichiara che il rilascio delle correzioni è in fase di accelerazione ma non riporta ancora errata disponibili. Chi è su quelle piattaforme deve controllare lo stato aggiornato del bollettino e, nel frattempo, applicare la mitigazione descritta più avanti.

Pillola tecnica: la JVM che conta è quella che sta girando

Aggiornare il pacchetto Java del sistema operativo non basta. Molti prodotti si portano dietro un runtime proprio, dentro la cartella di installazione, dentro un’appliance o dentro un’immagine container, e quel runtime ignora serenamente ciò che avete aggiornato sull’host. Inoltre una JVM in esecuzione tiene in memoria il vecchio codice finché non viene riavviata. Tre controlli che conviene fare sui processi reali, non sulla documentazione:

# quale binario java viene usato davvero
readlink -f "$(command -v java)" && java -version

# versione del runtime dentro un container in esecuzione
docker exec <container> java -version

# flag effettivi di una JVM gia' avviata
jcmd <pid> VM.flags

Per i container la sequenza è ricostruire o scaricare l’immagine base aggiornata, ricreare il container e verificare. Scaricare l’immagine nuova e lasciare in piedi il processo vecchio è un classico che continua a mietere vittime.

Come mitigare Java4Shell quando la patch non si può installare subito

Calif indica due opzioni di avvio della JVM che impediscono l’esecuzione del codice difettoso. La prima disattiva le routine accelerate per la codifica e decodifica Base64 e lascia intatte le altre ottimizzazioni:

-XX:-UseBASE64Intrinsics

La seconda disattiva del tutto l’uso di AVX-512, con un possibile impatto sulle prestazioni di altre operazioni:

-XX:UseAVX=2

Tre avvertenze. La prima: su ARM la JVM non riconosce UseAVX e non parte, quindi chi distribuisce la stessa configurazione su architetture miste rischia di trasformare una mitigazione in un fermo di servizio. La seconda: né Oracle né l’OpenJDK Vulnerability Group citano questi parametri nei propri advisory; li raccomandano Calif, Red Hat e Cisco Talos, questi ultimi due con riferimento a UseAVX=2, e vanno provati prima in un ambiente di test. La terza: Ostorlab riporta un’osservazione di Upwind secondo cui il parametro -XX:DisableIntrinsic=_base64_decodeBlock, usato da solo, impedisce l’avvio della JVM. Meglio non improvvisare varianti.

Le mitigazioni richiedono un riavvio, vanno verificate sul processo con jcmd e non sostituiscono la patch. Vanno rimosse una volta aggiornato il runtime.

Pillola tecnica: perché proxy e WAF non chiudono la partita

Alcune delle catene di Calif hanno bisogno di consegnare il corpo della richiesta a pezzi per controllare i tempi delle allocazioni in memoria. Un reverse proxy che attende il corpo completo prima di inoltrarlo, come fa nginx con le impostazioni predefinite, le interrompe. È però la stessa Calif a precisare che non si tratta di una mitigazione generale: la catena contro Elasticsearch parte da una singola richiesta completa, e dopo un upgrade a WebSocket i frame attraversano un tunnel su cui il buffering non agisce più. Anche un WAF può fermare alcuni payload, ma il decoder è raggiungibile da troppi percorsi applicativi diversi perché una regola li copra tutti.

Come capire se qualcuno ha già bussato: le tracce da cercare

Al momento non sono stati pubblicati indicatori di compromissione. Esistono però segnali che meritano un’occhiata, tenendo presente che indicano possibili tentativi e non una compromissione avvenuta. Nei log dei web server vanno cercati token Basic malformati, cioè stringhe Base64 la cui lunghezza non è multipla di quattro e che terminano con il segno di uguale. Nei log applicativi, raffiche di IllegalArgumentException provenienti dal decoder Base64. Sul filesystem, file di crash della JVM recenti. Nei log del supervisore, riavvii inattesi del servizio che a prima vista sembrano un banale esaurimento di memoria.

# crash della JVM negli ultimi 14 giorni
find / -name 'hs_err_pid*.log' -mtime -14 2>/dev/null

# il crash riguarda la routine Base64?
grep -i -E 'base64|decodeBlock' /percorso/hs_err_pid*.log

# raffiche di eccezioni dal decoder nei log applicativi
grep -R "IllegalArgumentException" /var/log/<applicazione> 2>/dev/null | grep -i base64

Un token malformato può arrivare anche da un client legittimo scritto male, quindi ogni riscontro va contestualizzato con indirizzo di origine, percorso richiesto e richieste adiacenti. Cisco Talos ha pubblicato regole Snort dedicate (SID da 67502 a 67513) che rilevano Base64 malformato in specifici campi delle richieste HTTP.

Un dato dà la misura di quanto sia economico almeno il danno minimo. Secondo quanto riporta Ostorlab, il gruppo Adversary Pursuit di Blackpoint Cyber ha mandato in crash un’applicazione Spring Boot di test con circa 28.300 richieste di login malformate in una ventina di secondi, senza autenticarsi. Anche dove l’esecuzione di codice resta difficile, il blocco del servizio è alla portata di molti.

Infine un promemoria che il centro svizzero mette nero su bianco e che vale la pena ripetere: un aggiornamento di sicurezza non rimuove una compromissione già avvenuta. Considerato che la tecnica consente di leggere la memoria prima ancora di eseguire codice, per i sistemi di gestione delle identità esposti e rimasti vulnerabili è prudente, in presenza di segnali anomali, valutare la rotazione di chiavi e segreti.

La falla era pubblica da settembre

C’è un dettaglio che nella maggior parte delle cronache è finito in fondo e che invece meriterebbe il primo paragrafo. Secondo la ricostruzione di Ostorlab e The Hacker News, il 9 settembre 2026 una pull request pubblica sul repository di OpenJDK, la numero 32781, descriveva l’overflow sulla coda con padding, conteneva un input capace di innescarlo e proponeva lo stesso controllo di lunghezza poi adottato nella correzione. È stata chiusa senza essere integrata il 4 novembre. L’identificativo CVE risulta riservato il 22 ottobre.

Il 17 novembre Calif ha annunciato la divulgazione con una frase che non lascia spazio a interpretazioni: i dettagli sarebbero stati pubblicati dopo il rilascio della patch, dal momento che la vulnerabilità è trapelata. Tra la pull request e gli aggiornamenti sono passati 69 giorni, durante i quali la descrizione del problema è rimasta leggibile da chiunque avesse la pazienza di seguire un repository pubblico. Oracle, nei crediti dell’advisory, attribuisce la segnalazione a Quang Luong di Calif e ad Albert Yang.

Nessuno ha prove che qualcuno ne abbia approfittato. Ma chi costruisce la propria valutazione del rischio sulla data di pubblicazione della CVE farebbe bene a spostare l’orologio indietro di due mesi.

Exploit pubblici e attacchi reali: qual è la situazione

Calif ha pubblicato una dimostrazione volutamente innocua, che riproduce la scrittura fuori confine all’interno di un array molto più grande del necessario, e ha dichiarato di trattenere le catene di exploit per i singoli prodotti finché gli utenti non avranno avuto modo di aggiornare. Ha anche scritto che le pubblicherà in seguito: la finestra per aggiornare, quindi, ha una scadenza anche se nessuno ha comunicato quale.

Nel frattempo altri si sono mossi. Il giorno stesso della divulgazione Kevin Breen di Immersive ha dichiarato di disporre di un exploit funzionante, precisando che non è generico e va adattato a ogni applicazione; non risulta che lo abbia rilasciato. Wiz, secondo quanto riportato da Ostorlab, afferma di aver dimostrato lo sfruttamento remoto contro Jenkins, Confluence e Tomcat. Su GitHub compaiono già repository con dimostrazioni, scanner e regole di rilevamento. Consiglio non richiesto: prima di eseguire su una macchina aziendale il codice di uno sconosciuto che promette di verificare una vulnerabilità, leggetelo. I falsi PoC distribuiti a chi ha fretta sono un genere letterario consolidato.

La disponibilità di dimostrazioni non equivale alla conferma di attacchi. Al 18 novembre non risultano segnalazioni pubbliche di sfruttamento attivo: Cisco Talos dichiara di non averne osservato ma si aspetta che i tentativi di ricognizione aumentino a breve, Tenable non ne ha notizia, la CVE non compare nel catalogo delle vulnerabilità sfruttate di CISA e, secondo Ostorlab, il centro canadese non era a conoscenza di attacchi al momento della sua allerta.

L’hacker centauro: cosa dice questo caso sull’intelligenza artificiale

Calif dichiara di aver usato agenti AI sia per trovare il difetto sia per costruire gli exploit. Nel resoconto tecnico Quang Luong racconta di aver puntato Codex sulle aree più delicate di HotSpot, cioè compilatore JIT, intrinsic, API molto esposte e crittografia, di aver scartato per una ventina di minuti risultati inutilizzabili e di aver poi ricevuto la segnalazione giusta. Il bilancio dichiarato è di circa un’ora per individuare la vulnerabilità, altre due per il primo exploit funzionante e meno di 200 dollari di token.

Sono tempi e costi riferiti dai ricercatori per il proprio lavoro, non una misura generale di ciò che un agente AI sa fare da solo. La stessa Calif precisa che il risultato nasce dalla combinazione tra la potenza dello strumento e il contesto fornito da persone esperte, quella figura che chiama centaur hacker, e che gli agenti si bloccavano sulla preparazione dell’heap finché i ricercatori non hanno scritto strumenti appositi per mostrarne lo stato. Una volta costruiti metodo e pipeline, però, le catene successive sono state prodotte in modo quasi autonomo.

La parte più interessante è la proposta finale, che i ricercatori chiamano vibe-uncoding: usare gli stessi strumenti per individuare e rimuovere il codice di cui un sistema non ha bisogno. Un decoder Base64 scritto a mano in assembly serve a chi decodifica quantità enormi di dati; viene però distribuito a tutti, compreso chi ne elabora poche centinaia di byte. La domanda con cui chiudono vale più di molte linee guida: con l’AI tutti si chiedono cosa si può costruire, forse per la sicurezza bisognerebbe chiedersi cosa si può cancellare.

Il rischio per banche, pubblica amministrazione e infrastrutture critiche italiane

In Italia Java è dappertutto, e spesso dove non lo si vede: servizi applicativi e infrastrutture di integrazione nel settore finanziario, piattaforme di servizio nelle telecomunicazioni, portali, sistemi documentali e middleware nella pubblica amministrazione, in larga parte sviluppati o gestiti da fornitori esterni. La difficoltà non è applicare una patch, è sapere dove applicarla.

Un inventario costruito sulle librerie applicative non vede la JVM. L’elenco delle dipendenze di un progetto dice quali componenti sono stati inclusi, non su quale runtime e su quale processore girano in produzione. Per questa vulnerabilità servono entrambe le informazioni, e in molte organizzazioni la seconda non la possiede nessuno in forma strutturata. La verifica deve quindi coinvolgere sistemisti, responsabili applicativi, team DevOps e fornitori, e ai fornitori va chiesta una risposta puntuale: quale runtime è incorporato nel prodotto, in quale versione, e quando verrà aggiornato.

L’ordine di intervento ragionevole parte dalle installazioni vulnerabili raggiungibili da utenti non autenticati, prosegue con le piattaforme di gestione delle identità e gli strumenti della filiera di sviluppo, e arriva agli ambienti interni con privilegi elevati. I client Java che aprono connessioni verso l’esterno vanno messi in lista, non dimenticati.

Le organizzazioni soggette a obblighi di cybersicurezza, compresa la disciplina NIS2 dove applicabile, devono trattare la vulnerabilità all’interno del proprio processo di gestione del rischio. La pubblicazione di una CVE non introduce da sola una nuova scadenza di legge né un obbligo di notifica di incidente: la notifica riguarda gli incidenti, non l’esistenza di una falla. Resta il fatto che un processo di gestione delle vulnerabilità che non sa rispondere alla domanda “quante JVM abbiamo” è conforme sulla carta e basta.

Partecipa alla community

guest

0 Commenti
Più recenti
Più votati
Inline Feedback
Vedi tutti i commenti

Articoli correlati

0
Lascia un commento, la tua opinione conta.x