use std::collections::BTreeMap;
use std::sync::Arc;
use std::time::SystemTime;
use crate::diff::HostIdentity;
use crate::diff::pairing;
use crate::model::host::hardware::HardwareInfo;
use crate::model::host::os::OsFingerprint;
use crate::model::host::{Host, HostStatus};
use crate::model::port::{Port, Protocol, Security, Service};
use crate::report::{PhaseOrigin, ScanPhase, ScanReport};
#[must_use]
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct MergeOptions {
identity: HostIdentity,
}
impl MergeOptions {
pub fn new() -> Self {
Self::default()
}
pub fn with_identity(mut self, identity: HostIdentity) -> Self {
self.identity = identity;
self
}
pub fn identity(&self) -> HostIdentity {
self.identity
}
}
#[derive(Debug)]
struct Source {
label: Option<Arc<str>>,
report: ScanReport,
}
#[derive(Debug)]
pub struct Merge {
options: MergeOptions,
sources: Vec<Source>,
}
impl Merge {
pub fn new(options: MergeOptions) -> Self {
Self {
options,
sources: Vec::new(),
}
}
pub fn add(&mut self, report: ScanReport) -> &mut Self {
self.sources.push(Source {
label: None,
report,
});
self
}
pub fn add_from(&mut self, label: impl Into<Arc<str>>, report: ScanReport) -> &mut Self {
self.sources.push(Source {
label: Some(label.into()),
report,
});
self
}
pub fn len(&self) -> usize {
self.sources.len()
}
pub fn is_empty(&self) -> bool {
self.sources.is_empty()
}
pub fn finish(self) -> ScanReport {
let Self { options, sources } = self;
if sources.is_empty() {
return ScanReport::from_phases(Vec::new(), Vec::new());
}
let mut sources: Vec<(SystemTime, Source)> = sources
.into_iter()
.map(|source| (source.report.observed_at(), source))
.collect();
sources.sort_by_key(|(stopped, _)| *stopped);
let mut dated: Vec<(SystemTime, &Host)> = sources
.iter()
.flat_map(|(stopped, source)| {
let stopped = *stopped;
source
.report
.hosts()
.map(move |record| (observed_at(record, stopped), record))
})
.collect();
dated.sort_by_key(|(at, _)| *at);
let records: Vec<&Host> = dated.into_iter().map(|(_, record)| record).collect();
let hosts: Vec<Host> = pairing::groups(&records, options.identity)
.into_iter()
.map(|group| {
let accounts: Vec<&Host> = group.into_iter().map(|i| records[i]).collect();
fold_host(&accounts)
})
.collect();
let engine_version = sources
.last()
.expect("a non-empty source list")
.1
.report
.engine_version()
.to_owned();
let mut phases = Vec::new();
for (_, source) in sources {
let attribution = PhaseOrigin::new(source.report.engine_version());
let attribution = match &source.label {
Some(label) => attribution.with_label(Arc::clone(label)),
None => attribution,
};
for mut phase in source.report.into_phases() {
if phase.origin().is_none() {
phase.attribute(attribution.clone());
}
phases.push(phase);
}
}
phases.sort_by_key(ScanPhase::started_at);
ScanReport::recorded(engine_version, phases, hosts)
}
}
fn observed_at(record: &Host, stopped: SystemTime) -> SystemTime {
record.last_seen().min(stopped)
}
fn fold_host(accounts: &[&Host]) -> Host {
let newest = accounts.last().expect("a group holds at least one record");
let mut host = Host::new(newest.primary_ip());
for account in accounts {
host.extend_ips(account.ips().iter().copied());
host.consider_primary_ip(account.primary_ip());
}
if let Some(hostname) = newest_claim(accounts, |account| account.hostname()) {
host.set_hostname(Some(hostname.to_owned()));
}
if let Some(status) = accounts
.iter()
.rev()
.map(|account| account.status())
.find(|status| *status != HostStatus::Unknown)
{
host.set_status(status);
}
for account in accounts {
for reason in account.reasons() {
host.add_reason(reason.clone());
}
for role in account.network_roles() {
host.add_network_role(*role);
}
for filtering in account.filtering() {
host.add_filtering(*filtering);
}
}
for account in accounts.iter().rev() {
for evidence in account.os_evidence() {
host.record_os_evidence(evidence.clone());
}
}
if let Some(os) = fold_os(accounts) {
host.set_os(os);
}
let mut hardware = None;
for found in accounts
.iter()
.rev()
.filter_map(|account| account.hardware())
{
match hardware {
Some(ref mut existing) => HardwareInfo::merge(existing, found.clone()),
None => hardware = Some(found.clone()),
}
}
if let Some(hardware) = hardware {
host.set_hardware(hardware);
}
if let Some(zone) = newest_claim(accounts, |account| account.zone()) {
host.set_zone(zone.clone());
}
if let Some(telemetry) = newest_claim(accounts, |account| {
let telemetry = account.telemetry();
(!telemetry.history().is_empty() || telemetry.hop_counter().is_some()).then_some(telemetry)
}) {
host.add_rtts(telemetry.history().iter().map(|sample| sample.rtt));
if let Some(arrived) = telemetry.hop_counter() {
host.record_hop_counter(arrived);
}
}
if let Some(path) = newest_claim(accounts, |account| {
let path = account.path();
(!path.is_empty()).then_some(path)
}) {
for hop in path.hops() {
host.record_hop(*hop);
}
}
for port in fold_ports(accounts) {
host.add_port(port);
}
for account in accounts {
for finding in account.findings() {
host.add_finding(finding.clone());
}
}
let first_seen = accounts
.iter()
.map(|account| account.first_seen())
.min()
.expect("a group holds at least one record");
let last_seen = accounts
.iter()
.map(|account| account.last_seen())
.max()
.expect("a group holds at least one record");
host.restore_seen(first_seen, last_seen);
host
}
fn newest_claim<'a, T>(accounts: &[&'a Host], claim: impl Fn(&'a Host) -> Option<T>) -> Option<T> {
accounts.iter().rev().find_map(|account| claim(account))
}
fn fold_ports(accounts: &[&Host]) -> Vec<Port> {
let mut by_endpoint: BTreeMap<(u16, Protocol), Vec<&Port>> = BTreeMap::new();
for account in accounts {
for port in account.ports() {
by_endpoint
.entry((port.number(), port.protocol()))
.or_default()
.push(port);
}
}
by_endpoint.into_values().map(|of| fold_port(&of)).collect()
}
fn fold_port(accounts: &[&Port]) -> Port {
let newest = accounts
.last()
.expect("an endpoint has at least one account");
let mut port = Port::new(newest.number(), newest.protocol(), newest.state());
if let Some(discovery) = newest_claim_port(accounts, |account| {
(account.state() == newest.state())
.then(|| account.discovery())
.flatten()
}) {
port = port.with_discovery(discovery.clone());
}
if let Some(service) = fold_service(accounts) {
port.set_service(service);
}
let mut security = None;
for found in accounts
.iter()
.rev()
.filter_map(|account| account.security())
{
match security {
Some(ref mut existing) => Security::merge(existing, found.clone()),
None => security = Some(found.clone()),
}
}
if let Some(security) = security {
port.set_security(security);
}
for account in accounts {
for finding in account.findings() {
port.add_finding(finding.clone());
}
}
port
}
fn fold_service(accounts: &[&Port]) -> Option<Service> {
let newest = newest_claim_port(accounts, |port| port.service())?;
let mut folded = Service::new(newest.name(), newest.confidence());
if let Some(product) = newest.product() {
folded = folded.with_product(product);
}
if let Some(vendor) = newest.vendor() {
folded = folded.with_vendor(vendor);
}
if let Some(version) = newest.version() {
folded = folded.with_version(version);
}
if let Some(extrainfo) = newest.extrainfo() {
folded = folded.with_extrainfo(extrainfo);
}
for older in accounts
.iter()
.rev()
.filter_map(|account| account.service())
.skip(1)
.filter(|older| same_service(newest, older))
{
if folded.vendor().is_none()
&& let Some(vendor) = older.vendor()
{
folded = folded.with_vendor(vendor);
}
if folded.version().is_none()
&& let Some(version) = older.version()
{
folded = folded.with_version(version);
}
if folded.extrainfo().is_none()
&& let Some(extrainfo) = older.extrainfo()
{
folded = folded.with_extrainfo(extrainfo);
}
}
for cpe in accounts
.iter()
.filter_map(|account| account.service())
.flat_map(Service::cpes)
{
folded.add_cpe(Arc::clone(cpe));
}
Some(folded)
}
fn same_service(newest: &Service, older: &Service) -> bool {
newest.name() == older.name() && newest.product() == older.product()
}
fn fold_os(accounts: &[&Host]) -> Option<OsFingerprint> {
let newest = newest_claim(accounts, |account| account.os())?;
let mut folded = OsFingerprint::new(newest.name(), newest.accuracy());
if let Some(family) = newest.family() {
folded = folded.with_family(family);
}
if let Some(generation) = newest.generation() {
folded = folded.with_generation(generation);
}
if let Some(vendor) = newest.vendor() {
folded = folded.with_vendor(vendor);
}
if let Some(kernel) = newest.kernel() {
folded = folded.with_kernel(kernel);
}
if let Some(arch) = newest.arch() {
folded = folded.with_arch(arch);
}
if let Some(device) = newest.device() {
folded = folded.with_device(device);
}
if let Some(accuracy) = newest.detail_accuracy() {
folded = folded.with_detail_accuracy(accuracy);
}
if let Some(evidence) = newest.evidence() {
folded = folded.with_evidence(evidence);
}
for older in accounts
.iter()
.rev()
.filter_map(|account| account.os())
.skip(1)
.filter(|older| names_the_same_system(newest, older))
{
if folded.kernel().is_none()
&& let Some(kernel) = older.kernel()
{
folded = folded.with_kernel(kernel);
}
if folded.arch().is_none()
&& let Some(arch) = older.arch()
{
folded = folded.with_arch(arch);
}
if folded.device().is_none()
&& let Some(device) = older.device()
{
folded = folded.with_device(device);
}
if folded.detail_accuracy().is_none()
&& let Some(accuracy) = older.detail_accuracy()
{
folded = folded.with_detail_accuracy(accuracy);
}
if folded.evidence().is_none()
&& let Some(evidence) = older.evidence()
{
folded = folded.with_evidence(evidence);
}
}
for cpe in accounts
.iter()
.filter_map(|account| account.os())
.flat_map(OsFingerprint::cpes)
{
folded.add_cpe(Arc::clone(cpe));
}
Some(folded)
}
fn names_the_same_system(newest: &OsFingerprint, older: &OsFingerprint) -> bool {
newest.name() == older.name()
&& newest.family() == older.family()
&& newest.generation() == older.generation()
&& newest.vendor() == older.vendor()
}
fn newest_claim_port<'a, T>(
accounts: &[&'a Port],
claim: impl Fn(&'a Port) -> Option<T>,
) -> Option<T> {
accounts.iter().rev().find_map(|account| claim(account))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::system::privilege::Privilege;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
use std::time::{Duration, SystemTime};
use crate::config::ZondConfig;
use crate::diff::ScanDiff;
use crate::model::exclusion::Exclusions;
use crate::model::host::path::Hop;
use crate::model::host::{OsEvidence, OsSource};
use crate::model::ip::scoped::Zone;
use crate::model::ip::set::IpSet;
use crate::model::port::PortState;
use crate::model::port::discovery::{Discovery, ScanResponse};
use crate::report::{PhaseParts, ScanKind, ScanSettings, TargetScope};
const DAY: Duration = Duration::from_secs(24 * 60 * 60);
const TCP: Protocol = Protocol::Tcp;
fn ip(last: u8) -> IpAddr {
IpAddr::V4(Ipv4Addr::new(10, 0, 0, last))
}
fn day(n: u64) -> SystemTime {
SystemTime::UNIX_EPOCH + DAY * n as u32
}
fn host(last: u8) -> Host {
let mut host = Host::new(ip(last));
host.set_status(HostStatus::Up);
host
}
fn report(engine: &str, at: SystemTime, hosts: Vec<Host>) -> ScanReport {
let phase = ScanPhase::from_parts(PhaseParts {
attachments: Vec::new(),
kind: ScanKind::PortScan,
started_at: at,
elapsed: Duration::from_secs(60),
privilege: Some(Privilege::Raw),
targets: TargetScope::from_ip_set(&mut IpSet::new(), &Exclusions::none()),
settings: ScanSettings::from(&ZondConfig::default()),
failures: Vec::new(),
refusals: Vec::new(),
unroutable: Vec::new(),
timed_out: Vec::new(),
probes: Vec::new(),
origin: None,
});
ScanReport::recorded(engine, vec![phase], hosts)
}
#[test]
fn a_folded_report_says_it_was_folded_and_a_measured_one_does_not() {
let one = report("0.13.0", day(1), vec![host(1)]);
let two = report("0.13.0", day(2), vec![host(2)]);
assert!(!one.is_merged(), "a report of one scan was not folded");
let folded = merged(vec![one, two]);
assert!(folded.is_merged());
assert_eq!(folded.elapsed(), Duration::from_secs(120));
assert_eq!(
folded
.finished_at()
.duration_since(folded.started_at())
.expect("a report ends after it begins"),
DAY + Duration::from_secs(60)
);
}
#[test]
fn folding_a_folded_report_leaves_it_folded() {
let once = merged(vec![
report("0.13.0", day(1), vec![host(1)]),
report("0.13.0", day(2), vec![host(2)]),
]);
let twice = merged(vec![once, report("0.13.0", day(3), vec![host(3)])]);
assert!(twice.is_merged());
}
fn merged(sources: Vec<ScanReport>) -> ScanReport {
let mut merge = Merge::new(MergeOptions::default());
for source in sources {
merge.add(source);
}
merge.finish()
}
fn state_of(report: &ScanReport, last: u8, number: u16) -> Option<PortState> {
report
.hosts()
.find(|host| host.ips().contains(&ip(last)))?
.ports()
.find(|port| port.number() == number)
.map(Port::state)
}
fn discovery_on(report: &ScanReport, last: u8, number: u16) -> Option<Discovery> {
report
.hosts()
.find(|host| host.ips().contains(&ip(last)))?
.ports()
.find(|port| port.number() == number)?
.discovery()
.cloned()
}
fn service_on(report: &ScanReport, last: u8, number: u16) -> Option<Service> {
report
.hosts()
.find(|host| host.ips().contains(&ip(last)))?
.ports()
.find(|port| port.number() == number)?
.service()
.cloned()
}
fn finding(id: &str, title: &str) -> crate::model::finding::Finding {
use crate::model::confidence::Confidence;
use crate::model::finding::{DetectionClass, DetectionId, Finding, Severity, Version};
Finding::new(
DetectionId::new(id, Version::new(1, 0, 0), "hash").expect("a valid detection id"),
title,
Severity::Medium,
Confidence::Certain,
DetectionClass::Passive,
)
.expect("a titled finding")
}
fn with_port(mut host: Host, port: Port) -> Host {
host.add_port(port);
host
}
#[test]
fn a_port_that_closed_since_the_older_scan_reads_as_closed() {
let january = with_port(host(1), Port::new(3389, Protocol::Tcp, PortState::Open));
let august = with_port(host(1), Port::new(3389, Protocol::Tcp, PortState::Closed));
let merged = merged(vec![
report("older", day(0), vec![january]),
report("newer", day(200), vec![august]),
]);
assert_eq!(
state_of(&merged, 1, 3389),
Some(PortState::Closed),
"the newest source that probed it said closed"
);
}
#[test]
fn an_endpoint_a_later_scan_never_recorded_keeps_its_verdict() {
let january = with_port(host(1), Port::new(22, TCP, PortState::Open));
let august = host(1);
let merged = merged(vec![
report("older", day(0), vec![january]),
report("newer", day(200), vec![august]),
]);
assert_eq!(
state_of(&merged, 1, 22),
Some(PortState::Open),
"silence about an endpoint is not a verdict about it"
);
}
#[test]
fn silence_in_a_later_scan_does_not_unseat_a_host_that_answered() {
let january = host(1);
let august = Host::new(ip(1));
assert_eq!(august.status(), HostStatus::Unknown, "the premise");
let merged = merged(vec![
report("older", day(0), vec![january]),
report("newer", day(200), vec![august]),
]);
assert_eq!(
merged.hosts().next().map(Host::status),
Some(HostStatus::Up)
);
}
#[test]
fn a_newer_unreachable_verdict_unseats_an_older_answer() {
let january = host(1);
let mut august = Host::new(ip(1));
august.set_status(HostStatus::Down);
let merged = merged(vec![
report("older", day(0), vec![january]),
report("newer", day(200), vec![august]),
]);
assert_eq!(
merged.hosts().next().map(Host::status),
Some(HostStatus::Down),
"an intermediary's unreachable is a later word than an answer"
);
}
#[test]
fn an_older_probe_of_the_state_that_won_still_explains_it() {
let probed = with_port(
host(1),
Port::new(443, TCP, PortState::Open)
.with_discovery(Discovery::new(ScanResponse::TcpSynAck)),
);
let imported = with_port(host(1), Port::new(443, TCP, PortState::Open));
let merged = merged(vec![
report("zond", day(0), vec![probed]),
report("nmap 7.94", day(200), vec![imported]),
]);
assert_eq!(
discovery_on(&merged, 1, 443).map(|found| found.reason().clone()),
Some(ScanResponse::TcpSynAck),
"the packet that settled the verdict being reported"
);
}
#[test]
fn evidence_never_comes_from_an_account_that_reached_another_verdict() {
let january = with_port(
host(1),
Port::new(443, TCP, PortState::Open)
.with_discovery(Discovery::new(ScanResponse::TcpSynAck)),
);
let august = with_port(host(1), Port::new(443, TCP, PortState::Closed));
let merged = merged(vec![
report("older", day(0), vec![january]),
report("newer", day(200), vec![august]),
]);
assert_eq!(
state_of(&merged, 1, 443),
Some(PortState::Closed),
"the premise"
);
assert_eq!(
discovery_on(&merged, 1, 443),
None,
"a packet explaining an open port is not evidence the port is closed"
);
}
#[test]
fn the_newest_readings_are_the_ones_the_evidence_cap_keeps() {
fn read(release: &str) -> OsEvidence {
OsEvidence {
source: OsSource::TcpStack,
family: Some("Linux".to_owned()),
device: None,
vendor: None,
product: None,
version: Some(release.to_owned()),
kernel: None,
arch: None,
cpe: None,
confidence: 0.8,
evidence: format!("a stack reading of {release}"),
}
}
let nightly: Vec<ScanReport> = (0..12)
.map(|night| {
let mut host = host(1);
host.record_os_evidence(read(&format!("6.1.{night}")));
report("nightly", day(night), vec![host])
})
.collect();
let merged = merged(nightly);
let kept: Vec<&str> = merged
.hosts()
.next()
.expect("a host")
.os_evidence()
.filter_map(|reading| reading.version.as_deref())
.collect();
assert!(
kept.contains(&"6.1.11"),
"the newest reading of the host, and the one a report is about: {kept:?}"
);
assert!(
!kept.contains(&"6.1.0"),
"and not the first reading of a year ago: {kept:?}"
);
}
#[test]
fn a_service_that_changed_product_does_not_inherit_the_old_version() {
let older = with_port(
host(1),
Port::new(80, TCP, PortState::Open).with_service(
Service::new("http", 90)
.with_product("Apache httpd")
.with_version("2.4.1"),
),
);
let newer = with_port(
host(1),
Port::new(80, TCP, PortState::Open)
.with_service(Service::new("http", 90).with_product("nginx")),
);
let merged = merged(vec![
report("older", day(0), vec![older]),
report("newer", day(200), vec![newer]),
]);
let service = service_on(&merged, 1, 80).expect("a service");
assert_eq!(service.product(), Some("nginx"));
assert_eq!(
service.version(),
None,
"a version belongs to the product it was read from"
);
}
#[test]
fn an_older_reading_of_the_same_service_supplies_the_version_the_newer_one_missed() {
let older = with_port(
host(1),
Port::new(80, TCP, PortState::Open).with_service(
Service::new("http", 90)
.with_product("Apache httpd")
.with_version("2.4.1"),
),
);
let newer = with_port(
host(1),
Port::new(80, TCP, PortState::Open)
.with_service(Service::new("http", 90).with_product("Apache httpd")),
);
let merged = merged(vec![
report("older", day(0), vec![older]),
report("newer", day(200), vec![newer]),
]);
assert_eq!(
service_on(&merged, 1, 80).and_then(|s| s.version().map(str::to_owned)),
Some("2.4.1".to_owned()),
"the same product, so the older detail is more of one finding"
);
}
#[test]
fn a_cpe_from_a_reading_that_lost_the_vote_is_still_recorded() {
let older = with_port(
host(1),
Port::new(80, TCP, PortState::Open).with_service(
Service::new("http", 90)
.with_product("Apache httpd")
.with_cpe("cpe:/a:apache:http_server"),
),
);
let newer = with_port(
host(1),
Port::new(80, TCP, PortState::Open).with_service(
Service::new("http", 90)
.with_product("nginx")
.with_cpe("cpe:/a:nginx:nginx"),
),
);
let merged = merged(vec![
report("older", day(0), vec![older]),
report("newer", day(200), vec![newer]),
]);
let service = service_on(&merged, 1, 80).expect("a service");
assert_eq!(service.cpes().len(), 2, "both identifiers apply");
}
#[test]
fn two_documents_keying_one_machine_differently_fold_to_one_host() {
let v6 = IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1));
let mut keyed_v4 = host(5);
keyed_v4.add_ip(v6);
let mut keyed_v6 = Host::new(v6);
keyed_v6.set_status(HostStatus::Up);
let merged = merged(vec![
report("nmap 7.94", day(0), vec![keyed_v4]),
report("zond", day(1), vec![keyed_v6]),
]);
assert_eq!(merged.host_count(), 1, "one machine, two documents");
assert_eq!(
merged.hosts().next().expect("a host").ips().len(),
2,
"and it holds both addresses"
);
}
#[test]
fn folding_a_report_leaves_its_findings_alone() {
let mut port = Port::new(443, TCP, PortState::Open).with_service(
Service::new("https", 90)
.with_product("nginx")
.with_version("1.24.0"),
);
port.add_finding(finding("tls-weak-cipher", "a weak cipher is offered"));
let mut carrier = host(1);
carrier.add_finding(finding("ssh-old", "an outdated SSH server"));
let source = report("test", day(0), vec![with_port(carrier, port)]);
let once = merged(vec![source.clone()]);
assert!(
ScanDiff::between(&source, &once).is_empty(),
"a merge of one source is that source"
);
let twice = merged(vec![source.clone(), source.clone()]);
assert!(
ScanDiff::between(&source, &twice).is_empty(),
"and folding it into itself adds nothing"
);
}
#[test]
fn two_accounts_of_one_host_keep_every_claim_and_grade_it_as_the_newer_did() {
use crate::model::confidence::Confidence;
use crate::model::finding::{DetectionClass, DetectionId, Finding, Severity, Version};
let graded = |severity| {
Finding::new(
DetectionId::new("tls-weak-cipher", Version::new(1, 0, 0), "hash")
.expect("a valid detection id"),
"a weak cipher is offered",
severity,
Confidence::Certain,
DetectionClass::Passive,
)
.expect("a titled finding")
};
let mut january = host(1);
january.add_finding(graded(Severity::Low));
january.add_finding(finding("ssh-old", "an outdated SSH server"));
let mut june = host(1);
june.add_finding(graded(Severity::Critical));
let folded = merged(vec![
report("older", day(0), vec![january]),
report("newer", day(30), vec![june]),
]);
let host = folded.hosts().next().expect("the one host");
let findings: Vec<_> = host.findings().collect();
assert_eq!(
findings.len(),
2,
"the claim only the older scan made is still a claim"
);
let cipher = findings
.iter()
.find(|finding| finding.detection().id() == "tls-weak-cipher")
.expect("the claim both scans made");
assert_eq!(
cipher.severity(),
Severity::Critical,
"the later scan graded it, so the later grade stands"
);
}
#[test]
fn the_order_sources_are_added_in_does_not_decide_the_outcome() {
let january = report(
"older",
day(0),
vec![with_port(host(1), Port::new(3389, TCP, PortState::Open))],
);
let august = report(
"newer",
day(200),
vec![with_port(host(1), Port::new(3389, TCP, PortState::Closed))],
);
let forwards = merged(vec![january.clone(), august.clone()]);
let backwards = merged(vec![august, january]);
assert_eq!(state_of(&forwards, 1, 3389), Some(PortState::Closed));
assert_eq!(state_of(&backwards, 1, 3389), Some(PortState::Closed));
}
#[test]
fn two_link_locals_on_different_segments_stay_two_hosts() {
let shared = IpAddr::V6(Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 1));
let mut near = Host::new(shared);
near.set_status(HostStatus::Up);
near.set_zone(Zone::new(1, "en0"));
let mut far = Host::new(shared);
far.set_status(HostStatus::Up);
far.set_zone(Zone::new(2, "en1"));
let merged = merged(vec![
report("en0", day(0), vec![near]),
report("en1", day(1), vec![far]),
]);
assert_eq!(merged.host_count(), 2, "two segments, two machines");
let zones: Vec<&str> = merged
.hosts()
.filter_map(|host| host.zone().map(Zone::name))
.collect();
assert_eq!(zones, ["en0", "en1"], "and each says which link it is on");
}
#[test]
fn folding_in_rounds_is_not_folding_at_once() {
let january = report(
"january",
day(0),
vec![with_port(host(1), Port::new(3389, TCP, PortState::Open))],
);
let march = report(
"march",
day(60),
vec![with_port(host(1), Port::new(3389, TCP, PortState::Closed))],
);
let august = report("august", day(200), vec![host(1)]);
let at_once = merged(vec![january.clone(), march.clone(), august.clone()]);
assert_eq!(
state_of(&at_once, 1, 3389),
Some(PortState::Closed),
"the newest source that probed the endpoint said closed"
);
let mut round = Merge::new(MergeOptions::default());
round.add(january).add(august);
let in_rounds = merged(vec![round.finish(), march]);
assert_eq!(
state_of(&in_rounds, 1, 3389),
Some(PortState::Open),
"January's verdict, carried into a document March cannot outrank"
);
}
#[test]
fn merging_a_merge_keeps_the_labels_its_own_sources_were_given() {
let mut inner = Merge::new(MergeOptions::default());
inner.add_from("q1.xml", report("nmap 7.94", day(0), vec![host(1)]));
inner.add_from("q2.xml", report("nmap 7.94", day(90), vec![host(2)]));
let mut outer = Merge::new(MergeOptions::default());
outer.add_from("combined.json", inner.finish());
outer.add_from("q3.xml", report("nmap 7.95", day(180), vec![host(3)]));
let merged = outer.finish();
let labels: Vec<&str> = merged
.phases()
.iter()
.filter_map(|phase| phase.origin().and_then(PhaseOrigin::label))
.collect();
assert_eq!(labels, ["q1.xml", "q2.xml", "q3.xml"]);
}
#[test]
fn a_merged_report_is_placed_by_when_it_last_looked() {
let merged = merged(vec![
report("older", day(0), vec![host(1)]),
report("newer", day(200), vec![host(2)]),
]);
let last_looked = day(200) + Duration::from_secs(60);
assert_eq!(merged.finished_at(), last_looked);
let diff = ScanDiff::between(&report("baseline", day(0), vec![host(1)]), &merged);
assert_eq!(
diff.current().at(),
last_looked,
"and that is the clock the comparison judges it at"
);
}
#[test]
fn a_record_is_placed_by_when_it_was_seen_not_by_when_its_document_stopped() {
let mut stale = with_port(host(1), Port::new(3389, TCP, PortState::Open));
stale.restore_seen(day(0), day(0));
let baseline = report("baseline", day(200), vec![stale]);
let march = report(
"march",
day(60),
vec![with_port(host(1), Port::new(3389, TCP, PortState::Closed))],
);
let merged = merged(vec![baseline, march]);
assert_eq!(
state_of(&merged, 1, 3389),
Some(PortState::Closed),
"March saw the endpoint after January did, whatever their documents say"
);
}
#[test]
fn a_conclusion_about_the_filter_in_front_of_a_host_survives_a_fold() {
use crate::model::host::Filtering;
let mut characterised = host(1);
characterised.add_filtering(Filtering::StatefulFilter);
characterised.add_filtering(Filtering::StatelessFilter);
let folded = merged(vec![
report("a", day(1), vec![characterised]),
report("b", day(2), vec![host(1)]),
]);
let host = folded.hosts().next().expect("one host");
assert!(host.filtering().contains(&Filtering::StatefulFilter));
assert!(host.filtering().contains(&Filtering::StatelessFilter));
}
#[test]
fn a_record_stamped_later_than_its_document_is_placed_by_the_document() {
let mut archived = with_port(host(1), Port::new(3389, TCP, PortState::Open));
archived.restore_seen(day(300), day(300));
let january = report("archive.xml", day(0), vec![archived]);
let mut probed = with_port(host(1), Port::new(3389, TCP, PortState::Closed));
probed.restore_seen(day(200), day(200));
let august = report("august", day(200), vec![probed]);
let merged = merged(vec![january, august]);
assert_eq!(
state_of(&merged, 1, 3389),
Some(PortState::Closed),
"an archive is as old as it says it is, not as old as its records were stamped"
);
}
#[test]
fn two_measured_routes_do_not_splice_into_one_that_was_never_travelled() {
let mut january = host(1);
january.record_hop(Hop::answered(1, ip(200), None));
january.record_hop(Hop::answered(2, ip(201), None));
let mut august = host(1);
august.record_hop(Hop::answered(1, ip(210), None));
let merged = merged(vec![
report("older", day(0), vec![january]),
report("newer", day(200), vec![august]),
]);
let path = merged.hosts().next().expect("a host").path().clone();
assert_eq!(path.at(1), Some(ip(210)), "the route measured last");
assert_ne!(
path.at(2),
Some(ip(201)),
"and not a second hop from a different route"
);
}
}