pub mod change;
pub mod host;
pub mod pairing;
pub mod port;
mod scope;
pub mod significance;
use std::time::{Duration, SystemTime};
use crate::model::host::Host;
use crate::report::{ScanKind, ScanReport};
pub use crate::diff::change::{Change, Coverage, Presence};
pub use crate::diff::host::{HostChange, HostDelta};
pub use crate::diff::pairing::HostIdentity;
pub use crate::diff::port::{
CertificateChange, PortChange, PortDelta, SecurityChange, ServiceChange,
};
pub use crate::diff::significance::Significance;
use crate::diff::port::Clocks;
use crate::diff::scope::ScopeIndex;
pub const DEFAULT_EXPIRY_THRESHOLD: Duration = Duration::from_secs(30 * 24 * 60 * 60);
#[must_use]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DiffOptions {
identity: HostIdentity,
expiry_threshold: Duration,
as_of: Option<SystemTime>,
}
impl Default for DiffOptions {
fn default() -> Self {
Self {
identity: HostIdentity::default(),
expiry_threshold: DEFAULT_EXPIRY_THRESHOLD,
as_of: None,
}
}
}
impl DiffOptions {
pub fn new() -> Self {
Self::default()
}
pub fn with_identity(mut self, identity: HostIdentity) -> Self {
self.identity = identity;
self
}
pub fn with_expiry_threshold(mut self, threshold: Duration) -> Self {
self.expiry_threshold = threshold;
self
}
pub fn as_of(mut self, at: SystemTime) -> Self {
self.as_of = Some(at);
self
}
pub fn identity(&self) -> HostIdentity {
self.identity
}
pub fn expiry_threshold(&self) -> Duration {
self.expiry_threshold
}
pub fn as_of_time(&self) -> Option<SystemTime> {
self.as_of
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Provenance {
engine_version: String,
at: SystemTime,
hosts: usize,
kinds: Vec<ScanKind>,
scope_stated: bool,
}
impl Provenance {
pub fn engine_version(&self) -> &str {
&self.engine_version
}
pub fn at(&self) -> SystemTime {
self.at
}
pub fn hosts(&self) -> usize {
self.hosts
}
pub fn kinds(&self) -> &[ScanKind] {
&self.kinds
}
pub fn states_scope(&self) -> bool {
self.scope_stated
}
}
#[derive(Debug, Clone)]
#[must_use = "a diff is the answer to what changed; dropping it discards it"]
pub struct ScanDiff {
baseline: Provenance,
current: Provenance,
hosts: Vec<HostDelta>,
}
impl ScanDiff {
pub fn between(baseline: &ScanReport, current: &ScanReport) -> Self {
Self::compare(baseline, current, &DiffOptions::default())
}
pub fn compare(baseline: &ScanReport, current: &ScanReport, options: &DiffOptions) -> Self {
let quiet = silent_in(baseline, current);
let heard = |host: &&Host| {
host.status() != crate::model::host::HostStatus::Unknown
|| !host.ips().iter().any(|ip| quiet.contains(ip))
};
let baseline_hosts: Vec<&Host> = baseline.hosts().filter(heard).collect();
let current_hosts: Vec<&Host> = current.hosts().filter(heard).collect();
let baseline_scope = ScopeIndex::of(baseline);
let current_scope = ScopeIndex::of(current);
let clocks = Clocks {
baseline: baseline.observed_at(),
current: options.as_of.unwrap_or_else(|| current.observed_at()),
expiry_threshold: options.expiry_threshold,
};
let components = pairing::components(&baseline_hosts, ¤t_hosts, options.identity);
let mut hosts: Vec<HostDelta> = components
.into_iter()
.map(|component| {
let before = merged(&baseline_hosts, &component.baseline);
let after = merged(¤t_hosts, &component.current);
let address = after
.as_ref()
.or(before.as_ref())
.map(Host::primary_ip)
.expect("a component holds a record on at least one side");
host::compare(
before.as_ref(),
after.as_ref(),
component.baseline.len(),
component.current.len(),
&baseline_scope,
¤t_scope,
&address,
&clocks,
)
})
.filter(|delta| !delta.is_empty())
.collect();
hosts.sort_by_key(HostDelta::address);
Self {
baseline: Provenance {
engine_version: baseline.engine_version().to_owned(),
at: clocks.baseline,
hosts: baseline_hosts.len(),
kinds: baseline.phases().iter().map(|phase| phase.kind()).collect(),
scope_stated: baseline_scope.states_scope(),
},
current: Provenance {
engine_version: current.engine_version().to_owned(),
at: clocks.current,
hosts: current_hosts.len(),
kinds: current.phases().iter().map(|phase| phase.kind()).collect(),
scope_stated: current_scope.states_scope(),
},
hosts,
}
}
pub fn baseline(&self) -> &Provenance {
&self.baseline
}
pub fn current(&self) -> &Provenance {
&self.current
}
pub fn hosts(&self) -> &[HostDelta] {
&self.hosts
}
pub fn is_empty(&self) -> bool {
self.hosts.is_empty()
}
pub fn summary(&self) -> DiffSummary {
let mut summary = DiffSummary::default();
for host in &self.hosts {
match host.presence() {
Presence::Added { .. } => summary.hosts_added.count(host.presence()),
Presence::Removed { .. } => summary.hosts_removed.count(host.presence()),
Presence::Both => {
if !host.changes().is_empty() || !host.ports().is_empty() {
summary.hosts_changed += 1;
}
}
}
for port in host.ports() {
if port.is_opened() {
summary.ports_opened.count(port.presence());
}
if port.is_closed() {
summary.ports_closed.count(port.presence());
}
if port.presence().is_in_both() && !port.changes().is_empty() {
summary.ports_changed += 1;
}
let mut service_moved = false;
for change in port.changes() {
match change {
PortChange::Service(_) => service_moved = true,
PortChange::Security(SecurityChange::Certificate(certificate)) => {
match certificate {
CertificateChange::Rotated { .. } => {
summary.certificates_rotated += 1;
}
CertificateChange::Expiring { .. } => {
summary.certificates_expiring += 1;
}
CertificateChange::Expired { .. } => {
summary.certificates_expired += 1;
}
CertificateChange::Presented(_)
| CertificateChange::Withdrawn(_) => {}
}
}
PortChange::State(_) => {}
PortChange::Security(
SecurityChange::TlsVersion(_)
| SecurityChange::CipherSuite(_)
| SecurityChange::Alpn { .. },
) => {}
PortChange::Findings { .. } => {}
}
}
if service_moved {
summary.services_changed += 1;
}
}
}
summary
}
}
#[non_exhaustive]
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct Confirmed {
pub total: usize,
pub confirmed: usize,
}
impl Confirmed {
fn count(&mut self, presence: Presence) {
self.total += 1;
if presence.is_confirmed() {
self.confirmed += 1;
}
}
}
#[non_exhaustive]
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct DiffSummary {
pub hosts_added: Confirmed,
pub hosts_removed: Confirmed,
pub hosts_changed: usize,
pub ports_opened: Confirmed,
pub ports_closed: Confirmed,
pub ports_changed: usize,
pub services_changed: usize,
pub certificates_rotated: usize,
pub certificates_expiring: usize,
pub certificates_expired: usize,
}
fn merged(hosts: &[&Host], indices: &[usize]) -> Option<Host> {
let (first, rest) = indices.split_first()?;
let mut merged = hosts[*first].clone();
for index in rest {
merged.merge(hosts[*index].clone());
}
Some(merged)
}
fn silent_in(baseline: &ScanReport, current: &ScanReport) -> crate::model::ip::set::IpSet {
let mut quiet = crate::model::ip::set::IpSet::new();
for phase in baseline.phases().iter().chain(current.phases()) {
for range in phase.silent() {
quiet.insert_range(*range);
}
}
quiet.canonicalize();
quiet
}
#[cfg(test)]
mod tests {
use crate::system::privilege::Privilege;
use std::net::{IpAddr, Ipv4Addr};
use std::time::Duration;
use super::*;
use crate::config::ZondConfig;
use crate::model::exclusion::Exclusions;
use crate::model::host::os::OsFingerprint;
use crate::model::host::{Host, HostStatus};
use crate::model::parse::ip::to_set;
use crate::model::port::security::CertificateInfo;
use crate::model::port::{Port, PortSet, PortState, Protocol, Security, Service};
use crate::report::{
PhaseParts, PortScope, ScanKind, ScanPhase, ScanReport, ScanSettings, ScopeParts,
TargetScope,
};
const DAY: Duration = Duration::from_secs(24 * 60 * 60);
fn ip(last: u8) -> IpAddr {
IpAddr::V4(Ipv4Addr::new(203, 0, 113, last))
}
fn host(last: u8) -> Host {
let mut host = Host::new(ip(last));
host.set_status(HostStatus::Up);
host
}
const PROMPT: Duration = Duration::ZERO;
fn found_silent(covered: &str, silent: &str, at: SystemTime) -> ScanReport {
let mut targets = to_set(&[covered], None, None).expect("a parseable range");
let silent = to_set(&[silent], None, None).expect("a parseable range");
let phase = ScanPhase::from_parts(PhaseParts {
open: false,
attachments: Vec::new(),
kind: ScanKind::PortScan,
started_at: at,
elapsed: PROMPT,
privilege: Some(Privilege::Raw),
targets: TargetScope::from_ip_set(&mut targets, &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(crate::model::ip::range::IpRange::V4)
.collect(),
stopped: None,
passes_cut: Vec::new(),
unreached: 0,
unheard_probes: 0,
probes: Vec::new(),
origin: None,
});
ScanReport::recorded("test", vec![phase], Vec::new())
}
fn unscoped(hosts: Vec<Host>) -> ScanReport {
ScanReport::recorded("test", Vec::new(), hosts)
}
fn scoped(hosts: Vec<Host>, covered: &str, excluded: &[&str], at: SystemTime) -> ScanReport {
let mut targets = to_set(&[covered], None, None).expect("a parseable range");
let exclusions = if excluded.is_empty() {
Exclusions::none()
} else {
Exclusions::new(to_set(excluded, None, None).expect("a parseable range"))
};
let scope = TargetScope::from_ip_set(&mut targets, &exclusions);
let phase = ScanPhase::from_parts(PhaseParts {
open: false,
attachments: Vec::new(),
kind: ScanKind::Discovery,
started_at: at,
elapsed: PROMPT,
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], hosts)
}
fn port_scanned(
hosts: Vec<Host>,
covered: &str,
ports: PortScope,
at: SystemTime,
) -> ScanReport {
let mut targets = to_set(&[covered], None, None).expect("a parseable range");
let scope = TargetScope::from_ip_set(&mut targets, &Exclusions::none());
let scope = TargetScope::from_parts(ScopeParts {
listened: Vec::new(),
ranges: scope.ranges().to_vec(),
links: Vec::new(),
addresses: scope.addresses(),
probes: None,
ports,
protocols: vec![Protocol::Tcp],
excluded: Vec::new(),
withheld: 0,
});
let phase = ScanPhase::from_parts(PhaseParts {
open: false,
attachments: Vec::new(),
kind: ScanKind::PortScan,
started_at: at,
elapsed: PROMPT,
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], hosts)
}
fn swept(hosts: Vec<Host>, covered: &str, link: &str, at: SystemTime) -> ScanReport {
use crate::model::ip::scoped::Zone;
let mut targets = to_set(&[covered], None, None).expect("a parseable range");
let scope = TargetScope::from_ip_set(&mut targets, &Exclusions::none());
let scope = TargetScope::from_parts(ScopeParts {
listened: Vec::new(),
ranges: scope.ranges().to_vec(),
links: vec![Zone::new(1, link)],
addresses: scope.addresses(),
probes: None,
ports: PortScope::NoPorts,
protocols: Vec::new(),
excluded: Vec::new(),
withheld: 0,
});
let phase = ScanPhase::from_parts(PhaseParts {
open: false,
attachments: Vec::new(),
kind: ScanKind::Discovery,
started_at: at,
elapsed: PROMPT,
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], hosts)
}
fn neighbour(last: u16, link: &str) -> Host {
use crate::model::ip::scoped::Zone;
use std::net::Ipv6Addr;
let mut host = Host::new(IpAddr::V6(Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, last)));
host.set_status(HostStatus::Up);
host.set_zone(Zone::new(1, link));
host
}
fn ports(spec: &str) -> PortSet {
PortSet::try_from(spec).expect("a port specification")
}
fn certificate(fingerprint: &str, start: SystemTime, end: SystemTime) -> Security {
Security::new().with_certificate(CertificateInfo::new(
"example.test",
"Test CA",
start,
end,
fingerprint,
))
}
#[test]
fn two_scans_that_found_the_same_things_report_nothing() {
let build = || {
let mut h = host(10);
h.add_port(Port::new(22, Protocol::Tcp, PortState::Open));
unscoped(vec![h])
};
let diff = ScanDiff::between(&build(), &build());
assert!(diff.is_empty(), "an unchanged network is an empty diff");
assert_eq!(diff.summary(), DiffSummary::default());
}
#[test]
fn a_round_trip_time_is_not_a_change() {
let mut before = host(10);
before.add_rtt(Duration::from_millis(4));
let mut after = host(10);
after.add_rtt(Duration::from_millis(91));
let diff = ScanDiff::between(&unscoped(vec![before]), &unscoped(vec![after]));
assert!(
diff.is_empty(),
"how fast the host answered is a measurement of the scan, not a finding"
);
}
#[test]
fn a_more_confident_reading_of_the_same_system_is_not_a_change() {
let mut before = host(10);
before.set_os(OsFingerprint::new("Linux", 74).with_family("Unix-like"));
let mut after = host(10);
after.set_os(OsFingerprint::new("Linux", 98).with_family("Unix-like"));
let diff = ScanDiff::between(&unscoped(vec![before]), &unscoped(vec![after]));
assert!(
diff.is_empty(),
"the fingerprinter growing surer of the same answer is not a change"
);
}
#[test]
fn a_different_system_is_a_change() {
let mut before = host(10);
before.set_os(OsFingerprint::new("Linux", 90));
let mut after = host(10);
after.set_os(OsFingerprint::new("Windows", 90));
let diff = ScanDiff::between(&unscoped(vec![before]), &unscoped(vec![after]));
let changes = diff.hosts()[0].changes();
assert!(matches!(changes[0], HostChange::Os(_)), "{changes:?}");
}
#[test]
fn a_host_that_appeared_where_the_baseline_looked_is_confirmed() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
let before = scoped(vec![host(10)], "203.0.113.0/24", &[], at);
let after = scoped(vec![host(10), host(11)], "203.0.113.0/24", &[], at + DAY);
let diff = ScanDiff::compare(&before, &after, &DiffOptions::default());
let appeared = diff
.hosts()
.iter()
.find(|delta| delta.address() == ip(11))
.expect("the new host is in the diff");
assert_eq!(
appeared.presence(),
Presence::Added {
before: Coverage::Covered
}
);
assert!(appeared.presence().is_confirmed());
assert_eq!(diff.summary().hosts_added.confirmed, 1);
}
#[test]
fn a_host_that_appeared_where_the_baseline_never_looked_is_not_confirmed() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
let before = scoped(vec![host(10)], "203.0.113.0/26", &[], at);
let after = scoped(vec![host(10), host(200)], "203.0.113.0/24", &[], at + DAY);
let diff = ScanDiff::between(&before, &after);
let appeared = diff
.hosts()
.iter()
.find(|delta| delta.address() == ip(200))
.expect("the new host is in the diff");
assert_eq!(
appeared.presence(),
Presence::Added {
before: Coverage::OutOfScope
}
);
assert!(!appeared.presence().is_confirmed());
let summary = diff.summary();
assert_eq!(summary.hosts_added.total, 1);
assert_eq!(
summary.hosts_added.confirmed, 0,
"a host nobody had looked for is not a host that appeared"
);
}
#[test]
fn a_host_the_current_scan_was_forbidden_reads_as_withheld() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
let before = scoped(vec![host(10), host(11)], "203.0.113.0/24", &[], at);
let after = scoped(
vec![host(10)],
"203.0.113.0/24",
&["203.0.113.11"],
at + DAY,
);
let diff = ScanDiff::between(&before, &after);
let gone = diff
.hosts()
.iter()
.find(|delta| delta.address() == ip(11))
.expect("the missing host is in the diff");
assert_eq!(
gone.presence(),
Presence::Removed {
after: Coverage::Withheld
},
"an address a policy forbade is not an address that went quiet"
);
assert!(!gone.presence().is_confirmed());
}
#[test]
fn a_report_that_states_no_scope_answers_unstated() {
let before = unscoped(vec![host(10), host(11)]);
let after = unscoped(vec![host(10)]);
let diff = ScanDiff::between(&before, &after);
let gone = diff
.hosts()
.iter()
.find(|delta| delta.address() == ip(11))
.expect("the missing host is in the diff");
assert_eq!(
gone.presence(),
Presence::Removed {
after: Coverage::Unstated
},
"a report that does not say what it walked cannot confirm a disappearance"
);
assert!(!gone.presence().is_confirmed());
assert_eq!(diff.summary().hosts_removed.confirmed, 0);
}
#[test]
fn a_host_that_went_quiet_where_the_scan_looked_is_confirmed() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
let before = scoped(vec![host(10), host(11)], "203.0.113.0/24", &[], at);
let after = scoped(vec![host(10)], "203.0.113.0/24", &[], at + DAY);
let diff = ScanDiff::between(&before, &after);
let summary = diff.summary();
assert_eq!(summary.hosts_removed.total, 1);
assert_eq!(summary.hosts_removed.confirmed, 1);
}
#[test]
fn a_port_that_opened_is_counted_once() {
let mut before = host(10);
before.add_port(Port::new(8080, Protocol::Tcp, PortState::Closed));
let mut after = host(10);
after.add_port(Port::new(8080, Protocol::Tcp, PortState::Open));
let diff = ScanDiff::between(&unscoped(vec![before]), &unscoped(vec![after]));
let delta = &diff.hosts()[0].ports()[0];
assert!(delta.is_opened());
assert!(!delta.is_closed());
assert!(matches!(
delta.changes()[0],
PortChange::State(Change {
before: PortState::Closed,
after: PortState::Open
})
));
let summary = diff.summary();
assert_eq!(summary.ports_opened.total, 1);
assert_eq!(
summary.ports_opened.confirmed, 1,
"both scans hold a record, so nothing is being assumed"
);
assert_eq!(summary.ports_closed.total, 0);
}
#[test]
fn a_port_only_the_later_scan_recorded_is_not_a_confirmed_opening() {
let before = host(10);
let mut after = host(10);
after.add_port(Port::new(8080, Protocol::Tcp, PortState::Open));
let diff = ScanDiff::between(&unscoped(vec![before]), &unscoped(vec![after]));
let delta = &diff.hosts()[0].ports()[0];
assert!(delta.is_opened());
assert_eq!(
delta.presence(),
Presence::Added {
before: Coverage::Unstated
},
"a scope records addresses, not the ports walked on each"
);
let summary = diff.summary();
assert_eq!(summary.ports_opened.total, 1);
assert_eq!(summary.ports_opened.confirmed, 0);
}
#[test]
fn an_endpoint_identical_in_both_scans_is_left_out() {
let mut before = host(10);
before.add_port(Port::new(22, Protocol::Tcp, PortState::Open));
before.add_port(Port::new(80, Protocol::Tcp, PortState::Closed));
let mut after = host(10);
after.add_port(Port::new(22, Protocol::Tcp, PortState::Open));
after.add_port(Port::new(80, Protocol::Tcp, PortState::Open));
let diff = ScanDiff::between(&unscoped(vec![before]), &unscoped(vec![after]));
let ports = diff.hosts()[0].ports();
assert_eq!(ports.len(), 1, "only the endpoint that moved: {ports:?}");
assert_eq!(ports[0].number(), 80);
}
#[test]
fn a_service_version_change_is_reported() {
let mut before = host(10);
before.add_port(
Port::new(80, Protocol::Tcp, PortState::Open)
.with_service(Service::new("http", 90).with_version("1.18.0")),
);
let mut after = host(10);
after.add_port(
Port::new(80, Protocol::Tcp, PortState::Open)
.with_service(Service::new("http", 90).with_version("1.24.0")),
);
let diff = ScanDiff::between(&unscoped(vec![before]), &unscoped(vec![after]));
let changes = diff.hosts()[0].ports()[0].changes();
let PortChange::Service(ServiceChange::Version(version)) = &changes[0] else {
panic!("expected a version change, got {changes:?}");
};
assert_eq!(version.before.as_deref(), Some("1.18.0"));
assert_eq!(version.after.as_deref(), Some("1.24.0"));
assert_eq!(diff.summary().services_changed, 1);
}
#[test]
fn a_service_identified_at_a_different_confidence_is_not_a_change() {
let mut before = host(10);
before.add_port(
Port::new(80, Protocol::Tcp, PortState::Open)
.with_service(Service::new("http", 60).with_version("1.18.0")),
);
let mut after = host(10);
after.add_port(
Port::new(80, Protocol::Tcp, PortState::Open)
.with_service(Service::new("http", 99).with_version("1.18.0")),
);
let diff = ScanDiff::between(&unscoped(vec![before]), &unscoped(vec![after]));
assert!(
diff.is_empty(),
"how sure the fingerprinter was is not a finding about the service"
);
}
#[test]
fn a_port_that_opened_where_the_baseline_walked_it_is_confirmed() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
let mut after = host(10);
after.add_port(Port::new(443, Protocol::Tcp, PortState::Open));
let diff = ScanDiff::between(
&port_scanned(
vec![host(10)],
"203.0.113.0/24",
PortScope::Every(ports("1-1024")),
at,
),
&port_scanned(
vec![after],
"203.0.113.0/24",
PortScope::Every(ports("1-1024")),
at + DAY,
),
);
let delta = &diff.hosts()[0].ports()[0];
assert_eq!(
delta.presence(),
Presence::Added {
before: Coverage::Covered
},
"the baseline walked 443 and recorded nothing there, so it opened"
);
assert_eq!(diff.summary().ports_opened.confirmed, 1);
}
#[test]
fn a_port_the_baseline_never_walked_is_not_a_confirmed_opening() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
let mut after = host(10);
after.add_port(Port::new(8080, Protocol::Tcp, PortState::Open));
let diff = ScanDiff::between(
&port_scanned(
vec![host(10)],
"203.0.113.0/24",
PortScope::Every(ports("1-1024")),
at,
),
&port_scanned(
vec![after],
"203.0.113.0/24",
PortScope::Every(ports("1-1024,8080")),
at + DAY,
),
);
let delta = &diff.hosts()[0].ports()[0];
assert_eq!(
delta.presence(),
Presence::Added {
before: Coverage::OutOfScope
},
"8080 was outside the baseline's port set, so nothing there is news"
);
let summary = diff.summary();
assert_eq!(summary.ports_opened.total, 1);
assert_eq!(summary.ports_opened.confirmed, 0);
}
#[test]
fn a_port_the_baseline_ran_short_of_is_not_a_confirmed_opening() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
let mut before = host(10);
before.add_port(Port::new(443, Protocol::Tcp, PortState::Unasked));
let mut after = host(10);
after.add_port(Port::new(443, Protocol::Tcp, PortState::Open));
let diff = ScanDiff::between(
&port_scanned(
vec![before],
"203.0.113.0/24",
PortScope::Every(ports("1-1024")),
at,
),
&port_scanned(
vec![after],
"203.0.113.0/24",
PortScope::Every(ports("1-1024")),
at + DAY,
),
);
let delta = &diff.hosts()[0].ports()[0];
assert_eq!(
delta.presence(),
Presence::Added {
before: Coverage::Unreached
},
"an unasked port read as a verdict the baseline reached"
);
assert!(
delta.baseline().is_none(),
"a port nobody probed is not a record of anything"
);
assert!(
delta.changes().is_empty(),
"an appearance carries no field-level changes"
);
let summary = diff.summary();
assert_eq!(summary.ports_opened.total, 1);
assert_eq!(
summary.ports_opened.confirmed, 0,
"a scan that ran short confirmed an opening it never looked for"
);
}
#[test]
fn a_port_the_later_scan_ran_short_of_is_not_a_confirmed_closing() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
let mut before = host(10);
before.add_port(Port::new(443, Protocol::Tcp, PortState::Open));
let mut after = host(10);
after.add_port(Port::new(443, Protocol::Tcp, PortState::Unasked));
let diff = ScanDiff::between(
&port_scanned(
vec![before],
"203.0.113.0/24",
PortScope::Every(ports("1-1024")),
at,
),
&port_scanned(
vec![after],
"203.0.113.0/24",
PortScope::Every(ports("1-1024")),
at + DAY,
),
);
let delta = &diff.hosts()[0].ports()[0];
assert_eq!(
delta.presence(),
Presence::Removed {
after: Coverage::Unreached
},
);
let summary = diff.summary();
assert_eq!(summary.ports_closed.total, 1);
assert_eq!(summary.ports_closed.confirmed, 0);
}
#[test]
fn an_endpoint_neither_scan_has_a_finding_for_is_reported_by_neither() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
let mut before = host(10);
before.add_port(Port::new(443, Protocol::Tcp, PortState::Unasked));
let diff = ScanDiff::between(
&port_scanned(
vec![before],
"203.0.113.0/24",
PortScope::Every(ports("1-1024")),
at,
),
&port_scanned(
vec![host(10)],
"203.0.113.0/24",
PortScope::Every(ports("1-1024")),
at + DAY,
),
);
assert!(diff.is_empty(), "{:?}", diff.hosts());
}
#[test]
fn a_port_that_opened_on_ground_both_scans_walked_is_urgent() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
let mut before = host(10);
before.add_port(Port::new(443, Protocol::Tcp, PortState::Closed));
let mut after = host(10);
after.add_port(Port::new(443, Protocol::Tcp, PortState::Open));
let diff = ScanDiff::between(
&port_scanned(
vec![before],
"203.0.113.0/24",
PortScope::Every(ports("1-1024")),
at,
),
&port_scanned(
vec![after],
"203.0.113.0/24",
PortScope::Every(ports("1-1024")),
at + DAY,
),
);
assert_eq!(
diff.hosts()[0].ports()[0].significance(),
Significance::Urgent
);
assert_eq!(diff.hosts()[0].significance(), Significance::Urgent);
assert_eq!(diff.significance(), Significance::Urgent);
}
#[test]
fn the_same_opening_against_a_scan_that_ran_short_is_routine() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
let mut before = host(10);
before.add_port(Port::new(443, Protocol::Tcp, PortState::Unasked));
let mut after = host(10);
after.add_port(Port::new(443, Protocol::Tcp, PortState::Open));
let diff = ScanDiff::between(
&port_scanned(
vec![before],
"203.0.113.0/24",
PortScope::Every(ports("1-1024")),
at,
),
&port_scanned(
vec![after],
"203.0.113.0/24",
PortScope::Every(ports("1-1024")),
at + DAY,
),
);
let port = &diff.hosts()[0].ports()[0];
assert!(port.is_opened(), "the record still says the port is open");
assert_eq!(
port.significance(),
Significance::Routine,
"a port nobody had checked ranked as one that opened"
);
assert_eq!(diff.significance(), Significance::Routine);
}
#[test]
fn a_host_found_by_a_wider_scan_is_routine_open_ports_and_all() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
let mut arrival = host(200);
arrival.add_port(Port::new(22, Protocol::Tcp, PortState::Open));
let diff = ScanDiff::between(
&scoped(vec![host(10)], "203.0.113.0/26", &[], at),
&scoped(vec![host(10), arrival], "203.0.113.0/24", &[], at + DAY),
);
let appeared = diff
.hosts()
.iter()
.find(|delta| delta.address() == ip(200))
.expect("the new host is in the diff");
assert!(!appeared.presence().is_confirmed());
assert_eq!(
appeared.significance(),
Significance::Routine,
"a host on ground nobody had walked was graded as one that arrived"
);
assert_eq!(diff.significance(), Significance::Routine);
}
#[test]
fn a_protocol_a_host_started_accepting_is_a_notable_change() {
use crate::model::host::IpProtocolState;
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
let mut before = host(10);
before.record_ip_protocol(47, IpProtocolState::Closed);
let mut after = host(10);
after.record_ip_protocol(47, IpProtocolState::Open);
let diff = ScanDiff::between(
&scoped(vec![before], "203.0.113.0/24", &[], at),
&scoped(vec![after], "203.0.113.0/24", &[], at + DAY),
);
let delta = &diff.hosts()[0];
let moved = delta
.changes()
.iter()
.find_map(|change| match change {
HostChange::IpProtocols { changed } => Some(changed),
_ => None,
})
.expect("the protocol moved");
assert_eq!(moved.len(), 1);
assert_eq!(moved[0].protocol, 47);
assert_eq!(moved[0].state.before, IpProtocolState::Closed);
assert_eq!(moved[0].state.after, IpProtocolState::Open);
assert_eq!(diff.significance(), Significance::Notable);
}
#[test]
fn a_protocol_only_one_scan_established_anything_about_is_not_a_change() {
use crate::model::host::IpProtocolState;
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
let mut before = host(10);
before.record_ip_protocol(47, IpProtocolState::Unasked);
let mut after = host(10);
after.record_ip_protocol(47, IpProtocolState::Open);
after.record_ip_protocol(89, IpProtocolState::Closed);
let diff = ScanDiff::between(
&scoped(vec![before], "203.0.113.0/24", &[], at),
&scoped(vec![after], "203.0.113.0/24", &[], at + DAY),
);
assert!(diff.is_empty(), "{:?}", diff.hosts());
}
#[test]
fn a_diff_of_nothing_but_drift_is_routine() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
let mut before = host(10);
before.set_hostname(Some("old.example.test".to_string()));
let mut after = host(10);
after.set_hostname(Some("new.example.test".to_string()));
let diff = ScanDiff::between(
&scoped(vec![before], "203.0.113.0/24", &[], at),
&scoped(vec![after], "203.0.113.0/24", &[], at + DAY),
);
assert!(!diff.is_empty(), "the hostname did move");
assert_eq!(diff.significance(), Significance::Routine);
}
#[test]
fn a_baseline_that_only_swept_never_walked_any_port() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
let mut after = host(10);
after.add_port(Port::new(443, Protocol::Tcp, PortState::Open));
let diff = ScanDiff::between(
&scoped(vec![host(10)], "203.0.113.0/24", &[], at),
&port_scanned(
vec![after],
"203.0.113.0/24",
PortScope::Every(ports("1-1024")),
at + DAY,
),
);
assert_eq!(
diff.hosts()[0].ports()[0].presence(),
Presence::Added {
before: Coverage::OutOfScope
},
"a sweep walks addresses; it did not probe this endpoint and can say so"
);
}
#[test]
fn a_baseline_whose_addresses_disagreed_about_ports_cannot_confirm_one() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
let mut after = host(10);
after.add_port(Port::new(443, Protocol::Tcp, PortState::Open));
let diff = ScanDiff::between(
&port_scanned(
vec![host(10)],
"203.0.113.0/24",
PortScope::Mixed(ports("80,443")),
at,
),
&port_scanned(
vec![after],
"203.0.113.0/24",
PortScope::Every(ports("80,443")),
at + DAY,
),
);
assert_eq!(
diff.hosts()[0].ports()[0].presence(),
Presence::Added {
before: Coverage::Unstated
},
"443 was walked for some addresses; the scope cannot say it was for this one"
);
}
#[test]
fn a_phase_that_cannot_say_vetoes_one_that_can() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
let mut after = host(10);
after.add_port(Port::new(443, Protocol::Tcp, PortState::Open));
let sweep = scoped(vec![host(10)], "203.0.113.0/24", &[], at);
let unstated = port_scanned(vec![host(10)], "203.0.113.0/24", PortScope::Unstated, at);
let mut phases = sweep.phases().to_vec();
phases.extend(unstated.phases().iter().cloned());
let baseline = ScanReport::recorded("test", phases, vec![host(10)]);
let diff = ScanDiff::between(
&baseline,
&port_scanned(
vec![after],
"203.0.113.0/24",
PortScope::Every(ports("1-1024")),
at + DAY,
),
);
assert_eq!(
diff.hosts()[0].ports()[0].presence(),
Presence::Added {
before: Coverage::Unstated
},
"the sweep's certainty about its own half is not the job's"
);
}
#[test]
fn a_neighbour_on_a_swept_link_is_covered_ground() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
let diff = ScanDiff::between(
&swept(vec![host(10)], "203.0.113.0/24", "en1", at),
&swept(
vec![host(10), neighbour(0x41a, "en1")],
"203.0.113.0/24",
"en1",
at + DAY,
),
);
let appeared = diff
.hosts()
.iter()
.find(|delta| delta.address().is_ipv6())
.expect("the neighbour is in the diff");
assert_eq!(
appeared.presence(),
Presence::Added {
before: Coverage::Covered
},
"the earlier scan swept this link and did not find it"
);
assert!(appeared.presence().is_confirmed());
assert_eq!(diff.summary().hosts_added.confirmed, 1);
}
#[test]
fn a_neighbour_on_a_link_that_was_not_swept_is_not_confirmed() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
let diff = ScanDiff::between(
&swept(vec![host(10)], "203.0.113.0/24", "en0", at),
&swept(
vec![host(10), neighbour(0x41a, "en1")],
"203.0.113.0/24",
"en1",
at + DAY,
),
);
let appeared = diff
.hosts()
.iter()
.find(|delta| delta.address().is_ipv6())
.expect("the neighbour is in the diff");
assert_eq!(
appeared.presence(),
Presence::Added {
before: Coverage::OutOfScope
},
"fe80::1 on two interfaces is two machines"
);
assert_eq!(diff.summary().hosts_added.confirmed, 0);
}
#[test]
fn a_host_on_a_swept_link_is_covered_whatever_it_is_keyed_by() {
use crate::model::ip::scoped::Zone;
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
let mut routable = Host::new("2001:db8::4".parse::<IpAddr>().expect("valid"));
routable.set_status(HostStatus::Up);
routable.set_zone(Zone::new(1, "en1"));
let diff = ScanDiff::between(
&swept(vec![host(10), routable], "203.0.113.0/24", "en1", at),
&swept(vec![host(10)], "203.0.113.0/24", "en1", at + DAY),
);
let gone = diff
.hosts()
.iter()
.find(|delta| delta.address().is_ipv6())
.expect("the host is in the diff");
assert_eq!(
gone.presence(),
Presence::Removed {
after: Coverage::Covered
},
"the later scan swept the link this host was found on"
);
assert_eq!(diff.summary().hosts_removed.confirmed, 1);
}
#[test]
fn a_host_with_no_link_is_not_covered_by_a_sweep() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
let mut routable = Host::new("2001:db8::1".parse::<IpAddr>().expect("valid"));
routable.set_status(HostStatus::Up);
let diff = ScanDiff::between(
&swept(vec![host(10)], "203.0.113.0/24", "en1", at),
&swept(vec![host(10), routable], "203.0.113.0/24", "en1", at + DAY),
);
let appeared = diff
.hosts()
.iter()
.find(|delta| delta.address().is_ipv6())
.expect("the host is in the diff");
assert!(
!appeared.presence().is_confirmed(),
"a host with no zone was not found on any link"
);
}
#[test]
fn a_host_is_covered_by_any_address_it_answers_at() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
let mut dual = Host::new("2001:db8::5".parse::<IpAddr>().expect("valid"));
dual.set_status(HostStatus::Up);
dual.add_ip(ip(11));
let diff = ScanDiff::between(
&scoped(vec![host(10)], "203.0.113.0/24", &[], at),
&scoped(vec![host(10), dual], "203.0.113.0/24", &[], at + DAY),
);
let appeared = diff
.hosts()
.iter()
.find(|delta| delta.address().is_ipv6())
.expect("the host is in the diff");
assert_eq!(
appeared.presence(),
Presence::Added {
before: Coverage::Covered
},
"the earlier scan walked 203.0.113.11 and found nothing there"
);
}
#[test]
fn a_rotated_certificate_is_reported() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000_000);
let mut before = host(10);
before.add_port(
Port::new(443, Protocol::Tcp, PortState::Open).with_security(certificate(
"aaaa",
at - 90 * DAY,
at + 300 * DAY,
)),
);
let mut after = host(10);
after.add_port(
Port::new(443, Protocol::Tcp, PortState::Open).with_security(certificate(
"bbbb",
at,
at + 365 * DAY,
)),
);
let diff = ScanDiff::between(
&scoped(vec![before], "203.0.113.0/24", &[], at),
&scoped(vec![after], "203.0.113.0/24", &[], at + DAY),
);
let changes = diff.hosts()[0].ports()[0].changes();
assert!(
changes.iter().any(|change| matches!(
change,
PortChange::Security(SecurityChange::Certificate(
CertificateChange::Rotated { .. }
))
)),
"{changes:?}"
);
assert_eq!(diff.summary().certificates_rotated, 1);
}
#[test]
fn a_certificate_nobody_touched_reports_the_threshold_it_crossed() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000_000);
let expires = at + 90 * DAY;
let same = || certificate("aaaa", at - 90 * DAY, expires);
let mut before = host(10);
before.add_port(Port::new(443, Protocol::Tcp, PortState::Open).with_security(same()));
let mut after = host(10);
after.add_port(Port::new(443, Protocol::Tcp, PortState::Open).with_security(same()));
let diff = ScanDiff::between(
&scoped(vec![before], "203.0.113.0/24", &[], at),
&scoped(vec![after], "203.0.113.0/24", &[], at + 80 * DAY),
);
let changes = diff.hosts()[0].ports()[0].changes();
let Some(PortChange::Security(SecurityChange::Certificate(CertificateChange::Expiring {
remaining,
..
}))) = changes.first()
else {
panic!("expected an expiry crossing, got {changes:?}");
};
assert_eq!(*remaining, 10 * DAY);
assert_eq!(diff.summary().certificates_expiring, 1);
}
#[test]
fn an_expiry_horizon_past_the_end_of_time_reports_rather_than_panics() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000_000);
let endpoint = |fingerprint: &str| {
let mut host = host(10);
host.add_port(
Port::new(443, Protocol::Tcp, PortState::Open).with_security(certificate(
fingerprint,
at - 90 * DAY,
at + 900 * DAY,
)),
);
host
};
let forever = DiffOptions::new().with_expiry_threshold(Duration::MAX);
let untouched = ScanDiff::compare(
&scoped(vec![endpoint("aaaa")], "203.0.113.0/24", &[], at),
&scoped(vec![endpoint("aaaa")], "203.0.113.0/24", &[], at + DAY),
&forever,
);
assert_eq!(untouched.summary().certificates_expiring, 0);
let rotated = ScanDiff::compare(
&scoped(vec![endpoint("aaaa")], "203.0.113.0/24", &[], at),
&scoped(vec![endpoint("bbbb")], "203.0.113.0/24", &[], at + DAY),
&forever,
);
assert_eq!(rotated.summary().certificates_expiring, 1);
}
#[test]
fn a_rotation_onto_an_expiring_certificate_still_reports_the_expiry() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000_000);
let mut before = host(10);
before.add_port(
Port::new(443, Protocol::Tcp, PortState::Open).with_security(certificate(
"aaaa",
at - 90 * DAY,
at + 20 * DAY,
)),
);
let mut after = host(10);
after.add_port(
Port::new(443, Protocol::Tcp, PortState::Open).with_security(certificate(
"bbbb",
at,
at + 22 * DAY,
)),
);
let diff = ScanDiff::between(
&scoped(vec![before], "203.0.113.0/24", &[], at),
&scoped(vec![after], "203.0.113.0/24", &[], at + 7 * DAY),
);
let changes = diff.hosts()[0].ports()[0].changes();
assert!(
changes.iter().any(|change| matches!(
change,
PortChange::Security(SecurityChange::Certificate(
CertificateChange::Rotated { .. }
))
)),
"{changes:?}"
);
assert_eq!(diff.summary().certificates_rotated, 1);
assert_eq!(
diff.summary().certificates_expiring,
1,
"the certificate presented now is inside the threshold and the \
baseline never saw it: {changes:?}"
);
}
#[test]
fn a_rotation_onto_an_already_lapsed_certificate_still_reports_it() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000_000);
let mut before = host(10);
before.add_port(
Port::new(443, Protocol::Tcp, PortState::Open).with_security(certificate(
"aaaa",
at - 400 * DAY,
at - DAY,
)),
);
let mut after = host(10);
after.add_port(
Port::new(443, Protocol::Tcp, PortState::Open).with_security(certificate(
"bbbb",
at - 400 * DAY,
at - 2 * DAY,
)),
);
let diff = ScanDiff::between(
&scoped(vec![before], "203.0.113.0/24", &[], at),
&scoped(vec![after], "203.0.113.0/24", &[], at + DAY),
);
assert_eq!(diff.summary().certificates_rotated, 1);
assert_eq!(
diff.summary().certificates_expired,
1,
"{:?}",
diff.hosts()[0].ports()[0].changes()
);
}
#[test]
fn a_certificate_that_was_already_expiring_is_not_reported_again() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000_000);
let expires = at + 20 * DAY;
let same = || certificate("aaaa", at - 90 * DAY, expires);
let mut before = host(10);
before.add_port(Port::new(443, Protocol::Tcp, PortState::Open).with_security(same()));
let mut after = host(10);
after.add_port(Port::new(443, Protocol::Tcp, PortState::Open).with_security(same()));
let diff = ScanDiff::between(
&scoped(vec![before], "203.0.113.0/24", &[], at),
&scoped(vec![after], "203.0.113.0/24", &[], at + 5 * DAY),
);
assert!(
diff.is_empty(),
"a renewal queue reports a certificate once, not on every scan"
);
}
#[test]
fn a_certificate_that_lapsed_between_the_scans_is_reported() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000_000);
let expires = at + 10 * DAY;
let same = || certificate("aaaa", at - 90 * DAY, expires);
let mut before = host(10);
before.add_port(Port::new(443, Protocol::Tcp, PortState::Open).with_security(same()));
let mut after = host(10);
after.add_port(Port::new(443, Protocol::Tcp, PortState::Open).with_security(same()));
let diff = ScanDiff::between(
&scoped(vec![before], "203.0.113.0/24", &[], at),
&scoped(vec![after], "203.0.113.0/24", &[], at + 40 * DAY),
);
let changes = diff.hosts()[0].ports()[0].changes();
let Some(PortChange::Security(SecurityChange::Certificate(CertificateChange::Expired {
since,
..
}))) = changes.first()
else {
panic!("expected a lapse, got {changes:?}");
};
assert_eq!(*since, 30 * DAY);
assert_eq!(diff.summary().certificates_expired, 1);
}
#[test]
fn asking_where_a_stored_scan_stands_today_moves_only_the_current_clock() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000_000);
let expires = at + 90 * DAY;
let same = || certificate("aaaa", at - 90 * DAY, expires);
let mut before = host(10);
before.add_port(Port::new(443, Protocol::Tcp, PortState::Open).with_security(same()));
let mut after = host(10);
after.add_port(Port::new(443, Protocol::Tcp, PortState::Open).with_security(same()));
let baseline = scoped(vec![before], "203.0.113.0/24", &[], at);
let current = scoped(vec![after], "203.0.113.0/24", &[], at + DAY);
assert!(ScanDiff::between(&baseline, ¤t).is_empty());
let asked_later = ScanDiff::compare(
&baseline,
¤t,
&DiffOptions::new().as_of(at + 85 * DAY),
);
assert_eq!(
asked_later.summary().certificates_expiring,
1,
"asked as of a later moment, the certificate is inside the threshold"
);
}
#[test]
fn a_host_whose_primary_address_moved_pairs_by_a_shared_one() {
let mut before = host(10);
before.add_ip(ip(11));
let mut after = Host::new(ip(11));
after.set_status(HostStatus::Up);
after.add_ip(ip(10));
after.add_port(Port::new(22, Protocol::Tcp, PortState::Open));
let diff = ScanDiff::between(&unscoped(vec![before]), &unscoped(vec![after]));
assert_eq!(diff.hosts().len(), 1, "one machine, not two");
let delta = &diff.hosts()[0];
assert!(delta.presence().is_in_both());
assert!(!delta.is_regrouped());
let summary = diff.summary();
assert_eq!(summary.hosts_added.total, 0);
assert_eq!(summary.hosts_removed.total, 0);
}
#[test]
fn the_strict_policy_reads_the_same_pair_as_two_hosts() {
let mut before = host(10);
before.add_ip(ip(11));
let mut after = Host::new(ip(11));
after.set_status(HostStatus::Up);
after.add_ip(ip(10));
let diff = ScanDiff::compare(
&unscoped(vec![before]),
&unscoped(vec![after]),
&DiffOptions::new().with_identity(HostIdentity::PrimaryAddress),
);
let summary = diff.summary();
assert_eq!(summary.hosts_added.total, 1);
assert_eq!(
summary.hosts_removed.total, 1,
"under this policy the address is the asset"
);
}
#[test]
fn one_host_seen_as_two_is_reported_as_a_regrouping() {
let mut before = host(10);
before.add_ip(ip(11));
let mut first = host(10);
first.add_port(Port::new(22, Protocol::Tcp, PortState::Open));
let mut second = Host::new(ip(11));
second.set_status(HostStatus::Up);
second.add_port(Port::new(80, Protocol::Tcp, PortState::Open));
let diff = ScanDiff::between(&unscoped(vec![before]), &unscoped(vec![first, second]));
assert_eq!(diff.hosts().len(), 1, "one component, however it was keyed");
let delta = &diff.hosts()[0];
assert!(delta.is_regrouped());
assert_eq!(delta.records(), (1, 2));
assert!(
delta.presence().is_in_both(),
"both scans saw the machine; they disagreed about how to key it"
);
let numbers: Vec<u16> = delta.ports().iter().map(PortDelta::number).collect();
assert_eq!(numbers, vec![22, 80]);
}
#[test]
fn a_shared_hardware_address_pairs_a_host_that_moved_address() {
use crate::model::mac::MacAddr;
let mac = MacAddr::new(0x2c, 0xcf, 0x67, 0xf2, 0x51, 0xe3);
let mut before = host(10);
before.record_mac(mac);
let mut after = host(60);
after.record_mac(mac);
let by_address = ScanDiff::between(
&unscoped(vec![before.clone()]),
&unscoped(vec![after.clone()]),
);
assert_eq!(
by_address.summary().hosts_added.total,
1,
"nothing links the two addresses without the hardware policy"
);
let by_hardware = ScanDiff::compare(
&unscoped(vec![before]),
&unscoped(vec![after]),
&DiffOptions::new().with_identity(HostIdentity::Hardware),
);
assert_eq!(by_hardware.hosts().len(), 1);
let delta = &by_hardware.hosts()[0];
assert!(delta.presence().is_in_both());
let changes = delta.changes();
assert!(
changes
.iter()
.any(|change| matches!(change, HostChange::Addresses { .. })),
"the address it moved to is the change: {changes:?}"
);
}
#[test]
fn hosts_come_back_ascending_by_address() {
let before = unscoped(vec![host(10)]);
let after = unscoped(vec![host(30), host(10), host(20)]);
let diff = ScanDiff::between(&before, &after);
let addresses: Vec<IpAddr> = diff.hosts().iter().map(HostDelta::address).collect();
assert_eq!(
addresses,
vec![ip(20), ip(30)],
"two runs over the same reports produce the same diff"
);
}
#[test]
fn a_report_with_no_phases_is_placed_by_its_latest_sighting() {
let at = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000_000);
let mut old = host(10);
old.restore_seen(at - DAY, at);
let diff = ScanDiff::between(&unscoped(vec![old]), &unscoped(vec![host(11)]));
assert_eq!(diff.baseline().at(), at);
assert!(!diff.baseline().states_scope());
assert_eq!(diff.baseline().hosts(), 1);
assert!(diff.baseline().kinds().is_empty());
}
#[test]
fn every_port_state_transition_grades_the_way_the_table_says() {
use crate::model::port::{Port, PortState, Protocol};
let table = [
(PortState::Open, PortState::Open, None),
(
PortState::Open,
PortState::Closed,
Some(Significance::Notable),
),
(
PortState::Open,
PortState::Filtered,
Some(Significance::Notable),
),
(
PortState::Open,
PortState::OpenFiltered,
Some(Significance::Notable),
),
(
PortState::Closed,
PortState::Open,
Some(Significance::Urgent),
),
(PortState::Closed, PortState::Closed, None),
(
PortState::Closed,
PortState::Filtered,
Some(Significance::Routine),
),
(
PortState::Filtered,
PortState::Open,
Some(Significance::Urgent),
),
(
PortState::Filtered,
PortState::Closed,
Some(Significance::Routine),
),
(PortState::Filtered, PortState::Filtered, None),
(
PortState::OpenFiltered,
PortState::Open,
Some(Significance::Urgent),
),
(PortState::OpenFiltered, PortState::OpenFiltered, None),
(PortState::Unasked, PortState::Unasked, None),
];
for (before, after, expected) in table {
let mut baseline = host(1);
baseline.add_port(Port::new(80, Protocol::Tcp, before));
let mut current = host(1);
current.add_port(Port::new(80, Protocol::Tcp, after));
let diff = ScanDiff::between(&unscoped(vec![baseline]), &unscoped(vec![current]));
let graded: Vec<Significance> = diff
.hosts()
.iter()
.flat_map(|host| host.ports())
.filter(|delta| delta.number() == 80)
.map(|delta| delta.significance())
.collect();
match expected {
Some(grade) => assert_eq!(graded, vec![grade], "{before:?} -> {after:?}"),
None => assert!(
graded.is_empty(),
"{before:?} -> {after:?} is not a change and must report none, got {graded:?}"
),
}
}
}
#[test]
fn a_transition_through_unasked_reads_as_ground_nobody_walked() {
use crate::model::port::{Port, PortState, Protocol};
for state in [
PortState::Open,
PortState::Closed,
PortState::Filtered,
PortState::OpenFiltered,
] {
for (before, after) in [(state, PortState::Unasked), (PortState::Unasked, state)] {
let mut baseline = host(1);
baseline.add_port(Port::new(80, Protocol::Tcp, before));
let mut current = host(1);
current.add_port(Port::new(80, Protocol::Tcp, after));
let diff = ScanDiff::between(&unscoped(vec![baseline]), &unscoped(vec![current]));
for delta in diff.hosts().iter().flat_map(|host| host.ports()) {
assert_eq!(
delta.significance(),
Significance::Routine,
"{before:?} -> {after:?} must not be graded above routine"
);
assert!(
!delta.presence().is_confirmed(),
"{before:?} -> {after:?} must not read as a confirmed change"
);
}
}
}
}
#[test]
fn a_quiet_address_listed_once_and_found_silent_once_is_no_change() {
let start = SystemTime::UNIX_EPOCH;
let mut unheard = Host::new(ip(5));
unheard.add_port(Port::new(443, Protocol::Tcp, PortState::Filtered));
let listed = scoped(vec![unheard], "203.0.113.0/29", &[], start);
let silent = found_silent("203.0.113.0/29", "203.0.113.5", start + DAY);
assert!(
ScanDiff::between(&listed, &silent).hosts().is_empty(),
"a quiet address read as a host that went away"
);
assert!(
ScanDiff::between(&silent, &listed).hosts().is_empty(),
"or as one that arrived"
);
}
#[test]
fn a_host_that_answered_and_is_silent_now_is_removed_from_covered_ground() {
let start = SystemTime::UNIX_EPOCH;
let answered = scoped(vec![host(5)], "203.0.113.0/29", &[], start);
let silent = found_silent("203.0.113.0/29", "203.0.113.5", start + DAY);
let diff = ScanDiff::between(&answered, &silent);
let [delta] = diff.hosts() else {
panic!("one host changed: {:?}", diff.hosts());
};
assert!(
matches!(
delta.presence(),
crate::diff::Presence::Removed {
after: Coverage::Covered
}
),
"{:?}",
delta.presence()
);
}
}