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