1use crate::errors::{AuthError, Result};
13use serde::{Deserialize, Serialize};
14use std::collections::HashMap;
15use std::sync::Arc;
16use std::time::{SystemTime, UNIX_EPOCH};
17use tokio::sync::RwLock;
18use uuid::Uuid;
19
20pub mod event_types {
24 pub const SESSION_REVOKED: &str =
25 "https://schemas.openid.net/secevent/caep/event-type/session-revoked";
26 pub const TOKEN_CLAIMS_CHANGE: &str =
27 "https://schemas.openid.net/secevent/caep/event-type/token-claims-change";
28 pub const CREDENTIAL_CHANGE: &str =
29 "https://schemas.openid.net/secevent/caep/event-type/credential-change";
30 pub const ASSURANCE_LEVEL_CHANGE: &str =
31 "https://schemas.openid.net/secevent/caep/event-type/assurance-level-change";
32 pub const DEVICE_COMPLIANCE_CHANGE: &str =
33 "https://schemas.openid.net/secevent/caep/event-type/device-compliance-change";
34}
35
36#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
40#[serde(tag = "format")]
41pub enum SubjectIdentifier {
42 #[serde(rename = "email")]
44 Email { email: String },
45 #[serde(rename = "iss_sub")]
47 IssSub { iss: String, sub: String },
48 #[serde(rename = "opaque")]
50 Opaque { id: String },
51 #[serde(rename = "phone_number")]
53 PhoneNumber { phone_number: String },
54 #[serde(rename = "session_id")]
56 SessionId {
57 session_id: String,
58 #[serde(default)]
59 iss: Option<String>,
60 },
61}
62
63#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
67#[serde(rename_all = "lowercase")]
68pub enum EventReasonAdmin {
69 Policy,
71 Admin,
73 User,
75}
76
77#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
79#[serde(rename_all = "snake_case")]
80pub enum ChangeType {
81 Create,
82 Revoke,
83 Update,
84 Delete,
85}
86
87#[derive(Debug, Clone, Serialize, Deserialize)]
89pub struct CaepEvent {
90 pub jti: String,
92 pub iss: String,
94 pub iat: u64,
96 pub event_type: String,
98 pub subject: SubjectIdentifier,
100 #[serde(default)]
102 pub initiating_entity: Option<EventReasonAdmin>,
103 #[serde(default)]
105 pub reason_admin: Option<String>,
106 #[serde(default)]
108 pub reason_user: Option<String>,
109 #[serde(default)]
111 pub properties: HashMap<String, serde_json::Value>,
112}
113
114impl CaepEvent {
115 pub fn new(iss: &str, event_type: &str, subject: SubjectIdentifier) -> Self {
117 let now = SystemTime::now()
118 .duration_since(UNIX_EPOCH)
119 .unwrap_or_default()
120 .as_secs();
121
122 Self {
123 jti: Uuid::new_v4().to_string(),
124 iss: iss.to_string(),
125 iat: now,
126 event_type: event_type.to_string(),
127 subject,
128 initiating_entity: None,
129 reason_admin: None,
130 reason_user: None,
131 properties: HashMap::new(),
132 }
133 }
134
135 pub fn with_initiating_entity(mut self, entity: EventReasonAdmin) -> Self {
137 self.initiating_entity = Some(entity);
138 self
139 }
140
141 pub fn with_reason_admin(mut self, reason: &str) -> Self {
143 self.reason_admin = Some(reason.to_string());
144 self
145 }
146
147 pub fn with_reason_user(mut self, reason: &str) -> Self {
149 self.reason_user = Some(reason.to_string());
150 self
151 }
152
153 pub fn with_property(mut self, key: &str, value: serde_json::Value) -> Self {
155 self.properties.insert(key.to_string(), value);
156 self
157 }
158
159 pub fn to_set_claims(&self) -> serde_json::Value {
161 let mut events: HashMap<String, serde_json::Value> = HashMap::new();
162 let mut event_body = serde_json::json!({
163 "subject": self.subject,
164 });
165 if let Some(ref entity) = self.initiating_entity {
166 event_body["initiating_entity"] = serde_json::to_value(entity)
167 .expect("serialising a serde value to JSON cannot fail");
168 }
169 if let Some(ref r) = self.reason_admin {
170 event_body["reason_admin"] = serde_json::json!({"en": r});
171 }
172 if let Some(ref r) = self.reason_user {
173 event_body["reason_user"] = serde_json::json!({"en": r});
174 }
175 for (k, v) in &self.properties {
176 event_body[k] = v.clone();
177 }
178 events.insert(self.event_type.clone(), event_body);
179
180 serde_json::json!({
181 "jti": self.jti,
182 "iss": self.iss,
183 "iat": self.iat,
184 "events": events,
185 })
186 }
187}
188
189#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
193#[serde(rename_all = "lowercase")]
194pub enum DeliveryMethod {
195 Push,
197 Poll,
199}
200
201#[derive(Debug, Clone, Serialize, Deserialize)]
203pub struct StreamConfig {
204 pub iss: String,
206 pub aud: Vec<String>,
208 pub events_supported: Vec<String>,
210 pub delivery_method: DeliveryMethod,
212 pub endpoint_url: String,
214}
215
216impl StreamConfig {
217 pub fn builder(iss: impl Into<String>, endpoint_url: impl Into<String>) -> StreamConfigBuilder {
219 StreamConfigBuilder {
220 iss: iss.into(),
221 aud: Vec::new(),
222 events_supported: Vec::new(),
223 delivery_method: DeliveryMethod::Push,
224 endpoint_url: endpoint_url.into(),
225 }
226 }
227
228 pub fn poll(iss: impl Into<String>, endpoint_url: impl Into<String>) -> StreamConfigBuilder {
230 Self::builder(iss, endpoint_url).delivery_method(DeliveryMethod::Poll)
231 }
232
233 pub fn push(iss: impl Into<String>, endpoint_url: impl Into<String>) -> StreamConfigBuilder {
235 Self::builder(iss, endpoint_url).delivery_method(DeliveryMethod::Push)
236 }
237}
238
239pub struct StreamConfigBuilder {
241 iss: String,
242 aud: Vec<String>,
243 events_supported: Vec<String>,
244 delivery_method: DeliveryMethod,
245 endpoint_url: String,
246}
247
248impl StreamConfigBuilder {
249 pub fn audience(mut self, audience: impl Into<String>) -> Self {
251 self.aud.push(audience.into());
252 self
253 }
254
255 pub fn audiences<I, S>(mut self, audiences: I) -> Self
257 where
258 I: IntoIterator<Item = S>,
259 S: Into<String>,
260 {
261 self.aud.extend(audiences.into_iter().map(Into::into));
262 self
263 }
264
265 pub fn supports_event(mut self, event_type: impl Into<String>) -> Self {
267 self.events_supported.push(event_type.into());
268 self
269 }
270
271 pub fn events_supported<I, S>(mut self, events: I) -> Self
273 where
274 I: IntoIterator<Item = S>,
275 S: Into<String>,
276 {
277 self.events_supported
278 .extend(events.into_iter().map(Into::into));
279 self
280 }
281
282 pub fn delivery_method(mut self, delivery_method: DeliveryMethod) -> Self {
284 self.delivery_method = delivery_method;
285 self
286 }
287
288 pub fn build(self) -> StreamConfig {
290 StreamConfig {
291 iss: self.iss,
292 aud: self.aud,
293 events_supported: self.events_supported,
294 delivery_method: self.delivery_method,
295 endpoint_url: self.endpoint_url,
296 }
297 }
298}
299
300#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
302#[serde(rename_all = "lowercase")]
303pub enum StreamStatus {
304 Enabled,
305 Paused,
306 Disabled,
307}
308
309struct EventStream {
313 config: StreamConfig,
314 status: StreamStatus,
315 events: Vec<CaepEvent>,
316}
317
318pub struct CaepTransmitter {
320 issuer: String,
321 streams: Arc<RwLock<HashMap<String, EventStream>>>,
322}
323
324impl CaepTransmitter {
325 pub fn new(issuer: &str) -> Self {
326 Self {
327 issuer: issuer.to_string(),
328 streams: Arc::new(RwLock::new(HashMap::new())),
329 }
330 }
331
332 pub async fn create_stream(&self, config: StreamConfig) -> String {
334 let stream_id = Uuid::new_v4().to_string();
335 self.streams.write().await.insert(
336 stream_id.clone(),
337 EventStream {
338 config,
339 status: StreamStatus::Enabled,
340 events: Vec::new(),
341 },
342 );
343 stream_id
344 }
345
346 pub async fn get_stream_config(&self, stream_id: &str) -> Option<StreamConfig> {
348 self.streams
349 .read()
350 .await
351 .get(stream_id)
352 .map(|s| s.config.clone())
353 }
354
355 pub async fn set_stream_status(&self, stream_id: &str, status: StreamStatus) -> Result<()> {
357 let mut streams = self.streams.write().await;
358 let stream = streams
359 .get_mut(stream_id)
360 .ok_or_else(|| AuthError::validation("Stream not found"))?;
361 stream.status = status;
362 Ok(())
363 }
364
365 pub async fn get_stream_status(&self, stream_id: &str) -> Option<StreamStatus> {
367 self.streams
368 .read()
369 .await
370 .get(stream_id)
371 .map(|s| s.status.clone())
372 }
373
374 pub async fn delete_stream(&self, stream_id: &str) -> bool {
376 self.streams.write().await.remove(stream_id).is_some()
377 }
378
379 pub async fn emit_session_revoked(
381 &self,
382 subject: SubjectIdentifier,
383 reason: Option<&str>,
384 ) -> Result<CaepEvent> {
385 let mut event = CaepEvent::new(&self.issuer, event_types::SESSION_REVOKED, subject);
386 if let Some(r) = reason {
387 event = event.with_reason_admin(r);
388 }
389 self.dispatch_event(&event).await;
390 Ok(event)
391 }
392
393 pub async fn emit_credential_change(
395 &self,
396 subject: SubjectIdentifier,
397 change_type: ChangeType,
398 ) -> Result<CaepEvent> {
399 let event = CaepEvent::new(&self.issuer, event_types::CREDENTIAL_CHANGE, subject)
400 .with_property(
401 "change_type",
402 serde_json::to_value(&change_type)
403 .expect("serialising a serde value to JSON cannot fail"),
404 );
405 self.dispatch_event(&event).await;
406 Ok(event)
407 }
408
409 pub async fn emit_device_compliance_change(
411 &self,
412 subject: SubjectIdentifier,
413 previous_status: &str,
414 current_status: &str,
415 ) -> Result<CaepEvent> {
416 let event = CaepEvent::new(&self.issuer, event_types::DEVICE_COMPLIANCE_CHANGE, subject)
417 .with_property("previous_status", serde_json::json!(previous_status))
418 .with_property("current_status", serde_json::json!(current_status));
419 self.dispatch_event(&event).await;
420 Ok(event)
421 }
422
423 pub async fn emit_token_claims_change(
427 &self,
428 subject: SubjectIdentifier,
429 claims: HashMap<String, serde_json::Value>,
430 ) -> Result<CaepEvent> {
431 let mut event = CaepEvent::new(&self.issuer, event_types::TOKEN_CLAIMS_CHANGE, subject);
432 event = event.with_property(
433 "claims",
434 serde_json::to_value(&claims).expect("serialising a serde value to JSON cannot fail"),
435 );
436 self.dispatch_event(&event).await;
437 Ok(event)
438 }
439
440 pub async fn emit_assurance_level_change(
444 &self,
445 subject: SubjectIdentifier,
446 current_level: &str,
447 previous_level: &str,
448 change_direction: &str,
449 ) -> Result<CaepEvent> {
450 let event = CaepEvent::new(&self.issuer, event_types::ASSURANCE_LEVEL_CHANGE, subject)
451 .with_property("current_level", serde_json::json!(current_level))
452 .with_property("previous_level", serde_json::json!(previous_level))
453 .with_property("change_direction", serde_json::json!(change_direction));
454 self.dispatch_event(&event).await;
455 Ok(event)
456 }
457
458 pub async fn poll_events(&self, stream_id: &str) -> Result<Vec<CaepEvent>> {
460 let mut streams = self.streams.write().await;
461 let stream = streams
462 .get_mut(stream_id)
463 .ok_or_else(|| AuthError::validation("Stream not found"))?;
464
465 if stream.status != StreamStatus::Enabled {
466 return Err(AuthError::validation("Stream is not enabled"));
467 }
468
469 let events = std::mem::take(&mut stream.events);
470 Ok(events)
471 }
472
473 async fn dispatch_event(&self, event: &CaepEvent) {
475 let mut streams = self.streams.write().await;
476 for stream in streams.values_mut() {
477 if stream.status != StreamStatus::Enabled {
478 continue;
479 }
480 if stream.config.events_supported.is_empty()
482 || stream
483 .config
484 .events_supported
485 .iter()
486 .any(|e| e == &event.event_type)
487 {
488 stream.events.push(event.clone());
489 }
490 }
491 }
492
493 pub async fn active_stream_count(&self) -> usize {
495 self.streams
496 .read()
497 .await
498 .values()
499 .filter(|s| s.status == StreamStatus::Enabled)
500 .count()
501 }
502}
503
504pub type EventHandler = Arc<dyn Fn(&CaepEvent) + Send + Sync>;
508
509pub struct CaepReceiver {
511 handlers: Arc<RwLock<HashMap<String, Vec<EventHandler>>>>,
512 received_jtis: Arc<RwLock<std::collections::HashSet<String>>>,
513}
514
515impl CaepReceiver {
516 pub fn new() -> Self {
517 Self {
518 handlers: Arc::new(RwLock::new(HashMap::new())),
519 received_jtis: Arc::new(RwLock::new(std::collections::HashSet::new())),
520 }
521 }
522
523 pub async fn on_event(&self, event_type: &str, handler: EventHandler) {
525 self.handlers
526 .write()
527 .await
528 .entry(event_type.to_string())
529 .or_default()
530 .push(handler);
531 }
532
533 pub async fn process_event(&self, event: &CaepEvent) -> Result<bool> {
537 {
539 let mut jtis = self.received_jtis.write().await;
540 if !jtis.insert(event.jti.clone()) {
541 return Ok(false); }
543 }
544
545 let handlers = self.handlers.read().await;
547 if let Some(handler_list) = handlers.get(&event.event_type) {
548 for handler in handler_list {
549 handler(event);
550 }
551 }
552
553 Ok(true)
554 }
555
556 pub async fn was_processed(&self, jti: &str) -> bool {
558 self.received_jtis.read().await.contains(jti)
559 }
560}
561
562impl Default for CaepReceiver {
563 fn default() -> Self {
564 Self::new()
565 }
566}
567
568#[cfg(test)]
569mod tests {
570 use super::*;
571
572 #[test]
575 fn test_subject_email_serialization() {
576 let sub = SubjectIdentifier::Email {
577 email: "user@example.com".to_string(),
578 };
579 let json = serde_json::to_value(&sub).unwrap();
580 assert_eq!(json["format"], "email");
581 assert_eq!(json["email"], "user@example.com");
582 }
583
584 #[test]
585 fn test_subject_iss_sub_serialization() {
586 let sub = SubjectIdentifier::IssSub {
587 iss: "https://issuer.example".to_string(),
588 sub: "user-123".to_string(),
589 };
590 let json = serde_json::to_value(&sub).unwrap();
591 assert_eq!(json["format"], "iss_sub");
592 }
593
594 #[test]
595 fn test_subject_session_id_serialization() {
596 let sub = SubjectIdentifier::SessionId {
597 session_id: "sess-001".to_string(),
598 iss: Some("https://issuer.example".to_string()),
599 };
600 let json = serde_json::to_value(&sub).unwrap();
601 assert_eq!(json["format"], "session_id");
602 assert_eq!(json["session_id"], "sess-001");
603 }
604
605 #[test]
606 fn test_subject_roundtrip() {
607 let sub = SubjectIdentifier::Opaque {
608 id: "opaque-id-42".to_string(),
609 };
610 let serialized = serde_json::to_string(&sub).unwrap();
611 let deserialized: SubjectIdentifier = serde_json::from_str(&serialized).unwrap();
612 assert_eq!(sub, deserialized);
613 }
614
615 #[test]
618 fn test_event_creation() {
619 let event = CaepEvent::new(
620 "https://issuer.example",
621 event_types::SESSION_REVOKED,
622 SubjectIdentifier::Email {
623 email: "user@x.com".to_string(),
624 },
625 );
626 assert!(!event.jti.is_empty());
627 assert!(event.iat > 0);
628 assert_eq!(event.event_type, event_types::SESSION_REVOKED);
629 }
630
631 #[test]
632 fn test_event_builder_chain() {
633 let event = CaepEvent::new(
634 "https://issuer.example",
635 event_types::CREDENTIAL_CHANGE,
636 SubjectIdentifier::Email {
637 email: "u@x.com".to_string(),
638 },
639 )
640 .with_initiating_entity(EventReasonAdmin::Admin)
641 .with_reason_admin("Password reset")
642 .with_reason_user("Your password was reset by admin")
643 .with_property("change_type", serde_json::json!("revoke"));
644
645 assert_eq!(event.initiating_entity, Some(EventReasonAdmin::Admin));
646 assert_eq!(event.reason_admin.as_deref(), Some("Password reset"));
647 assert!(event.properties.contains_key("change_type"));
648 }
649
650 #[test]
651 fn test_event_to_set_claims() {
652 let event = CaepEvent::new(
653 "https://iss.example",
654 event_types::SESSION_REVOKED,
655 SubjectIdentifier::Email {
656 email: "u@x.com".to_string(),
657 },
658 )
659 .with_reason_admin("Policy violation");
660
661 let claims = event.to_set_claims();
662 assert_eq!(claims["iss"], "https://iss.example");
663 assert!(claims["events"][event_types::SESSION_REVOKED].is_object());
664 let ev = &claims["events"][event_types::SESSION_REVOKED];
665 assert!(ev["subject"].is_object());
666 assert_eq!(ev["reason_admin"]["en"], "Policy violation");
667 }
668
669 #[tokio::test]
672 async fn test_transmitter_create_stream() {
673 let tx = CaepTransmitter::new("https://issuer.example");
674 let config =
675 StreamConfig::poll("https://issuer.example", "https://receiver.example/events")
676 .audience("https://receiver.example")
677 .supports_event(event_types::SESSION_REVOKED)
678 .build();
679 let stream_id = tx.create_stream(config.clone()).await;
680 assert!(!stream_id.is_empty());
681 assert_eq!(tx.active_stream_count().await, 1);
682
683 let retrieved = tx.get_stream_config(&stream_id).await.unwrap();
684 assert_eq!(retrieved.iss, config.iss);
685 }
686
687 #[tokio::test]
688 async fn test_transmitter_stream_status() {
689 let tx = CaepTransmitter::new("https://iss.example");
690 let id = tx
691 .create_stream(StreamConfig::poll("https://iss.example", "").build())
692 .await;
693
694 assert_eq!(tx.get_stream_status(&id).await, Some(StreamStatus::Enabled));
695
696 tx.set_stream_status(&id, StreamStatus::Paused)
697 .await
698 .unwrap();
699 assert_eq!(tx.get_stream_status(&id).await, Some(StreamStatus::Paused));
700 assert_eq!(tx.active_stream_count().await, 0);
701 }
702
703 #[tokio::test]
704 async fn test_transmitter_delete_stream() {
705 let tx = CaepTransmitter::new("https://iss.example");
706 let id = tx.create_stream(StreamConfig::push("", "").build()).await;
707
708 assert!(tx.delete_stream(&id).await);
709 assert!(!tx.delete_stream(&id).await); assert_eq!(tx.active_stream_count().await, 0);
711 }
712
713 #[tokio::test]
714 async fn test_transmitter_emit_session_revoked() {
715 let tx = CaepTransmitter::new("https://iss.example");
716 let id = tx
717 .create_stream(
718 StreamConfig::poll("", "")
719 .supports_event(event_types::SESSION_REVOKED)
720 .build(),
721 )
722 .await;
723
724 let event = tx
725 .emit_session_revoked(
726 SubjectIdentifier::Email {
727 email: "u@x.com".to_string(),
728 },
729 Some("Security policy"),
730 )
731 .await
732 .unwrap();
733
734 assert_eq!(event.event_type, event_types::SESSION_REVOKED);
735
736 let events = tx.poll_events(&id).await.unwrap();
737 assert_eq!(events.len(), 1);
738 assert_eq!(events[0].jti, event.jti);
739
740 let events2 = tx.poll_events(&id).await.unwrap();
742 assert!(events2.is_empty());
743 }
744
745 #[tokio::test]
746 async fn test_transmitter_event_filtering() {
747 let tx = CaepTransmitter::new("https://iss.example");
748
749 let id = tx
751 .create_stream(
752 StreamConfig::poll("", "")
753 .supports_event(event_types::SESSION_REVOKED)
754 .build(),
755 )
756 .await;
757
758 tx.emit_credential_change(
760 SubjectIdentifier::Email {
761 email: "u@x.com".to_string(),
762 },
763 ChangeType::Revoke,
764 )
765 .await
766 .unwrap();
767
768 let events = tx.poll_events(&id).await.unwrap();
769 assert!(events.is_empty());
770 }
771
772 #[tokio::test]
773 async fn test_transmitter_paused_stream_no_events() {
774 let tx = CaepTransmitter::new("https://iss.example");
775 let id = tx.create_stream(StreamConfig::poll("", "").build()).await;
776
777 tx.set_stream_status(&id, StreamStatus::Paused)
778 .await
779 .unwrap();
780
781 tx.emit_session_revoked(
782 SubjectIdentifier::Email {
783 email: "u@x.com".to_string(),
784 },
785 None,
786 )
787 .await
788 .unwrap();
789
790 assert!(tx.poll_events(&id).await.is_err());
792 }
793
794 #[tokio::test]
797 async fn test_receiver_process_event() {
798 let rx = CaepReceiver::new();
799 let called = Arc::new(std::sync::atomic::AtomicBool::new(false));
800 let called_clone = called.clone();
801
802 rx.on_event(
803 event_types::SESSION_REVOKED,
804 Arc::new(move |_event| {
805 called_clone.store(true, std::sync::atomic::Ordering::SeqCst);
806 }),
807 )
808 .await;
809
810 let event = CaepEvent::new(
811 "https://iss.example",
812 event_types::SESSION_REVOKED,
813 SubjectIdentifier::Email {
814 email: "u@x.com".to_string(),
815 },
816 );
817
818 let processed = rx.process_event(&event).await.unwrap();
819 assert!(processed);
820 assert!(called.load(std::sync::atomic::Ordering::SeqCst));
821 }
822
823 #[test]
824 fn test_stream_config_builder() {
825 let config =
826 StreamConfig::poll("https://issuer.example", "https://receiver.example/events")
827 .audience("https://receiver.example")
828 .audiences(["https://backup.example"])
829 .supports_event(event_types::SESSION_REVOKED)
830 .events_supported([event_types::CREDENTIAL_CHANGE])
831 .build();
832
833 assert_eq!(config.delivery_method, DeliveryMethod::Poll);
834 assert_eq!(config.aud.len(), 2);
835 assert_eq!(config.events_supported.len(), 2);
836 }
837
838 #[tokio::test]
839 async fn test_receiver_deduplication() {
840 let rx = CaepReceiver::new();
841 let event = CaepEvent::new(
842 "https://iss.example",
843 event_types::CREDENTIAL_CHANGE,
844 SubjectIdentifier::Opaque {
845 id: "x".to_string(),
846 },
847 );
848
849 let first = rx.process_event(&event).await.unwrap();
850 assert!(first);
851
852 let second = rx.process_event(&event).await.unwrap();
853 assert!(!second); assert!(rx.was_processed(&event.jti).await);
856 }
857
858 #[tokio::test]
859 async fn test_receiver_unhandled_event_type() {
860 let rx = CaepReceiver::new();
861 let event = CaepEvent::new(
862 "https://iss.example",
863 "custom:unknown-event",
864 SubjectIdentifier::Opaque {
865 id: "x".to_string(),
866 },
867 );
868 let processed = rx.process_event(&event).await.unwrap();
870 assert!(processed);
871 }
872
873 #[test]
876 fn test_delivery_method_serialization() {
877 assert_eq!(
878 serde_json::to_string(&DeliveryMethod::Push).unwrap(),
879 r#""push""#
880 );
881 assert_eq!(
882 serde_json::to_string(&DeliveryMethod::Poll).unwrap(),
883 r#""poll""#
884 );
885 }
886}