prep for sha2

Cargo.toml

@@ -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"
 

src/hashers.rs

@@ -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();
+        //let mut digest1: GenericArray<u8, N> = GenericArray::default();
-        shake256_a(&[&r, &pk_seed, &pk_root, m], &mut digest);
+        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>(
+    pub fn hmac_sha_256(key: &[u8], a0: &[u8], b1: &[u8]) -> [u8; 32] {
-        _pk_seed: &[u8], _sk_seed: &[u8], _adrs: &Adrs,
+        let k2 = key;
-    ) -> GenericArray<u8, N> {
+        let mut padded = [0x36; 64];
-        GenericArray::default()
+        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>(
+    pub(crate) fn f<N: ArrayLength>(pk_seed: &[u8], adrs: &Adrs, m1: &[u8]) -> GenericArray<u8, N> {
-        _pk_seed: &[u8], _adrs: &Adrs, _m1: &[u8],
+        let mut digest: GenericArray<u8, N> = GenericArray::default();
-    ) -> GenericArray<u8, N> {
+        let to_byte = [0u8; 64];
-        GenericArray::default()
+        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)]

src/lib.rs

@@ -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::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::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::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::Hashers;
     use generic_array::typenum::{Prod, Sum, U16, U2, U22, U3, U33, U34, U6, U66};

src/types.rs

@@ -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
+    }
 }