Crafting a CLI Tracerouter from Scratch

> cargo new tracerouter
> cd tracerouter

[dependencies]
socket2 = "0.5"

[main.rs]

use std::env;

fn main() -> std::io::Result<()> {
    let args: Vec<String> = env::args().collect();
    if args.len() != 2 || args[1].is_empty() {
        eprintln!("Usage: tracerouter <hostname>");
        std::process::exit(1);
    }
    println!("Tracing route to: {}...", &args[1];);
}

[mod.rs]

use std::net::IpAddr;
use dns_lookup::lookup_host;

/// Lookup host and return a list of valid IPV4-only addresses.
///
pub fn resolve_host(hostname: &String) -> Vec<IpAddr> {
    match lookup_host(hostname) {
        Ok(ips) => {
            ips
            .into_iter()
            .filter(|ip| ip.is_ipv4() )
            .collect::<Vec<IpAddr>>()
        }
        Err(e) => {
            eprintln!("Could not find valid IPs for {hostname}, {e}");
            std::process::exit(1);
        }
    }
}

[main.rs] After route println! feedback

[...]
use tracerouter::resolve_host;

fn main() -> std::io::Result<()> {
[...]
    println!("Tracing route to: {}...", &args[1]);

    let ips = resolve_host(&args[1]);
    if ips.len() == 0 {
        eprintln!("Error: Could not find IP for {}", &args[1]);
        std::process::exit(1);
    }

    Ok(())
}

[main.rs]

use socket2::{Domain, Protocol, Socket, Type};

