
Documenta o CVE-2026-65320, uma travessia de caminho tar-slip em untar_dir() do fastcore, com uma prova de conceito inofensiva que demonstra escrita arbitrária de arquivos e execução de código.
untar_dir()Severidade: Crítica, CVSS 3.1 9.8
Vetor (v3.1): CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
Afetado: fastcore 0 até 2.2.44 (mais recente no momento da redação; sem correção)
Corrigido em: Não corrigido no momento da redação
CWE: CWE-22 (Limitação Imprópria de um Caminho a um Diretório Restrito, 'Path Traversal')
Componente: fastcore.xtras.untar_dir() → fastcore.xtras._unpack() → shutil.unpack_archive()
Runtime de alto risco: Python < 3.14 (Python 3.14 torna o filtro tar seguro data o padrão)
Reportado por: Rahul Karne
CNA: VulnCheck
fastcore.xtras.untar_dir(fname, dest) é um helper documentado que extrai um arquivo tar "para dest".
Internamente, ele entrega o arquivo à função shutil.unpack_archive() da biblioteca padrão sem um filtro de extração, sem validar os caminhos dos membros do arquivo e sem qualquer verificação de contenção pós-extração.
Como resultado, um arquivo TAR cujos membros contenham sequências de travessia ../ ou caminhos absolutos pode gravar arquivos fora do diretório no qual o chamador pediu ao fastcore para extrair.
Um chamador que razoavelmente espera que untar_dir(fname, dest) confine tudo a dest acaba obtendo gravação arbitrária de arquivos em qualquer local onde o processo possa gravar.
Gravação arbitrária de arquivos sob a autoridade do processo que chama untar_dir().
Dependendo do que for sobrescrito, isso pode resultar em:
A prova de conceito demonstra a cadeia completa de gravação → importação → execução de código de ponta a ponta, inteiramente dentro de um diretório de demonstração inofensivo.
fastcore é uma dependência fundamental em todo o ecossistema fast.ai, incluindo:
fastainbdevghapiEle recebe dezenas de milhões de downloads por mês.
untar_dir() é a primitiva de extração por trás do fluxo de trabalho comum "baixar um arquivo, depois descompactá-lo", que segue o mesmo padrão geral do untar_data do fastai.
Qualquer caminho de código que forneça a untar_dir() um arquivo cujo conteúdo não seja totalmente confiável está exposto.
O código vulnerável existe em fastcore/xtras.py:
def _unpack(fname, out):
import shutil
shutil.unpack_archive(str(fname), str(out)) # <-- no filter, no validation
ls = out.ls()
return ls[0] if len(ls) == 1 else out
def untar_dir(fname, dest, rename=False, overwrite=False, uid=-1, gid=-1):
"untar `file` into `dest` ..."
import tempfile, shutil
dest = Path(dest)
with tempfile.TemporaryDirectory() as d:
out = Path(d) / remove_suffix(Path(fname).stem, '.tar')
out.mkdir()
...
src = _unpack(fname, out) # extraction escapes `out` here
...
shutil.move(str(src), dest)
...
return dest
untar_dir() cria um diretório temporário interno de extração:
<tempdir>/<random>/<archive-stem>/
Em seguida, ele chama _unpack(), que encaminha o arquivo diretamente para:
shutil.unpack_archive()
Para arquivos TAR, isso, em última análise, chama tarfile.extractall().
No Python < 3.14, o comportamento padrão de extração é fully_trusted, o que significa que membros com traversal podem ser aceitos.
Por exemplo, um membro de arquivo como:
../../../some/other/dir/file
é escrito em relação ao diretório de extração e, portanto, pode escapar dele.
Nada no fastcore:
filter="data" onde houver suporte....untar_dir() trata shutil.unpack_archive() como se fosse um extrator de arquivos seguro e isolado (sandboxed).
Não é.
A documentação da biblioteca padrão do Python alerta que extrair arquivos não confiáveis pode criar arquivos fora do destino solicitado e recomenda a filtragem de extração segura para arquivos TAR.
O fastcore não passa um filtro de extração apropriado nem implementa uma proteção equivalente de contenção para as versões do Python que suporta.
Também não alerta os chamadores de untar_dir() sobre esse comportamento sensível à segurança.
Membros TAR podem conter strings de caminho arbitrárias.
Em versões afetadas do Python, tarfile.extractall() não neutraliza automaticamente sequências de travessia .. por padrão.
Escrever um membro de travessia relativo ao diretório temporário de extração do fastcore é, portanto, suficiente para escapar desse diretório e escrever em qualquer lugar onde o processo tenha permissão de escrita.
Uma primitiva confiável é a travessia relativa, como:
../../../target/file
Esta é a técnica usada pela prova de conceito.
A entrada perigosa é o conteúdo do arquivo, não o caminho de destino escolhido pelo desenvolvedor.
Arquivos compactados são frequentemente obtidos de locais externos ou semiconfiáveis, incluindo:
Qualquer serviço ou ferramenta que baixe um arquivo compactado de uma fonte não confiável ou semiconfiável e subsequentemente o processe usando untar_dir() pode, portanto, estar acessível.
A PoC também inclui uma variante que serve o arquivo compactado manipulado a partir de um endpoint HTTP controlado pelo atacante para demonstrar esse caminho de entrega.
A exploração bem-sucedida requer:
A aplicação chama fastcore.xtras.untar_dir() em um arquivo compactado cujo conteúdo é influenciado pelo atacante, como um arquivo enviado por upload, baixado ou de outra forma não confiável.
O ambiente de execução usa Python < 3.14, ou outra configuração em que um filtro de extração TAR seguro não é aplicado.
Para escalar de escrita arbitrária de arquivos para execução de código, o processo posteriormente importa ou carrega um arquivo de um local alcançável pela travessia, como:
A escrita arbitrária de arquivos e a modificação de configuração/dados exigem apenas as condições 1 e 2.
poc_fastcore_cna_demo.py invoca a API real fastcore.xtras.untar_dir().
A demonstração é intencionalmente inofensiva.
Todo arquivo criado pela PoC permanece dentro de um único diretório de demonstração especificado usando:
--demo-root
O PoC não modifica arquivos reais do sistema e não acessa serviços de nuvem nem credenciais.
Imprime os detalhes do ambiente e o código-fonte vulnerável de _unpack() e untar_dir().
Cria um layout de demonstração contendo:
service_app/plugins/
Cria:
attacker_supplied_upload.tar