Make hid_send/recv cancellable

Author: msirringhaus

libwebauthn/examples/hid_device_selection.rs

@@ -0,0 +1,105 @@
+use std::error::Error;
+
+#[cfg(feature = "virtual-hid-device")]
+#[tokio::main]
+pub async fn main() -> Result<(), Box<dyn Error>> {
+    // This example doesn't work for virtual devices, because
+    // solo devices are not clone-able.
+    Ok(())
+}
+
+#[cfg(not(feature = "virtual-hid-device"))]
+#[tokio::main]
+pub async fn main() -> Result<(), Box<dyn Error>> {
+    use std::collections::HashMap;
+    use std::time::Duration;
+
+    use libwebauthn::transport::hid::channel::HidChannelHandle;
+    use tracing_subscriber::{self, EnvFilter};
+
+    use libwebauthn::transport::hid::{list_devices, HidDevice};
+    use libwebauthn::transport::Device;
+
+    fn setup_logging() {
+        tracing_subscriber::fmt()
+            .with_env_filter(EnvFilter::from_default_env())
+            .without_time()
+            .init();
+    }
+    setup_logging();
+
+    let devices = list_devices().await.unwrap();
+    let mut expected_answers = devices.len();
+    let (blinking_tx, mut blinking_rx) =
+        tokio::sync::mpsc::channel::<Option<usize>>(expected_answers);
+    let mut channel_map = HashMap::new();
+    let (setup_tx, mut setup_rx) =
+        tokio::sync::mpsc::channel::<(usize, HidDevice, HidChannelHandle)>(expected_answers);
+
+    println!("Found {expected_answers} devices. Select one by touching.");
+    for (idx, mut device) in devices.into_iter().enumerate() {
+        let stx = setup_tx.clone();
+        let btx = blinking_tx.clone();
+
+        tokio::spawn(async move {
+            let dev = device.clone();
+            let (mut channel, _state_rx) = device.channel().await.unwrap();
+            let handle = channel.get_handle();
+            stx.send((idx, dev, handle)).await.unwrap();
+            drop(stx);
+
+            println!("Blinking {idx}");
+            let res = channel
+                .blink_and_wait_for_user_presence(Duration::from_secs(300))
+                .await;
+            match res {
+                Ok(true) => {
+                    println!("Touch from {idx}");
+                    btx.send(Some(idx)).await.unwrap();
+                }
+                Ok(false) | Err(_) => {
+                    btx.send(None).await.unwrap();
+                }
+            }
+        });
+    }
+    drop(setup_tx);
+    while let Some((idx, device, handle)) = setup_rx.recv().await {
+        channel_map.insert(idx, (device, handle));
+    }
+
+    drop(blinking_tx);
+    let mut found_one = false;
+    while let Some(msg) = blinking_rx.recv().await {
+        expected_answers -= 1;
+        match msg {
+            Some(idx) => {
+                println!("Received {idx}");
+                for (key, (_device, handle)) in channel_map.iter() {
+                    if key == &idx {
+                        continue;
+                    }
+                    println!("Cancelling {key}");
+                    handle.cancel_ongoing_operation().await;
+                }
+                let (device, _handle) = &channel_map[&idx];
+                println!("User chosen device: {device:?}");
+                found_one = true;
+            }
+            None => {
+                if expected_answers == 0 {
+                    if found_one {
+                        println!("All devices finished.");
+                    } else {
+                        println!("No device was chosen. All timed out.");
+                    }
+                    break;
+                } else {
+                    continue;
+                }
+            }
+        }
+    }
+
+    Ok(())
+}

libwebauthn/src/transport/error.rs

