Autorisation et authentification en Rust : guide complet

Autorisation et authentification en Rust : guide complet pour développeurs

Rust est un langage de programmation système qui gagne en popularité pour la création de services web à haute charge et sécurisés. Cependant, l'implémentation de l'authentification (vérification de l'identité) et de l'autorisation (vérification des droits d'accès) en Rust nécessite une approche particulière en raison de son système de types strict et de l'absence de solutions intégrées. Dans cet article, nous examinerons les bibliothèques clés et des exemples pratiques.

Pourquoi Rust pour l'authentification ?

La sécurité est la priorité absolue de Rust. Le compilateur prévient les fuites de mémoire, les conditions de concurrence et de nombreuses vulnérabilités typiques du C/C++. Cependant, implémenter l'authentification manuellement peut entraîner des erreurs, c'est pourquoi la communauté a créé plusieurs bibliothèques matures.

Bibliothèques principales pour l'authentification en Rust

1. actix-web-httpauth — pour le framework web Actix-web

La bibliothèque la plus populaire pour implémenter l'authentification HTTP (Basic, Bearer, Digest) dans l'écosystème Actix-web.

2. jsonwebtoken — travail avec JWT

Implémentation complète des JSON Web Tokens (JWT) pour Rust. Prend en charge RS256, HS256, ES256 et d'autres algorithmes.

3. bcrypt — hachage de mots de passe

Bibliothèque fiable pour le hachage de mots de passe avec l'algorithme bcrypt et génération automatique de sel.

4. argon2 — hachage moderne

Si bcrypt semble obsolète, utilisez Argon2 — le gagnant du concours Password Hashing Competition.

5. tower-http — middleware pour l'autorisation

Permet de créer des middleware réutilisables pour vérifier les droits d'accès sur tout serveur HTTP basé sur Tower.

Exemple pratique : authentification via JWT dans Actix-web

Considérons un exemple minimal de serveur avec inscription et connexion. Ajoutez d'abord les dépendances dans Cargo.toml :

[dependencies]actix-web = "4"actix-web-httpauth = "0.8"jsonwebtoken = "9"bcrypt = "0.15"serde = { version = "1", features = ["derive"] }tokio = { version = "1", features = ["full"] }

Écrivons maintenant la structure utilisateur et les fonctions pour créer/vérifier le JWT :

use actix_web::{web, App, HttpServer, HttpResponse, HttpRequest};use actix_web_httpauth::extractors::bearer::BearerAuth;use jsonwebtoken::{encode, decode, Header, Validation, EncodingKey, DecodingKey};use bcrypt::{hash, verify, DEFAULT_COST};use serde::{Serialize, Deserialize};

#[derive(Debug, Serialize, Deserialize)]struct Claims {    sub: String, // email de l'utilisateur    exp: usize,  // temps d'expiration du token}

#[derive(Debug, Serialize, Deserialize)]struct User {    email: String,    password_hash: String,}

// Stockage des utilisateurs (en réalité — base de données)static USERS: once_cell::sync::Lazy<std::sync::Mutex<Vec<User>>> =    once_cell::sync::Lazy::new(|| std::sync::Mutex::new(vec![]));

async fn register(info: web::Json<UserInput>) -> HttpResponse {    let hashed = hash(&info.password, DEFAULT_COST).unwrap();    let user = User {        email: info.email.clone(),        password_hash: hashed,    };    USERS.lock().unwrap().push(user);    HttpResponse::Ok().json("Utilisateur enregistré")}

async fn login(info: web::Json<UserInput>) -> HttpResponse {    let users = USERS.lock().unwrap();    if let Some(user) = users.iter().find(|u| u.email == info.email) {        if verify(&info.password, &user.password_hash).unwrap() {            let claims = Claims {                sub: info.email.clone(),                exp: 10000000000,            };            let token = encode(                &Header::default(),                &claims,                &EncodingKey::from_secret(b"secret_key"),            ).unwrap();            return HttpResponse::Ok().json(token);        }    }    HttpResponse::Unauthori