Merge pull request #484 from input-output-hk/signature-without-path

Single signature without merkle path

Author: curiecrypt

clippy

@@ -1,6 +1,5 @@
 use hex::ToHex;
-use rand_chacha::ChaCha20Rng;
-use rand_core::{RngCore, SeedableRng};
+use rand_core::{CryptoRng, RngCore};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::env;
@@ -42,14 +41,16 @@ struct MultiSignatureArtifact {
 }
 
 /// Party represents a signing protocol participant
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Party {
     /// Party's identifier
     party_id: ProtocolPartyId,
     /// Party's stake
     stake: ProtocolStake,
     /// Protocol parameters
     params: Option<ProtocolParameters>,
+    /// Protocol initializer
+    initializer: Option<ProtocolInitializerNotCertified>,
     /// Protocol signer
     signer: Option<ProtocolSigner>,
     /// Protocol clerk
@@ -66,6 +67,7 @@ impl Party {
             party_id: format!("{}", party_id) as ProtocolPartyId,
             stake: stake as ProtocolStake,
             params: None,
+            initializer: None,
             signer: None,
             clerk: None,
             msigs: HashMap::new(),
@@ -105,10 +107,13 @@ impl Party {
         }
         let closed_reg = key_reg.close();
 
-        let seed = [0u8; 32];
-        let mut rng = ChaCha20Rng::from_seed(seed);
-        let p = ProtocolInitializerNotCertified::setup(self.params.unwrap(), self.stake, &mut rng);
-        self.signer = Some(p.new_signer(closed_reg).unwrap());
+        let signer = self
+            .initializer
+            .clone()
+            .unwrap()
+            .new_signer(closed_reg)
+            .unwrap();
+        self.signer = Some(signer);
         self.clerk = Some(ProtocolClerk::from_signer(self.signer.as_ref().unwrap()));
     }
 
@@ -296,10 +301,8 @@ pub struct Demonstrator {
 
 impl Demonstrator {
     /// Demonstrator factory
-    pub fn new(config: &crate::Config) -> Self {
+    pub fn new<R: RngCore + CryptoRng>(config: &crate::Config, rng: &mut R) -> Self {
         // Generate parties
-        let seed = [0u8; 32];
-        let mut rng = ChaCha20Rng::from_seed(seed);
         let parties = (0..config.nparties)
             .into_iter()
             .map(|party_id| Party::new(party_id, 1 + rng.next_u64() % 999))
@@ -328,7 +331,7 @@ pub trait ProtocolDemonstrator {
     fn establish(&mut self);
 
     /// Initialization phase of the protocol
-    fn initialize(&mut self);
+    fn initialize<R: RngCore + CryptoRng>(&mut self, rng: &mut R);
 
     /// Issue certificates
     fn issue_certificates(&mut self);
@@ -349,7 +352,7 @@ impl ProtocolDemonstrator for Demonstrator {
     }
 
     /// Initialization phase of the protocol
-    fn initialize(&mut self) {
+    fn initialize<R: RngCore + CryptoRng>(&mut self, rng: &mut R) {
         // Retrieve protocol parameters
         let mut verifier = Verifier::new();
         verifier.update_params(&self.params.unwrap());
@@ -358,25 +361,17 @@ impl ProtocolDemonstrator for Demonstrator {
         }
 
         // Register keys
-        let seed = [0u8; 32];
-        let mut rng = ChaCha20Rng::from_seed(seed);
-        let players = self
-            .parties
-            .iter()
-            .map(|party| (party.party_id.to_owned(), party.stake))
-            .collect::<Vec<_>>();
         let mut players_artifacts = Vec::new();
-        for (party_id, stake) in players {
+        for party in self.parties.iter_mut() {
             let protocol_initializer =
-                ProtocolInitializerNotCertified::setup(self.params.unwrap(), stake, &mut rng);
-            let verification_key: ProtocolSignerVerificationKey =
-                protocol_initializer.verification_key();
+                ProtocolInitializerNotCertified::setup(self.params.unwrap(), party.stake, rng);
             players_artifacts.push(PlayerArtifact {
-                party_id,
-                stake,
-                verification_key: key_encode_hex(verification_key).unwrap(),
-                initializer: key_encode_hex(protocol_initializer).unwrap(),
-            })
+                party_id: party.clone().party_id,
+                stake: party.stake,
+                verification_key: key_encode_hex(protocol_initializer.verification_key()).unwrap(),
+                initializer: key_encode_hex(protocol_initializer.clone()).unwrap(),
+            });
+            party.initializer = Some(protocol_initializer);
         }
         let players_with_keys = players_artifacts
             .iter()
@@ -487,6 +482,8 @@ pub fn write_artifacts<T: Serialize>(artifact_name: &str, value: &T) {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use rand_chacha::ChaCha20Rng;
+    use rand_core::SeedableRng;
 
     fn setup_protocol_parameters() -> ProtocolParameters {
         ProtocolParameters {
@@ -510,14 +507,18 @@ mod tests {
     #[test]
     fn test_demonstrator_new() {
         let config = default_config();
-        let demo = Demonstrator::new(&config);
+        let seed = [0u8; 32];
+        let mut rng = ChaCha20Rng::from_seed(seed);
+        let demo = Demonstrator::new(&config, &mut rng);
         assert_eq!(demo.config, config);
     }
 
     #[test]
     fn test_demonstrator_establish() {
         let config = default_config();
-        let mut demo = Demonstrator::new(&config);
+        let seed = [0u8; 32];
+        let mut rng = ChaCha20Rng::from_seed(seed);
+        let mut demo = Demonstrator::new(&config, &mut rng);
         demo.establish();
         assert_eq!(demo.params.unwrap().m, config.m);
         assert_eq!(demo.params.unwrap().k, config.k);
@@ -527,9 +528,11 @@ mod tests {
     #[test]
     fn test_demonstrator_initialize() {
         let config = default_config();
-        let mut demo = Demonstrator::new(&config);
+        let seed = [0u8; 32];
+        let mut rng = ChaCha20Rng::from_seed(seed);
+        let mut demo = Demonstrator::new(&config, &mut rng);
         demo.establish();
-        demo.initialize();
+        demo.initialize(&mut rng);
         assert_eq!(demo.parties.len(), config.nparties);
         assert_eq!(demo.messages.len(), config.nmessages);
         for party in demo.parties {
@@ -543,9 +546,11 @@ mod tests {
     #[test]
     fn test_demonstrator_issue_certificates_ok() {
         let config = default_config();
-        let mut demo = Demonstrator::new(&config);
+        let seed = [0u8; 32];
+        let mut rng = ChaCha20Rng::from_seed(seed);
+        let mut demo = Demonstrator::new(&config, &mut rng);
         demo.establish();
-        demo.initialize();
+        demo.initialize(&mut rng);
         demo.issue_certificates();
         assert_eq!(demo.parties.len(), config.nparties);
         assert_eq!(demo.messages.len(), config.nmessages);
@@ -559,9 +564,11 @@ mod tests {
         let mut config = default_config();
         config.k = 10000;
         config.m = 10;
-        let mut demo = Demonstrator::new(&config);
+        let seed = [0u8; 32];
+        let mut rng = ChaCha20Rng::from_seed(seed);
+        let mut demo = Demonstrator::new(&config, &mut rng);
         demo.establish();
-        demo.initialize();
+        demo.initialize(&mut rng);
         demo.issue_certificates();
         assert_eq!(demo.parties.len(), config.nparties);
         assert_eq!(demo.messages.len(), config.nmessages);
@@ -573,9 +580,11 @@ mod tests {
     #[test]
     fn test_demonstrator_verify_certificates_ok() {
         let config = default_config();
-        let mut demo = Demonstrator::new(&config);
+        let seed = [0u8; 32];
+        let mut rng = ChaCha20Rng::from_seed(seed);
+        let mut demo = Demonstrator::new(&config, &mut rng);
         demo.establish();
-        demo.initialize();
+        demo.initialize(&mut rng);
         demo.issue_certificates();
         assert_eq!(demo.parties.len(), config.nparties);
         assert_eq!(demo.messages.len(), config.nmessages);
@@ -587,9 +596,11 @@ mod tests {
         let mut config = default_config();
         config.k = 10000;
         config.m = 10;
-        let mut demo = Demonstrator::new(&config);
+        let seed = [0u8; 32];
+        let mut rng = ChaCha20Rng::from_seed(seed);
+        let mut demo = Demonstrator::new(&config, &mut rng);
         demo.establish();
-        demo.initialize();
+        demo.initialize(&mut rng);
         demo.issue_certificates();
         assert_eq!(demo.parties.len(), config.nparties);
         assert_eq!(demo.messages.len(), config.nmessages);

demo/protocol-demo/src/demonstrator.rs

@@ -2,6 +2,8 @@ mod demonstrator;
 
 use crate::demonstrator::{Demonstrator, ProtocolDemonstrator};
 use clap::Parser;
+use rand_chacha::ChaCha20Rng;
+use rand_core::SeedableRng;
 
 /// Simple demonstration of the Mithril protocol
 #[derive(Parser, Debug, PartialEq, Clone, Copy)]
@@ -40,15 +42,17 @@ fn main() {
     /////////////////////
 
     println!("\n>> Protocol establish phase");
-    let mut mithril_protocol = Demonstrator::new(&config);
+    let seed = [0u8; 32];
+    let mut rng = ChaCha20Rng::from_seed(seed);
+    let mut mithril_protocol = Demonstrator::new(&config, &mut rng);
     mithril_protocol.establish();
 
     //////////////////////////
     // initialization phase //
     /////////////////////////
 
     println!("\n>> Protocol initialize phase:");
-    mithril_protocol.initialize();
+    mithril_protocol.initialize(&mut rng);
 
     //////////////////////
     // operations phase //

demo/protocol-demo/src/main.rs

@@ -13,7 +13,7 @@ async fn certificate_chain() {
     let protocol_parameters = ProtocolParameters {
         k: 5,
         m: 100,
-        phi_f: 0.65,
+        phi_f: 0.95,
     };
     let mut tester = RuntimeTester::build(protocol_parameters.clone()).await;
 

mithril-aggregator/tests/certificate_chain.rs

@@ -10,7 +10,7 @@ async fn create_certificate() {
     let protocol_parameters = ProtocolParameters {
         k: 5,
         m: 100,
-        phi_f: 0.65,
+        phi_f: 0.95,
     };
     let mut tester = RuntimeTester::build(protocol_parameters.clone()).await;
 

mithril-aggregator/tests/create_certificate.rs

@@ -221,6 +221,13 @@ impl RuntimeTester {
                             e
                         )
                     })?;
+            } else {
+                panic!(
+                    "Signer '{}' could not sign. \
+                    This test is based on the assumption that every signer signs everytime. \
+                    Possible fix: relax the protocol parameters or give more stakes to this signer.",
+                    signer_with_stake.party_id
+                );
             }
         }
 

mithril-aggregator/tests/test_extensions/runtime_tester.rs

@@ -13,7 +13,10 @@ use mithril::key_reg::{ClosedKeyReg, KeyReg};
 use mithril::stm::{Stake, StmInitializer, StmParameters, StmSigner, StmVerificationKeyPoP};
 use mithril::RegisterError;
 
-use blake2::{digest::consts::U32, Blake2b, Digest};
+use blake2::{
+    digest::{consts::U32, FixedOutput},
+    Blake2b, Digest,
+};
 use kes_summed_ed25519::kes::{Sum6Kes, Sum6KesSig};
 use kes_summed_ed25519::traits::{KesSig, KesSk};
 use rand_core::{CryptoRng, RngCore};
@@ -255,7 +258,7 @@ impl KeyRegWrapper {
 
     /// Finalize the key registration.
     /// This function disables `KeyReg::register`, consumes the instance of `self`, and returns a `ClosedKeyReg`.
-    pub fn close<D: Digest>(self) -> ClosedKeyReg<D> {
+    pub fn close<D: Digest + FixedOutput>(self) -> ClosedKeyReg<D> {
         self.stm_key_reg.close()
     }
 }

mithril-common/src/crypto_helper/cardano/key_certification.rs

@@ -49,7 +49,7 @@ pub type ProtocolClerk = StmClerk<D>;
 pub type ProtocolKeyRegistration = KeyRegWrapper;
 
 /// Alias of [MithrilCore:StmSig](struct@mithril::stm::StmSig).
-pub type ProtocolSingleSignature = StmSig<D>;
+pub type ProtocolSingleSignature = StmSig;
 
 /// Alias of [MithrilCore:StmAggrSig](struct@mithril::stm::StmAggrSig).
 pub type ProtocolMultiSignature = StmAggrSig<D>;