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