4nk/sdk_client
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

User creation + login

Browse Source
This commit is contained in:
Sosthene00 2024-04-02 14:19:25 +02:00
parent 162cdd49af
commit 030cc0231a
5 changed files with 128 additions and 199 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
crates/sp_client/src/Prd_list.rs
View File

@ -1,14 +1,12 @@
use sp_backend::bitcoin::PublicKey;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use serde_json::{json, Value}; use serde_json::{json, Value};
use sp_backend::bitcoin::PublicKey;
//use sp_backend::silentpayments::sending::SilentPaymentAddress; //use sp_backend::silentpayments::sending::SilentPaymentAddress;
use std::marker::Copy;
use tsify::Tsify; use tsify::Tsify;
use wasm_bindgen::prelude::*; use wasm_bindgen::prelude::*;
use std::marker::Copy;
#[wasm_bindgen] #[wasm_bindgen]
#[derive(Debug, Default, Serialize, Deserialize, Clone, PartialEq, Copy)] #[derive(Debug, Default, Serialize, Deserialize, Clone, PartialEq, Copy)]
pub enum Role { pub enum Role {
Manager, Manager,
@ -18,27 +16,26 @@ pub enum Role {
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)] #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
pub struct SilentPaymentAddress { pub struct SilentPaymentAddress {
version : u8, version: u8,
scan_pubkey : PublicKey, scan_pubkey: PublicKey,
m_pubkey : PublicKey, m_pubkey: PublicKey,
is_testnet : bool, is_testnet: bool,
} }
#[derive(Debug, Copy, Clone)] #[derive(Debug, Copy, Clone)]
pub struct ItemMember { pub struct ItemMember {
pub role : Role, pub role: Role,
pub sp_address: SilentPaymentAddress, pub sp_address: SilentPaymentAddress,
//pre_id: hash(password, part1) //pre_id: hash(password, part1)
//shard, //shard,
//priv_key_mainnet_spend, (enc) //priv_key_mainnet_spend, (enc)
//priv_key_mainnet_scan, //priv_key_mainnet_scan,
//priv_key_signet_scan, //priv_key_signet_scan,
} }
impl ItemMember { impl ItemMember {
pub fn new(role: Role, sp_address: SilentPaymentAddress) -> Self { pub fn new(role: Role, sp_address: SilentPaymentAddress) -> Self {
ItemMember {role, sp_address} ItemMember { role, sp_address }
} }
} }
@ -46,38 +43,31 @@ impl ItemMember {
pub struct Prdlist { pub struct Prdlist {
//pub id: String, //pub id: String,
//pub version: String, //pub version: String,
pub gestionnaires: Vec<ItemMember>, pub gestionnaires: Vec<ItemMember>,
// pub gestionnaires: Box<Vec<ItemMember>>, // pub gestionnaires: Box<Vec<ItemMember>>,
} }
#[derive(Serialize)] #[derive(Serialize)]
#[wasm_bindgen] #[wasm_bindgen]
struct RequestBody { struct RequestBody {
message: String, message: String,
} }
pub fn send_PrdRequest(prdlist: &Prdlist) -> Result<(), JsValue> { pub fn send_PrdRequest(prdlist: &Prdlist) -> Result<(), JsValue> {
let managers: Vec<&ItemMember> = prdlist.gestionnaires.iter().filter(|m| m.role == Role::Manager).collect(); let managers: Vec<&ItemMember> = prdlist
.gestionnaires
.iter()
.filter(|m| m.role == Role::Manager)
.collect();
for manager in managers { for manager in managers {
let request_body = RequestBody { let request_body = RequestBody {
message: "Asking for the Prd list".to_string(), message: "Asking for the Prd list".to_string(),
}; };
let json_body = serde_json::to_string(&request_body).map_err(|e| JsValue::from_str(&format!("Failed to serialize request body: {:?}", e)))?; let json_body = serde_json::to_string(&request_body).map_err(|e| {
JsValue::from_str(&format!("Failed to serialize request body: {:?}", e))
})?;
println!("Sending request to manager {:?}", manager.sp_address); println!("Sending request to manager {:?}", manager.sp_address);
} }
Ok(()) Ok(())
} }

45
crates/sp_client/src/api.rs
View File

@ -128,20 +128,21 @@ pub fn get_receiving_address(sp_client: String) -> String {
#[wasm_bindgen] #[wasm_bindgen]
pub fn create_user( pub fn create_user(
password: String, password: String, // Attention à la conversion depuis le js
label: Option<String>, label: Option<String>,
birthday: u32, birthday_main: u32,
birthday_signet: u32,
process: String, process: String,
) -> ApiResult<createUserReturn> { ) -> ApiResult<createUserReturn> {
let mut output_list: Vec<OutputList> = Vec::new(); let mut output_list: Vec<OutputList> = Vec::new();
//recover //recover
let sp_wallet_recover = generate_sp_wallet(label.clone(), birthday, true)?; let sp_wallet_recover = generate_sp_wallet(label.clone(), birthday_signet, true)?;
output_list.push(sp_wallet_recover.sp_outputs); output_list.push(sp_wallet_recover.sp_outputs);
//revoke //revoke
let sp_wallet_revoke = generate_sp_wallet(label.clone(), birthday, true)?; let sp_wallet_revoke = generate_sp_wallet(label.clone(), birthday_signet, true)?;
output_list.push(sp_wallet_revoke.sp_outputs); output_list.push(sp_wallet_revoke.sp_outputs);
//mainet //mainet
let sp_wallet_main = generate_sp_wallet(label, birthday, false)?; let sp_wallet_main = generate_sp_wallet(label, birthday_main, false)?;
output_list.push(sp_wallet_main.sp_outputs); output_list.push(sp_wallet_main.sp_outputs);
let user_keys = UserKeys::new( let user_keys = UserKeys::new(
@ -195,3 +196,37 @@ pub fn get_processes() -> ApiResult<get_process_return> {
data_process.push(process3); data_process.push(process3);
Ok(get_process_return(data_process)) Ok(get_process_return(data_process))
} }
#[derive(Debug, Tsify, Serialize, Deserialize)]
#[tsify(from_wasm_abi)]
#[allow(non_camel_case_types)]
pub struct recover_data(Vec<u8>);
impl recover_data {
fn as_inner(&self) -> &[u8] {
&self.0
}
}
#[derive(Debug, Tsify, Serialize, Deserialize)]
#[tsify(from_wasm_abi)]
#[allow(non_camel_case_types)]
pub struct shamir_shares(Vec<Vec<u8>>);
impl shamir_shares {
fn as_inner(&self) -> &[Vec<u8>] {
&self.0
}
}
#[wasm_bindgen]
pub fn login_user(
user_password: String,
pre_id: String,
recover: recover_data,
shares: shamir_shares,
) -> ApiResult<()> {
let res = User::login(pre_id, user_password, recover.as_inner(), shares.as_inner())?;
Ok(res)
}

8
crates/sp_client/src/lib.rs
View File

@ -1,8 +1,8 @@
#![allow(warnings)] #![allow(warnings)]
mod Prd_list;
mod aesgcm;
pub mod api; pub mod api;
mod injecteurhtml; mod injecteurhtml;
mod user; mod peers;
mod aesgcm;
mod Prd_list;
mod process; mod process;
mod user;

9
crates/sp_client/src/peers.rs Normal file
View File

@ -0,0 +1,9 @@
use std::net::SocketAddr;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Peer {
pub addr: SocketAddr,
pub processes: Vec<String>,
}

209
crates/sp_client/src/user.rs
View File

@ -16,7 +16,6 @@ use sp_backend::bitcoin::secp256k1::ThirtyTwoByteHash;
use tsify::Tsify; use tsify::Tsify;
use wasm_bindgen::prelude::*; use wasm_bindgen::prelude::*;
use bytes::Bytes;
use shamir::SecretData; use shamir::SecretData;
use std::collections::HashMap; use std::collections::HashMap;
use std::fs::File; use std::fs::File;
@ -37,10 +36,14 @@ use img_parts::{ImageEXIF, ImageICC};
use crate::aesgcm::Aes256Decryption; use crate::aesgcm::Aes256Decryption;
use crate::aesgcm::HalfKey; use crate::aesgcm::HalfKey;
use crate::aesgcm::{Aes256Encryption, Purpose}; use crate::aesgcm::{Aes256Encryption, Purpose};
use crate::peers::Peer;
use crate::user; use crate::user;
type PreId = String; type PreId = String;
const MANAGERS_NUMBER: u8 = 10;
const QUORUM_SHARD: f32 = 0.8;
pub static CONNECTED_USERS: OnceLock<Mutex<HashMap<PreId, UserKeys>>> = OnceLock::new(); pub static CONNECTED_USERS: OnceLock<Mutex<HashMap<PreId, UserKeys>>> = OnceLock::new();
#[derive(Debug, Clone, Serialize, Deserialize)] #[derive(Debug, Clone, Serialize, Deserialize)]
@ -67,11 +70,12 @@ impl UserKeys {
#[derive(Debug, Serialize, Deserialize, Clone, Tsify)] #[derive(Debug, Serialize, Deserialize, Clone, Tsify)]
#[tsify(into_wasm_abi, from_wasm_abi)] #[tsify(into_wasm_abi, from_wasm_abi)]
pub struct User { pub struct User {
pub pre_id: String, pub pre_id: PreId,
pub process: String, pub processes: Vec<String>,
pub peers: Vec<Peer>,
recover_data: Vec<u8>, recover_data: Vec<u8>,
revoke_data: Option<Vec<u8>>, revoke_data: Option<Vec<u8>>,
sharding: Sharding, shares: Vec<Vec<u8>>,
} }
impl User { impl User {
@ -143,7 +147,18 @@ impl User {
let cipher_recover_part2 = part2_encryption.encrypt_with_aes_key()?; let cipher_recover_part2 = part2_encryption.encrypt_with_aes_key()?;
//create shardings //create shardings
let sharding = Sharding::new(&cipher_recover_part2.to_lower_hex_string(), 10u8); //nMembers = 10 for testing, need to recover nmember elsewhere let threshold = (MANAGERS_NUMBER as f32 * QUORUM_SHARD).floor();
debug_assert!(threshold > 0.0 && threshold <= u8::MAX as f32);
let sharding = shamir::SecretData::with_secret(
&cipher_recover_part2.to_lower_hex_string(),
threshold as u8,
);
let shares: Vec<Vec<u8>> = (1..MANAGERS_NUMBER)
.map(|x| {
sharding.get_share(x).unwrap() // Let's trust it for now
})
.collect();
//scan key: //scan key:
let mut engine = sha256::HashEngine::default(); let mut engine = sha256::HashEngine::default();
@ -171,10 +186,11 @@ impl User {
Ok(User { Ok(User {
pre_id: pre_id.to_string(), pre_id: pre_id.to_string(),
process, processes: vec![process],
peers: vec![],
recover_data, recover_data,
revoke_data: Some(revoke_data), revoke_data: Some(revoke_data),
sharding, shares,
}) })
} }
@ -182,7 +198,7 @@ impl User {
pre_id: PreId, pre_id: PreId,
user_password: String, user_password: String,
recover_data: &[u8], recover_data: &[u8],
sharding: Sharding, shares: &[Vec<u8>],
) -> Result<()> { ) -> Result<()> {
let mut retrieved_spend_key = [0u8; 32]; let mut retrieved_spend_key = [0u8; 32];
let mut retrieved_scan_key = [0u8; 32]; let mut retrieved_scan_key = [0u8; 32];
@ -228,13 +244,10 @@ impl User {
part1_ciphertext.to_vec(), part1_ciphertext.to_vec(),
)?); )?);
//@todo: get shardings from member managers!
let shardings = sharding.shares_vec.clone(); // temporary
retrieved_spend_key[16..].copy_from_slice(&Self::recover_part2( retrieved_spend_key[16..].copy_from_slice(&Self::recover_part2(
&user_password, &user_password,
&entropy2, &entropy2,
shardings, shares,
)?); )?);
retrieved_scan_key.copy_from_slice(&Self::recover_key_slice( retrieved_scan_key.copy_from_slice(&Self::recover_key_slice(
@ -309,17 +322,17 @@ impl User {
aes_dec.decrypt_with_key() aes_dec.decrypt_with_key()
} }
fn recover_part2(password: &str, entropy: &[u8], shares_vec: Vec<Vec<u8>>) -> Result<Vec<u8>> { fn recover_part2(password: &str, entropy: &[u8], shares: &[Vec<u8>]) -> Result<Vec<u8>> {
let mut engine = sha256::HashEngine::default(); let mut engine = sha256::HashEngine::default();
engine.write_all(&password.as_bytes()); engine.write_all(&password.as_bytes());
engine.write_all(&entropy); engine.write_all(&entropy);
let hash = sha256::Hash::from_engine(engine); let hash = sha256::Hash::from_engine(engine);
let shares_total: f32 = u8::try_from(shares_vec.len())?.try_into()?; let threshold = (MANAGERS_NUMBER as f32 * QUORUM_SHARD).floor();
let quorum_sharding: u8 = (Sharding::QUORUM_SHARD * shares_total).round() as u8; debug_assert!(threshold > 0.0 && threshold <= u8::MAX as f32);
let part2_key_enc = Vec::from_hex( let part2_key_enc = Vec::from_hex(
&SecretData::recover_secret(quorum_sharding, shares_vec) &SecretData::recover_secret(threshold as u8, shares.to_vec())
.ok_or_else(|| anyhow::Error::msg("Failed to retrieve the sharded secret"))?, .ok_or_else(|| anyhow::Error::msg("Failed to retrieve the sharded secret"))?,
)?; )?;
@ -356,141 +369,27 @@ impl User {
// sha_256(&password_hash) // sha_256(&password_hash)
// } // }
// Test sharing JS side // // Test sharing JS side
pub fn get_shares(&self) -> Vec<String> { // pub fn get_shares(&self) -> Vec<String> {
self.sharding.shares_format_str.clone() // self.sharding.shares_format_str.clone()
} // }
//Test sharing Js side // //Test sharing Js side
pub fn get_secret(&self, shardings: Vec<String>) -> String { // pub fn get_secret(&self, shardings: Vec<String>) -> String {
let mut shares_vec = Vec::new(); // let mut shares_vec = Vec::new();
for s in shardings.iter() { // for s in shardings.iter() {
let bytes_vec: Vec<u8> = s // let bytes_vec: Vec<u8> = s
.trim_matches(|c| c == '[' || c == ']') // .trim_matches(|c| c == '[' || c == ']')
.split(',') // .split(',')
.filter_map(|s| s.trim().parse().ok()) // .filter_map(|s| s.trim().parse().ok())
.collect(); // .collect();
shares_vec.push(bytes_vec); // shares_vec.push(bytes_vec);
} // }
self.sharding.recover_secrete(shares_vec.clone()) // self.sharding.recover_secrete(shares_vec.clone())
} // }
} }
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum BackUpImage {
Recover(Vec<u8>),
Revoke(Vec<u8>),
}
impl BackUpImage {
pub fn new_recover(image: &[u8], data: &[u8]) -> Result<Self> {
let img = write_exif(image, data)?;
Ok(Self::Recover(img))
}
pub fn new_revoke(image: &[u8], data: &[u8]) -> Result<Self> {
let img = write_exif(image, data)?;
Ok(Self::Revoke(img))
}
}
#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct Sharding {
shares_vec: Vec<Vec<u8>>,
shares_format_str: Vec<String>,
}
impl Sharding {
const QUORUM_SHARD: f32 = 0.80_f32;
pub fn new(part2_key_enc: &str, number_members: u8) -> Self {
let secret_data = SecretData::with_secret(part2_key_enc, number_members);
let mut shares_format_str: Vec<String> = Vec::new();
let shares_vec = (1..=number_members)
.map(|i| match secret_data.get_share(i) {
Ok(share) => {
let string = format!(
"[{}]",
share
.clone()
.iter()
.map(|b| format!("{}", b))
.collect::<Vec<_>>()
.join(",")
);
shares_format_str.push(string.clone());
share
}
Err(_) => panic!("Not able to recover the shares!"),
})
.collect::<Vec<_>>();
Sharding {
shares_vec,
shares_format_str,
}
}
pub fn recover_secrete(&self, shares: Vec<Vec<u8>>) -> String {
let quorum_sharding = (Self::QUORUM_SHARD * f32::from(shares.len() as u8)).round() as u8;
SecretData::recover_secret(quorum_sharding, shares).unwrap()
}
}
pub fn write_exif(image_to_recover: &[u8], data: &[u8]) -> Result<Vec<u8>> {
let mut jpeg = Jpeg::from_bytes(Bytes::from(image_to_recover.to_vec()))?;
let data_bytes = Bytes::from(data.to_owned());
jpeg.set_exif(Some(data_bytes));
let output_image_bytes = jpeg.encoder().bytes();
let output_image = output_image_bytes.to_vec();
Ok(output_image)
}
pub fn read_exif(image: &[u8]) -> Result<Vec<u8>, String> {
let image_bytes = Bytes::from(image.to_vec());
let jpeg = Jpeg::from_bytes(image_bytes).unwrap();
//exif out
let mut exif_image = Bytes::new();
if let Some(ref meta) = jpeg.exif() {
exif_image = meta.clone();
} else {
return Err("No exif data".to_string());
}
let exif_bytes = exif_image.as_ref();
Ok(exif_bytes.to_vec())
}
// //change for return Result?
// pub fn from_hex_to_b58(hex_string: &str) -> String {
// let decoded_data = hex::decode(hex_string).expect("Failed to decode hex string");
// let base58_string = bs58::encode(decoded_data).into_string();
// base58_string
// }
// //change for return Result?
// pub fn from_b58_to_hex(base58_string: &str) -> String {
// let decoded_data = bs58::decode(base58_string.to_owned()).into_vec().unwrap();
// let hex_string = decoded_data
// .iter()
// .map(|b| format!("{:02x}", b))
// .collect::<String>();
// hex_string
// }
// fn from_b64_to_hex(base64_string: &str) -> String {
// let decoded_data = base64::decode(base64_string).unwrap();
// let hex_string = decoded_data
// .iter()
// .map(|b| format!("{:02x}", b))
// .collect::<String>();
// hex_string
// }
// fn from_hex_to_b64(hex_string: &str) -> String {
// let decoded_data = hex::decode(hex_string).expect("Failed to decode hex string");
// let base64_string = base64::encode(decoded_data);
// base64_string
// }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; // Import everything from the outer module use super::*; // Import everything from the outer module
@ -550,22 +449,18 @@ mod tests {
let user_keys = helper_create_user_keys(); let user_keys = helper_create_user_keys();
let user = User::new(user_keys, USER_PASSWORD.to_owned(), PROCESS.to_owned()).unwrap(); let user = User::new(user_keys, USER_PASSWORD.to_owned(), PROCESS.to_owned()).unwrap();
let pre_id = user.pre_id; let res = User::login(
let recover_data = user.recover_data; user.pre_id.clone(),
let sharding = user.sharding;
let retrieved_recover_spend = User::login(
pre_id.clone(),
USER_PASSWORD.to_owned(), USER_PASSWORD.to_owned(),
&recover_data, &user.recover_data,
sharding, &user.shares,
); );
assert!(retrieved_recover_spend.is_ok()); assert!(res.is_ok());
let connected = CONNECTED_USERS.get().unwrap().lock().unwrap(); let connected = CONNECTED_USERS.get().unwrap().lock().unwrap();
let recover = &connected.get(&pre_id).unwrap().recover; let recover = &connected.get(&user.pre_id).unwrap().recover;
assert!( assert!(
format!( format!(