
Proof-of-concept e patch per CVE-2026-57845: RCE da deserializzazione pickle nel builder pandas di Hugging Face datasets, con script di riproduzione e indicazioni per la mitigazione.
<= 5.1.0 RCE tramite Pandas PickleGravità: Alta, CVSS 3.1 8.8
Vettore: CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
Interessato: tutte le versioni di Hugging Face datasets <= 5.1.0
Componente: datasets.packaged_modules.pandas.pandas
CWE: CWE-502 (Deserializzazione di dati non attendibili)
Scoperto e segnalato da: Sai Teja Erukude
Le versioni di Hugging Face datasets fino alla 5.1.0 inclusa consentono
l'esecuzione arbitraria di codice Python durante il caricamento di file pickle
controllati da un attaccante tramite il builder pacchettizzato pandas,
deprecato ma ancora registrato.
Il builder risolve i data_files forniti dal chiamante, apre ciascun file come
bytes e passa l'oggetto file direttamente a pandas.read_pickle() prima di
convertire il risultato in una tabella Arrow:
with open(file, "rb") as f:
pa_table = pa.Table.from_pandas(pd.read_pickle(f))
La deserializzazione di pickle in Python può eseguire codice scelto dall'attaccante. Quando una vittima
carica un dataset malevolo basato su pickle con
datasets.load_dataset("pandas", data_files=...), il payload viene eseguito con
i privilegi del processo della vittima prima della conversione in Arrow o della validazione delle feature.
Un attaccante che riesce a far caricare a una vittima un pickle controllato dall'attaccante tramite
il builder pandas può eseguire codice Python arbitrario nel processo della vittima.
Ciò può influire su flussi di lavoro di analisi dati, machine learning e automazione che
caricano dataset da progetti, repository, download o file condivisi non attendibili.
L'attaccante non necessita di privilegi nell'ambiente della vittima, ma la vittima
deve caricare il dataset malevolo, coerentemente con il requisito di interazione utente del report (UI:R).
A seconda dell'ambiente locale, ciò può consentire di:
Il percorso vulnerabile è il builder pacchettizzato pandas:
datasets.load_dataset("pandas", data_files=...)
-> dataset_module_factory(...)
-> registered pandas packaged builder
-> Pandas._split_generators(...)
-> resolve or download caller-supplied data_files
-> Pandas._generate_tables(...)
-> open(file, "rb")
-> pandas.read_pickle(f)
-> pyarrow.Table.from_pandas(...)
Il PoC crea un oggetto pickle il cui metodo __reduce__() specifica un callable
che scrive un file marcatore locale innocuo e restituisce un valido
pandas.DataFrame. Durante la deserializzazione, quel callable viene eseguito prima che il
builder converta il DataFrame restituito in una tabella Arrow. Il caricamento del dataset poi
si completa normalmente e restituisce una riga.
Il runner invoca la vera API datasets.load_dataset() dal pacchetto
installato. Una cache locale pulita e la rimozione del marcatore precedente garantiscono che il
risultato salvato dimostri l'esecuzione durante il caricamento del dataset.
Deprecare il builder o validare il DataFrame restituito non impedisce l'esecuzione durante l'unpickling. Anche la documentazione di pandas avverte contro il caricamento di dati pickle da fonti non attendibili.
run_poc.py genera attacker-controlled.pkl, lo carica tramite
il builder pandas e registra le prove di esecuzione.
Eseguire solo in un ambiente di test locale. Per riprodurre la versione mostrata nelle prove salvate su Windows:
python -m venv .venv
.\.venv\Scripts\python.exe -m pip install "datasets==5.1.0"
.\.venv\Scripts\python.exe -B run_poc.py
Il file requirements.txt incluso specifica attualmente
datasets<=5.0.1. Può essere installato con
python -m pip install -r requirements.txt per testare quel range precedente, ma
non seleziona l'installazione 5.1.0 usata nelle evidenze salvate. Il pin esplicito
sopra riproduce la versione di datasets di quell'installazione.
Evidenze attese sulla versione vulnerabile dimostrata:
datasets_version: 5.1.0
installed_package: True
load_error: None
row_count: 1
first_row: {'value': 'benign dataframe returned after pickle execution'}
marker_before_load_dataset: False
marker_after_load_dataset: True
marker_contents:
datasets_pandas_pickle_rce_triggered
success: True
L'evidenza importante è che il marker è assente prima di load_dataset(),
compare durante il caricamento e contiene la stringa attesa mentre il caricamento del dataset
si completa con successo e restituisce la riga attesa.
L'effetto di esecuzione del payload è una scrittura locale di un file marker:
datasets_pandas_pickle_rce_triggered
Il runner scrive anche i file pickle, cache e evidence generati. Ogni esecuzione
sostituisce attacker-controlled.pkl, marker.txt, cache/ ed evidence/ nella
directory PoC; preservare le evidenze esistenti prima di rieseguirlo.
Artefatti salvati:
La correzione mirata sostituisce l'intero corpo di Pandas._generate_tables() con
un errore incondizionato prima che qualsiasi file venga aperto o passato a
pandas.read_pickle():
def _generate_tables(self, files):
raise ValueError(PANDAS_PICKLE_DISABLED_ERROR)
L'errore spiega il rischio di esecuzione del pickle e indirizza i chiamanti verso Parquet, Arrow, CSV, JSON o Dataset.from_pandas() per un DataFrame esistente. Questo blocca il percorso di esecuzione di codice segnalato per ogni nome di file, inclusi i pickle considerati attendibili; non tenta di determinare quali file pickle siano affidabili.
Il builder rimane registrato e può ancora essere costruito tramite load_dataset_builder("pandas", ...) o Pandas(...). La risoluzione dei file e i download possono avvenire prima che la generazione della tabella fallisca. Con lo streaming, l'errore si verifica quando il dataset viene iterato. Una cache Arrow preparata compatibile può comunque essere riutilizzata senza chiamare _generate_tables() o deserializzare l'input. Modificare il sorgente del builder ne cambia l'hash, quindi le cache più vecchie potrebbero non corrispondere più automaticamente. Questa patch non rifiuta il nome del builder in load.py.
Ad esempio, caricare Parquet tramite il suo builder dedicato:
from datasets import load_dataset
dataset = load_dataset("parquet", data_files="data.parquet", split="train")
I test di regressione coprono il caricamento da zero, l'iterazione in streaming, la generazione diretta delle tabelle, la costruzione del builder, il riutilizzo della cache Arrow preparata e i formati di sostituzione supportati. Verificano che pandas.read_pickle() non venga mai raggiunto e che la generazione diretta delle tabelle non apra file. Controllare il tipo di un oggetto dopo l'unpickling è troppo tardi. Rinominare un file, emettere un avviso o convertire un pickle non attendibile in un altro formato eseguendo prima l'unpickling non risolve il rischio di esecuzione.