revert changes to std

Author: jowparks

Cargo.toml

@@ -12,22 +12,20 @@ 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", default-features = false, features = ["rand_core", "alloc"] }
+ed25519-dalek = { version = "2.1.0", features = ["rand_core"] }
 rand_chacha = { version = "0.3.1", optional = true }
-rand_core = { version = "0.6.4", default-features = false, features = ["alloc"] }
-reddsa = { path = "../reddsa", default-features = false, features = ["frost", "alloc"]}
-frost-core = { git = "https://github.com/ZcashFoundation/frost.git", package = "frost-core", default-features = false, features = ["serialization", "serde", "cheater-detection"] }
-frost-rerandomized = { git = "https://github.com/ZcashFoundation/frost.git", package = "frost-rerandomized", default-features = false  }
-siphasher = { version = "1.0.0", default-features = false }
-x25519-dalek = { version = "2.0.0", default-features = false, features = ["reusable_secrets", "static_secrets"] }
+rand_core = "0.6.4"
+reddsa = { git = "https://github.com/ZcashFoundation/reddsa.git", rev = "b9c3107e6ec5333a89a7fa064f2d10f749a90cce", features = ["frost", "frost-rerandomized"] }
+siphasher = { version = "1.0.0", optional = true }
+x25519-dalek = { version = "2.0.0", features = ["reusable_secrets", "static_secrets"] }
 
 [dev-dependencies]
 hex-literal = "0.4.1"
 rand = "0.8.5"
 
 [features]
-default = ["dkg"]
+default = ["std", "signing"]
 
 std = []
-signing = ["dep:blake3", "dep:rand_chacha", "std"]
-dkg = []
+signing = ["dep:blake3", "dep:rand_chacha", "dep:siphasher", "std"]
+dkg = ["std", "signing"]

src/checksum.rs

@@ -2,15 +2,17 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-use core::fmt;
+use std::error;
+use std::fmt;
 
 use siphasher::sip::SipHasher24;
-pub(crate) type ChecksumHasher = SipHasher24;
 
 pub(crate) const CHECKSUM_LEN: usize = 8;
 
 pub(crate) type Checksum = u64;
 
+pub(crate) type ChecksumHasher = SipHasher24;
+
 #[derive(Clone, Debug)]
 pub enum ChecksumError {
     SigningCommitmentError,
@@ -30,3 +32,5 @@ impl fmt::Display for ChecksumError {
         }
     }
 }
+
+impl error::Error for ChecksumError {}

src/dkg/group_key.rs

@@ -2,17 +2,12 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-use crate::io;
 use crate::multienc;
 use crate::participant::Identity;
 use crate::participant::Secret;
 use rand_core::CryptoRng;
 use rand_core::RngCore;
-
-#[cfg(not(feature = "std"))]
-extern crate alloc;
-#[cfg(not(feature = "std"))]
-use alloc::vec::Vec;
+use std::io;
 
 pub const GROUP_SECRET_KEY_LEN: usize = 32;
 

src/dkg/round1.rs

@@ -14,7 +14,6 @@ use crate::frost::keys::VerifiableSecretSharingCommitment;
 use crate::frost::Field;
 use crate::frost::Identifier;
 use crate::frost::JubjubScalarField;
-use crate::io;
 use crate::multienc;
 use crate::multienc::read_encrypted_blob;
 use crate::participant;
@@ -25,17 +24,12 @@ use crate::serde::read_variable_length_bytes;
 use crate::serde::write_u16;
 use crate::serde::write_variable_length;
 use crate::serde::write_variable_length_bytes;
-use core::borrow::Borrow;
 use rand_core::CryptoRng;
 use rand_core::RngCore;
-
-use core::hash::Hasher;
-use core::mem;
-
-#[cfg(not(feature = "std"))]
-extern crate alloc;
-#[cfg(not(feature = "std"))]
-use alloc::vec::Vec;
+use std::borrow::Borrow;
+use std::hash::Hasher;
+use std::io;
+use std::mem;
 
 type Scalar = <JubjubScalarField as Field>::Scalar;
 
@@ -268,7 +262,7 @@ impl PublicPackage {
         let frost_package = read_variable_length_bytes(&mut reader)?;
         let frost_package = Package::deserialize(&frost_package)?;
 
-        let group_secret_key_shard_encrypted = read_encrypted_blob(&mut reader)?;
+        let group_secret_key_shard_encrypted = read_variable_length_bytes(&mut reader)?;
 
         let mut checksum = [0u8; CHECKSUM_LEN];
         reader.read_exact(&mut checksum)?;
@@ -303,8 +297,8 @@ where
         return Err(IronfishFrostError::InvalidInput);
     }
 
