Debian Codegraph @

src/block_api.rs

raw
1 use crate::utils::{IPAD, OPAD, get_der_key};
2 use core::{fmt, slice};
3 use digest::{
4 InvalidLength, KeyInit, MacMarker, Output, Reset,
5 block_api::{
6 AlgorithmName, Block, BlockSizeUser, Buffer, BufferKindUser, EagerHash, FixedOutputCore,
7 OutputSizeUser, UpdateCore,
8 },
9 block_buffer::Eager,
10 common::{Key, KeySizeUser},
11 };
12
13 /// Generic core HMAC instance, which operates over blocks.
14 pub struct HmacCore<D: EagerHash> {
15 digest: D::Core,
16 opad_digest: D::Core,
17 }
18
19 impl<D: EagerHash> Clone for HmacCore<D> {
20 fn clone(&self) -> Self {
21 Self {
22 digest: self.digest.clone(),
23 opad_digest: self.opad_digest.clone(),
24 }
25 }
26 }
27
28 impl<D: EagerHash> MacMarker for HmacCore<D> {}
29
30 impl<D: EagerHash> BufferKindUser for HmacCore<D> {
31 type BufferKind = Eager;
32 }
33
34 impl<D: EagerHash> KeySizeUser for HmacCore<D> {
35 type KeySize = <<D as EagerHash>::Core as BlockSizeUser>::BlockSize;
36 }
37
38 impl<D: EagerHash> BlockSizeUser for HmacCore<D> {
39 type BlockSize = <<D as EagerHash>::Core as BlockSizeUser>::BlockSize;
40 }
41
42 impl<D: EagerHash> OutputSizeUser for HmacCore<D> {
43 type OutputSize = <<D as EagerHash>::Core as OutputSizeUser>::OutputSize;
44 }
45
46 impl<D: EagerHash> KeyInit for HmacCore<D> {
47 #[inline(always)]
48 fn new(key: &Key<Self>) -> Self {
49 Self::new_from_slice(key.as_slice()).expect("HMAC accepts keys of any length")
50 }
51
52 #[inline(always)]
53 fn new_from_slice(key: &[u8]) -> Result<Self, InvalidLength> {
54 let mut buf = get_der_key::<D>(key);
55 buf.iter_mut().for_each(|b: &mut u8| *b ^= IPAD);
56
57 let mut digest = D::Core::default();
58 digest.update_blocks(slice::from_ref(&buf));
59
60 buf.iter_mut().for_each(|b: &mut u8| *b ^= IPAD ^ OPAD);
61
62 let mut opad_digest = D::Core::default();
63 opad_digest.update_blocks(slice::from_ref(&buf));
64
65 Ok(Self {
66 opad_digest,
67 digest,
68 })
69 }
70 }
71
72 impl<D: EagerHash> UpdateCore for HmacCore<D> {
73 #[inline(always)]
74 fn update_blocks(&mut self, blocks: &[Block<Self>]) {
75 self.digest.update_blocks(blocks);
76 }
77 }
78
79 impl<D: EagerHash> FixedOutputCore for HmacCore<D> {
80 #[inline(always)]
81 fn finalize_fixed_core(&mut self, buffer: &mut Buffer<Self>, out: &mut Output<Self>) {
82 let mut hash = Output::<D::Core>::default();
83 self.digest.finalize_fixed_core(buffer, &mut hash);
84 // finalize_fixed_core should reset the buffer as well, but
85 // to be extra safe we reset it explicitly again.
86 buffer.reset();
87 let h = &mut self.opad_digest;
88 buffer.digest_blocks(&hash, |b| h.update_blocks(b));
89 h.finalize_fixed_core(buffer, out);
90 }
91 }
92
93 impl<D: EagerHash + AlgorithmName> AlgorithmName for HmacCore<D> {
94 fn write_alg_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
95 f.write_str("Hmac<")?;
96 <D as AlgorithmName>::write_alg_name(f)?;
97 f.write_str(">")
98 }
99 }
100
101 impl<D: EagerHash> fmt::Debug for HmacCore<D>
102 where
103 D::Core: AlgorithmName,
104 {
105 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
106 f.write_str("HmacCore { ... }")
107 }
108 }
109
110 /// Generic core HMAC instance, which operates over blocks.
111 pub struct HmacResetCore<D: EagerHash> {
112 digest: D::Core,
113 opad_digest: D::Core,
114 ipad_digest: D::Core,
115 }
116
117 impl<D: EagerHash> Clone for HmacResetCore<D> {
118 fn clone(&self) -> Self {
119 Self {
120 digest: self.digest.clone(),
121 opad_digest: self.opad_digest.clone(),
122 ipad_digest: self.ipad_digest.clone(),
123 }
124 }
125 }
126
127 impl<D: EagerHash> MacMarker for HmacResetCore<D> {}
128
129 impl<D: EagerHash> BufferKindUser for HmacResetCore<D> {
130 type BufferKind = Eager;
131 }
132
133 impl<D: EagerHash> KeySizeUser for HmacResetCore<D> {
134 type KeySize = <<D as EagerHash>::Core as BlockSizeUser>::BlockSize;
135 }
136
137 impl<D: EagerHash> BlockSizeUser for HmacResetCore<D> {
138 type BlockSize = <<D as EagerHash>::Core as BlockSizeUser>::BlockSize;
139 }
140
141 impl<D: EagerHash> OutputSizeUser for HmacResetCore<D> {
142 type OutputSize = <<D as EagerHash>::Core as OutputSizeUser>::OutputSize;
143 }
144
145 impl<D: EagerHash> KeyInit for HmacResetCore<D> {
146 #[inline(always)]
147 fn new(key: &Key<Self>) -> Self {
148 Self::new_from_slice(key.as_slice()).expect("HMAC accepts keys of any length")
149 }
150
151 #[inline(always)]
152 fn new_from_slice(key: &[u8]) -> Result<Self, InvalidLength> {
153 let mut buf = get_der_key::<D>(key);
154 buf.iter_mut().for_each(|b: &mut u8| *b ^= IPAD);
155
156 let mut digest = D::Core::default();
157 digest.update_blocks(slice::from_ref(&buf));
158
159 buf.iter_mut().for_each(|b: &mut u8| *b ^= IPAD ^ OPAD);
160
161 let mut opad_digest = D::Core::default();
162 opad_digest.update_blocks(slice::from_ref(&buf));
163
164 Ok(Self {
165 ipad_digest: digest.clone(),
166 opad_digest,
167 digest,
168 })
169 }
170 }
171
172 impl<D: EagerHash> UpdateCore for HmacResetCore<D> {
173 #[inline(always)]
174 fn update_blocks(&mut self, blocks: &[Block<Self>]) {
175 self.digest.update_blocks(blocks);
176 }
177 }
178
179 impl<D: EagerHash> FixedOutputCore for HmacResetCore<D> {
180 #[inline(always)]
181 fn finalize_fixed_core(&mut self, buffer: &mut Buffer<Self>, out: &mut Output<Self>) {
182 let mut hash = Output::<D::Core>::default();
183 self.digest.finalize_fixed_core(buffer, &mut hash);
184 // finalize_fixed_core should reset the buffer as well, but
185 // to be extra safe we reset it explicitly again.
186 buffer.reset();
187 let mut h = self.opad_digest.clone();
188 buffer.digest_blocks(&hash, |b| h.update_blocks(b));
189 h.finalize_fixed_core(buffer, out);
190 }
191 }
192
193 impl<D: EagerHash> Reset for HmacResetCore<D> {
194 #[inline(always)]
195 fn reset(&mut self) {
196 self.digest = self.ipad_digest.clone();
197 }
198 }
199
200 impl<D: EagerHash + AlgorithmName> AlgorithmName for HmacResetCore<D> {
201 fn write_alg_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
202 f.write_str("Hmac<")?;
203 <D as AlgorithmName>::write_alg_name(f)?;
204 f.write_str(">")
205 }
206 }
207
208 impl<D: EagerHash> fmt::Debug for HmacResetCore<D>
209 where
210 D::Core: AlgorithmName,
211 {
212 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
213 f.write_str("HmacResetCore { ... }")
214 }
215 }