use std::net::IpAddr;
use std::time::{Duration, Instant};
use async_trait::async_trait;
use pnet::packet::ip::IpNextHeaderProtocols;
use pnet::packet::udp::UdpPacket;
use tokio::sync::mpsc;
use crate::config::ProbeTuning;
use crate::error;
use crate::journal::settle::Outcome;
use crate::model::host::{HostStatus, StatusProtocol, StatusReason};
use crate::model::port::{PortState, Protocol};
use crate::model::target::PlannedTarget;
use crate::protocols::sizes::UDP_HDR_LEN;
use crate::scanner::pacing::congestion::{CongestionWindow, WindowLimits};
use crate::scanner::pacing::deadline::{AdaptiveDeadline, AdaptiveDeadlineConfig};
use crate::scanner::pacing::retry::{ProbeLedger, RetryPolicy, SilentHostPolicy};
use crate::scanner::pacing::timer::ScanBudget;
use crate::scanner::payload;
use crate::scanner::session::{ScanContext, ScannerKind};
use crate::scanner::strategy::{PortScanner, StrategyError};
use crate::system::interface::SourceResolver;
use crate::transport::capture::CapturedSegment;
use crate::transport::probe::{ProbeKind, ProbeTransport};
use super::icmp_error::{self, Unreachable};
use super::probe_scan::{self, AuditLabels, ProbeTarget, RawPortScan, RawProbeScan};
use super::send_udp;
use crate::scanner::audit::ProbeAudit;
type Ledger = ProbeLedger<ProbeTarget, (), u64>;
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<()>,
}
impl UdpPortScanner {
pub fn new(
resolver: SourceResolver,
ctx: ScanContext,
target_count: usize,
tuning: ProbeTuning,
) -> Result<Self, StrategyError> {
let src_port: u16 = rand::random_range(50_000..u16::MAX);
let transport = ProbeTransport::open_with(
ProbeKind::UdpProbe {
reply_port: src_port,
},
tuning.send_mode,
)?;
Ok(Self::build(
resolver,
ctx,
transport,
target_count,
src_port,
RETRY_POLICY.configured(tuning.retry),
tuning
.max_probe_rate
.unwrap_or(super::UDP_PORT_RATE_PER_SEC)
.max(1),
))
}
pub fn with_transport(
resolver: SourceResolver,
ctx: ScanContext,
transport: ProbeTransport,
target_count: usize,
src_port: u16,
) -> Self {
Self::build(
resolver,
ctx,
transport,
target_count,
src_port,
RETRY_POLICY,
super::UDP_PORT_RATE_PER_SEC,
)
}
fn build(
resolver: SourceResolver,
ctx: ScanContext,
transport: ProbeTransport,
target_count: usize,
src_port: u16,
retry: RetryPolicy,
rate_per_sec: u32,
) -> Self {
let (send_tick, batch) = super::pacing_for(rate_per_sec);
let deadline_config = DEADLINE_CONFIG
.allowing_for(retry.worst_case_probe_lifetime())
.allowing_pace_of(Duration::from_secs(1) / rate_per_sec.max(1), target_count);
let mut scanner = Self {
core: RawProbeScan {
resolver,
ctx,
transport,
deadline: AdaptiveDeadline::new(deadline_config, target_count),
ledger: Ledger::new(retry, target_count.min(MAX_IN_FLIGHT as usize)),
due: Vec::new(),
src_port,
send_failure: None,
audit: ProbeAudit::new(),
window: CongestionWindow::new(WindowLimits::fixed(MAX_IN_FLIGHT)),
send_tick,
batch,
max_unresolved: MAX_IN_FLIGHT as usize,
},
};
scanner.core.seed_timing();
scanner
}
fn resolve_probe(
&mut self,
target: ProbeTarget,
state: PortState,
sender: IpAddr,
now: Instant,
) {
let Some(resolution) = self.core.ledger.resolve(&target, None, now) else {
self.core.audit.record_reply_without_rtt();
return;
};
self.core.record_answer(&resolution);
self.record_port(target.0, target.1, state, Some(sender));
self.settle(Outcome::Answered {
position: resolution.payload,
});
}
}
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 => 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 {
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 probe(&mut self, ip: IpAddr, port: u16, position: u64, now: Instant) {
self.send(ip, port, Some(position), now);
}
fn reprobe(&mut self, ip: IpAddr, port: u16, now: Instant) {
self.send(ip, port, None, now);
}
fn handle_reply(&mut self, reply: &CapturedSegment, now: Instant) {
let classified = match reply.protocol {
IpNextHeaderProtocols::Udp => {
answering_probe(&reply.bytes, self.core.src_port).map(|(port, datagram)| {
if let Some(role) = payload::declared_role(port, datagram) {
self.core.ctx.update_host(reply.source, |host| {
host.add_network_role(role);
});
}
((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))) => {
self.resolve_probe(target, state, reply.source, now)
}
Some((target, Verdict::Host)) => self.core.record_host_down(target.0, reply.source),
None => {}
}
}
fn record_port(&mut self, ip: IpAddr, port_num: u16, state: PortState, sender: Option<IpAddr>) {
let port = crate::fingerprint::baseline_port(port_num, Protocol::Udp, state);
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);
}
});
}
}
#[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> {
probe_scan::run(self, targets).await;
Ok(())
}
}
impl UdpPortScanner {
fn send(&mut self, ip: IpAddr, port: u16, position: Option<u64>, now: Instant) {
let Some(src_addr) = self.core.resolver.resolve(ip) else {
error!(
verbosity = 2,
"no route to {ip}; skipping UDP probe to {ip}:{port}"
);
return;
};
let first_attempt = !self.core.ledger.contains(&(ip, port));
let sent = send_udp(
self.core.transport.tx.as_ref(),
self.core.src_port,
src_addr,
ip,
port,
&mut self.core.send_failure,
);
self.core.record_send(sent.is_some(), first_attempt);
if sent.is_some() {
match position {
Some(position) => self.core.ledger.arm(ip, (ip, port), (), position, now),
None => self.core.ledger.rearm(ip, (ip, port), (), now),
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::model::host::NetworkRole;
use crate::model::target::Target;
use std::net::{Ipv4Addr, Ipv6Addr};
use pnet::ipnetwork::{IpNetwork, Ipv4Network, Ipv6Network};
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::routed::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, 168, 1, 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, 168, 1, 1));
const LOCAL_V4: IpAddr = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 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() -> pnet::datalink::NetworkInterface {
pnet::datalink::NetworkInterface {
name: "test0".to_string(),
description: String::new(),
index: 0,
mac: None,
ips: vec![
IpNetwork::V4(Ipv4Network::new(Ipv4Addr::new(192, 168, 1, 50), 24).unwrap()),
IpNetwork::V6(
Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 50), 64).unwrap(),
),
],
flags: 0,
}
}
fn scanner_with_recorder() -> (UdpPortScanner, ScanSession, SentProbes) {
let (session, ctx) = ScanSession::new();
let (_reply_tx, reply_rx) = tokio::sync::mpsc::unbounded_channel();
let sender = MockSender::default();
let sent = sender.sent.clone();
let transport = ProbeTransport::from_parts(Box::new(sender), reply_rx);
let resolver = SourceResolver::from_interfaces(&[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::unbounded_channel();
let transport = ProbeTransport::from_parts(Box::new(MockSender::default()), reply_rx);
let resolver = SourceResolver::from_interfaces(&[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()))
}
fn captured(
source: IpAddr,
protocol: pnet::packet::ip::IpNextHeaderProtocol,
bytes: Vec<u8>,
) -> CapturedSegment {
CapturedSegment::synthetic(source, protocol, 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::create_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::create_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::create_ipv4_header(s, d, len, IpNextHeaderProtocols::Udp, ip::HOP_LIMIT_ROUTED)
.unwrap()
}
(IpAddr::V6(s), IpAddr::V6(d)) => {
ip::create_ipv6_header(s, d, len, IpNextHeaderProtocols::Udp, 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 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);
scanner.service_retries(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);
}
#[tokio::test]
#[ignore = "needs libpcap capture access (root or access_bpf)"]
async fn real_kernel_icmp_error_identifies_the_probe_that_caused_it() {
use crate::transport::capture;
use std::time::Duration;
let loopback = pnet::datalink::interfaces()
.into_iter()
.find(|iface| iface.is_loopback() && iface.is_up())
.expect("a loopback interface to capture on");
let socket = tokio::net::UdpSocket::bind(("127.0.0.1", 0)).await.unwrap();
let src_port = socket.local_addr().unwrap().port();
let reserved = tokio::net::UdpSocket::bind(("127.0.0.1", 0)).await.unwrap();
let closed_port = reserved.local_addr().unwrap().port();
drop(reserved);
let filter = format!("icmp or icmp6 or (udp and dst port {src_port})");
let (mut rx, _capture) = capture::start(&[loopback.name], &filter).unwrap();
tokio::time::sleep(Duration::from_millis(500)).await;
socket
.send_to(b"", ("127.0.0.1", closed_port))
.await
.unwrap();
let reply = tokio::time::timeout(Duration::from_secs(3), rx.recv())
.await
.expect("kernel produced no ICMP error within 3s")
.expect("capture stream closed");
assert_eq!(reply.protocol, IpNextHeaderProtocols::Icmp);
let error = icmp_error::parse(&reply).expect("a real ICMP error parses");
assert_eq!(
(quoted_probe(&error, src_port), verdict_of(error.reason)),
(
Some((IpAddr::V4(Ipv4Addr::LOCALHOST), closed_port)),
Verdict::Port(PortState::Closed)
),
"a real ICMP error must name the exact probe that caused it",
);
}
#[tokio::test]
#[ignore = "needs libpcap capture access (root or access_bpf)"]
async fn real_udp_reply_reaches_the_scan_through_the_capture_filter() {
use crate::transport::capture;
use std::time::Duration;
let loopback = pnet::datalink::interfaces()
.into_iter()
.find(|iface| iface.is_loopback() && iface.is_up())
.expect("a loopback interface to capture on");
let socket = tokio::net::UdpSocket::bind(("127.0.0.1", 0)).await.unwrap();
let src_port = socket.local_addr().unwrap().port();
let service = tokio::net::UdpSocket::bind(("127.0.0.1", 0)).await.unwrap();
let service_port = service.local_addr().unwrap().port();
tokio::spawn(async move {
let mut buf = [0u8; 64];
if let Ok((_, from)) = service.recv_from(&mut buf).await {
let _ = service.send_to(b"pong", from).await;
}
});
let filter = format!("icmp or icmp6 or (udp and dst port {src_port})");
let (mut rx, _capture) = capture::start(&[loopback.name], &filter).unwrap();
tokio::time::sleep(Duration::from_millis(500)).await;
socket
.send_to(b"ping", ("127.0.0.1", service_port))
.await
.unwrap();
let reply = tokio::time::timeout(Duration::from_secs(3), async {
while let Some(segment) = rx.recv().await {
if segment.protocol == IpNextHeaderProtocols::Udp {
return segment;
}
}
panic!("capture stream closed before a UDP reply arrived");
})
.await
.expect("no UDP reply captured within 3s");
assert_eq!(
answering_probe(&reply.bytes, src_port),
Some((service_port, b"ping".as_slice())),
"a real reply must resolve to the port that sent it, and to what it said",
);
}
#[test]
fn an_unanswered_probe_is_sent_again() {
let (mut scanner, session, sent) = scanner_with_recorder();
probe(&mut scanner, TARGET, 53);
scanner.service_retries(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_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();
scanner.service_retries(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();
scanner.service_retries(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::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);
scanner.resolve_remaining();
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::unbounded_channel();
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_interfaces(&[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);
}
}
}