Git-Mirrors/xmr-btc-swap
1
0
Fork 0
mirror of https://github.com/comit-network/xmr-btc-swap.git synced 2025-07-09 16:19:50 -04:00
Code Issues Projects Releases Packages Wiki Activity

WIP - figure out what is not working

Browse source
This commit is contained in:
Daniel Karzel 2021-06-11 15:19:50 +10:00
parent a9e0a68e68
commit 4730161b95
No known key found for this signature in database
GPG key ID: 30C3FC2E438ADB6E
5 changed files with 62 additions and 58 deletions
Download patch file Download diff file Expand all files Collapse all files

27
libp2p-tor/Cargo.toml
View file

@ -1,28 +1,27 @@
[package]
name = "libp2p-tor"
version = "0.1.0"
authors = ["Thomas Eizinger <thomas@eizinger.io>"]
authors = [ "Thomas Eizinger <thomas@eizinger.io>" ]
edition = "2018"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
anyhow = "1" # TODO: Get rid of anyhow dependency
torut = { version = "0.1", default-features = false, features = ["v3", "control"] }
tokio-socks = "0.5"
libp2p = { version = "0.37", default-features = false, features = ["tcp-tokio"] }
tokio = { version = "1", features = ["sync"] }
futures = "0.3"
tracing = "0.1"
data-encoding = "2.3"
reqwest = { version = "0.11", features = ["socks", "rustls-tls"], default-features = false }
async-trait = "0.1"
data-encoding = "2.3"
futures = "0.3"
libp2p = { version = "0.37", default-features = false, features = [ "tcp-tokio" ] }
rand = { version = "0.8", optional = true }
reqwest = { version = "0.11", features = [ "socks", "rustls-tls" ], default-features = false }
tokio = { version = "1", features = [ "sync" ] }
tokio-socks = "0.5"
torut = { version = "0.1", default-features = false, features = [ "v3", "control" ] }
tracing = "0.1"
[dev-dependencies]
tempfile = "3"
tokio = { version = "1", features = ["full"] }
libp2p = { version = "0.37", default-features = false, features = [ "yamux", "noise", "ping" ] }
rand = "0.8"
libp2p = { version = "0.37", default-features = false, features = ["yamux", "noise", "ping"] }
tracing-subscriber = { version = "0.2", default-features = false, features = ["fmt", "ansi", "env-filter", "chrono", "tracing-log"] }
tempfile = "3"
testcontainers = "0.12"
tokio = { version = "1", features = [ "full" ] }
tracing-subscriber = { version = "0.2", default-features = false, features = [ "fmt", "ansi", "env-filter", "chrono", "tracing-log" ] }

14
libp2p-tor/examples/dialer.rs
View file

@ -8,15 +8,19 @@ use std::time::Duration;
#[tokio::main]
async fn main() {
let addr_to_dial = std::env::args()
.next()
.unwrap()
let arg = std::env::args()
.last()
.unwrap();
let addr_to_dial = arg
.parse::<Multiaddr>()
.unwrap();
let mut swarm = new_swarm();
println!("Peer-ID: {}", swarm.local_peer_id());
println!("Dialing {}", addr_to_dial);
swarm.dial_addr(addr_to_dial).unwrap();
loop {
@ -41,7 +45,9 @@ async fn main() {
println!("Failed to ping {}: {}", peer, failure)
}
},
_ => {}
event => {
println!("Swarm event: {:?}", event)
}
}
}
}

28
libp2p-tor/examples/listener.rs
View file

