Merge 3098d39 into 4aab935

maidsafe · Jun 9, 2021 · 35b58bf · 35b58bf
2 parents 4aab935 + 3098d39
commit 35b58bf
Show file tree

Hide file tree

Showing 5 changed files with 107 additions and 45 deletions.
diff --git a/benches/reissue.rs b/benches/reissue.rs
@@ -3,16 +3,22 @@
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::iter::FromIterator;
 
-use sn_dbc::{bls_dkg_id, Dbc, DbcContent, KeyManager, Mint, ReissueRequest, ReissueTransaction};
+use sn_dbc::{
+    bls_dkg_id, Dbc, DbcContent, ExposedSigner, KeyManager, Mint, ReissueRequest,
+    ReissueTransaction,
+};
 
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 
-fn genesis(amount: u64) -> (Mint, bls_dkg::outcome::Outcome, Dbc) {
+fn genesis(amount: u64) -> (Mint<ExposedSigner>, bls_dkg::outcome::Outcome, Dbc) {
     let genesis_owner = bls_dkg_id();
 
     let mut genesis_node = Mint::new(KeyManager::new(
-        genesis_owner.public_key_set.clone(),
-        (0, genesis_owner.secret_key_share.clone()),
+        ExposedSigner::new(
+            0,
+            genesis_owner.public_key_set.clone(),
+            genesis_owner.secret_key_share.clone(),
+        ),
         genesis_owner.public_key_set.public_key(),
     ));
 

diff --git a/src/dbc.rs b/src/dbc.rs
@@ -62,7 +62,7 @@ mod tests {
     use quickcheck_macros::quickcheck;
 
     use crate::tests::{NonZeroTinyInt, TinyInt};
-    use crate::{KeyManager, Mint, ReissueRequest, ReissueTransaction};
+    use crate::{ExposedSigner, KeyManager, Mint, ReissueRequest, ReissueTransaction};
 
     fn divide(amount: u64, n_ways: u8) -> impl Iterator<Item = u64> {
         (0..n_ways).into_iter().map(move |i| {
@@ -156,8 +156,11 @@ mod tests {
         let genesis_key = genesis_owner.public_key_set.public_key();
 
         let mut genesis_node = Mint::new(KeyManager::new(
-            genesis_owner.public_key_set.clone(),
-            (0, genesis_owner.secret_key_share.clone()),
+            ExposedSigner::new(
+                0,
+                genesis_owner.public_key_set.clone(),
+                genesis_owner.secret_key_share.clone(),
+            ),
             genesis_key,
         ));
 
@@ -298,8 +301,7 @@ mod tests {
             if let Some(input) = repeating_inputs.next() {
                 let id = crate::bls_dkg_id();
                 let key_mgr = KeyManager::new(
-                    id.public_key_set.clone(),
-                    (0, id.secret_key_share),
+                    ExposedSigner::new(0, id.public_key_set.clone(), id.secret_key_share.clone()),
                     genesis_key,
                 );
                 let trans_sig_share = key_mgr.sign(&transaction.hash());

diff --git a/src/key_manager.rs b/src/key_manager.rs
@@ -53,33 +53,64 @@ impl From<Vec<PublicKey>> for KeyCache {
     }
 }
 
-#[derive(Debug, Clone)]
-pub struct KeyManager {
+pub trait Signer {
+    fn index(&self) -> u64;
+    fn public_key_set(&self) -> PublicKeySet;
+    fn sign<M: AsRef<[u8]>>(&self, msg: M) -> SignatureShare;
+}
+
+pub struct ExposedSigner {
+    index: u64,
     public_key_set: PublicKeySet,
-    secret_key_share: (u64, SecretKeyShare),
+    secret_key_share: SecretKeyShare,
+}
+
+impl ExposedSigner {
+    pub fn new(index: u64, public_key_set: PublicKeySet, secret_key_share: SecretKeyShare) -> Self {
+        Self {
+            index,
+            public_key_set,
+            secret_key_share,
+        }
+    }
+}
+
+impl Signer for ExposedSigner {
+    fn index(&self) -> u64 {
+        self.index
+    }
+
+    fn public_key_set(&self) -> PublicKeySet {
+        self.public_key_set.clone()
+    }
+
+    fn sign<M: AsRef<[u8]>>(&self, msg: M) -> threshold_crypto::SignatureShare {
+        self.secret_key_share.sign(msg)
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct KeyManager<S: Signer> {
+    signer: S,
     genesis_key: PublicKey,
     cache: KeyCache,
 }
 
-impl KeyManager {
-    pub fn new(
-        public_key_set: PublicKeySet,
-        secret_key_share: (u64, SecretKeyShare),
-        genesis_key: PublicKey,
-    ) -> Self {
+impl<S: Signer> KeyManager<S> {
+    pub fn new(signer: S, genesis_key: PublicKey) -> Self {
+        let public_key_set = signer.public_key_set();
         let mut cache = KeyCache::default();
         cache.add_known_key(genesis_key);
         cache.add_known_key(public_key_set.public_key());
         Self {
-            public_key_set,
-            secret_key_share,
+            signer,
             genesis_key,
             cache,
         }
     }
 
     pub fn verify_we_are_a_genesis_node(&self) -> Result<()> {
-        if self.public_key_set.public_key() == self.genesis_key {
+        if self.signer.public_key_set().public_key() == self.genesis_key {
             Ok(())
         } else {
             Err(Error::NotGenesisNode)
@@ -91,17 +122,16 @@ impl KeyManager {
     }
 
     pub fn public_key_set(&self) -> PublicKeySet {
-        self.public_key_set.clone()
+        self.signer.public_key_set()
     }
 
     pub fn sign(&self, msg_hash: &Hash) -> NodeSignature {
-        NodeSignature(
-            self.secret_key_share.0,
-            self.secret_key_share.1.sign(msg_hash),
-        )
+        NodeSignature(self.signer.index(), self.signer.sign(msg_hash))
     }
 
     pub fn verify(&self, msg_hash: &Hash, key: &PublicKey, signature: &Signature) -> Result<()> {
+        // NB: this can fail if self.signer changes keys..
+        // then cache needs to be kept in sync with signer view of its current key
         self.cache.verify(msg_hash, key, signature)
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
@@ -27,8 +27,11 @@ pub use crate::{
     dbc_content::{BlindedOwner, DbcContent},
     dbc_transaction::DbcTransaction,
     error::{Error, Result},
-    key_manager::{KeyCache, KeyManager, NodeSignature, PublicKey, PublicKeySet, Signature},
-    mint::{Mint, MintSignatures, ReissueRequest, ReissueTransaction, GENESIS_DBC_INPUT},
+    key_manager::{
+        ExposedSigner, KeyCache, KeyManager, NodeSignature, PublicKey, PublicKeySet, Signature,
+        Signer,
+    },
+    mint::{Mint, ReissueRequest, ReissueTransaction, GENESIS_DBC_INPUT},
 };
 
 impl From<[u8; 32]> for Hash {

diff --git a/src/mint.rs b/src/mint.rs
@@ -14,8 +14,8 @@
 // Outputs <= input value
 
 use crate::{
-    Dbc, DbcContent, DbcContentHash, DbcTransaction, Error, Hash, KeyCache, KeyManager,
-    NodeSignature, PublicKeySet, Result,
+    key_manager::Signer, Dbc, DbcContent, DbcContentHash, DbcTransaction, Error, Hash, KeyCache,
+    KeyManager, NodeSignature, PublicKeySet, Result,
 };
 use serde::{Deserialize, Serialize};
 use std::{
@@ -123,13 +123,16 @@ pub struct ReissueRequest {
 }
 
 #[derive(Debug, Clone)]
-pub struct Mint {
-    pub(crate) key_mgr: KeyManager,
+pub struct Mint<S>
+where
+    S: Signer,
+{
+    pub(crate) key_mgr: KeyManager<S>,
     pub spendbook: SpendBook,
 }
 
-impl Mint {
-    pub fn new(key_mgr: KeyManager) -> Self {
+impl<S: Signer> Mint<S> {
+    pub fn new(key_mgr: KeyManager<S>) -> Self {
         Self {
             key_mgr,
             spendbook: Default::default(),
@@ -256,16 +259,22 @@ mod tests {
     use super::*;
     use quickcheck_macros::quickcheck;
 
-    use crate::tests::{TinyInt, TinyVec};
+    use crate::{
+        tests::{TinyInt, TinyVec},
+        ExposedSigner,
+    };
 
     #[quickcheck]
     fn prop_genesis() {
         let genesis_owner = crate::bls_dkg_id();
         let genesis_key = genesis_owner.public_key_set.public_key();
 
         let mut genesis_node = Mint::new(KeyManager::new(
-            genesis_owner.public_key_set,
-            (0, genesis_owner.secret_key_share),
+            ExposedSigner::new(
+                0,
+                genesis_owner.public_key_set.clone(),
+                genesis_owner.secret_key_share,
+            ),
             genesis_key,
         ));
 
@@ -298,8 +307,11 @@ mod tests {
         let genesis_owner = crate::bls_dkg_id();
         let genesis_key = genesis_owner.public_key_set.public_key();
         let mut genesis_node = Mint::new(KeyManager::new(
-            genesis_owner.public_key_set.clone(),
-            (0, genesis_owner.secret_key_share.clone()),
+            ExposedSigner::new(
+                0,
+                genesis_owner.public_key_set.clone(),
+                genesis_owner.secret_key_share.clone(),
+            ),
             genesis_key,
         ));
 
@@ -403,8 +415,11 @@ mod tests {
         let genesis_owner = crate::bls_dkg_id();
         let genesis_key = genesis_owner.public_key_set.public_key();
         let mut genesis_node = Mint::new(KeyManager::new(
-            genesis_owner.public_key_set,
-            (0, genesis_owner.secret_key_share),
+            ExposedSigner::new(
+                0,
+                genesis_owner.public_key_set.clone(),
+                genesis_owner.secret_key_share,
+            ),
             genesis_key,
         ));
 
@@ -530,8 +545,11 @@ mod tests {
         let genesis_owner = crate::bls_dkg_id();
         let genesis_key = genesis_owner.public_key_set.public_key();
         let mut genesis_node = Mint::new(KeyManager::new(
-            genesis_owner.public_key_set,
-            (0, genesis_owner.secret_key_share),
+            ExposedSigner::new(
+                0,
+                genesis_owner.public_key_set.clone(),
+                genesis_owner.secret_key_share,
+            ),
             genesis_key,
         ));
 
@@ -802,8 +820,11 @@ mod tests {
         let genesis_owner = crate::bls_dkg_id();
         let genesis_key = genesis_owner.public_key_set.public_key();
         let mut genesis_node = Mint::new(KeyManager::new(
-            genesis_owner.public_key_set,
-            (0, genesis_owner.secret_key_share),
+            ExposedSigner::new(
+                0,
+                genesis_owner.public_key_set.clone(),
+                genesis_owner.secret_key_share,
+            ),
             genesis_key,
         ));