use std::net::IpAddr; use std::time::Duration; use tokio::io::AsyncReadExt; use tokio::net::TcpStream; const HEADER_TIMEOUT: Duration = Duration::from_secs(5); const MAX_V1_HEADER: usize = 107; #[derive(Debug, PartialEq, Eq)] pub(crate) struct Malformed; /// Consumes a PROXY protocol v1 header, if the stream starts with one, and /// returns the client address it names. Leaves the stream untouched otherwise, /// and when no byte arrives in time, since some ssh clients wait for the server /// banner before they send their own. pub(crate) async fn read_v1(stream: &mut TcpStream) -> Result, Malformed> { let mut first = [0u8; 1]; match tokio::time::timeout(HEADER_TIMEOUT, stream.peek(&mut first)).await { Ok(Ok(1)) if first[0] == b'P' => {} _ => return Ok(None), } let mut line = Vec::with_capacity(MAX_V1_HEADER); let read = async { while !line.ends_with(b"\r\n") && line.len() < MAX_V1_HEADER { line.push(stream.read_u8().await.map_err(|_| Malformed)?); } Ok(()) }; tokio::time::timeout(HEADER_TIMEOUT, read) .await .map_err(|_| Malformed)??; parse_v1(&line) } fn parse_v1(line: &[u8]) -> Result, Malformed> { let line = std::str::from_utf8(line) .ok() .and_then(|line| line.strip_suffix("\r\n")) .ok_or(Malformed)?; let mut fields = line.split(' '); match (fields.next(), fields.next(), fields.next()) { (Some("PROXY"), Some("UNKNOWN"), _) => Ok(None), (Some("PROXY"), Some(family @ ("TCP4" | "TCP6")), Some(source)) => { let source = source.parse::().map_err(|_| Malformed)?; match (family, source) { ("TCP4", IpAddr::V4(_)) | ("TCP6", IpAddr::V6(_)) => { Ok(Some(source.to_canonical())) } _ => Err(Malformed), } } _ => Err(Malformed), } } #[cfg(test)] mod tests { use tokio::io::AsyncWriteExt; use super::*; fn ip(value: &str) -> Option { Some(value.parse().unwrap()) } #[test] fn parse_v1_reads_the_source_address() { assert_eq!( parse_v1(b"PROXY TCP4 198.51.100.4 203.0.113.1 51234 22\r\n"), Ok(ip("198.51.100.4")) ); assert_eq!( parse_v1(b"PROXY TCP6 2001:db8::4 2001:db8::1 51234 22\r\n"), Ok(ip("2001:db8::4")) ); assert_eq!(parse_v1(b"PROXY UNKNOWN\r\n"), Ok(None)); } #[test] fn parse_v1_rejects_malformed_headers() { for line in [ &b"PROXY TCP4 198.51.100.4 203.0.113.1 51234 22"[..], b"PROXY TCP4 2001:db8::4 2001:db8::1 51234 22\r\n", b"PROXY TCP4 nope 203.0.113.1 51234 22\r\n", b"PROXY UDP4 198.51.100.4 203.0.113.1 51234 22\r\n", b"PRAXY TCP4 198.51.100.4 203.0.113.1 51234 22\r\n", ] { assert_eq!(parse_v1(line), Err(Malformed), "{line:?}"); } } async fn pair(sent: &'static [u8]) -> (TcpStream, Vec) { let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); let addr = listener.local_addr().unwrap(); let mut client = TcpStream::connect(addr).await.unwrap(); client.write_all(sent).await.unwrap(); client.shutdown().await.unwrap(); (listener.accept().await.unwrap().0, Vec::new()) } #[tokio::test] async fn read_v1_consumes_only_the_header() { let (mut stream, mut rest) = pair(b"PROXY TCP4 198.51.100.4 203.0.113.1 51234 22\r\nSSH-2.0-OpenSSH\r\n").await; assert_eq!(read_v1(&mut stream).await, Ok(ip("198.51.100.4"))); stream.read_to_end(&mut rest).await.unwrap(); assert_eq!(rest, b"SSH-2.0-OpenSSH\r\n"); } #[tokio::test] async fn read_v1_leaves_a_plain_ssh_stream_alone() { let (mut stream, mut rest) = pair(b"SSH-2.0-OpenSSH\r\n").await; assert_eq!(read_v1(&mut stream).await, Ok(None)); stream.read_to_end(&mut rest).await.unwrap(); assert_eq!(rest, b"SSH-2.0-OpenSSH\r\n"); } }