recipher 0.2.1

CipherStash key generation library for ZeroKMS
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

pub(crate) type Block<const B: usize> = [u8; B];

#[derive(Debug)]
pub(crate) struct CipherText<const B: usize> {
    pub(crate) data: Vec<Block<B>>,
    pub(crate) block_count: usize,
}

impl<const B: usize> CipherText<B> {
    pub(crate) fn init(block_count: usize) -> Self {
        Self {
            data: vec![[0u8; B]; block_count + 1],
            block_count: block_count + 1,
        }
    }

    pub(crate) fn aont_key(&self) -> &Block<B> {
        &self.data[self.block_count - 1]
    }

    pub(crate) fn aont_key_mut(&mut self) -> &mut Block<B> {
        &mut self.data[self.block_count - 1]
    }

    pub(crate) fn blocks(&self) -> &[Block<B>] {
        &self.data[..(self.block_count - 1)]
    }

    pub(crate) fn to_bytes(&self) -> Vec<u8> {
        self.data.iter().flatten().copied().collect()
    }

    pub(crate) fn from_bytes(input: &[u8]) -> Self {
        let data: Vec<Block<B>> = input
            .chunks(B)
            .map(|bytes| {
                let mut block = [0u8; B];
                block.copy_from_slice(bytes);
                block
            })
            .collect();

        let block_count = data.len();

        Self { data, block_count }
    }
}