-
Notifications
You must be signed in to change notification settings - Fork 238
/
lib.rs
160 lines (130 loc) · 4.15 KB
/
lib.rs
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
#![no_std]
#![doc = include_str!("../README.md")]
#![doc(
html_logo_url = "https://raw.githubusercontent.com/RustCrypto/media/6ee8e381/logo.svg",
html_favicon_url = "https://raw.githubusercontent.com/RustCrypto/media/6ee8e381/logo.svg"
)]
#![cfg_attr(docsrs, feature(doc_auto_cfg))]
#![warn(missing_docs, rust_2018_idioms)]
pub use digest::{self, Digest};
use core::{convert::TryInto, fmt, slice::from_ref};
use digest::{
array::Array,
block_buffer::Eager,
core_api::{
AlgorithmName, Block, BlockSizeUser, Buffer, BufferKindUser, CoreWrapper, FixedOutputCore,
OutputSizeUser, Reset, UpdateCore,
},
crypto_common::hazmat::{DeserializeStateError, SerializableState, SerializedState},
typenum::{Unsigned, U20, U28, U64},
HashMarker, Output,
};
#[cfg(feature = "oid")]
use digest::const_oid::{AssociatedOid, ObjectIdentifier};
#[cfg(feature = "zeroize")]
use digest::zeroize::{Zeroize, ZeroizeOnDrop};
mod compress;
pub use compress::compress;
const STATE_LEN: usize = 5;
const BLOCK_SIZE: usize = <Sha1Core as BlockSizeUser>::BlockSize::USIZE;
/// Core SHA-1 hasher state.
#[derive(Clone)]
pub struct Sha1Core {
h: [u32; STATE_LEN],
block_len: u64,
}
/// SHA-1 hasher state.
pub type Sha1 = CoreWrapper<Sha1Core>;
impl HashMarker for Sha1Core {}
impl BlockSizeUser for Sha1Core {
type BlockSize = U64;
}
impl BufferKindUser for Sha1Core {
type BufferKind = Eager;
}
impl OutputSizeUser for Sha1Core {
type OutputSize = U20;
}
impl UpdateCore for Sha1Core {
#[inline]
fn update_blocks(&mut self, blocks: &[Block<Self>]) {
self.block_len += blocks.len() as u64;
let blocks = Array::cast_slice_to_core(blocks);
compress(&mut self.h, blocks);
}
}
impl FixedOutputCore for Sha1Core {
#[inline]
fn finalize_fixed_core(&mut self, buffer: &mut Buffer<Self>, out: &mut Output<Self>) {
let bs = Self::BlockSize::U64;
let bit_len = 8 * (buffer.get_pos() as u64 + bs * self.block_len);
let mut h = self.h;
buffer.len64_padding_be(bit_len, |b| compress(&mut h, from_ref(&b.0)));
for (chunk, v) in out.chunks_exact_mut(4).zip(h.iter()) {
chunk.copy_from_slice(&v.to_be_bytes());
}
}
}
impl Default for Sha1Core {
#[inline]
fn default() -> Self {
Self {
h: [0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0],
block_len: 0,
}
}
}
impl Reset for Sha1Core {
#[inline]
fn reset(&mut self) {
*self = Default::default();
}
}
impl AlgorithmName for Sha1Core {
fn write_alg_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("Sha1")
}
}
impl fmt::Debug for Sha1Core {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("Sha1Core { ... }")
}
}
#[cfg(feature = "oid")]
#[cfg_attr(docsrs, doc(cfg(feature = "oid")))]
impl AssociatedOid for Sha1Core {
const OID: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.3.14.3.2.26");
}
impl Drop for Sha1Core {
fn drop(&mut self) {
#[cfg(feature = "zeroize")]
{
self.h.zeroize();
self.block_len.zeroize();
}
}
}
#[cfg(feature = "zeroize")]
impl ZeroizeOnDrop for Sha1Core {}
impl SerializableState for Sha1Core {
type SerializedStateSize = U28;
fn serialize(&self) -> SerializedState<Self> {
let mut serialized_h = SerializedState::<Self>::default();
for (val, chunk) in self.h.iter().zip(serialized_h.chunks_exact_mut(4)) {
chunk.copy_from_slice(&val.to_le_bytes());
}
serialized_h[20..].copy_from_slice(&self.block_len.to_le_bytes());
serialized_h
}
fn deserialize(
serialized_state: &SerializedState<Self>,
) -> Result<Self, DeserializeStateError> {
let (serialized_h, serialized_block_len) = serialized_state.split::<U20>();
let mut h = [0; STATE_LEN];
for (val, chunk) in h.iter_mut().zip(serialized_h.chunks_exact(4)) {
*val = u32::from_le_bytes(chunk.try_into().unwrap());
}
let block_len = u64::from_le_bytes(*serialized_block_len.as_ref());
Ok(Self { h, block_len })
}
}