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/certbn/cve-2026-97229-gitlab-ci-cd
Analisi delle VulnerabilitàAnalisi del CodiceExploitSfruttamento di Applicazioni WebDevSecOpsThreat IntelligencePaper e RicercaApprendimento e FormazioneRisposta agli Incidenti
GitHubcertbn/cve-2026-97229-gitlab-ci-cd

CVE-2026-97229-GitLab-CI-CD

Analisi tecnica e advisory di CVE-2026-97229, un overflow di interi nella regex di GitLab CI/CD che consente RCE non autenticato, con root-cause, diff della patch, regole di rilevamento e IoC.

Vedi Repository
15 giorni faNon ancora revisionato
Condividi

CVE-2026-97229: Esecuzione di codice remoto non autenticata (RCE) causata da un overflow di interi nel compilatore di espressioni regolari di GitLab CI/CD

CVSS Type KEV Auth

📌 TL;DR

  • Un overflow di interi (integer overflow, CWE-190) che si verifica durante l'elaborazione delle espressioni regolari (regular expression) nella CI/CD di GitLab CE/EE, che consente l'esecuzione di codice arbitrario (RCE) sul server GitLab tramite espressioni regolari manipolate. CVSS v3.1 10.0 (valore massimo).
  • La causa principale non risiede in GitLab stesso, ma nel motore di espressioni regolari integrato in Ruby Onigmo, raggiungibile tramite il percorso in cui GitLab compila le espressioni regolari fornite dall'utente con Regexp.new.
  • Le istanze interessate sono quelle self-managed. GitLab.com e Dedicated sono già stati corretti. Inserita nella CISA KEV il 2026-10-29, con sfruttamento reale confermato — è necessario applicare immediatamente la patch.

📋 Informazioni di base

VoceContenuto
CVE IDCVE-2026-97229
Data di pubblicazione2026-10-12 (pubblicazione dell'avviso GitLab) / pubblicazione del record CVE 2026-10-13
Prodotti interessatiGitLab Community Edition (CE) ed Enterprise Edition (EE), self-managed
Versioni interessate19.2 (< 19.2.8), 19.3 (< 19.3.5), 19.4 (< 19.4.2)
Versioni corrette19.2.8, 19.3.5, 19.4.2 o successive (vedere la "Nota" di seguito)
CVSS v3.110.0 (Critical) — CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
CVSS v4.0Vettore v4.0 non fornito nell'avviso ufficiale del fornitore (GitLab) né nel record CVE (nessun valore confermato)
CWECWE-190 (Integer Overflow or Wraparound)
Segnalatorejoaxcar (Johan Carlsson), bug bounty GitLab HackerOne
Sfruttamento realeInserita nella CISA KEV (2026-10-29, scadenza per le agenzie federali 2026-11-01). PoC pubblico disponibile (Rapid7, 2026-10-13). Tentativi di sfruttamento osservati contro istanze Alpine Linux (2026-10-20~21)

⚠️ Nota importante sulle versioni corrette (fatto verificato)

  • 19.3.4 non è una correzione valida. L'avviso iniziale indicava la correzione del ramo 19.3 come 19.3.4, ma la 19.3.4 presentava un bug che influiva sulla pagina delle merge request quando l'integrazione con Ona era attiva, ed è stata sostituita dalla 19.3.5. Alcune fonti secondarie indicano ancora erroneamente la 19.3.4 come versione corretta. Secondo la versione più recente dell'avviso del fornitore, la correzione del ramo 19.3 è la 19.3.5.
  • Le build da sorgente (source) o le immagini container che utilizzano un Ruby proprio rimangono vulnerabili anche aggiornando solo GitLab. Questo perché la correzione ha interessato il Ruby incluso (bundled) nei pacchetti Omnibus ufficiali di GitLab e nelle immagini CNG. In tali ambienti è necessario aggiornare Ruby alla versione 3.3.13 / 3.4.12 / 4.0.9 o successiva (rilasci del 2026-10-22~23). Questo è stato effettivamente un problema nel caso di Alpine Linux.

🔍 Analisi della causa della vulnerabilità (Root Cause)

1) Posizione e comportamento del codice vulnerabile

GitLab confronta le espressioni regolari fornite dall'utente con il percorso del repository (repository path) in rules:exists:regexp, rules:changes:regexp, ecc. della configurazione CI/CD. Queste espressioni regolari vengono infine compilate tramite Regexp.new di Ruby, e il motore interno Onigmo (motore di espressioni regolari incluso in Ruby, scritto in C) le converte in bytecode (pcode).

