Changes to be committed:
modified: src/client.rs modified: src/main.rs modified: src/server.rs modified: src/tcp_server.rs
This commit is contained in:
parent
05f3360a78
commit
ea55c94907
@ -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::<Vec<u8>>();
|
||||
let (dx, mx) = unbounded::<Vec<u8>>();
|
||||
|
||||
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::<SocketAddr>()
|
||||
.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(())
|
||||
}
|
||||
}
|
||||
28
src/main.rs
28
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<u8>
|
||||
@ -34,6 +34,28 @@ impl VpnPacket {
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
struct UDPVpnPacket {
|
||||
//start: Vec<u8>
|
||||
data: Vec<u8>
|
||||
//end: Vec<u8>
|
||||
}
|
||||
|
||||
impl UDPVpnPacket {
|
||||
fn serialize(&self) -> Vec<u8> {
|
||||
let h: &[u8] = &[1];
|
||||
[h, &self.data[..]].concat()
|
||||
}
|
||||
}
|
||||
|
||||
struct UDPVpnHandshake {}
|
||||
|
||||
impl UDPVpnHandshake {
|
||||
fn serialize(&self) -> Vec<u8> {
|
||||
[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.");
|
||||
}
|
||||
|
||||
136
src/server.rs
136
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::<IpAddr, UDPeer>::new()));
|
||||
|
||||
let receiver_sock = Arc::new(match UdpSocket::bind("192.168.0.5:8879".parse::<SocketAddr>().unwrap()).await {
|
||||
Ok(s) => s,
|
||||
Err(_error) => panic!("Cannot bind to address")
|
||||
});
|
||||
let (send2tun, recv2tun) = unbounded::<Vec<u8>>();
|
||||
|
||||
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(())
|
||||
}
|
||||
struct UDPeer {
|
||||
addr: SocketAddr
|
||||
}
|
||||
|
||||
/*struct WrappedUDP {
|
||||
sock_rec: Arc<UdpSocket>,
|
||||
sock_snd: Arc<UdpSocket>,
|
||||
addresses: Arc<Mutex<HashMap<IpAddr, UDPeer>>>
|
||||
}
|
||||
|
||||
impl WrappedUDP {
|
||||
pub async fn new(addr: &str) -> Self {
|
||||
|
||||
WrappedUDP { sock_rec, sock_snd, addresses }
|
||||
}
|
||||
|
||||
pub async fn init(&self) {
|
||||
|
||||
}
|
||||
}*/
|
||||
@ -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);
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user