feat(stm): implement support for multiple proof types in clerk

Author: jpraynaud

demo/protocol-demo/src/demonstrator.rs

@@ -1,4 +1,5 @@
 use hex::ToHex;
+use mithril_stm::AggregateSignatureType;
 use rand_core::{CryptoRng, RngCore};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -142,7 +143,12 @@ impl Party {
         message: &Vec<u8>,
         signatures: &[ProtocolSingleSignature],
     ) -> Option<&ProtocolMultiSignature> {
-        let msig = self.clerk.as_ref().unwrap().aggregate_signatures(signatures, message);
+        let aggregate_signature_type = AggregateSignatureType::Concatenation;
+        let msig = self.clerk.as_ref().unwrap().aggregate_signatures_with_type(
+            signatures,
+            message,
+            aggregate_signature_type,
+        );
         match msig {
             Ok(aggregate_signature) => {
                 println!("Party #{}: aggregate signature computed", self.party_id);

mithril-stm/benches/size_benches.rs

@@ -4,8 +4,8 @@ use blake2::{
     digest::consts::{U32, U64},
 };
 use mithril_stm::{
-    BasicVerifier, Clerk, Initializer, KeyRegistration, Parameters, Signer, SingleSignature,
-    SingleSignatureWithRegisteredParty, Stake, VerificationKey,
+    AggregateSignatureType, BasicVerifier, Clerk, Initializer, KeyRegistration, Parameters, Signer,
+    SingleSignature, SingleSignatureWithRegisteredParty, Stake, VerificationKey,
 };
 use rand_chacha::ChaCha20Rng;
 use rand_core::{RngCore, SeedableRng};
@@ -51,7 +51,10 @@ where
     let clerk = Clerk::new_clerk_from_signer(&ps[0]);
 
     // Aggregate with random parties
-    let aggr = clerk.aggregate_signatures(&sigs, &msg).unwrap();
+    let aggr_sig_type = AggregateSignatureType::Concatenation;
+    let aggr = clerk
+        .aggregate_signatures_with_type(&sigs, &msg, aggr_sig_type)
+        .unwrap();
 
     println!(
         "k = {} | m = {} | nr parties = {}; {} bytes",

mithril-stm/benches/stm.rs

@@ -1,14 +1,16 @@
+use std::fmt::Debug;
+
 use blake2::digest::{Digest, FixedOutput};
 use blake2::{Blake2b, digest::consts::U32};
 use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
-use mithril_stm::{
-    AggregateSignature, BasicVerifier, Clerk, Initializer, KeyRegistration, Parameters, Signer,
-    Stake, VerificationKey,
-};
 use rand_chacha::ChaCha20Rng;
 use rand_core::{RngCore, SeedableRng};
 use rayon::prelude::*;
-use std::fmt::Debug;
+
+use mithril_stm::{
+    AggregateSignature, AggregateSignatureType, BasicVerifier, Clerk, Initializer, KeyRegistration,
+    Parameters, Signer, Stake, VerificationKey,
+};
 
 /// This benchmark framework is not ideal. We really have to think what is the best mechanism for
 /// benchmarking these signatures, over which parameters, how many times to run them, etc:
@@ -67,9 +69,10 @@ where
     let sigs = signers.par_iter().filter_map(|p| p.sign(&msg)).collect::<Vec<_>>();
 
     let clerk = Clerk::new_clerk_from_signer(&signers[0]);
+    let aggregate_signature_type = AggregateSignatureType::Concatenation;
 
     group.bench_function(BenchmarkId::new("Aggregation", &param_string), |b| {
-        b.iter(|| clerk.aggregate_signatures(&sigs, &msg))
+        b.iter(|| clerk.aggregate_signatures_with_type(&sigs, &msg, aggregate_signature_type))
     });
 }
 
@@ -129,7 +132,10 @@ fn batch_benches<H>(
             let sigs = signers.par_iter().filter_map(|p| p.sign(&msg)).collect::<Vec<_>>();
 
             let clerk = Clerk::new_clerk_from_signer(&signers[0]);
-            let msig = clerk.aggregate_signatures(&sigs, &msg).unwrap();
+            let aggregate_signature_type = AggregateSignatureType::Concatenation;
+            let msig = clerk
+                .aggregate_signatures_with_type(&sigs, &msg, aggregate_signature_type)
+                .unwrap();
 
             batch_avks.push(clerk.compute_aggregate_verification_key());
             batch_stms.push(msig);

mithril-stm/examples/key_registration.rs

@@ -2,14 +2,14 @@
 //! but instead by all the participants in the signature process. Contrarily to the full protocol
 //! run presented in `tests/integration.rs`, we explicitly treat each party individually.
 use blake2::{Blake2b, digest::consts::U32};
-use mithril_stm::{
-    Clerk, ClosedKeyRegistration, Initializer, KeyRegistration, Parameters, Stake,
-    VerificationKeyProofOfPossession,
-};
-
 use rand_chacha::ChaCha20Rng;
 use rand_core::{RngCore, SeedableRng};
 
+use mithril_stm::{
+    AggregateSignatureType, Clerk, ClosedKeyRegistration, Initializer, KeyRegistration, Parameters,
+    Stake, VerificationKeyProofOfPossession,
+};
+
 type H = Blake2b<U32>;
 
 fn main() {
@@ -113,7 +113,8 @@ fn main() {
     let clerk = Clerk::new_clerk_from_closed_key_registration(&params, &closed_registration);
 
     // Now we aggregate the signatures
-    let msig_1 = match clerk.aggregate_signatures(&complete_sigs_1, &msg) {
+    let aggr_sig_type = AggregateSignatureType::Concatenation;
+    let msig_1 = match clerk.aggregate_signatures_with_type(&complete_sigs_1, &msg, aggr_sig_type) {
         Ok(s) => s,
         Err(e) => {
             panic!("Aggregation failed: {e:?}")
@@ -125,7 +126,7 @@ fn main() {
             .is_ok()
     );
 
-    let msig_2 = match clerk.aggregate_signatures(&complete_sigs_2, &msg) {
+    let msig_2 = match clerk.aggregate_signatures_with_type(&complete_sigs_2, &msg, aggr_sig_type) {
         Ok(s) => s,
         Err(e) => {
             panic!("Aggregation failed: {e:?}")
@@ -137,7 +138,7 @@ fn main() {
             .is_ok()
     );
 
-    let msig_3 = clerk.aggregate_signatures(&incomplete_sigs_3, &msg);
+    let msig_3 = clerk.aggregate_signatures_with_type(&incomplete_sigs_3, &msg, aggr_sig_type);
     assert!(msig_3.is_err());
 }
 

mithril-stm/src/aggregate_signature/clerk.rs

@@ -1,9 +1,8 @@
 use blake2::digest::{Digest, FixedOutput};
 
 use crate::{
-    AggregateSignature, AggregateVerificationKey, AggregationError, BasicVerifier,
-    ClosedKeyRegistration, Index, Parameters, Signer, SingleSignature,
-    SingleSignatureWithRegisteredParty, Stake, VerificationKey,
+    AggregateSignature, AggregateSignatureType, AggregateVerificationKey, AggregationError,
+    ClosedKeyRegistration, Index, Parameters, Signer, SingleSignature, Stake, VerificationKey,
     aggregate_signature::ConcatenationProof,
 };
 
@@ -57,50 +56,34 @@ impl<D: Digest + Clone + FixedOutput + Send + Sync> Clerk<D> {
         Self::new_clerk_from_signer(signer)
     }
 
-    /// Aggregate a set of signatures for their corresponding indices.
-    ///
-    /// This function first deduplicates the repeated signatures, and if there are enough signatures, it collects the merkle tree indexes of unique signatures.
-    /// The list of merkle tree indexes is used to create a batch proof, to prove that all signatures are from eligible signers.
-    ///
-    /// It returns an instance of `AggregateSignature`.
+    /// Aggregate a set of signatures.
+    #[deprecated(since = "0.6.0", note = "Use `aggregate_signatures_with_type` instead")] // TODO: Update since version
     pub fn aggregate_signatures(
         &self,
         sigs: &[SingleSignature],
         msg: &[u8],
     ) -> Result<AggregateSignature<D>, AggregationError> {
-        let sig_reg_list = sigs
-            .iter()
-            .map(|sig| SingleSignatureWithRegisteredParty {
-                sig: sig.clone(),
-                reg_party: self.closed_reg.reg_parties[sig.signer_index as usize],
-            })
-            .collect::<Vec<SingleSignatureWithRegisteredParty>>();
-
-        let avk = AggregateVerificationKey::from(&self.closed_reg);
-        let msgp = avk.get_merkle_tree_batch_commitment().concatenate_with_message(msg);
-        let mut unique_sigs = BasicVerifier::select_valid_signatures_for_k_indices(
-            &self.closed_reg.total_stake,
-            &self.params,
-            &msgp,
-            &sig_reg_list,
-        )?;
-
-        unique_sigs.sort_unstable();
+        let proof_type = AggregateSignatureType::Concatenation;
 
-        let mt_index_list = unique_sigs
-            .iter()
-            .map(|sig_reg| sig_reg.sig.signer_index as usize)
-            .collect::<Vec<usize>>();
-
-        let batch_proof = self
-            .closed_reg
-            .merkle_tree
-            .compute_merkle_tree_batch_path(mt_index_list);
+        self.aggregate_signatures_with_type(sigs, msg, proof_type)
+    }
 
-        Ok(AggregateSignature::Concatenation(ConcatenationProof {
-            signatures: unique_sigs,
-            batch_proof,
-        }))
+    /// Aggregate a set of signatures with a given proof type.
+    pub fn aggregate_signatures_with_type(
+        &self,
+        sigs: &[SingleSignature],
+        msg: &[u8],
+        aggregate_signature_type: AggregateSignatureType,
+    ) -> Result<AggregateSignature<D>, AggregationError> {
+        match aggregate_signature_type {
+            AggregateSignatureType::Concatenation => Ok(AggregateSignature::Concatenation(
+                ConcatenationProof::aggregate_signatures(self, sigs, msg)?,
+            )),
+            #[cfg(feature = "future_proof_system")]
+            AggregateSignatureType::Future => Err(AggregationError::UnsupportedProofSystem(
+                aggregate_signature_type,
+            )),
+        }
     }
 
     /// Aggregate a set of signatures for their corresponding indices.
@@ -110,6 +93,7 @@ impl<D: Digest + Clone + FixedOutput + Send + Sync> Clerk<D> {
     ///
     /// It returns an instance of `AggregateSignature`.
     #[deprecated(since = "0.5.0", note = "Use `aggregate_signatures` instead")]
+    #[allow(deprecated)]
     pub fn aggregate(
         &self,
         sigs: &[SingleSignature],

mithril-stm/src/aggregate_signature/mod.rs

@@ -24,13 +24,13 @@ mod tests {
     use rand_chacha::ChaCha20Rng;
     use rand_core::{RngCore, SeedableRng};
 
-    use crate::bls_multi_signature::BlsVerificationKey;
     use crate::merkle_tree::MerkleBatchPath;
     use crate::{
         AggregateSignature, AggregationError, BasicVerifier, Clerk, CoreVerifierError, Initializer,
         KeyRegistration, Parameters, Signer, SingleSignature, SingleSignatureWithRegisteredParty,
         Stake,
     };
+    use crate::{AggregateSignatureType, bls_multi_signature::BlsVerificationKey};
 
     type Sig = AggregateSignature<D>;
     type D = Blake2b<U32>;
@@ -169,7 +169,8 @@ mod tests {
                 let all_ps: Vec<usize> = (0..n).collect();
                 let sigs = find_signatures(&msg, &ps, &all_ps);
 
-                let msig = clerk.aggregate_signatures(&sigs, &msg);
+                let aggr_sig_type = AggregateSignatureType::Concatenation;
+                let msig = clerk.aggregate_signatures_with_type(&sigs, &msg, aggr_sig_type);
                 ProofTest { msig, clerk, msg }
             })
         })
@@ -252,10 +253,11 @@ mod tests {
             let params = Parameters { m, k, phi_f: 0.2 };
             let ps = setup_equal_parties(params, nparties);
             let clerk = Clerk::new_clerk_from_signer(&ps[0]);
+            let aggr_sig_type = AggregateSignatureType::Concatenation;
 
             let all_ps: Vec<usize> = (0..nparties).collect();
             let sigs = find_signatures(&msg, &ps, &all_ps);
-            let msig = clerk.aggregate_signatures(&sigs, &msg);
+            let msig = clerk.aggregate_signatures_with_type(&sigs, &msg, aggr_sig_type);
 
             match msig {
                 Ok(aggr) => {
@@ -265,7 +267,9 @@ mod tests {
                 Err(AggregationError::NotEnoughSignatures(n, k)) =>
                     assert!(n < params.k || k == params.k),
                 Err(AggregationError::UsizeConversionInvalid) =>
-                    unreachable!()
+                    unreachable!(),
+                Err(AggregationError::UnsupportedProofSystem(_)) =>
+                    unreachable!(),
             }
         }
 
@@ -277,6 +281,7 @@ mod tests {
                               seed in any::<[u8;32]>(),
                               batch_size in 2..10,
         ) {
+            let aggr_sig_type = AggregateSignatureType::Concatenation;
             let mut rng = ChaCha20Rng::from_seed(seed);
             let mut aggr_avks = Vec::new();
             let mut aggr_stms = Vec::new();
@@ -291,7 +296,7 @@ mod tests {
 
                 let all_ps: Vec<usize> = (0..nparties).collect();
                 let sigs = find_signatures(&msg, &ps, &all_ps);
-                let msig = clerk.aggregate_signatures(&sigs, &msg);
+                let msig = clerk.aggregate_signatures_with_type(&sigs, &msg, aggr_sig_type);
 
                 match msig {
                     Ok(aggr) => {
@@ -304,6 +309,7 @@ mod tests {
                         assert!(sigs.len() < params.k as usize)
                     }
                     Err(AggregationError::UsizeConversionInvalid) => unreachable!(),
+                    Err(AggregationError::UnsupportedProofSystem(_)) => unreachable!(),
                 }
             }
 
@@ -317,7 +323,7 @@ mod tests {
 
             let all_ps: Vec<usize> = (0..nparties).collect();
             let sigs = find_signatures(&msg, &ps, &all_ps);
-            let fake_msig = clerk.aggregate_signatures(&sigs, &msg);
+            let fake_msig = clerk.aggregate_signatures_with_type(&sigs, &msg, aggr_sig_type);
 
             aggr_stms[0] = fake_msig.unwrap();
             assert!(AggregateSignature::batch_verify(&aggr_stms, &batch_msgs, &aggr_avks, &batch_params).is_err());
@@ -381,10 +387,11 @@ mod tests {
             let params = Parameters { m: 10, k: 5, phi_f: 1.0 };
             let ps = setup_equal_parties(params, nparties);
             let clerk = Clerk::new_clerk_from_signer(&ps[0]);
+            let aggr_sig_type = AggregateSignatureType::Concatenation;
 
             let all_ps: Vec<usize> = (0..nparties).collect();
             let sigs = find_signatures(&msg, &ps, &all_ps);
-            let msig = clerk.aggregate_signatures(&sigs, &msg);
+            let msig = clerk.aggregate_signatures_with_type(&sigs, &msg, aggr_sig_type);
             if let Ok(aggr) = msig {
                     let bytes: Vec<u8> = aggr.to_bytes();
                     let aggr2 = AggregateSignature::from_bytes(&bytes).unwrap();
@@ -421,8 +428,9 @@ mod tests {
             assert!(sigs.len() < params.k as usize);
 
             let clerk = Clerk::new_clerk_from_signer(&ps[0]);
+            let aggr_sig_type = AggregateSignatureType::Concatenation;
 
-            let msig = clerk.aggregate_signatures(&sigs, &msg);
+            let msig = clerk.aggregate_signatures_with_type(&sigs, &msg, aggr_sig_type);
             match msig {
                 Err(AggregationError::NotEnoughSignatures(n, k)) =>
                     assert!(n < params.k && params.k == k),