Method init

kvac/src/bbs_sharp/proof.rs:137–190

Pass the appropriate type in `hw_sig_type` which corresponds to the signature type generated by user's secure hardware If `verifier_pub_key` is provided, then create a designated verifier proof which only the verifier can verify

(
        rng: &mut R,
        mac: &MAC<G>,
        params: &MACParams<G>,
        messages_and_blindings: MBI,
        user_public_key: &UserPublicKey<G>,
        hw_sig_type: HardwareSignatureType,

    /// Pass the appropriate type in `hw_sig_type` which corresponds to the signature type generated by user's secure hardware
    /// If `verifier_pub_key` is provided, then create a designated verifier proof which only the verifier can verify
    pub fn init<'a, MBI, R: RngCore>(
        rng: &mut R,
        mac: &MAC<G>,
        params: &MACParams<G>,
        messages_and_blindings: MBI,
        user_public_key: &UserPublicKey<G>,
        hw_sig_type: HardwareSignatureType,
        verifier_pub_key: Option<&G>,
    ) -> Result<Self, KVACError>
    where
        MBI: IntoIterator<Item = MessageOrBlinding<'a, G::ScalarField>>,
    {
        let (messages, indexed_blindings) =
            match split_messages_and_blindings(rng, messages_and_blindings, params) {
                Ok(t) => t,
                Err(l) => {
                    return Err(KVACError::MessageCountIncompatibleWithMACParams(
                        l,
                        params.supported_message_count(),
                    ))
                }
            };

        let r1 = G::ScalarField::rand(rng);
        let mut r2 = G::ScalarField::rand(rng);
        while r2.is_zero() {
            r2 = G::ScalarField::rand(rng);
        }
        let r3 = r2.inverse().unwrap();

        let A_hat = mac.A * (r1 * r2);
        // B = (e+x) * A = g_0 + user_pk + \sum(g_vec_i*m_i) for all i in I
        let B = params.b(messages.iter().enumerate(), &user_public_key)?;
        let D = B * r2;

        let minus_e = -mac.e;
        let B_bar = D * r1 + A_hat * minus_e;
        Self::_init(
            rng,
            A_hat.into(),
            B_bar.into(),
            D.into(),
            r1,
            r3,
            minus_e,
            messages,
            indexed_blindings,
            params,
            user_public_key,
            hw_sig_type,
            None,
            verifier_pub_key,
        )
    }

    /// Initialize the protocol using token received in HOL mode.
    /// Pass the appropriate type in `hw_sig_type` which corresponds to the signature type generated by user's secure hardware