feat: add WebTransport protocol

transports/quic/Cargo.toml

@@ -26,6 +26,16 @@ tokio = { version = "1.33.0", default-features = false, features = ["net", "rt",
 tracing = "0.1.37"
 socket2 = "0.5.5"
 ring = "0.16.20"
+sha2 = "0.10.7"
+hex = "0.4"
+
+# WebTransport
+http = "0.2.11"
+h3 = { git = "https://github.com/hyperium/h3" }
+h3-quinn = { git = "https://github.com/hyperium/h3" }
+h3-webtransport = { git = "https://github.com/hyperium/h3" }
+rcgen = "0.11.3"
+time = "0.3"
 
 [features]
 tokio = ["dep:tokio", "if-watch/tokio", "quinn/runtime-tokio"]
@@ -48,6 +58,7 @@ libp2p-yamux = { workspace = true }
 quickcheck = "1"
 tokio = { version = "1.33.0", features = ["macros", "rt-multi-thread", "time"] }
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+hex-literal = "0.4"
 
 [[test]]
 name = "stream_compliance"

transports/quic/src/config.rs

@@ -15,11 +15,13 @@
 // 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.
 
 use quinn::VarInt;
 use std::{sync::Arc, time::Duration};
+use libp2p_core::multihash::Multihash;
+use crate::webtransport::fingerprint::Fingerprint;
 
 /// Config for the transport.
 #[derive(Clone)]
@@ -55,12 +57,23 @@
     /// If support for draft-29 is enabled servers support draft-29 and version 1 on all
     /// QUIC listening addresses.
     /// As client the version is chosen based on the remote's address.
     pub support_draft_29: bool,
 
+    // pub web_transport_config: WebTransportConfig,
+
     /// TLS client config for the inner [`quinn::ClientConfig`].
     client_tls_config: Arc<rustls::ClientConfig>,
+    //todo At first boot of the node, it creates one self-signed certificate with a validity of 14 days,
+    // starting immediately, and another certificate with the 14 day validity period starting on
+    // the expiry date of the first certificate.
+    // The node advertises a multiaddress containing the certificate hashes of these two certificates.
+    // Once the first certificate has expired, the node starts using the already generated next certificate.
+    // At the same time, it again generates a new certificate for the following period and updates
+    // the multiaddress it advertises.
     /// TLS server config for the inner [`quinn::ServerConfig`].
     server_tls_config: Arc<rustls::ServerConfig>,
+    pub(crate) cert_hash: Multihash<64>,
+
     /// Libp2p identity of the node.
     keypair: libp2p_identity::Keypair,
 }
@@ -69,10 +82,26 @@
     /// Creates a new configuration object with default values.
     pub fn new(keypair: &libp2p_identity::Keypair) -> Self {
         let client_tls_config = Arc::new(libp2p_tls::make_client_config(keypair, None).unwrap());
-        let server_tls_config = Arc::new(libp2p_tls::make_server_config(keypair).unwrap());
+
+        //todo set up cert's dates
+        let (cert, private_key) = libp2p_tls::certificate::generate(keypair).unwrap();
+
+        let server_tls_config = Arc::new(
+            libp2p_tls::make_server_config_with_cert(
+                cert.clone(), private_key, vec![
+                    b"libp2p".to_vec(),
+                    b"h3".to_vec(),
+                    b"h3-32".to_vec(),
+                    b"h3-31".to_vec(),
+                    b"h3-30".to_vec(),
+                    b"h3-29".to_vec(),
+                ]
+            ).unwrap()
+        );
         Self {
             client_tls_config,
             server_tls_config,
+            cert_hash: Fingerprint::from_certificate(cert.as_ref()).to_multihash(),
             support_draft_29: false,
             handshake_timeout: Duration::from_secs(5),
             max_idle_timeout: 30 * 1000,
@@ -100,6 +129,7 @@
         let Config {
             client_tls_config,
             server_tls_config,
+            cert_hash: _,
             max_idle_timeout,
             max_concurrent_stream_limit,
             keep_alive_interval,

transports/quic/src/connection/connecting.rs

@@ -24,15 +24,16 @@
 
 use futures::{
     future::{select, Either, FutureExt, Select},
     prelude::*,
 };
 use futures_timer::Delay;
 use libp2p_identity::PeerId;
 use std::{
     pin::Pin,
     task::{Context, Poll},
     time::Duration,
 };
+use libp2p_core::muxing::StreamMuxerBox;
 
 /// A QUIC connection currently being negotiated.
 #[derive(Debug)]
@@ -67,7 +68,7 @@
 }
 
 impl Future for Connecting {
-    type Output = Result<(PeerId, Connection), Error>;
+    type Output = Result<(PeerId, StreamMuxerBox), Error>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let connection = match futures::ready!(self.connecting.poll_unpin(cx)) {
@@ -77,6 +78,6 @@
 
         let peer_id = Self::remote_peer_id(&connection);
         let muxer = Connection::new(connection);
-        Poll::Ready(Ok((peer_id, muxer)))
+        Poll::Ready(Ok((peer_id, StreamMuxerBox::new(muxer))))
     }
 }

transports/quic/src/lib.rs

@@ -62,6 +62,7 @@ mod connection;
 mod hole_punching;
 mod provider;
 mod transport;
+mod webtransport;
 
 use std::net::SocketAddr;
 
@@ -101,6 +102,9 @@ pub enum Error {
     /// Error when holepunching for a remote is already in progress
     #[error("Already punching hole for {0}).")]
     HolePunchInProgress(SocketAddr),
+
+    #[error("WebTransport error.")]
+    WebTransportError,
 }
 
 /// Dialing a remote peer failed.