
Preuve de concept et correctif pour CVE-2026-57845 : RCE par désérialisation pickle dans le générateur pandas de Hugging Face datasets, avec script de reproduction et recommandations de remédiation.
<= 5.1.0Gravité : Élevée, CVSS 3.1 8.8
Vecteur : CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
Affecté : toutes les versions de Hugging Face datasets <= 5.1.0
Composant : datasets.packaged_modules.pandas.pandas
CWE : CWE-502 (Désérialisation de données non fiables)
Découvert et signalé par : Sai Teja Erukude
Les versions de Hugging Face datasets jusqu'à 5.1.0 incluse permettent
l'exécution arbitraire de code Python lors du chargement de fichiers pickle
contrôlés par un attaquant via le builder packagé pandas, déprécié mais
toujours enregistré.
Le builder résout les data_files fournis par l'appelant, ouvre chaque fichier
sous forme d'octets et passe directement l'objet fichier à pandas.read_pickle()
avant de convertir le résultat en table Arrow :
with open(file, "rb") as f:
pa_table = pa.Table.from_pandas(pd.read_pickle(f))
La désérialisation de pickle Python peut exécuter du code choisi par l'attaquant. Lorsqu'une victime charge un jeu de données malveillant basé sur pickle avec
datasets.load_dataset("pandas", data_files=...), la charge utile s'exécute avec
les privilèges du processus de la victime avant la conversion Arrow ou la validation des caractéristiques.
Un attaquant capable d'amener une victime à charger un pickle contrôlé par l'attaquant via
le builder pandas peut exécuter du code Python arbitraire dans le processus de la victime.
Cela peut affecter les workflows d'analyse de données, d'apprentissage automatique et d'automatisation qui
chargent des jeux de données depuis des projets, dépôts, téléchargements ou fichiers partagés non fiables.
L'attaquant n'a pas besoin de privilèges dans l'environnement de la victime, mais la victime
doit charger le jeu de données malveillant, conformément à l'exigence d'interaction utilisateur du rapport (UI:R).
Selon l'environnement local, cela peut permettre :
Le chemin vulnérable est le builder packagé 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(...)
Le PoC crée un objet pickle dont la méthode __reduce__() spécifie un callable qui écrit un fichier marqueur local inoffensif et renvoie un pandas.DataFrame valide. Lors de la désérialisation, ce callable s'exécute avant que le builder ne convertisse le DataFrame renvoyé en table Arrow. Le chargement du dataset se termine ensuite normalement et renvoie une ligne.
Le runner invoque l'API réelle datasets.load_dataset() du package installé. Un cache local neuf et la suppression du marqueur précédent garantissent que le résultat enregistré démontre l'exécution pendant le chargement du dataset.
Déprécier le builder ou valider le DataFrame renvoyé n'empêche pas l'exécution lors du dépickling. La documentation pandas mise également en garde contre le chargement de données pickle provenant de sources non fiables.
run_poc.py génère attacker-controlled.pkl, le charge via le builder pandas et enregistre les preuves d'exécution.
À exécuter uniquement dans un environnement de test local. Pour reproduire la version présentée dans les preuves enregistrées sous Windows :
python -m venv .venv
.\.venv\Scripts\python.exe -m pip install "datasets==5.1.0"
.\.venv\Scripts\python.exe -B run_poc.py
Le fichier requirements.txt inclus spécifie actuellement
datasets<=5.0.1. Il peut être installé avec
python -m pip install -r requirements.txt pour tester cette plage antérieure, mais il
ne sélectionne pas l'installation 5.1.0 utilisée dans les preuves enregistrées. L'épinglage explicite
ci-dessus reproduit la version de datasets de cette installation.
Preuves attendues sur la version vulnérable démontrée :
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'élément de preuve important est que le marqueur est absent avant load_dataset(), apparaît pendant le chargement, et contient la chaîne attendue tandis que le chargement du jeu de données se termine avec succès et renvoie la ligne attendue.
L'effet d'exécution de la charge utile est une écriture locale d'un fichier marqueur :
datasets_pandas_pickle_rce_triggered
Le runner écrit également les fichiers pickle, cache et preuve générés. Chaque exécution
remplace attacker-controlled.pkl, marker.txt, cache/ et evidence/ dans le
répertoire PoC ; préservez les preuves existantes avant de le réexécuter.
Artefacts enregistrés :
Le correctif ciblé remplace l'intégralité du corps de Pandas._generate_tables() par
une erreur inconditionnelle avant qu'aucun fichier ne soit ouvert ou transmis à
pandas.read_pickle() :
def _generate_tables(self, files):
raise ValueError(PANDAS_PICKLE_DISABLED_ERROR)
L'erreur explique le risque d'exécution de pickle et oriente les appelants vers Parquet, Arrow, CSV, JSON ou Dataset.from_pandas() pour un DataFrame existant. Cela bloque le chemin d'exécution de code signalé pour chaque nom de fichier, y compris les pickles de confiance ; il ne tente pas de déterminer quels fichiers pickle sont dignes de confiance.
Le builder reste enregistré et peut toujours être construit via load_dataset_builder("pandas", ...) ou Pandas(...). La résolution de fichiers et les téléchargements peuvent se produire avant que la génération de table échoue. Avec le streaming, l'erreur se produit lors de l'itération du dataset. Un cache Arrow préparé compatible peut toujours être réutilisé sans appeler _generate_tables() ni dépickler l'entrée. Modifier la source du builder change son hash, de sorte que les anciens caches peuvent ne plus correspondre automatiquement. Ce correctif ne rejette pas le nom du builder dans load.py.
Par exemple, chargez Parquet via son builder dédié :
from datasets import load_dataset
dataset = load_dataset("parquet", data_files="data.parquet", split="train")