From ea55c9490780b87af5b0c0035a1f02492b49152d Mon Sep 17 00:00:00 2001 From: alterdekim Date: Sat, 17 Aug 2024 17:16:16 +0300 Subject: [PATCH] Changes to be committed: modified: src/client.rs modified: src/main.rs modified: src/server.rs modified: src/tcp_server.rs --- src/client.rs | 87 ++++++++++++++--------------- src/main.rs | 28 +++++++++- src/server.rs | 136 ++++++++++++++++++++++++++++++---------------- src/tcp_server.rs | 52 ------------------ 4 files changed, 155 insertions(+), 148 deletions(-) diff --git a/src/client.rs b/src/client.rs index 98c41b1..29382d8 100644 --- a/src/client.rs +++ b/src/client.rs @@ -1,15 +1,17 @@ -use std::process::Command; -use clap::{App, Arg}; -use env_logger::Builder; -use tokio::{net::UdpSocket, sync::{mpsc, Mutex}}; +use crossbeam_channel::{unbounded, Receiver}; +use tokio::{io::AsyncWriteExt, net::UdpSocket, sync::{mpsc, Mutex}}; use tokio::task::JoinSet; -use std::io::{self, Read, Write}; -use std::sync::mpsc::Receiver; +use packet::{builder::Builder, icmp, ip, Packet}; +use std::io::{Read, Write}; use tun2::BoxError; use log::{error, info, LevelFilter}; use std::sync::Arc; use std::net::SocketAddr; use std::collections::HashMap; +use std::process::Command; +use tokio::io::AsyncReadExt; + +use crate::{UDPVpnPacket, VpnPacket}; fn configure_routes() { let ip_output = Command::new("ip") @@ -56,7 +58,7 @@ fn configure_routes() { } } -pub async fn client_mode(remote_addr: String) -> io::Result<()> { +pub async fn client_mode(remote_addr: String) { info!("Starting client..."); let mut config = tun2::Configuration::default(); @@ -71,54 +73,49 @@ pub async fn client_mode(remote_addr: String) -> io::Result<()> { config.packet_information(true); }); - let dev = tun2::create(&config)?; - let (mut reader, mut writer) = dev.split(); + let dev = tun2::create(&config).unwrap(); + let (mut dev_reader, mut dev_writer) = dev.split(); #[cfg(target_os = "linux")] configure_routes(); - let sock = UdpSocket::bind("0.0.0.0:59611").await?; - sock.connect(&remote_addr).await?; - let receive_sock = Arc::new(sock); - let send_sock = Arc::new(UdpSocket::bind("0.0.0.0:59612").await?); - - let mut set = JoinSet::new(); + let sock = UdpSocket::bind("0.0.0.0:59611").await.unwrap(); + sock.connect(&remote_addr).await.unwrap(); - let srem = Arc::new(remote_addr.clone()); + let sock_rec = Arc::new(sock); + let sock_snd = sock_rec.clone(); - set.spawn(async move { - let mut buf = [0; 4096]; + let (tx, rx) = unbounded::>(); + let (dx, mx) = unbounded::>(); + + tokio::spawn(async move { + while let Ok(bytes) = rx.recv() { + dev_writer.write_all(&bytes).unwrap(); + } + }); + + tokio::spawn(async move { + let mut buf = vec![0; 8192]; + while let Ok(n) = dev_reader.read(&mut buf) { + dx.send(buf[..n].to_vec()).unwrap(); + } + }); + + tokio::spawn(async move { + let mut buf = vec![0; 4096]; loop { - match reader.read(&mut buf) { - Ok(size) => { - let pkt = &buf[..size]; - use std::io::{Error, ErrorKind::Other}; - //tx.send(pkt.to_vec()).await.unwrap(); - send_sock.send_to(pkt, srem.parse::() - .expect("Unable to parse socket address")); - info!("Wrote to sock"); - } - Err(error) => error!("Error with reading from tun") + if let Ok(l) = sock_rec.recv(&mut buf).await { + tx.send((&buf[..l]).to_vec()); } - () } }); - set.spawn(async move { - let mut buf = [0; 4096]; - loop { - match receive_sock.recv_from(&mut buf).await { - Ok((len, addr)) => { - println!("{:?} bytes received from {:?}", len, addr); - writer.write_all(&buf[..len]); - info!("Wrote to tun"); - } - Err(error) => error!("Error with reading from sock") - }; + loop { + if let Ok(bytes) = mx.recv() { + let vpn_packet = UDPVpnPacket{ data: bytes }; + let serialized_data = vpn_packet.serialize(); + //info!("Writing to sock: {:?}", serialized_data); + sock_snd.send(&serialized_data).await.unwrap(); } - }); - - while let Some(res) = set.join_next().await {} - - Ok(()) + } } \ No newline at end of file diff --git a/src/main.rs b/src/main.rs index cff9de0..19af419 100644 --- a/src/main.rs +++ b/src/main.rs @@ -8,10 +8,10 @@ use tun::platform::Device; use serde_derive::Serialize; use serde_derive::Deserialize; -//mod client; -//mod server; mod tcp_client; mod tcp_server; +mod server; +mod client; struct VpnPacket { //start: Vec @@ -34,6 +34,28 @@ impl VpnPacket { } } + +struct UDPVpnPacket { + //start: Vec + data: Vec + //end: Vec +} + +impl UDPVpnPacket { + fn serialize(&self) -> Vec { + let h: &[u8] = &[1]; + [h, &self.data[..]].concat() + } +} + +struct UDPVpnHandshake {} + +impl UDPVpnHandshake { + fn serialize(&self) -> Vec { + [0, 9, 9, 9, 9, 9, 9].to_vec() + } +} + #[tokio::main] async fn main() { @@ -68,7 +90,7 @@ async fn main() { if is_server_mode { if let Some(vpn_server_ip) = matches.value_of("bind-to") { let server_address = format!("{}:8879", vpn_server_ip); - tcp_server::server_mode(server_address).await; + server::server_mode(server_address).await; } else { eprintln!("Error: For server mode, you shall provide the '--bind-to' argument."); } diff --git a/src/server.rs b/src/server.rs index 62f68c4..141aaab 100644 --- a/src/server.rs +++ b/src/server.rs @@ -1,20 +1,24 @@ -use tokio::{net::UdpSocket, sync::{mpsc, Mutex}}; +use crossbeam_channel::{unbounded, Receiver, Sender}; +use tokio::{io::AsyncWriteExt, net::{TcpListener, TcpSocket, TcpStream, UdpSocket}, sync::{mpsc, Mutex}}; use tokio::task::JoinSet; -use packet::{builder::Builder, icmp, ip, Packet}; +use packet::{builder::Builder, icmp, ip, AsPacket, Packet}; use std::io::{Read, Write}; -use std::sync::mpsc::Receiver; use tun2::BoxError; use log::{error, info, LevelFilter}; use std::sync::Arc; -use std::net::SocketAddr; +use std::net::{ SocketAddr, Ipv4Addr, IpAddr }; use std::collections::HashMap; +use tokio::io::AsyncReadExt; +use std::process::Command; +use crate::VpnPacket; -pub async fn server_mode() -> Result<(), BoxError> { +pub async fn server_mode(bind_addr: String) { info!("Starting server..."); let mut config = tun2::Configuration::default(); config.address("10.8.0.1"); + config.netmask("255.255.255.0"); config.tun_name("tun0"); config.up(); @@ -23,55 +27,91 @@ pub async fn server_mode() -> Result<(), BoxError> { config.packet_information(true); }); - let dev = tun2::create(&config)?; - let (mut reader, mut writer) = dev.split(); + let dev = tun2::create(&config).unwrap(); + let (mut dev_reader, mut dev_writer) = dev.split(); - let clients_inserter = Arc::new(Mutex::new(HashMap::<&str, UdpSocket>::new())); - let clients_getter = clients_inserter.clone(); + let sock = UdpSocket::bind(bind_addr).await.unwrap(); + let sock_rec = Arc::new(sock); + let sock_snd = sock_rec.clone(); + let addresses = Arc::new(Mutex::new(HashMap::::new())); - let receiver_sock = Arc::new(match UdpSocket::bind("192.168.0.5:8879".parse::().unwrap()).await { - Ok(s) => s, - Err(_error) => panic!("Cannot bind to address") - }); + let (send2tun, recv2tun) = unbounded::>(); - let mut set = JoinSet::new(); - - set.spawn(async move { - let mut buf = [0; 4096]; + tokio::spawn(async move { loop { - let size = reader.read(&mut buf)?; - let pkt = &buf[..size]; - use std::io::{Error, ErrorKind::Other}; - let m = clients_getter.lock().await; - match m.get(&"10.0.8.2") { - Some(&ref sock) => { sock.send(&pkt).await.unwrap(); info!("Wrote to sock") }, - None => { error!("There's no client!") } - }; - drop(m); - () - } - #[allow(unreachable_code)] - Ok::<(), std::io::Error>(()) - }); - - set.spawn(async move { - let mut buf = [0; 4096]; - loop { - if let Ok((len, addr)) = receiver_sock.recv_from(&mut buf).await { - let mut m = clients_inserter.lock().await; - if !m.contains_key(&"10.0.8.2") { - let cl = UdpSocket::bind("0.0.0.0:59611").await?; - cl.connect(addr).await?; - m.insert("10.0.8.2", cl); - } - drop(m); - writer.write_all(&buf[..len])?; - info!("Wrote to tun"); + if let Ok(bytes) = recv2tun.recv() { + dev_writer.write_all(&bytes).unwrap(); } } }); - while let Some(res) = set.join_next().await {} + let addrs_cl = addresses.clone(); + tokio::spawn(async move { + let mut buf = vec![0; 4096]; + while let Ok(n) = dev_reader.read(&mut buf) { + // 16..=19 + if n > 19 { + let ip = IpAddr::V4(Ipv4Addr::new(buf[16], buf[17], buf[18], buf[19])); + let mp = addrs_cl.lock().await; + if let Some(peer) = mp.get(&ip) { + sock_snd.send_to(&buf[..n], peer.addr); + } else { + mp.values().for_each(| peer | { sock_snd.send_to(&buf[..n], peer.addr); }); + error!("UDPeer not found {:?}", ip); + } + drop(mp); + } + } + }); + + let mut buf = vec![0; 2048]; + let addrs_lp = addresses.clone(); + + loop { + if let Ok((len, addr)) = sock_rec.recv_from(&mut buf).await { + let mut mp = addrs_lp.lock().await; + match buf.first() { + Some(h) => { + match h { + 0 => { + // (&buf[1..len]).to_vec() + let internal_ip = IpAddr::V4(Ipv4Addr::new(10,8,0,2)); + mp.insert(internal_ip, UDPeer { addr }); + }, // handshake + 1 => { + if mp.values().any(| p | p.addr == addr) { + send2tun.send((&buf[1..len]).to_vec()); + } + }, // payload + _ => { + error!("Unexpected header value."); + } + } + }, + None => error!("There is no header") + } + drop(mp); + } + } +} - Ok(()) -} \ No newline at end of file +struct UDPeer { + addr: SocketAddr +} + +/*struct WrappedUDP { + sock_rec: Arc, + sock_snd: Arc, + addresses: Arc>> +} + +impl WrappedUDP { + pub async fn new(addr: &str) -> Self { + + WrappedUDP { sock_rec, sock_snd, addresses } + } + + pub async fn init(&self) { + + } +}*/ \ No newline at end of file diff --git a/src/tcp_server.rs b/src/tcp_server.rs index 8e71fd3..f9f0dd4 100644 --- a/src/tcp_server.rs +++ b/src/tcp_server.rs @@ -22,58 +22,6 @@ pub async fn server_mode(bind_addr: String) { config.tun_name("tun0"); config.up(); - /* let mut route_output = Command::new("route") - .arg("add") - .arg("0.0.0.0") - .arg("mask") - .arg("128.0.0.0") - .arg("0.0.0.0") - .output() - .expect("Failed to execute IP ROUTE 1"); - - if !route_output.status.success() { - error!("Failed to set route: {}", String::from_utf8_lossy(&route_output.stderr)); - } - - route_output = Command::new("route") - .arg("add") - .arg("10.8.0.1") - .arg("mask") - .arg("255.255.255.255") - .arg("0.0.0.0") - .output() - .expect("Failed to execute IP ROUTE 2"); - - if !route_output.status.success() { - error!("Failed to set route: {}", String::from_utf8_lossy(&route_output.stderr)); - } - - route_output = Command::new("route") - .arg("add") - .arg("127.255.255.255") - .arg("mask") - .arg("255.255.255.255") - .arg("0.0.0.0") - .output() - .expect("Failed to execute IP ROUTE 3"); - - if !route_output.status.success() { - error!("Failed to set route: {}", String::from_utf8_lossy(&route_output.stderr)); - } - - route_output = Command::new("route") - .arg("add") - .arg("128.0.0.0") - .arg("mask") - .arg("128.0.0.0") - .arg("0.0.0.0") - .output() - .expect("Failed to execute IP ROUTE 4"); - - if !route_output.status.success() { - error!("Failed to set route: {}", String::from_utf8_lossy(&route_output.stderr)); - }*/ - #[cfg(target_os = "linux")] config.platform_config(|config| { config.packet_information(true);