Decouple CableChannel from CableDevice implementations

Author: AlfioEmanueleFresta

libwebauthn/src/transport/cable/channel.rs

@@ -27,30 +27,28 @@ pub enum CableChannelDevice<'d> {
 }
 
 #[derive(Debug)]
-pub struct CableChannel<'d> {
+pub struct CableChannel {
     /// The WebSocket stream used for communication.
     // pub(crate) ws_stream: WebSocketStream<MaybeTlsStream<TcpStream>>,
 
     /// The noise state used for encryption over the WebSocket stream.
     // pub(crate) noise_state: TransportState,
 
     /// The device that this channel is connected to.
-    pub device: CableChannelDevice<'d>,
-
     pub(crate) handle_connection: task::JoinHandle<()>,
     pub(crate) cbor_sender: mpsc::Sender<CborRequest>,
     pub(crate) cbor_receiver: mpsc::Receiver<CborResponse>,
     pub(crate) tx: mpsc::Sender<UxUpdate>,
 }
 
-impl Display for CableChannel<'_> {
+impl Display for CableChannel {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(f, "CableChannel")
     }
 }
 
 #[async_trait]
-impl<'d> Channel for CableChannel<'d> {
+impl<'d> Channel for CableChannel {
     async fn supported_protocols(&self) -> Result<SupportedProtocols, Error> {
         Ok(SupportedProtocols::fido2_only())
     }
@@ -111,7 +109,7 @@ impl<'d> Channel for CableChannel<'d> {
     }
 }
 
-impl<'d> Ctap2AuthTokenStore for CableChannel<'d> {
+impl<'d> Ctap2AuthTokenStore for CableChannel {
     fn store_auth_data(&mut self, _auth_token_data: AuthTokenData) {}
 
     fn get_auth_data(&self) -> Option<&AuthTokenData> {

libwebauthn/src/transport/cable/known_devices.rs

@@ -125,7 +125,7 @@ unsafe impl Send for CableKnownDevice {}
 unsafe impl Sync for CableKnownDevice {}
 
 #[async_trait]
-impl<'d> Device<'d, Cable, CableChannel<'d>> for CableKnownDevice {
+impl<'d> Device<'d, Cable, CableChannel> for CableKnownDevice {
     async fn channel(&'d mut self) -> Result<(CableChannel, mpsc::Receiver<UxUpdate>), Error> {
         todo!()
     }

libwebauthn/src/transport/cable/qr_code_device.rs

@@ -243,8 +243,8 @@ impl Display for CableQrCodeDevice {
 }
 
 #[async_trait]
-impl<'d> Device<'d, Cable, CableChannel<'d>> for CableQrCodeDevice {
-    async fn channel(&'d mut self) -> Result<(CableChannel<'d>, mpsc::Receiver<UxUpdate>), Error> {
+impl<'d> Device<'d, Cable, CableChannel> for CableQrCodeDevice {
+    async fn channel(&'d mut self) -> Result<(CableChannel, mpsc::Receiver<UxUpdate>), Error> {
         let (_device, advert) = self.await_advertisement().await?;
 
         let Some(tunnel_domain) =
@@ -270,7 +270,7 @@ impl<'d> Device<'d, Cable, CableChannel<'d>> for CableQrCodeDevice {
             .unwrap();
 
         return tunnel::connect(
-            self,
+            &self.store,
             &tunnel_domain,
             &routing_id_str,
             &tunnel_id_str,

libwebauthn/src/transport/cable/tunnel.rs

@@ -19,9 +19,8 @@ use tokio_tungstenite::{connect_async, MaybeTlsStream, WebSocketStream};
 use tracing::{debug, error, trace, warn};
 use tungstenite::client::IntoClientRequest;
 
-use super::channel::{CableChannel, CableChannelDevice};
+use super::channel::CableChannel;
 use super::known_devices::{CableKnownDeviceInfo, CableKnownDeviceInfoStore};
-use super::qr_code_device::CableQrCodeDevice;
 use crate::proto::ctap2::cbor::{CborRequest, CborResponse};
 use crate::proto::ctap2::{Ctap2CommandCode, Ctap2GetInfoResponse};
 use crate::transport::cable::known_devices::CableKnownDeviceId;
@@ -157,13 +156,13 @@ pub fn decode_tunnel_server_domain(encoded: u16) -> Option<String> {
 }
 
 pub async fn connect<'d>(
-    device: &'d CableQrCodeDevice,
+    maybe_known_device_store: &Option<Arc<dyn CableKnownDeviceInfoStore>>,
     tunnel_domain: &str,
     routing_id: &str,
     tunnel_id: &str,
     psk: &[u8; 32],
     private_key: &NonZeroScalar,
-) -> Result<(CableChannel<'d>, mpsc::Receiver<UxUpdate>), Error> {
+) -> Result<(CableChannel, mpsc::Receiver<UxUpdate>), Error> {
     let connect_url = format!(
         "wss://{}/cable/connect/{}/{}",
         tunnel_domain, routing_id, tunnel_id
@@ -207,13 +206,16 @@ pub async fn connect<'d>(
     // After this, the handshake should be complete and you can start sending/receiving encrypted messages.
     // ...
 
-    let (cbor_sender, cbor_receiver, handle_connection) =
-        task_connection(tunnel_domain, device, ws_stream, noise_state)?;
+    let (cbor_sender, cbor_receiver, handle_connection) = task_connection(
+        tunnel_domain,
+        maybe_known_device_store,
+        ws_stream,
+        noise_state,
+    )?;
 
     let (send, recv) = mpsc::channel(1);
     Ok((
         CableChannel {
-            device: CableChannelDevice::QrCode(device),
             handle_connection,
             cbor_sender,
             cbor_receiver,
@@ -329,15 +331,15 @@ async fn do_handshake(
 
 fn task_connection(
     tunnel_domain: &str,
-    device: &CableQrCodeDevice,
+    maybe_known_device_store: &Option<Arc<dyn CableKnownDeviceInfoStore>>,
     ws_stream: WebSocketStream<MaybeTlsStream<TcpStream>>,
     transport_state: TransportState,
 ) -> Result<(Sender<CborRequest>, Receiver<CborResponse>, JoinHandle<()>), Error> {
     let (cbor_tx_send, cbor_tx_recv) = mpsc::channel(16);
     let (cbor_rx_send, cbor_rx_recv) = mpsc::channel(16);
 
     let tunnel_domain: String = tunnel_domain.to_string();
-    let maybe_known_device_store = device.store.to_owned();
+    let maybe_known_device_store = maybe_known_device_store.clone();
     let handle_connection = task::spawn(async move {
         connection(
             &tunnel_domain,