Authentifizierung und Autorisierung in Rust: Bibliotheken und praktische Beispiele

Authentifizierung und Autorisierung in Rust: von JWT bis Sessions

In der Welt der System- und Webprogrammierung hat sich Rust den Ruf einer sicheren und schnellen Sprache erworben. Bei der Erstellung von Webanwendungen stehen Entwickler jedoch oft vor der Aufgabe, Authentifizierung (Überprüfung der Benutzeridentität) und Autorisierung (Überprüfung der Zugriffsrechte) zu implementieren. In diesem Artikel betrachten wir die wichtigsten Bibliotheken und Ansätze zur Implementierung dieser Mechanismen in Rust und geben praktische Codebeispiele.

Grundlegende Konzepte von Authentifizierung und Autorisierung

Bevor wir zu den Werkzeugen übergehen, ist es wichtig, die Begriffe abzugrenzen:

• Authentifizierung — der Prozess der Überprüfung, ob ein Benutzer der ist, der er vorgibt zu sein. Dies erfolgt in der Regel durch Login/Passwort, Token oder Biometrie.
• Autorisierung — die Bestimmung, welche Ressourcen und Aktionen einem authentifizierten Benutzer zur Verfügung stehen. Wird oft durch Rollen (Administrator, Moderator, Benutzer) oder Zugriffsrechte implementiert.

In Rust können beide Prozesse sowohl auf niedriger Ebene (manuelle Token-Verwaltung) als auch mit Hilfe vorgefertigter Bibliotheken implementiert werden.

Beliebte Bibliotheken für die Authentifizierung in Rust

Für die Arbeit mit Sessions und Token gibt es in Rust mehrere ausgereifte Lösungen:

• actix-identity — zur Verwaltung von Sessions im Web-Framework Actix-web. Unterstützt Cookie-Sessions und Redis.
• jsonwebtoken — Bibliothek für die Arbeit mit JWT (JSON Web Tokens). Ermöglicht das Erstellen, Signieren und Verifizieren von Token.
• argon2 — Implementierung des von OWASP empfohlenen Passwort-Hashing-Algorithmus Argon2.
• bcrypt — klassische Bibliothek zum Hashing von Passwörtern.

Im Folgenden betrachten wir jedes Werkzeug anhand eines Beispiels.

Beispiel 1: Authentifizierung mit JWT und jsonwebtoken

JWT ist eine der beliebtesten Methoden zur Authentifizierung in REST-APIs. Der Token enthält Claims und wird mit einem geheimen Schlüssel signiert. Betrachten wir eine grundlegende Implementierung mit der Bibliothek jsonwebtoken.

// cargo add jsonwebtoken serdeuse jsonwebtoken::{encode, decode, Header, Validation, EncodingKey, DecodingKey};use serde::{Serialize, Deserialize};

#[derive(Debug, Serialize, Deserialize)]struct Claims {    sub: String,   // Benutzer-ID    exp: usize,    // Ablaufzeit (UNIX-Timestamp)    role: String,  // Benutzerrolle}

fn create_token(user_id: &str, role: &str) -> Result<String, jsonwebtoken::errors::Error> {    let claims = Claims {        sub: user_id.to_owned(),        exp: (chrono::Utc::now() + chrono::Duration::hours(24)).timestamp() as usize,        role: role.to_owned(),    };    encode(        &Header::default(),        &claims,        &EncodingKey::from_secret(b"ihr_geheimer_schlüssel")    )}

fn verify_token(token: &str) -> Result<Claims, jsonwebtoken::errors::Error> {    let token_data = decode::<Claims>(        token,        &DecodingKey::from_secret(b"ihr_geheimer_schlüssel"),        &Validation::default()    )?;    Ok(token_data.claims)}

In diesem Beispiel erstellen wir einen Token mit einer Gültigkeit von 24 Stunden, der die Benutzer-ID und die Rolle enthält. Die Funktion verify_token überprüft die Signatur und gibt die Claims zurück, die für die Autorisierung verwendet werden können.

Beispiel 2: Passwort-Hashing mit Argon2

Speichern Sie Passwörter niemals im Klartext! Verwenden Sie Argon2 – einen modernen und sicheren Hashing-Algorithmus.

// cargo add argon2use argon2::{Argon2, PasswordHash, PasswordHasher, PasswordVerifier};use argon2::password_hash::{SaltString, rand_core::OsRng};

fn hash_password(password: &str) -> String {    let salt = SaltString::generate(&mut OsRng);    let argon2 = Argon2::default();    argon2.hash_password(password.as_bytes(), &salt)        .expect("Hashing-Fehler")