hyperps/cve-2026-0897
Allocazione di risorse senza limiti o limitazioni di velocità nel componente di caricamento dei pesi HDF5 in Google Keras 3.0.0 fino alla 3.13.0 su tutte le piattaforme consente a un attaccante remoto di causare una Denial of Service (DoS) tramite l'esaurimento della memoria e il crash dell'interprete Python attraverso un file .keras appositamente predisposto.
-orange?style=for-the-badge){kind=icon}
-brightgreen?style=for-the-badge){kind=icon}
| Campo | Dettagli |
|---|---|
| CVE ID | CVE-2026-0897 |
| Pacchetto | keras (Google Keras) |
| Registro | PyPI |
| Versioni interessate | 3.0.0 fino a 3.13.0 (incluse) |
| Tipo di vulnerabilità | CWE-770: Allocazione di risorse senza limiti o throttling |
| Punteggio CVSS | 7.1 Alto (CVSS 4.0, CNA: Google Inc.) |
| Vettore CVSS | CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:P/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N |
| Vettore di attacco | Rete |
| Complessità dell'attacco | Bassa |
| Privilegi richiesti | Nessuno |
| Interazione dell'utente | Passiva (la vittima carica un file di modello) |
| Impatto sulla disponibilità | Alto |
| Impatto sulla riservatezza | Nessuno |
| Impatto sull'integrità | Nessuno |
| Pubblicato su NVD | 15 gennaio 2026 |
| Ultima modifica NVD | 23 gennaio 2026 |
| Fonte / CNA | Google Inc. |
| Segnalato da | HyperPS (Sarvesh Patil) tramite huntr.dev / GHSA |
| Stato della correzione | Integrata — PR #21880 |
Una vulnerabilità di tipo Denial of Service è presente nel componente di caricamento dei pesi HDF5 di Google Keras versioni 3.0.0 fino a 3.13.0 su tutte le piattaforme. La vulnerabilità è causata dall'assenza di qualsiasi validazione o limitazione (throttling) durante l'elaborazione dei metadati di forma (shape) dei dataset HDF5 dichiarati all'interno di un archivio .keras.
Il formato HDF5 consente ai dataset di dichiarare la propria forma (dimensioni dei tensori) come metadati. Quando Keras carica i pesi del modello da un archivio .keras, legge questa forma dichiarata e tenta di allocare un blocco di memoria corrispondente prima che qualsiasi dato venga trasferito. Poiché Keras non esegue alcun controllo dei limiti sulla forma dichiarata prima dell'allocazione, un attaccante può creare un file model.weights.h5 che dichiara una forma astronomicamente grande — ad esempio (1000000, 1000000, 1000000) — inducendo Keras a tentare un'allocazione di memoria su scala petabyte. Questo esaurisce tutta la memoria di sistema disponibile e provoca il crash dell'interprete Python.
Non è richiesta alcuna inferenza né ulteriore interazione dopo il caricamento del modello. L'attacco viene completamente innescato al momento del caricamento.
| File | Descrizione |
|---|---|
keras/src/saving/file_editor.py | KerasFileEditor._extract_weights_from_store() — legge la forma dei dataset HDF5 e alloca memoria senza validazione delle dimensioni o limitazioni (throttling) |
La vulnerabilità è situata in particolare nella classe KerasFileEditor, responsabile della deserializzazione dei tensori dei pesi del modello dagli archivi HDF5 incorporati negli archivi .keras.
| Metrica | Valore | Significato |
|---|---|---|
| Vettore di attacco (AV) | Rete | Sfruttabile da remoto tramite un file di modello distribuito |
| Complessità dell'attacco (AC) | Bassa | Nessuna condizione speciale o race condition richiesta |
| Requisiti di attacco (AT) | Nessuno | Nessuna configurazione di distribuzione prerequisita necessaria |
| Privilegi richiesti (PR) | Nessuno | Nessuna autenticazione o account richiesto |
| Interazione dell'utente (UI) | Passiva | La vittima deve caricare l'archivio .keras dannoso |
| Disponibilità del sistema vulnerabile (VA) | Alta | L'interprete Python va in crash; il servizio diventa completamente non disponibile |
| Riservatezza del sistema vulnerabile (VC) | Nessuna | Nessuna divulgazione di dati |
| Integrità del sistema vulnerabile (VI) | Nessuna | Nessuna modifica dei dati |
| Impatto sui sistemi successivi (SC/SI/SA) | Nessuno | L'impatto è limitato al processo di caricamento |
.keras da fonti non attendibili o fornite dall'utente è vulnerabile| Contesto | Rischio |
|---|---|
API pubbliche di servizio dei modelli che accettano file .keras caricati dagli utenti | L'attaccante manda in crash il servizio di inferenza con una singola richiesta |
| Piattaforme ML che ospitano download di modelli dalla community (es. Hugging Face) | Un modello avvelenato causa DoS per qualsiasi ricercatore che lo scarichi e lo carichi |
| Ambienti di apprendimento federato | Un partecipante malintenzionato distribuisce un file di pesi appositamente creato per mandare in crash il coordinatore o i nodi peer |
| Pipeline CI/CD che caricano checkpoint di modelli | Un checkpoint compromesso o sostituito causa il fallimento della pipeline e l'indisponibilità |
| Chatbot o servizi NLP che ricaricano i modelli a caldo in esecuzione | Una singola richiesta di ricaricamento dannosa manda giù il servizio |
Il formato file HDF5 memorizza i metadati dei tensori — incluse le dichiarazioni di forma — separatamente dai byte di dati effettivi. Quando KerasFileEditor._extract_weights_from_store() incontra una voce di dataset, legge la forma dichiarata e chiama NumPy per pre-allocare un array con le dimensioni corrispondenti prima di leggere qualsiasi dato dal disco.
Poiché la forma è un metadato, un file HDF5 minimale può dichiarare una forma che richiederebbe petabyte di memoria mentre il file stesso rimane di soli pochi kilobyte. Il rapporto tra dimensione del file e dimensione dell'allocazione rende questo un attacco di amplificazione estremamente efficace.
Una forma come (1000000, 1000000, 1000000) con un dtype float a 32 bit richiederebbe circa 4.000 petabyte di memoria. L'out-of-memory killer del sistema operativo o l'allocatore di Python manderanno in crash il processo quasi istantaneamente.
# keras/src/saving/file_editor.py (pre-fix, simplified)
def _extract_weights_from_store(self, h5_file, inner_path=""):
for key in h5_file.keys():
obj = h5_file[key]
if isinstance(obj, h5py.Dataset):
# Shape is read from metadata — no validation performed
shape = obj.shape
# NumPy attempts to allocate based on declared shape
data = np.zeros(shape, dtype=obj.dtype) # VULNERABLE: unbounded allocation
L'assenza di qualsiasi controllo su shape prima di chiamare np.zeros() è la causa principale.
Queste informazioni sono fornite esclusivamente a scopo educativo e difensivo. Non testare sistemi che non possiedi o per i quali non hai un'autorizzazione esplicita a testare.
.keras dannoso