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