use std::collections::{BTreeMap, BTreeSet};
use std::net::IpAddr;
use std::time::{Duration, Instant};
use pnet_packet::ip::IpNextHeaderProtocols;
use crate::model::host::IpProtocolState;
use crate::protocols::{icmp, sctp, tcp, udp};
use crate::report::ScannerKind;
use crate::scanner::session::ScanContext;
use crate::scanner::strategy::icmp_error::{self, Unreachable};
use crate::system::interface::SourceResolver;
use crate::transport::probe::{Emission, ProbeKind, ProbeTransport};
use crate::transport::raw::{self, TransportSenderHandle};
use crate::{counted, info};
const REPLY_WINDOW: Duration = Duration::from_secs(2);
pub const DEFAULT_PROTOCOLS: [u8; 13] = [1, 2, 4, 6, 17, 41, 47, 50, 51, 89, 103, 112, 132];
const SOURCE_PORT: u16 = 55_555;
const CLOSED_PORT: u16 = 54_321;
const ECHO_IDENTIFIER: u16 = 0x5A4F;
pub async fn probe(ctx: &ScanContext, targets: &[IpAddr], protocols: &BTreeSet<u8>) {
if targets.is_empty() || protocols.is_empty() {
return;
}
let Some((mut transport, senders)) = open(ctx, protocols) else {
return;
};
let mut resolver = SourceResolver::from_system();
info!(
"asking {} about {}",
counted(targets.len() as u128, "host", "hosts"),
counted(senders.len() as u128, "IP protocol", "IP protocols")
);
send_probes(ctx, targets, &senders, &mut resolver);
let probed: BTreeSet<IpAddr> = targets.iter().copied().collect();
let asked: BTreeSet<u8> = senders.keys().copied().collect();
collect_replies(ctx, &mut transport, &probed, &asked).await;
}
fn open(
ctx: &ScanContext,
protocols: &BTreeSet<u8>,
) -> Option<(ProbeTransport, BTreeMap<u8, TransportSenderHandle>)> {
let first = protocols.iter().copied().next()?;
let transport = match ProbeTransport::open_receiver(ProbeKind::IpProtocol { number: first }) {
Ok(transport) => transport,
Err(failure) => {
ctx.record_failure(
ScannerKind::Routed,
format!("no capture to hear IP protocol answers on: {failure}"),
);
return None;
}
};
let mut senders = BTreeMap::new();
for number in protocols.iter().copied() {
match raw::open_sender(raw::TransportType::IpProtocol(number)) {
Ok(handle) => {
senders.insert(number, handle);
}
Err(failure) => ctx.record_failure(
ScannerKind::Routed,
format!("no socket for IP protocol {number}, so it goes unasked: {failure:#}"),
),
}
}
if senders.is_empty() {
ctx.record_failure(
ScannerKind::Routed,
"no raw socket for any IP protocol asked about".to_string(),
);
return None;
}
Some((transport, senders))
}
fn send_probes(
ctx: &ScanContext,
targets: &[IpAddr],
senders: &BTreeMap<u8, TransportSenderHandle>,
resolver: &mut SourceResolver,
) {
for &host in targets {
let Some(source) = resolver.resolve(host) else {
continue;
};
for (&number, sender) in senders {
let payload = probe_payload(number, source, host);
let sent = sender
.send_to(Datagram(&payload), host, None, Emission::routed().hop_limit)
.is_ok();
let state = match sent {
true => IpProtocolState::OpenFiltered,
false => IpProtocolState::Unasked,
};
ctx.update_host(host, |host| {
host.record_ip_protocol(number, state);
});
}
}
}
fn probe_payload(number: u8, source: IpAddr, host: IpAddr) -> Vec<u8> {
let built = match (number, host) {
(1, IpAddr::V4(_)) | (58, IpAddr::V6(_)) => {
icmp::build_echo_request_message(source, host, 0, ECHO_IDENTIFIER, 0, &[])
}
(6, _) => tcp::build_probe(
crate::model::technique::TcpScanTechnique::Syn,
source,
host,
SOURCE_PORT,
CLOSED_PORT,
rand::random(),
),
(17, _) => udp::build_packet(source, host, SOURCE_PORT, CLOSED_PORT, Vec::new()),
(132, _) => Ok(sctp::build_init_probe(
SOURCE_PORT,
CLOSED_PORT,
rand::random(),
)),
_ => return Vec::new(),
};
built.unwrap_or_default()
}
async fn collect_replies(
ctx: &ScanContext,
transport: &mut ProbeTransport,
probed: &BTreeSet<IpAddr>,
asked: &BTreeSet<u8>,
) {
let deadline = Instant::now() + REPLY_WINDOW;
loop {
if ctx.handle.should_stop() {
return;
}
let remaining = deadline.saturating_duration_since(Instant::now());
if remaining.is_zero() {
return;
}
match tokio::time::timeout(remaining, transport.rx.recv()).await {
Ok(Some(reply)) => {
if let Some((host, number, state)) = matched(&reply, probed, asked) {
ctx.update_host(host, |host| {
host.record_ip_protocol(number, state);
});
}
}
Ok(None) | Err(_) => return,
}
}
}
fn matched(
reply: &crate::transport::capture::CapturedSegment,
probed: &BTreeSet<IpAddr>,
asked: &BTreeSet<u8>,
) -> Option<(IpAddr, u8, IpProtocolState)> {
if let Some(error) = icmp_error::parse(reply) {
let host = error.quoted.destination;
let number = error.quoted.protocol.0;
if !probed.contains(&host) || !asked.contains(&number) {
return None;
}
let state = match error.reason {
Unreachable::Protocol => IpProtocolState::Closed,
Unreachable::Port => IpProtocolState::Open,
Unreachable::Prohibited => IpProtocolState::Filtered,
Unreachable::Host => return None,
};
return Some((host, number, state));
}
let number = match reply.protocol {
IpNextHeaderProtocols::Icmp => 1,
IpNextHeaderProtocols::Icmpv6 => 58,
_ => return None,
};
if !probed.contains(&reply.source) || !asked.contains(&number) {
return None;
}
let over_ipv6 = number == 58;
match icmp::classify_echo_reply(&reply.bytes, ECHO_IDENTIFIER, over_ipv6) {
icmp::EchoReply::Ours { .. } => Some((reply.source, number, IpProtocolState::Open)),
_ => None,
}
}
struct Datagram<'a>(&'a [u8]);
impl pnet_packet::Packet for Datagram<'_> {
fn packet(&self) -> &[u8] {
self.0
}
fn payload(&self) -> &[u8] {
&[]
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::Ipv4Addr;
use pnet_packet::icmp::destination_unreachable::IcmpCodes;
use pnet_packet::icmp::destination_unreachable::MutableDestinationUnreachablePacket;
use pnet_packet::icmp::{IcmpCode, IcmpTypes};
use pnet_packet::ip::IpNextHeaderProtocol;
use crate::protocols::ip;
use crate::transport::capture::CapturedSegment;
const LOCAL: IpAddr = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 50));
const TARGET: IpAddr = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 200));
const STRANGER: IpAddr = IpAddr::V4(Ipv4Addr::new(198, 51, 100, 9));
fn asked(numbers: &[u8]) -> BTreeSet<u8> {
numbers.iter().copied().collect()
}
fn refusal(code: IcmpCode, host: IpAddr, number: u8) -> CapturedSegment {
let (IpAddr::V4(src), IpAddr::V4(dst)) = (LOCAL, host) else {
panic!("the fixture is IPv4");
};
let quoted = ip::build_ipv4_header(
src,
dst,
0,
IpNextHeaderProtocol(number),
ip::HOP_LIMIT_ROUTED,
)
.expect("a header");
let mut bytes =
vec![0u8; MutableDestinationUnreachablePacket::minimum_packet_size() + quoted.len()];
let mut message = MutableDestinationUnreachablePacket::new(&mut bytes).expect("a packet");
message.set_icmp_type(IcmpTypes::DestinationUnreachable);
message.set_icmp_code(code);
message.set_payload("ed);
CapturedSegment::synthetic(host, IpNextHeaderProtocols::Icmp, bytes)
}
fn verdict(reply: &CapturedSegment, named: &[u8]) -> Option<(IpAddr, u8, IpProtocolState)> {
matched(reply, &[TARGET].into_iter().collect(), &asked(named))
}
#[test]
fn each_message_settles_the_verdict_it_proves() {
let cases = [
(
IcmpCodes::DestinationProtocolUnreachable,
IpProtocolState::Closed,
),
(IcmpCodes::DestinationPortUnreachable, IpProtocolState::Open),
(
IcmpCodes::CommunicationAdministrativelyProhibited,
IpProtocolState::Filtered,
),
];
for (code, expected) in cases {
assert_eq!(
verdict(&refusal(code, TARGET, 47), &[47]),
Some((TARGET, 47, expected)),
"{code:?}"
);
}
}
#[test]
fn an_unreachable_address_settles_nothing_about_its_protocols() {
assert_eq!(
verdict(
&refusal(IcmpCodes::DestinationHostUnreachable, TARGET, 47),
&[47]
),
None
);
}
#[test]
fn a_message_this_pass_did_not_provoke_settles_nothing() {
assert_eq!(
verdict(
&refusal(IcmpCodes::DestinationProtocolUnreachable, STRANGER, 47),
&[47]
),
None,
"a host this pass never probed"
);
assert_eq!(
verdict(
&refusal(IcmpCodes::DestinationProtocolUnreachable, TARGET, 89),
&[47]
),
None,
"a protocol this pass never asked about"
);
}
#[test]
fn an_echo_reply_proves_icmp_only_when_it_is_this_passs_own() {
let ours = icmp::build_echo_request_message(TARGET, LOCAL, 0, ECHO_IDENTIFIER, 0, &[])
.expect("an echo message");
let mut ours = CapturedSegment::synthetic(TARGET, IpNextHeaderProtocols::Icmp, ours);
ours.bytes[0] = IcmpTypes::EchoReply.0;
assert_eq!(
verdict(&ours, &[1]),
Some((TARGET, 1, IpProtocolState::Open))
);
let theirs =
icmp::build_echo_request_message(TARGET, LOCAL, 0, ECHO_IDENTIFIER ^ 1, 0, &[])
.expect("an echo message");
let mut theirs = CapturedSegment::synthetic(TARGET, IpNextHeaderProtocols::Icmp, theirs);
theirs.bytes[0] = IcmpTypes::EchoReply.0;
assert_eq!(verdict(&theirs, &[1]), None, "somebody else's ping");
}
#[test]
fn a_header_is_built_only_where_it_could_change_the_answer() {
for number in [1, 6, 17, 132] {
assert!(
!probe_payload(number, LOCAL, TARGET).is_empty(),
"protocol {number} went out bare"
);
}
for number in [2, 4, 41, 47, 50, 51, 89, 103, 112] {
assert!(
probe_payload(number, LOCAL, TARGET).is_empty(),
"protocol {number} carried a header it has no use for"
);
}
}
#[test]
fn an_icmp_header_follows_its_own_family() {
assert!(!probe_payload(1, LOCAL, TARGET).is_empty(), "icmp over v4");
assert!(
probe_payload(58, LOCAL, TARGET).is_empty(),
"icmpv6 has no business in an IPv4 datagram"
);
}
#[test]
fn every_default_protocol_is_one_the_registry_names() {
for number in DEFAULT_PROTOCOLS {
assert!(
crate::model::host::ip_protocol_name(number).is_some(),
"protocol {number} is in the default set and has no name to print"
);
}
}
}