From e593b641609e74f8d158cf2d1edfbc87542d2d25 Mon Sep 17 00:00:00 2001
From: CounterFire2023 <136581895+CounterFire2023@users.noreply.github.com>
Date: Thu, 12 Oct 2023 19:30:53 +0800
Subject: [PATCH] =?UTF-8?q?=E5=A2=9E=E5=8A=A0=E4=B8=80=E4=BA=9B=E7=94=A8?=
 =?UTF-8?q?=E4=BA=8Erelay=E7=9A=84=E6=96=B9=E6=B3=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 examples/test.rs          | 10 +++++++++-
 rustwallet.h              |  6 ++++++
 src/lib.rs                | 18 ++++++++++++++++++
 src/wallet/wallet_impl.rs | 37 ++++++++++++++++++++++++++++++++-----
 4 files changed, 65 insertions(+), 6 deletions(-)

diff --git a/examples/test.rs b/examples/test.rs
index 789b7f7..35b4a54 100644
--- a/examples/test.rs
+++ b/examples/test.rs
@@ -7,7 +7,7 @@
 use rustwallet::{
     aes_decrypt, aes_encrypt, generate_sec_key, get_address, get_public_key, hash_pass_svr,
     hex_deflate, hex_inflate, keccak256_hash, local_pass_hasher, rdecrypt, rencrypt, sign,
-    sign_for_tran, wallet_decrypt, wallet_encrypt,
+    sign_for_tran, wallet_decrypt, wallet_encrypt,simple_sign,
 };
 use std::ffi::{CStr, CString};
 use std::os::raw::c_char;
@@ -139,5 +139,13 @@ fn main() {
         print_cchar!(msg_d);
         let msg_decrypted = rdecrypt(key_private, msg_encrypted);
         print_cchar!(msg_decrypted);
+        let msg = "hello world";
+        let sig = simple_sign(str_to_cchar!(msg), key_private);
+        print_cchar!(sig);
+
+        let str_1111 = "67181d63581e5506f137cfc66af17ffc8c0138238eb7fb9c2b4f424402d6c9d1";
+        let aes_key = "02aaaafbd375639879d6a694893dd14413662d90c59abaceb6cc4c791aa0834352";
+        let str_aes_plain = aes_decrypt(str_to_cchar!(str_1111), str_to_cchar!(aes_key));
+        print_cchar!(str_aes_plain);
     }
 }
diff --git a/rustwallet.h b/rustwallet.h
index 596038f..d481994 100644
--- a/rustwallet.h
+++ b/rustwallet.h
@@ -18,6 +18,8 @@ char *sign_for_tran(const char *msg_key,
 
 char *rencrypt(const char *pk, const char *msg);
 
+char *rdecrypt(const char *sk, const char *msg);
+
 char *wallet_encrypt(const char *msg_key,
                      const char *master_key,
                      const char *second_key,
@@ -45,3 +47,7 @@ char *local_pass_hasher(const char *password);
 bool verify_local_pass(const char *password, const char *pass_hash);
 
 char *generate_client_key(const char *password, const char *openid, const char *salt);
+
+char *simple_sign(const char *content, const char *key);
+
+char *ramdonKey(void);
diff --git a/src/lib.rs b/src/lib.rs
index f1c35dd..74950db 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -255,6 +255,24 @@ pub unsafe extern "C" fn generate_client_key(
     str_to_cchar!(result)
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn simple_sign(content: *const c_char, key: *const c_char) -> *mut c_char {
+    let result = wallet_impl::simple_sign(cchar_to_str!(content), cchar_to_str!(key));
+    let r = match result {
+        Ok(v) => v,
+        Err(err) => panic!("Problem sign: {:?}", err),
+    };
+    str_to_cchar!(r)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn ramdonKey() -> *mut c_char {
+    let (s_key, _p_key) = wallet_impl::generate_keypair();
+    let s_key = hex::encode(&s_key.secret_bytes());
+    let cs_key = CString::new(s_key).unwrap();
+    cs_key.into_raw()
+}
+
 unsafe fn generate_rwallet(
     msg_key: *const c_char,
     master_key: *const c_char,
diff --git a/src/wallet/wallet_impl.rs b/src/wallet/wallet_impl.rs
index ddbf63a..633dbb2 100644
--- a/src/wallet/wallet_impl.rs
+++ b/src/wallet/wallet_impl.rs
@@ -4,7 +4,7 @@ use crate::utils::{crypto_utils as crypro_utils, str_utils};
 use anyhow::Result;
 use core::fmt::Write;
 use primitive_types::{H160, H256};
-// use secp256k1::rand::rngs::OsRng;
+use secp256k1::rand::rngs::OsRng;
 use secp256k1::{Message, PublicKey, Secp256k1, SecretKey};
 use serde::{Deserialize, Serialize};
 use shamir_secret_sharing::num_bigint::BigInt;
@@ -33,10 +33,10 @@ pub fn local_pass_hasher(password: &str) -> String {
     pass_hash
 }
 
-// pub fn generate_keypair() -> (SecretKey, PublicKey) {
-//     let secp = Secp256k1::new();
-//     secp.generate_keypair(&mut OsRng)
-// }
+pub fn generate_keypair() -> (SecretKey, PublicKey) {
+    let secp = Secp256k1::new();
+    secp.generate_keypair(&mut OsRng)
+}
 
 pub fn public_key_address(public_key: &PublicKey) -> H160 {
     let public_key = public_key.serialize_uncompressed();
@@ -85,6 +85,33 @@ where
     keccak256(&eth_message).into()
 }
 
+pub fn simple_sign<S>(msg:S, key_str: S) -> Result<String>
+where
+    S: AsRef<[u8]>,
+{
+    let key_str = key_str.as_ref();
+    let key_str = str::from_utf8(key_str).expect("key_str is utf8");
+    let secret_key = SecretKey::from_str(key_str).expect("32 bytes, within curve order");
+    let secp = Secp256k1::new();
+    let message = msg.as_ref();
+    let message_hash = hash_message(message.as_ref());
+    let message_to_hash = Message::from_slice(message_hash.as_ref()).expect("32 bytes");
+    let (recovery_id, signature) = secp
+        .sign_ecdsa_recoverable(&message_to_hash, &secret_key)
+        .serialize_compact();
+
+    let mut s = hex::encode(signature);
+    let standard_v = recovery_id.to_i32() as u64 + 27;
+    let rv: u8 = standard_v
+        .try_into()
+        .expect("signature recovery in electrum notation always fits in a u8");
+    write!(s, "{:02x}", rv).unwrap();
+    let pk = get_public_key(&secret_key);
+    let address = public_key_address(&pk);
+    let result_str = format!("{:?}|{}", address, s);
+    Ok(result_str)
+}
+
 #[derive(Serialize, Deserialize, Debug)]
 pub struct Wallet {
     pub msg_key: String,