Tokens JWT em Rust: bibliotecas e implementação de autenticação

Tokens JWT em Rust: bibliotecas e implementação de autenticação

JSON Web Token (JWT) é um padrão aberto para criação de tokens de acesso baseado no formato JSON. No ecossistema Rust, o trabalho com JWT é realizado por meio de várias bibliotecas de qualidade, com destaque para a jsonwebtoken. Essa ferramenta oferece o ciclo completo de manipulação de tokens: criação, assinatura, verificação e decodificação.

Principais bibliotecas para JWT em Rust

Atualmente, as crates mais populares para trabalhar com JWT são:

• jsonwebtoken — biblioteca principal com suporte aos algoritmos HS256, RS256 e EdDSA
• jwt — alternativa mais leve com funcionalidades básicas
• biscuit — biblioteca avançada com suporte a cenários complexos

Neste artigo, vamos focar na jsonwebtoken por ser a solução mais madura e bem documentada.

Instalação e configuração

Adicione a dependência no Cargo.toml:

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

Criação e verificação de tokens JWT

Veja um exemplo completo de implementação de autenticação com JWT:

use jsonwebtoken::{encode, decode, Header, Validation, EncodingKey, DecodingKey};
use serde::{Serialize, Deserialize};
use chrono::{Utc, Duration};

#[derive(Debug, Serialize, Deserialize)]
struct Claims {
    sub: String,        // identificador do usuário
    exp: usize,         // data de expiração do token
    iat: usize,         // data de criação do token
    role: String,       // papel do usuário
}

fn create_token(user_id: &str, role: &str, secret: &str) -> Result {
    let now = Utc::now();
    let claims = Claims {
        sub: user_id.to_string(),
        exp: (now + Duration::hours(24)).timestamp() as usize,
        iat: now.timestamp() as usize,
        role: role.to_string(),
    };
    
    encode(
        &Header::default(),
        &claims,
        &EncodingKey::from_secret(secret.as_bytes())
    )
}

fn verify_token(token: &str, secret: &str) -> Result {
    let token_data = decode::(
        token,
        &DecodingKey::from_secret(secret.as_bytes()),
        &Validation::default()
    )?;
    Ok(token_data.claims)
}

Uso prático em aplicações web

A integração do JWT com frameworks web (como Actix-web ou Axum) exige a criação de um middleware para validação dos tokens:

use actix_web::{HttpRequest, HttpResponse, web, App, HttpServer, middleware::from_fn};
use std::sync::Arc;

// Middleware para validar JWT
async fn auth_middleware(
    req: HttpRequest,
) -> Result {
    let auth_header = req.headers()
        .get("Authorization")
        .and_then(|v| v.to_str().ok())
        .ok_or(HttpResponse::Unauthorized().json("Token ausente"))?;
    
    let token = auth_header
        .strip_prefix("Bearer ")
        .ok_or(HttpResponse::Unauthorized().json("Formato de token inválido"))?;
    
    verify_token(token, SECRET)
        .map_err(|_| HttpResponse::Unauthorized().json("Token inválido"))
}

// Endpoint protegido
async fn protected_endpoint(claims: Claims) -> HttpResponse {
    HttpResponse::Ok().json(claims)
}

Funcionalidades avançadas e melhores práticas

• Tokens de refresh — use tokens de acesso de curta duração (15-30 minutos) e tokens de refresh de longa duração (7-30 dias)
• Armazenamento de segredos — nunca armazene chaves secretas no código; utilize variáveis de ambiente ou um cofre seguro
• Algoritmos de assinatura — em produção, prefira RS256 (criptografia assimétrica) em vez de HS256
• Validação de claims — sempre verifique exp, iss e aud