-    let max_signers =
-        u16::try_from(participants.len()).map_err(|_| IronfishFrostError::InvalidInput)?;
+    let max_signers = u16::try_from(participants.len())
+        .map_err(|_| IronfishFrostError::InvalidInput("too many participants".to_string()))?;
 
     let (secret_package, public_package) = frost::keys::dkg::part1(
         self_identity.to_frost_identifier(),

src/dkg/round2.rs

@@ -16,7 +16,6 @@ use crate::frost::keys::VerifiableSecretSharingCommitment;
 use crate::frost::Field;
 use crate::frost::Identifier;
 use crate::frost::JubjubScalarField;
-use crate::io;
 use crate::multienc;
 use crate::participant;
 use crate::participant::Identity;
@@ -26,22 +25,13 @@ use crate::serde::read_variable_length_bytes;
 use crate::serde::write_u16;
 use crate::serde::write_variable_length;
 use crate::serde::write_variable_length_bytes;
-use core::borrow::Borrow;
-use core::hash::Hasher;
-use core::mem;
 use rand_core::CryptoRng;
 use rand_core::RngCore;
-// use log::info;
-
-#[cfg(feature = "std")]
+use std::borrow::Borrow;
 use std::collections::BTreeMap;
-
-#[cfg(not(feature = "std"))]
-extern crate alloc;
-#[cfg(not(feature = "std"))]
-use alloc::collections::BTreeMap;
-#[cfg(not(feature = "std"))]
-use alloc::vec::Vec;
+use std::hash::Hasher;
+use std::io;
+use std::mem;
 
 type Scalar = <JubjubScalarField as Field>::Scalar;
 

src/dkg/round3.rs

@@ -12,7 +12,6 @@ use crate::error::IronfishFrostError;
 use crate::frost::keys::dkg::part3;
 use crate::frost::keys::KeyPackage;
 use crate::frost::keys::PublicKeyPackage as FrostPublicKeyPackage;
-use crate::io;
 use crate::participant::Identity;
 use crate::participant::Secret;
 use crate::serde::read_u16;
@@ -21,20 +20,10 @@ use crate::serde::read_variable_length_bytes;
 use crate::serde::write_u16;
 use crate::serde::write_variable_length;
 use crate::serde::write_variable_length_bytes;
-use core::borrow::Borrow;
 use reddsa::frost::redjubjub::VerifyingKey;
-
-#[cfg(feature = "std")]
+use std::borrow::Borrow;
 use std::collections::BTreeMap;
-
-#[cfg(not(feature = "std"))]
-extern crate alloc;
-#[cfg(not(feature = "std"))]
-use alloc::collections::BTreeMap;
-#[cfg(not(feature = "std"))]
-use alloc::string::ToString;
-#[cfg(not(feature = "std"))]
-use alloc::vec::Vec;
+use std::io;
 
 #[derive(Clone, Eq, PartialEq, Debug)]
 pub struct PublicKeyPackage {
@@ -83,6 +72,7 @@ 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)?;
@@ -94,6 +84,7 @@ impl PublicKeyPackage {
         Ok(())
     }
 
+    #[cfg(feature = "std")]
     pub fn deserialize_from<R: io::Read>(mut reader: R) -> Result<Self, IronfishFrostError> {
         let frost_public_key_package = read_variable_length_bytes(&mut reader)?;
         let frost_public_key_package =

src/error.rs

@@ -5,16 +5,19 @@
 use reddsa::frost::redjubjub::frost::Error as FrostError;
 use reddsa::frost::redjubjub::JubjubBlake2b512;
 
-use crate::checksum::ChecksumError;
 use crate::io;
 
+#[cfg(feature = "std")]
+use crate::checksum::ChecksumError;
+
 #[derive(Debug)]
 pub enum IronfishFrostError {
     InvalidInput,
     StdError,
     IoError(io::Error),
     FrostError(FrostError<JubjubBlake2b512>),
     SignatureError(ed25519_dalek::SignatureError),
+    #[cfg(feature = "std")]
     ChecksumError(ChecksumError),
 }
 

src/lib.rs

@@ -11,6 +11,7 @@
 
 mod serde;
 
+#[cfg(feature = "signing")]
 mod checksum;
 
 pub mod error;
@@ -38,11 +39,6 @@ mod io {
     pub(crate) use std::io::Write;
 }
 
-#[cfg(not(feature = "std"))]
-#[macro_use]
-#[cfg(not(feature = "std"))]
-extern crate alloc;
-
 #[cfg(not(feature = "std"))]
 mod io {
     use core::cmp;
@@ -57,7 +53,7 @@ mod io {
         }
     }
 
-    pub(crate) type Result<T> = core::result::Result<T, Error>;
+    pub type Result<T> = core::result::Result<T, Error>;
 
     pub trait Read {
         fn read(&mut self, buf: &mut [u8]) -> Result<usize>;
@@ -78,13 +74,6 @@ mod io {
                 Err(Error)
             }
         }
-
-        fn by_ref(&mut self) -> &mut Self
-        where
-            Self: Sized,
-        {
-            self
-        }
     }
 
     impl<R: Read> Read for &mut R {
@@ -148,19 +137,3 @@ mod io {
         }
     }
 }
