Add onion_random_socks_auth

Signed-off-by: Eval EXEC <[email protected]>

Author: eval-exec

tentacle/src/builder.rs

@@ -241,6 +241,13 @@ where
         self
     }
 
+    /// Onion config for tcp
+    #[cfg(not(target_family = "wasm"))]
+    pub fn tcp_onion_random_socks_auth(mut self, onion_random_socks_auth: bool) -> Self {
+        self.config.tcp_config.tcp.onion_random_socks_auth = onion_random_socks_auth;
+        self
+    }
+
     /// The same as tcp config, but use on ws transport
     #[cfg(feature = "ws")]
     #[cfg_attr(docsrs, doc(cfg(feature = "ws")))]

tentacle/src/runtime/proxy/socks5_config.rs

@@ -1,20 +1,39 @@
 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) -> 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)))?;
+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() {
-                "" => None,
+                "" => {
+                    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(),

tentacle/src/runtime/tokio_runtime/mod.rs

@@ -146,11 +146,12 @@ async fn connect_by_proxy<A>(
     target_addr: A,
     socket_transformer: TcpSocketTransformer,
     proxy_url: String,
+    onion_random_socks_auth: bool,
 ) -> io::Result<TcpStream>
 where
     A: Into<shadowsocks::relay::Address>,
 {
-    let socks5_config = socks5_config::parse(&proxy_url)?;
+    let socks5_config = socks5_config::parse(&proxy_url, onion_random_socks_auth)?;
 
     let dial_addr: SocketAddr = socks5_config.proxy_url.parse().map_err(io::Error::other)?;
     let stream = connect_direct(dial_addr, socket_transformer).await?;
@@ -168,10 +169,13 @@ pub(crate) async fn connect(
         socket_transformer,
         proxy_url,
         onion_url: _,
+        onion_random_socks_auth: _,
     } = tcp_config;
 
     match proxy_url {
-        Some(proxy_url) => connect_by_proxy(target_addr, socket_transformer, proxy_url).await,
+        Some(proxy_url) => {
+            connect_by_proxy(target_addr, socket_transformer, proxy_url, false).await
+        }
         None => connect_direct(target_addr, socket_transformer).await,
     }
 }
@@ -184,6 +188,7 @@ pub(crate) async fn connect_onion(
         socket_transformer,
         proxy_url,
         onion_url,
+        onion_random_socks_auth,
     } = tcp_config;
     let onion_url = onion_url.or(proxy_url).ok_or(io::Error::other(
         "need tor proxy server to connect to onion address",
@@ -204,5 +209,11 @@ pub(crate) async fn connect_onion(
     let onion_address =
         shadowsocks::relay::Address::from_str(&onion_str).map_err(std::io::Error::other)?;
 
-    connect_by_proxy(onion_address, socket_transformer, onion_url).await
+    connect_by_proxy(
+        onion_address,
+        socket_transformer,
+        onion_url,
+        onion_random_socks_auth,
+    )
+    .await
 }

tentacle/src/service/config.rs

@@ -124,6 +124,7 @@ pub(crate) struct TcpSocketConfig {
     pub(crate) socket_transformer: TcpSocketTransformer,
     pub(crate) proxy_url: Option<String>,
     pub(crate) onion_url: Option<String>,
+    pub(crate) onion_random_socks_auth: bool,
 }
 
 impl Default for TcpSocketConfig {
@@ -132,6 +133,7 @@ impl Default for TcpSocketConfig {
             socket_transformer: Arc::new(|tcp_socket, _| Ok(tcp_socket)),
             proxy_url: None,
             onion_url: None,
+            onion_random_socks_auth: false,
         }
     }
 }