Jetons JWT en Rust : bibliothèque jsonwebtoken et gestion de l'authentification

Jetons JWT en Rust : bibliothèque jsonwebtoken

Les JSON Web Tokens (JWT) sont une norme ouverte (RFC 7519) pour créer des jetons d'accès basés sur JSON. Dans l'écosystème Rust, l'une des bibliothèques les plus populaires et stables pour travailler avec JWT est jsonwebtoken. Elle fournit un ensemble complet de fonctions pour créer, signer, vérifier et décoder les jetons JWT, prenant en charge à la fois les algorithmes de chiffrement symétriques (HS256, HS384, HS512) et asymétriques (RS256, RS384, RS512, ES256, ES384).

Installation et configuration

Pour commencer, ajoutez la dépendance dans le fichier Cargo.toml de votre projet :

[dependencies]jsonwebtoken = "9.3"serde = { version = "1.0", features = ["derive"] }chrono = "0.4"

La bibliothèque serde est nécessaire pour la sérialisation et la désérialisation des données du jeton, et chrono simplifie la gestion des horodatages (exp, iat, nbf).

Structure de base d'un JWT

Un jeton JWT se compose de trois parties : l'en-tête (header), la charge utile (claims) et la signature. En Rust, cela est implémenté via des structures :

use serde::{Serialize, Deserialize};

#[derive(Debug, Serialize, Deserialize)]struct Claims {    sub: String,      // sujet (généralement l'ID utilisateur)    exp: usize,       // date d'expiration (timestamp unix)    iat: usize,       // date de création (timestamp unix)    role: String,     // champ personnalisé}

Création et signature d'un jeton JWT

Examinons un exemple complet de création d'un jeton en utilisant l'algorithme HS256 (chiffrement symétrique) :

use jsonwebtoken::{encode, Header, EncodingKey};use chrono::Utc;

fn create_jwt(user_id: &str, secret: &str) -> Result {    let now = Utc::now().timestamp() as usize;    let claims = Claims {        sub: user_id.to_string(),        exp: now + 3600,  // le jeton est valide 1 heure        iat: now,        role: "user".to_string(),    };

    let token = encode(        &Header::default(),  // par défaut HS256        &claims,        &EncodingKey::from_secret(secret.as_bytes()),    )?;    Ok(token)}

Vérification et décodage du jeton

Pour vérifier l'authenticité du jeton, on utilise la fonction decode en spécifiant l'algorithme et la clé secrète :

use jsonwebtoken::{decode, DecodingKey, Validation, Algorithm};

fn verify_jwt(token: &str, secret: &str) -> Result {    let validation = Validation::new(Algorithm::HS256);    let token_data = decode::(        token,        &DecodingKey::from_secret(secret.as_bytes()),        &validation,    )?;    Ok(token_data.claims)}

Utilisation des algorithmes asymétriques (RS256)

Pour un environnement de production, il est recommandé d'utiliser le chiffrement asymétrique. Exemple avec RS256 :

use jsonwebtoken::{encode, decode, Header, EncodingKey, DecodingKey, Validation, Algorithm};

// Création du jeton avec une clé privéefn create_rs256_token(user_id: &str, private_key_pem: &str) -> Result> {    let claims = Claims {        sub: user_id.to_string(),        exp: (Utc::now().timestamp() + 3600) as usize,        iat: Utc::now().timestamp() as usize,        role: "admin".to_string(),    };

    let token = encode(        &Header::new(Algorithm::RS256),        &claims,        &EncodingKey::from_rsa_pem(private_key_pem.as_bytes())?,    )?;    Ok(token)}

// Vérification avec une clé publiquefn verify_rs256_token(token: &str, public_key_pem: &str) -> Result> {    let mut validation = Validation::new(Algorithm::RS256);    validation.validate_exp = true;  // vérification de la date d'expiration

    let token_data = decode::(        token,        &DecodingKey::from_rsa_pem(public_key_pem.as_bytes())?,        &validat