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(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
61impl std::fmt::Debug for FapiManager {
62 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
63 let mut d = f.debug_struct("FapiManager");
64 d.field("dpop_manager", &self.dpop_manager);
65 d.field("mtls_manager", &self.mtls_manager);
66 d.field("par_manager", &self.par_manager);
67 d.field("private_key_jwt_manager", &self.private_key_jwt_manager);
68 d.field("jwt_validator", &self.jwt_validator);
69 d.field("config", &self.config);
70 d.field("sessions", &crate::utils::redact::redacted(&self.sessions));
71 d.finish()
72 }
73}
74
75#[derive(Clone)]
77pub struct FapiConfig {
78 pub issuer: String,
80
81 pub request_signing_algorithm: Algorithm,
83
84 pub response_signing_algorithm: Algorithm,
86
87 pub private_key: EncodingKey,
89
90 pub public_key: DecodingKey,
92
93 pub max_request_age: i64,
95
96 pub require_dpop: bool,
98
99 pub require_mtls: bool,
101
102 pub require_par: bool,
104
105 pub enable_jarm: bool,
107
108 pub enhanced_audit: bool,
110}
111
112impl std::fmt::Debug for FapiConfig {
113 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
114 f.debug_struct("FapiConfig")
115 .field("issuer", &self.issuer)
116 .field("request_signing_algorithm", &self.request_signing_algorithm)
117 .field(
118 "response_signing_algorithm",
119 &self.response_signing_algorithm,
120 )
121 .field("private_key", &"<EncodingKey>")
122 .field("public_key", &"<DecodingKey>")
123 .field("max_request_age", &self.max_request_age)
124 .field("require_dpop", &self.require_dpop)
125 .field("require_mtls", &self.require_mtls)
126 .field("require_par", &self.require_par)
127 .field("enable_jarm", &self.enable_jarm)
128 .field("enhanced_audit", &self.enhanced_audit)
129 .finish()
130 }
131}
132
133#[derive(Clone, Serialize, Deserialize)]
135pub struct FapiSession {
136 pub session_id: String,
138
139 pub client_id: String,
141
142 pub user_id: String,
144
145 pub created_at: DateTime<Utc>,
147
148 pub expires_at: DateTime<Utc>,
150
151 pub dpop_proof: Option<String>,
153
154 pub cert_thumbprint: Option<String>,
156
157 pub request_jti: Option<String>,
159
160 pub scopes: Vec<String>,
162
163 pub metadata: HashMap<String, Value>,
165}
166
167impl std::fmt::Debug for FapiSession {
168 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
169 let mut d = f.debug_struct("FapiSession");
170 d.field(
171 "session_id",
172 &crate::utils::redact::redacted(&self.session_id),
173 );
174 d.field("client_id", &self.client_id);
175 d.field("user_id", &self.user_id);
176 d.field("created_at", &self.created_at);
177 d.field("expires_at", &self.expires_at);
178 d.field(
179 "dpop_proof",
180 &crate::utils::redact::redacted(&self.dpop_proof),
181 );
182 d.field("cert_thumbprint", &self.cert_thumbprint);
183 d.field("request_jti", &self.request_jti);
184 d.field("scopes", &self.scopes);
185 d.field("metadata", &self.metadata);
186 d.finish()
187 }
188}
189
190#[derive(Debug, Clone, Serialize, Deserialize)]
192pub struct FapiRequestObject {
193 pub iss: String,
195
196 pub aud: String,
198
199 pub iat: i64,
201
202 pub exp: i64,
204
205 pub nbf: Option<i64>,
207
208 pub jti: String,
210
211 pub response_type: String,
213
214 pub client_id: String,
216
217 pub redirect_uri: String,
219
220 pub scope: String,
222
223 pub state: Option<String>,
225
226 pub nonce: Option<String>,
228
229 pub code_challenge: Option<String>,
231
232 pub code_challenge_method: Option<String>,
234
235 #[serde(flatten)]
237 pub additional_claims: HashMap<String, Value>,
238}
239
240#[derive(Clone, Serialize, Deserialize)]
242pub struct FapiAuthorizationResponse {
243 pub iss: String,
245
246 pub aud: String,
248
249 pub iat: i64,
251
252 pub exp: i64,
254
255 pub code: Option<String>,
257
258 pub state: Option<String>,
260
261 pub error: Option<String>,
263
264 pub error_description: Option<String>,
266
267 #[serde(flatten)]
269 pub additional_params: HashMap<String, Value>,
270}
271
272impl std::fmt::Debug for FapiAuthorizationResponse {
273 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
274 let mut d = f.debug_struct("FapiAuthorizationResponse");
275 d.field("iss", &self.iss);
276 d.field("aud", &self.aud);
277 d.field("iat", &self.iat);
278 d.field("exp", &self.exp);
279 d.field("code", &crate::utils::redact::redacted(&self.code));
280 d.field("state", &self.state);
281 d.field("error", &self.error);
282 d.field("error_description", &self.error_description);
283 d.field(
284 "additional_params",
285 &crate::utils::redact::redacted(&self.additional_params),
286 );
287 d.finish()
288 }
289}
290
291#[derive(Clone, Serialize, Deserialize)]
293pub struct FapiTokenResponse {
294 pub access_token: String,
296
297 pub token_type: String,
299
300 pub expires_in: i64,
302
303 pub refresh_token: Option<String>,
305
306 pub scope: Option<String>,
308
309 pub id_token: Option<String>,
311
312 pub cnf: Option<Value>,
314}
315
316impl std::fmt::Debug for FapiTokenResponse {
317 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
318 let mut d = f.debug_struct("FapiTokenResponse");
319 d.field(
320 "access_token",
321 &crate::utils::redact::redacted(&self.access_token),
322 );
323 d.field("token_type", &self.token_type);
324 d.field("expires_in", &self.expires_in);
325 d.field(
326 "refresh_token",
327 &crate::utils::redact::redacted(&self.refresh_token),
328 );
329 d.field("scope", &self.scope);
330 d.field("id_token", &crate::utils::redact::redacted(&self.id_token));
331 d.field("cnf", &self.cnf);
332 d.finish()
333 }
334}
335
336fn request_object_too_old(now: i64, iat: i64, max_age: i64) -> bool {
338 now.checked_sub(iat).is_none_or(|age| age > max_age)
339}
340
341impl FapiManager {
342 pub fn new(
344 config: FapiConfig,
345 dpop_manager: Arc<DpopManager>,
346 mtls_manager: Arc<MutualTlsManager>,
347 par_manager: Arc<PARManager>,
348 private_key_jwt_manager: Arc<PrivateKeyJwtManager>,
349 jwt_validator: Arc<SecureJwtValidator>,
350 ) -> Self {
351 Self {
352 dpop_manager,
353 mtls_manager,
354 par_manager,
355 private_key_jwt_manager,
356 jwt_validator,
357 config,
358 sessions: Arc::new(RwLock::new(HashMap::new())),
359 }
360 }
361
362 pub async fn validate_authorization_request(
364 &self,
365 request_object: &str,
366 client_cert: Option<&str>,
367 dpop_proof: Option<&str>,
368 request_uri: Option<&str>,
369 ) -> Result<FapiRequestObject> {
370 let claims = if let Some(uri) = request_uri {
371 if self.config.require_par {
373 let par_request = self.par_manager.consume_request(uri).await.map_err(|e| {
375 AuthError::InvalidRequest(format!("PAR request validation failed: {}", e))
376 })?;
377
378 tracing::info!(
379 "FAPI PAR request consumed successfully for client: {}",
380 par_request.client_id
381 );
382
383 FapiRequestObject {
386 iss: par_request.client_id.clone(),
387 aud: self.config.issuer.clone(),
388 iat: Utc::now().timestamp(),
389 exp: Utc::now().timestamp() + 300, nbf: Some(Utc::now().timestamp()),
391 jti: uuid::Uuid::new_v4().to_string(),
392 response_type: par_request.response_type,
393 client_id: par_request.client_id,
394 redirect_uri: par_request.redirect_uri,
395 scope: par_request.scope.unwrap_or_default(),
396 state: par_request.state,
397 nonce: None, code_challenge: par_request.code_challenge,
399 code_challenge_method: par_request.code_challenge_method,
400 additional_claims: par_request
401 .additional_params
402 .into_iter()
403 .map(|(k, v)| (k, serde_json::Value::String(v)))
404 .collect(),
405 }
406 } else {
407 return Err(AuthError::InvalidRequest(
408 "request_uri provided but PAR not required".to_string(),
409 ));
410 }
411 } else {
412 if self.config.require_par {
414 return Err(AuthError::InvalidRequest(
415 "PAR is required but no request_uri provided".to_string(),
416 ));
417 }
418
419 self.validate_request_object(request_object).await?
421 };
422
423 if self.config.require_mtls {
425 let cert = client_cert.ok_or_else(|| {
426 AuthError::auth_method("mtls", "mTLS certificate required for FAPI 2.0")
427 })?;
428 let cert_bytes = decode_client_certificate(cert)?;
429 self.mtls_manager
430 .validate_client_certificate(&cert_bytes, &claims.client_id)
431 .await?;
432 }
433
434 let pending_proof = if self.config.require_dpop {
436 let Some(proof) = dpop_proof else {
437 return Err(AuthError::auth_method(
438 "dpop",
439 "DPoP proof required for FAPI 2.0",
440 ));
441 };
442 Some(
443 self.dpop_manager
444 .verify_dpop_proof(
445 proof,
446 "POST",
447 &format!("{}/authorize", self.config.issuer),
448 None,
449 None,
450 None,
451 )
452 .await?,
453 )
454 } else {
455 None
456 };
457
458 self.validate_request_claims(&claims).await?;
460
461 if let Some(pending) = pending_proof {
462 self.dpop_manager.commit_dpop_proof(pending).await?;
463 }
464
465 Ok(claims)
466 }
467
468 async fn validate_request_object(&self, request_object: &str) -> Result<FapiRequestObject> {
470 let decoding_key = &self.config.public_key;
472
473 match self
475 .jwt_validator
476 .validate_token(request_object, decoding_key, true)
477 {
478 Ok(secure_claims) => {
479 let header = jsonwebtoken::decode_header(request_object).map_err(|e| {
481 AuthError::InvalidToken(format!("Invalid request object header: {}", e))
482 })?;
483
484 if !matches!(
486 header.alg,
487 Algorithm::RS256 | Algorithm::PS256 | Algorithm::ES256
488 ) {
489 return Err(AuthError::InvalidToken(
490 "Request object must use RS256, PS256, or ES256".to_string(),
491 ));
492 }
493
494 let mut validation = Validation::new(header.alg);
496 validation.set_audience(&[&self.config.issuer]);
497 validation.validate_exp = true;
498 validation.validate_nbf = true;
499
500 let token_data = jsonwebtoken::decode::<FapiRequestObject>(
502 request_object,
503 &self.config.public_key,
504 &validation,
505 )
506 .map_err(|e| {
507 AuthError::InvalidToken(format!("Request object validation failed: {}", e))
508 })?;
509
510 let fapi_claims = token_data.claims;
511
512 if secure_claims.sub != fapi_claims.client_id {
515 return Err(AuthError::InvalidToken(
516 "Subject mismatch between secure validation and FAPI claims".to_string(),
517 ));
518 }
519
520 if secure_claims.iss != fapi_claims.iss {
522 return Err(AuthError::InvalidToken(
523 "Issuer mismatch between secure validation and FAPI claims".to_string(),
524 ));
525 }
526
527 if secure_claims.exp != fapi_claims.exp {
529 return Err(AuthError::InvalidToken(
530 "Expiry mismatch between secure validation and FAPI claims".to_string(),
531 ));
532 }
533
534 let now = Utc::now().timestamp();
536
537 if request_object_too_old(now, fapi_claims.iat, self.config.max_request_age) {
539 return Err(AuthError::InvalidToken(
540 "Request object too old".to_string(),
541 ));
542 }
543
544 if fapi_claims.client_id.is_empty() {
546 return Err(AuthError::InvalidToken(
547 "client_id required in request object".to_string(),
548 ));
549 }
550
551 if fapi_claims.redirect_uri.is_empty() {
552 return Err(AuthError::InvalidToken(
553 "redirect_uri required in request object".to_string(),
554 ));
555 }
556
557 if fapi_claims.response_type.is_empty() {
558 return Err(AuthError::InvalidToken(
559 "response_type required in request object".to_string(),
560 ));
561 }
562
563 tracing::info!(
564 "FAPI request object validated successfully with SecureJwtValidator for client: {}",
565 fapi_claims.client_id
566 );
567
568 Ok(fapi_claims)
569 }
570 Err(e) => {
571 tracing::error!("SecureJwtValidator failed for FAPI request object: {}", e);
572 Err(AuthError::InvalidToken(format!(
573 "Enhanced JWT validation failed: {}",
574 e
575 )))
576 }
577 }
578 }
579
580 async fn validate_request_claims(&self, claims: &FapiRequestObject) -> Result<()> {
582 if !matches!(claims.response_type.as_str(), "code" | "code id_token") {
584 return Err(AuthError::InvalidRequest(
585 "FAPI 2.0 requires code or code id_token response type".to_string(),
586 ));
587 }
588
589 if claims.code_challenge.is_none() {
591 return Err(AuthError::InvalidRequest(
592 "PKCE required for FAPI 2.0".to_string(),
593 ));
594 }
595
596 if let Some(method) = &claims.code_challenge_method {
597 if method != "S256" {
598 return Err(AuthError::InvalidRequest(
599 "FAPI 2.0 requires S256 code challenge method".to_string(),
600 ));
601 }
602 } else {
603 return Err(AuthError::InvalidRequest(
604 "code_challenge_method required for FAPI 2.0".to_string(),
605 ));
606 }
607
608 Ok(())
609 }
610
611 pub async fn authenticate_client_jwt(&self, client_assertion: &str) -> Result<String> {
616 const REFUSED: &str = "Client authentication failed";
617
618 let auth_result = match self
620 .private_key_jwt_manager
621 .authenticate_client(client_assertion)
622 .await
623 {
624 Ok(result) => result,
625 Err(e) => {
626 tracing::warn!("FAPI private key JWT assertion rejected: {}", e);
627 return Err(AuthError::auth_method("private_key_jwt", REFUSED));
628 }
629 };
630
631 if auth_result.authenticated {
632 tracing::info!(
633 "FAPI client authenticated successfully using private key JWT: {}",
634 auth_result.client_id
635 );
636 Ok(auth_result.client_id)
637 } else {
638 tracing::warn!(
639 "FAPI private key JWT authentication failed: {}",
640 auth_result.errors.join("; ")
641 );
642 Err(AuthError::auth_method("private_key_jwt", REFUSED))
643 }
644 }
645
646 pub async fn validate_token_request(
648 &self,
649 client_assertion: Option<&str>,
650 client_cert: Option<&str>,
651 dpop_proof: Option<&str>,
652 _authorization_code: &str,
653 ) -> Result<String> {
654 let client_id = if let Some(assertion) = client_assertion {
656 self.authenticate_client_jwt(assertion).await?
657 } else if self.config.require_mtls {
658 if let Some(cert) = client_cert {
659 let cert_bytes = decode_client_certificate(cert)?;
660
661 let client_id = self.extract_client_id_from_certificate(&cert_bytes).await?;
664
665 self.mtls_manager
666 .validate_client_certificate(&cert_bytes, &client_id)
667 .await?;
668
669 client_id.to_string()
670 } else {
671 return Err(AuthError::auth_method(
672 "mtls",
673 "Client certificate required for FAPI 2.0 token request",
674 ));
675 }
676 } else {
677 return Err(AuthError::auth_method(
678 "fapi",
679 "FAPI 2.0 requires either private_key_jwt or mTLS client authentication",
680 ));
681 };
682
683 if self.config.require_dpop {
685 if dpop_proof.is_none() {
686 return Err(AuthError::auth_method(
687 "dpop",
688 "DPoP proof required for FAPI 2.0 token request",
689 ));
690 }
691
692 let proof = dpop_proof.unwrap();
693 self.dpop_manager
694 .validate_dpop_proof(
695 proof,
696 "POST",
697 &format!("{}/token", self.config.issuer),
698 None, None,
700 )
701 .await?;
702 }
703
704 Ok(client_id)
705 }
706
707 pub async fn generate_authorization_response(
709 &self,
710 client_id: &str,
711 code: Option<&str>,
712 state: Option<&str>,
713 error: Option<&str>,
714 error_description: Option<&str>,
715 ) -> Result<String> {
716 if !self.config.enable_jarm {
717 return Err(AuthError::Configuration {
718 message: "JARM not enabled".to_string(),
719 help: Some("Enable JARM in your configuration to use this feature".to_string()),
720 docs_url: Some("https://docs.auth-framework.com/fapi#jarm".to_string()),
721 source: None,
722 suggested_fix: Some("Set enable_jarm to true in your FAPIConfig".to_string()),
723 });
724 }
725
726 let now = Utc::now();
727 let exp = now + Duration::minutes(5); let response = FapiAuthorizationResponse {
730 iss: self.config.issuer.clone(),
731 aud: client_id.to_string(),
732 iat: now.timestamp(),
733 exp: exp.timestamp(),
734 code: code.map(|c| c.to_string()),
735 state: state.map(|s| s.to_string()),
736 error: error.map(|e| e.to_string()),
737 error_description: error_description.map(|d| d.to_string()),
738 additional_params: HashMap::new(),
739 };
740
741 let header = Header::new(self.config.response_signing_algorithm);
743
744 let token =
746 jsonwebtoken::encode(&header, &response, &self.config.private_key).map_err(|e| {
747 AuthError::TokenGeneration(format!("Failed to sign JARM response: {}", e))
748 })?;
749
750 Ok(token)
751 }
752
753 pub async fn generate_token_response(
755 &self,
756 client_id: &str,
757 user_id: &str,
758 scopes: Vec<String>,
759 cert_thumbprint: Option<String>,
760 dpop_jkt: Option<String>,
761 ) -> Result<FapiTokenResponse> {
762 let access_token = self
764 .generate_access_token(client_id, user_id, &scopes, &cert_thumbprint, &dpop_jkt)
765 .await?;
766
767 let refresh_token = self.generate_refresh_token(client_id, user_id).await?;
769
770 let mut cnf = json!({});
772
773 if let Some(thumbprint) = cert_thumbprint {
774 cnf["x5t#S256"] = Value::String(thumbprint);
775 }
776
777 if let Some(jkt) = dpop_jkt {
778 cnf["jkt"] = Value::String(jkt);
779 }
780
781 let response = FapiTokenResponse {
782 access_token,
783 token_type: "DPoP".to_string(), expires_in: 3600, refresh_token: Some(refresh_token),
786 scope: Some(scopes.join(" ")),
787 id_token: None, cnf: if cnf.as_object().unwrap().is_empty() {
789 None
790 } else {
791 Some(cnf)
792 },
793 };
794
795 Ok(response)
796 }
797
798 async fn generate_access_token(
800 &self,
801 client_id: &str,
802 user_id: &str,
803 scopes: &[String],
804 cert_thumbprint: &Option<String>,
805 dpop_jkt: &Option<String>,
806 ) -> Result<String> {
807 let now = Utc::now();
808 let exp = now + Duration::hours(1);
809
810 let mut claims = json!({
811 "iss": self.config.issuer,
812 "aud": client_id,
813 "sub": user_id,
814 "iat": now.timestamp(),
815 "exp": exp.timestamp(),
816 "scope": scopes.join(" "),
817 "jti": Uuid::new_v4().to_string(),
818 });
819
820 let mut cnf = json!({});
822
823 if let Some(thumbprint) = cert_thumbprint {
824 cnf["x5t#S256"] = Value::String(thumbprint.clone());
825 }
826
827 if let Some(jkt) = dpop_jkt {
828 cnf["jkt"] = Value::String(jkt.clone());
829 }
830
831 if !cnf.as_object().unwrap().is_empty() {
832 claims["cnf"] = cnf;
833 }
834
835 let header = Header::new(Algorithm::RS256);
837
838 let token =
840 jsonwebtoken::encode(&header, &claims, &self.config.private_key).map_err(|e| {
841 AuthError::TokenGeneration(format!("Failed to generate access token: {}", e))
842 })?;
843
844 Ok(token)
845 }
846
847 async fn generate_refresh_token(&self, client_id: &str, user_id: &str) -> Result<String> {
849 let now = Utc::now();
850 let exp = now + Duration::days(30); let claims = json!({
853 "iss": self.config.issuer,
854 "aud": client_id,
855 "sub": user_id,
856 "iat": now.timestamp(),
857 "exp": exp.timestamp(),
858 "typ": "refresh_token",
859 "jti": Uuid::new_v4().to_string(),
860 });
861
862 let header = Header::new(Algorithm::RS256);
864
865 let token =
867 jsonwebtoken::encode(&header, &claims, &self.config.private_key).map_err(|e| {
868 AuthError::TokenGeneration(format!("Failed to generate refresh token: {}", e))
869 })?;
870
871 Ok(token)
872 }
873
874 pub async fn create_session(
876 &self,
877 client_id: &str,
878 user_id: &str,
879 scopes: Vec<String>,
880 dpop_proof: Option<String>,
881 cert_thumbprint: Option<String>,
882 request_jti: Option<String>,
883 ) -> Result<String> {
884 let session_id = Uuid::new_v4().to_string();
885 let now = Utc::now();
886 let expires_at = now + Duration::hours(24); let session = FapiSession {
889 session_id: session_id.clone(),
890 client_id: client_id.to_string(),
891 user_id: user_id.to_string(),
892 created_at: now,
893 expires_at,
894 dpop_proof,
895 cert_thumbprint,
896 request_jti,
897 scopes,
898 metadata: HashMap::new(),
899 };
900
901 let mut sessions = self.sessions.write().await;
902 sessions.insert(session_id.clone(), session);
903
904 Ok(session_id)
905 }
906
907 pub async fn get_session(&self, session_id: &str) -> Result<Option<FapiSession>> {
909 let sessions = self.sessions.read().await;
910 Ok(sessions.get(session_id).cloned())
911 }
912
913 pub async fn validate_session(&self, session_id: &str) -> Result<FapiSession> {
915 let session = self
916 .get_session(session_id)
917 .await?
918 .ok_or_else(|| AuthError::validation("Session not found".to_string()))?;
919
920 if Utc::now() > session.expires_at {
922 return Err(AuthError::validation("Session expired".to_string()));
923 }
924
925 Ok(session)
926 }
927
928 pub async fn remove_session(&self, session_id: &str) -> Result<()> {
930 let mut sessions = self.sessions.write().await;
931 sessions.remove(session_id);
932 Ok(())
933 }
934
935 pub async fn audit_log(&self, event: &str, details: &Value) -> Result<()> {
937 if self.config.enhanced_audit {
938 let timestamp = chrono::Utc::now().to_rfc3339();
942 let audit_entry = format!("[{}] FAPI AUDIT: {} - {}", timestamp, event, details);
943
944 log::info!("{}", audit_entry);
946 }
947 Ok(())
948 }
949
950 async fn extract_client_id_from_certificate(&self, cert_bytes: &[u8]) -> Result<String> {
952 client_id_from_certificate(cert_bytes)
953 }
954}
955
956impl Default for FapiConfig {
957 fn default() -> Self {
958 let issuer =
960 std::env::var("FAPI_ISSUER").unwrap_or_else(|_| "https://auth.example.com".to_string());
961
962 let private_key = if let Ok(key_path) = std::env::var("FAPI_PRIVATE_KEY_PATH") {
964 std::fs::read(&key_path)
965 .map_err(|e| tracing::warn!("Failed to load private key from {}: {}", key_path, e))
966 .and_then(|bytes| {
967 EncodingKey::from_rsa_pem(&bytes)
968 .map_err(|e| tracing::warn!("Invalid RSA key format: {}", e))
969 })
970 .unwrap_or_else(|_| EncodingKey::from_secret(b"dev_fallback_secret"))
971 } else {
972 EncodingKey::from_secret(b"dev_fallback_secret")
973 };
974
975 Self {
976 issuer,
977 request_signing_algorithm: Algorithm::RS256,
978 response_signing_algorithm: Algorithm::RS256,
979 private_key,
980 public_key: DecodingKey::from_secret(b"dev_secret"),
981 max_request_age: 300, require_dpop: true,
983 require_mtls: true,
984 require_par: true,
985 enable_jarm: true,
986 enhanced_audit: true,
987 }
988 }
989}
990
991fn decode_client_certificate(input: &str) -> Result<Vec<u8>> {
996 use base64::Engine;
997 use base64::engine::general_purpose::{STANDARD, STANDARD_NO_PAD, URL_SAFE, URL_SAFE_NO_PAD};
998
999 const BEGIN: &str = "-----BEGIN CERTIFICATE-----";
1000 const END: &str = "-----END CERTIFICATE-----";
1001 let bad = || {
1002 AuthError::auth_method(
1003 "mtls",
1004 "Client certificate must be PEM or base64-encoded DER",
1005 )
1006 };
1007
1008 let trimmed = input.trim();
1009 let body = if let Some(rest) = trimmed.strip_prefix(BEGIN) {
1010 let end = rest.find(END).ok_or_else(bad)?;
1011 if !rest[end + END.len()..].trim().is_empty() {
1013 return Err(bad());
1014 }
1015 &rest[..end]
1016 } else {
1017 trimmed
1018 };
1019 let compact: String = body.chars().filter(|c| !c.is_whitespace()).collect();
1020 if compact.is_empty() {
1021 return Err(bad());
1022 }
1023 STANDARD
1024 .decode(&compact)
1025 .or_else(|_| STANDARD_NO_PAD.decode(&compact))
1026 .or_else(|_| URL_SAFE.decode(&compact))
1027 .or_else(|_| URL_SAFE_NO_PAD.decode(&compact))
1028 .map_err(|_| bad())
1029}
1030
1031fn client_id_from_certificate(cert_der: &[u8]) -> Result<String> {
1034 use x509_parser::extensions::GeneralName;
1035
1036 let cert = match x509_parser::parse_x509_certificate(cert_der) {
1037 Ok(([], cert)) => cert,
1038 _ => {
1039 return Err(AuthError::auth_method(
1040 "mtls",
1041 "Invalid client certificate format",
1042 ));
1043 }
1044 };
1045
1046 let common_names: Vec<String> = cert
1047 .subject()
1048 .iter_common_name()
1049 .filter_map(|cn| cn.as_str().ok().map(str::to_string))
1050 .collect();
1051 if common_names.len() == 1 && !common_names[0].is_empty() {
1052 return Ok(common_names[0].clone());
1053 }
1054
1055 if let Ok(Some(san)) = cert.subject_alternative_name() {
1056 let names: Vec<String> = san
1057 .value
1058 .general_names
1059 .iter()
1060 .filter_map(|name| match name {
1061 GeneralName::DNSName(dns) => Some(dns.to_string()),
1062 GeneralName::URI(uri) => Some(uri.to_string()),
1063 _ => None,
1064 })
1065 .collect();
1066 if names.len() == 1 {
1067 return Ok(names[0].clone());
1068 }
1069 }
1070
1071 Err(AuthError::auth_method(
1072 "mtls",
1073 "Cannot derive a unique client id from the certificate (need one subject CN or one SAN)",
1074 ))
1075}
1076
1077#[cfg(test)]
1078mod tests {
1079 use super::*;
1080
1081 #[tokio::test]
1082 async fn private_key_jwt_failures_do_not_tell_the_caller_why() {
1083 use crate::security::secure_jwt::SecureJwtConfig;
1084 use crate::server::jwt::private_key_jwt::ClientJwtConfig;
1085 use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD};
1086
1087 let validator = || SecureJwtValidator::new(SecureJwtConfig::default());
1088 let assertions = Arc::new(PrivateKeyJwtManager::new(validator()));
1089 let manager = FapiManager::new(
1090 FapiConfig::default(),
1091 Arc::new(DpopManager::new(validator())),
1092 Arc::new(MutualTlsManager::new()),
1093 Arc::new(PARManager::new(Arc::new(
1094 crate::storage::MemoryStorage::new(),
1095 ))),
1096 assertions.clone(),
1097 Arc::new(validator()),
1098 );
1099
1100 let key = rcgen::KeyPair::generate_for(&rcgen::PKCS_ECDSA_P256_SHA256).unwrap();
1102 let raw = key.public_key_raw();
1103 let point = &raw[raw.len() - 65..];
1104 let jwk = json!({
1105 "kty": "EC", "crv": "P-256",
1106 "x": URL_SAFE_NO_PAD.encode(&point[1..33]),
1107 "y": URL_SAFE_NO_PAD.encode(&point[33..65]),
1108 });
1109 assertions
1110 .register_client(
1111 ClientJwtConfig::builder("fapi-client", jwk)
1112 .algorithms(vec![Algorithm::ES256])
1113 .audience("https://auth.example.com/token")
1114 .build(),
1115 )
1116 .await
1117 .unwrap();
1118 let signing_pem = key.serialize_pem();
1119
1120 let good = assertions
1122 .create_client_assertion(
1123 "fapi-client",
1124 "https://auth.example.com/token",
1125 signing_pem.as_bytes(),
1126 Algorithm::ES256,
1127 )
1128 .unwrap();
1129 assert_eq!(
1130 manager.authenticate_client_jwt(&good).await.unwrap(),
1131 "fapi-client"
1132 );
1133
1134 let wrong_audience = assertions
1137 .create_client_assertion(
1138 "fapi-client",
1139 "https://elsewhere.example/token",
1140 signing_pem.as_bytes(),
1141 Algorithm::ES256,
1142 )
1143 .unwrap();
1144 let unknown = assertions
1145 .create_client_assertion(
1146 "ghost",
1147 "https://auth.example.com/token",
1148 signing_pem.as_bytes(),
1149 Algorithm::ES256,
1150 )
1151 .unwrap();
1152 for (why, assertion) in [
1153 ("wrong audience", wrong_audience.as_str()),
1154 ("unknown client", unknown.as_str()),
1155 ("replay", good.as_str()),
1156 ("junk", "not-a-jwt"),
1157 ] {
1158 let message = manager
1159 .authenticate_client_jwt(assertion)
1160 .await
1161 .expect_err(why)
1162 .to_string();
1163 assert!(
1164 message.contains("Client authentication failed"),
1165 "{why}: {message}"
1166 );
1167 for leak in [
1168 "udience",
1169 "registered",
1170 "ignature",
1171 "replay",
1172 "JTI",
1173 "Algorithm",
1174 "expired",
1175 ] {
1176 assert!(
1177 !message.contains(leak),
1178 "{why}: {message:?} mentions {leak:?}"
1179 );
1180 }
1181 }
1182 }
1183
1184 #[tokio::test]
1185 async fn test_fapi_manager_creation() {
1186 let config = FapiConfig::default();
1188
1189 assert_eq!(config.issuer, "https://auth.example.com"); assert!(config.require_dpop);
1192 assert!(config.require_mtls);
1193 assert!(config.require_par);
1194 assert!(config.enable_jarm);
1195 assert!(config.enhanced_audit);
1196 }
1197
1198 #[tokio::test]
1199 async fn test_fapi_request_validation() {
1200 let config = FapiConfig::default();
1203
1204 let request_object = r#"{"iss":"client_id","aud":"https://example.com","exp":9999999999,"nbf":1000000000,"iat":1000000000,"jti":"unique_id"}"#;
1206
1207 let validation_result = validate_fapi_request_object(request_object, &config);
1209 assert!(
1210 validation_result.is_ok(),
1211 "FAPI request object validation failed"
1212 );
1213
1214 assert!(!request_object.is_empty());
1216 }
1217
1218 fn validate_fapi_request_object(
1220 request_object: &str,
1221 _config: &FapiConfig,
1222 ) -> Result<(), String> {
1223 let parsed: serde_json::Value = serde_json::from_str(request_object)
1225 .map_err(|_| "Invalid JSON structure in request object")?;
1226
1227 let required_claims = ["iss", "aud", "exp", "iat", "jti"];
1229 for claim in &required_claims {
1230 if parsed.get(claim).is_none() {
1231 return Err(format!("Missing required FAPI claim: {}", claim));
1232 }
1233 }
1234
1235 if let Some(exp) = parsed.get("exp").and_then(|v| v.as_i64()) {
1237 let now = chrono::Utc::now().timestamp();
1238 if exp <= now {
1239 return Err("Request object has expired".to_string());
1240 }
1241 }
1242
1243 Ok(())
1246 }
1247
1248 #[tokio::test]
1249 async fn test_fapi_response_generation() {
1250 let config = FapiConfig::default();
1253
1254 let auth_response = serde_json::json!({
1256 "code": "auth_code_123",
1257 "state": "client_state",
1258 "iss": config.issuer,
1259 "aud": "client_id",
1260 "exp": 9999999999i64
1261 });
1262
1263 assert!(auth_response["code"].is_string());
1265 }
1266
1267 #[tokio::test]
1268 async fn test_fapi_token_generation() {
1269 let config = FapiConfig::default();
1271
1272 let scopes = ["accounts".to_string(), "payments".to_string()];
1274 let client_id = "fapi_client_123";
1275 let user_id = "user_456";
1276 let cert_thumbprint = Some("sha256_cert_thumbprint".to_string());
1277
1278 assert!(config.require_dpop);
1280 assert!(config.require_mtls);
1281 assert!(!scopes.is_empty());
1282 assert!(!client_id.is_empty());
1283 assert!(!user_id.is_empty());
1284 assert!(cert_thumbprint.is_some());
1285 }
1286
1287 #[tokio::test]
1288 async fn test_fapi_session_management() {
1289 let config = FapiConfig::default();
1291
1292 let session_data = serde_json::json!({
1294 "client_id": "fapi_client",
1295 "user_id": "fapi_user",
1296 "scopes": ["accounts", "payments"],
1297 "mtls_cert": "client_certificate",
1298 "dpop_key": "client_dpop_key"
1299 });
1300
1301 assert!(session_data["mtls_cert"].is_string());
1303 assert!(session_data["dpop_key"].is_string());
1304 assert!(config.enhanced_audit);
1305 }
1306
1307 fn test_cert(cn: &str, org: Option<&str>) -> rcgen::Certificate {
1310 let mut params = rcgen::CertificateParams::new(Vec::<String>::new()).unwrap();
1311 let mut dn = rcgen::DistinguishedName::new();
1312 dn.push(rcgen::DnType::CommonName, cn);
1313 if let Some(org) = org {
1314 dn.push(rcgen::DnType::OrganizationName, org);
1315 }
1316 params.distinguished_name = dn;
1317 let key = rcgen::KeyPair::generate().unwrap();
1318 params.self_signed(&key).unwrap()
1319 }
1320
1321 #[test]
1322 fn decode_client_certificate_accepts_pem_and_base64_der() {
1323 use base64::Engine;
1324 let cert = test_cert("client-a", None);
1325 let der = cert.der().to_vec();
1326
1327 assert_eq!(decode_client_certificate(&cert.pem()).unwrap(), der);
1328 let b64 = base64::engine::general_purpose::STANDARD.encode(&der);
1329 assert_eq!(decode_client_certificate(&b64).unwrap(), der);
1330 let wrapped = format!(" {}\n{} \n", &b64[..20], &b64[20..]);
1331 assert_eq!(decode_client_certificate(&wrapped).unwrap(), der);
1332 }
1333
1334 #[test]
1335 fn decode_client_certificate_rejects_garbage_and_extra_certificates() {
1336 let a = test_cert("client-a", None).pem();
1337 let b = test_cert("client-b", None).pem();
1338 assert!(decode_client_certificate("").is_err());
1339 assert!(decode_client_certificate("!!! not base64 !!!").is_err());
1340 assert!(decode_client_certificate("-----BEGIN CERTIFICATE-----\nAAAA").is_err());
1341 assert!(decode_client_certificate(&format!("{a}{b}")).is_err());
1343 }
1344
1345 #[test]
1346 fn client_id_comes_from_the_parsed_subject_cn() {
1347 let cert = test_cert("client-a", None);
1348 assert_eq!(client_id_from_certificate(cert.der()).unwrap(), "client-a");
1349 }
1350
1351 #[test]
1352 fn client_id_is_not_found_by_searching_the_raw_bytes() {
1353 let cert = test_cert("real-client", Some("CN=victim-client,"));
1356 assert_eq!(
1357 client_id_from_certificate(cert.der()).unwrap(),
1358 "real-client"
1359 );
1360 }
1361
1362 #[test]
1363 fn client_id_needs_a_unique_identity() {
1364 let mut params = rcgen::CertificateParams::new(Vec::<String>::new()).unwrap();
1366 params.distinguished_name = rcgen::DistinguishedName::new(); let key = rcgen::KeyPair::generate().unwrap();
1368 let nameless = params.self_signed(&key).unwrap();
1369 assert!(client_id_from_certificate(nameless.der()).is_err());
1370 assert!(client_id_from_certificate(b"not a certificate").is_err());
1371 }
1372}
1373
1374#[cfg(test)]
1375mod request_object_age {
1376 use super::*;
1377
1378 #[test]
1379 fn an_age_that_cannot_be_represented_is_too_old() {
1380 let now = Utc::now().timestamp();
1381 assert!(!request_object_too_old(now, now, 60));
1382 assert!(!request_object_too_old(now, now - 60, 60));
1383 assert!(request_object_too_old(now, now - 61, 60));
1384 assert!(request_object_too_old(now, i64::MIN, 60));
1386 assert!(request_object_too_old(now, i64::MIN + 1, 60));
1387 assert!(request_object_too_old(i64::MAX, -1, 60));
1388 }
1389}