Technical Tutorials

Dans le paysage moderne du développement web, sécuriser les interfaces de programmation (API) n'est pas seulement une bonne pratique ; c'est une exigence fondamentale. Alors que les applications monopages (SPA) et les applications mobiles communiquent avec des serveurs backend, l'authentification basée sur les sessions traditionnelles devient souvent fastidieuse. C'est ici que les jetons web JSON (JWT) brillent. Le JWT est devenu la norme de l'industrie pour l'authentification sans état, permettant aux développeurs de transmettre l'identité de l'utilisateur de manière sécurisée entre le client et le serveur sans stocker de données de session côté serveur. Dans cet article, nous analyserons le fonctionnement des JWT, explorerons leur implémentation en Python et discuterons des considérations de sécurité critiques qui séparent souvent les implémentations amateurs des systèmes prêts pour la production.

Comprendre l'anatomie d'un JWT

Avant de plonger dans le code, il est essentiel de comprendre ce qu'est réellement un JWT. Un JWT est une norme ouverte (RFC 7519) qui définit un moyen compact et autonome de transmettre des informations de manière sécurisée entre des parties sous forme d'objet JSON. Ces informations peuvent être vérifiées et considérées comme fiables car elles sont signées numériquement. Les JWT peuvent être signés à l'aide d'un secret (avec l'algorithme HMAC) ou d'une paire de clés publique/privée en utilisant RSA ou ECDSA.

Un JWT se compose de trois parties, séparées par des points (.) :

En-tête : Compose généralement de deux parties : le type de jeton (JWT) et l'algorithme de signature utilisé (par exemple, HS256, RS256).
Payload : Contient les revendications. Les revendications sont des déclarations concernant une entité (généralement l'utilisateur) et des données supplémentaires. Il existe trois types de revendications : les revendications enregistrées, publiques et privées.
Signature : Créée en prenant l'en-tête encodé, le payload encodé, un secret et l'algorithme spécifié dans l'en-tête, puis en signant le tout.

Le jeton résultant ressemble à ceci :

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Implémentation de JWT en Python avec Flask

Pour cet exemple pratique, nous utiliserons Python avec Flask et la bibliothèque PyJWT. Cette configuration démontre comment générer, encoder et vérifier les jetons. Tout d'abord, assurez-vous que la bibliothèque requise est installée :

pip install flask pyjwt

Voici une implémentation de base d'une application Flask qui gère la connexion des utilisateurs et la génération de jetons. Notez que dans un environnement de production, vous ne devez jamais coder les secrets en dur ni stocker les mots de passe en texte clair.

import jwt
import datetime
from flask import Flask, request, jsonify

app = Flask(__name__)
# En production, utilisez des variables d'environnement
SECRET_KEY = "your-super-secret-key-change-this-in-production"

def generate_token(user_id):
    """Génère un jeton JWT avec une expiration."""
    payload = {
        'user_id': user_id,
        'exp': datetime.datetime.utcnow() + datetime.timedelta(hours=1),
        'iat': datetime.datetime.utcnow()
    }
    token = jwt.encode(payload, SECRET_KEY, algorithm="HS256")
    return token

@app.route('/login', methods=['POST'])
def login():
    """Point de terminaison de connexion simple."""
    data = request.json
    # En réalité, vérifiez les informations d'identification contre une base de données ici
    if data.get('username') == 'admin' and data.get('password') == 'password':
        token = generate_token(1)
        return jsonify({'token': token})
    return jsonify({'message': 'Identifiants invalides'}), 401

@app.route('/protected', methods=['GET'])
def protected_route():
    """Une route protégée nécessitant un JWT valide."""
    token = request.headers.get('Authorization').split(" ")[1]
    try:
        # Vérifier et décoder le jeton
        data = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
        return jsonify({'message': 'Accès accordé à l\'utilisateur', 'user_id': data['user_id']})
    except jwt.ExpiredSignatureError:
        return jsonify({'message': 'Le jeton a expiré'}), 401
    except jwt.InvalidTokenError:
        return jsonify({'message': 'Jeton invalide'}), 401

if __name__ == '__main__':
    app.run(debug=True)

Meilleures pratiques de sécurité et pièges courants

Bien que les JWT soient puissants, une implémentation incorrecte peut entraîner de graves vulnérabilités de sécurité. Voici les règles critiques à suivre :

1. Ne stockez jamais de données sensibles dans le payload : Puisque le payload n'est que codé en base64 et non chiffré, toute personne disposant du jeton peut en lire le contenu. N'incluez jamais de mots de passe, de données personnelles (PII) ou de données financières sensibles dans le payload du JWT. Si vous devez stocker des données sensibles, stockez un ID de référence dans le jeton et récupérez les détails depuis une base de données sécurisée.

2. Validez toujours l'algorithme : L'une des attaques les plus courantes contre les implémentations de JWT est le changement d'algorithme. Si le serveur accepte les jetons RS256 mais que l'attaquant fournit un jeton HS256 signé avec la clé publique, le serveur pourrait le valider incorrectement. Spécifiez toujours explicitement les algorithmes autorisés (par exemple, algorithms=["HS256"]) dans votre fonction de décodage.

3. Implémentez des durées de vie courtes avec des jetons d'actualisation : Les jetons d'accès doivent avoir une durée de vie courte (par exemple, 15 minutes) pour limiter la fenêtre d'opportunité pour un attaquant qui aurait volé le jeton. Utilisez des jetons d'actualisation pour obtenir de nouveaux jetons d'accès sans obliger l'utilisateur à se reconnecter. Les jetons d'actualisation doivent être stockés en toute sécurité (par exemple, cookies HttpOnly) et gérés côté serveur ou avec des politiques de rotation.

4. Sécurisez la transmission : Servez toujours votre application via HTTPS. Les JWT sont généralement transmis dans l'en-tête Authorization. S'ils sont transmis via HTTP, le jeton peut être intercepté via des attaques de type homme du milieu.

Conclusion

L'authentification JWT fournit une solution robuste et évolutive pour sécuriser les applications web modernes. En comprenant sa structure, en l'implémentant correctement à l'aide de bibliothèques comme PyJWT et en adhérant à des directives de sécurité strictes, les développeurs peuvent protéger leurs API contre les accès non autorisés. Rappelez-vous que la sécurité est un processus continu ; auditez régulièrement vos flux d'authentification, maintenez vos dépendances à jour et restez informé des menaces émergentes. Avec la bonne approche, les JWT peuvent être un allié puissant dans votre boîte à outils de sécurité d'application.