use std::collections::HashMap;
use std::net::IpAddr;
use std::time::Instant;
use async_trait::async_trait;
use pnet::packet::icmp::{IcmpPacket, IcmpTypes, destination_unreachable::IcmpCodes};
use pnet::packet::icmpv6::{Icmpv6Packet, Icmpv6Types};
use pnet::packet::udp::UdpPacket;
use tokio::sync::mpsc;
use crate::core::config::SendMode;
use crate::core::models::deadline::AdaptiveDeadline;
use crate::core::models::port::{PortState, Protocol};
use crate::core::models::target::Target;
use crate::core::session::{ScanContext, ScannerKind};
use crate::error;
use crate::network::probe::{ProbeKind, ProbeTransport};
use crate::scanner::{PortScanner, service};
use crate::system::interface::SourceResolver;
use super::{DEADLINE_CONFIG, send_udp};
type PendingProbes = HashMap<(IpAddr, u16), Instant>;
pub struct UdpPortScanner {
resolver: SourceResolver,
ctx: ScanContext,
transport: ProbeTransport,
deadline: AdaptiveDeadline,
pending: PendingProbes,
}
impl UdpPortScanner {
pub fn new(
resolver: SourceResolver,
ctx: ScanContext,
target_count: usize,
send_mode: SendMode,
) -> anyhow::Result<Self> {
let transport = ProbeTransport::open_with(ProbeKind::UdpProbe, send_mode)?;
let deadline = AdaptiveDeadline::new(DEADLINE_CONFIG, target_count);
Ok(Self {
resolver,
ctx,
transport,
deadline,
pending: PendingProbes::new(),
})
}
fn send_probe(&mut self, target: Target) {
if target.protocol != Protocol::Udp {
return;
}
let Some(src_addr) = self.resolver.resolve(target.ip) else {
error!(
verbosity = 2,
"No route to {}; skipping UDP probe to {}:{}", target.ip, target.ip, target.port
);
return;
};
if send_udp(self.transport.tx.as_ref(), src_addr, target.ip, target.port).is_some() {
self.pending
.insert((target.ip, target.port), Instant::now());
}
}
fn handle_reply(&mut self, ip: IpAddr, bytes: &[u8]) {
if let Some(udp) = UdpPacket::new(bytes) {
let src_port = udp.get_source();
let key = (ip, src_port);
if let Some(sent_at) = self.pending.remove(&key) {
self.deadline.mark_activity();
self.deadline.record_rtt(sent_at.elapsed());
self.record_port(ip, src_port, PortState::Open);
return;
}
}
if ip.is_ipv4() {
if let Some(icmp) = IcmpPacket::new(bytes)
&& icmp.get_icmp_type() == IcmpTypes::DestinationUnreachable
&& icmp.get_icmp_code() == IcmpCodes::DestinationPortUnreachable
{
let ports: Vec<u16> = self
.pending
.keys()
.filter(|(target_ip, _)| target_ip == &ip)
.map(|(_, p)| *p)
.collect();
for p in ports {
if let Some(sent_at) = self.pending.remove(&(ip, p)) {
self.deadline.mark_activity();
self.deadline.record_rtt(sent_at.elapsed());
self.record_port(ip, p, PortState::Closed);
}
}
}
} else if ip.is_ipv6()
&& let Some(icmp) = Icmpv6Packet::new(bytes)
&& icmp.get_icmpv6_type() == Icmpv6Types::DestinationUnreachable
{
let ports: Vec<u16> = self
.pending
.keys()
.filter(|(target_ip, _)| target_ip == &ip)
.map(|(_, p)| *p)
.collect();
for p in ports {
if let Some(sent_at) = self.pending.remove(&(ip, p)) {
self.deadline.mark_activity();
self.deadline.record_rtt(sent_at.elapsed());
self.record_port(ip, p, PortState::Closed);
}
}
}
}
fn resolve_remaining_as_filtered(&mut self) {
let remaining: Vec<(IpAddr, u16)> = self.pending.drain().map(|(key, _)| key).collect();
for (ip, port) in remaining {
self.record_port(ip, port, PortState::OpenFiltered);
}
}
fn record_port(&mut self, ip: IpAddr, port_num: u16, state: PortState) {
let port = crate::fingerprinting::baseline_port(port_num, Protocol::Udp, state);
self.ctx.update_host(ip, |host| host.add_port(port));
}
}
#[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 {
if self.ctx.handle.should_stop() || self.deadline.has_expired() {
break;
}
if sending_finished && self.pending.is_empty() {
break;
}
tokio::select! {
target = targets.recv(), if !sending_finished => {
match target {
Some(target) => self.send_probe(target),
None => sending_finished = true,
}
}
res = self.transport.rx.recv() => {
match res {
Some((bytes, ip)) => self.handle_reply(ip, &bytes),
None => break,
}
}
_ = tokio::time::sleep(self.deadline.time_until_next_tick()) => {}
}
}
self.resolve_remaining_as_filtered();
Ok(())
}
async fn detect_services(&mut self, ctx: &ScanContext) {
service::detect(ctx).await;
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::Ipv4Addr;
use pnet::ipnetwork::{IpNetwork, Ipv4Network};
use pnet::packet::icmp::{IcmpTypes, MutableIcmpPacket, destination_unreachable::IcmpCodes};
use pnet::packet::udp::MutableUdpPacket;
use crate::core::session::ScanSession;
use crate::network::capture::CaptureGuard;
use crate::network::probe::{MockSender, ProbeTransport};
const TARGET: IpAddr = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 200));
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(),
)],
flags: 0,
}
}
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,
CaptureGuard::noop(),
);
let resolver = SourceResolver::from_interfaces(&[on_link_interface()]);
let scanner = UdpPortScanner {
resolver,
ctx,
transport,
deadline: AdaptiveDeadline::new(DEADLINE_CONFIG, 8),
pending: PendingProbes::new(),
};
(scanner, session)
}
fn probe(scanner: &mut UdpPortScanner, port: u16) {
scanner.send_probe(Target {
ip: TARGET,
port,
protocol: Protocol::Udp,
});
}
fn port_state(session: &ScanSession, port: u16) -> Option<PortState> {
session
.store
.get(&TARGET)
.and_then(|h| h.ports().find(|p| p.number() == port).map(|p| p.state()))
}
fn udp_reply(src_port: u16) -> Vec<u8> {
let mut buf = vec![0u8; 8];
let mut udp = MutableUdpPacket::new(&mut buf).unwrap();
udp.set_source(src_port);
udp.set_destination(40_000);
udp.set_length(8);
buf
}
fn icmp_unreachable() -> Vec<u8> {
let mut buf = vec![0u8; 8];
let mut icmp = MutableIcmpPacket::new(&mut buf).unwrap();
icmp.set_icmp_type(IcmpTypes::DestinationUnreachable);
icmp.set_icmp_code(IcmpCodes::DestinationPortUnreachable);
buf
}
#[test]
fn direct_udp_reply_is_open() {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, 53);
scanner.handle_reply(TARGET, &udp_reply(53));
assert_eq!(port_state(&session, 53), Some(PortState::Open));
assert!(scanner.pending.is_empty());
}
#[test]
fn icmp_port_unreachable_is_closed() {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, 53);
scanner.handle_reply(TARGET, &icmp_unreachable());
assert_eq!(port_state(&session, 53), Some(PortState::Closed));
assert!(scanner.pending.is_empty());
}
#[test]
fn unanswered_probes_resolve_as_filtered() {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, 161);
scanner.resolve_remaining_as_filtered();
assert_eq!(port_state(&session, 161), Some(PortState::OpenFiltered));
assert!(scanner.pending.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.pending.is_empty());
}
}