1use crate::errors::{AuthError, Result};
28use crate::security::secure_jwt::SecureJwtValidator;
29use crate::server::{DpopManager, MutualTlsManager, PARManager, PrivateKeyJwtManager};
30use chrono::{DateTime, Duration, Utc};
31use jsonwebtoken::{Algorithm, DecodingKey, EncodingKey, Header, Validation};
32use serde::{Deserialize, Serialize};
33use serde_json::{Value, json};
34use std::collections::HashMap;
35use std::sync::Arc;
36use tokio::sync::RwLock;
37use uuid::Uuid;
38
39#[derive(Debug, Clone)]
41pub struct FapiManager {
42 dpop_manager: Arc<DpopManager>,
44
45 mtls_manager: Arc<MutualTlsManager>,
47
48 par_manager: Arc<PARManager>,
50
51 private_key_jwt_manager: Arc<PrivateKeyJwtManager>,
53
54 jwt_validator: Arc<SecureJwtValidator>,
56
57 config: FapiConfig,
59
60 sessions: Arc<RwLock<HashMap<String, FapiSession>>>,
62}
63
64#[derive(Clone)]
66pub struct FapiConfig {
67 pub issuer: String,
69
70 pub request_signing_algorithm: Algorithm,
72
73 pub response_signing_algorithm: Algorithm,
75
76 pub private_key: EncodingKey,
78
79 pub public_key: DecodingKey,
81
82 pub max_request_age: i64,
84
85 pub require_dpop: bool,
87
88 pub require_mtls: bool,
90
91 pub require_par: bool,
93
94 pub enable_jarm: bool,
96
97 pub enhanced_audit: bool,
99
100 pub is_degraded: bool,
104}
105
106impl std::fmt::Debug for FapiConfig {
107 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
108 f.debug_struct("FapiConfig")
109 .field("issuer", &self.issuer)
110 .field("request_signing_algorithm", &self.request_signing_algorithm)
111 .field(
112 "response_signing_algorithm",
113 &self.response_signing_algorithm,
114 )
115 .field("private_key", &"<EncodingKey>")
116 .field("public_key", &"<DecodingKey>")
117 .field("max_request_age", &self.max_request_age)
118 .field("require_dpop", &self.require_dpop)
119 .field("require_mtls", &self.require_mtls)
120 .field("require_par", &self.require_par)
121 .field("enable_jarm", &self.enable_jarm)
122 .field("enhanced_audit", &self.enhanced_audit)
123 .field("is_degraded", &self.is_degraded)
124 .finish()
125 }
126}
127
128impl FapiConfig {
129 pub fn builder(
133 issuer: impl Into<String>,
134 private_key: EncodingKey,
135 public_key: DecodingKey,
136 ) -> FapiConfigBuilder {
137 FapiConfigBuilder {
138 issuer: issuer.into(),
139 request_signing_algorithm: Algorithm::PS256,
140 response_signing_algorithm: Algorithm::PS256,
141 private_key,
142 public_key,
143 max_request_age: 60,
144 require_dpop: true,
145 require_mtls: true,
146 require_par: true,
147 enable_jarm: true,
148 enhanced_audit: true,
149 is_degraded: false,
150 }
151 }
152
153 #[deprecated(since = "0.5.0", note = "use FapiConfig::from_env() instead")]
155 pub fn load_from_env() -> Self {
156 Self::from_env()
157 }
158
159 pub fn from_env() -> Self {
163 Self::default()
164 }
165}
166
167pub struct FapiConfigBuilder {
169 issuer: String,
170 request_signing_algorithm: Algorithm,
171 response_signing_algorithm: Algorithm,
172 private_key: EncodingKey,
173 public_key: DecodingKey,
174 max_request_age: i64,
175 require_dpop: bool,
176 require_mtls: bool,
177 require_par: bool,
178 enable_jarm: bool,
179 enhanced_audit: bool,
180 is_degraded: bool,
181}
182
183impl FapiConfigBuilder {
184 pub fn request_signing_algorithm(mut self, alg: Algorithm) -> Self {
188 self.request_signing_algorithm = alg;
189 self
190 }
191
192 pub fn response_signing_algorithm(mut self, alg: Algorithm) -> Self {
194 self.response_signing_algorithm = alg;
195 self
196 }
197
198 pub fn max_request_age(mut self, age: i64) -> Self {
200 self.max_request_age = age;
201 self
202 }
203
204 pub fn require_dpop(mut self, require: bool) -> Self {
206 self.require_dpop = require;
207 self
208 }
209
210 pub fn require_mtls(mut self, require: bool) -> Self {
212 self.require_mtls = require;
213 self
214 }
215
216 pub fn require_par(mut self, require: bool) -> Self {
218 self.require_par = require;
219 self
220 }
221
222 pub fn enable_jarm(mut self, enable: bool) -> Self {
224 self.enable_jarm = enable;
225 self
226 }
227
228 pub fn enhanced_audit(mut self, enable: bool) -> Self {
230 self.enhanced_audit = enable;
231 self
232 }
233
234 pub fn degraded(mut self) -> Self {
236 self.is_degraded = true;
237 self
238 }
239
240 pub fn build(self) -> FapiConfig {
242 FapiConfig {
243 issuer: self.issuer,
244 request_signing_algorithm: self.request_signing_algorithm,
245 response_signing_algorithm: self.response_signing_algorithm,
246 private_key: self.private_key,
247 public_key: self.public_key,
248 max_request_age: self.max_request_age,
249 require_dpop: self.require_dpop,
250 require_mtls: self.require_mtls,
251 require_par: self.require_par,
252 enable_jarm: self.enable_jarm,
253 enhanced_audit: self.enhanced_audit,
254 is_degraded: self.is_degraded,
255 }
256 }
257}
258
259#[derive(Debug, Clone, Serialize, Deserialize)]
261pub struct FapiSession {
262 pub session_id: String,
264
265 pub client_id: String,
267
268 pub user_id: String,
270
271 pub created_at: DateTime<Utc>,
273
274 pub expires_at: DateTime<Utc>,
276
277 pub dpop_proof: Option<String>,
279
280 pub cert_thumbprint: Option<String>,
282
283 pub request_jti: Option<String>,
285
286 pub scopes: Vec<String>,
288
289 pub metadata: HashMap<String, Value>,
291}
292
293impl FapiSession {
294 pub fn builder(
296 session_id: impl Into<String>,
297 client_id: impl Into<String>,
298 user_id: impl Into<String>,
299 expires_in: Duration,
300 ) -> FapiSessionBuilder {
301 let now = Utc::now();
302 FapiSessionBuilder {
303 session_id: session_id.into(),
304 client_id: client_id.into(),
305 user_id: user_id.into(),
306 created_at: now,
307 expires_at: now + expires_in,
308 dpop_proof: None,
309 cert_thumbprint: None,
310 request_jti: None,
311 scopes: Vec::new(),
312 metadata: HashMap::new(),
313 }
314 }
315}
316
317pub struct FapiSessionBuilder {
319 session_id: String,
320 client_id: String,
321 user_id: String,
322 created_at: DateTime<Utc>,
323 expires_at: DateTime<Utc>,
324 dpop_proof: Option<String>,
325 cert_thumbprint: Option<String>,
326 request_jti: Option<String>,
327 scopes: Vec<String>,
328 metadata: HashMap<String, Value>,
329}
330
331impl FapiSessionBuilder {
332 pub fn dpop_proof(mut self, proof: impl Into<String>) -> Self {
334 self.dpop_proof = Some(proof.into());
335 self
336 }
337
338 pub fn cert_thumbprint(mut self, thumbprint: impl Into<String>) -> Self {
340 self.cert_thumbprint = Some(thumbprint.into());
341 self
342 }
343
344 pub fn request_jti(mut self, jti: impl Into<String>) -> Self {
346 self.request_jti = Some(jti.into());
347 self
348 }
349
350 pub fn add_scope(mut self, scope: impl Into<String>) -> Self {
352 self.scopes.push(scope.into());
353 self
354 }
355
356 pub fn add_scopes<I, S>(mut self, scopes: I) -> Self
358 where
359 I: IntoIterator<Item = S>,
360 S: Into<String>,
361 {
362 self.scopes.extend(scopes.into_iter().map(Into::into));
363 self
364 }
365
366 pub fn add_metadata(mut self, key: impl Into<String>, value: Value) -> Self {
368 self.metadata.insert(key.into(), value);
369 self
370 }
371
372 pub fn build(self) -> FapiSession {
374 FapiSession {
375 session_id: self.session_id,
376 client_id: self.client_id,
377 user_id: self.user_id,
378 created_at: self.created_at,
379 expires_at: self.expires_at,
380 dpop_proof: self.dpop_proof,
381 cert_thumbprint: self.cert_thumbprint,
382 request_jti: self.request_jti,
383 scopes: self.scopes,
384 metadata: self.metadata,
385 }
386 }
387}
388
389#[derive(Debug, Clone, Serialize, Deserialize)]
391pub struct FapiRequestObject {
392 pub iss: String,
394
395 pub aud: String,
397
398 pub iat: i64,
400
401 pub exp: i64,
403
404 pub nbf: Option<i64>,
406
407 pub jti: String,
409
410 pub response_type: String,
412
413 pub client_id: String,
415
416 pub redirect_uri: String,
418
419 pub scope: String,
421
422 pub state: Option<String>,
424
425 pub nonce: Option<String>,
427
428 pub code_challenge: Option<String>,
430
431 pub code_challenge_method: Option<String>,
433
434 #[serde(flatten)]
436 pub additional_claims: HashMap<String, Value>,
437}
438
439#[derive(Debug, Clone, Serialize, Deserialize)]
441pub struct FapiAuthorizationResponse {
442 pub iss: String,
444
445 pub aud: String,
447
448 pub iat: i64,
450
451 pub exp: i64,
453
454 pub code: Option<String>,
456
457 pub state: Option<String>,
459
460 pub error: Option<String>,
462
463 pub error_description: Option<String>,
465
466 #[serde(flatten)]
468 pub additional_params: HashMap<String, Value>,
469}
470
471#[derive(Clone, Serialize, Deserialize)]
473pub struct FapiTokenResponse {
474 pub access_token: String,
476
477 pub token_type: String,
479
480 pub expires_in: i64,
482
483 pub refresh_token: Option<String>,
485
486 pub scope: Option<String>,
488
489 pub id_token: Option<String>,
491
492 pub cnf: Option<Value>,
494}
495
496impl std::fmt::Debug for FapiTokenResponse {
497 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
498 let mut d = f.debug_struct("FapiTokenResponse");
499 d.field(
500 "access_token",
501 &crate::utils::redact::redacted(&self.access_token),
502 );
503 d.field("token_type", &self.token_type);
504 d.field("expires_in", &self.expires_in);
505 d.field(
506 "refresh_token",
507 &crate::utils::redact::redacted(&self.refresh_token),
508 );
509 d.field("scope", &self.scope);
510 d.field("id_token", &crate::utils::redact::redacted(&self.id_token));
511 d.field("cnf", &self.cnf);
512 d.finish()
513 }
514}
515
516impl FapiManager {
517 pub fn new(
519 config: FapiConfig,
520 dpop_manager: Arc<DpopManager>,
521 mtls_manager: Arc<MutualTlsManager>,
522 par_manager: Arc<PARManager>,
523 private_key_jwt_manager: Arc<PrivateKeyJwtManager>,
524 jwt_validator: Arc<SecureJwtValidator>,
525 ) -> Self {
526 Self {
527 dpop_manager,
528 mtls_manager,
529 par_manager,
530 private_key_jwt_manager,
531 jwt_validator,
532 config,
533 sessions: Arc::new(RwLock::new(HashMap::new())),
534 }
535 }
536
537 pub async fn validate_authorization_request(
539 &self,
540 request_object: &str,
541 client_cert: Option<&str>,
542 dpop_proof: Option<&str>,
543 request_uri: Option<&str>,
544 ) -> Result<FapiRequestObject> {
545 let claims = if let Some(uri) = request_uri {
546 if self.config.require_par {
548 let par_request = self.par_manager.consume_request(uri).await.map_err(|e| {
550 AuthError::InvalidRequest(format!("PAR request validation failed: {}", e))
551 })?;
552
553 tracing::info!(
554 "FAPI PAR request consumed successfully for client: {}",
555 par_request.client_id
556 );
557
558 let nonce = par_request.additional_params.get("nonce").cloned();
560 FapiRequestObject {
561 iss: par_request.client_id.clone(),
562 aud: self.config.issuer.clone(),
563 iat: Utc::now().timestamp(),
564 exp: Utc::now().timestamp() + 300, nbf: Some(Utc::now().timestamp()),
566 jti: uuid::Uuid::new_v4().to_string(),
567 response_type: par_request.response_type,
568 client_id: par_request.client_id,
569 redirect_uri: par_request.redirect_uri,
570 scope: par_request.scope.unwrap_or_default(),
571 state: par_request.state,
572 nonce,
573 code_challenge: par_request.code_challenge,
574 code_challenge_method: par_request.code_challenge_method,
575 additional_claims: par_request
576 .additional_params
577 .into_iter()
578 .map(|(k, v)| (k, serde_json::Value::String(v)))
579 .collect(),
580 }
581 } else {
582 return Err(AuthError::InvalidRequest(
583 "request_uri provided but PAR not required".to_string(),
584 ));
585 }
586 } else {
587 if self.config.require_par {
589 return Err(AuthError::InvalidRequest(
590 "PAR is required but no request_uri provided".to_string(),
591 ));
592 }
593
594 self.validate_request_object(request_object).await?
596 };
597
598 if self.config.require_mtls {
600 let cert = client_cert.ok_or_else(|| {
601 AuthError::auth_method("mtls", "mTLS certificate required for FAPI 2.0")
602 })?;
603 let cert_bytes = decode_client_certificate(cert)?;
604 self.mtls_manager
605 .validate_client_certificate(&cert_bytes, &claims.client_id)
606 .await?;
607 }
608
609 if self.config.require_dpop {
611 let proof = dpop_proof.ok_or_else(|| {
612 AuthError::auth_method("dpop", "DPoP proof required for FAPI 2.0")
613 })?;
614 self.dpop_manager
615 .validate_dpop_proof(
616 proof,
617 "POST",
618 &format!("{}/authorize", self.config.issuer),
619 None,
620 None,
621 )
622 .await?;
623 }
624
625 self.validate_request_claims(&claims).await?;
627
628 Ok(claims)
629 }
630
631 async fn validate_request_object(&self, request_object: &str) -> Result<FapiRequestObject> {
633 let decoding_key = &self.config.public_key;
635
636 match self
638 .jwt_validator
639 .validate_token(request_object, decoding_key)
640 {
641 Ok(secure_claims) => {
642 let header = jsonwebtoken::decode_header(request_object).map_err(|e| {
644 AuthError::token(format!("Invalid request object header: {}", e))
645 })?;
646
647 if !matches!(
649 header.alg,
650 Algorithm::RS256 | Algorithm::PS256 | Algorithm::ES256
651 ) {
652 return Err(AuthError::token(
653 "Request object must use RS256, PS256, or ES256".to_string(),
654 ));
655 }
656
657 let mut validation = Validation::new(header.alg);
659 validation.set_audience(&[&self.config.issuer]);
660 validation.validate_exp = true;
661 validation.validate_nbf = true;
662
663 let token_data = jsonwebtoken::decode::<FapiRequestObject>(
665 request_object,
666 &self.config.public_key,
667 &validation,
668 )
669 .map_err(|e| {
670 AuthError::token(format!("Request object validation failed: {}", e))
671 })?;
672
673 let fapi_claims = token_data.claims;
674
675 if secure_claims.sub != fapi_claims.client_id {
678 return Err(AuthError::token(
679 "Subject mismatch between secure validation and FAPI claims".to_string(),
680 ));
681 }
682
683 if secure_claims.iss != fapi_claims.iss {
685 return Err(AuthError::token(
686 "Issuer mismatch between secure validation and FAPI claims".to_string(),
687 ));
688 }
689
690 if secure_claims.exp != fapi_claims.exp {
692 return Err(AuthError::token(
693 "Expiry mismatch between secure validation and FAPI claims".to_string(),
694 ));
695 }
696
697 let now = Utc::now().timestamp();
699
700 if now - fapi_claims.iat > self.config.max_request_age {
702 return Err(AuthError::token("Request object too old".to_string()));
703 }
704
705 if fapi_claims.client_id.is_empty() {
707 return Err(AuthError::token(
708 "client_id required in request object".to_string(),
709 ));
710 }
711
712 if fapi_claims.redirect_uri.is_empty() {
713 return Err(AuthError::token(
714 "redirect_uri required in request object".to_string(),
715 ));
716 }
717
718 if fapi_claims.response_type.is_empty() {
719 return Err(AuthError::token(
720 "response_type required in request object".to_string(),
721 ));
722 }
723
724 tracing::info!(
725 "FAPI request object validated successfully with SecureJwtValidator for client: {}",
726 fapi_claims.client_id
727 );
728
729 Ok(fapi_claims)
730 }
731 Err(e) => {
732 tracing::error!("SecureJwtValidator failed for FAPI request object: {}", e);
733 Err(AuthError::token(format!(
734 "Enhanced JWT validation failed: {}",
735 e
736 )))
737 }
738 }
739 }
740
741 async fn validate_request_claims(&self, claims: &FapiRequestObject) -> Result<()> {
743 if !matches!(claims.response_type.as_str(), "code" | "code id_token") {
745 return Err(AuthError::InvalidRequest(
746 "FAPI 2.0 requires code or code id_token response type".to_string(),
747 ));
748 }
749
750 if claims.code_challenge.is_none() {
752 return Err(AuthError::InvalidRequest(
753 "PKCE required for FAPI 2.0".to_string(),
754 ));
755 }
756
757 if let Some(method) = &claims.code_challenge_method {
758 if method != "S256" {
759 return Err(AuthError::InvalidRequest(
760 "FAPI 2.0 requires S256 code challenge method".to_string(),
761 ));
762 }
763 } else {
764 return Err(AuthError::InvalidRequest(
765 "code_challenge_method required for FAPI 2.0".to_string(),
766 ));
767 }
768
769 Ok(())
770 }
771
772 pub async fn authenticate_client_jwt(&self, client_assertion: &str) -> Result<String> {
777 const REFUSED: &str = "Client authentication failed";
778
779 let auth_result = match self
781 .private_key_jwt_manager
782 .authenticate_client(client_assertion)
783 .await
784 {
785 Ok(result) => result,
786 Err(e) => {
787 tracing::warn!("FAPI private key JWT assertion rejected: {}", e);
788 return Err(AuthError::auth_method("private_key_jwt", REFUSED));
789 }
790 };
791
792 if auth_result.authenticated {
793 tracing::info!(
794 "FAPI client authenticated successfully using private key JWT: {}",
795 auth_result.client_id
796 );
797 Ok(auth_result.client_id)
798 } else {
799 tracing::warn!(
800 "FAPI private key JWT authentication failed: {}",
801 auth_result.errors.join("; ")
802 );
803 Err(AuthError::auth_method("private_key_jwt", REFUSED))
804 }
805 }
806
807 pub async fn validate_token_request(
809 &self,
810 client_assertion: Option<&str>,
811 client_cert: Option<&str>,
812 dpop_proof: Option<&str>,
813 authorization_code: &str,
814 ) -> Result<String> {
815 let client_id = if let Some(assertion) = client_assertion {
817 self.authenticate_client_jwt(assertion).await?
818 } else if self.config.require_mtls {
819 if let Some(cert) = client_cert {
820 let cert_bytes = decode_client_certificate(cert)?;
821
822 let client_id = self.extract_client_id_from_certificate(&cert_bytes).await?;
825
826 self.mtls_manager
827 .validate_client_certificate(&cert_bytes, &client_id)
828 .await?;
829
830 client_id.to_string()
831 } else {
832 return Err(AuthError::auth_method(
833 "mtls",
834 "Client certificate required for FAPI 2.0 token request",
835 ));
836 }
837 } else {
838 return Err(AuthError::auth_method(
839 "fapi",
840 "FAPI 2.0 requires either private_key_jwt or mTLS client authentication",
841 ));
842 };
843
844 if self.config.require_dpop {
846 let proof = dpop_proof.ok_or_else(|| {
847 AuthError::auth_method("dpop", "DPoP proof required for FAPI 2.0 token request")
848 })?;
849 self.dpop_manager
850 .validate_dpop_proof(
851 proof,
852 "POST",
853 &format!("{}/token", self.config.issuer),
854 Some(authorization_code), None,
856 )
857 .await?;
858 }
859
860 Ok(client_id)
861 }
862
863 pub async fn generate_authorization_response(
865 &self,
866 client_id: &str,
867 code: Option<&str>,
868 state: Option<&str>,
869 error: Option<&str>,
870 error_description: Option<&str>,
871 ) -> Result<String> {
872 if !self.config.enable_jarm {
873 return Err(AuthError::Configuration {
874 message: "JARM not enabled".to_string(),
875 help: Some("Enable JARM in your configuration to use this feature".to_string()),
876 docs_url: Some("https://docs.auth-framework.com/fapi#jarm".to_string()),
877 source: None,
878 suggested_fix: Some("Set enable_jarm to true in your FAPIConfig".to_string()),
879 });
880 }
881
882 let now = Utc::now();
883 let exp = now + Duration::minutes(5); let response = FapiAuthorizationResponse {
886 iss: self.config.issuer.clone(),
887 aud: client_id.to_string(),
888 iat: now.timestamp(),
889 exp: exp.timestamp(),
890 code: code.map(|c| c.to_string()),
891 state: state.map(|s| s.to_string()),
892 error: error.map(|e| e.to_string()),
893 error_description: error_description.map(|d| d.to_string()),
894 additional_params: HashMap::new(),
895 };
896
897 let header = Header::new(self.config.response_signing_algorithm);
899
900 let token =
902 jsonwebtoken::encode(&header, &response, &self.config.private_key).map_err(|e| {
903 AuthError::TokenGeneration(format!("Failed to sign JARM response: {}", e))
904 })?;
905
906 Ok(token)
907 }
908
909 pub async fn generate_token_response(
911 &self,
912 client_id: &str,
913 user_id: &str,
914 scopes: Vec<String>,
915 cert_thumbprint: Option<String>,
916 dpop_jkt: Option<String>,
917 ) -> Result<FapiTokenResponse> {
918 let access_token = self
920 .generate_access_token(client_id, user_id, &scopes, &cert_thumbprint, &dpop_jkt)
921 .await?;
922
923 let refresh_token = self.generate_refresh_token(client_id, user_id).await?;
925
926 let mut cnf = json!({});
928
929 if let Some(thumbprint) = cert_thumbprint {
930 cnf["x5t#S256"] = Value::String(thumbprint);
931 }
932
933 if let Some(jkt) = dpop_jkt {
934 cnf["jkt"] = Value::String(jkt);
935 }
936
937 let response = FapiTokenResponse {
938 access_token,
939 token_type: "DPoP".to_string(), expires_in: 3600, refresh_token: Some(refresh_token),
942 scope: Some(scopes.join(" ")),
943 id_token: None, cnf: if cnf.as_object().is_none_or(|o| o.is_empty()) {
945 None
946 } else {
947 Some(cnf)
948 },
949 };
950
951 Ok(response)
952 }
953
954 async fn generate_access_token(
956 &self,
957 client_id: &str,
958 user_id: &str,
959 scopes: &[String],
960 cert_thumbprint: &Option<String>,
961 dpop_jkt: &Option<String>,
962 ) -> Result<String> {
963 let now = Utc::now();
964 let exp = now + Duration::hours(1);
965
966 let mut claims = json!({
967 "iss": self.config.issuer,
968 "aud": client_id,
969 "sub": user_id,
970 "iat": now.timestamp(),
971 "exp": exp.timestamp(),
972 "scope": scopes.join(" "),
973 "jti": Uuid::new_v4().to_string(),
974 });
975
976 let mut cnf = json!({});
978
979 if let Some(thumbprint) = cert_thumbprint {
980 cnf["x5t#S256"] = Value::String(thumbprint.clone());
981 }
982
983 if let Some(jkt) = dpop_jkt {
984 cnf["jkt"] = Value::String(jkt.clone());
985 }
986
987 if !cnf.as_object().is_none_or(|o| o.is_empty()) {
988 claims["cnf"] = cnf;
989 }
990
991 let header = Header::new(Algorithm::RS256);
993
994 let token =
996 jsonwebtoken::encode(&header, &claims, &self.config.private_key).map_err(|e| {
997 AuthError::TokenGeneration(format!("Failed to generate access token: {}", e))
998 })?;
999
1000 Ok(token)
1001 }
1002
1003 async fn generate_refresh_token(&self, client_id: &str, user_id: &str) -> Result<String> {
1005 let now = Utc::now();
1006 let exp = now + Duration::days(30); let claims = json!({
1009 "iss": self.config.issuer,
1010 "aud": client_id,
1011 "sub": user_id,
1012 "iat": now.timestamp(),
1013 "exp": exp.timestamp(),
1014 "typ": crate::security::secure_jwt::TYP_REFRESH_TOKEN,
1015 "jti": Uuid::new_v4().to_string(),
1016 });
1017
1018 let header = Header::new(Algorithm::RS256);
1020
1021 let token =
1023 jsonwebtoken::encode(&header, &claims, &self.config.private_key).map_err(|e| {
1024 AuthError::TokenGeneration(format!("Failed to generate refresh token: {}", e))
1025 })?;
1026
1027 Ok(token)
1028 }
1029
1030 pub async fn create_session(
1032 &self,
1033 client_id: &str,
1034 user_id: &str,
1035 scopes: Vec<String>,
1036 dpop_proof: Option<String>,
1037 cert_thumbprint: Option<String>,
1038 request_jti: Option<String>,
1039 ) -> Result<String> {
1040 let session_id = Uuid::new_v4().to_string();
1041 let now = Utc::now();
1042 let expires_at = now + Duration::hours(24); let session = FapiSession {
1045 session_id: session_id.clone(),
1046 client_id: client_id.to_string(),
1047 user_id: user_id.to_string(),
1048 created_at: now,
1049 expires_at,
1050 dpop_proof,
1051 cert_thumbprint,
1052 request_jti,
1053 scopes,
1054 metadata: HashMap::new(),
1055 };
1056
1057 let mut sessions = self.sessions.write().await;
1058 sessions.insert(session_id.clone(), session);
1059
1060 Ok(session_id)
1061 }
1062
1063 pub async fn get_session(&self, session_id: &str) -> Result<Option<FapiSession>> {
1065 let sessions = self.sessions.read().await;
1066 Ok(sessions.get(session_id).cloned())
1067 }
1068
1069 pub async fn validate_session(&self, session_id: &str) -> Result<FapiSession> {
1071 let session = self
1072 .get_session(session_id)
1073 .await?
1074 .ok_or_else(|| AuthError::validation("Session not found".to_string()))?;
1075
1076 if Utc::now() > session.expires_at {
1078 return Err(AuthError::validation("Session expired".to_string()));
1079 }
1080
1081 Ok(session)
1082 }
1083
1084 pub async fn remove_session(&self, session_id: &str) -> Result<()> {
1086 let mut sessions = self.sessions.write().await;
1087 sessions.remove(session_id);
1088 Ok(())
1089 }
1090
1091 pub async fn audit_log(&self, event: &str, details: &Value) -> Result<()> {
1093 if self.config.enhanced_audit {
1094 let timestamp = chrono::Utc::now().to_rfc3339();
1098 let audit_entry = format!("[{}] FAPI AUDIT: {} - {}", timestamp, event, details);
1099
1100 tracing::info!("{}", audit_entry);
1102 }
1103 Ok(())
1104 }
1105
1106 async fn extract_client_id_from_certificate(&self, cert_bytes: &[u8]) -> Result<String> {
1108 client_id_from_certificate(cert_bytes)
1109 }
1110
1111 pub fn check_compliance(&self) -> Vec<FapiComplianceViolation> {
1116 let mut violations = Vec::new();
1117
1118 if self.config.is_degraded {
1119 violations.push(FapiComplianceViolation {
1120 requirement: "crypto-keys".to_string(),
1121 severity: FapiViolationSeverity::Critical,
1122 message: "RSA key pair not properly configured; all FAPI operations will fail"
1123 .to_string(),
1124 });
1125 }
1126
1127 if !self.config.require_par {
1128 violations.push(FapiComplianceViolation {
1129 requirement: "par".to_string(),
1130 severity: FapiViolationSeverity::Critical,
1131 message: "FAPI 2.0 Security Profile requires Pushed Authorization Requests"
1132 .to_string(),
1133 });
1134 }
1135
1136 if !self.config.require_dpop {
1137 violations.push(FapiComplianceViolation {
1138 requirement: "sender-constraint".to_string(),
1139 severity: FapiViolationSeverity::Warning,
1140 message: "DPoP is recommended for sender-constrained tokens".to_string(),
1141 });
1142 }
1143
1144 if !self.config.require_mtls {
1145 violations.push(FapiComplianceViolation {
1146 requirement: "sender-constraint".to_string(),
1147 severity: FapiViolationSeverity::Warning,
1148 message: "mTLS is recommended for client authentication and token binding"
1149 .to_string(),
1150 });
1151 }
1152
1153 if !self.config.require_dpop && !self.config.require_mtls {
1154 violations.push(FapiComplianceViolation {
1155 requirement: "sender-constraint".to_string(),
1156 severity: FapiViolationSeverity::Critical,
1157 message:
1158 "FAPI 2.0 requires at least one sender-constraining mechanism (DPoP or mTLS)"
1159 .to_string(),
1160 });
1161 }
1162
1163 if !self.config.enable_jarm {
1164 violations.push(FapiComplianceViolation {
1165 requirement: "jarm".to_string(),
1166 severity: FapiViolationSeverity::Warning,
1167 message: "JARM is recommended for authorization response integrity".to_string(),
1168 });
1169 }
1170
1171 if !self.config.enhanced_audit {
1172 violations.push(FapiComplianceViolation {
1173 requirement: "audit".to_string(),
1174 severity: FapiViolationSeverity::Warning,
1175 message: "Enhanced audit logging is recommended for FAPI compliance".to_string(),
1176 });
1177 }
1178
1179 if !matches!(
1180 self.config.request_signing_algorithm,
1181 Algorithm::RS256 | Algorithm::PS256 | Algorithm::ES256
1182 ) {
1183 violations.push(FapiComplianceViolation {
1184 requirement: "algorithm".to_string(),
1185 severity: FapiViolationSeverity::Critical,
1186 message: "Request signing must use RS256, PS256, or ES256".to_string(),
1187 });
1188 }
1189
1190 if self.config.max_request_age > 600 {
1191 violations.push(FapiComplianceViolation {
1192 requirement: "request-lifetime".to_string(),
1193 severity: FapiViolationSeverity::Warning,
1194 message: "Max request age exceeds recommended 10 minutes".to_string(),
1195 });
1196 }
1197
1198 violations
1199 }
1200
1201 pub fn is_compliant(&self) -> bool {
1203 !self
1204 .check_compliance()
1205 .iter()
1206 .any(|v| matches!(v.severity, FapiViolationSeverity::Critical))
1207 }
1208
1209 pub async fn validate_sender_constrained_token(
1214 &self,
1215 access_token: &str,
1216 dpop_proof: Option<&str>,
1217 client_cert: Option<&str>,
1218 http_method: &str,
1219 http_uri: &str,
1220 ) -> Result<serde_json::Value> {
1221 let token_data = self
1223 .jwt_validator
1224 .validate_token(access_token, &self.config.public_key)?;
1225
1226 let header = jsonwebtoken::decode_header(access_token)
1228 .map_err(|e| AuthError::token(format!("Invalid token header: {}", e)))?;
1229 let mut validation = Validation::new(header.alg);
1230 validation.set_audience(&[&self.config.issuer]);
1231 validation.validate_exp = true;
1232 let raw_claims = jsonwebtoken::decode::<serde_json::Value>(
1233 access_token,
1234 &self.config.public_key,
1235 &validation,
1236 )
1237 .map_err(|e| AuthError::token(format!("Token decode failed: {}", e)))?;
1238
1239 let cnf = raw_claims.claims.get("cnf").ok_or_else(|| {
1241 AuthError::token("Token is not sender-constrained (missing cnf claim)".to_string())
1242 })?;
1243
1244 if let Some(expected_jkt) = cnf.get("jkt").and_then(|v| v.as_str()) {
1246 let proof = dpop_proof.ok_or_else(|| {
1247 AuthError::token(
1248 "Token is DPoP-bound but no DPoP proof header provided".to_string(),
1249 )
1250 })?;
1251 self.dpop_manager
1252 .validate_dpop_proof(proof, http_method, http_uri, None, Some(expected_jkt))
1253 .await?;
1254 }
1255
1256 if let Some(expected_thumbprint) = cnf.get("x5t#S256").and_then(|v| v.as_str()) {
1258 let cert = client_cert.ok_or_else(|| {
1259 AuthError::token(
1260 "Token is certificate-bound but no client certificate provided".to_string(),
1261 )
1262 })?;
1263 use base64::Engine;
1265 use sha2::{Digest, Sha256};
1266 let cert_der = decode_client_certificate(cert)?;
1267 let presented_thumbprint =
1268 base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(Sha256::digest(&cert_der));
1269 if !bool::from(subtle::ConstantTimeEq::ct_eq(
1270 presented_thumbprint.as_bytes(),
1271 expected_thumbprint.as_bytes(),
1272 )) {
1273 return Err(AuthError::token(
1274 "Certificate thumbprint does not match token binding".to_string(),
1275 ));
1276 }
1277 }
1278
1279 Ok(serde_json::json!({
1281 "sub": token_data.sub,
1282 "iss": token_data.iss,
1283 "exp": token_data.exp,
1284 "scope": token_data.scope,
1285 }))
1286 }
1287
1288 pub fn validate_authorization_details(
1290 &self,
1291 authorization_details: &[AuthorizationDetail],
1292 ) -> Result<()> {
1293 if authorization_details.is_empty() {
1294 return Err(AuthError::InvalidRequest(
1295 "authorization_details must not be empty".to_string(),
1296 ));
1297 }
1298
1299 for (i, detail) in authorization_details.iter().enumerate() {
1300 if detail.r#type.is_empty() {
1301 return Err(AuthError::InvalidRequest(format!(
1302 "authorization_details[{}]: type is required",
1303 i
1304 )));
1305 }
1306
1307 for location in &detail.locations {
1309 if !location.starts_with("https://") {
1310 return Err(AuthError::InvalidRequest(format!(
1311 "authorization_details[{}]: location must use HTTPS: {}",
1312 i, location
1313 )));
1314 }
1315 }
1316
1317 for action in &detail.actions {
1319 if action.is_empty() {
1320 return Err(AuthError::InvalidRequest(format!(
1321 "authorization_details[{}]: empty action not allowed",
1322 i
1323 )));
1324 }
1325 }
1326 }
1327
1328 Ok(())
1329 }
1330}
1331
1332#[derive(Debug, Clone)]
1334pub struct FapiComplianceViolation {
1335 pub requirement: String,
1337 pub severity: FapiViolationSeverity,
1339 pub message: String,
1341}
1342
1343#[derive(Debug, Clone, PartialEq, Eq)]
1345pub enum FapiViolationSeverity {
1346 Critical,
1348 Warning,
1350}
1351
1352#[derive(Debug, Clone, Serialize, Deserialize)]
1354pub struct AuthorizationDetail {
1355 pub r#type: String,
1357
1358 #[serde(default)]
1360 pub locations: Vec<String>,
1361
1362 #[serde(default)]
1364 pub actions: Vec<String>,
1365
1366 #[serde(default)]
1368 pub datatypes: Vec<String>,
1369
1370 #[serde(skip_serializing_if = "Option::is_none")]
1372 pub identifier: Option<String>,
1373
1374 #[serde(flatten)]
1376 pub additional_fields: HashMap<String, Value>,
1377}
1378
1379impl Default for FapiConfig {
1380 fn default() -> Self {
1381 let issuer =
1383 std::env::var("FAPI_ISSUER").unwrap_or_else(|_| "https://auth.example.com".to_string());
1384
1385 let mut is_degraded = false;
1386
1387 let private_key = if let Ok(key_path) = std::env::var("FAPI_PRIVATE_KEY_PATH") {
1391 std::fs::read(&key_path)
1392 .map_err(|e| tracing::warn!("Failed to load private key from {}: {}", key_path, e))
1393 .and_then(|bytes| {
1394 EncodingKey::from_rsa_pem(&bytes)
1395 .map_err(|e| tracing::warn!("Invalid RSA key format: {}", e))
1396 })
1397 .unwrap_or_else(|_| {
1398 tracing::error!(
1399 "SECURITY CRITICAL: FAPI_PRIVATE_KEY_PATH is set but the key could not \
1400 be loaded. FAPI REQUIRES an RSA private key for request/response signing. \
1401 Using an ephemeral HMAC placeholder — ALL FAPI OPERATIONS WILL BE REJECTED \
1402 until a valid RSA key is provided. Set FAPI_PRIVATE_KEY_PATH to a valid \
1403 PEM-encoded RSA private key file."
1404 );
1405 is_degraded = true;
1406 use ring::rand::{SecureRandom, SystemRandom};
1407 let rng = SystemRandom::new();
1408 let mut bytes = [0u8; 32];
1409 rng.fill(&mut bytes).expect("AuthFramework fatal: system CSPRNG unavailable — the operating system cannot provide cryptographic randomness");
1410 EncodingKey::from_secret(&bytes)
1411 })
1412 } else {
1413 tracing::error!(
1414 "SECURITY CRITICAL: FAPI_PRIVATE_KEY_PATH not set. FAPI REQUIRES an RSA \
1415 private key for request and response signing. Using an ephemeral HMAC \
1416 placeholder — ALL FAPI OPERATIONS WILL BE REJECTED until a valid RSA key \
1417 is provided. Set FAPI_PRIVATE_KEY_PATH to a PEM-encoded RSA private key file."
1418 );
1419 is_degraded = true;
1420 use ring::rand::{SecureRandom, SystemRandom};
1421 let rng = SystemRandom::new();
1422 let mut bytes = [0u8; 32];
1423 rng.fill(&mut bytes).expect("AuthFramework fatal: system CSPRNG unavailable — the operating system cannot provide cryptographic randomness");
1424 EncodingKey::from_secret(&bytes)
1425 };
1426
1427 let public_key = if let Ok(key_path) = std::env::var("FAPI_PUBLIC_KEY_PATH") {
1429 std::fs::read(&key_path)
1430 .map_err(|e| tracing::warn!("Failed to load public key from {}: {}", key_path, e))
1431 .and_then(|bytes| {
1432 DecodingKey::from_rsa_pem(&bytes)
1433 .map_err(|e| tracing::warn!("Invalid RSA public key format: {}", e))
1434 })
1435 .unwrap_or_else(|_| {
1436 tracing::error!(
1437 "SECURITY CRITICAL: FAPI_PUBLIC_KEY_PATH is set but the key could not \
1438 be loaded. FAPI verification will not work correctly."
1439 );
1440 is_degraded = true;
1441 use ring::rand::{SecureRandom, SystemRandom};
1442 let rng = SystemRandom::new();
1443 let mut secret = [0u8; 32];
1444 rng.fill(&mut secret).expect("AuthFramework fatal: system CSPRNG unavailable — the operating system cannot provide cryptographic randomness");
1445 DecodingKey::from_secret(&secret)
1446 })
1447 } else {
1448 tracing::error!(
1449 "SECURITY CRITICAL: FAPI_PUBLIC_KEY_PATH not set. FAPI verification will \
1450 not work correctly. Set FAPI_PUBLIC_KEY_PATH to a PEM-encoded RSA public key file."
1451 );
1452 is_degraded = true;
1453 use ring::rand::{SecureRandom, SystemRandom};
1454 let rng = SystemRandom::new();
1455 let mut secret = [0u8; 32];
1456 rng.fill(&mut secret).expect("AuthFramework fatal: system CSPRNG unavailable — the operating system cannot provide cryptographic randomness");
1457 DecodingKey::from_secret(&secret)
1458 };
1459
1460 Self {
1461 issuer,
1462 request_signing_algorithm: Algorithm::RS256,
1463 response_signing_algorithm: Algorithm::RS256,
1464 private_key,
1465 public_key,
1466 max_request_age: 300, require_dpop: true,
1468 require_mtls: true,
1469 require_par: true,
1470 enable_jarm: true,
1471 enhanced_audit: true,
1472 is_degraded,
1473 }
1474 }
1475}
1476
1477fn decode_client_certificate(input: &str) -> Result<Vec<u8>> {
1482 use base64::Engine;
1483 use base64::engine::general_purpose::{STANDARD, STANDARD_NO_PAD, URL_SAFE, URL_SAFE_NO_PAD};
1484
1485 const BEGIN: &str = "-----BEGIN CERTIFICATE-----";
1486 const END: &str = "-----END CERTIFICATE-----";
1487 let bad = || {
1488 AuthError::auth_method(
1489 "mtls",
1490 "Client certificate must be PEM or base64-encoded DER",
1491 )
1492 };
1493
1494 let trimmed = input.trim();
1495 let body = if let Some(rest) = trimmed.strip_prefix(BEGIN) {
1496 let end = rest.find(END).ok_or_else(bad)?;
1497 if !rest[end + END.len()..].trim().is_empty() {
1499 return Err(bad());
1500 }
1501 &rest[..end]
1502 } else {
1503 trimmed
1504 };
1505 let compact: String = body.chars().filter(|c| !c.is_whitespace()).collect();
1506 if compact.is_empty() {
1507 return Err(bad());
1508 }
1509 STANDARD
1510 .decode(&compact)
1511 .or_else(|_| STANDARD_NO_PAD.decode(&compact))
1512 .or_else(|_| URL_SAFE.decode(&compact))
1513 .or_else(|_| URL_SAFE_NO_PAD.decode(&compact))
1514 .map_err(|_| bad())
1515}
1516
1517fn client_id_from_certificate(cert_der: &[u8]) -> Result<String> {
1520 use x509_parser::extensions::GeneralName;
1521
1522 let cert = match x509_parser::parse_x509_certificate(cert_der) {
1523 Ok(([], cert)) => cert,
1524 _ => {
1525 return Err(AuthError::auth_method(
1526 "mtls",
1527 "Invalid client certificate format",
1528 ));
1529 }
1530 };
1531
1532 let common_names: Vec<String> = cert
1533 .subject()
1534 .iter_common_name()
1535 .filter_map(|cn| cn.as_str().ok().map(str::to_string))
1536 .collect();
1537 if common_names.len() == 1 && !common_names[0].is_empty() {
1538 return Ok(common_names[0].clone());
1539 }
1540
1541 if let Ok(Some(san)) = cert.subject_alternative_name() {
1542 let names: Vec<String> = san
1543 .value
1544 .general_names
1545 .iter()
1546 .filter_map(|name| match name {
1547 GeneralName::DNSName(dns) => Some(dns.to_string()),
1548 GeneralName::URI(uri) => Some(uri.to_string()),
1549 _ => None,
1550 })
1551 .collect();
1552 if names.len() == 1 {
1553 return Ok(names[0].clone());
1554 }
1555 }
1556
1557 Err(AuthError::auth_method(
1558 "mtls",
1559 "Cannot derive a unique client id from the certificate (need one subject CN or one SAN)",
1560 ))
1561}
1562
1563#[cfg(test)]
1564mod tests {
1565 use super::*;
1566
1567 #[test]
1568 fn test_fapi_config_builder() {
1569 use ring::rand::{SecureRandom, SystemRandom};
1570 let rng = SystemRandom::new();
1571 let mut bytes = [0u8; 32];
1572 rng.fill(&mut bytes).unwrap();
1573 let private_key = EncodingKey::from_secret(&bytes);
1574 let public_key = DecodingKey::from_secret(&bytes);
1575
1576 let config = FapiConfig::builder("https://fapi.example.com", private_key, public_key)
1577 .request_signing_algorithm(Algorithm::ES256)
1578 .max_request_age(120)
1579 .require_dpop(false)
1580 .degraded()
1581 .build();
1582
1583 assert_eq!(config.issuer, "https://fapi.example.com");
1584 assert_eq!(config.request_signing_algorithm, Algorithm::ES256);
1585 assert_eq!(config.max_request_age, 120);
1586 assert!(!config.require_dpop);
1587 assert!(config.require_mtls); assert!(config.is_degraded);
1589 }
1590
1591 #[test]
1592 fn test_fapi_session_builder() {
1593 let session = FapiSession::builder(
1594 "sess_123",
1595 "client_456",
1596 "user_789",
1597 Duration::try_hours(1).unwrap(),
1598 )
1599 .dpop_proof("proof_abc")
1600 .add_scope("openid")
1601 .add_scopes(vec!["profile", "email"])
1602 .add_metadata("custom_flag", json!(true))
1603 .build();
1604
1605 assert_eq!(session.session_id, "sess_123");
1606 assert_eq!(session.client_id, "client_456");
1607 assert_eq!(session.user_id, "user_789");
1608 assert_eq!(session.dpop_proof.as_deref(), Some("proof_abc"));
1609 assert_eq!(session.scopes, vec!["openid", "profile", "email"]);
1610 assert_eq!(session.metadata["custom_flag"], true);
1611 }
1612
1613 #[tokio::test]
1614 async fn private_key_jwt_failures_do_not_tell_the_caller_why() {
1615 use crate::security::secure_jwt::SecureJwtConfig;
1616 use crate::server::jwt::private_key_jwt::ClientJwtConfig;
1617 use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD};
1618
1619 let validator = || SecureJwtValidator::new(SecureJwtConfig::default()).unwrap();
1620 let assertions = Arc::new(PrivateKeyJwtManager::new(validator()));
1621 let manager = FapiManager::new(
1622 FapiConfig::default(),
1623 Arc::new(DpopManager::new(validator())),
1624 Arc::new(MutualTlsManager::new()),
1625 Arc::new(PARManager::new(Arc::new(
1626 crate::storage::MemoryStorage::new(),
1627 ))),
1628 assertions.clone(),
1629 Arc::new(validator()),
1630 );
1631
1632 let key = rcgen::KeyPair::generate_for(&rcgen::PKCS_ECDSA_P256_SHA256).unwrap();
1634 let raw = key.public_key_raw();
1635 let point = &raw[raw.len() - 65..];
1636 let jwk = json!({
1637 "kty": "EC", "crv": "P-256",
1638 "x": URL_SAFE_NO_PAD.encode(&point[1..33]),
1639 "y": URL_SAFE_NO_PAD.encode(&point[33..65]),
1640 });
1641 assertions
1642 .register_client(
1643 ClientJwtConfig::builder("fapi-client", jwk)
1644 .algorithms(vec![Algorithm::ES256])
1645 .audience("https://auth.example.com/token")
1646 .build(),
1647 )
1648 .await
1649 .unwrap();
1650 let encoding_key = EncodingKey::from_ec_pem(key.serialize_pem().as_bytes()).unwrap();
1651
1652 let good = assertions
1654 .create_client_assertion(
1655 "fapi-client",
1656 "https://auth.example.com/token",
1657 &encoding_key,
1658 Algorithm::ES256,
1659 )
1660 .unwrap();
1661 assert_eq!(
1662 manager.authenticate_client_jwt(&good).await.unwrap(),
1663 "fapi-client"
1664 );
1665
1666 let wrong_audience = assertions
1669 .create_client_assertion(
1670 "fapi-client",
1671 "https://elsewhere.example/token",
1672 &encoding_key,
1673 Algorithm::ES256,
1674 )
1675 .unwrap();
1676 let unknown = assertions
1677 .create_client_assertion(
1678 "ghost",
1679 "https://auth.example.com/token",
1680 &encoding_key,
1681 Algorithm::ES256,
1682 )
1683 .unwrap();
1684 for (why, assertion) in [
1685 ("wrong audience", wrong_audience.as_str()),
1686 ("unknown client", unknown.as_str()),
1687 ("replay", good.as_str()),
1688 ("junk", "not-a-jwt"),
1689 ] {
1690 let message = manager
1691 .authenticate_client_jwt(assertion)
1692 .await
1693 .expect_err(why)
1694 .to_string();
1695 assert!(
1696 message.contains("Client authentication failed"),
1697 "{why}: {message}"
1698 );
1699 for leak in [
1700 "udience",
1701 "registered",
1702 "ignature",
1703 "replay",
1704 "JTI",
1705 "Algorithm",
1706 "expired",
1707 ] {
1708 assert!(
1709 !message.contains(leak),
1710 "{why}: {message:?} mentions {leak:?}"
1711 );
1712 }
1713 }
1714 }
1715
1716 #[tokio::test]
1717 async fn test_fapi_manager_creation() {
1718 let config = FapiConfig::default();
1720
1721 assert_eq!(config.issuer, "https://auth.example.com"); assert!(config.require_dpop);
1724 assert!(config.require_mtls);
1725 assert!(config.require_par);
1726 assert!(config.enable_jarm);
1727 assert!(config.enhanced_audit);
1728 }
1729
1730 #[tokio::test]
1731 async fn test_fapi_request_validation() {
1732 let config = FapiConfig::default();
1735
1736 let request_object = r#"{"iss":"client_id","aud":"https://example.com","exp":9999999999,"nbf":1000000000,"iat":1000000000,"jti":"unique_id"}"#;
1738
1739 let validation_result = validate_fapi_request_object(request_object, &config);
1741 assert!(
1742 validation_result.is_ok(),
1743 "FAPI request object validation failed"
1744 );
1745
1746 assert!(!request_object.is_empty());
1748 }
1749
1750 fn validate_fapi_request_object(
1752 request_object: &str,
1753 _config: &FapiConfig,
1754 ) -> Result<(), String> {
1755 let parsed: serde_json::Value = serde_json::from_str(request_object)
1757 .map_err(|_| "Invalid JSON structure in request object")?;
1758
1759 let required_claims = ["iss", "aud", "exp", "iat", "jti"];
1761 for claim in &required_claims {
1762 if parsed.get(claim).is_none() {
1763 return Err(format!("Missing required FAPI claim: {}", claim));
1764 }
1765 }
1766
1767 if let Some(exp) = parsed.get("exp").and_then(|v| v.as_i64()) {
1769 let now = chrono::Utc::now().timestamp();
1770 if exp <= now {
1771 return Err("Request object has expired".to_string());
1772 }
1773 }
1774
1775 Ok(())
1778 }
1779
1780 #[tokio::test]
1781 async fn test_fapi_response_generation() {
1782 let config = FapiConfig::default();
1785
1786 let auth_response = serde_json::json!({
1788 "code": "auth_code_123",
1789 "state": "client_state",
1790 "iss": config.issuer,
1791 "aud": "client_id",
1792 "exp": 9999999999i64
1793 });
1794
1795 assert!(auth_response["code"].is_string());
1797 }
1798
1799 #[tokio::test]
1800 async fn test_fapi_token_generation() {
1801 let config = FapiConfig::default();
1803
1804 let scopes = ["accounts".to_string(), "payments".to_string()];
1806 let client_id = "fapi_client_123";
1807 let user_id = "user_456";
1808 let cert_thumbprint = Some("sha256_cert_thumbprint".to_string());
1809
1810 assert!(config.require_dpop);
1812 assert!(config.require_mtls);
1813 assert!(!scopes.is_empty());
1814 assert!(!client_id.is_empty());
1815 assert!(!user_id.is_empty());
1816 assert!(cert_thumbprint.is_some());
1817 }
1818
1819 #[tokio::test]
1820 async fn test_fapi_session_management() {
1821 let config = FapiConfig::default();
1823
1824 let session_data = serde_json::json!({
1826 "client_id": "fapi_client",
1827 "user_id": "fapi_user",
1828 "scopes": ["accounts", "payments"],
1829 "mtls_cert": "client_certificate",
1830 "dpop_key": "client_dpop_key"
1831 });
1832
1833 assert!(session_data["mtls_cert"].is_string());
1835 assert!(session_data["dpop_key"].is_string());
1836 assert!(config.enhanced_audit);
1837 }
1838
1839 fn test_cert(cn: &str, org: Option<&str>) -> rcgen::Certificate {
1842 let mut params = rcgen::CertificateParams::new(Vec::<String>::new()).unwrap();
1843 let mut dn = rcgen::DistinguishedName::new();
1844 dn.push(rcgen::DnType::CommonName, cn);
1845 if let Some(org) = org {
1846 dn.push(rcgen::DnType::OrganizationName, org);
1847 }
1848 params.distinguished_name = dn;
1849 let key = rcgen::KeyPair::generate().unwrap();
1850 params.self_signed(&key).unwrap()
1851 }
1852
1853 #[test]
1854 fn decode_client_certificate_accepts_pem_and_base64_der() {
1855 use base64::Engine;
1856 let cert = test_cert("client-a", None);
1857 let der = cert.der().to_vec();
1858
1859 assert_eq!(decode_client_certificate(&cert.pem()).unwrap(), der);
1860 let b64 = base64::engine::general_purpose::STANDARD.encode(&der);
1861 assert_eq!(decode_client_certificate(&b64).unwrap(), der);
1862 let wrapped = format!(" {}\n{} \n", &b64[..20], &b64[20..]);
1863 assert_eq!(decode_client_certificate(&wrapped).unwrap(), der);
1864 }
1865
1866 #[test]
1867 fn decode_client_certificate_rejects_garbage_and_extra_certificates() {
1868 let a = test_cert("client-a", None).pem();
1869 let b = test_cert("client-b", None).pem();
1870 assert!(decode_client_certificate("").is_err());
1871 assert!(decode_client_certificate("!!! not base64 !!!").is_err());
1872 assert!(decode_client_certificate("-----BEGIN CERTIFICATE-----\nAAAA").is_err());
1873 assert!(decode_client_certificate(&format!("{a}{b}")).is_err());
1875 }
1876
1877 #[test]
1878 fn client_id_comes_from_the_parsed_subject_cn() {
1879 let cert = test_cert("client-a", None);
1880 assert_eq!(client_id_from_certificate(cert.der()).unwrap(), "client-a");
1881 }
1882
1883 #[test]
1884 fn client_id_is_not_found_by_searching_the_raw_bytes() {
1885 let cert = test_cert("real-client", Some("CN=victim-client,"));
1888 assert_eq!(
1889 client_id_from_certificate(cert.der()).unwrap(),
1890 "real-client"
1891 );
1892 }
1893
1894 #[test]
1895 fn client_id_needs_a_unique_identity() {
1896 let mut params = rcgen::CertificateParams::new(Vec::<String>::new()).unwrap();
1898 params.distinguished_name = rcgen::DistinguishedName::new(); let key = rcgen::KeyPair::generate().unwrap();
1900 let nameless = params.self_signed(&key).unwrap();
1901 assert!(client_id_from_certificate(nameless.der()).is_err());
1902 assert!(client_id_from_certificate(b"not a certificate").is_err());
1903 }
1904}