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