use async_trait::async_trait;
use md5::{Digest, Md5};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
use tokio::time::timeout;
use std::time::Duration;
use super::analyzer::{Analyzer, PortContext};
use super::model::{Evidence, SourceId};
use super::response::{Collected, ResponseSet};
const FETCH_TIMEOUT: Duration = Duration::from_secs(3);
const MAX_ICON_BYTES: usize = 256 * 1024;
const CONVENTIONAL_PATH: &str = "/favicon.ico";
fn request(path: &str) -> Vec<u8> {
format!("GET {path} HTTP/1.1\r\nHost: localhost\r\nAccept: */*\r\nConnection: close\r\n\r\n")
.into_bytes()
}
pub struct FaviconAnalyzer;
#[async_trait]
impl Analyzer for FaviconAnalyzer {
fn id(&self) -> SourceId {
SourceId::Favicon
}
fn interested(&self, ctx: &PortContext) -> bool {
ctx.speaks_http && ctx.addr.is_some()
}
async fn collect(&self, ctx: &PortContext, responses: &ResponseSet) -> Collected {
let Some(addr) = ctx.addr else {
return Collected::default();
};
match timeout(FETCH_TIMEOUT, icon_of(addr, responses)).await {
Ok(Some(icon)) => Collected::from_frames(vec![icon]),
_ => Collected::default(),
}
}
fn analyze(
&self,
_ctx: &PortContext,
_responses: &ResponseSet,
collected: &Collected,
) -> Vec<Evidence> {
let Some(icon) = collected.frames.first() else {
return Vec::new();
};
let digest = md5_hex(icon);
super::db::SignatureDb::global()
.identify_field(&digest)
.map(|evidence| vec![as_application(evidence)])
.unwrap_or_default()
}
}
fn as_application(mut evidence: Evidence) -> Evidence {
evidence.source = SourceId::Favicon;
match evidence.product.clone() {
Some(product) => evidence.with_extrainfo(product),
None => evidence,
}
}
#[cfg(any(test, feature = "test-support"))]
pub async fn digest_of(addr: std::net::SocketAddr) -> Option<String> {
let icon = timeout(FETCH_TIMEOUT, icon_of(addr, &ResponseSet::default()))
.await
.ok()??;
Some(md5_hex(&icon))
}
fn md5_hex(bytes: &[u8]) -> String {
Md5::digest(bytes)
.iter()
.map(|byte| format!("{byte:02x}"))
.collect()
}
async fn icon_of(addr: std::net::SocketAddr, responses: &ResponseSet) -> Option<Vec<u8>> {
let (page, base) = page_of(addr, responses).await;
let declared = page
.as_deref()
.and_then(declared_icon)
.and_then(|href| resolve(&base, href));
for path in declared
.iter()
.map(String::as_str)
.chain([CONVENTIONAL_PATH])
{
if let Some(icon) = fetch(addr, path).await {
return Some(icon);
}
}
None
}
async fn page_of(addr: std::net::SocketAddr, responses: &ResponseSet) -> (Option<String>, String) {
let root = "/".to_string();
let first = responses
.banners
.iter()
.find(|banner| banner.starts_with("HTTP/"));
if let Some(page) = first.filter(|page| declared_icon(page).is_some()) {
return (Some(page.clone()), root);
}
let path = first
.and_then(|page| super::redirect_path(page, Some(addr)))
.unwrap_or_else(|| root.clone());
let Some(page) = fetch_text(addr, &path).await else {
return (first.cloned(), root);
};
match super::redirect_path(&page, Some(addr)) {
Some(next) => match fetch_text(addr, &next).await {
Some(followed) => (Some(followed), next),
None => (Some(page), path),
},
None => (Some(page), path),
}
}
fn declared_icon(page: &str) -> Option<&str> {
let lower = page.to_ascii_lowercase();
let mut at = 0;
while let Some(start) = lower[at..].find("<link").map(|i| at + i) {
let end = lower[start..].find('>').map(|i| start + i)?;
let tag = &lower[start..end];
at = end;
let names_an_icon = attribute(tag, "rel")
.is_some_and(|rel| rel.split_whitespace().any(|word| word == "icon"));
if !names_an_icon {
continue;
}
if let Some(href) = attribute(tag, "href") {
let offset = tag.find(href)?;
return page.get(start + offset..start + offset + href.len());
}
}
None
}
fn attribute<'a>(tag: &'a str, name: &str) -> Option<&'a str> {
let at = tag.find(&format!("{name}="))? + name.len() + 1;
let rest = tag.get(at..)?;
let quote = rest.chars().next().filter(|c| *c == '"' || *c == '\'')?;
let value = rest.get(1..)?;
value.get(..value.find(quote)?)
}
fn resolve(base: &str, href: &str) -> Option<String> {
let href = href.trim();
if href.is_empty() || href.starts_with("//") {
return None;
}
let scheme_end = href
.find(':')
.filter(|at| *at < href.find('/').unwrap_or(usize::MAX));
if scheme_end.is_some() {
return None;
}
if href.starts_with('/') {
return Some(href.to_string());
}
let directory = match base.rfind('/') {
Some(at) => &base[..=at],
None => "/",
};
let href = href.strip_prefix("./").unwrap_or(href);
Some(format!("{directory}{href}"))
}
async fn fetch(addr: std::net::SocketAddr, path: &str) -> Option<Vec<u8>> {
let response = exchange(addr, path).await?;
if let Some(body) = body_of(&response) {
return Some(body.to_vec());
}
let head = String::from_utf8_lossy(&response);
let next = super::redirect_path(&head, Some(addr))?;
let followed = exchange(addr, &next).await?;
body_of(&followed).map(<[u8]>::to_vec)
}
async fn fetch_text(addr: std::net::SocketAddr, path: &str) -> Option<String> {
let response = exchange(addr, path).await?;
Some(String::from_utf8_lossy(&response).into_owned())
}
async fn exchange(addr: std::net::SocketAddr, path: &str) -> Option<Vec<u8>> {
let mut stream = TcpStream::connect(addr).await.ok()?;
stream.write_all(&request(path)).await.ok()?;
let mut response = Vec::new();
let mut buffer = [0u8; 8192];
loop {
let read = stream.read(&mut buffer).await.ok()?;
if read == 0 {
break;
}
response.extend_from_slice(&buffer[..read]);
if response.len() >= MAX_ICON_BYTES {
response.truncate(MAX_ICON_BYTES);
break;
}
}
Some(response)
}
fn body_of(response: &[u8]) -> Option<&[u8]> {
let status = response.get(..response.iter().position(|b| *b == b'\r')?)?;
if !status.starts_with(b"HTTP/") || !is_success(status) {
return None;
}
let at = response
.windows(4)
.position(|window| window == b"\r\n\r\n")?;
let body = response.get(at + 4..)?;
(!body.is_empty()).then_some(body)
}
fn is_success(status: &[u8]) -> bool {
status
.split(|byte| *byte == b' ')
.nth(1)
.is_some_and(|code| code == b"200")
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_digest_is_lowercase_hex() {
assert_eq!(md5_hex(b""), "d41d8cd98f00b204e9800998ecf8427e");
assert_eq!(md5_hex(b"abc"), "900150983cd24fb0d6963f7d28e17f72");
}
#[test]
fn a_body_is_taken_from_a_200_and_from_nothing_else() {
let ok = b"HTTP/1.1 200 OK\r\nContent-Type: image/x-icon\r\n\r\n\x00\x01icon";
assert_eq!(body_of(ok), Some(&b"\x00\x01icon"[..]));
let missing = b"HTTP/1.1 404 Not Found\r\n\r\nnope";
assert_eq!(body_of(missing), None);
}
#[test]
fn a_redirect_is_declined_rather_than_followed() {
let moved = b"HTTP/1.1 302 Found\r\nLocation: https://cdn.example/favicon.ico\r\n\r\n";
assert_eq!(body_of(moved), None);
}
#[test]
fn a_reason_phrase_other_than_ok_still_reads_as_success() {
let odd = b"HTTP/1.0 200 Document follows\r\n\r\nbytes";
assert_eq!(body_of(odd), Some(&b"bytes"[..]));
}
#[test]
fn a_response_with_no_body_yields_nothing_to_hash() {
assert_eq!(body_of(b"HTTP/1.1 200 OK\r\n\r\n"), None);
assert_eq!(body_of(b"not http at all"), None);
assert_eq!(body_of(b""), None);
}
#[test]
fn only_a_port_that_answered_in_http_is_asked_for_an_icon() {
use crate::model::port::Protocol;
let addr = Some("127.0.0.1:80".parse().unwrap());
let http = PortContext::new(80, Protocol::Tcp)
.with_addr(addr)
.with_speaks_http(true);
assert!(FaviconAnalyzer.interested(&http));
let quiet = PortContext::new(80, Protocol::Tcp)
.with_addr(addr)
.with_speaks_http(false);
assert!(!FaviconAnalyzer.interested(&quiet));
let no_socket = PortContext::new(80, Protocol::Tcp).with_speaks_http(true);
assert!(!FaviconAnalyzer.interested(&no_socket));
}
#[tokio::test]
async fn a_page_declaring_no_icon_falls_back_to_the_conventional_path() {
use crate::model::port::Protocol;
use tokio::net::TcpListener;
const ICON: &[u8] = b"\x00\x00\x01\x00 not really an icon, but bytes are bytes";
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
let mut asked = Vec::new();
for _ in 0..2 {
let Ok((mut stream, _)) = listener.accept().await else {
break;
};
let mut buffer = [0u8; 512];
let read = stream.read(&mut buffer).await.unwrap();
let path = String::from_utf8_lossy(&buffer[..read])
.split_whitespace()
.nth(1)
.unwrap_or_default()
.to_string();
asked.push(path.clone());
if path == CONVENTIONAL_PATH {
stream
.write_all(b"HTTP/1.1 200 OK\r\nContent-Type: image/x-icon\r\n\r\n")
.await
.unwrap();
stream.write_all(ICON).await.unwrap();
} else {
stream
.write_all(
b"HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n<html><head></head></html>",
)
.await
.unwrap();
}
}
asked
});
let responses = ResponseSet::from_banners(vec![
"HTTP/1.1 200 OK\r\n\r\n<html><head></head></html>".to_string(),
]);
let ctx = PortContext::new(addr.port(), Protocol::Tcp)
.with_addr(Some(addr))
.with_speaks_http(true);
let collected = FaviconAnalyzer.collect(&ctx, &responses).await;
let asked = server.await.unwrap();
assert_eq!(collected.frames.first().map(Vec::as_slice), Some(ICON));
assert!(
asked.contains(&CONVENTIONAL_PATH.to_string()),
"the convention should be tried when nothing is declared, got {asked:?}"
);
}
#[test]
fn a_known_digest_names_the_application_that_serves_it() {
let evidence = crate::fingerprint::SignatureDb::global()
.identify_field("4297c114f263c206ed12aaff4b0c7a50")
.expect("the corpus names it");
assert_eq!(evidence.product.as_deref(), Some("Metabase"));
}
#[test]
fn a_match_states_the_application_in_both_slots() {
let found = Evidence::new(
SourceId::BannerRegex,
crate::model::confidence::Confidence::Probable,
)
.with_service("favicons.xml")
.with_product("Metabase");
let marked = as_application(found);
assert_eq!(marked.source, SourceId::Favicon);
assert_eq!(marked.product.as_deref(), Some("Metabase"));
assert_eq!(marked.extrainfo.as_deref(), Some("Metabase"));
}
#[test]
fn a_match_naming_no_product_states_nothing_beside_it() {
let found = Evidence::new(
SourceId::BannerRegex,
crate::model::confidence::Confidence::Probable,
)
.with_service("favicons.xml");
assert_eq!(as_application(found).extrainfo, None);
}
#[tokio::test]
async fn an_endless_response_is_cut_off_at_the_cap() {
use tokio::net::TcpListener;
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
let (mut stream, _) = listener.accept().await.unwrap();
let mut buffer = [0u8; 512];
let _ = stream.read(&mut buffer).await;
stream
.write_all(b"HTTP/1.1 200 OK\r\nContent-Type: image/x-icon\r\n\r\n")
.await
.unwrap();
let chunk = vec![0xab; 32 * 1024];
for _ in 0..64 {
if stream.write_all(&chunk).await.is_err() {
break;
}
}
});
let icon = fetch(addr, "/favicon.ico").await.expect("a bounded body");
server.abort();
assert!(
icon.len() <= MAX_ICON_BYTES,
"read {} bytes, past the {MAX_ICON_BYTES} cap",
icon.len()
);
assert!(!icon.is_empty(), "what was read is still worth hashing");
}
const JELLYFIN: &str = r#"<html><head>
<link rel="apple-touch-icon" sizes="180x180" href="touchicon.f5bbb798cb2c65908633.png">
<link rel="shortcut icon" href="favicon.bc8d51405ec040305a87.ico">
</head></html>"#;
#[test]
fn a_declared_icon_is_read_out_of_the_markup() {
assert_eq!(
declared_icon(JELLYFIN),
Some("favicon.bc8d51405ec040305a87.ico")
);
}
#[test]
fn a_rel_that_merely_contains_icon_does_not_count() {
let only_touch = r#"<link rel="apple-touch-icon" href="touch.png">"#;
assert_eq!(declared_icon(only_touch), None);
let shortcut = r#"<link rel="shortcut icon" href="a.ico">"#;
assert_eq!(declared_icon(shortcut), Some("a.ico"));
}
#[test]
fn the_href_is_found_whatever_order_and_quoting_the_tag_uses() {
assert_eq!(
declared_icon(r#"<link href="/static/f.ico" rel="icon">"#),
Some("/static/f.ico")
);
assert_eq!(
declared_icon("<link rel='icon' href='/q.ico'>"),
Some("/q.ico")
);
}
#[test]
fn a_mixed_case_path_survives_the_search() {
assert_eq!(
declared_icon(r#"<link rel="ICON" href="/Static/FavIcon.ICO">"#),
Some("/Static/FavIcon.ICO")
);
}
#[test]
fn a_relative_icon_resolves_against_the_page_that_declared_it() {
assert_eq!(
resolve("/web/index.html", "favicon.bc8d51405ec040305a87.ico").as_deref(),
Some("/web/favicon.bc8d51405ec040305a87.ico")
);
assert_eq!(resolve("/", "favicon.ico").as_deref(), Some("/favicon.ico"));
assert_eq!(
resolve("/web/index.html", "/f.ico").as_deref(),
Some("/f.ico")
);
}
#[test]
fn an_icon_on_another_host_is_declined() {
assert_eq!(resolve("/", "https://cdn.example/f.ico"), None);
assert_eq!(resolve("/", "//cdn.example/f.ico"), None);
assert_eq!(resolve("/", ""), None);
}
#[test]
fn an_inline_data_icon_is_not_mistaken_for_a_path() {
let inline = "data:image/vnd.microsoft.icon;base64,AAABAAEAEBAAAAEAIABoBAAA";
assert_eq!(resolve("/", inline), None);
assert_eq!(resolve("/", "mailto:someone@example.com"), None);
}
#[test]
fn a_colon_inside_a_path_is_still_a_path() {
assert_eq!(
resolve("/", "/assets/img:v2/f.ico").as_deref(),
Some("/assets/img:v2/f.ico")
);
}
#[test]
fn markup_declaring_no_icon_yields_nothing() {
assert_eq!(
declared_icon("<html><head><title>x</title></head></html>"),
None
);
assert_eq!(declared_icon(""), None);
}
#[tokio::test]
async fn the_declared_icon_is_fetched_from_a_root_that_redirects() {
use crate::model::port::Protocol;
use tokio::net::TcpListener;
const ICON: &[u8] = b"\x00\x00\x01\x00 the bytes only /web/ serves";
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
let mut asked = Vec::new();
for _ in 0..3 {
let Ok((mut stream, _)) = listener.accept().await else {
break;
};
let mut buffer = [0u8; 512];
let read = stream.read(&mut buffer).await.unwrap();
let path = String::from_utf8_lossy(&buffer[..read])
.split_whitespace()
.nth(1)
.unwrap_or_default()
.to_string();
match path.as_str() {
"/web/index.html" => {
let body =
format!("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n{JELLYFIN}");
stream.write_all(body.as_bytes()).await.unwrap();
}
"/web/favicon.bc8d51405ec040305a87.ico" => {
stream
.write_all(b"HTTP/1.1 200 OK\r\nContent-Type: image/x-icon\r\n\r\n")
.await
.unwrap();
stream.write_all(ICON).await.unwrap();
asked.push(path);
break;
}
_ => {
stream
.write_all(b"HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\n\r\n")
.await
.unwrap();
}
}
asked.push(path);
}
asked
});
let responses = ResponseSet::from_banners(vec![
"HTTP/1.1 302 Found\r\nLocation: /web/index.html\r\nServer: Kestrel\r\n\r\n"
.to_string(),
]);
let ctx = PortContext::new(addr.port(), Protocol::Tcp)
.with_addr(Some(addr))
.with_speaks_http(true);
let collected = FaviconAnalyzer.collect(&ctx, &responses).await;
let asked = server.await.unwrap();
assert_eq!(collected.frames.first().map(Vec::as_slice), Some(ICON));
assert_eq!(
asked,
vec![
"/web/index.html".to_string(),
"/web/favicon.bc8d51405ec040305a87.ico".to_string(),
],
"the conventional path should not be asked for once a page declares one"
);
}
#[test]
fn a_here_segment_is_dropped_from_a_declared_path() {
assert_eq!(
resolve("/query", "./favicon.svg").as_deref(),
Some("/favicon.svg")
);
assert_eq!(
resolve("/web/index.html", "./f.ico").as_deref(),
Some("/web/f.ico")
);
}
#[tokio::test]
async fn a_banner_that_is_not_the_page_still_leads_to_the_root() {
use crate::model::port::Protocol;
use tokio::net::TcpListener;
const ICON: &[u8] = b"\x89PNG the icon only the root leads to";
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
let mut asked = Vec::new();
loop {
let Ok((mut stream, _)) = listener.accept().await else {
break;
};
let mut buffer = [0u8; 512];
let read = stream.read(&mut buffer).await.unwrap();
let path = String::from_utf8_lossy(&buffer[..read])
.split_whitespace()
.nth(1)
.unwrap_or_default()
.to_string();
asked.push(path.clone());
match path.as_str() {
"/" => {
stream
.write_all(b"HTTP/1.1 302 Found\r\nLocation: /login\r\nContent-Length: 0\r\n\r\n")
.await
.unwrap();
}
"/login" => {
let body = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n\
<html><head><link rel=\"icon\" href=\"static/fav32.png\"></head></html>";
stream.write_all(body.as_bytes()).await.unwrap();
}
"/static/fav32.png" => {
stream
.write_all(b"HTTP/1.1 200 OK\r\nContent-Type: image/png\r\n\r\n")
.await
.unwrap();
stream.write_all(ICON).await.unwrap();
break;
}
_ => {
stream
.write_all(b"HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\n\r\n")
.await
.unwrap();
}
}
}
asked
});
let responses = ResponseSet::from_banners(vec![
"HTTP/1.1 400 Bad Request\r\nContent-Length: 0\r\n\r\n".to_string(),
]);
let ctx = PortContext::new(addr.port(), Protocol::Tcp)
.with_addr(Some(addr))
.with_speaks_http(true);
let collected = FaviconAnalyzer.collect(&ctx, &responses).await;
let asked = server.await.unwrap();
assert_eq!(collected.frames.first().map(Vec::as_slice), Some(ICON));
assert_eq!(asked, vec!["/", "/login", "/static/fav32.png"]);
}
#[tokio::test]
async fn a_redirect_on_the_icon_itself_is_followed() {
use tokio::net::TcpListener;
const ICON: &[u8] = b"\x00\x00\x01\x00 behind a redirect";
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
for _ in 0..2 {
let Ok((mut stream, _)) = listener.accept().await else {
break;
};
let mut buffer = [0u8; 512];
let read = stream.read(&mut buffer).await.unwrap();
let path = String::from_utf8_lossy(&buffer[..read])
.split_whitespace()
.nth(1)
.unwrap_or_default()
.to_string();
if path == "/real.ico" {
stream.write_all(b"HTTP/1.1 200 OK\r\n\r\n").await.unwrap();
stream.write_all(ICON).await.unwrap();
} else {
stream
.write_all(b"HTTP/1.1 302 Found\r\nLocation: /real.ico\r\nContent-Length: 0\r\n\r\n")
.await
.unwrap();
}
}
});
let icon = fetch(addr, "/favicon.ico").await;
server.await.unwrap();
assert_eq!(icon.as_deref(), Some(ICON));
}
}