(wip) add sha256

Author: mikesposito

cipher/src/algorithm/mod.rs

@@ -7,6 +7,8 @@ pub mod poly1305;
 /// Module for the Blake3 message authentication code (MAC) algorithm.
 pub mod blake3;
 
+pub mod sha256;
+
 /// Re-exporting `ChaCha20` for direct use.
 pub use chacha20::ChaCha20;
 
@@ -16,6 +18,9 @@ pub use poly1305::{Poly1305, SignedEnvelope};
 /// Re-exporting `Blake3Mac` for direct use.
 pub use blake3::Blake3Mac;
 
+/// Re-exporting `Sha256` for direct use.
+pub use sha256::Sha256;
+
 pub trait AlgorithmKeyIVInit {
   /// Initializes the algorithm with a key and an initialization vector (IV).
   ///

cipher/src/algorithm/sha256/core.rs

@@ -0,0 +1,92 @@
+pub const STATE_WORDS: usize = 32;
+
+pub const HASH_WORDS: usize = 8;
+
+pub const SCHEDULE_WORDS: usize = 64;
+
+pub const INITIAL_HASH: Sha256Hash = [
+  0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+];
+
+pub const K: [u32; 64] = [
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+];
+
+pub type Sha256Hash = [u32; HASH_WORDS];
+
+pub type MessageSchedule = [u32; SCHEDULE_WORDS];
+
+pub type WorkingVariables = [u32; 8];
+
+pub fn init_working_variables(hash: &Sha256Hash) -> WorkingVariables {
+  [
+    hash[0], hash[1], hash[2], hash[3], hash[4], hash[5], hash[6], hash[7],
+  ]
+}
+
+pub fn prepare_schedule(block: &[u32; 16]) -> MessageSchedule {
+  let mut schedule = [0u32; SCHEDULE_WORDS];
+
+  // The first 16 words of the message schedule are the block itself.
+  for i in 0..16 {
+    schedule[i] = block[i];
+  }
+  // The remaining words are generated using the sigma functions.
+  for i in 16..SCHEDULE_WORDS {
+    schedule[i] = schedule[i - 16]
+      .wrapping_add(sig0(schedule[i - 15]))
+      .wrapping_add(schedule[i - 7])
+      .wrapping_add(sig1(schedule[i - 2]));
+  }
+
+  schedule
+}
+
+pub fn compress_schedule(schedule: &MessageSchedule, v: &mut WorkingVariables) {
+  for i in 0..SCHEDULE_WORDS {
+    let t1 = v[7]
+      .wrapping_add(big_sig1(v[4]))
+      .wrapping_add(schedule[i])
+      .wrapping_add(K[i]);
+
+    let t2 = big_sig0(v[0]).wrapping_add(v[0] & v[1] ^ v[0] & v[2] ^ v[1] & v[2]);
+
+    v[7] = v[6];
+    v[6] = v[5];
+    v[5] = v[4];
+    v[4] = v[3].wrapping_add(t1);
+    v[3] = v[2];
+    v[2] = v[1];
+    v[1] = v[0];
+    v[0] = t1.wrapping_add(t2);
+  }
+}
+
+pub fn update_hash(hash: &mut Sha256Hash, v: &WorkingVariables) {
+  for (h, w) in hash.iter_mut().zip(v.iter()) {
+    *h = h.wrapping_add(*w);
+  }
+}
+
+pub fn sig0(x: u32) -> u32 {
+  (x >> 7) ^ (x >> 18) ^ (x >> 3)
+}
+
+pub fn sig1(x: u32) -> u32 {
+  (x >> 17) ^ (x >> 19) ^ (x >> 10)
+}
+
+pub fn big_sig0(x: u32) -> u32 {
+  (x >> 2) ^ (x >> 13) ^ (x >> 22)
+}
+
+pub fn big_sig1(x: u32) -> u32 {
+  (x >> 6) ^ (x >> 11) ^ (x >> 25)
+}

cipher/src/algorithm/sha256/mod.rs

@@ -0,0 +1,77 @@
+pub mod core;
+
+use super::AlgorithmProcess;
+use core::{
+  compress_schedule, init_working_variables, prepare_schedule, update_hash, Sha256Hash,
+  INITIAL_HASH,
+};
+
+pub struct Sha256 {
+  hash: Sha256Hash,
+}
+
+impl Default for Sha256 {
+  fn default() -> Self {
+    Self { hash: INITIAL_HASH }
+  }
+}
+
+impl Sha256 {
+  /// Resets the hash to its initial state.
+  pub fn reset(&mut self) {
+    self.hash = INITIAL_HASH;
+  }
+
+  pub fn process_block(&mut self, block: &[u32; 16]) {
+    let schedule = prepare_schedule(block);
+    let mut v = init_working_variables(&self.hash);
+
+    // Perform the main hash computation loop.
+    compress_schedule(&schedule, &mut v);
+
+    // Update the hash with the computed values.
+    update_hash(&mut self.hash, &v);
+  }
+}
+
+impl AlgorithmProcess for Sha256 {
+  fn process(&mut self, data: Vec<u8>) -> Vec<u8> {
+    data.chunks(64).for_each(|chunk| {
+      let mut block = [0u32; 16];
+      for (i, word) in chunk.chunks(4).enumerate() {
+        if word.len() == 4 {
+          block[i] = u32::from_be_bytes([word[0], word[1], word[2], word[3]]);
+        }
+      }
+      self.process_block(&block);
+    });
+
+    let mut result = Vec::with_capacity(32);
+    for word in &self.hash {
+      result.extend_from_slice(&word.to_be_bytes());
+    }
+
+    result
+  }
+}
+
+#[cfg(test)]
+mod test {
+  use super::*;
+
+  #[test]
+  fn it_should_process_sha256() {
+    let mut sha256 = Sha256::default();
+    let data = b"Hello, world!";
+    let hash = sha256.process(data.to_vec());
+
+    assert_eq!(
+      hash,
+      [
+        0x65, 0xa8, 0xe2, 0x93, 0x93, 0x7b, 0x5f, 0x1c, 0x3d, 0x6f, 0x4c, 0x9e, 0x9b, 0x1a, 0x91,
+        0x3f, 0x7d, 0xf6, 0xa2, 0xc4, 0x8e, 0x5b, 0xe1, 0xd2, 0xf7, 0xb9, 0xa5, 0xe6, 0xf2, 0xc3,
+        0x4f
+      ]
+    );
+  }
+}