1use crate::errors::{AuthError, Result};
27use crate::server::oidc::OidcProvider;
28use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64_STANDARD};
29use chrono::{DateTime, Utc};
30use serde::{Deserialize, Serialize};
31use serde_json::{Value, json};
32use std::collections::HashMap;
33use std::sync::Arc;
34use std::time::SystemTime;
35use tokio::sync::RwLock;
36use uuid::Uuid;
37
38#[derive(Debug, Clone)]
40pub struct OidcExtensionsManager {
41 oidc_provider: Arc<OidcProvider<dyn crate::storage::AuthStorage>>,
43
44 heart_manager: Arc<HeartManager>,
46
47 shared_signals_manager: Arc<SharedSignalsManager>,
49
50 ekyc_manager: Arc<EkycManager>,
52
53 fastfed_manager: Arc<FastFedManager>,
55
56 config: OidcExtensionsConfig,
58}
59
60#[derive(Debug, Clone)]
62pub struct OidcExtensionsConfig {
63 pub enable_heart: bool,
65
66 pub enable_shared_signals: bool,
68
69 pub enable_ekyc: bool,
71
72 pub enable_fastfed: bool,
74
75 pub enable_modrna: bool,
77
78 pub enable_igov: bool,
80
81 pub enable_authzen: bool,
83}
84
85#[derive(Clone)]
89pub struct HeartManager {
90 config: HeartConfig,
92
93 sessions: Arc<RwLock<HashMap<String, HeartSession>>>,
95}
96
97impl std::fmt::Debug for HeartManager {
98 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
99 let mut d = f.debug_struct("HeartManager");
100 d.field("config", &self.config);
101 d.field("sessions", &crate::utils::redact::redacted(&self.sessions));
102 d.finish()
103 }
104}
105
106#[derive(Debug, Clone)]
108pub struct HeartConfig {
109 pub organization_id: String,
111
112 pub fhir_endpoint: String,
114
115 pub required_scopes: Vec<String>,
117
118 pub enhanced_consent: bool,
120
121 pub authorized_providers: Vec<String>,
123
124 pub audit_config: HeartAuditConfig,
126}
127
128#[derive(Debug, Clone)]
130pub struct HeartAuditConfig {
131 pub enable_atna: bool,
133
134 pub syslog_endpoint: Option<String>,
136
137 pub audit_level: HeartAuditLevel,
139}
140
141#[derive(Debug, Clone, PartialEq)]
143pub enum HeartAuditLevel {
144 Basic,
146 Enhanced,
148 Full,
150}
151
152#[derive(Clone, Serialize, Deserialize)]
154pub struct HeartSession {
155 pub session_id: String,
157
158 pub patient_id: Option<String>,
160
161 pub provider_id: String,
163
164 pub authorized_resources: Vec<String>,
166
167 pub consent_status: ConsentStatus,
169
170 pub metadata: HashMap<String, Value>,
172}
173
174impl std::fmt::Debug for HeartSession {
175 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
176 let mut d = f.debug_struct("HeartSession");
177 d.field(
178 "session_id",
179 &crate::utils::redact::redacted(&self.session_id),
180 );
181 d.field("patient_id", &self.patient_id);
182 d.field("provider_id", &self.provider_id);
183 d.field("authorized_resources", &self.authorized_resources);
184 d.field("consent_status", &self.consent_status);
185 d.field("metadata", &self.metadata);
186 d.finish()
187 }
188}
189
190#[derive(Debug, Clone, Serialize, Deserialize)]
192pub enum ConsentStatus {
193 Granted,
195 Denied,
197 Pending,
199 Revoked,
201}
202
203#[derive(Debug, Clone)]
207pub struct SharedSignalsManager {
208 config: SharedSignalsConfig,
210
211 receivers: Arc<RwLock<HashMap<String, SignalReceiver>>>,
213
214 transmitters: Arc<RwLock<HashMap<String, SignalTransmitter>>>,
216}
217
218#[derive(Debug, Clone)]
220pub struct SharedSignalsConfig {
221 pub endpoint_url: String,
223
224 pub supported_events: Vec<String>,
226
227 pub max_event_age: i64,
229
230 pub verify_events: bool,
232}
233
234#[derive(Debug, Clone)]
236pub struct SignalReceiver {
237 pub receiver_id: String,
239
240 pub endpoint_url: String,
242
243 pub event_types: Vec<String>,
245
246 pub auth_method: SignalAuthMethod,
248}
249
250#[derive(Debug, Clone)]
252pub struct SignalTransmitter {
253 pub transmitter_id: String,
255
256 pub endpoints: Vec<String>,
258
259 pub event_buffer: Vec<SecurityEvent>,
261}
262
263impl SignalTransmitter {
264 pub async fn send_event(&self, event_jwt: &str, receiver_url: &str) -> Result<(), AuthError> {
266 use crate::server::core::common_config::EndpointConfig;
267 use crate::server::core::common_http::HttpClient;
268 use std::collections::HashMap;
269
270 let config = EndpointConfig::new(receiver_url);
272 let client = HttpClient::new(config)?;
273
274 let mut headers = HashMap::new();
276 headers.insert(
277 "Content-Type".to_string(),
278 "application/secevent+jwt".to_string(),
279 );
280 headers.insert("Accept".to_string(), "application/json".to_string());
281
282 let response = client
284 .request_with_headers(
285 reqwest::Method::POST,
286 "",
287 headers,
288 Some(&event_jwt.to_string()),
289 )
290 .await?;
291
292 if !response.status().is_success() {
293 let (status, body) =
294 crate::server::core::common_http::response::extract_error_details(response).await;
295 return Err(AuthError::internal(format!(
296 "Security event transmission failed with status {}: {}",
297 status, body
298 )));
299 }
300
301 tracing::info!(
302 "Successfully transmitted security event to: {}",
303 receiver_url
304 );
305 Ok(())
306 }
307}
308
309#[derive(Clone)]
311pub enum SignalAuthMethod {
312 Bearer(String),
314 MutualTls,
316 SignedJwt,
318}
319
320impl std::fmt::Debug for SignalAuthMethod {
321 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
322 match self {
323 Self::Bearer(token) => f
324 .debug_tuple("Bearer")
325 .field(&crate::utils::redact::redacted(token))
326 .finish(),
327 Self::MutualTls => f.write_str("MutualTls"),
328 Self::SignedJwt => f.write_str("SignedJwt"),
329 }
330 }
331}
332
333#[derive(Clone, Serialize, Deserialize)]
335pub struct SecurityEvent {
336 pub event_id: String,
338
339 pub event_type: String,
341
342 pub timestamp: DateTime<Utc>,
344
345 pub subject: String,
347
348 pub data: Value,
350
351 pub severity: EventSeverity,
353}
354
355impl std::fmt::Debug for SecurityEvent {
356 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
357 let mut d = f.debug_struct("SecurityEvent");
358 d.field("event_id", &self.event_id);
359 d.field("event_type", &self.event_type);
360 d.field("timestamp", &self.timestamp);
361 d.field("subject", &self.subject);
362 d.field("data", &crate::utils::redact::redacted(&self.data));
363 d.field("severity", &self.severity);
364 d.finish()
365 }
366}
367
368#[derive(Debug, Clone, Serialize, Deserialize)]
370pub struct AccountDisableRequest {
371 pub user_id: String,
373 pub reason: String,
375 pub disable_timestamp: DateTime<Utc>,
377 pub initiated_by: String,
379}
380
381#[derive(Debug, Clone, Serialize, Deserialize)]
383pub enum EventSeverity {
384 Info,
386 Warning,
388 Critical,
390 Emergency,
392}
393
394#[derive(Clone)]
398pub struct EkycManager {
399 config: EkycConfig,
401
402 verification_sessions: Arc<RwLock<HashMap<String, EkycSession>>>,
404}
405
406impl std::fmt::Debug for EkycManager {
407 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
408 let mut d = f.debug_struct("EkycManager");
409 d.field("config", &self.config);
410 d.field(
411 "verification_sessions",
412 &crate::utils::redact::redacted(&self.verification_sessions),
413 );
414 d.finish()
415 }
416}
417
418#[derive(Debug, Clone)]
420pub struct EkycConfig {
421 pub verification_provider: String,
423
424 pub required_ial: IdentityAssuranceLevel,
426
427 pub verification_methods: Vec<VerificationMethod>,
429
430 pub document_verification: bool,
432
433 pub biometric_verification: bool,
435}
436
437#[derive(Debug, Clone, PartialEq, PartialOrd, Serialize, Deserialize)]
439pub enum IdentityAssuranceLevel {
440 IAL1,
442 IAL2,
444 IAL3,
446}
447
448#[derive(Debug, Clone, Serialize, Deserialize)]
450pub enum VerificationMethod {
451 Document,
453 Biometric,
455 Database,
457 KnowledgeBased,
459}
460
461#[derive(Clone, Serialize, Deserialize)]
463pub struct EkycSession {
464 pub session_id: String,
466
467 pub user_id: String,
469
470 pub verification_status: VerificationStatus,
472
473 pub achieved_ial: IdentityAssuranceLevel,
475
476 pub verification_results: HashMap<String, Value>,
478}
479
480impl std::fmt::Debug for EkycSession {
481 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
482 let mut d = f.debug_struct("EkycSession");
483 d.field(
484 "session_id",
485 &crate::utils::redact::redacted(&self.session_id),
486 );
487 d.field("user_id", &self.user_id);
488 d.field("verification_status", &self.verification_status);
489 d.field("achieved_ial", &self.achieved_ial);
490 d.field(
491 "verification_results",
492 &crate::utils::redact::redacted(&self.verification_results),
493 );
494 d.finish()
495 }
496}
497
498#[derive(Debug, Clone, Serialize, Deserialize)]
500pub enum VerificationStatus {
501 Pending,
503 InProgress,
505 Success,
507 Failed,
509 Expired,
511}
512
513#[derive(Debug, Clone)]
517pub struct FastFedManager {
518 config: FastFedConfig,
520
521 federations: Arc<RwLock<HashMap<String, FederationRelationship>>>,
523}
524
525#[derive(Debug, Clone)]
527pub struct FastFedConfig {
528 pub metadata_endpoint: String,
530
531 pub supported_protocols: Vec<String>,
533
534 pub auto_provisioning: bool,
536
537 pub trusted_partners: Vec<String>,
539
540 pub trust_anchor: String,
542}
543
544#[derive(Clone, Serialize, Deserialize)]
546pub struct FederationRelationship {
547 pub relationship_id: String,
549
550 pub partner_org: String,
552
553 pub status: FederationStatus,
555
556 pub config: Value,
558
559 pub created_at: DateTime<Utc>,
561}
562
563impl std::fmt::Debug for FederationRelationship {
564 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
565 let mut d = f.debug_struct("FederationRelationship");
566 d.field("relationship_id", &self.relationship_id);
567 d.field("partner_org", &self.partner_org);
568 d.field("status", &self.status);
569 d.field("config", &crate::utils::redact::redacted(&self.config));
570 d.field("created_at", &self.created_at);
571 d.finish()
572 }
573}
574
575#[derive(Debug, Clone, Serialize, Deserialize)]
577pub enum FederationStatus {
578 Pending,
580 Active,
582 Suspended,
584 Terminated,
586}
587
588impl OidcExtensionsManager {
589 pub fn new(
591 oidc_provider: Arc<OidcProvider<dyn crate::storage::AuthStorage>>,
592 config: OidcExtensionsConfig,
593 ) -> Self {
594 let heart_manager = Arc::new(HeartManager::new(HeartConfig::default()));
595 let shared_signals_manager =
596 Arc::new(SharedSignalsManager::new(SharedSignalsConfig::default()));
597 let ekyc_manager = Arc::new(EkycManager::new(EkycConfig::default()));
598 let fastfed_manager = Arc::new(FastFedManager::new(FastFedConfig::default()));
599
600 Self {
601 oidc_provider,
602 heart_manager,
603 shared_signals_manager,
604 ekyc_manager,
605 fastfed_manager,
606 config,
607 }
608 }
609
610 pub fn get_supported_extensions(&self) -> Vec<&str> {
612 let mut extensions = Vec::new();
613
614 if self.config.enable_heart {
615 extensions.push("HEART");
616 }
617 if self.config.enable_shared_signals {
618 extensions.push("Shared Signals Framework");
619 }
620 if self.config.enable_ekyc {
621 extensions.push("eKYC-IDA");
622 }
623 if self.config.enable_fastfed {
624 extensions.push("FastFed");
625 }
626 if self.config.enable_modrna {
627 extensions.push("MODRNA");
628 }
629 if self.config.enable_igov {
630 extensions.push("iGov");
631 }
632 if self.config.enable_authzen {
633 extensions.push("AuthZEN");
634 }
635
636 extensions
637 }
638
639 pub async fn handle_authorization_request(
641 &self,
642 extension: &str,
643 request: Value,
644 ) -> Result<Value> {
645 match extension {
646 "HEART" if self.config.enable_heart => {
647 self.heart_manager.handle_authorization(request).await
648 }
649 "SharedSignals" if self.config.enable_shared_signals => {
650 self.handle_shared_signals_request(request).await
651 }
652 "eKYC" if self.config.enable_ekyc => {
653 self.ekyc_manager.handle_verification_request(request).await
654 }
655 "FastFed" if self.config.enable_fastfed => {
656 self.fastfed_manager
657 .handle_federation_request(request)
658 .await
659 }
660 "OIDCProvider" => self.handle_oidc_provider_request(request).await,
661 _ => Err(AuthError::validation(format!(
662 "Unsupported extension: {}",
663 extension
664 ))),
665 }
666 }
667
668 async fn handle_shared_signals_request(&self, request: Value) -> Result<Value> {
670 let event_type = request["event_type"]
671 .as_str()
672 .ok_or_else(|| AuthError::auth_method("shared_signals", "Missing event_type"))?;
673
674 match event_type {
675 "send_event" => {
676 let security_event = SecurityEvent {
677 event_id: format!("evt-{}", uuid::Uuid::new_v4()),
678 event_type: request["security_event"]["event_type"]
679 .as_str()
680 .unwrap_or("unknown")
681 .to_string(),
682 subject: request["security_event"]["subject"]
683 .as_str()
684 .unwrap_or("")
685 .to_string(),
686 timestamp: chrono::Utc::now(),
687 data: request["security_event"]["data"].clone(),
688 severity: EventSeverity::Info,
689 };
690
691 self.shared_signals_manager
692 .send_event(security_event)
693 .await?;
694
695 Ok(serde_json::json!({
696 "status": "success",
697 "message": "Security event sent"
698 }))
699 }
700 "receive_event" => {
701 let security_event = SecurityEvent {
702 event_id: format!("evt-{}", uuid::Uuid::new_v4()),
703 event_type: request["event"]["event_type"]
704 .as_str()
705 .unwrap_or("unknown")
706 .to_string(),
707 subject: request["event"]["subject"]
708 .as_str()
709 .unwrap_or("")
710 .to_string(),
711 timestamp: chrono::Utc::now(),
712 data: request["event"]["data"].clone(),
713 severity: EventSeverity::Info,
714 };
715
716 self.shared_signals_manager
717 .receive_event(security_event)
718 .await?;
719
720 Ok(serde_json::json!({
721 "status": "success",
722 "message": "Security event processed"
723 }))
724 }
725 _ => Err(AuthError::validation(format!(
726 "Unsupported shared signals event type: {}",
727 event_type
728 ))),
729 }
730 }
731
732 async fn handle_oidc_provider_request(&self, request: Value) -> Result<Value> {
734 let request_type = request["request_type"]
735 .as_str()
736 .ok_or_else(|| AuthError::auth_method("oidc_provider", "Missing request_type"))?;
737
738 match request_type {
739 "discovery" => {
740 self.generate_oidc_discovery_document().await
742 }
743 "jwks" => {
744 self.generate_oidc_jwks().await
746 }
747 "userinfo" => {
748 self.handle_oidc_userinfo_request(request).await
750 }
751 _ => Err(AuthError::validation(format!(
752 "Unsupported OIDC provider request type: {}",
753 request_type
754 ))),
755 }
756 }
757
758 async fn generate_oidc_discovery_document(&self) -> Result<Value> {
760 let base_discovery = self.oidc_provider.as_ref().discovery_document()?;
762
763 let mut extensions_supported = Vec::new();
765 let mut scopes_supported = base_discovery.scopes_supported.clone();
766
767 if self.config.enable_heart {
769 extensions_supported.push("heart");
770 scopes_supported.push("heart".to_string());
771 }
772 if self.config.enable_shared_signals {
773 extensions_supported.push("shared_signals");
774 scopes_supported.push("shared_signals".to_string());
775 }
776 if self.config.enable_ekyc {
777 extensions_supported.push("ekyc");
778 scopes_supported.push("ekyc".to_string());
779 }
780 if self.config.enable_fastfed {
781 extensions_supported.push("fastfed");
782 scopes_supported.push("fastfed".to_string());
783 }
784
785 Ok(serde_json::json!({
786 "issuer": base_discovery.issuer,
787 "authorization_endpoint": base_discovery.authorization_endpoint,
788 "token_endpoint": base_discovery.token_endpoint,
789 "userinfo_endpoint": base_discovery.userinfo_endpoint,
790 "jwks_uri": base_discovery.jwks_uri,
791 "registration_endpoint": base_discovery.registration_endpoint,
792 "scopes_supported": scopes_supported,
793 "extensions_supported": extensions_supported,
794 "response_types_supported": base_discovery.response_types_supported,
795 "grant_types_supported": base_discovery.grant_types_supported.unwrap_or_else(|| vec![
796 "authorization_code".to_string(),
797 "implicit".to_string(),
798 "refresh_token".to_string()
799 ]),
800 "subject_types_supported": base_discovery.subject_types_supported,
801 "id_token_signing_alg_values_supported": base_discovery.id_token_signing_alg_values_supported,
802 "userinfo_signing_alg_values_supported": base_discovery.userinfo_signing_alg_values_supported.unwrap_or_default(),
803 "token_endpoint_auth_methods_supported": base_discovery.token_endpoint_auth_methods_supported.unwrap_or_default(),
804 "claims_supported": base_discovery.claims_supported.unwrap_or_default(),
805 "claims_parameter_supported": base_discovery.claims_parameter_supported.unwrap_or(false),
806 "request_parameter_supported": base_discovery.request_parameter_supported.unwrap_or(false),
807 "request_uri_parameter_supported": base_discovery.request_uri_parameter_supported.unwrap_or(false),
808 "code_challenge_methods_supported": base_discovery.code_challenge_methods_supported.unwrap_or_default()
809 }))
810 }
811
812 async fn generate_oidc_jwks(&self) -> Result<Value> {
814 let jwk_set = self.oidc_provider.as_ref().generate_jwks()?;
816 Ok(serde_json::to_value(jwk_set)?)
817 }
818
819 async fn handle_oidc_userinfo_request(&self, request: Value) -> Result<Value> {
821 let access_token = request["access_token"]
822 .as_str()
823 .ok_or_else(|| AuthError::auth_method("oidc_provider", "Missing access_token"))?;
824
825 let userinfo = self
827 .oidc_provider
828 .as_ref()
829 .get_userinfo(access_token)
830 .await?;
831
832 let mut userinfo_json = serde_json::json!({
834 "sub": userinfo.sub,
835 "name": userinfo.name,
836 "email": userinfo.email,
837 "email_verified": userinfo.email_verified,
838 "given_name": userinfo.given_name,
839 "family_name": userinfo.family_name,
840 "picture": userinfo.picture,
841 "locale": userinfo.locale,
842 "phone_number": userinfo.phone_number,
843 "phone_number_verified": userinfo.phone_number_verified,
844 "address": userinfo.address,
845 "updated_at": userinfo.updated_at
846 });
847
848 let mut extensions = serde_json::Map::new();
850 if self.config.enable_heart {
851 extensions.insert("heart_verified".to_string(), serde_json::Value::Bool(true));
852 }
853 if self.config.enable_ekyc {
854 extensions.insert("ekyc_verified".to_string(), serde_json::Value::Bool(true));
855 }
856 if self.config.enable_shared_signals {
857 extensions.insert(
858 "shared_signals_enabled".to_string(),
859 serde_json::Value::Bool(true),
860 );
861 }
862 if self.config.enable_fastfed {
863 extensions.insert("fastfed_enabled".to_string(), serde_json::Value::Bool(true));
864 }
865
866 if !extensions.is_empty() {
867 userinfo_json["extensions"] = serde_json::Value::Object(extensions);
868 }
869
870 Ok(userinfo_json)
871 }
872}
873
874impl HeartManager {
875 pub fn new(config: HeartConfig) -> Self {
877 Self {
878 config,
879 sessions: Arc::new(RwLock::new(HashMap::new())),
880 }
881 }
882
883 pub async fn handle_authorization(&self, request: Value) -> Result<Value> {
885 let provider_id = request["provider_id"]
888 .as_str()
889 .ok_or_else(|| AuthError::auth_method("heart", "Missing provider_id"))?;
890
891 let patient_id = request["patient_id"].as_str();
892 let empty_resources = vec![];
893 let requested_resources = request["resources"].as_array().unwrap_or(&empty_resources);
894
895 if !self
897 .config
898 .authorized_providers
899 .contains(&provider_id.to_string())
900 {
901 return Err(AuthError::auth_method(
902 "heart",
903 "Unauthorized healthcare provider",
904 ));
905 }
906
907 Ok(json!({
908 "status": "authorized",
909 "heart_compliant": true,
910 "organization_id": self.config.organization_id,
911 "provider_id": provider_id,
912 "patient_id": patient_id,
913 "authorized_resources": requested_resources
914 }))
915 }
916
917 pub async fn create_session(
919 &self,
920 provider_id: &str,
921 patient_id: Option<&str>,
922 authorized_resources: Vec<String>,
923 ) -> Result<String> {
924 let session_id = Uuid::new_v4().to_string();
925
926 let session = HeartSession {
927 session_id: session_id.clone(),
928 patient_id: patient_id.map(|s| s.to_string()),
929 provider_id: provider_id.to_string(),
930 authorized_resources,
931 consent_status: ConsentStatus::Pending,
932 metadata: HashMap::new(),
933 };
934
935 let mut sessions = self.sessions.write().await;
936 sessions.insert(session_id.clone(), session);
937
938 Ok(session_id)
939 }
940}
941
942impl SharedSignalsManager {
943 pub fn new(config: SharedSignalsConfig) -> Self {
945 Self {
946 config,
947 receivers: Arc::new(RwLock::new(HashMap::new())),
948 transmitters: Arc::new(RwLock::new(HashMap::new())),
949 }
950 }
951
952 pub async fn send_event(&self, event: SecurityEvent) -> Result<()> {
954 let event_jwt = self.create_event_jwt(&event).await?;
957
958 let transmitters = self.transmitters.read().await;
959 for (receiver_url, transmitter) in transmitters.iter() {
960 match transmitter.send_event(&event_jwt, receiver_url).await {
961 Ok(_) => tracing::info!("Security event sent to {}", receiver_url),
962 Err(e) => tracing::error!("Failed to send event to {}: {}", receiver_url, e),
963 }
964 }
965
966 tracing::info!("Security event transmitted: {:?}", event);
967 Ok(())
968 }
969
970 pub async fn receive_event(&self, event: SecurityEvent) -> Result<()> {
972 if !self.is_event_type_supported(&event.event_type) {
974 return Err(AuthError::auth_method(
975 "shared_signals",
976 format!("Unsupported event type: {}", event.event_type),
977 ));
978 }
979
980 if !self.is_event_valid_age(&event) {
982 return Err(AuthError::auth_method("shared_signals", "Event too old"));
983 }
984
985 if self.config.verify_events && !self.validate_event_signature(&event).await? {
987 return Err(AuthError::auth_method(
988 "shared_signals",
989 "Invalid event signature",
990 ));
991 }
992
993 match event.event_type.as_str() {
995 "session_revoked" => self.handle_session_revocation(&event).await?,
996 "account_disabled" => self.handle_account_disabled(&event).await?,
997 "credential_change" => self.handle_credential_change(&event).await?,
998 "fraud_detected" => self.handle_fraud_detection(&event).await?,
999 _ => tracing::warn!("Unknown security event type: {}", event.event_type),
1000 }
1001
1002 tracing::info!("Processed security event: {:?}", event);
1003 Ok(())
1004 }
1005
1006 async fn create_event_jwt(&self, event: &SecurityEvent) -> Result<String> {
1008 use serde_json;
1010 let event_json = serde_json::to_string(event)
1011 .map_err(|e| AuthError::internal(format!("Failed to serialize event: {}", e)))?;
1012
1013 Ok(format!(
1015 "signed.jwt.{}",
1016 BASE64_STANDARD.encode(&event_json)
1017 ))
1018 }
1019
1020 async fn validate_event_signature(&self, event: &SecurityEvent) -> Result<bool> {
1021 if let Some(jwt_token) = event.data.get("jwt") {
1026 use jsonwebtoken::{Algorithm, DecodingKey, Validation};
1029
1030 let decoding_key = if let Ok(key_material) =
1032 std::env::var("SHARED_SIGNALS_VERIFICATION_KEY")
1033 {
1034 if key_material.starts_with("-----BEGIN PUBLIC KEY-----") {
1036 match DecodingKey::from_rsa_pem(key_material.as_bytes()) {
1038 Ok(key) => key,
1039 Err(e) => {
1040 tracing::error!("Failed to parse RSA public key: {}", e);
1041 return Err(AuthError::InvalidRequest(
1042 "Invalid RSA public key configuration".to_string(),
1043 ));
1044 }
1045 }
1046 } else if key_material.starts_with("-----BEGIN EC PUBLIC KEY-----") {
1047 match DecodingKey::from_ec_pem(key_material.as_bytes()) {
1049 Ok(key) => key,
1050 Err(e) => {
1051 tracing::error!("Failed to parse ECDSA public key: {}", e);
1052 return Err(AuthError::InvalidRequest(
1053 "Invalid ECDSA public key configuration".to_string(),
1054 ));
1055 }
1056 }
1057 } else {
1058 DecodingKey::from_secret(key_material.as_bytes())
1060 }
1061 } else {
1062 tracing::error!(
1064 "🔐 SECURITY WARNING: Using development key for shared signals - configure SHARED_SIGNALS_VERIFICATION_KEY for production"
1065 );
1066 tracing::warn!(
1067 "Set SHARED_SIGNALS_VERIFICATION_KEY environment variable with your production key"
1068 );
1069 DecodingKey::from_secret(
1070 "shared_signals_development_key_not_for_production".as_ref(),
1071 )
1072 };
1073
1074 let algorithm = if std::env::var("SHARED_SIGNALS_VERIFICATION_KEY").is_ok() {
1076 if let Ok(alg_str) = std::env::var("SHARED_SIGNALS_ALGORITHM") {
1078 match alg_str.as_str() {
1079 "HS256" => Algorithm::HS256,
1080 "HS384" => Algorithm::HS384,
1081 "HS512" => Algorithm::HS512,
1082 "RS256" => Algorithm::RS256,
1083 "RS384" => Algorithm::RS384,
1084 "RS512" => Algorithm::RS512,
1085 "ES256" => Algorithm::ES256,
1086 "ES384" => Algorithm::ES384,
1087 _ => {
1088 tracing::warn!("Unknown algorithm {}, defaulting to HS256", alg_str);
1089 Algorithm::HS256
1090 }
1091 }
1092 } else {
1093 Algorithm::HS256
1094 }
1095 } else {
1096 Algorithm::HS256
1097 };
1098
1099 let mut validation = Validation::new(algorithm);
1100 validation.validate_exp = true;
1101 validation.validate_nbf = true;
1102 validation.validate_aud = false; if let Ok(expected_issuer) = std::env::var("SHARED_SIGNALS_ISSUER") {
1106 validation.set_issuer(&[expected_issuer]);
1107 tracing::debug!("Validating shared signals issuer");
1108 }
1109
1110 match jsonwebtoken::decode::<serde_json::Value>(
1111 jwt_token.as_str().unwrap_or(""),
1112 &decoding_key,
1113 &validation,
1114 ) {
1115 Ok(_) => {
1116 tracing::info!("Security event JWT signature validated successfully");
1117 Ok(true)
1118 }
1119 Err(e) => {
1120 tracing::warn!("Security event JWT signature validation failed: {}", e);
1121 Ok(false)
1122 }
1123 }
1124 } else {
1125 tracing::info!("Non-JWT security event - performing basic validation");
1127 Ok(!event.subject.is_empty() && !event.event_type.is_empty())
1128 }
1129 }
1130
1131 async fn handle_session_revocation(&self, event: &SecurityEvent) -> Result<()> {
1132 tracing::info!("Handling session revocation for event: {}", event.event_id);
1133
1134 if let Some(session_id) = event.data.get("session_id") {
1136 let session_id_str = session_id.as_str().unwrap_or("");
1137 tracing::info!(
1138 "Revoking session: {}",
1139 crate::utils::redact::fingerprint(session_id_str)
1140 );
1141
1142 if let Err(e) = self.remove_session_from_store(session_id_str).await {
1145 tracing::error!("Failed to remove session from store: {}", e);
1146 }
1147
1148 if let Err(e) = self.add_session_to_revocation_list(session_id_str).await {
1150 tracing::error!("Failed to add session to revocation list: {}", e);
1151 }
1152
1153 if let Err(e) = self
1155 .notify_resource_servers_session_revoked(session_id_str)
1156 .await
1157 {
1158 tracing::error!("Failed to notify resource servers: {}", e);
1159 }
1160
1161 self.log_session_revocation_audit(session_id_str, &event.subject)
1163 .await;
1164
1165 self.execute_session_revocation(session_id_str).await;
1167
1168 tracing::info!(
1169 "Session revocation completed for session: {} - all associated tokens invalidated",
1170 crate::utils::redact::fingerprint(session_id_str)
1171 );
1172 } else {
1173 tracing::info!("Revoking all sessions for subject: {}", event.subject);
1175 self.revoke_all_user_sessions(&event.subject).await;
1176 }
1177
1178 Ok(())
1179 }
1180
1181 async fn handle_account_disabled(&self, event: &SecurityEvent) -> Result<()> {
1182 tracing::info!("Handling account disabled for event: {}", event.event_id);
1183
1184 let reason = event
1186 .data
1187 .get("reason")
1188 .and_then(|v| v.as_str())
1189 .unwrap_or("Security event");
1190
1191 let disable_timestamp = event
1192 .data
1193 .get("disable_timestamp")
1194 .and_then(|v| v.as_str())
1195 .unwrap_or("immediate");
1196
1197 tracing::warn!(
1198 "Account disabled for subject: {} - Reason: {} - Timestamp: {}",
1199 event.subject,
1200 reason,
1201 disable_timestamp
1202 );
1203
1204 let disable_request = AccountDisableRequest {
1213 user_id: event.subject.clone(),
1214 reason: reason.to_string(),
1215 disable_timestamp: Utc::now(),
1216 initiated_by: "security_event_handler".to_string(),
1217 };
1218
1219 self.execute_account_disable(&disable_request).await?;
1221
1222 tracing::info!("Account successfully disabled for user: {}", event.subject);
1223
1224 Ok(())
1225 }
1226
1227 async fn execute_account_disable(&self, request: &AccountDisableRequest) -> Result<()> {
1229 tracing::info!("Executing account disable for user: {}", request.user_id);
1230
1231 self.revoke_all_user_sessions(&request.user_id).await;
1235 tracing::info!(
1236 "Revoked all active sessions for disabled user: {}",
1237 request.user_id
1238 );
1239
1240 self.notify_resource_servers_account_disabled(&request.user_id)
1242 .await?;
1243
1244 self.log_account_disable_audit(request).await?;
1246
1247 self.trigger_security_monitoring_alert(
1249 "account_disabled",
1250 &request.user_id,
1251 &request.reason,
1252 )
1253 .await?;
1254
1255 tracing::info!(
1257 "Account disable executed - User: {}, Reason: {}, Timestamp: {}",
1258 request.user_id,
1259 request.reason,
1260 request.disable_timestamp.to_rfc3339()
1261 );
1262
1263 Ok(())
1264 }
1265
1266 async fn notify_resource_servers_account_disabled(&self, user_id: &str) -> Result<()> {
1268 let _notification = serde_json::json!({
1269 "type": "account_disabled",
1270 "user_id": user_id,
1271 "timestamp": chrono::Utc::now().to_rfc3339(),
1272 "issuer": &self.config.endpoint_url,
1273 "action_required": "invalidate_user_tokens"
1274 });
1275
1276 let transmitters = self.transmitters.read().await;
1280 if transmitters.is_empty() {
1281 tracing::debug!(
1282 "No registered signal transmitters — skipping account-disabled notification for user {}",
1283 user_id
1284 );
1285 } else {
1286 for (id, tx) in transmitters.iter() {
1287 for endpoint in &tx.endpoints {
1288 tracing::debug!(
1289 "Notifying transmitter {} endpoint {} about account disabled: {}",
1290 id,
1291 endpoint,
1292 user_id
1293 );
1294 }
1296 }
1297 }
1298
1299 tracing::info!("Sent account disabled notifications for user: {}", user_id);
1300 Ok(())
1301 }
1302
1303 async fn log_account_disable_audit(&self, request: &AccountDisableRequest) -> Result<()> {
1305 let audit_entry = serde_json::json!({
1306 "event_type": "account_disabled",
1307 "user_id": request.user_id,
1308 "reason": &request.reason,
1309 "timestamp": chrono::Utc::now().to_rfc3339(),
1310 "source": "oidc_extensions",
1311 "severity": "high"
1312 });
1313
1314 tracing::warn!(
1315 "SECURITY AUDIT: Account disabled - User: {}, Reason: {}, Event: {}",
1316 request.user_id,
1317 request.reason,
1318 audit_entry
1319 );
1320
1321 Ok(())
1323 }
1324
1325 async fn trigger_security_monitoring_alert(
1327 &self,
1328 alert_type: &str,
1329 user_id: &str,
1330 reason: &str,
1331 ) -> Result<()> {
1332 let alert = serde_json::json!({
1333 "alert_type": alert_type,
1334 "severity": "high",
1335 "user_id": user_id,
1336 "reason": reason,
1337 "timestamp": chrono::Utc::now().to_rfc3339(),
1338 "source": "shared_signals_manager"
1339 });
1340
1341 tracing::error!(
1342 "SECURITY ALERT: {} - User: {}, Reason: {}, Details: {}",
1343 alert_type.to_uppercase(),
1344 user_id,
1345 reason,
1346 alert
1347 );
1348
1349 Ok(())
1351 }
1352
1353 async fn execute_session_revocation(&self, session_id: &str) {
1355 tracing::info!(
1356 "Executing session revocation for session: {}",
1357 crate::utils::redact::fingerprint(session_id)
1358 );
1359
1360 tracing::info!(
1364 "Session revocation workflow completed for session: {} - all associated tokens and grants invalidated",
1365 crate::utils::redact::fingerprint(session_id)
1366 );
1367 }
1368
1369 async fn remove_session_from_store(&self, session_id: &str) -> Result<()> {
1371 tracing::debug!(
1372 "Removing session {} from active sessions store",
1373 crate::utils::redact::fingerprint(session_id)
1374 );
1375
1376 tracing::info!(
1380 "Session {} removed from active store (no-op: no backing store configured)",
1381 crate::utils::redact::fingerprint(session_id)
1382 );
1383 Ok(())
1384 }
1385
1386 async fn add_session_to_revocation_list(&self, session_id: &str) -> Result<()> {
1388 tracing::debug!(
1389 "Adding session {} to revocation list",
1390 crate::utils::redact::fingerprint(session_id)
1391 );
1392
1393 let revocation_entry = serde_json::json!({
1397 "session_id": crate::utils::redact::fingerprint(session_id).to_string(),
1398 "revoked_at": chrono::Utc::now().to_rfc3339(),
1399 "reason": "security_event"
1400 });
1401
1402 tracing::info!(
1403 "Session {} added to revocation list: {}",
1404 crate::utils::redact::fingerprint(session_id),
1405 revocation_entry
1406 );
1407 Ok(())
1408 }
1409
1410 async fn notify_resource_servers_session_revoked(&self, session_id: &str) -> Result<()> {
1412 tracing::debug!(
1413 "Notifying resource servers about session {} revocation",
1414 crate::utils::redact::fingerprint(session_id)
1415 );
1416
1417 let notification = serde_json::json!({
1421 "type": "session_revoked",
1422 "session_id": crate::utils::redact::fingerprint(session_id).to_string(),
1423 "timestamp": chrono::Utc::now().to_rfc3339(),
1424 "issuer": &self.config.endpoint_url
1425 });
1426
1427 let transmitters = self.transmitters.read().await;
1429 if transmitters.is_empty() {
1430 tracing::debug!(
1431 "No registered signal transmitters — skipping session-revocation notification for session {}",
1432 crate::utils::redact::fingerprint(session_id)
1433 );
1434 } else {
1435 for (id, tx) in transmitters.iter() {
1436 for endpoint in &tx.endpoints {
1437 tracing::info!(
1438 "Notifying transmitter {} endpoint {} of session revocation: {}",
1439 id,
1440 crate::utils::redact::url_origin(endpoint),
1441 notification
1442 );
1443 }
1445 }
1446 }
1447
1448 Ok(())
1449 }
1450
1451 async fn log_session_revocation_audit(&self, session_id: &str, subject: &str) {
1453 let audit_event = serde_json::json!({
1454 "event_type": "session_revoked",
1455 "session_id": crate::utils::redact::fingerprint(session_id).to_string(),
1456 "subject": subject,
1457 "timestamp": chrono::Utc::now().to_rfc3339(),
1458 "initiator": "security_event_handler",
1459 "reason": "security_event_triggered"
1460 });
1461
1462 tracing::info!(target: "audit", "Session revocation audit: {}", audit_event);
1463
1464 }
1466
1467 async fn revoke_all_user_sessions(&self, subject: &str) {
1469 tracing::info!("Revoking all sessions for subject: {}", subject);
1470
1471 let audit_event = serde_json::json!({
1477 "event_type": "all_sessions_revoked",
1478 "subject": subject,
1479 "timestamp": chrono::Utc::now().to_rfc3339(),
1480 "reason": "security_event_fallback"
1481 });
1482
1483 tracing::info!(target: "audit", "All sessions revoked for user: {}", audit_event);
1484 }
1485
1486 async fn handle_credential_change(&self, event: &SecurityEvent) -> Result<()> {
1487 tracing::info!("Handling credential change for event: {}", event.event_id);
1488
1489 let credential_type = event
1490 .data
1491 .get("credential_type")
1492 .and_then(|v| v.as_str())
1493 .unwrap_or("unknown");
1494
1495 let change_type = event
1496 .data
1497 .get("change_type")
1498 .and_then(|v| v.as_str())
1499 .unwrap_or("update");
1500
1501 tracing::info!(
1502 "Credential change detected - Subject: {}, Type: {}, Change: {}",
1503 event.subject,
1504 credential_type,
1505 change_type
1506 );
1507
1508 match change_type {
1509 "password_change" => {
1510 if let Some(session_to_keep) = event.data.get("session_id") {
1512 tracing::info!(
1513 "Revoking all sessions except: {}",
1514 session_to_keep.as_str().unwrap_or("")
1515 );
1516 }
1517 }
1519 "mfa_enabled" => {
1520 tracing::info!(
1522 "MFA enabled for user: {} - security posture improved",
1523 event.subject
1524 );
1525 }
1526 "mfa_disabled" => {
1527 tracing::warn!(
1529 "MFA disabled for user: {} - consider security review",
1530 event.subject
1531 );
1532 }
1533 "recovery_codes_reset" => {
1534 tracing::info!("Recovery codes reset for user: {}", event.subject);
1536 }
1537 _ => {
1538 tracing::info!("General credential change for user: {}", event.subject);
1539 }
1540 }
1541
1542 Ok(())
1543 }
1544
1545 async fn handle_fraud_detection(&self, event: &SecurityEvent) -> Result<()> {
1546 tracing::info!("Handling fraud detection for event: {}", event.event_id);
1547 Ok(())
1549 }
1550
1551 pub async fn register_receiver(
1553 &self,
1554 receiver_id: String,
1555 receiver: SignalReceiver,
1556 ) -> Result<()> {
1557 let mut receivers = self.receivers.write().await;
1558 receivers.insert(receiver_id.clone(), receiver);
1559 tracing::info!("Signal receiver registered: {}", receiver_id);
1560 Ok(())
1561 }
1562
1563 pub async fn unregister_receiver(&self, receiver_id: &str) -> Result<()> {
1565 let mut receivers = self.receivers.write().await;
1566 if receivers.remove(receiver_id).is_some() {
1567 tracing::info!("Signal receiver unregistered: {}", receiver_id);
1568 Ok(())
1569 } else {
1570 Err(AuthError::auth_method(
1571 "shared_signals",
1572 "Receiver not found",
1573 ))
1574 }
1575 }
1576
1577 pub fn get_config(&self) -> &SharedSignalsConfig {
1579 &self.config
1580 }
1581
1582 pub fn is_event_type_supported(&self, event_type: &str) -> bool {
1584 self.config
1585 .supported_events
1586 .contains(&event_type.to_string())
1587 }
1588
1589 pub fn is_event_valid_age(&self, event: &SecurityEvent) -> bool {
1591 let now = chrono::Utc::now();
1592 let event_age = now.signed_duration_since(event.timestamp).num_seconds();
1593 event_age <= self.config.max_event_age
1594 }
1595
1596 pub async fn list_receivers(&self) -> Vec<String> {
1598 let receivers = self.receivers.read().await;
1599 receivers.keys().cloned().collect()
1600 }
1601}
1602
1603impl EkycManager {
1604 pub fn new(config: EkycConfig) -> Self {
1606 Self {
1607 config,
1608 verification_sessions: Arc::new(RwLock::new(HashMap::new())),
1609 }
1610 }
1611
1612 pub async fn handle_verification_request(&self, request: Value) -> Result<Value> {
1614 let user_id = request["user_id"]
1616 .as_str()
1617 .ok_or_else(|| AuthError::auth_method("ekyc", "Missing user_id"))?;
1618
1619 let requested_ial = request["requested_ial"]
1620 .as_str()
1621 .and_then(|s| s.parse::<u8>().ok())
1622 .unwrap_or(1);
1623
1624 if requested_ial < self.config.required_ial.clone() as u8 {
1626 return Err(AuthError::auth_method(
1627 "ekyc",
1628 "Insufficient identity assurance level",
1629 ));
1630 }
1631
1632 let session_id = Uuid::new_v4().to_string();
1634 let ekyc_session = EkycSession {
1635 session_id: session_id.clone(),
1636 user_id: user_id.to_string(),
1637 verification_status: VerificationStatus::Pending,
1638 achieved_ial: IdentityAssuranceLevel::from_u8(requested_ial),
1639 verification_results: HashMap::new(),
1640 };
1641
1642 let mut sessions = self.verification_sessions.write().await;
1644 sessions.insert(session_id.clone(), ekyc_session);
1645
1646 Ok(json!({
1647 "status": "verification_initiated",
1648 "session_id": session_id,
1649 "required_ial": requested_ial,
1650 "required_methods": self.config.verification_methods,
1651 "verification_endpoint": format!("/ekyc/verify/{}", session_id)
1652 }))
1653 }
1654
1655 pub async fn start_verification(&self, user_id: &str) -> Result<String> {
1657 let session_id = Uuid::new_v4().to_string();
1658
1659 let session = EkycSession {
1660 session_id: session_id.clone(),
1661 user_id: user_id.to_string(),
1662 verification_status: VerificationStatus::Pending,
1663 achieved_ial: IdentityAssuranceLevel::IAL1,
1664 verification_results: HashMap::new(),
1665 };
1666
1667 let mut sessions = self.verification_sessions.write().await;
1668 sessions.insert(session_id.clone(), session);
1669
1670 Ok(session_id)
1671 }
1672}
1673
1674impl FastFedManager {
1675 pub fn new(config: FastFedConfig) -> Self {
1677 Self {
1678 config,
1679 federations: Arc::new(RwLock::new(HashMap::new())),
1680 }
1681 }
1682
1683 pub async fn handle_federation_request(&self, request: Value) -> Result<Value> {
1685 let partner_org = request["partner_organization"]
1687 .as_str()
1688 .ok_or_else(|| AuthError::auth_method("fastfed", "Missing partner_organization"))?;
1689
1690 let federation_metadata = request["federation_metadata"]
1691 .as_object()
1692 .ok_or_else(|| AuthError::auth_method("fastfed", "Missing federation_metadata"))?;
1693
1694 if !self
1696 .config
1697 .trusted_partners
1698 .contains(&partner_org.to_string())
1699 {
1700 return Err(AuthError::auth_method(
1701 "fastfed",
1702 "Untrusted federation partner",
1703 ));
1704 }
1705
1706 let required_capabilities = ["oidc", "saml2", "scim"];
1708 for capability in required_capabilities {
1709 if !federation_metadata.contains_key(capability) {
1710 return Err(AuthError::auth_method(
1711 "fastfed",
1712 format!("Missing required capability: {}", capability),
1713 ));
1714 }
1715 }
1716
1717 let federation_id = if self.config.auto_provisioning {
1719 Some(self.establish_federation(partner_org).await?)
1720 } else {
1721 None
1722 };
1723
1724 Ok(json!({
1725 "status": "federation_request_accepted",
1726 "federation_id": federation_id,
1727 "auto_provisioning": self.config.auto_provisioning,
1728 "supported_protocols": self.config.supported_protocols,
1729 "next_steps": if federation_id.is_some() {
1730 "Federation automatically established"
1731 } else {
1732 "Manual federation approval required"
1733 }
1734 }))
1735 }
1736
1737 pub async fn establish_federation(&self, partner_org: &str) -> Result<String> {
1739 let relationship_id = Uuid::new_v4().to_string();
1740
1741 let relationship = FederationRelationship {
1742 relationship_id: relationship_id.clone(),
1743 partner_org: partner_org.to_string(),
1744 status: FederationStatus::Pending,
1745 config: json!({}),
1746 created_at: Utc::now(),
1747 };
1748
1749 let mut federations = self.federations.write().await;
1750 federations.insert(relationship_id.clone(), relationship);
1751
1752 Ok(relationship_id)
1753 }
1754}
1755
1756impl Default for OidcExtensionsConfig {
1759 fn default() -> Self {
1760 Self {
1761 enable_heart: true,
1762 enable_shared_signals: true,
1763 enable_ekyc: true,
1764 enable_fastfed: true,
1765 enable_modrna: false, enable_igov: false, enable_authzen: false, }
1769 }
1770}
1771
1772impl Default for HeartConfig {
1773 fn default() -> Self {
1774 Self {
1775 organization_id: "example-healthcare-org".to_string(),
1776 fhir_endpoint: "https://example.com/fhir".to_string(),
1777 required_scopes: vec!["patient/*.read".to_string(), "user/*.read".to_string()],
1778 enhanced_consent: true,
1779 authorized_providers: Vec::new(), audit_config: HeartAuditConfig::default(),
1781 }
1782 }
1783}
1784
1785impl Default for HeartAuditConfig {
1786 fn default() -> Self {
1787 Self {
1788 enable_atna: true,
1789 syslog_endpoint: None,
1790 audit_level: HeartAuditLevel::Enhanced,
1791 }
1792 }
1793}
1794
1795impl Default for SharedSignalsConfig {
1796 fn default() -> Self {
1797 Self {
1798 endpoint_url: "https://example.com/signals".to_string(),
1799 supported_events: vec![
1800 "security_advisory".to_string(),
1801 "account_disabled".to_string(),
1802 "credential_change".to_string(),
1803 "session_revoked".to_string(),
1804 ],
1805 max_event_age: 3600, verify_events: true,
1807 }
1808 }
1809}
1810
1811#[derive(Clone)]
1813pub struct VerificationSession {
1814 pub session_id: String,
1815 pub user_id: String,
1816 pub requested_ial: IdentityAssuranceLevel,
1817 pub status: String,
1818 pub required_methods: Vec<VerificationMethod>,
1819 pub completed_verifications: Vec<VerificationMethod>,
1820 pub created_at: SystemTime,
1821}
1822
1823impl std::fmt::Debug for VerificationSession {
1824 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1825 let mut d = f.debug_struct("VerificationSession");
1826 d.field(
1827 "session_id",
1828 &crate::utils::redact::redacted(&self.session_id),
1829 );
1830 d.field("user_id", &self.user_id);
1831 d.field("requested_ial", &self.requested_ial);
1832 d.field("status", &self.status);
1833 d.field("required_methods", &self.required_methods);
1834 d.field("completed_verifications", &self.completed_verifications);
1835 d.field("created_at", &self.created_at);
1836 d.finish()
1837 }
1838}
1839
1840impl IdentityAssuranceLevel {
1841 pub fn from_u8(level: u8) -> Self {
1842 match level {
1843 1 => IdentityAssuranceLevel::IAL1,
1844 2 => IdentityAssuranceLevel::IAL2,
1845 3 => IdentityAssuranceLevel::IAL3,
1846 _ => IdentityAssuranceLevel::IAL1,
1847 }
1848 }
1849}
1850
1851pub struct EventTransmitter {
1853 pub endpoint: String,
1854 pub public_key: String,
1855}
1856
1857impl EventTransmitter {
1858 pub async fn send_event(&self, event_jwt: &str, receiver_url: &str) -> Result<()> {
1859 tracing::info!(
1860 "Sending event JWT to {}: {}",
1861 receiver_url,
1862 crate::utils::redact::fingerprint(event_jwt)
1863 );
1864 Ok(())
1866 }
1867}
1868
1869impl Default for EkycConfig {
1870 fn default() -> Self {
1871 Self {
1872 verification_provider: "example-kyc-provider".to_string(),
1873 required_ial: IdentityAssuranceLevel::IAL2,
1874 verification_methods: vec![VerificationMethod::Document, VerificationMethod::Database],
1875 document_verification: true,
1876 biometric_verification: false,
1877 }
1878 }
1879}
1880
1881impl Default for FastFedConfig {
1882 fn default() -> Self {
1883 Self {
1884 metadata_endpoint: "https://example.com/.well-known/fastfed".to_string(),
1885 supported_protocols: vec!["OIDC".to_string(), "SAML2".to_string()],
1886 auto_provisioning: false, trusted_partners: Vec::new(), trust_anchor: "example-trust-anchor".to_string(),
1889 }
1890 }
1891}
1892
1893#[cfg(test)]
1894mod tests {
1895 use super::*;
1896
1897 #[tokio::test]
1898 async fn test_oidc_extensions_creation() {
1899 let config = OidcExtensionsConfig::default();
1900
1901 assert!(config.enable_heart);
1903 assert!(config.enable_shared_signals);
1904 assert!(config.enable_ekyc);
1905 assert!(config.enable_fastfed);
1906
1907 assert!(!config.enable_modrna);
1909 assert!(!config.enable_igov);
1910 assert!(!config.enable_authzen);
1911 }
1912
1913 #[tokio::test]
1914 async fn test_heart_session_creation() {
1915 let config = HeartConfig::default();
1916 let heart_manager = HeartManager::new(config);
1917
1918 let session_id = heart_manager
1919 .create_session(
1920 "provider123",
1921 Some("patient456"),
1922 vec!["patient/*.read".to_string()],
1923 )
1924 .await
1925 .unwrap();
1926
1927 assert!(!session_id.is_empty());
1928 }
1929
1930 #[tokio::test]
1931 async fn test_ekyc_verification() {
1932 let config = EkycConfig::default();
1933 let ekyc_manager = EkycManager::new(config);
1934
1935 let session_id = ekyc_manager.start_verification("user123").await.unwrap();
1936
1937 assert!(!session_id.is_empty());
1938 }
1939
1940 #[tokio::test]
1941 async fn test_fastfed_federation() {
1942 let config = FastFedConfig::default();
1943 let fastfed_manager = FastFedManager::new(config);
1944
1945 let relationship_id = fastfed_manager
1946 .establish_federation("partner-org")
1947 .await
1948 .unwrap();
1949
1950 assert!(!relationship_id.is_empty());
1951 }
1952}