use std::net::SocketAddr;
use std::time::Duration;
use async_trait::async_trait;
use tokio::io::{AsyncReadExt, AsyncWriteExt, BufReader};
use tokio::net::TcpStream;
use tokio::time::timeout;
use super::analyzer::{Analyzer, PortContext};
use super::model::{Confidence, Evidence, SourceId};
use super::response::{Collected, ResponseSet};
const SSH_PORTS: &[u16] = &[22, 2222];
const CLIENT_ID: &[u8] = b"SSH-2.0-Zond_1.0\r\n";
const EXCHANGE_TIMEOUT: Duration = Duration::from_secs(3);
const MAX_PACKET_LEN: usize = 35_000;
const MAX_ID_LINE: usize = 255;
const SSH_MSG_KEXINIT: u8 = 20;
pub struct SshAnalyzer;
#[async_trait]
impl Analyzer for SshAnalyzer {
fn id(&self) -> SourceId {
SourceId::Ssh
}
fn interested(&self, ctx: &PortContext) -> bool {
ctx.tunnel.is_none() && ctx.addr.is_some() && SSH_PORTS.contains(&ctx.port)
}
async fn collect(&self, ctx: &PortContext) -> Collected {
let Some(addr) = ctx.addr else {
return Collected::default();
};
match timeout(EXCHANGE_TIMEOUT, kexinit_exchange(addr)).await {
Ok(Some(packet)) => Collected {
frames: vec![packet],
},
_ => Collected::default(),
}
}
fn analyze(
&self,
_ctx: &PortContext,
_responses: &ResponseSet,
collected: &Collected,
) -> Vec<Evidence> {
let Some(kexinit) = collected.frames.first() else {
return Vec::new();
};
let Some(host_key_algorithms) = server_host_key_algorithms(kexinit) else {
return Vec::new();
};
let mut evidence = Evidence::new(SourceId::Ssh, Confidence::Strong).with_service("ssh");
if !host_key_algorithms.is_empty() {
evidence = evidence.with_extrainfo(format!("hostkey {host_key_algorithms}"));
}
vec![evidence]
}
}
async fn kexinit_exchange(addr: SocketAddr) -> Option<Vec<u8>> {
let stream = TcpStream::connect(addr).await.ok()?;
let mut reader = BufReader::new(stream);
reader.write_all(CLIENT_ID).await.ok()?;
reader.flush().await.ok()?;
let id_line = read_id_line(&mut reader).await?;
if !id_line.starts_with(b"SSH-") {
return None;
}
read_packet_payload(&mut reader).await
}
async fn read_id_line<R>(reader: &mut R) -> Option<Vec<u8>>
where
R: AsyncReadExt + Unpin,
{
let mut line = Vec::with_capacity(64);
let mut byte = [0u8; 1];
while line.len() < MAX_ID_LINE {
let n = reader.read(&mut byte).await.ok()?;
if n == 0 {
return None; }
if byte[0] == b'\n' {
if line.last() == Some(&b'\r') {
line.pop();
}
return Some(line);
}
line.push(byte[0]);
}
None }
async fn read_packet_payload<R>(reader: &mut R) -> Option<Vec<u8>>
where
R: AsyncReadExt + Unpin,
{
let mut length = [0u8; 4];
reader.read_exact(&mut length).await.ok()?;
let packet_length = u32::from_be_bytes(length) as usize;
if !(2..=MAX_PACKET_LEN).contains(&packet_length) {
return None;
}
let mut packet = vec![0u8; packet_length];
reader.read_exact(&mut packet).await.ok()?;
let padding_length = packet[0] as usize;
let payload_end = packet_length.checked_sub(padding_length)?;
if payload_end < 1 {
return None; }
Some(packet[1..payload_end].to_vec())
}
fn server_host_key_algorithms(payload: &[u8]) -> Option<String> {
if payload.first().copied()? != SSH_MSG_KEXINIT {
return None;
}
let mut cursor = 1 + 16;
skip_name_list(payload, &mut cursor)?;
read_name_list(payload, &mut cursor)
}
fn read_name_list(buf: &[u8], cursor: &mut usize) -> Option<String> {
let start = *cursor;
let len_end = start.checked_add(4)?;
let len = u32::from_be_bytes(buf.get(start..len_end)?.try_into().ok()?) as usize;
let data_end = len_end.checked_add(len)?;
let data = buf.get(len_end..data_end)?;
*cursor = data_end;
Some(String::from_utf8_lossy(data).into_owned())
}
fn skip_name_list(buf: &[u8], cursor: &mut usize) -> Option<()> {
let len_end = cursor.checked_add(4)?;
let len = u32::from_be_bytes(buf.get(*cursor..len_end)?.try_into().ok()?) as usize;
*cursor = len_end.checked_add(len)?;
(*cursor <= buf.len()).then_some(())
}
#[cfg(test)]
mod tests {
use super::*;
use proptest::prelude::*;
use tokio::io::AsyncWriteExt;
use tokio::net::TcpListener;
fn name_list(s: &str) -> Vec<u8> {
let mut out = (s.len() as u32).to_be_bytes().to_vec();
out.extend_from_slice(s.as_bytes());
out
}
fn kexinit_payload(kex: &str, host_key: &str) -> Vec<u8> {
let mut p = vec![SSH_MSG_KEXINIT];
p.extend_from_slice(&[0u8; 16]); p.extend_from_slice(&name_list(kex));
p.extend_from_slice(&name_list(host_key));
for _ in 0..8 {
p.extend_from_slice(&name_list("")); }
p.push(0); p.extend_from_slice(&0u32.to_be_bytes()); p
}
fn frame_packet(payload: &[u8]) -> Vec<u8> {
let mut padding = 8 - ((1 + payload.len()) % 8);
if padding < 4 {
padding += 8;
}
let packet_length = 1 + payload.len() + padding;
let mut out = (packet_length as u32).to_be_bytes().to_vec();
out.push(padding as u8);
out.extend_from_slice(payload);
out.extend(std::iter::repeat_n(0u8, padding));
out
}
#[test]
fn parses_host_key_algorithms_from_a_kexinit() {
let payload = kexinit_payload(
"curve25519-sha256,ecdh-sha2-nistp256",
"ssh-ed25519,rsa-sha2-512",
);
assert_eq!(
server_host_key_algorithms(&payload).as_deref(),
Some("ssh-ed25519,rsa-sha2-512")
);
}
#[test]
fn rejects_a_non_kexinit_message() {
let mut payload = kexinit_payload("kex", "keys");
payload[0] = 21; assert!(server_host_key_algorithms(&payload).is_none());
}
#[test]
fn truncated_name_list_is_rejected_not_panicked() {
let mut payload = vec![SSH_MSG_KEXINIT];
payload.extend_from_slice(&[0u8; 16]);
payload.extend_from_slice(&name_list("kex"));
payload.extend_from_slice(&1000u32.to_be_bytes()); payload.extend_from_slice(b"short"); assert!(server_host_key_algorithms(&payload).is_none());
}
#[tokio::test]
async fn read_packet_payload_rejects_an_over_long_length() {
let (client, mut server) = tokio::io::duplex(64);
tokio::spawn(async move {
let _ = server.write_all(&(u32::MAX).to_be_bytes()).await;
});
let mut reader = BufReader::new(client);
assert!(read_packet_payload(&mut reader).await.is_none());
}
#[tokio::test]
async fn collect_drives_the_exchange_against_a_mock_server_end_to_end() {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
tokio::spawn(async move {
let (mut sock, _) = listener.accept().await.unwrap();
sock.write_all(b"SSH-2.0-OpenSSH_9.6p1\r\n").await.unwrap();
let packet = frame_packet(&kexinit_payload("curve25519-sha256", "ssh-ed25519"));
sock.write_all(&packet).await.unwrap();
let mut buf = [0u8; 64];
let _ = sock.read(&mut buf).await;
});
let ctx = PortContext {
port: 22,
addr: Some(addr),
tunnel: None,
};
assert!(SshAnalyzer.interested(&ctx));
let collected = SshAnalyzer.collect(&ctx).await;
let evidence = SshAnalyzer.analyze(&ctx, &ResponseSet::default(), &collected);
assert_eq!(evidence.len(), 1);
assert_eq!(evidence[0].service.as_deref(), Some("ssh"));
assert_eq!(evidence[0].confidence, Confidence::Strong);
assert_eq!(
evidence[0].extrainfo.as_deref(),
Some("hostkey ssh-ed25519")
);
}
proptest! {
#[test]
fn kexinit_parser_never_panics_on_arbitrary_bytes(
bytes in proptest::collection::vec(any::<u8>(), 0..4096)
) {
let _ = server_host_key_algorithms(&bytes);
}
#[test]
fn kexinit_name_list_cursor_survives_fuzzed_lengths(
tail in proptest::collection::vec(any::<u8>(), 0..512)
) {
let mut payload = vec![SSH_MSG_KEXINIT];
payload.extend_from_slice(&[0u8; 16]);
payload.extend_from_slice(&tail);
let _ = server_host_key_algorithms(&payload);
}
}
#[tokio::test]
async fn not_interested_off_ssh_ports_or_without_an_address() {
let no_addr = PortContext {
port: 22,
addr: None,
tunnel: None,
};
assert!(!SshAnalyzer.interested(&no_addr));
let wrong_port = PortContext {
port: 80,
addr: Some("127.0.0.1:80".parse().unwrap()),
tunnel: None,
};
assert!(!SshAnalyzer.interested(&wrong_port));
}
}