lib: remove arti dependency in favor of tor proxy

Author: rustaceanrob

Cargo.lock

@@ -31,18 +31,10 @@ tokio = { version = "1", default-features = false, features = [
 
 # Optional dependencies
 rusqlite = { version = "0.31.0", features = ["bundled"], optional = true }
-arti-client = { version = "0.21.0", features = [
-    "rustls",
-    "tokio",
-    "onion-service-client",
-    "experimental-api",
-], default-features = false, optional = true }
-tor-rtcompat = { version = "0.21.0", features = ["tokio"], optional = true }
 
 [features]
 default = ["database"]
 database = ["rusqlite"]
-tor = ["arti-client", "tor-rtcompat"]
 filter-control = []
 
 [dev-dependencies]

Cargo.toml

@@ -15,7 +15,7 @@ use crate::{
     chain::checkpoints::HeaderCheckpoint,
     db::traits::{HeaderStore, PeerStore},
 };
-use crate::{ConnectionType, FilterSyncPolicy, LogLevel, PeerStoreSizeConfig, TrustedPeer};
+use crate::{FilterSyncPolicy, LogLevel, PeerStoreSizeConfig, TrustedPeer};
 
 #[cfg(feature = "database")]
 /// The default node returned from the [`NodeBuilder`](crate::core).
@@ -149,12 +149,6 @@ impl NodeBuilder {
         self
     }
 
-    /// Set the desired communication channel. Either directly over TCP or over the Tor network.
-    pub fn connection_type(mut self, connection_type: ConnectionType) -> Self {
-        self.config.connection_type = connection_type;
-        self
-    }
-
     /// Set the time duration a peer has to respond to a message from the local node.
     ///
     /// ## Note

example/tor.rs

@@ -3,7 +3,8 @@ use std::{collections::HashSet, path::PathBuf, time::Duration};
 use bitcoin::ScriptBuf;
 
 use crate::{
-    chain::checkpoints::HeaderCheckpoint, network::dns::DnsResolver, ConnectionType,
+    chain::checkpoints::HeaderCheckpoint,
+    network::{dns::DnsResolver, ConnectionType},
     FilterSyncPolicy, LogLevel, PeerStoreSizeConfig, TrustedPeer,
 };
 

src/builder.rs

@@ -116,11 +116,6 @@ use std::collections::HashSet;
 
 use std::net::{IpAddr, SocketAddr};
 
-#[cfg(feature = "tor")]
-pub use arti_client::{TorClient, TorClientConfig};
-#[cfg(feature = "tor")]
-use tor_rtcompat::PreferredRuntime;
-
 // Re-exports
 #[doc(inline)]
 pub use chain::checkpoints::{
@@ -320,21 +315,6 @@ impl TrustedPeer {
         }
     }
 
-    /// Create a new peer from a TorV3 service and port.
-    #[cfg(feature = "tor")]
-    pub fn new_from_tor_v3(
-        public_key: [u8; 32],
-        port: Option<u16>,
-        services: ServiceFlags,
-    ) -> Self {
-        let address = AddrV2::TorV3(public_key);
-        Self {
-            address,
-            port,
-            known_services: services,
-        }
-    }
-
     /// Create a new trusted peer using the default port for the network.
     pub fn from_ip(ip_addr: impl Into<IpAddr>) -> Self {
         let address = match ip_addr.into() {
@@ -362,17 +342,6 @@ impl TrustedPeer {
         }
     }
 
-    /// Create a new peer from a TorV3 service.
-    #[cfg(feature = "tor")]
-    pub fn from_tor_v3(public_key: [u8; 32]) -> Self {
-        let address = AddrV2::TorV3(public_key);
-        Self {
-            address,
-            port: None,
-            known_services: ServiceFlags::NONE,
-        }
-    }
-
     /// The IP address of the trusted peer.
     pub fn address(&self) -> AddrV2 {
         self.address.clone()
@@ -422,18 +391,6 @@ impl From<SocketAddr> for TrustedPeer {
     }
 }
 
-/// How to connect to peers on the peer-to-peer network
-#[derive(Default, Clone)]
-#[non_exhaustive]
-pub enum ConnectionType {
-    /// Version one peer-to-peer connections
-    #[default]
-    ClearNet,
-    /// Connect to peers over Tor
-    #[cfg(feature = "tor")]
-    Tor(TorClient<PreferredRuntime>),
-}
-
 /// Configure how many peers will be stored.
 #[derive(Debug, Default, Clone)]
 pub enum PeerStoreSizeConfig {

src/config.rs

@@ -1,10 +1,18 @@
+use std::{net::IpAddr, time::Duration};
+
 use bitcoin::{
     consensus::Decodable,
     io::Read,
-    p2p::{message::CommandString, Magic},
+    p2p::{address::AddrV2, message::CommandString, Magic},
+};
+use tokio::{
+    io::{AsyncRead, AsyncWrite},
+    net::TcpStream,
+    sync::Mutex,
+    time::Instant,
 };
-use std::time::Duration;
-use tokio::time::Instant;
+
+use error::PeerError;
 
 pub(crate) mod counter;
 pub(crate) mod dns;
@@ -16,14 +24,17 @@ pub(crate) mod peer;
 pub(crate) mod peer_map;
 #[allow(dead_code)]
 pub(crate) mod reader;
-#[cfg(feature = "tor")]
-pub(crate) mod tor;
+pub(crate) mod socks;
 pub(crate) mod traits;
 
 pub const PROTOCOL_VERSION: u32 = 70016;
 pub const KYOTO_VERSION: &str = "0.8.0";
 pub const RUST_BITCOIN_VERSION: &str = "0.32.4";
 const THIRTY_MINS: u64 = 60 * 30;
+const CONNECTION_TIMEOUT: u64 = 2;
+
+pub(crate) type StreamReader = Mutex<Box<dyn AsyncRead + Send + Unpin>>;
+pub(crate) type StreamWriter = Mutex<Box<dyn AsyncWrite + Send + Unpin>>;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub(crate) struct PeerId(pub(crate) u32);
@@ -86,6 +97,47 @@ impl LastBlockMonitor {
     }
 }
 
+#[derive(Debug, Clone, Copy, Default)]
+pub(crate) enum ConnectionType {
+    #[default]
+    ClearNet,
+    Socks5Proxy(IpAddr),
+}
+
+impl ConnectionType {
+    pub(crate) fn can_connect(&self, addr: &AddrV2) -> bool {
+        match &self {
+            &Self::ClearNet => matches!(addr, AddrV2::Ipv4(_) | AddrV2::Ipv6(_)),
+            &Self::Socks5Proxy(_) => matches!(addr, AddrV2::Ipv4(_) | AddrV2::Ipv6(_)),
+        }
+    }
+
+    pub(crate) async fn connect(
+        &self,
+        addr: AddrV2,
+        port: u16,
+    ) -> Result<(StreamReader, StreamWriter), PeerError> {
+        let socket_addr = match addr {
+            AddrV2::Ipv4(ip) => IpAddr::V4(ip),
+            AddrV2::Ipv6(ip) => IpAddr::V6(ip),
+            _ => return Err(PeerError::UnreachableSocketAddr),
+        };
+        let timeout = tokio::time::timeout(
+            Duration::from_secs(CONNECTION_TIMEOUT),
+            TcpStream::connect((socket_addr, port)),
+        )
+        .await
+        .map_err(|_| PeerError::ConnectionFailed)?;
+        match timeout {
+            Ok(stream) => {
+                let (reader, writer) = stream.into_split();
+                Ok((Mutex::new(Box::new(reader)), Mutex::new(Box::new(writer))))
+            }
+            Err(_) => Err(PeerError::ConnectionFailed),
+        }
+    }
+}
+
 pub(crate) struct V1Header {
     magic: Magic,
     _command: CommandString,

src/lib.rs

@@ -8,8 +8,8 @@ use tokio::io::AsyncReadExt;
 use crate::prelude::FutureResult;
 
 use super::error::PeerReadError;
-use super::traits::{MessageParser, StreamReader};
 use super::V1Header;
+use super::{traits::MessageParser, StreamReader};
 
 const MAX_MESSAGE_BYTES: u32 = 1024 * 1024 * 32;
 

src/network/mod.rs

@@ -23,17 +23,11 @@ use crate::{
 };
 
 use super::{
-    counter::MessageCounter,
-    error::PeerError,
-    parsers::V1MessageParser,
-    reader::Reader,
-    traits::{MessageGenerator, StreamReader, StreamWriter},
-    PeerId, PeerTimeoutConfig,
+    counter::MessageCounter, error::PeerError, parsers::V1MessageParser, reader::Reader,
+    traits::MessageGenerator, PeerId, PeerTimeoutConfig, StreamReader, StreamWriter,
 };
 
-#[cfg(not(feature = "tor"))]
 use super::outbound_messages::V2OutboundMessage;
-#[cfg(not(feature = "tor"))]
 use super::parsers::V2MessageParser;
 
 const MESSAGE_TIMEOUT: u64 = 2;
@@ -88,7 +82,6 @@ impl Peer {
         let writer = lock.deref_mut();
 
         // If a peer signals for V2 we will use it, otherwise just use plaintext.
-        #[cfg(not(feature = "tor"))]
         let (message_mutex, mut peer_reader) = if self.services.has(ServiceFlags::P2P_V2) {
             let mut lock = reader.lock().await;
             let read_lock = lock.deref_mut();
@@ -118,15 +111,6 @@ impl Peer {
             (message_mutex, reader)
         };
 
-        // V2 handshakes fail frequently over Tor and messages are encrypted over relays anyway.
-        #[cfg(feature = "tor")]
-        let (message_mutex, mut peer_reader) = {
-            let outbound_messages = V1OutboundMessage::new(self.network);
-            let message_mutex: MutexMessageGenerator = Mutex::new(Box::new(outbound_messages));
-            let reader = Reader::new(V1MessageParser::new(reader, self.network), tx);
-            (message_mutex, reader)
-        };
-
         let mut message_lock = message_mutex.lock().await;
         let outbound_messages = message_lock.deref_mut();
         let message = outbound_messages.version_message(None)?;