use std::collections::HashMap;
use std::net::IpAddr;
use std::time::{Duration, Instant};
use async_trait::async_trait;
use pnet_packet::ip::{IpNextHeaderProtocol, IpNextHeaderProtocols};
use pnet_packet::udp::UdpPacket;
use tokio::sync::mpsc;
use crate::config::{ProbeTuning, ServiceDetection};
use crate::journal::settle::Outcome;
use crate::logging::info;
use crate::model::capture::IpObservation;
use crate::model::host::{HostStatus, StatusProtocol, StatusReason};
use crate::model::port::discovery::{Discovery as PortDiscovery, ScanResponse};
use crate::model::port::{PortState, Protocol};
use crate::model::target::PlannedTarget;
use crate::protocols::sizes::UDP_HDR_LEN;
use crate::report::ScannerKind;
use crate::scanner::pacing::congestion::WindowLimits;
use crate::scanner::pacing::deadline::AdaptiveDeadlineConfig;
use crate::scanner::pacing::retry::{RetryPolicy, SilentHostPolicy};
use crate::scanner::pacing::timer::ScanBudget;
use crate::scanner::payload;
use crate::scanner::session::ScanContext;
use crate::scanner::strategy::{PortScanner, StrategyError};
use crate::system::interface::SourceResolver;
use crate::transport::capture::CapturedSegment;
use crate::transport::probe::{ProbeKind, ProbeTransport};
use super::super::raw::{EvasionParts, send_udp};
use super::{AuditLabels, CoreParts, ProbeTarget, RawPortScan, RawProbeScan};
use crate::scanner::strategy::icmp_error::{self, Unreachable};
const DEADLINE_CONFIG: AdaptiveDeadlineConfig = AdaptiveDeadlineConfig::new(
ScanBudget::new(
Duration::from_millis(2_000),
Duration::from_millis(200),
Duration::from_secs(45),
),
ScanBudget::new(
Duration::from_millis(500),
Duration::from_millis(50),
Duration::from_secs(10),
),
Duration::from_millis(1_200),
Duration::from_secs(5),
4.0,
20,
);
const RETRY_POLICY: RetryPolicy = RetryPolicy::new(
2,
Duration::from_millis(1_500),
Duration::from_millis(1_200),
Duration::from_secs(5),
1.5,
0.2,
Some(SilentHostPolicy::new(32, 1)),
);
const MAX_IN_FLIGHT: u32 = 512;
pub struct UdpPortScanner {
core: RawProbeScan<()>,
service_detection: ServiceDetection,
icmp: HashMap<IpAddr, IcmpTally>,
}
#[derive(Debug, Default, Clone, Copy)]
struct IcmpTally {
closed: u32,
late: u32,
silent: u32,
}
impl IcmpTally {
fn rate_limited(self) -> bool {
self.late > 0 && self.late < self.closed && self.silent > self.closed
}
}
impl UdpPortScanner {
pub fn new(
resolver: SourceResolver,
ctx: ScanContext,
target_count: usize,
tuning: ProbeTuning,
) -> Result<Self, StrategyError> {
let src_port: u16 = tuning
.evasion
.source_port_or(rand::random_range(50_000..u16::MAX));
let transport = ProbeTransport::open_capturing(
ProbeKind::UdpProbe {
reply_port: src_port,
},
tuning.evasion.effective_send_mode(tuning.send_mode),
&ctx.capture_links(),
)?;
Ok(Self {
service_detection: tuning.service_detection,
core: Self::core(resolver, ctx, transport, &tuning, src_port, target_count),
icmp: HashMap::new(),
})
}
pub fn with_transport(
resolver: SourceResolver,
ctx: ScanContext,
transport: ProbeTransport,
target_count: usize,
src_port: u16,
) -> Self {
Self::with_transport_tuned(
resolver,
ctx,
transport,
target_count,
src_port,
ProbeTuning::default(),
)
}
pub fn with_transport_tuned(
resolver: SourceResolver,
ctx: ScanContext,
transport: ProbeTransport,
target_count: usize,
src_port: u16,
tuning: ProbeTuning,
) -> Self {
Self {
service_detection: tuning.service_detection,
core: Self::core(resolver, ctx, transport, &tuning, src_port, target_count),
icmp: HashMap::new(),
}
}
fn core(
resolver: SourceResolver,
ctx: ScanContext,
transport: ProbeTransport,
tuning: &ProbeTuning,
src_port: u16,
target_count: usize,
) -> RawProbeScan<()> {
let rate = super::super::raw::rate_within(
tuning.max_probe_rate,
tuning.min_probe_rate,
super::UDP_PORT_RATE_PER_SEC,
);
RawProbeScan::new(CoreParts {
resolver,
ctx,
transport,
tuning,
src_port,
target_count,
retry: RETRY_POLICY.configured(tuning.retry),
rate,
deadline: DEADLINE_CONFIG,
window: WindowLimits::fixed(MAX_IN_FLIGHT),
max_unresolved: MAX_IN_FLIGHT as usize,
})
}
fn resolve_probe(
&mut self,
target: ProbeTarget,
state: PortState,
sender: IpAddr,
ttl: Option<u8>,
now: Instant,
) -> bool {
let Some(resolution) = self.core.ledger.resolve(&target, None, now) else {
self.core.audit.record_reply_without_rtt();
return false;
};
if state == PortState::Closed && sender == target.0 {
let tally = self.icmp.entry(target.0).or_default();
tally.closed += 1;
if resolution.attempts > 1 {
tally.late += 1;
}
}
let rtt = resolution.rtt;
self.core.record_answer(&resolution);
self.record_port_answered_by(target.0, target.1, state, Some(sender), ttl, rtt);
self.settle(Outcome::Answered {
position: resolution.payload,
});
true
}
fn asked(&self, (ip, port): ProbeTarget) -> bool {
self.core
.ctx
.read_host(ip, |host| {
host.ports()
.any(|found| found.number() == port && found.protocol() == Protocol::Udp)
})
.unwrap_or(false)
}
}
fn answering_probe(bytes: &[u8], src_port: u16) -> Option<(u16, &[u8])> {
let udp = UdpPacket::new(bytes)?;
if udp.get_destination() != src_port {
return None;
}
Some((udp.get_source(), &bytes[UDP_HDR_LEN..]))
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Verdict {
Port(PortState),
Host,
}
fn verdict_of(reason: Unreachable) -> Verdict {
match reason {
Unreachable::Port => Verdict::Port(PortState::Closed),
Unreachable::Prohibited | Unreachable::Protocol => Verdict::Port(PortState::Filtered),
Unreachable::Host => Verdict::Host,
}
}
fn quoted_probe(error: &icmp_error::IcmpError<'_>, src_port: u16) -> Option<ProbeTarget> {
if error.quoted.protocol != IpNextHeaderProtocols::Udp.0 {
return None;
}
let udp = UdpPacket::new(error.quoted.payload)?;
if udp.get_source() != src_port {
return None;
}
Some((error.quoted.destination, udp.get_destination()))
}
impl RawPortScan for UdpPortScanner {
type Token = ();
fn core(&self) -> &RawProbeScan<()> {
&self.core
}
fn core_mut(&mut self) -> &mut RawProbeScan<()> {
&mut self.core
}
fn protocol(&self) -> Protocol {
Protocol::Udp
}
fn silence_means(&self) -> PortState {
PortState::OpenFiltered
}
fn audit_labels(&self) -> AuditLabels {
AuditLabels {
tag: "udp-port",
silence: "open-filtered",
}
}
fn handle_reply(&mut self, reply: &CapturedSegment, now: Instant) {
let mut declared = None;
let mut names = Vec::new();
let classified = match IpNextHeaderProtocol(reply.protocol) {
IpNextHeaderProtocols::Udp => {
answering_probe(&reply.bytes, self.core.src_port).map(|(port, datagram)| {
declared = payload::declared_role(port, datagram);
names = payload::declared_names(port, datagram);
((reply.source, port), Verdict::Port(PortState::Open))
})
}
_ => icmp_error::parse(reply).and_then(|error| {
let target = quoted_probe(&error, self.core.src_port)?;
Some((target, verdict_of(error.reason)))
}),
};
match classified {
Some((target, Verdict::Port(state))) => {
let resolved = self.resolve_probe(
target,
state,
reply.source,
reply.observation.map(IpObservation::remaining_hops),
now,
);
if (declared.is_some() || !names.is_empty()) && (resolved || self.asked(target)) {
self.core.ctx.update_host(target.0, |host| {
if let Some(role) = declared {
host.add_network_role(role);
}
for name in names {
host.record_name(name);
}
});
}
}
Some((target, Verdict::Host)) => {
self.core.record_host_down(&target, None, reply.source);
}
None => {}
}
}
fn record_port(&mut self, ip: IpAddr, port_num: u16, state: PortState, sender: Option<IpAddr>) {
if state == PortState::OpenFiltered && sender.is_none() {
self.icmp.entry(ip).or_default().silent += 1;
}
self.record_port_answered_by(ip, port_num, state, sender, None, None);
}
fn send(&mut self, ip: IpAddr, port: u16, position: Option<u64>, now: Instant) {
let first_attempt = position.is_some();
let Some(src_addr) = self.core.source_for((ip, port), first_attempt) else {
return;
};
let sent = send_udp(
self.core.transport.tx.as_ref(),
self.core.src_port,
src_addr,
ip,
self.core.resolver.zone_of(ip),
port,
EvasionParts {
emission: self.core.emission,
shaping: self.core.shaping,
decoys: &self.core.decoys,
},
);
self.core
.record_send((ip, port), sent.as_ref().map(|_| ()), first_attempt);
if sent.is_ok() {
match position {
Some(position) => self.core.ledger.arm(ip, (ip, port), (), position, now),
None => self.core.ledger.rearm(ip, (ip, port), (), now),
}
}
}
}
impl UdpPortScanner {
fn report_rationed(&mut self) {
for (ip, tally) in self.icmp.drain() {
if tally.rate_limited() {
info!(
verbosity = 1,
"{ip} rate-limited its ICMP errors: {} of its ports answered closed, \
{} of them only when asked again, and {} stayed silent",
tally.closed,
tally.late,
tally.silent
);
self.core.ctx.record_icmp_rate_limited(ip);
}
}
}
fn record_port_answered_by(
&mut self,
ip: IpAddr,
port_num: u16,
state: PortState,
sender: Option<IpAddr>,
ttl: Option<u8>,
rtt: Option<Duration>,
) {
let port = crate::fingerprint::baseline_port(port_num, Protocol::Udp, state);
let port = match port_evidence(state, sender, ip) {
Some(reason) => {
let mut discovery = PortDiscovery::new(reason);
if let Some(rtt) = rtt {
discovery = discovery.with_rtt(rtt);
}
if let Some(ttl) = ttl {
discovery = discovery.with_ttl(ttl);
}
port.with_discovery(discovery)
}
None => port,
};
let evidence = match (state, sender) {
(PortState::Open, _) => Some((
HostStatus::Up,
StatusReason::new(StatusProtocol::Udp, "udp reply from a probed port"),
)),
(PortState::Closed, Some(sender)) if sender == ip => Some((
HostStatus::Up,
StatusReason::new(
StatusProtocol::IcmpUnreachable,
"port unreachable from the host",
),
)),
(PortState::Filtered, Some(sender)) if sender == ip => Some((
HostStatus::Up,
StatusReason::new(
StatusProtocol::IcmpUnreachable,
"administratively prohibited by the host",
),
)),
(PortState::Filtered, Some(sender)) => Some((
HostStatus::Filtered,
StatusReason::new(
StatusProtocol::IcmpUnreachable,
"administratively prohibited in path",
)
.from_source(sender),
)),
_ => None,
};
self.core.ctx.update_host(ip, |host| {
host.add_port(port);
if let Some((status, reason)) = evidence {
host.record_evidence(status, reason);
}
});
}
}
fn port_evidence(state: PortState, sender: Option<IpAddr>, target: IpAddr) -> Option<ScanResponse> {
match (state, sender) {
(PortState::Open, _) => Some(ScanResponse::UdpResponse),
(PortState::Closed, _) => Some(ScanResponse::IcmpUnreachable),
(PortState::Filtered, Some(from)) => Some(match from == target {
true => ScanResponse::IcmpProhibited,
false => ScanResponse::IcmpUnreachable,
}),
_ => None,
}
}
#[async_trait]
impl PortScanner for UdpPortScanner {
fn kind(&self) -> ScannerKind {
ScannerKind::UdpPort
}
fn supported_protocols(&self) -> Vec<Protocol> {
vec![Protocol::Udp]
}
async fn scan(&mut self, targets: mpsc::Receiver<PlannedTarget>) -> Result<(), StrategyError> {
let driven = super::drive(self, targets).await;
self.report_rationed();
driven
}
async fn detect_services(&mut self, ctx: &ScanContext) {
crate::scanner::service::detect(ctx, self.service_detection, Protocol::Udp).await;
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::model::host::NetworkRole;
use crate::model::target::Target;
use std::net::{Ipv4Addr, Ipv6Addr};
use pnet_packet::icmp::destination_unreachable::{
DestinationUnreachablePacket, IcmpCodes, MutableDestinationUnreachablePacket,
};
use pnet_packet::icmp::{IcmpCode, IcmpTypes};
use pnet_packet::icmpv6::{Icmpv6Code, Icmpv6Packet, Icmpv6Types, MutableIcmpv6Packet};
use crate::scanner::strategy::icmp_error::{
ICMPV6_ADMIN_PROHIBITED, ICMPV6_INGRESS_EGRESS_POLICY, ICMPV6_NO_ROUTE,
ICMPV6_PORT_UNREACHABLE, ICMPV6_REJECT_ROUTE, ICMPV6_UNUSED_LEN,
};
use crate::protocols::{ip, udp};
use crate::scanner::session::ScanSession;
use crate::transport::probe::{MockSender, ProbeTransport};
const TARGET: IpAddr = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 200));
const TARGET_V6: IpAddr = IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 200));
const ROUTER: IpAddr = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1));
const LOCAL_V4: IpAddr = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 50));
const LOCAL_V6: IpAddr = IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 50));
const SCAN_SRC_PORT: u16 = 54_321;
fn on_link_interface() -> crate::system::interface::Link {
use crate::system::interface::{Link, LinkAddress};
Link::new("test0", 0).with_addresses(vec![
LinkAddress::new(IpAddr::V4(Ipv4Addr::new(192, 0, 2, 50)), 24),
LinkAddress::new(
IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 50)),
64,
),
])
}
fn scanner_with_recorder() -> (UdpPortScanner, ScanSession, SentProbes) {
let (session, ctx) = ScanSession::new();
let (_reply_tx, reply_rx) = tokio::sync::mpsc::channel(1024);
let sender = MockSender::default();
let sent = sender.sent.clone();
let transport = ProbeTransport::from_parts(Box::new(sender), reply_rx);
let resolver = SourceResolver::from_links(&[on_link_interface()]);
let scanner = UdpPortScanner::with_transport(resolver, ctx, transport, 8, SCAN_SRC_PORT);
(scanner, session, sent)
}
type SentProbes = std::sync::Arc<std::sync::Mutex<Vec<crate::transport::probe::SentProbe>>>;
fn scanner_with_mock() -> (UdpPortScanner, ScanSession) {
let (session, ctx) = ScanSession::new();
let (_reply_tx, reply_rx) = tokio::sync::mpsc::channel(1024);
let transport = ProbeTransport::from_parts(Box::new(MockSender::default()), reply_rx);
let resolver = SourceResolver::from_links(&[on_link_interface()]);
let scanner = UdpPortScanner::with_transport(resolver, ctx, transport, 8, SCAN_SRC_PORT);
(scanner, session)
}
fn probe(scanner: &mut UdpPortScanner, ip: IpAddr, port: u16) {
scanner.send_probe(PlannedTarget::new(
u64::from(port),
Target {
ip,
port,
protocol: Protocol::Udp,
},
));
}
fn host_status(session: &ScanSession, ip: IpAddr) -> Option<HostStatus> {
session.hosts().get(ip).map(|host| host.status())
}
fn port_state(session: &ScanSession, ip: IpAddr, port: u16) -> Option<PortState> {
session
.hosts()
.get(ip)
.and_then(|h| h.ports().find(|p| p.number() == port).map(|p| p.state()))
}
#[test]
fn an_answered_udp_port_records_the_datagram_that_settled_it() {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET, 53);
let mut reply = udp_reply(53, SCAN_SRC_PORT);
reply.observation = Some(IpObservation::V4(crate::model::capture::Ipv4Observation {
ttl: 58,
identification: 0,
dont_fragment: true,
more_fragments: false,
dscp: 0,
ecn: 0,
}));
scanner.handle_reply(&reply, Instant::now());
let discovery = session
.hosts()
.get(TARGET)
.and_then(|host| {
host.ports()
.find(|port| port.number() == 53)
.and_then(|port| port.discovery().cloned())
})
.expect("the port carries its evidence");
assert_eq!(discovery.reason(), &ScanResponse::UdpResponse);
assert_eq!(discovery.ttl(), Some(58));
}
#[test]
fn an_unanswered_udp_port_records_no_evidence() {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET, 53);
scanner.record_port(TARGET, 53, PortState::OpenFiltered, None);
assert_eq!(
port_state(&session, TARGET, 53),
Some(PortState::OpenFiltered)
);
assert!(
session
.hosts()
.get(TARGET)
.and_then(|host| host
.ports()
.find(|port| port.number() == 53)
.and_then(|port| port.discovery().cloned()))
.is_none(),
"a silence was dressed up as a packet"
);
}
fn captured(
source: IpAddr,
protocol: pnet_packet::ip::IpNextHeaderProtocol,
bytes: Vec<u8>,
) -> CapturedSegment {
CapturedSegment::synthetic(source, protocol.0, bytes)
}
fn udp_reply(src_port: u16, dst_port: u16) -> CapturedSegment {
udp_reply_saying(src_port, dst_port, vec![])
}
fn udp_reply_saying(src_port: u16, dst_port: u16, said: Vec<u8>) -> CapturedSegment {
captured(
TARGET,
IpNextHeaderProtocols::Udp,
udp::build_packet(TARGET, LOCAL_V4, src_port, dst_port, said).unwrap(),
)
}
fn quoted_probe_packet(from: IpAddr, to: IpAddr, src_port: u16, dst_port: u16) -> Vec<u8> {
let datagram = udp::build_packet(from, to, src_port, dst_port, vec![]).unwrap();
let len = datagram.len() as u16;
let header = match (from, to) {
(IpAddr::V4(s), IpAddr::V4(d)) => ip::build_ipv4_header(
s,
d,
len,
IpNextHeaderProtocols::Udp.0,
ip::HOP_LIMIT_ROUTED,
)
.unwrap(),
(IpAddr::V6(s), IpAddr::V6(d)) => ip::build_ipv6_header(
s,
d,
len,
IpNextHeaderProtocols::Udp.0,
ip::HOP_LIMIT_ROUTED,
),
_ => panic!("IP version mismatch in test fixture"),
};
header.into_iter().chain(datagram).collect()
}
fn icmpv4_error(
from: IpAddr,
code: IcmpCode,
to: IpAddr,
src_port: u16,
dst_port: u16,
) -> CapturedSegment {
let quoted = quoted_probe_packet(LOCAL_V4, to, src_port, dst_port);
let mut buf = vec![0u8; DestinationUnreachablePacket::minimum_packet_size() + quoted.len()];
let mut packet = MutableDestinationUnreachablePacket::new(&mut buf).unwrap();
packet.set_icmp_type(IcmpTypes::DestinationUnreachable);
packet.set_icmp_code(code);
packet.set_payload("ed);
captured(from, IpNextHeaderProtocols::Icmp, buf)
}
fn icmpv6_error(code: Icmpv6Code, to: IpAddr, src_port: u16, dst_port: u16) -> CapturedSegment {
let quoted = quoted_probe_packet(LOCAL_V6, to, src_port, dst_port);
let mut buf =
vec![0u8; Icmpv6Packet::minimum_packet_size() + ICMPV6_UNUSED_LEN + quoted.len()];
let mut packet = MutableIcmpv6Packet::new(&mut buf).unwrap();
packet.set_icmpv6_type(Icmpv6Types::DestinationUnreachable);
packet.set_icmpv6_code(code);
let mut payload = vec![0u8; ICMPV6_UNUSED_LEN];
payload.extend_from_slice("ed);
packet.set_payload(&payload);
captured(to, IpNextHeaderProtocols::Icmpv6, buf)
}
#[test]
fn a_dns_answer_names_the_host_a_name_server() {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET, 53);
let mut answer = crate::scanner::payload::for_port(53).to_vec();
answer[2] |= 0b1000_0000;
scanner.handle_reply(&udp_reply_saying(53, SCAN_SRC_PORT, answer), Instant::now());
assert_eq!(port_state(&session, TARGET, 53), Some(PortState::Open));
let host = session.hosts().get(TARGET).expect("the host answered");
assert!(
host.network_roles().contains(&NetworkRole::DnsServer),
"the reply parsed as DNS, which a bound socket cannot fake"
);
}
#[test]
fn a_dns_answer_names_the_sender_only_if_the_scan_asked_it() {
let (mut scanner, session) = scanner_with_mock();
let mut answer = crate::scanner::payload::for_port(53).to_vec();
answer[2] |= 0b1000_0000;
scanner.handle_reply(
&udp_reply_saying(53, SCAN_SRC_PORT, answer.clone()),
Instant::now(),
);
assert!(
session.hosts().get(TARGET).is_none(),
"an answer nobody asked for invented a host: {:?}",
session.hosts().get(TARGET)
);
probe(&mut scanner, TARGET, 53);
scanner.handle_reply(&udp_reply(53, SCAN_SRC_PORT), Instant::now());
scanner.handle_reply(&udp_reply_saying(53, SCAN_SRC_PORT, answer), Instant::now());
let host = session.hosts().get(TARGET).expect("the host answered");
assert!(
host.network_roles().contains(&NetworkRole::DnsServer),
"a duplicate answer from a host that was asked still names it"
);
}
#[test]
fn a_name_table_names_the_machine_and_its_workgroup() {
use crate::model::host::{NameKind, NameSource};
use crate::protocols::netbios::tests::response;
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET, 137);
let table = response(&[("FILESERVER", 0x00, false), ("EXAMPLEGRP", 0x00, true)]);
scanner.handle_reply(&udp_reply_saying(137, SCAN_SRC_PORT, table), Instant::now());
let host = session.hosts().get(TARGET).expect("the host answered");
let names: Vec<_> = host
.names()
.map(|name| (name.kind(), name.source(), name.name().to_owned()))
.collect();
assert_eq!(
names,
[
(
NameKind::NetbiosHost,
NameSource::Netbios,
"FILESERVER".to_owned()
),
(
NameKind::NetbiosDomain,
NameSource::Netbios,
"EXAMPLEGRP".to_owned()
),
]
);
}
#[test]
fn an_open_port_53_that_does_not_speak_dns_is_only_an_open_port() {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET, 53);
scanner.handle_reply(
&udp_reply_saying(53, SCAN_SRC_PORT, b"hello".to_vec()),
Instant::now(),
);
assert_eq!(port_state(&session, TARGET, 53), Some(PortState::Open));
let host = session.hosts().get(TARGET).expect("the host answered");
assert!(host.network_roles().is_empty());
}
#[test]
fn direct_udp_reply_is_open() {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET, 53);
scanner.handle_reply(&udp_reply(53, SCAN_SRC_PORT), Instant::now());
assert_eq!(port_state(&session, TARGET, 53), Some(PortState::Open));
assert!(scanner.core.ledger.is_empty());
}
#[test]
fn udp_traffic_not_addressed_to_the_scan_is_ignored() {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET, 53);
scanner.handle_reply(
&udp_reply(53, SCAN_SRC_PORT.wrapping_add(1)),
Instant::now(),
);
assert_eq!(port_state(&session, TARGET, 53), None);
assert_eq!(scanner.core.ledger.len(), 1);
}
#[test]
fn icmp_port_unreachable_is_closed() {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET, 53);
scanner.handle_reply(
&icmpv4_error(
TARGET,
IcmpCodes::DestinationPortUnreachable,
TARGET,
SCAN_SRC_PORT,
53,
),
Instant::now(),
);
assert_eq!(port_state(&session, TARGET, 53), Some(PortState::Closed));
assert!(scanner.core.ledger.is_empty());
}
#[test]
fn icmp_unreachable_closes_only_the_port_it_quotes() {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET, 53);
probe(&mut scanner, TARGET, 161);
probe(&mut scanner, TARGET, 123);
scanner.handle_reply(
&icmpv4_error(
TARGET,
IcmpCodes::DestinationPortUnreachable,
TARGET,
SCAN_SRC_PORT,
161,
),
Instant::now(),
);
assert_eq!(port_state(&session, TARGET, 161), Some(PortState::Closed));
assert_eq!(port_state(&session, TARGET, 53), None);
assert_eq!(port_state(&session, TARGET, 123), None);
assert_eq!(scanner.core.ledger.len(), 2);
}
#[test]
fn unreachable_from_a_router_resolves_the_quoted_target() {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET, 53);
scanner.handle_reply(
&icmpv4_error(
ROUTER,
IcmpCodes::DestinationPortUnreachable,
TARGET,
SCAN_SRC_PORT,
53,
),
Instant::now(),
);
assert_eq!(port_state(&session, TARGET, 53), Some(PortState::Closed));
assert_eq!(port_state(&session, ROUTER, 53), None);
}
#[test]
fn host_unreachable_is_a_host_verdict_and_not_a_port_one() {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET, 53);
scanner.handle_reply(
&icmpv4_error(
ROUTER,
IcmpCodes::DestinationHostUnreachable,
TARGET,
SCAN_SRC_PORT,
53,
),
Instant::now(),
);
assert_eq!(host_status(&session, TARGET), Some(HostStatus::Down));
assert_eq!(
port_state(&session, TARGET, 53),
None,
"the port has no verdict yet and the probe must be left to retire on its own"
);
assert_eq!(
scanner.core.ledger.len(),
1,
"an unreachable address says nothing about the probe's fate"
);
}
#[test]
fn a_port_unreachable_proves_the_host_only_when_the_host_sent_it() {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET, 53);
scanner.handle_reply(
&icmpv4_error(
TARGET,
IcmpCodes::DestinationPortUnreachable,
TARGET,
SCAN_SRC_PORT,
53,
),
Instant::now(),
);
assert_eq!(host_status(&session, TARGET), Some(HostStatus::Up));
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET, 53);
scanner.handle_reply(
&icmpv4_error(
ROUTER,
IcmpCodes::DestinationPortUnreachable,
TARGET,
SCAN_SRC_PORT,
53,
),
Instant::now(),
);
assert_eq!(
host_status(&session, TARGET),
Some(HostStatus::Unknown),
"a middlebox answering for an address does not make that address alive"
);
assert_eq!(
port_state(&session, TARGET, 53),
Some(PortState::Closed),
"the port verdict still stands: the message does report on the port"
);
}
#[test]
fn an_in_path_policy_rejection_is_filtered_rather_than_up() {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET, 53);
scanner.handle_reply(
&icmpv4_error(
ROUTER,
IcmpCodes::CommunicationAdministrativelyProhibited,
TARGET,
SCAN_SRC_PORT,
53,
),
Instant::now(),
);
assert_eq!(host_status(&session, TARGET), Some(HostStatus::Filtered));
}
#[test]
fn exhausting_every_attempt_leaves_the_host_unknown() {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET, 53);
let mut now = Instant::now();
for _ in 0..8 {
now += Duration::from_secs(10);
super::super::retry_due(&mut scanner, now);
}
assert_eq!(
port_state(&session, TARGET, 53),
Some(PortState::OpenFiltered)
);
assert_eq!(host_status(&session, TARGET), Some(HostStatus::Unknown));
assert!(
session
.hosts()
.get(TARGET)
.expect("the port verdict created the host")
.reasons()
.is_empty(),
"silence is not evidence and must leave no audit trail"
);
}
#[test]
fn unreachable_quoting_a_foreign_probe_is_ignored() {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET, 53);
scanner.handle_reply(
&icmpv4_error(
TARGET,
IcmpCodes::DestinationPortUnreachable,
TARGET,
SCAN_SRC_PORT.wrapping_add(1),
53,
),
Instant::now(),
);
assert_eq!(port_state(&session, TARGET, 53), None);
assert_eq!(scanner.core.ledger.len(), 1);
}
#[test]
fn administratively_prohibited_icmp_is_filtered() {
for code in [
IcmpCodes::DestinationProtocolUnreachable,
IcmpCodes::NetworkAdministrativelyProhibited,
IcmpCodes::HostAdministrativelyProhibited,
IcmpCodes::CommunicationAdministrativelyProhibited,
] {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET, 53);
scanner.handle_reply(
&icmpv4_error(TARGET, code, TARGET, SCAN_SRC_PORT, 53),
Instant::now(),
);
assert_eq!(
port_state(&session, TARGET, 53),
Some(PortState::Filtered),
"ICMP code {code:?} should read as filtered"
);
}
}
#[test]
fn uninformative_icmp_codes_leave_the_probe_outstanding() {
for code in [
IcmpCodes::DestinationNetworkUnknown,
IcmpCodes::FragmentationRequiredAndDFFlagSet,
IcmpCodes::SourceRouteFailed,
] {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET, 53);
scanner.handle_reply(
&icmpv4_error(TARGET, code, TARGET, SCAN_SRC_PORT, 53),
Instant::now(),
);
assert_eq!(port_state(&session, TARGET, 53), None, "code {code:?}");
assert_eq!(scanner.core.ledger.len(), 1, "code {code:?}");
}
}
#[test]
fn icmpv6_policy_refusals_are_filtered() {
for code in [
ICMPV6_ADMIN_PROHIBITED,
ICMPV6_INGRESS_EGRESS_POLICY,
ICMPV6_REJECT_ROUTE,
] {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET_V6, 53);
scanner.handle_reply(
&icmpv6_error(code, TARGET_V6, SCAN_SRC_PORT, 53),
Instant::now(),
);
assert_eq!(
port_state(&session, TARGET_V6, 53),
Some(PortState::Filtered),
"ICMPv6 code {code:?} should read as filtered"
);
}
}
#[test]
fn icmp_error_is_never_read_as_a_udp_reply() {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET, 771);
probe(&mut scanner, TARGET, 53);
scanner.handle_reply(
&icmpv4_error(
TARGET,
IcmpCodes::DestinationPortUnreachable,
TARGET,
SCAN_SRC_PORT,
53,
),
Instant::now(),
);
assert_eq!(port_state(&session, TARGET, 771), None);
assert_eq!(port_state(&session, TARGET, 53), Some(PortState::Closed));
}
#[test]
fn icmpv6_port_unreachable_is_closed() {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET_V6, 53);
scanner.handle_reply(
&icmpv6_error(ICMPV6_PORT_UNREACHABLE, TARGET_V6, SCAN_SRC_PORT, 53),
Instant::now(),
);
assert_eq!(port_state(&session, TARGET_V6, 53), Some(PortState::Closed));
assert!(scanner.core.ledger.is_empty());
}
#[test]
fn icmpv6_no_route_is_ignored() {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET_V6, 53);
scanner.handle_reply(
&icmpv6_error(ICMPV6_NO_ROUTE, TARGET_V6, SCAN_SRC_PORT, 53),
Instant::now(),
);
assert_eq!(port_state(&session, TARGET_V6, 53), None);
assert_eq!(scanner.core.ledger.len(), 1);
}
#[test]
fn malformed_replies_are_dropped() {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET, 53);
for len in 0..48usize {
let bytes = vec![0xFFu8; len];
for protocol in [
IpNextHeaderProtocols::Udp,
IpNextHeaderProtocols::Icmp,
IpNextHeaderProtocols::Icmpv6,
] {
scanner.handle_reply(&captured(TARGET, protocol, bytes.clone()), Instant::now());
}
}
assert_eq!(port_state(&session, TARGET, 53), None);
assert_eq!(scanner.core.ledger.len(), 1);
}
#[test]
fn an_unanswered_probe_is_sent_again() {
let (mut scanner, session, sent) = scanner_with_recorder();
probe(&mut scanner, TARGET, 53);
super::super::retry_due(&mut scanner, Instant::now() + Duration::from_secs(2));
assert_eq!(sent.lock().unwrap().len(), 2, "the probe was not retried");
assert_eq!(port_state(&session, TARGET, 53), None, "no verdict yet");
}
#[test]
fn a_host_rationing_its_icmp_errors_is_named_and_a_filtered_one_is_not() {
const FILTERED: IpAddr = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 201));
let (mut scanner, _session) = scanner_with_mock();
let unreachable = |host: IpAddr, port: u16| {
icmpv4_error(
host,
IcmpCodes::DestinationPortUnreachable,
host,
SCAN_SRC_PORT,
port,
)
};
for port in 1..=20 {
probe(&mut scanner, TARGET, port);
probe(&mut scanner, FILTERED, port);
}
let mut now = Instant::now();
for port in 1..=6 {
scanner.handle_reply(&unreachable(TARGET, port), now);
}
for port in 1..=8 {
scanner.handle_reply(&unreachable(FILTERED, port), now);
}
now += Duration::from_secs(2);
super::super::retry_due(&mut scanner, now);
for port in 7..=8 {
scanner.handle_reply(&unreachable(TARGET, port), now);
}
for _ in 0..RETRY_POLICY.max_attempts + 1 {
now += RETRY_POLICY.worst_case_probe_lifetime();
super::super::retry_due(&mut scanner, now);
}
assert!(scanner.core.ledger.is_empty(), "every probe was settled");
scanner.report_rationed();
assert_eq!(scanner.core.ctx.take_icmp_rate_limited(), vec![TARGET]);
}
#[test]
fn a_single_closed_port_answered_late_behind_a_filter_is_not_a_ration() {
let lossy_filter = IcmpTally {
closed: 1,
late: 1,
silent: 19,
};
assert!(!lossy_filter.rate_limited(), "{lossy_filter:?}");
let ration = IcmpTally {
closed: 7,
late: 1,
silent: 33,
};
assert!(ration.rate_limited(), "{ration:?}");
}
#[test]
fn a_probe_that_spends_its_budget_is_written_off_during_the_scan() {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET, 53);
let mut now = Instant::now();
for _ in 0..RETRY_POLICY.max_attempts + 1 {
now += RETRY_POLICY.worst_case_probe_lifetime();
super::super::retry_due(&mut scanner, now);
}
assert_eq!(
port_state(&session, TARGET, 53),
Some(PortState::OpenFiltered)
);
assert!(scanner.core.ledger.is_empty());
}
#[test]
fn running_out_of_attempts_does_not_extend_the_deadline() {
let (mut scanner, _session) = scanner_with_mock();
probe(&mut scanner, TARGET, 53);
let before = scanner.core.deadline.time_until_next_tick();
let mut now = Instant::now();
for _ in 0..RETRY_POLICY.max_attempts + 1 {
now += RETRY_POLICY.worst_case_probe_lifetime();
super::super::retry_due(&mut scanner, now);
}
let after = scanner.core.deadline.time_until_next_tick();
assert!(
after <= before,
"silence clock was reset by an expiry ({before:?} -> {after:?})"
);
}
#[test]
fn pending_probes_shorten_the_sleep() {
let (mut scanner, _session) = scanner_with_mock();
let now = Instant::now();
assert!(scanner.core.ledger.is_empty());
let idle = scanner.core.tick_delay(now);
probe(&mut scanner, TARGET, 53);
let busy = scanner.core.tick_delay(now);
assert!(busy < idle, "sleep not shortened while probes are out");
assert!(
busy <= RETRY_POLICY.worst_case_probe_lifetime(),
"the loop would sleep past the probe's whole schedule"
);
}
#[test]
fn silence_floor_outlasts_the_icmp_rate_limit() {
const ICMP_RATE_LIMIT_INTERVAL: Duration = Duration::from_secs(1);
assert!(
DEADLINE_CONFIG.silence_floor > ICMP_RATE_LIMIT_INTERVAL,
"silence floor {:?} is shorter than one rate-limited answer",
DEADLINE_CONFIG.silence_floor
);
assert!(
super::super::super::raw::DEADLINE_CONFIG.silence_floor < ICMP_RATE_LIMIT_INTERVAL,
"the SYN profile was expected to be the tighter one"
);
}
#[test]
fn unanswered_probes_resolve_as_filtered() {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET, 161);
super::super::run_out(&mut scanner);
assert_eq!(
port_state(&session, TARGET, 161),
Some(PortState::OpenFiltered)
);
assert!(scanner.core.ledger.is_empty());
}
#[test]
fn non_udp_targets_are_not_probed() {
let (mut scanner, _session) = scanner_with_mock();
scanner.send_probe(PlannedTarget::new(
0,
Target {
ip: TARGET,
port: 80,
protocol: Protocol::Tcp,
},
));
assert!(scanner.core.ledger.is_empty());
}
#[test]
fn every_probe_is_sent_from_the_scan_source_port() {
let (_session, ctx) = ScanSession::new();
let (_reply_tx, reply_rx) = tokio::sync::mpsc::channel(1024);
let sender = MockSender::default();
let sent = sender.sent.clone();
let transport = ProbeTransport::from_parts(Box::new(sender), reply_rx);
let mut scanner = UdpPortScanner::with_transport(
SourceResolver::from_links(&[on_link_interface()]),
ctx,
transport,
8,
SCAN_SRC_PORT,
);
for port in [53, 161, 123] {
probe(&mut scanner, TARGET, port);
}
let sent = sent.lock().unwrap();
assert_eq!(sent.len(), 3);
for (segment, _src, _dst) in sent.iter() {
let udp = UdpPacket::new(segment).expect("probe is a UDP datagram");
assert_eq!(udp.get_source(), SCAN_SRC_PORT);
}
}
#[test]
fn a_host_unreachable_about_no_live_probe_records_nothing() {
let never = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 77));
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, TARGET, 53);
scanner.handle_reply(
&icmpv4_error(
ROUTER,
IcmpCodes::DestinationHostUnreachable,
never,
SCAN_SRC_PORT,
53,
),
Instant::now(),
);
assert_eq!(
host_status(&session, never),
None,
"an address nothing was sent to is not a host this scan found"
);
scanner.handle_reply(
&icmpv4_error(
ROUTER,
IcmpCodes::DestinationHostUnreachable,
TARGET,
SCAN_SRC_PORT,
9999,
),
Instant::now(),
);
assert_ne!(
host_status(&session, TARGET),
Some(HostStatus::Down),
"port 9999 was never probed, so this quotes nothing this scan sent"
);
}
}