fn main() -> std::io::Result<()> {
[...]
    // Create our IPV4 Socket
    let socket = Socket::new(
        Domain::IPV4,
        Type::RAW,
        Some(Protocol::ICMPV4)
    ).expect("Error: Could not initialize Socket.
    It is required for program to be running in a high privilege state.");

    // Specify to kernel we're sending our own IP header
    // If false, system will take care of it
    socket.set_header_included_v4(true).expect("Could not specify IP_HDRINCL header.");

    Ok(())
}

[main.rs]

fn main() -> std::io::Result<()> {
[...]
    let mut packet = [0u8; 20 + 8]; // IP Header (20 bytes) + ICMP (8 bytes)

    // IP Header (simplified, version 4, no options)
    // First 4 bits are the version (4) and the preceding 4 bits IHL (5) (big-endian represented)
    packet[0] = 0x45;                        // Version: 4, IHL: 5
    // packet[1] = 0;                        // ToS omitted because bucket is already 0
    packet[2] = 0;                          // High Byte
    packet[3] = 28;                         // Low Byte
    packet[4..6].copy_from_slice(&0u16.to_be_bytes()); // Identification (0)
    packet[6..8].copy_from_slice(&0u16.to_be_bytes()); // Flags + Fragment Offset (0 unspecified)
    // packet[8] = 4;                       // TTL (Late populated)
    packet[9] = 1;                          // Protocol (ICMP)

    Ok(())
}

[main.rs]

[...]

	  if args.len() != 2 || args[1].is_empty() {
	      eprintln!("Usage: tracerouter <hostname>");
	      std::process::exit(1);
	  }
	  println!("Tracing route to: {}...", &args[1]);

	  let my_ip = local_ip().unwrap_or_else(|_| panic!("Could not get local IP."));

[...]

[main.rs]

[...]
	  packet[8] = 4;                          // TTL
	  packet[9] = 1;                          // Protocol (ICMP)

	  let my_ip_str = my_ip.to_string();
	  let mut my_num_ip = my_ip_str.split(".");

	  // Set local IP Address to packet
	  for index in 12..=15 {
	      packet[index] = my_num_ip.next().unwrap().parse::<u8>().unwrap();
	  }

[...]

[main.rs]

[...] - /* After set our IP code to packet */

    // Uses each destination IP address to until an request is successfully completed
    for ip in dest_ips {
        // Parse IP to number as u8
        let str = ip.to_string();
        let mut num_ip = str.split(".");

        // Extract all 4 IPV4 fields advancing iterator parsing it to u8;
        // Like 192 (first parse) and the subsequent: 168, 1, 1
        for index in 16..=19 {
            packet[index] = num_ip.next().unwrap().parse::<u8>().unwrap();
        }
    }

[...]

[main.rs]

[...] - /* After set our IP code to packet */

    // ICMP Header
    packet[20] = 8;         // Type (Echo Request)
    // packet[21] = 0;      // Code (Omitted, already 0)
    packet[22] = todo!();   //  Checksum
    packet[23] = todo!();
    packet[24] = 0x12;      // Identifier
    packet[25] = 0x34;
    packet[26] = 0x00;      // Sequence Number
    packet[27] = 0x01;

    // Uses each destination IP address to until an request is successfully completed
    for ip in dest_ips {
        // Parse IP to number as u8
        let str = ip.to_string();
        let mut num_ip = str.split(".");

[...]

[mod.rs]

[...] - /* After resolve_host() definition */

/// Makes data into 2 bytes words, sum and invert them (NOT bit operation)
///
/// [0x32, 0x00, 0x49, 0x30, [...]] -> Raw Vec (u8 representation)
///
/// [0x3200, 0x4930, 0x0001, 0x3842] -> What we need
///
pub fn calc_checksum(data: &[u8]) -> u16 {
    // u32 so we can handle u16 bit overflow later
    let mut sum = 0u32; // -> 00000000 00000000 00000000 00000000;
    let mut i = 0;

    // -1 Set odd handling, as we step 2 each time when an odd is found
    // the conditional is not true because it's value is equal to data.len() - 1
    while i < data.len() - 1 {
        // Get 1 byte and shift it by 1 byte.
        // Now we got "1 byte extra space" since we're dealing with an u8 as cast it to u32 in the process;
        // Ex: Our u8 00000010 becomes 0000000 00000000 00000010 00000000 (u32 bits aligned)
        // This way we just free the needed space to block another byte into it (data[i+1]).
        // "|" Add the bits so as we already got the free byte (8 bits),
        // we can just add them casting to u32 as only same types are allowed to sum.
        let word = (data[i] as u32) << 8 | (data[i + 1] as u32);

        sum += word;
        i += 2;
    }

    // Odd buffer handling
    if i == data.len() -1 {
        sum += (data[i] as u32) << 8;
    }

    // Strip zeroed bytes from u32 sum until a valid u16 is set.
    // Finally, this is an operation to make our u32 with possible overflow
    // to fit into u16 correctly, following the checksum algorithm.
    while (sum >> 16) > 0 {
        // Sum lower 16 bits with overflow (if present)
        sum = (sum & 0xFFFF) + (sum >> 16);
    }

    !sum as u16
}

[mod.rs]

[...] - /* After calc_checksum() definition */

#[cfg(test)]
mod tests {
    use super::*;

    /// Assert checksum of a dummy ICMP packet is correct.
    ///
    #[test]
    fn pair_checksum() {
        let buf: [u8; 8] = [0x08, 0x00, 0x00, 0x00, 0x12, 0x34, 0x00, 0x01];
        let result: u16 = 0xE5CA;

        assert_eq!(result, calc_checksum(&buf));
    }

    #[test]
    fn odd_checksum() {
        // Same as above but with additional 0x23 on final.
        let buf: [u8; 9] = [0x08, 0x00, 0x00, 0x00, 0x12, 0x34, 0x00, 0x01, 0x23];
        let result: u16 = 0xC2CA;

        assert_eq!(result, calc_checksum(&buf));
    }
}

[...]

[main.rs]

[...]

		packet[8] = 4;                          // TTL
		packet[9] = 1;                          // Protocol (ICMP)

		let ip_checksum = calc_checksum(&packet[0..20]);
		packet[10] = (ip_checksum >> 8) as u8;  // High Byte
		packet[11] = (ip_checksum & 0xFF) as u8;// Low Byte

		let my_ip_str = my_ip.to_string();
		let mut my_num_ip = my_ip_str.split(".");

		// Set local IP Address to packet
		for index in 12..=15 {
		    packet[index] = my_num_ip.next().unwrap().parse::<u8>().unwrap();
		}

		// ICMP Header
		packet[20] = 8;         // Type (Echo Request)
		// packet[21] = 0;      // Code (Omitted, already 0)
		// packet[22] = 0;      //  Checksum (u16)
		// packet[23] = 0;
		packet[24] = 0x12;      // Identifier
		packet[25] = 0x34;
		packet[26] = 0x00;      // Sequence Number
		packet[27] = 0x01;

		let icmp_checksum = calc_checksum(&packet[20..=27]);
		packet[22] = (icmp_checksum >> 8) as u8;  // High Byte
		packet[23] = (icmp_checksum & 0xFF) as u8;// Low Byte

[...]

[main.rs]

[...] - /* After set our IP code to packet, on address loop */
    // Extract all 4 IPV4 fields advancing iterator parsing it to u8;
    // Like 192 (first parse) and the subsequent: 168, 1, 1
    for index in 16..=19 {
        packet[index] = num_ip.next().unwrap().parse::<u8>().unwrap();
    }

    for ttl in 1..=30 {
      // Set TTL on IP header
      packet[8] = ttl;

      // Effectivelly send our Packet,
      // blocking current thread until a response is read or TTL end is reached.
      socket.set_read_timeout(Some(Duration::from_secs(3)))?;
      socket.send_to(&packet, &SockAddr::from(SocketAddr::new(dest_ip, 0)))?;
      println!("Tracing with TTL: {ttl}");

      // 56 bytes buffer - High buffer on convential values (56 bytes on TTL outlive)
      let mut buffer: [MaybeUninit<u8>; 512] = [MaybeUninit::uninit(); 512];
    }

[...]

[main.rs]

[...]
      // Effectivelly send our Packet,
      // blocking current thread until a response is read or TTL end is reached.
      socket.set_read_timeout(Some(Duration::from_secs(3)))?;
      socket.send_to(&packet, &SockAddr::from(SocketAddr::new(dest_ip, 0)))?;
      println!("Tracing with TTL: {ttl}");

      // 56 bytes buffer - High buffer on convential values (56 bytes on TTL outlive)
      let mut buffer: [MaybeUninit<u8>; 512] = [MaybeUninit::uninit(); 512];
      match socket.recv_from(&mut buffer) {
          Ok((size, sender)) => {
              println!("Received {size} bytes from {sender:?}");

              // Responses generally are 56 (Time Exceed - IP Header/ICMP
              // of sender and original IP Header)
              // or 28 (Success, IPHeader/ICMP packet of sender).
              let received_data = unsafe {
                  std::slice::from_raw_parts(
                      buffer.as_ptr() as *const u8,
                      size
                  )
              };

              let received_ip = parse_sender_ip(&received_data[12..=15]);

              // Received ICMP type
              let icmp_type = received_data[20];

              if icmp_type == 11 {
                  println!("TTL: {ttl} on {received_ip}\n");

                  // Adjust by your flavor
                  std::thread::sleep(Duration::from_secs(1));
                  continue;
              }

              println!("Reached destiny: {received_ip}");
              break;
          },
          Err(err) if err.kind() == ErrorKind::WouldBlock
	          || err.kind() == ErrorKind::TimedOut => {
              eprintln!("TTL={ttl} Timeout - No Response.\n");
          },
          Err(err) => { return Err(err) }
      };
    }

[...]

[mod.rs]

[...] /* Before Tests */

pub fn parse_sender_ip(ip: &[u8]) -> String {
    let mut str_ip = String::new();

    for i in 1..ip.len() {
        str_ip += &(ip[i].to_string() + ".");
    }

    // Remove last '.'
    str_ip.pop();

    str_ip
}

[...]

cargo run -- [domain]

Tracing route to [google.com](http://google.com/)...
ips: [142.251.128.238]
my_ip: 10.0.0.111
Tracing with TTL: 1
Received 56 bytes from SockAddr { ss_family: 2, len: 16 }
icmp_type: 11
TTL: 1 on 0.0.1

Tracing with TTL: 2
Received 56 bytes from SockAddr { ss_family: 2, len: 16 }
icmp_type: 11
TTL: 2 on 39.121.208

Tracing with TTL: 3
Received 56 bytes from SockAddr { ss_family: 2, len: 16 }
icmp_type: 11
TTL: 3 on 201.45.236

Tracing with TTL: 4
Received 56 bytes from SockAddr { ss_family: 2, len: 16 }
icmp_type: 11
TTL: 4 on 201.45.185

Tracing with TTL: 5
Received 56 bytes from SockAddr { ss_family: 2, len: 16 }
icmp_type: 11
TTL: 5 on 248.108.29

Tracing with TTL: 6
Received 56 bytes from SockAddr { ss_family: 2, len: 16 }
icmp_type: 11
TTL: 6 on 150.1.176

Tracing with TTL: 7
Received 96 bytes from SockAddr { ss_family: 2, len: 16 }
icmp_type: 11
TTL: 7 on 250.162.224

Tracing with TTL: 8
Received 56 bytes from SockAddr { ss_family: 2, len: 16 }
icmp_type: 11
TTL: 8 on 170.226.225

Tracing with TTL: 9
Received 56 bytes from SockAddr { ss_family: 2, len: 16 }
icmp_type: 11
TTL: 9 on 85.251.13

Tracing with TTL: 10
Received 28 bytes from SockAddr { ss_family: 2, len: 16 }
icmp_type: 0
Reached destiny: 251.128.238