#[derive(Clone, Debug)]
pub struct Sha256 {
state: [u32; 8],
buffer: [u8; 64],
buffered: usize,
length: u64,
}
const K: [u32; 64] = [
0x428a_2f98,
0x7137_4491,
0xb5c0_fbcf,
0xe9b5_dba5,
0x3956_c25b,
0x59f1_11f1,
0x923f_82a4,
0xab1c_5ed5,
0xd807_aa98,
0x1283_5b01,
0x2431_85be,
0x550c_7dc3,
0x72be_5d74,
0x80de_b1fe,
0x9bdc_06a7,
0xc19b_f174,
0xe49b_69c1,
0xefbe_4786,
0x0fc1_9dc6,
0x240c_a1cc,
0x2de9_2c6f,
0x4a74_84aa,
0x5cb0_a9dc,
0x76f9_88da,
0x983e_5152,
0xa831_c66d,
0xb003_27c8,
0xbf59_7fc7,
0xc6e0_0bf3,
0xd5a7_9147,
0x06ca_6351,
0x1429_2967,
0x27b7_0a85,
0x2e1b_2138,
0x4d2c_6dfc,
0x5338_0d13,
0x650a_7354,
0x766a_0abb,
0x81c2_c92e,
0x9272_2c85,
0xa2bf_e8a1,
0xa81a_664b,
0xc24b_8b70,
0xc76c_51a3,
0xd192_e819,
0xd699_0624,
0xf40e_3585,
0x106a_a070,
0x19a4_c116,
0x1e37_6c08,
0x2748_774c,
0x34b0_bcb5,
0x391c_0cb3,
0x4ed8_aa4a,
0x5b9c_ca4f,
0x682e_6ff3,
0x748f_82ee,
0x78a5_636f,
0x84c8_7814,
0x8cc7_0208,
0x90be_fffa,
0xa450_6ceb,
0xbef9_a3f7,
0xc671_78f2,
];
const INITIAL: [u32; 8] = [
0x6a09_e667,
0xbb67_ae85,
0x3c6e_f372,
0xa54f_f53a,
0x510e_527f,
0x9b05_688c,
0x1f83_d9ab,
0x5be0_cd19,
];
impl Default for Sha256 {
fn default() -> Self {
Self::new()
}
}
impl Sha256 {
pub const LEN: usize = 32;
#[must_use]
pub fn new() -> Self {
Self {
state: INITIAL,
buffer: [0; 64],
buffered: 0,
length: 0,
}
}
#[must_use]
pub fn digest(data: &[u8]) -> [u8; Self::LEN] {
let mut hasher = Self::new();
hasher.update(data);
hasher.finalize()
}
pub fn update(&mut self, mut data: &[u8]) {
self.length = self
.length
.wrapping_add((data.len() as u64).wrapping_mul(8));
if self.buffered > 0 {
let take = (64usize.saturating_sub(self.buffered)).min(data.len());
let (head, rest) = data.split_at(take);
if let Some(slot) = self
.buffer
.get_mut(self.buffered..self.buffered.saturating_add(take))
{
slot.copy_from_slice(head);
}
self.buffered = self.buffered.saturating_add(take);
data = rest;
if self.buffered < 64 {
return;
}
let block = self.buffer;
self.compress(&block);
self.buffered = 0;
}
let (blocks, rest) = data.as_chunks::<64>();
for block in blocks {
self.compress(block);
}
if let Some(slot) = self.buffer.get_mut(..rest.len()) {
slot.copy_from_slice(rest);
}
self.buffered = rest.len();
}
#[must_use]
pub fn finalize(mut self) -> [u8; Self::LEN] {
let length = self.length;
let mut padding = [0u8; 72];
padding[0] = 0x80;
let pad = if self.buffered < 56 {
56usize.saturating_sub(self.buffered)
} else {
120usize.saturating_sub(self.buffered)
};
self.update(padding.get(..pad).unwrap_or(&[]));
self.update(&length.to_be_bytes());
let mut out = [0u8; Self::LEN];
for (chunk, word) in out.as_chunks_mut::<4>().0.iter_mut().zip(self.state) {
chunk.copy_from_slice(&word.to_be_bytes());
}
out
}
fn compress(&mut self, block: &[u8; 64]) {
let mut w = [0u32; 64];
for (slot, bytes) in w.iter_mut().zip(block.as_chunks::<4>().0) {
*slot = u32::from_be_bytes(*bytes);
}
for i in 16..64 {
w[i] = w[i - 16]
.wrapping_add(
w[i - 15].rotate_right(7) ^ w[i - 15].rotate_right(18) ^ (w[i - 15] >> 3),
)
.wrapping_add(w[i - 7])
.wrapping_add(
w[i - 2].rotate_right(17) ^ w[i - 2].rotate_right(19) ^ (w[i - 2] >> 10),
);
}
let [mut a, mut b, mut c, mut d, mut e, mut f, mut g, mut h] = self.state;
for (&k, &word) in K.iter().zip(&w) {
let t1 = h
.wrapping_add(e.rotate_right(6) ^ e.rotate_right(11) ^ e.rotate_right(25))
.wrapping_add((e & f) ^ (!e & g))
.wrapping_add(k)
.wrapping_add(word);
let t2 = (a.rotate_right(2) ^ a.rotate_right(13) ^ a.rotate_right(22))
.wrapping_add((a & b) ^ (a & c) ^ (b & c));
h = g;
g = f;
f = e;
e = d.wrapping_add(t1);
d = c;
c = b;
b = a;
a = t1.wrapping_add(t2);
}
for (state, value) in self.state.iter_mut().zip([a, b, c, d, e, f, g, h]) {
*state = state.wrapping_add(value);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn hex(bytes: &[u8]) -> String {
bytes.iter().map(|b| format!("{b:02x}")).collect()
}
#[test]
fn known_vectors() {
assert_eq!(
hex(&Sha256::digest(b"")),
"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
);
assert_eq!(
hex(&Sha256::digest(b"abc")),
"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
);
assert_eq!(
hex(&Sha256::digest(
b"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
)),
"248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1"
);
}
#[test]
fn incremental_matches_one_shot() {
let data: Vec<u8> = (0..1000u32).map(|i| (i * 7 % 251) as u8).collect();
for split in [0, 1, 55, 56, 63, 64, 65, 500, 999, 1000] {
let mut hasher = Sha256::new();
hasher.update(&data[..split]);
hasher.update(&data[split..]);
assert_eq!(hasher.finalize(), Sha256::digest(&data), "split {split}");
}
let million = vec![b'a'; 1_000_000];
assert_eq!(
hex(&Sha256::digest(&million)),
"cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0"
);
}
}