Migrate to thiserror v2. Error handling improvements.

Author: wolfmcnally

Cargo.toml

@@ -15,7 +15,7 @@ categories = ["cryptography"]                                      # https://cra
 bc-rand = "^0.4.0"
 bc-shamir = "^0.8.0"
 
-thiserror = "^1.0.48"
+thiserror = "^2.0"
 
 [dev-dependencies]
 hex-literal = "^0.4.1"

src/encoding.rs

@@ -1,6 +1,6 @@
 use bc_rand::RandomNumberGenerator;
 use bc_shamir::{split_secret, recover_secret};
-use crate::{SSKRError, METADATA_SIZE_BYTES, Secret, Spec, share::SSKRShare};
+use crate::{Error, Result, METADATA_SIZE_BYTES, Secret, Spec, share::SSKRShare};
 
 /// Generates SSKR shares for the given `Spec` and `Secret`.
 ///
@@ -11,7 +11,7 @@ use crate::{SSKRError, METADATA_SIZE_BYTES, Secret, Spec, share::SSKRShare};
 pub fn sskr_generate(
     spec: &Spec,
     master_secret: &Secret
-) -> Result<Vec<Vec<Vec<u8>>>, SSKRError> {
+) -> Result<Vec<Vec<Vec<u8>>>> {
     let mut rng = bc_rand::SecureRandomNumberGenerator;
     sskr_generate_using(spec, master_secret, &mut rng)
 }
