xref: /openbmc/linux/crypto/tcrypt.c (revision 64c70b1c)
1 /*
2  * Quick & dirty crypto testing module.
3  *
4  * This will only exist until we have a better testing mechanism
5  * (e.g. a char device).
6  *
7  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
8  * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
9  *
10  * This program is free software; you can redistribute it and/or modify it
11  * under the terms of the GNU General Public License as published by the Free
12  * Software Foundation; either version 2 of the License, or (at your option)
13  * any later version.
14  *
15  * 2006-12-07 Added SHA384 HMAC and SHA512 HMAC tests
16  * 2004-08-09 Added cipher speed tests (Reyk Floeter <reyk@vantronix.net>)
17  * 2003-09-14 Rewritten by Kartikey Mahendra Bhatt
18  *
19  */
20 
21 #include <linux/err.h>
22 #include <linux/init.h>
23 #include <linux/module.h>
24 #include <linux/mm.h>
25 #include <linux/slab.h>
26 #include <linux/scatterlist.h>
27 #include <linux/string.h>
28 #include <linux/crypto.h>
29 #include <linux/highmem.h>
30 #include <linux/moduleparam.h>
31 #include <linux/jiffies.h>
32 #include <linux/timex.h>
33 #include <linux/interrupt.h>
34 #include "tcrypt.h"
35 
36 /*
37  * Need to kmalloc() memory for testing kmap().
38  */
39 #define TVMEMSIZE	16384
40 #define XBUFSIZE	32768
41 
42 /*
43  * Indexes into the xbuf to simulate cross-page access.
44  */
45 #define IDX1		37
46 #define IDX2		32400
47 #define IDX3		1
48 #define IDX4		8193
49 #define IDX5		22222
50 #define IDX6		17101
51 #define IDX7		27333
52 #define IDX8		3000
53 
54 /*
55 * Used by test_cipher()
56 */
57 #define ENCRYPT 1
58 #define DECRYPT 0
59 
60 struct tcrypt_result {
61 	struct completion completion;
62 	int err;
63 };
64 
65 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
66 
67 /*
68  * Used by test_cipher_speed()
69  */
70 static unsigned int sec;
71 
72 static int mode;
73 static char *xbuf;
74 static char *tvmem;
75 
76 static char *check[] = {
77 	"des", "md5", "des3_ede", "rot13", "sha1", "sha256", "blowfish",
78 	"twofish", "serpent", "sha384", "sha512", "md4", "aes", "cast6",
79 	"arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
80 	"khazad", "wp512", "wp384", "wp256", "tnepres", "xeta",  "fcrypt",
81 	"camellia", NULL
82 };
83 
84 static void hexdump(unsigned char *buf, unsigned int len)
85 {
86 	while (len--)
87 		printk("%02x", *buf++);
88 
89 	printk("\n");
90 }
91 
92 static void tcrypt_complete(struct crypto_async_request *req, int err)
93 {
94 	struct tcrypt_result *res = req->data;
95 
96 	if (err == -EINPROGRESS)
97 		return;
98 
99 	res->err = err;
100 	complete(&res->completion);
101 }
102 
103 static void test_hash(char *algo, struct hash_testvec *template,
104 		      unsigned int tcount)
105 {
106 	unsigned int i, j, k, temp;
107 	struct scatterlist sg[8];
108 	char result[64];
109 	struct crypto_hash *tfm;
110 	struct hash_desc desc;
111 	struct hash_testvec *hash_tv;
112 	unsigned int tsize;
113 	int ret;
114 
115 	printk("\ntesting %s\n", algo);
116 
117 	tsize = sizeof(struct hash_testvec);
118 	tsize *= tcount;
119 
120 	if (tsize > TVMEMSIZE) {
121 		printk("template (%u) too big for tvmem (%u)\n", tsize, TVMEMSIZE);
122 		return;
123 	}
124 
125 	memcpy(tvmem, template, tsize);
126 	hash_tv = (void *)tvmem;
127 
128 	tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
129 	if (IS_ERR(tfm)) {
130 		printk("failed to load transform for %s: %ld\n", algo,
131 		       PTR_ERR(tfm));
132 		return;
133 	}
134 
135 	desc.tfm = tfm;
136 	desc.flags = 0;
137 
138 	for (i = 0; i < tcount; i++) {
139 		printk("test %u:\n", i + 1);
140 		memset(result, 0, 64);
141 
142 		sg_set_buf(&sg[0], hash_tv[i].plaintext, hash_tv[i].psize);
143 
144 		if (hash_tv[i].ksize) {
145 			ret = crypto_hash_setkey(tfm, hash_tv[i].key,
146 						 hash_tv[i].ksize);
147 			if (ret) {
148 				printk("setkey() failed ret=%d\n", ret);
149 				goto out;
150 			}
151 		}
152 
153 		ret = crypto_hash_digest(&desc, sg, hash_tv[i].psize, result);
154 		if (ret) {
155 			printk("digest () failed ret=%d\n", ret);
156 			goto out;
157 		}
158 
159 		hexdump(result, crypto_hash_digestsize(tfm));
160 		printk("%s\n",
161 		       memcmp(result, hash_tv[i].digest,
162 			      crypto_hash_digestsize(tfm)) ?
163 		       "fail" : "pass");
164 	}
165 
166 	printk("testing %s across pages\n", algo);
167 
168 	/* setup the dummy buffer first */
169 	memset(xbuf, 0, XBUFSIZE);
170 
171 	j = 0;
172 	for (i = 0; i < tcount; i++) {
173 		if (hash_tv[i].np) {
174 			j++;
175 			printk("test %u:\n", j);
176 			memset(result, 0, 64);
177 
178 			temp = 0;
179 			for (k = 0; k < hash_tv[i].np; k++) {
180 				memcpy(&xbuf[IDX[k]],
181 				       hash_tv[i].plaintext + temp,
182 				       hash_tv[i].tap[k]);
183 				temp += hash_tv[i].tap[k];
184 				sg_set_buf(&sg[k], &xbuf[IDX[k]],
185 					    hash_tv[i].tap[k]);
186 			}
187 
188 			if (hash_tv[i].ksize) {
189 				ret = crypto_hash_setkey(tfm, hash_tv[i].key,
190 							 hash_tv[i].ksize);
191 
192 				if (ret) {
193 					printk("setkey() failed ret=%d\n", ret);
194 					goto out;
195 				}
196 			}
197 
198 			ret = crypto_hash_digest(&desc, sg, hash_tv[i].psize,
199 						 result);
200 			if (ret) {
201 				printk("digest () failed ret=%d\n", ret);
202 				goto out;
203 			}
204 
205 			hexdump(result, crypto_hash_digestsize(tfm));
206 			printk("%s\n",
207 			       memcmp(result, hash_tv[i].digest,
208 				      crypto_hash_digestsize(tfm)) ?
209 			       "fail" : "pass");
210 		}
211 	}
212 
213 out:
214 	crypto_free_hash(tfm);
215 }
216 
217 static void test_cipher(char *algo, int enc,
218 			struct cipher_testvec *template, unsigned int tcount)
219 {
220 	unsigned int ret, i, j, k, temp;
221 	unsigned int tsize;
222 	char *q;
223 	struct crypto_ablkcipher *tfm;
224 	char *key;
225 	struct cipher_testvec *cipher_tv;
226 	struct ablkcipher_request *req;
227 	struct scatterlist sg[8];
228 	const char *e;
229 	struct tcrypt_result result;
230 
231 	if (enc == ENCRYPT)
232 	        e = "encryption";
233 	else
234 		e = "decryption";
235 
236 	printk("\ntesting %s %s\n", algo, e);
237 
238 	tsize = sizeof (struct cipher_testvec);
239 	tsize *= tcount;
240 
241 	if (tsize > TVMEMSIZE) {
242 		printk("template (%u) too big for tvmem (%u)\n", tsize,
243 		       TVMEMSIZE);
244 		return;
245 	}
246 
247 	memcpy(tvmem, template, tsize);
248 	cipher_tv = (void *)tvmem;
249 
250 	init_completion(&result.completion);
251 
252 	tfm = crypto_alloc_ablkcipher(algo, 0, 0);
253 
254 	if (IS_ERR(tfm)) {
255 		printk("failed to load transform for %s: %ld\n", algo,
256 		       PTR_ERR(tfm));
257 		return;
258 	}
259 
260 	req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
261 	if (!req) {
262 		printk("failed to allocate request for %s\n", algo);
263 		goto out;
264 	}
265 
266 	ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
267 					tcrypt_complete, &result);
268 
269 	j = 0;
270 	for (i = 0; i < tcount; i++) {
271 		if (!(cipher_tv[i].np)) {
272 			j++;
273 			printk("test %u (%d bit key):\n",
274 			j, cipher_tv[i].klen * 8);
275 
276 			crypto_ablkcipher_clear_flags(tfm, ~0);
277 			if (cipher_tv[i].wk)
278 				crypto_ablkcipher_set_flags(
279 					tfm, CRYPTO_TFM_REQ_WEAK_KEY);
280 			key = cipher_tv[i].key;
281 
282 			ret = crypto_ablkcipher_setkey(tfm, key,
283 						       cipher_tv[i].klen);
284 			if (ret) {
285 				printk("setkey() failed flags=%x\n",
286 				       crypto_ablkcipher_get_flags(tfm));
287 
288 				if (!cipher_tv[i].fail)
289 					goto out;
290 			}
291 
292 			sg_set_buf(&sg[0], cipher_tv[i].input,
293 				   cipher_tv[i].ilen);
294 
295 			ablkcipher_request_set_crypt(req, sg, sg,
296 						     cipher_tv[i].ilen,
297 						     cipher_tv[i].iv);
298 
299 			ret = enc ?
300 				crypto_ablkcipher_encrypt(req) :
301 				crypto_ablkcipher_decrypt(req);
302 
303 			switch (ret) {
304 			case 0:
305 				break;
306 			case -EINPROGRESS:
307 			case -EBUSY:
308 				ret = wait_for_completion_interruptible(
309 					&result.completion);
310 				if (!ret && !((ret = result.err))) {
311 					INIT_COMPLETION(result.completion);
312 					break;
313 				}
314 				/* fall through */
315 			default:
316 				printk("%s () failed err=%d\n", e, -ret);
317 				goto out;
318 			}
319 
320 			q = kmap(sg[0].page) + sg[0].offset;
321 			hexdump(q, cipher_tv[i].rlen);
322 
323 			printk("%s\n",
324 			       memcmp(q, cipher_tv[i].result,
325 				      cipher_tv[i].rlen) ? "fail" : "pass");
326 		}
327 	}
328 
329 	printk("\ntesting %s %s across pages (chunking)\n", algo, e);
330 	memset(xbuf, 0, XBUFSIZE);
331 
332 	j = 0;
333 	for (i = 0; i < tcount; i++) {
334 		if (cipher_tv[i].np) {
335 			j++;
336 			printk("test %u (%d bit key):\n",
337 			j, cipher_tv[i].klen * 8);
338 
339 			crypto_ablkcipher_clear_flags(tfm, ~0);
340 			if (cipher_tv[i].wk)
341 				crypto_ablkcipher_set_flags(
342 					tfm, CRYPTO_TFM_REQ_WEAK_KEY);
343 			key = cipher_tv[i].key;
344 
345 			ret = crypto_ablkcipher_setkey(tfm, key,
346 						       cipher_tv[i].klen);
347 			if (ret) {
348 				printk("setkey() failed flags=%x\n",
349 				       crypto_ablkcipher_get_flags(tfm));
350 
351 				if (!cipher_tv[i].fail)
352 					goto out;
353 			}
354 
355 			temp = 0;
356 			for (k = 0; k < cipher_tv[i].np; k++) {
357 				memcpy(&xbuf[IDX[k]],
358 				       cipher_tv[i].input + temp,
359 				       cipher_tv[i].tap[k]);
360 				temp += cipher_tv[i].tap[k];
361 				sg_set_buf(&sg[k], &xbuf[IDX[k]],
362 					   cipher_tv[i].tap[k]);
363 			}
364 
365 			ablkcipher_request_set_crypt(req, sg, sg,
366 						     cipher_tv[i].ilen,
367 						     cipher_tv[i].iv);
368 
369 			ret = enc ?
370 				crypto_ablkcipher_encrypt(req) :
371 				crypto_ablkcipher_decrypt(req);
372 
373 			switch (ret) {
374 			case 0:
375 				break;
376 			case -EINPROGRESS:
377 			case -EBUSY:
378 				ret = wait_for_completion_interruptible(
379 					&result.completion);
380 				if (!ret && !((ret = result.err))) {
381 					INIT_COMPLETION(result.completion);
382 					break;
383 				}
384 				/* fall through */
385 			default:
386 				printk("%s () failed err=%d\n", e, -ret);
387 				goto out;
388 			}
389 
390 			temp = 0;
391 			for (k = 0; k < cipher_tv[i].np; k++) {
392 				printk("page %u\n", k);
393 				q = kmap(sg[k].page) + sg[k].offset;
394 				hexdump(q, cipher_tv[i].tap[k]);
395 				printk("%s\n",
396 					memcmp(q, cipher_tv[i].result + temp,
397 						cipher_tv[i].tap[k]) ? "fail" :
398 					"pass");
399 				temp += cipher_tv[i].tap[k];
400 			}
401 		}
402 	}
403 
404 out:
405 	crypto_free_ablkcipher(tfm);
406 	ablkcipher_request_free(req);
407 }
408 
409 static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc, char *p,
410 			       int blen, int sec)
411 {
412 	struct scatterlist sg[1];
413 	unsigned long start, end;
414 	int bcount;
415 	int ret;
416 
417 	sg_set_buf(sg, p, blen);
418 
419 	for (start = jiffies, end = start + sec * HZ, bcount = 0;
420 	     time_before(jiffies, end); bcount++) {
421 		if (enc)
422 			ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
423 		else
424 			ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
425 
426 		if (ret)
427 			return ret;
428 	}
429 
430 	printk("%d operations in %d seconds (%ld bytes)\n",
431 	       bcount, sec, (long)bcount * blen);
432 	return 0;
433 }
434 
435 static int test_cipher_cycles(struct blkcipher_desc *desc, int enc, char *p,
436 			      int blen)
437 {
438 	struct scatterlist sg[1];
439 	unsigned long cycles = 0;
440 	int ret = 0;
441 	int i;
442 
443 	sg_set_buf(sg, p, blen);
444 
445 	local_bh_disable();
446 	local_irq_disable();
447 
448 	/* Warm-up run. */
449 	for (i = 0; i < 4; i++) {
450 		if (enc)
451 			ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
452 		else
453 			ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
454 
455 		if (ret)
456 			goto out;
457 	}
458 
459 	/* The real thing. */
460 	for (i = 0; i < 8; i++) {
461 		cycles_t start, end;
462 
463 		start = get_cycles();
464 		if (enc)
465 			ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
466 		else
467 			ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
468 		end = get_cycles();
469 
470 		if (ret)
471 			goto out;
472 
473 		cycles += end - start;
474 	}
475 
476 out:
477 	local_irq_enable();
478 	local_bh_enable();
479 
480 	if (ret == 0)
481 		printk("1 operation in %lu cycles (%d bytes)\n",
482 		       (cycles + 4) / 8, blen);
483 
484 	return ret;
485 }
486 
487 static void test_cipher_speed(char *algo, int enc, unsigned int sec,
488 			      struct cipher_testvec *template,
489 			      unsigned int tcount, struct cipher_speed *speed)
490 {
491 	unsigned int ret, i, j, iv_len;
492 	unsigned char *key, *p, iv[128];
493 	struct crypto_blkcipher *tfm;
494 	struct blkcipher_desc desc;
495 	const char *e;
496 
497 	if (enc == ENCRYPT)
498 	        e = "encryption";
499 	else
500 		e = "decryption";
501 
502 	printk("\ntesting speed of %s %s\n", algo, e);
503 
504 	tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);
505 
506 	if (IS_ERR(tfm)) {
507 		printk("failed to load transform for %s: %ld\n", algo,
508 		       PTR_ERR(tfm));
509 		return;
510 	}
511 	desc.tfm = tfm;
512 	desc.flags = 0;
513 
514 	for (i = 0; speed[i].klen != 0; i++) {
515 		if ((speed[i].blen + speed[i].klen) > TVMEMSIZE) {
516 			printk("template (%u) too big for tvmem (%u)\n",
517 			       speed[i].blen + speed[i].klen, TVMEMSIZE);
518 			goto out;
519 		}
520 
521 		printk("test %u (%d bit key, %d byte blocks): ", i,
522 		       speed[i].klen * 8, speed[i].blen);
523 
524 		memset(tvmem, 0xff, speed[i].klen + speed[i].blen);
525 
526 		/* set key, plain text and IV */
527 		key = (unsigned char *)tvmem;
528 		for (j = 0; j < tcount; j++) {
529 			if (template[j].klen == speed[i].klen) {
530 				key = template[j].key;
531 				break;
532 			}
533 		}
534 		p = (unsigned char *)tvmem + speed[i].klen;
535 
536 		ret = crypto_blkcipher_setkey(tfm, key, speed[i].klen);
537 		if (ret) {
538 			printk("setkey() failed flags=%x\n",
539 			       crypto_blkcipher_get_flags(tfm));
540 			goto out;
541 		}
542 
543 		iv_len = crypto_blkcipher_ivsize(tfm);
544 		if (iv_len) {
545 			memset(&iv, 0xff, iv_len);
546 			crypto_blkcipher_set_iv(tfm, iv, iv_len);
547 		}
548 
549 		if (sec)
550 			ret = test_cipher_jiffies(&desc, enc, p, speed[i].blen,
551 						  sec);
552 		else
553 			ret = test_cipher_cycles(&desc, enc, p, speed[i].blen);
554 
555 		if (ret) {
556 			printk("%s() failed flags=%x\n", e, desc.flags);
557 			break;
558 		}
559 	}
560 
561 out:
562 	crypto_free_blkcipher(tfm);
563 }
564 
565 static int test_hash_jiffies_digest(struct hash_desc *desc, char *p, int blen,
566 				    char *out, int sec)
567 {
568 	struct scatterlist sg[1];
569 	unsigned long start, end;
570 	int bcount;
571 	int ret;
572 
573 	for (start = jiffies, end = start + sec * HZ, bcount = 0;
574 	     time_before(jiffies, end); bcount++) {
575 		sg_set_buf(sg, p, blen);
576 		ret = crypto_hash_digest(desc, sg, blen, out);
577 		if (ret)
578 			return ret;
579 	}
580 
581 	printk("%6u opers/sec, %9lu bytes/sec\n",
582 	       bcount / sec, ((long)bcount * blen) / sec);
583 
584 	return 0;
585 }
586 
587 static int test_hash_jiffies(struct hash_desc *desc, char *p, int blen,
588 			     int plen, char *out, int sec)
589 {
590 	struct scatterlist sg[1];
591 	unsigned long start, end;
592 	int bcount, pcount;
593 	int ret;
594 
595 	if (plen == blen)
596 		return test_hash_jiffies_digest(desc, p, blen, out, sec);
597 
598 	for (start = jiffies, end = start + sec * HZ, bcount = 0;
599 	     time_before(jiffies, end); bcount++) {
600 		ret = crypto_hash_init(desc);
601 		if (ret)
602 			return ret;
603 		for (pcount = 0; pcount < blen; pcount += plen) {
604 			sg_set_buf(sg, p + pcount, plen);
605 			ret = crypto_hash_update(desc, sg, plen);
606 			if (ret)
607 				return ret;
608 		}
609 		/* we assume there is enough space in 'out' for the result */
610 		ret = crypto_hash_final(desc, out);
611 		if (ret)
612 			return ret;
613 	}
614 
615 	printk("%6u opers/sec, %9lu bytes/sec\n",
616 	       bcount / sec, ((long)bcount * blen) / sec);
617 
618 	return 0;
619 }
620 
621 static int test_hash_cycles_digest(struct hash_desc *desc, char *p, int blen,
622 				   char *out)
623 {
624 	struct scatterlist sg[1];
625 	unsigned long cycles = 0;
626 	int i;
627 	int ret;
628 
629 	local_bh_disable();
630 	local_irq_disable();
631 
632 	/* Warm-up run. */
633 	for (i = 0; i < 4; i++) {
634 		sg_set_buf(sg, p, blen);
635 		ret = crypto_hash_digest(desc, sg, blen, out);
636 		if (ret)
637 			goto out;
638 	}
639 
640 	/* The real thing. */
641 	for (i = 0; i < 8; i++) {
642 		cycles_t start, end;
643 
644 		start = get_cycles();
645 
646 		sg_set_buf(sg, p, blen);
647 		ret = crypto_hash_digest(desc, sg, blen, out);
648 		if (ret)
649 			goto out;
650 
651 		end = get_cycles();
652 
653 		cycles += end - start;
654 	}
655 
656 out:
657 	local_irq_enable();
658 	local_bh_enable();
659 
660 	if (ret)
661 		return ret;
662 
663 	printk("%6lu cycles/operation, %4lu cycles/byte\n",
664 	       cycles / 8, cycles / (8 * blen));
665 
666 	return 0;
667 }
668 
669 static int test_hash_cycles(struct hash_desc *desc, char *p, int blen,
670 			    int plen, char *out)
671 {
672 	struct scatterlist sg[1];
673 	unsigned long cycles = 0;
674 	int i, pcount;
675 	int ret;
676 
677 	if (plen == blen)
678 		return test_hash_cycles_digest(desc, p, blen, out);
679 
680 	local_bh_disable();
681 	local_irq_disable();
682 
683 	/* Warm-up run. */
684 	for (i = 0; i < 4; i++) {
685 		ret = crypto_hash_init(desc);
686 		if (ret)
687 			goto out;
688 		for (pcount = 0; pcount < blen; pcount += plen) {
689 			sg_set_buf(sg, p + pcount, plen);
690 			ret = crypto_hash_update(desc, sg, plen);
691 			if (ret)
692 				goto out;
693 		}
694 		ret = crypto_hash_final(desc, out);
695 		if (ret)
696 			goto out;
697 	}
698 
699 	/* The real thing. */
700 	for (i = 0; i < 8; i++) {
701 		cycles_t start, end;
702 
703 		start = get_cycles();
704 
705 		ret = crypto_hash_init(desc);
706 		if (ret)
707 			goto out;
708 		for (pcount = 0; pcount < blen; pcount += plen) {
709 			sg_set_buf(sg, p + pcount, plen);
710 			ret = crypto_hash_update(desc, sg, plen);
711 			if (ret)
712 				goto out;
713 		}
714 		ret = crypto_hash_final(desc, out);
715 		if (ret)
716 			goto out;
717 
718 		end = get_cycles();
719 
720 		cycles += end - start;
721 	}
722 
723 out:
724 	local_irq_enable();
725 	local_bh_enable();
726 
727 	if (ret)
728 		return ret;
729 
730 	printk("%6lu cycles/operation, %4lu cycles/byte\n",
731 	       cycles / 8, cycles / (8 * blen));
732 
733 	return 0;
734 }
735 
736 static void test_hash_speed(char *algo, unsigned int sec,
737 			      struct hash_speed *speed)
738 {
739 	struct crypto_hash *tfm;
740 	struct hash_desc desc;
741 	char output[1024];
742 	int i;
743 	int ret;
744 
745 	printk("\ntesting speed of %s\n", algo);
746 
747 	tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
748 
749 	if (IS_ERR(tfm)) {
750 		printk("failed to load transform for %s: %ld\n", algo,
751 		       PTR_ERR(tfm));
752 		return;
753 	}
754 
755 	desc.tfm = tfm;
756 	desc.flags = 0;
757 
758 	if (crypto_hash_digestsize(tfm) > sizeof(output)) {
759 		printk("digestsize(%u) > outputbuffer(%zu)\n",
760 		       crypto_hash_digestsize(tfm), sizeof(output));
761 		goto out;
762 	}
763 
764 	for (i = 0; speed[i].blen != 0; i++) {
765 		if (speed[i].blen > TVMEMSIZE) {
766 			printk("template (%u) too big for tvmem (%u)\n",
767 			       speed[i].blen, TVMEMSIZE);
768 			goto out;
769 		}
770 
771 		printk("test%3u (%5u byte blocks,%5u bytes per update,%4u updates): ",
772 		       i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
773 
774 		memset(tvmem, 0xff, speed[i].blen);
775 
776 		if (sec)
777 			ret = test_hash_jiffies(&desc, tvmem, speed[i].blen,
778 						speed[i].plen, output, sec);
779 		else
780 			ret = test_hash_cycles(&desc, tvmem, speed[i].blen,
781 					       speed[i].plen, output);
782 
783 		if (ret) {
784 			printk("hashing failed ret=%d\n", ret);
785 			break;
786 		}
787 	}
788 
789 out:
790 	crypto_free_hash(tfm);
791 }
792 
793 static void test_deflate(void)
794 {
795 	unsigned int i;
796 	char result[COMP_BUF_SIZE];
797 	struct crypto_comp *tfm;
798 	struct comp_testvec *tv;
799 	unsigned int tsize;
800 
801 	printk("\ntesting deflate compression\n");
802 
803 	tsize = sizeof (deflate_comp_tv_template);
804 	if (tsize > TVMEMSIZE) {
805 		printk("template (%u) too big for tvmem (%u)\n", tsize,
806 		       TVMEMSIZE);
807 		return;
808 	}
809 
810 	memcpy(tvmem, deflate_comp_tv_template, tsize);
811 	tv = (void *)tvmem;
812 
813 	tfm = crypto_alloc_comp("deflate", 0, CRYPTO_ALG_ASYNC);
814 	if (IS_ERR(tfm)) {
815 		printk("failed to load transform for deflate\n");
816 		return;
817 	}
818 
819 	for (i = 0; i < DEFLATE_COMP_TEST_VECTORS; i++) {
820 		int ilen, ret, dlen = COMP_BUF_SIZE;
821 
822 		printk("test %u:\n", i + 1);
823 		memset(result, 0, sizeof (result));
824 
825 		ilen = tv[i].inlen;
826 		ret = crypto_comp_compress(tfm, tv[i].input,
827 		                           ilen, result, &dlen);
828 		if (ret) {
829 			printk("fail: ret=%d\n", ret);
830 			continue;
831 		}
832 		hexdump(result, dlen);
833 		printk("%s (ratio %d:%d)\n",
834 		       memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
835 		       ilen, dlen);
836 	}
837 
838 	printk("\ntesting deflate decompression\n");
839 
840 	tsize = sizeof (deflate_decomp_tv_template);
841 	if (tsize > TVMEMSIZE) {
842 		printk("template (%u) too big for tvmem (%u)\n", tsize,
843 		       TVMEMSIZE);
844 		goto out;
845 	}
846 
847 	memcpy(tvmem, deflate_decomp_tv_template, tsize);
848 	tv = (void *)tvmem;
849 
850 	for (i = 0; i < DEFLATE_DECOMP_TEST_VECTORS; i++) {
851 		int ilen, ret, dlen = COMP_BUF_SIZE;
852 
853 		printk("test %u:\n", i + 1);
854 		memset(result, 0, sizeof (result));
855 
856 		ilen = tv[i].inlen;
857 		ret = crypto_comp_decompress(tfm, tv[i].input,
858 		                             ilen, result, &dlen);
859 		if (ret) {
860 			printk("fail: ret=%d\n", ret);
861 			continue;
862 		}
863 		hexdump(result, dlen);
864 		printk("%s (ratio %d:%d)\n",
865 		       memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
866 		       ilen, dlen);
867 	}
868 out:
869 	crypto_free_comp(tfm);
870 }
871 
872 static void test_available(void)
873 {
874 	char **name = check;
875 
876 	while (*name) {
877 		printk("alg %s ", *name);
878 		printk(crypto_has_alg(*name, 0, 0) ?
879 		       "found\n" : "not found\n");
880 		name++;
881 	}
882 }
883 
884 static void do_test(void)
885 {
886 	switch (mode) {
887 
888 	case 0:
889 		test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
890 
891 		test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
892 
893 		//DES
894 		test_cipher("ecb(des)", ENCRYPT, des_enc_tv_template,
895 			    DES_ENC_TEST_VECTORS);
896 		test_cipher("ecb(des)", DECRYPT, des_dec_tv_template,
897 			    DES_DEC_TEST_VECTORS);
898 		test_cipher("cbc(des)", ENCRYPT, des_cbc_enc_tv_template,
899 			    DES_CBC_ENC_TEST_VECTORS);
900 		test_cipher("cbc(des)", DECRYPT, des_cbc_dec_tv_template,
901 			    DES_CBC_DEC_TEST_VECTORS);
902 
903 		//DES3_EDE
904 		test_cipher("ecb(des3_ede)", ENCRYPT, des3_ede_enc_tv_template,
905 			    DES3_EDE_ENC_TEST_VECTORS);
906 		test_cipher("ecb(des3_ede)", DECRYPT, des3_ede_dec_tv_template,
907 			    DES3_EDE_DEC_TEST_VECTORS);
908 
909 		test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
910 
911 		test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
912 
913 		//BLOWFISH
914 		test_cipher("ecb(blowfish)", ENCRYPT, bf_enc_tv_template,
915 			    BF_ENC_TEST_VECTORS);
916 		test_cipher("ecb(blowfish)", DECRYPT, bf_dec_tv_template,
917 			    BF_DEC_TEST_VECTORS);
918 		test_cipher("cbc(blowfish)", ENCRYPT, bf_cbc_enc_tv_template,
919 			    BF_CBC_ENC_TEST_VECTORS);
920 		test_cipher("cbc(blowfish)", DECRYPT, bf_cbc_dec_tv_template,
921 			    BF_CBC_DEC_TEST_VECTORS);
922 
923 		//TWOFISH
924 		test_cipher("ecb(twofish)", ENCRYPT, tf_enc_tv_template,
925 			    TF_ENC_TEST_VECTORS);
926 		test_cipher("ecb(twofish)", DECRYPT, tf_dec_tv_template,
927 			    TF_DEC_TEST_VECTORS);
928 		test_cipher("cbc(twofish)", ENCRYPT, tf_cbc_enc_tv_template,
929 			    TF_CBC_ENC_TEST_VECTORS);
930 		test_cipher("cbc(twofish)", DECRYPT, tf_cbc_dec_tv_template,
931 			    TF_CBC_DEC_TEST_VECTORS);
932 
933 		//SERPENT
934 		test_cipher("ecb(serpent)", ENCRYPT, serpent_enc_tv_template,
935 			    SERPENT_ENC_TEST_VECTORS);
936 		test_cipher("ecb(serpent)", DECRYPT, serpent_dec_tv_template,
937 			    SERPENT_DEC_TEST_VECTORS);
938 
939 		//TNEPRES
940 		test_cipher("ecb(tnepres)", ENCRYPT, tnepres_enc_tv_template,
941 			    TNEPRES_ENC_TEST_VECTORS);
942 		test_cipher("ecb(tnepres)", DECRYPT, tnepres_dec_tv_template,
943 			    TNEPRES_DEC_TEST_VECTORS);
944 
945 		//AES
946 		test_cipher("ecb(aes)", ENCRYPT, aes_enc_tv_template,
947 			    AES_ENC_TEST_VECTORS);
948 		test_cipher("ecb(aes)", DECRYPT, aes_dec_tv_template,
949 			    AES_DEC_TEST_VECTORS);
950 		test_cipher("cbc(aes)", ENCRYPT, aes_cbc_enc_tv_template,
951 			    AES_CBC_ENC_TEST_VECTORS);
952 		test_cipher("cbc(aes)", DECRYPT, aes_cbc_dec_tv_template,
953 			    AES_CBC_DEC_TEST_VECTORS);
954 		test_cipher("lrw(aes)", ENCRYPT, aes_lrw_enc_tv_template,
955 			    AES_LRW_ENC_TEST_VECTORS);
956 		test_cipher("lrw(aes)", DECRYPT, aes_lrw_dec_tv_template,
957 			    AES_LRW_DEC_TEST_VECTORS);
958 
959 		//CAST5
960 		test_cipher("ecb(cast5)", ENCRYPT, cast5_enc_tv_template,
961 			    CAST5_ENC_TEST_VECTORS);
962 		test_cipher("ecb(cast5)", DECRYPT, cast5_dec_tv_template,
963 			    CAST5_DEC_TEST_VECTORS);
964 
965 		//CAST6
966 		test_cipher("ecb(cast6)", ENCRYPT, cast6_enc_tv_template,
967 			    CAST6_ENC_TEST_VECTORS);
968 		test_cipher("ecb(cast6)", DECRYPT, cast6_dec_tv_template,
969 			    CAST6_DEC_TEST_VECTORS);
970 
971 		//ARC4
972 		test_cipher("ecb(arc4)", ENCRYPT, arc4_enc_tv_template,
973 			    ARC4_ENC_TEST_VECTORS);
974 		test_cipher("ecb(arc4)", DECRYPT, arc4_dec_tv_template,
975 			    ARC4_DEC_TEST_VECTORS);
976 
977 		//TEA
978 		test_cipher("ecb(tea)", ENCRYPT, tea_enc_tv_template,
979 			    TEA_ENC_TEST_VECTORS);
980 		test_cipher("ecb(tea)", DECRYPT, tea_dec_tv_template,
981 			    TEA_DEC_TEST_VECTORS);
982 
983 
984 		//XTEA
985 		test_cipher("ecb(xtea)", ENCRYPT, xtea_enc_tv_template,
986 			    XTEA_ENC_TEST_VECTORS);
987 		test_cipher("ecb(xtea)", DECRYPT, xtea_dec_tv_template,
988 			    XTEA_DEC_TEST_VECTORS);
989 
990 		//KHAZAD
991 		test_cipher("ecb(khazad)", ENCRYPT, khazad_enc_tv_template,
992 			    KHAZAD_ENC_TEST_VECTORS);
993 		test_cipher("ecb(khazad)", DECRYPT, khazad_dec_tv_template,
994 			    KHAZAD_DEC_TEST_VECTORS);
995 
996 		//ANUBIS
997 		test_cipher("ecb(anubis)", ENCRYPT, anubis_enc_tv_template,
998 			    ANUBIS_ENC_TEST_VECTORS);
999 		test_cipher("ecb(anubis)", DECRYPT, anubis_dec_tv_template,
1000 			    ANUBIS_DEC_TEST_VECTORS);
1001 		test_cipher("cbc(anubis)", ENCRYPT, anubis_cbc_enc_tv_template,
1002 			    ANUBIS_CBC_ENC_TEST_VECTORS);
1003 		test_cipher("cbc(anubis)", DECRYPT, anubis_cbc_dec_tv_template,
1004 			    ANUBIS_CBC_ENC_TEST_VECTORS);
1005 
1006 		//XETA
1007 		test_cipher("ecb(xeta)", ENCRYPT, xeta_enc_tv_template,
1008 			    XETA_ENC_TEST_VECTORS);
1009 		test_cipher("ecb(xeta)", DECRYPT, xeta_dec_tv_template,
1010 			    XETA_DEC_TEST_VECTORS);
1011 
1012 		//FCrypt
1013 		test_cipher("pcbc(fcrypt)", ENCRYPT, fcrypt_pcbc_enc_tv_template,
1014 			    FCRYPT_ENC_TEST_VECTORS);
1015 		test_cipher("pcbc(fcrypt)", DECRYPT, fcrypt_pcbc_dec_tv_template,
1016 			    FCRYPT_DEC_TEST_VECTORS);
1017 
1018 		//CAMELLIA
1019 		test_cipher("ecb(camellia)", ENCRYPT,
1020 			    camellia_enc_tv_template,
1021 			    CAMELLIA_ENC_TEST_VECTORS);
1022 		test_cipher("ecb(camellia)", DECRYPT,
1023 			    camellia_dec_tv_template,
1024 			    CAMELLIA_DEC_TEST_VECTORS);
1025 		test_cipher("cbc(camellia)", ENCRYPT,
1026 			    camellia_cbc_enc_tv_template,
1027 			    CAMELLIA_CBC_ENC_TEST_VECTORS);
1028 		test_cipher("cbc(camellia)", DECRYPT,
1029 			    camellia_cbc_dec_tv_template,
1030 			    CAMELLIA_CBC_DEC_TEST_VECTORS);
1031 
1032 		test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
1033 		test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
1034 		test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
1035 		test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
1036 		test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
1037 		test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
1038 		test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
1039 		test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
1040 		test_deflate();
1041 		test_hash("crc32c", crc32c_tv_template, CRC32C_TEST_VECTORS);
1042 		test_hash("hmac(md5)", hmac_md5_tv_template,
1043 			  HMAC_MD5_TEST_VECTORS);
1044 		test_hash("hmac(sha1)", hmac_sha1_tv_template,
1045 			  HMAC_SHA1_TEST_VECTORS);
1046 		test_hash("hmac(sha256)", hmac_sha256_tv_template,
1047 			  HMAC_SHA256_TEST_VECTORS);
1048 		test_hash("hmac(sha384)", hmac_sha384_tv_template,
1049 			  HMAC_SHA384_TEST_VECTORS);
1050 		test_hash("hmac(sha512)", hmac_sha512_tv_template,
1051 			  HMAC_SHA512_TEST_VECTORS);
1052 
1053 		test_hash("xcbc(aes)", aes_xcbc128_tv_template,
1054 			  XCBC_AES_TEST_VECTORS);
1055 
1056 		test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
1057 		break;
1058 
1059 	case 1:
1060 		test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
1061 		break;
1062 
1063 	case 2:
1064 		test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
1065 		break;
1066 
1067 	case 3:
1068 		test_cipher("ecb(des)", ENCRYPT, des_enc_tv_template,
1069 			    DES_ENC_TEST_VECTORS);
1070 		test_cipher("ecb(des)", DECRYPT, des_dec_tv_template,
1071 			    DES_DEC_TEST_VECTORS);
1072 		test_cipher("cbc(des)", ENCRYPT, des_cbc_enc_tv_template,
1073 			    DES_CBC_ENC_TEST_VECTORS);
1074 		test_cipher("cbc(des)", DECRYPT, des_cbc_dec_tv_template,
1075 			    DES_CBC_DEC_TEST_VECTORS);
1076 		break;
1077 
1078 	case 4:
1079 		test_cipher("ecb(des3_ede)", ENCRYPT, des3_ede_enc_tv_template,
1080 			    DES3_EDE_ENC_TEST_VECTORS);
1081 		test_cipher("ecb(des3_ede)", DECRYPT, des3_ede_dec_tv_template,
1082 			    DES3_EDE_DEC_TEST_VECTORS);
1083 		break;
1084 
1085 	case 5:
1086 		test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
1087 		break;
1088 
1089 	case 6:
1090 		test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
1091 		break;
1092 
1093 	case 7:
1094 		test_cipher("ecb(blowfish)", ENCRYPT, bf_enc_tv_template,
1095 			    BF_ENC_TEST_VECTORS);
1096 		test_cipher("ecb(blowfish)", DECRYPT, bf_dec_tv_template,
1097 			    BF_DEC_TEST_VECTORS);
1098 		test_cipher("cbc(blowfish)", ENCRYPT, bf_cbc_enc_tv_template,
1099 			    BF_CBC_ENC_TEST_VECTORS);
1100 		test_cipher("cbc(blowfish)", DECRYPT, bf_cbc_dec_tv_template,
1101 			    BF_CBC_DEC_TEST_VECTORS);
1102 		break;
1103 
1104 	case 8:
1105 		test_cipher("ecb(twofish)", ENCRYPT, tf_enc_tv_template,
1106 			    TF_ENC_TEST_VECTORS);
1107 		test_cipher("ecb(twofish)", DECRYPT, tf_dec_tv_template,
1108 			    TF_DEC_TEST_VECTORS);
1109 		test_cipher("cbc(twofish)", ENCRYPT, tf_cbc_enc_tv_template,
1110 			    TF_CBC_ENC_TEST_VECTORS);
1111 		test_cipher("cbc(twofish)", DECRYPT, tf_cbc_dec_tv_template,
1112 			    TF_CBC_DEC_TEST_VECTORS);
1113 		break;
1114 
1115 	case 9:
1116 		test_cipher("ecb(serpent)", ENCRYPT, serpent_enc_tv_template,
1117 			    SERPENT_ENC_TEST_VECTORS);
1118 		test_cipher("ecb(serpent)", DECRYPT, serpent_dec_tv_template,
1119 			    SERPENT_DEC_TEST_VECTORS);
1120 		break;
1121 
1122 	case 10:
1123 		test_cipher("ecb(aes)", ENCRYPT, aes_enc_tv_template,
1124 			    AES_ENC_TEST_VECTORS);
1125 		test_cipher("ecb(aes)", DECRYPT, aes_dec_tv_template,
1126 			    AES_DEC_TEST_VECTORS);
1127 		test_cipher("cbc(aes)", ENCRYPT, aes_cbc_enc_tv_template,
1128 			    AES_CBC_ENC_TEST_VECTORS);
1129 		test_cipher("cbc(aes)", DECRYPT, aes_cbc_dec_tv_template,
1130 			    AES_CBC_DEC_TEST_VECTORS);
1131 		test_cipher("lrw(aes)", ENCRYPT, aes_lrw_enc_tv_template,
1132 			    AES_LRW_ENC_TEST_VECTORS);
1133 		test_cipher("lrw(aes)", DECRYPT, aes_lrw_dec_tv_template,
1134 			    AES_LRW_DEC_TEST_VECTORS);
1135 		break;
1136 
1137 	case 11:
1138 		test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
1139 		break;
1140 
1141 	case 12:
1142 		test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
1143 		break;
1144 
1145 	case 13:
1146 		test_deflate();
1147 		break;
1148 
1149 	case 14:
1150 		test_cipher("ecb(cast5)", ENCRYPT, cast5_enc_tv_template,
1151 			    CAST5_ENC_TEST_VECTORS);
1152 		test_cipher("ecb(cast5)", DECRYPT, cast5_dec_tv_template,
1153 			    CAST5_DEC_TEST_VECTORS);
1154 		break;
1155 
1156 	case 15:
1157 		test_cipher("ecb(cast6)", ENCRYPT, cast6_enc_tv_template,
1158 			    CAST6_ENC_TEST_VECTORS);
1159 		test_cipher("ecb(cast6)", DECRYPT, cast6_dec_tv_template,
1160 			    CAST6_DEC_TEST_VECTORS);
1161 		break;
1162 
1163 	case 16:
1164 		test_cipher("ecb(arc4)", ENCRYPT, arc4_enc_tv_template,
1165 			    ARC4_ENC_TEST_VECTORS);
1166 		test_cipher("ecb(arc4)", DECRYPT, arc4_dec_tv_template,
1167 			    ARC4_DEC_TEST_VECTORS);
1168 		break;
1169 
1170 	case 17:
1171 		test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
1172 		break;
1173 
1174 	case 18:
1175 		test_hash("crc32c", crc32c_tv_template, CRC32C_TEST_VECTORS);
1176 		break;
1177 
1178 	case 19:
1179 		test_cipher("ecb(tea)", ENCRYPT, tea_enc_tv_template,
1180 			    TEA_ENC_TEST_VECTORS);
1181 		test_cipher("ecb(tea)", DECRYPT, tea_dec_tv_template,
1182 			    TEA_DEC_TEST_VECTORS);
1183 		break;
1184 
1185 	case 20:
1186 		test_cipher("ecb(xtea)", ENCRYPT, xtea_enc_tv_template,
1187 			    XTEA_ENC_TEST_VECTORS);
1188 		test_cipher("ecb(xtea)", DECRYPT, xtea_dec_tv_template,
1189 			    XTEA_DEC_TEST_VECTORS);
1190 		break;
1191 
1192 	case 21:
1193 		test_cipher("ecb(khazad)", ENCRYPT, khazad_enc_tv_template,
1194 			    KHAZAD_ENC_TEST_VECTORS);
1195 		test_cipher("ecb(khazad)", DECRYPT, khazad_dec_tv_template,
1196 			    KHAZAD_DEC_TEST_VECTORS);
1197 		break;
1198 
1199 	case 22:
1200 		test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
1201 		break;
1202 
1203 	case 23:
1204 		test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
1205 		break;
1206 
1207 	case 24:
1208 		test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
1209 		break;
1210 
1211 	case 25:
1212 		test_cipher("ecb(tnepres)", ENCRYPT, tnepres_enc_tv_template,
1213 			    TNEPRES_ENC_TEST_VECTORS);
1214 		test_cipher("ecb(tnepres)", DECRYPT, tnepres_dec_tv_template,
1215 			    TNEPRES_DEC_TEST_VECTORS);
1216 		break;
1217 
1218 	case 26:
1219 		test_cipher("ecb(anubis)", ENCRYPT, anubis_enc_tv_template,
1220 			    ANUBIS_ENC_TEST_VECTORS);
1221 		test_cipher("ecb(anubis)", DECRYPT, anubis_dec_tv_template,
1222 			    ANUBIS_DEC_TEST_VECTORS);
1223 		test_cipher("cbc(anubis)", ENCRYPT, anubis_cbc_enc_tv_template,
1224 			    ANUBIS_CBC_ENC_TEST_VECTORS);
1225 		test_cipher("cbc(anubis)", DECRYPT, anubis_cbc_dec_tv_template,
1226 			    ANUBIS_CBC_ENC_TEST_VECTORS);
1227 		break;
1228 
1229 	case 27:
1230 		test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
1231 		break;
1232 
1233 	case 28:
1234 
1235 		test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
1236 		break;
1237 
1238 	case 29:
1239 		test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
1240 		break;
1241 
1242 	case 30:
1243 		test_cipher("ecb(xeta)", ENCRYPT, xeta_enc_tv_template,
1244 			    XETA_ENC_TEST_VECTORS);
1245 		test_cipher("ecb(xeta)", DECRYPT, xeta_dec_tv_template,
1246 			    XETA_DEC_TEST_VECTORS);
1247 		break;
1248 
1249 	case 31:
1250 		test_cipher("pcbc(fcrypt)", ENCRYPT, fcrypt_pcbc_enc_tv_template,
1251 			    FCRYPT_ENC_TEST_VECTORS);
1252 		test_cipher("pcbc(fcrypt)", DECRYPT, fcrypt_pcbc_dec_tv_template,
1253 			    FCRYPT_DEC_TEST_VECTORS);
1254 		break;
1255 
1256 	case 32:
1257 		test_cipher("ecb(camellia)", ENCRYPT,
1258 			    camellia_enc_tv_template,
1259 			    CAMELLIA_ENC_TEST_VECTORS);
1260 		test_cipher("ecb(camellia)", DECRYPT,
1261 			    camellia_dec_tv_template,
1262 			    CAMELLIA_DEC_TEST_VECTORS);
1263 		test_cipher("cbc(camellia)", ENCRYPT,
1264 			    camellia_cbc_enc_tv_template,
1265 			    CAMELLIA_CBC_ENC_TEST_VECTORS);
1266 		test_cipher("cbc(camellia)", DECRYPT,
1267 			    camellia_cbc_dec_tv_template,
1268 			    CAMELLIA_CBC_DEC_TEST_VECTORS);
1269 		break;
1270 
1271 	case 100:
1272 		test_hash("hmac(md5)", hmac_md5_tv_template,
1273 			  HMAC_MD5_TEST_VECTORS);
1274 		break;
1275 
1276 	case 101:
1277 		test_hash("hmac(sha1)", hmac_sha1_tv_template,
1278 			  HMAC_SHA1_TEST_VECTORS);
1279 		break;
1280 
1281 	case 102:
1282 		test_hash("hmac(sha256)", hmac_sha256_tv_template,
1283 			  HMAC_SHA256_TEST_VECTORS);
1284 		break;
1285 
1286 	case 103:
1287 		test_hash("hmac(sha384)", hmac_sha384_tv_template,
1288 			  HMAC_SHA384_TEST_VECTORS);
1289 		break;
1290 
1291 	case 104:
1292 		test_hash("hmac(sha512)", hmac_sha512_tv_template,
1293 			  HMAC_SHA512_TEST_VECTORS);
1294 		break;
1295 
1296 
1297 	case 200:
1298 		test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
1299 				  aes_speed_template);
1300 		test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
1301 				  aes_speed_template);
1302 		test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
1303 				  aes_speed_template);
1304 		test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
1305 				  aes_speed_template);
1306 		test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
1307 				  aes_lrw_speed_template);
1308 		test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
1309 				  aes_lrw_speed_template);
1310 		break;
1311 
1312 	case 201:
1313 		test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
1314 				  des3_ede_enc_tv_template,
1315 				  DES3_EDE_ENC_TEST_VECTORS,
1316 				  des3_ede_speed_template);
1317 		test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
1318 				  des3_ede_dec_tv_template,
1319 				  DES3_EDE_DEC_TEST_VECTORS,
1320 				  des3_ede_speed_template);
1321 		test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
1322 				  des3_ede_enc_tv_template,
1323 				  DES3_EDE_ENC_TEST_VECTORS,
1324 				  des3_ede_speed_template);
1325 		test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
1326 				  des3_ede_dec_tv_template,
1327 				  DES3_EDE_DEC_TEST_VECTORS,
1328 				  des3_ede_speed_template);
1329 		break;
1330 
1331 	case 202:
1332 		test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
1333 				  twofish_speed_template);
1334 		test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
1335 				  twofish_speed_template);
1336 		test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
1337 				  twofish_speed_template);
1338 		test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
1339 				  twofish_speed_template);
1340 		break;
1341 
1342 	case 203:
1343 		test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
1344 				  blowfish_speed_template);
1345 		test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
1346 				  blowfish_speed_template);
1347 		test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
1348 				  blowfish_speed_template);
1349 		test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
1350 				  blowfish_speed_template);
1351 		break;
1352 
1353 	case 204:
1354 		test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
1355 				  des_speed_template);
1356 		test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
1357 				  des_speed_template);
1358 		test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
1359 				  des_speed_template);
1360 		test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
1361 				  des_speed_template);
1362 		break;
1363 
1364 	case 205:
1365 		test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
1366 				camellia_speed_template);
1367 		test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
1368 				camellia_speed_template);
1369 		test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
1370 				camellia_speed_template);
1371 		test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
1372 				camellia_speed_template);
1373 		break;
1374 
1375 	case 300:
1376 		/* fall through */
1377 
1378 	case 301:
1379 		test_hash_speed("md4", sec, generic_hash_speed_template);
1380 		if (mode > 300 && mode < 400) break;
1381 
1382 	case 302:
1383 		test_hash_speed("md5", sec, generic_hash_speed_template);
1384 		if (mode > 300 && mode < 400) break;
1385 
1386 	case 303:
1387 		test_hash_speed("sha1", sec, generic_hash_speed_template);
1388 		if (mode > 300 && mode < 400) break;
1389 
1390 	case 304:
1391 		test_hash_speed("sha256", sec, generic_hash_speed_template);
1392 		if (mode > 300 && mode < 400) break;
1393 
1394 	case 305:
1395 		test_hash_speed("sha384", sec, generic_hash_speed_template);
1396 		if (mode > 300 && mode < 400) break;
1397 
1398 	case 306:
1399 		test_hash_speed("sha512", sec, generic_hash_speed_template);
1400 		if (mode > 300 && mode < 400) break;
1401 
1402 	case 307:
1403 		test_hash_speed("wp256", sec, generic_hash_speed_template);
1404 		if (mode > 300 && mode < 400) break;
1405 
1406 	case 308:
1407 		test_hash_speed("wp384", sec, generic_hash_speed_template);
1408 		if (mode > 300 && mode < 400) break;
1409 
1410 	case 309:
1411 		test_hash_speed("wp512", sec, generic_hash_speed_template);
1412 		if (mode > 300 && mode < 400) break;
1413 
1414 	case 310:
1415 		test_hash_speed("tgr128", sec, generic_hash_speed_template);
1416 		if (mode > 300 && mode < 400) break;
1417 
1418 	case 311:
1419 		test_hash_speed("tgr160", sec, generic_hash_speed_template);
1420 		if (mode > 300 && mode < 400) break;
1421 
1422 	case 312:
1423 		test_hash_speed("tgr192", sec, generic_hash_speed_template);
1424 		if (mode > 300 && mode < 400) break;
1425 
1426 	case 399:
1427 		break;
1428 
1429 	case 1000:
1430 		test_available();
1431 		break;
1432 
1433 	default:
1434 		/* useful for debugging */
1435 		printk("not testing anything\n");
1436 		break;
1437 	}
1438 }
1439 
1440 static int __init init(void)
1441 {
1442 	tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL);
1443 	if (tvmem == NULL)
1444 		return -ENOMEM;
1445 
1446 	xbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
1447 	if (xbuf == NULL) {
1448 		kfree(tvmem);
1449 		return -ENOMEM;
1450 	}
1451 
1452 	do_test();
1453 
1454 	kfree(xbuf);
1455 	kfree(tvmem);
1456 
1457 	/* We intentionaly return -EAGAIN to prevent keeping
1458 	 * the module. It does all its work from init()
1459 	 * and doesn't offer any runtime functionality
1460 	 * => we don't need it in the memory, do we?
1461 	 *                                        -- mludvig
1462 	 */
1463 	return -EAGAIN;
1464 }
1465 
1466 /*
1467  * If an init function is provided, an exit function must also be provided
1468  * to allow module unload.
1469  */
1470 static void __exit fini(void) { }
1471 
1472 module_init(init);
1473 module_exit(fini);
1474 
1475 module_param(mode, int, 0);
1476 module_param(sec, uint, 0);
1477 MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
1478 		      "(defaults to zero which uses CPU cycles instead)");
1479 
1480 MODULE_LICENSE("GPL");
1481 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
1482 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
1483