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