ferrosys 0.8.0

Pure-Rust filesystem formatter and reader: ext4, ext3, ext2, FAT32, FAT16, FAT12, exFAT, btrfs, and APFS — rootless, in userspace, byte-reproducible
Documentation
//! SHA-256, from FIPS 180-4 ("Secure Hash Standard", NIST, 2015): section 4.2.2 for the
//! constants, 5.1.1 for the padding, 5.3.3 for the initial value, and 6.2.2 for the
//! computation. Words are big-endian throughout, as the standard specifies.

use crate::bytes::{get_u32_be, put_u32_be};

/// The 64 round constants of section 4.2.2.
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,
];

/// The initial hash value of section 5.3.3.
const INITIAL_HASH: [u32; 8] = [
    0x6a09_e667,
    0xbb67_ae85,
    0x3c6e_f372,
    0xa54f_f53a,
    0x510e_527f,
    0x9b05_688c,
    0x1f83_d9ab,
    0x5be0_cd19,
];

/// Bytes one message block holds.
const BLOCK: usize = 64;

/// Fold one 64-byte block into the hash value: the computation of section 6.2.2.
fn compress(h: &mut [u32; 8], block: &[u8; BLOCK]) {
    let mut w = [0u32; 64];
    for (t, word) in w.iter_mut().take(16).enumerate() {
        *word = get_u32_be(block, t * 4);
    }
    for t in 16..64 {
        let s0 = w[t - 15].rotate_right(7) ^ w[t - 15].rotate_right(18) ^ (w[t - 15] >> 3);
        let s1 = w[t - 2].rotate_right(17) ^ w[t - 2].rotate_right(19) ^ (w[t - 2] >> 10);
        w[t] = w[t - 16]
            .wrapping_add(s0)
            .wrapping_add(w[t - 7])
            .wrapping_add(s1);
    }
    let [mut a, mut b, mut c, mut d, mut e, mut f, mut g, mut hh] = *h;
    for t in 0..64 {
        let big_s1 = e.rotate_right(6) ^ e.rotate_right(11) ^ e.rotate_right(25);
        let ch = (e & f) ^ (!e & g);
        let t1 = hh
            .wrapping_add(big_s1)
            .wrapping_add(ch)
            .wrapping_add(K[t])
            .wrapping_add(w[t]);
        let big_s0 = a.rotate_right(2) ^ a.rotate_right(13) ^ a.rotate_right(22);
        let maj = (a & b) ^ (a & c) ^ (b & c);
        let t2 = big_s0.wrapping_add(maj);
        hh = g;
        g = f;
        f = e;
        e = d.wrapping_add(t1);
        d = c;
        c = b;
        b = a;
        a = t1.wrapping_add(t2);
    }
    for (word, add) in h.iter_mut().zip([a, b, c, d, e, f, g, hh]) {
        *word = word.wrapping_add(add);
    }
}

/// The SHA-256 digest of `bytes`.
#[must_use]
pub(crate) fn sha256(bytes: &[u8]) -> [u8; 32] {
    let mut h = INITIAL_HASH;
    let (blocks, rest) = bytes.as_chunks::<BLOCK>();
    for block in blocks {
        compress(&mut h, block);
    }
    // Section 5.1.1: a one bit, zeros to 56 bytes into the last block, and the message's
    // length in bits as a big-endian 64-bit word — which spills into a second block where
    // the remainder leaves fewer than nine bytes.
    let mut tail = [0u8; BLOCK * 2];
    tail[..rest.len()].copy_from_slice(rest);
    tail[rest.len()] = 0x80;
    let tail_len = if rest.len() < BLOCK - 8 {
        BLOCK
    } else {
        BLOCK * 2
    };
    let bits = (bytes.len() as u64).wrapping_mul(8);
    put_u32_be(&mut tail, tail_len - 8, (bits >> 32) as u32);
    put_u32_be(&mut tail, tail_len - 4, bits as u32);
    for block in tail[..tail_len].as_chunks::<BLOCK>().0 {
        compress(&mut h, block);
    }
    let mut out = [0u8; 32];
    for (i, word) in h.into_iter().enumerate() {
        put_u32_be(&mut out, i * 4, word);
    }
    out
}