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 = ["dep:libp2p-onion", "libp2p-onion?/async-std"]
+onion-tokio = ["dep:libp2p-onion", "libp2p-onion?/tokio"]
+onion-native-tls = ["dep:libp2p-onion", "libp2p-onion?/native-tls"]
+onion-rustls = ["dep:libp2p-onion", "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-async-std", "onion-native-tls"]
+

examples/ping-onion.rs

@@ -0,0 +1,114 @@
+// Copyright 2022 Hannes Furmans
+//
+// 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-Onion example
+//!
+//! See ../src/tutorial.rs for a step-by-step guide building the example below.
+//!
+//! This example requires two seperate computers, one of which has to be reachable from the
+//! internet.
+//!
+//! On the first computer run:
+//! ```sh
+//! cargo run --example ping
+//! ```
+//!
+//! It will print the PeerId and the listening addresses, e.g. `Listening on
+//! "/ip4/0.0.0.0/tcp/24915"`
+//!
+//! Make sure that the first computer is reachable under one of these ip addresses and port.
+//!
+//! On the second computer run:
+//! ```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 over Tor.
+
+use futures::prelude::*;
+use libp2p::swarm::{Swarm, SwarmEvent};
+use libp2p::{
+    core::upgrade, identity, mplex, noise, onion, ping, 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 = onion::OnionAsyncStdNativeTlsTransport::bootstrapped().await?;
+    Ok(transport
+        .upgrade(upgrade::Version::V1)
+        .authenticate(
+            noise::NoiseAuthenticated::xx(&keypair)
+                .expect("Signing libp2p-noise static DH keypair failed."),
+        )
+        .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: {:?}", error)
+            }
+            SwarmEvent::Behaviour(event) => println!("{:?}", event),
+            _ => {}
+        }
+    }
+}

src/lib.rs

@@ -99,6 +99,11 @@ pub use libp2p_mplex as mplex;
 #[cfg_attr(docsrs, doc(cfg(feature = "noise")))]
 #[doc(inline)]
 pub use libp2p_noise as noise;
+#[cfg(any(feature = "onion-async-std", feature = "onion-tokio"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "onion")))]
+#[cfg(not(any(target_os = "emscripten", target_os = "wasi", target_os = "unknown")))]
+#[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,83 @@
+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::ops::Not;
+
+    use super::safe_extract_tor_address;
+
+    #[test]
+    fn extract_correct_address() {
+        let mut addresses = [
+            "/dns/ip.tld/tcp/10".parse().unwrap(),
+            "/dns4/dns.ip4.tld/tcp/11".parse().unwrap(),
+            "/dns6/dns.ip6.tld/tcp/12".parse().unwrap(),
+        ];
+
+        let all_correct = addresses
+            .iter_mut()
+            .map(safe_extract_tor_address)
+            .all(|extract_res| extract_res.is_ok() && extract_res.unwrap().is_ip_address().not());
+
+        assert!(all_correct, "Not all addresses have been parsed correctly");
+    }
+
+    #[test]
+    fn detect_incorrect_address() {
+        let mut addresses = [
+            "/tcp/10/udp/12".parse().unwrap(),
+            "/dns/ip.tld/dns4/ip.tld/dns6/ip.tld".parse().unwrap(),
+            "/tcp/10/ip4/1.1.1.1".parse().unwrap(),
+        ];
+
+        let all_correct = addresses
+            .iter_mut()
+            .map(safe_extract_tor_address)
+            .all(|res| res == Err(arti_client::TorAddrError::NoPort));
+
+        assert!(
+            all_correct,
+            "During the parsing of the faulty addresses, there was an incorrectness"
+        );
+    }
+}