fix(quic): avoid panic on post-handshake cert validation

Pull-Request: #6525.

Author: jxs

Cargo.lock

@@ -3,6 +3,10 @@
 - Raise MSRV to 1.88.0.
   See [PR 6273](https://github.com/libp2p/rust-libp2p/pull/6273).
 
+## 0.13.1
+- Handle certificate validation failures in post-handshake upgrade path instead of panicking.
+  See [GHSA-5hq8-qhww-jm7q](https://github.com/libp2p/rust-libp2p/security/advisories/GHSA-5hq8-qhww-jm7q)
+
 ## 0.13.0
 
 - Remove `async-std` support.

transports/quic/CHANGELOG.md

@@ -16,6 +16,7 @@ libp2p-core = { workspace = true }
 libp2p-tls = { workspace = true }
 libp2p-identity = { workspace = true }
 quinn = { version = "0.11.9", default-features = false, features = ["rustls", "futures-io"] }
+quinn-proto = { version = "0.11" }
 rand = { workspace = true }
 rustls = { version = "0.23.40", default-features = false }
 thiserror = { workspace = true }

transports/quic/Cargo.toml

@@ -33,6 +33,7 @@ use futures::{
 use futures_timer::Delay;
 use libp2p_identity::PeerId;
 use quinn::rustls::pki_types::CertificateDer;
+use quinn_proto::TransportError;
 
 use crate::{Connection, ConnectionError, Error};
 
@@ -51,20 +52,29 @@ impl Connecting {
 }
 
 impl Connecting {
-    /// Returns the address of the node we're connected to.
-    /// Panics if the connection is still handshaking.
-    fn remote_peer_id(connection: &quinn::Connection) -> PeerId {
+    fn remote_peer_id(connection: &quinn::Connection) -> Result<PeerId, Error> {
+        fn transport_err(reason: &str) -> Error {
+            Error::Connection(ConnectionError(quinn::ConnectionError::TransportError(
+                TransportError {
+                    code: quinn::TransportErrorCode::PROTOCOL_VIOLATION,
+                    frame: None,
+                    reason: reason.to_string(),
+                },
+            )))
+        }
+
         let identity = connection
             .peer_identity()
-            .expect("connection got identity because it passed TLS handshake; qed");
-        let certificates: Box<Vec<CertificateDer>> =
-            identity.downcast().expect("we rely on rustls feature; qed");
+            .ok_or_else(|| transport_err("No crypto identity in quinn's Connection"))?;
+        let certificates: Box<Vec<CertificateDer>> = identity
+            .downcast()
+            .map_err(|_| transport_err("Could not downcast identity"))?;
         let end_entity = certificates
             .first()
-            .expect("there should be exactly one certificate; qed");
+            .ok_or_else(|| transport_err("No certificate found"))?;
         let p2p_cert = libp2p_tls::certificate::parse(end_entity)
-            .expect("the certificate was validated during TLS handshake; qed");
-        p2p_cert.peer_id()
+            .map_err(|_| transport_err("Could not parse certificate"))?;
+        Ok(p2p_cert.peer_id())
     }
 }
 
@@ -77,7 +87,7 @@ impl Future for Connecting {
             Either::Left((connection, _)) => connection.map_err(ConnectionError)?,
         };
 
-        let peer_id = Self::remote_peer_id(&connection);
+        let peer_id = Self::remote_peer_id(&connection)?;
         let muxer = Connection::new(connection);
         Poll::Ready(Ok((peer_id, muxer)))
     }

transports/quic/src/connection/connecting.rs

@@ -581,6 +581,24 @@ mod tests {
         assert!(cert.signature_scheme().is_err());
     }
 
+    #[test]
+    fn parse_rejects_expired_certificate() {
+        // Regression for GHSA-5hq8-qhww-jm7q: expired cert must error, not panic.
+        let identity = identity::Keypair::generate_ed25519();
+        let signing = rcgen::KeyPair::generate_for(P2P_SIGNATURE_ALGORITHM).unwrap();
+
+        let mut params = rcgen::CertificateParams::default();
+        params.distinguished_name = rcgen::DistinguishedName::new();
+        params.not_before = rcgen::date_time_ymd(1970, 1, 1);
+        params.not_after = rcgen::date_time_ymd(1975, 1, 1);
+        params
+            .custom_extensions
+            .push(make_libp2p_extension(&identity, &signing).unwrap());
+        let cert: rustls::pki_types::CertificateDer = params.self_signed(&signing).unwrap().into();
+
+        assert!(parse(&cert).is_err());
+    }
+
     #[test]
     fn can_parse_certificate_with_ed25519_keypair() {
         let certificate = rustls::pki_types::CertificateDer::from(hex!("308201773082011ea003020102020900f5bd0debaa597f52300a06082a8648ce3d04030230003020170d3735303130313030303030305a180f34303936303130313030303030305a30003059301306072a8648ce3d020106082a8648ce3d030107034200046bf9871220d71dcb3483ecdfcbfcc7c103f8509d0974b3c18ab1f1be1302d643103a08f7a7722c1b247ba3876fe2c59e26526f479d7718a85202ddbe47562358a37f307d307b060a2b0601040183a25a01010101ff046a30680424080112207fda21856709c5ae12fd6e8450623f15f11955d384212b89f56e7e136d2e17280440aaa6bffabe91b6f30c35e3aa4f94b1188fed96b0ffdd393f4c58c1c047854120e674ce64c788406d1c2c4b116581fd7411b309881c3c7f20b46e54c7e6fe7f0f300a06082a8648ce3d040302034700304402207d1a1dbd2bda235ff2ec87daf006f9b04ba076a5a5530180cd9c2e8f6399e09d0220458527178c7e77024601dbb1b256593e9b96d961b96349d1f560114f61a87595").to_vec());