Files
ahash
aho_corasick
ansi_term
anyhow
atty
bech32
bincode
bit_set
bit_vec
bitcoin
bitcoin_hashes
bitflags
cfg_if
clap
convert_case
core2
crunchy
cryptoxide
enum_primitive
fancy_regex
hashbrown
hex
hex_literal
itoa
libc
libloading
memchr
num
num_bigint
num_complex
num_integer
num_iter
num_rational
num_traits
ordered_float
paste
proc_macro2
proc_macro_error
proc_macro_error_attr
qimalloc
quote
regex
regex_syntax
remain
rust_ssvm
ryu
secp256k1
secp256k1_sys
serde
serde_derive
serde_json
serde_value
sewup
sewup_derive
ss_ewasm_api
ssvm_evmc_client
ssvm_evmc_sys
strsim
syn
textwrap
thiserror
thiserror_impl
tiny_keccak
toml
unicode_width
unicode_xid
vec_map
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
use crate::cryptoutil::write_u32v_be;

pub(super) const STATE_LEN: usize = 8;
pub(super) const BLOCK_LEN: usize = 16;
pub(super) const BLOCK_LEN_BYTES: usize = BLOCK_LEN * core::mem::size_of::<u32>();

use super::impl256::*;

// A structure that represents that state of a digest computation for
// the SHA-2 32 bits family of digest functions
#[derive(Clone)]
pub(super) struct Engine {
    h: [u32; STATE_LEN],
}

impl Engine {
    pub(super) const fn new(h: &[u32; STATE_LEN]) -> Self {
        Self { h: *h }
    }

    pub(super) fn reset(&mut self, h: &[u32; STATE_LEN]) {
        self.h = *h;
    }

    /// Process a block in bytes with the SHA-2 32bits algorithm.
    pub fn blocks(&mut self, block: &[u8]) {
        assert_eq!(block.len() % BLOCK_LEN_BYTES, 0);
        digest_block(&mut self.h, block);
    }

    #[allow(dead_code)]
    pub(super) fn output_224bits(&self, out: &mut [u8; 28]) {
        write_u32v_be(out, &self.h[0..7]);
    }

    #[allow(dead_code)]
    pub(super) fn output_256bits(&self, out: &mut [u8; 32]) {
        write_u32v_be(out, &self.h);
    }

    pub(super) fn output_224bits_at(&self, out: &mut [u8]) {
        write_u32v_be(&mut out[0..28], &self.h[0..7]);
    }

    pub(super) fn output_256bits_at(&self, out: &mut [u8]) {
        write_u32v_be(&mut out[0..32], &self.h);
    }
}