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

85
src/lib.rs
View File

@ -17,29 +17,24 @@ use utils::str_utils::{base64_to_hex, hex_to_base64};
// #[cfg(target_os = "android")] // #[cfg(target_os = "android")]
// mod android; // mod android;
macro_rules! cchar_to_str{ macro_rules! cchar_to_str {
($p1:expr) => { ($p1:expr) => {{
{
let s = CStr::from_ptr($p1); let s = CStr::from_ptr($p1);
let ps = s.to_str().unwrap(); let ps = s.to_str().unwrap();
ps ps
} }};
}
} }
macro_rules! cchar_to_string{ macro_rules! cchar_to_string {
($p1:expr) => { ($p1:expr) => {{
{
let s = CStr::from_ptr($p1); let s = CStr::from_ptr($p1);
let ps = s.to_str().unwrap(); let ps = s.to_str().unwrap();
ps.to_string() ps.to_string()
} }};
}
} }
macro_rules! cchar_to_ostring{ macro_rules! cchar_to_ostring {
($p1:expr) => { ($p1:expr) => {{
{
let s = CStr::from_ptr($p1); let s = CStr::from_ptr($p1);
let pb = s.to_str().unwrap(); let pb = s.to_str().unwrap();
let result = if pb.is_empty() { let result = if pb.is_empty() {
@ -48,33 +43,26 @@ macro_rules! cchar_to_ostring{
Some(pb.to_string()) Some(pb.to_string())
}; };
result result
} }};
}
} }
macro_rules! str_to_cchar { macro_rules! str_to_cchar {
($p1:expr) => { ($p1:expr) => {{
{
let msgkey = CString::new($p1).unwrap(); let msgkey = CString::new($p1).unwrap();
let c_msgkey: *mut c_char = msgkey.into_raw(); let c_msgkey: *mut c_char = msgkey.into_raw();
c_msgkey c_msgkey
} }};
};
} }
macro_rules! ostr_to_cchar{ macro_rules! ostr_to_cchar {
($p1:expr) => { ($p1:expr) => {{
{
let key = match $p1 { let key = match $p1 {
Some(val) => { Some(val) => CString::new(val).unwrap(),
CString::new(val).unwrap() None => CString::new("").unwrap(),
},
None => CString::new("").unwrap()
}; };
let c_key: *mut c_char = key.into_raw(); let c_key: *mut c_char = key.into_raw();
c_key c_key
} }};
}
} }
#[repr(C)] #[repr(C)]
@ -92,7 +80,6 @@ pub unsafe extern "C" fn new_wallet(msg: *const c_char) -> CWallet {
convert_to_cwallet(rust_wallet) convert_to_cwallet(rust_wallet)
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn reset_wallet( pub unsafe extern "C" fn reset_wallet(
msg_key: *const c_char, msg_key: *const c_char,
@ -119,7 +106,7 @@ pub unsafe extern "C" fn get_address(
master_key: *const c_char, master_key: *const c_char,
second_key: *const c_char, second_key: *const c_char,
backup_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 rwallet = generate_rwallet(msg_key, master_key, second_key, backup_key);
let address = rwallet.get_address(); let address = rwallet.get_address();
let address_str = format!("{:?}", address); let address_str = format!("{:?}", address);
@ -127,6 +114,19 @@ pub unsafe extern "C" fn get_address(
c_address.into_raw() 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] #[no_mangle]
pub unsafe extern "C" fn generate_sec_key( pub unsafe extern "C" fn generate_sec_key(
msg_key: *const c_char, msg_key: *const c_char,
@ -146,8 +146,8 @@ pub unsafe extern "C" fn sign(
master_key: *const c_char, master_key: *const c_char,
second_key: *const c_char, second_key: *const c_char,
backup_key: *const c_char, backup_key: *const c_char,
msg: *const c_char msg: *const c_char,
) -> *mut c_char{ ) -> *mut c_char {
let rwallet = generate_rwallet(msg_key, master_key, second_key, backup_key); let rwallet = generate_rwallet(msg_key, master_key, second_key, backup_key);
let msg_str = cchar_to_str!(msg); let msg_str = cchar_to_str!(msg);
let signature = rwallet.sign(msg_str); let signature = rwallet.sign(msg_str);
@ -164,10 +164,11 @@ pub unsafe extern "C" fn sign_for_tran(
master_key: *const c_char, master_key: *const c_char,
second_key: *const c_char, second_key: *const c_char,
backup_key: *const c_char, backup_key: *const c_char,
msg: *const c_char msg: *const c_char,
) -> *mut c_char{ ) -> *mut c_char {
let rwallet = generate_rwallet(msg_key, master_key, second_key, backup_key); let rwallet = generate_rwallet(msg_key, master_key, second_key, backup_key);
let msg_str = cchar_to_str!(msg); let msg_str = cchar_to_str!(msg);
println!("msg for sign tran: {}", &msg_str);
let signature = rwallet.sign_for_tran(msg_str); let signature = rwallet.sign_for_tran(msg_str);
let (r, recid) = match signature { let (r, recid) = match signature {
Ok((v, _recid)) => (v, _recid), Ok((v, _recid)) => (v, _recid),
@ -183,11 +184,11 @@ pub unsafe extern "C" fn rencrypt(
master_key: *const c_char, master_key: *const c_char,
second_key: *const c_char, second_key: *const c_char,
backup_key: *const c_char, backup_key: *const c_char,
msg: *const c_char msg: *const c_char,
) -> *mut c_char{ ) -> *mut c_char {
let rwallet = generate_rwallet(msg_key, master_key, second_key, backup_key); let rwallet = generate_rwallet(msg_key, master_key, second_key, backup_key);
let msg_str = cchar_to_str!(msg); 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, Ok(v) => v,
Err(err) => panic!("error encrypt: {:?}", err), Err(err) => panic!("error encrypt: {:?}", err),
}; };
@ -200,11 +201,11 @@ pub unsafe extern "C" fn rdecrypt(
master_key: *const c_char, master_key: *const c_char,
second_key: *const c_char, second_key: *const c_char,
backup_key: *const c_char, backup_key: *const c_char,
msg: *const c_char msg: *const c_char,
) -> *mut c_char{ ) -> *mut c_char {
let rwallet = generate_rwallet(msg_key, master_key, second_key, backup_key); let rwallet = generate_rwallet(msg_key, master_key, second_key, backup_key);
let msg_str = cchar_to_str!(msg); 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, Ok(v) => v,
Err(err) => panic!("error decrypt: {:?}", err), Err(err) => panic!("error decrypt: {:?}", err),
}; };
@ -245,7 +246,7 @@ unsafe fn generate_rwallet(
master_key: *const c_char, master_key: *const c_char,
second_key: *const c_char, second_key: *const c_char,
backup_key: *const c_char, backup_key: *const c_char,
) ->Wallet { ) -> Wallet {
let pmsg = cchar_to_string!(msg_key); let pmsg = cchar_to_string!(msg_key);
let pm = cchar_to_string!(master_key); let pm = cchar_to_string!(master_key);
let second_key = cchar_to_ostring!(second_key); let second_key = cchar_to_ostring!(second_key);
@ -254,6 +255,6 @@ unsafe fn generate_rwallet(
msg_key: pmsg, msg_key: pmsg,
master_key: pm, master_key: pm,
second_key: second_key, 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 secp = Secp256k1::new();
let secret_key = self.get_secret_key(); 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 message_to_hash = Message::from_slice(&hex_str).unwrap();
let (_recovery_id, signature) = secp let (_recovery_id, signature) = secp
.sign_ecdsa_recoverable(&message_to_hash, &secret_key) .sign_ecdsa_recoverable(&message_to_hash, &secret_key)
@ -192,29 +195,33 @@ impl Wallet {
let pk = self.get_public_key(); let pk = self.get_public_key();
let pk = &pk.serialize(); let pk = &pk.serialize();
let msg = msg.as_bytes(); let msg = msg.as_bytes();
println!("msg before encrypt: {:?}", msg); // println!("msg before encrypt: {:?}", msg);
let msg_encrypt = match encrypt(pk, &msg) { let msg_encrypt = match encrypt(pk, &msg) {
Ok(v) => v, Ok(v) => v,
Err(e) => panic!("error encrypt content: {}", e), 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); let str_encrypt = hex::encode(&msg_encrypt);
Ok(str_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 = self.get_secret_key();
let sk = sk.secret_bytes(); 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) { let msg = match hex::decode(&msg) {
Ok(v) => v, 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) { let msg_decrypt = match decrypt(&sk, &msg) {
Ok(v) => v, Ok(v) => v,
Err(e) => panic!("error decrypt content: {}", e), 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 msg_decrypt = hex::encode(msg_decrypt);
let str_decrypt = match str::from_utf8(&msg_decrypt) { let str_decrypt = match str::from_utf8(&msg_decrypt) {
Ok(v) => v, Ok(v) => v,
@ -225,4 +232,3 @@ impl Wallet {
Ok(result) Ok(result)
} }
} }