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