(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).
   ///
@@ -67,6 +72,27 @@ pub trait AlgorithmProcessInPlace {
   fn process_in_place(&self, data: &mut [u8]);
 }
 
+pub trait Hasher {
+  /// Updates the hash with the provided data.
+  ///
+  /// This method processes the input data and updates the internal state of the hash.
+  /// It is typically used to feed data into the hash incrementally.
+  ///
+  /// # Arguments
+  /// * `data` - A byte slice of data to be hashed.
+  fn update(&mut self, data: &[u8]);
+
+  /// Finalizes the hash computation and returns the resulting hash value.
+  ///
+  /// This method completes the hash computation and returns the final hash value.
+  /// It is typically called after all data has been fed into the hash.
+  ///
+  /// # Returns
+  ///
+  /// A byte vector representing the final hash value.
+  fn finalize(&self) -> Vec<u8>;
+}
+
 pub trait AlgorithmCore: AlgorithmKeyIVInit + AlgorithmProcess + AlgorithmProcessInPlace {}
 
 pub trait EncryptionAlgorithm:

cipher/src/algorithm/sha256/core.rs

@@ -0,0 +1,110 @@
+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)
+}
+
+pub fn pad(data: &[u8]) -> Vec<u8> {
+  let mut padded = data.to_vec();
+  let bit_length = (data.len() as u64) * 8;
+
+  // Append a single '1' bit (0x80 in hex)
+  padded.push(0x80);
+
+  // Pad with '0' bits until the length is 56 bytes
+  while padded.len() % 64 != 56 {
+    padded.push(0x00);
+  }
+
+  // Append the length of the original message as a 64-bit big-endian integer
+  padded.extend_from_slice(&bit_length.to_be_bytes());
+
+  padded
+}

cipher/src/algorithm/sha256/mod.rs

@@ -0,0 +1,82 @@
+pub mod core;
+
+use core::{
+  compress_schedule, init_working_variables, pad, prepare_schedule, update_hash, Sha256Hash,
+  INITIAL_HASH,
+};
+
+use super::Hasher;
+
+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 Hasher for Sha256 {
+  fn update(&mut self, data: &[u8]) {
+    pad(data).chunks(64).for_each(|chunk| {
+      let mut block = [0u32; 16];
+      for (i, word) in chunk.chunks(4).enumerate() {
+        let mut bytes = [0u8; 4];
+        for (j, &byte) in word.iter().enumerate() {
+          bytes[j] = byte;
+        }
+        block[i] = u32::from_be_bytes(bytes);
+      }
+      self.process_block(&block);
+    });
+  }
+
+  fn finalize(&self) -> Vec<u8> {
+    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 hasher = Sha256::default();
+    let data = b"abc";
+
+    hasher.update(data);
+
+    assert_eq!(
+      hasher.finalize(),
+      [
+        0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea, 0x41, 0x41, 0x40, 0xde, 0x5d, 0xae, 0x22,
+        0x23, 0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c, 0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00,
+        0x15, 0xad
+      ]
+    );
+  }
+}