libmhash 0.2.1

A file hashing library that can do multiple hashes for multile files at the same time.
Documentation 
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

use sha1::Digest;

use crate::{paranoid_hash::Hasher, Error, Result};

use super::{SHA1_BLOCK_SIZE, SHA1_DIGEST_SIZE};

#[derive(Clone, Debug, Default)]
pub struct SHA1 {
    state: sha1::Sha1,
    is_done: bool,
    digest: [u8; Self::DIGEST_SIZE],
}

impl Hasher for SHA1 {
    fn update(&mut self, data: &[u8]) -> Result<()> {
        if self.is_done {
            return Err(Error::UpdatingAfterFinished);
        }

        self.state.update(data);
        Ok(())
    }

    fn update_last(&mut self, data: &[u8]) -> Result<()> {
        if self.is_done {
            return Err(Error::UpdatingAfterFinished);
        }

        self.is_done = true;

        self.state.update(data);
        let state = self.state.clone();
        let digest = state.finalize();
        self.digest.copy_from_slice(&digest[..]);
        Ok(())
    }

    fn digest(&self) -> Result<&[u8]> {
        if !self.is_done {
            return Err(Error::NotFinished);
        }

        Ok(&self.digest)
    }

    fn reset(&mut self) {
        *self = Self::new();
    }

    fn block_size(&self) -> usize {
        Self::BLOCK_SIZE
    }

    fn digest_size(&self) -> usize {
        Self::DIGEST_SIZE
    }
}

impl SHA1 {
    pub const BLOCK_SIZE: usize = SHA1_BLOCK_SIZE;
    pub const DIGEST_SIZE: usize = SHA1_DIGEST_SIZE;

    pub fn new() -> Self {
        Self {
            state: sha1::Sha1::new(),
            is_done: false,
            digest: [0; Self::DIGEST_SIZE],
        }
    }
}