transports/onion: Add dial-only implementation of Transport

Cargo.toml

@@ -35,6 +35,8 @@ default = [
     "wasm-ext",
     "websocket",
     "yamux",
+    "onion-async-std",
+    "onion-native-tls"
 ]
 
 autonat = ["dep:libp2p-autonat"]
@@ -68,6 +70,10 @@ yamux = ["dep:libp2p-yamux"]
 secp256k1 = ["libp2p-core/secp256k1"]
 rsa = ["libp2p-core/rsa"]
 serde = ["libp2p-core/serde", "libp2p-kad?/serde", "libp2p-gossipsub?/serde"]
+onion-async-std = ["libp2p-onion/async-std"]
+onion-tokio = ["libp2p-onion/tokio"]
+onion-native-tls = ["libp2p-onion/native-tls"]
+onion-rustls = ["libp2p-onion/rustls"]
 
 [package.metadata.docs.rs]
 all-features = true
@@ -112,6 +118,7 @@ libp2p-dns = { version = "0.36.0", path = "transports/dns", optional = true, def
 libp2p-mdns = { version = "0.40.0", path = "protocols/mdns", optional = true, default-features = false }
 libp2p-tcp = { version = "0.37.0", path = "transports/tcp", default-features = false, optional = true }
 libp2p-websocket = { version = "0.38.0", path = "transports/websocket", optional = true }
+libp2p-onion = { version = "0.1.0", path = "transports/onion", default-features = false, optional = true }
 
 [target.'cfg(not(target_os = "unknown"))'.dependencies]
 libp2p-gossipsub = { version = "0.41.0", path = "protocols/gossipsub", optional = true }
@@ -154,7 +161,8 @@ members = [
     "transports/tcp",
     "transports/uds",
     "transports/websocket",
-    "transports/wasm-ext"
+    "transports/wasm-ext",
+    "transports/onion"
 ]
 
 [[example]]
@@ -176,3 +184,8 @@ required-features = ["gossipsub"]
 [[example]]
 name = "ipfs-private"
 required-features = ["gossipsub", "pnet", "yamux", "ping", "noise", "tcp-async-io", "identify"]
+
+[[example]]
+name = "ping-onion"
+required-features = ["onion", "onion-async-std", "onion-native-tls", "tcp-async-io", "dns-async-std"]
+

examples/ping-onion.rs

@@ -0,0 +1,119 @@
+// Copyright 2018 Parity Technologies (UK) Ltd.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+//! Ping example
+//!
+//! See ../src/tutorial.rs for a step-by-step guide building the example below.
+//!
+//! In the first terminal window, run:
+//!
+//! ```sh
+//! cargo run --example ping-onion
+//! ```
+//!
+//! It will print the PeerId and the listening addresses, e.g. `Listening on
+//! "/ip4/0.0.0.0/tcp/24915"`
+//!
+//! In the second terminal window, start a new instance of the example with:
+//!
+//! ```sh
+//! cargo run --example ping-onion -- /ip4/127.0.0.1/tcp/24915
+//! ```
+//!
+//! The two nodes establish a connection, negotiate the ping protocol
+//! and begin pinging each other.
+
+use futures::prelude::*;
+use libp2p::swarm::{Swarm, SwarmEvent};
+use libp2p::{
+    core::upgrade, dns, identity, mplex, noise, onion, ping, tcp, yamux, Multiaddr, PeerId,
+    Transport,
+};
+use std::error::Error;
+
+async fn onion_transport(
+    keypair: identity::Keypair,
+) -> Result<
+    libp2p_core::transport::Boxed<(PeerId, libp2p_core::muxing::StreamMuxerBox)>,
+    Box<dyn Error>,
+> {
+    use std::time::Duration;
+
+    let transport = {
+        let onion = onion::OnionClient::from_builder(onion::OnionClient::builder(), false)?;
+        println!("bootstrapping...");
+        onion.bootstrap().await?;
+        println!("bootstrapped!");
+        onion
+    };
+
+    let noise_keys = noise::Keypair::<noise::X25519Spec>::new()
+        .into_authentic(&keypair)
+        .expect("Signing libp2p-noise static DH keypair failed.");
+    Ok(transport
+        .upgrade(upgrade::Version::V1)
+        .authenticate(noise::NoiseConfig::xx(noise_keys).into_authenticated())
+        .multiplex(upgrade::SelectUpgrade::new(
+            yamux::YamuxConfig::default(),
+            mplex::MplexConfig::default(),
+        ))
+        .timeout(Duration::from_secs(20))
+        .boxed())
+}
+
+#[async_std::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+    let addr = std::env::args().nth(1).expect("no multiaddr given");
+    let local_key = identity::Keypair::generate_ed25519();
+    let local_peer_id = PeerId::from(local_key.public());
+    println!("Local peer id: {:?}", local_peer_id);
+
+    // create a transport
+    let transport = onion_transport(local_key).await?;
+
+    // Create a ping network behaviour.
+    //
+    // For illustrative purposes, the ping protocol is configured to
+    // keep the connection alive, so a continuous sequence of pings
+    // can be observed.
+    let behaviour = ping::Behaviour::new(ping::Config::new().with_keep_alive(true));
+
+    let mut swarm = Swarm::new(transport, behaviour, local_peer_id);
+
+    // Dial the peer identified by the multi-address given as the second
+    // command-line argument, if any.
+    let remote: Multiaddr = addr.parse()?;
+    swarm.dial(remote)?;
+    println!("Dialed {}", addr);
+
+    loop {
+        match swarm.select_next_some().await {
+            SwarmEvent::ConnectionEstablished { endpoint, .. } => {
+                let endpoint_addr = endpoint.get_remote_address();
+                println!("Connection established to {:?}", endpoint_addr);
+            }
+            SwarmEvent::OutgoingConnectionError { error, .. } => {
+                println!("Error establishing outgoing connection")
+            }
+            SwarmEvent::Behaviour(event) => println!("{:?}", event),
+            _ => {}
+        }
+    }
+}

