refacor: fix failing test

Author: BasileiosKal

src/schemes/bbs/core/proof.rs

@@ -252,12 +252,8 @@ impl Proof {
         // cv_for_hash = encode_for_hash(cv_array)
         //  if cv_for_hash is INVALID, return INVALID
         //  cv = hash_to_scalar(cv_for_hash, 1)
-        let cv = compute_challenge::<_, I>(
-            &init_res,
-            disclosed_messages,
-            ph,
-            None
-        )?;
+        let cv =
+            compute_challenge::<_, I>(&init_res, disclosed_messages, ph, None)?;
 
         // Check the selective disclosure proof
         // if c != cv, return INVALID

src/schemes/bbs/interface.rs

@@ -103,4 +103,9 @@ pub(crate) trait BbsInterfaceParameter: InterfaceParameter {
             [&Self::api_id(), DEFAULT_DST_SUFFIX_H2S.as_bytes()].concat();
         Self::Ciphersuite::hash_to_scalar(data_to_hash, &e_dst)
     }
+
+    // Hash to curve function, using the Interface's identifier as a dst
+    fn hash_to_curve(message: &[u8]) -> Result<G1Projective, Error> {
+        Self::Ciphersuite::hash_to_curve(message, &Self::api_id())
+    }
 }

src/schemes/pseudonym/api/proof.rs

@@ -47,18 +47,17 @@ where
 
     let verify_signature = request.verify_signature.unwrap_or(true);
     if verify_signature
