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 parsed: Vec<HttpResponse<'_>> = responses
.banners
.iter()
.filter_map(|banner| HttpResponse::parse(banner))
.collect();
let Some(http) = parsed.first() else {
return Vec::new();
};
let mut evidence = vec![stamp(
Evidence::new(SourceId::HttpHeaders, Confidence::Probable).with_service("http"),
ctx,
)];
if let Some(header) = http.header("server") {
if let Some((product, version)) = parse_server(header) {
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(os) = os_from(header) {
let mut carrier =
Evidence::new(SourceId::HttpHeaders, Confidence::Probable).with_service("http");
carrier.os = Some(os);
evidence.push(stamp(carrier, 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,
));
}
let named = http
.header("server")
.and_then(parse_server)
.map(|(product, _)| product);
if let Some(application) = parsed
.iter()
.find_map(|response| application_hint(response, named.as_deref()))
{
evidence.push(stamp(
Evidence::new(SourceId::HttpHeaders, Confidence::Probable)
.with_service("http")
.with_extrainfo(application),
ctx,
));
}
evidence
}
}
fn application_hint(http: &HttpResponse<'_>, named: Option<&str>) -> Option<String> {
if let Some(vendor) = vendor_prefix(http) {
return Some(vendor);
}
let title = document_title(http.body)?;
let echoes_the_server = named.is_some_and(|product| {
let (title, product) = (title.to_ascii_lowercase(), product.to_ascii_lowercase());
title.contains(&product) || product.contains(&title)
});
(!echoes_the_server).then_some(title)
}
const NOT_A_VENDOR: &[&str] = &[
"accel",
"access",
"api",
"app",
"auth",
"cache",
"content",
"correlation",
"csrf",
"dns",
"download",
"forwarded",
"frame",
"http",
"instance",
"permitted",
"powered",
"ratelimit",
"rate",
"real",
"request",
"requested",
"response",
"robots",
"runtime",
"served",
"server",
"sourcemap",
"timer",
"total",
"trace",
"transaction",
"ua",
"upstream",
"varnish",
"version",
"xss",
];
fn vendor_prefix(http: &HttpResponse<'_>) -> Option<String> {
let mut counts: Vec<(String, usize)> = Vec::new();
for name in http.header_vocabulary() {
let lowered = name.to_ascii_lowercase();
let Some(rest) = lowered.strip_prefix("x-") else {
continue;
};
let token = rest.split('-').next().unwrap_or(rest);
if token.len() < 3
|| !token.chars().all(|c| c.is_ascii_alphanumeric())
|| NOT_A_VENDOR.contains(&token)
{
continue;
}
match counts.iter_mut().find(|(seen, _)| seen == token) {
Some((_, count)) => *count += 1,
None => counts.push((token.to_string(), 1)),
}
}
counts
.iter()
.enumerate()
.max_by_key(|(index, (_, count))| (*count, std::cmp::Reverse(*index)))
.map(|(_, (token, _))| capitalize(token))
}
fn capitalize(token: &str) -> String {
let mut chars = token.chars();
match chars.next() {
Some(first) => first.to_ascii_uppercase().to_string() + chars.as_str(),
None => String::new(),
}
}
const NOT_AN_APPLICATION: &[&str] = &[
"400 bad request",
"401 unauthorized",
"403 forbidden",
"404 not found",
"500 internal server error",
"bad request",
"document",
"error",
"forbidden",
"home",
"index",
"index of /",
"log in",
"login",
"not found",
"sign in",
"unauthorized",
"welcome",
];
fn document_title(body: &str) -> Option<String> {
let lower = body.to_ascii_lowercase();
let open = lower.find("<title")?;
let start = open + lower[open..].find('>')? + 1;
let end = start + lower[start..].find("</title>")?;
let title = body
.get(start..end)?
.split_whitespace()
.collect::<Vec<_>>()
.join(" ");
if title.is_empty() || title.len() > 40 {
return None;
}
if NOT_AN_APPLICATION.contains(&title.to_ascii_lowercase().as_str()) {
return None;
}
reads_as_a_name(&title).then_some(title)
}
const NAME_CONNECTIVES: &[&str] = &["of", "the", "and", "for", "de", "la", "du"];
fn reads_as_a_name(title: &str) -> bool {
if title.contains(['-', '|', ':', '·', '—', '–', '/', '(']) {
return false;
}
let mut words = title.split_whitespace();
let Some(first) = words.next() else {
return false;
};
if !first.chars().next().is_some_and(char::is_alphanumeric) {
return false;
}
words.all(|word| {
NAME_CONNECTIVES.contains(&word.to_ascii_lowercase().as_str())
|| word.chars().next().is_some_and(char::is_uppercase)
})
}
fn stamp(mut evidence: Evidence, ctx: &PortContext) -> Evidence {
evidence.tunnel = ctx.tunnel;
evidence
}
fn os_from(header: &str) -> Option<crate::fingerprint::os::OsEvidence> {
use crate::fingerprint::prefilter::Prefilter;
let db = crate::fingerprint::SignatureDb::global();
db.prefilter()
.candidates(header)
.into_iter()
.filter_map(|index| db.signature(index).identify(header))
.filter_map(|matched| matched.os)
.max_by(|a, b| {
a.confidence
.partial_cmp(&b.confidence)
.unwrap_or(std::cmp::Ordering::Equal)
})
}
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<'a> {
headers: Vec<(String, String)>,
body: &'a str,
}
impl<'a> HttpResponse<'a> {
fn parse(raw: &'a str) -> Option<Self> {
if !raw.starts_with("HTTP/") {
return None;
}
let (head, body) = raw
.find("\r\n\r\n")
.map(|at| (&raw[..at], &raw[at + 4..]))
.or_else(|| raw.find("\n\n").map(|at| (&raw[..at], &raw[at + 2..])))
.unwrap_or((raw, ""));
let mut headers = Vec::new();
for line in head.split('\n').skip(1) {
let line = line.strip_suffix('\r').unwrap_or(line);
if let Some((name, value)) = line.split_once(':') {
headers.push((name.trim().to_ascii_lowercase(), value.trim().to_string()));
}
}
Some(HttpResponse { headers, body })
}
fn header_vocabulary(&self) -> impl Iterator<Item = &str> {
self.headers.iter().map(|(name, _)| name.as_str()).chain(
self.header("access-control-allow-headers")
.into_iter()
.flat_map(|value| value.split(',').map(str::trim)),
)
}
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::fingerprint::model::Tunnel;
use proptest::prelude::*;
fn analyze(port: u16, banner: &str) -> Vec<Evidence> {
HttpHeadersAnalyzer.analyze(
&PortContext {
protocol: crate::model::port::Protocol::Tcp,
port,
addr: None,
tunnel: None,
},
&ResponseSet::from_banners(vec![banner.to_string()]),
&Collected::default(),
)
}
fn analyze_all(port: u16, banners: &[&str]) -> Vec<Evidence> {
HttpHeadersAnalyzer.analyze(
&PortContext {
protocol: crate::model::port::Protocol::Tcp,
port,
addr: None,
tunnel: None,
},
&ResponseSet::from_banners(banners.iter().map(|b| (*b).to_string()).collect()),
&Collected::default(),
)
}
#[test]
fn a_redirect_and_its_destination_are_read_together() {
let evidence = analyze_all(
8096,
&[
"HTTP/1.1 302 Found\r\nServer: Kestrel\r\nLocation: /web/index.html\r\n\r\n",
"HTTP/1.1 200 OK\r\nServer: Kestrel\r\n\r\n\
<!DOCTYPE html><html><head><title>Jellyfin</title></head>",
],
);
assert_eq!(
evidence.iter().find_map(|e| e.extrainfo.as_deref()),
Some("Jellyfin"),
"the page one hop away is where the application named itself"
);
assert!(
evidence
.iter()
.any(|e| e.product.as_deref() == Some("Kestrel")),
"and the framework it runs on is still recorded, from the direct answer"
);
}
fn extrainfo(port: u16, banner: &str) -> Option<String> {
analyze(port, banner)
.into_iter()
.find_map(|evidence| evidence.extrainfo)
}
#[test]
fn a_server_that_names_itself_only_in_its_cors_list_is_still_named() {
let banner = "HTTP/1.1 200 OK\r\n\
Server: UPnP/1.0 DLNADOC/1.50\r\n\
Access-Control-Allow-Headers: Accept, Authorization, Content-Type, \
X-MediaBrowser-Token, X-Emby-Token, X-Emby-Client, X-Emby-Authorization\r\n\
Content-Length: 0\r\n\r\n";
assert_eq!(extrainfo(8097, banner).as_deref(), Some("Emby"));
}
#[test]
fn a_vendor_prefix_on_a_header_names_the_vendor() {
let banner = "HTTP/1.1 200 OK\r\nServer: Kestrel\r\nX-Plex-Protocol: 1.0\r\n\r\n";
assert_eq!(extrainfo(32400, banner).as_deref(), Some("Plex"));
}
#[test]
fn the_standard_extension_headers_name_nothing() {
let banner = "HTTP/1.1 200 OK\r\n\
Server: nginx/1.22.1\r\n\
X-Frame-Options: DENY\r\n\
X-Content-Type-Options: nosniff\r\n\
X-XSS-Protection: 1; mode=block\r\n\
X-Request-Id: abc123\r\n\
X-Cache: HIT\r\n\r\n";
assert_eq!(extrainfo(80, banner), None);
}
#[test]
fn the_document_title_names_an_application_nobody_wrote_a_rule_for() {
let banner = "HTTP/1.1 200 OK\r\n\
Content-Type: text/html; charset=utf-8\r\n\r\n\
<!DOCTYPE html><html lang=\"en\"><head><title>Squoosh</title><meta \
name=\"description\" content=\"Squoosh is the ultimate image optimizer\" />";
assert_eq!(extrainfo(7778, banner).as_deref(), Some("Squoosh"));
}
#[test]
fn a_title_that_only_echoes_the_server_is_not_an_application() {
let welcome = "HTTP/1.1 200 OK\r\n\
Server: nginx/1.22.1\r\n\r\n\
<html><head><title>Welcome to nginx!</title>";
assert_eq!(extrainfo(80, welcome), None);
let repeat = "HTTP/1.1 200 OK\r\n\
Server: Netdata Embedded HTTP Server v2.11.0\r\n\r\n\
<html><head><title>Netdata</title>";
assert_eq!(extrainfo(19999, repeat), None, "nor is a bare repeat of it");
let different = "HTTP/1.1 200 OK\r\n\
Server: Kestrel\r\n\r\n\
<html><head><title>Jellyfin</title>";
assert_eq!(extrainfo(8096, different).as_deref(), Some("Jellyfin"));
}
#[test]
fn a_page_title_is_not_an_application_name() {
for title in ["404 Not Found", "Sign in", "Welcome", "Index of /"] {
let banner = format!("HTTP/1.1 200 OK\r\n\r\n<html><head><title>{title}</title>");
assert_eq!(extrainfo(8080, &banner), None, "{title} names no product");
}
let sentence = "HTTP/1.1 200 OK\r\n\r\n<html><head><title>The quick brown fox \
jumps over the lazy dog and keeps going</title>";
assert_eq!(
extrainfo(8080, sentence),
None,
"a sentence is a page description, not a product"
);
}
#[test]
fn a_tie_between_prefixes_goes_to_the_first_mentioned() {
let banner = "HTTP/1.1 200 OK\r\nX-Alpha-One: a\r\nX-Bravo-One: b\r\n\r\n";
let http = HttpResponse::parse(banner).expect("an HTTP response");
assert_eq!(vendor_prefix(&http).as_deref(), Some("Alpha"));
}
#[test]
fn a_title_that_is_somebody_talking_is_not_a_product() {
for title in [
"Yo whats up",
"this page is under construction",
"please log in to continue",
] {
let banner = format!("HTTP/1.1 200 OK\r\n\r\n<html><head><title>{title}</title>");
assert_eq!(extrainfo(8080, &banner), None, "`{title}` names no product");
}
}
#[test]
fn a_title_shaped_like_a_name_is_taken_as_one() {
for title in [
"Grafana",
"phpMyAdmin",
"openHAB",
"Home Assistant",
"Proxmox Virtual Environment",
"Bill of Materials",
] {
let banner = format!("HTTP/1.1 200 OK\r\n\r\n<html><head><title>{title}</title>");
assert_eq!(
extrainfo(8080, &banner).as_deref(),
Some(title),
"`{title}` reads as a name"
);
}
}
#[test]
fn a_title_with_a_separator_is_declined_rather_than_guessed_at() {
for title in [
"Dashboard - Grafana",
"Sonarr - Series",
"Log in | Nextcloud",
] {
let banner = format!("HTTP/1.1 200 OK\r\n\r\n<html><head><title>{title}</title>");
assert_eq!(extrainfo(8080, &banner), None, "`{title}` is ambiguous");
}
}
#[test]
fn a_vendor_prefix_outranks_a_title() {
let banner = "HTTP/1.1 200 OK\r\n\
X-Jenkins: 2.426.3\r\n\r\n\
<html><head><title>Dashboard</title>";
assert_eq!(extrainfo(8080, banner).as_deref(), Some("Jenkins"));
}
#[test]
fn the_parser_separates_the_body_from_the_headers() {
let response = HttpResponse::parse(
"HTTP/1.1 200 OK\r\nServer: nginx\r\n\r\n<html><body>hello</body></html>",
)
.expect("an HTTP response");
assert_eq!(response.header("server"), Some("nginx"));
assert_eq!(response.body, "<html><body>hello</body></html>");
let headers_only = HttpResponse::parse("HTTP/1.1 204 No Content\r\nServer: nginx\r\n\r\n")
.expect("an HTTP response");
assert_eq!(headers_only.body, "");
}
#[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,
protocol: crate::model::port::Protocol::Tcp,
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)));
}
}
#[cfg(test)]
mod os_from_headers {
use super::*;
use crate::fingerprint::response::Collected;
#[test]
fn a_server_header_reaches_the_rules_that_name_a_windows_release() {
let evidence = HttpHeadersAnalyzer.analyze(
&PortContext {
port: 80,
protocol: crate::model::port::Protocol::Tcp,
addr: None,
tunnel: None,
},
&ResponseSet::from_banners(vec![
"HTTP/1.1 200 OK\r\nServer: Microsoft-IIS/6.0\r\nContent-Length: 0\r\n\r\n"
.to_string(),
]),
&Collected::default(),
);
let os = evidence
.iter()
.find_map(|e| e.os.as_ref())
.expect("the Server value reaches the operating-system rules");
assert_eq!(os.family, "Windows");
assert_eq!(
os.product.as_deref(),
Some("Windows Server 2003"),
"and carries the precise release the corpus knows, not just the family"
);
}
#[test]
fn the_whole_response_is_not_what_those_rules_match() {
use crate::fingerprint::prefilter::Prefilter;
let response = "HTTP/1.1 200 OK\r\nServer: Microsoft-IIS/6.0\r\nContent-Length: 0\r\n\r\n";
let db = crate::fingerprint::SignatureDb::global();
let from_response = db
.prefilter()
.candidates(response)
.into_iter()
.filter_map(|index| db.signature(index).identify(response))
.find_map(|matched| matched.os);
assert!(
from_response.is_none(),
"if this ever starts matching, the rules changed shape and `os_from` \
should be reconsidered rather than left as a workaround"
);
assert!(
os_from("Microsoft-IIS/6.0").is_some(),
"while the value those rules are written against does match"
);
}
#[test]
fn a_server_the_corpus_does_not_know_names_nothing() {
assert!(os_from("SomeServer/1.0").is_none());
}
}