Il difetto fondamentale risiede nel calcolo della dimensione di espansione dei quantificatori (quantifier) nel compilatore Onigmo. Poiché la dimensione del programma compilato viene accumulata utilizzando un intero con segno a 32 bit e gli offset di salto vengono memorizzati in un RelAddrType con segno a 32 bit, quando il risultato della compilazione supera INT_MAX, sia il calcolo della lunghezza sia gli offset di salto vanno in wraparound.

Il controllo della dimensione in compile_quantifier_node() di regcomp.c di Ruby 3.3.12 è il punto chiave (secondo l'analisi di Rapid7 e i commit di Ruby):

/* regcomp.c: compile_quantifier_node() — 취약 로직 */
else if (!infinite && qn->greedy &&
         (qn->upper == 1 || (tlen + SIZE_OP_PUSH) * qn->upper
                                <= QUANTIFIER_EXPAND_LIMIT_SIZE)) { // 부호 있는 곱셈 → 오버플로
    ...
    r = compile_tree_n_times(qn->target, qn->lower, reg); // 모든 복사본을 인라인 확장
}

Se il prodotto tra la dimensione del corpo ripetuto (tlen) e il numero di ripetizioni (qn->upper) supera INT_MAX, il risultato va in wrap diventando negativo e supera il controllo "è sufficientemente piccolo, quindi si può espandere inline". Di conseguenza Onigmo genera un pcode enorme, e gli offset di salto calcolati successivamente con la lunghezza andata in wrap indirizzano il flusso di esecuzione verso posizioni errate.

2) Perché è un problema — Le difese di GitLab e il loro bypass

GitLab adotta diverse difese sulle espressioni regolari, ma vengono aggirate come segue (secondo il percorso end-to-end pubblicato da Rapid7):

  • Controllo della lunghezza del sorgente: esamina solo la lunghezza del sorgente prima dell'espansione.
  • Scanner del limite di ripetizione (REPEAT_BOUND, limite 1.000): riconosce solo cifre consecutive. Il PoC inserisce nel mezzo un commento inline di regex (?#), come in {5(?#)7805}, ingannando lo scanner. Onigmo ignora (?#) e legge il limite come 57.805, ma lo scanner non rileva il superamento di 1.000.
  • Controllo della dimensione di compilazione (limite di circa 1MB): viene eseguito solo al momento della prima compilazione US-ASCII. Tuttavia, se il percorso da confrontare contiene caratteri UTF-8 a 4 byte, Ruby ricompila in codifica UTF-8 in rb_reg_prepare_re(). In quel momento classi di caratteri POSIX come [[:word:]] si espandono in enormi tabelle di intervalli Unicode, ma GitLab non controlla la dimensione del risultato di questa ricompilazione. Inoltre, questa ricompilazione avviene al di fuori del timeout di matching (Regexp.timeout), quindi non viene bloccata nemmeno dal timeout.

In altre parole, una piccola espressione regolare (dell'ordine di 986 byte) supera i controlli e solo nella ricompilazione UTF-8 al momento del matching diventa un programma di grandi dimensioni che provoca l'overflow.

Nota (ipotesi): il percorso analizzato e pubblicato da Rapid7 presuppone che "si effettui prima il push di un .gitlab-ci.yml manipolato e di un percorso speciale in un progetto pubblico (richiede permessi di scrittura)". Questo contrasta con la valutazione PR:N (nessun permesso richiesto) di GitLab, ma poiché il report originale su HackerOne è privato, non è stato confermato pubblicamente come l'attacco segnalato aggiri la fase di scrittura (anche Rapid7 dichiara di non saperlo). Pertanto, il percorso esatto del report originale su cui si basa la valutazione di "completamente non autenticato" è attualmente oggetto di ipotesi.

3) Confronto del diff della patch (Before / After)

Basato su Ruby PR #19020 (commit cf35145fc4, backport 2d1859ffa6) + commit successivo 366f5fdc00. GitLab ha effettuato il backport di questa patch Ruby nel Ruby incluso (omnibus-gitlab MR !9845).

(a) Sostituzione della moltiplicazione con segno con un controllo basato sulla divisione (impossibilità di overflow)

/* Before: (tlen + SIZE_OP_PUSH) * qn->upper <= QUANTIFIER_EXPAND_LIMIT_SIZE  → 곱셈이 오버플로 */

/* After: regcomp.c */
#define IS_EXPAND_LIMIT_OK(tlen, n) \
  ((n) <= 0 || (tlen) <= QUANTIFIER_EXPAND_LIMIT_SIZE / (n))
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.

    927
  • 2

    ghostlock-app

    yukonga/ghostlock-app

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

    555
  • 3

    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.

    360
  • 4

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

    357
  • 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.

    324
  • 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.

    289

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →