refactor(transport): probe real availability and simplify transport()

Author: AlfioEmanueleFresta

libwebauthn/src/lib.rs

@@ -215,36 +215,27 @@ impl PartialEq for PinNotSetUpdate {
     }
 }
 
-/// Transports compiled into this build. Hybrid/caBLE is always included. Using it
-/// at runtime still needs a BLE adapter (see `transport::cable::is_available`).
-/// NFC appears only when an `nfc-backend-*` feature is enabled.
-pub fn available_transports() -> Vec<Transport> {
-    [
-        Transport::Usb,
-        Transport::Ble,
-        Transport::Hybrid,
-        #[cfg(any(feature = "nfc-backend-pcsc", feature = "nfc-backend-libnfc"))]
-        Transport::Nfc,
-    ]
-    .into_iter()
-    .collect()
+/// The transports usable right now. USB is always available. BLE and Hybrid
+/// (caBLE) need a Bluetooth adapter. NFC needs a reader and a compiled backend.
+pub async fn available_transports() -> Vec<Transport> {
+    let mut transports = vec![Transport::Usb];
+    // BLE and Hybrid (caBLE) both need a Bluetooth adapter.
+    if transport::ble::is_available().await {
+        transports.push(Transport::Ble);
+        transports.push(Transport::Hybrid);
+    }
+    if transport::nfc::is_nfc_available() {
+        transports.push(Transport::Nfc);
+    }
+    transports
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    #[test]
-    fn available_transports_reports_compiled_in() {
-        let transports = available_transports();
-        assert!(transports.contains(&Transport::Usb));
-        assert!(transports.contains(&Transport::Ble));
-        assert!(transports.contains(&Transport::Hybrid));
-
-        let nfc_compiled = cfg!(any(
-            feature = "nfc-backend-pcsc",
-            feature = "nfc-backend-libnfc"
-        ));
-        assert_eq!(transports.contains(&Transport::Nfc), nfc_compiled);
+    #[tokio::test]
+    async fn available_transports_always_includes_usb() {
+        assert!(available_transports().await.contains(&Transport::Usb));
     }
 }

libwebauthn/src/ops/webauthn/make_credential.rs

@@ -34,6 +34,7 @@ use crate::{
         },
     },
     transport::AuthTokenData,
+    Transport,
 };
 
 use super::timeout::DEFAULT_TIMEOUT;
@@ -48,7 +49,7 @@ pub struct MakeCredentialResponse {
     pub large_blob_key: Option<Vec<u8>>,
     pub unsigned_extensions_output: MakeCredentialsResponseUnsignedExtensions,
     /// Transport the credential was created over, stamped by the channel.
-    pub transport: Option<crate::Transport>,
+    pub transport: Option<Transport>,
     /// Transports the authenticator advertised in getInfo (0x09), if any.
     pub authenticator_transports: Option<Vec<String>>,
 }
@@ -67,7 +68,7 @@ struct AttestationObject<'a> {
 /// Maps the active transport to AuthenticatorTransport tokens for the registration
 /// `transports` member. The list is deduplicated and lexicographically sorted per
 /// WebAuthn L3 §5.2.1.1, and is empty when the transport is unknown.
