add ios && android interface

Cargo.toml

@@ -7,6 +7,9 @@ members = [
 "common/macros",
 "ffi/ffi_common",
 "ffi/ffi_macros",
-"ffi/ffi_vcl",
+"ffi/ffi_c/ffi_c_vcl",
+"ffi/ffi_java/ffi_java_vcl",
+"ffi/ffi_c/ffi_c_crypto",
+"ffi/ffi_java/ffi_java_crypto",
 "protos",
 ]

README.md

@@ -61,7 +61,7 @@ cargo run
 在本项目的根目录（即`WeDPR-Lab-Core`目录）中，运行如下命令。
 
 ```bash
-cargo doc
+cargo doc --no-deps
 ```
 
 以上命令将根据代码中的注释，在`target/doc`子目录中，生成的SDK接口文档。

common/macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wedpr_macros"
-version = "1.0.0"
+version = "1.1.0"
 authors = ["WeDPR <[email protected]>"]
 edition = "2018"
 

common/utils/Cargo.toml

@@ -1,10 +1,13 @@
 [package]
 name = "wedpr_utils"
-version = "1.0.0"
+version = "1.1.0"
 authors = ["WeDPR <[email protected]>"]
 edition = "2018"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+base64 = "0.10.1"
 failure = "0.1"
+hex = "0.3.0"
+wedpr_macros = { path = "../macros/"}

crypto/src/coder/base_x.rs → common/utils/src/coder/base_x.rs

@@ -4,8 +4,7 @@
 
 extern crate base64;
 
-use crate::coder::Coder;
-use wedpr_utils::error::WedprError;
+use crate::{coder::Coder, error::WedprError};
 
 #[derive(Default, Debug, Clone)]
 pub struct WedprBase64 {}

common/utils/src/coder/basic.rs

