Vmess WIP

Cargo.Bazel.lock

@@ -1,5 +1,5 @@
 {
-  "checksum": "f267c28d6e0cbe45608f60b117a704c18e3155b38981d0866edb7f1ea5e9fa9b",
+  "checksum": "3e9cefe14ba34202af1b06aa8dc813b02fe4ac0fa0a3022682061695eb3ec7e8",
   "crates": {
     "addr2line 0.20.0": {
       "name": "addr2line",
@@ -2044,7 +2044,7 @@
         "Git": {
           "remote": "https://github.com/Watfaq/boring.git",
           "commitish": {
-            "Branch": "bazel"
+            "Rev": "a5c2442"
           },
           "strip_prefix": "boring"
         }
@@ -2102,7 +2102,7 @@
         "Git": {
           "remote": "https://github.com/Watfaq/boring.git",
           "commitish": {
-            "Branch": "bazel"
+            "Rev": "a5c2442"
           },
           "strip_prefix": "boring-sys"
         }
@@ -7141,7 +7141,7 @@
         "Git": {
           "remote": "https://github.com/Watfaq/boring.git",
           "commitish": {
-            "Branch": "bazel"
+            "Rev": "a5c2442"
           },
           "strip_prefix": "hyper-boring"
         }
@@ -14488,7 +14488,7 @@
         "Git": {
           "remote": "https://github.com/Watfaq/boring.git",
           "commitish": {
-            "Branch": "bazel"
+            "Rev": "a5c2442"
           },
           "strip_prefix": "tokio-boring"
         }

clash_lib/Cargo.toml

@@ -33,10 +33,10 @@ foreign-types-shared = "0.3.1"
 network-interface = "1.0.0"
 base64 = "0.21"
 uuid = { version = "1.2.1", features = ["v4", "fast-rng", "macro-diagnostics"] }
-boring = { git = "https://github.com/Watfaq/boring.git", branch = "bazel" }
-boring-sys = { git = "https://github.com/Watfaq/boring.git", branch = "bazel" }
-hyper-boring = { git = "https://github.com/Watfaq/boring.git", branch = "bazel" }
-tokio-boring = { git = "https://github.com/Watfaq/boring.git", branch = "bazel" }
+boring = { git = "https://github.com/Watfaq/boring.git", rev = "a5c2442" }
+boring-sys = { git = "https://github.com/Watfaq/boring.git", rev = "a5c2442" }
+hyper-boring = { git = "https://github.com/Watfaq/boring.git", rev = "a5c2442" }
+tokio-boring = { git = "https://github.com/Watfaq/boring.git", rev = "a5c2442" }
 crc32fast = "1.3.2"
 brotli = "3.3.4"
 hmac = "0.12.1"

clash_lib/src/app/proxy_manager/providers/proxy_set_provider.rs

@@ -1,7 +1,7 @@
 use std::{collections::HashMap, sync::Arc, time::Duration};
 
 use async_trait::async_trait;
-use futures::{future, TryFutureExt};
+use futures::TryFutureExt;
 use serde::{Deserialize, Serialize};
 use serde_yaml::Value;
 use tokio::sync::Mutex;
@@ -82,6 +82,7 @@ impl ProxySetProvider {
                             OutboundProxyProtocol::Ss(s) => s.try_into(),
                             OutboundProxyProtocol::Socks5(_) => todo!(),
                             OutboundProxyProtocol::Trojan(_) => todo!(),
+                            OutboundProxyProtocol::Vmess(_) => todo!(),
                         })
                         .collect::<Result<Vec<_>, _>>();
                     Ok(proxies?)

clash_lib/src/config/internal/proxy.rs

@@ -50,6 +50,8 @@ pub enum OutboundProxyProtocol {
     Socks5(OutboundSocks5),
     #[serde(rename = "trojan")]
     Trojan(OutboundTrojan),
+    #[serde(rename = "vmess")]
+    Vmess(OutboundVmess),
 }
 
 impl OutboundProxyProtocol {
@@ -60,6 +62,7 @@ impl OutboundProxyProtocol {
             OutboundProxyProtocol::Ss(ss) => &ss.name,
             OutboundProxyProtocol::Socks5(socks5) => &socks5.name,
             OutboundProxyProtocol::Trojan(trojan) => &trojan.name,
+            OutboundProxyProtocol::Vmess(vmess) => &vmess.name,
         }
     }
 }
@@ -81,6 +84,7 @@ impl Display for OutboundProxyProtocol {
             OutboundProxyProtocol::Direct => write!(f, "{}", PROXY_DIRECT),
             OutboundProxyProtocol::Reject => write!(f, "{}", PROXY_REJECT),
             OutboundProxyProtocol::Trojan(_) => write!(f, "{}", "Trojan"),
+            OutboundProxyProtocol::Vmess(_) => write!(f, "{}", "Vmess"),
         }
     }
 }
