增加加密解密和hex base转换的方法

Cargo.toml

@@ -17,11 +17,11 @@ crate-type = ["staticlib", "lib"]
 anyhow = "1.0.65"
 bitcoin_hashes = "0.11.0"
 hex = "0.4.3"
-openssl = { version = "0.10.41", features = ["vendored"] }
-secp256k1 = { version = "0.21.3", features = ["rand-std", "bitcoin_hashes", "recovery"] }
+secp256k1 = { version = "0.25.0", features = ["rand-std", "bitcoin_hashes", "recovery"] }
 serde = { version = "1.0.145", features = ["derive"]}
 serde_json = "1.0.85"
 shamir_secret_sharing = "0.1.1"
 tiny-keccak = "1.5"
-web3 = { version = "0.18.0"}
-
+primitive-types = "0.12.1"
+ecies = {version = "0.2", default-features = false, features = ["pure"]}
+base64 = "0.21.0"

rustwallet.h

@@ -40,3 +40,19 @@ char *sign_for_tran(const char *msg_key,
                     const char *second_key,
                     const char *backup_key,
                     const char *msg);
+
+char *rencrypt(const char *msg_key,
+               const char *master_key,
+               const char *second_key,
+               const char *backup_key,
+               const char *msg);
+
+char *rdecrypt(const char *msg_key,
+               const char *master_key,
+               const char *second_key,
+               const char *backup_key,
+               const char *msg);
+
+char *str_deflate(const char *content);
+
+char *str_inflate(const char *content);

src/lib.rs

@@ -12,6 +12,8 @@ mod wallet;
 use wallet_impl::Wallet;
 
 use crate::wallet::*;
+mod utils;
+use utils::str_utils::{base64_to_hex, hex_to_base64};
 
 // #[cfg(target_os = "android")]
 // mod android;
