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");
}
}