1use std::sync::Arc;
33
34use iroh::endpoint::Connection;
35use iroh::protocol::{AcceptError, ProtocolHandler};
36use moq_net::{Origin, OriginConsumer, OriginProducer, Server, StatsHandle};
37use tokio::sync::Semaphore;
38use tokio_util::sync::CancellationToken;
39use web_transport_iroh::Session;
40
41use crate::moq_authz::{
42 is_valid_tenant_segment, tenant_prefix, PeerIdentity, SharedSubscribeAuthorizer,
43 SubscribeDecision,
44};
45use crate::transport::moql_admission::MoqlAdmissionAuthenticator;
46
47pub type PeerTenantResolver = Arc<dyn Fn(&PeerIdentity) -> Option<String> + Send + Sync>;
53
54pub trait IngressAuthorizer: Send + Sync {
58 fn authorize_ingress(&self, peer: &PeerIdentity, tenant: &str) -> bool;
60}
61
62impl<F> IngressAuthorizer for F
63where
64 F: Fn(&PeerIdentity, &str) -> bool + Send + Sync,
65{
66 fn authorize_ingress(&self, peer: &PeerIdentity, tenant: &str) -> bool {
67 self(peer, tenant)
68 }
69}
70
71pub type SharedIngressAuthorizer = Arc<dyn IngressAuthorizer>;
73
74#[derive(Clone, Default)]
85pub struct MoqAuthzConfig {
86 pub authorizer: Option<SharedSubscribeAuthorizer>,
88 pub tenant_resolver: Option<PeerTenantResolver>,
90 pub ingress_authorizer: Option<SharedIngressAuthorizer>,
93 pub admission: Option<Arc<MoqlAdmissionAuthenticator>>,
97}
98
99impl MoqAuthzConfig {
100 pub fn tenant_for(&self, peer: &PeerIdentity) -> Option<String> {
102 self.tenant_resolver.as_ref().and_then(|r| r(peer))
103 }
104
105 pub fn with_authorizer(mut self, authorizer: SharedSubscribeAuthorizer) -> Self {
107 self.authorizer = Some(authorizer);
108 self
109 }
110
111 pub fn with_ingress_authorizer(mut self, authorizer: SharedIngressAuthorizer) -> Self {
115 self.ingress_authorizer = Some(authorizer);
116 self
117 }
118
119 pub fn with_ingress_authorizer_option(
122 mut self,
123 authorizer: Option<SharedIngressAuthorizer>,
124 ) -> Self {
125 self.ingress_authorizer = authorizer;
126 self
127 }
128
129 pub fn authorizes_ingress(&self, peer: &PeerIdentity, tenant: &str) -> bool {
132 self.ingress_authorizer
133 .as_ref()
134 .is_some_and(|authorizer| authorizer.authorize_ingress(peer, tenant))
135 }
136
137 pub fn with_admission(mut self, admission: Arc<MoqlAdmissionAuthenticator>) -> Self {
142 self.admission = Some(admission);
143 self
144 }
145
146 pub async fn authorize_without_track_hook(&self, peer: &PeerIdentity) -> SubscribeDecision {
152 if let Some(authorizer) = self.authorizer.as_ref() {
153 authorizer.authorize_without_track_hook(peer).await
154 } else {
155 SubscribeDecision::Allow
156 }
157 }
158}
159
160#[derive(Clone)]
168pub struct OriginShared {
169 producer: OriginProducer,
170 consumer: OriginConsumer,
171}
172
173impl OriginShared {
174 pub fn new() -> Self {
176 let producer = Origin::random().produce();
177 let consumer = producer.consume();
178 Self { producer, consumer }
179 }
180
181 pub fn from_pair(producer: OriginProducer, consumer: OriginConsumer) -> Self {
185 Self { producer, consumer }
186 }
187
188 pub fn producer(&self) -> &OriginProducer {
189 &self.producer
190 }
191
192 pub fn consumer(&self) -> &OriginConsumer {
193 &self.consumer
194 }
195}
196
197impl Default for OriginShared {
198 fn default() -> Self {
199 Self::new()
200 }
201}
202
203#[derive(Clone)]
208pub struct IrohMoqProtocolHandler {
209 inner: Arc<HandlerInner>,
210}
211
212struct HandlerInner {
213 origin: OriginShared,
214 stats: StatsHandle,
215 authz: MoqAuthzConfig,
218 connection_limit: Arc<Semaphore>,
221 shutdown: CancellationToken,
224 event_authz: Option<Arc<dyn crate::events::EventAuthz>>,
225}
226
227impl std::fmt::Debug for IrohMoqProtocolHandler {
228 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
229 f.debug_struct("IrohMoqProtocolHandler")
230 .finish_non_exhaustive()
231 }
232}
233
234impl IrohMoqProtocolHandler {
235 pub fn new() -> Self {
238 Self::with_origin(OriginShared::new())
239 }
240
241 pub fn with_origin(origin: OriginShared) -> Self {
244 Self {
245 inner: Arc::new(HandlerInner {
246 origin,
247 stats: StatsHandle::default(),
248 authz: MoqAuthzConfig::default(),
249 connection_limit: Arc::new(Semaphore::new(
250 super::rpc_session::DEFAULT_CONNECTION_LIMIT,
251 )),
252 shutdown: CancellationToken::new(),
253 event_authz: None,
254 }),
255 }
256 }
257
258 pub fn with_authz(mut self, authz: MoqAuthzConfig) -> Self {
266 self.rebuild_inner(|i| i.authz = authz);
267 self
268 }
269
270 pub fn authorizes_ingress(&self, peer: &PeerIdentity, tenant: &str) -> bool {
274 self.inner.authz.authorizes_ingress(peer, tenant)
275 }
276
277 pub fn with_connection_limit(mut self, connection_limit: usize) -> Self {
280 self.rebuild_inner(|i| i.connection_limit = Arc::new(Semaphore::new(connection_limit)));
281 self
282 }
283
284 pub fn with_event_authz(mut self, authz: Arc<dyn crate::events::EventAuthz>) -> Self {
288 self.rebuild_inner(|i| i.event_authz = Some(authz));
289 self
290 }
291
292 async fn event_scopes(
293 &self,
294 peer: &PeerIdentity,
295 tenant: &str,
296 ingress: bool,
297 ) -> (Vec<String>, Vec<String>) {
298 let mut subscribe = Vec::new();
299 let mut publish = Vec::new();
300 if let (Some(authz), Some(subject)) = (&self.inner.event_authz, &peer.subject) {
301 if tenant != "local" {
304 return (subscribe, publish);
305 }
306 let subject = crate::envelope::Subject::new(subject.clone());
307 for source in authz.sources() {
309 let path = format!("local/events/{source}");
310 if authz.can_subscribe(&subject, source).await {
311 subscribe.push(path.clone());
312 }
313 if ingress && authz.can_publish(&subject, source).await {
314 publish.push(path);
315 }
316 }
317 }
318 (subscribe, publish)
319 }
320
321 async fn event_grants_current(
325 &self,
326 peer: &PeerIdentity,
327 scopes: &(Vec<String>, Vec<String>),
328 ) -> bool {
329 let Some(authz) = &self.inner.event_authz else {
330 return true;
331 };
332 let Some(subject) = &peer.subject else {
333 return false;
334 };
335 let subject = crate::envelope::Subject::new(subject.clone());
336 for path in &scopes.0 {
337 let Some(source) = path.strip_prefix("local/events/") else {
338 return false;
339 };
340 if !authz.revalidate_subscribe(&subject, source).await {
341 return false;
342 }
343 }
344 for path in &scopes.1 {
345 let Some(source) = path.strip_prefix("local/events/") else {
346 return false;
347 };
348 if !authz.revalidate_publish(&subject, source).await {
349 return false;
350 }
351 }
352 true
353 }
354
355 fn rebuild_inner(&mut self, f: impl FnOnce(&mut HandlerInner)) {
359 if let Some(inner) = Arc::get_mut(&mut self.inner) {
360 f(inner);
361 } else {
362 let old = &*self.inner;
363 let mut cloned = HandlerInner {
364 origin: old.origin.clone(),
365 stats: old.stats.clone(),
366 authz: old.authz.clone(),
367 connection_limit: Arc::clone(&old.connection_limit),
368 shutdown: old.shutdown.clone(),
369 event_authz: old.event_authz.clone(),
370 };
371 f(&mut cloned);
372 self.inner = Arc::new(cloned);
373 }
374 }
375
376 pub fn origin(&self) -> &OriginShared {
378 &self.inner.origin
379 }
380
381 pub fn origin_producer(&self) -> &OriginProducer {
383 self.inner.origin.producer()
384 }
385
386 pub fn origin_consumer(&self) -> &OriginConsumer {
389 self.inner.origin.consumer()
390 }
391}
392
393impl Default for IrohMoqProtocolHandler {
394 fn default() -> Self {
395 Self::new()
396 }
397}
398
399impl ProtocolHandler for IrohMoqProtocolHandler {
400 async fn accept(&self, conn: Connection) -> Result<(), AcceptError> {
401 let _connection_permit = match Arc::clone(&self.inner.connection_limit).try_acquire_owned()
406 {
407 Ok(permit) => permit,
408 Err(_) => {
409 tracing::warn!("iroh-moq: connection cap reached, rejecting connection");
410 conn.close(0u32.into(), b"moql connection cap reached");
411 return Ok(());
412 }
413 };
414 let admitted = match &self.inner.authz.admission {
421 Some(admission) => match admission.accept(&conn).await {
422 Ok(admitted) => {
423 tracing::debug!(
424 subject = %admitted.peer.subject.as_deref().unwrap_or("?"),
425 tenant = %admitted.tenant,
426 epoch = admitted.epoch,
427 carrier = %hex::encode(&admitted.carrier_node_id[..4]),
428 "iroh-moq: inside-carrier admission succeeded"
429 );
430 Some(admitted)
431 }
432 Err(e) => {
433 tracing::warn!(error = %e, "iroh-moq: admission rejected; closing carrier");
434 conn.close(0u32.into(), b"moql admission rejected");
435 return Ok(());
436 }
437 },
438 None => None,
439 };
440 let peer = admitted
443 .as_ref()
444 .map(|a| a.peer.clone())
445 .unwrap_or_else(PeerIdentity::anonymous);
446 if !self
447 .inner
448 .authz
449 .authorize_without_track_hook(&peer)
450 .await
451 .is_allowed()
452 {
453 tracing::warn!(
454 "iroh-moq: installed track authorizer denied session because #276 callback is unavailable"
455 );
456 conn.close(0u32.into(), b"per-track authorization unavailable");
457 return Ok(());
458 }
459 if !peer.is_authenticated() {
460 tracing::warn!(
461 "iroh-moq: refusing anonymous carrier pending verified session proof (#726)"
462 );
463 conn.close(0u32.into(), b"verified MoQ session proof required");
464 return Ok(());
465 }
466
467 let resolved_tenant = match &admitted {
474 Some(a) => Some(a.tenant.clone()),
475 None => self.inner.authz.tenant_for(&peer),
476 };
477 let tenant = match resolved_tenant {
478 Some(tenant) => tenant,
479 None => {
480 tracing::warn!("iroh-moq: authenticated peer has no tenant scope; refusing");
481 conn.close(0u32.into(), b"tenant scope required");
482 return Ok(());
483 }
484 };
485 if !is_valid_tenant_segment(&tenant) {
486 tracing::warn!(%tenant, "iroh-moq: invalid tenant scope; refusing");
487 conn.close(0u32.into(), b"valid tenant scope required");
488 return Ok(());
489 }
490
491 let ingress_granted = self.inner.authz.authorizes_ingress(&peer, &tenant);
497 if let Some(authz) = &self.inner.event_authz {
498 if !admitted
499 .as_ref()
500 .is_some_and(|peer| authz.admission_is_current(peer))
501 {
502 conn.close(
503 0u32.into(),
504 b"Event enrollment does not bind admitted key/head",
505 );
506 return Ok(());
507 }
508 }
509 let event_scopes = self.event_scopes(&peer, &tenant, ingress_granted).await;
510 let server = if self.inner.event_authz.is_some() {
511 if event_scopes.0.is_empty() && event_scopes.1.is_empty() {
512 conn.close(0u32.into(), b"no authorized event sources");
513 return Ok(());
514 }
515 let read: Vec<_> = event_scopes
516 .0
517 .iter()
518 .map(|s| moq_net::Path::new(s))
519 .collect();
520 let write: Vec<_> = event_scopes
521 .1
522 .iter()
523 .map(|s| moq_net::Path::new(s))
524 .collect();
525 let consume = if write.is_empty() {
528 None
529 } else {
530 self.inner.origin.producer.scope(&write)
531 };
532 let publish = if read.is_empty() {
533 None
534 } else {
535 self.inner.origin.consumer.scope(&read)
536 };
537 Server::new().with_publish(publish).with_consume(consume)
538 } else if ingress_granted {
539 let prefix = tenant_prefix(&tenant);
540 let path = moq_net::Path::new(&prefix);
541 let Some(scoped_origin) = self.inner.origin.producer.scope(&[path]) else {
542 return Ok(());
543 };
544 Server::new().with_origin(scoped_origin)
545 } else {
546 let Some(scoped_consumer) =
547 crate::moq_authz::tenant_scoped_consumer(self.inner.origin.consumer(), &tenant)
548 else {
549 return Ok(());
550 };
551 Server::new().with_publish(scoped_consumer)
552 }
553 .with_stats(self.inner.stats.clone());
554 let session_conn = conn.clone();
555 let session = Session::raw(conn);
556 let moq_session = server
557 .accept(session)
558 .await
559 .map_err(AcceptError::from_err)?;
560
561 let admission = self.inner.authz.admission.clone();
566 let admitted_for_session = admitted.clone();
567 let mut currentness = tokio::time::interval(std::time::Duration::from_millis(100));
568
569 loop {
573 tokio::select! {
574 biased;
575 _ = self.inner.shutdown.cancelled() => {
576 tracing::debug!("iroh-moq: shutdown signalled, dropping session");
577 break;
578 }
579 _ = currentness.tick() => {
580 if let (Some(admission), Some(admitted)) =
581 (admission.as_ref(), admitted_for_session.as_ref())
582 {
583 if !admission.is_still_current(admitted) {
584 tracing::warn!(
585 subject = %admitted.peer.subject.as_deref().unwrap_or("?"),
586 "iroh-moq: accepted state changed or expired; closing session"
587 );
588 session_conn.close(0u32.into(), b"moql accepted state no longer current");
589 break;
590 }
591 }
592 if !self.inner.event_authz.as_ref().is_none_or(|authz|
593 admitted_for_session.as_ref().is_some_and(|peer| authz.admission_is_current(peer)))
594 || !self.event_grants_current(&peer, &event_scopes).await {
595 session_conn.close(0u32.into(), b"event policy changed");
596 break;
597 }
598 if ingress_granted && !self.inner.authz.authorizes_ingress(&peer, &tenant) {
602 tracing::warn!(
603 subject = %peer.subject.as_deref().unwrap_or("?"),
604 %tenant,
605 "iroh-moq: ingress grant revoked; closing session"
606 );
607 session_conn.close(0u32.into(), b"moql ingress grant revoked");
608 break;
609 }
610 }
611 res = moq_session.closed() => {
612 tracing::debug!(result = ?res, "iroh-moq: session closed");
613 break;
614 }
615 }
616 }
617 Ok(())
618 }
619
620 async fn shutdown(&self) {
621 self.inner.shutdown.cancel();
622 }
623}
624
625#[cfg(test)]
626mod tests {
627 use super::*;
628 use crate::transport::iroh_substrate::{IrohSubstrate, NoopHandler, ALPN_MOQ_LITE};
629 use bytes::Bytes;
630 use ed25519_dalek::SigningKey;
631 use iroh::{EndpointAddr, TransportAddr};
632 use moq_net::{Client, Group, Track};
633 use rand::RngCore;
634
635 fn fresh_key() -> [u8; 32] {
636 let mut k = [0u8; 32];
637 rand::thread_rng().fill_bytes(&mut k);
638 k
639 }
640
641 fn direct_addr(substrate: &IrohSubstrate) -> EndpointAddr {
642 EndpointAddr::from_parts(
643 substrate.endpoint_id(),
644 substrate
645 .endpoint()
646 .bound_sockets()
647 .into_iter()
648 .map(TransportAddr::Ip),
649 )
650 }
651
652 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
656 async fn anonymous_carrier_cannot_publish_subscribe_or_obtain_tenant_scope(
657 ) -> anyhow::Result<()> {
658 use std::sync::atomic::{AtomicUsize, Ordering};
659
660 let resolver_calls = Arc::new(AtomicUsize::new(0));
661 let calls = Arc::clone(&resolver_calls);
662 let authz = MoqAuthzConfig {
663 authorizer: None,
664 tenant_resolver: Some(Arc::new(move |_peer| {
665 calls.fetch_add(1, Ordering::SeqCst);
666 Some("alice".to_owned())
667 })),
668 ingress_authorizer: None,
669 admission: None,
670 };
671 let handler = IrohMoqProtocolHandler::new().with_authz(authz);
672 let producer = handler.origin_producer().clone();
673 let server_consumer = handler.origin_consumer().clone();
674 let server =
675 IrohSubstrate::new_test(fresh_key(), handler, NoopHandler::new("rpc-not-wired"))
676 .await?;
677 let server_addr = direct_addr(&server);
678
679 let mut broadcast = producer
682 .create_broadcast("alice/run-1")
683 .ok_or_else(|| anyhow::anyhow!("create_broadcast denied"))?;
684 let mut track = broadcast.create_track(Track::new("tokens"))?;
685 let mut group = track.create_group(Group::from(0u64))?;
686 group.write_frame(Bytes::from_static(b"hello-moq"))?;
687 drop(group);
688
689 let client = IrohSubstrate::new_test(
691 fresh_key(),
692 NoopHandler::new("c-moq"),
693 NoopHandler::new("c-rpc"),
694 )
695 .await?;
696 let conn = client.connect(server_addr, ALPN_MOQ_LITE).await?;
697 let session = Session::raw(conn);
698 let client_origin: OriginProducer = Origin::random().produce();
699 let client_consumer: OriginConsumer = client_origin.consume();
700 let mut attacker_broadcast = client_origin
701 .create_broadcast("mallory/injected")
702 .ok_or_else(|| anyhow::anyhow!("create attacker broadcast"))?;
703 let mut attacker_track = attacker_broadcast.create_track(Track::new("tokens"))?;
704 let mut attacker_group = attacker_track.create_group(Group::from(0u64))?;
705 attacker_group.write_frame(Bytes::from_static(b"attacker-data"))?;
706 drop(attacker_group);
707 let moq_client = Client::new()
708 .with_origin(client_origin.clone())
709 .with_consume(client_origin);
710 let handshake = tokio::time::timeout(
711 std::time::Duration::from_secs(2),
712 moq_client.connect(session),
713 )
714 .await;
715 assert!(
716 matches!(handshake, Ok(Err(_))),
717 "anonymous MoQ handshake must be explicitly rejected, not succeed or time out"
718 );
719
720 let server_seen_attacker = tokio::time::timeout(
721 std::time::Duration::from_millis(300),
722 server_consumer.announced_broadcast("mallory/injected"),
723 )
724 .await;
725 assert!(
726 server_seen_attacker.is_err() || server_seen_attacker.ok().flatten().is_none(),
727 "anonymous carrier must not publish into the server origin"
728 );
729 let client_seen_server = tokio::time::timeout(
730 std::time::Duration::from_millis(300),
731 client_consumer.announced_broadcast("alice/run-1"),
732 )
733 .await;
734 assert!(
735 client_seen_server.is_err() || client_seen_server.ok().flatten().is_none(),
736 "anonymous carrier must not subscribe to the server origin"
737 );
738 assert_eq!(
739 resolver_calls.load(Ordering::SeqCst),
740 0,
741 "anonymous carrier must not obtain tenant scope"
742 );
743
744 client.shutdown().await?;
745 server.shutdown().await?;
746 Ok(())
747 }
748
749 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
753 async fn trusted_ingress_relays_to_distinct_subscriber_and_scopes_tenants() -> anyhow::Result<()>
754 {
755 use crate::crypto::pq::{ml_dsa_sk_from_seed, ml_dsa_sk_to_vk_bytes};
756 use crate::stream_info::MoqlServerIdentity;
757 use crate::transport::moql_admission::{
758 prove_moql_admission, AcceptedIdentityState, AcceptedSubjectKey, MoqlAdmissionProof,
759 MoqlServerIdentityProof,
760 };
761
762 let server_ed = SigningKey::from_bytes(&[0x71; 32]);
763 let server_pq = ml_dsa_sk_from_seed(&[0x72; 32]);
764 let producer_ed = SigningKey::from_bytes(&[0x73; 32]);
765 let producer_pq = ml_dsa_sk_from_seed(&[0x74; 32]);
766 let subscriber_ed = SigningKey::from_bytes(&[0x77; 32]);
767 let subscriber_pq = ml_dsa_sk_from_seed(&[0x78; 32]);
768 let other_ed = SigningKey::from_bytes(&[0x79; 32]);
769 let other_pq = ml_dsa_sk_from_seed(&[0x7A; 32]);
770 let expiry = crate::envelope::current_timestamp() + 60_000;
771 let server_identity = MoqlServerIdentity {
772 did: "did:at9p:relay".to_owned(),
773 epoch: 1,
774 head_digest: vec![0x75; 64],
775 expires_at_unix_ms: expiry,
776 ed25519: server_ed.verifying_key().to_bytes(),
777 ml_dsa65: ml_dsa_sk_to_vk_bytes(&server_pq),
778 };
779 let server_state = AcceptedIdentityState {
780 epoch: 1,
781 head_digest: [0x75; 64],
782 expires_at_unix_ms: Some(expiry),
783 subject_keys: vec![AcceptedSubjectKey {
784 ed25519: server_ed.verifying_key().to_bytes(),
785 ml_dsa_65: ml_dsa_sk_to_vk_bytes(&server_pq),
786 }],
787 service_ids: vec![],
788 };
789 let producer_state = AcceptedIdentityState {
790 epoch: 1,
791 head_digest: [0x76; 64],
792 expires_at_unix_ms: Some(expiry),
793 subject_keys: vec![AcceptedSubjectKey {
794 ed25519: producer_ed.verifying_key().to_bytes(),
795 ml_dsa_65: ml_dsa_sk_to_vk_bytes(&producer_pq),
796 }],
797 service_ids: vec![],
798 };
799 let subscriber_state = AcceptedIdentityState {
800 epoch: 1,
801 head_digest: [0x77; 64],
802 expires_at_unix_ms: Some(expiry),
803 subject_keys: vec![AcceptedSubjectKey {
804 ed25519: subscriber_ed.verifying_key().to_bytes(),
805 ml_dsa_65: ml_dsa_sk_to_vk_bytes(&subscriber_pq),
806 }],
807 service_ids: vec![],
808 };
809 let other_state = AcceptedIdentityState {
810 epoch: 1,
811 head_digest: [0x78; 64],
812 expires_at_unix_ms: Some(expiry),
813 subject_keys: vec![AcceptedSubjectKey {
814 ed25519: other_ed.verifying_key().to_bytes(),
815 ml_dsa_65: ml_dsa_sk_to_vk_bytes(&other_pq),
816 }],
817 service_ids: vec![],
818 };
819 let authority: Arc<dyn crate::transport::moql_admission::AcceptedStateAuthority> =
820 Arc::new(move |did: &str| match did {
821 "did:at9p:relay" => Some(server_state.clone()),
822 "did:at9p:producer" => Some(producer_state.clone()),
823 "did:at9p:subscriber" => Some(subscriber_state.clone()),
824 "did:at9p:other-producer" => Some(other_state.clone()),
825 _ => None,
826 });
827 let relay_secret = fresh_key();
828 let relay_carrier = *iroh::SecretKey::from_bytes(&relay_secret)
829 .public()
830 .as_bytes();
831 let admission = Arc::new(
832 crate::transport::moql_admission::MoqlAdmissionAuthenticator::new(
833 authority,
834 Arc::new(|peer| match peer.subject.as_deref() {
835 Some("did:at9p:producer") | Some("did:at9p:subscriber") => {
836 Some("alice".to_owned())
837 }
838 Some("did:at9p:other-producer") => Some("bob".to_owned()),
839 _ => None,
840 }),
841 )
842 .with_server_identity_and_carrier(
843 MoqlServerIdentityProof {
844 identity: server_identity.clone(),
845 ed25519: server_ed,
846 ml_dsa_65: server_pq,
847 },
848 relay_carrier,
849 ),
850 );
851 let handler = IrohMoqProtocolHandler::new().with_authz(
852 MoqAuthzConfig::default()
853 .with_admission(admission)
854 .with_ingress_authorizer(Arc::new(|peer: &PeerIdentity, tenant: &str| {
855 matches!(
856 peer.subject.as_deref(),
857 Some("did:at9p:producer") | Some("did:at9p:other-producer")
858 ) && matches!(tenant, "alice" | "bob")
859 })),
860 );
861 let relay_consumer = handler.origin_consumer().clone();
862 let relay =
863 IrohSubstrate::new_test(relay_secret, handler, NoopHandler::new("rpc-not-wired"))
864 .await?;
865 let producer = IrohSubstrate::new_test(
866 fresh_key(),
867 NoopHandler::new("producer-moq"),
868 NoopHandler::new("producer-rpc"),
869 )
870 .await?;
871 let subscriber = IrohSubstrate::new_test(
872 fresh_key(),
873 NoopHandler::new("subscriber-moq"),
874 NoopHandler::new("subscriber-rpc"),
875 )
876 .await?;
877 let other = IrohSubstrate::new_test(
878 fresh_key(),
879 NoopHandler::new("other-moq"),
880 NoopHandler::new("other-rpc"),
881 )
882 .await?;
883
884 let producer_conn = producer.connect(direct_addr(&relay), ALPN_MOQ_LITE).await?;
885 prove_moql_admission(
886 &producer_conn,
887 &MoqlAdmissionProof {
888 did: "did:at9p:producer".to_owned(),
889 ed25519: producer_ed,
890 ml_dsa_65: producer_pq,
891 expected_server: server_identity.clone(),
892 },
893 *producer.endpoint_id().as_bytes(),
894 std::time::Duration::from_secs(2),
895 )
896 .await?;
897 let producer_origin: OriginProducer = Origin::random().produce();
898 let producer_session = Client::new()
899 .with_origin(producer_origin.clone())
900 .connect(Session::raw(producer_conn))
901 .await?;
902
903 let subscriber_conn = subscriber
904 .connect(direct_addr(&relay), ALPN_MOQ_LITE)
905 .await?;
906 prove_moql_admission(
907 &subscriber_conn,
908 &MoqlAdmissionProof {
909 did: "did:at9p:subscriber".to_owned(),
910 ed25519: subscriber_ed,
911 ml_dsa_65: subscriber_pq,
912 expected_server: server_identity.clone(),
913 },
914 *subscriber.endpoint_id().as_bytes(),
915 std::time::Duration::from_secs(2),
916 )
917 .await?;
918 let subscriber_origin: OriginProducer = Origin::random().produce();
919 let subscriber_consumer = subscriber_origin.consume();
920 let subscriber_session = Client::new()
921 .with_origin(subscriber_origin.clone())
922 .with_consume(subscriber_origin.clone())
923 .connect(Session::raw(subscriber_conn))
924 .await?;
925
926 let broadcast_name = "alice/from-producer";
927 let mut producer_broadcast = producer_origin
928 .create_broadcast(broadcast_name)
929 .ok_or_else(|| anyhow::anyhow!("create producer broadcast"))?;
930 let mut producer_track = producer_broadcast.create_track(Track::new("tokens"))?;
931 let mut producer_group = producer_track.create_group(Group::from(0u64))?;
932 producer_group.write_frame(Bytes::from_static(b"producer frame"))?;
933 drop(producer_group);
934 tokio::time::timeout(
935 std::time::Duration::from_secs(2),
936 relay_consumer.announced_broadcast(broadcast_name),
937 )
938 .await?
939 .ok_or_else(|| anyhow::anyhow!("relay did not ingest trusted producer origin"))?;
940
941 let broadcast = tokio::time::timeout(
942 std::time::Duration::from_secs(2),
943 subscriber_consumer.announced_broadcast(broadcast_name),
944 )
945 .await?
946 .ok_or_else(|| anyhow::anyhow!("distinct subscriber did not receive relay announcement"))?;
947 let track = broadcast.subscribe_track(&Track::new("tokens"))?;
948 let mut group = tokio::time::timeout(std::time::Duration::from_secs(2), track.get_group(0))
949 .await??
950 .ok_or_else(|| anyhow::anyhow!("subscriber track ended before producer frame"))?;
951 assert_eq!(
952 group.read_frame().await?,
953 Some(Bytes::from_static(b"producer frame"))
954 );
955
956 let _subscriber_injection = subscriber_origin
959 .create_broadcast("alice/subscriber-injected")
960 .ok_or_else(|| anyhow::anyhow!("create subscriber injection"))?;
961 assert!(tokio::time::timeout(
962 std::time::Duration::from_millis(300),
963 relay_consumer.announced_broadcast("alice/subscriber-injected")
964 )
965 .await
966 .is_err());
967
968 let other_conn = other.connect(direct_addr(&relay), ALPN_MOQ_LITE).await?;
971 prove_moql_admission(
972 &other_conn,
973 &MoqlAdmissionProof {
974 did: "did:at9p:other-producer".to_owned(),
975 ed25519: other_ed,
976 ml_dsa_65: other_pq,
977 expected_server: server_identity,
978 },
979 *other.endpoint_id().as_bytes(),
980 std::time::Duration::from_secs(2),
981 )
982 .await?;
983 let other_origin: OriginProducer = Origin::random().produce();
984 let other_consumer = other_origin.consume();
985 let other_session = Client::new()
986 .with_origin(other_origin.clone())
987 .with_consume(other_origin.clone())
988 .connect(Session::raw(other_conn))
989 .await?;
990 let _cross_tenant_injection = other_origin
991 .create_broadcast("alice/cross-tenant-injected")
992 .ok_or_else(|| anyhow::anyhow!("create cross-tenant injection"))?;
993 assert!(tokio::time::timeout(
994 std::time::Duration::from_millis(300),
995 relay_consumer.announced_broadcast("alice/cross-tenant-injected")
996 )
997 .await
998 .is_err());
999 assert!(tokio::time::timeout(
1000 std::time::Duration::from_millis(300),
1001 other_consumer.announced_broadcast(broadcast_name)
1002 )
1003 .await
1004 .is_err());
1005
1006 drop(other_session);
1007 drop(subscriber_session);
1008 drop(producer_session);
1009 other.shutdown().await?;
1010 subscriber.shutdown().await?;
1011 producer.shutdown().await?;
1012 relay.shutdown().await?;
1013 Ok(())
1014 }
1015
1016 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
1021 async fn revoked_ingress_closes_live_producer_session() -> anyhow::Result<()> {
1022 use crate::crypto::pq::{ml_dsa_sk_from_seed, ml_dsa_sk_to_vk_bytes};
1023 use crate::stream_info::MoqlServerIdentity;
1024 use crate::transport::moql_admission::{
1025 prove_moql_admission, AcceptedIdentityState, AcceptedSubjectKey, MoqlAdmissionProof,
1026 MoqlServerIdentityProof,
1027 };
1028 use std::sync::atomic::{AtomicBool, Ordering};
1029
1030 let server_ed = SigningKey::from_bytes(&[0x81; 32]);
1031 let server_pq = ml_dsa_sk_from_seed(&[0x82; 32]);
1032 let producer_ed = SigningKey::from_bytes(&[0x83; 32]);
1033 let producer_pq = ml_dsa_sk_from_seed(&[0x84; 32]);
1034 let expiry = crate::envelope::current_timestamp() + 60_000;
1035 let server_identity = MoqlServerIdentity {
1036 did: "did:at9p:relay".to_owned(),
1037 epoch: 1,
1038 head_digest: vec![0x85; 64],
1039 expires_at_unix_ms: expiry,
1040 ed25519: server_ed.verifying_key().to_bytes(),
1041 ml_dsa65: ml_dsa_sk_to_vk_bytes(&server_pq),
1042 };
1043 let server_state = AcceptedIdentityState {
1044 epoch: 1,
1045 head_digest: [0x85; 64],
1046 expires_at_unix_ms: Some(expiry),
1047 subject_keys: vec![AcceptedSubjectKey {
1048 ed25519: server_ed.verifying_key().to_bytes(),
1049 ml_dsa_65: ml_dsa_sk_to_vk_bytes(&server_pq),
1050 }],
1051 service_ids: vec![],
1052 };
1053 let producer_state = AcceptedIdentityState {
1054 epoch: 1,
1055 head_digest: [0x86; 64],
1056 expires_at_unix_ms: Some(expiry),
1057 subject_keys: vec![AcceptedSubjectKey {
1058 ed25519: producer_ed.verifying_key().to_bytes(),
1059 ml_dsa_65: ml_dsa_sk_to_vk_bytes(&producer_pq),
1060 }],
1061 service_ids: vec![],
1062 };
1063 let authority: Arc<dyn crate::transport::moql_admission::AcceptedStateAuthority> =
1064 Arc::new(move |did: &str| match did {
1065 "did:at9p:relay" => Some(server_state.clone()),
1066 "did:at9p:producer" => Some(producer_state.clone()),
1067 _ => None,
1068 });
1069 let relay_secret = fresh_key();
1070 let relay_carrier = *iroh::SecretKey::from_bytes(&relay_secret)
1071 .public()
1072 .as_bytes();
1073 let admission = Arc::new(
1074 crate::transport::moql_admission::MoqlAdmissionAuthenticator::new(
1075 authority,
1076 Arc::new(|peer| {
1077 (peer.subject.as_deref() == Some("did:at9p:producer"))
1078 .then(|| "alice".to_owned())
1079 }),
1080 )
1081 .with_server_identity_and_carrier(
1082 MoqlServerIdentityProof {
1083 identity: server_identity.clone(),
1084 ed25519: server_ed,
1085 ml_dsa_65: server_pq,
1086 },
1087 relay_carrier,
1088 ),
1089 );
1090 let grant = Arc::new(AtomicBool::new(true));
1093 let grant_for_authz = Arc::clone(&grant);
1094 let handler = IrohMoqProtocolHandler::new().with_authz(
1095 MoqAuthzConfig::default()
1096 .with_admission(admission)
1097 .with_ingress_authorizer(Arc::new(move |peer: &PeerIdentity, tenant: &str| {
1098 grant_for_authz.load(Ordering::SeqCst)
1099 && peer.subject.as_deref() == Some("did:at9p:producer")
1100 && tenant == "alice"
1101 })),
1102 );
1103 let relay_consumer = handler.origin_consumer().clone();
1104 let relay =
1105 IrohSubstrate::new_test(relay_secret, handler, NoopHandler::new("rpc-not-wired"))
1106 .await?;
1107 let producer = IrohSubstrate::new_test(
1108 fresh_key(),
1109 NoopHandler::new("producer-moq"),
1110 NoopHandler::new("producer-rpc"),
1111 )
1112 .await?;
1113
1114 let producer_conn = producer.connect(direct_addr(&relay), ALPN_MOQ_LITE).await?;
1115 prove_moql_admission(
1116 &producer_conn,
1117 &MoqlAdmissionProof {
1118 did: "did:at9p:producer".to_owned(),
1119 ed25519: producer_ed,
1120 ml_dsa_65: producer_pq,
1121 expected_server: server_identity.clone(),
1122 },
1123 *producer.endpoint_id().as_bytes(),
1124 std::time::Duration::from_secs(2),
1125 )
1126 .await?;
1127 let producer_origin: OriginProducer = Origin::random().produce();
1128 let producer_session = Client::new()
1129 .with_origin(producer_origin.clone())
1130 .connect(Session::raw(producer_conn))
1131 .await?;
1132
1133 let mut first = producer_origin
1135 .create_broadcast("alice/first")
1136 .ok_or_else(|| anyhow::anyhow!("create first broadcast"))?;
1137 let mut track = first.create_track(Track::new("tokens"))?;
1138 let mut group = track.create_group(Group::from(0u64))?;
1139 group.write_frame(Bytes::from_static(b"first frame"))?;
1140 drop(group);
1141 tokio::time::timeout(
1142 std::time::Duration::from_secs(2),
1143 relay_consumer.announced_broadcast("alice/first"),
1144 )
1145 .await?
1146 .ok_or_else(|| anyhow::anyhow!("relay did not ingest the granted producer origin"))?;
1147
1148 grant.store(false, Ordering::SeqCst);
1151
1152 let close =
1159 tokio::time::timeout(std::time::Duration::from_secs(5), producer_session.closed())
1160 .await
1161 .map_err(|_| {
1162 anyhow::anyhow!("revoked ingress did not close the live producer session")
1163 })?;
1164 match close {
1165 Err(moq_net::Error::Transport(_)) => {}
1166 other => {
1167 return Err(anyhow::anyhow!(
1168 "unexpected session close outcome: {other:?}"
1169 ))
1170 }
1171 }
1172 let _late = producer_origin
1173 .create_broadcast("alice/after-revoke")
1174 .ok_or_else(|| anyhow::anyhow!("create post-revocation broadcast"))?;
1175 assert!(
1176 tokio::time::timeout(
1177 std::time::Duration::from_secs(1),
1178 relay_consumer.announced_broadcast("alice/after-revoke")
1179 )
1180 .await
1181 .is_err(),
1182 "a revoked producer must not announce further broadcasts on the same connection"
1183 );
1184
1185 drop(first);
1186 drop(track);
1187 drop(producer_session);
1188 producer.shutdown().await?;
1189 relay.shutdown().await?;
1190 Ok(())
1191 }
1192
1193 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
1197 async fn admission_connection_cap_saturates_and_releases() -> anyhow::Result<()> {
1198 use crate::crypto::pq::{ml_dsa_sk_from_seed, ml_dsa_sk_to_vk_bytes};
1199 use crate::stream_info::MoqlServerIdentity;
1200 use crate::transport::moql_admission::{
1201 AcceptedIdentityState, AcceptedSubjectKey, MoqlServerIdentityProof,
1202 };
1203
1204 let server_ed = SigningKey::from_bytes(&[0xA1; 32]);
1205 let server_pq = ml_dsa_sk_from_seed(&[0xA2; 32]);
1206 let server_did = "did:at9p:connection-cap-server".to_owned();
1207 let server_identity = MoqlServerIdentity {
1208 did: server_did.clone(),
1209 epoch: 1,
1210 head_digest: vec![0xA3; 64],
1211 expires_at_unix_ms: crate::envelope::current_timestamp() + 60_000,
1212 ed25519: server_ed.verifying_key().to_bytes(),
1213 ml_dsa65: ml_dsa_sk_to_vk_bytes(&server_pq),
1214 };
1215 let mut head_digest = [0u8; 64];
1216 head_digest.copy_from_slice(&server_identity.head_digest);
1217 let accepted_server = AcceptedIdentityState {
1218 epoch: server_identity.epoch,
1219 head_digest,
1220 subject_keys: vec![AcceptedSubjectKey {
1221 ed25519: server_identity.ed25519,
1222 ml_dsa_65: server_identity.ml_dsa65.clone(),
1223 }],
1224 service_ids: vec![],
1225 expires_at_unix_ms: Some(server_identity.expires_at_unix_ms),
1226 };
1227 let authority: Arc<dyn crate::transport::moql_admission::AcceptedStateAuthority> =
1228 Arc::new(move |did: &str| (did == server_did).then(|| accepted_server.clone()));
1229
1230 let server_secret = fresh_key();
1231 let server_carrier = *iroh::SecretKey::from_bytes(&server_secret)
1232 .public()
1233 .as_bytes();
1234 let admission = Arc::new(
1235 crate::transport::moql_admission::MoqlAdmissionAuthenticator::new(
1236 authority,
1237 Arc::new(|_peer| None),
1238 )
1239 .with_server_identity_and_carrier(
1240 MoqlServerIdentityProof {
1241 identity: server_identity,
1242 ed25519: server_ed,
1243 ml_dsa_65: server_pq,
1244 },
1245 server_carrier,
1246 ),
1247 );
1248 let handler = IrohMoqProtocolHandler::new()
1249 .with_authz(MoqAuthzConfig::default().with_admission(admission))
1250 .with_connection_limit(1);
1251 let server = IrohSubstrate::new_test(
1252 server_secret,
1253 handler.clone(),
1254 NoopHandler::new("rpc-not-wired"),
1255 )
1256 .await?;
1257 let server_addr = direct_addr(&server);
1258 let client = IrohSubstrate::new_test(
1259 fresh_key(),
1260 NoopHandler::new("client-moq"),
1261 NoopHandler::new("client-rpc"),
1262 )
1263 .await?;
1264
1265 let first = client.connect(server_addr.clone(), ALPN_MOQ_LITE).await?;
1268 tokio::time::timeout(std::time::Duration::from_secs(2), async {
1269 while handler.inner.connection_limit.available_permits() != 0 {
1270 tokio::task::yield_now().await;
1271 }
1272 })
1273 .await
1274 .map_err(|_| {
1275 anyhow::anyhow!("first stalled admission did not acquire connection permit")
1276 })?;
1277
1278 let second = client.connect(server_addr.clone(), ALPN_MOQ_LITE).await?;
1281 tokio::time::sleep(std::time::Duration::from_millis(50)).await;
1282 assert_eq!(
1283 handler.inner.connection_limit.available_permits(),
1284 0,
1285 "saturated admission must retain only the first connection permit"
1286 );
1287 second.close(0u32.into(), b"test complete");
1288
1289 first.close(0u32.into(), b"test complete");
1290 tokio::time::timeout(std::time::Duration::from_secs(2), async {
1291 while handler.inner.connection_limit.available_permits() != 1 {
1292 tokio::task::yield_now().await;
1293 }
1294 })
1295 .await
1296 .map_err(|_| anyhow::anyhow!("connection permit was not released after close"))?;
1297
1298 client.shutdown().await?;
1299 server.shutdown().await?;
1300 Ok(())
1301 }
1302}