resolved the issue of mapping RegisterError::KeyInvalid

Author: curiecrypt

mithril-stm/src/aggregate_signature/proof/concatenation.rs

@@ -8,8 +8,8 @@ use crate::bls_multi_signature::{BlsSignature, BlsVerificationKey};
 use crate::key_registration::RegisteredParty;
 use crate::merkle_tree::MerkleBatchPath;
 use crate::{
-    AggregateVerificationKey, BasicVerifier, Parameters, SingleSignature,
-    SingleSignatureWithRegisteredParty, StmAggregateSignatureError, StmResult,
+    AggregateSignatureError, AggregateVerificationKey, BasicVerifier, Parameters, SingleSignature,
+    SingleSignatureWithRegisteredParty, StmResult,
 };
 
 /// `ConcatenationProof` uses the "concatenation" proving system (as described in Section 4.3 of the original paper.)
@@ -211,25 +211,25 @@ impl<D: Clone + Digest + FixedOutput + Send + Sync> ConcatenationProof<D> {
         u64_bytes.copy_from_slice(
             bytes
                 .get(bytes_index..bytes_index + 8)
-                .ok_or(StmAggregateSignatureError::SerializationError)?,
+                .ok_or(AggregateSignatureError::SerializationError)?,
         );
         let total_sigs = usize::try_from(u64::from_be_bytes(u64_bytes))
-            .map_err(|_| StmAggregateSignatureError::SerializationError)?;
+            .map_err(|_| AggregateSignatureError::SerializationError)?;
         bytes_index += 8;
 
         let mut sig_reg_list = Vec::with_capacity(total_sigs);
         for _ in 0..total_sigs {
             u64_bytes.copy_from_slice(
                 bytes
                     .get(bytes_index..bytes_index + 8)
-                    .ok_or(StmAggregateSignatureError::SerializationError)?,
+                    .ok_or(AggregateSignatureError::SerializationError)?,
             );
             let sig_reg_size = usize::try_from(u64::from_be_bytes(u64_bytes))
-                .map_err(|_| StmAggregateSignatureError::SerializationError)?;
+                .map_err(|_| AggregateSignatureError::SerializationError)?;
             let sig_reg = SingleSignatureWithRegisteredParty::from_bytes::<D>(
                 bytes
                     .get(bytes_index + 8..bytes_index + 8 + sig_reg_size)
-                    .ok_or(StmAggregateSignatureError::SerializationError)?,
+                    .ok_or(AggregateSignatureError::SerializationError)?,
             )?;
             bytes_index += 8 + sig_reg_size;
             sig_reg_list.push(sig_reg);
@@ -238,7 +238,7 @@ impl<D: Clone + Digest + FixedOutput + Send + Sync> ConcatenationProof<D> {
         let batch_proof = MerkleBatchPath::from_bytes(
             bytes
                 .get(bytes_index..)
-                .ok_or(StmAggregateSignatureError::SerializationError)?,
+                .ok_or(AggregateSignatureError::SerializationError)?,
         )?;
 
         Ok(ConcatenationProof {

mithril-stm/src/aggregate_signature/signature.rs

@@ -6,7 +6,7 @@ use std::hash::Hash;
 use blake2::digest::{Digest, FixedOutput};
 use serde::{Deserialize, Serialize};
 
-use crate::error::StmAggregateSignatureError;
+use crate::error::AggregateSignatureError;
 use crate::merkle_tree::MerkleBatchPath;
 use crate::{AggregateVerificationKey, Parameters, StmResult};
 
@@ -103,7 +103,7 @@ impl<D: Clone + Digest + FixedOutput + Send + Sync> AggregateSignature<D> {
             }
             #[cfg(feature = "future_proof_system")]
             AggregateSignature::Future => Err(anyhow!(
-                StmAggregateSignatureError::UnsupportedProofSystem(self.into())
+                AggregateSignatureError::UnsupportedProofSystem(self.into())
             )),
         }
     }
@@ -131,7 +131,7 @@ impl<D: Clone + Digest + FixedOutput + Send + Sync> AggregateSignature<D> {
                             .filter_map(|s| s.to_concatenation_proof().cloned())
                             .collect::<Vec<_>>();
                         if concatenation_proofs.len() != aggregate_signatures_length {
-                            return Err(anyhow!(StmAggregateSignatureError::BatchInvalid));
+                            return Err(anyhow!(AggregateSignatureError::BatchInvalid));
                         }
 
                         ConcatenationProof::batch_verify(
@@ -142,14 +142,12 @@ impl<D: Clone + Digest + FixedOutput + Send + Sync> AggregateSignature<D> {
                         )
                     }
                     #[cfg(feature = "future_proof_system")]
-                    AggregateSignatureType::Future => {
-                        Err(anyhow!(StmAggregateSignatureError::UnsupportedProofSystem(
-                            aggregate_signature_type
-                        )))
-                    }
+                    AggregateSignatureType::Future => Err(anyhow!(
+                        AggregateSignatureError::UnsupportedProofSystem(aggregate_signature_type)
+                    )),
                 }
             })
-            .map_err(|_| anyhow!(StmAggregateSignatureError::BatchInvalid))
+            .map_err(|_| anyhow!(AggregateSignatureError::BatchInvalid))
     }
 
     /// Convert an aggregate signature to bytes
