use crate::network::types::{SshConnectionState, SshInfo, SshVersion};
use log::debug;
pub(super) fn analyze_ssh(payload: &[u8], is_outgoing: bool) -> Option<SshInfo> {
if !is_likely_ssh(payload) {
return None;
}
let mut info = SshInfo {
version: None,
client_software: None,
server_software: None,
connection_state: SshConnectionState::Banner,
algorithms: Vec::new(),
auth_method: None,
};
let text = String::from_utf8_lossy(payload);
for line in text.lines() {
if let Some(banner_info) = parse_ssh_banner(line) {
if is_outgoing {
if info.client_software.is_none() {
info.client_software = Some(banner_info.software);
info.version = Some(banner_info.version);
}
} else {
if info.server_software.is_none() {
info.server_software = Some(banner_info.software);
info.version = Some(banner_info.version);
}
}
}
}
let packet_state = (0..payload.len().saturating_sub(5))
.filter(|&i| is_valid_ssh_packet_at_offset(payload, i))
.find_map(|i| ssh_msg_state(payload[i + 5]).map(|(state, label)| (i, state, label)));
if let Some((offset, state, label)) = packet_state {
info.connection_state = state;
debug!("SSH: Detected {} message at offset {}", label, offset);
} else if info.server_software.is_some() || info.client_software.is_some() {
info.connection_state = SshConnectionState::Banner;
}
if let Some(algorithms) = parse_kexinit_algorithms(payload) {
info.algorithms = algorithms;
}
debug!("SSH analysis result: {:?}", info);
Some(info)
}
fn ssh_msg_state(msg_type: u8) -> Option<(SshConnectionState, &'static str)> {
match msg_type {
20 => Some((SshConnectionState::KeyExchange, "KEXINIT")),
21 => Some((SshConnectionState::KeyExchange, "NEWKEYS")),
50 => Some((SshConnectionState::Authentication, "USERAUTH_REQUEST")),
51 => Some((SshConnectionState::Authentication, "USERAUTH_FAILURE")),
52 => Some((SshConnectionState::Established, "USERAUTH_SUCCESS")),
90..=127 => Some((SshConnectionState::Established, "connection protocol")),
_ => None,
}
}
pub(super) fn is_likely_ssh(payload: &[u8]) -> bool {
if payload.len() < 4 {
return false;
}
payload.starts_with(b"SSH-1.") ||
payload.starts_with(b"SSH-2.") ||
is_ssh_packet_structure(payload)
}
fn parse_ssh_banner(line: &str) -> Option<BannerInfo> {
if !line.starts_with("SSH-") {
return None;
}
let parts: Vec<&str> = line.splitn(3, '-').collect();
if parts.len() < 2 {
return None;
}
let version = match parts[1] {
"1.99" | "2.0" => SshVersion::V2,
v if v.starts_with("1.") => SshVersion::V1,
_ => SshVersion::V2, };
let software = if parts.len() >= 3 {
parts[2].trim().to_string()
} else {
"Unknown".to_string()
};
Some(BannerInfo { version, software })
}
fn is_ssh_packet_structure(payload: &[u8]) -> bool {
if payload.len() < 6 {
return false;
}
is_valid_ssh_packet_at_offset(payload, 0)
}
fn is_valid_ssh_packet_at_offset(payload: &[u8], offset: usize) -> bool {
if payload.len() < offset + 6 {
return false;
}
let packet_length = u32::from_be_bytes([
payload[offset],
payload[offset + 1],
payload[offset + 2],
payload[offset + 3],
]);
let padding_length = payload[offset + 4] as u32;
let msg_type = payload[offset + 5];
if !(8..=35000).contains(&packet_length) {
return false;
}
if padding_length < 4 {
return false;
}
if padding_length + 1 >= packet_length {
return false;
}
matches!(
msg_type,
1..=4 | 20..=21 | 50..=52 | 80 | 90..=100 )
}
fn parse_kexinit_algorithms(payload: &[u8]) -> Option<Vec<String>> {
let text = String::from_utf8_lossy(payload);
let mut algorithms = Vec::new();
let common_algos = [
"diffie-hellman-group14-sha256",
"ecdh-sha2-nistp256",
"aes128-ctr",
"aes256-ctr",
"aes128-gcm",
"aes256-gcm",
"ssh-rsa",
"ssh-ed25519",
"ecdsa-sha2-nistp256",
"hmac-sha2-256",
"hmac-sha2-512",
];
for algo in &common_algos {
if text.contains(algo) {
algorithms.push(algo.to_string());
}
}
if algorithms.is_empty() {
None
} else {
Some(algorithms)
}
}
struct BannerInfo {
version: SshVersion,
software: String,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_openssh_banner() {
let payload = b"SSH-2.0-OpenSSH_8.9p1 Ubuntu-3ubuntu0.1\r\n";
let info = analyze_ssh(payload, false).unwrap();
assert_eq!(info.version, Some(SshVersion::V2));
assert_eq!(
info.server_software.as_deref(),
Some("OpenSSH_8.9p1 Ubuntu-3ubuntu0.1")
);
assert_eq!(info.connection_state, SshConnectionState::Banner);
}
#[test]
fn test_putty_banner() {
let payload = b"SSH-2.0-PuTTY_Release_0.76\r\n";
let info = analyze_ssh(payload, false).unwrap();
assert_eq!(info.version, Some(SshVersion::V2));
assert_eq!(info.server_software.as_deref(), Some("PuTTY_Release_0.76"));
}
#[test]
fn test_ssh1_banner() {
let payload = b"SSH-1.99-libssh_0.8.9\r\n";
let info = analyze_ssh(payload, false).unwrap();
assert_eq!(info.version, Some(SshVersion::V2)); assert_eq!(info.server_software.as_deref(), Some("libssh_0.8.9"));
}
#[test]
fn test_kexinit_detection() {
let mut payload = vec![0, 0, 0, 100]; payload.push(10); payload.push(20); payload.extend_from_slice(&[0; 94]);
let info = analyze_ssh(&payload, false).unwrap();
assert_eq!(info.connection_state, SshConnectionState::KeyExchange);
}
#[test]
fn test_userauth_success() {
let mut payload = vec![0, 0, 0, 20]; payload.push(5); payload.push(52); payload.extend_from_slice(&[0; 14]);
let info = analyze_ssh(&payload, false).unwrap();
assert_eq!(info.connection_state, SshConnectionState::Established);
}
#[test]
fn test_non_ssh_payload() {
let payload = b"HTTP/1.1 200 OK\r\n";
assert!(analyze_ssh(payload, false).is_none());
}
#[test]
fn test_partial_ssh_banner() {
let payload = b"SSH-2.0-Open";
let info = analyze_ssh(payload, false).unwrap();
assert_eq!(info.version, Some(SshVersion::V2));
}
#[test]
fn test_ssh_banner_parsing() {
assert!(parse_ssh_banner("SSH-2.0-OpenSSH_8.9").is_some());
assert!(parse_ssh_banner("SSH-1.5-oldversion").is_some());
assert!(parse_ssh_banner("HTTP/1.1 200 OK").is_none());
assert!(parse_ssh_banner("").is_none());
}
#[test]
fn test_is_likely_ssh() {
assert!(is_likely_ssh(b"SSH-2.0-OpenSSH"));
assert!(is_likely_ssh(b"SSH-1.99-libssh"));
assert!(!is_likely_ssh(b"HTTP/1.1"));
assert!(!is_likely_ssh(b"GET /"));
assert!(!is_likely_ssh(b""));
}
#[test]
fn test_ssh_packet_structure() {
let valid_packet = vec![0, 0, 0, 20, 5, 50, 0, 0, 0, 0];
assert!(is_ssh_packet_structure(&valid_packet));
let kexinit_packet = vec![0, 0, 0, 20, 5, 20, 0, 0, 0, 0];
assert!(is_ssh_packet_structure(&kexinit_packet));
let channel_packet = vec![0, 0, 0, 20, 5, 90, 0, 0, 0, 0];
assert!(is_ssh_packet_structure(&channel_packet));
let bad_padding = vec![0, 0, 0, 20, 2, 50, 0, 0, 0, 0];
assert!(!is_ssh_packet_structure(&bad_padding));
let bad_msg_type = vec![0, 0, 0, 20, 5, 70, 0, 0, 0, 0];
assert!(!is_ssh_packet_structure(&bad_msg_type));
let too_small = vec![0, 0, 0, 4, 4, 50, 0, 0, 0, 0];
assert!(!is_ssh_packet_structure(&too_small));
let bad_ratio = vec![0, 0, 0, 10, 10, 50, 0, 0, 0, 0];
assert!(!is_ssh_packet_structure(&bad_ratio));
let invalid_packet = vec![255, 255, 255, 255, 255, 255];
assert!(!is_ssh_packet_structure(&invalid_packet));
}
#[test]
fn test_various_ssh_implementations() {
let test_cases = vec![
("SSH-2.0-OpenSSH_7.4", SshVersion::V2, "OpenSSH_7.4"),
("SSH-2.0-libssh2_1.9.0", SshVersion::V2, "libssh2_1.9.0"),
(
"SSH-2.0-WinSCP_release_5.19.6",
SshVersion::V2,
"WinSCP_release_5.19.6",
),
("SSH-2.0-Paramiko_2.8.0", SshVersion::V2, "Paramiko_2.8.0"),
("SSH-1.99-Cisco-1.25", SshVersion::V2, "Cisco-1.25"), ("SSH-1.5-1.2.27", SshVersion::V1, "1.2.27"),
];
for (banner, expected_version, expected_software) in test_cases {
let payload = format!("{}\r\n", banner).into_bytes();
let info = analyze_ssh(&payload, false).unwrap();
assert_eq!(
info.version,
Some(expected_version),
"Failed for banner: {}",
banner
);
assert_eq!(
info.server_software.as_deref(),
Some(expected_software),
"Failed for banner: {}",
banner
);
assert_eq!(info.connection_state, SshConnectionState::Banner);
}
}
#[test]
fn test_ssh_connection_states() {
let mut kexinit_packet = vec![0, 0, 0, 100, 10, 20]; kexinit_packet.extend(vec![0; 94]); let info = analyze_ssh(&kexinit_packet, false).unwrap();
assert_eq!(info.connection_state, SshConnectionState::KeyExchange);
let mut userauth_packet = vec![0, 0, 0, 50, 8, 50]; userauth_packet.extend(vec![0; 44]);
let info = analyze_ssh(&userauth_packet, false).unwrap();
assert_eq!(info.connection_state, SshConnectionState::Authentication);
let mut success_packet = vec![0, 0, 0, 20, 5, 52]; success_packet.extend(vec![0; 14]);
let info = analyze_ssh(&success_packet, false).unwrap();
assert_eq!(info.connection_state, SshConnectionState::Established);
let mut conn_packet = vec![0, 0, 0, 30, 6, 95]; conn_packet.extend(vec![0; 24]);
let info = analyze_ssh(&conn_packet, false).unwrap();
assert_eq!(info.connection_state, SshConnectionState::Established);
}
#[test]
fn test_malformed_ssh_packets() {
assert!(analyze_ssh(&[], false).is_none());
assert!(analyze_ssh(&[1, 2, 3], false).is_none());
let invalid_banner = b"HTTP/1.1 200 OK\r\n";
assert!(analyze_ssh(invalid_banner, false).is_none());
let malformed_banner = b"SSH-\r\n";
assert!(analyze_ssh(malformed_banner, false).is_none());
}
#[test]
fn test_algorithm_detection() {
let payload_with_algos =
b"SSH-2.0-test\r\nsome data aes128-ctr ssh-ed25519 hmac-sha2-256 more data";
let info = analyze_ssh(payload_with_algos, false).unwrap();
assert!(!info.algorithms.is_empty());
assert!(info.algorithms.iter().any(|a| a.contains("aes128-ctr")));
}
#[test]
fn test_edge_cases() {
let minimal_banner = b"SSH-2.0\r\n";
let info = analyze_ssh(minimal_banner, false);
assert!(info.is_some());
let long_banner = format!("SSH-2.0-{}\r\n", "x".repeat(200)).into_bytes();
let info = analyze_ssh(&long_banner, false);
assert!(info.is_some());
let special_banner = b"SSH-2.0-OpenSSH_8.9p1-Ubuntu-3~20.04.3\r\n";
let info = analyze_ssh(special_banner, false).unwrap();
assert_eq!(info.version, Some(SshVersion::V2));
}
#[test]
fn test_client_server_software_distinction() {
let server_banner = b"SSH-2.0-OpenSSH_9.9\r\n";
let server_info = analyze_ssh(server_banner, false).unwrap();
assert!(server_info.server_software.is_some());
assert!(server_info.client_software.is_none());
assert_eq!(server_info.server_software.as_ref().unwrap(), "OpenSSH_9.9");
let client_banner = b"SSH-2.0-OpenSSH_9.8\r\n";
let client_info = analyze_ssh(client_banner, true).unwrap();
assert!(client_info.client_software.is_some());
assert!(client_info.server_software.is_none());
assert_eq!(client_info.client_software.as_ref().unwrap(), "OpenSSH_9.8");
}
#[test]
fn test_mixed_content() {
let mixed_payload = b"SSH-2.0-OpenSSH_8.9\r\n\x00\x00\x00\x14\x05\x32additional data here";
let info = analyze_ssh(mixed_payload, false).unwrap();
assert_eq!(info.version, Some(SshVersion::V2));
assert!(info.server_software.is_some());
assert_eq!(info.connection_state, SshConnectionState::Authentication);
}
#[test]
fn test_packet_state_at_last_window() {
let payload = b"SSH-2.0-Test\r\n\x00\x00\x00\x0c\x04\x14";
assert_eq!(payload.len(), 20);
let info = analyze_ssh(payload, false).unwrap();
assert!(info.server_software.is_some());
assert_eq!(info.connection_state, SshConnectionState::KeyExchange);
}
}