Add reconstruct_parallelized API for improve reconstruct performance (#2)

* Use rayon to improve reconstruct performance

* Add reconstruct_parallelized API for improve perf

Author: AlexiaChen

Cargo.toml

@@ -17,4 +17,5 @@ num-integer = "0.1.44"
 num-primes = "0.1.2"
 num-traits = "0.2.14"
 rand = "0.5.6"
+rayon = "1.5.0"
 sha2 = "0.9.2"

README.md

@@ -140,6 +140,32 @@ let r3_str = String::from_utf8(r3.to_biguint().unwrap().to_bytes_be()).unwrap();
 assert_eq!(secret_message.clone(), r3_str);
 ```
 
+Reconstruction using multi-threads.
+
+```rust
+let share_boxs = [s1, s2, s3];
+let r1 = p1
+    .reconstruct_parallelized(&share_boxs, &distribute_shares_box)
+    .unwrap();
+let r2 = p2
+    .reconstruct_parallelized(&share_boxs, &distribute_shares_box)
+    .unwrap();
+let r3 = p3
+    .reconstruct_parallelized(&share_boxs, &distribute_shares_box)
+    .unwrap();
+
+let r1_str = String::from_utf8(r1.to_biguint().unwrap().to_bytes_be()).unwrap();
+assert_eq!(secret_message.clone(), r1_str);
+let r2_str = String::from_utf8(r2.to_biguint().unwrap().to_bytes_be()).unwrap();
+assert_eq!(secret_message.clone(), r2_str);
+let r3_str = String::from_utf8(r3.to_biguint().unwrap().to_bytes_be()).unwrap();
+assert_eq!(secret_message.clone(), r3_str);
+```
+
+## In the futures
+
+Add more Elliptic Curves groups.
+
 ## Related References:
 
 - Berry Schoenmakers. [A Simple Publicly Verifiable Secret Sharing Scheme and its Application to Electronic Voting](https://www.win.tue.nl/~berry/papers/crypto99.pdf)

examples/mpvss_all.rs

@@ -79,8 +79,34 @@ fn main() {
         String::from_utf8(r3.to_biguint().unwrap().to_bytes_be()).unwrap();
     assert_eq!(secret_message.clone(), r3_str);
 
-    println!("secret message: {}", secret_message);
-    println!("r1 str: {}", r1_str);
-    println!("r2 str: {}", r2_str);
-    println!("r3 str: {}", r3_str);
+    println!("secret message with single thread: {}", secret_message);
+    println!("r1 str with single thread: {}", r1_str);
+    println!("r2 str with single thread: {}", r2_str);
+    println!("r3 str with single thread: {}", r3_str);
+
+    // Improve reconstruct performance
+    let r1 = p1
+        .reconstruct_parallelized(&share_boxs, &distribute_shares_box)
+        .unwrap();
+    let r2 = p2
+        .reconstruct_parallelized(&share_boxs, &distribute_shares_box)
+        .unwrap();
+    let r3 = p3
+        .reconstruct_parallelized(&share_boxs, &distribute_shares_box)
+        .unwrap();
+
+    let r1_str =
+        String::from_utf8(r1.to_biguint().unwrap().to_bytes_be()).unwrap();
+    assert_eq!(secret_message.clone(), r1_str);
+    let r2_str =
+        String::from_utf8(r2.to_biguint().unwrap().to_bytes_be()).unwrap();
+    assert_eq!(secret_message.clone(), r2_str);
+    let r3_str =
+        String::from_utf8(r3.to_biguint().unwrap().to_bytes_be()).unwrap();
+    assert_eq!(secret_message.clone(), r3_str);
+
+    println!("secret message with parallelized: {}", secret_message);
+    println!("r1 str with parallelized: {}", r1_str);
+    println!("r2 str with parallelized: {}", r2_str);
+    println!("r3 str with parallelized: {}", r3_str);
 }

examples/mpvss_sub.rs

@@ -102,4 +102,37 @@ fn main() {
     println!("r2 str: {}", r2_str);
     println!("r3 str: {}", r3_str);
     println!("r3 str: {}", r4_str);
+
+    // Improve reconstruct performance
+    let r1 = p1
+        .reconstruct_parallelized(&share_boxs, &distribute_shares_box)
+        .unwrap();
+    let r2 = p2
+        .reconstruct_parallelized(&share_boxs, &distribute_shares_box)
+        .unwrap();
+    let r3 = p3
+        .reconstruct_parallelized(&share_boxs, &distribute_shares_box)
+        .unwrap();
+    let r4 = p4
+        .reconstruct_parallelized(&share_boxs, &distribute_shares_box)
+        .unwrap();
+
+    let r1_str =
+        String::from_utf8(r1.to_biguint().unwrap().to_bytes_be()).unwrap();
+    assert_eq!(secret_message.clone(), r1_str);
+    let r2_str =
+        String::from_utf8(r2.to_biguint().unwrap().to_bytes_be()).unwrap();
+    assert_eq!(secret_message.clone(), r2_str);
+    let r3_str =
+        String::from_utf8(r3.to_biguint().unwrap().to_bytes_be()).unwrap();
+    assert_eq!(secret_message.clone(), r3_str);
+    let r4_str =
+        String::from_utf8(r4.to_biguint().unwrap().to_bytes_be()).unwrap();
+    assert_eq!(secret_message.clone(), r4_str);
+
+    println!("secret message with parallelized: {}", secret_message);
+    println!("r1 str with parallelized: {}", r1_str);
+    println!("r2 str with parallelized: {}", r2_str);
+    println!("r3 str with parallelized: {}", r3_str);
+    println!("r3 str with parallelized: {}", r4_str);
 }

src/mpvss.rs

@@ -12,6 +12,7 @@ use num_bigint::{BigInt, BigUint, RandBigInt, ToBigInt};
 use num_integer::Integer;
 use num_primes::Generator;
 use num_traits::identities::{One, Zero};
+use rayon::prelude::*;
 use sha2::{Digest, Sha256};
 use std::clone::Clone;
 use std::collections::BTreeMap;
@@ -189,6 +190,61 @@ impl MPVSS {
         dleq.check(&challenge_hasher)
     }
 
+    fn compute_factor(
+        &self,
+        position: i64,
+        share: &BigInt,
+        values: &[i64],
+    ) -> BigInt {
+        let mut exponent = BigInt::one();
+        let lagrangeCoefficient = Util::lagrange_coefficient(&position, values);
+        if lagrangeCoefficient.0.clone() % lagrangeCoefficient.1.clone()
+            == BigInt::zero()
+        {
+            // Lagrange coefficient is an integer
+            exponent = lagrangeCoefficient.0.clone()
+                / Util::abs(&lagrangeCoefficient.1);
+        } else {
+            // Lagrange coefficient is a proper fraction
+            // Cancel fraction if possible
+            let mut numerator = lagrangeCoefficient.0.to_biguint().unwrap();
+            let mut denominator =
+                Util::abs(&lagrangeCoefficient.1).to_biguint().unwrap();
+            let gcd = numerator.gcd(&denominator);
+            numerator = numerator / gcd.clone();
+            denominator = denominator / gcd.clone();
+
+            let q1 = self.q.clone() - BigInt::one();
+            let inverseDenominator = Util::mod_inverse(
+                &denominator.to_bigint().unwrap(),
+                &q1.to_bigint().unwrap(),
+            );
+            if inverseDenominator.is_some() {
+                exponent = (numerator.to_bigint().unwrap()
+                    * inverseDenominator.unwrap())
+                    % q1.clone().to_bigint().unwrap();
+            } else {
+                eprintln!("ERROR: Denominator of Lagrange coefficient fraction does not have an inverse. Share cannot be processed.");
+            }
+        }
+        let mut factor = share
+            .to_bigint()
+            .unwrap()
+            .modpow(&exponent, &self.q.to_bigint().unwrap());
+        if lagrangeCoefficient.0 * lagrangeCoefficient.1 < BigInt::zero() {
+            // Lagrange coefficient was negative. S^(-lambda) = 1/(S^lambda)
+            let inverseFactor =
+                Util::mod_inverse(&factor, &self.q.to_bigint().unwrap());
+            if inverseFactor.is_some() {
+                factor = inverseFactor.unwrap();
+            } else {
+                eprintln!("ERROR: Lagrange coefficient was negative and does not have an inverse. Share cannot be processed.")
+            }
+        }
+
+        factor
+    }
+
     /// Reconstruct secret from share boxs
     pub fn reconstruct(
         &self,
@@ -214,52 +270,59 @@ impl MPVSS {
         let mut secret: BigInt = BigInt::one();
         let values: Vec<i64> = shares.keys().map(|key| *key).collect();
         for (position, share) in shares {
-            let mut exponent = BigInt::one();
-            let lagrangeCoefficient =
-                Util::lagrange_coefficient(&position, values.as_slice());
-            if lagrangeCoefficient.0.clone() % lagrangeCoefficient.1.clone()
-                == BigInt::zero()
-            {
-                // Lagrange coefficient is an integer
-                exponent = lagrangeCoefficient.0.clone()
-                    / Util::abs(&lagrangeCoefficient.1);
-            } else {
-                // Lagrange coefficient is a proper fraction
-                // Cancel fraction if possible
-                let mut numerator = lagrangeCoefficient.0.to_biguint().unwrap();
-                let mut denominator =
-                    Util::abs(&lagrangeCoefficient.1).to_biguint().unwrap();
-                let gcd = numerator.gcd(&denominator);
-                numerator = numerator / gcd.clone();
-                denominator = denominator / gcd.clone();
+            let factor =
+                self.compute_factor(position, &share, values.as_slice());
+            secret = (secret * factor) % self.q.clone();
+        }
 
-                let q1 = self.q.clone() - BigInt::one();
-                let inverseDenominator = Util::mod_inverse(
-                    &denominator.to_bigint().unwrap(),
-                    &q1.to_bigint().unwrap(),
-                );
-                if inverseDenominator.is_some() {
-                    exponent = (numerator.to_bigint().unwrap()
-                        * inverseDenominator.unwrap())
-                        % q1.clone().to_bigint().unwrap();
-                } else {
-                    println!("ERROR: Denominator of Lagrange coefficient fraction does not have an inverse. Share cannot be processed.");
-                }
-            }
-            let mut factor = share
-                .to_bigint()
-                .unwrap()
-                .modpow(&exponent, &self.q.to_bigint().unwrap());
-            if lagrangeCoefficient.0 * lagrangeCoefficient.1 < BigInt::zero() {
-                // Lagrange coefficient was negative. S^(-lambda) = 1/(S^lambda)
-                let inverseFactor =
-                    Util::mod_inverse(&factor, &self.q.to_bigint().unwrap());
-                if inverseFactor.is_some() {
-                    factor = inverseFactor.unwrap();
-                } else {
-                    println!("ERROR: Lagrange coefficient was negative and does not have an inverse. Share cannot be processed.")
-                }
+        // Reconstruct the secret = H(G^s) xor U
+        let secret_hash = sha2::Sha256::digest(
+            &secret.to_biguint().unwrap().to_str_radix(10).as_bytes(),
+        );
+        let hash_big_uint = BigUint::from_bytes_be(&secret_hash[..])
+            .mod_floor(&self.q.to_biguint().unwrap());
+        let decrypted_secret = hash_big_uint
+            ^ distribute_share_box.U.clone().to_biguint().unwrap();
+        Some(decrypted_secret.to_bigint().unwrap())
+    }
+
+    /// Reconstruct secret from share boxs using multi threaded
+    pub fn reconstruct_parallelized(
+        &self,
+        share_boxs: &[ShareBox],
+        distribute_share_box: &DistributionSharesBox,
+    ) -> Option<BigInt> {
+        if share_boxs.len() < distribute_share_box.commitments.len() {
+            return None;
+        }
+        let mut shares: BTreeMap<i64, BigInt> = BTreeMap::new();
+        for share_box in share_boxs.iter() {
+            let position =
+                distribute_share_box.positions.get(&share_box.publickey);
+            if position.is_none() {
+                return None;
             }
+            shares.insert(*position.unwrap(), share_box.share.clone());
+        }
+        // Pooling  the shares. Suppose
+        // w.l.o.g.  that  participantsPiproduce  correctvalues for S_i, for i= 1,...,t.
+        // The secret G^s is obtained by Lagrange interpolation:
+        // ∏(i=1->t)(S^λ_i) = ∏(i=1->t)(G^p(i))^λ_i = G^(∑(i=1->t)p(i)*λ_i = G^p(0) = G^s,
+        let mut secret: BigInt = BigInt::one();
+        let values: Vec<i64> = shares.keys().map(|key| *key).collect();
+        let shares_vec: Vec<(i64, BigInt)> = shares
+            .into_iter()
+            .map(|(postion, share)| (postion, share))
+            .collect();
+        let shares_slice = shares_vec.as_slice();
+        let factors: Vec<BigInt> = shares_slice
+            .par_iter()
+            .map(|(position, share)| {
+                self.compute_factor(*position, share, values.as_slice())
+            })
+            .collect();
+
+        for factor in factors {
             secret = (secret * factor) % self.q.clone();
         }