//! A local OIDC relying party. Tokens never enter the browser or application logs. use std::{ collections::HashMap, sync::{Arc, Mutex}, time::{Duration, Instant}, }; use axum::{ extract::{Query, State}, http::{header, StatusCode}, response::{Html, IntoResponse, Redirect, Response}, routing::get, Json, Router, }; use axum_extra::extract::cookie::{Cookie, CookieJar, SameSite}; use openidconnect::{ core::{CoreAuthenticationFlow, CoreClient, CoreProviderMetadata}, reqwest, AuthorizationCode, ClientId, CsrfToken, EndpointMaybeSet, EndpointNotSet, EndpointSet, IssuerUrl, JsonWebTokenType, Nonce, OAuth2TokenResponse, PkceCodeChallenge, PkceCodeVerifier, RedirectUrl, TokenResponse, }; use serde::{Deserialize, Serialize}; const CALLBACK: &str = "http://127.0.0.1:4178/auth/cb"; const COOKIE: &str = "chirp_example"; type OidcClient = CoreClient< EndpointSet, EndpointNotSet, EndpointNotSet, EndpointNotSet, EndpointMaybeSet, EndpointMaybeSet, >; type WebResult = Result; struct Login { state: CsrfToken, nonce: Nonce, verifier: PkceCodeVerifier, expires: Instant, } struct App { client: OidcClient, issuer: String, http: reqwest::Client, // In-memory, expiring transactions are deliberately local to this demo. pending: Mutex>, } #[tokio::main] async fn main() -> anyhow::Result<()> { // Configuration errors are visible; the documented .env is required. dotenvy::from_filename(".env")?; let issuer = IssuerUrl::new(std::env::var("CHIRP_ISSUER")?)?; let client_id = std::env::var("CHIRP_CLIENT_ID")?; anyhow::ensure!( !client_id.starts_with("replace_"), "Set CHIRP_CLIENT_ID in .env" ); let http = reqwest::Client::builder() .redirect(reqwest::redirect::Policy::none()) .timeout(Duration::from_secs(15)) .build()?; let metadata = CoreProviderMetadata::discover_async(issuer.clone(), &http).await?; let client = CoreClient::from_provider_metadata(metadata, ClientId::new(client_id), None) .set_redirect_uri(RedirectUrl::new(CALLBACK.to_string())?); let app = Arc::new(App { client, issuer: issuer.as_str().to_string(), http, pending: Mutex::new(HashMap::new()), }); let router = Router::new() .route("/", get(home)) .route("/login", get(login)) .route("/auth/cb", get(callback)) .layer(axum::middleware::map_response(private_response)) .with_state(app); let listener = tokio::net::TcpListener::bind("127.0.0.1:4178").await?; println!("Open http://127.0.0.1:4178 — local integration example"); axum::serve(listener, router).await?; Ok(()) } async fn private_response(mut response: Response) -> Response { response .headers_mut() .insert(header::CACHE_CONTROL, "no-store".parse().unwrap()); response .headers_mut() .insert("referrer-policy", "no-referrer".parse().unwrap()); response } async fn home() -> Html<&'static str> { Html("Chirp example

Chirp sign-in example

This local app validates an OIDC login and shows your app-specific ID.

