---
title: "sdk/rust"
description: "Asynchrones Rust-Server-SDK für netzwerklose JWT-Prüfung,Anfrage-Authentifizierung und Webhook-Signaturvalidierung."
locale: "de"
---

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

# sdk/rust

## Zustand

Implementiert und lokal verifiziert. Die echteIdP-Round-Trip-Verifizierung (JWKS-Abruf, Token-Signierung/Prüfung gegeneine Live-XID-Instanz) wurde noch nicht durchgeführt und muss vor demProduktionseinsatz abgeschlossen werden.

## Installieren

Zu `Cargo.toml` hinzufügen:

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

## Schnellstart

```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}"),
}
}
```

## Anfrage authentifizieren

```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 */ }
}
```

## Webhook prüfen

```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 */ }
}
```

## Kern-API

| Symbol | Beschreibung |
| --- | --- |
| `XidClientConfig::new(issuer)` | Minimalkonstruktor. Builder-Methoden für optionale Einstellungenverketten. |
| `.with_audience(aud)` | Erwarteten Audience-Claim festlegen. |
| `.with_session_cookie(name)` | Session-Cookie-Namen überschreiben (Standard `__session`). |
| `.with_leeway(seconds)` | Taktversatztoleranz für exp/nbf. |
| `XidClient::new(config)` | Client mit dem Standard-reqwest-HTTP-Client erstellen. |
| `XidClient::with_http_client(config, http)` | Client mit einem benutzerdefinierten reqwest-Client erstellen (nützlichfür Tests). |
| `client.verify_token(token)` | Token-String prüfen; gibt `XidResult<VerifiedToken>` zurück. |
| `client.authenticate_request(headers, cookies)` | Token aus rohen Headern und Cookies extrahieren und prüfen; gibt`AuthState` zurück. |
| `WebhookVerifier::new(secret)` | Akzeptiert `whsec_<base64>` oder ein rohes Base64-Secret. |
| `verifier.verify_from_headers(headers, body)` | Svix-Header automatisch extrahieren und HMAC-SHA256-Signatur validieren. |

## Plattformhinweise

- Async-first-API auf tokio-Basis. Verwendet rustls (keineOpenSSL-Abhängigkeit) über reqwest.
- ES256 ist der primäre Algorithmus; RS256 wird unterstützt.PS256-Unterstützung ist geplant. ES384/ES512 sind noch nichtimplementiert.
- Framework-Integrationsfunktionen (`axum`, `actix-web`) sindgeplant, aber in dieser Version nicht enthalten.
- `XidError` verwendet `thiserror` für strukturierteFehlervarianten, darunter `JwtValidation`, `JwksFetch`,`KeyNotFound`, `IssuerMismatch` und webhook-spezifischeVarianten.

Source: https://xid.dev/de/sdks/rust/index.mdx