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