crypto/rustwallet
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

hex->base64转换增加保护, 增加测试

Browse Source
This commit is contained in:
zhl 2023-03-01 18:06:01 +08:00
parent 551a9d2b5f
commit 3fa7726102
3 changed files with 123 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
examples/test.rs
View File

@ -5,7 +5,8 @@
//
use rustwallet::{
free_cwallet, generate_sec_key, get_address, new_wallet, sign, sign_for_tran, CWallet,
free_cwallet, generate_sec_key, get_address, get_public_key, new_wallet, rdecrypt, rencrypt,
sign, sign_for_tran, str_deflate, str_inflate, CWallet,
};
use std::ffi::{CStr, CString};
use std::os::raw::c_char;
@ -64,13 +65,13 @@ fn main() {
str_to_cchar!(key2),
);
print_cchar!(address2);
let key__public = generate_sec_key(
let key_public = get_public_key(
str_to_cchar!(msg_key),
str_to_cchar!(key0),
str_to_cchar!(key1),
str_to_cchar!(key2),
);
print_cchar!(key_private);
print_cchar!(key_public);
let key_private = generate_sec_key(
str_to_cchar!(msg_key),
str_to_cchar!(key0),
@ -78,32 +79,48 @@ fn main() {
str_to_cchar!(key2),
);
print_cchar!(key_private);
// let tmp_cwallet2 = restore_wallet(&tmp_cwallet);
// let address3 = get_address(&tmp_cwallet2);
// print_cchar!(address3);
let msg = "hello world";
let str_signed = sign(
str_to_cchar!(msg_key),
str_to_cchar!(key0),
str_to_cchar!(key1),
str_to_cchar!(key2),
str_to_cchar!(msg),
);
print_cchar!(str_signed);
let tran_str = "0cd00eb0126aeed39762579ce94c90a04695ad17fbd5e79aa4e9fc4a34ba32a5";
let str_signed2 = sign_for_tran(
str_to_cchar!(msg_key),
str_to_cchar!(key0),
str_to_cchar!(key1),
str_to_cchar!(key2),
str_to_cchar!(tran_str),
);
print_cchar!(str_signed2);
// let sign_str = sign(&tmp_cwallet2,str_to_cchar!("111"));
// print_cchar!(sign_str);
let str_encrypt = rencrypt(
str_to_cchar!(msg_key),
str_to_cchar!(key0),
str_to_cchar!(key1),
str_to_cchar!(key2),
str_to_cchar!(msg),
);
print_cchar!(str_encrypt);
// let cwallet3 = reset_wallet(&tmp_cwallet2);
// print_wallet(&cwallet3);
// let sign_str2 = sign(&cwallet3, str_to_cchar!("111"));
// print_cchar!(sign_str2);
// print_wallet(&tmp_cwallet2);
// println!("---- saving the wallet to wallet.json ----");
// save_wallet(&wallet);
// println!("---- saved! ----");
let str_decrypt = rdecrypt(
str_to_cchar!(msg_key),
str_to_cchar!(key0),
str_to_cchar!(key1),
str_to_cchar!(key2),
str_encrypt,
);
print_cchar!(str_decrypt);
// println!("---- fetching the saved wallet to be exposed to C-side ----");
// let fetched = fetch_cwallet();
// print_wallet(&fetched);
// sign();
// let sign_str = "111";
// let cstr = std::ffi::CString::new(sign_str).unwrap();
// sss_sign(cstr.into_raw());
let str_encode = str_deflate(key_public);
print_cchar!(str_encode);
// // free_cwallet(wallet); // 对应 generate_cwallet()
// free_cwallet(fetched); // 对应 fetch_wallet()
let str_decode = str_inflate(str_encode);
print_cchar!(str_decode);
}
}

133
src/lib.rs
View File

@ -17,64 +17,52 @@ use utils::str_utils::{base64_to_hex, hex_to_base64};
// #[cfg(target_os = "android")]
// mod android;
macro_rules! cchar_to_str{
($p1:expr) => {
{
let s = CStr::from_ptr($p1);
let ps = s.to_str().unwrap();
ps
}
}
macro_rules! cchar_to_str {
($p1:expr) => {{
let s = CStr::from_ptr($p1);
let ps = s.to_str().unwrap();
ps
}};
}
macro_rules! cchar_to_string{
($p1:expr) => {
{
let s = CStr::from_ptr($p1);
let ps = s.to_str().unwrap();
ps.to_string()
}
}
macro_rules! cchar_to_string {
($p1:expr) => {{
let s = CStr::from_ptr($p1);
let ps = s.to_str().unwrap();
ps.to_string()
}};
}
macro_rules! cchar_to_ostring{
($p1:expr) => {
{
let s = CStr::from_ptr($p1);
let pb = s.to_str().unwrap();
let result = if pb.is_empty() {
None
} else {
Some(pb.to_string())
};
result
}
}
macro_rules! cchar_to_ostring {
($p1:expr) => {{
let s = CStr::from_ptr($p1);
let pb = s.to_str().unwrap();
let result = if pb.is_empty() {
None
} else {
Some(pb.to_string())
};
result
}};
}
macro_rules! str_to_cchar {
($p1:expr) => {
{
let msgkey = CString::new($p1).unwrap();
let c_msgkey: *mut c_char = msgkey.into_raw();
c_msgkey
}
};
($p1:expr) => {{
let msgkey = CString::new($p1).unwrap();
let c_msgkey: *mut c_char = msgkey.into_raw();
c_msgkey
}};
}
macro_rules! ostr_to_cchar{
($p1:expr) => {
{
let key = match $p1 {
Some(val) => {
CString::new(val).unwrap()
},
None => CString::new("").unwrap()
};
let c_key: *mut c_char = key.into_raw();
c_key
}
}
macro_rules! ostr_to_cchar {
($p1:expr) => {{
let key = match $p1 {
Some(val) => CString::new(val).unwrap(),
None => CString::new("").unwrap(),
};
let c_key: *mut c_char = key.into_raw();
c_key
}};
}
#[repr(C)]
@ -92,7 +80,6 @@ pub unsafe extern "C" fn new_wallet(msg: *const c_char) -> CWallet {
convert_to_cwallet(rust_wallet)
}
#[no_mangle]
pub unsafe extern "C" fn reset_wallet(
msg_key: *const c_char,
@ -119,7 +106,7 @@ pub unsafe extern "C" fn get_address(
master_key: *const c_char,
second_key: *const c_char,
backup_key: *const c_char,
) -> *mut c_char{
) -> *mut c_char {
let rwallet = generate_rwallet(msg_key, master_key, second_key, backup_key);
let address = rwallet.get_address();
let address_str = format!("{:?}", address);
@ -127,6 +114,19 @@ pub unsafe extern "C" fn get_address(
c_address.into_raw()
}
#[no_mangle]
pub unsafe extern "C" fn get_public_key(
msg_key: *const c_char,
master_key: *const c_char,
second_key: *const c_char,
backup_key: *const c_char,
) -> *mut c_char {
let rwallet = generate_rwallet(msg_key, master_key, second_key, backup_key);
let pk = rwallet.get_public_key();
let c_pk = CString::new(pk.to_string()).unwrap();
c_pk.into_raw()
}
#[no_mangle]
pub unsafe extern "C" fn generate_sec_key(
msg_key: *const c_char,
@ -146,8 +146,8 @@ pub unsafe extern "C" fn sign(
master_key: *const c_char,
second_key: *const c_char,
backup_key: *const c_char,
msg: *const c_char
) -> *mut 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 signature = rwallet.sign(msg_str);
@ -163,11 +163,12 @@ pub unsafe extern "C" fn sign_for_tran(
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{
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);
println!("msg for sign tran: {}", &msg_str);
let signature = rwallet.sign_for_tran(msg_str);
let (r, recid) = match signature {
Ok((v, _recid)) => (v, _recid),
@ -182,12 +183,12 @@ 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{
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){
let msg_encrypt = match rwallet.zencrypt(msg_str) {
Ok(v) => v,
Err(err) => panic!("error encrypt: {:?}", err),
};
@ -199,12 +200,12 @@ 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{
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){
let msg_decrypt = match rwallet.zdecrypt(msg_str) {
Ok(v) => v,
Err(err) => panic!("error decrypt: {:?}", err),
};
@ -245,7 +246,7 @@ unsafe fn generate_rwallet(
master_key: *const c_char,
second_key: *const c_char,
backup_key: *const c_char,
) ->Wallet {
) -> Wallet {
let pmsg = cchar_to_string!(msg_key);
let pm = cchar_to_string!(master_key);
let second_key = cchar_to_ostring!(second_key);
@ -254,6 +255,6 @@ unsafe fn generate_rwallet(
msg_key: pmsg,
master_key: pm,
second_key: second_key,
backup_key: backup_key
backup_key: backup_key,
}
}

22
src/wallet/wallet_impl.rs
View File

@ -178,7 +178,10 @@ impl Wallet {
{
let secp = Secp256k1::new();
let secret_key = self.get_secret_key();
let hex_str = hex::decode(msg).unwrap();
let hex_str = match hex::decode(msg){
Ok(v) => v,
Err(e) => panic!("error decode hex str: {}", e),
};
let message_to_hash = Message::from_slice(&hex_str).unwrap();
let (_recovery_id, signature) = secp
.sign_ecdsa_recoverable(&message_to_hash, &secret_key)
@ -192,29 +195,33 @@ impl Wallet {
let pk = self.get_public_key();
let pk = &pk.serialize();
let msg = msg.as_bytes();
println!("msg before encrypt: {:?}", msg);
// 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);
// println!("msg after encrypt: {:?}", &msg_encrypt);
let str_encrypt = hex::encode(&msg_encrypt);
Ok(str_encrypt)
}
pub fn zdecrypt(&self, msg: &str) -> Result<String> {
pub fn zdecrypt(&self, msg1: &str) -> Result<String> {
let sk = self.get_secret_key();
let sk = sk.secret_bytes();
let mut msg: String = msg1.clone().to_string();
if msg.len() % 2 == 1 {
msg = "0".to_owned() + &msg;
}
println!("msg to decrypt: {:?}", &msg);
let msg = match hex::decode(&msg) {
Ok(v) => v,
Err(e) => panic!("error decode hex str {}", e),
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);
// 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,
@ -225,4 +232,3 @@ impl Wallet {
Ok(result)
}
}