@ -2,7 +2,7 @@ use libp2p::core::muxing::StreamMuxerBox;
use libp2p::core::upgrade::Version;
use libp2p::ping::{Ping, PingEvent, PingSuccess};
use libp2p::swarm::{SwarmBuilder, SwarmEvent};
use libp2p::{identity, noise, yamux, Swarm, Transport};
use libp2p::{identity, noise, yamux, Swarm, Transport, Multiaddr};
use libp2p_tor::duplex;
use libp2p_tor::torut_ext::AuthenticatedConnectionExt;
use noise::NoiseConfig;
@ -10,23 +10,27 @@ use rand::Rng;
use std::time::Duration;
use torut::control::AuthenticatedConn;
use torut::onion::TorSecretKeyV3;
use std::str::FromStr;
#[tokio::main]
async fn main() {
let wildcard_multiaddr =
"/onion3/WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW:8080"
.parse()
.unwrap();
let mut swarm = new_swarm().await;
let key = random_onion_identity();
let onion_address = key.public().get_onion_address().get_address_without_dot_onion();
let onion_port = 7654;
println!("Peer-ID: {}", swarm.local_peer_id());
swarm.listen_on(wildcard_multiaddr).unwrap();
let mut swarm = new_swarm(key).await;
let peer_id = *swarm.local_peer_id();
println!("Peer-ID: {}", peer_id);
// TODO: Figure out what to with the port, we could also set it to 0 and then imply it from the assigned port
swarm.listen_on(Multiaddr::from_str(format!("/onion3/{}:{}", onion_address, onion_port).as_str()).unwrap()).unwrap();
loop {
match swarm.next_event().await {
SwarmEvent::NewListenAddr(addr) => {
println!("Listening on {}", addr);
println!("Connection string: {}/p2p/{}", addr, peer_id)
}
SwarmEvent::ConnectionEstablished {
peer_id, endpoint, ..
@ -48,7 +52,9 @@ async fn main() {
println!("Failed to ping {}: {}", peer, failure)
}
},
_ => {}
event => {
println!("Swarm event: {:?}", event)
}
}
}
}
@ -58,13 +64,13 @@ async fn main() {
///
/// In particular, this swarm can create ephemeral hidden services on the
/// configured Tor node.
async fn new_swarm() -> Swarm<Ping> {
async fn new_swarm(key: TorSecretKeyV3) -> Swarm<Ping> {
let identity = identity::Keypair::generate_ed25519();
SwarmBuilder::new(
duplex::TorConfig::new(
AuthenticatedConn::new(9051).await.unwrap(),
random_onion_identity,
key,
)
.await
.unwrap()

36
libp2p-tor/src/duplex.rs
View file

@ -15,13 +15,6 @@ use tokio::sync::Mutex;
use torut::control::{AsyncEvent, AuthenticatedConn};
use torut::onion::TorSecretKeyV3;
/// This is the hash of
/// `/onion3/WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW`.
const WILDCARD_ONION_ADDR_HASH: [u8; 35] = [
181, 173, 107, 90, 214, 181, 173, 107, 90, 214, 181, 173, 107, 90, 214, 181, 173, 107, 90, 214,
181, 173, 107, 90, 214, 181, 173, 107, 90, 214, 181, 173, 107, 90, 214,
];
type TorutAsyncEventHandler =
fn(
AsyncEvent<'_>,
@ -31,32 +24,33 @@ type TorutAsyncEventHandler =
pub struct TorConfig {
inner: MapErr<GenTcpConfig<libp2p::tcp::tokio::Tcp>, fn(std::io::Error) -> Error>, /* TODO: Make generic over async-std / tokio */
tor_client: Arc<Mutex<AuthenticatedConn<tokio::net::TcpStream, TorutAsyncEventHandler>>>,
onion_key_generator: Arc<dyn (Fn() -> TorSecretKeyV3) + Send + Sync>,
key: TorSecretKeyV3,
socks_port: u16,
}
impl TorConfig {
pub async fn new(
mut client: AuthenticatedConn<tokio::net::TcpStream, TorutAsyncEventHandler>,
onion_key_generator: impl (Fn() -> TorSecretKeyV3) + Send + Sync + 'static,
// TODO: change to key directly
key: TorSecretKeyV3,
) -> Result<Self, Error> {
let socks_port = client.get_socks_port().await?;
Ok(Self {
inner: TokioTcpConfig::new().map_err(Error::InnerTransprot),
tor_client: Arc::new(Mutex::new(client)),
onion_key_generator: Arc::new(onion_key_generator),
key,
socks_port,
})
}
pub async fn from_control_port(
control_port: u16,
key_generator: impl (Fn() -> TorSecretKeyV3) + Send + Sync + 'static,
key: TorSecretKeyV3,
) -> Result<Self, Error> {
let client = AuthenticatedConn::new(control_port).await?;
Self::new(client, key_generator).await
Self::new(client, key).await
}
}
@ -80,9 +74,9 @@ impl Transport for TorConfig {
return Err(TransportError::MultiaddrNotSupported(addr));
};
if onion.hash() != &WILDCARD_ONION_ADDR_HASH {
return Err(TransportError::Other(Error::OnlyWildcardAllowed));
}
let key: TorSecretKeyV3 = self.key;
let onion_bytes = key.public().get_onion_address().get_raw_bytes();
let onion_port = onion.port();
let localhost_tcp_random_port_addr = "/ip4/127.0.0.1/tcp/0"
.parse()
@ -90,10 +84,6 @@ impl Transport for TorConfig {
let listener = self.inner.listen_on(localhost_tcp_random_port_addr)?;
let key: TorSecretKeyV3 = (self.onion_key_generator)();
let onion_bytes = key.public().get_onion_address().get_raw_bytes();
let onion_port = onion.port();
let tor_client = self.tor_client;
let listener = listener
@ -115,6 +105,7 @@ impl Transport for TorConfig {
})
.expect("TODO: Error handling");
// TODO: Don't fully understand this part, why would we have two different multiaddresses here? the actual onion address and the multiaddress would make more sense...?
tracing::debug!(
"Setting up hidden service at {} to forward to {}",
onion_multiaddress,
@ -125,6 +116,7 @@ impl Transport for TorConfig {
.clone()
.lock()
.await
// TODO: Potentially simplify this, in our setup the onion port is always equal to the local port. Otherwise we would have the user provide an additional port for the oion service.
.add_ephemeral_service(&key, onion_port, local_port)
.await
{
@ -141,7 +133,9 @@ impl Transport for TorConfig {
local_addr,
remote_addr,
},
ListenerEvent::AddressExpired(_) => {
// TODO: why was the constructed multiaddr used here?
ListenerEvent::AddressExpired(adr) => {
// TODO: even if so, why would we ignore it? Far more logical to just use it...
// can ignore address because we only ever listened on one and we
// know which one that was
@ -156,7 +150,7 @@ impl Transport for TorConfig {
.del_onion(&onion_address_without_dot_onion)
.await
{
Ok(()) => ListenerEvent::AddressExpired(onion_multiaddress),
Ok(()) => ListenerEvent::AddressExpired(adr),
Err(e) => ListenerEvent::Error(Error::Torut(
torut_ext::Error::Connection(e),
)),

15
libp2p-tor/tests/integration_test.rs
View file

@ -42,7 +42,7 @@ async fn create_ephemeral_service() {
AuthenticatedConn::with_password(9051, "supersecret")
.await
.unwrap(),
move || onion_key_bytes.into(),
onion_key_bytes.into(),
)
.await
.unwrap()
@ -149,17 +149,16 @@ impl IntoIterator for TorArgs {
let mut args = Vec::new();
if let Some(port) = self.socks_port {
args.push(format!("SocksPort"));
args.push("SocksPort".to_string());
args.push(format!("0.0.0.0:{}", port));
}
if let Some(port) = self.control_port {
args.push(format!("ControlPort"));
args.push("ControlPort".to_string());
args.push(format!("0.0.0.0:{}", port));
args.push(format!("HashedControlPassword"));
args.push(format!(
"16:436B425404AA332A60B4F341C2023146C4B3A80548D757F0BB10DE81B4"
))
args.push("HashedControlPassword".to_string());
args.push("16:436B425404AA332A60B4F341C2023146C4B3A80548D757F0BB10DE81B4"
.to_string())
}
args.into_iter()
@ -186,7 +185,7 @@ impl Image for TorImage {
}
fn args(&self) -> Self::Args {
self.args.clone()
self.args
}
fn env_vars(&self) -> Self::EnvVars {