Single signer produce a signature #144, #145

Author: Alenar

mithril-aggregator/src/fake_data.rs

@@ -106,9 +106,10 @@ pub fn signers(total: u64) -> Vec<entities::Signer> {
 // TODO: To delete once key registration is implemented
 #[derive(Serialize, Deserialize, Clone)]
 pub struct SignerWithSecretKeys {
-    party_id: u64,
-    verification_key: String,
-    secret_key: String,
+    pub party_id: u64,
+    pub stake: u64,
+    pub verification_key: String,
+    pub secret_key: String,
 }
 
 /// Fake SignerKeys returns Verification/Secret keys for a party_id

mithril-signer/Cargo.lock

@@ -24,6 +24,7 @@ tar = "0.4.38"
 flate2 = "1.0.23"
 thiserror = "1.0.31"
 
+hex = "0.4.3"
 rand_core   = "0.6.3"
 rand_chacha = "0.3.1"
 rand = "0.7"

mithril-signer/Cargo.toml

@@ -1,8 +1,11 @@
 // @todo: remove this
 #![allow(dead_code)]
-use mithril_aggregator::entities;
 
 use ark_bls12_377::Bls12_377;
+use hex::{FromHex, ToHex};
+use std::io::Cursor;
+use thiserror::Error;
+
 use mithril::key_reg::KeyReg;
 use mithril::merkle_tree::MTHashLeaf;
 use mithril::mithril_proof::concat_proofs::{ConcatProof, TrivialEnv};
@@ -11,7 +14,7 @@ use mithril::stm::{
     Index, MTValue, PartyId, Stake, StmClerk, StmInitializer, StmMultiSig, StmParameters, StmSig,
     StmSigner,
 };
-use thiserror::Error;
+use mithril_aggregator::entities;
 
 pub type Bytes = Vec<u8>;
 
@@ -36,6 +39,9 @@ pub type ProtocolSignerSecretKey = MspSk<Bls12_377>;
 use mithril_aggregator::entities::{SignerWithStake, SingleSignature};
 #[cfg(test)]
 use mockall::automock;
+use rand_chacha::ChaCha20Rng;
+use rand_core::SeedableRng;
+use slog_scope::{trace, warn};
 
 #[cfg_attr(test, automock)]
 pub trait SingleSigner {
@@ -49,38 +55,161 @@ pub trait SingleSigner {
 
 #[derive(Error, Debug, PartialEq)]
 pub enum SingleSignerError {
-    #[error("the signer is not registered in the stake distribution")]
+    #[error("the signer verification key is not registered in the stake distribution")]
     UnregisteredVerificationKey(),
+
+    #[error("the signer party id is not registered in the stake distribution")]
+    UnregisteredPartyId(),
+
+    #[error("the protocol signer creation failed: `{0}`")]
+    ProtocolSignerCreationFailure(String),
 }
 
-pub struct MithrilSingleSigner {}
+pub struct MithrilSingleSigner {
+    party_id: u64,
+    secret_key: ProtocolSignerSecretKey,
+}
 
 impl MithrilSingleSigner {
-    pub fn new() -> Self {
-        Self {}
+    pub fn new(party_id: u64, secret_key: ProtocolSignerSecretKey) -> Self {
+        Self {
+            party_id,
+            secret_key,
+        }
+    }
+
+    pub fn create_protocol_signer(
+        &self,
+        current_player_stake: ProtocolStake,
+        stake_distribution: &[SignerWithStake], // @todo : use a hmap to prevent party id duplication
+        protocol_parameters: &entities::ProtocolParameters,
+    ) -> Result<ProtocolSigner, String> {
+        let players = stake_distribution
+            .iter()
+            .map(|s| (s.party_id as ProtocolPartyId, s.stake as ProtocolStake))
+            .collect::<Vec<_>>();
+        let protocol_parameters = ProtocolParameters {
+            k: protocol_parameters.k,
+            m: protocol_parameters.m,
+            phi_f: protocol_parameters.phi_f as f64,
+        };
+
+        let mut key_reg = KeyReg::new(&players);
+        for s in stake_distribution {
+            let decoded_key = key_decode_hex(&s.verification_key)?;
+            key_reg
+                .register(s.party_id as ProtocolPartyId, decoded_key)
+                .unwrap();
+        }
+        let closed_reg = key_reg.close();
+
+        let seed = [0u8; 32];
+        let mut rng = ChaCha20Rng::from_seed(seed);
+        let mut initializer = StmInitializer::setup(
+            protocol_parameters,
+            self.party_id as ProtocolPartyId,
+            current_player_stake,
+            &mut rng,
+        );
+        initializer.set_key(&self.secret_key);
+
+        Ok(initializer.new_signer(closed_reg))
     }
 }
 
 impl SingleSigner for MithrilSingleSigner {
     fn compute_single_signatures(
         &self,
-        _message: Bytes,
-        _stake_distribution: Vec<SignerWithStake>,
-        _protocol_parameters: &entities::ProtocolParameters,
+        message: Bytes,
+        stake_distribution: Vec<SignerWithStake>, // @todo : use a hmap to prevent party id duplication
+        protocol_parameters: &entities::ProtocolParameters,
     ) -> Result<Vec<SingleSignature>, SingleSignerError> {
-        Err(SingleSignerError::UnregisteredVerificationKey())
+        let current_signer_with_stake = stake_distribution
+            .iter()
+            .find(|s| s.party_id == self.party_id)
+            .ok_or(SingleSignerError::UnregisteredPartyId())?;
+
+        if current_signer_with_stake.verification_key.is_empty() {
+            return Err(SingleSignerError::UnregisteredVerificationKey());
+        }
+
+        let protocol_signer = self
+            .create_protocol_signer(
+                current_signer_with_stake.stake,
+                &stake_distribution,
+                protocol_parameters,
+            )
+            .map_err(SingleSignerError::ProtocolSignerCreationFailure)?;
+
+        trace!(
+            "Party #{}: sign message {}",
+            self.party_id,
+            message.encode_hex::<String>()
+        );
+
+        let mut signatures = Vec::new();
+        for i in 1..=protocol_parameters.m {
+            if let Some(signature) = protocol_signer.sign(&message, i) {
+                trace!("Party #{}: lottery #{} won", self.party_id, i,);
+                let encoded_signature = key_encode_hex(signature);
+
+                if encoded_signature.is_err() {
+                    warn!("couldn't compute signature: `{:?}`", encoded_signature); // @todo: structured log
+                    continue;
+                }
+
+                signatures.push(SingleSignature::new(
+                    self.party_id,
+                    i,
+                    encoded_signature.unwrap(),
+                ));
+            }
+        }
+        Ok(signatures)
     }
 }
 
+/// Encode key to hex helper
+pub fn key_encode_hex<T: ark_ff::ToBytes>(from: T) -> Result<String, String> {
+    Ok(ark_ff::to_bytes!(from)
+        .map_err(|e| format!("can't convert to hex: {}", e))?
+        .encode_hex::<String>())
+}
+
+/// Decode key from hex helper
+pub fn key_decode_hex<T: ark_ff::FromBytes>(from: &str) -> Result<T, String> {
+    ark_ff::FromBytes::read(Cursor::new(
+        Vec::from_hex(from).map_err(|e| format!("can't parse from hex: {}", e))?,
+    ))
+    .map_err(|e| format!("can't convert to bytes: {}", e))
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
     use mithril_aggregator::fake_data;
 
     #[test]
     fn cant_compute_if_signer_verification_key_is_not_registered() {
-        let single_signer = MithrilSingleSigner::new();
-        let stake_distribution = fake_data::signers_with_stakes(5);
+        let signer_with_keys = fake_data::signer_keys(0).unwrap();
+        let single_signer = MithrilSingleSigner::new(
+            signer_with_keys.party_id,
+            key_decode_hex(&signer_with_keys.secret_key).unwrap(),
+        );
+        let stake_distribution = fake_data::signers_with_stakes(5)
+            .into_iter()
+            .map(|s| {
+                if s.party_id == signer_with_keys.party_id {
+                    SignerWithStake {
+                        party_id: s.party_id,
+                        verification_key: "".to_string(),
+                        stake: s.stake,
+                    }
+                } else {
+                    s
+                }
+            })
+            .collect();
         let protocol_parameters = fake_data::protocol_parameters();
 
         let sign_result = single_signer.compute_single_signatures(
@@ -94,4 +223,40 @@ mod tests {
             sign_result.unwrap_err()
         )
     }
+
+    #[test]
+    fn should_produce_a_single_signature() {
+        let signer_with_keys = fake_data::signer_keys(0).unwrap();
+        let single_signer = MithrilSingleSigner::new(
+            signer_with_keys.party_id,
+            key_decode_hex(&signer_with_keys.secret_key).unwrap(),
+        );
+        let stake_distribution = fake_data::signers_with_stakes(5);
+        let protocol_parameters = fake_data::protocol_parameters();
+        let protocol_signer: ProtocolSigner = single_signer
+            .create_protocol_signer(
+                signer_with_keys.stake,
+                &stake_distribution,
+                &protocol_parameters,
+            )
+            .unwrap();
+        let clerk = StmClerk::from_signer(&protocol_signer, TrivialEnv);
+
+        let message = "message".as_bytes();
+        let sign_result = single_signer.compute_single_signatures(
+            message.to_vec(),
+            stake_distribution,
+            &protocol_parameters,
+        );
+
+        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, sig.index, message).is_ok());
+            assert_eq!(
+                decoded_sig.pk,
+                key_decode_hex(&signer_with_keys.verification_key).unwrap()
+            );
+        }
+    }
 }