From 5b26115f81f496f23c7806050965a61d8f3c0a65 Mon Sep 17 00:00:00 2001
From: Luke Parker <lukeparker5132@gmail.com>
Date: Tue, 7 Mar 2023 03:25:16 -0500
Subject: [PATCH] Add Debug implementations to dkg

---
 crypto/dkg/src/encryption.rs | 19 +++++++++++---
 crypto/dkg/src/frost.rs      | 48 +++++++++++++++++++++++++++++-------
 crypto/dkg/src/lib.rs        | 13 ++++++++++
 3 files changed, 67 insertions(+), 13 deletions(-)

diff --git a/crypto/dkg/src/encryption.rs b/crypto/dkg/src/encryption.rs
index e7047065..cbf61a99 100644
--- a/crypto/dkg/src/encryption.rs
+++ b/crypto/dkg/src/encryption.rs
@@ -1,6 +1,5 @@
-use core::fmt::Debug;
+use core::{ops::Deref, fmt};
 use std::{
-  ops::Deref,
   io::{self, Read, Write},
   collections::HashMap,
 };
@@ -39,8 +38,8 @@ pub trait ReadWrite: Sized {
   }
 }
 
-pub trait Message: Clone + PartialEq + Eq + Debug + Zeroize + ReadWrite {}
-impl<M: Clone + PartialEq + Eq + Debug + Zeroize + ReadWrite> Message for M {}
+pub trait Message: Clone + PartialEq + Eq + fmt::Debug + Zeroize + ReadWrite {}
+impl<M: Clone + PartialEq + Eq + fmt::Debug + Zeroize + ReadWrite> Message for M {}
 
 /// Wraps a message with a key to use for encryption in the future.
 #[derive(Clone, PartialEq, Eq, Debug, Zeroize)]
@@ -347,6 +346,18 @@ pub(crate) struct Encryption<C: Ciphersuite> {
   enc_keys: HashMap<Participant, C::G>,
 }
 
