Add SOCKS5 Support for SimpleHttpTransport

This adds a new feature flag 'proxy', which converts the regular
`TcpStream` of `SimpleHttpTransport`, in `Socks5Stream`. Which allows
Socks5 procy connection in rpc calls.

 - Builder methods added for proxy params.
 - New `Client::http_proxy()` to create a proxy transport.
 - Update and add tests for proxy.

Author: rajarshimaitra

Cargo.toml

@@ -23,10 +23,13 @@ simple_http = [ "base64" ]
 simple_tcp = []
 # Basic transport over a raw UnixStream
 simple_uds = []
+# Enable Socks5 Proxy in transport
+proxy = ["socks"]
 
 
 [dependencies]
 serde = { version = "1", features = ["derive"] }
 serde_json = { version = "1", features = [ "raw_value" ] }
 
 base64 = { version = "0.13.0", optional = true }
+socks = { version = "0.3.4", optional = true}

contrib/test.sh

@@ -1,6 +1,6 @@
 #!/bin/sh -ex
 
-FEATURES="simple_http simple_tcp simple_uds"
+FEATURES="simple_http simple_tcp simple_uds proxy"
 
 cargo --version
 rustc --version

src/simple_http.rs

@@ -2,7 +2,10 @@
 //! round-tripper that works with the bitcoind RPC server. This can be used
 //! if minimal dependencies are a goal and synchronous communication is ok.
 
+#[cfg(feature = "proxy")]
+use socks::Socks5Stream;
 use std::io::{BufRead, BufReader, Write};
+#[cfg(not(feature = "proxy"))]
 use std::net::TcpStream;
 use std::net::{SocketAddr, ToSocketAddrs};
 use std::time::{Duration, Instant};
@@ -19,6 +22,9 @@ use crate::{Request, Response};
 /// Set to 8332, the default RPC port for bitcoind.
 pub const DEFAULT_PORT: u16 = 8332;
 
+/// The Default SOCKS5 Port to use for proxy connection.
+pub const DEFAULT_PROXY_PORT: u16 = 9050;
+
 /// Simple HTTP transport that implements the necessary subset of HTTP for
 /// running a bitcoind RPC client.
 #[derive(Clone, Debug)]
@@ -28,6 +34,10 @@ pub struct SimpleHttpTransport {
     timeout: Duration,
     /// The value of the `Authorization` HTTP header.
     basic_auth: Option<String>,
+    #[cfg(feature = "proxy")]
+    proxy_addr: net::SocketAddr,
+    #[cfg(feature = "proxy")]
+    proxy_auth: Option<(String, String)>,
 }
 
 impl Default for SimpleHttpTransport {
@@ -40,6 +50,13 @@ impl Default for SimpleHttpTransport {
             path: "/".to_owned(),
             timeout: Duration::from_secs(15),
             basic_auth: None,
+            #[cfg(feature = "proxy")]
+            proxy_addr: net::SocketAddr::new(
+                net::IpAddr::V4(net::Ipv4Addr::new(127, 0, 0, 1)),
+                DEFAULT_PROXY_PORT,
+            ),
+            #[cfg(feature = "proxy")]
+            proxy_auth: None,
         }
     }
 }
@@ -61,6 +78,20 @@ impl SimpleHttpTransport {
     {
         // Open connection
         let request_deadline = Instant::now() + self.timeout;
+        #[cfg(feature = "proxy")]
+        let mut sock = if let Some((username, password)) = &self.proxy_auth {
+            Socks5Stream::connect_with_password(
+                self.proxy_addr,
+                self.addr,
+                username.as_str(),
+                password.as_str(),
+            )?
+            .into_inner()
+        } else {
+            Socks5Stream::connect(self.proxy_addr, self.addr)?.into_inner()
+        };
+
+        #[cfg(not(feature = "proxy"))]
         let mut sock = TcpStream::connect_timeout(&self.addr, self.timeout)?;
 
         sock.set_read_timeout(Some(self.timeout))?;
@@ -365,6 +396,22 @@ impl Builder {
         self
     }
 
+    #[cfg(feature = "proxy")]
+    /// Add proxy address to the transport for SOCKS5 proxy
+    pub fn proxy_addr<S: AsRef<str>>(mut self, proxy_addr: S) -> Result<Self, Error> {
+        // We don't expect path in proxy address.
+        self.tp.proxy_addr = check_url(proxy_addr.as_ref())?.0;
+        Ok(self)
+    }
+
+    #[cfg(feature = "proxy")]
+    /// Add optional proxy authentication as ('username', 'password')
+    pub fn proxy_auth<S: AsRef<str>>(mut self, user: S, pass: S) -> Self {
+        self.tp.proxy_auth =
+            Some((user, pass)).map(|(u, p)| (u.as_ref().to_string(), p.as_ref().to_string()));
+        self
+    }
+
     /// Builds the final `SimpleHttpTransport`
     pub fn build(self) -> SimpleHttpTransport {
         self.tp
@@ -390,11 +437,34 @@ impl crate::Client {
         }
         Ok(crate::Client::with_transport(builder.build()))
     }
+
+    #[cfg(feature = "proxy")]
+    /// Create a new JSON_RPC client using a HTTP-Socks5 proxy transport.
+    pub fn http_proxy(
+        url: &str,
+        user: Option<String>,
+        pass: Option<String>,
+        proxy_addr: &str,
+        proxy_auth: Option<(&str, &str)>,
+    ) -> Result<crate::Client, Error> {
+        let mut builder = Builder::new().url(url)?;
+        if let Some(user) = user {
+            builder = builder.auth(user, pass);
+        }
+        builder = builder.proxy_addr(proxy_addr)?;
+        if let Some((user, pass)) = proxy_auth {
+            builder = builder.proxy_auth(user, pass);
+        }
+        let tp = builder.build();
+        Ok(crate::Client::with_transport(tp))
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use std::net;
+    #[cfg(feature = "proxy")]
+    use std::str::FromStr;
 
     use super::*;
     use crate::Client;
@@ -435,7 +505,14 @@ mod tests {
             "http://[2001:0db8:85a3:0000:0000:8a2e:0370:7334]",
         ];
         for u in &valid_urls {
-            Builder::new().url(*u).unwrap_or_else(|_| panic!("error for: {}", u));
+            let (addr, path) = check_url(u).unwrap();
+            let builder = Builder::new().url(*u).unwrap_or_else(|_| panic!("error for: {}", u));
+            assert_eq!(builder.tp.addr, addr);
+            assert_eq!(builder.tp.path, path);
+            assert_eq!(builder.tp.timeout, Duration::from_secs(15));
+            assert_eq!(builder.tp.basic_auth, None);
+            #[cfg(feature = "proxy")]
+            assert_eq!(builder.tp.proxy_addr, SocketAddr::from_str("127.0.0.1:9050").unwrap());
         }
 
         let invalid_urls = [
@@ -465,4 +542,27 @@ mod tests {
 
         let _ = Client::simple_http("localhost:22", None, None).unwrap();
     }
+
+    #[cfg(feature = "proxy")]
+    #[test]
+    fn construct_with_proxy() {
+        let tp = Builder::new()
+            .timeout(Duration::from_millis(100))
+            .url("localhost:22")
+            .unwrap()
+            .auth("user", None)
+            .proxy_addr("127.0.0.1:9050")
+            .unwrap()
+            .build();
+        let _ = Client::with_transport(tp);
+
+        let _ = Client::http_proxy(
+            "localhost:22",
+            None,
+            None,
+            "127.0.0.1:9050",
+            Some(("user", "password")),
+        )
+        .unwrap();
+    }
 }