use async_trait::async_trait;
use super::db::SignatureDb;
use super::model::{Evidence, SourceId, Tunnel};
use super::prefilter::Prefilter;
use super::response::{Collected, ResponseSet};
pub struct PortContext {
pub port: u16,
pub addr: Option<std::net::SocketAddr>,
pub tunnel: Option<Tunnel>,
}
#[async_trait]
pub trait Analyzer: Send + Sync {
fn id(&self) -> SourceId;
fn interested(&self, ctx: &PortContext) -> bool;
async fn collect(&self, _ctx: &PortContext) -> Collected {
Collected::default()
}
fn analyze(
&self,
ctx: &PortContext,
responses: &ResponseSet,
collected: &Collected,
) -> Vec<Evidence>;
}
pub struct BannerRegexAnalyzer;
#[async_trait]
impl Analyzer for BannerRegexAnalyzer {
fn id(&self) -> SourceId {
SourceId::BannerRegex
}
fn interested(&self, _ctx: &PortContext) -> bool {
true
}
fn analyze(
&self,
ctx: &PortContext,
responses: &ResponseSet,
_collected: &Collected,
) -> Vec<Evidence> {
let db = SignatureDb::global();
let port_signatures = db.signatures_for_port(ctx.port);
db.warm(port_signatures);
let mut evidence = Vec::new();
for response in &responses.banners {
if let Some(found) = best_match(db, port_signatures, response) {
evidence.push(stamp(found, ctx, true));
continue;
}
let candidates = db.prefilter().candidates(response);
db.warm(&candidates);
if let Some(found) = best_match(db, &candidates, response) {
evidence.push(stamp(found, ctx, false));
}
}
evidence
}
}
fn best_match(db: &SignatureDb, indices: &[usize], response: &str) -> Option<Evidence> {
indices
.iter()
.filter_map(|&idx| db.signature(idx).identify(response))
.reduce(|best, m| if m.quality > best.quality { m } else { best })
.map(|m| m.evidence)
}
fn stamp(mut evidence: Evidence, ctx: &PortContext, port_confirmed: bool) -> Evidence {
evidence.tunnel = ctx.tunnel;
evidence.port_confirmed = port_confirmed;
evidence
}
#[cfg(test)]
mod tests {
use super::*;
use crate::fingerprinting::model::Confidence;
struct EchoAnalyzer;
#[async_trait]
impl Analyzer for EchoAnalyzer {
fn id(&self) -> SourceId {
SourceId::BannerRegex
}
fn interested(&self, _ctx: &PortContext) -> bool {
true
}
async fn collect(&self, ctx: &PortContext) -> Collected {
Collected {
frames: vec![vec![0xff, ctx.port as u8]],
}
}
fn analyze(
&self,
_ctx: &PortContext,
_responses: &ResponseSet,
collected: &Collected,
) -> Vec<Evidence> {
collected
.frames
.iter()
.map(|frame| {
Evidence::new(SourceId::BannerRegex, Confidence::Weak)
.with_product(format!("{frame:?}"))
})
.collect()
}
}
#[tokio::test]
async fn collect_output_reaches_analyze_as_raw_bytes() {
let ctx = PortContext {
port: 7,
addr: None,
tunnel: None,
};
let collected = EchoAnalyzer.collect(&ctx).await;
assert_eq!(collected.frames, vec![vec![0xff, 7]]);
let evidence = EchoAnalyzer.analyze(&ctx, &ResponseSet::default(), &collected);
assert_eq!(evidence.len(), 1);
assert_eq!(evidence[0].product.as_deref(), Some("[255, 7]"));
}
#[tokio::test]
async fn default_collect_is_a_silent_no_op() {
let ctx = PortContext {
port: 80,
addr: None,
tunnel: None,
};
assert!(BannerRegexAnalyzer.collect(&ctx).await.frames.is_empty());
}
}