use super::{BlockHasher, Hasher};
const K: [u64; 80] = [
0x428a2f98d728ae22,
0x7137449123ef65cd,
0xb5c0fbcfec4d3b2f,
0xe9b5dba58189dbbc,
0x3956c25bf348b538,
0x59f111f1b605d019,
0x923f82a4af194f9b,
0xab1c5ed5da6d8118,
0xd807aa98a3030242,
0x12835b0145706fbe,
0x243185be4ee4b28c,
0x550c7dc3d5ffb4e2,
0x72be5d74f27b896f,
0x80deb1fe3b1696b1,
0x9bdc06a725c71235,
0xc19bf174cf692694,
0xe49b69c19ef14ad2,
0xefbe4786384f25e3,
0x0fc19dc68b8cd5b5,
0x240ca1cc77ac9c65,
0x2de92c6f592b0275,
0x4a7484aa6ea6e483,
0x5cb0a9dcbd41fbd4,
0x76f988da831153b5,
0x983e5152ee66dfab,
0xa831c66d2db43210,
0xb00327c898fb213f,
0xbf597fc7beef0ee4,
0xc6e00bf33da88fc2,
0xd5a79147930aa725,
0x06ca6351e003826f,
0x142929670a0e6e70,
0x27b70a8546d22ffc,
0x2e1b21385c26c926,
0x4d2c6dfc5ac42aed,
0x53380d139d95b3df,
0x650a73548baf63de,
0x766a0abb3c77b2a8,
0x81c2c92e47edaee6,
0x92722c851482353b,
0xa2bfe8a14cf10364,
0xa81a664bbc423001,
0xc24b8b70d0f89791,
0xc76c51a30654be30,
0xd192e819d6ef5218,
0xd69906245565a910,
0xf40e35855771202a,
0x106aa07032bbd1b8,
0x19a4c116b8d2d0c8,
0x1e376c085141ab53,
0x2748774cdf8eeb99,
0x34b0bcb5e19b48a8,
0x391c0cb3c5c95a63,
0x4ed8aa4ae3418acb,
0x5b9cca4f7763e373,
0x682e6ff3d6b2b8a3,
0x748f82ee5defb2fc,
0x78a5636f43172f60,
0x84c87814a1f0ab72,
0x8cc702081a6439ec,
0x90befffa23631e28,
0xa4506cebde82bde9,
0xbef9a3f7b2c67915,
0xc67178f2e372532b,
0xca273eceea26619c,
0xd186b8c721c0c207,
0xeada7dd6cde0eb1e,
0xf57d4f7fee6ed178,
0x06f067aa72176fba,
0x0a637dc5a2c898a6,
0x113f9804bef90dae,
0x1b710b35131c471b,
0x28db77f523047d84,
0x32caab7b40c72493,
0x3c9ebe0a15c9bebc,
0x431d67c49c100d4c,
0x4cc5d4becb3e42b6,
0x597f299cfc657e2a,
0x5fcb6fab3ad6faec,
0x6c44198c4a475817,
];
const fn ch(x: u64, y: u64, z: u64) -> u64 {
(x & y) ^ (!x & z)
}
const fn maj(x: u64, y: u64, z: u64) -> u64 {
(x & y) ^ (x & z) ^ (y & z)
}
const fn sigma_0(x: u64) -> u64 {
x.rotate_right(28) ^ x.rotate_right(34) ^ x.rotate_right(39)
}
const fn sigma_1(x: u64) -> u64 {
x.rotate_right(14) ^ x.rotate_right(18) ^ x.rotate_right(41)
}
const fn little_sigma_0(x: u64) -> u64 {
x.rotate_right(1) ^ x.rotate_right(8) ^ x >> 7
}
const fn little_sigma_1(x: u64) -> u64 {
x.rotate_right(19) ^ x.rotate_right(61) ^ x >> 6
}
#[derive(Clone)]
pub struct Sha512 {
state: [u64; Self::HASH_SIZE / size_of::<u64>()],
len: u128,
}
impl Hasher<{ Sha512::HASH_SIZE }> for Sha512 {
fn new() -> Self {
Self {
state: [
0x6a09e667f3bcc908,
0xbb67ae8584caa73b,
0x3c6ef372fe94f82b,
0xa54ff53a5f1d36f1,
0x510e527fade682d1,
0x9b05688c2b3e6c1f,
0x1f83d9abfb41bd6b,
0x5be0cd19137e2179,
],
len: 0,
}
}
fn finish_with(mut self, msg: &[u8]) -> [u8; Self::HASH_SIZE] {
let chunks = msg.chunks_exact(Self::BLOCK_SIZE);
let remainder = chunks.remainder();
for block in chunks {
self.update_countless(&block.try_into().unwrap());
}
let mut last_block = [0; Self::BLOCK_SIZE];
last_block[..remainder.len()].copy_from_slice(remainder);
last_block[remainder.len()] = 0x80;
if remainder.len() < Self::BLOCK_SIZE - size_of::<u128>() {
last_block[Self::BLOCK_SIZE - size_of::<u128>()..]
.copy_from_slice(&((msg.len() as u128 + self.len) * 8).to_be_bytes());
} else {
self.update_countless(&last_block);
last_block = [0; Self::BLOCK_SIZE];
last_block[Self::BLOCK_SIZE - size_of::<u128>()..]
.copy_from_slice(&((msg.len() as u128 + self.len) * 8).to_be_bytes());
}
self.update(&last_block);
u64_array_to_be_bytes(&self.state)
}
fn finish(mut self) -> [u8; Self::HASH_SIZE] {
let mut padding = [0; Self::BLOCK_SIZE];
padding[0] = 0x80;
padding[Self::BLOCK_SIZE - size_of::<u128>()..]
.copy_from_slice(&(self.len * 8).to_be_bytes());
self.update_countless(&padding);
u64_array_to_be_bytes(&self.state)
}
fn hash(msg: &[u8]) -> [u8; Self::HASH_SIZE] {
let hasher = Self::new();
hasher.finish_with(msg)
}
}
impl BlockHasher<{ Self::HASH_SIZE }, { Self::BLOCK_SIZE }> for Sha512 {
fn update(&mut self, block: &[u8; Self::BLOCK_SIZE]) {
self.update_countless(block);
self.len += Self::BLOCK_SIZE as u128;
}
}
impl Sha512 {
pub const HASH_SIZE: usize = 64;
pub const BLOCK_SIZE: usize = 128;
fn update_countless(&mut self, block: &[u8; Self::BLOCK_SIZE]) {
let block = be_bytes_to_u64_array(block);
let mut message_schedule = [0; 80];
message_schedule[..block.len()].copy_from_slice(&block);
for i in 16..message_schedule.len() {
message_schedule[i] = little_sigma_1(message_schedule[i - 2])
.wrapping_add(message_schedule[i - 7])
.wrapping_add(little_sigma_0(message_schedule[i - 15]))
.wrapping_add(message_schedule[i - 16]);
}
let [mut a, mut b, mut c, mut d, mut e, mut f, mut g, mut h] = self.state;
for i in 0..80 {
let temp1 = h
.wrapping_add(sigma_1(e))
.wrapping_add(ch(e, f, g))
.wrapping_add(K[i])
.wrapping_add(message_schedule[i]);
let temp2 = sigma_0(a).wrapping_add(maj(a, b, c));
h = g;
g = f;
f = e;
e = d.wrapping_add(temp1);
d = c;
c = b;
b = a;
a = temp1.wrapping_add(temp2);
}
self.state[0] = self.state[0].wrapping_add(a);
self.state[1] = self.state[1].wrapping_add(b);
self.state[2] = self.state[2].wrapping_add(c);
self.state[3] = self.state[3].wrapping_add(d);
self.state[4] = self.state[4].wrapping_add(e);
self.state[5] = self.state[5].wrapping_add(f);
self.state[6] = self.state[6].wrapping_add(g);
self.state[7] = self.state[7].wrapping_add(h);
}
}
fn be_bytes_to_u64_array(bytes: &[u8; Sha512::BLOCK_SIZE]) -> [u64; Sha512::BLOCK_SIZE / 8] {
let mut as_u64 = [64; Sha512::BLOCK_SIZE / 8];
for (int, chunk) in as_u64.iter_mut().zip(bytes.chunks_exact(8)) {
*int = u64::from_be_bytes(chunk.try_into().unwrap());
}
as_u64
}
fn u64_array_to_be_bytes(
array: &[u64; Sha512::HASH_SIZE / size_of::<u64>()],
) -> [u8; Sha512::HASH_SIZE] {
let mut as_bytes = [0u8; Sha512::HASH_SIZE];
for (chunk, int) in as_bytes.chunks_exact_mut(8).zip(array) {
chunk.copy_from_slice(&int.to_be_bytes())
}
as_bytes
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn hash_1() {
let msg = [0x6f, 0x8d, 0x58, 0xb7, 0xca, 0xb1, 0x88, 0x8c];
let digest = [
0xa3, 0x94, 0x1d, 0xef, 0x28, 0x03, 0xc8, 0xdf, 0xc0, 0x8f, 0x20, 0xc0, 0x6b, 0xa7,
0xe9, 0xa3, 0x32, 0xae, 0x0c, 0x67, 0xe4, 0x7a, 0xe5, 0x73, 0x65, 0xc2, 0x43, 0xef,
0x40, 0x05, 0x9b, 0x11, 0xbe, 0x22, 0xc9, 0x1d, 0xa6, 0xa8, 0x0c, 0x2c, 0xff, 0x07,
0x42, 0xa8, 0xf4, 0xbc, 0xd9, 0x41, 0xbd, 0xee, 0x0b, 0x86, 0x1e, 0xc8, 0x72, 0xb2,
0x15, 0x43, 0x3c, 0xe8, 0xdc, 0xf3, 0xc0, 0x31,
];
assert_eq!(Sha512::hash(&msg), digest);
}
#[test]
fn hash_2() {
let msg = [
0x4f, 0x05, 0x60, 0x09, 0x50, 0x66, 0x4d, 0x51, 0x90, 0xa2, 0xeb, 0xc2, 0x9c, 0x9e,
0xdb, 0x89, 0xc2, 0x00, 0x79, 0xa4, 0xd3, 0xe6, 0xbc, 0x3b, 0x27, 0xd7, 0x5e, 0x34,
0xe2, 0xfa, 0x3d, 0x02, 0x76, 0x85, 0x02, 0xbd, 0x69, 0x79, 0x00, 0x78, 0x59, 0x8d,
0x5f, 0xcf, 0x3d, 0x67, 0x79, 0xbf, 0xed, 0x12, 0x84, 0xbb, 0xe5, 0xad, 0x72, 0xfb,
0x45, 0x60, 0x15, 0x18, 0x1d, 0x95, 0x87, 0xd6, 0xe8, 0x64, 0xc9, 0x40, 0x56, 0x4e,
0xaa, 0xfb, 0x4f, 0x2f, 0xea, 0xd4, 0x34, 0x6e, 0xa0, 0x9b, 0x68, 0x77, 0xd9, 0x34,
0x0f, 0x6b, 0x82, 0xeb, 0x15, 0x15, 0x88, 0x08, 0x72, 0x21, 0x3d, 0xa3, 0xad, 0x88,
0xfe, 0xba, 0x9f, 0x4f, 0x13, 0x81, 0x7a, 0x71, 0xd6, 0xf9, 0x0a, 0x1a, 0x17, 0xc4,
0x3a, 0x15, 0xc0, 0x38, 0xd9, 0x88, 0xb5, 0xb2, 0x9e, 0xdf, 0xfe, 0x2d, 0x6a, 0x06,
0x28, 0x13, 0xce, 0xdb, 0xe8, 0x52, 0xcd, 0xe3, 0x02, 0xb3, 0xe3, 0x3b, 0x69, 0x68,
0x46, 0xd2, 0xa8, 0xe3, 0x6b, 0xd6, 0x80, 0xef, 0xcc, 0x6c, 0xd3, 0xf9, 0xe9, 0xa4,
0xc1, 0xae, 0x8c, 0xac, 0x10, 0xcc, 0x52, 0x44, 0xd1, 0x31, 0x67, 0x71, 0x40, 0x39,
0x91, 0x76, 0xed, 0x46, 0x70, 0x00, 0x19, 0xa0, 0x04, 0xa1, 0x63, 0x80, 0x6f, 0x7f,
0xa4, 0x67, 0xfc, 0x4e, 0x17, 0xb4, 0x61, 0x7b, 0xbd, 0x76, 0x41, 0xaa, 0xff, 0x7f,
0xf5, 0x63, 0x96, 0xba, 0x8c, 0x08, 0xa8, 0xbe, 0x10, 0x0b, 0x33, 0xa2, 0x0b, 0x5d,
0xaf, 0x13, 0x4a, 0x2a, 0xef, 0xa5, 0xe1, 0xc3, 0x49, 0x67, 0x70, 0xdc, 0xf6, 0xba,
0xa4, 0xf7, 0xbb,
];
let digest = [
0xa9, 0xdb, 0x49, 0x0c, 0x70, 0x8c, 0xc7, 0x25, 0x48, 0xd7, 0x86, 0x35, 0xaa, 0x7d,
0xa7, 0x9b, 0xb2, 0x53, 0xf9, 0x45, 0xd7, 0x10, 0xe5, 0xcb, 0x67, 0x7a, 0x47, 0x4e,
0xfc, 0x7c, 0x65, 0xa2, 0xaa, 0xb4, 0x5b, 0xc7, 0xca, 0x11, 0x13, 0xc8, 0xce, 0x0f,
0x3c, 0x32, 0xe1, 0x39, 0x9d, 0xe9, 0xc4, 0x59, 0x53, 0x5e, 0x88, 0x16, 0x52, 0x1a,
0xb7, 0x14, 0xb2, 0xa6, 0xcd, 0x20, 0x05, 0x25,
];
assert_eq!(Sha512::hash(&msg), digest);
}
#[test]
fn update() {
let msg = [
0x4f, 0x05, 0x60, 0x09, 0x50, 0x66, 0x4d, 0x51, 0x90, 0xa2, 0xeb, 0xc2, 0x9c, 0x9e,
0xdb, 0x89, 0xc2, 0x00, 0x79, 0xa4, 0xd3, 0xe6, 0xbc, 0x3b, 0x27, 0xd7, 0x5e, 0x34,
0xe2, 0xfa, 0x3d, 0x02, 0x76, 0x85, 0x02, 0xbd, 0x69, 0x79, 0x00, 0x78, 0x59, 0x8d,
0x5f, 0xcf, 0x3d, 0x67, 0x79, 0xbf, 0xed, 0x12, 0x84, 0xbb, 0xe5, 0xad, 0x72, 0xfb,
0x45, 0x60, 0x15, 0x18, 0x1d, 0x95, 0x87, 0xd6, 0xe8, 0x64, 0xc9, 0x40, 0x56, 0x4e,
0xaa, 0xfb, 0x4f, 0x2f, 0xea, 0xd4, 0x34, 0x6e, 0xa0, 0x9b, 0x68, 0x77, 0xd9, 0x34,
0x0f, 0x6b, 0x82, 0xeb, 0x15, 0x15, 0x88, 0x08, 0x72, 0x21, 0x3d, 0xa3, 0xad, 0x88,
0xfe, 0xba, 0x9f, 0x4f, 0x13, 0x81, 0x7a, 0x71, 0xd6, 0xf9, 0x0a, 0x1a, 0x17, 0xc4,
0x3a, 0x15, 0xc0, 0x38, 0xd9, 0x88, 0xb5, 0xb2, 0x9e, 0xdf, 0xfe, 0x2d, 0x6a, 0x06,
0x28, 0x13, 0xce, 0xdb, 0xe8, 0x52, 0xcd, 0xe3, 0x02, 0xb3, 0xe3, 0x3b, 0x69, 0x68,
0x46, 0xd2, 0xa8, 0xe3, 0x6b, 0xd6, 0x80, 0xef, 0xcc, 0x6c, 0xd3, 0xf9, 0xe9, 0xa4,
0xc1, 0xae, 0x8c, 0xac, 0x10, 0xcc, 0x52, 0x44, 0xd1, 0x31, 0x67, 0x71, 0x40, 0x39,
0x91, 0x76, 0xed, 0x46, 0x70, 0x00, 0x19, 0xa0, 0x04, 0xa1, 0x63, 0x80, 0x6f, 0x7f,
0xa4, 0x67, 0xfc, 0x4e, 0x17, 0xb4, 0x61, 0x7b, 0xbd, 0x76, 0x41, 0xaa, 0xff, 0x7f,
0xf5, 0x63, 0x96, 0xba, 0x8c, 0x08, 0xa8, 0xbe, 0x10, 0x0b, 0x33, 0xa2, 0x0b, 0x5d,
0xaf, 0x13, 0x4a, 0x2a, 0xef, 0xa5, 0xe1, 0xc3, 0x49, 0x67, 0x70, 0xdc, 0xf6, 0xba,
0xa4, 0xf7, 0xbb,
];
let digest = [
0xa9, 0xdb, 0x49, 0x0c, 0x70, 0x8c, 0xc7, 0x25, 0x48, 0xd7, 0x86, 0x35, 0xaa, 0x7d,
0xa7, 0x9b, 0xb2, 0x53, 0xf9, 0x45, 0xd7, 0x10, 0xe5, 0xcb, 0x67, 0x7a, 0x47, 0x4e,
0xfc, 0x7c, 0x65, 0xa2, 0xaa, 0xb4, 0x5b, 0xc7, 0xca, 0x11, 0x13, 0xc8, 0xce, 0x0f,
0x3c, 0x32, 0xe1, 0x39, 0x9d, 0xe9, 0xc4, 0x59, 0x53, 0x5e, 0x88, 0x16, 0x52, 0x1a,
0xb7, 0x14, 0xb2, 0xa6, 0xcd, 0x20, 0x05, 0x25,
];
let mut hasher = Sha512::new();
let blocks = msg.chunks_exact(Sha512::BLOCK_SIZE);
let remainder = blocks.remainder();
for block in blocks {
hasher.update(block.try_into().unwrap());
}
assert_eq!(hasher.finish_with(remainder), digest);
}
}