From 116cfd3a049847845be3df7dae5f87c0e2ffb57f Mon Sep 17 00:00:00 2001
From: Kitsu <mail@kitsu.me>
Date: Thu, 26 Mar 2020 20:23:08 +0300
Subject: [PATCH] feat: support no_std

---
 Cargo.toml   |  7 ++++++-
 src/field.rs |  4 ++--
 src/lib.rs   | 29 +++++++++++++++++++++++++++++
 src/math.rs  | 15 +++++++++++----
 src/share.rs |  3 +++
 5 files changed, 51 insertions(+), 7 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 30c06c8..78d6af2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -17,8 +17,13 @@ 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 = "0.7"
+rand = { version = "0.7", default_features = false }
+hashbrown = "0.7.1"
 
 [dev-dependencies]
 criterion = "0.3"
diff --git a/src/field.rs b/src/field.rs
index aa2d7eb..4940ac8 100644
--- a/src/field.rs
+++ b/src/field.rs
@@ -1,8 +1,8 @@
 // Basic operations overrided for the Galois Field 256 (2**8)
 // Uses pre-calculated tables for 0x11d primitive polynomial (x**8 + x**4 + x**3 + x**2 + 1)
 
-use std::iter::{Product, Sum};
-use std::ops::{Add, Div, Mul, Sub};
+use core::iter::{Product, Sum};
+use core::ops::{Add, Div, Mul, Sub};
 
 const LOG_TABLE: [u8; 256] = [
     0x00, 0x00, 0x01, 0x19, 0x02, 0x32, 0x1a, 0xc6, 0x03, 0xdf, 0x33, 0xee, 0x1b, 0x68, 0xc7, 0x4b,
diff --git a/src/lib.rs b/src/lib.rs
index a9d673e..8a6d5e7 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -15,10 +15,20 @@
 //! assert_eq!(secret, vec![1, 2, 3, 4]);
 //! ```
 
+#![cfg_attr(not(feature = "std"), 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 field::GF256;
@@ -54,6 +64,7 @@ impl Sharks {
     /// let dealer = sharks.dealer(&[1, 2]);
     /// // Get 3 shares
     /// 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());
 
@@ -64,6 +75,24 @@ impl Sharks {
         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.
     /// If the number of distinct shares is less than the minimum threshold an `Err` is returned,
     /// otherwise an `Ok` containing the secret.
diff --git a/src/math.rs b/src/math.rs
index 187709d..f61f564 100644
--- a/src/math.rs
+++ b/src/math.rs
@@ -1,5 +1,8 @@
 // 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};
 
 use super::field::GF256;
@@ -28,13 +31,10 @@ pub fn interpolate(shares: &[Share]) -> Vec<u8> {
         .collect()
 }
 
-// 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) -> Vec<GF256> {
+pub fn random_polynomial_with_rng(mut rng: &mut impl rand::Rng, s: GF256, k: u8) -> Vec<GF256> {
     let k = k as usize;
     let mut poly = Vec::with_capacity(k);
     let between = Uniform::new_inclusive(1, 255);
-    let mut rng = rand::thread_rng();
 
     for _ in 1..k {
         poly.push(GF256(between.sample(&mut rng)));
@@ -44,6 +44,13 @@ pub fn random_polynomial(s: GF256, k: u8) -> Vec<GF256> {
     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.
diff --git a/src/share.rs b/src/share.rs
index c6b861b..a0b01e6 100644
--- a/src/share.rs
+++ b/src/share.rs
@@ -1,3 +1,6 @@
+#[cfg(not(feature = "std"))]
+use alloc::vec::Vec;
+
 use super::field::GF256;
 
 /// A share used to reconstruct the secret. Can be serialized to and from a byte array.