use async_trait::async_trait;
use super::analyzer::{Analyzer, PortContext};
use super::model::{Confidence, Evidence, SourceId};
use super::response::{Collected, ResponseSet};
pub struct HttpHeadersAnalyzer;
#[async_trait]
impl Analyzer for HttpHeadersAnalyzer {
fn id(&self) -> SourceId {
SourceId::HttpHeaders
}
fn interested(&self, _ctx: &PortContext) -> bool {
true
}
fn analyze(
&self,
ctx: &PortContext,
responses: &ResponseSet,
_collected: &Collected,
) -> Vec<Evidence> {
let Some(http) = responses
.banners
.iter()
.find_map(|banner| HttpResponse::parse(banner))
else {
return Vec::new();
};
let mut evidence = vec![stamp(
Evidence::new(SourceId::HttpHeaders, Confidence::Probable).with_service("http"),
ctx,
)];
if let Some((product, version)) = http.header("server").and_then(parse_server) {
let confidence = if version.is_some() {
Confidence::Strong
} else {
Confidence::Probable
};
let mut server = Evidence::new(SourceId::HttpHeaders, confidence)
.with_service("http")
.with_product(product);
server.version = version;
evidence.push(stamp(server, ctx));
}
if let Some(powered_by) = http.header("x-powered-by") {
evidence.push(stamp(
Evidence::new(SourceId::HttpHeaders, Confidence::Probable)
.with_service("http")
.with_extrainfo(powered_by),
ctx,
));
}
evidence
}
}
fn stamp(mut evidence: Evidence, ctx: &PortContext) -> Evidence {
evidence.tunnel = ctx.tunnel;
evidence
}
fn parse_server(value: &str) -> Option<(String, Option<String>)> {
let token = value.split_whitespace().next()?;
if let Some((product, version)) = token.split_once('/') {
let product = product.trim_end_matches('(');
let versioned = version.starts_with(|c: char| c.is_ascii_digit());
if !product.is_empty() && !is_placeholder(product) && versioned {
return Some((product.to_string(), Some(version.to_string())));
}
if !product.is_empty() && !is_placeholder(product) {
return Some((product.to_string(), None));
}
}
let product = token.split('(').next().unwrap_or(token);
(!product.is_empty() && !is_placeholder(product)).then(|| (product.to_string(), None))
}
fn is_placeholder(product: &str) -> bool {
matches!(
product.trim().to_ascii_lowercase().as_str(),
"" | "null" | "nil" | "none" | "unknown" | "unspecified" | "-"
)
}
struct HttpResponse {
headers: Vec<(String, String)>,
}
impl HttpResponse {
fn parse(raw: &str) -> Option<Self> {
if !raw.starts_with("HTTP/") {
return None;
}
let mut headers = Vec::new();
for line in raw.split('\n').skip(1) {
let line = line.strip_suffix('\r').unwrap_or(line);
if line.is_empty() {
break; }
if let Some((name, value)) = line.split_once(':') {
headers.push((name.trim().to_ascii_lowercase(), value.trim().to_string()));
}
}
Some(HttpResponse { headers })
}
fn header(&self, name: &str) -> Option<&str> {
self.headers
.iter()
.find(|(header, _)| header == name)
.map(|(_, value)| value.as_str())
.filter(|value| !value.is_empty())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::fingerprinting::model::Tunnel;
use proptest::prelude::*;
fn analyze(port: u16, banner: &str) -> Vec<Evidence> {
HttpHeadersAnalyzer.analyze(
&PortContext {
port,
addr: None,
tunnel: None,
},
&ResponseSet::from_banners(vec![banner.to_string()]),
&Collected::default(),
)
}
#[test]
fn extracts_long_tail_server_product_and_version() {
let evidence = analyze(
8000,
"HTTP/1.1 200 OK\r\nServer: gunicorn/21.2.0\r\nContent-Type: text/html\r\n\r\n<html>",
);
let server = evidence
.iter()
.find(|e| e.product.as_deref() == Some("gunicorn"))
.expect("names gunicorn");
assert_eq!(server.version.as_deref(), Some("21.2.0"));
assert_eq!(server.confidence, Confidence::Strong);
assert_eq!(server.service.as_deref(), Some("http"));
}
#[test]
fn iis_ten_is_covered_where_the_curated_regexes_stop() {
let evidence = analyze(80, "HTTP/1.1 200 OK\r\nServer: Microsoft-IIS/10.0\r\n\r\n");
let server = evidence
.iter()
.find(|e| e.product.as_deref() == Some("Microsoft-IIS"))
.expect("names IIS");
assert_eq!(server.version.as_deref(), Some("10.0"));
}
#[test]
fn server_without_version_is_probable_product_only() {
let evidence = analyze(80, "HTTP/1.0 200 OK\r\nServer: cloudflare\r\n\r\n");
let server = evidence
.iter()
.find(|e| e.product.as_deref() == Some("cloudflare"))
.expect("names cloudflare");
assert_eq!(server.version, None);
assert_eq!(server.confidence, Confidence::Probable);
}
#[test]
fn trailing_os_comment_token_is_ignored() {
let evidence = analyze(
80,
"HTTP/1.1 200 OK\r\nServer: Apache/2.4.58 (Ubuntu)\r\n\r\n",
);
let server = evidence
.iter()
.find(|e| e.product.as_deref() == Some("Apache"))
.expect("names Apache");
assert_eq!(server.version.as_deref(), Some("2.4.58"));
}
#[test]
fn valid_http_without_server_header_still_labels_http() {
let evidence = analyze(80, "HTTP/1.1 204 No Content\r\nContent-Length: 0\r\n\r\n");
assert_eq!(evidence.len(), 1);
assert_eq!(evidence[0].service.as_deref(), Some("http"));
assert_eq!(evidence[0].product, None);
}
#[test]
fn x_powered_by_becomes_extrainfo_beside_the_server_product() {
let evidence = analyze(
80,
"HTTP/1.1 200 OK\r\nServer: Apache/2.4.58\r\nX-Powered-By: PHP/8.2.1\r\n\r\n",
);
assert!(
evidence
.iter()
.any(|e| e.product.as_deref() == Some("Apache")),
"server keeps the product slot"
);
assert!(
evidence
.iter()
.any(|e| e.extrainfo.as_deref() == Some("PHP/8.2.1")),
"framework lands in extrainfo"
);
assert!(
evidence
.iter()
.all(|e| e.product.as_deref() != Some("PHP/8.2.1"))
);
}
#[test]
fn placeholder_server_token_names_no_product() {
let evidence = analyze(80, "HTTP/1.1 200 OK\r\nServer: null\r\n\r\n");
assert_eq!(evidence.len(), 1);
assert_eq!(evidence[0].service.as_deref(), Some("http"));
assert_eq!(evidence[0].product, None);
assert_eq!(parse_server("null"), None);
assert_eq!(parse_server("-"), None);
assert_eq!(parse_server("Unknown"), None);
}
#[test]
fn non_http_banner_yields_nothing() {
assert!(analyze(22, "SSH-2.0-OpenSSH_9.6p1 Debian-3").is_empty());
}
proptest! {
#[test]
fn http_parse_never_panics(raw in "(?s).*") {
let _ = HttpResponse::parse(&raw);
}
#[test]
fn http_header_parsing_never_panics(body in "(?s).*") {
if let Some(response) = HttpResponse::parse(&format!("HTTP/1.1 200 OK\r\n{body}")) {
let _ = response.header("server");
let _ = response.header("x-powered-by");
}
}
#[test]
fn parse_server_never_panics(value in "(?s).*") {
let _ = parse_server(&value);
}
}
#[test]
fn header_lookup_is_case_insensitive() {
let evidence = analyze(80, "HTTP/1.1 200 OK\r\nSERVER: nginx/1.25.3\r\n\r\n");
assert!(
evidence
.iter()
.any(|e| e.product.as_deref() == Some("nginx"))
);
}
#[test]
fn evidence_carries_the_tunnel_for_ssl_labelling() {
let evidence = HttpHeadersAnalyzer.analyze(
&PortContext {
port: 443,
addr: None,
tunnel: Some(Tunnel::Tls),
},
&ResponseSet::from_banners(vec![
"HTTP/1.1 200 OK\r\nServer: nginx/1.25.3\r\n\r\n".to_string(),
]),
&Collected::default(),
);
assert!(evidence.iter().all(|e| e.tunnel == Some(Tunnel::Tls)));
}
}