use std::time::{Instant, SystemTime};
use crate::config::ZondConfig;
use crate::report::{PhaseParts, ScanKind, ScanPhase, ScanReport, ScanSettings, TargetScope};
use crate::scanner::session::ScanContext;
use crate::system::privilege::Privilege;
pub struct PhaseRecorder {
kind: ScanKind,
started_at: SystemTime,
started: Instant,
privilege: Privilege,
targets: TargetScope,
settings: ScanSettings,
}
impl PhaseRecorder {
pub fn start(
kind: ScanKind,
privilege: Privilege,
targets: TargetScope,
cfg: &ZondConfig,
) -> Self {
Self {
kind,
started_at: SystemTime::now(),
started: Instant::now(),
privilege,
targets,
settings: ScanSettings::from(cfg),
}
}
pub fn finish(self, ctx: &ScanContext) -> ScanReport {
let mut targets = self.targets;
targets.record_sweeps(ctx.take_swept_links());
let phase = ScanPhase::from_parts(PhaseParts {
kind: self.kind,
started_at: self.started_at,
elapsed: self.started.elapsed(),
privilege: Some(self.privilege),
targets,
settings: self.settings,
failures: ctx.take_failures(),
refusals: ctx.take_refusals(),
unroutable: ctx.take_unroutable(),
timed_out: ctx.take_timed_out(),
probes: ctx.take_probe_stats(),
origin: None,
attachments: ctx.take_attachments(),
});
let hosts = ctx.store.iter().map(|entry| entry.value().clone());
ScanReport::new(phase, hosts)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::model::exclusion::Exclusions;
use crate::model::host::HostStatus;
use crate::model::ip::set::IpSet;
use crate::report::{BUCKET_BOUNDS_MS, ProbeStats, Refusal, ScannerKind, StopReason};
use crate::scanner::session::ScanSession;
fn scope() -> TargetScope {
let mut targets = IpSet::from_str("192.168.0.1-192.168.0.2").expect("a valid range");
TargetScope::from_ip_set(&mut targets, &Exclusions::none())
}
#[test]
fn a_refusal_reaches_the_report_as_a_refusal_and_not_as_a_failure() {
let cfg = ZondConfig::default();
let (_session, ctx) = ScanSession::new();
let recorder = PhaseRecorder::start(ScanKind::PortScan, Privilege::Connect, scope(), &cfg);
ctx.record_refusal(Refusal::new(
ScannerKind::SctpPort,
"no unprivileged init probe exists",
));
ctx.record_failure(ScannerKind::Local, "the capture would not open".to_string());
let report = recorder.finish(&ctx);
let phase = &report.phases()[0];
assert_eq!(phase.refusals().len(), 1, "the refusal is its own kind");
assert_eq!(phase.refusals()[0].scanner(), ScannerKind::SctpPort);
assert_eq!(
phase.failures().len(),
1,
"and the failure is still a failure"
);
assert_eq!(phase.failures()[0].scanner(), ScannerKind::Local);
}
#[test]
fn a_phase_takes_its_refusals_rather_than_copying_them() {
let cfg = ZondConfig::default();
let (_session, ctx) = ScanSession::new();
ctx.record_refusal(Refusal::new(ScannerKind::SctpPort, "no init probe"));
let first = PhaseRecorder::start(ScanKind::Discovery, Privilege::Connect, scope(), &cfg)
.finish(&ctx);
let second = PhaseRecorder::start(ScanKind::PortScan, Privilege::Connect, scope(), &cfg)
.finish(&ctx);
assert_eq!(first.phases()[0].refusals().len(), 1);
assert!(second.phases()[0].refusals().is_empty());
}
#[test]
fn the_same_refusal_filed_twice_is_recorded_once() {
let (_session, ctx) = ScanSession::new();
let refusal = Refusal::new(ScannerKind::Local, "too large to walk");
ctx.record_refusal(refusal.clone());
ctx.record_refusal(refusal);
assert_eq!(ctx.refusals_snapshot().len(), 1);
}
use std::net::{IpAddr, Ipv4Addr};
use std::str::FromStr;
use std::time::Duration;
fn ip(last: u8) -> IpAddr {
IpAddr::V4(Ipv4Addr::new(192, 168, 0, last))
}
#[test]
fn an_unroutable_address_is_recorded_without_making_the_scan_partial() {
let cfg = ZondConfig::default();
let (_session, ctx) = crate::scanner::session::ScanSession::new();
let mut targets = IpSet::from_str("192.168.0.1-192.168.0.2").expect("a valid range");
let scope = TargetScope::from_ip_set(&mut targets, &Exclusions::none());
let recorder = PhaseRecorder::start(ScanKind::Discovery, Privilege::Connect, scope, &cfg);
let unreachable: IpAddr = "2001:db8::1".parse().expect("literal");
ctx.record_unroutable(unreachable);
ctx.record_unroutable(unreachable);
let report = recorder.finish(&ctx);
assert_eq!(report.phases()[0].unroutable(), [unreachable]);
assert!(
!report.is_partial(),
"no strategy failed; that address is simply not reachable from here"
);
assert_eq!(report.failures().count(), 0);
}
#[test]
fn a_self_orchestrated_scan_can_close_its_own_phase() {
let cfg = ZondConfig::default();
let (_session, ctx) = crate::scanner::session::ScanSession::new();
let mut targets = IpSet::from_str("192.168.0.1-192.168.0.4").expect("a valid range");
let scope = TargetScope::from_ip_set(&mut targets, &Exclusions::none());
let recorder = PhaseRecorder::start(ScanKind::Discovery, Privilege::Connect, scope, &cfg);
ctx.update_host(ip(1), |host| host.set_status(HostStatus::Up));
ctx.record_failure(ScannerKind::Local, "eth0: no address".into());
let report = recorder.finish(&ctx);
assert_eq!(report.host_count(), 1);
assert_eq!(report.phases()[0].targets().addresses(), 4);
assert!(report.is_partial(), "the failure has to reach the record");
assert_eq!(report.failures().count(), 1);
}
#[test]
fn probe_stats_filed_during_a_scan_land_in_its_phase() {
let (_session, ctx) = crate::scanner::session::ScanSession::new();
let recorder = PhaseRecorder::start(
ScanKind::Discovery,
Privilege::Raw,
TargetScope::from_ip_set(&mut IpSet::new(), &Exclusions::none()),
&ZondConfig::default(),
);
ctx.record_probe_stats(ProbeStats {
window: None,
scanner: ScannerKind::Routed,
targets: 256,
stop_reason: StopReason::AllResponded,
elapsed: Duration::from_millis(40),
sends_attempted: 300,
sends_failed: 0,
sends_witnessed: 0,
segments_seen: 250,
segments_off_target: 1,
replies_without_rtt: 2,
hosts_found: 9,
answered_on: [7, 2, 0, 0, 0, 0],
answered_unattributed: 0,
first_reply: Some(Duration::from_millis(1)),
last_reply: Some(Duration::from_millis(30)),
found_at: [0; BUCKET_BOUNDS_MS.len() + 1],
capture: None,
});
let report = recorder.finish(&ctx);
let stats = report.phases()[0].probe_stats();
assert_eq!(stats.len(), 1);
assert_eq!(stats[0].scanner(), ScannerKind::Routed);
assert_eq!(stats[0].hosts_found(), 9);
assert_eq!(stats[0].answered_on()[1], 2);
assert_eq!(report.probe_stats().count(), 1);
assert!(ctx.take_probe_stats().is_empty());
}
}