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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
use digest;
use generic_array::GenericArray;
use block_buffer::BlockBuffer;
use generic_array::typenum::{U28, U32, U64};
use byte_tools::write_u32v_be;
use consts::{STATE_LEN, H224, H256};
#[cfg(not(feature = "asm"))]
use sha256_utils::compress256;
#[cfg(feature = "asm")]
use sha2_asm::compress256;
type BlockSize = U64;
pub type Block = GenericArray<u8, BlockSize>;
#[derive(Clone, Copy)]
struct Engine256State {
h: [u32; 8],
}
impl Engine256State {
fn new(h: &[u32; STATE_LEN]) -> Engine256State { Engine256State { h: *h } }
pub fn process_block(&mut self, data: &Block) {
compress256(&mut self.h, data);
}
}
#[derive(Clone, Copy)]
struct Engine256 {
len: u64,
buffer: BlockBuffer<BlockSize>,
state: Engine256State,
}
impl Engine256 {
fn new(h: &[u32; STATE_LEN]) -> Engine256 {
Engine256 {
len: 0,
buffer: Default::default(),
state: Engine256State::new(h),
}
}
fn input(&mut self, input: &[u8]) {
self.len += input.len() as u64;
let self_state = &mut self.state;
self.buffer.input(input, |input| self_state.process_block(input));
}
fn finish(&mut self) {
let self_state = &mut self.state;
let l = (self.len<<3).to_be();
self.buffer.len_padding(l, |input| self_state.process_block(input));
}
}
#[derive(Clone, Copy)]
pub struct Sha256 {
engine: Engine256,
}
impl Default for Sha256 {
fn default() -> Self { Sha256 { engine: Engine256::new(&H256) } }
}
impl digest::BlockInput for Sha256 {
type BlockSize = BlockSize;
}
impl digest::Input for Sha256 {
fn process(&mut self, msg: &[u8]) { self.engine.input(msg); }
}
impl digest::FixedOutput for Sha256 {
type OutputSize = U32;
fn fixed_result(mut self) -> GenericArray<u8, Self::OutputSize> {
self.engine.finish();
let mut out = GenericArray::default();
write_u32v_be(&mut out, &self.engine.state.h);
out
}
}
#[derive(Clone, Copy)]
pub struct Sha224 {
engine: Engine256,
}
impl Default for Sha224 {
fn default() -> Self { Sha224 { engine: Engine256::new(&H224) } }
}
impl digest::BlockInput for Sha224 {
type BlockSize = BlockSize;
}
impl digest::Input for Sha224 {
fn process(&mut self, msg: &[u8]) { self.engine.input(msg); }
}
impl digest::FixedOutput for Sha224 {
type OutputSize = U28;
fn fixed_result(mut self) -> GenericArray<u8, Self::OutputSize> {
self.engine.finish();
let mut out = GenericArray::default();
write_u32v_be(&mut out[..28], &self.engine.state.h[..7]);
out
}
}