From aa2410c99bc048f40eb7564620c91d88f56e1e4e Mon Sep 17 00:00:00 2001 From: aniampio Date: Wed, 3 Nov 2021 16:04:22 +0000 Subject: [PATCH] Remove commented code --- common/nymcoconut/src/proofs/mod.rs | 67 ++++++++------------ common/nymcoconut/src/scheme/verification.rs | 40 ++++-------- 2 files changed, 40 insertions(+), 67 deletions(-) diff --git a/common/nymcoconut/src/proofs/mod.rs b/common/nymcoconut/src/proofs/mod.rs index 4cda0f988b..ae6d915c9e 100644 --- a/common/nymcoconut/src/proofs/mod.rs +++ b/common/nymcoconut/src/proofs/mod.rs @@ -18,18 +18,18 @@ use std::borrow::Borrow; use std::convert::TryInto; use bls12_381::{G1Projective, G2Projective, Scalar}; -use digest::generic_array::typenum::Unsigned; use digest::Digest; +use digest::generic_array::typenum::Unsigned; use group::GroupEncoding; use itertools::izip; use sha2::Sha256; +use crate::{Attribute, elgamal, ElGamalKeyPair}; use crate::elgamal::Ciphertext; use crate::error::{CoconutError, Result}; use crate::scheme::setup::Parameters; use crate::scheme::VerificationKey; use crate::utils::{hash_g1, try_deserialize_scalar, try_deserialize_scalar_vec}; -use crate::{elgamal, Attribute, ElGamalKeyPair}; // as per the reference python implementation type ChallengeDigest = Sha256; @@ -51,10 +51,10 @@ pub struct ProofCmCs { // and as per the bls12-381 library all elements are using big-endian form /// Generates a Scalar [or Fp] challenge by hashing a number of elliptic curve points. fn compute_challenge(iter: I) -> Scalar -where - D: Digest, - I: Iterator, - B: AsRef<[u8]>, + where + D: Digest, + I: Iterator, + B: AsRef<[u8]>, { let mut h = D::new(); for point_representation in iter { @@ -82,8 +82,8 @@ fn produce_response(witness: &Scalar, challenge: &Scalar, secret: &Scalar) -> Sc // note: it's caller's responsibility to ensure witnesses.len() = secrets.len() fn produce_responses(witnesses: &[Scalar], challenge: &Scalar, secrets: &[S]) -> Vec -where - S: Borrow, + where + S: Borrow, { debug_assert_eq!(witnesses.len(), secrets.len()); @@ -150,10 +150,10 @@ impl ProofCmCs { // Ccm = (wr * g1) + (wm[0] * hs[0]) + ... + (wm[i] * hs[i]) let commitment_attributes = g1 * witness_commitment_opening + witness_attributes - .iter() - .zip(params.gen_hs().iter()) - .map(|(wm_i, hs_i)| hs_i * wm_i) - .sum::(); + .iter() + .zip(params.gen_hs().iter()) + .map(|(wm_i, hs_i)| hs_i * wm_i) + .sum::(); let ciphertexts_bytes = priv_attributes_ciphertexts .iter() @@ -244,19 +244,19 @@ impl ProofCmCs { self.response_keys.iter(), self.response_attributes.iter() ) - .map(|(c2, res_key, res_attr)| c2 * self.challenge + pub_key * res_key + h * res_attr) - .map(|witness| witness.to_bytes()) - .collect::>(); + .map(|(c2, res_key, res_attr)| c2 * self.challenge + pub_key * res_key + h * res_attr) + .map(|witness| witness.to_bytes()) + .collect::>(); // Cw = (cm * c) + (rr * g1) + (rm[0] * hs[0]) + ... + (rm[n] * hs[n]) let commitment_attributes = commitment * self.challenge + g1 * self.response_opening + self - .response_attributes - .iter() - .zip(params.gen_hs().iter()) - .map(|(res_attr, hs)| hs * res_attr) - .sum::(); + .response_attributes + .iter() + .zip(params.gen_hs().iter()) + .map(|(res_attr, hs)| hs * res_attr) + .sum::(); let ciphertexts_bytes = attributes_ciphertexts .iter() @@ -413,10 +413,10 @@ impl ProofKappaNu { let commitment_kappa = params.gen2() * witness_blinder + verification_key.alpha + witness_attributes - .iter() - .zip(verification_key.beta.iter()) - .map(|(wm_i, beta_i)| beta_i * wm_i) - .sum::(); + .iter() + .zip(verification_key.beta.iter()) + .map(|(wm_i, beta_i)| beta_i * wm_i) + .sum::(); // zeta is the public value associated with the serial number let commitment_zeta = params.gen2() * witness_serial_number; @@ -470,10 +470,10 @@ impl ProofKappaNu { + params.gen2() * self.response_blinder + verification_key.alpha * (Scalar::one() - self.challenge) + response_attributes - .iter() - .zip(verification_key.beta.iter()) - .map(|(priv_attr, beta_i)| beta_i * priv_attr) - .sum::(); + .iter() + .zip(verification_key.beta.iter()) + .map(|(priv_attr, beta_i)| beta_i * priv_attr) + .sum::(); // zeta is the public value associated with the serial number let commitment_zeta = zeta * self.challenge + params.gen2() * self.response_serial_number; @@ -502,11 +502,6 @@ impl ProofKappaNu { bytes.extend_from_slice(&self.response_serial_number.to_bytes()); bytes.extend_from_slice(&self.response_binding_number.to_bytes()); - // bytes.extend_from_slice(&attributes_len.to_le_bytes()); - // for rm in &self.response_attributes { - // bytes.extend_from_slice(&rm.to_bytes()); - // } - bytes.extend_from_slice(&self.response_blinder.to_bytes()); bytes @@ -550,12 +545,6 @@ impl ProofKappaNu { binding_number_bytes, CoconutError::Deserialization("failed to deserialize the binding number".to_string()), )?; - // let rm_end = 40 + rm_len as usize * 32; - // let response_attributes = try_deserialize_scalar_vec( - // rm_len, - // &bytes[40..rm_end], - // CoconutError::Deserialization("Failed to deserialize attributes response".to_string()), - // )?; let blinder_bytes = bytes[96..].try_into().unwrap(); let response_blinder = try_deserialize_scalar( diff --git a/common/nymcoconut/src/scheme/verification.rs b/common/nymcoconut/src/scheme/verification.rs index 6cac4e3216..4300f87362 100644 --- a/common/nymcoconut/src/scheme/verification.rs +++ b/common/nymcoconut/src/scheme/verification.rs @@ -16,9 +16,10 @@ use core::ops::Neg; use std::convert::TryFrom; use std::convert::TryInto; -use bls12_381::{multi_miller_loop, G1Affine, G2Prepared, G2Projective, Scalar}; +use bls12_381::{G1Affine, G2Prepared, G2Projective, multi_miller_loop, Scalar}; use group::{Curve, Group}; +use crate::Attribute; use crate::error::{CoconutError, Result}; use crate::proofs::ProofKappaNu; use crate::scheme::setup::Parameters; @@ -26,7 +27,6 @@ use crate::scheme::Signature; use crate::scheme::VerificationKey; use crate::traits::{Base58, Bytable}; use crate::utils::try_deserialize_g2_projective; -use crate::Attribute; // TODO NAMING: this whole thing // Theta @@ -133,10 +133,10 @@ pub fn compute_kappa( params.gen2() * blinding_factor + verification_key.alpha + private_attributes - .iter() - .zip(verification_key.beta.iter()) - .map(|(priv_attr, beta_i)| beta_i * priv_attr) - .sum::() + .iter() + .zip(verification_key.beta.iter()) + .map(|(priv_attr, beta_i)| beta_i * priv_attr) + .sum::() } pub fn compute_zeta(params: &Parameters, serial_number: Attribute) -> G2Projective { @@ -258,11 +258,11 @@ pub fn verify( ) -> bool { let kappa = (verification_key.alpha + public_attributes - .iter() - .zip(verification_key.beta.iter()) - .map(|(m_i, b_i)| b_i * m_i) - .sum::()) - .to_affine(); + .iter() + .zip(verification_key.beta.iter()) + .map(|(m_i, b_i)| b_i * m_i) + .sum::()) + .to_affine(); check_bilinear_pairing( &sig.0.to_affine(), @@ -298,25 +298,9 @@ mod tests { serial_number, binding_number, ) - .unwrap(); + .unwrap(); let bytes = theta.to_bytes(); assert_eq!(Theta::try_from(bytes.as_slice()).unwrap(), theta); - - // let mut params = setup(4).unwrap(); - // - // let keypair = keygen(&mut params); - // let private_attributes = params.n_random_scalars(2); - // - // let theta = prove_credential( - // &mut params, - // &keypair.verification_key(), - // &signature, - // &private_attributes, - // ) - // .unwrap(); - // - // let bytes = theta.to_bytes(); - // assert_eq!(Theta::try_from(bytes.as_slice()).unwrap(), theta); } }