//! Session frame reader. Frames travel inside the TLS 1.3 stream, so there is no per frame //! encryption: a dedicated task retains partial frames across command/timer selection and //! enforces strictly increasing sequence numbers. use anyhow::{Result, anyhow}; use super::RawPacket; /// A dedicated reader retains partial frames across command/timer selection. /// Dropping a session cancels its reader and releases the socket half. pub struct Reader { receiver: tokio::sync::mpsc::Receiver>, task: tokio::task::JoinHandle<()>, } impl Reader { pub fn new(mut stream: impl tokio::io::AsyncRead + Unpin + Send + 'static) -> Self { let (sender, receiver) = tokio::sync::mpsc::channel(32); let task = tokio::spawn(async move { // HELLO was 0 and SESSION was 1. let mut expected = 2u32; loop { let result = super::read(&mut stream).await.and_then(|packet| { if packet.sequence != expected { return Err(anyhow!("replayed or reordered control packet")); } expected = expected .checked_add(1) .ok_or_else(|| anyhow!("session sequence exhausted"))?; Ok(packet) }); let failed = result.is_err(); if sender.send(result).await.is_err() || failed { break; } } }); Self { receiver, task } } pub async fn next(&mut self) -> Result { self.receiver .recv() .await .ok_or_else(|| anyhow!("gateway reader stopped"))? } } impl Drop for Reader { fn drop(&mut self) { self.task.abort(); } } #[cfg(test)] mod tests { use super::*; use tokio::io::AsyncWriteExt; use tokio::time::{Duration, timeout}; fn server_frame(pid: u16, seq: u32, payload: &[u8]) -> Vec { let mut seq = seq; super::super::encode_frame(pid, &mut seq, payload) } #[tokio::test] async fn cancelling_wait_retains_partial_control_frame() { let (reader, mut writer) = tokio::io::duplex(256); let mut reader = Reader::new(reader); let frame = server_frame(5, 2, b"protobuf"); writer.write_all(&frame[..5]).await.unwrap(); assert!( timeout(Duration::from_millis(5), reader.next()) .await .is_err() ); writer.write_all(&frame[5..]).await.unwrap(); let packet = timeout(Duration::from_secs(1), reader.next()) .await .unwrap() .unwrap(); assert_eq!(packet.payload, b"protobuf"); } #[tokio::test] async fn replayed_control_sequence_is_rejected() { let (reader, mut writer) = tokio::io::duplex(256); let mut reader = Reader::new(reader); let frame = server_frame(5, 2, b""); writer.write_all(&frame).await.unwrap(); reader.next().await.unwrap(); writer.write_all(&frame).await.unwrap(); assert!(reader.next().await.is_err()); } #[tokio::test] async fn legacy_encrypted_flag_is_rejected() { let (reader, mut writer) = tokio::io::duplex(256); let mut reader = Reader::new(reader); let mut frame = server_frame(5, 2, b"0123456789abcdef"); frame[2..4].copy_from_slice(&2u16.to_be_bytes()); writer.write_all(&frame).await.unwrap(); assert!(reader.next().await.is_err()); } }