Rust Udp Listener Like Netcat - rust

Question

I have this code for a reverse shell with tcp in rust
fn pipe_thread<R, W>(mut r: R, mut w: W) -> std::thread::JoinHandle<()>
where
R: std::io::Read + Send + 'static,
W: std::io::Write + Send + 'static,
{
std::thread::spawn(move || {
let mut buffer = [0; 1024];
loop {
let len = r.read(&mut buffer).unwrap();
if len == 0 {
println!("Connection lost");
std::process::exit(0x0100);
}
w.write(&buffer[..len]).unwrap();
w.flush().unwrap();
}
})
}
fn listen() -> std::io::Result<()> {
let listener = std::net::TcpListener::bind(format!("{}:{}", "0.0.0.0", "55100"))?;
println!("Started listener");
let (stream, _) = listener.accept()?;
let t1 = pipe_thread(std::io::stdin(), stream.try_clone()?);
println!("Connection recieved");
let t2 = pipe_thread(stream, std::io::stdout());
t1.join().unwrap();
t2.join().unwrap();
return Ok(());
}
How would but would I do the exact same thing but with udp instead of tcp?
Netcat example:
netcat -ul 55100

Answer 1

The following code will listen for udp on port 55100. When it is sent a packet, it will save the address of the sender in the addr variable. Then when the user inputs a command, a udp packet is sent to the addr address.
To test it, first send it a udp packet from port 55101 nc -u localhost 55100 -p 55101, this sets addr to localhost:55101. Then listen on port 55101 with nc -ul localhost 55101 and send a command from the rust program so that the nc listener knows where to send its packets to. Now you should be able to send udp messages back and forth between net cat and the rust program.
fn main() {
let socket = std::net::UdpSocket::bind(format!("{}:{}", "0.0.0.0", "55100"))?;
println!("Started listener");
// Addr is the last address that send me a udp packet or None if I have never received a udp packet
use std::sync::{Arc, Mutex};
let addr: Arc<Mutex<Option<std::net::SocketAddr>>> = Arc::from(Mutex::new(None));
// Clone addr so it can be moved into the closure
let addr_clone = addr.clone();
let socket_clone = socket.try_clone().unwrap();
// Spawn listening loop
std::thread::spawn(move || loop {
let mut buffer = [0; 1024];
let (len, src_addr) = socket_clone.recv_from(&mut buffer).unwrap();
*addr_clone.lock().unwrap() = Some(src_addr);
print!("{}", std::str::from_utf8(&buffer).unwrap());
});
loop {
// Get user input
let mut buffer = String::new();
std::io::stdin().read_line(&mut buffer).unwrap();
// Send the command to the last address that send me a udp packet or if I have never received a udp packet, panic
let addr_option = *addr.lock().unwrap();
if let Some(addr) = addr_option {
socket.send_to(buffer.as_bytes(), addr).unwrap();
} else {
panic!("Cant send udp because I dont know where to send it.");
}
}
}