Define Tor Zone, add onion addressing and more (#481)

* Define Tor Zone, add onion addressing, extend AddressBook, adapt `handle_timed_sync_request`, changes in cuprated + some cleanup

In `cuprated`:

- Added `Z: NetworkZone` as a generic requirement for `address_book_config`. Now takes the optional node address in argument.
- Added `tor_net_seed_nodes` fn for obtaining tor seed nodes.
- Added `CrossNetworkInternalPeerId::Tor(_)` variant and `From<InternalPeerId<OnionAddr>>`

In `cuprate-wire`:

- Added `src/network_address/onion_addr.rs` implementing `OnionAddr` type used by `Tor` network zone.
- Implemented parsing, formatting, conversion and validation of `OnionAddr`.
- Implemented 2 validation tests and 2 parsing tests for `OnionAddr`.
- Documented and cleaned up `src/network_address/epee_builder.rs`.
- Changed `u8` `type` field of `TaggedNetworkAddress` to `AddressType` enum equivalent to monerod's `address_type`.
- Added additional `host` and `port` fields to `AllFieldedNetworkAddress` collection type.
- Added `NetworkAddress:Tor` variant and added conversion to related functions.

In `cuprate-address-book`:

- Added `our_own_addr: Z::Addr` field to AddressBookConfig. This adds a `Z: NetworkZone` requirement to `AddressBookConfig`.
- Adapted code to the new generic requirement.
- Implemented handling of new `AddressBookRequest::OwnAddress` for querying the node self specified address for the zone.

In `cuprate-p2p`:

- If `Z::BROADCAST_OUR_OWN_ADDR` = `true`, `handle_timed_sync_request` will insert the node's address to the peerlist being sent.

In `cuprate-p2p-core`:

- Removed `#[async_trait::async_trait]` attribute to `impl NetworkZone for *`.
- Added `AddressBookRequest::OwnAddress` and `AddressBookResponse::OwnAddress(Option<Z::Addr>)`.
- Defined new `Tor` `NetworkZone`

* fmt

* fix typo and fmt

* final edits?

* fix test

* forgor

Author: SyntheticBird45

Cargo.lock

@@ -219,11 +219,11 @@ impl Config {
             gray_peers_percent: self.p2p.clear_net.gray_peers_percent,
             p2p_port: self.p2p.clear_net.p2p_port,
             rpc_port: self.rpc.restricted.port_for_p2p(),
-            address_book_config: self
-                .p2p
-                .clear_net
-                .address_book_config
-                .address_book_config(&self.fs.cache_directory, self.network),
+            address_book_config: self.p2p.clear_net.address_book_config.address_book_config(
+                &self.fs.cache_directory,
+                self.network,
+                None,
+            ),
         }
     }
 

binaries/cuprated/src/config.rs

@@ -1,4 +1,5 @@
 use std::{
+    marker::PhantomData,
     net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr},
     path::Path,
     time::Duration,
@@ -10,8 +11,9 @@ use cuprate_helper::{fs::address_book_path, network::Network};
 use cuprate_p2p::config::TransportConfig;
 use cuprate_p2p_core::{
     transports::{Tcp, TcpServerConfig},
-    ClearNet, Transport,
+    ClearNet, NetworkZone, Transport,
 };
+use cuprate_wire::OnionAddr;
 
 use super::macros::config_struct;
 
