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