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