
Documenta CVE-2026-65320, un path traversal di tipo tar-slip in untar_dir() di fastcore, con un proof-of-concept innocuo che dimostra la scrittura arbitraria di file e l'esecuzione di codice.
untar_dir()Gravità: Critica, CVSS 3.1 9.8
Vettore (v3.1): CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
Interessato: fastcore dalla 0 alla 2.2.44 (ultima al momento della scrittura; non corretto)
Corretto in: Non corretto al momento della scrittura
CWE: CWE-22 (Improper Limitation of a Pathname to a Restricted Directory, 'Path Traversal')
Componente: fastcore.xtras.untar_dir() → fastcore.xtras._unpack() → shutil.unpack_archive()
Runtime ad alto rischio: Python < 3.14 (Python 3.14 rende predefinito il filtro tar sicuro data)
Segnalato da: Rahul Karne
CNA: VulnCheck
fastcore.xtras.untar_dir(fname, dest) è un helper documentato che estrae un archivio tar "in dest".
Internamente, passa l'archivio a shutil.unpack_archive() della libreria standard senza un filtro di estrazione, senza validare i percorsi dei membri dell'archivio e senza alcun controllo di contenimento post-estrazione.
Di conseguenza, un archivio TAR i cui membri contengono sequenze di traversal ../ o percorsi assoluti può scrivere file al di fuori della directory in cui il chiamante ha chiesto a fastcore di estrarre.
Un chiamante che ragionevolmente si aspetta che untar_dir(fname, dest) confini tutto a dest ottiene invece una scrittura arbitraria di file ovunque il processo possa scrivere.
Scrittura arbitraria di file sotto l'autorità del processo che chiama untar_dir().
A seconda di ciò che viene sovrascritto, questo può comportare:
La proof of concept dimostra l'intera catena scrittura → import → esecuzione di codice dall'inizio alla fine, interamente all'interno di una innocua directory demo.
fastcore è una dipendenza fondamentale in tutto l'ecosistema fast.ai, tra cui:
fastainbdevghapiRiceve decine di milioni di download al mese.
untar_dir() è la primitiva di estrazione alla base del comune flusso di lavoro "scarica un archivio, poi estrailo", che segue lo stesso schema generale di untar_data di fastai.
Qualsiasi percorso di codice che passi a untar_dir() un archivio il cui contenuto non è completamente fidato è esposto.
Il codice vulnerabile esiste in 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() crea una directory temporanea interna di estrazione:
<tempdir>/<random>/<archive-stem>/
Poi chiama _unpack(), che inoltra direttamente l'archivio a:
shutil.unpack_archive()
Per gli archivi TAR, questo alla fine chiama tarfile.extractall().
Su Python < 3.14, il comportamento di estrazione predefinito è fully_trusted, il che significa che i membri con traversal possono essere onorati.
Ad esempio, un membro dell'archivio come:
../../../some/other/dir/file
è scritto relativamente alla directory di estrazione e può quindi uscirne.
Niente in fastcore:
filter="data" dove supportato....untar_dir() tratta shutil.unpack_archive() come se fosse un estrattore di archivi sicuro e isolato.
Non lo è.
La documentazione della libreria standard di Python avverte che l'estrazione di archivi non attendibili può creare file al di fuori della destinazione richiesta e raccomanda un filtro di estrazione sicuro per gli archivi TAR.
fastcore non passa un filtro di estrazione appropriato né implementa una protezione equivalente di contenimento per le versioni di Python supportate.
Inoltre non avverte i chiamanti di untar_dir() riguardo a questo comportamento sensibile alla sicurezza.
I membri TAR possono contenere stringhe di percorso arbitrarie.
Nelle versioni di Python interessate, tarfile.extractall() non neutralizza automaticamente le sequenze di traversal .. per impostazione predefinita.
Scrivere un membro di traversal relativamente alla directory temporanea di estrazione di fastcore è quindi sufficiente per uscire da quella directory e scrivere ovunque il processo abbia il permesso di scrivere.
Una primitiva affidabile è il traversal relativo come:
../../../target/file
Questa è la tecnica utilizzata dalla proof of concept.
L'input pericoloso è il contenuto dell'archivio, non il percorso di destinazione scelto dallo sviluppatore.
Gli archivi vengono spesso ottenuti da posizioni esterne o semi-affidabili, tra cui:
Qualsiasi servizio o strumento che scarica un archivio da una fonte non affidabile o semi-affidabile e successivamente lo elabora utilizzando untar_dir() può quindi essere raggiungibile.
La PoC include anche una variante che serve l'archivio appositamente creato da un endpoint HTTP controllato dall'attaccante per dimostrare questo percorso di distribuzione.
Lo sfruttamento riuscito richiede:
L'applicazione chiama fastcore.xtras.untar_dir() su un archivio il cui contenuto è influenzato dall'attaccante, come un archivio caricato, scaricato o comunque non affidabile.
Il runtime utilizza Python < 3.14, o un'altra configurazione in cui non viene applicato un filtro di estrazione TAR sicuro.
Per l'escalation da scrittura arbitraria di file a esecuzione di codice, il processo successivamente importa o carica un file da una posizione raggiungibile tramite il traversal, come ad esempio:
La scrittura arbitraria di file e la modifica di configurazione/dati richiedono solo le condizioni 1 e 2.
poc_fastcore_cna_demo.py invoca l'API reale fastcore.xtras.untar_dir().
La dimostrazione è intenzionalmente innocua.
Ogni file creato dalla PoC rimane all'interno di un'unica directory demo specificata utilizzando:
--demo-root
Il PoC non modifica i file di sistema reali e non accede a servizi cloud o credenziali.
_unpack() e untar_dir().