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