1use crate::errors::{AuthError, Result};
25use crate::security::secure_jwt::SecureJwtValidator;
26use crate::server::{DpopManager, MutualTlsManager, PARManager, PrivateKeyJwtManager};
27use chrono::{DateTime, Duration, Utc};
28use jsonwebtoken::{Algorithm, DecodingKey, EncodingKey, Header, Validation};
29use serde::{Deserialize, Serialize};
30use serde_json::{Value, json};
31use std::collections::HashMap;
32use std::sync::Arc;
33use tokio::sync::RwLock;
34use uuid::Uuid;
35
36#[derive(Debug, Clone)]
38pub struct FapiManager {
39 dpop_manager: Arc<DpopManager>,
41
42 mtls_manager: Arc<MutualTlsManager>,
44
45 par_manager: Arc<PARManager>,
47
48 private_key_jwt_manager: Arc<PrivateKeyJwtManager>,
50
51 jwt_validator: Arc<SecureJwtValidator>,
53
54 config: FapiConfig,
56
57 sessions: Arc<RwLock<HashMap<String, FapiSession>>>,
59}
60
61#[derive(Clone)]
63pub struct FapiConfig {
64 pub issuer: String,
66
67 pub request_signing_algorithm: Algorithm,
69
70 pub response_signing_algorithm: Algorithm,
72
73 pub private_key: EncodingKey,
75
76 pub public_key: DecodingKey,
78
79 pub max_request_age: i64,
81
82 pub require_dpop: bool,
84
85 pub require_mtls: bool,
87
88 pub require_par: bool,
90
91 pub enable_jarm: bool,
93
94 pub enhanced_audit: bool,
96}
97
98impl std::fmt::Debug for FapiConfig {
99 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
100 f.debug_struct("FapiConfig")
101 .field("issuer", &self.issuer)
102 .field("request_signing_algorithm", &self.request_signing_algorithm)
103 .field(
104 "response_signing_algorithm",
105 &self.response_signing_algorithm,
106 )
107 .field("private_key", &"<EncodingKey>")
108 .field("public_key", &"<DecodingKey>")
109 .field("max_request_age", &self.max_request_age)
110 .field("require_dpop", &self.require_dpop)
111 .field("require_mtls", &self.require_mtls)
112 .field("require_par", &self.require_par)
113 .field("enable_jarm", &self.enable_jarm)
114 .field("enhanced_audit", &self.enhanced_audit)
115 .finish()
116 }
117}
118
119#[derive(Debug, Clone, Serialize, Deserialize)]
121pub struct FapiSession {
122 pub session_id: String,
124
125 pub client_id: String,
127
128 pub user_id: String,
130
131 pub created_at: DateTime<Utc>,
133
134 pub expires_at: DateTime<Utc>,
136
137 pub dpop_proof: Option<String>,
139
140 pub cert_thumbprint: Option<String>,
142
143 pub request_jti: Option<String>,
145
146 pub scopes: Vec<String>,
148
149 pub metadata: HashMap<String, Value>,
151}
152
153#[derive(Debug, Clone, Serialize, Deserialize)]
155pub struct FapiRequestObject {
156 pub iss: String,
158
159 pub aud: String,
161
162 pub iat: i64,
164
165 pub exp: i64,
167
168 pub nbf: Option<i64>,
170
171 pub jti: String,
173
174 pub response_type: String,
176
177 pub client_id: String,
179
180 pub redirect_uri: String,
182
183 pub scope: String,
185
186 pub state: Option<String>,
188
189 pub nonce: Option<String>,
191
192 pub code_challenge: Option<String>,
194
195 pub code_challenge_method: Option<String>,
197
198 #[serde(flatten)]
200 pub additional_claims: HashMap<String, Value>,
201}
202
203#[derive(Debug, Clone, Serialize, Deserialize)]
205pub struct FapiAuthorizationResponse {
206 pub iss: String,
208
209 pub aud: String,
211
212 pub iat: i64,
214
215 pub exp: i64,
217
218 pub code: Option<String>,
220
221 pub state: Option<String>,
223
224 pub error: Option<String>,
226
227 pub error_description: Option<String>,
229
230 #[serde(flatten)]
232 pub additional_params: HashMap<String, Value>,
233}
234
235#[derive(Debug, Clone, Serialize, Deserialize)]
237pub struct FapiTokenResponse {
238 pub access_token: String,
240
241 pub token_type: String,
243
244 pub expires_in: i64,
246
247 pub refresh_token: Option<String>,
249
250 pub scope: Option<String>,
252
253 pub id_token: Option<String>,
255
256 pub cnf: Option<Value>,
258}
259
260impl FapiManager {
261 pub fn new(
263 config: FapiConfig,
264 dpop_manager: Arc<DpopManager>,
265 mtls_manager: Arc<MutualTlsManager>,
266 par_manager: Arc<PARManager>,
267 private_key_jwt_manager: Arc<PrivateKeyJwtManager>,
268 jwt_validator: Arc<SecureJwtValidator>,
269 ) -> Self {
270 Self {
271 dpop_manager,
272 mtls_manager,
273 par_manager,
274 private_key_jwt_manager,
275 jwt_validator,
276 config,
277 sessions: Arc::new(RwLock::new(HashMap::new())),
278 }
279 }
280
281 pub async fn validate_authorization_request(
283 &self,
284 request_object: &str,
285 client_cert: Option<&str>,
286 dpop_proof: Option<&str>,
287 request_uri: Option<&str>,
288 ) -> Result<FapiRequestObject> {
289 let claims = if let Some(uri) = request_uri {
290 if self.config.require_par {
292 let par_request = self.par_manager.consume_request(uri).await.map_err(|e| {
294 AuthError::InvalidRequest(format!("PAR request validation failed: {}", e))
295 })?;
296
297 tracing::info!(
298 "FAPI PAR request consumed successfully for client: {}",
299 par_request.client_id
300 );
301
302 FapiRequestObject {
305 iss: par_request.client_id.clone(),
306 aud: self.config.issuer.clone(),
307 iat: Utc::now().timestamp(),
308 exp: Utc::now().timestamp() + 300, nbf: Some(Utc::now().timestamp()),
310 jti: uuid::Uuid::new_v4().to_string(),
311 response_type: par_request.response_type,
312 client_id: par_request.client_id,
313 redirect_uri: par_request.redirect_uri,
314 scope: par_request.scope.unwrap_or_default(),
315 state: par_request.state,
316 nonce: None, code_challenge: par_request.code_challenge,
318 code_challenge_method: par_request.code_challenge_method,
319 additional_claims: par_request
320 .additional_params
321 .into_iter()
322 .map(|(k, v)| (k, serde_json::Value::String(v)))
323 .collect(),
324 }
325 } else {
326 return Err(AuthError::InvalidRequest(
327 "request_uri provided but PAR not required".to_string(),
328 ));
329 }
330 } else {
331 if self.config.require_par {
333 return Err(AuthError::InvalidRequest(
334 "PAR is required but no request_uri provided".to_string(),
335 ));
336 }
337
338 self.validate_request_object(request_object).await?
340 };
341
342 if self.config.require_mtls {
344 let cert = client_cert.ok_or_else(|| {
345 AuthError::auth_method("mtls", "mTLS certificate required for FAPI 2.0")
346 })?;
347 let cert_bytes = decode_client_certificate(cert)?;
348 self.mtls_manager
349 .validate_client_certificate(&cert_bytes, &claims.client_id)
350 .await?;
351 }
352
353 if self.config.require_dpop {
355 if dpop_proof.is_none() {
356 return Err(AuthError::auth_method(
357 "dpop",
358 "DPoP proof required for FAPI 2.0",
359 ));
360 }
361
362 let proof = dpop_proof.unwrap();
363 self.dpop_manager
364 .validate_dpop_proof(
365 proof,
366 "POST",
367 &format!("{}/authorize", self.config.issuer),
368 None,
369 None,
370 )
371 .await?;
372 }
373
374 self.validate_request_claims(&claims).await?;
376
377 Ok(claims)
378 }
379
380 async fn validate_request_object(&self, request_object: &str) -> Result<FapiRequestObject> {
382 let decoding_key = &self.config.public_key;
384
385 match self
387 .jwt_validator
388 .validate_token(request_object, decoding_key, true)
389 {
390 Ok(secure_claims) => {
391 let header = jsonwebtoken::decode_header(request_object).map_err(|e| {
393 AuthError::InvalidToken(format!("Invalid request object header: {}", e))
394 })?;
395
396 if !matches!(
398 header.alg,
399 Algorithm::RS256 | Algorithm::PS256 | Algorithm::ES256
400 ) {
401 return Err(AuthError::InvalidToken(
402 "Request object must use RS256, PS256, or ES256".to_string(),
403 ));
404 }
405
406 let mut validation = Validation::new(header.alg);
408 validation.set_audience(&[&self.config.issuer]);
409 validation.validate_exp = true;
410 validation.validate_nbf = true;
411
412 let token_data = jsonwebtoken::decode::<FapiRequestObject>(
414 request_object,
415 &self.config.public_key,
416 &validation,
417 )
418 .map_err(|e| {
419 AuthError::InvalidToken(format!("Request object validation failed: {}", e))
420 })?;
421
422 let fapi_claims = token_data.claims;
423
424 if secure_claims.sub != fapi_claims.client_id {
427 return Err(AuthError::InvalidToken(
428 "Subject mismatch between secure validation and FAPI claims".to_string(),
429 ));
430 }
431
432 if secure_claims.iss != fapi_claims.iss {
434 return Err(AuthError::InvalidToken(
435 "Issuer mismatch between secure validation and FAPI claims".to_string(),
436 ));
437 }
438
439 if secure_claims.exp != fapi_claims.exp {
441 return Err(AuthError::InvalidToken(
442 "Expiry mismatch between secure validation and FAPI claims".to_string(),
443 ));
444 }
445
446 let now = Utc::now().timestamp();
448
449 if now - fapi_claims.iat > self.config.max_request_age {
451 return Err(AuthError::InvalidToken(
452 "Request object too old".to_string(),
453 ));
454 }
455
456 if fapi_claims.client_id.is_empty() {
458 return Err(AuthError::InvalidToken(
459 "client_id required in request object".to_string(),
460 ));
461 }
462
463 if fapi_claims.redirect_uri.is_empty() {
464 return Err(AuthError::InvalidToken(
465 "redirect_uri required in request object".to_string(),
466 ));
467 }
468
469 if fapi_claims.response_type.is_empty() {
470 return Err(AuthError::InvalidToken(
471 "response_type required in request object".to_string(),
472 ));
473 }
474
475 tracing::info!(
476 "FAPI request object validated successfully with SecureJwtValidator for client: {}",
477 fapi_claims.client_id
478 );
479
480 Ok(fapi_claims)
481 }
482 Err(e) => {
483 tracing::error!("SecureJwtValidator failed for FAPI request object: {}", e);
484 Err(AuthError::InvalidToken(format!(
485 "Enhanced JWT validation failed: {}",
486 e
487 )))
488 }
489 }
490 }
491
492 async fn validate_request_claims(&self, claims: &FapiRequestObject) -> Result<()> {
494 if !matches!(claims.response_type.as_str(), "code" | "code id_token") {
496 return Err(AuthError::InvalidRequest(
497 "FAPI 2.0 requires code or code id_token response type".to_string(),
498 ));
499 }
500
501 if claims.code_challenge.is_none() {
503 return Err(AuthError::InvalidRequest(
504 "PKCE required for FAPI 2.0".to_string(),
505 ));
506 }
507
508 if let Some(method) = &claims.code_challenge_method {
509 if method != "S256" {
510 return Err(AuthError::InvalidRequest(
511 "FAPI 2.0 requires S256 code challenge method".to_string(),
512 ));
513 }
514 } else {
515 return Err(AuthError::InvalidRequest(
516 "code_challenge_method required for FAPI 2.0".to_string(),
517 ));
518 }
519
520 Ok(())
521 }
522
523 pub async fn authenticate_client_jwt(&self, client_assertion: &str) -> Result<String> {
525 let auth_result = self
527 .private_key_jwt_manager
528 .authenticate_client(client_assertion)
529 .await
530 .map_err(|e| {
531 AuthError::auth_method(
532 "private_key_jwt",
533 format!("Private key JWT authentication failed: {}", e),
534 )
535 })?;
536
537 match auth_result.authenticated {
538 true => {
539 tracing::info!(
540 "FAPI client authenticated successfully using private key JWT: {}",
541 auth_result.client_id
542 );
543 Ok(auth_result.client_id)
544 }
545 false => {
546 let error_msg = auth_result.errors.join("; ");
547 tracing::error!("FAPI private key JWT authentication failed: {}", error_msg);
548 Err(AuthError::auth_method(
549 "private_key_jwt",
550 format!("Authentication failed: {}", error_msg),
551 ))
552 }
553 }
554 }
555
556 pub async fn validate_token_request(
558 &self,
559 client_assertion: Option<&str>,
560 client_cert: Option<&str>,
561 dpop_proof: Option<&str>,
562 authorization_code: &str,
563 ) -> Result<String> {
564 let client_id = if let Some(assertion) = client_assertion {
566 self.authenticate_client_jwt(assertion).await?
567 } else if self.config.require_mtls {
568 if let Some(cert) = client_cert {
569 let cert_bytes = decode_client_certificate(cert)?;
570
571 let client_id = self.extract_client_id_from_certificate(&cert_bytes).await?;
574
575 self.mtls_manager
576 .validate_client_certificate(&cert_bytes, &client_id)
577 .await?;
578
579 client_id.to_string()
580 } else {
581 return Err(AuthError::auth_method(
582 "mtls",
583 "Client certificate required for FAPI 2.0 token request",
584 ));
585 }
586 } else {
587 return Err(AuthError::auth_method(
588 "fapi",
589 "FAPI 2.0 requires either private_key_jwt or mTLS client authentication",
590 ));
591 };
592
593 if self.config.require_dpop {
595 if dpop_proof.is_none() {
596 return Err(AuthError::auth_method(
597 "dpop",
598 "DPoP proof required for FAPI 2.0 token request",
599 ));
600 }
601
602 let proof = dpop_proof.unwrap();
603 self.dpop_manager
604 .validate_dpop_proof(
605 proof,
606 "POST",
607 &format!("{}/token", self.config.issuer),
608 Some(authorization_code), None,
610 )
611 .await?;
612 }
613
614 Ok(client_id)
615 }
616
617 pub async fn generate_authorization_response(
619 &self,
620 client_id: &str,
621 code: Option<&str>,
622 state: Option<&str>,
623 error: Option<&str>,
624 error_description: Option<&str>,
625 ) -> Result<String> {
626 if !self.config.enable_jarm {
627 return Err(AuthError::Configuration {
628 message: "JARM not enabled".to_string(),
629 help: Some("Enable JARM in your configuration to use this feature".to_string()),
630 docs_url: Some("https://docs.auth-framework.com/fapi#jarm".to_string()),
631 source: None,
632 suggested_fix: Some("Set enable_jarm to true in your FAPIConfig".to_string()),
633 });
634 }
635
636 let now = Utc::now();
637 let exp = now + Duration::minutes(5); let response = FapiAuthorizationResponse {
640 iss: self.config.issuer.clone(),
641 aud: client_id.to_string(),
642 iat: now.timestamp(),
643 exp: exp.timestamp(),
644 code: code.map(|c| c.to_string()),
645 state: state.map(|s| s.to_string()),
646 error: error.map(|e| e.to_string()),
647 error_description: error_description.map(|d| d.to_string()),
648 additional_params: HashMap::new(),
649 };
650
651 let header = Header::new(self.config.response_signing_algorithm);
653
654 let token =
656 jsonwebtoken::encode(&header, &response, &self.config.private_key).map_err(|e| {
657 AuthError::TokenGeneration(format!("Failed to sign JARM response: {}", e))
658 })?;
659
660 Ok(token)
661 }
662
663 pub async fn generate_token_response(
665 &self,
666 client_id: &str,
667 user_id: &str,
668 scopes: Vec<String>,
669 cert_thumbprint: Option<String>,
670 dpop_jkt: Option<String>,
671 ) -> Result<FapiTokenResponse> {
672 let access_token = self
674 .generate_access_token(client_id, user_id, &scopes, &cert_thumbprint, &dpop_jkt)
675 .await?;
676
677 let refresh_token = self.generate_refresh_token(client_id, user_id).await?;
679
680 let mut cnf = json!({});
682
683 if let Some(thumbprint) = cert_thumbprint {
684 cnf["x5t#S256"] = Value::String(thumbprint);
685 }
686
687 if let Some(jkt) = dpop_jkt {
688 cnf["jkt"] = Value::String(jkt);
689 }
690
691 let response = FapiTokenResponse {
692 access_token,
693 token_type: "DPoP".to_string(), expires_in: 3600, refresh_token: Some(refresh_token),
696 scope: Some(scopes.join(" ")),
697 id_token: None, cnf: if cnf.as_object().unwrap().is_empty() {
699 None
700 } else {
701 Some(cnf)
702 },
703 };
704
705 Ok(response)
706 }
707
708 async fn generate_access_token(
710 &self,
711 client_id: &str,
712 user_id: &str,
713 scopes: &[String],
714 cert_thumbprint: &Option<String>,
715 dpop_jkt: &Option<String>,
716 ) -> Result<String> {
717 let now = Utc::now();
718 let exp = now + Duration::hours(1);
719
720 let mut claims = json!({
721 "iss": self.config.issuer,
722 "aud": client_id,
723 "sub": user_id,
724 "iat": now.timestamp(),
725 "exp": exp.timestamp(),
726 "scope": scopes.join(" "),
727 "jti": Uuid::new_v4().to_string(),
728 });
729
730 let mut cnf = json!({});
732
733 if let Some(thumbprint) = cert_thumbprint {
734 cnf["x5t#S256"] = Value::String(thumbprint.clone());
735 }
736
737 if let Some(jkt) = dpop_jkt {
738 cnf["jkt"] = Value::String(jkt.clone());
739 }
740
741 if !cnf.as_object().unwrap().is_empty() {
742 claims["cnf"] = cnf;
743 }
744
745 let header = Header::new(Algorithm::RS256);
747
748 let token =
750 jsonwebtoken::encode(&header, &claims, &self.config.private_key).map_err(|e| {
751 AuthError::TokenGeneration(format!("Failed to generate access token: {}", e))
752 })?;
753
754 Ok(token)
755 }
756
757 async fn generate_refresh_token(&self, client_id: &str, user_id: &str) -> Result<String> {
759 let now = Utc::now();
760 let exp = now + Duration::days(30); let claims = json!({
763 "iss": self.config.issuer,
764 "aud": client_id,
765 "sub": user_id,
766 "iat": now.timestamp(),
767 "exp": exp.timestamp(),
768 "typ": "refresh_token",
769 "jti": Uuid::new_v4().to_string(),
770 });
771
772 let header = Header::new(Algorithm::RS256);
774
775 let token =
777 jsonwebtoken::encode(&header, &claims, &self.config.private_key).map_err(|e| {
778 AuthError::TokenGeneration(format!("Failed to generate refresh token: {}", e))
779 })?;
780
781 Ok(token)
782 }
783
784 pub async fn create_session(
786 &self,
787 client_id: &str,
788 user_id: &str,
789 scopes: Vec<String>,
790 dpop_proof: Option<String>,
791 cert_thumbprint: Option<String>,
792 request_jti: Option<String>,
793 ) -> Result<String> {
794 let session_id = Uuid::new_v4().to_string();
795 let now = Utc::now();
796 let expires_at = now + Duration::hours(24); let session = FapiSession {
799 session_id: session_id.clone(),
800 client_id: client_id.to_string(),
801 user_id: user_id.to_string(),
802 created_at: now,
803 expires_at,
804 dpop_proof,
805 cert_thumbprint,
806 request_jti,
807 scopes,
808 metadata: HashMap::new(),
809 };
810
811 let mut sessions = self.sessions.write().await;
812 sessions.insert(session_id.clone(), session);
813
814 Ok(session_id)
815 }
816
817 pub async fn get_session(&self, session_id: &str) -> Result<Option<FapiSession>> {
819 let sessions = self.sessions.read().await;
820 Ok(sessions.get(session_id).cloned())
821 }
822
823 pub async fn validate_session(&self, session_id: &str) -> Result<FapiSession> {
825 let session = self
826 .get_session(session_id)
827 .await?
828 .ok_or_else(|| AuthError::validation("Session not found".to_string()))?;
829
830 if Utc::now() > session.expires_at {
832 return Err(AuthError::validation("Session expired".to_string()));
833 }
834
835 Ok(session)
836 }
837
838 pub async fn remove_session(&self, session_id: &str) -> Result<()> {
840 let mut sessions = self.sessions.write().await;
841 sessions.remove(session_id);
842 Ok(())
843 }
844
845 pub async fn audit_log(&self, event: &str, details: &Value) -> Result<()> {
847 if self.config.enhanced_audit {
848 let timestamp = chrono::Utc::now().to_rfc3339();
852 let audit_entry = format!("[{}] FAPI AUDIT: {} - {}", timestamp, event, details);
853
854 log::info!("{}", audit_entry);
856 }
857 Ok(())
858 }
859
860 async fn extract_client_id_from_certificate(&self, cert_bytes: &[u8]) -> Result<String> {
862 client_id_from_certificate(cert_bytes)
863 }
864}
865
866impl Default for FapiConfig {
867 fn default() -> Self {
868 let issuer =
870 std::env::var("FAPI_ISSUER").unwrap_or_else(|_| "https://auth.example.com".to_string());
871
872 let private_key = if let Ok(key_path) = std::env::var("FAPI_PRIVATE_KEY_PATH") {
874 std::fs::read(&key_path)
875 .map_err(|e| tracing::warn!("Failed to load private key from {}: {}", key_path, e))
876 .and_then(|bytes| {
877 EncodingKey::from_rsa_pem(&bytes)
878 .map_err(|e| tracing::warn!("Invalid RSA key format: {}", e))
879 })
880 .unwrap_or_else(|_| EncodingKey::from_secret(b"dev_fallback_secret"))
881 } else {
882 EncodingKey::from_secret(b"dev_fallback_secret")
883 };
884
885 Self {
886 issuer,
887 request_signing_algorithm: Algorithm::RS256,
888 response_signing_algorithm: Algorithm::RS256,
889 private_key,
890 public_key: DecodingKey::from_secret(b"dev_secret"),
891 max_request_age: 300, require_dpop: true,
893 require_mtls: true,
894 require_par: true,
895 enable_jarm: true,
896 enhanced_audit: true,
897 }
898 }
899}
900
901fn decode_client_certificate(input: &str) -> Result<Vec<u8>> {
906 use base64::Engine;
907 use base64::engine::general_purpose::{STANDARD, STANDARD_NO_PAD, URL_SAFE, URL_SAFE_NO_PAD};
908
909 const BEGIN: &str = "-----BEGIN CERTIFICATE-----";
910 const END: &str = "-----END CERTIFICATE-----";
911 let bad = || {
912 AuthError::auth_method(
913 "mtls",
914 "Client certificate must be PEM or base64-encoded DER",
915 )
916 };
917
918 let trimmed = input.trim();
919 let body = if let Some(rest) = trimmed.strip_prefix(BEGIN) {
920 let end = rest.find(END).ok_or_else(bad)?;
921 if !rest[end + END.len()..].trim().is_empty() {
923 return Err(bad());
924 }
925 &rest[..end]
926 } else {
927 trimmed
928 };
929 let compact: String = body.chars().filter(|c| !c.is_whitespace()).collect();
930 if compact.is_empty() {
931 return Err(bad());
932 }
933 STANDARD
934 .decode(&compact)
935 .or_else(|_| STANDARD_NO_PAD.decode(&compact))
936 .or_else(|_| URL_SAFE.decode(&compact))
937 .or_else(|_| URL_SAFE_NO_PAD.decode(&compact))
938 .map_err(|_| bad())
939}
940
941fn client_id_from_certificate(cert_der: &[u8]) -> Result<String> {
944 use x509_parser::extensions::GeneralName;
945
946 let cert = match x509_parser::parse_x509_certificate(cert_der) {
947 Ok(([], cert)) => cert,
948 _ => {
949 return Err(AuthError::auth_method(
950 "mtls",
951 "Invalid client certificate format",
952 ));
953 }
954 };
955
956 let common_names: Vec<String> = cert
957 .subject()
958 .iter_common_name()
959 .filter_map(|cn| cn.as_str().ok().map(str::to_string))
960 .collect();
961 if common_names.len() == 1 && !common_names[0].is_empty() {
962 return Ok(common_names[0].clone());
963 }
964
965 if let Ok(Some(san)) = cert.subject_alternative_name() {
966 let names: Vec<String> = san
967 .value
968 .general_names
969 .iter()
970 .filter_map(|name| match name {
971 GeneralName::DNSName(dns) => Some(dns.to_string()),
972 GeneralName::URI(uri) => Some(uri.to_string()),
973 _ => None,
974 })
975 .collect();
976 if names.len() == 1 {
977 return Ok(names[0].clone());
978 }
979 }
980
981 Err(AuthError::auth_method(
982 "mtls",
983 "Cannot derive a unique client id from the certificate (need one subject CN or one SAN)",
984 ))
985}
986
987#[cfg(test)]
988mod tests {
989 use super::*;
990
991 #[tokio::test]
992 async fn test_fapi_manager_creation() {
993 let config = FapiConfig::default();
995
996 assert_eq!(config.issuer, "https://auth.example.com"); assert!(config.require_dpop);
999 assert!(config.require_mtls);
1000 assert!(config.require_par);
1001 assert!(config.enable_jarm);
1002 assert!(config.enhanced_audit);
1003 }
1004
1005 #[tokio::test]
1006 async fn test_fapi_request_validation() {
1007 let config = FapiConfig::default();
1010
1011 let request_object = r#"{"iss":"client_id","aud":"https://example.com","exp":9999999999,"nbf":1000000000,"iat":1000000000,"jti":"unique_id"}"#;
1013
1014 let validation_result = validate_fapi_request_object(request_object, &config);
1016 assert!(
1017 validation_result.is_ok(),
1018 "FAPI request object validation failed"
1019 );
1020
1021 assert!(!request_object.is_empty());
1023 }
1024
1025 fn validate_fapi_request_object(
1027 request_object: &str,
1028 _config: &FapiConfig,
1029 ) -> Result<(), String> {
1030 let parsed: serde_json::Value = serde_json::from_str(request_object)
1032 .map_err(|_| "Invalid JSON structure in request object")?;
1033
1034 let required_claims = ["iss", "aud", "exp", "iat", "jti"];
1036 for claim in &required_claims {
1037 if parsed.get(claim).is_none() {
1038 return Err(format!("Missing required FAPI claim: {}", claim));
1039 }
1040 }
1041
1042 if let Some(exp) = parsed.get("exp").and_then(|v| v.as_i64()) {
1044 let now = chrono::Utc::now().timestamp();
1045 if exp <= now {
1046 return Err("Request object has expired".to_string());
1047 }
1048 }
1049
1050 Ok(())
1053 }
1054
1055 #[tokio::test]
1056 async fn test_fapi_response_generation() {
1057 let config = FapiConfig::default();
1060
1061 let auth_response = serde_json::json!({
1063 "code": "auth_code_123",
1064 "state": "client_state",
1065 "iss": config.issuer,
1066 "aud": "client_id",
1067 "exp": 9999999999i64
1068 });
1069
1070 assert!(auth_response["code"].is_string());
1072 }
1073
1074 #[tokio::test]
1075 async fn test_fapi_token_generation() {
1076 let config = FapiConfig::default();
1078
1079 let scopes = ["accounts".to_string(), "payments".to_string()];
1081 let client_id = "fapi_client_123";
1082 let user_id = "user_456";
1083 let cert_thumbprint = Some("sha256_cert_thumbprint".to_string());
1084
1085 assert!(config.require_dpop);
1087 assert!(config.require_mtls);
1088 assert!(!scopes.is_empty());
1089 assert!(!client_id.is_empty());
1090 assert!(!user_id.is_empty());
1091 assert!(cert_thumbprint.is_some());
1092 }
1093
1094 #[tokio::test]
1095 async fn test_fapi_session_management() {
1096 let config = FapiConfig::default();
1098
1099 let session_data = serde_json::json!({
1101 "client_id": "fapi_client",
1102 "user_id": "fapi_user",
1103 "scopes": ["accounts", "payments"],
1104 "mtls_cert": "client_certificate",
1105 "dpop_key": "client_dpop_key"
1106 });
1107
1108 assert!(session_data["mtls_cert"].is_string());
1110 assert!(session_data["dpop_key"].is_string());
1111 assert!(config.enhanced_audit);
1112 }
1113
1114 fn test_cert(cn: &str, org: Option<&str>) -> rcgen::Certificate {
1117 let mut params = rcgen::CertificateParams::new(Vec::<String>::new()).unwrap();
1118 let mut dn = rcgen::DistinguishedName::new();
1119 dn.push(rcgen::DnType::CommonName, cn);
1120 if let Some(org) = org {
1121 dn.push(rcgen::DnType::OrganizationName, org);
1122 }
1123 params.distinguished_name = dn;
1124 let key = rcgen::KeyPair::generate().unwrap();
1125 params.self_signed(&key).unwrap()
1126 }
1127
1128 #[test]
1129 fn decode_client_certificate_accepts_pem_and_base64_der() {
1130 use base64::Engine;
1131 let cert = test_cert("client-a", None);
1132 let der = cert.der().to_vec();
1133
1134 assert_eq!(decode_client_certificate(&cert.pem()).unwrap(), der);
1135 let b64 = base64::engine::general_purpose::STANDARD.encode(&der);
1136 assert_eq!(decode_client_certificate(&b64).unwrap(), der);
1137 let wrapped = format!(" {}\n{} \n", &b64[..20], &b64[20..]);
1138 assert_eq!(decode_client_certificate(&wrapped).unwrap(), der);
1139 }
1140
1141 #[test]
1142 fn decode_client_certificate_rejects_garbage_and_extra_certificates() {
1143 let a = test_cert("client-a", None).pem();
1144 let b = test_cert("client-b", None).pem();
1145 assert!(decode_client_certificate("").is_err());
1146 assert!(decode_client_certificate("!!! not base64 !!!").is_err());
1147 assert!(decode_client_certificate("-----BEGIN CERTIFICATE-----\nAAAA").is_err());
1148 assert!(decode_client_certificate(&format!("{a}{b}")).is_err());
1150 }
1151
1152 #[test]
1153 fn client_id_comes_from_the_parsed_subject_cn() {
1154 let cert = test_cert("client-a", None);
1155 assert_eq!(client_id_from_certificate(cert.der()).unwrap(), "client-a");
1156 }
1157
1158 #[test]
1159 fn client_id_is_not_found_by_searching_the_raw_bytes() {
1160 let cert = test_cert("real-client", Some("CN=victim-client,"));
1163 assert_eq!(
1164 client_id_from_certificate(cert.der()).unwrap(),
1165 "real-client"
1166 );
1167 }
1168
1169 #[test]
1170 fn client_id_needs_a_unique_identity() {
1171 let mut params = rcgen::CertificateParams::new(Vec::<String>::new()).unwrap();
1173 params.distinguished_name = rcgen::DistinguishedName::new(); let key = rcgen::KeyPair::generate().unwrap();
1175 let nameless = params.self_signed(&key).unwrap();
1176 assert!(client_id_from_certificate(nameless.der()).is_err());
1177 assert!(client_id_from_certificate(b"not a certificate").is_err());
1178 }
1179}