Line data Source code
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 : #include "./cipher-internal.h"
52 :
53 :
54 : #ifdef USE_AMD64_ASM
55 : /* AMD64 assembly implementations of AES */
56 : extern unsigned int _gcry_aes_amd64_encrypt_block(const void *keysched_enc,
57 : unsigned char *out,
58 : const unsigned char *in,
59 : int rounds,
60 : const void *encT);
61 :
62 : extern unsigned int _gcry_aes_amd64_decrypt_block(const void *keysched_dec,
63 : unsigned char *out,
64 : const unsigned char *in,
65 : int rounds,
66 : const void *decT);
67 : #endif /*USE_AMD64_ASM*/
68 :
69 : #ifdef USE_AESNI
70 : /* AES-NI (AMD64 & i386) accelerated implementations of AES */
71 : extern void _gcry_aes_aesni_do_setkey(RIJNDAEL_context *ctx, const byte *key);
72 : extern void _gcry_aes_aesni_prepare_decryption(RIJNDAEL_context *ctx);
73 :
74 : extern unsigned int _gcry_aes_aesni_encrypt (const RIJNDAEL_context *ctx,
75 : unsigned char *dst,
76 : const unsigned char *src);
77 : extern unsigned int _gcry_aes_aesni_decrypt (const RIJNDAEL_context *ctx,
78 : unsigned char *dst,
79 : const unsigned char *src);
80 : extern void _gcry_aes_aesni_cfb_enc (RIJNDAEL_context *ctx,
81 : unsigned char *outbuf,
82 : const unsigned char *inbuf,
83 : unsigned char *iv, size_t nblocks);
84 : extern void _gcry_aes_aesni_cbc_enc (RIJNDAEL_context *ctx,
85 : unsigned char *outbuf,
86 : const unsigned char *inbuf,
87 : unsigned char *iv, size_t nblocks,
88 : int cbc_mac);
89 : extern void _gcry_aes_aesni_ctr_enc (RIJNDAEL_context *ctx,
90 : unsigned char *outbuf,
91 : const unsigned char *inbuf,
92 : unsigned char *ctr, size_t nblocks);
93 : extern void _gcry_aes_aesni_cfb_dec (RIJNDAEL_context *ctx,
94 : unsigned char *outbuf,
95 : const unsigned char *inbuf,
96 : unsigned char *iv, size_t nblocks);
97 : extern void _gcry_aes_aesni_cbc_dec (RIJNDAEL_context *ctx,
98 : unsigned char *outbuf,
99 : const unsigned char *inbuf,
100 : unsigned char *iv, size_t nblocks);
101 : extern void _gcry_aes_aesni_ocb_crypt (gcry_cipher_hd_t c, void *outbuf_arg,
102 : const void *inbuf_arg, size_t nblocks,
103 : int encrypt);
104 : extern void _gcry_aes_aesni_ocb_auth (gcry_cipher_hd_t c, const void *abuf_arg,
105 : size_t nblocks);
106 : #endif
107 :
108 : #ifdef USE_SSSE3
109 : /* SSSE3 (AMD64) vector permutation implementation of AES */
110 : extern void _gcry_aes_ssse3_do_setkey(RIJNDAEL_context *ctx, const byte *key);
111 : extern void _gcry_aes_ssse3_prepare_decryption(RIJNDAEL_context *ctx);
112 :
113 : extern unsigned int _gcry_aes_ssse3_encrypt (const RIJNDAEL_context *ctx,
114 : unsigned char *dst,
115 : const unsigned char *src);
116 : extern unsigned int _gcry_aes_ssse3_decrypt (const RIJNDAEL_context *ctx,
117 : unsigned char *dst,
118 : const unsigned char *src);
119 : extern void _gcry_aes_ssse3_cfb_enc (RIJNDAEL_context *ctx,
120 : unsigned char *outbuf,
121 : const unsigned char *inbuf,
122 : unsigned char *iv, size_t nblocks);
123 : extern void _gcry_aes_ssse3_cbc_enc (RIJNDAEL_context *ctx,
124 : unsigned char *outbuf,
125 : const unsigned char *inbuf,
126 : unsigned char *iv, size_t nblocks,
127 : int cbc_mac);
128 : extern void _gcry_aes_ssse3_ctr_enc (RIJNDAEL_context *ctx,
129 : unsigned char *outbuf,
130 : const unsigned char *inbuf,
131 : unsigned char *ctr, size_t nblocks);
132 : extern void _gcry_aes_ssse3_cfb_dec (RIJNDAEL_context *ctx,
133 : unsigned char *outbuf,
134 : const unsigned char *inbuf,
135 : unsigned char *iv, size_t nblocks);
136 : extern void _gcry_aes_ssse3_cbc_dec (RIJNDAEL_context *ctx,
137 : unsigned char *outbuf,
138 : const unsigned char *inbuf,
139 : unsigned char *iv, size_t nblocks);
140 : extern void _gcry_aes_ssse3_ocb_crypt (gcry_cipher_hd_t c, void *outbuf_arg,
141 : const void *inbuf_arg, size_t nblocks,
142 : int encrypt);
143 : extern void _gcry_aes_ssse3_ocb_auth (gcry_cipher_hd_t c, const void *abuf_arg,
144 : size_t nblocks);
145 : #endif
146 :
147 : #ifdef USE_PADLOCK
148 : extern unsigned int _gcry_aes_padlock_encrypt (const RIJNDAEL_context *ctx,
149 : unsigned char *bx,
150 : const unsigned char *ax);
151 : extern unsigned int _gcry_aes_padlock_decrypt (const RIJNDAEL_context *ctx,
152 : unsigned char *bx,
153 : const unsigned char *ax);
154 : #endif
155 :
156 : #ifdef USE_ARM_ASM
157 : /* ARM assembly implementations of AES */
158 : extern unsigned int _gcry_aes_arm_encrypt_block(const void *keysched_enc,
159 : unsigned char *out,
160 : const unsigned char *in,
161 : int rounds,
162 : const void *encT);
163 :
164 : extern unsigned int _gcry_aes_arm_decrypt_block(const void *keysched_dec,
165 : unsigned char *out,
166 : const unsigned char *in,
167 : int rounds,
168 : const void *decT);
169 : #endif /*USE_ARM_ASM*/
170 :
171 : #ifdef USE_ARM_CE
172 : /* ARMv8 Crypto Extension implementations of AES */
173 : extern void _gcry_aes_armv8_ce_setkey(RIJNDAEL_context *ctx, const byte *key);
174 : extern void _gcry_aes_armv8_ce_prepare_decryption(RIJNDAEL_context *ctx);
175 :
176 : extern unsigned int _gcry_aes_armv8_ce_encrypt(const RIJNDAEL_context *ctx,
177 : unsigned char *dst,
178 : const unsigned char *src);
179 : extern unsigned int _gcry_aes_armv8_ce_decrypt(const RIJNDAEL_context *ctx,
180 : unsigned char *dst,
181 : const unsigned char *src);
182 :
183 : extern void _gcry_aes_armv8_ce_cfb_enc (RIJNDAEL_context *ctx,
184 : unsigned char *outbuf,
185 : const unsigned char *inbuf,
186 : unsigned char *iv, size_t nblocks);
187 : extern void _gcry_aes_armv8_ce_cbc_enc (RIJNDAEL_context *ctx,
188 : unsigned char *outbuf,
189 : const unsigned char *inbuf,
190 : unsigned char *iv, size_t nblocks,
191 : int cbc_mac);
192 : extern void _gcry_aes_armv8_ce_ctr_enc (RIJNDAEL_context *ctx,
193 : unsigned char *outbuf,
194 : const unsigned char *inbuf,
195 : unsigned char *ctr, size_t nblocks);
196 : extern void _gcry_aes_armv8_ce_cfb_dec (RIJNDAEL_context *ctx,
197 : unsigned char *outbuf,
198 : const unsigned char *inbuf,
199 : unsigned char *iv, size_t nblocks);
200 : extern void _gcry_aes_armv8_ce_cbc_dec (RIJNDAEL_context *ctx,
201 : unsigned char *outbuf,
202 : const unsigned char *inbuf,
203 : unsigned char *iv, size_t nblocks);
204 : extern void _gcry_aes_armv8_ce_ocb_crypt (gcry_cipher_hd_t c, void *outbuf_arg,
205 : const void *inbuf_arg, size_t nblocks,
206 : int encrypt);
207 : extern void _gcry_aes_armv8_ce_ocb_auth (gcry_cipher_hd_t c,
208 : const void *abuf_arg, size_t nblocks);
209 : #endif /*USE_ARM_ASM*/
210 :
211 : static unsigned int do_encrypt (const RIJNDAEL_context *ctx, unsigned char *bx,
212 : const unsigned char *ax);
213 : static unsigned int do_decrypt (const RIJNDAEL_context *ctx, unsigned char *bx,
214 : const unsigned char *ax);
215 :
216 :
217 :
218 : /* All the numbers. */
219 : #include "rijndael-tables.h"
220 :
221 :
222 :
223 :
224 : /* Function prototypes. */
225 : static const char *selftest(void);
226 :
227 :
228 :
229 : /* Prefetching for encryption/decryption tables. */
230 508632 : static void prefetch_table(const volatile byte *tab, size_t len)
231 : {
232 : size_t i;
233 :
234 2572069 : for (i = 0; i < len; i += 8 * 32)
235 : {
236 2063437 : (void)tab[i + 0 * 32];
237 2063437 : (void)tab[i + 1 * 32];
238 2063437 : (void)tab[i + 2 * 32];
239 2063437 : (void)tab[i + 3 * 32];
240 2063437 : (void)tab[i + 4 * 32];
241 2063437 : (void)tab[i + 5 * 32];
242 2063437 : (void)tab[i + 6 * 32];
243 2063437 : (void)tab[i + 7 * 32];
244 : }
245 :
246 508632 : (void)tab[len - 1];
247 508632 : }
248 :
249 479723 : static void prefetch_enc(void)
250 : {
251 479723 : prefetch_table((const void *)encT, sizeof(encT));
252 479723 : }
253 :
254 28909 : static void prefetch_dec(void)
255 : {
256 28909 : prefetch_table((const void *)&dec_tables, sizeof(dec_tables));
257 28909 : }
258 :
259 :
260 :
261 : /* Perform the key setup. */
262 : static gcry_err_code_t
263 2957 : do_setkey (RIJNDAEL_context *ctx, const byte *key, const unsigned keylen)
264 : {
265 : static int initialized = 0;
266 : static const char *selftest_failed = 0;
267 : int rounds;
268 2957 : int i,j, r, t, rconpointer = 0;
269 : int KC;
270 : #if defined(USE_AESNI) || defined(USE_PADLOCK) || defined(USE_SSSE3) \
271 : || defined(USE_ARM_CE)
272 : unsigned int hwfeatures;
273 : #endif
274 :
275 : /* The on-the-fly self tests are only run in non-fips mode. In fips
276 : mode explicit self-tests are required. Actually the on-the-fly
277 : self-tests are not fully thread-safe and it might happen that a
278 : failed self-test won't get noticed in another thread.
279 :
280 : FIXME: We might want to have a central registry of succeeded
281 : self-tests. */
282 2957 : if (!fips_mode () && !initialized)
283 : {
284 5 : initialized = 1;
285 5 : selftest_failed = selftest ();
286 5 : if (selftest_failed)
287 0 : log_error ("%s\n", selftest_failed );
288 : }
289 2957 : if (selftest_failed)
290 0 : return GPG_ERR_SELFTEST_FAILED;
291 :
292 2957 : if( keylen == 128/8 )
293 : {
294 1800 : rounds = 10;
295 1800 : KC = 4;
296 : }
297 1157 : else if ( keylen == 192/8 )
298 : {
299 512 : rounds = 12;
300 512 : KC = 6;
301 : }
302 645 : else if ( keylen == 256/8 )
303 : {
304 645 : rounds = 14;
305 645 : KC = 8;
306 : }
307 : else
308 0 : return GPG_ERR_INV_KEYLEN;
309 :
310 2957 : ctx->rounds = rounds;
311 :
312 : #if defined(USE_AESNI) || defined(USE_PADLOCK) || defined(USE_SSSE3) \
313 : || defined(USE_ARM_CE)
314 2957 : hwfeatures = _gcry_get_hw_features ();
315 : #endif
316 :
317 2957 : ctx->decryption_prepared = 0;
318 : #ifdef USE_PADLOCK
319 2957 : ctx->use_padlock = 0;
320 : #endif
321 : #ifdef USE_AESNI
322 2957 : ctx->use_aesni = 0;
323 : #endif
324 : #ifdef USE_SSSE3
325 2957 : ctx->use_ssse3 = 0;
326 : #endif
327 : #ifdef USE_ARM_CE
328 : ctx->use_arm_ce = 0;
329 : #endif
330 :
331 : if (0)
332 : {
333 : ;
334 : }
335 : #ifdef USE_AESNI
336 2957 : else if (hwfeatures & HWF_INTEL_AESNI)
337 : {
338 1558 : ctx->encrypt_fn = _gcry_aes_aesni_encrypt;
339 1558 : ctx->decrypt_fn = _gcry_aes_aesni_decrypt;
340 1558 : ctx->prefetch_enc_fn = NULL;
341 1558 : ctx->prefetch_dec_fn = NULL;
342 1558 : ctx->use_aesni = 1;
343 : }
344 : #endif
345 : #ifdef USE_PADLOCK
346 1399 : else if (hwfeatures & HWF_PADLOCK_AES && keylen == 128/8)
347 : {
348 0 : ctx->encrypt_fn = _gcry_aes_padlock_encrypt;
349 0 : ctx->decrypt_fn = _gcry_aes_padlock_decrypt;
350 0 : ctx->prefetch_enc_fn = NULL;
351 0 : ctx->prefetch_dec_fn = NULL;
352 0 : ctx->use_padlock = 1;
353 0 : memcpy (ctx->padlockkey, key, keylen);
354 : }
355 : #endif
356 : #ifdef USE_SSSE3
357 1399 : else if (hwfeatures & HWF_INTEL_SSSE3)
358 : {
359 0 : ctx->encrypt_fn = _gcry_aes_ssse3_encrypt;
360 0 : ctx->decrypt_fn = _gcry_aes_ssse3_decrypt;
361 0 : ctx->prefetch_enc_fn = NULL;
362 0 : ctx->prefetch_dec_fn = NULL;
363 0 : ctx->use_ssse3 = 1;
364 : }
365 : #endif
366 : #ifdef USE_ARM_CE
367 : else if (hwfeatures & HWF_ARM_AES)
368 : {
369 : ctx->encrypt_fn = _gcry_aes_armv8_ce_encrypt;
370 : ctx->decrypt_fn = _gcry_aes_armv8_ce_decrypt;
371 : ctx->prefetch_enc_fn = NULL;
372 : ctx->prefetch_dec_fn = NULL;
373 : ctx->use_arm_ce = 1;
374 : }
375 : #endif
376 : else
377 : {
378 1399 : ctx->encrypt_fn = do_encrypt;
379 1399 : ctx->decrypt_fn = do_decrypt;
380 1399 : ctx->prefetch_enc_fn = prefetch_enc;
381 1399 : ctx->prefetch_dec_fn = prefetch_dec;
382 : }
383 :
384 : /* NB: We don't yet support Padlock hardware key generation. */
385 :
386 : if (0)
387 : {
388 : ;
389 : }
390 : #ifdef USE_AESNI
391 2957 : else if (ctx->use_aesni)
392 1558 : _gcry_aes_aesni_do_setkey (ctx, key);
393 : #endif
394 : #ifdef USE_SSSE3
395 1399 : else if (ctx->use_ssse3)
396 0 : _gcry_aes_ssse3_do_setkey (ctx, key);
397 : #endif
398 : #ifdef USE_ARM_CE
399 : else if (ctx->use_arm_ce)
400 : _gcry_aes_armv8_ce_setkey (ctx, key);
401 : #endif
402 : else
403 : {
404 1399 : const byte *sbox = ((const byte *)encT) + 1;
405 : union
406 : {
407 : PROPERLY_ALIGNED_TYPE dummy;
408 : byte data[MAXKC][4];
409 : u32 data32[MAXKC];
410 : } tkk[2];
411 : #define k tkk[0].data
412 : #define k_u32 tkk[0].data32
413 : #define tk tkk[1].data
414 : #define tk_u32 tkk[1].data32
415 : #define W (ctx->keyschenc)
416 : #define W_u32 (ctx->keyschenc32)
417 :
418 1399 : prefetch_enc();
419 :
420 30407 : for (i = 0; i < keylen; i++)
421 : {
422 29008 : k[i >> 2][i & 3] = key[i];
423 : }
424 :
425 8651 : for (j = KC-1; j >= 0; j--)
426 : {
427 7252 : tk_u32[j] = k_u32[j];
428 : }
429 1399 : r = 0;
430 1399 : t = 0;
431 : /* Copy values into round key array. */
432 4727 : for (j = 0; (j < KC) && (r < rounds + 1); )
433 : {
434 9181 : for (; (j < KC) && (t < 4); j++, t++)
435 : {
436 7252 : W_u32[r][t] = le_bswap32(tk_u32[j]);
437 : }
438 1929 : if (t == 4)
439 : {
440 1697 : r++;
441 1697 : t = 0;
442 : }
443 : }
444 :
445 15430 : while (r < rounds + 1)
446 : {
447 : /* While not enough round key material calculated calculate
448 : new values. */
449 12632 : tk[0][0] ^= sbox[tk[KC-1][1] * 4];
450 12632 : tk[0][1] ^= sbox[tk[KC-1][2] * 4];
451 12632 : tk[0][2] ^= sbox[tk[KC-1][3] * 4];
452 12632 : tk[0][3] ^= sbox[tk[KC-1][0] * 4];
453 12632 : tk[0][0] ^= rcon[rconpointer++];
454 :
455 12632 : if (KC != 8)
456 : {
457 45896 : for (j = 1; j < KC; j++)
458 : {
459 35350 : tk_u32[j] ^= tk_u32[j-1];
460 : }
461 : }
462 : else
463 : {
464 8344 : for (j = 1; j < KC/2; j++)
465 : {
466 6258 : tk_u32[j] ^= tk_u32[j-1];
467 : }
468 2086 : tk[KC/2][0] ^= sbox[tk[KC/2 - 1][0] * 4];
469 2086 : tk[KC/2][1] ^= sbox[tk[KC/2 - 1][1] * 4];
470 2086 : tk[KC/2][2] ^= sbox[tk[KC/2 - 1][2] * 4];
471 2086 : tk[KC/2][3] ^= sbox[tk[KC/2 - 1][3] * 4];
472 8344 : for (j = KC/2 + 1; j < KC; j++)
473 : {
474 6258 : tk_u32[j] ^= tk_u32[j-1];
475 : }
476 : }
477 :
478 : /* Copy values into round key array. */
479 41308 : for (j = 0; (j < KC) && (r < rounds + 1); )
480 : {
481 76972 : for (; (j < KC) && (t < 4); j++, t++)
482 : {
483 60928 : W_u32[r][t] = le_bswap32(tk_u32[j]);
484 : }
485 16044 : if (t == 4)
486 : {
487 15348 : r++;
488 15348 : t = 0;
489 : }
490 : }
491 : }
492 : #undef W
493 : #undef tk
494 : #undef k
495 : #undef W_u32
496 : #undef tk_u32
497 : #undef k_u32
498 1399 : wipememory(&tkk, sizeof(tkk));
499 : }
500 :
501 2957 : return 0;
502 : }
503 :
504 :
505 : static gcry_err_code_t
506 2957 : rijndael_setkey (void *context, const byte *key, const unsigned keylen)
507 : {
508 2957 : RIJNDAEL_context *ctx = context;
509 2957 : return do_setkey (ctx, key, keylen);
510 : }
511 :
512 :
513 : /* Make a decryption key from an encryption key. */
514 : static void
515 2116 : prepare_decryption( RIJNDAEL_context *ctx )
516 : {
517 : int r;
518 :
519 : if (0)
520 : ;
521 : #ifdef USE_AESNI
522 2116 : else if (ctx->use_aesni)
523 : {
524 1082 : _gcry_aes_aesni_prepare_decryption (ctx);
525 : }
526 : #endif /*USE_AESNI*/
527 : #ifdef USE_SSSE3
528 1034 : else if (ctx->use_ssse3)
529 : {
530 0 : _gcry_aes_ssse3_prepare_decryption (ctx);
531 : }
532 : #endif /*USE_SSSE3*/
533 : #ifdef USE_ARM_CE
534 : else if (ctx->use_arm_ce)
535 : {
536 : _gcry_aes_armv8_ce_prepare_decryption (ctx);
537 : }
538 : #endif /*USE_SSSE3*/
539 : #ifdef USE_PADLOCK
540 1034 : else if (ctx->use_padlock)
541 : {
542 : /* Padlock does not need decryption subkeys. */
543 : }
544 : #endif /*USE_PADLOCK*/
545 : else
546 : {
547 1034 : const byte *sbox = ((const byte *)encT) + 1;
548 :
549 1034 : prefetch_enc();
550 1034 : prefetch_dec();
551 :
552 1034 : ctx->keyschdec32[0][0] = ctx->keyschenc32[0][0];
553 1034 : ctx->keyschdec32[0][1] = ctx->keyschenc32[0][1];
554 1034 : ctx->keyschdec32[0][2] = ctx->keyschenc32[0][2];
555 1034 : ctx->keyschdec32[0][3] = ctx->keyschenc32[0][3];
556 :
557 12360 : for (r = 1; r < ctx->rounds; r++)
558 : {
559 11326 : u32 *wi = ctx->keyschenc32[r];
560 11326 : u32 *wo = ctx->keyschdec32[r];
561 : u32 wt;
562 :
563 11326 : wt = wi[0];
564 22652 : wo[0] = rol(decT[sbox[(byte)(wt >> 0) * 4]], 8 * 0)
565 11326 : ^ rol(decT[sbox[(byte)(wt >> 8) * 4]], 8 * 1)
566 11326 : ^ rol(decT[sbox[(byte)(wt >> 16) * 4]], 8 * 2)
567 11326 : ^ rol(decT[sbox[(byte)(wt >> 24) * 4]], 8 * 3);
568 :
569 11326 : wt = wi[1];
570 22652 : wo[1] = rol(decT[sbox[(byte)(wt >> 0) * 4]], 8 * 0)
571 11326 : ^ rol(decT[sbox[(byte)(wt >> 8) * 4]], 8 * 1)
572 11326 : ^ rol(decT[sbox[(byte)(wt >> 16) * 4]], 8 * 2)
573 11326 : ^ rol(decT[sbox[(byte)(wt >> 24) * 4]], 8 * 3);
574 :
575 11326 : wt = wi[2];
576 22652 : wo[2] = rol(decT[sbox[(byte)(wt >> 0) * 4]], 8 * 0)
577 11326 : ^ rol(decT[sbox[(byte)(wt >> 8) * 4]], 8 * 1)
578 11326 : ^ rol(decT[sbox[(byte)(wt >> 16) * 4]], 8 * 2)
579 11326 : ^ rol(decT[sbox[(byte)(wt >> 24) * 4]], 8 * 3);
580 :
581 11326 : wt = wi[3];
582 22652 : wo[3] = rol(decT[sbox[(byte)(wt >> 0) * 4]], 8 * 0)
583 11326 : ^ rol(decT[sbox[(byte)(wt >> 8) * 4]], 8 * 1)
584 11326 : ^ rol(decT[sbox[(byte)(wt >> 16) * 4]], 8 * 2)
585 11326 : ^ rol(decT[sbox[(byte)(wt >> 24) * 4]], 8 * 3);
586 : }
587 :
588 1034 : ctx->keyschdec32[r][0] = ctx->keyschenc32[r][0];
589 1034 : ctx->keyschdec32[r][1] = ctx->keyschenc32[r][1];
590 1034 : ctx->keyschdec32[r][2] = ctx->keyschenc32[r][2];
591 1034 : ctx->keyschdec32[r][3] = ctx->keyschenc32[r][3];
592 : }
593 2116 : }
594 :
595 :
596 : #if !defined(USE_ARM_ASM) && !defined(USE_AMD64_ASM)
597 : /* Encrypt one block. A and B may be the same. */
598 : static unsigned int
599 : do_encrypt_fn (const RIJNDAEL_context *ctx, unsigned char *b,
600 : const unsigned char *a)
601 : {
602 : #define rk (ctx->keyschenc32)
603 : const byte *sbox = ((const byte *)encT) + 1;
604 : int rounds = ctx->rounds;
605 : int r;
606 : u32 sa[4];
607 : u32 sb[4];
608 :
609 : sb[0] = buf_get_le32(a + 0);
610 : sb[1] = buf_get_le32(a + 4);
611 : sb[2] = buf_get_le32(a + 8);
612 : sb[3] = buf_get_le32(a + 12);
613 :
614 : sa[0] = sb[0] ^ rk[0][0];
615 : sa[1] = sb[1] ^ rk[0][1];
616 : sa[2] = sb[2] ^ rk[0][2];
617 : sa[3] = sb[3] ^ rk[0][3];
618 :
619 : sb[0] = rol(encT[(byte)(sa[0] >> (0 * 8))], (0 * 8));
620 : sb[3] = rol(encT[(byte)(sa[0] >> (1 * 8))], (1 * 8));
621 : sb[2] = rol(encT[(byte)(sa[0] >> (2 * 8))], (2 * 8));
622 : sb[1] = rol(encT[(byte)(sa[0] >> (3 * 8))], (3 * 8));
623 : sa[0] = rk[1][0] ^ sb[0];
624 :
625 : sb[1] ^= rol(encT[(byte)(sa[1] >> (0 * 8))], (0 * 8));
626 : sa[0] ^= rol(encT[(byte)(sa[1] >> (1 * 8))], (1 * 8));
627 : sb[3] ^= rol(encT[(byte)(sa[1] >> (2 * 8))], (2 * 8));
628 : sb[2] ^= rol(encT[(byte)(sa[1] >> (3 * 8))], (3 * 8));
629 : sa[1] = rk[1][1] ^ sb[1];
630 :
631 : sb[2] ^= rol(encT[(byte)(sa[2] >> (0 * 8))], (0 * 8));
632 : sa[1] ^= rol(encT[(byte)(sa[2] >> (1 * 8))], (1 * 8));
633 : sa[0] ^= rol(encT[(byte)(sa[2] >> (2 * 8))], (2 * 8));
634 : sb[3] ^= rol(encT[(byte)(sa[2] >> (3 * 8))], (3 * 8));
635 : sa[2] = rk[1][2] ^ sb[2];
636 :
637 : sb[3] ^= rol(encT[(byte)(sa[3] >> (0 * 8))], (0 * 8));
638 : sa[2] ^= rol(encT[(byte)(sa[3] >> (1 * 8))], (1 * 8));
639 : sa[1] ^= rol(encT[(byte)(sa[3] >> (2 * 8))], (2 * 8));
640 : sa[0] ^= rol(encT[(byte)(sa[3] >> (3 * 8))], (3 * 8));
641 : sa[3] = rk[1][3] ^ sb[3];
642 :
643 : for (r = 2; r < rounds; r++)
644 : {
645 : sb[0] = rol(encT[(byte)(sa[0] >> (0 * 8))], (0 * 8));
646 : sb[3] = rol(encT[(byte)(sa[0] >> (1 * 8))], (1 * 8));
647 : sb[2] = rol(encT[(byte)(sa[0] >> (2 * 8))], (2 * 8));
648 : sb[1] = rol(encT[(byte)(sa[0] >> (3 * 8))], (3 * 8));
649 : sa[0] = rk[r][0] ^ sb[0];
650 :
651 : sb[1] ^= rol(encT[(byte)(sa[1] >> (0 * 8))], (0 * 8));
652 : sa[0] ^= rol(encT[(byte)(sa[1] >> (1 * 8))], (1 * 8));
653 : sb[3] ^= rol(encT[(byte)(sa[1] >> (2 * 8))], (2 * 8));
654 : sb[2] ^= rol(encT[(byte)(sa[1] >> (3 * 8))], (3 * 8));
655 : sa[1] = rk[r][1] ^ sb[1];
656 :
657 : sb[2] ^= rol(encT[(byte)(sa[2] >> (0 * 8))], (0 * 8));
658 : sa[1] ^= rol(encT[(byte)(sa[2] >> (1 * 8))], (1 * 8));
659 : sa[0] ^= rol(encT[(byte)(sa[2] >> (2 * 8))], (2 * 8));
660 : sb[3] ^= rol(encT[(byte)(sa[2] >> (3 * 8))], (3 * 8));
661 : sa[2] = rk[r][2] ^ sb[2];
662 :
663 : sb[3] ^= rol(encT[(byte)(sa[3] >> (0 * 8))], (0 * 8));
664 : sa[2] ^= rol(encT[(byte)(sa[3] >> (1 * 8))], (1 * 8));
665 : sa[1] ^= rol(encT[(byte)(sa[3] >> (2 * 8))], (2 * 8));
666 : sa[0] ^= rol(encT[(byte)(sa[3] >> (3 * 8))], (3 * 8));
667 : sa[3] = rk[r][3] ^ sb[3];
668 :
669 : r++;
670 :
671 : sb[0] = rol(encT[(byte)(sa[0] >> (0 * 8))], (0 * 8));
672 : sb[3] = rol(encT[(byte)(sa[0] >> (1 * 8))], (1 * 8));
673 : sb[2] = rol(encT[(byte)(sa[0] >> (2 * 8))], (2 * 8));
674 : sb[1] = rol(encT[(byte)(sa[0] >> (3 * 8))], (3 * 8));
675 : sa[0] = rk[r][0] ^ sb[0];
676 :
677 : sb[1] ^= rol(encT[(byte)(sa[1] >> (0 * 8))], (0 * 8));
678 : sa[0] ^= rol(encT[(byte)(sa[1] >> (1 * 8))], (1 * 8));
679 : sb[3] ^= rol(encT[(byte)(sa[1] >> (2 * 8))], (2 * 8));
680 : sb[2] ^= rol(encT[(byte)(sa[1] >> (3 * 8))], (3 * 8));
681 : sa[1] = rk[r][1] ^ sb[1];
682 :
683 : sb[2] ^= rol(encT[(byte)(sa[2] >> (0 * 8))], (0 * 8));
684 : sa[1] ^= rol(encT[(byte)(sa[2] >> (1 * 8))], (1 * 8));
685 : sa[0] ^= rol(encT[(byte)(sa[2] >> (2 * 8))], (2 * 8));
686 : sb[3] ^= rol(encT[(byte)(sa[2] >> (3 * 8))], (3 * 8));
687 : sa[2] = rk[r][2] ^ sb[2];
688 :
689 : sb[3] ^= rol(encT[(byte)(sa[3] >> (0 * 8))], (0 * 8));
690 : sa[2] ^= rol(encT[(byte)(sa[3] >> (1 * 8))], (1 * 8));
691 : sa[1] ^= rol(encT[(byte)(sa[3] >> (2 * 8))], (2 * 8));
692 : sa[0] ^= rol(encT[(byte)(sa[3] >> (3 * 8))], (3 * 8));
693 : sa[3] = rk[r][3] ^ sb[3];
694 : }
695 :
696 : /* Last round is special. */
697 :
698 : sb[0] = (sbox[(byte)(sa[0] >> (0 * 8)) * 4]) << (0 * 8);
699 : sb[3] = (sbox[(byte)(sa[0] >> (1 * 8)) * 4]) << (1 * 8);
700 : sb[2] = (sbox[(byte)(sa[0] >> (2 * 8)) * 4]) << (2 * 8);
701 : sb[1] = (sbox[(byte)(sa[0] >> (3 * 8)) * 4]) << (3 * 8);
702 : sa[0] = rk[r][0] ^ sb[0];
703 :
704 : sb[1] ^= (sbox[(byte)(sa[1] >> (0 * 8)) * 4]) << (0 * 8);
705 : sa[0] ^= (sbox[(byte)(sa[1] >> (1 * 8)) * 4]) << (1 * 8);
706 : sb[3] ^= (sbox[(byte)(sa[1] >> (2 * 8)) * 4]) << (2 * 8);
707 : sb[2] ^= (sbox[(byte)(sa[1] >> (3 * 8)) * 4]) << (3 * 8);
708 : sa[1] = rk[r][1] ^ sb[1];
709 :
710 : sb[2] ^= (sbox[(byte)(sa[2] >> (0 * 8)) * 4]) << (0 * 8);
711 : sa[1] ^= (sbox[(byte)(sa[2] >> (1 * 8)) * 4]) << (1 * 8);
712 : sa[0] ^= (sbox[(byte)(sa[2] >> (2 * 8)) * 4]) << (2 * 8);
713 : sb[3] ^= (sbox[(byte)(sa[2] >> (3 * 8)) * 4]) << (3 * 8);
714 : sa[2] = rk[r][2] ^ sb[2];
715 :
716 : sb[3] ^= (sbox[(byte)(sa[3] >> (0 * 8)) * 4]) << (0 * 8);
717 : sa[2] ^= (sbox[(byte)(sa[3] >> (1 * 8)) * 4]) << (1 * 8);
718 : sa[1] ^= (sbox[(byte)(sa[3] >> (2 * 8)) * 4]) << (2 * 8);
719 : sa[0] ^= (sbox[(byte)(sa[3] >> (3 * 8)) * 4]) << (3 * 8);
720 : sa[3] = rk[r][3] ^ sb[3];
721 :
722 : buf_put_le32(b + 0, sa[0]);
723 : buf_put_le32(b + 4, sa[1]);
724 : buf_put_le32(b + 8, sa[2]);
725 : buf_put_le32(b + 12, sa[3]);
726 : #undef rk
727 :
728 : return (56 + 2*sizeof(int));
729 : }
730 : #endif /*!USE_ARM_ASM && !USE_AMD64_ASM*/
731 :
732 :
733 : static unsigned int
734 5426554 : do_encrypt (const RIJNDAEL_context *ctx,
735 : unsigned char *bx, const unsigned char *ax)
736 : {
737 : #ifdef USE_AMD64_ASM
738 : # ifdef HAVE_COMPATIBLE_GCC_AMD64_PLATFORM_AS
739 5426554 : return _gcry_aes_amd64_encrypt_block(ctx->keyschenc, bx, ax, ctx->rounds,
740 : encT);
741 : # else
742 : /* Call SystemV ABI function without storing non-volatile XMM registers,
743 : * as target function does not use vector instruction sets. */
744 : const void *key = ctx->keyschenc;
745 : uintptr_t rounds = ctx->rounds;
746 : uintptr_t ret;
747 : asm volatile ("movq %[encT], %%r8\n\t"
748 : "callq *%[ret]\n\t"
749 : : [ret] "=a" (ret),
750 : "+D" (key),
751 : "+S" (bx),
752 : "+d" (ax),
753 : "+c" (rounds)
754 : : "0" (_gcry_aes_amd64_encrypt_block),
755 : [encT] "g" (encT)
756 : : "cc", "memory", "r8", "r9", "r10", "r11");
757 : return ret;
758 : # endif /* HAVE_COMPATIBLE_GCC_AMD64_PLATFORM_AS */
759 : #elif defined(USE_ARM_ASM)
760 : return _gcry_aes_arm_encrypt_block(ctx->keyschenc, bx, ax, ctx->rounds, encT);
761 : #else
762 : return do_encrypt_fn (ctx, bx, ax);
763 : #endif /* !USE_ARM_ASM && !USE_AMD64_ASM*/
764 : }
765 :
766 :
767 : static unsigned int
768 5036044 : rijndael_encrypt (void *context, byte *b, const byte *a)
769 : {
770 5036044 : RIJNDAEL_context *ctx = context;
771 :
772 5036044 : if (ctx->prefetch_enc_fn)
773 464489 : ctx->prefetch_enc_fn();
774 :
775 5036044 : return ctx->encrypt_fn (ctx, b, a);
776 : }
777 :
778 :
779 : /* Bulk encryption of complete blocks in CFB mode. Caller needs to
780 : make sure that IV is aligned on an unsigned long boundary. This
781 : function is only intended for the bulk encryption feature of
782 : cipher.c. */
783 : void
784 13310 : _gcry_aes_cfb_enc (void *context, unsigned char *iv,
785 : void *outbuf_arg, const void *inbuf_arg,
786 : size_t nblocks)
787 : {
788 13310 : RIJNDAEL_context *ctx = context;
789 13310 : unsigned char *outbuf = outbuf_arg;
790 13310 : const unsigned char *inbuf = inbuf_arg;
791 13310 : unsigned int burn_depth = 0;
792 :
793 13310 : if (ctx->prefetch_enc_fn)
794 675 : ctx->prefetch_enc_fn();
795 :
796 : if (0)
797 : ;
798 : #ifdef USE_AESNI
799 13310 : else if (ctx->use_aesni)
800 : {
801 12635 : _gcry_aes_aesni_cfb_enc (ctx, outbuf, inbuf, iv, nblocks);
802 12635 : burn_depth = 0;
803 : }
804 : #endif /*USE_AESNI*/
805 : #ifdef USE_SSSE3
806 675 : else if (ctx->use_ssse3)
807 : {
808 0 : _gcry_aes_ssse3_cfb_enc (ctx, outbuf, inbuf, iv, nblocks);
809 0 : burn_depth = 0;
810 : }
811 : #endif /*USE_SSSE3*/
812 : #ifdef USE_ARM_CE
813 : else if (ctx->use_arm_ce)
814 : {
815 : _gcry_aes_armv8_ce_cfb_enc (ctx, outbuf, inbuf, iv, nblocks);
816 : burn_depth = 0;
817 : }
818 : #endif /*USE_ARM_CE*/
819 : else
820 : {
821 675 : rijndael_cryptfn_t encrypt_fn = ctx->encrypt_fn;
822 :
823 13359 : for ( ;nblocks; nblocks-- )
824 : {
825 : /* Encrypt the IV. */
826 12684 : burn_depth = encrypt_fn (ctx, iv, iv);
827 : /* XOR the input with the IV and store input into IV. */
828 12684 : buf_xor_2dst(outbuf, iv, inbuf, BLOCKSIZE);
829 12684 : outbuf += BLOCKSIZE;
830 12684 : inbuf += BLOCKSIZE;
831 : }
832 : }
833 :
834 13310 : if (burn_depth)
835 675 : _gcry_burn_stack (burn_depth + 4 * sizeof(void *));
836 13310 : }
837 :
838 :
839 : /* Bulk encryption of complete blocks in CBC mode. Caller needs to
840 : make sure that IV is aligned on an unsigned long boundary. This
841 : function is only intended for the bulk encryption feature of
842 : cipher.c. */
843 : void
844 128094 : _gcry_aes_cbc_enc (void *context, unsigned char *iv,
845 : void *outbuf_arg, const void *inbuf_arg,
846 : size_t nblocks, int cbc_mac)
847 : {
848 128094 : RIJNDAEL_context *ctx = context;
849 128094 : unsigned char *outbuf = outbuf_arg;
850 128094 : const unsigned char *inbuf = inbuf_arg;
851 : unsigned char *last_iv;
852 128094 : unsigned int burn_depth = 0;
853 :
854 128094 : if (ctx->prefetch_enc_fn)
855 6590 : ctx->prefetch_enc_fn();
856 :
857 : if (0)
858 : ;
859 : #ifdef USE_AESNI
860 128094 : else if (ctx->use_aesni)
861 : {
862 121504 : _gcry_aes_aesni_cbc_enc (ctx, outbuf, inbuf, iv, nblocks, cbc_mac);
863 121504 : burn_depth = 0;
864 : }
865 : #endif /*USE_AESNI*/
866 : #ifdef USE_SSSE3
867 6590 : else if (ctx->use_ssse3)
868 : {
869 0 : _gcry_aes_ssse3_cbc_enc (ctx, outbuf, inbuf, iv, nblocks, cbc_mac);
870 0 : burn_depth = 0;
871 : }
872 : #endif /*USE_SSSE3*/
873 : #ifdef USE_ARM_CE
874 : else if (ctx->use_arm_ce)
875 : {
876 : _gcry_aes_armv8_ce_cbc_enc (ctx, outbuf, inbuf, iv, nblocks, cbc_mac);
877 : burn_depth = 0;
878 : }
879 : #endif /*USE_ARM_CE*/
880 : else
881 : {
882 6590 : rijndael_cryptfn_t encrypt_fn = ctx->encrypt_fn;
883 :
884 6590 : last_iv = iv;
885 :
886 132614 : for ( ;nblocks; nblocks-- )
887 : {
888 126024 : buf_xor(outbuf, inbuf, last_iv, BLOCKSIZE);
889 :
890 126024 : burn_depth = encrypt_fn (ctx, outbuf, outbuf);
891 :
892 126024 : last_iv = outbuf;
893 126024 : inbuf += BLOCKSIZE;
894 126024 : if (!cbc_mac)
895 25078 : outbuf += BLOCKSIZE;
896 : }
897 :
898 6590 : if (last_iv != iv)
899 5365 : buf_cpy (iv, last_iv, BLOCKSIZE);
900 : }
901 :
902 128094 : if (burn_depth)
903 5365 : _gcry_burn_stack (burn_depth + 4 * sizeof(void *));
904 128094 : }
905 :
906 :
907 : /* Bulk encryption of complete blocks in CTR mode. Caller needs to
908 : make sure that CTR is aligned on a 16 byte boundary if AESNI; the
909 : minimum alignment is for an u32. This function is only intended
910 : for the bulk encryption feature of cipher.c. CTR is expected to be
911 : of size BLOCKSIZE. */
912 : void
913 75191 : _gcry_aes_ctr_enc (void *context, unsigned char *ctr,
914 : void *outbuf_arg, const void *inbuf_arg,
915 : size_t nblocks)
916 : {
917 75191 : RIJNDAEL_context *ctx = context;
918 75191 : unsigned char *outbuf = outbuf_arg;
919 75191 : const unsigned char *inbuf = inbuf_arg;
920 75191 : unsigned int burn_depth = 0;
921 : int i;
922 :
923 75191 : if (ctx->prefetch_enc_fn)
924 3873 : ctx->prefetch_enc_fn();
925 :
926 : if (0)
927 : ;
928 : #ifdef USE_AESNI
929 75191 : else if (ctx->use_aesni)
930 : {
931 71318 : _gcry_aes_aesni_ctr_enc (ctx, outbuf, inbuf, ctr, nblocks);
932 71318 : burn_depth = 0;
933 : }
934 : #endif /*USE_AESNI*/
935 : #ifdef USE_SSSE3
936 3873 : else if (ctx->use_ssse3)
937 : {
938 0 : _gcry_aes_ssse3_ctr_enc (ctx, outbuf, inbuf, ctr, nblocks);
939 0 : burn_depth = 0;
940 : }
941 : #endif /*USE_SSSE3*/
942 : #ifdef USE_ARM_CE
943 : else if (ctx->use_arm_ce)
944 : {
945 : _gcry_aes_armv8_ce_ctr_enc (ctx, outbuf, inbuf, ctr, nblocks);
946 : burn_depth = 0;
947 : }
948 : #endif /*USE_ARM_CE*/
949 : else
950 : {
951 : union { unsigned char x1[16] ATTR_ALIGNED_16; u32 x32[4]; } tmp;
952 3873 : rijndael_cryptfn_t encrypt_fn = ctx->encrypt_fn;
953 :
954 83326 : for ( ;nblocks; nblocks-- )
955 : {
956 : /* Encrypt the counter. */
957 79453 : burn_depth = encrypt_fn (ctx, tmp.x1, ctr);
958 : /* XOR the input with the encrypted counter and store in output. */
959 79453 : buf_xor(outbuf, tmp.x1, inbuf, BLOCKSIZE);
960 79453 : outbuf += BLOCKSIZE;
961 79453 : inbuf += BLOCKSIZE;
962 : /* Increment the counter. */
963 79630 : for (i = BLOCKSIZE; i > 0; i--)
964 : {
965 79629 : ctr[i-1]++;
966 79629 : if (ctr[i-1])
967 79452 : break;
968 : }
969 : }
970 :
971 3873 : wipememory(&tmp, sizeof(tmp));
972 : }
973 :
974 75191 : if (burn_depth)
975 3873 : _gcry_burn_stack (burn_depth + 4 * sizeof(void *));
976 75191 : }
977 :
978 :
979 :
980 : #if !defined(USE_ARM_ASM) && !defined(USE_AMD64_ASM)
981 : /* Decrypt one block. A and B may be the same. */
982 : static unsigned int
983 : do_decrypt_fn (const RIJNDAEL_context *ctx, unsigned char *b,
984 : const unsigned char *a)
985 : {
986 : #define rk (ctx->keyschdec32)
987 : int rounds = ctx->rounds;
988 : int r;
989 : u32 sa[4];
990 : u32 sb[4];
991 :
992 : sb[0] = buf_get_le32(a + 0);
993 : sb[1] = buf_get_le32(a + 4);
994 : sb[2] = buf_get_le32(a + 8);
995 : sb[3] = buf_get_le32(a + 12);
996 :
997 : sa[0] = sb[0] ^ rk[rounds][0];
998 : sa[1] = sb[1] ^ rk[rounds][1];
999 : sa[2] = sb[2] ^ rk[rounds][2];
1000 : sa[3] = sb[3] ^ rk[rounds][3];
1001 :
1002 : for (r = rounds - 1; r > 1; r--)
1003 : {
1004 : sb[0] = rol(decT[(byte)(sa[0] >> (0 * 8))], (0 * 8));
1005 : sb[1] = rol(decT[(byte)(sa[0] >> (1 * 8))], (1 * 8));
1006 : sb[2] = rol(decT[(byte)(sa[0] >> (2 * 8))], (2 * 8));
1007 : sb[3] = rol(decT[(byte)(sa[0] >> (3 * 8))], (3 * 8));
1008 : sa[0] = rk[r][0] ^ sb[0];
1009 :
1010 : sb[1] ^= rol(decT[(byte)(sa[1] >> (0 * 8))], (0 * 8));
1011 : sb[2] ^= rol(decT[(byte)(sa[1] >> (1 * 8))], (1 * 8));
1012 : sb[3] ^= rol(decT[(byte)(sa[1] >> (2 * 8))], (2 * 8));
1013 : sa[0] ^= rol(decT[(byte)(sa[1] >> (3 * 8))], (3 * 8));
1014 : sa[1] = rk[r][1] ^ sb[1];
1015 :
1016 : sb[2] ^= rol(decT[(byte)(sa[2] >> (0 * 8))], (0 * 8));
1017 : sb[3] ^= rol(decT[(byte)(sa[2] >> (1 * 8))], (1 * 8));
1018 : sa[0] ^= rol(decT[(byte)(sa[2] >> (2 * 8))], (2 * 8));
1019 : sa[1] ^= rol(decT[(byte)(sa[2] >> (3 * 8))], (3 * 8));
1020 : sa[2] = rk[r][2] ^ sb[2];
1021 :
1022 : sb[3] ^= rol(decT[(byte)(sa[3] >> (0 * 8))], (0 * 8));
1023 : sa[0] ^= rol(decT[(byte)(sa[3] >> (1 * 8))], (1 * 8));
1024 : sa[1] ^= rol(decT[(byte)(sa[3] >> (2 * 8))], (2 * 8));
1025 : sa[2] ^= rol(decT[(byte)(sa[3] >> (3 * 8))], (3 * 8));
1026 : sa[3] = rk[r][3] ^ sb[3];
1027 :
1028 : r--;
1029 :
1030 : sb[0] = rol(decT[(byte)(sa[0] >> (0 * 8))], (0 * 8));
1031 : sb[1] = rol(decT[(byte)(sa[0] >> (1 * 8))], (1 * 8));
1032 : sb[2] = rol(decT[(byte)(sa[0] >> (2 * 8))], (2 * 8));
1033 : sb[3] = rol(decT[(byte)(sa[0] >> (3 * 8))], (3 * 8));
1034 : sa[0] = rk[r][0] ^ sb[0];
1035 :
1036 : sb[1] ^= rol(decT[(byte)(sa[1] >> (0 * 8))], (0 * 8));
1037 : sb[2] ^= rol(decT[(byte)(sa[1] >> (1 * 8))], (1 * 8));
1038 : sb[3] ^= rol(decT[(byte)(sa[1] >> (2 * 8))], (2 * 8));
1039 : sa[0] ^= rol(decT[(byte)(sa[1] >> (3 * 8))], (3 * 8));
1040 : sa[1] = rk[r][1] ^ sb[1];
1041 :
1042 : sb[2] ^= rol(decT[(byte)(sa[2] >> (0 * 8))], (0 * 8));
1043 : sb[3] ^= rol(decT[(byte)(sa[2] >> (1 * 8))], (1 * 8));
1044 : sa[0] ^= rol(decT[(byte)(sa[2] >> (2 * 8))], (2 * 8));
1045 : sa[1] ^= rol(decT[(byte)(sa[2] >> (3 * 8))], (3 * 8));
1046 : sa[2] = rk[r][2] ^ sb[2];
1047 :
1048 : sb[3] ^= rol(decT[(byte)(sa[3] >> (0 * 8))], (0 * 8));
1049 : sa[0] ^= rol(decT[(byte)(sa[3] >> (1 * 8))], (1 * 8));
1050 : sa[1] ^= rol(decT[(byte)(sa[3] >> (2 * 8))], (2 * 8));
1051 : sa[2] ^= rol(decT[(byte)(sa[3] >> (3 * 8))], (3 * 8));
1052 : sa[3] = rk[r][3] ^ sb[3];
1053 : }
1054 :
1055 : sb[0] = rol(decT[(byte)(sa[0] >> (0 * 8))], (0 * 8));
1056 : sb[1] = rol(decT[(byte)(sa[0] >> (1 * 8))], (1 * 8));
1057 : sb[2] = rol(decT[(byte)(sa[0] >> (2 * 8))], (2 * 8));
1058 : sb[3] = rol(decT[(byte)(sa[0] >> (3 * 8))], (3 * 8));
1059 : sa[0] = rk[1][0] ^ sb[0];
1060 :
1061 : sb[1] ^= rol(decT[(byte)(sa[1] >> (0 * 8))], (0 * 8));
1062 : sb[2] ^= rol(decT[(byte)(sa[1] >> (1 * 8))], (1 * 8));
1063 : sb[3] ^= rol(decT[(byte)(sa[1] >> (2 * 8))], (2 * 8));
1064 : sa[0] ^= rol(decT[(byte)(sa[1] >> (3 * 8))], (3 * 8));
1065 : sa[1] = rk[1][1] ^ sb[1];
1066 :
1067 : sb[2] ^= rol(decT[(byte)(sa[2] >> (0 * 8))], (0 * 8));
1068 : sb[3] ^= rol(decT[(byte)(sa[2] >> (1 * 8))], (1 * 8));
1069 : sa[0] ^= rol(decT[(byte)(sa[2] >> (2 * 8))], (2 * 8));
1070 : sa[1] ^= rol(decT[(byte)(sa[2] >> (3 * 8))], (3 * 8));
1071 : sa[2] = rk[1][2] ^ sb[2];
1072 :
1073 : sb[3] ^= rol(decT[(byte)(sa[3] >> (0 * 8))], (0 * 8));
1074 : sa[0] ^= rol(decT[(byte)(sa[3] >> (1 * 8))], (1 * 8));
1075 : sa[1] ^= rol(decT[(byte)(sa[3] >> (2 * 8))], (2 * 8));
1076 : sa[2] ^= rol(decT[(byte)(sa[3] >> (3 * 8))], (3 * 8));
1077 : sa[3] = rk[1][3] ^ sb[3];
1078 :
1079 : /* Last round is special. */
1080 : sb[0] = inv_sbox[(byte)(sa[0] >> (0 * 8))] << (0 * 8);
1081 : sb[1] = inv_sbox[(byte)(sa[0] >> (1 * 8))] << (1 * 8);
1082 : sb[2] = inv_sbox[(byte)(sa[0] >> (2 * 8))] << (2 * 8);
1083 : sb[3] = inv_sbox[(byte)(sa[0] >> (3 * 8))] << (3 * 8);
1084 : sa[0] = sb[0] ^ rk[0][0];
1085 :
1086 : sb[1] ^= inv_sbox[(byte)(sa[1] >> (0 * 8))] << (0 * 8);
1087 : sb[2] ^= inv_sbox[(byte)(sa[1] >> (1 * 8))] << (1 * 8);
1088 : sb[3] ^= inv_sbox[(byte)(sa[1] >> (2 * 8))] << (2 * 8);
1089 : sa[0] ^= inv_sbox[(byte)(sa[1] >> (3 * 8))] << (3 * 8);
1090 : sa[1] = sb[1] ^ rk[0][1];
1091 :
1092 : sb[2] ^= inv_sbox[(byte)(sa[2] >> (0 * 8))] << (0 * 8);
1093 : sb[3] ^= inv_sbox[(byte)(sa[2] >> (1 * 8))] << (1 * 8);
1094 : sa[0] ^= inv_sbox[(byte)(sa[2] >> (2 * 8))] << (2 * 8);
1095 : sa[1] ^= inv_sbox[(byte)(sa[2] >> (3 * 8))] << (3 * 8);
1096 : sa[2] = sb[2] ^ rk[0][2];
1097 :
1098 : sb[3] ^= inv_sbox[(byte)(sa[3] >> (0 * 8))] << (0 * 8);
1099 : sa[0] ^= inv_sbox[(byte)(sa[3] >> (1 * 8))] << (1 * 8);
1100 : sa[1] ^= inv_sbox[(byte)(sa[3] >> (2 * 8))] << (2 * 8);
1101 : sa[2] ^= inv_sbox[(byte)(sa[3] >> (3 * 8))] << (3 * 8);
1102 : sa[3] = sb[3] ^ rk[0][3];
1103 :
1104 : buf_put_le32(b + 0, sa[0]);
1105 : buf_put_le32(b + 4, sa[1]);
1106 : buf_put_le32(b + 8, sa[2]);
1107 : buf_put_le32(b + 12, sa[3]);
1108 : #undef rk
1109 :
1110 : return (56+2*sizeof(int));
1111 : }
1112 : #endif /*!USE_ARM_ASM && !USE_AMD64_ASM*/
1113 :
1114 :
1115 : /* Decrypt one block. AX and BX may be the same. */
1116 : static unsigned int
1117 1636335 : do_decrypt (const RIJNDAEL_context *ctx, unsigned char *bx,
1118 : const unsigned char *ax)
1119 : {
1120 : #ifdef USE_AMD64_ASM
1121 : # ifdef HAVE_COMPATIBLE_GCC_AMD64_PLATFORM_AS
1122 1636335 : return _gcry_aes_amd64_decrypt_block(ctx->keyschdec, bx, ax, ctx->rounds,
1123 : &dec_tables);
1124 : # else
1125 : /* Call SystemV ABI function without storing non-volatile XMM registers,
1126 : * as target function does not use vector instruction sets. */
1127 : const void *key = ctx->keyschdec;
1128 : uintptr_t rounds = ctx->rounds;
1129 : uintptr_t ret;
1130 : asm volatile ("movq %[dectabs], %%r8\n\t"
1131 : "callq *%[ret]\n\t"
1132 : : [ret] "=a" (ret),
1133 : "+D" (key),
1134 : "+S" (bx),
1135 : "+d" (ax),
1136 : "+c" (rounds)
1137 : : "0" (_gcry_aes_amd64_decrypt_block),
1138 : [dectabs] "g" (&dec_tables)
1139 : : "cc", "memory", "r8", "r9", "r10", "r11");
1140 : return ret;
1141 : # endif /* HAVE_COMPATIBLE_GCC_AMD64_PLATFORM_AS */
1142 : #elif defined(USE_ARM_ASM)
1143 : return _gcry_aes_arm_decrypt_block(ctx->keyschdec, bx, ax, ctx->rounds,
1144 : &dec_tables);
1145 : #else
1146 : return do_decrypt_fn (ctx, bx, ax);
1147 : #endif /*!USE_ARM_ASM && !USE_AMD64_ASM*/
1148 : }
1149 :
1150 :
1151 : static inline void
1152 1975961 : check_decryption_preparation (RIJNDAEL_context *ctx)
1153 : {
1154 1975961 : if ( !ctx->decryption_prepared )
1155 : {
1156 2116 : prepare_decryption ( ctx );
1157 2116 : ctx->decryption_prepared = 1;
1158 : }
1159 1975961 : }
1160 :
1161 :
1162 : static unsigned int
1163 1946141 : rijndael_decrypt (void *context, byte *b, const byte *a)
1164 : {
1165 1946141 : RIJNDAEL_context *ctx = context;
1166 :
1167 1946141 : check_decryption_preparation (ctx);
1168 :
1169 1946141 : if (ctx->prefetch_dec_fn)
1170 26072 : ctx->prefetch_dec_fn();
1171 :
1172 1946141 : return ctx->decrypt_fn (ctx, b, a);
1173 : }
1174 :
1175 :
1176 : /* Bulk decryption of complete blocks in CFB mode. Caller needs to
1177 : make sure that IV is aligned on an unsigned long boundary. This
1178 : function is only intended for the bulk encryption feature of
1179 : cipher.c. */
1180 : void
1181 12936 : _gcry_aes_cfb_dec (void *context, unsigned char *iv,
1182 : void *outbuf_arg, const void *inbuf_arg,
1183 : size_t nblocks)
1184 : {
1185 12936 : RIJNDAEL_context *ctx = context;
1186 12936 : unsigned char *outbuf = outbuf_arg;
1187 12936 : const unsigned char *inbuf = inbuf_arg;
1188 12936 : unsigned int burn_depth = 0;
1189 :
1190 12936 : if (ctx->prefetch_enc_fn)
1191 677 : ctx->prefetch_enc_fn();
1192 :
1193 : if (0)
1194 : ;
1195 : #ifdef USE_AESNI
1196 12936 : else if (ctx->use_aesni)
1197 : {
1198 12259 : _gcry_aes_aesni_cfb_dec (ctx, outbuf, inbuf, iv, nblocks);
1199 12259 : burn_depth = 0;
1200 : }
1201 : #endif /*USE_AESNI*/
1202 : #ifdef USE_SSSE3
1203 677 : else if (ctx->use_ssse3)
1204 : {
1205 0 : _gcry_aes_ssse3_cfb_dec (ctx, outbuf, inbuf, iv, nblocks);
1206 0 : burn_depth = 0;
1207 : }
1208 : #endif /*USE_SSSE3*/
1209 : #ifdef USE_ARM_CE
1210 : else if (ctx->use_arm_ce)
1211 : {
1212 : _gcry_aes_armv8_ce_cfb_dec (ctx, outbuf, inbuf, iv, nblocks);
1213 : burn_depth = 0;
1214 : }
1215 : #endif /*USE_ARM_CE*/
1216 : else
1217 : {
1218 677 : rijndael_cryptfn_t encrypt_fn = ctx->encrypt_fn;
1219 :
1220 13372 : for ( ;nblocks; nblocks-- )
1221 : {
1222 12695 : burn_depth = encrypt_fn (ctx, iv, iv);
1223 12695 : buf_xor_n_copy(outbuf, iv, inbuf, BLOCKSIZE);
1224 12695 : outbuf += BLOCKSIZE;
1225 12695 : inbuf += BLOCKSIZE;
1226 : }
1227 : }
1228 :
1229 12936 : if (burn_depth)
1230 677 : _gcry_burn_stack (burn_depth + 4 * sizeof(void *));
1231 12936 : }
1232 :
1233 :
1234 : /* Bulk decryption of complete blocks in CBC mode. Caller needs to
1235 : make sure that IV is aligned on an unsigned long boundary. This
1236 : function is only intended for the bulk encryption feature of
1237 : cipher.c. */
1238 : void
1239 22402 : _gcry_aes_cbc_dec (void *context, unsigned char *iv,
1240 : void *outbuf_arg, const void *inbuf_arg,
1241 : size_t nblocks)
1242 : {
1243 22402 : RIJNDAEL_context *ctx = context;
1244 22402 : unsigned char *outbuf = outbuf_arg;
1245 22402 : const unsigned char *inbuf = inbuf_arg;
1246 22402 : unsigned int burn_depth = 0;
1247 :
1248 22402 : check_decryption_preparation (ctx);
1249 :
1250 22402 : if (ctx->prefetch_dec_fn)
1251 971 : ctx->prefetch_dec_fn();
1252 :
1253 : if (0)
1254 : ;
1255 : #ifdef USE_AESNI
1256 22402 : else if (ctx->use_aesni)
1257 : {
1258 21431 : _gcry_aes_aesni_cbc_dec (ctx, outbuf, inbuf, iv, nblocks);
1259 21431 : burn_depth = 0;
1260 : }
1261 : #endif /*USE_AESNI*/
1262 : #ifdef USE_SSSE3
1263 971 : else if (ctx->use_ssse3)
1264 : {
1265 0 : _gcry_aes_ssse3_cbc_dec (ctx, outbuf, inbuf, iv, nblocks);
1266 0 : burn_depth = 0;
1267 : }
1268 : #endif /*USE_SSSE3*/
1269 : #ifdef USE_ARM_CE
1270 : else if (ctx->use_arm_ce)
1271 : {
1272 : _gcry_aes_armv8_ce_cbc_dec (ctx, outbuf, inbuf, iv, nblocks);
1273 : burn_depth = 0;
1274 : }
1275 : #endif /*USE_ARM_CE*/
1276 : else
1277 : {
1278 : unsigned char savebuf[BLOCKSIZE] ATTR_ALIGNED_16;
1279 971 : rijndael_cryptfn_t decrypt_fn = ctx->decrypt_fn;
1280 :
1281 25862 : for ( ;nblocks; nblocks-- )
1282 : {
1283 : /* INBUF is needed later and it may be identical to OUTBUF, so store
1284 : the intermediate result to SAVEBUF. */
1285 :
1286 24891 : burn_depth = decrypt_fn (ctx, savebuf, inbuf);
1287 :
1288 24891 : buf_xor_n_copy_2(outbuf, savebuf, iv, inbuf, BLOCKSIZE);
1289 24891 : inbuf += BLOCKSIZE;
1290 24891 : outbuf += BLOCKSIZE;
1291 : }
1292 :
1293 971 : wipememory(savebuf, sizeof(savebuf));
1294 : }
1295 :
1296 22402 : if (burn_depth)
1297 968 : _gcry_burn_stack (burn_depth + 4 * sizeof(void *));
1298 22402 : }
1299 :
1300 :
1301 :
1302 : /* Bulk encryption/decryption of complete blocks in OCB mode. */
1303 : size_t
1304 16344 : _gcry_aes_ocb_crypt (gcry_cipher_hd_t c, void *outbuf_arg,
1305 : const void *inbuf_arg, size_t nblocks, int encrypt)
1306 : {
1307 16344 : RIJNDAEL_context *ctx = (void *)&c->context.c;
1308 16344 : unsigned char *outbuf = outbuf_arg;
1309 16344 : const unsigned char *inbuf = inbuf_arg;
1310 16344 : unsigned int burn_depth = 0;
1311 :
1312 16344 : if (encrypt)
1313 : {
1314 8926 : if (ctx->prefetch_enc_fn)
1315 848 : ctx->prefetch_enc_fn();
1316 : }
1317 : else
1318 : {
1319 7418 : check_decryption_preparation (ctx);
1320 :
1321 7418 : if (ctx->prefetch_dec_fn)
1322 832 : ctx->prefetch_dec_fn();
1323 : }
1324 :
1325 : if (0)
1326 : ;
1327 : #ifdef USE_AESNI
1328 16344 : else if (ctx->use_aesni)
1329 : {
1330 14664 : _gcry_aes_aesni_ocb_crypt (c, outbuf, inbuf, nblocks, encrypt);
1331 14664 : burn_depth = 0;
1332 : }
1333 : #endif /*USE_AESNI*/
1334 : #ifdef USE_SSSE3
1335 1680 : else if (ctx->use_ssse3)
1336 : {
1337 0 : _gcry_aes_ssse3_ocb_crypt (c, outbuf, inbuf, nblocks, encrypt);
1338 0 : burn_depth = 0;
1339 : }
1340 : #endif /*USE_SSSE3*/
1341 : #ifdef USE_ARM_CE
1342 : else if (ctx->use_arm_ce)
1343 : {
1344 : _gcry_aes_armv8_ce_ocb_crypt (c, outbuf, inbuf, nblocks, encrypt);
1345 : burn_depth = 0;
1346 : }
1347 : #endif /*USE_ARM_CE*/
1348 1680 : else if (encrypt)
1349 : {
1350 : union { unsigned char x1[16] ATTR_ALIGNED_16; u32 x32[4]; } l_tmp;
1351 848 : rijndael_cryptfn_t encrypt_fn = ctx->encrypt_fn;
1352 :
1353 1586252 : for ( ;nblocks; nblocks-- )
1354 : {
1355 1585404 : u64 i = ++c->u_mode.ocb.data_nblocks;
1356 1585404 : const unsigned char *l = ocb_get_l(c, i);
1357 :
1358 : /* Offset_i = Offset_{i-1} xor L_{ntz(i)} */
1359 1585404 : buf_xor_1 (c->u_iv.iv, l, BLOCKSIZE);
1360 1585404 : buf_cpy (l_tmp.x1, inbuf, BLOCKSIZE);
1361 : /* Checksum_i = Checksum_{i-1} xor P_i */
1362 1585404 : buf_xor_1 (c->u_ctr.ctr, l_tmp.x1, BLOCKSIZE);
1363 : /* C_i = Offset_i xor ENCIPHER(K, P_i xor Offset_i) */
1364 1585404 : buf_xor_1 (l_tmp.x1, c->u_iv.iv, BLOCKSIZE);
1365 1585404 : burn_depth = encrypt_fn (ctx, l_tmp.x1, l_tmp.x1);
1366 1585404 : buf_xor_1 (l_tmp.x1, c->u_iv.iv, BLOCKSIZE);
1367 1585404 : buf_cpy (outbuf, l_tmp.x1, BLOCKSIZE);
1368 :
1369 1585404 : inbuf += BLOCKSIZE;
1370 1585404 : outbuf += BLOCKSIZE;
1371 : }
1372 : }
1373 : else
1374 : {
1375 : union { unsigned char x1[16] ATTR_ALIGNED_16; u32 x32[4]; } l_tmp;
1376 832 : rijndael_cryptfn_t decrypt_fn = ctx->decrypt_fn;
1377 :
1378 1586204 : for ( ;nblocks; nblocks-- )
1379 : {
1380 1585372 : u64 i = ++c->u_mode.ocb.data_nblocks;
1381 1585372 : const unsigned char *l = ocb_get_l(c, i);
1382 :
1383 : /* Offset_i = Offset_{i-1} xor L_{ntz(i)} */
1384 1585372 : buf_xor_1 (c->u_iv.iv, l, BLOCKSIZE);
1385 1585372 : buf_cpy (l_tmp.x1, inbuf, BLOCKSIZE);
1386 : /* C_i = Offset_i xor ENCIPHER(K, P_i xor Offset_i) */
1387 1585372 : buf_xor_1 (l_tmp.x1, c->u_iv.iv, BLOCKSIZE);
1388 1585372 : burn_depth = decrypt_fn (ctx, l_tmp.x1, l_tmp.x1);
1389 1585372 : buf_xor_1 (l_tmp.x1, c->u_iv.iv, BLOCKSIZE);
1390 : /* Checksum_i = Checksum_{i-1} xor P_i */
1391 1585372 : buf_xor_1 (c->u_ctr.ctr, l_tmp.x1, BLOCKSIZE);
1392 1585372 : buf_cpy (outbuf, l_tmp.x1, BLOCKSIZE);
1393 :
1394 1585372 : inbuf += BLOCKSIZE;
1395 1585372 : outbuf += BLOCKSIZE;
1396 : }
1397 : }
1398 :
1399 16344 : if (burn_depth)
1400 1680 : _gcry_burn_stack (burn_depth + 4 * sizeof(void *));
1401 :
1402 16344 : return 0;
1403 : }
1404 :
1405 :
1406 : /* Bulk authentication of complete blocks in OCB mode. */
1407 : size_t
1408 2886 : _gcry_aes_ocb_auth (gcry_cipher_hd_t c, const void *abuf_arg, size_t nblocks)
1409 : {
1410 2886 : RIJNDAEL_context *ctx = (void *)&c->context.c;
1411 2886 : const unsigned char *abuf = abuf_arg;
1412 2886 : unsigned int burn_depth = 0;
1413 :
1414 2886 : if (ctx->prefetch_enc_fn)
1415 138 : ctx->prefetch_enc_fn();
1416 :
1417 : if (0)
1418 : ;
1419 : #ifdef USE_AESNI
1420 2886 : else if (ctx->use_aesni)
1421 : {
1422 2748 : _gcry_aes_aesni_ocb_auth (c, abuf, nblocks);
1423 2748 : burn_depth = 0;
1424 : }
1425 : #endif /*USE_AESNI*/
1426 : #ifdef USE_SSSE3
1427 138 : else if (ctx->use_ssse3)
1428 : {
1429 0 : _gcry_aes_ssse3_ocb_auth (c, abuf, nblocks);
1430 0 : burn_depth = 0;
1431 : }
1432 : #endif /*USE_SSSE3*/
1433 : #ifdef USE_ARM_CE
1434 : else if (ctx->use_arm_ce)
1435 : {
1436 : _gcry_aes_armv8_ce_ocb_auth (c, abuf, nblocks);
1437 : burn_depth = 0;
1438 : }
1439 : #endif /*USE_ARM_CE*/
1440 : else
1441 : {
1442 : union { unsigned char x1[16] ATTR_ALIGNED_16; u32 x32[4]; } l_tmp;
1443 138 : rijndael_cryptfn_t encrypt_fn = ctx->encrypt_fn;
1444 :
1445 3145943 : for ( ;nblocks; nblocks-- )
1446 : {
1447 3145805 : u64 i = ++c->u_mode.ocb.aad_nblocks;
1448 3145805 : const unsigned char *l = ocb_get_l(c, i);
1449 :
1450 : /* Offset_i = Offset_{i-1} xor L_{ntz(i)} */
1451 3145805 : buf_xor_1 (c->u_mode.ocb.aad_offset, l, BLOCKSIZE);
1452 : /* Sum_i = Sum_{i-1} xor ENCIPHER(K, A_i xor Offset_i) */
1453 3145805 : buf_xor (l_tmp.x1, c->u_mode.ocb.aad_offset, abuf, BLOCKSIZE);
1454 3145805 : burn_depth = encrypt_fn (ctx, l_tmp.x1, l_tmp.x1);
1455 3145805 : buf_xor_1 (c->u_mode.ocb.aad_sum, l_tmp.x1, BLOCKSIZE);
1456 :
1457 3145805 : abuf += BLOCKSIZE;
1458 : }
1459 :
1460 138 : wipememory(&l_tmp, sizeof(l_tmp));
1461 : }
1462 :
1463 2886 : if (burn_depth)
1464 138 : _gcry_burn_stack (burn_depth + 4 * sizeof(void *));
1465 :
1466 2886 : return 0;
1467 : }
1468 :
1469 :
1470 :
1471 : /* Run the self-tests for AES 128. Returns NULL on success. */
1472 : static const char*
1473 7 : selftest_basic_128 (void)
1474 : {
1475 : RIJNDAEL_context *ctx;
1476 : unsigned char *ctxmem;
1477 : unsigned char scratch[16];
1478 :
1479 : /* The test vectors are from the AES supplied ones; more or less
1480 : randomly taken from ecb_tbl.txt (I=42,81,14) */
1481 : #if 1
1482 : static const unsigned char plaintext_128[16] =
1483 : {
1484 : 0x01,0x4B,0xAF,0x22,0x78,0xA6,0x9D,0x33,
1485 : 0x1D,0x51,0x80,0x10,0x36,0x43,0xE9,0x9A
1486 : };
1487 : static const unsigned char key_128[16] =
1488 : {
1489 : 0xE8,0xE9,0xEA,0xEB,0xED,0xEE,0xEF,0xF0,
1490 : 0xF2,0xF3,0xF4,0xF5,0xF7,0xF8,0xF9,0xFA
1491 : };
1492 : static const unsigned char ciphertext_128[16] =
1493 : {
1494 : 0x67,0x43,0xC3,0xD1,0x51,0x9A,0xB4,0xF2,
1495 : 0xCD,0x9A,0x78,0xAB,0x09,0xA5,0x11,0xBD
1496 : };
1497 : #else
1498 : /* Test vectors from fips-197, appendix C. */
1499 : # warning debug test vectors in use
1500 : static const unsigned char plaintext_128[16] =
1501 : {
1502 : 0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,
1503 : 0x88,0x99,0xaa,0xbb,0xcc,0xdd,0xee,0xff
1504 : };
1505 : static const unsigned char key_128[16] =
1506 : {
1507 : 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
1508 : 0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f
1509 : /* 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, */
1510 : /* 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c */
1511 : };
1512 : static const unsigned char ciphertext_128[16] =
1513 : {
1514 : 0x69,0xc4,0xe0,0xd8,0x6a,0x7b,0x04,0x30,
1515 : 0xd8,0xcd,0xb7,0x80,0x70,0xb4,0xc5,0x5a
1516 : };
1517 : #endif
1518 :
1519 : /* Because gcc/ld can only align the CTX struct on 8 bytes on the
1520 : stack, we need to allocate that context on the heap. */
1521 7 : ctx = _gcry_cipher_selftest_alloc_ctx (sizeof *ctx, &ctxmem);
1522 7 : if (!ctx)
1523 0 : return "failed to allocate memory";
1524 :
1525 7 : rijndael_setkey (ctx, key_128, sizeof (key_128));
1526 7 : rijndael_encrypt (ctx, scratch, plaintext_128);
1527 7 : if (memcmp (scratch, ciphertext_128, sizeof (ciphertext_128)))
1528 : {
1529 0 : xfree (ctxmem);
1530 0 : return "AES-128 test encryption failed.";
1531 : }
1532 7 : rijndael_decrypt (ctx, scratch, scratch);
1533 7 : xfree (ctxmem);
1534 7 : if (memcmp (scratch, plaintext_128, sizeof (plaintext_128)))
1535 0 : return "AES-128 test decryption failed.";
1536 :
1537 7 : return NULL;
1538 : }
1539 :
1540 : /* Run the self-tests for AES 192. Returns NULL on success. */
1541 : static const char*
1542 7 : selftest_basic_192 (void)
1543 : {
1544 : RIJNDAEL_context *ctx;
1545 : unsigned char *ctxmem;
1546 : unsigned char scratch[16];
1547 :
1548 : static unsigned char plaintext_192[16] =
1549 : {
1550 : 0x76,0x77,0x74,0x75,0xF1,0xF2,0xF3,0xF4,
1551 : 0xF8,0xF9,0xE6,0xE7,0x77,0x70,0x71,0x72
1552 : };
1553 : static unsigned char key_192[24] =
1554 : {
1555 : 0x04,0x05,0x06,0x07,0x09,0x0A,0x0B,0x0C,
1556 : 0x0E,0x0F,0x10,0x11,0x13,0x14,0x15,0x16,
1557 : 0x18,0x19,0x1A,0x1B,0x1D,0x1E,0x1F,0x20
1558 : };
1559 : static const unsigned char ciphertext_192[16] =
1560 : {
1561 : 0x5D,0x1E,0xF2,0x0D,0xCE,0xD6,0xBC,0xBC,
1562 : 0x12,0x13,0x1A,0xC7,0xC5,0x47,0x88,0xAA
1563 : };
1564 :
1565 7 : ctx = _gcry_cipher_selftest_alloc_ctx (sizeof *ctx, &ctxmem);
1566 7 : if (!ctx)
1567 0 : return "failed to allocate memory";
1568 7 : rijndael_setkey (ctx, key_192, sizeof(key_192));
1569 7 : rijndael_encrypt (ctx, scratch, plaintext_192);
1570 7 : if (memcmp (scratch, ciphertext_192, sizeof (ciphertext_192)))
1571 : {
1572 0 : xfree (ctxmem);
1573 0 : return "AES-192 test encryption failed.";
1574 : }
1575 7 : rijndael_decrypt (ctx, scratch, scratch);
1576 7 : xfree (ctxmem);
1577 7 : if (memcmp (scratch, plaintext_192, sizeof (plaintext_192)))
1578 0 : return "AES-192 test decryption failed.";
1579 :
1580 7 : return NULL;
1581 : }
1582 :
1583 :
1584 : /* Run the self-tests for AES 256. Returns NULL on success. */
1585 : static const char*
1586 7 : selftest_basic_256 (void)
1587 : {
1588 : RIJNDAEL_context *ctx;
1589 : unsigned char *ctxmem;
1590 : unsigned char scratch[16];
1591 :
1592 : static unsigned char plaintext_256[16] =
1593 : {
1594 : 0x06,0x9A,0x00,0x7F,0xC7,0x6A,0x45,0x9F,
1595 : 0x98,0xBA,0xF9,0x17,0xFE,0xDF,0x95,0x21
1596 : };
1597 : static unsigned char key_256[32] =
1598 : {
1599 : 0x08,0x09,0x0A,0x0B,0x0D,0x0E,0x0F,0x10,
1600 : 0x12,0x13,0x14,0x15,0x17,0x18,0x19,0x1A,
1601 : 0x1C,0x1D,0x1E,0x1F,0x21,0x22,0x23,0x24,
1602 : 0x26,0x27,0x28,0x29,0x2B,0x2C,0x2D,0x2E
1603 : };
1604 : static const unsigned char ciphertext_256[16] =
1605 : {
1606 : 0x08,0x0E,0x95,0x17,0xEB,0x16,0x77,0x71,
1607 : 0x9A,0xCF,0x72,0x80,0x86,0x04,0x0A,0xE3
1608 : };
1609 :
1610 7 : ctx = _gcry_cipher_selftest_alloc_ctx (sizeof *ctx, &ctxmem);
1611 7 : if (!ctx)
1612 0 : return "failed to allocate memory";
1613 7 : rijndael_setkey (ctx, key_256, sizeof(key_256));
1614 7 : rijndael_encrypt (ctx, scratch, plaintext_256);
1615 7 : if (memcmp (scratch, ciphertext_256, sizeof (ciphertext_256)))
1616 : {
1617 0 : xfree (ctxmem);
1618 0 : return "AES-256 test encryption failed.";
1619 : }
1620 7 : rijndael_decrypt (ctx, scratch, scratch);
1621 7 : xfree (ctxmem);
1622 7 : if (memcmp (scratch, plaintext_256, sizeof (plaintext_256)))
1623 0 : return "AES-256 test decryption failed.";
1624 :
1625 7 : return NULL;
1626 : }
1627 :
1628 :
1629 : /* Run the self-tests for AES-CTR-128, tests IV increment of bulk CTR
1630 : encryption. Returns NULL on success. */
1631 : static const char*
1632 5 : selftest_ctr_128 (void)
1633 : {
1634 5 : const int nblocks = 8+1;
1635 5 : const int blocksize = BLOCKSIZE;
1636 5 : const int context_size = sizeof(RIJNDAEL_context);
1637 :
1638 5 : return _gcry_selftest_helper_ctr("AES", &rijndael_setkey,
1639 : &rijndael_encrypt, &_gcry_aes_ctr_enc, nblocks, blocksize,
1640 : context_size);
1641 : }
1642 :
1643 :
1644 : /* Run the self-tests for AES-CBC-128, tests bulk CBC decryption.
1645 : Returns NULL on success. */
1646 : static const char*
1647 5 : selftest_cbc_128 (void)
1648 : {
1649 5 : const int nblocks = 8+2;
1650 5 : const int blocksize = BLOCKSIZE;
1651 5 : const int context_size = sizeof(RIJNDAEL_context);
1652 :
1653 5 : return _gcry_selftest_helper_cbc("AES", &rijndael_setkey,
1654 : &rijndael_encrypt, &_gcry_aes_cbc_dec, nblocks, blocksize,
1655 : context_size);
1656 : }
1657 :
1658 :
1659 : /* Run the self-tests for AES-CFB-128, tests bulk CFB decryption.
1660 : Returns NULL on success. */
1661 : static const char*
1662 5 : selftest_cfb_128 (void)
1663 : {
1664 5 : const int nblocks = 8+2;
1665 5 : const int blocksize = BLOCKSIZE;
1666 5 : const int context_size = sizeof(RIJNDAEL_context);
1667 :
1668 5 : return _gcry_selftest_helper_cfb("AES", &rijndael_setkey,
1669 : &rijndael_encrypt, &_gcry_aes_cfb_dec, nblocks, blocksize,
1670 : context_size);
1671 : }
1672 :
1673 :
1674 : /* Run all the self-tests and return NULL on success. This function
1675 : is used for the on-the-fly self-tests. */
1676 : static const char *
1677 5 : selftest (void)
1678 : {
1679 : const char *r;
1680 :
1681 5 : if ( (r = selftest_basic_128 ())
1682 5 : || (r = selftest_basic_192 ())
1683 5 : || (r = selftest_basic_256 ()) )
1684 0 : return r;
1685 :
1686 5 : if ( (r = selftest_ctr_128 ()) )
1687 0 : return r;
1688 :
1689 5 : if ( (r = selftest_cbc_128 ()) )
1690 0 : return r;
1691 :
1692 5 : if ( (r = selftest_cfb_128 ()) )
1693 0 : return r;
1694 :
1695 5 : return r;
1696 : }
1697 :
1698 :
1699 : /* SP800-38a.pdf for AES-128. */
1700 : static const char *
1701 4 : selftest_fips_128_38a (int requested_mode)
1702 : {
1703 : static const struct tv
1704 : {
1705 : int mode;
1706 : const unsigned char key[16];
1707 : const unsigned char iv[16];
1708 : struct
1709 : {
1710 : const unsigned char input[16];
1711 : const unsigned char output[16];
1712 : } data[4];
1713 : } tv[2] =
1714 : {
1715 : {
1716 : GCRY_CIPHER_MODE_CFB, /* F.3.13, CFB128-AES128 */
1717 : { 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
1718 : 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c },
1719 : { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1720 : 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1721 : {
1722 : { { 0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
1723 : 0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a },
1724 : { 0x3b, 0x3f, 0xd9, 0x2e, 0xb7, 0x2d, 0xad, 0x20,
1725 : 0x33, 0x34, 0x49, 0xf8, 0xe8, 0x3c, 0xfb, 0x4a } },
1726 :
1727 : { { 0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
1728 : 0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51 },
1729 : { 0xc8, 0xa6, 0x45, 0x37, 0xa0, 0xb3, 0xa9, 0x3f,
1730 : 0xcd, 0xe3, 0xcd, 0xad, 0x9f, 0x1c, 0xe5, 0x8b } },
1731 :
1732 : { { 0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
1733 : 0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef },
1734 : { 0x26, 0x75, 0x1f, 0x67, 0xa3, 0xcb, 0xb1, 0x40,
1735 : 0xb1, 0x80, 0x8c, 0xf1, 0x87, 0xa4, 0xf4, 0xdf } },
1736 :
1737 : { { 0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
1738 : 0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10 },
1739 : { 0xc0, 0x4b, 0x05, 0x35, 0x7c, 0x5d, 0x1c, 0x0e,
1740 : 0xea, 0xc4, 0xc6, 0x6f, 0x9f, 0xf7, 0xf2, 0xe6 } }
1741 : }
1742 : },
1743 : {
1744 : GCRY_CIPHER_MODE_OFB,
1745 : { 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
1746 : 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c },
1747 : { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1748 : 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
1749 : {
1750 : { { 0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
1751 : 0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a },
1752 : { 0x3b, 0x3f, 0xd9, 0x2e, 0xb7, 0x2d, 0xad, 0x20,
1753 : 0x33, 0x34, 0x49, 0xf8, 0xe8, 0x3c, 0xfb, 0x4a } },
1754 :
1755 : { { 0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
1756 : 0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51 },
1757 : { 0x77, 0x89, 0x50, 0x8d, 0x16, 0x91, 0x8f, 0x03,
1758 : 0xf5, 0x3c, 0x52, 0xda, 0xc5, 0x4e, 0xd8, 0x25 } },
1759 :
1760 : { { 0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
1761 : 0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef },
1762 : { 0x97, 0x40, 0x05, 0x1e, 0x9c, 0x5f, 0xec, 0xf6,
1763 : 0x43, 0x44, 0xf7, 0xa8, 0x22, 0x60, 0xed, 0xcc } },
1764 :
1765 : { { 0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
1766 : 0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10 },
1767 : { 0x30, 0x4c, 0x65, 0x28, 0xf6, 0x59, 0xc7, 0x78,
1768 : 0x66, 0xa5, 0x10, 0xd9, 0xc1, 0xd6, 0xae, 0x5e } },
1769 : }
1770 : }
1771 : };
1772 : unsigned char scratch[16];
1773 : gpg_error_t err;
1774 : int tvi, idx;
1775 4 : gcry_cipher_hd_t hdenc = NULL;
1776 4 : gcry_cipher_hd_t hddec = NULL;
1777 :
1778 : #define Fail(a) do { \
1779 : _gcry_cipher_close (hdenc); \
1780 : _gcry_cipher_close (hddec); \
1781 : return a; \
1782 : } while (0)
1783 :
1784 : gcry_assert (sizeof tv[0].data[0].input == sizeof scratch);
1785 : gcry_assert (sizeof tv[0].data[0].output == sizeof scratch);
1786 :
1787 6 : for (tvi=0; tvi < DIM (tv); tvi++)
1788 6 : if (tv[tvi].mode == requested_mode)
1789 4 : break;
1790 4 : if (tvi == DIM (tv))
1791 0 : Fail ("no test data for this mode");
1792 :
1793 4 : err = _gcry_cipher_open (&hdenc, GCRY_CIPHER_AES, tv[tvi].mode, 0);
1794 4 : if (err)
1795 0 : Fail ("open");
1796 4 : err = _gcry_cipher_open (&hddec, GCRY_CIPHER_AES, tv[tvi].mode, 0);
1797 4 : if (err)
1798 0 : Fail ("open");
1799 4 : err = _gcry_cipher_setkey (hdenc, tv[tvi].key, sizeof tv[tvi].key);
1800 4 : if (!err)
1801 4 : err = _gcry_cipher_setkey (hddec, tv[tvi].key, sizeof tv[tvi].key);
1802 4 : if (err)
1803 0 : Fail ("set key");
1804 4 : err = _gcry_cipher_setiv (hdenc, tv[tvi].iv, sizeof tv[tvi].iv);
1805 4 : if (!err)
1806 4 : err = _gcry_cipher_setiv (hddec, tv[tvi].iv, sizeof tv[tvi].iv);
1807 4 : if (err)
1808 0 : Fail ("set IV");
1809 20 : for (idx=0; idx < DIM (tv[tvi].data); idx++)
1810 : {
1811 16 : err = _gcry_cipher_encrypt (hdenc, scratch, sizeof scratch,
1812 16 : tv[tvi].data[idx].input,
1813 : sizeof tv[tvi].data[idx].input);
1814 16 : if (err)
1815 0 : Fail ("encrypt command");
1816 16 : if (memcmp (scratch, tv[tvi].data[idx].output, sizeof scratch))
1817 0 : Fail ("encrypt mismatch");
1818 16 : err = _gcry_cipher_decrypt (hddec, scratch, sizeof scratch,
1819 16 : tv[tvi].data[idx].output,
1820 : sizeof tv[tvi].data[idx].output);
1821 16 : if (err)
1822 0 : Fail ("decrypt command");
1823 16 : if (memcmp (scratch, tv[tvi].data[idx].input, sizeof scratch))
1824 0 : Fail ("decrypt mismatch");
1825 : }
1826 :
1827 : #undef Fail
1828 4 : _gcry_cipher_close (hdenc);
1829 4 : _gcry_cipher_close (hddec);
1830 4 : return NULL;
1831 : }
1832 :
1833 :
1834 : /* Complete selftest for AES-128 with all modes and driver code. */
1835 : static gpg_err_code_t
1836 2 : selftest_fips_128 (int extended, selftest_report_func_t report)
1837 : {
1838 : const char *what;
1839 : const char *errtxt;
1840 :
1841 2 : what = "low-level";
1842 2 : errtxt = selftest_basic_128 ();
1843 2 : if (errtxt)
1844 0 : goto failed;
1845 :
1846 2 : if (extended)
1847 : {
1848 2 : what = "cfb";
1849 2 : errtxt = selftest_fips_128_38a (GCRY_CIPHER_MODE_CFB);
1850 2 : if (errtxt)
1851 0 : goto failed;
1852 :
1853 2 : what = "ofb";
1854 2 : errtxt = selftest_fips_128_38a (GCRY_CIPHER_MODE_OFB);
1855 2 : if (errtxt)
1856 0 : goto failed;
1857 : }
1858 :
1859 2 : return 0; /* Succeeded. */
1860 :
1861 : failed:
1862 0 : if (report)
1863 0 : report ("cipher", GCRY_CIPHER_AES128, what, errtxt);
1864 0 : return GPG_ERR_SELFTEST_FAILED;
1865 : }
1866 :
1867 : /* Complete selftest for AES-192. */
1868 : static gpg_err_code_t
1869 2 : selftest_fips_192 (int extended, selftest_report_func_t report)
1870 : {
1871 : const char *what;
1872 : const char *errtxt;
1873 :
1874 : (void)extended; /* No extended tests available. */
1875 :
1876 2 : what = "low-level";
1877 2 : errtxt = selftest_basic_192 ();
1878 2 : if (errtxt)
1879 0 : goto failed;
1880 :
1881 :
1882 2 : return 0; /* Succeeded. */
1883 :
1884 : failed:
1885 0 : if (report)
1886 0 : report ("cipher", GCRY_CIPHER_AES192, what, errtxt);
1887 0 : return GPG_ERR_SELFTEST_FAILED;
1888 : }
1889 :
1890 :
1891 : /* Complete selftest for AES-256. */
1892 : static gpg_err_code_t
1893 2 : selftest_fips_256 (int extended, selftest_report_func_t report)
1894 : {
1895 : const char *what;
1896 : const char *errtxt;
1897 :
1898 : (void)extended; /* No extended tests available. */
1899 :
1900 2 : what = "low-level";
1901 2 : errtxt = selftest_basic_256 ();
1902 2 : if (errtxt)
1903 0 : goto failed;
1904 :
1905 2 : return 0; /* Succeeded. */
1906 :
1907 : failed:
1908 0 : if (report)
1909 0 : report ("cipher", GCRY_CIPHER_AES256, what, errtxt);
1910 0 : return GPG_ERR_SELFTEST_FAILED;
1911 : }
1912 :
1913 :
1914 :
1915 : /* Run a full self-test for ALGO and return 0 on success. */
1916 : static gpg_err_code_t
1917 6 : run_selftests (int algo, int extended, selftest_report_func_t report)
1918 : {
1919 : gpg_err_code_t ec;
1920 :
1921 6 : switch (algo)
1922 : {
1923 : case GCRY_CIPHER_AES128:
1924 2 : ec = selftest_fips_128 (extended, report);
1925 2 : break;
1926 : case GCRY_CIPHER_AES192:
1927 2 : ec = selftest_fips_192 (extended, report);
1928 2 : break;
1929 : case GCRY_CIPHER_AES256:
1930 2 : ec = selftest_fips_256 (extended, report);
1931 2 : break;
1932 : default:
1933 0 : ec = GPG_ERR_CIPHER_ALGO;
1934 0 : break;
1935 :
1936 : }
1937 6 : return ec;
1938 : }
1939 :
1940 :
1941 :
1942 :
1943 : static const char *rijndael_names[] =
1944 : {
1945 : "RIJNDAEL",
1946 : "AES128",
1947 : "AES-128",
1948 : NULL
1949 : };
1950 :
1951 : static gcry_cipher_oid_spec_t rijndael_oids[] =
1952 : {
1953 : { "2.16.840.1.101.3.4.1.1", GCRY_CIPHER_MODE_ECB },
1954 : { "2.16.840.1.101.3.4.1.2", GCRY_CIPHER_MODE_CBC },
1955 : { "2.16.840.1.101.3.4.1.3", GCRY_CIPHER_MODE_OFB },
1956 : { "2.16.840.1.101.3.4.1.4", GCRY_CIPHER_MODE_CFB },
1957 : { NULL }
1958 : };
1959 :
1960 : gcry_cipher_spec_t _gcry_cipher_spec_aes =
1961 : {
1962 : GCRY_CIPHER_AES, {0, 1},
1963 : "AES", rijndael_names, rijndael_oids, 16, 128,
1964 : sizeof (RIJNDAEL_context),
1965 : rijndael_setkey, rijndael_encrypt, rijndael_decrypt,
1966 : NULL, NULL,
1967 : run_selftests
1968 : };
1969 :
1970 :
1971 : static const char *rijndael192_names[] =
1972 : {
1973 : "RIJNDAEL192",
1974 : "AES-192",
1975 : NULL
1976 : };
1977 :
1978 : static gcry_cipher_oid_spec_t rijndael192_oids[] =
1979 : {
1980 : { "2.16.840.1.101.3.4.1.21", GCRY_CIPHER_MODE_ECB },
1981 : { "2.16.840.1.101.3.4.1.22", GCRY_CIPHER_MODE_CBC },
1982 : { "2.16.840.1.101.3.4.1.23", GCRY_CIPHER_MODE_OFB },
1983 : { "2.16.840.1.101.3.4.1.24", GCRY_CIPHER_MODE_CFB },
1984 : { NULL }
1985 : };
1986 :
1987 : gcry_cipher_spec_t _gcry_cipher_spec_aes192 =
1988 : {
1989 : GCRY_CIPHER_AES192, {0, 1},
1990 : "AES192", rijndael192_names, rijndael192_oids, 16, 192,
1991 : sizeof (RIJNDAEL_context),
1992 : rijndael_setkey, rijndael_encrypt, rijndael_decrypt,
1993 : NULL, NULL,
1994 : run_selftests
1995 : };
1996 :
1997 :
1998 : static const char *rijndael256_names[] =
1999 : {
2000 : "RIJNDAEL256",
2001 : "AES-256",
2002 : NULL
2003 : };
2004 :
2005 : static gcry_cipher_oid_spec_t rijndael256_oids[] =
2006 : {
2007 : { "2.16.840.1.101.3.4.1.41", GCRY_CIPHER_MODE_ECB },
2008 : { "2.16.840.1.101.3.4.1.42", GCRY_CIPHER_MODE_CBC },
2009 : { "2.16.840.1.101.3.4.1.43", GCRY_CIPHER_MODE_OFB },
2010 : { "2.16.840.1.101.3.4.1.44", GCRY_CIPHER_MODE_CFB },
2011 : { NULL }
2012 : };
2013 :
2014 : gcry_cipher_spec_t _gcry_cipher_spec_aes256 =
2015 : {
2016 : GCRY_CIPHER_AES256, {0, 1},
2017 : "AES256", rijndael256_names, rijndael256_oids, 16, 256,
2018 : sizeof (RIJNDAEL_context),
2019 : rijndael_setkey, rijndael_encrypt, rijndael_decrypt,
2020 : NULL, NULL,
2021 : run_selftests
2022 : };
|
