handle surplus options

Cargo.toml

@@ -1,13 +1,12 @@
 [package]
 name = "ctap_hmac"
 description = "A Rust implementation of the FIDO2 CTAP protocol, including the HMAC extension"
-version = "0.4.0"
+version = "0.3.0"
 license = "Apache-2.0/MIT"
-homepage = "https://github.com/shimunn/ctap"
+homepage = "https://github.com/ArdaXi/ctap/pull/2"
 repository = "https://github.com/shimunn/ctap"
 authors = ["Arda Xi <arda@ardaxi.com>", "shimun <shimun@shimun.net>"]
 edition = "2018"
-readme = "README.md"
 
 [dependencies]
 rand = "0.6"

examples/hmac.rs

@@ -4,6 +4,7 @@ use crypto::digest::Digest;
 use crypto::sha2::Sha256;
 use ctap::extensions::hmac::HmacExtension;
 use ctap::{FidoAssertionRequestBuilder, FidoCredential, FidoCredentialRequestBuilder};
+
 use hex;
 use std::env::args;
 use std::io::prelude::*;

examples/multiple.rs

@@ -1,4 +1,5 @@
 extern crate ctap_hmac as ctap;
+
 use ctap::{
     FidoAssertionRequestBuilder, FidoCredential, FidoCredentialRequestBuilder, FidoDevice,
     FidoResult,
@@ -6,7 +7,6 @@ use ctap::{
 
 use hex;
 use std::env::args;
-use std::time::Duration;
 
 const RP_ID: &str = "ctap_demo";
 
@@ -41,8 +41,7 @@ fn main() -> ctap::FidoResult<()> {
         .map(|handle| FidoDevice::new(&handle))
         .collect::<FidoResult<Vec<_>>>()?;
     // run with --features request_multiple
-    let (cred, _) =
+    let (cred, _) = ctap::get_assertion_devices(&req, devices.iter_mut())?;
-        ctap::get_assertion_devices(&req, devices.iter_mut(), Some(Duration::from_secs(10)))?;
     println!("Success, got assertion for: {}", hex::encode(&cred.id));
     Ok(())
 }

src/error.rs

@@ -23,8 +23,6 @@ pub struct CborErrorCode(u8);
 pub enum FidoErrorKind {
     #[fail(display = "Read/write error with device.")]
     Io,
-    #[fail(display = "Operation timed out")]
-    Timeout,
     #[fail(display = "Error while reading packet from device.")]
     ReadPacket,
     #[fail(display = "Error while writing packet to device.")]
@@ -49,7 +47,7 @@ pub enum FidoErrorKind {
     DecryptPin,
     #[fail(display = "Failed to verify response signature.")]
     VerifySignature,
-    #[fail(display = "Failed to verify response signature.")]
+    #[fail(display = "Supplied key has incorrect type.")]
     KeyType,
     #[fail(display = "Device returned error: {}", _0)]
     CborError(CborErrorCode),

src/extensions/hmac.rs

@@ -1,4 +1,6 @@
-use crate::{FidoAssertionRequest, FidoAssertionRequestBuilder, FidoCredentialRequest};
+use crate::{
+    FidoAssertionRequest, FidoAssertionRequestBuilder, FidoCredentialRequest,
+};
 use crate::{FidoCredential, FidoDevice, FidoErrorKind, FidoResult};
 use cbor_codec::value::{Bytes, Int, Key, Text, Value};
 use cbor_codec::Encoder;
@@ -11,6 +13,7 @@ use rust_crypto::sha2::Sha256;
 use std::collections::BTreeMap;
 use std::io::Cursor;
 
+
 pub trait HmacExtension {
     fn extension_name() -> &'static str {
         "hmac-secret"

src/lib.rs

@@ -457,6 +457,7 @@ impl FidoDevice {
     ///
     /// This method will fail if a PIN is required but the device is not
     /// unlocked or if the device returns malformed data.
+
     pub fn get_assertion<'a, 'b>(
         &mut self,
         assertion: &FidoAssertionRequest<'a, 'b>,

src/util.rs

@@ -7,8 +7,7 @@ use crate::{
 use crossbeam::thread;
 #[cfg(feature = "request_multiple")]
 use std::sync::mpsc::channel;
-#[cfg(feature = "request_multiple")]
+
-use std::time::Duration;
 #[cfg(feature = "request_multiple")]
 pub fn request_multiple_devices<
     'a,
@@ -16,7 +15,6 @@ pub fn request_multiple_devices<
     F: Fn(&mut FidoDevice) -> FidoResult<T> + 'a + Sync,
 >(
     devices: impl Iterator<Item = (&'a mut FidoDevice, &'a F)>,
-    timeout: Option<Duration>,
 ) -> FidoResult<T> {
     thread::scope(|scope| -> FidoResult<T> {
         let (tx, rx) = channel();
@@ -28,39 +26,22 @@ pub fn request_multiple_devices<
                 Ok((cancel, thread_handle))
             })
             .collect::<FidoResult<Vec<_>>>()?;
+
         let mut err = None;
-        let mut slept = Duration::from_millis(0);
+        for res in rx.iter().take(handles.len()) {
-        let interval = Duration::from_millis(10);
+            match res {
-        let mut received = 0usize;
+                Ok(_) => {
-        let res = loop {
-            match timeout {
-                Some(t) if t < slept => {
-                    break if let Some(cause) = err {
-                        cause
-                    } else {
-                        Err(FidoErrorKind::Timeout.into())
-                    };
-                }
-                _ => (),
-            }
-            if timeout.map(|t| t < slept).unwrap_or(true) {}
-            if let Ok(msg) = rx.recv_timeout(interval) {
-                received += 1;
-                match msg {
-                    e @ Err(_) if received == handles.len() => break e,
-                    e @ Err(_) => err = Some(e),
-                    res @ Ok(_) => break res,
-                }
-            } else {
-                slept += interval;
-            }
-        };
                     for (mut cancel, join) in handles {
                         // Canceling out of courtesy don't care if it fails
                         let _ = cancel.cancel();
                         let _ = join.join();
                     }
-        res
+                    return res;
+                }
+                e => err = Some(e),
+            }
+        }
+        err.unwrap_or(Err(FidoErrorKind::DeviceUnsupported.into()))
     })
     .unwrap()
 }
@@ -70,10 +51,9 @@ pub fn request_multiple_devices<
 pub fn get_assertion_devices<'a>(
     assertion_request: &'a FidoAssertionRequest,
     devices: impl Iterator<Item = &'a mut FidoDevice>,
-    timeout: Option<Duration>,
 ) -> FidoResult<(&'a FidoCredential, AuthenticatorData)> {
     let get_assertion = |device: &mut FidoDevice| device.get_assertion(assertion_request);
-    request_multiple_devices(devices.map(|device| (device, &get_assertion)), timeout)
+    request_multiple_devices(devices.map(|device| (device, &get_assertion)))
 }
 
 /// Will send the `credential_request` to all supplied `devices` and return either the first credential or the last error
@@ -81,8 +61,7 @@ pub fn get_assertion_devices<'a>(
 pub fn make_credential_devices<'a>(
     credential_request: &'a FidoCredentialRequest,
     devices: impl Iterator<Item = &'a mut FidoDevice>,
-    timeout: Option<Duration>,
 ) -> FidoResult<FidoCredential> {
     let make_credential = |device: &mut FidoDevice| device.make_credential(credential_request);
-    request_multiple_devices(devices.map(|device| (device, &make_credential)), timeout)
+    request_multiple_devices(devices.map(|device| (device, &make_credential)))
 }