Skip to main content

auth_framework/server/oidc/
core.rs

1//! OpenID Connect Provider Implementation (OIDC 1.0)
2//!
3//! This module implements a complete OpenID Connect Provider based on:
4//! - OpenID Connect Core 1.0 specification
5//! - OpenID Connect Discovery 1.0
6//! - OpenID Connect Dynamic Client Registration 1.0
7//! - JSON Web Token (JWT) Profile for OAuth 2.0 Client Authentication and Authorization Grants
8
9use crate::errors::{AuthError, Result};
10use crate::oauth2_server::OAuth2Server;
11use crate::server::core::client_registry::ClientRegistry;
12use crate::storage::AuthStorage;
13use crate::tokens::TokenManager;
14use jsonwebtoken::{Algorithm, Header};
15use serde::{Deserialize, Serialize};
16use serde_json::Value;
17use std::collections::HashMap;
18use std::fmt;
19use std::sync::Arc;
20use std::time::{Duration, SystemTime, UNIX_EPOCH};
21
22/// OpenID Connect Provider configuration
23#[derive(Debug, Clone)]
24pub struct OidcConfig {
25    /// Issuer identifier (must be HTTPS URL)
26    pub issuer: String,
27
28    /// OAuth 2.0 base configuration
29    pub oauth2_config: crate::oauth2_server::OAuth2Config,
30
31    /// JWK Set URI
32    pub jwks_uri: String,
33
34    /// UserInfo endpoint URI
35    pub userinfo_endpoint: String,
36
37    /// Supported response types
38    pub response_types_supported: Vec<String>,
39
40    /// Supported subject identifier types
41    pub subject_types_supported: Vec<SubjectType>,
42
43    /// Supported ID token signing algorithms
44    pub id_token_signing_alg_values_supported: Vec<Algorithm>,
45
46    /// Supported scopes
47    pub scopes_supported: Vec<String>,
48
49    /// Supported claims
50    pub claims_supported: Vec<String>,
51
52    /// Whether claims parameter is supported
53    pub claims_parameter_supported: bool,
54
55    /// Whether request parameter is supported
56    pub request_parameter_supported: bool,
57
58    /// Whether request_uri parameter is supported
59    pub request_uri_parameter_supported: bool,
60
61    /// ID token expiration time
62    pub id_token_expiry: Duration,
63
64    /// Maximum age for authentication
65    pub max_age_supported: Option<Duration>,
66}
67
68impl Default for OidcConfig {
69    fn default() -> Self {
70        Self {
71            issuer: "https://auth.example.com".to_string(),
72            oauth2_config: crate::oauth2_server::OAuth2Config::default(),
73            jwks_uri: "https://auth.example.com/.well-known/jwks.json".to_string(),
74            userinfo_endpoint: "https://auth.example.com/oidc/userinfo".to_string(),
75            response_types_supported: vec![
76                "code".to_string(),
77                "id_token".to_string(),
78                "id_token token".to_string(),
79                "code id_token".to_string(),
80                "code token".to_string(),
81                "code id_token token".to_string(),
82            ],
83            subject_types_supported: vec![SubjectType::Public],
84            id_token_signing_alg_values_supported: vec![
85                Algorithm::RS256,
86                Algorithm::ES256,
87                Algorithm::HS256,
88            ],
89            scopes_supported: vec![
90                "openid".to_string(),
91                "profile".to_string(),
92                "email".to_string(),
93                "address".to_string(),
94                "phone".to_string(),
95                "offline_access".to_string(),
96            ],
97            claims_supported: vec![
98                "sub".to_string(),
99                "name".to_string(),
100                "given_name".to_string(),
101                "family_name".to_string(),
102                "middle_name".to_string(),
103                "nickname".to_string(),
104                "preferred_username".to_string(),
105                "profile".to_string(),
106                "picture".to_string(),
107                "website".to_string(),
108                "email".to_string(),
109                "email_verified".to_string(),
110                "gender".to_string(),
111                "birthdate".to_string(),
112                "zoneinfo".to_string(),
113                "locale".to_string(),
114                "phone_number".to_string(),
115                "phone_number_verified".to_string(),
116                "address".to_string(),
117                "updated_at".to_string(),
118            ],
119            claims_parameter_supported: true,
120            request_parameter_supported: true,
121            request_uri_parameter_supported: true,
122            id_token_expiry: Duration::from_secs(3600), // 1 hour
123            max_age_supported: Some(Duration::from_secs(86400)), // 24 hours
124        }
125    }
126}
127
128impl OidcConfig {
129    /// Create a new builder for `OidcConfig`, starting from defaults.
130    ///
131    /// # Example
132    ///
133    /// ```rust,no_run
134    /// use auth_framework::server::oidc::core::OidcConfig;
135    /// use std::time::Duration;
136    ///
137    /// let config = OidcConfig::builder()
138    ///     .issuer("https://id.example.com")
139    ///     .id_token_expiry(Duration::from_secs(1800))
140    ///     .build();
141    /// ```
142    pub fn builder() -> OidcConfigBuilder {
143        OidcConfigBuilder::default()
144    }
145}
146
147/// A builder for [`OidcConfig`].
148///
149/// Obtain via [`OidcConfig::builder()`]. All fields start with sensible
150/// defaults; override only what you need.
151#[derive(Debug, Clone, Default)]
152pub struct OidcConfigBuilder {
153    config: OidcConfig,
154}
155
156impl OidcConfigBuilder {
157    /// Set the issuer identifier (must be an HTTPS URL in production).
158    ///
159    /// # Example
160    /// ```rust,ignore
161    /// let config = OidcConfigBuilder::default()
162    ///     .issuer("https://auth.example.com")
163    ///     .build();
164    /// ```
165    pub fn issuer(mut self, issuer: impl Into<String>) -> Self {
166        self.config.issuer = issuer.into();
167        self
168    }
169
170    /// Set the underlying OAuth 2.0 configuration.
171    ///
172    /// # Example
173    /// ```rust,ignore
174    /// let config = OidcConfigBuilder::default()
175    ///     .oauth2_config(OAuth2Config::default())
176    ///     .build();
177    /// ```
178    pub fn oauth2_config(mut self, config: crate::oauth2_server::OAuth2Config) -> Self {
179        self.config.oauth2_config = config;
180        self
181    }
182
183    /// Set the JWK Set URI.
184    ///
185    /// # Example
186    /// ```rust,ignore
187    /// let config = OidcConfigBuilder::default()
188    ///     .jwks_uri("https://auth.example.com/.well-known/jwks.json")
189    ///     .build();
190    /// ```
191    pub fn jwks_uri(mut self, uri: impl Into<String>) -> Self {
192        self.config.jwks_uri = uri.into();
193        self
194    }
195
196    /// Set the UserInfo endpoint URI.
197    ///
198    /// # Example
199    /// ```rust,ignore
200    /// let config = OidcConfigBuilder::default()
201    ///     .userinfo_endpoint("https://auth.example.com/userinfo")
202    ///     .build();
203    /// ```
204    pub fn userinfo_endpoint(mut self, uri: impl Into<String>) -> Self {
205        self.config.userinfo_endpoint = uri.into();
206        self
207    }
208
209    /// Set the supported response types.
210    ///
211    /// # Example
212    /// ```rust,ignore
213    /// let config = OidcConfigBuilder::default()
214    ///     .response_types_supported(vec!["code".into(), "id_token".into()])
215    ///     .build();
216    /// ```
217    pub fn response_types_supported(mut self, types: Vec<String>) -> Self {
218        self.config.response_types_supported = types;
219        self
220    }
221
222    /// Set the supported subject identifier types.
223    ///
224    /// # Example
225    /// ```rust,ignore
226    /// let config = OidcConfigBuilder::default()
227    ///     .subject_types_supported(vec![SubjectType::Public])
228    ///     .build();
229    /// ```
230    pub fn subject_types_supported(mut self, types: Vec<SubjectType>) -> Self {
231        self.config.subject_types_supported = types;
232        self
233    }
234
235    /// Set the supported ID token signing algorithms.
236    ///
237    /// # Example
238    /// ```rust,ignore
239    /// let config = OidcConfigBuilder::default()
240    ///     .id_token_signing_alg_values_supported(vec![Algorithm::RS256])
241    ///     .build();
242    /// ```
243    pub fn id_token_signing_alg_values_supported(mut self, algs: Vec<Algorithm>) -> Self {
244        self.config.id_token_signing_alg_values_supported = algs;
245        self
246    }
247
248    /// Set the supported scopes.
249    ///
250    /// # Example
251    /// ```rust,ignore
252    /// let config = OidcConfigBuilder::default()
253    ///     .scopes_supported(vec!["openid".into(), "profile".into(), "email".into()])
254    ///     .build();
255    /// ```
256    pub fn scopes_supported(mut self, scopes: Vec<String>) -> Self {
257        self.config.scopes_supported = scopes;
258        self
259    }
260
261    /// Set the supported claims.
262    ///
263    /// # Example
264    /// ```rust,ignore
265    /// let config = OidcConfigBuilder::default()
266    ///     .claims_supported(vec!["sub".into(), "name".into(), "email".into()])
267    ///     .build();
268    /// ```
269    pub fn claims_supported(mut self, claims: Vec<String>) -> Self {
270        self.config.claims_supported = claims;
271        self
272    }
273
274    /// Set whether the claims parameter is supported.
275    ///
276    /// # Example
277    /// ```rust,ignore
278    /// let config = OidcConfigBuilder::default()
279    ///     .claims_parameter_supported(true)
280    ///     .build();
281    /// ```
282    pub fn claims_parameter_supported(mut self, supported: bool) -> Self {
283        self.config.claims_parameter_supported = supported;
284        self
285    }
286
287    /// Set whether the request parameter is supported.
288    ///
289    /// # Example
290    /// ```rust,ignore
291    /// let config = OidcConfigBuilder::default()
292    ///     .request_parameter_supported(true)
293    ///     .build();
294    /// ```
295    pub fn request_parameter_supported(mut self, supported: bool) -> Self {
296        self.config.request_parameter_supported = supported;
297        self
298    }
299
300    /// Set whether the request_uri parameter is supported.
301    ///
302    /// # Example
303    /// ```rust,ignore
304    /// let config = OidcConfigBuilder::default()
305    ///     .request_uri_parameter_supported(false)
306    ///     .build();
307    /// ```
308    pub fn request_uri_parameter_supported(mut self, supported: bool) -> Self {
309        self.config.request_uri_parameter_supported = supported;
310        self
311    }
312
313    /// Set the ID token expiration duration.
314    ///
315    /// # Example
316    /// ```rust,ignore
317    /// use std::time::Duration;
318    /// let config = OidcConfigBuilder::default()
319    ///     .id_token_expiry(Duration::from_secs(3600))
320    ///     .build();
321    /// ```
322    pub fn id_token_expiry(mut self, expiry: Duration) -> Self {
323        self.config.id_token_expiry = expiry;
324        self
325    }
326
327    /// Set the maximum age for authentication.
328    ///
329    /// # Example
330    /// ```rust,ignore
331    /// use std::time::Duration;
332    /// let config = OidcConfigBuilder::default()
333    ///     .max_age_supported(Duration::from_secs(86400))
334    ///     .build();
335    /// ```
336    pub fn max_age_supported(mut self, max_age: Duration) -> Self {
337        self.config.max_age_supported = Some(max_age);
338        self
339    }
340
341    /// Build the [`OidcConfig`].
342    ///
343    /// # Example
344    /// ```rust,ignore
345    /// let config = OidcConfigBuilder::default()
346    ///     .issuer("https://auth.example.com")
347    ///     .scopes_supported(vec!["openid".into(), "profile".into()])
348    ///     .id_token_expiry(Duration::from_secs(3600))
349    ///     .build();
350    /// ```
351    pub fn build(self) -> OidcConfig {
352        self.config
353    }
354}
355
356/// Subject identifier types
357#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
358#[serde(rename_all = "lowercase")]
359pub enum SubjectType {
360    /// Public subject identifier
361    Public,
362    /// Pairwise subject identifier
363    Pairwise,
364}
365
366/// OpenID Connect Provider
367pub struct OidcProvider<S: AuthStorage + ?Sized> {
368    config: OidcConfig,
369    oauth2_server: OAuth2Server,
370    token_manager: Arc<TokenManager>,
371    storage: Arc<S>,
372    client_registry: Option<Arc<ClientRegistry>>,
373}
374
375impl<S: AuthStorage + ?Sized> fmt::Debug for OidcProvider<S> {
376    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
377        f.debug_struct("OidcProvider")
378            .field("config", &self.config)
379            .field("oauth2_server", &"<OAuth2Server>")
380            .field("token_manager", &"<TokenManager>")
381            .field("storage", &"<AuthStorage>")
382            .field("client_registry", &self.client_registry.is_some())
383            .finish()
384    }
385}
386
387impl<S: ?Sized + AuthStorage> OidcProvider<S> {
388    /// Create a new OIDC Provider
389    pub async fn new(
390        config: OidcConfig,
391        token_manager: Arc<TokenManager>,
392        storage: Arc<S>,
393    ) -> Result<Self> {
394        let oauth2_server =
395            OAuth2Server::new(config.oauth2_config.clone(), token_manager.clone()).await?;
396
397        Ok(Self {
398            config,
399            oauth2_server,
400            token_manager,
401            storage,
402            client_registry: None,
403        })
404    }
405
406    /// Get the underlying OAuth 2.0 server
407    pub fn oauth2_server(&self) -> &OAuth2Server {
408        &self.oauth2_server
409    }
410
411    /// Set the client registry for validation
412    pub fn set_client_registry(&mut self, client_registry: Arc<ClientRegistry>) {
413        self.client_registry = Some(client_registry);
414    }
415
416    /// Get OIDC configuration
417    pub fn config(&self) -> &OidcConfig {
418        &self.config
419    }
420
421    /// Generate OpenID Connect Discovery document
422    pub fn discovery_document(&self) -> Result<OidcDiscoveryDocument> {
423        Ok(OidcDiscoveryDocument {
424            issuer: self.config.issuer.clone(),
425            authorization_endpoint: format!("{}/oidc/authorize", self.config.issuer),
426            token_endpoint: format!("{}/oidc/token", self.config.issuer),
427            userinfo_endpoint: self.config.userinfo_endpoint.clone(),
428            jwks_uri: self.config.jwks_uri.clone(),
429            registration_endpoint: Some(format!("{}/oidc/register", self.config.issuer)),
430            scopes_supported: self.config.scopes_supported.clone(),
431            response_types_supported: self.config.response_types_supported.clone(),
432            response_modes_supported: Some(vec![
433                "query".to_string(),
434                "fragment".to_string(),
435                "form_post".to_string(),
436            ]),
437            grant_types_supported: Some(vec![
438                "authorization_code".to_string(),
439                "refresh_token".to_string(),
440                "client_credentials".to_string(),
441            ]),
442            subject_types_supported: self.config.subject_types_supported.clone(),
443            id_token_signing_alg_values_supported: self
444                .config
445                .id_token_signing_alg_values_supported
446                .iter()
447                .map(algorithm_to_string)
448                .collect(),
449            userinfo_signing_alg_values_supported: Some(vec![
450                "RS256".to_string(),
451                "ES256".to_string(),
452                "HS256".to_string(),
453            ]),
454            token_endpoint_auth_methods_supported: Some(vec![
455                "client_secret_basic".to_string(),
456                "client_secret_post".to_string(),
457                "client_secret_jwt".to_string(),
458                "private_key_jwt".to_string(),
459            ]),
460            claims_supported: Some(self.config.claims_supported.clone()),
461            claims_parameter_supported: Some(self.config.claims_parameter_supported),
462            request_parameter_supported: Some(self.config.request_parameter_supported),
463            request_uri_parameter_supported: Some(self.config.request_uri_parameter_supported),
464            code_challenge_methods_supported: Some(vec!["S256".to_string()]),
465        })
466    }
467}
468
469/// Request parameters for creating an ID token.
470///
471/// Use [`IdTokenRequest::new`] to construct with the required `subject` and
472/// `client_id`, then chain optional setters for `nonce`, `auth_time`, and
473/// extra `claims`.
474///
475/// # Example
476///
477/// ```rust,no_run
478/// # use auth_framework::server::oidc::core::IdTokenRequest;
479/// let request = IdTokenRequest::new("user123", "client456")
480///     .with_nonce("abc");
481/// ```
482#[derive(Debug, Clone, Default)]
483pub struct IdTokenRequest<'a> {
484    pub subject: &'a str,
485    pub client_id: &'a str,
486    pub nonce: Option<&'a str>,
487    pub auth_time: Option<SystemTime>,
488    pub claims: Option<&'a HashMap<String, Value>>,
489}
490
491impl<'a> IdTokenRequest<'a> {
492    /// Create a new ID token request with required subject and client_id.
493    pub fn new(subject: &'a str, client_id: &'a str) -> Self {
494        Self {
495            subject,
496            client_id,
497            nonce: None,
498            auth_time: None,
499            claims: None,
500        }
501    }
502
503    /// Set the nonce value for replay protection.
504    pub fn with_nonce(mut self, nonce: &'a str) -> Self {
505        self.nonce = Some(nonce);
506        self
507    }
508
509    /// Set the authentication time.
510    pub fn with_auth_time(mut self, auth_time: SystemTime) -> Self {
511        self.auth_time = Some(auth_time);
512        self
513    }
514
515    /// Set additional claims to include in the ID token.
516    pub fn with_claims(mut self, claims: &'a HashMap<String, Value>) -> Self {
517        self.claims = Some(claims);
518        self
519    }
520}
521
522impl<S: AuthStorage + ?Sized> OidcProvider<S> {
523    /// Create an ID token from a request.
524    pub async fn create_id_token(&self, request: IdTokenRequest<'_>) -> Result<String> {
525        let subject = request.subject;
526        let client_id = request.client_id;
527        let nonce = request.nonce;
528        let auth_time = request.auth_time;
529        let claims = request.claims;
530        let now = SystemTime::now()
531            .duration_since(UNIX_EPOCH)
532            .map_err(|e| AuthError::auth_method("oidc", format!("Time error: {}", e)))?
533            .as_secs();
534
535        let exp = now + self.config.id_token_expiry.as_secs();
536
537        let mut id_token_claims = IdTokenClaims {
538            iss: self.config.issuer.clone(),
539            sub: subject.to_string(),
540            aud: vec![client_id.to_string()],
541            exp,
542            iat: now,
543            auth_time: auth_time
544                .and_then(|t| t.duration_since(UNIX_EPOCH).ok().map(|d| d.as_secs())),
545            nonce: nonce.map(|n| n.to_string()),
546            additional_claims: claims.cloned().unwrap_or_default(),
547        };
548
549        // Add standard claims if provided
550        if let Some(claims) = claims {
551            for (key, value) in claims {
552                if self.config.claims_supported.contains(key) {
553                    id_token_claims
554                        .additional_claims
555                        .insert(key.clone(), value.clone());
556                }
557            }
558        }
559
560        // Create JWT
561        let _header = Header::new(Algorithm::RS256);
562        let token = self
563            .token_manager
564            .create_typed_jwt_token(
565                subject,
566                vec!["openid".to_string()],
567                Some(Duration::from_secs(3600)),
568                "id_token",
569            )
570            .map_err(|e| AuthError::auth_method("oidc", format!("JWT creation failed: {}", e)))?;
571
572        Ok(token)
573    }
574
575    /// Validate an authorization request for OIDC
576    pub async fn validate_authorization_request(
577        &self,
578        request: &OidcAuthorizationRequest,
579    ) -> Result<AuthorizationValidationResult> {
580        // Check if 'openid' scope is present
581        if !request.scope.split_whitespace().any(|s| s == "openid") {
582            return Err(AuthError::auth_method(
583                "oidc",
584                "Missing required 'openid' scope",
585            ));
586        }
587
588        // SEC-H2: Require state parameter (CSRF protection per OAuth 2.0 §10.12)
589        match &request.state {
590            None => {
591                return Err(AuthError::auth_method(
592                    "oidc",
593                    "Missing required 'state' parameter",
594                ));
595            }
596            Some(s) if s.is_empty() => {
597                return Err(AuthError::auth_method(
598                    "oidc",
599                    "The 'state' parameter must not be empty",
600                ));
601            }
602            _ => {}
603        }
604
605        // Validate response_type
606        if !self
607            .config
608            .response_types_supported
609            .contains(&request.response_type)
610        {
611            return Err(AuthError::auth_method(
612                "oidc",
613                format!("Unsupported response_type: {}", request.response_type),
614            ));
615        }
616
617        // SEC-M8: Block implicit grant response types (OAuth 2.1 compliance).
618        // Response types containing "token" without "code" are implicit grants.
619        {
620            let rt = &request.response_type;
621            if rt.split_whitespace().any(|part| part == "token")
622                && !rt.split_whitespace().any(|part| part == "code")
623            {
624                return Err(AuthError::auth_method(
625                    "oidc",
626                    "Implicit grant (response_type containing 'token' without 'code') is not permitted",
627                ));
628            }
629        }
630
631        // Validate client_id
632        if request.client_id.is_empty() {
633            return Err(AuthError::auth_method("oidc", "Missing client_id"));
634        }
635
636        // Check client exists in registry and validate redirect_uri + scopes
637        if let Some(client_registry) = &self.client_registry {
638            if client_registry
639                .get_client(&request.client_id)
640                .await?
641                .is_none()
642            {
643                return Err(AuthError::auth_method("oidc", "Invalid client_id"));
644            }
645
646            // Validate redirect_uri against registered URIs
647            if !client_registry
648                .validate_redirect_uri(&request.client_id, &request.redirect_uri)
649                .await?
650            {
651                return Err(AuthError::auth_method(
652                    "oidc",
653                    "Invalid redirect_uri for client",
654                ));
655            }
656
657            // SEC-M4: Validate requested scopes against client's authorized scopes
658            for scope in request.scope.split_whitespace() {
659                if !client_registry
660                    .validate_scope(&request.client_id, scope)
661                    .await?
662                {
663                    return Err(AuthError::auth_method(
664                        "oidc",
665                        format!("Client is not authorized for scope '{}'", scope),
666                    ));
667                }
668            }
669        } else {
670            // SEC-H3: Without a client registry, we cannot verify the redirect_uri
671            // belongs to a legitimate client. Reject all requests to prevent open
672            // redirect attacks.
673            return Err(AuthError::auth_method(
674                "oidc",
675                "Client registry is required for authorization requests",
676            ));
677        }
678
679        // SEC-M4: Validate all requested scopes against server's supported scopes
680        for scope in request.scope.split_whitespace() {
681            if !self.config.scopes_supported.contains(&scope.to_string()) {
682                return Err(AuthError::auth_method(
683                    "oidc",
684                    format!("Unsupported scope '{}'", scope),
685                ));
686            }
687        }
688
689        Ok(AuthorizationValidationResult {
690            valid: true,
691            client_id: request.client_id.clone(),
692            redirect_uri: request.redirect_uri.clone(),
693            scope: request.scope.clone(),
694            state: request.state.clone(),
695            nonce: request.nonce.clone(),
696            max_age: request.max_age,
697            response_type: request.response_type.clone(),
698        })
699    }
700
701    /// Get user information for the UserInfo endpoint
702    pub async fn get_userinfo(&self, access_token: &str) -> Result<UserInfo> {
703        // Validate access token
704        let token_claims = self
705            .token_manager
706            .validate_jwt_token(access_token)
707            .map_err(|e| AuthError::auth_method("oidc", format!("Invalid access token: {}", e)))?;
708        if token_claims.token_use().is_some() {
709            return Err(AuthError::auth_method(
710                "oidc",
711                "Invalid access token: only an access token can be used here",
712            ));
713        }
714        // Revoked tokens (logout / revocation) are refused; an unreadable list fails closed.
715        match self
716            .storage
717            .get_kv(&format!("revoked_token:{}", token_claims.jti))
718            .await
719        {
720            Ok(None) => {}
721            Ok(Some(_)) => {
722                return Err(AuthError::auth_method(
723                    "oidc",
724                    "Invalid access token: it has been revoked",
725                ));
726            }
727            Err(e) => {
728                tracing::error!("Could not check token revocation list: {}", e);
729                return Err(AuthError::auth_method(
730                    "oidc",
731                    "Unable to verify access token status",
732                ));
733            }
734        }
735
736        // The account must exist and be active (a signature proves who minted the token, not
737        // that its subject is still a live account).
738        match self
739            .storage
740            .get_kv(&format!("user:{}", token_claims.sub))
741            .await
742        {
743            Ok(Some(bytes)) => {
744                let record: serde_json::Value = serde_json::from_slice(&bytes)
745                    .map_err(|_| AuthError::auth_method("oidc", "Unable to verify the account"))?;
746                if record["active"].as_bool() == Some(false) {
747                    return Err(AuthError::auth_method(
748                        "oidc",
749                        "The account has been deactivated",
750                    ));
751                }
752            }
753            Ok(None) => {
754                return Err(AuthError::auth_method("oidc", "Unknown account"));
755            }
756            Err(e) => {
757                tracing::error!("Could not read the account record: {}", e);
758                return Err(AuthError::auth_method(
759                    "oidc",
760                    "Unable to verify the account",
761                ));
762            }
763        }
764
765        // Extract subject from token
766        let subject = &token_claims.sub;
767
768        // Get user information from storage
769        let user_key = format!("user:{}", subject);
770        if let Some(user_data) = self.storage.get_kv(&user_key).await? {
771            let user_str = std::str::from_utf8(&user_data).unwrap_or("{}");
772            let user_profile: HashMap<String, Value> =
773                serde_json::from_str(user_str).unwrap_or_default();
774
775            Ok(UserInfo {
776                sub: subject.clone(),
777                name: user_profile
778                    .get("name")
779                    .and_then(|v| v.as_str())
780                    .map(|s| s.to_string()),
781                given_name: user_profile
782                    .get("given_name")
783                    .and_then(|v| v.as_str())
784                    .map(|s| s.to_string()),
785                family_name: user_profile
786                    .get("family_name")
787                    .and_then(|v| v.as_str())
788                    .map(|s| s.to_string()),
789                middle_name: user_profile
790                    .get("middle_name")
791                    .and_then(|v| v.as_str())
792                    .map(|s| s.to_string()),
793                nickname: user_profile
794                    .get("nickname")
795                    .and_then(|v| v.as_str())
796                    .map(|s| s.to_string()),
797                preferred_username: user_profile
798                    .get("preferred_username")
799                    .and_then(|v| v.as_str())
800                    .map(|s| s.to_string()),
801                profile: user_profile
802                    .get("profile")
803                    .and_then(|v| v.as_str())
804                    .map(|s| s.to_string()),
805                picture: user_profile
806                    .get("picture")
807                    .and_then(|v| v.as_str())
808                    .map(|s| s.to_string()),
809                website: user_profile
810                    .get("website")
811                    .and_then(|v| v.as_str())
812                    .map(|s| s.to_string()),
813                email: user_profile
814                    .get("email")
815                    .and_then(|v| v.as_str())
816                    .map(|s| s.to_string()),
817                email_verified: user_profile.get("email_verified").and_then(|v| v.as_bool()),
818                gender: user_profile
819                    .get("gender")
820                    .and_then(|v| v.as_str())
821                    .map(|s| s.to_string()),
822                birthdate: user_profile
823                    .get("birthdate")
824                    .and_then(|v| v.as_str())
825                    .map(|s| s.to_string()),
826                zoneinfo: user_profile
827                    .get("zoneinfo")
828                    .and_then(|v| v.as_str())
829                    .map(|s| s.to_string()),
830                locale: user_profile
831                    .get("locale")
832                    .and_then(|v| v.as_str())
833                    .map(|s| s.to_string()),
834                phone_number: user_profile
835                    .get("phone_number")
836                    .and_then(|v| v.as_str())
837                    .map(|s| s.to_string()),
838                phone_number_verified: user_profile
839                    .get("phone_number_verified")
840                    .and_then(|v| v.as_bool()),
841                address: user_profile
842                    .get("address")
843                    .and_then(|addr| addr.as_object())
844                    .map(|addr_obj| Address {
845                        formatted: addr_obj
846                            .get("formatted")
847                            .and_then(|v| v.as_str())
848                            .map(|s| s.to_string()),
849                        street_address: addr_obj
850                            .get("street_address")
851                            .and_then(|v| v.as_str())
852                            .map(|s| s.to_string()),
853                        locality: addr_obj
854                            .get("locality")
855                            .and_then(|v| v.as_str())
856                            .map(|s| s.to_string()),
857                        region: addr_obj
858                            .get("region")
859                            .and_then(|v| v.as_str())
860                            .map(|s| s.to_string()),
861                        postal_code: addr_obj
862                            .get("postal_code")
863                            .and_then(|v| v.as_str())
864                            .map(|s| s.to_string()),
865                        country: addr_obj
866                            .get("country")
867                            .and_then(|v| v.as_str())
868                            .map(|s| s.to_string()),
869                    }),
870                updated_at: user_profile.get("updated_at").and_then(|v| v.as_u64()),
871                additional_claims: user_profile
872                    .into_iter()
873                    .filter(|(k, _)| {
874                        ![
875                            "sub",
876                            "name",
877                            "given_name",
878                            "family_name",
879                            "middle_name",
880                            "nickname",
881                            "preferred_username",
882                            "profile",
883                            "picture",
884                            "website",
885                            "email",
886                            "email_verified",
887                            "gender",
888                            "birthdate",
889                            "zoneinfo",
890                            "locale",
891                            "phone_number",
892                            "phone_number_verified",
893                            "address",
894                            "updated_at",
895                        ]
896                        .contains(&k.as_str())
897                    })
898                    .collect(),
899            })
900        } else {
901            // Return minimal user info with only the subject claim when no stored profile exists
902            Ok(UserInfo {
903                sub: subject.clone(),
904                name: None,
905                given_name: None,
906                family_name: None,
907                middle_name: None,
908                nickname: None,
909                preferred_username: Some(subject.clone()),
910                profile: None,
911                picture: None,
912                website: None,
913                email: None,
914                email_verified: None,
915                gender: None,
916                birthdate: None,
917                zoneinfo: None,
918                locale: None,
919                phone_number: None,
920                phone_number_verified: None,
921                address: None,
922                updated_at: None,
923                additional_claims: HashMap::new(),
924            })
925        }
926    }
927
928    /// Handle logout request
929    pub async fn handle_logout(
930        &self,
931        id_token_hint: Option<&str>,
932        post_logout_redirect_uri: Option<&str>,
933        state: Option<&str>,
934    ) -> Result<LogoutResponse> {
935        // Validate ID token hint if provided
936        if let Some(id_token) = id_token_hint {
937            let claims = self
938                .token_manager
939                .validate_jwt_token(id_token)
940                .map_err(|e| AuthError::auth_method("oidc", format!("Invalid ID token: {}", e)))?;
941
942            // Invalidate all sessions for the user identified in the token
943            let user_sessions = self
944                .storage
945                .list_user_sessions(&claims.sub)
946                .await
947                .map_err(|e| AuthError::internal(format!("Failed to list user sessions: {}", e)))?;
948
949            for session in user_sessions {
950                self.storage
951                    .delete_session(&session.session_id)
952                    .await
953                    .map_err(|e| AuthError::internal(format!("Failed to delete session: {}", e)))?;
954            }
955        }
956
957        // Validate post_logout_redirect_uri against registered URIs
958        if let Some(post_logout_uri) = post_logout_redirect_uri {
959            // Extract client_id from the ID token if available
960            if let Some(id_token) = id_token_hint {
961                let claims = self
962                    .token_manager
963                    .validate_jwt_token(id_token)
964                    .map_err(|e| {
965                        AuthError::auth_method("oidc", format!("Invalid ID token: {}", e))
966                    })?;
967
968                if let Some(aud) = claims.aud.split_whitespace().next() {
969                    // Validate that the post-logout redirect URI is registered for this client
970                    if !self
971                        .is_post_logout_uri_registered(aud, post_logout_uri)
972                        .await?
973                    {
974                        return Err(AuthError::validation(
975                            "post_logout_redirect_uri not registered for client",
976                        ));
977                    }
978                }
979            } else {
980                // If no ID token provided, we cannot validate the client association
981                // In a production system, you might want to require ID token for validation
982                return Err(AuthError::validation(
983                    "id_token_hint required for post_logout_redirect_uri validation",
984                ));
985            }
986        }
987
988        Ok(LogoutResponse {
989            post_logout_redirect_uri: post_logout_redirect_uri.map(|uri| uri.to_string()),
990            state: state.map(|s| s.to_string()),
991        })
992    }
993
994    /// Check if a post-logout redirect URI is registered for a client
995    async fn is_post_logout_uri_registered(&self, client_id: &str, uri: &str) -> Result<bool> {
996        // SECURITY CRITICAL: Validate redirect URI against registered URIs
997
998        // Basic security: only allow https URIs (except localhost for development)
999        if !uri.starts_with("https://")
1000            && !uri.starts_with("http://localhost")
1001            && !uri.starts_with("http://127.0.0.1")
1002        {
1003            tracing::warn!(
1004                "Rejected post-logout redirect URI with invalid scheme: {}",
1005                uri
1006            );
1007            return Ok(false);
1008        }
1009
1010        // Enhanced security: Validate against registered URIs
1011        match self.get_client_registered_post_logout_uris(client_id).await {
1012            Ok(registered_uris) => {
1013                let is_registered = registered_uris.contains(&uri.to_string());
1014                if !is_registered {
1015                    tracing::warn!(
1016                        "Rejected unregistered post-logout redirect URI for client {}: {}",
1017                        client_id,
1018                        uri
1019                    );
1020                }
1021                Ok(is_registered)
1022            }
1023            Err(_) => {
1024                // When client lookup fails, reject all redirect URIs to prevent
1025                // open-redirect attacks. Even loopback URIs are rejected here because
1026                // `http://localhost.evil.com` would match a naive prefix check.
1027                tracing::error!(
1028                    "Rejected redirect URI — client lookup failed for {}: {}",
1029                    client_id,
1030                    uri
1031                );
1032                Ok(false)
1033            }
1034        }
1035    }
1036
1037    /// Get registered post-logout redirect URIs for a client
1038    async fn get_client_registered_post_logout_uris(&self, client_id: &str) -> Result<Vec<String>> {
1039        // Look up post-logout redirect URIs from client registry storage
1040        if let Some(client_registry) = &self.client_registry
1041            && let Some(client) = client_registry.get_client(client_id).await?
1042        {
1043            // Post-logout redirect URIs are stored in client metadata
1044            if let Some(uris) = client.metadata.get("post_logout_redirect_uris")
1045                && let Some(arr) = uris.as_array()
1046            {
1047                return Ok(arr
1048                    .iter()
1049                    .filter_map(|v| v.as_str().map(|s| s.to_string()))
1050                    .collect());
1051            }
1052        }
1053        // Unknown client or no registry — return empty list so all redirect URIs
1054        // are rejected, preventing open-redirect attacks.
1055        Ok(Vec::new())
1056    }
1057
1058    /// Generate JWK Set for the .well-known/jwks.json endpoint
1059    pub fn generate_jwks(&self) -> Result<JwkSet> {
1060        let keys = self
1061            .token_manager
1062            .export_public_jwks()?
1063            .into_iter()
1064            .map(|key| Jwk {
1065                kty: "RSA".to_string(),
1066                use_: Some("sig".to_string()),
1067                key_ops: Some(vec!["verify".to_string()]),
1068                alg: Some(algorithm_to_string(&key.algorithm)),
1069                kid: Some(key.kid),
1070                n: key.n,
1071                e: key.e,
1072                additional_params: HashMap::new(),
1073            })
1074            .collect();
1075
1076        Ok(JwkSet { keys })
1077    }
1078}
1079
1080/// OIDC Authorization Request
1081#[derive(Debug, Clone, Serialize, Deserialize)]
1082pub struct OidcAuthorizationRequest {
1083    pub response_type: String,
1084    pub client_id: String,
1085    pub redirect_uri: String,
1086    pub scope: String,
1087    pub state: Option<String>,
1088    pub nonce: Option<String>,
1089    pub max_age: Option<u64>,
1090    pub ui_locales: Option<String>,
1091    pub claims_locales: Option<String>,
1092    pub id_token_hint: Option<String>,
1093    pub login_hint: Option<String>,
1094    pub acr_values: Option<String>,
1095    pub claims: Option<String>,
1096    pub request: Option<String>,
1097    pub request_uri: Option<String>,
1098}
1099
1100impl OidcAuthorizationRequest {
1101    /// Create a builder with the required `client_id` and `redirect_uri`.
1102    ///
1103    /// Defaults: `response_type = "code"`, `scope = "openid"`.
1104    pub fn builder(
1105        client_id: impl Into<String>,
1106        redirect_uri: impl Into<String>,
1107    ) -> OidcAuthorizationRequestBuilder {
1108        OidcAuthorizationRequestBuilder::new(client_id, redirect_uri)
1109    }
1110}
1111
1112/// Fluent builder for [`OidcAuthorizationRequest`].
1113///
1114/// # Example
1115///
1116/// ```rust
1117/// use auth_framework::server::oidc::core::OidcAuthorizationRequest;
1118///
1119/// let req = OidcAuthorizationRequest::builder("my-client", "https://app.example/callback")
1120///     .scope("openid profile email")
1121///     .state("random_state")
1122///     .nonce("random_nonce")
1123///     .build();
1124///
1125/// assert_eq!(req.client_id, "my-client");
1126/// assert_eq!(req.scope, "openid profile email");
1127/// ```
1128pub struct OidcAuthorizationRequestBuilder {
1129    req: OidcAuthorizationRequest,
1130}
1131
1132impl OidcAuthorizationRequestBuilder {
1133    fn new(client_id: impl Into<String>, redirect_uri: impl Into<String>) -> Self {
1134        Self {
1135            req: OidcAuthorizationRequest {
1136                response_type: "code".to_string(),
1137                client_id: client_id.into(),
1138                redirect_uri: redirect_uri.into(),
1139                scope: "openid".to_string(),
1140                state: None,
1141                nonce: None,
1142                max_age: None,
1143                ui_locales: None,
1144                claims_locales: None,
1145                id_token_hint: None,
1146                login_hint: None,
1147                acr_values: None,
1148                claims: None,
1149                request: None,
1150                request_uri: None,
1151            },
1152        }
1153    }
1154
1155    /// Set the OAuth2 response type (default: `"code"`).
1156    pub fn response_type(mut self, rt: impl Into<String>) -> Self {
1157        self.req.response_type = rt.into();
1158        self
1159    }
1160
1161    /// Set the requested scopes (default: `"openid"`).
1162    pub fn scope(mut self, scope: impl Into<String>) -> Self {
1163        self.req.scope = scope.into();
1164        self
1165    }
1166
1167    /// Set the state parameter for CSRF protection.
1168    pub fn state(mut self, state: impl Into<String>) -> Self {
1169        self.req.state = Some(state.into());
1170        self
1171    }
1172
1173    /// Set the nonce for ID token replay protection.
1174    pub fn nonce(mut self, nonce: impl Into<String>) -> Self {
1175        self.req.nonce = Some(nonce.into());
1176        self
1177    }
1178
1179    /// Set the maximum authentication age in seconds.
1180    pub fn max_age(mut self, seconds: u64) -> Self {
1181        self.req.max_age = Some(seconds);
1182        self
1183    }
1184
1185    /// Provide a login hint (e.g. email or username).
1186    pub fn login_hint(mut self, hint: impl Into<String>) -> Self {
1187        self.req.login_hint = Some(hint.into());
1188        self
1189    }
1190
1191    /// Set the id_token_hint for session management.
1192    pub fn id_token_hint(mut self, hint: impl Into<String>) -> Self {
1193        self.req.id_token_hint = Some(hint.into());
1194        self
1195    }
1196
1197    /// Set the ACR values.
1198    pub fn acr_values(mut self, values: impl Into<String>) -> Self {
1199        self.req.acr_values = Some(values.into());
1200        self
1201    }
1202
1203    /// Consume the builder and produce the request.
1204    pub fn build(self) -> OidcAuthorizationRequest {
1205        self.req
1206    }
1207}
1208
1209/// Authorization validation result
1210#[derive(Debug, Clone)]
1211pub struct AuthorizationValidationResult {
1212    pub valid: bool,
1213    pub client_id: String,
1214    pub redirect_uri: String,
1215    pub scope: String,
1216    pub state: Option<String>,
1217    pub nonce: Option<String>,
1218    pub max_age: Option<u64>,
1219    pub response_type: String,
1220}
1221
1222/// ID Token Claims
1223#[derive(Debug, Clone, Serialize, Deserialize)]
1224pub struct IdTokenClaims {
1225    /// Issuer
1226    pub iss: String,
1227    /// Subject
1228    pub sub: String,
1229    /// Audience
1230    pub aud: Vec<String>,
1231    /// Expiration time
1232    pub exp: u64,
1233    /// Issued at
1234    pub iat: u64,
1235    /// Authentication time
1236    #[serde(skip_serializing_if = "Option::is_none")]
1237    pub auth_time: Option<u64>,
1238    /// Nonce
1239    #[serde(skip_serializing_if = "Option::is_none")]
1240    pub nonce: Option<String>,
1241    /// Additional claims
1242    #[serde(flatten)]
1243    pub additional_claims: HashMap<String, Value>,
1244}
1245
1246/// UserInfo response
1247#[derive(Debug, Clone, Serialize, Deserialize)]
1248pub struct UserInfo {
1249    pub sub: String,
1250    #[serde(skip_serializing_if = "Option::is_none")]
1251    pub name: Option<String>,
1252    #[serde(skip_serializing_if = "Option::is_none")]
1253    pub given_name: Option<String>,
1254    #[serde(skip_serializing_if = "Option::is_none")]
1255    pub family_name: Option<String>,
1256    #[serde(skip_serializing_if = "Option::is_none")]
1257    pub middle_name: Option<String>,
1258    #[serde(skip_serializing_if = "Option::is_none")]
1259    pub nickname: Option<String>,
1260    #[serde(skip_serializing_if = "Option::is_none")]
1261    pub preferred_username: Option<String>,
1262    #[serde(skip_serializing_if = "Option::is_none")]
1263    pub profile: Option<String>,
1264    #[serde(skip_serializing_if = "Option::is_none")]
1265    pub picture: Option<String>,
1266    #[serde(skip_serializing_if = "Option::is_none")]
1267    pub website: Option<String>,
1268    #[serde(skip_serializing_if = "Option::is_none")]
1269    pub email: Option<String>,
1270    #[serde(skip_serializing_if = "Option::is_none")]
1271    pub email_verified: Option<bool>,
1272    #[serde(skip_serializing_if = "Option::is_none")]
1273    pub gender: Option<String>,
1274    #[serde(skip_serializing_if = "Option::is_none")]
1275    pub birthdate: Option<String>,
1276    #[serde(skip_serializing_if = "Option::is_none")]
1277    pub zoneinfo: Option<String>,
1278    #[serde(skip_serializing_if = "Option::is_none")]
1279    pub locale: Option<String>,
1280    #[serde(skip_serializing_if = "Option::is_none")]
1281    pub phone_number: Option<String>,
1282    #[serde(skip_serializing_if = "Option::is_none")]
1283    pub phone_number_verified: Option<bool>,
1284    #[serde(skip_serializing_if = "Option::is_none")]
1285    pub address: Option<Address>,
1286    #[serde(skip_serializing_if = "Option::is_none")]
1287    pub updated_at: Option<u64>,
1288    #[serde(flatten)]
1289    pub additional_claims: HashMap<String, Value>,
1290}
1291
1292/// Address claim
1293#[derive(Debug, Clone, Serialize, Deserialize)]
1294pub struct Address {
1295    #[serde(skip_serializing_if = "Option::is_none")]
1296    pub formatted: Option<String>,
1297    #[serde(skip_serializing_if = "Option::is_none")]
1298    pub street_address: Option<String>,
1299    #[serde(skip_serializing_if = "Option::is_none")]
1300    pub locality: Option<String>,
1301    #[serde(skip_serializing_if = "Option::is_none")]
1302    pub region: Option<String>,
1303    #[serde(skip_serializing_if = "Option::is_none")]
1304    pub postal_code: Option<String>,
1305    #[serde(skip_serializing_if = "Option::is_none")]
1306    pub country: Option<String>,
1307}
1308
1309/// OIDC Discovery Document
1310#[derive(Debug, Clone, Serialize, Deserialize)]
1311pub struct OidcDiscoveryDocument {
1312    pub issuer: String,
1313    pub authorization_endpoint: String,
1314    pub token_endpoint: String,
1315    pub userinfo_endpoint: String,
1316    pub jwks_uri: String,
1317    #[serde(skip_serializing_if = "Option::is_none")]
1318    pub registration_endpoint: Option<String>,
1319    pub scopes_supported: Vec<String>,
1320    pub response_types_supported: Vec<String>,
1321    #[serde(skip_serializing_if = "Option::is_none")]
1322    pub response_modes_supported: Option<Vec<String>>,
1323    #[serde(skip_serializing_if = "Option::is_none")]
1324    pub grant_types_supported: Option<Vec<String>>,
1325    pub subject_types_supported: Vec<SubjectType>,
1326    pub id_token_signing_alg_values_supported: Vec<String>,
1327    #[serde(skip_serializing_if = "Option::is_none")]
1328    pub userinfo_signing_alg_values_supported: Option<Vec<String>>,
1329    #[serde(skip_serializing_if = "Option::is_none")]
1330    pub token_endpoint_auth_methods_supported: Option<Vec<String>>,
1331    #[serde(skip_serializing_if = "Option::is_none")]
1332    pub claims_supported: Option<Vec<String>>,
1333    #[serde(skip_serializing_if = "Option::is_none")]
1334    pub claims_parameter_supported: Option<bool>,
1335    #[serde(skip_serializing_if = "Option::is_none")]
1336    pub request_parameter_supported: Option<bool>,
1337    #[serde(skip_serializing_if = "Option::is_none")]
1338    pub request_uri_parameter_supported: Option<bool>,
1339    #[serde(skip_serializing_if = "Option::is_none")]
1340    pub code_challenge_methods_supported: Option<Vec<String>>,
1341}
1342
1343/// JWK Set
1344#[derive(Debug, Clone, Serialize, Deserialize)]
1345pub struct JwkSet {
1346    pub keys: Vec<Jwk>,
1347}
1348
1349/// JSON Web Key
1350#[derive(Debug, Clone, Serialize, Deserialize)]
1351pub struct Jwk {
1352    pub kty: String,
1353    #[serde(rename = "use", skip_serializing_if = "Option::is_none")]
1354    pub use_: Option<String>,
1355    #[serde(skip_serializing_if = "Option::is_none")]
1356    pub key_ops: Option<Vec<String>>,
1357    #[serde(skip_serializing_if = "Option::is_none")]
1358    pub alg: Option<String>,
1359    #[serde(skip_serializing_if = "Option::is_none")]
1360    pub kid: Option<String>,
1361    pub n: String,
1362    pub e: String,
1363    #[serde(flatten)]
1364    pub additional_params: HashMap<String, Value>,
1365}
1366
1367/// Logout response
1368#[derive(Debug, Clone)]
1369pub struct LogoutResponse {
1370    pub post_logout_redirect_uri: Option<String>,
1371    pub state: Option<String>,
1372}
1373
1374/// Helper function to convert Algorithm to string
1375fn algorithm_to_string(alg: &Algorithm) -> String {
1376    match alg {
1377        Algorithm::HS256 => "HS256".to_string(),
1378        Algorithm::HS384 => "HS384".to_string(),
1379        Algorithm::HS512 => "HS512".to_string(),
1380        Algorithm::ES256 => "ES256".to_string(),
1381        Algorithm::ES384 => "ES384".to_string(),
1382        Algorithm::RS256 => "RS256".to_string(),
1383        Algorithm::RS384 => "RS384".to_string(),
1384        Algorithm::RS512 => "RS512".to_string(),
1385        Algorithm::PS256 => "PS256".to_string(),
1386        Algorithm::PS384 => "PS384".to_string(),
1387        Algorithm::PS512 => "PS512".to_string(),
1388        Algorithm::EdDSA => "EdDSA".to_string(),
1389    }
1390}
1391
1392#[cfg(test)]
1393mod tests {
1394    use super::*;
1395    use crate::storage::MemoryStorage;
1396
1397    #[tokio::test]
1398    async fn userinfo_refuses_a_deactivated_or_unknown_account() {
1399        let provider = create_test_oidc_provider().await;
1400        let tm = provider.token_manager.clone();
1401        let token_for = |sub: &str| {
1402            tm.create_jwt_token(
1403                sub,
1404                vec!["openid".into()],
1405                Some(std::time::Duration::from_secs(600)),
1406            )
1407            .unwrap()
1408        };
1409        provider
1410            .storage
1411            .store_kv(
1412                "user:gone",
1413                serde_json::json!({"id": "gone", "active": false})
1414                    .to_string()
1415                    .as_bytes(),
1416                None,
1417            )
1418            .await
1419            .unwrap();
1420        let err = provider
1421            .get_userinfo(&token_for("gone"))
1422            .await
1423            .unwrap_err()
1424            .to_string();
1425        assert!(err.to_lowercase().contains("deactivated"), "{err}");
1426        let err = provider
1427            .get_userinfo(&token_for("never-registered"))
1428            .await
1429            .unwrap_err()
1430            .to_string();
1431        assert!(err.to_lowercase().contains("unknown account"), "{err}");
1432    }
1433
1434    #[tokio::test]
1435    async fn userinfo_refuses_revoked_and_refresh_tokens() {
1436        let provider = create_test_oidc_provider().await;
1437        let tm = provider.token_manager.clone();
1438        let access = tm
1439            .create_jwt_token(
1440                "user_x",
1441                vec!["openid".into()],
1442                Some(std::time::Duration::from_secs(600)),
1443            )
1444            .unwrap();
1445        let refresh = tm
1446            .create_refresh_jwt_token("user_x", Some(std::time::Duration::from_secs(600)))
1447            .unwrap();
1448        assert!(
1449            provider.get_userinfo(&refresh).await.is_err(),
1450            "refresh JWT"
1451        );
1452
1453        let jti = tm.validate_jwt_token(&access).unwrap().jti;
1454        provider
1455            .storage
1456            .store_kv(&format!("revoked_token:{jti}"), b"revoked", None)
1457            .await
1458            .unwrap();
1459        let err = provider
1460            .get_userinfo(&access)
1461            .await
1462            .unwrap_err()
1463            .to_string();
1464        assert!(err.contains("revoked"), "{err}");
1465    }
1466
1467    async fn create_test_oidc_provider() -> OidcProvider<MemoryStorage> {
1468        let config = OidcConfig::default();
1469        let token_manager = Arc::new(TokenManager::new_hmac(
1470            b"test_secret_key_32_bytes_long!!!!",
1471            "test_issuer",
1472            "test_audience",
1473        ));
1474        let storage = Arc::new(MemoryStorage::new());
1475
1476        // Register a test client so that the fail-closed client registry check passes
1477        let client_registry = Arc::new(
1478            crate::server::core::client_registry::ClientRegistry::new(
1479                storage.clone() as Arc<dyn crate::storage::AuthStorage>
1480            )
1481            .await
1482            .unwrap(),
1483        );
1484        let test_client = crate::client::ClientConfig {
1485            client_id: "test_client".to_string(),
1486            client_secret: Some("test_secret".to_string()),
1487            client_type: crate::client::ClientType::Confidential,
1488            redirect_uris: vec!["https://client.example.com/callback".to_string()].into(),
1489            authorized_scopes: vec![
1490                "openid".to_string(),
1491                "profile".to_string(),
1492                "email".to_string(),
1493            ]
1494            .into(),
1495            authorized_grant_types: vec!["authorization_code".to_string()].into(),
1496            authorized_response_types: vec!["code".to_string()].into(),
1497            client_name: Some("Test Client".to_string()),
1498            client_description: None,
1499            metadata: std::collections::HashMap::new(),
1500        };
1501        client_registry.register_client(test_client).await.unwrap();
1502
1503        let mut provider = OidcProvider::new(config, token_manager, storage)
1504            .await
1505            .unwrap();
1506        provider.set_client_registry(client_registry);
1507        provider
1508    }
1509
1510    #[tokio::test]
1511    async fn test_oidc_provider_creation() {
1512        let provider = create_test_oidc_provider().await;
1513        assert_eq!(provider.config.issuer, "https://auth.example.com");
1514        assert!(
1515            provider
1516                .config
1517                .scopes_supported
1518                .contains(&"openid".to_string())
1519        );
1520    }
1521
1522    #[tokio::test]
1523    async fn test_discovery_document() {
1524        let provider = create_test_oidc_provider().await;
1525        let discovery = provider.discovery_document().unwrap();
1526
1527        assert_eq!(discovery.issuer, "https://auth.example.com");
1528        assert_eq!(
1529            discovery.authorization_endpoint,
1530            "https://auth.example.com/oidc/authorize"
1531        );
1532        assert!(discovery.scopes_supported.contains(&"openid".to_string()));
1533        assert!(
1534            discovery
1535                .response_types_supported
1536                .contains(&"code".to_string())
1537        );
1538    }
1539
1540    #[tokio::test]
1541    async fn test_authorization_request_validation() {
1542        let provider = create_test_oidc_provider().await;
1543
1544        let valid_request = OidcAuthorizationRequest {
1545            response_type: "code".to_string(),
1546            client_id: "test_client".to_string(),
1547            redirect_uri: "https://client.example.com/callback".to_string(),
1548            scope: "openid profile email".to_string(),
1549            state: Some("abc123".to_string()),
1550            nonce: Some("xyz789".to_string()),
1551            max_age: None,
1552            ui_locales: None,
1553            claims_locales: None,
1554            id_token_hint: None,
1555            login_hint: None,
1556            acr_values: None,
1557            claims: None,
1558            request: None,
1559            request_uri: None,
1560        };
1561
1562        let result = provider
1563            .validate_authorization_request(&valid_request)
1564            .await
1565            .unwrap();
1566        assert!(result.valid);
1567        assert_eq!(result.client_id, "test_client");
1568        assert_eq!(result.scope, "openid profile email");
1569    }
1570
1571    #[tokio::test]
1572    async fn test_authorization_request_missing_openid_scope() {
1573        let provider = create_test_oidc_provider().await;
1574
1575        let invalid_request = OidcAuthorizationRequest {
1576            response_type: "code".to_string(),
1577            client_id: "test_client".to_string(),
1578            redirect_uri: "https://client.example.com/callback".to_string(),
1579            scope: "profile email".to_string(), // Missing 'openid'
1580            state: Some("abc123".to_string()),
1581            nonce: Some("xyz789".to_string()),
1582            max_age: None,
1583            ui_locales: None,
1584            claims_locales: None,
1585            id_token_hint: None,
1586            login_hint: None,
1587            acr_values: None,
1588            claims: None,
1589            request: None,
1590            request_uri: None,
1591        };
1592
1593        let result = provider
1594            .validate_authorization_request(&invalid_request)
1595            .await;
1596        assert!(result.is_err());
1597    }
1598
1599    #[tokio::test]
1600    async fn test_id_token_creation() {
1601        let provider = create_test_oidc_provider().await;
1602
1603        let auth_time = SystemTime::now();
1604        let mut claims = HashMap::new();
1605        claims.insert("name".to_string(), Value::String("John Doe".to_string()));
1606        claims.insert(
1607            "email".to_string(),
1608            Value::String("john@example.com".to_string()),
1609        );
1610
1611        use crate::server::oidc::core::IdTokenRequest;
1612        let id_token = provider
1613            .create_id_token(
1614                IdTokenRequest::new("user123", "client456")
1615                    .with_nonce("nonce789")
1616                    .with_auth_time(auth_time)
1617                    .with_claims(&claims),
1618            )
1619            .await
1620            .unwrap();
1621
1622        assert!(!id_token.is_empty());
1623        assert!(id_token.contains('.'));
1624    }
1625
1626    #[tokio::test]
1627    async fn an_id_token_is_not_an_access_token() {
1628        use crate::server::oidc::core::IdTokenRequest;
1629        let provider = create_test_oidc_provider().await;
1630        let id_token = provider
1631            .create_id_token(IdTokenRequest::new("user123", "client456"))
1632            .await
1633            .unwrap();
1634        // it is a valid JWT of this server ...
1635        assert!(provider.token_manager.validate_jwt_token(&id_token).is_ok());
1636        // ... but not something that authenticates a request
1637        let storage = MemoryStorage::new();
1638        assert!(
1639            crate::auth::validate_access_jwt_with(
1640                &provider.token_manager,
1641                &storage,
1642                &id_token,
1643                false,
1644                false
1645            )
1646            .await
1647            .is_err(),
1648            "an ID token must not be accepted as an access token"
1649        );
1650        // control: a genuine access token for the same subject is
1651        let access = provider
1652            .token_manager
1653            .create_jwt_token("user123", vec!["openid".into()], None)
1654            .unwrap();
1655        assert!(
1656            crate::auth::validate_access_jwt_with(
1657                &provider.token_manager,
1658                &storage,
1659                &access,
1660                false,
1661                false
1662            )
1663            .await
1664            .is_ok()
1665        );
1666    }
1667
1668    #[tokio::test]
1669    async fn test_jwks_generation() {
1670        let provider = create_test_oidc_provider().await;
1671        let jwks = provider.generate_jwks().unwrap();
1672
1673        assert!(jwks.keys.is_empty());
1674    }
1675
1676    #[tokio::test]
1677    async fn test_logout_handling() {
1678        let provider = create_test_oidc_provider().await;
1679
1680        // Test logout without post_logout_redirect_uri (should work without id_token_hint)
1681        let logout_response = provider
1682            .handle_logout(None, None, Some("state123"))
1683            .await
1684            .unwrap();
1685
1686        assert_eq!(logout_response.post_logout_redirect_uri, None);
1687        assert_eq!(logout_response.state, Some("state123".to_string()));
1688    }
1689
1690    #[test]
1691    fn test_subject_type_serialization() {
1692        let public = SubjectType::Public;
1693        let pairwise = SubjectType::Pairwise;
1694
1695        let public_json = serde_json::to_string(&public).unwrap();
1696        let pairwise_json = serde_json::to_string(&pairwise).unwrap();
1697
1698        assert_eq!(public_json, "\"public\"");
1699        assert_eq!(pairwise_json, "\"pairwise\"");
1700    }
1701
1702    #[test]
1703    fn test_algorithm_to_string_conversion() {
1704        assert_eq!(algorithm_to_string(&Algorithm::RS256), "RS256");
1705        assert_eq!(algorithm_to_string(&Algorithm::ES256), "ES256");
1706        assert_eq!(algorithm_to_string(&Algorithm::HS256), "HS256");
1707        assert_eq!(algorithm_to_string(&Algorithm::EdDSA), "EdDSA");
1708    }
1709
1710    #[test]
1711    fn test_oidc_config_default() {
1712        let config = OidcConfig::default();
1713        assert_eq!(config.issuer, "https://auth.example.com");
1714        assert!(config.scopes_supported.contains(&"openid".to_string()));
1715        assert!(config.claims_supported.contains(&"sub".to_string()));
1716        assert_eq!(config.subject_types_supported, vec![SubjectType::Public]);
1717    }
1718}