2b19e0947e5b56415106a8abc4d4de1452415eb0
[libgcrypt.git] / cipher / rijndael.c
1 /* Rijndael (AES) for GnuPG
2  * Copyright (C) 2000, 2001, 2002, 2003, 2007,
3  *               2008 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
49 #define MAXKC                   (256/32)
50 #define MAXROUNDS               14
51 #define BLOCKSIZE               (128/8)
52
53
54 /* USE_PADLOCK indicates whether to compile the padlock specific
55    code.  */
56 #undef USE_PADLOCK
57 #ifdef ENABLE_PADLOCK_SUPPORT
58 # if defined (__i386__) && SIZEOF_UNSIGNED_LONG == 4 && defined (__GNUC__)
59 # define USE_PADLOCK
60 # endif
61 #endif /*ENABLE_PADLOCK_SUPPORT*/
62
63
64 /* USE_AESNI inidicates whether to compile with Intel AES-NI code.  */
65 #undef USE_AESNI
66 #ifdef ENABLE_AESNI_SUPPORT
67 # if defined (__i386__) && SIZEOF_UNSIGNED_LONG == 4 && defined (__GNUC__)
68 #  define USE_AESNI
69 # endif
70 #endif /* ENABLE_AESNI_SUPPORT */
71
72
73 static const char *selftest(void);
74
75 typedef struct
76 {
77   int   ROUNDS;             /* Key-length-dependent number of rounds.  */
78   int decryption_prepared;  /* The decryption key schedule is available.  */
79 #ifdef USE_PADLOCK
80   int use_padlock;          /* Padlock shall be used.  */
81   /* The key as passed to the padlock engine.  */
82   unsigned char padlock_key[16] __attribute__ ((aligned (16)));
83 #endif
84   union
85   {
86     PROPERLY_ALIGNED_TYPE dummy;
87     byte keyschedule[MAXROUNDS+1][4][4];
88   } u1;
89   union
90   {
91     PROPERLY_ALIGNED_TYPE dummy;
92     byte keyschedule[MAXROUNDS+1][4][4];
93   } u2;
94 } RIJNDAEL_context;
95
96 #define keySched  u1.keyschedule
97 #define keySched2 u2.keyschedule
98
99 /* All the numbers.  */
100 #include "rijndael-tables.h"
101
102
103 /* Perform the key setup.  */
104 static gcry_err_code_t
105 do_setkey (RIJNDAEL_context *ctx, const byte *key, const unsigned keylen)
106 {
107   static int initialized = 0;
108   static const char *selftest_failed=0;
109   int ROUNDS;
110   int i,j, r, t, rconpointer = 0;
111   int KC;
112   union
113   {
114     PROPERLY_ALIGNED_TYPE dummy;
115     byte k[MAXKC][4];
116   } k;
117 #define k k.k
118   union
119   {
120     PROPERLY_ALIGNED_TYPE dummy;
121     byte tk[MAXKC][4];
122   } tk;
123 #define tk tk.tk
124
125   /* The on-the-fly self tests are only run in non-fips mode. In fips
126      mode explicit self-tests are required.  Actually the on-the-fly
127      self-tests are not fully thread-safe and it might happen that a
128      failed self-test won't get noticed in another thread.
129
130      FIXME: We might want to have a central registry of succeeded
131      self-tests. */
132   if (!fips_mode () && !initialized)
133     {
134       initialized = 1;
135       selftest_failed = selftest ();
136       if (selftest_failed)
137         log_error ("%s\n", selftest_failed );
138     }
139   if (selftest_failed)
140     return GPG_ERR_SELFTEST_FAILED;
141
142   ctx->decryption_prepared = 0;
143 #ifdef USE_PADLOCK
144   ctx->use_padlock = 0;
145 #endif
146
147   if( keylen == 128/8 )
148     {
149       ROUNDS = 10;
150       KC = 4;
151 #ifdef USE_PADLOCK
152       if ((_gcry_get_hw_features () & HWF_PADLOCK_AES))
153         {
154           ctx->use_padlock = 1;
155           memcpy (ctx->padlock_key, key, keylen);
156         }
157 #endif
158     }
159   else if ( keylen == 192/8 )
160     {
161       ROUNDS = 12;
162       KC = 6;
163     }
164   else if ( keylen == 256/8 )
165     {
166       ROUNDS = 14;
167       KC = 8;
168     }
169   else
170     return GPG_ERR_INV_KEYLEN;
171
172   ctx->ROUNDS = ROUNDS;
173
174 #ifdef USE_PADLOCK
175   if (ctx->use_padlock)
176     {
177       /* Nothing to do as we support only hardware key generation for
178          now.  */
179     }
180   else
181 #endif /*USE_PADLOCK*/
182     {
183 #define W (ctx->keySched)
184       for (i = 0; i < keylen; i++)
185         {
186           k[i >> 2][i & 3] = key[i];
187         }
188
189       for (j = KC-1; j >= 0; j--)
190         {
191           *((u32*)tk[j]) = *((u32*)k[j]);
192         }
193       r = 0;
194       t = 0;
195       /* Copy values into round key array.  */
196       for (j = 0; (j < KC) && (r < ROUNDS + 1); )
197         {
198           for (; (j < KC) && (t < 4); j++, t++)
199             {
200               *((u32*)W[r][t]) = *((u32*)tk[j]);
201             }
202           if (t == 4)
203             {
204               r++;
205               t = 0;
206             }
207         }
208
209       while (r < ROUNDS + 1)
210         {
211           /* While not enough round key material calculated calculate
212              new values.  */
213           tk[0][0] ^= S[tk[KC-1][1]];
214           tk[0][1] ^= S[tk[KC-1][2]];
215           tk[0][2] ^= S[tk[KC-1][3]];
216           tk[0][3] ^= S[tk[KC-1][0]];
217           tk[0][0] ^= rcon[rconpointer++];
218
219           if (KC != 8)
220             {
221               for (j = 1; j < KC; j++)
222                 {
223                   *((u32*)tk[j]) ^= *((u32*)tk[j-1]);
224                 }
225             }
226           else
227             {
228               for (j = 1; j < KC/2; j++)
229                 {
230                   *((u32*)tk[j]) ^= *((u32*)tk[j-1]);
231                 }
232               tk[KC/2][0] ^= S[tk[KC/2 - 1][0]];
233               tk[KC/2][1] ^= S[tk[KC/2 - 1][1]];
234               tk[KC/2][2] ^= S[tk[KC/2 - 1][2]];
235               tk[KC/2][3] ^= S[tk[KC/2 - 1][3]];
236               for (j = KC/2 + 1; j < KC; j++)
237                 {
238                   *((u32*)tk[j]) ^= *((u32*)tk[j-1]);
239                 }
240             }
241
242           /* Copy values into round key array.  */
243           for (j = 0; (j < KC) && (r < ROUNDS + 1); )
244             {
245               for (; (j < KC) && (t < 4); j++, t++)
246                 {
247                   *((u32*)W[r][t]) = *((u32*)tk[j]);
248                 }
249               if (t == 4)
250                 {
251                   r++;
252                   t = 0;
253                 }
254             }
255         }
256 #undef W
257     }
258
259   return 0;
260 #undef tk
261 #undef k
262 }
263
264
265 static gcry_err_code_t
266 rijndael_setkey (void *context, const byte *key, const unsigned keylen)
267 {
268   RIJNDAEL_context *ctx = context;
269
270   int rc = do_setkey (ctx, key, keylen);
271   _gcry_burn_stack ( 100 + 16*sizeof(int));
272   return rc;
273 }
274
275
276 /* Make a decryption key from an encryption key. */
277 static void
278 prepare_decryption( RIJNDAEL_context *ctx )
279 {
280   int r;
281   union
282   {
283     PROPERLY_ALIGNED_TYPE dummy;
284     byte *w;
285   } w;
286 #define w w.w
287
288   for (r=0; r < MAXROUNDS+1; r++ )
289     {
290       *((u32*)ctx->keySched2[r][0]) = *((u32*)ctx->keySched[r][0]);
291       *((u32*)ctx->keySched2[r][1]) = *((u32*)ctx->keySched[r][1]);
292       *((u32*)ctx->keySched2[r][2]) = *((u32*)ctx->keySched[r][2]);
293       *((u32*)ctx->keySched2[r][3]) = *((u32*)ctx->keySched[r][3]);
294     }
295 #define W (ctx->keySched2)
296   for (r = 1; r < ctx->ROUNDS; r++)
297     {
298       w = W[r][0];
299       *((u32*)w) = *((u32*)U1[w[0]]) ^ *((u32*)U2[w[1]])
300         ^ *((u32*)U3[w[2]]) ^ *((u32*)U4[w[3]]);
301
302       w = W[r][1];
303       *((u32*)w) = *((u32*)U1[w[0]]) ^ *((u32*)U2[w[1]])
304         ^ *((u32*)U3[w[2]]) ^ *((u32*)U4[w[3]]);
305
306       w = W[r][2];
307       *((u32*)w) = *((u32*)U1[w[0]]) ^ *((u32*)U2[w[1]])
308         ^ *((u32*)U3[w[2]]) ^ *((u32*)U4[w[3]]);
309
310       w = W[r][3];
311       *((u32*)w) = *((u32*)U1[w[0]]) ^ *((u32*)U2[w[1]])
312         ^ *((u32*)U3[w[2]]) ^ *((u32*)U4[w[3]]);
313     }
314 #undef W
315 #undef w
316 }
317
318
319 \f
320 /* Encrypt one block.  A and B need to be aligned on a 4 byte
321    boundary.  A and B may be the same. */
322 static void
323 do_encrypt_aligned (const RIJNDAEL_context *ctx,
324                     unsigned char *b, const unsigned char *a)
325 {
326 #define rk (ctx->keySched)
327   int ROUNDS = ctx->ROUNDS;
328   int r;
329   union
330   {
331     u32  tempu32[4];  /* Force correct alignment. */
332     byte temp[4][4];
333   } u;
334
335   *((u32*)u.temp[0]) = *((u32*)(a   )) ^ *((u32*)rk[0][0]);
336   *((u32*)u.temp[1]) = *((u32*)(a+ 4)) ^ *((u32*)rk[0][1]);
337   *((u32*)u.temp[2]) = *((u32*)(a+ 8)) ^ *((u32*)rk[0][2]);
338   *((u32*)u.temp[3]) = *((u32*)(a+12)) ^ *((u32*)rk[0][3]);
339   *((u32*)(b    ))   = (*((u32*)T1[u.temp[0][0]])
340                         ^ *((u32*)T2[u.temp[1][1]])
341                         ^ *((u32*)T3[u.temp[2][2]])
342                         ^ *((u32*)T4[u.temp[3][3]]));
343   *((u32*)(b + 4))   = (*((u32*)T1[u.temp[1][0]])
344                         ^ *((u32*)T2[u.temp[2][1]])
345                         ^ *((u32*)T3[u.temp[3][2]])
346                         ^ *((u32*)T4[u.temp[0][3]]));
347   *((u32*)(b + 8))   = (*((u32*)T1[u.temp[2][0]])
348                         ^ *((u32*)T2[u.temp[3][1]])
349                         ^ *((u32*)T3[u.temp[0][2]])
350                         ^ *((u32*)T4[u.temp[1][3]]));
351   *((u32*)(b +12))   = (*((u32*)T1[u.temp[3][0]])
352                         ^ *((u32*)T2[u.temp[0][1]])
353                         ^ *((u32*)T3[u.temp[1][2]])
354                         ^ *((u32*)T4[u.temp[2][3]]));
355
356   for (r = 1; r < ROUNDS-1; r++)
357     {
358       *((u32*)u.temp[0]) = *((u32*)(b   )) ^ *((u32*)rk[r][0]);
359       *((u32*)u.temp[1]) = *((u32*)(b+ 4)) ^ *((u32*)rk[r][1]);
360       *((u32*)u.temp[2]) = *((u32*)(b+ 8)) ^ *((u32*)rk[r][2]);
361       *((u32*)u.temp[3]) = *((u32*)(b+12)) ^ *((u32*)rk[r][3]);
362
363       *((u32*)(b    ))   = (*((u32*)T1[u.temp[0][0]])
364                             ^ *((u32*)T2[u.temp[1][1]])
365                             ^ *((u32*)T3[u.temp[2][2]])
366                             ^ *((u32*)T4[u.temp[3][3]]));
367       *((u32*)(b + 4))   = (*((u32*)T1[u.temp[1][0]])
368                             ^ *((u32*)T2[u.temp[2][1]])
369                             ^ *((u32*)T3[u.temp[3][2]])
370                             ^ *((u32*)T4[u.temp[0][3]]));
371       *((u32*)(b + 8))   = (*((u32*)T1[u.temp[2][0]])
372                             ^ *((u32*)T2[u.temp[3][1]])
373                             ^ *((u32*)T3[u.temp[0][2]])
374                             ^ *((u32*)T4[u.temp[1][3]]));
375       *((u32*)(b +12))   = (*((u32*)T1[u.temp[3][0]])
376                             ^ *((u32*)T2[u.temp[0][1]])
377                             ^ *((u32*)T3[u.temp[1][2]])
378                             ^ *((u32*)T4[u.temp[2][3]]));
379     }
380
381   /* Last round is special. */
382   *((u32*)u.temp[0]) = *((u32*)(b   )) ^ *((u32*)rk[ROUNDS-1][0]);
383   *((u32*)u.temp[1]) = *((u32*)(b+ 4)) ^ *((u32*)rk[ROUNDS-1][1]);
384   *((u32*)u.temp[2]) = *((u32*)(b+ 8)) ^ *((u32*)rk[ROUNDS-1][2]);
385   *((u32*)u.temp[3]) = *((u32*)(b+12)) ^ *((u32*)rk[ROUNDS-1][3]);
386   b[ 0] = T1[u.temp[0][0]][1];
387   b[ 1] = T1[u.temp[1][1]][1];
388   b[ 2] = T1[u.temp[2][2]][1];
389   b[ 3] = T1[u.temp[3][3]][1];
390   b[ 4] = T1[u.temp[1][0]][1];
391   b[ 5] = T1[u.temp[2][1]][1];
392   b[ 6] = T1[u.temp[3][2]][1];
393   b[ 7] = T1[u.temp[0][3]][1];
394   b[ 8] = T1[u.temp[2][0]][1];
395   b[ 9] = T1[u.temp[3][1]][1];
396   b[10] = T1[u.temp[0][2]][1];
397   b[11] = T1[u.temp[1][3]][1];
398   b[12] = T1[u.temp[3][0]][1];
399   b[13] = T1[u.temp[0][1]][1];
400   b[14] = T1[u.temp[1][2]][1];
401   b[15] = T1[u.temp[2][3]][1];
402   *((u32*)(b   )) ^= *((u32*)rk[ROUNDS][0]);
403   *((u32*)(b+ 4)) ^= *((u32*)rk[ROUNDS][1]);
404   *((u32*)(b+ 8)) ^= *((u32*)rk[ROUNDS][2]);
405   *((u32*)(b+12)) ^= *((u32*)rk[ROUNDS][3]);
406 #undef rk
407 }
408
409
410 static void
411 do_encrypt (const RIJNDAEL_context *ctx,
412             unsigned char *bx, const unsigned char *ax)
413 {
414   /* BX and AX are not necessary correctly aligned.  Thus we need to
415      copy them here. */
416   union
417   {
418     u32  dummy[4];
419     byte a[16];
420   } a;
421   union
422   {
423     u32  dummy[4];
424     byte b[16];
425   } b;
426
427   memcpy (a.a, ax, 16);
428   do_encrypt_aligned (ctx, b.b, a.a);
429   memcpy (bx, b.b, 16);
430 }
431
432
433 /* Encrypt or decrypt one block using the padlock engine.  A and B may
434    be the same. */
435 #ifdef USE_PADLOCK
436 static void
437 do_padlock (const RIJNDAEL_context *ctx, int decrypt_flag,
438             unsigned char *bx, const unsigned char *ax)
439 {
440   /* BX and AX are not necessary correctly aligned.  Thus we need to
441      copy them here. */
442   unsigned char a[16] __attribute__ ((aligned (16)));
443   unsigned char b[16] __attribute__ ((aligned (16)));
444   unsigned int cword[4] __attribute__ ((aligned (16)));
445
446   /* The control word fields are:
447       127:12   11:10 9     8     7     6     5     4     3:0
448       RESERVED KSIZE CRYPT INTER KEYGN CIPHR ALIGN DGEST ROUND  */
449   cword[0] = (ctx->ROUNDS & 15);  /* (The mask is just a safeguard.)  */
450   cword[1] = 0;
451   cword[2] = 0;
452   cword[3] = 0;
453   if (decrypt_flag)
454     cword[0] |= 0x00000200;
455
456   memcpy (a, ax, 16);
457
458   asm volatile
459     ("pushfl\n\t"          /* Force key reload.  */
460      "popfl\n\t"
461      "xchg %3, %%ebx\n\t"  /* Load key.  */
462      "movl $1, %%ecx\n\t"  /* Init counter for just one block.  */
463      ".byte 0xf3, 0x0f, 0xa7, 0xc8\n\t" /* REP XSTORE ECB. */
464      "xchg %3, %%ebx\n"    /* Restore GOT register.  */
465      : /* No output */
466      : "S" (a), "D" (b), "d" (cword), "r" (ctx->padlock_key)
467      : "%ecx", "cc", "memory"
468      );
469
470   memcpy (bx, b, 16);
471
472 }
473 #endif /*USE_PADLOCK*/
474
475
476 static void
477 rijndael_encrypt (void *context, byte *b, const byte *a)
478 {
479   RIJNDAEL_context *ctx = context;
480
481 #ifdef USE_PADLOCK
482   if (ctx->use_padlock)
483     {
484       do_padlock (ctx, 0, b, a);
485       _gcry_burn_stack (48 + 15 /* possible padding for alignment */);
486     }
487   else
488 #endif /*USE_PADLOCK*/
489     {
490       do_encrypt (ctx, b, a);
491       _gcry_burn_stack (48 + 2*sizeof(int));
492     }
493 }
494
495
496 /* Bulk encryption of complete blocks in CFB mode.  Caller needs to
497    make sure that IV is aligned on an unsigned long boundary.  This
498    function is only intended for the bulk encryption feature of
499    cipher.c. */
500 void
501 _gcry_aes_cfb_enc (void *context, unsigned char *iv,
502                    void *outbuf_arg, const void *inbuf_arg,
503                    unsigned int nblocks)
504 {
505   RIJNDAEL_context *ctx = context;
506   unsigned char *outbuf = outbuf_arg;
507   const unsigned char *inbuf = inbuf_arg;
508   unsigned char *ivp;
509   int i;
510
511 #ifdef USE_PADLOCK
512   if (ctx->use_padlock)
513     {
514       /* Fixme: Let Padlock do the CFBing.  */
515       for ( ;nblocks; nblocks-- )
516         {
517           /* Encrypt the IV. */
518           do_padlock (ctx, 0, iv, iv);
519           /* XOR the input with the IV and store input into IV.  */
520           for (ivp=iv,i=0; i < BLOCKSIZE; i++ )
521             *outbuf++ = (*ivp++ ^= *inbuf++);
522         }
523     }
524   else
525 #endif /* USE_PADLOCK*/
526     {
527       for ( ;nblocks; nblocks-- )
528         {
529           /* Encrypt the IV. */
530           do_encrypt_aligned (ctx, iv, iv);
531           /* XOR the input with the IV and store input into IV.  */
532           for (ivp=iv,i=0; i < BLOCKSIZE; i++ )
533             *outbuf++ = (*ivp++ ^= *inbuf++);
534         }
535     }
536
537   _gcry_burn_stack (48 + 2*sizeof(int));
538 }
539
540
541 /* Bulk encryption of complete blocks in CBC mode.  Caller needs to
542    make sure that IV is aligned on an unsigned long boundary.  This
543    function is only intended for the bulk encryption feature of
544    cipher.c. */
545 void
546 _gcry_aes_cbc_enc (void *context, unsigned char *iv,
547                    void *outbuf_arg, const void *inbuf_arg,
548                    unsigned int nblocks, int cbc_mac)
549 {
550   RIJNDAEL_context *ctx = context;
551   unsigned char *outbuf = outbuf_arg;
552   const unsigned char *inbuf = inbuf_arg;
553   unsigned char *ivp;
554   int i;
555
556   for ( ;nblocks; nblocks-- )
557     {
558       for (ivp=iv, i=0; i < BLOCKSIZE; i++ )
559         outbuf[i] = inbuf[i] ^ *ivp++;
560
561 #ifdef USE_PADLOCK
562       if (ctx->use_padlock)
563         do_padlock (ctx, 0, outbuf, outbuf);
564       else
565 #endif /*USE_PADLOCK*/
566         do_encrypt (ctx, outbuf, outbuf );
567
568       memcpy (iv, outbuf, BLOCKSIZE);
569       inbuf += BLOCKSIZE;
570       if (!cbc_mac)
571         outbuf += BLOCKSIZE;
572     }
573
574   _gcry_burn_stack (48 + 2*sizeof(int));
575 }
576
577
578 \f
579 /* Decrypt one block.  A and B need to be aligned on a 4 byte boundary
580    and the decryption must have been prepared.  A and B may be the
581    same. */
582 static void
583 do_decrypt_aligned (RIJNDAEL_context *ctx,
584                     unsigned char *b, const unsigned char *a)
585 {
586 #define rk  (ctx->keySched2)
587   int ROUNDS = ctx->ROUNDS;
588   int r;
589   union
590   {
591     u32  tempu32[4];  /* Force correct alignment. */
592     byte temp[4][4];
593   } u;
594
595
596   *((u32*)u.temp[0]) = *((u32*)(a   )) ^ *((u32*)rk[ROUNDS][0]);
597   *((u32*)u.temp[1]) = *((u32*)(a+ 4)) ^ *((u32*)rk[ROUNDS][1]);
598   *((u32*)u.temp[2]) = *((u32*)(a+ 8)) ^ *((u32*)rk[ROUNDS][2]);
599   *((u32*)u.temp[3]) = *((u32*)(a+12)) ^ *((u32*)rk[ROUNDS][3]);
600
601   *((u32*)(b   ))    = (*((u32*)T5[u.temp[0][0]])
602                         ^ *((u32*)T6[u.temp[3][1]])
603                         ^ *((u32*)T7[u.temp[2][2]])
604                         ^ *((u32*)T8[u.temp[1][3]]));
605   *((u32*)(b+ 4))    = (*((u32*)T5[u.temp[1][0]])
606                         ^ *((u32*)T6[u.temp[0][1]])
607                         ^ *((u32*)T7[u.temp[3][2]])
608                         ^ *((u32*)T8[u.temp[2][3]]));
609   *((u32*)(b+ 8))    = (*((u32*)T5[u.temp[2][0]])
610                         ^ *((u32*)T6[u.temp[1][1]])
611                         ^ *((u32*)T7[u.temp[0][2]])
612                         ^ *((u32*)T8[u.temp[3][3]]));
613   *((u32*)(b+12))    = (*((u32*)T5[u.temp[3][0]])
614                         ^ *((u32*)T6[u.temp[2][1]])
615                         ^ *((u32*)T7[u.temp[1][2]])
616                         ^ *((u32*)T8[u.temp[0][3]]));
617
618   for (r = ROUNDS-1; r > 1; r--)
619     {
620       *((u32*)u.temp[0]) = *((u32*)(b   )) ^ *((u32*)rk[r][0]);
621       *((u32*)u.temp[1]) = *((u32*)(b+ 4)) ^ *((u32*)rk[r][1]);
622       *((u32*)u.temp[2]) = *((u32*)(b+ 8)) ^ *((u32*)rk[r][2]);
623       *((u32*)u.temp[3]) = *((u32*)(b+12)) ^ *((u32*)rk[r][3]);
624       *((u32*)(b   ))    = (*((u32*)T5[u.temp[0][0]])
625                             ^ *((u32*)T6[u.temp[3][1]])
626                             ^ *((u32*)T7[u.temp[2][2]])
627                             ^ *((u32*)T8[u.temp[1][3]]));
628       *((u32*)(b+ 4))    = (*((u32*)T5[u.temp[1][0]])
629                             ^ *((u32*)T6[u.temp[0][1]])
630                             ^ *((u32*)T7[u.temp[3][2]])
631                             ^ *((u32*)T8[u.temp[2][3]]));
632       *((u32*)(b+ 8))    = (*((u32*)T5[u.temp[2][0]])
633                             ^ *((u32*)T6[u.temp[1][1]])
634                             ^ *((u32*)T7[u.temp[0][2]])
635                             ^ *((u32*)T8[u.temp[3][3]]));
636       *((u32*)(b+12))    = (*((u32*)T5[u.temp[3][0]])
637                             ^ *((u32*)T6[u.temp[2][1]])
638                             ^ *((u32*)T7[u.temp[1][2]])
639                             ^ *((u32*)T8[u.temp[0][3]]));
640     }
641
642   /* Last round is special. */
643   *((u32*)u.temp[0]) = *((u32*)(b   )) ^ *((u32*)rk[1][0]);
644   *((u32*)u.temp[1]) = *((u32*)(b+ 4)) ^ *((u32*)rk[1][1]);
645   *((u32*)u.temp[2]) = *((u32*)(b+ 8)) ^ *((u32*)rk[1][2]);
646   *((u32*)u.temp[3]) = *((u32*)(b+12)) ^ *((u32*)rk[1][3]);
647   b[ 0] = S5[u.temp[0][0]];
648   b[ 1] = S5[u.temp[3][1]];
649   b[ 2] = S5[u.temp[2][2]];
650   b[ 3] = S5[u.temp[1][3]];
651   b[ 4] = S5[u.temp[1][0]];
652   b[ 5] = S5[u.temp[0][1]];
653   b[ 6] = S5[u.temp[3][2]];
654   b[ 7] = S5[u.temp[2][3]];
655   b[ 8] = S5[u.temp[2][0]];
656   b[ 9] = S5[u.temp[1][1]];
657   b[10] = S5[u.temp[0][2]];
658   b[11] = S5[u.temp[3][3]];
659   b[12] = S5[u.temp[3][0]];
660   b[13] = S5[u.temp[2][1]];
661   b[14] = S5[u.temp[1][2]];
662   b[15] = S5[u.temp[0][3]];
663   *((u32*)(b   )) ^= *((u32*)rk[0][0]);
664   *((u32*)(b+ 4)) ^= *((u32*)rk[0][1]);
665   *((u32*)(b+ 8)) ^= *((u32*)rk[0][2]);
666   *((u32*)(b+12)) ^= *((u32*)rk[0][3]);
667 #undef rk
668 }
669
670
671 /* Decrypt one block.  AX and BX may be the same. */
672 static void
673 do_decrypt (RIJNDAEL_context *ctx, byte *bx, const byte *ax)
674 {
675   /* BX and AX are not necessary correctly aligned.  Thus we need to
676      copy them here. */
677   union
678   {
679     u32  dummy[4];
680     byte a[16];
681   } a;
682   union
683   {
684     u32  dummy[4];
685     byte b[16];
686   } b;
687
688   if ( !ctx->decryption_prepared )
689     {
690       prepare_decryption ( ctx );
691       _gcry_burn_stack (64);
692       ctx->decryption_prepared = 1;
693     }
694
695   memcpy (a.a, ax, 16);
696   do_decrypt_aligned (ctx, b.b, a.a);
697   memcpy (bx, b.b, 16);
698 #undef rk
699 }
700
701
702
703
704 static void
705 rijndael_decrypt (void *context, byte *b, const byte *a)
706 {
707   RIJNDAEL_context *ctx = context;
708
709 #ifdef USE_PADLOCK
710   if (ctx->use_padlock)
711     {
712       do_padlock (ctx, 1, b, a);
713       _gcry_burn_stack (48 + 2*sizeof(int) /* FIXME */);
714     }
715   else
716 #endif /*USE_PADLOCK*/
717     {
718       do_decrypt (ctx, b, a);
719       _gcry_burn_stack (48+2*sizeof(int));
720     }
721 }
722
723
724 /* Bulk decryption of complete blocks in CFB mode.  Caller needs to
725    make sure that IV is aligned on an unisgned lonhg boundary.  This
726    function is only intended for the bulk encryption feature of
727    cipher.c. */
728 void
729 _gcry_aes_cfb_dec (void *context, unsigned char *iv,
730                    void *outbuf_arg, const void *inbuf_arg,
731                    unsigned int nblocks)
732 {
733   RIJNDAEL_context *ctx = context;
734   unsigned char *outbuf = outbuf_arg;
735   const unsigned char *inbuf = inbuf_arg;
736   unsigned char *ivp;
737   unsigned char temp;
738   int i;
739
740 #ifdef USE_PADLOCK
741   if (ctx->use_padlock)
742     {
743       /* Fixme:  Let Padlock do the CFBing.  */
744       for ( ;nblocks; nblocks-- )
745         {
746           do_padlock (ctx, 0, iv, iv);
747           for (ivp=iv,i=0; i < BLOCKSIZE; i++ )
748             {
749               temp = *inbuf++;
750               *outbuf++ = *ivp ^ temp;
751               *ivp++ = temp;
752             }
753         }
754     }
755   else
756 #endif /*USE_PADLOCK*/
757     {
758       for ( ;nblocks; nblocks-- )
759         {
760           do_encrypt_aligned (ctx, iv, iv);
761           for (ivp=iv,i=0; i < BLOCKSIZE; i++ )
762             {
763               temp = *inbuf++;
764               *outbuf++ = *ivp ^ temp;
765               *ivp++ = temp;
766             }
767         }
768     }
769
770   _gcry_burn_stack (48 + 2*sizeof(int));
771 }
772
773
774 /* Bulk decryption of complete blocks in CBC mode.  Caller needs to
775    make sure that IV is aligned on an unsigned long boundary.  This
776    function is only intended for the bulk encryption feature of
777    cipher.c. */
778 void
779 _gcry_aes_cbc_dec (void *context, unsigned char *iv,
780                    void *outbuf_arg, const void *inbuf_arg,
781                    unsigned int nblocks)
782 {
783   RIJNDAEL_context *ctx = context;
784   unsigned char *outbuf = outbuf_arg;
785   const unsigned char *inbuf = inbuf_arg;
786   unsigned char *ivp;
787   int i;
788   unsigned char savebuf[BLOCKSIZE];
789
790   for ( ;nblocks; nblocks-- )
791     {
792       /* We need to save INBUF away because it may be identical to
793          OUTBUF.  */
794       memcpy (savebuf, inbuf, BLOCKSIZE);
795
796 #ifdef USE_PADLOCK
797       if (ctx->use_padlock)
798         do_padlock (ctx, 1, outbuf, inbuf);
799       else
800 #endif /*USE_PADLOCK*/
801         do_decrypt (ctx, outbuf, inbuf);
802
803       for (ivp=iv, i=0; i < BLOCKSIZE; i++ )
804         outbuf[i] ^= *ivp++;
805       memcpy (iv, savebuf, BLOCKSIZE);
806       inbuf += BLOCKSIZE;
807       outbuf += BLOCKSIZE;
808     }
809
810   _gcry_burn_stack (48 + 2*sizeof(int) + BLOCKSIZE + 4*sizeof (char*));
811 }
812
813
814
815 \f
816 /* Run the self-tests for AES 128.  Returns NULL on success. */
817 static const char*
818 selftest_basic_128 (void)
819 {
820   RIJNDAEL_context ctx;
821   unsigned char scratch[16];
822
823   /* The test vectors are from the AES supplied ones; more or less
824      randomly taken from ecb_tbl.txt (I=42,81,14) */
825   static const unsigned char plaintext_128[16] =
826     {
827       0x01,0x4B,0xAF,0x22,0x78,0xA6,0x9D,0x33,
828       0x1D,0x51,0x80,0x10,0x36,0x43,0xE9,0x9A
829     };
830   static const unsigned char key_128[16] =
831     {
832       0xE8,0xE9,0xEA,0xEB,0xED,0xEE,0xEF,0xF0,
833       0xF2,0xF3,0xF4,0xF5,0xF7,0xF8,0xF9,0xFA
834     };
835   static const unsigned char ciphertext_128[16] =
836     {
837       0x67,0x43,0xC3,0xD1,0x51,0x9A,0xB4,0xF2,
838       0xCD,0x9A,0x78,0xAB,0x09,0xA5,0x11,0xBD
839     };
840
841   rijndael_setkey (&ctx, key_128, sizeof (key_128));
842   rijndael_encrypt (&ctx, scratch, plaintext_128);
843   if (memcmp (scratch, ciphertext_128, sizeof (ciphertext_128)))
844      return "AES-128 test encryption failed.";
845   rijndael_decrypt (&ctx, scratch, scratch);
846   if (memcmp (scratch, plaintext_128, sizeof (plaintext_128)))
847     return "AES-128 test decryption failed.";
848
849   return NULL;
850 }
851
852 /* Run the self-tests for AES 192.  Returns NULL on success. */
853 static const char*
854 selftest_basic_192 (void)
855 {
856   RIJNDAEL_context ctx;
857   unsigned char scratch[16];
858
859   static unsigned char plaintext_192[16] =
860     {
861       0x76,0x77,0x74,0x75,0xF1,0xF2,0xF3,0xF4,
862       0xF8,0xF9,0xE6,0xE7,0x77,0x70,0x71,0x72
863     };
864   static unsigned char key_192[24] =
865     {
866       0x04,0x05,0x06,0x07,0x09,0x0A,0x0B,0x0C,
867       0x0E,0x0F,0x10,0x11,0x13,0x14,0x15,0x16,
868       0x18,0x19,0x1A,0x1B,0x1D,0x1E,0x1F,0x20
869     };
870   static const unsigned char ciphertext_192[16] =
871     {
872       0x5D,0x1E,0xF2,0x0D,0xCE,0xD6,0xBC,0xBC,
873       0x12,0x13,0x1A,0xC7,0xC5,0x47,0x88,0xAA
874     };
875
876   rijndael_setkey (&ctx, key_192, sizeof(key_192));
877   rijndael_encrypt (&ctx, scratch, plaintext_192);
878   if (memcmp (scratch, ciphertext_192, sizeof (ciphertext_192)))
879     return "AES-192 test encryption failed.";
880   rijndael_decrypt (&ctx, scratch, scratch);
881   if (memcmp (scratch, plaintext_192, sizeof (plaintext_192)))
882     return "AES-192 test decryption failed.";
883
884   return NULL;
885 }
886
887
888 /* Run the self-tests for AES 256.  Returns NULL on success. */
889 static const char*
890 selftest_basic_256 (void)
891 {
892   RIJNDAEL_context ctx;
893   unsigned char scratch[16];
894
895   static unsigned char plaintext_256[16] =
896     {
897       0x06,0x9A,0x00,0x7F,0xC7,0x6A,0x45,0x9F,
898       0x98,0xBA,0xF9,0x17,0xFE,0xDF,0x95,0x21
899     };
900   static unsigned char key_256[32] =
901     {
902       0x08,0x09,0x0A,0x0B,0x0D,0x0E,0x0F,0x10,
903       0x12,0x13,0x14,0x15,0x17,0x18,0x19,0x1A,
904       0x1C,0x1D,0x1E,0x1F,0x21,0x22,0x23,0x24,
905       0x26,0x27,0x28,0x29,0x2B,0x2C,0x2D,0x2E
906     };
907   static const unsigned char ciphertext_256[16] =
908     {
909       0x08,0x0E,0x95,0x17,0xEB,0x16,0x77,0x71,
910       0x9A,0xCF,0x72,0x80,0x86,0x04,0x0A,0xE3
911     };
912
913   rijndael_setkey (&ctx, key_256, sizeof(key_256));
914   rijndael_encrypt (&ctx, scratch, plaintext_256);
915   if (memcmp (scratch, ciphertext_256, sizeof (ciphertext_256)))
916     return "AES-256 test encryption failed.";
917   rijndael_decrypt (&ctx, scratch, scratch);
918   if (memcmp (scratch, plaintext_256, sizeof (plaintext_256)))
919     return "AES-256 test decryption failed.";
920
921   return NULL;
922 }
923
924 /* Run all the self-tests and return NULL on success.  This function
925    is used for the on-the-fly self-tests. */
926 static const char *
927 selftest (void)
928 {
929   const char *r;
930
931   if ( (r = selftest_basic_128 ())
932        || (r = selftest_basic_192 ())
933        || (r = selftest_basic_256 ()) )
934     return r;
935
936   return r;
937 }
938
939
940 /* SP800-38a.pdf for AES-128.  */
941 static const char *
942 selftest_fips_128_38a (int requested_mode)
943 {
944   struct tv
945   {
946     int mode;
947     const unsigned char key[16];
948     const unsigned char iv[16];
949     struct
950     {
951       const unsigned char input[16];
952       const unsigned char output[16];
953     } data[4];
954   } tv[2] =
955     {
956       {
957         GCRY_CIPHER_MODE_CFB,  /* F.3.13, CFB128-AES128 */
958         { 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
959           0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c },
960         { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
961           0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
962         {
963           { { 0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
964               0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a },
965             { 0x3b, 0x3f, 0xd9, 0x2e, 0xb7, 0x2d, 0xad, 0x20,
966               0x33, 0x34, 0x49, 0xf8, 0xe8, 0x3c, 0xfb, 0x4a } },
967
968           { { 0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
969               0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51 },
970             { 0xc8, 0xa6, 0x45, 0x37, 0xa0, 0xb3, 0xa9, 0x3f,
971               0xcd, 0xe3, 0xcd, 0xad, 0x9f, 0x1c, 0xe5, 0x8b } },
972
973           { { 0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
974               0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef },
975             { 0x26, 0x75, 0x1f, 0x67, 0xa3, 0xcb, 0xb1, 0x40,
976               0xb1, 0x80, 0x8c, 0xf1, 0x87, 0xa4, 0xf4, 0xdf } },
977
978           { { 0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
979               0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10 },
980             { 0xc0, 0x4b, 0x05, 0x35, 0x7c, 0x5d, 0x1c, 0x0e,
981               0xea, 0xc4, 0xc6, 0x6f, 0x9f, 0xf7, 0xf2, 0xe6 } }
982         }
983       },
984       {
985         GCRY_CIPHER_MODE_OFB,
986         { 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
987           0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c },
988         { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
989           0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
990         {
991           { { 0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
992               0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a },
993             { 0x3b, 0x3f, 0xd9, 0x2e, 0xb7, 0x2d, 0xad, 0x20,
994               0x33, 0x34, 0x49, 0xf8, 0xe8, 0x3c, 0xfb, 0x4a } },
995
996           { { 0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
997               0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51 },
998             { 0x77, 0x89, 0x50, 0x8d, 0x16, 0x91, 0x8f, 0x03,
999               0xf5, 0x3c, 0x52, 0xda, 0xc5, 0x4e, 0xd8, 0x25 } },
1000
1001           { { 0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
1002               0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef },
1003             { 0x97, 0x40, 0x05, 0x1e, 0x9c, 0x5f, 0xec, 0xf6,
1004               0x43, 0x44, 0xf7, 0xa8, 0x22, 0x60, 0xed, 0xcc } },
1005
1006           { { 0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
1007               0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10 },
1008             { 0x30, 0x4c, 0x65, 0x28, 0xf6, 0x59, 0xc7, 0x78,
1009               0x66, 0xa5, 0x10, 0xd9, 0xc1, 0xd6, 0xae, 0x5e } },
1010         }
1011       }
1012     };
1013   unsigned char scratch[16];
1014   gpg_error_t err;
1015   int tvi, idx;
1016   gcry_cipher_hd_t hdenc = NULL;
1017   gcry_cipher_hd_t hddec = NULL;
1018
1019 #define Fail(a) do {           \
1020     _gcry_cipher_close (hdenc);  \
1021     _gcry_cipher_close (hddec);  \
1022     return a;                    \
1023   } while (0)
1024
1025   gcry_assert (sizeof tv[0].data[0].input == sizeof scratch);
1026   gcry_assert (sizeof tv[0].data[0].output == sizeof scratch);
1027
1028   for (tvi=0; tvi < DIM (tv); tvi++)
1029     if (tv[tvi].mode == requested_mode)
1030       break;
1031   if (tvi == DIM (tv))
1032     Fail ("no test data for this mode");
1033
1034   err = _gcry_cipher_open (&hdenc, GCRY_CIPHER_AES, tv[tvi].mode, 0);
1035   if (err)
1036     Fail ("open");
1037   err = _gcry_cipher_open (&hddec, GCRY_CIPHER_AES, tv[tvi].mode, 0);
1038   if (err)
1039     Fail ("open");
1040   err = _gcry_cipher_setkey (hdenc, tv[tvi].key,  sizeof tv[tvi].key);
1041   if (!err)
1042     err = _gcry_cipher_setkey (hddec, tv[tvi].key, sizeof tv[tvi].key);
1043   if (err)
1044     Fail ("set key");
1045   err = _gcry_cipher_setiv (hdenc, tv[tvi].iv, sizeof tv[tvi].iv);
1046   if (!err)
1047     err = _gcry_cipher_setiv (hddec, tv[tvi].iv, sizeof tv[tvi].iv);
1048   if (err)
1049     Fail ("set IV");
1050   for (idx=0; idx < DIM (tv[tvi].data); idx++)
1051     {
1052       err = _gcry_cipher_encrypt (hdenc, scratch, sizeof scratch,
1053                                   tv[tvi].data[idx].input,
1054                                   sizeof tv[tvi].data[idx].input);
1055       if (err)
1056         Fail ("encrypt command");
1057       if (memcmp (scratch, tv[tvi].data[idx].output, sizeof scratch))
1058         Fail ("encrypt mismatch");
1059       err = _gcry_cipher_decrypt (hddec, scratch, sizeof scratch,
1060                                   tv[tvi].data[idx].output,
1061                                   sizeof tv[tvi].data[idx].output);
1062       if (err)
1063         Fail ("decrypt command");
1064       if (memcmp (scratch, tv[tvi].data[idx].input, sizeof scratch))
1065         Fail ("decrypt mismatch");
1066     }
1067
1068 #undef Fail
1069   _gcry_cipher_close (hdenc);
1070   _gcry_cipher_close (hddec);
1071   return NULL;
1072 }
1073
1074
1075 /* Complete selftest for AES-128 with all modes and driver code.  */
1076 static gpg_err_code_t
1077 selftest_fips_128 (int extended, selftest_report_func_t report)
1078 {
1079   const char *what;
1080   const char *errtxt;
1081
1082   what = "low-level";
1083   errtxt = selftest_basic_128 ();
1084   if (errtxt)
1085     goto failed;
1086
1087   if (extended)
1088     {
1089       what = "cfb";
1090       errtxt = selftest_fips_128_38a (GCRY_CIPHER_MODE_CFB);
1091       if (errtxt)
1092         goto failed;
1093
1094       what = "ofb";
1095       errtxt = selftest_fips_128_38a (GCRY_CIPHER_MODE_OFB);
1096       if (errtxt)
1097         goto failed;
1098     }
1099
1100   return 0; /* Succeeded. */
1101
1102  failed:
1103   if (report)
1104     report ("cipher", GCRY_CIPHER_AES128, what, errtxt);
1105   return GPG_ERR_SELFTEST_FAILED;
1106 }
1107
1108 /* Complete selftest for AES-192.  */
1109 static gpg_err_code_t
1110 selftest_fips_192 (int extended, selftest_report_func_t report)
1111 {
1112   const char *what;
1113   const char *errtxt;
1114
1115   (void)extended; /* No extended tests available.  */
1116
1117   what = "low-level";
1118   errtxt = selftest_basic_192 ();
1119   if (errtxt)
1120     goto failed;
1121
1122
1123   return 0; /* Succeeded. */
1124
1125  failed:
1126   if (report)
1127     report ("cipher", GCRY_CIPHER_AES192, what, errtxt);
1128   return GPG_ERR_SELFTEST_FAILED;
1129 }
1130
1131
1132 /* Complete selftest for AES-256.  */
1133 static gpg_err_code_t
1134 selftest_fips_256 (int extended, selftest_report_func_t report)
1135 {
1136   const char *what;
1137   const char *errtxt;
1138
1139   (void)extended; /* No extended tests available.  */
1140
1141   what = "low-level";
1142   errtxt = selftest_basic_256 ();
1143   if (errtxt)
1144     goto failed;
1145
1146   return 0; /* Succeeded. */
1147
1148  failed:
1149   if (report)
1150     report ("cipher", GCRY_CIPHER_AES256, what, errtxt);
1151   return GPG_ERR_SELFTEST_FAILED;
1152 }
1153
1154
1155
1156 /* Run a full self-test for ALGO and return 0 on success.  */
1157 static gpg_err_code_t
1158 run_selftests (int algo, int extended, selftest_report_func_t report)
1159 {
1160   gpg_err_code_t ec;
1161
1162   switch (algo)
1163     {
1164     case GCRY_CIPHER_AES128:
1165       ec = selftest_fips_128 (extended, report);
1166       break;
1167     case GCRY_CIPHER_AES192:
1168       ec = selftest_fips_192 (extended, report);
1169       break;
1170     case GCRY_CIPHER_AES256:
1171       ec = selftest_fips_256 (extended, report);
1172       break;
1173     default:
1174       ec = GPG_ERR_CIPHER_ALGO;
1175       break;
1176
1177     }
1178   return ec;
1179 }
1180
1181
1182 \f
1183
1184 static const char *rijndael_names[] =
1185   {
1186     "RIJNDAEL",
1187     "AES128",
1188     "AES-128",
1189     NULL
1190   };
1191
1192 static gcry_cipher_oid_spec_t rijndael_oids[] =
1193   {
1194     { "2.16.840.1.101.3.4.1.1", GCRY_CIPHER_MODE_ECB },
1195     { "2.16.840.1.101.3.4.1.2", GCRY_CIPHER_MODE_CBC },
1196     { "2.16.840.1.101.3.4.1.3", GCRY_CIPHER_MODE_OFB },
1197     { "2.16.840.1.101.3.4.1.4", GCRY_CIPHER_MODE_CFB },
1198     { NULL }
1199   };
1200
1201 gcry_cipher_spec_t _gcry_cipher_spec_aes =
1202   {
1203     "AES", rijndael_names, rijndael_oids, 16, 128, sizeof (RIJNDAEL_context),
1204     rijndael_setkey, rijndael_encrypt, rijndael_decrypt
1205   };
1206 cipher_extra_spec_t _gcry_cipher_extraspec_aes =
1207   {
1208     run_selftests
1209   };
1210
1211 static const char *rijndael192_names[] =
1212   {
1213     "RIJNDAEL192",
1214     "AES-192",
1215     NULL
1216   };
1217
1218 static gcry_cipher_oid_spec_t rijndael192_oids[] =
1219   {
1220     { "2.16.840.1.101.3.4.1.21", GCRY_CIPHER_MODE_ECB },
1221     { "2.16.840.1.101.3.4.1.22", GCRY_CIPHER_MODE_CBC },
1222     { "2.16.840.1.101.3.4.1.23", GCRY_CIPHER_MODE_OFB },
1223     { "2.16.840.1.101.3.4.1.24", GCRY_CIPHER_MODE_CFB },
1224     { NULL }
1225   };
1226
1227 gcry_cipher_spec_t _gcry_cipher_spec_aes192 =
1228   {
1229     "AES192", rijndael192_names, rijndael192_oids, 16, 192, sizeof (RIJNDAEL_context),
1230     rijndael_setkey, rijndael_encrypt, rijndael_decrypt
1231   };
1232 cipher_extra_spec_t _gcry_cipher_extraspec_aes192 =
1233   {
1234     run_selftests
1235   };
1236
1237 static const char *rijndael256_names[] =
1238   {
1239     "RIJNDAEL256",
1240     "AES-256",
1241     NULL
1242   };
1243
1244 static gcry_cipher_oid_spec_t rijndael256_oids[] =
1245   {
1246     { "2.16.840.1.101.3.4.1.41", GCRY_CIPHER_MODE_ECB },
1247     { "2.16.840.1.101.3.4.1.42", GCRY_CIPHER_MODE_CBC },
1248     { "2.16.840.1.101.3.4.1.43", GCRY_CIPHER_MODE_OFB },
1249     { "2.16.840.1.101.3.4.1.44", GCRY_CIPHER_MODE_CFB },
1250     { NULL }
1251   };
1252
1253 gcry_cipher_spec_t _gcry_cipher_spec_aes256 =
1254   {
1255     "AES256", rijndael256_names, rijndael256_oids, 16, 256,
1256     sizeof (RIJNDAEL_context),
1257     rijndael_setkey, rijndael_encrypt, rijndael_decrypt
1258   };
1259
1260 cipher_extra_spec_t _gcry_cipher_extraspec_aes256 =
1261   {
1262     run_selftests
1263   };