Botan 3.14.1
Crypto and TLS for C&
aes_vperm.cpp
Go to the documentation of this file.
1/*
2* AES using vector permutes (SSSE3, NEON)
3* (C) 2010,2016,2019 Jack Lloyd
4*
5* Based on public domain x86-64 assembly written by Mike Hamburg,
6* described in "Accelerating AES with Vector Permute Instructions"
7* (CHES 2009). His original code is available at
8* https://crypto.stanford.edu/vpaes/
9*
10* Botan is released under the Simplified BSD License (see license.txt)
11*/
12
13#include <botan/internal/aes.h>
14
15#include <botan/internal/ct_utils.h>
16#include <botan/internal/isa_extn.h>
17#include <botan/internal/simd_4x32.h>
18#include <utility>
19
20namespace Botan {
21
22namespace {
23
24inline SIMD_4x32 BOTAN_FN_ISA_SIMD_4X32 shiftrows(SIMD_4x32 x, size_t r) {
25 const SIMD_4x32 vperm_sr[4] = {
26 SIMD_4x32(0x03020100, 0x07060504, 0x0B0A0908, 0x0F0E0D0C),
27 SIMD_4x32(0x0F0A0500, 0x030E0904, 0x07020D08, 0x0B06010C),
28 SIMD_4x32(0x0B020900, 0x0F060D04, 0x030A0108, 0x070E050C),
29 SIMD_4x32(0x070A0D00, 0x0B0E0104, 0x0F020508, 0x0306090C),
30 };
31
32 return SIMD_4x32::byte_shuffle(x, vperm_sr[r]);
33}
34
35inline SIMD_4x32 BOTAN_FN_ISA_SIMD_4X32 low_nibs(SIMD_4x32 x) {
36 const SIMD_4x32 lo_nibs_mask = SIMD_4x32::splat_u8(0x0F);
37 return lo_nibs_mask & x;
38}
39
40inline SIMD_4x32 BOTAN_FN_ISA_SIMD_4X32 high_nibs(SIMD_4x32 x) {
41 const SIMD_4x32 lo_nibs_mask = SIMD_4x32::splat_u8(0x0F);
42 return (x.shr<4>() & lo_nibs_mask);
43}
44
45inline SIMD_4x32 BOTAN_FN_ISA_SIMD_4X32 aes_enc_first_round(SIMD_4x32 B, SIMD_4x32 K) {
46 const SIMD_4x32 k_ipt1 = SIMD_4x32(0x5A2A7000, 0xC2B2E898, 0x52227808, 0xCABAE090);
47 const SIMD_4x32 k_ipt2 = SIMD_4x32(0x317C4D00, 0x4C01307D, 0xB0FDCC81, 0xCD80B1FC);
48
49 return SIMD_4x32::byte_shuffle(k_ipt1, low_nibs(B)) ^ SIMD_4x32::byte_shuffle(k_ipt2, high_nibs(B)) ^ K;
50}
51
52BOTAN_FORCE_INLINE BOTAN_FN_ISA_SIMD_4X32 std::pair<SIMD_4x32, SIMD_4x32> aes_decompose_kinv(const SIMD_4x32 B) {
53 const SIMD_4x32 k_inv1 = SIMD_4x32(0x0D080180, 0x0E05060F, 0x0A0B0C02, 0x04070309);
54 const SIMD_4x32 k_inv2 = SIMD_4x32(0x0F0B0780, 0x01040A06, 0x02050809, 0x030D0E0C);
55
56 const SIMD_4x32 Bh = high_nibs(B);
57 SIMD_4x32 Bl = low_nibs(B);
58 const SIMD_4x32 t2 = SIMD_4x32::byte_shuffle(k_inv2, Bl);
59 Bl ^= Bh;
60
61 const SIMD_4x32 t5 = Bl ^ SIMD_4x32::masked_byte_shuffle(k_inv1, t2 ^ SIMD_4x32::byte_shuffle(k_inv1, Bh));
62 const SIMD_4x32 t6 = Bh ^ SIMD_4x32::masked_byte_shuffle(k_inv1, t2 ^ SIMD_4x32::byte_shuffle(k_inv1, Bl));
63
64 return std::make_pair(t5, t6);
65}
66
67inline SIMD_4x32 BOTAN_FN_ISA_SIMD_4X32 aes_enc_round(SIMD_4x32 B, SIMD_4x32 K, size_t r) {
68 const SIMD_4x32 sb2u = SIMD_4x32(0x0B712400, 0xE27A93C6, 0xBC982FCD, 0x5EB7E955);
69 const SIMD_4x32 sb2t = SIMD_4x32(0x0AE12900, 0x69EB8840, 0xAB82234A, 0xC2A163C8);
70
71 const SIMD_4x32 mc_forward[4] = {SIMD_4x32(0x00030201, 0x04070605, 0x080B0A09, 0x0C0F0E0D),
72 SIMD_4x32(0x04070605, 0x080B0A09, 0x0C0F0E0D, 0x00030201),
73 SIMD_4x32(0x080B0A09, 0x0C0F0E0D, 0x00030201, 0x04070605),
74 SIMD_4x32(0x0C0F0E0D, 0x00030201, 0x04070605, 0x080B0A09)};
75 const SIMD_4x32 mc_backward[4] = {
76 SIMD_4x32(0x02010003, 0x06050407, 0x0A09080B, 0x0E0D0C0F),
77 SIMD_4x32(0x0E0D0C0F, 0x02010003, 0x06050407, 0x0A09080B),
78 SIMD_4x32(0x0A09080B, 0x0E0D0C0F, 0x02010003, 0x06050407),
79 SIMD_4x32(0x06050407, 0x0A09080B, 0x0E0D0C0F, 0x02010003),
80 };
81 const SIMD_4x32 sb1u = SIMD_4x32(0xCB503E00, 0xB19BE18F, 0x142AF544, 0xA5DF7A6E);
82 const SIMD_4x32 sb1t = SIMD_4x32(0xFAE22300, 0x3618D415, 0x0D2ED9EF, 0x3BF7CCC1);
83
84 const auto [t5, t6] = aes_decompose_kinv(B);
85
88 SIMD_4x32::byte_shuffle(t7, mc_forward[r % 4]);
89
90 return SIMD_4x32::byte_shuffle(t8, mc_forward[r % 4]) ^ SIMD_4x32::byte_shuffle(t7, mc_backward[r % 4]) ^ t8;
91}
92
93inline SIMD_4x32 BOTAN_FN_ISA_SIMD_4X32 aes_enc_last_round(SIMD_4x32 B, SIMD_4x32 K, size_t r) {
94 const SIMD_4x32 sbou = SIMD_4x32(0x6FBDC700, 0xD0D26D17, 0xC502A878, 0x15AABF7A);
95 const SIMD_4x32 sbot = SIMD_4x32(0x5FBB6A00, 0xCFE474A5, 0x412B35FA, 0x8E1E90D1);
96
97 const auto [t5, t6] = aes_decompose_kinv(B);
98
99 return shiftrows(SIMD_4x32::masked_byte_shuffle(sbou, t5) ^ SIMD_4x32::masked_byte_shuffle(sbot, t6) ^ K, r % 4);
100}
101
102inline SIMD_4x32 BOTAN_FN_ISA_SIMD_4X32 aes_dec_first_round(SIMD_4x32 B, SIMD_4x32 K) {
103 const SIMD_4x32 k_dipt1 = SIMD_4x32(0x0B545F00, 0x0F505B04, 0x114E451A, 0x154A411E);
104 const SIMD_4x32 k_dipt2 = SIMD_4x32(0x60056500, 0x86E383E6, 0xF491F194, 0x12771772);
105
106 return SIMD_4x32::byte_shuffle(k_dipt1, low_nibs(B)) ^ SIMD_4x32::byte_shuffle(k_dipt2, high_nibs(B)) ^ K;
107}
108
109inline SIMD_4x32 BOTAN_FN_ISA_SIMD_4X32 aes_dec_round(SIMD_4x32 B, SIMD_4x32 K, size_t r) {
110 const SIMD_4x32 mcx[4] = {
111 SIMD_4x32(0x0C0F0E0D, 0x00030201, 0x04070605, 0x080B0A09),
112 SIMD_4x32(0x080B0A09, 0x0C0F0E0D, 0x00030201, 0x04070605),
113 SIMD_4x32(0x04070605, 0x080B0A09, 0x0C0F0E0D, 0x00030201),
114 SIMD_4x32(0x00030201, 0x04070605, 0x080B0A09, 0x0C0F0E0D),
115 };
116
117 const SIMD_4x32 sbbu = SIMD_4x32(0x96B44200, 0xD0226492, 0xB0F2D404, 0x602646F6);
118 const SIMD_4x32 sbbt = SIMD_4x32(0xCD596700, 0xC19498A6, 0x3255AA6B, 0xF3FF0C3E);
119 const SIMD_4x32 sbdu = SIMD_4x32(0xE6B1A200, 0x7D57CCDF, 0x882A4439, 0xF56E9B13);
120 const SIMD_4x32 sbdt = SIMD_4x32(0x24C6CB00, 0x3CE2FAF7, 0x15DEEFD3, 0x2931180D);
121 const SIMD_4x32 sbeu = SIMD_4x32(0x26D4D000, 0x46F29296, 0x64B4F6B0, 0x22426004);
122 const SIMD_4x32 sbet = SIMD_4x32(0xFFAAC100, 0x0C55A6CD, 0x98593E32, 0x9467F36B);
123 const SIMD_4x32 sb9u = SIMD_4x32(0x9A86D600, 0x851C0353, 0x4F994CC9, 0xCAD51F50);
124 const SIMD_4x32 sb9t = SIMD_4x32(0xECD74900, 0xC03B1789, 0xB2FBA565, 0x725E2C9E);
125
126 const auto [t5, t6] = aes_decompose_kinv(B);
127
128 const SIMD_4x32 mc = mcx[(r - 1) % 4];
129
135 return SIMD_4x32::byte_shuffle(t12, mc) ^ SIMD_4x32::masked_byte_shuffle(sbeu, t5) ^
137}
138
139inline SIMD_4x32 BOTAN_FN_ISA_SIMD_4X32 aes_dec_last_round(SIMD_4x32 B, SIMD_4x32 K, size_t r) {
140 const SIMD_4x32 sboud = SIMD_4x32(0x7EF94000, 0x1387EA53, 0xD4943E2D, 0xC7AA6DB9);
141 const SIMD_4x32 sbotd = SIMD_4x32(0x93441D00, 0x12D7560F, 0xD8C58E9C, 0xCA4B8159);
142
143 const uint32_t which_sr = ((((r - 1) << 4) ^ 48) & 48) / 16;
144
145 const auto [t5, t6] = aes_decompose_kinv(B);
146
147 const SIMD_4x32 x = SIMD_4x32::masked_byte_shuffle(sboud, t5) ^ SIMD_4x32::masked_byte_shuffle(sbotd, t6) ^ K;
148 return shiftrows(x, which_sr);
149}
150
151void BOTAN_FN_ISA_SIMD_4X32
152vperm_encrypt_blocks(const uint8_t in[], uint8_t out[], size_t blocks, const SIMD_4x32 K[], size_t rounds) {
153 CT::poison(in, blocks * 16);
154
155 const size_t blocks2 = blocks - (blocks % 2);
156
157 for(size_t i = 0; i != blocks2; i += 2) {
158 SIMD_4x32 B0 = SIMD_4x32::load_le(in + i * 16);
159 SIMD_4x32 B1 = SIMD_4x32::load_le(in + (i + 1) * 16);
160
161 B0 = aes_enc_first_round(B0, K[0]);
162 B1 = aes_enc_first_round(B1, K[0]);
163
164 for(size_t r = 1; r != rounds; ++r) {
165 B0 = aes_enc_round(B0, K[r], r);
166 B1 = aes_enc_round(B1, K[r], r);
167 }
168
169 B0 = aes_enc_last_round(B0, K[rounds], rounds);
170 B1 = aes_enc_last_round(B1, K[rounds], rounds);
171
172 B0.store_le(out + i * 16);
173 B1.store_le(out + (i + 1) * 16);
174 }
175
176 for(size_t i = blocks2; i < blocks; ++i) {
177 SIMD_4x32 B = SIMD_4x32::load_le(in + i * 16); // ???
178
179 B = aes_enc_first_round(B, K[0]);
180
181 for(size_t r = 1; r != rounds; ++r) {
182 B = aes_enc_round(B, K[r], r);
183 }
184
185 B = aes_enc_last_round(B, K[rounds], rounds);
186 B.store_le(out + i * 16);
187 }
188
189 CT::unpoison(in, blocks * 16);
190 CT::unpoison(out, blocks * 16);
191}
192
193void BOTAN_FN_ISA_SIMD_4X32
194vperm_decrypt_blocks(const uint8_t in[], uint8_t out[], size_t blocks, const SIMD_4x32 K[], size_t rounds) {
195 CT::poison(in, blocks * 16);
196
197 const size_t blocks2 = blocks - (blocks % 2);
198
199 for(size_t i = 0; i != blocks2; i += 2) {
200 SIMD_4x32 B0 = SIMD_4x32::load_le(in + i * 16);
201 SIMD_4x32 B1 = SIMD_4x32::load_le(in + (i + 1) * 16);
202
203 B0 = aes_dec_first_round(B0, K[0]);
204 B1 = aes_dec_first_round(B1, K[0]);
205
206 for(size_t r = 1; r != rounds; ++r) {
207 B0 = aes_dec_round(B0, K[r], r);
208 B1 = aes_dec_round(B1, K[r], r);
209 }
210
211 B0 = aes_dec_last_round(B0, K[rounds], rounds);
212 B1 = aes_dec_last_round(B1, K[rounds], rounds);
213
214 B0.store_le(out + i * 16);
215 B1.store_le(out + (i + 1) * 16);
216 }
217
218 for(size_t i = blocks2; i < blocks; ++i) {
219 SIMD_4x32 B = SIMD_4x32::load_le(in + i * 16); // ???
220
221 B = aes_dec_first_round(B, K[0]);
222
223 for(size_t r = 1; r != rounds; ++r) {
224 B = aes_dec_round(B, K[r], r);
225 }
226
227 B = aes_dec_last_round(B, K[rounds], rounds);
228 B.store_le(out + i * 16);
229 }
230
231 CT::unpoison(in, blocks * 16);
232 CT::unpoison(out, blocks * 16);
233}
234
235} // namespace
236
237void BOTAN_FN_ISA_SIMD_4X32 AES_128::vperm_encrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const {
238 const SIMD_4x32 K[11] = {
239 SIMD_4x32::load_le(&m_EK[4 * 0]),
240 SIMD_4x32::load_le(&m_EK[4 * 1]),
241 SIMD_4x32::load_le(&m_EK[4 * 2]),
242 SIMD_4x32::load_le(&m_EK[4 * 3]),
243 SIMD_4x32::load_le(&m_EK[4 * 4]),
244 SIMD_4x32::load_le(&m_EK[4 * 5]),
245 SIMD_4x32::load_le(&m_EK[4 * 6]),
246 SIMD_4x32::load_le(&m_EK[4 * 7]),
247 SIMD_4x32::load_le(&m_EK[4 * 8]),
248 SIMD_4x32::load_le(&m_EK[4 * 9]),
249 SIMD_4x32::load_le(&m_EK[4 * 10]),
250 };
251
252 return vperm_encrypt_blocks(in, out, blocks, K, 10);
253}
254
255void BOTAN_FN_ISA_SIMD_4X32 AES_128::vperm_decrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const {
256 const SIMD_4x32 K[11] = {
257 SIMD_4x32::load_le(&m_DK[4 * 0]),
258 SIMD_4x32::load_le(&m_DK[4 * 1]),
259 SIMD_4x32::load_le(&m_DK[4 * 2]),
260 SIMD_4x32::load_le(&m_DK[4 * 3]),
261 SIMD_4x32::load_le(&m_DK[4 * 4]),
262 SIMD_4x32::load_le(&m_DK[4 * 5]),
263 SIMD_4x32::load_le(&m_DK[4 * 6]),
264 SIMD_4x32::load_le(&m_DK[4 * 7]),
265 SIMD_4x32::load_le(&m_DK[4 * 8]),
266 SIMD_4x32::load_le(&m_DK[4 * 9]),
267 SIMD_4x32::load_le(&m_DK[4 * 10]),
268 };
269
270 return vperm_decrypt_blocks(in, out, blocks, K, 10);
271}
272
273void BOTAN_FN_ISA_SIMD_4X32 AES_192::vperm_encrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const {
274 const SIMD_4x32 K[13] = {
275 SIMD_4x32::load_le(&m_EK[4 * 0]),
276 SIMD_4x32::load_le(&m_EK[4 * 1]),
277 SIMD_4x32::load_le(&m_EK[4 * 2]),
278 SIMD_4x32::load_le(&m_EK[4 * 3]),
279 SIMD_4x32::load_le(&m_EK[4 * 4]),
280 SIMD_4x32::load_le(&m_EK[4 * 5]),
281 SIMD_4x32::load_le(&m_EK[4 * 6]),
282 SIMD_4x32::load_le(&m_EK[4 * 7]),
283 SIMD_4x32::load_le(&m_EK[4 * 8]),
284 SIMD_4x32::load_le(&m_EK[4 * 9]),
285 SIMD_4x32::load_le(&m_EK[4 * 10]),
286 SIMD_4x32::load_le(&m_EK[4 * 11]),
287 SIMD_4x32::load_le(&m_EK[4 * 12]),
288 };
289
290 return vperm_encrypt_blocks(in, out, blocks, K, 12);
291}
292
293void BOTAN_FN_ISA_SIMD_4X32 AES_192::vperm_decrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const {
294 const SIMD_4x32 K[13] = {
295 SIMD_4x32::load_le(&m_DK[4 * 0]),
296 SIMD_4x32::load_le(&m_DK[4 * 1]),
297 SIMD_4x32::load_le(&m_DK[4 * 2]),
298 SIMD_4x32::load_le(&m_DK[4 * 3]),
299 SIMD_4x32::load_le(&m_DK[4 * 4]),
300 SIMD_4x32::load_le(&m_DK[4 * 5]),
301 SIMD_4x32::load_le(&m_DK[4 * 6]),
302 SIMD_4x32::load_le(&m_DK[4 * 7]),
303 SIMD_4x32::load_le(&m_DK[4 * 8]),
304 SIMD_4x32::load_le(&m_DK[4 * 9]),
305 SIMD_4x32::load_le(&m_DK[4 * 10]),
306 SIMD_4x32::load_le(&m_DK[4 * 11]),
307 SIMD_4x32::load_le(&m_DK[4 * 12]),
308 };
309
310 return vperm_decrypt_blocks(in, out, blocks, K, 12);
311}
312
313void BOTAN_FN_ISA_SIMD_4X32 AES_256::vperm_encrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const {
314 const SIMD_4x32 K[15] = {
315 SIMD_4x32::load_le(&m_EK[4 * 0]),
316 SIMD_4x32::load_le(&m_EK[4 * 1]),
317 SIMD_4x32::load_le(&m_EK[4 * 2]),
318 SIMD_4x32::load_le(&m_EK[4 * 3]),
319 SIMD_4x32::load_le(&m_EK[4 * 4]),
320 SIMD_4x32::load_le(&m_EK[4 * 5]),
321 SIMD_4x32::load_le(&m_EK[4 * 6]),
322 SIMD_4x32::load_le(&m_EK[4 * 7]),
323 SIMD_4x32::load_le(&m_EK[4 * 8]),
324 SIMD_4x32::load_le(&m_EK[4 * 9]),
325 SIMD_4x32::load_le(&m_EK[4 * 10]),
326 SIMD_4x32::load_le(&m_EK[4 * 11]),
327 SIMD_4x32::load_le(&m_EK[4 * 12]),
328 SIMD_4x32::load_le(&m_EK[4 * 13]),
329 SIMD_4x32::load_le(&m_EK[4 * 14]),
330 };
331
332 return vperm_encrypt_blocks(in, out, blocks, K, 14);
333}
334
335void BOTAN_FN_ISA_SIMD_4X32 AES_256::vperm_decrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const {
336 const SIMD_4x32 K[15] = {
337 SIMD_4x32::load_le(&m_DK[4 * 0]),
338 SIMD_4x32::load_le(&m_DK[4 * 1]),
339 SIMD_4x32::load_le(&m_DK[4 * 2]),
340 SIMD_4x32::load_le(&m_DK[4 * 3]),
341 SIMD_4x32::load_le(&m_DK[4 * 4]),
342 SIMD_4x32::load_le(&m_DK[4 * 5]),
343 SIMD_4x32::load_le(&m_DK[4 * 6]),
344 SIMD_4x32::load_le(&m_DK[4 * 7]),
345 SIMD_4x32::load_le(&m_DK[4 * 8]),
346 SIMD_4x32::load_le(&m_DK[4 * 9]),
347 SIMD_4x32::load_le(&m_DK[4 * 10]),
348 SIMD_4x32::load_le(&m_DK[4 * 11]),
349 SIMD_4x32::load_le(&m_DK[4 * 12]),
350 SIMD_4x32::load_le(&m_DK[4 * 13]),
351 SIMD_4x32::load_le(&m_DK[4 * 14]),
352 };
353
354 return vperm_decrypt_blocks(in, out, blocks, K, 14);
355}
356
357namespace {
358
359inline SIMD_4x32 BOTAN_FN_ISA_SIMD_4X32 aes_schedule_transform(SIMD_4x32 input, SIMD_4x32 table_1, SIMD_4x32 table_2) {
360 return SIMD_4x32::byte_shuffle(table_1, low_nibs(input)) ^ SIMD_4x32::byte_shuffle(table_2, high_nibs(input));
361}
362
363inline SIMD_4x32 BOTAN_FN_ISA_SIMD_4X32 aes_schedule_transform_init(SIMD_4x32 input) {
364 return aes_enc_first_round(input, SIMD_4x32());
365}
366
367SIMD_4x32 BOTAN_FN_ISA_SIMD_4X32 aes_schedule_mangle(SIMD_4x32 k, uint8_t round_no) {
368 const SIMD_4x32 mc_forward0(0x00030201, 0x04070605, 0x080B0A09, 0x0C0F0E0D);
369
370 SIMD_4x32 t = SIMD_4x32::byte_shuffle(k ^ SIMD_4x32::splat_u8(0x5B), mc_forward0);
371 SIMD_4x32 t2 = t;
372 t = SIMD_4x32::byte_shuffle(t, mc_forward0);
373 t2 = t ^ t2 ^ SIMD_4x32::byte_shuffle(t, mc_forward0);
374 return shiftrows(t2, round_no % 4);
375}
376
377SIMD_4x32 BOTAN_FN_ISA_SIMD_4X32 aes_schedule_mangle_dec(SIMD_4x32 k, uint8_t round_no) {
378 const SIMD_4x32 mc_forward0(0x00030201, 0x04070605, 0x080B0A09, 0x0C0F0E0D);
379
380 const SIMD_4x32 dsk[8] = {
381 SIMD_4x32(0x7ED9A700, 0xB6116FC8, 0x82255BFC, 0x4AED9334),
382 SIMD_4x32(0x27143300, 0x45765162, 0xE9DAFDCE, 0x8BB89FAC),
383 SIMD_4x32(0xCCA86400, 0x27438FEB, 0xADC90561, 0x4622EE8A),
384 SIMD_4x32(0x4F92DD00, 0x815C13CE, 0xBD602FF2, 0x73AEE13C),
385 SIMD_4x32(0x01C6C700, 0x03C4C502, 0xFA3D3CFB, 0xF83F3EF9),
386 SIMD_4x32(0x38CFF700, 0xEE1921D6, 0x7384BC4B, 0xA5526A9D),
387 SIMD_4x32(0x53732000, 0xE3C390B0, 0x10306343, 0xA080D3F3),
388 SIMD_4x32(0x036982E8, 0xA0CA214B, 0x8CE60D67, 0x2F45AEC4),
389 };
390
391 SIMD_4x32 t = aes_schedule_transform(k, dsk[0], dsk[1]);
392 SIMD_4x32 output = SIMD_4x32::byte_shuffle(t, mc_forward0);
393
394 t = aes_schedule_transform(t, dsk[2], dsk[3]);
395 output = SIMD_4x32::byte_shuffle(t ^ output, mc_forward0);
396
397 t = aes_schedule_transform(t, dsk[4], dsk[5]);
398 output = SIMD_4x32::byte_shuffle(t ^ output, mc_forward0);
399
400 t = aes_schedule_transform(t, dsk[6], dsk[7]);
401 output = SIMD_4x32::byte_shuffle(t ^ output, mc_forward0);
402
403 return shiftrows(output, round_no % 4);
404}
405
406SIMD_4x32 BOTAN_FN_ISA_SIMD_4X32 aes_schedule_mangle_last(SIMD_4x32 k, uint8_t round_no) {
407 const SIMD_4x32 out_tr1(0xD6B66000, 0xFF9F4929, 0xDEBE6808, 0xF7974121);
408 const SIMD_4x32 out_tr2(0x50BCEC00, 0x01EDBD51, 0xB05C0CE0, 0xE10D5DB1);
409
410 k = shiftrows(k, round_no % 4) ^ SIMD_4x32::splat_u8(0x5B);
411 return aes_schedule_transform(k, out_tr1, out_tr2);
412}
413
414SIMD_4x32 BOTAN_FN_ISA_SIMD_4X32 aes_schedule_mangle_last_dec(SIMD_4x32 k) {
415 const SIMD_4x32 deskew1(0x47A4E300, 0x07E4A340, 0x5DBEF91A, 0x1DFEB95A);
416 const SIMD_4x32 deskew2(0x83EA6900, 0x5F36B5DC, 0xF49D1E77, 0x2841C2AB);
417
418 k ^= SIMD_4x32::splat_u8(0x5B);
419 return aes_schedule_transform(k, deskew1, deskew2);
420}
421
422SIMD_4x32 BOTAN_FN_ISA_SIMD_4X32 aes_schedule_round(SIMD_4x32 input1, SIMD_4x32 input2) {
423 const SIMD_4x32 sb1u = SIMD_4x32(0xCB503E00, 0xB19BE18F, 0x142AF544, 0xA5DF7A6E);
424 const SIMD_4x32 sb1t = SIMD_4x32(0xFAE22300, 0x3618D415, 0x0D2ED9EF, 0x3BF7CCC1);
425
426 SIMD_4x32 smeared = input2 ^ input2.shift_elems_left<1>();
427 smeared ^= smeared.shift_elems_left<2>();
428 smeared ^= SIMD_4x32::splat_u8(0x5B);
429
430 const auto [t5, t6] = aes_decompose_kinv(input1);
431
432 return smeared ^ SIMD_4x32::masked_byte_shuffle(sb1u, t5) ^ SIMD_4x32::masked_byte_shuffle(sb1t, t6);
433}
434
435SIMD_4x32 BOTAN_FN_ISA_SIMD_4X32 aes_schedule_round_rcon(size_t rc, SIMD_4x32 input1, SIMD_4x32 input2) {
436 const SIMD_4x32 rcon[10] = {
437 SIMD_4x32(0x00000070, 0x00000000, 0x00000000, 0x00000000),
438 SIMD_4x32(0x0000002A, 0x00000000, 0x00000000, 0x00000000),
439 SIMD_4x32(0x00000098, 0x00000000, 0x00000000, 0x00000000),
440 SIMD_4x32(0x00000008, 0x00000000, 0x00000000, 0x00000000),
441 SIMD_4x32(0x0000004D, 0x00000000, 0x00000000, 0x00000000),
442 SIMD_4x32(0x0000007C, 0x00000000, 0x00000000, 0x00000000),
443 SIMD_4x32(0x0000007D, 0x00000000, 0x00000000, 0x00000000),
444 SIMD_4x32(0x00000081, 0x00000000, 0x00000000, 0x00000000),
445 SIMD_4x32(0x0000001F, 0x00000000, 0x00000000, 0x00000000),
446 SIMD_4x32(0x00000083, 0x00000000, 0x00000000, 0x00000000),
447 };
448
449 // This byte shuffle is equivalent to alignr<1>(shuffle32(input1, (3,3,3,3)));
450 const SIMD_4x32 shuffle3333_15 = SIMD_4x32::splat(0x0C0F0E0D);
451 return aes_schedule_round(SIMD_4x32::byte_shuffle(input1, shuffle3333_15), input2 ^ rcon[rc]);
452}
453
454SIMD_4x32 BOTAN_FN_ISA_SIMD_4X32 aes_schedule_192_smear(SIMD_4x32 x, SIMD_4x32 y) {
455 const SIMD_4x32 shuffle3332 = SIMD_4x32(0x0B0A0908, 0x0F0E0D0C, 0x0F0E0D0C, 0x0F0E0D0C);
456 const SIMD_4x32 shuffle2000 = SIMD_4x32(0x03020100, 0x03020100, 0x03020100, 0x0B0A0908);
457
458 const SIMD_4x32 zero_top_half(0, 0, 0xFFFFFFFF, 0xFFFFFFFF);
459 y &= zero_top_half;
460 return y ^ SIMD_4x32::byte_shuffle(x, shuffle3332) ^ SIMD_4x32::byte_shuffle(y, shuffle2000);
461}
462
463} // namespace
464
465// NOLINTBEGIN(readability-container-data-pointer)
466
467void BOTAN_FN_ISA_SIMD_4X32 AES_128::vperm_key_schedule(const uint8_t keyb[], size_t /*unused*/) {
468 m_EK.resize(11 * 4);
469 m_DK.resize(11 * 4);
470
471 SIMD_4x32 key = SIMD_4x32::load_le(keyb);
472
473 shiftrows(key, 2).store_le(&m_DK[4 * 10]);
474
475 key = aes_schedule_transform_init(key);
476 key.store_le(&m_EK[0]);
477
478 for(size_t i = 1; i != 10; ++i) {
479 key = aes_schedule_round_rcon(i - 1, key, key);
480
481 aes_schedule_mangle(key, (12 - i) % 4).store_le(&m_EK[4 * i]);
482
483 aes_schedule_mangle_dec(key, (10 - i) % 4).store_le(&m_DK[4 * (10 - i)]);
484 }
485
486 key = aes_schedule_round_rcon(9, key, key);
487 aes_schedule_mangle_last(key, 2).store_le(&m_EK[4 * 10]);
488 aes_schedule_mangle_last_dec(key).store_le(&m_DK[0]);
489}
490
491void BOTAN_FN_ISA_SIMD_4X32 AES_192::vperm_key_schedule(const uint8_t keyb[], size_t /*unused*/) {
492 m_EK.resize(13 * 4);
493 m_DK.resize(13 * 4);
494
495 SIMD_4x32 key1 = SIMD_4x32::load_le(keyb);
496 SIMD_4x32 key2 = SIMD_4x32::load_le(keyb + 8);
497
498 shiftrows(key1, 0).store_le(&m_DK[12 * 4]);
499
500 key1 = aes_schedule_transform_init(key1);
501 key2 = aes_schedule_transform_init(key2);
502
503 key1.store_le(&m_EK[0]);
504
505 for(size_t i = 0; i != 4; ++i) {
506 // key2 with 8 high bytes masked off
507 SIMD_4x32 t = key2;
508 key2 = aes_schedule_round_rcon(2 * i, key2, key1);
509 const auto key2t = SIMD_4x32::alignr8(key2, t);
510
511 aes_schedule_mangle(key2t, (i + 3) % 4).store_le(&m_EK[4 * (3 * i + 1)]);
512 aes_schedule_mangle_dec(key2t, (i + 3) % 4).store_le(&m_DK[4 * (11 - 3 * i)]);
513
514 t = aes_schedule_192_smear(key2, t);
515
516 aes_schedule_mangle(t, (i + 2) % 4).store_le(&m_EK[4 * (3 * i + 2)]);
517 aes_schedule_mangle_dec(t, (i + 2) % 4).store_le(&m_DK[4 * (10 - 3 * i)]);
518
519 key2 = aes_schedule_round_rcon(2 * i + 1, t, key2);
520
521 if(i == 3) {
522 aes_schedule_mangle_last(key2, (i + 1) % 4).store_le(&m_EK[4 * (3 * i + 3)]);
523 aes_schedule_mangle_last_dec(key2).store_le(&m_DK[4 * (9 - 3 * i)]);
524 } else {
525 aes_schedule_mangle(key2, (i + 1) % 4).store_le(&m_EK[4 * (3 * i + 3)]);
526 aes_schedule_mangle_dec(key2, (i + 1) % 4).store_le(&m_DK[4 * (9 - 3 * i)]);
527 }
528
529 key1 = key2;
530 key2 = aes_schedule_192_smear(key2, t);
531 }
532}
533
534void BOTAN_FN_ISA_SIMD_4X32 AES_256::vperm_key_schedule(const uint8_t keyb[], size_t /*unused*/) {
535 m_EK.resize(15 * 4);
536 m_DK.resize(15 * 4);
537
538 SIMD_4x32 key1 = SIMD_4x32::load_le(keyb);
539 SIMD_4x32 key2 = SIMD_4x32::load_le(keyb + 16);
540
541 shiftrows(key1, 2).store_le(&m_DK[4 * 14]);
542
543 key1 = aes_schedule_transform_init(key1);
544 key2 = aes_schedule_transform_init(key2);
545
546 key1.store_le(&m_EK[0]);
547 aes_schedule_mangle(key2, 3).store_le(&m_EK[4]);
548
549 aes_schedule_mangle_dec(key2, 1).store_le(&m_DK[4 * 13]);
550
551 const SIMD_4x32 shuffle3333 = SIMD_4x32::splat(0x0F0E0D0C);
552
553 for(size_t i = 2; i != 14; i += 2) {
554 const SIMD_4x32 k_t = key2;
555 key1 = key2 = aes_schedule_round_rcon((i / 2) - 1, key2, key1);
556
557 aes_schedule_mangle(key2, i % 4).store_le(&m_EK[4 * i]);
558 aes_schedule_mangle_dec(key2, (i + 2) % 4).store_le(&m_DK[4 * (14 - i)]);
559
560 key2 = aes_schedule_round(SIMD_4x32::byte_shuffle(key2, shuffle3333), k_t);
561
562 aes_schedule_mangle(key2, (i - 1) % 4).store_le(&m_EK[4 * (i + 1)]);
563 aes_schedule_mangle_dec(key2, (i + 1) % 4).store_le(&m_DK[4 * (13 - i)]);
564 }
565
566 key2 = aes_schedule_round_rcon(6, key2, key1);
567
568 aes_schedule_mangle_last(key2, 2).store_le(&m_EK[4 * 14]);
569 aes_schedule_mangle_last_dec(key2).store_le(&m_DK[0]);
570}
571
572// NOLINTEND(readability-container-data-pointer)
573
574} // namespace Botan
static SIMD_4x32 BOTAN_FN_ISA_SIMD_4X32 load_le(const void *in) noexcept
Definition simd_4x32.h:183
static SIMD_4x32 BOTAN_FN_ISA_SIMD_4X32 byte_shuffle(const SIMD_4x32 &tbl, const SIMD_4x32 &idx)
Definition simd_4x32.h:796
static SIMD_4x32 BOTAN_FN_ISA_SIMD_4X32 alignr8(const SIMD_4x32 &a, const SIMD_4x32 &b)
Definition simd_4x32.h:882
static SIMD_4x32 BOTAN_FN_ISA_SIMD_4X32 splat(uint32_t B) noexcept
Definition simd_4x32.h:123
static SIMD_4x32 BOTAN_FN_ISA_SIMD_4X32 masked_byte_shuffle(const SIMD_4x32 &tbl, const SIMD_4x32 &idx)
Definition simd_4x32.h:836
static SIMD_4x32 BOTAN_FN_ISA_SIMD_4X32 splat_u8(uint8_t B) noexcept
Definition simd_4x32.h:140
SIMD_4x32 BOTAN_FN_ISA_SIMD_4X32 shift_elems_left() const noexcept
Definition simd_4x32.h:562
#define BOTAN_FORCE_INLINE
Definition compiler.h:86
constexpr void unpoison(const T *p, size_t n)
Definition ct_utils.h:67
constexpr void poison(const T *p, size_t n)
Definition ct_utils.h:56