---
title: "sdk/rust"
description: "SDK de servidor Rust assíncrono para verificação JWT sem rede,autenticação de requisições e validação de assinatura de webhook."
locale: "pt-BR"
---

> Documentation Index
> Fetch the locale documentation index at: https://xid.dev/pt-br/llms.txt
> Use this file to discover all available pages before exploring further.

# sdk/rust

## Estado

Implementado e verificado localmente. A verificação de ida e voltacom um IdP real (busca de JWKS, assinatura/verificação de tokencontra uma instância XID ativa) ainda não foi realizada e deve serconcluída antes do uso em produção.

## Instalar

Adicione ao `Cargo.toml`:

```toml
[dependencies]
xid = "0.1"
tokio = { version = "1", features = ["full"] }
```

## Início rápido

```rust
use std::sync::Arc;
use xid::{XidClient, XidClientConfig, AuthState};

#[tokio::main]
async fn main() {
let config = XidClientConfig::new("https://xid.dev")
    .with_audience("your-client-id");

let client = Arc::new(XidClient::new(config).expect("build client"));

match client.verify_token("eyJ...").await {
    Ok(verified) => {
        println!("user: {}", verified.claims.sub);
        println!("email: {:?}", verified.claims.email);
    }
    Err(e) => eprintln!("invalid token: {e}"),
}
}
```

## Autentica uma requisição

```rust
let state = client.authenticate_request(raw_headers, cookies).await;

match state {
AuthState::Authenticated(token) => {
    println!("user: {}", token.claims.sub);
    // token.claims.has_scope("openid") -> bool
    // token.claims.org_id -> Option<String>
}
AuthState::Unauthenticated => { /* return 401 */ }
AuthState::Invalid(e) => { /* return 401 */ }
}
```

## Verifica webhook

```rust
use xid::WebhookVerifier;

let webhook_secret =
std::env::var("XID_WEBHOOK_SECRET").expect("XID_WEBHOOK_SECRET is required");
let verifier = WebhookVerifier::new(&webhook_secret).expect("valid secret");

match verifier.verify_from_headers(headers, body) {
Ok(()) => {
    let payload = xid::WebhookPayload::from_bytes(body).unwrap();
    println!("event: {}", payload.event_type);
}
Err(e) => { /* return 400 */ }
}
```

## API principal

| Símbolo | Descrição |
| --- | --- |
| `XidClientConfig::new(issuer)` | Construtor mínimo. Encadeie métodos builder para configuraçõesopcionais. |
| `.with_audience(aud)` | Define o claim de audiência esperado. |
| `.with_session_cookie(name)` | Substitui o nome do cookie de sessão (padrão `__session`). |
| `.with_leeway(seconds)` | Tolerância de desvio de relógio para exp/nbf. |
| `XidClient::new(config)` | Constrói o cliente com o cliente HTTP reqwest padrão. |
| `XidClient::with_http_client(config, http)` | Constrói o cliente com um reqwest personalizado (útil para testes). |
| `client.verify_token(token)` | Verifica a string do token; retorna `XidResult<VerifiedToken>`. |
| `client.authenticate_request(headers, cookies)` | Extrai e verifica o token de headers e cookies brutos; retorna`AuthState`. |
| `WebhookVerifier::new(secret)` | Aceita `whsec_<base64>` ou segredo base64 puro. |
| `verifier.verify_from_headers(headers, body)` | Extrai cabeçalhos svix automaticamente e valida a assinaturaHMAC-SHA256. |

## Notas da plataforma

- API assíncrona construída sobre tokio. Usa rustls (sem dependência deOpenSSL) via reqwest.
- ES256 é o algoritmo principal; RS256 é suportado. Suporte a PS256está planejado. ES384/ES512 ainda não estão implementados.
- Recursos de integração de framework (`axum`, `actix-web`)estão planejados mas não incluídos nesta versão.
- `XidError` usa `thiserror` para variantes de errosestruturados incluindo `JwtValidation`, `JwksFetch`,`KeyNotFound`, `IssuerMismatch` e variantes específicas dewebhook.

Source: https://xid.dev/pt-br/sdks/rust/index.mdx