use crate::config::ServiceDetection;
use crate::config::limits::{
CONNECT_PROBE_TIMEOUT, DISCOVERY_CONCURRENCY, HOST_SYN_RETRANSMIT,
NEIGHBOUR_PATH_FINDING_TIMEOUT, PATH_FINDING_TIMEOUT,
};
use crate::counted;
use crate::evasion::EvasionProfile;
use crate::journal::settle::{Outcome, Settled};
use crate::logging::{error, info};
use crate::model::host::{Host, HostStatus, NetworkRole, StatusProtocol, StatusReason};
use crate::model::ip::scoped::ZoneMap;
use crate::model::ip::set::IpSet;
use crate::model::port::discovery::{Discovery, ScanResponse};
use crate::model::port::{Port, PortState, Protocol};
use crate::model::target::PlannedTarget;
use crate::report::StopReason;
use crate::report::{Pass, ScannerKind};
use crate::scanner::audit::ProbeAudit;
use crate::scanner::dispatcher::dispatch_addresses_of;
use crate::scanner::handle::ScanHandle;
use crate::scanner::payload;
use crate::scanner::pool::ProbePool;
use crate::scanner::session::ScanContext;
use crate::scanner::strategy::routed::SynPorts;
use crate::scanner::strategy::{HostScanner, PortScanner, StrategyError, record_unasked};
use crate::system::descriptors::{self, Descriptor};
use crate::system::interface::{OnLinkTable, refuses_neighbour};
use crate::transport::dial::PathAllowance;
use crate::transport::dial::{Connecting, Egress, Holder, Shaping, SourcePortHeld};
use async_trait::async_trait;
use std::io::{self, ErrorKind};
use std::net::{IpAddr, SocketAddr};
use std::sync::Arc;
use std::time::{Duration, Instant};
use tokio::net::TcpStream;
use tokio::sync::mpsc;
use tokio::time::timeout;
mod neighbours;
use neighbours::{Held, HeldConnects, Neighbours};
impl From<&EvasionProfile> for Shaping {
fn from(evasion: &EvasionProfile) -> Self {
Self {
source_port: evasion.source_port,
hop_limit: evasion.ttl,
}
}
}
pub struct ConnectScanner {
ips: IpSet,
ctx: ScanContext,
evasion: EvasionProfile,
ports: SynPorts,
}
impl ConnectScanner {
pub fn new(ips: IpSet, ctx: ScanContext, evasion: &EvasionProfile) -> Self {
Self::asking(ips, ctx, evasion, SynPorts::common())
}
pub fn asking(ips: IpSet, ctx: ScanContext, evasion: &EvasionProfile, ports: SynPorts) -> Self {
Self {
ips,
ctx,
evasion: evasion.clone(),
ports,
}
}
}
#[async_trait]
impl HostScanner for ConnectScanner {
fn kind(&self) -> ScannerKind {
ScannerKind::Connect
}
async fn discover_hosts(&mut self) -> Result<(), StrategyError> {
discover_on(
std::mem::take(&mut self.ips),
self.ctx.clone(),
&self.evasion,
self.ports,
)
.await
}
}
struct Probed {
ip: IpAddr,
port: Option<Port>,
responses: Vec<String>,
about_the_host: crate::fingerprint::AboutTheHost,
identified_in_part: bool,
answered: bool,
outcome: Outcome,
attempt: Attempt,
rtt: Option<Duration>,
role: Option<NetworkRole>,
silence: Option<Silence>,
held_down: Option<HeldPort>,
settles: bool,
}
type ProbedPort = Option<Probed>;
#[derive(Debug, Clone, PartialEq, Eq)]
enum Attempt {
Sent,
Refused(Refusal),
Starved,
Unmade,
}
#[derive(Debug, Clone, PartialEq, Eq)]
enum Refusal {
NoRoute,
Forbidden,
PortHeld(u16, Holder),
Unresolved,
Local(String),
}
impl Refusal {
fn of(error: &io::Error) -> Self {
if let Some(held) = SourcePortHeld::of(error) {
return Self::PortHeld(held.port, held.holder);
}
match error.kind() {
ErrorKind::HostUnreachable | ErrorKind::NetworkUnreachable
if refused_by_policy(error) =>
{
Self::Forbidden
}
ErrorKind::HostUnreachable | ErrorKind::NetworkUnreachable => Self::NoRoute,
_ => Self::Local(error.to_string()),
}
}
}
fn refused_by_policy(error: &io::Error) -> bool {
error
.get_ref()
.and_then(|inner| inner.downcast_ref::<io::Error>())
.is_some_and(|inner| {
matches!(
inner.kind(),
ErrorKind::PermissionDenied | ErrorKind::InvalidInput
)
})
}
#[derive(Debug, Default)]
struct Shortfall {
starved: u128,
identified_in_part: u128,
unroutable: std::collections::BTreeSet<IpAddr>,
forbidden: std::collections::BTreeSet<IpAddr>,
port_held: u128,
held: Option<(u16, Holder)>,
refused: u128,
first_refusal: Option<String>,
}
impl Shortfall {
fn count(&mut self, ip: IpAddr, attempt: &Attempt) {
match attempt {
Attempt::Starved => self.starved += 1,
Attempt::Refused(Refusal::NoRoute | Refusal::Unresolved) => {
self.unroutable.insert(ip);
}
Attempt::Refused(Refusal::Forbidden) => {
self.unroutable.insert(ip);
self.forbidden.insert(ip);
}
Attempt::Refused(Refusal::PortHeld(port, holder)) => {
self.port_held += 1;
self.held.get_or_insert((*port, *holder));
}
Attempt::Refused(Refusal::Local(why)) => {
self.refused += 1;
self.first_refusal.get_or_insert_with(|| why.clone());
}
Attempt::Sent | Attempt::Unmade => {}
}
}
fn report(self, ctx: &ScanContext, scanner: ScannerKind, unit: &str, units: &str) {
let segments = if self.unroutable.is_empty() {
OnLinkTable::from_links(&[])
} else {
OnLinkTable::of_segments()
};
self.file(ctx, scanner, unit, units, &segments, refuses_neighbour);
}
fn file(
self,
ctx: &ScanContext,
scanner: ScannerKind,
unit: &str,
units: &str,
segments: &OnLinkTable,
refuses: fn(IpAddr) -> bool,
) {
if self.starved > 0 {
let unasked = counted(self.starved, unit, units);
report_starved(ctx, scanner, unasked, descriptors::PATIENCE);
}
if self.identified_in_part > 0 {
let ports = counted(self.identified_in_part, "port", "ports");
crate::warn!(
"{ports} identified in part ({})",
descriptors::starved_briefly()
);
ctx.file_cut_short(
scanner,
format!(
"{ports} identified in part: {}",
descriptors::starved(descriptors::PATIENCE)
),
);
}
for address in self.unroutable {
let reached = ctx
.read_host(address, |host| host.status() == HostStatus::Up)
.unwrap_or(false);
if !reached {
let overrides_segment = || {
segments.source_for(address).is_some()
&& !segments.is_segment_edge(address)
&& refuses(address)
};
if self.forbidden.contains(&address) || overrides_segment() {
ctx.note_refused_by_route(address);
}
ctx.record_unroutable(address);
}
}
if let Some((port, holder)) = self.held {
let by = match holder {
Holder::Closing => "still closing",
Holder::Socket => "held elsewhere",
};
let unasked = counted(self.port_held, unit, units);
crate::warn!("{unasked} unasked (source port {port} {by})");
ctx.file_cut_short(
scanner,
format!("{unasked} left unasked: source port {port} {by}"),
);
}
if self.refused > 0 {
let cause = self.first_refusal.as_deref().unwrap_or("cause unrecorded");
ctx.record_failure(
scanner,
format!(
"{} left unasked: this machine refused to send them: {cause}",
counted(self.refused, unit, units)
),
);
}
}
}
pub struct ConnectPortScanner {
ctx: ScanContext,
concurrency: usize,
detection: ServiceDetection,
evasion: EvasionProfile,
zones: ZoneMap,
}
impl ConnectPortScanner {
pub fn new(
ctx: ScanContext,
concurrency: usize,
detection: ServiceDetection,
evasion: &EvasionProfile,
) -> Self {
Self {
ctx,
concurrency,
detection,
evasion: evasion.clone(),
zones: ZoneMap::new(),
}
}
pub fn with_zones(mut self, zones: ZoneMap) -> Self {
self.zones = zones;
self
}
}
#[async_trait]
impl PortScanner for ConnectPortScanner {
fn kind(&self) -> ScannerKind {
ScannerKind::Connect
}
fn supported_protocols(&self) -> Vec<Protocol> {
vec![Protocol::Tcp]
}
async fn scan(&mut self, rx: mpsc::Receiver<PlannedTarget>) -> Result<(), StrategyError> {
scan(
rx,
self.concurrency,
self.ctx.clone(),
self.detection,
&self.evasion,
&self.zones,
)
.await
}
async fn detect_services(&mut self, ctx: &ScanContext) {
crate::scanner::service::detect_inherited(ctx, self.detection, Protocol::Tcp).await;
}
}
pub struct ConnectUdpPortScanner {
ctx: ScanContext,
concurrency: usize,
evasion: EvasionProfile,
service_detection: ServiceDetection,
zones: ZoneMap,
}
impl ConnectUdpPortScanner {
pub fn new(ctx: ScanContext, concurrency: usize, evasion: &EvasionProfile) -> Self {
Self::with_detection(ctx, concurrency, evasion, ServiceDetection::default())
}
pub fn with_detection(
ctx: ScanContext,
concurrency: usize,
evasion: &EvasionProfile,
service_detection: ServiceDetection,
) -> Self {
Self {
ctx,
concurrency,
evasion: evasion.clone(),
service_detection,
zones: ZoneMap::new(),
}
}
pub fn with_zones(mut self, zones: ZoneMap) -> Self {
self.zones = zones;
self
}
}
#[async_trait]
impl PortScanner for ConnectUdpPortScanner {
fn kind(&self) -> ScannerKind {
ScannerKind::ConnectUdp
}
fn supported_protocols(&self) -> Vec<Protocol> {
vec![Protocol::Udp]
}
async fn detect_services(&mut self, ctx: &ScanContext) {
crate::scanner::service::detect(ctx, self.service_detection, Protocol::Udp).await;
}
async fn scan(&mut self, mut rx: mpsc::Receiver<PlannedTarget>) -> Result<(), StrategyError> {
crate::fingerprint::load_corpus().await;
let ctx = self.ctx.clone();
let shaping = Shaping::from(&self.evasion);
let mut shortfall = Shortfall::default();
let mut pool = ProbePool::new(
self.concurrency,
self.ctx.clone(),
self.kind(),
|probed, audit: &mut ProbeAudit| absorb_probe(&ctx, probed, audit, &mut shortfall),
);
let mut probes = 0u128;
let mut reason = StopReason::AttemptsSpent;
while let Some(target) = rx.recv().await {
if let Some(cause) = self.ctx.handle.stopped() {
reason = cause.into();
record_unasked(&self.ctx, &target);
break;
}
probes += 1;
if self.ctx.host_expired(target.ip()) {
record_unasked(&self.ctx, &target);
continue;
}
let endpoint = self.zones.endpoint(target.ip(), target.port());
let egress = self.ctx.egress_toward(target.ip());
let handle = self.ctx.handle.clone();
pool.admit(udp_port_prober(target, shaping, egress, endpoint, handle))
.await;
}
rx.close();
while let Ok(target) = rx.try_recv() {
record_unasked(&self.ctx, &target);
}
pool.drain().await;
let audit = pool.into_audit();
shortfall.report(&self.ctx, self.kind(), "port", "ports");
finish(&self.ctx, audit, self.kind(), probes, reason);
Ok(())
}
}
pub async fn scan(
rx: mpsc::Receiver<PlannedTarget>,
concurrency_limit: usize,
ctx: ScanContext,
detection: ServiceDetection,
evasion: &EvasionProfile,
zones: &ZoneMap,
) -> Result<(), StrategyError> {
let neighbours = Neighbours::of_system();
Box::pin(scan_among(
rx,
concurrency_limit,
ctx,
detection,
evasion,
zones,
neighbours,
))
.await
}
async fn scan_among(
mut rx: mpsc::Receiver<PlannedTarget>,
concurrency_limit: usize,
ctx: ScanContext,
detection: ServiceDetection,
evasion: &EvasionProfile,
zones: &ZoneMap,
neighbours: Neighbours,
) -> Result<(), StrategyError> {
crate::fingerprint::load_corpus().await;
let shaping = Shaping::from(evasion);
let folder = ctx.clone();
let mut shortfall = Shortfall::default();
let crowds = crate::scanner::service::Crowds::default();
let tarpits = crate::scanner::service::Tarpits::default();
let slow = SlowPaths::default();
let held = HeldPorts::default();
let finding = PathFinding::of(OnLinkTable::of_segments());
let neighbours = Arc::new(neighbours);
let mut pool = ProbePool::new(
concurrency_limit,
ctx.clone(),
ScannerKind::Connect,
|probed: ProbedPort, audit: &mut ProbeAudit| {
if let Some(port) = probed.as_ref().and_then(|probed| probed.held_down) {
held.note(port);
return;
}
if let Some(silence) = probed.as_ref().and_then(|probed| probed.silence) {
slow.note(silence);
}
absorb_probe(&folder, probed, audit, &mut shortfall);
},
);
let asking = Asking {
ctx: &ctx,
detection,
shaping,
zones,
crowds: &crowds,
tarpits: &tarpits,
neighbours: &neighbours,
};
let mut probes = 0u128;
let mut reason = StopReason::AttemptsSpent;
while let Some(target) = rx.recv().await {
if let Some(cause) = ctx.handle.stopped() {
reason = cause.into();
record_unasked(&ctx, &target);
break;
}
probes += 1;
if ctx.host_expired(target.ip()) {
record_unasked(&ctx, &target);
continue;
}
pool.admit(asking.first(target, &finding)).await;
}
rx.close();
while let Ok(target) = rx.try_recv() {
record_unasked(&ctx, &target);
}
pool.drain().await;
held.ask_again(&asking, &mut pool).await;
slow.ask_again(&asking, &mut pool).await;
held.ask_again(&asking, &mut pool).await;
let audit = pool.into_audit();
if detection.connects()
&& ctx.handle.should_stop()
&& ctx.store.iter().any(|host| {
host.value()
.ports()
.any(|port| port.protocol() == Protocol::Tcp && port.state() == PortState::Open)
})
{
ctx.stopping_before(Pass::Services);
}
shortfall.identified_in_part +=
crowds.ask_again(&ctx, ScannerKind::Connect).await.len() as u128;
crowds.report_silence();
tarpits.report(&ctx, ScannerKind::Service);
shortfall.report(&ctx, ScannerKind::Connect, "port", "ports");
finish(&ctx, audit, ScannerKind::Connect, probes, reason);
Ok(())
}
fn connect_patience(path: PathAllowance) -> Duration {
path.over(HOST_SYN_RETRANSMIT).max(CONNECT_PROBE_TIMEOUT)
}
fn measured_path(ctx: &ScanContext, ip: IpAddr) -> PathAllowance {
ctx.read_host(ip, |host| {
PathAllowance::of_round_trips(host.telemetry().round_trips())
})
.unwrap_or(PathAllowance::NONE)
}
struct Asking<'a> {
ctx: &'a ScanContext,
detection: ServiceDetection,
shaping: Shaping,
zones: &'a ZoneMap,
crowds: &'a crate::scanner::service::Crowds,
tarpits: &'a crate::scanner::service::Tarpits,
neighbours: &'a Arc<Neighbours>,
}
impl Asking<'_> {
fn first(
&self,
target: PlannedTarget,
finding: &PathFinding,
) -> impl Future<Output = ProbedPort> + Send + 'static {
let (ctx, finding, ip) = (self.ctx.clone(), finding.clone(), target.ip());
self.port_waiting(target, move || {
finding.patience(measured_path(&ctx, ip), ip)
})
}
fn port(
&self,
target: PlannedTarget,
patience: Duration,
) -> impl Future<Output = ProbedPort> + Send + 'static {
self.port_waiting(target, move || patience)
}
fn port_waiting(
&self,
target: PlannedTarget,
patience: impl FnOnce() -> Duration + Send + 'static,
) -> impl Future<Output = ProbedPort> + Send + 'static {
let ctx = self.ctx;
let endpoint = self.zones.endpoint(target.ip(), target.port());
let egress = ctx.egress_toward(target.ip());
let identify = ctx.service_detection_on(self.detection, target.port(), target.protocol());
let crowd = self.crowds.of(target.ip(), ctx.target_name(target.ip()));
let identify = match ctx.read_host(target.ip(), |host| {
self.tarpits
.identifies(host, Some(&crowd), target.port(), target.protocol())
}) {
Some(false) => ServiceDetection::Off,
_ => identify,
};
let (shaping, ctx) = (self.shaping, ctx.clone());
let neighbours = Arc::clone(self.neighbours);
async move {
port_prober(
target,
identify,
shaping,
egress,
endpoint,
patience(),
ctx,
crowd,
neighbours,
)
.await
}
}
fn again(
&self,
target: PlannedTarget,
patience: Duration,
) -> impl Future<Output = ProbedPort> + Send + 'static {
let asked = self.port(target, patience);
async move {
asked.await.map(|probed| Probed {
settles: false,
port: probed
.port
.filter(|port| port.state() != PortState::Unasked),
..probed
})
}
}
}
#[derive(Debug, Clone, Copy)]
struct HeldPort {
target: PlannedTarget,
until: Instant,
}
#[derive(Debug, Default)]
struct HeldPorts {
held: std::sync::Mutex<Vec<HeldPort>>,
}
impl HeldPorts {
fn note(&self, port: HeldPort) {
self.held
.lock()
.unwrap_or_else(|held| held.into_inner())
.push(port);
}
async fn ask_again<F>(&self, asking: &Asking<'_>, pool: &mut ProbePool<ProbedPort, F>)
where
F: FnMut(ProbedPort, &mut ProbeAudit),
{
let ctx = asking.ctx;
loop {
let held =
std::mem::take(&mut *self.held.lock().unwrap_or_else(|held| held.into_inner()));
let Some(until) = held.iter().map(|port| port.until).max() else {
return;
};
let waited = ctx
.handle
.or_stopped(tokio::time::sleep_until(until.into()))
.await;
for port in held {
let ip = port.target.ip();
if waited.is_none() || ctx.handle.should_stop() || ctx.host_expired(ip) {
record_unasked(ctx, &port.target);
continue;
}
let patience =
NEIGHBOUR_PATH_FINDING_TIMEOUT.max(connect_patience(measured_path(ctx, ip)));
pool.admit(asking.port(port.target, patience)).await;
}
pool.drain().await;
}
}
}
#[derive(Debug, Clone, Copy)]
struct Silence {
target: PlannedTarget,
waited: Duration,
}
#[derive(Debug, Default)]
struct SlowPaths {
silent: std::sync::Mutex<std::collections::HashMap<IpAddr, Vec<Silence>>>,
}
#[derive(Clone)]
struct PathFinding {
segments: Arc<OnLinkTable>,
sent: Arc<std::sync::Mutex<std::collections::HashSet<IpAddr>>>,
}
impl PathFinding {
fn of(segments: OnLinkTable) -> Self {
Self {
segments: Arc::new(segments),
sent: Arc::default(),
}
}
fn patience(&self, path: PathAllowance, ip: IpAddr) -> Duration {
let finds_the_path = path == PathAllowance::NONE
&& self
.sent
.lock()
.unwrap_or_else(|held| held.into_inner())
.insert(ip);
if finds_the_path {
path_finding_wait(is_neighbour(&self.segments, ip))
} else {
connect_patience(path)
}
}
}
impl SlowPaths {
fn note(&self, silence: Silence) {
self.silent
.lock()
.unwrap_or_else(|held| held.into_inner())
.entry(silence.target.ip())
.or_default()
.push(silence);
}
fn take(&self) -> std::collections::HashMap<IpAddr, Vec<Silence>> {
std::mem::take(&mut *self.silent.lock().unwrap_or_else(|held| held.into_inner()))
}
async fn ask_again<F>(&self, asking: &Asking<'_>, pool: &mut ProbePool<ProbedPort, F>)
where
F: FnMut(ProbedPort, &mut ProbeAudit),
{
let ctx = asking.ctx;
let owed = self.take();
let open = |ip: &IpAddr| ctx.handle.stopped().is_none() && !ctx.host_expired(*ip);
let mut finders = std::collections::HashSet::new();
for (ip, ports) in &owed {
let found = ports
.iter()
.any(|silence| silence.waited >= PATH_FINDING_TIMEOUT);
if found || !open(ip) || measured_path(ctx, *ip) != PathAllowance::NONE {
continue;
}
let Some(likeliest) = ports.iter().min_by_key(|silence| {
let number = silence.target.port();
let rank = crate::model::port::TCP_BY_PREVALENCE
.iter()
.position(|&listed| listed == number);
(rank.is_none(), rank, number)
}) else {
continue;
};
finders.insert(likeliest.target);
pool.admit(asking.again(likeliest.target, PATH_FINDING_TIMEOUT))
.await;
}
pool.drain().await;
let mut asked = finders.len() as u128;
for (ip, ports) in &owed {
let path = measured_path(ctx, *ip);
if path == PathAllowance::NONE || !open(ip) {
continue;
}
let patience = connect_patience(path);
for silence in ports {
if silence.waited < patience && !finders.contains(&silence.target) {
asked += 1;
pool.admit(asking.again(silence.target, patience)).await;
}
}
}
pool.drain().await;
self.take();
if asked > 0 {
info!(
verbosity = 1,
"{} asked again, waiting for a slower path",
counted(asked, "filtered port", "filtered ports")
);
}
}
}
fn absorb_probe(
ctx: &ScanContext,
probed: ProbedPort,
audit: &mut ProbeAudit,
shortfall: &mut Shortfall,
) {
let Some(probed) = probed else {
return;
};
match probed.attempt {
Attempt::Sent => audit.record_send(true),
Attempt::Refused(_) | Attempt::Starved => audit.record_send(false),
Attempt::Unmade => {}
}
shortfall.count(probed.ip, &probed.attempt);
shortfall.identified_in_part += u128::from(probed.identified_in_part);
if probed.answered {
audit.record_host_found(None);
}
let (outcome, settles) = (probed.outcome, probed.settles);
file_probe(ctx, probed);
if settles {
ctx.record_outcome(outcome);
}
}
fn file_probe(ctx: &ScanContext, probed: Probed) {
if probed.port.is_none() && !probed.answered && probed.role.is_none() {
return;
}
if let Some((number, protocol)) = probed
.port
.as_ref()
.map(|port| (port.number(), port.protocol()))
{
ctx.record_responses(probed.ip.into(), number, protocol, probed.responses);
}
ctx.update_host(probed.ip, |host| {
if let Some(port) = probed.port.clone() {
host.add_port(port);
}
if let Some(role) = probed.role {
host.add_network_role(role);
}
if probed.answered {
host.record_evidence(
HostStatus::Up,
StatusReason::new(
StatusProtocol::TcpConnect,
"tcp connect answered by the host",
),
);
}
if let Some(rtt) = probed.rtt {
host.add_rtt_from(rtt, StatusProtocol::TcpConnect);
}
if !probed.about_the_host.is_empty() {
probed.about_the_host.clone().apply(host);
}
});
}
fn settled(number: u16, state: PortState, reason: Option<ScanResponse>) -> Port {
settled_over(Protocol::Tcp, number, state, reason)
}
fn settled_over(
protocol: Protocol,
number: u16,
state: PortState,
reason: Option<ScanResponse>,
) -> Port {
let port = crate::fingerprint::baseline_port(number, protocol, state);
match reason {
Some(reason) => port.with_discovery(Discovery::new(reason)),
None => port,
}
}
fn udp_evidence(state: PortState) -> Option<ScanResponse> {
match state {
PortState::Open => Some(ScanResponse::UdpResponse),
PortState::Closed | PortState::Filtered => Some(ScanResponse::IcmpUnreachable),
_ => None,
}
}
fn note_handshake(ctx: &ScanContext, ip: IpAddr, rtt: Duration) {
ctx.update_host(ip, |host| {
host.record_evidence(
HostStatus::Up,
StatusReason::new(
StatusProtocol::TcpConnect,
"tcp connect answered by the host",
),
);
host.add_rtt_from(rtt, StatusProtocol::TcpConnect);
});
}
#[allow(clippy::too_many_arguments)]
async fn port_prober(
planned: PlannedTarget,
detection: ServiceDetection,
shaping: Shaping,
egress: Egress,
socket_addr: SocketAddr,
mut patience: Duration,
ctx: ScanContext,
crowd: std::sync::Arc<crate::scanner::service::Crowd>,
neighbours: Arc<Neighbours>,
) -> ProbedPort {
let handle = &ctx.handle;
let target = planned.target;
if target.protocol == Protocol::Udp {
return None;
}
let position = planned.position;
let verdict = |state, reason, answered, rtt, outcome| {
Some(Probed {
ip: target.ip,
port: Some(settled(target.port, state, reason)),
responses: Vec::new(),
about_the_host: crate::fingerprint::AboutTheHost::default(),
identified_in_part: false,
answered,
rtt,
outcome,
attempt: Attempt::Sent,
role: None,
silence: None,
held_down: None,
settles: true,
})
};
let unasked = |outcome, attempt| {
Some(Probed {
ip: target.ip,
port: Some(settled(target.port, PortState::Unasked, None)),
responses: Vec::new(),
about_the_host: crate::fingerprint::AboutTheHost::default(),
identified_in_part: false,
answered: false,
rtt: None,
outcome,
attempt,
role: None,
silence: None,
held_down: None,
settles: true,
})
};
let held_down = |until| {
Some(Probed {
ip: target.ip,
port: None,
responses: Vec::new(),
about_the_host: crate::fingerprint::AboutTheHost::default(),
identified_in_part: false,
answered: false,
rtt: None,
outcome: Outcome::Unasked,
attempt: Attempt::Unmade,
role: None,
silence: None,
held_down: Some(HeldPort {
target: planned,
until,
}),
settles: false,
})
};
let mut met_itself = None;
let mut meetings = 0;
let mut held = HeldConnects::default();
while meetings < SELF_MEETINGS {
if neighbours.unreached(target.ip) {
return unasked(Outcome::Unroutable, Attempt::Refused(Refusal::Unresolved));
}
if let Some(until) = neighbours.held_until(target.ip) {
return held_down(until);
}
let (handshake, rtt, descriptor) = match dial(handle, descriptors::PATIENCE, || {
std::future::ready(egress.start_connect(socket_addr, shaping))
})
.await
{
Dialled::Ran {
result: Ok(connecting),
began,
descriptor,
} => {
let Some(finished) = handshake(connecting, patience, handle).await else {
return unasked(Outcome::Interrupted, Attempt::Sent);
};
(Handshake::sent(finished), began.elapsed(), Some(descriptor))
}
Dialled::Ran {
result: Err(e),
began,
..
} => (Handshake::unsent(e), began.elapsed(), None),
Dialled::Stopped => return unasked(Outcome::Unasked, Attempt::Unmade),
Dialled::Starved => return unasked(Outcome::Unroutable, Attempt::Starved),
};
let concluded = matches!(handshake, Handshake::Unreachable);
if (concluded || matches!(handshake, Handshake::Silent))
&& let Some(state) = neighbours.holding(target.ip)
{
match held.after(state, concluded) {
Held::Again(wait) => {
patience = patience.max(wait);
continue;
}
Held::Unreached => {
neighbours.give_up(target.ip);
return unasked(Outcome::Unroutable, Attempt::Refused(Refusal::Unresolved));
}
}
}
return match handshake {
Handshake::Accepted(stream) => {
let port = settled(target.port, PortState::Open, Some(ScanResponse::TcpSynAck));
note_handshake(&ctx, target.ip, rtt);
let path = measured_path(&ctx, target.ip);
let identified = handle
.or_stopped(crowd.identify(
target.ip.into(),
stream,
port,
detection,
egress,
path,
))
.await;
drop(descriptor);
let Some(identified) = identified else {
return verdict(
PortState::Open,
Some(ScanResponse::TcpSynAck),
true,
None,
Outcome::Answered { position },
);
};
Some(Probed {
ip: target.ip,
port: Some(identified.port),
responses: identified.responses,
about_the_host: identified.about_the_host,
identified_in_part: identified.starved,
answered: true,
rtt: None,
outcome: Outcome::Answered { position },
attempt: Attempt::Sent,
role: None,
silence: None,
held_down: None,
settles: true,
})
}
Handshake::Refused => verdict(
PortState::Closed,
Some(ScanResponse::ConnectionRefused),
true,
Some(rtt),
Outcome::Answered { position },
),
Handshake::Unreachable => verdict(
PortState::Filtered,
Some(ScanResponse::IcmpUnreachable),
false,
None,
Outcome::Answered { position },
),
Handshake::Silent => verdict(
PortState::Filtered,
Some(ScanResponse::NoResponse),
false,
None,
Outcome::Exhausted { position },
)
.map(|probed| Probed {
silence: Some(Silence {
target: planned,
waited: patience,
}),
..probed
}),
Handshake::MetItself(e) => {
meetings += 1;
met_itself = Some(e);
continue;
}
Handshake::NotSent(e) if crate::transport::probe::host_is_down(&e) => {
match neighbours.hold_down(target.ip, &e) {
Some(until) => held_down(until),
None => unasked(Outcome::Unroutable, Attempt::Refused(Refusal::Unresolved)),
}
}
Handshake::NotSent(e) => {
unasked(Outcome::Unroutable, Attempt::Refused(Refusal::of(&e)))
}
Handshake::Failed(e) => {
error!(
verbosity = 2,
"connect to {socket_addr} failed after sending: {e}"
);
unasked(Outcome::Unroutable, Attempt::Sent)
}
};
}
let why = met_itself.map_or_else(String::new, |e| e.to_string());
unasked(Outcome::Unroutable, Attempt::Refused(Refusal::Local(why)))
}
const SELF_MEETINGS: usize = 3;
#[derive(Debug)]
enum Handshake {
Accepted(TcpStream),
Refused,
Unreachable,
Silent,
MetItself(io::Error),
NotSent(io::Error),
Failed(io::Error),
}
impl Handshake {
fn unsent(error: io::Error) -> Self {
if crate::transport::dial::met_itself(&error) {
Self::MetItself(error)
} else if error.kind() == ErrorKind::ConnectionRefused {
Self::Refused
} else {
Self::NotSent(error)
}
}
fn sent(result: io::Result<TcpStream>) -> Self {
let error = match result {
Ok(stream) => return Self::Accepted(stream),
Err(error) => error,
};
if crate::transport::dial::met_itself(&error) {
return Self::MetItself(error);
}
match error.kind() {
ErrorKind::ConnectionRefused => Self::Refused,
ErrorKind::TimedOut => Self::Silent,
_ if is_unreachable(&error) => Self::Unreachable,
_ => Self::Failed(error),
}
}
}
fn is_unreachable(error: &io::Error) -> bool {
if matches!(
error.kind(),
ErrorKind::HostUnreachable | ErrorKind::NetworkUnreachable
) {
return true;
}
#[cfg(target_os = "linux")]
{
matches!(
error.raw_os_error(),
Some(libc::ENOPROTOOPT | libc::EHOSTDOWN | libc::ENONET)
)
}
#[cfg(not(target_os = "linux"))]
{
false
}
}
async fn handshake(
connecting: Connecting,
patience: Duration,
handle: &ScanHandle,
) -> Option<io::Result<TcpStream>> {
handle
.or_stopped(timeout(patience, connecting.finish()))
.await
.map(|finished| finished.unwrap_or_else(|_elapsed| Err(ErrorKind::TimedOut.into())))
}
async fn udp_port_prober(
planned: PlannedTarget,
shaping: Shaping,
egress: Egress,
socket_addr: SocketAddr,
handle: ScanHandle,
) -> ProbedPort {
let target = planned.target;
if target.protocol != Protocol::Udp {
return None;
}
let position = planned.position;
let record = |state, answered, outcome, attempt| {
Some(Probed {
ip: target.ip,
port: Some(settled_over(
Protocol::Udp,
target.port,
state,
udp_evidence(state),
)),
responses: Vec::new(),
about_the_host: crate::fingerprint::AboutTheHost::default(),
identified_in_part: false,
answered,
rtt: None,
outcome,
attempt,
role: None,
silence: None,
held_down: None,
settles: true,
})
};
let refused = |e: &io::Error| Attempt::Refused(Refusal::of(e));
let (socket, _descriptor) = match dial(&handle, descriptors::PATIENCE, || {
egress.udp_shaped(target.ip, shaping)
})
.await
{
Dialled::Ran {
result: Ok(socket),
descriptor,
..
} => (socket, descriptor),
Dialled::Ran { result: Err(e), .. } => {
error!(
verbosity = 2,
"no UDP socket for probing {socket_addr}: {e}"
);
return record(PortState::Unasked, false, Outcome::Unroutable, refused(&e));
}
Dialled::Stopped => {
return record(PortState::Unasked, false, Outcome::Unasked, Attempt::Unmade);
}
Dialled::Starved => {
return record(
PortState::Unasked,
false,
Outcome::Unroutable,
Attempt::Starved,
);
}
};
if let Err(e) = socket.connect(socket_addr).await {
error!(
verbosity = 2,
"cannot address UDP probe to {socket_addr}: {e}"
);
return record(PortState::Unasked, false, Outcome::Unroutable, refused(&e));
}
if let Err(e) = socket.send(payload::for_port(target.port)).await {
return match e.kind() {
ErrorKind::ConnectionRefused => record(
PortState::Closed,
false,
Outcome::Answered { position },
Attempt::Sent,
),
_ => {
error!(
verbosity = 2,
"failed to send UDP probe to {socket_addr}: {e}"
);
record(PortState::Unasked, false, Outcome::Unroutable, refused(&e))
}
};
}
let mut buf = [0u8; 1024];
match timeout(CONNECT_PROBE_TIMEOUT, socket.recv(&mut buf)).await {
Ok(Ok(read)) => record(
PortState::Open,
true,
Outcome::Answered { position },
Attempt::Sent,
)
.map(|probed| Probed {
role: payload::declared_role(target.port, &buf[..read]),
about_the_host: crate::fingerprint::AboutTheHost {
names: payload::declared_names(target.port, &buf[..read]),
..Default::default()
},
..probed
}),
Ok(Err(e)) if e.kind() == ErrorKind::ConnectionRefused => record(
PortState::Closed,
false,
Outcome::Answered { position },
Attempt::Sent,
),
Ok(Err(e)) if is_unreachable(&e) => record(
PortState::Filtered,
false,
Outcome::Answered { position },
Attempt::Sent,
),
Ok(Err(e)) => {
error!(
verbosity = 2,
"UDP probe to {socket_addr} failed after sending: {e}"
);
record(
PortState::OpenFiltered,
false,
Outcome::Unroutable,
Attempt::Sent,
)
}
Err(_) => record(
PortState::OpenFiltered,
false,
Outcome::Exhausted { position },
Attempt::Sent,
),
}
}
enum Dialled<T> {
Ran {
result: io::Result<T>,
began: Instant,
descriptor: Descriptor,
},
Stopped,
Starved,
}
async fn dial<T, F, Fut>(handle: &ScanHandle, patience: Duration, mut attempt: F) -> Dialled<T>
where
F: FnMut() -> Fut,
Fut: Future<Output = io::Result<T>>,
{
let mut refused_since: Option<Instant> = None;
let mut pause = descriptors::FIRST_PAUSE;
loop {
let descriptor = descriptors::gate()
.acquire()
.await
.expect("the descriptor gate is never closed");
if handle.should_stop() {
return Dialled::Stopped;
}
let began = Instant::now();
match attempt().await {
Err(e) if descriptors::exhausted(&e) => {
drop(descriptor);
if refused_since.get_or_insert(began).elapsed() >= patience {
return Dialled::Starved;
}
tokio::time::sleep(pause).await;
pause = (pause * 2).min(descriptors::LONGEST_PAUSE);
}
result => {
return Dialled::Ran {
result,
began,
descriptor,
};
}
}
}
}
fn report_starved(ctx: &ScanContext, scanner: ScannerKind, unasked: String, patience: Duration) {
crate::warn!("{unasked} unasked ({})", descriptors::starved_briefly());
ctx.file_cut_short(
scanner,
format!("{unasked} left unasked: {}", descriptors::starved(patience)),
);
}
fn finish(
ctx: &ScanContext,
audit: ProbeAudit,
scanner: ScannerKind,
probes: u128,
reason: StopReason,
) {
audit.report("connect", probes, reason, None, None);
ctx.record_probe_stats(audit.stats(scanner, probes, reason, None, None));
}
pub async fn discover(
ips: IpSet,
ctx: ScanContext,
evasion: &EvasionProfile,
) -> Result<(), StrategyError> {
discover_on(ips, ctx, evasion, SynPorts::common()).await
}
pub async fn discover_on(
ips: IpSet,
ctx: ScanContext,
evasion: &EvasionProfile,
ports: SynPorts,
) -> Result<(), StrategyError> {
sweep(ips, ctx, evasion, ports, descriptors::PATIENCE).await
}
async fn sweep(
ips: IpSet,
ctx: ScanContext,
evasion: &EvasionProfile,
ports: SynPorts,
patience: Duration,
) -> Result<(), StrategyError> {
let shaping = Shaping::from(evasion);
let ports: Arc<[u16]> = ports.as_slice().into();
let mut rx = dispatch_addresses_of(
ips,
1024,
ctx.order_seed,
Some(Arc::clone(&ctx.positions)),
&ctx.handle,
);
let folder = ctx.clone();
let mut starved = 0u128;
let mut shortfall = Shortfall::default();
let segments = Arc::new(OnLinkTable::of_segments());
let edges = Arc::clone(&segments);
let mut pool = ProbePool::new(
DISCOVERY_CONCURRENCY.min(descriptors::budget()),
ctx.clone(),
ScannerKind::Connect,
|probed, audit: &mut ProbeAudit| {
absorb_host(&folder, probed, audit, &mut starved, &mut shortfall, &edges)
},
);
let mut probes = 0u128;
let mut reason = StopReason::AttemptsSpent;
while let Some(ip) = rx.recv().await {
if let Some(cause) = ctx.handle.stopped() {
reason = cause.into();
ctx.record_address_outcomes(Outcome::Unasked, 1);
break;
}
probes += 1;
let egress = ctx.egress_toward(ip);
pool.admit(prober(
ip,
Arc::clone(&ports),
ctx.handle.clone(),
shaping,
egress,
patience,
is_neighbour(&segments, ip),
))
.await;
}
while rx.try_recv().is_ok() {
ctx.record_address_outcomes(Outcome::Unasked, 1);
}
pool.drain().await;
let audit = pool.into_audit();
if starved > 0 {
let unasked = counted(starved, "address", "addresses");
report_starved(&ctx, ScannerKind::Connect, unasked, patience);
}
shortfall.report(&ctx, ScannerKind::Connect, "address", "addresses");
finish(&ctx, audit, ScannerKind::Connect, probes, reason);
Ok(())
}
struct ProbedHost {
ip: IpAddr,
fate: Fate,
}
enum Fate {
Answered(Box<Host>),
Exhausted,
Refused(Refusal),
Starved,
Interrupted,
Unasked,
}
fn absorb_host(
ctx: &ScanContext,
probed: ProbedHost,
audit: &mut ProbeAudit,
starved: &mut u128,
shortfall: &mut Shortfall,
segments: &OnLinkTable,
) {
match probed.fate {
Fate::Refused(Refusal::NoRoute | Refusal::Forbidden)
if segments.is_segment_edge(probed.ip) =>
{
ctx.settle_address(probed.ip, Settled::Exhausted);
}
Fate::Answered(host) => {
let ip = host.primary_ip();
audit.record_send(true);
audit.record_host_found(None);
ctx.update_host(ip, |existing| existing.merge(*host));
ctx.settle_address(probed.ip, Settled::Answered);
}
Fate::Exhausted => {
audit.record_send(true);
ctx.settle_address(probed.ip, Settled::Exhausted);
}
Fate::Refused(refusal) => {
audit.record_send(false);
shortfall.count(probed.ip, &Attempt::Refused(refusal));
ctx.record_address_outcomes(Outcome::Unroutable, 1);
}
Fate::Starved => {
audit.record_send(false);
*starved += 1;
ctx.record_address_outcomes(Outcome::Unroutable, 1);
}
Fate::Interrupted => {
audit.record_send(true);
ctx.record_address_outcomes(Outcome::Interrupted, 1);
}
Fate::Unasked => ctx.record_address_outcomes(Outcome::Unasked, 1),
}
}
fn is_neighbour(segments: &OnLinkTable, ip: IpAddr) -> bool {
let link_local = matches!(ip, IpAddr::V6(v6) if v6.is_unicast_link_local());
link_local || segments.source_for(ip).is_some()
}
fn path_finding_wait(neighbour: bool) -> Duration {
if neighbour {
NEIGHBOUR_PATH_FINDING_TIMEOUT
} else {
PATH_FINDING_TIMEOUT
}
}
async fn prober(
ip: IpAddr,
ports: Arc<[u16]>,
handle: ScanHandle,
shaping: Shaping,
egress: Egress,
patience: Duration,
neighbour: bool,
) -> ProbedHost {
let mut asked = false;
let mut refused = None;
let mut waiting = path_finding_wait(neighbour);
let mut left = false;
let cut_short = |asked| ProbedHost {
ip,
fate: if asked {
Fate::Interrupted
} else {
Fate::Unasked
},
};
for &port in ports.iter() {
let addr = SocketAddr::new(ip, port);
let mut met_itself = None;
let mut knock = None;
for _ in 0..SELF_MEETINGS {
if handle.should_stop() {
return cut_short(asked);
}
let (handshake, start, _descriptor) = match dial(&handle, patience, || {
std::future::ready(egress.start_connect(addr, shaping))
})
.await
{
Dialled::Ran {
result: Ok(connecting),
began,
descriptor,
} => {
let Some(finished) = handshake(connecting, waiting, &handle).await else {
return cut_short(true);
};
let sent = Handshake::sent(finished);
waiting = CONNECT_PROBE_TIMEOUT;
let resolving = neighbour && !std::mem::replace(&mut left, true);
(sent, (began, resolving), Some(descriptor))
}
Dialled::Ran {
result: Err(e),
began,
..
} => (Handshake::unsent(e), (began, false), None),
Dialled::Stopped => return cut_short(asked),
Dialled::Starved => {
return ProbedHost {
ip,
fate: Fate::Starved,
};
}
};
match Knock::of(handshake) {
Knock::MetItself(e) => met_itself = Some(e),
other => {
knock = Some((other, start));
break;
}
}
}
match knock {
Some((Knock::Answered, (start, resolving))) => return answered(ip, start, resolving),
Some((Knock::Asked, _)) => asked = true,
Some((Knock::Refused(refusal @ (Refusal::NoRoute | Refusal::Forbidden)), _)) => {
return ProbedHost {
ip,
fate: Fate::Refused(refusal),
};
}
Some((Knock::Refused(refusal), _)) => {
refused.get_or_insert(refusal);
}
Some((Knock::MetItself(_), _)) | None => {
let why = met_itself.map_or_else(String::new, |e| e.to_string());
refused.get_or_insert(Refusal::Local(why));
}
}
}
ProbedHost {
ip,
fate: match refused {
Some(refusal) => Fate::Refused(refusal),
None if asked => Fate::Exhausted,
None => Fate::Unasked,
},
}
}
#[derive(Debug)]
enum Knock {
Answered,
Asked,
Refused(Refusal),
MetItself(io::Error),
}
impl Knock {
fn of(handshake: Handshake) -> Self {
match handshake {
Handshake::Accepted(_) | Handshake::Refused => Self::Answered,
Handshake::Failed(e)
if matches!(
e.kind(),
ErrorKind::ConnectionReset | ErrorKind::ConnectionAborted
) =>
{
Self::Answered
}
Handshake::Unreachable | Handshake::Silent | Handshake::Failed(_) => Self::Asked,
Handshake::MetItself(e) => Self::MetItself(e),
Handshake::NotSent(e) => Self::Refused(Refusal::of(&e)),
}
}
}
fn answered(ip: IpAddr, start: Instant, resolving: bool) -> ProbedHost {
let mut host = Host::new(ip);
let rtt = start.elapsed();
if resolving {
host.add_first_to_neighbour_rtt_from(rtt, StatusProtocol::TcpConnect);
} else {
host.add_rtt_from(rtt, StatusProtocol::TcpConnect);
}
host.record_evidence(
HostStatus::Up,
StatusReason::new(
StatusProtocol::TcpConnect,
"tcp connect answered by the host",
),
);
ProbedHost {
ip,
fate: Fate::Answered(Box::new(host)),
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::model::target::Target;
use crate::testing::loopback::accept_from_this_process;
use std::net::{Ipv4Addr, Ipv6Addr};
use tokio::net::UdpSocket;
#[test]
fn a_connect_waits_as_ever_on_an_ordinary_path_and_longer_on_a_slow_one() {
assert_eq!(connect_patience(PathAllowance::NONE), CONNECT_PROBE_TIMEOUT);
assert_eq!(
connect_patience(PathAllowance::of_round_trip(Duration::from_millis(40))),
CONNECT_PROBE_TIMEOUT
);
let slow = Duration::from_millis(1_900);
for path in [
PathAllowance::of_round_trip(slow),
PathAllowance::of_round_trips([slow; 10]),
] {
assert!(
connect_patience(path) > HOST_SYN_RETRANSMIT + slow,
"a connect across {path:?} waits {:?}",
connect_patience(path)
);
}
}
#[test]
fn the_first_port_asked_of_an_unmeasured_host_finds_the_path() {
use crate::system::interface::{Link, LinkAddress};
let finding = PathFinding::of(OnLinkTable::from_links(&[Link::new("test0", 1)
.with_addresses(vec![LinkAddress::new(
IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1)),
24,
)])]));
let host = IpAddr::V4(Ipv4Addr::new(198, 51, 100, 7));
let other = IpAddr::V4(Ipv4Addr::new(198, 51, 100, 8));
let neighbour = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 9));
assert_eq!(
finding.patience(PathAllowance::NONE, host),
PATH_FINDING_TIMEOUT
);
assert_eq!(
finding.patience(PathAllowance::NONE, host),
CONNECT_PROBE_TIMEOUT
);
assert_eq!(
finding.patience(PathAllowance::NONE, other),
PATH_FINDING_TIMEOUT
);
assert_eq!(
finding.patience(PathAllowance::NONE, neighbour),
NEIGHBOUR_PATH_FINDING_TIMEOUT
);
let measured = PathAllowance::of_round_trip(Duration::from_millis(1_900));
let third = IpAddr::V4(Ipv4Addr::new(198, 51, 100, 9));
assert_eq!(
finding.patience(measured, third),
connect_patience(measured)
);
}
fn udp_target(ip: IpAddr, port: u16) -> PlannedTarget {
PlannedTarget::new(
u64::from(port),
Target {
ip,
port,
protocol: Protocol::Udp,
},
)
}
#[tokio::test]
async fn closed_ipv6_port_is_classified_not_dropped() {
let ip = IpAddr::V6(Ipv6Addr::LOCALHOST);
let closed = crate::testing::loopback::ClosedUdpPort::open(ip);
let port = closed.port();
let probed = udp_port_prober(
udp_target(ip, port),
Shaping::default(),
Egress::KERNEL,
SocketAddr::new(ip, port),
ScanHandle::new(),
)
.await;
let probed = probed.expect("an IPv6 target must produce a verdict");
let probed_port = probed.port.expect("a closed port is still a verdict");
assert_eq!(probed.ip, ip);
assert_eq!(probed_port.number(), port);
assert_eq!(probed_port.state(), PortState::Closed);
}
#[tokio::test]
async fn closed_ipv4_port_is_closed() {
let ip = IpAddr::V4(Ipv4Addr::LOCALHOST);
let closed = crate::testing::loopback::ClosedUdpPort::open(ip);
let port = closed.port();
let probed = udp_port_prober(
udp_target(ip, port),
Shaping::default(),
Egress::KERNEL,
SocketAddr::new(ip, port),
ScanHandle::new(),
)
.await;
assert_eq!(
probed
.and_then(|probed| probed.port)
.expect("a verdict")
.state(),
PortState::Closed
);
}
#[tokio::test]
async fn a_udp_port_the_connect_path_settles_records_what_settled_it() {
let ip = IpAddr::V4(Ipv4Addr::LOCALHOST);
let service = UdpSocket::bind((ip, 0)).await.expect("bind service");
let open = service.local_addr().expect("bound").port();
tokio::spawn(async move {
let mut buf = [0u8; 64];
if let Ok((_, from)) =
crate::testing::loopback::recv_from_this_process(&service, &mut buf).await
{
let _ = service.send_to(b"pong", from).await;
}
});
let held = crate::testing::loopback::ClosedUdpPort::open(ip);
let closed = held.port();
for (port, reason) in [
(open, ScanResponse::UdpResponse),
(closed, ScanResponse::IcmpUnreachable),
] {
let probed = udp_port_prober(
udp_target(ip, port),
Shaping::default(),
Egress::KERNEL,
SocketAddr::new(ip, port),
ScanHandle::new(),
)
.await
.and_then(|probed| probed.port)
.expect("a verdict");
assert_eq!(
probed.discovery().map(|found| found.reason().clone()),
Some(reason),
"{port}: {probed:?}"
);
}
}
#[tokio::test]
async fn a_name_table_names_the_machine_on_the_connect_path() {
use crate::export::schema::HostDto;
use crate::export::{ExportOptions, Redaction};
use crate::model::host::Host;
use crate::protocols::netbios::tests::response;
let ip = IpAddr::V4(Ipv4Addr::LOCALHOST);
let service = UdpSocket::bind((ip, 0)).await.expect("bind service");
let at = service.local_addr().expect("bound");
tokio::spawn(async move {
let mut buf = [0u8; 64];
if let Ok((_, from)) = service.recv_from(&mut buf).await {
let table = response(&[
("FILESERVER", 0x00, false),
("FILESERVER", 0x20, false),
("EXAMPLEGRP", 0x00, true),
]);
let _ = service.send_to(&table, from).await;
}
});
let probed = udp_port_prober(
udp_target(ip, 137),
Shaping::default(),
Egress::KERNEL,
at,
ScanHandle::new(),
)
.await
.expect("a verdict");
let mut host = Host::new(ip);
probed.about_the_host.apply(&mut host);
let render = |options: ExportOptions| {
serde_json::to_value(HostDto::new(&host, &options)).expect("a host renders")
};
assert_eq!(
render(ExportOptions::new())["names"],
serde_json::json!([
{"source": "netbios", "kind": "netbios_host", "name": "FILESERVER"},
{"source": "netbios", "kind": "netbios_domain", "name": "EXAMPLEGRP"},
])
);
let masked = render(ExportOptions::new().with_redaction(Redaction::Standard)).to_string();
assert!(
!masked.contains("FILESERVER") && !masked.contains("EXAMPLEGRP"),
"a name survived redaction: {masked}"
);
}
#[tokio::test]
async fn a_refused_connect_times_the_host() {
let ip = IpAddr::V4(Ipv4Addr::LOCALHOST);
let port = crate::testing::loopback::refused_port(ip).port();
let planned = PlannedTarget::new(
0,
Target {
ip,
port,
protocol: Protocol::Tcp,
},
);
let (session, ctx) = crate::scanner::session::ScanSession::new();
let probed = port_prober(
planned,
ServiceDetection::Off,
Shaping::default(),
Egress::KERNEL,
SocketAddr::new(ip, port),
CONNECT_PROBE_TIMEOUT,
ctx.clone(),
Default::default(),
Default::default(),
)
.await;
absorb_probe(
&ctx,
probed,
&mut ProbeAudit::new(),
&mut Shortfall::default(),
);
let host = session
.hosts()
.get(ip)
.expect("the refusal proves the host");
assert!(
host.average_rtt().is_some(),
"the connect's round trip was not recorded against the host"
);
}
#[tokio::test]
async fn a_host_the_connect_path_reached_is_credited_to_a_handshake() {
let ip = IpAddr::V4(Ipv4Addr::LOCALHOST);
let port = crate::testing::loopback::refused_port(ip).port();
let (session, ctx) = crate::scanner::session::ScanSession::new();
let probed = port_prober(
tcp_target(ip, port),
ServiceDetection::Off,
Shaping::default(),
Egress::KERNEL,
SocketAddr::new(ip, port),
CONNECT_PROBE_TIMEOUT,
ctx.clone(),
Default::default(),
Default::default(),
)
.await;
absorb_probe(
&ctx,
probed,
&mut ProbeAudit::new(),
&mut Shortfall::default(),
);
let scanned = session
.hosts()
.get(ip)
.expect("the refusal proves the host");
let Fate::Answered(swept) = answered(ip, Instant::now(), false).fate else {
panic!("an answered address is answered");
};
for (found, host) in [("a port scan", &scanned), ("a sweep", &*swept)] {
let protocols: Vec<&StatusProtocol> = host
.reasons()
.iter()
.map(|reason| &reason.protocol)
.collect();
assert_eq!(protocols, [&StatusProtocol::TcpConnect], "{found}");
assert_eq!(
host.rtt_protocol(),
Some(StatusProtocol::TcpConnect),
"{found}"
);
}
}
#[tokio::test]
async fn a_listener_that_answers_is_open() {
for ip in [
IpAddr::V4(Ipv4Addr::LOCALHOST),
IpAddr::V6(Ipv6Addr::LOCALHOST),
] {
let service = UdpSocket::bind((ip, 0)).await.expect("bind service");
let port = service.local_addr().unwrap().port();
tokio::spawn(async move {
let mut buf = [0u8; 64];
if let Ok((_, from)) =
crate::testing::loopback::recv_from_this_process(&service, &mut buf).await
{
let _ = service.send_to(b"pong", from).await;
}
});
let probed = udp_port_prober(
udp_target(ip, port),
Shaping::default(),
Egress::KERNEL,
SocketAddr::new(ip, port),
ScanHandle::new(),
)
.await;
assert_eq!(
probed
.and_then(|probed| probed.port)
.expect("a verdict")
.state(),
PortState::Open,
"a live {ip} listener must read as open"
);
}
}
#[tokio::test]
async fn a_host_whose_neighbour_was_given_up_is_sent_nothing_more() {
use crate::transport::kernel_neighbors::{KernelNeighbors, NeighborTable};
let ip = IpAddr::V4(Ipv4Addr::LOCALHOST);
let listener = std::net::TcpListener::bind((ip, 0)).expect("bind a listener");
listener
.set_nonblocking(true)
.expect("a listener that does not block");
let port = listener.local_addr().expect("an inet address").port();
let table = KernelNeighbors::with_reader(Box::new(|| Ok(NeighborTable::new())))
.routing(Box::new(|address| Ok(Some(address))));
let neighbours = Arc::new(Neighbours::reading(Some(table)));
neighbours.give_up(ip);
let probed = port_prober(
tcp_target(ip, port),
ServiceDetection::Off,
Shaping::default(),
Egress::KERNEL,
SocketAddr::new(ip, port),
CONNECT_PROBE_TIMEOUT,
crate::scanner::session::ScanSession::new().1,
Default::default(),
neighbours,
)
.await
.expect("a TCP target is probed");
assert_eq!(
probed.port.as_ref().map(Port::state),
Some(PortState::Unasked)
);
assert_eq!(probed.attempt, Attempt::Refused(Refusal::Unresolved));
assert!(listener.accept().is_err(), "the port was connected");
}
#[test]
fn a_lone_sample_is_held_to_the_path_finding_wait() {
assert_eq!(
crate::transport::dial::UNMEASURED_PATH_WAIT,
PATH_FINDING_TIMEOUT
);
}
#[test]
fn a_neighbour_s_first_connect_waits_for_its_resolution_too() {
use crate::system::interface::{Link, LinkAddress};
let segments = OnLinkTable::from_links(&[Link::new("test0", 1).with_addresses(vec![
LinkAddress::new(IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1)), 24),
LinkAddress::new(
IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1)),
64,
),
])]);
let wait =
|ip: &str| path_finding_wait(is_neighbour(&segments, ip.parse().expect("an address")));
for neighbour in ["192.0.2.9", "2001:db8::9", "fe80::9"] {
assert_eq!(
wait(neighbour),
NEIGHBOUR_PATH_FINDING_TIMEOUT,
"{neighbour}"
);
}
for routed in ["203.0.113.9", "2001:db8:9::1"] {
assert_eq!(wait(routed), PATH_FINDING_TIMEOUT, "{routed}");
}
}
#[test]
fn a_neighbour_s_first_answer_is_a_bound_a_later_handshake_retires() {
use crate::model::host::telemetry::RttSource;
let ip = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 9));
let resolving = Instant::now()
.checked_sub(Duration::from_millis(3_800))
.expect("a clock that has run");
let Fate::Answered(mut swept) = answered(ip, resolving, true).fate else {
panic!("an answered address is answered");
};
assert_eq!(
swept
.telemetry()
.history()
.back()
.map(|sample| sample.source),
Some(RttSource::FirstToNeighbour)
);
let path = Duration::from_millis(1_900);
swept.add_rtt_from(path, StatusProtocol::TcpConnect);
assert_eq!(swept.telemetry().round_trips(), [path]);
}
fn tcp_target(ip: IpAddr, port: u16) -> PlannedTarget {
PlannedTarget::new(
u64::from(port),
Target {
ip,
port,
protocol: Protocol::Tcp,
},
)
}
#[tokio::test]
async fn a_connect_that_reaches_itself_is_never_filed_as_an_open_port() {
for ip in [
IpAddr::V4(Ipv4Addr::LOCALHOST),
IpAddr::V6(Ipv6Addr::LOCALHOST),
] {
let held = crate::testing::loopback::HeldTcpPort::open(ip);
let port = held.port();
let shaping = Shaping {
source_port: Some(port),
hop_limit: None,
};
let probed = port_prober(
tcp_target(ip, port),
ServiceDetection::default(),
shaping,
Egress::KERNEL,
SocketAddr::new(ip, port),
CONNECT_PROBE_TIMEOUT,
crate::scanner::session::ScanSession::new().1,
Default::default(),
Default::default(),
)
.await
.expect("a TCP target is probed");
assert_eq!(
probed.port.as_ref().map(Port::state),
Some(PortState::Unasked),
"{ip}: a connect that met itself was filed as {:?}",
probed.port
);
assert!(
matches!(&probed.attempt, Attempt::Refused(Refusal::Local(why))
if why.contains("reached itself")),
"{ip}: the refusal says why, and has {:?}",
probed.attempt
);
assert!(!probed.answered, "{ip}: nothing answered");
}
}
#[tokio::test]
async fn a_stop_ends_an_identification_in_flight() {
let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
.await
.expect("a free port");
let port = listener.local_addr().expect("its address").port();
let (_session, ctx) = crate::scanner::session::ScanSession::new();
let stopper = ctx.handle.clone();
let (returned, mut probe_done) = tokio::sync::oneshot::channel::<()>();
let listening = tokio::spawn(async move {
let mut held = Vec::new();
let first = accept_from_this_process(&listener)
.await
.expect("the probe connects");
held.push(first);
stopper.abort();
loop {
tokio::select! {
accepted = accept_from_this_process(&listener) => {
held.push(accepted.expect("a connection"));
}
_ = &mut probe_done => break,
}
}
while let Ok(Ok(more)) = tokio::time::timeout(
Duration::from_millis(500),
accept_from_this_process(&listener),
)
.await
{
held.push(more);
}
held.len()
});
let ip = IpAddr::V4(Ipv4Addr::LOCALHOST);
let probed = port_prober(
tcp_target(ip, port),
ServiceDetection::Thorough,
Shaping::default(),
Egress::KERNEL,
SocketAddr::new(ip, port),
CONNECT_PROBE_TIMEOUT,
ctx,
Default::default(),
Default::default(),
)
.await
.expect("a TCP target is probed");
let _ = returned.send(());
assert_eq!(
listening.await.expect("the listener ends"),
1,
"the identification went on connecting after the stop"
);
assert_eq!(
probed.port.as_ref().map(Port::state),
Some(PortState::Open),
"the handshake's verdict is kept"
);
assert!(probed.answered);
}
#[cfg(unix)]
fn a_port_that_drops_syns() -> (socket2::Socket, Vec<std::net::TcpStream>) {
let listener = socket2::Socket::new(
socket2::Domain::IPV4,
socket2::Type::STREAM,
Some(socket2::Protocol::TCP),
)
.expect("a socket");
listener
.bind(&SocketAddr::from((Ipv4Addr::LOCALHOST, 0)).into())
.expect("binds loopback");
listener.listen(1).expect("listens");
let addr = listener
.local_addr()
.expect("its address")
.as_socket()
.expect("an inet address");
let mut queued = Vec::new();
for _ in 0..64 {
match std::net::TcpStream::connect_timeout(&addr, Duration::from_millis(300)) {
Ok(stream) => queued.push(stream),
Err(_) => return (listener, queued),
}
}
panic!("the listener's queue never filled");
}
#[cfg(unix)]
#[tokio::test]
async fn a_stop_ends_a_handshake_in_flight_and_leaves_its_port_unasked() {
let (listener, _queued) = a_port_that_drops_syns();
let port = listener
.local_addr()
.expect("its address")
.as_socket()
.expect("an inet address")
.port();
let (_session, ctx) = crate::scanner::session::ScanSession::new();
let stopper = ctx.handle.clone();
tokio::spawn(async move {
tokio::time::sleep(Duration::from_millis(300)).await;
stopper.abort();
});
let ip = IpAddr::V4(Ipv4Addr::LOCALHOST);
let patience = Duration::from_secs(600);
let probed = tokio::time::timeout(
Duration::from_secs(60),
port_prober(
tcp_target(ip, port),
ServiceDetection::Off,
Shaping::default(),
Egress::KERNEL,
SocketAddr::new(ip, port),
patience,
ctx,
Default::default(),
Default::default(),
),
)
.await
.expect("the stop ended the handshake")
.expect("a TCP target is probed");
assert_eq!(
probed.port.as_ref().map(Port::state),
Some(PortState::Unasked),
"a handshake cut short has no verdict"
);
assert!(!probed.answered);
assert!(
matches!(probed.outcome, Outcome::Interrupted),
"asked and cut short, so a resume asks again: {:?}",
probed.outcome
);
}
#[cfg(unix)]
#[tokio::test]
async fn a_second_asking_cut_short_revises_nothing() {
let (listener, _queued) = a_port_that_drops_syns();
let port = listener
.local_addr()
.expect("its address")
.as_socket()
.expect("an inet address")
.port();
let (_session, ctx) = crate::scanner::session::ScanSession::new();
let stopper = ctx.handle.clone();
tokio::spawn(async move {
tokio::time::sleep(Duration::from_millis(300)).await;
stopper.abort();
});
let (crowds, tarpits, neighbours) = Default::default();
let asking = Asking {
ctx: &ctx,
detection: ServiceDetection::Off,
shaping: Shaping::default(),
zones: &ZoneMap::new(),
crowds: &crowds,
tarpits: &tarpits,
neighbours: &neighbours,
};
let ip = IpAddr::V4(Ipv4Addr::LOCALHOST);
let probed = tokio::time::timeout(
Duration::from_secs(60),
asking.again(tcp_target(ip, port), Duration::from_secs(600)),
)
.await
.expect("the stop ended the handshake")
.expect("a TCP target is probed");
assert_eq!(probed.port, None, "the second asking filed a port");
assert!(matches!(probed.attempt, Attempt::Sent), "its send counts");
}
#[tokio::test]
async fn a_handshake_times_the_host_before_its_port_is_identified() {
let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
.await
.expect("a free port");
let port = listener.local_addr().expect("its address").port();
let (accepted, first) = tokio::sync::oneshot::channel();
let listening = tokio::spawn(async move {
let held = accept_from_this_process(&listener)
.await
.expect("the probe connects");
let _ = accepted.send(());
tokio::time::sleep(Duration::from_secs(30)).await;
drop(held);
});
let ip = IpAddr::V4(Ipv4Addr::LOCALHOST);
let (_session, ctx) = crate::scanner::session::ScanSession::new();
let probing = tokio::spawn(port_prober(
tcp_target(ip, port),
ServiceDetection::Banner,
Shaping::default(),
Egress::KERNEL,
SocketAddr::new(ip, port),
CONNECT_PROBE_TIMEOUT,
ctx.clone(),
Default::default(),
Default::default(),
));
first.await.expect("the listener took the connection");
let mut timed = None;
for _ in 0..200 {
timed = ctx.read_host(ip, Host::median_rtt).flatten();
if timed.is_some() || probing.is_finished() {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
let identifying = !probing.is_finished();
ctx.handle.abort();
let _ = probing.await;
listening.abort();
assert!(
timed.is_some(),
"the handshake's round trip was not the host's while its port was identified"
);
assert!(identifying, "the identification ended before the test read");
}
#[cfg(unix)]
#[test]
fn a_route_refusing_by_policy_is_told_from_a_missing_one() {
let refused_with = |code| {
Refusal::of(&io::Error::new(
ErrorKind::HostUnreachable,
io::Error::from_raw_os_error(code),
))
};
assert_eq!(refused_with(libc::EACCES), Refusal::Forbidden);
assert_eq!(refused_with(libc::EINVAL), Refusal::Forbidden);
assert_eq!(
Refusal::of(&io::Error::from_raw_os_error(libc::EHOSTUNREACH)),
Refusal::NoRoute
);
assert_eq!(
Refusal::of(&io::Error::from_raw_os_error(libc::ENETUNREACH)),
Refusal::NoRoute
);
}
#[test]
fn an_unreachable_is_an_answer_after_the_syn_left_and_a_local_failure_before() {
for kind in [ErrorKind::HostUnreachable, ErrorKind::NetworkUnreachable] {
assert!(
matches!(
Handshake::sent(Err(io::Error::from(kind))),
Handshake::Unreachable
),
"{kind:?} after the SYN left"
);
assert!(
matches!(
Handshake::unsent(io::Error::from(kind)),
Handshake::NotSent(_)
),
"{kind:?} before anything left"
);
assert_eq!(
Refusal::of(&io::Error::from(kind)),
Refusal::NoRoute,
"{kind:?} before anything left is filed against the address"
);
}
let refused = || io::Error::from(ErrorKind::ConnectionRefused);
assert!(matches!(
Handshake::sent(Err(refused())),
Handshake::Refused
));
assert!(matches!(Handshake::unsent(refused()), Handshake::Refused));
assert!(matches!(
Handshake::sent(Err(io::Error::from(ErrorKind::TimedOut))),
Handshake::Silent
));
assert!(matches!(
Handshake::unsent(io::Error::from(ErrorKind::AddrNotAvailable)),
Handshake::NotSent(_)
));
}
#[tokio::test]
async fn a_port_this_machine_refused_to_send_is_unasked_and_the_report_says_why() {
let target = IpAddr::V4(Ipv4Addr::new(198, 51, 100, 7));
let (session, ctx) = crate::scanner::session::ScanSession::builder()
.send_source(vec![IpAddr::V4(Ipv4Addr::new(192, 0, 2, 250))])
.build();
let (tx, rx) = mpsc::channel(2);
tx.send(tcp_target(target, 443)).await.expect("queued");
drop(tx);
scan(
rx,
1,
ctx.clone(),
ServiceDetection::Off,
&EvasionProfile::default(),
&ZoneMap::new(),
)
.await
.expect("the scan runs");
let state = session.hosts().read(target, |host| {
host.ports().map(Port::state).collect::<Vec<_>>()
});
assert_eq!(state, Some(vec![PortState::Unasked]));
let failures = ctx.failures_snapshot();
assert!(
failures.iter().any(|failure| failure
.reason()
.starts_with("1 port left unasked: this machine refused")),
"the report says the refusal was this machine's, and has {failures:?}"
);
let stats = &ctx.probe_stats_snapshot()[0];
assert_eq!(
(stats.sends_attempted(), stats.sends_failed()),
(1, 1),
"a send this machine refused is a send that failed"
);
}
#[cfg(unix)]
async fn scan_held_down(ctx: &ScanContext, target: PlannedTarget) {
let (tx, rx) = mpsc::channel(1);
tx.send(target).await.expect("queued");
drop(tx);
scan_among(
rx,
1,
ctx.clone(),
ServiceDetection::Off,
&EvasionProfile::default(),
&ZoneMap::new(),
Neighbours::default().holding_down_for(Duration::from_millis(300)),
)
.await
.expect("the scan runs");
}
#[cfg(unix)]
#[tokio::test]
async fn a_connect_refused_for_a_hold_down_is_asked_again_after_it() {
let ip = IpAddr::V4(Ipv4Addr::LOCALHOST);
let listener = std::net::TcpListener::bind((ip, 0)).expect("bind a listener");
let addr = listener.local_addr().expect("an inet address");
crate::transport::dial::dialled::refuse(addr, libc::EHOSTDOWN, 1);
let (session, ctx) = crate::scanner::session::ScanSession::new();
scan_held_down(&ctx, tcp_target(ip, addr.port())).await;
assert_eq!(
crate::transport::dial::dialled::to(addr),
2,
"the port was not asked again"
);
let state = session
.hosts()
.read(ip, |host| host.ports().map(Port::state).collect::<Vec<_>>());
assert_eq!(state, Some(vec![PortState::Open]));
assert!(
ctx.failures_snapshot().is_empty(),
"a hold-down was blamed on this machine: {:?}",
ctx.failures_snapshot()
);
assert!(!ctx.is_unroutable(ip));
}
#[cfg(unix)]
#[tokio::test]
async fn a_connect_refused_for_a_second_hold_down_files_its_host_unreachable() {
let ip = IpAddr::V4(Ipv4Addr::LOCALHOST);
let listener = std::net::TcpListener::bind((ip, 0)).expect("bind a listener");
let addr = listener.local_addr().expect("an inet address");
crate::transport::dial::dialled::refuse(addr, libc::EHOSTDOWN, 2);
let (session, ctx) = crate::scanner::session::ScanSession::new();
scan_held_down(&ctx, tcp_target(ip, addr.port())).await;
assert_eq!(crate::transport::dial::dialled::to(addr), 2);
let state = session
.hosts()
.read(ip, |host| host.ports().map(Port::state).collect::<Vec<_>>());
assert_eq!(state, Some(vec![PortState::Unasked]));
assert!(ctx.is_unroutable(ip), "the host is unreached");
assert!(
ctx.failures_snapshot().is_empty(),
"a hold-down was blamed on this machine: {:?}",
ctx.failures_snapshot()
);
}
#[tokio::test]
async fn a_tarpits_unlikely_port_is_found_open_and_not_asked_what_it_runs() {
use crate::scanner::service::TARPIT_PORTS_IDENTIFIED;
use crate::testing::loopback::SilentPort;
let mut heard = Vec::new();
for tarpit in [true, false] {
let silent = SilentPort::open();
let addr = silent.addr();
assert!(
!crate::model::port::catalog::top_tcp(TARPIT_PORTS_IDENTIFIED)
.contains(&addr.port()),
"test assumes an ephemeral port is not among the likeliest"
);
let (session, ctx) = crate::scanner::session::ScanSession::new();
ctx.update_host(addr.ip(), |host| {
if tarpit {
host.add_network_role(NetworkRole::Tarpit);
}
});
let closed = crate::testing::loopback::refused_port(addr.ip()).port();
let (tx, rx) = mpsc::channel(2);
for port in [addr.port(), closed] {
tx.send(tcp_target(addr.ip(), port)).await.expect("queued");
}
drop(tx);
scan(
rx,
1,
ctx.clone(),
ServiceDetection::Probe,
&EvasionProfile::default(),
&ZoneMap::new(),
)
.await
.expect("the scan runs");
let open = session.hosts().read(addr.ip(), |host| {
host.ports()
.filter(|port| port.state() == PortState::Open)
.map(Port::number)
.collect::<Vec<_>>()
});
assert_eq!(open, Some(vec![addr.port()]), "tarpit: {tarpit}");
let reported = ctx.failures_snapshot().iter().any(|failure| {
failure.scanner() == ScannerKind::Service
&& failure.reason().starts_with(&format!(
"{}: 1 open ports were not fingerprinted",
addr.ip()
))
});
assert_eq!(reported, tarpit, "tarpit: {tarpit}");
heard.push(silent.heard());
}
assert_eq!(heard[0], 0, "the tarpit's port was asked what it runs");
assert!(
heard[1] > 0,
"the same port on an ordinary host was asked nothing, so the first \
half proves nothing"
);
}
#[tokio::test]
async fn a_pinned_source_port_still_closing_is_named_as_the_reason_a_port_went_unasked() {
use tokio::io::AsyncReadExt;
let ip = IpAddr::V4(Ipv4Addr::LOCALHOST);
let listener = tokio::net::TcpListener::bind((ip, 0)).await.expect("bind");
let port = listener.local_addr().expect("bound").port();
tokio::spawn(async move {
while let Ok(mut stream) = accept_from_this_process(&listener).await {
tokio::spawn(async move {
let mut buf = [0u8; 256];
while matches!(stream.read(&mut buf).await, Ok(read) if read > 0) {}
});
}
});
let held = crate::testing::loopback::HeldTcpPort::open(ip);
let pinned = held.port();
let evasion = EvasionProfile {
source_port: Some(pinned),
..EvasionProfile::default()
};
let run = || async {
let (session, ctx) = crate::scanner::session::ScanSession::new();
let (tx, rx) = mpsc::channel(1);
tx.send(tcp_target(ip, port)).await.expect("queued");
drop(tx);
scan(
rx,
1,
ctx.clone(),
ServiceDetection::Off,
&evasion,
&ZoneMap::new(),
)
.await
.expect("the scan runs");
let state = session
.hosts()
.read(ip, |host| host.ports().map(Port::state).next())
.flatten();
let reasons: Vec<String> = ctx
.failures_snapshot()
.iter()
.map(|failure| failure.reason().to_string())
.collect();
(state, reasons)
};
assert_eq!(run().await.0, Some(PortState::Open), "the first run");
match run().await {
(Some(PortState::Open), _) => {}
(Some(PortState::Unasked), reasons) => assert!(
reasons.iter().any(|reason| reason
== &format!("1 port left unasked: source port {pinned} still closing")),
"the report names the pinned port, and has {reasons:?}"
),
other => panic!("the port was neither asked nor unasked: {other:?}"),
}
}
#[test]
fn a_pinned_source_port_held_is_warned_in_one_short_line_not_as_a_failure() {
for (holder, by) in [
(Holder::Closing, "still closing"),
(Holder::Socket, "held elsewhere"),
] {
let (_session, ctx) = crate::scanner::session::ScanSession::new();
let mut shortfall = Shortfall::default();
let held = Attempt::Refused(Refusal::PortHeld(40404, holder));
shortfall.count(IpAddr::V4(Ipv4Addr::LOCALHOST), &held);
shortfall.count(IpAddr::V4(Ipv4Addr::LOCALHOST), &held);
let lines = crate::logging::logged(|| {
shortfall.report(&ctx, ScannerKind::Connect, "port", "ports");
});
let said: Vec<&str> = lines.iter().map(|line| line.message.as_str()).collect();
assert_eq!(said, [format!("2 ports unasked (source port 40404 {by})")]);
let filed: Vec<(String, bool)> = ctx
.failures_snapshot()
.iter()
.map(|failure| (failure.reason().to_string(), failure.is_cut_short()))
.collect();
assert_eq!(
filed,
[(
format!("2 ports left unasked: source port 40404 {by}"),
true
)],
"filed, and marked as cut short rather than failed"
);
}
}
#[test]
fn descriptor_starvation_is_warned_naming_the_limit_and_filed_as_cut_short() {
let (_session, ctx) = crate::scanner::session::ScanSession::new();
let mut shortfall = Shortfall::default();
shortfall.count(IpAddr::V4(Ipv4Addr::LOCALHOST), &Attempt::Starved);
shortfall.count(IpAddr::V4(Ipv4Addr::LOCALHOST), &Attempt::Starved);
shortfall.identified_in_part = 1;
let lines = crate::logging::logged(|| {
shortfall.report(&ctx, ScannerKind::Connect, "port", "ports");
});
let limit = descriptors::starved_briefly();
let said: Vec<&str> = lines.iter().map(|line| line.message.as_str()).collect();
assert_eq!(
said,
[
format!("2 ports unasked ({limit})"),
format!("1 port identified in part ({limit})"),
]
);
let filed = ctx.failures_snapshot();
assert_eq!(filed.len(), 2, "{filed:?}");
assert!(
filed.iter().all(|failure| failure.is_cut_short()
&& failure.reason().contains("file descriptor limit")),
"{filed:?}"
);
}
#[tokio::test]
async fn tcp_targets_are_skipped() {
let target = PlannedTarget::new(
0,
Target {
ip: IpAddr::V4(Ipv4Addr::LOCALHOST),
port: 80,
protocol: Protocol::Tcp,
},
);
assert!(
udp_port_prober(
target,
Shaping::default(),
Egress::KERNEL,
SocketAddr::new(target.ip(), target.port()),
ScanHandle::new(),
)
.await
.is_none()
);
}
#[test]
fn the_profile_maps_onto_what_a_connect_can_carry() {
let profile = EvasionProfile {
source_port: Some(53),
ttl: Some(12),
..Default::default()
};
let shaping = Shaping::from(&profile);
assert_eq!(shaping.source_port, Some(53));
assert_eq!(shaping.hop_limit, Some(12));
assert!(shaping.is_active());
assert!(!Shaping::from(&EvasionProfile::default()).is_active());
}
#[cfg(unix)]
use crate::system::descriptors::testing::{
exhaust as exhaust_descriptors, in_a_process_of_its_own,
};
#[cfg(unix)]
#[test]
fn a_sweep_short_of_descriptors_waits_for_one_rather_than_passing_the_address_over() {
if !in_a_process_of_its_own(
module_path!(),
"a_sweep_short_of_descriptors_waits_for_one_rather_than_passing_the_address_over",
) {
return;
}
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.expect("a runtime, built while descriptors remain");
let held = exhaust_descriptors(64);
let local = IpAddr::V4(Ipv4Addr::LOCALHOST);
runtime.block_on(async {
let (session, ctx) = crate::scanner::session::ScanSession::new();
tokio::spawn(async move {
tokio::time::sleep(std::time::Duration::from_millis(300)).await;
drop(held);
});
discover(IpSet::from(local), ctx.clone(), &EvasionProfile::default())
.await
.expect("the sweep runs");
assert!(
session.hosts().contains(local),
"this machine answers every connect, so a sweep that missed it \
passed the address over for want of a socket"
);
let stats = &ctx.probe_stats_snapshot()[0];
assert_eq!(
(stats.sends_attempted(), stats.sends_failed()),
(1, 0),
"one address, asked once it had a socket"
);
});
}
#[tokio::test]
async fn a_sweep_connect_that_reaches_itself_finds_no_host_and_says_why() {
for ip in [
IpAddr::V4(Ipv4Addr::LOCALHOST),
IpAddr::V6(Ipv6Addr::LOCALHOST),
] {
let held = crate::testing::loopback::HeldTcpPort::open(ip);
let port = held.port();
let evasion = EvasionProfile {
source_port: Some(port),
..EvasionProfile::default()
};
let (session, ctx) = crate::scanner::session::ScanSession::new();
discover_on(IpSet::from(ip), ctx.clone(), &evasion, SynPorts::only(port))
.await
.expect("the sweep runs");
assert!(
!session
.hosts()
.read(ip, |host| host.status() == HostStatus::Up)
.unwrap_or(false),
"{ip}: a connect that met itself proved a host"
);
assert_eq!(ctx.settlements().settled_count(), 0, "{ip}: nothing asked");
let failures = ctx.failures_snapshot();
assert!(
failures
.iter()
.any(|failure| failure.reason().contains("reached itself")),
"{ip}: the report says why, and has {failures:?}"
);
}
}
#[test]
fn a_liveness_knock_reads_an_unreachable_by_where_it_surfaced() {
for kind in [ErrorKind::HostUnreachable, ErrorKind::NetworkUnreachable] {
assert!(
matches!(
Knock::of(Handshake::unsent(io::Error::from(kind))),
Knock::Refused(Refusal::NoRoute)
),
"{kind:?} before anything left"
);
assert!(
matches!(
Knock::of(Handshake::sent(Err(io::Error::from(kind)))),
Knock::Asked
),
"{kind:?} after the SYN left"
);
}
assert!(matches!(
Knock::of(Handshake::sent(Err(io::Error::from(
ErrorKind::ConnectionRefused
)))),
Knock::Answered
));
assert!(matches!(
Knock::of(Handshake::sent(Err(io::Error::from(ErrorKind::TimedOut)))),
Knock::Asked
));
}
#[test]
fn an_address_no_route_leads_to_is_filed_unroutable() {
let ip = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 9));
let (_session, ctx) = crate::scanner::session::ScanSession::new();
let mut audit = ProbeAudit::default();
let mut shortfall = Shortfall::default();
absorb_host(
&ctx,
ProbedHost {
ip,
fate: Fate::Refused(Refusal::NoRoute),
},
&mut audit,
&mut 0,
&mut shortfall,
&OnLinkTable::from_links(&[]),
);
shortfall.report(&ctx, ScannerKind::Connect, "address", "addresses");
assert!(ctx.is_unroutable(ip));
assert!(ctx.failures_snapshot().is_empty(), "nothing broke here");
}
#[test]
fn a_neighbour_the_routing_table_refuses_is_named_refused_by_a_route() {
use crate::system::interface::{Link, LinkAddress};
let segments = OnLinkTable::from_links(&[Link::new("test0", 1).with_addresses(vec![
LinkAddress::new(IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1)), 24),
])]);
let address = |last| IpAddr::V4(Ipv4Addr::new(192, 0, 2, last));
let routed = IpAddr::V4(Ipv4Addr::new(198, 51, 100, 7));
let (_session, ctx) = crate::scanner::session::ScanSession::new();
let mut shortfall = Shortfall::default();
for ip in [address(2), address(3), address(255), routed] {
shortfall.count(ip, &Attempt::Refused(Refusal::NoRoute));
}
shortfall.file(
&ctx,
ScannerKind::Connect,
"address",
"addresses",
&segments,
|target| target != IpAddr::V4(Ipv4Addr::new(192, 0, 2, 3)),
);
for ip in [address(2), address(3), address(255), routed] {
assert!(ctx.is_unroutable(ip), "{ip} not filed unreachable");
}
let refused = ctx.take_refused_by_route();
assert_eq!(refused, [address(2)]);
}
#[test]
fn a_segment_s_own_addresses_are_settled_rather_than_filed_unreachable() {
use crate::system::interface::{Link, LinkAddress};
let segments = OnLinkTable::from_links(&[Link::new("test0", 1).with_addresses(vec![
LinkAddress::new(IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1)), 24),
])]);
let (_session, ctx) = crate::scanner::session::ScanSession::new();
let mut audit = ProbeAudit::default();
let mut shortfall = Shortfall::default();
let edges = [Ipv4Addr::new(192, 0, 2, 0), Ipv4Addr::new(192, 0, 2, 255)];
let neighbour = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 9));
for ip in edges.map(IpAddr::V4).into_iter().chain([neighbour]) {
absorb_host(
&ctx,
ProbedHost {
ip,
fate: Fate::Refused(Refusal::NoRoute),
},
&mut audit,
&mut 0,
&mut shortfall,
&segments,
);
}
shortfall.report(&ctx, ScannerKind::Connect, "address", "addresses");
let settled_silent = ctx.take_silent();
for edge in edges.map(IpAddr::V4) {
assert!(!ctx.is_unroutable(edge), "{edge} filed unreachable");
assert!(settled_silent.contains(&edge), "{edge} left unsettled");
}
assert!(ctx.is_unroutable(neighbour));
assert!(!settled_silent.contains(&neighbour));
}
#[cfg(unix)]
#[test]
fn a_sweep_that_never_gets_a_socket_reports_it_rather_than_an_empty_network() {
if !in_a_process_of_its_own(
module_path!(),
"a_sweep_that_never_gets_a_socket_reports_it_rather_than_an_empty_network",
) {
return;
}
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.expect("a runtime, built while descriptors remain");
let _held = exhaust_descriptors(64);
let local = IpAddr::V4(Ipv4Addr::LOCALHOST);
runtime.block_on(async {
let (session, ctx) = crate::scanner::session::ScanSession::new();
let patience = std::time::Duration::from_millis(200);
sweep(
IpSet::from(local),
ctx.clone(),
&EvasionProfile::default(),
SynPorts::common(),
patience,
)
.await
.expect("the sweep runs");
assert!(!session.hosts().contains(local), "no socket, no answer");
assert_eq!(
ctx.settlements().settled_count(),
0,
"an address never asked is not settled"
);
let stats = &ctx.probe_stats_snapshot()[0];
assert_eq!(
(stats.sends_attempted(), stats.sends_failed()),
(1, 1),
"the send was attempted and the process refused it"
);
let failures = ctx.failures_snapshot();
assert!(
failures.iter().any(|failure| failure
.reason()
.contains("file descriptor limit of 64")
&& failure.is_cut_short()),
"the report names the limit the sweep ran into, as a limit and \
not a fault, and has {failures:?}"
);
});
}
}