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