add verifyBlankBallot java ffi (#61)

cyjseagull · web-flow · commit cdd6add0be21 · 2022-07-23T15:41:59.000+08:00
* add verifyBlankBallot java ffi

* store proof with binary data
diff --git a/bounty/Cargo.toml b/bounty/Cargo.toml
@@ -14,7 +14,7 @@ rand = "0.3.17"
 sha3 = "0.8"
 wedpr_l_crypto_zkp_discrete_logarithm_proof = {version = "1.3.0", git = "https://github.com/WeBankBlockchain/WeDPR-Lab-Crypto", branch = "dev-1.3.0"}
 wedpr_l_crypto_zkp_range_proof = "1.2.0"
-wedpr_l_crypto_zkp_utils = "1.0.0"
+wedpr_l_crypto_zkp_utils ={version = "1.3.0", git = "https://github.com/WeBankBlockchain/WeDPR-Lab-Crypto", branch = "dev-1.3.0"}
 wedpr_l_macros = "1.0.0"
 wedpr_l_utils = "1.0.0"
 wedpr_s_protos = { path = "../protos" }
diff --git a/ffi/ffi_java/ffi_java_acv/src/verifier.rs b/ffi/ffi_java/ffi_java_acv/src/verifier.rs
@@ -19,8 +19,8 @@ use wedpr_l_crypto_zkp_utils::bytes_to_point;
 use wedpr_s_anonymous_ciphertext_voting;
 
 use wedpr_s_protos::generated::acv::{
-    DecryptedResultPartStorage, PollParametersStorage, VoteRequest,
-    VoteResultStorage, VoteStorage,
+    DecryptedResultPartStorage, PollParametersStorage, RegistrationRequest,
+    RegistrationResponse, VoteRequest, VoteResultStorage, VoteStorage,
 };
 
 // Java FFI: Java interfaces will be generated under
@@ -366,3 +366,46 @@ pub extern "system" fn Java_com_webank_wedpr_acv_NativeInterface_verifyVoteResul
     );
     result_jobject.into_inner()
 }
