1use 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
33pub 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
269pub 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 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 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 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
561fn 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
608fn 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 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
632pub 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 let pending = {
651 let mut auths = state.pending_external_auths.write().await;
652 match auths.get(¶ms.state) {
653 Some(p) if p.provider_slug == provider_slug && p.expires_at > Instant::now() => {
654 auths.remove(¶ms.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 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 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 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 let external_claims: serde_json::Value = match pending.provider_kind {
784 ProviderKind::Oidc => {
785 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 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 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 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 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 match claims["nonce"].as_str() {
884 Some(nonce) if nonce == pending.external_nonce => { }
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 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 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 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 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 let authoritative_username = match super::user_mapping::should_provision(
1270 &provider.provisioning,
1271 &mapped_subject,
1272 &provider.allowed_domains,
1273 ) {
1274 Ok(true) => {
1275 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 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 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 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, 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 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
1423async 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 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 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 if !resolution.provisioned {
1530 append_jit_enrollment_intent(issuer, external_sub, &resolution.username);
1535 return Ok(resolution.username);
1536 }
1537
1538 let subject = &resolution.username;
1541 if let Some(pm) = crate::auth::global_policy_manager() {
1542 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 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 append_jit_enrollment_intent(issuer, external_sub, &resolution.username);
1597
1598 Ok(resolution.username)
1599}
1600
1601fn 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 #[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 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 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 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}