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

crypto simplification

Browse Source
This commit is contained in:
Sosthene00 2024-04-30 11:23:47 +02:00 committed by Sosthene
parent b1bfe0ba22
commit a59c680d0e
1 changed files with 85 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

185
src/crypto.rs
View File

@ -4,9 +4,7 @@ use anyhow::{Error, Result};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use sp_client::{ use sp_client::{
bitcoin::{ bitcoin::{
key::constants::SECRET_KEY_SIZE, hex::{DisplayHex, FromHex}, key::constants::SECRET_KEY_SIZE, secp256k1::{ecdh::SharedSecret, PublicKey}, Txid
secp256k1::{ecdh::SharedSecret, PublicKey},
Txid,
}, },
silentpayments::{ silentpayments::{
bitcoin_hashes::{sha256t_hash_newtype, Hash, HashEngine}, bitcoin_hashes::{sha256t_hash_newtype, Hash, HashEngine},
@ -45,18 +43,21 @@ impl SharedPoint {
#[derive(Debug, Serialize, Deserialize, Tsify, Clone)] #[derive(Debug, Serialize, Deserialize, Tsify, Clone)]
#[tsify(from_wasm_abi, into_wasm_abi)] #[tsify(from_wasm_abi, into_wasm_abi)]
pub struct AnkSharedSecret { pub struct AnkSharedSecret {
secret: [u8; 32], secret: String,
pub trusted: bool, pub trusted: bool,
} }
impl AnkSharedSecret { impl AnkSharedSecret {
pub fn new(shared_point: [u8; 64], trusted: bool) -> Self { pub fn new(shared_point: [u8; 64], trusted: bool) -> Self {
let secret = AnkSharedSecretHash::from_shared_point(shared_point).to_byte_array(); let secret = AnkSharedSecretHash::from_shared_point(shared_point).to_byte_array();
Self { secret, trusted } Self { secret: secret.to_lower_hex_string(), trusted }
} }
pub fn to_byte_array(&self) -> [u8; 32] { pub fn to_byte_array(&self) -> [u8; 32] {
self.secret let bytes = Vec::from_hex(&self.secret).unwrap();
let mut buf = [0u8;32];
buf.copy_from_slice(&bytes);
buf
} }
} }
@ -121,32 +122,8 @@ impl Aes256Decryption {
pub fn new( pub fn new(
purpose: Purpose, purpose: Purpose,
cipher_text: CipherText, cipher_text: CipherText,
encrypted_aes_key: Vec<u8>, // If shared_secret is none this is actually the aes_key aes_key: [u8;32],
shared_secret: Option<SharedSecret>, // We don't need that for certain purpose, like Login
) -> Result<Self> { ) -> Result<Self> {
let mut aes_key = [0u8; 32];
if let Some(shared_secret) = shared_secret {
if encrypted_aes_key.len() <= 12 {
return Err(Error::msg("encrypted_aes_key is shorter than nonce length"));
} // Actually we could probably test that if the remnant is not a multiple of 32, something's wrong
// take the first 12 bytes form encrypted_aes_key as nonce
let (decrypt_key_nonce, encrypted_key) = encrypted_aes_key.split_at(12);
// decrypt key with shared_secret obtained from transaction
let decrypt_key_cipher = Aes256Gcm::new_from_slice(shared_secret.as_ref())
.map_err(|e| Error::msg(format!("{}", e)))?;
let aes_key_plain = decrypt_key_cipher
.decrypt(decrypt_key_nonce.into(), encrypted_key)
.map_err(|e| Error::msg(format!("{}", e)))?;
if aes_key_plain.len() != 32 {
return Err(Error::msg("Invalid length for decrypted key"));
}
aes_key.copy_from_slice(&aes_key_plain);
} else {
if encrypted_aes_key.len() != 32 {
return Err(Error::msg("Invalid length for decrypted key"));
}
aes_key.copy_from_slice(&encrypted_aes_key);
}
if cipher_text.len() <= 12 { if cipher_text.len() <= 12 {
return Err(Error::msg("cipher_text is shorter than nonce length")); return Err(Error::msg("cipher_text is shorter than nonce length"));
} }
@ -244,7 +221,7 @@ impl Aes256Encryption {
for (_, sp_address2shared_secret) in self.shared_secrets.iter() { for (_, sp_address2shared_secret) in self.shared_secrets.iter() {
for (sp_address, shared_secret) in sp_address2shared_secret { for (sp_address, shared_secret) in sp_address2shared_secret {
let cipher = Aes256Gcm::new_from_slice(&shared_secret.secret) let cipher = Aes256Gcm::new_from_slice(&shared_secret.to_byte_array())
.map_err(|e| Error::msg(format!("{}", e)))?; .map_err(|e| Error::msg(format!("{}", e)))?;
let nonce = Aes256Gcm::generate_nonce(&mut rng); let nonce = Aes256Gcm::generate_nonce(&mut rng);
let encrypted_key = cipher let encrypted_key = cipher
@ -329,7 +306,7 @@ impl Aes256Encryption {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use std::str::FromStr; use std::{io::Read, str::FromStr};
use sp_client::bitcoin::hex::FromHex; use sp_client::bitcoin::hex::FromHex;
@ -394,7 +371,7 @@ mod tests {
plain_key.copy_from_slice(&aes_key.to_vec()); plain_key.copy_from_slice(&aes_key.to_vec());
let aes_dec = let aes_dec =
Aes256Decryption::new(Purpose::Login, cipher.unwrap(), plain_key.to_vec(), None); Aes256Decryption::new(Purpose::Login, cipher.unwrap(), plain_key);
assert!(aes_dec.is_ok()); assert!(aes_dec.is_ok());
} }
@ -412,7 +389,7 @@ mod tests {
buf.copy_from_slice(&alice_secret); buf.copy_from_slice(&alice_secret);
sp_address2shared_secrets.insert( sp_address2shared_secrets.insert(
ALICE_SP_ADDRESS.try_into().unwrap(), ALICE_SP_ADDRESS.try_into().unwrap(),
AnkSharedSecret { secret: buf, trusted: true } AnkSharedSecret { secret: buf.to_lower_hex_string(), trusted: true }
); );
shared_secrets.insert( shared_secrets.insert(
Txid::from_str(TRANSACTION).unwrap(), Txid::from_str(TRANSACTION).unwrap(),
@ -434,93 +411,101 @@ mod tests {
assert!(ciphertext.is_ok()); assert!(ciphertext.is_ok());
let aes_dec = Aes256Decryption::new( let decrypt_key = Aes256Decryption::new(
Purpose::Login, Purpose::Arbitrary,
ciphertext.unwrap(),
encrypted_key.unwrap(), encrypted_key.unwrap(),
Some(SharedSecret::from_str(ALICE_SHARED_SECRET).unwrap()), SharedSecret::from_str(ALICE_SHARED_SECRET).unwrap().secret_bytes(),
); );
assert!(aes_dec.is_ok()); assert!(decrypt_key.is_ok());
let retrieved_plain = aes_dec.unwrap().decrypt_with_key(); let mut retrieved_key = [0u8;32];
retrieved_key.copy_from_slice(&decrypt_key.unwrap().decrypt_with_key().unwrap());
let decrypt_msg = Aes256Decryption::new(
Purpose::Arbitrary,
ciphertext.unwrap(),
retrieved_key
);
let retrieved_plain = decrypt_msg.unwrap().decrypt_with_key();
assert!(retrieved_plain.is_ok()); assert!(retrieved_plain.is_ok());
assert!(retrieved_plain.unwrap() == plaintext); assert!(retrieved_plain.unwrap() == plaintext);
} }
#[test] // #[test]
fn aes_encrypt_key_many() { // fn aes_encrypt_key_many() {
let plaintext = [1u8; THIRTYTWO]; // let plaintext = [1u8; THIRTYTWO];
let mut aes_enc = // let mut aes_enc =
Aes256Encryption::new(Purpose::ThirtyTwoBytes, plaintext.to_vec()).unwrap(); // Aes256Encryption::new(Purpose::ThirtyTwoBytes, plaintext.to_vec()).unwrap();
let mut shared_secrets: HashMap<Txid, _> = HashMap::new(); // let mut shared_secrets: HashMap<Txid, _> = HashMap::new();
let mut sp_address2shared_secrets: HashMap<SilentPaymentAddress, AnkSharedSecret> = // let mut sp_address2shared_secrets: HashMap<SilentPaymentAddress, AnkSharedSecret> =
HashMap::new(); // HashMap::new();
let alice_secret = Vec::from_hex(ALICE_SHARED_SECRET).unwrap(); // let alice_secret = Vec::from_hex(ALICE_SHARED_SECRET).unwrap();
let mut buf = [0u8;32]; // let mut buf = [0u8;32];
buf.copy_from_slice(&alice_secret); // buf.copy_from_slice(&alice_secret);
sp_address2shared_secrets.insert( // sp_address2shared_secrets.insert(
ALICE_SP_ADDRESS.try_into().unwrap(), // ALICE_SP_ADDRESS.try_into().unwrap(),
AnkSharedSecret { secret: buf, trusted: true } // AnkSharedSecret { secret: buf, trusted: true }
); // );
let bob_secret = Vec::from_hex(BOB_SHARED_SECRET).unwrap(); // let bob_secret = Vec::from_hex(BOB_SHARED_SECRET).unwrap();
let mut buf = [0u8;32]; // let mut buf = [0u8;32];
buf.copy_from_slice(&bob_secret); // buf.copy_from_slice(&bob_secret);
sp_address2shared_secrets.insert( // sp_address2shared_secrets.insert(
BOB_SP_ADDRESS.try_into().unwrap(), // BOB_SP_ADDRESS.try_into().unwrap(),
AnkSharedSecret { secret: buf, trusted: true } // AnkSharedSecret { secret: buf, trusted: true }
); // );
shared_secrets.insert( // shared_secrets.insert(
Txid::from_str(TRANSACTION).unwrap(), // Txid::from_str(TRANSACTION).unwrap(),
sp_address2shared_secrets, // sp_address2shared_secrets,
); // );
aes_enc.set_shared_secret(shared_secrets); // aes_enc.set_shared_secret(shared_secrets);
let mut sp_address2encrypted_keys = aes_enc.encrypt_keys_with_shared_secrets(); // let mut sp_address2encrypted_keys = aes_enc.encrypt_keys_with_shared_secrets();
assert!(sp_address2encrypted_keys.is_ok()); // assert!(sp_address2encrypted_keys.is_ok());
// Alice // // Alice
let encrypted_key = sp_address2encrypted_keys // let encrypted_key = sp_address2encrypted_keys
.as_mut() // .as_mut()
.unwrap() // .unwrap()
.get(&ALICE_SP_ADDRESS.try_into().unwrap()) // .get(&ALICE_SP_ADDRESS.try_into().unwrap())
.cloned(); // .cloned();
let ciphertext = aes_enc.encrypt_with_aes_key(); // let ciphertext = aes_enc.encrypt_with_aes_key();
let aes_dec = Aes256Decryption::new( // let aes_dec = Aes256Decryption::new(
Purpose::ThirtyTwoBytes, // Purpose::ThirtyTwoBytes,
ciphertext.unwrap(), // ciphertext.unwrap(),
encrypted_key.unwrap(), // encrypted_key.unwrap(),
Some(SharedSecret::from_str(ALICE_SHARED_SECRET).unwrap()), // Some(SharedSecret::from_str(ALICE_SHARED_SECRET).unwrap()),
); // );
let retrieved_plain = aes_dec.unwrap().decrypt_with_key(); // let retrieved_plain = aes_dec.unwrap().decrypt_with_key();
assert!(retrieved_plain.unwrap() == plaintext); // assert!(retrieved_plain.unwrap() == plaintext);
// Bob // // Bob
let encrypted_key = sp_address2encrypted_keys // let encrypted_key = sp_address2encrypted_keys
.unwrap() // .unwrap()
.get(&BOB_SP_ADDRESS.try_into().unwrap()) // .get(&BOB_SP_ADDRESS.try_into().unwrap())
.cloned(); // .cloned();
let ciphertext = aes_enc.encrypt_with_aes_key(); // let ciphertext = aes_enc.encrypt_with_aes_key();
let aes_dec = Aes256Decryption::new( // let aes_dec = Aes256Decryption::new(
Purpose::ThirtyTwoBytes, // Purpose::ThirtyTwoBytes,
ciphertext.unwrap(), // ciphertext.unwrap(),
encrypted_key.unwrap(), // encrypted_key.unwrap(),
Some(SharedSecret::from_str(BOB_SHARED_SECRET).unwrap()), // Some(SharedSecret::from_str(BOB_SHARED_SECRET).unwrap()),
); // );
let retrieved_plain = aes_dec.unwrap().decrypt_with_key(); // let retrieved_plain = aes_dec.unwrap().decrypt_with_key();
assert!(retrieved_plain.unwrap() == plaintext); // assert!(retrieved_plain.unwrap() == plaintext);
} // }
} }