simplify rng usage, update tests, upgrade version to 0.4

.github/workflows/rust.yml

@@ -17,7 +17,7 @@ jobs:
         with:
           command: check
 
-  test:
+  test-std:
     name: Test
     runs-on: ubuntu-latest
     steps:
@@ -31,6 +31,20 @@ jobs:
         with:
           command: test
 
+  test-nostd:
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+      - uses: actions-rs/cargo@v1
+        with:
+          command: test --no-default-features
+
   format:
     name: Format
     runs-on: ubuntu-latest

CHANGELOG.md

@@ -4,6 +4,10 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.0] - 2020-04-02
+### Added
+- It is now possible to compile without `std` with `--no-default-features`
+
 ## [0.3.3] - 2020-03-23
 ### Changed
 - Fix codecov badge

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sharks"
-version = "0.3.3"
+version = "0.4.0"
 authors = ["Aitor Ruano <codearm@pm.me>"]
 description = "Fast, small and secure Shamir's Secret Sharing library crate"
 homepage = "https://github.com/c0dearm/sharks"
@@ -16,17 +16,17 @@ maintenance = { status = "actively-developed" }
 codecov = { repository = "c0dearm/sharks" }
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [features]
 default = ["std"]
 std = ["rand/std"]
 
 [dependencies]
-rand = { version = "0.7", default_features = false }
+rand = { version = "0.7", default-features = false }
-hashbrown = "0.7.1"
+hashbrown = "0.7"
 
 [dev-dependencies]
 criterion = "0.3"
+rand_chacha = "0.2"
 
 [[bench]]
 name = "benchmarks"

README.md

@@ -17,7 +17,14 @@ Add this to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-sharks = "0.3"
+sharks = "0.4"
+```
+
+If your environment doesn't support `std`:
+
+```toml
+[dependencies]
+sharks = { version = "0.4", default-features = false }
 ```
 
 To get started using Sharks, see the [Rust docs](https://docs.rs/sharks)

src/field.rs

@@ -206,13 +206,13 @@ mod tests {
 
     #[test]
     fn sum_works() {
-        let values = vec![GF256(0x53), GF256(0xCA), GF256(0)];
+        let values = alloc::vec![GF256(0x53), GF256(0xCA), GF256(0)];
         assert_eq!(values.into_iter().sum::<GF256>().0, 0x99);
     }
 
     #[test]
     fn product_works() {
-        let values = vec![GF256(1), GF256(1), GF256(4)];
+        let values = alloc::vec![GF256(1), GF256(1), GF256(4)];
         assert_eq!(values.into_iter().product::<GF256>().0, 4);
     }
 }

src/lib.rs

@@ -1,7 +1,7 @@
 //! Fast, small and secure [Shamir's Secret Sharing](https://en.wikipedia.org/wiki/Shamir%27s_Secret_Sharing) library crate
 //!
-//! Usage example:
+//! Usage example (std):
-//! ```
+//! ```ignore
 //! use sharks::{ Sharks, Share };
 //!
 //! // Set a minimum threshold of 10 shares
@@ -14,22 +14,33 @@
 //! let secret = sharks.recover(shares.as_slice()).unwrap();
 //! assert_eq!(secret, vec![1, 2, 3, 4]);
 //! ```
-
+//!
-#![cfg_attr(not(feature = "std"), no_std)]
+//! //! Usage example (no std):
+//! ```ignore
+//! use sharks::{ Sharks, Share };
+//! use rand_chacha::rand_core::SeedableRng;
+//!
+//! // Set a minimum threshold of 10 shares
+//! let sharks = Sharks(10);
+//! // Obtain an iterator over the shares for secret [1, 2, 3, 4]
+//! let mut rng = rand_chacha::ChaCha8Rng::from_seed([0x90; 32]);
+//! let dealer = sharks.dealer_rng(&[1, 2, 3, 4], &mut rng);
+//! // Get 10 shares
+//! let shares: Vec<Share> = dealer.take(10).collect();
+//! // Recover the original secret!
+//! let secret = sharks.recover(shares.as_slice()).unwrap();
+//! assert_eq!(secret, vec![1, 2, 3, 4]);
+//! ```
+#![no_std]
 
 mod field;
 mod math;
 mod share;
 
