Autorisation et authentification en Rust : bibliothèques…

Autorisation et authentification en Rust : aperçu complet des outils

Rust est un langage de programmation système de plus en plus utilisé pour créer des services web à forte charge. Les questions de sécurité, notamment l'authentification (vérification de l'identité de l'utilisateur) et l'autorisation (vérification des droits d'accès), y sont particulièrement cruciales. Dans cet article, nous examinerons les bibliothèques et approches clés pour implémenter ces mécanismes dans l'écosystème Rust.

Approches principales de l'authentification

Dans les projets Rust, trois stratégies sont le plus souvent utilisées :

Authentification par session — le serveur stocke l'état de la session (généralement dans Redis ou en mémoire), le client reçoit un cookie avec l'identifiant de session.
JWT (JSON Web Token) — jetons sans état qui contiennent des revendications (claims) et sont signés par le serveur.
OAuth2 / OpenID Connect — authentification décentralisée via des fournisseurs tiers (Google, GitHub, Yandex).

Bibliothèques Rust essentielles

1. `jsonwebtoken` — travail avec JWT

La bibliothèque la plus populaire pour créer et vérifier les jetons JWT. Prend en charge HS256, RS256, ES256 et d'autres algorithmes.

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

// Création du jetonlet claims = serde_json::json!({    "sub": "user123",    "exp": 1740000000,    "role": "admin"});let token = encode(&Header::default(), &claims, &EncodingKey::from_secret("secret".as_ref())).unwrap();

// Vérificationlet token_data = decode::<serde_json::Value>(    &token,    &DecodingKey::from_secret("secret".as_ref()),    &Validation::default()).unwrap();println!("Le jeton appartient à : {}", token_data.claims["sub"]);

2. `bcrypt` — hachage des mots de passe

Hachage sécurisé avec sel. Utilisé pour stocker les mots de passe en toute sécurité dans la base de données.

use bcrypt::{hash, verify, DEFAULT_COST};

let password = "super_secret_123";let hashed = hash(password, DEFAULT_COST).unwrap();println!("Haché : {}", hashed);

let valid = verify(password, &hashed).unwrap();println!("Mot de passe correct : {}", valid); // true

3. `actix-web-identity` / `actix-web-flash` — sessions pour Actix Web

Si vous utilisez le framework Actix Web, ces crates vous aideront à gérer les sessions via des cookies ou Redis.

use actix_web::{web, App, HttpServer, HttpRequest, HttpResponse, middleware::IdentityService};use actix_web::cookie::Key;

async fn login(req: HttpRequest) -> HttpResponse {    let identity = req.extensions().get::<Identity>().unwrap();    identity.remember("user_id=42".to_string());    HttpResponse::Ok().body("Authentifié")}

#[actix_web::main]async fn main() -> std::io::Result<()> {    HttpServer::new(|| {        App::new()            .wrap(IdentityService::new(Key::from(&[0; 32])))            .route("/login", web::get().to(login))    })    .bind("127.0.0.1:8080")?    .run()    .await}

4. `oauth2` — client OAuth2

Bibliothèque pour implémenter le flux OAuth2 (par exemple, "Connexion avec GitHub"). Prend en charge Authorization Code, Client Credentials et Refresh Token.

use oauth2::{basic::BasicClient, AuthUrl, TokenUrl, ClientId, ClientSecret, RedirectUrl};

let client = BasicClient::new(    ClientId::new("your_client_id".to_string()),    Some(ClientSecret::new("your_client_secret".to_string())),    AuthUrl::new("https://github.com/login/oauth/authorize".to_string()).unwrap(),    Some(TokenUrl::new("https://github.com/login/oauth/access_token".to_string()).unwrap())).set_redirect_uri(RedirectUrl::new("http://localhost:8080/callback".to_string()).unwrap());