Coconut Proof allows empty blinding messages

benches/benches/ps_proof.rs

@@ -76,7 +76,7 @@ fn pok_sig_benchmark(c: &mut Criterion) {
         let sig = &sigs_range[i];
 
         let mut prove_group = c.benchmark_group(format!("Creating proof for Proof-of-knowledge of signature and corresponding multi-message of size {}", count));
-        for (_j, r_count) in k.iter().enumerate() {
+        for (j, r_count) in k.iter().enumerate() {
             prove_group.bench_with_input(
                 BenchmarkId::from_parameter(format!("Revealing {} messages", r_count)),
                 &r_count,
@@ -89,7 +89,7 @@ fn pok_sig_benchmark(c: &mut Criterion) {
                                     .iter()
                                     .enumerate()
                                     .merge_join_by(
-                                        revealed_indices[i].iter(),
+                                        revealed_indices[j].iter(),
                                         |(m_idx, _), reveal_idx| m_idx.cmp(reveal_idx),
                                     )
                                     .map(|either| match either {

coconut/src/proof/messages_pok/mod.rs

@@ -558,14 +558,23 @@ mod tests {
     #[test]
     fn empty_proof() {
         let mut rng = StdRng::seed_from_u64(0u64);
-        let (_sk, _pk, params, _messages) = test_setup::<Bls12_381, Blake2b512, _>(&mut rng, 1);
+        let (_, _, params, messages) = test_setup::<Bls12_381, Blake2b512, _>(&mut rng, 1);
         let h = G1::rand(&mut rng).into_affine();
 
-        assert_eq!(
-            MessagesPoKGenerator::init(&mut rng, &[], &params, &h),
-            Err(MessagesPoKError::MessageInputError(
-                MessageUnpackingError::NoMessagesProvided
-            ))
-        );
+        let pok = MessagesPoKGenerator::init(&mut rng, &[], &params, &h)
+            .unwrap();
+
+        let mut chal_bytes_prover = vec![];
+        pok.challenge_contribution(&mut chal_bytes_prover, &params, &h)
+            .unwrap();
+        let challenge_prover =
+            compute_random_oracle_challenge::<Fr, Blake2b512>(&chal_bytes_prover);
+
+        let proof = pok.clone().gen_proof(&challenge_prover).unwrap();
+        let indices = (0..messages.len()).rev();
+
+        assert!(proof
+            .verify(&challenge_prover, indices.clone(), &params, &h)
+            .is_ok());
     }
 }

coconut/src/proof/mod.rs

@@ -178,7 +178,7 @@ impl<'pair, Pair, F: PrimeField> UnpackedBlindedMessages<'pair, Pair, F> {
         let (paired, (msgs, blindings)): (Vec<_>, _) =
             process_results(paired, |iter| iter.unzip())?;
         if paired.is_empty() {
-            Err(MessageUnpackingError::NoMessagesProvided)
+            Ok(Self(paired, msgs, blindings))
         } else if pair_with.len() != total_count {
             Err(MessageUnpackingError::LessMessagesThanExpected {
                 provided: total_count,

coconut/src/proof/signature_pok/mod.rs

@@ -347,12 +347,20 @@ mod tests {
 
         let sig = Signature::new(&mut rng, messages.as_slice(), &sk, &params).unwrap();
 
-        assert_eq!(
-            SignaturePoKGenerator::init(&mut rng, &[], &sig, &pk, &params),
-            Err(SignaturePoKError::MessageInputError(
-                MessageUnpackingError::NoMessagesProvided
-            ))
-        );
+        let pok = SignaturePoKGenerator::init(&mut rng, &[], &sig, &pk, &params).unwrap();
+
+        let mut chal_bytes_prover = vec![];
+        pok.challenge_contribution(&mut chal_bytes_prover, &pk, &params)
+            .unwrap();
+        let challenge_prover =
+            compute_random_oracle_challenge::<Fr, Blake2b512>(&chal_bytes_prover);
+
+        let proof = pok.clone().gen_proof(&challenge_prover).unwrap();
+        let revealed = messages.iter().enumerate().into_iter().rev();
+
+        assert!(proof
+            .verify(&challenge_prover, revealed.clone(), &pk, &params)
+            .is_ok());
     }
 
     #[test]