diff --git a/Cargo.toml b/Cargo.toml index 775361c..26f6348 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -6,3 +6,12 @@ edition = "2021" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] +socket2 = "0.4" +env_logger = "0.10" +rhexdump = "0.1.1" +rand = "0.8.5" + +[profile.release] +strip = true # Automatically strip symbols from the binary. +opt-level = "z" +lto = true \ No newline at end of file diff --git a/src/main.rs b/src/main.rs index 1a1014f..d74ea6e 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,44 +1,97 @@ -use std::env; -use std::io::{self}; -use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket}; +use core::time::Duration; +use rand::{ + Rng, + thread_rng, + distributions::Alphanumeric, +}; + +use std::{ + sync::Arc, + env, + io::{self}, + net::{IpAddr, Ipv4Addr, SocketAddr}, +}; +use std::os::{ + unix::io::AsRawFd, + unix::io::FromRawFd +}; +//use env_logger::Env; fn main() { + //env_logger::Builder::from_env(Env::default().default_filter_or("info")).init(); // Parse the command line arguments. let args: Vec = env::args().collect(); if args.len() == 1 || args.contains(&"--help".to_string()) { - eprintln!("Usage: cargo run --dest [--request ] [--data ] [--payload ]"); + eprintln!("Usage: cargo run --dest [--request/-r ] [--data/-d ] [--payload/-p ]"); std::process::exit(1); } - // if args.len() < 2 { - // eprintln!("Error: expected at least one argument (the destination IP address)"); - // std::process::exit(1); - // } + let dest_ip = args[1].parse::().unwrap(); + let mut ping_request = None; let mut data = None; - let mut payload = None; + let mut temp_payload = None; for (i, arg) in args[1..].iter().enumerate() { if arg == "--request" || arg == "-r" { - ping_request = Some(args[i + 1].parse::().unwrap()); + ping_request = Some(args[i + 2].parse::().unwrap()); } else if arg == "--data" || arg == "-d" { - data = Some(args[i + 1].parse::().unwrap()); + data = Some(args[i + 2].parse::().unwrap()); } else if arg == "--payload" || arg == "-p" { - payload = Some(args[i + 1].as_bytes()); + temp_payload = Some(args[i + 2].as_bytes()); } } + // SOURCE IP ADDRESS + // let localhost = Ipv4Addr::LOCALHOST; + let localhost = Ipv4Addr::UNSPECIFIED; + let socket_ip_address = SocketAddr::new(IpAddr::V4(localhost), 80); + let socket2_ip_address = socket_ip_address.into(); + let ping_request = ping_request.unwrap_or(0x0800); // Default ping request value let data = data.unwrap_or(0x0000); // Default data value - let payload = payload.unwrap_or(b""); // Default payload value + let payload = temp_payload.unwrap_or(b""); + // match temp_payload { + // None => { + // let mut rng = thread_rng(); + // payload=(0..64) + // .map(|_| rng.sample(Alphanumeric) as char) + // .collect::() + // .as_bytes() + // // .unwrap_or("Couldn't generate 64 bits of entropy") + // //b"" + // } + // Some(p) => { + // payload=p + // }, // Default payload value + // }; // Create a UDP socket. - let socket = UdpSocket::bind("0.0.0.0:8080").unwrap(); + let socket2_ipv4_socket = socket2::Socket::new( + socket2::Domain::IPV4, + socket2::Type::DGRAM, + Some(socket2::Protocol::ICMPV4), + ).unwrap(); + + // BIND TO LOCAL ADDRESS + socket2_ipv4_socket + .bind(&socket2_ip_address) + .expect(&format!( + "Failed binding to Ipv4 address {:?}", + &socket_ip_address + )); + + + // CREATE STD SOCKET FROM SOCKET2 SOCKET + let raw_ipv4_socket = socket2_ipv4_socket.as_raw_fd(); + let std_ipv4_socket = unsafe { std::net::UdpSocket::from_raw_fd(raw_ipv4_socket) }; + std_ipv4_socket.set_read_timeout(Some(Duration::from_millis(100))).expect(&format!("Failed to set read timeout")); + let socket_arc = Arc::new(std_ipv4_socket); // Set the socket to be non-blocking. - socket.set_nonblocking(true).unwrap(); + // socket.set_nonblocking(true).unwrap(); // Set the Time-To-Live (TTL) value for the socket. - socket.set_ttl(64).unwrap(); + // socket.set_ttl(64).unwrap(); // Create the ping request message. let mut buf = [0u8; 64]; @@ -68,14 +121,20 @@ fn main() { buf[3] = (checksum & 0xff) as u8; // Send the ping request to the specified destination IP address. - let dest_addr = SocketAddr::new(IpAddr::V4(dest_ip), 8080); - socket.send_to(&buf, dest_addr).unwrap(); + let dest_addr = SocketAddr::new(IpAddr::V4(dest_ip), 0); + println!("[SENDING ICMP DATA]\n"); + println!("{}",rhexdump::hexdump(&buf)); + let result = socket_arc.send_to(&buf, dest_addr); + match result { + Ok(bytes) => println!("> {} bytes sent over the socket", bytes), + Err(err) => println!("> Failed to send data over the socket: {}", err) + } // Wait for a response from the destination. let mut buf = [0; 64]; let timeout = std::time::Duration::from_secs(1); - socket.set_read_timeout(Some(timeout)).unwrap(); - let (bytes_recv, _src_addr) = match socket.recv_from(&mut buf) { + socket_arc.set_read_timeout(Some(timeout)).unwrap(); + let (bytes_recv, _src_addr) = match socket_arc.recv_from(&mut buf) { Ok(res) => res, Err(ref err) if err.kind() == io::ErrorKind::WouldBlock => { println!("No response from destination"); @@ -93,14 +152,17 @@ fn main() { let icmp_checksum = ((buf[2] as u16) << 8) | (buf[3] as u16); let icmp_id = ((buf[4] as u16) << 8) | (buf[5] as u16); let icmp_seq = ((buf[6] as u16) << 8) | (buf[7] as u16); - let data = &buf[0..bytes_recv]; + //let data = &buf[8..bytes_recv]; // Print the parsed response. - println!("icmp_type={} icmp_code={} icmp_checksum={:04x}", icmp_type, icmp_code, icmp_checksum); - println!("icmp_id={} icmp_seq={}", icmp_id, icmp_seq); - print!("data="); - for b in data { - print!("{:02x}", b); - } + println!("\n[ANALYSIS] \n"); + println!("{}",rhexdump::hexdump(&buf)); + println!(" > {} bytes recv over the socket", bytes_recv); + println!(" > icmp_type = {:width$} icmp_code = {:width$} icmp_checksum={:04x}", icmp_type, icmp_code, icmp_checksum, width=2); + println!(" > icmp_id = {:width$} icmp_seq = {:width$}", icmp_id, icmp_seq, width=2); + // print!("data="); + // for b in data { + // print!("{:02x}", b); + // } println!(); }