use std::net::IpAddr;
use std::time::{Duration, Instant};
use tokio::sync::mpsc;
use crate::model::host::{HostStatus, StatusProtocol, StatusReason};
use crate::model::port::{PortState, Protocol};
use crate::model::target::Target;
use crate::scanner::audit::ProbeAudit;
use crate::scanner::pacing::deadline::AdaptiveDeadline;
use crate::scanner::pacing::retry::{Due, ProbeLedger};
use crate::scanner::report::StopReason;
use crate::scanner::session::{ScanContext, ScannerKind};
use crate::scanner::strategy::PortScanner;
use crate::system::interface::SourceResolver;
use crate::transport::capture::CapturedSegment;
use crate::transport::probe::ProbeTransport;
pub type ProbeTarget = (IpAddr, u16);
pub struct RawProbeScan<T> {
pub resolver: SourceResolver,
pub ctx: ScanContext,
pub transport: ProbeTransport,
pub deadline: AdaptiveDeadline,
pub ledger: ProbeLedger<ProbeTarget, T>,
pub due: Vec<Due<ProbeTarget>>,
pub src_port: u16,
pub send_failure: Option<String>,
pub audit: ProbeAudit,
pub max_in_flight: usize,
}
impl<T: Copy + PartialEq> RawProbeScan<T> {
pub fn stop_reason(&self, sending_finished: bool) -> Option<StopReason> {
if self.ctx.handle.should_stop() {
return Some(StopReason::Aborted);
}
if self.deadline.hard_deadline_passed() {
return Some(StopReason::DeadlineExpired);
}
if sending_finished && self.ledger.is_empty() {
return Some(StopReason::AttemptsSpent);
}
if self.ledger.is_empty() && self.deadline.has_expired() {
return Some(StopReason::DeadlineExpired);
}
None
}
pub fn admitting(&self, sending_finished: bool) -> bool {
!sending_finished && self.ledger.len() < self.max_in_flight
}
pub fn tick_delay(&self, now: Instant) -> Duration {
let until_deadline_tick = self.deadline.time_until_next_tick();
match self.ledger.next_due() {
Some(due) => until_deadline_tick.min(due.saturating_duration_since(now)),
None => until_deadline_tick,
}
}
pub fn record_host_down(&mut self, ip: IpAddr, sender: IpAddr) {
self.ctx.update_host(ip, |host| {
host.record_evidence(
HostStatus::Down,
StatusReason::new(StatusProtocol::IcmpUnreachable, "destination unreachable")
.from_source(sender),
);
});
}
pub fn finish(
&mut self,
kind: ScannerKind,
audit_tag: &str,
silence_verdict: &str,
probes: u128,
reason: StopReason,
) {
if self.audit.sends_failed > 0 {
self.ctx.record_failure(
kind,
format!(
"{} probes could not be sent, so their ports are reported \
{silence_verdict} without having been asked: {}",
self.audit.sends_failed,
self.send_failure.as_deref().unwrap_or("cause unrecorded"),
),
);
}
let capture = self.transport.capture_counts();
self.audit.report(audit_tag, probes, reason, capture);
self.ctx
.record_probe_stats(self.audit.stats(kind, probes, reason, capture));
}
}
pub trait RawPortScan: PortScanner {
type Token: Copy + PartialEq;
fn core(&self) -> &RawProbeScan<Self::Token>;
fn core_mut(&mut self) -> &mut RawProbeScan<Self::Token>;
fn protocol(&self) -> Protocol;
fn silence_means(&self) -> PortState;
fn audit_labels(&self) -> AuditLabels;
fn probe(&mut self, ip: IpAddr, port: u16, now: Instant);
fn handle_reply(&mut self, reply: &CapturedSegment, now: Instant);
fn record_port(&mut self, ip: IpAddr, port: u16, state: PortState, sender: Option<IpAddr>);
fn send_probe(&mut self, target: Target) {
if target.protocol == self.protocol() {
self.probe(target.ip, target.port, Instant::now());
}
}
fn service_retries(&mut self, now: Instant) {
let core = self.core_mut();
core.ledger.drain_due(now, &mut core.due);
let due = std::mem::take(&mut self.core_mut().due);
let silence = self.silence_means();
for event in &due {
match *event {
Due::Retry {
key: (ip, port), ..
} => self.probe(ip, port, now),
Due::Exhausted((ip, port)) => self.record_port(ip, port, silence, None),
}
}
let core = self.core_mut();
core.due = due;
core.due.clear();
}
fn resolve_remaining(&mut self) {
let silence = self.silence_means();
for (ip, port) in self.core_mut().ledger.drain_unresolved() {
self.record_port(ip, port, silence, None);
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct AuditLabels {
pub tag: &'static str,
pub silence: &'static str,
}
pub async fn run<S: RawPortScan>(scanner: &mut S, mut targets: mpsc::Receiver<Target>) {
let mut sending_finished = false;
let mut probes = 0u128;
let reason = loop {
let now = Instant::now();
scanner.service_retries(now);
if let Some(reason) = scanner.core().stop_reason(sending_finished) {
break reason;
}
let admitting = scanner.core().admitting(sending_finished);
let tick = scanner.core().tick_delay(now);
tokio::select! {
target = targets.recv(), if admitting => {
match target {
Some(target) => {
probes += 1;
scanner.send_probe(target);
}
None => sending_finished = true,
}
}
res = scanner.core_mut().transport.rx.recv() => {
match res {
Some(reply) => {
scanner.core_mut().audit.record_segment();
scanner.handle_reply(&reply, Instant::now());
}
None => break StopReason::StreamClosed,
}
}
_ = tokio::time::sleep(tick) => {}
}
};
scanner.resolve_remaining();
let kind = scanner.kind();
let labels = scanner.audit_labels();
scanner
.core_mut()
.finish(kind, labels.tag, labels.silence, probes, reason);
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::Ipv4Addr;
use crate::scanner::session::ScanSession;
use crate::transport::probe::{ProbeSender, ProbeTransport, SendError};
#[derive(Default)]
struct NullSender;
impl ProbeSender for NullSender {
fn send(&self, _segment: &[u8], _src: IpAddr, _dst: IpAddr) -> Result<(), SendError> {
Ok(())
}
}
const TARGET: IpAddr = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 10));
fn core() -> (RawProbeScan<()>, ScanSession) {
let (session, ctx) = ScanSession::new();
let (_tx, rx) = tokio::sync::mpsc::unbounded_channel();
let core = RawProbeScan {
resolver: SourceResolver::from_interfaces(&[]),
ctx,
transport: ProbeTransport::from_parts(Box::new(NullSender), rx),
deadline: AdaptiveDeadline::new(super::super::DEADLINE_CONFIG, 8),
ledger: ProbeLedger::new(super::super::RETRY_POLICY, 8),
due: Vec::new(),
src_port: 54_321,
send_failure: None,
audit: ProbeAudit::new(),
max_in_flight: 4,
};
(core, session)
}
#[test]
fn an_empty_ledger_does_not_end_a_scan_that_still_has_targets_coming() {
let (core, _session) = core();
assert_eq!(
core.stop_reason(false),
None,
"the target stream is still open, so nothing has been concluded"
);
assert_eq!(
core.stop_reason(true),
Some(StopReason::AttemptsSpent),
"with the stream done and nothing outstanding, waiting cannot help"
);
}
#[test]
fn an_outstanding_probe_holds_the_scan_open_past_a_dry_target_stream() {
let (mut core, _session) = core();
core.ledger.arm(TARGET, (TARGET, 80), (), Instant::now());
assert_eq!(
core.stop_reason(true),
None,
"a probe is still within its retry schedule"
);
}
#[test]
fn an_abort_outranks_every_other_reason() {
let (mut core, _session) = core();
core.ledger.arm(TARGET, (TARGET, 80), (), Instant::now());
core.ctx.handle.abort();
assert_eq!(core.stop_reason(false), Some(StopReason::Aborted));
}
#[test]
fn the_ledger_stops_admitting_at_the_ceiling() {
let (mut core, _session) = core();
assert!(core.admitting(false), "an empty ledger admits");
let now = Instant::now();
for port in 0..core.max_in_flight as u16 {
core.ledger.arm(TARGET, (TARGET, port), (), now);
}
assert!(
!core.admitting(false),
"admitting past the ceiling grows correlation state for nothing"
);
assert!(
!core.admitting(true),
"a finished stream never admits, ceiling or not"
);
}
}