diff --git a/rs/moq-net/src/lite/session.rs b/rs/moq-net/src/lite/session.rs index e6b6b4a4254..c64069ba730 100644 --- a/rs/moq-net/src/lite/session.rs +++ b/rs/moq-net/src/lite/session.rs @@ -529,3 +529,36 @@ impl SendGoaway { } } } + +#[cfg(test)] +mod tests { + use super::*; + + /// A SETUP read on the session's own Setup Stream (the client side) that repeats a + /// Parameter ID fails to decode, so nothing can satisfy the claimed slot. + #[tokio::test(start_paused = true)] + async fn repeated_setup_parameter_closes_the_session() { + // SETUP type, five-byte message, then two empty parameters with id 0. + let session = crate::lite::test_transport::ScriptedSession::eof(Vec::new()) + .with_incoming_unis(vec![vec![1, 5, 2, 0, 0, 0, 0]]); + let log = session.log.clone(); + let mut started = start(Config { + runtime: crate::time::Clock::tokio(), + session, + setup_stream: None, + publish: None, + subscribe: None, + peer_hop: None, + version: Version::Lite05, + our_setup: Setup::default(), + peer_setup: None, + }) + .unwrap(); + let _ = started.driver.poll(&kio::Waiter::noop()); + assert!( + log.closes() + .iter() + .any(|(code, _)| *code == SessionError::ProtocolViolation.to_code()) + ); + } +} diff --git a/rs/moq-net/src/lite/setup.rs b/rs/moq-net/src/lite/setup.rs index 53810df0476..3bfe511e253 100644 --- a/rs/moq-net/src/lite/setup.rs +++ b/rs/moq-net/src/lite/setup.rs @@ -257,12 +257,30 @@ impl Message for Setup { /// stream) wait on this before deciding what to do. Cheap to clone: every handle /// shares the same slot. #[derive(Clone, Default)] -pub(crate) struct PeerSetup(kio::Shared>); +pub(crate) struct PeerSetup(kio::Shared); + +#[derive(Default)] +struct PeerSetupState { + seen: bool, + setup: Option, +} impl PeerSetup { /// Record the peer's SETUP. pub fn set(&self, setup: Setup) { - *self.0.lock() = Some(setup); + let mut state = self.0.lock(); + state.seen = true; + state.setup = Some(setup); + } + + /// Claim the Setup Stream before decoding its body, refusing any second stream. + pub fn claim(&self) -> Result<(), crate::Error> { + let mut state = self.0.lock(); + if state.seen { + return Err(crate::Error::ProtocolViolation); + } + state.seen = true; + Ok(()) } /// Poll for the peer's advertised probe level, waiting until its SETUP arrives. @@ -289,13 +307,13 @@ impl PeerSetup { /// driver. fn poll_get(&self, waiter: &kio::Waiter, f: impl FnOnce(&Setup) -> T) -> std::task::Poll { let slot = std::task::ready!(self.0.poll(waiter, |setup| { - if setup.is_some() { + if setup.setup.is_some() { std::task::Poll::Ready(()) } else { std::task::Poll::Pending } })); - std::task::Poll::Ready(f(slot.as_ref().expect("waited for Some"))) + std::task::Poll::Ready(f(slot.setup.as_ref().expect("waited for Some"))) } } diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index a50a331db20..1579aa0d4e9 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -675,6 +675,12 @@ impl kio::Task for UniServe { fn poll(&mut self, waiter: &kio::Waiter) -> Poll<()> { if let Err(err) = ready!(self.poll_serve(waiter)) { tracing::debug!(%err, "error running uni stream"); + if matches!(err, Error::ProtocolViolation) { + self.subscriber + .session + .clone() + .close(crate::SessionError::ProtocolViolation.to_code(), &err.to_string()); + } } Poll::Ready(()) } @@ -703,7 +709,12 @@ impl UniServe { }; self.state = match kind { lite::DataType::Group => UniState::Group(GroupRecv::new(self.subscriber.clone(), reader)), - lite::DataType::Setup => UniState::Setup { reader }, + lite::DataType::Setup => { + if self.subscriber.version.has_setup_stream() { + self.subscriber.peer_setup.claim()?; + } + UniState::Setup { reader } + } }; } UniState::Setup { reader } => { @@ -721,8 +732,9 @@ impl UniServe { return Poll::Ready(Ok(())); } Err(err) => { + tracing::debug!(%err, "failed to read peer setup"); self.abort(&err); - return Poll::Ready(Ok(())); + return Poll::Ready(Err(Error::ProtocolViolation)); } } } diff --git a/rs/moq-net/src/server.rs b/rs/moq-net/src/server.rs index 2c96e1d84a3..21d9efd6dd6 100644 --- a/rs/moq-net/src/server.rs +++ b/rs/moq-net/src/server.rs @@ -1182,6 +1182,31 @@ mod tests { assert_eq!(request.path(), ""); } + #[tokio::test(start_paused = true)] + async fn repeated_lite_setup_parameter_closes_the_session() { + // SETUP type, five-byte message, then two empty parameters with id 0. + let session = FakeSession::new(ALPN_LITE_05, [vec![1, 5, 2, 0, 0, 0, 0]]); + let result = Server::new() + .accept_request(tokio::time::Instant::now().into_std(), session.clone()) + .await; + assert!(result.is_err()); + assert_eq!(session.closed(), Some(SessionError::ProtocolViolation.to_code())); + } + + #[tokio::test(start_paused = true)] + async fn accepted_lite_setup_refuses_a_second_setup_stream() { + let session = FakeSession::new(ALPN_LITE_05, [lite05_setup(None, None, None)]); + let transport = session.clone(); + let request = Server::new() + .accept_request(tokio::time::Instant::now().into_std(), session) + .await + .unwrap(); + let (_session, mut driver) = request.ok().await.unwrap(); + transport.uni.lock().unwrap().push_back(vec![1]); + let _ = driver.poll(tokio::time::Instant::now().into_std(), &kio::Waiter::noop()); + assert_eq!(transport.closed(), Some(SessionError::ProtocolViolation.to_code())); + } + #[tokio::test(start_paused = true)] async fn accept_request_reads_lite05_role() { let session = FakeSession::new(