use aho_corasick::AhoCorasick;
use regex_syntax::hir::literal::{ExtractKind, Extractor};
use regex_syntax::hir::{Hir, HirKind};
use regex_syntax::parse;
use super::matcher::Signature;
const MIN_LITERAL_LEN: usize = 3;
pub trait Prefilter: Send + Sync {
fn candidates(&self, response: &str) -> Vec<usize>;
}
pub struct LiteralPrefilter {
automaton: AhoCorasick,
literal_owner: Vec<usize>,
always_run: Vec<usize>,
}
impl LiteralPrefilter {
pub fn build(signatures: &[Signature]) -> Self {
let mut literals: Vec<Vec<u8>> = Vec::new();
let mut literal_owner: Vec<usize> = Vec::new();
let mut always_run: Vec<usize> = Vec::new();
for (idx, signature) in signatures.iter().enumerate() {
match required_literals(signature.pattern()) {
Some(lits) => {
for lit in lits {
literals.push(lit);
literal_owner.push(idx);
}
}
None => always_run.push(idx),
}
}
let automaton = AhoCorasick::builder()
.ascii_case_insensitive(true)
.build(&literals)
.expect("aho-corasick construction over signature literals");
Self {
automaton,
literal_owner,
always_run,
}
}
}
impl Prefilter for LiteralPrefilter {
fn candidates(&self, response: &str) -> Vec<usize> {
let mut selected = vec![false; self.literal_owner.len().max(1)];
let mut candidates = self.always_run.clone();
for m in self.automaton.find_overlapping_iter(response) {
let owner = self.literal_owner[m.pattern().as_usize()];
if !std::mem::replace(&mut selected[m.pattern().as_usize()], true) {
candidates.push(owner);
}
}
candidates.sort_unstable();
candidates.dedup();
candidates
}
}
fn required_literals(pattern: &str) -> Option<Vec<Vec<u8>>> {
let hir = parse(pattern).ok()?;
if let Some(set) = literal_set(&hir, ExtractKind::Prefix) {
return Some(set);
}
if let Some(inner) = longest_required_literal(&hir).filter(|l| l.len() >= MIN_LITERAL_LEN) {
return Some(vec![inner]);
}
literal_set(&hir, ExtractKind::Suffix)
}
fn literal_set(hir: &Hir, kind: ExtractKind) -> Option<Vec<Vec<u8>>> {
let mut extractor = Extractor::new();
extractor.kind(kind);
let seq = extractor.extract(hir);
let literals = seq.literals()?; if literals.is_empty() {
return None;
}
let mut out = Vec::with_capacity(literals.len());
for literal in literals {
if literal.as_bytes().is_empty() {
return None;
}
out.push(literal.as_bytes().to_vec());
}
Some(out)
}
fn longest_required_literal(hir: &Hir) -> Option<Vec<u8>> {
match hir.kind() {
HirKind::Literal(literal) => Some(literal.0.to_vec()),
HirKind::Capture(capture) => longest_required_literal(&capture.sub),
HirKind::Concat(parts) => parts
.iter()
.filter_map(longest_required_literal)
.max_by_key(Vec::len),
HirKind::Repetition(rep) if rep.min >= 1 => longest_required_literal(&rep.sub),
_ => None,
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::fingerprint::signature::MatchRule;
use proptest::prelude::*;
fn sig(pattern: &str) -> Signature {
Signature::new(
"svc",
&MatchRule {
name: None,
pattern: pattern.to_string(),
version_group: None,
vendor: None,
product: None,
context: None,
example: None,
metadata: None,
},
)
}
#[test]
fn selects_by_prefix_literal_and_skips_non_candidates() {
let sigs = [sig(r"^SSH-[\d.]+-OpenSSH"), sig(r"^HTTP/1\.[01]")];
let pf = LiteralPrefilter::build(&sigs);
let ssh = pf.candidates("SSH-2.0-OpenSSH_9.6");
assert!(ssh.contains(&0));
assert!(!ssh.contains(&1)); }
#[test]
fn selects_by_inner_literal() {
let sigs = [sig(r"^(\S{1,64}) FTP Server \(Version ([\d.]+)\)")];
let pf = LiteralPrefilter::build(&sigs);
assert!(
pf.candidates("host.example FTP Server (Version 1.2.3)")
.contains(&0)
);
assert!(pf.candidates("SSH-2.0-OpenSSH_9.6").is_empty());
}
#[test]
fn unfilterable_pattern_is_always_a_candidate() {
let sigs = [sig(r"^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$")];
let pf = LiteralPrefilter::build(&sigs);
assert!(pf.candidates("anything at all").contains(&0));
}
#[test]
fn case_insensitive_literal_still_selects() {
let sigs = [sig(r"^Server: nginx")];
let pf = LiteralPrefilter::build(&sigs);
assert!(pf.candidates("server: NGINX/1.25").contains(&0));
}
proptest! {
#[test]
fn candidates_never_panics_on_arbitrary_input(response in "(?s).*") {
let sigs = [sig(r"^HTTP/\d"), sig(r"Server: (\w+)"), sig(r"^\d{3} ")];
let pf = LiteralPrefilter::build(&sigs);
let _ = pf.candidates(&response);
}
}
}