ferveo-tdec-temp5 0.4.0-alpha

Threshold signature and encryption using group secret key
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

use ark_ec::pairing::Pairing;

use crate::{
    prepare_combine_simple, BlindedKeyShare, CiphertextHeader,
    DecryptionSharePrecomputed, DecryptionShareSimple, PrivateKeyShare, Result,
    ShareCommitment,
};

#[derive(Clone, Debug)]
pub struct PublicDecryptionContextSimple<E: Pairing> {
    pub domain: E::ScalarField,
    pub share_commitment: ShareCommitment<E>,
    pub blinded_key_share: BlindedKeyShare<E>,
    pub validator_public_key: ferveo_common::PublicKey<E>,
}

// TODO: Mark for removal - #197
#[derive(Clone, Debug)]
pub struct SetupParams<E: Pairing> {
    pub b: E::ScalarField, // Validator private key
    pub b_inv: E::ScalarField,
    pub g: E::G1Affine,
    pub g_inv: E::G1Prepared,
    pub h_inv: E::G2Prepared,
    pub h: E::G2Affine,
}

#[derive(Clone, Debug)]
pub struct PrivateDecryptionContextSimple<E: Pairing> {
    pub index: usize,
    pub setup_params: SetupParams<E>,
    pub private_key_share: PrivateKeyShare<E>,
    pub public_decryption_contexts: Vec<PublicDecryptionContextSimple<E>>,
}

impl<E: Pairing> PrivateDecryptionContextSimple<E> {
    pub fn create_share(
        &self,
        ciphertext_header: &CiphertextHeader<E>,
        aad: &[u8],
    ) -> Result<DecryptionShareSimple<E>> {
        DecryptionShareSimple::create(
            &self.setup_params.b,
            &self.private_key_share,
            ciphertext_header,
            aad,
        )
    }

    pub fn create_share_precomputed(
        &self,
        ciphertext_header: &CiphertextHeader<E>,
        aad: &[u8],
        selected_participants: &[usize],
    ) -> Result<DecryptionSharePrecomputed<E>> {
        let selected_domain_points = selected_participants
            .iter()
            .map(|i| self.public_decryption_contexts[*i].domain)
            .collect::<Vec<_>>();
        let lagrange_coeffs =
            prepare_combine_simple::<E>(&selected_domain_points);

        DecryptionSharePrecomputed::create(
            self.index,
            &self.setup_params.b,
            &self.private_key_share,
            ciphertext_header,
            aad,
            &lagrange_coeffs[self.index],
        )
    }
}