-fn registration_transports(transport: Option<crate::Transport>) -> Vec<String> {
+fn registration_transports(transport: Option<Transport>) -> Vec<String> {
     let mut tokens: Vec<String> = transport
         .into_iter()
         .map(Ctap2Transport::from)
@@ -1537,18 +1538,18 @@ mod tests {
         let request = create_test_request();
 
         for (transport, token) in [
-            (crate::Transport::Usb, "usb"),
-            (crate::Transport::Ble, "ble"),
-            (crate::Transport::Nfc, "nfc"),
-            (crate::Transport::Hybrid, "hybrid"),
+            (Transport::Usb, "usb"),
+            (Transport::Ble, "ble"),
+            (Transport::Nfc, "nfc"),
+            (Transport::Hybrid, "hybrid"),
         ] {
             response.transport = Some(transport);
             let model = response.to_idl_model(&request).unwrap();
             assert_eq!(model.response.transports, vec![token.to_string()]);
         }
 
         // The token reaches the JSON wire format too.
-        response.transport = Some(crate::Transport::Nfc);
+        response.transport = Some(Transport::Nfc);
         let json = response
             .to_json_string(
                 &request,
@@ -1573,7 +1574,7 @@ mod tests {
         let request = create_test_request();
 
         // Reported out of order with a duplicate; the ceremony transport (ble) folds in.
-        response.transport = Some(crate::Transport::Ble);
+        response.transport = Some(Transport::Ble);
         response.authenticator_transports = Some(vec![
             "usb".to_string(),
             "nfc".to_string(),
@@ -1586,7 +1587,7 @@ mod tests {
         );
 
         // A ceremony transport already in the reported list is not duplicated.
-        response.transport = Some(crate::Transport::Usb);
+        response.transport = Some(Transport::Usb);
         response.authenticator_transports = Some(vec!["usb".to_string(), "nfc".to_string()]);
         let model = response.to_idl_model(&request).unwrap();
         assert_eq!(
@@ -1600,7 +1601,7 @@ mod tests {
         assert_eq!(model.response.transports, vec!["usb".to_string()]);
 
         // Unknown tokens pass through, folded with the ceremony transport.
-        response.transport = Some(crate::Transport::Ble);
+        response.transport = Some(Transport::Ble);
         response.authenticator_transports =
             Some(vec!["smart-card".to_string(), "custom".to_string()]);
         let model = response.to_idl_model(&request).unwrap();

libwebauthn/src/proto/ctap2/model.rs

@@ -1,4 +1,5 @@
 use crate::proto::ctap1::Ctap1Transport;
+use crate::Transport;
 use crate::{
     ops::webauthn::idl::create::PublicKeyCredentialUserEntity, pin::PinUvAuthProtocol,
     webauthn::Error,
@@ -167,13 +168,13 @@ impl From<&Ctap1Transport> for Ctap2Transport {
     }
 }
 
-impl From<crate::Transport> for Ctap2Transport {
-    fn from(transport: crate::Transport) -> Ctap2Transport {
+impl From<Transport> for Ctap2Transport {
+    fn from(transport: Transport) -> Ctap2Transport {
         match transport {
-            crate::Transport::Usb => Ctap2Transport::Usb,
-            crate::Transport::Ble => Ctap2Transport::Ble,
-            crate::Transport::Nfc => Ctap2Transport::Nfc,
-            crate::Transport::Hybrid => Ctap2Transport::Hybrid,
+            Transport::Usb => Ctap2Transport::Usb,
+            Transport::Ble => Ctap2Transport::Ble,
+            Transport::Nfc => Ctap2Transport::Nfc,
+            Transport::Hybrid => Ctap2Transport::Hybrid,
         }
     }
 }

libwebauthn/src/transport/ble/channel.rs

@@ -15,6 +15,7 @@ use crate::transport::channel::{
 use crate::transport::device::SupportedProtocols;
 use crate::transport::error::TransportError;
 use crate::webauthn::error::Error;
+use crate::Transport;
 use crate::UvUpdate;
 
 use super::btleplug::manager::SupportedRevisions;
@@ -81,8 +82,8 @@ impl Display for BleChannel<'_> {
 impl<'a> Channel for BleChannel<'a> {
     type UxUpdate = UvUpdate;
 
-    fn transport(&self) -> Option<crate::Transport> {
-        Some(crate::Transport::Ble)
+    fn transport(&self) -> Transport {
+        Transport::Ble
     }
 
     async fn supported_protocols(&self) -> Result<SupportedProtocols, Error> {

libwebauthn/src/transport/cable/channel.rs

@@ -18,6 +18,7 @@ use crate::transport::{
     channel::ChannelStatus, device::SupportedProtocols, Channel, Ctap2AuthTokenStore,
 };
 use crate::webauthn::error::Error;
+use crate::Transport;
 use crate::UvUpdate;
 
 use super::known_devices::CableKnownDevice;
@@ -125,8 +126,8 @@ impl From<UvUpdate> for CableUxUpdate {
 impl Channel for CableChannel {
     type UxUpdate = CableUxUpdate;
 
-    fn transport(&self) -> Option<crate::Transport> {
-        Some(crate::Transport::Hybrid)
+    fn transport(&self) -> Transport {
+        Transport::Hybrid
     }
 
     async fn supported_protocols(&self) -> Result<SupportedProtocols, Error> {

libwebauthn/src/transport/channel.rs

@@ -11,6 +11,7 @@ use crate::proto::{
     ctap2::cbor::{CborRequest, CborResponse},
 };
 use crate::webauthn::error::Error;
+use crate::Transport;
 use crate::UvUpdate;
 
 use async_trait::async_trait;
@@ -65,9 +66,9 @@ pub trait Channel: Send + Sync + Display + Ctap2AuthTokenStore {
     async fn close(&mut self);
 
     /// The transport this channel speaks over, used to populate the registration
-    /// response `transports` member. `None` means unknown.
-    fn transport(&self) -> Option<crate::Transport> {
-        None
+    /// response `transports` member.
+    fn transport(&self) -> Transport {
+        Transport::Usb
     }
 
     async fn apdu_send(&mut self, request: &ApduRequest, timeout: Duration) -> Result<(), Error>;

libwebauthn/src/transport/hid/channel.rs

@@ -34,6 +34,7 @@ use crate::transport::hid::framing::{
     HidCommand, HidMessage, HidMessageParser, HidMessageParserState,
 };
 use crate::webauthn::error::{Error, PlatformError};
+use crate::Transport;
 use crate::UvUpdate;
 
 use super::device::get_hidapi;
@@ -505,8 +506,8 @@ impl Display for HidChannel<'_> {
 impl Channel for HidChannel<'_> {
     type UxUpdate = UvUpdate;
 
-    fn transport(&self) -> Option<crate::Transport> {
-        Some(crate::Transport::Usb)
+    fn transport(&self) -> Transport {
+        Transport::Usb
     }
 
     async fn supported_protocols(&self) -> Result<SupportedProtocols, Error> {

libwebauthn/src/transport/mod.rs

@@ -23,6 +23,13 @@ pub mod hid;
 pub mod mock;
 #[cfg(any(feature = "nfc-backend-pcsc", feature = "nfc-backend-libnfc"))]
 pub mod nfc;
+// No NFC backend compiled: a stub so callers need not gate on the feature.
+#[cfg(not(any(feature = "nfc-backend-pcsc", feature = "nfc-backend-libnfc")))]
+pub mod nfc {
+    pub fn is_nfc_available() -> bool {
+        false
+    }
+}
 
 mod channel;
 #[allow(clippy::module_inception)]

libwebauthn/src/transport/nfc/channel.rs

@@ -21,6 +21,7 @@ use crate::transport::channel::{
 use crate::transport::device::SupportedProtocols;
 use crate::transport::error::TransportError;
 use crate::webauthn::Error;
+use crate::Transport;
 use crate::UvUpdate;
 
 use super::commands::{command_ctap_msg, command_get_response};
@@ -259,8 +260,8 @@ where
 {
     type UxUpdate = UvUpdate;
 
-    fn transport(&self) -> Option<crate::Transport> {
-        Some(crate::Transport::Nfc)
+    fn transport(&self) -> Transport {
+        Transport::Nfc
     }
 
     async fn supported_protocols(&self) -> Result<SupportedProtocols, Error> {

libwebauthn/src/webauthn.rs

@@ -141,7 +141,7 @@ where
             FidoProtocol::FIDO2 => make_credential_fido2(self, op).await,
             FidoProtocol::U2F => make_credential_u2f(self, op).await,
         }?;
-        response.transport = self.transport();
+        response.transport = Some(self.transport());
         Ok(response)
     }