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

change key labels for better naming

Browse Source
This commit is contained in:
Marvin Jones 2026-06-01 15:18:51 -04:00
parent 39163f942e
commit b304443850
1 changed files with 56 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

109
key_protocol/src/key_management/key_tree/keys_public.rs
View File

@ -6,12 +6,15 @@ use crate::key_management::key_tree::traits::KeyTreeNode;
#[derive(Debug, Serialize, Deserialize, Clone)]
#[cfg_attr(any(test, feature = "test_utils"), derive(PartialEq, Eq))]
pub struct ChildKeysPublic {
pub cssk: nssa::PrivateKey,
pub csk: nssa::PrivateKey,
pub cpk: nssa::PublicKey,
pub ccc: [u8; 32],
/// Secret key for public account.
pub sk: nssa::PrivateKey,
/// Schnorr secret key.
pub ssk: nssa::PrivateKey,
/// Schnorr public key.
pub pk: nssa::PublicKey,
pub cc: [u8; 32],
/// Can be [`None`] if root.
pub cci: Option<u32>,
pub ci: Option<u32>,
}
impl ChildKeysPublic {
@ -19,31 +22,31 @@ impl ChildKeysPublic {
pub fn root(seed: [u8; 64]) -> Self {
let hash_value = hmac_sha512::HMAC::mac(seed, "LEE_master_pub");
let cssk = nssa::PrivateKey::try_new(
let sk = nssa::PrivateKey::try_new(
*hash_value
.first_chunk::<32>()
.expect("hash_value is 64 bytes, must be safe to get first 32"),
)
.expect("Expect a valid Private Key");
let csk = nssa::PrivateKey::tweak(cssk.value()).expect("`key_protocol::key_management::keys_public::root()`: Invalid private key produced from `tweak`");
let ssk = nssa::PrivateKey::tweak(sk.value()).expect("`key_protocol::key_management::keys_public::root()`: Invalid private key produced from `tweak`");
let ccc = *hash_value
let cc = *hash_value
.last_chunk::<32>()
.expect("hash_value is 64 bytes, must be safe to get last 32");
let cpk = nssa::PublicKey::new_from_private_key(&csk);
let pk = nssa::PublicKey::new_from_private_key(&ssk);
Self {
cssk,
csk,
cpk,
ccc,
cci: None,
sk,
ssk,
pk,
cc,
ci: None,
}
}
#[must_use]
pub fn nth_child(&self, cci: u32) -> Self {
let hash_value = self.compute_hash_value(cci);
pub fn nth_child(&self, ci: u32) -> Self {
let hash_value = self.compute_hash_value(ci);
let lhs = k256::Scalar::from_repr(
(*hash_value
@ -52,46 +55,46 @@ impl ChildKeysPublic {
.into(),
)
.expect("Expect a valid k256 scalar");
let rhs = k256::Scalar::from_repr((*self.cssk.value()).into())
let rhs = k256::Scalar::from_repr((*self.sk.value()).into())
.expect("Expect a valid k256 scalar");
let cssk = nssa::PrivateKey::try_new(lhs.add(&rhs).to_bytes().into())
let sk = nssa::PrivateKey::try_new(lhs.add(&rhs).to_bytes().into())
.expect("Expect a valid private key");
let csk = nssa::PrivateKey::tweak(cssk.value()).expect("`key_protocol::key_management::keys_public::nth_child()`: Invalid private key produced from `tweak`");
let ssk = nssa::PrivateKey::tweak(sk.value()).expect("`key_protocol::key_management::keys_public::nth_child()`: Invalid private key produced from `tweak`");
let ccc = *hash_value
let cc = *hash_value
.last_chunk::<32>()
.expect("hash_value is 64 bytes, must be safe to get last 32");
let cpk = nssa::PublicKey::new_from_private_key(&csk);
let pk = nssa::PublicKey::new_from_private_key(&ssk);
Self {
cssk,
csk,
cpk,
ccc,
cci: Some(cci),
sk,
ssk,
pk,
cc,
ci: Some(ci),
}
}
#[must_use]
pub fn account_id(&self) -> nssa::AccountId {
nssa::AccountId::from(&self.cpk)
nssa::AccountId::from(&self.pk)
}
fn compute_hash_value(&self, cci: u32) -> [u8; 64] {
fn compute_hash_value(&self, ci: u32) -> [u8; 64] {
let mut hash_input = vec![];
// Simplified key logic by only supporting harden keys.
// Non-harden keys would require access to untweaked public keys associated to `cssk`s.
// Non-harden keys would require access to untweaked public keys associated to `sk`s.
// Thus, not PQ secure.
hash_input.extend_from_slice(&[0_u8]);
hash_input.extend_from_slice(self.cssk.value());
hash_input.extend_from_slice(self.sk.value());
#[expect(clippy::big_endian_bytes, reason = "BIP-032 uses big endian")]
hash_input.extend_from_slice(&cci.to_be_bytes());
hash_input.extend_from_slice(&ci.to_be_bytes());
hmac_sha512::HMAC::mac(hash_input, self.ccc)
hmac_sha512::HMAC::mac(hash_input, self.cc)
}
}
@ -101,7 +104,7 @@ impl ChildKeysPublic {
)]
impl<'a> From<&'a ChildKeysPublic> for &'a nssa::PrivateKey {
fn from(value: &'a ChildKeysPublic) -> Self {
&value.csk
&value.ssk
}
}
@ -110,8 +113,8 @@ impl KeyTreeNode for ChildKeysPublic {
Self::root(seed)
}
fn derive_child(&self, cci: u32) -> Self {
self.nth_child(cci)
fn derive_child(&self, ci: u32) -> Self {
self.nth_child(ci)
}
fn account_ids(&self) -> impl Iterator<Item = nssa::AccountId> {
@ -135,33 +138,33 @@ mod tests {
];
let keys = ChildKeysPublic::root(seed);
let expected_ccc = [
let expected_cc = [
238, 94, 84, 154, 56, 224, 80, 218, 133, 249, 179, 222, 9, 24, 17, 252, 120, 127, 222,
13, 146, 126, 232, 239, 113, 9, 194, 219, 190, 48, 187, 155,
];
let expected_cssk: PrivateKey = PrivateKey::try_new([
let expected_sk: PrivateKey = PrivateKey::try_new([
40, 35, 239, 19, 53, 178, 250, 55, 115, 12, 34, 3, 153, 153, 72, 170, 190, 36, 172, 36,
202, 148, 181, 228, 35, 222, 58, 84, 156, 24, 146, 86,
])
.unwrap();
let expected_csk: PrivateKey = PrivateKey::try_new([
let expected_ssk: PrivateKey = PrivateKey::try_new([
207, 4, 246, 223, 104, 72, 19, 85, 14, 122, 194, 82, 32, 163, 60, 57, 8, 25, 209, 91,
254, 107, 76, 238, 31, 68, 236, 192, 154, 78, 105, 118,
])
.unwrap();
let expected_cpk: PublicKey = PublicKey::try_new([
let expected_pk: PublicKey = PublicKey::try_new([
188, 163, 203, 45, 151, 154, 230, 254, 123, 114, 158, 130, 19, 182, 164, 143, 150, 131,
176, 7, 27, 58, 204, 116, 5, 247, 0, 255, 111, 160, 52, 201,
])
.unwrap();
assert!(expected_ccc == keys.ccc);
assert!(expected_cssk == keys.cssk);
assert!(expected_csk == keys.csk);
assert!(expected_cpk == keys.cpk);
assert!(expected_cc == keys.cc);
assert!(expected_ssk == keys.ssk);
assert!(expected_sk == keys.sk);
assert!(expected_pk == keys.pk);
}
#[test]
@ -173,35 +176,35 @@ mod tests {
187, 148, 92, 44, 253, 210, 37,
];
let root_keys = ChildKeysPublic::root(seed);
let cci = (2_u32).pow(31) + 13;
let child_keys = ChildKeysPublic::nth_child(&root_keys, cci);
let ci = (2_u32).pow(31) + 13;
let child_keys = ChildKeysPublic::nth_child(&root_keys, ci);
let expected_ccc = [
let expected_cc = [
149, 226, 13, 4, 194, 12, 69, 29, 9, 234, 209, 119, 98, 4, 128, 91, 37, 103, 192, 31,
130, 126, 123, 20, 90, 34, 173, 209, 101, 248, 155, 36,
];
let expected_cssk: PrivateKey = PrivateKey::try_new([
let expected_sk: PrivateKey = PrivateKey::try_new([
9, 65, 33, 228, 25, 82, 219, 117, 91, 217, 11, 223, 144, 85, 246, 26, 123, 216, 107,
213, 33, 52, 188, 22, 198, 246, 71, 46, 245, 174, 16, 47,
])
.unwrap();
let expected_csk: PrivateKey = PrivateKey::try_new([
let expected_ssk: PrivateKey = PrivateKey::try_new([
100, 37, 212, 81, 40, 233, 72, 156, 177, 139, 50, 114, 136, 157, 202, 132, 203, 246,
252, 242, 13, 81, 42, 100, 159, 240, 187, 252, 202, 108, 25, 105,
])
.unwrap();
let expected_cpk: PublicKey = PublicKey::try_new([
let expected_pk: PublicKey = PublicKey::try_new([
210, 59, 119, 137, 21, 153, 82, 22, 195, 82, 12, 16, 80, 156, 125, 199, 19, 173, 46,
224, 213, 144, 165, 126, 70, 129, 171, 141, 77, 212, 108, 233,
])
.unwrap();
assert!(expected_ccc == child_keys.ccc);
assert!(expected_cssk == child_keys.cssk);
assert!(expected_csk == child_keys.csk);
assert!(expected_cpk == child_keys.cpk);
assert!(expected_cc == child_keys.cc);
assert!(expected_ssk == child_keys.ssk);
assert!(expected_sk == child_keys.sk);
assert!(expected_pk == child_keys.pk);
}
}