1use crate::api::{ApiResponse, ApiState, extract_bearer_token, validate_api_token};
7use crate::oauth2_server::AuthorizationRequest;
8pub use crate::oauth2_server::{
10 AuthorizationRequest as AuthorizeRequest, TokenRequest, TokenResponse,
11};
12use axum::{
13 Json,
14 extract::{Path, Query, State},
15 http::{HeaderMap, StatusCode},
16 response::{IntoResponse, Redirect},
17};
18use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
19use serde::{Deserialize, Serialize};
20use sha2::{Digest, Sha256};
21use url::Url;
22use uuid::Uuid;
23
24fn redirect_uri_matches(candidate: &str, registered: &str) -> bool {
29 match (Url::parse(candidate), Url::parse(registered)) {
30 (Ok(a), Ok(b)) => {
31 if a.fragment().is_some() || b.fragment().is_some() {
33 return false;
34 }
35
36 a.scheme() == b.scheme()
37 && a.host_str() == b.host_str()
38 && a.port_or_known_default() == b.port_or_known_default()
39 && a.path() == b.path()
40 && a.query() == b.query()
41 }
42 _ => candidate == registered,
45 }
46}
47
48#[derive(Debug, Serialize)]
64pub struct OAuthError {
65 pub error: String,
66 #[serde(skip_serializing_if = "Option::is_none")]
67 pub error_description: Option<String>,
68 #[serde(skip_serializing_if = "Option::is_none")]
69 pub error_uri: Option<String>,
70 #[serde(skip_serializing_if = "Option::is_none")]
71 pub state: Option<String>,
72}
73
74impl OAuthError {
75 pub fn new(error: impl Into<String>) -> Self {
77 Self {
78 error: error.into(),
79 error_description: None,
80 error_uri: None,
81 state: None,
82 }
83 }
84
85 pub fn description(mut self, desc: impl Into<String>) -> Self {
87 self.error_description = Some(desc.into());
88 self
89 }
90
91 pub fn state(mut self, state: impl Into<String>) -> Self {
93 self.state = Some(state.into());
94 self
95 }
96
97 pub fn maybe_state(mut self, state: Option<String>) -> Self {
99 self.state = state;
100 self
101 }
102
103 pub fn error_uri(mut self, uri: impl Into<String>) -> Self {
105 self.error_uri = Some(uri.into());
106 self
107 }
108}
109
110#[derive(Debug, Serialize, Deserialize)]
129pub struct ClientInfo {
130 pub client_id: String,
131 pub name: String,
132 pub description: String,
133 pub redirect_uris: Vec<String>,
134 pub scopes: Vec<String>,
135}
136
137#[derive(Deserialize)]
148pub struct RevokeRequest {
149 pub token: String,
150 #[serde(default)]
151 pub token_type_hint: Option<String>, #[serde(default)]
154 pub client_id: Option<String>,
155 #[serde(default)]
157 pub client_secret: Option<String>,
158}
159
160impl std::fmt::Debug for RevokeRequest {
161 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
162 let mut d = f.debug_struct("RevokeRequest");
163 d.field("token", &crate::utils::redact::redacted(&self.token));
164 d.field("token_type_hint", &self.token_type_hint);
165 d.field("client_id", &self.client_id);
166 d.field(
167 "client_secret",
168 &crate::utils::redact::redacted(&self.client_secret),
169 );
170 d.finish()
171 }
172}
173
174#[derive(Debug, Serialize)]
193pub struct UserInfoResponse {
194 pub sub: String,
195 #[serde(skip_serializing_if = "Option::is_none")]
196 pub name: Option<String>,
197 #[serde(skip_serializing_if = "Option::is_none")]
198 pub email: Option<String>,
199 #[serde(skip_serializing_if = "Option::is_none")]
200 pub picture: Option<String>,
201 #[serde(skip_serializing_if = "Option::is_none")]
202 pub updated_at: Option<i64>,
203}
204
205pub async fn authorize(
214 State(state): State<ApiState>,
215 headers: HeaderMap,
216 Query(params): Query<AuthorizationRequest>,
217) -> impl IntoResponse {
218 if params.response_type != "code" {
219 let error = OAuthError::new("unsupported_response_type")
220 .description("Only 'code' response type is supported")
221 .maybe_state(params.state);
222 return (StatusCode::BAD_REQUEST, Json(error)).into_response();
223 }
224
225 if params.client_id.is_empty() {
226 let error = OAuthError::new("invalid_request")
227 .description("client_id is required")
228 .maybe_state(params.state);
229 return (StatusCode::BAD_REQUEST, Json(error)).into_response();
230 }
231
232 if params.redirect_uri.is_empty() {
233 let error = OAuthError::new("invalid_request")
234 .description("redirect_uri is required")
235 .maybe_state(params.state);
236 return (StatusCode::BAD_REQUEST, Json(error)).into_response();
237 }
238
239 let user_id = {
243 let token_str = match extract_bearer_token(&headers) {
244 Some(t) => t,
245 None => {
246 let error = OAuthError::new("unauthorized_client")
247 .description(
248 "User authentication required: supply your access token as \
249 'Authorization: Bearer <token>'",
250 )
251 .maybe_state(params.state);
252 return (StatusCode::UNAUTHORIZED, Json(error)).into_response();
253 }
254 };
255 match validate_api_token(&state.auth_framework, &token_str).await {
256 Ok(auth_token) => auth_token.user_id,
257 Err(_) => {
258 let error = OAuthError::new("unauthorized_client")
259 .description("Invalid or expired user access token")
260 .maybe_state(params.state);
261 return (StatusCode::UNAUTHORIZED, Json(error)).into_response();
262 }
263 }
264 };
265
266 let client_key = format!("oauth2_client:{}", params.client_id);
269 match state.auth_framework.storage().get_kv(&client_key).await {
270 Ok(Some(data)) => {
271 let client_data: serde_json::Value = serde_json::from_slice(&data).unwrap_or_default();
272 let registered_uris: Vec<String> = client_data["redirect_uris"]
273 .as_array()
274 .map(|arr| {
275 arr.iter()
276 .filter_map(|v| v.as_str().map(String::from))
277 .collect()
278 })
279 .unwrap_or_default();
280
281 if !registered_uris
282 .iter()
283 .any(|r| redirect_uri_matches(¶ms.redirect_uri, r))
284 {
285 tracing::warn!(
286 client_id = %params.client_id,
287 redirect_uri = %params.redirect_uri,
288 "OAuth authorize: redirect_uri not registered for client"
289 );
290 let error = OAuthError::new("invalid_request")
291 .description("redirect_uri is not registered for this client")
292 .maybe_state(params.state);
293 return (StatusCode::BAD_REQUEST, Json(error)).into_response();
294 }
295
296 let is_public_client = !super::client_secret::is_confidential(&client_data);
298 if is_public_client && params.code_challenge.is_none() {
299 let error = OAuthError::new("invalid_request")
300 .description("Public clients must use PKCE: code_challenge is required")
301 .maybe_state(params.state);
302 return (StatusCode::BAD_REQUEST, Json(error)).into_response();
303 }
304 }
305 Ok(None) => {
306 tracing::warn!(client_id = %params.client_id, "OAuth authorize: unknown client_id");
307 let error = OAuthError::new("invalid_client")
308 .description("Unknown client_id")
309 .maybe_state(params.state);
310 return (StatusCode::BAD_REQUEST, Json(error)).into_response();
311 }
312 Err(e) => {
313 tracing::error!(
314 client_id = %params.client_id,
315 error = %e,
316 "OAuth authorize: storage error looking up client"
317 );
318 let error = OAuthError::new("server_error")
319 .description("Authorization server error")
320 .maybe_state(params.state);
321 return (StatusCode::INTERNAL_SERVER_ERROR, Json(error)).into_response();
322 }
323 }
324
325 let auth_code = format!("ac_{}", uuid::Uuid::new_v4().to_string().replace("-", ""));
326
327 if let Some(ref resources) = params.resource
329 && let Err(e) =
330 crate::server::oauth::resource_indicators::validate_resource_indicators(resources)
331 {
332 let error = OAuthError::new("invalid_target")
333 .description(e.to_string())
334 .maybe_state(params.state);
335 return (StatusCode::BAD_REQUEST, Json(error)).into_response();
336 }
337
338 let code_data = serde_json::json!({
339 "client_id": params.client_id,
340 "redirect_uri": params.redirect_uri,
341 "scope": params.scope.clone().unwrap_or_else(|| "openid profile email".to_string()),
342 "state": params.state.clone(),
343 "code_challenge": params.code_challenge,
344 "code_challenge_method": params.code_challenge_method,
345 "user_id": user_id,
346 "resource": params.resource,
347 "created_at": chrono::Utc::now().to_rfc3339(),
348 "expires_at": (chrono::Utc::now() + chrono::Duration::minutes(10)).to_rfc3339(),
349 "used": false,
350 });
351
352 let storage_key = format!("oauth2_code:{}", auth_code);
353 let code_data_str = match serde_json::to_string(&code_data) {
354 Ok(s) => s,
355 Err(e) => {
356 tracing::error!("Failed to serialize OAuth authorization code data: {:?}", e);
357 let error =
358 OAuthError::new("server_error").description("Authorization server internal error");
359 return (StatusCode::INTERNAL_SERVER_ERROR, Json(error)).into_response();
360 }
361 };
362
363 if let Err(e) = state
364 .auth_framework
365 .storage()
366 .store_kv(
367 &storage_key,
368 code_data_str.as_bytes(),
369 Some(std::time::Duration::from_secs(600)),
370 )
371 .await
372 {
373 tracing::error!("Failed to store OAuth authorization code: {:?}", e);
374 let error = OAuthError::new("server_error")
375 .description("Authorization server error")
376 .maybe_state(params.state);
377 return (StatusCode::INTERNAL_SERVER_ERROR, Json(error)).into_response();
378 }
379
380 let encoded_state: Option<String> = params.state.as_deref().map(|st| {
383 st.bytes()
384 .flat_map(|b| {
385 if b.is_ascii_alphanumeric() || matches!(b, b'-' | b'_' | b'.' | b'~') {
386 vec![b as char]
387 } else {
388 format!("%{:02X}", b).chars().collect()
389 }
390 })
391 .collect()
392 });
393
394 let mut redirect_url = params.redirect_uri;
395 redirect_url.push_str(&format!("?code={}", auth_code));
396 if let Some(ref st) = encoded_state {
397 redirect_url.push_str(&format!("&state={}", st));
398 }
399
400 tracing::info!(
401 client_id = %params.client_id,
402 user_id = %user_id,
403 "OAuth authorization code issued"
404 );
405 Redirect::to(&redirect_url).into_response()
406}
407
408pub async fn token(
422 State(state): State<ApiState>,
423 Json(req): Json<TokenRequest>,
424) -> ApiResponse<TokenResponse> {
425 match req.grant_type.as_str() {
426 "authorization_code" => handle_authorization_code_grant(state, req).await,
427 "refresh_token" => handle_refresh_token_grant(state, req).await,
428 _ => ApiResponse::error_typed(
429 "unsupported_grant_type",
430 "Supported grant types: authorization_code, refresh_token",
431 ),
432 }
433}
434
435async fn handle_authorization_code_grant(
436 state: ApiState,
437 req: TokenRequest,
438) -> ApiResponse<TokenResponse> {
439 let code = match req.code {
440 Some(c) => c,
441 None => {
442 return ApiResponse::validation_error_typed(
443 "code is required for authorization_code grant",
444 );
445 }
446 };
447
448 let client_id = match req.client_id {
449 Some(c) => c,
450 None => return ApiResponse::validation_error_typed("client_id is required"),
451 };
452
453 let client_kind =
456 match authenticate_token_client(&state, &client_id, req.client_secret.as_deref()).await {
457 Ok(kind) => kind,
458 Err(refusal) => return *refusal,
459 };
460
461 let consumed_key = format!("oauth2_code_consumed:{}", code);
462 let storage_key = format!("oauth2_code:{}", code);
463 let code_data = match state.auth_framework.storage().get_kv(&storage_key).await {
464 Ok(Some(data)) => match serde_json::from_slice::<serde_json::Value>(&data) {
465 Ok(json) => json,
466 Err(e) => {
467 tracing::error!("Failed to parse stored authorization code data: {:?}", e);
468 return ApiResponse::error_typed("invalid_grant", "Invalid authorization code");
469 }
470 },
471 Ok(None) => {
472 return ApiResponse::error_typed(
473 "invalid_grant",
474 "Authorization code not found or expired",
475 );
476 }
477 Err(e) => {
478 tracing::error!("Failed to retrieve authorization code: {:?}", e);
479 return ApiResponse::error_typed(
480 "server_error",
481 "Failed to validate authorization code",
482 );
483 }
484 };
485
486 match state
490 .auth_framework
491 .storage()
492 .store_kv_if_absent(
493 &consumed_key,
494 b"1",
495 Some(std::time::Duration::from_secs(600)),
496 )
497 .await
498 {
499 Ok(true) => {}
500 Ok(false) => {
501 return ApiResponse::error_typed("invalid_grant", "Authorization code already used");
502 }
503 Err(e) => {
504 tracing::error!("Failed to claim authorization code: {:?}", e);
505 return ApiResponse::error_typed(
506 "server_error",
507 "Failed to process authorization code",
508 );
509 }
510 }
511
512 if code_data["client_id"].as_str() != Some(&client_id) {
515 if let Err(e) = state
516 .auth_framework
517 .storage()
518 .delete_kv(&consumed_key)
519 .await
520 {
521 tracing::warn!("Failed to release code consumed marker: {:?}", e);
522 }
523 return ApiResponse::error_typed("invalid_grant", "client_id mismatch");
524 }
525
526 if let Err(e) = state.auth_framework.storage().delete_kv(&storage_key).await {
528 tracing::error!("Failed to delete authorization code from storage: {:?}", e);
529 return ApiResponse::error_typed("server_error", "Failed to process authorization code");
530 }
531
532 if let Some(redirect_uri) = &req.redirect_uri {
534 let stored_uri = code_data["redirect_uri"].as_str().unwrap_or_default();
535 if !redirect_uri_matches(redirect_uri, stored_uri) {
536 return ApiResponse::error_typed("invalid_grant", "redirect_uri mismatch");
537 }
538 }
539
540 let stored_challenge = code_data["code_challenge"].as_str();
542 let challenge_method = code_data["code_challenge_method"]
543 .as_str()
544 .unwrap_or("plain");
545
546 if let Some(stored) = stored_challenge {
547 let code_verifier = match &req.code_verifier {
549 Some(verifier) => verifier,
550 None => {
551 return ApiResponse::error_typed(
552 "invalid_request",
553 "code_verifier is required when PKCE challenge was provided",
554 );
555 }
556 };
557
558 let computed_challenge = match challenge_method {
559 "S256" => {
560 let mut hasher = Sha256::new();
561 hasher.update(code_verifier.as_bytes());
562 URL_SAFE_NO_PAD.encode(hasher.finalize())
563 }
564 "plain" => code_verifier.clone(),
565 _ => {
566 return ApiResponse::error_typed(
567 "invalid_request",
568 "Unsupported code_challenge_method",
569 );
570 }
571 };
572
573 if computed_challenge != stored {
574 return ApiResponse::error_typed("invalid_grant", "PKCE verification failed");
575 }
576 } else if req.code_verifier.is_some() {
577 return ApiResponse::error_typed(
579 "invalid_request",
580 "code_verifier provided but no PKCE challenge was used in authorization",
581 );
582 } else if client_kind == ClientKind::Public {
583 return ApiResponse::error_typed(
587 "invalid_request",
588 "Public clients must use PKCE: provide code_challenge in authorization and code_verifier in token request",
589 );
590 }
591
592 let authz_resources: Vec<String> = code_data["resource"]
597 .as_array()
598 .map(|arr| {
599 arr.iter()
600 .filter_map(|v| v.as_str().map(String::from))
601 .collect()
602 })
603 .unwrap_or_default();
604
605 if let Some(ref token_resources) = req.resource {
606 if let Err(e) =
607 crate::server::oauth::resource_indicators::validate_resource_indicators(token_resources)
608 {
609 return ApiResponse::error_typed("invalid_target", e.to_string());
610 }
611 if let Err(e) = crate::server::oauth::resource_indicators::validate_token_resource_subset(
612 token_resources,
613 &authz_resources,
614 ) {
615 return ApiResponse::error_typed("invalid_target", e.to_string());
616 }
617 }
618
619 let scope = code_data["scope"]
621 .as_str()
622 .unwrap_or("openid profile email");
623 let scopes: Vec<String> = scope.split_whitespace().map(|s| s.to_string()).collect();
624
625 let user_id = match code_data["user_id"].as_str() {
629 Some(uid) if !uid.is_empty() => uid.to_string(),
630 _ => {
631 tracing::error!("Authorization code missing user_id field");
632 return ApiResponse::error_typed("server_error", "Malformed authorization code");
633 }
634 };
635
636 let token = match state.auth_framework.token_manager().create_auth_token(
637 &user_id,
638 scopes.clone(),
639 "oauth2",
640 None,
641 ) {
642 Ok(token) => token,
643 Err(e) => {
644 tracing::error!("Failed to create access token: {:?}", e);
645 return ApiResponse::error_typed("server_error", "Failed to create access token");
646 }
647 };
648
649 let refresh_token_value = uuid::Uuid::new_v4().to_string().replace("-", "");
651 let refresh_data = serde_json::json!({
652 "user_id": user_id,
653 "client_id": client_id,
654 "scopes": scope,
655 });
656 let refresh_key = format!("oauth2_refresh_token:{}", refresh_token_value);
657 if let Err(e) = state
658 .auth_framework
659 .storage()
660 .store_kv(
661 &refresh_key,
662 serde_json::to_string(&refresh_data)
663 .unwrap_or_default()
664 .as_bytes(),
665 Some(REFRESH_TOKEN_TTL),
666 )
667 .await
668 {
669 tracing::warn!("Failed to store refresh token: {:?}", e);
670 }
671
672 let expires_in = (token.expires_at - token.issued_at).num_seconds().max(0) as u64;
673 let response = TokenResponse {
674 access_token: token.access_token,
675 token_type: "Bearer".to_string(),
676 expires_in,
677 refresh_token: Some(refresh_token_value),
678 scope: Some(scope.to_string()),
679 id_token: None,
680 };
681
682 tracing::info!("OAuth2 tokens issued for client: {}", client_id);
683 ApiResponse::success(response)
684}
685
686fn refusal(code: &str, message: &str) -> Box<ApiResponse<TokenResponse>> {
688 Box::new(ApiResponse::error_typed(code, message))
689}
690
691async fn load_client_record(
693 state: &ApiState,
694 client_id: &str,
695) -> std::result::Result<Option<serde_json::Value>, Box<ApiResponse<TokenResponse>>> {
696 let key = format!("oauth2_client:{client_id}");
697 match state.auth_framework.storage().get_kv(&key).await {
698 Ok(Some(data)) => serde_json::from_slice(&data).map(Some).map_err(|e| {
699 tracing::error!("Unreadable client record for {client_id}: {e}");
700 refusal("server_error", "Failed to validate client")
701 }),
702 Ok(None) => Ok(None),
703 Err(e) => {
704 tracing::error!("Failed to load client {client_id}: {e:?}");
705 Err(refusal("server_error", "Failed to validate client"))
706 }
707 }
708}
709
710#[derive(Clone, Copy, PartialEq, Eq)]
712enum ClientKind {
713 Public,
715 Confidential,
717}
718
719async fn authenticate_token_client(
726 state: &ApiState,
727 client_id: &str,
728 presented_secret: Option<&str>,
729) -> std::result::Result<ClientKind, Box<ApiResponse<TokenResponse>>> {
730 let Some(record) = load_client_record(state, client_id).await? else {
731 return Err(refusal("invalid_client", "Unknown client"));
732 };
733 match super::client_secret::is_confidential(&record) {
734 false => Ok(ClientKind::Public),
735 true => {
736 let authenticated = match presented_secret {
737 Some(presented) => {
738 super::client_secret::authenticate(
739 state.auth_framework.storage().as_ref(),
740 client_id,
741 &record,
742 presented,
743 )
744 .await
745 }
746 None => false,
747 };
748 if authenticated {
749 Ok(ClientKind::Confidential)
750 } else {
751 Err(refusal("invalid_client", "Client authentication failed"))
752 }
753 }
754 }
755}
756
757const REFRESH_TOKEN_TTL: std::time::Duration = std::time::Duration::from_secs(30 * 24 * 3600);
759
760async fn authorize_refresh_client(
773 state: &ApiState,
774 stored_client: &str,
775 presented_id: Option<&str>,
776 presented_secret: Option<&str>,
777) -> std::result::Result<(), Box<ApiResponse<TokenResponse>>> {
778 let not_issued_to_you = || {
779 refusal(
780 "invalid_grant",
781 "Refresh token was not issued to this client",
782 )
783 };
784
785 let Some(stored_record) = load_client_record(state, stored_client).await? else {
786 return Err(refusal(
787 "invalid_grant",
788 "Refresh token was issued to a client that is no longer registered",
789 ));
790 };
791
792 if !super::client_secret::is_confidential(&stored_record) {
793 return match presented_id {
795 Some(id) if id == stored_client => Ok(()),
796 _ => Err(not_issued_to_you()),
797 };
798 }
799
800 let (Some(presented_id), Some(presented_secret)) = (presented_id, presented_secret) else {
802 return Err(refusal(
803 "invalid_client",
804 "Client authentication is required",
805 ));
806 };
807 let presented_record = if presented_id == stored_client {
808 Some(stored_record)
809 } else {
810 load_client_record(state, presented_id).await?
811 };
812 let authenticated = match presented_record.as_ref() {
813 Some(record) => {
814 super::client_secret::authenticate(
815 state.auth_framework.storage().as_ref(),
816 presented_id,
817 record,
818 presented_secret,
819 )
820 .await
821 }
822 None => false,
823 };
824 if !authenticated {
825 return Err(refusal("invalid_client", "Client authentication failed"));
826 }
827 if presented_id != stored_client {
828 return Err(not_issued_to_you());
829 }
830 Ok(())
831}
832
833async fn handle_refresh_token_grant(
834 state: ApiState,
835 req: TokenRequest,
836) -> ApiResponse<TokenResponse> {
837 let refresh_token_str = match req.refresh_token {
838 Some(t) => t,
839 None => return ApiResponse::validation_error_typed("refresh_token is required"),
840 };
841
842 let revoked_key = format!("oauth2_revoked_token:{}", refresh_token_str);
848 match state.auth_framework.storage().get_kv(&revoked_key).await {
849 Ok(Some(_)) => {
850 return ApiResponse::error_typed("invalid_grant", "Refresh token has been revoked");
851 }
852 Ok(None) => {} Err(e) => {
854 tracing::error!("Refresh token revocation check failed: {:?}", e);
855 return ApiResponse::error_typed("server_error", "Failed to validate refresh token");
856 }
857 }
858
859 let consumed_key = format!("oauth2_refresh_consumed:{}", refresh_token_str);
860
861 let refresh_key = format!("oauth2_refresh_token:{}", refresh_token_str);
863 let stored = match state.auth_framework.storage().get_kv(&refresh_key).await {
864 Ok(Some(data)) => match serde_json::from_slice::<serde_json::Value>(&data) {
865 Ok(v) => v,
866 Err(_) => return ApiResponse::error_typed("invalid_grant", "Invalid refresh token"),
867 },
868 Ok(None) => {
869 return ApiResponse::error_typed("invalid_grant", "Refresh token not found or expired");
870 }
871 Err(e) => {
872 tracing::error!("Failed to retrieve refresh token: {:?}", e);
873 return ApiResponse::error_typed("server_error", "Failed to validate refresh token");
874 }
875 };
876
877 match state
882 .auth_framework
883 .storage()
884 .store_kv_if_absent(&consumed_key, b"1", Some(REFRESH_TOKEN_TTL))
885 .await
886 {
887 Ok(true) => {}
888 Ok(false) => {
889 return ApiResponse::error_typed("invalid_grant", "Refresh token already consumed");
890 }
891 Err(e) => {
892 tracing::error!("Failed to claim refresh token: {:?}", e);
893 return ApiResponse::error_typed("server_error", "Failed to validate refresh token");
894 }
895 }
896
897 let user_id = match stored["user_id"].as_str() {
898 Some(u) => u.to_string(),
899 None => {
900 let _ = state
901 .auth_framework
902 .storage()
903 .delete_kv(&consumed_key)
904 .await;
905 return ApiResponse::error_typed("invalid_grant", "Malformed refresh token data");
906 }
907 };
908 let client_id = match &stored["client_id"] {
909 serde_json::Value::Null => None,
910 serde_json::Value::String(s) => Some(s.clone()),
911 _ => {
914 let _ = state
915 .auth_framework
916 .storage()
917 .delete_kv(&consumed_key)
918 .await;
919 return ApiResponse::error_typed("invalid_grant", "Malformed refresh token data");
920 }
921 };
922
923 if let Some(stored_client) = client_id.as_deref()
927 && let Err(refusal) = authorize_refresh_client(
928 &state,
929 stored_client,
930 req.client_id.as_deref(),
931 req.client_secret.as_deref(),
932 )
933 .await
934 {
935 if let Err(e) = state
936 .auth_framework
937 .storage()
938 .delete_kv(&consumed_key)
939 .await
940 {
941 tracing::warn!("Failed to release refresh consumed marker: {:?}", e);
942 }
943 return *refusal;
944 }
945
946 let scope = stored["scopes"]
947 .as_str()
948 .unwrap_or("openid profile email")
949 .to_string();
950 let scopes: Vec<String> = scope.split_whitespace().map(|s| s.to_string()).collect();
951
952 let token = match state
953 .auth_framework
954 .token_manager()
955 .create_auth_token(&user_id, scopes, "oauth2", None)
956 {
957 Ok(t) => t,
958 Err(e) => {
959 tracing::error!("Failed to create access token on refresh: {:?}", e);
960 let _ = state
963 .auth_framework
964 .storage()
965 .delete_kv(&consumed_key)
966 .await;
967 return ApiResponse::error_typed("server_error", "Failed to issue access token");
968 }
969 };
970
971 let new_refresh_token = uuid::Uuid::new_v4().to_string().replace("-", "");
974 let new_refresh_data = serde_json::json!({
975 "user_id": user_id,
976 "client_id": client_id,
977 "scopes": scope,
978 });
979 let new_refresh_key = format!("oauth2_refresh_token:{}", new_refresh_token);
980 if let Err(e) = state
981 .auth_framework
982 .storage()
983 .store_kv(
984 &new_refresh_key,
985 serde_json::to_string(&new_refresh_data)
986 .unwrap_or_default()
987 .as_bytes(),
988 Some(REFRESH_TOKEN_TTL),
989 )
990 .await
991 {
992 tracing::error!("Failed to store new refresh token: {:?}", e);
993 let _ = state
994 .auth_framework
995 .storage()
996 .delete_kv(&consumed_key)
997 .await;
998 return ApiResponse::error_typed("server_error", "Failed to issue refresh token");
999 }
1000
1001 if let Err(e) = state.auth_framework.storage().delete_kv(&refresh_key).await {
1003 tracing::warn!(
1004 "Failed to delete old refresh token during rotation: {:?}",
1005 e
1006 );
1007 }
1008
1009 let expires_in = (token.expires_at - token.issued_at).num_seconds().max(0) as u64;
1010 let response = TokenResponse {
1011 access_token: token.access_token,
1012 token_type: "Bearer".to_string(),
1013 expires_in,
1014 refresh_token: Some(new_refresh_token),
1015 scope: Some(scope),
1016 id_token: None,
1017 };
1018
1019 tracing::info!("OAuth2 token refreshed for user: {}", user_id);
1020 ApiResponse::success(response)
1021}
1022
1023async fn revocation_caller_is(
1027 state: &ApiState,
1028 headers: &HeaderMap,
1029 req: &RevokeRequest,
1030 owner: &str,
1031) -> bool {
1032 use base64::engine::general_purpose::STANDARD;
1033 let basic = headers
1034 .get(axum::http::header::AUTHORIZATION)
1035 .and_then(|value| value.to_str().ok())
1036 .and_then(|value| value.strip_prefix("Basic "))
1037 .and_then(|encoded| STANDARD.decode(encoded).ok())
1038 .and_then(|decoded| String::from_utf8(decoded).ok())
1039 .map(|decoded| match decoded.split_once(':') {
1040 Some((id, secret)) => (id.to_string(), Some(secret.to_string())),
1041 None => (decoded, None),
1042 });
1043 let (presented_id, presented_secret) = match basic {
1044 Some(pair) => pair,
1045 None => match &req.client_id {
1046 Some(id) => (id.clone(), req.client_secret.clone()),
1047 None => return false,
1048 },
1049 };
1050 if presented_id != owner {
1051 return false;
1052 }
1053 let key = format!("oauth2_client:{owner}");
1054 let record: serde_json::Value = match state.auth_framework.storage().get_kv(&key).await {
1055 Ok(Some(data)) => match serde_json::from_slice(&data) {
1056 Ok(record) => record,
1057 Err(_) => return false,
1058 },
1059 _ => return false,
1060 };
1061 if !super::client_secret::is_confidential(&record) {
1062 return true;
1063 }
1064 match presented_secret {
1065 Some(secret) => {
1066 super::client_secret::authenticate(
1067 state.auth_framework.storage().as_ref(),
1068 owner,
1069 &record,
1070 &secret,
1071 )
1072 .await
1073 }
1074 None => false,
1075 }
1076}
1077
1078pub async fn revoke(
1110 State(state): State<ApiState>,
1111 headers: HeaderMap,
1112 Json(req): Json<RevokeRequest>,
1113) -> ApiResponse<serde_json::Value> {
1114 if req.token.is_empty() || req.token.len() > 8192 {
1116 return ApiResponse::error_typed("invalid_request", "Invalid token");
1117 }
1118
1119 let issued_jwt = state
1123 .auth_framework
1124 .token_manager()
1125 .validate_jwt_token(&req.token)
1126 .ok();
1127 let refresh_record: Option<serde_json::Value> = match state
1128 .auth_framework
1129 .storage()
1130 .get_kv(&format!("oauth2_refresh_token:{}", req.token))
1131 .await
1132 {
1133 Ok(Some(data)) => serde_json::from_slice(&data).ok(),
1134 Ok(None) => None,
1135 Err(e) => {
1136 tracing::error!("Failed to look up the token to revoke: {:?}", e);
1137 return ApiResponse::error_typed("server_error", "Failed to revoke token");
1138 }
1139 };
1140 if issued_jwt.is_none() && refresh_record.is_none() {
1141 return ApiResponse::success(serde_json::json!({
1142 "message": "Token revoked successfully"
1143 }));
1144 }
1145
1146 let owner_client = issued_jwt
1151 .as_ref()
1152 .and_then(|claims| claims.client_id.clone())
1153 .or_else(|| {
1154 refresh_record
1155 .as_ref()
1156 .and_then(|record| record["client_id"].as_str().map(String::from))
1157 });
1158 if let Some(owner) = owner_client
1159 && !revocation_caller_is(&state, &headers, &req, &owner).await
1160 {
1161 return ApiResponse::error_typed("invalid_client", "Client authentication failed");
1162 }
1163 let revoked_token_key = format!("oauth2_revoked_token:{}", req.token);
1166 let revoked_data = serde_json::json!({
1167 "token": req.token,
1168 "revoked_at": chrono::Utc::now().to_rfc3339(),
1169 "token_type_hint": req.token_type_hint
1170 });
1171
1172 if let Err(e) = state
1173 .auth_framework
1174 .storage()
1175 .store_kv(
1176 &revoked_token_key,
1177 serde_json::to_string(&revoked_data)
1178 .unwrap_or_default()
1179 .as_bytes(),
1180 Some(std::time::Duration::from_secs(86400 * 30)),
1186 )
1187 .await
1188 {
1189 tracing::error!("Failed to store revoked token: {:?}", e);
1190 return ApiResponse::error_typed("server_error", "Failed to revoke token");
1191 }
1192
1193 let refresh_key = format!("oauth2_refresh_token:{}", req.token);
1198 if let Err(e) = state.auth_framework.storage().delete_kv(&refresh_key).await {
1199 tracing::warn!("Failed to delete refresh token on revoke: {:?}", e);
1200 }
1201
1202 if let Ok(claims) = state
1207 .auth_framework
1208 .token_manager()
1209 .validate_jwt_token(&req.token)
1210 {
1211 let now = chrono::Utc::now().timestamp();
1212 let remaining_secs = (claims.exp - now + 60).max(60) as u64;
1213 let jti_key = format!("revoked_token:{}", claims.jti);
1214 if let Err(e) = state
1215 .auth_framework
1216 .storage()
1217 .store_kv(
1218 &jti_key,
1219 b"1",
1220 Some(std::time::Duration::from_secs(remaining_secs)),
1221 )
1222 .await
1223 {
1224 tracing::warn!("Failed to store JWT JTI revocation entry: {:?}", e);
1225 } else {
1226 tracing::info!("JWT token revoked via jti: {}", claims.jti);
1227 }
1228 }
1229
1230 tracing::info!(
1231 "OAuth2 token revoked: {}",
1232 &req.token[..10.min(req.token.len())]
1233 );
1234
1235 ApiResponse::success(serde_json::json!({
1236 "message": "Token revoked successfully"
1237 }))
1238}
1239
1240pub async fn userinfo(
1253 State(state): State<ApiState>,
1254 headers: HeaderMap,
1255) -> ApiResponse<UserInfoResponse> {
1256 let token = match extract_bearer_token(&headers) {
1258 Some(t) => t,
1259 None => {
1260 return ApiResponse::error_typed("invalid_token", "Authorization header required");
1261 }
1262 };
1263
1264 let revoked_token_key = format!("oauth2_revoked_token:{}", token);
1266 if let Ok(Some(_)) = state
1267 .auth_framework
1268 .storage()
1269 .get_kv(&revoked_token_key)
1270 .await
1271 {
1272 return ApiResponse::error_typed("invalid_token", "Token has been revoked");
1273 }
1274
1275 let claims = match state
1277 .auth_framework
1278 .token_manager()
1279 .validate_jwt_token(&token)
1280 {
1281 Ok(c) => c,
1282 Err(_) => {
1283 return ApiResponse::error_typed("invalid_token", "Access token is invalid");
1284 }
1285 };
1286
1287 let user_profile = match state.auth_framework.get_user_profile(&claims.sub).await {
1289 Ok(profile) => profile,
1290 Err(e) => {
1291 tracing::error!("Failed to get user profile: {:?}", e);
1292 return ApiResponse::error_typed("server_error", "Failed to retrieve user information");
1293 }
1294 };
1295
1296 let userinfo = UserInfoResponse {
1297 sub: claims.sub.clone(),
1298 name: user_profile.username.clone(),
1299 email: if claims.scope.split_whitespace().any(|s| s == "email") {
1301 user_profile.email.clone()
1302 } else {
1303 None
1304 },
1305 picture: user_profile.picture.clone(),
1306 updated_at: Some(chrono::Utc::now().timestamp()),
1307 };
1308
1309 tracing::info!("OAuth2 UserInfo requested for user: {}", claims.sub);
1310 ApiResponse::success(userinfo)
1311}
1312
1313pub async fn get_client_info(
1321 State(state): State<ApiState>,
1322 Path(client_id): Path<String>,
1323) -> impl IntoResponse {
1324 let client_key = format!("oauth2_client:{}", client_id);
1325 match state.auth_framework.storage().get_kv(&client_key).await {
1326 Ok(Some(data)) => match serde_json::from_slice::<ClientInfo>(&data) {
1327 Ok(client) => (
1328 StatusCode::OK,
1329 Json(serde_json::json!({ "success": true, "data": client })),
1330 )
1331 .into_response(),
1332 Err(e) => {
1333 tracing::error!(client_id = %client_id, error = %e, "Failed to deserialize client record");
1334 (
1335 StatusCode::INTERNAL_SERVER_ERROR,
1336 Json(serde_json::json!({
1337 "success": false,
1338 "error": "server_error",
1339 "message": "Failed to read client record"
1340 })),
1341 )
1342 .into_response()
1343 }
1344 },
1345 Ok(None) => (
1346 StatusCode::NOT_FOUND,
1347 Json(serde_json::json!({
1348 "success": false,
1349 "error": "invalid_client",
1350 "message": "Unknown client_id"
1351 })),
1352 )
1353 .into_response(),
1354 Err(e) => {
1355 tracing::error!(client_id = %client_id, error = %e, "Storage error looking up client");
1356 (
1357 StatusCode::INTERNAL_SERVER_ERROR,
1358 Json(serde_json::json!({
1359 "success": false,
1360 "error": "server_error",
1361 "message": "Authorization server error"
1362 })),
1363 )
1364 .into_response()
1365 }
1366 }
1367}
1368
1369pub async fn openid_configuration(State(state): State<ApiState>) -> impl IntoResponse {
1385 let issuer = {
1386 let configured = state.auth_framework.config().issuer.clone();
1387 if configured.is_empty() {
1388 "https://auth.example.com".to_string()
1389 } else {
1390 configured
1391 }
1392 };
1393
1394 let config = serde_json::json!({
1395 "issuer": issuer,
1396 "authorization_endpoint": format!("{}/api/v1/oauth/authorize", issuer),
1397 "token_endpoint": format!("{}/api/v1/oauth/token", issuer),
1398 "userinfo_endpoint": format!("{}/api/v1/oauth/userinfo", issuer),
1399 "revocation_endpoint": format!("{}/api/v1/oauth/revoke", issuer),
1400 "introspection_endpoint": format!("{}/api/v1/oauth/introspect", issuer),
1401 "jwks_uri": format!("{}/api/v1/.well-known/jwks.json", issuer),
1402 "end_session_endpoint": format!("{}/api/v1/oauth/end_session", issuer),
1403 "pushed_authorization_request_endpoint": format!("{}/api/v1/oauth/par", issuer),
1404 "registration_endpoint": format!("{}/api/v1/oauth/register", issuer),
1405 "response_types_supported": ["code"],
1406 "grant_types_supported": [
1407 "authorization_code",
1408 "refresh_token"
1409 ],
1410 "subject_types_supported": ["public"],
1411 "id_token_signing_alg_values_supported": ["HS256"],
1412 "token_endpoint_auth_methods_supported": [
1413 "client_secret_basic",
1414 "client_secret_post"
1415 ],
1416 "code_challenge_methods_supported": ["S256"],
1417 "scopes_supported": ["openid", "profile", "email"]
1418 });
1419
1420 (StatusCode::OK, Json(config))
1421}
1422
1423pub async fn jwks(State(_state): State<ApiState>) -> impl IntoResponse {
1440 (StatusCode::OK, Json(serde_json::json!({ "keys": [] })))
1441}
1442
1443#[derive(Deserialize)]
1459pub struct EndSessionRequest {
1460 pub id_token_hint: Option<String>,
1461 pub post_logout_redirect_uri: Option<String>,
1462 pub state: Option<String>,
1463}
1464
1465impl std::fmt::Debug for EndSessionRequest {
1466 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1467 let mut d = f.debug_struct("EndSessionRequest");
1468 d.field(
1469 "id_token_hint",
1470 &crate::utils::redact::redacted(&self.id_token_hint),
1471 );
1472 d.field("post_logout_redirect_uri", &self.post_logout_redirect_uri);
1473 d.field("state", &self.state);
1474 d.finish()
1475 }
1476}
1477
1478pub async fn end_session(
1490 State(state): State<ApiState>,
1491 Query(params): Query<EndSessionRequest>,
1492) -> impl IntoResponse {
1493 if let Some(ref token) = params.id_token_hint
1495 && let Ok(claims) = state
1496 .auth_framework
1497 .token_manager()
1498 .validate_jwt_token(token)
1499 {
1500 let revoked_key = format!("oauth2_revoked_token:{}", token);
1501 if let Err(e) = state
1502 .auth_framework
1503 .storage()
1504 .store_kv(
1505 &revoked_key,
1506 b"revoked",
1507 Some(std::time::Duration::from_secs(86400 * 7)),
1508 )
1509 .await
1510 {
1511 tracing::warn!("Failed to revoke token during OIDC end_session: {}", e);
1512 }
1513 tracing::info!("OIDC end_session: revoked token for user {}", claims.sub);
1514 }
1515
1516 if let Some(ref redirect_uri) = params.post_logout_redirect_uri {
1520 let allowed = if let Some(ref token) = params.id_token_hint {
1522 let client_id = state
1524 .auth_framework
1525 .token_manager()
1526 .validate_jwt_token(token)
1527 .ok()
1528 .and_then(|claims| {
1529 if let Some(ref cid) = claims.client_id
1531 && !cid.is_empty()
1532 {
1533 return Some(cid.clone());
1534 }
1535 if !claims.aud.is_empty() {
1537 Some(claims.aud.clone())
1538 } else {
1539 None
1540 }
1541 });
1542 if let Some(cid) = client_id {
1543 let client_key = format!("oauth2_client:{}", cid);
1544 match state.auth_framework.storage().get_kv(&client_key).await {
1545 Ok(Some(data)) => {
1546 let client: serde_json::Value =
1547 serde_json::from_slice(&data).unwrap_or_default();
1548 let uris: Vec<String> = client["redirect_uris"]
1549 .as_array()
1550 .map(|a| {
1551 a.iter()
1552 .filter_map(|v| v.as_str().map(String::from))
1553 .collect()
1554 })
1555 .unwrap_or_default();
1556 uris.iter().any(|r| redirect_uri_matches(redirect_uri, r))
1557 }
1558 _ => false,
1559 }
1560 } else {
1561 false
1562 }
1563 } else {
1564 false
1565 };
1566
1567 if allowed {
1568 if let Ok(mut parsed) = Url::parse(redirect_uri) {
1569 if let Some(ref st) = params.state {
1570 parsed.query_pairs_mut().append_pair("state", st);
1571 }
1572 return Redirect::to(parsed.as_str()).into_response();
1573 }
1574 } else {
1575 tracing::warn!(
1576 "end_session: post_logout_redirect_uri rejected — not registered for the client"
1577 );
1578 }
1579 }
1580
1581 (
1583 StatusCode::OK,
1584 Json(serde_json::json!({ "status": "logged_out" })),
1585 )
1586 .into_response()
1587}
1588
1589#[derive(Debug, Deserialize)]
1605pub struct ClientRegistrationRequest {
1606 pub redirect_uris: Vec<String>,
1607 #[serde(default)]
1608 pub client_name: Option<String>,
1609 #[serde(default)]
1610 pub token_endpoint_auth_method: Option<String>,
1611 #[serde(default)]
1612 pub grant_types: Option<Vec<String>>,
1613 #[serde(default)]
1614 pub response_types: Option<Vec<String>>,
1615 #[serde(default)]
1616 pub scope: Option<String>,
1617}
1618
1619pub async fn register_client(
1639 State(state): State<ApiState>,
1640 headers: HeaderMap,
1641 Json(req): Json<ClientRegistrationRequest>,
1642) -> impl IntoResponse {
1643 let token_str = match extract_bearer_token(&headers) {
1645 Some(t) => t,
1646 None => {
1647 return (
1648 StatusCode::UNAUTHORIZED,
1649 Json(serde_json::json!({
1650 "error": "invalid_token",
1651 "error_description": "A valid Bearer token is required for dynamic client registration"
1652 })),
1653 )
1654 .into_response();
1655 }
1656 };
1657
1658 let is_initial_access_token = match state
1660 .auth_framework
1661 .storage()
1662 .get_kv("oauth2_initial_access_token")
1663 .await
1664 {
1665 Ok(Some(stored)) => {
1666 let stored_str = String::from_utf8_lossy(&stored);
1667 subtle::ConstantTimeEq::ct_eq(token_str.as_bytes(), stored_str.trim().as_bytes()).into()
1668 }
1669 _ => false,
1670 };
1671
1672 let is_admin = if !is_initial_access_token {
1674 match validate_api_token(&state.auth_framework, &token_str).await {
1675 Ok(auth_token) => auth_token.roles.contains("admin"),
1676 Err(_) => false,
1677 }
1678 } else {
1679 false
1680 };
1681
1682 if !is_initial_access_token && !is_admin {
1683 return (
1684 StatusCode::FORBIDDEN,
1685 Json(serde_json::json!({
1686 "error": "insufficient_scope",
1687 "error_description": "Dynamic client registration requires admin privileges or a valid Initial Access Token"
1688 })),
1689 )
1690 .into_response();
1691 }
1692 for uri in &req.redirect_uris {
1694 match Url::parse(uri) {
1695 Ok(parsed) => {
1696 match parsed.scheme() {
1697 "https" => {}
1698 "http" => {
1699 if !matches!(parsed.host_str(), Some("localhost" | "127.0.0.1" | "[::1]")) {
1701 return (
1702 StatusCode::BAD_REQUEST,
1703 Json(serde_json::json!({
1704 "error": "invalid_redirect_uri",
1705 "error_description": format!("Non-loopback HTTP redirect_uri not allowed: {}", uri)
1706 })),
1707 )
1708 .into_response();
1709 }
1710 }
1711 scheme => {
1712 return (
1713 StatusCode::BAD_REQUEST,
1714 Json(serde_json::json!({
1715 "error": "invalid_redirect_uri",
1716 "error_description": format!("Disallowed URI scheme '{}' in redirect_uri: {}", scheme, uri)
1717 })),
1718 )
1719 .into_response();
1720 }
1721 }
1722 }
1723 Err(_) => {
1724 return (
1725 StatusCode::BAD_REQUEST,
1726 Json(serde_json::json!({
1727 "error": "invalid_redirect_uri",
1728 "error_description": format!("Invalid redirect_uri: {}", uri)
1729 })),
1730 )
1731 .into_response();
1732 }
1733 }
1734 }
1735
1736 if req.redirect_uris.is_empty() {
1737 return (
1738 StatusCode::BAD_REQUEST,
1739 Json(serde_json::json!({
1740 "error": "invalid_client_metadata",
1741 "error_description": "At least one redirect_uri is required"
1742 })),
1743 )
1744 .into_response();
1745 }
1746
1747 let client_id = Uuid::new_v4().to_string();
1748 let client_secret = Uuid::new_v4().to_string();
1749 let client_secret_hash = match super::client_secret::hash_secret(&client_secret).await {
1751 Ok(hash) => hash,
1752 Err(e) => {
1753 tracing::error!("Failed to hash a client secret: {}", e);
1754 return (
1755 StatusCode::INTERNAL_SERVER_ERROR,
1756 Json(serde_json::json!({
1757 "error": "server_error",
1758 "error_description": "Failed to register client"
1759 })),
1760 )
1761 .into_response();
1762 }
1763 };
1764
1765 let client_data = serde_json::json!({
1766 "client_id": client_id,
1767 "client_secret_hash": client_secret_hash,
1768 "client_name": req.client_name,
1769 "redirect_uris": req.redirect_uris,
1770 "token_endpoint_auth_method": req.token_endpoint_auth_method.as_deref().unwrap_or("client_secret_basic"),
1771 "grant_types": req.grant_types.as_deref().unwrap_or(&["authorization_code".to_string()]),
1772 "response_types": req.response_types.as_deref().unwrap_or(&["code".to_string()]),
1773 "scope": req.scope.as_deref().unwrap_or("openid"),
1774 });
1775
1776 let key = format!("oauth2_client:{}", client_id);
1777 if let Err(e) = state
1778 .auth_framework
1779 .storage()
1780 .store_kv(&key, client_data.to_string().as_bytes(), None)
1781 .await
1782 {
1783 tracing::error!("Failed to store client registration: {}", e);
1784 return (
1785 StatusCode::INTERNAL_SERVER_ERROR,
1786 Json(serde_json::json!({
1787 "error": "server_error",
1788 "error_description": "Failed to register client"
1789 })),
1790 )
1791 .into_response();
1792 }
1793
1794 tracing::info!("Dynamic client registered: client_id={}", client_id);
1795
1796 (
1797 StatusCode::CREATED,
1798 Json(serde_json::json!({
1799 "client_id": client_id,
1800 "client_secret": client_secret,
1801 "client_name": req.client_name,
1802 "redirect_uris": req.redirect_uris,
1803 "token_endpoint_auth_method": req.token_endpoint_auth_method.as_deref().unwrap_or("client_secret_basic"),
1804 "grant_types": req.grant_types.as_deref().unwrap_or(&["authorization_code".to_string()]),
1805 "response_types": req.response_types.as_deref().unwrap_or(&["code".to_string()]),
1806 "scope": req.scope.as_deref().unwrap_or("openid"),
1807 })),
1808 )
1809 .into_response()
1810}
1811
1812pub async fn users_me(state: State<ApiState>, headers: HeaderMap) -> impl IntoResponse {
1826 userinfo(state, headers).await
1828}