use std::collections::HashMap;
use std::sync::{Arc, OnceLock};
use rayon::prelude::*;
use crate::fingerprint::signature::{ServiceDefinition, unescape};
use super::matcher::Signature;
use super::prefilter::LiteralPrefilter;
const EMBEDDED_DB: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/fingerprints.bin"));
static DB: OnceLock<SignatureDb> = OnceLock::new();
pub struct SignatureDb {
signatures: Vec<Signature>,
name_index: HashMap<u16, Arc<str>>,
by_port: HashMap<u16, Vec<usize>>,
tcp_probes: HashMap<u16, Vec<Vec<u8>>>,
generic_tcp_probes: Vec<Vec<u8>>,
udp_probes: HashMap<u16, Vec<Vec<u8>>>,
prefilter: OnceLock<LiteralPrefilter>,
}
impl SignatureDb {
pub fn global() -> &'static SignatureDb {
DB.get_or_init(|| {
let defs: Vec<ServiceDefinition> = bincode::deserialize(EMBEDDED_DB)
.expect("embedded fingerprint database failed to deserialize");
SignatureDb::from_defs(defs)
})
}
fn from_defs(defs: Vec<ServiceDefinition>) -> Self {
let mut signatures = Vec::new();
let mut service_sigs: HashMap<String, Vec<usize>> = HashMap::new();
let mut service_tcp_probes: HashMap<String, Vec<Vec<u8>>> = HashMap::new();
let mut service_udp_probes: HashMap<String, Vec<Vec<u8>>> = HashMap::new();
let mut generic_tcp_probes: Vec<Vec<u8>> = Vec::new();
for def in &defs {
for rule in &def.r#match {
let idx = signatures.len();
signatures.push(Signature::new(&def.service.name, rule));
service_sigs
.entry(def.service.name.clone())
.or_default()
.push(idx);
}
for probe in &def.probe {
let by_protocol = match probe.protocol.as_str() {
"tcp" => &mut service_tcp_probes,
"udp" => &mut service_udp_probes,
_ => continue,
};
let payload = unescape(&probe.payload);
if probe.generic && probe.protocol == "tcp" {
generic_tcp_probes.push(payload.clone());
}
by_protocol
.entry(def.service.name.clone())
.or_default()
.push(payload);
}
}
let mut name_index: HashMap<u16, Arc<str>> = HashMap::new();
let mut port_services: HashMap<u16, Vec<String>> = HashMap::new();
for def in &defs {
for &port in &def.service.default_ports {
name_index
.entry(port)
.or_insert_with(|| Arc::from(def.service.name.as_str()));
let names = port_services.entry(port).or_default();
if !names.contains(&def.service.name) {
names.push(def.service.name.clone());
}
}
}
let mut by_port: HashMap<u16, Vec<usize>> = HashMap::new();
let mut tcp_probes: HashMap<u16, Vec<Vec<u8>>> = HashMap::new();
let mut udp_probes: HashMap<u16, Vec<Vec<u8>>> = HashMap::new();
for (port, names) in &port_services {
let mut indices: Vec<usize> = names
.iter()
.filter_map(|name| service_sigs.get(name))
.flatten()
.copied()
.collect();
indices.sort_unstable();
indices.dedup();
by_port.insert(*port, indices);
for (source, index) in [
(&service_tcp_probes, &mut tcp_probes),
(&service_udp_probes, &mut udp_probes),
] {
let payloads: Vec<Vec<u8>> = names
.iter()
.filter_map(|name| source.get(name))
.flatten()
.cloned()
.collect();
if !payloads.is_empty() {
index.insert(*port, payloads);
}
}
}
Self {
signatures,
name_index,
by_port,
tcp_probes,
generic_tcp_probes,
udp_probes,
prefilter: OnceLock::new(),
}
}
pub fn service_name(&self, port: u16) -> Option<Arc<str>> {
self.name_index.get(&port).cloned()
}
pub fn indexed_ports(&self) -> impl Iterator<Item = u16> + '_ {
self.name_index.keys().copied()
}
pub fn generic_tcp_probe_payloads(&self) -> &[Vec<u8>] {
&self.generic_tcp_probes
}
pub fn signatures_for_port(&self, port: u16) -> &[usize] {
self.by_port.get(&port).map_or(&[], Vec::as_slice)
}
pub fn signature(&self, idx: usize) -> &Signature {
&self.signatures[idx]
}
pub fn tcp_probe_payloads(&self, port: u16) -> &[Vec<u8>] {
self.tcp_probes.get(&port).map_or(&[], Vec::as_slice)
}
pub fn udp_probe_payloads(&self, port: u16) -> &[Vec<u8>] {
self.udp_probes.get(&port).map_or(&[], Vec::as_slice)
}
pub fn prefilter(&self) -> &LiteralPrefilter {
self.prefilter
.get_or_init(|| LiteralPrefilter::build(&self.signatures))
}
pub fn warm(&self, indices: &[usize]) {
indices
.par_iter()
.for_each(|&idx| self.signatures[idx].compile());
}
#[cfg(test)]
pub(crate) fn embedded_definitions() -> Vec<ServiceDefinition> {
bincode::deserialize(EMBEDDED_DB)
.expect("embedded fingerprint database failed to deserialize")
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::fingerprint::signature::{MatchRule, Probe, ServiceSignature};
fn def(name: &str, ports: Vec<u16>, patterns: &[&str]) -> ServiceDefinition {
ServiceDefinition {
service: ServiceSignature {
name: name.to_string(),
default_ports: ports,
description: None,
attribution: None,
},
probe: Vec::new(),
r#match: patterns
.iter()
.map(|p| MatchRule {
name: None,
pattern: p.to_string(),
version_group: None,
vendor: None,
product: None,
context: None,
example: None,
metadata: None,
})
.collect(),
}
}
fn db() -> SignatureDb {
SignatureDb::from_defs(vec![
def("http", vec![80, 8080], &["^HTTP/1", "^Server:"]),
def("https", vec![443], &["^TLS"]),
def("http-alt", vec![80], &["^HTX"]),
])
}
#[test]
fn name_index_is_first_claimant() {
let db = db();
assert_eq!(db.service_name(80).as_deref(), Some("http"));
assert_eq!(db.service_name(443).as_deref(), Some("https"));
assert!(db.service_name(22).is_none());
}
#[test]
fn port_index_is_service_linked() {
let db = SignatureDb::from_defs(vec![
def("ssh", vec![22], &["^SSH-2", "^SSH-1"]), def("ssh", vec![], &["^SSH banner"]), def("http", vec![80], &["^HTTP/1"]),
]);
assert_eq!(db.signatures_for_port(22).len(), 3);
assert_eq!(db.signatures_for_port(80).len(), 1);
assert!(db.signatures_for_port(9999).is_empty());
}
#[test]
fn signatures_identify_through_the_index() {
let db = db();
let hit = db
.signatures_for_port(80)
.iter()
.find_map(|&i| db.signature(i).identify("HTTP/1.1 200 OK"));
assert_eq!(
hit.and_then(|m| m.evidence.service),
Some("http".to_string())
);
}
#[test]
fn every_port_with_a_signature_is_a_port_the_default_scan_reaches() {
use crate::model::port::catalog::{TCP_BY_PREVALENCE, UDP_BY_PREVALENCE};
let probed: std::collections::HashSet<u16> = TCP_BY_PREVALENCE
.iter()
.chain(UDP_BY_PREVALENCE.iter())
.copied()
.collect();
let unreachable: Vec<u16> = SignatureDb::global()
.indexed_ports()
.filter(|port| !probed.contains(port))
.collect();
assert!(
unreachable.is_empty(),
"these ports have signatures but no default scan reaches them, so the \
signatures can never match: {unreachable:?}. Add them to the catalogue, \
or drop the signature."
);
}
#[test]
fn the_shipped_database_carries_a_generic_probe() {
let generic = SignatureDb::global().generic_tcp_probe_payloads();
assert!(
!generic.is_empty(),
"no probe is marked generic, so every unrecognised port is asked nothing"
);
assert!(
generic.len() <= 2,
"a generic probe is sent to every unrecognised port of every scan; \
{} of them is a cost that wants an argument",
generic.len()
);
assert!(
generic
.iter()
.any(|payload| payload.starts_with(b"GET / HTTP/")),
"the one question worth asking of an unknown port is an HTTP request"
);
}
#[test]
fn a_generic_udp_probe_is_not_indexed_as_generic() {
let mut def = def("weird", vec![9999], &["^X"]);
def.probe = vec![Probe {
name: Some("nope".into()),
payload: "ping".into(),
protocol: "udp".into(),
rarity: 0,
generic: true,
}];
assert!(
SignatureDb::from_defs(vec![def])
.generic_tcp_probe_payloads()
.is_empty()
);
}
#[test]
fn unescape_decodes_common_sequences() {
assert_eq!(unescape(r"GET /\r\n"), b"GET /\r\n");
assert_eq!(unescape(r"a\tb\0c"), b"a\tb\0c");
assert_eq!(unescape(r"\x00\xff\x1b"), &[0x00, 0xff, 0x1b]);
assert_eq!(unescape(r"c:\path"), br"c:\path"); assert_eq!(unescape(r"\\n"), br"\n"); }
#[test]
fn probe_payloads_are_decoded_to_wire_bytes() {
let mut d = def("http", vec![80], &["^HTTP/1"]);
d.probe = vec![Probe {
name: None,
payload: r"GET / HTTP/1.1\r\n\r\n".to_string(),
protocol: "tcp".to_string(),
rarity: 0,
generic: false,
}];
let db = SignatureDb::from_defs(vec![d]);
assert_eq!(
db.tcp_probe_payloads(80),
&[b"GET / HTTP/1.1\r\n\r\n".to_vec()]
);
}
}