Merge pull request #81 from iron-fish/mat/cleanup

reddsa upgrade + no-std + min round3

Author: mat-if

Cargo.toml

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

src/checksum.rs

@@ -2,17 +2,15 @@
  * 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 std::error;
-use std::fmt;
+use core::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,
@@ -33,4 +31,7 @@ impl fmt::Display for ChecksumError {
     }
 }
 
+#[cfg(feature = "std")]
+use std::error;
+#[cfg(feature = "std")]
 impl error::Error for ChecksumError {}

src/dkg/error.rs

@@ -2,12 +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 crate::io;
 use crate::multienc;
 use crate::participant::Identity;
 use crate::participant::Secret;
 use rand_core::CryptoRng;
 use rand_core::RngCore;
-use std::io;
+
+#[cfg(not(feature = "std"))]
+extern crate alloc;
+#[cfg(not(feature = "std"))]
+use alloc::vec::Vec;
 
 pub const GROUP_SECRET_KEY_LEN: usize = 32;
 
@@ -79,7 +84,7 @@ impl GroupSecretKeyShard {
     }
 
     pub fn import(secret: &Secret, exported: &[u8]) -> io::Result<Self> {
-        let bytes = multienc::decrypt(secret, &exported).map_err(io::Error::other)?;
+        let bytes = multienc::decrypt(secret, exported).map_err(io::Error::other)?;
 
         if bytes.len() != GROUP_SECRET_KEY_LEN {
             return Err(io::Error::other(

src/dkg/group_key.rs

@@ -2,7 +2,6 @@
  * 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/. */
 
-pub mod error;
 pub mod group_key;
 pub mod round1;
 pub mod round2;

src/dkg/mod.rs

@@ -5,17 +5,17 @@
 use crate::checksum::Checksum;
 use crate::checksum::ChecksumHasher;
 use crate::checksum::CHECKSUM_LEN;
-use crate::dkg::error::Error;
 use crate::dkg::group_key::GroupSecretKeyShard;
+use crate::error::IronfishFrostError;
 use crate::frost;
 use crate::frost::keys::dkg::round1::Package;
 use crate::frost::keys::dkg::round1::SecretPackage;
 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;
 use crate::participant::Identity;
 use crate::serde::read_u16;
@@ -24,12 +24,21 @@ 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 std::borrow::Borrow;
-use std::hash::Hasher;
-use std::io;
-use std::mem;
+
+use core::hash::Hasher;
+use core::mem;
+
+#[cfg(not(feature = "std"))]
+extern crate alloc;
+
+#[cfg(not(feature = "std"))]
+use alloc::vec::Vec;
+
+#[cfg(not(feature = "std"))]
+use alloc::string::ToString;
 
 type Scalar = <JubjubScalarField as Field>::Scalar;
 
@@ -80,23 +89,24 @@ impl<'a> From<&'a SerializableSecretPackage> for &'a SecretPackage {
 }
 
 impl SerializableSecretPackage {
-    fn serialize_into<W: io::Write>(&self, mut writer: W) -> io::Result<()> {
+    fn serialize_into<W: io::Write>(&self, mut writer: W) -> Result<(), IronfishFrostError> {
         writer.write_all(&self.identifier.serialize())?;
         write_variable_length(&mut writer, &self.coefficients, |writer, scalar| {
             writer.write_all(&scalar.to_bytes())
         })?;
-        write_variable_length(&mut writer, self.commitment.serialize(), |writer, array| {
+        let serialized = self.commitment.serialize()?;
+        write_variable_length(&mut writer, serialized, |writer, array| {
             writer.write_all(&array)
         })?;
         write_u16(&mut writer, self.min_signers)?;
         write_u16(&mut writer, self.max_signers)?;
         Ok(())
     }
 
-    fn deserialize_from<R: io::Read>(mut reader: R) -> io::Result<Self> {
+    fn deserialize_from<R: io::Read>(mut reader: R) -> Result<Self, IronfishFrostError> {
         let mut identifier = [0u8; 32];
         reader.read_exact(&mut identifier)?;
-        let identifier = Identifier::deserialize(&identifier).map_err(io::Error::other)?;
+        let identifier = Identifier::deserialize(&identifier)?;
 
         let coefficients = read_variable_length(&mut reader, |reader| {
             let mut scalar = [0u8; 32];
@@ -112,8 +122,7 @@ impl SerializableSecretPackage {
                 reader.read_exact(&mut array)?;
                 Ok(array)
             },
-        )?)
-        .map_err(io::Error::other)?;
+        )?)?;
 
         let min_signers = read_u16(&mut reader)?;
         let max_signers = read_u16(&mut reader)?;
@@ -153,8 +162,9 @@ pub fn export_secret_package<R: RngCore + CryptoRng>(
 pub fn import_secret_package(
     exported: &[u8],
     secret: &participant::Secret,
-) -> io::Result<SecretPackage> {
-    let serialized = multienc::decrypt(secret, &exported).map_err(io::Error::other)?;
+) -> Result<SecretPackage, IronfishFrostError> {
+    let serialized =
+        multienc::decrypt(secret, exported).map_err(IronfishFrostError::DecryptionError)?;
     SerializableSecretPackage::deserialize_from(&serialized[..]).map(|pkg| pkg.into())
 }
 
@@ -247,22 +257,22 @@ impl PublicPackage {
         buf
     }
 
-    pub fn serialize_into<W: io::Write>(&self, mut writer: W) -> io::Result<()> {
+    pub fn serialize_into<W: io::Write>(&self, mut writer: W) -> Result<(), IronfishFrostError> {
         self.identity.serialize_into(&mut writer)?;
-        let frost_package = self.frost_package.serialize().map_err(io::Error::other)?;
+        let frost_package = self.frost_package.serialize()?;
         write_variable_length_bytes(&mut writer, &frost_package)?;
-        writer.write_all(&self.group_secret_key_shard_encrypted[..])?;
+        write_variable_length_bytes(&mut writer, &self.group_secret_key_shard_encrypted)?;
         writer.write_all(&self.checksum.to_le_bytes())?;
         Ok(())
     }
 
-    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 identity = Identity::deserialize_from(&mut reader).expect("reading identity failed");
 
         let frost_package = read_variable_length_bytes(&mut reader)?;
-        let frost_package = Package::deserialize(&frost_package).map_err(io::Error::other)?;
+        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)?;
@@ -282,7 +292,7 @@ pub fn round1<'a, I, R>(
     min_signers: u16,
     participants: I,
     mut csrng: R,
-) -> Result<(Vec<u8>, PublicPackage), Error>
+) -> Result<(Vec<u8>, PublicPackage), IronfishFrostError>
 where
     I: IntoIterator<Item = &'a Identity>,
     R: RngCore + CryptoRng,
@@ -294,25 +304,24 @@ where
     let participants = participants;
 
     if !participants.contains(&self_identity) {
-        return Err(Error::InvalidInput(
+        return Err(IronfishFrostError::InvalidInput(
             "participants must include self_identity".to_string(),
         ));
     }
 
     let max_signers = u16::try_from(participants.len())
-        .map_err(|_| Error::InvalidInput("too many participants".to_string()))?;
+        .map_err(|_| IronfishFrostError::InvalidInput("too many participants".to_string()))?;
 
     let (secret_package, public_package) = frost::keys::dkg::part1(
         self_identity.to_frost_identifier(),
         max_signers,
         min_signers,
         &mut csrng,
-    )
-    .map_err(Error::FrostError)?;
+    )?;
 
     let encrypted_secret_package =
         export_secret_package(&secret_package, self_identity, &mut csrng)
-            .map_err(Error::EncryptionError)?;
+            .map_err(IronfishFrostError::EncryptionError)?;
 
     let group_secret_key_shard = GroupSecretKeyShard::random(&mut csrng);
 
@@ -492,6 +501,13 @@ mod tests {
         let deserialized = PublicPackage::deserialize_from(&serialized[..])
             .expect("package deserialization failed");
 
+        assert_eq!(public_package.identity, deserialized.identity);
+        assert_eq!(public_package.checksum, deserialized.checksum);
+        assert_eq!(public_package.frost_package, deserialized.frost_package);
+        assert_eq!(
+            public_package.group_secret_key_shard_encrypted,
+            deserialized.group_secret_key_shard_encrypted
+        );
         assert_eq!(public_package, deserialized);
     }