Skip to main content

hyprstream_rpc/transport/
iroh_moq.rs

1//! Iroh streaming plane — moq-lite (`moql` ALPN) protocol handler.
2//!
3//! Part of Epic #131 Phase 3 (#134). This module ships the wire layer for
4//! the streaming plane:
5//!
6//! - [`IrohMoqProtocolHandler`] plugs into [`crate::transport::iroh_substrate`]
7//!   under the `moql` ALPN, wrapping each accepted iroh `Connection` as a
8//!   `web_transport_iroh::Session` and handing it to `moq_net::Server`,
9//!   which spawns the moq-lite session machinery internally.
10//! - One shared [`OriginShared`] (an `OriginProducer` + matching
11//!   `OriginConsumer`) is held by the handler; the *same* origin is used
12//!   for **in-process publishing** (callers obtain it via
13//!   [`IrohMoqProtocolHandler::origin_producer`] and create broadcasts
14//!   directly) **and for external subscribers** — per spike #94's finding,
15//!   `moq_net::Server` does exactly this.
16//!
17//! **Trust model**: §7.5 unchanged. On the wire, subscribers learn the
18//! DH-derived (unguessable) Track path out-of-band via authenticated RPC
19//! (a signed `StreamInfo`), and the per-Frame payload carries the
20//! chained-HMAC envelope. CDN-portability per §10.x of the Federated Agentic
21//! Namespaces doc. Admission: without an authenticator the carrier is
22//! unauthenticated and the accept path refuses anonymous peers; with a
23//! [`crate::transport::moql_admission::MoqlAdmissionAuthenticator`] installed
24//! (#1027), each connection must first prove an accepted current
25//! Ed25519 + ML-DSA-65 identity inside the carrier, and is then served only
26//! its own tenant's scope.
27//!
28//! **What this module does NOT do**: refactor `StreamService` or
29//! `EventService` to use this. That lands in Phase 3 part 2+ along with
30//! the §7.5 chained-HMAC tokenstream port.
31
32use 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
47/// Resolves the tenant for an independently authenticated application peer.
48/// Carrier NodeId is never passed here. Without a fresh-proof seam (#1027)
49/// the iroh accept path refuses before invoking this resolver; with a
50/// [`MoqlAdmissionAuthenticator`] installed, the resolver runs inside the
51/// admission exchange over the *verified* subject.
52pub type PeerTenantResolver = Arc<dyn Fn(&PeerIdentity) -> Option<String> + Send + Sync>;
53
54/// Trusted decision for granting an admitted peer ingress into a tenant's
55/// shared origin. Admission proves the peer identity and tenant only; it does
56/// not imply that the peer may publish. The default is therefore deny.
57pub trait IngressAuthorizer: Send + Sync {
58    /// Whether this already-admitted `peer` may publish to the supplied tenant.
59    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
71/// Shareable ingress authorization hook supplied by the owning service policy.
72pub type SharedIngressAuthorizer = Arc<dyn IngressAuthorizer>;
73
74/// #276 authorization config for a moq accept path: an optional subscribe
75/// authorizer and an optional peer→tenant resolver for per-tenant announce
76/// scoping. Absence of fresh application/session proof is always fail-closed;
77/// these hooks cannot turn an anonymous carrier into an authenticated peer.
78///
79/// #1027: installing an [`MoqlAdmissionAuthenticator`] changes the posture —
80/// the accept path runs the inside-carrier Ed25519 + ML-DSA-65
81/// challenge/response before any moq machinery and serves only the admitted
82/// peer's tenant scope. Without it, the anonymous fail-closed refusal below is
83/// unchanged.
84#[derive(Clone, Default)]
85pub struct MoqAuthzConfig {
86    /// Subscribe-time authorization hook (public-open / private-gated).
87    pub authorizer: Option<SharedSubscribeAuthorizer>,
88    /// Maps a peer identity to its tenant for per-tenant announce scoping.
89    pub tenant_resolver: Option<PeerTenantResolver>,
90    /// Explicit trusted producer/relay decision. Its absence is a deliberate
91    /// deny: an admitted peer is a read-only subscriber, never a publisher.
92    pub ingress_authorizer: Option<SharedIngressAuthorizer>,
93    /// #1027 inside-carrier admission authenticator. When set, every accepted
94    /// `moql` connection must prove an accepted current Ed25519 + ML-DSA-65
95    /// identity before the moq handshake; the carrier NodeId alone is refused.
96    pub admission: Option<Arc<MoqlAdmissionAuthenticator>>,
97}
98
99impl MoqAuthzConfig {
100    /// Resolve the tenant for `peer`, if a resolver is configured.
101    pub fn tenant_for(&self, peer: &PeerIdentity) -> Option<String> {
102        self.tenant_resolver.as_ref().and_then(|r| r(peer))
103    }
104
105    /// Set/replace the subscribe authorizer.
106    pub fn with_authorizer(mut self, authorizer: SharedSubscribeAuthorizer) -> Self {
107        self.authorizer = Some(authorizer);
108        self
109    }
110
111    /// Install the service-owned trusted ingress decision. This hook is kept
112    /// separate from tenant admission: a subject→tenant row is not a producer
113    /// role grant.
114    pub fn with_ingress_authorizer(mut self, authorizer: SharedIngressAuthorizer) -> Self {
115        self.ingress_authorizer = Some(authorizer);
116        self
117    }
118
119    /// Install an optional service-owned ingress decision without converting an
120    /// absent deployment policy into a grant.
121    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    /// Whether the admitted peer has an explicit trusted ingress grant.
130    /// Missing configuration fails closed to read-only delivery.
131    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    /// Install the #1027 inside-carrier admission authenticator. The
138    /// authenticator carries its own authoritative subject→tenant resolver;
139    /// `tenant_resolver` is only consulted for peers authenticated by other
140    /// means (none today on this path).
141    pub fn with_admission(mut self, admission: Arc<MoqlAdmissionAuthenticator>) -> Self {
142        self.admission = Some(admission);
143        self
144    }
145
146    /// Gate an MoQ session while the transport cannot surface track names.
147    ///
148    /// Dormant (`None`) preserves the legacy pass-through. Once an authorizer
149    /// is installed, its coarse admission decision is mandatory; current
150    /// implementations deny until moq-net's #276 per-track callback exists.
151    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/// Shared `Origin` clone-pair held by the handler.
161///
162/// - `producer` is what *we* publish into (call `create_broadcast`, `create_track`, etc.).
163/// - `consumer` is what *remote subscribers* read from (handed to `Server::with_publish`).
164///
165/// Both reference the same underlying tree — broadcasts created via
166/// `producer` are visible to remote subscribers consuming via `consumer`.
167#[derive(Clone)]
168pub struct OriginShared {
169    producer: OriginProducer,
170    consumer: OriginConsumer,
171}
172
173impl OriginShared {
174    /// Build a fresh origin pair with a random id.
175    pub fn new() -> Self {
176        let producer = Origin::random().produce();
177        let consumer = producer.consume();
178        Self { producer, consumer }
179    }
180
181    /// Wrap an existing producer/consumer pair (e.g. the process-global moq
182    /// origin) so the iroh `moql` accept path serves the SAME broadcasts the
183    /// quinn `/moq` path does (#282 parallel bind).
184    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/// iroh `ProtocolHandler` for the `moql` ALPN. Each accepted connection is
204/// wrapped as a `web_transport_iroh::Session` and handed to
205/// `moq_net::Server::accept`, which performs the moq handshake and spawns
206/// the session machinery.
207#[derive(Clone)]
208pub struct IrohMoqProtocolHandler {
209    inner: Arc<HandlerInner>,
210}
211
212struct HandlerInner {
213    origin: OriginShared,
214    stats: StatsHandle,
215    /// #276 subscribe-authz + per-tenant announce scoping config. Defaults to
216    /// "off" (open same-tenant subscribe preserved).
217    authz: MoqAuthzConfig,
218    /// Caps accepted `moql` connections before their admission exchange. The
219    /// permit lives until the connection accept task exits.
220    connection_limit: Arc<Semaphore>,
221    /// Triggered by `ProtocolHandler::shutdown` so accept handlers stop
222    /// waiting for `Session::closed()` and exit promptly.
223    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    /// Build with a fresh origin pair (use [`Self::origin_producer`] to
236    /// publish broadcasts).
237    pub fn new() -> Self {
238        Self::with_origin(OriginShared::new())
239    }
240
241    /// Build with a caller-supplied origin pair. Useful when one origin is
242    /// shared across multiple substrates or with an existing service.
243    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    /// Install the #276 subscribe-authz + per-tenant announce-scoping config.
259    ///
260    /// With an [`MoqlAdmissionAuthenticator`] in the config (#1027), the accept
261    /// path runs the inside-carrier challenge/response first and the admitted
262    /// peer's tenant scope is served. Without one, no fresh-proof seam supplies
263    /// an authenticated [`PeerIdentity`] and the carrier NodeId alone never
264    /// reaches the resolver.
265    pub fn with_authz(mut self, authz: MoqAuthzConfig) -> Self {
266        self.rebuild_inner(|i| i.authz = authz);
267        self
268    }
269
270    /// Query the installed ingress decision. This is intentionally the same
271    /// decision the accept path uses when choosing its scoped writable origin.
272    /// It keeps service-spawner wiring testable without exposing handler state.
273    pub fn authorizes_ingress(&self, peer: &PeerIdentity, tenant: &str) -> bool {
274        self.inner.authz.authorizes_ingress(peer, tenant)
275    }
276
277    /// Override the server-wide accepted-connection cap. Connections beyond
278    /// the cap are dropped instead of waiting for admission.
279    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    /// Serve only the fixed Event namespace, with independent MAC decisions
285    /// for each declared source and direction. No per-track callback is needed:
286    /// the session never receives an origin outside its authorized sources.
287    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            // Event has a fixed namespace. Other tenants cannot acquire local
302            // visibility, even if their policy happens to permit a source.
303            if tenant != "local" {
304                return (subscribe, publish);
305            }
306            let subject = crate::envelope::Subject::new(subject.clone());
307            // Inventory comes from the same reference monitor as label policy.
308            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    /// Revalidate only grants this session actually holds. Probing unrelated
322    /// denied scopes on every watchdog tick emits an unbounded denial WAL.
323    /// This caches no permit: every held operation is checked afresh.
324    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    /// Mutate the inner config, cloning the shared `Arc<HandlerInner>` only when
356    /// it is already shared (cloned handler) so builder calls compose without
357    /// dropping previously-installed fields (authz / admission).
358    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    /// Borrow the shared origin pair.
377    pub fn origin(&self) -> &OriginShared {
378        &self.inner.origin
379    }
380
381    /// Borrow the producer (for in-process publishing).
382    pub fn origin_producer(&self) -> &OriginProducer {
383        self.inner.origin.producer()
384    }
385
386    /// Borrow the consumer (for in-process subscribing — same data as a
387    /// remote subscriber sees on the wire).
388    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        // Iroh's Router creates an accept task per carrier connection. Acquire
402        // before awaiting the #1027 challenge/response so unauthenticated peers
403        // cannot retain unbounded tasks for the admission timeout. Keep this
404        // permit through the admitted session's lifetime.
405        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        // #1027: with an admission authenticator installed, the peer must
415        // complete the fresh inside-carrier Ed25519 + ML-DSA-65
416        // challenge/response BEFORE any moq machinery runs. The exchange binds
417        // the accepted-state epoch/head and both nonces into the transcript;
418        // replay, expiry, rotation, cross-tenant resolution failure, and
419        // NodeId-only identity all reject here, fail-closed.
420        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        // Carrier NodeId is transport metadata only. Without #1027 admission
441        // proof, authorization sees an anonymous peer.
442        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        // Authenticated-session path: hand the admitted peer only a consumer
468        // narrowed to its own `{tenant}/` prefix. The tenant comes from the
469        // admission exchange (server-resolved from the verified subject); the
470        // legacy resolver seam remains for any future proof source. Missing
471        // tenant resolution must remain fail-closed; it must never fall back
472        // to the process-global consumer.
473        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        // An admitted session is a tenant-scoped *subscriber* by default.
492        // Admission proves identity and tenant; it is not a producer/relay
493        // capability. Only a separate service-owned ingress decision may hand
494        // the peer a scoped writable origin. This keeps an ordinary subscriber
495        // from colliding with a producer's broadcast names.
496        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            // Never scope with an empty list: library defaults must not turn
526            // deny into an unrestricted origin.
527            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        // Admission is stateful rather than a one-time capability. Poll the
562        // same daemon-owned authority used by the challenge exchange while the
563        // MoQ session is alive; expiry, an accepted-head advance, or a rotated
564        // key closes the carrier and drops the scoped session immediately.
565        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        // Hold the session alive until either the connection closes or
570        // shutdown is requested. Server::accept has already spawned the
571        // session's pump tasks; dropping `moq_session` tears them down.
572        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                    // Ingress is live deployment authority, not a one-time
599                    // capability: a revoked grant must not keep announcing on
600                    // the writable scoped origin this session already holds.
601                    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    /// An anonymous carrier cannot subscribe to server broadcasts, publish a
653    /// client origin, or reach the tenant resolver. Mutating the carrier NodeId
654    /// cannot change that decision because it is never an application proof.
655    #[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        // A server-side broadcast would be exposed if anonymous subscribe were
680        // still open.
681        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        // A client-side origin would be exposed if anonymous publish were open.
690        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    /// A real mutually admitted producer, relay, and distinct subscriber carry
750    /// a frame end-to-end. The subscriber is read-only, while trusted ingress
751    /// remains both subject- and tenant-scoped.
752    #[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        // An authenticated subscriber is read-only even when it offers an
957        // origin: it cannot inject a same-tenant broadcast into the relay.
958        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        // A separately trusted bob producer can connect, but its scoped origin
969        // cannot ingest into alice and its scoped consumer cannot observe alice.
970        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    /// Ingress is live deployment authority, not a one-time capability: when
1017    /// the grant is revoked mid-session, the currentness watchdog closes the
1018    /// session that already holds the writable scoped origin, so no further
1019    /// announcement is carried on that connection without any reconnect.
1020    #[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        // Mutable policy backing the ingress decision; the test flips
1091        // `grant` mid-session to model a grant revocation.
1092        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        // Granted: the producer's announce is carried end-to-end.
1134        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        // Revoke the grant. The writable scoped origin is already in the
1149        // peer's hands; only the live-session recheck can stop it.
1150        grant.store(false, Ordering::SeqCst);
1151
1152        // The same connection's session is closed by the watchdog; the peer
1153        // cannot carry any further announcement on it. Pinned moq-net
1154        // (07f558f, rs/moq-net/src/session.rs:81-84) yields
1155        // `Err(Error::Transport(..))` from `closed()` unconditionally, with
1156        // the transport close reason inside; the session resolving at all IS
1157        // the close — that is the success condition here.
1158        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    /// The connection cap is acquired before #1027 admission awaits the peer's
1194    /// first stream, is not queued for a saturated peer, and is returned when
1195    /// the stalled carrier closes.
1196    #[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        // This carrier never opens the admission stream, leaving the server in
1266        // the bounded admission wait while holding its one connection permit.
1267        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        // A second connection reaches iroh's carrier handshake but cannot add a
1279        // second admission task; the handler rejects it without queueing.
1280        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}