modified: src/client.rs

modified:   src/config.rs
	modified:   src/main.rs

src/client.rs

@@ -1,85 +1,5 @@
 use crossbeam_channel::unbounded;
 use socket2::SockAddr;
-use tokio::{net::UdpSocket, sync::{Mutex, mpsc}, io::{BufReader, BufWriter, AsyncWriteExt, AsyncReadExt}, fs::File};
-use tokio_util::sync::CancellationToken;
-use std::{io::{Read, Write}, net::SocketAddr};
-use base64::prelude::*;
-use log::{error, info, warn};
-use std::sync::Arc;
-use std::net::Ipv4Addr;
-use x25519_dalek::{PublicKey, StaticSecret};
-use std::{ process::Command, os::unix::io::FromRawFd};
-use aes_gcm::{
-    aead::{Aead, AeadCore, KeyInit, OsRng},
-    Aes256Gcm, Nonce};
-
-use crate::config::ClientConfiguration;
-use crate::udp::{UDPVpnPacket, UDPVpnHandshake, UDPSerializable};
-use network_interface::NetworkInterface;
-use network_interface::NetworkInterfaceConfig;
-
-fn configure_routes(endpoint_ip: &str, s_interface: Option<String>) {
-    let interfaces = NetworkInterface::show().unwrap();
-
-    let net_inter = interfaces.iter()
-        .filter(|i| !i.addr.iter().any(|b| b.ip().to_string() == "127.0.0.1" || b.ip().to_string() == "::1") )
-        .min_by(|x, y| x.index.cmp(&y.index))
-        .unwrap();
-
-    let inter_name = if s_interface.is_some() { s_interface.unwrap() } else { net_inter.name };
-
-    info!("Main network interface: {:?}", inter_name);
-
-    /*let mut ip_output = Command::new("sudo")
-        .arg("ip")
-        .arg("route")
-        .arg("del")
-        .arg("default")
-        .output()
-        .expect("Failed to delete default gateway.");
-
-    if !ip_output.status.success() {
-        error!("Failed to delete default gateway: {:?}", String::from_utf8_lossy(&ip_output.stderr));
-    }*/
-
-    let mut ip_output = Command::new("sudo")
-        .arg("ip")
-        .arg("-4")
-        .arg("route")
-        .arg("add")
-        .arg("0.0.0.0/0")
-        .arg("dev")
-        .arg("tun0")
-        .output()
-        .expect("Failed to execute ip route command.");
-
-    if !ip_output.status.success() {
-        error!("Failed to route all traffic: {:?}", String::from_utf8_lossy(&ip_output.stderr));
-    }
-
-    ip_output = Command::new("sudo")
-        .arg("ip")
-        .arg("route")
-        .arg("add")
-        .arg(endpoint_ip.to_owned()+"/32")
-        .arg("via")
-        .arg("192.168.0.1")
-        .arg("dev")
-        .arg(inter_name)
-        .output()
-        .expect("Failed to make exception for vpns endpoint.");
-
-    if !ip_output.status.success() {
-        error!("Failed to forward packets: {:?}", String::from_utf8_lossy(&ip_output.stderr));
-    }
-}
-
-/*
-s_interface: Option<&str>
-let s_a: SocketAddr = client_config.server.endpoint.parse().unwrap();
-#[cfg(target_os = "linux")]
-configure_routes(&s_a.ip().to_string(), s_interface);
-*/
 
 /*
 What the fuck I want to implement?
@@ -91,43 +11,83 @@ Both of child classes should trigger the same "core vpn client" module
 
 */
 
