fix cargo test-all-features

Author: jowparks

Cargo.toml

@@ -12,19 +12,21 @@ repository = "https://github.com/iron-fish/ironfish-frost"
 blake3 = { version = "1.5.0", optional = true }
 chacha20 = "0.9.1"
 chacha20poly1305 = "0.10.1"
-ed25519-dalek = { version = "2.1.0", features = ["rand_core"] }
-rand_chacha = { version = "0.3.1", optional = true }
-rand_core = "0.6.4"
-reddsa = { git = "https://github.com/ZcashFoundation/reddsa.git", rev = "311baf8865f6e21527d1f20750d8f2cf5c9e531a", features = ["frost", "frost-rerandomized"] }
-siphasher = { version = "1.0.0", features =["serde_no_std"] }
-x25519-dalek = { version = "2.0.0", features = ["reusable_secrets", "static_secrets"] }
+ed25519-dalek = { version = "2.1.0", features = ["rand_core", "alloc"], default-features = false }
+rand_chacha = { version = "0.3.1", optional = true, default-features = false }
+rand_core = { version = "0.6.4", features = ["alloc"], default-features = false }
+reddsa = { path = "../reddsa",  features = ["frost", "alloc"], default-features = false }
+frost-core = { git = "https://github.com/ZcashFoundation/frost.git", rev = "c6c3f2f", package = "frost-core", features = ["serialization", "serde", "cheater-detection"], default-features = false }
+frost-rerandomized = { git = "https://github.com/ZcashFoundation/frost.git", rev = "c6c3f2f", package = "frost-rerandomized", features = ["serialization", "cheater-detection"], default-features = false }
+siphasher = { version = "1.0.0", default-features = false }
+x25519-dalek = { version = "2.0.0", features = ["reusable_secrets", "static_secrets"], default-features = false }
 
 [dev-dependencies]
 hex-literal = "0.4.1"
 rand = "0.8.5"
 
 [features]
-default = ["signing"]
+default = ["dkg"]
 
 std = []
 signing = ["dep:blake3", "dep:rand_chacha", "std"]

src/checksum.rs

@@ -30,8 +30,3 @@ impl fmt::Display for ChecksumError {
         }
     }
 }
-
-#[cfg(feature = "std")]
-use std::error;
-#[cfg(feature = "std")]
-impl error::Error for ChecksumError {}

src/dkg/round1.rs

@@ -16,6 +16,7 @@ use crate::frost::Identifier;
 use crate::frost::JubjubScalarField;
 use crate::io;
 use crate::multienc;
+use crate::multienc::read_encrypted_blob;
 use crate::participant;
 use crate::participant::Identity;
 use crate::serde::read_u16;
@@ -34,8 +35,6 @@ use core::mem;
 #[cfg(not(feature = "std"))]
 extern crate alloc;
 #[cfg(not(feature = "std"))]
-use alloc::string::ToString;
-#[cfg(not(feature = "std"))]
 use alloc::vec::Vec;
 
 type Scalar = <JubjubScalarField as Field>::Scalar;
