Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
Strumenti/GitHubGitHub/rahulreddykarne/cve-2026-65320-fastcore
Analisi delle VulnerabilitàAnalisi del CodiceExploitSfruttamento di Applicazioni WebPaper e RicercaApprendimento e Formazione
GitHubrahulreddykarne/cve-2026-65320-fastcore

CVE-2026-65320-fastcore

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.

Vedi Repository
233 giorni faNon ancora revisionato
Condividi

CVE-2026-65320: Path Traversal (Tar Slip) in fastcore tramite 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


Riepilogo

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.


Impatto

Scrittura arbitraria di file sotto l'autorità del processo che chiama untar_dir().

A seconda di ciò che viene sovrascritto, questo può comportare:

  • Esecuzione di codice — sovrascrivere un file Python che l'applicazione importa successivamente, come un plugin, un hook di avvio o un modulo importabile, oppure inserire un file in una posizione caricata automaticamente.
  • Manomissione di dati / configurazione — sovrascrivere file di configurazione, credenziali o dati dell'applicazione.
  • Denial of service — corrompere file da cui il servizio dipende.

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.


Portata

fastcore è una dipendenza fondamentale in tutto l'ecosistema fast.ai, tra cui:

  • fastai
  • nbdev
  • ghapi
  • Altri pacchetti correlati

Riceve 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.


Dettaglio tecnico

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:

  • Passa filter="data" dove supportato.
  • Rifiuta i percorsi assoluti.
  • Rifiuta i percorsi con lettera di unità.
  • Rifiuta i percorsi UNC.
  • Rifiuta i componenti di percorso ...
  • Rifiuta i membri symlink o hardlink.
  • Verifica che ogni percorso estratto sia rimasto sotto la radice di estrazione prevista prima di restituire successo.

Causa principale

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.


Perché specificamente il percorso TAR

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.


Distribuzione tramite la rete

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:

  • Bundle di modelli
  • Archivi di dataset
  • Bundle di plugin
  • Artefatti CI/CD
  • Caricamenti degli utenti
  • Caricamenti dei partner
  • Download HTTP remoti

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.


Precondizioni di sfruttamento

Lo sfruttamento riuscito richiede:

  1. 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.

  2. Il runtime utilizza Python < 3.14, o un'altra configurazione in cui non viene applicato un filtro di estrazione TAR sicuro.

  3. 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:

    • Una directory di plugin
    • Un modulo Python importabile
    • Un hook di avvio
    • Un'altra posizione di file caricati automaticamente

La scrittura arbitraria di file e la modifica di configurazione/dati richiedono solo le condizioni 1 e 2.


Proof of Concept

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.

Cosa fa il PoC

  1. Stampa i dettagli dell'ambiente e il codice sorgente vulnerabile per _unpack() e untar_dir().
Scarica lo strumento

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Il toolkit OSINT definitivo: grafo di indagine, punteggio di affidabilità, famiglie di alias, mappa, timeline e report. 49 moduli, oltre 400 siti, nessuna chiave API richiesta.

    891
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # App di esecuzione con un tocco GhostLock (CVE-2026-43499)

    547
  • 3

    ARTEX

    baarai/artex

    Piattaforma di penetration testing autonoma multi-agente basata su LLM con agenti planner/worker, grafi di asset e di esplorazione, registrazione del traffico MITM e retesting delle vulnerabilità.

    369
  • 4

    redforge

    cybersecurity91/redforge

    Toolkit red team lato browser con 102 strumenti offline per ricognizione, generazione di payload, attacchi alle credenziali, crittografia, codifica e reportistica dell'engagement.

    366
  • 5

    looking-glass

    anonghosty/looking-glass

    Piattaforma CSIRT che importa i report di Shadowserver in MongoDB e li riproduce come mappe interattive, analisi, risultati, avvisi e dashboard executive.

    309
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Il sistema d'azione per la cybersecurity nativa AI—dove l'intento diventa esecuzione governata, le evidenze diventano memoria operativa, e ogni operazione migliora la successiva.

    282

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →