Skip to main content

hyprstream_core/services/oauth/
oidc_callback.rs

1//! External OAuth/OIDC provider callback handler.
2//!
3//! Handles the return redirect from an external provider after the user
4//! authenticates. Supports two provider kinds:
5//!
6//! - `oidc`   — full OpenID Connect: discovery + id_token JWT verification
7//! - `oauth2` — generic OAuth 2.0: fixed endpoints + userinfo HTTP call
8//!
9//! After claims are obtained (via either path), identity mapping, provisioning,
10//! and auth code issuance are identical regardless of provider kind.
11
12use std::sync::Arc;
13use std::time::{Duration, Instant};
14
15use axum::extract::{Extension, Path, Query, State};
16use axum::http::{header, HeaderMap};
17use axum::response::{IntoResponse, Redirect, Response};
18use axum::{Form, Json};
19use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine};
20use rand::RngCore;
21use serde::{Deserialize, Serialize};
22use sha2::{Digest, Sha256};
23
24use super::state::{AuthorizeBinding, OAuthState, PendingAuthCode, PendingExternalAuth};
25use crate::auth::user_store::UserProfilePatch;
26use crate::config::{ProviderKind, ProvisioningMode};
27
28#[derive(Serialize)]
29pub struct FederateOwnerLinkStart {
30    authorization_url: String,
31}
32
33/// Start an explicit Federate owner link for the currently signed-in hosted
34/// account. The endpoint accepts no target account or owner DID from the
35/// browser; both are resolved from the authenticated session and trusted
36/// provider configuration.
37pub async fn begin_federate_owner_link(
38    State(state): State<Arc<OAuthState>>,
39    Extension(allowed_origins): Extension<Vec<String>>,
40    headers: HeaderMap,
41) -> Response {
42    let Some(origin) = headers
43        .get(header::ORIGIN)
44        .and_then(|value| value.to_str().ok())
45    else {
46        return (
47            axum::http::StatusCode::FORBIDDEN,
48            "Invalid identity UI origin",
49        )
50            .into_response();
51    };
52    if !allowed_origins.iter().any(|allowed| {
53        allowed != "*"
54            && url::Url::parse(allowed)
55                .ok()
56                .is_some_and(|url| url.origin().ascii_serialization() == origin)
57    }) {
58        return (
59            axum::http::StatusCode::FORBIDDEN,
60            "Invalid identity UI origin",
61        )
62            .into_response();
63    }
64    let return_origin = origin.to_owned();
65
66    let candidates: Vec<_> = state
67        .external_providers
68        .iter()
69        .filter(|(_, provider)| {
70            provider.issuer_url.as_deref() == Some(super::federate_source::ISSUER)
71                && provider.federate_atproto_owner.is_some()
72        })
73        .collect();
74    let [(provider_slug, provider)] = candidates.as_slice() else {
75        return (
76            axum::http::StatusCode::SERVICE_UNAVAILABLE,
77            "Exactly one Federate owner provider must be configured",
78        )
79            .into_response();
80    };
81    let provider_slug = (*provider_slug).clone();
82    let provider = (*provider).clone();
83    let Some(enrollment) = provider.federate_atproto_owner.as_ref() else {
84        return (
85            axum::http::StatusCode::SERVICE_UNAVAILABLE,
86            "Federate owner enrollment is not configured",
87        )
88            .into_response();
89    };
90    if provider.kind != ProviderKind::Oidc
91        || provider.allow_http
92        || !matches!(provider.provisioning, ProvisioningMode::Deny)
93    {
94        return (
95            axum::http::StatusCode::SERVICE_UNAVAILABLE,
96            "Federate owner provider is not safely configured",
97        )
98            .into_response();
99    }
100
101    let Some(session_id) = super::session::extract_session_id(&headers) else {
102        return (
103            axum::http::StatusCode::UNAUTHORIZED,
104            "A local hosted-account session is required",
105        )
106            .into_response();
107    };
108    let Some(session) = state.sessions.get(&session_id).await else {
109        return (
110            axum::http::StatusCode::UNAUTHORIZED,
111            "A local hosted-account session is required",
112        )
113            .into_response();
114    };
115    if session.auth_method != "atproto"
116        || session.atproto_did.as_deref() != Some(session.username.as_str())
117        || session.verified_tenant.as_deref().is_none_or(str::is_empty)
118    {
119        return (
120            axum::http::StatusCode::FORBIDDEN,
121            "Federate owner linking requires a local hosted account",
122        )
123            .into_response();
124    }
125    let Some(user_service) = state.user_service.as_ref() else {
126        return (
127            axum::http::StatusCode::SERVICE_UNAVAILABLE,
128            "Credential store is unavailable",
129        )
130            .into_response();
131    };
132    let username = match user_service
133        .store()
134        .get_username_by_atproto_did(&session.username)
135        .await
136    {
137        Ok(Some(username)) => username,
138        Ok(None) => {
139            return (
140                axum::http::StatusCode::FORBIDDEN,
141                "The local hosted account is unavailable",
142            )
143                .into_response();
144        }
145        Err(error) => {
146            tracing::warn!(%error, "Federate owner link account lookup failed");
147            return (
148                axum::http::StatusCode::INTERNAL_SERVER_ERROR,
149                "Credential store lookup failed",
150            )
151                .into_response();
152        }
153    };
154    if enrollment
155        .username
156        .as_deref()
157        .is_some_and(|configured| configured != username)
158    {
159        return (
160            axum::http::StatusCode::FORBIDDEN,
161            "This hosted account is not the configured owner account",
162        )
163            .into_response();
164    }
165    let (hosted_did, tenant) = match super::token::resolve_hosted_account_binding(&state, &username)
166        .await
167    {
168        Ok(binding)
169            if binding.0 == session.username
170                && Some(binding.1.as_str()) == session.verified_tenant.as_deref() =>
171        {
172            binding
173        }
174        Ok(_) => {
175            return (
176                axum::http::StatusCode::FORBIDDEN,
177                "Local hosted account authority binding changed",
178            )
179                .into_response();
180        }
181        Err(error) => {
182            tracing::warn!(%error, username = %username, "Federate owner link account rejected");
183            return (
184                axum::http::StatusCode::FORBIDDEN,
185                "A complete active hosted account is required",
186            )
187                .into_response();
188        }
189    };
190    let metadata = match state
191        .oidc_discovery
192        .get_metadata(super::federate_source::ISSUER, false)
193        .await
194    {
195        Ok(metadata) => metadata,
196        Err(error) => {
197            tracing::warn!(%error, "Federate OIDC discovery failed for account linking");
198            return (
199                axum::http::StatusCode::BAD_GATEWAY,
200                "Federate OIDC discovery failed",
201            )
202                .into_response();
203        }
204    };
205    let mut state_bytes = [0u8; 32];
206    rand::rngs::OsRng.fill_bytes(&mut state_bytes);
207    let external_state = URL_SAFE_NO_PAD.encode(state_bytes);
208    let mut nonce_bytes = [0u8; 32];
209    rand::rngs::OsRng.fill_bytes(&mut nonce_bytes);
210    let external_nonce = URL_SAFE_NO_PAD.encode(nonce_bytes);
211    let mut verifier_bytes = [0u8; 32];
212    rand::rngs::OsRng.fill_bytes(&mut verifier_bytes);
213    let pkce_verifier = URL_SAFE_NO_PAD.encode(verifier_bytes);
214    let pkce_challenge = URL_SAFE_NO_PAD.encode(Sha256::digest(pkce_verifier.as_bytes()));
215    let callback_url = format!("{}/oauth/callback/{}", state.issuer_url, provider_slug);
216    let authorize_url = match build_provider_authorize_url(
217        &metadata.authorization_endpoint,
218        &provider.client_id,
219        &callback_url,
220        &provider.effective_scopes().join(" "),
221        &external_state,
222        Some(&external_nonce),
223        Some(&pkce_challenge),
224    ) {
225        Ok(url) => url,
226        Err(error) => {
227            tracing::warn!(%error, "Federate OIDC authorization URL rejected");
228            return (
229                axum::http::StatusCode::BAD_GATEWAY,
230                "Federate OIDC authorization endpoint is invalid",
231            )
232                .into_response();
233        }
234    };
235    state.pending_external_auths.write().await.insert(
236        external_state.clone(),
237        PendingExternalAuth {
238            provider_slug,
239            external_state,
240            external_nonce,
241            provider_kind: ProviderKind::Oidc,
242            pkce_supported: true,
243            pkce_verifier,
244            client_secret: provider.client_secret.clone(),
245            token_endpoint: metadata.token_endpoint,
246            original_request: None,
247            federate_owner_link: Some(super::state::PendingFederateOwnerLink {
248                session_id,
249                owner_did: enrollment.owner_did.clone(),
250                username,
251                hosted_did,
252                tenant,
253                return_origin,
254            }),
255            created_at: Instant::now(),
256            expires_at: Instant::now() + Duration::from_secs(600),
257        },
258    );
259    (
260        axum::http::StatusCode::OK,
261        [(header::CACHE_CONTROL, "no-store, max-age=0")],
262        Json(FederateOwnerLinkStart {
263            authorization_url: authorize_url,
264        }),
265    )
266        .into_response()
267}
268
269/// Initiate external OAuth/OIDC login by redirecting to the provider.
270///
271/// `POST /oauth/external/authorize/:provider`
272///
273/// Dispatches on `provider.kind`:
274/// - `oidc`   — fetches OIDC discovery, sends PKCE + nonce
275/// - `oauth2` — uses configured endpoints, omits nonce,
276///   skips PKCE when `pkce_supported = false`
277pub async fn external_authorize(
278    State(state): State<Arc<OAuthState>>,
279    Path(provider_slug): Path<String>,
280    headers: HeaderMap,
281    Form(form): Form<ExternalAuthorizeForm>,
282) -> Response {
283    // A provider selection is an explicit approval, not a navigable GET that
284    // link previewers or browser prefetch can trigger. Reject cross-origin
285    // form submissions before touching the one-time authorization binding.
286    if !external_origin_matches(&headers, &state.issuer_url) {
287        return (axum::http::StatusCode::FORBIDDEN, "Invalid login origin").into_response();
288    }
289    let provider = match state.external_providers.get(&provider_slug) {
290        Some(p) => p.clone(),
291        None => {
292            return (
293                axum::http::StatusCode::NOT_FOUND,
294                format!("Unknown provider: {provider_slug}"),
295            )
296                .into_response();
297        }
298    };
299    if !matches!(provider.provisioning, ProvisioningMode::Deny) {
300        return (
301            axum::http::StatusCode::SERVICE_UNAVAILABLE,
302            "External just-in-time provisioning is unsupported",
303        )
304            .into_response();
305    }
306
307    // Only a previously validated, displayed authorization request can start
308    // an external login. Consume its nonce atomically with the local POST path;
309    // arbitrary query parameters have no authority here.
310    let binding = consume_external_login_challenge(&state, &form.login_challenge).await;
311    let Some(binding) = binding else {
312        return (
313            axum::http::StatusCode::BAD_REQUEST,
314            "Invalid or consumed login challenge",
315        )
316            .into_response();
317    };
318    let request = binding.request;
319    // The ATProto profile requires a local identity/DID and PAR-bound DPoP;
320    // an external IdP cannot satisfy those invariants. Reject before any
321    // provider request or identity mutation.
322    let scopes = request.scope.as_deref().unwrap_or("");
323    if super::state::atproto_profile_active(
324        &scopes
325            .split_whitespace()
326            .map(str::to_owned)
327            .collect::<Vec<_>>(),
328    ) || request.dpop_jkt.is_some()
329        || request.client_assertion_jkt.is_some()
330    {
331        return (
332            axum::http::StatusCode::BAD_REQUEST,
333            "Bound OAuth profiles are unsupported for external login",
334        )
335            .into_response();
336    }
337    if let Err(response) = super::authorize::validate_authorize_scopes(&state, &request).await {
338        return response;
339    }
340    if request.response_type != "code"
341        || request.code_challenge_method != "S256"
342        || request.code_challenge.is_empty()
343        || super::authorize::derive_display_info(&state, &request.client_id, &request.redirect_uri)
344            .await
345            .is_none()
346    {
347        return (
348            axum::http::StatusCode::BAD_REQUEST,
349            "Invalid authorization request",
350        )
351            .into_response();
352    }
353
354    let mut state_bytes = [0u8; 32];
355    rand::rngs::OsRng.fill_bytes(&mut state_bytes);
356    let external_state = URL_SAFE_NO_PAD.encode(state_bytes);
357
358    let callback_url = format!("{}/oauth/callback/{}", state.issuer_url, provider_slug);
359
360    match provider.kind {
361        ProviderKind::Oidc => {
362            let issuer = match provider.issuer_url.as_deref() {
363                Some(u) => u,
364                None => {
365                    return (
366                        axum::http::StatusCode::INTERNAL_SERVER_ERROR,
367                        "oidc provider missing issuer_url",
368                    )
369                        .into_response()
370                }
371            };
372            let metadata = match state
373                .oidc_discovery
374                .get_metadata(issuer, provider.allow_http)
375                .await
376            {
377                Ok(m) => m,
378                Err(e) => {
379                    tracing::error!(provider = %provider_slug, error = %e, "OIDC discovery failed");
380                    return (
381                        axum::http::StatusCode::BAD_GATEWAY,
382                        format!("OIDC discovery failed: {e}"),
383                    )
384                        .into_response();
385                }
386            };
387
388            let mut verifier_bytes = [0u8; 32];
389            rand::rngs::OsRng.fill_bytes(&mut verifier_bytes);
390            let pkce_verifier = URL_SAFE_NO_PAD.encode(verifier_bytes);
391            let pkce_challenge = URL_SAFE_NO_PAD.encode(Sha256::digest(pkce_verifier.as_bytes()));
392
393            let mut nonce_bytes = [0u8; 32];
394            rand::rngs::OsRng.fill_bytes(&mut nonce_bytes);
395            let external_nonce = URL_SAFE_NO_PAD.encode(nonce_bytes);
396
397            let scopes = provider.effective_scopes().join(" ");
398            let authorize_url = match build_provider_authorize_url(
399                &metadata.authorization_endpoint,
400                &provider.client_id,
401                &callback_url,
402                &scopes,
403                &external_state,
404                Some(&external_nonce),
405                Some(&pkce_challenge),
406            ) {
407                Ok(url) => url,
408                Err(_) => {
409                    return (
410                        axum::http::StatusCode::BAD_GATEWAY,
411                        "Invalid provider authorization URL",
412                    )
413                        .into_response()
414                }
415            };
416
417            let pending = PendingExternalAuth {
418                provider_slug: provider_slug.clone(),
419                external_state: external_state.clone(),
420                external_nonce,
421                provider_kind: ProviderKind::Oidc,
422                pkce_supported: true,
423                pkce_verifier,
424                client_secret: provider.client_secret.clone(),
425                token_endpoint: metadata.token_endpoint.clone(),
426                original_request: Some(request.clone()),
427                federate_owner_link: None,
428                created_at: Instant::now(),
429                expires_at: Instant::now() + Duration::from_secs(600),
430            };
431            state
432                .pending_external_auths
433                .write()
434                .await
435                .insert(external_state.clone(), pending);
436            Redirect::temporary(&authorize_url).into_response()
437        }
438
439        ProviderKind::OAuth2 => {
440            let auth_endpoint = match provider.effective_authorization_endpoint() {
441                Some(u) => u,
442                None => {
443                    return (
444                        axum::http::StatusCode::INTERNAL_SERVER_ERROR,
445                        "oauth2 provider missing authorization_endpoint",
446                    )
447                        .into_response()
448                }
449            };
450            let token_endpoint = match provider.effective_token_endpoint_url() {
451                Some(u) => u.to_owned(),
452                None => {
453                    return (
454                        axum::http::StatusCode::INTERNAL_SERVER_ERROR,
455                        "oauth2 provider missing token_endpoint_url",
456                    )
457                        .into_response()
458                }
459            };
460
461            let pkce_supported = provider.effective_pkce_supported();
462            let (pkce_verifier, pkce_challenge) = if pkce_supported {
463                let mut verifier_bytes = [0u8; 32];
464                rand::rngs::OsRng.fill_bytes(&mut verifier_bytes);
465                let v = URL_SAFE_NO_PAD.encode(verifier_bytes);
466                let c = URL_SAFE_NO_PAD.encode(Sha256::digest(v.as_bytes()));
467                (v, Some(c))
468            } else {
469                (String::new(), None)
470            };
471
472            let scopes = provider.effective_scopes().join(" ");
473            let authorize_url = match build_provider_authorize_url(
474                auth_endpoint,
475                &provider.client_id,
476                &callback_url,
477                &scopes,
478                &external_state,
479                None,
480                pkce_challenge.as_deref(),
481            ) {
482                Ok(url) => url,
483                Err(_) => {
484                    return (
485                        axum::http::StatusCode::INTERNAL_SERVER_ERROR,
486                        "Invalid provider authorization URL",
487                    )
488                        .into_response()
489                }
490            };
491
492            let pending = PendingExternalAuth {
493                provider_slug: provider_slug.clone(),
494                external_state: external_state.clone(),
495                external_nonce: String::new(),
496                provider_kind: provider.kind.clone(),
497                pkce_supported,
498                pkce_verifier,
499                client_secret: provider.client_secret.clone(),
500                token_endpoint,
501                original_request: Some(request.clone()),
502                federate_owner_link: None,
503                created_at: Instant::now(),
504                expires_at: Instant::now() + Duration::from_secs(600),
505            };
506            state
507                .pending_external_auths
508                .write()
509                .await
510                .insert(external_state.clone(), pending);
511            Redirect::temporary(&authorize_url).into_response()
512        }
513    }
514}
515
516fn build_provider_authorize_url(
517    endpoint: &str,
518    client_id: &str,
519    callback_url: &str,
520    scopes: &str,
521    state: &str,
522    nonce: Option<&str>,
523    pkce_challenge: Option<&str>,
524) -> Result<String, url::ParseError> {
525    let mut url = url::Url::parse(endpoint)?;
526    {
527        let mut query = url.query_pairs_mut();
528        query
529            .append_pair("response_type", "code")
530            .append_pair("client_id", client_id)
531            .append_pair("redirect_uri", callback_url)
532            .append_pair("scope", scopes)
533            .append_pair("state", state);
534        if let Some(nonce) = nonce {
535            query.append_pair("nonce", nonce);
536        }
537        if let Some(challenge) = pkce_challenge {
538            query
539                .append_pair("code_challenge", challenge)
540                .append_pair("code_challenge_method", "S256");
541        }
542    }
543    Ok(url.into())
544}
545
546fn external_origin_matches(headers: &HeaderMap, issuer_url: &str) -> bool {
547    let Ok(expected) = url::Url::parse(issuer_url) else {
548        return false;
549    };
550    let all_origins = headers.get_all(header::ORIGIN);
551    let mut values = all_origins.iter();
552    let Some(origin) = values.next().and_then(|value| value.to_str().ok()) else {
553        return false;
554    };
555    if values.next().is_some() {
556        return false;
557    }
558    origin == expected.origin().ascii_serialization()
559}
560
561/// This RP has no trust policy for additional ID-token audiences. Accept only
562/// this client's sole audience and, when supplied, its matching authorized
563/// party. Signature and standard JWT claims are verified before this check.
564fn id_token_targets_client(claims: &serde_json::Value, client_id: &str) -> bool {
565    let audience_matches = match &claims["aud"] {
566        serde_json::Value::String(audience) => audience == client_id,
567        serde_json::Value::Array(audiences) if audiences.len() == 1 => {
568            audiences[0].as_str() == Some(client_id)
569        }
570        _ => false,
571    };
572    let party_matches = match claims.get("azp") {
573        None => true,
574        Some(serde_json::Value::String(party)) => party == client_id,
575        _ => false,
576    };
577    audience_matches && party_matches
578}
579
580async fn consume_external_login_challenge(
581    state: &OAuthState,
582    challenge: &str,
583) -> Option<AuthorizeBinding> {
584    let mut nonces = state.pending_nonces.write().await;
585    let expires_at = nonces.remove(challenge);
586    let binding = state
587        .pending_authorize_bindings
588        .write()
589        .await
590        .remove(challenge);
591    match (expires_at, binding) {
592        (Some(expiry), Some(binding)) if Instant::now() < expiry => Some(binding),
593        _ => None,
594    }
595}
596
597#[derive(Deserialize)]
598pub struct ExternalAuthorizeForm {
599    pub login_challenge: String,
600}
601
602#[derive(Deserialize)]
603pub struct CallbackParams {
604    pub code: String,
605    pub state: String,
606}
607
608/// Reject an upstream error using only public response metadata.
609fn check_token_response(
610    response: reqwest::Response,
611    provider_slug: &str,
612) -> Result<reqwest::Response, (axum::http::StatusCode, &'static str)> {
613    let status = response.status();
614    if status.is_success() {
615        return Ok(response);
616    }
617
618    // Never read or log the body, even at DEBUG/TRACE: error fields and provider
619    // diagnostics can contain credentials, and arbitrary providers have no safe
620    // redaction contract. Keep only the configured provider and HTTP status.
621    tracing::error!(
622        provider = %provider_slug,
623        status = status.as_u16(),
624        "External token endpoint returned error"
625    );
626    Err((
627        axum::http::StatusCode::BAD_GATEWAY,
628        "External token exchange rejected",
629    ))
630}
631
632/// Handle callback from external OIDC provider.
633///
634/// `GET /oauth/callback/:provider`
635///
636/// 1. Validate state against pending external auth
637/// 2. Exchange code for tokens at external provider
638/// 3. Validate external id_token
639/// 4. Map identity to local subject
640/// 5. Issue hyprstream auth code
641/// 6. Redirect to original client
642pub async fn external_callback(
643    State(state): State<Arc<OAuthState>>,
644    Path(provider_slug): Path<String>,
645    headers: HeaderMap,
646    Query(params): Query<CallbackParams>,
647) -> Response {
648    // Consume only a state bound to this provider. A callback to a different
649    // slug must not burn a valid login transaction.
650    let pending = {
651        let mut auths = state.pending_external_auths.write().await;
652        match auths.get(&params.state) {
653            Some(p) if p.provider_slug == provider_slug && p.expires_at > Instant::now() => {
654                auths.remove(&params.state)
655            }
656            _ => None,
657        }
658    };
659    let pending = match pending {
660        Some(p) => p,
661        _ => {
662            return (
663                axum::http::StatusCode::BAD_REQUEST,
664                "Invalid or expired external auth state",
665            )
666                .into_response();
667        }
668    };
669
670    if let Some(request) = pending.original_request.as_ref() {
671        if pending.federate_owner_link.is_some() {
672            return (
673                axum::http::StatusCode::BAD_REQUEST,
674                "Invalid Federate owner link state",
675            )
676                .into_response();
677        }
678        let scopes = match super::authorize::validate_authorize_scopes(&state, request).await {
679            Ok(scopes) => scopes,
680            Err(response) => return response,
681        };
682        if super::state::atproto_profile_active(&scopes)
683            || request.dpop_jkt.is_some()
684            || request.client_assertion_jkt.is_some()
685            || request.response_type != "code"
686            || request.code_challenge_method != "S256"
687            || request.code_challenge.is_empty()
688            || super::authorize::derive_display_info(
689                &state,
690                &request.client_id,
691                &request.redirect_uri,
692            )
693            .await
694            .is_none()
695        {
696            return (
697                axum::http::StatusCode::BAD_REQUEST,
698                "Invalid authorization request",
699            )
700                .into_response();
701        }
702    } else if pending.federate_owner_link.is_none() {
703        return (
704            axum::http::StatusCode::BAD_REQUEST,
705            "Invalid external authorization state",
706        )
707            .into_response();
708    }
709
710    // Look up provider config
711    let provider = match state.external_providers.get(&provider_slug) {
712        Some(p) => p.clone(),
713        None => {
714            return (
715                axum::http::StatusCode::NOT_FOUND,
716                format!("Unknown provider: {provider_slug}"),
717            )
718                .into_response();
719        }
720    };
721    if !matches!(provider.provisioning, ProvisioningMode::Deny) {
722        return (
723            axum::http::StatusCode::SERVICE_UNAVAILABLE,
724            "External just-in-time provisioning is unsupported",
725        )
726            .into_response();
727    }
728
729    // Exchange code for tokens at external provider
730    let callback_url = format!("{}/oauth/callback/{}", state.issuer_url, provider_slug);
731    let mut token_params = vec![
732        ("grant_type", "authorization_code".to_owned()),
733        ("code", params.code.clone()),
734        ("redirect_uri", callback_url),
735        ("client_id", provider.client_id.clone()),
736    ];
737    if pending.pkce_supported {
738        token_params.push(("code_verifier", pending.pkce_verifier.clone()));
739    }
740    if let Some(ref secret) = pending.client_secret {
741        token_params.push(("client_secret", secret.clone()));
742    }
743
744    let mut token_request = state
745        .http_client
746        .post(&pending.token_endpoint)
747        .form(&token_params)
748        .timeout(Duration::from_secs(10));
749
750    // GitHub (and many generic OAuth 2.0 providers) default to form-encoded responses;
751    // Accept: application/json ensures we always get parseable JSON.
752    if matches!(pending.provider_kind, ProviderKind::OAuth2) {
753        token_request = token_request.header("Accept", "application/json");
754    }
755
756    let token_response = match token_request.send().await {
757        Ok(r) => r,
758        Err(e) => {
759            tracing::error!(provider = %provider_slug, error = %e, "External token exchange failed");
760            return (axum::http::StatusCode::BAD_GATEWAY, "Token exchange failed").into_response();
761        }
762    };
763
764    let token_response = match check_token_response(token_response, &provider_slug) {
765        Ok(response) => response,
766        Err(response) => return response.into_response(),
767    };
768
769    let token_json: serde_json::Value = match token_response.json().await {
770        Ok(v) => v,
771        Err(e) => {
772            tracing::error!(provider = %provider_slug, error = %e, "Invalid token response JSON");
773            return (
774                axum::http::StatusCode::BAD_GATEWAY,
775                "Invalid token response",
776            )
777                .into_response();
778        }
779    };
780
781    // Obtain normalised claims — dispatching on provider kind.
782    // Both paths produce the same structure: { sub, name, email, email_verified }.
783    let external_claims: serde_json::Value = match pending.provider_kind {
784        ProviderKind::Oidc => {
785            // Full OpenID Connect: verify the id_token JWT against provider JWKS.
786            let external_id_token = match token_json["id_token"].as_str() {
787                Some(t) => t,
788                None => {
789                    tracing::error!(provider = %provider_slug, "No id_token in external token response");
790                    return (
791                        axum::http::StatusCode::BAD_GATEWAY,
792                        "No id_token from external provider",
793                    )
794                        .into_response();
795                }
796            };
797
798            let issuer = match provider.issuer_url.as_deref() {
799                Some(u) => u,
800                None => {
801                    return (
802                        axum::http::StatusCode::INTERNAL_SERVER_ERROR,
803                        "oidc provider missing issuer_url",
804                    )
805                        .into_response()
806                }
807            };
808
809            // Verify external id_token signature against the provider's JWKS.
810            //
811            // Fetches the JWKS from the provider's discovery endpoint, selects the
812            // appropriate key (by kid or algorithm), and verifies the JWT signature.
813            // Supports RS256, ES256, and EdDSA algorithms.
814            let metadata = match state
815                .oidc_discovery
816                .get_metadata(issuer, provider.allow_http)
817                .await
818            {
819                Ok(m) => m,
820                Err(e) => {
821                    tracing::error!(provider = %provider_slug, error = %e, "OIDC discovery for JWKS failed");
822                    return (
823                        axum::http::StatusCode::BAD_GATEWAY,
824                        "OIDC discovery for JWKS verification failed",
825                    )
826                        .into_response();
827                }
828            };
829
830            let verified = match crate::auth::id_token_verify::verify_id_token(
831                external_id_token,
832                &metadata.jwks_uri,
833                issuer,
834                &provider.client_id,
835                &state.http_client,
836            )
837            .await
838            {
839                Ok(v) => v,
840                Err(e) => {
841                    tracing::error!(provider = %provider_slug, error = %e, "External id_token JWKS verification failed");
842                    return (
843                        axum::http::StatusCode::BAD_GATEWAY,
844                        "External id_token verification failed",
845                    )
846                        .into_response();
847                }
848            };
849
850            let claims = verified.claims;
851
852            // Validate issuer (OIDC Core Section 3.1.3.7)
853            if claims["iss"].as_str() != Some(issuer) {
854                tracing::error!(
855                    provider = %provider_slug,
856                    expected = %issuer,
857                    got = %claims["iss"],
858                    "External id_token issuer mismatch"
859                );
860                return (axum::http::StatusCode::BAD_REQUEST, "Issuer mismatch").into_response();
861            }
862
863            // Validate audience (OIDC Core Section 3.1.3.6)
864            if !id_token_targets_client(&claims, &provider.client_id) {
865                tracing::error!(provider = %provider_slug, "External id_token audience mismatch");
866                return (axum::http::StatusCode::BAD_REQUEST, "Audience mismatch").into_response();
867            }
868
869            // Validate expiration (OIDC Core Section 3.1.3.6)
870            if let Some(exp) = claims["exp"].as_i64() {
871                let now = chrono::Utc::now().timestamp();
872                let skew = provider.clock_skew_seconds as i64;
873                if now > exp + skew {
874                    tracing::error!(provider = %provider_slug, "External id_token expired");
875                    return (axum::http::StatusCode::BAD_REQUEST, "Token expired").into_response();
876                }
877            } else {
878                tracing::error!(provider = %provider_slug, "External id_token missing exp claim");
879                return (axum::http::StatusCode::BAD_REQUEST, "Missing exp claim").into_response();
880            }
881
882            // Validate nonce (REQUIRED when sent in auth request — OIDC Core Section 3.1.3.6)
883            match claims["nonce"].as_str() {
884                Some(nonce) if nonce == pending.external_nonce => { /* valid */ }
885                Some(_) => {
886                    tracing::error!(provider = %provider_slug, "External id_token nonce mismatch");
887                    return (axum::http::StatusCode::BAD_REQUEST, "Nonce mismatch").into_response();
888                }
889                None => {
890                    tracing::error!(provider = %provider_slug, "External id_token missing nonce (required)");
891                    return (axum::http::StatusCode::BAD_REQUEST, "Missing nonce").into_response();
892                }
893            }
894
895            claims
896        }
897
898        ProviderKind::OAuth2 => {
899            // Generic OAuth 2.0 / GitHub: exchange gave us an opaque access_token.
900            // Fetch user identity from the provider's userinfo endpoint.
901            let access_token = match token_json["access_token"].as_str() {
902                Some(t) => t,
903                None => {
904                    tracing::error!(provider = %provider_slug, "No access_token in external token response");
905                    return (
906                        axum::http::StatusCode::BAD_GATEWAY,
907                        "No access_token from external provider",
908                    )
909                        .into_response();
910                }
911            };
912
913            let userinfo_url = match provider.effective_userinfo_endpoint() {
914                Some(u) => u.to_owned(),
915                None => {
916                    tracing::error!(provider = %provider_slug, "OAuth2 provider missing userinfo_endpoint");
917                    return (
918                        axum::http::StatusCode::INTERNAL_SERVER_ERROR,
919                        "oauth2 provider missing userinfo_endpoint",
920                    )
921                        .into_response();
922                }
923            };
924
925            let mapping = provider.effective_claim_mapping();
926            match super::oauth2_userinfo::fetch_oauth2_claims(
927                &state.http_client,
928                &userinfo_url,
929                access_token,
930                &mapping,
931            )
932            .await
933            {
934                Ok(claims) => claims,
935                Err(e) => {
936                    tracing::error!(provider = %provider_slug, error = %e, "OAuth2 userinfo fetch failed");
937                    return (
938                        axum::http::StatusCode::BAD_GATEWAY,
939                        format!("Userinfo fetch failed: {e}"),
940                    )
941                        .into_response();
942                }
943            }
944        }
945    };
946
947    // Map external identity to a candidate local username. This is a *hint* —
948    // the authoritative username is resolved by the credential store, not by
949    // the mapping function.
950    let mapped_subject = match super::user_mapping::map_external_identity(
951        &provider_slug,
952        &external_claims,
953        &provider.user_mapping,
954        &state.issuer_url,
955    ) {
956        Ok(s) => s,
957        Err(e) => {
958            tracing::error!(provider = %provider_slug, error = %e, "Identity mapping failed");
959            return (
960                axum::http::StatusCode::FORBIDDEN,
961                format!("Identity mapping failed: {e}"),
962            )
963                .into_response();
964        }
965    };
966
967    // Resolve the issuer to use for the normalized (issuer, subject) binding.
968    // Prefer the provider's configured issuer_url, then the id_token `iss`
969    // claim, then the provider slug as a last-resort synthetic issuer.
970    let binding_issuer = provider
971        .issuer_url
972        .as_deref()
973        .or_else(|| external_claims["iss"].as_str())
974        .unwrap_or(&provider_slug)
975        .to_owned();
976    let external_sub = match external_claims["sub"].as_str() {
977        Some(s) if !s.is_empty() => s.to_owned(),
978        _ => {
979            tracing::error!(provider = %provider_slug, "External token missing required 'sub' claim — rejecting");
980            return (
981                axum::http::StatusCode::BAD_REQUEST,
982                "External token missing required 'sub' claim",
983            )
984                .into_response();
985        }
986    };
987
988    if binding_issuer == super::federate_source::ISSUER && provider.federate_atproto_owner.is_none()
989    {
990        tracing::warn!(provider = %provider_slug, "Federate issuer is missing server-side owner enrollment");
991        return (
992            axum::http::StatusCode::FORBIDDEN,
993            "Federate owner enrollment is required",
994        )
995            .into_response();
996    }
997
998    // Federate owner enrollment binds only a verified nested ATProto DID to
999    // an existing active hosted account. A fixed configured username supports
1000    // operator-enrolled accounts; an omitted username requires the explicit
1001    // session-bound link intent captured above.
1002    if let Some(enrollment) = &provider.federate_atproto_owner {
1003        if pending.provider_kind != ProviderKind::Oidc
1004            || provider.issuer_url.as_deref() != Some(super::federate_source::ISSUER)
1005            || provider.allow_http
1006            || !matches!(
1007                &provider.provisioning,
1008                crate::config::ProvisioningMode::Deny
1009            )
1010        {
1011            tracing::error!(provider = %provider_slug, "Federate owner enrollment is misconfigured");
1012            return (
1013                axum::http::StatusCode::FORBIDDEN,
1014                "Federate owner enrollment is misconfigured",
1015            )
1016                .into_response();
1017        }
1018
1019        if let Err(error) = super::user_mapping::map_federate_atproto_owner(
1020            &external_claims,
1021            super::federate_source::ISSUER,
1022            &enrollment.owner_did,
1023        ) {
1024            tracing::warn!(provider = %provider_slug, %error, "Federate owner claim rejected");
1025            return (
1026                axum::http::StatusCode::FORBIDDEN,
1027                "Federate owner claim rejected",
1028            )
1029                .into_response();
1030        }
1031
1032        let (username, expected_hosted_did, expected_tenant) =
1033            if let Some(link) = &pending.federate_owner_link {
1034                if link.owner_did != enrollment.owner_did
1035                    || super::session::extract_session_id(&headers).as_deref()
1036                        != Some(link.session_id.as_str())
1037                {
1038                    return (
1039                        axum::http::StatusCode::FORBIDDEN,
1040                        "The hosted-account session changed during Federate owner linking",
1041                    )
1042                        .into_response();
1043                }
1044                let Some(session) = state.sessions.get(&link.session_id).await else {
1045                    return (
1046                        axum::http::StatusCode::UNAUTHORIZED,
1047                        "The hosted-account session expired during Federate owner linking",
1048                    )
1049                        .into_response();
1050                };
1051                if session.auth_method != "atproto"
1052                    || session.atproto_did.as_deref() != Some(link.hosted_did.as_str())
1053                    || session.username != link.hosted_did
1054                    || session.verified_tenant.as_deref() != Some(link.tenant.as_str())
1055                {
1056                    return (
1057                        axum::http::StatusCode::FORBIDDEN,
1058                        "The hosted-account session is no longer eligible",
1059                    )
1060                        .into_response();
1061                }
1062                let Some(user_service) = state.user_service.as_ref() else {
1063                    return (
1064                        axum::http::StatusCode::SERVICE_UNAVAILABLE,
1065                        "Credential store is unavailable",
1066                    )
1067                        .into_response();
1068                };
1069                match user_service
1070                    .store()
1071                    .get_username_by_atproto_did(&link.hosted_did)
1072                    .await
1073                {
1074                    Ok(Some(username)) if username == link.username => {}
1075                    Ok(_) => {
1076                        return (
1077                            axum::http::StatusCode::FORBIDDEN,
1078                            "The hosted-account owner changed during Federate owner linking",
1079                        )
1080                            .into_response();
1081                    }
1082                    Err(error) => {
1083                        tracing::warn!(%error, "Federate owner link account lookup failed");
1084                        return (
1085                            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
1086                            "Credential store lookup failed",
1087                        )
1088                            .into_response();
1089                    }
1090                }
1091                (
1092                    link.username.clone(),
1093                    link.hosted_did.clone(),
1094                    link.tenant.clone(),
1095                )
1096            } else if let Some(username) = enrollment.username.as_deref() {
1097                let (hosted_did, tenant) =
1098                    match super::token::resolve_hosted_account_binding(&state, username).await {
1099                        Ok(binding) => binding,
1100                        Err(error) => {
1101                            tracing::warn!(provider = %provider_slug, username = %username, %error,
1102                        "Federate owner target is not an active authority-owned hosted account");
1103                            return (
1104                                axum::http::StatusCode::FORBIDDEN,
1105                                "Federate owner target is not an active hosted account",
1106                            )
1107                                .into_response();
1108                        }
1109                    };
1110                (username.to_owned(), hosted_did, tenant)
1111            } else {
1112                let Some(user_service) = state.user_service.as_ref() else {
1113                    return (
1114                        axum::http::StatusCode::SERVICE_UNAVAILABLE,
1115                        "Credential store is unavailable",
1116                    )
1117                        .into_response();
1118                };
1119                let username = match user_service
1120                    .store()
1121                    .get_external_identity_user(super::federate_source::ISSUER, &external_sub)
1122                    .await
1123                {
1124                    Ok(Some(username)) => username,
1125                    Ok(None) => {
1126                        return (
1127                            axum::http::StatusCode::FORBIDDEN,
1128                            "Explicit session-bound Federate owner linking is required",
1129                        )
1130                            .into_response();
1131                    }
1132                    Err(error) => {
1133                        tracing::warn!(%error, "Federate owner binding lookup failed");
1134                        return (
1135                            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
1136                            "Credential store lookup failed",
1137                        )
1138                            .into_response();
1139                    }
1140                };
1141                let (hosted_did, tenant) =
1142                    match super::token::resolve_hosted_account_binding(&state, &username).await {
1143                        Ok(binding) => binding,
1144                        Err(error) => {
1145                            tracing::warn!(provider = %provider_slug, username = %username, %error,
1146                        "Federate owner binding target is not an active hosted account");
1147                            return (
1148                                axum::http::StatusCode::FORBIDDEN,
1149                                "Linked account is not an active hosted account",
1150                            )
1151                                .into_response();
1152                        }
1153                    };
1154                (username, hosted_did, tenant)
1155            };
1156
1157        let (resolved_did, _resolved_tenant) =
1158            match super::token::resolve_hosted_account_binding(&state, &username).await {
1159                Ok(binding) if binding.0 == expected_hosted_did && binding.1 == expected_tenant => {
1160                    binding
1161                }
1162                Ok(_) => {
1163                    return (
1164                        axum::http::StatusCode::FORBIDDEN,
1165                        "The hosted-account binding changed during Federate owner linking",
1166                    )
1167                        .into_response();
1168                }
1169                Err(error) => {
1170                    tracing::warn!(provider = %provider_slug, username = %username, %error,
1171                    "Federate owner target is not an active authority-owned hosted account");
1172                    return (
1173                        axum::http::StatusCode::FORBIDDEN,
1174                        "Federate owner target is not an active hosted account",
1175                    )
1176                        .into_response();
1177                }
1178            };
1179        if pending.federate_owner_link.is_some() {
1180            let Some(user_service) = state.user_service.as_ref() else {
1181                return (
1182                    axum::http::StatusCode::SERVICE_UNAVAILABLE,
1183                    "Credential store is unavailable",
1184                )
1185                    .into_response();
1186            };
1187            if let Err(error) = user_service
1188                .store()
1189                .bind_existing_external_idp_to_hosted_account(
1190                    super::federate_source::ISSUER,
1191                    &external_sub,
1192                    &username,
1193                    &resolved_did,
1194                )
1195                .await
1196            {
1197                tracing::warn!(provider = %provider_slug, %error, "Federate owner binding rejected");
1198                return (
1199                    axum::http::StatusCode::FORBIDDEN,
1200                    "Federate owner binding rejected",
1201                )
1202                    .into_response();
1203            }
1204        } else if let Some(configured_username) = enrollment.username.as_deref() {
1205            let Some(user_service) = state.user_service.as_ref() else {
1206                return (
1207                    axum::http::StatusCode::SERVICE_UNAVAILABLE,
1208                    "Credential store is unavailable",
1209                )
1210                    .into_response();
1211            };
1212            if let Err(error) = user_service
1213                .store()
1214                .bind_existing_external_idp_to_hosted_account(
1215                    super::federate_source::ISSUER,
1216                    &external_sub,
1217                    configured_username,
1218                    &resolved_did,
1219                )
1220                .await
1221            {
1222                tracing::warn!(provider = %provider_slug, %error, "Federate owner binding rejected");
1223                return (
1224                    axum::http::StatusCode::FORBIDDEN,
1225                    "Federate owner binding rejected",
1226                )
1227                    .into_response();
1228            }
1229        }
1230    }
1231
1232    if pending.federate_owner_link.is_some() {
1233        let Some(link) = pending.federate_owner_link.as_ref() else {
1234            return (
1235                axum::http::StatusCode::BAD_REQUEST,
1236                "Invalid owner link state",
1237            )
1238                .into_response();
1239        };
1240        let Ok(mut return_url) = url::Url::parse(&link.return_origin) else {
1241            return (
1242                axum::http::StatusCode::INTERNAL_SERVER_ERROR,
1243                "Invalid owner link return origin",
1244            )
1245                .into_response();
1246        };
1247        return_url.set_path("/hosts");
1248        return_url.set_query(None);
1249        return Redirect::temporary(return_url.as_str()).into_response();
1250    }
1251
1252    let Some(request) = pending.original_request.as_ref() else {
1253        return (
1254            axum::http::StatusCode::BAD_REQUEST,
1255            "Invalid external authorization state",
1256        )
1257            .into_response();
1258    };
1259    let scopes = match super::authorize::validate_authorize_scopes(&state, request).await {
1260        Ok(scopes) => scopes,
1261        Err(response) => return response,
1262    };
1263
1264    // Resolve the authoritative local username via the credential store.
1265    // In auto-provision mode this atomically binds (issuer, subject) and may
1266    // create the local account. In deny mode the binding must already exist.
1267    // Either way: never continue with the pre-binding candidate if the store
1268    // resolves a different authoritative username.
1269    let authoritative_username = match super::user_mapping::should_provision(
1270        &provider.provisioning,
1271        &mapped_subject,
1272        &provider.allowed_domains,
1273    ) {
1274        Ok(true) => {
1275            // Auto-provision: atomically resolve-or-bind the external identity.
1276            match provision_federated_user(
1277                &state,
1278                &binding_issuer,
1279                &external_sub,
1280                &mapped_subject,
1281                &external_claims,
1282                &provider.default_scopes,
1283            )
1284            .await
1285            {
1286                Ok(username) => username,
1287                Err(response) => return response,
1288            }
1289        }
1290        Ok(false) => {
1291            // A matching username or verified email is never proof of account
1292            // ownership. Deny mode requires an operator-established exact
1293            // (issuer, subject) binding to an existing active local account.
1294            let Some(ref user_svc) = state.user_service else {
1295                return (
1296                    axum::http::StatusCode::SERVICE_UNAVAILABLE,
1297                    "Credential store unavailable",
1298                )
1299                    .into_response();
1300            };
1301            let store = user_svc.store();
1302            let username = match store
1303                .get_external_identity_user(&binding_issuer, &external_sub)
1304                .await
1305            {
1306                Ok(Some(username)) => username,
1307                Ok(None) => {
1308                    return (
1309                        axum::http::StatusCode::FORBIDDEN,
1310                        "External identity is not linked",
1311                    )
1312                        .into_response();
1313                }
1314                Err(error) => {
1315                    tracing::error!(provider = %provider_slug, %error, "External identity lookup failed");
1316                    return (
1317                        axum::http::StatusCode::INTERNAL_SERVER_ERROR,
1318                        "User lookup failed",
1319                    )
1320                        .into_response();
1321                }
1322            };
1323            match store.get_profile(&username).await {
1324                Ok(Some(profile)) if profile.active != Some(false) => username,
1325                Ok(_) => {
1326                    return (
1327                        axum::http::StatusCode::FORBIDDEN,
1328                        "Linked account is unavailable",
1329                    )
1330                        .into_response();
1331                }
1332                Err(error) => {
1333                    tracing::error!(provider = %provider_slug, %error, "Linked account lookup failed");
1334                    return (
1335                        axum::http::StatusCode::INTERNAL_SERVER_ERROR,
1336                        "User lookup failed",
1337                    )
1338                        .into_response();
1339                }
1340            }
1341        }
1342        Err(e) => {
1343            tracing::warn!(provider = %provider_slug, subject = %mapped_subject, error = %e, "Provisioning denied");
1344            return (
1345                axum::http::StatusCode::FORBIDDEN,
1346                format!("Access denied: {e}"),
1347            )
1348                .into_response();
1349        }
1350    };
1351
1352    // The shared token endpoint requires an authority-owned hosted account
1353    // record and deployment-zone tenant for every user token. Reject here so
1354    // an external login cannot hand the client an unusable authorization code.
1355    if let Err(error) =
1356        super::token::resolve_hosted_account_binding(&state, &authoritative_username).await
1357    {
1358        tracing::warn!(provider = %provider_slug, username = %authoritative_username, %error, "External identity has no hosted account binding");
1359        return (
1360            axum::http::StatusCode::FORBIDDEN,
1361            "Local hosted account binding required",
1362        )
1363            .into_response();
1364    }
1365
1366    tracing::info!(
1367        provider = %provider_slug,
1368        external_sub = %external_claims["sub"].as_str().unwrap_or("unknown"),
1369        mapped_subject = %mapped_subject,
1370        authoritative_username = %authoritative_username,
1371        "External OIDC authentication successful"
1372    );
1373
1374    // Resume the original hyprstream authorize flow: issue auth code
1375    let mut code_bytes = [0u8; 32];
1376    rand::rngs::OsRng.fill_bytes(&mut code_bytes);
1377    let code = URL_SAFE_NO_PAD.encode(code_bytes);
1378
1379    let auth_code = PendingAuthCode {
1380        code: code.clone(),
1381        client_id: request.client_id.clone(),
1382        redirect_uri: request.redirect_uri.clone(),
1383        code_challenge: request.code_challenge.clone(),
1384        scopes,
1385        oidc_nonce: request.nonce.clone(),
1386        resource: request.resource.clone().filter(|value| !value.is_empty()),
1387        created_at: Instant::now(),
1388        expires_at: Instant::now() + Duration::from_secs(60),
1389        username: authoritative_username,
1390        verifying_key: None, // external OIDC — no local Ed25519 key binding
1391        // Bound profiles were rejected before provider redirection and again
1392        // before provisioning; generic external login issues bearer codes.
1393        dpop_jkt: None,
1394        client_assertion_jkt: None,
1395    };
1396    state
1397        .pending_codes
1398        .write()
1399        .await
1400        .insert(code.clone(), auth_code);
1401
1402    // Redirect to original client with hyprstream auth code
1403    let redirect_url = match super::authorize::build_authorize_redirect_url(
1404        &request.redirect_uri,
1405        &code,
1406        request.state.as_deref(),
1407        &state.issuer_url,
1408    ) {
1409        Ok(url) => url,
1410        Err(_) => {
1411            state.pending_codes.write().await.remove(&code);
1412            return (
1413                axum::http::StatusCode::INTERNAL_SERVER_ERROR,
1414                "Invalid redirect URI",
1415            )
1416                .into_response();
1417        }
1418    };
1419
1420    Redirect::temporary(&redirect_url).into_response()
1421}
1422
1423/// Atomically resolve or bind an external IdP identity and provision profile
1424/// data for a first-time federated login.
1425///
1426/// Returns the authoritative local username — which may differ from the
1427/// candidate when the `(issuer, subject)` binding already existed. The caller
1428/// MUST use the returned username, never the pre-binding candidate.
1429///
1430/// Fail-closed: any credential-store error rejects the login. Casbin policy
1431/// writes are best-effort (logged, not fatal) because they are a separate
1432/// subsystem from the credential store.
1433async fn provision_federated_user(
1434    state: &OAuthState,
1435    issuer: &str,
1436    external_sub: &str,
1437    candidate_username: &str,
1438    external_claims: &serde_json::Value,
1439    default_scopes: &[String],
1440) -> Result<String, Response> {
1441    let Some(ref user_svc) = state.user_service else {
1442        tracing::error!("Federated provisioning failed: credential store is not configured");
1443        return Err((
1444            axum::http::StatusCode::SERVICE_UNAVAILABLE,
1445            "credential store is not configured",
1446        )
1447            .into_response());
1448    };
1449    let store = user_svc.store();
1450
1451    // Atomically resolve-or-bind the normalized (issuer, subject) identity.
1452    // This is the authoritative step — it creates the local account and binding
1453    // in one operation, or returns the existing binding's username.
1454    let resolution = match store
1455        .resolve_or_bind_external_idp(issuer, external_sub, candidate_username)
1456        .await
1457    {
1458        Ok(r) => r,
1459        Err(e) => {
1460            tracing::error!(
1461                issuer = %issuer,
1462                external_sub = %external_sub,
1463                candidate = %candidate_username,
1464                error = %e,
1465                "Failed to resolve or bind external identity — rejecting login"
1466            );
1467            return Err((
1468                axum::http::StatusCode::INTERNAL_SERVER_ERROR,
1469                "Failed to provision federated identity",
1470            )
1471                .into_response());
1472        }
1473    };
1474
1475    if !resolution.provisioned {
1476        match store.get_profile(&resolution.username).await {
1477            Ok(Some(profile)) if profile.active != Some(false) => {}
1478            Ok(_) => {
1479                return Err((
1480                    axum::http::StatusCode::FORBIDDEN,
1481                    "Linked account is unavailable",
1482                )
1483                    .into_response());
1484            }
1485            Err(error) => {
1486                tracing::error!(username = %resolution.username, %error, "Linked account lookup failed");
1487                return Err((
1488                    axum::http::StatusCode::INTERNAL_SERVER_ERROR,
1489                    "User lookup failed",
1490                )
1491                    .into_response());
1492            }
1493        }
1494    }
1495
1496    // Populate profile fields from external claims only for newly provisioned
1497    // accounts. Existing accounts retain their configured profile.
1498    if resolution.provisioned {
1499        let profile = UserProfilePatch {
1500            name: external_claims["name"]
1501                .as_str()
1502                .map(str::to_owned)
1503                .map(Some),
1504            email: external_claims["email"]
1505                .as_str()
1506                .map(str::to_owned)
1507                .map(Some),
1508            email_verified: external_claims["email_verified"].as_bool().map(Some),
1509            active: Some(Some(true)),
1510            external_id: external_claims["sub"].as_str().map(str::to_owned).map(Some),
1511            ..Default::default()
1512        };
1513        if let Err(e) = store.set_profile(&resolution.username, profile).await {
1514            tracing::error!(
1515                username = %resolution.username,
1516                error = %e,
1517                "Failed to set profile for newly provisioned federated user — rejecting login"
1518            );
1519            return Err((
1520                axum::http::StatusCode::INTERNAL_SERVER_ERROR,
1521                "Failed to provision federated user profile",
1522            )
1523                .into_response());
1524        }
1525    }
1526
1527    // Existing bindings may have had privileges revoked after their first
1528    // login. Never restore provider defaults on a later authentication.
1529    if !resolution.provisioned {
1530        // Replay the first-login enrollment intent by idempotency key: if the
1531        // original append failed, this self-heals the missed intent instead
1532        // of silently leaving the account unenrolled (MAC denies unlabeled
1533        // subjects until the intent reconciles).
1534        append_jit_enrollment_intent(issuer, external_sub, &resolution.username);
1535        return Ok(resolution.username);
1536    }
1537
1538    // Write Casbin rules for default_scopes (best-effort — separate subsystem).
1539    // Scope format: "action:resource_type:resource_id" — e.g. "infer:model:*", "read:*:*"
1540    let subject = &resolution.username;
1541    if let Some(pm) = crate::auth::global_policy_manager() {
1542        // Self-ownership rules: always grant access to the user's own namespace
1543        // (user:{sub}:*) so JIT users can at minimum read/write their own profile
1544        // and settings — regardless of what default_scopes the provider supplies.
1545        // Addresses the zero-capabilities-on-first-login gap (#182).
1546        let self_ns = format!("user:{subject}:*");
1547        if let Err(e) = pm
1548            .add_policy_with_domain(subject, "*", &self_ns, "*", "allow")
1549            .await
1550        {
1551            tracing::warn!(subject = %subject, error = %e, "Failed to write self-ownership Casbin rule");
1552        }
1553
1554        // If no scopes are configured by the provider, fall back to viewer-level
1555        // defaults so the user can at minimum query models and registry entries.
1556        let effective_scopes: Vec<String> = if default_scopes.is_empty() {
1557            vec!["query:model:*".to_owned(), "query:registry:*".to_owned()]
1558        } else {
1559            default_scopes.to_vec()
1560        };
1561
1562        for scope in &effective_scopes {
1563            let parts: Vec<&str> = scope.splitn(3, ':').collect();
1564            let (action, resource) = match parts.as_slice() {
1565                [action, rtype, rid] if *rtype == "*" && *rid == "*" => (*action, "*".to_owned()),
1566                [action, rtype, rid] => (*action, format!("{rtype}:{rid}")),
1567                [action] => (*action, "*".to_owned()),
1568                _ => continue,
1569            };
1570            if let Err(e) = pm
1571                .add_policy_with_domain(subject, "*", &resource, action, "allow")
1572                .await
1573            {
1574                tracing::error!(subject = %subject, scope = %scope, error = %e, "Failed to write Casbin rule");
1575            }
1576        }
1577        if let Err(e) = pm.save().await {
1578            tracing::error!(subject = %subject, error = %e, "Failed to persist Casbin rules after provisioning");
1579        }
1580
1581        tracing::info!(
1582            subject = %subject,
1583            provisioned = resolution.provisioned,
1584            scopes = ?effective_scopes,
1585            "Federated user provisioned"
1586        );
1587    } else {
1588        tracing::warn!("PolicyManager not available — default_scopes not applied for {subject}");
1589    }
1590
1591    // #698 Phase 2: the binding is committed and defaults are applied; append
1592    // the durable enrollment intent. A journal failure must not roll back the
1593    // provisioned account or fail the login — it is logged as requiring
1594    // operator reconciliation (the user mints unlabeled and MAC denies until
1595    // then; later logins replay the intent by idempotency key).
1596    append_jit_enrollment_intent(issuer, external_sub, &resolution.username);
1597
1598    Ok(resolution.username)
1599}
1600
1601/// Append the OIDC JIT enrollment intent keyed by the atomically-bound
1602/// `(issuer, subject)` pair (#698 Phase 2). Never fatal to the login path:
1603/// the account already exists, so failures are recorded for reconciliation
1604/// and the fail-closed MAC deny on unlabeled subjects bounds the risk.
1605fn append_jit_enrollment_intent(issuer: &str, external_sub: &str, username: &str) {
1606    use crate::mac::enrollment_journal as journal;
1607    let Some(dir) = journal::global_journal_dir() else {
1608        tracing::error!(
1609            subject = %username,
1610            "enrollment journal directory is not configured — reconciliation required"
1611        );
1612        return;
1613    };
1614    let intent = journal::EnrollmentIntent {
1615        subject: username.to_owned(),
1616        label: journal::DEFAULT_ENROLLMENT_CLEARANCE.to_owned(),
1617        provision_epoch: std::time::SystemTime::now()
1618            .duration_since(std::time::UNIX_EPOCH)
1619            .map(|d| d.as_secs())
1620            .unwrap_or(0),
1621        idempotency_key: Some(journal::jit_idempotency_key(issuer, external_sub)),
1622    };
1623    match journal::record_intent(dir, intent) {
1624        Ok(journal::AppendOutcome::Committed { seq }) => {
1625            tracing::info!(subject = %username, seq, "enrollment intent journaled");
1626        }
1627        Ok(journal::AppendOutcome::Replay { .. }) => {}
1628        Ok(journal::AppendOutcome::Conflict { seq }) => tracing::error!(
1629            subject = %username,
1630            seq,
1631            "enrollment-intent journal recorded a conflict — operator reconciliation required"
1632        ),
1633        Err(error) => tracing::error!(
1634            subject = %username,
1635            %error,
1636            "enrollment-intent journal append failed — reconciliation required"
1637        ),
1638    }
1639}
1640
1641#[cfg(test)]
1642#[allow(clippy::unwrap_used)]
1643mod external_login_tests {
1644    use super::*;
1645    use hyprstream_rpc::crypto::CryptoPolicy;
1646    use hyprstream_rpc::rpc_client::RpcClientImpl;
1647    use hyprstream_rpc::signer::LocalSigner;
1648    use hyprstream_rpc::transport::lazy_uds::LazyUdsTransport;
1649
1650    const CLIENT_VERIFIER: &str =
1651        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~";
1652
1653    fn test_state() -> OAuthState {
1654        let key = ed25519_dalek::SigningKey::from_bytes(&[0x61; 32]);
1655        let remote = ed25519_dalek::SigningKey::from_bytes(&[0x62; 32]).verifying_key();
1656        let make_client = || {
1657            Arc::new(
1658                RpcClientImpl::new(
1659                    LocalSigner::new(key.clone()),
1660                    LazyUdsTransport::new("/dev/null/oauth-external-login-test.sock".into()),
1661                    Some(remote),
1662                )
1663                .with_response_verify_policy(CryptoPolicy::Classical),
1664            )
1665        };
1666        let mut config = crate::config::OAuthConfig::default();
1667        config.default_scopes.push("openid".to_owned());
1668        config.oidc_providers.insert(
1669            "provider".to_owned(),
1670            serde_json::from_value(serde_json::json!({
1671                "kind": "oauth2",
1672                "client_id": "upstream-client",
1673                "authorization_endpoint": "https://idp.example/authorize",
1674                "token_endpoint_url": "https://idp.example/token",
1675                "userinfo_endpoint": "https://idp.example/userinfo"
1676            }))
1677            .unwrap(),
1678        );
1679        let mut auto = config.oidc_providers["provider"].clone();
1680        auto.provisioning = ProvisioningMode::Auto;
1681        config.oidc_providers.insert("auto".to_owned(), auto);
1682        OAuthState::new(
1683            &config,
1684            hyprstream_rpc_std::policy_client::PolicyClient::new(make_client()),
1685            hyprstream_rpc_std::discovery_client::DiscoveryClient::new(make_client()),
1686            key.verifying_key().to_bytes(),
1687        )
1688    }
1689
1690    fn test_request() -> super::super::authorize::AuthorizeParams {
1691        super::super::authorize::AuthorizeParams {
1692            client_id: "client".to_owned(),
1693            redirect_uri: "https://client.example/cb?existing=1".to_owned(),
1694            code_challenge: URL_SAFE_NO_PAD.encode(Sha256::digest(CLIENT_VERIFIER.as_bytes())),
1695            code_challenge_method: "S256".to_owned(),
1696            response_type: "code".to_owned(),
1697            state: Some("a&b".to_owned()),
1698            scope: Some("openid".to_owned()),
1699            resource: Some("https://mcp.example/".to_owned()),
1700            nonce: Some("oidc-nonce".to_owned()),
1701            dpop_jkt: None,
1702            client_assertion_jkt: None,
1703        }
1704    }
1705
1706    fn test_client() -> super::super::state::RegisteredClient {
1707        super::super::state::RegisteredClient {
1708            client_id: "client".to_owned(),
1709            redirect_uris: vec!["https://client.example/cb?existing=1".to_owned()],
1710            client_name: None,
1711            client_uri: None,
1712            logo_uri: None,
1713            grant_types: vec![],
1714            response_types: vec![],
1715            token_endpoint_auth_method: None,
1716            jwks: None,
1717            jwks_uri: None,
1718            hyprstream_node_did: None,
1719            scope: Some("openid".to_owned()),
1720            dpop_bound_access_tokens: None,
1721            is_cimd: false,
1722            registered_at: Instant::now(),
1723        }
1724    }
1725
1726    #[test]
1727    fn external_oidc_provider_approval_requires_exact_origin() {
1728        let issuer = "https://auth.example.test/oauth";
1729        let mut headers = HeaderMap::new();
1730        assert!(!external_origin_matches(&headers, issuer));
1731        headers.insert(header::ORIGIN, "https://auth.example.test".parse().unwrap());
1732        assert!(external_origin_matches(&headers, issuer));
1733        headers.insert(
1734            header::ORIGIN,
1735            "https://auth.example.test.attacker.test".parse().unwrap(),
1736        );
1737        assert!(!external_origin_matches(&headers, issuer));
1738        headers.insert(header::ORIGIN, "null".parse().unwrap());
1739        assert!(!external_origin_matches(&headers, issuer));
1740        headers.append(header::ORIGIN, "https://auth.example.test".parse().unwrap());
1741        assert!(!external_origin_matches(&headers, issuer));
1742    }
1743
1744    #[test]
1745    fn external_oidc_id_token_requires_sole_audience_and_matching_azp() {
1746        let client = "hyprstream-client";
1747        assert!(id_token_targets_client(
1748            &serde_json::json!({"aud": client}),
1749            client
1750        ));
1751        assert!(id_token_targets_client(
1752            &serde_json::json!({"aud": [client], "azp": client}),
1753            client
1754        ));
1755        for claims in [
1756            serde_json::json!({"aud": "other"}),
1757            serde_json::json!({"aud": [client, "other"], "azp": client}),
1758            serde_json::json!({"aud": [client], "azp": "other"}),
1759            serde_json::json!({"aud": [client], "azp": null}),
1760        ] {
1761            assert!(!id_token_targets_client(&claims, client), "{claims}");
1762        }
1763    }
1764
1765    #[test]
1766    fn external_oidc_provider_authorize_url_preserves_existing_query_and_fragment() {
1767        let built = build_provider_authorize_url(
1768            "https://idp.example/authorize?realm=staff#login",
1769            "client id",
1770            "https://rp.example/callback?x=1&y=2",
1771            "openid profile",
1772            "random&state",
1773            Some("nonce"),
1774            Some("challenge"),
1775        )
1776        .unwrap();
1777        let parsed = url::Url::parse(&built).unwrap();
1778        assert_eq!(parsed.fragment(), Some("login"));
1779        let pairs: std::collections::HashMap<_, _> = parsed.query_pairs().collect();
1780        assert_eq!(pairs["realm"], "staff");
1781        assert_eq!(pairs["client_id"], "client id");
1782        assert_eq!(pairs["redirect_uri"], "https://rp.example/callback?x=1&y=2");
1783        assert_eq!(pairs["scope"], "openid profile");
1784        assert_eq!(pairs["state"], "random&state");
1785        assert_eq!(pairs["nonce"], "nonce");
1786        assert_eq!(pairs["code_challenge"], "challenge");
1787    }
1788
1789    #[cfg(feature = "pglite")]
1790    #[tokio::test]
1791    async fn external_oidc_inactive_existing_binding_cannot_reprovision() {
1792        use crate::auth::{ProductionUserStore, UserProfilePatch, UserStore};
1793
1794        let (_guard, store) = crate::auth::pglite_store::tests::fresh().await;
1795        store
1796            .resolve_or_bind_external_idp("provider", "alice", "provider:alice")
1797            .await
1798            .unwrap();
1799        store
1800            .set_profile(
1801                "provider:alice",
1802                UserProfilePatch {
1803                    active: Some(Some(false)),
1804                    ..Default::default()
1805                },
1806            )
1807            .await
1808            .unwrap();
1809        let state =
1810            test_state().with_user_store(ProductionUserStore::for_test(Arc::new(store.clone())));
1811        let response = provision_federated_user(
1812            &state,
1813            "provider",
1814            "alice",
1815            "provider:alice",
1816            &serde_json::json!({"sub": "alice"}),
1817            &[],
1818        )
1819        .await
1820        .unwrap_err();
1821        assert_eq!(response.status(), axum::http::StatusCode::FORBIDDEN);
1822        assert_eq!(
1823            store
1824                .get_profile("provider:alice")
1825                .await
1826                .unwrap()
1827                .unwrap()
1828                .active,
1829            Some(false)
1830        );
1831    }
1832
1833    #[tokio::test]
1834    async fn external_oidc_login_challenge_is_single_use_and_retains_complete_par_request() {
1835        let state = test_state();
1836        let request = test_request();
1837        state
1838            .pending_nonces
1839            .write()
1840            .await
1841            .insert("once".to_owned(), Instant::now() + Duration::from_secs(300));
1842        state.pending_authorize_bindings.write().await.insert(
1843            "once".to_owned(),
1844            AuthorizeBinding {
1845                request: request.clone(),
1846            },
1847        );
1848        let consumed = consume_external_login_challenge(&state, "once")
1849            .await
1850            .unwrap()
1851            .request;
1852        assert_eq!(consumed.client_assertion_jkt, request.client_assertion_jkt);
1853        assert_eq!(consumed.resource, request.resource);
1854        assert_eq!(consumed.state, request.state);
1855        assert!(consume_external_login_challenge(&state, "once")
1856            .await
1857            .is_none());
1858        state.pending_nonces.write().await.insert(
1859            "expired".to_owned(),
1860            Instant::now() - Duration::from_secs(1),
1861        );
1862        state
1863            .pending_authorize_bindings
1864            .write()
1865            .await
1866            .insert("expired".to_owned(), AuthorizeBinding { request });
1867        assert!(consume_external_login_challenge(&state, "expired")
1868            .await
1869            .is_none());
1870    }
1871
1872    #[tokio::test]
1873    async fn external_oidc_provider_hop_uses_bound_request_once() {
1874        let state = Arc::new(test_state());
1875        state
1876            .clients
1877            .write()
1878            .await
1879            .insert("client".to_owned(), test_client());
1880        state
1881            .pending_nonces
1882            .write()
1883            .await
1884            .insert("once".to_owned(), Instant::now() + Duration::from_secs(300));
1885        state.pending_authorize_bindings.write().await.insert(
1886            "once".to_owned(),
1887            AuthorizeBinding {
1888                request: test_request(),
1889            },
1890        );
1891        let origin = url::Url::parse(&state.issuer_url)
1892            .unwrap()
1893            .origin()
1894            .ascii_serialization();
1895        let mut headers = HeaderMap::new();
1896        headers.insert(header::ORIGIN, origin.parse().unwrap());
1897        let disabled = external_authorize(
1898            State(state.clone()),
1899            Path("auto".to_owned()),
1900            headers.clone(),
1901            Form(ExternalAuthorizeForm {
1902                login_challenge: "once".to_owned(),
1903            }),
1904        )
1905        .await;
1906        assert_eq!(
1907            disabled.status(),
1908            axum::http::StatusCode::SERVICE_UNAVAILABLE
1909        );
1910        assert!(state.pending_nonces.read().await.contains_key("once"));
1911        let submit = || ExternalAuthorizeForm {
1912            login_challenge: "once".to_owned(),
1913        };
1914        let response = external_authorize(
1915            State(state.clone()),
1916            Path("provider".to_owned()),
1917            headers.clone(),
1918            Form(submit()),
1919        )
1920        .await;
1921        assert!(response.status().is_redirection());
1922        let location = response
1923            .headers()
1924            .get(header::LOCATION)
1925            .unwrap()
1926            .to_str()
1927            .unwrap();
1928        let upstream = url::Url::parse(location).unwrap();
1929        assert_eq!(upstream.host_str(), Some("idp.example"));
1930        assert!(upstream
1931            .query_pairs()
1932            .any(|(key, value)| key == "client_id" && value == "upstream-client"));
1933        let pending = state.pending_external_auths.read().await;
1934        assert_eq!(pending.len(), 1);
1935        let bound = pending.values().next().unwrap();
1936        assert_eq!(
1937            bound.original_request.as_ref().unwrap().redirect_uri,
1938            test_request().redirect_uri
1939        );
1940        assert!(bound
1941            .original_request
1942            .as_ref()
1943            .unwrap()
1944            .client_assertion_jkt
1945            .is_none());
1946        drop(pending);
1947        let replay = external_authorize(
1948            State(state.clone()),
1949            Path("provider".to_owned()),
1950            headers.clone(),
1951            Form(submit()),
1952        )
1953        .await;
1954        assert_eq!(replay.status(), axum::http::StatusCode::BAD_REQUEST);
1955
1956        for (challenge, scope, redirect, binding) in [
1957            (
1958                "excessive",
1959                "openid write",
1960                "https://client.example/cb?existing=1",
1961                "none",
1962            ),
1963            (
1964                "atproto",
1965                "atproto",
1966                "https://client.example/cb?existing=1",
1967                "none",
1968            ),
1969            ("redirect", "openid", "https://attacker.example/cb", "none"),
1970            (
1971                "assertion",
1972                "openid",
1973                "https://client.example/cb?existing=1",
1974                "assertion",
1975            ),
1976            (
1977                "dpop",
1978                "openid",
1979                "https://client.example/cb?existing=1",
1980                "dpop",
1981            ),
1982        ] {
1983            state.pending_nonces.write().await.insert(
1984                challenge.to_owned(),
1985                Instant::now() + Duration::from_secs(300),
1986            );
1987            let mut request = test_request();
1988            request.scope = Some(scope.to_owned());
1989            request.redirect_uri = redirect.to_owned();
1990            if binding == "assertion" {
1991                request.client_assertion_jkt = Some("par-bound-key".to_owned());
1992            }
1993            if binding == "dpop" {
1994                request.dpop_jkt = Some("par-bound-key".to_owned());
1995            }
1996            state
1997                .pending_authorize_bindings
1998                .write()
1999                .await
2000                .insert(challenge.to_owned(), AuthorizeBinding { request });
2001            let response = external_authorize(
2002                State(state.clone()),
2003                Path("provider".to_owned()),
2004                headers.clone(),
2005                Form(ExternalAuthorizeForm {
2006                    login_challenge: challenge.to_owned(),
2007                }),
2008            )
2009            .await;
2010            assert_eq!(response.status(), axum::http::StatusCode::BAD_REQUEST);
2011            assert_eq!(state.pending_external_auths.read().await.len(), 1);
2012        }
2013    }
2014
2015    #[tokio::test]
2016    async fn external_oidc_handlers_reject_origin_and_replayed_callback_state() {
2017        let state = Arc::new(test_state());
2018        let response = external_authorize(
2019            State(state.clone()),
2020            Path("configured-provider".to_owned()),
2021            HeaderMap::new(),
2022            Form(ExternalAuthorizeForm {
2023                login_challenge: "unknown".to_owned(),
2024            }),
2025        )
2026        .await;
2027        assert_eq!(response.status(), axum::http::StatusCode::FORBIDDEN);
2028
2029        let params = CallbackParams {
2030            code: "upstream-code".to_owned(),
2031            state: "unknown".to_owned(),
2032        };
2033        let response = external_callback(
2034            State(state.clone()),
2035            Path("provider".to_owned()),
2036            HeaderMap::new(),
2037            Query(params),
2038        )
2039        .await;
2040        assert_eq!(response.status(), axum::http::StatusCode::BAD_REQUEST);
2041
2042        state.pending_external_auths.write().await.insert(
2043            "once".to_owned(),
2044            PendingExternalAuth {
2045                provider_slug: "provider".to_owned(),
2046                external_state: "once".to_owned(),
2047                external_nonce: "nonce".to_owned(),
2048                provider_kind: ProviderKind::Oidc,
2049                pkce_supported: true,
2050                pkce_verifier: "verifier".to_owned(),
2051                client_secret: None,
2052                token_endpoint: "https://idp.example/token".to_owned(),
2053                original_request: Some(test_request()),
2054                federate_owner_link: None,
2055                created_at: Instant::now(),
2056                expires_at: Instant::now() + Duration::from_secs(60),
2057            },
2058        );
2059        let callback = || CallbackParams {
2060            code: "upstream-code".to_owned(),
2061            state: "once".to_owned(),
2062        };
2063        let wrong_provider = external_callback(
2064            State(state.clone()),
2065            Path("other".to_owned()),
2066            HeaderMap::new(),
2067            Query(callback()),
2068        )
2069        .await;
2070        assert_eq!(wrong_provider.status(), axum::http::StatusCode::BAD_REQUEST);
2071        assert!(state
2072            .pending_external_auths
2073            .read()
2074            .await
2075            .contains_key("once"));
2076        let original_provider = external_callback(
2077            State(state.clone()),
2078            Path("provider".to_owned()),
2079            HeaderMap::new(),
2080            Query(callback()),
2081        )
2082        .await;
2083        assert_eq!(
2084            original_provider.status(),
2085            axum::http::StatusCode::BAD_REQUEST
2086        );
2087        assert!(!state
2088            .pending_external_auths
2089            .read()
2090            .await
2091            .contains_key("once"));
2092        let replay = external_callback(
2093            State(state),
2094            Path("provider".to_owned()),
2095            HeaderMap::new(),
2096            Query(callback()),
2097        )
2098        .await;
2099        assert_eq!(replay.status(), axum::http::StatusCode::BAD_REQUEST);
2100    }
2101
2102    /// A matching username, an inactive link, and a link without a hosted
2103    /// account record each fail before authorization-code issuance.
2104    #[tokio::test]
2105    async fn external_oidc_shared_callback_requires_hosted_account_after_explicit_link() {
2106        use crate::auth::{
2107            ExternalIdentityBinding, ProductionUserStore, RocksDbUserStore, UserProfilePatch,
2108            UserStore,
2109        };
2110        use axum::{
2111            routing::{get, post},
2112            Json, Router,
2113        };
2114
2115        let app = Router::new()
2116            .route(
2117                "/token",
2118                post(|| async { Json(serde_json::json!({"access_token": "upstream-token"})) }),
2119            )
2120            .route(
2121                "/userinfo",
2122                get(|| async { Json(serde_json::json!({"sub": "alice"})) }),
2123            );
2124        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
2125        let address = listener.local_addr().unwrap();
2126        let server = tokio::spawn(async move { axum::serve(listener, app).await });
2127        let base = format!("http://{address}");
2128
2129        let user_dir = tempfile::TempDir::new().unwrap();
2130        let user_store = Arc::new(RocksDbUserStore::open(user_dir.path()).unwrap());
2131        user_store.register("provider:alice").await.unwrap();
2132        let mut state =
2133            test_state().with_user_store(ProductionUserStore::for_test(user_store.clone()));
2134        state.http_client = reqwest::Client::builder().no_proxy().build().unwrap();
2135        state
2136            .external_providers
2137            .get_mut("provider")
2138            .unwrap()
2139            .userinfo_endpoint = Some(format!("{base}/userinfo"));
2140        state
2141            .clients
2142            .write()
2143            .await
2144            .insert("client".to_owned(), test_client());
2145        let pending_auth = PendingExternalAuth {
2146            provider_slug: "provider".to_owned(),
2147            external_state: "upstream-state".to_owned(),
2148            external_nonce: String::new(),
2149            provider_kind: ProviderKind::OAuth2,
2150            pkce_supported: true,
2151            pkce_verifier: "upstream-verifier".to_owned(),
2152            client_secret: None,
2153            token_endpoint: format!("{base}/token"),
2154            original_request: Some(test_request()),
2155            federate_owner_link: None,
2156            created_at: Instant::now(),
2157            expires_at: Instant::now() + Duration::from_secs(60),
2158        };
2159        state
2160            .pending_external_auths
2161            .write()
2162            .await
2163            .insert("upstream-state".to_owned(), pending_auth.clone());
2164        let state = Arc::new(state);
2165        let callback = || CallbackParams {
2166            code: "upstream-code".to_owned(),
2167            state: "upstream-state".to_owned(),
2168        };
2169        let unbound = external_callback(
2170            State(state.clone()),
2171            Path("provider".to_owned()),
2172            HeaderMap::new(),
2173            Query(callback()),
2174        )
2175        .await;
2176        assert_eq!(unbound.status(), axum::http::StatusCode::FORBIDDEN);
2177        assert!(state.pending_codes.read().await.is_empty());
2178
2179        // Model an authorized operator linking the verified upstream subject
2180        // to this existing local account. A name match alone was insufficient.
2181        user_store
2182            .set_profile(
2183                "provider:alice",
2184                UserProfilePatch {
2185                    external_identities: Some(vec![ExternalIdentityBinding {
2186                        issuer: "provider".to_owned(),
2187                        subject: "alice".to_owned(),
2188                    }]),
2189                    active: Some(Some(false)),
2190                    ..Default::default()
2191                },
2192            )
2193            .await
2194            .unwrap();
2195        state
2196            .pending_external_auths
2197            .write()
2198            .await
2199            .insert("upstream-state".to_owned(), pending_auth.clone());
2200        let inactive = external_callback(
2201            State(state.clone()),
2202            Path("provider".to_owned()),
2203            HeaderMap::new(),
2204            Query(callback()),
2205        )
2206        .await;
2207        assert_eq!(inactive.status(), axum::http::StatusCode::FORBIDDEN);
2208        let body = axum::body::to_bytes(inactive.into_body(), usize::MAX)
2209            .await
2210            .unwrap();
2211        assert_eq!(body.as_ref(), b"Linked account is unavailable");
2212        assert!(state.pending_codes.read().await.is_empty());
2213
2214        user_store
2215            .set_profile(
2216                "provider:alice",
2217                UserProfilePatch {
2218                    active: Some(Some(true)),
2219                    ..Default::default()
2220                },
2221            )
2222            .await
2223            .unwrap();
2224        state
2225            .pending_external_auths
2226            .write()
2227            .await
2228            .insert("upstream-state".to_owned(), pending_auth);
2229        let response = external_callback(
2230            State(state.clone()),
2231            Path("provider".to_owned()),
2232            HeaderMap::new(),
2233            Query(callback()),
2234        )
2235        .await;
2236        server.abort();
2237        assert_eq!(response.status(), axum::http::StatusCode::FORBIDDEN);
2238        let body = axum::body::to_bytes(response.into_body(), usize::MAX)
2239            .await
2240            .unwrap();
2241        assert_eq!(body.as_ref(), b"Local hosted account binding required");
2242        assert!(state.pending_codes.read().await.is_empty());
2243    }
2244
2245    #[tokio::test]
2246    async fn external_oidc_authorize_page_offers_post_only_for_generic_profile() {
2247        use crate::auth::{ProductionUserStore, RocksDbUserStore};
2248
2249        let user_dir = tempfile::TempDir::new().unwrap();
2250        let user_store = Arc::new(RocksDbUserStore::open(user_dir.path()).unwrap());
2251        let state =
2252            Arc::new(test_state().with_user_store(ProductionUserStore::for_test(user_store)));
2253        let mut client = test_client();
2254        client.scope = Some("openid atproto".to_owned());
2255        state
2256            .clients
2257            .write()
2258            .await
2259            .insert("client".to_owned(), client);
2260        let generic = super::super::authorize::AuthorizeQuery {
2261            request_uri: None,
2262            client_id: Some("client".to_owned()),
2263            redirect_uri: Some(test_request().redirect_uri),
2264            code_challenge: Some(test_request().code_challenge),
2265            code_challenge_method: Some("S256".to_owned()),
2266            response_type: Some("code".to_owned()),
2267            state: None,
2268            scope: Some("openid".to_owned()),
2269            resource: None,
2270            nonce: None,
2271        };
2272        let response =
2273            super::super::authorize::authorize_get(State(state.clone()), Query(generic)).await;
2274        assert_eq!(response.status(), axum::http::StatusCode::OK);
2275        let body = axum::body::to_bytes(response.into_body(), usize::MAX)
2276            .await
2277            .unwrap();
2278        let html = String::from_utf8(body.to_vec()).unwrap();
2279        assert!(html.contains("method=\"post\" action=\"/oauth/external/authorize/provider\""));
2280        assert!(html.contains("Authorize and sign in with provider"));
2281        assert!(!html.contains("/oauth/external/authorize/auto"));
2282        assert!(!html.contains("href=\"/oauth/external/authorize"));
2283
2284        let mut atproto = test_request();
2285        atproto.scope = Some("atproto".to_owned());
2286        atproto.dpop_jkt = Some("par-bound-key".to_owned());
2287        state.pending_par_requests.write().await.insert(
2288            "urn:ietf:params:oauth:request_uri:atproto".to_owned(),
2289            super::super::state::PushedAuthRequest {
2290                params: atproto,
2291                expires_at: Instant::now() + Duration::from_secs(60),
2292            },
2293        );
2294        let par = super::super::authorize::AuthorizeQuery {
2295            request_uri: Some("urn:ietf:params:oauth:request_uri:atproto".to_owned()),
2296            client_id: Some("client".to_owned()),
2297            redirect_uri: None,
2298            code_challenge: None,
2299            code_challenge_method: None,
2300            response_type: None,
2301            state: None,
2302            scope: None,
2303            resource: None,
2304            nonce: None,
2305        };
2306        let response =
2307            super::super::authorize::authorize_get(State(state.clone()), Query(par)).await;
2308        assert_eq!(response.status(), axum::http::StatusCode::OK);
2309        let body = axum::body::to_bytes(response.into_body(), usize::MAX)
2310            .await
2311            .unwrap();
2312        let html = String::from_utf8(body.to_vec()).unwrap();
2313        assert!(!html.contains("/oauth/external/authorize/provider"));
2314
2315        for (name, dpop, assertion) in [
2316            ("dpop", Some("par-bound-key"), None),
2317            ("assertion", None, Some("par-bound-key")),
2318        ] {
2319            let uri = format!("urn:ietf:params:oauth:request_uri:{name}");
2320            let mut bound = test_request();
2321            bound.dpop_jkt = dpop.map(str::to_owned);
2322            bound.client_assertion_jkt = assertion.map(str::to_owned);
2323            state.pending_par_requests.write().await.insert(
2324                uri.clone(),
2325                super::super::state::PushedAuthRequest {
2326                    params: bound,
2327                    expires_at: Instant::now() + Duration::from_secs(60),
2328                },
2329            );
2330            let query = super::super::authorize::AuthorizeQuery {
2331                request_uri: Some(uri),
2332                client_id: Some("client".to_owned()),
2333                redirect_uri: None,
2334                code_challenge: None,
2335                code_challenge_method: None,
2336                response_type: None,
2337                state: None,
2338                scope: None,
2339                resource: None,
2340                nonce: None,
2341            };
2342            let response =
2343                super::super::authorize::authorize_get(State(state.clone()), Query(query)).await;
2344            assert_eq!(response.status(), axum::http::StatusCode::OK);
2345            let body = axum::body::to_bytes(response.into_body(), usize::MAX)
2346                .await
2347                .unwrap();
2348            let html = String::from_utf8(body.to_vec()).unwrap();
2349            assert!(
2350                !html.contains("/oauth/external/authorize/provider"),
2351                "{name}"
2352            );
2353        }
2354    }
2355}
2356
2357#[cfg(test)]
2358#[allow(clippy::expect_used)]
2359mod token_response_tests {
2360    use super::check_token_response;
2361    use axum::{http::StatusCode, response::IntoResponse, routing::post, Router};
2362    use parking_lot::Mutex;
2363    use std::io::Write;
2364    use std::sync::Arc;
2365    use tracing::Level;
2366
2367    #[derive(Clone, Default)]
2368    struct LogCapture(Arc<Mutex<Vec<u8>>>);
2369
2370    impl Write for LogCapture {
2371        fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
2372            self.0.lock().extend_from_slice(bytes);
2373            Ok(bytes.len())
2374        }
2375
2376        fn flush(&mut self) -> std::io::Result<()> {
2377            Ok(())
2378        }
2379    }
2380
2381    async fn upstream_response(status: StatusCode, body: String) -> reqwest::Response {
2382        let app = Router::new().route("/token", post(move || async move { (status, body) }));
2383        let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
2384            .await
2385            .expect("bind mock token endpoint");
2386        let address = listener.local_addr().expect("mock endpoint address");
2387        let server = tokio::spawn(async move { axum::serve(listener, app).await });
2388        let response = reqwest::Client::builder()
2389            .no_proxy()
2390            .redirect(reqwest::redirect::Policy::none())
2391            .timeout(std::time::Duration::from_secs(5))
2392            .build()
2393            .expect("test client")
2394            .post(format!("http://{address}/token"))
2395            .send()
2396            .await
2397            .expect("mock token response");
2398        server.abort();
2399        response
2400    }
2401
2402    fn capture_check(
2403        response: reqwest::Response,
2404        level: Level,
2405    ) -> (Result<reqwest::Response, axum::response::Response>, String) {
2406        let capture = LogCapture::default();
2407        let writer = capture.clone();
2408        let subscriber = tracing_subscriber::fmt()
2409            .json()
2410            .without_time()
2411            .with_max_level(level)
2412            .with_writer(move || writer.clone())
2413            .finish();
2414        let result = tracing::subscriber::with_default(subscriber, || {
2415            check_token_response(response, "test-provider")
2416        })
2417        .map_err(IntoResponse::into_response);
2418        let logs = String::from_utf8(capture.0.lock().clone()).expect("UTF-8 structured logs");
2419        (result, logs)
2420    }
2421
2422    #[tokio::test]
2423    async fn token_response_errors_log_only_public_metadata() {
2424        let bodies = [
2425            serde_json::json!({
2426                "access_token": "access-secret-canary",
2427                "refresh_token": "refresh-secret-canary",
2428                "id_token": "eyJhbGciOiJSUzI1NiJ9.eyJzdWIiOiJzZWNyZXQifQ.signature-canary",
2429                "code": "authorization-code-canary",
2430                "client_secret": "client-secret-canary",
2431                "error": "provider-defined-secret-canary",
2432                "error_description": "Bearer diagnostic-secret-canary",
2433                "diagnostics": { "nested": "nested-secret-canary" }
2434            })
2435            .to_string(),
2436            "Bearer opaque-token-canary\nclient_secret=secret-canary&code=code-canary".repeat(1024),
2437            "".to_owned(),
2438        ];
2439        for status in [
2440            StatusCode::FOUND,
2441            StatusCode::BAD_REQUEST,
2442            StatusCode::UNAUTHORIZED,
2443            StatusCode::TOO_MANY_REQUESTS,
2444            StatusCode::INTERNAL_SERVER_ERROR,
2445            StatusCode::SERVICE_UNAVAILABLE,
2446        ] {
2447            for body in &bodies {
2448                // TRACE additionally proves that diagnostics weren't merely
2449                // moved to a lower severity. Each normal threshold is covered.
2450                for level in [Level::ERROR, Level::WARN, Level::INFO, Level::TRACE] {
2451                    let upstream = upstream_response(status, body.clone()).await;
2452                    let (result, logs) = capture_check(upstream, level);
2453                    let rejection = result.expect_err("reject non-success response");
2454                    assert_eq!(rejection.status(), StatusCode::BAD_GATEWAY);
2455                    let rejection_body = axum::body::to_bytes(rejection.into_body(), 1024)
2456                        .await
2457                        .expect("read rejection body");
2458                    assert_eq!(&rejection_body[..], b"External token exchange rejected");
2459                    let events: Vec<serde_json::Value> = logs
2460                        .lines()
2461                        .map(|line| serde_json::from_str(line).expect("JSON log event"))
2462                        .collect();
2463                    assert_eq!(events.len(), 1, "one safe error event: {logs}");
2464                    assert_eq!(events[0]["level"], "ERROR");
2465                    // Exact field allowlist catches raw bodies, unknown error
2466                    // codes, nested credentials, and future diagnostic fields.
2467                    assert_eq!(
2468                        events[0]["fields"],
2469                        serde_json::json!({
2470                            "message": "External token endpoint returned error",
2471                            "provider": "test-provider",
2472                            "status": status.as_u16(),
2473                        })
2474                    );
2475                    assert!(!logs.contains("canary"), "secret in logs: {logs}");
2476                }
2477            }
2478        }
2479    }
2480
2481    #[tokio::test]
2482    async fn token_response_success_preserves_body_without_logging() {
2483        let body = r#"{"access_token":"success-secret-canary"}"#;
2484        let upstream = upstream_response(StatusCode::OK, body.to_owned()).await;
2485        let (result, logs) = capture_check(upstream, Level::TRACE);
2486        let response = result.expect("successful response passes through");
2487        assert_eq!(response.status(), reqwest::StatusCode::OK);
2488        assert_eq!(response.text().await.expect("untouched token body"), body);
2489        assert!(logs.is_empty(), "successful token response logged: {logs}");
2490    }
2491}