new

Cargo.lock

@@ -113,6 +113,56 @@ dependencies = [
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "crossbeam"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1137cd7e7fc0fb5d3c5a8678be38ec56e819125d8d7907411fe24ccb943faca8"
+dependencies = [
+ "crossbeam-channel",
+ "crossbeam-deque",
+ "crossbeam-epoch",
+ "crossbeam-queue",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06ba6d68e24814cb8de6bb986db8222d3a027d15872cabc0d18817bc3c0e4471"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-queue"
+version = "0.3.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f58bbc28f91df819d0aa2a2c00cd19754769c2fad90579b3592b1c9ba7a3115"
+dependencies = [
+ "crossbeam-utils",
+]
+
 [[package]]
 name = "crossbeam-utils"
 version = "0.8.20"
@@ -612,6 +662,8 @@ name = "tun1"
 version = "0.1.0"
 dependencies = [
  "base64",
+ "crossbeam",
+ "crossbeam-utils",
  "lazy_static",
  "pnet",
  "pnet_macros",

Cargo.toml

@@ -12,3 +12,5 @@ serde = { version = "1.0.217", features = ["derive"] }
 serde_json = "1.0"
 base64 = "0.22.1"
 lazy_static = "1.5.0"
+crossbeam = "0.8.4"
+crossbeam-utils = "0.8.20"

src/config.rs

-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct ConfigRouter {
-    pub remote_id: u8,
-    pub proto: i32,
-    pub family: u8,
-    pub mark: u32,
-    pub endpoint: String,
-    pub remote_secret: String,
-    pub dev: String,
-    pub up: String,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Config {
-    pub local_id: u8,
-    pub local_secret: String,
-    pub routers: Vec<ConfigRouter>,
-}
\ No newline at end of file

src/Router.rs → src/router.rs

-use std::collections::HashMap;
-use crate::config::ConfigRouter;
 use socket2::{Domain, Protocol, SockAddr, Socket, Type};
-use std::process::{Command, ExitStatus};
-use tun::{Device, Reader, Writer};
-const SECRET_LENGTH: usize = 32;
+use std::collections::hash_map::Entry;
+use std::collections::HashMap;
+use std::net::ToSocketAddrs;
+use std::process::Command;
+use std::sync::Arc;
+use tun::{Reader, Writer};
+pub const SECRET_LENGTH: usize = 32;
+use crate::ConfigRouter;
 use base64::prelude::*;
-use lazy_static::lazy_static;
-
-lazy_static! {
-    static ref sockets: HashMap<u16, Socket> = {
-        HashMap::new()
-    };
-}
 
 pub struct Router {
-    pub config: ConfigRouter,
+    pub config: &'static ConfigRouter,
     pub secret: [u8; SECRET_LENGTH],
-    pub remote_addr: Option<SockAddr>,
+    pub endpoint: Option<SockAddr>,
     pub tun_reader: Reader,
     pub tun_writer: Writer,
-    pub socket: Socket,
+    pub socket: Arc<Socket>,
 }
 
 impl Router {
-    fn create_secret(
-        config: &ConfigRouter,
+    pub(crate) fn create_secret(
+        config: &str,
     ) -> Result<[u8; SECRET_LENGTH], Box<dyn std::error::Error>> {
         let mut secret = [0u8; SECRET_LENGTH];
-        let decoded = BASE64_STANDARD.decode(config.remote_secret.as_str())?;
+        let decoded = BASE64_STANDARD.decode(config)?;
         let len = decoded.len().min(SECRET_LENGTH);
         secret[..len].copy_from_slice(&decoded[..len]);
         Ok(secret)
     }
-    fn create_raw_socket(config: &ConfigRouter) -> Result<Socket, Box<dyn std::error::Error>> {
+    fn create_raw_socket(
+        config: &ConfigRouter,
+        sockets: &mut HashMap<u16, Arc<Socket>>,
+    ) -> Result<Arc<Socket>, Box<dyn std::error::Error>> {
         let key = (config.family as u16) << 8 | config.proto as u16;
-        match sockets.get(&key) {
-            Some(socket) => println!("{book}: {review}"),
-            None => println!("{book} is unreviewed.")
-        }
-
-
-        let socket = Socket::new(
-            if config.family == 6 {
-                Domain::IPV6
-            } else {
-                Domain::IPV4
-            },
-            Type::RAW,
-            Some(Protocol::from(config.proto)),
-        )?;
-        Ok(socket)
+        let result = match sockets.entry(key) {
+            Entry::Occupied(entry) => entry.get().clone(),
+            Entry::Vacant(entry) => entry
+                .insert(Arc::new(Socket::new(
+                    if config.family == 6 {
+                        Domain::IPV6
+                    } else {
+                        Domain::IPV4
+                    },
+                    Type::RAW,
+                    Some(Protocol::from(config.proto)),
+                )?))
+                .clone(),
+        };
+        Ok(result)
     }
     fn create_tun_device(
         config: &ConfigRouter,
@@ -64,16 +62,28 @@ impl Router {
         Command::new(config.up.as_str()).status()?;
         Ok(())
     }
-    pub fn new(config: ConfigRouter) -> Result<Router, Box<dyn std::error::Error>> {
-        let secret = Self::create_secret(&config)?;
-        let socket = Self::create_raw_socket(&config)?;
+
+    fn create_endpoint(
+        config: &ConfigRouter,
+    ) -> Result<Option<SockAddr>, Box<dyn std::error::Error>> {
+        let parsed = config.endpoint.to_socket_addrs()?.next().unwrap();
+        Ok(Some(parsed.into()))
+    }
+
+    pub fn new(
+        config: &'static ConfigRouter,
+        sockets: &mut HashMap<u16, Arc<Socket>>,
+    ) -> Result<Router, Box<dyn std::error::Error>> {
+        let secret = Self::create_secret(config.remote_secret.as_str())?;
+        let endpoint = Self::create_endpoint(&config)?;
+        let socket = Self::create_raw_socket(&config, sockets)?;
         let (tun_reader, tun_writer) = Self::create_tun_device(&config)?;
         Self::run_up_script(&config)?;
 
         let router = Router {
             config,
             secret,
-            remote_addr: None,
+            endpoint,
             tun_reader,
             tun_writer,
             socket,
@@ -81,4 +91,13 @@ impl Router {
 
         Ok(router)
     }
+
+    pub(crate) fn encrypt(&self, data: &mut [u8]) {
+        for (i, b) in data.iter_mut().enumerate() {
+            *b ^= self.secret[i % SECRET_LENGTH];
+        }
+    }
+    pub(crate) fn decrypt(&self, data: &mut [u8]) {
+        self.encrypt(data);
+    }
 }