Remove commented code

2021-11-03 16:04:22 +00:00
parent c1df8eef62
commit aa2410c99b
2 changed files with 40 additions and 67 deletions
@@ -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<D, I, B>(iter: I) -> Scalar
-where
-    D: Digest,
-    I: Iterator<Item = B>,
-    B: AsRef<[u8]>,
+    where
+        D: Digest,
+        I: Iterator<Item=B>,
+        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<S>(witnesses: &[Scalar], challenge: &Scalar, secrets: &[S]) -> Vec<Scalar>
-where
-    S: Borrow<Scalar>,
+    where
+        S: Borrow<Scalar>,
 {
    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::<G1Projective>();
+            .iter()
+            .zip(params.gen_hs().iter())
+            .map(|(wm_i, hs_i)| hs_i * wm_i)
+            .sum::<G1Projective>();

        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::<Vec<_>>();
+            .map(|(c2, res_key, res_attr)| c2 * self.challenge + pub_key * res_key + h * res_attr)
+            .map(|witness| witness.to_bytes())
+            .collect::<Vec<_>>();

        // 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::<G1Projective>();
+            .response_attributes
+            .iter()
+            .zip(params.gen_hs().iter())
+            .map(|(res_attr, hs)| hs * res_attr)
+            .sum::<G1Projective>();

        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::<G2Projective>();
+            .iter()
+            .zip(verification_key.beta.iter())
+            .map(|(wm_i, beta_i)| beta_i * wm_i)
+            .sum::<G2Projective>();

        // 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::<G2Projective>();
+            .iter()
+            .zip(verification_key.beta.iter())
+            .map(|(priv_attr, beta_i)| beta_i * priv_attr)
+            .sum::<G2Projective>();

        // 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(
@@ -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::<G2Projective>()
+        .iter()
+        .zip(verification_key.beta.iter())
+        .map(|(priv_attr, beta_i)| beta_i * priv_attr)
+        .sum::<G2Projective>()
 }

 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::<G2Projective>())
-    .to_affine();
+        .iter()
+        .zip(verification_key.beta.iter())
+        .map(|(m_i, b_i)| b_i * m_i)
+        .sum::<G2Projective>())
+        .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);
    }
 }