1 use block_cipher_trait::generic_array::GenericArray;
2 use block_cipher_trait::generic_array::typenum::{U16, U24, U8};
3 use block_cipher_trait::BlockCipher;
4 use arch::*;
5 
6 use core::mem;
7 use utils::{Block128, Block128x8};
8 
9 mod expand;
10 #[cfg(test)]
11 mod test_expand;
12 
13 /// AES-192 block cipher
14 #[derive(Copy, Clone)]
15 pub struct Aes192 {
16     encrypt_keys: [__m128i; 13],
17     decrypt_keys: [__m128i; 13],
18 }
19 
20 impl Aes192 {
21     #[inline(always)]
encrypt8(&self, mut blocks: [__m128i; 8]) -> [__m128i; 8]22     pub(crate) fn encrypt8(&self, mut blocks: [__m128i; 8]) -> [__m128i; 8] {
23         let keys = self.encrypt_keys;
24         unsafe {
25             xor8!(blocks, keys[0]);
26             aesenc8!(blocks, keys[1]);
27             aesenc8!(blocks, keys[2]);
28             aesenc8!(blocks, keys[3]);
29             aesenc8!(blocks, keys[4]);
30             aesenc8!(blocks, keys[5]);
31             aesenc8!(blocks, keys[6]);
32             aesenc8!(blocks, keys[7]);
33             aesenc8!(blocks, keys[8]);
34             aesenc8!(blocks, keys[9]);
35             aesenc8!(blocks, keys[10]);
36             aesenc8!(blocks, keys[11]);
37             aesenclast8!(blocks, keys[12]);
38         }
39         blocks
40     }
41 
42     #[inline(always)]
encrypt(&self, mut block: __m128i) -> __m128i43     pub(crate) fn encrypt(&self, mut block: __m128i) -> __m128i {
44         let keys = self.encrypt_keys;
45         unsafe {
46             block = _mm_xor_si128(block, keys[0]);
47             block = _mm_aesenc_si128(block, keys[1]);
48             block = _mm_aesenc_si128(block, keys[2]);
49             block = _mm_aesenc_si128(block, keys[3]);
50             block = _mm_aesenc_si128(block, keys[4]);
51             block = _mm_aesenc_si128(block, keys[5]);
52             block = _mm_aesenc_si128(block, keys[6]);
53             block = _mm_aesenc_si128(block, keys[7]);
54             block = _mm_aesenc_si128(block, keys[8]);
55             block = _mm_aesenc_si128(block, keys[9]);
56             block = _mm_aesenc_si128(block, keys[10]);
57             block = _mm_aesenc_si128(block, keys[11]);
58             _mm_aesenclast_si128(block, keys[12])
59         }
60     }
61 }
62 
63 impl BlockCipher for Aes192 {
64     type KeySize = U24;
65     type BlockSize = U16;
66     type ParBlocks = U8;
67 
68     #[inline]
new(key: &GenericArray<u8, U24>) -> Self69     fn new(key: &GenericArray<u8, U24>) -> Self {
70         let key = unsafe { mem::transmute(key) };
71         let (encrypt_keys, decrypt_keys) = expand::expand(key);
72         Self {
73             encrypt_keys,
74             decrypt_keys,
75         }
76     }
77 
78     #[inline]
encrypt_block(&self, block: &mut Block128)79     fn encrypt_block(&self, block: &mut Block128) {
80         unsafe {
81             let b = _mm_loadu_si128(block.as_ptr() as *const __m128i);
82             let b = self.encrypt(b);
83             _mm_storeu_si128(block.as_mut_ptr() as *mut __m128i, b);
84         }
85     }
86 
87     #[inline]
decrypt_block(&self, block: &mut Block128)88     fn decrypt_block(&self, block: &mut Block128) {
89         let keys = self.decrypt_keys;
90         unsafe {
91             let mut b = _mm_loadu_si128(block.as_ptr() as *const __m128i);
92             b = _mm_xor_si128(b, keys[12]);
93             b = _mm_aesdec_si128(b, keys[11]);
94             b = _mm_aesdec_si128(b, keys[10]);
95             b = _mm_aesdec_si128(b, keys[9]);
96             b = _mm_aesdec_si128(b, keys[8]);
97             b = _mm_aesdec_si128(b, keys[7]);
98             b = _mm_aesdec_si128(b, keys[6]);
99             b = _mm_aesdec_si128(b, keys[5]);
100             b = _mm_aesdec_si128(b, keys[4]);
101             b = _mm_aesdec_si128(b, keys[3]);
102             b = _mm_aesdec_si128(b, keys[2]);
103             b = _mm_aesdec_si128(b, keys[1]);
104             b = _mm_aesdeclast_si128(b, keys[0]);
105             _mm_storeu_si128(block.as_mut_ptr() as *mut __m128i, b);
106         }
107     }
108 
109     #[inline]
encrypt_blocks(&self, blocks: &mut Block128x8)110     fn encrypt_blocks(&self, blocks: &mut Block128x8) {
111         unsafe {
112             let b = self.encrypt8(load8!(blocks));
113             store8!(blocks, b);
114         }
115     }
116 
117     #[inline]
decrypt_blocks(&self, blocks: &mut Block128x8)118     fn decrypt_blocks(&self, blocks: &mut Block128x8) {
119         let keys = self.decrypt_keys;
120         unsafe {
121             let mut b = load8!(blocks);
122             xor8!(b, keys[12]);
123             aesdec8!(b, keys[11]);
124             aesdec8!(b, keys[10]);
125             aesdec8!(b, keys[9]);
126             aesdec8!(b, keys[8]);
127             aesdec8!(b, keys[7]);
128             aesdec8!(b, keys[6]);
129             aesdec8!(b, keys[5]);
130             aesdec8!(b, keys[4]);
131             aesdec8!(b, keys[3]);
132             aesdec8!(b, keys[2]);
133             aesdec8!(b, keys[1]);
134             aesdeclast8!(b, keys[0]);
135             store8!(blocks, b);
136         }
137     }
138 }
139 
140 impl_opaque_debug!(Aes192);
141