cleanup crypto
This commit is contained in:
Sosthene
parent
3cbe77c143
commit
bbc9eaa962
386
src/crypto.rs
386
src/crypto.rs
@ -1,20 +1,5 @@
|
||||
use std::collections::HashMap;
|
||||
|
||||
use anyhow::{Error, Result};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use sp_client::{
|
||||
bitcoin::{
|
||||
hex::{DisplayHex, FromHex},
|
||||
key::constants::SECRET_KEY_SIZE,
|
||||
Txid,
|
||||
},
|
||||
silentpayments::{
|
||||
bitcoin_hashes::{sha256t_hash_newtype, Hash, HashEngine},
|
||||
secp256k1::PublicKey,
|
||||
utils::SilentPaymentAddress,
|
||||
},
|
||||
};
|
||||
use tsify::Tsify;
|
||||
use sp_client::silentpayments::{bitcoin_hashes::{sha256t_hash_newtype, Hash, HashEngine}, secp256k1::PublicKey};
|
||||
|
||||
use aes_gcm::aead::{Aead, Payload};
|
||||
pub use aes_gcm::{AeadCore, Aes256Gcm, KeyInit};
|
||||
@ -22,43 +7,6 @@ use rand::thread_rng;
|
||||
|
||||
pub const AAD: &[u8] = "4nk".as_bytes();
|
||||
|
||||
const HALFKEYSIZE: usize = SECRET_KEY_SIZE / 2;
|
||||
|
||||
const THIRTYTWO: usize = 32;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct SharedPoint([u8; 64]);
|
||||
|
||||
impl SharedPoint {
|
||||
pub fn as_inner(&self) -> &[u8; 64] {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, Deserialize, Tsify, Clone, Default, PartialEq)]
|
||||
#[tsify(from_wasm_abi, into_wasm_abi)]
|
||||
pub struct AnkSharedSecret {
|
||||
secret: String,
|
||||
}
|
||||
|
||||
impl AnkSharedSecret {
|
||||
pub fn new(shared_point: PublicKey) -> Self {
|
||||
let mut shared_point_bin = [0u8; 64];
|
||||
shared_point_bin.copy_from_slice(&shared_point.serialize_uncompressed()[1..]);
|
||||
let secret = AnkSharedSecretHash::from_shared_point(shared_point_bin).to_byte_array();
|
||||
Self {
|
||||
secret: secret.to_lower_hex_string(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn to_byte_array(&self) -> [u8; 32] {
|
||||
let bytes = Vec::from_hex(&self.secret).unwrap();
|
||||
let mut buf = [0u8; 32];
|
||||
buf.copy_from_slice(&bytes);
|
||||
buf
|
||||
}
|
||||
}
|
||||
|
||||
sha256t_hash_newtype! {
|
||||
pub struct AnkSharedSecretTag = hash_str("4nk/AnkSharedSecret");
|
||||
|
||||
@ -67,317 +15,39 @@ sha256t_hash_newtype! {
|
||||
}
|
||||
|
||||
impl AnkSharedSecretHash {
|
||||
pub fn from_shared_point(shared_point: [u8; 64]) -> Self {
|
||||
pub fn from_shared_point(shared_point: PublicKey) -> Self {
|
||||
let mut eng = AnkSharedSecretHash::engine();
|
||||
eng.input(&shared_point);
|
||||
eng.input(&shared_point.serialize_uncompressed()[1..]);
|
||||
AnkSharedSecretHash::from_engine(eng)
|
||||
}
|
||||
}
|
||||
|
||||
pub struct HalfKey([u8; HALFKEYSIZE]);
|
||||
|
||||
impl TryFrom<Vec<u8>> for HalfKey {
|
||||
type Error = anyhow::Error;
|
||||
fn try_from(value: Vec<u8>) -> std::prelude::v1::Result<Self, Error> {
|
||||
if value.len() == HALFKEYSIZE {
|
||||
let mut buf = [0u8; HALFKEYSIZE];
|
||||
buf.copy_from_slice(&value);
|
||||
Ok(HalfKey(buf))
|
||||
} else {
|
||||
Err(Error::msg("Invalid length for HalfKey"))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl HalfKey {
|
||||
pub fn as_slice(&self) -> &[u8] {
|
||||
&self.0
|
||||
}
|
||||
|
||||
pub fn to_inner(&self) -> Vec<u8> {
|
||||
self.0.to_vec()
|
||||
}
|
||||
}
|
||||
|
||||
pub enum Purpose {
|
||||
Login,
|
||||
ThirtyTwoBytes,
|
||||
Arbitrary,
|
||||
}
|
||||
|
||||
pub type CipherText = Vec<u8>;
|
||||
|
||||
pub type EncryptedKey = Vec<u8>;
|
||||
|
||||
pub struct Aes256Decryption {
|
||||
pub purpose: Purpose,
|
||||
cipher_text: CipherText,
|
||||
aes_key: [u8; 32],
|
||||
nonce: [u8; 12],
|
||||
}
|
||||
|
||||
impl Aes256Decryption {
|
||||
pub fn new(purpose: Purpose, cipher_text: CipherText, aes_key: [u8; 32]) -> Result<Self> {
|
||||
if cipher_text.len() <= 12 {
|
||||
return Err(Error::msg("cipher_text is shorter than nonce length"));
|
||||
}
|
||||
let (message_nonce, message_cipher) = cipher_text.split_at(12);
|
||||
let mut nonce = [0u8; 12];
|
||||
nonce.copy_from_slice(message_nonce);
|
||||
Ok(Self {
|
||||
purpose,
|
||||
cipher_text: message_cipher.to_vec(),
|
||||
aes_key,
|
||||
nonce,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn decrypt_with_key(&self) -> Result<Vec<u8>> {
|
||||
match self.purpose {
|
||||
Purpose::Login => {
|
||||
let half_key = self.decrypt_login()?;
|
||||
Ok(half_key.to_inner())
|
||||
}
|
||||
Purpose::ThirtyTwoBytes => {
|
||||
let thirty_two_buf = self.decrypt_thirty_two()?;
|
||||
Ok(thirty_two_buf.to_vec())
|
||||
}
|
||||
Purpose::Arbitrary => {
|
||||
let arbitrary = self.decrypt_arbitrary()?;
|
||||
Ok(arbitrary)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn decrypt_login(&self) -> Result<HalfKey> {
|
||||
let cipher = Aes256Gcm::new(&self.aes_key.into());
|
||||
let plain = cipher
|
||||
.decrypt(&self.nonce.into(), &*self.cipher_text)
|
||||
.map_err(|e| Error::msg(format!("{}", e)))?;
|
||||
if plain.len() != SECRET_KEY_SIZE / 2 {
|
||||
return Err(Error::msg("Plain text of invalid lenght for a login"));
|
||||
}
|
||||
let mut key_half = [0u8; SECRET_KEY_SIZE / 2];
|
||||
key_half.copy_from_slice(&plain);
|
||||
Ok(HalfKey(key_half))
|
||||
}
|
||||
|
||||
fn decrypt_thirty_two(&self) -> Result<[u8; THIRTYTWO]> {
|
||||
let cipher = Aes256Gcm::new(&self.aes_key.into());
|
||||
let plain = cipher
|
||||
.decrypt(&self.nonce.into(), &*self.cipher_text)
|
||||
.map_err(|e| Error::msg(format!("{}", e)))?;
|
||||
if plain.len() != THIRTYTWO {
|
||||
return Err(Error::msg("Plain text of invalid length, should be 32"));
|
||||
}
|
||||
let mut thirty_two = [0u8; THIRTYTWO];
|
||||
thirty_two.copy_from_slice(&plain);
|
||||
Ok(thirty_two)
|
||||
}
|
||||
|
||||
fn decrypt_arbitrary(&self) -> Result<Vec<u8>> {
|
||||
let cipher = Aes256Gcm::new(&self.aes_key.into());
|
||||
let payload = Payload {
|
||||
msg: &self.cipher_text,
|
||||
aad: AAD,
|
||||
};
|
||||
let plain = cipher
|
||||
.decrypt(&self.nonce.into(), payload)
|
||||
.map_err(|e| Error::msg(format!("{}", e)))?;
|
||||
Ok(plain)
|
||||
}
|
||||
}
|
||||
|
||||
pub struct Aes256Encryption {
|
||||
pub purpose: Purpose,
|
||||
plaintext: Vec<u8>,
|
||||
aes_key: [u8; 32],
|
||||
nonce: [u8; 12],
|
||||
shared_secrets: HashMap<Txid, HashMap<SilentPaymentAddress, AnkSharedSecret>>,
|
||||
}
|
||||
|
||||
impl Aes256Encryption {
|
||||
pub fn new(purpose: Purpose, plaintext: Vec<u8>) -> Result<Self> {
|
||||
let mut rng = thread_rng();
|
||||
let aes_key: [u8; 32] = Aes256Gcm::generate_key(&mut rng).into();
|
||||
let nonce: [u8; 12] = Aes256Gcm::generate_nonce(&mut rng).into();
|
||||
Self::import_key(purpose, plaintext, aes_key, nonce)
|
||||
}
|
||||
|
||||
pub fn set_shared_secret(
|
||||
&mut self,
|
||||
shared_secrets: HashMap<Txid, HashMap<SilentPaymentAddress, AnkSharedSecret>>,
|
||||
) {
|
||||
self.shared_secrets = shared_secrets;
|
||||
}
|
||||
|
||||
pub fn encrypt_keys_with_shared_secrets(
|
||||
&self,
|
||||
) -> Result<HashMap<SilentPaymentAddress, EncryptedKey>> {
|
||||
let mut res = HashMap::new();
|
||||
let mut rng = thread_rng();
|
||||
|
||||
for (_, sp_address2shared_secret) in self.shared_secrets.iter() {
|
||||
for (sp_address, shared_secret) in sp_address2shared_secret {
|
||||
let cipher = Aes256Gcm::new_from_slice(&shared_secret.to_byte_array())
|
||||
.map_err(|e| Error::msg(format!("{}", e)))?;
|
||||
let nonce = Aes256Gcm::generate_nonce(&mut rng);
|
||||
let encrypted_key = cipher
|
||||
.encrypt(&nonce, self.aes_key.as_slice())
|
||||
.map_err(|e| Error::msg(format!("{}", e)))?;
|
||||
|
||||
let mut ciphertext = Vec::<u8>::with_capacity(nonce.len() + encrypted_key.len());
|
||||
ciphertext.extend(nonce);
|
||||
ciphertext.extend(encrypted_key);
|
||||
|
||||
res.insert(sp_address.to_owned(), ciphertext);
|
||||
}
|
||||
}
|
||||
Ok(res)
|
||||
}
|
||||
|
||||
pub fn import_key(
|
||||
purpose: Purpose,
|
||||
plaintext: Vec<u8>,
|
||||
aes_key: [u8; 32],
|
||||
nonce: [u8; 12],
|
||||
) -> Result<Self> {
|
||||
if plaintext.len() == 0 {
|
||||
return Err(Error::msg("Can't create encryption for an empty message"));
|
||||
}
|
||||
Ok(Self {
|
||||
purpose,
|
||||
plaintext,
|
||||
aes_key,
|
||||
nonce,
|
||||
shared_secrets: HashMap::new(),
|
||||
})
|
||||
}
|
||||
|
||||
pub fn export_key(&self) -> [u8; 32] {
|
||||
self.aes_key
|
||||
}
|
||||
|
||||
pub fn encrypt_with_aes_key(&self) -> Result<CipherText> {
|
||||
match self.purpose {
|
||||
Purpose::Login => self.encrypt_login(),
|
||||
Purpose::ThirtyTwoBytes => self.encrypt_thirty_two(),
|
||||
Purpose::Arbitrary => self.encrypt_arbitrary(),
|
||||
}
|
||||
}
|
||||
|
||||
fn encrypt_login(&self) -> Result<CipherText> {
|
||||
let half_key: HalfKey = self.plaintext.clone().try_into()?;
|
||||
let cipher = Aes256Gcm::new(&self.aes_key.into());
|
||||
let cipher_text = cipher
|
||||
.encrypt(&self.nonce.into(), half_key.as_slice())
|
||||
.map_err(|e| Error::msg(format!("{}", e)))?;
|
||||
let mut res = Vec::with_capacity(self.nonce.len() + cipher_text.len());
|
||||
res.extend_from_slice(&self.nonce);
|
||||
res.extend_from_slice(&cipher_text);
|
||||
Ok(res)
|
||||
}
|
||||
|
||||
fn encrypt_thirty_two(&self) -> Result<CipherText> {
|
||||
if self.plaintext.len() != 32 {
|
||||
return Err(Error::msg("Invalid length, should be 32"));
|
||||
}
|
||||
let mut thirty_two = [0u8; 32];
|
||||
thirty_two.copy_from_slice(&self.plaintext);
|
||||
let cipher = Aes256Gcm::new(&self.aes_key.into());
|
||||
let cipher_text = cipher
|
||||
.encrypt(&self.nonce.into(), thirty_two.as_slice())
|
||||
.map_err(|e| Error::msg(format!("{}", e)))?;
|
||||
let mut res = Vec::with_capacity(self.nonce.len() + cipher_text.len());
|
||||
res.extend_from_slice(&self.nonce);
|
||||
res.extend_from_slice(&cipher_text);
|
||||
Ok(res)
|
||||
}
|
||||
|
||||
fn encrypt_arbitrary(&self) -> Result<CipherText> {
|
||||
let cipher = Aes256Gcm::new(&self.aes_key.into());
|
||||
let payload = Payload {
|
||||
msg: &self.plaintext,
|
||||
aad: AAD,
|
||||
};
|
||||
let cipher_text = cipher
|
||||
.encrypt(&self.nonce.into(), payload)
|
||||
.map_err(|e| Error::msg(format!("{}", e)))?;
|
||||
let mut res = Vec::with_capacity(self.nonce.len() + cipher_text.len());
|
||||
res.extend_from_slice(&self.nonce);
|
||||
res.extend_from_slice(&cipher_text);
|
||||
Ok(res)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::{io::Read, str::FromStr};
|
||||
|
||||
use sp_client::bitcoin::hex::FromHex;
|
||||
|
||||
use super::*;
|
||||
|
||||
const ALICE_SP_ADDRESS: &str = "tsp1qqw3lqr6xravz9nf8ntazgwwl0fqv47kfjdxsnxs6eutavqfwyv5q6qk97mmyf6dtkdyzqlu2zv6h9j2ggclk7vn705q5u2phglpq7yw3dg5rwpdz";
|
||||
const BOB_SP_ADDRESS: &str = "tsp1qq2hlsgrj0gz8kcfkf9flqw5llz0u2vr04telqndku9mcqm6dl4fhvq60t8r78srrf56w9yr7w9e9dusc2wjqc30up6fjwnh9mw3e3veqegdmtf08";
|
||||
const TRANSACTION: &str = "4e6d03dec558e1b6624f813bf2da7cd8d8fb1c2296684c08cf38724dcfd8d10b";
|
||||
const ALICE_SHARED_SECRET: &str =
|
||||
"ccf02d364c2641ca129a3fdf49de57b705896e233f7ba6d738991993ea7e2106";
|
||||
const BOB_SHARED_SECRET: &str =
|
||||
"15ef3e377fb842e81de52dbaaea8ba30aeb051a81043ee19264afd27353da521";
|
||||
|
||||
#[test]
|
||||
fn new_aes_empty_plaintext() {
|
||||
let plaintext = Vec::new();
|
||||
let aes_enc = Aes256Encryption::new(Purpose::Login, plaintext);
|
||||
|
||||
assert!(aes_enc.is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn aes_encrypt_login_invalid_length() {
|
||||
let plaintext = "example";
|
||||
let aes_enc_short = Aes256Encryption::new(Purpose::Login, plaintext.as_bytes().to_vec());
|
||||
|
||||
assert!(aes_enc_short.is_ok());
|
||||
|
||||
let cipher = aes_enc_short.unwrap().encrypt_with_aes_key();
|
||||
|
||||
assert!(cipher.is_err());
|
||||
|
||||
let plaintext = [1u8; 64];
|
||||
let aes_enc_long = Aes256Encryption::new(Purpose::Login, plaintext.to_vec());
|
||||
|
||||
assert!(aes_enc_long.is_ok());
|
||||
|
||||
let cipher = aes_enc_long.unwrap().encrypt_with_aes_key();
|
||||
|
||||
assert!(cipher.is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn aes_encrypt_login() {
|
||||
let plaintext = [1u8; HALFKEYSIZE];
|
||||
let aes_key = Aes256Gcm::generate_key(&mut thread_rng());
|
||||
pub fn encrypt_with_key(key: &[u8; 32], plaintext: &[u8]) -> Result<Vec<u8>> {
|
||||
let encryption_eng = Aes256Gcm::new(key.into());
|
||||
let nonce = Aes256Gcm::generate_nonce(&mut thread_rng());
|
||||
let aes_enc = Aes256Encryption::import_key(
|
||||
Purpose::Login,
|
||||
plaintext.to_vec(),
|
||||
aes_key.into(),
|
||||
nonce.into(),
|
||||
);
|
||||
let payload = Payload {
|
||||
msg: plaintext,
|
||||
aad: AAD,
|
||||
};
|
||||
let ciphertext = encryption_eng.encrypt(&nonce, payload)
|
||||
.map_err(|e| anyhow::anyhow!(e))?;
|
||||
|
||||
assert!(aes_enc.is_ok());
|
||||
let mut res: Vec<u8> = Vec::with_capacity(nonce.len() + ciphertext.len());
|
||||
res.extend_from_slice(&nonce);
|
||||
res.extend_from_slice(&ciphertext);
|
||||
|
||||
let cipher = aes_enc.unwrap().encrypt_with_aes_key();
|
||||
|
||||
assert!(cipher.is_ok());
|
||||
|
||||
let mut plain_key = [0u8; 32];
|
||||
plain_key.copy_from_slice(&aes_key.to_vec());
|
||||
|
||||
let aes_dec = Aes256Decryption::new(Purpose::Login, cipher.unwrap(), plain_key);
|
||||
|
||||
assert!(aes_dec.is_ok());
|
||||
}
|
||||
Ok(res)
|
||||
}
|
||||
|
||||
pub fn decrypt_with_key(key: &[u8; 32], ciphertext: &[u8]) -> Result<Vec<u8>> {
|
||||
let decryption_eng = Aes256Gcm::new(key.into());
|
||||
let nonce = &ciphertext[..12];
|
||||
let payload = Payload {
|
||||
msg: &ciphertext[12..],
|
||||
aad: AAD,
|
||||
};
|
||||
let plaintext = decryption_eng.decrypt(nonce.into(), payload)
|
||||
.map_err(|e| anyhow::anyhow!(e))?;
|
||||
|
||||
Ok(plaintext)
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user