@@ -29,7 +29,7 @@ pub fn sskr_generate_using(
     spec: &Spec,
     master_secret: &Secret,
     random_generator: &mut impl RandomNumberGenerator
-) -> Result<Vec<Vec<Vec<u8>>>, SSKRError> {
+) -> Result<Vec<Vec<Vec<u8>>>> {
     let groups_shares = generate_shares(spec, master_secret, random_generator)?;
 
     let result: Vec<Vec<Vec<u8>>> = groups_shares.iter().map (|group| {
@@ -49,7 +49,7 @@ pub fn sskr_generate_using(
 ///
 /// Returns an error if the shares do not meet the necessary quorum of groups
 /// and member shares within each group.
-pub fn sskr_combine<T>(shares: &[T]) -> Result<Secret, SSKRError>
+pub fn sskr_combine<T>(shares: &[T]) -> Result<Secret>
 where
     T: AsRef<[u8]>
 {
@@ -97,24 +97,24 @@ fn serialize_share(share: &SSKRShare) -> Vec<u8> {
     result
 }
 
-fn deserialize_share(source: &[u8]) -> Result<SSKRShare, SSKRError> {
+fn deserialize_share(source: &[u8]) -> Result<SSKRShare> {
     if source.len() < METADATA_SIZE_BYTES {
-        return Err(SSKRError::ShareLengthInvalid);
+        return Err(Error::ShareLengthInvalid);
     }
 
     let group_threshold = ((source[2] >> 4) + 1) as usize;
     let group_count = ((source[2] & 0xf) + 1) as usize;
 
     if group_threshold > group_count {
-        return Err(SSKRError::GroupThresholdInvalid);
+        return Err(Error::GroupThresholdInvalid);
     }
 
     let identifier = ((source[0] as u16) << 8) | source[1] as u16;
     let group_index = (source[3] >> 4) as usize;
     let member_threshold = ((source[3] & 0xf) + 1) as usize;
     let reserved = source[4] >> 4;
     if reserved != 0 {
-        return Err(SSKRError::ShareReservedBitsInvalid);
+        return Err(Error::ShareReservedBitsInvalid);
     }
     let member_index = (source[4] & 0xf) as usize;
     let value = Secret::new(&source[METADATA_SIZE_BYTES..])?;
@@ -134,22 +134,22 @@ fn generate_shares(
     spec: &Spec,
     master_secret: &Secret,
     random_generator: &mut impl RandomNumberGenerator
-) -> Result<Vec<Vec<SSKRShare>>, SSKRError> {
+) -> Result<Vec<Vec<SSKRShare>>> {
     // assign a random identifier
     let mut identifier = [0u8; 2];
     random_generator.fill_random_data(&mut identifier);
     let identifier: u16 = ((identifier[0] as u16) << 8) | identifier[1] as u16;
 
     let mut groups_shares: Vec<Vec<SSKRShare>> = Vec::with_capacity(spec.group_count());
 
-    let group_secrets = split_secret(spec.group_threshold(), spec.group_count(), master_secret.data(), random_generator).map_err(SSKRError::ShamirError)?;
+    let group_secrets = split_secret(spec.group_threshold(), spec.group_count(), master_secret.data(), random_generator).map_err(Error::ShamirError)?;
 
     for (group_index, group) in spec.groups().iter().enumerate() {
         let group_secret = &group_secrets[group_index];
         let member_secrets = split_secret(group.member_threshold(), group.member_count(), group_secret, random_generator)
-            .map_err(SSKRError::ShamirError)?
+            .map_err(Error::ShamirError)?
             .into_iter().map(Secret::new)
-            .collect::<Result<Vec<Secret>, _>>()?;
+            .collect::<Result<Vec<Secret>>>()?;
         let member_sskr_shares: Vec<SSKRShare> = member_secrets.into_iter().enumerate().map(|(member_index, member_secret)| {
             SSKRShare::new(
                 identifier,
@@ -186,13 +186,13 @@ impl Group {
     }
 }
 
-fn combine_shares(shares: &[SSKRShare]) -> Result<Secret, SSKRError> {
+fn combine_shares(shares: &[SSKRShare]) -> Result<Secret> {
     let mut identifier = 0;
     let mut group_threshold = 0;
     let mut group_count = 0;
 
     if shares.is_empty() {
-        return Err(SSKRError::SharesEmpty);
+        return Err(Error::SharesEmpty);
     }
 
     let mut next_group = 0;
@@ -213,7 +213,7 @@ fn combine_shares(shares: &[SSKRShare]) -> Result<Secret, SSKRError> {
                 share.group_count() != group_count ||
                 share.value().len() != secret_len
             {
-                return Err(SSKRError::ShareSetInvalid);
+                return Err(Error::ShareSetInvalid);
             }
         }
 
@@ -223,11 +223,11 @@ fn combine_shares(shares: &[SSKRShare]) -> Result<Secret, SSKRError> {
             if share.group_index() == group.group_index {
                 group_found = true;
                 if share.member_threshold() != group.member_threshold {
-                    return Err(SSKRError::MemberThresholdInvalid);
+                    return Err(Error::MemberThresholdInvalid);
                 }
                 for k in 0..group.member_indexes.len() {
                     if share.member_index() == group.member_indexes[k] {
-                        return Err(SSKRError::DuplicateMemberIndex);
+                        return Err(Error::DuplicateMemberIndex);
                     }
                 }
                 if group.member_indexes.len() < group.member_threshold {
@@ -248,7 +248,7 @@ fn combine_shares(shares: &[SSKRShare]) -> Result<Secret, SSKRError> {
 
     // Check that we have enough groups to recover the master secret
     if next_group < group_threshold {
-        return Err(SSKRError::NotEnoughGroups);
+        return Err(Error::NotEnoughGroups);
     }
 
     // Here, all of the shares are unpacked into member groups. Now we go through each
@@ -275,7 +275,7 @@ fn combine_shares(shares: &[SSKRShare]) -> Result<Secret, SSKRError> {
 
     // If we don't have enough groups to recover the master secret, return an error
     if master_indexes.len() < group_threshold {
-        return Err(SSKRError::NotEnoughGroups);
+        return Err(Error::NotEnoughGroups);
     }
 
     // Recover the master secret

src/error.rs

@@ -2,7 +2,7 @@ use thiserror::Error;
 
 /// Errors that can occur when using the SSKR library.
 #[derive(Debug, Error)]
-pub enum SSKRError {
+pub enum Error {
     #[error("When combining shares, the provided shares contained a duplicate member index")]
     DuplicateMemberIndex,
 
@@ -46,11 +46,7 @@ pub enum SSKRError {
     ShareSetInvalid,
 
     #[error("SSKR Shamir error: {0}")]
-    ShamirError(bc_shamir::Error),
+    ShamirError(#[from] bc_shamir::Error),
 }
 
-impl From<bc_shamir::Error> for SSKRError {
-    fn from(err: bc_shamir::Error) -> Self {
-        SSKRError::ShamirError(err)
-    }
-}
+pub type Result<T> = std::result::Result<T, Error>;

src/lib.rs

@@ -83,7 +83,7 @@ mod spec;
 pub use spec::{ Spec, GroupSpec };
 
 mod error;
-pub use error::SSKRError;
+pub use error::{ Error, Result };
 
 #[cfg(test)]
 mod tests {
@@ -108,7 +108,7 @@ mod tests {
             unimplemented!()
         }
 
-        fn try_fill_bytes(&mut self, _dest: &mut [u8]) -> Result<(), rand::Error> {
+        fn try_fill_bytes(&mut self, _dest: &mut [u8]) -> std::result::Result<(), rand::Error> {
             unimplemented!()
         }
     }
@@ -397,12 +397,12 @@ mod tests {
     /// Test fix for [#1](https://github.com/BlockchainCommons/bc-sskr-rust/issues/1).
     #[test]
     fn example_encode_3() {
-        use crate::{ SSKRError, Secret, GroupSpec, Spec, sskr_generate, sskr_combine };
+        use crate::{ Secret, GroupSpec, Spec, sskr_generate, sskr_combine };
         use std::str::from_utf8;
 
         const TEXT: &str = "my secret belongs to me.";
 
-        fn roundtrip(m: usize, n: usize) -> Result<Secret, SSKRError> {
+        fn roundtrip(m: usize, n: usize) -> Result<Secret> {
             let secret = Secret::new(TEXT).unwrap();
             let spec = Spec::new(1, vec![GroupSpec::new(m, n).unwrap()]).unwrap();
             let shares: Vec<Vec<Vec<u8>>> = sskr_generate(&spec, &secret).unwrap();

src/secret.rs

@@ -1,4 +1,4 @@
-use crate::{SSKRError, MIN_SECRET_LEN, MAX_SECRET_LEN};
+use crate::{Error, MIN_SECRET_LEN, MAX_SECRET_LEN};
 
 /// A secret to be split into shares.
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -15,20 +15,20 @@ impl Secret {
     ///
     /// Returns an error if the length of the secret is less than `MIN_SECRET_LEN`, greater than `MAX_SECRET_LEN`,
     /// or not even.
-    pub fn new<T>(data: T) -> Result<Self, SSKRError>
+    pub fn new<T>(data: T) -> Result<Self, Error>
     where
         T: AsRef<[u8]>,
     {
         let data = data.as_ref();
         let len = data.len();
         if len < MIN_SECRET_LEN {
-            return Err(SSKRError::SecretTooShort);
+            return Err(Error::SecretTooShort);
         }
         if len > MAX_SECRET_LEN {
-            return Err(SSKRError::SecretTooLong);
+            return Err(Error::SecretTooLong);
         }
         if len & 1 != 0 {
-            return Err(SSKRError::SecretLengthNotEven);
+            return Err(Error::SecretLengthNotEven);
         }
         Ok(Self(data.to_vec()))
     }

src/spec.rs

@@ -1,6 +1,6 @@
 use bc_shamir::MAX_SHARE_COUNT;
 
-use crate::SSKRError;
+use crate::Error;
 
 /// A specification for an SSKR split.
 #[derive(Debug, Clone, PartialEq)]
@@ -24,15 +24,15 @@ impl Spec {
     /// Returns an error if the group threshold is zero, if the group threshold
     /// is greater than the number of groups, or if the number of groups is
     /// greater than the maximum share count.
-    pub fn new(group_threshold: usize, groups: Vec<GroupSpec>) -> Result<Self, SSKRError> {
+    pub fn new(group_threshold: usize, groups: Vec<GroupSpec>) -> Result<Self, Error> {
         if group_threshold == 0 {
-            return Err(SSKRError::GroupThresholdInvalid);
+            return Err(Error::GroupThresholdInvalid);
         }
         if group_threshold > groups.len() {
-            return Err(SSKRError::GroupThresholdInvalid);
+            return Err(Error::GroupThresholdInvalid);
         }
         if groups.len() > MAX_SHARE_COUNT {
-            return Err(SSKRError::GroupCountInvalid);
+            return Err(Error::GroupCountInvalid);
         }
         Ok(Self {
             group_threshold,
@@ -83,15 +83,15 @@ impl GroupSpec {
     /// Returns an error if the member count is zero, if the member count is
     /// greater than the maximum share count, or if the member threshold is
     /// greater than the member count.
-    pub fn new(member_threshold: usize, member_count: usize) -> Result<Self, SSKRError> {
+    pub fn new(member_threshold: usize, member_count: usize) -> Result<Self, Error> {
         if member_count == 0 {
-            return Err(SSKRError::MemberCountInvalid);
+            return Err(Error::MemberCountInvalid);
         }
         if member_count > MAX_SHARE_COUNT {
-            return Err(SSKRError::MemberCountInvalid);
+            return Err(Error::MemberCountInvalid);
         }
         if member_threshold > member_count {
-            return Err(SSKRError::MemberThresholdInvalid);
+            return Err(Error::MemberThresholdInvalid);
         }
         Ok(Self { member_threshold, member_count })
     }
@@ -107,16 +107,16 @@ impl GroupSpec {
     }
 
     /// Parses a group specification from a string.
-    pub fn parse(s: &str) -> Result<Self, SSKRError> {
+    pub fn parse(s: &str) -> Result<Self, Error> {
         let parts: Vec<&str> = s.split('-').collect();
         if parts.len() != 3 {
-            return Err(SSKRError::GroupSpecInvalid);
+            return Err(Error::GroupSpecInvalid);
         }
-        let member_threshold = parts[0].parse::<usize>().map_err(|_| SSKRError::GroupSpecInvalid)?;
+        let member_threshold = parts[0].parse::<usize>().map_err(|_| Error::GroupSpecInvalid)?;
         if parts[1] != "of" {
-            return Err(SSKRError::GroupSpecInvalid);
+            return Err(Error::GroupSpecInvalid);
         }
-        let member_count = parts[2].parse::<usize>().map_err(|_| SSKRError::GroupSpecInvalid)?;
+        let member_count = parts[2].parse::<usize>().map_err(|_| Error::GroupSpecInvalid)?;
         Self::new(member_threshold, member_count)
     }
 }