@@ -173,11 +171,10 @@ impl<D: Clone + Digest + FixedOutput + Send + Sync> AggregateSignature<D> {
 
     /// Extract an aggregate signature from a byte slice.
     pub fn from_bytes(bytes: &[u8]) -> StmResult<Self> {
-        let proof_type_byte =
-            bytes.first().ok_or(StmAggregateSignatureError::SerializationError)?;
+        let proof_type_byte = bytes.first().ok_or(AggregateSignatureError::SerializationError)?;
         let proof_bytes = &bytes[1..];
         let proof_type = AggregateSignatureType::from_byte_encoding_prefix(*proof_type_byte)
-            .ok_or(StmAggregateSignatureError::SerializationError)?;
+            .ok_or(AggregateSignatureError::SerializationError)?;
         match proof_type {
             AggregateSignatureType::Concatenation => Ok(AggregateSignature::Concatenation(
                 ConcatenationProof::from_bytes(proof_bytes)?,

mithril-stm/src/bls_multi_signature/mod.rs

@@ -94,6 +94,7 @@ mod tests {
     use rand_chacha::ChaCha20Rng;
     use rand_core::{RngCore, SeedableRng};
 
+    use crate::RegisterError;
     use crate::bls_multi_signature::helper::unsafe_helpers::{p1_affine_to_sig, p2_affine_to_vk};
     use crate::error::MultiSignatureError;
     use crate::key_registration::KeyRegistration;
@@ -199,8 +200,8 @@ mod tests {
 
             assert!(
                 matches!(
-                    error.downcast_ref::<MultiSignatureError>(),
-                    Some(MultiSignatureError::VerificationKeyInfinity(_))
+                    error.downcast_ref::<RegisterError>(),
+                    Some(RegisterError::KeyInvalid(_))
                 ),
                 "Unexpected error: {error:?}");
         }

mithril-stm/src/error.rs

@@ -58,7 +58,7 @@ pub enum MerkleTreeError {
 
 /// Errors which can be output by Mithril single signature verification.
 #[derive(Debug, Clone, thiserror::Error)]
-pub enum StmSignatureError {
+pub enum SignatureError {
     /// There is an index out of bounds
     #[error("Received index, {0}, is higher than what the security parameter allows, {1}.")]
     IndexBoundFailed(u64, u64),
@@ -89,7 +89,7 @@ pub enum AggregationError {
 
 /// Errors which can be output by Mithril aggregate verification.
 #[derive(Debug, Clone, thiserror::Error)]
-pub enum StmAggregateSignatureError {
+pub enum AggregateSignatureError {
     /// This error occurs when the the serialization of the raw bytes failed
     #[error("Invalid bytes")]
     SerializationError,

mithril-stm/src/key_registration.rs

@@ -38,7 +38,8 @@ impl KeyRegistration {
         pk: BlsVerificationKeyProofOfPossession,
     ) -> StmResult<()> {
         if let Entry::Vacant(e) = self.keys.entry(pk.vk) {
-            pk.verify_proof_of_possession()?;
+            pk.verify_proof_of_possession()
+                .map_err(|_| RegisterError::KeyInvalid(Box::new(pk)))?;
             e.insert(stake);
             return Ok(());
         }

mithril-stm/src/lib.rs

@@ -125,8 +125,7 @@ pub use aggregate_signature::{
     AggregateSignature, AggregateSignatureType, AggregateVerificationKey, BasicVerifier, Clerk,
 };
 pub use error::{
-    AggregationError, MultiSignatureError, RegisterError, StmAggregateSignatureError,
-    StmSignatureError,
+    AggregateSignatureError, AggregationError, MultiSignatureError, RegisterError, SignatureError,
 };
 pub use key_registration::{ClosedKeyRegistration, KeyRegistration};
 pub use parameters::Parameters;

mithril-stm/src/single_signature/signature.rs

@@ -9,8 +9,7 @@ use serde::{Deserialize, Serialize};
 use crate::bls_multi_signature::BlsSignature;
 use crate::eligibility_check::is_lottery_won;
 use crate::{
-    AggregateVerificationKey, Index, Parameters, Stake, StmResult, StmSignatureError,
-    VerificationKey,
+    AggregateVerificationKey, Index, Parameters, SignatureError, Stake, StmResult, VerificationKey,
 };
 use anyhow::{Context, anyhow};
 
@@ -57,15 +56,13 @@ impl SingleSignature {
     ) -> StmResult<()> {
         for &index in &self.indexes {
             if index > params.m {
-                return Err(anyhow!(StmSignatureError::IndexBoundFailed(
-                    index, params.m
-                )));
+                return Err(anyhow!(SignatureError::IndexBoundFailed(index, params.m)));
             }
 
             let ev = self.sigma.evaluate_dense_mapping(msg, index);
 
             if !is_lottery_won(params.phi_f, ev, *stake, *total_stake) {
-                return Err(anyhow!(StmSignatureError::LotteryLost));
+                return Err(anyhow!(SignatureError::LotteryLost));
             }
         }
 
@@ -99,15 +96,15 @@ impl SingleSignature {
     pub fn from_bytes<D: Clone + Digest + FixedOutput>(bytes: &[u8]) -> StmResult<SingleSignature> {
         let mut u64_bytes = [0u8; 8];
 
-        u64_bytes.copy_from_slice(bytes.get(0..8).ok_or(StmSignatureError::SerializationError)?);
+        u64_bytes.copy_from_slice(bytes.get(0..8).ok_or(SignatureError::SerializationError)?);
         let nr_indexes = u64::from_be_bytes(u64_bytes) as usize;
 
         let mut indexes = Vec::new();
         for i in 0..nr_indexes {
             u64_bytes.copy_from_slice(
                 bytes
                     .get(8 + i * 8..16 + i * 8)
-                    .ok_or(StmSignatureError::SerializationError)?,
+                    .ok_or(SignatureError::SerializationError)?,
             );
             indexes.push(u64::from_be_bytes(u64_bytes));
         }
@@ -116,13 +113,13 @@ impl SingleSignature {
         let sigma = BlsSignature::from_bytes(
             bytes
                 .get(offset..offset + 48)
-                .ok_or(StmSignatureError::SerializationError)?,
+                .ok_or(SignatureError::SerializationError)?,
         )?;
 
         u64_bytes.copy_from_slice(
             bytes
                 .get(offset + 48..offset + 56)
-                .ok_or(StmSignatureError::SerializationError)?,
+                .ok_or(SignatureError::SerializationError)?,
         );
         let signer_index = u64::from_be_bytes(u64_bytes);
 

mithril-stm/src/single_signature/signature_registered_party.rs

@@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize, Serializer, ser::SerializeTuple};
 
 use crate::StmResult;
 use crate::key_registration::RegisteredParty;
-use crate::{SingleSignature, StmSignatureError};
+use crate::{SignatureError, SingleSignature};
 
 /// Signature with its registered party.
 #[derive(Debug, Clone, Hash, Deserialize, Eq, PartialEq, Ord, PartialOrd)]
@@ -31,10 +31,10 @@ impl SingleSignatureWithRegisteredParty {
         bytes: &[u8],
     ) -> StmResult<SingleSignatureWithRegisteredParty> {
         let reg_party = RegisteredParty::from_bytes(
-            bytes.get(0..104).ok_or(StmSignatureError::SerializationError)?,
+            bytes.get(0..104).ok_or(SignatureError::SerializationError)?,
         )?;
         let sig = SingleSignature::from_bytes::<D>(
-            bytes.get(104..).ok_or(StmSignatureError::SerializationError)?,
+            bytes.get(104..).ok_or(SignatureError::SerializationError)?,
         )?;
 
         Ok(SingleSignatureWithRegisteredParty { sig, reg_party })