1use std::collections::HashMap;
48use std::path::{Path, PathBuf};
49use std::sync::{
50 atomic::{AtomicU64, Ordering},
51 Arc, OnceLock, Weak,
52};
53
54use anyhow::{anyhow, ensure, Context, Result};
55use bytes::Bytes;
56use moq_net::{
57 Broadcast, BroadcastConsumer, BroadcastProducer, Group, OriginConsumer, OriginProducer, Track,
58 TrackProducer,
59};
60use parking_lot::{Mutex, RwLock};
61use tokio_util::sync::CancellationToken;
62
63use crate::crypto::StreamHmacState;
64use crate::stream_epoch::StreamEpochRatchet;
65use crate::streaming::{StreamContext, StreamPayloadData, StreamVerifier};
66
67static GLOBAL_MOQ_ORIGIN: OnceLock<MoqStreamOrigin> = OnceLock::new();
74static GLOBAL_MOQ_UDS_PATH: OnceLock<PathBuf> = OnceLock::new();
76static GLOBAL_MOQ_ADMISSION_PROOF: OnceLock<crate::transport::moql_admission::MoqlAdmissionProof> =
80 OnceLock::new();
81
82pub fn init_global_moq_admission_proof(
84 proof: crate::transport::moql_admission::MoqlAdmissionProof,
85) -> bool {
86 GLOBAL_MOQ_ADMISSION_PROOF.set(proof).is_ok()
87}
88
89pub fn global_moq_admission_proof(
91) -> Option<&'static crate::transport::moql_admission::MoqlAdmissionProof> {
92 GLOBAL_MOQ_ADMISSION_PROOF.get()
93}
94
95pub fn init_global_moq_origin(origin: MoqStreamOrigin) -> bool {
101 GLOBAL_MOQ_ORIGIN.set(origin).is_ok()
102}
103
104pub fn global_moq_origin() -> Option<&'static MoqStreamOrigin> {
108 GLOBAL_MOQ_ORIGIN.get()
109}
110
111pub fn global_moq_uds_path() -> Option<&'static Path> {
116 GLOBAL_MOQ_UDS_PATH.get().map(PathBuf::as_path)
117}
118
119#[derive(Clone, Debug)]
121pub struct NodeStreamReach {
122 pub addr: std::net::SocketAddr,
124 pub server_name: String,
126 pub cert_hashes: Vec<[u8; 32]>,
128}
129
130#[derive(Clone, Debug, Default)]
138pub struct ProducerReachConfig {
139 pub moql_server_identity: Option<crate::stream_info::MoqlServerIdentity>,
142 pub relay_moql_server_identity: Option<crate::stream_info::MoqlServerIdentity>,
146 pub iroh_node_id: Option<[u8; 32]>,
149 pub quic_reach: Option<NodeStreamReach>,
153 pub relay: Option<crate::stream_info::TransportConfig>,
157}
158
159pub type ProducerReachConfigHandle = Arc<RwLock<ProducerReachConfig>>;
162
163impl ProducerReachConfig {
164 pub fn reach(&self) -> Vec<crate::stream_info::Destination> {
170 self.reach_with_relay(RelayChoice::ServerDefault)
171 }
172
173 pub fn reach_with_relay(
181 &self,
182 relay_choice: RelayChoice,
183 ) -> Vec<crate::stream_info::Destination> {
184 use crate::stream_info::{Destination, IrohReach, QuicReach, Role, TransportConfig};
185 let mut reach = Vec::new();
186
187 let relay_only = matches!(relay_choice, RelayChoice::Only(_));
190
191 if !relay_only {
192 if let Some(node_id) = self.iroh_node_id {
197 reach.push(Destination {
198 role: Role::Direct,
199 transport: TransportConfig::Iroh(IrohReach {
201 node_id,
202 alpn: String::from_utf8_lossy(
203 crate::transport::iroh_substrate::ALPN_MOQ_LITE,
204 )
205 .into_owned(),
206 relay_url: String::new(),
207 }),
208 moql_server_identity: self.moql_server_identity.clone().unwrap_or_default(),
209 });
210 }
211
212 if let Some(r) = &self.quic_reach {
215 reach.push(Destination {
216 role: Role::Direct,
217 transport: TransportConfig::Quic(QuicReach {
218 addr: r.addr.to_string(),
219 server_name: r.server_name.clone(),
220 cert_hashes: r.cert_hashes.iter().map(|h| h.to_vec()).collect(),
221 }),
222 moql_server_identity: self.moql_server_identity.clone().unwrap_or_default(),
223 });
224 }
225 }
226
227 let relay = match relay_choice {
239 RelayChoice::ServerDefault => self
240 .relay
241 .clone()
242 .map(|relay| (relay, self.relay_moql_server_identity.clone())),
243 RelayChoice::Override(target) | RelayChoice::Only(target) => {
246 Some((target.transport, Some(target.server_identity)))
247 }
248 RelayChoice::NoRelay => None,
249 };
250 if let Some((relay, relay_identity)) = relay {
251 reach.push(Destination {
252 role: Role::Relay,
253 transport: relay,
254 moql_server_identity: relay_identity.unwrap_or_default(),
255 });
256 }
257
258 reach
259 }
260}
261
262#[derive(Clone, Debug, Default)]
267pub enum RelayChoice {
268 #[default]
271 ServerDefault,
272 Override(RelayTarget),
277 Only(RelayTarget),
280 NoRelay,
285}
286
287#[derive(Clone, Debug)]
293pub struct RelayTarget {
294 pub transport: crate::stream_info::TransportConfig,
295 pub server_identity: crate::stream_info::MoqlServerIdentity,
296}
297
298impl RelayTarget {
299 pub fn new(
300 transport: crate::stream_info::TransportConfig,
301 server_identity: crate::stream_info::MoqlServerIdentity,
302 ) -> Self {
303 Self {
304 transport,
305 server_identity,
306 }
307 }
308}
309
310pub fn relay_reach_from_decoded(
322 config: &crate::transport::TransportConfig,
323) -> Option<crate::stream_info::TransportConfig> {
324 use crate::stream_info::{IrohReach, QuicReach, TransportConfig as ReachTransport};
325 use crate::transport::EndpointType;
326 match &config.endpoint {
327 EndpointType::Quic {
328 addr,
329 server_name,
330 auth,
331 } => Some(ReachTransport::Quic(QuicReach {
332 addr: addr.to_string(),
333 server_name: server_name.clone(),
334 cert_hashes: auth
335 .accept_cert_hashes()
336 .iter()
337 .map(|h| h.to_vec())
338 .collect(),
339 })),
340 EndpointType::Iroh {
341 node_id, relay_url, ..
342 } => {
343 Some(ReachTransport::Iroh(IrohReach {
345 node_id: *node_id,
346 alpn: String::from_utf8_lossy(crate::transport::iroh_substrate::ALPN_MOQ_LITE)
347 .into_owned(),
348 relay_url: relay_url.clone().unwrap_or_default(),
349 }))
350 }
351 EndpointType::Ipc { .. } | EndpointType::SystemdFd { .. } | EndpointType::Inproc { .. } => {
352 None
353 }
354 }
355}
356
357pub fn serve_moq_uds_background(origin: MoqStreamOrigin, path: PathBuf) {
367 use crate::transport::uds_session::{accept_uds, PLANE_MOQ};
368 use moq_net::Server as MoqServer;
369
370 if native_iroh_required() {
371 tracing::error!("network-iroh-required refuses a local MoQ socket server");
372 return;
373 }
374 let _ = std::fs::remove_file(&path);
376
377 let listener = match std::os::unix::net::UnixListener::bind(&path) {
380 Ok(l) => l,
381 Err(e) => {
382 tracing::error!(path = %path.display(), "moq UDS bind failed: {e}");
383 return;
384 }
385 };
386
387 #[cfg(unix)]
389 {
390 use std::os::unix::fs::PermissionsExt;
391 let _ = std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600));
392 }
393
394 if let Err(e) = listener.set_nonblocking(true) {
398 tracing::error!("moq UDS set_nonblocking failed: {e}");
399 return;
400 }
401
402 let listener = match tokio::net::UnixListener::from_std(listener) {
404 Ok(l) => l,
405 Err(e) => {
406 tracing::error!("moq UDS listener conversion failed: {e}");
407 return;
408 }
409 };
410
411 if GLOBAL_MOQ_UDS_PATH.set(path.clone()).is_err() {
412 return; }
414
415 tracing::info!(path = %path.display(), "moq UDS listener ready");
416
417 tokio::spawn(async move {
418 loop {
419 let stream = match listener.accept().await {
420 Ok((s, _)) => s,
421 Err(e) => {
422 tracing::warn!("moq UDS accept error: {e}");
423 continue;
424 }
425 };
426 let consumer = origin.consumer().clone();
427 tokio::spawn(async move {
428 let (plane, session) = match accept_uds(stream).await {
429 Ok(pair) => pair,
430 Err(e) => {
431 tracing::debug!("moq UDS handshake error: {e}");
432 return;
433 }
434 };
435 if plane != PLANE_MOQ {
436 tracing::debug!("moq UDS: unexpected plane 0x{plane:02x} — dropping");
437 return;
438 }
439 if let Err(e) = MoqServer::new()
440 .with_publish(consumer)
441 .accept(session)
442 .await
443 {
444 tracing::debug!("moq UDS session ended: {e}");
445 }
446 });
447 }
448 });
449}
450
451pub const BROADCAST_ANNOUNCE_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);
453
454pub const GROUP_IDLE_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(30);
457
458pub const FRAME_READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(5);
460
461pub const STREAM_TRACK: &str = "stream";
463
464pub const DEFAULT_PREFIX: &str = "local/streams";
470
471#[derive(Clone)]
478pub struct MoqStreamOrigin {
479 inner: Arc<OriginInner>,
480}
481
482pub type MoqStreamOriginHandle = Arc<RwLock<Option<MoqStreamOrigin>>>;
485
486pub struct MoqStreamOriginBuilder {
489 producer: OriginProducer,
490 consumer: OriginConsumer,
491 prefix: String,
492 authorize_signer: Option<Arc<dyn Fn(&[u8; 32]) -> bool + Send + Sync>>,
493}
494
495impl MoqStreamOriginBuilder {
496 pub fn with_prefix(mut self, prefix: impl Into<String>) -> Self {
498 self.prefix = prefix.into();
499 self
500 }
501
502 pub fn with_authorize_signer(
505 mut self,
506 f: impl Fn(&[u8; 32]) -> bool + Send + Sync + 'static,
507 ) -> Self {
508 self.authorize_signer = Some(Arc::new(f));
509 self
510 }
511
512 pub fn build(self) -> MoqStreamOrigin {
514 MoqStreamOrigin {
515 inner: Arc::new(OriginInner {
516 producer: self.producer,
517 consumer: self.consumer,
518 prefix: self.prefix,
519 authorize_signer: self.authorize_signer,
520 broadcasts: Mutex::new(HashMap::new()),
521 next_broadcast_generation: AtomicU64::new(0),
522 }),
523 }
524 }
525}
526
527struct BroadcastEntry {
528 _producer: BroadcastProducer,
529 generation: u64,
530}
531
532struct OriginInner {
533 producer: OriginProducer,
534 consumer: OriginConsumer,
535 prefix: String,
537 authorize_signer: Option<Arc<dyn Fn(&[u8; 32]) -> bool + Send + Sync>>,
543 broadcasts: Mutex<HashMap<String, BroadcastEntry>>,
549 next_broadcast_generation: AtomicU64,
550}
551
552struct BroadcastCleanup {
557 origin: Weak<OriginInner>,
558 path: String,
559 generation: u64,
560}
561
562impl Drop for BroadcastCleanup {
563 fn drop(&mut self) {
564 let Some(origin) = self.origin.upgrade() else {
565 return;
566 };
567 let removed = {
568 let mut broadcasts = origin.broadcasts.lock();
569 let remove = broadcasts
570 .get(&self.path)
571 .is_some_and(|entry| entry.generation == self.generation);
572 if remove {
573 broadcasts.remove(&self.path)
574 } else {
575 None
576 }
577 };
578 drop(removed);
582 }
583}
584
585impl MoqStreamOrigin {
586 pub fn builder(producer: OriginProducer, consumer: OriginConsumer) -> MoqStreamOriginBuilder {
589 MoqStreamOriginBuilder {
590 producer,
591 consumer,
592 prefix: DEFAULT_PREFIX.to_owned(),
593 authorize_signer: None,
594 }
595 }
596
597 pub fn from_pair(producer: OriginProducer, consumer: OriginConsumer) -> Self {
599 Self::builder(producer, consumer).build()
600 }
601
602 pub fn standalone() -> MoqStreamOriginBuilder {
609 let producer = moq_net::Origin::random().produce();
610 let consumer = producer.consume();
611 Self::builder(producer, consumer)
612 }
613
614 pub fn consumer(&self) -> &OriginConsumer {
616 &self.inner.consumer
617 }
618
619 pub fn producer(&self) -> &OriginProducer {
621 &self.inner.producer
622 }
623
624 pub fn authorize_signer(&self, signer: &[u8; 32]) -> bool {
628 match &self.inner.authorize_signer {
629 Some(f) => f(signer),
630 None => true,
631 }
632 }
633
634 pub fn broadcast_path(&self, topic: &str) -> String {
636 format!("{}/{}", self.inner.prefix, topic)
637 }
638
639 pub fn publisher(&self, ctx: &StreamContext) -> Result<MoqStreamPublisher> {
646 self.publisher_with_provenance(ctx, None)
647 }
648
649 pub fn publisher_with_provenance(
656 &self,
657 ctx: &StreamContext,
658 provenance: Option<crate::stream_provenance::ProvenanceSigner>,
659 ) -> Result<MoqStreamPublisher> {
660 ensure!(
661 !ctx.has_epoch_ratchet() || ctx.enc_key().is_some(),
662 "identified stream rejected a context with transport AEAD disabled"
663 );
664 ctx.with_publisher_epoch_ratchet(|epoch_ratchet| {
670 let path = self.broadcast_path(ctx.topic());
671 let (broadcast, track) = publish_stream_broadcast(&path, |path, broadcast| {
672 self.inner.producer.publish_broadcast(path, broadcast)
673 })?;
674
675 let generation = self
676 .inner
677 .next_broadcast_generation
678 .fetch_add(1, Ordering::Relaxed);
679
680 let replaced = self.inner.broadcasts.lock().insert(
685 path.clone(),
686 BroadcastEntry {
687 _producer: broadcast,
688 generation,
689 },
690 );
691 drop(replaced);
694
695 Ok(MoqStreamPublisher {
696 hmac_state: StreamHmacState::new(*ctx.mac_key(), ctx.topic().to_owned()),
697 enc_key: ctx.enc_key().copied(),
701 provenance,
702 track,
703 next_group: 0,
704 next_sequence: 0,
705 epoch_ratchet: epoch_ratchet.take(),
706 cancel_token: ctx.cancel_token().clone(),
707 terminated: false,
708 topic: ctx.topic().to_owned(),
709 _broadcast_cleanup: BroadcastCleanup {
710 origin: Arc::downgrade(&self.inner),
711 path,
712 generation,
713 },
714 })
715 })
716 }
717}
718
719fn publish_stream_broadcast(
722 path: &str,
723 announce: impl FnOnce(&str, BroadcastConsumer) -> bool,
724) -> Result<(BroadcastProducer, TrackProducer)> {
725 let mut broadcast = Broadcast::new().produce();
726 let track = broadcast.create_track(Track::new(STREAM_TRACK))?;
727 ensure!(
728 announce(path, broadcast.consume()),
729 "create_broadcast denied for {path}"
730 );
731 Ok((broadcast, track))
732}
733
734pub struct MoqStreamPublisher {
747 hmac_state: StreamHmacState,
748 enc_key: Option<[u8; 32]>,
752 provenance: Option<crate::stream_provenance::ProvenanceSigner>,
755 track: TrackProducer,
756 next_group: u64,
758 next_sequence: u64,
760 epoch_ratchet: Option<crate::stream_epoch::StreamEpochRatchet>,
762 cancel_token: CancellationToken,
763 terminated: bool,
764 topic: String,
765 _broadcast_cleanup: BroadcastCleanup,
766}
767
768impl MoqStreamPublisher {
769 pub async fn wait_for_consumer(&self) -> Result<()> {
773 if self.cancel_token.is_cancelled() {
774 anyhow::bail!("stream cancelled before consumer demand");
775 }
776 tokio::select! {
777 _ = self.cancel_token.cancelled() => {
778 anyhow::bail!("stream cancelled before consumer demand");
779 }
780 result = self.track.used() => {
781 result.map_err(|error| anyhow!("stream consumer demand failed: {error}"))
782 }
783 }
784 }
785
786 pub fn publish_next_epoch(&mut self) -> Result<u64> {
791 let ratchet = self
792 .epoch_ratchet
793 .as_ref()
794 .ok_or_else(|| anyhow!("stream is not using the identified epoch profile"))?;
795 let commit = ratchet.prepare_next()?;
796 let mut pending = ratchet.clone();
797 let keys = pending.commit_prepared(&commit)?;
798
799 self.write_block(&[StreamPayloadData::EpochCommit(commit)])?;
802
803 self.hmac_state =
804 StreamHmacState::new(*keys.producer_to_consumer.mac_key, self.topic.clone());
805 self.enc_key = Some(*keys.producer_to_consumer.enc_key);
806 self.next_sequence = 0;
807 self.epoch_ratchet = Some(pending);
808 Ok(keys.epoch)
809 }
810
811 pub async fn publish_data(&mut self, data: &[u8]) -> Result<()> {
813 if self.cancel_token.is_cancelled() {
814 anyhow::bail!("stream cancelled");
815 }
816 self.write_block(&[StreamPayloadData::Data(data.to_vec())])
817 }
818
819 pub async fn publish_error(&mut self, message: &str) -> Result<()> {
821 self.write_block(&[StreamPayloadData::Error(message.to_owned())])?;
822 self.track.finish()?;
823 self.terminated = true;
824 Ok(())
825 }
826
827 pub async fn complete(mut self, metadata: &[u8]) -> Result<()> {
829 self.complete_ref(metadata).await
830 }
831
832 pub async fn complete_ref(&mut self, metadata: &[u8]) -> Result<()> {
834 self.write_block(&[StreamPayloadData::Complete(metadata.to_vec())])?;
835 self.track.finish()?;
836 self.terminated = true;
837 Ok(())
838 }
839
840 pub fn topic(&self) -> &str {
842 &self.topic
843 }
844
845 pub fn is_terminated(&self) -> bool {
847 self.terminated
848 }
849
850 pub fn is_cancelled(&self) -> bool {
852 self.cancel_token.is_cancelled()
853 }
854
855 fn write_block(&mut self, payloads: &[StreamPayloadData]) -> Result<()> {
858 let sequence_number = self.next_sequence;
861 let epoch = self
862 .epoch_ratchet
863 .as_ref()
864 .map_or(0, StreamEpochRatchet::epoch);
865 let is_epoch_control = matches!(payloads, [StreamPayloadData::EpochCommit(_)]);
866 if is_epoch_control && self.enc_key.is_none() {
867 anyhow::bail!("identified stream epoch control cannot be serialized without AEAD");
868 }
869 if let Some(state) = &self.epoch_ratchet {
870 ensure!(
871 !payloads
872 .iter()
873 .any(|payload| matches!(payload, StreamPayloadData::Tagged { .. })),
874 "identified stream rejected pre-tagged payload bypass"
875 );
876 let limit = state.binding().max_blocks_per_epoch();
877 if sequence_number > limit || (sequence_number == limit && !is_epoch_control) {
878 anyhow::bail!(
879 "identified stream epoch {epoch} exhausted after {} blocks; authenticated rekey required",
880 state.binding().max_blocks_per_epoch()
881 );
882 }
883 }
884 let group_id = self.next_group;
885 let next_group = self
886 .next_group
887 .checked_add(1)
888 .ok_or_else(|| anyhow!("stream Group identity exhausted"))?;
889 let next_sequence = self
890 .next_sequence
891 .checked_add(1)
892 .ok_or_else(|| anyhow!("stream sequence exhausted"))?;
893
894 let sealed: Vec<StreamPayloadData>;
900 let payloads: &[StreamPayloadData] = match self.enc_key {
901 Some(ref enc_key) => {
902 let epoch_keys = self
903 .epoch_ratchet
904 .as_ref()
905 .map(crate::stream_epoch::StreamEpochRatchet::current_keys);
906 sealed = payloads
907 .iter()
908 .enumerate()
909 .map(|(index, p)| {
910 let nonce = epoch_keys
911 .as_ref()
912 .map(|keys| {
913 let counter = sequence_number
917 .checked_mul(1 << 16)
918 .and_then(|value| value.checked_add(index as u64))
919 .ok_or_else(|| {
920 anyhow!("stream payload nonce counter exhausted")
921 })?;
922 Ok::<[u8; 12], anyhow::Error>(
923 keys.producer_to_consumer.nonce(counter),
924 )
925 })
926 .transpose()?;
927 seal_payload(
928 enc_key,
929 &self.topic,
930 epoch,
931 sequence_number,
932 index,
933 nonce,
934 p,
935 )
936 })
937 .collect::<Result<Vec<_>>>()?;
938 &sealed
939 }
940 None => payloads,
941 };
942
943 let signed_region = crate::streaming::encode_stream_block(
947 self.hmac_state.prev_mac_bytes(),
948 sequence_number,
949 epoch,
950 payloads,
951 )?;
952
953 let capnp_bytes = match self.provenance {
958 Some(ref signer) => {
959 let (signer_kid, sig) = signer.sign(&signed_region)?;
960 crate::streaming::encode_stream_block_with_provenance(
961 self.hmac_state.prev_mac_bytes(),
962 sequence_number,
963 epoch,
964 payloads,
965 Some((&signer_kid, &sig)),
966 )?
967 }
968 None => signed_region,
969 };
970 let mut pending_hmac_state = self.hmac_state.clone();
971 let mac = pending_hmac_state.compute_next(&capnp_bytes);
972
973 let mut frame = Vec::with_capacity(capnp_bytes.len() + 16);
974 frame.extend_from_slice(&capnp_bytes);
975 frame.extend_from_slice(&mac);
976
977 let mut group = self.track.create_group(Group::from(group_id))?;
978 group.write_frame(Bytes::from(frame))?;
979 group.finish()?;
980
981 self.hmac_state = pending_hmac_state;
985 self.next_group = next_group;
986 self.next_sequence = next_sequence;
987 Ok(())
988 }
989}
990
991pub type AnyStreamPublisher = MoqStreamPublisher;
1001
1002impl MoqStreamPublisher {
1003 pub async fn publish_data_with_rate(&mut self, data: &[u8], rate: f32) -> Result<()> {
1005 let _ = rate;
1006 self.publish_data(data).await
1007 }
1008
1009 pub async fn publish_progress(
1011 &mut self,
1012 stage: &str,
1013 current: usize,
1014 total: usize,
1015 ) -> Result<()> {
1016 let data = format!("{}:{}:{}", stage, current, total);
1017 self.publish_data(data.as_bytes()).await
1018 }
1019
1020 pub async fn flush(&mut self) -> Result<()> {
1022 Ok(())
1023 }
1024
1025 pub async fn try_publish_data(&mut self, data: &[u8], rate: f32) -> Result<bool> {
1028 let _ = rate;
1029 self.publish_data(data).await.map(|_| true)
1030 }
1031}
1032
1033pub struct MoqStreamHandle {
1041 rx: tokio::sync::mpsc::Receiver<anyhow::Result<crate::streaming::StreamPayload>>,
1042 broadcast_path: String,
1043 cancel: tokio_util::sync::CancellationToken,
1044}
1045
1046impl MoqStreamHandle {
1047 pub fn new(
1054 uds_path: String,
1055 broadcast_path: String,
1056 mac_key: [u8; 32],
1057 enc_key: [u8; 32],
1058 topic: String,
1059 ) -> Self {
1060 let cancel = tokio_util::sync::CancellationToken::new();
1061 let (tx, rx) =
1062 tokio::sync::mpsc::channel::<anyhow::Result<crate::streaming::StreamPayload>>(64);
1063 tokio::spawn(moq_stream_handle_task(
1064 uds_path,
1065 broadcast_path.clone(),
1066 mac_key,
1067 enc_key,
1068 topic,
1069 None,
1070 tx,
1071 cancel.clone(),
1072 ));
1073 Self {
1074 rx,
1075 broadcast_path,
1076 cancel,
1077 }
1078 }
1079
1080 pub fn identified(
1083 uds_path: String,
1084 broadcast_path: String,
1085 ratchet: crate::stream_epoch::StreamEpochRatchet,
1086 ) -> Self {
1087 let keys = ratchet.current_keys();
1088 let topic = ratchet.route_topic().to_owned();
1089 let cancel = tokio_util::sync::CancellationToken::new();
1090 let (tx, rx) =
1091 tokio::sync::mpsc::channel::<anyhow::Result<crate::streaming::StreamPayload>>(64);
1092 tokio::spawn(moq_stream_handle_task(
1093 uds_path,
1094 broadcast_path.clone(),
1095 *keys.producer_to_consumer.mac_key,
1096 *keys.producer_to_consumer.enc_key,
1097 topic,
1098 Some(ratchet),
1099 tx,
1100 cancel.clone(),
1101 ));
1102 Self {
1103 rx,
1104 broadcast_path,
1105 cancel,
1106 }
1107 }
1108
1109 pub fn networked(
1146 reach: Vec<crate::stream_info::Destination>,
1147 qos: &crate::stream_info::StreamOpt,
1148 broadcast_path: String,
1149 mac_key: [u8; 32],
1150 enc_key: [u8; 32],
1151 topic: String,
1152 server_identity: crate::stream_info::MoqlServerIdentity,
1153 ) -> Self {
1154 Self::networked_with_server_identity(
1155 reach,
1156 qos,
1157 broadcast_path,
1158 mac_key,
1159 enc_key,
1160 topic,
1161 server_identity,
1162 )
1163 }
1164
1165 pub fn networked_with_server_identity(
1168 reach: Vec<crate::stream_info::Destination>,
1169 qos: &crate::stream_info::StreamOpt,
1170 broadcast_path: String,
1171 mac_key: [u8; 32],
1172 enc_key: [u8; 32],
1173 topic: String,
1174 server_identity: crate::stream_info::MoqlServerIdentity,
1175 ) -> Self {
1176 let reach = select_reach(&reach, qos);
1179 let cancel = tokio_util::sync::CancellationToken::new();
1180 let (tx, rx) =
1181 tokio::sync::mpsc::channel::<anyhow::Result<crate::streaming::StreamPayload>>(64);
1182 let has_dialable_reach = reach.iter().any(|d| reach_to_transport_config(d).is_some());
1187 if has_dialable_reach || native_iroh_required() {
1188 tokio::spawn(moq_stream_handle_task_networked(
1189 reach,
1190 broadcast_path.clone(),
1191 mac_key,
1192 enc_key,
1193 topic,
1194 None,
1195 server_identity,
1196 tx,
1197 cancel.clone(),
1198 ));
1199 } else if let Some(uds) = global_moq_uds_path() {
1200 let uds_path = uds.to_string_lossy().into_owned();
1201 tokio::spawn(moq_stream_handle_task(
1202 uds_path,
1203 broadcast_path.clone(),
1204 mac_key,
1205 enc_key,
1206 topic,
1207 None,
1208 tx,
1209 cancel.clone(),
1210 ));
1211 } else {
1212 tokio::spawn(async move {
1215 let _ = tx
1216 .send(Err(anyhow!(
1217 "no dialable reach in StreamInfo and no local moq UDS plane — \
1218 cannot subscribe to broadcast"
1219 )))
1220 .await;
1221 });
1222 }
1223 Self {
1224 rx,
1225 broadcast_path,
1226 cancel,
1227 }
1228 }
1229
1230 pub fn networked_identified(
1235 reach: Vec<crate::stream_info::Destination>,
1236 qos: &crate::stream_info::StreamOpt,
1237 broadcast_path: String,
1238 ratchet: crate::stream_epoch::StreamEpochRatchet,
1239 server_identity: crate::stream_info::MoqlServerIdentity,
1240 ) -> Self {
1241 let reach = select_reach(&reach, qos);
1242 let keys = ratchet.current_keys();
1243 let mac_key = *keys.producer_to_consumer.mac_key;
1244 let enc_key = *keys.producer_to_consumer.enc_key;
1245 let topic = ratchet.route_topic().to_owned();
1246 let cancel = tokio_util::sync::CancellationToken::new();
1247 let (tx, rx) =
1248 tokio::sync::mpsc::channel::<anyhow::Result<crate::streaming::StreamPayload>>(64);
1249 let has_dialable_reach = reach.iter().any(|d| reach_to_transport_config(d).is_some());
1250 if has_dialable_reach || native_iroh_required() {
1251 tokio::spawn(moq_stream_handle_task_networked(
1252 reach,
1253 broadcast_path.clone(),
1254 mac_key,
1255 enc_key,
1256 topic,
1257 Some(ratchet),
1258 server_identity,
1259 tx,
1260 cancel.clone(),
1261 ));
1262 } else if let Some(uds) = global_moq_uds_path() {
1263 tokio::spawn(moq_stream_handle_task(
1264 uds.to_string_lossy().into_owned(),
1265 broadcast_path.clone(),
1266 mac_key,
1267 enc_key,
1268 topic,
1269 Some(ratchet),
1270 tx,
1271 cancel.clone(),
1272 ));
1273 } else {
1274 tokio::spawn(async move {
1275 let _ = tx
1276 .send(Err(anyhow!(
1277 "no dialable reach in StreamInfo and no local moq UDS plane — \
1278 cannot subscribe to identified broadcast"
1279 )))
1280 .await;
1281 });
1282 }
1283 Self {
1284 rx,
1285 broadcast_path,
1286 cancel,
1287 }
1288 }
1289
1290 pub async fn recv_next(&mut self) -> anyhow::Result<Option<crate::streaming::StreamPayload>> {
1294 match self.rx.recv().await {
1295 Some(Ok(p)) => Ok(Some(p)),
1296 Some(Err(e)) => Err(e),
1297 None => Ok(None),
1298 }
1299 }
1300
1301 pub fn stream_id(&self) -> &str {
1303 &self.broadcast_path
1304 }
1305
1306 pub fn cancel_token(&self) -> &tokio_util::sync::CancellationToken {
1308 &self.cancel
1309 }
1310
1311 pub fn cancel(&self) {
1313 self.cancel.cancel();
1314 }
1315}
1316
1317impl futures::Stream for MoqStreamHandle {
1318 type Item = anyhow::Result<crate::streaming::StreamPayload>;
1319
1320 fn poll_next(
1321 mut self: std::pin::Pin<&mut Self>,
1322 cx: &mut std::task::Context<'_>,
1323 ) -> std::task::Poll<Option<Self::Item>> {
1324 self.rx.poll_recv(cx)
1325 }
1326}
1327
1328#[allow(clippy::too_many_arguments)]
1330async fn moq_stream_handle_task(
1331 uds_path: String,
1332 broadcast_path: String,
1333 mac_key: [u8; 32],
1334 enc_key: [u8; 32],
1335 topic: String,
1336 epoch_ratchet: Option<crate::stream_epoch::StreamEpochRatchet>,
1337 tx: tokio::sync::mpsc::Sender<anyhow::Result<crate::streaming::StreamPayload>>,
1338 cancel: tokio_util::sync::CancellationToken,
1339) {
1340 use crate::streaming::StreamVerifier;
1341 use crate::transport::uds_session::{connect_uds, PLANE_MOQ};
1342 use moq_net::{Client as MoqClient, Origin, Track};
1343
1344 if native_iroh_required() {
1345 let _ = tx
1346 .send(Err(anyhow!(
1347 "network-iroh-required refuses a local MoQ socket client"
1348 )))
1349 .await;
1350 return;
1351 }
1352 let session = match connect_uds(&uds_path, PLANE_MOQ).await {
1353 Ok(s) => s,
1354 Err(e) => {
1355 let _ = tx
1356 .send(Err(anyhow!("moq UDS connect {uds_path}: {e}")))
1357 .await;
1358 return;
1359 }
1360 };
1361 let client_origin = Origin::random().produce();
1362 let client_consumer = client_origin.consume();
1363 let moq_client = MoqClient::new().with_consume(client_origin);
1364 let _session = match moq_client.connect(session).await {
1365 Ok(s) => s,
1366 Err(e) => {
1367 let _ = tx.send(Err(anyhow!("moq handshake: {e}"))).await;
1368 return;
1369 }
1370 };
1371 let bc = match tokio::time::timeout(
1372 BROADCAST_ANNOUNCE_TIMEOUT,
1373 client_consumer.announced_broadcast(&broadcast_path),
1374 )
1375 .await
1376 {
1377 Ok(Some(bc)) => bc,
1378 Ok(None) => {
1379 let _ = tx
1380 .send(Err(anyhow!("broadcast {broadcast_path} not announced")))
1381 .await;
1382 return;
1383 }
1384 Err(_) => {
1385 let _ = tx
1386 .send(Err(anyhow!(
1387 "timeout waiting for broadcast {broadcast_path}"
1388 )))
1389 .await;
1390 return;
1391 }
1392 };
1393 let track = match bc.subscribe_track(&Track::new(STREAM_TRACK)) {
1394 Ok(t) => t,
1395 Err(e) => {
1396 let _ = tx.send(Err(anyhow!("subscribe_track: {e}"))).await;
1397 return;
1398 }
1399 };
1400 let mut verifier = StreamVerifier::new(mac_key, topic.clone()).with_enc_key(enc_key);
1402 if let Some(ratchet) = epoch_ratchet {
1403 verifier = verifier.with_epoch_ratchet(ratchet);
1404 }
1405 let mut expected_seq = 0u64;
1413 loop {
1414 if cancel.is_cancelled() {
1415 break;
1416 }
1417 let mut group =
1418 match tokio::time::timeout(GROUP_IDLE_TIMEOUT, track.get_group(expected_seq)).await {
1419 Ok(Ok(Some(g))) => g,
1420 Ok(Ok(None)) => break, Err(_elapsed) => {
1422 let _ = tx
1423 .send(Err(anyhow!(
1424 "stream idle: no group for {}s",
1425 GROUP_IDLE_TIMEOUT.as_secs()
1426 )))
1427 .await;
1428 break;
1429 }
1430 Ok(Err(e)) => {
1431 let _ = tx.send(Err(anyhow!("moq next_group: {e}"))).await;
1432 break;
1433 }
1434 };
1435 expected_seq += 1;
1436 let frame: bytes::Bytes =
1437 match tokio::time::timeout(FRAME_READ_TIMEOUT, group.read_frame()).await {
1438 Ok(Ok(Some(f))) => f,
1439 Ok(Ok(None)) => break, Ok(Err(e)) => {
1441 let _ = tx.send(Err(anyhow!("frame read error: {e}"))).await;
1442 break;
1443 }
1444 Err(_elapsed) => {
1445 let _ = tx
1446 .send(Err(anyhow!(
1447 "frame read timeout after {}s",
1448 FRAME_READ_TIMEOUT.as_secs()
1449 )))
1450 .await;
1451 break;
1452 }
1453 };
1454 match verify_moq_frame(&mut verifier, &topic, &frame) {
1455 Ok(payloads) => {
1456 for p in payloads {
1457 let is_terminal = matches!(
1458 p,
1459 crate::streaming::StreamPayload::Complete(_)
1460 | crate::streaming::StreamPayload::Error(_)
1461 );
1462 if tx.send(Ok(p)).await.is_err() {
1463 return;
1464 }
1465 if is_terminal {
1466 return;
1467 }
1468 }
1469 }
1470 Err(e) => {
1471 let _ = tx.send(Err(e)).await;
1472 return;
1473 }
1474 }
1475 }
1476}
1477
1478pub fn reach_to_transport_config(
1484 reach: &crate::stream_info::Destination,
1485) -> Option<crate::transport::TransportConfig> {
1486 wire_transport_to_dial(&reach.transport)
1487}
1488
1489pub fn wire_transport_to_dial(
1496 wire: &crate::stream_info::TransportConfig,
1497) -> Option<crate::transport::TransportConfig> {
1498 use crate::stream_info::TransportConfig as ReachTransport;
1499 use crate::transport::{QuicServerAuth, TransportConfig};
1500 match wire {
1501 ReachTransport::Quic(q) => {
1502 let addr: std::net::SocketAddr = q.addr.parse().ok()?;
1503 let hashes: Vec<[u8; 32]> = q
1505 .cert_hashes
1506 .iter()
1507 .filter_map(|h| <[u8; 32]>::try_from(h.as_slice()).ok())
1508 .collect();
1509 let auth = if hashes.is_empty() {
1510 QuicServerAuth::web_pki()
1511 } else {
1512 QuicServerAuth::pinned(hashes).ok()?
1514 };
1515 Some(TransportConfig::quic_with_auth(
1516 addr,
1517 q.server_name.clone(),
1518 auth,
1519 ))
1520 }
1521 ReachTransport::Iroh(i) => {
1529 let relay_url = if i.relay_url.is_empty() {
1530 None
1531 } else {
1532 Some(i.relay_url.clone())
1533 };
1534 Some(TransportConfig::iroh(i.node_id, Vec::new(), relay_url))
1535 }
1536 }
1537}
1538
1539pub fn dial_transport_to_wire(
1549 dial: &crate::transport::TransportConfig,
1550) -> Option<crate::stream_info::TransportConfig> {
1551 use crate::stream_info::{IrohReach, QuicReach, TransportConfig as ReachTransport};
1552 use crate::transport::EndpointType;
1553 match &dial.endpoint {
1554 EndpointType::Quic {
1555 addr,
1556 server_name,
1557 auth,
1558 } => Some(ReachTransport::Quic(QuicReach {
1559 addr: addr.to_string(),
1560 server_name: server_name.clone(),
1561 cert_hashes: auth
1562 .accept_cert_hashes()
1563 .iter()
1564 .map(|h| h.to_vec())
1565 .collect(),
1566 })),
1567 EndpointType::Iroh {
1571 node_id, relay_url, ..
1572 } => Some(ReachTransport::Iroh(IrohReach {
1573 node_id: *node_id,
1574 alpn: String::from_utf8_lossy(crate::transport::iroh_substrate::ALPN_HYPRSTREAM_RPC)
1575 .into_owned(),
1576 relay_url: relay_url.clone().unwrap_or_default(),
1577 })),
1578 EndpointType::Inproc { .. } | EndpointType::Ipc { .. } | EndpointType::SystemdFd { .. } => {
1580 None
1581 }
1582 }
1583}
1584
1585pub struct MoqReachConnection {
1591 pub consumer: OriginConsumer,
1594 _session: moq_net::Session,
1597}
1598
1599static NATIVE_IROH_REQUIRED: std::sync::atomic::AtomicBool =
1601 std::sync::atomic::AtomicBool::new(false);
1602
1603pub fn require_native_iroh() {
1605 NATIVE_IROH_REQUIRED.store(true, std::sync::atomic::Ordering::Release);
1606}
1607
1608pub fn native_iroh_required() -> bool {
1609 NATIVE_IROH_REQUIRED.load(std::sync::atomic::Ordering::Acquire)
1610}
1611
1612pub async fn connect_moq_reach(
1637 reach: &[crate::stream_info::Destination],
1638) -> Result<MoqReachConnection> {
1639 connect_moq_reach_with_server_identity(
1640 reach,
1641 &crate::stream_info::MoqlServerIdentity::default(),
1642 )
1643 .await
1644}
1645
1646pub async fn connect_moq_reach_with_server_identity(
1649 reach: &[crate::stream_info::Destination],
1650 server_identity: &crate::stream_info::MoqlServerIdentity,
1651) -> Result<MoqReachConnection> {
1652 connect_moq_reach_for_profile(reach, server_identity, native_iroh_required()).await
1653}
1654
1655pub async fn connect_moq_reach_for_profile(
1657 reach: &[crate::stream_info::Destination],
1658 server_identity: &crate::stream_info::MoqlServerIdentity,
1659 iroh_required: bool,
1660) -> Result<MoqReachConnection> {
1661 use crate::transport::uds_session::{connect_uds, PLANE_MOQ};
1662 use moq_net::{Client as MoqClient, Origin};
1663
1664 let iroh_required = iroh_required || native_iroh_required();
1665 let client_origin = Origin::random().produce();
1666 let consumer = client_origin.consume();
1667 let moq_client = MoqClient::new().with_consume(client_origin);
1668
1669 let mut last_err: Option<String> = None;
1671 let mut had_dialable_network_reach = false;
1672 for dest in reach {
1673 let Some(cfg) = reach_to_transport_config(dest) else {
1674 continue;
1675 };
1676 if iroh_required && !matches!(cfg.endpoint, crate::transport::EndpointType::Iroh { .. }) {
1677 continue;
1678 }
1679 had_dialable_network_reach = true;
1680 let dial = match (&cfg.endpoint, global_moq_admission_proof()) {
1681 (crate::transport::EndpointType::Iroh { .. }, Some(proof)) => {
1682 let expected_server = match destination_server_identity(dest, server_identity) {
1688 Ok(identity) => identity,
1689 Err(error) => {
1690 last_err = Some(error.to_string());
1691 continue;
1692 }
1693 };
1694 match expected_server {
1695 None => Err(anyhow!(
1696 "iroh moql reach lacks a live resolver-verified server witness"
1697 )),
1698 Some(expected_server) => {
1699 let mut proof = proof.clone();
1704 proof.expected_server = expected_server.clone();
1705 crate::dial::dial_stream_authenticated(&cfg, &proof).await
1706 }
1707 }
1708 }
1709 (crate::transport::EndpointType::Iroh { .. }, None) => Err(anyhow::anyhow!(
1710 "iroh moql reach requires an accepted-state admission proof"
1711 )),
1712 _ => crate::dial::dial_stream(&cfg).await,
1713 };
1714 match dial {
1715 Ok(stream_session) => match stream_session.connect_moq(&moq_client).await {
1716 Ok(session) => {
1717 return Ok(MoqReachConnection {
1718 consumer,
1719 _session: session,
1720 });
1721 }
1722 Err(e) => last_err = Some(format!("moq handshake: {e}")),
1723 },
1724 Err(e) => last_err = Some(e.to_string()),
1725 }
1726 }
1727
1728 if iroh_required && !had_dialable_network_reach {
1732 return Err(anyhow!(
1733 "network-iroh-required: no dialable Iroh stream reach; refusing QUIC/local fallback"
1734 ));
1735 }
1736 if had_dialable_network_reach {
1737 return Err(anyhow!(
1738 "all dialable network reaches failed; refusing local moq UDS fallback{}",
1739 last_err
1740 .map(|e| format!(" (last dial error: {e})"))
1741 .unwrap_or_default()
1742 ));
1743 }
1744
1745 if let Some(uds) = global_moq_uds_path() {
1747 let session = connect_uds(uds, PLANE_MOQ)
1748 .await
1749 .with_context(|| format!("moq UDS connect {}", uds.display()))?;
1750 let session = moq_client
1751 .connect(session)
1752 .await
1753 .map_err(|e| anyhow!("moq UDS handshake: {e}"))?;
1754 return Ok(MoqReachConnection {
1755 consumer,
1756 _session: session,
1757 });
1758 }
1759
1760 Err(anyhow!(
1762 "no dialable reach in StreamInfo and no local moq UDS plane — cannot subscribe to broadcast{}",
1763 last_err
1764 .map(|e| format!(" (last dial error: {e})"))
1765 .unwrap_or_default()
1766 ))
1767}
1768
1769fn destination_server_identity<'a>(
1774 destination: &'a crate::stream_info::Destination,
1775 enclosing: &'a crate::stream_info::MoqlServerIdentity,
1776) -> Result<Option<&'a crate::stream_info::MoqlServerIdentity>> {
1777 if destination_identity_is_live(&destination.moql_server_identity) {
1778 return Ok(Some(&destination.moql_server_identity));
1779 }
1780 if destination.role == crate::stream_info::Role::Relay {
1781 anyhow::bail!("relay moql reach lacks a live resolver-verified relay witness");
1782 }
1783 Ok(destination_identity_is_live(enclosing).then_some(enclosing))
1784}
1785
1786fn destination_identity_is_live(identity: &crate::stream_info::MoqlServerIdentity) -> bool {
1787 !identity.did.is_empty()
1788 && identity.epoch != 0
1789 && identity.head_digest.len() == 64
1790 && identity.ed25519.len() == 32
1791 && !identity.ml_dsa65.is_empty()
1792 && identity.expires_at_unix_ms > crate::envelope::current_timestamp()
1793}
1794
1795pub fn select_reach(
1827 advertised: &[crate::stream_info::Destination],
1828 qos: &crate::stream_info::StreamOpt,
1829) -> Vec<crate::stream_info::Destination> {
1830 use crate::stream_info::{Retention, Role};
1831 let relay_first = !matches!(qos.retention, Retention::Live);
1832 let mut ordered: Vec<crate::stream_info::Destination> = Vec::with_capacity(advertised.len());
1833 let prefer = if relay_first {
1835 Role::Relay
1836 } else {
1837 Role::Direct
1838 };
1839 ordered.extend(advertised.iter().filter(|d| d.role == prefer).cloned());
1840 ordered.extend(advertised.iter().filter(|d| d.role != prefer).cloned());
1841 ordered
1842}
1843
1844pub async fn connect_moq_reach_for_qos(
1853 reach: &[crate::stream_info::Destination],
1854 qos: &crate::stream_info::StreamOpt,
1855) -> Result<MoqReachConnection> {
1856 let ordered = select_reach(reach, qos);
1857 connect_moq_reach(&ordered).await
1858}
1859
1860const RELAY_RECONNECT_BASE: std::time::Duration = std::time::Duration::from_millis(500);
1878const RELAY_RECONNECT_MAX: std::time::Duration = std::time::Duration::from_secs(30);
1880const RELAY_RECONNECT_WARN_AFTER: u32 = 5;
1883
1884fn assert_relay_path_pinned(cfg: &crate::transport::TransportConfig) -> Result<()> {
1917 use crate::transport::EndpointType;
1918 match &cfg.endpoint {
1919 EndpointType::Iroh { .. } => Ok(()),
1921 EndpointType::Quic { auth, .. } => {
1923 if auth.accept_cert_hashes().is_empty() {
1924 Err(anyhow!(
1925 "relay endpoint is WebPKI-only (no leaf-cert pin): cannot confirm it is the \
1926 configured relay target — refusing to announce origin UP (fail-closed, #504)"
1927 ))
1928 } else {
1929 Ok(())
1930 }
1931 }
1932 other => Err(anyhow!(
1933 "relay endpoint {other:?} carries no network target pin — \
1934 refusing to announce origin UP (fail-closed, #504)"
1935 )),
1936 }
1937}
1938
1939pub fn serve_origin_to_relay_background(
1951 producer: OriginProducer,
1952 relay: crate::stream_info::TransportConfig,
1953 admission_proof: Option<crate::transport::moql_admission::MoqlAdmissionProof>,
1954 relay_server_identity: Option<crate::stream_info::MoqlServerIdentity>,
1955) {
1956 tokio::spawn(async move {
1957 let mut failures: u32 = 0;
1958 loop {
1959 match run_relay_announce_link(
1960 &producer,
1961 &relay,
1962 admission_proof.as_ref(),
1963 relay_server_identity.as_ref(),
1964 )
1965 .await
1966 {
1967 Ok(()) => failures = 0,
1969 Err(e) => {
1970 failures = failures.saturating_add(1);
1971 if failures >= RELAY_RECONNECT_WARN_AFTER {
1972 tracing::warn!(
1973 failures,
1974 "moq relay announce link failing repeatedly: {e}; relay may be unreachable"
1975 );
1976 } else {
1977 tracing::debug!("moq relay announce link ended: {e}; reconnecting");
1978 }
1979 }
1980 }
1981 let shift = failures.min(6); let backoff = RELAY_RECONNECT_BASE
1987 .checked_mul(1u32 << shift)
1988 .unwrap_or(RELAY_RECONNECT_MAX)
1989 .min(RELAY_RECONNECT_MAX);
1990 let half = backoff / 2;
1991 let jitter = if half.is_zero() {
1992 std::time::Duration::ZERO
1993 } else {
1994 std::time::Duration::from_nanos(rand::random::<u64>() % half.as_nanos() as u64)
1995 };
1996 tokio::time::sleep(half + jitter).await;
1997 }
1998 });
1999}
2000
2001pub async fn run_relay_announce_link(
2013 producer: &OriginProducer,
2014 relay: &crate::stream_info::TransportConfig,
2015 admission_proof: Option<&crate::transport::moql_admission::MoqlAdmissionProof>,
2016 relay_server_identity: Option<&crate::stream_info::MoqlServerIdentity>,
2017) -> Result<()> {
2018 use moq_net::Client as MoqClient;
2019
2020 let dest = crate::stream_info::Destination {
2023 role: crate::stream_info::Role::Relay,
2024 transport: relay.clone(),
2025 moql_server_identity: relay_server_identity.cloned().unwrap_or_default(),
2026 };
2027 let cfg = reach_to_transport_config(&dest)
2028 .ok_or_else(|| anyhow!("relay reach is not a dialable network transport"))?;
2029
2030 if native_iroh_required()
2031 && !matches!(cfg.endpoint, crate::transport::EndpointType::Iroh { .. })
2032 {
2033 return Err(anyhow!(
2034 "network-iroh-required rejects non-Iroh stream relay"
2035 ));
2036 }
2037
2038 if let Err(e) = assert_relay_path_pinned(&cfg) {
2047 tracing::warn!("moq relay announce gate: {e}");
2048 return Err(e);
2049 }
2050
2051 let stream_session = match (&cfg.endpoint, admission_proof, relay_server_identity) {
2052 (crate::transport::EndpointType::Iroh { .. }, Some(proof), Some(expected_server))
2053 if destination_identity_is_live(expected_server) =>
2054 {
2055 let mut proof = proof.clone();
2056 proof.expected_server = expected_server.clone();
2059 crate::dial::dial_stream_authenticated(&cfg, &proof).await?
2060 }
2061 (crate::transport::EndpointType::Iroh { .. }, Some(_), Some(_)) => {
2062 anyhow::bail!("iroh moql relay lacks a live resolver-verified relay witness")
2063 }
2064 (crate::transport::EndpointType::Iroh { .. }, Some(_), None) => {
2065 anyhow::bail!("iroh moql relay requires a resolver-verified relay witness")
2066 }
2067 (crate::transport::EndpointType::Iroh { .. }, None, _) => {
2068 anyhow::bail!("iroh moql relay requires an accepted-state admission proof")
2069 }
2070 _ => crate::dial::dial_stream(&cfg).await?,
2071 };
2072 let moq_client = MoqClient::new().with_origin(producer.clone());
2075 let moq_session = stream_session
2076 .connect_moq(&moq_client)
2077 .await
2078 .map_err(|e| anyhow!("relay moq handshake: {e}"))?;
2079
2080 tracing::info!("moq relay announce link established");
2081 let reason = moq_session.closed().await;
2082 Err(anyhow!("moq relay session closed: {reason:?}"))
2083}
2084
2085#[allow(clippy::too_many_arguments)]
2089async fn moq_stream_handle_task_networked(
2090 reach: Vec<crate::stream_info::Destination>,
2091 broadcast_path: String,
2092 mac_key: [u8; 32],
2093 enc_key: [u8; 32],
2094 topic: String,
2095 epoch_ratchet: Option<crate::stream_epoch::StreamEpochRatchet>,
2096 server_identity: crate::stream_info::MoqlServerIdentity,
2097 tx: tokio::sync::mpsc::Sender<anyhow::Result<crate::streaming::StreamPayload>>,
2098 cancel: tokio_util::sync::CancellationToken,
2099) {
2100 use crate::streaming::StreamVerifier;
2101 use moq_net::Track;
2102
2103 let conn = match connect_moq_reach_with_server_identity(&reach, &server_identity).await {
2106 Ok(c) => c,
2107 Err(e) => {
2108 let _ = tx
2109 .send(Err(anyhow!("moq networked dial failed: {e}")))
2110 .await;
2111 return;
2112 }
2113 };
2114 let client_consumer = &conn.consumer;
2117 let bc = match tokio::time::timeout(
2118 BROADCAST_ANNOUNCE_TIMEOUT,
2119 client_consumer.announced_broadcast(&broadcast_path),
2120 )
2121 .await
2122 {
2123 Ok(Some(bc)) => bc,
2124 Ok(None) => {
2125 let _ = tx
2126 .send(Err(anyhow!("broadcast {broadcast_path} not announced")))
2127 .await;
2128 return;
2129 }
2130 Err(_) => {
2131 let _ = tx
2132 .send(Err(anyhow!(
2133 "timeout waiting for broadcast {broadcast_path}"
2134 )))
2135 .await;
2136 return;
2137 }
2138 };
2139 let track = match bc.subscribe_track(&Track::new(STREAM_TRACK)) {
2140 Ok(t) => t,
2141 Err(e) => {
2142 let _ = tx.send(Err(anyhow!("subscribe_track: {e}"))).await;
2143 return;
2144 }
2145 };
2146 let mut verifier = StreamVerifier::new(mac_key, topic.clone()).with_enc_key(enc_key);
2148 if let Some(ratchet) = epoch_ratchet {
2149 verifier = verifier.with_epoch_ratchet(ratchet);
2150 }
2151 let mut expected_seq = 0u64;
2159 loop {
2160 if cancel.is_cancelled() {
2161 break;
2162 }
2163 let mut group =
2164 match tokio::time::timeout(GROUP_IDLE_TIMEOUT, track.get_group(expected_seq)).await {
2165 Ok(Ok(Some(g))) => g,
2166 Ok(Ok(None)) => break,
2167 Err(_elapsed) => {
2168 let _ = tx
2169 .send(Err(anyhow!(
2170 "stream idle: no group for {}s",
2171 GROUP_IDLE_TIMEOUT.as_secs()
2172 )))
2173 .await;
2174 break;
2175 }
2176 Ok(Err(e)) => {
2177 let _ = tx.send(Err(anyhow!("moq next_group: {e}"))).await;
2178 break;
2179 }
2180 };
2181 expected_seq += 1;
2182 let frame: bytes::Bytes =
2183 match tokio::time::timeout(FRAME_READ_TIMEOUT, group.read_frame()).await {
2184 Ok(Ok(Some(f))) => f,
2185 Ok(Ok(None)) => break,
2186 Ok(Err(e)) => {
2187 let _ = tx.send(Err(anyhow!("frame read error: {e}"))).await;
2188 break;
2189 }
2190 Err(_elapsed) => {
2191 let _ = tx
2192 .send(Err(anyhow!(
2193 "frame read timeout after {}s",
2194 FRAME_READ_TIMEOUT.as_secs()
2195 )))
2196 .await;
2197 break;
2198 }
2199 };
2200 match verify_moq_frame(&mut verifier, &topic, &frame) {
2201 Ok(payloads) => {
2202 for p in payloads {
2203 let is_terminal = matches!(
2204 p,
2205 crate::streaming::StreamPayload::Complete(_)
2206 | crate::streaming::StreamPayload::Error(_)
2207 );
2208 if tx.send(Ok(p)).await.is_err() {
2209 return;
2210 }
2211 if is_terminal {
2212 return;
2213 }
2214 }
2215 }
2216 Err(e) => {
2217 let _ = tx.send(Err(e)).await;
2218 return;
2219 }
2220 }
2221 }
2222}
2223
2224pub fn verify_moq_frame(
2231 verifier: &mut StreamVerifier,
2232 topic: &str,
2233 frame: &[u8],
2234) -> Result<Vec<crate::streaming::StreamPayload>> {
2235 if frame.len() < 16 {
2236 anyhow::bail!("moq frame too short: {} bytes", frame.len());
2237 }
2238 let split = frame.len() - 16;
2239 verifier.verify_parts(topic.as_bytes(), &frame[..split], &frame[split..])
2242}
2243
2244pub fn verify_moq_frame_with_provenance(
2252 verifier: &mut StreamVerifier,
2253 topic: &str,
2254 frame: &[u8],
2255 roster: &dyn crate::envelope::PqTrustStore,
2256 is_enrolled: &dyn Fn(&[u8; 32]) -> bool,
2257) -> Result<Vec<crate::streaming::StreamPayload>> {
2258 if frame.len() < 16 {
2259 anyhow::bail!("moq frame too short: {} bytes", frame.len());
2260 }
2261 let split = frame.len() - 16;
2262 let capnp_data = &frame[..split];
2263
2264 let payloads = verifier.verify_parts(topic.as_bytes(), capnp_data, &frame[split..])?;
2266
2267 let mut slice: &[u8] = capnp_data;
2270 let reader = capnp::serialize::read_message_from_flat_slice(
2271 &mut slice,
2272 capnp::message::ReaderOptions::default(),
2273 )?;
2274 let block = reader.get_root::<crate::streaming_capnp::stream_block::Reader>()?;
2275 let prov = block.get_provenance()?;
2276 let signer_kid = prov.get_signer_kid()?;
2277 let sig = prov.get_sig()?;
2278 let signed_region = crate::stream_provenance::signed_region_from_block(&block)?;
2279 crate::stream_provenance::verify_provenance(
2280 signer_kid,
2281 sig,
2282 &signed_region,
2283 roster,
2284 is_enrolled,
2285 )?;
2286
2287 Ok(payloads)
2288}
2289
2290fn seal_payload(
2298 enc_key: &[u8; 32],
2299 topic: &str,
2300 epoch: u64,
2301 sequence_number: u64,
2302 payload_index: usize,
2303 nonce: Option<[u8; 12]>,
2304 payload: &StreamPayloadData,
2305) -> Result<StreamPayloadData> {
2306 use crate::crypto::event_crypto::{encrypt_event, encrypt_event_with_nonce, EventPrivacy};
2307 use crate::stream_consumer::{
2308 stream_aead_aad, SEALED_KIND_COMPLETE, SEALED_KIND_DATA, SEALED_KIND_EPOCH_COMMIT,
2309 SEALED_KIND_ERROR,
2310 };
2311
2312 let control_bytes = match payload {
2313 StreamPayloadData::EpochCommit(commit) => Some(commit.encode_control_object()),
2314 _ => None,
2315 };
2316 let (kind, body): (u8, &[u8]) = match payload {
2317 StreamPayloadData::Data(d) => (SEALED_KIND_DATA, d),
2318 StreamPayloadData::Complete(d) => (SEALED_KIND_COMPLETE, d),
2319 StreamPayloadData::Error(message) => (SEALED_KIND_ERROR, message.as_bytes()),
2320 StreamPayloadData::EpochCommit(_) => (
2321 SEALED_KIND_EPOCH_COMMIT,
2322 control_bytes
2323 .as_deref()
2324 .ok_or_else(|| anyhow!("stream epoch control encoding missing"))?,
2325 ),
2326 other => return Ok(other.clone()),
2328 };
2329
2330 let mut plaintext = Vec::with_capacity(1 + body.len());
2331 plaintext.push(kind);
2332 plaintext.extend_from_slice(body);
2333
2334 let aad = stream_aead_aad(topic, epoch, sequence_number, payload_index);
2335 let (tag, ciphertext, nonce, key_commitment) = match nonce {
2336 Some(nonce) => encrypt_event_with_nonce(enc_key, nonce, &aad, &plaintext),
2337 None => encrypt_event(enc_key, &aad, &plaintext, EventPrivacy::ZeroKnowledge),
2338 }
2339 .map_err(|e| anyhow!("stream AEAD seal failed: {e}"))?;
2340
2341 Ok(StreamPayloadData::Tagged {
2342 tag,
2343 payload: ciphertext,
2344 nonce: nonce.to_vec(),
2345 key_commitment: key_commitment.to_vec(),
2346 })
2347}
2348
2349#[cfg(test)]
2350#[allow(clippy::expect_used, clippy::unwrap_used)]
2351mod tests {
2352 use super::*;
2353 use crate::streaming::StreamPayload;
2354 use moq_net::Origin;
2355
2356 fn origin() -> MoqStreamOrigin {
2357 let producer = Origin::random().produce();
2358 let consumer = producer.consume();
2359 MoqStreamOrigin::from_pair(producer, consumer)
2360 }
2361
2362 #[tokio::test]
2365 async fn moq_stream_announcement_has_subscribable_track() -> Result<()> {
2366 use futures::FutureExt;
2367
2368 let origin = origin();
2369 let path = origin.broadcast_path("immediate-subscriber");
2370 let mut subscriber = None;
2371 let (_broadcast, track) = publish_stream_broadcast(&path, |path, broadcast| {
2372 assert!(origin.inner.producer.publish_broadcast(path, broadcast));
2373 let announced = origin
2374 .consumer()
2375 .announced_broadcast(path)
2376 .now_or_never()
2377 .expect("publication must be immediately visible")
2378 .expect("published broadcast must exist");
2379 subscriber = Some(
2380 announced
2381 .subscribe_track(&Track::new(STREAM_TRACK))
2382 .expect("announced stream track must already be subscribable"),
2383 );
2384 true
2385 })?;
2386 assert!(subscriber.is_some());
2387 track
2388 .used()
2389 .now_or_never()
2390 .expect("subscriber demand must be visible")?;
2391 Ok(())
2392 }
2393
2394 #[tokio::test]
2395 async fn moq_stream_announcement_denial_is_an_error() {
2396 let error = publish_stream_broadcast("denied/stream", |_, _| false)
2397 .err()
2398 .expect("denied announcement must not return a publisher");
2399 assert_eq!(
2400 error.to_string(),
2401 "create_broadcast denied for denied/stream"
2402 );
2403 }
2404
2405 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
2408 async fn moq_stream_round_trip() -> Result<()> {
2409 let origin = origin();
2410 let (_client_secret, client_pub) = crate::crypto::generate_ephemeral_keypair();
2411 let ctx = StreamContext::from_third_party_interop_dh(&client_pub.to_bytes())?;
2412 let topic = ctx.topic().to_owned();
2413 let mac_key = *ctx.mac_key();
2414 let enc_key = *ctx.enc_key().expect("DH ctx has enc_key");
2416
2417 let mut pub_ = origin.publisher(&ctx)?;
2418 pub_.publish_data(b"hello").await?;
2419 pub_.publish_data(b"world").await?;
2420 pub_.complete_ref(b"{}").await?;
2421
2422 let path = origin.broadcast_path(&topic);
2424 let bc = tokio::time::timeout(
2425 std::time::Duration::from_secs(5),
2426 origin.consumer().announced_broadcast(path.as_str()),
2427 )
2428 .await?
2429 .ok_or_else(|| anyhow!("broadcast not announced"))?;
2430 let mut track = bc.subscribe_track(&Track::new(STREAM_TRACK))?;
2431
2432 let mut verifier = StreamVerifier::new(mac_key, topic.clone()).with_enc_key(enc_key);
2433 let mut got: Vec<StreamPayload> = Vec::new();
2434 for _ in 0..3 {
2435 let mut group =
2436 tokio::time::timeout(std::time::Duration::from_secs(5), track.next_group())
2437 .await??
2438 .ok_or_else(|| anyhow!("next_group None"))?;
2439 let frame = tokio::time::timeout(std::time::Duration::from_secs(5), group.read_frame())
2440 .await??
2441 .ok_or_else(|| anyhow!("read_frame None"))?;
2442 got.extend(verify_moq_frame(&mut verifier, &topic, &frame)?);
2443 }
2444
2445 assert!(matches!(&got[0], StreamPayload::Data(d) if d == b"hello"));
2446 assert!(matches!(&got[1], StreamPayload::Data(d) if d == b"world"));
2447 assert!(matches!(&got[2], StreamPayload::Complete(_)));
2448 Ok(())
2449 }
2450
2451 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
2454 async fn moq_stream_complete_finishes_track_for_attached_consumer() -> Result<()> {
2455 let origin = origin();
2456 let (_client_secret, client_pub) = crate::crypto::generate_ephemeral_keypair();
2457 let ctx = StreamContext::from_third_party_interop_dh(&client_pub.to_bytes())?;
2458 let topic = ctx.topic().to_owned();
2459 let mac_key = *ctx.mac_key();
2460 let enc_key = *ctx.enc_key().expect("DH ctx has enc_key");
2461
2462 let mut publisher = origin.publisher(&ctx)?;
2463 let broadcast = origin
2464 .consumer()
2465 .announced_broadcast(origin.broadcast_path(&topic).as_str())
2466 .await
2467 .ok_or_else(|| anyhow!("consumer did not see completed broadcast"))?;
2468 let mut track = broadcast.subscribe_track(&Track::new(STREAM_TRACK))?;
2469 publisher.publish_data(b"late-data").await?;
2470 publisher.complete_ref(b"{}").await?;
2471 drop(publisher);
2472
2473 let mut verifier = StreamVerifier::new(mac_key, topic.clone()).with_enc_key(enc_key);
2474 let mut got = Vec::new();
2475 for _ in 0..2 {
2476 let mut group = track
2477 .next_group()
2478 .await?
2479 .ok_or_else(|| anyhow!("completed stream omitted a group"))?;
2480 let frame = group
2481 .read_frame()
2482 .await?
2483 .ok_or_else(|| anyhow!("completed stream group omitted a frame"))?;
2484 got.extend(verify_moq_frame(&mut verifier, &topic, &frame)?);
2485 }
2486 assert!(matches!(&got[0], StreamPayload::Data(data) if data == b"late-data"));
2487 assert!(matches!(&got[1], StreamPayload::Complete(_)));
2488 assert!(
2489 track.next_group().await?.is_none(),
2490 "completed track must EOF cleanly"
2491 );
2492 Ok(())
2493 }
2494
2495 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
2498 async fn moq_stream_error_finishes_track_for_attached_consumer() -> Result<()> {
2499 let origin = origin();
2500 let (_client_secret, client_pub) = crate::crypto::generate_ephemeral_keypair();
2501 let ctx = StreamContext::from_third_party_interop_dh(&client_pub.to_bytes())?;
2502 let topic = ctx.topic().to_owned();
2503 let mac_key = *ctx.mac_key();
2504 let enc_key = *ctx.enc_key().expect("DH ctx has enc_key");
2505
2506 let mut publisher = origin.publisher(&ctx)?;
2507 let broadcast = origin
2508 .consumer()
2509 .announced_broadcast(origin.broadcast_path(&topic).as_str())
2510 .await
2511 .ok_or_else(|| anyhow!("consumer did not see errored broadcast"))?;
2512 let mut track = broadcast.subscribe_track(&Track::new(STREAM_TRACK))?;
2513 publisher.publish_data(b"partial").await?;
2514 publisher.publish_error("expected failure").await?;
2515 drop(publisher);
2516
2517 let mut verifier = StreamVerifier::new(mac_key, topic.clone()).with_enc_key(enc_key);
2518 let mut got = Vec::new();
2519 for _ in 0..2 {
2520 let mut group = track
2521 .next_group()
2522 .await?
2523 .ok_or_else(|| anyhow!("errored stream omitted a group"))?;
2524 let frame = group
2525 .read_frame()
2526 .await?
2527 .ok_or_else(|| anyhow!("errored stream group omitted a frame"))?;
2528 got.extend(verify_moq_frame(&mut verifier, &topic, &frame)?);
2529 }
2530 assert!(matches!(&got[0], StreamPayload::Data(data) if data == b"partial"));
2531 assert!(matches!(&got[1], StreamPayload::Error(message) if message == "expected failure"));
2532 assert!(
2533 track.next_group().await?.is_none(),
2534 "errored track must EOF cleanly"
2535 );
2536 Ok(())
2537 }
2538
2539 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
2544 async fn moq_stream_finished_broadcast_cleanup_is_exact_and_retains_attached_track(
2545 ) -> Result<()> {
2546 let origin = origin();
2547
2548 let (_complete_secret, complete_pub) = crate::crypto::generate_ephemeral_keypair();
2549 let complete_ctx = StreamContext::from_third_party_interop_dh(&complete_pub.to_bytes())?;
2550 let complete_topic = complete_ctx.topic().to_owned();
2551 let complete_mac_key = *complete_ctx.mac_key();
2552 let complete_enc_key = *complete_ctx.enc_key().expect("DH ctx has enc_key");
2553 let mut complete_publisher = origin.publisher(&complete_ctx)?;
2554 let complete_broadcast = origin
2555 .consumer()
2556 .announced_broadcast(origin.broadcast_path(&complete_topic).as_str())
2557 .await
2558 .ok_or_else(|| anyhow!("complete broadcast was not announced"))?;
2559 let mut complete_track = complete_broadcast.subscribe_track(&Track::new(STREAM_TRACK))?;
2560 complete_publisher
2561 .publish_data(b"retained-complete")
2562 .await?;
2563 complete_publisher.complete_ref(b"{}").await?;
2564 drop(complete_publisher);
2565 assert_eq!(origin.inner.broadcasts.lock().len(), 0);
2566
2567 let mut complete_verifier = StreamVerifier::new(complete_mac_key, complete_topic.clone())
2568 .with_enc_key(complete_enc_key);
2569 let mut complete_payloads = Vec::new();
2570 for _ in 0..2 {
2571 let mut group = complete_track
2572 .next_group()
2573 .await?
2574 .ok_or_else(|| anyhow!("complete group was not retained for attached consumer"))?;
2575 let frame = group
2576 .read_frame()
2577 .await?
2578 .ok_or_else(|| anyhow!("complete frame was not retained"))?;
2579 complete_payloads.extend(verify_moq_frame(
2580 &mut complete_verifier,
2581 &complete_topic,
2582 &frame,
2583 )?);
2584 }
2585 assert!(matches!(
2586 &complete_payloads[0],
2587 StreamPayload::Data(data) if data == b"retained-complete"
2588 ));
2589 assert!(matches!(&complete_payloads[1], StreamPayload::Complete(_)));
2590 assert!(complete_track.next_group().await?.is_none());
2591 drop(complete_track);
2592
2593 let (_error_secret, error_pub) = crate::crypto::generate_ephemeral_keypair();
2594 let error_ctx = StreamContext::from_third_party_interop_dh(&error_pub.to_bytes())?;
2595 let error_topic = error_ctx.topic().to_owned();
2596 let error_mac_key = *error_ctx.mac_key();
2597 let error_enc_key = *error_ctx.enc_key().expect("DH ctx has enc_key");
2598 let mut error_publisher = origin.publisher(&error_ctx)?;
2599 let error_broadcast = origin
2600 .consumer()
2601 .announced_broadcast(origin.broadcast_path(&error_topic).as_str())
2602 .await
2603 .ok_or_else(|| anyhow!("error broadcast was not announced"))?;
2604 let mut error_track = error_broadcast.subscribe_track(&Track::new(STREAM_TRACK))?;
2605 error_publisher.publish_data(b"retained-error").await?;
2606 error_publisher.publish_error("retained failure").await?;
2607 drop(error_publisher);
2608 assert_eq!(origin.inner.broadcasts.lock().len(), 0);
2609
2610 let mut error_verifier =
2611 StreamVerifier::new(error_mac_key, error_topic.clone()).with_enc_key(error_enc_key);
2612 let mut error_payloads = Vec::new();
2613 for _ in 0..2 {
2614 let mut group = error_track
2615 .next_group()
2616 .await?
2617 .ok_or_else(|| anyhow!("error group was not retained for attached consumer"))?;
2618 let frame = group
2619 .read_frame()
2620 .await?
2621 .ok_or_else(|| anyhow!("error frame was not retained"))?;
2622 error_payloads.extend(verify_moq_frame(&mut error_verifier, &error_topic, &frame)?);
2623 }
2624 assert!(matches!(
2625 &error_payloads[0],
2626 StreamPayload::Data(data) if data == b"retained-error"
2627 ));
2628 assert!(matches!(
2629 &error_payloads[1],
2630 StreamPayload::Error(message) if message == "retained failure"
2631 ));
2632 assert!(error_track.next_group().await?.is_none());
2633 drop(error_track);
2634
2635 let (_empty_secret, empty_pub) = crate::crypto::generate_ephemeral_keypair();
2637 let empty_ctx = StreamContext::from_third_party_interop_dh(&empty_pub.to_bytes())?;
2638 let mut empty_publisher = origin.publisher(&empty_ctx)?;
2639 empty_publisher.complete_ref(b"{}").await?;
2640 drop(empty_publisher);
2641 assert_eq!(origin.inner.broadcasts.lock().len(), 0);
2642
2643 let (_replacement_secret, replacement_pub) = crate::crypto::generate_ephemeral_keypair();
2645 let replacement_ctx =
2646 StreamContext::from_third_party_interop_dh(&replacement_pub.to_bytes())?;
2647 let old_publisher = origin.publisher(&replacement_ctx)?;
2648 let mut new_publisher = origin.publisher(&replacement_ctx)?;
2649 assert_eq!(origin.inner.broadcasts.lock().len(), 1);
2650 drop(old_publisher);
2651 assert_eq!(origin.inner.broadcasts.lock().len(), 1);
2652 new_publisher.complete_ref(b"{}").await?;
2653 drop(new_publisher);
2654 assert_eq!(origin.inner.broadcasts.lock().len(), 0);
2655 Ok(())
2656 }
2657
2658 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
2661 async fn moq_stream_consumer_wait_observes_cancellation() -> Result<()> {
2662 let origin = origin();
2663 let (_client_secret, client_pub) = crate::crypto::generate_ephemeral_keypair();
2664 let ctx = StreamContext::from_third_party_interop_dh(&client_pub.to_bytes())?;
2665 let publisher = origin.publisher(&ctx)?;
2666 ctx.cancel_token().cancel();
2667 let error = publisher
2668 .wait_for_consumer()
2669 .await
2670 .expect_err("cancelled stream must not wait for a consumer");
2671 assert!(error.to_string().contains("cancelled"));
2672 Ok(())
2673 }
2674
2675 #[tokio::test]
2684 #[ignore = "bounded 32 MiB MoQ application-frame ceiling measurement"]
2685 async fn measure_keyed_application_frame_ceiling() -> Result<()> {
2686 const DECODE_BF16_BYTES: usize = 8 * 1024;
2687 const PREFILL_BF16_BYTES: usize = 64 * 1024 * 1024;
2688 const RECOMMENDED_ACTIVATION_DATA_BUDGET: usize = 31 * 1024 * 1024;
2689 const MOQ_SERIALIZED_FRAME_CAP: usize = 32 * 1024 * 1024;
2690 const EXPECTED_DECODE_FRAME_BYTES: usize = 8_408;
2691 const EXPECTED_BUDGET_FRAME_BYTES: usize = 32_506_072;
2692 const EXPECTED_KEYED_PAYLOAD_CEILING_BYTES: usize = 33_554_223;
2693
2694 let decode_frame = keyed_application_frame_probe(DECODE_BF16_BYTES)
2695 .await?
2696 .map_err(|error| anyhow!("8 KiB decode probe rejected: {error}"))?;
2697 assert_eq!(decode_frame, EXPECTED_DECODE_FRAME_BYTES);
2698
2699 let budget_frame = keyed_application_frame_probe(RECOMMENDED_ACTIVATION_DATA_BUDGET)
2700 .await?
2701 .map_err(|error| anyhow!("31 MiB safety-budget probe rejected: {error}"))?;
2702 assert_eq!(budget_frame, EXPECTED_BUDGET_FRAME_BYTES);
2703 assert_eq!(MOQ_SERIALIZED_FRAME_CAP - budget_frame, 1_048_360);
2704
2705 const {
2710 assert!(PREFILL_BF16_BYTES > MOQ_SERIALIZED_FRAME_CAP);
2711 }
2712
2713 assert_negative_control_not_materialized(PREFILL_BF16_BYTES)?;
2714
2715 let mut accepted = DECODE_BF16_BYTES;
2716 let mut rejected = PREFILL_BF16_BYTES;
2717 while rejected - accepted > 1 {
2718 let candidate = accepted + (rejected - accepted) / 2;
2719 match keyed_application_frame_probe(candidate).await? {
2720 Ok(_) => accepted = candidate,
2721 Err(error) if error.contains("frame too large") => rejected = candidate,
2722 Err(error) => anyhow::bail!(
2723 "payload probe at {candidate} bytes failed for a non-causal reason: {error}"
2724 ),
2725 }
2726 }
2727
2728 let ceiling_frame = keyed_application_frame_probe(accepted)
2729 .await?
2730 .map_err(|error| anyhow!("ceiling probe rejected: {error}"))?;
2731 let first_rejected_error = keyed_application_frame_probe(rejected)
2732 .await?
2733 .expect_err("first payload above the measured ceiling unexpectedly succeeded");
2734
2735 assert_eq!(rejected, accepted + 1);
2736 assert_eq!(accepted, EXPECTED_KEYED_PAYLOAD_CEILING_BYTES);
2737 assert_eq!(ceiling_frame, MOQ_SERIALIZED_FRAME_CAP);
2738 assert!(first_rejected_error.contains("frame too large"));
2739 assert!(PREFILL_BF16_BYTES >= rejected);
2740 Ok(())
2741 }
2742
2743 #[test]
2746 fn prefill_negative_control_does_not_invoke_allocator() -> Result<()> {
2747 assert_negative_control_not_materialized(64 * 1024 * 1024)
2748 }
2749
2750 fn assert_negative_control_not_materialized(payload_len: usize) -> Result<()> {
2751 let mut allocation_attempted = false;
2754 let error = deterministic_bf16_probe_payload_with(payload_len, |_| {
2755 allocation_attempted = true;
2756 Vec::new()
2757 })
2758 .expect_err("negative-control payload unexpectedly reached the allocator");
2759 anyhow::ensure!(!allocation_attempted, "negative control invoked allocator");
2760 anyhow::ensure!(
2761 error.to_string().contains("refusing to materialize"),
2762 "negative-control guard failed for a non-causal reason: {error}"
2763 );
2764 Ok(())
2765 }
2766
2767 async fn keyed_application_frame_probe(
2768 payload_len: usize,
2769 ) -> Result<std::result::Result<usize, String>> {
2770 let payload = deterministic_bf16_probe_payload_with(payload_len, |len| vec![0_u8; len])?;
2771 let origin = origin();
2772 let (_client_secret, client_pub) = crate::crypto::generate_ephemeral_keypair();
2773 let ctx = StreamContext::from_third_party_interop_dh(&client_pub.to_bytes())?;
2774 let topic = ctx.topic().to_owned();
2775 let mut publisher = origin.publisher(&ctx)?;
2776
2777 if let Err(error) = publisher.publish_data(&payload).await {
2778 return Ok(Err(error.to_string()));
2779 }
2780
2781 let path = origin.broadcast_path(&topic);
2782 let broadcast = origin
2783 .consumer()
2784 .announced_broadcast(path.as_str())
2785 .await
2786 .ok_or_else(|| anyhow!("probe broadcast not announced"))?;
2787 let track = broadcast.subscribe_track(&Track::new(STREAM_TRACK))?;
2788 let mut group = track
2789 .get_group(0)
2790 .await?
2791 .ok_or_else(|| anyhow!("probe Group 0 missing"))?;
2792 let frame = group
2793 .read_frame()
2794 .await?
2795 .ok_or_else(|| anyhow!("probe frame missing"))?;
2796 Ok(Ok(frame.len()))
2797 }
2798
2799 fn deterministic_bf16_probe_payload_with(
2800 payload_len: usize,
2801 allocate: impl FnOnce(usize) -> Vec<u8>,
2802 ) -> Result<Vec<u8>> {
2803 const MAX_MATERIALIZED_PROBE_BYTES: usize = 32 * 1024 * 1024 + 4 * 1024;
2806 anyhow::ensure!(
2807 payload_len <= MAX_MATERIALIZED_PROBE_BYTES,
2808 "refusing to materialize {payload_len}-byte negative-control payload"
2809 );
2810
2811 let mut payload = allocate(payload_len);
2815 anyhow::ensure!(
2816 payload.len() == payload_len,
2817 "probe allocator returned {} bytes for requested {payload_len}",
2818 payload.len()
2819 );
2820 for value in payload.chunks_exact_mut(2) {
2821 value.copy_from_slice(&[0x80, 0x3f]);
2822 }
2823 Ok(payload)
2824 }
2825
2826 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
2830 async fn identified_epoch_rekey_keeps_stock_moq_objects_opaque_and_immutable() -> Result<()> {
2831 use crate::crypto::hybrid_kem::{generate_recipient, SuiteId};
2832 use crate::crypto::key_exchange::client_identified_stream_epoch;
2833 use crate::stream_epoch::{
2834 IdentifiedStreamBinding, StreamAcceptedState, StreamCarrierProfile, StreamRouteRole,
2835 };
2836
2837 let binding = IdentifiedStreamBinding::new(
2838 StreamCarrierProfile::StandardPublicRelay,
2839 StreamRouteRole::Relay,
2840 "did:at9p:producer",
2841 "did:at9p:consumer",
2842 StreamAcceptedState {
2843 identity_did: "did:at9p:producer".into(),
2844 digest: [0x31; 64],
2845 epoch: 3,
2846 },
2847 StreamAcceptedState {
2848 identity_did: "did:at9p:consumer".into(),
2849 digest: [0x41; 64],
2850 epoch: 4,
2851 },
2852 "inference.generate",
2853 "infer:model:qwen",
2854 "local/streams/identified",
2855 "did:at9p:producer#mesh-kem",
2856 "urn:hyprstream:stream-client:one-shot",
2857 1,
2858 )?;
2859 let client_keypair = generate_recipient(SuiteId::HyKemX25519MlKem768)?;
2860 let ctx = StreamContext::from_hybrid_identified(
2861 &client_keypair.public().encode(),
2862 binding.clone(),
2863 )?;
2864 let client_ratchet = client_identified_stream_epoch(
2865 &client_keypair,
2866 ctx.kem_ciphertexts()
2867 .expect("hybrid context has ciphertexts"),
2868 binding.clone(),
2869 )?;
2870 let initial_ratchet = client_ratchet.clone();
2871 let topic = ctx.topic().to_owned();
2872 let origin = origin();
2873 let duplicate_ctx = ctx.clone();
2874 assert!(
2875 origin.publisher(&ctx.clone().without_aead()).is_err(),
2876 "identified context accepted an AEAD downgrade before publication"
2877 );
2878 let mut publisher = origin.publisher(&ctx)?;
2879 assert!(
2880 origin.publisher(&duplicate_ctx).is_err(),
2881 "identified context clone created a second epoch-zero publisher"
2882 );
2883 publisher.publish_data(b"epoch-zero-secret").await?;
2884 assert!(
2885 publisher.publish_data(b"must-rekey-first").await.is_err(),
2886 "epoch block bound must fail closed"
2887 );
2888
2889 assert_eq!(publisher.publish_next_epoch()?, 1);
2890 publisher.publish_data(b"epoch-one-secret").await?;
2891
2892 assert_eq!(publisher.publish_next_epoch()?, 2);
2893 let private_error = "private model failure: customer prompt rejected";
2894 publisher.publish_error(private_error).await?;
2895
2896 let path = origin.broadcast_path(&topic);
2897 let bc = tokio::time::timeout(
2898 std::time::Duration::from_secs(5),
2899 origin.consumer().announced_broadcast(path.as_str()),
2900 )
2901 .await?
2902 .ok_or_else(|| anyhow!("broadcast not announced"))?;
2903 let track = bc.subscribe_track(&Track::new(STREAM_TRACK))?;
2904 let mut verifier =
2905 StreamVerifier::new([0; 32], String::new()).with_epoch_ratchet(client_ratchet);
2906
2907 let mut frames = Vec::new();
2908 for group_id in 0..5 {
2909 let mut group =
2910 tokio::time::timeout(std::time::Duration::from_secs(5), track.get_group(group_id))
2911 .await??
2912 .ok_or_else(|| anyhow!("identified Group {group_id} missing"))?;
2913 frames.push(
2914 tokio::time::timeout(std::time::Duration::from_secs(5), group.read_frame())
2915 .await??
2916 .ok_or_else(|| anyhow!("identified Object {group_id} missing"))?,
2917 );
2918 }
2919 let frame0 = &frames[0];
2920 assert!(
2921 !frame0
2922 .windows(b"epoch-zero-secret".len())
2923 .any(|window| window == b"epoch-zero-secret"),
2924 "stock relay-visible Object leaked plaintext"
2925 );
2926 let first = verify_moq_frame(&mut verifier, &topic, frame0)?;
2927 assert!(matches!(&first[0], StreamPayload::Data(data) if data == b"epoch-zero-secret"));
2928
2929 let control0 = &frames[1];
2930 assert!(
2931 !control0
2932 .windows(b"HYSEPK01".len())
2933 .any(|window| window == b"HYSEPK01")
2934 && !control0
2935 .windows(32)
2936 .any(|window| window == binding.binding_hash()),
2937 "relay-visible control Object exposed the epoch-control plaintext"
2938 );
2939 assert!(verify_moq_frame(&mut verifier, &topic, control0)?.is_empty());
2940 let second = verify_moq_frame(&mut verifier, &topic, &frames[2])?;
2941 assert!(matches!(&second[0], StreamPayload::Data(data) if data == b"epoch-one-secret"));
2942
2943 assert!(verify_moq_frame(&mut verifier, &topic, &frames[3])?.is_empty());
2944 assert!(
2945 !frames[4]
2946 .windows(private_error.len())
2947 .any(|window| window == private_error.as_bytes()),
2948 "stock relay-visible Object leaked the private error string"
2949 );
2950 let error = verify_moq_frame(&mut verifier, &topic, &frames[4])?;
2951 assert!(matches!(&error[0], StreamPayload::Error(message) if message == private_error));
2952
2953 let verifier_after_epoch_zero = || -> Result<StreamVerifier> {
2958 let mut verifier = StreamVerifier::new([0; 32], String::new())
2959 .with_epoch_ratchet(initial_ratchet.clone());
2960 let payloads = verify_moq_frame(&mut verifier, &topic, &frames[0])?;
2961 anyhow::ensure!(matches!(
2962 &payloads[0],
2963 StreamPayload::Data(data) if data == b"epoch-zero-secret"
2964 ));
2965 Ok(verifier)
2966 };
2967
2968 let mut tampered = frames[1].to_vec();
2969 let tampered_index = tampered.len() / 2;
2970 tampered[tampered_index] ^= 0x80;
2971 let mut tamper_verifier = verifier_after_epoch_zero()?;
2972 assert!(verify_moq_frame(&mut tamper_verifier, &topic, &tampered).is_err());
2973 assert!(verify_moq_frame(&mut tamper_verifier, &topic, &frames[1])?.is_empty());
2974 assert!(matches!(
2975 &verify_moq_frame(&mut tamper_verifier, &topic, &frames[2])?[0],
2976 StreamPayload::Data(data) if data == b"epoch-one-secret"
2977 ));
2978
2979 let mut replay_verifier = verifier_after_epoch_zero()?;
2980 assert!(verify_moq_frame(&mut replay_verifier, &topic, &frames[1])?.is_empty());
2981 assert!(verify_moq_frame(&mut replay_verifier, &topic, &frames[1]).is_err());
2982 assert!(matches!(
2983 &verify_moq_frame(&mut replay_verifier, &topic, &frames[2])?[0],
2984 StreamPayload::Data(data) if data == b"epoch-one-secret"
2985 ));
2986
2987 let previous_mac = &frames[0][frames[0].len() - 16..];
2988 let mut skipped = initial_ratchet.prepare_next()?;
2989 skipped.epoch += 1;
2990 let skipped_frame = identified_test_frame(
2991 &initial_ratchet,
2992 &topic,
2993 previous_mac,
2994 1,
2995 &StreamPayloadData::EpochCommit(skipped),
2996 )?;
2997 let mut skip_verifier = verifier_after_epoch_zero()?;
2998 assert!(verify_moq_frame(&mut skip_verifier, &topic, &skipped_frame).is_err());
2999 assert!(verify_moq_frame(&mut skip_verifier, &topic, &frames[1])?.is_empty());
3000
3001 let foreign_binding = IdentifiedStreamBinding::new(
3002 StreamCarrierProfile::StandardPublicRelay,
3003 StreamRouteRole::Relay,
3004 "did:at9p:producer",
3005 "did:at9p:consumer",
3006 StreamAcceptedState {
3007 identity_did: "did:at9p:producer".into(),
3008 digest: [0x31; 64],
3009 epoch: 3,
3010 },
3011 StreamAcceptedState {
3012 identity_did: "did:at9p:consumer".into(),
3013 digest: [0x41; 64],
3014 epoch: 4,
3015 },
3016 "inference.generate",
3017 "infer:model:qwen",
3018 "local/streams/foreign",
3019 "did:at9p:producer#mesh-kem",
3020 "urn:hyprstream:stream-client:one-shot",
3021 1,
3022 )?;
3023 let foreign = crate::stream_epoch::StreamEpochRatchet::from_hybrid_secret(
3024 &[0xA5; 32],
3025 foreign_binding,
3026 )?;
3027 let cross_stream_frame = identified_test_frame(
3028 &initial_ratchet,
3029 &topic,
3030 previous_mac,
3031 1,
3032 &StreamPayloadData::EpochCommit(foreign.prepare_next()?),
3033 )?;
3034 let mut cross_verifier = verifier_after_epoch_zero()?;
3035 assert!(verify_moq_frame(&mut cross_verifier, &topic, &cross_stream_frame).is_err());
3036 assert!(verify_moq_frame(&mut cross_verifier, &topic, &frames[1])?.is_empty());
3037
3038 let clear_payloads = [
3039 StreamPayloadData::Data(b"relay-visible forged data".to_vec()),
3040 StreamPayloadData::Error("relay-visible forged error".into()),
3041 StreamPayloadData::Complete(b"relay-visible forged completion".to_vec()),
3042 StreamPayloadData::Data(initial_ratchet.prepare_next()?.encode_control_object()),
3043 ];
3044 for clear_payload in &clear_payloads {
3045 let forged_clear =
3046 identified_test_frame(&initial_ratchet, &topic, previous_mac, 1, clear_payload)?;
3047 let mut clear_verifier = verifier_after_epoch_zero()?;
3048 assert!(verify_moq_frame(&mut clear_verifier, &topic, &forged_clear).is_err());
3049 assert!(verify_moq_frame(&mut clear_verifier, &topic, &frames[1])?.is_empty());
3050 }
3051
3052 let clear_heartbeat = identified_clear_heartbeat_frame(&initial_ratchet, previous_mac, 1)?;
3053 let mut heartbeat_verifier = verifier_after_epoch_zero()?;
3054 assert!(verify_moq_frame(&mut heartbeat_verifier, &topic, &clear_heartbeat).is_err());
3055 assert!(verify_moq_frame(&mut heartbeat_verifier, &topic, &frames[1])?.is_empty());
3056
3057 let mut reordered_verifier = verifier_after_epoch_zero()?;
3060 assert!(verify_moq_frame(&mut reordered_verifier, &topic, &frames[2]).is_err());
3061 assert!(verify_moq_frame(&mut reordered_verifier, &topic, &frames[1])?.is_empty());
3062 assert!(matches!(
3063 &verify_moq_frame(&mut reordered_verifier, &topic, &frames[2])?[0],
3064 StreamPayload::Data(data) if data == b"epoch-one-secret"
3065 ));
3066
3067 for pair in frames.windows(2) {
3068 assert_ne!(pair[0], pair[1]);
3069 }
3070 Ok(())
3071 }
3072
3073 fn identified_test_frame(
3074 ratchet: &crate::stream_epoch::StreamEpochRatchet,
3075 topic: &str,
3076 previous_mac: &[u8],
3077 sequence_number: u64,
3078 payload: &StreamPayloadData,
3079 ) -> Result<Vec<u8>> {
3080 let keys = ratchet.current_keys();
3081 let nonce = keys.producer_to_consumer.nonce(
3082 sequence_number
3083 .checked_mul(1 << 16)
3084 .ok_or_else(|| anyhow!("test stream payload nonce counter exhausted"))?,
3085 );
3086 let payload = if matches!(payload, StreamPayloadData::EpochCommit(_)) {
3087 seal_payload(
3088 &keys.producer_to_consumer.enc_key,
3089 topic,
3090 ratchet.epoch(),
3091 sequence_number,
3092 0,
3093 Some(nonce),
3094 payload,
3095 )?
3096 } else {
3097 payload.clone()
3098 };
3099 let capnp = crate::streaming::encode_stream_block(
3100 previous_mac,
3101 sequence_number,
3102 ratchet.epoch(),
3103 &[payload],
3104 )?;
3105 let mac = crate::crypto::keyed_mac_truncated_parts(
3106 &keys.producer_to_consumer.mac_key,
3107 &[previous_mac, &capnp],
3108 );
3109 let mut frame = capnp;
3110 frame.extend_from_slice(&mac);
3111 Ok(frame)
3112 }
3113
3114 fn identified_clear_heartbeat_frame(
3115 ratchet: &crate::stream_epoch::StreamEpochRatchet,
3116 previous_mac: &[u8],
3117 sequence_number: u64,
3118 ) -> Result<Vec<u8>> {
3119 let mut msg = capnp::message::Builder::new_default();
3120 {
3121 let mut block = msg.init_root::<crate::streaming_capnp::stream_block::Builder>();
3122 block.set_prev_mac(previous_mac);
3123 block.set_sequence_number(sequence_number);
3124 block.set_epoch(ratchet.epoch());
3125 block.init_payloads(1).get(0).set_heartbeat(());
3126 }
3127 let mut capnp = Vec::new();
3128 capnp::serialize::write_message(&mut capnp, &msg)?;
3129 let keys = ratchet.current_keys();
3130 let mac = crate::crypto::keyed_mac_truncated_parts(
3131 &keys.producer_to_consumer.mac_key,
3132 &[previous_mac, &capnp],
3133 );
3134 capnp.extend_from_slice(&mac);
3135 Ok(capnp)
3136 }
3137
3138 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
3141 async fn any_stream_publisher_moq_round_trip() -> Result<()> {
3142 let origin = origin();
3143 let (_client_secret, client_pub) = crate::crypto::generate_ephemeral_keypair();
3144 let ctx = StreamContext::from_third_party_interop_dh(&client_pub.to_bytes())?;
3145 let topic = ctx.topic().to_owned();
3146 let mac_key = *ctx.mac_key();
3147 let enc_key = *ctx.enc_key().expect("DH ctx has enc_key");
3149
3150 let mut any_pub: AnyStreamPublisher = origin.publisher(&ctx)?;
3151 any_pub.publish_data(b"ping").await?;
3152 any_pub.complete_ref(b"{}").await?;
3153
3154 let path = origin.broadcast_path(&topic);
3156 let bc = tokio::time::timeout(
3157 std::time::Duration::from_secs(5),
3158 origin.consumer().announced_broadcast(path.as_str()),
3159 )
3160 .await?
3161 .ok_or_else(|| anyhow!("broadcast not announced"))?;
3162 let mut track = bc.subscribe_track(&Track::new(STREAM_TRACK))?;
3163 let mut verifier = StreamVerifier::new(mac_key, topic.clone()).with_enc_key(enc_key);
3164 let mut got: Vec<StreamPayload> = Vec::new();
3165 for _ in 0..2 {
3166 let mut group =
3167 tokio::time::timeout(std::time::Duration::from_secs(5), track.next_group())
3168 .await??
3169 .ok_or_else(|| anyhow!("next_group None"))?;
3170 let frame = tokio::time::timeout(std::time::Duration::from_secs(5), group.read_frame())
3171 .await??
3172 .ok_or_else(|| anyhow!("read_frame None"))?;
3173 got.extend(verify_moq_frame(&mut verifier, &topic, &frame)?);
3174 }
3175 assert!(matches!(&got[0], StreamPayload::Data(d) if d == b"ping"));
3176 assert!(matches!(&got[1], StreamPayload::Complete(_)));
3177 Ok(())
3178 }
3179
3180 #[test]
3184 fn iroh_reach_dial_wire_roundtrip() {
3185 use crate::transport::{EndpointType, TransportConfig};
3186 let node_id = [0x42u8; 32];
3187 let dial = TransportConfig::iroh(
3188 node_id,
3189 Vec::new(),
3190 Some("https://relay.example".to_owned()),
3191 );
3192 let wire = dial_transport_to_wire(&dial).expect("iroh dial → wire");
3193 match &wire {
3194 crate::stream_info::TransportConfig::Iroh(i) => {
3195 assert_eq!(i.node_id, node_id);
3196 assert_eq!(i.relay_url, "https://relay.example");
3197 assert_eq!(i.alpn, "hyprstream-rpc/1");
3198 }
3199 other => panic!("expected wire Iroh, got {other:?}"),
3200 }
3201 let back = wire_transport_to_dial(&wire).expect("iroh wire → dial");
3202 match back.endpoint {
3203 EndpointType::Iroh {
3204 node_id: n,
3205 relay_url,
3206 direct_addrs,
3207 } => {
3208 assert_eq!(n, node_id);
3209 assert_eq!(relay_url.as_deref(), Some("https://relay.example"));
3210 assert!(
3211 direct_addrs.is_empty(),
3212 "wire iroh reach never carries direct addrs"
3213 );
3214 }
3215 other => panic!("expected dial Iroh, got {other:?}"),
3216 }
3217 }
3218
3219 #[test]
3223 fn same_host_endpoints_never_wire_advertised() {
3224 use crate::transport::TransportConfig;
3225 assert!(
3226 dial_transport_to_wire(&TransportConfig::inproc("hyprstream/inference-x")).is_none()
3227 );
3228 assert!(dial_transport_to_wire(&TransportConfig::ipc("/tmp/x.sock")).is_none());
3229 }
3230
3231 #[test]
3235 fn iroh_reach_empty_relay_decodes_but_not_dialable() {
3236 use crate::stream_info::{IrohReach, TransportConfig as ReachTransport};
3237 let wire = ReachTransport::Iroh(IrohReach {
3238 node_id: [9u8; 32],
3239 alpn: "moql".to_owned(),
3240 relay_url: String::new(),
3241 });
3242 let dial = wire_transport_to_dial(&wire).expect("decodes");
3243 let signer = crate::signer::LocalSigner::new(crate::crypto::SigningKey::generate(
3245 &mut rand::rngs::OsRng,
3246 ));
3247 assert!(
3248 crate::dial::dial(&dial, signer, None, None).is_err(),
3249 "RPC dial must require explicit reachability and response proof"
3250 );
3251 }
3252
3253 #[test]
3257 fn quic_reach_is_dialable() {
3258 use crate::stream_info::{Destination, QuicReach, Role, TransportConfig as ReachTransport};
3259 let reach = Destination {
3260 role: Role::Direct,
3261 transport: ReachTransport::Quic(QuicReach {
3262 addr: "127.0.0.1:4433".to_owned(),
3263 server_name: "localhost".to_owned(),
3264 cert_hashes: vec![vec![0u8; 32]],
3265 }),
3266 moql_server_identity: Default::default(),
3267 };
3268 assert!(
3269 reach_to_transport_config(&reach).is_some(),
3270 "a Quic reach must resolve to a dialable TransportConfig (selects the \
3271 networked dial_stream path, not the local UDS)"
3272 );
3273 }
3274
3275 #[test]
3281 fn iroh_reach_resolves_to_node_id() {
3282 use crate::stream_info::{Destination, IrohReach, Role, TransportConfig as ReachTransport};
3283 use crate::transport::EndpointType;
3284
3285 let node_id = [0x7u8; 32];
3286 let reach = Destination {
3288 role: Role::Direct,
3289 transport: ReachTransport::Iroh(IrohReach {
3290 node_id,
3291 alpn: "moql".to_owned(),
3292 relay_url: String::new(),
3293 }),
3294 moql_server_identity: Default::default(),
3295 };
3296 assert_eq!(
3297 reach.role,
3298 Role::Direct,
3299 "iroh reach is a direct producer reach"
3300 );
3301
3302 let cfg = reach_to_transport_config(&reach)
3303 .expect("an iroh reach with a node_id must resolve to a dialable TransportConfig");
3304 match cfg.endpoint {
3305 EndpointType::Iroh {
3306 node_id: got,
3307 direct_addrs,
3308 relay_url,
3309 } => {
3310 assert_eq!(
3311 got, node_id,
3312 "resolved node_id must round-trip the advertised one"
3313 );
3314 assert!(
3316 direct_addrs.is_empty(),
3317 "S2 iroh reach carries no direct addrs (pkarr)"
3318 );
3319 assert!(
3320 relay_url.is_none(),
3321 "S2 iroh reach carries no relay URL (pkarr)"
3322 );
3323 }
3324 other => panic!("iroh reach must resolve to EndpointType::Iroh, got {other:?}"),
3325 }
3326 }
3327
3328 #[test]
3332 fn iroh_reach_is_dialable() {
3333 use crate::stream_info::{Destination, IrohReach, Role, TransportConfig as ReachTransport};
3334 let reach = [Destination {
3335 role: Role::Direct,
3336 transport: ReachTransport::Iroh(IrohReach {
3337 node_id: [0xABu8; 32],
3338 alpn: "moql".to_owned(),
3339 relay_url: String::new(),
3340 }),
3341 moql_server_identity: Default::default(),
3342 }];
3343 assert!(
3344 reach.iter().any(|d| reach_to_transport_config(d).is_some()),
3345 "an iroh reach must resolve to a dialable TransportConfig"
3346 );
3347 }
3348
3349 #[tokio::test]
3353 async fn rejected_iroh_reach_never_falls_back_to_local_uds() -> Result<()> {
3354 use crate::stream_info::{Destination, IrohReach, Role, TransportConfig as ReachTransport};
3355
3356 let reach = [Destination {
3357 role: Role::Direct,
3358 transport: ReachTransport::Iroh(IrohReach {
3359 node_id: [0xCDu8; 32],
3360 alpn: "moql".to_owned(),
3361 relay_url: String::new(),
3362 }),
3363 moql_server_identity: Default::default(),
3364 }];
3365
3366 let err = match connect_moq_reach(&reach).await {
3370 Ok(_) => panic!("Iroh reach without admission proof must be rejected"),
3371 Err(err) => err,
3372 };
3373 let message = err.to_string();
3374 assert!(
3375 message
3376 .contains("all dialable network reaches failed; refusing local moq UDS fallback"),
3377 "dialable Iroh rejection must not fall back to local UDS: {message}"
3378 );
3379 assert!(
3380 message.contains("iroh moql reach"),
3381 "network admission rejection must be retained: {message}"
3382 );
3383 Ok(())
3384 }
3385
3386 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
3400 async fn networked_prefers_reach_over_local_uds() -> Result<()> {
3401 use crate::stream_info::{Destination, QuicReach, Role, TransportConfig as ReachTransport};
3402
3403 let uds_marker = "/nonexistent/hyprstream-275-uds-marker.sock";
3408 let _ = GLOBAL_MOQ_UDS_PATH.set(PathBuf::from(uds_marker));
3409
3410 let reach = vec![Destination {
3412 role: Role::Direct,
3413 transport: ReachTransport::Quic(QuicReach {
3414 addr: "127.0.0.1:1".to_owned(),
3415 server_name: "localhost".to_owned(),
3416 cert_hashes: vec![[0xABu8; 32].to_vec()],
3417 }),
3418 moql_server_identity: Default::default(),
3419 }];
3420
3421 let qos = crate::stream_info::StreamOpt::default();
3422 let mut handle = MoqStreamHandle::networked(
3423 reach,
3424 &qos,
3425 "local/streams/test/deadbeef".to_owned(),
3426 [0u8; 32],
3427 [0u8; 32],
3428 "deadbeef".repeat(8),
3429 Default::default(),
3430 );
3431
3432 match tokio::time::timeout(std::time::Duration::from_secs(3), handle.recv_next()).await {
3433 Err(_elapsed) => Ok(()),
3435 Ok(res) => {
3438 let err = res.expect_err("dial to a closed port must not yield a payload");
3439 let msg = err.to_string();
3440 assert!(
3441 !msg.contains(uds_marker),
3442 "consumer connected to the local UDS plane instead of dialing the \
3443 producer's reach (#275 regression): {msg}"
3444 );
3445 assert!(
3446 msg.contains("networked dial"),
3447 "expected a networked dial failure (reach was dialed), got: {msg}"
3448 );
3449 Ok(())
3450 }
3451 }
3452 }
3453
3454 #[test]
3455 fn authorize_signer_gate() {
3456 let producer = Origin::random().produce();
3457 let consumer = producer.consume();
3458 let gated = MoqStreamOrigin::builder(producer, consumer)
3459 .with_authorize_signer(|pk| pk[0] == 1)
3460 .build();
3461 assert!(gated.authorize_signer(&[1u8; 32]));
3462 assert!(!gated.authorize_signer(&[2u8; 32]));
3463 assert!(origin().authorize_signer(&[9u8; 32]));
3465 }
3466
3467 use crate::stream_info::{
3470 Destination, IrohReach, Job, Log, Pipe, QuicReach, Role, StreamOpt, StreamOptPreset,
3471 TransportConfig as ReachTransport,
3472 };
3473
3474 fn direct_iroh(b: u8) -> Destination {
3475 Destination {
3476 role: Role::Direct,
3477 transport: ReachTransport::Iroh(IrohReach {
3478 node_id: [b; 32],
3479 alpn: String::new(),
3480 relay_url: String::new(),
3481 }),
3482 moql_server_identity: Default::default(),
3483 }
3484 }
3485 fn relay_quic(addr: &str) -> Destination {
3486 Destination {
3487 role: Role::Relay,
3488 transport: ReachTransport::Quic(QuicReach {
3489 addr: addr.to_owned(),
3490 server_name: "relay".to_owned(),
3491 cert_hashes: vec![vec![0u8; 32]],
3492 }),
3493 moql_server_identity: Default::default(),
3494 }
3495 }
3496
3497 #[tokio::test]
3498 async fn required_stream_reach_rejects_empty_and_browser_only_without_dial() {
3499 let identity = crate::stream_info::MoqlServerIdentity::default();
3500 for reach in [
3501 vec![],
3502 vec![crate::stream_info::Destination {
3503 role: crate::stream_info::Role::Direct,
3504 transport: crate::stream_info::TransportConfig::Quic(
3505 crate::stream_info::QuicReach {
3506 addr: "127.0.0.1:9".into(),
3507 server_name: "localhost".into(),
3508 cert_hashes: vec![],
3509 },
3510 ),
3511 moql_server_identity: Default::default(),
3512 }],
3513 ] {
3514 let result = tokio::time::timeout(
3515 std::time::Duration::from_millis(200),
3516 connect_moq_reach_for_profile(&reach, &identity, true),
3517 )
3518 .await
3519 .unwrap();
3520 assert!(result
3521 .err()
3522 .unwrap()
3523 .to_string()
3524 .contains("no dialable Iroh stream reach"));
3525 }
3526 }
3527
3528 fn accepted_server_identity(did: &str, marker: u8) -> crate::stream_info::MoqlServerIdentity {
3529 crate::stream_info::MoqlServerIdentity {
3530 did: did.to_owned(),
3531 epoch: 1,
3532 head_digest: vec![marker; 64],
3533 expires_at_unix_ms: crate::envelope::current_timestamp() + 60_000,
3534 ed25519: [marker; 32],
3535 ml_dsa65: vec![marker; 1952],
3536 }
3537 }
3538
3539 #[test]
3544 fn relay_destination_uses_its_own_accepted_state_witness() {
3545 let producer = accepted_server_identity("did:at9p:producer", 0x11);
3546 let relay = accepted_server_identity("did:at9p:relay", 0x22);
3547 let relay_transport = ReachTransport::Iroh(IrohReach {
3548 node_id: [0x33; 32],
3549 alpn: "moql".to_owned(),
3550 relay_url: String::new(),
3551 });
3552 let cfg = ProducerReachConfig {
3553 moql_server_identity: Some(producer.clone()),
3554 relay_moql_server_identity: Some(relay.clone()),
3555 iroh_node_id: Some([0x44; 32]),
3556 quic_reach: None,
3557 relay: Some(relay_transport.clone()),
3558 };
3559
3560 let reach = cfg.reach();
3561 let direct = reach
3562 .iter()
3563 .find(|destination| destination.role == Role::Direct)
3564 .expect("producer direct reach");
3565 let relay_destination = reach
3566 .iter()
3567 .find(|destination| destination.role == Role::Relay)
3568 .expect("relay reach");
3569 assert_eq!(direct.moql_server_identity, producer);
3570 assert_eq!(relay_destination.moql_server_identity, relay);
3571 assert_ne!(
3572 relay_destination.moql_server_identity, direct.moql_server_identity,
3573 "the relay must never inherit the producer accepted-state witness"
3574 );
3575
3576 let independent = cfg.reach_with_relay(RelayChoice::Override(RelayTarget::new(
3577 relay_transport,
3578 relay.clone(),
3579 )));
3580 let independent_relay = independent
3581 .iter()
3582 .find(|destination| destination.role == Role::Relay)
3583 .expect("independent relay reach");
3584 assert_eq!(independent_relay.moql_server_identity, relay);
3585 }
3586
3587 #[test]
3591 fn relay_without_witness_cannot_borrow_live_producer_authority() {
3592 let producer = accepted_server_identity("did:at9p:producer", 0x11);
3593 let relay = Destination {
3594 role: Role::Relay,
3595 transport: ReachTransport::Iroh(IrohReach {
3596 node_id: [0x22; 32],
3597 alpn: "moql".to_owned(),
3598 relay_url: String::new(),
3599 }),
3600 moql_server_identity: Default::default(),
3601 };
3602 let error = destination_server_identity(&relay, &producer)
3603 .expect_err("relay without its own resolver witness must reject");
3604 assert!(error.to_string().contains("relay witness"));
3605
3606 let direct = Destination {
3607 role: Role::Direct,
3608 transport: ReachTransport::Quic(QuicReach {
3609 addr: "127.0.0.1:4434".to_owned(),
3610 server_name: "producer".to_owned(),
3611 cert_hashes: vec![vec![0u8; 32]],
3612 }),
3613 moql_server_identity: Default::default(),
3614 };
3615 assert_eq!(
3616 destination_server_identity(&direct, &producer)
3617 .expect("direct legacy fallback remains valid")
3618 .expect("live producer witness"),
3619 &producer,
3620 );
3621 }
3622
3623 #[test]
3628 fn relay_gate_accepts_iroh_target_pinned_without_granting_identity() {
3629 for node_id in [[7u8; 32], [19u8; 32]] {
3632 let cfg = crate::transport::TransportConfig::iroh(node_id, Vec::new(), None);
3633 assert!(assert_relay_path_pinned(&cfg).is_ok());
3634 }
3635 }
3636
3637 #[test]
3639 fn relay_gate_accepts_quic_leaf_pinned() {
3640 let addr = "127.0.0.1:7777".parse().expect("addr");
3641 let cfg = crate::transport::TransportConfig::quic_pinned(addr, "relay", [3u8; 32]);
3642 assert!(assert_relay_path_pinned(&cfg).is_ok());
3643 }
3644
3645 #[test]
3649 fn relay_gate_rejects_quic_webpki_only() {
3650 let addr = "127.0.0.1:7777".parse().expect("addr");
3651 let cfg = crate::transport::TransportConfig::quic(addr, "relay");
3652 let err = assert_relay_path_pinned(&cfg).expect_err("WebPKI-only relay must be rejected");
3653 assert!(
3654 err.to_string().contains("WebPKI-only"),
3655 "expected a WebPKI-only rejection, got: {err}"
3656 );
3657 }
3658
3659 #[test]
3662 fn relay_gate_accepts_quic_webpki_plus_pin() {
3663 let addr = "127.0.0.1:7777".parse().expect("addr");
3664 let auth = crate::transport::QuicServerAuth::web_pki_pinned(vec![[5u8; 32]]).expect("auth");
3665 let cfg = crate::transport::TransportConfig::quic_with_auth(addr, "relay", auth);
3666 assert!(assert_relay_path_pinned(&cfg).is_ok());
3667 }
3668
3669 #[test]
3672 fn relay_gate_rejects_unpinned_same_host() {
3673 let cfg = crate::transport::TransportConfig::inproc("hyprstream/x");
3674 assert!(assert_relay_path_pinned(&cfg).is_err());
3675 }
3676
3677 #[test]
3683 fn producer_reach_advertises_relay_when_configured() {
3684 let relay = ReachTransport::Quic(QuicReach {
3685 addr: "10.0.0.9:4433".to_owned(),
3686 server_name: "pds".to_owned(),
3687 cert_hashes: vec![vec![1u8; 32]],
3688 });
3689 let cfg = ProducerReachConfig {
3690 relay: Some(relay.clone()),
3691 ..Default::default()
3692 };
3693 let reach = cfg.reach();
3694 assert!(
3695 reach
3696 .iter()
3697 .any(|d| d.role == Role::Relay && d.transport == relay),
3698 "ProducerReachConfig::reach must advertise the configured Role::Relay reach"
3699 );
3700 }
3701
3702 #[test]
3707 fn heterogeneous_reach_in_one_process() {
3708 let relay_x = ReachTransport::Quic(QuicReach {
3709 addr: "10.0.0.9:4433".to_owned(),
3710 server_name: "relay-x".to_owned(),
3711 cert_hashes: vec![vec![7u8; 32]],
3712 });
3713 let cfg = ProducerReachConfig {
3715 moql_server_identity: None,
3716 relay_moql_server_identity: None,
3717 iroh_node_id: Some([3u8; 32]),
3718 quic_reach: None,
3719 relay: Some(relay_x.clone()),
3720 };
3721
3722 let reach_y = cfg.reach();
3724 assert_eq!(
3725 reach_y[0].role,
3726 Role::Direct,
3727 "Y must advertise its direct reach first"
3728 );
3729 assert!(
3730 reach_y.iter().any(|d| d.role == Role::Relay),
3731 "Y must also advertise the server-global relay"
3732 );
3733
3734 let relay_only = ReachTransport::Quic(QuicReach {
3737 addr: "10.0.0.50:4433".to_owned(),
3738 server_name: "relay-anon".to_owned(),
3739 cert_hashes: vec![vec![9u8; 32]],
3740 });
3741 let reach_x = cfg.reach_with_relay(RelayChoice::Only(RelayTarget::new(
3742 relay_only.clone(),
3743 accepted_server_identity("did:at9p:relay-anon", 0x23),
3744 )));
3745 assert_eq!(
3746 reach_x.len(),
3747 1,
3748 "relay-only stream X must omit all direct reaches"
3749 );
3750 assert_eq!(reach_x[0].role, Role::Relay, "X is relay-only (anonymized)");
3751 assert_eq!(
3752 reach_x[0].transport, relay_only,
3753 "X uses its per-stream relay override"
3754 );
3755 assert!(
3756 !reach_x.iter().any(|d| d.role == Role::Direct),
3757 "X must NOT leak a direct reach (server authority / anonymization)"
3758 );
3759
3760 assert_ne!(
3763 reach_x, reach_y,
3764 "X (relay-only) and Y (direct+relay) must differ"
3765 );
3766 }
3767
3768 #[test]
3771 fn per_stream_relay_override_keeps_direct() {
3772 let server_relay = ReachTransport::Quic(QuicReach {
3773 addr: "10.0.0.1:4433".to_owned(),
3774 server_name: "server".to_owned(),
3775 cert_hashes: vec![vec![1u8; 32]],
3776 });
3777 let tenant_relay = ReachTransport::Quic(QuicReach {
3778 addr: "10.0.0.2:4433".to_owned(),
3779 server_name: "tenant".to_owned(),
3780 cert_hashes: vec![vec![2u8; 32]],
3781 });
3782 let cfg = ProducerReachConfig {
3783 moql_server_identity: None,
3784 relay_moql_server_identity: None,
3785 iroh_node_id: Some([4u8; 32]),
3786 quic_reach: None,
3787 relay: Some(server_relay.clone()),
3788 };
3789 let reach = cfg.reach_with_relay(RelayChoice::Override(RelayTarget::new(
3790 tenant_relay.clone(),
3791 accepted_server_identity("did:at9p:tenant-relay", 0x24),
3792 )));
3793 assert_eq!(
3794 reach[0].role,
3795 Role::Direct,
3796 "override keeps the direct reach, listed first"
3797 );
3798 let relay_d = reach
3799 .iter()
3800 .find(|d| d.role == Role::Relay)
3801 .expect("relay advertised");
3802 assert_eq!(
3803 relay_d.transport, tenant_relay,
3804 "per-stream override replaces the server relay"
3805 );
3806 }
3807
3808 #[test]
3810 fn select_reach_orders_by_qos_topology() {
3811 let advertised = vec![direct_iroh(1), relay_quic("10.0.0.1:4433"), direct_iroh(2)];
3812
3813 let pipe = Pipe::stream_opt();
3815 let ordered = select_reach(&advertised, &pipe);
3816 assert_eq!(
3817 ordered[0].role,
3818 Role::Direct,
3819 "live pipe must try direct first"
3820 );
3821 assert_eq!(
3822 ordered[2].role,
3823 Role::Relay,
3824 "relay falls to the back for a live pipe"
3825 );
3826 assert_eq!(
3827 ordered[0],
3828 direct_iroh(1),
3829 "within-role advertised order preserved"
3830 );
3831 assert_eq!(ordered[1], direct_iroh(2));
3832
3833 let job = Job::stream_opt();
3835 let ordered = select_reach(&advertised, &job);
3836 assert_eq!(
3837 ordered[0].role,
3838 Role::Relay,
3839 "retained job must try relay first"
3840 );
3841
3842 let log = Log::stream_opt();
3844 assert_eq!(select_reach(&advertised, &log)[0].role, Role::Relay);
3845 }
3846
3847 #[test]
3851 fn select_reach_preserves_server_authority() {
3852 let relay_only = vec![relay_quic("10.0.0.1:4433")];
3853
3854 let ordered = select_reach(&relay_only, &StreamOpt::default());
3856 assert_eq!(ordered.len(), 1, "selection must not add or drop reaches");
3857 assert_eq!(
3858 ordered[0].role,
3859 Role::Relay,
3860 "a relay-only stream stays relay-only"
3861 );
3862 assert!(
3863 !ordered.iter().any(|d| d.role == Role::Direct),
3864 "the client must NOT fabricate a direct reach the service didn't advertise"
3865 );
3866
3867 let advertised = vec![direct_iroh(1), relay_quic("a:1"), direct_iroh(2)];
3869 let mut a = advertised.clone();
3870 let mut b = select_reach(&advertised, &Job::stream_opt());
3871 a.sort_by_key(|d| (d.role == Role::Relay, format!("{d:?}")));
3872 b.sort_by_key(|d| (d.role == Role::Relay, format!("{d:?}")));
3873 assert_eq!(
3874 a, b,
3875 "selection must be a permutation of the advertised reach"
3876 );
3877 }
3878
3879 #[test]
3882 fn relay_reach_from_decoded_round_trips() {
3883 let cfg = crate::transport::TransportConfig::iroh([0x5u8; 32], Vec::new(), None);
3885 match relay_reach_from_decoded(&cfg) {
3886 Some(ReachTransport::Iroh(i)) => assert_eq!(i.node_id, [0x5u8; 32]),
3887 other => panic!("expected iroh wire reach, got {other:?}"),
3888 }
3889 assert!(
3891 relay_reach_from_decoded(&crate::transport::TransportConfig::ipc("/tmp/x.sock"))
3892 .is_none(),
3893 "a same-host ipc transport is not a network-routable relay"
3894 );
3895 }
3896
3897 #[test]
3900 fn aead_seal_open_roundtrip() {
3901 let enc_key = [0x42u8; 32];
3902 let topic = "deadbeef";
3903 let epoch = 7u64;
3904 for payload in [
3905 StreamPayloadData::Data(b"hello tokens".to_vec()),
3906 StreamPayloadData::Complete(b"{\"done\":true}".to_vec()),
3907 ] {
3908 let sealed = seal_payload(&enc_key, topic, epoch, 0, 0, None, &payload).unwrap();
3909 let StreamPayloadData::Tagged {
3910 tag,
3911 payload: ct,
3912 nonce,
3913 key_commitment,
3914 } = &sealed
3915 else {
3916 panic!("seal must produce a Tagged payload");
3917 };
3918 let opened = crate::stream_consumer::open_sealed_payload(
3919 &enc_key,
3920 topic,
3921 epoch,
3922 0,
3923 0,
3924 tag,
3925 ct,
3926 nonce,
3927 key_commitment,
3928 )
3929 .unwrap();
3930 match (&payload, &opened) {
3931 (StreamPayloadData::Data(a), StreamPayload::Data(b))
3932 | (StreamPayloadData::Complete(a), StreamPayload::Complete(b)) => {
3933 assert_eq!(a, b);
3934 }
3935 _ => panic!("opened variant must match sealed variant"),
3936 }
3937 }
3938 }
3939
3940 #[test]
3941 fn aead_open_rejects_wrong_key_and_tamper() {
3942 let enc_key = [0x42u8; 32];
3943 let topic = "t";
3944 let epoch = 1u64;
3945 let sealed = seal_payload(
3946 &enc_key,
3947 topic,
3948 epoch,
3949 0,
3950 0,
3951 None,
3952 &StreamPayloadData::Data(b"secret".to_vec()),
3953 )
3954 .unwrap();
3955 let StreamPayloadData::Tagged {
3956 tag,
3957 payload: ct,
3958 nonce,
3959 key_commitment,
3960 } = &sealed
3961 else {
3962 panic!("expected Tagged");
3963 };
3964
3965 let wrong = [0x99u8; 32];
3967 assert!(crate::stream_consumer::open_sealed_payload(
3968 &wrong,
3969 topic,
3970 epoch,
3971 0,
3972 0,
3973 tag,
3974 ct,
3975 nonce,
3976 key_commitment
3977 )
3978 .is_err());
3979
3980 assert!(crate::stream_consumer::open_sealed_payload(
3982 &enc_key,
3983 topic,
3984 2,
3985 0,
3986 0,
3987 tag,
3988 ct,
3989 nonce,
3990 key_commitment
3991 )
3992 .is_err());
3993
3994 let mut bad_ct = ct.clone();
3996 if let Some(b) = bad_ct.first_mut() {
3997 *b ^= 0xFF;
3998 }
3999 assert!(crate::stream_consumer::open_sealed_payload(
4000 &enc_key,
4001 topic,
4002 epoch,
4003 0,
4004 0,
4005 tag,
4006 &bad_ct,
4007 nonce,
4008 key_commitment
4009 )
4010 .is_err());
4011 }
4012
4013 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
4018 async fn provenance_publish_verify_and_reject() -> Result<()> {
4019 use crate::envelope::KeyedPqTrustStore;
4020 use crate::stream_provenance::ProvenanceSigner;
4021 use ed25519_dalek::SigningKey;
4022
4023 let origin = origin();
4024 let (_cs, client_pub) = crate::crypto::generate_ephemeral_keypair();
4025 let ctx = StreamContext::from_third_party_interop_dh(&client_pub.to_bytes())?;
4026 let topic = ctx.topic().to_owned();
4027 let mac_key = *ctx.mac_key();
4028 let enc_key = *ctx.enc_key().expect("DH ctx has enc_key");
4029
4030 let host_ed = SigningKey::from_bytes(&[5u8; 32]);
4031 let signer = ProvenanceSigner::from_ed25519(host_ed.clone());
4032 let kid = signer.signer_kid();
4033
4034 let mut pub_ = origin.publisher_with_provenance(&ctx, Some(signer))?;
4035 pub_.publish_data(b"hi").await?;
4036 pub_.complete_ref(b"{}").await?;
4037
4038 let path = origin.broadcast_path(&topic);
4040 let bc = tokio::time::timeout(
4041 std::time::Duration::from_secs(5),
4042 origin.consumer().announced_broadcast(path.as_str()),
4043 )
4044 .await?
4045 .ok_or_else(|| anyhow!("broadcast not announced"))?;
4046 let mut track = bc.subscribe_track(&Track::new(STREAM_TRACK))?;
4047 let mut frames: Vec<bytes::Bytes> = Vec::new();
4048 for _ in 0..2 {
4049 let mut group =
4050 tokio::time::timeout(std::time::Duration::from_secs(5), track.next_group())
4051 .await??
4052 .ok_or_else(|| anyhow!("next_group None"))?;
4053 let frame = tokio::time::timeout(std::time::Duration::from_secs(5), group.read_frame())
4054 .await??
4055 .ok_or_else(|| anyhow!("read_frame None"))?;
4056 frames.push(frame);
4057 }
4058
4059 use ml_dsa::Keypair;
4061 let mut roster = KeyedPqTrustStore::new();
4062 roster.bind(
4063 kid,
4064 &crate::node_identity::derive_mesh_mldsa_key(&host_ed).verifying_key(),
4065 );
4066 let enrolled = |k: &[u8; 32]| *k == kid;
4067
4068 let mut v = StreamVerifier::new(mac_key, topic.clone()).with_enc_key(enc_key);
4070 let got = verify_moq_frame_with_provenance(&mut v, &topic, &frames[0], &roster, &enrolled)?;
4071 assert!(matches!(&got[0], StreamPayload::Data(d) if d == b"hi"));
4072
4073 let empty = KeyedPqTrustStore::new();
4076 let none_enrolled = |_: &[u8; 32]| false;
4077 let mut v2 = StreamVerifier::new(mac_key, topic.clone()).with_enc_key(enc_key);
4078 assert!(verify_moq_frame_with_provenance(
4079 &mut v2,
4080 &topic,
4081 &frames[0],
4082 &empty,
4083 &none_enrolled
4084 )
4085 .is_err());
4086 Ok(())
4087 }
4088}