use std::sync::OnceLock;
use crate::fingerprint::os::OsMetadata;
use crate::fingerprint::signature::{MAX_COMPILED_REGEX_BYTES, MatchRule};
use crate::warn;
use super::model::{Confidence, Evidence, SourceId};
use super::pattern::{self, CompiledPattern};
pub struct Signature {
service: String,
product: Option<String>,
vendor: Option<String>,
version_group: Option<u8>,
pattern: String,
compiled: OnceLock<Option<CompiledPattern>>,
os: Option<Box<OsMetadata>>,
}
impl Signature {
pub fn new(service: &str, rule: &MatchRule) -> Self {
Self {
service: service.to_string(),
product: rule.product.clone(),
vendor: rule.vendor.clone(),
version_group: rule.version_group,
pattern: rule.pattern.clone(),
compiled: OnceLock::new(),
os: rule
.metadata
.as_ref()
.and_then(OsMetadata::from_map)
.map(Box::new),
}
}
pub fn os_metadata(&self) -> Option<&OsMetadata> {
self.os.as_deref()
}
pub fn pattern(&self) -> &str {
&self.pattern
}
pub fn compile(&self) {
self.compiled();
}
fn compiled(&self) -> Option<&CompiledPattern> {
self.compiled
.get_or_init(
|| match pattern::compile(&self.pattern, MAX_COMPILED_REGEX_BYTES) {
Ok(compiled) => Some(compiled),
Err(e) => {
warn!(
"fingerprint signature for service '{}' was skipped: its pattern \
failed to compile ({e}); pattern = {:?}",
self.service, self.pattern
);
None
}
},
)
.as_ref()
}
pub fn identify(&self, response: &str) -> Option<Match> {
let wants_captures = self.os.is_some();
let matched = self.compiled()?.identify_with_captures(
response,
self.version_group,
wants_captures,
)?;
let version = matched.version;
let confidence = if version.is_some() {
Confidence::Strong
} else {
Confidence::Probable
};
let detail = self.product.is_some() as u8 + self.vendor.is_some() as u8;
let mut evidence =
Evidence::new(SourceId::BannerRegex, confidence).with_service(self.service.clone());
evidence.product = self.product.clone();
evidence.vendor = self.vendor.clone();
evidence.version = version;
Some(Match {
evidence,
quality: MatchQuality { confidence, detail },
os: self.os.as_deref().and_then(|metadata| {
super::os::banner_evidence(metadata, matched.captures.as_deref().unwrap_or(&[]))
}),
})
}
}
pub struct Match {
pub evidence: Evidence,
pub quality: MatchQuality,
pub os: Option<crate::fingerprint::os::OsEvidence>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub struct MatchQuality {
confidence: Confidence,
detail: u8,
}
#[cfg(test)]
mod tests {
use super::*;
fn rule(pattern: &str, version_group: Option<u8>, product: Option<&str>) -> MatchRule {
MatchRule {
name: None,
pattern: pattern.to_string(),
version_group,
vendor: None,
product: product.map(str::to_string),
context: None,
example: None,
metadata: None,
}
}
#[test]
fn captures_version_and_reports_strong_confidence() {
let sig = Signature::new(
"ssh",
&rule(r"^SSH-[\d.]+-OpenSSH_([\w.]+)", Some(1), Some("OpenSSH")),
);
let ev = sig
.identify("SSH-2.0-OpenSSH_9.6p1 Debian")
.expect("should match")
.evidence;
assert_eq!(ev.service.as_deref(), Some("ssh"));
assert_eq!(ev.product.as_deref(), Some("OpenSSH"));
assert_eq!(ev.version.as_deref(), Some("9.6p1"));
assert_eq!(ev.confidence, Confidence::Strong);
}
#[test]
fn bare_match_is_probable_and_names_no_product() {
let sig = Signature::new("http", &rule("^HTTP/1.1", None, None));
let ev = sig
.identify("HTTP/1.1 200 OK")
.expect("should match")
.evidence;
assert_eq!(ev.confidence, Confidence::Probable);
assert_eq!(ev.service.as_deref(), Some("http"));
assert_eq!(
ev.product, None,
"the rule named no product, so neither does the evidence"
);
}
#[test]
fn specific_match_outranks_generic_for_same_response() {
let response = "HTTP/1.1 200 OK\r\nServer: nginx/1.25.3\r\n";
let generic = Signature::new("http", &rule(r"(?i)^HTTP/\d+\.\d+\s+\d+", None, None));
let mut nginx_rule = rule(r"(?i)Server:\s*nginx/([\d.]+)", Some(1), Some("nginx"));
nginx_rule.vendor = Some("NGINX".to_string());
let nginx = Signature::new("http", &nginx_rule);
let generic_q = generic.identify(response).expect("generic matches").quality;
let nginx_q = nginx.identify(response).expect("nginx matches").quality;
assert!(nginx_q > generic_q, "specific match must outrank generic");
}
#[test]
fn no_match_returns_none() {
let sig = Signature::new("http", &rule("^HTTP/1.1", None, None));
assert!(sig.identify("SSH-2.0-OpenSSH_9.6").is_none());
}
#[test]
fn backreference_signature_matches_via_the_fancy_engine() {
let sig = Signature::new("dup", &rule(r"^(\w+) \1$", None, None));
assert!(sig.identify("token token").is_some());
assert!(sig.identify("token other").is_none());
}
#[test]
fn unsupported_pattern_is_skipped_not_fatal() {
let sig = Signature::new("x", &rule("(", None, None));
assert!(sig.identify("aa").is_none());
}
}