src/lib.rs

@@ -99,6 +99,10 @@ pub use libp2p_mplex as mplex;
 #[cfg_attr(docsrs, doc(cfg(feature = "noise")))]
 #[doc(inline)]
 pub use libp2p_noise as noise;
+#[cfg(feature = "onion")]
+#[cfg_attr(docsrs, doc(cfg(feature = "onion")))]
+#[doc(inline)]
+pub use libp2p_onion as onion;
 #[cfg(feature = "ping")]
 #[cfg_attr(docsrs, doc(cfg(feature = "ping")))]
 #[doc(inline)]

transports/onion/Cargo.toml

@@ -0,0 +1,33 @@
+[package]
+name = "libp2p-onion"
+version = "0.1.0"
+edition = "2021"
+license = "MIT"
+resolver = "2"
+
+
+[dependencies]
+libp2p-core = { version = "0.36.0", path = "../../core", default-features = false }
+futures = "0.3"
+arti-client = { version = "0.6", default-features = false }
+thiserror = "1"
+tor-rtcompat = "0.6"
+tokio-crate = { package = "tokio", version = "1", optional = true, default-features = false }
+async-std-crate = { package = "async-std", version = "1", optional = true, default-features = false }
+
+[dev-dependencies]
+libp2p = { version = "0.49", path = "../../" }
+tokio-crate = { package = "tokio", version = "1", features = ["rt", "macros"] }
+async-std-crate = { package = "async-std", version = "1", features = ["attributes"] }
+
+
+[features]
+default = ["async-std", "native-tls"]
+tokio = ["arti-client/tokio", "dep:tokio-crate"]
+async-std = ["arti-client/async-std"]
+native-tls = ["arti-client/native-tls"]
+rustls = ["arti-client/rustls"]
+
+[package.metadata.docs.rs]
+rustdoc-args = ["--cfg", "docsrs"]
+rustc-args = ["--cfg", "docsrs"]

transports/onion/src/address.rs

