Added a little more friendliness

This commit is contained in:
beffroi 2022-12-08 16:59:07 +01:00
parent b0f15f37ee
commit ab0ea1e1ee
2 changed files with 98 additions and 27 deletions

View File

@ -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

View File

@ -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<String> = env::args().collect();
if args.len() == 1 || args.contains(&"--help".to_string()) {
eprintln!("Usage: cargo run --dest <destination IP address> [--request <ping request>] [--data <data>] [--payload <payload>]");
eprintln!("Usage: cargo run --dest <destination IP address> [--request/-r <ping request>] [--data/-d <data>] [--payload/-p <payload>]");
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::<Ipv4Addr>().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::<u16>().unwrap());
ping_request = Some(args[i + 2].parse::<u16>().unwrap());
} else if arg == "--data" || arg == "-d" {
data = Some(args[i + 1].parse::<u16>().unwrap());
data = Some(args[i + 2].parse::<u16>().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::<String>()
// .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!();
}