k12 0.5.1

Implementation of the KangarooTwelve family of extendable-output functions
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

extern crate alloc;

use alloc::vec::Vec;
use core::fmt;
use digest::{
    CollisionResistance, CustomizedInit, ExtendableOutput, ExtendableOutputReset, HashMarker,
    Reset, Update,
    common::AlgorithmName,
    consts::{U16, U32},
};

use crate::{Kt, KtReader, utils::length_encode};

/// Customized KangarooTwelve hasher generic over rate with owned customization string.
#[derive(Clone)]
pub struct CustomKt<const RATE: usize> {
    customization: Vec<u8>,
    inner: Kt<RATE>,
}

impl<const RATE: usize> CustomizedInit for CustomKt<RATE> {
    #[inline]
    fn new_customized(customization: &[u8]) -> Self {
        let len = u64::try_from(customization.len()).expect("length should always fit into `u64`");
        let mut buf = Vec::new();
        length_encode(len, |enc_len| {
            buf = Vec::with_capacity(customization.len() + enc_len.len());
            buf.extend_from_slice(customization);
            buf.extend_from_slice(enc_len);
        });

        Self {
            customization: buf,
            inner: Default::default(),
        }
    }
}

impl<const RATE: usize> Default for CustomKt<RATE> {
    #[inline]
    fn default() -> Self {
        Self::new_customized(&[])
    }
}

impl<const RATE: usize> fmt::Debug for CustomKt<RATE> {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
        write!(f, "CustomKt{} {{ ... }}", 4 * (200 - RATE))
    }
}

impl<const RATE: usize> AlgorithmName for CustomKt<RATE> {
    #[inline]
    fn write_alg_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
        Kt::<RATE>::write_alg_name(f)
    }
}

impl<const RATE: usize> HashMarker for CustomKt<RATE> {}

impl<const RATE: usize> Update for CustomKt<RATE> {
    #[inline]
    fn update(&mut self, data: &[u8]) {
        self.inner.update(data);
    }
}

impl<const RATE: usize> Reset for CustomKt<RATE> {
    #[inline]
    fn reset(&mut self) {
        self.inner.reset();
    }
}

impl<const RATE: usize> ExtendableOutput for CustomKt<RATE> {
    type Reader = KtReader<RATE>;

    #[inline]
    fn finalize_xof(mut self) -> Self::Reader {
        self.inner.update(&self.customization);
        self.inner.raw_finalize()
    }
}

impl<const RATE: usize> ExtendableOutputReset for CustomKt<RATE> {
    #[inline]
    fn finalize_xof_reset(&mut self) -> Self::Reader {
        self.inner.update(&self.customization);
        let reader = self.inner.raw_finalize();
        self.inner.reset();
        reader
    }
}

impl<const RATE: usize> Drop for CustomKt<RATE> {
    #[inline]
    fn drop(&mut self) {
        #[cfg(feature = "zeroize")]
        {
            use digest::zeroize::Zeroize;
            self.customization.zeroize();
            // `inner` is zeroized by `Drop`
        }
    }
}

#[cfg(feature = "zeroize")]
impl<const RATE: usize> digest::zeroize::ZeroizeOnDrop for CustomKt<RATE> {}

/// Customized KT128 hasher with owned customization string.
pub type CustomKt128 = CustomKt<168>;
/// Customized KT256 hasher with owned customization string.
pub type CustomKt256 = CustomKt<136>;

impl CollisionResistance for CustomKt128 {
    // https://www.rfc-editor.org/rfc/rfc9861.html#section-7-7
    type CollisionResistance = U16;
}

impl CollisionResistance for CustomKt256 {
    // https://www.rfc-editor.org/rfc/rfc9861.html#section-7-8
    type CollisionResistance = U32;
}