Backport zeroize fix (#266)

* Backport `zeroize` fix

* Update version

* Fix CI

* Remove bench for CI MSRV

* Downgrade rustyline for MSRV

* Downgrade proptest for MSRV

* Downgrade zeroize for MSRV

src/envelope.rs

@@ -61,7 +61,7 @@ fn recover_keys_internal<CS: CipherSuite>(
     Ok(client_static_keypair)
 }
 
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Zeroize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Zeroize)]
 #[zeroize(drop)]
 pub(crate) enum InnerEnvelopeMode {
     Zero = 0,
@@ -98,7 +98,7 @@ pub(crate) struct Envelope<CS: CipherSuite> {
 impl<CS: CipherSuite> Clone for Envelope<CS> {
     fn clone(&self) -> Self {
         Self {
-            mode: self.mode,
+            mode: self.mode.clone(),
             nonce: self.nonce.clone(),
             hmac: self.hmac.clone(),
         }

src/key_exchange/tripledh.rs

@@ -170,7 +170,7 @@ impl<D: Hash, G: Group> KeyExchange<D, G> for TripleDH {
             ));
         }
 
-        transcript_hasher.update(ke2_message.mac.to_vec());
+        transcript_hasher.update(ke2_message.mac);
 
         let mut client_mac =
             Hmac::<D>::new_from_slice(&km3).map_err(|_| InternalPakeError::HmacError)?;

src/keypair.rs

@@ -144,10 +144,10 @@ impl<G: Group + Debug> KeyPair<G> {
     fn uniform_keypair_strategy() -> BoxedStrategy<Self> {
         // The no_shrink is because keypairs should be fixed -- shrinking would cause a different
         // keypair to be generated, which appears to not be very useful.
-        any::<[u8; 32]>()
-            .prop_filter_map("valid random keypair", |seed| {
+        prop::array::uniform32(0_u8..)
+            .prop_map(|seed| {
                 let mut rng = StdRng::from_seed(seed);
-                Some(Self::generate_random(&mut rng))
+                Self::generate_random(&mut rng)
             })
             .no_shrink()
             .boxed()
@@ -281,21 +281,21 @@ mod tests {
 
     proptest! {
         #[test]
-        fn test_ristretto_check(kp in KeyPair::<RistrettoPoint>::uniform_keypair_strategy()) {
+        fn test_ristretto_check(ref kp in KeyPair::<RistrettoPoint>::uniform_keypair_strategy()) {
             let pk = kp.public();
             prop_assert!(KeyPair::<RistrettoPoint>::check_public_key(pk.clone()).is_ok());
         }
 
         #[test]
-        fn test_ristretto_pub_from_priv(kp in KeyPair::<RistrettoPoint>::uniform_keypair_strategy()) {
+        fn test_ristretto_pub_from_priv(ref kp in KeyPair::<RistrettoPoint>::uniform_keypair_strategy()) {
             let pk = kp.public();
             let sk = kp.private();
             prop_assert_eq!(&KeyPair::<RistrettoPoint>::public_from_private(sk), pk);
         }
 
         #[test]
-        fn test_ristretto_dh(kp1 in KeyPair::<RistrettoPoint>::uniform_keypair_strategy(),
-                          kp2 in KeyPair::<RistrettoPoint>::uniform_keypair_strategy()) {
+        fn test_ristretto_dh(ref kp1 in KeyPair::<RistrettoPoint>::uniform_keypair_strategy(),
+        ref kp2 in KeyPair::<RistrettoPoint>::uniform_keypair_strategy()) {
 
             let dh1 = KeyPair::<RistrettoPoint>::diffie_hellman(kp1.public().clone(), kp2.private().clone())?;
             let dh2 = KeyPair::<RistrettoPoint>::diffie_hellman(kp2.public().clone(), kp1.private().clone())?;
@@ -304,7 +304,7 @@ mod tests {
         }
 
         #[test]
-        fn test_private_key_slice(kp in KeyPair::<RistrettoPoint>::uniform_keypair_strategy()) {
+        fn test_private_key_slice(ref kp in KeyPair::<RistrettoPoint>::uniform_keypair_strategy()) {
             let sk_bytes = kp.private().to_vec();
 
             let kp2 = KeyPair::<RistrettoPoint>::from_private_key_slice(&sk_bytes)?;

src/lib.rs

@@ -747,6 +747,10 @@ compile_error!(
      please enable one of: u64_backend, u32_backend"
 );
 
+#[cfg(test)]
+#[macro_use]
+extern crate proptest;
+
 // Error types
 pub mod errors;
 

src/serialization/tests.rs

@@ -346,57 +346,57 @@ fn ke3_message_roundtrip() {
 proptest! {
 
 #[test]
-fn test_i2osp_os2ip(bytes in vec(any::<u8>(), 0..std::mem::size_of::<usize>())) {
-    assert_eq!(i2osp(os2ip(&bytes)?, bytes.len()), bytes);
+fn test_i2osp_os2ip(ref bytes in vec(prop::num::u8::ANY, 0..std::mem::size_of::<usize>())) {
+    assert_eq!(&i2osp(os2ip(&bytes)?, bytes.len()), bytes);
 }
 
 #[test]
-fn test_nocrash_registration_request(bytes in vec(any::<u8>(), 0..200)) {
+fn test_nocrash_registration_request(ref bytes in vec(prop::num::u8::ANY, 0..200)) {
     RegistrationRequest::<Default>::deserialize(&bytes[..]).map_or(true, |_| true);
 }
 
 #[test]
-fn test_nocrash_registration_response(bytes in vec(any::<u8>(), 0..200)) {
+fn test_nocrash_registration_response(ref bytes in vec(prop::num::u8::ANY, 0..200)) {
     RegistrationResponse::<Default>::deserialize(&bytes[..]).map_or(true, |_| true);
 }
 
 #[test]
-fn test_nocrash_registration_upload(bytes in vec(any::<u8>(), 0..200)) {
+fn test_nocrash_registration_upload(ref bytes in vec(prop::num::u8::ANY, 0..200)) {
     RegistrationUpload::<Default>::deserialize(&bytes[..]).map_or(true, |_| true);
 }
 
 #[test]
-fn test_nocrash_credential_request(bytes in vec(any::<u8>(), 0..500)) {
+fn test_nocrash_credential_request(ref bytes in vec(prop::num::u8::ANY, 0..500)) {
     CredentialRequest::<Default>::deserialize(&bytes[..]).map_or(true, |_| true);
 }
 
 #[test]
-fn test_nocrash_credential_response(bytes in vec(any::<u8>(), 0..500)) {
+fn test_nocrash_credential_response(ref bytes in vec(prop::num::u8::ANY, 0..500)) {
     CredentialResponse::<Default>::deserialize(&bytes[..]).map_or(true, |_| true);
 }
 
 #[test]
-fn test_nocrash_credential_finalization(bytes in vec(any::<u8>(), 0..500)) {
+fn test_nocrash_credential_finalization(ref bytes in vec(prop::num::u8::ANY, 0..500)) {
     CredentialFinalization::<Default>::deserialize(&bytes[..]).map_or(true, |_| true);
 }
 
 #[test]
-fn test_nocrash_client_registration(bytes in vec(any::<u8>(), 0..700)) {
+fn test_nocrash_client_registration(ref bytes in vec(prop::num::u8::ANY, 0..700)) {
     ClientRegistration::<Default>::deserialize(&bytes[..]).map_or(true, |_| true);
 }
 
 #[test]
-fn test_nocrash_server_registration(bytes in vec(any::<u8>(), 0..700)) {
+fn test_nocrash_server_registration(ref bytes in vec(prop::num::u8::ANY, 0..700)) {
     ServerRegistration::<Default>::deserialize(&bytes[..]).map_or(true, |_| true);
 }
 
 #[test]
-fn test_nocrash_client_login(bytes in vec(any::<u8>(), 0..700)) {
+fn test_nocrash_client_login(ref bytes in vec(prop::num::u8::ANY, 0..700)) {
     ClientLogin::<Default>::deserialize(&bytes[..]).map_or(true, |_| true);
 }
 
 #[test]
-fn test_nocrash_server_login(bytes in vec(any::<u8>(), 0..700)) {
+fn test_nocrash_server_login(ref bytes in vec(prop::num::u8::ANY, 0..700)) {
     ServerLogin::<Default>::deserialize(&bytes[..]).map_or(true, |_| true);
 }