30 #if !(defined(__CRYPTO) || defined(_ARCH_PWR8) || defined(_ARCH_PWR9)) 31 # undef CRYPTOPP_POWER8_CRYPTO_AVAILABLE 32 # undef CRYPTOPP_POWER8_AES_AVAILABLE 35 #if (CRYPTOPP_AESNI_AVAILABLE) 36 # include <smmintrin.h> 37 # include <wmmintrin.h> 41 #if (CRYPTOPP_ARM_AES_AVAILABLE) 42 # include <arm_neon.h> 47 #if defined(CRYPTOPP_ARM_ACLE_AVAILABLE) 49 # include <arm_acle.h> 52 #if defined(CRYPTOPP_POWER8_AES_AVAILABLE) 56 #ifdef CRYPTOPP_GNU_STYLE_INLINE_ASSEMBLY 61 #ifndef EXCEPTION_EXECUTE_HANDLER 62 # define EXCEPTION_EXECUTE_HANDLER 1 66 #define M128_CAST(x) ((__m128i *)(void *)(x)) 67 #define CONST_M128_CAST(x) ((const __m128i *)(const void *)(x)) 71 #ifdef CRYPTOPP_GNU_STYLE_INLINE_ASSEMBLY 73 typedef void (*SigHandler)(int);
75 static jmp_buf s_jmpSIGILL;
76 static void SigIllHandler(
int)
78 longjmp(s_jmpSIGILL, 1);
81 #endif // Not CRYPTOPP_MS_STYLE_INLINE_ASSEMBLY 83 #if (CRYPTOPP_BOOL_ARM32 || CRYPTOPP_BOOL_ARM64) 86 #if defined(CRYPTOPP_NO_CPU_FEATURE_PROBES) 88 #elif (CRYPTOPP_ARM_AES_AVAILABLE) 89 # if defined(CRYPTOPP_MS_STYLE_INLINE_ASSEMBLY) 90 volatile bool result =
true;
94 uint8x16_t data = vdupq_n_u8(0), key = vdupq_n_u8(0);
95 uint8x16_t r1 = vaeseq_u8(data, key);
96 uint8x16_t r2 = vaesdq_u8(data, key);
100 result = !!(vgetq_lane_u8(r1,0) | vgetq_lane_u8(r2,7));
102 __except (EXCEPTION_EXECUTE_HANDLER)
111 volatile bool result =
true;
113 volatile SigHandler oldHandler = signal(SIGILL, SigIllHandler);
114 if (oldHandler == SIG_ERR)
117 volatile sigset_t oldMask;
118 if (sigprocmask(0, NULLPTR, (sigset_t*)&oldMask))
121 if (setjmp(s_jmpSIGILL))
125 uint8x16_t data = vdupq_n_u8(0), key = vdupq_n_u8(0);
126 uint8x16_t r1 = vaeseq_u8(data, key);
127 uint8x16_t r2 = vaesdq_u8(data, key);
129 r2 = vaesimcq_u8(r2);
132 result = !!(vgetq_lane_u8(r1,0) | vgetq_lane_u8(r2,7));
135 sigprocmask(SIG_SETMASK, (sigset_t*)&oldMask, NULLPTR);
136 signal(SIGILL, oldHandler);
141 #endif // CRYPTOPP_ARM_AES_AVAILABLE 143 #endif // ARM32 or ARM64 147 #if (CRYPTOPP_ARM_AES_AVAILABLE) 149 ANONYMOUS_NAMESPACE_BEGIN
151 static inline void ARMV8_Enc_Block(uint64x2_t &data,
const word32 *subkeys,
unsigned int rounds)
154 const byte *keys = reinterpret_cast<const byte*>(subkeys);
155 uint8x16_t block = vreinterpretq_u8_u64(data);
158 block = vaeseq_u8(block, vld1q_u8(keys+0*16));
160 block = vaesmcq_u8(block);
162 for (
unsigned int i=1; i<rounds-1; i+=2)
165 block = vaeseq_u8(block, vld1q_u8(keys+i*16));
167 block = vaesmcq_u8(block);
169 block = vaeseq_u8(block, vld1q_u8(keys+(i+1)*16));
171 block = vaesmcq_u8(block);
175 block = vaeseq_u8(block, vld1q_u8(keys+(rounds-1)*16));
177 block = veorq_u8(block, vld1q_u8(keys+rounds*16));
179 data = vreinterpretq_u64_u8(block);
182 static inline void ARMV8_Enc_6_Blocks(uint64x2_t &data0, uint64x2_t &data1,
183 uint64x2_t &data2, uint64x2_t &data3, uint64x2_t &data4, uint64x2_t &data5,
184 const word32 *subkeys,
unsigned int rounds)
187 const byte *keys = reinterpret_cast<const byte*>(subkeys);
189 uint8x16_t block0 = vreinterpretq_u8_u64(data0);
190 uint8x16_t block1 = vreinterpretq_u8_u64(data1);
191 uint8x16_t block2 = vreinterpretq_u8_u64(data2);
192 uint8x16_t block3 = vreinterpretq_u8_u64(data3);
193 uint8x16_t block4 = vreinterpretq_u8_u64(data4);
194 uint8x16_t block5 = vreinterpretq_u8_u64(data5);
197 for (
unsigned int i=0; i<rounds-1; ++i)
199 uint8x16_t key = vld1q_u8(keys+i*16);
201 block0 = vaeseq_u8(block0, key);
203 block0 = vaesmcq_u8(block0);
205 block1 = vaeseq_u8(block1, key);
207 block1 = vaesmcq_u8(block1);
209 block2 = vaeseq_u8(block2, key);
211 block2 = vaesmcq_u8(block2);
213 block3 = vaeseq_u8(block3, key);
215 block3 = vaesmcq_u8(block3);
217 block4 = vaeseq_u8(block4, key);
219 block4 = vaesmcq_u8(block4);
221 block5 = vaeseq_u8(block5, key);
223 block5 = vaesmcq_u8(block5);
227 key = vld1q_u8(keys+(rounds-1)*16);
228 block0 = vaeseq_u8(block0, key);
229 block1 = vaeseq_u8(block1, key);
230 block2 = vaeseq_u8(block2, key);
231 block3 = vaeseq_u8(block3, key);
232 block4 = vaeseq_u8(block4, key);
233 block5 = vaeseq_u8(block5, key);
236 key = vld1q_u8(keys+rounds*16);
237 data0 = vreinterpretq_u64_u8(veorq_u8(block0, key));
238 data1 = vreinterpretq_u64_u8(veorq_u8(block1, key));
239 data2 = vreinterpretq_u64_u8(veorq_u8(block2, key));
240 data3 = vreinterpretq_u64_u8(veorq_u8(block3, key));
241 data4 = vreinterpretq_u64_u8(veorq_u8(block4, key));
242 data5 = vreinterpretq_u64_u8(veorq_u8(block5, key));
245 static inline void ARMV8_Dec_Block(uint64x2_t &data,
const word32 *subkeys,
unsigned int rounds)
248 const byte *keys = reinterpret_cast<const byte*>(subkeys);
249 uint8x16_t block = vreinterpretq_u8_u64(data);
252 block = vaesdq_u8(block, vld1q_u8(keys+0*16));
254 block = vaesimcq_u8(block);
256 for (
unsigned int i=1; i<rounds-1; i+=2)
259 block = vaesdq_u8(block, vld1q_u8(keys+i*16));
261 block = vaesimcq_u8(block);
263 block = vaesdq_u8(block, vld1q_u8(keys+(i+1)*16));
265 block = vaesimcq_u8(block);
269 block = vaesdq_u8(block, vld1q_u8(keys+(rounds-1)*16));
271 block = veorq_u8(block, vld1q_u8(keys+rounds*16));
273 data = vreinterpretq_u64_u8(block);
276 static inline void ARMV8_Dec_6_Blocks(uint64x2_t &data0, uint64x2_t &data1,
277 uint64x2_t &data2, uint64x2_t &data3, uint64x2_t &data4, uint64x2_t &data5,
278 const word32 *subkeys,
unsigned int rounds)
281 const byte *keys = reinterpret_cast<const byte*>(subkeys);
283 uint8x16_t block0 = vreinterpretq_u8_u64(data0);
284 uint8x16_t block1 = vreinterpretq_u8_u64(data1);
285 uint8x16_t block2 = vreinterpretq_u8_u64(data2);
286 uint8x16_t block3 = vreinterpretq_u8_u64(data3);
287 uint8x16_t block4 = vreinterpretq_u8_u64(data4);
288 uint8x16_t block5 = vreinterpretq_u8_u64(data5);
291 for (
unsigned int i=0; i<rounds-1; ++i)
293 key = vld1q_u8(keys+i*16);
295 block0 = vaesdq_u8(block0, key);
297 block0 = vaesimcq_u8(block0);
299 block1 = vaesdq_u8(block1, key);
301 block1 = vaesimcq_u8(block1);
303 block2 = vaesdq_u8(block2, key);
305 block2 = vaesimcq_u8(block2);
307 block3 = vaesdq_u8(block3, key);
309 block3 = vaesimcq_u8(block3);
311 block4 = vaesdq_u8(block4, key);
313 block4 = vaesimcq_u8(block4);
315 block5 = vaesdq_u8(block5, key);
317 block5 = vaesimcq_u8(block5);
321 key = vld1q_u8(keys+(rounds-1)*16);
322 block0 = vaesdq_u8(block0, key);
323 block1 = vaesdq_u8(block1, key);
324 block2 = vaesdq_u8(block2, key);
325 block3 = vaesdq_u8(block3, key);
326 block4 = vaesdq_u8(block4, key);
327 block5 = vaesdq_u8(block5, key);
330 key = vld1q_u8(keys+rounds*16);
331 data0 = vreinterpretq_u64_u8(veorq_u8(block0, key));
332 data1 = vreinterpretq_u64_u8(veorq_u8(block1, key));
333 data2 = vreinterpretq_u64_u8(veorq_u8(block2, key));
334 data3 = vreinterpretq_u64_u8(veorq_u8(block3, key));
335 data4 = vreinterpretq_u64_u8(veorq_u8(block4, key));
336 data5 = vreinterpretq_u64_u8(veorq_u8(block5, key));
339 ANONYMOUS_NAMESPACE_END
341 size_t Rijndael_Enc_AdvancedProcessBlocks_ARMV8(
const word32 *subKeys,
size_t rounds,
342 const byte *inBlocks,
const byte *xorBlocks,
byte *outBlocks,
size_t length, word32 flags)
344 return AdvancedProcessBlocks128_NEON1x6(ARMV8_Enc_Block, ARMV8_Enc_6_Blocks,
345 subKeys, rounds, inBlocks, xorBlocks, outBlocks, length, flags);
348 size_t Rijndael_Dec_AdvancedProcessBlocks_ARMV8(
const word32 *subKeys,
size_t rounds,
349 const byte *inBlocks,
const byte *xorBlocks,
byte *outBlocks,
size_t length, word32 flags)
351 return AdvancedProcessBlocks128_NEON1x6(ARMV8_Dec_Block, ARMV8_Dec_6_Blocks,
352 subKeys, rounds, inBlocks, xorBlocks, outBlocks, length, flags);
355 #endif // CRYPTOPP_ARM_AES_AVAILABLE 359 #if (CRYPTOPP_AESNI_AVAILABLE) 361 ANONYMOUS_NAMESPACE_BEGIN
364 CRYPTOPP_ALIGN_DATA(16)
365 const word32 s_rconLE[] = {
366 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1B, 0x36
369 static inline void AESNI_Enc_Block(__m128i &block, MAYBE_CONST word32 *subkeys,
unsigned int rounds)
371 const __m128i* skeys = reinterpret_cast<const __m128i*>(subkeys);
373 block = _mm_xor_si128(block, skeys[0]);
374 for (
unsigned int i=1; i<rounds-1; i+=2)
376 block = _mm_aesenc_si128(block, skeys[i]);
377 block = _mm_aesenc_si128(block, skeys[i+1]);
379 block = _mm_aesenc_si128(block, skeys[rounds-1]);
380 block = _mm_aesenclast_si128(block, skeys[rounds]);
383 static inline void AESNI_Enc_4_Blocks(__m128i &block0, __m128i &block1, __m128i &block2, __m128i &block3,
384 MAYBE_CONST word32 *subkeys,
unsigned int rounds)
386 const __m128i* skeys = reinterpret_cast<const __m128i*>(subkeys);
388 __m128i rk = skeys[0];
389 block0 = _mm_xor_si128(block0, rk);
390 block1 = _mm_xor_si128(block1, rk);
391 block2 = _mm_xor_si128(block2, rk);
392 block3 = _mm_xor_si128(block3, rk);
393 for (
unsigned int i=1; i<rounds; i++)
396 block0 = _mm_aesenc_si128(block0, rk);
397 block1 = _mm_aesenc_si128(block1, rk);
398 block2 = _mm_aesenc_si128(block2, rk);
399 block3 = _mm_aesenc_si128(block3, rk);
402 block0 = _mm_aesenclast_si128(block0, rk);
403 block1 = _mm_aesenclast_si128(block1, rk);
404 block2 = _mm_aesenclast_si128(block2, rk);
405 block3 = _mm_aesenclast_si128(block3, rk);
408 static inline void AESNI_Dec_Block(__m128i &block, MAYBE_CONST word32 *subkeys,
unsigned int rounds)
410 const __m128i* skeys = reinterpret_cast<const __m128i*>(subkeys);
412 block = _mm_xor_si128(block, skeys[0]);
413 for (
unsigned int i=1; i<rounds-1; i+=2)
415 block = _mm_aesdec_si128(block, skeys[i]);
416 block = _mm_aesdec_si128(block, skeys[i+1]);
418 block = _mm_aesdec_si128(block, skeys[rounds-1]);
419 block = _mm_aesdeclast_si128(block, skeys[rounds]);
422 static inline void AESNI_Dec_4_Blocks(__m128i &block0, __m128i &block1, __m128i &block2, __m128i &block3,
423 MAYBE_CONST word32 *subkeys,
unsigned int rounds)
425 const __m128i* skeys = reinterpret_cast<const __m128i*>(subkeys);
427 __m128i rk = skeys[0];
428 block0 = _mm_xor_si128(block0, rk);
429 block1 = _mm_xor_si128(block1, rk);
430 block2 = _mm_xor_si128(block2, rk);
431 block3 = _mm_xor_si128(block3, rk);
432 for (
unsigned int i=1; i<rounds; i++)
435 block0 = _mm_aesdec_si128(block0, rk);
436 block1 = _mm_aesdec_si128(block1, rk);
437 block2 = _mm_aesdec_si128(block2, rk);
438 block3 = _mm_aesdec_si128(block3, rk);
441 block0 = _mm_aesdeclast_si128(block0, rk);
442 block1 = _mm_aesdeclast_si128(block1, rk);
443 block2 = _mm_aesdeclast_si128(block2, rk);
444 block3 = _mm_aesdeclast_si128(block3, rk);
447 ANONYMOUS_NAMESPACE_END
449 void Rijndael_UncheckedSetKey_SSE4_AESNI(
const byte *userKey,
size_t keyLen, word32 *rk)
451 const size_t rounds = keyLen / 4 + 6;
452 const word32 *rc = s_rconLE;
454 __m128i temp = _mm_loadu_si128(M128_CAST(userKey+keyLen-16));
455 std::memcpy(rk, userKey, keyLen);
458 const size_t keySize = 4*(rounds+1);
459 const word32* end = rk + keySize;
463 rk[keyLen/4] = rk[0] ^ _mm_extract_epi32(_mm_aeskeygenassist_si128(temp, 0), 3) ^ *(rc++);
464 rk[keyLen/4+1] = rk[1] ^ rk[keyLen/4];
465 rk[keyLen/4+2] = rk[2] ^ rk[keyLen/4+1];
466 rk[keyLen/4+3] = rk[3] ^ rk[keyLen/4+2];
468 if (rk + keyLen/4 + 4 == end)
473 rk[10] = rk[ 4] ^ rk[ 9];
474 rk[11] = rk[ 5] ^ rk[10];
475 temp = _mm_insert_epi32(temp, rk[11], 3);
477 else if (keyLen == 32)
479 temp = _mm_insert_epi32(temp, rk[11], 3);
480 rk[12] = rk[ 4] ^ _mm_extract_epi32(_mm_aeskeygenassist_si128(temp, 0), 2);
481 rk[13] = rk[ 5] ^ rk[12];
482 rk[14] = rk[ 6] ^ rk[13];
483 rk[15] = rk[ 7] ^ rk[14];
484 temp = _mm_insert_epi32(temp, rk[15], 3);
488 temp = _mm_insert_epi32(temp, rk[7], 3);
495 void Rijndael_UncheckedSetKeyRev_AESNI(word32 *key,
unsigned int rounds)
500 vec_swap(*M128_CAST(key), *M128_CAST(key+4*rounds));
502 for (i = 4, j = 4*rounds-4; i < j; i += 4, j -= 4)
504 temp = _mm_aesimc_si128(*M128_CAST(key+i));
505 *M128_CAST(key+i) = _mm_aesimc_si128(*M128_CAST(key+j));
506 *M128_CAST(key+j) = temp;
509 *M128_CAST(key+i) = _mm_aesimc_si128(*M128_CAST(key+i));
512 size_t Rijndael_Enc_AdvancedProcessBlocks_AESNI(
const word32 *subKeys,
size_t rounds,
513 const byte *inBlocks,
const byte *xorBlocks,
byte *outBlocks,
size_t length, word32 flags)
516 MAYBE_CONST word32* sk = MAYBE_UNCONST_CAST(word32*, subKeys);
517 MAYBE_CONST
byte* ib = MAYBE_UNCONST_CAST(
byte*, inBlocks);
518 MAYBE_CONST
byte* xb = MAYBE_UNCONST_CAST(
byte*, xorBlocks);
520 return AdvancedProcessBlocks128_4x1_SSE(AESNI_Enc_Block, AESNI_Enc_4_Blocks,
521 sk, rounds, ib, xb, outBlocks, length, flags);
524 size_t Rijndael_Dec_AdvancedProcessBlocks_AESNI(
const word32 *subKeys,
size_t rounds,
525 const byte *inBlocks,
const byte *xorBlocks,
byte *outBlocks,
size_t length, word32 flags)
527 MAYBE_CONST word32* sk = MAYBE_UNCONST_CAST(word32*, subKeys);
528 MAYBE_CONST
byte* ib = MAYBE_UNCONST_CAST(
byte*, inBlocks);
529 MAYBE_CONST
byte* xb = MAYBE_UNCONST_CAST(
byte*, xorBlocks);
531 return AdvancedProcessBlocks128_4x1_SSE(AESNI_Dec_Block, AESNI_Dec_4_Blocks,
532 sk, rounds, ib, xb, outBlocks, length, flags);
535 #endif // CRYPTOPP_AESNI_AVAILABLE 539 #if (CRYPTOPP_POWER8_AES_AVAILABLE) 541 ANONYMOUS_NAMESPACE_BEGIN
544 CRYPTOPP_ALIGN_DATA(16)
545 static const uint32_t s_rconBE[] = {
546 0x01000000, 0x02000000, 0x04000000, 0x08000000,
547 0x10000000, 0x20000000, 0x40000000, 0x80000000,
548 0x1B000000, 0x36000000
551 static inline void POWER8_Enc_Block(uint32x4_p &block,
const word32 *subkeys,
unsigned int rounds)
554 const byte *keys = reinterpret_cast<const byte*>(subkeys);
559 for (
size_t i=1; i<rounds-1; i+=2)
569 static inline void POWER8_Enc_6_Blocks(uint32x4_p &block0, uint32x4_p &block1,
570 uint32x4_p &block2, uint32x4_p &block3, uint32x4_p &block4,
571 uint32x4_p &block5,
const word32 *subkeys,
unsigned int rounds)
574 const byte *keys = reinterpret_cast<const byte*>(subkeys);
584 for (
size_t i=1; i<rounds; ++i)
604 static inline void POWER8_Dec_Block(uint32x4_p &block,
const word32 *subkeys,
unsigned int rounds)
607 const byte *keys = reinterpret_cast<const byte*>(subkeys);
612 for (
size_t i=rounds-1; i>1; i-=2)
622 static inline void POWER8_Dec_6_Blocks(uint32x4_p &block0, uint32x4_p &block1,
623 uint32x4_p &block2, uint32x4_p &block3, uint32x4_p &block4,
624 uint32x4_p &block5,
const word32 *subkeys,
unsigned int rounds)
627 const byte *keys = reinterpret_cast<const byte*>(subkeys);
637 for (
size_t i=rounds-1; i>0; --i)
657 ANONYMOUS_NAMESPACE_END
659 void Rijndael_UncheckedSetKey_POWER8(
const byte* userKey,
size_t keyLen, word32* rk,
const byte* Se)
661 const size_t rounds = keyLen / 4 + 6;
662 const word32 *rc = s_rconBE;
665 word32 *rk_saved = rk, temp;
666 CRYPTOPP_UNUSED(rk_saved);
669 const size_t keySize = 4*(rounds+1);
670 const word32* end = rk + keySize;
674 temp = rk[keyLen/4-1];
675 word32 x = (word32(Se[GETBYTE(temp, 2)]) << 24) ^ (word32(Se[GETBYTE(temp, 1)]) << 16) ^
676 (word32(Se[GETBYTE(temp, 0)]) << 8) ^ Se[GETBYTE(temp, 3)];
677 rk[keyLen/4] = rk[0] ^ x ^ *(rc++);
678 rk[keyLen/4+1] = rk[1] ^ rk[keyLen/4];
679 rk[keyLen/4+2] = rk[2] ^ rk[keyLen/4+1];
680 rk[keyLen/4+3] = rk[3] ^ rk[keyLen/4+2];
682 if (rk + keyLen/4 + 4 == end)
687 rk[10] = rk[ 4] ^ rk[ 9];
688 rk[11] = rk[ 5] ^ rk[10];
690 else if (keyLen == 32)
693 rk[12] = rk[ 4] ^ (word32(Se[GETBYTE(temp, 3)]) << 24) ^ (word32(Se[GETBYTE(temp, 2)]) << 16) ^ (word32(Se[GETBYTE(temp, 1)]) << 8) ^ Se[GETBYTE(temp, 0)];
694 rk[13] = rk[ 5] ^ rk[12];
695 rk[14] = rk[ 6] ^ rk[13];
696 rk[15] = rk[ 7] ^ rk[14];
701 #if defined(CRYPTOPP_LITTLE_ENDIAN) 703 const uint8x16_p mask = ((uint8x16_p){12,13,14,15, 8,9,10,11, 4,5,6,7, 0,1,2,3});
704 const uint8x16_p zero = {0};
707 for (i=0; i<rounds; i+=2, rk+=8)
709 const uint8x16_p d1 = vec_vsx_ld( 0, (uint8_t*)rk);
710 const uint8x16_p d2 = vec_vsx_ld(16, (uint8_t*)rk);
711 vec_vsx_st(vec_perm(d1, zero, mask), 0, (uint8_t*)rk);
712 vec_vsx_st(vec_perm(d2, zero, mask), 16, (uint8_t*)rk);
715 for ( ; i<rounds+1; i++, rk+=4)
716 vec_vsx_st(vec_perm(vec_vsx_ld(0, (uint8_t*)rk), zero, mask), 0, (uint8_t*)rk);
720 size_t Rijndael_Enc_AdvancedProcessBlocks128_6x1_ALTIVEC(
const word32 *subKeys,
size_t rounds,
721 const byte *inBlocks,
const byte *xorBlocks,
byte *outBlocks,
size_t length, word32 flags)
723 return AdvancedProcessBlocks128_6x1_ALTIVEC(POWER8_Enc_Block, POWER8_Enc_6_Blocks,
724 subKeys, rounds, inBlocks, xorBlocks, outBlocks, length, flags);
727 size_t Rijndael_Dec_AdvancedProcessBlocks128_6x1_ALTIVEC(
const word32 *subKeys,
size_t rounds,
728 const byte *inBlocks,
const byte *xorBlocks,
byte *outBlocks,
size_t length, word32 flags)
730 return AdvancedProcessBlocks128_6x1_ALTIVEC(POWER8_Dec_Block, POWER8_Dec_6_Blocks,
731 subKeys, rounds, inBlocks, xorBlocks, outBlocks, length, flags);
734 #endif // CRYPTOPP_POWER8_AES_AVAILABLE T1 VectorEncrypt(const T1 &state, const T2 &key)
One round of AES encryption.
Utility functions for the Crypto++ library.
T1 VectorEncryptLast(const T1 &state, const T2 &key)
Final round of AES encryption.
Library configuration file.
T1 VectorDecryptLast(const T1 &state, const T2 &key)
Final round of AES decryption.
Support functions for PowerPC and vector operations.
bool IsAlignedOn(const void *ptr, unsigned int alignment)
Determines whether ptr is aligned to a minimum value.
uint32x4_p VectorLoadKey(const byte src[16])
Loads a vector from a byte array.
#define CRYPTOPP_ASSERT(exp)
Debugging and diagnostic assertion.
T1 VectorXor(const T1 &vec1, const T2 &vec2)
XOR two vectors.
T1 VectorDecrypt(const T1 &state, const T2 &key)
One round of AES decryption.
Crypto++ library namespace.
void vec_swap(T &a, T &b)
Swaps two variables which are arrays.