Added some secret sharing schemes

Author: hdvanegasm

README.md

@@ -81,9 +81,9 @@ library. The interaction between parties are done using the functions `send` and
 ## Missing features
 
 - [x] ~Implement secp256k1~.
-- [ ] Implement Feldman VSS.
+- [x] ~Implement Feldman VSS~.
 - [ ] Document the source code.
-- [ ] Implement Shamir's secret-sharing.
+- [x] ~Implement Shamir's secret-sharing.~
 - [ ] Implement a fake network so that the final user can prototype MPC protocols locally.
 - [ ] Implement polynomials over the prime field of the elliptic curves which is useful for Feldman VSS.
 - [ ] Improve the serialization and deserialization to optimize the communication.

src/math/ec/mod.rs

@@ -1,18 +1,21 @@
-use serde::{Deserialize, Serialize};
-
 use super::field::FiniteField;
+use serde::{Deserialize, Serialize};
 
 pub mod secp256k1;
 
 /// Trait that defines an elliptic curve point using certain number of limbs for the scalar and
 /// prime field.
-pub trait EllipticCurve<const LIMBS: usize>: Serialize + for<'a> Deserialize<'a> {
+pub trait EllipticCurve<const LIMBS: usize>:
+    Serialize + for<'a> Deserialize<'a> + PartialEq + Copy + Clone
+{
     type ScalarField: FiniteField<LIMBS>;
 
     /// Field in which the elliptic curve is defined. The points in the elliptic curve will be
     /// pairs in this field.
     type PrimeField: FiniteField<LIMBS>;
 
+    const ZERO: Self;
+
     /// Returns the generator of the curve.
     fn gen() -> Self;
 
@@ -26,9 +29,6 @@ pub trait EllipticCurve<const LIMBS: usize>: Serialize + for<'a> Deserialize<'a>
     /// point in the elliptic curve.
     fn scalar_mul(&self, rhs: &Self::ScalarField) -> Self;
 
-    /// Returns whether two points in the elliptic curve are equal.
-    fn eq(&self, other: &Self) -> bool;
-
     /// Returns the additive inverse of the point in the elliptic curve.
     fn negate(&self) -> Self;
 }

src/math/ec/secp256k1.rs

@@ -1,27 +1,25 @@
-use std::ops::{Add, Mul};
-
-use crypto_bigint::Uint;
-use serde::{Deserialize, Serialize};
-
 use crate::math::{
     field::{
         secp256k1_prime::Secp256k1PrimeField, secp256k1_scalar::Secp256k1ScalarField, FiniteField,
     },
     ring::Ring,
 };
+use crypto_bigint::Uint;
+use serde::{Deserialize, Serialize};
+use std::ops::{Add, Mul};
 
 use super::EllipticCurve;
 
 /// Implementation of secp256k1 using projective coordinates.
-#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, Eq)]
 pub struct Secp256k1(
     Secp256k1PrimeField,
     Secp256k1PrimeField,
     Secp256k1PrimeField,
 );
 
 /// Representation of a secp256k1 point using affine coordinates.
-#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
 pub struct AffinePoint(Secp256k1PrimeField, Secp256k1PrimeField);
 
 impl AffinePoint {
@@ -114,6 +112,7 @@ impl Secp256k1 {
 impl EllipticCurve<4> for Secp256k1 {
     type ScalarField = Secp256k1ScalarField;
     type PrimeField = Secp256k1PrimeField;
+    const ZERO: Self = Self::POINT_AT_INFINITY;
 
     fn gen() -> Self {
         Self(
@@ -214,9 +213,15 @@ impl EllipticCurve<4> for Secp256k1 {
     fn sub(&self, rhs: &Self) -> Self {
         self.add(&rhs.negate())
     }
+}
 
+impl PartialEq for Secp256k1 {
     fn eq(&self, other: &Self) -> bool {
         self.x().mul(other.z()).eq(&other.x().mul(self.z()))
             && self.y().mul(other.z()).eq(&other.y().mul(self.z()))
     }
+
+    fn ne(&self, other: &Self) -> bool {
+        !(self == other)
+    }
 }

src/math/field/mod.rs

@@ -1,7 +1,6 @@
-use std::{fmt::Debug, ops::Div};
-
 use crate::math::ring;
 use crypto_bigint::{NonZero, Uint};
+use std::{fmt::Debug, ops::Div};
 use thiserror::Error;
 
 /// This module contains an implementation of the field Mersenne 61 which is the
@@ -23,7 +22,9 @@ pub enum FieldError {
 }
 
 /// Trait that represent a finite field of integers modulo a prime $p$.
-pub trait FiniteField<const LIMBS: usize>: ring::Ring + for<'a> Div<&'a Self> {
+pub trait FiniteField<const LIMBS: usize>:
+    ring::Ring + for<'a> Div<&'a Self> + Copy + Clone
+{
     /// Modulus used in for the field represented in Little-Endian.
     const MODULUS: NonZero<Uint<LIMBS>>;
 

src/math/field/secp256k1_prime.rs

@@ -1,13 +1,10 @@
-use std::ops::{Add, Div, Mul, Sub};
-
+use super::{FieldError, FiniteField};
+use crate::math::ring::Ring;
 use crypto_bigint::{rand_core::RngCore, NonZero, RandomMod, Uint, Zero};
 use serde::{Deserialize, Serialize};
+use std::ops::{Add, Div, Mul, Sub};
 
-use crate::math::ring::Ring;
-
-use super::{FieldError, FiniteField};
-
-#[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Hash, Eq, Serialize, Deserialize)]
+#[derive(Debug, Copy, Clone, PartialEq, Hash, Eq, Serialize, Deserialize)]
 pub struct Secp256k1PrimeField(Uint<4>);
 
 impl Secp256k1PrimeField {

src/math/field/secp256k1_scalar.rs

@@ -1,27 +1,14 @@
+use super::{naf::NafEncoding, FieldError, FiniteField};
+use crate::math::ring::Ring;
 use crypto_bigint::{rand_core::RngCore, Limb, NonZero, RandomMod, Uint, Zero};
-use std::ops::{Add, Div, Mul, Sub};
-
 use serde::{Deserialize, Serialize};
-
-use crate::math::ring::Ring;
-
-use super::{naf::NafEncoding, FieldError, FiniteField};
+use std::ops::{Add, Div, Mul, Sub};
 
 const LIMBS: usize = 4;
 
 #[derive(Debug, Copy, Clone, PartialEq, Hash, Eq, Serialize, Deserialize)]
 pub struct Secp256k1ScalarField(Uint<LIMBS>);
 
-fn test_bit<const LIMBS: usize>(input: Uint<LIMBS>, pos: usize) -> bool {
-    assert!((pos as u32) < LIMBS as u32 * Limb::BITS);
-    let bits_per_limb = Limb::BITS;
-
-    let limbs_input = input.as_limbs();
-    let limb = pos as u32 / bits_per_limb;
-    let limb_pos = pos as u32 % bits_per_limb;
-    ((limbs_input[limb as usize] >> limb_pos) & Limb::ONE) == Limb::ONE
-}
-
 impl Secp256k1ScalarField {
     pub fn to_naf(&self) -> NafEncoding {
         let mut naf = NafEncoding::new(Self::BIT_SIZE + 1);
@@ -48,7 +35,6 @@ impl Secp256k1ScalarField {
 }
 
 impl FiniteField<4> for Secp256k1ScalarField {
-    // TODO: Fix this number.
     const MODULUS: NonZero<Uint<4>> = NonZero::<Uint<4>>::new_unwrap(Uint::from_words([
         0xBFD25E8CD0364141,
         0xBAAEDCE6AF48A03B,
@@ -128,3 +114,13 @@ impl Div<&Self> for Secp256k1ScalarField {
         Ok(self.mul(&inverse))
     }
 }
+
+fn test_bit<const LIMBS: usize>(input: Uint<LIMBS>, pos: usize) -> bool {
+    assert!((pos as u32) < LIMBS as u32 * Limb::BITS);
+    let bits_per_limb = Limb::BITS;
+
+    let limbs_input = input.as_limbs();
+    let limb = pos as u32 / bits_per_limb;
+    let limb_pos = pos as u32 % bits_per_limb;
+    ((limbs_input[limb as usize] >> limb_pos) & Limb::ONE) == Limb::ONE
+}

src/math/matrix.rs

@@ -1,10 +1,9 @@
-use std::ops::{Add, AddAssign, Mul, Sub, SubAssign};
-
+use super::{ring::Ring, vector::Vector};
 use crypto_bigint::rand_core::RngCore;
+use serde::Serialize;
+use std::ops::{Add, AddAssign, Mul, Sub, SubAssign};
 use thiserror::Error;
 
-use super::{ring::Ring, vector::Vector};
-
 /// Errors that may occurs when creating and operating with matrices.
 #[derive(Error, Debug)]
 pub enum Error {
@@ -21,6 +20,7 @@ pub enum Error {
 pub type Result<T> = std::result::Result<T, Error>;
 
 /// Matrix with elements in a ring.
+#[derive(Serialize, Debug, Eq)]
 pub struct Matrix<T: Ring> {
     /// Elements of the matrix.
     elements: Vec<T>,

src/math/poly.rs

@@ -1,14 +1,13 @@
+use super::ring::Ring;
+use crate::math::field::FiniteField;
+use crypto_bigint::rand_core::RngCore;
+use serde::Serialize;
 use std::{
     collections::HashSet,
     ops::{Index, IndexMut},
 };
-
-use crate::math::field::FiniteField;
-use crypto_bigint::rand_core::RngCore;
 use thiserror::Error;
 
-use super::ring::Ring;
-
 /// Errors for all the polynomial operations.
 #[derive(Debug, Error)]
 pub enum Error<T>
@@ -28,7 +27,7 @@ where
 pub type Result<T, R> = std::result::Result<T, Error<R>>;
 
 /// Represents a polynomial whose coefficients are elements in a finite field.
-#[derive(PartialEq, Eq, Debug)]
+#[derive(PartialEq, Eq, Debug, Serialize)]
 pub struct Polynomial<const LIMBS: usize, T: FiniteField<LIMBS>>(Vec<T>);
 
 impl<const LIMBS: usize, T: FiniteField<LIMBS>> Polynomial<LIMBS, T> {
@@ -41,6 +40,14 @@ impl<const LIMBS: usize, T: FiniteField<LIMBS>> Polynomial<LIMBS, T> {
         result
     }
 
+    pub fn coefficients(&self) -> &[T] {
+        &self.0
+    }
+
+    pub fn degree(&self) -> usize {
+        self.0.len() - 1
+    }
+
     /// Generates a random polynomial of a given degree using a given pseudo-random generator.
     pub fn random<R: RngCore>(degree: usize, rng: &mut R) -> Self {
         let mut coefficients = Vec::with_capacity(degree + 1);
@@ -50,6 +57,10 @@ impl<const LIMBS: usize, T: FiniteField<LIMBS>> Polynomial<LIMBS, T> {
         Self(coefficients)
     }
 
+    pub fn set_constant_coeff(&mut self, value: T) {
+        self[0] = value;
+    }
+
     pub fn new(coef: Vec<T>) -> Result<Self, T> {
         if coef.len() == 0 {
             Err(Error::EmptyCoefficients)
@@ -82,12 +93,12 @@ impl<const LIMBS: usize, const N: usize, T: FiniteField<LIMBS>> From<[T; N]>
 }
 
 /// Computes the lagrange basis evaluated at `x`
-pub(crate) fn compute_lagrange_basis<const LIMBS: usize, T: FiniteField<LIMBS>>(
-    nodes: Vec<T>,
+pub fn compute_lagrange_basis<const LIMBS: usize, T: FiniteField<LIMBS>>(
+    nodes: &[T],
     x: &T,
 ) -> Result<Vec<T>, T> {
-    if !all_different(&nodes) {
-        return Err(Error::NotAllDifferentInterpolation(nodes));
+    if !all_different(nodes) {
+        return Err(Error::NotAllDifferentInterpolation(nodes.to_vec()));
     }
     let mut lagrange_basis = Vec::with_capacity(nodes.len());
     for j in 0..nodes.len() {
@@ -125,15 +136,15 @@ fn all_different<T: Ring>(list: &[T]) -> bool {
 
 /// Computes the evaluation of the interpolated polynomial at `x`.
 pub fn interpolate_polynomial_at<const LIMBS: usize, T: FiniteField<LIMBS>>(
-    evaluations: Vec<T>,
-    alphas: Vec<T>,
+    evaluations: &[T],
+    alphas: &[T],
     x: &T,
 ) -> Result<T, T> {
     assert!(alphas.len() > 0);
     assert!(alphas.len() == evaluations.len());
     let lagrange_basis = compute_lagrange_basis(alphas, x)?;
     let mut interpolation = T::ZERO;
-    for (eval, basis) in evaluations.into_iter().zip(lagrange_basis) {
+    for (eval, basis) in evaluations.iter().zip(lagrange_basis) {
         interpolation = interpolation.add(&eval.mul(&basis));
     }
     Ok(interpolation)

src/math/ring.rs

@@ -1,12 +1,11 @@
+use crypto_bigint::rand_core::RngCore;
+use serde::{Deserialize, Serialize};
 use std::{
     fmt::Debug,
     hash::Hash,
     ops::{Add, Mul, Sub},
 };
 
-use crypto_bigint::rand_core::RngCore;
-use serde::{Deserialize, Serialize};
-
 /// This trait represent an algebraic finite Ring.
 pub trait Ring:
     Debug

src/math/vector.rs

@@ -1,9 +1,10 @@
-use crypto_bigint::rand_core::RngCore;
-
 use super::ring::Ring;
+use crypto_bigint::rand_core::RngCore;
+use serde::Serialize;
 use std::ops::{Add, Index, IndexMut, Mul, Sub};
 
 /// Vector whose elements belong to a ring.
+#[derive(Serialize, PartialEq, Eq, Debug)]
 pub struct Vector<T: Ring>(Vec<T>);
 
 impl<T> Vector<T>