Remove Zeroize Tests (#381)

* Remove Zeroize tests

* Remove `Zeroize` requirements from `Group::Pk`

* Remove `Copy` requirements from `Group::Pk`

* Change to `ZeroizeOnDrop` requirements for `Group::Sk`

* Add note why we don't use `elliptic_curve::PublicKey`

src/key_exchange/sigma_i/mod.rs

@@ -155,7 +155,9 @@ pub trait SignatureProtocol {
 pub struct Ke2Builder<'a, CS: CipherSuite, KE: Group> {
     transcript: Message<'a, CS, KE>,
     server_nonce: GenericArray<u8, NonceLen>,
+    #[derive_where(skip(Zeroize))]
     client_s_pk: PublicKey<KeGroup<CS>>,
+    #[derive_where(skip(Zeroize))]
     server_e_pk: PublicKey<KE>,
     expected_mac: Output<KeHash<CS>>,
     session_key: Output<KeHash<CS>>,
@@ -179,6 +181,7 @@ pub struct Ke2Builder<'a, CS: CipherSuite, KE: Group> {
 #[derive_where(Clone, ZeroizeOnDrop)]
 #[derive_where(Debug, Eq, Hash, PartialEq; <SIG::Group as Group>::Pk, SIG::VerifyState<CS, KE>)]
 pub struct Ke2State<CS: CipherSuite, SIG: SignatureProtocol, KE: Group> {
+    #[derive_where(skip(Zeroize))]
     client_s_pk: PublicKey<SIG::Group>,
     session_key: Output<KeHash<CS>>,
     verify_state: SIG::VerifyState<CS, KE>,
@@ -203,6 +206,7 @@ where
     Le<<KEH::Core as BlockSizeUser>::BlockSize, U256>: NonZero,
 {
     server_nonce: GenericArray<u8, NonceLen>,
+    #[derive_where(skip(Zeroize))]
     server_e_pk: PublicKey<KE>,
     signature: SIG::Signature,
     mac: Output<KEH>,
@@ -583,61 +587,3 @@ where
         SIG::serialize_signature(&self.signature).concat(self.mac.clone())
     }
 }
-
-//////////////////////////
-// Test Implementations //
-//===================== //
-//////////////////////////
-
-#[cfg(test)]
-use crate::key_exchange::shared::Ke1MessageIter;
-#[cfg(test)]
-use crate::serialization::AssertZeroized;
-
-#[cfg(test)]
-impl<CS: CipherSuite, KE: Group> AssertZeroized for CachedMessage<CS, KE>
-where
-    Ke1MessageIter<KE>: AssertZeroized,
-{
-    fn assert_zeroized(&self) {
-        let Self {
-            credential_request,
-            ke1_message,
-            credential_response,
-            server_nonce,
-            server_e_pk,
-            server_mac,
-        } = self;
-
-        credential_request.assert_zeroized();
-        ke1_message.assert_zeroized();
-        credential_response.assert_zeroized();
-
-        for byte in server_nonce.iter().chain(server_e_pk).chain(server_mac) {
-            assert_eq!(byte, &0);
-        }
-    }
-}
-
-#[cfg(test)]
-impl<CS: CipherSuite, SIG: SignatureProtocol, KE: Group> AssertZeroized for Ke2State<CS, SIG, KE>
-where
-    <SIG::Group as Group>::Pk: AssertZeroized,
-    SIG::VerifyState<CS, KE>: AssertZeroized,
-{
-    fn assert_zeroized(&self) {
-        let Self {
-            client_s_pk,
-            session_key,
-            verify_state,
-            expected_mac,
-        } = self;
-
-        client_s_pk.assert_zeroized();
-        verify_state.assert_zeroized();
-
-        for byte in session_key.iter().chain(expected_mac) {
-            assert_eq!(byte, &0);
-        }
-    }
-}