mpvss-rs 2.0.0

A Simple Publicly Verifiable Secret Sharing Library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

// Copyright 2020-2021  MathxH Chen.
//
// Code is licensed under MIT Apache Dual License

use num_bigint::{BigInt, RandBigInt, ToBigInt};
use num_traits::pow::Pow;
use std::clone::Clone;
use std::ops::*;
use std::vec::Vec;

/// Shamir Secret Shares on Polynomial, (k,n) threshhod secheme
/// P(x) = a_0*x^0 + a_1*x^1 + a_2*x^2 + ... + a_n*x^(k-1)
/// degree is k - 1
/// s = P(0) = a_0
/// s_i = P(i)

#[derive(Debug, Clone, Default)]
pub struct Polynomial {
    pub coefficients: Vec<BigInt>,
}

impl Polynomial {
    /// Create empty Polynomial instance
    pub fn new() -> Self {
        Polynomial {
            coefficients: Vec::new(),
        }
    }

    pub fn init_coefficients(&mut self, coefficients: &[BigInt]) {
        self.coefficients = coefficients.to_vec();
    }

    pub fn init(&mut self, degree: i32, q: &BigInt) {
        let mut coefficients = vec![];
        let mut rng = rand::thread_rng();
        // [0,degree] not [0,degree)
        for _ in 0..=degree {
            let coefficient = rng
                .gen_biguint_below(&q.to_biguint().unwrap())
                .to_bigint()
                .unwrap();
            coefficients.push(coefficient);
        }

        self.init_coefficients(&coefficients);
    }

    /// Get P(x) = value
    pub fn get_value(&self, x: &BigInt) -> BigInt {
        // a_0
        let mut result = self.coefficients[0].clone();
        // a0+ a_1*x^1 + a_2*x^2 + ... + a_n*x^n
        for i in 1..self.coefficients.len() {
            result += self.coefficients[i].clone().mul(x.pow(i));
        }
        result
    }
}

#[cfg(test)]
mod tests {
    use super::BigInt;
    use super::Polynomial;
    use num_bigint::ToBigInt;
    #[test]
    fn test_init_polynomial() {
        let mut polynomial = Polynomial::new();
        let degree = 3;
        polynomial.init(degree, &BigInt::from(5_i32));

        assert_eq!(polynomial.coefficients.len(), (degree + 1) as usize);
    }
    #[test]
    fn test_get_value() {
        // a_0 = 3, a_1 = 2, a_2 = 2, a_3 = 4
        let mut polynomial = Polynomial::new();
        polynomial.init_coefficients(&vec![
            3.to_bigint().unwrap(),
            2.to_bigint().unwrap(),
            2.to_bigint().unwrap(),
            4.to_bigint().unwrap(),
        ]);

        // P(0) = a_0 = 3
        assert_eq!(
            polynomial.get_value(&0.to_bigint().unwrap()),
            BigInt::from(3_i32)
        );

        // P(1) = 11
        assert_eq!(
            polynomial.get_value(&1.to_bigint().unwrap()),
            BigInt::from(11_i32)
        );

        // P(2) = 47
        assert_eq!(
            polynomial.get_value(&2.to_bigint().unwrap()),
            BigInt::from(47_i32)
        );

        // P(3) = 135
        assert_eq!(
            polynomial.get_value(&3.to_bigint().unwrap()),
            BigInt::from(135_i32)
        );
    }

    #[test]
    fn test_get_value2() {
        let q: BigInt = BigInt::from(15486967);
        let coefficients = vec![
            BigInt::from(105211),
            BigInt::from(1548877),
            BigInt::from(892134),
            BigInt::from(3490857),
            BigInt::from(324),
            BigInt::from(14234735),
        ];
        let x: BigInt = BigInt::from(278);
        let mut polynomial = Polynomial::new();
        polynomial.init_coefficients(&coefficients);
        assert_eq!(polynomial.get_value(&x) % q, BigInt::from(4115179));
    }
}