Allow for shared secret to be created even if no PIN is set on the device to support HMAC/PRF

Author: msirringhaus

libwebauthn/src/management/authenticator_config.rs

@@ -199,4 +199,8 @@ impl Ctap2UserVerifiableRequest for Ctap2AuthenticatorConfigRequest {
     fn handle_legacy_preview(&mut self, _info: &Ctap2GetInfoResponse) {
         // No-op
     }
+
+    fn needs_shared_secret(&self, _get_info_response: &Ctap2GetInfoResponse) -> bool {
+        false
+    }
 }

libwebauthn/src/management/bio_enrollment.rs

@@ -335,4 +335,8 @@ impl Ctap2UserVerifiableRequest for Ctap2BioEnrollmentRequest {
             }
         }
     }
+
+    fn needs_shared_secret(&self, _get_info_response: &Ctap2GetInfoResponse) -> bool {
+        false
+    }
 }

libwebauthn/src/management/credential_management.rs

@@ -318,4 +318,8 @@ impl Ctap2UserVerifiableRequest for Ctap2CredentialManagementRequest {
             }
         }
     }
+
+    fn needs_shared_secret(&self, _get_info_response: &Ctap2GetInfoResponse) -> bool {
+        false
+    }
 }

libwebauthn/src/ops/webauthn/make_credential.rs

@@ -193,7 +193,7 @@ pub enum MakeCredentialHmacOrPrfInput {
     // },
 }
 