+
+// Java interface section.
+// All functions are under class name 'com.webank.wedpr.acv.NativeInterface'.
+/// Java interface for
+/// 'com.webank.wedpr.acv.NativeInterface->verifyBlankBallot'.
+#[no_mangle]
+pub extern "system" fn Java_com_webank_wedpr_acv_NativeInterface_verifyBlankBallot(
+    _env: JNIEnv,
+    _class: JClass,
+    registration_request: JString,
+    registration_response: JString,
+) -> jobject {
+    let result_jobject = get_result_jobject(&_env);
+    let pb_registration_request = java_safe_jstring_to_pb!(
+        _env,
+        result_jobject,
+        registration_request,
+        RegistrationRequest
+    );
+    let pb_registration_response = java_safe_jstring_to_pb!(
+        _env,
+        result_jobject,
+        registration_response,
+        RegistrationResponse
+    );
+    let result =
+        match wedpr_s_anonymous_ciphertext_voting::voter::verify_blank_ballot(
+            &pb_registration_request,
+            &pb_registration_response,
+        ) {
+            Ok(v) => v,
+            Err(e) => {
+                return java_set_error_field_and_extract_jobject(
+                    &_env,
+                    &result_jobject,
+                    &format!("verifyBlankBallot failed, err = {:?}", e),
+                )
+            },
+        };
+    // write verify_result
+    java_safe_set_boolean_field!(_env, result_jobject, result, "verifyResult");
+    result_jobject.into_inner()
+}
diff --git a/protos/src/lib.rs b/protos/src/lib.rs
@@ -5,10 +5,7 @@
 extern crate lazy_static;
 use crate::{
     config::{HASH, SIGNATURE},
-    generated::{
-        acv::Ballot,
-        zkp::{PBBalanceProof, PBEqualityProof},
-    },
+    generated::{acv::Ballot, zkp::PBBalanceProof},
 };
 use wedpr_l_utils::{
     error::WedprError,
@@ -20,7 +17,7 @@ pub mod generated;
 use protobuf::Message;
 use wedpr_l_crypto_zkp_utils::{
     bytes_to_point, bytes_to_scalar, point_to_bytes, scalar_to_bytes,
-    ArithmeticProof, BalanceProof, EqualityProof, FormatProof, KnowledgeProof,
+    ArithmeticProof,
 };
 
 pub fn proto_to_bytes<T: Message>(proto: &T) -> Result<Vec<u8>, WedprError> {
@@ -37,80 +34,6 @@ pub fn bytes_to_proto<T: Message>(proto_bytes: &[u8]) -> Result<T, WedprError> {
     };
 }
 
-/// from struct BalanceProof to PBBalanceProof
-pub fn balance_proof_to_pb(balance_proof: &BalanceProof) -> PBBalanceProof {
-    let mut pb_proof = PBBalanceProof::new();
-    pb_proof.set_check1(scalar_to_bytes(&balance_proof.check1));
-    pb_proof.set_check2(scalar_to_bytes(&balance_proof.check2));
-    pb_proof.set_m1(scalar_to_bytes(&balance_proof.m1));
-    pb_proof.set_m2(scalar_to_bytes(&balance_proof.m2));
-    pb_proof.set_m3(scalar_to_bytes(&balance_proof.m3));
-    pb_proof.set_m4(scalar_to_bytes(&balance_proof.m4));
-    pb_proof.set_m5(scalar_to_bytes(&balance_proof.m5));
-    pb_proof.set_m6(scalar_to_bytes(&balance_proof.m6));
-    pb_proof
-}
-
-// from PBBalanceProof to struct BalanceProof
-pub fn pb_to_balance_proof(
-    balance_proof: &PBBalanceProof,
-) -> Result<BalanceProof, WedprError> {
-    Ok(BalanceProof {
-        check1: bytes_to_scalar(balance_proof.get_check1())?,
-        check2: bytes_to_scalar(balance_proof.get_check2())?,
-        m1: bytes_to_scalar(balance_proof.get_m1())?,
-        m2: bytes_to_scalar(balance_proof.get_m2())?,
-        m3: bytes_to_scalar(balance_proof.get_m3())?,
-        m4: bytes_to_scalar(balance_proof.get_m4())?,
-        m5: bytes_to_scalar(balance_proof.get_m5())?,
-        m6: bytes_to_scalar(balance_proof.get_m6())?,
-    })
-}
-
-// from struct KnowledgeProof to PBBalanceProof
-pub fn knowledge_proof_to_pb(
-    knowledge_proof: &KnowledgeProof,
-) -> PBBalanceProof {
-    let mut pb_proof = PBBalanceProof::new();
-    pb_proof.set_t1(point_to_bytes(&knowledge_proof.t1));
-    pb_proof.set_m1(scalar_to_bytes(&knowledge_proof.m1));
-    pb_proof.set_m2(scalar_to_bytes(&knowledge_proof.m2));
-    pb_proof
-}
-
-// from PBBalanceProof to struct KnowledgeProof
-pub fn pb_to_knowledge_proof(
-    knowledge_proof: &PBBalanceProof,
-) -> Result<KnowledgeProof, WedprError> {
-    Ok(KnowledgeProof {
-        t1: bytes_to_point(&knowledge_proof.get_t1())?,
-        m1: bytes_to_scalar(&knowledge_proof.get_m1())?,
-        m2: bytes_to_scalar(&knowledge_proof.get_m2())?,
-    })
-}
-
-// from struct FormatProof to PBBalanceProof
-pub fn format_proof_to_pb(format_proof: &FormatProof) -> PBBalanceProof {
-    let mut pb_proof = PBBalanceProof::new();
-    pb_proof.set_t1(point_to_bytes(&format_proof.t1));
-    pb_proof.set_t2(point_to_bytes(&format_proof.t2));
-    pb_proof.set_m1(scalar_to_bytes(&format_proof.m1));
-    pb_proof.set_m2(scalar_to_bytes(&format_proof.m2));
-    pb_proof
-}
-
-// from PBBalanceProof to struct FormatProof
-pub fn pb_to_format_proof(
-    format_proof: &PBBalanceProof,
-) -> Result<FormatProof, WedprError> {
-    Ok(FormatProof {
-        t1: bytes_to_point(&format_proof.get_t1())?,
-        t2: bytes_to_point(&format_proof.get_t2())?,
-        m1: bytes_to_scalar(&format_proof.get_m1())?,
-        m2: bytes_to_scalar(&format_proof.get_m2())?,
-    })
-}
-
 // from struct ArithmeticProof to PBBalanceProof
 pub fn arithmetric_proof_to_pb(
     arithmetric_proof: &ArithmeticProof,
@@ -143,26 +66,6 @@ pub fn pb_to_arithmetric_proof(
     })
 }
 
