1use std::collections::{BTreeMap, BTreeSet};
24use std::time::Duration;
25use std::time::SystemTime;
26
27use crate::diff::change::{Change, Coverage, Presence};
28use crate::diff::host::Reassessment;
29use crate::model::finding::{Finding, Standing};
30use crate::model::port::security::CertificateInfo;
31use crate::model::port::{Build, Port, PortState, Protocol, Security, Service};
32
33#[derive(Debug, Clone, PartialEq)]
39pub struct PortDelta {
40 number: u16,
41 protocol: Protocol,
42 presence: Presence,
43 baseline: Option<Port>,
44 current: Option<Port>,
45 changes: Vec<PortChange>,
46}
47
48impl PortDelta {
49 pub fn number(&self) -> u16 {
51 self.number
52 }
53
54 pub fn protocol(&self) -> Protocol {
56 self.protocol
57 }
58
59 pub fn presence(&self) -> Presence {
62 self.presence
63 }
64
65 pub fn baseline(&self) -> Option<&Port> {
70 self.baseline.as_ref()
71 }
72
73 pub fn current(&self) -> Option<&Port> {
75 self.current.as_ref()
76 }
77
78 pub fn changes(&self) -> &[PortChange] {
81 &self.changes
82 }
83
84 pub fn is_empty(&self) -> bool {
89 self.presence.is_in_both() && self.changes.is_empty()
90 }
91
92 pub fn is_opened(&self) -> bool {
100 self.state_of(self.current.as_ref()) == Some(PortState::Open)
101 && self.state_of(self.baseline.as_ref()) != Some(PortState::Open)
102 }
103
104 pub fn is_closed(&self) -> bool {
108 self.state_of(self.baseline.as_ref()) == Some(PortState::Open)
109 && self.state_of(self.current.as_ref()) != Some(PortState::Open)
110 }
111
112 fn state_of(&self, port: Option<&Port>) -> Option<PortState> {
113 port.map(Port::state)
114 }
115}
116
117#[non_exhaustive]
122#[derive(Debug, Clone, PartialEq)]
123pub enum PortChange {
124 State(Change<PortState>),
128 Service(ServiceChange),
130 Security(SecurityChange),
132 Findings {
148 appeared: Vec<Finding>,
150 resolved: Vec<Finding>,
153 unsettled: Vec<Finding>,
156 reassessed: Vec<Reassessment>,
158 },
159}
160
161#[non_exhaustive]
166#[derive(Debug, Clone, PartialEq)]
167pub enum ServiceChange {
168 Identified(Service),
170 Unidentified(Service),
175 Name(Change<String>),
177 Product(Change<Option<String>>),
179 Vendor(Change<Option<String>>),
181 Version(Change<Option<String>>),
183 ExtraInfo(Change<Option<String>>),
185 Build(Change<Option<Build>>),
189 Cpes {
191 gained: Vec<String>,
193 lost: Vec<String>,
195 },
196}
197
198#[non_exhaustive]
200#[derive(Debug, Clone, PartialEq)]
201pub enum SecurityChange {
202 TlsVersion(Change<Option<String>>),
204 CipherSuite(Change<Option<String>>),
206 Alpn {
208 gained: Vec<String>,
210 lost: Vec<String>,
212 },
213 Certificate(CertificateChange),
215}
216
217#[non_exhaustive]
227#[derive(Debug, Clone, PartialEq)]
228pub enum CertificateChange {
229 Presented(CertificateInfo),
231 Withdrawn(CertificateInfo),
233 Rotated {
235 before: Box<CertificateInfo>,
237 after: Box<CertificateInfo>,
239 },
240 Expiring {
243 certificate: Box<CertificateInfo>,
245 remaining: Duration,
247 },
248 Expired {
251 certificate: Box<CertificateInfo>,
253 since: Duration,
255 },
256}
257
258#[derive(Debug, Clone, Copy, PartialEq, Eq)]
263enum Validity {
264 Absent,
267 NotYetValid,
268 Valid,
269 Expiring,
270 Expired,
271}
272
273pub(crate) struct Clocks {
276 pub(crate) baseline: SystemTime,
277 pub(crate) current: SystemTime,
278 pub(crate) expiry_threshold: Duration,
279}
280
281pub(crate) fn compare<'a>(
291 baseline: &[&'a Port],
292 current: &[&'a Port],
293 presence: PresenceFor<'_>,
294 clocks: &Clocks,
295) -> Vec<PortDelta> {
296 let index = |ports: &[&'a Port]| -> BTreeMap<(u16, Protocol), &'a Port> {
300 ports
301 .iter()
302 .filter(|port| port.state() != PortState::Unasked)
303 .map(|port| ((port.number(), port.protocol()), *port))
304 .collect()
305 };
306 let unreached = |ports: &[&'a Port]| -> BTreeSet<(u16, Protocol)> {
307 ports
308 .iter()
309 .filter(|port| port.state() == PortState::Unasked)
310 .map(|port| (port.number(), port.protocol()))
311 .collect()
312 };
313
314 let baseline_unreached = unreached(baseline);
315 let current_unreached = unreached(current);
316 let baseline = index(baseline);
317 let current = index(current);
318
319 let keys: BTreeSet<(u16, Protocol)> = baseline.keys().chain(current.keys()).copied().collect();
320
321 let mut deltas = Vec::new();
322 for (number, protocol) in keys {
323 let before = baseline.get(&(number, protocol)).copied();
324 let after = current.get(&(number, protocol)).copied();
325
326 let (presence, changes) = match (before, after) {
327 (Some(_), Some(_)) => (Presence::Both, changes_between(before, after, clocks)),
328 (Some(_), None) => (
329 presence.removed(number, protocol, ¤t_unreached),
330 Vec::new(),
331 ),
332 (None, Some(_)) => (
333 presence.added(number, protocol, &baseline_unreached),
334 Vec::new(),
335 ),
336 (None, None) => unreachable!("a key comes from one side or the other"),
337 };
338
339 if presence.is_in_both() && changes.is_empty() {
340 continue;
341 }
342
343 deltas.push(PortDelta {
344 number,
345 protocol,
346 presence,
347 baseline: before.cloned(),
348 current: after.cloned(),
349 changes,
350 });
351 }
352
353 deltas
354}
355
356pub(crate) struct PresenceFor<'a> {
361 pub(crate) baseline: &'a dyn Fn(u16, Protocol) -> Coverage,
362 pub(crate) current: &'a dyn Fn(u16, Protocol) -> Coverage,
363}
364
365impl PresenceFor<'_> {
366 fn added(
367 &self,
368 number: u16,
369 protocol: Protocol,
370 unreached: &BTreeSet<(u16, Protocol)>,
371 ) -> Presence {
372 Presence::Added {
373 before: Self::coverage(self.baseline, number, protocol, unreached),
374 }
375 }
376
377 fn removed(
378 &self,
379 number: u16,
380 protocol: Protocol,
381 unreached: &BTreeSet<(u16, Protocol)>,
382 ) -> Presence {
383 Presence::Removed {
384 after: Self::coverage(self.current, number, protocol, unreached),
385 }
386 }
387
388 fn coverage(
394 scope: &dyn Fn(u16, Protocol) -> Coverage,
395 number: u16,
396 protocol: Protocol,
397 unreached: &BTreeSet<(u16, Protocol)>,
398 ) -> Coverage {
399 if unreached.contains(&(number, protocol)) {
400 Coverage::Unreached
401 } else {
402 scope(number, protocol)
403 }
404 }
405}
406
407fn changes_between(
409 before: Option<&Port>,
410 after: Option<&Port>,
411 clocks: &Clocks,
412) -> Vec<PortChange> {
413 let (Some(before), Some(after)) = (before, after) else {
414 return Vec::new();
415 };
416
417 let mut changes = Vec::new();
418
419 if let Some(state) = Change::between(before.state(), after.state()) {
420 changes.push(PortChange::State(state));
421 }
422
423 changes.extend(
424 service_changes(before.service(), after.service())
425 .into_iter()
426 .map(PortChange::Service),
427 );
428
429 changes.extend(
430 security_changes(before.security(), after.security(), clocks)
431 .into_iter()
432 .map(PortChange::Security),
433 );
434
435 let (appeared, gone, reassessed) =
436 super::host::findings_between(before.findings(), after.findings());
437
438 let (unsettled, resolved): (Vec<Finding>, Vec<Finding>) = gone
441 .into_iter()
442 .partition(|finding| standing(finding, before, after) == Some(Standing::Unsettled));
443
444 if !appeared.is_empty()
445 || !resolved.is_empty()
446 || !unsettled.is_empty()
447 || !reassessed.is_empty()
448 {
449 changes.push(PortChange::Findings {
450 appeared,
451 resolved,
452 unsettled,
453 reassessed,
454 });
455 }
456
457 changes
458}
459
460fn standing(finding: &Finding, before: &Port, after: &Port) -> Option<Standing> {
470 if finding.is_correlation() {
471 return correlation_standing(finding, before.service()?, after.service());
472 }
473 let silent = Security::new();
474 let now = after.security().unwrap_or(&silent);
475 now.standing(finding, before.security()?)
476}
477
478fn correlation_standing(
492 finding: &Finding,
493 basis: &Service,
494 now: Option<&Service>,
495) -> Option<Standing> {
496 let backs = |service: &Service| finding.cpes().any(|cpe| service.cpes().contains(cpe));
497 if !backs(basis) {
498 return None;
499 }
500 let Some(now) = now.filter(|service| !service.is_inferred()) else {
501 return Some(Standing::Unsettled);
502 };
503 if backs(now) {
504 return Some(Standing::Upheld);
505 }
506
507 let differs = |stated: Option<&str>, then: Option<&str>| {
508 stated.is_some_and(|stated| then.is_none_or(|then| stated != then))
509 };
510 let contradicts = now.name() != basis.name()
511 || differs(now.product(), basis.product())
512 || differs(now.version(), basis.version());
513 Some(if contradicts {
514 Standing::Overturned
515 } else {
516 Standing::Unsettled
517 })
518}
519
520fn service_changes(before: Option<&Service>, after: Option<&Service>) -> Vec<ServiceChange> {
526 let before = before.filter(|service| !service.is_inferred());
527 let after = after.filter(|service| !service.is_inferred());
528
529 match (before, after) {
530 (None, None) => Vec::new(),
531 (None, Some(after)) => vec![ServiceChange::Identified(after.clone())],
532 (Some(before), None) => vec![ServiceChange::Unidentified(before.clone())],
533 (Some(before), Some(after)) => {
534 let mut changes = Vec::new();
535
536 if let Some(name) = Change::between(before.name().to_owned(), after.name().to_owned()) {
537 changes.push(ServiceChange::Name(name));
538 }
539 if let Some(product) = optional(before.product(), after.product()) {
540 changes.push(ServiceChange::Product(product));
541 }
542 if let Some(vendor) = optional(before.vendor(), after.vendor()) {
543 changes.push(ServiceChange::Vendor(vendor));
544 }
545 if let Some(version) = optional(before.version(), after.version()) {
546 changes.push(ServiceChange::Version(version));
547 }
548 if let Some(extra) = optional(before.extrainfo(), after.extrainfo()) {
549 changes.push(ServiceChange::ExtraInfo(extra));
550 }
551 if let Some(build) = Change::between(before.build().cloned(), after.build().cloned()) {
552 changes.push(ServiceChange::Build(build));
553 }
554
555 let (gained, lost) = set_change(
556 before.cpes().iter().map(|cpe| cpe.to_string()),
557 after.cpes().iter().map(|cpe| cpe.to_string()),
558 );
559 if !gained.is_empty() || !lost.is_empty() {
560 changes.push(ServiceChange::Cpes { gained, lost });
561 }
562
563 changes
564 }
565 }
566}
567
568fn security_changes(
570 before: Option<&Security>,
571 after: Option<&Security>,
572 clocks: &Clocks,
573) -> Vec<SecurityChange> {
574 let mut changes = Vec::new();
575
576 let before_version = before.and_then(Security::tls_version);
577 let after_version = after.and_then(Security::tls_version);
578 if let Some(version) = optional(before_version, after_version) {
579 changes.push(SecurityChange::TlsVersion(version));
580 }
581
582 let before_cipher = before.and_then(Security::cipher_suite);
583 let after_cipher = after.and_then(Security::cipher_suite);
584 if let Some(cipher) = optional(before_cipher, after_cipher) {
585 changes.push(SecurityChange::CipherSuite(cipher));
586 }
587
588 let (gained, lost) = set_change(
589 before
590 .map(Security::alpn)
591 .unwrap_or_default()
592 .iter()
593 .map(|p| p.to_string()),
594 after
595 .map(Security::alpn)
596 .unwrap_or_default()
597 .iter()
598 .map(|p| p.to_string()),
599 );
600 if !gained.is_empty() || !lost.is_empty() {
601 changes.push(SecurityChange::Alpn { gained, lost });
602 }
603
604 changes.extend(
605 certificate_changes(before, after, clocks)
606 .into_iter()
607 .map(SecurityChange::Certificate),
608 );
609
610 changes
611}
612
613fn certificate_changes(
616 before: Option<&Security>,
617 after: Option<&Security>,
618 clocks: &Clocks,
619) -> Vec<CertificateChange> {
620 let before_cert = before.and_then(Security::certificate);
621 let after_cert = after.and_then(Security::certificate);
622
623 let mut changes = Vec::new();
624
625 match (before_cert, after_cert) {
626 (None, None) => return changes,
627 (None, Some(after)) => changes.push(CertificateChange::Presented(after.clone())),
628 (Some(before), None) => {
629 changes.push(CertificateChange::Withdrawn(before.clone()));
630 return changes;
631 }
632 (Some(before), Some(after)) => {
633 if before.fingerprint_sha256() != after.fingerprint_sha256() {
634 changes.push(CertificateChange::Rotated {
635 before: Box::new(before.clone()),
636 after: Box::new(after.clone()),
637 });
638 }
639 }
640 }
641
642 let same_certificate = matches!(
647 (before_cert, after_cert),
648 (Some(before), Some(after))
649 if before.fingerprint_sha256() == after.fingerprint_sha256()
650 );
651 let was = if same_certificate {
652 validity(after, clocks.expiry_threshold, clocks.baseline)
653 } else {
654 Validity::Absent
655 };
656 let is = validity(after, clocks.expiry_threshold, clocks.current);
657
658 if let Some(certificate) = after_cert {
659 match is {
660 Validity::Expiring if was != Validity::Expiring => {
661 let remaining = certificate
662 .validity_end()
663 .duration_since(clocks.current)
664 .unwrap_or_default();
665 changes.push(CertificateChange::Expiring {
666 certificate: Box::new(certificate.clone()),
667 remaining,
668 });
669 }
670 Validity::Expired if was != Validity::Expired => {
671 let since = clocks
672 .current
673 .duration_since(certificate.validity_end())
674 .unwrap_or_default();
675 changes.push(CertificateChange::Expired {
676 certificate: Box::new(certificate.clone()),
677 since,
678 });
679 }
680 _ => {}
681 }
682 }
683
684 changes
685}
686
687fn validity(security: Option<&Security>, threshold: Duration, at: SystemTime) -> Validity {
689 let Some(security) = security else {
690 return Validity::Absent;
691 };
692 let Some(certificate) = security.certificate() else {
693 return Validity::Absent;
694 };
695
696 if at < certificate.validity_start() {
699 Validity::NotYetValid
700 } else if at > certificate.validity_end() {
701 Validity::Expired
702 } else if security.is_cert_expiring_at(threshold, at) {
703 Validity::Expiring
704 } else {
705 Validity::Valid
706 }
707}
708
709fn optional(before: Option<&str>, after: Option<&str>) -> Option<Change<Option<String>>> {
712 Change::between(before.map(str::to_owned), after.map(str::to_owned))
713}
714
715fn set_change(
717 before: impl Iterator<Item = String>,
718 after: impl Iterator<Item = String>,
719) -> (Vec<String>, Vec<String>) {
720 let before: std::collections::BTreeSet<String> = before.collect();
721 let after: std::collections::BTreeSet<String> = after.collect();
722
723 let gained = after.difference(&before).cloned().collect();
724 let lost = before.difference(&after).cloned().collect();
725 (gained, lost)
726}
727
728#[cfg(test)]
738mod tests {
739 use super::*;
740 use crate::model::confidence::Confidence;
741 use crate::model::finding::{DetectionClass, DetectionId, Severity, Version};
742 use crate::model::tls::{
743 CipherSuite, Interruption, TlsSupport, TlsVersion, UnfinishedVersion, VersionSupport,
744 };
745
746 fn clocks() -> Clocks {
747 Clocks {
748 baseline: SystemTime::UNIX_EPOCH,
749 current: SystemTime::UNIX_EPOCH,
750 expiry_threshold: Duration::from_secs(30 * 24 * 60 * 60),
751 }
752 }
753
754 fn port(state: PortState) -> Port {
755 Port::new(443, Protocol::Tcp, state)
756 }
757
758 fn finding(title: &str) -> Finding {
759 Finding::new(
760 DetectionId::new("audit", Version::new(1, 0, 0), "hash").expect("a detection id"),
761 title,
762 Severity::High,
763 Confidence::Certain,
764 DetectionClass::Passive,
765 )
766 .expect("a titled finding")
767 }
768
769 type Moved<'a> = (
772 &'a [Finding],
773 &'a [Finding],
774 &'a [Finding],
775 &'a [Reassessment],
776 );
777
778 fn findings_change(changes: &[PortChange]) -> Option<Moved<'_>> {
779 changes.iter().find_map(|change| match change {
780 PortChange::Findings {
781 appeared,
782 resolved,
783 unsettled,
784 reassessed,
785 } => Some((
786 appeared.as_slice(),
787 resolved.as_slice(),
788 unsettled.as_slice(),
789 reassessed.as_slice(),
790 )),
791 _ => None,
792 })
793 }
794
795 #[test]
796 fn an_endpoint_that_did_not_move_reports_nothing() {
797 let before = port(PortState::Open);
798 let after = port(PortState::Open);
799 assert!(changes_between(Some(&before), Some(&after), &clocks()).is_empty());
800 }
801
802 #[test]
803 fn a_state_change_is_reported() {
804 let before = port(PortState::Open);
805 let after = port(PortState::Closed);
806
807 let changes = changes_between(Some(&before), Some(&after), &clocks());
808 assert!(changes.iter().any(|change| matches!(
809 change,
810 PortChange::State(state)
811 if state.before == PortState::Open && state.after == PortState::Closed
812 )));
813 }
814
815 #[test]
817 fn a_finding_that_appeared_on_the_endpoint_is_reported() {
818 let before = port(PortState::Open);
819 let mut after = port(PortState::Open);
820 after.add_finding(finding("Weak cipher"));
821
822 let changes = changes_between(Some(&before), Some(&after), &clocks());
823 let (appeared, resolved, _, _) = findings_change(&changes).expect("a findings change");
824 assert_eq!(appeared.len(), 1);
825 assert_eq!(appeared[0].title(), "Weak cipher");
826 assert!(resolved.is_empty());
827 }
828
829 #[test]
830 fn a_finding_that_went_away_from_the_endpoint_is_reported_as_resolved() {
831 let mut before = port(PortState::Open);
832 before.add_finding(finding("Weak cipher"));
833 let after = port(PortState::Open);
834
835 let changes = changes_between(Some(&before), Some(&after), &clocks());
836 let (appeared, resolved, _, _) = findings_change(&changes).expect("a findings change");
837 assert!(appeared.is_empty());
838 assert_eq!(resolved.len(), 1);
839 }
840
841 fn enumerated(support: TlsSupport) -> Port {
844 let findings = support.findings();
845 let mut port = port(PortState::Open).with_security(Security::new().with_support(support));
846 for finding in findings {
847 port.add_finding(finding);
848 }
849 port
850 }
851
852 fn ten_accepted() -> TlsSupport {
855 TlsSupport::new().accepting(VersionSupport::new(
856 TlsVersion::Tls10,
857 vec![CipherSuite::from_code(0x002F).expect("a registered suite")],
858 vec![],
859 ))
860 }
861
862 fn titles(findings: &[Finding]) -> Vec<&str> {
863 findings.iter().map(Finding::title).collect()
864 }
865
866 #[test]
870 fn a_finding_a_cut_short_walk_did_not_get_back_to_is_not_resolved() {
871 let before = enumerated(ten_accepted());
872 let after = enumerated(TlsSupport::new().leaving_unfinished(UnfinishedVersion::new(
873 TlsVersion::Tls10,
874 Interruption::Stopped,
875 )));
876 assert!(
877 titles(&before.findings().cloned().collect::<Vec<_>>())
878 .contains(&"TLSv1.0 is still accepted"),
879 "the baseline's walk draws the claim this is about"
880 );
881
882 let changes = changes_between(Some(&before), Some(&after), &clocks());
883 let (_, resolved, unsettled, _) = findings_change(&changes).expect("a findings change");
884 assert!(
885 resolved.is_empty(),
886 "a walk that never finished reported {:?} resolved",
887 titles(resolved)
888 );
889 assert_eq!(
890 titles(unsettled),
891 titles(&before.findings().cloned().collect::<Vec<_>>()),
892 "every claim the baseline drew from TLS 1.0 is said to be unsettled"
893 );
894 }
895
896 #[test]
899 fn a_finding_a_finished_walk_refuted_is_resolved() {
900 let before = enumerated(ten_accepted());
901 let after = enumerated(TlsSupport::new().accepting(VersionSupport::new(
902 TlsVersion::Tls13,
903 vec![CipherSuite::from_code(0x1301).expect("a registered suite")],
904 vec![],
905 )));
906
907 let changes = changes_between(Some(&before), Some(&after), &clocks());
908 let (_, resolved, unsettled, _) = findings_change(&changes).expect("a findings change");
909 assert!(unsettled.is_empty(), "{:?}", titles(unsettled));
910 assert!(titles(resolved).contains(&"TLSv1.0 is still accepted"));
911 }
912
913 fn presenting(fingerprint: &str) -> Port {
917 let certificate = CertificateInfo::new(
918 "www.example.test",
919 "www.example.test",
920 SystemTime::UNIX_EPOCH,
921 SystemTime::UNIX_EPOCH + Duration::from_secs(365 * 24 * 60 * 60),
922 fingerprint,
923 )
924 .with_public_key("RSA", 2048);
925 let findings = certificate.findings(SystemTime::UNIX_EPOCH);
926 let mut port = port(PortState::Open).with_security(
927 Security::new()
928 .with_tls_version("TLSv1.3")
929 .with_certificate(certificate),
930 );
931 for finding in findings {
932 port.add_finding(finding);
933 }
934 port
935 }
936
937 #[test]
942 fn a_posture_finding_the_current_scan_saw_no_certificate_for_is_not_resolved() {
943 let before = presenting("aaaa");
944 let unparsed =
945 port(PortState::Open).with_security(Security::new().with_tls_version("TLSv1.3"));
946 assert_eq!(
947 titles(&before.findings().cloned().collect::<Vec<_>>()),
948 ["TLS certificate is self-signed"],
949 "the baseline's certificate draws the claim this is about"
950 );
951
952 for after in [port(PortState::Open), unparsed] {
953 let changes = changes_between(Some(&before), Some(&after), &clocks());
954 assert!(
955 changes.iter().any(|change| matches!(
956 change,
957 PortChange::Security(SecurityChange::Certificate(
958 CertificateChange::Withdrawn(_)
959 ))
960 )),
961 "the certificate's absence is still reported as such"
962 );
963 let (_, resolved, unsettled, _) = findings_change(&changes).expect("a findings change");
964 assert!(
965 resolved.is_empty(),
966 "a scan shown no certificate reported {:?} resolved",
967 titles(resolved)
968 );
969 assert_eq!(titles(unsettled), ["TLS certificate is self-signed"]);
970 }
971 }
972
973 #[test]
977 fn a_posture_finding_the_current_scan_was_shown_another_certificate_for_is_resolved() {
978 let before = presenting("aaaa");
979 let after = port(PortState::Open).with_security(
980 Security::new()
981 .with_tls_version("TLSv1.3")
982 .with_certificate(
983 CertificateInfo::new(
984 "www.example.test",
985 "Example CA",
986 SystemTime::UNIX_EPOCH,
987 SystemTime::UNIX_EPOCH + Duration::from_secs(365 * 24 * 60 * 60),
988 "bbbb",
989 )
990 .with_public_key("RSA", 2048),
991 ),
992 );
993
994 let changes = changes_between(Some(&before), Some(&after), &clocks());
995 let (_, resolved, unsettled, _) = findings_change(&changes).expect("a findings change");
996 assert!(unsettled.is_empty(), "{:?}", titles(unsettled));
997 assert_eq!(titles(resolved), ["TLS certificate is self-signed"]);
998 }
999
1000 fn correlated() -> Port {
1003 const CPE: &str = "cpe:/a:apache:http_server:2.4.49";
1004 let mut port = port(PortState::Open);
1005 port.set_service(
1006 Service::new("http", 90)
1007 .with_product("Apache httpd")
1008 .with_version("2.4.49")
1009 .with_cpe(CPE),
1010 );
1011 port.add_finding(
1012 finding("Apache httpd 2.4.49: path traversal")
1013 .with_reference(crate::model::finding::Reference::Cve(
1014 "CVE-2021-41773".into(),
1015 ))
1016 .with_cpe(CPE),
1017 );
1018 port
1019 }
1020
1021 #[test]
1025 fn a_correlation_the_current_scan_identified_nothing_to_test_is_not_resolved() {
1026 let before = correlated();
1027
1028 let mut labelled = port(PortState::Open);
1029 labelled.set_service(Service::new("http", 0));
1030 let mut unversioned = port(PortState::Open);
1031 unversioned.set_service(Service::new("http", 90).with_product("Apache httpd"));
1032
1033 for (case, after) in [
1034 ("no service at all", port(PortState::Open)),
1035 ("a port-number label", labelled),
1036 ("the same software without a version", unversioned),
1037 ] {
1038 let changes = changes_between(Some(&before), Some(&after), &clocks());
1039 let (_, resolved, unsettled, _) = findings_change(&changes).expect("a findings change");
1040 assert!(
1041 resolved.is_empty(),
1042 "{case}: reported {:?} resolved",
1043 titles(resolved)
1044 );
1045 assert_eq!(
1046 titles(unsettled),
1047 ["Apache httpd 2.4.49: path traversal"],
1048 "{case}"
1049 );
1050 }
1051 }
1052
1053 #[test]
1056 fn a_correlation_a_newer_identification_no_longer_backs_is_resolved() {
1057 let before = correlated();
1058 let mut upgraded = port(PortState::Open);
1059 upgraded.set_service(
1060 Service::new("http", 90)
1061 .with_product("Apache httpd")
1062 .with_version("2.4.58")
1063 .with_cpe("cpe:/a:apache:http_server:2.4.58"),
1064 );
1065 let mut replaced = port(PortState::Open);
1066 replaced.set_service(Service::new("http", 90).with_product("nginx"));
1067
1068 for (case, after) in [("upgraded", upgraded), ("replaced", replaced)] {
1069 let changes = changes_between(Some(&before), Some(&after), &clocks());
1070 let (_, resolved, unsettled, _) = findings_change(&changes).expect("a findings change");
1071 assert!(unsettled.is_empty(), "{case}: {:?}", titles(unsettled));
1072 assert_eq!(
1073 titles(resolved),
1074 ["Apache httpd 2.4.49: path traversal"],
1075 "{case}"
1076 );
1077 }
1078 }
1079
1080 #[test]
1083 fn an_endpoint_present_on_one_side_only_reports_no_field_changes() {
1084 let only = port(PortState::Open);
1085 assert!(changes_between(Some(&only), None, &clocks()).is_empty());
1086 assert!(changes_between(None, Some(&only), &clocks()).is_empty());
1087 }
1088}