@@ -0,0 +1,41 @@
+// Copyright 2020 WeDPR Lab Project Authors. Licensed under Apache-2.0.
+
+//! Basic encoding and decoding functions.
+
+extern crate hex;
+
+use crate::{coder::Coder, error::WedprError};
+
+#[derive(Default, Debug, Clone)]
+pub struct WedprHex {}
+
+/// Implements Hex as a Coder instance.
+impl Coder for WedprHex {
+ fn encode<T: ?Sized + AsRef<[u8]>>(&self, input: &T) -> String {
+ hex::encode(input)
+ }
+
+ fn decode(&self, input: &str) -> Result<Vec<u8>, WedprError> {
+ match hex::decode(input) {
+ Ok(v) => return Ok(v),
+ Err(_) => {
+ wedpr_println!("hex decoding failed, input was: {}", input);
+ return Err(WedprError::DecodeError);
+ },
+ };
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_hex() {
+ let hex = WedprHex::default();
+ let str = "5c74d17c6a";
+ let bytes = hex.decode(&str).unwrap();
+ let recovered_str = hex.encode(&bytes);
+ assert_eq!(str, recovered_str);
+ }
+}

crypto/src/coder/mod.rs → common/utils/src/coder/mod.rs

@@ -3,8 +3,9 @@
 //! Data encoding and decoding functions.
 
 pub mod base_x;
+pub mod basic;
 
-use wedpr_utils::error::WedprError;
+use crate::error::WedprError;
 
 /// Trait of a replaceable coder algorithm.
 pub trait Coder {

common/utils/src/lib.rs

@@ -4,5 +4,8 @@
 
 #[macro_use]
 extern crate failure;
+#[macro_use]
+extern crate wedpr_macros;
 
+pub mod coder;
 pub mod error;

crypto/Cargo.toml

@@ -1,19 +1,19 @@
 [package]
 name = "wedpr_crypto"
-version = "1.0.0"
+version = "1.1.0"
 authors = ["WeDPR <[email protected]>"]
 edition = "2018"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-base64 = "0.10.1"
 bulletproofs = "1.0.4"
 curve25519-dalek = { version = "1", features = ["serde"] }
+ecies = "0.1.4"
 lazy_static = "0.2"
 merlin = "1"
 rand = "0.6"
-secp256k1 = { version = "0.17.2", features = ["recovery"] }
+secp256k1 = { version = "0.19.0", features = ["recovery", "rand"] }
 sha3 = "0.8"
 wedpr_macros = { path = "../common/macros/"}
 wedpr_protos = { path = "../protos/" }

crypto/src/constant.rs

@@ -9,11 +9,12 @@ use curve25519_dalek::{
 };
 extern crate secp256k1;
 use crate::{
- coder::base_x::WedprBase64, hash::keccak256::WedprKeccak256,
+ ecies::secp256k1::WedprSecp256k1Ecies, hash::keccak256::WedprKeccak256,
  signature::secp256k1::WedprSecp256k1Recover,
 };
 use secp256k1::{All, Secp256k1, VerifyOnly};
 use sha3::Sha3_512;
+use wedpr_utils::coder::base_x::WedprBase64;
 
 lazy_static! {
  /// A base point used by various crypto algorithms.
@@ -31,6 +32,7 @@ lazy_static! {
 
  /// Shared coder algorithm reference for quick implementation replacement.
  /// Other code should use this reference, and not directly use a specific implementation.
+ // You may change WedprBase64 to other coder implementation such as WedprHex.
  pub static ref CODER: WedprBase64 = WedprBase64::default();
 
  /// Shared signature algorithm reference for quick implementation replacement.
@@ -41,16 +43,24 @@ lazy_static! {
  /// Shared hash algorithm reference for quick implementation replacement.
  /// Other code should use this reference, and not directly use a specific implementation.
  pub static ref HASH: WedprKeccak256 = WedprKeccak256::default();
+
+ /// Shared ECIES algorithm reference for quick implementation replacement.
+ /// Other code should use this reference, and not directly use a specific implementation.
+ pub static ref ECIES: WedprSecp256k1Ecies = WedprSecp256k1Ecies::default();
 }
 
 /// Serialized data size of a point.
 pub const RISTRETTO_POINT_SIZE_IN_BYTES: usize = 32;
 
 /// Constants only used by tests.
 pub mod tests {
- // secp256k1 test key pair
+ // Test key pair for secp256k1 algorithms.
  pub const SECP256K1_TEST_SECRET_KEY: &str =
  "EMGwfgpqDQVUsVO7jxUniSNYxTPjGcbbf6eikaAIKog=";
  pub const SECP256K1_TEST_PUBLIC_KEY: &str =
  "ApBrmk0PHxPp4ElvnhlmwEiAklVdDbX+MicqML591eC2";
+
+ // Test string for a base64 encoded message.
+ pub const BASE64_ENCODED_TEST_MESSAGE: &str =
+ "g6sLGLyLvnkOSvBcQdKNSPx8m4XmAogueNMmE6V0Ico=";
 }

crypto/src/ecies/mod.rs

@@ -0,0 +1,27 @@
+// Copyright 2020 WeDPR Lab Project Authors. Licensed under Apache-2.0.
+
+//! ECIES (Elliptic Curve Integrated Encryption Scheme) functions.
+//! ECIES is a public-key authenticated encryption scheme, which allows
+//! using a public key to encrypt a message of any length and provide integrity
+//! check.
+
+use wedpr_utils::error::WedprError;
+
+pub mod secp256k1;
+
+/// Trait of a replaceable ECIES algorithm.
+pub trait Ecies {
+ /// Encrypts a message by ECIES with a public key.
+ fn encrypt<T: ?Sized + AsRef<[u8]>>(
+ &self,
+ public_key: &T,
+ message: &T,
+ ) -> Result<Vec<u8>, WedprError>;
+
+ /// Decrypts a ciphertext by ECIES with a private key.
+ fn decrypt<T: ?Sized + AsRef<[u8]>>(
+ &self,
+ private_key: &T,
+ ciphertext: &T,
+ ) -> Result<Vec<u8>, WedprError>;
+}

crypto/src/ecies/secp256k1.rs

@@ -0,0 +1,77 @@
+// Copyright 2020 WeDPR Lab Project Authors. Licensed under Apache-2.0.
+
+//! ECIES functions on Secp256k1 curve.
+
+extern crate ecies;
+
+use wedpr_utils::error::WedprError;
+
+use crate::ecies::Ecies;
+
+#[derive(Default, Debug, Clone)]
+pub struct WedprSecp256k1Ecies {}
+
+/// Implements a ECIES instance on Secp256k1 curve.
+impl Ecies for WedprSecp256k1Ecies {
+ fn encrypt<T: ?Sized + AsRef<[u8]>>(
+ &self,
+ public_key: &T,
+ message: &T,
+ ) -> Result<Vec<u8>, WedprError>
+ {
+ match ecies::encrypt(public_key.as_ref(), message.as_ref()) {
+ Ok(v) => Ok(v.to_vec()),
+ Err(_) => {
+ wedpr_println!("secp256k1 ECIES encrypt failed");
+ return Err(WedprError::FormatError);
+ },
+ }
+ }
+
+ fn decrypt<T: ?Sized + AsRef<[u8]>>(
+ &self,
+ private_key: &T,
+ ciphertext: &T,
+ ) -> Result<Vec<u8>, WedprError>
+ {
+ match ecies::decrypt(private_key.as_ref(), ciphertext.as_ref()) {
+ Ok(v) => Ok(v.to_vec()),
+ Err(_) => {
+ wedpr_println!("secp256k1 ECIES decrypt failed");
+ return Err(WedprError::FormatError);
+ },
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::{
+ constant::tests::{
+ BASE64_ENCODED_TEST_MESSAGE, SECP256K1_TEST_PUBLIC_KEY,
+ SECP256K1_TEST_SECRET_KEY,
+ },
+ utils::{bytes_to_string, string_to_bytes},
+ };
+
+ #[test]
+ fn test_secp256k1_ecies() {
+ let secp256k1_ecies = WedprSecp256k1Ecies::default();
+
+ let encoded_msg = BASE64_ENCODED_TEST_MESSAGE;
+ let ciphertext = secp256k1_ecies
+ .encrypt(
+ &string_to_bytes(SECP256K1_TEST_PUBLIC_KEY).unwrap(),
+ &string_to_bytes(encoded_msg).unwrap(),
+ )
+ .unwrap();
+ let decrypted_msg = secp256k1_ecies
+ .decrypt(
+ &string_to_bytes(SECP256K1_TEST_SECRET_KEY).unwrap(),
+ &ciphertext,
+ )
+ .unwrap();
+ assert_eq!(bytes_to_string(&decrypted_msg), encoded_msg);
+ }
+}

crypto/src/hash/keccak256.rs

@@ -12,24 +12,29 @@ pub struct WedprKeccak256 {}
 
 /// Implements FISCO-BCOS-compatible Keccak256 as a Hash instance.
 impl Hash for WedprKeccak256 {
- fn hash(&self, msg: &str) -> Vec<u8> {
- let mut mes = Keccak256::default();
- mes.input(msg);
- mes.result().to_vec()
+ fn hash<T: ?Sized + AsRef<[u8]>>(&self, input: &T) -> Vec<u8> {
+ let mut hash_algorithm = Keccak256::default();
+ hash_algorithm.input(input);
+ hash_algorithm.result().to_vec()
  }
 }
 
 #[cfg(test)]
 mod tests {
  use super::*;
- use crate::utils::bytes_to_string;
+ use crate::{
+ constant::tests::BASE64_ENCODED_TEST_MESSAGE,
+ utils::{bytes_to_string, string_to_bytes},
+ };
 
  #[test]
  fn test_keccak256() {
  let keccak256 = WedprKeccak256::default();
- let msg = "WeDPR";
- let computed_hash = bytes_to_string(&keccak256.hash(msg));
- let expected_hash = "g6sLGLyLvnkOSvBcQdKNSPx8m4XmAogueNMmE6V0Ico=";
- assert_eq!(expected_hash, computed_hash);
+ let msg = BASE64_ENCODED_TEST_MESSAGE;
+ let expected_hash = "5S04Vv6HBCWG6xNARqwPb294Hz/3BlaFVwKvAJByd9Q=";
+ assert_eq!(
+ expected_hash,
+ bytes_to_string(&keccak256.hash(&string_to_bytes(&msg).unwrap()))
+ );
  }
 }

crypto/src/hash/mod.rs

@@ -6,6 +6,7 @@ pub mod keccak256;
 
 /// Trait of a replaceable hash algorithm.
 pub trait Hash {
- /// Generates a fixed length hash bytes vector from any string.
- fn hash(&self, msg: &str) -> Vec<u8>;
+ /// Generates a fixed length hash bytes vector from a bytes array of any
+ /// length.
+ fn hash<T: ?Sized + AsRef<[u8]>>(&self, input: &T) -> Vec<u8>;
 }

crypto/src/lib.rs

@@ -7,8 +7,8 @@ extern crate wedpr_macros;
 #[macro_use]
 extern crate lazy_static;
 
-pub mod coder;
 pub mod constant;
+pub mod ecies;
 pub mod hash;
 pub mod signature;
 pub mod utils;

crypto/src/signature/mod.rs

@@ -9,16 +9,21 @@ pub mod secp256k1;
 /// Trait of a replaceable signature algorithm.
 pub trait Signature {
  /// Signs a message hash with the private key.
- fn sign(
+ fn sign<T: ?Sized + AsRef<[u8]>>(
  &self,
- private_key: &str,
- msg_hash_str: &str,
- ) -> Result<String, WedprError>;
+ private_key: &T,
+ msg_hash: &T,
+ ) -> Result<Vec<u8>, WedprError>;
+
  /// Verifies a message hash with the public key.
- fn verify(
+ fn verify<T: ?Sized + AsRef<[u8]>>(
  &self,
- public_key: &str,
- msg_hash_str: &str,
- signature: &str,
+ public_key: &T,
+ msg_hash: &T,
+ signature: &T,
  ) -> bool;
+
+ /// Generates a new key pair for signature algorithm.
+ // TODO: Replace output list with a struct or protobuf.
+ fn generate_keypair(&self) -> (Vec<u8>, Vec<u8>);
 }