use std::collections::BTreeMap;
use std::sync::Arc;
use std::time::SystemTime;
use crate::diff::HostIdentity;
use crate::diff::pairing;
use crate::model::finding::{Finding, Standing};
use crate::model::host::hardware::HardwareInfo;
use crate::model::host::os::OsFingerprint;
use crate::model::host::{Host, HostStatus};
use crate::model::port::{Port, PortState, 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 state = newest_claim_port(accounts, |account| {
(account.state() != PortState::Unasked).then_some(account.state())
})
.unwrap_or(newest.state());
let mut port = Port::new(newest.number(), newest.protocol(), state);
if let Some(discovery) = newest_claim_port(accounts, |account| {
(account.state() == 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: Option<Security> = None;
for found in accounts.iter().filter_map(|account| account.security()) {
let mut newer = found.clone();
if let Some(older) = security.take() {
newer.merge(older);
}
security = Some(newer);
}
if let Some(security) = security {
port.set_security(security);
}
for account in accounts {
for finding in account.findings() {
if !overturned(finding, account, &port) {
port.add_finding(finding.clone());
}
}
}
port
}
fn overturned(finding: &Finding, account: &Port, folded: &Port) -> bool {
match (folded.security(), account.security()) {
(Some(folded), Some(basis)) => {
folded.standing(finding, basis) == Some(Standing::Overturned)
}
_ => false,
}
}
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::discovery::{Discovery, ScanResponse};
use crate::model::tls::{
CipherSuite, Interruption, TlsSupport, TlsVersion, UnfinishedVersion, VersionSupport,
};
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(192, 0, 2, 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(),
reached_by_connect: 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"
);
}
#[test]
fn a_later_scan_that_never_asked_does_not_erase_what_an_earlier_one_found() {
for found in [PortState::Open, PortState::Closed, PortState::Filtered] {
let wide = with_port(host(1), Port::new(3389, Protocol::Tcp, found));
let narrow = with_port(host(1), Port::new(3389, Protocol::Tcp, PortState::Unasked));
let mut merge = Merge::new(MergeOptions::default());
merge.add(report("wide", day(1), vec![wide]));
merge.add(report("narrow", day(2), vec![narrow]));
let merged = merge.finish();
let state = merged
.hosts()
.next()
.and_then(|host| host.ports().find(|port| port.number() == 3389))
.map(|port| port.state());
assert_eq!(
state,
Some(found),
"a scan that ran out of budget erased a {found:?} port"
);
}
}
#[test]
fn a_later_scan_that_did_ask_still_overrides() {
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 mut merge = Merge::new(MergeOptions::default());
merge.add(report("january", day(1), vec![january]));
merge.add(report("august", day(2), vec![august]));
assert_eq!(
merge
.finish()
.hosts()
.next()
.and_then(|host| host.ports().find(|port| port.number() == 3389))
.map(|port| port.state()),
Some(PortState::Closed),
"a later scan that looked is allowed to close a port"
);
}
fn suite(code: u16) -> CipherSuite {
CipherSuite::from_code(code).expect("a suite in the registry")
}
fn enumerated(support: TlsSupport) -> Host {
with_port(
host(1),
Port::new(443, TCP, PortState::Open)
.with_security(Security::new().with_support(support)),
)
}
fn support_on(report: &ScanReport) -> TlsSupport {
report
.hosts()
.next()
.and_then(|host| host.ports().find(|port| port.number() == 443))
.and_then(Port::security)
.map(|security| security.support().clone())
.expect("443 carries an enumeration")
}
#[test]
fn a_cut_short_walk_does_not_replace_a_complete_one() {
use TlsVersion::{Tls12, Tls13};
let complete = TlsSupport::new()
.accepting(VersionSupport::new(
Tls12,
vec![suite(0xC030), suite(0xC02F), suite(0x000A)],
vec![],
))
.accepting(VersionSupport::new(Tls13, vec![suite(0x1302)], vec![]));
let cut_short = TlsSupport::new()
.accepting(VersionSupport::new(Tls12, vec![suite(0xC030)], vec![]))
.leaving_unfinished(UnfinishedVersion::new(Tls12, Interruption::Stopped))
.accepting(VersionSupport::new(Tls13, vec![suite(0x1301)], vec![]));
let merged = merged(vec![
report("older", day(1), vec![enumerated(complete.clone())]),
report("newer", day(2), vec![enumerated(cut_short)]),
]);
let support = support_on(&merged);
assert_eq!(
support.versions()[0],
complete.versions()[0],
"the older walk of TLS 1.2 finished, and the newer found nothing it lacks"
);
assert!(support.is_complete(), "and so it is the whole answer there");
assert_eq!(
support.versions()[1].suites(),
&[suite(0x1301)],
"the newer walk of TLS 1.3 finished, and a finished walk is the newer answer"
);
}
#[test]
fn a_finished_walk_retires_every_older_answer() {
use TlsVersion::Tls12;
let finished = |suites: Vec<CipherSuite>| {
TlsSupport::new().accepting(VersionSupport::new(Tls12, suites, vec![]))
};
let january = finished(vec![suite(0xC030), suite(0xC02F)]);
let february = finished(vec![suite(0xC02F)]);
let march = TlsSupport::new()
.accepting(VersionSupport::new(Tls12, vec![suite(0xC030)], vec![]))
.leaving_unfinished(UnfinishedVersion::new(Tls12, Interruption::Unanswered));
let merged = merged(vec![
report("january", day(1), vec![enumerated(january)]),
report("february", day(2), vec![enumerated(february)]),
report("march", day(3), vec![enumerated(march.clone())]),
]);
assert_eq!(support_on(&merged), march);
}
fn audited(support: TlsSupport) -> Host {
let findings = support.findings();
let mut port = Port::new(443, TCP, PortState::Open)
.with_security(Security::new().with_support(support));
for finding in findings {
port.add_finding(finding);
}
with_port(host(1), port)
}
fn findings_on(report: &ScanReport) -> Vec<String> {
report
.hosts()
.next()
.and_then(|host| host.ports().find(|port| port.number() == 443))
.map(|port| port.findings().map(|f| f.title().to_owned()).collect())
.unwrap_or_default()
}
#[test]
fn a_finding_a_newer_finished_walk_overturned_is_not_carried() {
use TlsVersion::{Tls10, Tls12};
let january = TlsSupport::new()
.accepting(VersionSupport::new(Tls10, vec![suite(0x002F)], vec![]))
.accepting(VersionSupport::new(Tls12, vec![suite(0xC02F)], vec![]));
let february =
TlsSupport::new().accepting(VersionSupport::new(Tls12, vec![suite(0xC02F)], vec![]));
let merged = merged(vec![
report("january", day(1), vec![audited(january)]),
report("february", day(2), vec![audited(february.clone())]),
]);
assert_eq!(support_on(&merged), february, "February's walk stands");
let titles = findings_on(&merged);
assert!(
titles.is_empty(),
"the merged port carries findings its own record refutes: {titles:?}"
);
}
#[test]
fn a_finding_a_newer_walk_never_got_back_to_is_kept() {
use TlsVersion::Tls10;
let january =
TlsSupport::new().accepting(VersionSupport::new(Tls10, vec![suite(0x002F)], vec![]));
let february = TlsSupport::new()
.accepting(VersionSupport::new(Tls10, vec![suite(0xC013)], vec![]))
.leaving_unfinished(UnfinishedVersion::new(Tls10, Interruption::Stopped));
let merged = merged(vec![
report("january", day(1), vec![audited(january.clone())]),
report("february", day(2), vec![audited(february.clone())]),
]);
assert_eq!(support_on(&merged), february, "February's walk stands");
let static_rsa = january
.findings()
.into_iter()
.map(|finding| finding.title().to_owned())
.find(|title| title.contains("long-term key"))
.expect("January draws a claim from the static-RSA suite");
assert!(
findings_on(&merged).contains(&static_rsa),
"a claim the newer walk never got back to was dropped"
);
}
#[test]
fn a_posture_finding_goes_with_the_certificate_it_was_drawn_from() {
use crate::model::port::security::CertificateInfo;
let presenting = |fingerprint: &str, issuer: &str| {
let certificate =
CertificateInfo::new("www.example.test", issuer, day(0), day(365), fingerprint);
let findings = certificate.findings(day(1));
let mut port = Port::new(443, TCP, PortState::Open)
.with_security(Security::new().with_certificate(certificate));
for finding in findings {
port.add_finding(finding);
}
with_port(host(1), port)
};
let self_signed = "TLS certificate is self-signed".to_owned();
let rotated = merged(vec![
report(
"older",
day(1),
vec![presenting("aaaa", "www.example.test")],
),
report("newer", day(2), vec![presenting("bbbb", "Example CA")]),
]);
assert!(
!findings_on(&rotated).contains(&self_signed),
"a claim about a certificate the endpoint no longer presents"
);
let kept = merged(vec![
report(
"older",
day(1),
vec![presenting("aaaa", "www.example.test")],
),
report(
"newer",
day(2),
vec![presenting("aaaa", "www.example.test")],
),
]);
assert!(findings_on(&kept).contains(&self_signed));
}
#[test]
fn a_port_nobody_ever_asked_about_stays_unasked() {
let first = with_port(host(1), Port::new(3389, Protocol::Tcp, PortState::Unasked));
let second = with_port(host(1), Port::new(3389, Protocol::Tcp, PortState::Unasked));
let mut merge = Merge::new(MergeOptions::default());
merge.add(report("first", day(1), vec![first]));
merge.add(report("second", day(2), vec![second]));
assert_eq!(
merge
.finish()
.hosts()
.next()
.and_then(|host| host.ports().find(|port| port.number() == 3389))
.map(|port| port.state()),
Some(PortState::Unasked)
);
}
}