use proptest::prelude::*;
use rayon::prelude::*;
use super::db::SignatureDb;
use super::matcher::Signature;
use super::prefilter::{LiteralPrefilter, Prefilter};
use super::response::{Collected, ResponseSet, TlsInfo};
use super::{Analyzer, BannerRegexAnalyzer, PortContext, ServiceVerdict, TlsCertAnalyzer, Tunnel};
use crate::model::confidence::Confidence;
fn signatures_with_examples() -> (Vec<Signature>, Vec<Option<String>>) {
let defs = SignatureDb::embedded_definitions();
let mut signatures = Vec::new();
let mut examples = Vec::new();
for def in &defs {
for rule in &def.r#match {
signatures.push(Signature::new(&def.service.name, rule));
examples.push(rule.example.clone().filter(|e| !e.is_empty()));
}
}
(signatures, examples)
}
#[test]
fn every_signature_matches_its_example() {
let (signatures, examples) = signatures_with_examples();
let mut mismatches: Vec<String> = signatures
.par_iter()
.zip(examples.par_iter())
.filter_map(|(signature, example)| {
let example = example.as_deref()?;
signature
.identify(example, crate::model::host::OsSource::ServiceBanner)
.is_none()
.then(|| format!("example={example:?} pattern={:?}", signature.pattern()))
})
.collect();
mismatches.sort();
assert!(
mismatches.is_empty(),
"{} examples do not match their own rule. A pattern that fails its own \
example fails the banner it was written from too.\nFirst:\n{}",
mismatches.len(),
mismatches
.iter()
.take(20)
.cloned()
.collect::<Vec<_>>()
.join("\n"),
);
}
#[test]
fn prefilter_never_drops_a_matching_signature() {
let (signatures, examples) = signatures_with_examples();
let prefilter = LiteralPrefilter::build(&signatures);
let violations: usize = signatures
.par_iter()
.zip(examples.par_iter())
.enumerate()
.filter(|(idx, (signature, example))| {
let Some(example) = example.as_deref() else {
return false;
};
if signature
.identify(example, crate::model::host::OsSource::ServiceBanner)
.is_none()
{
return false; }
!prefilter.candidates(example).contains(idx)
})
.count();
assert_eq!(
violations,
0,
"prefilter dropped {}",
crate::logging::counted(
violations as u128,
"matching signature",
"matching signatures"
)
);
}
#[test]
fn only_a_pattern_with_no_literal_is_matched_against_every_response() {
const KNOWN_ALWAYS_RUN: usize = 12;
let (signatures, _) = signatures_with_examples();
let prefilter = LiteralPrefilter::build(&signatures);
let always: Vec<&str> = prefilter
.always_run()
.iter()
.map(|&idx| signatures[idx].pattern())
.collect();
assert!(
always.len() <= KNOWN_ALWAYS_RUN,
"{} of {} signatures always run:\n{}",
always.len(),
signatures.len(),
always.join("\n")
);
}
#[test]
fn one_reply_is_one_witness() {
use crate::model::host::{Host, OsSource};
use std::collections::BTreeSet;
let (signatures, examples) = signatures_with_examples();
let read_as = [
OsSource::ServiceBanner,
OsSource::SnmpAgent,
OsSource::MdnsResponder,
];
let mut misfiled: Vec<String> = signatures
.par_iter()
.zip(examples.par_iter())
.filter_map(|(signature, example)| Some((signature, example.as_deref()?)))
.flat_map_iter(|(signature, example)| {
read_as.into_iter().filter_map(move |source| {
let matched = signature.identify(example, source)?;
let mut host = Host::new("192.0.2.1".parse().expect("a literal address"));
super::AboutTheHost {
os: matched.os.into_iter().collect(),
hardware: matched.hardware,
names: Vec::new(),
}
.apply(&mut host);
let filed: BTreeSet<OsSource> =
host.os_evidence().map(|evidence| evidence.source).collect();
filed
.iter()
.any(|other| *other != source)
.then(|| format!("{example:?} read as {source:?} left {filed:?}"))
})
})
.collect();
misfiled.sort();
assert!(
misfiled.is_empty(),
"{} left a reading under a source they were not read as:\n{}",
crate::logging::counted(misfiled.len() as u128, "example", "examples"),
misfiled
.iter()
.take(20)
.cloned()
.collect::<Vec<_>>()
.join("\n"),
);
}
#[test]
fn golden_cases_resolve_end_to_end() {
struct Case {
port: u16,
response: &'static str,
service: &'static str,
product: Option<&'static str>,
version: Option<&'static str>,
}
let cases = [
Case {
port: 22,
response: "SSH-2.0-OpenSSH_9.6p1 Debian-3",
service: "ssh",
product: Some("OpenSSH"),
version: Some("9.6p1"),
},
Case {
port: 22,
response: "SSH-2.0-dropbear_2022.83",
service: "ssh",
product: Some("dropbear"),
version: Some("2022.83"),
},
Case {
port: 80,
response: "HTTP/1.1 200 OK\r\nServer: nginx/1.25.3\r\nContent-Type: text/html\r\n\r\n",
service: "http",
product: Some("nginx"),
version: Some("1.25.3"),
},
];
for case in cases {
let responses = ResponseSet::from_banners(vec![case.response.to_string()]);
let evidence = BannerRegexAnalyzer.analyze(
&PortContext {
port: case.port,
protocol: crate::model::port::Protocol::Tcp,
addr: None,
tunnel: None,
speaks_http: false,
detection: crate::config::ServiceDetection::default(),
host_name: None,
},
&responses,
&Collected::default(),
);
let verdict = ServiceVerdict::resolve(evidence);
assert_eq!(
verdict.service.as_deref(),
Some(case.service),
"service for {:?}",
case.response
);
if let Some(product) = case.product {
assert_eq!(
verdict.product.as_deref(),
Some(product),
"product for {:?}",
case.response
);
}
if let Some(version) = case.version {
assert_eq!(
verdict.version.as_deref(),
Some(version),
"version for {:?}",
case.response
);
}
}
}
#[test]
fn non_standard_port_is_identified_via_global_fallback() {
let port = 51987;
assert!(
SignatureDb::global().signatures_for_port(port).is_empty(),
"test assumes port {port} is unclaimed"
);
let responses = ResponseSet::from_banners(vec!["SSH-2.0-OpenSSH_9.6p1".to_string()]);
let evidence = BannerRegexAnalyzer.analyze(
&PortContext {
protocol: crate::model::port::Protocol::Tcp,
port,
addr: None,
tunnel: None,
speaks_http: false,
detection: crate::config::ServiceDetection::default(),
host_name: None,
},
&responses,
&Collected::default(),
);
assert!(
evidence.iter().all(|e| !e.port_confirmed),
"global-fallback evidence must not be port-confirmed"
);
let verdict = ServiceVerdict::resolve(evidence);
assert_eq!(verdict.service.as_deref(), Some("ssh"));
assert_eq!(verdict.product.as_deref(), Some("OpenSSH"));
assert_eq!(verdict.version.as_deref(), Some("9.6p1"));
}
proptest! {
#[test]
fn banner_pipeline_never_panics_on_adversarial_input(banner in "(?s).*") {
let responses = ResponseSet::from_banners(vec![banner]);
let ctx = PortContext {
port: 80,
protocol: crate::model::port::Protocol::Tcp,
addr: None,
tunnel: None,
speaks_http: false,
detection: crate::config::ServiceDetection::default(),
host_name: None,
};
let evidence = BannerRegexAnalyzer.analyze(&ctx, &responses, &Collected::default());
let _ = ServiceVerdict::resolve(evidence);
}
}
#[test]
fn port_linked_match_is_tagged_port_confirmed() {
let responses = ResponseSet::from_banners(vec!["SSH-2.0-OpenSSH_9.6p1 Debian-3".to_string()]);
let evidence = BannerRegexAnalyzer.analyze(
&PortContext {
port: 22,
protocol: crate::model::port::Protocol::Tcp,
addr: None,
tunnel: None,
speaks_http: false,
detection: crate::config::ServiceDetection::default(),
host_name: None,
},
&responses,
&Collected::default(),
);
assert!(
evidence.iter().any(|e| e.port_confirmed),
"a port-linked match must be tagged port-confirmed"
);
}
const SELF_SIGNED_CERT: &[u8] = include_bytes!("testdata/selfsigned.der");
#[test]
fn tls_cert_identifies_self_signed_appliance() {
let responses = ResponseSet::default().with_tls(TlsInfo {
certificates: vec![SELF_SIGNED_CERT.to_vec()],
..TlsInfo::default()
});
let evidence = TlsCertAnalyzer.analyze(
&PortContext {
port: 8443,
protocol: crate::model::port::Protocol::Tcp,
addr: None,
tunnel: Some(Tunnel::Tls),
speaks_http: false,
detection: crate::config::ServiceDetection::default(),
host_name: None,
},
&responses,
&Collected::default(),
);
let verdict = ServiceVerdict::resolve(evidence);
assert_eq!(verdict.service.as_deref(), Some("ssl"));
assert_eq!(verdict.vendor.as_deref(), Some("Zond Appliance"));
assert_eq!(verdict.confidence, Confidence::Probable);
let service = verdict.to_service().unwrap();
assert_eq!(service.name(), "ssl");
assert_eq!(service.vendor(), Some("Zond Appliance"));
}
#[test]
fn tls_analyzer_is_silent_without_a_certificate() {
let responses = ResponseSet::from_banners(vec!["HTTP/1.1 200 OK".to_string()]);
assert!(
TlsCertAnalyzer
.analyze(
&PortContext {
port: 80,
protocol: crate::model::port::Protocol::Tcp,
addr: None,
tunnel: None,
speaks_http: false,
detection: crate::config::ServiceDetection::default(),
host_name: None,
},
&responses,
&Collected::default(),
)
.is_empty()
);
}
#[test]
fn banner_matched_in_a_tunnel_is_labelled_with_scheme() {
let responses = ResponseSet::from_banners(vec!["SSH-2.0-OpenSSH_9.6p1".to_string()]);
let ctx = PortContext {
port: 22,
protocol: crate::model::port::Protocol::Tcp,
addr: None,
tunnel: Some(Tunnel::Tls),
speaks_http: false,
detection: crate::config::ServiceDetection::default(),
host_name: None,
};
let evidence = BannerRegexAnalyzer.analyze(&ctx, &responses, &Collected::default());
let verdict = ServiceVerdict::resolve(evidence);
assert_eq!(verdict.service.as_deref(), Some("ssh")); assert_eq!(verdict.tunnel, Some(Tunnel::Tls));
assert_eq!(verdict.to_service().unwrap().name(), "ssl/ssh"); }
fn named(port: u16, protocol: crate::model::port::Protocol, banner: &str) -> ServiceVerdict {
let responses = ResponseSet::from_banners(vec![banner.to_string()]);
let evidence = BannerRegexAnalyzer.analyze(
&PortContext {
port,
protocol,
addr: None,
tunnel: None,
speaks_http: false,
detection: crate::config::ServiceDetection::default(),
host_name: None,
},
&responses,
&Collected::default(),
);
ServiceVerdict::resolve(evidence)
}
#[test]
fn only_a_framed_zabbix_reply_is_named_zabbix() {
use crate::model::port::Protocol::{Tcp, Udp};
let not_zabbix = [
(
8080,
Tcp,
"HTTP/1.1 200 OK\r\nServer: farm\r\nSet-Cookie: 1f3a9c=0; Path=/\r\n\
Content-Type: text/html\r\n\r\n<title>1 new message</title>",
),
(51987, Tcp, "1\r\n"),
(161, Udp, "1.3.6.1.4.1.11.2.3.9.1"),
];
for (port, protocol, banner) in not_zabbix {
let verdict = named(port, protocol, banner);
assert!(
verdict
.evidence
.iter()
.all(|evidence| evidence.service.as_deref() != Some("zabbix")),
"{banner:?} on {port} was read as zabbix: {verdict:?}"
);
}
let pong = "ZBXD\u{1}\u{1}\0\0\0\0\0\0\0\u{31}";
for port in [10050, 51987] {
let verdict = named(port, Tcp, pong);
assert_eq!(verdict.service.as_deref(), Some("zabbix"), "on {port}");
}
}
#[test]
fn only_a_pjl_reply_is_named_a_raw_print_port() {
use crate::model::port::Protocol::Tcp;
let not_a_printer = [
(
8080,
"HTTP/1.1 200 OK\r\nServer: Apache\r\nX-Powered-By: PHP/8.1.2\r\n\
Content-Type: text/html\r\n\r\n<title>Welcome</title>",
),
(51987, "X-Powered-By: PHP/8.1.2"),
(9100, "Powered by PHP"),
];
for (port, banner) in not_a_printer {
let verdict = named(port, Tcp, banner);
assert!(
verdict
.evidence
.iter()
.all(|evidence| evidence.service.as_deref() != Some("jetdirect")),
"{banner:?} on {port} was read as a raw-print port: {verdict:?}"
);
}
let id = "@PJL INFO ID\r\n\"HP LaserJet 4250\"\r\n\u{c}";
let verdict = named(9100, Tcp, id);
assert_eq!(verdict.service.as_deref(), Some("jetdirect"));
}
#[test]
fn every_rule_reading_a_high_byte_ships_an_example() {
fn names_a_high_byte(pattern: &str) -> bool {
pattern
.match_indices("\\x")
.filter_map(|(at, _)| pattern.get(at + 2..at + 4))
.filter_map(|digits| u8::from_str_radix(digits, 16).ok())
.any(|byte| byte >= 0x80)
}
let mut unexampled: Vec<String> = SignatureDb::embedded_definitions()
.iter()
.flat_map(|def| {
def.r#match
.iter()
.filter(|rule| names_a_high_byte(&rule.pattern))
.filter(|rule| rule.example.as_deref().is_none_or(str::is_empty))
.map(|rule| {
format!(
"{}#{}",
def.service.name,
rule.name.as_deref().unwrap_or("?")
)
})
})
.collect();
unexampled.sort();
assert!(
unexampled.is_empty(),
"rules reading a high byte with no example: {unexampled:?}"
);
}
#[test]
fn binary_replies_reach_the_rules_written_for_their_bytes() {
use crate::model::port::Protocol::Tcp;
let replies: &[(u16, &[u8], &str)] = &[
(139, b"\x82\x00\x00\x00", "netbios-ssn"),
(139, b"\x83\x00\x00\x01\x82", "netbios-ssn"),
(23, b"\xff\xfd\x18\xff\xfd\x20", "telnet"),
(
389,
b"\x30\x84\x00\x00\x00\x10\x02\x01\x01\x61\x84\x00\x00\x00\x07\x0a\x01\x00\x04\x00\x04\x00",
"ldap",
),
(1080, b"\x05\xff", "socks5"),
(
179,
b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x15\x03\x06\x05",
"bgp",
),
(
1723,
b"\x00\x9c\x00\x01\x1a\x2b\x3c\x4d\x00\x02\x00\x00\x01\x00\x01\x00",
"pptp",
),
(5556, b"\xff\x00\x00\x00\x00\x00\x00\x00\x01\x7f\x03\x00", "zeromq"),
(9042, b"\x84\x00\x00\x01\x00\x00\x00\x00\x10", "cassandra"),
(
25565,
b"\xff\x00\x16\x00\xa7\x00\x31\x00\x00\x00\x37\x00\x36",
"minecraft",
),
(
111,
b"\x80\x00\x00\x1czond\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
"rpcbind",
),
(515, b"\x00", "lpd"),
(1099, b"N\x00\x0c198.51.100.7\x00\x00\x04\x4b", "java-rmi"),
(
548,
b"\x01\x03\x00\x01\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00",
"afp",
),
(5666, b"\x00\x02\x00\x02\x5a\xc3\x91\x07\x00\x00NRPE v4.1.0", "nrpe"),
(1883, b"\x20\x02\x00\x00", "mqtt"),
(1080, b"\x05\x00", "socks5"),
(1433, TDS_PRELOGIN_RESPONSE, "mssql"),
(
51987,
b"\x00\x5a\x00\x50\x7f\x00\x00\x01",
"socks4",
),
(
11211,
b"\x81\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\
\x00\x00\x00\x00\x00\x00\x00\x001.6.21",
"memcached_binary",
),
];
for (port, reply, service) in replies {
let text = super::extract::reply_text(reply);
let verdict = named(*port, Tcp, &text);
assert_eq!(
verdict.service.as_deref(),
Some(*service),
"{reply:02x?} on {port}"
);
}
}
const TDS_PRELOGIN_RESPONSE: &[u8] = b"\x04\x01\x00\x2b\x00\x00\x01\x00\
\x00\x00\x1a\x00\x06\x01\x00\x20\x00\x01\x02\x00\x21\x00\x01\x03\x00\x22\x00\x00\
\x04\x00\x22\x00\x01\xff\x0f\x00\x07\xd0\x00\x00\x02\x00\x00";
#[test]
fn a_binary_rule_does_not_claim_another_protocol_opening_the_same_way() {
fn modbus(transaction: [u8; 2]) -> Vec<u8> {
let mut reply = transaction.to_vec();
reply.extend_from_slice(b"\x00\x00\x00\x05\x01\x03\x02\x00\x2a");
reply
}
let cases: &[(&str, &str, Vec<u8>)] = &[
(
"lpd",
"lpd_response",
b"\x00\x00\x00\x0b\x7e\x09\x30\x07\xa6\x03\x02\x01\x06".to_vec(),
),
(
"lpd",
"lpd_response",
b"\x00\x9c\x00\x01\x1a\x2b\x3c\x4d\x00\x02\x00\x00".to_vec(),
),
(
"java-rmi",
"jrmp_ack",
b"NOTICE AUTH :*** Looking up your hostname\r\n".to_vec(),
),
("afp", "dsi_reply", modbus([0x01, 0x03])),
("nrpe", "nrpe_response", modbus([0x00, 0x02])),
("mqtt", "mqtt_connack", modbus([0x20, 0x02])),
(
"socks5",
"socks5_response",
b"\x05\x00\x0c\x03\x10\x00\x00\x00\x44\x00\x00\x00".to_vec(),
),
("mssql", "mssql_prelogin_response", modbus([0x04, 0x01])),
(
"tor",
"tor_socks_match",
b"HTTP/1.0 501 Not Implemented\r\n\r\n".to_vec(),
),
(
"socks4",
"socks4_response",
b"\x00\x5a\x12\x34\x81\x80\x00\x01\x00\x01\x00\x00\x00\x00".to_vec(),
),
(
"memcached_binary",
"version_response",
b"\x81\x0aHello Zond".to_vec(),
),
];
let defs = SignatureDb::embedded_definitions();
let claimed: Vec<String> = cases
.iter()
.filter(|(service, rule, reply)| {
let (def, matched) = defs
.iter()
.filter(|def| def.service.name == *service)
.find_map(|def| {
def.r#match
.iter()
.find(|candidate| candidate.name.as_deref() == Some(*rule))
.map(|matched| (def, matched))
})
.unwrap_or_else(|| panic!("no rule {service}#{rule}"));
Signature::new(&def.service.name, matched)
.identify(
&super::extract::reply_text(reply),
crate::model::host::OsSource::ServiceBanner,
)
.is_some()
})
.map(|(service, rule, reply)| format!("{service}#{rule} claimed {reply:02x?}"))
.collect();
assert!(claimed.is_empty(), "{claimed:#?}");
}
#[test]
fn a_high_first_byte_alone_names_no_binary_protocol() {
use crate::model::port::Protocol::Tcp;
let others: &[&[u8]] = &[
b"\x82\x01\x02\x03 something else",
b"\x80\x00\x01\x00 not a reply to this engine",
b"\xff\x00\x10\x00\x41\x00\x42",
];
for reply in others {
let verdict = named(51987, Tcp, &super::extract::reply_text(reply));
for claimed in ["netbios-ssn", "rpcbind", "minecraft", "zeromq"] {
assert!(
verdict
.evidence
.iter()
.all(|evidence| evidence.service.as_deref() != Some(claimed)),
"{reply:02x?} was read as {claimed}: {verdict:?}"
);
}
}
}
#[tokio::test]
async fn a_session_service_is_named_from_its_answer_over_a_socket() {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::{TcpListener, TcpStream};
use crate::model::port::{PortState, Protocol};
use crate::testing::loopback::accept_from_this_process;
let listener = TcpListener::bind("127.0.0.1:0").await.expect("a socket");
let addr = listener.local_addr().expect("its address");
let server = tokio::spawn(async move {
let Ok(mut sock) = accept_from_this_process(&listener).await else {
return;
};
let mut request = [0u8; 128];
if sock.read(&mut request).await.is_ok_and(|read| read > 0) {
let _ = sock.write_all(b"\x82\x00\x00\x00").await;
}
let _ = sock.read(&mut request).await;
});
let stream = TcpStream::connect(addr).await.expect("connects");
let port = super::baseline_port(139, Protocol::Tcp, PortState::Open);
let identified =
super::fingerprint_tcp(stream, port, crate::config::ServiceDetection::Probe).await;
server.abort();
let labelled = super::baseline_port(139, Protocol::Tcp, PortState::Open);
let label = labelled.service().map(|service| service.confidence());
let identified = identified.service().expect("the port is named");
assert_eq!(identified.name(), "netbios-ssn");
assert!(
Some(identified.confidence()) > label,
"{identified:?} is no more than the port's label"
);
}
#[test]
fn an_rdp_negotiation_answer_names_the_security_layer() {
use crate::model::port::Protocol::Tcp;
let answers: &[(&[u8], Option<&str>)] = &[
(
b"\x03\x00\x00\x13\x0e\xd0\x00\x00\x12\x34\x00\x02\x1f\x08\x00\x02\x00\x00\x00",
Some("security layer: CredSSP (NLA)"),
),
(
b"\x03\x00\x00\x13\x0e\xd0\x00\x00\x12\x34\x00\x02\x01\x08\x00\x01\x00\x00\x00",
Some("security layer: TLS without NLA"),
),
(
b"\x03\x00\x00\x13\x0e\xd0\x00\x00\x12\x34\x00\x03\x00\x08\x00\x02\x00\x00\x00",
Some("security layer: standard RDP security only"),
),
(
b"\x03\x00\x00\x13\x0e\xd0\x00\x00\xc3\xa9\x00\x02\x1f\x08\x00\x02\x00\x00\x00",
Some("security layer: CredSSP (NLA)"),
),
(b"\x03\x00\x00\x0b\x06\xd0\x00\x00\x12\x34\x00", None),
];
for (answer, layer) in answers {
let verdict = named(3389, Tcp, &super::extract::reply_text(answer));
assert_eq!(verdict.service.as_deref(), Some("rdp"), "{answer:02x?}");
assert_eq!(verdict.extrainfo.as_deref(), *layer, "{answer:02x?}");
}
}
#[tokio::test]
async fn an_rdp_server_is_named_from_its_negotiation_over_a_socket() {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::{TcpListener, TcpStream};
use crate::model::port::{PortState, Protocol};
use crate::testing::loopback::accept_from_this_process;
let listener = TcpListener::bind("127.0.0.1:0").await.expect("a socket");
let addr = listener.local_addr().expect("its address");
let server = tokio::spawn(async move {
let Ok(mut sock) = accept_from_this_process(&listener).await else {
return;
};
let mut request = [0u8; 64];
if sock
.read(&mut request)
.await
.is_ok_and(|read| read == 19 && request[5] == 0xe0)
{
let _ = sock
.write_all(
b"\x03\x00\x00\x13\x0e\xd0\x00\x00\x12\x34\x00\x02\x1f\x08\x00\x02\x00\x00\x00",
)
.await;
}
let _ = sock.read(&mut request).await;
});
let stream = TcpStream::connect(addr).await.expect("connects");
let port = super::baseline_port(3389, Protocol::Tcp, PortState::Open);
let identified =
super::fingerprint_tcp(stream, port, crate::config::ServiceDetection::Probe).await;
server.abort();
let service = identified.service().expect("the port is named");
assert_eq!(service.name(), "rdp");
assert_eq!(service.extrainfo(), Some("security layer: CredSSP (NLA)"));
}
fn root_dse(level: &[u8]) -> String {
let mut bytes = b"\x04\x15supportedCapabilities1\x84\x00\x00\x00\x18\x04\x16".to_vec();
bytes.extend_from_slice(b"1.2.840.113556.1.4.8000\x84\x00\x00\x00\x28");
bytes.extend_from_slice(b"\x04\x1ddomainControllerFunctionality1\x84\x00\x00\x00");
bytes.push(2 + level.len() as u8);
bytes.extend_from_slice(&[0x04, level.len() as u8]);
bytes.extend_from_slice(level);
super::extract::reply_text(&bytes)
}
#[test]
fn a_functional_level_names_the_release_only_as_far_as_it_goes() {
use crate::model::port::Protocol::Tcp;
let cases: &[(&[u8], &str, &str)] = &[
(b"7", "Windows Server", "cpe:/o:microsoft:windows:-"),
(
b"10",
"Windows Server 2025",
"cpe:/o:microsoft:windows_server_2025:-",
),
(
b"6",
"Windows Server 2012 R2",
"cpe:/o:microsoft:windows_server_2012:-",
),
];
for (level, product, cpe) in cases {
let found = SignatureDb::global()
.identify(389, Tcp, &root_dse(level))
.expect("a controller's root DSE is read");
let os = found.os.expect("the level names an operating system");
assert_eq!(os.product.as_deref(), Some(*product), "level {level:?}");
assert_eq!(os.cpe.as_deref(), Some(*cpe), "level {level:?}");
assert_eq!(
found.product.as_deref(),
Some("Active Directory Controller")
);
}
}
#[test]
fn smb_and_ldap_together_keep_the_cpe_of_the_release_they_establish() {
use crate::model::port::Protocol::Tcp;
let db = SignatureDb::global();
let read = |port: u16, text: &str| {
db.identify(port, Tcp, text)
.and_then(|found| found.os)
.expect("the reply names an operating system")
};
let smb = read(445, "Windows 10.0 Build 20348");
let ldap = read(389, &root_dse(b"7"));
for evidence in [vec![smb.clone(), ldap.clone()], vec![ldap, smb]] {
let verdict = super::os::resolve(evidence).expect("the two agree");
assert_eq!(verdict.product.as_deref(), Some("Windows Server 2022"));
assert_eq!(
verdict.cpe.as_deref(),
Some("cpe:/o:microsoft:windows_server_2022:-")
);
}
}
fn read_as_the_transport(port: u16, bytes: &[u8]) -> ServiceVerdict {
let mut banners = super::extract::from_stream(port, bytes);
banners.push(super::extract::reply_text(bytes));
let evidence = BannerRegexAnalyzer.analyze(
&PortContext::new(port, crate::model::port::Protocol::Tcp),
&ResponseSet::from_banners(banners),
&Collected::default(),
);
ServiceVerdict::resolve(evidence)
}
#[test]
fn everyday_services_are_named_over_tcp_from_what_they_say_first() {
struct Case {
port: u16,
reply: Vec<u8>,
service: &'static str,
product: Option<&'static str>,
version: Option<&'static str>,
extrainfo: Option<&'static str>,
}
let krb_error = {
let fields = [0xA6, 0x03, 0x02, 0x01, 6];
let mut sequence = vec![0x30, fields.len() as u8];
sequence.extend_from_slice(&fields);
let mut error = vec![0x7E, sequence.len() as u8];
error.extend_from_slice(&sequence);
let mut framed = (error.len() as u32).to_be_bytes().to_vec();
framed.extend_from_slice(&error);
framed
};
let nfs_mismatch = {
let mut reply = b"zone".to_vec();
for word in [1u32, 0, 0, 0, 2, 3, 4] {
reply.extend_from_slice(&word.to_be_bytes());
}
let mut framed = (0x8000_0000 | reply.len() as u32).to_be_bytes().to_vec();
framed.extend_from_slice(&reply);
framed
};
let bind_version = {
let mut message = b"\x00\x00\x84\x00\x00\x01\x00\x01\x00\x00\x00\x00".to_vec();
message.extend_from_slice(b"\x07version\x04bind\x00\x00\x10\x00\x03");
let text = b"9.18.28-0ubuntu0.22.04.1-Ubuntu";
message.extend_from_slice(b"\xc0\x0c\x00\x10\x00\x03\x00\x00\x00\x00");
message.extend_from_slice(&((text.len() + 1) as u16).to_be_bytes());
message.push(text.len() as u8);
message.extend_from_slice(text);
let mut framed = (message.len() as u16).to_be_bytes().to_vec();
framed.extend_from_slice(&message);
framed
};
let prelogin = b"\x04\x01\x00\x1a\x00\x00\x01\x00\
\x00\x00\x0b\x00\x06\x01\x00\x11\x00\x01\xff\x0f\x00\x07\xd0\x00\x00\x02"
.to_vec();
let cases = [
Case {
port: 6379,
reply: b"-NOAUTH Authentication required.\r\n".to_vec(),
service: "redis",
product: None,
version: None,
extrainfo: Some("authentication required"),
},
Case {
port: 5900,
reply: b"RFB 003.008\n".to_vec(),
service: "vnc",
product: None,
version: None,
extrainfo: Some("protocol 3.8"),
},
Case {
port: 1433,
reply: prelogin,
service: "mssql",
product: Some("SQL Server"),
version: Some("15.0.2000"),
extrainfo: Some("SQL Server 2019"),
},
Case {
port: 88,
reply: krb_error,
service: "kerberos",
product: None,
version: None,
extrainfo: None,
},
Case {
port: 2049,
reply: nfs_mismatch,
service: "nfs",
product: Some("NFS"),
version: Some("4"),
extrainfo: Some("versions 3 to 4"),
},
Case {
port: 53,
reply: bind_version,
service: "dns",
product: Some("BIND"),
version: Some("9.18.28"),
extrainfo: None,
},
];
for case in cases {
let verdict = read_as_the_transport(case.port, &case.reply);
assert_eq!(
verdict.service.as_deref(),
Some(case.service),
"on {}",
case.port
);
assert_eq!(verdict.product.as_deref(), case.product, "on {}", case.port);
assert_eq!(verdict.version.as_deref(), case.version, "on {}", case.port);
assert_eq!(
verdict.extrainfo.as_deref(),
case.extrainfo,
"on {}",
case.port
);
}
}
#[test]
fn only_a_reply_to_the_api_versions_request_is_named_kafka() {
use crate::model::port::Protocol::Tcp;
let broker = super::extract::reply_text(b"\x00\x00\x00\x06\x00\x00\x00\x03\x00\x00");
assert_eq!(named(9092, Tcp, &broker).service.as_deref(), Some("kafka"));
let others: &[&[u8]] = &[
b"\x00\x00\x00\x0b\x7e\x09\x30\x07\xa6\x03\x02\x01\x06",
b"\x00\x00\x01\x00 some other framed protocol",
];
for reply in others {
let verdict = named(51987, Tcp, &super::extract::reply_text(reply));
assert!(
verdict
.evidence
.iter()
.all(|evidence| evidence.service.as_deref() != Some("kafka")),
"{reply:02x?} was read as kafka: {verdict:?}"
);
}
}
#[test]
fn the_nrpe_probe_is_a_query_the_daemon_answers() {
fn crc32(bytes: &[u8]) -> u32 {
let mut crc = u32::MAX;
for &byte in bytes {
crc ^= u32::from(byte);
for _ in 0..8 {
crc = (crc >> 1) ^ (0xEDB8_8320 & 0u32.wrapping_sub(crc & 1));
}
}
!crc
}
assert_eq!(
crc32(b"123456789"),
0xCBF4_3926,
"the published check value"
);
let db = SignatureDb::global();
let query = db
.tcp_probe_payloads(5666)
.iter()
.find(|payload| payload.starts_with(b"\x00\x02"))
.expect("port 5666 has an NRPE probe");
assert_eq!(query.len(), 1036, "the whole packet");
assert_eq!(&query[2..4], b"\x00\x01", "a query");
assert!(
query[10..].starts_with(b"_NRPE_CHECK\0"),
"the version check"
);
let mut zeroed = query.clone();
zeroed[4..8].fill(0);
assert_eq!(
u32::from_be_bytes(query[4..8].try_into().expect("four bytes")),
crc32(&zeroed),
"the CRC-32 over the packet with its own field zeroed"
);
}
#[test]
fn tor_is_named_by_its_own_answer_and_not_by_a_socks5_greeting() {
use crate::model::port::Protocol::Tcp;
let greeting = named(9050, Tcp, "\u{5}\u{0}");
assert_eq!(greeting.service.as_deref(), Some("socks5"));
let web = "HTTP/1.0 501 Tor is not an HTTP Proxy\r\nContent-Type: text/html\r\n\r\n";
for port in [9050, 9150] {
let verdict = named(port, Tcp, web);
assert_eq!(verdict.service.as_deref(), Some("tor"), "on {port}");
assert_eq!(verdict.product.as_deref(), Some("tor_socks"), "on {port}");
}
}