-#[cfg(not(feature = "std"))]
 extern crate alloc;
-#[cfg(not(feature = "std"))]
-use alloc::vec::Vec;
-#[cfg(not(feature = "std"))]
-use hashbrown::HashSet;
 
-#[cfg(feature = "std")]
+use alloc::vec::Vec;
-use std::collections::HashSet;
+use hashbrown::HashSet;
 
 use field::GF256;
 pub use share::Share;
@@ -38,7 +49,7 @@ pub use share::Share;
 /// Its only parameter is the minimum shares threshold.
 ///
 /// Usage example:
-/// ```
+/// ```ignore
 /// # use sharks::{ Sharks, Share };
 /// // Set a minimum threshold of 10 shares
 /// let sharks = Sharks(10);
@@ -53,6 +64,37 @@ pub use share::Share;
 pub struct Sharks(pub u8);
 
 impl Sharks {
+    /// This method is useful when `std` is not available. For typical usage
+    /// see the `dealer` method.
+    ///
+    /// Given a `secret` byte slice, returns an `Iterator` along new shares.
+    /// The maximum number of shares that can be generated is 256.
+    /// A random number generator has to be provided.
+    ///
+    /// Example:
+    /// ```
+    /// # use sharks::{ Sharks, Share };
+    /// # use rand_chacha::rand_core::SeedableRng;
+    /// # let sharks = Sharks(3);
+    /// // Obtain an iterator over the shares for secret [1, 2]
+    /// let mut rng = rand_chacha::ChaCha8Rng::from_seed([0x90; 32]);
+    /// let dealer = sharks.dealer_rng(&[1, 2], &mut rng);
+    /// // Get 3 shares
+    /// let shares: Vec<Share> = dealer.take(3).collect();
+    pub fn dealer_rng<R: rand::Rng>(
+        &self,
+        secret: &[u8],
+        rng: &mut R,
+    ) -> impl Iterator<Item = Share> {
+        let mut polys = Vec::with_capacity(secret.len());
+
+        for chunk in secret {
+            polys.push(math::random_polynomial(GF256(*chunk), self.0, rng))
+        }
+
+        math::get_evaluator(polys)
+    }
+
     /// Given a `secret` byte slice, returns an `Iterator` along new shares.
     /// The maximum number of shares that can be generated is 256.
     ///
@@ -66,31 +108,8 @@ impl Sharks {
     /// let shares: Vec<Share> = dealer.take(3).collect();
     #[cfg(feature = "std")]
     pub fn dealer(&self, secret: &[u8]) -> impl Iterator<Item = Share> {
-        let mut polys = Vec::with_capacity(secret.len());
+        let mut rng = rand::thread_rng();
-
+        self.dealer_rng(secret, &mut rng)
-        for chunk in secret {
-            polys.push(math::random_polynomial(GF256(*chunk), self.0))
-        }
-
-        math::get_evaluator(polys)
-    }
-
-    pub fn dealer_with_rng(
-        &self,
-        mut rng: &mut impl rand::Rng,
-        secret: &[u8],
-    ) -> impl Iterator<Item = Share> {
-        let mut polys = Vec::with_capacity(secret.len());
-
-        for chunk in secret {
-            polys.push(math::random_polynomial_with_rng(
-                &mut rng,
-                GF256(*chunk),
-                self.0,
-            ))
-        }
-
-        math::get_evaluator(polys)
     }
 
     /// Given an iterable collection of shares, recovers the original secret.
@@ -100,8 +119,10 @@ impl Sharks {
     /// Example:
     /// ```
     /// # use sharks::{ Sharks, Share };
+    /// # use rand_chacha::rand_core::SeedableRng;
     /// # let sharks = Sharks(3);
-    /// # let mut shares: Vec<Share> = sharks.dealer(&[1]).take(3).collect();
+    /// # let mut rng = rand_chacha::ChaCha8Rng::from_seed([0x90; 32]);
+    /// # let mut shares: Vec<Share> = sharks.dealer_rng(&[1], &mut rng).take(3).collect();
     /// // Recover original secret from shares
     /// let mut secret = sharks.recover(&shares);
     /// // Secret correctly recovered
@@ -140,11 +161,22 @@ impl Sharks {
 #[cfg(test)]
 mod tests {
     use super::{Share, Sharks};
+    use alloc::vec::Vec;
+    #[cfg(not(feature = "std"))]
+    use rand_chacha::rand_core::SeedableRng;
 
     #[test]
     fn test_insufficient_shares_err() {
         let sharks = Sharks(255);
+
+        #[cfg(not(feature = "std"))]
+        let mut rng = rand_chacha::ChaCha8Rng::from_seed([0x90; 32]);
+
+        #[cfg(feature = "std")]
         let dealer = sharks.dealer(&[1]);
+        #[cfg(not(feature = "std"))]
+        let dealer = sharks.dealer_rng(&[1], &mut rng);
+
         let shares: Vec<Share> = dealer.take(254).collect();
         let secret = sharks.recover(&shares);
         assert!(secret.is_err());
@@ -153,7 +185,15 @@ mod tests {
     #[test]
     fn test_duplicate_shares_err() {
         let sharks = Sharks(255);
+
+        #[cfg(not(feature = "std"))]
+        let mut rng = rand_chacha::ChaCha8Rng::from_seed([0x90; 32]);
+
+        #[cfg(feature = "std")]
         let dealer = sharks.dealer(&[1]);
+        #[cfg(not(feature = "std"))]
+        let dealer = sharks.dealer_rng(&[1], &mut rng);
+
         let mut shares: Vec<Share> = dealer.take(255).collect();
         shares[1] = Share {
             x: shares[0].x,
@@ -166,9 +206,17 @@ mod tests {
     #[test]
     fn test_integration_works() {
         let sharks = Sharks(255);
+
+        #[cfg(not(feature = "std"))]
+        let mut rng = rand_chacha::ChaCha8Rng::from_seed([0x90; 32]);
+
+        #[cfg(feature = "std")]
         let dealer = sharks.dealer(&[1, 2, 3, 4]);
+        #[cfg(not(feature = "std"))]
+        let dealer = sharks.dealer_rng(&[1, 2, 3, 4], &mut rng);
+
         let shares: Vec<Share> = dealer.take(255).collect();
         let secret = sharks.recover(&shares).unwrap();
-        assert_eq!(secret, vec![1, 2, 3, 4]);
+        assert_eq!(secret, alloc::vec![1, 2, 3, 4]);
     }
 }

src/math.rs

@@ -1,6 +1,5 @@
 // A module which contains necessary algorithms to compute Shamir's shares and recover secrets
 
-#[cfg(not(feature = "std"))]
 use alloc::vec::Vec;
 
 use rand::distributions::{Distribution, Uniform};
@@ -31,26 +30,21 @@ pub fn interpolate(shares: &[Share]) -> Vec<u8> {
         .collect()
 }
 
-pub fn random_polynomial_with_rng(mut rng: &mut impl rand::Rng, s: GF256, k: u8) -> Vec<GF256> {
+// Generates `k` polynomial coefficients, being the last one `s` and the others randomly generated between `[1, 255]`.
+// Coefficient degrees go from higher to lower in the returned vector order.
+pub fn random_polynomial<R: rand::Rng>(s: GF256, k: u8, rng: &mut R) -> Vec<GF256> {
     let k = k as usize;
     let mut poly = Vec::with_capacity(k);
     let between = Uniform::new_inclusive(1, 255);
 
     for _ in 1..k {
-        poly.push(GF256(between.sample(&mut rng)));
+        poly.push(GF256(between.sample(rng)));
     }
     poly.push(s);
 
     poly
 }
 
-// Generates `k` polynomial coefficients, being the last one `s` and the others randomly generated between `[1, 255]`.
-// Coefficient degrees go from higher to lower in the returned vector order.
-#[cfg(feature = "std")]
-pub fn random_polynomial(s: GF256, k: u8) -> Vec<GF256> {
-    random_polynomial_with_rng(&mut rand::thread_rng(), s, k)
-}
-
 // Returns an iterator over the points of the `polys` polynomials passed as argument.
 // Each item of the iterator is a tuple `(x, [f_1(x), f_2(x)..])` where eaxh `f_i` is the result for the ith polynomial.
 // Each polynomial corresponds to one byte chunk of the original secret.
@@ -68,30 +62,37 @@ pub fn get_evaluator(polys: Vec<Vec<GF256>>) -> impl Iterator<Item = Share> {
 #[cfg(test)]
 mod tests {
     use super::{get_evaluator, interpolate, random_polynomial, Share, GF256};
+    use alloc::vec::Vec;
+    use rand_chacha::rand_core::SeedableRng;
 
     #[test]
     fn random_polynomial_works() {
-        let poly = random_polynomial(GF256(1), 3);
+        let mut rng = rand_chacha::ChaCha8Rng::from_seed([0x90; 32]);
+        let poly = random_polynomial(GF256(1), 3, &mut rng);
         assert_eq!(poly.len(), 3);
         assert_eq!(poly[2], GF256(1));
     }
 
     #[test]
     fn evaluator_works() {
-        let iter = get_evaluator(vec![vec![GF256(3), GF256(2), GF256(5)]]);
+        let iter = get_evaluator(alloc::vec![alloc::vec![GF256(3), GF256(2), GF256(5)]]);
         let values: Vec<_> = iter.take(2).map(|s| (s.x, s.y)).collect();
         assert_eq!(
             values,
-            vec![(GF256(1), vec![GF256(4)]), (GF256(2), vec![GF256(13)])]
+            alloc::vec![
+                (GF256(1), alloc::vec![GF256(4)]),
+                (GF256(2), alloc::vec![GF256(13)])
+            ]
         );
     }
 
     #[test]
     fn interpolate_works() {
-        let poly = random_polynomial(GF256(185), 10);
+        let mut rng = rand_chacha::ChaCha8Rng::from_seed([0x90; 32]);
-        let iter = get_evaluator(vec![poly]);
+        let poly = random_polynomial(GF256(185), 10, &mut rng);
+        let iter = get_evaluator(alloc::vec![poly]);
         let shares: Vec<Share> = iter.take(10).collect();
         let root = interpolate(&shares);
-        assert_eq!(root, vec![185]);
+        assert_eq!(root, alloc::vec![185]);
     }
 }

src/share.rs

@@ -1,4 +1,3 @@
-#[cfg(not(feature = "std"))]
 use alloc::vec::Vec;
 
 use super::field::GF256;
@@ -8,12 +7,14 @@ use super::field::GF256;
 /// Usage example:
 /// ```
 /// use sharks::{Sharks, Share};
+/// # use rand_chacha::rand_core::SeedableRng;
 /// # fn send_to_printer(_: Vec<u8>) {}
 /// # fn ask_shares() -> Vec<Vec<u8>> {vec![vec![1, 2], vec![2, 3], vec![3, 4]]}
 ///
 /// // Transmit the share bytes to a printer
 /// let sharks = Sharks(3);
-/// let dealer = sharks.dealer(&[1, 2, 3]);
+/// let mut rng = rand_chacha::ChaCha8Rng::from_seed([0x90; 32]);
+/// let dealer = sharks.dealer_rng(&[1, 2, 3], &mut rng);
 ///
 /// // Get 5 shares and print paper keys
 /// for s in dealer.take(5) {
@@ -52,15 +53,16 @@ impl From<&[u8]> for Share {
 #[cfg(test)]
 mod tests {
     use super::{Share, GF256};
+    use alloc::vec::Vec;
 
     #[test]
     fn vec_from_share_works() {
         let share = Share {
             x: GF256(1),
-            y: vec![GF256(2), GF256(3)],
+            y: alloc::vec![GF256(2), GF256(3)],
         };
         let bytes = Vec::from(&share);
-        assert_eq!(bytes, vec![1, 2, 3]);
+        assert_eq!(bytes, alloc::vec![1, 2, 3]);
     }
 
     #[test]
@@ -68,6 +70,6 @@ mod tests {
         let bytes = [1, 2, 3];
         let share = Share::from(&bytes[..]);
         assert_eq!(share.x, GF256(1));
-        assert_eq!(share.y, vec![GF256(2), GF256(3)]);
+        assert_eq!(share.y, alloc::vec![GF256(2), GF256(3)]);
     }
 }