webrtc: support wildcard listen addresses

Cargo.toml

@@ -26,6 +26,7 @@ ip_network = "0.4"
 libc = "0.2.158"
 mockall = "0.13.1"
 multiaddr = "0.18.2"
+multibase = "0.9.2"
 multihash = { version = "0.19.4", default-features = false, features = ["std"] }
 multihash-codetable = { version = "0.2.1", default-features = false, features = [
     "sha2",
@@ -90,6 +91,7 @@ rcgen = { version = "0.14.5", optional = true }
 
 # WebRTC related dependencies. WebRTC is an experimental feature flag. The dependencies must be updated.
 str0m = { version = "0.22.0", default-features = false, features = ["openssl", "vendored"], optional = true }
+quinn-udp = { version = "0.6.1", default-features = false, features = ["tracing"], optional = true }
 # End of WebRTC related dependencies.
 
 # Fuzzing related dependencies.
@@ -134,7 +136,7 @@ fuzz = [
 # Unstable / experimental feature flags. These features are not guaranteed to be stable and may change in the future.
 # They are not yet suitable for production use-cases and should be used with caution.
 quic = ["dep:webpki", "dep:quinn", "dep:rustls", "dep:ring", "dep:rcgen"]
-webrtc = ["dep:str0m"]
+webrtc = ["dep:str0m", "dep:quinn-udp"]
 rsa = ["dep:ring"]
 
 [profile.release]

src/transport/webrtc/certificate.rs

@@ -6,11 +6,16 @@
 //!
 //! litep2p does not persist the certificate itself, persistence is left to the caller.
 
+use crate::types::multihash::Multihash;
+use multihash_codetable::MultihashDigest as _;
 use str0m::{config::DtlsCert, crypto::CryptoError, error::DtlsError, RtcError};
 
+/// Local certificate & key used for DTLS connections.
 #[derive(Debug)]
 pub struct DtlsCertificate {
+    /// Certificate as X.509 DER.
     certificate: Vec<u8>,
+    /// Matching private key as PKCS#8 DER.
     private_key: Vec<u8>,
 }
 
@@ -40,6 +45,16 @@ impl DtlsCertificate {
         })
     }
 
+    /// Get the certificate certhash for WebRTC multiaddress.
+    pub fn certhash(&self) -> Multihash<64> {
+        multihash_codetable::Code::Sha2_256.digest(&self.certificate)
+    }
+
+    /// Certhash string representation as in multiaddress.
+    pub fn certhash_b64(&self) -> String {
+        multibase::encode(multibase::Base::Base64Url, self.certhash().to_bytes())
+    }
+
     /// Returns the raw certificate and private-key bytes.
     pub fn as_parts(&self) -> (&Vec<u8>, &Vec<u8>) {
         (&self.certificate, &self.private_key)

src/transport/webrtc/config.rs

@@ -30,9 +30,9 @@ use crate::transport::webrtc::certificate::DtlsCertificate;
 /// otherwise, the WebRTC transport is not initialized.
 #[derive(Debug)]
 pub struct Config {
-    /// WebRTC listening address.
+    /// WebRTC listen addresses.
     ///
-    /// Unspecified addresses (`0.0.0.0` / `[::]`) are not supported.
+    /// Wildcard addresses are expanded to specific interface addresses when advertised.
     pub listen_addresses: Vec<Multiaddr>,
 
     /// Connection datagram buffer size.

src/transport/webrtc/connection.rs

@@ -29,8 +29,10 @@ use crate::{
     transport::{
         webrtc::{
             schema::webrtc::message::Flag,
+            socket::WebRtcSocket,
             substream::{Message, Substream as WebRtcSubstream, SubstreamHandle},
             util::{extract_framed_message, WebRtcMessage},
+            AddressPair,
         },
         Endpoint, SUBSTREAM_OPEN_TIMEOUT,
     },
@@ -46,11 +48,10 @@ use str0m::{
     net::{Protocol as Str0mProtocol, Receive},
     Event, IceConnectionState, Input, Output, Rtc,
 };
-use tokio::{net::UdpSocket, sync::mpsc::Receiver};
+use tokio::sync::mpsc::Receiver;
 
 use std::{
     collections::{HashMap, HashSet, VecDeque},
-    net::SocketAddr,
     pin::Pin,
     sync::Arc,
     task::{Context, Poll},
@@ -244,14 +245,11 @@ pub struct WebRtcConnection {
     /// Endpoint.
     endpoint: Endpoint,
 
-    /// Peer address
-    peer_address: SocketAddr,
-
-    /// Local address.
-    local_address: SocketAddr,
+    /// Addresses of the session.
+    addrs: AddressPair,
 
     /// Transport socket.
-    socket: Arc<UdpSocket>,
+    socket: Arc<WebRtcSocket>,
 
     /// RX channel for receiving datagrams from the transport.
     dgram_rx: Receiver<Vec<u8>>,
@@ -296,9 +294,8 @@ impl WebRtcConnection {
     pub fn new(
         rtc: Rtc,
         peer: PeerId,
-        peer_address: SocketAddr,
-        local_address: SocketAddr,
-        socket: Arc<UdpSocket>,
+        addrs: AddressPair,
+        socket: Arc<WebRtcSocket>,
         protocol_set: ProtocolSet,
         endpoint: Endpoint,
         dgram_rx: Receiver<Vec<u8>>,
@@ -307,8 +304,7 @@ impl WebRtcConnection {
             rtc,
             protocol_set,
             peer,
-            peer_address,
-            local_address,
+            addrs,
             socket,
             endpoint,
             dgram_rx,
@@ -1134,7 +1130,9 @@ impl WebRtcConnection {
                         "transmit data",
                     );
 
-                    if let Err(error) = self.socket.try_send_to(&v.contents, v.destination) {
+                    if let Err(error) =
+                        self.socket.try_send_to(&v.contents, v.destination, self.addrs.local.ip())
+                    {
                         if error.kind() == std::io::ErrorKind::WouldBlock {
                             tracing::trace!(
                                 target: LOG_TARGET,
@@ -1266,8 +1264,8 @@ impl WebRtcConnection {
                             Instant::now(),
                             Receive {
                                 proto: Str0mProtocol::Udp,
-                                source: self.peer_address,
-                                destination: self.local_address,
+                                source: self.addrs.remote,
+                                destination: self.addrs.local,
                                 contents,
                             },
                         );