logos-blockchain/lssa
1
0
Fork 0
mirror of https://github.com/logos-blockchain/lssa.git synced 2026-01-04 06:13:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #56 from vacp2p/serde_json_vs_group_encoding

Browse Source 
`serde_json` instead of `GroupEncoding` serialization
This commit is contained in:
tyshko-rostyslav 2025-04-08 14:25:09 -04:00 committed by GitHub
commit bfe39185fa
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
6 changed files with 57 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
accounts/src/key_management/ephemeral_key_holder.rs
View File

@ -1,5 +1,4 @@
use aes_gcm::{aead::Aead, AeadCore, Aes256Gcm, Key, KeyInit}; use aes_gcm::{aead::Aead, AeadCore, Aes256Gcm, Key, KeyInit};
use elliptic_curve::group::GroupEncoding;
use elliptic_curve::PrimeField; use elliptic_curve::PrimeField;
use k256::{AffinePoint, FieldBytes, Scalar}; use k256::{AffinePoint, FieldBytes, Scalar};
use log::info; use log::info;
@ -41,7 +40,7 @@ impl EphemeralKeyHolder {
data: &[u8], data: &[u8],
) -> (CipherText, Nonce) { ) -> (CipherText, Nonce) {
let key_point = self.calculate_shared_secret_sender(viewing_public_key_receiver); let key_point = self.calculate_shared_secret_sender(viewing_public_key_receiver);
let binding = key_point.to_bytes(); let binding = serde_json::to_vec(&key_point).unwrap();
let key_raw = &binding.as_slice()[..32]; let key_raw = &binding.as_slice()[..32];
let key_raw_adjust: [u8; 32] = key_raw.try_into().unwrap(); let key_raw_adjust: [u8; 32] = key_raw.try_into().unwrap();
@ -56,7 +55,7 @@ impl EphemeralKeyHolder {
pub fn log(&self) { pub fn log(&self) {
info!( info!(
"Ephemeral private key is {:?}", "Ephemeral private key is {:?}",
hex::encode(self.ephemeral_secret_key.to_bytes()) hex::encode(serde_json::to_vec(&self.ephemeral_secret_key).unwrap())
); );
} }
} }

33
accounts/src/key_management/mod.rs
View File

