bab_rs 0.5.0

An implementation of the Bab family of hash functions, and its WILLIAM3 instantiation.
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
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

mod basics;
mod portable;

mod hasher;
pub use hasher::William3Hasher;

mod batch;
pub use batch::{batch_hash, batch_hash_keyed};

mod digest;
pub use digest::William3Digest;

pub mod storage;

use crate::{
    generic::BabInstantiation,
    william3::{
        basics::{BLOCK_LEN, CHUNK_END, CHUNK_START, IV, KEYED_HASH, PARENT, ROOT},
        portable::hash1,
    },
};

/// The [number of bytes](https://worm-blossom.github.io/bab/#width) in a WILLIAM3 digest.
pub const WIDTH: usize = 32;

/// The [number of bytes](https://worm-blossom.github.io/bab/#chunk_size) in a WILLIAM3.
pub const CHUNK_SIZE: usize = 1024;

/// A convenient type alias for the labels of the Merkle tree used by Bab.
pub type Label<const WIDTH: usize> = [u8; WIDTH];

/// A convenient type alias for a Bab chunk of data.
pub type Chunk<const CHUNK_SIZE: usize> = [u8; CHUNK_SIZE];

#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub(crate) struct HashChunkContext {
    key: Option<[u32; 8]>,
}

impl HashChunkContext {
    pub fn new() -> Self {
        Self { key: None }
    }

    pub fn new_keyed(key: [u32; 8]) -> Self {
        Self { key: Some(key) }
    }
}

pub(crate) fn hash_chunk(
    chunk: &[u8],
    is_root: bool,
    state: &HashChunkContext,
    output: &mut [u8; WIDTH],
) {
    let mut flags = 0;
    if state.key.is_some() {
        flags |= KEYED_HASH
    }

    let flags_start = CHUNK_START;

    let mut flags_end = CHUNK_END;
    if is_root {
        flags_end |= ROOT;
    }

    hash1(
        chunk,
        state.key.as_ref().unwrap_or(IV),
        0,
        flags,
        flags_start,
        flags_end,
        output,
    );
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub(crate) struct HashInnerContext {
    key: Option<[u32; 8]>,
}

impl HashInnerContext {
    pub fn new() -> Self {
        Self { key: None }
    }

    pub fn new_keyed(key: [u32; 8]) -> Self {
        Self { key: Some(key) }
    }
}

pub(crate) fn hash_inner(
    left_label: &[u8; WIDTH],
    right_label: &[u8; WIDTH],
    length_of_subtree: u64,
    is_root: bool,
    state: &HashInnerContext,
    output: &mut [u8; WIDTH],
) {
    let mut flags = PARENT;
    if is_root {
        flags |= ROOT
    }

    let flags_start = 0;
    let flags_end = 0;

    let mut message_words = [0; BLOCK_LEN];
    message_words[..WIDTH].copy_from_slice(left_label);
    message_words[WIDTH..].copy_from_slice(right_label);

    hash1(
        &message_words[..],
        state.key.as_ref().unwrap_or(IV),
        length_of_subtree,
        flags,
        flags_start,
        flags_end,
        output,
    );
}

pub(crate) fn william3_instantiation()
-> BabInstantiation<WIDTH, CHUNK_SIZE, HashChunkContext, HashInnerContext> {
    BabInstantiation {
        hash_chunk,
        hash_inner,
        hash_chunk_context: HashChunkContext { key: None },
        hash_inner_context: HashInnerContext { key: None },
    }
}