?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
scripts/package/Makefile: rpmbuild add support of RPMOPTS
[linux/fpc-iii.git] / crypto / testmgr.c
blob7d4acc4492338921dd1307c1cc4d4a252130b36a
1 /*
2 * Algorithm testing framework and tests.
3 *
4 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
5 * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
6 * Copyright (c) 2007 Nokia Siemens Networks
7 * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
8 *
9 * Updated RFC4106 AES-GCM testing.
10 * Authors: Aidan O'Mahony (aidan.o.mahony@intel.com)
11 * Adrian Hoban <adrian.hoban@intel.com>
12 * Gabriele Paoloni <gabriele.paoloni@intel.com>
13 * Tadeusz Struk (tadeusz.struk@intel.com)
14 * Copyright (c) 2010, Intel Corporation.
15 *
16 * This program is free software; you can redistribute it and/or modify it
17 * under the terms of the GNU General Public License as published by the Free
18 * Software Foundation; either version 2 of the License, or (at your option)
19 * any later version.
20 *
21 */
22
23 #include <crypto/aead.h>
24 #include <crypto/hash.h>
25 #include <crypto/skcipher.h>
26 #include <linux/err.h>
27 #include <linux/fips.h>
28 #include <linux/module.h>
29 #include <linux/scatterlist.h>
30 #include <linux/slab.h>
31 #include <linux/string.h>
32 #include <crypto/rng.h>
33 #include <crypto/drbg.h>
34 #include <crypto/akcipher.h>
35
36 #include "internal.h"
37
38 #ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
39
40 /* a perfect nop */
41 int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
42 {
43 return 0;
44 }
45
46 #else
47
48 #include "testmgr.h"
49
50 /*
51 * Need slab memory for testing (size in number of pages).
52 */
53 #define XBUFSIZE 8
54
55 /*
56 * Indexes into the xbuf to simulate cross-page access.
57 */
58 #define IDX1 32
59 #define IDX2 32400
60 #define IDX3 1
61 #define IDX4 8193
62 #define IDX5 22222
63 #define IDX6 17101
64 #define IDX7 27333
65 #define IDX8 3000
66
67 /*
68 * Used by test_cipher()
69 */
70 #define ENCRYPT 1
71 #define DECRYPT 0
72
73 struct tcrypt_result {
74 struct completion completion;
75 int err;
76 };
77
78 struct aead_test_suite {
79 struct {
80 struct aead_testvec *vecs;
81 unsigned int count;
82 } enc, dec;
83 };
84
85 struct cipher_test_suite {
86 struct {
87 struct cipher_testvec *vecs;
88 unsigned int count;
89 } enc, dec;
90 };
91
92 struct comp_test_suite {
93 struct {
94 struct comp_testvec *vecs;
95 unsigned int count;
96 } comp, decomp;
97 };
98
99 struct hash_test_suite {
100 struct hash_testvec *vecs;
101 unsigned int count;
102 };
103
104 struct cprng_test_suite {
105 struct cprng_testvec *vecs;
106 unsigned int count;
107 };
108
109 struct drbg_test_suite {
110 struct drbg_testvec *vecs;
111 unsigned int count;
112 };
113
114 struct akcipher_test_suite {
115 struct akcipher_testvec *vecs;
116 unsigned int count;
117 };
118
119 struct alg_test_desc {
120 const char *alg;
121 int (*test)(const struct alg_test_desc *desc, const char *driver,
122 u32 type, u32 mask);
123 int fips_allowed; /* set if alg is allowed in fips mode */
124
125 union {
126 struct aead_test_suite aead;
127 struct cipher_test_suite cipher;
128 struct comp_test_suite comp;
129 struct hash_test_suite hash;
130 struct cprng_test_suite cprng;
131 struct drbg_test_suite drbg;
132 struct akcipher_test_suite akcipher;
133 } suite;
134 };
135
136 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
137
138 static void hexdump(unsigned char *buf, unsigned int len)
139 {
140 print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
141 16, 1,
142 buf, len, false);
143 }
144
145 static void tcrypt_complete(struct crypto_async_request *req, int err)
146 {
147 struct tcrypt_result *res = req->data;
148
149 if (err == -EINPROGRESS)
150 return;
151
152 res->err = err;
153 complete(&res->completion);
154 }
155
156 static int testmgr_alloc_buf(char *buf[XBUFSIZE])
157 {
158 int i;
159
160 for (i = 0; i < XBUFSIZE; i++) {
161 buf[i] = (void *)__get_free_page(GFP_KERNEL);
162 if (!buf[i])
163 goto err_free_buf;
164 }
165
166 return 0;
167
168 err_free_buf:
169 while (i-- > 0)
170 free_page((unsigned long)buf[i]);
171
172 return -ENOMEM;
173 }
174
175 static void testmgr_free_buf(char *buf[XBUFSIZE])
176 {
177 int i;
178
179 for (i = 0; i < XBUFSIZE; i++)
180 free_page((unsigned long)buf[i]);
181 }
182
183 static int wait_async_op(struct tcrypt_result *tr, int ret)
184 {
185 if (ret == -EINPROGRESS || ret == -EBUSY) {
186 wait_for_completion(&tr->completion);
187 reinit_completion(&tr->completion);
188 ret = tr->err;
189 }
190 return ret;
191 }
192
193 static int ahash_partial_update(struct ahash_request **preq,
194 struct crypto_ahash *tfm, struct hash_testvec *template,
195 void *hash_buff, int k, int temp, struct scatterlist *sg,
196 const char *algo, char *result, struct tcrypt_result *tresult)
197 {
198 char *state;
199 struct ahash_request *req;
200 int statesize, ret = -EINVAL;
201
202 req = *preq;
203 statesize = crypto_ahash_statesize(
204 crypto_ahash_reqtfm(req));
205 state = kmalloc(statesize, GFP_KERNEL);
206 if (!state) {
207 pr_err("alt: hash: Failed to alloc state for %s\n", algo);
208 goto out_nostate;
209 }
210 ret = crypto_ahash_export(req, state);
211 if (ret) {
212 pr_err("alt: hash: Failed to export() for %s\n", algo);
213 goto out;
214 }
215 ahash_request_free(req);
216 req = ahash_request_alloc(tfm, GFP_KERNEL);
217 if (!req) {
218 pr_err("alg: hash: Failed to alloc request for %s\n", algo);
219 goto out_noreq;
220 }
221 ahash_request_set_callback(req,
222 CRYPTO_TFM_REQ_MAY_BACKLOG,
223 tcrypt_complete, tresult);
224
225 memcpy(hash_buff, template->plaintext + temp,
226 template->tap[k]);
227 sg_init_one(&sg[0], hash_buff, template->tap[k]);
228 ahash_request_set_crypt(req, sg, result, template->tap[k]);
229 ret = crypto_ahash_import(req, state);
230 if (ret) {
231 pr_err("alg: hash: Failed to import() for %s\n", algo);
232 goto out;
233 }
234 ret = wait_async_op(tresult, crypto_ahash_update(req));
235 if (ret)
236 goto out;
237 *preq = req;
238 ret = 0;
239 goto out_noreq;
240 out:
241 ahash_request_free(req);
242 out_noreq:
243 kfree(state);
244 out_nostate:
245 return ret;
246 }
247
248 static int __test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
249 unsigned int tcount, bool use_digest,
250 const int align_offset)
251 {
252 const char *algo = crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm));
253 unsigned int i, j, k, temp;
254 struct scatterlist sg[8];
255 char *result;
256 char *key;
257 struct ahash_request *req;
258 struct tcrypt_result tresult;
259 void *hash_buff;
260 char *xbuf[XBUFSIZE];
261 int ret = -ENOMEM;
262
263 result = kmalloc(MAX_DIGEST_SIZE, GFP_KERNEL);
264 if (!result)
265 return ret;
266 key = kmalloc(MAX_KEYLEN, GFP_KERNEL);
267 if (!key)
268 goto out_nobuf;
269 if (testmgr_alloc_buf(xbuf))
270 goto out_nobuf;
271
272 init_completion(&tresult.completion);
273
274 req = ahash_request_alloc(tfm, GFP_KERNEL);
275 if (!req) {
276 printk(KERN_ERR "alg: hash: Failed to allocate request for "
277 "%s\n", algo);
278 goto out_noreq;
279 }
280 ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
281 tcrypt_complete, &tresult);
282
283 j = 0;
284 for (i = 0; i < tcount; i++) {
285 if (template[i].np)
286 continue;
287
288 ret = -EINVAL;
289 if (WARN_ON(align_offset + template[i].psize > PAGE_SIZE))
290 goto out;
291
292 j++;
293 memset(result, 0, MAX_DIGEST_SIZE);
294
295 hash_buff = xbuf[0];
296 hash_buff += align_offset;
297
298 memcpy(hash_buff, template[i].plaintext, template[i].psize);
299 sg_init_one(&sg[0], hash_buff, template[i].psize);
300
301 if (template[i].ksize) {
302 crypto_ahash_clear_flags(tfm, ~0);
303 if (template[i].ksize > MAX_KEYLEN) {
304 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
305 j, algo, template[i].ksize, MAX_KEYLEN);
306 ret = -EINVAL;
307 goto out;
308 }
309 memcpy(key, template[i].key, template[i].ksize);
310 ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
311 if (ret) {
312 printk(KERN_ERR "alg: hash: setkey failed on "
313 "test %d for %s: ret=%d\n", j, algo,
314 -ret);
315 goto out;
316 }
317 }
318
319 ahash_request_set_crypt(req, sg, result, template[i].psize);
320 if (use_digest) {
321 ret = wait_async_op(&tresult, crypto_ahash_digest(req));
322 if (ret) {
323 pr_err("alg: hash: digest failed on test %d "
324 "for %s: ret=%d\n", j, algo, -ret);
325 goto out;
326 }
327 } else {
328 ret = wait_async_op(&tresult, crypto_ahash_init(req));
329 if (ret) {
330 pr_err("alt: hash: init failed on test %d "
331 "for %s: ret=%d\n", j, algo, -ret);
332 goto out;
333 }
334 ret = wait_async_op(&tresult, crypto_ahash_update(req));
335 if (ret) {
336 pr_err("alt: hash: update failed on test %d "
337 "for %s: ret=%d\n", j, algo, -ret);
338 goto out;
339 }
340 ret = wait_async_op(&tresult, crypto_ahash_final(req));
341 if (ret) {
342 pr_err("alt: hash: final failed on test %d "
343 "for %s: ret=%d\n", j, algo, -ret);
344 goto out;
345 }
346 }
347
348 if (memcmp(result, template[i].digest,
349 crypto_ahash_digestsize(tfm))) {
350 printk(KERN_ERR "alg: hash: Test %d failed for %s\n",
351 j, algo);
352 hexdump(result, crypto_ahash_digestsize(tfm));
353 ret = -EINVAL;
354 goto out;
355 }
356 }
357
358 j = 0;
359 for (i = 0; i < tcount; i++) {
360 /* alignment tests are only done with continuous buffers */
361 if (align_offset != 0)
362 break;
363
364 if (!template[i].np)
365 continue;
366
367 j++;
368 memset(result, 0, MAX_DIGEST_SIZE);
369
370 temp = 0;
371 sg_init_table(sg, template[i].np);
372 ret = -EINVAL;
373 for (k = 0; k < template[i].np; k++) {
374 if (WARN_ON(offset_in_page(IDX[k]) +
375 template[i].tap[k] > PAGE_SIZE))
376 goto out;
377 sg_set_buf(&sg[k],
378 memcpy(xbuf[IDX[k] >> PAGE_SHIFT] +
379 offset_in_page(IDX[k]),
380 template[i].plaintext + temp,
381 template[i].tap[k]),
382 template[i].tap[k]);
383 temp += template[i].tap[k];
384 }
385
386 if (template[i].ksize) {
387 if (template[i].ksize > MAX_KEYLEN) {
388 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
389 j, algo, template[i].ksize, MAX_KEYLEN);
390 ret = -EINVAL;
391 goto out;
392 }
393 crypto_ahash_clear_flags(tfm, ~0);
394 memcpy(key, template[i].key, template[i].ksize);
395 ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
396
397 if (ret) {
398 printk(KERN_ERR "alg: hash: setkey "
399 "failed on chunking test %d "
400 "for %s: ret=%d\n", j, algo, -ret);
401 goto out;
402 }
403 }
404
405 ahash_request_set_crypt(req, sg, result, template[i].psize);
406 ret = crypto_ahash_digest(req);
407 switch (ret) {
408 case 0:
409 break;
410 case -EINPROGRESS:
411 case -EBUSY:
412 wait_for_completion(&tresult.completion);
413 reinit_completion(&tresult.completion);
414 ret = tresult.err;
415 if (!ret)
416 break;
417 /* fall through */
418 default:
419 printk(KERN_ERR "alg: hash: digest failed "
420 "on chunking test %d for %s: "
421 "ret=%d\n", j, algo, -ret);
422 goto out;
423 }
424
425 if (memcmp(result, template[i].digest,
426 crypto_ahash_digestsize(tfm))) {
427 printk(KERN_ERR "alg: hash: Chunking test %d "
428 "failed for %s\n", j, algo);
429 hexdump(result, crypto_ahash_digestsize(tfm));
430 ret = -EINVAL;
431 goto out;
432 }
433 }
434
435 /* partial update exercise */
436 j = 0;
437 for (i = 0; i < tcount; i++) {
438 /* alignment tests are only done with continuous buffers */
439 if (align_offset != 0)
440 break;
441
442 if (template[i].np < 2)
443 continue;
444
445 j++;
446 memset(result, 0, MAX_DIGEST_SIZE);
447
448 ret = -EINVAL;
449 hash_buff = xbuf[0];
450 memcpy(hash_buff, template[i].plaintext,
451 template[i].tap[0]);
452 sg_init_one(&sg[0], hash_buff, template[i].tap[0]);
453
454 if (template[i].ksize) {
455 crypto_ahash_clear_flags(tfm, ~0);
456 if (template[i].ksize > MAX_KEYLEN) {
457 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
458 j, algo, template[i].ksize, MAX_KEYLEN);
459 ret = -EINVAL;
460 goto out;
461 }
462 memcpy(key, template[i].key, template[i].ksize);
463 ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
464 if (ret) {
465 pr_err("alg: hash: setkey failed on test %d for %s: ret=%d\n",
466 j, algo, -ret);
467 goto out;
468 }
469 }
470
471 ahash_request_set_crypt(req, sg, result, template[i].tap[0]);
472 ret = wait_async_op(&tresult, crypto_ahash_init(req));
473 if (ret) {
474 pr_err("alt: hash: init failed on test %d for %s: ret=%d\n",
475 j, algo, -ret);
476 goto out;
477 }
478 ret = wait_async_op(&tresult, crypto_ahash_update(req));
479 if (ret) {
480 pr_err("alt: hash: update failed on test %d for %s: ret=%d\n",
481 j, algo, -ret);
482 goto out;
483 }
484
485 temp = template[i].tap[0];
486 for (k = 1; k < template[i].np; k++) {
487 ret = ahash_partial_update(&req, tfm, &template[i],
488 hash_buff, k, temp, &sg[0], algo, result,
489 &tresult);
490 if (ret) {
491 pr_err("hash: partial update failed on test %d for %s: ret=%d\n",
492 j, algo, -ret);
493 goto out_noreq;
494 }
495 temp += template[i].tap[k];
496 }
497 ret = wait_async_op(&tresult, crypto_ahash_final(req));
498 if (ret) {
499 pr_err("alt: hash: final failed on test %d for %s: ret=%d\n",
500 j, algo, -ret);
501 goto out;
502 }
503 if (memcmp(result, template[i].digest,
504 crypto_ahash_digestsize(tfm))) {
505 pr_err("alg: hash: Partial Test %d failed for %s\n",
506 j, algo);
507 hexdump(result, crypto_ahash_digestsize(tfm));
508 ret = -EINVAL;
509 goto out;
510 }
511 }
512
513 ret = 0;
514
515 out:
516 ahash_request_free(req);
517 out_noreq:
518 testmgr_free_buf(xbuf);
519 out_nobuf:
520 kfree(key);
521 kfree(result);
522 return ret;
523 }
524
525 static int test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
526 unsigned int tcount, bool use_digest)
527 {
528 unsigned int alignmask;
529 int ret;
530
531 ret = __test_hash(tfm, template, tcount, use_digest, 0);
532 if (ret)
533 return ret;
534
535 /* test unaligned buffers, check with one byte offset */
536 ret = __test_hash(tfm, template, tcount, use_digest, 1);
537 if (ret)
538 return ret;
539
540 alignmask = crypto_tfm_alg_alignmask(&tfm->base);
541 if (alignmask) {
542 /* Check if alignment mask for tfm is correctly set. */
543 ret = __test_hash(tfm, template, tcount, use_digest,
544 alignmask + 1);
545 if (ret)
546 return ret;
547 }
548
549 return 0;
550 }
551
552 static int __test_aead(struct crypto_aead *tfm, int enc,
553 struct aead_testvec *template, unsigned int tcount,
554 const bool diff_dst, const int align_offset)
555 {
556 const char *algo = crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm));
557 unsigned int i, j, k, n, temp;
558 int ret = -ENOMEM;
559 char *q;
560 char *key;
561 struct aead_request *req;
562 struct scatterlist *sg;
563 struct scatterlist *sgout;
564 const char *e, *d;
565 struct tcrypt_result result;
566 unsigned int authsize, iv_len;
567 void *input;
568 void *output;
569 void *assoc;
570 char *iv;
571 char *xbuf[XBUFSIZE];
572 char *xoutbuf[XBUFSIZE];
573 char *axbuf[XBUFSIZE];
574
575 iv = kzalloc(MAX_IVLEN, GFP_KERNEL);
576 if (!iv)
577 return ret;
578 key = kmalloc(MAX_KEYLEN, GFP_KERNEL);
579 if (!key)
580 goto out_noxbuf;
581 if (testmgr_alloc_buf(xbuf))
582 goto out_noxbuf;
583 if (testmgr_alloc_buf(axbuf))
584 goto out_noaxbuf;
585 if (diff_dst && testmgr_alloc_buf(xoutbuf))
586 goto out_nooutbuf;
587
588 /* avoid "the frame size is larger than 1024 bytes" compiler warning */
589 sg = kmalloc(sizeof(*sg) * 8 * (diff_dst ? 4 : 2), GFP_KERNEL);
590 if (!sg)
591 goto out_nosg;
592 sgout = &sg[16];
593
594 if (diff_dst)
595 d = "-ddst";
596 else
597 d = "";
598
599 if (enc == ENCRYPT)
600 e = "encryption";
601 else
602 e = "decryption";
603
604 init_completion(&result.completion);
605
606 req = aead_request_alloc(tfm, GFP_KERNEL);
607 if (!req) {
608 pr_err("alg: aead%s: Failed to allocate request for %s\n",
609 d, algo);
610 goto out;
611 }
612
613 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
614 tcrypt_complete, &result);
615
616 iv_len = crypto_aead_ivsize(tfm);
617
618 for (i = 0, j = 0; i < tcount; i++) {
619 if (template[i].np)
620 continue;
621
622 j++;
623
624 /* some templates have no input data but they will
625 * touch input
626 */
627 input = xbuf[0];
628 input += align_offset;
629 assoc = axbuf[0];
630
631 ret = -EINVAL;
632 if (WARN_ON(align_offset + template[i].ilen >
633 PAGE_SIZE || template[i].alen > PAGE_SIZE))
634 goto out;
635
636 memcpy(input, template[i].input, template[i].ilen);
637 memcpy(assoc, template[i].assoc, template[i].alen);
638 if (template[i].iv)
639 memcpy(iv, template[i].iv, iv_len);
640 else
641 memset(iv, 0, iv_len);
642
643 crypto_aead_clear_flags(tfm, ~0);
644 if (template[i].wk)
645 crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
646
647 if (template[i].klen > MAX_KEYLEN) {
648 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
649 d, j, algo, template[i].klen,
650 MAX_KEYLEN);
651 ret = -EINVAL;
652 goto out;
653 }
654 memcpy(key, template[i].key, template[i].klen);
655
656 ret = crypto_aead_setkey(tfm, key, template[i].klen);
657 if (!ret == template[i].fail) {
658 pr_err("alg: aead%s: setkey failed on test %d for %s: flags=%x\n",
659 d, j, algo, crypto_aead_get_flags(tfm));
660 goto out;
661 } else if (ret)
662 continue;
663
664 authsize = abs(template[i].rlen - template[i].ilen);
665 ret = crypto_aead_setauthsize(tfm, authsize);
666 if (ret) {
667 pr_err("alg: aead%s: Failed to set authsize to %u on test %d for %s\n",
668 d, authsize, j, algo);
669 goto out;
670 }
671
672 k = !!template[i].alen;
673 sg_init_table(sg, k + 1);
674 sg_set_buf(&sg[0], assoc, template[i].alen);
675 sg_set_buf(&sg[k], input,
676 template[i].ilen + (enc ? authsize : 0));
677 output = input;
678
679 if (diff_dst) {
680 sg_init_table(sgout, k + 1);
681 sg_set_buf(&sgout[0], assoc, template[i].alen);
682
683 output = xoutbuf[0];
684 output += align_offset;
685 sg_set_buf(&sgout[k], output,
686 template[i].rlen + (enc ? 0 : authsize));
687 }
688
689 aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
690 template[i].ilen, iv);
691
692 aead_request_set_ad(req, template[i].alen);
693
694 ret = enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req);
695
696 switch (ret) {
697 case 0:
698 if (template[i].novrfy) {
699 /* verification was supposed to fail */
700 pr_err("alg: aead%s: %s failed on test %d for %s: ret was 0, expected -EBADMSG\n",
701 d, e, j, algo);
702 /* so really, we got a bad message */
703 ret = -EBADMSG;
704 goto out;
705 }
706 break;
707 case -EINPROGRESS:
708 case -EBUSY:
709 wait_for_completion(&result.completion);
710 reinit_completion(&result.completion);
711 ret = result.err;
712 if (!ret)
713 break;
714 case -EBADMSG:
715 if (template[i].novrfy)
716 /* verification failure was expected */
717 continue;
718 /* fall through */
719 default:
720 pr_err("alg: aead%s: %s failed on test %d for %s: ret=%d\n",
721 d, e, j, algo, -ret);
722 goto out;
723 }
724
725 q = output;
726 if (memcmp(q, template[i].result, template[i].rlen)) {
727 pr_err("alg: aead%s: Test %d failed on %s for %s\n",
728 d, j, e, algo);
729 hexdump(q, template[i].rlen);
730 ret = -EINVAL;
731 goto out;
732 }
733 }
734
735 for (i = 0, j = 0; i < tcount; i++) {
736 /* alignment tests are only done with continuous buffers */
737 if (align_offset != 0)
738 break;
739
740 if (!template[i].np)
741 continue;
742
743 j++;
744
745 if (template[i].iv)
746 memcpy(iv, template[i].iv, iv_len);
747 else
748 memset(iv, 0, MAX_IVLEN);
749
750 crypto_aead_clear_flags(tfm, ~0);
751 if (template[i].wk)
752 crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
753 if (template[i].klen > MAX_KEYLEN) {
754 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
755 d, j, algo, template[i].klen, MAX_KEYLEN);
756 ret = -EINVAL;
757 goto out;
758 }
759 memcpy(key, template[i].key, template[i].klen);
760
761 ret = crypto_aead_setkey(tfm, key, template[i].klen);
762 if (!ret == template[i].fail) {
763 pr_err("alg: aead%s: setkey failed on chunk test %d for %s: flags=%x\n",
764 d, j, algo, crypto_aead_get_flags(tfm));
765 goto out;
766 } else if (ret)
767 continue;
768
769 authsize = abs(template[i].rlen - template[i].ilen);
770
771 ret = -EINVAL;
772 sg_init_table(sg, template[i].anp + template[i].np);
773 if (diff_dst)
774 sg_init_table(sgout, template[i].anp + template[i].np);
775
776 ret = -EINVAL;
777 for (k = 0, temp = 0; k < template[i].anp; k++) {
778 if (WARN_ON(offset_in_page(IDX[k]) +
779 template[i].atap[k] > PAGE_SIZE))
780 goto out;
781 sg_set_buf(&sg[k],
782 memcpy(axbuf[IDX[k] >> PAGE_SHIFT] +
783 offset_in_page(IDX[k]),
784 template[i].assoc + temp,
785 template[i].atap[k]),
786 template[i].atap[k]);
787 if (diff_dst)
788 sg_set_buf(&sgout[k],
789 axbuf[IDX[k] >> PAGE_SHIFT] +
790 offset_in_page(IDX[k]),
791 template[i].atap[k]);
792 temp += template[i].atap[k];
793 }
794
795 for (k = 0, temp = 0; k < template[i].np; k++) {
796 if (WARN_ON(offset_in_page(IDX[k]) +
797 template[i].tap[k] > PAGE_SIZE))
798 goto out;
799
800 q = xbuf[IDX[k] >> PAGE_SHIFT] + offset_in_page(IDX[k]);
801 memcpy(q, template[i].input + temp, template[i].tap[k]);
802 sg_set_buf(&sg[template[i].anp + k],
803 q, template[i].tap[k]);
804
805 if (diff_dst) {
806 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
807 offset_in_page(IDX[k]);
808
809 memset(q, 0, template[i].tap[k]);
810
811 sg_set_buf(&sgout[template[i].anp + k],
812 q, template[i].tap[k]);
813 }
814
815 n = template[i].tap[k];
816 if (k == template[i].np - 1 && enc)
817 n += authsize;
818 if (offset_in_page(q) + n < PAGE_SIZE)
819 q[n] = 0;
820
821 temp += template[i].tap[k];
822 }
823
824 ret = crypto_aead_setauthsize(tfm, authsize);
825 if (ret) {
826 pr_err("alg: aead%s: Failed to set authsize to %u on chunk test %d for %s\n",
827 d, authsize, j, algo);
828 goto out;
829 }
830
831 if (enc) {
832 if (WARN_ON(sg[template[i].anp + k - 1].offset +
833 sg[template[i].anp + k - 1].length +
834 authsize > PAGE_SIZE)) {
835 ret = -EINVAL;
836 goto out;
837 }
838
839 if (diff_dst)
840 sgout[template[i].anp + k - 1].length +=
841 authsize;
842 sg[template[i].anp + k - 1].length += authsize;
843 }
844
845 aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
846 template[i].ilen,
847 iv);
848
849 aead_request_set_ad(req, template[i].alen);
850
851 ret = enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req);
852
853 switch (ret) {
854 case 0:
855 if (template[i].novrfy) {
856 /* verification was supposed to fail */
857 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret was 0, expected -EBADMSG\n",
858 d, e, j, algo);
859 /* so really, we got a bad message */
860 ret = -EBADMSG;
861 goto out;
862 }
863 break;
864 case -EINPROGRESS:
865 case -EBUSY:
866 wait_for_completion(&result.completion);
867 reinit_completion(&result.completion);
868 ret = result.err;
869 if (!ret)
870 break;
871 case -EBADMSG:
872 if (template[i].novrfy)
873 /* verification failure was expected */
874 continue;
875 /* fall through */
876 default:
877 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret=%d\n",
878 d, e, j, algo, -ret);
879 goto out;
880 }
881
882 ret = -EINVAL;
883 for (k = 0, temp = 0; k < template[i].np; k++) {
884 if (diff_dst)
885 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
886 offset_in_page(IDX[k]);
887 else
888 q = xbuf[IDX[k] >> PAGE_SHIFT] +
889 offset_in_page(IDX[k]);
890
891 n = template[i].tap[k];
892 if (k == template[i].np - 1)
893 n += enc ? authsize : -authsize;
894
895 if (memcmp(q, template[i].result + temp, n)) {
896 pr_err("alg: aead%s: Chunk test %d failed on %s at page %u for %s\n",
897 d, j, e, k, algo);
898 hexdump(q, n);
899 goto out;
900 }
901
902 q += n;
903 if (k == template[i].np - 1 && !enc) {
904 if (!diff_dst &&
905 memcmp(q, template[i].input +
906 temp + n, authsize))
907 n = authsize;
908 else
909 n = 0;
910 } else {
911 for (n = 0; offset_in_page(q + n) && q[n]; n++)
912 ;
913 }
914 if (n) {
915 pr_err("alg: aead%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
916 d, j, e, k, algo, n);
917 hexdump(q, n);
918 goto out;
919 }
920
921 temp += template[i].tap[k];
922 }
923 }
924
925 ret = 0;
926
927 out:
928 aead_request_free(req);
929 kfree(sg);
930 out_nosg:
931 if (diff_dst)
932 testmgr_free_buf(xoutbuf);
933 out_nooutbuf:
934 testmgr_free_buf(axbuf);
935 out_noaxbuf:
936 testmgr_free_buf(xbuf);
937 out_noxbuf:
938 kfree(key);
939 kfree(iv);
940 return ret;
941 }
942
943 static int test_aead(struct crypto_aead *tfm, int enc,
944 struct aead_testvec *template, unsigned int tcount)
945 {
946 unsigned int alignmask;
947 int ret;
948
949 /* test 'dst == src' case */
950 ret = __test_aead(tfm, enc, template, tcount, false, 0);
951 if (ret)
952 return ret;
953
954 /* test 'dst != src' case */
955 ret = __test_aead(tfm, enc, template, tcount, true, 0);
956 if (ret)
957 return ret;
958
959 /* test unaligned buffers, check with one byte offset */
960 ret = __test_aead(tfm, enc, template, tcount, true, 1);
961 if (ret)
962 return ret;
963
964 alignmask = crypto_tfm_alg_alignmask(&tfm->base);
965 if (alignmask) {
966 /* Check if alignment mask for tfm is correctly set. */
967 ret = __test_aead(tfm, enc, template, tcount, true,
968 alignmask + 1);
969 if (ret)
970 return ret;
971 }
972
973 return 0;
974 }
975
976 static int test_cipher(struct crypto_cipher *tfm, int enc,
977 struct cipher_testvec *template, unsigned int tcount)
978 {
979 const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm));
980 unsigned int i, j, k;
981 char *q;
982 const char *e;
983 void *data;
984 char *xbuf[XBUFSIZE];
985 int ret = -ENOMEM;
986
987 if (testmgr_alloc_buf(xbuf))
988 goto out_nobuf;
989
990 if (enc == ENCRYPT)
991 e = "encryption";
992 else
993 e = "decryption";
994
995 j = 0;
996 for (i = 0; i < tcount; i++) {
997 if (template[i].np)
998 continue;
999
1000 j++;
1001
1002 ret = -EINVAL;
1003 if (WARN_ON(template[i].ilen > PAGE_SIZE))
1004 goto out;
1005
1006 data = xbuf[0];
1007 memcpy(data, template[i].input, template[i].ilen);
1008
1009 crypto_cipher_clear_flags(tfm, ~0);
1010 if (template[i].wk)
1011 crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
1012
1013 ret = crypto_cipher_setkey(tfm, template[i].key,
1014 template[i].klen);
1015 if (!ret == template[i].fail) {
1016 printk(KERN_ERR "alg: cipher: setkey failed "
1017 "on test %d for %s: flags=%x\n", j,
1018 algo, crypto_cipher_get_flags(tfm));
1019 goto out;
1020 } else if (ret)
1021 continue;
1022
1023 for (k = 0; k < template[i].ilen;
1024 k += crypto_cipher_blocksize(tfm)) {
1025 if (enc)
1026 crypto_cipher_encrypt_one(tfm, data + k,
1027 data + k);
1028 else
1029 crypto_cipher_decrypt_one(tfm, data + k,
1030 data + k);
1031 }
1032
1033 q = data;
1034 if (memcmp(q, template[i].result, template[i].rlen)) {
1035 printk(KERN_ERR "alg: cipher: Test %d failed "
1036 "on %s for %s\n", j, e, algo);
1037 hexdump(q, template[i].rlen);
1038 ret = -EINVAL;
1039 goto out;
1040 }
1041 }
1042
1043 ret = 0;
1044
1045 out:
1046 testmgr_free_buf(xbuf);
1047 out_nobuf:
1048 return ret;
1049 }
1050
1051 static int __test_skcipher(struct crypto_skcipher *tfm, int enc,
1052 struct cipher_testvec *template, unsigned int tcount,
1053 const bool diff_dst, const int align_offset)
1054 {
1055 const char *algo =
1056 crypto_tfm_alg_driver_name(crypto_skcipher_tfm(tfm));
1057 unsigned int i, j, k, n, temp;
1058 char *q;
1059 struct skcipher_request *req;
1060 struct scatterlist sg[8];
1061 struct scatterlist sgout[8];
1062 const char *e, *d;
1063 struct tcrypt_result result;
1064 void *data;
1065 char iv[MAX_IVLEN];
1066 char *xbuf[XBUFSIZE];
1067 char *xoutbuf[XBUFSIZE];
1068 int ret = -ENOMEM;
1069 unsigned int ivsize = crypto_skcipher_ivsize(tfm);
1070
1071 if (testmgr_alloc_buf(xbuf))
1072 goto out_nobuf;
1073
1074 if (diff_dst && testmgr_alloc_buf(xoutbuf))
1075 goto out_nooutbuf;
1076
1077 if (diff_dst)
1078 d = "-ddst";
1079 else
1080 d = "";
1081
1082 if (enc == ENCRYPT)
1083 e = "encryption";
1084 else
1085 e = "decryption";
1086
1087 init_completion(&result.completion);
1088
1089 req = skcipher_request_alloc(tfm, GFP_KERNEL);
1090 if (!req) {
1091 pr_err("alg: skcipher%s: Failed to allocate request for %s\n",
1092 d, algo);
1093 goto out;
1094 }
1095
1096 skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1097 tcrypt_complete, &result);
1098
1099 j = 0;
1100 for (i = 0; i < tcount; i++) {
1101 if (template[i].np && !template[i].also_non_np)
1102 continue;
1103
1104 if (template[i].iv)
1105 memcpy(iv, template[i].iv, ivsize);
1106 else
1107 memset(iv, 0, MAX_IVLEN);
1108
1109 j++;
1110 ret = -EINVAL;
1111 if (WARN_ON(align_offset + template[i].ilen > PAGE_SIZE))
1112 goto out;
1113
1114 data = xbuf[0];
1115 data += align_offset;
1116 memcpy(data, template[i].input, template[i].ilen);
1117
1118 crypto_skcipher_clear_flags(tfm, ~0);
1119 if (template[i].wk)
1120 crypto_skcipher_set_flags(tfm,
1121 CRYPTO_TFM_REQ_WEAK_KEY);
1122
1123 ret = crypto_skcipher_setkey(tfm, template[i].key,
1124 template[i].klen);
1125 if (!ret == template[i].fail) {
1126 pr_err("alg: skcipher%s: setkey failed on test %d for %s: flags=%x\n",
1127 d, j, algo, crypto_skcipher_get_flags(tfm));
1128 goto out;
1129 } else if (ret)
1130 continue;
1131
1132 sg_init_one(&sg[0], data, template[i].ilen);
1133 if (diff_dst) {
1134 data = xoutbuf[0];
1135 data += align_offset;
1136 sg_init_one(&sgout[0], data, template[i].ilen);
1137 }
1138
1139 skcipher_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
1140 template[i].ilen, iv);
1141 ret = enc ? crypto_skcipher_encrypt(req) :
1142 crypto_skcipher_decrypt(req);
1143
1144 switch (ret) {
1145 case 0:
1146 break;
1147 case -EINPROGRESS:
1148 case -EBUSY:
1149 wait_for_completion(&result.completion);
1150 reinit_completion(&result.completion);
1151 ret = result.err;
1152 if (!ret)
1153 break;
1154 /* fall through */
1155 default:
1156 pr_err("alg: skcipher%s: %s failed on test %d for %s: ret=%d\n",
1157 d, e, j, algo, -ret);
1158 goto out;
1159 }
1160
1161 q = data;
1162 if (memcmp(q, template[i].result, template[i].rlen)) {
1163 pr_err("alg: skcipher%s: Test %d failed (invalid result) on %s for %s\n",
1164 d, j, e, algo);
1165 hexdump(q, template[i].rlen);
1166 ret = -EINVAL;
1167 goto out;
1168 }
1169
1170 if (template[i].iv_out &&
1171 memcmp(iv, template[i].iv_out,
1172 crypto_skcipher_ivsize(tfm))) {
1173 pr_err("alg: skcipher%s: Test %d failed (invalid output IV) on %s for %s\n",
1174 d, j, e, algo);
1175 hexdump(iv, crypto_skcipher_ivsize(tfm));
1176 ret = -EINVAL;
1177 goto out;
1178 }
1179 }
1180
1181 j = 0;
1182 for (i = 0; i < tcount; i++) {
1183 /* alignment tests are only done with continuous buffers */
1184 if (align_offset != 0)
1185 break;
1186
1187 if (!template[i].np)
1188 continue;
1189
1190 if (template[i].iv)
1191 memcpy(iv, template[i].iv, ivsize);
1192 else
1193 memset(iv, 0, MAX_IVLEN);
1194
1195 j++;
1196 crypto_skcipher_clear_flags(tfm, ~0);
1197 if (template[i].wk)
1198 crypto_skcipher_set_flags(tfm,
1199 CRYPTO_TFM_REQ_WEAK_KEY);
1200
1201 ret = crypto_skcipher_setkey(tfm, template[i].key,
1202 template[i].klen);
1203 if (!ret == template[i].fail) {
1204 pr_err("alg: skcipher%s: setkey failed on chunk test %d for %s: flags=%x\n",
1205 d, j, algo, crypto_skcipher_get_flags(tfm));
1206 goto out;
1207 } else if (ret)
1208 continue;
1209
1210 temp = 0;
1211 ret = -EINVAL;
1212 sg_init_table(sg, template[i].np);
1213 if (diff_dst)
1214 sg_init_table(sgout, template[i].np);
1215 for (k = 0; k < template[i].np; k++) {
1216 if (WARN_ON(offset_in_page(IDX[k]) +
1217 template[i].tap[k] > PAGE_SIZE))
1218 goto out;
1219
1220 q = xbuf[IDX[k] >> PAGE_SHIFT] + offset_in_page(IDX[k]);
1221
1222 memcpy(q, template[i].input + temp, template[i].tap[k]);
1223
1224 if (offset_in_page(q) + template[i].tap[k] < PAGE_SIZE)
1225 q[template[i].tap[k]] = 0;
1226
1227 sg_set_buf(&sg[k], q, template[i].tap[k]);
1228 if (diff_dst) {
1229 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
1230 offset_in_page(IDX[k]);
1231
1232 sg_set_buf(&sgout[k], q, template[i].tap[k]);
1233
1234 memset(q, 0, template[i].tap[k]);
1235 if (offset_in_page(q) +
1236 template[i].tap[k] < PAGE_SIZE)
1237 q[template[i].tap[k]] = 0;
1238 }
1239
1240 temp += template[i].tap[k];
1241 }
1242
1243 skcipher_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
1244 template[i].ilen, iv);
1245
1246 ret = enc ? crypto_skcipher_encrypt(req) :
1247 crypto_skcipher_decrypt(req);
1248
1249 switch (ret) {
1250 case 0:
1251 break;
1252 case -EINPROGRESS:
1253 case -EBUSY:
1254 wait_for_completion(&result.completion);
1255 reinit_completion(&result.completion);
1256 ret = result.err;
1257 if (!ret)
1258 break;
1259 /* fall through */
1260 default:
1261 pr_err("alg: skcipher%s: %s failed on chunk test %d for %s: ret=%d\n",
1262 d, e, j, algo, -ret);
1263 goto out;
1264 }
1265
1266 temp = 0;
1267 ret = -EINVAL;
1268 for (k = 0; k < template[i].np; k++) {
1269 if (diff_dst)
1270 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
1271 offset_in_page(IDX[k]);
1272 else
1273 q = xbuf[IDX[k] >> PAGE_SHIFT] +
1274 offset_in_page(IDX[k]);
1275
1276 if (memcmp(q, template[i].result + temp,
1277 template[i].tap[k])) {
1278 pr_err("alg: skcipher%s: Chunk test %d failed on %s at page %u for %s\n",
1279 d, j, e, k, algo);
1280 hexdump(q, template[i].tap[k]);
1281 goto out;
1282 }
1283
1284 q += template[i].tap[k];
1285 for (n = 0; offset_in_page(q + n) && q[n]; n++)
1286 ;
1287 if (n) {
1288 pr_err("alg: skcipher%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
1289 d, j, e, k, algo, n);
1290 hexdump(q, n);
1291 goto out;
1292 }
1293 temp += template[i].tap[k];
1294 }
1295 }
1296
1297 ret = 0;
1298
1299 out:
1300 skcipher_request_free(req);
1301 if (diff_dst)
1302 testmgr_free_buf(xoutbuf);
1303 out_nooutbuf:
1304 testmgr_free_buf(xbuf);
1305 out_nobuf:
1306 return ret;
1307 }
1308
1309 static int test_skcipher(struct crypto_skcipher *tfm, int enc,
1310 struct cipher_testvec *template, unsigned int tcount)
1311 {
1312 unsigned int alignmask;
1313 int ret;
1314
1315 /* test 'dst == src' case */
1316 ret = __test_skcipher(tfm, enc, template, tcount, false, 0);
1317 if (ret)
1318 return ret;
1319
1320 /* test 'dst != src' case */
1321 ret = __test_skcipher(tfm, enc, template, tcount, true, 0);
1322 if (ret)
1323 return ret;
1324
1325 /* test unaligned buffers, check with one byte offset */
1326 ret = __test_skcipher(tfm, enc, template, tcount, true, 1);
1327 if (ret)
1328 return ret;
1329
1330 alignmask = crypto_tfm_alg_alignmask(&tfm->base);
1331 if (alignmask) {
1332 /* Check if alignment mask for tfm is correctly set. */
1333 ret = __test_skcipher(tfm, enc, template, tcount, true,
1334 alignmask + 1);
1335 if (ret)
1336 return ret;
1337 }
1338
1339 return 0;
1340 }
1341
1342 static int test_comp(struct crypto_comp *tfm, struct comp_testvec *ctemplate,
1343 struct comp_testvec *dtemplate, int ctcount, int dtcount)
1344 {
1345 const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
1346 unsigned int i;
1347 char result[COMP_BUF_SIZE];
1348 int ret;
1349
1350 for (i = 0; i < ctcount; i++) {
1351 int ilen;
1352 unsigned int dlen = COMP_BUF_SIZE;
1353
1354 memset(result, 0, sizeof (result));
1355
1356 ilen = ctemplate[i].inlen;
1357 ret = crypto_comp_compress(tfm, ctemplate[i].input,
1358 ilen, result, &dlen);
1359 if (ret) {
1360 printk(KERN_ERR "alg: comp: compression failed "
1361 "on test %d for %s: ret=%d\n", i + 1, algo,
1362 -ret);
1363 goto out;
1364 }
1365
1366 if (dlen != ctemplate[i].outlen) {
1367 printk(KERN_ERR "alg: comp: Compression test %d "
1368 "failed for %s: output len = %d\n", i + 1, algo,
1369 dlen);
1370 ret = -EINVAL;
1371 goto out;
1372 }
1373
1374 if (memcmp(result, ctemplate[i].output, dlen)) {
1375 printk(KERN_ERR "alg: comp: Compression test %d "
1376 "failed for %s\n", i + 1, algo);
1377 hexdump(result, dlen);
1378 ret = -EINVAL;
1379 goto out;
1380 }
1381 }
1382
1383 for (i = 0; i < dtcount; i++) {
1384 int ilen;
1385 unsigned int dlen = COMP_BUF_SIZE;
1386
1387 memset(result, 0, sizeof (result));
1388
1389 ilen = dtemplate[i].inlen;
1390 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
1391 ilen, result, &dlen);
1392 if (ret) {
1393 printk(KERN_ERR "alg: comp: decompression failed "
1394 "on test %d for %s: ret=%d\n", i + 1, algo,
1395 -ret);
1396 goto out;
1397 }
1398
1399 if (dlen != dtemplate[i].outlen) {
1400 printk(KERN_ERR "alg: comp: Decompression test %d "
1401 "failed for %s: output len = %d\n", i + 1, algo,
1402 dlen);
1403 ret = -EINVAL;
1404 goto out;
1405 }
1406
1407 if (memcmp(result, dtemplate[i].output, dlen)) {
1408 printk(KERN_ERR "alg: comp: Decompression test %d "
1409 "failed for %s\n", i + 1, algo);
1410 hexdump(result, dlen);
1411 ret = -EINVAL;
1412 goto out;
1413 }
1414 }
1415
1416 ret = 0;
1417
1418 out:
1419 return ret;
1420 }
1421
1422 static int test_cprng(struct crypto_rng *tfm, struct cprng_testvec *template,
1423 unsigned int tcount)
1424 {
1425 const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm));
1426 int err = 0, i, j, seedsize;
1427 u8 *seed;
1428 char result[32];
1429
1430 seedsize = crypto_rng_seedsize(tfm);
1431
1432 seed = kmalloc(seedsize, GFP_KERNEL);
1433 if (!seed) {
1434 printk(KERN_ERR "alg: cprng: Failed to allocate seed space "
1435 "for %s\n", algo);
1436 return -ENOMEM;
1437 }
1438
1439 for (i = 0; i < tcount; i++) {
1440 memset(result, 0, 32);
1441
1442 memcpy(seed, template[i].v, template[i].vlen);
1443 memcpy(seed + template[i].vlen, template[i].key,
1444 template[i].klen);
1445 memcpy(seed + template[i].vlen + template[i].klen,
1446 template[i].dt, template[i].dtlen);
1447
1448 err = crypto_rng_reset(tfm, seed, seedsize);
1449 if (err) {
1450 printk(KERN_ERR "alg: cprng: Failed to reset rng "
1451 "for %s\n", algo);
1452 goto out;
1453 }
1454
1455 for (j = 0; j < template[i].loops; j++) {
1456 err = crypto_rng_get_bytes(tfm, result,
1457 template[i].rlen);
1458 if (err < 0) {
1459 printk(KERN_ERR "alg: cprng: Failed to obtain "
1460 "the correct amount of random data for "
1461 "%s (requested %d)\n", algo,
1462 template[i].rlen);
1463 goto out;
1464 }
1465 }
1466
1467 err = memcmp(result, template[i].result,
1468 template[i].rlen);
1469 if (err) {
1470 printk(KERN_ERR "alg: cprng: Test %d failed for %s\n",
1471 i, algo);
1472 hexdump(result, template[i].rlen);
1473 err = -EINVAL;
1474 goto out;
1475 }
1476 }
1477
1478 out:
1479 kfree(seed);
1480 return err;
1481 }
1482
1483 static int alg_test_aead(const struct alg_test_desc *desc, const char *driver,
1484 u32 type, u32 mask)
1485 {
1486 struct crypto_aead *tfm;
1487 int err = 0;
1488
1489 tfm = crypto_alloc_aead(driver, type | CRYPTO_ALG_INTERNAL, mask);
1490 if (IS_ERR(tfm)) {
1491 printk(KERN_ERR "alg: aead: Failed to load transform for %s: "
1492 "%ld\n", driver, PTR_ERR(tfm));
1493 return PTR_ERR(tfm);
1494 }
1495
1496 if (desc->suite.aead.enc.vecs) {
1497 err = test_aead(tfm, ENCRYPT, desc->suite.aead.enc.vecs,
1498 desc->suite.aead.enc.count);
1499 if (err)
1500 goto out;
1501 }
1502
1503 if (!err && desc->suite.aead.dec.vecs)
1504 err = test_aead(tfm, DECRYPT, desc->suite.aead.dec.vecs,
1505 desc->suite.aead.dec.count);
1506
1507 out:
1508 crypto_free_aead(tfm);
1509 return err;
1510 }
1511
1512 static int alg_test_cipher(const struct alg_test_desc *desc,
1513 const char *driver, u32 type, u32 mask)
1514 {
1515 struct crypto_cipher *tfm;
1516 int err = 0;
1517
1518 tfm = crypto_alloc_cipher(driver, type | CRYPTO_ALG_INTERNAL, mask);
1519 if (IS_ERR(tfm)) {
1520 printk(KERN_ERR "alg: cipher: Failed to load transform for "
1521 "%s: %ld\n", driver, PTR_ERR(tfm));
1522 return PTR_ERR(tfm);
1523 }
1524
1525 if (desc->suite.cipher.enc.vecs) {
1526 err = test_cipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1527 desc->suite.cipher.enc.count);
1528 if (err)
1529 goto out;
1530 }
1531
1532 if (desc->suite.cipher.dec.vecs)
1533 err = test_cipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1534 desc->suite.cipher.dec.count);
1535
1536 out:
1537 crypto_free_cipher(tfm);
1538 return err;
1539 }
1540
1541 static int alg_test_skcipher(const struct alg_test_desc *desc,
1542 const char *driver, u32 type, u32 mask)
1543 {
1544 struct crypto_skcipher *tfm;
1545 int err = 0;
1546
1547 tfm = crypto_alloc_skcipher(driver, type | CRYPTO_ALG_INTERNAL, mask);
1548 if (IS_ERR(tfm)) {
1549 printk(KERN_ERR "alg: skcipher: Failed to load transform for "
1550 "%s: %ld\n", driver, PTR_ERR(tfm));
1551 return PTR_ERR(tfm);
1552 }
1553
1554 if (desc->suite.cipher.enc.vecs) {
1555 err = test_skcipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1556 desc->suite.cipher.enc.count);
1557 if (err)
1558 goto out;
1559 }
1560
1561 if (desc->suite.cipher.dec.vecs)
1562 err = test_skcipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1563 desc->suite.cipher.dec.count);
1564
1565 out:
1566 crypto_free_skcipher(tfm);
1567 return err;
1568 }
1569
1570 static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
1571 u32 type, u32 mask)
1572 {
1573 struct crypto_comp *tfm;
1574 int err;
1575
1576 tfm = crypto_alloc_comp(driver, type, mask);
1577 if (IS_ERR(tfm)) {
1578 printk(KERN_ERR "alg: comp: Failed to load transform for %s: "
1579 "%ld\n", driver, PTR_ERR(tfm));
1580 return PTR_ERR(tfm);
1581 }
1582
1583 err = test_comp(tfm, desc->suite.comp.comp.vecs,
1584 desc->suite.comp.decomp.vecs,
1585 desc->suite.comp.comp.count,
1586 desc->suite.comp.decomp.count);
1587
1588 crypto_free_comp(tfm);
1589 return err;
1590 }
1591
1592 static int alg_test_hash(const struct alg_test_desc *desc, const char *driver,
1593 u32 type, u32 mask)
1594 {
1595 struct crypto_ahash *tfm;
1596 int err;
1597
1598 tfm = crypto_alloc_ahash(driver, type | CRYPTO_ALG_INTERNAL, mask);
1599 if (IS_ERR(tfm)) {
1600 printk(KERN_ERR "alg: hash: Failed to load transform for %s: "
1601 "%ld\n", driver, PTR_ERR(tfm));
1602 return PTR_ERR(tfm);
1603 }
1604
1605 err = test_hash(tfm, desc->suite.hash.vecs,
1606 desc->suite.hash.count, true);
1607 if (!err)
1608 err = test_hash(tfm, desc->suite.hash.vecs,
1609 desc->suite.hash.count, false);
1610
1611 crypto_free_ahash(tfm);
1612 return err;
1613 }
1614
1615 static int alg_test_crc32c(const struct alg_test_desc *desc,
1616 const char *driver, u32 type, u32 mask)
1617 {
1618 struct crypto_shash *tfm;
1619 u32 val;
1620 int err;
1621
1622 err = alg_test_hash(desc, driver, type, mask);
1623 if (err)
1624 goto out;
1625
1626 tfm = crypto_alloc_shash(driver, type | CRYPTO_ALG_INTERNAL, mask);
1627 if (IS_ERR(tfm)) {
1628 printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: "
1629 "%ld\n", driver, PTR_ERR(tfm));
1630 err = PTR_ERR(tfm);
1631 goto out;
1632 }
1633
1634 do {
1635 SHASH_DESC_ON_STACK(shash, tfm);
1636 u32 *ctx = (u32 *)shash_desc_ctx(shash);
1637
1638 shash->tfm = tfm;
1639 shash->flags = 0;
1640
1641 *ctx = le32_to_cpu(420553207);
1642 err = crypto_shash_final(shash, (u8 *)&val);
1643 if (err) {
1644 printk(KERN_ERR "alg: crc32c: Operation failed for "
1645 "%s: %d\n", driver, err);
1646 break;
1647 }
1648
1649 if (val != ~420553207) {
1650 printk(KERN_ERR "alg: crc32c: Test failed for %s: "
1651 "%d\n", driver, val);
1652 err = -EINVAL;
1653 }
1654 } while (0);
1655
1656 crypto_free_shash(tfm);
1657
1658 out:
1659 return err;
1660 }
1661
1662 static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver,
1663 u32 type, u32 mask)
1664 {
1665 struct crypto_rng *rng;
1666 int err;
1667
1668 rng = crypto_alloc_rng(driver, type | CRYPTO_ALG_INTERNAL, mask);
1669 if (IS_ERR(rng)) {
1670 printk(KERN_ERR "alg: cprng: Failed to load transform for %s: "
1671 "%ld\n", driver, PTR_ERR(rng));
1672 return PTR_ERR(rng);
1673 }
1674
1675 err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count);
1676
1677 crypto_free_rng(rng);
1678
1679 return err;
1680 }
1681
1682
1683 static int drbg_cavs_test(struct drbg_testvec *test, int pr,
1684 const char *driver, u32 type, u32 mask)
1685 {
1686 int ret = -EAGAIN;
1687 struct crypto_rng *drng;
1688 struct drbg_test_data test_data;
1689 struct drbg_string addtl, pers, testentropy;
1690 unsigned char *buf = kzalloc(test->expectedlen, GFP_KERNEL);
1691
1692 if (!buf)
1693 return -ENOMEM;
1694
1695 drng = crypto_alloc_rng(driver, type | CRYPTO_ALG_INTERNAL, mask);
1696 if (IS_ERR(drng)) {
1697 printk(KERN_ERR "alg: drbg: could not allocate DRNG handle for "
1698 "%s\n", driver);
1699 kzfree(buf);
1700 return -ENOMEM;
1701 }
1702
1703 test_data.testentropy = &testentropy;
1704 drbg_string_fill(&testentropy, test->entropy, test->entropylen);
1705 drbg_string_fill(&pers, test->pers, test->perslen);
1706 ret = crypto_drbg_reset_test(drng, &pers, &test_data);
1707 if (ret) {
1708 printk(KERN_ERR "alg: drbg: Failed to reset rng\n");
1709 goto outbuf;
1710 }
1711
1712 drbg_string_fill(&addtl, test->addtla, test->addtllen);
1713 if (pr) {
1714 drbg_string_fill(&testentropy, test->entpra, test->entprlen);
1715 ret = crypto_drbg_get_bytes_addtl_test(drng,
1716 buf, test->expectedlen, &addtl, &test_data);
1717 } else {
1718 ret = crypto_drbg_get_bytes_addtl(drng,
1719 buf, test->expectedlen, &addtl);
1720 }
1721 if (ret < 0) {
1722 printk(KERN_ERR "alg: drbg: could not obtain random data for "
1723 "driver %s\n", driver);
1724 goto outbuf;
1725 }
1726
1727 drbg_string_fill(&addtl, test->addtlb, test->addtllen);
1728 if (pr) {
1729 drbg_string_fill(&testentropy, test->entprb, test->entprlen);
1730 ret = crypto_drbg_get_bytes_addtl_test(drng,
1731 buf, test->expectedlen, &addtl, &test_data);
1732 } else {
1733 ret = crypto_drbg_get_bytes_addtl(drng,
1734 buf, test->expectedlen, &addtl);
1735 }
1736 if (ret < 0) {
1737 printk(KERN_ERR "alg: drbg: could not obtain random data for "
1738 "driver %s\n", driver);
1739 goto outbuf;
1740 }
1741
1742 ret = memcmp(test->expected, buf, test->expectedlen);
1743
1744 outbuf:
1745 crypto_free_rng(drng);
1746 kzfree(buf);
1747 return ret;
1748 }
1749
1750
1751 static int alg_test_drbg(const struct alg_test_desc *desc, const char *driver,
1752 u32 type, u32 mask)
1753 {
1754 int err = 0;
1755 int pr = 0;
1756 int i = 0;
1757 struct drbg_testvec *template = desc->suite.drbg.vecs;
1758 unsigned int tcount = desc->suite.drbg.count;
1759
1760 if (0 == memcmp(driver, "drbg_pr_", 8))
1761 pr = 1;
1762
1763 for (i = 0; i < tcount; i++) {
1764 err = drbg_cavs_test(&template[i], pr, driver, type, mask);
1765 if (err) {
1766 printk(KERN_ERR "alg: drbg: Test %d failed for %s\n",
1767 i, driver);
1768 err = -EINVAL;
1769 break;
1770 }
1771 }
1772 return err;
1773
1774 }
1775
1776 static int do_test_rsa(struct crypto_akcipher *tfm,
1777 struct akcipher_testvec *vecs)
1778 {
1779 char *xbuf[XBUFSIZE];
1780 struct akcipher_request *req;
1781 void *outbuf_enc = NULL;
1782 void *outbuf_dec = NULL;
1783 struct tcrypt_result result;
1784 unsigned int out_len_max, out_len = 0;
1785 int err = -ENOMEM;
1786 struct scatterlist src, dst, src_tab[2];
1787
1788 if (testmgr_alloc_buf(xbuf))
1789 return err;
1790
1791 req = akcipher_request_alloc(tfm, GFP_KERNEL);
1792 if (!req)
1793 goto free_xbuf;
1794
1795 init_completion(&result.completion);
1796
1797 if (vecs->public_key_vec)
1798 err = crypto_akcipher_set_pub_key(tfm, vecs->key,
1799 vecs->key_len);
1800 else
1801 err = crypto_akcipher_set_priv_key(tfm, vecs->key,
1802 vecs->key_len);
1803 if (err)
1804 goto free_req;
1805
1806 out_len_max = crypto_akcipher_maxsize(tfm);
1807 outbuf_enc = kzalloc(out_len_max, GFP_KERNEL);
1808 if (!outbuf_enc)
1809 goto free_req;
1810
1811 if (WARN_ON(vecs->m_size > PAGE_SIZE))
1812 goto free_all;
1813
1814 memcpy(xbuf[0], vecs->m, vecs->m_size);
1815
1816 sg_init_table(src_tab, 2);
1817 sg_set_buf(&src_tab[0], xbuf[0], 8);
1818 sg_set_buf(&src_tab[1], xbuf[0] + 8, vecs->m_size - 8);
1819 sg_init_one(&dst, outbuf_enc, out_len_max);
1820 akcipher_request_set_crypt(req, src_tab, &dst, vecs->m_size,
1821 out_len_max);
1822 akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1823 tcrypt_complete, &result);
1824
1825 /* Run RSA encrypt - c = m^e mod n;*/
1826 err = wait_async_op(&result, crypto_akcipher_encrypt(req));
1827 if (err) {
1828 pr_err("alg: rsa: encrypt test failed. err %d\n", err);
1829 goto free_all;
1830 }
1831 if (req->dst_len != vecs->c_size) {
1832 pr_err("alg: rsa: encrypt test failed. Invalid output len\n");
1833 err = -EINVAL;
1834 goto free_all;
1835 }
1836 /* verify that encrypted message is equal to expected */
1837 if (memcmp(vecs->c, outbuf_enc, vecs->c_size)) {
1838 pr_err("alg: rsa: encrypt test failed. Invalid output\n");
1839 err = -EINVAL;
1840 goto free_all;
1841 }
1842 /* Don't invoke decrypt for vectors with public key */
1843 if (vecs->public_key_vec) {
1844 err = 0;
1845 goto free_all;
1846 }
1847 outbuf_dec = kzalloc(out_len_max, GFP_KERNEL);
1848 if (!outbuf_dec) {
1849 err = -ENOMEM;
1850 goto free_all;
1851 }
1852
1853 if (WARN_ON(vecs->c_size > PAGE_SIZE))
1854 goto free_all;
1855
1856 memcpy(xbuf[0], vecs->c, vecs->c_size);
1857
1858 sg_init_one(&src, xbuf[0], vecs->c_size);
1859 sg_init_one(&dst, outbuf_dec, out_len_max);
1860 init_completion(&result.completion);
1861 akcipher_request_set_crypt(req, &src, &dst, vecs->c_size, out_len_max);
1862
1863 /* Run RSA decrypt - m = c^d mod n;*/
1864 err = wait_async_op(&result, crypto_akcipher_decrypt(req));
1865 if (err) {
1866 pr_err("alg: rsa: decrypt test failed. err %d\n", err);
1867 goto free_all;
1868 }
1869 out_len = req->dst_len;
1870 if (out_len != vecs->m_size) {
1871 pr_err("alg: rsa: decrypt test failed. Invalid output len\n");
1872 err = -EINVAL;
1873 goto free_all;
1874 }
1875 /* verify that decrypted message is equal to the original msg */
1876 if (memcmp(vecs->m, outbuf_dec, vecs->m_size)) {
1877 pr_err("alg: rsa: decrypt test failed. Invalid output\n");
1878 err = -EINVAL;
1879 }
1880 free_all:
1881 kfree(outbuf_dec);
1882 kfree(outbuf_enc);
1883 free_req:
1884 akcipher_request_free(req);
1885 free_xbuf:
1886 testmgr_free_buf(xbuf);
1887 return err;
1888 }
1889
1890 static int test_rsa(struct crypto_akcipher *tfm, struct akcipher_testvec *vecs,
1891 unsigned int tcount)
1892 {
1893 int ret, i;
1894
1895 for (i = 0; i < tcount; i++) {
1896 ret = do_test_rsa(tfm, vecs++);
1897 if (ret) {
1898 pr_err("alg: rsa: test failed on vector %d, err=%d\n",
1899 i + 1, ret);
1900 return ret;
1901 }
1902 }
1903 return 0;
1904 }
1905
1906 static int test_akcipher(struct crypto_akcipher *tfm, const char *alg,
1907 struct akcipher_testvec *vecs, unsigned int tcount)
1908 {
1909 if (strncmp(alg, "rsa", 3) == 0)
1910 return test_rsa(tfm, vecs, tcount);
1911
1912 return 0;
1913 }
1914
1915 static int alg_test_akcipher(const struct alg_test_desc *desc,
1916 const char *driver, u32 type, u32 mask)
1917 {
1918 struct crypto_akcipher *tfm;
1919 int err = 0;
1920
1921 tfm = crypto_alloc_akcipher(driver, type | CRYPTO_ALG_INTERNAL, mask);
1922 if (IS_ERR(tfm)) {
1923 pr_err("alg: akcipher: Failed to load tfm for %s: %ld\n",
1924 driver, PTR_ERR(tfm));
1925 return PTR_ERR(tfm);
1926 }
1927 if (desc->suite.akcipher.vecs)
1928 err = test_akcipher(tfm, desc->alg, desc->suite.akcipher.vecs,
1929 desc->suite.akcipher.count);
1930
1931 crypto_free_akcipher(tfm);
1932 return err;
1933 }
1934
1935 static int alg_test_null(const struct alg_test_desc *desc,
1936 const char *driver, u32 type, u32 mask)
1937 {
1938 return 0;
1939 }
1940
1941 /* Please keep this list sorted by algorithm name. */
1942 static const struct alg_test_desc alg_test_descs[] = {
1943 {
1944 .alg = "__cbc-cast5-avx",
1945 .test = alg_test_null,
1946 }, {
1947 .alg = "__cbc-cast6-avx",
1948 .test = alg_test_null,
1949 }, {
1950 .alg = "__cbc-serpent-avx",
1951 .test = alg_test_null,
1952 }, {
1953 .alg = "__cbc-serpent-avx2",
1954 .test = alg_test_null,
1955 }, {
1956 .alg = "__cbc-serpent-sse2",
1957 .test = alg_test_null,
1958 }, {
1959 .alg = "__cbc-twofish-avx",
1960 .test = alg_test_null,
1961 }, {
1962 .alg = "__driver-cbc-aes-aesni",
1963 .test = alg_test_null,
1964 .fips_allowed = 1,
1965 }, {
1966 .alg = "__driver-cbc-camellia-aesni",
1967 .test = alg_test_null,
1968 }, {
1969 .alg = "__driver-cbc-camellia-aesni-avx2",
1970 .test = alg_test_null,
1971 }, {
1972 .alg = "__driver-cbc-cast5-avx",
1973 .test = alg_test_null,
1974 }, {
1975 .alg = "__driver-cbc-cast6-avx",
1976 .test = alg_test_null,
1977 }, {
1978 .alg = "__driver-cbc-serpent-avx",
1979 .test = alg_test_null,
1980 }, {
1981 .alg = "__driver-cbc-serpent-avx2",
1982 .test = alg_test_null,
1983 }, {
1984 .alg = "__driver-cbc-serpent-sse2",
1985 .test = alg_test_null,
1986 }, {
1987 .alg = "__driver-cbc-twofish-avx",
1988 .test = alg_test_null,
1989 }, {
1990 .alg = "__driver-ecb-aes-aesni",
1991 .test = alg_test_null,
1992 .fips_allowed = 1,
1993 }, {
1994 .alg = "__driver-ecb-camellia-aesni",
1995 .test = alg_test_null,
1996 }, {
1997 .alg = "__driver-ecb-camellia-aesni-avx2",
1998 .test = alg_test_null,
1999 }, {
2000 .alg = "__driver-ecb-cast5-avx",
2001 .test = alg_test_null,
2002 }, {
2003 .alg = "__driver-ecb-cast6-avx",
2004 .test = alg_test_null,
2005 }, {
2006 .alg = "__driver-ecb-serpent-avx",
2007 .test = alg_test_null,
2008 }, {
2009 .alg = "__driver-ecb-serpent-avx2",
2010 .test = alg_test_null,
2011 }, {
2012 .alg = "__driver-ecb-serpent-sse2",
2013 .test = alg_test_null,
2014 }, {
2015 .alg = "__driver-ecb-twofish-avx",
2016 .test = alg_test_null,
2017 }, {
2018 .alg = "__driver-gcm-aes-aesni",
2019 .test = alg_test_null,
2020 .fips_allowed = 1,
2021 }, {
2022 .alg = "__ghash-pclmulqdqni",
2023 .test = alg_test_null,
2024 .fips_allowed = 1,
2025 }, {
2026 .alg = "ansi_cprng",
2027 .test = alg_test_cprng,
2028 .suite = {
2029 .cprng = {
2030 .vecs = ansi_cprng_aes_tv_template,
2031 .count = ANSI_CPRNG_AES_TEST_VECTORS
2032 }
2033 }
2034 }, {
2035 .alg = "authenc(hmac(md5),ecb(cipher_null))",
2036 .test = alg_test_aead,
2037 .suite = {
2038 .aead = {
2039 .enc = {
2040 .vecs = hmac_md5_ecb_cipher_null_enc_tv_template,
2041 .count = HMAC_MD5_ECB_CIPHER_NULL_ENC_TEST_VECTORS
2042 },
2043 .dec = {
2044 .vecs = hmac_md5_ecb_cipher_null_dec_tv_template,
2045 .count = HMAC_MD5_ECB_CIPHER_NULL_DEC_TEST_VECTORS
2046 }
2047 }
2048 }
2049 }, {
2050 .alg = "authenc(hmac(sha1),cbc(aes))",
2051 .test = alg_test_aead,
2052 .suite = {
2053 .aead = {
2054 .enc = {
2055 .vecs =
2056 hmac_sha1_aes_cbc_enc_tv_temp,
2057 .count =
2058 HMAC_SHA1_AES_CBC_ENC_TEST_VEC
2059 }
2060 }
2061 }
2062 }, {
2063 .alg = "authenc(hmac(sha1),cbc(des))",
2064 .test = alg_test_aead,
2065 .suite = {
2066 .aead = {
2067 .enc = {
2068 .vecs =
2069 hmac_sha1_des_cbc_enc_tv_temp,
2070 .count =
2071 HMAC_SHA1_DES_CBC_ENC_TEST_VEC
2072 }
2073 }
2074 }
2075 }, {
2076 .alg = "authenc(hmac(sha1),cbc(des3_ede))",
2077 .test = alg_test_aead,
2078 .fips_allowed = 1,
2079 .suite = {
2080 .aead = {
2081 .enc = {
2082 .vecs =
2083 hmac_sha1_des3_ede_cbc_enc_tv_temp,
2084 .count =
2085 HMAC_SHA1_DES3_EDE_CBC_ENC_TEST_VEC
2086 }
2087 }
2088 }
2089 }, {
2090 .alg = "authenc(hmac(sha1),ctr(aes))",
2091 .test = alg_test_null,
2092 .fips_allowed = 1,
2093 }, {
2094 .alg = "authenc(hmac(sha1),ecb(cipher_null))",
2095 .test = alg_test_aead,
2096 .suite = {
2097 .aead = {
2098 .enc = {
2099 .vecs =
2100 hmac_sha1_ecb_cipher_null_enc_tv_temp,
2101 .count =
2102 HMAC_SHA1_ECB_CIPHER_NULL_ENC_TEST_VEC
2103 },
2104 .dec = {
2105 .vecs =
2106 hmac_sha1_ecb_cipher_null_dec_tv_temp,
2107 .count =
2108 HMAC_SHA1_ECB_CIPHER_NULL_DEC_TEST_VEC
2109 }
2110 }
2111 }
2112 }, {
2113 .alg = "authenc(hmac(sha1),rfc3686(ctr(aes)))",
2114 .test = alg_test_null,
2115 .fips_allowed = 1,
2116 }, {
2117 .alg = "authenc(hmac(sha224),cbc(des))",
2118 .test = alg_test_aead,
2119 .suite = {
2120 .aead = {
2121 .enc = {
2122 .vecs =
2123 hmac_sha224_des_cbc_enc_tv_temp,
2124 .count =
2125 HMAC_SHA224_DES_CBC_ENC_TEST_VEC
2126 }
2127 }
2128 }
2129 }, {
2130 .alg = "authenc(hmac(sha224),cbc(des3_ede))",
2131 .test = alg_test_aead,
2132 .fips_allowed = 1,
2133 .suite = {
2134 .aead = {
2135 .enc = {
2136 .vecs =
2137 hmac_sha224_des3_ede_cbc_enc_tv_temp,
2138 .count =
2139 HMAC_SHA224_DES3_EDE_CBC_ENC_TEST_VEC
2140 }
2141 }
2142 }
2143 }, {
2144 .alg = "authenc(hmac(sha256),cbc(aes))",
2145 .test = alg_test_aead,
2146 .fips_allowed = 1,
2147 .suite = {
2148 .aead = {
2149 .enc = {
2150 .vecs =
2151 hmac_sha256_aes_cbc_enc_tv_temp,
2152 .count =
2153 HMAC_SHA256_AES_CBC_ENC_TEST_VEC
2154 }
2155 }
2156 }
2157 }, {
2158 .alg = "authenc(hmac(sha256),cbc(des))",
2159 .test = alg_test_aead,
2160 .suite = {
2161 .aead = {
2162 .enc = {
2163 .vecs =
2164 hmac_sha256_des_cbc_enc_tv_temp,
2165 .count =
2166 HMAC_SHA256_DES_CBC_ENC_TEST_VEC
2167 }
2168 }
2169 }
2170 }, {
2171 .alg = "authenc(hmac(sha256),cbc(des3_ede))",
2172 .test = alg_test_aead,
2173 .fips_allowed = 1,
2174 .suite = {
2175 .aead = {
2176 .enc = {
2177 .vecs =
2178 hmac_sha256_des3_ede_cbc_enc_tv_temp,
2179 .count =
2180 HMAC_SHA256_DES3_EDE_CBC_ENC_TEST_VEC
2181 }
2182 }
2183 }
2184 }, {
2185 .alg = "authenc(hmac(sha256),ctr(aes))",
2186 .test = alg_test_null,
2187 .fips_allowed = 1,
2188 }, {
2189 .alg = "authenc(hmac(sha256),rfc3686(ctr(aes)))",
2190 .test = alg_test_null,
2191 .fips_allowed = 1,
2192 }, {
2193 .alg = "authenc(hmac(sha384),cbc(des))",
2194 .test = alg_test_aead,
2195 .suite = {
2196 .aead = {
2197 .enc = {
2198 .vecs =
2199 hmac_sha384_des_cbc_enc_tv_temp,
2200 .count =
2201 HMAC_SHA384_DES_CBC_ENC_TEST_VEC
2202 }
2203 }
2204 }
2205 }, {
2206 .alg = "authenc(hmac(sha384),cbc(des3_ede))",
2207 .test = alg_test_aead,
2208 .fips_allowed = 1,
2209 .suite = {
2210 .aead = {
2211 .enc = {
2212 .vecs =
2213 hmac_sha384_des3_ede_cbc_enc_tv_temp,
2214 .count =
2215 HMAC_SHA384_DES3_EDE_CBC_ENC_TEST_VEC
2216 }
2217 }
2218 }
2219 }, {
2220 .alg = "authenc(hmac(sha384),ctr(aes))",
2221 .test = alg_test_null,
2222 .fips_allowed = 1,
2223 }, {
2224 .alg = "authenc(hmac(sha384),rfc3686(ctr(aes)))",
2225 .test = alg_test_null,
2226 .fips_allowed = 1,
2227 }, {
2228 .alg = "authenc(hmac(sha512),cbc(aes))",
2229 .fips_allowed = 1,
2230 .test = alg_test_aead,
2231 .suite = {
2232 .aead = {
2233 .enc = {
2234 .vecs =
2235 hmac_sha512_aes_cbc_enc_tv_temp,
2236 .count =
2237 HMAC_SHA512_AES_CBC_ENC_TEST_VEC
2238 }
2239 }
2240 }
2241 }, {
2242 .alg = "authenc(hmac(sha512),cbc(des))",
2243 .test = alg_test_aead,
2244 .suite = {
2245 .aead = {
2246 .enc = {
2247 .vecs =
2248 hmac_sha512_des_cbc_enc_tv_temp,
2249 .count =
2250 HMAC_SHA512_DES_CBC_ENC_TEST_VEC
2251 }
2252 }
2253 }
2254 }, {
2255 .alg = "authenc(hmac(sha512),cbc(des3_ede))",
2256 .test = alg_test_aead,
2257 .fips_allowed = 1,
2258 .suite = {
2259 .aead = {
2260 .enc = {
2261 .vecs =
2262 hmac_sha512_des3_ede_cbc_enc_tv_temp,
2263 .count =
2264 HMAC_SHA512_DES3_EDE_CBC_ENC_TEST_VEC
2265 }
2266 }
2267 }
2268 }, {
2269 .alg = "authenc(hmac(sha512),ctr(aes))",
2270 .test = alg_test_null,
2271 .fips_allowed = 1,
2272 }, {
2273 .alg = "authenc(hmac(sha512),rfc3686(ctr(aes)))",
2274 .test = alg_test_null,
2275 .fips_allowed = 1,
2276 }, {
2277 .alg = "cbc(aes)",
2278 .test = alg_test_skcipher,
2279 .fips_allowed = 1,
2280 .suite = {
2281 .cipher = {
2282 .enc = {
2283 .vecs = aes_cbc_enc_tv_template,
2284 .count = AES_CBC_ENC_TEST_VECTORS
2285 },
2286 .dec = {
2287 .vecs = aes_cbc_dec_tv_template,
2288 .count = AES_CBC_DEC_TEST_VECTORS
2289 }
2290 }
2291 }
2292 }, {
2293 .alg = "cbc(anubis)",
2294 .test = alg_test_skcipher,
2295 .suite = {
2296 .cipher = {
2297 .enc = {
2298 .vecs = anubis_cbc_enc_tv_template,
2299 .count = ANUBIS_CBC_ENC_TEST_VECTORS
2300 },
2301 .dec = {
2302 .vecs = anubis_cbc_dec_tv_template,
2303 .count = ANUBIS_CBC_DEC_TEST_VECTORS
2304 }
2305 }
2306 }
2307 }, {
2308 .alg = "cbc(blowfish)",
2309 .test = alg_test_skcipher,
2310 .suite = {
2311 .cipher = {
2312 .enc = {
2313 .vecs = bf_cbc_enc_tv_template,
2314 .count = BF_CBC_ENC_TEST_VECTORS
2315 },
2316 .dec = {
2317 .vecs = bf_cbc_dec_tv_template,
2318 .count = BF_CBC_DEC_TEST_VECTORS
2319 }
2320 }
2321 }
2322 }, {
2323 .alg = "cbc(camellia)",
2324 .test = alg_test_skcipher,
2325 .suite = {
2326 .cipher = {
2327 .enc = {
2328 .vecs = camellia_cbc_enc_tv_template,
2329 .count = CAMELLIA_CBC_ENC_TEST_VECTORS
2330 },
2331 .dec = {
2332 .vecs = camellia_cbc_dec_tv_template,
2333 .count = CAMELLIA_CBC_DEC_TEST_VECTORS
2334 }
2335 }
2336 }
2337 }, {
2338 .alg = "cbc(cast5)",
2339 .test = alg_test_skcipher,
2340 .suite = {
2341 .cipher = {
2342 .enc = {
2343 .vecs = cast5_cbc_enc_tv_template,
2344 .count = CAST5_CBC_ENC_TEST_VECTORS
2345 },
2346 .dec = {
2347 .vecs = cast5_cbc_dec_tv_template,
2348 .count = CAST5_CBC_DEC_TEST_VECTORS
2349 }
2350 }
2351 }
2352 }, {
2353 .alg = "cbc(cast6)",
2354 .test = alg_test_skcipher,
2355 .suite = {
2356 .cipher = {
2357 .enc = {
2358 .vecs = cast6_cbc_enc_tv_template,
2359 .count = CAST6_CBC_ENC_TEST_VECTORS
2360 },
2361 .dec = {
2362 .vecs = cast6_cbc_dec_tv_template,
2363 .count = CAST6_CBC_DEC_TEST_VECTORS
2364 }
2365 }
2366 }
2367 }, {
2368 .alg = "cbc(des)",
2369 .test = alg_test_skcipher,
2370 .suite = {
2371 .cipher = {
2372 .enc = {
2373 .vecs = des_cbc_enc_tv_template,
2374 .count = DES_CBC_ENC_TEST_VECTORS
2375 },
2376 .dec = {
2377 .vecs = des_cbc_dec_tv_template,
2378 .count = DES_CBC_DEC_TEST_VECTORS
2379 }
2380 }
2381 }
2382 }, {
2383 .alg = "cbc(des3_ede)",
2384 .test = alg_test_skcipher,
2385 .fips_allowed = 1,
2386 .suite = {
2387 .cipher = {
2388 .enc = {
2389 .vecs = des3_ede_cbc_enc_tv_template,
2390 .count = DES3_EDE_CBC_ENC_TEST_VECTORS
2391 },
2392 .dec = {
2393 .vecs = des3_ede_cbc_dec_tv_template,
2394 .count = DES3_EDE_CBC_DEC_TEST_VECTORS
2395 }
2396 }
2397 }
2398 }, {
2399 .alg = "cbc(serpent)",
2400 .test = alg_test_skcipher,
2401 .suite = {
2402 .cipher = {
2403 .enc = {
2404 .vecs = serpent_cbc_enc_tv_template,
2405 .count = SERPENT_CBC_ENC_TEST_VECTORS
2406 },
2407 .dec = {
2408 .vecs = serpent_cbc_dec_tv_template,
2409 .count = SERPENT_CBC_DEC_TEST_VECTORS
2410 }
2411 }
2412 }
2413 }, {
2414 .alg = "cbc(twofish)",
2415 .test = alg_test_skcipher,
2416 .suite = {
2417 .cipher = {
2418 .enc = {
2419 .vecs = tf_cbc_enc_tv_template,
2420 .count = TF_CBC_ENC_TEST_VECTORS
2421 },
2422 .dec = {
2423 .vecs = tf_cbc_dec_tv_template,
2424 .count = TF_CBC_DEC_TEST_VECTORS
2425 }
2426 }
2427 }
2428 }, {
2429 .alg = "ccm(aes)",
2430 .test = alg_test_aead,
2431 .fips_allowed = 1,
2432 .suite = {
2433 .aead = {
2434 .enc = {
2435 .vecs = aes_ccm_enc_tv_template,
2436 .count = AES_CCM_ENC_TEST_VECTORS
2437 },
2438 .dec = {
2439 .vecs = aes_ccm_dec_tv_template,
2440 .count = AES_CCM_DEC_TEST_VECTORS
2441 }
2442 }
2443 }
2444 }, {
2445 .alg = "chacha20",
2446 .test = alg_test_skcipher,
2447 .suite = {
2448 .cipher = {
2449 .enc = {
2450 .vecs = chacha20_enc_tv_template,
2451 .count = CHACHA20_ENC_TEST_VECTORS
2452 },
2453 .dec = {
2454 .vecs = chacha20_enc_tv_template,
2455 .count = CHACHA20_ENC_TEST_VECTORS
2456 },
2457 }
2458 }
2459 }, {
2460 .alg = "cmac(aes)",
2461 .fips_allowed = 1,
2462 .test = alg_test_hash,
2463 .suite = {
2464 .hash = {
2465 .vecs = aes_cmac128_tv_template,
2466 .count = CMAC_AES_TEST_VECTORS
2467 }
2468 }
2469 }, {
2470 .alg = "cmac(des3_ede)",
2471 .fips_allowed = 1,
2472 .test = alg_test_hash,
2473 .suite = {
2474 .hash = {
2475 .vecs = des3_ede_cmac64_tv_template,
2476 .count = CMAC_DES3_EDE_TEST_VECTORS
2477 }
2478 }
2479 }, {
2480 .alg = "compress_null",
2481 .test = alg_test_null,
2482 }, {
2483 .alg = "crc32",
2484 .test = alg_test_hash,
2485 .suite = {
2486 .hash = {
2487 .vecs = crc32_tv_template,
2488 .count = CRC32_TEST_VECTORS
2489 }
2490 }
2491 }, {
2492 .alg = "crc32c",
2493 .test = alg_test_crc32c,
2494 .fips_allowed = 1,
2495 .suite = {
2496 .hash = {
2497 .vecs = crc32c_tv_template,
2498 .count = CRC32C_TEST_VECTORS
2499 }
2500 }
2501 }, {
2502 .alg = "crct10dif",
2503 .test = alg_test_hash,
2504 .fips_allowed = 1,
2505 .suite = {
2506 .hash = {
2507 .vecs = crct10dif_tv_template,
2508 .count = CRCT10DIF_TEST_VECTORS
2509 }
2510 }
2511 }, {
2512 .alg = "cryptd(__driver-cbc-aes-aesni)",
2513 .test = alg_test_null,
2514 .fips_allowed = 1,
2515 }, {
2516 .alg = "cryptd(__driver-cbc-camellia-aesni)",
2517 .test = alg_test_null,
2518 }, {
2519 .alg = "cryptd(__driver-cbc-camellia-aesni-avx2)",
2520 .test = alg_test_null,
2521 }, {
2522 .alg = "cryptd(__driver-cbc-serpent-avx2)",
2523 .test = alg_test_null,
2524 }, {
2525 .alg = "cryptd(__driver-ecb-aes-aesni)",
2526 .test = alg_test_null,
2527 .fips_allowed = 1,
2528 }, {
2529 .alg = "cryptd(__driver-ecb-camellia-aesni)",
2530 .test = alg_test_null,
2531 }, {
2532 .alg = "cryptd(__driver-ecb-camellia-aesni-avx2)",
2533 .test = alg_test_null,
2534 }, {
2535 .alg = "cryptd(__driver-ecb-cast5-avx)",
2536 .test = alg_test_null,
2537 }, {
2538 .alg = "cryptd(__driver-ecb-cast6-avx)",
2539 .test = alg_test_null,
2540 }, {
2541 .alg = "cryptd(__driver-ecb-serpent-avx)",
2542 .test = alg_test_null,
2543 }, {
2544 .alg = "cryptd(__driver-ecb-serpent-avx2)",
2545 .test = alg_test_null,
2546 }, {
2547 .alg = "cryptd(__driver-ecb-serpent-sse2)",
2548 .test = alg_test_null,
2549 }, {
2550 .alg = "cryptd(__driver-ecb-twofish-avx)",
2551 .test = alg_test_null,
2552 }, {
2553 .alg = "cryptd(__driver-gcm-aes-aesni)",
2554 .test = alg_test_null,
2555 .fips_allowed = 1,
2556 }, {
2557 .alg = "cryptd(__ghash-pclmulqdqni)",
2558 .test = alg_test_null,
2559 .fips_allowed = 1,
2560 }, {
2561 .alg = "ctr(aes)",
2562 .test = alg_test_skcipher,
2563 .fips_allowed = 1,
2564 .suite = {
2565 .cipher = {
2566 .enc = {
2567 .vecs = aes_ctr_enc_tv_template,
2568 .count = AES_CTR_ENC_TEST_VECTORS
2569 },
2570 .dec = {
2571 .vecs = aes_ctr_dec_tv_template,
2572 .count = AES_CTR_DEC_TEST_VECTORS
2573 }
2574 }
2575 }
2576 }, {
2577 .alg = "ctr(blowfish)",
2578 .test = alg_test_skcipher,
2579 .suite = {
2580 .cipher = {
2581 .enc = {
2582 .vecs = bf_ctr_enc_tv_template,
2583 .count = BF_CTR_ENC_TEST_VECTORS
2584 },
2585 .dec = {
2586 .vecs = bf_ctr_dec_tv_template,
2587 .count = BF_CTR_DEC_TEST_VECTORS
2588 }
2589 }
2590 }
2591 }, {
2592 .alg = "ctr(camellia)",
2593 .test = alg_test_skcipher,
2594 .suite = {
2595 .cipher = {
2596 .enc = {
2597 .vecs = camellia_ctr_enc_tv_template,
2598 .count = CAMELLIA_CTR_ENC_TEST_VECTORS
2599 },
2600 .dec = {
2601 .vecs = camellia_ctr_dec_tv_template,
2602 .count = CAMELLIA_CTR_DEC_TEST_VECTORS
2603 }
2604 }
2605 }
2606 }, {
2607 .alg = "ctr(cast5)",
2608 .test = alg_test_skcipher,
2609 .suite = {
2610 .cipher = {
2611 .enc = {
2612 .vecs = cast5_ctr_enc_tv_template,
2613 .count = CAST5_CTR_ENC_TEST_VECTORS
2614 },
2615 .dec = {
2616 .vecs = cast5_ctr_dec_tv_template,
2617 .count = CAST5_CTR_DEC_TEST_VECTORS
2618 }
2619 }
2620 }
2621 }, {
2622 .alg = "ctr(cast6)",
2623 .test = alg_test_skcipher,
2624 .suite = {
2625 .cipher = {
2626 .enc = {
2627 .vecs = cast6_ctr_enc_tv_template,
2628 .count = CAST6_CTR_ENC_TEST_VECTORS
2629 },
2630 .dec = {
2631 .vecs = cast6_ctr_dec_tv_template,
2632 .count = CAST6_CTR_DEC_TEST_VECTORS
2633 }
2634 }
2635 }
2636 }, {
2637 .alg = "ctr(des)",
2638 .test = alg_test_skcipher,
2639 .suite = {
2640 .cipher = {
2641 .enc = {
2642 .vecs = des_ctr_enc_tv_template,
2643 .count = DES_CTR_ENC_TEST_VECTORS
2644 },
2645 .dec = {
2646 .vecs = des_ctr_dec_tv_template,
2647 .count = DES_CTR_DEC_TEST_VECTORS
2648 }
2649 }
2650 }
2651 }, {
2652 .alg = "ctr(des3_ede)",
2653 .test = alg_test_skcipher,
2654 .suite = {
2655 .cipher = {
2656 .enc = {
2657 .vecs = des3_ede_ctr_enc_tv_template,
2658 .count = DES3_EDE_CTR_ENC_TEST_VECTORS
2659 },
2660 .dec = {
2661 .vecs = des3_ede_ctr_dec_tv_template,
2662 .count = DES3_EDE_CTR_DEC_TEST_VECTORS
2663 }
2664 }
2665 }
2666 }, {
2667 .alg = "ctr(serpent)",
2668 .test = alg_test_skcipher,
2669 .suite = {
2670 .cipher = {
2671 .enc = {
2672 .vecs = serpent_ctr_enc_tv_template,
2673 .count = SERPENT_CTR_ENC_TEST_VECTORS
2674 },
2675 .dec = {
2676 .vecs = serpent_ctr_dec_tv_template,
2677 .count = SERPENT_CTR_DEC_TEST_VECTORS
2678 }
2679 }
2680 }
2681 }, {
2682 .alg = "ctr(twofish)",
2683 .test = alg_test_skcipher,
2684 .suite = {
2685 .cipher = {
2686 .enc = {
2687 .vecs = tf_ctr_enc_tv_template,
2688 .count = TF_CTR_ENC_TEST_VECTORS
2689 },
2690 .dec = {
2691 .vecs = tf_ctr_dec_tv_template,
2692 .count = TF_CTR_DEC_TEST_VECTORS
2693 }
2694 }
2695 }
2696 }, {
2697 .alg = "cts(cbc(aes))",
2698 .test = alg_test_skcipher,
2699 .suite = {
2700 .cipher = {
2701 .enc = {
2702 .vecs = cts_mode_enc_tv_template,
2703 .count = CTS_MODE_ENC_TEST_VECTORS
2704 },
2705 .dec = {
2706 .vecs = cts_mode_dec_tv_template,
2707 .count = CTS_MODE_DEC_TEST_VECTORS
2708 }
2709 }
2710 }
2711 }, {
2712 .alg = "deflate",
2713 .test = alg_test_comp,
2714 .fips_allowed = 1,
2715 .suite = {
2716 .comp = {
2717 .comp = {
2718 .vecs = deflate_comp_tv_template,
2719 .count = DEFLATE_COMP_TEST_VECTORS
2720 },
2721 .decomp = {
2722 .vecs = deflate_decomp_tv_template,
2723 .count = DEFLATE_DECOMP_TEST_VECTORS
2724 }
2725 }
2726 }
2727 }, {
2728 .alg = "digest_null",
2729 .test = alg_test_null,
2730 }, {
2731 .alg = "drbg_nopr_ctr_aes128",
2732 .test = alg_test_drbg,
2733 .fips_allowed = 1,
2734 .suite = {
2735 .drbg = {
2736 .vecs = drbg_nopr_ctr_aes128_tv_template,
2737 .count = ARRAY_SIZE(drbg_nopr_ctr_aes128_tv_template)
2738 }
2739 }
2740 }, {
2741 .alg = "drbg_nopr_ctr_aes192",
2742 .test = alg_test_drbg,
2743 .fips_allowed = 1,
2744 .suite = {
2745 .drbg = {
2746 .vecs = drbg_nopr_ctr_aes192_tv_template,
2747 .count = ARRAY_SIZE(drbg_nopr_ctr_aes192_tv_template)
2748 }
2749 }
2750 }, {
2751 .alg = "drbg_nopr_ctr_aes256",
2752 .test = alg_test_drbg,
2753 .fips_allowed = 1,
2754 .suite = {
2755 .drbg = {
2756 .vecs = drbg_nopr_ctr_aes256_tv_template,
2757 .count = ARRAY_SIZE(drbg_nopr_ctr_aes256_tv_template)
2758 }
2759 }
2760 }, {
2761 /*
2762 * There is no need to specifically test the DRBG with every
2763 * backend cipher -- covered by drbg_nopr_hmac_sha256 test
2764 */
2765 .alg = "drbg_nopr_hmac_sha1",
2766 .fips_allowed = 1,
2767 .test = alg_test_null,
2768 }, {
2769 .alg = "drbg_nopr_hmac_sha256",
2770 .test = alg_test_drbg,
2771 .fips_allowed = 1,
2772 .suite = {
2773 .drbg = {
2774 .vecs = drbg_nopr_hmac_sha256_tv_template,
2775 .count =
2776 ARRAY_SIZE(drbg_nopr_hmac_sha256_tv_template)
2777 }
2778 }
2779 }, {
2780 /* covered by drbg_nopr_hmac_sha256 test */
2781 .alg = "drbg_nopr_hmac_sha384",
2782 .fips_allowed = 1,
2783 .test = alg_test_null,
2784 }, {
2785 .alg = "drbg_nopr_hmac_sha512",
2786 .test = alg_test_null,
2787 .fips_allowed = 1,
2788 }, {
2789 .alg = "drbg_nopr_sha1",
2790 .fips_allowed = 1,
2791 .test = alg_test_null,
2792 }, {
2793 .alg = "drbg_nopr_sha256",
2794 .test = alg_test_drbg,
2795 .fips_allowed = 1,
2796 .suite = {
2797 .drbg = {
2798 .vecs = drbg_nopr_sha256_tv_template,
2799 .count = ARRAY_SIZE(drbg_nopr_sha256_tv_template)
2800 }
2801 }
2802 }, {
2803 /* covered by drbg_nopr_sha256 test */
2804 .alg = "drbg_nopr_sha384",
2805 .fips_allowed = 1,
2806 .test = alg_test_null,
2807 }, {
2808 .alg = "drbg_nopr_sha512",
2809 .fips_allowed = 1,
2810 .test = alg_test_null,
2811 }, {
2812 .alg = "drbg_pr_ctr_aes128",
2813 .test = alg_test_drbg,
2814 .fips_allowed = 1,
2815 .suite = {
2816 .drbg = {
2817 .vecs = drbg_pr_ctr_aes128_tv_template,
2818 .count = ARRAY_SIZE(drbg_pr_ctr_aes128_tv_template)
2819 }
2820 }
2821 }, {
2822 /* covered by drbg_pr_ctr_aes128 test */
2823 .alg = "drbg_pr_ctr_aes192",
2824 .fips_allowed = 1,
2825 .test = alg_test_null,
2826 }, {
2827 .alg = "drbg_pr_ctr_aes256",
2828 .fips_allowed = 1,
2829 .test = alg_test_null,
2830 }, {
2831 .alg = "drbg_pr_hmac_sha1",
2832 .fips_allowed = 1,
2833 .test = alg_test_null,
2834 }, {
2835 .alg = "drbg_pr_hmac_sha256",
2836 .test = alg_test_drbg,
2837 .fips_allowed = 1,
2838 .suite = {
2839 .drbg = {
2840 .vecs = drbg_pr_hmac_sha256_tv_template,
2841 .count = ARRAY_SIZE(drbg_pr_hmac_sha256_tv_template)
2842 }
2843 }
2844 }, {
2845 /* covered by drbg_pr_hmac_sha256 test */
2846 .alg = "drbg_pr_hmac_sha384",
2847 .fips_allowed = 1,
2848 .test = alg_test_null,
2849 }, {
2850 .alg = "drbg_pr_hmac_sha512",
2851 .test = alg_test_null,
2852 .fips_allowed = 1,
2853 }, {
2854 .alg = "drbg_pr_sha1",
2855 .fips_allowed = 1,
2856 .test = alg_test_null,
2857 }, {
2858 .alg = "drbg_pr_sha256",
2859 .test = alg_test_drbg,
2860 .fips_allowed = 1,
2861 .suite = {
2862 .drbg = {
2863 .vecs = drbg_pr_sha256_tv_template,
2864 .count = ARRAY_SIZE(drbg_pr_sha256_tv_template)
2865 }
2866 }
2867 }, {
2868 /* covered by drbg_pr_sha256 test */
2869 .alg = "drbg_pr_sha384",
2870 .fips_allowed = 1,
2871 .test = alg_test_null,
2872 }, {
2873 .alg = "drbg_pr_sha512",
2874 .fips_allowed = 1,
2875 .test = alg_test_null,
2876 }, {
2877 .alg = "ecb(__aes-aesni)",
2878 .test = alg_test_null,
2879 .fips_allowed = 1,
2880 }, {
2881 .alg = "ecb(aes)",
2882 .test = alg_test_skcipher,
2883 .fips_allowed = 1,
2884 .suite = {
2885 .cipher = {
2886 .enc = {
2887 .vecs = aes_enc_tv_template,
2888 .count = AES_ENC_TEST_VECTORS
2889 },
2890 .dec = {
2891 .vecs = aes_dec_tv_template,
2892 .count = AES_DEC_TEST_VECTORS
2893 }
2894 }
2895 }
2896 }, {
2897 .alg = "ecb(anubis)",
2898 .test = alg_test_skcipher,
2899 .suite = {
2900 .cipher = {
2901 .enc = {
2902 .vecs = anubis_enc_tv_template,
2903 .count = ANUBIS_ENC_TEST_VECTORS
2904 },
2905 .dec = {
2906 .vecs = anubis_dec_tv_template,
2907 .count = ANUBIS_DEC_TEST_VECTORS
2908 }
2909 }
2910 }
2911 }, {
2912 .alg = "ecb(arc4)",
2913 .test = alg_test_skcipher,
2914 .suite = {
2915 .cipher = {
2916 .enc = {
2917 .vecs = arc4_enc_tv_template,
2918 .count = ARC4_ENC_TEST_VECTORS
2919 },
2920 .dec = {
2921 .vecs = arc4_dec_tv_template,
2922 .count = ARC4_DEC_TEST_VECTORS
2923 }
2924 }
2925 }
2926 }, {
2927 .alg = "ecb(blowfish)",
2928 .test = alg_test_skcipher,
2929 .suite = {
2930 .cipher = {
2931 .enc = {
2932 .vecs = bf_enc_tv_template,
2933 .count = BF_ENC_TEST_VECTORS
2934 },
2935 .dec = {
2936 .vecs = bf_dec_tv_template,
2937 .count = BF_DEC_TEST_VECTORS
2938 }
2939 }
2940 }
2941 }, {
2942 .alg = "ecb(camellia)",
2943 .test = alg_test_skcipher,
2944 .suite = {
2945 .cipher = {
2946 .enc = {
2947 .vecs = camellia_enc_tv_template,
2948 .count = CAMELLIA_ENC_TEST_VECTORS
2949 },
2950 .dec = {
2951 .vecs = camellia_dec_tv_template,
2952 .count = CAMELLIA_DEC_TEST_VECTORS
2953 }
2954 }
2955 }
2956 }, {
2957 .alg = "ecb(cast5)",
2958 .test = alg_test_skcipher,
2959 .suite = {
2960 .cipher = {
2961 .enc = {
2962 .vecs = cast5_enc_tv_template,
2963 .count = CAST5_ENC_TEST_VECTORS
2964 },
2965 .dec = {
2966 .vecs = cast5_dec_tv_template,
2967 .count = CAST5_DEC_TEST_VECTORS
2968 }
2969 }
2970 }
2971 }, {
2972 .alg = "ecb(cast6)",
2973 .test = alg_test_skcipher,
2974 .suite = {
2975 .cipher = {
2976 .enc = {
2977 .vecs = cast6_enc_tv_template,
2978 .count = CAST6_ENC_TEST_VECTORS
2979 },
2980 .dec = {
2981 .vecs = cast6_dec_tv_template,
2982 .count = CAST6_DEC_TEST_VECTORS
2983 }
2984 }
2985 }
2986 }, {
2987 .alg = "ecb(cipher_null)",
2988 .test = alg_test_null,
2989 }, {
2990 .alg = "ecb(des)",
2991 .test = alg_test_skcipher,
2992 .suite = {
2993 .cipher = {
2994 .enc = {
2995 .vecs = des_enc_tv_template,
2996 .count = DES_ENC_TEST_VECTORS
2997 },
2998 .dec = {
2999 .vecs = des_dec_tv_template,
3000 .count = DES_DEC_TEST_VECTORS
3001 }
3002 }
3003 }
3004 }, {
3005 .alg = "ecb(des3_ede)",
3006 .test = alg_test_skcipher,
3007 .fips_allowed = 1,
3008 .suite = {
3009 .cipher = {
3010 .enc = {
3011 .vecs = des3_ede_enc_tv_template,
3012 .count = DES3_EDE_ENC_TEST_VECTORS
3013 },
3014 .dec = {
3015 .vecs = des3_ede_dec_tv_template,
3016 .count = DES3_EDE_DEC_TEST_VECTORS
3017 }
3018 }
3019 }
3020 }, {
3021 .alg = "ecb(fcrypt)",
3022 .test = alg_test_skcipher,
3023 .suite = {
3024 .cipher = {
3025 .enc = {
3026 .vecs = fcrypt_pcbc_enc_tv_template,
3027 .count = 1
3028 },
3029 .dec = {
3030 .vecs = fcrypt_pcbc_dec_tv_template,
3031 .count = 1
3032 }
3033 }
3034 }
3035 }, {
3036 .alg = "ecb(khazad)",
3037 .test = alg_test_skcipher,
3038 .suite = {
3039 .cipher = {
3040 .enc = {
3041 .vecs = khazad_enc_tv_template,
3042 .count = KHAZAD_ENC_TEST_VECTORS
3043 },
3044 .dec = {
3045 .vecs = khazad_dec_tv_template,
3046 .count = KHAZAD_DEC_TEST_VECTORS
3047 }
3048 }
3049 }
3050 }, {
3051 .alg = "ecb(seed)",
3052 .test = alg_test_skcipher,
3053 .suite = {
3054 .cipher = {
3055 .enc = {
3056 .vecs = seed_enc_tv_template,
3057 .count = SEED_ENC_TEST_VECTORS
3058 },
3059 .dec = {
3060 .vecs = seed_dec_tv_template,
3061 .count = SEED_DEC_TEST_VECTORS
3062 }
3063 }
3064 }
3065 }, {
3066 .alg = "ecb(serpent)",
3067 .test = alg_test_skcipher,
3068 .suite = {
3069 .cipher = {
3070 .enc = {
3071 .vecs = serpent_enc_tv_template,
3072 .count = SERPENT_ENC_TEST_VECTORS
3073 },
3074 .dec = {
3075 .vecs = serpent_dec_tv_template,
3076 .count = SERPENT_DEC_TEST_VECTORS
3077 }
3078 }
3079 }
3080 }, {
3081 .alg = "ecb(tea)",
3082 .test = alg_test_skcipher,
3083 .suite = {
3084 .cipher = {
3085 .enc = {
3086 .vecs = tea_enc_tv_template,
3087 .count = TEA_ENC_TEST_VECTORS
3088 },
3089 .dec = {
3090 .vecs = tea_dec_tv_template,
3091 .count = TEA_DEC_TEST_VECTORS
3092 }
3093 }
3094 }
3095 }, {
3096 .alg = "ecb(tnepres)",
3097 .test = alg_test_skcipher,
3098 .suite = {
3099 .cipher = {
3100 .enc = {
3101 .vecs = tnepres_enc_tv_template,
3102 .count = TNEPRES_ENC_TEST_VECTORS
3103 },
3104 .dec = {
3105 .vecs = tnepres_dec_tv_template,
3106 .count = TNEPRES_DEC_TEST_VECTORS
3107 }
3108 }
3109 }
3110 }, {
3111 .alg = "ecb(twofish)",
3112 .test = alg_test_skcipher,
3113 .suite = {
3114 .cipher = {
3115 .enc = {
3116 .vecs = tf_enc_tv_template,
3117 .count = TF_ENC_TEST_VECTORS
3118 },
3119 .dec = {
3120 .vecs = tf_dec_tv_template,
3121 .count = TF_DEC_TEST_VECTORS
3122 }
3123 }
3124 }
3125 }, {
3126 .alg = "ecb(xeta)",
3127 .test = alg_test_skcipher,
3128 .suite = {
3129 .cipher = {
3130 .enc = {
3131 .vecs = xeta_enc_tv_template,
3132 .count = XETA_ENC_TEST_VECTORS
3133 },
3134 .dec = {
3135 .vecs = xeta_dec_tv_template,
3136 .count = XETA_DEC_TEST_VECTORS
3137 }
3138 }
3139 }
3140 }, {
3141 .alg = "ecb(xtea)",
3142 .test = alg_test_skcipher,
3143 .suite = {
3144 .cipher = {
3145 .enc = {
3146 .vecs = xtea_enc_tv_template,
3147 .count = XTEA_ENC_TEST_VECTORS
3148 },
3149 .dec = {
3150 .vecs = xtea_dec_tv_template,
3151 .count = XTEA_DEC_TEST_VECTORS
3152 }
3153 }
3154 }
3155 }, {
3156 .alg = "gcm(aes)",
3157 .test = alg_test_aead,
3158 .fips_allowed = 1,
3159 .suite = {
3160 .aead = {
3161 .enc = {
3162 .vecs = aes_gcm_enc_tv_template,
3163 .count = AES_GCM_ENC_TEST_VECTORS
3164 },
3165 .dec = {
3166 .vecs = aes_gcm_dec_tv_template,
3167 .count = AES_GCM_DEC_TEST_VECTORS
3168 }
3169 }
3170 }
3171 }, {
3172 .alg = "ghash",
3173 .test = alg_test_hash,
3174 .fips_allowed = 1,
3175 .suite = {
3176 .hash = {
3177 .vecs = ghash_tv_template,
3178 .count = GHASH_TEST_VECTORS
3179 }
3180 }
3181 }, {
3182 .alg = "hmac(crc32)",
3183 .test = alg_test_hash,
3184 .suite = {
3185 .hash = {
3186 .vecs = bfin_crc_tv_template,
3187 .count = BFIN_CRC_TEST_VECTORS
3188 }
3189 }
3190 }, {
3191 .alg = "hmac(md5)",
3192 .test = alg_test_hash,
3193 .suite = {
3194 .hash = {
3195 .vecs = hmac_md5_tv_template,
3196 .count = HMAC_MD5_TEST_VECTORS
3197 }
3198 }
3199 }, {
3200 .alg = "hmac(rmd128)",
3201 .test = alg_test_hash,
3202 .suite = {
3203 .hash = {
3204 .vecs = hmac_rmd128_tv_template,
3205 .count = HMAC_RMD128_TEST_VECTORS
3206 }
3207 }
3208 }, {
3209 .alg = "hmac(rmd160)",
3210 .test = alg_test_hash,
3211 .suite = {
3212 .hash = {
3213 .vecs = hmac_rmd160_tv_template,
3214 .count = HMAC_RMD160_TEST_VECTORS
3215 }
3216 }
3217 }, {
3218 .alg = "hmac(sha1)",
3219 .test = alg_test_hash,
3220 .fips_allowed = 1,
3221 .suite = {
3222 .hash = {
3223 .vecs = hmac_sha1_tv_template,
3224 .count = HMAC_SHA1_TEST_VECTORS
3225 }
3226 }
3227 }, {
3228 .alg = "hmac(sha224)",
3229 .test = alg_test_hash,
3230 .fips_allowed = 1,
3231 .suite = {
3232 .hash = {
3233 .vecs = hmac_sha224_tv_template,
3234 .count = HMAC_SHA224_TEST_VECTORS
3235 }
3236 }
3237 }, {
3238 .alg = "hmac(sha256)",
3239 .test = alg_test_hash,
3240 .fips_allowed = 1,
3241 .suite = {
3242 .hash = {
3243 .vecs = hmac_sha256_tv_template,
3244 .count = HMAC_SHA256_TEST_VECTORS
3245 }
3246 }
3247 }, {
3248 .alg = "hmac(sha384)",
3249 .test = alg_test_hash,
3250 .fips_allowed = 1,
3251 .suite = {
3252 .hash = {
3253 .vecs = hmac_sha384_tv_template,
3254 .count = HMAC_SHA384_TEST_VECTORS
3255 }
3256 }
3257 }, {
3258 .alg = "hmac(sha512)",
3259 .test = alg_test_hash,
3260 .fips_allowed = 1,
3261 .suite = {
3262 .hash = {
3263 .vecs = hmac_sha512_tv_template,
3264 .count = HMAC_SHA512_TEST_VECTORS
3265 }
3266 }
3267 }, {
3268 .alg = "jitterentropy_rng",
3269 .fips_allowed = 1,
3270 .test = alg_test_null,
3271 }, {
3272 .alg = "kw(aes)",
3273 .test = alg_test_skcipher,
3274 .fips_allowed = 1,
3275 .suite = {
3276 .cipher = {
3277 .enc = {
3278 .vecs = aes_kw_enc_tv_template,
3279 .count = ARRAY_SIZE(aes_kw_enc_tv_template)
3280 },
3281 .dec = {
3282 .vecs = aes_kw_dec_tv_template,
3283 .count = ARRAY_SIZE(aes_kw_dec_tv_template)
3284 }
3285 }
3286 }
3287 }, {
3288 .alg = "lrw(aes)",
3289 .test = alg_test_skcipher,
3290 .suite = {
3291 .cipher = {
3292 .enc = {
3293 .vecs = aes_lrw_enc_tv_template,
3294 .count = AES_LRW_ENC_TEST_VECTORS
3295 },
3296 .dec = {
3297 .vecs = aes_lrw_dec_tv_template,
3298 .count = AES_LRW_DEC_TEST_VECTORS
3299 }
3300 }
3301 }
3302 }, {
3303 .alg = "lrw(camellia)",
3304 .test = alg_test_skcipher,
3305 .suite = {
3306 .cipher = {
3307 .enc = {
3308 .vecs = camellia_lrw_enc_tv_template,
3309 .count = CAMELLIA_LRW_ENC_TEST_VECTORS
3310 },
3311 .dec = {
3312 .vecs = camellia_lrw_dec_tv_template,
3313 .count = CAMELLIA_LRW_DEC_TEST_VECTORS
3314 }
3315 }
3316 }
3317 }, {
3318 .alg = "lrw(cast6)",
3319 .test = alg_test_skcipher,
3320 .suite = {
3321 .cipher = {
3322 .enc = {
3323 .vecs = cast6_lrw_enc_tv_template,
3324 .count = CAST6_LRW_ENC_TEST_VECTORS
3325 },
3326 .dec = {
3327 .vecs = cast6_lrw_dec_tv_template,
3328 .count = CAST6_LRW_DEC_TEST_VECTORS
3329 }
3330 }
3331 }
3332 }, {
3333 .alg = "lrw(serpent)",
3334 .test = alg_test_skcipher,
3335 .suite = {
3336 .cipher = {
3337 .enc = {
3338 .vecs = serpent_lrw_enc_tv_template,
3339 .count = SERPENT_LRW_ENC_TEST_VECTORS
3340 },
3341 .dec = {
3342 .vecs = serpent_lrw_dec_tv_template,
3343 .count = SERPENT_LRW_DEC_TEST_VECTORS
3344 }
3345 }
3346 }
3347 }, {
3348 .alg = "lrw(twofish)",
3349 .test = alg_test_skcipher,
3350 .suite = {
3351 .cipher = {
3352 .enc = {
3353 .vecs = tf_lrw_enc_tv_template,
3354 .count = TF_LRW_ENC_TEST_VECTORS
3355 },
3356 .dec = {
3357 .vecs = tf_lrw_dec_tv_template,
3358 .count = TF_LRW_DEC_TEST_VECTORS
3359 }
3360 }
3361 }
3362 }, {
3363 .alg = "lz4",
3364 .test = alg_test_comp,
3365 .fips_allowed = 1,
3366 .suite = {
3367 .comp = {
3368 .comp = {
3369 .vecs = lz4_comp_tv_template,
3370 .count = LZ4_COMP_TEST_VECTORS
3371 },
3372 .decomp = {
3373 .vecs = lz4_decomp_tv_template,
3374 .count = LZ4_DECOMP_TEST_VECTORS
3375 }
3376 }
3377 }
3378 }, {
3379 .alg = "lz4hc",
3380 .test = alg_test_comp,
3381 .fips_allowed = 1,
3382 .suite = {
3383 .comp = {
3384 .comp = {
3385 .vecs = lz4hc_comp_tv_template,
3386 .count = LZ4HC_COMP_TEST_VECTORS
3387 },
3388 .decomp = {
3389 .vecs = lz4hc_decomp_tv_template,
3390 .count = LZ4HC_DECOMP_TEST_VECTORS
3391 }
3392 }
3393 }
3394 }, {
3395 .alg = "lzo",
3396 .test = alg_test_comp,
3397 .fips_allowed = 1,
3398 .suite = {
3399 .comp = {
3400 .comp = {
3401 .vecs = lzo_comp_tv_template,
3402 .count = LZO_COMP_TEST_VECTORS
3403 },
3404 .decomp = {
3405 .vecs = lzo_decomp_tv_template,
3406 .count = LZO_DECOMP_TEST_VECTORS
3407 }
3408 }
3409 }
3410 }, {
3411 .alg = "md4",
3412 .test = alg_test_hash,
3413 .suite = {
3414 .hash = {
3415 .vecs = md4_tv_template,
3416 .count = MD4_TEST_VECTORS
3417 }
3418 }
3419 }, {
3420 .alg = "md5",
3421 .test = alg_test_hash,
3422 .suite = {
3423 .hash = {
3424 .vecs = md5_tv_template,
3425 .count = MD5_TEST_VECTORS
3426 }
3427 }
3428 }, {
3429 .alg = "michael_mic",
3430 .test = alg_test_hash,
3431 .suite = {
3432 .hash = {
3433 .vecs = michael_mic_tv_template,
3434 .count = MICHAEL_MIC_TEST_VECTORS
3435 }
3436 }
3437 }, {
3438 .alg = "ofb(aes)",
3439 .test = alg_test_skcipher,
3440 .fips_allowed = 1,
3441 .suite = {
3442 .cipher = {
3443 .enc = {
3444 .vecs = aes_ofb_enc_tv_template,
3445 .count = AES_OFB_ENC_TEST_VECTORS
3446 },
3447 .dec = {
3448 .vecs = aes_ofb_dec_tv_template,
3449 .count = AES_OFB_DEC_TEST_VECTORS
3450 }
3451 }
3452 }
3453 }, {
3454 .alg = "pcbc(fcrypt)",
3455 .test = alg_test_skcipher,
3456 .suite = {
3457 .cipher = {
3458 .enc = {
3459 .vecs = fcrypt_pcbc_enc_tv_template,
3460 .count = FCRYPT_ENC_TEST_VECTORS
3461 },
3462 .dec = {
3463 .vecs = fcrypt_pcbc_dec_tv_template,
3464 .count = FCRYPT_DEC_TEST_VECTORS
3465 }
3466 }
3467 }
3468 }, {
3469 .alg = "poly1305",
3470 .test = alg_test_hash,
3471 .suite = {
3472 .hash = {
3473 .vecs = poly1305_tv_template,
3474 .count = POLY1305_TEST_VECTORS
3475 }
3476 }
3477 }, {
3478 .alg = "rfc3686(ctr(aes))",
3479 .test = alg_test_skcipher,
3480 .fips_allowed = 1,
3481 .suite = {
3482 .cipher = {
3483 .enc = {
3484 .vecs = aes_ctr_rfc3686_enc_tv_template,
3485 .count = AES_CTR_3686_ENC_TEST_VECTORS
3486 },
3487 .dec = {
3488 .vecs = aes_ctr_rfc3686_dec_tv_template,
3489 .count = AES_CTR_3686_DEC_TEST_VECTORS
3490 }
3491 }
3492 }
3493 }, {
3494 .alg = "rfc4106(gcm(aes))",
3495 .test = alg_test_aead,
3496 .fips_allowed = 1,
3497 .suite = {
3498 .aead = {
3499 .enc = {
3500 .vecs = aes_gcm_rfc4106_enc_tv_template,
3501 .count = AES_GCM_4106_ENC_TEST_VECTORS
3502 },
3503 .dec = {
3504 .vecs = aes_gcm_rfc4106_dec_tv_template,
3505 .count = AES_GCM_4106_DEC_TEST_VECTORS
3506 }
3507 }
3508 }
3509 }, {
3510 .alg = "rfc4309(ccm(aes))",
3511 .test = alg_test_aead,
3512 .fips_allowed = 1,
3513 .suite = {
3514 .aead = {
3515 .enc = {
3516 .vecs = aes_ccm_rfc4309_enc_tv_template,
3517 .count = AES_CCM_4309_ENC_TEST_VECTORS
3518 },
3519 .dec = {
3520 .vecs = aes_ccm_rfc4309_dec_tv_template,
3521 .count = AES_CCM_4309_DEC_TEST_VECTORS
3522 }
3523 }
3524 }
3525 }, {
3526 .alg = "rfc4543(gcm(aes))",
3527 .test = alg_test_aead,
3528 .suite = {
3529 .aead = {
3530 .enc = {
3531 .vecs = aes_gcm_rfc4543_enc_tv_template,
3532 .count = AES_GCM_4543_ENC_TEST_VECTORS
3533 },
3534 .dec = {
3535 .vecs = aes_gcm_rfc4543_dec_tv_template,
3536 .count = AES_GCM_4543_DEC_TEST_VECTORS
3537 },
3538 }
3539 }
3540 }, {
3541 .alg = "rfc7539(chacha20,poly1305)",
3542 .test = alg_test_aead,
3543 .suite = {
3544 .aead = {
3545 .enc = {
3546 .vecs = rfc7539_enc_tv_template,
3547 .count = RFC7539_ENC_TEST_VECTORS
3548 },
3549 .dec = {
3550 .vecs = rfc7539_dec_tv_template,
3551 .count = RFC7539_DEC_TEST_VECTORS
3552 },
3553 }
3554 }
3555 }, {
3556 .alg = "rfc7539esp(chacha20,poly1305)",
3557 .test = alg_test_aead,
3558 .suite = {
3559 .aead = {
3560 .enc = {
3561 .vecs = rfc7539esp_enc_tv_template,
3562 .count = RFC7539ESP_ENC_TEST_VECTORS
3563 },
3564 .dec = {
3565 .vecs = rfc7539esp_dec_tv_template,
3566 .count = RFC7539ESP_DEC_TEST_VECTORS
3567 },
3568 }
3569 }
3570 }, {
3571 .alg = "rmd128",
3572 .test = alg_test_hash,
3573 .suite = {
3574 .hash = {
3575 .vecs = rmd128_tv_template,
3576 .count = RMD128_TEST_VECTORS
3577 }
3578 }
3579 }, {
3580 .alg = "rmd160",
3581 .test = alg_test_hash,
3582 .suite = {
3583 .hash = {
3584 .vecs = rmd160_tv_template,
3585 .count = RMD160_TEST_VECTORS
3586 }
3587 }
3588 }, {
3589 .alg = "rmd256",
3590 .test = alg_test_hash,
3591 .suite = {
3592 .hash = {
3593 .vecs = rmd256_tv_template,
3594 .count = RMD256_TEST_VECTORS
3595 }
3596 }
3597 }, {
3598 .alg = "rmd320",
3599 .test = alg_test_hash,
3600 .suite = {
3601 .hash = {
3602 .vecs = rmd320_tv_template,
3603 .count = RMD320_TEST_VECTORS
3604 }
3605 }
3606 }, {
3607 .alg = "rsa",
3608 .test = alg_test_akcipher,
3609 .fips_allowed = 1,
3610 .suite = {
3611 .akcipher = {
3612 .vecs = rsa_tv_template,
3613 .count = RSA_TEST_VECTORS
3614 }
3615 }
3616 }, {
3617 .alg = "salsa20",
3618 .test = alg_test_skcipher,
3619 .suite = {
3620 .cipher = {
3621 .enc = {
3622 .vecs = salsa20_stream_enc_tv_template,
3623 .count = SALSA20_STREAM_ENC_TEST_VECTORS
3624 }
3625 }
3626 }
3627 }, {
3628 .alg = "sha1",
3629 .test = alg_test_hash,
3630 .fips_allowed = 1,
3631 .suite = {
3632 .hash = {
3633 .vecs = sha1_tv_template,
3634 .count = SHA1_TEST_VECTORS
3635 }
3636 }
3637 }, {
3638 .alg = "sha224",
3639 .test = alg_test_hash,
3640 .fips_allowed = 1,
3641 .suite = {
3642 .hash = {
3643 .vecs = sha224_tv_template,
3644 .count = SHA224_TEST_VECTORS
3645 }
3646 }
3647 }, {
3648 .alg = "sha256",
3649 .test = alg_test_hash,
3650 .fips_allowed = 1,
3651 .suite = {
3652 .hash = {
3653 .vecs = sha256_tv_template,
3654 .count = SHA256_TEST_VECTORS
3655 }
3656 }
3657 }, {
3658 .alg = "sha384",
3659 .test = alg_test_hash,
3660 .fips_allowed = 1,
3661 .suite = {
3662 .hash = {
3663 .vecs = sha384_tv_template,
3664 .count = SHA384_TEST_VECTORS
3665 }
3666 }
3667 }, {
3668 .alg = "sha512",
3669 .test = alg_test_hash,
3670 .fips_allowed = 1,
3671 .suite = {
3672 .hash = {
3673 .vecs = sha512_tv_template,
3674 .count = SHA512_TEST_VECTORS
3675 }
3676 }
3677 }, {
3678 .alg = "tgr128",
3679 .test = alg_test_hash,
3680 .suite = {
3681 .hash = {
3682 .vecs = tgr128_tv_template,
3683 .count = TGR128_TEST_VECTORS
3684 }
3685 }
3686 }, {
3687 .alg = "tgr160",
3688 .test = alg_test_hash,
3689 .suite = {
3690 .hash = {
3691 .vecs = tgr160_tv_template,
3692 .count = TGR160_TEST_VECTORS
3693 }
3694 }
3695 }, {
3696 .alg = "tgr192",
3697 .test = alg_test_hash,
3698 .suite = {
3699 .hash = {
3700 .vecs = tgr192_tv_template,
3701 .count = TGR192_TEST_VECTORS
3702 }
3703 }
3704 }, {
3705 .alg = "vmac(aes)",
3706 .test = alg_test_hash,
3707 .suite = {
3708 .hash = {
3709 .vecs = aes_vmac128_tv_template,
3710 .count = VMAC_AES_TEST_VECTORS
3711 }
3712 }
3713 }, {
3714 .alg = "wp256",
3715 .test = alg_test_hash,
3716 .suite = {
3717 .hash = {
3718 .vecs = wp256_tv_template,
3719 .count = WP256_TEST_VECTORS
3720 }
3721 }
3722 }, {
3723 .alg = "wp384",
3724 .test = alg_test_hash,
3725 .suite = {
3726 .hash = {
3727 .vecs = wp384_tv_template,
3728 .count = WP384_TEST_VECTORS
3729 }
3730 }
3731 }, {
3732 .alg = "wp512",
3733 .test = alg_test_hash,
3734 .suite = {
3735 .hash = {
3736 .vecs = wp512_tv_template,
3737 .count = WP512_TEST_VECTORS
3738 }
3739 }
3740 }, {
3741 .alg = "xcbc(aes)",
3742 .test = alg_test_hash,
3743 .suite = {
3744 .hash = {
3745 .vecs = aes_xcbc128_tv_template,
3746 .count = XCBC_AES_TEST_VECTORS
3747 }
3748 }
3749 }, {
3750 .alg = "xts(aes)",
3751 .test = alg_test_skcipher,
3752 .fips_allowed = 1,
3753 .suite = {
3754 .cipher = {
3755 .enc = {
3756 .vecs = aes_xts_enc_tv_template,
3757 .count = AES_XTS_ENC_TEST_VECTORS
3758 },
3759 .dec = {
3760 .vecs = aes_xts_dec_tv_template,
3761 .count = AES_XTS_DEC_TEST_VECTORS
3762 }
3763 }
3764 }
3765 }, {
3766 .alg = "xts(camellia)",
3767 .test = alg_test_skcipher,
3768 .suite = {
3769 .cipher = {
3770 .enc = {
3771 .vecs = camellia_xts_enc_tv_template,
3772 .count = CAMELLIA_XTS_ENC_TEST_VECTORS
3773 },
3774 .dec = {
3775 .vecs = camellia_xts_dec_tv_template,
3776 .count = CAMELLIA_XTS_DEC_TEST_VECTORS
3777 }
3778 }
3779 }
3780 }, {
3781 .alg = "xts(cast6)",
3782 .test = alg_test_skcipher,
3783 .suite = {
3784 .cipher = {
3785 .enc = {
3786 .vecs = cast6_xts_enc_tv_template,
3787 .count = CAST6_XTS_ENC_TEST_VECTORS
3788 },
3789 .dec = {
3790 .vecs = cast6_xts_dec_tv_template,
3791 .count = CAST6_XTS_DEC_TEST_VECTORS
3792 }
3793 }
3794 }
3795 }, {
3796 .alg = "xts(serpent)",
3797 .test = alg_test_skcipher,
3798 .suite = {
3799 .cipher = {
3800 .enc = {
3801 .vecs = serpent_xts_enc_tv_template,
3802 .count = SERPENT_XTS_ENC_TEST_VECTORS
3803 },
3804 .dec = {
3805 .vecs = serpent_xts_dec_tv_template,
3806 .count = SERPENT_XTS_DEC_TEST_VECTORS
3807 }
3808 }
3809 }
3810 }, {
3811 .alg = "xts(twofish)",
3812 .test = alg_test_skcipher,
3813 .suite = {
3814 .cipher = {
3815 .enc = {
3816 .vecs = tf_xts_enc_tv_template,
3817 .count = TF_XTS_ENC_TEST_VECTORS
3818 },
3819 .dec = {
3820 .vecs = tf_xts_dec_tv_template,
3821 .count = TF_XTS_DEC_TEST_VECTORS
3822 }
3823 }
3824 }
3825 }
3826 };
3827
3828 static bool alg_test_descs_checked;
3829
3830 static void alg_test_descs_check_order(void)
3831 {
3832 int i;
3833
3834 /* only check once */
3835 if (alg_test_descs_checked)
3836 return;
3837
3838 alg_test_descs_checked = true;
3839
3840 for (i = 1; i < ARRAY_SIZE(alg_test_descs); i++) {
3841 int diff = strcmp(alg_test_descs[i - 1].alg,
3842 alg_test_descs[i].alg);
3843
3844 if (WARN_ON(diff > 0)) {
3845 pr_warn("testmgr: alg_test_descs entries in wrong order: '%s' before '%s'\n",
3846 alg_test_descs[i - 1].alg,
3847 alg_test_descs[i].alg);
3848 }
3849
3850 if (WARN_ON(diff == 0)) {
3851 pr_warn("testmgr: duplicate alg_test_descs entry: '%s'\n",
3852 alg_test_descs[i].alg);
3853 }
3854 }
3855 }
3856
3857 static int alg_find_test(const char *alg)
3858 {
3859 int start = 0;
3860 int end = ARRAY_SIZE(alg_test_descs);
3861
3862 while (start < end) {
3863 int i = (start + end) / 2;
3864 int diff = strcmp(alg_test_descs[i].alg, alg);
3865
3866 if (diff > 0) {
3867 end = i;
3868 continue;
3869 }
3870
3871 if (diff < 0) {
3872 start = i + 1;
3873 continue;
3874 }
3875
3876 return i;
3877 }
3878
3879 return -1;
3880 }
3881
3882 int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
3883 {
3884 int i;
3885 int j;
3886 int rc;
3887
3888 alg_test_descs_check_order();
3889
3890 if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) {
3891 char nalg[CRYPTO_MAX_ALG_NAME];
3892
3893 if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >=
3894 sizeof(nalg))
3895 return -ENAMETOOLONG;
3896
3897 i = alg_find_test(nalg);
3898 if (i < 0)
3899 goto notest;
3900
3901 if (fips_enabled && !alg_test_descs[i].fips_allowed)
3902 goto non_fips_alg;
3903
3904 rc = alg_test_cipher(alg_test_descs + i, driver, type, mask);
3905 goto test_done;
3906 }
3907
3908 i = alg_find_test(alg);
3909 j = alg_find_test(driver);
3910 if (i < 0 && j < 0)
3911 goto notest;
3912
3913 if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) ||
3914 (j >= 0 && !alg_test_descs[j].fips_allowed)))
3915 goto non_fips_alg;
3916
3917 rc = 0;
3918 if (i >= 0)
3919 rc |= alg_test_descs[i].test(alg_test_descs + i, driver,
3920 type, mask);
3921 if (j >= 0 && j != i)
3922 rc |= alg_test_descs[j].test(alg_test_descs + j, driver,
3923 type, mask);
3924
3925 test_done:
3926 if (fips_enabled && rc)
3927 panic("%s: %s alg self test failed in fips mode!\n", driver, alg);
3928
3929 if (fips_enabled && !rc)
3930 pr_info("alg: self-tests for %s (%s) passed\n", driver, alg);
3931
3932 return rc;
3933
3934 notest:
3935 printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
3936 return 0;
3937 non_fips_alg:
3938 return -EINVAL;
3939 }
3940
3941 #endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */
3942
3943 EXPORT_SYMBOL_GPL(alg_test);
Linux with added FPC-III support