use std::num::NonZeroU32;
use std::{
collections::HashMap,
net::IpAddr,
time::{Duration, Instant},
};
use crate::config::ProbeTuning;
use crate::evasion::SegmentShaping;
use crate::info;
use crate::journal::settle::{Outcome, Settled};
use crate::model::host::{HostStatus, StatusProtocol, StatusReason};
use crate::model::ip::set::IpSet;
use crate::model::technique::{TcpReply, TcpScanTechnique};
use crate::protocols as protocol;
use crate::scanner::pacing::deadline::AdaptiveDeadline;
use crate::scanner::pacing::retry::{ProbeLedger, Resolution, RetryPolicy};
use crate::scanner::session::ScanContext;
use crate::system::interface::RoutedTarget;
use crate::transport::probe::{Emission, ProbeKind, ProbeTransport};
use async_trait::async_trait;
use tokio::sync::mpsc::UnboundedSender;
use crate::report::ScannerKind;
use crate::report::StopReason;
use crate::scanner::strategy::raw::{
DEADLINE_CONFIG, EvasionParts, RETRY_POLICY, SendFaults, SynToken, pacing_for, rate_within,
send_init, send_syn,
};
use crate::scanner::strategy::sweep::HostSweep;
use crate::scanner::strategy::{HostScanner, StrategyError};
pub(super) const PROBE_RATE_PER_SEC: NonZeroU32 = NonZeroU32::new(4_000).expect("a non-zero rate");
fn answers_a_syn_probe(bytes: &[u8]) -> bool {
protocol::tcp::parse(bytes)
.ok()
.and_then(|tcp| protocol::tcp::classify_probe_response(&tcp))
.is_some_and(|reply| !matches!(reply, TcpReply::ChallengeAck))
}
const SYN_DISCOVERY_PORT: u16 = 443;
#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SweepProbe {
Syn {
src_port: Option<u16>,
dst_port: u16,
},
Init {
src_port: u16,
dst_port: u16,
},
}
impl SweepProbe {
pub const fn syn(src_port: Option<u16>) -> Self {
Self::Syn {
src_port,
dst_port: SYN_DISCOVERY_PORT,
}
}
pub const fn init(src_port: u16, dst_port: u16) -> Self {
Self::Init { src_port, dst_port }
}
const fn transport(self) -> ProbeKind {
match self {
Self::Syn { .. } => ProbeKind::TcpSyn,
Self::Init { src_port, .. } => ProbeKind::Sctp {
reply_port: src_port,
},
}
}
const fn scanner_kind(self) -> ScannerKind {
match self {
Self::Syn { .. } => ScannerKind::Routed,
Self::Init { .. } => ScannerKind::RoutedSctp,
}
}
fn answers(self, bytes: &[u8]) -> bool {
match self {
Self::Syn { .. } => answers_a_syn_probe(bytes),
Self::Init { .. } => protocol::sctp::parse(bytes)
.ok()
.and_then(|packet| protocol::sctp::classify_probe_response(&packet))
.is_some(),
}
}
fn token_of(self, bytes: &[u8], padding: u16) -> Option<SweepToken> {
match self {
Self::Syn { .. } => protocol::tcp::parse(bytes).ok().map(|tcp| {
SweepToken::Syn(SynToken {
seq: protocol::tcp::echoed_nonce(TcpScanTechnique::Syn, &tcp, padding),
src_port: tcp.destination_port(),
})
}),
Self::Init { .. } => protocol::sctp::parse(bytes)
.ok()
.map(|packet| SweepToken::Init(protocol::sctp::echoed_nonce(&packet))),
}
}
fn evidence(self) -> StatusReason {
match self {
Self::Syn { .. } => {
StatusReason::new(StatusProtocol::TcpSyn, "tcp reply to a discovery probe")
}
Self::Init { .. } => {
StatusReason::new(StatusProtocol::Sctp, "sctp reply to a discovery probe")
}
}
}
}
#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SweepToken {
Syn(SynToken),
Init(u32),
}
pub struct RoutedScanner {
ctx: ScanContext,
sources: HashMap<IpAddr, IpAddr>,
ips: IpSet,
transport: ProbeTransport,
probe: SweepProbe,
emission: Emission,
shaping: SegmentShaping,
decoys: Vec<IpAddr>,
deadline: AdaptiveDeadline,
dns_tx: Option<UnboundedSender<IpAddr>>,
sweep: HostSweep<SweepToken>,
pending: std::vec::IntoIter<IpAddr>,
send_tick: Duration,
batch: usize,
faults: SendFaults,
}
#[async_trait]
impl HostScanner for RoutedScanner {
fn kind(&self) -> ScannerKind {
self.probe.scanner_kind()
}
async fn discover_hosts(&mut self) -> Result<(), StrategyError> {
let mut send_tick = tokio::time::interval(self.send_tick);
send_tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
let reason = loop {
let now = Instant::now();
self.sweep.service_retries(&self.ctx, now);
let all_responded = self.sweep.all_responded(self.ips.len());
if let Some(cause) = self.ctx.handle.stopped() {
break cause.into();
}
if all_responded {
break StopReason::AllResponded;
}
if self.nothing_left_to_send() && self.sweep.ledger.is_empty() {
break StopReason::AttemptsSpent;
}
if self.deadline.hard_deadline_passed() {
break StopReason::DeadlineExpired;
}
let sending = !self.nothing_left_to_send();
let tick = self.sweep.idle_delay(&self.deadline, now);
tokio::select! {
res = self.transport.rx.recv() => {
match res {
Some(reply) => {
self.sweep.audit.record_segment();
self.handle_discovery_reply(reply.source, &reply.bytes, Instant::now());
}
None => break StopReason::StreamClosed,
}
},
_ = send_tick.tick(), if sending => {
self.send_allowance(Instant::now());
}
_ = tokio::time::sleep(tick), if !sending => {}
}
};
let outstanding = self.sweep.ledger.drain_unresolved().len() as u64;
self.ctx
.record_many_outcomes(Outcome::Interrupted, outstanding);
self.ctx
.record_many_outcomes(Outcome::Unasked, self.pending.len() as u64);
self.ctx
.record_many_outcomes(Outcome::Unroutable, self.faults.addresses.len() as u64);
if let Some(reason) = &self.faults.broken {
let broken = self.sweep.audit.sends_failed - self.faults.unroutable_count;
self.ctx.record_failure(
ScannerKind::Routed,
format!(
"{broken} of {} probes could not be sent: {reason}",
self.sweep.audit.sends_attempted,
),
);
}
for address in &self.faults.addresses {
self.ctx.record_unroutable(*address);
}
if let Some((address, _)) = &self.faults.unroutable {
match self.faults.unroutable_count.saturating_sub(1) {
0 => info!("no route to {address}"),
1 => info!("no route to {address} and 1 other address"),
more => info!("no route to {address} and {more} other addresses"),
}
}
let capture = self.transport.capture_counts();
let targets = self.ips.len();
self.sweep.report(
&self.ctx,
"routed-discovery",
ScannerKind::Routed,
targets,
reason,
capture,
);
Ok(())
}
}
impl RoutedScanner {
pub fn new(
targets: Vec<RoutedTarget>,
ctx: ScanContext,
dns_tx: Option<UnboundedSender<IpAddr>>,
tuning: ProbeTuning,
) -> Result<Self, StrategyError> {
Self::asking(
SweepProbe::syn(tuning.evasion.source_port),
targets,
ctx,
dns_tx,
tuning,
)
}
pub fn over_sctp(
targets: Vec<RoutedTarget>,
ctx: ScanContext,
dns_tx: Option<UnboundedSender<IpAddr>>,
tuning: ProbeTuning,
dst_port: u16,
) -> Result<Self, StrategyError> {
let src_port = tuning
.evasion
.source_port
.unwrap_or_else(|| rand::random_range(50_000..u16::MAX));
Self::asking(
SweepProbe::init(src_port, dst_port),
targets,
ctx,
dns_tx,
tuning,
)
}
fn asking(
probe: SweepProbe,
targets: Vec<RoutedTarget>,
ctx: ScanContext,
dns_tx: Option<UnboundedSender<IpAddr>>,
tuning: ProbeTuning,
) -> Result<Self, StrategyError> {
let transport = ProbeTransport::open_with(
probe.transport(),
tuning.evasion.effective_send_mode(tuning.send_mode),
)?;
Ok(Self::build(
targets,
ctx,
dns_tx,
transport,
probe,
tuning.evasion.emission(),
tuning.evasion.segment_shaping(),
tuning.evasion.decoys.clone(),
RETRY_POLICY.configured(tuning.retry),
rate_within(
tuning.max_probe_rate,
tuning.min_probe_rate,
PROBE_RATE_PER_SEC,
),
))
}
pub fn with_transport(
targets: Vec<RoutedTarget>,
ctx: ScanContext,
dns_tx: Option<UnboundedSender<IpAddr>>,
transport: ProbeTransport,
) -> Self {
Self::with_transport_asking(targets, ctx, dns_tx, transport, SweepProbe::syn(None))
}
pub fn with_transport_asking(
targets: Vec<RoutedTarget>,
ctx: ScanContext,
dns_tx: Option<UnboundedSender<IpAddr>>,
transport: ProbeTransport,
probe: SweepProbe,
) -> Self {
Self::build(
targets,
ctx,
dns_tx,
transport,
probe,
Emission::routed(),
SegmentShaping::default(),
Vec::new(),
RETRY_POLICY,
PROBE_RATE_PER_SEC,
)
}
#[allow(clippy::too_many_arguments)]
fn build(
targets: Vec<RoutedTarget>,
ctx: ScanContext,
dns_tx: Option<UnboundedSender<IpAddr>>,
transport: ProbeTransport,
probe: SweepProbe,
emission: Emission,
shaping: SegmentShaping,
decoys: Vec<IpAddr>,
retry: RetryPolicy,
rate_per_sec: NonZeroU32,
) -> Self {
let mut ips = IpSet::new();
let mut order = Vec::with_capacity(targets.len());
let mut sources = HashMap::with_capacity(targets.len());
for RoutedTarget { target, source } in targets {
ips.insert(target);
if sources.insert(target, source).is_none() {
order.push(target);
}
}
ips.canonicalize();
let target_count = sources.len();
let (send_tick, batch) = pacing_for(rate_per_sec);
let send_duration =
Duration::from_secs_f64(target_count as f64 / f64::from(rate_per_sec.get()));
let deadline_config =
DEADLINE_CONFIG.allowing_for(retry.worst_case_probe_lifetime() + send_duration);
Self {
ctx,
sources,
ips,
transport,
probe,
emission,
shaping,
decoys,
deadline: AdaptiveDeadline::new(deadline_config, target_count),
dns_tx,
sweep: HostSweep::new(ProbeLedger::new(retry, target_count)),
pending: order.into_iter(),
send_tick,
batch,
faults: SendFaults::default(),
}
}
fn handle_discovery_reply(&mut self, ip: IpAddr, bytes: &[u8], now: Instant) {
if !self.ips.contains(&ip) {
self.sweep.audit.record_off_target();
return;
}
if !self.probe.answers(bytes) {
self.sweep.audit.record_off_target();
return;
}
self.ctx.settle_address(ip, Settled::Answered);
let resolution = self.resolve_probe(ip, bytes, now);
let rtt = resolution.and_then(|resolution| resolution.rtt);
if rtt.is_none() {
self.sweep.audit.record_reply_without_rtt();
}
let evidence = self.probe.evidence();
self.ctx.write_host(ip, |host| {
let was_up = host.status().is_up();
host.record_evidence(HostStatus::Up, evidence.clone());
if let Some(rtt) = rtt {
host.add_rtt_from(rtt, evidence.protocol.clone());
return true;
}
!was_up
});
if self.sweep.responded.insert(ip) {
self.sweep
.audit
.record_host_found(resolution.and_then(|resolution| resolution.answered_attempt));
self.deadline.mark_activity();
if let Some(dns) = &self.dns_tx {
let _ = dns.send(ip);
}
}
if let Some(rtt) = rtt {
self.deadline.record_rtt(rtt);
}
}
fn resolve_probe(&mut self, ip: IpAddr, bytes: &[u8], now: Instant) -> Option<Resolution> {
let token = self
.probe
.token_of(bytes, self.shaping.padding.unwrap_or(0));
token
.and_then(|token| self.sweep.ledger.resolve(&ip, Some(token), now))
.or_else(|| self.sweep.ledger.resolve(&ip, None, now))
}
fn nothing_left_to_send(&self) -> bool {
self.sweep.retries.is_empty() && self.pending.len() == 0
}
fn send_allowance(&mut self, now: Instant) {
for _ in 0..self.batch {
let queued = match self.sweep.retries.pop_front() {
Some(target) if self.ctx.host_ready_at(target, now).is_none() => Some(target),
Some(target) => {
self.sweep.retries.push_back(target);
None
}
None => None,
};
let Some(target) = queued.or_else(|| self.pending.next()) else {
return;
};
self.probe(target, now);
}
}
fn probe(&mut self, target: IpAddr, now: Instant) {
let Some(&source) = self.sources.get(&target) else {
return;
};
let token = match self.probe {
SweepProbe::Syn { src_port, dst_port } => send_syn(
self.transport.tx.as_ref(),
source,
target,
None,
dst_port,
src_port,
EvasionParts {
emission: self.emission,
shaping: self.shaping,
decoys: &self.decoys,
},
&mut self.faults,
)
.map(SweepToken::Syn),
SweepProbe::Init { src_port, dst_port } => send_init(
self.transport.tx.as_ref(),
source,
target,
None,
dst_port,
src_port,
&self.decoys,
self.emission,
&mut self.faults,
)
.map(SweepToken::Init),
};
self.sweep.audit.record_send(token.is_some());
if let Some(token) = token {
self.ctx.host_probed(target, now);
self.sweep.ledger.arm(target, target, token, (), now);
}
}
}