use std::collections::HashMap;
use std::sync::{Arc, OnceLock};
use rayon::prelude::*;
use crate::core::models::fingerprint::ServiceDefinition;
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>>,
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_probes: HashMap<String, Vec<Vec<u8>>> = HashMap::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.iter().filter(|p| p.protocol == "tcp") {
service_probes
.entry(def.service.name.clone())
.or_default()
.push(unescape(&probe.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 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);
let payloads: Vec<Vec<u8>> = names
.iter()
.filter_map(|name| service_probes.get(name))
.flatten()
.cloned()
.collect();
if !payloads.is_empty() {
probes.insert(*port, payloads);
}
}
Self {
signatures,
name_index,
by_port,
probes,
prefilter: OnceLock::new(),
}
}
pub fn service_name(&self, port: u16) -> Option<Arc<str>> {
self.name_index.get(&port).cloned()
}
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.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")
}
}
fn unescape(payload: &str) -> Vec<u8> {
let mut out = Vec::with_capacity(payload.len());
let mut chars = payload.chars();
while let Some(c) = chars.next() {
if c != '\\' {
out.extend_from_slice(c.encode_utf8(&mut [0u8; 4]).as_bytes());
continue;
}
match chars.next() {
Some('r') => out.push(b'\r'),
Some('n') => out.push(b'\n'),
Some('t') => out.push(b'\t'),
Some('0') => out.push(0),
Some('\\') => out.push(b'\\'),
Some('x') => {
let hi = chars.next().and_then(|h| h.to_digit(16));
let lo = chars.next().and_then(|l| l.to_digit(16));
match (hi, lo) {
(Some(hi), Some(lo)) => out.push((hi * 16 + lo) as u8),
_ => out.extend_from_slice(b"\\x"),
}
}
Some(other) => {
out.push(b'\\');
out.extend_from_slice(other.encode_utf8(&mut [0u8; 4]).as_bytes());
}
None => out.push(b'\\'),
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
use crate::core::models::fingerprint::{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 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,
}];
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()]
);
}
}