aegis 0.9.8

AEGIS authenticated ciphers (AEGIS-128, AEGIS-256, AEGIS-128X, AEGIS-256X)
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

mod aes {
    pub use softaes::Block;
    pub use softaes::SoftAesFast as Aes;
}

#[derive(Copy, Clone, Debug, Default)]
pub(crate) struct AesBlock(aes::Block);

impl AesBlock {
    #[inline(always)]
    pub fn from_bytes(bytes: &[u8]) -> AesBlock {
        AesBlock(aes::Block::from_slice(bytes))
    }

    #[inline(always)]
    pub fn to_bytes(&self) -> [u8; 16] {
        self.0.to_bytes()
    }

    #[inline(always)]
    pub fn xor(&self, other: AesBlock) -> AesBlock {
        AesBlock(self.0 ^ other.0)
    }

    #[inline(always)]
    pub fn and(&self, other: AesBlock) -> AesBlock {
        AesBlock(self.0 & other.0)
    }

    #[inline(always)]
    pub fn round(&self, rk: AesBlock) -> AesBlock {
        AesBlock(aes::Aes::block_encrypt(&self.0, &rk.0))
    }
}

/// A pair of AES blocks for parallel processing
#[derive(Copy, Clone, Debug, Default)]
pub(crate) struct AesBlock2([AesBlock; 2]);

impl AesBlock2 {
    #[inline(always)]
    pub fn from_blocks(b0: AesBlock, b1: AesBlock) -> Self {
        AesBlock2([b0, b1])
    }

    #[inline(always)]
    pub fn as_blocks(&self) -> (AesBlock, AesBlock) {
        (self.0[0], self.0[1])
    }

    #[inline(always)]
    pub fn xor(&self, other: AesBlock2) -> AesBlock2 {
        AesBlock2([self.0[0].xor(other.0[0]), self.0[1].xor(other.0[1])])
    }

    #[inline(always)]
    pub fn and(&self, other: AesBlock2) -> AesBlock2 {
        AesBlock2([self.0[0].and(other.0[0]), self.0[1].and(other.0[1])])
    }

    #[inline(always)]
    pub fn round(&self, rk: AesBlock2) -> AesBlock2 {
        AesBlock2([self.0[0].round(rk.0[0]), self.0[1].round(rk.0[1])])
    }
}

/// Four AES blocks for parallel processing
#[derive(Copy, Clone, Debug, Default)]
pub(crate) struct AesBlock4([AesBlock; 4]);

impl AesBlock4 {
    #[inline(always)]
    pub fn from_blocks(b0: AesBlock, b1: AesBlock, b2: AesBlock, b3: AesBlock) -> Self {
        AesBlock4([b0, b1, b2, b3])
    }

    #[inline(always)]
    pub fn as_blocks(&self) -> (AesBlock, AesBlock, AesBlock, AesBlock) {
        (self.0[0], self.0[1], self.0[2], self.0[3])
    }

    #[inline(always)]
    pub fn xor(&self, other: AesBlock4) -> AesBlock4 {
        AesBlock4([
            self.0[0].xor(other.0[0]),
            self.0[1].xor(other.0[1]),
            self.0[2].xor(other.0[2]),
            self.0[3].xor(other.0[3]),
        ])
    }

    #[inline(always)]
    pub fn and(&self, other: AesBlock4) -> AesBlock4 {
        AesBlock4([
            self.0[0].and(other.0[0]),
            self.0[1].and(other.0[1]),
            self.0[2].and(other.0[2]),
            self.0[3].and(other.0[3]),
        ])
    }

    #[inline(always)]
    pub fn round(&self, rk: AesBlock4) -> AesBlock4 {
        AesBlock4([
            self.0[0].round(rk.0[0]),
            self.0[1].round(rk.0[1]),
            self.0[2].round(rk.0[2]),
            self.0[3].round(rk.0[3]),
        ])
    }
}