Reduce amount of duplicated code in OCB bulk implementations
[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           unsigned int ntz = _gcry_ctz64 (i);
1250           const unsigned char *l;
1251
1252           if (ntz < OCB_L_TABLE_SIZE)
1253               l = c->u_mode.ocb.L[ntz];
1254           else
1255               l = _gcry_cipher_ocb_get_l (c, l_tmp.x1, i);
1256
1257           /* Offset_i = Offset_{i-1} xor L_{ntz(i)} */
1258           buf_xor_1 (c->u_iv.iv, l, BLOCKSIZE);
1259           buf_cpy (l_tmp.x1, inbuf, BLOCKSIZE);
1260           /* Checksum_i = Checksum_{i-1} xor P_i  */
1261           buf_xor_1 (c->u_ctr.ctr, l_tmp.x1, BLOCKSIZE);
1262           /* C_i = Offset_i xor ENCIPHER(K, P_i xor Offset_i)  */
1263           buf_xor_1 (l_tmp.x1, c->u_iv.iv, BLOCKSIZE);
1264           burn_depth = encrypt_fn (ctx, l_tmp.x1, l_tmp.x1);
1265           buf_xor_1 (l_tmp.x1, c->u_iv.iv, BLOCKSIZE);
1266           buf_cpy (outbuf, l_tmp.x1, BLOCKSIZE);
1267
1268           inbuf += BLOCKSIZE;
1269           outbuf += BLOCKSIZE;
1270         }
1271     }
1272   else
1273     {
1274       union { unsigned char x1[16] ATTR_ALIGNED_16; u32 x32[4]; } l_tmp;
1275       rijndael_cryptfn_t decrypt_fn = ctx->decrypt_fn;
1276
1277       for ( ;nblocks; nblocks-- )
1278         {
1279           u64 i = ++c->u_mode.ocb.data_nblocks;
1280           unsigned int ntz = _gcry_ctz64 (i);
1281           const unsigned char *l;
1282
1283           if (ntz < OCB_L_TABLE_SIZE)
1284               l = c->u_mode.ocb.L[ntz];
1285           else
1286               l = _gcry_cipher_ocb_get_l (c, l_tmp.x1, i);
1287
1288           /* Offset_i = Offset_{i-1} xor L_{ntz(i)} */
1289           buf_xor_1 (c->u_iv.iv, l, BLOCKSIZE);
1290           buf_cpy (l_tmp.x1, inbuf, BLOCKSIZE);
1291           /* C_i = Offset_i xor ENCIPHER(K, P_i xor Offset_i)  */
1292           buf_xor_1 (l_tmp.x1, c->u_iv.iv, BLOCKSIZE);
1293           burn_depth = decrypt_fn (ctx, l_tmp.x1, l_tmp.x1);
1294           buf_xor_1 (l_tmp.x1, c->u_iv.iv, BLOCKSIZE);
1295           /* Checksum_i = Checksum_{i-1} xor P_i  */
1296           buf_xor_1 (c->u_ctr.ctr, l_tmp.x1, BLOCKSIZE);
1297           buf_cpy (outbuf, l_tmp.x1, BLOCKSIZE);
1298
1299           inbuf += BLOCKSIZE;
1300           outbuf += BLOCKSIZE;
1301         }
1302     }
1303
1304   if (burn_depth)
1305     _gcry_burn_stack (burn_depth + 4 * sizeof(void *));
1306
1307   return 0;
1308 }
1309
1310
1311 /* Bulk authentication of complete blocks in OCB mode. */
1312 size_t
1313 _gcry_aes_ocb_auth (gcry_cipher_hd_t c, const void *abuf_arg, size_t nblocks)
1314 {
1315   RIJNDAEL_context *ctx = (void *)&c->context.c;
1316   const unsigned char *abuf = abuf_arg;
1317   unsigned int burn_depth = 0;
1318
1319   if (ctx->prefetch_enc_fn)
1320     ctx->prefetch_enc_fn();
1321
1322   if (0)
1323     ;
1324 #ifdef USE_AESNI
1325   else if (ctx->use_aesni)
1326     {
1327       _gcry_aes_aesni_ocb_auth (c, abuf, nblocks);
1328       burn_depth = 0;
1329     }
1330 #endif /*USE_AESNI*/
1331 #ifdef USE_SSSE3
1332   else if (ctx->use_ssse3)
1333     {
1334       _gcry_aes_ssse3_ocb_auth (c, abuf, nblocks);
1335       burn_depth = 0;
1336     }
1337 #endif /*USE_SSSE3*/
1338   else
1339     {
1340       union { unsigned char x1[16] ATTR_ALIGNED_16; u32 x32[4]; } l_tmp;
1341       rijndael_cryptfn_t encrypt_fn = ctx->encrypt_fn;
1342
1343       for ( ;nblocks; nblocks-- )
1344         {
1345           u64 i = ++c->u_mode.ocb.aad_nblocks;
1346           unsigned int ntz = _gcry_ctz64 (i);
1347           const unsigned char *l;
1348
1349           if (ntz < OCB_L_TABLE_SIZE)
1350               l = c->u_mode.ocb.L[ntz];
1351           else
1352               l = _gcry_cipher_ocb_get_l (c, l_tmp.x1, i);
1353
1354           /* Offset_i = Offset_{i-1} xor L_{ntz(i)} */
1355           buf_xor_1 (c->u_mode.ocb.aad_offset, l, BLOCKSIZE);
1356           /* Sum_i = Sum_{i-1} xor ENCIPHER(K, A_i xor Offset_i)  */
1357           buf_xor (l_tmp.x1, c->u_mode.ocb.aad_offset, abuf, BLOCKSIZE);
1358           burn_depth = encrypt_fn (ctx, l_tmp.x1, l_tmp.x1);
1359           buf_xor_1 (c->u_mode.ocb.aad_sum, l_tmp.x1, BLOCKSIZE);
1360
1361           abuf += BLOCKSIZE;
1362         }
1363
1364       wipememory(&l_tmp, sizeof(l_tmp));
1365     }
1366
1367   if (burn_depth)
1368     _gcry_burn_stack (burn_depth + 4 * sizeof(void *));
1369
1370   return 0;
1371 }
1372
1373
1374 \f
1375 /* Run the self-tests for AES 128.  Returns NULL on success. */
1376 static const char*
1377 selftest_basic_128 (void)
1378 {
1379   RIJNDAEL_context ctx;
1380   unsigned char scratch[16];
1381
1382   /* The test vectors are from the AES supplied ones; more or less
1383      randomly taken from ecb_tbl.txt (I=42,81,14) */
1384 #if 1
1385   static const unsigned char plaintext_128[16] =
1386     {
1387       0x01,0x4B,0xAF,0x22,0x78,0xA6,0x9D,0x33,
1388       0x1D,0x51,0x80,0x10,0x36,0x43,0xE9,0x9A
1389     };
1390   static const unsigned char key_128[16] =
1391     {
1392       0xE8,0xE9,0xEA,0xEB,0xED,0xEE,0xEF,0xF0,
1393       0xF2,0xF3,0xF4,0xF5,0xF7,0xF8,0xF9,0xFA
1394     };
1395   static const unsigned char ciphertext_128[16] =
1396     {
1397       0x67,0x43,0xC3,0xD1,0x51,0x9A,0xB4,0xF2,
1398       0xCD,0x9A,0x78,0xAB,0x09,0xA5,0x11,0xBD
1399     };
1400 #else
1401   /* Test vectors from fips-197, appendix C. */
1402 # warning debug test vectors in use
1403   static const unsigned char plaintext_128[16] =
1404     {
1405       0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,
1406       0x88,0x99,0xaa,0xbb,0xcc,0xdd,0xee,0xff
1407     };
1408   static const unsigned char key_128[16] =
1409     {
1410       0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
1411       0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f
1412       /* 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, */
1413       /* 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c */
1414     };
1415   static const unsigned char ciphertext_128[16] =
1416     {
1417       0x69,0xc4,0xe0,0xd8,0x6a,0x7b,0x04,0x30,
1418       0xd8,0xcd,0xb7,0x80,0x70,0xb4,0xc5,0x5a
1419     };
1420 #endif
1421
1422   rijndael_setkey (&ctx, key_128, sizeof (key_128));
1423   rijndael_encrypt (&ctx, scratch, plaintext_128);
1424   if (memcmp (scratch, ciphertext_128, sizeof (ciphertext_128)))
1425      return "AES-128 test encryption failed.";
1426   rijndael_decrypt (&ctx, scratch, scratch);
1427   if (memcmp (scratch, plaintext_128, sizeof (plaintext_128)))
1428     return "AES-128 test decryption failed.";
1429
1430   return NULL;
1431 }
1432
1433 /* Run the self-tests for AES 192.  Returns NULL on success. */
1434 static const char*
1435 selftest_basic_192 (void)
1436 {
1437   RIJNDAEL_context ctx;
1438   unsigned char scratch[16];
1439
1440   static unsigned char plaintext_192[16] =
1441     {
1442       0x76,0x77,0x74,0x75,0xF1,0xF2,0xF3,0xF4,
1443       0xF8,0xF9,0xE6,0xE7,0x77,0x70,0x71,0x72
1444     };
1445   static unsigned char key_192[24] =
1446     {
1447       0x04,0x05,0x06,0x07,0x09,0x0A,0x0B,0x0C,
1448       0x0E,0x0F,0x10,0x11,0x13,0x14,0x15,0x16,
1449       0x18,0x19,0x1A,0x1B,0x1D,0x1E,0x1F,0x20
1450     };
1451   static const unsigned char ciphertext_192[16] =
1452     {
1453       0x5D,0x1E,0xF2,0x0D,0xCE,0xD6,0xBC,0xBC,
1454       0x12,0x13,0x1A,0xC7,0xC5,0x47,0x88,0xAA
1455     };
1456
1457   rijndael_setkey (&ctx, key_192, sizeof(key_192));
1458   rijndael_encrypt (&ctx, scratch, plaintext_192);
1459   if (memcmp (scratch, ciphertext_192, sizeof (ciphertext_192)))
1460     return "AES-192 test encryption failed.";
1461   rijndael_decrypt (&ctx, scratch, scratch);
1462   if (memcmp (scratch, plaintext_192, sizeof (plaintext_192)))
1463     return "AES-192 test decryption failed.";
1464
1465   return NULL;
1466 }
1467
1468
1469 /* Run the self-tests for AES 256.  Returns NULL on success. */
1470 static const char*
1471 selftest_basic_256 (void)
1472 {
1473   RIJNDAEL_context ctx;
1474   unsigned char scratch[16];
1475
1476   static unsigned char plaintext_256[16] =
1477     {
1478       0x06,0x9A,0x00,0x7F,0xC7,0x6A,0x45,0x9F,
1479       0x98,0xBA,0xF9,0x17,0xFE,0xDF,0x95,0x21
1480     };
1481   static unsigned char key_256[32] =
1482     {
1483       0x08,0x09,0x0A,0x0B,0x0D,0x0E,0x0F,0x10,
1484       0x12,0x13,0x14,0x15,0x17,0x18,0x19,0x1A,
1485       0x1C,0x1D,0x1E,0x1F,0x21,0x22,0x23,0x24,
1486       0x26,0x27,0x28,0x29,0x2B,0x2C,0x2D,0x2E
1487     };
1488   static const unsigned char ciphertext_256[16] =
1489     {
1490       0x08,0x0E,0x95,0x17,0xEB,0x16,0x77,0x71,
1491       0x9A,0xCF,0x72,0x80,0x86,0x04,0x0A,0xE3
1492     };
1493
1494   rijndael_setkey (&ctx, key_256, sizeof(key_256));
1495   rijndael_encrypt (&ctx, scratch, plaintext_256);
1496   if (memcmp (scratch, ciphertext_256, sizeof (ciphertext_256)))
1497     return "AES-256 test encryption failed.";
1498   rijndael_decrypt (&ctx, scratch, scratch);
1499   if (memcmp (scratch, plaintext_256, sizeof (plaintext_256)))
1500     return "AES-256 test decryption failed.";
1501
1502   return NULL;
1503 }
1504
1505
1506 /* Run the self-tests for AES-CTR-128, tests IV increment of bulk CTR
1507    encryption.  Returns NULL on success. */
1508 static const char*
1509 selftest_ctr_128 (void)
1510 {
1511   const int nblocks = 8+1;
1512   const int blocksize = BLOCKSIZE;
1513   const int context_size = sizeof(RIJNDAEL_context);
1514
1515   return _gcry_selftest_helper_ctr("AES", &rijndael_setkey,
1516            &rijndael_encrypt, &_gcry_aes_ctr_enc, nblocks, blocksize,
1517            context_size);
1518 }
1519
1520
1521 /* Run the self-tests for AES-CBC-128, tests bulk CBC decryption.
1522    Returns NULL on success. */
1523 static const char*
1524 selftest_cbc_128 (void)
1525 {
1526   const int nblocks = 8+2;
1527   const int blocksize = BLOCKSIZE;
1528   const int context_size = sizeof(RIJNDAEL_context);
1529
1530   return _gcry_selftest_helper_cbc("AES", &rijndael_setkey,
1531            &rijndael_encrypt, &_gcry_aes_cbc_dec, nblocks, blocksize,
1532            context_size);
1533 }
1534
1535
1536 /* Run the self-tests for AES-CFB-128, tests bulk CFB decryption.
1537    Returns NULL on success. */
1538 static const char*
1539 selftest_cfb_128 (void)
1540 {
1541   const int nblocks = 8+2;
1542   const int blocksize = BLOCKSIZE;
1543   const int context_size = sizeof(RIJNDAEL_context);
1544
1545   return _gcry_selftest_helper_cfb("AES", &rijndael_setkey,
1546            &rijndael_encrypt, &_gcry_aes_cfb_dec, nblocks, blocksize,
1547            context_size);
1548 }
1549
1550
1551 /* Run all the self-tests and return NULL on success.  This function
1552    is used for the on-the-fly self-tests. */
1553 static const char *
1554 selftest (void)
1555 {
1556   const char *r;
1557
1558   if ( (r = selftest_basic_128 ())
1559        || (r = selftest_basic_192 ())
1560        || (r = selftest_basic_256 ()) )
1561     return r;
1562
1563   if ( (r = selftest_ctr_128 ()) )
1564     return r;
1565
1566   if ( (r = selftest_cbc_128 ()) )
1567     return r;
1568
1569   if ( (r = selftest_cfb_128 ()) )
1570     return r;
1571
1572   return r;
1573 }
1574
1575
1576 /* SP800-38a.pdf for AES-128.  */
1577 static const char *
1578 selftest_fips_128_38a (int requested_mode)
1579 {
1580   static const struct tv
1581   {
1582     int mode;
1583     const unsigned char key[16];
1584     const unsigned char iv[16];
1585     struct
1586     {
1587       const unsigned char input[16];
1588       const unsigned char output[16];
1589     } data[4];
1590   } tv[2] =
1591     {
1592       {
1593         GCRY_CIPHER_MODE_CFB,  /* F.3.13, CFB128-AES128 */
1594         { 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
1595           0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c },
1596         { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1597           0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1598         {
1599           { { 0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
1600               0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a },
1601             { 0x3b, 0x3f, 0xd9, 0x2e, 0xb7, 0x2d, 0xad, 0x20,
1602               0x33, 0x34, 0x49, 0xf8, 0xe8, 0x3c, 0xfb, 0x4a } },
1603
1604           { { 0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
1605               0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51 },
1606             { 0xc8, 0xa6, 0x45, 0x37, 0xa0, 0xb3, 0xa9, 0x3f,
1607               0xcd, 0xe3, 0xcd, 0xad, 0x9f, 0x1c, 0xe5, 0x8b } },
1608
1609           { { 0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
1610               0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef },
1611             { 0x26, 0x75, 0x1f, 0x67, 0xa3, 0xcb, 0xb1, 0x40,
1612               0xb1, 0x80, 0x8c, 0xf1, 0x87, 0xa4, 0xf4, 0xdf } },
1613
1614           { { 0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
1615               0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10 },
1616             { 0xc0, 0x4b, 0x05, 0x35, 0x7c, 0x5d, 0x1c, 0x0e,
1617               0xea, 0xc4, 0xc6, 0x6f, 0x9f, 0xf7, 0xf2, 0xe6 } }
1618         }
1619       },
1620       {
1621         GCRY_CIPHER_MODE_OFB,
1622         { 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
1623           0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c },
1624         { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1625           0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1626         {
1627           { { 0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
1628               0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a },
1629             { 0x3b, 0x3f, 0xd9, 0x2e, 0xb7, 0x2d, 0xad, 0x20,
1630               0x33, 0x34, 0x49, 0xf8, 0xe8, 0x3c, 0xfb, 0x4a } },
1631
1632           { { 0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
1633               0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51 },
1634             { 0x77, 0x89, 0x50, 0x8d, 0x16, 0x91, 0x8f, 0x03,
1635               0xf5, 0x3c, 0x52, 0xda, 0xc5, 0x4e, 0xd8, 0x25 } },
1636
1637           { { 0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
1638               0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef },
1639             { 0x97, 0x40, 0x05, 0x1e, 0x9c, 0x5f, 0xec, 0xf6,
1640               0x43, 0x44, 0xf7, 0xa8, 0x22, 0x60, 0xed, 0xcc } },
1641
1642           { { 0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
1643               0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10 },
1644             { 0x30, 0x4c, 0x65, 0x28, 0xf6, 0x59, 0xc7, 0x78,
1645               0x66, 0xa5, 0x10, 0xd9, 0xc1, 0xd6, 0xae, 0x5e } },
1646         }
1647       }
1648     };
1649   unsigned char scratch[16];
1650   gpg_error_t err;
1651   int tvi, idx;
1652   gcry_cipher_hd_t hdenc = NULL;
1653   gcry_cipher_hd_t hddec = NULL;
1654
1655 #define Fail(a) do {           \
1656     _gcry_cipher_close (hdenc);  \
1657     _gcry_cipher_close (hddec);  \
1658     return a;                    \
1659   } while (0)
1660
1661   gcry_assert (sizeof tv[0].data[0].input == sizeof scratch);
1662   gcry_assert (sizeof tv[0].data[0].output == sizeof scratch);
1663
1664   for (tvi=0; tvi < DIM (tv); tvi++)
1665     if (tv[tvi].mode == requested_mode)
1666       break;
1667   if (tvi == DIM (tv))
1668     Fail ("no test data for this mode");
1669
1670   err = _gcry_cipher_open (&hdenc, GCRY_CIPHER_AES, tv[tvi].mode, 0);
1671   if (err)
1672     Fail ("open");
1673   err = _gcry_cipher_open (&hddec, GCRY_CIPHER_AES, tv[tvi].mode, 0);
1674   if (err)
1675     Fail ("open");
1676   err = _gcry_cipher_setkey (hdenc, tv[tvi].key,  sizeof tv[tvi].key);
1677   if (!err)
1678     err = _gcry_cipher_setkey (hddec, tv[tvi].key, sizeof tv[tvi].key);
1679   if (err)
1680     Fail ("set key");
1681   err = _gcry_cipher_setiv (hdenc, tv[tvi].iv, sizeof tv[tvi].iv);
1682   if (!err)
1683     err = _gcry_cipher_setiv (hddec, tv[tvi].iv, sizeof tv[tvi].iv);
1684   if (err)
1685     Fail ("set IV");
1686   for (idx=0; idx < DIM (tv[tvi].data); idx++)
1687     {
1688       err = _gcry_cipher_encrypt (hdenc, scratch, sizeof scratch,
1689                                   tv[tvi].data[idx].input,
1690                                   sizeof tv[tvi].data[idx].input);
1691       if (err)
1692         Fail ("encrypt command");
1693       if (memcmp (scratch, tv[tvi].data[idx].output, sizeof scratch))
1694         Fail ("encrypt mismatch");
1695       err = _gcry_cipher_decrypt (hddec, scratch, sizeof scratch,
1696                                   tv[tvi].data[idx].output,
1697                                   sizeof tv[tvi].data[idx].output);
1698       if (err)
1699         Fail ("decrypt command");
1700       if (memcmp (scratch, tv[tvi].data[idx].input, sizeof scratch))
1701         Fail ("decrypt mismatch");
1702     }
1703
1704 #undef Fail
1705   _gcry_cipher_close (hdenc);
1706   _gcry_cipher_close (hddec);
1707   return NULL;
1708 }
1709
1710
1711 /* Complete selftest for AES-128 with all modes and driver code.  */
1712 static gpg_err_code_t
1713 selftest_fips_128 (int extended, selftest_report_func_t report)
1714 {
1715   const char *what;
1716   const char *errtxt;
1717
1718   what = "low-level";
1719   errtxt = selftest_basic_128 ();
1720   if (errtxt)
1721     goto failed;
1722
1723   if (extended)
1724     {
1725       what = "cfb";
1726       errtxt = selftest_fips_128_38a (GCRY_CIPHER_MODE_CFB);
1727       if (errtxt)
1728         goto failed;
1729
1730       what = "ofb";
1731       errtxt = selftest_fips_128_38a (GCRY_CIPHER_MODE_OFB);
1732       if (errtxt)
1733         goto failed;
1734     }
1735
1736   return 0; /* Succeeded. */
1737
1738  failed:
1739   if (report)
1740     report ("cipher", GCRY_CIPHER_AES128, what, errtxt);
1741   return GPG_ERR_SELFTEST_FAILED;
1742 }
1743
1744 /* Complete selftest for AES-192.  */
1745 static gpg_err_code_t
1746 selftest_fips_192 (int extended, selftest_report_func_t report)
1747 {
1748   const char *what;
1749   const char *errtxt;
1750
1751   (void)extended; /* No extended tests available.  */
1752
1753   what = "low-level";
1754   errtxt = selftest_basic_192 ();
1755   if (errtxt)
1756     goto failed;
1757
1758
1759   return 0; /* Succeeded. */
1760
1761  failed:
1762   if (report)
1763     report ("cipher", GCRY_CIPHER_AES192, what, errtxt);
1764   return GPG_ERR_SELFTEST_FAILED;
1765 }
1766
1767
1768 /* Complete selftest for AES-256.  */
1769 static gpg_err_code_t
1770 selftest_fips_256 (int extended, selftest_report_func_t report)
1771 {
1772   const char *what;
1773   const char *errtxt;
1774
1775   (void)extended; /* No extended tests available.  */
1776
1777   what = "low-level";
1778   errtxt = selftest_basic_256 ();
1779   if (errtxt)
1780     goto failed;
1781
1782   return 0; /* Succeeded. */
1783
1784  failed:
1785   if (report)
1786     report ("cipher", GCRY_CIPHER_AES256, what, errtxt);
1787   return GPG_ERR_SELFTEST_FAILED;
1788 }
1789
1790
1791
1792 /* Run a full self-test for ALGO and return 0 on success.  */
1793 static gpg_err_code_t
1794 run_selftests (int algo, int extended, selftest_report_func_t report)
1795 {
1796   gpg_err_code_t ec;
1797
1798   switch (algo)
1799     {
1800     case GCRY_CIPHER_AES128:
1801       ec = selftest_fips_128 (extended, report);
1802       break;
1803     case GCRY_CIPHER_AES192:
1804       ec = selftest_fips_192 (extended, report);
1805       break;
1806     case GCRY_CIPHER_AES256:
1807       ec = selftest_fips_256 (extended, report);
1808       break;
1809     default:
1810       ec = GPG_ERR_CIPHER_ALGO;
1811       break;
1812
1813     }
1814   return ec;
1815 }
1816
1817
1818 \f
1819
1820 static const char *rijndael_names[] =
1821   {
1822     "RIJNDAEL",
1823     "AES128",
1824     "AES-128",
1825     NULL
1826   };
1827
1828 static gcry_cipher_oid_spec_t rijndael_oids[] =
1829   {
1830     { "2.16.840.1.101.3.4.1.1", GCRY_CIPHER_MODE_ECB },
1831     { "2.16.840.1.101.3.4.1.2", GCRY_CIPHER_MODE_CBC },
1832     { "2.16.840.1.101.3.4.1.3", GCRY_CIPHER_MODE_OFB },
1833     { "2.16.840.1.101.3.4.1.4", GCRY_CIPHER_MODE_CFB },
1834     { NULL }
1835   };
1836
1837 gcry_cipher_spec_t _gcry_cipher_spec_aes =
1838   {
1839     GCRY_CIPHER_AES, {0, 1},
1840     "AES", rijndael_names, rijndael_oids, 16, 128,
1841     sizeof (RIJNDAEL_context),
1842     rijndael_setkey, rijndael_encrypt, rijndael_decrypt,
1843     NULL, NULL,
1844     run_selftests
1845   };
1846
1847
1848 static const char *rijndael192_names[] =
1849   {
1850     "RIJNDAEL192",
1851     "AES-192",
1852     NULL
1853   };
1854
1855 static gcry_cipher_oid_spec_t rijndael192_oids[] =
1856   {
1857     { "2.16.840.1.101.3.4.1.21", GCRY_CIPHER_MODE_ECB },
1858     { "2.16.840.1.101.3.4.1.22", GCRY_CIPHER_MODE_CBC },
1859     { "2.16.840.1.101.3.4.1.23", GCRY_CIPHER_MODE_OFB },
1860     { "2.16.840.1.101.3.4.1.24", GCRY_CIPHER_MODE_CFB },
1861     { NULL }
1862   };
1863
1864 gcry_cipher_spec_t _gcry_cipher_spec_aes192 =
1865   {
1866     GCRY_CIPHER_AES192, {0, 1},
1867     "AES192", rijndael192_names, rijndael192_oids, 16, 192,
1868     sizeof (RIJNDAEL_context),
1869     rijndael_setkey, rijndael_encrypt, rijndael_decrypt,
1870     NULL, NULL,
1871     run_selftests
1872   };
1873
1874
1875 static const char *rijndael256_names[] =
1876   {
1877     "RIJNDAEL256",
1878     "AES-256",
1879     NULL
1880   };
1881
1882 static gcry_cipher_oid_spec_t rijndael256_oids[] =
1883   {
1884     { "2.16.840.1.101.3.4.1.41", GCRY_CIPHER_MODE_ECB },
1885     { "2.16.840.1.101.3.4.1.42", GCRY_CIPHER_MODE_CBC },
1886     { "2.16.840.1.101.3.4.1.43", GCRY_CIPHER_MODE_OFB },
1887     { "2.16.840.1.101.3.4.1.44", GCRY_CIPHER_MODE_CFB },
1888     { NULL }
1889   };
1890
1891 gcry_cipher_spec_t _gcry_cipher_spec_aes256 =
1892   {
1893     GCRY_CIPHER_AES256, {0, 1},
1894     "AES256", rijndael256_names, rijndael256_oids, 16, 256,
1895     sizeof (RIJNDAEL_context),
1896     rijndael_setkey, rijndael_encrypt, rijndael_decrypt,
1897     NULL, NULL,
1898     run_selftests
1899   };