use std::fmt;
use serde::{Deserialize, Deserializer, Serialize, Serializer, de};
const DIGEST_BYTES: usize = 32;
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Digest([u8; DIGEST_BYTES]);
impl Digest {
#[must_use]
pub fn of_bytes(bytes: &[u8]) -> Self {
Self(sha256(bytes))
}
pub fn from_hex(value: &str) -> Result<Self, DigestParseError> {
if value.len() != DIGEST_BYTES * 2 {
return Err(DigestParseError);
}
let mut bytes = [0_u8; DIGEST_BYTES];
for (index, pair) in value.as_bytes().as_chunks::<2>().0.iter().enumerate() {
let high = decode_nibble(pair[0]).ok_or(DigestParseError)?;
let low = decode_nibble(pair[1]).ok_or(DigestParseError)?;
bytes[index] = (high << 4) | low;
}
Ok(Self(bytes))
}
#[must_use]
pub fn to_hex(self) -> String {
let mut encoded = String::with_capacity(DIGEST_BYTES * 2);
for byte in self.0 {
use fmt::Write as _;
write!(encoded, "{byte:02x}").expect("writing to a String cannot fail");
}
encoded
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct DigestParseError;
impl fmt::Display for DigestParseError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(
"digest must contain exactly 64 lowercase or uppercase hexadecimal characters",
)
}
}
impl std::error::Error for DigestParseError {}
impl fmt::Display for Digest {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(&self.to_hex())
}
}
impl Serialize for Digest {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.serialize_str(&self.to_hex())
}
}
impl<'de> Deserialize<'de> for Digest {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let value = String::deserialize(deserializer)?;
Self::from_hex(&value).map_err(de::Error::custom)
}
}
fn decode_nibble(value: u8) -> Option<u8> {
match value {
b'0'..=b'9' => Some(value - b'0'),
b'a'..=b'f' => Some(value - b'a' + 10),
b'A'..=b'F' => Some(value - b'A' + 10),
_ => None,
}
}
fn sha256(input: &[u8]) -> [u8; DIGEST_BYTES] {
let mut state = [
0x6a09_e667_u32,
0xbb67_ae85,
0x3c6e_f372,
0xa54f_f53a,
0x510e_527f,
0x9b05_688c,
0x1f83_d9ab,
0x5be0_cd19,
];
let bit_len = (input.len() as u64).wrapping_mul(8);
let padded_len = input.len().saturating_add(9).div_ceil(64) * 64;
let mut padded = Vec::with_capacity(padded_len);
padded.extend_from_slice(input);
padded.push(0x80);
padded.resize(padded_len - 8, 0);
padded.extend_from_slice(&bit_len.to_be_bytes());
for chunk in padded.as_chunks::<64>().0 {
compress(&mut state, chunk);
}
let mut output = [0_u8; DIGEST_BYTES];
for (index, word) in state.into_iter().enumerate() {
output[index * 4..index * 4 + 4].copy_from_slice(&word.to_be_bytes());
}
output
}
fn compress(state: &mut [u32; 8], chunk: &[u8; 64]) {
let mut schedule = [0_u32; 64];
for (index, word) in chunk.as_chunks::<4>().0.iter().enumerate() {
schedule[index] = u32::from_be_bytes([word[0], word[1], word[2], word[3]]);
}
for index in 16..64 {
let s0 = schedule[index - 15].rotate_right(7)
^ schedule[index - 15].rotate_right(18)
^ (schedule[index - 15] >> 3);
let s1 = schedule[index - 2].rotate_right(17)
^ schedule[index - 2].rotate_right(19)
^ (schedule[index - 2] >> 10);
schedule[index] = schedule[index - 16]
.wrapping_add(s0)
.wrapping_add(schedule[index - 7])
.wrapping_add(s1);
}
let mut working = *state;
for (word, constant) in schedule.into_iter().zip(ROUND_CONSTANTS) {
let big_s1 =
working[4].rotate_right(6) ^ working[4].rotate_right(11) ^ working[4].rotate_right(25);
let choice = (working[4] & working[5]) ^ (!working[4] & working[6]);
let temporary1 = working[7]
.wrapping_add(big_s1)
.wrapping_add(choice)
.wrapping_add(constant)
.wrapping_add(word);
let big_s0 =
working[0].rotate_right(2) ^ working[0].rotate_right(13) ^ working[0].rotate_right(22);
let majority =
(working[0] & working[1]) ^ (working[0] & working[2]) ^ (working[1] & working[2]);
let temporary2 = big_s0.wrapping_add(majority);
working = [
temporary1.wrapping_add(temporary2),
working[0],
working[1],
working[2],
working[3].wrapping_add(temporary1),
working[4],
working[5],
working[6],
];
}
for (current, value) in state.iter_mut().zip(working) {
*current = current.wrapping_add(value);
}
}
const ROUND_CONSTANTS: [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,
];
#[cfg(test)]
mod tests {
use super::Digest;
#[test]
fn matches_sha256_test_vectors() {
assert_eq!(
Digest::of_bytes(b"").to_hex(),
"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
);
assert_eq!(
Digest::of_bytes(b"abc").to_hex(),
"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
);
}
#[test]
fn rejects_malformed_hex() {
assert!(Digest::from_hex("abcd").is_err());
assert!(Digest::from_hex(&"z".repeat(64)).is_err());
}
}