use crate::diff::ScanDiff;
use crate::diff::change::{Change, Presence};
use crate::diff::host::{HostChange, HostDelta, Reassessment};
use crate::diff::port::{CertificateChange, PortChange, PortDelta, SecurityChange, ServiceChange};
use crate::model::finding::{Finding, Severity};
use crate::model::host::HostStatus;
use crate::model::port::PortState;
#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Significance {
Routine,
Notable,
Urgent,
}
impl Significance {
pub const ALL: [Significance; 3] = [Self::Routine, Self::Notable, Self::Urgent];
pub const fn label(self) -> &'static str {
match self {
Self::Routine => "Routine",
Self::Notable => "Notable",
Self::Urgent => "Urgent",
}
}
pub const fn of_severity(severity: Severity) -> Self {
match severity {
Severity::Info | Severity::Low => Self::Routine,
Severity::Medium => Self::Notable,
Severity::High | Severity::Critical => Self::Urgent,
}
}
const fn max(self, other: Self) -> Self {
if (self as u8) >= (other as u8) {
self
} else {
other
}
}
}
impl HostChange {
pub fn significance(&self) -> Significance {
match self {
HostChange::Status(status) => match answers(status.before) == answers(status.after) {
true => Significance::Routine,
false => Significance::Notable,
},
HostChange::Os(_)
| HostChange::Macs { .. }
| HostChange::Roles { .. }
| HostChange::Filtering { .. }
| HostChange::IpProtocols { .. } => Significance::Notable,
HostChange::Hostname(_) | HostChange::Addresses { .. } | HostChange::Vendor(_) => {
Significance::Routine
}
HostChange::Findings {
appeared,
resolved,
reassessed,
} => of_findings(appeared, resolved, reassessed),
}
}
}
impl PortChange {
pub fn significance(&self) -> Significance {
match self {
PortChange::State(state) => of_state(state),
PortChange::Service(service) => of_service(service),
PortChange::Security(security) => of_security(security),
PortChange::Findings {
appeared,
resolved,
reassessed,
} => of_findings(appeared, resolved, reassessed),
}
}
}
impl PortDelta {
pub fn significance(&self) -> Significance {
let presence = if !self.presence().is_confirmed() {
Significance::Routine
} else if self.is_opened() {
Significance::Urgent
} else if self.is_closed() {
Significance::Notable
} else {
Significance::Routine
};
self.changes()
.iter()
.map(PortChange::significance)
.fold(presence, Significance::max)
}
}
impl HostDelta {
pub fn significance(&self) -> Significance {
let presence = match self.presence() {
Presence::Both => Significance::Routine,
presence if !presence.is_confirmed() => Significance::Routine,
Presence::Added { .. } | Presence::Removed { .. } => Significance::Notable,
};
let own = self
.changes()
.iter()
.map(HostChange::significance)
.fold(presence, Significance::max);
self.ports()
.iter()
.map(PortDelta::significance)
.fold(own, Significance::max)
}
}
impl ScanDiff {
pub fn significance(&self) -> Significance {
self.hosts()
.iter()
.map(HostDelta::significance)
.fold(Significance::Routine, Significance::max)
}
}
const fn answers(status: HostStatus) -> bool {
matches!(status, HostStatus::Up | HostStatus::Filtered)
}
fn of_state(state: &Change<PortState>) -> Significance {
let was_open = state.before == PortState::Open;
let is_open = state.after == PortState::Open;
match (was_open, is_open) {
(false, true) => Significance::Urgent,
(true, false) => Significance::Notable,
_ => Significance::Routine,
}
}
fn of_service(change: &ServiceChange) -> Significance {
match change {
ServiceChange::Name(_) | ServiceChange::Version(_) => Significance::Notable,
ServiceChange::Identified(_)
| ServiceChange::Unidentified(_)
| ServiceChange::Product(_)
| ServiceChange::Vendor(_)
| ServiceChange::ExtraInfo(_)
| ServiceChange::Cpes { .. } => Significance::Routine,
}
}
fn of_security(change: &SecurityChange) -> Significance {
match change {
SecurityChange::TlsVersion(_) => Significance::Notable,
SecurityChange::CipherSuite(_) | SecurityChange::Alpn { .. } => Significance::Routine,
SecurityChange::Certificate(certificate) => match certificate {
CertificateChange::Expired { .. } => Significance::Urgent,
CertificateChange::Expiring { .. }
| CertificateChange::Presented(_)
| CertificateChange::Withdrawn(_) => Significance::Notable,
CertificateChange::Rotated { .. } => Significance::Routine,
},
}
}
fn of_findings(
appeared: &[Finding],
_resolved: &[Finding],
reassessed: &[Reassessment],
) -> Significance {
let raised = reassessed
.iter()
.filter(|shift| shift.severity.after > shift.severity.before)
.map(|shift| Significance::of_severity(shift.severity.after));
appeared
.iter()
.map(|finding| Significance::of_severity(finding.severity()))
.chain(raised)
.fold(Significance::Routine, Significance::max)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::model::confidence::Confidence;
use crate::model::finding::{DetectionClass, DetectionId, Version};
fn finding(severity: Severity) -> Finding {
Finding::new(
DetectionId::new("test", Version::new(1, 0, 0), "hash").expect("a detection id"),
"A finding",
severity,
Confidence::Certain,
DetectionClass::ActiveBenign,
)
.expect("a finding")
}
#[test]
fn the_grades_are_ordered_least_first() {
assert!(Significance::Routine < Significance::Notable);
assert!(Significance::Notable < Significance::Urgent);
assert_eq!(
Significance::ALL,
[
Significance::Routine,
Significance::Notable,
Significance::Urgent
]
);
}
#[test]
fn a_port_that_opened_outranks_one_that_closed() {
let opened = PortChange::State(Change::new(PortState::Filtered, PortState::Open));
let closed = PortChange::State(Change::new(PortState::Open, PortState::Filtered));
assert_eq!(opened.significance(), Significance::Urgent);
assert_eq!(closed.significance(), Significance::Notable);
assert!(opened.significance() > closed.significance());
}
#[test]
fn a_verdict_moving_between_two_closed_states_is_routine() {
for (before, after) in [
(PortState::Filtered, PortState::Closed),
(PortState::Closed, PortState::Unfiltered),
(PortState::ClosedFiltered, PortState::Filtered),
] {
assert_eq!(
PortChange::State(Change::new(before, after)).significance(),
Significance::Routine,
"{before:?} to {after:?}"
);
}
}
#[test]
fn a_lapsed_certificate_is_the_one_urgent_thing_about_transport_security() {
use crate::model::port::security::CertificateInfo;
use std::time::{Duration, SystemTime};
let certificate = CertificateInfo::new(
"example.test",
"Test CA",
SystemTime::UNIX_EPOCH,
SystemTime::UNIX_EPOCH + Duration::from_secs(1),
"fingerprint",
);
let expired =
PortChange::Security(SecurityChange::Certificate(CertificateChange::Expired {
certificate: Box::new(certificate.clone()),
since: Duration::from_secs(60),
}));
let expiring =
PortChange::Security(SecurityChange::Certificate(CertificateChange::Expiring {
certificate: Box::new(certificate.clone()),
remaining: Duration::from_secs(60),
}));
let rotated =
PortChange::Security(SecurityChange::Certificate(CertificateChange::Rotated {
before: Box::new(certificate.clone()),
after: Box::new(certificate),
}));
assert_eq!(expired.significance(), Significance::Urgent);
assert_eq!(expiring.significance(), Significance::Notable);
assert_eq!(rotated.significance(), Significance::Routine);
}
#[test]
fn a_finding_is_graded_by_its_own_severity() {
for (severity, expected) in [
(Severity::Info, Significance::Routine),
(Severity::Low, Significance::Routine),
(Severity::Medium, Significance::Notable),
(Severity::High, Significance::Urgent),
(Severity::Critical, Significance::Urgent),
] {
let change = HostChange::Findings {
appeared: vec![finding(severity)],
resolved: Vec::new(),
reassessed: Vec::new(),
};
assert_eq!(change.significance(), expected, "{severity:?}");
}
}
#[test]
fn a_finding_that_went_away_or_was_graded_down_is_routine() {
let resolved = HostChange::Findings {
appeared: Vec::new(),
resolved: vec![finding(Severity::Critical)],
reassessed: Vec::new(),
};
assert_eq!(resolved.significance(), Significance::Routine);
let downgraded = HostChange::Findings {
appeared: Vec::new(),
resolved: Vec::new(),
reassessed: vec![Reassessment {
finding: finding(Severity::Low),
severity: Change::new(Severity::Critical, Severity::Low),
}],
};
assert_eq!(downgraded.significance(), Significance::Routine);
let raised = HostChange::Findings {
appeared: Vec::new(),
resolved: Vec::new(),
reassessed: vec![Reassessment {
finding: finding(Severity::Critical),
severity: Change::new(Severity::Low, Severity::Critical),
}],
};
assert_eq!(raised.significance(), Significance::Urgent);
}
#[test]
fn a_status_change_is_graded_by_whether_the_host_is_there() {
let arrived = HostChange::Status(Change::new(HostStatus::Unknown, HostStatus::Up));
let went = HostChange::Status(Change::new(HostStatus::Up, HostStatus::Unknown));
let filtered = HostChange::Status(Change::new(HostStatus::Up, HostStatus::Filtered));
let quiet = HostChange::Status(Change::new(HostStatus::Unknown, HostStatus::Down));
assert_eq!(arrived.significance(), Significance::Notable);
assert_eq!(went.significance(), Significance::Notable);
assert_eq!(filtered.significance(), Significance::Routine);
assert_eq!(quiet.significance(), Significance::Routine);
}
}