use std::net::IpAddr;
use crate::diff::change::Coverage;
use crate::model::host::Host;
use crate::model::ip::range::IpRange;
use crate::model::port::Protocol;
use crate::scanner::report::{PortScope, ScanReport, TargetScope};
pub(crate) struct ScopeIndex {
covered: Vec<IpRange>,
withheld: Vec<IpRange>,
stated: bool,
ports: Vec<PortScope>,
scopes: Vec<TargetScope>,
}
impl ScopeIndex {
pub(crate) fn of(report: &ScanReport) -> Self {
let mut covered = Vec::new();
let mut withheld = Vec::new();
let mut ports = Vec::new();
let mut scopes = Vec::new();
for phase in report.phases() {
let scope = phase.targets();
covered.extend_from_slice(scope.ranges());
withheld.extend_from_slice(scope.excluded());
ports.push(scope.ports().clone());
scopes.push(scope.clone());
}
let stated = !covered.is_empty()
|| !withheld.is_empty()
|| scopes.iter().any(|scope| !scope.links().is_empty());
Self {
covered,
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.covered.iter().any(|range| range.contains(ip)) {
Coverage::Covered
} else if self.withheld.iter().any(|range| range.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() {
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
}
}
}