fix(ws): install a rustls crypto provider so the TLS connect does not panic

Author: mkzung

Cargo.lock

@@ -31,8 +31,8 @@ bridge = []
 ctf = ["alloy/contract", "alloy/providers"]
 rfq = []
 tracing = ["dep:tracing", "dep:serde_ignored", "dep:serde_path_to_error"]
-ws = ["dep:backoff", "dep:bitflags", "dep:tokio", "dep:tokio-tungstenite"]
-rtds = ["dep:backoff", "dep:tokio", "dep:tokio-tungstenite"]
+ws = ["dep:backoff", "dep:bitflags", "dep:rustls", "dep:tokio", "dep:tokio-tungstenite"]
+rtds = ["dep:backoff", "dep:rustls", "dep:tokio", "dep:tokio-tungstenite"]
 heartbeats = ["dep:tokio", "dep:tokio-util"]
 
 [dependencies]
@@ -72,6 +72,7 @@ sha1 = "0.10.6"
 sha2 = "0.10.9"
 strum_macros = "0.28.0"
 tokio = { version = "1.50.0", features = ["rt-multi-thread", "macros"], optional = true }
+rustls = { version = "0.23.38", optional = true }
 tokio-tungstenite = { version = "0.29.0", features = ["rustls-tls-native-roots"], optional = true }
 tokio-util = { version = "0.7.18", optional = true }
 tracing = { version = "0.1", optional = true }
@@ -386,3 +387,8 @@ unwrap_used = "warn"
 [profile.bench]
 lto = "thin"        # Link-Time Optimization: enables cross-crate inlining
 codegen-units = 1   # Single codegen unit allows more aggressive optimizations
+
+
+
+
+

Cargo.toml

@@ -8,7 +8,7 @@ use std::marker::PhantomData;
 use std::time::Instant;
 
 use backoff::backoff::Backoff as _;
-use futures::{SinkExt as _, StreamExt as _};
+use futures::{FutureExt as _, SinkExt as _, StreamExt as _};
 use serde::Serialize;
 use serde::de::DeserializeOwned;
 use tokio::net::TcpStream;
@@ -29,6 +29,23 @@ type WsStream = WebSocketStream<MaybeTlsStream<TcpStream>>;
 /// Broadcast channel capacity for incoming messages.
 const BROADCAST_CAPACITY: usize = 1024;
 
+/// Install a default rustls crypto provider if the process does not already have one.
+///
+/// Establishing the TLS connection resolves the process-level rustls `CryptoProvider`
+/// from crate features, which panics when more than one provider is present in the
+/// dependency graph. That happens readily in practice, because an application only has
+/// to pull in `ring` alongside the `aws-lc-rs` that rustls enables by default. Installing
+/// a provider explicitly avoids the panic, and an application that has already installed
+/// its own provider is left untouched.
+fn ensure_crypto_provider() {
+    static INIT: std::sync::Once = std::sync::Once::new();
+    INIT.call_once(|| {
+        if rustls::crypto::CryptoProvider::get_default().is_none() {
+            _ = rustls::crypto::aws_lc_rs::default_provider().install_default();
+        }
+    });
+}
+
 /// Connection state tracking.
 #[non_exhaustive]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -119,22 +136,36 @@ where
         let (broadcast_tx, _) = broadcast::channel(BROADCAST_CAPACITY);
         let (state_tx, state_rx) = watch::channel(ConnectionState::Disconnected);
 
+        ensure_crypto_provider();
+
         // Spawn connection task
         let connection_config = config;
         let connection_endpoint = endpoint;
         let broadcast_tx_clone = broadcast_tx.clone();
         let state_tx_clone = state_tx.clone();
+        let panic_state_tx = state_tx.clone();
 
         tokio::spawn(async move {
-            Self::connection_loop(
+            let connection_loop = std::panic::AssertUnwindSafe(Self::connection_loop(
                 connection_endpoint,
                 connection_config,
                 sender_rx,
                 broadcast_tx_clone,
                 parser,
                 state_tx_clone,
-            )
-            .await;
+            ));
+
+            if connection_loop.catch_unwind().await.is_err() {
+                // This task is detached, so a panic in the connection loop is otherwise
+                // swallowed: the manager would keep reporting whatever state it reached
+                // last (typically `Connecting`) and every subscription stream would hang
+                // with no error and no data. Report the connection as disconnected so the
+                // failure is at least observable.
+                _ = panic_state_tx.send(ConnectionState::Disconnected);
+
+                #[cfg(feature = "tracing")]
+                tracing::error!("websocket connection task panicked; reporting disconnected");
+            }
         });
 
         Ok(Self {
@@ -424,3 +455,17 @@ where
         self.state_tx.subscribe()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::ensure_crypto_provider;
+
+    #[test]
+    fn ensure_crypto_provider_installs_a_default() {
+        // More than one rustls crypto provider is present in the dependency graph, so
+        // the process-level default cannot be resolved from crate features and setting
+        // up TLS panics. Installing one keeps that from happening.
+        ensure_crypto_provider();
+        assert!(rustls::crypto::CryptoProvider::get_default().is_some());
+    }
+}