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
#![no_std]
extern crate byte_tools;
extern crate generic_array;
use generic_array::{GenericArray, ArrayLength};
use byte_tools::zero;
type Block<N> = GenericArray<u8, N>;
#[derive(Clone, Copy)]
pub struct DigestBuffer<N: ArrayLength<u8>> where N::ArrayType: Copy {
buffer: GenericArray<u8, N>,
pos: usize,
}
impl <N: ArrayLength<u8>> DigestBuffer<N> where N::ArrayType: Copy {
pub fn new() -> DigestBuffer<N> {
DigestBuffer::<N> {
buffer: Default::default(),
pos: 0,
}
}
pub fn input<F: FnMut(&Block<N>)>(&mut self, mut input: &[u8], mut func: F) {
if self.pos != 0 {
let rem = N::to_usize() - self.pos;
if input.len() >= rem {
let (l, r) = input.split_at(rem);
input = r;
self.buffer[self.pos..].copy_from_slice(l);
self.pos = 0;
func(&self.buffer);
} else {
let end = self.pos + input.len();
self.buffer[self.pos..end].copy_from_slice(input);
self.pos = end;
return;
}
}
while input.len() >= N::to_usize() {
let (l, r) = input.split_at(N::to_usize());
input = r;
let block = GenericArray::from_slice(&l);
func(block);
}
self.buffer[..input.len()].copy_from_slice(input);
self.pos += input.len();
}
pub fn reset(&mut self) {
self.pos = 0;
}
pub fn zero_until(&mut self, idx: usize) {
assert!(idx >= self.pos);
zero(&mut self.buffer[self.pos..idx]);
self.pos = idx;
}
pub fn next(&mut self, len: usize) -> &mut [u8] {
self.pos += len;
&mut self.buffer[self.pos - len..self.pos]
}
pub fn full_buffer(& mut self) -> &Block<N> {
assert!(self.pos == self.size());
self.pos = 0;
&self.buffer
}
pub fn current_buffer(&mut self) -> &[u8] {
let tmp = self.pos;
self.pos = 0;
&self.buffer[..tmp]
}
pub fn position(&self) -> usize { self.pos }
pub fn remaining(&self) -> usize { self.size() - self.pos }
pub fn standard_padding<F: FnMut(&Block<N>)>(&mut self, rem: usize, mut func: F) {
let size = self.size();
self.next(1)[0] = 128;
if self.remaining() < rem {
self.zero_until(size);
func(self.full_buffer());
}
self.zero_until(size - rem);
}
pub fn size(&self) -> usize {
N::to_usize()
}
}
impl <N: ArrayLength<u8>> Default for DigestBuffer<N> where N::ArrayType: Copy {
fn default() -> Self { Self::new() }
}