-        && !(signature.verify::<_, _, _, I::Ciphersuite>(
+        && !(signature.verify::<_, _, _, I>(
             &pk,
             request.header.as_ref(),
             &generators,
             &digested_messages,
-            Some(I::api_id()),
         )?)
     {
         return Err(Error::SignatureVerification);
     };
 
-    let proof = ProofWithNym::new::<_, _, I::Ciphersuite>(
+    let proof = ProofWithNym::new::<_, _, I>(
         &pk,
         &signature,
         &pseudonym,
@@ -68,7 +67,6 @@ where
         request.presentation_header.as_ref(),
         &generators,
         &proof_messages,
-        Some(I::api_id()),
     )?;
 
     Ok(proof.to_octets())
@@ -97,14 +95,13 @@ where
     let generators =
         MemoryCachedGenerators::<I>::new(total_message_count, None)?;
 
-    proof.verify::<_, _, I::Ciphersuite>(
+    proof.verify::<_, _, I>(
         &pk,
         &pseudonym,
         &request.verifier_id,
         request.header.as_ref(),
         request.presentation_header.as_ref(),
         &generators,
         &messages,
-        Some(I::api_id()),
     )
 }

src/schemes/pseudonym/api/pseudonym.rs

@@ -14,11 +14,8 @@ where
     T: AsRef<[u8]>,
     I: BbsInterfaceParameter,
 {
-    let pseudonym = Pseudonym::new::<_, I>(
-        &request.verifier_id,
-        &request.prover_id,
-        Some(I::api_id()),
-    )?;
+    let pseudonym =
+        Pseudonym::new::<_, I>(&request.verifier_id, &request.prover_id)?;
 
     Ok(pseudonym.to_octets())
 }

src/schemes/pseudonym/api/signature.rs

@@ -30,13 +30,12 @@ where
 
     let generators = MemoryCachedGenerators::<I>::new(messages.len(), None)?;
 
-    Signature::new::<_, _, _, I::Ciphersuite>(
+    Signature::new::<_, _, _, I>(
         &sk,
         &pk,
         request.header.as_ref(),
         &generators,
         &messages,
-        Some(I::api_id()),
     )
     .map(|sig| sig.to_octets())
 }
@@ -57,11 +56,10 @@ where
     let generators = MemoryCachedGenerators::<I>::new(messages.len(), None)?;
     let signature = Signature::from_octets(request.signature)?;
 
-    signature.verify::<_, _, _, I::Ciphersuite>(
+    signature.verify::<_, _, _, I>(
         &pk,
         request.header.as_ref(),
         &generators,
         &messages,
-        Some(I::api_id()),
     )
 }

src/schemes/pseudonym/core/proof.rs

@@ -16,6 +16,7 @@ use crate::{
             types::{CommitProofInitResult, Message, ProofMessage},
             utils::compute_challenge,
         },
+        interface::BbsInterfaceParameter,
     },
     common::util::create_random_scalar,
     curves::bls12_381::{Bls12, G2Prepared},
@@ -37,7 +38,7 @@ impl core::fmt::Display for ProofWithNym {
 impl ProofWithNym {
     // TODO: remove the clippy warning de-activation
     #[allow(clippy::too_many_arguments)]
-    pub fn new<T, G, C>(
+    pub fn new<T, G, I>(
         PK: &PublicKey,
         signature: &Signature,
         pseudonym: &Pseudonym,
@@ -47,14 +48,13 @@ impl ProofWithNym {
         ph: Option<T>,
         generators: &G,
         messages: &[ProofMessage],
-        api_id: Option<Vec<u8>>,
     ) -> Result<Self, Error>
     where
         T: AsRef<[u8]>,
         G: Generators,
-        C: BbsCiphersuiteParameters,
+        I: BbsInterfaceParameter,
     {
-        Self::new_with_rng::<_, _, _, C>(
+        Self::new_with_rng::<_, _, _, I>(
             PK,
             signature,
             pseudonym,
@@ -64,14 +64,13 @@ impl ProofWithNym {
             ph,
             generators,
             messages,
-            api_id,
             OsRng,
         )
     }
 
     // TODO: remove the clippy warning de-activation
     #[allow(clippy::too_many_arguments)]
-    pub fn new_with_rng<T, R, G, C>(
+    pub fn new_with_rng<T, R, G, I>(
         PK: &PublicKey,
         signature: &Signature,
         pseudonym: &Pseudonym,
@@ -81,17 +80,14 @@ impl ProofWithNym {
         ph: Option<T>,
         generators: &G,
         messages: &[ProofMessage],
-        api_id: Option<Vec<u8>>,
         mut rng: R,
     ) -> Result<Self, Error>
     where
         T: AsRef<[u8]>,
         R: RngCore + CryptoRng,
         G: Generators,
-        C: BbsCiphersuiteParameters,
+        I: BbsInterfaceParameter,
     {
-        let api_id = api_id.unwrap_or([].to_vec());
-
         // (r1, r2, r3, m~_j1, ..., m~_jU) = calculate_random_scalars(3+U)
         let mut random_scalars = RandomScalars {
             r1: create_random_scalar(&mut rng)?,
@@ -134,19 +130,18 @@ impl ProofWithNym {
             }
         }
 
-        let init_result = Proof::proof_init::<T, G, C>(
+        let init_result = Proof::proof_init::<T, G, I>(
             PK,
             signature,
             generators,
             &random_scalars,
             header,
             message_scalars,
             undisclosed_indexes,
-            &api_id,
         )?;
 
         // Pseudonym correctness proof init
-        let OP = C::hash_to_curve(verifier_id.as_ref(), &api_id)?;
+        let OP = I::hash_to_curve(verifier_id.as_ref())?;
 
         let pid_tilde = random_scalars.m_tilde_scalars.last().unwrap();
         let pseudonym_proof_init = CommitProofInitResult {
@@ -156,11 +151,10 @@ impl ProofWithNym {
         };
 
         // challenge calculation
-        let challenge = compute_challenge::<_, C>(
+        let challenge = compute_challenge::<_, I>(
             &init_result,
             &disclosed_messages,
             ph,
-            api_id,
             Some(pseudonym_proof_init),
         )?;
 
@@ -181,7 +175,7 @@ impl ProofWithNym {
 
     // TODO: Remove this clippy warning de-activation
     #[allow(clippy::too_many_arguments)]
-    pub fn verify<T, G, C>(
+    pub fn verify<T, G, I>(
         &self,
         PK: &PublicKey,
         pseudonym: &Pseudonym,
@@ -190,12 +184,11 @@ impl ProofWithNym {
         ph: Option<T>,
         generators: &G,
         disclosed_messages: &BTreeMap<usize, Message>,
-        api_id: Option<Vec<u8>>,
     ) -> Result<bool, Error>
     where
         T: AsRef<[u8]>,
         G: Generators,
-        C: BbsCiphersuiteParameters,
+        I: BbsInterfaceParameter,
     {
         // if KeyValidate(PK) is INVALID, return INVALID
         // `PK` should not be an identity and should belong to subgroup G2
@@ -206,7 +199,7 @@ impl ProofWithNym {
         // the pseudonym should be a point of G1 but not any of the constant
         // "reserved" points (i.e., the identity of G1 or the base
         // generator and the base point of G1).
-        if pseudonym.is_valid::<C>().unwrap_u8() == 0u8 {
+        if pseudonym.is_valid::<I::Ciphersuite>().unwrap_u8() == 0u8 {
             return Err(Error::InvalidPseudonym);
         }
 
@@ -228,19 +221,16 @@ impl ProofWithNym {
             }
         }
 
-        let api_id = api_id.unwrap_or([].to_vec());
-
         // initialize the proof verification procedure
-        let init_res = self.0.proof_verify_init::<T, G, C>(
+        let init_res = self.0.proof_verify_init::<T, G, I>(
             PK,
             header,
             generators,
             disclosed_messages,
-            &api_id,
         )?;
 
         // initialize the pseudonym correctness proof verification procedure
-        let OP = C::hash_to_curve(verifier_id.as_ref(), &api_id)?;
+        let OP = I::hash_to_curve(verifier_id.as_ref())?;
         let pseudonym_point = pseudonym.as_point();
         let proof_challenge = self.0.c;
 
@@ -256,11 +246,10 @@ impl ProofWithNym {
             blind_commit: Uv,
         };
 
-        let challenge = compute_challenge::<_, C>(
+        let challenge = compute_challenge::<_, I>(
             &init_res,
             disclosed_messages,
             ph,
-            api_id,
             Some(pseudonym_proof_verify_init),
         )?;
 
@@ -279,7 +268,7 @@ impl ProofWithNym {
         // Check the signature proof
         // if e(Abar, W) * e(Abar, -P2) != 1, return INVALID
         // else return VALID
-        let P2 = C::p2().to_affine();
+        let P2 = I::Ciphersuite::p2().to_affine();
         Ok(Bls12::multi_miller_loop(&[
             (
                 &self.0.A_bar.to_affine(),

src/schemes/pseudonym/core/pseudonym.rs

@@ -19,11 +19,7 @@ pub(crate) struct Pseudonym(G1Projective);
 
 // TODO: Use ct to check equalities bellow
 impl Pseudonym {
-    pub fn new<T, I>(
-        verifier_id: &T,
-        prover_id: &T,
-        api_id: Option<Vec<u8>>,
-    ) -> Result<Self, Error>
+    pub fn new<T, I>(verifier_id: &T, prover_id: &T) -> Result<Self, Error>
     where
         T: AsRef<[u8]>,
         I: BbsInterfaceParameter,
@@ -40,8 +36,7 @@ impl Pseudonym {
             });
         }
 
-        let api_id = api_id.as_ref().map_or(&[] as &[u8], |v| v.as_ref());
-        let OP = I::Ciphersuite::hash_to_curve(verifier_id, api_id)?;
+        let OP = I::hash_to_curve(verifier_id)?;
 
         // Check that OP is not the identity, the base point of G1 or P1.
         if OP.is_identity().unwrap_u8() == 1u8