Merge 1f07f84 into d1867db

src/key_gen/tests.rs

@@ -14,6 +14,7 @@ use bincode::serialize;
 use itertools::Itertools;
 use rand::{Rng, RngCore};
 use std::collections::{BTreeMap, BTreeSet};
+use threshold_crypto::{PublicKeySet, SignatureShare};
 use xor_name::XorName;
 
 // Alter the configure of the number of nodes and the threshold.
@@ -109,50 +110,88 @@ fn all_nodes_being_responsive() -> Result<()> {
 #[test]
 fn having_max_unresponsive_nodes_still_work() -> Result<()> {
     let mut rng = rand::thread_rng();
-    let mut non_responsives = BTreeSet::<u64>::new();
-    for i in 0..(NODENUM - THRESHOLD - 1) as u64 {
-        let _ = non_responsives.insert(i);
-    }
-    let (peer_ids, mut generators) = setup_generators(&mut rng, non_responsives.clone())?;
-
-    let mut proposals = Vec::new();
-    // With one non_responsive node, Proposal phase cannot be completed automatically. This
-    // requires finalize_contributing_phase to be called externally to complete the procedure.
-    // All participants will transit into Complaint phase afterwards, Then requires
-    // finalize_complaining_phase to be called externally to complete the procedure.
-    for _ in 0..2 {
-        peer_ids.iter().enumerate().for_each(|(index, _peer_id)| {
-            if let Ok(proposal_vec) = generators[index].timed_phase_transition(&mut rng) {
-                if !non_responsives.contains(&(index as u64)) {
-                    for proposal in proposal_vec {
-                        proposals.push(proposal);
+    let all_nodes: BTreeSet<_> = (0u64..NODENUM as u64).collect();
+    let combinations_of_non_resp = all_nodes
+        .iter()
+        .cloned()
+        .combinations(NODENUM - THRESHOLD - 1);
+
+    for non_responsive in combinations_of_non_resp {
+        let non_responsives: BTreeSet<u64> = non_responsive.iter().cloned().collect();
+        let (peer_ids, mut generators) = setup_generators(&mut rng, non_responsives.clone())?;
+
+        let mut proposals = Vec::new();
+        // With one non_responsive node, Proposal phase cannot be completed automatically. This
+        // requires finalize_contributing_phase to be called externally to complete the procedure.
+        // All participants will transit into Complaint phase afterwards, Then requires
+        // finalize_complaining_phase to be called externally to complete the procedure.
+        for _ in 0..2 {
+            peer_ids.iter().enumerate().for_each(|(index, _peer_id)| {
+                if let Ok(proposal_vec) = generators[index].timed_phase_transition(&mut rng) {
+                    if !non_responsives.contains(&(index as u64)) {
+                        for proposal in proposal_vec {
+                            proposals.push(proposal);
+                        }
                     }
                 }
-            }
-        });
-        // Continue the procedure with messaging.
-        messaging(
-            &mut rng,
-            &mut generators,
-            &mut proposals,
-            non_responsives.clone(),
-        );
-        assert!(proposals.is_empty());
-    }
+            });
+            // Continue the procedure with messaging.
+            messaging(
+                &mut rng,
+                &mut generators,
+                &mut proposals,
+                non_responsives.clone(),
+            );
+            assert!(proposals.is_empty());
+        }
 
-    generators
-        .iter_mut()
-        .enumerate()
-        .for_each(|(index, key_gen)| {
+        let responsive = all_nodes
+            .difference(&non_responsives)
+            .cloned()
+            .collect_vec();
+
+        let pub_key_set: PublicKeySet = generators[responsive[0] as usize]
+            .generate_keys()
+            .expect("Failed to generate `PublicKeySet` for node #0")
+            .1
+            .public_key_set;
+
+        let msg = "Test message!";
+        let mut sig_shares: BTreeMap<usize, SignatureShare> = BTreeMap::new();
+
+        for (index, key_gen) in generators.iter_mut().enumerate() {
             if !non_responsives.contains(&(index as u64)) {
-                assert!(key_gen.generate_keys().is_some());
+                let outcome = if let Some(outcome) = key_gen.generate_keys() {
+                    outcome.1
+                } else {
+                    return Err(format_err!(
+                        "Failed to generate `PublicKeySet` and `SecretKeyShare` for node #{}",
+                        index
+                    ));
+                };
+                let sk = outcome.secret_key_share;
+                let index = key_gen.our_index as usize;
+                let pks = outcome.public_key_set;
+                assert_eq!(pks, pub_key_set);
+                let sig = sk.sign(msg);
+                assert!(pks.public_key_share(index).verify(&sig, msg));
+                let _ = sig_shares.insert(index, sig);
+
                 non_responsives.iter().for_each(|idx| {
                     assert!(!key_gen.names().contains(&peer_ids[*idx as usize].name()))
                 });
             } else {
                 assert!(key_gen.generate_keys().is_none());
-            }
-        });
+            };
+        }
+
+        let sig = match pub_key_set.combine_signatures(sig_shares.iter()) {
+            Ok(sig) => sig,
+            Err(e) => return Err(format_err!("Unexpected Error {:?}: Not able to generate Signature with THRESHOLD + 1 sig_shares", e)),
+        };
+
+        assert!(pub_key_set.public_key().verify(&sig, msg));
+    }
     Ok(())
 }