@@ -137,6 +141,22 @@ pub struct OutboundTrojan {
     pub ws_opts: Option<WsOpt>,
 }
 
+#[derive(serde::Serialize, serde::Deserialize, Debug, Default)]
+pub struct OutboundVmess {
+    pub name: String,
+    pub server: String,
+    pub port: u16,
+    pub uuid: String,
+    pub alter_id: u16,
+    pub cipher: String,
+    pub udp: bool,
+    pub tls: bool,
+    pub skip_cert_verify: bool,
+    pub server_name: Option<String>,
+    pub network: Option<String>,
+    pub ws_opts: Option<WsOpt>,
+}
+
 #[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
 #[serde(tag = "type")]
 pub enum OutboundGroupProtocol {

clash_lib/src/proxy/mod.rs

@@ -21,7 +21,7 @@ pub mod shadowsocks;
 pub mod socks;
 //pub mod trojan;
 pub mod utils;
-//pub mod vmess;
+pub mod vmess;
 
 pub mod converters;
 

clash_lib/src/proxy/shadowsocks/datagram.rs

@@ -142,6 +142,7 @@ impl Sink<UdpPacket> for OutboundDatagramShadowsocks {
         Poll::Ready(Ok(()))
     }
 }
+
 impl Stream for OutboundDatagramShadowsocks {
     type Item = UdpPacket;
 

clash_lib/src/proxy/vmess/mod.rs

@@ -6,7 +6,11 @@ use http::Uri;
 
 mod vmess_impl;
 
-use crate::{app::ThreadSafeDNSResolver, session::Session};
+use crate::{
+    app::ThreadSafeDNSResolver,
+    config::internal::proxy::{OutboundProxy, OutboundProxyProtocol},
+    session::{Session, SocksAddr},
+};
 
 use super::{
     transport::{self, Http2Config},
@@ -77,13 +81,29 @@ impl OutboundHandler for Handler {
         &self.opts.name
     }
 
+    /// The protocol of the outbound handler
+    /// only contains Type information, do not rely on the underlying value
+    fn proto(&self) -> OutboundProxy {
+        OutboundProxy::ProxyServer(OutboundProxyProtocol::Vmess(Default::default()))
+    }
+
+    /// The proxy remote address
+    async fn remote_addr(&self) -> Option<SocksAddr> {
+        Some(SocksAddr::Domain(self.opts.server.clone(), self.opts.port))
+    }
+
+    /// whether the outbound handler support UDP
+    async fn support_udp(&self) -> bool {
+        self.opts.udp
+    }
+
     async fn connect_stream(
         &self,
         sess: &Session,
         resolver: ThreadSafeDNSResolver,
     ) -> io::Result<AnyStream> {
-        let mut stream = new_tcp_stream(
-            resolver,
+        let stream = new_tcp_stream(
+            resolver.clone(),
             self.opts.server.as_str(),
             self.opts.port,
             self.opts.common_opts.iface.as_ref(),
@@ -99,6 +119,18 @@ impl OutboundHandler for Handler {
         })
         .await?;
 
+        self.proxy_stream(stream, sess, resolver).await
+    }
+
+    /// wraps a stream with outbound handler
+    async fn proxy_stream(
+        &self,
+        s: AnyStream,
+        sess: &Session,
+        resolver: ThreadSafeDNSResolver,
+    ) -> io::Result<AnyStream> {
+        let mut stream = s;
+
         let underlying = match self.opts.transport {
             Some(VmessTransport::Ws(ref opt)) => {
                 let uri = format!("ws://{}:{}{}", self.opts.server, self.opts.port, opt.path)
@@ -169,7 +201,6 @@ impl OutboundHandler for Handler {
 
         vmess_builder.proxy_stream(underlying).await
     }
-
     async fn connect_datagram(
         &self,
         sess: &Session,