use std::pin::Pin;
use tokio::task::JoinHandle;
use crate::config::ZondConfig;
use crate::detect::Detections;
use crate::journal::cursor::Checkpoint;
use crate::model::{
ip::scoped::Zone,
ip::set::{IpSet, Positions},
port::PortSet,
target::{TargetIndex, TargetMap},
};
#[cfg(feature = "journal-format")]
use crate::report::ScanPhase;
use crate::report::ScannerKind;
use crate::report::{LivenessSkip, ScanKind, ScanReport, TargetScope};
use crate::scanner::orchestrator::{
Enrichment, ScanCapabilities, finish_enrichment, probed_subset, run_port_phase,
};
use crate::scanner::recorder::PhaseRecorder;
use crate::scanner::session::{ScanContext, ScanSession, Stage};
use crate::system::interface;
use crate::system::privilege::Privilege;
use strategy::local::Scope;
use strategy::routed::SynPorts;
pub mod handle;
pub mod recorder;
pub mod session;
pub mod plan;
pub mod strategy;
#[cfg(feature = "journal-format")]
pub mod checkpoint;
pub mod detection;
pub mod dispatcher;
pub mod rdns;
pub mod service;
pub(crate) mod audit;
pub(crate) mod pacing;
pub(crate) mod payload;
pub(crate) mod pool;
mod orchestrator;
mod vantage;
#[non_exhaustive]
#[derive(Debug, thiserror::Error)]
pub enum ScanError {
#[error("the scan task {}: {detail}", if *.panicked { "panicked" } else { "was cancelled" })]
TaskFailed {
panicked: bool,
detail: String,
},
#[error("this journal records the other phase of a scan")]
WrongPhase,
#[cfg(feature = "journal-format")]
#[error("{0}")]
PlanChanged(#[from] crate::journal::manifest::PlanChanged),
#[cfg(feature = "journal-format")]
#[error("{0}")]
OptionChanged(#[from] crate::journal::manifest::OptionChanged),
#[error("{0}")]
Evasion(#[from] crate::evasion::EvasionError),
#[error("file descriptor limit {limit} is below the {needed} a scan needs")]
TooFewDescriptors {
limit: usize,
needed: usize,
},
}
#[cfg(feature = "journal-format")]
fn accepted(
journal: crate::journal::Journal,
checks: impl FnOnce(&crate::journal::Journal) -> Result<(), ScanError>,
) -> Result<crate::journal::Journal, ScanError> {
match checks(&journal) {
Ok(()) => Ok(journal),
Err(refused) => {
journal.withdraw();
Err(refused)
}
}
}
#[cfg(feature = "journal-format")]
fn under_the_recorded_options(
journal: &crate::journal::Journal,
cfg: &ZondConfig,
) -> Result<(), ScanError> {
match journal.options() {
Some(options) => Ok(options.check(cfg)?),
None => Ok(()),
}
}
#[cfg(feature = "journal-format")]
fn under_the_recorded_technique(journal: &crate::journal::Journal, cfg: &ZondConfig) -> ZondConfig {
let recorded = journal.manifest().technique();
if journal.options().is_some() || recorded == cfg.tcp_technique {
return cfg.clone();
}
crate::info!(
verbosity = 1,
"{recorded} scan, as the job recorded (not {})",
cfg.tcp_technique
);
ZondConfig {
tcp_technique: recorded,
..cfg.clone()
}
}
#[cfg(feature = "journal-format")]
fn recording_options(
mut journal: crate::journal::Journal,
cfg: &ZondConfig,
) -> crate::journal::Journal {
use crate::journal::manifest::JobOptions;
if let Err(e) = journal.record_options(JobOptions::of(cfg)) {
crate::warn!("options not recorded ({e})");
}
journal
}
fn capture_plan(addresses: &IpSet, cfg: &ZondConfig) -> Result<Vec<Zone>, ScanError> {
let mut addresses = addresses.clone();
cfg.exclusions.withhold(&mut addresses);
let links = crate::transport::probe::capture_links_toward(&addresses, &cfg.send_source);
enough_descriptors(captures_needed(Privilege::current(), &links))?;
Ok(links)
}
fn captures_needed(privilege: Privilege, links: &[Zone]) -> usize {
match privilege.is_raw() {
true => links.len(),
false => 0,
}
}
fn enough_descriptors(captures: usize) -> Result<(), ScanError> {
match crate::system::descriptors::too_few(captures) {
Some((limit, needed)) => Err(ScanError::TooFewDescriptors { limit, needed }),
None => Ok(()),
}
}
fn plan_addresses(target_map: &TargetMap) -> IpSet {
orchestrator::unsettled_ips(target_map, &Checkpoint::default())
}
#[cfg(feature = "journal-format")]
fn counted_as_recorded(
journal: &crate::journal::Journal,
this_run: &crate::journal::manifest::Plan,
) -> Result<(), ScanError> {
journal.manifest().covers(this_run, Privilege::current())?;
Ok(())
}
fn panic_or_cancellation(error: tokio::task::JoinError) -> ScanError {
if !error.is_panic() {
return ScanError::TaskFailed {
panicked: false,
detail: "the runtime shut down before the scan finished".to_string(),
};
}
let payload = error.into_panic();
let detail = payload
.downcast_ref::<&'static str>()
.map(|message| (*message).to_string())
.or_else(|| payload.downcast_ref::<String>().cloned())
.unwrap_or_else(|| "a panic carrying no message".to_string());
ScanError::TaskFailed {
panicked: true,
detail,
}
}
pub struct ScanTask {
handle: Option<JoinHandle<ScanReport>>,
stop: handle::ScanHandle,
#[cfg(feature = "journal-format")]
journal: Option<checkpoint::Checkpointing>,
#[cfg(feature = "journal-format")]
earlier: Vec<ScanPhase>,
}
impl ScanTask {
fn new(handle: JoinHandle<ScanReport>, stop: handle::ScanHandle) -> Self {
Self {
handle: Some(handle),
stop,
#[cfg(feature = "journal-format")]
journal: None,
#[cfg(feature = "journal-format")]
earlier: Vec::new(),
}
}
#[cfg(feature = "journal-format")]
fn journalling(
handle: JoinHandle<ScanReport>,
stop: handle::ScanHandle,
journal: checkpoint::Checkpointing,
earlier: Vec<ScanPhase>,
) -> Self {
Self {
handle: Some(handle),
stop,
journal: Some(journal),
earlier,
}
}
pub async fn join(mut self) -> Result<ScanReport, ScanError> {
let running = self.handle.as_mut().expect("a task is joined at most once");
let report = running.await.map_err(panic_or_cancellation);
self.handle = None;
#[cfg(feature = "journal-format")]
if let Some(journal) = self.journal.take() {
let phases = report.as_ref().map(ScanReport::phases).unwrap_or_default();
journal.finish(phases).await;
}
#[cfg(feature = "journal-format")]
if !self.earlier.is_empty() {
let earlier = std::mem::take(&mut self.earlier);
return report.map(|report| {
let mut whole = ScanReport::from_phases(earlier, []);
whole.merge(report);
whole
});
}
report
}
}
impl Drop for ScanTask {
fn drop(&mut self) {
let Some(scan) = self.handle.take() else {
return;
};
self.stop.abort();
#[cfg(feature = "journal-format")]
if let Some(journal) = self.journal.take()
&& let Ok(runtime) = tokio::runtime::Handle::try_current()
{
runtime.spawn(async move {
let phases = match scan.await {
Ok(report) => report.phases().to_vec(),
Err(_) => Vec::new(),
};
journal.finish(&phases).await;
});
}
#[cfg(not(feature = "journal-format"))]
drop(scan);
}
}
impl IntoFuture for ScanTask {
type Output = Result<ScanReport, ScanError>;
type IntoFuture = Pin<Box<dyn Future<Output = Self::Output> + Send>>;
fn into_future(self) -> Self::IntoFuture {
Box::pin(self.join())
}
}
pub async fn discover(
targets: IpSet,
cfg: &ZondConfig,
) -> Result<(ScanSession, ScanTask), ScanError> {
cfg.evasion.validate()?;
let capture_links = capture_plan(&targets, cfg)?;
let mut numbered = targets.clone();
cfg.exclusions.withhold(&mut numbered);
numbered.canonicalize();
let positions = numbered.positions();
let planned = planned_addresses(&positions);
let (session, ctx) = ScanSession::builder()
.excluding(cfg.exclusions.clone())
.naming(cfg.target_names.clone())
.host_timeout(cfg.host_timeout)
.scan_timeout(cfg.scan_timeout)
.host_probe_interval(cfg.host_probe_interval)
.send_source(cfg.send_source.clone())
.listening_only_to(cfg.listen_only_ports.clone())
.counting(positions)
.planning(Stage::Discovery, planned)
.staging(discovery_stages(cfg))
.build();
let handle = spawn_discovery(targets, capture_links, cfg, ctx);
let stop = session.handle().clone();
Ok((session, ScanTask::new(handle, stop)))
}
#[cfg(feature = "journal-format")]
pub async fn discover_with_journal(
targets: IpSet,
cfg: &ZondConfig,
journal: crate::journal::Journal,
) -> Result<(ScanSession, ScanTask), ScanError> {
let mut capture_links = Vec::new();
let journal = accepted(journal, |journal| {
cfg.evasion.validate()?;
if journal.manifest().kind() != ScanKind::Discovery {
return Err(ScanError::WrongPhase);
}
let recorded = journal.manifest().recorded();
let Some(addresses) = recorded.addresses() else {
return Err(ScanError::WrongPhase);
};
let swept = if *journal.resume_point() == Checkpoint::default() {
&targets
} else {
addresses
};
capture_links = capture_plan(swept, cfg)?;
let this_run = crate::journal::manifest::Plan::discovery(
swept,
&cfg.exclusions,
recorded.sweeps_the_segment(),
);
counted_as_recorded(journal, &this_run)?;
under_the_recorded_options(journal, cfg)
})?;
let journal = recording_options(journal, cfg);
let recorded = journal.manifest().recorded();
let Some(addresses) = recorded.addresses() else {
return Err(ScanError::WrongPhase);
};
let positions = addresses.positions();
let resume_point = journal.resume_point().clone();
let order_seed = journal.manifest().order_seed;
let sweep = if resume_point == Checkpoint::default() {
targets
} else {
resume_point.remaining_addresses(&positions)
};
let planned = planned_addresses(&positions);
let finished = journal.finished_hosts().unwrap_or_else(|e| {
crate::warn!("passes rerun for every host ({e})");
Default::default()
});
let (session, ctx) = ScanSession::builder()
.excluding(cfg.exclusions.clone())
.naming(cfg.target_names.clone())
.host_timeout(cfg.host_timeout)
.scan_timeout(cfg.scan_timeout)
.host_probe_interval(cfg.host_probe_interval)
.send_source(cfg.send_source.clone())
.listening_only_to(cfg.listen_only_ports.clone())
.resuming(&resume_point)
.finished(finished, sweep.clone())
.counting(positions)
.planning(Stage::Discovery, planned)
.staging(discovery_stages(cfg))
.ordering(order_seed)
.build();
ctx.restore_hosts(journal.restored());
let earlier = journal.earlier_phases().to_vec();
let ticker = checkpoint::spawn_checkpoints(journal, ctx.progress());
let handle = spawn_discovery(sweep, capture_links, cfg, ctx);
let stop = session.handle().clone();
Ok((
session,
ScanTask::journalling(handle, stop, ticker, earlier),
))
}
fn planned_addresses(positions: &Positions) -> Option<u64> {
positions.unnumbered().is_empty().then(|| positions.total())
}
fn discovery_stages(cfg: &ZondConfig) -> Vec<Stage> {
let mut stages = vec![Stage::Discovery];
if cfg.os_detection.is_active() {
stages.push(Stage::Os);
}
if cfg.traceroute {
stages.push(Stage::Traceroute);
}
if cfg.characterise {
stages.push(Stage::Filters);
}
if !cfg.ip_protocols.is_empty() {
stages.push(Stage::IpProtocols);
}
stages
}
fn scan_stages(cfg: &ZondConfig, runs_liveness: bool) -> Vec<Stage> {
let cfg = &running_under(cfg);
let mut stages = Vec::new();
if runs_liveness {
stages.push(Stage::Discovery);
}
stages.push(Stage::Ports);
if cfg.service_detection.connects() {
stages.push(Stage::Services);
}
if cfg.service_detection != crate::config::ServiceDetection::Off
&& cfg.detection.ceiling().is_some()
{
stages.push(Stage::Detections);
}
if cfg.tls_enumeration {
stages.push(Stage::Tls);
}
if cfg.os_detection.is_active() {
stages.push(Stage::Os);
}
if cfg.traceroute {
stages.push(Stage::Traceroute);
}
if cfg.characterise {
stages.push(Stage::Filters);
}
if !cfg.ip_protocols.is_empty() {
stages.push(Stage::IpProtocols);
}
stages
}
fn asks_liveness(cfg: &ZondConfig) -> bool {
!cfg.assume_up && cfg.idle_scan.is_none()
}
fn liveness_earns_its_place(cfg: &ZondConfig, map: &TargetMap) -> bool {
use crate::model::port::Protocol;
if !asks_liveness(cfg) {
return false;
}
let asked = SynPorts::for_scan(&tcp_ports_of(map))
.excluding(&cfg.excluded_ports)
.len()
+ usize::from(orchestrator::sctp_discovery_port(map).is_some());
if asked == 0 {
return false;
}
if !cfg.tcp_technique.has_connect_fallback() {
return true;
}
if map.names(Protocol::Udp) {
return true;
}
let per_address = map
.units
.iter()
.map(crate::model::target::TargetSet::port_count)
.max()
.unwrap_or(0);
if per_address > asked {
return true;
}
reaches_a_local_segment(cfg, map)
}
fn liveness_skip(cfg: &ZondConfig, runs_liveness: bool) -> Option<LivenessSkip> {
if runs_liveness {
None
} else if cfg.idle_scan.is_some() {
Some(LivenessSkip::IdleScan)
} else if cfg.assume_up {
Some(LivenessSkip::AssumeUp)
} else {
Some(LivenessSkip::PortsNoDearer)
}
}
const ON_LINK_CHECK_CEILING: u128 = 1 << 13;
fn reaches_a_local_segment(cfg: &ZondConfig, map: &TargetMap) -> bool {
match map.gross_ips() {
Ok(count) if count <= ON_LINK_CHECK_CEILING => {}
_ => return false,
}
let mut ips = IpSet::new();
for unit in &map.units {
for range in unit.ips().v4() {
ips.push_v4_range(*range);
}
for range in unit.ips().v6() {
ips.push_v6_range(*range);
}
}
ips.canonicalize();
let plan = plan::DiscoveryPlan::build(ips, Scope::Targeted, &cfg.exclusions, &cfg.send_source);
plan.steps()
.iter()
.any(|step| matches!(step, plan::DiscoveryStep::Local { .. }))
}
fn running_under(cfg: &ZondConfig) -> ZondConfig {
if cfg.idle_scan.is_none() {
return cfg.clone();
}
let mut muted = cfg.clone();
muted.service_detection = crate::config::ServiceDetection::Off;
if muted.detection.ceiling() > Some(crate::model::finding::DetectionClass::Passive) {
muted.detection =
crate::config::DetectionEnvelope::up_to(crate::model::finding::DetectionClass::Passive);
}
if muted.os_detection.is_active() {
muted.os_detection = crate::config::OsDetection::Passive;
}
muted.traceroute = false;
muted.characterise = false;
muted.ip_protocols.clear();
muted.tls_enumeration = false;
muted
}
fn record_idle_refusals(cfg: &ZondConfig, ctx: &ScanContext) {
use crate::model::finding::DetectionClass;
use crate::report::ScannerKind;
use plan::RefusedStep;
if cfg.idle_scan.is_none() {
return;
}
if cfg.service_detection.connects() {
crate::info!(verbosity = 1, "service detection skipped (idle scan)");
}
if cfg.detection.ceiling() > Some(DetectionClass::Passive) {
ctx.record_refusal(
RefusedStep::pass_not_in_an_idle_scan(ScannerKind::Detection, "active detection")
.into(),
);
}
if cfg.os_detection.is_active() {
ctx.record_refusal(
RefusedStep::pass_not_in_an_idle_scan(ScannerKind::OsSeries, "OS probing").into(),
);
}
if cfg.traceroute {
ctx.record_refusal(
RefusedStep::pass_not_in_an_idle_scan(ScannerKind::Routed, "route trace").into(),
);
}
if cfg.characterise {
ctx.record_refusal(
RefusedStep::pass_not_in_an_idle_scan(ScannerKind::Routed, "filter characterisation")
.into(),
);
}
if !cfg.ip_protocols.is_empty() {
ctx.record_refusal(
RefusedStep::pass_not_in_an_idle_scan(ScannerKind::Routed, "IP-protocol probe").into(),
);
}
if cfg.tls_enumeration {
ctx.record_refusal(
RefusedStep::pass_not_in_an_idle_scan(ScannerKind::Service, "TLS enumeration").into(),
);
}
}
fn planned_targets(map: &TargetMap) -> Option<u64> {
let index = TargetIndex::of(map);
index.is_complete().then(|| index.total())
}
fn spawn_discovery(
mut targets: IpSet,
capture_links: Vec<Zone>,
cfg: &ZondConfig,
ctx: ScanContext,
) -> JoinHandle<ScanReport> {
let sends = !targets.is_empty() || cfg.segment_sweep;
let caps = ScanCapabilities::resolve(
cfg,
sends.then(orchestrator::Probing::sweep),
&targets,
interface::FrameSender::Sweep,
);
let scope = address_scope(&mut targets, &ctx);
let recorder =
PhaseRecorder::start(ScanKind::Discovery, caps.privilege, scope, cfg).opening_in(&ctx);
let reach = if cfg.segment_sweep {
Scope::Sweep
} else {
Scope::Targeted
};
let cfg = cfg.clone();
let held_back = crate::system::descriptors::hold_back();
tokio::spawn(async move {
let _held_back = held_back;
ctx.capture_on(capture_links);
ctx.enter_stage(Stage::Discovery, None);
run_discovery(targets, reach, caps, &cfg, &ctx, SynPorts::common(), None).await;
orchestrator::run_active_os_probe(&ctx, cfg.os_detection, cfg.probe_tuning(), caps).await;
orchestrator::run_traceroute(&ctx, &cfg, caps).await;
orchestrator::run_characterise(&ctx, &cfg, caps).await;
orchestrator::run_ip_protocols(&ctx, &cfg).await;
ctx.enter_stage(Stage::Finishing, None);
vantage::attribute(&ctx);
orchestrator::correlate(&ctx, cfg.service_detection).await;
recorder.finish_last(ctx)
})
}
fn machine_policy(ctx: &ScanContext) -> crate::model::exclusion::Exclusions {
ctx.exclusions.widened(ctx.withheld_by_hardware())
}
fn address_scope(targets: &mut IpSet, ctx: &ScanContext) -> TargetScope {
let tied = ctx.withheld_by_hardware();
for address in &tied {
if targets.contains(address) {
ctx.settle_withheld(*address);
}
}
TargetScope::from_ip_set(targets, &ctx.exclusions.widened(tied))
}
async fn run_discovery(
targets: IpSet,
reach: Scope,
caps: ScanCapabilities,
cfg: &ZondConfig,
ctx: &ScanContext,
syn_ports: SynPorts,
sctp_port: Option<u16>,
) {
let syn_ports = syn_ports.excluding(&cfg.excluded_ports);
if caps.privilege.is_raw() {
let unframed =
caps.beyond_frames(&targets, &cfg.send_source, interface::FrameSender::Sweep);
let mut plan =
plan::DiscoveryPlan::build(targets, reach, &cfg.exclusions, &cfg.send_source);
plan.connect_instead(&unframed.targets);
plan.asking_tcp(syn_ports);
for address in plan.refused_by_route().iter() {
ctx.note_refused_by_route(address);
}
for address in plan.withheld().iter() {
ctx.note_withheld_neighbour(address);
}
if let Some(port) = sctp_port {
plan.also_over_sctp(port);
}
orchestrator::reached_by_connect(&plan, unframed, ctx);
let enrichment = Enrichment::spawn(plan, ctx, caps, cfg.probe_tuning()).await;
finish_enrichment(Some(enrichment), caps, ctx, rdns::Unheard::Skipped).await;
} else {
let targets = orchestrator::walkable(targets, ctx);
if syn_ports.is_empty() {
ctx.record_refusal(
plan::RefusedStep::every_discovery_port_excluded(ScannerKind::Connect).into(),
);
} else if let Err(error) =
strategy::connect::discover_on(targets, ctx.clone(), &cfg.evasion, syn_ports).await
{
ctx.record_failure(ScannerKind::Connect, error.to_string());
}
finish_enrichment(None, caps, ctx, rdns::Unheard::Skipped).await;
}
orchestrator::run_passive_os_identification(ctx, cfg.os_detection);
}
fn tcp_ports_of(map: &TargetMap) -> PortSet {
map.units
.iter()
.fold(PortSet::new(), |named, unit| named.union(unit.ports()))
}
#[must_use]
#[derive(Debug, Clone)]
pub struct ListenScope {
links: Vec<crate::model::ip::scoped::Zone>,
recording: strategy::passive::Recording,
until: Until,
}
#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum Until {
#[default]
Stopped,
Elapsed(std::time::Duration),
}
impl ListenScope {
pub fn on(links: Vec<crate::model::ip::scoped::Zone>) -> Self {
Self {
links,
recording: strategy::passive::Recording::Attached,
until: Until::Stopped,
}
}
pub fn recording_everything(mut self) -> Self {
self.recording = strategy::passive::Recording::Everything;
self
}
pub fn recording_only(mut self, addresses: IpSet) -> Self {
self.recording = strategy::passive::Recording::Only(addresses);
self
}
pub fn for_at_most(mut self, span: std::time::Duration) -> Self {
self.until = Until::Elapsed(span);
self
}
pub fn links(&self) -> &[crate::model::ip::scoped::Zone] {
&self.links
}
pub fn until(&self) -> Until {
self.until
}
}
pub async fn listen(
scope: ListenScope,
cfg: &ZondConfig,
) -> Result<(ScanSession, ScanTask), ScanError> {
let (session, ctx) = ScanSession::builder()
.excluding(cfg.exclusions.clone())
.naming(cfg.target_names.clone())
.host_timeout(cfg.host_timeout)
.scan_timeout(cfg.scan_timeout)
.host_probe_interval(cfg.host_probe_interval)
.staging(vec![Stage::Listening])
.build();
let handle = spawn_listen(scope, cfg, ctx);
let stop = session.handle().clone();
Ok((session, ScanTask::new(handle, stop)))
}
#[cfg(feature = "journal-format")]
pub async fn listen_with_journal(
scope: ListenScope,
cfg: &ZondConfig,
journal: crate::journal::Journal,
) -> Result<(ScanSession, ScanTask), ScanError> {
let journal = accepted(journal, |journal| {
if journal.manifest().kind() != ScanKind::Listen {
return Err(ScanError::WrongPhase);
}
Ok(())
})?;
let (session, ctx) = ScanSession::builder()
.excluding(cfg.exclusions.clone())
.naming(cfg.target_names.clone())
.host_timeout(cfg.host_timeout)
.scan_timeout(cfg.scan_timeout)
.host_probe_interval(cfg.host_probe_interval)
.staging(vec![Stage::Listening])
.build();
ctx.restore_hosts(journal.restored());
let earlier = journal.earlier_phases().to_vec();
let ticker = checkpoint::spawn_checkpoints(journal, ctx.progress());
let handle = spawn_listen(scope, cfg, ctx);
let stop = session.handle().clone();
Ok((
session,
ScanTask::journalling(handle, stop, ticker, earlier),
))
}
fn spawn_listen(scope: ListenScope, cfg: &ZondConfig, ctx: ScanContext) -> JoinHandle<ScanReport> {
let cfg = cfg.clone();
tokio::spawn(async move {
ctx.enter_stage(Stage::Listening, None);
let opened =
strategy::passive::PassiveListener::open(&scope.links, scope.recording, ctx.clone());
let recorder = PhaseRecorder::start(
ScanKind::Listen,
listening_privilege(opened.as_ref().err()),
TargetScope::listening_on(scope.links.clone(), &cfg.exclusions),
&cfg,
)
.opening_in(&ctx);
match opened {
Ok(listener) => {
let mut listener = listener.detecting_os(cfg.os_detection);
if let Until::Elapsed(span) = scope.until {
listener = listener.stopping_after(span);
}
if let Err(error) = listener.observe().await {
ctx.record_failure(ScannerKind::Passive, error.to_string());
}
}
Err(error) => ctx.record_failure(ScannerKind::Passive, error.to_string()),
}
vantage::attribute(&ctx);
orchestrator::correlate(&ctx, cfg.service_detection).await;
recorder.finish_last(ctx)
})
}
fn listening_privilege(refusal: Option<&strategy::StrategyError>) -> Privilege {
use crate::transport::capture::CaptureError;
match refusal {
None => Privilege::Raw,
Some(strategy::StrategyError::Capture(CaptureError::NoInterface { refused }))
if refused.is_empty() =>
{
Privilege::current()
}
Some(strategy::StrategyError::Capture(error)) if error.is_denied() => Privilege::Connect,
Some(strategy::StrategyError::Capture(_)) => Privilege::Raw,
Some(_) => Privilege::current(),
}
}
pub fn withhold_unprobeable(target_map: &mut TargetMap) {
target_map.take_unprobeable(&[], interface::is_enumerable);
}
pub async fn scan(
target_map: TargetMap,
cfg: &ZondConfig,
detections: Detections,
) -> Result<(ScanSession, ScanTask), ScanError> {
cfg.evasion.validate()?;
let mut target_map = target_map;
target_map.withhold_ports(&cfg.excluded_ports);
let withheld = orchestrator::withhold_unprobeable_targets(&mut target_map);
let capture_links = capture_plan(&plan_addresses(&target_map), cfg)?;
let planned = planned_targets(&target_map);
let runs_liveness = liveness_earns_its_place(cfg, &target_map);
let (session, ctx) = ScanSession::builder()
.excluding(cfg.exclusions.clone())
.naming(cfg.target_names.clone())
.host_timeout(cfg.host_timeout)
.scan_timeout(cfg.scan_timeout)
.host_probe_interval(cfg.host_probe_interval)
.send_source(cfg.send_source.clone())
.listening_only_to(cfg.listen_only_ports.clone())
.detections(detections)
.planning(Stage::Ports, planned)
.staging(scan_stages(cfg, runs_liveness))
.build();
let handle = spawn_scan(
target_map,
withheld,
capture_links,
cfg,
ctx,
Checkpoint::default(),
runs_liveness,
);
let stop = session.handle().clone();
Ok((session, ScanTask::new(handle, stop)))
}
#[cfg(feature = "journal-format")]
pub async fn scan_with_journal(
target_map: TargetMap,
cfg: &ZondConfig,
detections: Detections,
journal: crate::journal::Journal,
) -> Result<(ScanSession, ScanTask), ScanError> {
let mut capture_links = Vec::new();
let journal = accepted(journal, |journal| {
cfg.evasion.validate()?;
let mut probed = target_map.clone();
probed.withhold_ports(&cfg.excluded_ports);
orchestrator::withhold_unprobeable_targets(&mut probed);
capture_links = capture_plan(&plan_addresses(&probed), cfg)?;
if journal.manifest().kind() != ScanKind::PortScan {
return Err(ScanError::WrongPhase);
}
let technique = journal.manifest().technique();
let this_run =
crate::journal::manifest::Plan::port_scan(&target_map, &cfg.exclusions, technique);
counted_as_recorded(journal, &this_run)?;
under_the_recorded_options(journal, cfg)
})?;
let cfg = &under_the_recorded_technique(&journal, cfg);
let journal = recording_options(journal, cfg);
let numbered_without = journal.options().map_or_else(
|| cfg.excluded_ports.clone(),
crate::journal::manifest::JobOptions::excluded_ports,
);
let withheld_ports = cfg.excluded_ports.difference(&numbered_without);
let mut target_map = target_map;
target_map.withhold_ports(&numbered_without);
let withheld = orchestrator::withhold_unprobeable_targets(&mut target_map);
let runs_liveness = liveness_earns_its_place(cfg, &target_map);
let finished = journal.finished_hosts().unwrap_or_else(|e| {
crate::warn!("passes rerun for every host ({e})");
Default::default()
});
let mut numbered = target_map.clone();
cfg.exclusions.withhold_targets(&mut numbered);
let asked = orchestrator::unsettled_ips(&numbered, journal.resume_point());
let (session, ctx) = ScanSession::builder()
.excluding(cfg.exclusions.clone())
.naming(cfg.target_names.clone())
.host_timeout(cfg.host_timeout)
.scan_timeout(cfg.scan_timeout)
.host_probe_interval(cfg.host_probe_interval)
.send_source(cfg.send_source.clone())
.listening_only_to(cfg.listen_only_ports.clone())
.withholding_ports(withheld_ports)
.resuming(journal.resume_point())
.finished(finished, asked)
.detections(detections)
.planning(Stage::Ports, planned_targets(&target_map))
.staging(scan_stages(cfg, runs_liveness))
.ordering(journal.manifest().order_seed)
.build();
ctx.restore_hosts(journal.restored());
let earlier = journal.earlier_phases().to_vec();
let resume_point = journal.resume_point().clone();
let ticker = checkpoint::spawn_checkpoints(journal, ctx.progress());
let handle = spawn_scan(
target_map,
withheld,
capture_links,
cfg,
ctx,
resume_point,
runs_liveness,
);
let stop = session.handle().clone();
Ok((
session,
ScanTask::journalling(handle, stop, ticker, earlier),
))
}
fn sitting_probes(
cfg: &ZondConfig,
target_map: &TargetMap,
numbered: &TargetMap,
settled: &Checkpoint,
) -> Option<orchestrator::Probing> {
(!orchestrator::unsettled_ips(numbered, settled).is_empty())
.then(|| orchestrator::Probing::ports(cfg, target_map))
}
#[allow(clippy::too_many_arguments)]
fn spawn_scan(
target_map: TargetMap,
withheld: orchestrator::Withheld,
capture_links: Vec<Zone>,
cfg: &ZondConfig,
ctx: ScanContext,
settled: Checkpoint,
runs_liveness: bool,
) -> JoinHandle<ScanReport> {
let mut numbered = target_map.clone();
cfg.exclusions.withhold_targets(&mut numbered);
let caps = ScanCapabilities::resolve(
cfg,
sitting_probes(cfg, &target_map, &numbered, &settled),
&orchestrator::unsettled_ips(&numbered, &settled),
interface::FrameSender::Probe,
);
let requested = cfg.clone();
let cfg = running_under(&requested);
let held_back = crate::system::descriptors::hold_back();
tokio::spawn(async move {
let _held_back = held_back;
crate::fingerprint::start_loading_corpus();
ctx.number_targets(TargetIndex::of(&numbered));
ctx.capture_on(capture_links);
let skipped = liveness_skip(&cfg, runs_liveness);
let (liveness, live) = if let Some(why) = skipped {
match why {
LivenessSkip::IdleScan => {
crate::info!(verbosity = 1, "liveness pass skipped (idle scan)");
}
LivenessSkip::PortsNoDearer => {
crate::info!(verbosity = 1, "liveness pass skipped (port scan no dearer)");
}
_ => {}
}
(None, None)
} else {
let unnumbered = Checkpoint::default();
let mut finished = orchestrator::unsettled_ips(&numbered, &unnumbered);
finished.subtract(&orchestrator::unsettled_ips(&numbered, &settled));
let mut ips = orchestrator::unsettled_ips(&target_map, &unnumbered);
ips.subtract(&finished);
let scope = address_scope(&mut ips, &ctx);
let recorder = PhaseRecorder::start(ScanKind::Discovery, caps.privilege, scope, &cfg)
.opening_in(&ctx);
ctx.enter_stage(Stage::Discovery, None);
let syn_ports = SynPorts::for_scan(&tcp_ports_of(&target_map));
let sctp = orchestrator::sctp_discovery_port(&target_map);
run_discovery(ips, Scope::Targeted, caps, &cfg, &ctx, syn_ports, sctp).await;
orchestrator::correlate(&ctx, cfg.service_detection).await;
let (report, liveness) = recorder.close(&ctx);
(Some(report), liveness)
};
let mut covered = match &live {
Some(live) => probed_subset(&target_map, &live.live),
None => target_map.clone(),
};
let scope = TargetScope::from_target_map(&mut covered, &machine_policy(&ctx));
let mut recorder = PhaseRecorder::start(ScanKind::PortScan, caps.privilege, scope, &cfg);
if let Some(why) = skipped {
recorder = recorder.skipping_liveness(why);
}
let recorder = recorder.opening_in(&ctx);
ctx.enter_stage(Stage::Ports, None);
record_idle_refusals(&requested, &ctx);
let port_scanner = match caps.privilege.is_raw() {
true => ScannerKind::SynPort,
false => ScannerKind::Connect,
};
withheld.refuse(&ctx, port_scanner);
let stands_in = skipped == Some(LivenessSkip::PortsNoDearer);
run_port_phase(
numbered,
withheld.zones(),
live,
&ctx,
caps,
&cfg,
settled,
stands_in,
)
.await;
orchestrator::run_tls_enumeration(&ctx, &cfg).await;
orchestrator::run_active_os_series(&ctx, cfg.os_detection, cfg.probe_tuning(), caps).await;
orchestrator::run_active_os_snmp(&ctx, cfg.os_detection, &cfg.excluded_ports).await;
orchestrator::run_active_os_mdns(&ctx, cfg.os_detection, !cfg.no_dns, &cfg.excluded_ports)
.await;
orchestrator::run_active_os_probe(&ctx, cfg.os_detection, cfg.probe_tuning(), caps).await;
orchestrator::run_traceroute(&ctx, &cfg, caps).await;
orchestrator::run_characterise(&ctx, &cfg, caps).await;
orchestrator::run_ip_protocols(&ctx, &cfg).await;
ctx.enter_stage(Stage::Finishing, None);
vantage::attribute(&ctx);
orchestrator::correlate(&ctx, cfg.service_detection).await;
orchestrator::run_cert_posture(&ctx);
let report = recorder.finish_last(ctx);
match liveness {
Some(mut first) => {
first.merge_later_copy(report);
first
}
None => report,
}
})
}
#[cfg(test)]
mod tests {
use super::*;
use crate::testing::loopback::accept_from_this_process;
#[test]
fn a_sitting_with_nothing_left_to_ask_names_no_probes() {
let mut map = TargetMap::new();
map.add_unit(crate::model::target::TargetSet::new(
"192.0.2.1".parse().expect("an address"),
"80".parse().expect("a port"),
));
let cfg = ZondConfig::default();
let everything = Checkpoint::new(1, []);
assert_eq!(sitting_probes(&cfg, &map, &map, &everything), None);
assert!(
sitting_probes(&cfg, &map, &map, &Checkpoint::default()).is_some(),
"a sitting with its target left to ask probes it"
);
}
#[cfg(feature = "journal-format")]
fn journal_root(name: &str) -> std::path::PathBuf {
let root = std::env::temp_dir().join(format!("zond-{name}-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(&root).expect("a scratch root");
root
}
#[test]
fn a_named_address_of_an_excluded_machine_leaves_the_sweeps_scope() {
use crate::journal::settle::Outcome;
use crate::model::exclusion::Exclusions;
use crate::model::ip::set::{IpSet, Positions};
use crate::model::mac::MacAddr;
use std::net::IpAddr;
let machine = MacAddr::new(0x02, 0, 0, 0, 0, 0x30);
let excluded: IpAddr = "192.0.2.30".parse().expect("literal");
let other: IpAddr = "192.0.2.40".parse().expect("literal");
let mut policy = IpSet::new();
policy.insert(excluded);
let mut targets: IpSet = "192.0.2.39-192.0.2.41".parse().expect("a range");
let (_session, ctx) = ScanSession::builder()
.excluding(Exclusions::new(policy))
.with_neighbours(vec![(excluded, Some(machine)), (other, Some(machine))])
.counting(Positions::of(&targets))
.build();
let scope = address_scope(&mut targets, &ctx);
assert!(!targets.contains(&other), "it is still a target");
assert_eq!(targets.len(), 2);
assert_eq!((scope.addresses(), scope.withheld()), (2, 1));
let excluded_starts: Vec<IpAddr> = scope
.excluded()
.iter()
.map(|range| range.start_addr())
.collect();
assert!(excluded_starts.contains(&other), "{excluded_starts:?}");
assert!(excluded_starts.contains(&excluded), "{excluded_starts:?}");
assert_eq!(
ctx.settlements().count(Outcome::Withheld { position: 0 }),
1
);
assert_eq!(ctx.settlements().checkpoint().settled_count(), 1);
}
fn refused_up_front() -> ZondConfig {
ZondConfig {
evasion: crate::evasion::EvasionProfile::default().with_ttl(0),
..ZondConfig::default()
}
}
#[cfg(feature = "journal-format")]
#[tokio::test]
async fn a_journalled_scan_refused_up_front_leaves_no_record() {
use crate::journal::Journal;
use crate::journal::manifest::Plan;
use crate::model::ip::set::IpSet;
use crate::model::target::TargetSet;
let root = journal_root("refused");
let addresses: IpSet = "192.0.2.1".parse().expect("an address");
let mut map = TargetMap::new();
map.add_unit(TargetSet::new(
addresses.clone(),
"22".parse().expect("ports"),
));
let cfg = refused_up_front();
let plan = Plan::port_scan(&map, &cfg.exclusions, cfg.tcp_technique);
let journal = Journal::create(&root, &plan, Privilege::current(), "").expect("creates");
let directory = journal.directory().to_path_buf();
let refused = scan_with_journal(map, &cfg, Detections::embedded(), journal).await;
assert!(
matches!(refused, Err(ScanError::Evasion(_))),
"{:?}",
refused.err()
);
assert!(
!directory.exists(),
"a port scan that never ran left a record"
);
let plan = Plan::discovery(&addresses, &cfg.exclusions, false);
let journal = Journal::create(&root, &plan, Privilege::current(), "").expect("creates");
let directory = journal.directory().to_path_buf();
let refused = discover_with_journal(addresses, &cfg, journal).await;
assert!(
matches!(refused, Err(ScanError::Evasion(_))),
"{:?}",
refused.err()
);
assert!(!directory.exists(), "a sweep that never ran left a record");
std::fs::remove_dir_all(&root).ok();
}
#[test]
fn a_raw_scan_needs_a_capture_device_for_each_link_it_captures_on() {
use crate::model::ip::scoped::Zone;
let links = [Zone::new(1, "lo0"), Zone::new(4, "en0")];
assert_eq!(captures_needed(Privilege::Raw, &links), 2);
assert_eq!(captures_needed(Privilege::Connect, &links), 0);
}
#[test]
fn a_scan_of_loopback_plans_its_captures_on_loopback_alone() {
let cfg = ZondConfig::default();
let links =
capture_plan(&"127.0.0.1".parse().expect("an address"), &cfg).expect("room for it");
let loopback: Vec<_> = crate::system::interface::interfaces()
.expect("this machine's interfaces")
.into_iter()
.filter(crate::system::interface::Link::is_loopback)
.map(|link| link.zone())
.collect();
assert_eq!(links, loopback);
}
#[tokio::test]
async fn a_port_scan_of_a_range_too_wide_to_walk_refuses_it_and_ends() {
use crate::model::target::TargetSet;
let mut map = TargetMap::new();
map.add_unit(TargetSet::new(
"2001:db8::/64".parse().expect("a prefix"),
"80,443".parse().expect("ports"),
));
let cfg = ZondConfig {
no_dns: true,
..ZondConfig::default()
};
let (_session, task) = scan(map, &cfg, Detections::embedded())
.await
.expect("the scan starts");
let report = tokio::time::timeout(std::time::Duration::from_secs(120), task)
.await
.expect("the scan ended")
.expect("the scan ran");
let refused: Vec<_> = report
.phases()
.iter()
.filter(|phase| phase.kind() == ScanKind::PortScan)
.flat_map(|phase| phase.refusals().iter())
.filter(|refusal| refusal.reason().contains("too large to walk"))
.collect();
assert_eq!(refused.len(), 1, "{:?}", report.phases());
}
#[cfg(feature = "journal-format")]
#[tokio::test]
async fn a_withheld_link_local_target_leaves_one_numbering_across_sittings() {
use crate::journal::Journal;
use crate::journal::manifest::Plan;
use crate::model::ip::set::IpSet;
use crate::model::target::TargetSet;
use crate::testing::loopback::SilentPort;
let peer = SilentPort::open();
let mut map = TargetMap::new();
map.add_unit(TargetSet::new(
"fe80::1-fe80::2".parse::<IpSet>().expect("addresses"),
"80".parse().expect("ports"),
));
map.add_unit(TargetSet::new(
IpSet::from(peer.addr().ip()),
peer.addr().port().to_string().parse().expect("ports"),
));
let cfg = ZondConfig {
no_dns: true,
assume_up: true,
service_detection: crate::config::ServiceDetection::Off,
..ZondConfig::default()
};
let plan = Plan::port_scan(&map, &cfg.exclusions, cfg.tcp_technique);
let root = journal_root("withheld-link-local");
let journal = Journal::create(&root, &plan, Privilege::current(), "").expect("creates");
let directory = journal.directory().to_path_buf();
let (session, task) = scan_with_journal(map.clone(), &cfg, Detections::embedded(), journal)
.await
.expect("the first sitting starts");
let report = task.join().await.expect("it finishes");
assert!(
report
.phases()
.iter()
.flat_map(|phase| phase.refusals())
.any(|refusal| refusal.reason().contains("link-local, name the interface")),
"the unscoped targets are refused: {:?}",
report.phases()
);
let progress = session.progress();
assert_eq!(progress.planned(), Some(1), "the plan walked is one target");
assert_eq!(
progress.remaining(),
Some(0),
"and a finished sitting owes none"
);
let (journal, settled) =
Journal::resume(&directory, &plan, Privilege::current()).expect("resumes");
assert_eq!(settled.settled_count(), 1, "the job recorded it settled");
let (session, task) = scan_with_journal(map, &cfg, Detections::embedded(), journal)
.await
.expect("the second sitting starts");
let _report = task.join().await.expect("it finishes");
assert_eq!(
session.progress().remaining(),
Some(0),
"a resume walks the plan the first sitting numbered"
);
std::fs::remove_dir_all(&root).ok();
}
#[tokio::test]
async fn a_sweep_counts_the_addresses_it_settles() {
let cfg = ZondConfig {
no_dns: true,
..ZondConfig::default()
};
let (session, task) = discover("127.0.0.1".parse().expect("an address"), &cfg)
.await
.expect("the sweep starts");
let _report = task.await.expect("the sweep ran");
let progress = session.progress();
assert_eq!(progress.planned(), Some(1));
assert_eq!(progress.settled(), 1, "the one address answered");
}
#[tokio::test]
async fn dropping_the_task_stops_the_scan() {
use crate::model::target::TargetSet;
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("a free port");
let port = listener.local_addr().expect("its address").port();
tokio::spawn(async move {
let mut held = Vec::new();
while let Ok(stream) = accept_from_this_process(&listener).await {
held.push(stream);
}
});
let mut map = TargetMap::new();
map.add_unit(TargetSet::new(
"127.0.0.1".parse().expect("an address"),
port.to_string().parse().expect("a port"),
));
let cfg = ZondConfig {
no_dns: true,
service_detection: crate::config::ServiceDetection::Thorough,
..ZondConfig::default()
};
let (mut session, task) = scan(map, &cfg, Detections::embedded())
.await
.expect("the scan starts");
drop(task);
assert_eq!(
session.handle().stopped(),
Some(handle::StopCause::Aborted),
"the scan runs on with nobody to collect it"
);
while session.events().recv().await.is_some() {}
}
#[tokio::test]
async fn a_scan_stopped_before_its_ports_starts_no_later_pass() {
use crate::model::target::TargetSet;
use crate::scanner::session::ScanEvent;
let mut map = TargetMap::new();
map.add_unit(TargetSet::new(
"127.0.0.1".parse().expect("an address"),
"1-16".parse().expect("ports"),
));
let cfg = ZondConfig {
no_dns: true,
os_detection: crate::config::OsDetection::Active,
traceroute: true,
tls_enumeration: true,
..ZondConfig::default()
};
let (mut session, task) = scan(map, &cfg, Detections::embedded())
.await
.expect("the scan starts");
session.handle().abort();
let _report = task.await.expect("the scan ran");
let mut stages = Vec::new();
while let Some(event) = session.events().try_recv() {
if let ScanEvent::StageChanged { stage } = event {
stages.push(stage);
}
}
assert!(
stages
.iter()
.all(|stage| matches!(stage, Stage::Discovery | Stage::Ports | Stage::Finishing)),
"a pass began after the stop: {stages:?}"
);
}
#[cfg(feature = "journal-format")]
#[tokio::test]
async fn a_resume_asking_what_its_job_did_not_is_refused_and_keeps_its_record() {
use crate::journal::Journal;
use crate::journal::manifest::{JobOptions, OptionChanged, Plan};
use crate::journal::settle::{Outcome, Settlements};
use crate::model::ip::set::IpSet;
let root = journal_root("option-changed");
let addresses: IpSet = "192.0.2.1-192.0.2.4".parse().expect("addresses");
let first = ZondConfig {
traceroute: true,
..ZondConfig::default()
};
let plan = Plan::discovery(&addresses, &first.exclusions, false);
let mut journal = Journal::create(&root, &plan, Privilege::current(), "").expect("creates");
journal
.record_options(JobOptions::of(&first))
.expect("records");
let settlements = Settlements::default();
settlements.record(Outcome::Answered { position: 0 });
journal.checkpoint(&settlements).expect("checkpoints");
let directory = journal.directory().to_path_buf();
journal.close().expect("closes");
let (journal, _) =
Journal::resume(&directory, &plan, Privilege::current()).expect("resumes");
let refused = discover_with_journal(addresses, &ZondConfig::default(), journal).await;
assert!(
matches!(
refused,
Err(ScanError::OptionChanged(OptionChanged {
option: "traceroute"
}))
),
"{:?}",
refused.err()
);
assert!(directory.join("manifest.json").exists(), "the record went");
std::fs::remove_dir_all(&root).ok();
}
#[cfg(feature = "journal-format")]
#[tokio::test]
async fn a_job_recorded_without_options_resumes_under_its_manifests_technique() {
use crate::journal::Journal;
use crate::journal::manifest::Plan;
use crate::model::ip::set::IpSet;
use crate::model::target::TargetSet;
use crate::model::technique::TcpScanTechnique;
let root = journal_root("recorded-technique");
let mut map = TargetMap::new();
map.add_unit(TargetSet::new(
"127.0.0.1".parse::<IpSet>().expect("an address"),
"9".parse().expect("ports"),
));
let cfg = ZondConfig {
no_dns: true,
assume_up: true,
..ZondConfig::default()
};
assert_ne!(cfg.tcp_technique, TcpScanTechnique::Ack, "test premise");
let plan = Plan::port_scan(&map, &cfg.exclusions, TcpScanTechnique::Ack);
let journal = Journal::create(&root, &plan, Privilege::current(), "").expect("creates");
let directory = journal.directory().to_path_buf();
journal.close().expect("closes");
let (journal, _) =
Journal::resume(&directory, &plan, Privilege::current()).expect("resumes");
assert!(journal.options().is_none(), "test premise: no options");
let (_session, task) = scan_with_journal(map, &cfg, Detections::embedded(), journal)
.await
.expect("the sitting starts");
let report = task.join().await.expect("it finishes");
let ports = report
.phases()
.iter()
.find(|phase| phase.kind() == ScanKind::PortScan)
.expect("a port phase");
assert_eq!(ports.settings().tcp_technique, TcpScanTechnique::Ack);
std::fs::remove_dir_all(&root).ok();
}
#[cfg(feature = "journal-format")]
#[tokio::test]
async fn a_watch_records_no_options_to_hold_a_later_sitting_to() {
use crate::journal::Journal;
use crate::journal::manifest::Plan;
use crate::model::ip::scoped::Zone;
let root = journal_root("watch-options");
let links = vec![Zone::new(u32::MAX, "zond-no-such-link")];
let plan = Plan::listen(links.clone());
let scope =
|| ListenScope::on(links.clone()).for_at_most(std::time::Duration::from_millis(1));
let journal = Journal::create(&root, &plan, Privilege::current(), "").expect("creates");
let directory = journal.directory().to_path_buf();
let (_session, task) = listen_with_journal(scope(), &ZondConfig::default(), journal)
.await
.expect("the watch starts");
let _ = task.join().await.expect("it ends");
assert!(
!directory.join("options.json").exists(),
"a watch recorded options"
);
let (journal, _) =
Journal::resume(&directory, &plan, Privilege::current()).expect("resumes");
let other = ZondConfig {
traceroute: true,
tcp_technique: crate::model::technique::TcpScanTechnique::Fin,
..ZondConfig::default()
};
let (_session, task) = listen_with_journal(scope(), &other, journal)
.await
.expect("a watch resumed under other settings continues");
let _ = task.join().await.expect("it ends");
std::fs::remove_dir_all(&root).ok();
}
#[cfg(feature = "journal-format")]
#[tokio::test]
async fn a_sweeps_journal_is_refused_to_a_port_scan() {
use crate::journal::Journal;
use crate::journal::manifest::Plan;
use crate::model::ip::set::IpSet;
use crate::model::target::TargetSet;
let root = journal_root("other-phase");
let addresses: IpSet = "127.0.0.1".parse().expect("an address");
let mut map = TargetMap::new();
map.add_unit(TargetSet::new(
addresses.clone(),
"9".parse().expect("ports"),
));
let cfg = ZondConfig::default();
let plan = Plan::discovery(&addresses, &cfg.exclusions, false);
let journal = Journal::create(&root, &plan, Privilege::current(), "").expect("creates");
let refused = scan_with_journal(map, &cfg, Detections::embedded(), journal).await;
assert!(
matches!(refused, Err(ScanError::WrongPhase)),
"{:?}",
refused.err()
);
std::fs::remove_dir_all(&root).ok();
}
#[cfg(feature = "journal-format")]
#[tokio::test]
async fn a_resumed_liveness_pass_counts_what_the_policy_leaves() {
use crate::journal::Journal;
use crate::journal::manifest::Plan;
use crate::journal::settle::{Outcome, Settlements};
use crate::model::exclusion::Exclusions;
use crate::model::target::TargetSet;
let mut map = TargetMap::new();
map.add_unit(TargetSet::new(
"127.0.0.1-127.0.0.4".parse().expect("addresses"),
"1-100".parse().expect("ports"),
));
let cfg = ZondConfig {
no_dns: true,
scan_timeout: Some(std::time::Duration::from_secs(1)),
exclusions: Exclusions::new("127.0.0.1".parse().expect("an address")),
..ZondConfig::default()
};
let plan = Plan::port_scan(&map, &cfg.exclusions, cfg.tcp_technique);
let root = journal_root("liveness-numbering");
let mut journal = Journal::create(&root, &plan, Privilege::current(), "").expect("creates");
let settlements = Settlements::default();
for position in 0..200 {
settlements.record(Outcome::Answered { position });
}
journal.checkpoint(&settlements).expect("checkpoints");
let directory = journal.directory().to_path_buf();
journal.close().expect("closes");
let (journal, _) =
Journal::resume(&directory, &plan, Privilege::current()).expect("resumes");
let (_session, task) = scan_with_journal(map, &cfg, Detections::embedded(), journal)
.await
.expect("the sitting starts");
let report = task.join().await.expect("the sitting ends");
let liveness = report
.phases()
.iter()
.find(|phase| phase.kind() == ScanKind::Discovery)
.expect("a liveness pass ran");
assert_eq!(
liveness.targets().addresses(),
1,
"{:?}",
liveness.targets().ranges()
);
assert_eq!(liveness.targets().withheld(), 1, "the policy's cost went");
std::fs::remove_dir_all(&root).ok();
}
#[cfg(feature = "journal-format")]
#[tokio::test]
async fn a_sitting_killed_after_a_checkpoint_leaves_its_hosts_owed() {
use crate::journal::Journal;
use crate::journal::manifest::Plan;
use crate::model::exclusion::Exclusions;
use crate::model::host::HostStatus;
use crate::model::ip::set::IpSet;
use crate::model::target::TargetSet;
use crate::scanner::checkpoint::spawn_checkpoints;
let address: std::net::IpAddr = "127.0.0.1".parse().expect("an address");
let mut map = TargetMap::new();
map.add_unit(TargetSet::new(
IpSet::from(address),
"80".parse().expect("ports"),
));
let cfg = ZondConfig::default();
let plan = Plan::port_scan(&map, &cfg.exclusions, cfg.tcp_technique);
let root = journal_root("killed-owed");
let journal = Journal::create(&root, &plan, Privilege::current(), "").expect("creates");
let directory = journal.directory().to_path_buf();
let (_session, ctx) = ScanSession::new();
let mut scope = IpSet::from(address);
let _open = PhaseRecorder::start(
ScanKind::PortScan,
Privilege::current(),
TargetScope::from_ip_set(&mut scope, &Exclusions::none()),
&cfg,
)
.opening_in(&ctx);
ctx.update_host(address, |host| host.set_status(HostStatus::Up));
let mut ticker = spawn_checkpoints(journal, ctx.progress());
ticker.checkpointed().await;
ticker.kill().await;
let (journal, _) =
Journal::resume(&directory, &plan, Privilege::current()).expect("resumes");
assert!(
journal
.earlier_phases()
.iter()
.any(|phase| phase.stopped().is_none()),
"the killed sitting's standing phase is read back"
);
let finished = journal.finished_hosts().expect("reads");
let (_resumed, resumed) = ScanSession::builder()
.finished(finished.clone(), IpSet::new())
.build();
resumed.restore_hosts(journal.restored());
let owed = resumed
.read_host(address, |host| resumed.owes_passes(host))
.expect("the host came back");
assert!(
owed,
"a killed sitting's host was taken as finished: {finished:?}"
);
journal.close().expect("closes");
std::fs::remove_dir_all(&root).ok();
}
#[cfg(feature = "journal-format")]
#[tokio::test]
async fn only_a_sitting_that_ran_to_its_end_records_its_hosts_finished() {
use crate::journal::Journal;
use crate::journal::manifest::Plan;
use crate::model::target::TargetSet;
let mut map = TargetMap::new();
map.add_unit(TargetSet::new(
"127.0.0.1".parse().expect("an address"),
"9".parse().expect("ports"),
));
let cfg = ZondConfig {
no_dns: true,
assume_up: true,
..ZondConfig::default()
};
let plan = Plan::port_scan(&map, &cfg.exclusions, cfg.tcp_technique);
for stopped in [false, true] {
let root = journal_root(&format!("records-finished-{stopped}"));
let journal = Journal::create(&root, &plan, Privilege::current(), "").expect("creates");
let directory = journal.directory().to_path_buf();
let (session, task) =
scan_with_journal(map.clone(), &cfg, Detections::embedded(), journal)
.await
.expect("the sitting starts");
if stopped {
session.handle().abort();
}
let report = task.join().await.expect("the sitting ends");
assert!(report.host_count() > 0 || stopped, "the host was not found");
let (journal, _) =
Journal::resume(&directory, &plan, Privilege::current()).expect("resumes");
let finished = journal.finished_hosts().expect("reads");
assert_eq!(
finished.contains("127.0.0.1"),
!stopped,
"stopped: {stopped}, finished: {finished:?}"
);
drop(journal);
std::fs::remove_dir_all(&root).ok();
}
}
#[cfg(feature = "journal-format")]
#[tokio::test]
async fn a_resumed_job_asks_a_host_a_sitting_finished_nothing_it_already_asked() {
use crate::journal::Journal;
use crate::journal::manifest::Plan;
use crate::journal::settle::{Outcome, Settlements};
use crate::model::host::{Host, HostStatus};
use crate::model::port::{Port, PortState, Protocol, Service};
use crate::model::target::TargetSet;
let mut map = TargetMap::new();
map.add_unit(TargetSet::new(
"127.0.0.1".parse().expect("an address"),
"80".parse().expect("ports"),
));
let cfg = ZondConfig {
no_dns: true,
..ZondConfig::default()
};
let plan = Plan::port_scan(&map, &cfg.exclusions, cfg.tcp_technique);
let resumed = |finished: bool| {
let (root, map, cfg, plan) = (
journal_root(&format!("finished-{finished}")),
map.clone(),
cfg.clone(),
plan.clone(),
);
async move {
let mut journal =
Journal::create(&root, &plan, Privilege::current(), "").expect("creates");
let mut host = Host::new("127.0.0.1".parse().expect("an address"));
host.set_status(HostStatus::Up);
host.add_port(
Port::new(80, Protocol::Tcp, PortState::Open)
.with_service(Service::new("http", 100)),
);
journal.record_hosts(&[host]).expect("records the host");
let settlements = Settlements::default();
settlements.record(Outcome::Answered { position: 0 });
journal.checkpoint(&settlements).expect("checkpoints");
if finished {
journal
.record_finished(["127.0.0.1".to_string()])
.expect("records the sitting's end");
}
let directory = journal.directory().to_path_buf();
journal.close().expect("closes");
let written = |directory: &std::path::Path| {
std::fs::metadata(directory.join("hosts.jsonl")).map_or(0, |file| file.len())
};
let before = written(&directory);
let (journal, _) =
Journal::resume(&directory, &plan, Privilege::current()).expect("resumes");
let (_session, task) =
scan_with_journal(map, &cfg, Detections::embedded(), journal)
.await
.expect("the sitting starts");
let _report = task.join().await.expect("the sitting ends");
let runs = crate::journal::store::read_detections(&directory).expect("reads");
let rewritten = written(&directory) > before;
std::fs::remove_dir_all(&root).ok();
(runs.len(), rewritten)
}
};
let (runs, _) = resumed(false).await;
assert!(
runs > 0,
"a host no sitting finished is owed its detections"
);
let (runs, rewritten) = resumed(true).await;
assert_eq!(runs, 0, "a finished host was asked its detections again");
assert!(!rewritten, "a finished host was written down again");
}
#[cfg(feature = "journal-format")]
#[tokio::test]
async fn a_resumed_sitting_reports_each_recorded_round_trip_once() {
use crate::journal::Journal;
use crate::journal::manifest::Plan;
use crate::journal::settle::{Outcome, Settlements};
use crate::model::host::{Host, HostStatus};
use crate::model::target::TargetSet;
use std::time::Duration;
let mut map = TargetMap::new();
map.add_unit(TargetSet::new(
"127.0.0.1".parse().expect("an address"),
"20000-20015".parse().expect("ports"),
));
let cfg = ZondConfig {
no_dns: true,
..ZondConfig::default()
};
assert!(liveness_earns_its_place(&cfg, &map), "the pass runs");
let plan = Plan::port_scan(&map, &cfg.exclusions, cfg.tcp_technique);
let root = journal_root("round-trips-once");
let mut journal = Journal::create(&root, &plan, Privilege::current(), "").expect("creates");
let recorded: Vec<Duration> = (91..=96).map(Duration::from_millis).collect();
let mut host = Host::new("127.0.0.1".parse().expect("an address"));
host.set_status(HostStatus::Up);
host.add_rtts(recorded.iter().copied());
journal.record_hosts(&[host]).expect("records the host");
let settlements = Settlements::default();
for position in 0..16 {
settlements.record(Outcome::Answered { position });
}
journal.checkpoint(&settlements).expect("checkpoints");
journal
.record_finished(["127.0.0.1".to_string()])
.expect("records the sitting's end");
let directory = journal.directory().to_path_buf();
journal.close().expect("closes");
let (journal, _) =
Journal::resume(&directory, &plan, Privilege::current()).expect("resumes");
let (_session, task) = scan_with_journal(map, &cfg, Detections::embedded(), journal)
.await
.expect("the sitting starts");
let report = task.join().await.expect("the sitting ends");
std::fs::remove_dir_all(&root).ok();
let [host] = report.hosts().collect::<Vec<_>>()[..] else {
panic!("one host reported");
};
let held: Vec<Duration> = host
.telemetry()
.history()
.iter()
.map(|sample| sample.rtt)
.collect();
for rtt in &recorded {
assert_eq!(
held.iter().filter(|held| *held == rtt).count(),
1,
"{rtt:?} is reported other than once: {held:?}"
);
}
}
#[cfg(feature = "journal-format")]
#[tokio::test]
async fn a_resume_draws_the_detections_a_killed_sitting_owed_a_port_it_settled() {
use crate::journal::Journal;
use crate::journal::manifest::Plan;
use crate::journal::settle::{Outcome, Settlements};
use crate::model::host::{Host, HostStatus};
use crate::model::port::{Port, PortState, Protocol, Service};
use crate::model::target::TargetSet;
use crate::testing::loopback::accept_from_this_process;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let web_server = || async {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("binds loopback");
let addr = listener.local_addr().expect("a local address");
tokio::spawn(async move {
while let Ok(mut sock) = accept_from_this_process(&listener).await {
tokio::spawn(async move {
let mut buffer = [0u8; 1024];
if !matches!(sock.read(&mut buffer).await, Ok(n) if n > 0) {
return;
}
let _ = sock
.write_all(
b"HTTP/1.1 200 OK\r\nServer: nginx/1.24.0\r\n\
Content-Type: text/html\r\nContent-Length: 0\r\n\
Connection: close\r\n\r\n",
)
.await;
});
}
});
addr
};
let addr = web_server().await;
let unreached = web_server().await.port();
let mut map = TargetMap::new();
map.add_unit(TargetSet::new(
addr.ip().into(),
format!("{},{unreached}", addr.port())
.parse()
.expect("ports"),
));
let cfg = ZondConfig {
no_dns: true,
..ZondConfig::default()
};
let plan = Plan::port_scan(&map, &cfg.exclusions, cfg.tcp_technique);
let settled = map
.iter()
.position(|target| target.port == addr.port())
.expect("the server's port is planned") as u64;
let findings = |report: &ScanReport| {
report
.hosts()
.flat_map(Host::ports)
.flat_map(Port::findings)
.count()
};
let root = journal_root("owed-detections-whole");
let journal = Journal::create(&root, &plan, Privilege::current(), "").expect("creates");
let (_session, task) =
scan_with_journal(map.clone(), &cfg, Detections::embedded(), journal)
.await
.expect("the sitting starts");
let whole = findings(&task.join().await.expect("the sitting ends"));
std::fs::remove_dir_all(&root).ok();
assert!(whole > 0, "the server draws no finding to lose");
let root = journal_root("owed-detections-killed");
let mut journal = Journal::create(&root, &plan, Privilege::current(), "").expect("creates");
let mut host = Host::new(addr.ip());
host.set_status(HostStatus::Up);
host.add_port(
Port::new(addr.port(), Protocol::Tcp, PortState::Open)
.with_service(Service::new("http", 90)),
);
journal.record_hosts(&[host]).expect("records the host");
let settlements = Settlements::default();
settlements.record(Outcome::Answered { position: settled });
journal.checkpoint(&settlements).expect("checkpoints");
let directory = journal.directory().to_path_buf();
journal.close().expect("closes");
let (journal, _) =
Journal::resume(&directory, &plan, Privilege::current()).expect("resumes");
let (_session, task) = scan_with_journal(map, &cfg, Detections::embedded(), journal)
.await
.expect("the sitting starts");
let resumed = findings(&task.join().await.expect("the sitting ends"));
std::fs::remove_dir_all(&root).ok();
assert_eq!(
resumed, whole,
"the resume drew other findings than one sitting"
);
}
#[cfg(feature = "journal-format")]
#[tokio::test]
async fn a_resume_excluding_another_port_sends_it_nothing_and_keeps_the_numbering() {
use crate::journal::Journal;
use crate::journal::manifest::{JobOptions, Plan};
use crate::journal::settle::{Outcome, Settlements};
use crate::model::host::{Host, HostStatus};
use crate::model::port::{Port, PortSet, PortState, Protocol};
use crate::model::target::TargetSet;
use crate::testing::loopback::SilentPort;
let (first, second) = (SilentPort::open(), SilentPort::open());
let (excluded, settled) = if first.addr().port() < second.addr().port() {
(first, second)
} else {
(second, first)
};
let mut map = TargetMap::new();
map.add_unit(TargetSet::new(
"127.0.0.1".parse().expect("an address"),
format!("{},{}", excluded.addr().port(), settled.addr().port())
.parse()
.expect("ports"),
));
let recorded = ZondConfig {
no_dns: true,
assume_up: true,
..ZondConfig::default()
};
let plan = Plan::port_scan(&map, &recorded.exclusions, recorded.tcp_technique);
let root = journal_root("added-exclusion");
let mut journal = Journal::create(&root, &plan, Privilege::current(), "").expect("creates");
journal
.record_options(JobOptions::of(&recorded))
.expect("records the options");
let mut host = Host::new("127.0.0.1".parse().expect("an address"));
host.set_status(HostStatus::Up);
host.add_port(Port::new(
excluded.addr().port(),
Protocol::Tcp,
PortState::Open,
));
journal.record_hosts(&[host]).expect("records the host");
let settlements = Settlements::default();
settlements.record(Outcome::Answered { position: 1 });
journal.checkpoint(&settlements).expect("checkpoints");
let directory = journal.directory().to_path_buf();
journal.close().expect("closes");
let mut cfg = recorded.clone();
cfg.excluded_ports =
PortSet::try_from(excluded.addr().port().to_string().as_str()).expect("a port");
let (journal, _) =
Journal::resume(&directory, &plan, Privilege::current()).expect("resumes");
let (_session, task) = scan_with_journal(map, &cfg, Detections::embedded(), journal)
.await
.expect("a sitting excluding more is continued");
let report = task.join().await.expect("the sitting ends");
std::fs::remove_dir_all(&root).ok();
assert_eq!(
crate::transport::dial::dialled::to(excluded.addr()),
0,
"the excluded port was asked"
);
assert_eq!(
crate::transport::dial::dialled::to(settled.addr()),
0,
"a settled target was asked again"
);
assert!(
report
.hosts()
.flat_map(Host::ports)
.all(|port| port.number() != excluded.addr().port()),
"the excluded port is still reported"
);
assert!(
report
.phases()
.last()
.expect("the sitting's phase")
.settings()
.excluded_ports
.contains(excluded.addr().port(), Protocol::Tcp),
"the report does not say the port was excluded"
);
}
#[cfg(feature = "journal-format")]
#[tokio::test]
async fn a_job_excluding_a_port_is_complete_once_it_has_asked_the_rest() {
use crate::journal::Journal;
use crate::journal::manifest::Plan;
use crate::model::port::PortSet;
use crate::model::target::TargetSet;
use crate::testing::loopback::SilentPort;
let (excluded, asked) = (SilentPort::open(), SilentPort::open());
let mut map = TargetMap::new();
map.add_unit(TargetSet::new(
"127.0.0.1".parse().expect("an address"),
format!("{},{}", excluded.addr().port(), asked.addr().port())
.parse()
.expect("ports"),
));
let cfg = ZondConfig {
no_dns: true,
assume_up: true,
excluded_ports: PortSet::try_from(excluded.addr().port().to_string().as_str())
.expect("a port"),
..ZondConfig::default()
};
let plan = Plan::port_scan(&map, &cfg.exclusions, cfg.tcp_technique);
let root = journal_root("excluded-complete");
let journal = Journal::create(&root, &plan, Privilege::current(), "").expect("creates");
let (_session, task) = scan_with_journal(map, &cfg, Detections::embedded(), journal)
.await
.expect("the sitting starts");
let _report = task.join().await.expect("the sitting ends");
let listed = crate::journal::store::list(&root).expect("lists");
std::fs::remove_dir_all(&root).ok();
assert_eq!(
crate::transport::dial::dialled::to(excluded.addr()),
0,
"the excluded port was asked"
);
let [entry] = listed.as_slice() else {
panic!("one job on record: {listed:?}");
};
assert_eq!(
(entry.settled(), entry.manifest.total_targets),
(Some(1), 1),
"settled against the total"
);
assert!(entry.is_complete(), "the finished job reads as unfinished");
}
#[cfg(feature = "journal-format")]
#[tokio::test]
async fn a_resumed_sweep_with_nothing_left_passes_nothing_over_what_it_finished() {
use crate::journal::Journal;
use crate::journal::manifest::Plan;
use crate::model::ip::set::IpSet;
let addresses: IpSet = "127.0.0.1".parse().expect("an address");
let cfg = ZondConfig {
no_dns: true,
traceroute: true,
..ZondConfig::default()
};
let plan = Plan::discovery(&addresses, &cfg.exclusions, false);
let root = journal_root("finished-sweep");
let journal = Journal::create(&root, &plan, Privilege::current(), "").expect("creates");
let directory = journal.directory().to_path_buf();
let (_session, task) = discover_with_journal(addresses.clone(), &cfg, journal)
.await
.expect("the sitting starts");
let first = task.join().await.expect("the sitting ends");
assert!(first.host_count() > 0, "loopback was not found");
let written =
|| std::fs::metadata(directory.join("hosts.jsonl")).map_or(0, |file| file.len());
let before = written();
let (journal, _) =
Journal::resume(&directory, &plan, Privilege::current()).expect("resumes");
let (_session, task) = discover_with_journal(addresses, &cfg, journal)
.await
.expect("the sitting starts");
let resumed = task.join().await.expect("the sitting ends");
let after = written();
std::fs::remove_dir_all(&root).ok();
let traced = resumed
.phases()
.last()
.expect("the sitting's phase")
.refusals()
.iter()
.any(|refusal| refusal.reason().contains("route trace"));
assert!(!traced, "the finished host was owed its route trace");
assert_eq!(after, before, "the finished host was written down again");
}
#[cfg(feature = "journal-format")]
#[tokio::test]
async fn a_port_scan_handed_a_journal_of_another_plan_is_refused() {
use crate::journal::Journal;
use crate::journal::manifest::Plan;
use crate::model::target::TargetSet;
let root = journal_root("other-plan");
let map = |ports: &str| {
let mut map = TargetMap::new();
map.add_unit(TargetSet::new(
"127.0.0.1".parse().expect("an address"),
ports.parse().expect("ports"),
));
map
};
let cfg = ZondConfig::default();
let recorded = Plan::port_scan(&map("1-100"), &cfg.exclusions, cfg.tcp_technique);
let journal = Journal::create(&root, &recorded, Privilege::current(), "").expect("creates");
let refused = scan_with_journal(map("1000-1100"), &cfg, Detections::embedded(), journal)
.await
.err();
assert!(
matches!(refused, Some(ScanError::PlanChanged(_))),
"{refused:?}"
);
let other = Privilege::from_raw(!Privilege::current().is_raw());
let journal = Journal::create(&root, &recorded, other, "").expect("creates");
let refused = scan_with_journal(map("1-100"), &cfg, Detections::embedded(), journal)
.await
.err();
assert!(
matches!(refused, Some(ScanError::PlanChanged(_))),
"{refused:?}"
);
std::fs::remove_dir_all(&root).ok();
}
#[cfg(feature = "journal-format")]
#[tokio::test]
async fn a_refused_resume_keeps_the_record_of_the_sitting_before_it() {
use crate::journal::Journal;
use crate::journal::manifest::Plan;
use crate::journal::settle::{Outcome, Settlements};
use crate::model::ip::set::IpSet;
let root = journal_root("refused-resume");
let addresses: IpSet = "192.0.2.1-192.0.2.4".parse().expect("addresses");
let cfg = refused_up_front();
let plan = Plan::discovery(&addresses, &cfg.exclusions, false);
let mut journal = Journal::create(&root, &plan, Privilege::current(), "").expect("creates");
let settlements = Settlements::default();
settlements.record(Outcome::Answered { position: 0 });
journal.checkpoint(&settlements).expect("checkpoints");
let directory = journal.directory().to_path_buf();
journal.close().expect("closes");
let (journal, _) =
Journal::resume(&directory, &plan, Privilege::current()).expect("resumes");
let refused = discover_with_journal(addresses, &cfg, journal).await;
assert!(
matches!(refused, Err(ScanError::Evasion(_))),
"{:?}",
refused.err()
);
assert!(directory.join("manifest.json").exists(), "the record went");
std::fs::remove_dir_all(&root).ok();
}
#[test]
fn a_listener_is_recorded_unprivileged_only_where_privilege_refused_it() {
use crate::scanner::strategy::StrategyError;
use crate::transport::capture::{CaptureError, LibraryError};
let denied = |link: &str| CaptureError::Denied {
interface: link.into(),
source: LibraryError::new(pcap::Error::PcapError("permission denied".into())),
};
let filter = CaptureError::Filter {
filter: "ip6 and ether proto 0x86dd".into(),
source: LibraryError::new(pcap::Error::PcapError("not an ethernet link".into())),
};
let refused = |refused| StrategyError::Capture(CaptureError::NoInterface { refused });
assert_eq!(
listening_privilege(Some(&refused(vec![("en0".into(), denied("en0"))]))),
Privilege::Connect,
"the platform refused this process"
);
assert_eq!(
listening_privilege(Some(&refused(vec![("utun4".into(), filter)]))),
Privilege::Raw,
"the link refused the filter, after the platform let it open"
);
assert_eq!(listening_privilege(None), Privilege::Raw, "it listened");
assert_eq!(
listening_privilege(Some(&refused(Vec::new()))),
Privilege::current(),
"no link was tried, so the process's own answer is all there is"
);
}
#[tokio::test]
async fn a_panicking_scan_reports_what_the_panic_said() {
for spawned in [
tokio::spawn(async { panic!("a literal message") }),
tokio::spawn(async { panic!("a formatted {}", "message") }),
] {
let error = panic_or_cancellation(spawned.await.expect_err("the task panicked"));
let ScanError::TaskFailed { panicked, detail } = error else {
unreachable!("a panic is a TaskFailed")
};
assert!(panicked);
assert!(detail.contains("message"), "the payload was lost: {detail}");
}
}
#[tokio::test]
async fn a_cancelled_scan_is_not_reported_as_a_panic() {
let spawned = tokio::spawn(std::future::pending::<()>());
spawned.abort();
let error = panic_or_cancellation(spawned.await.expect_err("the task was cancelled"));
let ScanError::TaskFailed { panicked, .. } = error else {
unreachable!("a cancellation is a TaskFailed")
};
assert!(!panicked);
}
#[test]
fn an_idle_scans_declined_passes_are_filed_once_each_in_a_short_line() {
use crate::config::{DetectionEnvelope, OsDetection};
use crate::model::finding::DetectionClass;
let cfg = ZondConfig {
idle_scan: Some(crate::config::IdleScan::new(
"192.0.2.9".parse().expect("an address"),
)),
os_detection: OsDetection::Active,
traceroute: true,
characterise: true,
tls_enumeration: true,
ip_protocols: [47].into_iter().collect(),
detection: DetectionEnvelope::up_to(DetectionClass::ActiveBenign),
..ZondConfig::default()
};
let (_session, ctx) = ScanSession::new();
let said = crate::logging::logged(|| record_idle_refusals(&cfg, &ctx));
let refusals = ctx.take_refusals();
assert_eq!(refusals.len(), 6, "{refusals:?}");
for refusal in &refusals {
let line = format!("not covered: {}", refusal.reason());
assert!(line.len() <= 64, "{} characters: {line}", line.len());
}
assert!(
said.iter()
.all(|line| !line.message.contains("not covered")),
"a refusal was said on filing as well as in the report: {said:?}"
);
}
}