[Clean] safer unwrap & except handling

crypto/src/keypair.rs

@@ -498,13 +498,14 @@ impl Keyring {
         use crate::error::CryptoError;
         let mut offset = 0;
         let read_key = |offset: &mut usize| -> Result<Vec<u8>, CryptoError> {
-            let len = u16::from_be_bytes(
-                bytes
-                    .get(*offset..*offset + 2)
-                    .ok_or(CryptoError::InvalidKeyLength)?
-                    .try_into()
-                    .expect("slice is 2 bytes, verified above"),
-            ) as usize;
+            let slice = bytes
+                .get(*offset..*offset + 2)
+                .ok_or(CryptoError::InvalidKeyLength)?;
+            let len = if let Ok(arr) = <[u8; 2]>::try_from(slice) {
+                u16::from_be_bytes(arr)
+            } else {
+                return Err(CryptoError::InvalidKeyLength);
+            } as usize;
             *offset += 2;
             let key = bytes
                 .get(*offset..*offset + len)
@@ -712,14 +713,14 @@ mod tests {
     use super::*;
 
     #[test]
-    fn public_key_bundle_roundtrip() {
+    fn public_key_bundle_roundtrip() -> Result<(), Box<dyn std::error::Error>> {
         let kem = KemPublicKey::new(vec![1u8; 32]);
         let pq = SignaturePqPublicKey::new(vec![2u8; 64]);
         let cl = SignaturePublicKey::new(vec![3u8; 32]);
 
         let bundle = PublicKeyBundle::new(kem, pq, cl);
         let bytes = bundle.as_bytes();
-        let recovered = PublicKeyBundle::from_bytes(&bytes).unwrap();
+        let recovered = PublicKeyBundle::from_bytes(&bytes)?;
 
         assert_eq!(
             bundle.kem_public_key.as_bytes(),
@@ -733,22 +734,24 @@ mod tests {
             bundle.sig_cl_public_key.as_bytes(),
             recovered.sig_cl_public_key.as_bytes()
         );
+        Ok(())
     }
 
     #[test]
-    fn public_key_bundle_try_from_roundtrip() {
+    fn public_key_bundle_try_from_roundtrip() -> Result<(), Box<dyn std::error::Error>> {
         let bundle = PublicKeyBundle::new(
             KemPublicKey::new(vec![0xABu8; 48]),
             SignaturePqPublicKey::new(vec![0xCDu8; 96]),
             SignaturePublicKey::new(vec![0xEFu8; 32]),
         );
         let bytes: Vec<u8> = Vec::from(&bundle);
-        let recovered = PublicKeyBundle::try_from(bytes.as_slice()).unwrap();
+        let recovered = PublicKeyBundle::try_from(bytes.as_slice())?;
         assert_eq!(bundle.as_bytes(), recovered.as_bytes());
+        Ok(())
     }
 
     #[test]
-    fn keyring_roundtrip() {
+    fn keyring_roundtrip() -> Result<(), Box<dyn std::error::Error>> {
         let keyring = Keyring::new(
             KemPublicKey::new(vec![1u8; 32]),
             KemPrivateKey::new(vec![2u8; 32]),
@@ -758,7 +761,7 @@ mod tests {
             SignaturePrivateKey::new(vec![6u8; 32]),
         );
         let bytes = keyring.to_bytes();
-        let recovered = Keyring::from_bytes(&bytes).unwrap();
+        let recovered = Keyring::from_bytes(&bytes)?;
         assert_eq!(
             keyring.kem_public_key.as_bytes(),
             recovered.kem_public_key.as_bytes()
@@ -771,10 +774,11 @@ mod tests {
             keyring.sig_cl_public_key.as_bytes(),
             recovered.sig_cl_public_key.as_bytes()
         );
+        Ok(())
     }
 
     #[test]
-    fn keyring_try_from_roundtrip() {
+    fn keyring_try_from_roundtrip() -> Result<(), Box<dyn std::error::Error>> {
         let keyring = Keyring::new(
             KemPublicKey::new(vec![0u8; 16]),
             KemPrivateKey::new(vec![1u8; 16]),
@@ -784,21 +788,23 @@ mod tests {
             SignaturePrivateKey::new(vec![5u8; 16]),
         );
         let bytes: Vec<u8> = Vec::from(&keyring);
-        let recovered = Keyring::try_from(bytes.as_slice()).unwrap();
+        let recovered = Keyring::try_from(bytes.as_slice())?;
         assert_eq!(keyring.to_bytes(), recovered.to_bytes());
+        Ok(())
     }
 
     #[test]
-    fn hex_roundtrip() {
+    fn hex_roundtrip() -> Result<(), Box<dyn std::error::Error>> {
         let key = KemPublicKey::new(vec![0xDE, 0xAD, 0xBE, 0xEF]);
         let hex = key.to_hex();
         assert_eq!(hex, "deadbeef");
-        let recovered = KemPublicKey::from_hex(&hex).unwrap();
+        let recovered = KemPublicKey::from_hex(&hex)?;
         assert_eq!(key.as_bytes(), recovered.as_bytes());
+        Ok(())
     }
 
     #[test]
-    fn keyring_hex_roundtrip() {
+    fn keyring_hex_roundtrip() -> Result<(), Box<dyn std::error::Error>> {
         let keyring = Keyring::new(
             KemPublicKey::new(vec![1u8; 16]),
             KemPrivateKey::new(vec![2u8; 16]),
@@ -808,12 +814,13 @@ mod tests {
             SignaturePrivateKey::new(vec![6u8; 16]),
         );
         let hex = keyring.to_hex();
-        let recovered = Keyring::from_hex(&hex).unwrap();
+        let recovered = Keyring::from_hex(&hex)?;
         assert_eq!(keyring.to_bytes(), recovered.to_bytes());
+        Ok(())
     }
 
     #[test]
-    fn keyring_base64_roundtrip() {
+    fn keyring_base64_roundtrip() -> Result<(), Box<dyn std::error::Error>> {
         let keyring = Keyring::new(
             KemPublicKey::new(vec![1u8; 16]),
             KemPrivateKey::new(vec![2u8; 16]),
@@ -823,20 +830,22 @@ mod tests {
             SignaturePrivateKey::new(vec![6u8; 16]),
         );
         let b64 = keyring.to_base64();
-        let recovered = Keyring::from_base64(&b64).unwrap();
+        let recovered = Keyring::from_base64(&b64)?;
         assert_eq!(keyring.to_bytes(), recovered.to_bytes());
+        Ok(())
     }
 
     #[test]
-    fn public_key_bundle_base64_roundtrip() {
+    fn public_key_bundle_base64_roundtrip() -> Result<(), Box<dyn std::error::Error>> {
         let bundle = PublicKeyBundle::new(
             KemPublicKey::new(vec![1u8; 32]),
             SignaturePqPublicKey::new(vec![2u8; 64]),
             SignaturePublicKey::new(vec![3u8; 32]),
         );
         let b64 = bundle.to_base64();
-        let recovered = PublicKeyBundle::from_base64(&b64).unwrap();
+        let recovered = PublicKeyBundle::from_base64(&b64)?;
         assert_eq!(bundle.as_bytes(), recovered.as_bytes());
+        Ok(())
     }
 
     #[test]