-#[derive(Debug, Default, Clone, Serialize)]
+#[derive(Debug, Default, Clone, Serialize, PartialEq)]
 pub struct MakeCredentialPrfOutput {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub enabled: Option<bool>,
@@ -315,10 +315,7 @@ impl DowngradableRequest<RegisterRequest> for MakeCredentialRequest {
         }
 
         // Options must not include "rk" set to true.
-        if matches!(
-            self.resident_key,
-            Some(ResidentKeyRequirement::Required)
-        ) {
+        if matches!(self.resident_key, Some(ResidentKeyRequirement::Required)) {
             debug!("Not downgradable: request requires resident key");
             return false;
         }

libwebauthn/src/proto/ctap2/model.rs

@@ -209,14 +209,17 @@ pub trait Ctap2UserVerifiableRequest {
     fn permissions_rpid(&self) -> Option<&str>;
     fn can_use_uv(&self, info: &Ctap2GetInfoResponse) -> bool;
     fn handle_legacy_preview(&mut self, info: &Ctap2GetInfoResponse);
+    /// We need to establish a shared secret, even if no PIN or UV is set on the device
+    fn needs_shared_secret(&self, info: &Ctap2GetInfoResponse) -> bool;
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Ctap2UserVerificationOperation {
     GetPinUvAuthTokenUsingUvWithPermissions,
     GetPinUvAuthTokenUsingPinWithPermissions,
     GetPinToken,
-    None,
+    ClientPinOnlyForSharedSecret,
+    LegacyUv,
 }
 
 #[cfg(test)]

libwebauthn/src/proto/ctap2/model/get_assertion.rs

@@ -441,6 +441,20 @@ impl Ctap2UserVerifiableRequest for Ctap2GetAssertionRequest {
     fn handle_legacy_preview(&mut self, _info: &Ctap2GetInfoResponse) {
         // No-op
     }
+
+    fn needs_shared_secret(&self, get_info_response: &Ctap2GetInfoResponse) -> bool {
+        let hmac_supported = get_info_response
+            .extensions
+            .as_ref()
+            .map(|e| e.contains(&String::from("hmac-secret")))
+            .unwrap_or_default();
+        let hmac_requested = self
+            .extensions
+            .as_ref()
+            .map(|e| !matches!(e.hmac_or_prf, GetAssertionHmacOrPrfInput::None))
+            .unwrap_or_default();
+        hmac_requested && hmac_supported
+    }
 }
 
 impl Ctap2GetAssertionResponse {

libwebauthn/src/proto/ctap2/model/get_info.rs

@@ -153,11 +153,21 @@ pub struct Ctap2GetInfoResponse {
 }
 
 impl Ctap2GetInfoResponse {
+    /// Only checks if the option exists, i.e. is not None
+    /// but does not check if the option is enabled (true)
+    /// or disabled (false)
+    pub fn option_exists(&self, name: &str) -> bool {
+        let Some(options) = self.options.as_ref() else {
+            return false;
+        };
+        options.get(name).is_some()
+    }
+
+    /// Checks if the option exists and is set to true
     pub fn option_enabled(&self, name: &str) -> bool {
-        if self.options.is_none() {
+        let Some(options) = self.options.as_ref() else {
             return false;
-        }
-        let options = self.options.as_ref().unwrap();
+        };
         options.get(name) == Some(&true)
     }
 
@@ -195,32 +205,43 @@ impl Ctap2GetInfoResponse {
             (self.option_enabled("pinUvAuthToken") && self.option_enabled("uv"))
     }
 
+    pub fn can_establish_shared_secret(&self) -> bool {
+        // clientPin exists: clientPin command is supported, so we can establish a shared secret
+        // uv exists and pinUvAuthToken is enabled: clientPin command partially supported. Enough to establish shared secret
+        self.option_exists("clientPin")
+            || (self.option_exists("uv") && self.option_enabled("pinUvAuthToken"))
+    }
+
     pub fn uv_operation(&self, uv_blocked: bool) -> Option<Ctap2UserVerificationOperation> {
         if self.option_enabled("uv") && !uv_blocked {
             if self.option_enabled("pinUvAuthToken") {
                 debug!("getPinUvAuthTokenUsingUvWithPermissions");
-                return Some(
-                    Ctap2UserVerificationOperation::GetPinUvAuthTokenUsingUvWithPermissions,
-                );
+                Some(Ctap2UserVerificationOperation::GetPinUvAuthTokenUsingUvWithPermissions)
             } else {
                 debug!("Deprecated FIDO 2.0 behaviour: populating 'uv' flag");
-                return Some(Ctap2UserVerificationOperation::None);
+                Some(Ctap2UserVerificationOperation::LegacyUv)
             }
         } else {
             // !uv
+
+            // clientPIN exists, but is not enabled, aka PIN is not yet set on the device
+            // We can use it for establishing a shared secret, but not for creating a pinUvAuthToken
+            if self.option_exists("clientPin") && !self.option_enabled("clientPin") {
+                return Some(Ctap2UserVerificationOperation::ClientPinOnlyForSharedSecret);
+            }
+
+            // If we do have a PIN, check if we need to use legacy getPinToken or new getPinUvAuthToken..-command
             if self.option_enabled("pinUvAuthToken") {
                 assert!(self.option_enabled("clientPin"));
                 debug!("getPinUvAuthTokenUsingPinWithPermissions");
-                return Some(
-                    Ctap2UserVerificationOperation::GetPinUvAuthTokenUsingPinWithPermissions,
-                );
+                Some(Ctap2UserVerificationOperation::GetPinUvAuthTokenUsingPinWithPermissions)
             } else if self.option_enabled("clientPin") {
                 // !pinUvAuthToken
                 debug!("getPinToken");
-                return Some(Ctap2UserVerificationOperation::GetPinToken);
+                Some(Ctap2UserVerificationOperation::GetPinToken)
             } else {
                 debug!("No UV and no PIN (e.g. maybe UV was blocked and no PIN available)");
-                return None;
+                None
             }
         }
     }

libwebauthn/src/proto/ctap2/model/make_credential.rs

@@ -7,10 +7,9 @@ use super::{
 use crate::{
     fido::AuthenticatorData,
     ops::webauthn::{
-        CredentialProtectionPolicy, ResidentKeyRequirement,
-        MakeCredentialHmacOrPrfInput, MakeCredentialLargeBlobExtension, MakeCredentialRequest,
-        MakeCredentialResponse, MakeCredentialsRequestExtensions,
-        MakeCredentialsResponseUnsignedExtensions,
+        CredentialProtectionPolicy, MakeCredentialHmacOrPrfInput, MakeCredentialLargeBlobExtension,
+        MakeCredentialRequest, MakeCredentialResponse, MakeCredentialsRequestExtensions,
+        MakeCredentialsResponseUnsignedExtensions, ResidentKeyRequirement,
     },
     pin::PinUvAuthProtocol,
     proto::CtapError,
@@ -350,6 +349,10 @@ impl Ctap2UserVerifiableRequest for Ctap2MakeCredentialRequest {
     fn handle_legacy_preview(&mut self, _info: &Ctap2GetInfoResponse) {
         // No-op
     }
+
+    fn needs_shared_secret(&self, _get_info_response: &Ctap2GetInfoResponse) -> bool {
+        false
+    }
 }
 
 #[derive(Debug, Default, Clone, Serialize, Deserialize)]

libwebauthn/src/transport/channel.rs

@@ -96,12 +96,39 @@ impl Ctap2AuthTokenPermission {
 
 #[derive(Debug, Clone)]
 pub struct AuthTokenData {
-    pub shared_secret: Vec<u8>,
-    pub permission: Ctap2AuthTokenPermission,
-    pub pin_uv_auth_token: Vec<u8>,
     pub protocol_version: Ctap2PinUvAuthProtocol,
     pub key_agreement: PublicKey,
+    pub shared_secret: Vec<u8>,
     pub uv_operation: Ctap2UserVerificationOperation,
+    pub permission: Option<Ctap2AuthTokenPermission>,
+    pub pin_uv_auth_token: Option<Vec<u8>>,
+}
+
+impl AuthTokenData {
+    pub fn new(
+        shared_secret: Vec<u8>,
+        protocol_version: Ctap2PinUvAuthProtocol,
+        key_agreement: PublicKey,
+        uv_operation: Ctap2UserVerificationOperation,
+    ) -> Self {
+        Self {
+            protocol_version,
+            key_agreement,
+            shared_secret,
+            uv_operation,
+            permission: None,
+            pin_uv_auth_token: None,
+        }
+    }
+
+    pub fn store_auth_token(
+        &mut self,
+        permission: Ctap2AuthTokenPermission,
+        pin_uv_auth_token: Vec<u8>,
+    ) {
+        self.permission = Some(permission);
+        self.pin_uv_auth_token = Some(pin_uv_auth_token);
+    }
 }
 
 #[async_trait]
@@ -111,8 +138,10 @@ pub trait Ctap2AuthTokenStore {
     fn clear_uv_auth_token_store(&mut self);
     fn get_uv_auth_token(&self, requested_permission: &Ctap2AuthTokenPermission) -> Option<&[u8]> {
         if let Some(stored_data) = self.get_auth_data() {
-            if stored_data.permission.contains(requested_permission) {
-                return Some(&stored_data.pin_uv_auth_token);
+            if let Some(permission) = &stored_data.permission {
+                if permission.contains(requested_permission) {
+                    return stored_data.pin_uv_auth_token.as_deref();
+                }
             }
         }
         None