@@ -175,6 +177,53 @@ pub unsafe extern "C" fn sign_for_tran(
     str_to_cchar!(result)
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn rencrypt(
+    msg_key: *const c_char,
+    master_key: *const c_char,
+    second_key: *const c_char,
+    backup_key: *const c_char, 
+    msg: *const c_char
+) -> *mut c_char{
+    let rwallet = generate_rwallet(msg_key, master_key, second_key, backup_key);
+    let msg_str = cchar_to_str!(msg);
+    let msg_encrypt = match rwallet.zencrypt(msg_str){
+        Ok(v) => v,
+        Err(err) => panic!("error encrypt: {:?}", err),
+    };
+    str_to_cchar!(msg_encrypt)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn rdecrypt(
+    msg_key: *const c_char,
+    master_key: *const c_char,
+    second_key: *const c_char,
+    backup_key: *const c_char, 
+    msg: *const c_char
+) -> *mut c_char{
+    let rwallet = generate_rwallet(msg_key, master_key, second_key, backup_key);
+    let msg_str = cchar_to_str!(msg);
+    let msg_decrypt = match rwallet.zdecrypt(msg_str){
+        Ok(v) => v,
+        Err(err) => panic!("error decrypt: {:?}", err),
+    };
+    str_to_cchar!(msg_decrypt)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn str_deflate(content: *const c_char) -> *mut c_char {
+    let content_str = cchar_to_str!(content);
+    let msg_base64 = hex_to_base64(&content_str);
+    str_to_cchar!(msg_base64)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn str_inflate(content: *const c_char) -> *mut c_char {
+    let content_str = cchar_to_str!(content);
+    let msg_hex = base64_to_hex(&content_str);
+    str_to_cchar!(msg_hex)
+}
 
 unsafe fn convert_to_cwallet(rwallet: Wallet) -> CWallet {
     let c_msgkey: *mut c_char = str_to_cchar!(rwallet.msg_key);
@@ -191,19 +240,6 @@ unsafe fn convert_to_cwallet(rwallet: Wallet) -> CWallet {
     cw
 }
 
-// unsafe fn convert_to_rwallet(cwallet: &CWallet) -> Wallet {
-//     let pmsg = cchar_to_string!(cwallet.msg_key);
-//     let pm = cchar_to_string!(cwallet.master_key);
-//     let second_key = cchar_to_ostring!(cwallet.second_key);
-//     let backup_key = cchar_to_ostring!(cwallet.backup_key);
-//     Wallet {
-//         msg_key: pmsg,
-//         master_key: pm,
-//         second_key: second_key,
-//         backup_key: backup_key
-//     }
-// }
-
 unsafe fn generate_rwallet(
     msg_key: *const c_char,
     master_key: *const c_char,

src/utils/mod.rs

@@ -0,0 +1 @@
+pub mod str_utils;

src/utils/str_utils.rs

@@ -0,0 +1,17 @@
+use base64::{engine::general_purpose, Engine as _};
+
+pub fn hex_to_base64(content: &str) -> String {
+    let str_tmp = match hex::decode(content) {
+        Ok(v) => v,
+        Err(e) => panic!("error decode hex str: {}", e),
+    };
+    general_purpose::STANDARD_NO_PAD.encode(&str_tmp)
+}
+
+pub fn base64_to_hex(content: &str) -> String {
+    let str_tmp = match general_purpose::STANDARD_NO_PAD.decode(content) {
+        Ok(v) => v,
+        Err(e) => panic!("error decode base64 str: {}", e),
+    };
+    hex::encode(&str_tmp)
+}

src/wallet/wallet_impl.rs

@@ -2,6 +2,8 @@ extern crate hex;
 
 use anyhow::Result;
 use core::fmt::Write;
+use ecies::{decrypt, encrypt};
+use primitive_types::{H160, H256};
 use secp256k1::rand::rngs::OsRng;
 use secp256k1::{Message, PublicKey, Secp256k1, SecretKey};
 use serde::{Deserialize, Serialize};
@@ -10,20 +12,19 @@ use shamir_secret_sharing::ShamirSecretSharing as SSS;
 use std::str;
 use std::str::FromStr;
 use tiny_keccak::keccak256;
-use web3::types::{Address, H256};
 
 pub fn generate_keypair() -> (SecretKey, PublicKey) {
     let secp = Secp256k1::new();
-    let mut rng = OsRng::new().expect("OsRng");
-    secp.generate_keypair(&mut rng)
+    // let mut rng = OsRng::new().expect("OsRng");
+    secp.generate_keypair(&mut OsRng)
 }
 
-pub fn public_key_address(public_key: &PublicKey) -> Address {
+pub fn public_key_address(public_key: &PublicKey) -> H160 {
     let public_key = public_key.serialize_uncompressed();
     debug_assert_eq!(public_key[0], 0x04);
     let hash = keccak256(&public_key[1..]);
 
-    Address::from_slice(&hash[12..])
+    H160::from_slice(&hash[12..])
 }
 
 pub fn get_public_key(secret_key: &SecretKey) -> PublicKey {
@@ -43,11 +44,7 @@ pub fn get_sss(msg: &str) -> SSS {
 }
 
 pub fn generate_sss_keypair(msg: &str, skey: &str) -> Vec<String> {
-    let secret = BigInt::parse_bytes(
-        &skey.as_bytes(),
-        16,
-    )
-    .unwrap();
+    let secret = BigInt::parse_bytes(&skey.as_bytes(), 16).unwrap();
     let sss = get_sss(msg);
     let shares = sss.split(secret.clone());
     let mut shares_str: Vec<String> = Vec::new();
@@ -57,7 +54,6 @@ pub fn generate_sss_keypair(msg: &str, skey: &str) -> Vec<String> {
     shares_str
 }
 
-
 pub fn hash_message<S>(message: S) -> H256
 where
     S: AsRef<[u8]>,
@@ -81,7 +77,7 @@ pub struct Wallet {
 impl Wallet {
     pub fn new(msg: &str) -> Self {
         let (secret_key, _pub_key) = generate_keypair();
-        let s = hex::encode(&secret_key.serialize_secret());
+        let s = hex::encode(&secret_key.secret_bytes());
         let shares_str = generate_sss_keypair(msg, &s);
         // println!("secret key: {:?}", secret_key);
         // println!("{:?}", s);
@@ -91,13 +87,13 @@ impl Wallet {
             msg_key: msg.to_string(),
             master_key: shares_str.get(0).unwrap().to_string(),
             second_key: second_key,
-            backup_key: backup_key
+            backup_key: backup_key,
         }
     }
 
     pub fn reset_wallet(&self) -> Self {
         let secret_key = self.get_secret_key();
-        let s = hex::encode(&secret_key.serialize_secret());
+        let s = hex::encode(&secret_key.secret_bytes());
         let shares_str = generate_sss_keypair(&self.msg_key, &s);
         let second_key = shares_str.get(1).map(String::clone);
         let backup_key = shares_str.get(2).map(String::clone);
@@ -106,16 +102,13 @@ impl Wallet {
             msg_key: self.msg_key.clone(),
             master_key: shares_str.get(0).unwrap().to_string(),
             second_key: second_key,
-            backup_key: backup_key
+            backup_key: backup_key,
         }
     }
 
     fn get_secret_key(&self) -> SecretKey {
         let key_str_0: &str = &self.master_key;
-        let key0 = BigInt::parse_bytes(
-            &key_str_0.as_bytes(),
-            16,
-        ).unwrap();
+        let key0 = BigInt::parse_bytes(&key_str_0.as_bytes(), 16).unwrap();
         let kp0: (usize, BigInt) = (1, key0);
         let i: usize;
         let key_str_1: &str;
@@ -130,11 +123,7 @@ impl Wallet {
             i = 2;
             key_str_1 = "";
         }
-        let key1 = BigInt::parse_bytes(
-            &key_str_1.as_bytes(),
-            16,
-        )
-        .unwrap();
+        let key1 = BigInt::parse_bytes(&key_str_1.as_bytes(), 16).unwrap();
         let kp1 = (i, key1);
         let _tmp = vec![kp0, kp1];
         let sss = get_sss(&self.msg_key);
@@ -143,7 +132,6 @@ impl Wallet {
         if s_key_str.len() < 64 {
             s_key_str += "0";
         }
-        println!("{}", &s_key_str);
         SecretKey::from_str(&s_key_str).expect("32 bytes, within curve order")
     }
 
@@ -154,11 +142,11 @@ impl Wallet {
 
     pub fn generate_sec_key(&self) -> String {
         let secret_key = self.get_secret_key();
-        let s = hex::encode(&secret_key.serialize_secret());
+        let s = hex::encode(&secret_key.secret_bytes());
         s
     }
 
-    pub fn get_address(&self) -> Address {
+    pub fn get_address(&self) -> H160 {
         let public_key = self.get_public_key();
         public_key_address(&public_key)
     }
@@ -199,4 +187,42 @@ impl Wallet {
         let recid = _recovery_id.to_i32();
         Ok((s, recid))
     }
+
+    pub fn zencrypt(&self, msg: &str) -> Result<String> {
+        let pk = self.get_public_key();
+        let pk = &pk.serialize();
+        let msg = msg.as_bytes();
+        println!("msg before encrypt: {:?}", msg);
+        let msg_encrypt = match encrypt(pk, &msg) {
+            Ok(v) => v,
+            Err(e) => panic!("error encrypt content: {}", e),
+        };
+        println!("msg after encrypt: {:?}", &msg_encrypt);
+        let str_encrypt = hex::encode(&msg_encrypt);
+        Ok(str_encrypt)
     }
+
+    pub fn zdecrypt(&self, msg: &str) -> Result<String> {
+        let sk = self.get_secret_key();
+        let sk = sk.secret_bytes();
+        let msg = match hex::decode(&msg) {
+            Ok(v) => v,
+            Err(e) => panic!("error decode hex str {}", e),
+        };
+        println!("msg to decrypt: {:?}", &msg);
+        let msg_decrypt = match decrypt(&sk, &msg) {
+            Ok(v) => v,
+            Err(e) => panic!("error decrypt content: {}", e),
+        };
+        println!("msg after decrypt: {:?}", &msg_decrypt);
+        // let msg_decrypt = hex::encode(msg_decrypt);
+        let str_decrypt = match str::from_utf8(&msg_decrypt) {
+            Ok(v) => v,
+            Err(e) => panic!("Invalid UTF-8 sequence: {}", e),
+        };
+        let result = str_decrypt.to_string();
+
+        Ok(result)
+    }
+}
+