pub mod model;
pub mod os;
mod analyzer;
mod context;
mod db;
mod extract;
mod favicon;
mod framed;
mod http;
mod jarm;
mod matcher;
pub(crate) mod pattern;
mod prefilter;
mod response;
mod signature;
mod sip;
mod snmp;
mod ssh;
mod tls;
mod tls_cert;
mod tls_enum;
mod tls_summary;
#[cfg(test)]
mod corpus;
#[cfg(test)]
mod pattern_properties;
pub use analyzer::{Analyzer, BannerRegexAnalyzer, PortContext};
pub use db::{InvalidDefinition, SignatureDb};
pub use favicon::FaviconAnalyzer;
#[cfg(any(test, feature = "test-support"))]
pub use favicon::digest_of as favicon_digest;
pub use http::HttpHeadersAnalyzer;
pub use jarm::JarmAnalyzer;
pub use model::{Evidence, ServiceVerdict, SourceId, Tunnel};
pub use response::{Collected, ResponseSet, TlsInfo};
pub use context::{CONTEXTS, Context, Reach, context_note, reach_of};
pub use signature::{
CORPUS_ROOT, DefinitionError, MAX_COMPILED_REGEX_BYTES, MAX_UDP_PROBE_BYTES, MatchRule, Probe,
RULE_ID_SEPARATOR, RuleIdDefect, ServiceDefinition, ServiceSignature, claim_rule_id,
corpus_slug, rule_id,
};
pub(crate) use signature::unescape;
pub use ssh::SshAnalyzer;
pub use tls_cert::TlsCertAnalyzer;
pub use tls_enum::{EXCHANGE_TIMEOUT, MAX_OFFERS_PER_VERSION, enumerate_tls};
use std::net::SocketAddr;
use std::time::Duration;
use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
use tokio::net::TcpStream;
use tokio::time::timeout;
use crate::config::ServiceDetection;
use crate::model::port::{Port, PortState, Protocol, Service};
const BANNER_READ_TIMEOUT: Duration = Duration::from_millis(500);
const PROBE_READ_TIMEOUT: Duration = Duration::from_millis(1_000);
const CONTINUATION_GRACE: Duration = Duration::from_millis(50);
const USER_AGENT: &str = "ZondScanner/1.0";
const CONNECT_RETRY_TIMEOUT: Duration = Duration::from_millis(500);
const MAX_RESPONSE_BYTES: usize = 4096;
pub const MAX_IDENTITY_BYTES: usize = 256;
pub(crate) fn identity_field(value: &str) -> Option<&str> {
let value = value.trim();
(!value.is_empty() && value.len() <= MAX_IDENTITY_BYTES).then_some(value)
}
const MAX_CONTINUATION: Duration = Duration::from_secs(2);
const COLLECTION_BUDGET: Duration = Duration::from_secs(25);
#[must_use]
pub fn reads_replies(port: u16, protocol: Protocol) -> bool {
extract::reads(port, protocol)
}
pub fn lookup_service_name(port: u16) -> Option<String> {
SignatureDb::global()
.service_name(port)
.map(|s| s.to_string())
}
#[derive(Debug, Clone, Default)]
pub struct AboutTheHost {
pub os: Vec<crate::model::host::OsEvidence>,
pub hardware: Option<crate::model::host::HardwareInfo>,
}
impl AboutTheHost {
pub fn is_empty(&self) -> bool {
self.os.is_empty() && self.hardware.is_none()
}
pub fn apply(self, host: &mut crate::model::host::Host) -> bool {
if let Some(described) = self.hardware {
match host.hardware().cloned() {
Some(mut known) => {
known.merge(described);
host.set_hardware(known);
}
None => host.set_hardware(described),
}
}
os::identify(host, self.os)
}
fn from_evidence(evidence: &[Evidence]) -> Self {
Self {
os: evidence.iter().filter_map(|e| e.os.clone()).collect(),
hardware: evidence
.iter()
.filter_map(|e| e.hardware.as_ref())
.cloned()
.reduce(|mut best, other| {
best.merge(other);
best
}),
}
}
}
pub fn decode_udp_reply(port: u16, datagram: &[u8]) -> Vec<String> {
extract::from_datagram(port, datagram)
}
pub fn tls_security(tls: &TlsInfo) -> crate::model::port::Security {
tls_summary::security(tls)
}
pub fn baseline_service(port: u16) -> Option<Service> {
lookup_service_name(port).map(|name| Service::new(name, 0))
}
pub fn baseline_port(port: u16, protocol: Protocol, state: PortState) -> Port {
let mut classified = Port::new(port, protocol, state);
if let Some(service) = baseline_service(port) {
classified.set_service(service);
}
classified
}
pub async fn fingerprint_tcp(stream: TcpStream, port: Port, detection: ServiceDetection) -> Port {
fingerprint_tcp_detailed(stream, port, detection).await.0
}
pub async fn fingerprint_tcp_detailed(
stream: TcpStream,
mut port: Port,
detection: ServiceDetection,
) -> (Port, AboutTheHost, Vec<String>) {
let addr = stream.peer_addr().ok();
let Ok((responses, tunnel)) =
timeout(COLLECTION_BUDGET, gather(stream, port.number(), detection)).await
else {
return (port, AboutTheHost::default(), Vec::new());
};
if responses.is_empty() {
return (port, AboutTheHost::default(), Vec::new());
}
if let Some(tls) = responses.tls.as_ref() {
port.set_security(tls_summary::security(tls));
}
let fallback = first_printable(&responses.banners);
let banners = responses.banners.clone();
let mut about_the_host = AboutTheHost::default();
match analyze(
port.number(),
Protocol::Tcp,
addr,
responses,
tunnel,
detection,
)
.await
{
Some(verdict) if !verdict.is_empty() => {
about_the_host = AboutTheHost::from_evidence(&verdict.evidence);
if let Some(service) = verdict.to_service() {
port.set_service(service);
}
}
_ => {
if let Some(banner) = fallback {
port.set_service(Service::new(format!("banner: {banner}"), 0));
}
}
}
(port, about_the_host, banners)
}
pub async fn fingerprint_udp_detailed(
addr: std::net::SocketAddr,
mut port: Port,
) -> Option<(Port, AboutTheHost, Vec<String>)> {
let texts = probe_udp(addr).await?;
let responses = ResponseSet::from_banners(texts);
let banners = responses.banners.clone();
let verdict = analyze(
addr.port(),
Protocol::Udp,
None,
responses,
None,
ServiceDetection::default(),
)
.await
.filter(|verdict| !verdict.is_empty())?;
let about_the_host = AboutTheHost::from_evidence(&verdict.evidence);
if let Some(service) = verdict.to_service() {
port.set_service(service);
}
Some((port, about_the_host, banners))
}
async fn probe_udp(addr: std::net::SocketAddr) -> Option<Vec<String>> {
for payload in SignatureDb::global().udp_probe_payloads(addr.port()) {
let texts = probe_udp_with(addr, payload).await;
if !texts.is_empty() {
return Some(texts);
}
}
None
}
pub async fn probe_udp_with(addr: std::net::SocketAddr, payload: &[u8]) -> Vec<String> {
match probe_udp_raw(addr, payload).await {
Some(reply) => extract::from_datagram(addr.port(), &reply),
None => Vec::new(),
}
}
pub async fn probe_udp_raw(addr: std::net::SocketAddr, payload: &[u8]) -> Option<Vec<u8>> {
let bind = if addr.is_ipv4() {
"0.0.0.0:0"
} else {
"[::]:0"
};
let socket = tokio::net::UdpSocket::bind(bind).await.ok()?;
socket.connect(addr).await.ok()?;
socket.send(payload).await.ok()?;
let mut buffer = vec![0u8; MAX_RESPONSE_BYTES];
let read = timeout(PROBE_READ_TIMEOUT, socket.recv(&mut buffer))
.await
.ok()?
.ok()?;
buffer.truncate(read);
Some(buffer)
}
async fn gather(
mut stream: TcpStream,
port: u16,
detection: ServiceDetection,
) -> (ResponseSet, Option<Tunnel>) {
if !detection.connects() {
return (ResponseSet::default(), None);
}
if !detection.sends() {
let banner = read_response(&mut stream, BANNER_READ_TIMEOUT).await;
return (
ResponseSet::from_banners(banner.into_iter().collect()),
None,
);
}
let Ok(socket) = stream.peer_addr() else {
return (plaintext(&mut stream, port, None).await, None);
};
let mut opened = Some(stream);
for rung in Rung::ladder(port) {
let stream = match opened.take() {
Some(stream) => stream,
None => match redial(socket).await {
Some(fresh) => fresh,
None => return (ResponseSet::default(), None),
},
};
let (responses, tunnel) = rung.ask(stream, port, socket, detection).await;
if !responses.is_empty() {
return (responses, tunnel);
}
}
(ResponseSet::default(), None)
}
async fn redial(socket: SocketAddr) -> Option<TcpStream> {
match timeout(CONNECT_RETRY_TIMEOUT, TcpStream::connect(socket)).await {
Ok(Ok(fresh)) => Some(fresh),
_ => None,
}
}
#[derive(Clone, Copy)]
enum Rung {
Tls,
SpeculativeTls,
LegacyTls,
Plaintext,
LastResort,
}
impl Rung {
fn ladder(port: u16) -> &'static [Rung] {
if tls::is_tls_port(port) {
&[
Rung::Tls,
Rung::LegacyTls,
Rung::Plaintext,
Rung::LastResort,
]
} else {
&[Rung::Plaintext, Rung::SpeculativeTls, Rung::LastResort]
}
}
async fn ask(
self,
mut stream: TcpStream,
port: u16,
socket: SocketAddr,
detection: ServiceDetection,
) -> (ResponseSet, Option<Tunnel>) {
match self {
Rung::Tls => tunneled(tls::handshake(stream, socket.ip()).await, port).await,
Rung::SpeculativeTls => {
tunneled(tls::speculative_handshake(stream, socket.ip()).await, port).await
}
Rung::LegacyTls => (legacy_tls(stream).await, None),
Rung::Plaintext => (plaintext(&mut stream, port, Some(socket)).await, None),
Rung::LastResort => (last_resort(stream, socket, port, detection).await, None),
}
}
}
async fn last_resort(
first: TcpStream,
socket: SocketAddr,
port: u16,
detection: ServiceDetection,
) -> ResponseSet {
let probes =
SignatureDb::global().universal_tcp_probe_payloads(port, detection.probe_intensity());
let mut replies = Vec::new();
let mut opened = Some(first);
for payload in probes {
let Some(mut stream) = (match opened.take() {
Some(stream) => Some(stream),
None => redial(socket).await,
}) else {
break;
};
if stream.write_all(payload).await.is_err() {
continue;
}
if let Some(reply) = read_document(&mut stream, PROBE_READ_TIMEOUT).await {
replies.push(reply);
}
}
ResponseSet::from_banners(replies)
}
async fn plaintext(stream: &mut TcpStream, port: u16, socket: Option<SocketAddr>) -> ResponseSet {
let probes = SignatureDb::global().tcp_probe_payloads(port);
if !probes.is_empty() {
let banners = collect_responses(stream, port, probes).await;
if banners
.first()
.is_some_and(|first| looks_like_tls(first.as_bytes()))
{
return ResponseSet::default();
}
return ResponseSet::from_banners(banners);
}
match ask_generically(stream, socket).await {
GenericReply::Spoke(banners) => ResponseSet::from_banners(banners),
GenericReply::Tls | GenericReply::Silent => ResponseSet::default(),
}
}
enum GenericReply {
Spoke(Vec<String>),
Tls,
Silent,
}
async fn ask_generically(stream: &mut TcpStream, socket: Option<SocketAddr>) -> GenericReply {
for payload in SignatureDb::global().generic_tcp_probe_payloads() {
if stream.write_all(payload).await.is_err() {
break;
}
}
let Some(bytes) = read_bytes(stream, PROBE_READ_TIMEOUT, CONTINUATION_GRACE).await else {
return GenericReply::Silent;
};
if looks_like_tls(&bytes) {
return GenericReply::Tls;
}
let first = String::from_utf8_lossy(&bytes).into_owned();
let followed = match (socket, redirect_path(&first, socket)) {
(Some(socket), Some(path)) => follow_redirect(socket, &path).await,
_ => None,
};
GenericReply::Spoke(std::iter::once(first).chain(followed).collect())
}
fn redirect_path(response: &str, peer: Option<SocketAddr>) -> Option<String> {
let (status, headers) = response.split_once("\r\n").or(response.split_once('\n'))?;
let code: u16 = status.split_whitespace().nth(1)?.parse().ok()?;
if !(300..400).contains(&code) {
return None;
}
let location = headers
.lines()
.take_while(|line| !line.trim_end_matches('\r').is_empty())
.find_map(|line| {
let (name, value) = line.split_once(':')?;
name.trim()
.eq_ignore_ascii_case("location")
.then(|| value.trim())
})?;
if location.is_empty() || location.chars().any(char::is_control) {
return None;
}
match location {
url if url.contains("://") || url.starts_with("//") => same_host_path(url, peer?),
path if path.starts_with('/') => Some(path.to_string()),
relative => Some(format!("/{relative}")),
}
}
fn same_host_path(url: &str, peer: SocketAddr) -> Option<String> {
let after_scheme = match url.split_once("://") {
Some(("http", rest)) => rest,
None => url.strip_prefix("//")?,
Some(_) => return None,
};
let (authority, path) = match after_scheme.find('/') {
Some(at) => after_scheme.split_at(at),
None => (after_scheme, "/"),
};
let expected = [
format!("{}:{}", peer.ip(), peer.port()),
match peer.port() {
80 => peer.ip().to_string(),
_ => String::new(),
},
];
expected
.iter()
.any(|name| !name.is_empty() && name.eq_ignore_ascii_case(authority))
.then(|| path.to_string())
}
async fn follow_redirect(socket: SocketAddr, path: &str) -> Option<String> {
let mut stream = timeout(CONNECT_RETRY_TIMEOUT, TcpStream::connect(socket))
.await
.ok()?
.ok()?;
let request = format!(
"GET {path} HTTP/1.1\r\nHost: {}\r\nUser-Agent: {USER_AGENT}\r\n\
Accept: */*\r\nConnection: close\r\n\r\n",
socket.ip()
);
stream.write_all(request.as_bytes()).await.ok()?;
read_document(&mut stream, PROBE_READ_TIMEOUT).await
}
fn looks_like_tls(bytes: &[u8]) -> bool {
matches!(bytes, [0x14..=0x17, 0x03, 0x00..=0x04, ..])
}
async fn legacy_tls(stream: TcpStream) -> ResponseSet {
match tls::legacy_version(stream).await {
Some(version) => {
ResponseSet::default().with_tls(TlsInfo::new(Vec::new()).with_version(version))
}
None => ResponseSet::default(),
}
}
async fn tunneled(
handshake: Option<(tls::TlsTunnel, TlsInfo)>,
port: u16,
) -> (ResponseSet, Option<Tunnel>) {
let Some((mut tunnel, info)) = handshake else {
return (ResponseSet::default(), None);
};
let db = SignatureDb::global();
let probes = match db.tcp_probe_payloads(port) {
[] => db.generic_tcp_probe_payloads(),
own => own,
};
let banners = collect_responses(&mut tunnel, port, probes).await;
let responses = ResponseSet {
banners,
tls: Some(info),
};
(responses, Some(Tunnel::Tls))
}
async fn collect_responses<S>(stream: &mut S, port: u16, probes: &[Vec<u8>]) -> Vec<String>
where
S: AsyncRead + AsyncWrite + Unpin,
{
let mut banners = Vec::new();
if let Some(banner) = read_response(stream, BANNER_READ_TIMEOUT).await {
banners.push(banner);
}
for payload in probes {
if stream.write_all(payload).await.is_err() {
break;
}
let Some(bytes) = read_bytes(stream, PROBE_READ_TIMEOUT, CONTINUATION_GRACE).await else {
continue;
};
banners.extend(extract::from_stream(port, &bytes));
banners.push(String::from_utf8_lossy(&bytes).into_owned());
}
banners
}
static ANALYZERS: &[&dyn Analyzer] = &[
&BannerRegexAnalyzer,
&FaviconAnalyzer,
&HttpHeadersAnalyzer,
&JarmAnalyzer,
&SshAnalyzer,
&TlsCertAnalyzer,
];
#[must_use]
pub fn analyzers() -> &'static [&'static dyn Analyzer] {
ANALYZERS
}
async fn analyze(
port: u16,
protocol: Protocol,
addr: Option<std::net::SocketAddr>,
responses: ResponseSet,
tunnel: Option<Tunnel>,
detection: ServiceDetection,
) -> Option<ServiceVerdict> {
let speaks_http = responses
.banners
.iter()
.any(|banner| banner.starts_with("HTTP/"));
let ctx = PortContext::new(port, protocol)
.with_addr(addr)
.with_tunnel(tunnel)
.with_speaks_http(speaks_http)
.with_detection(detection);
analyze_with(ctx, responses, analyzers()).await
}
pub async fn analyze_with(
ctx: PortContext,
responses: ResponseSet,
analyzers: &'static [&'static dyn Analyzer],
) -> Option<ServiceVerdict> {
let mut collected = Vec::with_capacity(analyzers.len());
for analyzer in analyzers {
let interested = analyzer.interested(&ctx);
collected.push((
interested,
match interested {
true => analyzer.collect(&ctx, &responses).await,
false => Collected::default(),
},
));
}
tokio::task::spawn_blocking(move || {
let mut evidence = Vec::new();
for (analyzer, (interested, collected)) in analyzers.iter().zip(&collected) {
if *interested {
evidence.extend(analyzer.analyze(&ctx, &responses, collected));
}
}
(!evidence.is_empty()).then(|| ServiceVerdict::resolve(evidence))
})
.await
.ok()
.flatten()
}
async fn read_response<S>(stream: &mut S, wait: Duration) -> Option<String>
where
S: AsyncRead + Unpin,
{
read_bytes(stream, wait, Duration::ZERO)
.await
.map(|bytes| String::from_utf8_lossy(&bytes).into_owned())
}
async fn read_document<S>(stream: &mut S, wait: Duration) -> Option<String>
where
S: AsyncRead + Unpin,
{
read_bytes(stream, wait, CONTINUATION_GRACE)
.await
.map(|bytes| String::from_utf8_lossy(&bytes).into_owned())
}
async fn read_bytes<S>(stream: &mut S, wait: Duration, grace: Duration) -> Option<Vec<u8>>
where
S: AsyncRead + Unpin,
{
let mut collected: Vec<u8> = Vec::new();
let mut buffer = [0u8; MAX_RESPONSE_BYTES];
let mut budget = wait;
let mut deadline = None;
while collected.len() < MAX_RESPONSE_BYTES {
match timeout(budget, stream.read(&mut buffer)).await {
Ok(Ok(n)) if n > 0 => {
let room = MAX_RESPONSE_BYTES - collected.len();
collected.extend_from_slice(&buffer[..n.min(room)]);
if grace.is_zero() {
break;
}
let deadline =
*deadline.get_or_insert_with(|| tokio::time::Instant::now() + MAX_CONTINUATION);
let remaining = deadline.saturating_duration_since(tokio::time::Instant::now());
if remaining.is_zero() {
break;
}
budget = grace.min(remaining);
}
_ => break,
}
}
(!collected.is_empty()).then_some(collected)
}
fn first_printable(responses: &[String]) -> Option<String> {
let printable: String = responses
.iter()
.flat_map(|response| response.chars())
.filter(|c| c.is_ascii_graphic() || *c == ' ')
.take(32)
.collect();
(!printable.is_empty()).then_some(printable)
}
#[cfg(test)]
mod tests {
#[test]
fn an_unregistered_port_is_seeded_with_nothing() {
assert!(baseline_service(22).is_some());
let unregistered = (40_000..=65_535)
.find(|port| lookup_service_name(*port).is_none())
.expect("some port in the ephemeral range is unregistered");
assert!(
baseline_service(unregistered).is_none(),
"port {unregistered} invented a service name"
);
assert!(
baseline_port(unregistered, Protocol::Tcp, PortState::Closed)
.service()
.is_none()
);
}
#[test]
fn an_sctp_port_is_named_by_the_service_that_claims_its_number() {
let port = baseline_port(2905, Protocol::Sctp, PortState::Open);
let service = port.service().expect("m3ua claims 2905");
assert_eq!(service.name(), "m3ua");
assert!(
service.is_inferred(),
"nothing asked the port what it was running"
);
}
#[test]
fn a_seeded_label_is_never_mistaken_for_an_identification() {
let seeded = baseline_service(22).expect("ssh is registered");
assert_eq!(seeded.name(), "ssh");
assert!(
seeded.is_inferred(),
"nothing asked port 22 what it was running"
);
}
#[test]
fn a_same_host_redirect_names_where_to_look_next() {
let jellyfin = "HTTP/1.1 302 Found\r\n\
Location: /web/index.html\r\n\
Server: Kestrel\r\n\r\n";
assert_eq!(
redirect_path(jellyfin, Some(peer())).as_deref(),
Some("/web/index.html")
);
}
fn peer() -> std::net::SocketAddr {
"127.0.0.1:8096".parse().expect("a literal address")
}
#[test]
fn a_relative_location_resolves_against_the_root_it_was_served_from() {
let jellyfin = "HTTP/1.1 302 Found\r\nLocation: web/\r\nServer: Kestrel\r\n\r\n";
assert_eq!(
redirect_path(jellyfin, Some(peer())).as_deref(),
Some("/web/")
);
}
#[test]
fn an_absolute_location_naming_the_scanned_host_is_followed() {
let grafana = "HTTP/1.1 302 Found\r\nLocation: http://127.0.0.1:8096/login\r\n\r\n";
assert_eq!(
redirect_path(grafana, Some(peer())).as_deref(),
Some("/login")
);
let bare = "HTTP/1.1 302 Found\r\nLocation: http://127.0.0.1:8096\r\n\r\n";
assert_eq!(redirect_path(bare, Some(peer())).as_deref(), Some("/"));
}
#[test]
fn an_absolute_location_on_another_port_is_declined() {
let elsewhere = "HTTP/1.1 302 Found\r\nLocation: http://127.0.0.1:9999/x\r\n\r\n";
assert_eq!(redirect_path(elsewhere, Some(peer())), None);
}
#[test]
fn an_upgrade_to_https_is_declined_rather_than_guessed() {
let upgrade = "HTTP/1.1 301 Moved\r\nLocation: https://127.0.0.1:8096/\r\n\r\n";
assert_eq!(redirect_path(upgrade, Some(peer())), None);
}
#[test]
fn an_absolute_location_is_declined_when_there_is_no_peer_to_check() {
let named = "HTTP/1.1 302 Found\r\nLocation: http://127.0.0.1:8096/login\r\n\r\n";
assert_eq!(redirect_path(named, None), None);
}
#[test]
fn a_scheme_relative_location_is_declined_like_any_other_host() {
let elsewhere = "HTTP/1.1 302 Found\r\nLocation: //cdn.example/web/\r\n\r\n";
assert_eq!(redirect_path(elsewhere, Some(peer())), None);
let here = "HTTP/1.1 302 Found\r\nLocation: //127.0.0.1:8096/web/\r\n\r\n";
assert_eq!(redirect_path(here, Some(peer())).as_deref(), Some("/web/"));
}
#[test]
fn a_redirect_off_the_host_is_declined() {
for location in [
"https://example.com/login",
"http://somewhere.else/",
"https://127.0.0.1/web/",
"/web/\rX-Injected: 1",
"/web/\u{0}index.html",
] {
let response = format!("HTTP/1.1 302 Found\r\nLocation: {location}\r\n\r\n");
assert_eq!(
redirect_path(&response, Some(peer())),
None,
"`{location}` is not somewhere this scan may follow"
);
}
}
#[test]
fn a_response_that_is_not_a_redirect_names_nowhere_to_go() {
assert_eq!(
redirect_path(
"HTTP/1.1 200 OK\r\nLocation: /ignored\r\n\r\n",
Some(peer())
),
None,
"a 200 is an answer, whatever else it carries"
);
assert_eq!(
redirect_path("HTTP/1.1 302 Found\r\nServer: nginx\r\n\r\n", Some(peer())),
None,
"and a redirect naming nowhere leads nowhere"
);
assert_eq!(
redirect_path("SSH-2.0-OpenSSH_9.2p1\r\n", Some(peer())),
None
);
assert_eq!(redirect_path("", Some(peer())), None);
}
#[test]
fn a_tls_alert_is_recognised_as_tls_rather_than_as_a_banner() {
assert!(looks_like_tls(&[0x15, 0x03, 0x03, 0x00, 0x02, 0x02, 0x0A]));
assert!(looks_like_tls(&[0x16, 0x03, 0x01, 0x00, 0x2A]));
assert!(!looks_like_tls(b"HTTP/1.1 200 OK"));
assert!(!looks_like_tls(b"SSH-2.0-OpenSSH_9.2p1"));
assert!(!looks_like_tls(&[0x15]), "too short to be a record");
assert!(!looks_like_tls(&[]));
}
use super::*;
#[tokio::test]
async fn analyze_runs_both_phases_and_resolves() {
let responses = ResponseSet::from_banners(vec!["SSH-2.0-OpenSSH_9.6p1 Debian".to_string()]);
let verdict = analyze(
22,
Protocol::Tcp,
None,
responses,
None,
ServiceDetection::default(),
)
.await
.expect("names a service");
assert_eq!(verdict.service.as_deref(), Some("ssh"));
assert_eq!(verdict.product.as_deref(), Some("OpenSSH"));
assert_eq!(verdict.version.as_deref(), Some("9.6p1"));
}
#[tokio::test]
async fn analyze_identifies_a_long_tail_http_server_end_to_end() {
let responses = ResponseSet::from_banners(vec![
"HTTP/1.1 200 OK\r\nServer: gunicorn/21.2.0\r\nContent-Type: text/html\r\n\r\n"
.to_string(),
]);
let verdict = analyze(
8000,
Protocol::Tcp,
None,
responses,
None,
ServiceDetection::default(),
)
.await
.expect("names a service");
assert_eq!(verdict.service.as_deref(), Some("http"));
assert_eq!(verdict.product.as_deref(), Some("Gunicorn"));
assert_eq!(verdict.version.as_deref(), Some("21.2.0"));
assert_eq!(
verdict.cpe.as_deref(),
Some("cpe:/a:gunicorn:gunicorn:21.2.0"),
"the reading that won the slot is the one the correlator can use"
);
}
#[tokio::test]
async fn analyze_composes_curated_product_vendor_with_powered_by_extrainfo() {
let responses = ResponseSet::from_banners(vec![
"HTTP/1.1 200 OK\r\nServer: Apache/2.4.58\r\nX-Powered-By: PHP/8.2.1\r\n\r\n"
.to_string(),
]);
let service = analyze(
80,
Protocol::Tcp,
None,
responses,
None,
ServiceDetection::default(),
)
.await
.expect("names a service")
.to_service()
.expect("projects onto a service");
assert_eq!(service.name(), "http");
assert_eq!(service.product(), Some("Apache HTTP Server"));
assert_eq!(service.vendor(), Some("Apache Software Foundation"));
assert_eq!(service.version(), Some("2.4.58"));
assert_eq!(service.extrainfo(), Some("PHP/8.2.1"));
}
#[tokio::test]
async fn analyze_resolves_a_versionless_server_to_its_name_not_generic_http() {
let responses = ResponseSet::from_banners(vec![
"HTTP/1.1 403 Forbidden\r\nServer: cloudflare\r\n\r\n".to_string(),
]);
let verdict = analyze(
8000,
Protocol::Tcp,
None,
responses,
None,
ServiceDetection::default(),
)
.await
.expect("names a service");
assert_eq!(verdict.service.as_deref(), Some("http"));
assert_eq!(verdict.product.as_deref(), Some("cloudflare"));
}
#[tokio::test]
async fn a_hostile_response_cannot_fill_a_report_field() {
use tokio::net::{TcpListener, TcpStream};
let listener = TcpListener::bind("127.0.0.1:0").await.expect("a socket");
let addr = listener.local_addr().expect("its address");
let server = tokio::spawn(async move {
let Ok((mut sock, _)) = listener.accept().await else {
return;
};
let long = "A".repeat(1_500);
let response =
format!("HTTP/1.1 200 OK\r\nServer: {long}\r\nX-Powered-By: {long}\r\n\r\n");
let _ = sock.write_all(response.as_bytes()).await;
let mut buffer = [0u8; MAX_RESPONSE_BYTES];
let _ = sock.read(&mut buffer).await;
});
let stream = TcpStream::connect(addr).await.expect("connects");
let port = baseline_port(80, Protocol::Tcp, PortState::Open);
let identified = fingerprint_tcp(stream, port, ServiceDetection::Probe).await;
server.abort();
let service = identified.service().expect("the port is still named");
for (field, value) in [
("product", service.product()),
("version", service.version()),
("extrainfo", service.extrainfo()),
] {
if let Some(value) = value {
assert!(
value.len() <= MAX_IDENTITY_BYTES,
"{field} is {} bytes, past the bound",
value.len()
);
}
}
assert_eq!(
service.product(),
None,
"a fifteen-hundred-byte token is refused rather than truncated"
);
}
#[test]
fn an_ordinary_identity_field_passes_through() {
assert_eq!(identity_field("nginx/1.24.0"), Some("nginx/1.24.0"));
assert_eq!(identity_field(" PHP/8.2.1 "), Some("PHP/8.2.1"));
assert_eq!(identity_field(""), None);
assert_eq!(identity_field(" "), None);
assert_eq!(
identity_field(&"A".repeat(MAX_IDENTITY_BYTES)).map(str::len),
Some(MAX_IDENTITY_BYTES)
);
assert_eq!(identity_field(&"A".repeat(MAX_IDENTITY_BYTES + 1)), None);
}
#[tokio::test]
async fn a_server_that_speaks_only_tls_ten_is_still_recorded() {
use tokio::net::{TcpListener, TcpStream};
let listener = TcpListener::bind("127.0.0.1:0").await.expect("a socket");
let addr = listener.local_addr().expect("its address");
let server = tokio::spawn(async move {
for round in 0..2 {
let Ok((mut sock, _)) = listener.accept().await else {
return;
};
let mut buffer = [0u8; 1024];
let _ = sock.read(&mut buffer).await;
let reply: &[u8] = match round {
0 => &[0x15, 0x03, 0x01, 0x00, 0x02, 0x02, 0x46],
_ => &[
0x16, 0x03, 0x01, 0x00, 0x2a, 0x02, 0x00, 0x00, 0x26, 0x03, 0x01,
],
};
let _ = sock.write_all(reply).await;
}
});
let stream = TcpStream::connect(addr).await.expect("connects");
let port = baseline_port(443, Protocol::Tcp, PortState::Open);
let (responses, tunnel) = gather(stream, 443, ServiceDetection::Probe).await;
server.abort();
let _ = port;
assert!(
tunnel.is_none(),
"nothing was tunnelled and nothing claims to be"
);
let tls = responses
.tls
.as_ref()
.expect("the port speaks TLS, which is the finding");
assert_eq!(tls.version, Some("TLSv1.0"));
assert_eq!(tls_security(tls).tls_version(), Some("TLSv1.0"));
}
#[tokio::test]
async fn a_trickling_port_cannot_hold_the_reader() {
use tokio::net::{TcpListener, TcpStream};
let listener = TcpListener::bind("127.0.0.1:0").await.expect("a socket");
let addr = listener.local_addr().expect("its address");
let server = tokio::spawn(async move {
let Ok((mut sock, _)) = listener.accept().await else {
return;
};
for _ in 0..2_000 {
if sock.write_all(b"A").await.is_err() {
return;
}
tokio::time::sleep(Duration::from_millis(40)).await;
}
});
let mut stream = TcpStream::connect(addr).await.expect("connects");
let started = std::time::Instant::now();
let read = read_document(&mut stream, PROBE_READ_TIMEOUT).await;
let held = started.elapsed();
server.abort();
assert!(read.is_some(), "what did arrive is still returned");
assert!(
held < PROBE_READ_TIMEOUT + MAX_CONTINUATION + Duration::from_secs(2),
"one trickling port held the reader for {held:?}"
);
}
#[test]
fn the_collection_budget_covers_every_path_through_gather() {
let probes = SignatureDb::global()
.indexed_ports()
.map(|port| SignatureDb::global().tcp_probe_payloads(port).len())
.max()
.unwrap_or(0)
.max(1) as u32;
let spoke =
|count: u32| BANNER_READ_TIMEOUT + (PROBE_READ_TIMEOUT + MAX_CONTINUATION) * count;
let silent = |count: u32| BANNER_READ_TIMEOUT + PROBE_READ_TIMEOUT * count;
let read_once = PROBE_READ_TIMEOUT + MAX_CONTINUATION;
let rung = CONNECT_RETRY_TIMEOUT;
let tls_all_three =
tls::TLS_HANDSHAKE_TIMEOUT + rung + tls::LEGACY_PROBE_TIMEOUT + rung + spoke(probes);
let tls_then_silence =
tls::TLS_HANDSHAKE_TIMEOUT + rung + tls::LEGACY_PROBE_TIMEOUT + rung + silent(probes);
let claimed_then_tls = silent(probes) + rung + tls::SPECULATIVE_TLS_TIMEOUT + spoke(probes);
let alert_then_tls = read_once + rung + tls::SPECULATIVE_TLS_TIMEOUT + spoke(1);
let unclaimed_then_redirect = read_once + rung + read_once;
let universal = SignatureDb::global()
.universal_tcp_probe_payloads(0, ServiceDetection::Thorough.probe_intensity())
.len()
.max(1) as u32;
let last_resort = (rung + read_once) * universal;
let worst = [
tls_all_three + last_resort,
tls_then_silence + last_resort,
claimed_then_tls,
alert_then_tls,
unclaimed_then_redirect,
silent(probes) + rung + tls::SPECULATIVE_TLS_TIMEOUT + last_resort,
]
.into_iter()
.max()
.expect("six paths");
assert!(
worst < COLLECTION_BUDGET,
"the budget ({COLLECTION_BUDGET:?}) is below the longest honest path \
({worst:?}), so it would cut real scans short"
);
}
#[tokio::test]
async fn analyze_returns_none_when_no_evidence() {
assert!(
analyze(
1,
Protocol::Tcp,
None,
ResponseSet::default(),
None,
ServiceDetection::default(),
)
.await
.is_none()
);
}
}