JWT-Tokens in Rust: Die Bibliothek jsonwebtoken und Authentifizierung

JWT-Tokens in Rust: Die Bibliothek jsonwebtoken

JSON Web Tokens (JWT) sind ein offener Standard (RFC 7519) zur Erstellung von Zugriffstokens auf Basis von JSON. Im Rust-Ökosystem ist jsonwebtoken eine der beliebtesten und stabilsten Bibliotheken für die Arbeit mit JWT. Sie bietet einen vollständigen Satz an Funktionen zum Erstellen, Signieren, Verifizieren und Dekodieren von JWT-Tokens und unterstützt sowohl symmetrische (HS256, HS384, HS512) als auch asymmetrische (RS256, RS384, RS512, ES256, ES384) Verschlüsselungsalgorithmen.

Installation und Konfiguration

Fügen Sie zunächst die Abhängigkeit in Ihre Cargo.toml-Datei Ihres Projekts ein:

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

Die Bibliothek serde wird für die Serialisierung und Deserialisierung der Tokendaten benötigt, und chrono vereinfacht die Arbeit mit Zeitstempeln (exp, iat, nbf).

Grundlegende JWT-Struktur

Ein JWT-Token besteht aus drei Teilen: Header, Payload (Claims) und Signatur. In Rust wird dies durch Strukturen implementiert:

use serde::{Serialize, Deserialize};

#[derive(Debug, Serialize, Deserialize)]struct Claims {    sub: String,      // Subjekt (normalerweise Benutzer-ID)    exp: usize,       // Ablaufzeit (Unix-Timestamp)    iat: usize,       // Erstellungszeit (Unix-Timestamp)    role: String,     // Benutzerdefiniertes Feld}

Erstellung und Signierung eines JWT-Tokens

Betrachten wir ein vollständiges Beispiel zur Erstellung eines Tokens mit dem HS256-Algorithmus (symmetrische Verschlüsselung):

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,  // Token ist 1 Stunde gültig        iat: now,        role: "user".to_string(),    };

    let token = encode(        &Header::default(),  // Standardmäßig HS256        &claims,        &EncodingKey::from_secret(secret.as_bytes()),    )?;    Ok(token)}

Verifizierung und Dekodierung des Tokens

Zur Überprüfung der Authentizität des Tokens wird die Funktion decode mit Angabe des Algorithmus und des geheimen Schlüssels verwendet:

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)}

Arbeit mit asymmetrischen Algorithmen (RS256)

Für Produktionsumgebungen wird die Verwendung asymmetrischer Verschlüsselung empfohlen. Beispiel mit RS256:

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

// Token mit privatem Schlüssel erstellenfn 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)}

// Verifizierung mit öffentlichem Schlüsselfn verify_rs256_token(token: &str, public_key_pem: &str) -> Result> {    let mut validation = Validation::new(Algorithm::RS256);    validation.validate_exp = true;  // Überprüfung der Gültigkeitsdauer

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