bbs_plus 0.25.0

BBS, BBS+, threshold BBS+ signatures and protocols for proof of knowledge of signature
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

//! The multiplication phase of the threshold signing protocol of BBS and BBS+.

use super::ParticipantId;
use crate::error::BBSPlusError;
use ark_ff::PrimeField;
use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
use ark_std::{
    collections::{BTreeMap, BTreeSet},
    rand::RngCore,
    vec::Vec,
};
use digest::{DynDigest, ExtendableOutput, Update};
use oblivious_transfer_protocols::ot_based_multiplication::{
    base_ot_multi_party_pairwise::BaseOTOutput,
    batch_mul_multi_party::{
        Message1, Message2, Participant as MultiplicationParty,
        ParticipantOutput as MultiplicationPartyOutput,
    },
    dkls18_mul_2p::MultiplicationOTEParams,
    dkls19_batch_mul_2p::GadgetVector,
};

#[derive(Clone, CanonicalSerialize, CanonicalDeserialize)]
pub struct Phase2<F: PrimeField, const KAPPA: u16, const STATISTICAL_SECURITY_PARAMETER: u16>(
    pub MultiplicationParty<F, KAPPA, STATISTICAL_SECURITY_PARAMETER>,
);

#[derive(Clone, Debug, PartialEq, CanonicalSerialize, CanonicalDeserialize)]
pub struct Phase2Output<F: PrimeField>(pub MultiplicationPartyOutput<F>);

impl<F: PrimeField, const KAPPA: u16, const STATISTICAL_SECURITY_PARAMETER: u16>
    Phase2<F, KAPPA, STATISTICAL_SECURITY_PARAMETER>
{
    pub fn init<R: RngCore, X: Default + Update + ExtendableOutput>(
        rng: &mut R,
        id: ParticipantId,
        masked_signing_key_share: Vec<F>,
        masked_r: Vec<F>,
        base_ot_output: BaseOTOutput,
        others: BTreeSet<ParticipantId>,
        ote_params: MultiplicationOTEParams<KAPPA, STATISTICAL_SECURITY_PARAMETER>,
        gadget_vector: &GadgetVector<F, KAPPA, STATISTICAL_SECURITY_PARAMETER>,
    ) -> Result<(Self, BTreeMap<ParticipantId, Message1<F>>), BBSPlusError> {
        let (p, m) = MultiplicationParty::init::<R, X>(
            rng,
            id,
            masked_signing_key_share,
            masked_r,
            base_ot_output,
            others,
            ote_params,
            gadget_vector,
            b"Multiplication phase for threshold BBS and BBS+",
        )?;
        Ok((Self(p), m))
    }

    /// Process received message from Party2 of multiplication protocol
    pub fn receive_message1<
        D: Default + DynDigest + Clone,
        X: Default + Update + ExtendableOutput,
    >(
        &mut self,
        sender_id: ParticipantId,
        message: Message1<F>,
        gadget_vector: &GadgetVector<F, KAPPA, STATISTICAL_SECURITY_PARAMETER>,
    ) -> Result<Message2<F>, BBSPlusError> {
        let m = self
            .0
            .receive_message1::<D, X>(sender_id, message, gadget_vector)?;
        Ok(m)
    }

    /// Process received message from Party1 of multiplication protocol
    pub fn receive_message2<D: Default + DynDigest + Clone>(
        &mut self,
        sender_id: ParticipantId,
        message: Message2<F>,
        gadget_vector: &GadgetVector<F, KAPPA, STATISTICAL_SECURITY_PARAMETER>,
    ) -> Result<(), BBSPlusError> {
        self.0
            .receive_message2::<D>(sender_id, message, gadget_vector)?;
        Ok(())
    }

    pub fn finish(self) -> Phase2Output<F> {
        Phase2Output(self.0.finish())
    }
}