@@ -266,16 +268,23 @@ impl Default for AddressBookConfig {
 
 impl AddressBookConfig {
     /// Returns the [`cuprate_address_book::AddressBookConfig`].
-    pub fn address_book_config(
+    pub fn address_book_config<Z: NetworkZone>(
         &self,
         cache_dir: &Path,
         network: Network,
-    ) -> cuprate_address_book::AddressBookConfig {
+        our_own_address: Option<Z::Addr>,
+    ) -> cuprate_address_book::AddressBookConfig<Z> {
+        assert!(
+            !Z::BROADCAST_OWN_ADDR && our_own_address.is_some(),
+            "This network DO NOT take an incoming address."
+        );
+
         cuprate_address_book::AddressBookConfig {
             max_white_list_length: self.max_white_list_length,
             max_gray_list_length: self.max_gray_list_length,
             peer_store_directory: address_book_path(cache_dir, network),
             peer_save_period: self.peer_save_period,
+            our_own_address,
         }
     }
 }
@@ -317,3 +326,25 @@ pub fn clear_net_seed_nodes(network: Network) -> Vec<SocketAddr> {
         .collect::<Result<_, _>>()
         .unwrap()
 }
+
+/// Seed nodes for `Tor`.
+pub fn tor_net_seed_nodes(network: Network) -> Vec<OnionAddr> {
+    let seeds = match network {
+        Network::Mainnet => [
+            "zbjkbsxc5munw3qusl7j2hpcmikhqocdf4pqhnhtpzw5nt5jrmofptid.onion:18083",
+            "qz43zul2x56jexzoqgkx2trzwcfnr6l3hbtfcfx54g4r3eahy3bssjyd.onion:18083",
+            "plowsof3t5hogddwabaeiyrno25efmzfxyro2vligremt7sxpsclfaid.onion:18083",
+            "plowsoffjexmxalw73tkjmf422gq6575fc7vicuu4javzn2ynnte6tyd.onion:18083",
+            "plowsofe6cleftfmk2raiw5h2x66atrik3nja4bfd3zrfa2hdlgworad.onion:18083",
+            "aclc4e2jhhtr44guufbnwk5bzwhaecinax4yip4wr4tjn27sjsfg6zqd.onion:18083",
+        ]
+        .as_slice(),
+        Network::Stagenet | Network::Testnet => [].as_slice(),
+    };
+
+    seeds
+        .iter()
+        .map(|s| s.parse())
+        .collect::<Result<_, _>>()
+        .unwrap()
+}

binaries/cuprated/src/config/p2p.rs

@@ -1,16 +1,25 @@
 use std::net::SocketAddr;
 
-use cuprate_p2p_core::{client::InternalPeerID, ClearNet, NetworkZone};
+use cuprate_p2p_core::{client::InternalPeerID, ClearNet, NetworkZone, Tor};
+use cuprate_wire::OnionAddr;
 
 /// An identifier for a P2P peer on any network.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum CrossNetworkInternalPeerId {
     /// A clear-net peer.
     ClearNet(InternalPeerID<<ClearNet as NetworkZone>::Addr>),
+    /// A Tor onion peer.
+    Tor(InternalPeerID<<Tor as NetworkZone>::Addr>),
 }
 
-impl From<InternalPeerID<<ClearNet as NetworkZone>::Addr>> for CrossNetworkInternalPeerId {
-    fn from(addr: InternalPeerID<<ClearNet as NetworkZone>::Addr>) -> Self {
+impl From<InternalPeerID<SocketAddr>> for CrossNetworkInternalPeerId {
+    fn from(addr: InternalPeerID<SocketAddr>) -> Self {
         Self::ClearNet(addr)
     }
 }
+
+impl From<InternalPeerID<OnionAddr>> for CrossNetworkInternalPeerId {
+    fn from(addr: InternalPeerID<OnionAddr>) -> Self {
+        Self::Tor(addr)
+    }
+}

binaries/cuprated/src/p2p/network_address.rs

@@ -17,14 +17,15 @@ cuprate-fixed-bytes     = { workspace = true }
 cuprate-types           = { workspace = true, default-features = false, features = ["epee"] }
 cuprate-helper          = { workspace = true, default-features = false, features = ["map"] }
 
-bitflags = { workspace = true, features = ["std"] }
-bytes = { workspace = true, features = ["std"] }
-thiserror = { workspace = true }
+bitflags                = { workspace = true, features = ["std"] }
+bytes                   = { workspace = true, features = ["std"] }
+thiserror               = { workspace = true }
 
 arbitrary = { workspace = true, features = ["derive"], optional = true }
 
 [dev-dependencies]
-hex = { workspace = true, features = ["std"]}
+hex                     = { workspace = true, features = ["std"]}
+proptest                = { workspace = true }
 
 [lints]
 workspace = true

net/wire/Cargo.toml

@@ -26,7 +26,7 @@ pub mod network_address;
 pub mod p2p;
 
 pub use cuprate_levin::BucketError;
-pub use network_address::{NetZone, NetworkAddress};
+pub use network_address::{NetZone, NetworkAddress, OnionAddr};
 pub use p2p::*;
 
 // re-export.

net/wire/src/lib.rs

@@ -26,6 +26,9 @@ use cuprate_epee_encoding::EpeeObject;
 mod epee_builder;
 use epee_builder::*;
 
+mod onion_addr;
+pub use onion_addr::*;
+
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum NetZone {
     Public,
@@ -38,6 +41,7 @@ pub enum NetZone {
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum NetworkAddress {
     Clear(SocketAddr),
+    Tor(OnionAddr),
 }
 
 impl EpeeObject for NetworkAddress {
@@ -56,6 +60,7 @@ impl NetworkAddress {
     pub const fn get_zone(&self) -> NetZone {
         match self {
             Self::Clear(_) => NetZone::Public,
+            Self::Tor(_) => NetZone::Tor,
         }
     }
 
@@ -72,6 +77,7 @@ impl NetworkAddress {
     pub const fn port(&self) -> u16 {
         match self {
             Self::Clear(ip) => ip.port(),
+            Self::Tor(addr) => addr.port(),
         }
     }
 }
@@ -106,7 +112,7 @@ impl TryFrom<NetworkAddress> for SocketAddr {
     fn try_from(value: NetworkAddress) -> Result<Self, Self::Error> {
         match value {
             NetworkAddress::Clear(addr) => Ok(addr),
-            //_ => Err(NetworkAddressIncorrectZone)
+            NetworkAddress::Tor(_) => Err(NetworkAddressIncorrectZone),
         }
     }
 }

net/wire/src/network_address.rs

@@ -1,21 +1,37 @@
+//! Address epee serialization
+//!
+//! Addresses needs to be serialized into a specific format before being sent to other peers.
+//! This module is handling this particular construction.
+//!
+
+//---------------------------------------------------------------------------------------------------- Imports
+
 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
 
 use bytes::Buf;
 use thiserror::Error;
 
 use cuprate_epee_encoding::{epee_object, EpeeObjectBuilder};
+use cuprate_types::AddressType;
 
 use crate::NetworkAddress;
 
+use super::OnionAddr;
+
+//---------------------------------------------------------------------------------------------------- Network address construction
+
 #[derive(Default)]
+/// A serialized network address being communicated to or from a peer.
 pub struct TaggedNetworkAddress {
-    ty: Option<u8>,
+    /// Type of the network address (used later for conversion)
+    ty: Option<AddressType>,
+    /// All possible fields for a network address
     addr: Option<AllFieldsNetworkAddress>,
 }
 
 epee_object!(
     TaggedNetworkAddress,
-    ty("type"): Option<u8>,
+    ty("type"): Option<AddressType>,
     addr: Option<AllFieldsNetworkAddress>,
 );
 
@@ -75,53 +91,85 @@ impl From<NetworkAddress> for TaggedNetworkAddress {
         match value {
             NetworkAddress::Clear(addr) => match addr {
                 SocketAddr::V4(addr) => Self {
-                    ty: Some(1),
+                    ty: Some(AddressType::Ipv4),
                     addr: Some(AllFieldsNetworkAddress {
                         m_ip: Some(u32::from_le_bytes(addr.ip().octets())),
                         m_port: Some(addr.port()),
                         addr: None,
+                        host: None,
+                        port: None,
                     }),
                 },
                 SocketAddr::V6(addr) => Self {
-                    ty: Some(2),
+                    ty: Some(AddressType::Ipv6),
                     addr: Some(AllFieldsNetworkAddress {
                         addr: Some(addr.ip().octets()),
                         m_port: Some(addr.port()),
                         m_ip: None,
+                        host: None,
+                        port: None,
                     }),
                 },
             },
+            NetworkAddress::Tor(onion_addr) => Self {
+                ty: Some(AddressType::Tor),
+                addr: Some(AllFieldsNetworkAddress {
+                    m_ip: None,
+                    m_port: None,
+                    addr: None,
+                    host: Some(onion_addr.addr_string()),
+                    port: Some(onion_addr.port()),
+                }),
+            },
         }
     }
 }
 
 #[derive(Default)]
+/// There are no ordering guarantees in epee format and as such all potential fields can be collected during deserialization.
+/// The [`AllFieldsNetworkAddress`] is containing, as its name suggest, all optional field describing an address , as if it
+/// could be of any type.
 struct AllFieldsNetworkAddress {
+    /// IPv4 address
     m_ip: Option<u32>,
+    /// IP port field
     m_port: Option<u16>,
+
+    /// IPv6 address
     addr: Option<[u8; 16]>,
+
+    /// Alternative network domain name (<domain>.onion or <domain>.i2p)
+    host: Option<String>,
+    /// Alternative network virtual port
+    port: Option<u16>,
 }
 
 epee_object!(
     AllFieldsNetworkAddress,
     m_ip: Option<u32>,
     m_port: Option<u16>,
     addr: Option<[u8; 16]>,
+    host: Option<String>,
+    port: Option<u16>,
 );
 
 impl AllFieldsNetworkAddress {
-    fn try_into_network_address(self, ty: u8) -> Option<NetworkAddress> {
+    fn try_into_network_address(self, ty: AddressType) -> Option<NetworkAddress> {
         Some(match ty {
-            1 => NetworkAddress::from(SocketAddrV4::new(
+            AddressType::Ipv4 => NetworkAddress::from(SocketAddrV4::new(
                 Ipv4Addr::from(self.m_ip?.to_le_bytes()),
                 self.m_port?,
             )),
-            2 => NetworkAddress::from(SocketAddrV6::new(
+            AddressType::Ipv6 => NetworkAddress::from(SocketAddrV6::new(
                 Ipv6Addr::from(self.addr?),
                 self.m_port?,
                 0,
                 0,
             )),
+            AddressType::Tor => {
+                NetworkAddress::from(OnionAddr::new(self.host?.as_str(), self.port?).ok()?)
+            }
+            // Invalid
             _ => return None,
         })
     }