use std::collections::HashMap;
use std::net::IpAddr;
use std::sync::Arc;
use std::time::{Duration, Instant};
use dashmap::DashMap;
use pnet_packet::ip::IpNextHeaderProtocols;
use pnet_packet::tcp::TcpPacket;
use crate::counted;
use crate::model::host::path::Hop;
use crate::model::port::{PortState, Protocol};
use crate::protocols::{icmp, tcp};
use crate::report::ScannerKind;
use crate::scanner::session::ScanContext;
use crate::system::interface::SourceResolver;
use crate::transport::capture::CapturedSegment;
use crate::transport::frame::IpSegment;
use crate::transport::probe::{Emission, ProbeKind, ProbeTransport};
use crate::{info, warn};
use crate::scanner::strategy::icmp_error;
pub const MAX_HOPS: u8 = 30;
const ROUND_TIMEOUT: Duration = Duration::from_millis(1500);
const ATTEMPTS: u8 = 3;
const MAX_IN_FLIGHT: usize = 16;
#[derive(Debug, Clone, Default)]
pub struct PathCache {
known: Arc<DashMap<Waypoint, Arc<[Hop]>>>,
}
type Waypoint = (u8, IpAddr);
impl PathCache {
pub fn new() -> Self {
Self::default()
}
fn prefix_of(&self, distance: u8, address: IpAddr) -> Option<Vec<Hop>> {
let prefix = self.known.get(&(distance, address))?;
Some(prefix.iter().map(|hop| hop.as_inferred()).collect())
}
fn remember(&self, hops: &[Hop]) {
for (index, hop) in hops.iter().enumerate() {
let Some(address) = hop.address() else {
continue;
};
let prefix: Arc<[Hop]> = hops[..index].into();
self.known.insert((hop.distance(), address), prefix);
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
enum TraceProbe {
Syn { port: u16 },
Echo,
}
impl TraceProbe {
fn probe_kind(self, marker: u16) -> ProbeKind {
match self {
TraceProbe::Syn { .. } => ProbeKind::TcpProbe {
reply_port: marker,
icmp_errors: true,
},
TraceProbe::Echo => ProbeKind::IcmpEcho { identifier: marker },
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
struct Sent {
target: IpAddr,
distance: u8,
}
struct Tracer {
ctx: ScanContext,
transport: ProbeTransport,
probe: TraceProbe,
cache: PathCache,
marker: u16,
resolver: SourceResolver,
in_flight: HashMap<Sent, Instant>,
sent: u64,
failed: u64,
answered: u64,
}
impl Tracer {
fn new(
ctx: ScanContext,
transport: ProbeTransport,
probe: TraceProbe,
marker: u16,
cache: PathCache,
) -> Self {
Self {
ctx,
transport,
probe,
cache,
marker,
resolver: SourceResolver::from_system(),
in_flight: HashMap::new(),
sent: 0,
failed: 0,
answered: 0,
}
}
fn send(&mut self, target: IpAddr, distance: u8, source: IpAddr) -> bool {
let segment = match self.probe {
TraceProbe::Syn { port } => {
let sequence = (u32::from(self.marker) << 8) | u32::from(distance);
match tcp::build_probe(
crate::model::technique::TcpScanTechnique::Syn,
source,
target,
self.marker,
port,
sequence,
) {
Ok(segment) => segment,
Err(error) => {
warn!(
verbosity = 2,
"could not build a trace probe for {target}: {error}"
);
return false;
}
}
}
TraceProbe::Echo => {
match icmp::build_echo_request_message(
source,
target,
icmp::ECHO_PROBE_CODE,
self.marker,
u16::from(distance),
&[],
) {
Ok(message) => message,
Err(error) => {
warn!(
verbosity = 2,
"could not build a trace probe for {target}: {error}"
);
return false;
}
}
}
};
match self
.transport
.tx
.send(&segment, source, target, None, Emission::at_hop(distance))
{
Ok(()) => {
self.in_flight
.insert(Sent { target, distance }, Instant::now());
self.sent += 1;
true
}
Err(error) => {
warn!(
verbosity = 2,
"trace probe to {target} was not sent: {error:#}"
);
self.failed += 1;
false
}
}
}
async fn collect(&mut self, deadline: Instant, mut on_reply: impl FnMut(&mut Self, Reply)) {
while !self.in_flight.is_empty() {
let now = Instant::now();
if now >= deadline || self.ctx.handle.should_stop() {
return;
}
let next = tokio::time::timeout(deadline - now, self.transport.rx.recv()).await;
let Ok(Some(segment)) = next else {
return;
};
if let Some(reply) = self.classify(&segment) {
self.answered += 1;
on_reply(self, reply);
}
}
}
fn classify(&mut self, segment: &CapturedSegment) -> Option<Reply> {
if let Some(expired) = icmp_error::parse_expired(segment) {
let sent = self.attribute(&expired.quoted)?;
let rtt = self.in_flight.remove(&sent).map(|at| at.elapsed());
return Some(Reply::Expired {
sent,
router: segment.source,
rtt,
});
}
let arrived = segment.observation.as_ref()?.remaining_hops();
let answered = self.answered_distance(segment)?;
self.in_flight.remove(&Sent {
target: segment.source,
distance: answered,
});
Some(Reply::Arrived {
target: segment.source,
probed: answered,
implied: distance_from(arrived),
})
}
fn answered_distance(&self, segment: &CapturedSegment) -> Option<u8> {
match self.probe {
TraceProbe::Syn { .. } => {
if segment.protocol != IpNextHeaderProtocols::Tcp {
return None;
}
let reply = TcpPacket::new(&segment.bytes)?;
if reply.get_destination() != self.marker {
return None;
}
let echoed = reply.get_acknowledgement().checked_sub(1)?;
if (echoed >> 8) != u32::from(self.marker) {
return None;
}
Some((echoed & 0xff) as u8)
}
TraceProbe::Echo => {
let over_ipv6 = match segment.protocol {
IpNextHeaderProtocols::Icmp => false,
IpNextHeaderProtocols::Icmpv6 => true,
_ => return None,
};
match icmp::classify_echo_reply(&segment.bytes, self.marker, over_ipv6) {
icmp::EchoReply::Ours { sequence } => u8::try_from(sequence).ok(),
_ => None,
}
}
}
}
fn attribute(&self, quoted: &IpSegment<'_>) -> Option<Sent> {
attribute(self.probe, self.marker, quoted)
}
}
fn attribute(probe: TraceProbe, marker: u16, quoted: &IpSegment<'_>) -> Option<Sent> {
let head: [u8; 8] = quoted.payload.get(..8)?.try_into().ok()?;
let distance = match (probe, quoted.protocol) {
(TraceProbe::Syn { .. }, IpNextHeaderProtocols::Tcp) => {
if u16::from_be_bytes([head[0], head[1]]) != marker {
return None;
}
let sequence = u32::from_be_bytes([head[4], head[5], head[6], head[7]]);
if (sequence >> 8) != u32::from(marker) {
return None;
}
(sequence & 0xff) as u8
}
(TraceProbe::Echo, IpNextHeaderProtocols::Icmp | IpNextHeaderProtocols::Icmpv6) => {
if u16::from_be_bytes([head[4], head[5]]) != marker {
return None;
}
u8::try_from(u16::from_be_bytes([head[6], head[7]])).ok()?
}
_ => return None,
};
Some(Sent {
target: quoted.destination,
distance,
})
}
enum Landing {
Router(IpAddr, Option<Duration>),
Target,
Silent,
}
enum Reply {
Expired {
sent: Sent,
router: IpAddr,
rtt: Option<Duration>,
},
Arrived {
target: IpAddr,
probed: u8,
implied: u8,
},
}
fn distance_from(arrived: u8) -> u8 {
const COMMON: [u8; 4] = [32, 64, 128, 255];
let started = COMMON
.into_iter()
.find(|start| *start >= arrived)
.unwrap_or(u8::MAX);
started.saturating_sub(arrived)
}
fn probe_for(ctx: &ScanContext, target: &IpAddr) -> TraceProbe {
let port = ctx.read_host(target, |host| {
host.ports()
.filter(|port| port.protocol() == Protocol::Tcp && port.state() == PortState::Open)
.map(crate::model::port::Port::number)
.min()
});
match port.flatten() {
Some(port) => TraceProbe::Syn { port },
None => TraceProbe::Echo,
}
}
pub async fn trace(ctx: &ScanContext, targets: Vec<IpAddr>) {
if targets.is_empty() {
return;
}
let cache = PathCache::new();
let mut groups: HashMap<TraceProbe, Vec<IpAddr>> = HashMap::new();
for target in targets {
groups
.entry(probe_for(ctx, &target))
.or_default()
.push(target);
}
for (probe, group) in groups {
if ctx.handle.should_stop() {
return;
}
let marker: u16 = rand::random_range(33_000..60_000);
let transport = match ProbeTransport::open(probe.probe_kind(marker)) {
Ok(transport) => transport,
Err(error) => {
ctx.record_failure(
ScannerKind::Routed,
format!("no transport to trace with: {error}"),
);
return;
}
};
let mut tracer = Tracer::new(ctx.clone(), transport, probe, marker, cache.clone());
tracer.run(group).await;
}
}
impl Tracer {
async fn run(&mut self, group: Vec<IpAddr>) {
let distances = self.measure_distances(&group).await;
for (target, distance) in distances {
if self.ctx.handle.should_stop() {
break;
}
if self.ctx.host_expired(target) {
continue;
}
self.walk(target, distance).await;
}
if self.sent == 0 && self.failed > 0 {
warn!(
"traceroute could not put any of its {} probes on the wire; no path was measured",
self.failed
);
} else if self.sent > 0 && self.answered == 0 {
warn!(
"traceroute heard nothing back from {} probes; no path was measured",
self.sent
);
} else {
info!(
verbosity = 3,
"traceroute: {} probes sent ({} refused), {} answered",
self.sent,
self.failed,
self.answered
);
}
}
async fn measure_distances(&mut self, group: &[IpAddr]) -> Vec<(IpAddr, u8)> {
let mut found: Vec<(IpAddr, u8)> = Vec::new();
let mut unknown: Vec<IpAddr> = Vec::new();
for target in group {
match self
.ctx
.read_host(target, |host| host.telemetry().hop_counter())
.flatten()
{
Some(arrived) => {
let distance = distance_from(arrived);
info!(
verbosity = 2,
"{target} is about {} away, from the hop counter of {arrived} \
its reply arrived with",
counted(u128::from(distance), "hop", "hops")
);
found.push((*target, distance));
}
None => unknown.push(*target),
}
}
found.extend(self.probe_for_distances(&unknown).await);
found
}
async fn probe_for_distances(&mut self, group: &[IpAddr]) -> Vec<(IpAddr, u8)> {
let mut found: Vec<(IpAddr, u8)> = Vec::new();
for window in group.chunks(MAX_IN_FLIGHT) {
if self.ctx.handle.should_stop() {
break;
}
for target in window {
let Some(source) = self.resolver.resolve(*target) else {
warn!(
verbosity = 2,
"no source address to trace {target} from; skipping it"
);
continue;
};
for _ in 0..ATTEMPTS {
self.send(*target, MAX_HOPS, source);
}
}
let deadline = Instant::now() + ROUND_TIMEOUT;
let mut reached: Vec<(IpAddr, u8)> = Vec::new();
self.collect(deadline, |_, reply| match reply {
Reply::Arrived {
target,
probed: MAX_HOPS,
implied,
} if window.contains(&target)
&& !reached.iter().any(|(host, _)| *host == target) =>
{
reached.push((target, implied));
}
_ => {}
})
.await;
found.extend(reached);
self.in_flight.clear();
}
found
}
async fn probe_distance(&mut self, target: IpAddr, at: u8, source: IpAddr) -> Landing {
for _ in 0..ATTEMPTS {
self.send(target, at, source);
}
let deadline = Instant::now() + ROUND_TIMEOUT;
let mut landing = Landing::Silent;
let attempted = self.sent;
self.collect(deadline, |_, reply| match reply {
Reply::Expired {
sent,
router: from,
rtt,
} if sent.target == target && sent.distance == at => {
landing = Landing::Router(from, rtt);
}
Reply::Arrived {
target: who,
probed,
..
} if who == target && probed == at => {
landing = Landing::Target;
}
_ => {}
})
.await;
self.in_flight.clear();
info!(
verbosity = 2,
"trace {target} at hop {at}: {} ({} sent)",
match landing {
Landing::Router(address, _) => format!("router {address}"),
Landing::Target => "the target itself".to_string(),
Landing::Silent => "nothing answered".to_string(),
},
counted((self.sent - attempted) as u128, "probe", "probes")
);
landing
}
async fn walk(&mut self, target: IpAddr, estimate: u8) {
let Some(source) = self.resolver.resolve(target) else {
return;
};
let mut measured: Vec<Hop> = Vec::new();
let mut spliced: Option<Vec<Hop>> = None;
let mut reached = estimate.max(1);
while reached <= MAX_HOPS {
if self.ctx.handle.should_stop() {
return;
}
match self.probe_distance(target, reached, source).await {
Landing::Target => break,
Landing::Router(address, rtt) => {
measured.push(Hop::answered(reached, address, rtt));
}
Landing::Silent => measured.push(Hop::silent(reached)),
}
reached += 1;
}
let target_hop = (reached <= MAX_HOPS).then_some(reached);
let known: Vec<u8> = measured.iter().map(Hop::distance).collect();
let mut at = target_hop.unwrap_or(reached).saturating_sub(1);
let mut far_end = target_hop;
while at >= 1 {
if self.ctx.handle.should_stop() {
break;
}
if known.contains(&at) {
at -= 1;
continue;
}
match self.probe_distance(target, at, source).await {
Landing::Target => far_end = Some(at),
Landing::Router(address, rtt) => {
measured.push(Hop::answered(at, address, rtt));
if let Some(prefix) = self.cache.prefix_of(at, address) {
spliced = Some(prefix);
break;
}
}
Landing::Silent => measured.push(Hop::silent(at)),
}
at -= 1;
}
let mut hops: Vec<Hop> = Vec::new();
if let Some(distance) = far_end {
hops.push(Hop::answered(distance, target, None));
}
if let Some(prefix) = spliced {
hops.extend(prefix);
}
hops.extend(
measured
.into_iter()
.filter(|hop| far_end.is_none_or(|distance| hop.distance() < distance)),
);
hops.sort_by_key(Hop::distance);
if hops.is_empty() {
return;
}
self.cache.remember(&hops);
self.ctx.update_host(target, |host| {
for hop in &hops {
host.record_hop(*hop);
}
});
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::Ipv4Addr;
use tokio::sync::mpsc;
use crate::model::capture::{IpObservation, Ipv4Observation};
use crate::model::exclusion::Exclusions;
use crate::protocols::craft;
use crate::scanner::session::ScanSession;
use crate::transport::probe::{MockSender, ProbeSender, SendError};
fn ip(last: u8) -> IpAddr {
IpAddr::V4(Ipv4Addr::new(192, 0, 2, last))
}
struct Network {
distance: u8,
reply_ttl: u8,
silent: Vec<u8>,
replies: mpsc::Sender<CapturedSegment>,
}
fn syn_ack_to(probe: &[u8]) -> Vec<u8> {
use pnet_packet::tcp::{MutableTcpPacket, TcpFlags};
let sent = TcpPacket::new(probe).expect("the probe is a TCP segment");
let mut bytes = vec![0u8; 20];
let mut reply = MutableTcpPacket::new(&mut bytes).expect("20 bytes is a header");
reply.set_source(sent.get_destination());
reply.set_destination(sent.get_source());
reply.set_acknowledgement(sent.get_sequence().wrapping_add(1));
reply.set_flags(TcpFlags::SYN | TcpFlags::ACK);
reply.set_data_offset(5);
bytes
}
fn router_at(distance: u8) -> IpAddr {
IpAddr::V4(Ipv4Addr::new(198, 51, 100, distance))
}
impl Network {
fn observed(
source: IpAddr,
protocol: pnet_packet::ip::IpNextHeaderProtocol,
bytes: Vec<u8>,
ttl: u8,
) -> CapturedSegment {
CapturedSegment {
received_at: Instant::now(),
source,
destination: None,
protocol,
bytes,
observation: Some(IpObservation::V4(Ipv4Observation {
ttl,
identification: 0,
dont_fragment: false,
more_fragments: false,
dscp: 0,
ecn: 0,
})),
source_mac: None,
}
}
}
impl ProbeSender for Network {
fn send(
&self,
segment: &[u8],
src: IpAddr,
dst: IpAddr,
_zone: Option<u32>,
emission: Emission,
) -> Result<(), SendError> {
if emission.hop_limit >= self.distance {
let reply = Network::observed(
dst,
IpNextHeaderProtocols::Tcp,
syn_ack_to(segment),
self.reply_ttl,
);
let _ = self.replies.try_send(reply);
return Ok(());
}
if self.silent.contains(&emission.hop_limit) {
return Ok(());
}
let quoted = {
let (IpAddr::V4(s), IpAddr::V4(d)) = (src, dst) else {
unreachable!("the fixture is IPv4")
};
let header = crate::protocols::ip::build_ipv4_header(
s,
d,
segment.len() as u16,
IpNextHeaderProtocols::Tcp,
emission.hop_limit,
)
.expect("a header builds");
header
.into_iter()
.chain(segment.iter().copied())
.collect::<Vec<u8>>()
};
let mut bytes = vec![0u8; 8];
bytes[0] = pnet_packet::icmp::IcmpTypes::TimeExceeded.0;
bytes.extend_from_slice("ed);
let _ = self.replies.try_send(Network::observed(
router_at(emission.hop_limit),
IpNextHeaderProtocols::Icmp,
bytes,
255,
));
Ok(())
}
}
fn tracer_against(network: Network) -> (ScanContext, Tracer) {
tracer_under(network, Exclusions::none())
}
fn tracer_under(network: Network, exclusions: Exclusions) -> (ScanContext, Tracer) {
let (_session, ctx) = ScanSession::builder().excluding(exclusions).build();
let (tx, rx) = mpsc::channel(1024);
let network = Network {
replies: tx,
..network
};
let transport = ProbeTransport::from_parts(Box::new(network), rx);
let tracer = Tracer::new(
ctx.clone(),
transport,
TraceProbe::Syn { port: 443 },
41_234,
PathCache::new(),
);
(ctx, tracer)
}
#[tokio::test(flavor = "current_thread")]
async fn a_trace_records_every_router_between_here_and_the_target() {
let target = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 9));
let (ctx, mut tracer) = tracer_against(Network {
distance: 4,
reply_ttl: 60,
silent: vec![2],
replies: mpsc::channel(1024).0,
});
tracer.run(vec![target]).await;
let path = ctx
.read_host(target, |host| host.path().clone())
.expect("the target was recorded");
let seen: Vec<(u8, Option<IpAddr>)> = path
.hops()
.iter()
.map(|hop| (hop.distance(), hop.address()))
.collect();
assert_eq!(
seen,
vec![
(1, Some(router_at(1))),
(2, None),
(3, Some(router_at(3))),
(4, Some(target)),
],
"every distance is accounted for, including the router that stayed quiet"
);
}
#[tokio::test(flavor = "current_thread")]
async fn an_excluded_router_is_withheld_whether_measured_or_spliced() {
let first = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 9));
let second = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 10));
let mut forbidden = crate::model::ip::set::IpSet::new();
forbidden.insert(router_at(2));
let (ctx, mut tracer) = tracer_under(
Network {
distance: 4,
reply_ttl: 60,
silent: vec![],
replies: mpsc::channel(1024).0,
},
Exclusions::new(forbidden),
);
tracer.run(vec![first, second]).await;
for (target, spliced) in [(first, false), (second, true)] {
let path = ctx
.read_host(target, |host| host.path().clone())
.expect("the target was recorded");
assert!(
path.hops()
.iter()
.all(|hop| hop.address() != Some(router_at(2))),
"{target}: {path:?}"
);
let at_two = path.hops()[1];
assert_eq!(at_two.distance(), 2, "{target}: {path:?}");
assert!(at_two.is_withheld(), "{target}: {path:?}");
assert_eq!(
at_two.inferred(),
spliced,
"{target}: the splice happened, and stays marked: {path:?}"
);
assert_eq!(path.at(3), Some(router_at(3)), "{target}: {path:?}");
assert_eq!(path.length(), Some(4));
}
}
async fn trace_across(network: Network, target: IpAddr) -> Vec<(u8, Option<IpAddr>)> {
let seed = network.reply_ttl;
let (ctx, mut tracer) = tracer_against(network);
ctx.update_host(target, |host| host.record_hop_counter(seed));
tracer.run(vec![target]).await;
ctx.read_host(target, |host| {
host.path()
.hops()
.iter()
.map(|hop| (hop.distance(), hop.address()))
.collect()
})
.unwrap_or_default()
}
#[tokio::test(flavor = "current_thread")]
async fn a_target_further_out_than_its_replies_suggest_is_still_reached() {
let target = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 9));
let seen = trace_across(
Network {
distance: 7,
reply_ttl: 59,
silent: vec![2],
replies: mpsc::channel(1024).0,
},
target,
)
.await;
assert_eq!(
seen.last(),
Some(&(7, Some(target))),
"the target sits where it actually is, not where its replies implied"
);
assert_eq!(seen.len(), 7, "every distance out to it is accounted for");
assert_eq!(
seen[4],
(5, Some(router_at(5))),
"the hops past the estimate"
);
assert_eq!(seen[5], (6, Some(router_at(6))));
}
#[tokio::test(flavor = "current_thread")]
async fn a_target_nearer_than_its_replies_suggest_is_not_reported_far_away() {
let target = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 9));
let seen = trace_across(
Network {
distance: 5,
reply_ttl: 56,
silent: vec![],
replies: mpsc::channel(1024).0,
},
target,
)
.await;
assert_eq!(seen.last(), Some(&(5, Some(target))));
assert_eq!(seen.len(), 5, "nothing is recorded past the target");
}
#[tokio::test(flavor = "current_thread")]
async fn a_path_of_silent_routers_keeps_its_length() {
let target = IpAddr::V4(Ipv4Addr::new(203, 0, 113, 9));
let seen = trace_across(
Network {
distance: 6,
reply_ttl: 58,
silent: (1..=6).collect(),
replies: mpsc::channel(1024).0,
},
target,
)
.await;
assert_eq!(
seen.last(),
Some(&(6, Some(target))),
"the target stays where its own answers put it"
);
assert_eq!(seen.len(), 6, "every silent distance holds its place");
assert!(
seen[..5].iter().all(|(_, address)| address.is_none()),
"the routers that said nothing are recorded as having said nothing: {seen:?}"
);
}
const LOCAL: Ipv4Addr = Ipv4Addr::new(192, 0, 2, 50);
const TARGET: Ipv4Addr = Ipv4Addr::new(192, 0, 2, 9);
const OTHER_TARGET: Ipv4Addr = Ipv4Addr::new(192, 0, 2, 10);
const STRANGER: Ipv4Addr = Ipv4Addr::new(198, 51, 100, 77);
const MARKER: u16 = 41_234;
fn echo_tracer() -> (Tracer, mpsc::Sender<CapturedSegment>) {
use crate::system::interface::{Link, LinkAddress};
let (_session, ctx) = ScanSession::new();
let (replies, rx) = mpsc::channel(16);
let transport = ProbeTransport::from_parts(Box::new(MockSender::default()), rx);
let mut tracer = Tracer::new(ctx, transport, TraceProbe::Echo, MARKER, PathCache::new());
tracer.resolver = SourceResolver::from_links(&[
Link::new("test0", 0).with_addresses(vec![LinkAddress::new(LOCAL.into(), 24)])
]);
(tracer, replies)
}
fn captured_echo(message: &craft::Icmpv4, source: Ipv4Addr, ttl: u8) -> CapturedSegment {
Network::observed(
source.into(),
IpNextHeaderProtocols::Icmp,
message.to_bytes(),
ttl,
)
}
#[test]
fn an_echo_request_is_not_an_answer_to_an_echo_trace() {
let (mut tracer, _replies) = echo_tracer();
let sequence = u16::from(MAX_HOPS);
let request = craft::Icmpv4::echo_request(MARKER, sequence);
assert!(
tracer
.classify(&captured_echo(&request, LOCAL, MAX_HOPS))
.is_none(),
"the trace's own request was read as an answer"
);
let reply = craft::Icmpv4::echo_reply(MARKER, sequence);
assert!(
matches!(
tracer.classify(&captured_echo(&reply, TARGET, 60)),
Some(Reply::Arrived { target, probed: MAX_HOPS, .. }) if target == IpAddr::from(TARGET)
),
"and the reply it draws still is one"
);
}
#[tokio::test(flavor = "current_thread")]
async fn the_distance_round_keeps_one_answer_from_each_host_it_asked() {
let (mut tracer, replies) = echo_tracer();
let sequence = u16::from(MAX_HOPS);
let request = craft::Icmpv4::echo_request(MARKER, sequence);
let reply = craft::Icmpv4::echo_reply(MARKER, sequence);
for segment in [
captured_echo(&request, LOCAL, MAX_HOPS),
captured_echo(&reply, STRANGER, 60),
captured_echo(&reply, TARGET, 60),
captured_echo(&reply, TARGET, 60),
captured_echo(&reply, OTHER_TARGET, 60),
] {
replies.try_send(segment).expect("room in the channel");
}
let found = tracer
.probe_for_distances(&[TARGET.into(), OTHER_TARGET.into()])
.await;
assert_eq!(
found,
vec![(IpAddr::from(TARGET), 4), (IpAddr::from(OTHER_TARGET), 4)]
);
}
fn quoted_probe(probe: TraceProbe, marker: u16, target: IpAddr, distance: u8) -> Vec<u8> {
let source = ip(200);
let (segment, protocol) = match probe {
TraceProbe::Syn { port } => (
tcp::build_probe(
crate::model::technique::TcpScanTechnique::Syn,
source,
target,
marker,
port,
(u32::from(marker) << 8) | u32::from(distance),
)
.expect("a probe builds"),
IpNextHeaderProtocols::Tcp,
),
TraceProbe::Echo => (
icmp::build_echo_request_message(
source,
target,
icmp::ECHO_PROBE_CODE,
marker,
u16::from(distance),
&[],
)
.expect("a probe builds"),
IpNextHeaderProtocols::Icmp,
),
};
let (IpAddr::V4(s), IpAddr::V4(d)) = (source, target) else {
unreachable!("the fixture is IPv4")
};
let header =
crate::protocols::ip::build_ipv4_header(s, d, segment.len() as u16, protocol, distance)
.expect("a header builds");
header.into_iter().chain(segment).collect()
}
#[test]
fn a_quoted_probe_names_the_host_and_the_distance_it_was_built_for() {
for probe in [TraceProbe::Syn { port: 443 }, TraceProbe::Echo] {
for distance in [1u8, 7, 30] {
let bytes = quoted_probe(probe, 41_234, ip(9), distance);
let quoted =
crate::transport::frame::parse_ip_segment(&bytes).expect("the fixture parses");
let sent = attribute(probe, 41_234, "ed)
.unwrap_or_else(|| panic!("{probe:?} at {distance} should be attributed"));
assert_eq!(sent.target, ip(9));
assert_eq!(sent.distance, distance);
}
}
}
#[test]
fn an_error_about_somebody_elses_packet_is_refused() {
let probe = TraceProbe::Syn { port: 443 };
let bytes = quoted_probe(probe, 41_234, ip(9), 5);
let quoted = crate::transport::frame::parse_ip_segment(&bytes).expect("the fixture parses");
assert!(attribute(probe, 41_234, "ed).is_some(), "our own probe");
assert!(
attribute(probe, 41_235, "ed).is_none(),
"another run's marker"
);
assert!(
attribute(TraceProbe::Echo, 41_234, "ed).is_none(),
"a TCP quotation read by an echo trace"
);
}
#[test]
fn a_truncated_quotation_is_refused() {
let probe = TraceProbe::Syn { port: 443 };
let bytes = quoted_probe(probe, 41_234, ip(9), 5);
let quoted = crate::transport::frame::parse_ip_segment(&bytes).expect("the fixture parses");
let short = IpSegment {
payload: "ed.payload[..4],
..quoted
};
assert!(attribute(probe, 41_234, &short).is_none());
}
#[test]
fn a_hop_counter_says_how_far_a_reply_travelled() {
assert_eq!(distance_from(64), 0, "a host on this segment");
assert_eq!(distance_from(57), 7, "seven routers, from a 64 stack");
assert_eq!(distance_from(250), 5, "five routers, from a 255 stack");
assert_eq!(distance_from(120), 8, "eight routers, from a 128 stack");
assert_eq!(distance_from(30), 2, "two routers, from a 32 stack");
}
#[test]
fn a_spliced_path_is_marked_as_inherited() {
let cache = PathCache::new();
cache.remember(&[
Hop::answered(1, ip(1), Some(Duration::from_millis(1))),
Hop::answered(2, ip(2), Some(Duration::from_millis(2))),
Hop::answered(3, ip(3), Some(Duration::from_millis(3))),
]);
let prefix = cache
.prefix_of(3, ip(3))
.expect("a router another trace recorded at this distance");
assert_eq!(prefix.len(), 2, "everything in front of the router matched");
assert!(prefix.iter().all(Hop::inferred));
assert!(
prefix.iter().all(|hop| hop.rtt().is_none()),
"a timing belongs to the trace that measured it"
);
assert_eq!(prefix[0].address(), Some(ip(1)));
}
#[test]
fn a_router_at_another_distance_is_not_the_same_point_in_a_path() {
let cache = PathCache::new();
cache.remember(&[Hop::answered(1, ip(1), None), Hop::answered(2, ip(2), None)]);
assert!(cache.prefix_of(2, ip(2)).is_some());
assert!(
cache.prefix_of(3, ip(2)).is_none(),
"same router, further away"
);
assert!(
cache.prefix_of(2, ip(9)).is_none(),
"another router entirely"
);
}
#[test]
fn a_silent_hop_survives_being_cached() {
let cache = PathCache::new();
cache.remember(&[
Hop::answered(1, ip(1), None),
Hop::silent(2),
Hop::answered(3, ip(3), None),
]);
let prefix = cache.prefix_of(3, ip(3)).expect("the far router is known");
assert_eq!(prefix.len(), 2);
assert_eq!(prefix[1].distance(), 2);
assert_eq!(prefix[1].address(), None, "the hole is still a hole");
}
}