public
/
blahaj
5
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

simplify rng usage, update tests, upgrade version to 0.4

This commit is contained in:
Aitor Ruano 2020-04-02 09:31:52 +02:00
parent 116cfd3a04
commit ef3636b3a2
8 changed files with 144 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
.github/workflows/rust.yml vendored
View File

@ -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

4
CHANGELOG.md
View File

@ -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

8
Cargo.toml
View File

@ -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 }
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"

9
README.md
View File

@ -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)

4
src/field.rs
View File

@ -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);
}
}

126
src/lib.rs
View File

@ -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 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<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());
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)
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<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]);
}
}

33
src/math.rs
View File

@ -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 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<Share> = iter.take(10).collect();
let root = interpolate(&shares);
assert_eq!(root, vec![185]);
assert_eq!(root, alloc::vec![185]);
}
}

12
src/share.rs
View File

@ -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)]);
}
}