5b0fe1c896ffac0a2ab3394947d162b655c6d5eb
[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 #include "rijndael-internal.h"
51
52
53 /* Define an u32 variant for the sake of gcc 4.4's strict aliasing.  */
54 #if __GNUC__ > 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )
55 typedef u32           __attribute__ ((__may_alias__)) u32_a_t;
56 #else
57 typedef u32           u32_a_t;
58 #endif
59
60
61 #ifdef USE_AMD64_ASM
62 /* AMD64 assembly implementations of AES */
63 extern unsigned int _gcry_aes_amd64_encrypt_block(const void *keysched_enc,
64                                                   unsigned char *out,
65                                                   const unsigned char *in,
66                                                   int rounds,
67                                                   const void *encT);
68
69 extern unsigned int _gcry_aes_amd64_decrypt_block(const void *keysched_dec,
70                                                   unsigned char *out,
71                                                   const unsigned char *in,
72                                                   int rounds,
73                                                   const void *decT);
74 #endif /*USE_AMD64_ASM*/
75
76 #ifdef USE_AESNI
77 /* AES-NI (AMD64 & i386) accelerated implementations of AES */
78 extern void _gcry_aes_aesni_do_setkey(RIJNDAEL_context *ctx, const byte *key);
79 extern void _gcry_aes_aesni_prepare_decryption(RIJNDAEL_context *ctx);
80
81 extern unsigned int _gcry_aes_aesni_encrypt (const RIJNDAEL_context *ctx,
82                                              unsigned char *dst,
83                                              const unsigned char *src);
84 extern unsigned int _gcry_aes_aesni_decrypt (const RIJNDAEL_context *ctx,
85                                              unsigned char *dst,
86                                              const unsigned char *src);
87 extern void _gcry_aes_aesni_cfb_enc (RIJNDAEL_context *ctx,
88                                      unsigned char *outbuf,
89                                      const unsigned char *inbuf,
90                                      unsigned char *iv, size_t nblocks);
91 extern void _gcry_aes_aesni_cbc_enc (RIJNDAEL_context *ctx,
92                                      unsigned char *outbuf,
93                                      const unsigned char *inbuf,
94                                      unsigned char *iv, size_t nblocks,
95                                      int cbc_mac);
96 extern void _gcry_aes_aesni_ctr_enc (RIJNDAEL_context *ctx,
97                                      unsigned char *outbuf,
98                                      const unsigned char *inbuf,
99                                      unsigned char *ctr, size_t nblocks);
100 extern void _gcry_aes_aesni_cfb_dec (RIJNDAEL_context *ctx,
101                                      unsigned char *outbuf,
102                                      const unsigned char *inbuf,
103                                      unsigned char *iv, size_t nblocks);
104 extern void _gcry_aes_aesni_cbc_dec (RIJNDAEL_context *ctx,
105                                      unsigned char *outbuf,
106                                      const unsigned char *inbuf,
107                                      unsigned char *iv, size_t nblocks);
108 #endif
109
110 #ifdef USE_PADLOCK
111 extern unsigned int _gcry_aes_padlock_encrypt (const RIJNDAEL_context *ctx,
112                                                unsigned char *bx,
113                                                const unsigned char *ax);
114 extern unsigned int _gcry_aes_padlock_decrypt (const RIJNDAEL_context *ctx,
115                                                unsigned char *bx,
116                                                const unsigned char *ax);
117 #endif
118
119 #ifdef USE_ARM_ASM
120 /* ARM assembly implementations of AES */
121 extern unsigned int _gcry_aes_arm_encrypt_block(const void *keysched_enc,
122                                                 unsigned char *out,
123                                                 const unsigned char *in,
124                                                 int rounds,
125                                                 const void *encT);
126
127 extern unsigned int _gcry_aes_arm_decrypt_block(const void *keysched_dec,
128                                                 unsigned char *out,
129                                                 const unsigned char *in,
130                                                 int rounds,
131                                                 const void *decT);
132 #endif /*USE_ARM_ASM*/
133
134 static unsigned int do_encrypt (const RIJNDAEL_context *ctx, unsigned char *bx,
135                                 const unsigned char *ax);
136 static unsigned int do_decrypt (const RIJNDAEL_context *ctx, unsigned char *bx,
137                                 const unsigned char *ax);
138
139 \f
140
141 /* All the numbers.  */
142 #include "rijndael-tables.h"
143
144
145 \f
146
147 /* Function prototypes.  */
148 static const char *selftest(void);
149
150
151 \f
152 /* Prefetching for encryption/decryption tables. */
153 static void prefetch_table(const volatile byte *tab, size_t len)
154 {
155   size_t i;
156
157   for (i = 0; i < len; i += 8 * 32)
158     {
159       (void)tab[i + 0 * 32];
160       (void)tab[i + 1 * 32];
161       (void)tab[i + 2 * 32];
162       (void)tab[i + 3 * 32];
163       (void)tab[i + 4 * 32];
164       (void)tab[i + 5 * 32];
165       (void)tab[i + 6 * 32];
166       (void)tab[i + 7 * 32];
167     }
168
169   (void)tab[len - 1];
170 }
171
172 static void prefetch_enc(void)
173 {
174   prefetch_table((const void *)encT, sizeof(encT));
175 }
176
177 static void prefetch_dec(void)
178 {
179   prefetch_table((const void *)&dec_tables, sizeof(dec_tables));
180 }
181
182
183 \f
184 /* Perform the key setup.  */
185 static gcry_err_code_t
186 do_setkey (RIJNDAEL_context *ctx, const byte *key, const unsigned keylen)
187 {
188   static int initialized = 0;
189   static const char *selftest_failed=0;
190   int rounds;
191   int i,j, r, t, rconpointer = 0;
192   int KC;
193 #if defined(USE_AESNI) || defined(USE_PADLOCK)
194   unsigned int hwfeatures;
195 #endif
196
197   /* The on-the-fly self tests are only run in non-fips mode. In fips
198      mode explicit self-tests are required.  Actually the on-the-fly
199      self-tests are not fully thread-safe and it might happen that a
200      failed self-test won't get noticed in another thread.
201
202      FIXME: We might want to have a central registry of succeeded
203      self-tests. */
204   if (!fips_mode () && !initialized)
205     {
206       initialized = 1;
207       selftest_failed = selftest ();
208       if (selftest_failed)
209         log_error ("%s\n", selftest_failed );
210     }
211   if (selftest_failed)
212     return GPG_ERR_SELFTEST_FAILED;
213
214   if( keylen == 128/8 )
215     {
216       rounds = 10;
217       KC = 4;
218     }
219   else if ( keylen == 192/8 )
220     {
221       rounds = 12;
222       KC = 6;
223     }
224   else if ( keylen == 256/8 )
225     {
226       rounds = 14;
227       KC = 8;
228     }
229   else
230     return GPG_ERR_INV_KEYLEN;
231
232   ctx->rounds = rounds;
233
234 #if defined(USE_AESNI) || defined(USE_PADLOCK)
235   hwfeatures = _gcry_get_hw_features ();
236 #endif
237
238   ctx->decryption_prepared = 0;
239 #ifdef USE_PADLOCK
240   ctx->use_padlock = 0;
241 #endif
242 #ifdef USE_AESNI
243   ctx->use_aesni = 0;
244 #endif
245
246   if (0)
247     {
248       ;
249     }
250 #ifdef USE_AESNI
251   else if (hwfeatures & HWF_INTEL_AESNI)
252     {
253       ctx->encrypt_fn = _gcry_aes_aesni_encrypt;
254       ctx->decrypt_fn = _gcry_aes_aesni_decrypt;
255       ctx->prefetch_enc_fn = NULL;
256       ctx->prefetch_dec_fn = NULL;
257       ctx->use_aesni = 1;
258     }
259 #endif
260 #ifdef USE_PADLOCK
261   else if (hwfeatures & HWF_PADLOCK_AES && keylen == 128/8)
262     {
263       ctx->encrypt_fn = _gcry_aes_padlock_encrypt;
264       ctx->decrypt_fn = _gcry_aes_padlock_decrypt;
265       ctx->prefetch_enc_fn = NULL;
266       ctx->prefetch_dec_fn = NULL;
267       ctx->use_padlock = 1;
268       memcpy (ctx->padlockkey, key, keylen);
269     }
270 #endif
271   else
272     {
273       ctx->encrypt_fn = do_encrypt;
274       ctx->decrypt_fn = do_decrypt;
275       ctx->prefetch_enc_fn = prefetch_enc;
276       ctx->prefetch_dec_fn = prefetch_dec;
277     }
278
279   /* NB: We don't yet support Padlock hardware key generation.  */
280
281   if (0)
282     {
283       ;
284     }
285 #ifdef USE_AESNI
286   else if (ctx->use_aesni)
287     _gcry_aes_aesni_do_setkey (ctx, key);
288 #endif
289   else
290     {
291       const byte *sbox = ((const byte *)encT) + 1;
292       union
293         {
294           PROPERLY_ALIGNED_TYPE dummy;
295           byte data[MAXKC][4];
296         } tkk[2];
297 #define k tkk[0].data
298 #define tk tkk[1].data
299 #define W (ctx->keyschenc)
300
301       prefetch_enc();
302
303       for (i = 0; i < keylen; i++)
304         {
305           k[i >> 2][i & 3] = key[i];
306         }
307
308       for (j = KC-1; j >= 0; j--)
309         {
310           *((u32_a_t*)tk[j]) = *((u32_a_t*)k[j]);
311         }
312       r = 0;
313       t = 0;
314       /* Copy values into round key array.  */
315       for (j = 0; (j < KC) && (r < rounds + 1); )
316         {
317           for (; (j < KC) && (t < 4); j++, t++)
318             {
319               *((u32_a_t*)W[r][t]) = le_bswap32(*((u32_a_t*)tk[j]));
320             }
321           if (t == 4)
322             {
323               r++;
324               t = 0;
325             }
326         }
327
328       while (r < rounds + 1)
329         {
330           /* While not enough round key material calculated calculate
331              new values.  */
332           tk[0][0] ^= sbox[tk[KC-1][1] * 4];
333           tk[0][1] ^= sbox[tk[KC-1][2] * 4];
334           tk[0][2] ^= sbox[tk[KC-1][3] * 4];
335           tk[0][3] ^= sbox[tk[KC-1][0] * 4];
336           tk[0][0] ^= rcon[rconpointer++];
337
338           if (KC != 8)
339             {
340               for (j = 1; j < KC; j++)
341                 {
342                   *((u32_a_t*)tk[j]) ^= *((u32_a_t*)tk[j-1]);
343                 }
344             }
345           else
346             {
347               for (j = 1; j < KC/2; j++)
348                 {
349                   *((u32_a_t*)tk[j]) ^= *((u32_a_t*)tk[j-1]);
350                 }
351               tk[KC/2][0] ^= sbox[tk[KC/2 - 1][0] * 4];
352               tk[KC/2][1] ^= sbox[tk[KC/2 - 1][1] * 4];
353               tk[KC/2][2] ^= sbox[tk[KC/2 - 1][2] * 4];
354               tk[KC/2][3] ^= sbox[tk[KC/2 - 1][3] * 4];
355               for (j = KC/2 + 1; j < KC; j++)
356                 {
357                   *((u32_a_t*)tk[j]) ^= *((u32_a_t*)tk[j-1]);
358                 }
359             }
360
361           /* Copy values into round key array.  */
362           for (j = 0; (j < KC) && (r < rounds + 1); )
363             {
364               for (; (j < KC) && (t < 4); j++, t++)
365                 {
366                   *((u32_a_t*)W[r][t]) = le_bswap32(*((u32_a_t*)tk[j]));
367                 }
368               if (t == 4)
369                 {
370                   r++;
371                   t = 0;
372                 }
373             }
374         }
375 #undef W
376 #undef tk
377 #undef k
378       wipememory(&tkk, sizeof(tkk));
379     }
380
381   return 0;
382 }
383
384
385 static gcry_err_code_t
386 rijndael_setkey (void *context, const byte *key, const unsigned keylen)
387 {
388   RIJNDAEL_context *ctx = context;
389   return do_setkey (ctx, key, keylen);
390 }
391
392
393 /* Make a decryption key from an encryption key. */
394 static void
395 prepare_decryption( RIJNDAEL_context *ctx )
396 {
397   int r;
398
399   if (0)
400     ;
401 #ifdef USE_AESNI
402   else if (ctx->use_aesni)
403     {
404       _gcry_aes_aesni_prepare_decryption (ctx);
405     }
406 #endif /*USE_AESNI*/
407 #ifdef USE_PADLOCK
408   else if (ctx->use_padlock)
409     {
410       /* Padlock does not need decryption subkeys. */
411     }
412 #endif /*USE_PADLOCK*/
413   else
414     {
415       const byte *sbox = ((const byte *)encT) + 1;
416
417       prefetch_enc();
418       prefetch_dec();
419
420       *((u32_a_t*)ctx->keyschdec[0][0]) = *((u32_a_t*)ctx->keyschenc[0][0]);
421       *((u32_a_t*)ctx->keyschdec[0][1]) = *((u32_a_t*)ctx->keyschenc[0][1]);
422       *((u32_a_t*)ctx->keyschdec[0][2]) = *((u32_a_t*)ctx->keyschenc[0][2]);
423       *((u32_a_t*)ctx->keyschdec[0][3]) = *((u32_a_t*)ctx->keyschenc[0][3]);
424
425       for (r = 1; r < ctx->rounds; r++)
426         {
427           u32_a_t *wi = (u32_a_t*)((ctx->keyschenc)[r]);
428           u32_a_t *wo = (u32_a_t*)((ctx->keyschdec)[r]);
429           u32 wt;
430
431           wt = wi[0];
432           wo[0] = rol(decT[sbox[(byte)(wt >> 0) * 4]], 8 * 0)
433                  ^ rol(decT[sbox[(byte)(wt >> 8) * 4]], 8 * 1)
434                  ^ rol(decT[sbox[(byte)(wt >> 16) * 4]], 8 * 2)
435                  ^ rol(decT[sbox[(byte)(wt >> 24) * 4]], 8 * 3);
436
437           wt = wi[1];
438           wo[1] = rol(decT[sbox[(byte)(wt >> 0) * 4]], 8 * 0)
439                  ^ rol(decT[sbox[(byte)(wt >> 8) * 4]], 8 * 1)
440                  ^ rol(decT[sbox[(byte)(wt >> 16) * 4]], 8 * 2)
441                  ^ rol(decT[sbox[(byte)(wt >> 24) * 4]], 8 * 3);
442
443           wt = wi[2];
444           wo[2] = rol(decT[sbox[(byte)(wt >> 0) * 4]], 8 * 0)
445                  ^ rol(decT[sbox[(byte)(wt >> 8) * 4]], 8 * 1)
446                  ^ rol(decT[sbox[(byte)(wt >> 16) * 4]], 8 * 2)
447                  ^ rol(decT[sbox[(byte)(wt >> 24) * 4]], 8 * 3);
448
449           wt = wi[3];
450           wo[3] = rol(decT[sbox[(byte)(wt >> 0) * 4]], 8 * 0)
451                  ^ rol(decT[sbox[(byte)(wt >> 8) * 4]], 8 * 1)
452                  ^ rol(decT[sbox[(byte)(wt >> 16) * 4]], 8 * 2)
453                  ^ rol(decT[sbox[(byte)(wt >> 24) * 4]], 8 * 3);
454         }
455
456       *((u32_a_t*)ctx->keyschdec[r][0]) = *((u32_a_t*)ctx->keyschenc[r][0]);
457       *((u32_a_t*)ctx->keyschdec[r][1]) = *((u32_a_t*)ctx->keyschenc[r][1]);
458       *((u32_a_t*)ctx->keyschdec[r][2]) = *((u32_a_t*)ctx->keyschenc[r][2]);
459       *((u32_a_t*)ctx->keyschdec[r][3]) = *((u32_a_t*)ctx->keyschenc[r][3]);
460     }
461 }
462
463 \f
464 #if !defined(USE_ARM_ASM) && !defined(USE_AMD64_ASM)
465 /* Encrypt one block. A and B may be the same. */
466 static unsigned int
467 do_encrypt_fn (const RIJNDAEL_context *ctx, unsigned char *b,
468                const unsigned char *a)
469 {
470 #define rk (ctx->keyschenc)
471   const byte *sbox = ((const byte *)encT) + 1;
472   int rounds = ctx->rounds;
473   int r;
474   u32 sa[4];
475   u32 sb[4];
476
477   sb[0] = buf_get_le32(a + 0);
478   sb[1] = buf_get_le32(a + 4);
479   sb[2] = buf_get_le32(a + 8);
480   sb[3] = buf_get_le32(a + 12);
481
482   sa[0] = sb[0] ^ *((u32_a_t*)rk[0][0]);
483   sa[1] = sb[1] ^ *((u32_a_t*)rk[0][1]);
484   sa[2] = sb[2] ^ *((u32_a_t*)rk[0][2]);
485   sa[3] = sb[3] ^ *((u32_a_t*)rk[0][3]);
486
487   sb[0] = rol(encT[(byte)(sa[0] >> (0 * 8))], (0 * 8));
488   sb[3] = rol(encT[(byte)(sa[0] >> (1 * 8))], (1 * 8));
489   sb[2] = rol(encT[(byte)(sa[0] >> (2 * 8))], (2 * 8));
490   sb[1] = rol(encT[(byte)(sa[0] >> (3 * 8))], (3 * 8));
491   sa[0] = *((u32_a_t*)rk[1][0]) ^ sb[0];
492
493   sb[1] ^= rol(encT[(byte)(sa[1] >> (0 * 8))], (0 * 8));
494   sa[0] ^= rol(encT[(byte)(sa[1] >> (1 * 8))], (1 * 8));
495   sb[3] ^= rol(encT[(byte)(sa[1] >> (2 * 8))], (2 * 8));
496   sb[2] ^= rol(encT[(byte)(sa[1] >> (3 * 8))], (3 * 8));
497   sa[1] = *((u32_a_t*)rk[1][1]) ^ sb[1];
498
499   sb[2] ^= rol(encT[(byte)(sa[2] >> (0 * 8))], (0 * 8));
500   sa[1] ^= rol(encT[(byte)(sa[2] >> (1 * 8))], (1 * 8));
501   sa[0] ^= rol(encT[(byte)(sa[2] >> (2 * 8))], (2 * 8));
502   sb[3] ^= rol(encT[(byte)(sa[2] >> (3 * 8))], (3 * 8));
503   sa[2] = *((u32_a_t*)rk[1][2]) ^ sb[2];
504
505   sb[3] ^= rol(encT[(byte)(sa[3] >> (0 * 8))], (0 * 8));
506   sa[2] ^= rol(encT[(byte)(sa[3] >> (1 * 8))], (1 * 8));
507   sa[1] ^= rol(encT[(byte)(sa[3] >> (2 * 8))], (2 * 8));
508   sa[0] ^= rol(encT[(byte)(sa[3] >> (3 * 8))], (3 * 8));
509   sa[3] = *((u32_a_t*)rk[1][3]) ^ sb[3];
510
511   for (r = 2; r < rounds; r++)
512     {
513       sb[0] = rol(encT[(byte)(sa[0] >> (0 * 8))], (0 * 8));
514       sb[3] = rol(encT[(byte)(sa[0] >> (1 * 8))], (1 * 8));
515       sb[2] = rol(encT[(byte)(sa[0] >> (2 * 8))], (2 * 8));
516       sb[1] = rol(encT[(byte)(sa[0] >> (3 * 8))], (3 * 8));
517       sa[0] = *((u32_a_t*)rk[r][0]) ^ sb[0];
518
519       sb[1] ^= rol(encT[(byte)(sa[1] >> (0 * 8))], (0 * 8));
520       sa[0] ^= rol(encT[(byte)(sa[1] >> (1 * 8))], (1 * 8));
521       sb[3] ^= rol(encT[(byte)(sa[1] >> (2 * 8))], (2 * 8));
522       sb[2] ^= rol(encT[(byte)(sa[1] >> (3 * 8))], (3 * 8));
523       sa[1] = *((u32_a_t*)rk[r][1]) ^ sb[1];
524
525       sb[2] ^= rol(encT[(byte)(sa[2] >> (0 * 8))], (0 * 8));
526       sa[1] ^= rol(encT[(byte)(sa[2] >> (1 * 8))], (1 * 8));
527       sa[0] ^= rol(encT[(byte)(sa[2] >> (2 * 8))], (2 * 8));
528       sb[3] ^= rol(encT[(byte)(sa[2] >> (3 * 8))], (3 * 8));
529       sa[2] = *((u32_a_t*)rk[r][2]) ^ sb[2];
530
531       sb[3] ^= rol(encT[(byte)(sa[3] >> (0 * 8))], (0 * 8));
532       sa[2] ^= rol(encT[(byte)(sa[3] >> (1 * 8))], (1 * 8));
533       sa[1] ^= rol(encT[(byte)(sa[3] >> (2 * 8))], (2 * 8));
534       sa[0] ^= rol(encT[(byte)(sa[3] >> (3 * 8))], (3 * 8));
535       sa[3] = *((u32_a_t*)rk[r][3]) ^ sb[3];
536
537       r++;
538
539       sb[0] = rol(encT[(byte)(sa[0] >> (0 * 8))], (0 * 8));
540       sb[3] = rol(encT[(byte)(sa[0] >> (1 * 8))], (1 * 8));
541       sb[2] = rol(encT[(byte)(sa[0] >> (2 * 8))], (2 * 8));
542       sb[1] = rol(encT[(byte)(sa[0] >> (3 * 8))], (3 * 8));
543       sa[0] = *((u32_a_t*)rk[r][0]) ^ sb[0];
544
545       sb[1] ^= rol(encT[(byte)(sa[1] >> (0 * 8))], (0 * 8));
546       sa[0] ^= rol(encT[(byte)(sa[1] >> (1 * 8))], (1 * 8));
547       sb[3] ^= rol(encT[(byte)(sa[1] >> (2 * 8))], (2 * 8));
548       sb[2] ^= rol(encT[(byte)(sa[1] >> (3 * 8))], (3 * 8));
549       sa[1] = *((u32_a_t*)rk[r][1]) ^ sb[1];
550
551       sb[2] ^= rol(encT[(byte)(sa[2] >> (0 * 8))], (0 * 8));
552       sa[1] ^= rol(encT[(byte)(sa[2] >> (1 * 8))], (1 * 8));
553       sa[0] ^= rol(encT[(byte)(sa[2] >> (2 * 8))], (2 * 8));
554       sb[3] ^= rol(encT[(byte)(sa[2] >> (3 * 8))], (3 * 8));
555       sa[2] = *((u32_a_t*)rk[r][2]) ^ sb[2];
556
557       sb[3] ^= rol(encT[(byte)(sa[3] >> (0 * 8))], (0 * 8));
558       sa[2] ^= rol(encT[(byte)(sa[3] >> (1 * 8))], (1 * 8));
559       sa[1] ^= rol(encT[(byte)(sa[3] >> (2 * 8))], (2 * 8));
560       sa[0] ^= rol(encT[(byte)(sa[3] >> (3 * 8))], (3 * 8));
561       sa[3] = *((u32_a_t*)rk[r][3]) ^ sb[3];
562     }
563
564   /* Last round is special. */
565
566   sb[0] = (sbox[(byte)(sa[0] >> (0 * 8)) * 4]) << (0 * 8);
567   sb[3] = (sbox[(byte)(sa[0] >> (1 * 8)) * 4]) << (1 * 8);
568   sb[2] = (sbox[(byte)(sa[0] >> (2 * 8)) * 4]) << (2 * 8);
569   sb[1] = (sbox[(byte)(sa[0] >> (3 * 8)) * 4]) << (3 * 8);
570   sa[0] = *((u32_a_t*)rk[r][0]) ^ sb[0];
571
572   sb[1] ^= (sbox[(byte)(sa[1] >> (0 * 8)) * 4]) << (0 * 8);
573   sa[0] ^= (sbox[(byte)(sa[1] >> (1 * 8)) * 4]) << (1 * 8);
574   sb[3] ^= (sbox[(byte)(sa[1] >> (2 * 8)) * 4]) << (2 * 8);
575   sb[2] ^= (sbox[(byte)(sa[1] >> (3 * 8)) * 4]) << (3 * 8);
576   sa[1] = *((u32_a_t*)rk[r][1]) ^ sb[1];
577
578   sb[2] ^= (sbox[(byte)(sa[2] >> (0 * 8)) * 4]) << (0 * 8);
579   sa[1] ^= (sbox[(byte)(sa[2] >> (1 * 8)) * 4]) << (1 * 8);
580   sa[0] ^= (sbox[(byte)(sa[2] >> (2 * 8)) * 4]) << (2 * 8);
581   sb[3] ^= (sbox[(byte)(sa[2] >> (3 * 8)) * 4]) << (3 * 8);
582   sa[2] = *((u32_a_t*)rk[r][2]) ^ sb[2];
583
584   sb[3] ^= (sbox[(byte)(sa[3] >> (0 * 8)) * 4]) << (0 * 8);
585   sa[2] ^= (sbox[(byte)(sa[3] >> (1 * 8)) * 4]) << (1 * 8);
586   sa[1] ^= (sbox[(byte)(sa[3] >> (2 * 8)) * 4]) << (2 * 8);
587   sa[0] ^= (sbox[(byte)(sa[3] >> (3 * 8)) * 4]) << (3 * 8);
588   sa[3] = *((u32_a_t*)rk[r][3]) ^ sb[3];
589
590   buf_put_le32(b + 0, sa[0]);
591   buf_put_le32(b + 4, sa[1]);
592   buf_put_le32(b + 8, sa[2]);
593   buf_put_le32(b + 12, sa[3]);
594 #undef rk
595
596   return (56 + 2*sizeof(int));
597 }
598 #endif /*!USE_ARM_ASM && !USE_AMD64_ASM*/
599
600
601 static unsigned int
602 do_encrypt (const RIJNDAEL_context *ctx,
603             unsigned char *bx, const unsigned char *ax)
604 {
605 #ifdef USE_AMD64_ASM
606   return _gcry_aes_amd64_encrypt_block(ctx->keyschenc, bx, ax, ctx->rounds,
607                                        encT);
608 #elif defined(USE_ARM_ASM)
609   return _gcry_aes_arm_encrypt_block(ctx->keyschenc, bx, ax, ctx->rounds, encT);
610 #else
611   return do_encrypt_fn (ctx, bx, ax);
612 #endif /* !USE_ARM_ASM && !USE_AMD64_ASM*/
613 }
614
615
616 static unsigned int
617 rijndael_encrypt (void *context, byte *b, const byte *a)
618 {
619   RIJNDAEL_context *ctx = context;
620
621   if (ctx->prefetch_enc_fn)
622     ctx->prefetch_enc_fn();
623
624   return ctx->encrypt_fn (ctx, b, a);
625 }
626
627
628 /* Bulk encryption of complete blocks in CFB mode.  Caller needs to
629    make sure that IV is aligned on an unsigned long boundary.  This
630    function is only intended for the bulk encryption feature of
631    cipher.c. */
632 void
633 _gcry_aes_cfb_enc (void *context, unsigned char *iv,
634                    void *outbuf_arg, const void *inbuf_arg,
635                    size_t nblocks)
636 {
637   RIJNDAEL_context *ctx = context;
638   unsigned char *outbuf = outbuf_arg;
639   const unsigned char *inbuf = inbuf_arg;
640   unsigned int burn_depth = 0;
641
642   if (ctx->prefetch_enc_fn)
643     ctx->prefetch_enc_fn();
644
645   if (0)
646     ;
647 #ifdef USE_AESNI
648   else if (ctx->use_aesni)
649     {
650       _gcry_aes_aesni_cfb_enc (ctx, outbuf, inbuf, iv, nblocks);
651       burn_depth = 0;
652     }
653 #endif /*USE_AESNI*/
654   else
655     {
656       rijndael_cryptfn_t encrypt_fn = ctx->encrypt_fn;
657
658       for ( ;nblocks; nblocks-- )
659         {
660           /* Encrypt the IV. */
661           burn_depth = encrypt_fn (ctx, iv, iv);
662           /* XOR the input with the IV and store input into IV.  */
663           buf_xor_2dst(outbuf, iv, inbuf, BLOCKSIZE);
664           outbuf += BLOCKSIZE;
665           inbuf  += BLOCKSIZE;
666         }
667     }
668
669   if (burn_depth)
670     _gcry_burn_stack (burn_depth + 4 * sizeof(void *));
671 }
672
673
674 /* Bulk encryption of complete blocks in CBC mode.  Caller needs to
675    make sure that IV is aligned on an unsigned long boundary.  This
676    function is only intended for the bulk encryption feature of
677    cipher.c. */
678 void
679 _gcry_aes_cbc_enc (void *context, unsigned char *iv,
680                    void *outbuf_arg, const void *inbuf_arg,
681                    size_t nblocks, int cbc_mac)
682 {
683   RIJNDAEL_context *ctx = context;
684   unsigned char *outbuf = outbuf_arg;
685   const unsigned char *inbuf = inbuf_arg;
686   unsigned char *last_iv;
687   unsigned int burn_depth = 0;
688
689   if (ctx->prefetch_enc_fn)
690     ctx->prefetch_enc_fn();
691
692   if (0)
693     ;
694 #ifdef USE_AESNI
695   else if (ctx->use_aesni)
696     {
697       _gcry_aes_aesni_cbc_enc (ctx, outbuf, inbuf, iv, nblocks, cbc_mac);
698       burn_depth = 0;
699     }
700 #endif /*USE_AESNI*/
701   else
702     {
703       rijndael_cryptfn_t encrypt_fn = ctx->encrypt_fn;
704
705       last_iv = iv;
706
707       for ( ;nblocks; nblocks-- )
708         {
709           buf_xor(outbuf, inbuf, last_iv, BLOCKSIZE);
710
711           burn_depth = encrypt_fn (ctx, outbuf, outbuf);
712
713           last_iv = outbuf;
714           inbuf += BLOCKSIZE;
715           if (!cbc_mac)
716             outbuf += BLOCKSIZE;
717         }
718
719       if (last_iv != iv)
720         buf_cpy (iv, last_iv, BLOCKSIZE);
721     }
722
723   if (burn_depth)
724     _gcry_burn_stack (burn_depth + 4 * sizeof(void *));
725 }
726
727
728 /* Bulk encryption of complete blocks in CTR mode.  Caller needs to
729    make sure that CTR is aligned on a 16 byte boundary if AESNI; the
730    minimum alignment is for an u32.  This function is only intended
731    for the bulk encryption feature of cipher.c.  CTR is expected to be
732    of size BLOCKSIZE. */
733 void
734 _gcry_aes_ctr_enc (void *context, unsigned char *ctr,
735                    void *outbuf_arg, const void *inbuf_arg,
736                    size_t nblocks)
737 {
738   RIJNDAEL_context *ctx = context;
739   unsigned char *outbuf = outbuf_arg;
740   const unsigned char *inbuf = inbuf_arg;
741   unsigned int burn_depth = 0;
742   int i;
743
744   if (ctx->prefetch_enc_fn)
745     ctx->prefetch_enc_fn();
746
747   if (0)
748     ;
749 #ifdef USE_AESNI
750   else if (ctx->use_aesni)
751     {
752       _gcry_aes_aesni_ctr_enc (ctx, outbuf, inbuf, ctr, nblocks);
753       burn_depth = 0;
754     }
755 #endif /*USE_AESNI*/
756   else
757     {
758       union { unsigned char x1[16] ATTR_ALIGNED_16; u32 x32[4]; } tmp;
759       rijndael_cryptfn_t encrypt_fn = ctx->encrypt_fn;
760
761       for ( ;nblocks; nblocks-- )
762         {
763           /* Encrypt the counter. */
764           burn_depth = encrypt_fn (ctx, tmp.x1, ctr);
765           /* XOR the input with the encrypted counter and store in output.  */
766           buf_xor(outbuf, tmp.x1, inbuf, BLOCKSIZE);
767           outbuf += BLOCKSIZE;
768           inbuf  += BLOCKSIZE;
769           /* Increment the counter.  */
770           for (i = BLOCKSIZE; i > 0; i--)
771             {
772               ctr[i-1]++;
773               if (ctr[i-1])
774                 break;
775             }
776         }
777
778       wipememory(&tmp, sizeof(tmp));
779     }
780
781   if (burn_depth)
782     _gcry_burn_stack (burn_depth + 4 * sizeof(void *));
783 }
784
785
786 \f
787 #if !defined(USE_ARM_ASM) && !defined(USE_AMD64_ASM)
788 /* Decrypt one block.  A and B may be the same. */
789 static unsigned int
790 do_decrypt_fn (const RIJNDAEL_context *ctx, unsigned char *b,
791                const unsigned char *a)
792 {
793 #define rk  (ctx->keyschdec)
794   int rounds = ctx->rounds;
795   int r;
796   u32 sa[4];
797   u32 sb[4];
798
799   sb[0] = buf_get_le32(a + 0);
800   sb[1] = buf_get_le32(a + 4);
801   sb[2] = buf_get_le32(a + 8);
802   sb[3] = buf_get_le32(a + 12);
803
804   sa[0] = sb[0] ^ *((u32_a_t*)rk[rounds][0]);
805   sa[1] = sb[1] ^ *((u32_a_t*)rk[rounds][1]);
806   sa[2] = sb[2] ^ *((u32_a_t*)rk[rounds][2]);
807   sa[3] = sb[3] ^ *((u32_a_t*)rk[rounds][3]);
808
809   for (r = rounds - 1; r > 1; r--)
810     {
811       sb[0] = rol(decT[(byte)(sa[0] >> (0 * 8))], (0 * 8));
812       sb[1] = rol(decT[(byte)(sa[0] >> (1 * 8))], (1 * 8));
813       sb[2] = rol(decT[(byte)(sa[0] >> (2 * 8))], (2 * 8));
814       sb[3] = rol(decT[(byte)(sa[0] >> (3 * 8))], (3 * 8));
815       sa[0] = *((u32_a_t*)rk[r][0]) ^ sb[0];
816
817       sb[1] ^= rol(decT[(byte)(sa[1] >> (0 * 8))], (0 * 8));
818       sb[2] ^= rol(decT[(byte)(sa[1] >> (1 * 8))], (1 * 8));
819       sb[3] ^= rol(decT[(byte)(sa[1] >> (2 * 8))], (2 * 8));
820       sa[0] ^= rol(decT[(byte)(sa[1] >> (3 * 8))], (3 * 8));
821       sa[1] = *((u32_a_t*)rk[r][1]) ^ sb[1];
822
823       sb[2] ^= rol(decT[(byte)(sa[2] >> (0 * 8))], (0 * 8));
824       sb[3] ^= rol(decT[(byte)(sa[2] >> (1 * 8))], (1 * 8));
825       sa[0] ^= rol(decT[(byte)(sa[2] >> (2 * 8))], (2 * 8));
826       sa[1] ^= rol(decT[(byte)(sa[2] >> (3 * 8))], (3 * 8));
827       sa[2] = *((u32_a_t*)rk[r][2]) ^ sb[2];
828
829       sb[3] ^= rol(decT[(byte)(sa[3] >> (0 * 8))], (0 * 8));
830       sa[0] ^= rol(decT[(byte)(sa[3] >> (1 * 8))], (1 * 8));
831       sa[1] ^= rol(decT[(byte)(sa[3] >> (2 * 8))], (2 * 8));
832       sa[2] ^= rol(decT[(byte)(sa[3] >> (3 * 8))], (3 * 8));
833       sa[3] = *((u32_a_t*)rk[r][3]) ^ sb[3];
834
835       r--;
836
837       sb[0] = rol(decT[(byte)(sa[0] >> (0 * 8))], (0 * 8));
838       sb[1] = rol(decT[(byte)(sa[0] >> (1 * 8))], (1 * 8));
839       sb[2] = rol(decT[(byte)(sa[0] >> (2 * 8))], (2 * 8));
840       sb[3] = rol(decT[(byte)(sa[0] >> (3 * 8))], (3 * 8));
841       sa[0] = *((u32_a_t*)rk[r][0]) ^ sb[0];
842
843       sb[1] ^= rol(decT[(byte)(sa[1] >> (0 * 8))], (0 * 8));
844       sb[2] ^= rol(decT[(byte)(sa[1] >> (1 * 8))], (1 * 8));
845       sb[3] ^= rol(decT[(byte)(sa[1] >> (2 * 8))], (2 * 8));
846       sa[0] ^= rol(decT[(byte)(sa[1] >> (3 * 8))], (3 * 8));
847       sa[1] = *((u32_a_t*)rk[r][1]) ^ sb[1];
848
849       sb[2] ^= rol(decT[(byte)(sa[2] >> (0 * 8))], (0 * 8));
850       sb[3] ^= rol(decT[(byte)(sa[2] >> (1 * 8))], (1 * 8));
851       sa[0] ^= rol(decT[(byte)(sa[2] >> (2 * 8))], (2 * 8));
852       sa[1] ^= rol(decT[(byte)(sa[2] >> (3 * 8))], (3 * 8));
853       sa[2] = *((u32_a_t*)rk[r][2]) ^ sb[2];
854
855       sb[3] ^= rol(decT[(byte)(sa[3] >> (0 * 8))], (0 * 8));
856       sa[0] ^= rol(decT[(byte)(sa[3] >> (1 * 8))], (1 * 8));
857       sa[1] ^= rol(decT[(byte)(sa[3] >> (2 * 8))], (2 * 8));
858       sa[2] ^= rol(decT[(byte)(sa[3] >> (3 * 8))], (3 * 8));
859       sa[3] = *((u32_a_t*)rk[r][3]) ^ sb[3];
860     }
861
862   sb[0] = rol(decT[(byte)(sa[0] >> (0 * 8))], (0 * 8));
863   sb[1] = rol(decT[(byte)(sa[0] >> (1 * 8))], (1 * 8));
864   sb[2] = rol(decT[(byte)(sa[0] >> (2 * 8))], (2 * 8));
865   sb[3] = rol(decT[(byte)(sa[0] >> (3 * 8))], (3 * 8));
866   sa[0] = *((u32_a_t*)rk[1][0]) ^ sb[0];
867
868   sb[1] ^= rol(decT[(byte)(sa[1] >> (0 * 8))], (0 * 8));
869   sb[2] ^= rol(decT[(byte)(sa[1] >> (1 * 8))], (1 * 8));
870   sb[3] ^= rol(decT[(byte)(sa[1] >> (2 * 8))], (2 * 8));
871   sa[0] ^= rol(decT[(byte)(sa[1] >> (3 * 8))], (3 * 8));
872   sa[1] = *((u32_a_t*)rk[1][1]) ^ sb[1];
873
874   sb[2] ^= rol(decT[(byte)(sa[2] >> (0 * 8))], (0 * 8));
875   sb[3] ^= rol(decT[(byte)(sa[2] >> (1 * 8))], (1 * 8));
876   sa[0] ^= rol(decT[(byte)(sa[2] >> (2 * 8))], (2 * 8));
877   sa[1] ^= rol(decT[(byte)(sa[2] >> (3 * 8))], (3 * 8));
878   sa[2] = *((u32_a_t*)rk[1][2]) ^ sb[2];
879
880   sb[3] ^= rol(decT[(byte)(sa[3] >> (0 * 8))], (0 * 8));
881   sa[0] ^= rol(decT[(byte)(sa[3] >> (1 * 8))], (1 * 8));
882   sa[1] ^= rol(decT[(byte)(sa[3] >> (2 * 8))], (2 * 8));
883   sa[2] ^= rol(decT[(byte)(sa[3] >> (3 * 8))], (3 * 8));
884   sa[3] = *((u32_a_t*)rk[1][3]) ^ sb[3];
885
886   /* Last round is special. */
887   sb[0] = inv_sbox[(byte)(sa[0] >> (0 * 8))] << (0 * 8);
888   sb[1] = inv_sbox[(byte)(sa[0] >> (1 * 8))] << (1 * 8);
889   sb[2] = inv_sbox[(byte)(sa[0] >> (2 * 8))] << (2 * 8);
890   sb[3] = inv_sbox[(byte)(sa[0] >> (3 * 8))] << (3 * 8);
891   sa[0] = sb[0] ^ *((u32_a_t*)rk[0][0]);
892
893   sb[1] ^= inv_sbox[(byte)(sa[1] >> (0 * 8))] << (0 * 8);
894   sb[2] ^= inv_sbox[(byte)(sa[1] >> (1 * 8))] << (1 * 8);
895   sb[3] ^= inv_sbox[(byte)(sa[1] >> (2 * 8))] << (2 * 8);
896   sa[0] ^= inv_sbox[(byte)(sa[1] >> (3 * 8))] << (3 * 8);
897   sa[1] = sb[1] ^ *((u32_a_t*)rk[0][1]);
898
899   sb[2] ^= inv_sbox[(byte)(sa[2] >> (0 * 8))] << (0 * 8);
900   sb[3] ^= inv_sbox[(byte)(sa[2] >> (1 * 8))] << (1 * 8);
901   sa[0] ^= inv_sbox[(byte)(sa[2] >> (2 * 8))] << (2 * 8);
902   sa[1] ^= inv_sbox[(byte)(sa[2] >> (3 * 8))] << (3 * 8);
903   sa[2] = sb[2] ^ *((u32_a_t*)rk[0][2]);
904
905   sb[3] ^= inv_sbox[(byte)(sa[3] >> (0 * 8))] << (0 * 8);
906   sa[0] ^= inv_sbox[(byte)(sa[3] >> (1 * 8))] << (1 * 8);
907   sa[1] ^= inv_sbox[(byte)(sa[3] >> (2 * 8))] << (2 * 8);
908   sa[2] ^= inv_sbox[(byte)(sa[3] >> (3 * 8))] << (3 * 8);
909   sa[3] = sb[3] ^ *((u32_a_t*)rk[0][3]);
910
911   buf_put_le32(b + 0, sa[0]);
912   buf_put_le32(b + 4, sa[1]);
913   buf_put_le32(b + 8, sa[2]);
914   buf_put_le32(b + 12, sa[3]);
915 #undef rk
916
917   return (56+2*sizeof(int));
918 }
919 #endif /*!USE_ARM_ASM && !USE_AMD64_ASM*/
920
921
922 /* Decrypt one block.  AX and BX may be the same. */
923 static unsigned int
924 do_decrypt (const RIJNDAEL_context *ctx, unsigned char *bx,
925             const unsigned char *ax)
926 {
927 #ifdef USE_AMD64_ASM
928   return _gcry_aes_amd64_decrypt_block(ctx->keyschdec, bx, ax, ctx->rounds,
929                                        &dec_tables);
930 #elif defined(USE_ARM_ASM)
931   return _gcry_aes_arm_decrypt_block(ctx->keyschdec, bx, ax, ctx->rounds,
932                                      &dec_tables);
933 #else
934   return do_decrypt_fn (ctx, bx, ax);
935 #endif /*!USE_ARM_ASM && !USE_AMD64_ASM*/
936 }
937
938
939 static inline void
940 check_decryption_preparation (RIJNDAEL_context *ctx)
941 {
942   if ( !ctx->decryption_prepared )
943     {
944       prepare_decryption ( ctx );
945       ctx->decryption_prepared = 1;
946     }
947 }
948
949
950 static unsigned int
951 rijndael_decrypt (void *context, byte *b, const byte *a)
952 {
953   RIJNDAEL_context *ctx = context;
954
955   check_decryption_preparation (ctx);
956
957   if (ctx->prefetch_dec_fn)
958     ctx->prefetch_dec_fn();
959
960   return ctx->decrypt_fn (ctx, b, a);
961 }
962
963
964 /* Bulk decryption of complete blocks in CFB mode.  Caller needs to
965    make sure that IV is aligned on an unsigned long boundary.  This
966    function is only intended for the bulk encryption feature of
967    cipher.c. */
968 void
969 _gcry_aes_cfb_dec (void *context, unsigned char *iv,
970                    void *outbuf_arg, const void *inbuf_arg,
971                    size_t nblocks)
972 {
973   RIJNDAEL_context *ctx = context;
974   unsigned char *outbuf = outbuf_arg;
975   const unsigned char *inbuf = inbuf_arg;
976   unsigned int burn_depth = 0;
977
978   if (ctx->prefetch_enc_fn)
979     ctx->prefetch_enc_fn();
980
981   if (0)
982     ;
983 #ifdef USE_AESNI
984   else if (ctx->use_aesni)
985     {
986       _gcry_aes_aesni_cfb_dec (ctx, outbuf, inbuf, iv, nblocks);
987       burn_depth = 0;
988     }
989 #endif /*USE_AESNI*/
990   else
991     {
992       rijndael_cryptfn_t encrypt_fn = ctx->encrypt_fn;
993
994       for ( ;nblocks; nblocks-- )
995         {
996           burn_depth = encrypt_fn (ctx, iv, iv);
997           buf_xor_n_copy(outbuf, iv, inbuf, BLOCKSIZE);
998           outbuf += BLOCKSIZE;
999           inbuf  += BLOCKSIZE;
1000         }
1001     }
1002
1003   if (burn_depth)
1004     _gcry_burn_stack (burn_depth + 4 * sizeof(void *));
1005 }
1006
1007
1008 /* Bulk decryption of complete blocks in CBC mode.  Caller needs to
1009    make sure that IV is aligned on an unsigned long boundary.  This
1010    function is only intended for the bulk encryption feature of
1011    cipher.c. */
1012 void
1013 _gcry_aes_cbc_dec (void *context, unsigned char *iv,
1014                    void *outbuf_arg, const void *inbuf_arg,
1015                    size_t nblocks)
1016 {
1017   RIJNDAEL_context *ctx = context;
1018   unsigned char *outbuf = outbuf_arg;
1019   const unsigned char *inbuf = inbuf_arg;
1020   unsigned int burn_depth = 0;
1021
1022   check_decryption_preparation (ctx);
1023
1024   if (ctx->prefetch_dec_fn)
1025     ctx->prefetch_dec_fn();
1026
1027   if (0)
1028     ;
1029 #ifdef USE_AESNI
1030   else if (ctx->use_aesni)
1031     {
1032       _gcry_aes_aesni_cbc_dec (ctx, outbuf, inbuf, iv, nblocks);
1033       burn_depth = 0;
1034     }
1035 #endif /*USE_AESNI*/
1036   else
1037     {
1038       unsigned char savebuf[BLOCKSIZE] ATTR_ALIGNED_16;
1039       rijndael_cryptfn_t decrypt_fn = ctx->decrypt_fn;
1040
1041       for ( ;nblocks; nblocks-- )
1042         {
1043           /* INBUF is needed later and it may be identical to OUTBUF, so store
1044              the intermediate result to SAVEBUF.  */
1045
1046           burn_depth = decrypt_fn (ctx, savebuf, inbuf);
1047
1048           buf_xor_n_copy_2(outbuf, savebuf, iv, inbuf, BLOCKSIZE);
1049           inbuf += BLOCKSIZE;
1050           outbuf += BLOCKSIZE;
1051         }
1052
1053       wipememory(savebuf, sizeof(savebuf));
1054     }
1055
1056   if (burn_depth)
1057     _gcry_burn_stack (burn_depth + 4 * sizeof(void *));
1058 }
1059
1060
1061 \f
1062 /* Run the self-tests for AES 128.  Returns NULL on success. */
1063 static const char*
1064 selftest_basic_128 (void)
1065 {
1066   RIJNDAEL_context ctx;
1067   unsigned char scratch[16];
1068
1069   /* The test vectors are from the AES supplied ones; more or less
1070      randomly taken from ecb_tbl.txt (I=42,81,14) */
1071 #if 1
1072   static const unsigned char plaintext_128[16] =
1073     {
1074       0x01,0x4B,0xAF,0x22,0x78,0xA6,0x9D,0x33,
1075       0x1D,0x51,0x80,0x10,0x36,0x43,0xE9,0x9A
1076     };
1077   static const unsigned char key_128[16] =
1078     {
1079       0xE8,0xE9,0xEA,0xEB,0xED,0xEE,0xEF,0xF0,
1080       0xF2,0xF3,0xF4,0xF5,0xF7,0xF8,0xF9,0xFA
1081     };
1082   static const unsigned char ciphertext_128[16] =
1083     {
1084       0x67,0x43,0xC3,0xD1,0x51,0x9A,0xB4,0xF2,
1085       0xCD,0x9A,0x78,0xAB,0x09,0xA5,0x11,0xBD
1086     };
1087 #else
1088   /* Test vectors from fips-197, appendix C. */
1089 # warning debug test vectors in use
1090   static const unsigned char plaintext_128[16] =
1091     {
1092       0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,
1093       0x88,0x99,0xaa,0xbb,0xcc,0xdd,0xee,0xff
1094     };
1095   static const unsigned char key_128[16] =
1096     {
1097       0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
1098       0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f
1099       /* 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, */
1100       /* 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c */
1101     };
1102   static const unsigned char ciphertext_128[16] =
1103     {
1104       0x69,0xc4,0xe0,0xd8,0x6a,0x7b,0x04,0x30,
1105       0xd8,0xcd,0xb7,0x80,0x70,0xb4,0xc5,0x5a
1106     };
1107 #endif
1108
1109   rijndael_setkey (&ctx, key_128, sizeof (key_128));
1110   rijndael_encrypt (&ctx, scratch, plaintext_128);
1111   if (memcmp (scratch, ciphertext_128, sizeof (ciphertext_128)))
1112      return "AES-128 test encryption failed.";
1113   rijndael_decrypt (&ctx, scratch, scratch);
1114   if (memcmp (scratch, plaintext_128, sizeof (plaintext_128)))
1115     return "AES-128 test decryption failed.";
1116
1117   return NULL;
1118 }
1119
1120 /* Run the self-tests for AES 192.  Returns NULL on success. */
1121 static const char*
1122 selftest_basic_192 (void)
1123 {
1124   RIJNDAEL_context ctx;
1125   unsigned char scratch[16];
1126
1127   static unsigned char plaintext_192[16] =
1128     {
1129       0x76,0x77,0x74,0x75,0xF1,0xF2,0xF3,0xF4,
1130       0xF8,0xF9,0xE6,0xE7,0x77,0x70,0x71,0x72
1131     };
1132   static unsigned char key_192[24] =
1133     {
1134       0x04,0x05,0x06,0x07,0x09,0x0A,0x0B,0x0C,
1135       0x0E,0x0F,0x10,0x11,0x13,0x14,0x15,0x16,
1136       0x18,0x19,0x1A,0x1B,0x1D,0x1E,0x1F,0x20
1137     };
1138   static const unsigned char ciphertext_192[16] =
1139     {
1140       0x5D,0x1E,0xF2,0x0D,0xCE,0xD6,0xBC,0xBC,
1141       0x12,0x13,0x1A,0xC7,0xC5,0x47,0x88,0xAA
1142     };
1143
1144   rijndael_setkey (&ctx, key_192, sizeof(key_192));
1145   rijndael_encrypt (&ctx, scratch, plaintext_192);
1146   if (memcmp (scratch, ciphertext_192, sizeof (ciphertext_192)))
1147     return "AES-192 test encryption failed.";
1148   rijndael_decrypt (&ctx, scratch, scratch);
1149   if (memcmp (scratch, plaintext_192, sizeof (plaintext_192)))
1150     return "AES-192 test decryption failed.";
1151
1152   return NULL;
1153 }
1154
1155
1156 /* Run the self-tests for AES 256.  Returns NULL on success. */
1157 static const char*
1158 selftest_basic_256 (void)
1159 {
1160   RIJNDAEL_context ctx;
1161   unsigned char scratch[16];
1162
1163   static unsigned char plaintext_256[16] =
1164     {
1165       0x06,0x9A,0x00,0x7F,0xC7,0x6A,0x45,0x9F,
1166       0x98,0xBA,0xF9,0x17,0xFE,0xDF,0x95,0x21
1167     };
1168   static unsigned char key_256[32] =
1169     {
1170       0x08,0x09,0x0A,0x0B,0x0D,0x0E,0x0F,0x10,
1171       0x12,0x13,0x14,0x15,0x17,0x18,0x19,0x1A,
1172       0x1C,0x1D,0x1E,0x1F,0x21,0x22,0x23,0x24,
1173       0x26,0x27,0x28,0x29,0x2B,0x2C,0x2D,0x2E
1174     };
1175   static const unsigned char ciphertext_256[16] =
1176     {
1177       0x08,0x0E,0x95,0x17,0xEB,0x16,0x77,0x71,
1178       0x9A,0xCF,0x72,0x80,0x86,0x04,0x0A,0xE3
1179     };
1180
1181   rijndael_setkey (&ctx, key_256, sizeof(key_256));
1182   rijndael_encrypt (&ctx, scratch, plaintext_256);
1183   if (memcmp (scratch, ciphertext_256, sizeof (ciphertext_256)))
1184     return "AES-256 test encryption failed.";
1185   rijndael_decrypt (&ctx, scratch, scratch);
1186   if (memcmp (scratch, plaintext_256, sizeof (plaintext_256)))
1187     return "AES-256 test decryption failed.";
1188
1189   return NULL;
1190 }
1191
1192
1193 /* Run the self-tests for AES-CTR-128, tests IV increment of bulk CTR
1194    encryption.  Returns NULL on success. */
1195 static const char*
1196 selftest_ctr_128 (void)
1197 {
1198   const int nblocks = 8+1;
1199   const int blocksize = BLOCKSIZE;
1200   const int context_size = sizeof(RIJNDAEL_context);
1201
1202   return _gcry_selftest_helper_ctr("AES", &rijndael_setkey,
1203            &rijndael_encrypt, &_gcry_aes_ctr_enc, nblocks, blocksize,
1204            context_size);
1205 }
1206
1207
1208 /* Run the self-tests for AES-CBC-128, tests bulk CBC decryption.
1209    Returns NULL on success. */
1210 static const char*
1211 selftest_cbc_128 (void)
1212 {
1213   const int nblocks = 8+2;
1214   const int blocksize = BLOCKSIZE;
1215   const int context_size = sizeof(RIJNDAEL_context);
1216
1217   return _gcry_selftest_helper_cbc("AES", &rijndael_setkey,
1218            &rijndael_encrypt, &_gcry_aes_cbc_dec, nblocks, blocksize,
1219            context_size);
1220 }
1221
1222
1223 /* Run the self-tests for AES-CFB-128, tests bulk CFB decryption.
1224    Returns NULL on success. */
1225 static const char*
1226 selftest_cfb_128 (void)
1227 {
1228   const int nblocks = 8+2;
1229   const int blocksize = BLOCKSIZE;
1230   const int context_size = sizeof(RIJNDAEL_context);
1231
1232   return _gcry_selftest_helper_cfb("AES", &rijndael_setkey,
1233            &rijndael_encrypt, &_gcry_aes_cfb_dec, nblocks, blocksize,
1234            context_size);
1235 }
1236
1237
1238 /* Run all the self-tests and return NULL on success.  This function
1239    is used for the on-the-fly self-tests. */
1240 static const char *
1241 selftest (void)
1242 {
1243   const char *r;
1244
1245   if ( (r = selftest_basic_128 ())
1246        || (r = selftest_basic_192 ())
1247        || (r = selftest_basic_256 ()) )
1248     return r;
1249
1250   if ( (r = selftest_ctr_128 ()) )
1251     return r;
1252
1253   if ( (r = selftest_cbc_128 ()) )
1254     return r;
1255
1256   if ( (r = selftest_cfb_128 ()) )
1257     return r;
1258
1259   return r;
1260 }
1261
1262
1263 /* SP800-38a.pdf for AES-128.  */
1264 static const char *
1265 selftest_fips_128_38a (int requested_mode)
1266 {
1267   static const struct tv
1268   {
1269     int mode;
1270     const unsigned char key[16];
1271     const unsigned char iv[16];
1272     struct
1273     {
1274       const unsigned char input[16];
1275       const unsigned char output[16];
1276     } data[4];
1277   } tv[2] =
1278     {
1279       {
1280         GCRY_CIPHER_MODE_CFB,  /* F.3.13, CFB128-AES128 */
1281         { 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
1282           0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c },
1283         { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1284           0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1285         {
1286           { { 0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
1287               0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a },
1288             { 0x3b, 0x3f, 0xd9, 0x2e, 0xb7, 0x2d, 0xad, 0x20,
1289               0x33, 0x34, 0x49, 0xf8, 0xe8, 0x3c, 0xfb, 0x4a } },
1290
1291           { { 0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
1292               0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51 },
1293             { 0xc8, 0xa6, 0x45, 0x37, 0xa0, 0xb3, 0xa9, 0x3f,
1294               0xcd, 0xe3, 0xcd, 0xad, 0x9f, 0x1c, 0xe5, 0x8b } },
1295
1296           { { 0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
1297               0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef },
1298             { 0x26, 0x75, 0x1f, 0x67, 0xa3, 0xcb, 0xb1, 0x40,
1299               0xb1, 0x80, 0x8c, 0xf1, 0x87, 0xa4, 0xf4, 0xdf } },
1300
1301           { { 0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
1302               0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10 },
1303             { 0xc0, 0x4b, 0x05, 0x35, 0x7c, 0x5d, 0x1c, 0x0e,
1304               0xea, 0xc4, 0xc6, 0x6f, 0x9f, 0xf7, 0xf2, 0xe6 } }
1305         }
1306       },
1307       {
1308         GCRY_CIPHER_MODE_OFB,
1309         { 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
1310           0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c },
1311         { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1312           0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1313         {
1314           { { 0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
1315               0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a },
1316             { 0x3b, 0x3f, 0xd9, 0x2e, 0xb7, 0x2d, 0xad, 0x20,
1317               0x33, 0x34, 0x49, 0xf8, 0xe8, 0x3c, 0xfb, 0x4a } },
1318
1319           { { 0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
1320               0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51 },
1321             { 0x77, 0x89, 0x50, 0x8d, 0x16, 0x91, 0x8f, 0x03,
1322               0xf5, 0x3c, 0x52, 0xda, 0xc5, 0x4e, 0xd8, 0x25 } },
1323
1324           { { 0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
1325               0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef },
1326             { 0x97, 0x40, 0x05, 0x1e, 0x9c, 0x5f, 0xec, 0xf6,
1327               0x43, 0x44, 0xf7, 0xa8, 0x22, 0x60, 0xed, 0xcc } },
1328
1329           { { 0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
1330               0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10 },
1331             { 0x30, 0x4c, 0x65, 0x28, 0xf6, 0x59, 0xc7, 0x78,
1332               0x66, 0xa5, 0x10, 0xd9, 0xc1, 0xd6, 0xae, 0x5e } },
1333         }
1334       }
1335     };
1336   unsigned char scratch[16];
1337   gpg_error_t err;
1338   int tvi, idx;
1339   gcry_cipher_hd_t hdenc = NULL;
1340   gcry_cipher_hd_t hddec = NULL;
1341
1342 #define Fail(a) do {           \
1343     _gcry_cipher_close (hdenc);  \
1344     _gcry_cipher_close (hddec);  \
1345     return a;                    \
1346   } while (0)
1347
1348   gcry_assert (sizeof tv[0].data[0].input == sizeof scratch);
1349   gcry_assert (sizeof tv[0].data[0].output == sizeof scratch);
1350
1351   for (tvi=0; tvi < DIM (tv); tvi++)
1352     if (tv[tvi].mode == requested_mode)
1353       break;
1354   if (tvi == DIM (tv))
1355     Fail ("no test data for this mode");
1356
1357   err = _gcry_cipher_open (&hdenc, GCRY_CIPHER_AES, tv[tvi].mode, 0);
1358   if (err)
1359     Fail ("open");
1360   err = _gcry_cipher_open (&hddec, GCRY_CIPHER_AES, tv[tvi].mode, 0);
1361   if (err)
1362     Fail ("open");
1363   err = _gcry_cipher_setkey (hdenc, tv[tvi].key,  sizeof tv[tvi].key);
1364   if (!err)
1365     err = _gcry_cipher_setkey (hddec, tv[tvi].key, sizeof tv[tvi].key);
1366   if (err)
1367     Fail ("set key");
1368   err = _gcry_cipher_setiv (hdenc, tv[tvi].iv, sizeof tv[tvi].iv);
1369   if (!err)
1370     err = _gcry_cipher_setiv (hddec, tv[tvi].iv, sizeof tv[tvi].iv);
1371   if (err)
1372     Fail ("set IV");
1373   for (idx=0; idx < DIM (tv[tvi].data); idx++)
1374     {
1375       err = _gcry_cipher_encrypt (hdenc, scratch, sizeof scratch,
1376                                   tv[tvi].data[idx].input,
1377                                   sizeof tv[tvi].data[idx].input);
1378       if (err)
1379         Fail ("encrypt command");
1380       if (memcmp (scratch, tv[tvi].data[idx].output, sizeof scratch))
1381         Fail ("encrypt mismatch");
1382       err = _gcry_cipher_decrypt (hddec, scratch, sizeof scratch,
1383                                   tv[tvi].data[idx].output,
1384                                   sizeof tv[tvi].data[idx].output);
1385       if (err)
1386         Fail ("decrypt command");
1387       if (memcmp (scratch, tv[tvi].data[idx].input, sizeof scratch))
1388         Fail ("decrypt mismatch");
1389     }
1390
1391 #undef Fail
1392   _gcry_cipher_close (hdenc);
1393   _gcry_cipher_close (hddec);
1394   return NULL;
1395 }
1396
1397
1398 /* Complete selftest for AES-128 with all modes and driver code.  */
1399 static gpg_err_code_t
1400 selftest_fips_128 (int extended, selftest_report_func_t report)
1401 {
1402   const char *what;
1403   const char *errtxt;
1404
1405   what = "low-level";
1406   errtxt = selftest_basic_128 ();
1407   if (errtxt)
1408     goto failed;
1409
1410   if (extended)
1411     {
1412       what = "cfb";
1413       errtxt = selftest_fips_128_38a (GCRY_CIPHER_MODE_CFB);
1414       if (errtxt)
1415         goto failed;
1416
1417       what = "ofb";
1418       errtxt = selftest_fips_128_38a (GCRY_CIPHER_MODE_OFB);
1419       if (errtxt)
1420         goto failed;
1421     }
1422
1423   return 0; /* Succeeded. */
1424
1425  failed:
1426   if (report)
1427     report ("cipher", GCRY_CIPHER_AES128, what, errtxt);
1428   return GPG_ERR_SELFTEST_FAILED;
1429 }
1430
1431 /* Complete selftest for AES-192.  */
1432 static gpg_err_code_t
1433 selftest_fips_192 (int extended, selftest_report_func_t report)
1434 {
1435   const char *what;
1436   const char *errtxt;
1437
1438   (void)extended; /* No extended tests available.  */
1439
1440   what = "low-level";
1441   errtxt = selftest_basic_192 ();
1442   if (errtxt)
1443     goto failed;
1444
1445
1446   return 0; /* Succeeded. */
1447
1448  failed:
1449   if (report)
1450     report ("cipher", GCRY_CIPHER_AES192, what, errtxt);
1451   return GPG_ERR_SELFTEST_FAILED;
1452 }
1453
1454
1455 /* Complete selftest for AES-256.  */
1456 static gpg_err_code_t
1457 selftest_fips_256 (int extended, selftest_report_func_t report)
1458 {
1459   const char *what;
1460   const char *errtxt;
1461
1462   (void)extended; /* No extended tests available.  */
1463
1464   what = "low-level";
1465   errtxt = selftest_basic_256 ();
1466   if (errtxt)
1467     goto failed;
1468
1469   return 0; /* Succeeded. */
1470
1471  failed:
1472   if (report)
1473     report ("cipher", GCRY_CIPHER_AES256, what, errtxt);
1474   return GPG_ERR_SELFTEST_FAILED;
1475 }
1476
1477
1478
1479 /* Run a full self-test for ALGO and return 0 on success.  */
1480 static gpg_err_code_t
1481 run_selftests (int algo, int extended, selftest_report_func_t report)
1482 {
1483   gpg_err_code_t ec;
1484
1485   switch (algo)
1486     {
1487     case GCRY_CIPHER_AES128:
1488       ec = selftest_fips_128 (extended, report);
1489       break;
1490     case GCRY_CIPHER_AES192:
1491       ec = selftest_fips_192 (extended, report);
1492       break;
1493     case GCRY_CIPHER_AES256:
1494       ec = selftest_fips_256 (extended, report);
1495       break;
1496     default:
1497       ec = GPG_ERR_CIPHER_ALGO;
1498       break;
1499
1500     }
1501   return ec;
1502 }
1503
1504
1505 \f
1506
1507 static const char *rijndael_names[] =
1508   {
1509     "RIJNDAEL",
1510     "AES128",
1511     "AES-128",
1512     NULL
1513   };
1514
1515 static gcry_cipher_oid_spec_t rijndael_oids[] =
1516   {
1517     { "2.16.840.1.101.3.4.1.1", GCRY_CIPHER_MODE_ECB },
1518     { "2.16.840.1.101.3.4.1.2", GCRY_CIPHER_MODE_CBC },
1519     { "2.16.840.1.101.3.4.1.3", GCRY_CIPHER_MODE_OFB },
1520     { "2.16.840.1.101.3.4.1.4", GCRY_CIPHER_MODE_CFB },
1521     { NULL }
1522   };
1523
1524 gcry_cipher_spec_t _gcry_cipher_spec_aes =
1525   {
1526     GCRY_CIPHER_AES, {0, 1},
1527     "AES", rijndael_names, rijndael_oids, 16, 128,
1528     sizeof (RIJNDAEL_context),
1529     rijndael_setkey, rijndael_encrypt, rijndael_decrypt,
1530     NULL, NULL,
1531     run_selftests
1532   };
1533
1534
1535 static const char *rijndael192_names[] =
1536   {
1537     "RIJNDAEL192",
1538     "AES-192",
1539     NULL
1540   };
1541
1542 static gcry_cipher_oid_spec_t rijndael192_oids[] =
1543   {
1544     { "2.16.840.1.101.3.4.1.21", GCRY_CIPHER_MODE_ECB },
1545     { "2.16.840.1.101.3.4.1.22", GCRY_CIPHER_MODE_CBC },
1546     { "2.16.840.1.101.3.4.1.23", GCRY_CIPHER_MODE_OFB },
1547     { "2.16.840.1.101.3.4.1.24", GCRY_CIPHER_MODE_CFB },
1548     { NULL }
1549   };
1550
1551 gcry_cipher_spec_t _gcry_cipher_spec_aes192 =
1552   {
1553     GCRY_CIPHER_AES192, {0, 1},
1554     "AES192", rijndael192_names, rijndael192_oids, 16, 192,
1555     sizeof (RIJNDAEL_context),
1556     rijndael_setkey, rijndael_encrypt, rijndael_decrypt,
1557     NULL, NULL,
1558     run_selftests
1559   };
1560
1561
1562 static const char *rijndael256_names[] =
1563   {
1564     "RIJNDAEL256",
1565     "AES-256",
1566     NULL
1567   };
1568
1569 static gcry_cipher_oid_spec_t rijndael256_oids[] =
1570   {
1571     { "2.16.840.1.101.3.4.1.41", GCRY_CIPHER_MODE_ECB },
1572     { "2.16.840.1.101.3.4.1.42", GCRY_CIPHER_MODE_CBC },
1573     { "2.16.840.1.101.3.4.1.43", GCRY_CIPHER_MODE_OFB },
1574     { "2.16.840.1.101.3.4.1.44", GCRY_CIPHER_MODE_CFB },
1575     { NULL }
1576   };
1577
1578 gcry_cipher_spec_t _gcry_cipher_spec_aes256 =
1579   {
1580     GCRY_CIPHER_AES256, {0, 1},
1581     "AES256", rijndael256_names, rijndael256_oids, 16, 256,
1582     sizeof (RIJNDAEL_context),
1583     rijndael_setkey, rijndael_encrypt, rijndael_decrypt,
1584     NULL, NULL,
1585     run_selftests
1586   };