feat(core): NAT detection for IPv4/udp/dublin (#1104)

crates/trippy-core/src/lib.rs

@@ -81,7 +81,7 @@ pub use probe::{
  Extension, Extensions, IcmpPacketType, MplsLabelStack, MplsLabelStackMember, Probe,
  ProbeComplete, ProbeStatus, UnknownExtension,
 };
-pub use state::{Hop, State};
+pub use state::{Hop, NatStatus, State};
 pub use strategy::{CompletionReason, Round, Strategy};
 pub use tracer::Tracer;
 pub use types::{

crates/trippy-core/src/probe.rs

@@ -1,4 +1,4 @@
-use crate::types::{Flags, Port, RoundId, Sequence, TimeToLive, TraceId};
+use crate::types::{Checksum, Flags, Port, RoundId, Sequence, TimeToLive, TraceId};
 use std::net::IpAddr;
 use std::time::SystemTime;
 
@@ -90,6 +90,7 @@ impl Probe {
  host: IpAddr,
  received: SystemTime,
  icmp_packet_type: IcmpPacketType,
+ checksum: Option<Checksum>,
  extensions: Option<Extensions>,
  ) -> ProbeComplete {
  ProbeComplete {
@@ -103,6 +104,7 @@ impl Probe {
  host,
  received,
  icmp_packet_type,
+ checksum,
  extensions,
  }
  }
@@ -141,6 +143,8 @@ pub struct ProbeComplete {
  pub received: SystemTime,
  /// The type of ICMP response packet received for the probe.
  pub icmp_packet_type: IcmpPacketType,
+ /// The UDP checksum of the original datagram.
+ pub checksum: Option<Checksum>,
  /// The ICMP response extensions.
  pub extensions: Option<Extensions>,
 }

crates/trippy-core/src/state.rs

@@ -186,6 +186,8 @@ pub struct Hop {
  last_sequence: u16,
  /// The icmp packet type for the last probe for this hop.
  last_icmp_packet_type: Option<IcmpPacketType>,
+ /// The NAT detection status for the last probe for this hop.
+ last_nat_status: NatStatus,
  /// The history of round trip times across the last N rounds.
  samples: Vec<Duration>,
  /// The ICMP extensions for this hop.
@@ -325,6 +327,12 @@ impl Hop {
  self.last_icmp_packet_type
  }
 
+ /// The NAT detection status for the last probe for this hop.
+ #[must_use]
+ pub const fn last_nat_status(&self) -> NatStatus {
+ self.last_nat_status
+ }
+
  /// The last N samples.
  #[must_use]
  pub fn samples(&self) -> &[Duration] {
@@ -360,10 +368,22 @@ impl Default for Hop {
  m2: 0f64,
  samples: Vec::default(),
  extensions: None,
+ last_nat_status: NatStatus::NotApplicable,
  }
  }
 }
 
+/// The state of a NAT detection for a `Hop`.
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum NatStatus {
+ /// NAT detection was not applicable.
+ NotApplicable,
+ /// NAT was not detected at this hop.
+ NotDetected,
+ /// NAT was detected at this hop.
+ Detected,
+}
+
 /// Data for a single trace flow.
 #[derive(Debug, Clone)]
 struct FlowState {
@@ -434,12 +454,13 @@ impl FlowState {
  self.round_count += 1;
  self.highest_ttl = std::cmp::max(self.highest_ttl, round.largest_ttl.0);
  self.highest_ttl_for_round = round.largest_ttl.0;
+ let mut prev_hop_checksum = None;
  for probe in round.probes {
- self.update_from_probe(probe);
+ self.update_from_probe(probe, &mut prev_hop_checksum);
  }
  }
 
- fn update_from_probe(&mut self, probe: &ProbeStatus) {
+ fn update_from_probe(&mut self, probe: &ProbeStatus, prev_hop_checksum: &mut Option<u16>) {
  match probe {
  ProbeStatus::Complete(complete) => {
  self.update_lowest_ttl(complete.ttl);
@@ -482,6 +503,18 @@ impl FlowState {
  hop.last_dest_port = complete.dest_port.0;
  hop.last_sequence = complete.sequence.0;
  hop.last_icmp_packet_type = Some(complete.icmp_packet_type);
+ if let Some(checksum) = &complete.checksum {
+ if let Some(prev_hop_checksum) = prev_hop_checksum {
+ if *prev_hop_checksum == checksum.0 {
+ hop.last_nat_status = NatStatus::NotDetected;
+ } else {
+ hop.last_nat_status = NatStatus::Detected;
+ *prev_hop_checksum = checksum.0;
+ }
+ } else {
+ *prev_hop_checksum = Some(checksum.0);
+ }
+ }
  }
  ProbeStatus::Awaited(awaited) => {
  self.update_lowest_ttl(awaited.ttl);
@@ -520,6 +553,7 @@ impl FlowState {
 #[cfg(test)]
 mod tests {
  use super::*;
+ use crate::types::Checksum;
  use crate::{
  CompletionReason, Flags, IcmpPacketType, Port, Probe, ProbeComplete, ProbeStatus, Sequence,
  TimeToLive, TraceId,
@@ -562,9 +596,9 @@ mod tests {
  type Error = anyhow::Error;
 
  fn try_from(value: String) -> Result<Self, Self::Error> {
- // format: {ttl} {status} {duration} {host} {sequence} {src_port} {dest_port}
+ // format: {ttl} {status} {duration} {host} {sequence} {src_port} {dest_port} {checksum}
  let values = value.split_ascii_whitespace().collect::<Vec<_>>();
- if values.len() == 7 {
+ if values.len() == 8 {
  let ttl = TimeToLive(u8::from_str(values[0])?);
  let state = values[1].to_ascii_lowercase();
  let sequence = Sequence(u16::from_str(values[4])?);
@@ -590,6 +624,7 @@ mod tests {
  let host = IpAddr::from_str(values[3])?;
  let duration = Duration::from_millis(u64::from_str(values[2])?);
  let received = sent.add(duration);
+ let checksum = Some(Checksum(u16::from_str(values[7])?));
  let icmp_packet_type = IcmpPacketType::NotApplicable;
  Ok(ProbeStatus::Complete(
  Probe::new(
@@ -606,6 +641,7 @@ mod tests {
  host,
  received,
  icmp_packet_type,
+ checksum,
  None,
  ),
  ))
@@ -619,7 +655,7 @@ mod tests {
  }
  }
 
- /// A helper struct so wwe may inject the round into the probes.
+ /// A helper struct so we may inject the round into the probes.
  struct ProbeRound(ProbeData, RoundId);
 
  impl From<ProbeRound> for ProbeStatus {
@@ -664,6 +700,25 @@ mod tests {
  last_src: u16,
  last_dest: u16,
  last_sequence: u16,
+ last_nat_status: NatStatusWrapper,
+ }
+
+ /// A wrapper struct over `NatStatus` to allow deserialization.
+ #[derive(Deserialize, Debug, Clone)]
+ #[serde(try_from = "String")]
+ struct NatStatusWrapper(NatStatus);
+
+ impl TryFrom<String> for NatStatusWrapper {
+ type Error = anyhow::Error;
+
+ fn try_from(value: String) -> Result<Self, Self::Error> {
+ match value.to_ascii_lowercase().as_str() {
+ "none" => Ok(Self(NatStatus::NotApplicable)),
+ "nat" => Ok(Self(NatStatus::Detected)),
+ "no_nat" => Ok(Self(NatStatus::NotDetected)),
+ _ => Err(anyhow!("unknown nat status")),
+ }
+ }
  }
 
  macro_rules! file {
@@ -677,6 +732,7 @@ mod tests {
  #[test_case(file!("ipv4_3probes_3hops_completed.yaml"))]
  #[test_case(file!("ipv4_4probes_all_status.yaml"))]
  #[test_case(file!("ipv4_4probes_0latency.yaml"))]
+ #[test_case(file!("ipv4_nat.yaml"))]
  fn test_scenario(scenario: Scenario) {
  let mut trace = State::new(StateConfig {
  max_flows: 1,
@@ -716,6 +772,7 @@ mod tests {
  assert_eq!(actual.last_src_port(), expected.last_src);
  assert_eq!(actual.last_dest_port(), expected.last_dest);
  assert_eq!(actual.last_sequence(), expected.last_sequence);
+ assert_eq!(actual.last_nat_status(), expected.last_nat_status.0);
  assert_eq!(
  Some(
  actual