Fix segv with AES-NI on some platforms.
[libgcrypt.git] / cipher / rijndael.c
1 /* Rijndael (AES) for GnuPG
2  * Copyright (C) 2000, 2001, 2002, 2003, 2007,
3  *               2008, 2011 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 /* Helper macro to force alignment to 16 bytes.  */
55 #ifdef __GNUC__
56 # define ATTR_ALIGNED_16  __attribute__ ((aligned (16)))
57 #else
58 # define ATTR_ALIGNED_16
59 #endif
60
61
62 /* USE_PADLOCK indicates whether to compile the padlock specific
63    code.  */
64 #undef USE_PADLOCK
65 #ifdef ENABLE_PADLOCK_SUPPORT
66 # ifdef __GNUC__
67 #  if (defined (__i386__) && SIZEOF_UNSIGNED_LONG == 4) || defined(__x86_64__)
68 #   define USE_PADLOCK 1
69 #  endif
70 # endif
71 #endif /*ENABLE_PADLOCK_SUPPORT*/
72
73 /* USE_AESNI inidicates whether to compile with Intel AES-NI code.  We
74    need the vector-size attribute which seems to be available since
75    gcc 3.  However, to be on the safe side we require at least gcc 4.  */
76 #undef USE_AESNI
77 #ifdef ENABLE_AESNI_SUPPORT
78 # if defined (__i386__) && SIZEOF_UNSIGNED_LONG == 4 && __GNUC__ >= 4
79 #  define USE_AESNI 1
80 # endif
81 #endif /* ENABLE_AESNI_SUPPORT */
82
83 #ifdef USE_AESNI
84   typedef int m128i_t __attribute__ ((__vector_size__ (16)));
85 #endif /*USE_AESNI*/
86
87 /* Define an u32 variant for the sake of gcc 4.4's strict aliasing.  */
88 #if __GNUC__ > 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )
89 typedef u32           __attribute__ ((__may_alias__)) u32_a_t;
90 #else
91 typedef u32           u32_a_t;
92 #endif
93
94
95 \f
96 /* Our context object.  */
97 typedef struct
98 {
99   /* The first fields are the keyschedule arrays.  This is so that
100      they are aligned on a 16 byte boundary if using gcc.  This
101      alignment is required for the AES-NI code and a good idea in any
102      case.  The alignment is guaranteed due to the way cipher.c
103      allocates the space for the context.  The PROPERLY_ALIGNED_TYPE
104      hack is used to force a minimal alignment if not using gcc of if
105      the alignment requirement is higher that 16 bytes.  */
106   union
107   {
108     PROPERLY_ALIGNED_TYPE dummy;
109     byte keyschedule[MAXROUNDS+1][4][4];
110 #ifdef USE_PADLOCK
111     /* The key as passed to the padlock engine.  It is only used if
112        the padlock engine is used (USE_PADLOCK, below).  */
113     unsigned char padlock_key[16] __attribute__ ((aligned (16)));
114 #endif /*USE_PADLOCK*/
115   } u1;
116   union
117   {
118     PROPERLY_ALIGNED_TYPE dummy;
119     byte keyschedule[MAXROUNDS+1][4][4];
120   } u2;
121   int rounds;               /* Key-length-dependent number of rounds.  */
122   int decryption_prepared;  /* The decryption key schedule is available.  */
123 #ifdef USE_PADLOCK
124   int use_padlock;          /* Padlock shall be used.  */
125 #endif /*USE_PADLOCK*/
126 #ifdef USE_AESNI
127   int use_aesni;            /* AES-NI shall be used.  */
128 #endif /*USE_AESNI*/
129 } RIJNDAEL_context ATTR_ALIGNED_16;
130
131 /* Macros defining alias for the keyschedules.  */
132 #define keyschenc  u1.keyschedule
133 #define keyschdec  u2.keyschedule
134 #define padlockkey u1.padlock_key
135
136 /* Two macros to be called prior and after the use of AESNI
137    instructions.  There should be no external function calls between
138    the use of these macros.  There purpose is to make sure that the
139    SSE regsiters are cleared and won't reveal any information about
140    the key or the data.  */
141 #ifdef USE_AESNI
142 # define aesni_prepare() do { } while (0)
143 # define aesni_cleanup()                                                \
144   do { asm volatile ("pxor %%xmm0, %%xmm0\n\t"                          \
145                      "pxor %%xmm1, %%xmm1\n" :: );                      \
146   } while (0)
147 # define aesni_cleanup_2_4()                                            \
148   do { asm volatile ("pxor %%xmm2, %%xmm2\n\t"                          \
149                      "pxor %%xmm3, %%xmm3\n"                            \
150                      "pxor %%xmm4, %%xmm4\n":: );                       \
151   } while (0)
152 #else
153 # define aesni_prepare() do { } while (0)
154 # define aesni_cleanup() do { } while (0)
155 #endif
156
157
158 /* All the numbers.  */
159 #include "rijndael-tables.h"
160
161
162 \f
163 /* Function prototypes.  */
164 #ifdef USE_AESNI
165 /* We don't want to inline these functions to help gcc allocate enough
166    registers.  */
167 static void do_aesni_ctr (const RIJNDAEL_context *ctx, unsigned char *ctr,
168                           unsigned char *b, const unsigned char *a)
169   __attribute__ ((__noinline__));
170 static void do_aesni_ctr_4 (const RIJNDAEL_context *ctx, unsigned char *ctr,
171                             unsigned char *b, const unsigned char *a)
172   __attribute__ ((__noinline__));
173 #endif /*USE_AESNI*/
174
175 static const char *selftest(void);
176
177
178 \f
179 /* Perform the key setup.  */
180 static gcry_err_code_t
181 do_setkey (RIJNDAEL_context *ctx, const byte *key, const unsigned keylen)
182 {
183   static int initialized = 0;
184   static const char *selftest_failed=0;
185   int rounds;
186   int i,j, r, t, rconpointer = 0;
187   int KC;
188   union
189   {
190     PROPERLY_ALIGNED_TYPE dummy;
191     byte k[MAXKC][4];
192   } k;
193 #define k k.k
194   union
195   {
196     PROPERLY_ALIGNED_TYPE dummy;
197     byte tk[MAXKC][4];
198   } tk;
199 #define tk tk.tk
200
201   /* The on-the-fly self tests are only run in non-fips mode. In fips
202      mode explicit self-tests are required.  Actually the on-the-fly
203      self-tests are not fully thread-safe and it might happen that a
204      failed self-test won't get noticed in another thread.
205
206      FIXME: We might want to have a central registry of succeeded
207      self-tests. */
208   if (!fips_mode () && !initialized)
209     {
210       initialized = 1;
211       selftest_failed = selftest ();
212       if (selftest_failed)
213         log_error ("%s\n", selftest_failed );
214     }
215   if (selftest_failed)
216     return GPG_ERR_SELFTEST_FAILED;
217
218   ctx->decryption_prepared = 0;
219 #ifdef USE_PADLOCK
220   ctx->use_padlock = 0;
221 #endif
222 #ifdef USE_AESNI
223   ctx->use_aesni = 0;
224 #endif
225
226   if( keylen == 128/8 )
227     {
228       rounds = 10;
229       KC = 4;
230
231       if (0)
232         ;
233 #ifdef USE_PADLOCK
234       else if ((_gcry_get_hw_features () & HWF_PADLOCK_AES))
235         {
236           ctx->use_padlock = 1;
237           memcpy (ctx->padlockkey, key, keylen);
238         }
239 #endif
240 #ifdef USE_AESNI
241       else if ((_gcry_get_hw_features () & HWF_INTEL_AESNI))
242         {
243           ctx->use_aesni = 1;
244         }
245 #endif
246     }
247   else if ( keylen == 192/8 )
248     {
249       rounds = 12;
250       KC = 6;
251
252       if (0)
253         {
254           ;
255         }
256 #ifdef USE_AESNI
257       else if ((_gcry_get_hw_features () & HWF_INTEL_AESNI))
258         {
259           ctx->use_aesni = 1;
260         }
261 #endif
262     }
263   else if ( keylen == 256/8 )
264     {
265       rounds = 14;
266       KC = 8;
267
268       if (0)
269         {
270           ;
271         }
272 #ifdef USE_AESNI
273       else if ((_gcry_get_hw_features () & HWF_INTEL_AESNI))
274         {
275           ctx->use_aesni = 1;
276         }
277 #endif
278     }
279   else
280     return GPG_ERR_INV_KEYLEN;
281
282   ctx->rounds = rounds;
283
284   if (0)
285     ;
286 #ifdef USE_PADLOCK
287   else if (ctx->use_padlock)
288     {
289       /* Nothing to do as we support only hardware key generation for
290          now.  */
291     }
292 #endif /*USE_PADLOCK*/
293 #ifdef USE_AESNI_is_disabled_here
294   else if (ctx->use_aesni && ctx->rounds == 10)
295     {
296       /* Note: This code works for AES-128 but it is not much better
297          than using the standard key schedule.  We disable it for
298          now and don't put any effort into implementing this for
299          AES-192 and AES-256.  */
300       asm volatile ("movl   %[key], %%esi\n\t"
301                     "movdqu (%%esi), %%xmm1\n\t"     /* xmm1 := key   */
302                     "movl   %[ksch], %%esi\n\t"
303                     "movdqa %%xmm1, (%%esi)\n\t"     /* ksch[0] := xmm1  */
304                     "aeskeygenassist $0x01, %%xmm1, %%xmm2\n\t"
305                     "call .Lexpand128_%=\n\t"
306                     "movdqa %%xmm1, 0x10(%%esi)\n\t" /* ksch[1] := xmm1  */
307                     "aeskeygenassist $0x02, %%xmm1, %%xmm2\n\t"
308                     "call .Lexpand128_%=\n\t"
309                     "movdqa %%xmm1, 0x20(%%esi)\n\t" /* ksch[2] := xmm1  */
310                     "aeskeygenassist $0x04, %%xmm1, %%xmm2\n\t"
311                     "call .Lexpand128_%=\n\t"
312                     "movdqa %%xmm1, 0x30(%%esi)\n\t" /* ksch[3] := xmm1  */
313                     "aeskeygenassist $0x08, %%xmm1, %%xmm2\n\t"
314                     "call .Lexpand128_%=\n\t"
315                     "movdqa %%xmm1, 0x40(%%esi)\n\t" /* ksch[4] := xmm1  */
316                     "aeskeygenassist $0x10, %%xmm1, %%xmm2\n\t"
317                     "call .Lexpand128_%=\n\t"
318                     "movdqa %%xmm1, 0x50(%%esi)\n\t" /* ksch[5] := xmm1  */
319                     "aeskeygenassist $0x20, %%xmm1, %%xmm2\n\t"
320                     "call .Lexpand128_%=\n\t"
321                     "movdqa %%xmm1, 0x60(%%esi)\n\t" /* ksch[6] := xmm1  */
322                     "aeskeygenassist $0x40, %%xmm1, %%xmm2\n\t"
323                     "call .Lexpand128_%=\n\t"
324                     "movdqa %%xmm1, 0x70(%%esi)\n\t" /* ksch[7] := xmm1  */
325                     "aeskeygenassist $0x80, %%xmm1, %%xmm2\n\t"
326                     "call .Lexpand128_%=\n\t"
327                     "movdqa %%xmm1, 0x80(%%esi)\n\t" /* ksch[8] := xmm1  */
328                     "aeskeygenassist $0x1b, %%xmm1, %%xmm2\n\t"
329                     "call .Lexpand128_%=\n\t"
330                     "movdqa %%xmm1, 0x90(%%esi)\n\t" /* ksch[9] := xmm1  */
331                     "aeskeygenassist $0x36, %%xmm1, %%xmm2\n\t"
332                     "call .Lexpand128_%=\n\t"
333                     "movdqa %%xmm1, 0xa0(%%esi)\n\t" /* ksch[10] := xmm1  */
334                     "jmp .Lleave%=\n"
335
336                     ".Lexpand128_%=:\n\t"
337                     "pshufd $0xff, %%xmm2, %%xmm2\n\t"
338                     "movdqa %%xmm1, %%xmm3\n\t"
339                     "pslldq $4, %%xmm3\n\t"
340                     "pxor   %%xmm3, %%xmm1\n\t"
341                     "pslldq $4, %%xmm3\n\t"
342                     "pxor   %%xmm3, %%xmm1\n\t"
343                     "pslldq $4, %%xmm3\n\t"
344                     "pxor   %%xmm3, %%xmm2\n\t"
345                     "pxor   %%xmm2, %%xmm1\n\t"
346                     "ret\n"
347
348                     ".Lleave%=:\n\t"
349                     "pxor %%xmm1, %%xmm1\n\t"
350                     "pxor %%xmm2, %%xmm2\n\t"
351                     "pxor %%xmm3, %%xmm3\n"
352                     :
353                     : [key] "g" (key), [ksch] "g" (ctx->keyschenc)
354                     : "%esi", "cc", "memory" );
355     }
356 #endif /*USE_AESNI*/
357   else
358     {
359 #define W (ctx->keyschenc)
360       for (i = 0; i < keylen; i++)
361         {
362           k[i >> 2][i & 3] = key[i];
363         }
364
365       for (j = KC-1; j >= 0; j--)
366         {
367           *((u32*)tk[j]) = *((u32*)k[j]);
368         }
369       r = 0;
370       t = 0;
371       /* Copy values into round key array.  */
372       for (j = 0; (j < KC) && (r < rounds + 1); )
373         {
374           for (; (j < KC) && (t < 4); j++, t++)
375             {
376               *((u32*)W[r][t]) = *((u32*)tk[j]);
377             }
378           if (t == 4)
379             {
380               r++;
381               t = 0;
382             }
383         }
384
385       while (r < rounds + 1)
386         {
387           /* While not enough round key material calculated calculate
388              new values.  */
389           tk[0][0] ^= S[tk[KC-1][1]];
390           tk[0][1] ^= S[tk[KC-1][2]];
391           tk[0][2] ^= S[tk[KC-1][3]];
392           tk[0][3] ^= S[tk[KC-1][0]];
393           tk[0][0] ^= rcon[rconpointer++];
394
395           if (KC != 8)
396             {
397               for (j = 1; j < KC; j++)
398                 {
399                   *((u32*)tk[j]) ^= *((u32*)tk[j-1]);
400                 }
401             }
402           else
403             {
404               for (j = 1; j < KC/2; j++)
405                 {
406                   *((u32*)tk[j]) ^= *((u32*)tk[j-1]);
407                 }
408               tk[KC/2][0] ^= S[tk[KC/2 - 1][0]];
409               tk[KC/2][1] ^= S[tk[KC/2 - 1][1]];
410               tk[KC/2][2] ^= S[tk[KC/2 - 1][2]];
411               tk[KC/2][3] ^= S[tk[KC/2 - 1][3]];
412               for (j = KC/2 + 1; j < KC; j++)
413                 {
414                   *((u32*)tk[j]) ^= *((u32*)tk[j-1]);
415                 }
416             }
417
418           /* Copy values into round key array.  */
419           for (j = 0; (j < KC) && (r < rounds + 1); )
420             {
421               for (; (j < KC) && (t < 4); j++, t++)
422                 {
423                   *((u32*)W[r][t]) = *((u32*)tk[j]);
424                 }
425               if (t == 4)
426                 {
427                   r++;
428                   t = 0;
429                 }
430             }
431         }
432 #undef W
433     }
434
435   return 0;
436 #undef tk
437 #undef k
438 }
439
440
441 static gcry_err_code_t
442 rijndael_setkey (void *context, const byte *key, const unsigned keylen)
443 {
444   RIJNDAEL_context *ctx = context;
445
446   int rc = do_setkey (ctx, key, keylen);
447   _gcry_burn_stack ( 100 + 16*sizeof(int));
448   return rc;
449 }
450
451
452 /* Make a decryption key from an encryption key. */
453 static void
454 prepare_decryption( RIJNDAEL_context *ctx )
455 {
456   int r;
457
458 #ifdef USE_AESNI
459   if (ctx->use_aesni)
460     {
461       /* The AES-NI decrypt instructions use the Equivalent Inverse
462          Cipher, thus we can't use the the standard decrypt key
463          preparation.  */
464         m128i_t *ekey = (m128i_t*)ctx->keyschenc;
465         m128i_t *dkey = (m128i_t*)ctx->keyschdec;
466         int rr;
467
468         dkey[0] = ekey[ctx->rounds];
469         for (r=1, rr=ctx->rounds-1; r < ctx->rounds; r++, rr--)
470           {
471             asm volatile
472               ("movdqu %[ekey], %%xmm1\n\t"
473                /*"aesimc %%xmm1, %%xmm1\n\t"*/
474                ".byte 0x66, 0x0f, 0x38, 0xdb, 0xc9\n\t"
475                "movdqu %%xmm1, %[dkey]"
476                : [dkey] "=m" (dkey[r])
477                : [ekey] "m" (ekey[rr]) );
478           }
479         dkey[r] = ekey[0];
480     }
481   else
482 #endif /*USE_AESNI*/
483     {
484       union
485       {
486         PROPERLY_ALIGNED_TYPE dummy;
487         byte *w;
488       } w;
489 #define w w.w
490
491       for (r=0; r < MAXROUNDS+1; r++ )
492         {
493           *((u32*)ctx->keyschdec[r][0]) = *((u32*)ctx->keyschenc[r][0]);
494           *((u32*)ctx->keyschdec[r][1]) = *((u32*)ctx->keyschenc[r][1]);
495           *((u32*)ctx->keyschdec[r][2]) = *((u32*)ctx->keyschenc[r][2]);
496           *((u32*)ctx->keyschdec[r][3]) = *((u32*)ctx->keyschenc[r][3]);
497         }
498 #define W (ctx->keyschdec)
499       for (r = 1; r < ctx->rounds; r++)
500         {
501           w = W[r][0];
502           *((u32*)w) = *((u32*)U1[w[0]]) ^ *((u32*)U2[w[1]])
503             ^ *((u32*)U3[w[2]]) ^ *((u32*)U4[w[3]]);
504
505           w = W[r][1];
506           *((u32*)w) = *((u32*)U1[w[0]]) ^ *((u32*)U2[w[1]])
507             ^ *((u32*)U3[w[2]]) ^ *((u32*)U4[w[3]]);
508
509           w = W[r][2];
510           *((u32*)w) = *((u32*)U1[w[0]]) ^ *((u32*)U2[w[1]])
511         ^ *((u32*)U3[w[2]]) ^ *((u32*)U4[w[3]]);
512
513           w = W[r][3];
514           *((u32*)w) = *((u32*)U1[w[0]]) ^ *((u32*)U2[w[1]])
515             ^ *((u32*)U3[w[2]]) ^ *((u32*)U4[w[3]]);
516         }
517 #undef W
518 #undef w
519     }
520 }
521
522 \f
523 /* Encrypt one block.  A and B need to be aligned on a 4 byte
524    boundary.  A and B may be the same. */
525 static void
526 do_encrypt_aligned (const RIJNDAEL_context *ctx,
527                     unsigned char *b, const unsigned char *a)
528 {
529 #define rk (ctx->keyschenc)
530   int rounds = ctx->rounds;
531   int r;
532   union
533   {
534     u32  tempu32[4];  /* Force correct alignment. */
535     byte temp[4][4];
536   } u;
537
538   *((u32_a_t*)u.temp[0]) = *((u32_a_t*)(a   )) ^ *((u32_a_t*)rk[0][0]);
539   *((u32_a_t*)u.temp[1]) = *((u32_a_t*)(a+ 4)) ^ *((u32_a_t*)rk[0][1]);
540   *((u32_a_t*)u.temp[2]) = *((u32_a_t*)(a+ 8)) ^ *((u32_a_t*)rk[0][2]);
541   *((u32_a_t*)u.temp[3]) = *((u32_a_t*)(a+12)) ^ *((u32_a_t*)rk[0][3]);
542   *((u32_a_t*)(b    ))   = (*((u32_a_t*)T1[u.temp[0][0]])
543                         ^ *((u32_a_t*)T2[u.temp[1][1]])
544                         ^ *((u32_a_t*)T3[u.temp[2][2]])
545                         ^ *((u32_a_t*)T4[u.temp[3][3]]));
546   *((u32_a_t*)(b + 4))   = (*((u32_a_t*)T1[u.temp[1][0]])
547                         ^ *((u32_a_t*)T2[u.temp[2][1]])
548                         ^ *((u32_a_t*)T3[u.temp[3][2]])
549                         ^ *((u32_a_t*)T4[u.temp[0][3]]));
550   *((u32_a_t*)(b + 8))   = (*((u32_a_t*)T1[u.temp[2][0]])
551                         ^ *((u32_a_t*)T2[u.temp[3][1]])
552                         ^ *((u32_a_t*)T3[u.temp[0][2]])
553                         ^ *((u32_a_t*)T4[u.temp[1][3]]));
554   *((u32_a_t*)(b +12))   = (*((u32_a_t*)T1[u.temp[3][0]])
555                         ^ *((u32_a_t*)T2[u.temp[0][1]])
556                         ^ *((u32_a_t*)T3[u.temp[1][2]])
557                         ^ *((u32_a_t*)T4[u.temp[2][3]]));
558
559   for (r = 1; r < rounds-1; r++)
560     {
561       *((u32_a_t*)u.temp[0]) = *((u32_a_t*)(b   )) ^ *((u32_a_t*)rk[r][0]);
562       *((u32_a_t*)u.temp[1]) = *((u32_a_t*)(b+ 4)) ^ *((u32_a_t*)rk[r][1]);
563       *((u32_a_t*)u.temp[2]) = *((u32_a_t*)(b+ 8)) ^ *((u32_a_t*)rk[r][2]);
564       *((u32_a_t*)u.temp[3]) = *((u32_a_t*)(b+12)) ^ *((u32_a_t*)rk[r][3]);
565
566       *((u32_a_t*)(b    ))   = (*((u32_a_t*)T1[u.temp[0][0]])
567                             ^ *((u32_a_t*)T2[u.temp[1][1]])
568                             ^ *((u32_a_t*)T3[u.temp[2][2]])
569                             ^ *((u32_a_t*)T4[u.temp[3][3]]));
570       *((u32_a_t*)(b + 4))   = (*((u32_a_t*)T1[u.temp[1][0]])
571                             ^ *((u32_a_t*)T2[u.temp[2][1]])
572                             ^ *((u32_a_t*)T3[u.temp[3][2]])
573                             ^ *((u32_a_t*)T4[u.temp[0][3]]));
574       *((u32_a_t*)(b + 8))   = (*((u32_a_t*)T1[u.temp[2][0]])
575                             ^ *((u32_a_t*)T2[u.temp[3][1]])
576                             ^ *((u32_a_t*)T3[u.temp[0][2]])
577                             ^ *((u32_a_t*)T4[u.temp[1][3]]));
578       *((u32_a_t*)(b +12))   = (*((u32_a_t*)T1[u.temp[3][0]])
579                             ^ *((u32_a_t*)T2[u.temp[0][1]])
580                             ^ *((u32_a_t*)T3[u.temp[1][2]])
581                             ^ *((u32_a_t*)T4[u.temp[2][3]]));
582     }
583
584   /* Last round is special. */
585   *((u32_a_t*)u.temp[0]) = *((u32_a_t*)(b   )) ^ *((u32_a_t*)rk[rounds-1][0]);
586   *((u32_a_t*)u.temp[1]) = *((u32_a_t*)(b+ 4)) ^ *((u32_a_t*)rk[rounds-1][1]);
587   *((u32_a_t*)u.temp[2]) = *((u32_a_t*)(b+ 8)) ^ *((u32_a_t*)rk[rounds-1][2]);
588   *((u32_a_t*)u.temp[3]) = *((u32_a_t*)(b+12)) ^ *((u32_a_t*)rk[rounds-1][3]);
589   b[ 0] = T1[u.temp[0][0]][1];
590   b[ 1] = T1[u.temp[1][1]][1];
591   b[ 2] = T1[u.temp[2][2]][1];
592   b[ 3] = T1[u.temp[3][3]][1];
593   b[ 4] = T1[u.temp[1][0]][1];
594   b[ 5] = T1[u.temp[2][1]][1];
595   b[ 6] = T1[u.temp[3][2]][1];
596   b[ 7] = T1[u.temp[0][3]][1];
597   b[ 8] = T1[u.temp[2][0]][1];
598   b[ 9] = T1[u.temp[3][1]][1];
599   b[10] = T1[u.temp[0][2]][1];
600   b[11] = T1[u.temp[1][3]][1];
601   b[12] = T1[u.temp[3][0]][1];
602   b[13] = T1[u.temp[0][1]][1];
603   b[14] = T1[u.temp[1][2]][1];
604   b[15] = T1[u.temp[2][3]][1];
605   *((u32_a_t*)(b   )) ^= *((u32_a_t*)rk[rounds][0]);
606   *((u32_a_t*)(b+ 4)) ^= *((u32_a_t*)rk[rounds][1]);
607   *((u32_a_t*)(b+ 8)) ^= *((u32_a_t*)rk[rounds][2]);
608   *((u32_a_t*)(b+12)) ^= *((u32_a_t*)rk[rounds][3]);
609 #undef rk
610 }
611
612
613 static void
614 do_encrypt (const RIJNDAEL_context *ctx,
615             unsigned char *bx, const unsigned char *ax)
616 {
617   /* BX and AX are not necessary correctly aligned.  Thus we might
618      need to copy them here.  We try to align to a 16 bytes.  */
619   if (((size_t)ax & 0x0f) || ((size_t)bx & 0x0f))
620     {
621       union
622       {
623         u32  dummy[4];
624         byte a[16] ATTR_ALIGNED_16;
625       } a;
626       union
627       {
628         u32  dummy[4];
629         byte b[16] ATTR_ALIGNED_16;
630       } b;
631
632       memcpy (a.a, ax, 16);
633       do_encrypt_aligned (ctx, b.b, a.a);
634       memcpy (bx, b.b, 16);
635     }
636   else
637     {
638       do_encrypt_aligned (ctx, bx, ax);
639     }
640 }
641
642
643 /* Encrypt or decrypt one block using the padlock engine.  A and B may
644    be the same. */
645 #ifdef USE_PADLOCK
646 static void
647 do_padlock (const RIJNDAEL_context *ctx, int decrypt_flag,
648             unsigned char *bx, const unsigned char *ax)
649 {
650   /* BX and AX are not necessary correctly aligned.  Thus we need to
651      copy them here. */
652   unsigned char a[16] __attribute__ ((aligned (16)));
653   unsigned char b[16] __attribute__ ((aligned (16)));
654   unsigned int cword[4] __attribute__ ((aligned (16)));
655   int blocks;
656
657   /* The control word fields are:
658       127:12   11:10 9     8     7     6     5     4     3:0
659       RESERVED KSIZE CRYPT INTER KEYGN CIPHR ALIGN DGEST ROUND  */
660   cword[0] = (ctx->rounds & 15);  /* (The mask is just a safeguard.)  */
661   cword[1] = 0;
662   cword[2] = 0;
663   cword[3] = 0;
664   if (decrypt_flag)
665     cword[0] |= 0x00000200;
666
667   memcpy (a, ax, 16);
668
669   blocks = 1; /* Init counter for just one block.  */
670 #ifdef __x86_64__
671   asm volatile
672     ("pushfq\n\t"          /* Force key reload.  */
673      "popfq\n\t"
674      ".byte 0xf3, 0x0f, 0xa7, 0xc8\n\t" /* REP XCRYPT ECB. */
675      : /* No output */
676      : "S" (a), "D" (b), "d" (cword), "b" (ctx->padlockkey), "c" (blocks)
677      : "cc", "memory"
678      );
679 #else
680   asm volatile
681     ("pushfl\n\t"          /* Force key reload.  */
682      "popfl\n\t"
683      "xchg %3, %%ebx\n\t"  /* Load key.  */
684      ".byte 0xf3, 0x0f, 0xa7, 0xc8\n\t" /* REP XCRYPT ECB. */
685      "xchg %3, %%ebx\n"    /* Restore GOT register.  */
686      : /* No output */
687      : "S" (a), "D" (b), "d" (cword), "r" (ctx->padlockkey), "c" (blocks)
688      : "cc", "memory"
689      );
690 #endif
691
692   memcpy (bx, b, 16);
693
694 }
695 #endif /*USE_PADLOCK*/
696
697
698 #ifdef USE_AESNI
699 /* Encrypt one block using the Intel AES-NI instructions.  A and B may
700    be the same; they need to be properly aligned to 16 bytes.
701
702    Our problem here is that gcc does not allow the "x" constraint for
703    SSE registers in asm unless you compile with -msse.  The common
704    wisdom is to use a separate file for SSE instructions and build it
705    separately.  This would require a lot of extra build system stuff,
706    similar to what we do in mpi/ for the asm stuff.  What we do
707    instead is to use standard registers and a bit more of plain asm
708    which copies the data and key stuff to the SSE registers and later
709    back.  If we decide to implement some block modes with parallelized
710    AES instructions, it might indeed be better to use plain asm ala
711    mpi/.  */
712 static void
713 do_aesni_enc_aligned (const RIJNDAEL_context *ctx,
714                       unsigned char *b, const unsigned char *a)
715 {
716 #define aesenc_xmm1_xmm0      ".byte 0x66, 0x0f, 0x38, 0xdc, 0xc1\n\t"
717 #define aesenclast_xmm1_xmm0  ".byte 0x66, 0x0f, 0x38, 0xdd, 0xc1\n\t"
718   /* Note: For now we relax the alignment requirement for A and B: It
719      does not make much difference because in many case we would need
720      to memcpy them to an extra buffer; using the movdqu is much faster
721      that memcpy and movdqa.  For CFB we know that the IV is properly
722      aligned but that is a special case.  We should better implement
723      CFB direct in asm.  */
724   asm volatile ("movdqu %[src], %%xmm0\n\t"     /* xmm0 := *a     */
725                 "movl   %[key], %%esi\n\t"      /* esi  := keyschenc */
726                 "movdqa (%%esi), %%xmm1\n\t"    /* xmm1 := key[0] */
727                 "pxor   %%xmm1, %%xmm0\n\t"     /* xmm0 ^= key[0] */
728                 "movdqa 0x10(%%esi), %%xmm1\n\t"
729                 aesenc_xmm1_xmm0
730                 "movdqa 0x20(%%esi), %%xmm1\n\t"
731                 aesenc_xmm1_xmm0
732                 "movdqa 0x30(%%esi), %%xmm1\n\t"
733                 aesenc_xmm1_xmm0
734                 "movdqa 0x40(%%esi), %%xmm1\n\t"
735                 aesenc_xmm1_xmm0
736                 "movdqa 0x50(%%esi), %%xmm1\n\t"
737                 aesenc_xmm1_xmm0
738                 "movdqa 0x60(%%esi), %%xmm1\n\t"
739                 aesenc_xmm1_xmm0
740                 "movdqa 0x70(%%esi), %%xmm1\n\t"
741                 aesenc_xmm1_xmm0
742                 "movdqa 0x80(%%esi), %%xmm1\n\t"
743                 aesenc_xmm1_xmm0
744                 "movdqa 0x90(%%esi), %%xmm1\n\t"
745                 aesenc_xmm1_xmm0
746                 "movdqa 0xa0(%%esi), %%xmm1\n\t"
747                 "cmp $10, %[rounds]\n\t"
748                 "jz .Lenclast%=\n\t"
749                 aesenc_xmm1_xmm0
750                 "movdqa 0xb0(%%esi), %%xmm1\n\t"
751                 aesenc_xmm1_xmm0
752                 "movdqa 0xc0(%%esi), %%xmm1\n\t"
753                 "cmp $12, %[rounds]\n\t"
754                 "jz .Lenclast%=\n\t"
755                 aesenc_xmm1_xmm0
756                 "movdqa 0xd0(%%esi), %%xmm1\n\t"
757                 aesenc_xmm1_xmm0
758                 "movdqa 0xe0(%%esi), %%xmm1\n"
759
760                 ".Lenclast%=:\n\t"
761                 aesenclast_xmm1_xmm0
762                 "movdqu %%xmm0, %[dst]\n"
763                 : [dst] "=m" (*b)
764                 : [src] "m" (*a),
765                   [key] "r" (ctx->keyschenc),
766                   [rounds] "r" (ctx->rounds)
767                 : "%esi", "cc", "memory");
768 #undef aesenc_xmm1_xmm0
769 #undef aesenclast_xmm1_xmm0
770 }
771
772
773 static void
774 do_aesni_dec_aligned (const RIJNDAEL_context *ctx,
775                       unsigned char *b, const unsigned char *a)
776 {
777 #define aesdec_xmm1_xmm0      ".byte 0x66, 0x0f, 0x38, 0xde, 0xc1\n\t"
778 #define aesdeclast_xmm1_xmm0  ".byte 0x66, 0x0f, 0x38, 0xdf, 0xc1\n\t"
779   asm volatile ("movdqu %[src], %%xmm0\n\t"     /* xmm0 := *a     */
780                 "movl   %[key], %%esi\n\t"
781                 "movdqa (%%esi), %%xmm1\n\t"
782                 "pxor   %%xmm1, %%xmm0\n\t"     /* xmm0 ^= key[0] */
783                 "movdqa 0x10(%%esi), %%xmm1\n\t"
784                 aesdec_xmm1_xmm0
785                 "movdqa 0x20(%%esi), %%xmm1\n\t"
786                 aesdec_xmm1_xmm0
787                 "movdqa 0x30(%%esi), %%xmm1\n\t"
788                 aesdec_xmm1_xmm0
789                 "movdqa 0x40(%%esi), %%xmm1\n\t"
790                 aesdec_xmm1_xmm0
791                 "movdqa 0x50(%%esi), %%xmm1\n\t"
792                 aesdec_xmm1_xmm0
793                 "movdqa 0x60(%%esi), %%xmm1\n\t"
794                 aesdec_xmm1_xmm0
795                 "movdqa 0x70(%%esi), %%xmm1\n\t"
796                 aesdec_xmm1_xmm0
797                 "movdqa 0x80(%%esi), %%xmm1\n\t"
798                 aesdec_xmm1_xmm0
799                 "movdqa 0x90(%%esi), %%xmm1\n\t"
800                 aesdec_xmm1_xmm0
801                 "movdqa 0xa0(%%esi), %%xmm1\n\t"
802                 "cmp $10, %[rounds]\n\t"
803                 "jz .Ldeclast%=\n\t"
804                 aesdec_xmm1_xmm0
805                 "movdqa 0xb0(%%esi), %%xmm1\n\t"
806                 aesdec_xmm1_xmm0
807                 "movdqa 0xc0(%%esi), %%xmm1\n\t"
808                 "cmp $12, %[rounds]\n\t"
809                 "jz .Ldeclast%=\n\t"
810                 aesdec_xmm1_xmm0
811                 "movdqa 0xd0(%%esi), %%xmm1\n\t"
812                 aesdec_xmm1_xmm0
813                 "movdqa 0xe0(%%esi), %%xmm1\n"
814
815                 ".Ldeclast%=:\n\t"
816                 aesdeclast_xmm1_xmm0
817                 "movdqu %%xmm0, %[dst]\n"
818                 : [dst] "=m" (*b)
819                 : [src] "m" (*a),
820                   [key] "r" (ctx->keyschdec),
821                   [rounds] "r" (ctx->rounds)
822                 : "%esi", "cc", "memory");
823 #undef aesdec_xmm1_xmm0
824 #undef aesdeclast_xmm1_xmm0
825 }
826
827
828 /* Perform a CFB encryption or decryption round using the
829    initialization vector IV and the input block A.  Write the result
830    to the output block B and update IV.  IV needs to be 16 byte
831    aligned.  */
832 static void
833 do_aesni_cfb (const RIJNDAEL_context *ctx, int decrypt_flag,
834               unsigned char *iv, unsigned char *b, const unsigned char *a)
835 {
836 #define aesenc_xmm1_xmm0      ".byte 0x66, 0x0f, 0x38, 0xdc, 0xc1\n\t"
837 #define aesenclast_xmm1_xmm0  ".byte 0x66, 0x0f, 0x38, 0xdd, 0xc1\n\t"
838   asm volatile ("movdqa %[iv], %%xmm0\n\t"      /* xmm0 := IV     */
839                 "movl   %[key], %%esi\n\t"      /* esi  := keyschenc */
840                 "movdqa (%%esi), %%xmm1\n\t"    /* xmm1 := key[0] */
841                 "pxor   %%xmm1, %%xmm0\n\t"     /* xmm0 ^= key[0] */
842                 "movdqa 0x10(%%esi), %%xmm1\n\t"
843                 aesenc_xmm1_xmm0
844                 "movdqa 0x20(%%esi), %%xmm1\n\t"
845                 aesenc_xmm1_xmm0
846                 "movdqa 0x30(%%esi), %%xmm1\n\t"
847                 aesenc_xmm1_xmm0
848                 "movdqa 0x40(%%esi), %%xmm1\n\t"
849                 aesenc_xmm1_xmm0
850                 "movdqa 0x50(%%esi), %%xmm1\n\t"
851                 aesenc_xmm1_xmm0
852                 "movdqa 0x60(%%esi), %%xmm1\n\t"
853                 aesenc_xmm1_xmm0
854                 "movdqa 0x70(%%esi), %%xmm1\n\t"
855                 aesenc_xmm1_xmm0
856                 "movdqa 0x80(%%esi), %%xmm1\n\t"
857                 aesenc_xmm1_xmm0
858                 "movdqa 0x90(%%esi), %%xmm1\n\t"
859                 aesenc_xmm1_xmm0
860                 "movdqa 0xa0(%%esi), %%xmm1\n\t"
861                 "cmp $10, %[rounds]\n\t"
862                 "jz .Lenclast%=\n\t"
863                 aesenc_xmm1_xmm0
864                 "movdqa 0xb0(%%esi), %%xmm1\n\t"
865                 aesenc_xmm1_xmm0
866                 "movdqa 0xc0(%%esi), %%xmm1\n\t"
867                 "cmp $12, %[rounds]\n\t"
868                 "jz .Lenclast%=\n\t"
869                 aesenc_xmm1_xmm0
870                 "movdqa 0xd0(%%esi), %%xmm1\n\t"
871                 aesenc_xmm1_xmm0
872                 "movdqa 0xe0(%%esi), %%xmm1\n"
873
874                 ".Lenclast%=:\n\t"
875                 aesenclast_xmm1_xmm0
876                 "movdqu %[src], %%xmm1\n\t"      /* Save input.  */
877                 "pxor %%xmm1, %%xmm0\n\t"        /* xmm0 = input ^ IV  */
878
879                 "cmp $1, %[decrypt]\n\t"
880                 "jz .Ldecrypt_%=\n\t"
881                 "movdqa %%xmm0, %[iv]\n\t"       /* [encrypt] Store IV.  */
882                 "jmp .Lleave_%=\n"
883                 ".Ldecrypt_%=:\n\t"
884                 "movdqa %%xmm1, %[iv]\n"         /* [decrypt] Store IV.  */
885                 ".Lleave_%=:\n\t"
886                 "movdqu %%xmm0, %[dst]\n"        /* Store output.   */
887                 : [iv] "+m" (*iv), [dst] "=m" (*b)
888                 : [src] "m" (*a),
889                   [key] "g" (ctx->keyschenc),
890                   [rounds] "g" (ctx->rounds),
891                   [decrypt] "m" (decrypt_flag)
892                 : "%esi", "cc", "memory");
893 #undef aesenc_xmm1_xmm0
894 #undef aesenclast_xmm1_xmm0
895 }
896
897 /* Perform a CTR encryption round using the counter CTR and the input
898    block A.  Write the result to the output block B and update CTR.
899    CTR needs to be a 16 byte aligned little-endian value.  */
900 static void
901 do_aesni_ctr (const RIJNDAEL_context *ctx,
902               unsigned char *ctr, unsigned char *b, const unsigned char *a)
903 {
904 #define aesenc_xmm1_xmm0      ".byte 0x66, 0x0f, 0x38, 0xdc, 0xc1\n\t"
905 #define aesenclast_xmm1_xmm0  ".byte 0x66, 0x0f, 0x38, 0xdd, 0xc1\n\t"
906   static unsigned char be_mask[16] __attribute__ ((aligned (16))) =
907     { 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
908
909   asm volatile ("movdqa %[ctr], %%xmm0\n\t"     /* xmm0, xmm2 := CTR   */
910                 "movaps %%xmm0, %%xmm2\n\t"
911                 "mov    $1, %%esi\n\t"          /* xmm2++ (big-endian) */
912                 "movd   %%esi, %%xmm1\n\t"
913                 "pshufb %[mask], %%xmm2\n\t"
914                 "paddq  %%xmm1, %%xmm2\n\t"
915                 "pshufb %[mask], %%xmm2\n\t"
916                 "movdqa %%xmm2, %[ctr]\n"       /* Update CTR.         */
917
918                 "movl   %[key], %%esi\n\t"      /* esi  := keyschenc */
919                 "movdqa (%%esi), %%xmm1\n\t"    /* xmm1 := key[0]    */
920                 "pxor   %%xmm1, %%xmm0\n\t"     /* xmm0 ^= key[0]    */
921                 "movdqa 0x10(%%esi), %%xmm1\n\t"
922                 aesenc_xmm1_xmm0
923                 "movdqa 0x20(%%esi), %%xmm1\n\t"
924                 aesenc_xmm1_xmm0
925                 "movdqa 0x30(%%esi), %%xmm1\n\t"
926                 aesenc_xmm1_xmm0
927                 "movdqa 0x40(%%esi), %%xmm1\n\t"
928                 aesenc_xmm1_xmm0
929                 "movdqa 0x50(%%esi), %%xmm1\n\t"
930                 aesenc_xmm1_xmm0
931                 "movdqa 0x60(%%esi), %%xmm1\n\t"
932                 aesenc_xmm1_xmm0
933                 "movdqa 0x70(%%esi), %%xmm1\n\t"
934                 aesenc_xmm1_xmm0
935                 "movdqa 0x80(%%esi), %%xmm1\n\t"
936                 aesenc_xmm1_xmm0
937                 "movdqa 0x90(%%esi), %%xmm1\n\t"
938                 aesenc_xmm1_xmm0
939                 "movdqa 0xa0(%%esi), %%xmm1\n\t"
940                 "cmp $10, %[rounds]\n\t"
941                 "jz .Lenclast%=\n\t"
942                 aesenc_xmm1_xmm0
943                 "movdqa 0xb0(%%esi), %%xmm1\n\t"
944                 aesenc_xmm1_xmm0
945                 "movdqa 0xc0(%%esi), %%xmm1\n\t"
946                 "cmp $12, %[rounds]\n\t"
947                 "jz .Lenclast%=\n\t"
948                 aesenc_xmm1_xmm0
949                 "movdqa 0xd0(%%esi), %%xmm1\n\t"
950                 aesenc_xmm1_xmm0
951                 "movdqa 0xe0(%%esi), %%xmm1\n"
952
953                 ".Lenclast%=:\n\t"
954                 aesenclast_xmm1_xmm0
955                 "movdqu %[src], %%xmm1\n\t"      /* xmm1 := input   */
956                 "pxor %%xmm1, %%xmm0\n\t"        /* EncCTR ^= input  */
957                 "movdqu %%xmm0, %[dst]"          /* Store EncCTR.    */
958
959                 : [ctr] "+m" (*ctr), [dst] "=m" (*b)
960                 : [src] "m" (*a),
961                   [key] "g" (ctx->keyschenc),
962                   [rounds] "g" (ctx->rounds),
963                   [mask] "m" (*be_mask)
964                 : "%esi", "cc", "memory");
965 #undef aesenc_xmm1_xmm0
966 #undef aesenclast_xmm1_xmm0
967 }
968
969
970 /* Four blocks at a time variant of do_aesni_ctr.  */
971 static void
972 do_aesni_ctr_4 (const RIJNDAEL_context *ctx,
973                 unsigned char *ctr, unsigned char *b, const unsigned char *a)
974 {
975 #define aesenc_xmm1_xmm0      ".byte 0x66, 0x0f, 0x38, 0xdc, 0xc1\n\t"
976 #define aesenc_xmm1_xmm2      ".byte 0x66, 0x0f, 0x38, 0xdc, 0xd1\n\t"
977 #define aesenc_xmm1_xmm3      ".byte 0x66, 0x0f, 0x38, 0xdc, 0xd9\n\t"
978 #define aesenc_xmm1_xmm4      ".byte 0x66, 0x0f, 0x38, 0xdc, 0xe1\n\t"
979 #define aesenclast_xmm1_xmm0  ".byte 0x66, 0x0f, 0x38, 0xdd, 0xc1\n\t"
980 #define aesenclast_xmm1_xmm2  ".byte 0x66, 0x0f, 0x38, 0xdd, 0xd1\n\t"
981 #define aesenclast_xmm1_xmm3  ".byte 0x66, 0x0f, 0x38, 0xdd, 0xd9\n\t"
982 #define aesenclast_xmm1_xmm4  ".byte 0x66, 0x0f, 0x38, 0xdd, 0xe1\n\t"
983
984   static unsigned char be_mask[16] __attribute__ ((aligned (16))) =
985     { 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
986
987   /* Register usage:
988       esi   keyschedule
989       xmm0  CTR-0
990       xmm1  temp / round key
991       xmm2  CTR-1
992       xmm3  CTR-2
993       xmm4  CTR-3
994       xmm5  temp
995    */
996
997   asm volatile ("movdqa %[ctr], %%xmm0\n\t"     /* xmm0, xmm2 := CTR   */
998                 "movaps %%xmm0, %%xmm2\n\t"
999                 "mov    $1, %%esi\n\t"          /* xmm1 := 1 */
1000                 "movd   %%esi, %%xmm1\n\t"
1001                 "pshufb %[mask], %%xmm2\n\t"    /* xmm2 := le(xmm2) */
1002                 "paddq  %%xmm1, %%xmm2\n\t"     /* xmm2++           */
1003                 "movaps %%xmm2, %%xmm3\n\t"     /* xmm3 := xmm2     */
1004                 "paddq  %%xmm1, %%xmm3\n\t"     /* xmm3++           */
1005                 "movaps %%xmm3, %%xmm4\n\t"     /* xmm4 := xmm3     */
1006                 "paddq  %%xmm1, %%xmm4\n\t"     /* xmm4++           */
1007                 "movaps %%xmm4, %%xmm5\n\t"     /* xmm5 := xmm4     */
1008                 "paddq  %%xmm1, %%xmm5\n\t"     /* xmm5++           */
1009                 "pshufb %[mask], %%xmm2\n\t"    /* xmm2 := be(xmm2) */
1010                 "pshufb %[mask], %%xmm3\n\t"    /* xmm3 := be(xmm3) */
1011                 "pshufb %[mask], %%xmm4\n\t"    /* xmm4 := be(xmm4) */
1012                 "pshufb %[mask], %%xmm5\n\t"    /* xmm5 := be(xmm5) */
1013                 "movdqa %%xmm5, %[ctr]\n"       /* Update CTR.      */
1014
1015                 "movl   %[key], %%esi\n\t"      /* esi  := keyschenc */
1016                 "movdqa (%%esi), %%xmm1\n\t"    /* xmm1 := key[0]    */
1017                 "pxor   %%xmm1, %%xmm0\n\t"     /* xmm0 ^= key[0]    */
1018                 "pxor   %%xmm1, %%xmm2\n\t"     /* xmm2 ^= key[0]    */
1019                 "pxor   %%xmm1, %%xmm3\n\t"     /* xmm3 ^= key[0]    */
1020                 "pxor   %%xmm1, %%xmm4\n\t"     /* xmm4 ^= key[0]    */
1021                 "movdqa 0x10(%%esi), %%xmm1\n\t"
1022                 aesenc_xmm1_xmm0
1023                 aesenc_xmm1_xmm2
1024                 aesenc_xmm1_xmm3
1025                 aesenc_xmm1_xmm4
1026                 "movdqa 0x20(%%esi), %%xmm1\n\t"
1027                 aesenc_xmm1_xmm0
1028                 aesenc_xmm1_xmm2
1029                 aesenc_xmm1_xmm3
1030                 aesenc_xmm1_xmm4
1031                 "movdqa 0x30(%%esi), %%xmm1\n\t"
1032                 aesenc_xmm1_xmm0
1033                 aesenc_xmm1_xmm2
1034                 aesenc_xmm1_xmm3
1035                 aesenc_xmm1_xmm4
1036                 "movdqa 0x40(%%esi), %%xmm1\n\t"
1037                 aesenc_xmm1_xmm0
1038                 aesenc_xmm1_xmm2
1039                 aesenc_xmm1_xmm3
1040                 aesenc_xmm1_xmm4
1041                 "movdqa 0x50(%%esi), %%xmm1\n\t"
1042                 aesenc_xmm1_xmm0
1043                 aesenc_xmm1_xmm2
1044                 aesenc_xmm1_xmm3
1045                 aesenc_xmm1_xmm4
1046                 "movdqa 0x60(%%esi), %%xmm1\n\t"
1047                 aesenc_xmm1_xmm0
1048                 aesenc_xmm1_xmm2
1049                 aesenc_xmm1_xmm3
1050                 aesenc_xmm1_xmm4
1051                 "movdqa 0x70(%%esi), %%xmm1\n\t"
1052                 aesenc_xmm1_xmm0
1053                 aesenc_xmm1_xmm2
1054                 aesenc_xmm1_xmm3
1055                 aesenc_xmm1_xmm4
1056                 "movdqa 0x80(%%esi), %%xmm1\n\t"
1057                 aesenc_xmm1_xmm0
1058                 aesenc_xmm1_xmm2
1059                 aesenc_xmm1_xmm3
1060                 aesenc_xmm1_xmm4
1061                 "movdqa 0x90(%%esi), %%xmm1\n\t"
1062                 aesenc_xmm1_xmm0
1063                 aesenc_xmm1_xmm2
1064                 aesenc_xmm1_xmm3
1065                 aesenc_xmm1_xmm4
1066                 "movdqa 0xa0(%%esi), %%xmm1\n\t"
1067                 "cmp $10, %[rounds]\n\t"
1068                 "jz .Lenclast%=\n\t"
1069                 aesenc_xmm1_xmm0
1070                 aesenc_xmm1_xmm2
1071                 aesenc_xmm1_xmm3
1072                 aesenc_xmm1_xmm4
1073                 "movdqa 0xb0(%%esi), %%xmm1\n\t"
1074                 aesenc_xmm1_xmm0
1075                 aesenc_xmm1_xmm2
1076                 aesenc_xmm1_xmm3
1077                 aesenc_xmm1_xmm4
1078                 "movdqa 0xc0(%%esi), %%xmm1\n\t"
1079                 "cmp $12, %[rounds]\n\t"
1080                 "jz .Lenclast%=\n\t"
1081                 aesenc_xmm1_xmm0
1082                 aesenc_xmm1_xmm2
1083                 aesenc_xmm1_xmm3
1084                 aesenc_xmm1_xmm4
1085                 "movdqa 0xd0(%%esi), %%xmm1\n\t"
1086                 aesenc_xmm1_xmm0
1087                 aesenc_xmm1_xmm2
1088                 aesenc_xmm1_xmm3
1089                 aesenc_xmm1_xmm4
1090                 "movdqa 0xe0(%%esi), %%xmm1\n"
1091
1092                 ".Lenclast%=:\n\t"
1093                 aesenclast_xmm1_xmm0
1094                 aesenclast_xmm1_xmm2
1095                 aesenclast_xmm1_xmm3
1096                 aesenclast_xmm1_xmm4
1097
1098                 "movdqu %[src], %%xmm1\n\t"      /* Get block 1.      */
1099                 "pxor %%xmm1, %%xmm0\n\t"        /* EncCTR-1 ^= input */
1100                 "movdqu %%xmm0, %[dst]\n\t"      /* Store block 1     */
1101
1102                 "movdqu (16)%[src], %%xmm1\n\t"  /* Get block 2.      */
1103                 "pxor %%xmm1, %%xmm2\n\t"        /* EncCTR-2 ^= input */
1104                 "movdqu %%xmm2, (16)%[dst]\n\t"  /* Store block 2.    */
1105
1106                 "movdqu (32)%[src], %%xmm1\n\t"  /* Get block 3.      */
1107                 "pxor %%xmm1, %%xmm3\n\t"        /* EncCTR-3 ^= input */
1108                 "movdqu %%xmm3, (32)%[dst]\n\t"  /* Store block 3.    */
1109
1110                 "movdqu (48)%[src], %%xmm1\n\t"  /* Get block 4.      */
1111                 "pxor %%xmm1, %%xmm4\n\t"        /* EncCTR-4 ^= input */
1112                 "movdqu %%xmm4, (48)%[dst]"      /* Store block 4.   */
1113
1114                 : [ctr] "+m" (*ctr), [dst] "=m" (*b)
1115                 : [src] "m" (*a),
1116                   [key] "g" (ctx->keyschenc),
1117                   [rounds] "g" (ctx->rounds),
1118                   [mask] "m" (*be_mask)
1119                 : "%esi", "cc", "memory");
1120 #undef aesenc_xmm1_xmm0
1121 #undef aesenc_xmm1_xmm2
1122 #undef aesenc_xmm1_xmm3
1123 #undef aesenc_xmm1_xmm4
1124 #undef aesenclast_xmm1_xmm0
1125 #undef aesenclast_xmm1_xmm2
1126 #undef aesenclast_xmm1_xmm3
1127 #undef aesenclast_xmm1_xmm4
1128 }
1129
1130
1131 static void
1132 do_aesni (RIJNDAEL_context *ctx, int decrypt_flag,
1133           unsigned char *bx, const unsigned char *ax)
1134 {
1135
1136   if (decrypt_flag)
1137     {
1138       if (!ctx->decryption_prepared )
1139         {
1140           prepare_decryption ( ctx );
1141           ctx->decryption_prepared = 1;
1142         }
1143       do_aesni_dec_aligned (ctx, bx, ax);
1144     }
1145   else
1146     do_aesni_enc_aligned (ctx, bx, ax);
1147 }
1148 #endif /*USE_AESNI*/
1149
1150
1151 static void
1152 rijndael_encrypt (void *context, byte *b, const byte *a)
1153 {
1154   RIJNDAEL_context *ctx = context;
1155
1156   if (0)
1157     ;
1158 #ifdef USE_PADLOCK
1159   else if (ctx->use_padlock)
1160     {
1161       do_padlock (ctx, 0, b, a);
1162       _gcry_burn_stack (48 + 15 /* possible padding for alignment */);
1163     }
1164 #endif /*USE_PADLOCK*/
1165 #ifdef USE_AESNI
1166   else if (ctx->use_aesni)
1167     {
1168       aesni_prepare ();
1169       do_aesni (ctx, 0, b, a);
1170       aesni_cleanup ();
1171     }
1172 #endif /*USE_AESNI*/
1173   else
1174     {
1175       do_encrypt (ctx, b, a);
1176       _gcry_burn_stack (56 + 2*sizeof(int));
1177     }
1178 }
1179
1180
1181 /* Bulk encryption of complete blocks in CFB mode.  Caller needs to
1182    make sure that IV is aligned on an unsigned long boundary.  This
1183    function is only intended for the bulk encryption feature of
1184    cipher.c. */
1185 void
1186 _gcry_aes_cfb_enc (void *context, unsigned char *iv,
1187                    void *outbuf_arg, const void *inbuf_arg,
1188                    unsigned int nblocks)
1189 {
1190   RIJNDAEL_context *ctx = context;
1191   unsigned char *outbuf = outbuf_arg;
1192   const unsigned char *inbuf = inbuf_arg;
1193   unsigned char *ivp;
1194   int i;
1195
1196   if (0)
1197     ;
1198 #ifdef USE_PADLOCK
1199   else if (ctx->use_padlock)
1200     {
1201       /* Fixme: Let Padlock do the CFBing.  */
1202       for ( ;nblocks; nblocks-- )
1203         {
1204           /* Encrypt the IV. */
1205           do_padlock (ctx, 0, iv, iv);
1206           /* XOR the input with the IV and store input into IV.  */
1207           for (ivp=iv,i=0; i < BLOCKSIZE; i++ )
1208             *outbuf++ = (*ivp++ ^= *inbuf++);
1209         }
1210     }
1211 #endif /*USE_PADLOCK*/
1212 #ifdef USE_AESNI
1213   else if (ctx->use_aesni)
1214     {
1215       aesni_prepare ();
1216       for ( ;nblocks; nblocks-- )
1217         {
1218           do_aesni_cfb (ctx, 0, iv, outbuf, inbuf);
1219           outbuf += BLOCKSIZE;
1220           inbuf  += BLOCKSIZE;
1221         }
1222       aesni_cleanup ();
1223     }
1224 #endif /*USE_AESNI*/
1225   else
1226     {
1227       for ( ;nblocks; nblocks-- )
1228         {
1229           /* Encrypt the IV. */
1230           do_encrypt_aligned (ctx, iv, iv);
1231           /* XOR the input with the IV and store input into IV.  */
1232           for (ivp=iv,i=0; i < BLOCKSIZE; i++ )
1233             *outbuf++ = (*ivp++ ^= *inbuf++);
1234         }
1235     }
1236
1237   _gcry_burn_stack (48 + 2*sizeof(int));
1238 }
1239
1240
1241 /* Bulk encryption of complete blocks in CBC mode.  Caller needs to
1242    make sure that IV is aligned on an unsigned long boundary.  This
1243    function is only intended for the bulk encryption feature of
1244    cipher.c. */
1245 void
1246 _gcry_aes_cbc_enc (void *context, unsigned char *iv,
1247                    void *outbuf_arg, const void *inbuf_arg,
1248                    unsigned int nblocks, int cbc_mac)
1249 {
1250   RIJNDAEL_context *ctx = context;
1251   unsigned char *outbuf = outbuf_arg;
1252   const unsigned char *inbuf = inbuf_arg;
1253   unsigned char *ivp;
1254   int i;
1255
1256   aesni_prepare ();
1257   for ( ;nblocks; nblocks-- )
1258     {
1259       for (ivp=iv, i=0; i < BLOCKSIZE; i++ )
1260         outbuf[i] = inbuf[i] ^ *ivp++;
1261
1262       if (0)
1263         ;
1264 #ifdef USE_PADLOCK
1265       else if (ctx->use_padlock)
1266         do_padlock (ctx, 0, outbuf, outbuf);
1267 #endif /*USE_PADLOCK*/
1268 #ifdef USE_AESNI
1269       else if (ctx->use_aesni)
1270         do_aesni (ctx, 0, outbuf, outbuf);
1271 #endif /*USE_AESNI*/
1272       else
1273         do_encrypt (ctx, outbuf, outbuf );
1274
1275       memcpy (iv, outbuf, BLOCKSIZE);
1276       inbuf += BLOCKSIZE;
1277       if (!cbc_mac)
1278         outbuf += BLOCKSIZE;
1279     }
1280   aesni_cleanup ();
1281
1282   _gcry_burn_stack (48 + 2*sizeof(int));
1283 }
1284
1285
1286 /* Bulk encryption of complete blocks in CTR mode.  Caller needs to
1287    make sure that CTR is aligned on a 16 byte boundary if AESNI; the
1288    minimum alignment is for an u32.  This function is only intended
1289    for the bulk encryption feature of cipher.c.  CTR is expected to be
1290    of size BLOCKSIZE. */
1291 void
1292 _gcry_aes_ctr_enc (void *context, unsigned char *ctr,
1293                    void *outbuf_arg, const void *inbuf_arg,
1294                    unsigned int nblocks)
1295 {
1296   RIJNDAEL_context *ctx = context;
1297   unsigned char *outbuf = outbuf_arg;
1298   const unsigned char *inbuf = inbuf_arg;
1299   unsigned char *p;
1300   int i;
1301
1302   if (0)
1303     ;
1304 #ifdef USE_AESNI
1305   else if (ctx->use_aesni)
1306     {
1307       aesni_prepare ();
1308       for ( ;nblocks > 3 ; nblocks -= 4 )
1309         {
1310           do_aesni_ctr_4 (ctx, ctr, outbuf, inbuf);
1311           outbuf += 4*BLOCKSIZE;
1312           inbuf  += 4*BLOCKSIZE;
1313         }
1314       for ( ;nblocks; nblocks-- )
1315         {
1316           do_aesni_ctr (ctx, ctr, outbuf, inbuf);
1317           outbuf += BLOCKSIZE;
1318           inbuf  += BLOCKSIZE;
1319         }
1320       aesni_cleanup ();
1321       aesni_cleanup_2_4 ();
1322     }
1323 #endif /*USE_AESNI*/
1324   else
1325     {
1326       union { unsigned char x1[16]; u32 x32[4]; } tmp;
1327
1328       for ( ;nblocks; nblocks-- )
1329         {
1330           /* Encrypt the counter. */
1331           do_encrypt_aligned (ctx, tmp.x1, ctr);
1332           /* XOR the input with the encrypted counter and store in output.  */
1333           for (p=tmp.x1, i=0; i < BLOCKSIZE; i++)
1334             *outbuf++ = (*p++ ^= *inbuf++);
1335           /* Increment the counter.  */
1336           for (i = BLOCKSIZE; i > 0; i--)
1337             {
1338               ctr[i-1]++;
1339               if (ctr[i-1])
1340                 break;
1341             }
1342         }
1343     }
1344
1345   _gcry_burn_stack (48 + 2*sizeof(int));
1346 }
1347
1348
1349 \f
1350 /* Decrypt one block.  A and B need to be aligned on a 4 byte boundary
1351    and the decryption must have been prepared.  A and B may be the
1352    same. */
1353 static void
1354 do_decrypt_aligned (RIJNDAEL_context *ctx,
1355                     unsigned char *b, const unsigned char *a)
1356 {
1357 #define rk  (ctx->keyschdec)
1358   int rounds = ctx->rounds;
1359   int r;
1360   union
1361   {
1362     u32  tempu32[4];  /* Force correct alignment. */
1363     byte temp[4][4];
1364   } u;
1365
1366
1367   *((u32_a_t*)u.temp[0]) = *((u32_a_t*)(a   )) ^ *((u32_a_t*)rk[rounds][0]);
1368   *((u32_a_t*)u.temp[1]) = *((u32_a_t*)(a+ 4)) ^ *((u32_a_t*)rk[rounds][1]);
1369   *((u32_a_t*)u.temp[2]) = *((u32_a_t*)(a+ 8)) ^ *((u32_a_t*)rk[rounds][2]);
1370   *((u32_a_t*)u.temp[3]) = *((u32_a_t*)(a+12)) ^ *((u32_a_t*)rk[rounds][3]);
1371
1372   *((u32_a_t*)(b   ))    = (*((u32_a_t*)T5[u.temp[0][0]])
1373                         ^ *((u32_a_t*)T6[u.temp[3][1]])
1374                         ^ *((u32_a_t*)T7[u.temp[2][2]])
1375                         ^ *((u32_a_t*)T8[u.temp[1][3]]));
1376   *((u32_a_t*)(b+ 4))    = (*((u32_a_t*)T5[u.temp[1][0]])
1377                         ^ *((u32_a_t*)T6[u.temp[0][1]])
1378                         ^ *((u32_a_t*)T7[u.temp[3][2]])
1379                         ^ *((u32_a_t*)T8[u.temp[2][3]]));
1380   *((u32_a_t*)(b+ 8))    = (*((u32_a_t*)T5[u.temp[2][0]])
1381                         ^ *((u32_a_t*)T6[u.temp[1][1]])
1382                         ^ *((u32_a_t*)T7[u.temp[0][2]])
1383                         ^ *((u32_a_t*)T8[u.temp[3][3]]));
1384   *((u32_a_t*)(b+12))    = (*((u32_a_t*)T5[u.temp[3][0]])
1385                         ^ *((u32_a_t*)T6[u.temp[2][1]])
1386                         ^ *((u32_a_t*)T7[u.temp[1][2]])
1387                         ^ *((u32_a_t*)T8[u.temp[0][3]]));
1388
1389   for (r = rounds-1; r > 1; r--)
1390     {
1391       *((u32_a_t*)u.temp[0]) = *((u32_a_t*)(b   )) ^ *((u32_a_t*)rk[r][0]);
1392       *((u32_a_t*)u.temp[1]) = *((u32_a_t*)(b+ 4)) ^ *((u32_a_t*)rk[r][1]);
1393       *((u32_a_t*)u.temp[2]) = *((u32_a_t*)(b+ 8)) ^ *((u32_a_t*)rk[r][2]);
1394       *((u32_a_t*)u.temp[3]) = *((u32_a_t*)(b+12)) ^ *((u32_a_t*)rk[r][3]);
1395       *((u32_a_t*)(b   ))    = (*((u32_a_t*)T5[u.temp[0][0]])
1396                             ^ *((u32_a_t*)T6[u.temp[3][1]])
1397                             ^ *((u32_a_t*)T7[u.temp[2][2]])
1398                             ^ *((u32_a_t*)T8[u.temp[1][3]]));
1399       *((u32_a_t*)(b+ 4))    = (*((u32_a_t*)T5[u.temp[1][0]])
1400                             ^ *((u32_a_t*)T6[u.temp[0][1]])
1401                             ^ *((u32_a_t*)T7[u.temp[3][2]])
1402                             ^ *((u32_a_t*)T8[u.temp[2][3]]));
1403       *((u32_a_t*)(b+ 8))    = (*((u32_a_t*)T5[u.temp[2][0]])
1404                             ^ *((u32_a_t*)T6[u.temp[1][1]])
1405                             ^ *((u32_a_t*)T7[u.temp[0][2]])
1406                             ^ *((u32_a_t*)T8[u.temp[3][3]]));
1407       *((u32_a_t*)(b+12))    = (*((u32_a_t*)T5[u.temp[3][0]])
1408                             ^ *((u32_a_t*)T6[u.temp[2][1]])
1409                             ^ *((u32_a_t*)T7[u.temp[1][2]])
1410                             ^ *((u32_a_t*)T8[u.temp[0][3]]));
1411     }
1412
1413   /* Last round is special. */
1414   *((u32_a_t*)u.temp[0]) = *((u32_a_t*)(b   )) ^ *((u32_a_t*)rk[1][0]);
1415   *((u32_a_t*)u.temp[1]) = *((u32_a_t*)(b+ 4)) ^ *((u32_a_t*)rk[1][1]);
1416   *((u32_a_t*)u.temp[2]) = *((u32_a_t*)(b+ 8)) ^ *((u32_a_t*)rk[1][2]);
1417   *((u32_a_t*)u.temp[3]) = *((u32_a_t*)(b+12)) ^ *((u32_a_t*)rk[1][3]);
1418   b[ 0] = S5[u.temp[0][0]];
1419   b[ 1] = S5[u.temp[3][1]];
1420   b[ 2] = S5[u.temp[2][2]];
1421   b[ 3] = S5[u.temp[1][3]];
1422   b[ 4] = S5[u.temp[1][0]];
1423   b[ 5] = S5[u.temp[0][1]];
1424   b[ 6] = S5[u.temp[3][2]];
1425   b[ 7] = S5[u.temp[2][3]];
1426   b[ 8] = S5[u.temp[2][0]];
1427   b[ 9] = S5[u.temp[1][1]];
1428   b[10] = S5[u.temp[0][2]];
1429   b[11] = S5[u.temp[3][3]];
1430   b[12] = S5[u.temp[3][0]];
1431   b[13] = S5[u.temp[2][1]];
1432   b[14] = S5[u.temp[1][2]];
1433   b[15] = S5[u.temp[0][3]];
1434   *((u32_a_t*)(b   )) ^= *((u32_a_t*)rk[0][0]);
1435   *((u32_a_t*)(b+ 4)) ^= *((u32_a_t*)rk[0][1]);
1436   *((u32_a_t*)(b+ 8)) ^= *((u32_a_t*)rk[0][2]);
1437   *((u32_a_t*)(b+12)) ^= *((u32_a_t*)rk[0][3]);
1438 #undef rk
1439 }
1440
1441
1442 /* Decrypt one block.  AX and BX may be the same. */
1443 static void
1444 do_decrypt (RIJNDAEL_context *ctx, byte *bx, const byte *ax)
1445 {
1446   if ( !ctx->decryption_prepared )
1447     {
1448       prepare_decryption ( ctx );
1449       _gcry_burn_stack (64);
1450       ctx->decryption_prepared = 1;
1451     }
1452
1453   /* BX and AX are not necessary correctly aligned.  Thus we might
1454      need to copy them here.  We try to align to a 16 bytes. */
1455   if (((size_t)ax & 0x0f) || ((size_t)bx & 0x0f))
1456     {
1457       union
1458       {
1459         u32  dummy[4];
1460         byte a[16] ATTR_ALIGNED_16;
1461       } a;
1462       union
1463       {
1464         u32  dummy[4];
1465         byte b[16] ATTR_ALIGNED_16;
1466       } b;
1467
1468       memcpy (a.a, ax, 16);
1469       do_decrypt_aligned (ctx, b.b, a.a);
1470       memcpy (bx, b.b, 16);
1471     }
1472   else
1473     {
1474       do_decrypt_aligned (ctx, bx, ax);
1475     }
1476 }
1477
1478
1479
1480
1481 static void
1482 rijndael_decrypt (void *context, byte *b, const byte *a)
1483 {
1484   RIJNDAEL_context *ctx = context;
1485
1486   if (0)
1487     ;
1488 #ifdef USE_PADLOCK
1489   else if (ctx->use_padlock)
1490     {
1491       do_padlock (ctx, 1, b, a);
1492       _gcry_burn_stack (48 + 2*sizeof(int) /* FIXME */);
1493     }
1494 #endif /*USE_PADLOCK*/
1495 #ifdef USE_AESNI
1496   else if (ctx->use_aesni)
1497     {
1498       aesni_prepare ();
1499       do_aesni (ctx, 1, b, a);
1500       aesni_cleanup ();
1501     }
1502 #endif /*USE_AESNI*/
1503   else
1504     {
1505       do_decrypt (ctx, b, a);
1506       _gcry_burn_stack (56+2*sizeof(int));
1507     }
1508 }
1509
1510
1511 /* Bulk decryption of complete blocks in CFB mode.  Caller needs to
1512    make sure that IV is aligned on an unisgned lonhg boundary.  This
1513    function is only intended for the bulk encryption feature of
1514    cipher.c. */
1515 void
1516 _gcry_aes_cfb_dec (void *context, unsigned char *iv,
1517                    void *outbuf_arg, const void *inbuf_arg,
1518                    unsigned int nblocks)
1519 {
1520   RIJNDAEL_context *ctx = context;
1521   unsigned char *outbuf = outbuf_arg;
1522   const unsigned char *inbuf = inbuf_arg;
1523   unsigned char *ivp;
1524   unsigned char temp;
1525   int i;
1526
1527   if (0)
1528     ;
1529 #ifdef USE_PADLOCK
1530   else if (ctx->use_padlock)
1531     {
1532       /* Fixme:  Let Padlock do the CFBing.  */
1533       for ( ;nblocks; nblocks-- )
1534         {
1535           do_padlock (ctx, 0, iv, iv);
1536           for (ivp=iv,i=0; i < BLOCKSIZE; i++ )
1537             {
1538               temp = *inbuf++;
1539               *outbuf++ = *ivp ^ temp;
1540               *ivp++ = temp;
1541             }
1542         }
1543     }
1544 #endif /*USE_PADLOCK*/
1545 #ifdef USE_AESNI
1546   else if (ctx->use_aesni)
1547     {
1548       aesni_prepare ();
1549       for ( ;nblocks; nblocks-- )
1550         {
1551           do_aesni_cfb (ctx, 1, iv, outbuf, inbuf);
1552           outbuf += BLOCKSIZE;
1553           inbuf  += BLOCKSIZE;
1554         }
1555       aesni_cleanup ();
1556     }
1557 #endif /*USE_AESNI*/
1558   else
1559     {
1560       for ( ;nblocks; nblocks-- )
1561         {
1562           do_encrypt_aligned (ctx, iv, iv);
1563           for (ivp=iv,i=0; i < BLOCKSIZE; i++ )
1564             {
1565               temp = *inbuf++;
1566               *outbuf++ = *ivp ^ temp;
1567               *ivp++ = temp;
1568             }
1569         }
1570     }
1571
1572   _gcry_burn_stack (48 + 2*sizeof(int));
1573 }
1574
1575
1576 /* Bulk decryption of complete blocks in CBC mode.  Caller needs to
1577    make sure that IV is aligned on an unsigned long boundary.  This
1578    function is only intended for the bulk encryption feature of
1579    cipher.c. */
1580 void
1581 _gcry_aes_cbc_dec (void *context, unsigned char *iv,
1582                    void *outbuf_arg, const void *inbuf_arg,
1583                    unsigned int nblocks)
1584 {
1585   RIJNDAEL_context *ctx = context;
1586   unsigned char *outbuf = outbuf_arg;
1587   const unsigned char *inbuf = inbuf_arg;
1588   unsigned char *ivp;
1589   int i;
1590   unsigned char savebuf[BLOCKSIZE];
1591
1592   aesni_prepare ();
1593   for ( ;nblocks; nblocks-- )
1594     {
1595       /* We need to save INBUF away because it may be identical to
1596          OUTBUF.  */
1597       memcpy (savebuf, inbuf, BLOCKSIZE);
1598
1599       if (0)
1600         ;
1601 #ifdef USE_PADLOCK
1602       else if (ctx->use_padlock)
1603         do_padlock (ctx, 1, outbuf, inbuf);
1604 #endif /*USE_PADLOCK*/
1605 #ifdef USE_AESNI
1606       else if (ctx->use_aesni)
1607         do_aesni (ctx, 1, outbuf, inbuf);
1608 #endif /*USE_AESNI*/
1609       else
1610         do_decrypt (ctx, outbuf, inbuf);
1611
1612       for (ivp=iv, i=0; i < BLOCKSIZE; i++ )
1613         outbuf[i] ^= *ivp++;
1614       memcpy (iv, savebuf, BLOCKSIZE);
1615       inbuf += BLOCKSIZE;
1616       outbuf += BLOCKSIZE;
1617     }
1618   aesni_cleanup ();
1619
1620   _gcry_burn_stack (48 + 2*sizeof(int) + BLOCKSIZE + 4*sizeof (char*));
1621 }
1622
1623
1624
1625 \f
1626 /* Run the self-tests for AES 128.  Returns NULL on success. */
1627 static const char*
1628 selftest_basic_128 (void)
1629 {
1630   RIJNDAEL_context ctx;
1631   unsigned char scratch[16];
1632
1633   /* The test vectors are from the AES supplied ones; more or less
1634      randomly taken from ecb_tbl.txt (I=42,81,14) */
1635 #if 1
1636   static const unsigned char plaintext_128[16] =
1637     {
1638       0x01,0x4B,0xAF,0x22,0x78,0xA6,0x9D,0x33,
1639       0x1D,0x51,0x80,0x10,0x36,0x43,0xE9,0x9A
1640     };
1641   static const unsigned char key_128[16] =
1642     {
1643       0xE8,0xE9,0xEA,0xEB,0xED,0xEE,0xEF,0xF0,
1644       0xF2,0xF3,0xF4,0xF5,0xF7,0xF8,0xF9,0xFA
1645     };
1646   static const unsigned char ciphertext_128[16] =
1647     {
1648       0x67,0x43,0xC3,0xD1,0x51,0x9A,0xB4,0xF2,
1649       0xCD,0x9A,0x78,0xAB,0x09,0xA5,0x11,0xBD
1650     };
1651 #else
1652   /* Test vectors from fips-197, appendix C. */
1653 # warning debug test vectors in use
1654   static const unsigned char plaintext_128[16] =
1655     {
1656       0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,
1657       0x88,0x99,0xaa,0xbb,0xcc,0xdd,0xee,0xff
1658     };
1659   static const unsigned char key_128[16] =
1660     {
1661       0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
1662       0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f
1663       /* 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, */
1664       /* 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c */
1665     };
1666   static const unsigned char ciphertext_128[16] =
1667     {
1668       0x69,0xc4,0xe0,0xd8,0x6a,0x7b,0x04,0x30,
1669       0xd8,0xcd,0xb7,0x80,0x70,0xb4,0xc5,0x5a
1670     };
1671 #endif
1672
1673   rijndael_setkey (&ctx, key_128, sizeof (key_128));
1674   rijndael_encrypt (&ctx, scratch, plaintext_128);
1675   if (memcmp (scratch, ciphertext_128, sizeof (ciphertext_128)))
1676      return "AES-128 test encryption failed.";
1677   rijndael_decrypt (&ctx, scratch, scratch);
1678   if (memcmp (scratch, plaintext_128, sizeof (plaintext_128)))
1679     return "AES-128 test decryption failed.";
1680
1681   return NULL;
1682 }
1683
1684 /* Run the self-tests for AES 192.  Returns NULL on success. */
1685 static const char*
1686 selftest_basic_192 (void)
1687 {
1688   RIJNDAEL_context ctx;
1689   unsigned char scratch[16];
1690
1691   static unsigned char plaintext_192[16] =
1692     {
1693       0x76,0x77,0x74,0x75,0xF1,0xF2,0xF3,0xF4,
1694       0xF8,0xF9,0xE6,0xE7,0x77,0x70,0x71,0x72
1695     };
1696   static unsigned char key_192[24] =
1697     {
1698       0x04,0x05,0x06,0x07,0x09,0x0A,0x0B,0x0C,
1699       0x0E,0x0F,0x10,0x11,0x13,0x14,0x15,0x16,
1700       0x18,0x19,0x1A,0x1B,0x1D,0x1E,0x1F,0x20
1701     };
1702   static const unsigned char ciphertext_192[16] =
1703     {
1704       0x5D,0x1E,0xF2,0x0D,0xCE,0xD6,0xBC,0xBC,
1705       0x12,0x13,0x1A,0xC7,0xC5,0x47,0x88,0xAA
1706     };
1707
1708   rijndael_setkey (&ctx, key_192, sizeof(key_192));
1709   rijndael_encrypt (&ctx, scratch, plaintext_192);
1710   if (memcmp (scratch, ciphertext_192, sizeof (ciphertext_192)))
1711     return "AES-192 test encryption failed.";
1712   rijndael_decrypt (&ctx, scratch, scratch);
1713   if (memcmp (scratch, plaintext_192, sizeof (plaintext_192)))
1714     return "AES-192 test decryption failed.";
1715
1716   return NULL;
1717 }
1718
1719
1720 /* Run the self-tests for AES 256.  Returns NULL on success. */
1721 static const char*
1722 selftest_basic_256 (void)
1723 {
1724   RIJNDAEL_context ctx;
1725   unsigned char scratch[16];
1726
1727   static unsigned char plaintext_256[16] =
1728     {
1729       0x06,0x9A,0x00,0x7F,0xC7,0x6A,0x45,0x9F,
1730       0x98,0xBA,0xF9,0x17,0xFE,0xDF,0x95,0x21
1731     };
1732   static unsigned char key_256[32] =
1733     {
1734       0x08,0x09,0x0A,0x0B,0x0D,0x0E,0x0F,0x10,
1735       0x12,0x13,0x14,0x15,0x17,0x18,0x19,0x1A,
1736       0x1C,0x1D,0x1E,0x1F,0x21,0x22,0x23,0x24,
1737       0x26,0x27,0x28,0x29,0x2B,0x2C,0x2D,0x2E
1738     };
1739   static const unsigned char ciphertext_256[16] =
1740     {
1741       0x08,0x0E,0x95,0x17,0xEB,0x16,0x77,0x71,
1742       0x9A,0xCF,0x72,0x80,0x86,0x04,0x0A,0xE3
1743     };
1744
1745   rijndael_setkey (&ctx, key_256, sizeof(key_256));
1746   rijndael_encrypt (&ctx, scratch, plaintext_256);
1747   if (memcmp (scratch, ciphertext_256, sizeof (ciphertext_256)))
1748     return "AES-256 test encryption failed.";
1749   rijndael_decrypt (&ctx, scratch, scratch);
1750   if (memcmp (scratch, plaintext_256, sizeof (plaintext_256)))
1751     return "AES-256 test decryption failed.";
1752
1753   return NULL;
1754 }
1755
1756 /* Run all the self-tests and return NULL on success.  This function
1757    is used for the on-the-fly self-tests. */
1758 static const char *
1759 selftest (void)
1760 {
1761   const char *r;
1762
1763   if ( (r = selftest_basic_128 ())
1764        || (r = selftest_basic_192 ())
1765        || (r = selftest_basic_256 ()) )
1766     return r;
1767
1768   return r;
1769 }
1770
1771
1772 /* SP800-38a.pdf for AES-128.  */
1773 static const char *
1774 selftest_fips_128_38a (int requested_mode)
1775 {
1776   struct tv
1777   {
1778     int mode;
1779     const unsigned char key[16];
1780     const unsigned char iv[16];
1781     struct
1782     {
1783       const unsigned char input[16];
1784       const unsigned char output[16];
1785     } data[4];
1786   } tv[2] =
1787     {
1788       {
1789         GCRY_CIPHER_MODE_CFB,  /* F.3.13, CFB128-AES128 */
1790         { 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
1791           0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c },
1792         { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1793           0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1794         {
1795           { { 0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
1796               0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a },
1797             { 0x3b, 0x3f, 0xd9, 0x2e, 0xb7, 0x2d, 0xad, 0x20,
1798               0x33, 0x34, 0x49, 0xf8, 0xe8, 0x3c, 0xfb, 0x4a } },
1799
1800           { { 0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
1801               0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51 },
1802             { 0xc8, 0xa6, 0x45, 0x37, 0xa0, 0xb3, 0xa9, 0x3f,
1803               0xcd, 0xe3, 0xcd, 0xad, 0x9f, 0x1c, 0xe5, 0x8b } },
1804
1805           { { 0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
1806               0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef },
1807             { 0x26, 0x75, 0x1f, 0x67, 0xa3, 0xcb, 0xb1, 0x40,
1808               0xb1, 0x80, 0x8c, 0xf1, 0x87, 0xa4, 0xf4, 0xdf } },
1809
1810           { { 0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
1811               0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10 },
1812             { 0xc0, 0x4b, 0x05, 0x35, 0x7c, 0x5d, 0x1c, 0x0e,
1813               0xea, 0xc4, 0xc6, 0x6f, 0x9f, 0xf7, 0xf2, 0xe6 } }
1814         }
1815       },
1816       {
1817         GCRY_CIPHER_MODE_OFB,
1818         { 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
1819           0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c },
1820         { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1821           0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1822         {
1823           { { 0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
1824               0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a },
1825             { 0x3b, 0x3f, 0xd9, 0x2e, 0xb7, 0x2d, 0xad, 0x20,
1826               0x33, 0x34, 0x49, 0xf8, 0xe8, 0x3c, 0xfb, 0x4a } },
1827
1828           { { 0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
1829               0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51 },
1830             { 0x77, 0x89, 0x50, 0x8d, 0x16, 0x91, 0x8f, 0x03,
1831               0xf5, 0x3c, 0x52, 0xda, 0xc5, 0x4e, 0xd8, 0x25 } },
1832
1833           { { 0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
1834               0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef },
1835             { 0x97, 0x40, 0x05, 0x1e, 0x9c, 0x5f, 0xec, 0xf6,
1836               0x43, 0x44, 0xf7, 0xa8, 0x22, 0x60, 0xed, 0xcc } },
1837
1838           { { 0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
1839               0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10 },
1840             { 0x30, 0x4c, 0x65, 0x28, 0xf6, 0x59, 0xc7, 0x78,
1841               0x66, 0xa5, 0x10, 0xd9, 0xc1, 0xd6, 0xae, 0x5e } },
1842         }
1843       }
1844     };
1845   unsigned char scratch[16];
1846   gpg_error_t err;
1847   int tvi, idx;
1848   gcry_cipher_hd_t hdenc = NULL;
1849   gcry_cipher_hd_t hddec = NULL;
1850
1851 #define Fail(a) do {           \
1852     _gcry_cipher_close (hdenc);  \
1853     _gcry_cipher_close (hddec);  \
1854     return a;                    \
1855   } while (0)
1856
1857   gcry_assert (sizeof tv[0].data[0].input == sizeof scratch);
1858   gcry_assert (sizeof tv[0].data[0].output == sizeof scratch);
1859
1860   for (tvi=0; tvi < DIM (tv); tvi++)
1861     if (tv[tvi].mode == requested_mode)
1862       break;
1863   if (tvi == DIM (tv))
1864     Fail ("no test data for this mode");
1865
1866   err = _gcry_cipher_open (&hdenc, GCRY_CIPHER_AES, tv[tvi].mode, 0);
1867   if (err)
1868     Fail ("open");
1869   err = _gcry_cipher_open (&hddec, GCRY_CIPHER_AES, tv[tvi].mode, 0);
1870   if (err)
1871     Fail ("open");
1872   err = _gcry_cipher_setkey (hdenc, tv[tvi].key,  sizeof tv[tvi].key);
1873   if (!err)
1874     err = _gcry_cipher_setkey (hddec, tv[tvi].key, sizeof tv[tvi].key);
1875   if (err)
1876     Fail ("set key");
1877   err = _gcry_cipher_setiv (hdenc, tv[tvi].iv, sizeof tv[tvi].iv);
1878   if (!err)
1879     err = _gcry_cipher_setiv (hddec, tv[tvi].iv, sizeof tv[tvi].iv);
1880   if (err)
1881     Fail ("set IV");
1882   for (idx=0; idx < DIM (tv[tvi].data); idx++)
1883     {
1884       err = _gcry_cipher_encrypt (hdenc, scratch, sizeof scratch,
1885                                   tv[tvi].data[idx].input,
1886                                   sizeof tv[tvi].data[idx].input);
1887       if (err)
1888         Fail ("encrypt command");
1889       if (memcmp (scratch, tv[tvi].data[idx].output, sizeof scratch))
1890         Fail ("encrypt mismatch");
1891       err = _gcry_cipher_decrypt (hddec, scratch, sizeof scratch,
1892                                   tv[tvi].data[idx].output,
1893                                   sizeof tv[tvi].data[idx].output);
1894       if (err)
1895         Fail ("decrypt command");
1896       if (memcmp (scratch, tv[tvi].data[idx].input, sizeof scratch))
1897         Fail ("decrypt mismatch");
1898     }
1899
1900 #undef Fail
1901   _gcry_cipher_close (hdenc);
1902   _gcry_cipher_close (hddec);
1903   return NULL;
1904 }
1905
1906
1907 /* Complete selftest for AES-128 with all modes and driver code.  */
1908 static gpg_err_code_t
1909 selftest_fips_128 (int extended, selftest_report_func_t report)
1910 {
1911   const char *what;
1912   const char *errtxt;
1913
1914   what = "low-level";
1915   errtxt = selftest_basic_128 ();
1916   if (errtxt)
1917     goto failed;
1918
1919   if (extended)
1920     {
1921       what = "cfb";
1922       errtxt = selftest_fips_128_38a (GCRY_CIPHER_MODE_CFB);
1923       if (errtxt)
1924         goto failed;
1925
1926       what = "ofb";
1927       errtxt = selftest_fips_128_38a (GCRY_CIPHER_MODE_OFB);
1928       if (errtxt)
1929         goto failed;
1930     }
1931
1932   return 0; /* Succeeded. */
1933
1934  failed:
1935   if (report)
1936     report ("cipher", GCRY_CIPHER_AES128, what, errtxt);
1937   return GPG_ERR_SELFTEST_FAILED;
1938 }
1939
1940 /* Complete selftest for AES-192.  */
1941 static gpg_err_code_t
1942 selftest_fips_192 (int extended, selftest_report_func_t report)
1943 {
1944   const char *what;
1945   const char *errtxt;
1946
1947   (void)extended; /* No extended tests available.  */
1948
1949   what = "low-level";
1950   errtxt = selftest_basic_192 ();
1951   if (errtxt)
1952     goto failed;
1953
1954
1955   return 0; /* Succeeded. */
1956
1957  failed:
1958   if (report)
1959     report ("cipher", GCRY_CIPHER_AES192, what, errtxt);
1960   return GPG_ERR_SELFTEST_FAILED;
1961 }
1962
1963
1964 /* Complete selftest for AES-256.  */
1965 static gpg_err_code_t
1966 selftest_fips_256 (int extended, selftest_report_func_t report)
1967 {
1968   const char *what;
1969   const char *errtxt;
1970
1971   (void)extended; /* No extended tests available.  */
1972
1973   what = "low-level";
1974   errtxt = selftest_basic_256 ();
1975   if (errtxt)
1976     goto failed;
1977
1978   return 0; /* Succeeded. */
1979
1980  failed:
1981   if (report)
1982     report ("cipher", GCRY_CIPHER_AES256, what, errtxt);
1983   return GPG_ERR_SELFTEST_FAILED;
1984 }
1985
1986
1987
1988 /* Run a full self-test for ALGO and return 0 on success.  */
1989 static gpg_err_code_t
1990 run_selftests (int algo, int extended, selftest_report_func_t report)
1991 {
1992   gpg_err_code_t ec;
1993
1994   switch (algo)
1995     {
1996     case GCRY_CIPHER_AES128:
1997       ec = selftest_fips_128 (extended, report);
1998       break;
1999     case GCRY_CIPHER_AES192:
2000       ec = selftest_fips_192 (extended, report);
2001       break;
2002     case GCRY_CIPHER_AES256:
2003       ec = selftest_fips_256 (extended, report);
2004       break;
2005     default:
2006       ec = GPG_ERR_CIPHER_ALGO;
2007       break;
2008
2009     }
2010   return ec;
2011 }
2012
2013
2014 \f
2015
2016 static const char *rijndael_names[] =
2017   {
2018     "RIJNDAEL",
2019     "AES128",
2020     "AES-128",
2021     NULL
2022   };
2023
2024 static gcry_cipher_oid_spec_t rijndael_oids[] =
2025   {
2026     { "2.16.840.1.101.3.4.1.1", GCRY_CIPHER_MODE_ECB },
2027     { "2.16.840.1.101.3.4.1.2", GCRY_CIPHER_MODE_CBC },
2028     { "2.16.840.1.101.3.4.1.3", GCRY_CIPHER_MODE_OFB },
2029     { "2.16.840.1.101.3.4.1.4", GCRY_CIPHER_MODE_CFB },
2030     { NULL }
2031   };
2032
2033 gcry_cipher_spec_t _gcry_cipher_spec_aes =
2034   {
2035     "AES", rijndael_names, rijndael_oids, 16, 128, sizeof (RIJNDAEL_context),
2036     rijndael_setkey, rijndael_encrypt, rijndael_decrypt
2037   };
2038 cipher_extra_spec_t _gcry_cipher_extraspec_aes =
2039   {
2040     run_selftests
2041   };
2042
2043 static const char *rijndael192_names[] =
2044   {
2045     "RIJNDAEL192",
2046     "AES-192",
2047     NULL
2048   };
2049
2050 static gcry_cipher_oid_spec_t rijndael192_oids[] =
2051   {
2052     { "2.16.840.1.101.3.4.1.21", GCRY_CIPHER_MODE_ECB },
2053     { "2.16.840.1.101.3.4.1.22", GCRY_CIPHER_MODE_CBC },
2054     { "2.16.840.1.101.3.4.1.23", GCRY_CIPHER_MODE_OFB },
2055     { "2.16.840.1.101.3.4.1.24", GCRY_CIPHER_MODE_CFB },
2056     { NULL }
2057   };
2058
2059 gcry_cipher_spec_t _gcry_cipher_spec_aes192 =
2060   {
2061     "AES192", rijndael192_names, rijndael192_oids, 16, 192, sizeof (RIJNDAEL_context),
2062     rijndael_setkey, rijndael_encrypt, rijndael_decrypt
2063   };
2064 cipher_extra_spec_t _gcry_cipher_extraspec_aes192 =
2065   {
2066     run_selftests
2067   };
2068
2069 static const char *rijndael256_names[] =
2070   {
2071     "RIJNDAEL256",
2072     "AES-256",
2073     NULL
2074   };
2075
2076 static gcry_cipher_oid_spec_t rijndael256_oids[] =
2077   {
2078     { "2.16.840.1.101.3.4.1.41", GCRY_CIPHER_MODE_ECB },
2079     { "2.16.840.1.101.3.4.1.42", GCRY_CIPHER_MODE_CBC },
2080     { "2.16.840.1.101.3.4.1.43", GCRY_CIPHER_MODE_OFB },
2081     { "2.16.840.1.101.3.4.1.44", GCRY_CIPHER_MODE_CFB },
2082     { NULL }
2083   };
2084
2085 gcry_cipher_spec_t _gcry_cipher_spec_aes256 =
2086   {
2087     "AES256", rijndael256_names, rijndael256_oids, 16, 256,
2088     sizeof (RIJNDAEL_context),
2089     rijndael_setkey, rijndael_encrypt, rijndael_decrypt
2090   };
2091
2092 cipher_extra_spec_t _gcry_cipher_extraspec_aes256 =
2093   {
2094     run_selftests
2095   };