1use std::sync::Arc;
18
19#[cfg(not(target_arch = "wasm32"))]
20use super::dispatch_pep::{MacDecision, MacDenyReason};
21#[cfg(not(target_arch = "wasm32"))]
25use super::moq_resolve::{MoqEventLabelResolver, MoqEventObjectRef, MoqEventPlane};
26use super::{SecurityContext, SecurityLabel};
27use crate::envelope::Subject;
28
29#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
35pub enum MoqEventAction {
36 Publish,
38 Subscribe,
40 JoinDecrypt,
42}
43
44impl MoqEventAction {
45 pub const fn discriminant(self) -> u16 {
47 match self {
48 MoqEventAction::Publish => 0,
49 MoqEventAction::Subscribe => 1,
50 MoqEventAction::JoinDecrypt => 2,
51 }
52 }
53
54 pub const fn from_discriminant(value: u16) -> Option<Self> {
58 match value {
59 0 => Some(MoqEventAction::Publish),
60 1 => Some(MoqEventAction::Subscribe),
61 2 => Some(MoqEventAction::JoinDecrypt),
62 _ => None,
63 }
64 }
65}
66
67#[async_trait::async_trait]
76pub trait ClearanceSource: Send + Sync {
77 async fn clearance(&self, subject: &Subject) -> Option<SecurityContext>;
78}
79
80#[derive(Debug, Clone, Copy, PartialEq, Eq)]
82pub enum MoqMacAuditReason {
83 #[cfg(not(target_arch = "wasm32"))]
85 Mac(MacDenyReason),
86 UnknownObjectIdentity,
94 TrackAdmissionHookUnavailable,
99 SourceOwnershipDenied,
101}
102
103#[derive(Debug, Clone, PartialEq, Eq)]
111pub struct MoqMacAuditRecord {
112 pub subject: Option<String>,
114 pub object: String,
120 pub action: MoqEventAction,
122 pub subject_clearance: Option<SecurityLabel>,
124 pub object_label: Option<SecurityLabel>,
126 pub reason: MoqMacAuditReason,
128}
129
130pub trait MoqMacAuditSink: Send + Sync {
136 fn record_deny(&self, record: &MoqMacAuditRecord) -> Result<(), String>;
137}
138
139pub const MAX_AUDIT_COORDINATE_PREFIX_BYTES: usize = 64;
143
144pub const BOUNDED_AUDIT_COORDINATE_MAX_BYTES: usize =
148 MAX_AUDIT_COORDINATE_PREFIX_BYTES + "~b3:0000000000000000~len:18446744073709551615".len();
149
150#[must_use]
167pub fn bounded_audit_coordinate(raw: &str) -> String {
168 if raw.len() <= MAX_AUDIT_COORDINATE_PREFIX_BYTES {
169 return raw.to_owned();
170 }
171 let mut cut = MAX_AUDIT_COORDINATE_PREFIX_BYTES;
172 while !raw.is_char_boundary(cut) {
173 cut -= 1;
174 }
175 let digest = blake3::hash(raw.as_bytes());
176 let digest_hex: String = digest.as_bytes()[..8]
177 .iter()
178 .map(|byte| format!("{byte:02x}"))
179 .collect();
180 format!("{}~b3:{digest_hex}~len:{}", &raw[..cut], raw.len())
181}
182
183pub struct MoqEventPep {
188 #[cfg(not(target_arch = "wasm32"))]
189 resolver: Arc<dyn MoqEventLabelResolver>,
190 clearance: Arc<dyn ClearanceSource>,
191 audit: Arc<dyn MoqMacAuditSink>,
192}
193
194impl MoqEventPep {
195 pub fn deny_event_scope(&self, subject: &Subject, prefix: &str, action: MoqEventAction) {
197 self.audit_deny(
198 subject,
199 &bounded_audit_coordinate(prefix),
200 action,
201 None,
202 None,
203 MoqMacAuditReason::SourceOwnershipDenied,
204 );
205 }
206 #[cfg(not(target_arch = "wasm32"))]
210 pub fn new(
211 resolver: Arc<dyn MoqEventLabelResolver>,
212 clearance: Arc<dyn ClearanceSource>,
213 audit: Arc<dyn MoqMacAuditSink>,
214 ) -> Self {
215 Self {
216 resolver,
217 clearance,
218 audit,
219 }
220 }
221
222 fn audit_deny(
223 &self,
224 subject: &Subject,
225 track_or_prefix: &str,
226 action: MoqEventAction,
227 subject_clearance: Option<SecurityLabel>,
228 object_label: Option<SecurityLabel>,
229 reason: MoqMacAuditReason,
230 ) {
231 let record = MoqMacAuditRecord {
232 subject: subject.name().map(str::to_owned),
233 object: track_or_prefix.to_owned(),
234 action,
235 subject_clearance,
236 object_label,
237 reason,
238 };
239 if let Err(_error) = self.audit.record_deny(&record) {
240 #[cfg(not(target_arch = "wasm32"))]
241 tracing::error!(
242 target: "hyprstream.mac.audit",
243 error = %_error,
244 subject = ?record.subject,
245 object = %record.object,
246 action = ?record.action,
247 reason = ?record.reason,
248 "MoQ MAC deny could not be durably audited; enforcing deny"
249 );
250 }
251 }
252
253 #[must_use]
260 #[cfg(not(target_arch = "wasm32"))]
261 pub async fn check(
262 &self,
263 subject: &Subject,
264 object: &MoqEventObjectRef,
265 action: MoqEventAction,
266 ) -> MacDecision {
267 let Some(subject_ctx) = self.clearance.clearance(subject).await else {
268 let reason = MacDenyReason::NoClearance;
269 self.audit_deny(
270 subject,
271 &object.audit_coordinate(),
272 action,
273 None,
274 None,
275 MoqMacAuditReason::Mac(reason),
276 );
277 return MacDecision::Deny(reason);
278 };
279 let Some(object_label) = self.resolver.resolve(object) else {
280 let reason = MacDenyReason::UnlabeledObject;
281 self.audit_deny(
282 subject,
283 &object.audit_coordinate(),
284 action,
285 Some(*subject_ctx.clearance()),
286 None,
287 MoqMacAuditReason::Mac(reason),
288 );
289 return MacDecision::Deny(reason);
290 };
291 if subject_ctx.can_access(&object_label) {
292 MacDecision::Permit
293 } else {
294 let reason = MacDenyReason::FloorDeny;
295 self.audit_deny(
296 subject,
297 &object.audit_coordinate(),
298 action,
299 Some(*subject_ctx.clearance()),
300 Some(object_label),
301 MoqMacAuditReason::Mac(reason),
302 );
303 MacDecision::Deny(reason)
304 }
305 }
306
307 #[cfg(not(target_arch = "wasm32"))]
311 pub async fn event_grant_is_current(&self, subject: &Subject, prefix: &str) -> bool {
312 let Some(object) = MoqEventObjectRef::parse(MoqEventPlane::Event, prefix) else {
313 return false;
314 };
315 let Some(context) = self.clearance.clearance(subject).await else {
316 return false;
317 };
318 self.resolver
319 .resolve(&object)
320 .is_some_and(|label| context.can_access(&label))
321 }
322
323 #[must_use]
332 #[cfg(not(target_arch = "wasm32"))]
333 pub async fn check_event_prefix(
334 &self,
335 subject: &Subject,
336 prefix: &str,
337 action: MoqEventAction,
338 ) -> MacDecision {
339 match MoqEventObjectRef::parse(MoqEventPlane::Event, prefix) {
340 Some(object) => self.check(subject, &object, action).await,
341 None => {
342 self.audit_deny(
343 subject,
344 &bounded_audit_coordinate(prefix),
345 action,
346 None,
347 None,
348 MoqMacAuditReason::UnknownObjectIdentity,
349 );
350 MacDecision::Deny(MacDenyReason::UnlabeledObject)
351 }
352 }
353 }
354
355 #[must_use]
362 #[cfg(not(target_arch = "wasm32"))]
363 pub async fn check_stream_track(
364 &self,
365 subject: &Subject,
366 track: &str,
367 action: MoqEventAction,
368 ) -> MacDecision {
369 match MoqEventObjectRef::parse(MoqEventPlane::Stream, track) {
370 Some(object) => self.check(subject, &object, action).await,
371 None => {
372 self.audit_deny(
373 subject,
374 &bounded_audit_coordinate(track),
375 action,
376 None,
377 None,
378 MoqMacAuditReason::UnknownObjectIdentity,
379 );
380 MacDecision::Deny(MacDenyReason::UnlabeledObject)
381 }
382 }
383 }
384
385 pub async fn deny_track_admission_without_hook(&self, subject: &Subject) {
390 self.audit_deny(
391 subject,
392 "<moq-session:track-hook-unavailable>",
393 MoqEventAction::Subscribe,
394 self.clearance
395 .clearance(subject)
396 .await
397 .map(|ctx| *ctx.clearance()),
398 None,
399 MoqMacAuditReason::TrackAdmissionHookUnavailable,
400 );
401 }
402
403 #[cfg(not(target_arch = "wasm32"))]
404 pub fn resolver(&self) -> &Arc<dyn MoqEventLabelResolver> {
405 &self.resolver
406 }
407
408 pub fn clearance(&self) -> &Arc<dyn ClearanceSource> {
409 &self.clearance
410 }
411}
412
413#[derive(Debug, Clone, Default)]
415pub struct DenyAllClearanceSource;
416
417#[async_trait::async_trait]
418impl ClearanceSource for DenyAllClearanceSource {
419 async fn clearance(&self, _subject: &Subject) -> Option<SecurityContext> {
420 None
421 }
422}
423
424#[cfg(all(test, not(target_arch = "wasm32")))]
425#[allow(clippy::unwrap_used)]
426mod tests {
427 use super::*;
428 use crate::auth::mac::{
429 Assurance, CompartmentSet, DenyAllMoqEventResolver, Level, MoqEventPolicyRow,
430 MoqEventPolicyTable, VerifiedKeyMaterial,
431 };
432 use parking_lot::Mutex;
433
434 fn public_label() -> SecurityLabel {
435 SecurityLabel::new(Level::Public, Assurance::Classical, CompartmentSet::EMPTY)
436 }
437
438 fn secret_label() -> SecurityLabel {
439 SecurityLabel::new(Level::Secret, Assurance::PqHybrid, CompartmentSet::EMPTY)
440 }
441
442 fn declared_resolver() -> crate::auth::mac::DeclaredTrackPolicyResolver {
445 crate::auth::mac::DeclaredTrackPolicyResolver::new(
446 MoqEventPolicyTable::build(
447 1,
448 [
449 MoqEventPolicyRow::new(MoqEventPlane::Event, "worker", secret_label()).unwrap(),
450 MoqEventPolicyRow::new(MoqEventPlane::Event, "registry", public_label())
451 .unwrap(),
452 MoqEventPolicyRow::new(MoqEventPlane::Stream, "streams", public_label())
453 .unwrap(),
454 ],
455 )
456 .unwrap(),
457 )
458 }
459
460 struct TieredClearance {
461 cleared_did: String,
462 }
463
464 #[async_trait::async_trait]
465 impl ClearanceSource for TieredClearance {
466 async fn clearance(&self, subject: &Subject) -> Option<SecurityContext> {
467 if subject.name() == Some(self.cleared_did.as_str()) {
468 Some(SecurityContext::from_clearance(
469 secret_label(),
470 VerifiedKeyMaterial::PqHybrid,
471 ))
472 } else {
473 Some(SecurityContext::from_clearance(
474 public_label(),
475 VerifiedKeyMaterial::Classical,
476 ))
477 }
478 }
479 }
480
481 #[derive(Default)]
482 struct RecordingAudit {
483 records: Mutex<Vec<MoqMacAuditRecord>>,
484 }
485
486 impl MoqMacAuditSink for RecordingAudit {
487 fn record_deny(&self, record: &MoqMacAuditRecord) -> Result<(), String> {
488 self.records.lock().push(record.clone());
489 Ok(())
490 }
491 }
492
493 fn pep(resolver: Arc<dyn MoqEventLabelResolver>, audit: &Arc<RecordingAudit>) -> MoqEventPep {
494 MoqEventPep::new(
495 resolver,
496 Arc::new(TieredClearance {
497 cleared_did: "did:web:cleared".to_owned(),
498 }),
499 audit.clone(),
500 )
501 }
502
503 #[tokio::test]
504 async fn installed_pep_audits_every_missing_clearance_deny() {
505 let audit = Arc::new(RecordingAudit::default());
506 let pep = MoqEventPep::new(
507 Arc::new(DenyAllMoqEventResolver),
508 Arc::new(DenyAllClearanceSource),
509 audit.clone(),
510 );
511 for action in [
512 MoqEventAction::Publish,
513 MoqEventAction::Subscribe,
514 MoqEventAction::JoinDecrypt,
515 ] {
516 assert_eq!(
517 pep.check_event_prefix(&Subject::anonymous(), "registry", action)
518 .await,
519 MacDecision::Deny(MacDenyReason::NoClearance)
520 );
521 }
522 let records = audit.records.lock();
523 assert_eq!(records.len(), 3);
524 assert!(records
525 .iter()
526 .all(|record| { record.reason == MoqMacAuditReason::Mac(MacDenyReason::NoClearance) }));
527 }
528
529 #[tokio::test]
530 async fn installed_pep_denies_unlabeled_object() {
531 let audit = Arc::new(RecordingAudit::default());
532 let pep = pep(Arc::new(DenyAllMoqEventResolver), &audit);
533 assert_eq!(
534 pep.check_event_prefix(
535 &Subject::new("did:web:cleared"),
536 "inference",
537 MoqEventAction::Subscribe,
538 )
539 .await,
540 MacDecision::Deny(MacDenyReason::UnlabeledObject)
541 );
542 let records = audit.records.lock();
543 assert_eq!(records.len(), 1);
544 assert_eq!(
545 records[0].reason,
546 MoqMacAuditReason::Mac(MacDenyReason::UnlabeledObject)
547 );
548 }
549
550 #[tokio::test]
551 async fn installed_pep_enforces_label_ceiling_for_every_action() {
552 let audit = Arc::new(RecordingAudit::default());
553 let pep = pep(Arc::new(declared_resolver()), &audit);
554 for action in [
555 MoqEventAction::Publish,
556 MoqEventAction::Subscribe,
557 MoqEventAction::JoinDecrypt,
558 ] {
559 assert_eq!(
560 pep.check_event_prefix(
561 &Subject::new("did:web:public"),
562 "worker.sandbox1.started",
563 action,
564 )
565 .await,
566 MacDecision::Deny(MacDenyReason::FloorDeny)
567 );
568 assert_eq!(
569 pep.check_event_prefix(
570 &Subject::new("did:web:cleared"),
571 "worker.sandbox1.started",
572 action,
573 )
574 .await,
575 MacDecision::Permit
576 );
577 }
578 let records = audit.records.lock();
579 assert_eq!(records.len(), 3);
580 assert!(records
581 .iter()
582 .all(|record| record.reason == MoqMacAuditReason::Mac(MacDenyReason::FloorDeny)));
583 }
584
585 #[tokio::test]
586 async fn known_stream_tracks_resolve_and_permit_through_the_typed_boundary() {
587 let audit = Arc::new(RecordingAudit::default());
588 let pep = pep(Arc::new(declared_resolver()), &audit);
589 assert_eq!(
591 pep.check_stream_track(
592 &Subject::new("did:web:public"),
593 "alice/streams/run-1/i0",
594 MoqEventAction::Subscribe,
595 )
596 .await,
597 MacDecision::Permit
598 );
599 assert_eq!(
601 pep.check_event_prefix(
602 &Subject::new("did:web:public"),
603 "streams.session.x",
604 MoqEventAction::Subscribe,
605 )
606 .await,
607 MacDecision::Deny(MacDenyReason::UnlabeledObject)
608 );
609 }
610
611 #[tokio::test]
612 async fn unknown_or_noncanonical_coordinates_deny_as_unknown_identities() {
613 let audit = Arc::new(RecordingAudit::default());
614 let pep = pep(Arc::new(declared_resolver()), &audit);
615 let subject = Subject::new("did:web:cleared");
616
617 for bad in ["Worker", "5:acmeworker", "wor/ker"] {
619 assert_eq!(
620 pep.check_event_prefix(&subject, bad, MoqEventAction::Publish)
621 .await,
622 MacDecision::Deny(MacDenyReason::UnlabeledObject),
623 "{bad:?} must not decode"
624 );
625 }
626 for bad in ["alice", "alice/../streams/run"] {
628 assert_eq!(
629 pep.check_stream_track(&subject, bad, MoqEventAction::Subscribe)
630 .await,
631 MacDecision::Deny(MacDenyReason::UnlabeledObject),
632 "{bad:?} must not decode"
633 );
634 }
635
636 let records = audit.records.lock();
637 assert_eq!(records.len(), 5);
638 assert!(records
639 .iter()
640 .all(|record| record.reason == MoqMacAuditReason::UnknownObjectIdentity));
641 }
642
643 #[test]
644 fn unknown_plane_and_action_discriminants_have_no_typed_value_to_check() {
645 for unknown in [2u16, 3, u16::MAX] {
648 assert_eq!(MoqEventPlane::from_discriminant(unknown), None);
649 }
650 for unknown in [3u16, 4, u16::MAX] {
651 assert_eq!(MoqEventAction::from_discriminant(unknown), None);
652 }
653 for action in [
655 MoqEventAction::Publish,
656 MoqEventAction::Subscribe,
657 MoqEventAction::JoinDecrypt,
658 ] {
659 assert_eq!(
660 MoqEventAction::from_discriminant(action.discriminant()),
661 Some(action)
662 );
663 }
664 for plane in [MoqEventPlane::Event, MoqEventPlane::Stream] {
665 assert_eq!(
666 MoqEventPlane::from_discriminant(plane.discriminant()),
667 Some(plane)
668 );
669 }
670 }
671
672 #[tokio::test]
673 async fn empty_declared_table_denies_every_parseable_identity() {
674 let audit = Arc::new(RecordingAudit::default());
675 let pep = pep(
676 Arc::new(crate::auth::mac::DeclaredTrackPolicyResolver::new(
677 MoqEventPolicyTable::empty(),
678 )),
679 &audit,
680 );
681 let subject = Subject::new("did:web:cleared");
682 assert_eq!(
683 pep.check_event_prefix(&subject, "worker", MoqEventAction::Publish)
684 .await,
685 MacDecision::Deny(MacDenyReason::UnlabeledObject)
686 );
687 assert_eq!(
688 pep.check_stream_track(
689 &subject,
690 "alice/streams/run-1/i0",
691 MoqEventAction::Subscribe
692 )
693 .await,
694 MacDecision::Deny(MacDenyReason::UnlabeledObject)
695 );
696 }
697
698 fn oversized_event_coordinate() -> String {
701 format!("worker.{}", "x".repeat(4 * 1024 * 1024))
704 }
705
706 fn oversized_stream_coordinate() -> String {
707 format!("{}/{}", ["a"; 8].join("/"), "y".repeat(4 * 1024 * 1024))
710 }
711
712 #[tokio::test]
713 async fn malformed_event_coordinate_denies_with_bounded_audited_object() {
714 let audit = Arc::new(RecordingAudit::default());
715 let pep = pep(Arc::new(declared_resolver()), &audit);
716 let subject = Subject::new("did:web:cleared");
717
718 assert_eq!(
720 pep.check_event_prefix(
721 &subject,
722 &oversized_event_coordinate(),
723 MoqEventAction::Publish,
724 )
725 .await,
726 MacDecision::Deny(MacDenyReason::UnlabeledObject)
727 );
728
729 let records = audit.records.lock();
730 assert_eq!(records.len(), 1);
731 let object = &records[0].object;
732 assert!(
734 object.len() <= BOUNDED_AUDIT_COORDINATE_MAX_BYTES,
735 "audited object {object:?} exceeds the explicit cap"
736 );
737 let marker_start = object.rfind("~b3:").unwrap();
739 let (prefix, marker) = object.split_at(marker_start);
740 assert!(prefix.len() <= MAX_AUDIT_COORDINATE_PREFIX_BYTES);
741 let raw_len = oversized_event_coordinate().len();
742 assert_eq!(
743 marker.len(),
744 "~b3:".len() + 16 + "~len:".len() + raw_len.to_string().len(),
745 "marker is the fixed-shape 16-hex digest plus the exact raw length"
746 );
747 assert!(marker.ends_with(&format!("~len:{raw_len}")));
748 }
749
750 #[tokio::test]
751 async fn malformed_stream_coordinate_denies_with_bounded_audited_object() {
752 let audit = Arc::new(RecordingAudit::default());
753 let pep = pep(Arc::new(declared_resolver()), &audit);
754 let subject = Subject::new("did:web:cleared");
755
756 assert_eq!(
757 pep.check_stream_track(
758 &subject,
759 &oversized_stream_coordinate(),
760 MoqEventAction::Subscribe,
761 )
762 .await,
763 MacDecision::Deny(MacDenyReason::UnlabeledObject)
764 );
765
766 let records = audit.records.lock();
767 assert_eq!(records.len(), 1);
768 let object = &records[0].object;
769 assert!(object.len() <= BOUNDED_AUDIT_COORDINATE_MAX_BYTES);
770 let raw_len = oversized_stream_coordinate().len();
771 assert!(object.ends_with(&format!("~len:{raw_len}")));
772 assert!(object.contains("~b3:"));
773 }
774
775 #[tokio::test]
776 async fn differing_oversized_malformed_tails_do_not_collide_in_audit() {
777 let a = format!("worker.{}", "x".repeat(4 * 1024 * 1024));
778 let b = format!("worker.{}", "z".repeat(4 * 1024 * 1024));
779 let bounded_a = bounded_audit_coordinate(&a);
781 let bounded_b = bounded_audit_coordinate(&b);
782 assert_ne!(bounded_a, bounded_b, "digest must distinguish the tails");
783
784 let audit = Arc::new(RecordingAudit::default());
787 let pep = pep(Arc::new(declared_resolver()), &audit);
788 let subject = Subject::new("did:web:cleared");
789 for input in [&a, &b] {
790 assert_eq!(
791 pep.check_event_prefix(&subject, input, MoqEventAction::Publish)
792 .await,
793 MacDecision::Deny(MacDenyReason::UnlabeledObject)
794 );
795 }
796 let records = audit.records.lock();
797 assert_eq!(records.len(), 2);
798 assert_ne!(records[0].object, records[1].object);
799 assert!(records[0].object.len() <= BOUNDED_AUDIT_COORDINATE_MAX_BYTES);
800 assert!(records[1].object.len() <= BOUNDED_AUDIT_COORDINATE_MAX_BYTES);
801 assert_eq!(records[0].object, bounded_a);
803 assert_eq!(records[1].object, bounded_b);
804 }
805
806 #[test]
807 fn bounded_audit_coordinate_is_small_input_verbatim_and_utf8_safe() {
808 assert_eq!(bounded_audit_coordinate("5:tenantworker"), "5:tenantworker");
810
811 let straddling = format!("{}é{}", "a".repeat(63), "z".repeat(256));
815 let bounded = bounded_audit_coordinate(&straddling);
816 assert!(bounded.len() <= BOUNDED_AUDIT_COORDINATE_MAX_BYTES);
817 let prefix_end = bounded.find("~b3:").unwrap();
818 assert!(prefix_end <= MAX_AUDIT_COORDINATE_PREFIX_BYTES);
819 assert_eq!(bounded, bounded_audit_coordinate(&straddling));
820 }
821}