Fix lint

Author: sosthene-nitrokey

src/credential.rs

@@ -795,20 +795,20 @@ mod test {
     fn credential_data() -> CredentialData {
         CredentialData {
             rp: Rp::new(PublicKeyCredentialRpEntity {
-                id: String::from("John Doe"),
+                id: String::try_from("John Doe").unwrap(),
                 name: None,
                 icon: None,
             }),
             user: User::new(PublicKeyCredentialUserEntity {
-                id: Bytes::from_slice(&[1, 2, 3]).unwrap(),
+                id: Bytes::try_from(&[1, 2, 3]).unwrap(),
                 icon: None,
                 name: None,
                 display_name: None,
             }),
             creation_time: 123,
             use_counter: false,
             algorithm: -7,
-            key: Key::WrappedKey(Bytes::from_slice(&[1, 2, 3]).unwrap()),
+            key: Key::WrappedKey(Bytes::try_from(&[1, 2, 3]).unwrap()),
             hmac_secret: Some(false),
             cred_protect: None,
             use_short_id: Some(true),
@@ -822,15 +822,15 @@ mod test {
             rp: Rp {
                 format: SerializationFormat::Long,
                 inner: PublicKeyCredentialRpEntity {
-                    id: String::from("John Doe"),
+                    id: String::try_from("John Doe").unwrap(),
                     name: None,
                     icon: None,
                 },
             },
             user: User {
                 format: SerializationFormat::Long,
                 inner: PublicKeyCredentialUserEntity {
-                    id: Bytes::from_slice(&[1, 2, 3]).unwrap(),
+                    id: Bytes::try_from(&[1, 2, 3]).unwrap(),
                     icon: None,
                     name: None,
                     display_name: None,
@@ -839,7 +839,7 @@ mod test {
             creation_time: 123,
             use_counter: false,
             algorithm: -7,
-            key: Key::WrappedKey(Bytes::from_slice(&[1, 2, 3]).unwrap()),
+            key: Key::WrappedKey(Bytes::try_from(&[1, 2, 3]).unwrap()),
             hmac_secret: Some(false),
             cred_protect: None,
             use_short_id: None,
@@ -866,7 +866,7 @@ mod test {
         let between = Uniform::from(0..(N + 1));
         let n = between.sample(&mut OsRng);
 
-        bytes.resize_default(n).unwrap();
+        bytes.resize_zero(n).unwrap();
 
         OsRng.fill_bytes(&mut bytes);
         bytes
@@ -1080,7 +1080,7 @@ mod test {
     #[test]
     fn max_credential_id() {
         let rp_id: String<256> = core::iter::repeat_n('?', 256).collect();
-        let key = Bytes::from_slice(&[u8::MAX; 128]).unwrap();
+        let key = Bytes::try_from(&[u8::MAX; 128]).unwrap();
         let credential = StrippedCredential {
             ctap: CtapVersion::Fido21Pre,
             creation_time: u32::MAX,
@@ -1161,8 +1161,8 @@ mod test {
 
         fn inner(&self) -> PublicKeyCredentialRpEntity {
             PublicKeyCredentialRpEntity {
-                id: self.id.into(),
-                name: self.name.map(From::from),
+                id: self.id.try_into().unwrap(),
+                name: self.name.map(|n| n.try_into().unwrap()),
                 icon: None,
             }
         }
@@ -1226,10 +1226,10 @@ mod test {
 
         fn inner(&self) -> PublicKeyCredentialUserEntity {
             PublicKeyCredentialUserEntity {
-                id: Bytes::from_slice(self.id).unwrap(),
-                icon: self.icon.map(From::from),
-                name: self.name.map(From::from),
-                display_name: self.display_name.map(From::from),
+                id: Bytes::try_from(self.id).unwrap(),
+                icon: self.icon.map(|v| v.try_into().unwrap()),
+                name: self.name.map(|v| v.try_into().unwrap()),
+                display_name: self.display_name.map(|v| v.try_into().unwrap()),
             }
         }
     }
@@ -1301,7 +1301,7 @@ mod test {
         "
         );
 
-        let credential = FullCredential::deserialize(&Bytes::from_slice(&data).unwrap()).unwrap();
+        let credential = FullCredential::deserialize(&Bytes::try_from(&data).unwrap()).unwrap();
         assert!(matches!(credential.ctap, CtapVersion::Fido21Pre));
         assert_eq!(credential.nonce, &hex!("F62CA01ED181A3D03D561FC7"));
         assert_eq!(
@@ -1310,17 +1310,17 @@ mod test {
                 rp: Rp {
                     format: SerializationFormat::Long,
                     inner: PublicKeyCredentialRpEntity {
-                        id: "webauthn.io".into(),
+                        id: "webauthn.io".try_into().unwrap(),
                         name: None,
                         icon: None,
                     },
                 },
                 user: User {
                     format: SerializationFormat::Long,
                     inner: PublicKeyCredentialUserEntity {
-                        id: Bytes::from_slice(&hex!("6447567A644445")).unwrap(),
+                        id: Bytes::try_from(&hex!("6447567A644445")).unwrap(),
                         icon: None,
-                        name: Some("test1".into()),
+                        name: Some("test1".try_into().unwrap()),
                         display_name: None,
                     },
                 },

src/ctap2.rs

@@ -96,7 +96,7 @@ impl<UP: UserPresence, T: TrussedRequirements> Authenticator for crate::Authenti
         let mut response = ctap2::get_info::Response::default();
         response.versions = versions;
         response.extensions = Some(extensions);
-        response.aaguid = Bytes::try_from(&aaguid).unwrap();
+        response.aaguid = Bytes::from(&aaguid);
         response.options = Some(options);
         response.transports = Some(transports);
         // 1200
@@ -900,11 +900,15 @@ impl<UP: UserPresence, T: TrussedRequirements> Authenticator for crate::Authenti
     fn vendor(&mut self, op: VendorOperation) -> Result<()> {
         info_now!("hello VO {:?}", &op);
         match op.into() {
-            0x79 => syscall!(self.trussed.debug_dump_store()),
-            _ => return Err(Error::InvalidCommand),
-        };
-
-        Ok(())
+            0x79 => {
+                #[allow(deprecated)]
+                {
+                    syscall!(self.trussed.debug_dump_store());
+                }
+                Err(Error::InvalidCommand)
+            }
+            _ => Err(Error::InvalidCommand),
+        }
     }
 
     #[inline(never)]
@@ -1286,7 +1290,7 @@ impl<UP: UserPresence, T: TrussedRequirements> crate::Authenticator<UP, T> {
 
                 // check pinAuth
                 let mut data: Bytes<{ sizes::MAX_CREDENTIAL_ID_LENGTH_PLUS_256 }> =
-                    Bytes::try_from(&[parameters.sub_command as u8]).unwrap();
+                    Bytes::from(&[parameters.sub_command as u8]);
                 let len = 1 + match parameters.sub_command {
                     Subcommand::EnumerateCredentialsBegin
                     | Subcommand::DeleteCredential
@@ -1468,7 +1472,7 @@ impl<UP: UserPresence, T: TrussedRequirements> crate::Authenticator<UP, T> {
             let cred_random = syscall!(self.trussed.derive_key(
                 Mechanism::HmacSha256,
                 credential_key,
-                Some(Bytes::try_from(&[get_assertion_state.uv_performed as u8]).unwrap()),
+                Some(Bytes::from(&[get_assertion_state.uv_performed as u8])),
                 StorageAttributes::new().set_persistence(Location::Volatile)
             ))
             .key;

src/ctap2/pin.rs

@@ -420,7 +420,7 @@ impl SharedSecret {
 
     fn generate_iv<T: CryptoClient>(&self, trussed: &mut T) -> ShortData {
         match self {
-            Self::V1 { .. } => ShortData::try_from(&[0; 16]).unwrap(),
+            Self::V1 { .. } => ShortData::from(&[0; 16]),
             Self::V2 { .. } => {
                 ShortData::try_from(&*syscall!(trussed.random_bytes(16)).bytes).unwrap()
             }