+impl<C: Ciphersuite> fmt::Debug for Encryption<C> {
+  fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fmt
+      .debug_struct("Encryption")
+      .field("context", &self.context)
+      .field("i", &self.i)
+      .field("enc_pub_key", &self.enc_pub_key)
+      .field("enc_keys", &self.enc_keys)
+      .finish_non_exhaustive()
+  }
+}
+
 impl<C: Ciphersuite> Zeroize for Encryption<C> {
   fn zeroize(&mut self) {
     self.enc_key.zeroize();
diff --git a/crypto/dkg/src/frost.rs b/crypto/dkg/src/frost.rs
index 054d7bd9..e2e7c64b 100644
--- a/crypto/dkg/src/frost.rs
+++ b/crypto/dkg/src/frost.rs
@@ -1,8 +1,4 @@
-use core::{
-  marker::PhantomData,
-  ops::Deref,
-  fmt::{Debug, Formatter},
-};
+use core::{marker::PhantomData, ops::Deref, fmt};
 use std::{
   io::{self, Read, Write},
   collections::HashMap,
@@ -85,6 +81,7 @@ impl<C: Ciphersuite> ReadWrite for Commitments<C> {
 }
 
 /// State machine to begin the key generation protocol.
+#[derive(Debug, Zeroize)]
 pub struct KeyGenMachine<C: Ciphersuite> {
   params: ThresholdParams,
   context: String,
@@ -186,8 +183,8 @@ impl<F: PrimeField> AsMut<[u8]> for SecretShare<F> {
     self.0.as_mut()
   }
 }
-impl<F: PrimeField> Debug for SecretShare<F> {
-  fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), core::fmt::Error> {
+impl<F: PrimeField> fmt::Debug for SecretShare<F> {
+  fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
     fmt.debug_struct("SecretShare").finish_non_exhaustive()
   }
 }
@@ -198,7 +195,7 @@ impl<F: PrimeField> Zeroize for SecretShare<F> {
 }
 // Still manually implement ZeroizeOnDrop to ensure these don't stick around.
 // We could replace Zeroizing<M> with a bound M: ZeroizeOnDrop.
-// Doing so would potentially fail to highlight thr expected behavior with these and remove a layer
+// Doing so would potentially fail to highlight the expected behavior with these and remove a layer
 // of depth.
 impl<F: PrimeField> Drop for SecretShare<F> {
   fn drop(&mut self) {
@@ -229,6 +226,18 @@ pub struct SecretShareMachine<C: Ciphersuite> {
   encryption: Encryption<C>,
 }
 
+impl<C: Ciphersuite> fmt::Debug for SecretShareMachine<C> {
+  fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fmt
+      .debug_struct("SecretShareMachine")
+      .field("params", &self.params)
+      .field("context", &self.context)
+      .field("our_commitments", &self.our_commitments)
+      .field("encryption", &self.encryption)
+      .finish_non_exhaustive()
+  }
+}
+
 impl<C: Ciphersuite> SecretShareMachine<C> {
   /// Verify the data from the previous round (canonicity, PoKs, message authenticity)
   #[allow(clippy::type_complexity)]
@@ -322,6 +331,17 @@ pub struct KeyMachine<C: Ciphersuite> {
   encryption: Encryption<C>,
 }
 
+impl<C: Ciphersuite> fmt::Debug for KeyMachine<C> {
+  fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fmt
+      .debug_struct("KeyMachine")
+      .field("params", &self.params)
+      .field("commitments", &self.commitments)
+      .field("encryption", &self.encryption)
+      .finish_non_exhaustive()
+  }
+}
+
 impl<C: Ciphersuite> Zeroize for KeyMachine<C> {
   fn zeroize(&mut self) {
     self.params.zeroize();
@@ -457,6 +477,16 @@ pub struct BlameMachine<C: Ciphersuite> {
   result: ThresholdCore<C>,
 }
 
+impl<C: Ciphersuite> fmt::Debug for BlameMachine<C> {
+  fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fmt
+      .debug_struct("BlameMachine")
+      .field("commitments", &self.commitments)
+      .field("encryption", &self.encryption)
+      .finish_non_exhaustive()
+  }
+}
+
 impl<C: Ciphersuite> Zeroize for BlameMachine<C> {
   fn zeroize(&mut self) {
     for (_, commitments) in self.commitments.iter_mut() {
@@ -542,7 +572,7 @@ impl<C: Ciphersuite> BlameMachine<C> {
   }
 }
 
-#[derive(Zeroize)]
+#[derive(Debug, Zeroize)]
 pub struct AdditionalBlameMachine<C: Ciphersuite>(BlameMachine<C>);
 impl<C: Ciphersuite> AdditionalBlameMachine<C> {
   /// Given an accusation of fault, determine the faulty party (either the sender, who sent an
diff --git a/crypto/dkg/src/lib.rs b/crypto/dkg/src/lib.rs
index 47ffc895..20c3c06a 100644
--- a/crypto/dkg/src/lib.rs
+++ b/crypto/dkg/src/lib.rs
@@ -344,6 +344,19 @@ pub struct ThresholdView<C: Ciphersuite> {
   verification_shares: HashMap<Participant, C::G>,
 }
 
+impl<C: Ciphersuite> fmt::Debug for ThresholdView<C> {
+  fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fmt
+      .debug_struct("ThresholdView")
+      .field("offset", &self.offset)
+      .field("group_key", &self.group_key)
+      .field("included", &self.included)
+      .field("original_verification_shares", &self.original_verification_shares)
+      .field("verification_shares", &self.verification_shares)
+      .finish_non_exhaustive()
+  }
+}
+
 impl<C: Ciphersuite> Zeroize for ThresholdView<C> {
   fn zeroize(&mut self) {
     self.offset.zeroize();