@@ -19,6 +19,8 @@ pub enum PlatformError {
     SyntaxError,
     #[error("cbor serialization error: {0}")]
     CborError(#[from] CborError),
+    #[error("cancelled by user")]
+    Cancelled,
 }
 
 #[derive(thiserror::Error, Debug, PartialEq)]

libwebauthn/src/transport/hid/channel.rs

@@ -1,15 +1,16 @@
 use std::convert::TryFrom;
 use std::fmt::{Debug, Display, Formatter};
 use std::io::{Cursor as IOCursor, Seek, SeekFrom};
-use std::ops::Deref;
+use std::ops::DerefMut;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
 use async_trait::async_trait;
 use byteorder::{BigEndian, ReadBytesExt};
 use hidapi::HidDevice as HidApiDevice;
 use rand::{thread_rng, Rng};
-use tokio::sync::mpsc;
+use tokio::sync::mpsc::error::TryRecvError;
+use tokio::sync::mpsc::{self, Receiver, Sender};
 use tokio::time::sleep;
 use tracing::{debug, info, instrument, trace, warn, Level};
 
@@ -27,6 +28,7 @@ use crate::transport::error::{Error, TransportError};
 use crate::transport::hid::framing::{
     HidCommand, HidMessage, HidMessageParser, HidMessageParserState,
 };
+use crate::webauthn::PlatformError;
 use crate::UxUpdate;
 
 use super::device::get_hidapi;
@@ -44,45 +46,66 @@ const REPORT_ID: u8 = 0x00;
 // by a CBOR command, so we want to ensure we wait some time after winking.
 const WINK_MIN_WAIT: Duration = Duration::from_secs(2);
 
+pub type CancelHidOperation = ();
 enum OpenHidDevice {
-    HidApiDevice(Arc<Mutex<HidApiDevice>>),
+    HidApiDevice(Arc<Mutex<(HidApiDevice, mpsc::Receiver<CancelHidOperation>)>>),
     #[cfg(feature = "virtual-hid-device")]
     VirtualDevice,
 }
 
+#[derive(Debug, Clone)]
+pub struct HidChannelHandle {
+    tx: Sender<CancelHidOperation>,
+}
+
+impl HidChannelHandle {
+    pub async fn cancel_ongoing_operation(&self) {
+        let _ = self.tx.send(()).await;
+    }
+}
+
 pub struct HidChannel<'d> {
     status: ChannelStatus,
     device: &'d HidDevice,
     open_device: OpenHidDevice,
     init: InitResponse,
     auth_token_data: Option<AuthTokenData>,
     tx: mpsc::Sender<UxUpdate>,
+    handle: HidChannelHandle,
 }
 
 impl<'d> HidChannel<'d> {
     pub async fn new(
         device: &'d HidDevice,
         tx: mpsc::Sender<UxUpdate>,
     ) -> Result<HidChannel<'d>, Error> {
+        let (handle_tx, handle_rx) = mpsc::channel(1);
+        let handle = HidChannelHandle { tx: handle_tx };
+
         let mut channel = Self {
             status: ChannelStatus::Ready,
             device,
             open_device: match device.backend {
                 HidBackendDevice::HidApiDevice(_) => {
                     let hidapi_device = Self::hid_open(device)?;
-                    OpenHidDevice::HidApiDevice(Arc::new(Mutex::new(hidapi_device)))
+                    OpenHidDevice::HidApiDevice(Arc::new(Mutex::new((hidapi_device, handle_rx))))
                 }
                 #[cfg(feature = "virtual-hid-device")]
                 HidBackendDevice::VirtualDevice(_) => OpenHidDevice::VirtualDevice,
             },
             init: InitResponse::default(),
             auth_token_data: None,
             tx,
+            handle,
         };
         channel.init = channel.init(INIT_TIMEOUT).await?;
         Ok(channel)
     }
 