@@ -0,0 +1,107 @@
+use std::net::{IpAddr, SocketAddr};
+
+use arti_client::{IntoTorAddr, TorAddr, TorAddrError};
+use libp2p_core::{multiaddr::Protocol, Multiaddr};
+
+pub fn dangerous_extract_tor_address(multiaddr: &Multiaddr) -> Result<TorAddr, TorAddrError> {
+    let socket_addr = try_extract_socket_addr(&mut multiaddr.clone())?;
+    TorAddr::dangerously_from(socket_addr)
+}
+
+pub fn safe_extract_tor_address(multiaddr: &mut Multiaddr) -> Result<TorAddr, TorAddrError> {
+    let tcp_variant = multiaddr.pop().ok_or(TorAddrError::NoPort)?;
+    let tcp_port = match tcp_variant {
+        Protocol::Tcp(p) => p,
+        _ => return Err(TorAddrError::NoPort),
+    };
+    let dns_variant = multiaddr.pop().ok_or(TorAddrError::InvalidHostname)?;
+    let dns_addr = match dns_variant {
+        Protocol::Dns(dns) => dns,
+        Protocol::Dns4(dns) => dns,
+        Protocol::Dns6(dns) => dns,
+        _ => return Err(TorAddrError::InvalidHostname),
+    };
+    let address_tuple = (dns_addr.as_ref(), tcp_port);
+    address_tuple.into_tor_addr()
+}
+
+fn try_extract_socket_addr(multiaddr: &mut Multiaddr) -> Result<SocketAddr, TorAddrError> {
+    let tcp_variant = multiaddr.pop().ok_or(TorAddrError::NoPort)?;
+    let port = match tcp_variant {
+        Protocol::Tcp(p) => p,
+        _ => return Err(TorAddrError::NoPort),
+    };
+    let ip_variant = multiaddr.pop().ok_or(TorAddrError::InvalidHostname)?;
+    let ip = match ip_variant {
+        Protocol::Ip4(ip4) => IpAddr::V4(ip4),
+        Protocol::Ip6(ip6) => IpAddr::V6(ip6),
+        _ => return Err(TorAddrError::InvalidHostname),
+    };
+    Ok(SocketAddr::new(ip, port))
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{borrow::Cow, net::Ipv4Addr, ops::Not};
+
+    use libp2p_core::{multiaddr::multiaddr, Multiaddr};
+
+    use super::safe_extract_tor_address;
+
+    #[test]
+    fn extract_correct_address() {
+        let dns_test_addr = multiaddr!(Dns(Cow::Borrowed("ip.tld")), Tcp(10u16));
+        let dns_test_addr_res = safe_extract_tor_address(&mut dns_test_addr.clone());
+        assert!(dns_test_addr_res.is_ok());
+        assert!(dns_test_addr_res.unwrap().is_ip_address().not());
+
+        let dns_4_test_addr = multiaddr!(Dns4(Cow::Borrowed("dns.ip4.tld")), Tcp(11u16));
+        let dns_4_test_addr_res = safe_extract_tor_address(&mut dns_4_test_addr.clone());
+        assert!(dns_4_test_addr_res.is_ok());
+        assert!(dns_4_test_addr_res.unwrap().is_ip_address().not());
+
+        let dns_6_test_addr = multiaddr!(Dns6(Cow::Borrowed("dns.ip6.tld")), Tcp(12u16));
+        let dns_6_test_addr_res = safe_extract_tor_address(&mut dns_6_test_addr.clone());
+        assert!(dns_6_test_addr_res.is_ok());
+        assert!(dns_6_test_addr_res.unwrap().is_ip_address().not());
+
+        let addresses = [
+            dns_test_addr,
+            dns_4_test_addr,
+            dns_6_test_addr,
+            Multiaddr::empty(),
+        ];
+
+        for (idx, a) in addresses.iter().enumerate() {
+            for (idy, b) in addresses.iter().enumerate() {
+                if idx == idy {
+                    continue;
+                }
+                let mut new = Multiaddr::empty();
+                a.iter().for_each(|e| {
+                    new.push(e);
+                });
+                b.iter().for_each(|e| {
+                    new.push(e);
+                });
+                let new_addr_res = safe_extract_tor_address(&mut new);
+                assert!(new_addr_res.is_ok());
+            }
+        }
+    }
+
+    #[test]
+    fn detect_incorrect_address() {
+        let without_dns = multiaddr!(Tcp(10u16), Udp(12u16));
+        let without_dns_res = safe_extract_tor_address(&mut without_dns.clone());
+        assert_eq!(without_dns_res, Err(arti_client::TorAddrError::NoPort));
+
+        let host = Cow::Borrowed("ip.tld");
+        let without_port = multiaddr!(Dns(host.clone()), Dns4(host.clone()), Dns6(host.clone()));
+        let without_port_res = safe_extract_tor_address(&mut without_port.clone());
+        assert_eq!(without_port_res, Err(arti_client::TorAddrError::NoPort));
+        let with_ip_addr = multiaddr!(Tcp(10u16), Ip4("1.1.1.1".parse::<Ipv4Addr>().unwrap()));
+        let with_ip_addr_res = safe_extract_tor_address(&mut with_ip_addr.clone());
+        assert_eq!(with_ip_addr_res, Err(arti_client::TorAddrError::NoPort));
+    }
+}