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