Create a dedicated crate for the DKG (#141)

* Add dkg crate

* Remove F_len and G_len

They're generally no longer used.

* Replace hash_to_vec with a provided method around associated type H: Digest

Part of trying to minimize this trait so it can be moved elsewhere. Vec, 
which isn't std, may have been a blocker.

* Encrypt secret shares within the FROST library

Reduces requirements on callers in order to be correct.

* Update usage of Zeroize within FROST

* Inline functions in key_gen

There was no reason to have them separated as they were. sign probably 
has the same statement available, yet that isn't the focus right now.

* Add a ciphersuite package which provides hash_to_F

* Set the Ciphersuite version to something valid

* Have ed448 export Scalar/FieldElement/Point at the top level

* Move FROST over to Ciphersuite

* Correct usage of ff in ciphersuite

* Correct documentation handling

* Move Schnorr signatures to their own crate

* Remove unused feature from schnorr

* Fix Schnorr tests

* Split DKG into a separate crate

* Add serialize to Commitments and SecretShare

Helper for buf = vec![]; .write(buf).unwrap(); buf

* Move FROST over to the new dkg crate

* Update Monero lib to latest FROST

* Correct ethereum's usage of features

* Add serialize to GeneratorProof

* Add serialize helper function to FROST

* Rename AddendumSerialize to WriteAddendum

* Update processor

* Slight fix to processor

crypto/dkg/src/tests/mod.rs

@@ -0,0 +1,69 @@
+use std::collections::HashMap;
+
+use rand_core::{RngCore, CryptoRng};
+
+use group::ff::Field;
+
+use ciphersuite::Ciphersuite;
+
+use crate::{ThresholdCore, ThresholdKeys, lagrange};
+
+/// FROST generation test.
+pub mod frost;
+use frost::frost_gen;
+
+// Promotion test.
+mod promote;
+use promote::test_generator_promotion;
+
+/// Constant amount of participants to use when testing.
+pub const PARTICIPANTS: u16 = 5;
+/// Constant threshold of participants to use when signing.
+pub const THRESHOLD: u16 = ((PARTICIPANTS / 3) * 2) + 1;
+
+/// Clone a map without a specific value.
+pub fn clone_without<K: Clone + std::cmp::Eq + std::hash::Hash, V: Clone>(
+  map: &HashMap<K, V>,
+  without: &K,
+) -> HashMap<K, V> {
+  let mut res = map.clone();
+  res.remove(without).unwrap();
+  res
+}
+
+/// Recover the secret from a collection of keys.
+pub fn recover_key<C: Ciphersuite>(keys: &HashMap<u16, ThresholdKeys<C>>) -> C::F {
+  let first = keys.values().next().expect("no keys provided");
+  assert!(keys.len() >= first.params().t().into(), "not enough keys provided");
+  let included = keys.keys().cloned().collect::<Vec<_>>();
+
+  let group_private = keys.iter().fold(C::F::zero(), |accum, (i, keys)| {
+    accum + (keys.secret_share() * lagrange::<C::F>(*i, &included))
+  });
+  assert_eq!(C::generator() * group_private, first.group_key(), "failed to recover keys");
+  group_private
+}
+
+/// Generate threshold keys for tests.
+pub fn key_gen<R: RngCore + CryptoRng, C: Ciphersuite>(
+  rng: &mut R,
+) -> HashMap<u16, ThresholdKeys<C>> {
+  let res = frost_gen(rng)
+    .drain()
+    .map(|(i, core)| {
+      assert_eq!(
+        &ThresholdCore::<C>::deserialize::<&[u8]>(&mut core.serialize().as_ref()).unwrap(),
+        &core
+      );
+      (i, ThresholdKeys::new(core))
+    })
+    .collect();
+  assert_eq!(C::generator() * recover_key(&res), res[&1].group_key());
+  res
+}
+
+/// Run the test suite on a ciphersuite.
+pub fn test_ciphersuite<R: RngCore + CryptoRng, C: Ciphersuite>(rng: &mut R) {
+  key_gen::<_, C>(rng);
+  test_generator_promotion::<_, C>(rng);
+}