diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index e3d884b..a92f52a 100644 --- a/.github/workflows/rust.yml +++ b/.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 diff --git a/CHANGELOG.md b/CHANGELOG.md index f43d7d1..e6f51a5 100644 --- a/CHANGELOG.md +++ b/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 diff --git a/Cargo.toml b/Cargo.toml index 78d6af2..32df553 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "sharks" -version = "0.3.3" +version = "0.4.0" authors = ["Aitor Ruano "] 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 } -hashbrown = "0.7.1" +rand = { version = "0.7", default-features = false } +hashbrown = "0.7" [dev-dependencies] criterion = "0.3" +rand_chacha = "0.2" [[bench]] name = "benchmarks" diff --git a/README.md b/README.md index 48fe603..4726743 100644 --- a/README.md +++ b/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) diff --git a/src/field.rs b/src/field.rs index 4940ac8..b9b93d9 100644 --- a/src/field.rs +++ b/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::().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::().0, 4); } } diff --git a/src/lib.rs b/src/lib.rs index 8a6d5e7..5f3c23a 100644 --- a/src/lib.rs +++ b/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 = 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 std::collections::HashSet; +use alloc::vec::Vec; +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 = dealer.take(3).collect(); + pub fn dealer_rng( + &self, + secret: &[u8], + rng: &mut R, + ) -> impl Iterator { + 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 = dealer.take(3).collect(); #[cfg(feature = "std")] pub fn dealer(&self, secret: &[u8]) -> impl Iterator { - let mut polys = Vec::with_capacity(secret.len()); - - 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 { - 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) + let mut rng = rand::thread_rng(); + self.dealer_rng(secret, &mut rng) } /// 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 = sharks.dealer(&[1]).take(3).collect(); + /// # let mut rng = rand_chacha::ChaCha8Rng::from_seed([0x90; 32]); + /// # let mut shares: Vec = 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 = 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 = 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 = 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]); } } diff --git a/src/math.rs b/src/math.rs index f61f564..e5e83a0 100644 --- a/src/math.rs +++ b/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 { .collect() } -pub fn random_polynomial_with_rng(mut rng: &mut impl rand::Rng, s: GF256, k: u8) -> Vec { +// 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(s: GF256, k: u8, rng: &mut R) -> Vec { 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 { - 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>) -> impl Iterator { #[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 iter = get_evaluator(vec![poly]); + let mut rng = rand_chacha::ChaCha8Rng::from_seed([0x90; 32]); + let poly = random_polynomial(GF256(185), 10, &mut rng); + let iter = get_evaluator(alloc::vec![poly]); let shares: Vec = iter.take(10).collect(); let root = interpolate(&shares); - assert_eq!(root, vec![185]); + assert_eq!(root, alloc::vec![185]); } } diff --git a/src/share.rs b/src/share.rs index a0b01e6..dfd0cb2 100644 --- a/src/share.rs +++ b/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) {} /// # fn ask_shares() -> Vec> {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)]); } }