remove shadowsocks, use fast-socks5

Signed-off-by: Eval EXEC <execvy@gmail.com>

Author: eval-exec

multiaddr/src/onion_addr.rs

@@ -1,5 +1,7 @@
 use std::{borrow::Cow, fmt};
 
+use data_encoding::BASE32;
+
 /// Represents an Onion v3 address
 #[derive(Clone)]
 pub struct Onion3Addr<'a>(Cow<'a, [u8; 35]>, u16);
@@ -19,6 +21,11 @@ impl<'a> Onion3Addr<'a> {
     pub fn acquire<'b>(self) -> Onion3Addr<'b> {
         Onion3Addr(Cow::Owned(self.0.into_owned()), self.1)
     }
+
+    pub fn hash_string(&self) -> String {
+        let s = BASE32.encode(self.hash());
+        s.to_lowercase()
+    }
 }
 
 impl PartialEq for Onion3Addr<'_> {

multiaddr/src/protocol.rs

@@ -273,8 +273,7 @@ impl<'a> fmt::Display for Protocol<'a> {
             Wss => write!(f, "/wss"),
             Memory(port) => write!(f, "/memory/{}", port),
             Onion3(addr) => {
-                let s = BASE32.encode(addr.hash());
-                write!(f, "/onion3/{}:{}", s.to_lowercase(), addr.port())
+                write!(f, "/onion3/{}:{}", addr.hash_string(), addr.port())
             }
         }
     }

tentacle/Cargo.toml

@@ -44,12 +44,12 @@ igd = { version = "0.15", optional = true, package = "igd-next" }
 
 #tls
 tokio-rustls = { version = "0.26.0", optional = true }
+fast-socks5 = "0.10.0"
 
 [target.'cfg(not(target_family = "wasm"))'.dependencies]
 # rand 0.8 not support wasm32
 rand = "0.8"
 socket2 = { version = "0.5.0", features = ["all"] }
-shadowsocks = { version = "1.21.0", default-features = false }
 url = "2.5.4"
 
 [target.'cfg(target_family = "wasm")'.dependencies]

tentacle/src/builder.rs

@@ -227,16 +227,27 @@ where
         self
     }
 
+    fn must_parse_proxy_url(url: String) -> url::Url {
+        let url = url::Url::parse(&url)
+            .unwrap_or_else(|err| panic!("parse {} to url::Url failed: {}", url, err));
+        if url.scheme().ne("socks5") {
+            panic!("tentacle only support socks5 proxy");
+        }
+        url
+    }
+
     /// Proxy config for tcp
     #[cfg(not(target_family = "wasm"))]
     pub fn tcp_proxy_config(mut self, proxy_url: String) -> Self {
+        let proxy_url: url::Url = Self::must_parse_proxy_url(proxy_url);
         self.config.tcp_config.tcp.proxy_url = Some(proxy_url);
         self
     }
 
     /// Onion config for tcp
     #[cfg(not(target_family = "wasm"))]
     pub fn tcp_onion_config(mut self, onion_url: String) -> Self {
+        let onion_url: url::Url = Self::must_parse_proxy_url(onion_url);
         self.config.tcp_config.tcp.onion_url = Some(onion_url);
         self
     }

tentacle/src/runtime/proxy/socks5.rs