+    pub fn get_handle(&self) -> HidChannelHandle {
+        self.handle.clone()
+    }
+
     #[instrument(skip_all)]
     pub async fn wink(&mut self, timeout: Duration) -> Result<bool, Error> {
         if !self.init.caps.contains(Caps::WINK) {
@@ -246,22 +269,40 @@ impl<'d> HidChannel<'d> {
     pub async fn hid_send(&self, msg: &HidMessage) -> Result<(), Error> {
         match &self.open_device {
             OpenHidDevice::HidApiDevice(hidapi_device) => {
-                let Ok(guard) = hidapi_device.lock() else {
+                let Ok(mut guard) = hidapi_device.lock() else {
                     warn!("Poisoned lock on HID API device");
                     return Err(Error::Transport(TransportError::ConnectionLost));
                 };
-                Self::hid_send_hidapi(guard.deref(), msg)
+                let (device, cancel_rx) = guard.deref_mut();
+                let response = Self::hid_send_hidapi(device, cancel_rx, msg);
+                if matches!(response, Err(Error::Platform(PlatformError::Cancelled))) {
+                    // Using hid_send_hidapi directly, instead of hid_cancel, to avoid recursion
+                    let _ = Self::hid_send_hidapi(
+                        device,
+                        cancel_rx,
+                        &HidMessage::new(self.init.cid, HidCommand::Cancel, &[]),
+                    );
+                }
+                response
             }
             #[cfg(feature = "virtual-hid-device")]
             OpenHidDevice::VirtualDevice => Self::hid_send_virtual(msg).await,
         }
     }
 
-    fn hid_send_hidapi(device: &hidapi::HidDevice, msg: &HidMessage) -> Result<(), Error> {
+    fn hid_send_hidapi(
+        device: &hidapi::HidDevice,
+        cancel_rx: &mut Receiver<CancelHidOperation>,
+        msg: &HidMessage,
+    ) -> Result<(), Error> {
         let packets = msg
             .packets(PACKET_SIZE)
             .or(Err(Error::Transport(TransportError::InvalidFraming)))?;
         for (i, packet) in packets.iter().enumerate() {
+            if !matches!(cancel_rx.try_recv(), Err(TryRecvError::Empty)) {
+                return Err(Error::Platform(PlatformError::Cancelled));
+            }
+
             let mut report: Vec<u8> = vec![REPORT_ID];
             report.extend(packet);
             report.extend(vec![0; PACKET_SIZE - packet.len()]);
@@ -319,13 +360,15 @@ impl<'d> HidChannel<'d> {
                     // Note that we're just using spawn_blocking() on hid_recv(), not on hid_send(),
                     // since implementing this on hid_send and would cause unnecessary copies/locking.
                     tokio::task::spawn_blocking(move || {
-                        let Ok(guard) = device.lock() else {
+                        let Ok(mut guard) = device.lock() else {
                             warn!("Poisoned lock on HID API device");
                             return Err(Error::Transport(TransportError::ConnectionLost));
                         };
-                        let device = guard.deref();
-                        Self::hid_recv_hidapi(device, timeout)
-                    }).await.unwrap()
+                        let (device, cancel_rx) = guard.deref_mut();
+                        Self::hid_recv_hidapi(device, cancel_rx, timeout)
+                    })
+                    .await
+                    .expect("HID read not to panic.")
                 }
                 #[cfg(feature = "virtual-hid-device")]
                 OpenHidDevice::VirtualDevice => Self::hid_recv_virtual(timeout).await,
@@ -339,14 +382,26 @@ impl<'d> HidChannel<'d> {
                     debug!("Ignoring HID keep-alive");
                     continue;
                 }
+                Err(Error::Platform(PlatformError::Cancelled)) => {
+                    let _ = self.hid_cancel().await;
+                    break response;
+                }
                 _ => break response,
             }
         }
     }
 
-    fn hid_recv_hidapi(device: &hidapi::HidDevice, timeout: Duration) -> Result<HidMessage, Error> {
+    fn hid_recv_hidapi(
+        device: &hidapi::HidDevice,
+        cancel_rx: &mut Receiver<CancelHidOperation>,
+        timeout: Duration,
+    ) -> Result<HidMessage, Error> {
         let mut parser = HidMessageParser::new();
         loop {
+            if !matches!(cancel_rx.try_recv(), Err(TryRecvError::Empty)) {
+                return Err(Error::Platform(PlatformError::Cancelled));
+            }
+
             let mut report = [0; PACKET_SIZE];
             device
                 .read_timeout(&mut report, timeout.as_millis() as i32)