Fix #95, correct key ordering for CBOR encoding (#96)

See #95 for more context.

CTAP canonical CBOR encoding requires map keys to be sorted from shorter
key-length, to longer key-lenght.

No trivial root-cause fix due to serde_cbor, but thankfully the CBOR
data structures with string keys in libwebauthn are limited.

Added tests to prevent regressions.


## Test vectors

As decoded by [cbor.me](https://cbor.me).

### Ctap2CredentialType

```
A2                         # map(2)
   63                      # text(3)
      616C67               # "alg"
   26                      # negative(6)
   64                      # text(4)
      74797065             # "type"
   6A                      # text(10)
      7075626C69632D6B6579 # "public-key"
```

### Ctap2PublicKeyCredentialDescriptor

```
A2                         # map(2)
   62                      # text(2)
      6964                 # "id"
   41                      # bytes(1)
      42                   # "B"
   64                      # text(4)
      74797065             # "type"
   6A                      # text(10)
      7075626C69632D6B6579 # "public-key"
```

Author: AlfioEmanueleFresta

libwebauthn/Cargo.toml

@@ -41,7 +41,7 @@ num_enum = "0.7.1"
 x509-parser = "0.16.0"
 time = "0.3.35"
 curve25519-dalek = "4.1.3"
-hex = "0.4.2"
+hex = "0.4.3"
 mockall = "0.11.4"
 hidapi = { version = "2.4.1", default-features = false, features = [
     "linux-static-hidraw",

libwebauthn/src/proto/ctap2/model.rs

@@ -139,8 +139,8 @@ impl From<&Ctap1Transport> for Ctap2Transport {
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Ctap2PublicKeyCredentialDescriptor {
-    pub r#type: Ctap2PublicKeyCredentialType,
     pub id: ByteBuf,
+    pub r#type: Ctap2PublicKeyCredentialType,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     pub transports: Option<Vec<Ctap2Transport>>,
@@ -156,11 +156,11 @@ pub enum Ctap2COSEAlgorithmIdentifier {
 
 #[derive(Debug, Clone, Copy, Serialize, Deserialize)]
 pub struct Ctap2CredentialType {
-    #[serde(rename = "type")]
-    pub public_key_type: Ctap2PublicKeyCredentialType,
-
     #[serde(rename = "alg")]
     pub algorithm: Ctap2COSEAlgorithmIdentifier,
+
+    #[serde(rename = "type")]
+    pub public_key_type: Ctap2PublicKeyCredentialType,
 }
 
 impl Default for Ctap2CredentialType {
@@ -205,3 +205,40 @@ pub enum Ctap2UserVerificationOperation {
     GetPinToken,
     None,
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::proto::ctap2::Ctap2PublicKeyCredentialDescriptor;
+
+    use super::{Ctap2CredentialType, Ctap2COSEAlgorithmIdentifier, Ctap2PublicKeyCredentialType};
+    use serde_bytes::ByteBuf;
+    use serde_cbor;
+    use hex;
+
+    #[test]
+    /// Verify CBOR serialization conforms to CTAP canonical standard, including ordering (see #95) 
+    pub fn credential_type_field_serialization() {
+        let credential_type = Ctap2CredentialType {
+            algorithm: Ctap2COSEAlgorithmIdentifier::ES256,
+            public_key_type: Ctap2PublicKeyCredentialType::PublicKey,
+        };
+        let serialized = serde_cbor::to_vec(&credential_type).unwrap();
+        // Known good, verified by hand with cbor.me playground
+        let expected = hex::decode("a263616c672664747970656a7075626c69632d6b6579").unwrap();
+        assert_eq!(serialized, expected);
+    }
+
+    #[test]
+    /// Verify CBOR serialization conforms to CTAP canonical standard, including ordering (see #95) 
+    pub fn credential_descriptor_serialization() {
+        let credential_descriptor = Ctap2PublicKeyCredentialDescriptor {
+            id: ByteBuf::from(vec![0x42]),
+            r#type: Ctap2PublicKeyCredentialType::PublicKey,
+            transports: None,
+        };
+        let serialized = serde_cbor::to_vec(&credential_descriptor).unwrap();
+        // Known good, verified by hand with cbor.me playground
+        let expected = hex::decode("a2626964414264747970656a7075626c69632d6b6579").unwrap();
+        assert_eq!(serialized, expected);
+    }
+}