Fix clippy warnings

Author: sosthene-nitrokey

core/src/mechanisms.rs

@@ -29,7 +29,7 @@ pub trait Aes256Cbc: CryptoClient {
             wrapping_key,
             key,
             &[],
-            iv.and_then(|iv| ShortData::try_from(iv).ok()),
+            iv.map(ShortData::from),
         )
     }
 }
@@ -66,7 +66,7 @@ pub trait Chacha8Poly1305: CryptoClient {
             key,
             message,
             associated_data,
-            nonce.and_then(|nonce| ShortData::try_from(nonce).ok()),
+            nonce.map(ShortData::from),
         )
     }
 
@@ -109,7 +109,7 @@ pub trait Chacha8Poly1305: CryptoClient {
             wrapping_key,
             key,
             associated_data,
-            nonce.and_then(|nonce| ShortData::try_from(nonce).ok()),
+            nonce.map(ShortData::from),
         )
     }
 }

src/mechanisms/chacha8poly1305.rs

@@ -152,8 +152,8 @@ impl MechanismImpl for super::Chacha8Poly1305 {
             .try_into()
             .unwrap();
 
-        let nonce = ShortData::try_from(&nonce).unwrap();
-        let tag = ShortData::try_from(&tag).unwrap();
+        let nonce = ShortData::from(&nonce);
+        let tag = ShortData::from(&tag);
 
         // let ciphertext = Message::from_slice(&ciphertext).unwrap();
         Ok(reply::Encrypt {

src/mechanisms/ed255.rs

@@ -132,7 +132,7 @@ impl MechanismImpl for super::Ed255 {
                 let cose_pk = cosey::Ed25519PublicKey {
                     // x: Bytes::from_slice(public_key.x_coordinate()).unwrap(),
                     // x: Bytes::from_slice(&buf).unwrap(),
-                    x: Bytes::try_from(public_key.as_bytes()).unwrap(),
+                    x: Bytes::from(public_key.as_bytes()),
                 };
                 crate::cbor_serialize_bytes(&cose_pk).map_err(|_| Error::CborError)?
             }
@@ -187,7 +187,7 @@ impl MechanismImpl for super::Ed255 {
         let keypair = load_keypair(keystore, &key_id)?;
 
         let native_signature = keypair.sign(&request.message);
-        let our_signature = Signature::try_from(&native_signature.to_bytes()).unwrap();
+        let our_signature = Signature::from(&native_signature.to_bytes());
 
         // hprintln!("Ed255 signature:").ok();
         // hprintln!("msg: {:?}", &request.message).ok();

src/mechanisms/p256.rs

@@ -205,15 +205,15 @@ impl MechanismImpl for super::P256 {
         let serialized_key = match request.format {
             KeySerialization::EcdhEsHkdf256 => {
                 let cose_pk = cosey::EcdhEsHkdf256PublicKey {
-                    x: Bytes::try_from(&public_key.x()).unwrap(),
-                    y: Bytes::try_from(&public_key.y()).unwrap(),
+                    x: Bytes::from(&public_key.x()),
+                    y: Bytes::from(&public_key.y()),
                 };
                 crate::cbor_serialize_bytes(&cose_pk).map_err(|_| Error::CborError)?
             }
             KeySerialization::Cose => {
                 let cose_pk = cosey::P256PublicKey {
-                    x: Bytes::try_from(&public_key.x()).unwrap(),
-                    y: Bytes::try_from(&public_key.y()).unwrap(),
+                    x: Bytes::from(&public_key.x()),
+                    y: Bytes::from(&public_key.y()),
                 };
                 crate::cbor_serialize_bytes(&cose_pk).map_err(|_| Error::CborError)?
             }
@@ -269,9 +269,7 @@ impl MechanismImpl for super::P256 {
                 let l = signature.to_sec1_bytes(&mut buffer);
                 Signature::try_from(&buffer[..l]).unwrap()
             }
-            SignatureSerialization::Raw => {
-                Signature::try_from(&signature.to_untagged_bytes()).unwrap()
-            }
+            SignatureSerialization::Raw => Signature::from(&signature.to_untagged_bytes()),
             _ => {
                 return Err(Error::InvalidSerializationFormat);
             }
@@ -354,9 +352,7 @@ impl MechanismImpl for super::P256Prehashed {
                 let l = signature.to_sec1_bytes(&mut buffer);
                 Signature::try_from(&buffer[..l]).unwrap()
             }
-            SignatureSerialization::Raw => {
-                Signature::try_from(&signature.to_untagged_bytes()).unwrap()
-            }
+            SignatureSerialization::Raw => Signature::from(&signature.to_untagged_bytes()),
             _ => {
                 return Err(Error::InvalidSerializationFormat);
             }

src/tests.rs

@@ -951,7 +951,7 @@ fn filesystem() {
     .metadata
     .is_none(),);
 
-    let data = Bytes::try_from(&[0; 20]).unwrap();
+    let data = Bytes::from(&[0; 20]);
     block!(client
         .write_file(Location::Internal, path.clone(), data.clone(), None,)
         .expect("no client error"))

tests/filesystem.rs

@@ -60,13 +60,13 @@ fn iterating(location: Location) {
         syscall!(client.write_file(
             location,
             PathBuf::from(path!("foo")),
-            Bytes::try_from(b"foo").unwrap(),
+            Bytes::from(b"foo"),
             None
         ));
         syscall!(client.write_file(
             location,
             PathBuf::from(path!("bar")),
-            Bytes::try_from(b"bar").unwrap(),
+            Bytes::from(b"bar"),
             None
         ));
         let first_entry = syscall!(client.read_dir_first(location, PathBuf::new(), None))

tests/serde_extensions.rs

@@ -384,8 +384,8 @@ pub fn run<F: FnOnce(&mut Client<'_>)>(backends: &'static [BackendId<runner::id:
 fn test_extension() {
     use extensions::TestClient as _;
 
-    let msg = ShortData::try_from(&[0x01, 0x02, 0x03]).unwrap();
-    let rev = ShortData::try_from(&[0x03, 0x02, 0x01]).unwrap();
+    let msg = ShortData::from(&[0x01, 0x02, 0x03]);
+    let rev = ShortData::from(&[0x03, 0x02, 0x01]);
     run(&[], |client| {
         assert!(trussed::try_syscall!(client.reverse(msg.clone())).is_err());
     });
@@ -409,9 +409,9 @@ fn sample_extension() {
     use extensions::SampleClient as _;
     use extensions::TestClient as _;
 
-    let msg = ShortData::try_from(&[1, 2, 3, 4]).unwrap();
-    let rev = ShortData::try_from(&[4, 3, 2, 1]).unwrap();
-    let trunc = ShortData::try_from(&[1, 2, 3]).unwrap();
+    let msg = ShortData::from(&[1, 2, 3, 4]);
+    let rev = ShortData::from(&[4, 3, 2, 1]);
+    let trunc = ShortData::from(&[1, 2, 3]);
     run(&[], |client| {
         assert!(trussed::try_syscall!(client.truncate(msg.clone())).is_err());
     });
@@ -440,9 +440,9 @@ fn mixed_extension() {
     use extensions::SampleClient as _;
     use extensions::TestClient as _;
 
-    let msg = ShortData::try_from(&[1, 2, 3, 4]).unwrap();
-    let rev = ShortData::try_from(&[4, 3, 2, 1]).unwrap();
-    let trunc = ShortData::try_from(&[1, 2, 3]).unwrap();
+    let msg = ShortData::from(&[1, 2, 3, 4]);
+    let rev = ShortData::from(&[4, 3, 2, 1]);
+    let trunc = ShortData::from(&[1, 2, 3]);
     run(runner::BACKENDS_MIXED, |client| {
         assert_eq!(trussed::syscall!(client.sample_calls()).calls, 0);
         assert_eq!(trussed::syscall!(client.test_calls()).calls, 0);