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