xref: /openbmc/linux/crypto/tcrypt.c (revision b6dcefde)
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  * Copyright (c) 2007 Nokia Siemens Networks
10  *
11  * This program is free software; you can redistribute it and/or modify it
12  * under the terms of the GNU General Public License as published by the Free
13  * Software Foundation; either version 2 of the License, or (at your option)
14  * any later version.
15  *
16  */
17 
18 #include <crypto/hash.h>
19 #include <linux/err.h>
20 #include <linux/init.h>
21 #include <linux/module.h>
22 #include <linux/slab.h>
23 #include <linux/scatterlist.h>
24 #include <linux/string.h>
25 #include <linux/moduleparam.h>
26 #include <linux/jiffies.h>
27 #include <linux/timex.h>
28 #include <linux/interrupt.h>
29 #include "tcrypt.h"
30 #include "internal.h"
31 
32 /*
33  * Need slab memory for testing (size in number of pages).
34  */
35 #define TVMEMSIZE	4
36 
37 /*
38 * Used by test_cipher_speed()
39 */
40 #define ENCRYPT 1
41 #define DECRYPT 0
42 
43 /*
44  * Used by test_cipher_speed()
45  */
46 static unsigned int sec;
47 
48 static char *alg = NULL;
49 static u32 type;
50 static u32 mask;
51 static int mode;
52 static char *tvmem[TVMEMSIZE];
53 
54 static char *check[] = {
55 	"des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256",
56 	"blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes",
57 	"cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
58 	"khazad", "wp512", "wp384", "wp256", "tnepres", "xeta",  "fcrypt",
59 	"camellia", "seed", "salsa20", "rmd128", "rmd160", "rmd256", "rmd320",
60 	"lzo", "cts", "zlib", NULL
61 };
62 
63 static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc,
64 			       struct scatterlist *sg, int blen, int sec)
65 {
66 	unsigned long start, end;
67 	int bcount;
68 	int ret;
69 
70 	for (start = jiffies, end = start + sec * HZ, bcount = 0;
71 	     time_before(jiffies, end); bcount++) {
72 		if (enc)
73 			ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
74 		else
75 			ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
76 
77 		if (ret)
78 			return ret;
79 	}
80 
81 	printk("%d operations in %d seconds (%ld bytes)\n",
82 	       bcount, sec, (long)bcount * blen);
83 	return 0;
84 }
85 
86 static int test_cipher_cycles(struct blkcipher_desc *desc, int enc,
87 			      struct scatterlist *sg, int blen)
88 {
89 	unsigned long cycles = 0;
90 	int ret = 0;
91 	int i;
92 
93 	local_bh_disable();
94 	local_irq_disable();
95 
96 	/* Warm-up run. */
97 	for (i = 0; i < 4; i++) {
98 		if (enc)
99 			ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
100 		else
101 			ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
102 
103 		if (ret)
104 			goto out;
105 	}
106 
107 	/* The real thing. */
108 	for (i = 0; i < 8; i++) {
109 		cycles_t start, end;
110 
111 		start = get_cycles();
112 		if (enc)
113 			ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
114 		else
115 			ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
116 		end = get_cycles();
117 
118 		if (ret)
119 			goto out;
120 
121 		cycles += end - start;
122 	}
123 
124 out:
125 	local_irq_enable();
126 	local_bh_enable();
127 
128 	if (ret == 0)
129 		printk("1 operation in %lu cycles (%d bytes)\n",
130 		       (cycles + 4) / 8, blen);
131 
132 	return ret;
133 }
134 
135 static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 };
136 
137 static void test_cipher_speed(const char *algo, int enc, unsigned int sec,
138 			      struct cipher_speed_template *template,
139 			      unsigned int tcount, u8 *keysize)
140 {
141 	unsigned int ret, i, j, iv_len;
142 	const char *key, iv[128];
143 	struct crypto_blkcipher *tfm;
144 	struct blkcipher_desc desc;
145 	const char *e;
146 	u32 *b_size;
147 
148 	if (enc == ENCRYPT)
149 	        e = "encryption";
150 	else
151 		e = "decryption";
152 
153 	printk("\ntesting speed of %s %s\n", algo, e);
154 
155 	tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);
156 
157 	if (IS_ERR(tfm)) {
158 		printk("failed to load transform for %s: %ld\n", algo,
159 		       PTR_ERR(tfm));
160 		return;
161 	}
162 	desc.tfm = tfm;
163 	desc.flags = 0;
164 
165 	i = 0;
166 	do {
167 
168 		b_size = block_sizes;
169 		do {
170 			struct scatterlist sg[TVMEMSIZE];
171 
172 			if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
173 				printk("template (%u) too big for "
174 				       "tvmem (%lu)\n", *keysize + *b_size,
175 				       TVMEMSIZE * PAGE_SIZE);
176 				goto out;
177 			}
178 
179 			printk("test %u (%d bit key, %d byte blocks): ", i,
180 					*keysize * 8, *b_size);
181 
182 			memset(tvmem[0], 0xff, PAGE_SIZE);
183 
184 			/* set key, plain text and IV */
185 			key = tvmem[0];
186 			for (j = 0; j < tcount; j++) {
187 				if (template[j].klen == *keysize) {
188 					key = template[j].key;
189 					break;
190 				}
191 			}
192 
193 			ret = crypto_blkcipher_setkey(tfm, key, *keysize);
194 			if (ret) {
195 				printk("setkey() failed flags=%x\n",
196 						crypto_blkcipher_get_flags(tfm));
197 				goto out;
198 			}
199 
200 			sg_init_table(sg, TVMEMSIZE);
201 			sg_set_buf(sg, tvmem[0] + *keysize,
202 				   PAGE_SIZE - *keysize);
203 			for (j = 1; j < TVMEMSIZE; j++) {
204 				sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
205 				memset (tvmem[j], 0xff, PAGE_SIZE);
206 			}
207 
208 			iv_len = crypto_blkcipher_ivsize(tfm);
209 			if (iv_len) {
210 				memset(&iv, 0xff, iv_len);
211 				crypto_blkcipher_set_iv(tfm, iv, iv_len);
212 			}
213 
214 			if (sec)
215 				ret = test_cipher_jiffies(&desc, enc, sg,
216 							  *b_size, sec);
217 			else
218 				ret = test_cipher_cycles(&desc, enc, sg,
219 							 *b_size);
220 
221 			if (ret) {
222 				printk("%s() failed flags=%x\n", e, desc.flags);
223 				break;
224 			}
225 			b_size++;
226 			i++;
227 		} while (*b_size);
228 		keysize++;
229 	} while (*keysize);
230 
231 out:
232 	crypto_free_blkcipher(tfm);
233 }
234 
235 static int test_hash_jiffies_digest(struct hash_desc *desc,
236 				    struct scatterlist *sg, int blen,
237 				    char *out, int sec)
238 {
239 	unsigned long start, end;
240 	int bcount;
241 	int ret;
242 
243 	for (start = jiffies, end = start + sec * HZ, bcount = 0;
244 	     time_before(jiffies, end); bcount++) {
245 		ret = crypto_hash_digest(desc, sg, blen, out);
246 		if (ret)
247 			return ret;
248 	}
249 
250 	printk("%6u opers/sec, %9lu bytes/sec\n",
251 	       bcount / sec, ((long)bcount * blen) / sec);
252 
253 	return 0;
254 }
255 
256 static int test_hash_jiffies(struct hash_desc *desc, struct scatterlist *sg,
257 			     int blen, int plen, char *out, int sec)
258 {
259 	unsigned long start, end;
260 	int bcount, pcount;
261 	int ret;
262 
263 	if (plen == blen)
264 		return test_hash_jiffies_digest(desc, sg, blen, out, sec);
265 
266 	for (start = jiffies, end = start + sec * HZ, bcount = 0;
267 	     time_before(jiffies, end); bcount++) {
268 		ret = crypto_hash_init(desc);
269 		if (ret)
270 			return ret;
271 		for (pcount = 0; pcount < blen; pcount += plen) {
272 			ret = crypto_hash_update(desc, sg, plen);
273 			if (ret)
274 				return ret;
275 		}
276 		/* we assume there is enough space in 'out' for the result */
277 		ret = crypto_hash_final(desc, out);
278 		if (ret)
279 			return ret;
280 	}
281 
282 	printk("%6u opers/sec, %9lu bytes/sec\n",
283 	       bcount / sec, ((long)bcount * blen) / sec);
284 
285 	return 0;
286 }
287 
288 static int test_hash_cycles_digest(struct hash_desc *desc,
289 				   struct scatterlist *sg, int blen, char *out)
290 {
291 	unsigned long cycles = 0;
292 	int i;
293 	int ret;
294 
295 	local_bh_disable();
296 	local_irq_disable();
297 
298 	/* Warm-up run. */
299 	for (i = 0; i < 4; i++) {
300 		ret = crypto_hash_digest(desc, sg, blen, out);
301 		if (ret)
302 			goto out;
303 	}
304 
305 	/* The real thing. */
306 	for (i = 0; i < 8; i++) {
307 		cycles_t start, end;
308 
309 		start = get_cycles();
310 
311 		ret = crypto_hash_digest(desc, sg, blen, out);
312 		if (ret)
313 			goto out;
314 
315 		end = get_cycles();
316 
317 		cycles += end - start;
318 	}
319 
320 out:
321 	local_irq_enable();
322 	local_bh_enable();
323 
324 	if (ret)
325 		return ret;
326 
327 	printk("%6lu cycles/operation, %4lu cycles/byte\n",
328 	       cycles / 8, cycles / (8 * blen));
329 
330 	return 0;
331 }
332 
333 static int test_hash_cycles(struct hash_desc *desc, struct scatterlist *sg,
334 			    int blen, int plen, char *out)
335 {
336 	unsigned long cycles = 0;
337 	int i, pcount;
338 	int ret;
339 
340 	if (plen == blen)
341 		return test_hash_cycles_digest(desc, sg, blen, out);
342 
343 	local_bh_disable();
344 	local_irq_disable();
345 
346 	/* Warm-up run. */
347 	for (i = 0; i < 4; i++) {
348 		ret = crypto_hash_init(desc);
349 		if (ret)
350 			goto out;
351 		for (pcount = 0; pcount < blen; pcount += plen) {
352 			ret = crypto_hash_update(desc, sg, plen);
353 			if (ret)
354 				goto out;
355 		}
356 		ret = crypto_hash_final(desc, out);
357 		if (ret)
358 			goto out;
359 	}
360 
361 	/* The real thing. */
362 	for (i = 0; i < 8; i++) {
363 		cycles_t start, end;
364 
365 		start = get_cycles();
366 
367 		ret = crypto_hash_init(desc);
368 		if (ret)
369 			goto out;
370 		for (pcount = 0; pcount < blen; pcount += plen) {
371 			ret = crypto_hash_update(desc, sg, plen);
372 			if (ret)
373 				goto out;
374 		}
375 		ret = crypto_hash_final(desc, out);
376 		if (ret)
377 			goto out;
378 
379 		end = get_cycles();
380 
381 		cycles += end - start;
382 	}
383 
384 out:
385 	local_irq_enable();
386 	local_bh_enable();
387 
388 	if (ret)
389 		return ret;
390 
391 	printk("%6lu cycles/operation, %4lu cycles/byte\n",
392 	       cycles / 8, cycles / (8 * blen));
393 
394 	return 0;
395 }
396 
397 static void test_hash_speed(const char *algo, unsigned int sec,
398 			    struct hash_speed *speed)
399 {
400 	struct scatterlist sg[TVMEMSIZE];
401 	struct crypto_hash *tfm;
402 	struct hash_desc desc;
403 	static char output[1024];
404 	int i;
405 	int ret;
406 
407 	printk(KERN_INFO "\ntesting speed of %s\n", algo);
408 
409 	tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
410 
411 	if (IS_ERR(tfm)) {
412 		printk(KERN_ERR "failed to load transform for %s: %ld\n", algo,
413 		       PTR_ERR(tfm));
414 		return;
415 	}
416 
417 	desc.tfm = tfm;
418 	desc.flags = 0;
419 
420 	if (crypto_hash_digestsize(tfm) > sizeof(output)) {
421 		printk(KERN_ERR "digestsize(%u) > outputbuffer(%zu)\n",
422 		       crypto_hash_digestsize(tfm), sizeof(output));
423 		goto out;
424 	}
425 
426 	sg_init_table(sg, TVMEMSIZE);
427 	for (i = 0; i < TVMEMSIZE; i++) {
428 		sg_set_buf(sg + i, tvmem[i], PAGE_SIZE);
429 		memset(tvmem[i], 0xff, PAGE_SIZE);
430 	}
431 
432 	for (i = 0; speed[i].blen != 0; i++) {
433 		if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
434 			printk(KERN_ERR
435 			       "template (%u) too big for tvmem (%lu)\n",
436 			       speed[i].blen, TVMEMSIZE * PAGE_SIZE);
437 			goto out;
438 		}
439 
440 		printk(KERN_INFO "test%3u "
441 		       "(%5u byte blocks,%5u bytes per update,%4u updates): ",
442 		       i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
443 
444 		if (sec)
445 			ret = test_hash_jiffies(&desc, sg, speed[i].blen,
446 						speed[i].plen, output, sec);
447 		else
448 			ret = test_hash_cycles(&desc, sg, speed[i].blen,
449 					       speed[i].plen, output);
450 
451 		if (ret) {
452 			printk(KERN_ERR "hashing failed ret=%d\n", ret);
453 			break;
454 		}
455 	}
456 
457 out:
458 	crypto_free_hash(tfm);
459 }
460 
461 static void test_available(void)
462 {
463 	char **name = check;
464 
465 	while (*name) {
466 		printk("alg %s ", *name);
467 		printk(crypto_has_alg(*name, 0, 0) ?
468 		       "found\n" : "not found\n");
469 		name++;
470 	}
471 }
472 
473 static inline int tcrypt_test(const char *alg)
474 {
475 	int ret;
476 
477 	ret = alg_test(alg, alg, 0, 0);
478 	/* non-fips algs return -EINVAL in fips mode */
479 	if (fips_enabled && ret == -EINVAL)
480 		ret = 0;
481 	return ret;
482 }
483 
484 static int do_test(int m)
485 {
486 	int i;
487 	int ret = 0;
488 
489 	switch (m) {
490 	case 0:
491 		for (i = 1; i < 200; i++)
492 			ret += do_test(i);
493 		break;
494 
495 	case 1:
496 		ret += tcrypt_test("md5");
497 		break;
498 
499 	case 2:
500 		ret += tcrypt_test("sha1");
501 		break;
502 
503 	case 3:
504 		ret += tcrypt_test("ecb(des)");
505 		ret += tcrypt_test("cbc(des)");
506 		break;
507 
508 	case 4:
509 		ret += tcrypt_test("ecb(des3_ede)");
510 		ret += tcrypt_test("cbc(des3_ede)");
511 		break;
512 
513 	case 5:
514 		ret += tcrypt_test("md4");
515 		break;
516 
517 	case 6:
518 		ret += tcrypt_test("sha256");
519 		break;
520 
521 	case 7:
522 		ret += tcrypt_test("ecb(blowfish)");
523 		ret += tcrypt_test("cbc(blowfish)");
524 		break;
525 
526 	case 8:
527 		ret += tcrypt_test("ecb(twofish)");
528 		ret += tcrypt_test("cbc(twofish)");
529 		break;
530 
531 	case 9:
532 		ret += tcrypt_test("ecb(serpent)");
533 		break;
534 
535 	case 10:
536 		ret += tcrypt_test("ecb(aes)");
537 		ret += tcrypt_test("cbc(aes)");
538 		ret += tcrypt_test("lrw(aes)");
539 		ret += tcrypt_test("xts(aes)");
540 		ret += tcrypt_test("ctr(aes)");
541 		ret += tcrypt_test("rfc3686(ctr(aes))");
542 		break;
543 
544 	case 11:
545 		ret += tcrypt_test("sha384");
546 		break;
547 
548 	case 12:
549 		ret += tcrypt_test("sha512");
550 		break;
551 
552 	case 13:
553 		ret += tcrypt_test("deflate");
554 		break;
555 
556 	case 14:
557 		ret += tcrypt_test("ecb(cast5)");
558 		break;
559 
560 	case 15:
561 		ret += tcrypt_test("ecb(cast6)");
562 		break;
563 
564 	case 16:
565 		ret += tcrypt_test("ecb(arc4)");
566 		break;
567 
568 	case 17:
569 		ret += tcrypt_test("michael_mic");
570 		break;
571 
572 	case 18:
573 		ret += tcrypt_test("crc32c");
574 		break;
575 
576 	case 19:
577 		ret += tcrypt_test("ecb(tea)");
578 		break;
579 
580 	case 20:
581 		ret += tcrypt_test("ecb(xtea)");
582 		break;
583 
584 	case 21:
585 		ret += tcrypt_test("ecb(khazad)");
586 		break;
587 
588 	case 22:
589 		ret += tcrypt_test("wp512");
590 		break;
591 
592 	case 23:
593 		ret += tcrypt_test("wp384");
594 		break;
595 
596 	case 24:
597 		ret += tcrypt_test("wp256");
598 		break;
599 
600 	case 25:
601 		ret += tcrypt_test("ecb(tnepres)");
602 		break;
603 
604 	case 26:
605 		ret += tcrypt_test("ecb(anubis)");
606 		ret += tcrypt_test("cbc(anubis)");
607 		break;
608 
609 	case 27:
610 		ret += tcrypt_test("tgr192");
611 		break;
612 
613 	case 28:
614 
615 		ret += tcrypt_test("tgr160");
616 		break;
617 
618 	case 29:
619 		ret += tcrypt_test("tgr128");
620 		break;
621 
622 	case 30:
623 		ret += tcrypt_test("ecb(xeta)");
624 		break;
625 
626 	case 31:
627 		ret += tcrypt_test("pcbc(fcrypt)");
628 		break;
629 
630 	case 32:
631 		ret += tcrypt_test("ecb(camellia)");
632 		ret += tcrypt_test("cbc(camellia)");
633 		break;
634 	case 33:
635 		ret += tcrypt_test("sha224");
636 		break;
637 
638 	case 34:
639 		ret += tcrypt_test("salsa20");
640 		break;
641 
642 	case 35:
643 		ret += tcrypt_test("gcm(aes)");
644 		break;
645 
646 	case 36:
647 		ret += tcrypt_test("lzo");
648 		break;
649 
650 	case 37:
651 		ret += tcrypt_test("ccm(aes)");
652 		break;
653 
654 	case 38:
655 		ret += tcrypt_test("cts(cbc(aes))");
656 		break;
657 
658         case 39:
659 		ret += tcrypt_test("rmd128");
660 		break;
661 
662         case 40:
663 		ret += tcrypt_test("rmd160");
664 		break;
665 
666 	case 41:
667 		ret += tcrypt_test("rmd256");
668 		break;
669 
670 	case 42:
671 		ret += tcrypt_test("rmd320");
672 		break;
673 
674 	case 43:
675 		ret += tcrypt_test("ecb(seed)");
676 		break;
677 
678 	case 44:
679 		ret += tcrypt_test("zlib");
680 		break;
681 
682 	case 45:
683 		ret += tcrypt_test("rfc4309(ccm(aes))");
684 		break;
685 
686 	case 100:
687 		ret += tcrypt_test("hmac(md5)");
688 		break;
689 
690 	case 101:
691 		ret += tcrypt_test("hmac(sha1)");
692 		break;
693 
694 	case 102:
695 		ret += tcrypt_test("hmac(sha256)");
696 		break;
697 
698 	case 103:
699 		ret += tcrypt_test("hmac(sha384)");
700 		break;
701 
702 	case 104:
703 		ret += tcrypt_test("hmac(sha512)");
704 		break;
705 
706 	case 105:
707 		ret += tcrypt_test("hmac(sha224)");
708 		break;
709 
710 	case 106:
711 		ret += tcrypt_test("xcbc(aes)");
712 		break;
713 
714 	case 107:
715 		ret += tcrypt_test("hmac(rmd128)");
716 		break;
717 
718 	case 108:
719 		ret += tcrypt_test("hmac(rmd160)");
720 		break;
721 
722 	case 109:
723 		ret += tcrypt_test("vmac(aes)");
724 		break;
725 
726 	case 150:
727 		ret += tcrypt_test("ansi_cprng");
728 		break;
729 
730 	case 200:
731 		test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
732 				speed_template_16_24_32);
733 		test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
734 				speed_template_16_24_32);
735 		test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
736 				speed_template_16_24_32);
737 		test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
738 				speed_template_16_24_32);
739 		test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
740 				speed_template_32_40_48);
741 		test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
742 				speed_template_32_40_48);
743 		test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
744 				speed_template_32_48_64);
745 		test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
746 				speed_template_32_48_64);
747 		break;
748 
749 	case 201:
750 		test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
751 				des3_speed_template, DES3_SPEED_VECTORS,
752 				speed_template_24);
753 		test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
754 				des3_speed_template, DES3_SPEED_VECTORS,
755 				speed_template_24);
756 		test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
757 				des3_speed_template, DES3_SPEED_VECTORS,
758 				speed_template_24);
759 		test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
760 				des3_speed_template, DES3_SPEED_VECTORS,
761 				speed_template_24);
762 		break;
763 
764 	case 202:
765 		test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
766 				speed_template_16_24_32);
767 		test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
768 				speed_template_16_24_32);
769 		test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
770 				speed_template_16_24_32);
771 		test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
772 				speed_template_16_24_32);
773 		break;
774 
775 	case 203:
776 		test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
777 				  speed_template_8_32);
778 		test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
779 				  speed_template_8_32);
780 		test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
781 				  speed_template_8_32);
782 		test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
783 				  speed_template_8_32);
784 		break;
785 
786 	case 204:
787 		test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
788 				  speed_template_8);
789 		test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
790 				  speed_template_8);
791 		test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
792 				  speed_template_8);
793 		test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
794 				  speed_template_8);
795 		break;
796 
797 	case 205:
798 		test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
799 				speed_template_16_24_32);
800 		test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
801 				speed_template_16_24_32);
802 		test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
803 				speed_template_16_24_32);
804 		test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
805 				speed_template_16_24_32);
806 		break;
807 
808 	case 206:
809 		test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
810 				  speed_template_16_32);
811 		break;
812 
813 	case 300:
814 		/* fall through */
815 
816 	case 301:
817 		test_hash_speed("md4", sec, generic_hash_speed_template);
818 		if (mode > 300 && mode < 400) break;
819 
820 	case 302:
821 		test_hash_speed("md5", sec, generic_hash_speed_template);
822 		if (mode > 300 && mode < 400) break;
823 
824 	case 303:
825 		test_hash_speed("sha1", sec, generic_hash_speed_template);
826 		if (mode > 300 && mode < 400) break;
827 
828 	case 304:
829 		test_hash_speed("sha256", sec, generic_hash_speed_template);
830 		if (mode > 300 && mode < 400) break;
831 
832 	case 305:
833 		test_hash_speed("sha384", sec, generic_hash_speed_template);
834 		if (mode > 300 && mode < 400) break;
835 
836 	case 306:
837 		test_hash_speed("sha512", sec, generic_hash_speed_template);
838 		if (mode > 300 && mode < 400) break;
839 
840 	case 307:
841 		test_hash_speed("wp256", sec, generic_hash_speed_template);
842 		if (mode > 300 && mode < 400) break;
843 
844 	case 308:
845 		test_hash_speed("wp384", sec, generic_hash_speed_template);
846 		if (mode > 300 && mode < 400) break;
847 
848 	case 309:
849 		test_hash_speed("wp512", sec, generic_hash_speed_template);
850 		if (mode > 300 && mode < 400) break;
851 
852 	case 310:
853 		test_hash_speed("tgr128", sec, generic_hash_speed_template);
854 		if (mode > 300 && mode < 400) break;
855 
856 	case 311:
857 		test_hash_speed("tgr160", sec, generic_hash_speed_template);
858 		if (mode > 300 && mode < 400) break;
859 
860 	case 312:
861 		test_hash_speed("tgr192", sec, generic_hash_speed_template);
862 		if (mode > 300 && mode < 400) break;
863 
864 	case 313:
865 		test_hash_speed("sha224", sec, generic_hash_speed_template);
866 		if (mode > 300 && mode < 400) break;
867 
868 	case 314:
869 		test_hash_speed("rmd128", sec, generic_hash_speed_template);
870 		if (mode > 300 && mode < 400) break;
871 
872 	case 315:
873 		test_hash_speed("rmd160", sec, generic_hash_speed_template);
874 		if (mode > 300 && mode < 400) break;
875 
876 	case 316:
877 		test_hash_speed("rmd256", sec, generic_hash_speed_template);
878 		if (mode > 300 && mode < 400) break;
879 
880 	case 317:
881 		test_hash_speed("rmd320", sec, generic_hash_speed_template);
882 		if (mode > 300 && mode < 400) break;
883 
884 	case 399:
885 		break;
886 
887 	case 1000:
888 		test_available();
889 		break;
890 	}
891 
892 	return ret;
893 }
894 
895 static int do_alg_test(const char *alg, u32 type, u32 mask)
896 {
897 	return crypto_has_alg(alg, type, mask ?: CRYPTO_ALG_TYPE_MASK) ?
898 	       0 : -ENOENT;
899 }
900 
901 static int __init tcrypt_mod_init(void)
902 {
903 	int err = -ENOMEM;
904 	int i;
905 
906 	for (i = 0; i < TVMEMSIZE; i++) {
907 		tvmem[i] = (void *)__get_free_page(GFP_KERNEL);
908 		if (!tvmem[i])
909 			goto err_free_tv;
910 	}
911 
912 	if (alg)
913 		err = do_alg_test(alg, type, mask);
914 	else
915 		err = do_test(mode);
916 
917 	if (err) {
918 		printk(KERN_ERR "tcrypt: one or more tests failed!\n");
919 		goto err_free_tv;
920 	}
921 
922 	/* We intentionaly return -EAGAIN to prevent keeping the module,
923 	 * unless we're running in fips mode. It does all its work from
924 	 * init() and doesn't offer any runtime functionality, but in
925 	 * the fips case, checking for a successful load is helpful.
926 	 * => we don't need it in the memory, do we?
927 	 *                                        -- mludvig
928 	 */
929 	if (!fips_enabled)
930 		err = -EAGAIN;
931 
932 err_free_tv:
933 	for (i = 0; i < TVMEMSIZE && tvmem[i]; i++)
934 		free_page((unsigned long)tvmem[i]);
935 
936 	return err;
937 }
938 
939 /*
940  * If an init function is provided, an exit function must also be provided
941  * to allow module unload.
942  */
943 static void __exit tcrypt_mod_fini(void) { }
944 
945 module_init(tcrypt_mod_init);
946 module_exit(tcrypt_mod_fini);
947 
948 module_param(alg, charp, 0);
949 module_param(type, uint, 0);
950 module_param(mask, uint, 0);
951 module_param(mode, int, 0);
952 module_param(sec, uint, 0);
953 MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
954 		      "(defaults to zero which uses CPU cycles instead)");
955 
956 MODULE_LICENSE("GPL");
957 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
958 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
959