use std::collections::{BTreeSet, HashMap};
use std::net::IpAddr;
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
use std::time::Duration;
use tokio::net::TcpStream;
use crate::model::host::{Host, NetworkRole};
use crate::model::ip::scoped::ScopedIp;
use crate::warn;
use crate::config::ServiceDetection;
use crate::config::limits::{CONNECT_CONCURRENCY, CONNECT_PROBE_TIMEOUT};
use crate::detect::contention::HostContention;
use crate::fingerprint::Fingerprinted;
use crate::model::port::{Port, PortState, Protocol};
use crate::report::{Pass, ScannerKind};
use crate::scanner::pool::ProbePool;
use crate::scanner::session::{ScanContext, Stage};
use crate::system::descriptors;
use crate::transport::dial::Egress;
use crate::transport::dial::PathAllowance;
pub async fn detect(ctx: &ScanContext, detection: ServiceDetection, over: Protocol) {
identify(ctx, detection, over, Which::Every).await;
}
pub(crate) async fn detect_inherited(
ctx: &ScanContext,
detection: ServiceDetection,
over: Protocol,
) {
identify(ctx, detection, over, Which::Inherited).await;
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum Which {
Every,
Inherited,
}
async fn identify(ctx: &ScanContext, detection: ServiceDetection, over: Protocol, which: Which) {
if !detection.connects() {
return;
}
let tarpits = Tarpits::default();
let targets = fingerprintable_ports(ctx, over, detection, which, &tarpits);
if targets.is_empty() || ctx.stopping_before(Pass::Services) {
tarpits.report(ctx, ScannerKind::Service);
return;
}
ctx.enter_stage(Stage::Services, Some(targets.len() as u64));
let mut asked = 0;
let mut quiet = QuietPorts::default();
let mut in_part = QuietPorts::default();
let crowds = Crowds::default();
let mut pool = ProbePool::new(
CONNECT_CONCURRENCY,
ctx.clone(),
ScannerKind::Service,
|attempt: Attempt, _audit| {
ctx.stage_advanced();
match attempt {
Attempt::Identified(found) => {
let Identified {
ip,
port,
about_the_host,
banners,
identified_in_part,
} = *found;
if identified_in_part {
in_part.record(&ip, port.number(), Unreached::Starved);
}
ctx.record_responses(ip.clone(), port.number(), port.protocol(), banners);
write_back(ctx, ip, port, about_the_host);
}
Attempt::Unreachable { ip, number, reason } => {
quiet.record(&ip, number, reason);
}
Attempt::Quiet => {}
}
},
);
for target in targets {
if ctx.stopping_before(Pass::Services) {
break;
}
let address = target.address.addr();
if ctx.host_expired(address) {
continue;
}
let crowd = crowds.of(address, ctx.target_name(address));
let identifies = ctx.read_host(address, |host| {
tarpits.identifies(host, Some(&crowd), target.number, target.protocol)
});
if identifies == Some(false) {
ctx.stage_advanced();
continue;
}
asked += 1;
let egress = ctx.egress_toward(address);
let detection = ctx.service_detection_on(detection, target.number, target.protocol);
let identifying = fingerprint_one(target, detection, egress, crowd);
let handle = ctx.handle.clone();
pool.admit(async move {
handle
.or_stopped(identifying)
.await
.unwrap_or(Attempt::Quiet)
})
.await;
}
pool.drain().await;
drop(pool);
ctx.stopping_before(Pass::Services);
close_pass(ctx, &crowds, &quiet, in_part, asked).await;
tarpits.report(ctx, ScannerKind::Service);
}
async fn close_pass(
ctx: &ScanContext,
crowds: &Crowds,
quiet: &QuietPorts,
mut in_part: QuietPorts,
asked: usize,
) {
for (ip, port) in crowds.ask_again(ctx, ScannerKind::Service).await {
in_part.record(&ip, port, Unreached::Starved);
}
crowds.report_silence();
quiet.report(ctx, asked);
in_part.report_in_part(ctx);
}
const QUIET_PORTS_WORTH_A_WORD: usize = 10;
#[derive(Debug, Default)]
struct QuietPorts {
count: usize,
first: Option<String>,
reason: Option<Unreached>,
}
impl QuietPorts {
fn record(&mut self, ip: &ScopedIp, number: u16, reason: Unreached) {
self.count += 1;
if self.first.is_none() {
self.first = Some(ip.endpoint(number));
self.reason = Some(reason);
}
}
fn summary(first: &str, reason: &Unreached, count: usize) -> String {
format!(
"{} could not be fingerprinted: {}",
Self::named(first, count),
reason.said()
)
}
fn line(first: &str, reason: &Unreached, count: usize) -> String {
format!(
"{} not fingerprinted ({})",
Self::named_briefly(first, count),
reason.terse()
)
}
fn named_briefly(first: &str, count: usize) -> String {
match count - 1 {
0 => first.to_string(),
rest => format!("{first} and {rest} more"),
}
}
fn named(first: &str, count: usize) -> String {
match count - 1 {
0 => first.to_string(),
1 => format!("{first} and 1 other port"),
rest => format!("{first} and {rest} other ports"),
}
}
fn report_in_part(&self, ctx: &ScanContext) {
let (Some(first), Some(reason)) = (&self.first, &self.reason) else {
return;
};
warn!(
"{} identified in part ({})",
Self::named_briefly(first, self.count),
reason.terse()
);
ctx.file_cut_short(
ScannerKind::Service,
format!(
"{} identified in part: {}",
Self::named(first, self.count),
reason.said()
),
);
}
fn report(&self, ctx: &ScanContext, asked: usize) {
let (Some(first), Some(reason)) = (&self.first, &self.reason) else {
return;
};
warn!("{}", Self::line(first, reason, self.count));
ctx.file_cut_short(
ScannerKind::Service,
Self::summary(first, reason, self.count),
);
if self.count == asked && asked >= QUIET_PORTS_WORTH_A_WORD {
warn!("all {asked} open ports silent on connect (likely a middlebox)");
}
}
}
fn fingerprintable_ports(
ctx: &ScanContext,
over: Protocol,
detection: ServiceDetection,
which: Which,
tarpits: &Tarpits,
) -> Vec<Target> {
if over == Protocol::Udp && !detection.sends() {
return Vec::new();
}
let mut targets = Vec::new();
for host in ctx.store.iter() {
if !ctx.owes_passes(host.value()) {
continue;
}
let address = host.value().scoped_ip();
let path = PathAllowance::of_round_trips(host.value().telemetry().round_trips());
let first = targets.len();
for port in host.value().ports() {
if port.protocol() == over
&& port.state() == PortState::Open
&& crate::fingerprint::reads_replies(port.number(), port.protocol())
&& (which == Which::Every
|| ctx.responses_lost(&address, port.number(), port.protocol()))
&& tarpits.identifies(host.value(), None, port.number(), port.protocol())
{
targets.push(Target {
address: address.clone(),
number: port.number(),
protocol: port.protocol(),
path,
});
}
}
asking_order(&mut targets[first..], over);
}
targets
}
fn asking_order(host: &mut [Target], protocol: Protocol) {
let likeliest = likeliest(protocol);
let rank = |number: u16| likeliest.iter().position(|&likely| likely == number);
let mut rest: Vec<u16> = host
.iter()
.map(|target| target.number)
.filter(|&number| rank(number).is_none())
.collect();
rest.sort_unstable();
host.sort_by_cached_key(|target| match rank(target.number) {
Some(rank) => (0, rank),
None => {
let place = rest.binary_search(&target.number).unwrap_or_default();
(
1 + halvings_to_part_of_its_own(&rest, place),
usize::from(target.number),
)
}
});
}
fn halvings_to_part_of_its_own(sorted: &[u16], place: usize) -> usize {
match place.checked_sub(1).map(|below| sorted[below]) {
None => 0,
Some(below) => (below ^ sorted[place]).leading_zeros() as usize + 1,
}
}
fn likeliest(protocol: Protocol) -> &'static [u16] {
use crate::model::port::catalog::{top_tcp, top_udp};
match protocol {
Protocol::Tcp => top_tcp(TARPIT_PORTS_IDENTIFIED),
Protocol::Udp => top_udp(TARPIT_PORTS_IDENTIFIED),
Protocol::Sctp => &[],
}
}
pub(crate) const TARPIT_PORTS_IDENTIFIED: usize = crate::model::port::catalog::TCP_TIER_BOUNDS[0];
pub(crate) const SILENT_PORTS_OF_A_TARPIT: usize = TARPIT_PORTS_IDENTIFIED;
#[derive(Debug, Default)]
pub(crate) struct Tarpits {
passed_over: Mutex<std::collections::BTreeMap<ScopedIp, PassedOver>>,
}
#[derive(Debug, Default)]
struct PassedOver {
ports: BTreeSet<(u16, Protocol)>,
silent: usize,
}
impl Tarpits {
pub(crate) fn identifies(
&self,
host: &Host,
crowd: Option<&Crowd>,
number: u16,
protocol: Protocol,
) -> bool {
let silent = crowd.and_then(Crowd::answers_nothing);
if !host.network_roles().contains(&NetworkRole::Tarpit) && silent.is_none() {
return true;
}
if likeliest(protocol).contains(&number) {
return true;
}
let mut passed_over = self
.passed_over
.lock()
.unwrap_or_else(|held| held.into_inner());
let host = passed_over.entry(host.scoped_ip()).or_default();
host.ports.insert((number, protocol));
host.silent = host.silent.max(silent.unwrap_or(0));
false
}
pub(crate) fn report(&self, ctx: &ScanContext, kind: ScannerKind) {
let passed_over = std::mem::take(
&mut *self
.passed_over
.lock()
.unwrap_or_else(|held| held.into_inner()),
);
for (host, passed) in passed_over {
let counted = ctx.read_host(host.clone(), |recorded| {
let left = recorded
.ports()
.filter(|port| port.state() == PortState::Open)
.filter(|port| passed.ports.contains(&(port.number(), port.protocol())))
.count();
let why = match recorded.network_roles().contains(&NetworkRole::Tarpit) {
true => Why::Open(recorded.open_port_count()),
false => Why::Silent(passed.silent),
};
(left, why)
});
let Some((count, why)) = counted.filter(|(count, _)| *count > 0) else {
continue;
};
warn!("{}", Self::line(&host, count, why));
ctx.file_cut_short(kind, Self::summary(&host, count, why));
}
}
fn line(host: &ScopedIp, count: usize, why: Why) -> String {
let why = match why {
Why::Open(_) => "tarpit".to_owned(),
Why::Silent(silent) => format!("said nothing on {silent}"),
};
format!("{host}: {count} open ports not fingerprinted ({why})")
}
fn summary(host: &ScopedIp, count: usize, why: Why) -> String {
let why = match why {
Why::Open(open) => format!("a host open on {open} ports answers everything"),
Why::Silent(silent) => {
format!("{silent} of its ports took a connection and said nothing when asked")
}
};
format!(
"{host}: {count} open ports were not fingerprinted: {why}, and once it \
was known for that only its likeliest were asked what they run"
)
}
}
#[derive(Debug, Clone, Copy)]
enum Why {
Open(usize),
Silent(usize),
}
struct Target {
address: ScopedIp,
number: u16,
protocol: Protocol,
path: PathAllowance,
}
enum Attempt {
Identified(Box<Identified>),
Unreachable {
ip: ScopedIp,
number: u16,
reason: Unreached,
},
Quiet,
}
#[derive(Debug, Clone, PartialEq, Eq)]
enum Unreached {
Silent(Duration),
Starved,
Failed {
kind: std::io::ErrorKind,
said: String,
},
}
impl Unreached {
fn of(error: std::io::Error, within: Duration) -> Self {
if descriptors::exhausted(&error) {
Self::Starved
} else if error.kind() == std::io::ErrorKind::TimedOut {
Self::Silent(within)
} else {
Self::Failed {
kind: error.kind(),
said: error.to_string(),
}
}
}
fn said(&self) -> String {
match self {
Self::Silent(within) => format!("no answer within {:?}", tenths(*within)),
Self::Starved => descriptors::starved(descriptors::PATIENCE),
Self::Failed { said, .. } => said.clone(),
}
}
fn terse(&self) -> String {
match self {
Self::Silent(within) => format!("no answer in {:?}", tenths(*within)),
Self::Starved => descriptors::starved_briefly(),
Self::Failed { kind, .. } => kind.to_string(),
}
}
}
fn tenths(duration: Duration) -> Duration {
Duration::from_millis(((duration.as_millis() + 50) / 100 * 100) as u64)
}
struct Identified {
ip: ScopedIp,
port: Port,
about_the_host: crate::fingerprint::AboutTheHost,
banners: Vec<String>,
identified_in_part: bool,
}
async fn fingerprint_one(
target: Target,
detection: ServiceDetection,
egress: Egress,
crowd: Arc<Crowd>,
) -> Attempt {
let Target {
address: target,
number: port_number,
protocol,
path,
} = target;
let Some(addr) = target.to_socket_addr(port_number) else {
warn!(
verbosity = 2,
"cannot fingerprint {}: no interface recorded for a link-local address",
target.endpoint(port_number)
);
return Attempt::Quiet;
};
let port = crate::fingerprint::baseline_port(port_number, protocol, PortState::Open);
let _descriptor = descriptors::gate()
.acquire()
.await
.expect("the descriptor gate is never closed");
let (port, about_the_host, banners, identified_in_part) = match protocol {
Protocol::Tcp => {
let within = path.over(CONNECT_PROBE_TIMEOUT);
let stream = match egress.connect_timed(addr, within).await {
Ok(stream) => stream,
Err(e) => {
return Attempt::Unreachable {
ip: target,
number: port_number,
reason: Unreached::of(e, within),
};
}
};
let identified = crowd
.identify(target.clone(), stream, port, detection, egress, path)
.await;
(
identified.port,
identified.about_the_host,
identified.responses,
identified.starved,
)
}
Protocol::Udp => {
match crate::fingerprint::fingerprint_udp_on(addr, port, egress, path).await {
Some(identified) if identified.starved => {
return Attempt::Unreachable {
ip: target,
number: port_number,
reason: Unreached::Starved,
};
}
Some(identified) => (
identified.port,
identified.about_the_host,
identified.responses,
false,
),
None => return Attempt::Quiet,
}
}
Protocol::Sctp => return Attempt::Quiet,
};
Attempt::Identified(Box::new(Identified {
ip: target,
port,
about_the_host,
banners,
identified_in_part,
}))
}
#[derive(Debug, Default)]
pub(crate) struct Crowds {
hosts: Mutex<HashMap<IpAddr, Arc<Crowd>>>,
}
impl Crowds {
pub(crate) fn of(&self, host: IpAddr, name: Option<Arc<str>>) -> Arc<Crowd> {
let mut hosts = self.hosts.lock().unwrap_or_else(|held| held.into_inner());
Arc::clone(hosts.entry(host).or_insert_with(|| {
Arc::new(Crowd {
name,
..Crowd::default()
})
}))
}
pub(crate) async fn ask_again(
&self,
ctx: &ScanContext,
kind: ScannerKind,
) -> Vec<(ScopedIp, u16)> {
let crowds: Vec<Arc<Crowd>> = {
let hosts = self.hosts.lock().unwrap_or_else(|held| held.into_inner());
hosts.values().cloned().collect()
};
let mut in_part = Vec::new();
let mut pool = ProbePool::new(
CONNECT_CONCURRENCY,
ctx.clone(),
kind,
|asked: AskedAlone, _audit| {
for (key, found) in asked.named {
let (number, protocol) = (found.port.number(), found.port.protocol());
ctx.record_responses(key.clone(), number, protocol, found.responses);
write_back(ctx, key, found.port, found.about_the_host);
}
in_part.extend(asked.in_part);
},
);
for crowd in crowds {
let owed = crowd.owed();
if owed.is_empty() {
continue;
}
if ctx.handle.should_stop() {
break;
}
pool.admit(crowd.ask_alone(owed, ctx.clone())).await;
}
pool.drain().await;
drop(pool);
in_part
}
}
impl Crowds {
pub(crate) fn report_silence(&self) {
let silent: Vec<(ScopedIp, u16)> = {
let hosts = self.hosts.lock().unwrap_or_else(|held| held.into_inner());
hosts
.values()
.flat_map(|crowd| {
std::mem::take(
&mut *crowd.silent.lock().unwrap_or_else(|held| held.into_inner()),
)
})
.collect()
};
if let Some(line) = silence_line(&silent) {
crate::info!(verbosity = 1, "{line}");
}
}
}
fn silence_line(silent: &[(ScopedIp, u16)]) -> Option<String> {
let (ip, number) = silent
.iter()
.min_by_key(|(ip, number)| (ip.addr(), *number))?;
let ports = match silent.len() - 1 {
0 => ip.endpoint(*number),
rest => format!("{} and {rest} more", ip.endpoint(*number)),
};
Some(format!("{ports} said nothing when asked (unidentified)"))
}
#[derive(Debug, Default)]
pub(crate) struct Crowd {
contention: HostContention,
answered_late: AtomicBool,
owed: Mutex<Vec<Owed>>,
backlog: Mutex<Backlog>,
name: Option<Arc<str>>,
silent: Mutex<Vec<(ScopedIp, u16)>>,
answered: AtomicUsize,
unanswered: AtomicUsize,
}
#[derive(Debug)]
struct Owed {
key: ScopedIp,
addr: std::net::SocketAddr,
port: Port,
detection: ServiceDetection,
egress: Egress,
path: PathAllowance,
in_part: bool,
}
#[derive(Debug, Default)]
struct AskedAlone {
named: Vec<(ScopedIp, Fingerprinted)>,
in_part: Vec<(ScopedIp, u16)>,
}
impl Crowd {
pub(crate) async fn identify(
&self,
key: ScopedIp,
stream: TcpStream,
port: Port,
detection: ServiceDetection,
egress: Egress,
path: PathAllowance,
) -> Fingerprinted {
let addr = stream.peer_addr().ok();
let visit = self.contention.enter();
let found = crate::fingerprint::fingerprint_tcp_via(
stream,
port.clone(),
detection,
egress,
path,
self.name.clone(),
)
.await;
let alone = visit.leave();
self.heard(&found);
if !found.responses.is_empty() {
self.answered.fetch_add(1, Ordering::Relaxed);
} else if found.ran_out_waiting && !found.starved && detection.sends() {
self.unanswered.fetch_add(1, Ordering::Relaxed);
}
if found.responses.is_empty() && found.ran_out_waiting && !found.starved {
self.silent
.lock()
.unwrap_or_else(|held| held.into_inner())
.push((key.clone(), port.number()));
}
self.backlog
.lock()
.unwrap_or_else(|held| held.into_inner())
.left(found.waited_in_vain);
if let (Some(addr), false, true, true) = (
addr,
alone,
found.responses.is_empty(),
found.ran_out_waiting,
) {
self.owed
.lock()
.unwrap_or_else(|held| held.into_inner())
.push(Owed {
key,
addr,
port,
detection,
egress,
path,
in_part: found.starved,
});
}
found
}
pub(crate) fn answers_nothing(&self) -> Option<usize> {
let unanswered = self.unanswered.load(Ordering::Relaxed);
(unanswered >= SILENT_PORTS_OF_A_TARPIT
&& unanswered > self.answered.load(Ordering::Relaxed))
.then_some(unanswered)
}
fn owed(&self) -> Vec<Owed> {
let owed = std::mem::take(&mut *self.owed.lock().unwrap_or_else(|held| held.into_inner()));
match self.answered_late.load(Ordering::Relaxed) {
true => owed,
false => Vec::new(),
}
}
async fn ask_alone(self: Arc<Self>, owed: Vec<Owed>, ctx: ScanContext) -> AskedAlone {
let mut asked = AskedAlone::default();
let mut silent = 0usize;
let through = self
.backlog
.lock()
.unwrap_or_else(|held| held.into_inner())
.through();
if let Some(through) = through
&& ctx
.handle
.or_stopped(tokio::time::sleep_until(through))
.await
.is_none()
{
return asked;
}
for Owed {
key,
addr,
port,
detection,
egress,
path,
in_part,
} in owed
{
if silent > asked.named.len() || ctx.handle.should_stop() || ctx.host_expired(addr.ip())
{
break;
}
let _descriptor = descriptors::gate()
.acquire()
.await
.expect("the descriptor gate is never closed");
let number = port.number();
let name = self.name.clone();
let identified = async {
let stream = egress
.connect_timed(addr, path.over(CONNECT_PROBE_TIMEOUT))
.await?;
Ok::<_, std::io::Error>(
crate::fingerprint::fingerprint_tcp_via(
stream, port, detection, egress, path, name,
)
.await,
)
};
let Some(identified) = ctx.handle.or_stopped(identified).await else {
break;
};
let again = match identified {
Ok(again) => again,
Err(e) if descriptors::exhausted(&e) => {
if !in_part {
asked.in_part.push((key, number));
}
continue;
}
Err(_) => {
silent += 1;
continue;
}
};
self.heard(&again);
if again.starved && !in_part {
asked.in_part.push((key.clone(), number));
}
if !again.responses.is_empty() {
self.silent
.lock()
.unwrap_or_else(|held| held.into_inner())
.retain(|(silent, port)| !(*silent == key && *port == number));
asked.named.push((key, again));
} else if !again.starved {
silent += 1;
}
}
asked
}
fn heard(&self, found: &Fingerprinted) {
if found.answered_late {
self.answered_late.store(true, Ordering::Relaxed);
}
}
}
#[derive(Debug, Default)]
struct Backlog {
waited_in_vain: Duration,
last_left: Option<tokio::time::Instant>,
}
impl Backlog {
fn left(&mut self, waited_in_vain: Duration) {
self.waited_in_vain += waited_in_vain;
self.last_left = Some(tokio::time::Instant::now());
}
fn through(&self) -> Option<tokio::time::Instant> {
let last_left = self.last_left?;
if self.waited_in_vain.is_zero() {
return None;
}
let wait = self.waited_in_vain.min(BACKLOG_WAIT_LIMIT);
Some(last_left + wait)
}
}
const BACKLOG_WAIT_LIMIT: Duration = Duration::from_secs(10);
fn write_back(
ctx: &ScanContext,
key: ScopedIp,
port: Port,
about_the_host: crate::fingerprint::AboutTheHost,
) {
ctx.update_host(key, |host| {
host.add_port(port);
if about_the_host.is_empty() {
return;
}
about_the_host.apply(host);
});
}
#[cfg(test)]
mod tests {
use super::*;
use crate::scanner::session::ScanSession;
use crate::testing::loopback::{SilentPort, accept_from_this_process, from_this_process};
use std::net::IpAddr;
use std::sync::Arc;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;
#[tokio::test]
async fn a_port_that_answers_nothing_is_said_to_have_answered_nothing() {
use crate::testing::loopback::{SilentPort, accept_from_this_process};
let silent = SilentPort::open();
let greeting = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("binds loopback");
let speaks = greeting.local_addr().expect("a local address");
tokio::spawn(async move {
while let Ok(mut sock) = accept_from_this_process(&greeting).await {
let _ = sock.write_all(b"SSH-2.0-OpenSSH_9.6\r\n").await;
}
});
let crowds = Crowds::default();
for addr in [silent.addr(), speaks] {
let key: ScopedIp = addr.ip().into();
let stream = TcpStream::connect(addr).await.expect("connects");
let port =
crate::fingerprint::baseline_port(addr.port(), Protocol::Tcp, PortState::Open);
crowds
.of(addr.ip(), None)
.identify(
key,
stream,
port,
ServiceDetection::Banner,
Egress::KERNEL,
PathAllowance::NONE,
)
.await;
}
let silent_ports: Vec<(ScopedIp, u16)> = crowds
.of(silent.addr().ip(), None)
.silent
.lock()
.expect("not poisoned")
.clone();
let key: ScopedIp = silent.addr().ip().into();
assert_eq!(silent_ports, vec![(key.clone(), silent.addr().port())]);
assert_eq!(
silence_line(&silent_ports).as_deref(),
Some(
format!(
"{} said nothing when asked (unidentified)",
key.endpoint(silent.addr().port())
)
.as_str()
)
);
assert_eq!(
silence_line(&[(key.clone(), 2222), (key.clone(), 22)]).as_deref(),
Some(
format!(
"{} and 1 more said nothing when asked (unidentified)",
key.endpoint(22)
)
.as_str()
)
);
}
#[test]
fn many_quiet_ports_collapse_into_one_line() {
let mut quiet = QuietPorts::default();
let ip: ScopedIp = "192.0.2.1".parse::<IpAddr>().expect("an address").into();
for port in 0..83u16 {
quiet.record(
&ip,
1000 + port,
Unreached::Silent(Duration::from_millis(1_500)),
);
}
let first = quiet.first.as_deref().expect("a first port");
let reason = quiet.reason.as_ref().expect("a reason");
assert_eq!(
QuietPorts::summary(first, reason, quiet.count),
"192.0.2.1:1000 and 82 other ports could not be fingerprinted: no answer within 1.5s"
);
assert_eq!(
QuietPorts::line(first, reason, quiet.count),
"192.0.2.1:1000 and 82 more not fingerprinted (no answer in 1.5s)"
);
}
#[test]
fn ports_identified_in_part_are_one_failure_naming_the_limit() {
let (session, ctx) = ScanSession::new();
let mut in_part = QuietPorts::default();
let ip: ScopedIp = "192.0.2.1".parse::<IpAddr>().expect("an address").into();
for port in [443u16, 8443, 9443] {
in_part.record(&ip, port, Unreached::Starved);
}
in_part.report_in_part(&ctx);
let failures = ctx.take_failures();
assert_eq!(failures.len(), 1, "{failures:?}");
assert!(
failures[0].reason().starts_with(
"192.0.2.1:443 and 2 other ports identified in part: file descriptor limit"
),
"{}",
failures[0].reason()
);
assert!(failures[0].is_cut_short(), "a limit, not a fault");
drop(session);
}
#[test]
fn one_quiet_port_is_named_alone() {
let refused = Unreached::of(
std::io::Error::new(std::io::ErrorKind::ConnectionRefused, "connection refused"),
CONNECT_PROBE_TIMEOUT,
);
assert_eq!(
QuietPorts::summary("192.0.2.1:22", &refused, 1),
"192.0.2.1:22 could not be fingerprinted: connection refused"
);
assert_eq!(
QuietPorts::summary("192.0.2.1:22", &refused, 2),
"192.0.2.1:22 and 1 other port could not be fingerprinted: connection refused"
);
assert_eq!(
QuietPorts::line("192.0.2.1:22", &refused, 1),
"192.0.2.1:22 not fingerprinted (connection refused)"
);
}
#[test]
fn an_ipv6_endpoint_stays_bracketed() {
let mut quiet = QuietPorts::default();
let ip: ScopedIp = "2001:db8::1".parse::<IpAddr>().expect("an address").into();
quiet.record(&ip, 443, Unreached::Silent(CONNECT_PROBE_TIMEOUT));
assert_eq!(quiet.first.as_deref(), Some("[2001:db8::1]:443"));
}
#[tokio::test]
async fn detect_fingerprints_an_open_tcp_port_end_to_end() {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
tokio::spawn(async move {
if let Ok(mut sock) = accept_from_this_process(&listener).await {
let _ = sock.write_all(b"SSH-2.0-OpenSSH_9.6p1 Debian-3\r\n").await;
}
});
let (session, ctx) = ScanSession::new();
let ip = addr.ip();
let mut host = Host::new(ip);
host.add_port(Port::new(addr.port(), Protocol::Tcp, PortState::Open));
session.hosts().insert(ip, host);
detect(&ctx, ServiceDetection::default(), Protocol::Tcp).await;
let host = session.hosts().get(ip).unwrap();
let port = host
.ports()
.find(|p| p.number() == addr.port())
.expect("port present");
let service = port.service().expect("service identified");
assert_eq!(service.name(), "ssh");
assert_eq!(service.product(), Some("OpenSSH"));
assert_eq!(service.version(), Some("9.6p1"));
}
#[tokio::test]
async fn detection_turned_off_connects_to_nothing() {
let (session, ctx) = ScanSession::new();
let silent = SilentPort::open();
let addr = silent.addr();
ctx.update_host(addr.ip(), |host| {
host.add_port(Port::new(addr.port(), Protocol::Tcp, PortState::Open));
});
detect(&ctx, ServiceDetection::Off, Protocol::Tcp).await;
assert_eq!(
crate::transport::dial::dialled::to(addr),
0,
"a level that connects to nothing connected to the port"
);
drop(session);
}
#[tokio::test]
async fn a_stop_before_identification_names_the_pass_it_left() {
let (session, ctx) = ScanSession::new();
let unreachable: IpAddr = "192.0.2.1".parse().expect("a documentation address");
ctx.update_host(unreachable, |host| {
host.add_port(Port::new(22, Protocol::Tcp, PortState::Open));
});
ctx.handle.abort();
detect(&ctx, ServiceDetection::default(), Protocol::Tcp).await;
assert_eq!(ctx.take_passes_cut(), [crate::report::Pass::Services]);
drop(session);
}
#[tokio::test]
async fn detect_is_a_no_op_with_no_open_ports() {
let (session, ctx) = ScanSession::new();
let ip: IpAddr = "127.0.0.1".parse().unwrap();
let mut host = Host::new(ip);
host.add_port(Port::new(9, Protocol::Tcp, PortState::Closed));
session.hosts().insert(ip, host);
detect(&ctx, ServiceDetection::default(), Protocol::Tcp).await;
let host = session.hosts().get(ip).unwrap();
let port = host.ports().find(|p| p.number() == 9).unwrap();
assert!(port.service().is_none());
}
#[tokio::test]
async fn a_listen_only_port_is_sent_nothing_where_any_other_is_asked() {
let mut received = Vec::new();
for listen_only in [true, false] {
let silent = SilentPort::open();
let addr = silent.addr();
let ports = match listen_only {
true => BTreeSet::from([addr.port()]),
false => BTreeSet::new(),
};
let (session, ctx) = ScanSession::builder().listening_only_to(ports).build();
let ip = addr.ip();
let mut host = Host::new(ip);
host.add_port(Port::new(addr.port(), Protocol::Tcp, PortState::Open));
session.hosts().insert(ip, host);
detect(&ctx, ServiceDetection::Thorough, Protocol::Tcp).await;
received.push(silent.heard());
}
assert_eq!(received[0], 0, "a listen-only port was sent a payload");
assert!(
received[1] > 0,
"the same port off the list was asked nothing, so the first half \
proves nothing"
);
}
#[test]
fn a_level_that_only_listens_takes_no_udp_port() {
let (session, ctx) = ScanSession::new();
let ip: IpAddr = "192.0.2.1".parse().expect("a documentation address");
ctx.update_host(ip, |host| {
host.add_port(Port::new(161, Protocol::Udp, PortState::Open));
});
assert!(
crate::fingerprint::reads_replies(161, Protocol::Udp),
"SNMP is a UDP port the pass would otherwise ask"
);
let taken = |level| {
fingerprintable_ports(
&ctx,
Protocol::Udp,
level,
Which::Every,
&Tarpits::default(),
)
.len()
};
assert_eq!(
taken(ServiceDetection::Banner),
0,
"a listening level sent a datagram"
);
assert_eq!(
taken(ServiceDetection::Probe),
1,
"the default took no UDP port either, so the first half proves nothing"
);
drop(session);
}
#[test]
fn a_tarpit_has_only_its_likeliest_ports_taken() {
use crate::model::port::catalog::top_tcp;
let (session, ctx) = ScanSession::new();
let tarpit: IpAddr = "192.0.2.1".parse().expect("a documentation address");
let ordinary: IpAddr = "192.0.2.2".parse().expect("a documentation address");
let range = 1..=1_200u16;
ctx.update_host(tarpit, |host| {
for number in range.clone() {
host.add_port(Port::new(number, Protocol::Tcp, PortState::Open));
}
});
ctx.update_host(ordinary, |host| {
for number in [22, 51_000] {
host.add_port(Port::new(number, Protocol::Tcp, PortState::Open));
}
});
let tarpits = Tarpits::default();
let targets = fingerprintable_ports(
&ctx,
Protocol::Tcp,
ServiceDetection::Probe,
Which::Every,
&tarpits,
);
let taken = |address: IpAddr| {
let mut numbers: Vec<u16> = targets
.iter()
.filter(|target| target.address.addr() == address)
.map(|target| target.number)
.collect();
numbers.sort_unstable();
numbers
};
let mut likeliest: Vec<u16> = top_tcp(TARPIT_PORTS_IDENTIFIED)
.iter()
.copied()
.filter(|number| range.contains(number))
.collect();
likeliest.sort_unstable();
assert!(
!likeliest.is_empty(),
"the range holds some of the likeliest"
);
assert_eq!(taken(tarpit), likeliest, "the tarpit's ports taken");
assert_eq!(
taken(ordinary),
[22, 51_000],
"the ordinary host's ports taken"
);
tarpits.report(&ctx, ScannerKind::Service);
let failures = ctx.take_failures();
let left = range.len() - likeliest.len();
assert_eq!(failures.len(), 1, "{failures:?}");
assert!(
failures[0].reason().starts_with(&format!(
"192.0.2.1: {left} open ports were not fingerprinted"
)),
"{}",
failures[0].reason()
);
drop(session);
}
#[test]
fn a_service_above_a_block_of_silent_ports_is_asked_before_the_block_gives_the_host_away() {
let (session, ctx) = ScanSession::new();
let address: IpAddr = "192.0.2.1".parse().expect("a documentation address");
let silent = 1..=150u16;
let talkative = 50_000;
ctx.update_host(address, |host| {
for number in silent.clone().chain([talkative]) {
host.add_port(Port::new(number, Protocol::Tcp, PortState::Open));
}
});
let tarpits = Tarpits::default();
let targets = fingerprintable_ports(
&ctx,
Protocol::Tcp,
ServiceDetection::Probe,
Which::Every,
&tarpits,
);
let crowd = Crowd::default();
let mut asked = Vec::new();
for target in &targets {
let identifies = ctx
.read_host(address, |host| {
tarpits.identifies(host, Some(&crowd), target.number, target.protocol)
})
.expect("recorded");
if !identifies {
continue;
}
asked.push(target.number);
let heard = match target.number == talkative {
true => &crowd.answered,
false => &crowd.unanswered,
};
heard.fetch_add(1, Ordering::Relaxed);
}
assert!(asked.contains(&talkative), "asked only {asked:?}");
assert!(
asked.len() < targets.len(),
"the host's silence still gave it away"
);
drop(session);
}
#[test]
fn a_host_silent_on_its_ports_is_identified_as_a_tarpit_is() {
use crate::model::port::catalog::top_tcp;
let (session, ctx) = ScanSession::new();
let silent: IpAddr = "192.0.2.1".parse().expect("a documentation address");
let talkative: IpAddr = "192.0.2.2".parse().expect("a documentation address");
let unlikely = 51_000;
let likeliest = top_tcp(TARPIT_PORTS_IDENTIFIED)[0];
assert!(!top_tcp(TARPIT_PORTS_IDENTIFIED).contains(&unlikely));
for ip in [silent, talkative] {
ctx.update_host(ip, |host| {
for number in [likeliest, unlikely] {
host.add_port(Port::new(number, Protocol::Tcp, PortState::Open));
}
});
}
let crowd = |answered, unanswered| Crowd {
answered: AtomicUsize::new(answered),
unanswered: AtomicUsize::new(unanswered),
..Crowd::default()
};
let quiet = crowd(3, SILENT_PORTS_OF_A_TARPIT);
let busy = crowd(SILENT_PORTS_OF_A_TARPIT, SILENT_PORTS_OF_A_TARPIT);
let short = crowd(0, SILENT_PORTS_OF_A_TARPIT - 1);
let tarpits = Tarpits::default();
let identifies = |ip, crowd: &Crowd, number| {
ctx.read_host(ip, |host| {
tarpits.identifies(host, Some(crowd), number, Protocol::Tcp)
})
.expect("recorded")
};
assert!(!identifies(silent, &quiet, unlikely), "the silent host's");
assert!(identifies(silent, &quiet, likeliest), "its likeliest");
assert!(identifies(talkative, &busy, unlikely), "answered as often");
assert!(identifies(talkative, &short, unlikely), "too few to tell");
tarpits.report(&ctx, ScannerKind::Service);
let failures = ctx.take_failures();
assert_eq!(failures.len(), 1, "{failures:?}");
assert_eq!(
failures[0].reason(),
format!(
"192.0.2.1: 1 open ports were not fingerprinted: \
{SILENT_PORTS_OF_A_TARPIT} of its ports took a connection and said \
nothing when asked, and once it was known for that only its \
likeliest were asked what they run"
)
);
drop(session);
}
#[test]
fn a_steady_slow_path_is_allowed_for_as_its_round_trips_show() {
let (session, ctx) = ScanSession::new();
let host: IpAddr = "192.0.2.1".parse().expect("a documentation address");
let path = Duration::from_millis(1_900);
ctx.update_host(host, |record| {
for _ in 0..10 {
record.add_rtt(path);
}
record.add_port(Port::new(22, Protocol::Tcp, PortState::Open));
});
let targets = fingerprintable_ports(
&ctx,
Protocol::Tcp,
ServiceDetection::Probe,
Which::Every,
&Tarpits::default(),
);
let allowed = targets[0].path.over(Duration::ZERO);
assert!(allowed > path, "the path itself: {allowed:?}");
assert!(allowed < path * 2, "one sample's three: {allowed:?}");
drop(session);
}
#[tokio::test]
async fn a_port_that_refuses_a_connection_is_written_into_the_report() {
let addr = crate::testing::loopback::refused_port(std::net::IpAddr::from([127, 0, 0, 1]));
let (session, ctx) = ScanSession::new();
let ip = addr.ip();
let mut host = Host::new(ip);
host.add_port(Port::new(addr.port(), Protocol::Tcp, PortState::Open));
session.hosts().insert(ip, host);
detect(&ctx, ServiceDetection::default(), Protocol::Tcp).await;
let failures = ctx.take_failures();
assert_eq!(failures.len(), 1, "one unreachable port, one line about it");
assert!(
failures[0].reason().contains(&addr.port().to_string()),
"the failure names the port it is about: {}",
failures[0].reason()
);
}
async fn behind_a_slow_path(delay: Duration) -> std::net::SocketAddr {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
tokio::spawn(async move {
while let Ok(mut sock) = accept_from_this_process(&listener).await {
tokio::spawn(async move {
let mut buffer = [0u8; 1024];
if !matches!(sock.read(&mut buffer).await, Ok(n) if n > 0) {
return;
}
tokio::time::sleep(delay).await;
let _ = sock
.write_all(
b"HTTP/1.1 200 OK\r\nServer: nginx/1.24.0\r\n\
Content-Length: 0\r\nConnection: close\r\n\r\n",
)
.await;
});
}
});
addr
}
#[tokio::test]
async fn an_open_port_behind_a_slow_path_is_identified_within_the_round_trip_measured() {
let path = Duration::from_millis(600);
let addr = behind_a_slow_path(Duration::from_millis(1_300)).await;
let (session, ctx) = ScanSession::new();
let ip = addr.ip();
let mut host = Host::new(ip);
host.add_rtt(path);
host.add_port(Port::new(addr.port(), Protocol::Tcp, PortState::Open));
session.hosts().insert(ip, host);
detect(&ctx, ServiceDetection::default(), Protocol::Tcp).await;
let host = session.hosts().get(ip).unwrap();
let port = host
.ports()
.find(|p| p.number() == addr.port())
.expect("port present");
assert_eq!(
port.service().map(|service| service.name()),
Some("http"),
"a service answering behind a path of {path:?} went unheard"
);
}
#[test]
fn a_connect_behind_a_measured_path_names_the_wait_it_was_given() {
let within =
PathAllowance::of_round_trip(Duration::from_millis(1_900)).over(CONNECT_PROBE_TIMEOUT);
let silent = Unreached::of(std::io::ErrorKind::TimedOut.into(), within);
assert_eq!(silent.said(), "no answer within 4.5s");
assert_eq!(
QuietPorts::line("192.0.2.10:22", &silent, 1),
"192.0.2.10:22 not fingerprinted (no answer in 4.5s)"
);
}
type Served = Arc<std::sync::Mutex<Vec<(u16, String)>>>;
fn one_worker(ports: usize, service: Duration) -> (Vec<u16>, Served) {
use std::io::{Read, Write};
let (queue, work) = std::sync::mpsc::channel();
let mut numbers = Vec::new();
for _ in 0..ports {
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let number = listener.local_addr().unwrap().port();
numbers.push(number);
let queue = queue.clone();
std::thread::spawn(move || {
for sock in from_this_process(&listener) {
if queue.send((number, sock)).is_err() {
break;
}
}
});
}
let served = Arc::new(std::sync::Mutex::new(Vec::new()));
let log = Arc::clone(&served);
std::thread::spawn(move || {
for (number, mut sock) in work {
let mut buffer = [0u8; 1024];
let _ = sock.set_read_timeout(Some(Duration::from_millis(100)));
let Ok(n) = sock.read(&mut buffer) else {
continue;
};
let request = String::from_utf8_lossy(&buffer[..n]).into_owned();
if !request.starts_with("GET ") {
continue;
}
std::thread::sleep(service);
let _ = sock.write_all(
b"HTTP/1.1 200 OK\r\nServer: nginx/1.24.0\r\n\
Content-Length: 0\r\nConnection: close\r\n\r\n",
);
let line = request.lines().next().unwrap_or_default().to_owned();
log.lock().unwrap().push((number, line));
}
});
(numbers, served)
}
fn open_on_loopback(ports: &[u16]) -> (ScanSession, ScanContext) {
let (session, ctx) = ScanSession::new();
let ip: IpAddr = "127.0.0.1".parse().unwrap();
let mut host = Host::new(ip);
for &number in ports {
host.add_port(Port::new(number, Protocol::Tcp, PortState::Open));
}
session.hosts().insert(ip, host);
(session, ctx)
}
#[tokio::test]
async fn ports_one_worker_answers_in_turn_are_each_identified() {
let (ports, served) = one_worker(2, Duration::from_millis(750));
let (session, ctx) = open_on_loopback(&ports);
detect(&ctx, ServiceDetection::default(), Protocol::Tcp).await;
let host = session
.hosts()
.get("127.0.0.1".parse::<IpAddr>().unwrap())
.unwrap();
let named: Vec<Option<String>> = ports
.iter()
.map(|&number| {
host.ports()
.find(|p| p.number() == number)
.and_then(|p| p.service().map(|service| service.name().to_owned()))
})
.collect();
assert_eq!(
named,
vec![Some("http".to_owned()), Some("http".to_owned())],
"a port queued behind its neighbour went unnamed; served: {:?}",
served.lock().unwrap()
);
}
#[tokio::test]
async fn a_silent_port_beside_a_prompt_one_is_asked_once() {
let (prompt, _) = one_worker(1, Duration::ZERO);
let silent = SilentPort::open();
let (session, ctx) = open_on_loopback(&[prompt[0], silent.addr().port()]);
detect(&ctx, ServiceDetection::default(), Protocol::Tcp).await;
let once = silent.heard();
let generic: usize = crate::fingerprint::SignatureDb::global()
.generic_tcp_probe_payloads()
.iter()
.map(Vec::len)
.sum();
let (alone_session, alone_ctx) = open_on_loopback(&[silent.addr().port()]);
detect(&alone_ctx, ServiceDetection::default(), Protocol::Tcp).await;
let alone = silent.heard() - once;
assert!(generic > 0 && alone >= generic);
assert_eq!(
once, alone,
"the silent port was sent {once} bytes beside a prompt port and \
{alone} alone, so it was identified more than once"
);
drop((session, alone_session));
}
async fn identified_in(crowd: &Crowd, silent: &SilentPort) -> usize {
let before = silent.heard();
let addr = silent.addr();
let stream = TcpStream::connect(addr).await.unwrap();
let port = crate::fingerprint::baseline_port(addr.port(), Protocol::Tcp, PortState::Open);
let found = crowd
.identify(
addr.ip().into(),
stream,
port,
ServiceDetection::default(),
Egress::KERNEL,
PathAllowance::NONE,
)
.await;
assert!(found.responses.is_empty(), "the port says nothing");
silent.heard() - before
}
#[tokio::test]
async fn a_port_owed_a_second_asking_is_handed_back_before_it_is_asked_again() {
let silent = SilentPort::open();
let crowd = Crowd::default();
crowd.answered_late.store(true, Ordering::Relaxed);
let company = crowd.contention.enter();
let in_company = identified_in(&crowd, &silent).await;
drop(company);
let alone = identified_in(&Crowd::default(), &silent).await;
assert!(alone > 0);
assert_eq!(
in_company, alone,
"the port was sent {in_company} bytes before it was handed back \
and {alone} identified once, so it was asked again inside"
);
}
#[tokio::test]
async fn a_port_owed_a_second_asking_is_asked_again_once_the_pass_is_done() {
let silent = SilentPort::open();
let (_session, ctx) = ScanSession::new();
let crowds = Crowds::default();
let crowd = crowds.of(silent.addr().ip(), None);
crowd.answered_late.store(true, Ordering::Relaxed);
let company = crowd.contention.enter();
let first = identified_in(&crowd, &silent).await;
drop(company);
crowds.ask_again(&ctx, ScannerKind::Service).await;
assert!(first > 0);
assert_eq!(silent.heard(), first * 2, "asked once again");
}
#[cfg(unix)]
#[tokio::test]
async fn a_second_asking_the_file_limit_cuts_short_is_counted_identified_in_part() {
use crate::system::descriptors::testing::{
in_a_process_of_its_own, refuse_every_descriptor, wait_out_a_full_table_for,
};
if !in_a_process_of_its_own(
module_path!(),
"a_second_asking_the_file_limit_cuts_short_is_counted_identified_in_part",
) {
return;
}
wait_out_a_full_table_for(Duration::from_millis(100));
let refusing =
crate::testing::loopback::refused_port(std::net::IpAddr::from([127, 0, 0, 1]));
let (_session, ctx) = ScanSession::new();
let crowds = Crowds::default();
let crowd = crowds.of(refusing.ip(), None);
crowd.answered_late.store(true, Ordering::Relaxed);
crowd.owed.lock().unwrap().push(Owed {
key: refusing.ip().into(),
addr: refusing,
port: crate::fingerprint::baseline_port(
refusing.port(),
Protocol::Tcp,
PortState::Open,
),
detection: ServiceDetection::default(),
egress: Egress::KERNEL,
path: PathAllowance::NONE,
in_part: false,
});
let held = refuse_every_descriptor();
close_pass(
&ctx,
&crowds,
&QuietPorts::default(),
QuietPorts::default(),
1,
)
.await;
drop(held);
let failures = ctx.take_failures();
assert_eq!(failures.len(), 1, "{failures:?}");
assert!(
failures[0].reason().starts_with(&format!(
"{} identified in part",
ScopedIp::from(refusing.ip()).endpoint(refusing.port())
)),
"a second asking refused a socket was not counted: {}",
failures[0].reason()
);
}
#[cfg(unix)]
#[tokio::test]
async fn a_second_asking_whose_later_questions_find_no_socket_is_counted_identified_in_part() {
use crate::system::descriptors::testing::{
in_a_process_of_its_own, refuse_every_descriptor, wait_out_a_full_table_for,
};
use std::os::fd::AsRawFd;
if !in_a_process_of_its_own(
module_path!(),
"a_second_asking_whose_later_questions_find_no_socket_is_counted_identified_in_part",
) {
return;
}
wait_out_a_full_table_for(Duration::from_millis(100));
let unanswering = std::net::TcpListener::bind("127.0.0.1:0").expect("a loopback port");
let addr = unanswering.local_addr().expect("a local address");
let (_session, ctx) = ScanSession::new();
let crowds = Crowds::default();
let crowd = crowds.of(addr.ip(), None);
crowd.answered_late.store(true, Ordering::Relaxed);
crowd.owed.lock().unwrap().push(Owed {
key: addr.ip().into(),
addr,
port: crate::fingerprint::baseline_port(addr.port(), Protocol::Tcp, PortState::Open),
detection: ServiceDetection::default(),
egress: Egress::KERNEL,
path: PathAllowance::NONE,
in_part: false,
});
let listening = unanswering.as_raw_fd();
let refusing = std::thread::spawn(move || {
let mut waiting = libc::pollfd {
fd: listening,
events: libc::POLLIN,
revents: 0,
};
let ready = unsafe { libc::poll(&raw mut waiting, 1, 30_000) };
(ready == 1).then(refuse_every_descriptor)
});
close_pass(
&ctx,
&crowds,
&QuietPorts::default(),
QuietPorts::default(),
1,
)
.await;
let refused = refusing.join().expect("the watch on the listener");
drop(refused);
unanswering
.set_nonblocking(true)
.expect("a non-blocking listener");
assert!(
unanswering.accept().is_ok(),
"the asking never connected, so its first question was what was refused"
);
let failures = ctx.take_failures();
assert_eq!(failures.len(), 1, "{failures:?}");
assert!(
failures[0].reason().starts_with(&format!(
"{} identified in part",
ScopedIp::from(addr.ip()).endpoint(addr.port())
)),
"an asking whose later questions were refused a socket was not counted: {}",
failures[0].reason()
);
}
#[tokio::test]
async fn a_second_asking_waits_out_what_the_pass_left_its_host() {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let (accepted_tx, mut accepted) = tokio::sync::mpsc::unbounded_channel();
let server = tokio::spawn(async move {
while let Ok(mut sock) = accept_from_this_process(&listener).await {
let _ = accepted_tx.send(tokio::time::Instant::now());
tokio::spawn(async move {
let mut sink = [0u8; 256];
while matches!(sock.read(&mut sink).await, Ok(n) if n > 0) {}
});
}
});
let (_session, ctx) = ScanSession::new();
let crowds = Crowds::default();
let crowd = crowds.of(addr.ip(), None);
crowd.answered_late.store(true, Ordering::Relaxed);
let company = crowd.contention.enter();
let found = crowd
.identify(
addr.ip().into(),
TcpStream::connect(addr).await.unwrap(),
crate::fingerprint::baseline_port(addr.port(), Protocol::Tcp, PortState::Open),
ServiceDetection::Banner,
Egress::KERNEL,
PathAllowance::NONE,
)
.await;
let left = tokio::time::Instant::now();
drop(company);
assert!(!found.waited_in_vain.is_zero(), "the banner wait ran out");
crowds.ask_again(&ctx, ScannerKind::Service).await;
server.abort();
let first = accepted.recv().await.expect("the first asking");
let second = accepted.recv().await.expect("the second asking");
assert!(first < left);
let margin = Duration::from_millis(100);
assert!(
second + margin >= left + found.waited_in_vain,
"asked again {:?} after the first left, with {:?} of its waits run out",
second.saturating_duration_since(left),
found.waited_in_vain
);
}
async fn identified_together(crowd: &Crowd, silent: &[SilentPort; 3]) -> [usize; 3] {
let one = |port: &SilentPort| {
let addr = port.addr();
async move {
let stream = TcpStream::connect(addr).await.unwrap();
let baseline =
crate::fingerprint::baseline_port(addr.port(), Protocol::Tcp, PortState::Open);
crowd
.identify(
addr.ip().into(),
stream,
baseline,
ServiceDetection::default(),
Egress::KERNEL,
PathAllowance::NONE,
)
.await
}
};
let found = tokio::join!(one(&silent[0]), one(&silent[1]), one(&silent[2]));
assert!(
[found.0, found.1, found.2]
.iter()
.all(|found| found.responses.is_empty() && found.ran_out_waiting),
"every port says nothing"
);
silent.each_ref().map(SilentPort::connections_told)
}
#[tokio::test]
async fn a_host_silent_when_asked_again_alone_is_not_asked_again_port_by_port() {
let silent = [SilentPort::open(), SilentPort::open(), SilentPort::open()];
let (_session, ctx) = ScanSession::new();
let crowds = Crowds::default();
let crowd = crowds.of("127.0.0.1".parse().unwrap(), None);
crowd.answered_late.store(true, Ordering::Relaxed);
let first = identified_together(&crowd, &silent).await;
crowds.ask_again(&ctx, ScannerKind::Service).await;
assert!(first.iter().all(|&taken| taken > 0));
let again: Vec<usize> = silent
.iter()
.zip(first)
.map(|(port, first)| port.connections_told() - first)
.collect();
let asked_again = again.iter().filter(|&&taken| taken > 0).count();
assert_eq!(
asked_again, 1,
"the host stayed silent alone and was still asked again on \
{asked_again} ports: {again:?} connections more"
);
}
#[tokio::test]
async fn a_stop_cuts_short_a_second_asking_in_flight() {
let silent = SilentPort::open();
let (_session, ctx) = ScanSession::new();
let crowds = Crowds::default();
let crowd = crowds.of(silent.addr().ip(), None);
crowd.answered_late.store(true, Ordering::Relaxed);
let company = crowd.contention.enter();
let first = identified_in(&crowd, &silent).await;
drop(company);
let through = crowd
.backlog
.lock()
.unwrap()
.through()
.unwrap_or_else(tokio::time::Instant::now);
let stop = async {
tokio::time::sleep_until(through + Duration::from_secs(1)).await;
ctx.handle.abort();
};
tokio::join!(crowds.ask_again(&ctx, ScannerKind::Service), stop);
let again = silent.heard() - first;
assert!(
again < first,
"the second asking sent {again} bytes after the stop, as many as \
a whole walk sends ({first})"
);
}
}