use std::net::IpAddr;
use crate::diff::change::Coverage;
use crate::model::host::Host;
use crate::model::ip::set::IpSet;
use crate::model::port::Protocol;
use crate::report::{PortScope, ScanReport, TargetScope};
pub(crate) struct ScopeIndex {
covered: IpSet,
undecided: IpSet,
withheld: IpSet,
stated: bool,
ports: Vec<PortScope>,
scopes: Vec<TargetScope>,
}
impl ScopeIndex {
pub(crate) fn of(report: &ScanReport) -> Self {
let mut covered = IpSet::new();
let mut undecided = IpSet::new();
let mut withheld = IpSet::new();
let mut ports = Vec::new();
let mut scopes = Vec::new();
for phase in report.phases() {
let scope = phase.targets();
for range in scope.ranges() {
covered.insert_range(*range);
}
for range in scope.excluded() {
withheld.insert_range(*range);
}
ports.push(scope.ports().clone());
scopes.push(scope.clone());
}
for range in report.undecided() {
undecided.insert_range(range);
}
covered.canonicalize();
undecided.canonicalize();
withheld.canonicalize();
let stated = !covered.is_empty()
|| !withheld.is_empty()
|| scopes.iter().any(|scope| !scope.links().is_empty());
Self {
covered,
undecided,
withheld,
stated,
ports,
scopes,
}
}
pub(crate) fn states_scope(&self) -> bool {
self.stated
}
pub(crate) fn of_host(&self, host: &Host) -> Coverage {
if self.scopes.iter().any(|scope| scope.swept(host.zone())) {
return Coverage::Covered;
}
let mut best = Coverage::Unstated;
for ip in host.ips() {
match self.address(ip) {
Coverage::Covered => return Coverage::Covered,
Coverage::Withheld => best = Coverage::Withheld,
Coverage::OutOfScope if best != Coverage::Withheld => {
best = Coverage::OutOfScope;
}
_ => {}
}
}
best
}
pub(crate) fn address(&self, ip: &IpAddr) -> Coverage {
if self.undecided.contains(ip) {
Coverage::Unreached
} else if self.covered.contains(ip) {
Coverage::Covered
} else if self.withheld.contains(ip) {
Coverage::Withheld
} else if self.stated {
Coverage::OutOfScope
} else {
Coverage::Unstated
}
}
pub(crate) fn endpoint(&self, address: Coverage, port: u16, protocol: Protocol) -> Coverage {
if address.is_excluded() || address == Coverage::Unreached {
return address;
}
let mut stated = false;
let mut cannot_say = false;
for scope in &self.ports {
match scope.covers(port, protocol) {
Some(true) => return Coverage::Covered,
Some(false) => stated = true,
None => cannot_say = true,
}
}
if cannot_say {
Coverage::Unstated
} else if stated {
Coverage::OutOfScope
} else {
Coverage::Unstated
}
}
}
#[cfg(test)]
mod tests {
use crate::system::privilege::Privilege;
use std::net::Ipv4Addr;
use std::time::{Duration, SystemTime};
use super::*;
use crate::config::ZondConfig;
use crate::model::exclusion::Exclusions;
use crate::model::ip::range::IpRange;
use crate::model::ip::set::IpSet;
use crate::model::parse::ip::to_set;
use crate::report::{PhaseParts, ScanKind, ScanPhase, ScanSettings, ScopeParts};
fn ip(last: u8) -> IpAddr {
IpAddr::V4(Ipv4Addr::new(203, 0, 113, last))
}
fn report(covered: &[&str], excluded: &[&str], ports: PortScope) -> ScanReport {
let exclusions = if excluded.is_empty() {
Exclusions::none()
} else {
Exclusions::new(to_set(excluded, None, None).expect("parseable ranges"))
};
let mut targets = if covered.is_empty() {
IpSet::new()
} else {
to_set(covered, None, None).expect("parseable ranges")
};
let walked = TargetScope::from_ip_set(&mut targets, &exclusions);
let scope = TargetScope::from_parts(ScopeParts {
listened: Vec::new(),
ranges: walked.ranges().to_vec(),
links: Vec::new(),
addresses: walked.addresses(),
probes: None,
ports,
protocols: Vec::new(),
excluded: walked.excluded().to_vec(),
withheld: walked.withheld(),
});
let phase = ScanPhase::from_parts(PhaseParts {
open: false,
attachments: Vec::new(),
kind: ScanKind::Discovery,
started_at: SystemTime::UNIX_EPOCH,
elapsed: Duration::from_secs(1),
privilege: Some(Privilege::Raw),
targets: scope,
settings: ScanSettings::from(&ZondConfig::default()),
failures: Vec::new(),
refusals: Vec::new(),
unroutable: Vec::new(),
refused_by_route: Vec::new(),
timed_out: Vec::new(),
icmp_rate_limited: Vec::new(),
reached_by_connect: Vec::new(),
undecided: Vec::new(),
liveness_skipped: None,
silent: Vec::new(),
stopped: None,
passes_cut: Vec::new(),
unreached: 0,
unheard_probes: 0,
probes: Vec::new(),
origin: None,
});
ScanReport::recorded("test", vec![phase], Vec::new())
}
fn phase_leaving(walked: &str, open: &str) -> ScanPhase {
let mut targets = to_set(&[walked], None, None).expect("a parseable range");
let scope = TargetScope::from_ip_set(&mut targets, &Exclusions::none());
let open = to_set(&[open], None, None).expect("a parseable range");
ScanPhase::from_parts(PhaseParts {
open: false,
attachments: Vec::new(),
kind: ScanKind::Discovery,
started_at: SystemTime::UNIX_EPOCH,
elapsed: Duration::from_secs(1),
privilege: Some(Privilege::Raw),
targets: scope,
settings: ScanSettings::from(&ZondConfig::default()),
failures: Vec::new(),
refusals: Vec::new(),
unroutable: Vec::new(),
refused_by_route: Vec::new(),
timed_out: Vec::new(),
icmp_rate_limited: Vec::new(),
reached_by_connect: Vec::new(),
undecided: open.v4().iter().copied().map(IpRange::V4).collect(),
liveness_skipped: None,
silent: Vec::new(),
stopped: None,
passes_cut: Vec::new(),
unreached: 0,
unheard_probes: 0,
probes: Vec::new(),
origin: None,
})
}
#[test]
fn an_address_a_port_phase_found_silent_is_covered() {
let mut walked = to_set(&["203.0.113.0/24"], None, None).expect("a range");
let silent = to_set(&["203.0.113.5"], None, None).expect("an address");
let phase = ScanPhase::from_parts(PhaseParts {
open: false,
attachments: Vec::new(),
kind: ScanKind::PortScan,
started_at: SystemTime::UNIX_EPOCH,
elapsed: Duration::from_secs(1),
privilege: Some(Privilege::Raw),
targets: TargetScope::from_ip_set(&mut walked, &Exclusions::none()),
settings: ScanSettings::from(&ZondConfig::default()),
failures: Vec::new(),
refusals: Vec::new(),
unroutable: Vec::new(),
refused_by_route: Vec::new(),
timed_out: Vec::new(),
icmp_rate_limited: Vec::new(),
reached_by_connect: Vec::new(),
undecided: Vec::new(),
liveness_skipped: Some(crate::report::LivenessSkip::PortsNoDearer),
silent: silent.v4().iter().copied().map(IpRange::V4).collect(),
stopped: None,
passes_cut: Vec::new(),
unreached: 0,
unheard_probes: 0,
probes: Vec::new(),
origin: None,
});
let report = ScanReport::recorded("test", vec![phase], Vec::new());
assert_eq!(
ScopeIndex::of(&report).address(&ip(5)),
Coverage::Covered,
"asked and silent, not unreached"
);
}
#[test]
fn an_address_a_phase_left_undecided_is_unreached_and_so_are_its_ports() {
let report = ScanReport::recorded(
"test",
vec![phase_leaving("203.0.113.0/24", "203.0.113.128/25")],
Vec::new(),
);
let index = ScopeIndex::of(&report);
assert_eq!(index.address(&ip(7)), Coverage::Covered, "decided");
let open = index.address(&ip(200));
assert_eq!(open, Coverage::Unreached, "walked, never decided");
assert_eq!(
index.endpoint(open, 443, Protocol::Tcp),
Coverage::Unreached,
"nothing was probed at an address nobody reached"
);
}
#[test]
fn an_address_another_phase_decided_is_covered() {
let report = ScanReport::recorded(
"test",
vec![
phase_leaving("203.0.113.0/24", "203.0.113.128/25"),
phase_leaving("203.0.113.128/25", "203.0.113.250"),
],
Vec::new(),
);
let index = ScopeIndex::of(&report);
assert_eq!(index.address(&ip(200)), Coverage::Covered);
assert_eq!(
index.address(&ip(250)),
Coverage::Unreached,
"and one neither sitting decided is still open"
);
}
#[test]
fn an_address_inside_a_walked_range_is_covered() {
let index = ScopeIndex::of(&report(&["203.0.113.0/24"], &[], PortScope::NoPorts));
assert_eq!(index.address(&ip(7)), Coverage::Covered);
}
#[test]
fn an_address_the_policy_withheld_is_reported_as_withheld() {
let index = ScopeIndex::of(&report(
&["203.0.113.0/24"],
&["203.0.113.64/26"],
PortScope::NoPorts,
));
assert_eq!(index.address(&ip(100)), Coverage::Withheld);
assert_eq!(index.address(&ip(7)), Coverage::Covered);
}
#[test]
fn an_address_outside_a_stated_scope_is_out_of_scope() {
let index = ScopeIndex::of(&report(&["203.0.113.0/25"], &[], PortScope::NoPorts));
assert_eq!(index.address(&ip(200)), Coverage::OutOfScope);
}
#[test]
fn a_report_that_states_no_scope_answers_unstated() {
let index = ScopeIndex::of(&report(&[], &[], PortScope::NoPorts));
assert!(!index.states_scope());
assert_eq!(index.address(&ip(7)), Coverage::Unstated);
}
#[test]
fn an_endpoint_is_no_better_covered_than_its_address() {
let index = ScopeIndex::of(&report(&["203.0.113.0/24"], &[], PortScope::NoPorts));
assert_eq!(
index.endpoint(Coverage::OutOfScope, 22, Protocol::Tcp),
Coverage::OutOfScope,
"a port on an address nobody walked is not covered"
);
}
}