测试sss

This commit is contained in:
fitchgc 2022-10-09 07:05:43 +00:00
parent d3227072d1
commit 1ead3d4756
3 changed files with 55 additions and 55 deletions

View File

@ -6,9 +6,7 @@
use std::ffi::CStr; use std::ffi::CStr;
//use rustylib::gen::{CWallet}; //use rustylib::gen::{CWallet};
use rustwallet::{ use rustwallet::{fetch_cwallet, free_cwallet, sign, sss_sign, CWallet};
fetch_cwallet, free_cwallet, generate_cwallet, save_wallet, sign, sss_sign, CWallet,
};
fn main() { fn main() {
unsafe { unsafe {
@ -24,7 +22,9 @@ fn main() {
let fetched = fetch_cwallet(); let fetched = fetch_cwallet();
print_wallet(&fetched); print_wallet(&fetched);
sign(); sign();
sss_sign(); let sign_str = "111";
let cstr = std::ffi::CString::new(sign_str).unwrap();
sss_sign(cstr.into_raw());
// free_cwallet(wallet); // 对应 generate_cwallet() // free_cwallet(wallet); // 对应 generate_cwallet()
free_cwallet(fetched); // 对应 fetch_wallet() free_cwallet(fetched); // 对应 fetch_wallet()

View File

@ -73,28 +73,27 @@ pub unsafe extern "C" fn sign() {
Err(_) => { Err(_) => {
println!("error sign"); println!("error sign");
} }
Ok(w) => { Ok(w) => match w.sign("111") {
match w.sign("111") {
Err(err) => { Err(err) => {
println!("error sign: {:?}", err); println!("error sign: {:?}", err);
} }
Ok(sig) => { Ok(sig) => {
println!("sig result: {:?}", sig); println!("sig result: {:?}", sig);
} }
} },
}
}; };
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn sss_sign() { pub unsafe extern "C" fn sss_sign(msg: *const std::os::raw::c_char) {
let c_str = CStr::from_ptr(msg);
let str = c_str.to_str().unwrap();
match wallet_impl::Wallet::retrieve_keys("wallet.json") { match wallet_impl::Wallet::retrieve_keys("wallet.json") {
Err(_) => { Err(_) => {
println!("error sign"); println!("error sign");
} }
Ok(w) => { Ok(w) => {
w.sss_sign(); w.sss_sign(&str);
} }
}; };
} }

View File

@ -1,19 +1,19 @@
extern crate hex; extern crate hex;
use anyhow::Result; use anyhow::Result;
use secp256k1::{PublicKey, SecretKey, Message, Secp256k1}; use core::fmt::Write;
use secp256k1::rand::rngs::OsRng; use secp256k1::rand::rngs::OsRng;
use secp256k1::{Message, PublicKey, Secp256k1, SecretKey};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use shamir_secret_sharing::num_bigint::BigInt;
use shamir_secret_sharing::ShamirSecretSharing as SSS;
use std::io::BufWriter; use std::io::BufWriter;
use std::str;
use std::str::FromStr; use std::str::FromStr;
use std::{fs::OpenOptions, io::BufReader}; use std::{fs::OpenOptions, io::BufReader};
use tiny_keccak::keccak256; use tiny_keccak::keccak256;
use web3::signing::{hash_message, Key, SecretKeyRef};
use web3::types::Address; use web3::types::Address;
use web3::signing::{ hash_message, SecretKeyRef, Key };
use std::str;
use core::fmt::Write;
use shamir_secret_sharing::num_bigint::BigInt;
use shamir_secret_sharing::ShamirSecretSharing as SSS;
pub fn generate_keypair() -> (SecretKey, PublicKey) { pub fn generate_keypair() -> (SecretKey, PublicKey) {
let secp = Secp256k1::new(); let secp = Secp256k1::new();
@ -29,7 +29,6 @@ pub fn public_key_address(public_key: &PublicKey) -> Address {
Address::from_slice(&hash[12..]) Address::from_slice(&hash[12..])
} }
#[derive(Serialize, Deserialize, Debug)] #[derive(Serialize, Deserialize, Debug)]
pub struct Wallet { pub struct Wallet {
pub secret_key: String, pub secret_key: String,
@ -41,13 +40,9 @@ impl Wallet {
pub fn new(secret_key: &SecretKey, public_key: &PublicKey) -> Self { pub fn new(secret_key: &SecretKey, public_key: &PublicKey) -> Self {
let addr: Address = public_key_address(&public_key); let addr: Address = public_key_address(&public_key);
println!("secret key: {:?}", secret_key); println!("secret key: {:?}", secret_key);
let mut s = String::with_capacity(2 * 32); let s = hex::encode(&secret_key.serialize_secret());
for i in &secret_key.serialize_secret() {
write!(s, "{:02x}", *i).unwrap();
}
println!("{:?}", s); println!("{:?}", s);
Wallet { Wallet {
secret_key: s, secret_key: s,
public_key: public_key.to_string(), public_key: public_key.to_string(),
@ -61,7 +56,6 @@ impl Wallet {
.create(true) .create(true)
.open(file_path)?; .open(file_path)?;
let buf_writer = BufWriter::new(file); let buf_writer = BufWriter::new(file);
serde_json::to_writer_pretty(buf_writer, self)?; serde_json::to_writer_pretty(buf_writer, self)?;
Ok(()) Ok(())
@ -70,20 +64,22 @@ impl Wallet {
pub fn retrieve_keys(file_path: &str) -> Result<Wallet> { pub fn retrieve_keys(file_path: &str) -> Result<Wallet> {
let file = OpenOptions::new().read(true).open(file_path)?; let file = OpenOptions::new().read(true).open(file_path)?;
let buf_reader = BufReader::new(file); let buf_reader = BufReader::new(file);
let wallet: Wallet = serde_json::from_reader(buf_reader)?; let wallet: Wallet = serde_json::from_reader(buf_reader)?;
Ok(wallet) Ok(wallet)
} }
pub fn sss_sign(&self) { pub fn sss_sign(&self, msg: &str) {
let k_hash = keccak256(msg.as_bytes());
println!("k_hash: {:?}", &k_hash);
let s = hex::encode(&k_hash);
println!("k_hash str: {:?}", &s);
println!("k_hash byte: {:?}", &s.as_bytes());
let pb = BigInt::parse_bytes(&s.as_bytes(), 16).unwrap();
let sss = SSS { let sss = SSS {
threshold: 2, threshold: 2,
share_amount: 3, share_amount: 3,
prime: BigInt::parse_bytes( prime: pb,
b"fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f",
16,
)
.unwrap(),
}; };
let secret = BigInt::parse_bytes( let secret = BigInt::parse_bytes(
@ -109,7 +105,8 @@ impl Wallet {
pub fn sign<S>(&self, msg: S) -> Result<()> pub fn sign<S>(&self, msg: S) -> Result<()>
where where
S: AsRef<[u8]>,{ S: AsRef<[u8]>,
{
let secp = Secp256k1::new(); let secp = Secp256k1::new();
println!("secret key str: {:?}", self.secret_key); println!("secret key str: {:?}", self.secret_key);
let message = msg.as_ref(); let message = msg.as_ref();
@ -118,7 +115,9 @@ impl Wallet {
println!("secret key: {:?}", pk); println!("secret key: {:?}", pk);
let key = SecretKeyRef::new(&pk); let key = SecretKeyRef::new(&pk);
let signature = key.sign(message_hash.as_bytes(), None).expect("hash is non-zero 32-bytes; qed"); let signature = key
.sign(message_hash.as_bytes(), None)
.expect("hash is non-zero 32-bytes; qed");
let v = signature let v = signature
.v .v
.try_into() .try_into()
@ -137,20 +136,22 @@ impl Wallet {
bytes.extend_from_slice(signature.s.as_bytes()); bytes.extend_from_slice(signature.s.as_bytes());
bytes.push(v); bytes.push(v);
let mut str_sign = String::with_capacity(2 * 65); let str_sign = hex::encode(bytes);
for i in bytes.iter() {
write!(str_sign, "{:02x}", i).unwrap();
}
println!("web3 sign: {:?}", str_sign); println!("web3 sign: {:?}", str_sign);
let message_to_hash = Message::from_slice(message_hash.as_ref()).unwrap(); let message_to_hash = Message::from_slice(message_hash.as_ref()).unwrap();
let (recovery_id, signature) = secp.sign_ecdsa_recoverable(&message_to_hash, &pk).serialize_compact(); let (recovery_id, signature) = secp
let mut s = String::with_capacity(2 * 65); .sign_ecdsa_recoverable(&message_to_hash, &pk)
for i in signature { .serialize_compact();
write!(s, "{:02x}", i).unwrap(); // let mut s = String::with_capacity(2 * 65);
} // for i in signature {
// write!(s, "{:02x}", i).unwrap();
// }
let mut s = hex::encode(signature);
let standard_v = recovery_id.to_i32() as u64 + 27; 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"); let rv: u8 = standard_v
.try_into()
.expect("signature recovery in electrum notation always fits in a u8");
write!(s, "{:02x}", rv).unwrap(); write!(s, "{:02x}", rv).unwrap();
println!("normal sigx: {:?}", s); println!("normal sigx: {:?}", s);