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, Confidence, PortContext, ServiceVerdict, TlsCertAnalyzer, Tunnel,
};
const KNOWN_EXAMPLE_MISMATCHES: usize = 218;
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)
.is_none()
.then(|| format!("example={example:?} pattern={:?}", signature.pattern()))
})
.collect();
mismatches.sort();
assert_eq!(
mismatches.len(),
KNOWN_EXAMPLE_MISMATCHES,
"example-match count changed (found {}, baseline {KNOWN_EXAMPLE_MISMATCHES}). If you \
changed signatures, review the delta and update KNOWN_EXAMPLE_MISMATCHES.\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).is_none() {
return false; }
!prefilter.candidates(example).contains(idx)
})
.count();
assert_eq!(
violations, 0,
"prefilter dropped {violations} matching signature(s)"
);
}
#[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,
},
&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,
},
&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,
};
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,
},
&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 {
banners: Vec::new(),
tls: Some(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),
},
&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,
},
&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),
};
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"); }