Replace the custom X25519/HKDF/ChaCha20 TCP layer with rustls (TLS 1.3 only, ALPN vnox-lnex/3, no plaintext or fallback). Add a trust store (pin, trust on first use, public CA), block changed fingerprints and identities, bind the Ed25519 auth signature to the TLS exporter, add RU/EN trust dialog and update the interop test and e2e voice tool.
99 lines
3.5 KiB
Rust
99 lines
3.5 KiB
Rust
//! 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<Result<RawPacket>>,
|
|
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<RawPacket> {
|
|
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<u8> {
|
|
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());
|
|
}
|
|
}
|