@@ -1,81 +1,35 @@
-use std::io;
-
-use log::debug;
-use shadowsocks::relay::socks5::{
-    self, Address, Command, Error as Socks5Error, HandshakeRequest, HandshakeResponse,
-    PasswdAuthRequest, PasswdAuthResponse, Reply, TcpRequestHeader, TcpResponseHeader,
+use fast_socks5::{
+    client::{Config as ConnectConfig, Socks5Stream},
+    AuthenticationMethod, Socks5Command,
 };
-use tokio::io::{AsyncRead, AsyncWrite};
-
-use super::socks5_config::Socks5Config;
-
-pub async fn establish_connection<S, A>(
-    mut s: S,
-    target_addr: A,
-    socks5_config: Socks5Config,
-) -> Result<S, Socks5Error>
-where
-    S: AsyncRead + AsyncWrite + Unpin,
-    A: Into<Address>,
-{
-    debug!(
-        "client connecting proxy server: config {}, with auth: {}",
-        socks5_config.proxy_url,
-        socks5_config.auth.is_some()
-    );
-    // destruct socks5_config
-    let Socks5Config { auth, proxy_url: _ } = socks5_config;
-
-    // 1. Handshake
-    let hs = {
-        if auth.is_some() {
-            HandshakeRequest::new(vec![socks5::SOCKS5_AUTH_METHOD_PASSWORD])
+use tokio::net::TcpStream;
+
+pub async fn connect(
+    socks_server: url::Url,
+    target_addr: String,
+    target_port: u16,
+) -> Result<TcpStream, fast_socks5::SocksError> {
+    let auth = {
+        if let Some(password) = socks_server.password() {
+            AuthenticationMethod::Password {
+                username: socks_server.username().to_string(),
+                password: password.to_string(),
+            }
         } else {
-            HandshakeRequest::new(vec![socks5::SOCKS5_AUTH_METHOD_NONE])
+            AuthenticationMethod::None
         }
     };
-    debug!("client connected, going to send handshake: {:?}", hs);
-
-    hs.write_to(&mut s).await?;
-
-    let hsp = HandshakeResponse::read_from(&mut s).await?;
-
-    debug!("got handshake response: {:?}", hsp);
-    match hsp.chosen_method {
-        socks5::SOCKS5_AUTH_METHOD_NONE => (),
-        socks5::SOCKS5_AUTH_METHOD_PASSWORD => {
-            if let Some((uname, passwd)) = auth {
-                let pr = PasswdAuthRequest::new(uname, passwd);
-                pr.write_to(&mut s).await?;
-                let prp = PasswdAuthResponse::read_from(&mut s).await?;
-                match Reply::from_u8(prp.status) {
-                    Reply::Succeeded => debug!("password auth succeeded"),
-                    r => return Err(Socks5Error::Reply(r)),
-                }
-            } else {
-                return Err(Socks5Error::PasswdAuthInvalidRequest);
-            }
-        }
-        _ => {
-            return Err(Socks5Error::IoError(io::Error::other(format!(
-                "unsupported auth method: {}",
-                hsp.chosen_method
-            ))))
-        }
-    }
-
-    // 2. Send request header
-    let h = TcpRequestHeader::new(Command::TcpConnect, target_addr.into());
-    debug!("going to connect, req: {:?}", h);
-    h.write_to(&mut s).await?;
-
-    let hp = TcpResponseHeader::read_from(&mut s).await?;
-
-    debug!("got response: {:?}", hp);
-    match hp.reply {
-        Reply::Succeeded => (),
-        r => return Err(Socks5Error::Reply(r)),
-    }
-
-    Ok(s)
+    let socks_server_host = socks_server.host_str().ok_or_else(|| {
+        fast_socks5::SocksError::ArgumentInputError("socks_server should have host")
+    })?;
+    Socks5Stream::connect_raw(
+        Socks5Command::TCPConnect,
+        socks_server_host,
+        target_addr,
+        target_port,
+        Some(auth),
+        ConnectConfig::default(),
+    )
+    .await
+    .map(|socket| socket.get_socket())
 }

tentacle/src/runtime/proxy/socks5_config.rs

@@ -1,56 +1,15 @@
-use std::io;
-
 use rand::Rng;
 
-#[derive(Debug)]
-pub(crate) struct Socks5Config {
-    pub(crate) proxy_url: String,
-    pub(crate) auth: Option<(String, String)>,
-}
-
-// parse proxy url like "socks5://username:password@localhost:1080" to Socks5Config
-pub(crate) fn parse(proxy_url: &str, onion_random_socks_auth: bool) -> io::Result<Socks5Config> {
-    let parsed_url = url::Url::parse(proxy_url).map_err(|err| {
-        io::Error::other(format!("parse proxy_url {} failed, {}", proxy_url, err))
-    })?;
-    let scheme = parsed_url.scheme();
-    match scheme {
-        "socks5" => {
-            let auth = match parsed_url.username() {
-                "" => {
-                    if onion_random_socks_auth {
-                        let username = rand::thread_rng()
-                            .sample_iter(&rand::distributions::Alphanumeric)
-                            .take(8)
-                            .map(char::from)
-                            .collect();
-                        let password = rand::thread_rng()
-                            .sample_iter(&rand::distributions::Alphanumeric)
-                            .take(16)
-                            .map(char::from)
-                            .collect();
-                        Some((username, password))
-                    } else {
-                        None
-                    }
-                }
-                username => Some((
-                    username.to_string(),
-                    parsed_url.password().unwrap_or("").to_string(),
-                )),
-            };
-            let port = parsed_url.port().ok_or(io::Error::other("missing port"))?;
-            let proxy_url = String::new()
-                + parsed_url
-                    .host_str()
-                    .ok_or(io::Error::other("missing host"))?
-                + ":"
-                + &format!("{port}");
-            Ok(Socks5Config { proxy_url, auth })
-        }
-        _ => Err(io::Error::other(format!(
-            "tentacle doesn't support proxy scheme: {}",
-            scheme
-        ))),
-    }
+pub(crate) fn random_auth() -> (String, String) {
+    let username = rand::thread_rng()
+        .sample_iter(&rand::distributions::Alphanumeric)
+        .take(8)
+        .map(char::from)
+        .collect();
+    let password = rand::thread_rng()
+        .sample_iter(&rand::distributions::Alphanumeric)
+        .take(16)
+        .map(char::from)
+        .collect();
+    (username, password)
 }