-
-#[cfg(not(feature = "std"))]
-use alloc::vec::Vec;
-
-#[cfg(not(feature = "std"))]
-impl io::Write for Vec<u8> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.extend_from_slice(buf);
-        Ok(buf.len())
-    }
-
-    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        self.extend_from_slice(buf);
-        Ok(())
-    }
-}

src/multienc.rs

@@ -20,13 +20,6 @@ use rand_core::RngCore;
 use x25519_dalek::PublicKey;
 use x25519_dalek::ReusableSecret;
 
-#[cfg(not(feature = "std"))]
-extern crate alloc;
-#[cfg(not(feature = "std"))]
-use crate::alloc::borrow::ToOwned;
-#[cfg(not(feature = "std"))]
-use alloc::vec::Vec;
-
 pub const HEADER_SIZE: usize = 56;
 pub const KEY_SIZE: usize = 32;
 
@@ -36,30 +29,31 @@ pub const fn metadata_size(num_recipients: usize) -> usize {
     HEADER_SIZE + KEY_SIZE * num_recipients
 }
 
-pub fn read_encrypted_blob<R>(reader: &mut R) -> Result<Vec<u8>, io::Error>
+#[cfg(feature = "std")]
+pub fn read_encrypted_blob<R>(mut reader: R) -> io::Result<Vec<u8>>
 where
-    R: crate::io::Read,
+    R: io::Read,
 {
+    use std::io::Read;
+
     let mut result = Vec::new();
+    let reader = reader.by_ref();
 
-    let mut header_bytes = [0u8; HEADER_SIZE];
-    reader.read_exact(&mut header_bytes)?;
-    let header: Header = Header::deserialize_from(&header_bytes[..])?;
+    reader.take(HEADER_SIZE as u64).read_to_end(&mut result)?;
 
+    let header = Header::deserialize_from(&result[..])?;
     for _ in 0..header.num_recipients {
-        let mut key_bytes = vec![0u8; KEY_SIZE];
-        reader.read_exact(&mut key_bytes)?;
-        result.extend(key_bytes);
+        reader.take(KEY_SIZE as u64).read_to_end(&mut result)?;
     }
-
-    let mut data_bytes = vec![0u8; header.data_len];
-    reader.read_exact(&mut data_bytes)?;
-    result.extend(data_bytes);
+    reader
+        .take(header.data_len as u64)
+        .read_to_end(&mut result)?;
 
     Ok(result)
 }
 
 #[must_use]
+#[cfg(feature = "std")]
 pub fn encrypt<'a, I, R>(data: &[u8], recipients: I, csrng: R) -> Vec<u8>
 where
     I: IntoIterator<Item = &'a Identity>,
@@ -146,21 +140,15 @@ where
 ///
 /// This method expects the ciphertext and the metadata to be concatenated in one slice. Use
 /// [`decrypt_in_place`] if you have two separate slices.
+#[cfg(feature = "std")]
 pub fn decrypt(secret: &Secret, data: &[u8]) -> io::Result<Vec<u8>> {
     let header = Header::deserialize_from(data)?;
     let metadata_len = metadata_size(header.num_recipients);
     let total_len = metadata_len
         .checked_add(header.data_len)
         .ok_or_else(|| io::Error::other("overflow when calculating data size"))?;
     if data.len() < total_len {
-        #[cfg(feature = "std")]
-        {
-            return Err(io::Error::from(io::ErrorKind::UnexpectedEof));
-        }
-        #[cfg(not(feature = "std"))]
-        {
-            return Err(io::Error);
-        }
+        return Err(io::Error::from(io::ErrorKind::UnexpectedEof));
     }
 
     let (metadata, ciphertext) = data.split_at(metadata_len);
@@ -253,6 +241,7 @@ impl Header {
         write_usize(&mut writer, self.data_len)
     }
 
+    #[cfg(feature = "std")]
     fn deserialize_from<R: io::Read>(mut reader: R) -> io::Result<Self> {
         let mut agreement_key = [0u8; 32];
         reader.read_exact(&mut agreement_key)?;
@@ -276,6 +265,7 @@ impl Header {
 
 #[cfg(test)]
 mod tests {
+    #[cfg(feature = "std")]
     mod detached {
         use crate::multienc::decrypt;
         use crate::multienc::encrypt;