add range proof

crypto/zkp/discrete_logarithm_proof/Cargo.toml

@@ -10,15 +10,15 @@ description = "Library of WeDPR shared zkp Function implement discrete logarithm
 
 [dependencies]
 hex = "0.4.2"
-curve25519-dalek = { version = "1.0", features = [ "serde" ] }
+curve25519-dalek = { version = "4.1", features = [ "serde" ] }
 wedpr_l_crypto_zkp_utils = {version = "1.3.0", path = "../utils/"}
 wedpr_l_macros = "1.0.0"
 wedpr_l_protos =  "1.2.0"
 wedpr_l_utils = "1.1.0"
-rand = "0.6"
+rand = "0.8.5"
 
 [dev-dependencies]
-criterion = "0.3"
+criterion = "0.5"
 
 [[bench]]
 name = "dlp"

crypto/zkp/discrete_logarithm_proof/benches/dlp.rs

@@ -168,7 +168,7 @@ fn create_point_mul_helper(c: &mut Criterion) {
 
 fn create_point_mul_1_helper(c: &mut Criterion) {
     let label = format!("create_point_mul_1_helper",);
-    let scalar_1 = Scalar::one();
+    let scalar_1 = Scalar::from(1u8);
     let value_basepoint = *BASEPOINT_G1;
     c.bench_function(&label, move |b| b.iter(|| scalar_1 * value_basepoint));
 }

crypto/zkp/discrete_logarithm_proof/src/lib.rs

@@ -279,8 +279,8 @@ pub fn verify_knowledge_proof_in_batch(
     }
     let mut t1_sum_expected: RistrettoPoint = Default::default();
     let mut c1_c_expected: RistrettoPoint = Default::default();
-    let mut m1_expected: Scalar = Scalar::zero();
-    let mut m2_expected: Scalar = Scalar::zero();
+    let mut m1_expected: Scalar = Scalar::from(0u8);
+    let mut m2_expected: Scalar = Scalar::from(0u8);
 
     for i in 0..c_point_list.len() {
         // 8 bit random scalar
@@ -418,8 +418,8 @@ pub fn verify_format_proof_in_batch(
     let mut t2_sum_expected: RistrettoPoint = Default::default();
     let mut c1_c_expected: RistrettoPoint = Default::default();
     let mut c2_c_expected: RistrettoPoint = Default::default();
-    let mut m1_expected: Scalar = Scalar::zero();
-    let mut m2_expected: Scalar = Scalar::zero();
+    let mut m1_expected: Scalar = Scalar::from(0u8);
+    let mut m2_expected: Scalar = Scalar::from(0u8);
 
     for i in 0..c1_point_list.len() {
         // 8 bit random scalar
@@ -606,11 +606,11 @@ pub fn verify_sum_relationship_in_batch(
     let mut c1_c_expected: RistrettoPoint = Default::default();
     let mut c2_c_expected: RistrettoPoint = Default::default();
     let mut c3_c_expected: RistrettoPoint = Default::default();
-    let mut m1_expected: Scalar = Scalar::zero();
-    let mut m2_expected: Scalar = Scalar::zero();
-    let mut m3_expected: Scalar = Scalar::zero();
-    let mut m4_expected: Scalar = Scalar::zero();
-    let mut m5_expected: Scalar = Scalar::zero();
+    let mut m1_expected: Scalar = Scalar::from(0u8);
+    let mut m2_expected: Scalar = Scalar::from(0u8);
+    let mut m3_expected: Scalar = Scalar::from(0u8);
+    let mut m4_expected: Scalar = Scalar::from(0u8);
+    let mut m5_expected: Scalar = Scalar::from(0u8);
     for i in 0..c1_point_list.len() {
         // 8 bit random scalar
         let random_scalar = get_random_u8();
@@ -832,12 +832,12 @@ pub fn verify_product_relationship_in_batch(
     let mut t3_c1_c_expected: RistrettoPoint = Default::default();
     let mut t3_c2_c_expected: RistrettoPoint = Default::default();
     let mut t3_c3_c_expected: RistrettoPoint = Default::default();
-    let mut m1_expected: Scalar = Scalar::zero();
-    let mut m1_m3_expected: Scalar = Scalar::zero();
-    let mut m2_expected: Scalar = Scalar::zero();
-    let mut m3_expected: Scalar = Scalar::zero();
-    let mut m4_expected: Scalar = Scalar::zero();
-    let mut m5_expected: Scalar = Scalar::zero();
+    let mut m1_expected: Scalar = Scalar::from(0u8);
+    let mut m1_m3_expected: Scalar = Scalar::from(0u8);
+    let mut m2_expected: Scalar = Scalar::from(0u8);
+    let mut m3_expected: Scalar = Scalar::from(0u8);
+    let mut m4_expected: Scalar = Scalar::from(0u8);
+    let mut m5_expected: Scalar = Scalar::from(0u8);
     for i in 0..c1_point_list.len() {
         // 8 bit random scalar
         let random_scalar = get_random_u8();
@@ -988,7 +988,7 @@ pub fn verify_equality_relationship_proof_in_batch(
     let mut t2_sum_expected: RistrettoPoint = Default::default();
     let mut c1_c_expected: RistrettoPoint = Default::default();
     let mut c2_c_expected: RistrettoPoint = Default::default();
-    let mut m1_expected: Scalar = Scalar::zero();
+    let mut m1_expected: Scalar = Scalar::from(0u8);
     for i in 0..c1_point_list.len() {
         // 8 bit random scalar
         let random_scalar = get_random_u8();
@@ -1071,7 +1071,7 @@ mod tests {
             &[c_basepoint, blinding_basepoint],
         );
         let c3_point =
-            RistrettoPoint::multiscalar_mul(&[Scalar::zero(), c3_blinding], &[
+            RistrettoPoint::multiscalar_mul(&[Scalar::from(0u8), c3_blinding], &[
                 c_basepoint,
                 blinding_basepoint,
             ]);

crypto/zkp/range_proof/Cargo.toml

@@ -9,9 +9,16 @@ description = "Library of WeDPR shared zkp Function implement range proof."
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bulletproofs = { package = "wedpr_l_bulletproofs", version = "1.0.5" }
-curve25519-dalek = { version = "1.0", features = [ "serde" ] }
-merlin = "1"
-wedpr_l_crypto_zkp_utils = "1.2.0"
+bulletproofs = { package = "bulletproofs", version = "5.0" }
+curve25519-dalek = { version = "4.1", features = [ "serde" ] }
+merlin = "3"
+wedpr_l_crypto_zkp_utils = {version = "1.3.0", path = "../utils/"}
 wedpr_l_macros = "1.0.0"
 wedpr_l_utils = "1.1.0"
+
+[dev-dependencies]
+criterion = "0.5"
+
+[[bench]]
+name = "proof"
+harness = false

crypto/zkp/range_proof/benches/proof.rs

@@ -0,0 +1,32 @@
+// Copyright 2021 WeDPR Lab Project Authors. Licensed under Apache-2.0.
+
+#[macro_use]
+extern crate criterion;
+use criterion::Criterion;
+
+use curve25519_dalek::{
+    ristretto::RistrettoPoint, scalar::Scalar, traits::MultiscalarMul,
+};
+use wedpr_l_crypto_zkp_range_proof::{
+    self, prove_value_range, verify_value_range,
+};
+
+fn create_verify_range_proof_helper(c: &mut Criterion) {
+    let label = format!("create_verify_range_proof_helper");
+    let (proof_c1, c1_point, _) = prove_value_range(32u64);
+    c.bench_function(&label, move |b| {
+        b.iter(|| {
+            assert_eq!(true, verify_value_range(&c1_point, &proof_c1));
+        })
+    });
+}
+
+criterion_group! {
+    name = init_proof_test;
+    config = Criterion::default().sample_size(10);
+targets =
+create_verify_range_proof_helper,
+
+}
+
+criterion_main!(init_proof_test);

crypto/zkp/utils/Cargo.toml

@@ -10,11 +10,13 @@ description = "Library of WeDPR shared zkp function utils."
 
 [dependencies]
 serde = { version = "1.0", features = ["derive"] }
-curve25519-dalek = { version = "1.0", features = [ "serde" ] }
+curve25519-dalek = { version = "4.1", features = [ "serde", "digest", "rand_core" ] }
 lazy_static = "1.4.0"
-rand = "0.6"
-rand_core = { version = "0.5", features = ["getrandom"] }
-sha3 = "0.8"
+rand = "0.8.5"
+sha3 = "0.10"
 wedpr_l_crypto_hash_keccak256 = "1.1.0"
 wedpr_l_macros = "1.0.0"
 wedpr_l_utils = "1.1.0"
+
+[patch.crates-io]
+zerocopy = { version = "=0.7.35" }

crypto/zkp/utils/src/lib.rs

@@ -379,7 +379,7 @@ fn to_bytes32_slice(barry: &[u8]) -> Result<&[u8; 32], WedprError> {
 /// Converts a vector to Scalar.
 pub fn bytes_to_scalar(input: &[u8]) -> Result<Scalar, WedprError> {
     let get_num_u8 = to_bytes32_slice(&input)?;
-    let scalar_num = Scalar::from_bits(*get_num_u8);
+    let scalar_num = Scalar::from_bytes_mod_order(*get_num_u8);
     Ok(scalar_num)
 }
 
@@ -399,7 +399,17 @@ pub fn bytes_to_point(point: &[u8]) -> Result<RistrettoPoint, WedprError> {
         wedpr_println!("bytes_to_point decode failed");
         return Err(WedprError::FormatError);
     }
-    let point_value = match CompressedRistretto::from_slice(&point).decompress()
+    let point_value_result = match CompressedRistretto::from_slice(&point)
+    {
+        Ok(v) => v,
+        Err(_e) => {
+            wedpr_println!(
+                "bytes_to_point decompress CompressedRistretto failed"
+            );
+            return Err(WedprError::FormatError);
+        },
+    };
+    let point_value = match point_value_result.decompress()
     {
         Some(v) => v,
         None => {

ffi/ffi_c/ffi_c_zkp/Cargo.toml

@@ -6,20 +6,21 @@ edition = "2018"
 
 [features]
 default = ["wedpr_f_zkp_proof"]
-wedpr_f_zkp_proof = ["wedpr_l_crypto_zkp_discrete_logarithm_proof"]
+wedpr_f_zkp_proof = ["wedpr_l_crypto_zkp_discrete_logarithm_proof", "wedpr_l_crypto_zkp_range_proof"]
 
 [lib]
 name = "ffi_c_zkp"
 crate-type = [ "cdylib", "staticlib" ]
 
 [dependencies]
-curve25519-dalek = { version = "1.0", features = [ "serde" ] }
+curve25519-dalek = { version = "4.1", features = [ "serde" ] }
 libc = "0.2.60"
 wedpr_l_utils = "1.1.0"
 wedpr_ffi_common = { path = "../../ffi_common" }
 wedpr_ffi_macros = { path = "../../ffi_macros" }
 wedpr_l_crypto_zkp_utils = {version = "1.3.0", path = "../../../crypto/zkp/utils/"}
 wedpr_l_crypto_zkp_discrete_logarithm_proof = { version = "1.3.0", path = "../../../crypto/zkp/discrete_logarithm_proof/", optional = true}
+wedpr_l_crypto_zkp_range_proof = { path = "../../../crypto/zkp/range_proof/", optional = true}
 
 # This is required to generate C/C++ header files.
 [build-dependencies]

ffi/ffi_c/ffi_c_zkp/src/lib.rs

@@ -2,5 +2,6 @@
 //! compatible architectures (including iOS), with fast binary interfaces.
 // Copyright 2020 WeDPR Lab Project Authors. Licensed under Apache-2.0.
 pub mod discrete_logarithm_proof;
+pub mod range_proof;
 pub mod utils;
 // C/C++ FFI: C-style interfaces will be generated.

ffi/ffi_c/ffi_c_zkp/src/range_proof.rs

@@ -0,0 +1,84 @@
+use crate::utils::{
+    c_input_buffer_to_point, c_input_buffer_to_scalar,
+    c_input_buffer_to_vec
+};
+use wedpr_ffi_common::utils::{CInputBuffer, COutputBuffer, FAILURE, SUCCESS};
+
+use wedpr_ffi_common::utils::c_write_data_to_pointer;
+
+#[cfg(feature = "wedpr_f_zkp_proof")]
+use wedpr_l_crypto_zkp_range_proof::{
+    prove_value_range_with_blinding_and_blinding_basepoint, verify_value_range_with_blinding_basepoint
+};
+
+#[no_mangle]
+/// C interface for 'wedpr_generate_range_proof'.
+pub unsafe extern "C" fn wedpr_generate_range_proof(
+    c_value: u64,
+    c_blinding: &CInputBuffer,
+    blinding_basepoint_data: &CInputBuffer,
+    c_range_proof: &mut COutputBuffer,
+) -> i8 {
+    // c_blinding
+    let c_blinding_result: Result<curve25519_dalek::Scalar, wedpr_l_utils::error::WedprError> = c_input_buffer_to_scalar(&c_blinding);
+    let c_blinding_value = match c_blinding_result {
+        Ok(v) => v,
+        Err(_) => return FAILURE,
+    };
+    // blinding_basepoint
+    let blinding_basepoint_result =
+        c_input_buffer_to_point(blinding_basepoint_data);
+    let blinding_basepoint = match blinding_basepoint_result {
+        Ok(v) => v,
+        Err(_) => return FAILURE,
+    };
+    let (range_proof, _) = prove_value_range_with_blinding_and_blinding_basepoint(
+        c_value,
+        &c_blinding_value,
+        &blinding_basepoint,
+    );
+    // write balance proof back to c_balance_proof
+    c_write_data_to_pointer(
+        &range_proof,
+        c_range_proof.data,
+        c_range_proof.len,
+    );
+    SUCCESS
+}
+
+#[no_mangle]
+/// C interface for 'wedpr_verify_range_proof'.
+pub unsafe extern "C" fn wedpr_verify_range_proof(
+    commitment_point_data: &CInputBuffer,
+    proof: &CInputBuffer,
+    blinding_basepoint_data: &CInputBuffer,
+) -> i8 {
+    // c_point
+    let c_point_result = c_input_buffer_to_point(commitment_point_data);
+    let c_point = match c_point_result {
+        Ok(v) => v,
+        Err(_) => return FAILURE,
+    };
+    // range_proof
+    let range_proof_result = c_input_buffer_to_vec(proof);
+    let range_proof = match range_proof_result {
+        Ok(v) => v,
+        Err(_) => return FAILURE,
+    };
+    // blinding_basepoint
+    let blinding_basepoint_result =
+        c_input_buffer_to_point(blinding_basepoint_data);
+    let blinding_basepoint = match blinding_basepoint_result {
+        Ok(v) => v,
+        Err(_) => return FAILURE,
+    };
+    let result = verify_value_range_with_blinding_basepoint(
+        &c_point,
+        &range_proof,
+        &blinding_basepoint,
+    );
+    if result {
+        return SUCCESS;
+    }
+    FAILURE
+}

ffi/ffi_c/ffi_c_zkp/src/utils.rs

@@ -11,6 +11,16 @@ use wedpr_l_utils::error::WedprError;
 
 // From Rust to C/C++.
 use libc::c_char;
+
+pub unsafe fn c_input_buffer_to_vec(
+    input_data: &CInputBuffer,
+) -> Result<Vec<u8>, WedprError> {
+    let rust_bytes_input = c_read_raw_pointer(&input_data);
+    // avoid the input c buffer been released
+    // std::mem::forget(rust_bytes_input);
+    Ok(rust_bytes_input)
+}
+
 pub unsafe fn c_input_buffer_to_point(
     input_data: &CInputBuffer,
 ) -> Result<RistrettoPoint, WedprError> {