@ -1,6 +1,5 @@
use aes_gcm::{aead::Aead, Aes256Gcm, Key, KeyInit}; use aes_gcm::{aead::Aead, Aes256Gcm, Key, KeyInit};
use constants_types::{CipherText, Nonce}; use constants_types::{CipherText, Nonce};
use elliptic_curve::group::GroupEncoding;
use ephemeral_key_holder::EphemeralKeyHolder; use ephemeral_key_holder::EphemeralKeyHolder;
use k256::AffinePoint; use k256::AffinePoint;
use log::info; use log::info;
@ -65,7 +64,7 @@ impl AddressKeyHolder {
nonce: Nonce, nonce: Nonce,
) -> Result<Vec<u8>, aes_gcm::Error> { ) -> Result<Vec<u8>, aes_gcm::Error> {
let key_point = self.calculate_shared_secret_receiver(ephemeral_public_key_sender); let key_point = self.calculate_shared_secret_receiver(ephemeral_public_key_sender);
let binding = key_point.to_bytes(); let binding = serde_json::to_vec(&key_point).unwrap();
let key_raw = &binding.as_slice()[..32]; let key_raw = &binding.as_slice()[..32];
let key_raw_adjust: [u8; 32] = key_raw.try_into().unwrap(); let key_raw_adjust: [u8; 32] = key_raw.try_into().unwrap();
@ -79,23 +78,29 @@ impl AddressKeyHolder {
pub fn log(&self) { pub fn log(&self) {
info!( info!(
"Secret spending key is {:?}", "Secret spending key is {:?}",
hex::encode(self.top_secret_key_holder.secret_spending_key.to_bytes()), hex::encode(
serde_json::to_vec(&self.top_secret_key_holder.secret_spending_key).unwrap()
),
); );
info!( info!(
"Nulifier secret key is {:?}", "Nulifier secret key is {:?}",
hex::encode(self.utxo_secret_key_holder.nullifier_secret_key.to_bytes()), hex::encode(
serde_json::to_vec(&self.utxo_secret_key_holder.nullifier_secret_key).unwrap()
),
); );
info!( info!(
"Viewing secret key is {:?}", "Viewing secret key is {:?}",
hex::encode(self.utxo_secret_key_holder.viewing_secret_key.to_bytes()), hex::encode(
serde_json::to_vec(&self.utxo_secret_key_holder.viewing_secret_key).unwrap()
),
); );
info!( info!(
"Nullifier public key is {:?}", "Nullifier public key is {:?}",
hex::encode(self.nullifer_public_key.to_bytes()), hex::encode(serde_json::to_vec(&self.nullifer_public_key).unwrap()),
); );
info!( info!(
"Viewing public key is {:?}", "Viewing public key is {:?}",
hex::encode(self.viewing_public_key.to_bytes()), hex::encode(serde_json::to_vec(&self.viewing_public_key).unwrap()),
); );
} }
} }
@ -158,7 +163,7 @@ mod tests {
address_key_holder.calculate_shared_secret_receiver(ephemeral_public_key_sender); address_key_holder.calculate_shared_secret_receiver(ephemeral_public_key_sender);
// Prepare the encryption key from shared secret // Prepare the encryption key from shared secret
let key_raw = shared_secret.to_bytes(); let key_raw = serde_json::to_vec(&shared_secret).unwrap();
let key_raw_adjust_pre = &key_raw.as_slice()[..32]; let key_raw_adjust_pre = &key_raw.as_slice()[..32];
let key_raw_adjust: [u8; 32] = key_raw_adjust_pre.try_into().unwrap(); let key_raw_adjust: [u8; 32] = key_raw_adjust_pre.try_into().unwrap();
let key: Key<Aes256Gcm> = key_raw_adjust.into(); let key: Key<Aes256Gcm> = key_raw_adjust.into();
@ -226,7 +231,7 @@ mod tests {
address_key_holder.calculate_shared_secret_receiver(ephemeral_public_key_sender); address_key_holder.calculate_shared_secret_receiver(ephemeral_public_key_sender);
// Prepare the encryption key from shared secret // Prepare the encryption key from shared secret
let key_raw = shared_secret.to_bytes(); let key_raw = serde_json::to_vec(&shared_secret).unwrap();
let key_raw_adjust_pre = &key_raw.as_slice()[..32]; let key_raw_adjust_pre = &key_raw.as_slice()[..32];
let key_raw_adjust: [u8; 32] = key_raw_adjust_pre.try_into().unwrap(); let key_raw_adjust: [u8; 32] = key_raw_adjust_pre.try_into().unwrap();
let key: Key<Aes256Gcm> = key_raw_adjust.into(); let key: Key<Aes256Gcm> = key_raw_adjust.into();
@ -266,7 +271,7 @@ mod tests {
address_key_holder.calculate_shared_secret_receiver(ephemeral_public_key_sender); address_key_holder.calculate_shared_secret_receiver(ephemeral_public_key_sender);
// Prepare the encryption key from shared secret // Prepare the encryption key from shared secret
let key_raw = shared_secret.to_bytes(); let key_raw = serde_json::to_vec(&shared_secret).unwrap();
let key_raw_adjust_pre = &key_raw.as_slice()[..32]; let key_raw_adjust_pre = &key_raw.as_slice()[..32];
let key_raw_adjust: [u8; 32] = key_raw_adjust_pre.try_into().unwrap(); let key_raw_adjust: [u8; 32] = key_raw_adjust_pre.try_into().unwrap();
let key: Key<Aes256Gcm> = key_raw_adjust.into(); let key: Key<Aes256Gcm> = key_raw_adjust.into();
@ -312,7 +317,7 @@ mod tests {
let shared_secret = let shared_secret =
address_key_holder.calculate_shared_secret_receiver(ephemeral_public_key_sender); address_key_holder.calculate_shared_secret_receiver(ephemeral_public_key_sender);
// Prepare the encryption key from shared secret // Prepare the encryption key from shared secret
let key_raw = shared_secret.to_bytes(); let key_raw = serde_json::to_vec(&shared_secret).unwrap();
let key_raw_adjust_pre = &key_raw.as_slice()[..32]; let key_raw_adjust_pre = &key_raw.as_slice()[..32];
let key_raw_adjust: [u8; 32] = key_raw_adjust_pre.try_into().unwrap(); let key_raw_adjust: [u8; 32] = key_raw_adjust_pre.try_into().unwrap();
let key: Key<Aes256Gcm> = key_raw_adjust.into(); let key: Key<Aes256Gcm> = key_raw_adjust.into();
@ -351,7 +356,7 @@ mod tests {
println!( println!(
"Group generator {:?}", "Group generator {:?}",
hex::encode(AffinePoint::GENERATOR.to_bytes()) hex::encode(serde_json::to_vec(&AffinePoint::GENERATOR).unwrap())
); );
println!( println!(
"Nullifier constant {:?}", "Nullifier constant {:?}",
@ -373,11 +378,11 @@ mod tests {
println!("Address{:?}", hex::encode(address)); println!("Address{:?}", hex::encode(address));
println!( println!(
"Nulifier public key {:?}", "Nulifier public key {:?}",
hex::encode(nullifer_public_key.to_bytes()) hex::encode(serde_json::to_vec(&nullifer_public_key).unwrap())
); );
println!( println!(
"Viewing public key {:?}", "Viewing public key {:?}",
hex::encode(viewing_public_key.to_bytes()) hex::encode(serde_json::to_vec(&viewing_public_key).unwrap())
); );
} }
} }

5
accounts/src/key_management/secret_holders.rs
View File

@ -1,4 +1,3 @@
use elliptic_curve::group::GroupEncoding;
use elliptic_curve::PrimeField; use elliptic_curve::PrimeField;
use k256::{AffinePoint, FieldBytes, Scalar}; use k256::{AffinePoint, FieldBytes, Scalar};
use rand::{rngs::OsRng, RngCore}; use rand::{rngs::OsRng, RngCore};
@ -105,8 +104,8 @@ impl UTXOSecretKeyHolder {
let mut hasher = sha2::Sha256::new(); let mut hasher = sha2::Sha256::new();
hasher.update(npk.to_bytes()); hasher.update(serde_json::to_vec(&npk).unwrap());
hasher.update(vpk.to_bytes()); hasher.update(serde_json::to_vec(&vpk).unwrap());
<TreeHashType>::from(hasher.finalize_fixed()) <TreeHashType>::from(hasher.finalize_fixed())
} }

19
node_core/src/lib.rs
View File

@ -4,7 +4,6 @@ use std::sync::{
}; };
use common::ExecutionFailureKind; use common::ExecutionFailureKind;
use k256::elliptic_curve::group::GroupEncoding;
use ::storage::transaction::{Transaction, TransactionPayload, TxKind}; use ::storage::transaction::{Transaction, TransactionPayload, TxKind};
use accounts::account_core::{Account, AccountAddress}; use accounts::account_core::{Account, AccountAddress};
@ -181,7 +180,8 @@ impl NodeCore {
let ephm_key_holder = &accout.produce_ephemeral_key_holder(); let ephm_key_holder = &accout.produce_ephemeral_key_holder();
ephm_key_holder.log(); ephm_key_holder.log();
let eph_pub_key = ephm_key_holder.generate_ephemeral_public_key().to_bytes(); let eph_pub_key =
serde_json::to_vec(&ephm_key_holder.generate_ephemeral_public_key()).unwrap();
let encoded_data = Account::encrypt_data( let encoded_data = Account::encrypt_data(
&ephm_key_holder, &ephm_key_holder,
@ -232,7 +232,8 @@ impl NodeCore {
let ephm_key_holder = &accout.produce_ephemeral_key_holder(); let ephm_key_holder = &accout.produce_ephemeral_key_holder();
ephm_key_holder.log(); ephm_key_holder.log();
let eph_pub_key = ephm_key_holder.generate_ephemeral_public_key().to_bytes(); let eph_pub_key =
serde_json::to_vec(&ephm_key_holder.generate_ephemeral_public_key()).unwrap();
let encoded_data = utxos let encoded_data = utxos
.iter() .iter()
@ -308,7 +309,8 @@ impl NodeCore {
let ephm_key_holder = &accout.produce_ephemeral_key_holder(); let ephm_key_holder = &accout.produce_ephemeral_key_holder();
ephm_key_holder.log(); ephm_key_holder.log();
let eph_pub_key = ephm_key_holder.generate_ephemeral_public_key().to_bytes(); let eph_pub_key =
serde_json::to_vec(&ephm_key_holder.generate_ephemeral_public_key()).unwrap();
let encoded_data: Vec<(Vec<u8>, Vec<u8>, u8)> = utxos let encoded_data: Vec<(Vec<u8>, Vec<u8>, u8)> = utxos
.iter() .iter()
@ -392,7 +394,8 @@ impl NodeCore {
let ephm_key_holder = &accout.produce_ephemeral_key_holder(); let ephm_key_holder = &accout.produce_ephemeral_key_holder();
ephm_key_holder.log(); ephm_key_holder.log();
let eph_pub_key = ephm_key_holder.generate_ephemeral_public_key().to_bytes(); let eph_pub_key =
serde_json::to_vec(&ephm_key_holder.generate_ephemeral_public_key()).unwrap();
let mut encoded_data: Vec<(Vec<u8>, Vec<u8>, u8)> = resulting_utxos_receiver let mut encoded_data: Vec<(Vec<u8>, Vec<u8>, u8)> = resulting_utxos_receiver
.iter() .iter()
@ -498,7 +501,8 @@ impl NodeCore {
let ephm_key_holder = &account.produce_ephemeral_key_holder(); let ephm_key_holder = &account.produce_ephemeral_key_holder();
ephm_key_holder.log(); ephm_key_holder.log();
let eph_pub_key = ephm_key_holder.generate_ephemeral_public_key().to_bytes(); let eph_pub_key =
serde_json::to_vec(&ephm_key_holder.generate_ephemeral_public_key()).unwrap();
let encoded_data: Vec<(Vec<u8>, Vec<u8>, u8)> = utxos let encoded_data: Vec<(Vec<u8>, Vec<u8>, u8)> = utxos
.iter() .iter()
@ -1124,7 +1128,8 @@ impl NodeCore {
let ephm_key_holder = &accout.produce_ephemeral_key_holder(); let ephm_key_holder = &accout.produce_ephemeral_key_holder();
ephm_key_holder.log(); ephm_key_holder.log();
let eph_pub_key = ephm_key_holder.generate_ephemeral_public_key().to_bytes(); let eph_pub_key =
serde_json::to_vec(&ephm_key_holder.generate_ephemeral_public_key()).unwrap();
let encoded_data: Vec<(Vec<u8>, Vec<u8>, u8)> = utxos let encoded_data: Vec<(Vec<u8>, Vec<u8>, u8)> = utxos
.iter() .iter()

49
node_core/src/storage/mod.rs
View File

@ -6,7 +6,6 @@ use std::{
use accounts::account_core::{Account, AccountAddress}; use accounts::account_core::{Account, AccountAddress};
use anyhow::Result; use anyhow::Result;
use block_store::NodeBlockStore; use block_store::NodeBlockStore;
use elliptic_curve::group::GroupEncoding;
use k256::AffinePoint; use k256::AffinePoint;
use public_context::PublicSCContext; use public_context::PublicSCContext;
use storage::{ use storage::{
@ -106,39 +105,29 @@ impl NodeChainStore {
.collect(), .collect(),
)?; )?;
let slice_try: Result<[u8; 33], _> = tx.ephemeral_pub_key.clone().try_into(); let eph_key_compressed = serde_json::to_vec(&tx.ephemeral_pub_key);
let eph_key_compressed =
slice_try.and_then(|inner| Ok(<AffinePoint as GroupEncoding>::Repr::from(inner)));
if let Ok(eph_key_compressed) = eph_key_compressed { if let Ok(eph_key_compressed) = eph_key_compressed {
let ephemeral_public_key_sender = AffinePoint::from_bytes(&eph_key_compressed); let ephemeral_public_key_sender =
serde_json::from_slice::<AffinePoint>(&eph_key_compressed)?;
if ephemeral_public_key_sender.is_some().into() { for (ciphertext, nonce, tag) in tx.encoded_data.clone() {
let ephemeral_public_key_sender = ephemeral_public_key_sender.unwrap(); let slice = nonce.as_slice();
let nonce =
for (ciphertext, nonce, tag) in tx.encoded_data.clone() { accounts::key_management::constants_types::Nonce::clone_from_slice(slice);
let slice = nonce.as_slice(); for (acc_id, acc) in self.acc_map.iter_mut() {
let nonce = if acc_id[0] == tag {
accounts::key_management::constants_types::Nonce::clone_from_slice( let decoded_data_curr_acc = acc.decrypt_data(
slice, ephemeral_public_key_sender,
ciphertext.clone(),
nonce,
); );
if let Ok(decoded_data_curr_acc) = decoded_data_curr_acc {
for (acc_id, acc) in self.acc_map.iter_mut() { let decoded_utxo_try =
if acc_id[0] == tag { serde_json::from_slice::<UTXO>(&decoded_data_curr_acc);
let decoded_data_curr_acc = acc.decrypt_data( if let Ok(utxo) = decoded_utxo_try {
ephemeral_public_key_sender, if &utxo.owner == acc_id {
ciphertext.clone(), acc.utxo_tree.insert_item(utxo)?;
nonce,
);
if let Ok(decoded_data_curr_acc) = decoded_data_curr_acc {
let decoded_utxo_try =
serde_json::from_slice::<UTXO>(&decoded_data_curr_acc);
if let Ok(utxo) = decoded_utxo_try {
if &utxo.owner == acc_id {
acc.utxo_tree.insert_item(utxo)?;
}
} }
} }
} }

7
sequencer_core/src/sequecer_store/accounts_store.rs
View File

@ -1,5 +1,5 @@
use accounts::account_core::{AccountAddress, PublicKey}; use accounts::account_core::{AccountAddress, PublicKey};
use elliptic_curve::group::GroupEncoding; use k256::AffinePoint;
use std::collections::HashMap; use std::collections::HashMap;
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
@ -16,10 +16,9 @@ impl AccountPublicData {
viewing_public_key: Vec<u8>, viewing_public_key: Vec<u8>,
) -> Self { ) -> Self {
Self { Self {
nullifier_public_key: PublicKey::from_bytes(nullifier_public_key.as_slice().into()) nullifier_public_key: serde_json::from_slice::<AffinePoint>(&nullifier_public_key)
.unwrap(),
viewing_public_key: PublicKey::from_bytes(viewing_public_key.as_slice().into())
.unwrap(), .unwrap(),
viewing_public_key: serde_json::from_slice::<AffinePoint>(&viewing_public_key).unwrap(),
address, address,
} }
} }