-pub struct AndroidClient {
+pub mod general {
-    client_config: ClientConfiguration,
+    use crate::config::ClientConfiguration;
-    fd: i32,
+    use tokio_util::sync::CancellationToken;
-    close_token: CancellationToken
+    use tokio::{net::UdpSocket, sync::{Mutex, mpsc}, io::{BufReader, BufWriter, AsyncWriteExt, AsyncReadExt, AsyncRead, AsyncWrite}, fs::File};
+    use log::{error, info, warn};
+    use aes_gcm::{
+        aead::{Aead, AeadCore, KeyInit, OsRng},
+        Aes256Gcm, Nonce};
+    use base64::prelude::*;
+    use std::{fmt::Error, io::Read, pin, sync::Arc};
+    use std::net::Ipv4Addr;
+    use std::pin::pin;
+    use x25519_dalek::{PublicKey, StaticSecret};
+    use crate::udp::{UDPVpnPacket, UDPVpnHandshake, UDPSerializable};
+    use tun2::{platform::Device, Configuration, DeviceReader, DeviceWriter};
+
+    trait ReadWrapper {
+        async fn read(&mut self, buf: &mut [u8]) -> Result<usize, ()>;
     }
 
-pub struct DesktopClient {
+    pub struct DevReader {
-    client_config: ClientConfiguration,
+        pub dr: DeviceReader
-    s_interface: Option<String>
     }
 
-impl VpnClient for AndroidClient {
+    // TODO: implement custom Error
-    async fn start(&self) {
+    impl ReadWrapper for DevReader {
-        info!("FD: {:?}", &self.fd);
+        async fn read(&mut self, buf: &mut [u8]) -> Result<usize, ()> {
-        let mut dev = unsafe { File::from_raw_fd(self.fd) };
+            let r = self.dr.read(buf).await;
-        let mut dev1 = unsafe { File::from_raw_fd(self.fd) };
+            if let Ok(a) = r {
-        let mut dev_reader = BufReader::new(dev);
+                return Ok(a);
-        let mut dev_writer = BufWriter::new(dev1);
+            }
-        let client = CoreVpnClient{client_config: self.client_config, dev_reader, dev_writer, close_token: self.close_token};
+            Err(())
-        client.start().await;
         }
     }
 
-impl VpnClient for DesktopClient {
+    struct FdReader {
-    async fn start(&self) {
+        br: File
-        info!("s_interface: {:?}", &self.s_interface);
+    }
-        let mut config = tun2::Configuration::default();
-        config.address(&self.client_config.client.address)
-            .netmask("255.255.255.255")
-            .destination("10.66.66.1")
-            .tun_name("tun0")
-            .up();
 
-        let dev = tun2::create(&config).unwrap();
+    impl ReadWrapper for FdReader {
-        let (mut dev_reader, mut dev_writer) = dev.split();
+        async fn read(&mut self, buf: &mut [u8]) -> Result<usize, ()> {
-        let client = CoreVpnClient{ client_config: self.client_config, dev_reader, dev_writer, close_token: tokio_util::sync::CancellationToken::new()};
+            let r = self.br.read(buf).await;
-        client.start().await;
+            if let Ok(a) = r {
+                return Ok(a);
+            }
+            Err(())
+        }
+    }
+
+    trait WriteWrapper {
+        async fn write(&mut self, buf: &[u8]) -> Result<usize, ()>;
+    }
+
+    pub struct DevWriter {
+        pub dr: DeviceWriter
+    }
+
+    // TODO: implement custom Error
+    impl WriteWrapper for DevWriter {
+        async fn write(&mut self, buf: &[u8]) -> Result<usize, ()> {
+            if let Ok(a) = self.dr.write(buf).await {
+                return Ok(a);
+            }
+            Err(())
+        }
+    }
+    
+    struct FdWriter {
+        br: File
+    }
+
+    impl WriteWrapper for FdWriter {
+        async fn write(&mut self, buf: &[u8]) -> Result<usize, ()> {
+            if let Ok(a) = self.br.write(buf).await {
+                return Ok(a);
+            }
+            Err(())
         }
     }
 
@@ -135,20 +95,21 @@ pub trait VpnClient {
         async fn start(&self);
     }
     
-struct CoreVpnClient {
+    pub struct CoreVpnClient<T, R> where T: ReadWrapper, R: WriteWrapper {
-    client_config: ClientConfiguration,
+        pub client_config: ClientConfiguration,
-    dev_reader: Reader,
+        pub dev_reader: T,
-    dev_writer: Writer,
+        pub dev_writer: R,
-    close_token: CancellationToken
+        pub close_token: CancellationToken
     }
 
-impl CoreVpnClient {
+    impl<T: ReadWrapper + std::marker::Sync, R: WriteWrapper + std::marker::Sync> CoreVpnClient<T, R> {
-    pub async fn start(&self) {
+         pub async fn start(&mut self) {
             info!("Starting client...");
     
             let dr_cancel: CancellationToken = CancellationToken::new();
             let sr_cancel: CancellationToken = CancellationToken::new();
             
+            info!("SSS: {:?}", &self.client_config.server.endpoint);
             let sock = UdpSocket::bind("0.0.0.0:25565").await.unwrap();
             sock.connect(&self.client_config.server.endpoint).await.unwrap();
         
@@ -160,7 +121,7 @@ impl CoreVpnClient {
         
             let cipher_shared: Arc<Mutex<Option<x25519_dalek::SharedSecret>>> = Arc::new(Mutex::new(None));
         
-        let dr_cc = dr_cancel.clone();
+           /* let dr_cc = dr_cancel.clone();
             let dev_read_task = tokio::spawn(async move {
                 let mut buf = vec![0; 1400]; // mtu
                 loop {
@@ -177,13 +138,13 @@ impl CoreVpnClient {
                         }
                     };
                 }
-        });
+            });*/
         
-        let priv_key = BASE64_STANDARD.decode(self.client_config.client.private_key).unwrap();
+            let priv_key = BASE64_STANDARD.decode(&self.client_config.client.private_key).unwrap();
             
             let cipher_shared_clone = cipher_shared.clone();
             let sr_cc = sr_cancel.clone();
-        let sock_read_task = tokio::spawn(async move {
+         /* let sock_read_task = tokio::spawn(async move {
                 let mut buf = vec![0; 4096];
         
                 loop {
@@ -236,9 +197,9 @@ impl CoreVpnClient {
                         }
                     };
                 }
-        });
+            });*/
         
-        let pkey = BASE64_STANDARD.decode(self.client_config.client.public_key).unwrap();
+            let pkey = BASE64_STANDARD.decode(&self.client_config.client.public_key).unwrap();
             let handshake = UDPVpnHandshake{ public_key: pkey, request_ip: self.client_config.client.address.parse::<Ipv4Addr>().unwrap() };
             let mut nz = 0;
             while nz < 25 {
@@ -248,6 +209,12 @@ impl CoreVpnClient {
             //sock_snd.send(&handshake.serialize()).await.unwrap();
         
             let s_cipher = cipher_shared.clone();
+    
+            self.dev_writer.write(&handshake.serialize()).await;
+    
+            let mut buf = vec![0; 1400]; // mtu
+            let mut buf1 = vec![0; 4096];
+
             loop {
                 tokio::select! {
                     _ = self.close_token.cancelled() => {
@@ -259,12 +226,12 @@ impl CoreVpnClient {
                     rr = rx.recv() => {
                         if let Some(bytes) = rr {
                             info!("Write to tun.");
-                        if let Err(e) = self.dev_writer.write_all(&bytes).await {
+                            if let Err(e) = self.dev_writer.write(&bytes).await {
                                 error!("Writing error: {:?}", e);
                             }
-                        if let Err(e) = self.dev_writer.flush().await {
+                           /* if let Err(e) = self.dev_writer.flush().await {
                                 error!("Flushing error: {:?}", e);
-                        }
+                            }*/
                         }
                     }
                     rr2 = mx.recv() => {
@@ -289,10 +256,180 @@ impl CoreVpnClient {
                             }
                         }
                     }
+                    rr = self.dev_reader.read(&mut buf) => {
+                        if let Ok(n) = rr {
+                            info!("Read from tun."); // hex::encode(&buf[..n])
+                            dx.send(buf[..n].to_vec()).unwrap();
+                        }
+                    }
+                    rr = sock_rec.recv(&mut buf1) => {
+                        if let Ok(l) = rr {
+                            info!("Read from socket");
+                            let mut s_cipher = cipher_shared_clone.lock().await;
+                            match buf1.first() {
+                                Some(h) => {
+                                    match h {
+                                        0 => {
+                                            let handshake = UDPVpnHandshake::deserialize(&(buf1[..l].to_vec()));
+                                            let mut k = [0u8; 32];
+                                            for (&x, p) in handshake.public_key.iter().zip(k.iter_mut()) {
+                                                *p = x;
+                                            }
+                                            let mut k1 = [0u8; 32];
+                                            for (&x, p) in priv_key.iter().zip(k1.iter_mut()) {
+                                                *p = x;
+                                            }
+                                            *s_cipher = Some(StaticSecret::from(k1)
+                                                .diffie_hellman(&PublicKey::from(k)));
+                                        }, // handshake
+                                        1 => {
+                                            let wrapped_packet = UDPVpnPacket::deserialize(&(buf1[..l].to_vec()));
+                                            if s_cipher.is_some() {
+                                                let aes = Aes256Gcm::new(s_cipher.as_ref().unwrap().as_bytes().into());
+                                                let nonce = Nonce::clone_from_slice(&wrapped_packet.nonce);
+                                                match aes.decrypt(&nonce, &wrapped_packet.data[..]) {
+                                                    Ok(decrypted) => { let _ = tx.send(decrypted); },
+                                                    Err(error) => { error!("Decryption error! {:?}", error); }
+                                                }
+                                            } else {
+                                                warn!("There is no static_secret");
+                                            }
+                                        }, // payload
+                                        2 => { info!("Got keepalive packet"); },
+                                        _ => { error!("Unexpected header value."); }
+                                    }
+                                },
+                                None => { error!("There is no header."); }
+                            }
+                            drop(s_cipher);
+                        }
+                    }
                 };
             }
         }
     }
+}
+
+pub mod android {
+    #![cfg(target_os = "android")]
+    use crate::client::general::{VpnClient, CoreVpnClient};
+    use crate::config::ClientConfiguration;
+    use tokio_util::sync::CancellationToken;
+    use tokio::{net::UdpSocket, sync::{Mutex, mpsc}, io::{BufReader, BufWriter, AsyncWriteExt, AsyncReadExt}, fs::File};
+    use log::{error, info, warn};
+
+    pub struct AndroidClient {
+        client_config: ClientConfiguration,
+        fd: i32,
+        close_token: CancellationToken
+    }
+    
+    impl VpnClient for AndroidClient {
+        async fn start(&self) {
+            info!("FD: {:?}", &self.fd);
+            let mut dev = unsafe { File::from_raw_fd(self.fd) };
+            let mut dev1 = unsafe { File::from_raw_fd(self.fd) };
+            let mut dev_reader = BufReader::new(dev);
+            let mut dev_writer = BufWriter::new(dev1);
+            let client = CoreVpnClient{client_config: self.client_config, dev_reader, dev_writer, close_token: self.close_token};
+            client.start().await;
+        }
+    }
+}
+
+pub mod desktop {
+    use crate::client::general::{CoreVpnClient, DevReader, DevWriter, VpnClient};
+    use crate::config::ClientConfiguration;
+    use log::{error, info, warn};
+    use network_interface::{NetworkInterface, NetworkInterfaceConfig};
+    use tokio::io::BufReader;
+    use std::process::Command;
+    use std::{io::{Read, Write}, net::SocketAddr};
+
+    fn configure_routes(endpoint_ip: &str, s_interface: Option<String>) {
+        let interfaces = NetworkInterface::show().unwrap();
+    
+        let net_inter = interfaces.iter()
+            .filter(|i| !i.addr.iter().any(|b| b.ip().to_string() == "127.0.0.1" || b.ip().to_string() == "::1") )
+            .min_by(|x, y| x.index.cmp(&y.index))
+            .unwrap();
+    
+        let inter_name = if s_interface.is_some() { s_interface.unwrap() } else { net_inter.name.clone() };
+    
+        info!("Main network interface: {:?}", inter_name);
+    
+        /*let mut ip_output = Command::new("sudo")
+            .arg("ip")
+            .arg("route")
+            .arg("del")
+            .arg("default")
+            .output()
+            .expect("Failed to delete default gateway.");
+    
+        if !ip_output.status.success() {
+            error!("Failed to delete default gateway: {:?}", String::from_utf8_lossy(&ip_output.stderr));
+        }*/
+    
+        let mut ip_output = Command::new("sudo")
+            .arg("ip")
+            .arg("-4")
+            .arg("route")
+            .arg("add")
+            .arg("0.0.0.0/0")
+            .arg("dev")
+            .arg("tun0")
+            .output()
+            .expect("Failed to execute ip route command.");
+    
+        if !ip_output.status.success() {
+            error!("Failed to route all traffic: {:?}", String::from_utf8_lossy(&ip_output.stderr));
+        }
+    
+        ip_output = Command::new("sudo")
+            .arg("ip")
+            .arg("route")
+            .arg("add")
+            .arg(endpoint_ip.to_owned()+"/32")
+            .arg("via")
+            .arg("192.168.0.1")
+            .arg("dev")
+            .arg(inter_name)
+            .output()
+            .expect("Failed to make exception for vpns endpoint.");
+    
+        if !ip_output.status.success() {
+            error!("Failed to forward packets: {:?}", String::from_utf8_lossy(&ip_output.stderr));
+        }
+    }
+
+    pub struct DesktopClient {
+        pub client_config: ClientConfiguration,
+        pub s_interface: Option<String>
+    }
+    
+    impl VpnClient for DesktopClient {
+        async fn start(&self) {
+            info!("s_interface: {:?}", &self.s_interface);
+            let mut config = tun2::Configuration::default();
+            config.address(&self.client_config.client.address)
+                .netmask("255.255.255.255")
+                .destination("10.66.66.1")
+                .tun_name("tun0")
+                .up();
+        
+            let dev = tun2::create_as_async(&config).unwrap();
+            let (mut dev_writer, mut dev_reader) = dev.split().unwrap();
+            let mut client = CoreVpnClient{ client_config: self.client_config.clone(), dev_reader: DevReader{ dr: dev_reader }, dev_writer: DevWriter{dr: dev_writer}, close_token: tokio_util::sync::CancellationToken::new()};
+            let s_a: SocketAddr = self.client_config.server.endpoint.parse().unwrap();
+
+            #[cfg(target_os = "linux")]
+            configure_routes(&s_a.ip().to_string(), s_interface);
+
+            client.start().await;
+        }
+    }
+}
+
 
 /*pub async fn client_mode(client_config: ClientConfiguration, s_interface: Option<&str>) {
     info!("Starting client...");

src/config.rs

@@ -6,7 +6,7 @@ use x25519_dalek::{StaticSecret, PublicKey};
 use rand::{rngs::StdRng, SeedableRng};
 use base64::prelude::*;
 
-#[derive(Serialize, Deserialize, PartialEq, Debug)]
+#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
 pub struct ServerInterface {
     pub bind_address: String,
     pub internal_address: String,
@@ -22,7 +22,7 @@ pub struct ServerPeer {
     pub ip: Ipv4Addr
 }
 
-#[derive(Serialize, Deserialize, PartialEq, Debug)]
+#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
 pub enum ObfsProtocol {
     FakeDNS,
     VEIL,
@@ -30,12 +30,12 @@ pub enum ObfsProtocol {
     NONE
 }
 
-#[derive(Serialize, Deserialize, PartialEq, Debug)]
+#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
 pub struct ObfsConfig {
     protocol: ObfsProtocol
 }
 
-#[derive(Serialize, Deserialize, PartialEq, Debug)]
+#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
 pub struct ServerConfiguration {
     pub interface: ServerInterface,
     pub peers: Vec<ServerPeer>,
@@ -62,34 +62,34 @@ impl ServerConfiguration {
     }
 }
 
-#[derive(Serialize, Deserialize, PartialEq, Debug)]
+#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
 pub struct DNSConfig {
     enabled: bool,
     net_name: String,
     entries: Vec<DNSEntry>
 }
 
-#[derive(Serialize, Deserialize, PartialEq, Debug)]
+#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
 pub struct DNSEntry {
     ip: Ipv4Addr,
     subdomain: String
 }
 
-#[derive(Serialize, Deserialize, PartialEq, Debug)]
+#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
 pub struct ClientInterface {
     pub private_key: String,
     pub public_key: String,
     pub address: String
 }
 
-#[derive(Serialize, Deserialize, PartialEq, Debug)]
+#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
 pub struct EndpointInterface {
     pub public_key: String,
     pub endpoint: String,
     pub keepalive: u8
 }
 
-#[derive(Serialize, Deserialize, PartialEq, Debug)]
+#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
 pub struct ClientConfiguration {
     pub client: ClientInterface,
     pub server: EndpointInterface

src/main.rs

@@ -4,14 +4,13 @@ use clap::{App, Arg, ArgMatches};
 use env_logger::Builder;
 use log::{error, LevelFilter};
 use crate::config::{ ServerConfiguration, ClientConfiguration, ObfsProtocol, ServerPeer };
-use crate::client::{DesktopClient, VpnClient};
+use crate::client::{desktop::DesktopClient, general::VpnClient};
 
 mod obfs;
 mod server;
 mod client;
 mod udp;
 mod config;
-mod client_socks;
 
 fn generate_server_config(matches: &ArgMatches, config_path: &str) {
     let bind_address = matches.value_of("bind-address").expect("No bind address specified");
@@ -66,7 +65,7 @@ async fn init_server(cfg_raw: &str, s_interface: Option<&str>) {
     server::server_mode(config, s_interface).await;
 }
 
-async fn init_client(cfg_raw: &str, s_interface: Option<&str>) {
+async fn init_client(cfg_raw: &str, s_interface: Option<String>) {
     let config: ClientConfiguration = serde_yaml::from_str(cfg_raw).expect("Bad client config file structure");
     //client::client_mode(config, s_interface).await;
     let client = DesktopClient{client_config: config, s_interface};
@@ -164,7 +163,7 @@ async fn main() {
 
         match mode {
             "server" => init_server(cfg_raw, matches.value_of("interface")).await,
-            "client" => init_client(cfg_raw, matches.value_of("interface")).await,
+            "client" => init_client(cfg_raw, matches.value_of("interface").map_or(None, |x| Some(String::from(x)))).await,
             "new_peer" => generate_peer_config(&matches, config_path, cfg_raw),
             _ => error!("There is config file already")
         }