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