solving some complaints

Author: iquerejeta

mithril-aggregator/src/multi_signer.rs

@@ -189,7 +189,8 @@ impl MultiSigner for MultiSignerImpl {
 
         let message = &self.get_current_message().unwrap();
         let clerk = self.clerk();
-        match clerk.verify_sig(signature, message) {
+        let avk = clerk.compute_avk();
+        match signature.verify(&self.protocol_parameters.unwrap(), &avk, message) {
             Ok(_) => {
                 // Register single signature
                 self.single_signatures

mithril-common/src/crypto_helper/types.rs

@@ -1,8 +1,8 @@
 use mithril::key_reg::KeyReg;
 use mithril::multi_sig::SigningKey;
 use mithril::stm::{
-    Index, PartyId, Stake, StmClerk, StmInitializer, StmMultiSig, StmParameters, StmSig, StmSigner,
-    StmVerificationKey,
+    Index, PartyId, Stake, StmClerk, StmInitializer, StmAggrSig, StmParameters, StmSig, StmSigner,
+    StmVerificationKeyPoP,
 };
 
 pub type Bytes = Vec<u8>;
@@ -19,6 +19,6 @@ pub type ProtocolInitializer = StmInitializer;
 pub type ProtocolClerk = StmClerk<D>;
 pub type ProtocolKeyRegistration = KeyReg;
 pub type ProtocolSingleSignature = StmSig<D>;
-pub type ProtocolMultiSignature = StmMultiSig<D>;
-pub type ProtocolSignerVerificationKey = StmVerificationKey;
+pub type ProtocolMultiSignature = StmAggrSig<D>;
+pub type ProtocolSignerVerificationKey = StmVerificationKeyPoP;
 pub type ProtocolSignerSecretKey = SigningKey;

mithril-core/examples/key_registration.rs

@@ -3,7 +3,10 @@
 //! run presented in `tests/integration.rs`, we explicitly treat each party individually.
 
 use mithril::key_reg::{ClosedKeyReg, KeyReg};
-use mithril::stm::{Stake, StmClerk, StmInitializer, StmParameters, StmSig, StmSigner, StmVerificationKeyPoP, StmVerifier};
+use mithril::stm::{
+    Stake, StmClerk, StmInitializer, StmParameters, StmSig, StmSigner, StmVerificationKeyPoP,
+    StmVerifier,
+};
 
 use rand_chacha::ChaCha20Rng;
 use rand_core::{RngCore, SeedableRng};

mithril-core/src/c_api.rs

@@ -444,7 +444,8 @@ mod signer {
 
 mod key_reg {
     use crate::c_api::{
-        ClosedKeyRegPtr, KeyRegPtr, MerkleTreeCommitmentPtr, StmVerificationKeyPoPPtr, NULLPOINTERERR,
+        ClosedKeyRegPtr, KeyRegPtr, MerkleTreeCommitmentPtr, StmVerificationKeyPoPPtr,
+        NULLPOINTERERR,
     };
     use crate::error::RegisterError;
     use crate::key_reg::KeyReg;
@@ -609,7 +610,7 @@ mod clerk {
                     Err(VerificationFailure::LotteryLost) => -1,
                     Err(VerificationFailure::InvalidMerkleTree(_)) => -2,
                     Err(VerificationFailure::InvalidSignature(_)) => -3,
-                    Err(VerificationFailure::IndexBoundFailed(_,_)) => -4,
+                    Err(VerificationFailure::IndexBoundFailed(_, _)) => -4,
                 };
             }
             NULLPOINTERERR

mithril-core/src/key_reg.rs

@@ -2,9 +2,9 @@
 
 use crate::error::RegisterError;
 use digest::{Digest, FixedOutput};
+use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
-use serde::{Deserialize, Serialize};
 
 use super::multi_sig::VerificationKeyPoP;
 use super::stm::{PartyId, Stake};
@@ -26,8 +26,8 @@ pub struct KeyReg {
 /// a closed key registration.
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(bound(
-serialize = "MerkleTree<D>: Serialize",
-deserialize = "MerkleTree<D>: Deserialize<'de>"
+    serialize = "MerkleTree<D>: Serialize",
+    deserialize = "MerkleTree<D>: Deserialize<'de>"
 ))]
 pub struct ClosedKeyReg<D>
 where

mithril-core/src/stm.rs

@@ -276,7 +276,12 @@ pub struct StmSig<D: Clone + Digest + FixedOutput> {
 impl<D: Clone + Digest + FixedOutput> StmSig<D> {
     /// Verify an stm signature by checking that the lottery was won, the merkle path is correct,
     /// the index is in the desired range and the underlying msp signature validates.
-    pub fn verify(&self, params: &StmParameters, avk: &StmAggrVerificationKey<D>, msg: &[u8]) -> Result<(), VerificationFailure<D>> {
+    pub fn verify(
+        &self,
+        params: &StmParameters,
+        avk: &StmAggrVerificationKey<D>,
+        msg: &[u8],
+    ) -> Result<(), VerificationFailure<D>> {
         let msgp = avk.mt_commitment.concat_with_msg(msg);
 
         if self.index > params.m {
@@ -344,7 +349,7 @@ impl<D: Clone + Digest + FixedOutput> StmSig<D> {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct StmAggrVerificationKey<D>
 where
-    D: Clone + Digest + FixedOutput
+    D: Clone + Digest + FixedOutput,
 {
     mt_commitment: MerkleTreeCommitment<D>,
     total_stake: Stake,
@@ -357,7 +362,7 @@ where
     fn from(reg: &ClosedKeyReg<D>) -> Self {
         Self {
             mt_commitment: reg.merkle_tree.to_commitment(),
-            total_stake: reg.total_stake
+            total_stake: reg.total_stake,
         }
     }
 }
@@ -419,13 +424,29 @@ impl<D: Clone + Digest + FixedOutput> StmAggrSig<D> {
             }
 
             // Check that merkle paths are valid
-            if avk.mt_commitment.check(&MTLeaf(sig.pk, sig.stake), &sig.path).is_err() {
+            if avk
+                .mt_commitment
+                .check(&MTLeaf(sig.pk, sig.stake), &sig.path)
+                .is_err()
+            {
                 return Err(MithrilWitnessError::PathInvalid(sig.path.clone()));
             }
         }
 
-        let aggregate_signature: Signature = self.signatures.iter().map(|sig| sig.sigma).collect::<Vec<Signature>>().iter().sum();
-        let aggregate_mpk: StmVerificationKey = self.signatures.iter().map(|sig| sig.pk).collect::<Vec<StmVerificationKey>>().iter().sum();
+        let aggregate_signature: Signature = self
+            .signatures
+            .iter()
+            .map(|sig| sig.sigma)
+            .collect::<Vec<Signature>>()
+            .iter()
+            .sum();
+        let aggregate_mpk: StmVerificationKey = self
+            .signatures
+            .iter()
+            .map(|sig| sig.pk)
+            .collect::<Vec<StmVerificationKey>>()
+            .iter()
+            .sum();
 
         aggregate_signature.verify(&avk.mt_commitment.concat_with_msg(msg), &aggregate_mpk)?;
         Ok(())
@@ -633,10 +654,19 @@ where
         // sigma <- MSP.Sig(msk, msg')
         // ev <- MSP.Eval(msg', index, sigma)
         // return 1 if ev < phi(stake) else return 0
-        let msgp = self.closed_reg.merkle_tree.to_commitment().concat_with_msg(msg);
+        let msgp = self
+            .closed_reg
+            .merkle_tree
+            .to_commitment()
+            .concat_with_msg(msg);
         let sigma = self.sk.sign(&msgp);
         let ev = sigma.eval(&msgp, index);
-        ev_lt_phi(self.params.phi_f, ev, self.stake, self.closed_reg.total_stake)
+        ev_lt_phi(
+            self.params.phi_f,
+            ev,
+            self.stake,
+            self.closed_reg.total_stake,
+        )
     }
 
     /// If lottery is won for this message/index, signs it.
@@ -648,9 +678,16 @@ where
             //      p_i is the users path inside the merkle tree AVK
             //      reg_i is (mvk_i, stake_i)
             // return pi
-            let msgp = self.closed_reg.merkle_tree.to_commitment().concat_with_msg(msg);
+            let msgp = self
+                .closed_reg
+                .merkle_tree
+                .to_commitment()
+                .concat_with_msg(msg);
             let sigma = self.sk.sign(&msgp);
-            let path = self.closed_reg.merkle_tree.get_path(self.mt_index.try_into().unwrap());
+            let path = self
+                .closed_reg
+                .merkle_tree
+                .get_path(self.mt_index.try_into().unwrap());
             Some(StmSig {
                 sigma,
                 pk: self.vk,
@@ -881,10 +918,7 @@ where
     /// Create a new `Clerk` from a closed registration instance.
     /// todo: why does it consume the closed reg?
     pub fn from_registration(params: StmParameters, closed_reg: ClosedKeyReg<D>) -> Self {
-        Self {
-            params,
-            closed_reg
-        }
+        Self { params, closed_reg }
     }
 
     /// Creates a Clerk from a Signer.
@@ -927,8 +961,12 @@ where
         msig: &StmAggrSig<D>,
         msg: &[u8],
     ) -> Result<(), MithrilWitnessError<D>> {
-        StmVerifier::new(self.closed_reg.merkle_tree.to_commitment(), self.params, self.closed_reg.total_stake)
-            .verify_msig(msg, msig)
+        StmVerifier::new(
+            self.closed_reg.merkle_tree.to_commitment(),
+            self.params,
+            self.closed_reg.total_stake,
+        )
+        .verify_msig(msg, msig)
     }
 
     /// Given a slice of `indices` and one of `sigs`, this functions selects a single valid signature
@@ -1096,11 +1134,11 @@ where
         params: StmParameters,
         total_stake: Stake,
     ) -> Self {
-        let avk = StmAggrVerificationKey { mt_commitment, total_stake };
-        Self {
-            avk,
-            params,
-        }
+        let avk = StmAggrVerificationKey {
+            mt_commitment,
+            total_stake,
+        };
+        Self { avk, params }
     }
 
     /// Verify an aggregated signature

mithril-signer/src/single_signer.rs

@@ -4,7 +4,7 @@ use thiserror::Error;
 
 use mithril_common::crypto_helper::{
     key_decode_hex, key_encode_hex, Bytes, ProtocolInitializer, ProtocolKeyRegistration,
-    ProtocolParameters, ProtocolPartyId, ProtocolSigner, ProtocolSignerSecretKey, ProtocolStake,
+    ProtocolParameters, ProtocolPartyId, ProtocolSingleSignature, ProtocolSigner, ProtocolSignerSecretKey, ProtocolStake,
 };
 use mithril_common::entities::{self, SignerWithStake, SingleSignature};
 
@@ -195,6 +195,7 @@ mod tests {
             )
             .unwrap();
         let clerk = ProtocolClerk::from_signer(&protocol_signer);
+        let avk = clerk.compute_avk();
 
         let message = "message".as_bytes();
         let sign_result = single_signer.compute_single_signatures(
@@ -205,8 +206,8 @@ mod tests {
 
         assert!(!sign_result.as_ref().unwrap().is_empty());
         for sig in sign_result.unwrap() {
-            let decoded_sig = key_decode_hex(&sig.signature).unwrap();
-            assert!(clerk.verify_sig(&decoded_sig, message).is_ok());
+            let decoded_sig: ProtocolSingleSignature = key_decode_hex(&sig.signature).unwrap();
+            assert!(decoded_sig.verify(&protocol_parameters, &avk, message).is_ok());
             assert_eq!(
                 decoded_sig.pk,
                 key_decode_hex(&signer_with_keys.verification_key).unwrap()