Blackfin: bf54x: add MMR layout for PINT
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / crypto / tcrypt.c
blob3ca68f9fc14d84029603640cc765ca70584a01ee
1 /*
2 * Quick & dirty crypto testing module.
4 * This will only exist until we have a better testing mechanism
5 * (e.g. a char device).
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
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.
18 #include <crypto/hash.h>
19 #include <linux/err.h>
20 #include <linux/init.h>
21 #include <linux/gfp.h>
22 #include <linux/module.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"
33 * Need slab memory for testing (size in number of pages).
35 #define TVMEMSIZE 4
38 * Used by test_cipher_speed()
40 #define ENCRYPT 1
41 #define DECRYPT 0
44 * Used by test_cipher_speed()
46 static unsigned int sec;
48 static char *alg = NULL;
49 static u32 type;
50 static u32 mask;
51 static int mode;
52 static char *tvmem[TVMEMSIZE];
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
63 static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc,
64 struct scatterlist *sg, int blen, int sec)
66 unsigned long start, end;
67 int bcount;
68 int ret;
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);
77 if (ret)
78 return ret;
81 printk("%d operations in %d seconds (%ld bytes)\n",
82 bcount, sec, (long)bcount * blen);
83 return 0;
86 static int test_cipher_cycles(struct blkcipher_desc *desc, int enc,
87 struct scatterlist *sg, int blen)
89 unsigned long cycles = 0;
90 int ret = 0;
91 int i;
93 local_bh_disable();
94 local_irq_disable();
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);
103 if (ret)
104 goto out;
107 /* The real thing. */
108 for (i = 0; i < 8; i++) {
109 cycles_t start, end;
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();
118 if (ret)
119 goto out;
121 cycles += end - start;
124 out:
125 local_irq_enable();
126 local_bh_enable();
128 if (ret == 0)
129 printk("1 operation in %lu cycles (%d bytes)\n",
130 (cycles + 4) / 8, blen);
132 return ret;
135 static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 };
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)
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;
148 if (enc == ENCRYPT)
149 e = "encryption";
150 else
151 e = "decryption";
153 printk("\ntesting speed of %s %s\n", algo, e);
155 tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);
157 if (IS_ERR(tfm)) {
158 printk("failed to load transform for %s: %ld\n", algo,
159 PTR_ERR(tfm));
160 return;
162 desc.tfm = tfm;
163 desc.flags = 0;
165 i = 0;
166 do {
168 b_size = block_sizes;
169 do {
170 struct scatterlist sg[TVMEMSIZE];
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;
179 printk("test %u (%d bit key, %d byte blocks): ", i,
180 *keysize * 8, *b_size);
182 memset(tvmem[0], 0xff, PAGE_SIZE);
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;
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;
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);
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);
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);
221 if (ret) {
222 printk("%s() failed flags=%x\n", e, desc.flags);
223 break;
225 b_size++;
226 i++;
227 } while (*b_size);
228 keysize++;
229 } while (*keysize);
231 out:
232 crypto_free_blkcipher(tfm);
235 static int test_hash_jiffies_digest(struct hash_desc *desc,
236 struct scatterlist *sg, int blen,
237 char *out, int sec)
239 unsigned long start, end;
240 int bcount;
241 int ret;
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;
250 printk("%6u opers/sec, %9lu bytes/sec\n",
251 bcount / sec, ((long)bcount * blen) / sec);
253 return 0;
256 static int test_hash_jiffies(struct hash_desc *desc, struct scatterlist *sg,
257 int blen, int plen, char *out, int sec)
259 unsigned long start, end;
260 int bcount, pcount;
261 int ret;
263 if (plen == blen)
264 return test_hash_jiffies_digest(desc, sg, blen, out, sec);
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;
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;
282 printk("%6u opers/sec, %9lu bytes/sec\n",
283 bcount / sec, ((long)bcount * blen) / sec);
285 return 0;
288 static int test_hash_cycles_digest(struct hash_desc *desc,
289 struct scatterlist *sg, int blen, char *out)
291 unsigned long cycles = 0;
292 int i;
293 int ret;
295 local_bh_disable();
296 local_irq_disable();
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;
305 /* The real thing. */
306 for (i = 0; i < 8; i++) {
307 cycles_t start, end;
309 start = get_cycles();
311 ret = crypto_hash_digest(desc, sg, blen, out);
312 if (ret)
313 goto out;
315 end = get_cycles();
317 cycles += end - start;
320 out:
321 local_irq_enable();
322 local_bh_enable();
324 if (ret)
325 return ret;
327 printk("%6lu cycles/operation, %4lu cycles/byte\n",
328 cycles / 8, cycles / (8 * blen));
330 return 0;
333 static int test_hash_cycles(struct hash_desc *desc, struct scatterlist *sg,
334 int blen, int plen, char *out)
336 unsigned long cycles = 0;
337 int i, pcount;
338 int ret;
340 if (plen == blen)
341 return test_hash_cycles_digest(desc, sg, blen, out);
343 local_bh_disable();
344 local_irq_disable();
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;
356 ret = crypto_hash_final(desc, out);
357 if (ret)
358 goto out;
361 /* The real thing. */
362 for (i = 0; i < 8; i++) {
363 cycles_t start, end;
365 start = get_cycles();
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;
375 ret = crypto_hash_final(desc, out);
376 if (ret)
377 goto out;
379 end = get_cycles();
381 cycles += end - start;
384 out:
385 local_irq_enable();
386 local_bh_enable();
388 if (ret)
389 return ret;
391 printk("%6lu cycles/operation, %4lu cycles/byte\n",
392 cycles / 8, cycles / (8 * blen));
394 return 0;
397 static void test_hash_sg_init(struct scatterlist *sg)
399 int i;
401 sg_init_table(sg, TVMEMSIZE);
402 for (i = 0; i < TVMEMSIZE; i++) {
403 sg_set_buf(sg + i, tvmem[i], PAGE_SIZE);
404 memset(tvmem[i], 0xff, PAGE_SIZE);
408 static void test_hash_speed(const char *algo, unsigned int sec,
409 struct hash_speed *speed)
411 struct scatterlist sg[TVMEMSIZE];
412 struct crypto_hash *tfm;
413 struct hash_desc desc;
414 static char output[1024];
415 int i;
416 int ret;
418 printk(KERN_INFO "\ntesting speed of %s\n", algo);
420 tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
422 if (IS_ERR(tfm)) {
423 printk(KERN_ERR "failed to load transform for %s: %ld\n", algo,
424 PTR_ERR(tfm));
425 return;
428 desc.tfm = tfm;
429 desc.flags = 0;
431 if (crypto_hash_digestsize(tfm) > sizeof(output)) {
432 printk(KERN_ERR "digestsize(%u) > outputbuffer(%zu)\n",
433 crypto_hash_digestsize(tfm), sizeof(output));
434 goto out;
437 test_hash_sg_init(sg);
438 for (i = 0; speed[i].blen != 0; i++) {
439 if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
440 printk(KERN_ERR
441 "template (%u) too big for tvmem (%lu)\n",
442 speed[i].blen, TVMEMSIZE * PAGE_SIZE);
443 goto out;
446 if (speed[i].klen)
447 crypto_hash_setkey(tfm, tvmem[0], speed[i].klen);
449 printk(KERN_INFO "test%3u "
450 "(%5u byte blocks,%5u bytes per update,%4u updates): ",
451 i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
453 if (sec)
454 ret = test_hash_jiffies(&desc, sg, speed[i].blen,
455 speed[i].plen, output, sec);
456 else
457 ret = test_hash_cycles(&desc, sg, speed[i].blen,
458 speed[i].plen, output);
460 if (ret) {
461 printk(KERN_ERR "hashing failed ret=%d\n", ret);
462 break;
466 out:
467 crypto_free_hash(tfm);
470 struct tcrypt_result {
471 struct completion completion;
472 int err;
475 static void tcrypt_complete(struct crypto_async_request *req, int err)
477 struct tcrypt_result *res = req->data;
479 if (err == -EINPROGRESS)
480 return;
482 res->err = err;
483 complete(&res->completion);
486 static inline int do_one_ahash_op(struct ahash_request *req, int ret)
488 if (ret == -EINPROGRESS || ret == -EBUSY) {
489 struct tcrypt_result *tr = req->base.data;
491 ret = wait_for_completion_interruptible(&tr->completion);
492 if (!ret)
493 ret = tr->err;
494 INIT_COMPLETION(tr->completion);
496 return ret;
499 static int test_ahash_jiffies_digest(struct ahash_request *req, int blen,
500 char *out, int sec)
502 unsigned long start, end;
503 int bcount;
504 int ret;
506 for (start = jiffies, end = start + sec * HZ, bcount = 0;
507 time_before(jiffies, end); bcount++) {
508 ret = do_one_ahash_op(req, crypto_ahash_digest(req));
509 if (ret)
510 return ret;
513 printk("%6u opers/sec, %9lu bytes/sec\n",
514 bcount / sec, ((long)bcount * blen) / sec);
516 return 0;
519 static int test_ahash_jiffies(struct ahash_request *req, int blen,
520 int plen, char *out, int sec)
522 unsigned long start, end;
523 int bcount, pcount;
524 int ret;
526 if (plen == blen)
527 return test_ahash_jiffies_digest(req, blen, out, sec);
529 for (start = jiffies, end = start + sec * HZ, bcount = 0;
530 time_before(jiffies, end); bcount++) {
531 ret = crypto_ahash_init(req);
532 if (ret)
533 return ret;
534 for (pcount = 0; pcount < blen; pcount += plen) {
535 ret = do_one_ahash_op(req, crypto_ahash_update(req));
536 if (ret)
537 return ret;
539 /* we assume there is enough space in 'out' for the result */
540 ret = do_one_ahash_op(req, crypto_ahash_final(req));
541 if (ret)
542 return ret;
545 pr_cont("%6u opers/sec, %9lu bytes/sec\n",
546 bcount / sec, ((long)bcount * blen) / sec);
548 return 0;
551 static int test_ahash_cycles_digest(struct ahash_request *req, int blen,
552 char *out)
554 unsigned long cycles = 0;
555 int ret, i;
557 /* Warm-up run. */
558 for (i = 0; i < 4; i++) {
559 ret = do_one_ahash_op(req, crypto_ahash_digest(req));
560 if (ret)
561 goto out;
564 /* The real thing. */
565 for (i = 0; i < 8; i++) {
566 cycles_t start, end;
568 start = get_cycles();
570 ret = do_one_ahash_op(req, crypto_ahash_digest(req));
571 if (ret)
572 goto out;
574 end = get_cycles();
576 cycles += end - start;
579 out:
580 if (ret)
581 return ret;
583 pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
584 cycles / 8, cycles / (8 * blen));
586 return 0;
589 static int test_ahash_cycles(struct ahash_request *req, int blen,
590 int plen, char *out)
592 unsigned long cycles = 0;
593 int i, pcount, ret;
595 if (plen == blen)
596 return test_ahash_cycles_digest(req, blen, out);
598 /* Warm-up run. */
599 for (i = 0; i < 4; i++) {
600 ret = crypto_ahash_init(req);
601 if (ret)
602 goto out;
603 for (pcount = 0; pcount < blen; pcount += plen) {
604 ret = do_one_ahash_op(req, crypto_ahash_update(req));
605 if (ret)
606 goto out;
608 ret = do_one_ahash_op(req, crypto_ahash_final(req));
609 if (ret)
610 goto out;
613 /* The real thing. */
614 for (i = 0; i < 8; i++) {
615 cycles_t start, end;
617 start = get_cycles();
619 ret = crypto_ahash_init(req);
620 if (ret)
621 goto out;
622 for (pcount = 0; pcount < blen; pcount += plen) {
623 ret = do_one_ahash_op(req, crypto_ahash_update(req));
624 if (ret)
625 goto out;
627 ret = do_one_ahash_op(req, crypto_ahash_final(req));
628 if (ret)
629 goto out;
631 end = get_cycles();
633 cycles += end - start;
636 out:
637 if (ret)
638 return ret;
640 pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
641 cycles / 8, cycles / (8 * blen));
643 return 0;
646 static void test_ahash_speed(const char *algo, unsigned int sec,
647 struct hash_speed *speed)
649 struct scatterlist sg[TVMEMSIZE];
650 struct tcrypt_result tresult;
651 struct ahash_request *req;
652 struct crypto_ahash *tfm;
653 static char output[1024];
654 int i, ret;
656 printk(KERN_INFO "\ntesting speed of async %s\n", algo);
658 tfm = crypto_alloc_ahash(algo, 0, 0);
659 if (IS_ERR(tfm)) {
660 pr_err("failed to load transform for %s: %ld\n",
661 algo, PTR_ERR(tfm));
662 return;
665 if (crypto_ahash_digestsize(tfm) > sizeof(output)) {
666 pr_err("digestsize(%u) > outputbuffer(%zu)\n",
667 crypto_ahash_digestsize(tfm), sizeof(output));
668 goto out;
671 test_hash_sg_init(sg);
672 req = ahash_request_alloc(tfm, GFP_KERNEL);
673 if (!req) {
674 pr_err("ahash request allocation failure\n");
675 goto out;
678 init_completion(&tresult.completion);
679 ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
680 tcrypt_complete, &tresult);
682 for (i = 0; speed[i].blen != 0; i++) {
683 if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
684 pr_err("template (%u) too big for tvmem (%lu)\n",
685 speed[i].blen, TVMEMSIZE * PAGE_SIZE);
686 break;
689 pr_info("test%3u "
690 "(%5u byte blocks,%5u bytes per update,%4u updates): ",
691 i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
693 ahash_request_set_crypt(req, sg, output, speed[i].plen);
695 if (sec)
696 ret = test_ahash_jiffies(req, speed[i].blen,
697 speed[i].plen, output, sec);
698 else
699 ret = test_ahash_cycles(req, speed[i].blen,
700 speed[i].plen, output);
702 if (ret) {
703 pr_err("hashing failed ret=%d\n", ret);
704 break;
708 ahash_request_free(req);
710 out:
711 crypto_free_ahash(tfm);
714 static void test_available(void)
716 char **name = check;
718 while (*name) {
719 printk("alg %s ", *name);
720 printk(crypto_has_alg(*name, 0, 0) ?
721 "found\n" : "not found\n");
722 name++;
726 static inline int tcrypt_test(const char *alg)
728 int ret;
730 ret = alg_test(alg, alg, 0, 0);
731 /* non-fips algs return -EINVAL in fips mode */
732 if (fips_enabled && ret == -EINVAL)
733 ret = 0;
734 return ret;
737 static int do_test(int m)
739 int i;
740 int ret = 0;
742 switch (m) {
743 case 0:
744 for (i = 1; i < 200; i++)
745 ret += do_test(i);
746 break;
748 case 1:
749 ret += tcrypt_test("md5");
750 break;
752 case 2:
753 ret += tcrypt_test("sha1");
754 break;
756 case 3:
757 ret += tcrypt_test("ecb(des)");
758 ret += tcrypt_test("cbc(des)");
759 break;
761 case 4:
762 ret += tcrypt_test("ecb(des3_ede)");
763 ret += tcrypt_test("cbc(des3_ede)");
764 break;
766 case 5:
767 ret += tcrypt_test("md4");
768 break;
770 case 6:
771 ret += tcrypt_test("sha256");
772 break;
774 case 7:
775 ret += tcrypt_test("ecb(blowfish)");
776 ret += tcrypt_test("cbc(blowfish)");
777 break;
779 case 8:
780 ret += tcrypt_test("ecb(twofish)");
781 ret += tcrypt_test("cbc(twofish)");
782 break;
784 case 9:
785 ret += tcrypt_test("ecb(serpent)");
786 break;
788 case 10:
789 ret += tcrypt_test("ecb(aes)");
790 ret += tcrypt_test("cbc(aes)");
791 ret += tcrypt_test("lrw(aes)");
792 ret += tcrypt_test("xts(aes)");
793 ret += tcrypt_test("ctr(aes)");
794 ret += tcrypt_test("rfc3686(ctr(aes))");
795 break;
797 case 11:
798 ret += tcrypt_test("sha384");
799 break;
801 case 12:
802 ret += tcrypt_test("sha512");
803 break;
805 case 13:
806 ret += tcrypt_test("deflate");
807 break;
809 case 14:
810 ret += tcrypt_test("ecb(cast5)");
811 break;
813 case 15:
814 ret += tcrypt_test("ecb(cast6)");
815 break;
817 case 16:
818 ret += tcrypt_test("ecb(arc4)");
819 break;
821 case 17:
822 ret += tcrypt_test("michael_mic");
823 break;
825 case 18:
826 ret += tcrypt_test("crc32c");
827 break;
829 case 19:
830 ret += tcrypt_test("ecb(tea)");
831 break;
833 case 20:
834 ret += tcrypt_test("ecb(xtea)");
835 break;
837 case 21:
838 ret += tcrypt_test("ecb(khazad)");
839 break;
841 case 22:
842 ret += tcrypt_test("wp512");
843 break;
845 case 23:
846 ret += tcrypt_test("wp384");
847 break;
849 case 24:
850 ret += tcrypt_test("wp256");
851 break;
853 case 25:
854 ret += tcrypt_test("ecb(tnepres)");
855 break;
857 case 26:
858 ret += tcrypt_test("ecb(anubis)");
859 ret += tcrypt_test("cbc(anubis)");
860 break;
862 case 27:
863 ret += tcrypt_test("tgr192");
864 break;
866 case 28:
868 ret += tcrypt_test("tgr160");
869 break;
871 case 29:
872 ret += tcrypt_test("tgr128");
873 break;
875 case 30:
876 ret += tcrypt_test("ecb(xeta)");
877 break;
879 case 31:
880 ret += tcrypt_test("pcbc(fcrypt)");
881 break;
883 case 32:
884 ret += tcrypt_test("ecb(camellia)");
885 ret += tcrypt_test("cbc(camellia)");
886 break;
887 case 33:
888 ret += tcrypt_test("sha224");
889 break;
891 case 34:
892 ret += tcrypt_test("salsa20");
893 break;
895 case 35:
896 ret += tcrypt_test("gcm(aes)");
897 break;
899 case 36:
900 ret += tcrypt_test("lzo");
901 break;
903 case 37:
904 ret += tcrypt_test("ccm(aes)");
905 break;
907 case 38:
908 ret += tcrypt_test("cts(cbc(aes))");
909 break;
911 case 39:
912 ret += tcrypt_test("rmd128");
913 break;
915 case 40:
916 ret += tcrypt_test("rmd160");
917 break;
919 case 41:
920 ret += tcrypt_test("rmd256");
921 break;
923 case 42:
924 ret += tcrypt_test("rmd320");
925 break;
927 case 43:
928 ret += tcrypt_test("ecb(seed)");
929 break;
931 case 44:
932 ret += tcrypt_test("zlib");
933 break;
935 case 45:
936 ret += tcrypt_test("rfc4309(ccm(aes))");
937 break;
939 case 100:
940 ret += tcrypt_test("hmac(md5)");
941 break;
943 case 101:
944 ret += tcrypt_test("hmac(sha1)");
945 break;
947 case 102:
948 ret += tcrypt_test("hmac(sha256)");
949 break;
951 case 103:
952 ret += tcrypt_test("hmac(sha384)");
953 break;
955 case 104:
956 ret += tcrypt_test("hmac(sha512)");
957 break;
959 case 105:
960 ret += tcrypt_test("hmac(sha224)");
961 break;
963 case 106:
964 ret += tcrypt_test("xcbc(aes)");
965 break;
967 case 107:
968 ret += tcrypt_test("hmac(rmd128)");
969 break;
971 case 108:
972 ret += tcrypt_test("hmac(rmd160)");
973 break;
975 case 109:
976 ret += tcrypt_test("vmac(aes)");
977 break;
979 case 150:
980 ret += tcrypt_test("ansi_cprng");
981 break;
983 case 200:
984 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
985 speed_template_16_24_32);
986 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
987 speed_template_16_24_32);
988 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
989 speed_template_16_24_32);
990 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
991 speed_template_16_24_32);
992 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
993 speed_template_32_40_48);
994 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
995 speed_template_32_40_48);
996 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
997 speed_template_32_48_64);
998 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
999 speed_template_32_48_64);
1000 break;
1002 case 201:
1003 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
1004 des3_speed_template, DES3_SPEED_VECTORS,
1005 speed_template_24);
1006 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
1007 des3_speed_template, DES3_SPEED_VECTORS,
1008 speed_template_24);
1009 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
1010 des3_speed_template, DES3_SPEED_VECTORS,
1011 speed_template_24);
1012 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
1013 des3_speed_template, DES3_SPEED_VECTORS,
1014 speed_template_24);
1015 break;
1017 case 202:
1018 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
1019 speed_template_16_24_32);
1020 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
1021 speed_template_16_24_32);
1022 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
1023 speed_template_16_24_32);
1024 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
1025 speed_template_16_24_32);
1026 break;
1028 case 203:
1029 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
1030 speed_template_8_32);
1031 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
1032 speed_template_8_32);
1033 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
1034 speed_template_8_32);
1035 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
1036 speed_template_8_32);
1037 break;
1039 case 204:
1040 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
1041 speed_template_8);
1042 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
1043 speed_template_8);
1044 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
1045 speed_template_8);
1046 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
1047 speed_template_8);
1048 break;
1050 case 205:
1051 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
1052 speed_template_16_24_32);
1053 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
1054 speed_template_16_24_32);
1055 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
1056 speed_template_16_24_32);
1057 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
1058 speed_template_16_24_32);
1059 break;
1061 case 206:
1062 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
1063 speed_template_16_32);
1064 break;
1066 case 300:
1067 /* fall through */
1069 case 301:
1070 test_hash_speed("md4", sec, generic_hash_speed_template);
1071 if (mode > 300 && mode < 400) break;
1073 case 302:
1074 test_hash_speed("md5", sec, generic_hash_speed_template);
1075 if (mode > 300 && mode < 400) break;
1077 case 303:
1078 test_hash_speed("sha1", sec, generic_hash_speed_template);
1079 if (mode > 300 && mode < 400) break;
1081 case 304:
1082 test_hash_speed("sha256", sec, generic_hash_speed_template);
1083 if (mode > 300 && mode < 400) break;
1085 case 305:
1086 test_hash_speed("sha384", sec, generic_hash_speed_template);
1087 if (mode > 300 && mode < 400) break;
1089 case 306:
1090 test_hash_speed("sha512", sec, generic_hash_speed_template);
1091 if (mode > 300 && mode < 400) break;
1093 case 307:
1094 test_hash_speed("wp256", sec, generic_hash_speed_template);
1095 if (mode > 300 && mode < 400) break;
1097 case 308:
1098 test_hash_speed("wp384", sec, generic_hash_speed_template);
1099 if (mode > 300 && mode < 400) break;
1101 case 309:
1102 test_hash_speed("wp512", sec, generic_hash_speed_template);
1103 if (mode > 300 && mode < 400) break;
1105 case 310:
1106 test_hash_speed("tgr128", sec, generic_hash_speed_template);
1107 if (mode > 300 && mode < 400) break;
1109 case 311:
1110 test_hash_speed("tgr160", sec, generic_hash_speed_template);
1111 if (mode > 300 && mode < 400) break;
1113 case 312:
1114 test_hash_speed("tgr192", sec, generic_hash_speed_template);
1115 if (mode > 300 && mode < 400) break;
1117 case 313:
1118 test_hash_speed("sha224", sec, generic_hash_speed_template);
1119 if (mode > 300 && mode < 400) break;
1121 case 314:
1122 test_hash_speed("rmd128", sec, generic_hash_speed_template);
1123 if (mode > 300 && mode < 400) break;
1125 case 315:
1126 test_hash_speed("rmd160", sec, generic_hash_speed_template);
1127 if (mode > 300 && mode < 400) break;
1129 case 316:
1130 test_hash_speed("rmd256", sec, generic_hash_speed_template);
1131 if (mode > 300 && mode < 400) break;
1133 case 317:
1134 test_hash_speed("rmd320", sec, generic_hash_speed_template);
1135 if (mode > 300 && mode < 400) break;
1137 case 318:
1138 test_hash_speed("ghash-generic", sec, hash_speed_template_16);
1139 if (mode > 300 && mode < 400) break;
1141 case 399:
1142 break;
1144 case 400:
1145 /* fall through */
1147 case 401:
1148 test_ahash_speed("md4", sec, generic_hash_speed_template);
1149 if (mode > 400 && mode < 500) break;
1151 case 402:
1152 test_ahash_speed("md5", sec, generic_hash_speed_template);
1153 if (mode > 400 && mode < 500) break;
1155 case 403:
1156 test_ahash_speed("sha1", sec, generic_hash_speed_template);
1157 if (mode > 400 && mode < 500) break;
1159 case 404:
1160 test_ahash_speed("sha256", sec, generic_hash_speed_template);
1161 if (mode > 400 && mode < 500) break;
1163 case 405:
1164 test_ahash_speed("sha384", sec, generic_hash_speed_template);
1165 if (mode > 400 && mode < 500) break;
1167 case 406:
1168 test_ahash_speed("sha512", sec, generic_hash_speed_template);
1169 if (mode > 400 && mode < 500) break;
1171 case 407:
1172 test_ahash_speed("wp256", sec, generic_hash_speed_template);
1173 if (mode > 400 && mode < 500) break;
1175 case 408:
1176 test_ahash_speed("wp384", sec, generic_hash_speed_template);
1177 if (mode > 400 && mode < 500) break;
1179 case 409:
1180 test_ahash_speed("wp512", sec, generic_hash_speed_template);
1181 if (mode > 400 && mode < 500) break;
1183 case 410:
1184 test_ahash_speed("tgr128", sec, generic_hash_speed_template);
1185 if (mode > 400 && mode < 500) break;
1187 case 411:
1188 test_ahash_speed("tgr160", sec, generic_hash_speed_template);
1189 if (mode > 400 && mode < 500) break;
1191 case 412:
1192 test_ahash_speed("tgr192", sec, generic_hash_speed_template);
1193 if (mode > 400 && mode < 500) break;
1195 case 413:
1196 test_ahash_speed("sha224", sec, generic_hash_speed_template);
1197 if (mode > 400 && mode < 500) break;
1199 case 414:
1200 test_ahash_speed("rmd128", sec, generic_hash_speed_template);
1201 if (mode > 400 && mode < 500) break;
1203 case 415:
1204 test_ahash_speed("rmd160", sec, generic_hash_speed_template);
1205 if (mode > 400 && mode < 500) break;
1207 case 416:
1208 test_ahash_speed("rmd256", sec, generic_hash_speed_template);
1209 if (mode > 400 && mode < 500) break;
1211 case 417:
1212 test_ahash_speed("rmd320", sec, generic_hash_speed_template);
1213 if (mode > 400 && mode < 500) break;
1215 case 499:
1216 break;
1218 case 1000:
1219 test_available();
1220 break;
1223 return ret;
1226 static int do_alg_test(const char *alg, u32 type, u32 mask)
1228 return crypto_has_alg(alg, type, mask ?: CRYPTO_ALG_TYPE_MASK) ?
1229 0 : -ENOENT;
1232 static int __init tcrypt_mod_init(void)
1234 int err = -ENOMEM;
1235 int i;
1237 for (i = 0; i < TVMEMSIZE; i++) {
1238 tvmem[i] = (void *)__get_free_page(GFP_KERNEL);
1239 if (!tvmem[i])
1240 goto err_free_tv;
1243 if (alg)
1244 err = do_alg_test(alg, type, mask);
1245 else
1246 err = do_test(mode);
1248 if (err) {
1249 printk(KERN_ERR "tcrypt: one or more tests failed!\n");
1250 goto err_free_tv;
1253 /* We intentionaly return -EAGAIN to prevent keeping the module,
1254 * unless we're running in fips mode. It does all its work from
1255 * init() and doesn't offer any runtime functionality, but in
1256 * the fips case, checking for a successful load is helpful.
1257 * => we don't need it in the memory, do we?
1258 * -- mludvig
1260 if (!fips_enabled)
1261 err = -EAGAIN;
1263 err_free_tv:
1264 for (i = 0; i < TVMEMSIZE && tvmem[i]; i++)
1265 free_page((unsigned long)tvmem[i]);
1267 return err;
1271 * If an init function is provided, an exit function must also be provided
1272 * to allow module unload.
1274 static void __exit tcrypt_mod_fini(void) { }
1276 module_init(tcrypt_mod_init);
1277 module_exit(tcrypt_mod_fini);
1279 module_param(alg, charp, 0);
1280 module_param(type, uint, 0);
1281 module_param(mask, uint, 0);
1282 module_param(mode, int, 0);
1283 module_param(sec, uint, 0);
1284 MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
1285 "(defaults to zero which uses CPU cycles instead)");
1287 MODULE_LICENSE("GPL");
1288 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
1289 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");