Add ARMv8/CE acceleration for AES-XTS
[libgcrypt.git] / cipher / rijndael.c
1 /* Rijndael (AES) for GnuPG
2  * Copyright (C) 2000, 2001, 2002, 2003, 2007,
3  *               2008, 2011, 2012 Free Software Foundation, Inc.
4  *
5  * This file is part of Libgcrypt.
6  *
7  * Libgcrypt is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU Lesser General Public License as
9  * published by the Free Software Foundation; either version 2.1 of
10  * the License, or (at your option) any later version.
11  *
12  * Libgcrypt is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
19  *******************************************************************
20  * The code here is based on the optimized implementation taken from
21  * http://www.esat.kuleuven.ac.be/~rijmen/rijndael/ on Oct 2, 2000,
22  * which carries this notice:
23  *------------------------------------------
24  * rijndael-alg-fst.c   v2.3   April '2000
25  *
26  * Optimised ANSI C code
27  *
28  * authors: v1.0: Antoon Bosselaers
29  *          v2.0: Vincent Rijmen
30  *          v2.3: Paulo Barreto
31  *
32  * This code is placed in the public domain.
33  *------------------------------------------
34  *
35  * The SP800-38a document is available at:
36  *   http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
37  *
38  */
39
40 #include <config.h>
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <string.h> /* for memcmp() */
44
45 #include "types.h"  /* for byte and u32 typedefs */
46 #include "g10lib.h"
47 #include "cipher.h"
48 #include "bufhelp.h"
49 #include "cipher-selftest.h"
50 #include "rijndael-internal.h"
51 #include "./cipher-internal.h"
52
53
54 #ifdef USE_AMD64_ASM
55 /* AMD64 assembly implementations of AES */
56 extern unsigned int _gcry_aes_amd64_encrypt_block(const void *keysched_enc,
57                                                   unsigned char *out,
58                                                   const unsigned char *in,
59                                                   int rounds,
60                                                   const void *encT);
61
62 extern unsigned int _gcry_aes_amd64_decrypt_block(const void *keysched_dec,
63                                                   unsigned char *out,
64                                                   const unsigned char *in,
65                                                   int rounds,
66                                                   const void *decT);
67 #endif /*USE_AMD64_ASM*/
68
69 #ifdef USE_AESNI
70 /* AES-NI (AMD64 & i386) accelerated implementations of AES */
71 extern void _gcry_aes_aesni_do_setkey(RIJNDAEL_context *ctx, const byte *key);
72 extern void _gcry_aes_aesni_prepare_decryption(RIJNDAEL_context *ctx);
73
74 extern unsigned int _gcry_aes_aesni_encrypt (const RIJNDAEL_context *ctx,
75                                              unsigned char *dst,
76                                              const unsigned char *src);
77 extern unsigned int _gcry_aes_aesni_decrypt (const RIJNDAEL_context *ctx,
78                                              unsigned char *dst,
79                                              const unsigned char *src);
80 extern void _gcry_aes_aesni_cfb_enc (RIJNDAEL_context *ctx,
81                                      unsigned char *outbuf,
82                                      const unsigned char *inbuf,
83                                      unsigned char *iv, size_t nblocks);
84 extern void _gcry_aes_aesni_cbc_enc (RIJNDAEL_context *ctx,
85                                      unsigned char *outbuf,
86                                      const unsigned char *inbuf,
87                                      unsigned char *iv, size_t nblocks,
88                                      int cbc_mac);
89 extern void _gcry_aes_aesni_ctr_enc (RIJNDAEL_context *ctx,
90                                      unsigned char *outbuf,
91                                      const unsigned char *inbuf,
92                                      unsigned char *ctr, size_t nblocks);
93 extern void _gcry_aes_aesni_cfb_dec (RIJNDAEL_context *ctx,
94                                      unsigned char *outbuf,
95                                      const unsigned char *inbuf,
96                                      unsigned char *iv, size_t nblocks);
97 extern void _gcry_aes_aesni_cbc_dec (RIJNDAEL_context *ctx,
98                                      unsigned char *outbuf,
99                                      const unsigned char *inbuf,
100                                      unsigned char *iv, size_t nblocks);
101 extern void _gcry_aes_aesni_ocb_crypt (gcry_cipher_hd_t c, void *outbuf_arg,
102                                        const void *inbuf_arg, size_t nblocks,
103                                        int encrypt);
104 extern void _gcry_aes_aesni_ocb_auth (gcry_cipher_hd_t c, const void *abuf_arg,
105                                       size_t nblocks);
106 extern void _gcry_aes_aesni_xts_crypt (RIJNDAEL_context *ctx,
107                                        unsigned char *tweak,
108                                        unsigned char *outbuf,
109                                        const unsigned char *inbuf,
110                                        size_t nblocks, int encrypt);
111 #endif
112
113 #ifdef USE_SSSE3
114 /* SSSE3 (AMD64) vector permutation implementation of AES */
115 extern void _gcry_aes_ssse3_do_setkey(RIJNDAEL_context *ctx, const byte *key);
116 extern void _gcry_aes_ssse3_prepare_decryption(RIJNDAEL_context *ctx);
117
118 extern unsigned int _gcry_aes_ssse3_encrypt (const RIJNDAEL_context *ctx,
119                                              unsigned char *dst,
120                                              const unsigned char *src);
121 extern unsigned int _gcry_aes_ssse3_decrypt (const RIJNDAEL_context *ctx,
122                                              unsigned char *dst,
123                                              const unsigned char *src);
124 extern void _gcry_aes_ssse3_cfb_enc (RIJNDAEL_context *ctx,
125                                      unsigned char *outbuf,
126                                      const unsigned char *inbuf,
127                                      unsigned char *iv, size_t nblocks);
128 extern void _gcry_aes_ssse3_cbc_enc (RIJNDAEL_context *ctx,
129                                      unsigned char *outbuf,
130                                      const unsigned char *inbuf,
131                                      unsigned char *iv, size_t nblocks,
132                                      int cbc_mac);
133 extern void _gcry_aes_ssse3_ctr_enc (RIJNDAEL_context *ctx,
134                                      unsigned char *outbuf,
135                                      const unsigned char *inbuf,
136                                      unsigned char *ctr, size_t nblocks);
137 extern void _gcry_aes_ssse3_cfb_dec (RIJNDAEL_context *ctx,
138                                      unsigned char *outbuf,
139                                      const unsigned char *inbuf,
140                                      unsigned char *iv, size_t nblocks);
141 extern void _gcry_aes_ssse3_cbc_dec (RIJNDAEL_context *ctx,
142                                      unsigned char *outbuf,
143                                      const unsigned char *inbuf,
144                                      unsigned char *iv, size_t nblocks);
145 extern void _gcry_aes_ssse3_ocb_crypt (gcry_cipher_hd_t c, void *outbuf_arg,
146                                        const void *inbuf_arg, size_t nblocks,
147                                        int encrypt);
148 extern void _gcry_aes_ssse3_ocb_auth (gcry_cipher_hd_t c, const void *abuf_arg,
149                                       size_t nblocks);
150 #endif
151
152 #ifdef USE_PADLOCK
153 extern unsigned int _gcry_aes_padlock_encrypt (const RIJNDAEL_context *ctx,
154                                                unsigned char *bx,
155                                                const unsigned char *ax);
156 extern unsigned int _gcry_aes_padlock_decrypt (const RIJNDAEL_context *ctx,
157                                                unsigned char *bx,
158                                                const unsigned char *ax);
159 #endif
160
161 #ifdef USE_ARM_ASM
162 /* ARM assembly implementations of AES */
163 extern unsigned int _gcry_aes_arm_encrypt_block(const void *keysched_enc,
164                                                 unsigned char *out,
165                                                 const unsigned char *in,
166                                                 int rounds,
167                                                 const void *encT);
168
169 extern unsigned int _gcry_aes_arm_decrypt_block(const void *keysched_dec,
170                                                 unsigned char *out,
171                                                 const unsigned char *in,
172                                                 int rounds,
173                                                 const void *decT);
174 #endif /*USE_ARM_ASM*/
175
176 #ifdef USE_ARM_CE
177 /* ARMv8 Crypto Extension implementations of AES */
178 extern void _gcry_aes_armv8_ce_setkey(RIJNDAEL_context *ctx, const byte *key);
179 extern void _gcry_aes_armv8_ce_prepare_decryption(RIJNDAEL_context *ctx);
180
181 extern unsigned int _gcry_aes_armv8_ce_encrypt(const RIJNDAEL_context *ctx,
182                                                unsigned char *dst,
183                                                const unsigned char *src);
184 extern unsigned int _gcry_aes_armv8_ce_decrypt(const RIJNDAEL_context *ctx,
185                                                unsigned char *dst,
186                                                const unsigned char *src);
187
188 extern void _gcry_aes_armv8_ce_cfb_enc (RIJNDAEL_context *ctx,
189                                         unsigned char *outbuf,
190                                         const unsigned char *inbuf,
191                                         unsigned char *iv, size_t nblocks);
192 extern void _gcry_aes_armv8_ce_cbc_enc (RIJNDAEL_context *ctx,
193                                         unsigned char *outbuf,
194                                         const unsigned char *inbuf,
195                                         unsigned char *iv, size_t nblocks,
196                                         int cbc_mac);
197 extern void _gcry_aes_armv8_ce_ctr_enc (RIJNDAEL_context *ctx,
198                                         unsigned char *outbuf,
199                                         const unsigned char *inbuf,
200                                         unsigned char *ctr, size_t nblocks);
201 extern void _gcry_aes_armv8_ce_cfb_dec (RIJNDAEL_context *ctx,
202                                         unsigned char *outbuf,
203                                         const unsigned char *inbuf,
204                                         unsigned char *iv, size_t nblocks);
205 extern void _gcry_aes_armv8_ce_cbc_dec (RIJNDAEL_context *ctx,
206                                         unsigned char *outbuf,
207                                         const unsigned char *inbuf,
208                                         unsigned char *iv, size_t nblocks);
209 extern void _gcry_aes_armv8_ce_ocb_crypt (gcry_cipher_hd_t c, void *outbuf_arg,
210                                           const void *inbuf_arg, size_t nblocks,
211                                           int encrypt);
212 extern void _gcry_aes_armv8_ce_ocb_auth (gcry_cipher_hd_t c,
213                                          const void *abuf_arg, size_t nblocks);
214 extern void _gcry_aes_armv8_ce_xts_crypt (RIJNDAEL_context *ctx,
215                                           unsigned char *tweak,
216                                           unsigned char *outbuf,
217                                           const unsigned char *inbuf,
218                                           size_t nblocks, int encrypt);
219 #endif /*USE_ARM_ASM*/
220
221 static unsigned int do_encrypt (const RIJNDAEL_context *ctx, unsigned char *bx,
222                                 const unsigned char *ax);
223 static unsigned int do_decrypt (const RIJNDAEL_context *ctx, unsigned char *bx,
224                                 const unsigned char *ax);
225
226 \f
227
228 /* All the numbers.  */
229 #include "rijndael-tables.h"
230
231
232 \f
233
234 /* Function prototypes.  */
235 static const char *selftest(void);
236
237
238 \f
239 /* Prefetching for encryption/decryption tables. */
240 static void prefetch_table(const volatile byte *tab, size_t len)
241 {
242   size_t i;
243
244   for (i = 0; i < len; i += 8 * 32)
245     {
246       (void)tab[i + 0 * 32];
247       (void)tab[i + 1 * 32];
248       (void)tab[i + 2 * 32];
249       (void)tab[i + 3 * 32];
250       (void)tab[i + 4 * 32];
251       (void)tab[i + 5 * 32];
252       (void)tab[i + 6 * 32];
253       (void)tab[i + 7 * 32];
254     }
255
256   (void)tab[len - 1];
257 }
258
259 static void prefetch_enc(void)
260 {
261   prefetch_table((const void *)encT, sizeof(encT));
262 }
263
264 static void prefetch_dec(void)
265 {
266   prefetch_table((const void *)&dec_tables, sizeof(dec_tables));
267 }
268
269
270 \f
271 /* Perform the key setup.  */
272 static gcry_err_code_t
273 do_setkey (RIJNDAEL_context *ctx, const byte *key, const unsigned keylen)
274 {
275   static int initialized = 0;
276   static const char *selftest_failed = 0;
277   int rounds;
278   int i,j, r, t, rconpointer = 0;
279   int KC;
280 #if defined(USE_AESNI) || defined(USE_PADLOCK) || defined(USE_SSSE3) \
281     || defined(USE_ARM_CE)
282   unsigned int hwfeatures;
283 #endif
284
285   /* The on-the-fly self tests are only run in non-fips mode. In fips
286      mode explicit self-tests are required.  Actually the on-the-fly
287      self-tests are not fully thread-safe and it might happen that a
288      failed self-test won't get noticed in another thread.
289
290      FIXME: We might want to have a central registry of succeeded
291      self-tests. */
292   if (!fips_mode () && !initialized)
293     {
294       initialized = 1;
295       selftest_failed = selftest ();
296       if (selftest_failed)
297         log_error ("%s\n", selftest_failed );
298     }
299   if (selftest_failed)
300     return GPG_ERR_SELFTEST_FAILED;
301
302   if( keylen == 128/8 )
303     {
304       rounds = 10;
305       KC = 4;
306     }
307   else if ( keylen == 192/8 )
308     {
309       rounds = 12;
310       KC = 6;
311     }
312   else if ( keylen == 256/8 )
313     {
314       rounds = 14;
315       KC = 8;
316     }
317   else
318     return GPG_ERR_INV_KEYLEN;
319
320   ctx->rounds = rounds;
321
322 #if defined(USE_AESNI) || defined(USE_PADLOCK) || defined(USE_SSSE3) \
323     || defined(USE_ARM_CE)
324   hwfeatures = _gcry_get_hw_features ();
325 #endif
326
327   ctx->decryption_prepared = 0;
328 #ifdef USE_PADLOCK
329   ctx->use_padlock = 0;
330 #endif
331 #ifdef USE_AESNI
332   ctx->use_aesni = 0;
333 #endif
334 #ifdef USE_SSSE3
335   ctx->use_ssse3 = 0;
336 #endif
337 #ifdef USE_ARM_CE
338   ctx->use_arm_ce = 0;
339 #endif
340
341   if (0)
342     {
343       ;
344     }
345 #ifdef USE_AESNI
346   else if (hwfeatures & HWF_INTEL_AESNI)
347     {
348       ctx->encrypt_fn = _gcry_aes_aesni_encrypt;
349       ctx->decrypt_fn = _gcry_aes_aesni_decrypt;
350       ctx->prefetch_enc_fn = NULL;
351       ctx->prefetch_dec_fn = NULL;
352       ctx->use_aesni = 1;
353     }
354 #endif
355 #ifdef USE_PADLOCK
356   else if (hwfeatures & HWF_PADLOCK_AES && keylen == 128/8)
357     {
358       ctx->encrypt_fn = _gcry_aes_padlock_encrypt;
359       ctx->decrypt_fn = _gcry_aes_padlock_decrypt;
360       ctx->prefetch_enc_fn = NULL;
361       ctx->prefetch_dec_fn = NULL;
362       ctx->use_padlock = 1;
363       memcpy (ctx->padlockkey, key, keylen);
364     }
365 #endif
366 #ifdef USE_SSSE3
367   else if (hwfeatures & HWF_INTEL_SSSE3)
368     {
369       ctx->encrypt_fn = _gcry_aes_ssse3_encrypt;
370       ctx->decrypt_fn = _gcry_aes_ssse3_decrypt;
371       ctx->prefetch_enc_fn = NULL;
372       ctx->prefetch_dec_fn = NULL;
373       ctx->use_ssse3 = 1;
374     }
375 #endif
376 #ifdef USE_ARM_CE
377   else if (hwfeatures & HWF_ARM_AES)
378     {
379       ctx->encrypt_fn = _gcry_aes_armv8_ce_encrypt;
380       ctx->decrypt_fn = _gcry_aes_armv8_ce_decrypt;
381       ctx->prefetch_enc_fn = NULL;
382       ctx->prefetch_dec_fn = NULL;
383       ctx->use_arm_ce = 1;
384     }
385 #endif
386   else
387     {
388       ctx->encrypt_fn = do_encrypt;
389       ctx->decrypt_fn = do_decrypt;
390       ctx->prefetch_enc_fn = prefetch_enc;
391       ctx->prefetch_dec_fn = prefetch_dec;
392     }
393
394   /* NB: We don't yet support Padlock hardware key generation.  */
395
396   if (0)
397     {
398       ;
399     }
400 #ifdef USE_AESNI
401   else if (ctx->use_aesni)
402     _gcry_aes_aesni_do_setkey (ctx, key);
403 #endif
404 #ifdef USE_SSSE3
405   else if (ctx->use_ssse3)
406     _gcry_aes_ssse3_do_setkey (ctx, key);
407 #endif
408 #ifdef USE_ARM_CE
409   else if (ctx->use_arm_ce)
410     _gcry_aes_armv8_ce_setkey (ctx, key);
411 #endif
412   else
413     {
414       const byte *sbox = ((const byte *)encT) + 1;
415       union
416         {
417           PROPERLY_ALIGNED_TYPE dummy;
418           byte data[MAXKC][4];
419           u32 data32[MAXKC];
420         } tkk[2];
421 #define k      tkk[0].data
422 #define k_u32  tkk[0].data32
423 #define tk     tkk[1].data
424 #define tk_u32 tkk[1].data32
425 #define W      (ctx->keyschenc)
426 #define W_u32  (ctx->keyschenc32)
427
428       prefetch_enc();
429
430       for (i = 0; i < keylen; i++)
431         {
432           k[i >> 2][i & 3] = key[i];
433         }
434
435       for (j = KC-1; j >= 0; j--)
436         {
437           tk_u32[j] = k_u32[j];
438         }
439       r = 0;
440       t = 0;
441       /* Copy values into round key array.  */
442       for (j = 0; (j < KC) && (r < rounds + 1); )
443         {
444           for (; (j < KC) && (t < 4); j++, t++)
445             {
446               W_u32[r][t] = le_bswap32(tk_u32[j]);
447             }
448           if (t == 4)
449             {
450               r++;
451               t = 0;
452             }
453         }
454
455       while (r < rounds + 1)
456         {
457           /* While not enough round key material calculated calculate
458              new values.  */
459           tk[0][0] ^= sbox[tk[KC-1][1] * 4];
460           tk[0][1] ^= sbox[tk[KC-1][2] * 4];
461           tk[0][2] ^= sbox[tk[KC-1][3] * 4];
462           tk[0][3] ^= sbox[tk[KC-1][0] * 4];
463           tk[0][0] ^= rcon[rconpointer++];
464
465           if (KC != 8)
466             {
467               for (j = 1; j < KC; j++)
468                 {
469                   tk_u32[j] ^= tk_u32[j-1];
470                 }
471             }
472           else
473             {
474               for (j = 1; j < KC/2; j++)
475                 {
476                   tk_u32[j] ^= tk_u32[j-1];
477                 }
478               tk[KC/2][0] ^= sbox[tk[KC/2 - 1][0] * 4];
479               tk[KC/2][1] ^= sbox[tk[KC/2 - 1][1] * 4];
480               tk[KC/2][2] ^= sbox[tk[KC/2 - 1][2] * 4];
481               tk[KC/2][3] ^= sbox[tk[KC/2 - 1][3] * 4];
482               for (j = KC/2 + 1; j < KC; j++)
483                 {
484                   tk_u32[j] ^= tk_u32[j-1];
485                 }
486             }
487
488           /* Copy values into round key array.  */
489           for (j = 0; (j < KC) && (r < rounds + 1); )
490             {
491               for (; (j < KC) && (t < 4); j++, t++)
492                 {
493                   W_u32[r][t] = le_bswap32(tk_u32[j]);
494                 }
495               if (t == 4)
496                 {
497                   r++;
498                   t = 0;
499                 }
500             }
501         }
502 #undef W
503 #undef tk
504 #undef k
505 #undef W_u32
506 #undef tk_u32
507 #undef k_u32
508       wipememory(&tkk, sizeof(tkk));
509     }
510
511   return 0;
512 }
513
514
515 static gcry_err_code_t
516 rijndael_setkey (void *context, const byte *key, const unsigned keylen)
517 {
518   RIJNDAEL_context *ctx = context;
519   return do_setkey (ctx, key, keylen);
520 }
521
522
523 /* Make a decryption key from an encryption key. */
524 static void
525 prepare_decryption( RIJNDAEL_context *ctx )
526 {
527   int r;
528
529   if (0)
530     ;
531 #ifdef USE_AESNI
532   else if (ctx->use_aesni)
533     {
534       _gcry_aes_aesni_prepare_decryption (ctx);
535     }
536 #endif /*USE_AESNI*/
537 #ifdef USE_SSSE3
538   else if (ctx->use_ssse3)
539     {
540       _gcry_aes_ssse3_prepare_decryption (ctx);
541     }
542 #endif /*USE_SSSE3*/
543 #ifdef USE_ARM_CE
544   else if (ctx->use_arm_ce)
545     {
546       _gcry_aes_armv8_ce_prepare_decryption (ctx);
547     }
548 #endif /*USE_SSSE3*/
549 #ifdef USE_PADLOCK
550   else if (ctx->use_padlock)
551     {
552       /* Padlock does not need decryption subkeys. */
553     }
554 #endif /*USE_PADLOCK*/
555   else
556     {
557       const byte *sbox = ((const byte *)encT) + 1;
558
559       prefetch_enc();
560       prefetch_dec();
561
562       ctx->keyschdec32[0][0] = ctx->keyschenc32[0][0];
563       ctx->keyschdec32[0][1] = ctx->keyschenc32[0][1];
564       ctx->keyschdec32[0][2] = ctx->keyschenc32[0][2];
565       ctx->keyschdec32[0][3] = ctx->keyschenc32[0][3];
566
567       for (r = 1; r < ctx->rounds; r++)
568         {
569           u32 *wi = ctx->keyschenc32[r];
570           u32 *wo = ctx->keyschdec32[r];
571           u32 wt;
572
573           wt = wi[0];
574           wo[0] = rol(decT[sbox[(byte)(wt >> 0) * 4]], 8 * 0)
575                  ^ rol(decT[sbox[(byte)(wt >> 8) * 4]], 8 * 1)
576                  ^ rol(decT[sbox[(byte)(wt >> 16) * 4]], 8 * 2)
577                  ^ rol(decT[sbox[(byte)(wt >> 24) * 4]], 8 * 3);
578
579           wt = wi[1];
580           wo[1] = rol(decT[sbox[(byte)(wt >> 0) * 4]], 8 * 0)
581                  ^ rol(decT[sbox[(byte)(wt >> 8) * 4]], 8 * 1)
582                  ^ rol(decT[sbox[(byte)(wt >> 16) * 4]], 8 * 2)
583                  ^ rol(decT[sbox[(byte)(wt >> 24) * 4]], 8 * 3);
584
585           wt = wi[2];
586           wo[2] = rol(decT[sbox[(byte)(wt >> 0) * 4]], 8 * 0)
587                  ^ rol(decT[sbox[(byte)(wt >> 8) * 4]], 8 * 1)
588                  ^ rol(decT[sbox[(byte)(wt >> 16) * 4]], 8 * 2)
589                  ^ rol(decT[sbox[(byte)(wt >> 24) * 4]], 8 * 3);
590
591           wt = wi[3];
592           wo[3] = rol(decT[sbox[(byte)(wt >> 0) * 4]], 8 * 0)
593                  ^ rol(decT[sbox[(byte)(wt >> 8) * 4]], 8 * 1)
594                  ^ rol(decT[sbox[(byte)(wt >> 16) * 4]], 8 * 2)
595                  ^ rol(decT[sbox[(byte)(wt >> 24) * 4]], 8 * 3);
596         }
597
598       ctx->keyschdec32[r][0] = ctx->keyschenc32[r][0];
599       ctx->keyschdec32[r][1] = ctx->keyschenc32[r][1];
600       ctx->keyschdec32[r][2] = ctx->keyschenc32[r][2];
601       ctx->keyschdec32[r][3] = ctx->keyschenc32[r][3];
602     }
603 }
604
605 \f
606 #if !defined(USE_ARM_ASM) && !defined(USE_AMD64_ASM)
607 /* Encrypt one block. A and B may be the same. */
608 static unsigned int
609 do_encrypt_fn (const RIJNDAEL_context *ctx, unsigned char *b,
610                const unsigned char *a)
611 {
612 #define rk (ctx->keyschenc32)
613   const byte *sbox = ((const byte *)encT) + 1;
614   int rounds = ctx->rounds;
615   int r;
616   u32 sa[4];
617   u32 sb[4];
618
619   sb[0] = buf_get_le32(a + 0);
620   sb[1] = buf_get_le32(a + 4);
621   sb[2] = buf_get_le32(a + 8);
622   sb[3] = buf_get_le32(a + 12);
623
624   sa[0] = sb[0] ^ rk[0][0];
625   sa[1] = sb[1] ^ rk[0][1];
626   sa[2] = sb[2] ^ rk[0][2];
627   sa[3] = sb[3] ^ rk[0][3];
628
629   sb[0] = rol(encT[(byte)(sa[0] >> (0 * 8))], (0 * 8));
630   sb[3] = rol(encT[(byte)(sa[0] >> (1 * 8))], (1 * 8));
631   sb[2] = rol(encT[(byte)(sa[0] >> (2 * 8))], (2 * 8));
632   sb[1] = rol(encT[(byte)(sa[0] >> (3 * 8))], (3 * 8));
633   sa[0] = rk[1][0] ^ sb[0];
634
635   sb[1] ^= rol(encT[(byte)(sa[1] >> (0 * 8))], (0 * 8));
636   sa[0] ^= rol(encT[(byte)(sa[1] >> (1 * 8))], (1 * 8));
637   sb[3] ^= rol(encT[(byte)(sa[1] >> (2 * 8))], (2 * 8));
638   sb[2] ^= rol(encT[(byte)(sa[1] >> (3 * 8))], (3 * 8));
639   sa[1] = rk[1][1] ^ sb[1];
640
641   sb[2] ^= rol(encT[(byte)(sa[2] >> (0 * 8))], (0 * 8));
642   sa[1] ^= rol(encT[(byte)(sa[2] >> (1 * 8))], (1 * 8));
643   sa[0] ^= rol(encT[(byte)(sa[2] >> (2 * 8))], (2 * 8));
644   sb[3] ^= rol(encT[(byte)(sa[2] >> (3 * 8))], (3 * 8));
645   sa[2] = rk[1][2] ^ sb[2];
646
647   sb[3] ^= rol(encT[(byte)(sa[3] >> (0 * 8))], (0 * 8));
648   sa[2] ^= rol(encT[(byte)(sa[3] >> (1 * 8))], (1 * 8));
649   sa[1] ^= rol(encT[(byte)(sa[3] >> (2 * 8))], (2 * 8));
650   sa[0] ^= rol(encT[(byte)(sa[3] >> (3 * 8))], (3 * 8));
651   sa[3] = rk[1][3] ^ sb[3];
652
653   for (r = 2; r < rounds; r++)
654     {
655       sb[0] = rol(encT[(byte)(sa[0] >> (0 * 8))], (0 * 8));
656       sb[3] = rol(encT[(byte)(sa[0] >> (1 * 8))], (1 * 8));
657       sb[2] = rol(encT[(byte)(sa[0] >> (2 * 8))], (2 * 8));
658       sb[1] = rol(encT[(byte)(sa[0] >> (3 * 8))], (3 * 8));
659       sa[0] = rk[r][0] ^ sb[0];
660
661       sb[1] ^= rol(encT[(byte)(sa[1] >> (0 * 8))], (0 * 8));
662       sa[0] ^= rol(encT[(byte)(sa[1] >> (1 * 8))], (1 * 8));
663       sb[3] ^= rol(encT[(byte)(sa[1] >> (2 * 8))], (2 * 8));
664       sb[2] ^= rol(encT[(byte)(sa[1] >> (3 * 8))], (3 * 8));
665       sa[1] = rk[r][1] ^ sb[1];
666
667       sb[2] ^= rol(encT[(byte)(sa[2] >> (0 * 8))], (0 * 8));
668       sa[1] ^= rol(encT[(byte)(sa[2] >> (1 * 8))], (1 * 8));
669       sa[0] ^= rol(encT[(byte)(sa[2] >> (2 * 8))], (2 * 8));
670       sb[3] ^= rol(encT[(byte)(sa[2] >> (3 * 8))], (3 * 8));
671       sa[2] = rk[r][2] ^ sb[2];
672
673       sb[3] ^= rol(encT[(byte)(sa[3] >> (0 * 8))], (0 * 8));
674       sa[2] ^= rol(encT[(byte)(sa[3] >> (1 * 8))], (1 * 8));
675       sa[1] ^= rol(encT[(byte)(sa[3] >> (2 * 8))], (2 * 8));
676       sa[0] ^= rol(encT[(byte)(sa[3] >> (3 * 8))], (3 * 8));
677       sa[3] = rk[r][3] ^ sb[3];
678
679       r++;
680
681       sb[0] = rol(encT[(byte)(sa[0] >> (0 * 8))], (0 * 8));
682       sb[3] = rol(encT[(byte)(sa[0] >> (1 * 8))], (1 * 8));
683       sb[2] = rol(encT[(byte)(sa[0] >> (2 * 8))], (2 * 8));
684       sb[1] = rol(encT[(byte)(sa[0] >> (3 * 8))], (3 * 8));
685       sa[0] = rk[r][0] ^ sb[0];
686
687       sb[1] ^= rol(encT[(byte)(sa[1] >> (0 * 8))], (0 * 8));
688       sa[0] ^= rol(encT[(byte)(sa[1] >> (1 * 8))], (1 * 8));
689       sb[3] ^= rol(encT[(byte)(sa[1] >> (2 * 8))], (2 * 8));
690       sb[2] ^= rol(encT[(byte)(sa[1] >> (3 * 8))], (3 * 8));
691       sa[1] = rk[r][1] ^ sb[1];
692
693       sb[2] ^= rol(encT[(byte)(sa[2] >> (0 * 8))], (0 * 8));
694       sa[1] ^= rol(encT[(byte)(sa[2] >> (1 * 8))], (1 * 8));
695       sa[0] ^= rol(encT[(byte)(sa[2] >> (2 * 8))], (2 * 8));
696       sb[3] ^= rol(encT[(byte)(sa[2] >> (3 * 8))], (3 * 8));
697       sa[2] = rk[r][2] ^ sb[2];
698
699       sb[3] ^= rol(encT[(byte)(sa[3] >> (0 * 8))], (0 * 8));
700       sa[2] ^= rol(encT[(byte)(sa[3] >> (1 * 8))], (1 * 8));
701       sa[1] ^= rol(encT[(byte)(sa[3] >> (2 * 8))], (2 * 8));
702       sa[0] ^= rol(encT[(byte)(sa[3] >> (3 * 8))], (3 * 8));
703       sa[3] = rk[r][3] ^ sb[3];
704     }
705
706   /* Last round is special. */
707
708   sb[0] = (sbox[(byte)(sa[0] >> (0 * 8)) * 4]) << (0 * 8);
709   sb[3] = (sbox[(byte)(sa[0] >> (1 * 8)) * 4]) << (1 * 8);
710   sb[2] = (sbox[(byte)(sa[0] >> (2 * 8)) * 4]) << (2 * 8);
711   sb[1] = (sbox[(byte)(sa[0] >> (3 * 8)) * 4]) << (3 * 8);
712   sa[0] = rk[r][0] ^ sb[0];
713
714   sb[1] ^= (sbox[(byte)(sa[1] >> (0 * 8)) * 4]) << (0 * 8);
715   sa[0] ^= (sbox[(byte)(sa[1] >> (1 * 8)) * 4]) << (1 * 8);
716   sb[3] ^= (sbox[(byte)(sa[1] >> (2 * 8)) * 4]) << (2 * 8);
717   sb[2] ^= (sbox[(byte)(sa[1] >> (3 * 8)) * 4]) << (3 * 8);
718   sa[1] = rk[r][1] ^ sb[1];
719
720   sb[2] ^= (sbox[(byte)(sa[2] >> (0 * 8)) * 4]) << (0 * 8);
721   sa[1] ^= (sbox[(byte)(sa[2] >> (1 * 8)) * 4]) << (1 * 8);
722   sa[0] ^= (sbox[(byte)(sa[2] >> (2 * 8)) * 4]) << (2 * 8);
723   sb[3] ^= (sbox[(byte)(sa[2] >> (3 * 8)) * 4]) << (3 * 8);
724   sa[2] = rk[r][2] ^ sb[2];
725
726   sb[3] ^= (sbox[(byte)(sa[3] >> (0 * 8)) * 4]) << (0 * 8);
727   sa[2] ^= (sbox[(byte)(sa[3] >> (1 * 8)) * 4]) << (1 * 8);
728   sa[1] ^= (sbox[(byte)(sa[3] >> (2 * 8)) * 4]) << (2 * 8);
729   sa[0] ^= (sbox[(byte)(sa[3] >> (3 * 8)) * 4]) << (3 * 8);
730   sa[3] = rk[r][3] ^ sb[3];
731
732   buf_put_le32(b + 0, sa[0]);
733   buf_put_le32(b + 4, sa[1]);
734   buf_put_le32(b + 8, sa[2]);
735   buf_put_le32(b + 12, sa[3]);
736 #undef rk
737
738   return (56 + 2*sizeof(int));
739 }
740 #endif /*!USE_ARM_ASM && !USE_AMD64_ASM*/
741
742
743 static unsigned int
744 do_encrypt (const RIJNDAEL_context *ctx,
745             unsigned char *bx, const unsigned char *ax)
746 {
747 #ifdef USE_AMD64_ASM
748   return _gcry_aes_amd64_encrypt_block(ctx->keyschenc, bx, ax, ctx->rounds,
749                                        encT);
750 #elif defined(USE_ARM_ASM)
751   return _gcry_aes_arm_encrypt_block(ctx->keyschenc, bx, ax, ctx->rounds, encT);
752 #else
753   return do_encrypt_fn (ctx, bx, ax);
754 #endif /* !USE_ARM_ASM && !USE_AMD64_ASM*/
755 }
756
757
758 static unsigned int
759 rijndael_encrypt (void *context, byte *b, const byte *a)
760 {
761   RIJNDAEL_context *ctx = context;
762
763   if (ctx->prefetch_enc_fn)
764     ctx->prefetch_enc_fn();
765
766   return ctx->encrypt_fn (ctx, b, a);
767 }
768
769
770 /* Bulk encryption of complete blocks in CFB mode.  Caller needs to
771    make sure that IV is aligned on an unsigned long boundary.  This
772    function is only intended for the bulk encryption feature of
773    cipher.c. */
774 void
775 _gcry_aes_cfb_enc (void *context, unsigned char *iv,
776                    void *outbuf_arg, const void *inbuf_arg,
777                    size_t nblocks)
778 {
779   RIJNDAEL_context *ctx = context;
780   unsigned char *outbuf = outbuf_arg;
781   const unsigned char *inbuf = inbuf_arg;
782   unsigned int burn_depth = 0;
783
784   if (ctx->prefetch_enc_fn)
785     ctx->prefetch_enc_fn();
786
787   if (0)
788     ;
789 #ifdef USE_AESNI
790   else if (ctx->use_aesni)
791     {
792       _gcry_aes_aesni_cfb_enc (ctx, outbuf, inbuf, iv, nblocks);
793       burn_depth = 0;
794     }
795 #endif /*USE_AESNI*/
796 #ifdef USE_SSSE3
797   else if (ctx->use_ssse3)
798     {
799       _gcry_aes_ssse3_cfb_enc (ctx, outbuf, inbuf, iv, nblocks);
800       burn_depth = 0;
801     }
802 #endif /*USE_SSSE3*/
803 #ifdef USE_ARM_CE
804   else if (ctx->use_arm_ce)
805     {
806       _gcry_aes_armv8_ce_cfb_enc (ctx, outbuf, inbuf, iv, nblocks);
807       burn_depth = 0;
808     }
809 #endif /*USE_ARM_CE*/
810   else
811     {
812       rijndael_cryptfn_t encrypt_fn = ctx->encrypt_fn;
813
814       for ( ;nblocks; nblocks-- )
815         {
816           /* Encrypt the IV. */
817           burn_depth = encrypt_fn (ctx, iv, iv);
818           /* XOR the input with the IV and store input into IV.  */
819           buf_xor_2dst(outbuf, iv, inbuf, BLOCKSIZE);
820           outbuf += BLOCKSIZE;
821           inbuf  += BLOCKSIZE;
822         }
823     }
824
825   if (burn_depth)
826     _gcry_burn_stack (burn_depth + 4 * sizeof(void *));
827 }
828
829
830 /* Bulk encryption of complete blocks in CBC mode.  Caller needs to
831    make sure that IV is aligned on an unsigned long boundary.  This
832    function is only intended for the bulk encryption feature of
833    cipher.c. */
834 void
835 _gcry_aes_cbc_enc (void *context, unsigned char *iv,
836                    void *outbuf_arg, const void *inbuf_arg,
837                    size_t nblocks, int cbc_mac)
838 {
839   RIJNDAEL_context *ctx = context;
840   unsigned char *outbuf = outbuf_arg;
841   const unsigned char *inbuf = inbuf_arg;
842   unsigned char *last_iv;
843   unsigned int burn_depth = 0;
844
845   if (ctx->prefetch_enc_fn)
846     ctx->prefetch_enc_fn();
847
848   if (0)
849     ;
850 #ifdef USE_AESNI
851   else if (ctx->use_aesni)
852     {
853       _gcry_aes_aesni_cbc_enc (ctx, outbuf, inbuf, iv, nblocks, cbc_mac);
854       burn_depth = 0;
855     }
856 #endif /*USE_AESNI*/
857 #ifdef USE_SSSE3
858   else if (ctx->use_ssse3)
859     {
860       _gcry_aes_ssse3_cbc_enc (ctx, outbuf, inbuf, iv, nblocks, cbc_mac);
861       burn_depth = 0;
862     }
863 #endif /*USE_SSSE3*/
864 #ifdef USE_ARM_CE
865   else if (ctx->use_arm_ce)
866     {
867       _gcry_aes_armv8_ce_cbc_enc (ctx, outbuf, inbuf, iv, nblocks, cbc_mac);
868       burn_depth = 0;
869     }
870 #endif /*USE_ARM_CE*/
871   else
872     {
873       rijndael_cryptfn_t encrypt_fn = ctx->encrypt_fn;
874
875       last_iv = iv;
876
877       for ( ;nblocks; nblocks-- )
878         {
879           buf_xor(outbuf, inbuf, last_iv, BLOCKSIZE);
880
881           burn_depth = encrypt_fn (ctx, outbuf, outbuf);
882
883           last_iv = outbuf;
884           inbuf += BLOCKSIZE;
885           if (!cbc_mac)
886             outbuf += BLOCKSIZE;
887         }
888
889       if (last_iv != iv)
890         buf_cpy (iv, last_iv, BLOCKSIZE);
891     }
892
893   if (burn_depth)
894     _gcry_burn_stack (burn_depth + 4 * sizeof(void *));
895 }
896
897
898 /* Bulk encryption of complete blocks in CTR mode.  Caller needs to
899    make sure that CTR is aligned on a 16 byte boundary if AESNI; the
900    minimum alignment is for an u32.  This function is only intended
901    for the bulk encryption feature of cipher.c.  CTR is expected to be
902    of size BLOCKSIZE. */
903 void
904 _gcry_aes_ctr_enc (void *context, unsigned char *ctr,
905                    void *outbuf_arg, const void *inbuf_arg,
906                    size_t nblocks)
907 {
908   RIJNDAEL_context *ctx = context;
909   unsigned char *outbuf = outbuf_arg;
910   const unsigned char *inbuf = inbuf_arg;
911   unsigned int burn_depth = 0;
912   int i;
913
914   if (ctx->prefetch_enc_fn)
915     ctx->prefetch_enc_fn();
916
917   if (0)
918     ;
919 #ifdef USE_AESNI
920   else if (ctx->use_aesni)
921     {
922       _gcry_aes_aesni_ctr_enc (ctx, outbuf, inbuf, ctr, nblocks);
923       burn_depth = 0;
924     }
925 #endif /*USE_AESNI*/
926 #ifdef USE_SSSE3
927   else if (ctx->use_ssse3)
928     {
929       _gcry_aes_ssse3_ctr_enc (ctx, outbuf, inbuf, ctr, nblocks);
930       burn_depth = 0;
931     }
932 #endif /*USE_SSSE3*/
933 #ifdef USE_ARM_CE
934   else if (ctx->use_arm_ce)
935     {
936       _gcry_aes_armv8_ce_ctr_enc (ctx, outbuf, inbuf, ctr, nblocks);
937       burn_depth = 0;
938     }
939 #endif /*USE_ARM_CE*/
940   else
941     {
942       union { unsigned char x1[16] ATTR_ALIGNED_16; u32 x32[4]; } tmp;
943       rijndael_cryptfn_t encrypt_fn = ctx->encrypt_fn;
944
945       for ( ;nblocks; nblocks-- )
946         {
947           /* Encrypt the counter. */
948           burn_depth = encrypt_fn (ctx, tmp.x1, ctr);
949           /* XOR the input with the encrypted counter and store in output.  */
950           buf_xor(outbuf, tmp.x1, inbuf, BLOCKSIZE);
951           outbuf += BLOCKSIZE;
952           inbuf  += BLOCKSIZE;
953           /* Increment the counter.  */
954           for (i = BLOCKSIZE; i > 0; i--)
955             {
956               ctr[i-1]++;
957               if (ctr[i-1])
958                 break;
959             }
960         }
961
962       wipememory(&tmp, sizeof(tmp));
963     }
964
965   if (burn_depth)
966     _gcry_burn_stack (burn_depth + 4 * sizeof(void *));
967 }
968
969
970 \f
971 #if !defined(USE_ARM_ASM) && !defined(USE_AMD64_ASM)
972 /* Decrypt one block.  A and B may be the same. */
973 static unsigned int
974 do_decrypt_fn (const RIJNDAEL_context *ctx, unsigned char *b,
975                const unsigned char *a)
976 {
977 #define rk (ctx->keyschdec32)
978   int rounds = ctx->rounds;
979   int r;
980   u32 sa[4];
981   u32 sb[4];
982
983   sb[0] = buf_get_le32(a + 0);
984   sb[1] = buf_get_le32(a + 4);
985   sb[2] = buf_get_le32(a + 8);
986   sb[3] = buf_get_le32(a + 12);
987
988   sa[0] = sb[0] ^ rk[rounds][0];
989   sa[1] = sb[1] ^ rk[rounds][1];
990   sa[2] = sb[2] ^ rk[rounds][2];
991   sa[3] = sb[3] ^ rk[rounds][3];
992
993   for (r = rounds - 1; r > 1; r--)
994     {
995       sb[0] = rol(decT[(byte)(sa[0] >> (0 * 8))], (0 * 8));
996       sb[1] = rol(decT[(byte)(sa[0] >> (1 * 8))], (1 * 8));
997       sb[2] = rol(decT[(byte)(sa[0] >> (2 * 8))], (2 * 8));
998       sb[3] = rol(decT[(byte)(sa[0] >> (3 * 8))], (3 * 8));
999       sa[0] = rk[r][0] ^ sb[0];
1000
1001       sb[1] ^= rol(decT[(byte)(sa[1] >> (0 * 8))], (0 * 8));
1002       sb[2] ^= rol(decT[(byte)(sa[1] >> (1 * 8))], (1 * 8));
1003       sb[3] ^= rol(decT[(byte)(sa[1] >> (2 * 8))], (2 * 8));
1004       sa[0] ^= rol(decT[(byte)(sa[1] >> (3 * 8))], (3 * 8));
1005       sa[1] = rk[r][1] ^ sb[1];
1006
1007       sb[2] ^= rol(decT[(byte)(sa[2] >> (0 * 8))], (0 * 8));
1008       sb[3] ^= rol(decT[(byte)(sa[2] >> (1 * 8))], (1 * 8));
1009       sa[0] ^= rol(decT[(byte)(sa[2] >> (2 * 8))], (2 * 8));
1010       sa[1] ^= rol(decT[(byte)(sa[2] >> (3 * 8))], (3 * 8));
1011       sa[2] = rk[r][2] ^ sb[2];
1012
1013       sb[3] ^= rol(decT[(byte)(sa[3] >> (0 * 8))], (0 * 8));
1014       sa[0] ^= rol(decT[(byte)(sa[3] >> (1 * 8))], (1 * 8));
1015       sa[1] ^= rol(decT[(byte)(sa[3] >> (2 * 8))], (2 * 8));
1016       sa[2] ^= rol(decT[(byte)(sa[3] >> (3 * 8))], (3 * 8));
1017       sa[3] = rk[r][3] ^ sb[3];
1018
1019       r--;
1020
1021       sb[0] = rol(decT[(byte)(sa[0] >> (0 * 8))], (0 * 8));
1022       sb[1] = rol(decT[(byte)(sa[0] >> (1 * 8))], (1 * 8));
1023       sb[2] = rol(decT[(byte)(sa[0] >> (2 * 8))], (2 * 8));
1024       sb[3] = rol(decT[(byte)(sa[0] >> (3 * 8))], (3 * 8));
1025       sa[0] = rk[r][0] ^ sb[0];
1026
1027       sb[1] ^= rol(decT[(byte)(sa[1] >> (0 * 8))], (0 * 8));
1028       sb[2] ^= rol(decT[(byte)(sa[1] >> (1 * 8))], (1 * 8));
1029       sb[3] ^= rol(decT[(byte)(sa[1] >> (2 * 8))], (2 * 8));
1030       sa[0] ^= rol(decT[(byte)(sa[1] >> (3 * 8))], (3 * 8));
1031       sa[1] = rk[r][1] ^ sb[1];
1032
1033       sb[2] ^= rol(decT[(byte)(sa[2] >> (0 * 8))], (0 * 8));
1034       sb[3] ^= rol(decT[(byte)(sa[2] >> (1 * 8))], (1 * 8));
1035       sa[0] ^= rol(decT[(byte)(sa[2] >> (2 * 8))], (2 * 8));
1036       sa[1] ^= rol(decT[(byte)(sa[2] >> (3 * 8))], (3 * 8));
1037       sa[2] = rk[r][2] ^ sb[2];
1038
1039       sb[3] ^= rol(decT[(byte)(sa[3] >> (0 * 8))], (0 * 8));
1040       sa[0] ^= rol(decT[(byte)(sa[3] >> (1 * 8))], (1 * 8));
1041       sa[1] ^= rol(decT[(byte)(sa[3] >> (2 * 8))], (2 * 8));
1042       sa[2] ^= rol(decT[(byte)(sa[3] >> (3 * 8))], (3 * 8));
1043       sa[3] = rk[r][3] ^ sb[3];
1044     }
1045
1046   sb[0] = rol(decT[(byte)(sa[0] >> (0 * 8))], (0 * 8));
1047   sb[1] = rol(decT[(byte)(sa[0] >> (1 * 8))], (1 * 8));
1048   sb[2] = rol(decT[(byte)(sa[0] >> (2 * 8))], (2 * 8));
1049   sb[3] = rol(decT[(byte)(sa[0] >> (3 * 8))], (3 * 8));
1050   sa[0] = rk[1][0] ^ sb[0];
1051
1052   sb[1] ^= rol(decT[(byte)(sa[1] >> (0 * 8))], (0 * 8));
1053   sb[2] ^= rol(decT[(byte)(sa[1] >> (1 * 8))], (1 * 8));
1054   sb[3] ^= rol(decT[(byte)(sa[1] >> (2 * 8))], (2 * 8));
1055   sa[0] ^= rol(decT[(byte)(sa[1] >> (3 * 8))], (3 * 8));
1056   sa[1] = rk[1][1] ^ sb[1];
1057
1058   sb[2] ^= rol(decT[(byte)(sa[2] >> (0 * 8))], (0 * 8));
1059   sb[3] ^= rol(decT[(byte)(sa[2] >> (1 * 8))], (1 * 8));
1060   sa[0] ^= rol(decT[(byte)(sa[2] >> (2 * 8))], (2 * 8));
1061   sa[1] ^= rol(decT[(byte)(sa[2] >> (3 * 8))], (3 * 8));
1062   sa[2] = rk[1][2] ^ sb[2];
1063
1064   sb[3] ^= rol(decT[(byte)(sa[3] >> (0 * 8))], (0 * 8));
1065   sa[0] ^= rol(decT[(byte)(sa[3] >> (1 * 8))], (1 * 8));
1066   sa[1] ^= rol(decT[(byte)(sa[3] >> (2 * 8))], (2 * 8));
1067   sa[2] ^= rol(decT[(byte)(sa[3] >> (3 * 8))], (3 * 8));
1068   sa[3] = rk[1][3] ^ sb[3];
1069
1070   /* Last round is special. */
1071   sb[0] = inv_sbox[(byte)(sa[0] >> (0 * 8))] << (0 * 8);
1072   sb[1] = inv_sbox[(byte)(sa[0] >> (1 * 8))] << (1 * 8);
1073   sb[2] = inv_sbox[(byte)(sa[0] >> (2 * 8))] << (2 * 8);
1074   sb[3] = inv_sbox[(byte)(sa[0] >> (3 * 8))] << (3 * 8);
1075   sa[0] = sb[0] ^ rk[0][0];
1076
1077   sb[1] ^= inv_sbox[(byte)(sa[1] >> (0 * 8))] << (0 * 8);
1078   sb[2] ^= inv_sbox[(byte)(sa[1] >> (1 * 8))] << (1 * 8);
1079   sb[3] ^= inv_sbox[(byte)(sa[1] >> (2 * 8))] << (2 * 8);
1080   sa[0] ^= inv_sbox[(byte)(sa[1] >> (3 * 8))] << (3 * 8);
1081   sa[1] = sb[1] ^ rk[0][1];
1082
1083   sb[2] ^= inv_sbox[(byte)(sa[2] >> (0 * 8))] << (0 * 8);
1084   sb[3] ^= inv_sbox[(byte)(sa[2] >> (1 * 8))] << (1 * 8);
1085   sa[0] ^= inv_sbox[(byte)(sa[2] >> (2 * 8))] << (2 * 8);
1086   sa[1] ^= inv_sbox[(byte)(sa[2] >> (3 * 8))] << (3 * 8);
1087   sa[2] = sb[2] ^ rk[0][2];
1088
1089   sb[3] ^= inv_sbox[(byte)(sa[3] >> (0 * 8))] << (0 * 8);
1090   sa[0] ^= inv_sbox[(byte)(sa[3] >> (1 * 8))] << (1 * 8);
1091   sa[1] ^= inv_sbox[(byte)(sa[3] >> (2 * 8))] << (2 * 8);
1092   sa[2] ^= inv_sbox[(byte)(sa[3] >> (3 * 8))] << (3 * 8);
1093   sa[3] = sb[3] ^ rk[0][3];
1094
1095   buf_put_le32(b + 0, sa[0]);
1096   buf_put_le32(b + 4, sa[1]);
1097   buf_put_le32(b + 8, sa[2]);
1098   buf_put_le32(b + 12, sa[3]);
1099 #undef rk
1100
1101   return (56+2*sizeof(int));
1102 }
1103 #endif /*!USE_ARM_ASM && !USE_AMD64_ASM*/
1104
1105
1106 /* Decrypt one block.  AX and BX may be the same. */
1107 static unsigned int
1108 do_decrypt (const RIJNDAEL_context *ctx, unsigned char *bx,
1109             const unsigned char *ax)
1110 {
1111 #ifdef USE_AMD64_ASM
1112   return _gcry_aes_amd64_decrypt_block(ctx->keyschdec, bx, ax, ctx->rounds,
1113                                        &dec_tables);
1114 #elif defined(USE_ARM_ASM)
1115   return _gcry_aes_arm_decrypt_block(ctx->keyschdec, bx, ax, ctx->rounds,
1116                                      &dec_tables);
1117 #else
1118   return do_decrypt_fn (ctx, bx, ax);
1119 #endif /*!USE_ARM_ASM && !USE_AMD64_ASM*/
1120 }
1121
1122
1123 static inline void
1124 check_decryption_preparation (RIJNDAEL_context *ctx)
1125 {
1126   if ( !ctx->decryption_prepared )
1127     {
1128       prepare_decryption ( ctx );
1129       ctx->decryption_prepared = 1;
1130     }
1131 }
1132
1133
1134 static unsigned int
1135 rijndael_decrypt (void *context, byte *b, const byte *a)
1136 {
1137   RIJNDAEL_context *ctx = context;
1138
1139   check_decryption_preparation (ctx);
1140
1141   if (ctx->prefetch_dec_fn)
1142     ctx->prefetch_dec_fn();
1143
1144   return ctx->decrypt_fn (ctx, b, a);
1145 }
1146
1147
1148 /* Bulk decryption of complete blocks in CFB mode.  Caller needs to
1149    make sure that IV is aligned on an unsigned long boundary.  This
1150    function is only intended for the bulk encryption feature of
1151    cipher.c. */
1152 void
1153 _gcry_aes_cfb_dec (void *context, unsigned char *iv,
1154                    void *outbuf_arg, const void *inbuf_arg,
1155                    size_t nblocks)
1156 {
1157   RIJNDAEL_context *ctx = context;
1158   unsigned char *outbuf = outbuf_arg;
1159   const unsigned char *inbuf = inbuf_arg;
1160   unsigned int burn_depth = 0;
1161
1162   if (ctx->prefetch_enc_fn)
1163     ctx->prefetch_enc_fn();
1164
1165   if (0)
1166     ;
1167 #ifdef USE_AESNI
1168   else if (ctx->use_aesni)
1169     {
1170       _gcry_aes_aesni_cfb_dec (ctx, outbuf, inbuf, iv, nblocks);
1171       burn_depth = 0;
1172     }
1173 #endif /*USE_AESNI*/
1174 #ifdef USE_SSSE3
1175   else if (ctx->use_ssse3)
1176     {
1177       _gcry_aes_ssse3_cfb_dec (ctx, outbuf, inbuf, iv, nblocks);
1178       burn_depth = 0;
1179     }
1180 #endif /*USE_SSSE3*/
1181 #ifdef USE_ARM_CE
1182   else if (ctx->use_arm_ce)
1183     {
1184       _gcry_aes_armv8_ce_cfb_dec (ctx, outbuf, inbuf, iv, nblocks);
1185       burn_depth = 0;
1186     }
1187 #endif /*USE_ARM_CE*/
1188   else
1189     {
1190       rijndael_cryptfn_t encrypt_fn = ctx->encrypt_fn;
1191
1192       for ( ;nblocks; nblocks-- )
1193         {
1194           burn_depth = encrypt_fn (ctx, iv, iv);
1195           buf_xor_n_copy(outbuf, iv, inbuf, BLOCKSIZE);
1196           outbuf += BLOCKSIZE;
1197           inbuf  += BLOCKSIZE;
1198         }
1199     }
1200
1201   if (burn_depth)
1202     _gcry_burn_stack (burn_depth + 4 * sizeof(void *));
1203 }
1204
1205
1206 /* Bulk decryption of complete blocks in CBC mode.  Caller needs to
1207    make sure that IV is aligned on an unsigned long boundary.  This
1208    function is only intended for the bulk encryption feature of
1209    cipher.c. */
1210 void
1211 _gcry_aes_cbc_dec (void *context, unsigned char *iv,
1212                    void *outbuf_arg, const void *inbuf_arg,
1213                    size_t nblocks)
1214 {
1215   RIJNDAEL_context *ctx = context;
1216   unsigned char *outbuf = outbuf_arg;
1217   const unsigned char *inbuf = inbuf_arg;
1218   unsigned int burn_depth = 0;
1219
1220   check_decryption_preparation (ctx);
1221
1222   if (ctx->prefetch_dec_fn)
1223     ctx->prefetch_dec_fn();
1224
1225   if (0)
1226     ;
1227 #ifdef USE_AESNI
1228   else if (ctx->use_aesni)
1229     {
1230       _gcry_aes_aesni_cbc_dec (ctx, outbuf, inbuf, iv, nblocks);
1231       burn_depth = 0;
1232     }
1233 #endif /*USE_AESNI*/
1234 #ifdef USE_SSSE3
1235   else if (ctx->use_ssse3)
1236     {
1237       _gcry_aes_ssse3_cbc_dec (ctx, outbuf, inbuf, iv, nblocks);
1238       burn_depth = 0;
1239     }
1240 #endif /*USE_SSSE3*/
1241 #ifdef USE_ARM_CE
1242   else if (ctx->use_arm_ce)
1243     {
1244       _gcry_aes_armv8_ce_cbc_dec (ctx, outbuf, inbuf, iv, nblocks);
1245       burn_depth = 0;
1246     }
1247 #endif /*USE_ARM_CE*/
1248   else
1249     {
1250       unsigned char savebuf[BLOCKSIZE] ATTR_ALIGNED_16;
1251       rijndael_cryptfn_t decrypt_fn = ctx->decrypt_fn;
1252
1253       for ( ;nblocks; nblocks-- )
1254         {
1255           /* INBUF is needed later and it may be identical to OUTBUF, so store
1256              the intermediate result to SAVEBUF.  */
1257
1258           burn_depth = decrypt_fn (ctx, savebuf, inbuf);
1259
1260           buf_xor_n_copy_2(outbuf, savebuf, iv, inbuf, BLOCKSIZE);
1261           inbuf += BLOCKSIZE;
1262           outbuf += BLOCKSIZE;
1263         }
1264
1265       wipememory(savebuf, sizeof(savebuf));
1266     }
1267
1268   if (burn_depth)
1269     _gcry_burn_stack (burn_depth + 4 * sizeof(void *));
1270 }
1271
1272
1273 \f
1274 /* Bulk encryption/decryption of complete blocks in OCB mode. */
1275 size_t
1276 _gcry_aes_ocb_crypt (gcry_cipher_hd_t c, void *outbuf_arg,
1277                      const void *inbuf_arg, size_t nblocks, int encrypt)
1278 {
1279   RIJNDAEL_context *ctx = (void *)&c->context.c;
1280   unsigned char *outbuf = outbuf_arg;
1281   const unsigned char *inbuf = inbuf_arg;
1282   unsigned int burn_depth = 0;
1283
1284   if (encrypt)
1285     {
1286       if (ctx->prefetch_enc_fn)
1287         ctx->prefetch_enc_fn();
1288     }
1289   else
1290     {
1291       check_decryption_preparation (ctx);
1292
1293       if (ctx->prefetch_dec_fn)
1294         ctx->prefetch_dec_fn();
1295     }
1296
1297   if (0)
1298     ;
1299 #ifdef USE_AESNI
1300   else if (ctx->use_aesni)
1301     {
1302       _gcry_aes_aesni_ocb_crypt (c, outbuf, inbuf, nblocks, encrypt);
1303       burn_depth = 0;
1304     }
1305 #endif /*USE_AESNI*/
1306 #ifdef USE_SSSE3
1307   else if (ctx->use_ssse3)
1308     {
1309       _gcry_aes_ssse3_ocb_crypt (c, outbuf, inbuf, nblocks, encrypt);
1310       burn_depth = 0;
1311     }
1312 #endif /*USE_SSSE3*/
1313 #ifdef USE_ARM_CE
1314   else if (ctx->use_arm_ce)
1315     {
1316       _gcry_aes_armv8_ce_ocb_crypt (c, outbuf, inbuf, nblocks, encrypt);
1317       burn_depth = 0;
1318     }
1319 #endif /*USE_ARM_CE*/
1320   else if (encrypt)
1321     {
1322       union { unsigned char x1[16] ATTR_ALIGNED_16; u32 x32[4]; } l_tmp;
1323       rijndael_cryptfn_t encrypt_fn = ctx->encrypt_fn;
1324
1325       for ( ;nblocks; nblocks-- )
1326         {
1327           u64 i = ++c->u_mode.ocb.data_nblocks;
1328           const unsigned char *l = ocb_get_l(c, i);
1329
1330           /* Offset_i = Offset_{i-1} xor L_{ntz(i)} */
1331           buf_xor_1 (c->u_iv.iv, l, BLOCKSIZE);
1332           buf_cpy (l_tmp.x1, inbuf, BLOCKSIZE);
1333           /* Checksum_i = Checksum_{i-1} xor P_i  */
1334           buf_xor_1 (c->u_ctr.ctr, l_tmp.x1, BLOCKSIZE);
1335           /* C_i = Offset_i xor ENCIPHER(K, P_i xor Offset_i)  */
1336           buf_xor_1 (l_tmp.x1, c->u_iv.iv, BLOCKSIZE);
1337           burn_depth = encrypt_fn (ctx, l_tmp.x1, l_tmp.x1);
1338           buf_xor_1 (l_tmp.x1, c->u_iv.iv, BLOCKSIZE);
1339           buf_cpy (outbuf, l_tmp.x1, BLOCKSIZE);
1340
1341           inbuf += BLOCKSIZE;
1342           outbuf += BLOCKSIZE;
1343         }
1344     }
1345   else
1346     {
1347       union { unsigned char x1[16] ATTR_ALIGNED_16; u32 x32[4]; } l_tmp;
1348       rijndael_cryptfn_t decrypt_fn = ctx->decrypt_fn;
1349
1350       for ( ;nblocks; nblocks-- )
1351         {
1352           u64 i = ++c->u_mode.ocb.data_nblocks;
1353           const unsigned char *l = ocb_get_l(c, i);
1354
1355           /* Offset_i = Offset_{i-1} xor L_{ntz(i)} */
1356           buf_xor_1 (c->u_iv.iv, l, BLOCKSIZE);
1357           buf_cpy (l_tmp.x1, inbuf, BLOCKSIZE);
1358           /* C_i = Offset_i xor ENCIPHER(K, P_i xor Offset_i)  */
1359           buf_xor_1 (l_tmp.x1, c->u_iv.iv, BLOCKSIZE);
1360           burn_depth = decrypt_fn (ctx, l_tmp.x1, l_tmp.x1);
1361           buf_xor_1 (l_tmp.x1, c->u_iv.iv, BLOCKSIZE);
1362           /* Checksum_i = Checksum_{i-1} xor P_i  */
1363           buf_xor_1 (c->u_ctr.ctr, l_tmp.x1, BLOCKSIZE);
1364           buf_cpy (outbuf, l_tmp.x1, BLOCKSIZE);
1365
1366           inbuf += BLOCKSIZE;
1367           outbuf += BLOCKSIZE;
1368         }
1369     }
1370
1371   if (burn_depth)
1372     _gcry_burn_stack (burn_depth + 4 * sizeof(void *));
1373
1374   return 0;
1375 }
1376
1377
1378 /* Bulk authentication of complete blocks in OCB mode. */
1379 size_t
1380 _gcry_aes_ocb_auth (gcry_cipher_hd_t c, const void *abuf_arg, size_t nblocks)
1381 {
1382   RIJNDAEL_context *ctx = (void *)&c->context.c;
1383   const unsigned char *abuf = abuf_arg;
1384   unsigned int burn_depth = 0;
1385
1386   if (ctx->prefetch_enc_fn)
1387     ctx->prefetch_enc_fn();
1388
1389   if (0)
1390     ;
1391 #ifdef USE_AESNI
1392   else if (ctx->use_aesni)
1393     {
1394       _gcry_aes_aesni_ocb_auth (c, abuf, nblocks);
1395       burn_depth = 0;
1396     }
1397 #endif /*USE_AESNI*/
1398 #ifdef USE_SSSE3
1399   else if (ctx->use_ssse3)
1400     {
1401       _gcry_aes_ssse3_ocb_auth (c, abuf, nblocks);
1402       burn_depth = 0;
1403     }
1404 #endif /*USE_SSSE3*/
1405 #ifdef USE_ARM_CE
1406   else if (ctx->use_arm_ce)
1407     {
1408       _gcry_aes_armv8_ce_ocb_auth (c, abuf, nblocks);
1409       burn_depth = 0;
1410     }
1411 #endif /*USE_ARM_CE*/
1412   else
1413     {
1414       union { unsigned char x1[16] ATTR_ALIGNED_16; u32 x32[4]; } l_tmp;
1415       rijndael_cryptfn_t encrypt_fn = ctx->encrypt_fn;
1416
1417       for ( ;nblocks; nblocks-- )
1418         {
1419           u64 i = ++c->u_mode.ocb.aad_nblocks;
1420           const unsigned char *l = ocb_get_l(c, i);
1421
1422           /* Offset_i = Offset_{i-1} xor L_{ntz(i)} */
1423           buf_xor_1 (c->u_mode.ocb.aad_offset, l, BLOCKSIZE);
1424           /* Sum_i = Sum_{i-1} xor ENCIPHER(K, A_i xor Offset_i)  */
1425           buf_xor (l_tmp.x1, c->u_mode.ocb.aad_offset, abuf, BLOCKSIZE);
1426           burn_depth = encrypt_fn (ctx, l_tmp.x1, l_tmp.x1);
1427           buf_xor_1 (c->u_mode.ocb.aad_sum, l_tmp.x1, BLOCKSIZE);
1428
1429           abuf += BLOCKSIZE;
1430         }
1431
1432       wipememory(&l_tmp, sizeof(l_tmp));
1433     }
1434
1435   if (burn_depth)
1436     _gcry_burn_stack (burn_depth + 4 * sizeof(void *));
1437
1438   return 0;
1439 }
1440
1441
1442 /* Bulk encryption/decryption of complete blocks in XTS mode. */
1443 void
1444 _gcry_aes_xts_crypt (void *context, unsigned char *tweak,
1445                      void *outbuf_arg, const void *inbuf_arg,
1446                      size_t nblocks, int encrypt)
1447 {
1448   RIJNDAEL_context *ctx = context;
1449   unsigned char *outbuf = outbuf_arg;
1450   const unsigned char *inbuf = inbuf_arg;
1451   unsigned int burn_depth = 0;
1452   rijndael_cryptfn_t crypt_fn;
1453   u64 tweak_lo, tweak_hi, tweak_next_lo, tweak_next_hi, tmp_lo, tmp_hi, carry;
1454
1455   if (encrypt)
1456     {
1457       if (ctx->prefetch_enc_fn)
1458         ctx->prefetch_enc_fn();
1459
1460       crypt_fn = ctx->encrypt_fn;
1461     }
1462   else
1463     {
1464       check_decryption_preparation (ctx);
1465
1466       if (ctx->prefetch_dec_fn)
1467         ctx->prefetch_dec_fn();
1468
1469       crypt_fn = ctx->decrypt_fn;
1470     }
1471
1472   if (0)
1473     ;
1474 #ifdef USE_AESNI
1475   else if (ctx->use_aesni)
1476     {
1477       _gcry_aes_aesni_xts_crypt (ctx, tweak, outbuf, inbuf, nblocks, encrypt);
1478       burn_depth = 0;
1479     }
1480 #endif /*USE_AESNI*/
1481 #ifdef USE_ARM_CE
1482   else if (ctx->use_arm_ce)
1483     {
1484       _gcry_aes_armv8_ce_xts_crypt (ctx, tweak, outbuf, inbuf, nblocks, encrypt);
1485       burn_depth = 0;
1486     }
1487 #endif /*USE_ARM_CE*/
1488   else
1489     {
1490       tweak_next_lo = buf_get_le64 (tweak + 0);
1491       tweak_next_hi = buf_get_le64 (tweak + 8);
1492
1493       while (nblocks)
1494         {
1495           tweak_lo = tweak_next_lo;
1496           tweak_hi = tweak_next_hi;
1497
1498           /* Xor-Encrypt/Decrypt-Xor block. */
1499           tmp_lo = buf_get_le64 (inbuf + 0) ^ tweak_lo;
1500           tmp_hi = buf_get_le64 (inbuf + 8) ^ tweak_hi;
1501
1502           buf_put_le64 (outbuf + 0, tmp_lo);
1503           buf_put_le64 (outbuf + 8, tmp_hi);
1504
1505           /* Generate next tweak. */
1506           carry = -(tweak_next_hi >> 63) & 0x87;
1507           tweak_next_hi = (tweak_next_hi << 1) + (tweak_next_lo >> 63);
1508           tweak_next_lo = (tweak_next_lo << 1) ^ carry;
1509
1510           burn_depth = crypt_fn (ctx, outbuf, outbuf);
1511
1512           buf_put_le64 (outbuf + 0, buf_get_le64 (outbuf + 0) ^ tweak_lo);
1513           buf_put_le64 (outbuf + 8, buf_get_le64 (outbuf + 8) ^ tweak_hi);
1514
1515           outbuf += GCRY_XTS_BLOCK_LEN;
1516           inbuf += GCRY_XTS_BLOCK_LEN;
1517           nblocks--;
1518         }
1519
1520       buf_put_le64 (tweak + 0, tweak_next_lo);
1521       buf_put_le64 (tweak + 8, tweak_next_hi);
1522     }
1523
1524   if (burn_depth)
1525     _gcry_burn_stack (burn_depth + 5 * sizeof(void *));
1526 }
1527
1528 \f
1529 /* Run the self-tests for AES 128.  Returns NULL on success. */
1530 static const char*
1531 selftest_basic_128 (void)
1532 {
1533   RIJNDAEL_context *ctx;
1534   unsigned char *ctxmem;
1535   unsigned char scratch[16];
1536
1537   /* The test vectors are from the AES supplied ones; more or less
1538      randomly taken from ecb_tbl.txt (I=42,81,14) */
1539 #if 1
1540   static const unsigned char plaintext_128[16] =
1541     {
1542       0x01,0x4B,0xAF,0x22,0x78,0xA6,0x9D,0x33,
1543       0x1D,0x51,0x80,0x10,0x36,0x43,0xE9,0x9A
1544     };
1545   static const unsigned char key_128[16] =
1546     {
1547       0xE8,0xE9,0xEA,0xEB,0xED,0xEE,0xEF,0xF0,
1548       0xF2,0xF3,0xF4,0xF5,0xF7,0xF8,0xF9,0xFA
1549     };
1550   static const unsigned char ciphertext_128[16] =
1551     {
1552       0x67,0x43,0xC3,0xD1,0x51,0x9A,0xB4,0xF2,
1553       0xCD,0x9A,0x78,0xAB,0x09,0xA5,0x11,0xBD
1554     };
1555 #else
1556   /* Test vectors from fips-197, appendix C. */
1557 # warning debug test vectors in use
1558   static const unsigned char plaintext_128[16] =
1559     {
1560       0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,
1561       0x88,0x99,0xaa,0xbb,0xcc,0xdd,0xee,0xff
1562     };
1563   static const unsigned char key_128[16] =
1564     {
1565       0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
1566       0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f
1567       /* 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, */
1568       /* 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c */
1569     };
1570   static const unsigned char ciphertext_128[16] =
1571     {
1572       0x69,0xc4,0xe0,0xd8,0x6a,0x7b,0x04,0x30,
1573       0xd8,0xcd,0xb7,0x80,0x70,0xb4,0xc5,0x5a
1574     };
1575 #endif
1576
1577   /* Because gcc/ld can only align the CTX struct on 8 bytes on the
1578      stack, we need to allocate that context on the heap.  */
1579   ctx = _gcry_cipher_selftest_alloc_ctx (sizeof *ctx, &ctxmem);
1580   if (!ctx)
1581     return "failed to allocate memory";
1582
1583   rijndael_setkey (ctx, key_128, sizeof (key_128));
1584   rijndael_encrypt (ctx, scratch, plaintext_128);
1585   if (memcmp (scratch, ciphertext_128, sizeof (ciphertext_128)))
1586     {
1587       xfree (ctxmem);
1588       return "AES-128 test encryption failed.";
1589     }
1590   rijndael_decrypt (ctx, scratch, scratch);
1591   xfree (ctxmem);
1592   if (memcmp (scratch, plaintext_128, sizeof (plaintext_128)))
1593     return "AES-128 test decryption failed.";
1594
1595   return NULL;
1596 }
1597
1598 /* Run the self-tests for AES 192.  Returns NULL on success. */
1599 static const char*
1600 selftest_basic_192 (void)
1601 {
1602   RIJNDAEL_context *ctx;
1603   unsigned char *ctxmem;
1604   unsigned char scratch[16];
1605
1606   static unsigned char plaintext_192[16] =
1607     {
1608       0x76,0x77,0x74,0x75,0xF1,0xF2,0xF3,0xF4,
1609       0xF8,0xF9,0xE6,0xE7,0x77,0x70,0x71,0x72
1610     };
1611   static unsigned char key_192[24] =
1612     {
1613       0x04,0x05,0x06,0x07,0x09,0x0A,0x0B,0x0C,
1614       0x0E,0x0F,0x10,0x11,0x13,0x14,0x15,0x16,
1615       0x18,0x19,0x1A,0x1B,0x1D,0x1E,0x1F,0x20
1616     };
1617   static const unsigned char ciphertext_192[16] =
1618     {
1619       0x5D,0x1E,0xF2,0x0D,0xCE,0xD6,0xBC,0xBC,
1620       0x12,0x13,0x1A,0xC7,0xC5,0x47,0x88,0xAA
1621     };
1622
1623   ctx = _gcry_cipher_selftest_alloc_ctx (sizeof *ctx, &ctxmem);
1624   if (!ctx)
1625     return "failed to allocate memory";
1626   rijndael_setkey (ctx, key_192, sizeof(key_192));
1627   rijndael_encrypt (ctx, scratch, plaintext_192);
1628   if (memcmp (scratch, ciphertext_192, sizeof (ciphertext_192)))
1629     {
1630       xfree (ctxmem);
1631       return "AES-192 test encryption failed.";
1632     }
1633   rijndael_decrypt (ctx, scratch, scratch);
1634   xfree (ctxmem);
1635   if (memcmp (scratch, plaintext_192, sizeof (plaintext_192)))
1636     return "AES-192 test decryption failed.";
1637
1638   return NULL;
1639 }
1640
1641
1642 /* Run the self-tests for AES 256.  Returns NULL on success. */
1643 static const char*
1644 selftest_basic_256 (void)
1645 {
1646   RIJNDAEL_context *ctx;
1647   unsigned char *ctxmem;
1648   unsigned char scratch[16];
1649
1650   static unsigned char plaintext_256[16] =
1651     {
1652       0x06,0x9A,0x00,0x7F,0xC7,0x6A,0x45,0x9F,
1653       0x98,0xBA,0xF9,0x17,0xFE,0xDF,0x95,0x21
1654     };
1655   static unsigned char key_256[32] =
1656     {
1657       0x08,0x09,0x0A,0x0B,0x0D,0x0E,0x0F,0x10,
1658       0x12,0x13,0x14,0x15,0x17,0x18,0x19,0x1A,
1659       0x1C,0x1D,0x1E,0x1F,0x21,0x22,0x23,0x24,
1660       0x26,0x27,0x28,0x29,0x2B,0x2C,0x2D,0x2E
1661     };
1662   static const unsigned char ciphertext_256[16] =
1663     {
1664       0x08,0x0E,0x95,0x17,0xEB,0x16,0x77,0x71,
1665       0x9A,0xCF,0x72,0x80,0x86,0x04,0x0A,0xE3
1666     };
1667
1668   ctx = _gcry_cipher_selftest_alloc_ctx (sizeof *ctx, &ctxmem);
1669   if (!ctx)
1670     return "failed to allocate memory";
1671   rijndael_setkey (ctx, key_256, sizeof(key_256));
1672   rijndael_encrypt (ctx, scratch, plaintext_256);
1673   if (memcmp (scratch, ciphertext_256, sizeof (ciphertext_256)))
1674     {
1675       xfree (ctxmem);
1676       return "AES-256 test encryption failed.";
1677     }
1678   rijndael_decrypt (ctx, scratch, scratch);
1679   xfree (ctxmem);
1680   if (memcmp (scratch, plaintext_256, sizeof (plaintext_256)))
1681     return "AES-256 test decryption failed.";
1682
1683   return NULL;
1684 }
1685
1686
1687 /* Run the self-tests for AES-CTR-128, tests IV increment of bulk CTR
1688    encryption.  Returns NULL on success. */
1689 static const char*
1690 selftest_ctr_128 (void)
1691 {
1692   const int nblocks = 8+1;
1693   const int blocksize = BLOCKSIZE;
1694   const int context_size = sizeof(RIJNDAEL_context);
1695
1696   return _gcry_selftest_helper_ctr("AES", &rijndael_setkey,
1697            &rijndael_encrypt, &_gcry_aes_ctr_enc, nblocks, blocksize,
1698            context_size);
1699 }
1700
1701
1702 /* Run the self-tests for AES-CBC-128, tests bulk CBC decryption.
1703    Returns NULL on success. */
1704 static const char*
1705 selftest_cbc_128 (void)
1706 {
1707   const int nblocks = 8+2;
1708   const int blocksize = BLOCKSIZE;
1709   const int context_size = sizeof(RIJNDAEL_context);
1710
1711   return _gcry_selftest_helper_cbc("AES", &rijndael_setkey,
1712            &rijndael_encrypt, &_gcry_aes_cbc_dec, nblocks, blocksize,
1713            context_size);
1714 }
1715
1716
1717 /* Run the self-tests for AES-CFB-128, tests bulk CFB decryption.
1718    Returns NULL on success. */
1719 static const char*
1720 selftest_cfb_128 (void)
1721 {
1722   const int nblocks = 8+2;
1723   const int blocksize = BLOCKSIZE;
1724   const int context_size = sizeof(RIJNDAEL_context);
1725
1726   return _gcry_selftest_helper_cfb("AES", &rijndael_setkey,
1727            &rijndael_encrypt, &_gcry_aes_cfb_dec, nblocks, blocksize,
1728            context_size);
1729 }
1730
1731
1732 /* Run all the self-tests and return NULL on success.  This function
1733    is used for the on-the-fly self-tests. */
1734 static const char *
1735 selftest (void)
1736 {
1737   const char *r;
1738
1739   if ( (r = selftest_basic_128 ())
1740        || (r = selftest_basic_192 ())
1741        || (r = selftest_basic_256 ()) )
1742     return r;
1743
1744   if ( (r = selftest_ctr_128 ()) )
1745     return r;
1746
1747   if ( (r = selftest_cbc_128 ()) )
1748     return r;
1749
1750   if ( (r = selftest_cfb_128 ()) )
1751     return r;
1752
1753   return r;
1754 }
1755
1756
1757 /* SP800-38a.pdf for AES-128.  */
1758 static const char *
1759 selftest_fips_128_38a (int requested_mode)
1760 {
1761   static const struct tv
1762   {
1763     int mode;
1764     const unsigned char key[16];
1765     const unsigned char iv[16];
1766     struct
1767     {
1768       const unsigned char input[16];
1769       const unsigned char output[16];
1770     } data[4];
1771   } tv[2] =
1772     {
1773       {
1774         GCRY_CIPHER_MODE_CFB,  /* F.3.13, CFB128-AES128 */
1775         { 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
1776           0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c },
1777         { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1778           0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1779         {
1780           { { 0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
1781               0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a },
1782             { 0x3b, 0x3f, 0xd9, 0x2e, 0xb7, 0x2d, 0xad, 0x20,
1783               0x33, 0x34, 0x49, 0xf8, 0xe8, 0x3c, 0xfb, 0x4a } },
1784
1785           { { 0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
1786               0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51 },
1787             { 0xc8, 0xa6, 0x45, 0x37, 0xa0, 0xb3, 0xa9, 0x3f,
1788               0xcd, 0xe3, 0xcd, 0xad, 0x9f, 0x1c, 0xe5, 0x8b } },
1789
1790           { { 0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
1791               0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef },
1792             { 0x26, 0x75, 0x1f, 0x67, 0xa3, 0xcb, 0xb1, 0x40,
1793               0xb1, 0x80, 0x8c, 0xf1, 0x87, 0xa4, 0xf4, 0xdf } },
1794
1795           { { 0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
1796               0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10 },
1797             { 0xc0, 0x4b, 0x05, 0x35, 0x7c, 0x5d, 0x1c, 0x0e,
1798               0xea, 0xc4, 0xc6, 0x6f, 0x9f, 0xf7, 0xf2, 0xe6 } }
1799         }
1800       },
1801       {
1802         GCRY_CIPHER_MODE_OFB,
1803         { 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
1804           0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c },
1805         { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1806           0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1807         {
1808           { { 0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
1809               0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a },
1810             { 0x3b, 0x3f, 0xd9, 0x2e, 0xb7, 0x2d, 0xad, 0x20,
1811               0x33, 0x34, 0x49, 0xf8, 0xe8, 0x3c, 0xfb, 0x4a } },
1812
1813           { { 0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
1814               0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51 },
1815             { 0x77, 0x89, 0x50, 0x8d, 0x16, 0x91, 0x8f, 0x03,
1816               0xf5, 0x3c, 0x52, 0xda, 0xc5, 0x4e, 0xd8, 0x25 } },
1817
1818           { { 0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
1819               0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef },
1820             { 0x97, 0x40, 0x05, 0x1e, 0x9c, 0x5f, 0xec, 0xf6,
1821               0x43, 0x44, 0xf7, 0xa8, 0x22, 0x60, 0xed, 0xcc } },
1822
1823           { { 0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
1824               0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10 },
1825             { 0x30, 0x4c, 0x65, 0x28, 0xf6, 0x59, 0xc7, 0x78,
1826               0x66, 0xa5, 0x10, 0xd9, 0xc1, 0xd6, 0xae, 0x5e } },
1827         }
1828       }
1829     };
1830   unsigned char scratch[16];
1831   gpg_error_t err;
1832   int tvi, idx;
1833   gcry_cipher_hd_t hdenc = NULL;
1834   gcry_cipher_hd_t hddec = NULL;
1835
1836 #define Fail(a) do {           \
1837     _gcry_cipher_close (hdenc);  \
1838     _gcry_cipher_close (hddec);  \
1839     return a;                    \
1840   } while (0)
1841
1842   gcry_assert (sizeof tv[0].data[0].input == sizeof scratch);
1843   gcry_assert (sizeof tv[0].data[0].output == sizeof scratch);
1844
1845   for (tvi=0; tvi < DIM (tv); tvi++)
1846     if (tv[tvi].mode == requested_mode)
1847       break;
1848   if (tvi == DIM (tv))
1849     Fail ("no test data for this mode");
1850
1851   err = _gcry_cipher_open (&hdenc, GCRY_CIPHER_AES, tv[tvi].mode, 0);
1852   if (err)
1853     Fail ("open");
1854   err = _gcry_cipher_open (&hddec, GCRY_CIPHER_AES, tv[tvi].mode, 0);
1855   if (err)
1856     Fail ("open");
1857   err = _gcry_cipher_setkey (hdenc, tv[tvi].key,  sizeof tv[tvi].key);
1858   if (!err)
1859     err = _gcry_cipher_setkey (hddec, tv[tvi].key, sizeof tv[tvi].key);
1860   if (err)
1861     Fail ("set key");
1862   err = _gcry_cipher_setiv (hdenc, tv[tvi].iv, sizeof tv[tvi].iv);
1863   if (!err)
1864     err = _gcry_cipher_setiv (hddec, tv[tvi].iv, sizeof tv[tvi].iv);
1865   if (err)
1866     Fail ("set IV");
1867   for (idx=0; idx < DIM (tv[tvi].data); idx++)
1868     {
1869       err = _gcry_cipher_encrypt (hdenc, scratch, sizeof scratch,
1870                                   tv[tvi].data[idx].input,
1871                                   sizeof tv[tvi].data[idx].input);
1872       if (err)
1873         Fail ("encrypt command");
1874       if (memcmp (scratch, tv[tvi].data[idx].output, sizeof scratch))
1875         Fail ("encrypt mismatch");
1876       err = _gcry_cipher_decrypt (hddec, scratch, sizeof scratch,
1877                                   tv[tvi].data[idx].output,
1878                                   sizeof tv[tvi].data[idx].output);
1879       if (err)
1880         Fail ("decrypt command");
1881       if (memcmp (scratch, tv[tvi].data[idx].input, sizeof scratch))
1882         Fail ("decrypt mismatch");
1883     }
1884
1885 #undef Fail
1886   _gcry_cipher_close (hdenc);
1887   _gcry_cipher_close (hddec);
1888   return NULL;
1889 }
1890
1891
1892 /* Complete selftest for AES-128 with all modes and driver code.  */
1893 static gpg_err_code_t
1894 selftest_fips_128 (int extended, selftest_report_func_t report)
1895 {
1896   const char *what;
1897   const char *errtxt;
1898
1899   what = "low-level";
1900   errtxt = selftest_basic_128 ();
1901   if (errtxt)
1902     goto failed;
1903
1904   if (extended)
1905     {
1906       what = "cfb";
1907       errtxt = selftest_fips_128_38a (GCRY_CIPHER_MODE_CFB);
1908       if (errtxt)
1909         goto failed;
1910
1911       what = "ofb";
1912       errtxt = selftest_fips_128_38a (GCRY_CIPHER_MODE_OFB);
1913       if (errtxt)
1914         goto failed;
1915     }
1916
1917   return 0; /* Succeeded. */
1918
1919  failed:
1920   if (report)
1921     report ("cipher", GCRY_CIPHER_AES128, what, errtxt);
1922   return GPG_ERR_SELFTEST_FAILED;
1923 }
1924
1925 /* Complete selftest for AES-192.  */
1926 static gpg_err_code_t
1927 selftest_fips_192 (int extended, selftest_report_func_t report)
1928 {
1929   const char *what;
1930   const char *errtxt;
1931
1932   (void)extended; /* No extended tests available.  */
1933
1934   what = "low-level";
1935   errtxt = selftest_basic_192 ();
1936   if (errtxt)
1937     goto failed;
1938
1939
1940   return 0; /* Succeeded. */
1941
1942  failed:
1943   if (report)
1944     report ("cipher", GCRY_CIPHER_AES192, what, errtxt);
1945   return GPG_ERR_SELFTEST_FAILED;
1946 }
1947
1948
1949 /* Complete selftest for AES-256.  */
1950 static gpg_err_code_t
1951 selftest_fips_256 (int extended, selftest_report_func_t report)
1952 {
1953   const char *what;
1954   const char *errtxt;
1955
1956   (void)extended; /* No extended tests available.  */
1957
1958   what = "low-level";
1959   errtxt = selftest_basic_256 ();
1960   if (errtxt)
1961     goto failed;
1962
1963   return 0; /* Succeeded. */
1964
1965  failed:
1966   if (report)
1967     report ("cipher", GCRY_CIPHER_AES256, what, errtxt);
1968   return GPG_ERR_SELFTEST_FAILED;
1969 }
1970
1971
1972
1973 /* Run a full self-test for ALGO and return 0 on success.  */
1974 static gpg_err_code_t
1975 run_selftests (int algo, int extended, selftest_report_func_t report)
1976 {
1977   gpg_err_code_t ec;
1978
1979   switch (algo)
1980     {
1981     case GCRY_CIPHER_AES128:
1982       ec = selftest_fips_128 (extended, report);
1983       break;
1984     case GCRY_CIPHER_AES192:
1985       ec = selftest_fips_192 (extended, report);
1986       break;
1987     case GCRY_CIPHER_AES256:
1988       ec = selftest_fips_256 (extended, report);
1989       break;
1990     default:
1991       ec = GPG_ERR_CIPHER_ALGO;
1992       break;
1993
1994     }
1995   return ec;
1996 }
1997
1998
1999 \f
2000
2001 static const char *rijndael_names[] =
2002   {
2003     "RIJNDAEL",
2004     "AES128",
2005     "AES-128",
2006     NULL
2007   };
2008
2009 static gcry_cipher_oid_spec_t rijndael_oids[] =
2010   {
2011     { "2.16.840.1.101.3.4.1.1", GCRY_CIPHER_MODE_ECB },
2012     { "2.16.840.1.101.3.4.1.2", GCRY_CIPHER_MODE_CBC },
2013     { "2.16.840.1.101.3.4.1.3", GCRY_CIPHER_MODE_OFB },
2014     { "2.16.840.1.101.3.4.1.4", GCRY_CIPHER_MODE_CFB },
2015     { NULL }
2016   };
2017
2018 gcry_cipher_spec_t _gcry_cipher_spec_aes =
2019   {
2020     GCRY_CIPHER_AES, {0, 1},
2021     "AES", rijndael_names, rijndael_oids, 16, 128,
2022     sizeof (RIJNDAEL_context),
2023     rijndael_setkey, rijndael_encrypt, rijndael_decrypt,
2024     NULL, NULL,
2025     run_selftests
2026   };
2027
2028
2029 static const char *rijndael192_names[] =
2030   {
2031     "RIJNDAEL192",
2032     "AES-192",
2033     NULL
2034   };
2035
2036 static gcry_cipher_oid_spec_t rijndael192_oids[] =
2037   {
2038     { "2.16.840.1.101.3.4.1.21", GCRY_CIPHER_MODE_ECB },
2039     { "2.16.840.1.101.3.4.1.22", GCRY_CIPHER_MODE_CBC },
2040     { "2.16.840.1.101.3.4.1.23", GCRY_CIPHER_MODE_OFB },
2041     { "2.16.840.1.101.3.4.1.24", GCRY_CIPHER_MODE_CFB },
2042     { NULL }
2043   };
2044
2045 gcry_cipher_spec_t _gcry_cipher_spec_aes192 =
2046   {
2047     GCRY_CIPHER_AES192, {0, 1},
2048     "AES192", rijndael192_names, rijndael192_oids, 16, 192,
2049     sizeof (RIJNDAEL_context),
2050     rijndael_setkey, rijndael_encrypt, rijndael_decrypt,
2051     NULL, NULL,
2052     run_selftests
2053   };
2054
2055
2056 static const char *rijndael256_names[] =
2057   {
2058     "RIJNDAEL256",
2059     "AES-256",
2060     NULL
2061   };
2062
2063 static gcry_cipher_oid_spec_t rijndael256_oids[] =
2064   {
2065     { "2.16.840.1.101.3.4.1.41", GCRY_CIPHER_MODE_ECB },
2066     { "2.16.840.1.101.3.4.1.42", GCRY_CIPHER_MODE_CBC },
2067     { "2.16.840.1.101.3.4.1.43", GCRY_CIPHER_MODE_OFB },
2068     { "2.16.840.1.101.3.4.1.44", GCRY_CIPHER_MODE_CFB },
2069     { NULL }
2070   };
2071
2072 gcry_cipher_spec_t _gcry_cipher_spec_aes256 =
2073   {
2074     GCRY_CIPHER_AES256, {0, 1},
2075     "AES256", rijndael256_names, rijndael256_oids, 16, 256,
2076     sizeof (RIJNDAEL_context),
2077     rijndael_setkey, rijndael_encrypt, rijndael_decrypt,
2078     NULL, NULL,
2079     run_selftests
2080   };