Tokens JWT em Rust: biblioteca jsonwebtoken e trabalho com autenticação

Tokens JWT em Rust: biblioteca jsonwebtoken

JSON Web Tokens (JWT) é um padrão aberto (RFC 7519) para criação de tokens de acesso baseados em JSON. No ecossistema Rust, uma das bibliotecas mais populares e estáveis para trabalhar com JWT é a jsonwebtoken. Ela fornece um conjunto completo de funções para criar, assinar, verificar e decodificar tokens JWT, suportando algoritmos de criptografia simétricos (HS256, HS384, HS512) e assimétricos (RS256, RS384, RS512, ES256, ES384).

Instalação e configuração

Para começar, adicione a dependência no arquivo Cargo.toml do seu projeto:

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

A biblioteca serde é necessária para serialização e desserialização dos dados do token, e chrono simplifica o trabalho com timestamps (exp, iat, nbf).

Estrutura básica do JWT

Um token JWT consiste em três partes: cabeçalho (header), payload (claims) e assinatura. Em Rust, isso é implementado através de estruturas:

use serde::{Serialize, Deserialize};

#[derive(Debug, Serialize, Deserialize)]struct Claims {    sub: String,      // assunto (geralmente ID do usuário)    exp: usize,       // tempo de expiração (timestamp unix)    iat: usize,       // tempo de criação (timestamp unix)    role: String,     // campo personalizado}

Criação e assinatura de token JWT

Vamos considerar um exemplo completo de criação de token usando o algoritmo HS256 (criptografia simétrica):

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 válido por 1 hora        iat: now,        role: "user".to_string(),    };

    let token = encode(        &Header::default(),  // padrão é HS256        &claims,        &EncodingKey::from_secret(secret.as_bytes()),    )?;    Ok(token)}

Verificação e decodificação do token

Para verificar a autenticidade do token, utiliza-se a função decode especificando o algoritmo e a chave secreta:

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

Trabalhando com algoritmos assimétricos (RS256)

Para ambientes de produção, recomenda-se o uso de criptografia assimétrica. Exemplo com RS256:

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

// Criação do token com chave privadafn 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)}

// Verificação com chave públicafn verify_rs256_token(token: &str, public_key_pem: &str) -> Result> {    let mut validation = Validation::new(Algorithm::RS256);    validation.validate_exp = true;  // verificação de prazo de validade

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