@@ -143,7 +142,7 @@ pub(super) fn get_secret_package_signers(pkg: &SecretPackage) -> (u16, u16) {
 pub fn export_secret_package<R: RngCore + CryptoRng>(
     pkg: &SecretPackage,
     identity: &Identity,
-    csrng: R,
+    mut csrng: R,
 ) -> io::Result<Vec<u8>> {
     let serializable = <&SerializableSecretPackage>::from(pkg);
     if serializable.identifier != identity.to_frost_identifier() {
@@ -154,7 +153,7 @@ pub fn export_secret_package<R: RngCore + CryptoRng>(
     serializable
         .serialize_into(&mut serialized)
         .expect("serialization failed");
-    Ok(multienc::encrypt(&serialized, [identity], csrng))
+    Ok(multienc::encrypt(&serialized, [identity], &mut csrng))
 }
 
 pub fn import_secret_package(

src/dkg/round2.rs

@@ -329,18 +329,19 @@ impl CombinedPublicPackage {
         Ok(write_variable_length(
             writer,
             &self.packages,
-            |writer, pkg| Ok(pkg.serialize_without_sender_into(writer)?),
+            |writer, pkg| {
+                pkg.serialize_without_sender_into(writer)
+                    .map_err(|_| io::Error::other("serialize_into failed"))
+            },
         )?)
     }
 
-    pub fn deserialize_from<R: io::Read>(mut reader: R) -> io::Result<Self> {
+    pub fn deserialize_from<R: io::Read>(mut reader: R) -> Result<Self, IronfishFrostError> {
         let sender_identity = Identity::deserialize_from(&mut reader)?;
 
         let packages = read_variable_length(reader, move |reader| {
-            Ok(PublicPackage::deserialize_without_sender_from(
-                reader,
-                sender_identity.clone(),
-            )?)
+            PublicPackage::deserialize_without_sender_from(reader, sender_identity.clone())
+                .map_err(|_| io::Error::other("deserialization failed"))
         })?;
 
         Ok(Self { packages })

src/dkg/round3.rs

@@ -83,7 +83,6 @@ impl PublicKeyPackage {
         bytes
     }
 
-    #[cfg(feature = "std")]
     pub fn serialize_into<W: io::Write>(&self, mut writer: W) -> Result<(), IronfishFrostError> {
         let frost_public_key_package = self.frost_public_key_package.serialize()?;
         write_variable_length_bytes(&mut writer, &frost_public_key_package)?;

src/error.rs

@@ -6,12 +6,13 @@ use reddsa::frost::redjubjub::frost::Error as FrostError;
 use reddsa::frost::redjubjub::JubjubBlake2b512;
 
 use crate::checksum::ChecksumError;
+use crate::io;
 
 #[derive(Debug)]
 pub enum IronfishFrostError {
     InvalidInput,
     StdError,
-    IoError(std::io::Error),
+    IoError(io::Error),
     FrostError(FrostError<JubjubBlake2b512>),
     SignatureError(ed25519_dalek::SignatureError),
     ChecksumError(ChecksumError),
@@ -23,8 +24,8 @@ impl From<FrostError<JubjubBlake2b512>> for IronfishFrostError {
     }
 }
 
-impl From<std::io::Error> for IronfishFrostError {
-    fn from(error: std::io::Error) -> Self {
+impl From<io::Error> for IronfishFrostError {
+    fn from(error: io::Error) -> Self {
         IronfishFrostError::IoError(error)
     }
 }
@@ -34,12 +35,3 @@ impl From<ed25519_dalek::SignatureError> for IronfishFrostError {
         IronfishFrostError::SignatureError(error)
     }
 }
-
-impl From<IronfishFrostError> for std::io::Error {
-    fn from(error: IronfishFrostError) -> Self {
-        match error {
-            IronfishFrostError::IoError(e) => e,
-            _ => std::io::Error::new(std::io::ErrorKind::Other, format!("{:?}", error)),
-        }
-    }
-}

src/multienc.rs

@@ -60,7 +60,7 @@ where
 }
 
 #[must_use]
-pub fn encrypt<'a, I, R>(data: &[u8], recipients: I, csrng: R) -> Vec<u8>
+pub fn encrypt<'a, I, R>(data: &[u8], recipients: I, mut csrng: R) -> Vec<u8>
 where
     I: IntoIterator<Item = &'a Identity>,
     I::IntoIter: ExactSizeIterator,
@@ -72,7 +72,7 @@ where
 
     let (metadata, ciphertext) = result.split_at_mut(metadata_len);
     ciphertext.copy_from_slice(data);
-    encrypt_in_place(ciphertext, metadata, recipients, csrng).expect("failed to encrypt data");
+    encrypt_in_place(ciphertext, metadata, recipients, &mut csrng).expect("failed to encrypt data");
 
     result
 }
@@ -118,7 +118,7 @@ where
     // We write the number of recipients and the length of the ciphertext in the metadata for
     // convenience, to make decryption easier for the caller. Both numbers are unauthenticated,
     // again for the reason outline above: we rely on the ChaCha20Poly1305 tag for integrity.
-    let agreement_secret = ReusableSecret::random_from_rng(csrng);
+    let agreement_secret = ReusableSecret::random_from_rng(&mut csrng);
     let agreement_key = PublicKey::from(&agreement_secret);
 
     let header = Header {