From 91a8565afa01a819ca3b2ca27cb91a9cf1d99727 Mon Sep 17 00:00:00 2001 From: Matthew LeVan Date: Tue, 10 Oct 2023 14:24:28 -0400 Subject: [PATCH] jets: cleanup nasty byte copying --- rust/ares/src/jets/lock/ed.rs | 113 ++++++++++----------------------- rust/ares/src/jets/lock/sha.rs | 6 +- 2 files changed, 38 insertions(+), 81 deletions(-) diff --git a/rust/ares/src/jets/lock/ed.rs b/rust/ares/src/jets/lock/ed.rs index 70981c9..35c8322 100644 --- a/rust/ares/src/jets/lock/ed.rs +++ b/rust/ares/src/jets/lock/ed.rs @@ -1,4 +1,4 @@ -use crate::jets::util::slot; +use crate::jets::util::{met,slot}; use crate::jets::{JetErr, Result}; use crate::mem::NockStack; use crate::newt::Newt; @@ -9,37 +9,19 @@ crate::gdb!(); pub fn jet_sign(stack: &mut NockStack, _newt: &mut Option<&mut Newt>, subject: Noun) -> Result { let sam = slot(subject, 6)?; - let message = slot(sam, 2)?.as_atom()?; - let seed = slot(sam, 3)?.as_atom()?; + let msg = slot(sam, 2)?.as_atom()?; + let sed = slot(sam, 3)?.as_atom()?; unsafe { - let mut msg_bytes = message.as_bytes(); - // TODO: absolutely disgusting - // remove the leading/trailing 0s - while msg_bytes.len() > 0 && msg_bytes[msg_bytes.len() - 1] == 0 { - msg_bytes = &msg_bytes[..msg_bytes.len() - 1]; - } - while msg_bytes.len() > 0 && msg_bytes[0] == 0 { - msg_bytes = &msg_bytes[1..]; - } - let msg_len = msg_bytes.len(); - let (mut _msg_ida, msg) = IndirectAtom::new_raw_mut_bytes(stack, msg_len); - for i in 0..msg_len { - msg[i] = msg_bytes[i]; - } + let msg_bytes = &(msg.as_bytes())[0..met(3, msg)]; // drop trailing zeros - let (mut _sed_ida, sed) = IndirectAtom::new_raw_mut_bytes(stack, 32); - let sed_bytes = seed.as_bytes(); - let sed_len = sed_bytes.len(); - if sed_len > 32 { - return Err(JetErr::Deterministic); - } - for i in 0..sed_len { - sed[i] = sed_bytes[i]; - } + let sed_bytes = sed.as_bytes(); + let (mut _seed_ida, seed) = IndirectAtom::new_raw_mut_bytes(stack, 32); + if sed_bytes.len() > 32 { return Err(JetErr::Deterministic) }; + seed.copy_from_slice(sed_bytes); let (mut sig_ida, sig) = IndirectAtom::new_raw_mut_bytes(stack, 64); - urcrypt_ed_sign(msg.as_ptr(), msg_len, sed.as_ptr(), sig.as_mut_ptr()); + urcrypt_ed_sign(msg_bytes.as_ptr(), msg_bytes.len(), seed.as_ptr(), sig.as_mut_ptr()); sig.reverse(); // LSB first Ok(sig_ida.normalize_as_atom().as_noun()) @@ -47,55 +29,34 @@ pub fn jet_sign(stack: &mut NockStack, _newt: &mut Option<&mut Newt>, subject: N } pub fn jet_veri(stack: &mut NockStack, _newt: &mut Option<&mut Newt>, subject: Noun) -> Result { - let signature = slot(subject, 12)?.as_atom()?; - let message = slot(subject, 26)?.as_atom()?; - let public_key = slot(subject, 27)?.as_atom()?; + let sig = slot(subject, 12)?.as_atom()?; + let msg = slot(subject, 26)?.as_atom()?; + let puk = slot(subject, 27)?.as_atom()?; unsafe { - let (mut _sig_ida, sig) = IndirectAtom::new_raw_mut_bytes(stack, 64); - let sig_bytes = signature.as_bytes(); - if sig_bytes.len() > 64 { - // vere punts; we should do the same in the future - return Err(JetErr::NonDeterministic); - } - for i in 0..sig_bytes.len() { - sig[i] = sig_bytes[i]; - } + let (mut _sig_ida, signature) = IndirectAtom::new_raw_mut_bytes(stack, 64); + let sig_bytes = sig.as_bytes(); + // vere punts; we should do the same in the future + if sig_bytes.len() > 64 { return Err(JetErr::NonDeterministic) }; + signature.copy_from_slice(sig_bytes); - let (mut _pub_ida, pub_key) = IndirectAtom::new_raw_mut_bytes(stack, 32); - let pub_bytes = public_key.as_bytes(); - if pub_bytes.len() > 32 { - // vere punts; we should do the same in the future - return Err(JetErr::NonDeterministic); - } - for i in 0..pub_bytes.len() { - pub_key[i] = pub_bytes[i]; - } + let (mut _pub_ida, public_key) = IndirectAtom::new_raw_mut_bytes(stack, 32); + let pub_bytes = puk.as_bytes(); + // vere punts; we should do the same in the future + if pub_bytes.len() > 32 { return Err(JetErr::NonDeterministic) }; + public_key.copy_from_slice(pub_bytes); - let mut msg_bytes = message.as_bytes(); - // TODO: absolutely disgusting - // remove the leading/trailing 0s - while msg_bytes.len() > 0 && msg_bytes[msg_bytes.len() - 1] == 0 { - msg_bytes = &msg_bytes[..msg_bytes.len() - 1]; - } - while msg_bytes.len() > 0 && msg_bytes[0] == 0 { - msg_bytes = &msg_bytes[1..]; - } - let msg_len = msg_bytes.len(); - let (mut _msg_ida, msg) = IndirectAtom::new_raw_mut_bytes(stack, msg_len); - for i in 0..msg_len { - msg[i] = msg_bytes[i]; - } + let message = &(msg.as_bytes())[0..met(3, msg)]; // drop trailing zeros + + let valid = urcrypt_ed_veri(message.as_ptr(), message.len(), public_key.as_ptr(), signature.as_ptr()); - let valid = urcrypt_ed_veri(msg.as_ptr(), msg_len, pub_key.as_ptr(), sig.as_ptr()); Ok(if valid { YES } else { NO }) } } pub fn jet_shar(stack: &mut NockStack, _newt: &mut Option<&mut Newt>, subject: Noun) -> Result { - let sam = slot(subject, 6)?; - let pub_key = slot(sam, 2)?.as_direct()?; - let sec_key = slot(sam, 3)?.as_direct()?; + let pub_key = slot(subject, 12)?.as_direct()?; + let sec_key = slot(subject, 13)?.as_direct()?; if sec_key.bit_size() > 32 { return Err(JetErr::Deterministic); @@ -112,35 +73,31 @@ pub fn jet_shar(stack: &mut NockStack, _newt: &mut Option<&mut Newt>, subject: N let pub_bytes = pub_key.data().to_le_bytes(); let sec_bytes = sec_key.data().to_le_bytes(); - for i in 0..pub_bytes.len() { - public[i] = pub_bytes[i]; - } - for i in 0..sec_bytes.len() { - secret[i] = sec_bytes[i]; - } + public[0..pub_bytes.len()].copy_from_slice(&pub_bytes[..]); + secret[0..sec_bytes.len()].copy_from_slice(&sec_bytes[..]); let (mut shar_ida, shar) = IndirectAtom::new_raw_mut_bytes(stack, 32); urcrypt_ed_shar(public.as_ptr(), secret.as_ptr(), shar.as_mut_ptr()); + Ok(shar_ida.normalize_as_atom().as_noun()) } } pub fn jet_puck(stack: &mut NockStack, _newt: &mut Option<&mut Newt>, subject: Noun) -> Result { - let sam = slot(subject, 6)?.as_direct()?; + let sed = slot(subject, 6)?.as_direct()?; - if sam.bit_size() > 32 { + if sed.bit_size() > 32 { return Err(JetErr::Deterministic); } unsafe { let (mut _seed_ida, seed) = IndirectAtom::new_raw_mut_bytes(stack, 32); - let sam_bytes = sam.data().to_le_bytes(); - for i in 0..sam_bytes.len() { - seed[i] = sam_bytes[i]; - } + let sed_bytes = sed.data().to_le_bytes(); + seed[0..sed_bytes.len()].copy_from_slice(&sed_bytes[..]); let (mut pub_ida, pub_key) = IndirectAtom::new_raw_mut_bytes(stack, 32); urcrypt_ed_puck(seed.as_ptr(), pub_key.as_mut_ptr()); + Ok(pub_ida.normalize_as_atom().as_noun()) } } diff --git a/rust/ares/src/jets/lock/sha.rs b/rust/ares/src/jets/lock/sha.rs index fd8aec6..260375c 100644 --- a/rust/ares/src/jets/lock/sha.rs +++ b/rust/ares/src/jets/lock/sha.rs @@ -38,7 +38,7 @@ pub fn jet_shal(stack: &mut NockStack, _newt: &mut Option<&mut Newt>, subject: N Err(_) => return Err(JetErr::NonDeterministic), }; - let message = dat.as_bytes(); + let message = &(dat.as_bytes())[0..met(3, dat)]; // drop trailing zeros unsafe { let (mut ida, out) = IndirectAtom::new_raw_mut_bytes(stack, 64); @@ -52,11 +52,11 @@ pub fn jet_shas(stack: &mut NockStack, _newt: &mut Option<&mut Newt>, subject: N let sal = slot(sam, 2)?.as_atom()?; let ruz= slot(sam, 3)?.as_atom()?; - let sal_bytes = sal.as_bytes(); + let sal_bytes = &(sal.as_bytes())[0..met(3, sal)]; // drop trailing zeros let (mut _salt_ida, salt) = unsafe { IndirectAtom::new_raw_mut_bytes(stack, sal_bytes.len()) }; salt.copy_from_slice(sal_bytes); - let message = ruz.as_bytes(); + let message = &(ruz.as_bytes())[0..met(3, ruz)]; // drop trailing zeros unsafe { let (mut out_ida, out) = IndirectAtom::new_raw_mut_bytes(stack, 32);