-// from struct EqualityProof to PBEqualityProof
-pub fn equality_proof_to_pb(equality_proof: &EqualityProof) -> PBEqualityProof {
-    let mut pb_proof = PBEqualityProof::new();
-    pb_proof.set_t1(point_to_bytes(&equality_proof.t1));
-    pb_proof.set_t2(point_to_bytes(&equality_proof.t2));
-    pb_proof.set_m1(scalar_to_bytes(&equality_proof.m1));
-    pb_proof
-}
-
-// from PBEqualityProof to struct EqualityProof
-pub fn pb_to_equality_proof(
-    equality_proof: &PBEqualityProof,
-) -> Result<EqualityProof, WedprError> {
-    Ok(EqualityProof {
-        t1: bytes_to_point(&equality_proof.get_t1())?,
-        t2: bytes_to_point(&equality_proof.get_t2())?,
-        m1: bytes_to_scalar(&equality_proof.get_m1())?,
-    })
-}
-
 // generate signature for the ballot
 pub fn generate_ballot_signature(
     secret_key: &[u8],
diff --git a/solution/anonymous_ciphertext_voting/src/counter.rs b/solution/anonymous_ciphertext_voting/src/counter.rs
@@ -5,21 +5,16 @@
 use wedpr_l_crypto_zkp_discrete_logarithm_proof::prove_equality_relationship_proof;
 use wedpr_l_crypto_zkp_utils::{
     bytes_to_point, bytes_to_scalar, get_random_scalar, point_to_bytes,
-    scalar_to_bytes, BASEPOINT_G2,
+    scalar_to_bytes, Serialize, BASEPOINT_G2,
 };
 use wedpr_l_utils::error::WedprError;
 
-use wedpr_s_protos::{
-    generated::acv::{
-        CounterParametersShareRequest, CounterSecret, CountingPart,
-        DecryptedResultPartStorage, StringToCountingPartPair,
-        UnlistedBallotDecryptedResult, VoteStorage,
-    },
-    proto_to_bytes,
+use wedpr_s_protos::generated::acv::{
+    CounterParametersShareRequest, CounterSecret, CountingPart,
+    DecryptedResultPartStorage, StringToCountingPartPair,
+    UnlistedBallotDecryptedResult, VoteStorage,
 };
 
-use wedpr_s_protos::equality_proof_to_pb;
-
 /// Makes secrets used by a counter.
 pub fn make_counter_secret() -> CounterSecret {
     let secret_share = get_random_scalar();
@@ -71,9 +66,7 @@ pub fn count(
             &BASEPOINT_G2,
             &candidate_part_share,
         );
-        counting_part.set_equality_proof(proto_to_bytes(
-            &(equality_proof_to_pb(&equality_proof)),
-        )?);
+        counting_part.set_equality_proof(equality_proof.serialize());
         // Write back.
         let candidate = candidate_ballot_pair.get_candidate();
         let mut candidate_counting_part_pair = StringToCountingPartPair::new();
@@ -97,9 +90,7 @@ pub fn count(
 
     // Write back.
     let blank_part = partially_decrypted_result.mut_blank_part();
-    blank_part.set_equality_proof(proto_to_bytes(&equality_proof_to_pb(
-        &equality_proof,
-    ))?);
+    blank_part.set_equality_proof(equality_proof.serialize());
     blank_part.set_blinding_c2(point_to_bytes(&blinding_c2));
     blank_part.set_counter_id(counter_id.to_string());
     Ok(partially_decrypted_result)
@@ -130,9 +121,8 @@ pub fn count_unlisted(
         decrypted_unlisted_candidate.set_blinding_c2(point_to_bytes(
             &(unlisted_candidate_part_share * secret_share),
         ));
-        decrypted_unlisted_candidate.set_equality_proof(proto_to_bytes(
-            &equality_proof_to_pb(&equality_proof),
-        )?);
+        decrypted_unlisted_candidate
+            .set_equality_proof(equality_proof.serialize());
 
         // decrypt and generaate the equality proof for unlisted candidate
         // ballot
@@ -148,9 +138,8 @@ pub fn count_unlisted(
         decrypted_ulisted_candidate_ballot.set_blinding_c2(point_to_bytes(
             &(unlisted_candidate_ballot_part_share * secret_share),
         ));
-        decrypted_ulisted_candidate_ballot.set_equality_proof(proto_to_bytes(
-            &equality_proof_to_pb(&equality_proof),
-        )?);
+        decrypted_ulisted_candidate_ballot
+            .set_equality_proof(equality_proof.serialize());
 
         let mut unlisted_candidate_part_item =
             UnlistedBallotDecryptedResult::new();
diff --git a/solution/anonymous_ciphertext_voting/src/lib.rs b/solution/anonymous_ciphertext_voting/src/lib.rs
@@ -46,7 +46,6 @@ mod tests {
                 .push(counter_parameters_share);
             counter_secret_list.push(counter_secret);
         }
-
         // Initialize the coordinator.
         let (public_key, secret_key) = SIGNATURE.generate_keypair();
 
@@ -60,7 +59,6 @@ mod tests {
             &counter_parameters,
         )
         .unwrap();
-
         // Initialize all voters.
         let mut voter_secret_list: Vec<VoterSecret> = vec![];
         let mut voter_registration_list = vec![];
@@ -121,7 +119,6 @@ mod tests {
                 &public_key
             )
             .unwrap());
-
             // Coordinator aggregates individual ciphertext ballots.
             assert!(coordinator::aggregate_vote_sum_response(
                 &poll_parameters,
@@ -131,7 +128,6 @@ mod tests {
             .unwrap());
             vote_request_list.push(vote_request);
         }
-
         // All counters decrypt the poll result in a distributed manner.
         let mut aggregated_decrypted_result = DecryptedResultPartStorage::new();
         for index in 0..counter_secret_list.len() {
@@ -153,7 +149,6 @@ mod tests {
                 &partially_decrypted_result
             )
             .unwrap());
-
             // Coordinator aggregates parts of decrypted poll result.
             assert!(coordinator::aggregate_decrypted_part_sum(
                 &poll_parameters,
@@ -162,7 +157,6 @@ mod tests {
             )
             .unwrap());
         }
-
         // Coordinator decrypts the final poll result by enumerating all
         // possible value and checking ZKP data.
         // TODO: Design a better way to do the decryption.
@@ -298,6 +292,20 @@ mod tests {
         )
         .unwrap();
 
+        // verify blank ballot
+        let result =
+            voter::verify_blank_ballot(&registration_request1, &response1)
+                .unwrap();
+        assert_eq!(result, true);
+        let result =
+            voter::verify_blank_ballot(&registration_request2, &response2)
+                .unwrap();
+        assert_eq!(result, true);
+        let result =
+            voter::verify_blank_ballot(&registration_request3, &response3)
+                .unwrap();
+        assert_eq!(result, true);
+
         // begin vote
         let mut encrypted_vote_sum = VoteStorage::new();
         let make_choice = |x: &Vec<i32>| {
@@ -614,7 +622,19 @@ mod tests {
             blank_ballot_count[2],
         )
         .unwrap();
-
+        // verify blank ballot
+        let result =
+            voter::verify_blank_ballot(&registration_request1, &response1)
+                .unwrap();
+        assert_eq!(result, true);
+        let result =
+            voter::verify_blank_ballot(&registration_request2, &response2)
+                .unwrap();
+        assert_eq!(result, true);
+        let result =
+            voter::verify_blank_ballot(&registration_request3, &response3)
+                .unwrap();
+        assert_eq!(result, true);
         let mut encrypted_vote_sum = VoteStorage::new();
 
         let make_choice = |x: &Vec<i32>, y: &Vec<i64>| {
diff --git a/solution/anonymous_ciphertext_voting/src/verifier.rs b/solution/anonymous_ciphertext_voting/src/verifier.rs
diff --git a/solution/anonymous_ciphertext_voting/src/voter.rs b/solution/anonymous_ciphertext_voting/src/voter.rs
