use crate::config::ServiceDetection;
use crate::config::limits::{CONNECT_PROBE_TIMEOUT, DISCOVERY_CONCURRENCY};
use crate::counted;
use crate::evasion::EvasionProfile;
use crate::journal::settle::{Outcome, Settled};
use crate::logging::error;
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::ScannerKind;
use crate::report::StopReason;
use crate::scanner::audit::ProbeAudit;
use crate::scanner::dispatcher::dispatch_addresses;
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};
use crate::system::descriptors::{self, Descriptor};
use crate::transport::dial::{Connecting, Egress, Shaping};
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;
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,
answered: bool,
outcome: Outcome,
attempt: Attempt,
rtt: Option<Duration>,
role: Option<NetworkRole>,
}
type ProbedPort = Option<Probed>;
#[derive(Debug, Clone, PartialEq, Eq)]
enum Attempt {
Sent,
Refused(Refusal),
Starved,
Unmade,
}
#[derive(Debug, Clone, PartialEq, Eq)]
enum Refusal {
NoRoute,
Local(String),
}
impl Refusal {
fn of(error: &io::Error) -> Self {
match error.kind() {
ErrorKind::HostUnreachable | ErrorKind::NetworkUnreachable => Self::NoRoute,
_ => Self::Local(error.to_string()),
}
}
}
#[derive(Debug, Default)]
struct Shortfall {
starved: u128,
unroutable: std::collections::BTreeSet<IpAddr>,
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) => {
self.unroutable.insert(ip);
}
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) {
if self.starved > 0 {
let unasked = counted(self.starved, unit, units);
report_starved(ctx, scanner, unasked, descriptors::PATIENCE);
}
for address in self.unroutable {
let reached = ctx
.read_host(address, |host| host.status() == HostStatus::Up)
.unwrap_or(false);
if !reached {
ctx.record_unroutable(address);
}
}
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
}
}
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> {
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;
}
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(
mut rx: mpsc::Receiver<PlannedTarget>,
concurrency_limit: usize,
ctx: ScanContext,
detection: ServiceDetection,
evasion: &EvasionProfile,
zones: &ZoneMap,
) -> Result<(), StrategyError> {
let shaping = Shaping::from(evasion);
let folder = ctx.clone();
let mut shortfall = Shortfall::default();
let mut pool = ProbePool::new(
concurrency_limit,
ctx.clone(),
ScannerKind::Connect,
|probed, audit: &mut ProbeAudit| absorb_probe(&folder, probed, audit, &mut shortfall),
);
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;
}
let endpoint = zones.endpoint(target.ip(), target.port());
let egress = ctx.egress_toward(target.ip());
let identify = ctx.service_detection_on(detection, target.port(), target.protocol());
pool.admit(port_prober(
target,
identify,
shaping,
egress,
endpoint,
ctx.handle.clone(),
))
.await;
}
while let Ok(target) = rx.try_recv() {
record_unasked(&ctx, &target);
}
pool.drain().await;
let audit = pool.into_audit();
shortfall.report(&ctx, ScannerKind::Connect, "port", "ports");
finish(&ctx, audit, ScannerKind::Connect, probes, reason);
Ok(())
}
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);
ctx.record_outcome(probed.outcome);
if probed.answered {
audit.record_host_found(None);
}
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::TcpSyn, "tcp connect answered by the host"),
);
}
if let Some(rtt) = probed.rtt {
host.add_rtt_from(rtt, StatusProtocol::TcpSyn);
}
if !probed.about_the_host.is_empty() {
probed.about_the_host.clone().apply(host);
}
});
}
fn settled(number: u16, state: PortState, reason: Option<ScanResponse>) -> Port {
let port = crate::fingerprint::baseline_port(number, Protocol::Tcp, state);
match reason {
Some(reason) => port.with_discovery(Discovery::new(reason)),
None => port,
}
}
fn record_unasked(ctx: &ScanContext, target: &PlannedTarget) {
let port =
crate::fingerprint::baseline_port(target.port(), target.protocol(), PortState::Unasked);
ctx.update_host(target.ip(), |host| {
host.add_port(port);
});
ctx.record_outcome(Outcome::Unasked);
}
async fn port_prober(
planned: PlannedTarget,
detection: ServiceDetection,
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 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(),
answered,
rtt,
outcome,
attempt: Attempt::Sent,
role: None,
})
};
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(),
answered: false,
rtt: None,
outcome,
attempt,
role: None,
})
};
let mut met_itself = None;
for _ in 0..SELF_MEETINGS {
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 handshake = Handshake::sent(handshake(connecting).await);
(handshake, 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),
};
return match handshake {
Handshake::Accepted(stream) => {
let port = settled(target.port, PortState::Open, Some(ScanResponse::TcpSynAck));
let (port, about_the_host, responses) =
crate::fingerprint::fingerprint_tcp_via(stream, port, detection, egress).await;
drop(descriptor);
Some(Probed {
ip: target.ip,
port: Some(port),
responses,
about_the_host,
answered: true,
rtt: Some(rtt),
outcome: Outcome::Answered { position },
attempt: Attempt::Sent,
role: None,
})
}
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 },
),
Handshake::MetItself(e) => {
met_itself = Some(e);
continue;
}
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) -> io::Result<TcpStream> {
timeout(CONNECT_PROBE_TIMEOUT, connecting.finish())
.await
.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(crate::fingerprint::baseline_port(
target.port,
Protocol::Udp,
state,
)),
responses: Vec::new(),
about_the_host: crate::fingerprint::AboutTheHost::default(),
answered,
rtt: None,
outcome,
attempt,
role: None,
})
};
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]),
..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,
};
}
}
}
}
async fn connect(egress: Egress, addr: SocketAddr, shaping: Shaping) -> io::Result<TcpStream> {
timeout(CONNECT_PROBE_TIMEOUT, egress.connect_shaped(addr, shaping))
.await
.unwrap_or_else(|_elapsed| Err(ErrorKind::TimedOut.into()))
}
fn report_starved(ctx: &ScanContext, scanner: ScannerKind, unasked: String, patience: Duration) {
ctx.record_failure(
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(ips, 1024, ctx.order_seed, &ctx.handle);
let folder = ctx.clone();
let mut starved = 0u128;
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),
);
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,
))
.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);
}
finish(&ctx, audit, ScannerKind::Connect, probes, reason);
Ok(())
}
struct ProbedHost {
ip: IpAddr,
fate: Fate,
}
enum Fate {
Answered(Box<Host>),
Exhausted,
Unroutable,
Starved,
Interrupted,
Unasked,
}
fn absorb_host(ctx: &ScanContext, probed: ProbedHost, audit: &mut ProbeAudit, starved: &mut u128) {
match probed.fate {
Fate::Answered(host) => {
let ip = host.primary_ip();
audit.record_send(true);
audit.record_host_found(None);
ctx.settle_address(probed.ip, Settled::Answered);
ctx.update_host(ip, |existing| existing.merge(*host));
}
Fate::Exhausted => {
audit.record_send(true);
ctx.settle_address(probed.ip, Settled::Exhausted);
}
Fate::Unroutable => {
audit.record_send(false);
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),
}
}
async fn prober(
ip: IpAddr,
ports: Arc<[u16]>,
handle: ScanHandle,
shaping: Shaping,
egress: Egress,
patience: Duration,
) -> ProbedHost {
let mut asked = false;
let cut_short = |asked| ProbedHost {
ip,
fate: if asked {
Fate::Interrupted
} else {
Fate::Unasked
},
};
for &port in ports.iter() {
if handle.should_stop() {
return cut_short(asked);
}
let addr = SocketAddr::new(ip, port);
let (attempt, start, _descriptor) =
match dial(&handle, patience, || connect(egress, addr, shaping)).await {
Dialled::Ran {
result,
began,
descriptor,
} => (result, began, descriptor),
Dialled::Stopped => return cut_short(asked),
Dialled::Starved => {
return ProbedHost {
ip,
fate: Fate::Starved,
};
}
};
match attempt {
Ok(_) => return answered(ip, start),
Err(e) => match e.kind() {
ErrorKind::ConnectionRefused
| ErrorKind::ConnectionReset
| ErrorKind::ConnectionAborted => return answered(ip, start),
ErrorKind::TimedOut => asked = true,
_ => {}
},
}
}
ProbedHost {
ip,
fate: if asked {
Fate::Exhausted
} else {
Fate::Unroutable
},
}
}
fn answered(ip: IpAddr, start: Instant) -> ProbedHost {
let mut host = Host::new(ip);
host.add_rtt_from(start.elapsed(), StatusProtocol::TcpSyn);
host.record_evidence(
HostStatus::Up,
StatusReason::new(StatusProtocol::TcpSyn, "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 std::net::{Ipv4Addr, Ipv6Addr};
use tokio::net::UdpSocket;
fn udp_target(ip: IpAddr, port: u16) -> PlannedTarget {
PlannedTarget::new(
u64::from(port),
Target {
ip,
port,
protocol: Protocol::Udp,
},
)
}
async fn closed_loopback_udp_port(ip: IpAddr) -> u16 {
let socket = UdpSocket::bind((ip, 0)).await.expect("bind to reserve");
let port = socket.local_addr().expect("reserved addr").port();
drop(socket);
port
}
#[tokio::test]
async fn closed_ipv6_port_is_classified_not_dropped() {
let ip = IpAddr::V6(Ipv6Addr::LOCALHOST);
let port = closed_loopback_udp_port(ip).await;
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 port = closed_loopback_udp_port(ip).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::Closed
);
}
#[tokio::test]
async fn a_refused_connect_times_the_host() {
let ip = IpAddr::V4(Ipv4Addr::LOCALHOST);
let port = {
let listener = std::net::TcpListener::bind((ip, 0)).expect("bind to reserve");
listener.local_addr().expect("reserved addr").port()
};
let planned = PlannedTarget::new(
0,
Target {
ip,
port,
protocol: Protocol::Tcp,
},
);
let probed = port_prober(
planned,
ServiceDetection::Off,
Shaping::default(),
Egress::KERNEL,
SocketAddr::new(ip, port),
ScanHandle::new(),
)
.await;
let (session, ctx) = crate::scanner::session::ScanSession::new();
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_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)) = service.recv_from(&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"
);
}
}
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 port = {
let reserved = std::net::TcpListener::bind((ip, 0)).expect("a free port");
reserved.local_addr().expect("its address").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),
ScanHandle::new(),
)
.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");
}
}
#[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"
);
}
#[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"
);
});
}
#[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")),
"the report names the limit the sweep ran into, and has {failures:?}"
);
});
}
}