Exemple de Validation JWT en Python

⚠️ Avis Important : Ceci est un exemple basique à des fins de démonstration uniquement. Pour une utilisation en production, veuillez rechercher et mettre en œuvre les meilleures pratiques spécifiques à votre pile logicielle, vos exigences de sécurité et votre environnement de déploiement. Suivez toujours les directives de sécurité de votre organisation et envisagez d'utiliser des bibliothèques et des frameworks JWT établis.

📝 Remarque : Cet exemple démontre le téléchargement de JWKS et la mise en cache de fichiers à des fins éducatives. Dans les environnements de production, vous pouvez choisir de mettre en œuvre la gestion des clés JWKS différemment en fonction de votre infrastructure - comme en utilisant la gestion de configuration, des variables d'environnement, ou votre stratégie de mise en cache préférée.

Cet exemple démontre comment valider les jetons JWT de Rokt en utilisant Python.

Prérequis

Installez les packages requis :

pip install PyJWT cryptography

Exemple Complet

import jwt
import json
import base64
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives.asymmetric.ec import EllipticCurvePublicNumbers, SECP256R1
from cryptography.hazmat.backends import default_backend
from datetime import datetime

def load_jwk_public_key(jwk):
    """Convertir JWK en clé publique ECDSA"""
    # Décoder les coordonnées encodées en base64url
    x = int.from_bytes(base64.urlsafe_b64decode(jwk['x'] + '=='), 'big')
    y = int.from_bytes(base64.urlsafe_b64decode(jwk['y'] + '=='), 'big')
    
    # Créer une clé publique ECDSA
    public_numbers = EllipticCurvePublicNumbers(x, y, SECP256R1())
    return public_numbers.public_key(default_backend())

def validate_jwt_token(token, jwks_json):
    """Valider le jeton JWT en utilisant JWKS"""
    try:
        # Analyser JWKS
        jwks = json.loads(jwks_json)
        if not jwks.get('keys'):
            raise ValueError('Aucune clé trouvée dans JWKS')
        
        # Obtenir la première clé
        jwk = jwks['keys'][0]
        
        # Convertir JWK en clé publique
        public_key = load_jwk_public_key(jwk)
        
        # Vérifier et décoder le jeton JWT
        claims = jwt.decode(
            token, 
            public_key, 
            algorithms=['ES256'],
            leeway=60  # Permettre une dérive d'horloge de 1 minute
        )
        
        return {
            'is_valid': True,
```python
    'claims': claims
}

except Exception as e:
    return {
        'is_valid': False,
        'error': str(e)
}

def main():
    # Copiez le jeton de test depuis la page d'aperçu
    sample_token = "PASTE_TEST_TOKEN_HERE"

    # URL du point de terminaison JWKS
    jwks_url = "https://public-api.rokt.com/.well-known/jwks.json"

    print("=== Validateur JWT Python ===")
    print(f"Token: {sample_token[:50]}...")
    print(f"JWKS URL: {jwks_url}")
    print()

    # Télécharger et mettre en cache le JWKS
    import requests
    import json
    import os
    from datetime import datetime, timedelta

    jwks_cache_file = "jwks_cache.json"

    # Vérifiez si le fichier de cache existe et est récent (moins de 24 heures)
    if os.path.exists(jwks_cache_file):
        file_age = datetime.now() - datetime.fromtimestamp(os.path.getmtime(jwks_cache_file))
        if file_age < timedelta(hours=24):
            print(f"Utilisation du JWKS mis en cache depuis : {jwks_cache_file}")
            with open(jwks_cache_file, 'r') as f:
                jwks_json = f.read()
        else:
            print("Cache expiré, téléchargement d'un nouveau JWKS")
            response = requests.get(jwks_url, timeout=10)
            response.raise_for_status()
            jwks_json = response.text

            # Mettre en cache le JWKS
            with open(jwks_cache_file, 'w') as f:
                f.write(jwks_json)
            print(f"JWKS mis en cache dans : {jwks_cache_file}")
    else:
        print("Aucun cache trouvé, téléchargement du JWKS")
        response = requests.get(jwks_url, timeout=10)
        response.raise_for_status()
        jwks_json = response.text

        # Mettre en cache le JWKS
        with open(jwks_cache_file, 'w') as f:
            f.write(jwks_json)
        print(f"JWKS mis en cache dans : {jwks_cache_file}")

    print("JWKS téléchargé et mis en cache avec succès")

    # Extraire les coordonnées de la clé publique du JWKS
    jwks_data = json.loads(jwks_json)
    if not jwks_data.get('keys') or len(jwks_data['keys']) == 0:
        raise Exception("Aucune clé trouvée dans le JWKS")

    key = jwks_data['keys'][0]
    x_coordinate = key['x']
    y_coordinate = key['y']

    # Valider le jeton
    result = validate_jwt_token(sample_token, jwks_json)

    if result['is_valid']:
``````python
claims = result['claims']
print("✅ Validation du jeton réussie !")
print(f"ID de la campagne : {claims.get('cid')}")
print(f"ID de la création : {claims.get('crid')}")
print(f"RCLID : {claims.get('rclid')}")
print(f"Émis à : {datetime.fromtimestamp(claims.get('iat')).strftime('%Y-%m-%d %H:%M:%S UTC')}")
else:
print(f"❌ Échec de la validation du jeton : {result['error']}")

if __name__ == "__main__":
main()

Exemple d'entrée/sortie

Entrée

• Jeton JWT : Copiez le jeton de test depuis la page d'aperçu
• Source de la clé publique : https://public-api.rokt.com/.well-known/jwks.json

Sortie

=== Validateur Python JWT ===
Jeton : eyJhbGciOiJFUzI1NiIsImtpZCI6InJva3Qtc2lnbmluZy1rZXkiLCJ0eXAiOiJKV1QifQ...
URL JWKS : https://public-api.rokt.com/.well-known/jwks.json

Téléchargement du JWKS depuis : https://public-api.rokt.com/.well-known/jwks.json
JWKS mis en cache dans : jwks_cache.json
JWKS téléchargé et mis en cache avec succès

✅ Validation du jeton réussie !
ID de la campagne : 3436085368692408324
ID de la création : 3437732754935906308
RCLID : 7db958dbd232247a4a8285a34d22fe0f4e9affa463bf5ee54e26721ab0df0e23
Émis à : 2025-08-20 15:10:01 UTC

1. Enregistrez le code dans `rokt_jwt_validator.py`
2. Installez les dépendances : `pip install PyJWT cryptography`
3. Exécutez : `python rokt_jwt_validator.py`

## Implémentation alternative avec jose

Pour une solution plus robuste, vous pouvez également utiliser la bibliothèque `python-jose` :

```bash
pip install python-jose[cryptography]

from jose import jwt
from jose.jwk import get_public_key

def validate_with_jose(token, jwks_json):
    jwks = json.loads(jwks_json)
    public_key = get_public_key(jwks['keys'][0])
    
    claims = jwt.decode(
        token,
        public_key,
        algorithms=['ES256']
    )
    return claims

Remarques

• La clé publique est récupérée depuis le point de terminaison JWKS de Rokt

• L'exemple utilise l'algorithme ECDSA-256 (ES256) pour la vérification de signature

• Envisagez de mettre en cache la clé publique pour améliorer les performances

• La bibliothèque cryptography offre une meilleure sécurité que les implémentations purement Python