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