7f3fc7b9a3fd6da378bc19d59267ccc30e6fd485
[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
36 #include <config.h>
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <string.h> /* for memcmp() */
40
41 #include "types.h"  /* for byte and u32 typedefs */
42 #include "g10lib.h"
43 #include "cipher.h"
44
45 #define MAXKC                   (256/32)
46 #define MAXROUNDS               14
47 #define BLOCKSIZE               (128/8)
48
49
50 /* USE_PADLOCK indicates whether to compile the padlock specific
51    code.  */
52 #undef USE_PADLOCK
53 #ifdef ENABLE_PADLOCK_SUPPORT
54 # if defined (__i386__) && SIZEOF_UNSIGNED_LONG == 4 && defined (__GNUC__)
55 # define USE_PADLOCK
56 # endif
57 #endif /*ENABLE_PADLOCK_SUPPORT*/
58
59 static const char *selftest(void);
60
61 typedef struct 
62 {
63   int   ROUNDS;             /* Key-length-dependent number of rounds.  */
64   int decryption_prepared;  /* The decryption key schedule is available.  */
65 #ifdef USE_PADLOCK
66   int use_padlock;          /* Padlock shall be used.  */
67   /* The key as passed to the padlock engine.  */
68   unsigned char padlock_key[16] __attribute__ ((aligned (16)));
69 #endif
70   union
71   {
72     PROPERLY_ALIGNED_TYPE dummy;
73     byte keyschedule[MAXROUNDS+1][4][4];
74   } u1;
75   union
76   {
77     PROPERLY_ALIGNED_TYPE dummy;
78     byte keyschedule[MAXROUNDS+1][4][4];        
79   } u2;
80 } RIJNDAEL_context;
81
82 #define keySched  u1.keyschedule
83 #define keySched2 u2.keyschedule
84
85 /* All the numbers.  */
86 #include "rijndael-tables.h"
87
88
89 /* Perform the key setup.  */  
90 static gcry_err_code_t
91 do_setkey (RIJNDAEL_context *ctx, const byte *key, const unsigned keylen)
92 {
93   static int initialized = 0;
94   static const char *selftest_failed=0;
95   int ROUNDS;
96   byte k[MAXKC][4];
97   int i,j, r, t, rconpointer = 0;
98   byte tk[MAXKC][4];
99   int KC;
100   
101   if (!initialized)
102     {
103       initialized = 1;
104       selftest_failed = selftest ();
105       if( selftest_failed )
106         log_error ("%s\n", selftest_failed );
107     }
108   if( selftest_failed )
109     return GPG_ERR_SELFTEST_FAILED;
110
111   ctx->decryption_prepared = 0;
112 #ifdef USE_PADLOCK
113   ctx->use_padlock = 0;
114 #endif
115
116   if( keylen == 128/8 )
117     {
118       ROUNDS = 10;
119       KC = 4;
120 #ifdef USE_PADLOCK
121       if ((_gcry_get_hw_features () & HWF_PADLOCK_AES))
122         {
123           ctx->use_padlock = 1;
124           memcpy (ctx->padlock_key, key, keylen);
125         }
126 #endif
127     }
128   else if ( keylen == 192/8 )
129     {
130       ROUNDS = 12;
131       KC = 6;
132     }
133   else if ( keylen == 256/8 )
134     {
135       ROUNDS = 14;
136       KC = 8;
137     }
138   else
139     return GPG_ERR_INV_KEYLEN;
140
141   ctx->ROUNDS = ROUNDS;
142
143 #ifdef USE_PADLOCK
144   if (ctx->use_padlock)
145     {
146       /* Nothing to do as we support only hardware key generation for
147          now.  */
148     }
149   else
150 #endif /*USE_PADLOCK*/
151     {
152 #define W (ctx->keySched)
153       for (i = 0; i < keylen; i++) 
154         {
155           k[i >> 2][i & 3] = key[i]; 
156         }
157       
158       for (j = KC-1; j >= 0; j--) 
159         {
160           *((u32*)tk[j]) = *((u32*)k[j]);
161         }
162       r = 0;
163       t = 0;
164       /* Copy values into round key array.  */
165       for (j = 0; (j < KC) && (r < ROUNDS + 1); )
166         {
167           for (; (j < KC) && (t < 4); j++, t++)
168             {
169               *((u32*)W[r][t]) = *((u32*)tk[j]);
170             }
171           if (t == 4)
172             {
173               r++;
174               t = 0;
175             }
176         }
177       
178       while (r < ROUNDS + 1)
179         {
180           /* While not enough round key material calculated calculate
181              new values.  */
182           tk[0][0] ^= S[tk[KC-1][1]];
183           tk[0][1] ^= S[tk[KC-1][2]];
184           tk[0][2] ^= S[tk[KC-1][3]];
185           tk[0][3] ^= S[tk[KC-1][0]];
186           tk[0][0] ^= rcon[rconpointer++];
187           
188           if (KC != 8)
189             {
190               for (j = 1; j < KC; j++) 
191                 {
192                   *((u32*)tk[j]) ^= *((u32*)tk[j-1]);
193                 }
194             } 
195           else 
196             {
197               for (j = 1; j < KC/2; j++)
198                 {
199                   *((u32*)tk[j]) ^= *((u32*)tk[j-1]);
200                 }
201               tk[KC/2][0] ^= S[tk[KC/2 - 1][0]];
202               tk[KC/2][1] ^= S[tk[KC/2 - 1][1]];
203               tk[KC/2][2] ^= S[tk[KC/2 - 1][2]];
204               tk[KC/2][3] ^= S[tk[KC/2 - 1][3]];
205               for (j = KC/2 + 1; j < KC; j++)
206                 {
207                   *((u32*)tk[j]) ^= *((u32*)tk[j-1]);
208                 }
209             }
210           
211           /* Copy values into round key array.  */
212           for (j = 0; (j < KC) && (r < ROUNDS + 1); )
213             {
214               for (; (j < KC) && (t < 4); j++, t++)
215                 {
216                   *((u32*)W[r][t]) = *((u32*)tk[j]);
217                 }
218               if (t == 4)
219                 {
220                   r++;
221                   t = 0;
222                 }
223             }
224         }               
225 #undef W    
226     }
227
228   return 0;
229 }
230
231
232 static gcry_err_code_t
233 rijndael_setkey (void *context, const byte *key, const unsigned keylen)
234 {
235   RIJNDAEL_context *ctx = context;
236
237   int rc = do_setkey (ctx, key, keylen);
238   _gcry_burn_stack ( 100 + 16*sizeof(int));
239   return rc;
240 }
241
242
243 /* Make a decryption key from an encryption key. */
244 static void
245 prepare_decryption( RIJNDAEL_context *ctx )
246 {
247   int r;
248   byte *w;
249
250   for (r=0; r < MAXROUNDS+1; r++ )
251     {
252       *((u32*)ctx->keySched2[r][0]) = *((u32*)ctx->keySched[r][0]);
253       *((u32*)ctx->keySched2[r][1]) = *((u32*)ctx->keySched[r][1]);
254       *((u32*)ctx->keySched2[r][2]) = *((u32*)ctx->keySched[r][2]);
255       *((u32*)ctx->keySched2[r][3]) = *((u32*)ctx->keySched[r][3]);
256     }
257 #define W (ctx->keySched2)
258   for (r = 1; r < ctx->ROUNDS; r++)
259     {
260       w = W[r][0];
261       *((u32*)w) = *((u32*)U1[w[0]]) ^ *((u32*)U2[w[1]])
262         ^ *((u32*)U3[w[2]]) ^ *((u32*)U4[w[3]]);
263        
264       w = W[r][1];
265       *((u32*)w) = *((u32*)U1[w[0]]) ^ *((u32*)U2[w[1]])
266         ^ *((u32*)U3[w[2]]) ^ *((u32*)U4[w[3]]);
267         
268       w = W[r][2];
269       *((u32*)w) = *((u32*)U1[w[0]]) ^ *((u32*)U2[w[1]])
270         ^ *((u32*)U3[w[2]]) ^ *((u32*)U4[w[3]]);
271         
272       w = W[r][3];
273       *((u32*)w) = *((u32*)U1[w[0]]) ^ *((u32*)U2[w[1]])
274         ^ *((u32*)U3[w[2]]) ^ *((u32*)U4[w[3]]);
275     }
276 #undef W
277 }       
278
279
280 \f
281 /* Encrypt one block.  A and B need to be aligned on a 4 byte
282    boundary.  A and B may be the same. */
283 static void
284 do_encrypt_aligned (const RIJNDAEL_context *ctx, 
285                     unsigned char *b, const unsigned char *a)
286 {
287 #define rk (ctx->keySched)
288   int ROUNDS = ctx->ROUNDS;
289   int r;
290   union
291   {
292     u32  tempu32[4];  /* Force correct alignment. */
293     byte temp[4][4];
294   } u;
295
296   *((u32*)u.temp[0]) = *((u32*)(a   )) ^ *((u32*)rk[0][0]);
297   *((u32*)u.temp[1]) = *((u32*)(a+ 4)) ^ *((u32*)rk[0][1]);
298   *((u32*)u.temp[2]) = *((u32*)(a+ 8)) ^ *((u32*)rk[0][2]);
299   *((u32*)u.temp[3]) = *((u32*)(a+12)) ^ *((u32*)rk[0][3]);
300   *((u32*)(b    ))   = (*((u32*)T1[u.temp[0][0]])
301                         ^ *((u32*)T2[u.temp[1][1]])
302                         ^ *((u32*)T3[u.temp[2][2]]) 
303                         ^ *((u32*)T4[u.temp[3][3]]));
304   *((u32*)(b + 4))   = (*((u32*)T1[u.temp[1][0]])
305                         ^ *((u32*)T2[u.temp[2][1]])
306                         ^ *((u32*)T3[u.temp[3][2]]) 
307                         ^ *((u32*)T4[u.temp[0][3]]));
308   *((u32*)(b + 8))   = (*((u32*)T1[u.temp[2][0]])
309                         ^ *((u32*)T2[u.temp[3][1]])
310                         ^ *((u32*)T3[u.temp[0][2]]) 
311                         ^ *((u32*)T4[u.temp[1][3]]));
312   *((u32*)(b +12))   = (*((u32*)T1[u.temp[3][0]])
313                         ^ *((u32*)T2[u.temp[0][1]])
314                         ^ *((u32*)T3[u.temp[1][2]]) 
315                         ^ *((u32*)T4[u.temp[2][3]]));
316
317   for (r = 1; r < ROUNDS-1; r++)
318     {
319       *((u32*)u.temp[0]) = *((u32*)(b   )) ^ *((u32*)rk[r][0]);
320       *((u32*)u.temp[1]) = *((u32*)(b+ 4)) ^ *((u32*)rk[r][1]);
321       *((u32*)u.temp[2]) = *((u32*)(b+ 8)) ^ *((u32*)rk[r][2]);
322       *((u32*)u.temp[3]) = *((u32*)(b+12)) ^ *((u32*)rk[r][3]);
323
324       *((u32*)(b    ))   = (*((u32*)T1[u.temp[0][0]])
325                             ^ *((u32*)T2[u.temp[1][1]])
326                             ^ *((u32*)T3[u.temp[2][2]]) 
327                             ^ *((u32*)T4[u.temp[3][3]]));
328       *((u32*)(b + 4))   = (*((u32*)T1[u.temp[1][0]])
329                             ^ *((u32*)T2[u.temp[2][1]])
330                             ^ *((u32*)T3[u.temp[3][2]]) 
331                             ^ *((u32*)T4[u.temp[0][3]]));
332       *((u32*)(b + 8))   = (*((u32*)T1[u.temp[2][0]])
333                             ^ *((u32*)T2[u.temp[3][1]])
334                             ^ *((u32*)T3[u.temp[0][2]]) 
335                             ^ *((u32*)T4[u.temp[1][3]]));
336       *((u32*)(b +12))   = (*((u32*)T1[u.temp[3][0]])
337                             ^ *((u32*)T2[u.temp[0][1]])
338                             ^ *((u32*)T3[u.temp[1][2]]) 
339                             ^ *((u32*)T4[u.temp[2][3]]));
340     }
341
342   /* Last round is special. */   
343   *((u32*)u.temp[0]) = *((u32*)(b   )) ^ *((u32*)rk[ROUNDS-1][0]);
344   *((u32*)u.temp[1]) = *((u32*)(b+ 4)) ^ *((u32*)rk[ROUNDS-1][1]);
345   *((u32*)u.temp[2]) = *((u32*)(b+ 8)) ^ *((u32*)rk[ROUNDS-1][2]);
346   *((u32*)u.temp[3]) = *((u32*)(b+12)) ^ *((u32*)rk[ROUNDS-1][3]);
347   b[ 0] = T1[u.temp[0][0]][1];
348   b[ 1] = T1[u.temp[1][1]][1];
349   b[ 2] = T1[u.temp[2][2]][1];
350   b[ 3] = T1[u.temp[3][3]][1];
351   b[ 4] = T1[u.temp[1][0]][1];
352   b[ 5] = T1[u.temp[2][1]][1];
353   b[ 6] = T1[u.temp[3][2]][1];
354   b[ 7] = T1[u.temp[0][3]][1];
355   b[ 8] = T1[u.temp[2][0]][1];
356   b[ 9] = T1[u.temp[3][1]][1];
357   b[10] = T1[u.temp[0][2]][1];
358   b[11] = T1[u.temp[1][3]][1];
359   b[12] = T1[u.temp[3][0]][1];
360   b[13] = T1[u.temp[0][1]][1];
361   b[14] = T1[u.temp[1][2]][1];
362   b[15] = T1[u.temp[2][3]][1];
363   *((u32*)(b   )) ^= *((u32*)rk[ROUNDS][0]);
364   *((u32*)(b+ 4)) ^= *((u32*)rk[ROUNDS][1]);
365   *((u32*)(b+ 8)) ^= *((u32*)rk[ROUNDS][2]);
366   *((u32*)(b+12)) ^= *((u32*)rk[ROUNDS][3]);
367 #undef rk
368 }
369
370
371 static void
372 do_encrypt (const RIJNDAEL_context *ctx,
373             unsigned char *bx, const unsigned char *ax)
374 {
375   /* BX and AX are not necessary correctly aligned.  Thus we need to
376      copy them here. */
377   union
378   {
379     u32  dummy[4]; 
380     byte a[16];
381   } a;
382   union
383   {
384     u32  dummy[4]; 
385     byte b[16];
386   } b;
387
388   memcpy (a.a, ax, 16);
389   do_encrypt_aligned (ctx, b.b, a.a);
390   memcpy (bx, b.b, 16);
391 }
392
393
394 /* Encrypt or decrypt one block using the padlock engine.  A and B may
395    be the same. */
396 #ifdef USE_PADLOCK
397 static void
398 do_padlock (const RIJNDAEL_context *ctx, int decrypt_flag,
399             unsigned char *bx, const unsigned char *ax)
400 {
401   /* BX and AX are not necessary correctly aligned.  Thus we need to
402      copy them here. */
403   unsigned char a[16] __attribute__ ((aligned (16)));
404   unsigned char b[16] __attribute__ ((aligned (16)));
405   unsigned int cword[4] __attribute__ ((aligned (16)));
406
407   /* The control word fields are:
408       127:12   11:10 9     8     7     6     5     4     3:0
409       RESERVED KSIZE CRYPT INTER KEYGN CIPHR ALIGN DGEST ROUND  */
410   cword[0] = (ctx->ROUNDS & 15);  /* (The mask is just a safeguard.)  */
411   cword[1] = 0;
412   cword[2] = 0;
413   cword[3] = 0;
414   if (decrypt_flag)
415     cword[0] |= 0x00000200;
416
417   memcpy (a, ax, 16);
418    
419   asm volatile 
420     ("pushfl\n\t"          /* Force key reload.  */            
421      "popfl\n\t"
422      "xchg %3, %%ebx\n\t"  /* Load key.  */
423      "movl $1, %%ecx\n\t"  /* Init counter for just one block.  */
424      ".byte 0xf3, 0x0f, 0xa7, 0xc8\n\t" /* REP XSTORE ECB. */
425      "xchg %3, %%ebx\n"    /* Restore GOT register.  */
426      : /* No output */
427      : "S" (a), "D" (b), "d" (cword), "r" (ctx->padlock_key)
428      : "%ecx", "cc", "memory"
429      );
430
431   memcpy (bx, b, 16);
432
433 }
434 #endif /*USE_PADLOCK*/
435
436
437 static void
438 rijndael_encrypt (void *context, byte *b, const byte *a)
439 {
440   RIJNDAEL_context *ctx = context;
441
442 #ifdef USE_PADLOCK
443   if (ctx->use_padlock)
444     {
445       do_padlock (ctx, 0, b, a);
446       _gcry_burn_stack (48 + 15 /* possible padding for alignment */);
447     }
448   else
449 #endif /*USE_PADLOCK*/
450     {
451       do_encrypt (ctx, b, a);
452       _gcry_burn_stack (48 + 2*sizeof(int));
453     }
454 }
455
456
457 /* Bulk encryption of complete blocks in CFB mode.  Caller needs to
458    make sure that IV is aligned on an unsigned long boundary.  This
459    function is only intended for the bulk encryption feature of
460    cipher.c. */
461 void
462 _gcry_aes_cfb_enc (void *context, unsigned char *iv, 
463                    void *outbuf_arg, const void *inbuf_arg,
464                    unsigned int nblocks)
465 {
466   RIJNDAEL_context *ctx = context;
467   unsigned char *outbuf = outbuf_arg;
468   const unsigned char *inbuf = inbuf_arg;
469   unsigned char *ivp;
470   int i;
471
472 #ifdef USE_PADLOCK
473   if (ctx->use_padlock)
474     {
475       /* Fixme: Let Padlock do the CFBing.  */
476       for ( ;nblocks; nblocks-- )
477         {
478           /* Encrypt the IV. */
479           do_padlock (ctx, 0, iv, iv);
480           /* XOR the input with the IV and store input into IV.  */
481           for (ivp=iv,i=0; i < BLOCKSIZE; i++ )
482             *outbuf++ = (*ivp++ ^= *inbuf++);
483         }
484     }
485   else
486 #endif /* USE_PADLOCK*/
487     {
488       for ( ;nblocks; nblocks-- )
489         {
490           /* Encrypt the IV. */
491           do_encrypt_aligned (ctx, 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
498   _gcry_burn_stack (48 + 2*sizeof(int));
499 }
500
501
502 /* Bulk encryption of complete blocks in CBC mode.  Caller needs to
503    make sure that IV is aligned on an unsigned long boundary.  This
504    function is only intended for the bulk encryption feature of
505    cipher.c. */
506 void
507 _gcry_aes_cbc_enc (void *context, unsigned char *iv, 
508                    void *outbuf_arg, const void *inbuf_arg,
509                    unsigned int nblocks, int cbc_mac)
510 {
511   RIJNDAEL_context *ctx = context;
512   unsigned char *outbuf = outbuf_arg;
513   const unsigned char *inbuf = inbuf_arg;
514   unsigned char *ivp;
515   int i;
516
517   for ( ;nblocks; nblocks-- )
518     {
519       for (ivp=iv, i=0; i < BLOCKSIZE; i++ )
520         outbuf[i] = inbuf[i] ^ *ivp++;
521
522 #ifdef USE_PADLOCK
523       if (ctx->use_padlock)
524         do_padlock (ctx, 0, outbuf, outbuf);
525       else
526 #endif /*USE_PADLOCK*/
527         do_encrypt (ctx, outbuf, outbuf );
528
529       memcpy (iv, outbuf, BLOCKSIZE);
530       inbuf += BLOCKSIZE;
531       if (!cbc_mac)
532         outbuf += BLOCKSIZE;
533     }
534
535   _gcry_burn_stack (48 + 2*sizeof(int));
536 }
537
538
539 \f
540 /* Decrypt one block.  A and B need to be aligned on a 4 byte boundary
541    and the decryption must have been prepared.  A and B may be the
542    same. */
543 static void
544 do_decrypt_aligned (RIJNDAEL_context *ctx, 
545                     unsigned char *b, const unsigned char *a)
546 {
547 #define rk  (ctx->keySched2)
548   int ROUNDS = ctx->ROUNDS; 
549   int r;
550   union 
551   {
552     u32  tempu32[4];  /* Force correct alignment. */
553     byte temp[4][4];
554   } u;
555
556
557   *((u32*)u.temp[0]) = *((u32*)(a   )) ^ *((u32*)rk[ROUNDS][0]);
558   *((u32*)u.temp[1]) = *((u32*)(a+ 4)) ^ *((u32*)rk[ROUNDS][1]);
559   *((u32*)u.temp[2]) = *((u32*)(a+ 8)) ^ *((u32*)rk[ROUNDS][2]);
560   *((u32*)u.temp[3]) = *((u32*)(a+12)) ^ *((u32*)rk[ROUNDS][3]);
561   
562   *((u32*)(b   ))    = (*((u32*)T5[u.temp[0][0]])
563                         ^ *((u32*)T6[u.temp[3][1]])
564                         ^ *((u32*)T7[u.temp[2][2]]) 
565                         ^ *((u32*)T8[u.temp[1][3]]));
566   *((u32*)(b+ 4))    = (*((u32*)T5[u.temp[1][0]])
567                         ^ *((u32*)T6[u.temp[0][1]])
568                         ^ *((u32*)T7[u.temp[3][2]]) 
569                         ^ *((u32*)T8[u.temp[2][3]]));
570   *((u32*)(b+ 8))    = (*((u32*)T5[u.temp[2][0]])
571                         ^ *((u32*)T6[u.temp[1][1]])
572                         ^ *((u32*)T7[u.temp[0][2]]) 
573                         ^ *((u32*)T8[u.temp[3][3]]));
574   *((u32*)(b+12))    = (*((u32*)T5[u.temp[3][0]])
575                         ^ *((u32*)T6[u.temp[2][1]])
576                         ^ *((u32*)T7[u.temp[1][2]]) 
577                         ^ *((u32*)T8[u.temp[0][3]]));
578
579   for (r = ROUNDS-1; r > 1; r--)
580     {
581       *((u32*)u.temp[0]) = *((u32*)(b   )) ^ *((u32*)rk[r][0]);
582       *((u32*)u.temp[1]) = *((u32*)(b+ 4)) ^ *((u32*)rk[r][1]);
583       *((u32*)u.temp[2]) = *((u32*)(b+ 8)) ^ *((u32*)rk[r][2]);
584       *((u32*)u.temp[3]) = *((u32*)(b+12)) ^ *((u32*)rk[r][3]);
585       *((u32*)(b   ))    = (*((u32*)T5[u.temp[0][0]])
586                             ^ *((u32*)T6[u.temp[3][1]])
587                             ^ *((u32*)T7[u.temp[2][2]]) 
588                             ^ *((u32*)T8[u.temp[1][3]]));
589       *((u32*)(b+ 4))    = (*((u32*)T5[u.temp[1][0]])
590                             ^ *((u32*)T6[u.temp[0][1]])
591                             ^ *((u32*)T7[u.temp[3][2]]) 
592                             ^ *((u32*)T8[u.temp[2][3]]));
593       *((u32*)(b+ 8))    = (*((u32*)T5[u.temp[2][0]])
594                             ^ *((u32*)T6[u.temp[1][1]])
595                             ^ *((u32*)T7[u.temp[0][2]]) 
596                             ^ *((u32*)T8[u.temp[3][3]]));
597       *((u32*)(b+12))    = (*((u32*)T5[u.temp[3][0]])
598                             ^ *((u32*)T6[u.temp[2][1]])
599                             ^ *((u32*)T7[u.temp[1][2]]) 
600                             ^ *((u32*)T8[u.temp[0][3]]));
601     }
602
603   /* Last round is special. */   
604   *((u32*)u.temp[0]) = *((u32*)(b   )) ^ *((u32*)rk[1][0]);
605   *((u32*)u.temp[1]) = *((u32*)(b+ 4)) ^ *((u32*)rk[1][1]);
606   *((u32*)u.temp[2]) = *((u32*)(b+ 8)) ^ *((u32*)rk[1][2]);
607   *((u32*)u.temp[3]) = *((u32*)(b+12)) ^ *((u32*)rk[1][3]);
608   b[ 0] = S5[u.temp[0][0]];
609   b[ 1] = S5[u.temp[3][1]];
610   b[ 2] = S5[u.temp[2][2]];
611   b[ 3] = S5[u.temp[1][3]];
612   b[ 4] = S5[u.temp[1][0]];
613   b[ 5] = S5[u.temp[0][1]];
614   b[ 6] = S5[u.temp[3][2]];
615   b[ 7] = S5[u.temp[2][3]];
616   b[ 8] = S5[u.temp[2][0]];
617   b[ 9] = S5[u.temp[1][1]];
618   b[10] = S5[u.temp[0][2]];
619   b[11] = S5[u.temp[3][3]];
620   b[12] = S5[u.temp[3][0]];
621   b[13] = S5[u.temp[2][1]];
622   b[14] = S5[u.temp[1][2]];
623   b[15] = S5[u.temp[0][3]];
624   *((u32*)(b   )) ^= *((u32*)rk[0][0]);
625   *((u32*)(b+ 4)) ^= *((u32*)rk[0][1]);
626   *((u32*)(b+ 8)) ^= *((u32*)rk[0][2]);
627   *((u32*)(b+12)) ^= *((u32*)rk[0][3]);
628 #undef rk
629 }
630
631
632 /* Decrypt one block.  AX and BX may be the same. */
633 static void
634 do_decrypt (RIJNDAEL_context *ctx, byte *bx, const byte *ax)
635 {
636   /* BX and AX are not necessary correctly aligned.  Thus we need to
637      copy them here. */
638   union
639   {
640     u32  dummy[4]; 
641     byte a[16];
642   } a;
643   union
644   {
645     u32  dummy[4]; 
646     byte b[16];
647   } b;
648
649   if ( !ctx->decryption_prepared )
650     {
651       prepare_decryption ( ctx );
652       _gcry_burn_stack (64);
653       ctx->decryption_prepared = 1;
654     }
655
656   memcpy (a.a, ax, 16);
657   do_decrypt_aligned (ctx, b.b, a.a);
658   memcpy (bx, b.b, 16);
659 #undef rk
660 }
661     
662
663
664
665 static void
666 rijndael_decrypt (void *context, byte *b, const byte *a)
667 {
668   RIJNDAEL_context *ctx = context;
669
670 #ifdef USE_PADLOCK
671   if (ctx->use_padlock)
672     {
673       do_padlock (ctx, 1, b, a);
674       _gcry_burn_stack (48 + 2*sizeof(int) /* FIXME */);
675     }
676   else
677 #endif /*USE_PADLOCK*/
678     {
679       do_decrypt (ctx, b, a);
680       _gcry_burn_stack (48+2*sizeof(int));
681     }
682 }
683
684
685 /* Bulk decryption of complete blocks in CFB mode.  Caller needs to
686    make sure that IV is aligned on an unisgned lonhg boundary.  This
687    function is only intended for the bulk encryption feature of
688    cipher.c. */
689 void
690 _gcry_aes_cfb_dec (void *context, unsigned char *iv, 
691                    void *outbuf_arg, const void *inbuf_arg,
692                    unsigned int nblocks)
693 {
694   RIJNDAEL_context *ctx = context;
695   unsigned char *outbuf = outbuf_arg;
696   const unsigned char *inbuf = inbuf_arg;
697   unsigned char *ivp;
698   unsigned char temp;
699   int i;
700
701 #ifdef USE_PADLOCK
702   if (ctx->use_padlock)
703     {
704       /* Fixme:  Let Padlock do the CFBing.  */
705       for ( ;nblocks; nblocks-- )
706         {
707           do_padlock (ctx, 0, iv, iv);
708           for (ivp=iv,i=0; i < BLOCKSIZE; i++ )
709             {
710               temp = *inbuf++;
711               *outbuf++ = *ivp ^ temp;
712               *ivp++ = temp;
713             }
714         }
715     }
716   else
717 #endif /*USE_PADLOCK*/
718     {
719       for ( ;nblocks; nblocks-- )
720         {
721           do_encrypt_aligned (ctx, iv, iv);
722           for (ivp=iv,i=0; i < BLOCKSIZE; i++ )
723             {
724               temp = *inbuf++;
725               *outbuf++ = *ivp ^ temp;
726               *ivp++ = temp;
727             }
728         }
729     }
730
731   _gcry_burn_stack (48 + 2*sizeof(int));
732 }
733
734
735 /* Bulk decryption of complete blocks in CBC mode.  Caller needs to
736    make sure that IV is aligned on an unsigned long boundary.  This
737    function is only intended for the bulk encryption feature of
738    cipher.c. */
739 void
740 _gcry_aes_cbc_dec (void *context, unsigned char *iv, 
741                    void *outbuf_arg, const void *inbuf_arg,
742                    unsigned int nblocks)
743 {
744   RIJNDAEL_context *ctx = context;
745   unsigned char *outbuf = outbuf_arg;
746   const unsigned char *inbuf = inbuf_arg;
747   unsigned char *ivp;
748   int i;
749   unsigned char savebuf[BLOCKSIZE];
750
751   for ( ;nblocks; nblocks-- )
752     {
753       /* We need to save INBUF away because it may be identical to
754          OUTBUF.  */
755       memcpy (savebuf, inbuf, BLOCKSIZE);
756
757 #ifdef USE_PADLOCK
758       if (ctx->use_padlock)
759         do_padlock (ctx, 1, outbuf, inbuf);
760       else
761 #endif /*USE_PADLOCK*/
762         do_decrypt (ctx, outbuf, inbuf);
763
764       for (ivp=iv, i=0; i < BLOCKSIZE; i++ )
765         outbuf[i] ^= *ivp++;
766       memcpy (iv, savebuf, BLOCKSIZE);
767       inbuf += BLOCKSIZE;
768       outbuf += BLOCKSIZE;
769     }
770
771   _gcry_burn_stack (48 + 2*sizeof(int) + BLOCKSIZE + 4*sizeof (char*));
772 }
773
774
775
776 \f
777 /* Test a single encryption and decryption with each key size. */
778 static const char*
779 selftest (void)
780 {
781   RIJNDAEL_context ctx;
782   byte scratch[16];        
783
784   /* The test vectors are from the AES supplied ones; more or less 
785    * randomly taken from ecb_tbl.txt (I=42,81,14)
786    */
787   static byte plaintext[16] = {
788     0x01,0x4B,0xAF,0x22,0x78,0xA6,0x9D,0x33,
789     0x1D,0x51,0x80,0x10,0x36,0x43,0xE9,0x9A
790   };
791   static byte key[16] = {
792     0xE8,0xE9,0xEA,0xEB,0xED,0xEE,0xEF,0xF0,
793     0xF2,0xF3,0xF4,0xF5,0xF7,0xF8,0xF9,0xFA
794   };
795   static const byte ciphertext[16] = {
796     0x67,0x43,0xC3,0xD1,0x51,0x9A,0xB4,0xF2,
797     0xCD,0x9A,0x78,0xAB,0x09,0xA5,0x11,0xBD
798   };
799
800   static byte plaintext_192[16] = {
801     0x76,0x77,0x74,0x75,0xF1,0xF2,0xF3,0xF4,
802     0xF8,0xF9,0xE6,0xE7,0x77,0x70,0x71,0x72
803   };
804   static byte key_192[24] = {
805     0x04,0x05,0x06,0x07,0x09,0x0A,0x0B,0x0C,
806     0x0E,0x0F,0x10,0x11,0x13,0x14,0x15,0x16,
807     0x18,0x19,0x1A,0x1B,0x1D,0x1E,0x1F,0x20
808   };
809   static const byte ciphertext_192[16] = {
810     0x5D,0x1E,0xF2,0x0D,0xCE,0xD6,0xBC,0xBC,
811     0x12,0x13,0x1A,0xC7,0xC5,0x47,0x88,0xAA
812   };
813     
814   static byte plaintext_256[16] = {
815     0x06,0x9A,0x00,0x7F,0xC7,0x6A,0x45,0x9F,
816     0x98,0xBA,0xF9,0x17,0xFE,0xDF,0x95,0x21
817   };
818   static byte key_256[32] = {
819     0x08,0x09,0x0A,0x0B,0x0D,0x0E,0x0F,0x10,
820     0x12,0x13,0x14,0x15,0x17,0x18,0x19,0x1A,
821     0x1C,0x1D,0x1E,0x1F,0x21,0x22,0x23,0x24,
822     0x26,0x27,0x28,0x29,0x2B,0x2C,0x2D,0x2E
823   };
824   static const byte ciphertext_256[16] = {
825     0x08,0x0E,0x95,0x17,0xEB,0x16,0x77,0x71,
826     0x9A,0xCF,0x72,0x80,0x86,0x04,0x0A,0xE3
827   };
828
829   rijndael_setkey (&ctx, key, sizeof(key));
830   rijndael_encrypt (&ctx, scratch, plaintext);
831   if (memcmp (scratch, ciphertext, sizeof (ciphertext)))
832     return "Rijndael-128 test encryption failed.";
833   rijndael_decrypt (&ctx, scratch, scratch);
834   if (memcmp (scratch, plaintext, sizeof (plaintext)))
835     return "Rijndael-128 test decryption failed.";
836
837   rijndael_setkey (&ctx, key_192, sizeof(key_192));
838   rijndael_encrypt (&ctx, scratch, plaintext_192);
839   if (memcmp (scratch, ciphertext_192, sizeof (ciphertext_192)))
840     return "Rijndael-192 test encryption failed.";
841   rijndael_decrypt (&ctx, scratch, scratch);
842   if (memcmp (scratch, plaintext_192, sizeof (plaintext_192)))
843     return "Rijndael-192 test decryption failed.";
844     
845   rijndael_setkey (&ctx, key_256, sizeof(key_256));
846   rijndael_encrypt (&ctx, scratch, plaintext_256);
847   if (memcmp (scratch, ciphertext_256, sizeof (ciphertext_256)))
848     return "Rijndael-256 test encryption failed.";
849   rijndael_decrypt (&ctx, scratch, scratch);
850   if (memcmp (scratch, plaintext_256, sizeof (plaintext_256)))
851     return "Rijndael-256 test decryption failed.";
852     
853   return NULL;
854 }
855
856 \f
857
858 static const char *rijndael_names[] =
859   {
860     "RIJNDAEL",
861     NULL
862   };
863
864 static gcry_cipher_oid_spec_t rijndael_oids[] =
865   {
866     { "2.16.840.1.101.3.4.1.1", GCRY_CIPHER_MODE_ECB },
867     { "2.16.840.1.101.3.4.1.2", GCRY_CIPHER_MODE_CBC },
868     { "2.16.840.1.101.3.4.1.3", GCRY_CIPHER_MODE_OFB },
869     { "2.16.840.1.101.3.4.1.4", GCRY_CIPHER_MODE_CFB },
870     { NULL }
871   };
872
873 gcry_cipher_spec_t _gcry_cipher_spec_aes =
874   {
875     "AES", rijndael_names, rijndael_oids, 16, 128, sizeof (RIJNDAEL_context),
876     rijndael_setkey, rijndael_encrypt, rijndael_decrypt
877   };
878
879 static const char *rijndael192_names[] =
880   {
881     "RIJNDAEL192",
882     NULL
883   };
884
885 static gcry_cipher_oid_spec_t rijndael192_oids[] =
886   {
887     { "2.16.840.1.101.3.4.1.21", GCRY_CIPHER_MODE_ECB },
888     { "2.16.840.1.101.3.4.1.22", GCRY_CIPHER_MODE_CBC },
889     { "2.16.840.1.101.3.4.1.23", GCRY_CIPHER_MODE_OFB },
890     { "2.16.840.1.101.3.4.1.24", GCRY_CIPHER_MODE_CFB },
891     { NULL }
892   };
893
894 gcry_cipher_spec_t _gcry_cipher_spec_aes192 =
895   {
896     "AES192", rijndael192_names, rijndael192_oids, 16, 192, sizeof (RIJNDAEL_context),
897     rijndael_setkey, rijndael_encrypt, rijndael_decrypt
898   };
899
900 static const char *rijndael256_names[] =
901   {
902     "RIJNDAEL256",
903     NULL
904   };
905
906 static gcry_cipher_oid_spec_t rijndael256_oids[] =
907   {
908     { "2.16.840.1.101.3.4.1.41", GCRY_CIPHER_MODE_ECB },
909     { "2.16.840.1.101.3.4.1.42", GCRY_CIPHER_MODE_CBC },
910     { "2.16.840.1.101.3.4.1.43", GCRY_CIPHER_MODE_OFB },
911     { "2.16.840.1.101.3.4.1.44", GCRY_CIPHER_MODE_CFB },
912     { NULL }
913   };
914
915 gcry_cipher_spec_t _gcry_cipher_spec_aes256 =
916   {
917     "AES256", rijndael256_names, rijndael256_oids, 16, 256,
918     sizeof (RIJNDAEL_context),
919     rijndael_setkey, rijndael_encrypt, rijndael_decrypt
920   };