arcium-primitives 0.4.2

Arcium primitives
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

use ff::Field;

use crate::{
    algebra::{
        field::{FieldExtension, SubfieldElement},
        BoxedUint,
    },
    correlated_randomness::pow::types::{OpenPowPair, PowPair},
    errors::PrimitiveError,
    izip_eq,
    sharing::{Reconstructible, VerifiableWith},
    types::PeerIndex,
};
// ---------------
// |   Opening   |
// ---------------

impl<F: FieldExtension> Reconstructible for PowPair<F> {
    type Opening = OpenPowPair<F>;
    type Value = (SubfieldElement<F>, SubfieldElement<F>);

    fn open_to(&self, peer_index: PeerIndex) -> Result<OpenPowPair<F>, PrimitiveError> {
        Ok(OpenPowPair {
            lambda: self.lambda.open_to(peer_index)?,
            lambda_pow_neg_exp: self.lambda_pow_neg_exp.open_to(peer_index)?,
        })
    }

    fn open_to_all_others(&self) -> impl ExactSizeIterator<Item = OpenPowPair<F>> {
        let lambda = self.lambda.open_to_all_others();
        let lambda_pow_neg_exp = self.lambda_pow_neg_exp.open_to_all_others();
        izip_eq!(lambda, lambda_pow_neg_exp).map(|(lambda, lambda_pow_neg_exp)| OpenPowPair {
            lambda,
            lambda_pow_neg_exp,
        })
    }

    fn reconstruct(&self, openings: Vec<OpenPowPair<F>>) -> Result<Self::Value, PrimitiveError> {
        let (lambda_openings, lambda_pow_neg_exp_openings): (Vec<_>, Vec<_>) = openings
            .into_iter()
            .map(|o| (o.lambda, o.lambda_pow_neg_exp))
            .unzip();
        let lambda = self.lambda.reconstruct(lambda_openings)?;
        let lambda_pow_neg_exp = self
            .lambda_pow_neg_exp
            .reconstruct(lambda_pow_neg_exp_openings)?;
        Ok((lambda, lambda_pow_neg_exp))
    }
}

impl<F: FieldExtension> VerifiableWith for PowPair<F> {
    type VerificationData = BoxedUint;
    fn verify_with(
        &self,
        openings: Vec<OpenPowPair<F>>,
        exponent: BoxedUint,
    ) -> Result<(), PrimitiveError> {
        let (lambda, lambda_pow_neg_exp) = self.reconstruct(openings)?;
        let expected_lambda_pow_neg_exp = lambda.pow::<BoxedUint>(exponent).invert();
        if expected_lambda_pow_neg_exp.is_none().into() {
            return Err(PrimitiveError::WrongCorrelation(
                "λ^(-exp) is not invertible".to_string(),
            ));
        }
        let expected_lambda_pow_neg_exp = expected_lambda_pow_neg_exp.unwrap();
        if lambda_pow_neg_exp != expected_lambda_pow_neg_exp {
            return Err(PrimitiveError::WrongCorrelation(
                "Stored (λ^(-exp)) does not match reconstructed λ^(-exp)".to_string(),
            ));
        }
        Ok(())
    }
}