
Prova de conceito e patch para CVE-2026-57845: RCE por desserialização de pickle no builder pandas do Hugging Face datasets, com script de reprodução e orientações de remediação.
<= 5.1.0Severidade: Alta, CVSS 3.1 8.8
Vetor: CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
Afetado: todas as versões de datasets do Hugging Face <= 5.1.0
Componente: datasets.packaged_modules.pandas.pandas
CWE: CWE-502 (Desserialização de Dados Não Confiáveis)
Descoberto e reportado por: Sai Teja Erukude
As versões de datasets do Hugging Face até a 5.1.0, inclusive, permitem a execução
arbitrária de código Python ao carregar arquivos pickle controlados por um atacante por meio
do builder empacotado pandas, obsoleto mas ainda registrado.
O builder resolve os data_files fornecidos pelo chamador, abre cada arquivo como bytes
e passa o objeto de arquivo diretamente para pandas.read_pickle() antes de converter
o resultado em uma tabela Arrow:
with open(file, "rb") as f:
pa_table = pa.Table.from_pandas(pd.read_pickle(f))
A desserialização de pickle do Python pode executar código escolhido pelo atacante. Quando uma vítima
carrega um conjunto de dados malicioso baseado em pickle com
datasets.load_dataset("pandas", data_files=...), o payload é executado com
os privilégios do processo da vítima antes da conversão para Arrow ou da validação de features.
Um atacante que consiga fazer com que uma vítima carregue um pickle controlado pelo atacante através
do builder pandas pode executar código Python arbitrário no processo da vítima.
Isso pode afetar fluxos de trabalho de análise de dados, aprendizado de máquina e automação que
carregam conjuntos de dados de projetos, repositórios, downloads ou arquivos compartilhados não confiáveis.
O atacante não precisa de privilégios no ambiente da vítima, mas a vítima
deve carregar o conjunto de dados malicioso, em conformidade com o requisito de interação do usuário
do relatório (UI:R).
Dependendo do ambiente local, isso pode permitir:
O caminho vulnerável é o builder empacotado 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(...)
O PoC cria um objeto pickle cujo método __reduce__() especifica um callable
que escreve um arquivo marcador local inofensivo e retorna um
pandas.DataFrame válido. Durante a desserialização, esse callable é executado antes
que o builder converta o DataFrame retornado em uma tabela Arrow. O carregamento do dataset então
é concluído normalmente e retorna uma linha.
O runner invoca a API real datasets.load_dataset() do pacote
instalado. Um cache local novo e a remoção do marcador anterior garantem que o
resultado salvo demonstre a execução durante o carregamento do dataset.
Descontinuar o builder ou validar o DataFrame retornado não impede a execução durante o unpickling. A documentação do pandas também alerta contra o carregamento de dados pickle de fontes não confiáveis.
run_poc.py gera attacker-controlled.pkl, o carrega através
do builder pandas e registra evidências de execução.
Execute apenas em um ambiente de teste local. Para reproduzir a versão mostrada na evidência salva no Windows:
python -m venv .venv
.\.venv\Scripts\python.exe -m pip install "datasets==5.1.0"
.\.venv\Scripts\python.exe -B run_poc.py
O requirements.txt incluído atualmente especifica
datasets<=5.0.1. Ele pode ser instalado com
python -m pip install -r requirements.txt para testar essa faixa anterior, mas
não seleciona a instalação 5.1.0 usada nas evidências salvas. A fixação explícita
acima reproduz a versão de datasets dessa instalação.
Evidências esperadas na versão vulnerável demonstrada:
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
A evidência importante é que o marcador está ausente antes de load_dataset(),
aparece durante o carregamento e contém a string esperada enquanto o carregamento do dataset
é concluído com sucesso e retorna a linha esperada.
O efeito de execução do payload é uma escrita local de arquivo marcador:
datasets_pandas_pickle_rce_triggered
O executor também grava os arquivos pickle, cache e evidências gerados. Cada execução
substitui attacker-controlled.pkl, marker.txt, cache/ e evidence/ no
diretório do PoC; preserve as evidências existentes antes de executá-lo novamente.
Artefatos salvos:
A correção pontual substitui todo o corpo de Pandas._generate_tables() por
um erro incondicional antes que qualquer arquivo seja aberto ou passado para
pandas.read_pickle():
def _generate_tables(self, files):
raise ValueError(PANDAS_PICKLE_DISABLED_ERROR)
O erro explica o risco de execução de pickle e direciona os chamadores para Parquet, Arrow, CSV, JSON ou Dataset.from_pandas() para um DataFrame existente. Isso bloqueia o caminho de execução de código relatado para todos os nomes de arquivo, incluindo pickles confiáveis; não tenta determinar quais arquivos pickle são confiáveis.
O builder permanece registrado e ainda pode ser construído por meio de load_dataset_builder("pandas", ...) ou Pandas(...). A resolução de arquivos e os downloads podem ocorrer antes que a geração da tabela falhe. Com streaming, o erro ocorre quando o dataset é iterado. Um cache Arrow preparado compatível ainda pode ser reutilizado sem chamar _generate_tables() ou fazer unpickle da entrada. Alterar o código-fonte do builder altera seu hash, portanto caches mais antigos podem não corresponder mais automaticamente. Este patch não rejeita o nome do builder em load.py.
Por exemplo, carregue Parquet por meio de seu builder dedicado:
from datasets import load_dataset
dataset = load_dataset("parquet", data_files="data.parquet", split="train")
Os testes de regressão cobrem o carregamento inicial, a iteração em streaming, a geração direta de tabelas, a construção do builder, a reutilização do cache Arrow preparado e os formatos de substituição suportados. Eles verificam que pandas.read_pickle() nunca é alcançado e que a geração direta de tabelas não abre ficheiros. Verificar o tipo de um objeto após o unpickling é demasiado tarde. Renomear um ficheiro, emitir um aviso ou converter um pickle não confiável para outro formato através de um unpickling prévio não resolve o risco de execução.