transports/onion: Add dial-only implementation of Transport

Cargo.toml

@@ -35,6 +35,9 @@ default = [
     "wasm-ext",
     "websocket",
     "yamux",
+    "onion",
+    "onion-async-std",
+    "onion-native-tls"
 ]
 
 autonat = ["dep:libp2p-autonat"]
@@ -68,6 +71,11 @@ yamux = ["dep:libp2p-yamux"]
 secp256k1 = ["libp2p-core/secp256k1"]
 rsa = ["libp2p-core/rsa"]
 serde = ["libp2p-core/serde", "libp2p-kad?/serde", "libp2p-gossipsub?/serde"]
+onion = ["dep:libp2p-onion"]
+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 +120,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 +163,8 @@ members = [
     "transports/tcp",
     "transports/uds",
     "transports/websocket",
-    "transports/wasm-ext"
+    "transports/wasm-ext",
+    "transports/onion"
 ]
 
 [[example]]
@@ -176,3 +186,7 @@ required-features = ["gossipsub"]
 [[example]]
 name = "ipfs-private"
 required-features = ["gossipsub"]
+
+[[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,122 @@
+// 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 dns_tcp = dns::DnsConfig::system(tcp::TcpTransport::new(
+            tcp::GenTcpConfig::new().nodelay(true),
+        ))
+        .await?;
+        let onion = onion::OnionClient::from_builder(onion::OnionClient::builder(), false)?;
+        println!("bootstrapping...");
+        onion.bootstrap().await?;
+        println!("bootstrapped!");
+        onion.or_transport(dns_tcp)
+    };
+
+    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 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);
+
+    // Tell the swarm to listen on all interfaces and a random, OS-assigned
+    // port.
+    swarm.listen_on("/ip4/0.0.0.0/tcp/0".parse()?)?;
+
+    // Dial the peer identified by the multi-address given as the second
+    // command-line argument, if any.
+    if let Some(addr) = std::env::args().nth(1) {
+        let remote: Multiaddr = addr.parse()?;
+        swarm.dial(remote)?;
+        println!("Dialed {}", addr)
+    }
+
+    loop {
+        match swarm.select_next_some().await {
+            SwarmEvent::NewListenAddr { address, .. } => println!("Listening on {:?}", address),
+            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,80 @@
+use std::net::{IpAddr, SocketAddr};
+
+use arti_client::{IntoTorAddr, TorAddr, TorAddrError};
+use libp2p_core::{multiaddr::Protocol, Multiaddr};
+
+fn try_extract_socket_addr(multiaddr: &Multiaddr) -> Result<SocketAddr, TorAddrError> {
+    let mut ip_4 = None;
+    let mut ip_6 = None;
+    let mut tcp_port_opt = None;
+    for e in multiaddr.iter() {
+        match e {
+            Protocol::Ip4(a) => {
+                ip_4 = Some(IpAddr::V4(a));
+            }
+            Protocol::Ip6(a) => {
+                ip_6 = Some(IpAddr::V6(a));
+            }
+            Protocol::Tcp(p) => {
+                tcp_port_opt = Some(p);
+            }
+            _ => {}
+        }
+    }
+    let ip = ip_4.or(ip_6).ok_or(TorAddrError::InvalidHostname)?;
+    let tcp_port = tcp_port_opt.ok_or(TorAddrError::NoPort)?;
+    Ok(SocketAddr::new(ip, tcp_port))
+}
+
+pub(super) fn dangerous_extract_tor_address(
+    multiaddr: &Multiaddr,
+) -> Result<TorAddr, TorAddrError> {
+    let socket_addr = try_extract_socket_addr(multiaddr)?;
+    TorAddr::dangerously_from(socket_addr)
+}
+
+macro_rules! try_convert_to_tor_addr {
+    ($dns:ident, $tcp_port:ident, $tor_addr_error:ident) => {
+        if let Some(dns_s) = $dns {
+            match (dns_s.as_ref(), $tcp_port).into_tor_addr() {
+                Ok(tor_addr) => return Ok(tor_addr),
+                Err(e) => $tor_addr_error = Some(e),
+            }
+        }
+    };
+}
+
+pub(super) fn safe_extract_tor_address(multiaddr: &Multiaddr) -> Result<TorAddr, TorAddrError> {
+    let mut dns = None;
+    let mut dns_4 = None;
+    let mut dns_6 = None;
+    let mut dns_addr = None;
+    let mut tcp_port_opt = None;
+    for e in multiaddr.iter() {
+        match e {
+            Protocol::Dns(s) => {
+                dns = Some(s);
+            }
+            Protocol::Dns4(s) => {
+                dns_4 = Some(s);
+            }
+            Protocol::Dns6(s) => {
+                dns_6 = Some(s);
+            }
+            Protocol::Dnsaddr(s) => {
+                dns_addr = Some(s);
+            }
+            Protocol::Tcp(p) => {
+                tcp_port_opt = Some(p);
+            }
+            _ => {}
+        }
+    }
+    let tcp_port = tcp_port_opt.ok_or(TorAddrError::NoPort)?;
+    let mut tor_addr_error = None;
+    try_convert_to_tor_addr!(dns, tcp_port, tor_addr_error);
+    try_convert_to_tor_addr!(dns_4, tcp_port, tor_addr_error);
+    try_convert_to_tor_addr!(dns_6, tcp_port, tor_addr_error);
+    try_convert_to_tor_addr!(dns_addr, tcp_port, tor_addr_error);
+    Err(tor_addr_error.unwrap_or(TorAddrError::InvalidHostname))
+}