new

Cargo.lock

@@ -41,6 +41,12 @@ version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
 
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
 [[package]]
 name = "bitflags"
 version = "2.6.0"
@@ -260,6 +266,18 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "itoa"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d75a2a4b1b190afb6f5425f10f6a8f959d2ea0b9c2b1d79553551850539e4674"
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
 [[package]]
 name = "libc"
 version = "0.2.167"
@@ -473,6 +491,12 @@ version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
+[[package]]
+name = "ryu"
+version = "1.0.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ea1a2d0a644769cc99faa24c3ad26b379b786fe7c36fd3c546254801650e6dd"
+
 [[package]]
 name = "serde"
 version = "1.0.217"
@@ -493,6 +517,18 @@ dependencies = [
  "syn 2.0.90",
 ]
 
+[[package]]
+name = "serde_json"
+version = "1.0.138"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d434192e7da787e94a6ea7e9670b26a036d0ca41e0b7efb2676dd32bae872949"
+dependencies = [
+ "itoa",
+ "memchr",
+ "ryu",
+ "serde",
+]
+
 [[package]]
 name = "slab"
 version = "0.4.9"
@@ -575,8 +611,12 @@ dependencies = [
 name = "tun1"
 version = "0.1.0"
 dependencies = [
+ "base64",
+ "lazy_static",
  "pnet",
  "pnet_macros",
+ "serde",
+ "serde_json",
  "socket2",
  "tun",
 ]

Cargo.toml

@@ -8,3 +8,7 @@ tun = "0.7"
 socket2 = { version = "0.5.8", features = ["all"] }
 pnet = "0.35.0"
 pnet_macros = "0.35.0"
+serde = { version = "1.0.217", features = ["derive"] }
+serde_json = "1.0"
+base64 = "0.22.1"
+lazy_static = "1.5.0"

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 base64::prelude::*;
+use lazy_static::lazy_static;
+
+lazy_static! {
+    static ref sockets: HashMap<u16, Socket> = {
+        HashMap::new()
+    };
+}
+
+pub struct Router {
+    pub config: ConfigRouter,
+    pub secret: [u8; SECRET_LENGTH],
+    pub remote_addr: Option<SockAddr>,
+    pub tun_reader: Reader,
+    pub tun_writer: Writer,
+    pub socket: Socket,
+}
+
+impl Router {
+    fn create_secret(
+        config: &ConfigRouter,
+    ) -> 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 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>> {
+        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)
+    }
+    fn create_tun_device(
+        config: &ConfigRouter,
+    ) -> Result<(Reader, Writer), Box<dyn std::error::Error>> {
+        let mut tun_config = tun::Configuration::default();
+        tun_config.tun_name(config.dev.as_str()).up();
+
+        let dev = tun::create(&tun_config)?;
+        Ok(dev.split())
+    }
+    fn run_up_script(config: &ConfigRouter) -> Result<(), Box<dyn std::error::Error>> {
+        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)?;
+        let (tun_reader, tun_writer) = Self::create_tun_device(&config)?;
+        Self::run_up_script(&config)?;
+
+        let router = Router {
+            config,
+            secret,
+            remote_addr: None,
+            tun_reader,
+            tun_writer,
+            socket,
+        };
+
+        Ok(router)
+    }
+}

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/main.rs

+mod config;
+mod Router;
+
 use pnet::packet::ipv4::Ipv4Packet;
 use socket2::{Domain, Protocol, Socket, Type};
 use std::error::Error;
@@ -7,6 +10,7 @@ use std::net::ToSocketAddrs;
 use std::process::Command;
 use std::sync::{Arc, RwLock};
 use std::{env, thread};
+use crate::config::Config;
 
 #[repr(C)]
 pub struct Meta {
@@ -36,6 +40,10 @@ impl Secret {
 }
 
 fn main() -> Result<(), Box<dyn Error>> {
+    
+    let data = env::args().nth(0).unwrap();
+    let config: Config = serde_json::from_str(data.as_str())?;
+    
     let local_id: u8 = env::var("LOCAL_ID")?.parse()?;
     let remote_id: u8 = env::var("REMOTE_ID")?.parse()?;
     let local_secret = Secret::new(&env::var("LOCAL_SECRET")?);
@@ -57,11 +65,7 @@ fn main() -> Result<(), Box<dyn Error>> {
         Err(_) => None,
     }));
 
-    let mut config = tun::Configuration::default();
-    config.tun_name(dev).up();
     
-    let dev = tun::create(&config)?;
-    let (mut reader, mut writer) = dev.split();
 
     // Create a raw socket with protocol number 144
     let socket = Socket::new(family, Type::RAW, Some(Protocol::from(proto)))?;