use std::net::IpAddr;
use std::time::{Duration, Instant};
use async_trait::async_trait;
use pnet::packet::Packet;
use pnet::packet::icmp::destination_unreachable::{DestinationUnreachablePacket, IcmpCodes};
use pnet::packet::icmp::{IcmpCode, IcmpTypes};
use pnet::packet::icmpv6::{Icmpv6Code, Icmpv6Packet, Icmpv6Types};
use pnet::packet::ip::IpNextHeaderProtocols;
use pnet::packet::udp::UdpPacket;
use tokio::sync::mpsc;
use crate::core::config::ProbeTuning;
use crate::core::models::deadline::{AdaptiveDeadline, AdaptiveDeadlineConfig};
use crate::core::models::host::{HostStatus, StatusProtocol, StatusReason};
use crate::core::models::port::{PortState, Protocol};
use crate::core::models::retry::{Due, ProbeLedger, RetryPolicy, SilentHostPolicy};
use crate::core::models::target::Target;
use crate::core::models::timer::ScanBudget;
use crate::core::session::{ScanContext, ScannerKind};
use crate::error;
use crate::network::capture::CapturedSegment;
use crate::network::frame;
use crate::network::probe::{ProbeKind, ProbeTransport};
use crate::scanner::PortScanner;
use crate::system::interface::SourceResolver;
use super::send_udp;
type ProbeTarget = (IpAddr, u16);
type Ledger = ProbeLedger<ProbeTarget, ()>;
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: usize = 512;
const ICMPV6_PORT_UNREACHABLE: Icmpv6Code = Icmpv6Code(4);
const ICMPV6_ADMIN_PROHIBITED: Icmpv6Code = Icmpv6Code(1);
const ICMPV6_INGRESS_EGRESS_POLICY: Icmpv6Code = Icmpv6Code(5);
const ICMPV6_REJECT_ROUTE: Icmpv6Code = Icmpv6Code(6);
const ICMPV6_NO_ROUTE: Icmpv6Code = Icmpv6Code(0);
const ICMPV6_ADDR_UNREACHABLE: Icmpv6Code = Icmpv6Code(3);
const ICMPV6_UNUSED_LEN: usize = 4;
pub struct UdpPortScanner {
resolver: SourceResolver,
ctx: ScanContext,
transport: ProbeTransport,
deadline: AdaptiveDeadline,
ledger: Ledger,
due: Vec<Due<ProbeTarget>>,
src_port: u16,
}
impl UdpPortScanner {
pub fn new(
resolver: SourceResolver,
ctx: ScanContext,
target_count: usize,
tuning: ProbeTuning,
) -> anyhow::Result<Self> {
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),
))
}
#[cfg(any(test, feature = "test-support"))]
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,
)
}
fn build(
resolver: SourceResolver,
ctx: ScanContext,
transport: ProbeTransport,
target_count: usize,
src_port: u16,
retry: RetryPolicy,
) -> Self {
let deadline_config = DEADLINE_CONFIG.allowing_for(retry.worst_case_probe_lifetime());
Self {
resolver,
ctx,
transport,
deadline: AdaptiveDeadline::new(deadline_config, target_count),
ledger: Ledger::new(retry, target_count.min(MAX_IN_FLIGHT)),
due: Vec::new(),
src_port,
}
}
fn send_probe(&mut self, target: Target) {
if target.protocol != Protocol::Udp {
return;
}
self.probe(target.ip, target.port, Instant::now());
}
fn probe(&mut self, ip: IpAddr, port: u16, now: Instant) {
let Some(src_addr) = self.resolver.resolve(ip) else {
error!(
verbosity = 2,
"No route to {ip}; skipping UDP probe to {ip}:{port}"
);
return;
};
if send_udp(
self.transport.tx.as_ref(),
self.src_port,
src_addr,
ip,
port,
)
.is_some()
{
self.ledger.arm(ip, (ip, port), (), now);
}
}
fn handle_reply(&mut self, reply: &CapturedSegment, now: Instant) {
let classified = match reply.protocol {
IpNextHeaderProtocols::Udp => answering_probe(&reply.bytes, self.src_port)
.map(|port| ((reply.source, port), Verdict::Port(PortState::Open))),
IpNextHeaderProtocols::Icmp => quoted_by_icmpv4(&reply.bytes, self.src_port),
IpNextHeaderProtocols::Icmpv6 => quoted_by_icmpv6(&reply.bytes, self.src_port),
_ => None,
};
match classified {
Some((target, Verdict::Port(state))) => {
self.resolve_probe(target, state, reply.source, now)
}
Some((target, Verdict::Host)) => self.record_host_down(target.0, reply.source),
None => {}
}
}
fn record_host_down(&mut self, ip: IpAddr, sender: IpAddr) {
self.ctx.update_host(ip, |host| {
host.record_evidence(
HostStatus::Down,
StatusReason::new(StatusProtocol::IcmpUnreachable, "destination unreachable")
.from_source(sender),
);
});
}
fn resolve_probe(
&mut self,
target: ProbeTarget,
state: PortState,
sender: IpAddr,
now: Instant,
) {
let Some(resolution) = self.ledger.resolve(&target, None, now) else {
return;
};
self.deadline.mark_activity();
if let Some(rtt) = resolution.rtt {
self.deadline.record_rtt(rtt);
}
self.record_port(target.0, target.1, state, Some(sender));
}
fn service_retries(&mut self, now: Instant) {
self.ledger.drain_due(now, &mut self.due);
let due = std::mem::take(&mut self.due);
for event in &due {
match *event {
Due::Retry {
key: (ip, port), ..
} => self.probe(ip, port, now),
Due::Exhausted((ip, port)) => {
self.record_port(ip, port, PortState::OpenFiltered, None)
}
}
}
self.due = due;
self.due.clear();
}
fn resolve_remaining_as_filtered(&mut self) {
for (ip, port) in self.ledger.drain_unresolved() {
self.record_port(ip, port, PortState::OpenFiltered, None);
}
}
fn tick_delay(&self, now: Instant) -> Duration {
let until_deadline_tick = self.deadline.time_until_next_tick();
match self.ledger.next_due() {
Some(due) => until_deadline_tick.min(due.saturating_duration_since(now)),
None => until_deadline_tick,
}
}
fn record_port(&mut self, ip: IpAddr, port_num: u16, state: PortState, sender: Option<IpAddr>) {
let port = crate::fingerprinting::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.ctx.update_host(ip, |host| {
host.add_port(port);
if let Some((status, reason)) = evidence {
host.record_evidence(status, reason);
}
});
}
}
fn answering_probe(bytes: &[u8], src_port: u16) -> Option<u16> {
let udp = UdpPacket::new(bytes)?;
if udp.get_destination() != src_port {
return None;
}
Some(udp.get_source())
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Verdict {
Port(PortState),
Host,
}
fn icmpv4_verdict(code: IcmpCode) -> Option<Verdict> {
match code {
IcmpCodes::DestinationPortUnreachable => Some(Verdict::Port(PortState::Closed)),
IcmpCodes::DestinationProtocolUnreachable
| IcmpCodes::NetworkAdministrativelyProhibited
| IcmpCodes::HostAdministrativelyProhibited
| IcmpCodes::CommunicationAdministrativelyProhibited => {
Some(Verdict::Port(PortState::Filtered))
}
IcmpCodes::DestinationHostUnreachable => Some(Verdict::Host),
_ => None,
}
}
fn icmpv6_verdict(code: Icmpv6Code) -> Option<Verdict> {
match code {
ICMPV6_PORT_UNREACHABLE => Some(Verdict::Port(PortState::Closed)),
ICMPV6_ADMIN_PROHIBITED | ICMPV6_INGRESS_EGRESS_POLICY | ICMPV6_REJECT_ROUTE => {
Some(Verdict::Port(PortState::Filtered))
}
ICMPV6_NO_ROUTE | ICMPV6_ADDR_UNREACHABLE => Some(Verdict::Host),
_ => None,
}
}
fn quoted_by_icmpv4(bytes: &[u8], src_port: u16) -> Option<(ProbeTarget, Verdict)> {
let unreachable = DestinationUnreachablePacket::new(bytes)?;
if unreachable.get_icmp_type() != IcmpTypes::DestinationUnreachable {
return None;
}
let verdict = icmpv4_verdict(unreachable.get_icmp_code())?;
Some((quoted_probe(unreachable.payload(), src_port)?, verdict))
}
fn quoted_by_icmpv6(bytes: &[u8], src_port: u16) -> Option<(ProbeTarget, Verdict)> {
let unreachable = Icmpv6Packet::new(bytes)?;
if unreachable.get_icmpv6_type() != Icmpv6Types::DestinationUnreachable {
return None;
}
let verdict = icmpv6_verdict(unreachable.get_icmpv6_code())?;
let quoted = unreachable.payload().get(ICMPV6_UNUSED_LEN..)?;
Some((quoted_probe(quoted, src_port)?, verdict))
}
fn quoted_probe(quoted_packet: &[u8], src_port: u16) -> Option<ProbeTarget> {
let quoted = frame::parse_ip_segment(quoted_packet)?;
if quoted.protocol != IpNextHeaderProtocols::Udp {
return None;
}
let udp = UdpPacket::new(quoted.payload)?;
if udp.get_source() != src_port {
return None;
}
Some((quoted.destination, udp.get_destination()))
}
#[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, mut targets: mpsc::Receiver<Target>) -> anyhow::Result<()> {
let mut sending_finished = false;
loop {
let now = Instant::now();
self.service_retries(now);
if self.ctx.handle.should_stop() || self.deadline.hard_deadline_passed() {
break;
}
if sending_finished && self.ledger.is_empty() {
break;
}
if self.ledger.is_empty() && self.deadline.has_expired() {
break;
}
let admitting = !sending_finished && self.ledger.len() < MAX_IN_FLIGHT;
let tick = self.tick_delay(now);
tokio::select! {
target = targets.recv(), if admitting => {
match target {
Some(target) => self.send_probe(target),
None => sending_finished = true,
}
}
res = self.transport.rx.recv() => {
match res {
Some(reply) => self.handle_reply(&reply, Instant::now()),
None => break,
}
}
_ = tokio::time::sleep(tick) => {}
}
}
self.resolve_remaining_as_filtered();
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::{Ipv4Addr, Ipv6Addr};
use pnet::ipnetwork::{IpNetwork, Ipv4Network, Ipv6Network};
use pnet::packet::icmp::IcmpCode;
use pnet::packet::icmp::destination_unreachable::MutableDestinationUnreachablePacket;
use pnet::packet::icmpv6::MutableIcmpv6Packet;
use crate::core::session::ScanSession;
use crate::network::probe::{MockSender, ProbeTransport};
use crate::protocols::{ip, udp};
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::network::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(Target {
ip,
port,
protocol: Protocol::Udp,
});
}
fn host_status(session: &ScanSession, ip: IpAddr) -> Option<HostStatus> {
session.store.get(&ip).map(|host| host.status())
}
fn port_state(session: &ScanSession, ip: IpAddr, port: u16) -> Option<PortState> {
session
.store
.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 {
source,
protocol,
bytes,
}
}
fn udp_reply(src_port: u16, dst_port: u16) -> CapturedSegment {
captured(
TARGET,
IpNextHeaderProtocols::Udp,
udp::create_packet(&TARGET, &LOCAL_V4, src_port, dst_port, vec![]).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).unwrap()
}
(IpAddr::V6(s), IpAddr::V6(d)) => {
ip::create_ipv6_header(s, d, len, IpNextHeaderProtocols::Udp).unwrap()
}
_ => 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 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.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.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.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.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.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
.store
.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.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.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.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(Icmpv6Code(0), TARGET_V6, SCAN_SRC_PORT, 53),
Instant::now(),
);
assert_eq!(port_state(&session, TARGET_V6, 53), None);
assert_eq!(scanner.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.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::network::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);
assert_eq!(
quoted_by_icmpv4(&reply.bytes, src_port),
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::network::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),
"a real reply must resolve to the port that sent it",
);
}
#[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.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.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.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.ledger.is_empty());
let idle = scanner.tick_delay(now);
probe(&mut scanner, TARGET, 53);
let busy = scanner.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_as_filtered();
assert_eq!(
port_state(&session, TARGET, 161),
Some(PortState::OpenFiltered)
);
assert!(scanner.ledger.is_empty());
}
#[test]
fn non_udp_targets_are_not_probed() {
let (mut scanner, _session) = scanner_with_mock();
scanner.send_probe(Target {
ip: TARGET,
port: 80,
protocol: Protocol::Tcp,
});
assert!(scanner.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);
}
}
}