1use std::collections::{BTreeSet, HashMap, HashSet};
39use std::net::IpAddr;
40
41use tokio::sync::mpsc::UnboundedSender;
42
43use crate::config::limits;
44use crate::config::{ProbeTuning, ZondConfig};
45use crate::model::exclusion::Exclusions;
46use crate::model::ip::range::{IpRange, Ipv6Range};
47use crate::model::ip::scoped::ZoneMap;
48use crate::model::ip::set::IpSet;
49use crate::model::mac::MacAddr;
50use crate::model::port::Protocol;
51use crate::model::technique::TcpScanTechnique;
52use crate::report::ScannerKind;
53use crate::scanner::session::ScanContext;
54use crate::scanner::strategy::connect::{
55 ConnectPortScanner, ConnectScanner, ConnectUdpPortScanner,
56};
57use crate::scanner::strategy::local::{LocalScanner, Scope};
58use crate::scanner::strategy::ports::{
59 IdlePortScanner, SctpPortScanner, TcpPortScanner, UdpPortScanner,
60};
61use crate::scanner::strategy::routed::{RoutedScanner, SynPorts};
62use crate::scanner::strategy::{HostScanner, PortScanner, StrategyError};
63use crate::system::interface::Link;
64use crate::system::interface::{self, RoutedTarget};
65use crate::system::neighbor_cache;
66use crate::system::privilege::Privilege;
67use crate::{counted, info, warn};
68
69#[non_exhaustive]
74#[derive(Debug, Clone)]
75pub struct RefusedStep {
76 pub scanner: ScannerKind,
78 pub reason: String,
81}
82
83impl RefusedStep {
84 pub fn technique_needs_raw_sockets(technique: TcpScanTechnique) -> Self {
93 Self {
94 scanner: ScannerKind::for_raw_tcp(technique),
95 reason: format!("tcp ports: {technique} scan needs raw sockets (sudo)"),
96 }
97 }
98
99 pub fn sctp_needs_raw_sockets() -> Self {
104 Self {
105 scanner: ScannerKind::SctpPort,
106 reason: "sctp ports: init scan needs raw sockets (sudo)".to_string(),
107 }
108 }
109
110 pub fn sctp_not_in_an_idle_scan() -> Self {
115 Self {
116 scanner: ScannerKind::SctpPort,
117 reason: "sctp ports: not probed in an idle scan".to_string(),
118 }
119 }
120
121 pub fn udp_not_in_an_idle_scan() -> Self {
127 Self {
128 scanner: ScannerKind::UdpPort,
129 reason: "udp ports: not probed in an idle scan".to_string(),
130 }
131 }
132
133 pub(crate) fn technique_beyond_frames(technique: TcpScanTechnique, targets: u128) -> Self {
138 Self {
139 scanner: ScannerKind::for_raw_tcp(technique),
140 reason: format!(
141 "tcp ports on {}: {technique} scan needs a raw socket (sudo)",
142 counted(targets, "target", "targets"),
143 ),
144 }
145 }
146
147 pub(crate) fn sctp_beyond_frames(targets: u128) -> Self {
150 Self {
151 scanner: ScannerKind::SctpPort,
152 reason: format!(
153 "sctp ports on {}: init scan needs a raw socket (sudo)",
154 counted(targets, "target", "targets"),
155 ),
156 }
157 }
158
159 pub(crate) fn pass_beyond_frames(scanner: ScannerKind, pass: &str, hosts: u128) -> Self {
165 Self {
166 scanner,
167 reason: format!(
168 "{pass} on {}: needs a raw socket (sudo)",
169 counted(hosts, "host", "hosts"),
170 ),
171 }
172 }
173
174 pub(crate) fn pass_not_in_an_idle_scan(scanner: ScannerKind, pass: &str) -> Self {
184 Self {
185 scanner,
186 reason: format!("{pass}: not run in an idle scan"),
187 }
188 }
189
190 pub(crate) fn idle_zombie_excluded(zombie: IpAddr) -> Self {
196 Self {
197 scanner: ScannerKind::Idle,
198 reason: format!("idle scan: zombie {zombie} is excluded"),
199 }
200 }
201
202 pub fn idle_needs_privilege() -> Self {
208 Self {
209 scanner: ScannerKind::Idle,
210 reason: "idle scan: needs raw sockets (sudo)".to_owned(),
211 }
212 }
213
214 pub fn routed_range_not_enumerable(range: &Ipv6Range) -> Self {
219 Self {
220 scanner: ScannerKind::Routed,
221 reason: format!(
222 "{}: too large to walk (give addresses or a smaller prefix)",
223 describe(range)
224 ),
225 }
226 }
227
228 pub(crate) fn every_discovery_port_excluded(scanner: ScannerKind) -> Self {
235 Self {
236 scanner,
237 reason: "tcp liveness: every port it asks is excluded".to_owned(),
238 }
239 }
240
241 pub(crate) fn port_range_not_enumerable(range: &Ipv6Range, scanner: ScannerKind) -> Self {
247 Self {
248 scanner,
249 reason: format!(
250 "{}: too large to walk (give addresses or a smaller prefix)",
251 describe(range)
252 ),
253 }
254 }
255
256 pub fn unprivileged_range_not_enumerable(range: &Ipv6Range) -> Self {
263 Self {
264 scanner: ScannerKind::Connect,
265 reason: format!(
266 "{}: too large to walk (sudo sweeps a segment)",
267 describe(range)
268 ),
269 }
270 }
271
272 pub fn link_local_port_target_needs_an_interface(range: &Ipv6Range) -> Self {
282 let target = name(range);
283 Self {
284 scanner: ScannerKind::SynPort,
285 reason: format!("{target}: {}", name_an_interface(range)),
286 }
287 }
288
289 pub fn link_local_port_target_names_two_segments(range: &Ipv6Range) -> Self {
294 let target = name(range);
295 Self {
296 scanner: ScannerKind::SynPort,
297 reason: format!("{target}: named on two interfaces (scan one at a time)"),
298 }
299 }
300
301 pub fn local_range_needs_a_sweep(range: &Ipv6Range) -> Self {
312 Self {
313 scanner: ScannerKind::Local,
314 reason: format!(
315 "{}: too large to walk (sweep the segment instead)",
316 describe(range)
317 ),
318 }
319 }
320}
321
322fn withhold_unwalkable(targets: &mut IpSet) -> Vec<Ipv6Range> {
329 let unwalkable: Vec<Ipv6Range> = targets
330 .v6()
331 .iter()
332 .filter(|range| !interface::is_enumerable(range))
333 .copied()
334 .collect();
335
336 if unwalkable.is_empty() {
337 return unwalkable;
338 }
339
340 let mut kept = IpSet::new();
341 for range in targets.v4() {
342 kept.push_v4_range(*range);
343 }
344 for range in targets.v6() {
345 if interface::is_enumerable(range) {
346 kept.push_v6_range(*range);
347 }
348 }
349 kept.canonicalize();
350 *targets = kept;
351
352 unwalkable
353}
354
355impl From<RefusedStep> for crate::report::Refusal {
356 fn from(step: RefusedStep) -> Self {
360 Self::new(step.scanner, step.reason)
361 }
362}
363
364fn name(range: &Ipv6Range) -> String {
367 match range.start_addr() == range.end_addr() {
368 true => range.start_addr().to_string(),
369 false => format!("{}-{}", range.start_addr(), range.end_addr()),
370 }
371}
372
373fn describe(range: &Ipv6Range) -> String {
378 format!(
379 "{}-{} is {} addresses",
380 range.start_addr(),
381 range.end_addr(),
382 range.len()
383 )
384}
385
386#[derive(Debug, Clone)]
392#[non_exhaustive]
393pub enum DiscoveryStep {
394 Local {
398 interface: Box<Link>,
400 targets: IpSet,
403 scope: Scope,
405 },
406 Routed {
409 targets: Vec<RoutedTarget>,
411 ports: SynPorts,
414 },
415 RoutedSctp {
421 targets: Vec<RoutedTarget>,
423 port: u16,
425 },
426 Connect {
432 targets: IpSet,
434 ports: SynPorts,
438 },
439}
440
441impl DiscoveryStep {
442 pub fn kind(&self) -> ScannerKind {
444 match self {
445 Self::Local { .. } => ScannerKind::Local,
446 Self::Routed { .. } => ScannerKind::Routed,
447 Self::RoutedSctp { .. } => ScannerKind::RoutedSctp,
448 Self::Connect { .. } => ScannerKind::Connect,
449 }
450 }
451
452 pub fn target_count(&self) -> u128 {
457 match self {
458 Self::Local { targets, .. } | Self::Connect { targets, .. } => targets.len(),
459 Self::Routed { targets, .. } | Self::RoutedSctp { targets, .. } => {
460 targets.len() as u128
461 }
462 }
463 }
464
465 pub fn into_scanner(
475 self,
476 ctx: ScanContext,
477 dns_tx: Option<UnboundedSender<IpAddr>>,
478 tuning: ProbeTuning,
479 ) -> Result<Box<dyn HostScanner>, StrategyError> {
480 match self {
481 Self::Local {
482 interface,
483 targets,
484 scope,
485 } => Ok(Box::new(LocalScanner::new(
486 *interface,
487 targets,
488 ctx,
489 dns_tx,
490 scope,
491 tuning.retry,
492 )?)),
493 Self::Routed { targets, ports } => Ok(Box::new(RoutedScanner::over_tcp(
494 targets, ctx, dns_tx, tuning, ports,
495 )?)),
496 Self::RoutedSctp { targets, port } => Ok(Box::new(RoutedScanner::over_sctp(
497 targets, ctx, dns_tx, tuning, port,
498 )?)),
499 Self::Connect { targets, ports } => Ok(Box::new(ConnectScanner::asking(
500 targets,
501 ctx,
502 &tuning.evasion,
503 ports,
504 ))),
505 }
506 }
507}
508
509#[derive(Debug, Clone)]
514pub struct DiscoveryPlan {
515 steps: Vec<DiscoveryStep>,
516 refusals: Vec<RefusedStep>,
517 ours: IpSet,
518 refused_by_route: IpSet,
521 withheld: IpSet,
523}
524
525impl DiscoveryPlan {
526 pub fn build(targets: IpSet, scope: Scope, exclusions: &Exclusions, forced: &[IpAddr]) -> Self {
541 let mut steps = Vec::new();
542 let mut refusals = Vec::new();
543 let mut refused_by_route = IpSet::new();
544
545 let interface::RoutedTargets {
546 mut local,
547 routed,
548 mut unmapped,
549 ours,
550 ambiguous,
551 unenumerable,
552 } = interface::map_ips_to_interfaces_forced(targets, forced);
553
554 for range in &ambiguous {
557 refusals.push(RefusedStep {
558 scanner: ScannerKind::Local,
559 reason: format!("{}: {}", range.start_addr(), name_an_interface(range)),
560 });
561 }
562
563 for range in &unenumerable {
565 refusals.push(RefusedStep::routed_range_not_enumerable(range));
566 }
567
568 let mut withheld = IpSet::new();
570 if matches!(scope, Scope::Sweep) {
571 include_swept_link(&mut local);
572 withheld = seed_from_neighbor_table(&mut local, exclusions);
573 }
574
575 for (interface, mut targets) in local {
576 for range in withhold_unwalkable(&mut targets) {
581 match scope {
582 Scope::Sweep => info!(
584 verbosity = 1,
585 "{} is swept by solicitation rather than walked",
586 describe(&range)
587 ),
588 Scope::Targeted => {
589 refusals.push(RefusedStep::local_range_needs_a_sweep(&range))
590 }
591 }
592 }
593
594 let refused = interface::refused_neighbours(&interface, &targets);
599 if !refused.is_empty() {
600 targets.subtract(&refused);
601 for address in refused.iter() {
602 unmapped.insert(address);
603 refused_by_route.insert(address);
604 }
605 info!(
606 verbosity = 1,
607 "{} on {} refused by a route, not asked by frame",
608 counted(refused.len(), "address", "addresses"),
609 interface.name()
610 );
611 }
612
613 if targets.is_empty() && matches!(scope, Scope::Targeted) {
616 continue;
617 }
618 if matches!(scope, Scope::Sweep) {
621 info!(
622 verbosity = 1,
623 "sweeping {}: {}",
624 interface.name(),
625 match targets.len() {
626 0 => "IPv6 neighbours only, having no IPv4 range to walk".to_string(),
627 count => counted(count, "address", "addresses"),
628 }
629 );
630 }
631 steps.push(DiscoveryStep::Local {
632 interface: Box::new(interface),
633 targets,
634 scope,
635 });
636 }
637
638 if !routed.is_empty() {
639 steps.push(DiscoveryStep::Routed {
640 targets: routed,
641 ports: SynPorts::common(),
642 });
643 }
644
645 if !unmapped.is_empty() {
646 steps.push(DiscoveryStep::Connect {
647 targets: unmapped,
648 ports: SynPorts::common(),
649 });
650 }
651
652 Self {
653 steps,
654 refusals,
655 ours,
656 refused_by_route,
657 withheld,
658 }
659 }
660
661 pub fn withheld_neighbours(
670 targets: IpSet,
671 scope: Scope,
672 exclusions: &Exclusions,
673 forced: &[IpAddr],
674 ) -> IpSet {
675 if !matches!(scope, Scope::Sweep) {
676 return IpSet::new();
677 }
678 let mut local = interface::map_ips_to_interfaces_forced(targets, forced).local;
679 include_swept_link(&mut local);
680 let table = neighbor_cache::ipv6_neighbors();
681 let machines = machines_named(exclusions, &table);
682 let mut withheld = IpSet::new();
683 for intf in local.keys() {
684 for candidate in candidates_on(intf, &table, exclusions, &machines) {
685 if candidate.withheld {
686 withheld.insert_range(candidate.range);
687 }
688 }
689 }
690 withheld.canonicalize();
691 withheld
692 }
693
694 pub(crate) fn refused_by_route(&self) -> &IpSet {
698 &self.refused_by_route
699 }
700
701 pub(crate) fn withheld(&self) -> &IpSet {
705 &self.withheld
706 }
707
708 pub fn also_over_sctp(&mut self, port: u16) {
718 let sctp: Vec<DiscoveryStep> = self
719 .steps
720 .iter()
721 .filter_map(|step| match step {
722 DiscoveryStep::Routed { targets, .. } => Some(DiscoveryStep::RoutedSctp {
723 targets: targets.clone(),
724 port,
725 }),
726 _ => None,
727 })
728 .collect();
729 self.steps.extend(sctp);
730 }
731
732 pub fn asking_tcp(&mut self, ports: SynPorts) {
746 if ports.is_empty() {
747 let refusals = &mut self.refusals;
748 self.steps.retain(|step| match step {
749 DiscoveryStep::Routed { .. } | DiscoveryStep::Connect { .. } => {
750 refusals.push(RefusedStep::every_discovery_port_excluded(step.kind()));
751 false
752 }
753 _ => true,
754 });
755 return;
756 }
757 for step in &mut self.steps {
758 if let DiscoveryStep::Routed { ports: asked, .. }
759 | DiscoveryStep::Connect { ports: asked, .. } = step
760 {
761 *asked = ports;
762 }
763 }
764 }
765
766 pub(crate) fn withhold(&mut self, targets: &IpSet) -> IpSet {
779 let mut taken = IpSet::new();
780 if targets.is_empty() {
781 return taken;
782 }
783
784 for step in &mut self.steps {
785 match step {
786 DiscoveryStep::Local { targets: held, .. } => {
787 let mut kept = held.clone();
788 kept.subtract(targets);
789 let mut gone = held.clone();
791 gone.subtract(&kept);
792 for range in gone.v4() {
793 taken.push_v4_range(*range);
794 }
795 for range in gone.v6() {
796 taken.push_v6_range(*range);
797 }
798 *held = kept;
799 }
800 DiscoveryStep::Routed { targets: held, .. }
801 | DiscoveryStep::RoutedSctp { targets: held, .. } => held.retain(|routed| {
802 let out = targets.contains(&routed.target);
803 if out {
804 taken.insert(routed.target);
805 }
806 !out
807 }),
808 DiscoveryStep::Connect { .. } => {}
809 }
810 }
811
812 self.steps.retain(|step| match step {
813 DiscoveryStep::Local {
814 interface,
815 targets,
816 scope,
817 } => {
818 !targets.is_empty() || (matches!(scope, Scope::Sweep) && interface.carries_frames())
819 }
820 DiscoveryStep::Routed { targets, .. } | DiscoveryStep::RoutedSctp { targets, .. } => {
821 !targets.is_empty()
822 }
823 DiscoveryStep::Connect { .. } => true,
824 });
825
826 taken.canonicalize();
827 taken
828 }
829
830 pub(crate) fn connect_instead(&mut self, targets: &IpSet) -> IpSet {
835 let moved = self.withhold(targets);
836 if moved.is_empty() {
837 return moved;
838 }
839
840 let existing = self.steps.iter_mut().find_map(|step| match step {
841 DiscoveryStep::Connect { targets, .. } => Some(targets),
842 _ => None,
843 });
844 match existing {
845 Some(held) => {
846 for range in moved.v4() {
847 held.push_v4_range(*range);
848 }
849 for range in moved.v6() {
850 held.push_v6_range(*range);
851 }
852 held.canonicalize();
853 }
854 None => {
856 let ports = self
857 .steps
858 .iter()
859 .find_map(|step| match step {
860 DiscoveryStep::Routed { ports, .. } => Some(*ports),
861 _ => None,
862 })
863 .unwrap_or_else(SynPorts::common);
864 self.steps.push(DiscoveryStep::Connect {
865 targets: moved.clone(),
866 ports,
867 });
868 }
869 }
870 moved
871 }
872
873 pub fn steps(&self) -> &[DiscoveryStep] {
875 &self.steps
876 }
877
878 pub fn steps_mut(&mut self) -> &mut Vec<DiscoveryStep> {
880 &mut self.steps
881 }
882
883 pub fn ours(&self) -> &IpSet {
892 &self.ours
893 }
894
895 pub fn refusals(&self) -> &[RefusedStep] {
897 &self.refusals
898 }
899
900 pub fn into_steps(self) -> Vec<DiscoveryStep> {
902 self.steps
903 }
904}
905
906#[derive(Debug, Clone, Copy, PartialEq, Eq)]
908#[non_exhaustive]
909pub enum PortScanStep {
910 RawTcp {
913 technique: TcpScanTechnique,
915 },
916 RawUdp,
919 RawSctp,
922 ConnectTcp,
925 ConnectUdp,
927 Idle {
931 zombie: IpAddr,
933 zombie_port: Option<u16>,
936 },
937}
938
939impl PortScanStep {
940 pub fn kind(&self) -> ScannerKind {
947 match self {
948 Self::RawTcp { technique } => ScannerKind::for_raw_tcp(*technique),
949 Self::RawUdp => ScannerKind::UdpPort,
950 Self::RawSctp => ScannerKind::SctpPort,
951 Self::ConnectTcp => ScannerKind::Connect,
952 Self::ConnectUdp => ScannerKind::ConnectUdp,
953 Self::Idle { .. } => ScannerKind::Idle,
954 }
955 }
956
957 pub fn protocol(&self) -> Protocol {
959 match self {
960 Self::RawTcp { .. } | Self::ConnectTcp | Self::Idle { .. } => Protocol::Tcp,
961 Self::RawUdp | Self::ConnectUdp => Protocol::Udp,
962 Self::RawSctp => Protocol::Sctp,
963 }
964 }
965
966 pub fn is_raw(&self) -> bool {
972 matches!(self, Self::RawTcp { .. } | Self::RawUdp | Self::RawSctp)
973 }
974
975 pub fn into_scanner(
984 self,
985 ctx: ScanContext,
986 target_count: usize,
987 tuning: ProbeTuning,
988 zones: ZoneMap,
989 ) -> Result<Box<dyn PortScanner>, StrategyError> {
990 match self {
991 Self::RawTcp { technique } => Ok(Box::new(TcpPortScanner::new(
992 interface::SourceResolver::from_system()
993 .with_zones(zones)
994 .with_forced(tuning.send_source.clone()),
995 ctx,
996 technique,
997 target_count,
998 tuning,
999 )?)),
1000 Self::RawUdp => Ok(Box::new(UdpPortScanner::new(
1001 interface::SourceResolver::from_system()
1002 .with_zones(zones)
1003 .with_forced(tuning.send_source.clone()),
1004 ctx,
1005 target_count,
1006 tuning,
1007 )?)),
1008 Self::RawSctp => Ok(Box::new(SctpPortScanner::new(
1009 interface::SourceResolver::from_system()
1010 .with_zones(zones)
1011 .with_forced(tuning.send_source.clone()),
1012 ctx,
1013 target_count,
1014 tuning,
1015 )?)),
1016 Self::ConnectTcp => Ok(Box::new(
1017 ConnectPortScanner::new(
1018 ctx,
1019 limits::CONNECT_CONCURRENCY,
1020 tuning.service_detection,
1021 &tuning.evasion,
1022 )
1023 .with_zones(zones),
1024 )),
1025 Self::ConnectUdp => Ok(Box::new(
1026 ConnectUdpPortScanner::with_detection(
1027 ctx,
1028 limits::CONNECT_CONCURRENCY,
1029 &tuning.evasion,
1030 tuning.service_detection,
1031 )
1032 .with_zones(zones),
1033 )),
1034 Self::Idle {
1035 zombie,
1036 zombie_port,
1037 } => Ok(Box::new(IdlePortScanner::new(
1038 ctx,
1039 zombie,
1040 zombie_port,
1041 tuning,
1042 )?)),
1043 }
1044 }
1045}
1046
1047#[derive(Debug, Clone)]
1049pub struct PortScanPlan {
1050 steps: Vec<PortScanStep>,
1051 refusals: Vec<RefusedStep>,
1052 refused: Vec<Protocol>,
1055 technique: TcpScanTechnique,
1056 idle: bool,
1063}
1064
1065impl PortScanPlan {
1066 pub fn build(cfg: &ZondConfig, privilege: Privilege) -> Self {
1083 let mut plan = Self {
1084 steps: Vec::new(),
1085 refusals: Vec::new(),
1086 refused: Vec::new(),
1087 technique: cfg.tcp_technique,
1088 idle: cfg.idle_scan.is_some(),
1089 };
1090
1091 if let Some(idle) = &cfg.idle_scan {
1095 if cfg.exclusions.excludes(&idle.zombie) {
1099 plan.refuse(
1100 Protocol::Tcp,
1101 RefusedStep::idle_zombie_excluded(idle.zombie),
1102 );
1103 } else if privilege.is_raw() {
1104 plan.steps.push(PortScanStep::Idle {
1105 zombie: idle.zombie,
1106 zombie_port: idle.zombie_port,
1107 });
1108 } else {
1109 plan.refuse(Protocol::Tcp, RefusedStep::idle_needs_privilege());
1110 }
1111 return plan;
1112 }
1113
1114 let raw = Self::raw_scanning(privilege);
1116 if privilege.is_raw() && !raw {
1117 warn!("no usable network interface found; using TCP connect fallback");
1118 }
1119
1120 if raw {
1123 plan.steps.push(PortScanStep::RawTcp {
1124 technique: cfg.tcp_technique,
1125 });
1126 } else if cfg.tcp_technique.has_connect_fallback() {
1127 plan.steps.push(PortScanStep::ConnectTcp);
1128 } else {
1129 plan.refuse(
1130 Protocol::Tcp,
1131 RefusedStep::technique_needs_raw_sockets(cfg.tcp_technique),
1132 );
1133 }
1134
1135 plan
1136 }
1137
1138 fn raw_scanning(privilege: Privilege) -> bool {
1142 privilege.is_raw() && interface::SourceResolver::from_system().has_sources()
1143 }
1144
1145 fn refuse(&mut self, protocol: Protocol, refusal: RefusedStep) {
1148 self.refusals.push(refusal);
1149 self.refused.push(protocol);
1150 }
1151
1152 pub fn technique(&self) -> TcpScanTechnique {
1157 self.technique
1158 }
1159
1160 pub fn steps(&self) -> &[PortScanStep] {
1162 &self.steps
1163 }
1164
1165 pub fn steps_mut(&mut self) -> &mut Vec<PortScanStep> {
1167 &mut self.steps
1168 }
1169
1170 pub fn refusals(&self) -> &[RefusedStep] {
1172 &self.refusals
1173 }
1174
1175 pub fn into_steps(self) -> Vec<PortScanStep> {
1177 self.steps
1178 }
1179
1180 pub fn cover_sctp(&mut self, privilege: Privilege) {
1190 if self.idle {
1191 self.refuse(Protocol::Sctp, RefusedStep::sctp_not_in_an_idle_scan());
1192 return;
1193 }
1194
1195 if privilege.is_raw() && interface::SourceResolver::from_system().has_sources() {
1197 self.steps.push(PortScanStep::RawSctp);
1198 } else {
1199 self.refuse(Protocol::Sctp, RefusedStep::sctp_needs_raw_sockets());
1200 }
1201 }
1202
1203 pub fn cover_udp(&mut self, privilege: Privilege) {
1215 if self.covers(Protocol::Udp) {
1216 return;
1217 }
1218 if self.idle {
1219 self.refuse(Protocol::Udp, RefusedStep::udp_not_in_an_idle_scan());
1220 } else if Self::raw_scanning(privilege) {
1221 self.steps.push(PortScanStep::RawUdp);
1222 } else {
1223 self.steps.push(PortScanStep::ConnectUdp);
1224 }
1225 }
1226
1227 pub(crate) fn refuses(&self, protocol: Protocol) -> bool {
1234 self.refused.contains(&protocol)
1235 }
1236
1237 pub fn covers(&self, protocol: Protocol) -> bool {
1242 self.steps.iter().any(|step| step.protocol() == protocol)
1243 }
1244}
1245
1246fn include_swept_link(local: &mut HashMap<Link, IpSet>) {
1257 let Some(link) = interface::lan_link() else {
1258 return;
1259 };
1260
1261 if local.keys().any(|intf| intf.name() == link.link.name()) {
1262 return;
1263 }
1264
1265 local.insert(link.link, IpSet::new());
1266}
1267
1268fn seed_from_neighbor_table(local: &mut HashMap<Link, IpSet>, exclusions: &Exclusions) -> IpSet {
1290 let table = neighbor_cache::ipv6_neighbors();
1291 if table.is_empty() {
1292 return IpSet::new();
1293 }
1294 let machines = machines_named(exclusions, &table);
1295 seed_from_neighbor_table_with(local, &table, exclusions, &machines)
1296}
1297
1298fn machines_named(
1302 exclusions: &Exclusions,
1303 v6_table: &[neighbor_cache::Neighbor],
1304) -> BTreeSet<MacAddr> {
1305 if exclusions.is_empty() {
1306 return BTreeSet::new();
1307 }
1308 let v4 = neighbor_cache::ipv4_neighbors();
1309 exclusions.hardware_in(v4.iter().chain(v6_table).map(|entry| (entry.ip, entry.mac)))
1310}
1311
1312fn seed_from_neighbor_table_with(
1318 local: &mut HashMap<Link, IpSet>,
1319 table: &[neighbor_cache::Neighbor],
1320 exclusions: &Exclusions,
1321 machines: &BTreeSet<MacAddr>,
1322) -> IpSet {
1323 let mut withheld = IpSet::new();
1324 for (intf, targets) in local.iter_mut() {
1325 let mut seeded = 0usize;
1326 for candidate in candidates_on(intf, table, exclusions, machines) {
1327 if candidate.withheld {
1332 info!(
1333 verbosity = 2,
1334 "neighbour {} is excluded, so it is not taken as a candidate",
1335 candidate.address
1336 );
1337 withheld.insert_range(candidate.range);
1338 continue;
1339 }
1340 targets.insert_range(candidate.range);
1341 seeded += 1;
1342 }
1343
1344 if seeded > 0 {
1345 targets.canonicalize();
1346 info!(
1347 verbosity = 1,
1348 "took {} from the neighbour table as candidates on {}",
1349 counted(seeded as u128, "IPv6 address", "IPv6 addresses"),
1350 intf.name()
1351 );
1352 }
1353 }
1354 withheld.canonicalize();
1355 withheld
1356}
1357
1358struct Candidate {
1360 address: IpAddr,
1362 range: IpRange,
1365 withheld: bool,
1368}
1369
1370fn candidates_on(
1374 intf: &Link,
1375 table: &[neighbor_cache::Neighbor],
1376 exclusions: &Exclusions,
1377 machines: &BTreeSet<MacAddr>,
1378) -> Vec<Candidate> {
1379 let tied: HashSet<IpAddr> = table
1380 .iter()
1381 .filter(|entry| entry.mac.is_some_and(|mac| machines.contains(&mac)))
1382 .map(|entry| entry.ip)
1383 .collect();
1384 candidates_for(intf, table)
1385 .into_iter()
1386 .filter_map(|address| {
1387 let IpAddr::V6(v6) = address else {
1388 return None;
1389 };
1390 let zone = v6.is_unicast_link_local().then_some(intf.index());
1393 let range = IpRange::V6(Ipv6Range::scoped(v6, v6, zone).ok()?);
1394 Some(Candidate {
1395 address,
1396 range,
1397 withheld: exclusions.excludes(&address) || tied.contains(&address),
1398 })
1399 })
1400 .collect()
1401}
1402
1403fn candidates_for(link: &Link, table: &[neighbor_cache::Neighbor]) -> Vec<IpAddr> {
1405 let own: std::collections::HashSet<IpAddr> =
1406 link.addresses().iter().map(|held| held.address()).collect();
1407
1408 table
1409 .iter()
1410 .filter(|entry| entry.interface_index == link.index())
1411 .filter(|entry| !own.contains(&entry.ip))
1412 .filter(|entry| match entry.ip {
1413 IpAddr::V6(addr) => !addr.is_loopback() && !addr.is_unspecified(),
1414 IpAddr::V4(_) => false,
1415 })
1416 .map(|entry| entry.ip)
1417 .collect()
1418}
1419
1420fn name_an_interface(range: &Ipv6Range) -> String {
1435 match link_local_example(&crate::system::interface::interfaces_or_none()) {
1436 Some(link) => format!(
1437 "link-local, name the interface ({}%{})",
1438 range.start_addr(),
1439 link.name()
1440 ),
1441 None => "link-local, name the interface".to_owned(),
1442 }
1443}
1444
1445fn link_local_example(links: &[Link]) -> Option<&Link> {
1450 let segment = |link: &&Link| {
1451 link.is_up()
1452 && link.is_broadcast()
1453 && !link.is_loopback()
1454 && link
1455 .ipv6()
1456 .any(|(address, _)| address.is_unicast_link_local())
1457 };
1458 links
1459 .iter()
1460 .filter(segment)
1461 .find(|link| link.carries_default_route())
1462 .or_else(|| links.iter().find(segment))
1463}
1464
1465#[cfg(test)]
1466mod tests {
1467 use super::*;
1468
1469 #[test]
1473 fn the_link_local_hint_names_an_interface_this_host_has() {
1474 use crate::system::interface::{Addressing, LinkAddress};
1475 use std::net::Ipv6Addr;
1476
1477 let link_local =
1478 LinkAddress::new(IpAddr::V6(Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 1)), 64);
1479 let global = LinkAddress::new(
1480 IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1)),
1481 64,
1482 );
1483 let link = |name: &str, addresses: Vec<LinkAddress>| {
1484 Link::new(name, 1)
1485 .with_link_up(true)
1486 .with_addressing(Addressing::Broadcast)
1487 .with_addresses(addresses)
1488 };
1489
1490 let links = [
1491 link("tun0", vec![link_local]).with_addressing(Addressing::PointToPoint),
1492 link("eth1", vec![global]),
1493 link("eth2", vec![link_local]).with_link_up(false),
1494 link("eth0", vec![link_local]),
1495 link("wlan0", vec![link_local]).with_default_route(true),
1496 ];
1497 assert_eq!(link_local_example(&links).map(Link::name), Some("wlan0"));
1498 assert_eq!(
1499 link_local_example(&links[..4]).map(Link::name),
1500 Some("eth0")
1501 );
1502 assert!(link_local_example(&links[..3]).is_none());
1503 }
1504
1505 const SRC_PORT: u16 = 54_321;
1508
1509 fn v6(addr: &str) -> IpAddr {
1510 addr.parse().unwrap()
1511 }
1512
1513 fn interface_with(index: u32, name: &str, own: Vec<IpAddr>) -> Link {
1514 use crate::system::interface::LinkAddress;
1515 Link::new(name, index).with_addresses(
1516 own.into_iter()
1517 .map(|ip| LinkAddress::new(ip, if ip.is_ipv4() { 24 } else { 64 }))
1518 .collect(),
1519 )
1520 }
1521
1522 fn entry(ip: &str, index: u32) -> neighbor_cache::Neighbor {
1523 neighbor_cache::Neighbor {
1524 ip: v6(ip),
1525 mac: None,
1526 interface_index: index,
1527 }
1528 }
1529
1530 fn framed(index: u32, name: &str, own: Vec<IpAddr>) -> Link {
1532 interface_with(index, name, own)
1533 .with_mac(crate::model::mac::MacAddr::new(0x02, 0, 0, 0, 0, 0x10))
1534 }
1535
1536 fn set_of(addresses: &[&str]) -> IpSet {
1537 let mut set = IpSet::new();
1538 for address in addresses {
1539 set.insert(v6(address));
1540 }
1541 set
1542 }
1543
1544 #[test]
1547 fn what_a_frame_cannot_reach_moves_to_the_connect_step() {
1548 let mut plan = DiscoveryPlan {
1549 ours: IpSet::new(),
1550 refused_by_route: IpSet::new(),
1551 withheld: IpSet::new(),
1552 steps: vec![
1553 DiscoveryStep::Local {
1554 interface: Box::new(interface_with(20, "utun9", vec![v6("198.51.100.2")])),
1555 targets: set_of(&["198.51.100.7"]),
1556 scope: Scope::Targeted,
1557 },
1558 DiscoveryStep::Local {
1559 interface: Box::new(framed(4, "en0", vec![v6("192.0.2.10")])),
1560 targets: set_of(&["192.0.2.50"]),
1561 scope: Scope::Targeted,
1562 },
1563 DiscoveryStep::Routed {
1564 targets: vec![
1565 RoutedTarget {
1566 target: v6("203.0.113.23"),
1567 source: v6("198.51.100.2"),
1568 },
1569 RoutedTarget {
1570 target: v6("203.0.113.9"),
1571 source: v6("192.0.2.10"),
1572 },
1573 ],
1574 ports: SynPorts::common(),
1575 },
1576 ],
1577 refusals: Vec::new(),
1578 };
1579
1580 let moved = plan.connect_instead(&set_of(&["198.51.100.7", "203.0.113.23"]));
1581
1582 assert_eq!(moved.len(), 2);
1583 let kinds: Vec<ScannerKind> = plan.steps().iter().map(DiscoveryStep::kind).collect();
1584 assert_eq!(
1585 kinds,
1586 vec![
1587 ScannerKind::Local,
1588 ScannerKind::Routed,
1589 ScannerKind::Connect
1590 ],
1591 "the tunnel's local step is gone and a connect step has arrived"
1592 );
1593 match &plan.steps()[1] {
1594 DiscoveryStep::Routed { targets, .. } => {
1595 assert_eq!(targets.len(), 1);
1596 assert_eq!(targets[0].target, v6("203.0.113.9"));
1597 }
1598 other => panic!("expected the routed step, found {other:?}"),
1599 }
1600 match &plan.steps()[2] {
1601 DiscoveryStep::Connect { targets, .. } => assert_eq!(*targets, moved),
1602 other => panic!("expected the connect step, found {other:?}"),
1603 }
1604 }
1605
1606 #[test]
1609 fn a_sweeps_step_stays_on_a_framed_link_and_goes_on_a_tunnel() {
1610 let mut plan = DiscoveryPlan {
1611 ours: IpSet::new(),
1612 refused_by_route: IpSet::new(),
1613 withheld: IpSet::new(),
1614 steps: vec![
1615 DiscoveryStep::Local {
1616 interface: Box::new(framed(4, "en0", vec![v6("192.0.2.10")])),
1617 targets: set_of(&["192.0.2.50"]),
1618 scope: Scope::Sweep,
1619 },
1620 DiscoveryStep::Local {
1621 interface: Box::new(interface_with(20, "utun9", vec![v6("198.51.100.2")])),
1622 targets: set_of(&["198.51.100.7"]),
1623 scope: Scope::Sweep,
1624 },
1625 ],
1626 refusals: Vec::new(),
1627 };
1628
1629 plan.withhold(&set_of(&["192.0.2.50", "198.51.100.7"]));
1630
1631 assert_eq!(plan.steps().len(), 1);
1632 match &plan.steps()[0] {
1633 DiscoveryStep::Local {
1634 interface, targets, ..
1635 } => {
1636 assert_eq!(interface.name(), "en0");
1637 assert!(targets.is_empty());
1638 }
1639 other => panic!("expected the sweep's own step, found {other:?}"),
1640 }
1641 }
1642
1643 #[test]
1645 fn withholding_leaves_the_connect_step_as_it_was() {
1646 let mut plan = DiscoveryPlan {
1647 ours: IpSet::new(),
1648 refused_by_route: IpSet::new(),
1649 withheld: IpSet::new(),
1650 steps: vec![DiscoveryStep::Connect {
1651 targets: set_of(&["127.0.0.1"]),
1652 ports: SynPorts::common(),
1653 }],
1654 refusals: Vec::new(),
1655 };
1656
1657 let taken = plan.withhold(&set_of(&["127.0.0.1"]));
1658
1659 assert!(taken.is_empty(), "nothing was taken from a frame step");
1660 match &plan.steps()[0] {
1661 DiscoveryStep::Connect { targets, .. } => assert_eq!(*targets, set_of(&["127.0.0.1"])),
1662 other => panic!("expected the connect step, found {other:?}"),
1663 }
1664 }
1665
1666 #[test]
1670 fn the_routed_steps_ask_the_ports_they_are_given() {
1671 let mut plan = DiscoveryPlan {
1672 ours: IpSet::new(),
1673 refused_by_route: IpSet::new(),
1674 withheld: IpSet::new(),
1675 steps: vec![DiscoveryStep::Routed {
1676 targets: vec![RoutedTarget {
1677 target: v6("198.51.100.1"),
1678 source: v6("192.0.2.9"),
1679 }],
1680 ports: SynPorts::common(),
1681 }],
1682 refusals: Vec::new(),
1683 };
1684 let scan = SynPorts::for_scan(&"8443".try_into().expect("a port specification"));
1685
1686 plan.asking_tcp(scan);
1687
1688 assert!(matches!(
1689 plan.steps(),
1690 [DiscoveryStep::Routed { ports, .. }] if *ports == scan
1691 ));
1692 }
1693
1694 #[test]
1697 fn the_connect_step_asks_the_ports_the_routed_steps_are_given() {
1698 let mut plan = DiscoveryPlan {
1699 ours: IpSet::new(),
1700 refused_by_route: IpSet::new(),
1701 withheld: IpSet::new(),
1702 steps: vec![
1703 DiscoveryStep::Routed {
1704 targets: vec![RoutedTarget {
1705 target: v6("198.51.100.1"),
1706 source: v6("192.0.2.9"),
1707 }],
1708 ports: SynPorts::common(),
1709 },
1710 DiscoveryStep::Connect {
1711 targets: set_of(&["127.0.0.1"]),
1712 ports: SynPorts::common(),
1713 },
1714 ],
1715 refusals: Vec::new(),
1716 };
1717 let scan = SynPorts::for_scan(&"8443".try_into().expect("a port specification"));
1718
1719 plan.asking_tcp(scan);
1720
1721 assert!(
1722 matches!(
1723 plan.steps(),
1724 [DiscoveryStep::Routed { .. }, DiscoveryStep::Connect { ports, .. }] if *ports == scan
1725 ),
1726 "the connect step asks {:?}",
1727 plan.steps()
1728 );
1729 }
1730
1731 #[test]
1734 fn a_plan_left_no_tcp_port_refuses_its_tcp_steps() {
1735 let mut plan = DiscoveryPlan {
1736 ours: IpSet::new(),
1737 refused_by_route: IpSet::new(),
1738 withheld: IpSet::new(),
1739 steps: vec![
1740 DiscoveryStep::Routed {
1741 targets: vec![RoutedTarget {
1742 target: v6("198.51.100.1"),
1743 source: v6("192.0.2.9"),
1744 }],
1745 ports: SynPorts::common(),
1746 },
1747 DiscoveryStep::Connect {
1748 targets: set_of(&["127.0.0.1"]),
1749 ports: SynPorts::common(),
1750 },
1751 ],
1752 refusals: Vec::new(),
1753 };
1754 let everything = "1-65535".try_into().expect("a port specification");
1755
1756 plan.asking_tcp(SynPorts::common().excluding(&everything));
1757
1758 assert!(plan.steps().is_empty(), "left {:?}", plan.steps());
1759 let refused: Vec<ScannerKind> = plan.refusals().iter().map(|r| r.scanner).collect();
1760 assert_eq!(refused, [ScannerKind::Routed, ScannerKind::Connect]);
1761 }
1762
1763 #[test]
1765 fn a_connect_step_made_for_what_frames_miss_asks_the_routed_ports() {
1766 let mut plan = DiscoveryPlan {
1767 ours: IpSet::new(),
1768 refused_by_route: IpSet::new(),
1769 withheld: IpSet::new(),
1770 steps: vec![DiscoveryStep::Routed {
1771 targets: vec![
1772 RoutedTarget {
1773 target: v6("198.51.100.1"),
1774 source: v6("192.0.2.9"),
1775 },
1776 RoutedTarget {
1777 target: v6("198.51.100.2"),
1778 source: v6("192.0.2.9"),
1779 },
1780 ],
1781 ports: SynPorts::common(),
1782 }],
1783 refusals: Vec::new(),
1784 };
1785 let scan = SynPorts::for_scan(&"8443".try_into().expect("a port specification"));
1786
1787 plan.asking_tcp(scan);
1788 plan.connect_instead(&set_of(&["198.51.100.2"]));
1789
1790 assert!(
1791 matches!(
1792 plan.steps(),
1793 [DiscoveryStep::Routed { .. }, DiscoveryStep::Connect { ports, .. }] if *ports == scan
1794 ),
1795 "the connect step asks {:?}",
1796 plan.steps()
1797 );
1798 }
1799
1800 #[test]
1802 fn an_sctp_sweep_is_added_to_the_routed_steps_alone() {
1803 let mut plan = DiscoveryPlan {
1804 ours: IpSet::new(),
1805 refused_by_route: IpSet::new(),
1806 withheld: IpSet::new(),
1807 steps: vec![
1808 DiscoveryStep::Routed {
1809 targets: vec![RoutedTarget {
1810 target: v6("192.0.2.1"),
1811 source: v6("192.0.2.9"),
1812 }],
1813 ports: SynPorts::common(),
1814 },
1815 DiscoveryStep::Connect {
1816 targets: IpSet::new(),
1817 ports: SynPorts::common(),
1818 },
1819 ],
1820 refusals: Vec::new(),
1821 };
1822
1823 plan.also_over_sctp(3868);
1824
1825 let kinds: Vec<ScannerKind> = plan.steps().iter().map(DiscoveryStep::kind).collect();
1826 assert_eq!(
1827 kinds,
1828 vec![
1829 ScannerKind::Routed,
1830 ScannerKind::Connect,
1831 ScannerKind::RoutedSctp
1832 ]
1833 );
1834 assert!(matches!(
1835 plan.steps().last(),
1836 Some(DiscoveryStep::RoutedSctp { port: 3868, .. })
1837 ));
1838 }
1839
1840 #[test]
1843 fn sctp_without_raw_sockets_is_refused_rather_than_substituted() {
1844 let mut plan = PortScanPlan::build(&ZondConfig::default(), Privilege::Connect);
1845 plan.cover_sctp(Privilege::Connect);
1846
1847 assert!(!plan.covers(Protocol::Sctp));
1848 assert!(
1849 plan.refusals()
1850 .iter()
1851 .any(|refusal| refusal.scanner == ScannerKind::SctpPort),
1852 "the sctp ports went unprobed and nothing in the report said so"
1853 );
1854 }
1855
1856 #[test]
1859 fn an_idle_scan_refuses_sctp_rather_than_probing_it_directly() {
1860 let cfg = ZondConfig {
1861 idle_scan: Some(crate::config::IdleScan::new(v6("192.0.2.9"))),
1862 ..ZondConfig::default()
1863 };
1864 let mut plan = PortScanPlan::build(&cfg, Privilege::Raw);
1865 plan.cover_sctp(Privilege::Raw);
1866
1867 assert!(!plan.covers(Protocol::Sctp));
1868 let refusal = plan
1869 .refusals()
1870 .iter()
1871 .find(|refusal| refusal.scanner == ScannerKind::SctpPort)
1872 .expect("the sctp ports are accounted for");
1873 assert!(
1874 refusal.reason.contains("idle"),
1875 "the reason names something other than the idle scan: {}",
1876 refusal.reason
1877 );
1878 }
1879
1880 #[test]
1884 fn an_idle_scan_through_an_excluded_zombie_is_refused() {
1885 let zombie = v6("192.0.2.9");
1886 let mut forbidden = IpSet::new();
1887 forbidden.insert(zombie);
1888 let cfg = ZondConfig {
1889 idle_scan: Some(crate::config::IdleScan::new(zombie)),
1890 exclusions: Exclusions::new(forbidden),
1891 ..ZondConfig::default()
1892 };
1893
1894 let plan = PortScanPlan::build(&cfg, Privilege::Raw);
1895
1896 assert!(
1897 !plan
1898 .steps()
1899 .iter()
1900 .any(|step| matches!(step, PortScanStep::Idle { .. })),
1901 "an idle step would probe the excluded zombie"
1902 );
1903 assert!(
1904 !plan.covers(Protocol::Tcp),
1905 "and nothing stands in for it by probing the target directly"
1906 );
1907 let refusal = plan
1908 .refusals()
1909 .iter()
1910 .find(|refusal| refusal.scanner == ScannerKind::Idle)
1911 .expect("the refused scan is accounted for");
1912 assert!(
1913 refusal.reason.contains("192.0.2.9") && refusal.reason.contains("excluded"),
1914 "the reason names the zombie and the exclusion: {}",
1915 refusal.reason
1916 );
1917 }
1918
1919 #[test]
1923 fn a_refused_idle_scan_probes_no_other_transport_directly() {
1924 let zombie = v6("192.0.2.9");
1925 let mut forbidden = IpSet::new();
1926 forbidden.insert(zombie);
1927 let cfg = ZondConfig {
1928 idle_scan: Some(crate::config::IdleScan::new(zombie)),
1929 exclusions: Exclusions::new(forbidden),
1930 ..ZondConfig::default()
1931 };
1932
1933 for privilege in [Privilege::Raw, Privilege::Connect] {
1934 let mut plan = PortScanPlan::build(&cfg, privilege);
1935 plan.cover_sctp(privilege);
1936 plan.cover_udp(privilege);
1937
1938 assert!(
1939 plan.steps().is_empty(),
1940 "{privilege:?}: nothing is probed directly: {:?}",
1941 plan.steps()
1942 );
1943 for protocol in [Protocol::Sctp, Protocol::Udp] {
1944 assert!(plan.refuses(protocol), "{privilege:?}: {protocol:?}");
1945 }
1946 let reasons: Vec<&str> = plan.refusals().iter().map(|r| r.reason.as_str()).collect();
1947 for transport in ["sctp", "udp"] {
1948 assert!(
1949 reasons
1950 .iter()
1951 .any(|reason| reason.contains(transport) && reason.contains("idle scan")),
1952 "{privilege:?}: {transport} is refused as an idle scan's: {reasons:?}"
1953 );
1954 }
1955 }
1956 }
1957
1958 #[test]
1960 fn a_udp_step_is_planned_only_when_the_targets_name_udp() {
1961 for privilege in [Privilege::Raw, Privilege::Connect] {
1962 let plan = PortScanPlan::build(&ZondConfig::default(), privilege);
1963 assert!(
1964 !plan.covers(Protocol::Udp),
1965 "{privilege:?}: a plan built before the targets are read names no UDP step, so \
1966 a TCP-only scan opens no UDP scanner to probe nothing"
1967 );
1968 }
1969
1970 let mut plan = PortScanPlan::build(&ZondConfig::default(), Privilege::Connect);
1971 plan.cover_udp(Privilege::Connect);
1972 assert!(plan.covers(Protocol::Udp) && !plan.refuses(Protocol::Udp));
1973 assert!(plan.refusals().is_empty());
1974 }
1975
1976 fn v6_set(cidr: &str) -> IpSet {
1977 crate::model::parse::ip::to_set(&[cidr], None, None).expect("a range")
1978 }
1979
1980 #[test]
1984 fn a_local_prefix_too_large_to_walk_is_withheld_from_the_targets() {
1985 let mut targets = v6_set("2001:db8:1:1::/64");
1986 assert_eq!(targets.len(), 1u128 << 64, "a /64, kept whole to here");
1987
1988 let withheld = withhold_unwalkable(&mut targets);
1989
1990 assert_eq!(withheld.len(), 1, "the prefix is taken out");
1991 assert!(targets.is_empty(), "and nothing is left to walk");
1992 }
1993
1994 #[test]
1997 fn withholding_a_prefix_keeps_the_addresses_named_beside_it() {
1998 let mut targets = crate::model::parse::ip::to_set(
1999 &["2001:db8:1:1::/64", "2001:db8:2::1", "192.0.2.7"],
2000 None,
2001 None,
2002 )
2003 .expect("a mixed set");
2004
2005 let withheld = withhold_unwalkable(&mut targets);
2006
2007 assert_eq!(withheld.len(), 1);
2008 assert_eq!(targets.len(), 2, "the literal and the IPv4 address survive");
2009 }
2010
2011 #[test]
2013 fn a_walkable_prefix_is_untouched() {
2014 let mut targets = v6_set("2001:db8::/120");
2015 let before = targets.len();
2016
2017 assert!(withhold_unwalkable(&mut targets).is_empty());
2018 assert_eq!(targets.len(), before);
2019 }
2020
2021 #[test]
2024 fn seeding_skips_other_interfaces_our_own_addresses_and_loopback() {
2025 let own = v6("2001:db8::50");
2026 let intf = interface_with(7, "en0", vec![own]);
2027 let table = vec![
2028 entry("2001:db8::aa", 7),
2029 entry("fe80::bb", 7),
2030 entry("2001:db8::cc", 9),
2031 entry("2001:db8::50", 7),
2032 entry("::1", 7),
2033 ];
2034
2035 let seeded = candidates_for(&intf, &table);
2036
2037 assert_eq!(seeded, vec![v6("2001:db8::aa"), v6("fe80::bb")]);
2038 }
2039
2040 #[test]
2043 fn a_seeded_link_local_keeps_its_interface_and_a_global_does_not() {
2044 let intf = interface_with(7, "en0", Vec::new());
2045 let table = vec![entry("fe80::bb", 7), entry("2001:db8::aa", 7)];
2046 let mut local = std::collections::HashMap::from([(intf, IpSet::new())]);
2047
2048 seed_from_neighbor_table_with(&mut local, &table, &Exclusions::none(), &BTreeSet::new());
2049
2050 let targets = local.into_values().next().unwrap();
2051 let zones: Vec<Option<u32>> = targets.v6().iter().map(|range| range.zone()).collect();
2052 assert!(
2053 zones.contains(&Some(7)),
2054 "the link-local needs its interface"
2055 );
2056 assert!(
2057 zones.contains(&None),
2058 "the global address needs no interface"
2059 );
2060 }
2061
2062 #[test]
2064 fn an_unprivileged_plan_covers_both_protocols() {
2065 let mut plan = PortScanPlan::build(&ZondConfig::default(), Privilege::Connect);
2066 plan.cover_udp(Privilege::Connect);
2067
2068 assert!(plan.covers(Protocol::Tcp));
2069 assert!(plan.covers(Protocol::Udp));
2070 assert!(plan.refusals().is_empty());
2071 }
2072
2073 #[test]
2076 fn a_technique_the_fallback_cannot_express_is_refused_at_planning_time() {
2077 let cfg = ZondConfig {
2078 tcp_technique: TcpScanTechnique::Fin,
2079 ..ZondConfig::default()
2080 };
2081 let mut plan = PortScanPlan::build(&cfg, Privilege::Connect);
2082 plan.cover_udp(Privilege::Connect);
2083
2084 assert!(
2085 !plan.covers(Protocol::Tcp),
2086 "a connect scan cannot send a FIN and must not plan to"
2087 );
2088 assert!(plan.covers(Protocol::Udp), "the UDP half is unaffected");
2089
2090 assert_eq!(plan.refusals().len(), 1, "the caller has to be told");
2091 assert_eq!(plan.refusals()[0].scanner, ScannerKind::TcpPort);
2092 assert!(
2093 plan.refusals()[0].reason.contains("fin"),
2094 "the refusal has to name the technique: {}",
2095 plan.refusals()[0].reason
2096 );
2097 assert!(
2098 plan.refuses(Protocol::Tcp) && !plan.refuses(Protocol::Udp),
2099 "and which protocol it leaves unprobed, for the router to count"
2100 );
2101 }
2102
2103 #[test]
2107 fn a_step_reports_under_the_same_name_as_the_scanner_it_builds() {
2108 use crate::scanner::session::ScanSession;
2109 use crate::scanner::strategy::ports::TcpPortScanner;
2110 use crate::transport::probe::{Emission, ProbeSender, ProbeTransport, SendError};
2111
2112 struct Unsendable;
2113 impl ProbeSender for Unsendable {
2114 fn send(
2115 &self,
2116 _: &[u8],
2117 _: IpAddr,
2118 _: IpAddr,
2119 _: Option<u32>,
2120 _emission: Emission,
2121 ) -> Result<(), SendError> {
2122 Ok(())
2123 }
2124 }
2125
2126 let (_session, ctx) = ScanSession::new();
2127 for &technique in TcpScanTechnique::ALL {
2128 let (_tx, rx) = tokio::sync::mpsc::channel(1024);
2129 let scanner = TcpPortScanner::with_transport(
2130 interface::SourceResolver::from_links(&[]),
2131 ctx.clone(),
2132 technique,
2133 ProbeTransport::from_parts(Box::new(Unsendable), rx),
2134 1,
2135 SRC_PORT,
2136 );
2137
2138 assert_eq!(
2139 PortScanStep::RawTcp { technique }.kind(),
2140 scanner.kind(),
2141 "a {technique} step and its scanner disagree about what to call themselves"
2142 );
2143 }
2144 }
2145
2146 #[test]
2148 fn every_raw_step_is_recognisable_as_one() {
2149 for &technique in TcpScanTechnique::ALL {
2150 assert!(PortScanStep::RawTcp { technique }.is_raw(), "{technique}");
2151 }
2152 assert!(PortScanStep::RawUdp.is_raw());
2153 assert!(!PortScanStep::ConnectTcp.is_raw());
2154 assert!(!PortScanStep::ConnectUdp.is_raw());
2155 }
2156
2157 #[test]
2159 fn a_plan_remembers_the_technique_it_was_built_for() {
2160 let cfg = ZondConfig {
2161 tcp_technique: TcpScanTechnique::Ack,
2162 ..ZondConfig::default()
2163 };
2164 assert_eq!(
2165 PortScanPlan::build(&cfg, Privilege::Connect).technique(),
2166 TcpScanTechnique::Ack
2167 );
2168 }
2169
2170 #[test]
2173 fn dropping_a_step_is_visible_in_what_the_plan_covers() {
2174 let mut plan = PortScanPlan::build(&ZondConfig::default(), Privilege::Connect);
2175 plan.steps_mut()
2176 .retain(|step| step.protocol() != Protocol::Udp);
2177
2178 assert!(plan.covers(Protocol::Tcp));
2179 assert!(!plan.covers(Protocol::Udp));
2180 }
2181
2182 #[test]
2189 fn a_swept_plan_takes_no_candidate_from_an_excluded_machine() {
2190 let machine = MacAddr::new(0x02, 0, 0, 0, 0, 0x30);
2191 let other = MacAddr::new(0x02, 0, 0, 0, 0, 0x31);
2192 let at = |ip: &str, mac| neighbor_cache::Neighbor {
2193 mac: Some(mac),
2194 ..entry(ip, 7)
2195 };
2196 let v4 = neighbor_cache::Neighbor {
2197 ip: "192.0.2.30".parse().expect("literal"),
2198 mac: Some(machine),
2199 interface_index: 7,
2200 };
2201 let v6_table = vec![at("2001:db8::30", machine), at("2001:db8::31", other)];
2202
2203 let mut forbidden = IpSet::new();
2204 forbidden.insert(v4.ip);
2205 let exclusions = Exclusions::new(forbidden);
2206 let mut both = vec![v4];
2207 both.extend(v6_table.iter().cloned());
2208 let machines = exclusions.hardware_in(both.iter().map(|entry| (entry.ip, entry.mac)));
2209
2210 let intf = interface_with(7, "en0", Vec::new());
2211 let mut local = std::collections::HashMap::from([(intf, IpSet::new())]);
2212 let withheld = seed_from_neighbor_table_with(&mut local, &v6_table, &exclusions, &machines);
2213
2214 let targets = local.into_values().next().expect("the one interface");
2215 assert!(
2216 !targets.contains(&v6("2001:db8::30")),
2217 "the excluded machine's IPv6 address became a target"
2218 );
2219 assert_eq!(
2220 withheld.iter().collect::<Vec<_>>(),
2221 vec![v6("2001:db8::30")],
2222 "what the sweep kept back went uncounted"
2223 );
2224 assert!(
2225 targets.contains(&v6("2001:db8::31")),
2226 "and its neighbour did"
2227 );
2228 }
2229
2230 #[test]
2236 fn a_swept_plan_does_not_take_an_excluded_neighbour_as_a_candidate() {
2237 let intf = interface_with(7, "en0", Vec::new());
2238 let table = vec![entry("2001:db8::aa", 7), entry("2001:dead::bb", 7)];
2239 let mut local = std::collections::HashMap::from([(intf, IpSet::new())]);
2240
2241 let mut forbidden = IpSet::new();
2242 forbidden.insert_range("2001:db8::/64".parse().expect("a valid range"));
2243 seed_from_neighbor_table_with(
2244 &mut local,
2245 &table,
2246 &Exclusions::new(forbidden),
2247 &BTreeSet::new(),
2248 );
2249
2250 let targets = local.into_values().next().expect("the one interface");
2251 let carried: Vec<std::net::Ipv6Addr> = targets
2252 .v6()
2253 .iter()
2254 .map(|range| range.start_addr())
2255 .collect();
2256
2257 assert!(
2258 !carried.contains(&"2001:db8::aa".parse().expect("literal")),
2259 "an excluded neighbour must not become a target"
2260 );
2261 assert!(
2262 carried.contains(&"2001:dead::bb".parse().expect("literal")),
2263 "and everything else still is"
2264 );
2265 }
2266}