feat: support no_std

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"

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,

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.

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.

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.