saymrwulf/fips205-source
1
0
Fork 0
mirror of https://github.com/saymrwulf/fips205-source.git synced 2026-09-04 20:03:45 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

prep for sha2

Browse source
This commit is contained in:
integritychain 2024-02-03 10:17:59 -06:00
parent 8c4c11ae0b
commit 30d0241f2e
5 changed files with 292 additions and 64 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Cargo.toml
View file

@ -12,6 +12,7 @@ rust-version = "1.73"
zeroize = { version = "1.7.0", features = ["zeroize_derive"] }
rand_core = { version = "0.6.4", default-features = false }
sha3 = { version = "0.10.8", default-features = false }
sha2 = { version = "0.10.8", default-features = false }
generic-array = { version = "1.0.0", features=["const-default", "zeroize"] }
hex = "0.4.3"

158
src/hashers.rs
View file

@ -15,7 +15,6 @@ pub(crate) struct Hashers<K: ArrayLength, LEN: ArrayLength, M: ArrayLength, N: A
#[cfg(any(
feature = "slh_dsa_sha2_128s", // TODO: Wrong!! fix
feature = "slh_dsa_shake_128f",
feature = "slh_dsa_shake_128s",
feature = "slh_dsa_shake_192f",
@ -23,7 +22,6 @@ pub(crate) struct Hashers<K: ArrayLength, LEN: ArrayLength, M: ArrayLength, N: A
feature = "slh_dsa_shake_256f",
feature = "slh_dsa_shake_256s"
))]
#[allow(dead_code)]
pub(crate) mod shake {
use crate::types::Adrs;
use generic_array::{ArrayLength, GenericArray};
@ -106,65 +104,169 @@ pub(crate) mod shake {
}
}
#[allow(dead_code)]
pub(crate) mod sha2_cat_1 {
use crate::hashers::shake::shake256_a;
use crate::types::Adrs;
use core::cmp::min;
use generic_array::{ArrayLength, GenericArray};
use sha2::{Digest, Sha256};
// Requires length of output less than or equal to 32 byte digeest
pub fn sha2_256(input: &[&[u8]], out: &mut [u8]) {
let mut hasher = Sha256::new();
input.iter().for_each(|item| hasher.update(item));
let result = hasher.finalize();
out.copy_from_slice(&result[0..out.len()]);
}
// a non-zero hash function to allow placeholder tests to pass
pub(crate) fn h_msg<M: ArrayLength>(
r: &[u8], pk_seed: &[u8], pk_root: &[u8], m: &[u8],
) -> GenericArray<u8, M> {
let mut digest: GenericArray<u8, M> = GenericArray::default();
shake256_a(&[&r, &pk_seed, &pk_root, m], &mut digest);
//let mut digest1: GenericArray<u8, N> = GenericArray::default();
let mut digest1 = [0u8; 32];
sha2_256(&[&r, &pk_seed, &pk_root, m], &mut digest1);
let mut result: GenericArray<u8, M> = GenericArray::default();
let mut start = 0;
let mut counter = 0u32;
while start < M::to_usize() {
let mut tmp = [0u8; 32];
sha2_256(&[&r, &pk_seed, &digest1, &counter.to_be_bytes()], &mut tmp);
let len = min(M::to_usize() - start, 32);
result[start..start + len].copy_from_slice(&tmp[0..len]);
start += 32;
counter += 1;
}
result
}
pub(crate) fn prf<N: ArrayLength>(
pk_seed: &[u8], sk_seed: &[u8], adrs: &Adrs,
) -> GenericArray<u8, N> {
let mut digest: GenericArray<u8, N> = GenericArray::default();
let to_byte = [0u8; 64];
sha2_256(
&[
pk_seed,
&to_byte[0..(64 - N::to_usize())],
&adrs.to_22_bytes(),
sk_seed,
],
&mut digest,
); // Note that the spec swaps order of last to params
digest
}
// pub(crate) fn h_msg<M: ArrayLength>(
// _r: &[u8], _pk_seed: &[u8], _pk_root: &[u8], _m: &[u8],
// ) -> GenericArray<u8, M> {
// GenericArray::default()
// }
pub(crate) fn prf<N: ArrayLength>(
_pk_seed: &[u8], _sk_seed: &[u8], _adrs: &Adrs,
) -> GenericArray<u8, N> {
GenericArray::default()
pub fn hmac_sha_256(key: &[u8], a0: &[u8], b1: &[u8]) -> [u8; 32] {
let k2 = key;
let mut padded = [0x36; 64];
for (p, &k) in padded.iter_mut().zip(k2.iter()) {
*p ^= k;
}
let mut inner_hasher = Sha256::new();
inner_hasher.update(&padded[..]);
inner_hasher.update(a0);
inner_hasher.update(b1);
for p in padded.iter_mut() {
*p ^= 0x6a;
}
let mut outer_hasher = Sha256::new();
outer_hasher.update(&padded[..]);
outer_hasher.update(inner_hasher.finalize());
outer_hasher.finalize().into()
}
// TODO - HMAC <<<<<<<---------------------
pub(crate) fn prf_msg<N: ArrayLength>(
_sk_prf: &[u8], _opt_rand: &[u8], _m: &[u8],
sk_prf: &[u8], opt_rand: &[u8], m: &[u8],
) -> GenericArray<u8, N> {
GenericArray::default()
let mut digest: GenericArray<u8, N> = GenericArray::default();
//sha2_256(&[sk_prf, opt_rand, m], &mut digest);
let xxx = hmac_sha_256(sk_prf, opt_rand, m);
digest.copy_from_slice(&xxx[0..N::to_usize()]);
digest
}
pub(crate) fn f<N: ArrayLength>(
_pk_seed: &[u8], _adrs: &Adrs, _m1: &[u8],
) -> GenericArray<u8, N> {
GenericArray::default()
pub(crate) fn f<N: ArrayLength>(pk_seed: &[u8], adrs: &Adrs, m1: &[u8]) -> GenericArray<u8, N> {
let mut digest: GenericArray<u8, N> = GenericArray::default();
let to_byte = [0u8; 64];
sha2_256(
&[
pk_seed,
&to_byte[0..(64 - N::to_usize())],
&adrs.to_22_bytes(),
m1,
],
&mut digest,
);
digest
}
pub(crate) fn h<N: ArrayLength>(
_pk_seed: &[u8], _adrs: &Adrs, _m1: &[u8], _m2: &[u8],
pk_seed: &[u8], adrs: &Adrs, m1: &[u8], m2: &[u8],
) -> GenericArray<u8, N> {
GenericArray::default()
let mut digest: GenericArray<u8, N> = GenericArray::default();
let to_byte = [0u8; 64];
sha2_256(
&[
pk_seed,
&to_byte[0..(64 - N::to_usize())],
&adrs.to_22_bytes(),
m1,
m2,
],
&mut digest,
);
digest
}
// Until a more elegant way is found to covert ml into list of bytes
pub(crate) fn t_l<LEN: ArrayLength, N: ArrayLength>(
_pk_seed: &[u8], _adrs: &Adrs, _ml: &GenericArray<GenericArray<u8, N>, LEN>,
pk_seed: &[u8], adrs: &Adrs, ml: &GenericArray<GenericArray<u8, N>, LEN>,
) -> GenericArray<u8, N> {
GenericArray::default()
let mut result = GenericArray::default();
let to_byte = [0u8; 64];
let mut hasher = Sha256::new();
hasher.update(pk_seed);
hasher.update(&to_byte[0..(64 - N::to_usize())]);
hasher.update(&adrs.to_32_bytes());
ml.iter().for_each(|item| hasher.update(item));
let digest = hasher.finalize();
result.copy_from_slice(&digest[0..N::to_usize()]);
result
}
// TODO: Squash K and LEN versions
// Until a more elegant way is found to covert ml into list of bytes
pub(crate) fn t_len<K: ArrayLength, N: ArrayLength>(
_pk_seed: &[u8], _adrs: &Adrs, _ml: &GenericArray<GenericArray<u8, N>, K>,
pk_seed: &[u8], adrs: &Adrs, ml: &GenericArray<GenericArray<u8, N>, K>,
) -> GenericArray<u8, N> {
GenericArray::default()
let mut result = GenericArray::default();
let to_byte = [0u8; 64];
let mut hasher = Sha256::new();
hasher.update(pk_seed);
hasher.update(&to_byte[0..(64 - N::to_usize())]);
hasher.update(&adrs.to_32_bytes());
ml.iter().for_each(|item| hasher.update(item));
let digest = hasher.finalize();
result.copy_from_slice(&digest[0..N::to_usize()]);
result
}
// // Until a more elegant way is found to covert ml into list of bytes
// pub(crate) fn t_l<LEN: ArrayLength, N: ArrayLength>(
// _pk_seed: &[u8], _adrs: &Adrs, _ml: &GenericArray<GenericArray<u8, N>, LEN>,
// ) -> GenericArray<u8, N> {
// GenericArray::default()
// }
//
// // TODO: Squash K and LEN versions
// // Until a more elegant way is found to covert ml into list of bytes
// pub(crate) fn t_len<K: ArrayLength, N: ArrayLength>(
// _pk_seed: &[u8], _adrs: &Adrs, _ml: &GenericArray<GenericArray<u8, N>, K>,
// ) -> GenericArray<u8, N> {
// GenericArray::default()
// }
}
#[allow(dead_code)]

6
src/lib.rs
View file

@ -82,8 +82,7 @@ macro_rules! functionality {
/// TKTK
#[cfg(feature = "slh_dsa_sha2_128s")]
pub mod slh_dsa_sha2_128s {
//use crate::hashers::sha2_cat_1::{f, h, h_msg, prf, prf_msg, t_l, t_len};
use crate::hashers::shake::{f, h, h_msg, prf, prf_msg, t_l, t_len};
use crate::hashers::sha2_cat_1::{f, h, h_msg, prf, prf_msg, t_l, t_len};
use crate::hashers::Hashers;
use generic_array::typenum::{Prod, Sum, U12, U14, U16, U2, U3, U30, U63, U7, U9};
@ -132,8 +131,7 @@ pub mod slh_dsa_shake_128s {
/// TKTK
#[cfg(feature = "slh_dsa_sha2_128f")]
pub mod slh_dsa_sha2_128f {
//use crate::hashers::sha2_cat_1::{f, h, h_msg, prf, prf_msg, t_l, t_len};
use crate::hashers::shake::{f, h, h_msg, prf, prf_msg, t_l, t_len};
use crate::hashers::sha2_cat_1::{f, h, h_msg, prf, prf_msg, t_l, t_len};
use crate::hashers::Hashers;
use generic_array::typenum::{Prod, Sum, U16, U2, U22, U3, U33, U34, U6, U66};

179
src/test.rs
View file

File diff suppressed because one or more lines are too long

12
src/types.rs
View file

@ -224,4 +224,16 @@ impl Adrs {
}
ret
}
pub(crate) fn to_22_bytes(&self) -> [u8; 22] {
let mut ret = [0u8; 22];
ret[0] = self.f0[3];
ret[1..5].copy_from_slice(&self.f2);
ret[5..9].copy_from_slice(&self.f3);
ret[9] = self.f4[3];
ret[10..14].copy_from_slice(&self.f5);
ret[14..18].copy_from_slice(&self.f6);
ret[18..22].copy_from_slice(&self.f7);
ret
}
}