use async_trait::async_trait;
use super::db::SignatureDb;
use super::model::{Evidence, SourceId, Tunnel};
use super::prefilter::Prefilter;
use super::response::{Collected, ResponseSet};
use crate::model::port::Protocol;
pub struct PortContext {
pub port: u16,
pub protocol: Protocol,
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, port_confirmed)) = banner_evidence(db, port_signatures, response) {
evidence.push(stamp(found, ctx, port_confirmed));
}
}
evidence
}
}
fn best_match(db: &SignatureDb, indices: &[usize], texts: &[&str]) -> Option<Evidence> {
let matched: Vec<super::matcher::Match> = texts
.iter()
.flat_map(|text| {
indices
.iter()
.filter_map(move |&idx| db.signature(idx).identify(text))
})
.collect();
let service = matched
.iter()
.reduce(|best, m| if m.quality > best.quality { m } else { best })?;
let os = matched
.iter()
.filter_map(|m| m.os.as_ref())
.reduce(|best, os| {
if os_detail(os) > os_detail(best) {
os
} else {
best
}
})
.cloned();
Some(Evidence {
os,
..service.evidence.clone()
})
}
fn os_detail(os: &super::os::OsEvidence) -> u8 {
u8::from(os.version.is_some())
+ u8::from(os.kernel.is_some())
+ u8::from(os.product.is_some())
+ u8::from(os.vendor.is_some())
+ u8::from(os.cpe.is_some())
}
fn banner_evidence(
db: &SignatureDb,
port_signatures: &[usize],
banner: &str,
) -> Option<(Evidence, bool)> {
let texts = super::extract::texts(banner);
let mut found = best_match(db, port_signatures, &texts);
let mut port_confirmed = found.is_some();
if found.as_ref().is_none_or(|found| found.os.is_none()) {
let mut candidates: Vec<usize> = texts
.iter()
.flat_map(|text| db.prefilter().candidates(text))
.collect();
candidates.sort_unstable();
candidates.dedup();
db.warm(&candidates);
if let Some(global) = best_match(db, &candidates, &texts) {
match found.as_mut() {
Some(found) => found.os = global.os,
None => {
found = Some(global);
port_confirmed = false;
}
}
}
}
found.map(|found| (found, port_confirmed))
}
#[cfg(test)]
pub(crate) fn os_from_banner(
db: &SignatureDb,
port: u16,
banner: &str,
) -> Option<super::os::OsEvidence> {
let port_signatures = db.signatures_for_port(port);
db.warm(port_signatures);
banner_evidence(db, port_signatures, banner).and_then(|(found, _)| found.os)
}
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::fingerprint::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,
protocol: crate::model::port::Protocol::Tcp,
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,
protocol: crate::model::port::Protocol::Tcp,
addr: None,
tunnel: None,
};
assert!(BannerRegexAnalyzer.collect(&ctx).await.frames.is_empty());
}
}