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(Debug, Deserialize)]
148pub struct RevokeRequest {
149 pub token: String,
150 #[serde(default)]
151 pub token_type_hint: Option<String>, }
153
154#[derive(Debug, Serialize)]
173pub struct UserInfoResponse {
174 pub sub: String,
175 #[serde(skip_serializing_if = "Option::is_none")]
176 pub name: Option<String>,
177 #[serde(skip_serializing_if = "Option::is_none")]
178 pub email: Option<String>,
179 #[serde(skip_serializing_if = "Option::is_none")]
180 pub picture: Option<String>,
181 #[serde(skip_serializing_if = "Option::is_none")]
182 pub updated_at: Option<i64>,
183}
184
185pub async fn authorize(
194 State(state): State<ApiState>,
195 headers: HeaderMap,
196 Query(params): Query<AuthorizationRequest>,
197) -> impl IntoResponse {
198 if params.response_type != "code" {
199 let error = OAuthError::new("unsupported_response_type")
200 .description("Only 'code' response type is supported")
201 .maybe_state(params.state);
202 return (StatusCode::BAD_REQUEST, Json(error)).into_response();
203 }
204
205 if params.client_id.is_empty() {
206 let error = OAuthError::new("invalid_request")
207 .description("client_id is required")
208 .maybe_state(params.state);
209 return (StatusCode::BAD_REQUEST, Json(error)).into_response();
210 }
211
212 if params.redirect_uri.is_empty() {
213 let error = OAuthError::new("invalid_request")
214 .description("redirect_uri is required")
215 .maybe_state(params.state);
216 return (StatusCode::BAD_REQUEST, Json(error)).into_response();
217 }
218
219 let user_id = {
223 let token_str = match extract_bearer_token(&headers) {
224 Some(t) => t,
225 None => {
226 let error = OAuthError::new("unauthorized_client")
227 .description(
228 "User authentication required: supply your access token as \
229 'Authorization: Bearer <token>'",
230 )
231 .maybe_state(params.state);
232 return (StatusCode::UNAUTHORIZED, Json(error)).into_response();
233 }
234 };
235 match validate_api_token(&state.auth_framework, &token_str).await {
236 Ok(auth_token) => auth_token.user_id,
237 Err(_) => {
238 let error = OAuthError::new("unauthorized_client")
239 .description("Invalid or expired user access token")
240 .maybe_state(params.state);
241 return (StatusCode::UNAUTHORIZED, Json(error)).into_response();
242 }
243 }
244 };
245
246 let client_key = format!("oauth2_client:{}", params.client_id);
249 match state.auth_framework.storage().get_kv(&client_key).await {
250 Ok(Some(data)) => {
251 let client_data: serde_json::Value = serde_json::from_slice(&data).unwrap_or_default();
252 let registered_uris: Vec<String> = client_data["redirect_uris"]
253 .as_array()
254 .map(|arr| {
255 arr.iter()
256 .filter_map(|v| v.as_str().map(String::from))
257 .collect()
258 })
259 .unwrap_or_default();
260
261 if !registered_uris
262 .iter()
263 .any(|r| redirect_uri_matches(¶ms.redirect_uri, r))
264 {
265 tracing::warn!(
266 client_id = %params.client_id,
267 redirect_uri = %params.redirect_uri,
268 "OAuth authorize: redirect_uri not registered for client"
269 );
270 let error = OAuthError::new("invalid_request")
271 .description("redirect_uri is not registered for this client")
272 .maybe_state(params.state);
273 return (StatusCode::BAD_REQUEST, Json(error)).into_response();
274 }
275
276 let is_public_client = client_data
278 .get("client_secret")
279 .and_then(|v| v.as_str())
280 .is_none_or(|s| s.is_empty());
281 if is_public_client && params.code_challenge.is_none() {
282 let error = OAuthError::new("invalid_request")
283 .description("Public clients must use PKCE: code_challenge is required")
284 .maybe_state(params.state);
285 return (StatusCode::BAD_REQUEST, Json(error)).into_response();
286 }
287 }
288 Ok(None) => {
289 tracing::warn!(client_id = %params.client_id, "OAuth authorize: unknown client_id");
290 let error = OAuthError::new("invalid_client")
291 .description("Unknown client_id")
292 .maybe_state(params.state);
293 return (StatusCode::BAD_REQUEST, Json(error)).into_response();
294 }
295 Err(e) => {
296 tracing::error!(
297 client_id = %params.client_id,
298 error = %e,
299 "OAuth authorize: storage error looking up client"
300 );
301 let error = OAuthError::new("server_error")
302 .description("Authorization server error")
303 .maybe_state(params.state);
304 return (StatusCode::INTERNAL_SERVER_ERROR, Json(error)).into_response();
305 }
306 }
307
308 let auth_code = format!("ac_{}", uuid::Uuid::new_v4().to_string().replace("-", ""));
309
310 if let Some(ref resources) = params.resource
312 && let Err(e) =
313 crate::server::oauth::resource_indicators::validate_resource_indicators(resources)
314 {
315 let error = OAuthError::new("invalid_target")
316 .description(e.to_string())
317 .maybe_state(params.state);
318 return (StatusCode::BAD_REQUEST, Json(error)).into_response();
319 }
320
321 let code_data = serde_json::json!({
322 "client_id": params.client_id,
323 "redirect_uri": params.redirect_uri,
324 "scope": params.scope.clone().unwrap_or_else(|| "openid profile email".to_string()),
325 "state": params.state.clone(),
326 "code_challenge": params.code_challenge,
327 "code_challenge_method": params.code_challenge_method,
328 "user_id": user_id,
329 "resource": params.resource,
330 "created_at": chrono::Utc::now().to_rfc3339(),
331 "expires_at": (chrono::Utc::now() + chrono::Duration::minutes(10)).to_rfc3339(),
332 "used": false,
333 });
334
335 let storage_key = format!("oauth2_code:{}", auth_code);
336 let code_data_str = match serde_json::to_string(&code_data) {
337 Ok(s) => s,
338 Err(e) => {
339 tracing::error!("Failed to serialize OAuth authorization code data: {:?}", e);
340 let error =
341 OAuthError::new("server_error").description("Authorization server internal error");
342 return (StatusCode::INTERNAL_SERVER_ERROR, Json(error)).into_response();
343 }
344 };
345
346 if let Err(e) = state
347 .auth_framework
348 .storage()
349 .store_kv(
350 &storage_key,
351 code_data_str.as_bytes(),
352 Some(std::time::Duration::from_secs(600)),
353 )
354 .await
355 {
356 tracing::error!("Failed to store OAuth authorization code: {:?}", e);
357 let error = OAuthError::new("server_error")
358 .description("Authorization server error")
359 .maybe_state(params.state);
360 return (StatusCode::INTERNAL_SERVER_ERROR, Json(error)).into_response();
361 }
362
363 let encoded_state: Option<String> = params.state.as_deref().map(|st| {
366 st.bytes()
367 .flat_map(|b| {
368 if b.is_ascii_alphanumeric() || matches!(b, b'-' | b'_' | b'.' | b'~') {
369 vec![b as char]
370 } else {
371 format!("%{:02X}", b).chars().collect()
372 }
373 })
374 .collect()
375 });
376
377 let mut redirect_url = params.redirect_uri;
378 redirect_url.push_str(&format!("?code={}", auth_code));
379 if let Some(ref st) = encoded_state {
380 redirect_url.push_str(&format!("&state={}", st));
381 }
382
383 tracing::info!(
384 client_id = %params.client_id,
385 user_id = %user_id,
386 "OAuth authorization code issued"
387 );
388 Redirect::to(&redirect_url).into_response()
389}
390
391pub async fn token(
405 State(state): State<ApiState>,
406 Json(req): Json<TokenRequest>,
407) -> ApiResponse<TokenResponse> {
408 match req.grant_type.as_str() {
409 "authorization_code" => handle_authorization_code_grant(state, req).await,
410 "refresh_token" => handle_refresh_token_grant(state, req).await,
411 _ => ApiResponse::error_typed(
412 "unsupported_grant_type",
413 "Supported grant types: authorization_code, refresh_token",
414 ),
415 }
416}
417
418async fn handle_authorization_code_grant(
419 state: ApiState,
420 req: TokenRequest,
421) -> ApiResponse<TokenResponse> {
422 let code = match req.code {
423 Some(c) => c,
424 None => {
425 return ApiResponse::validation_error_typed(
426 "code is required for authorization_code grant",
427 );
428 }
429 };
430
431 let client_id = match req.client_id {
432 Some(c) => c,
433 None => return ApiResponse::validation_error_typed("client_id is required"),
434 };
435
436 let consumed_key = format!("oauth2_code_consumed:{}", code);
440 if let Ok(Some(_)) = state.auth_framework.storage().get_kv(&consumed_key).await {
441 return ApiResponse::error_typed("invalid_grant", "Authorization code already used");
442 }
443 if let Err(e) = state
445 .auth_framework
446 .storage()
447 .store_kv(
448 &consumed_key,
449 b"1",
450 Some(std::time::Duration::from_secs(600)),
451 )
452 .await
453 {
454 tracing::warn!("Failed to store code consumed marker: {:?}", e);
455 }
456
457 let storage_key = format!("oauth2_code:{}", code);
458 let code_data = match state.auth_framework.storage().get_kv(&storage_key).await {
459 Ok(Some(data)) => match serde_json::from_slice::<serde_json::Value>(&data) {
460 Ok(json) => json,
461 Err(e) => {
462 tracing::error!("Failed to parse stored authorization code data: {:?}", e);
463 return ApiResponse::error_typed("invalid_grant", "Invalid authorization code");
464 }
465 },
466 Ok(None) => {
467 return ApiResponse::error_typed(
468 "invalid_grant",
469 "Authorization code not found or expired",
470 );
471 }
472 Err(e) => {
473 tracing::error!("Failed to retrieve authorization code: {:?}", e);
474 return ApiResponse::error_typed(
475 "server_error",
476 "Failed to validate authorization code",
477 );
478 }
479 };
480
481 if let Err(e) = state.auth_framework.storage().delete_kv(&storage_key).await {
483 tracing::error!("Failed to delete authorization code from storage: {:?}", e);
484 return ApiResponse::error_typed("server_error", "Failed to process authorization code");
485 }
486
487 if code_data["client_id"].as_str() != Some(&client_id) {
489 return ApiResponse::error_typed("invalid_grant", "client_id mismatch");
490 }
491
492 if let Some(redirect_uri) = &req.redirect_uri {
494 let stored_uri = code_data["redirect_uri"].as_str().unwrap_or_default();
495 if !redirect_uri_matches(redirect_uri, stored_uri) {
496 return ApiResponse::error_typed("invalid_grant", "redirect_uri mismatch");
497 }
498 }
499
500 let stored_challenge = code_data["code_challenge"].as_str();
502 let challenge_method = code_data["code_challenge_method"]
503 .as_str()
504 .unwrap_or("plain");
505
506 if let Some(stored) = stored_challenge {
507 let code_verifier = match &req.code_verifier {
509 Some(verifier) => verifier,
510 None => {
511 return ApiResponse::error_typed(
512 "invalid_request",
513 "code_verifier is required when PKCE challenge was provided",
514 );
515 }
516 };
517
518 let computed_challenge = match challenge_method {
519 "S256" => {
520 let mut hasher = Sha256::new();
521 hasher.update(code_verifier.as_bytes());
522 URL_SAFE_NO_PAD.encode(hasher.finalize())
523 }
524 "plain" => code_verifier.clone(),
525 _ => {
526 return ApiResponse::error_typed(
527 "invalid_request",
528 "Unsupported code_challenge_method",
529 );
530 }
531 };
532
533 if computed_challenge != stored {
534 return ApiResponse::error_typed("invalid_grant", "PKCE verification failed");
535 }
536 } else if req.code_verifier.is_some() {
537 return ApiResponse::error_typed(
539 "invalid_request",
540 "code_verifier provided but no PKCE challenge was used in authorization",
541 );
542 } else if req.client_secret.is_none() {
543 return ApiResponse::error_typed(
547 "invalid_request",
548 "Public clients must use PKCE: provide code_challenge in authorization and code_verifier in token request",
549 );
550 }
551
552 let authz_resources: Vec<String> = code_data["resource"]
557 .as_array()
558 .map(|arr| {
559 arr.iter()
560 .filter_map(|v| v.as_str().map(String::from))
561 .collect()
562 })
563 .unwrap_or_default();
564
565 if let Some(ref token_resources) = req.resource {
566 if let Err(e) =
567 crate::server::oauth::resource_indicators::validate_resource_indicators(token_resources)
568 {
569 return ApiResponse::error_typed("invalid_target", e.to_string());
570 }
571 if let Err(e) = crate::server::oauth::resource_indicators::validate_token_resource_subset(
572 token_resources,
573 &authz_resources,
574 ) {
575 return ApiResponse::error_typed("invalid_target", e.to_string());
576 }
577 }
578
579 let scope = code_data["scope"]
581 .as_str()
582 .unwrap_or("openid profile email");
583 let scopes: Vec<String> = scope.split_whitespace().map(|s| s.to_string()).collect();
584
585 let user_id = match code_data["user_id"].as_str() {
589 Some(uid) if !uid.is_empty() => uid.to_string(),
590 _ => {
591 tracing::error!("Authorization code missing user_id field");
592 return ApiResponse::error_typed("server_error", "Malformed authorization code");
593 }
594 };
595
596 let token = match state.auth_framework.token_manager().create_auth_token(
597 &user_id,
598 scopes.clone(),
599 "oauth2",
600 None,
601 ) {
602 Ok(token) => token,
603 Err(e) => {
604 tracing::error!("Failed to create access token: {:?}", e);
605 return ApiResponse::error_typed("server_error", "Failed to create access token");
606 }
607 };
608
609 let refresh_token_value = uuid::Uuid::new_v4().to_string().replace("-", "");
611 let refresh_data = serde_json::json!({
612 "user_id": user_id,
613 "client_id": client_id,
614 "scopes": scope,
615 });
616 let refresh_key = format!("oauth2_refresh_token:{}", refresh_token_value);
617 if let Err(e) = state
618 .auth_framework
619 .storage()
620 .store_kv(
621 &refresh_key,
622 serde_json::to_string(&refresh_data)
623 .unwrap_or_default()
624 .as_bytes(),
625 Some(std::time::Duration::from_secs(30 * 24 * 3600)),
626 )
627 .await
628 {
629 tracing::warn!("Failed to store refresh token: {:?}", e);
630 }
631
632 let expires_in = (token.expires_at - token.issued_at).num_seconds().max(0) as u64;
633 let response = TokenResponse {
634 access_token: token.access_token,
635 token_type: "Bearer".to_string(),
636 expires_in,
637 refresh_token: Some(refresh_token_value),
638 scope: Some(scope.to_string()),
639 id_token: None,
640 };
641
642 tracing::info!("OAuth2 tokens issued for client: {}", client_id);
643 ApiResponse::success(response)
644}
645
646fn refusal(code: &str, message: &str) -> Box<ApiResponse<TokenResponse>> {
648 Box::new(ApiResponse::error_typed(code, message))
649}
650
651async fn load_client_record(
653 state: &ApiState,
654 client_id: &str,
655) -> std::result::Result<Option<serde_json::Value>, Box<ApiResponse<TokenResponse>>> {
656 let key = format!("oauth2_client:{client_id}");
657 match state.auth_framework.storage().get_kv(&key).await {
658 Ok(Some(data)) => serde_json::from_slice(&data).map(Some).map_err(|e| {
659 tracing::error!("Unreadable client record for {client_id}: {e}");
660 refusal("server_error", "Failed to validate client")
661 }),
662 Ok(None) => Ok(None),
663 Err(e) => {
664 tracing::error!("Failed to load client {client_id}: {e:?}");
665 Err(refusal("server_error", "Failed to validate client"))
666 }
667 }
668}
669
670fn client_secret_of(record: &serde_json::Value) -> Option<&str> {
672 record["client_secret"].as_str().filter(|s| !s.is_empty())
673}
674
675async fn authorize_refresh_client(
688 state: &ApiState,
689 stored_client: &str,
690 presented_id: Option<&str>,
691 presented_secret: Option<&str>,
692) -> std::result::Result<(), Box<ApiResponse<TokenResponse>>> {
693 let not_issued_to_you = || {
694 refusal(
695 "invalid_grant",
696 "Refresh token was not issued to this client",
697 )
698 };
699
700 let Some(stored_record) = load_client_record(state, stored_client).await? else {
701 return Err(refusal(
702 "invalid_grant",
703 "Refresh token was issued to a client that is no longer registered",
704 ));
705 };
706
707 if client_secret_of(&stored_record).is_none() {
708 return match presented_id {
710 Some(id) if id == stored_client => Ok(()),
711 _ => Err(not_issued_to_you()),
712 };
713 }
714
715 let (Some(presented_id), Some(presented_secret)) = (presented_id, presented_secret) else {
717 return Err(refusal(
718 "invalid_client",
719 "Client authentication is required",
720 ));
721 };
722 let presented_record = if presented_id == stored_client {
723 Some(stored_record)
724 } else {
725 load_client_record(state, presented_id).await?
726 };
727 let authenticated = presented_record
728 .as_ref()
729 .and_then(client_secret_of)
730 .is_some_and(|secret| {
731 crate::security::timing_protection::constant_time_string_compare(
732 presented_secret,
733 secret,
734 )
735 });
736 if !authenticated {
737 return Err(refusal("invalid_client", "Client authentication failed"));
738 }
739 if presented_id != stored_client {
740 return Err(not_issued_to_you());
741 }
742 Ok(())
743}
744
745async fn handle_refresh_token_grant(
746 state: ApiState,
747 req: TokenRequest,
748) -> ApiResponse<TokenResponse> {
749 let refresh_token_str = match req.refresh_token {
750 Some(t) => t,
751 None => return ApiResponse::validation_error_typed("refresh_token is required"),
752 };
753
754 let revoked_key = format!("oauth2_revoked_token:{}", refresh_token_str);
760 match state.auth_framework.storage().get_kv(&revoked_key).await {
761 Ok(Some(_)) => {
762 return ApiResponse::error_typed("invalid_grant", "Refresh token has been revoked");
763 }
764 Ok(None) => {} Err(e) => {
766 tracing::error!("Refresh token revocation check failed: {:?}", e);
767 return ApiResponse::error_typed("server_error", "Failed to validate refresh token");
768 }
769 }
770
771 let consumed_key = format!("oauth2_refresh_consumed:{}", refresh_token_str);
774 if let Ok(Some(_)) = state.auth_framework.storage().get_kv(&consumed_key).await {
775 return ApiResponse::error_typed("invalid_grant", "Refresh token already consumed");
776 }
777 if let Err(e) = state
778 .auth_framework
779 .storage()
780 .store_kv(
781 &consumed_key,
782 b"1",
783 Some(std::time::Duration::from_secs(600)),
784 )
785 .await
786 {
787 tracing::warn!("Failed to store refresh consumed marker: {:?}", e);
788 }
789
790 let refresh_key = format!("oauth2_refresh_token:{}", refresh_token_str);
792 let stored = match state.auth_framework.storage().get_kv(&refresh_key).await {
793 Ok(Some(data)) => match serde_json::from_slice::<serde_json::Value>(&data) {
794 Ok(v) => v,
795 Err(_) => return ApiResponse::error_typed("invalid_grant", "Invalid refresh token"),
796 },
797 Ok(None) => {
798 return ApiResponse::error_typed("invalid_grant", "Refresh token not found or expired");
799 }
800 Err(e) => {
801 tracing::error!("Failed to retrieve refresh token: {:?}", e);
802 return ApiResponse::error_typed("server_error", "Failed to validate refresh token");
803 }
804 };
805
806 let user_id = match stored["user_id"].as_str() {
807 Some(u) => u.to_string(),
808 None => return ApiResponse::error_typed("invalid_grant", "Malformed refresh token data"),
809 };
810 let client_id = match &stored["client_id"] {
811 serde_json::Value::Null => None,
812 serde_json::Value::String(s) => Some(s.clone()),
813 _ => return ApiResponse::error_typed("invalid_grant", "Malformed refresh token data"),
816 };
817
818 if let Some(stored_client) = client_id.as_deref()
822 && let Err(refusal) = authorize_refresh_client(
823 &state,
824 stored_client,
825 req.client_id.as_deref(),
826 req.client_secret.as_deref(),
827 )
828 .await
829 {
830 if let Err(e) = state
831 .auth_framework
832 .storage()
833 .delete_kv(&consumed_key)
834 .await
835 {
836 tracing::warn!("Failed to release refresh consumed marker: {:?}", e);
837 }
838 return *refusal;
839 }
840
841 let scope = stored["scopes"]
842 .as_str()
843 .unwrap_or("openid profile email")
844 .to_string();
845 let scopes: Vec<String> = scope.split_whitespace().map(|s| s.to_string()).collect();
846
847 let token = match state
848 .auth_framework
849 .token_manager()
850 .create_auth_token(&user_id, scopes, "oauth2", None)
851 {
852 Ok(t) => t,
853 Err(e) => {
854 tracing::error!("Failed to create access token on refresh: {:?}", e);
855 return ApiResponse::error_typed("server_error", "Failed to issue access token");
856 }
857 };
858
859 let new_refresh_token = uuid::Uuid::new_v4().to_string().replace("-", "");
862 let new_refresh_data = serde_json::json!({
863 "user_id": user_id,
864 "client_id": client_id,
865 "scopes": scope,
866 });
867 let new_refresh_key = format!("oauth2_refresh_token:{}", new_refresh_token);
868 if let Err(e) = state
869 .auth_framework
870 .storage()
871 .store_kv(
872 &new_refresh_key,
873 serde_json::to_string(&new_refresh_data)
874 .unwrap_or_default()
875 .as_bytes(),
876 Some(std::time::Duration::from_secs(30 * 24 * 3600)),
877 )
878 .await
879 {
880 tracing::error!("Failed to store new refresh token: {:?}", e);
881 return ApiResponse::error_typed("server_error", "Failed to issue refresh token");
882 }
883
884 if let Err(e) = state.auth_framework.storage().delete_kv(&refresh_key).await {
886 tracing::warn!(
887 "Failed to delete old refresh token during rotation: {:?}",
888 e
889 );
890 }
891
892 let expires_in = (token.expires_at - token.issued_at).num_seconds().max(0) as u64;
893 let response = TokenResponse {
894 access_token: token.access_token,
895 token_type: "Bearer".to_string(),
896 expires_in,
897 refresh_token: Some(new_refresh_token),
898 scope: Some(scope),
899 id_token: None,
900 };
901
902 tracing::info!("OAuth2 token refreshed for user: {}", user_id);
903 ApiResponse::success(response)
904}
905
906pub async fn revoke(
929 State(state): State<ApiState>,
930 Json(req): Json<RevokeRequest>,
931) -> ApiResponse<serde_json::Value> {
932 let revoked_token_key = format!("oauth2_revoked_token:{}", req.token);
935 let revoked_data = serde_json::json!({
936 "token": req.token,
937 "revoked_at": chrono::Utc::now().to_rfc3339(),
938 "token_type_hint": req.token_type_hint
939 });
940
941 if let Err(e) = state
942 .auth_framework
943 .storage()
944 .store_kv(
945 &revoked_token_key,
946 serde_json::to_string(&revoked_data)
947 .unwrap_or_default()
948 .as_bytes(),
949 Some(std::time::Duration::from_secs(86400 * 30)),
955 )
956 .await
957 {
958 tracing::error!("Failed to store revoked token: {:?}", e);
959 return ApiResponse::error_typed("server_error", "Failed to revoke token");
960 }
961
962 let refresh_key = format!("oauth2_refresh_token:{}", req.token);
967 if let Err(e) = state.auth_framework.storage().delete_kv(&refresh_key).await {
968 tracing::warn!("Failed to delete refresh token on revoke: {:?}", e);
969 }
970
971 if let Ok(claims) = state
976 .auth_framework
977 .token_manager()
978 .validate_jwt_token(&req.token)
979 {
980 let now = chrono::Utc::now().timestamp();
981 let remaining_secs = (claims.exp - now + 60).max(60) as u64;
982 let jti_key = format!("revoked_token:{}", claims.jti);
983 if let Err(e) = state
984 .auth_framework
985 .storage()
986 .store_kv(
987 &jti_key,
988 b"1",
989 Some(std::time::Duration::from_secs(remaining_secs)),
990 )
991 .await
992 {
993 tracing::warn!("Failed to store JWT JTI revocation entry: {:?}", e);
994 } else {
995 tracing::info!("JWT token revoked via jti: {}", claims.jti);
996 }
997 }
998
999 tracing::info!(
1000 "OAuth2 token revoked: {}",
1001 &req.token[..10.min(req.token.len())]
1002 );
1003
1004 ApiResponse::success(serde_json::json!({
1005 "message": "Token revoked successfully"
1006 }))
1007}
1008
1009pub async fn userinfo(
1022 State(state): State<ApiState>,
1023 headers: HeaderMap,
1024) -> ApiResponse<UserInfoResponse> {
1025 let token = match extract_bearer_token(&headers) {
1027 Some(t) => t,
1028 None => {
1029 return ApiResponse::error_typed("invalid_token", "Authorization header required");
1030 }
1031 };
1032
1033 let revoked_token_key = format!("oauth2_revoked_token:{}", token);
1035 if let Ok(Some(_)) = state
1036 .auth_framework
1037 .storage()
1038 .get_kv(&revoked_token_key)
1039 .await
1040 {
1041 return ApiResponse::error_typed("invalid_token", "Token has been revoked");
1042 }
1043
1044 let claims = match state
1046 .auth_framework
1047 .token_manager()
1048 .validate_jwt_token(&token)
1049 {
1050 Ok(c) => c,
1051 Err(_) => {
1052 return ApiResponse::error_typed("invalid_token", "Access token is invalid");
1053 }
1054 };
1055
1056 let user_profile = match state.auth_framework.get_user_profile(&claims.sub).await {
1058 Ok(profile) => profile,
1059 Err(e) => {
1060 tracing::error!("Failed to get user profile: {:?}", e);
1061 return ApiResponse::error_typed("server_error", "Failed to retrieve user information");
1062 }
1063 };
1064
1065 let userinfo = UserInfoResponse {
1066 sub: claims.sub.clone(),
1067 name: user_profile.username.clone(),
1068 email: if claims.scope.split_whitespace().any(|s| s == "email") {
1070 user_profile.email.clone()
1071 } else {
1072 None
1073 },
1074 picture: user_profile.picture.clone(),
1075 updated_at: Some(chrono::Utc::now().timestamp()),
1076 };
1077
1078 tracing::info!("OAuth2 UserInfo requested for user: {}", claims.sub);
1079 ApiResponse::success(userinfo)
1080}
1081
1082pub async fn get_client_info(
1090 State(state): State<ApiState>,
1091 Path(client_id): Path<String>,
1092) -> impl IntoResponse {
1093 let client_key = format!("oauth2_client:{}", client_id);
1094 match state.auth_framework.storage().get_kv(&client_key).await {
1095 Ok(Some(data)) => match serde_json::from_slice::<ClientInfo>(&data) {
1096 Ok(client) => (
1097 StatusCode::OK,
1098 Json(serde_json::json!({ "success": true, "data": client })),
1099 )
1100 .into_response(),
1101 Err(e) => {
1102 tracing::error!(client_id = %client_id, error = %e, "Failed to deserialize client record");
1103 (
1104 StatusCode::INTERNAL_SERVER_ERROR,
1105 Json(serde_json::json!({
1106 "success": false,
1107 "error": "server_error",
1108 "message": "Failed to read client record"
1109 })),
1110 )
1111 .into_response()
1112 }
1113 },
1114 Ok(None) => (
1115 StatusCode::NOT_FOUND,
1116 Json(serde_json::json!({
1117 "success": false,
1118 "error": "invalid_client",
1119 "message": "Unknown client_id"
1120 })),
1121 )
1122 .into_response(),
1123 Err(e) => {
1124 tracing::error!(client_id = %client_id, error = %e, "Storage error looking up client");
1125 (
1126 StatusCode::INTERNAL_SERVER_ERROR,
1127 Json(serde_json::json!({
1128 "success": false,
1129 "error": "server_error",
1130 "message": "Authorization server error"
1131 })),
1132 )
1133 .into_response()
1134 }
1135 }
1136}
1137
1138pub async fn openid_configuration(State(state): State<ApiState>) -> impl IntoResponse {
1154 let issuer = {
1155 let configured = state.auth_framework.config().issuer.clone();
1156 if configured.is_empty() {
1157 "https://auth.example.com".to_string()
1158 } else {
1159 configured
1160 }
1161 };
1162
1163 let config = serde_json::json!({
1164 "issuer": issuer,
1165 "authorization_endpoint": format!("{}/api/v1/oauth/authorize", issuer),
1166 "token_endpoint": format!("{}/api/v1/oauth/token", issuer),
1167 "userinfo_endpoint": format!("{}/api/v1/oauth/userinfo", issuer),
1168 "revocation_endpoint": format!("{}/api/v1/oauth/revoke", issuer),
1169 "introspection_endpoint": format!("{}/api/v1/oauth/introspect", issuer),
1170 "jwks_uri": format!("{}/api/v1/.well-known/jwks.json", issuer),
1171 "end_session_endpoint": format!("{}/api/v1/oauth/end_session", issuer),
1172 "pushed_authorization_request_endpoint": format!("{}/api/v1/oauth/par", issuer),
1173 "registration_endpoint": format!("{}/api/v1/oauth/register", issuer),
1174 "response_types_supported": ["code"],
1175 "grant_types_supported": [
1176 "authorization_code",
1177 "refresh_token"
1178 ],
1179 "subject_types_supported": ["public"],
1180 "id_token_signing_alg_values_supported": ["HS256"],
1181 "token_endpoint_auth_methods_supported": [
1182 "client_secret_basic",
1183 "client_secret_post"
1184 ],
1185 "code_challenge_methods_supported": ["S256"],
1186 "scopes_supported": ["openid", "profile", "email"]
1187 });
1188
1189 (StatusCode::OK, Json(config))
1190}
1191
1192pub async fn jwks(State(_state): State<ApiState>) -> impl IntoResponse {
1209 (StatusCode::OK, Json(serde_json::json!({ "keys": [] })))
1210}
1211
1212#[derive(Debug, Deserialize)]
1228pub struct EndSessionRequest {
1229 pub id_token_hint: Option<String>,
1230 pub post_logout_redirect_uri: Option<String>,
1231 pub state: Option<String>,
1232}
1233
1234pub async fn end_session(
1246 State(state): State<ApiState>,
1247 Query(params): Query<EndSessionRequest>,
1248) -> impl IntoResponse {
1249 if let Some(ref token) = params.id_token_hint
1251 && let Ok(claims) = state
1252 .auth_framework
1253 .token_manager()
1254 .validate_jwt_token(token)
1255 {
1256 let revoked_key = format!("oauth2_revoked_token:{}", token);
1257 if let Err(e) = state
1258 .auth_framework
1259 .storage()
1260 .store_kv(
1261 &revoked_key,
1262 b"revoked",
1263 Some(std::time::Duration::from_secs(86400 * 7)),
1264 )
1265 .await
1266 {
1267 tracing::warn!("Failed to revoke token during OIDC end_session: {}", e);
1268 }
1269 tracing::info!("OIDC end_session: revoked token for user {}", claims.sub);
1270 }
1271
1272 if let Some(ref redirect_uri) = params.post_logout_redirect_uri {
1276 let allowed = if let Some(ref token) = params.id_token_hint {
1278 let client_id = state
1280 .auth_framework
1281 .token_manager()
1282 .validate_jwt_token(token)
1283 .ok()
1284 .and_then(|claims| {
1285 if let Some(ref cid) = claims.client_id
1287 && !cid.is_empty()
1288 {
1289 return Some(cid.clone());
1290 }
1291 if !claims.aud.is_empty() {
1293 Some(claims.aud.clone())
1294 } else {
1295 None
1296 }
1297 });
1298 if let Some(cid) = client_id {
1299 let client_key = format!("oauth2_client:{}", cid);
1300 match state.auth_framework.storage().get_kv(&client_key).await {
1301 Ok(Some(data)) => {
1302 let client: serde_json::Value =
1303 serde_json::from_slice(&data).unwrap_or_default();
1304 let uris: Vec<String> = client["redirect_uris"]
1305 .as_array()
1306 .map(|a| {
1307 a.iter()
1308 .filter_map(|v| v.as_str().map(String::from))
1309 .collect()
1310 })
1311 .unwrap_or_default();
1312 uris.iter().any(|r| redirect_uri_matches(redirect_uri, r))
1313 }
1314 _ => false,
1315 }
1316 } else {
1317 false
1318 }
1319 } else {
1320 false
1321 };
1322
1323 if allowed {
1324 if let Ok(mut parsed) = Url::parse(redirect_uri) {
1325 if let Some(ref st) = params.state {
1326 parsed.query_pairs_mut().append_pair("state", st);
1327 }
1328 return Redirect::to(parsed.as_str()).into_response();
1329 }
1330 } else {
1331 tracing::warn!(
1332 "end_session: post_logout_redirect_uri rejected — not registered for the client"
1333 );
1334 }
1335 }
1336
1337 (
1339 StatusCode::OK,
1340 Json(serde_json::json!({ "status": "logged_out" })),
1341 )
1342 .into_response()
1343}
1344
1345#[derive(Debug, Deserialize)]
1361pub struct ClientRegistrationRequest {
1362 pub redirect_uris: Vec<String>,
1363 #[serde(default)]
1364 pub client_name: Option<String>,
1365 #[serde(default)]
1366 pub token_endpoint_auth_method: Option<String>,
1367 #[serde(default)]
1368 pub grant_types: Option<Vec<String>>,
1369 #[serde(default)]
1370 pub response_types: Option<Vec<String>>,
1371 #[serde(default)]
1372 pub scope: Option<String>,
1373}
1374
1375pub async fn register_client(
1395 State(state): State<ApiState>,
1396 headers: HeaderMap,
1397 Json(req): Json<ClientRegistrationRequest>,
1398) -> impl IntoResponse {
1399 let token_str = match extract_bearer_token(&headers) {
1401 Some(t) => t,
1402 None => {
1403 return (
1404 StatusCode::UNAUTHORIZED,
1405 Json(serde_json::json!({
1406 "error": "invalid_token",
1407 "error_description": "A valid Bearer token is required for dynamic client registration"
1408 })),
1409 )
1410 .into_response();
1411 }
1412 };
1413
1414 let is_initial_access_token = match state
1416 .auth_framework
1417 .storage()
1418 .get_kv("oauth2_initial_access_token")
1419 .await
1420 {
1421 Ok(Some(stored)) => {
1422 let stored_str = String::from_utf8_lossy(&stored);
1423 subtle::ConstantTimeEq::ct_eq(token_str.as_bytes(), stored_str.trim().as_bytes()).into()
1424 }
1425 _ => false,
1426 };
1427
1428 let is_admin = if !is_initial_access_token {
1430 match validate_api_token(&state.auth_framework, &token_str).await {
1431 Ok(auth_token) => auth_token.roles.contains("admin"),
1432 Err(_) => false,
1433 }
1434 } else {
1435 false
1436 };
1437
1438 if !is_initial_access_token && !is_admin {
1439 return (
1440 StatusCode::FORBIDDEN,
1441 Json(serde_json::json!({
1442 "error": "insufficient_scope",
1443 "error_description": "Dynamic client registration requires admin privileges or a valid Initial Access Token"
1444 })),
1445 )
1446 .into_response();
1447 }
1448 for uri in &req.redirect_uris {
1450 match Url::parse(uri) {
1451 Ok(parsed) => {
1452 match parsed.scheme() {
1453 "https" => {}
1454 "http" => {
1455 if !matches!(parsed.host_str(), Some("localhost" | "127.0.0.1" | "[::1]")) {
1457 return (
1458 StatusCode::BAD_REQUEST,
1459 Json(serde_json::json!({
1460 "error": "invalid_redirect_uri",
1461 "error_description": format!("Non-loopback HTTP redirect_uri not allowed: {}", uri)
1462 })),
1463 )
1464 .into_response();
1465 }
1466 }
1467 scheme => {
1468 return (
1469 StatusCode::BAD_REQUEST,
1470 Json(serde_json::json!({
1471 "error": "invalid_redirect_uri",
1472 "error_description": format!("Disallowed URI scheme '{}' in redirect_uri: {}", scheme, uri)
1473 })),
1474 )
1475 .into_response();
1476 }
1477 }
1478 }
1479 Err(_) => {
1480 return (
1481 StatusCode::BAD_REQUEST,
1482 Json(serde_json::json!({
1483 "error": "invalid_redirect_uri",
1484 "error_description": format!("Invalid redirect_uri: {}", uri)
1485 })),
1486 )
1487 .into_response();
1488 }
1489 }
1490 }
1491
1492 if req.redirect_uris.is_empty() {
1493 return (
1494 StatusCode::BAD_REQUEST,
1495 Json(serde_json::json!({
1496 "error": "invalid_client_metadata",
1497 "error_description": "At least one redirect_uri is required"
1498 })),
1499 )
1500 .into_response();
1501 }
1502
1503 let client_id = Uuid::new_v4().to_string();
1504 let client_secret = Uuid::new_v4().to_string();
1505
1506 let client_data = serde_json::json!({
1507 "client_id": client_id,
1508 "client_secret": client_secret,
1509 "client_name": req.client_name,
1510 "redirect_uris": req.redirect_uris,
1511 "token_endpoint_auth_method": req.token_endpoint_auth_method.as_deref().unwrap_or("client_secret_basic"),
1512 "grant_types": req.grant_types.as_deref().unwrap_or(&["authorization_code".to_string()]),
1513 "response_types": req.response_types.as_deref().unwrap_or(&["code".to_string()]),
1514 "scope": req.scope.as_deref().unwrap_or("openid"),
1515 });
1516
1517 let key = format!("oauth2_client:{}", client_id);
1518 if let Err(e) = state
1519 .auth_framework
1520 .storage()
1521 .store_kv(&key, client_data.to_string().as_bytes(), None)
1522 .await
1523 {
1524 tracing::error!("Failed to store client registration: {}", e);
1525 return (
1526 StatusCode::INTERNAL_SERVER_ERROR,
1527 Json(serde_json::json!({
1528 "error": "server_error",
1529 "error_description": "Failed to register client"
1530 })),
1531 )
1532 .into_response();
1533 }
1534
1535 tracing::info!("Dynamic client registered: client_id={}", client_id);
1536
1537 (
1538 StatusCode::CREATED,
1539 Json(serde_json::json!({
1540 "client_id": client_id,
1541 "client_secret": client_secret,
1542 "client_name": req.client_name,
1543 "redirect_uris": req.redirect_uris,
1544 "token_endpoint_auth_method": req.token_endpoint_auth_method.as_deref().unwrap_or("client_secret_basic"),
1545 "grant_types": req.grant_types.as_deref().unwrap_or(&["authorization_code".to_string()]),
1546 "response_types": req.response_types.as_deref().unwrap_or(&["code".to_string()]),
1547 "scope": req.scope.as_deref().unwrap_or("openid"),
1548 })),
1549 )
1550 .into_response()
1551}
1552
1553pub async fn users_me(state: State<ApiState>, headers: HeaderMap) -> impl IntoResponse {
1567 userinfo(state, headers).await
1569}