Sign in with Chirp
") } async fn login(State(app): State>, jar: CookieJar) -> WebResult { let (challenge, verifier) = PkceCodeChallenge::new_random_sha256(); // openid is included automatically by this OIDC SDK; no email scope. let (url, state, nonce) = app .client .authorize_url( CoreAuthenticationFlow::AuthorizationCode, CsrfToken::new_random, Nonce::new_random, ) .set_pkce_challenge(challenge) .url(); // Keep the browser binding independent of the state visible in the URL. let browser_id = CsrfToken::new_random().secret().clone(); let mut pending = app.pending.lock().unwrap(); pending.retain(|_, login| login.expires > Instant::now()); if let Some(old) = jar.get(COOKIE) { pending.remove(old.value()); } if pending.len() >= 1000 { return Err(( StatusCode::SERVICE_UNAVAILABLE, "Too many pending sign-ins. Try later.", )); } pending.insert( browser_id.clone(), Login { state, nonce, verifier, expires: Instant::now() + Duration::from_secs(600), }, ); // HTTP is limited to loopback. Use Secure cookies for a deployed HTTPS app. let cookie = Cookie::build((COOKIE, browser_id)) .path("/") .http_only(true) .same_site(SameSite::Lax) .build(); Ok((jar.add(cookie), Redirect::to(url.as_str())).into_response()) } #[derive(Deserialize)] struct Callback { code: String, state: String, iss: String, } #[derive(Serialize)] struct Identity { status: &'static str, sub: String, } async fn callback( State(app): State>, jar: CookieJar, Query(params): Query, ) -> WebResult { let rejected = || { ( StatusCode::BAD_REQUEST, "Sign-in failed. Return to / and start again.", ) }; let browser_id = jar .get(COOKIE) .ok_or(( StatusCode::BAD_REQUEST, "Missing browser transaction cookie. Start again from /login.", ))? .value(); // Consume before network work: a callback can succeed at most once. let login = app.pending.lock().unwrap().remove(browser_id).ok_or(( StatusCode::BAD_REQUEST, "Browser transaction expired or already used. Start again from /login.", ))?; if login.expires <= Instant::now() || login.state != CsrfToken::new(params.state) || params.iss != app.issuer { return Err(( StatusCode::BAD_REQUEST, "Expired sign-in or mismatched state/issuer. Start again from /login.", )); } let tokens = app .client .exchange_code(AuthorizationCode::new(params.code)) .map_err(|_| { ( StatusCode::BAD_REQUEST, "Issuer discovery has no token endpoint.", ) })? .set_pkce_verifier(login.verifier) .request_async(&app.http) .await .map_err(|error| { let reason = match error { openidconnect::RequestTokenError::ServerResponse(_) => { "Issuer rejected the token exchange. Start again from /login." } openidconnect::RequestTokenError::Request(_) => { "Could not reach the issuer token endpoint." } openidconnect::RequestTokenError::Parse(error, _) => { // The field path is useful for interoperability diagnosis; // never print the response body, which contains tokens. eprintln!("Invalid token response field: {}", error.path()); "Issuer returned a token response that does not match OIDC." } openidconnect::RequestTokenError::Other(_) => "Unexpected token endpoint response.", }; (StatusCode::BAD_REQUEST, reason) })?; let id_token = tokens.id_token().ok_or_else(rejected)?; // The SDK verifies the signature against discovery's JWKS, algorithm, // issuer, audience, expiry, and the transaction's nonce before exposing sub. // Chirp uses an explicit JWT type to separate identity from API authority. // Restrict the SDK to that type; never disable its JOSE type checks. let verifier = app .client .id_token_verifier() .set_allowed_jose_types([JsonWebTokenType::new("chirp-id+jwt".to_string()) .normalize() .map_err(|_| rejected())?]); let claims = id_token.claims(&verifier, &login.nonce).map_err(|_| { ( StatusCode::BAD_REQUEST, "ID token validation failed. Start again from /login.", ) })?; // The standard SDK also checks UserInfo's subject against the verified ID // token, preventing a substituted access token from changing the identity. let _: openidconnect::core::CoreUserInfoClaims = app .client .user_info( tokens.access_token().clone(), Some(claims.subject().clone()), ) .map_err(|_| (StatusCode::BAD_REQUEST, "Issuer has no UserInfo endpoint."))? .request_async(&app.http) .await .map_err(|_| (StatusCode::BAD_REQUEST, "UserInfo validation failed."))?; let identity = Identity { status: "OIDC verified", sub: claims.subject().as_str().to_string(), }; // A real app creates its own session here. This example retains no tokens // or user data and deliberately provides no persistent app session. let jar = jar.remove(Cookie::build(COOKIE).path("/").build()); Ok((jar, Json(identity)).into_response()) }