]> bbs.cooldavid.org Git - net-next-2.6.git/blame_incremental - crypto/tcrypt.c
git://bbs.cooldavid.org / net-next-2.6.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
rtnetlink: Link address family API
[net-next-2.6.git] / crypto / tcrypt.c
... / ...
CommitLineData
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/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"
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 */
46static unsigned int sec;
47
48static char *alg = NULL;
49static u32 type;
50static u32 mask;
51static int mode;
52static char *tvmem[TVMEMSIZE];
53
54static 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
63static 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
86static 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
124out:
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
135static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 };
136
137static 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
231out:
232 crypto_free_blkcipher(tfm);
233}
234
235static 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
256static 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
288static 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
320out:
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
333static 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
384out:
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
397static void test_hash_sg_init(struct scatterlist *sg)
398{
399 int i;
400
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);
405 }
406}
407
408static void test_hash_speed(const char *algo, unsigned int sec,
409 struct hash_speed *speed)
410{
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;
417
418 printk(KERN_INFO "\ntesting speed of %s\n", algo);
419
420 tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
421
422 if (IS_ERR(tfm)) {
423 printk(KERN_ERR "failed to load transform for %s: %ld\n", algo,
424 PTR_ERR(tfm));
425 return;
426 }
427
428 desc.tfm = tfm;
429 desc.flags = 0;
430
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;
435 }
436
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;
444 }
445
446 if (speed[i].klen)
447 crypto_hash_setkey(tfm, tvmem[0], speed[i].klen);
448
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);
452
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);
459
460 if (ret) {
461 printk(KERN_ERR "hashing failed ret=%d\n", ret);
462 break;
463 }
464 }
465
466out:
467 crypto_free_hash(tfm);
468}
469
470struct tcrypt_result {
471 struct completion completion;
472 int err;
473};
474
475static void tcrypt_complete(struct crypto_async_request *req, int err)
476{
477 struct tcrypt_result *res = req->data;
478
479 if (err == -EINPROGRESS)
480 return;
481
482 res->err = err;
483 complete(&res->completion);
484}
485
486static inline int do_one_ahash_op(struct ahash_request *req, int ret)
487{
488 if (ret == -EINPROGRESS || ret == -EBUSY) {
489 struct tcrypt_result *tr = req->base.data;
490
491 ret = wait_for_completion_interruptible(&tr->completion);
492 if (!ret)
493 ret = tr->err;
494 INIT_COMPLETION(tr->completion);
495 }
496 return ret;
497}
498
499static int test_ahash_jiffies_digest(struct ahash_request *req, int blen,
500 char *out, int sec)
501{
502 unsigned long start, end;
503 int bcount;
504 int ret;
505
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;
511 }
512
513 printk("%6u opers/sec, %9lu bytes/sec\n",
514 bcount / sec, ((long)bcount * blen) / sec);
515
516 return 0;
517}
518
519static int test_ahash_jiffies(struct ahash_request *req, int blen,
520 int plen, char *out, int sec)
521{
522 unsigned long start, end;
523 int bcount, pcount;
524 int ret;
525
526 if (plen == blen)
527 return test_ahash_jiffies_digest(req, blen, out, sec);
528
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;
538 }
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;
543 }
544
545 pr_cont("%6u opers/sec, %9lu bytes/sec\n",
546 bcount / sec, ((long)bcount * blen) / sec);
547
548 return 0;
549}
550
551static int test_ahash_cycles_digest(struct ahash_request *req, int blen,
552 char *out)
553{
554 unsigned long cycles = 0;
555 int ret, i;
556
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;
562 }
563
564 /* The real thing. */
565 for (i = 0; i < 8; i++) {
566 cycles_t start, end;
567
568 start = get_cycles();
569
570 ret = do_one_ahash_op(req, crypto_ahash_digest(req));
571 if (ret)
572 goto out;
573
574 end = get_cycles();
575
576 cycles += end - start;
577 }
578
579out:
580 if (ret)
581 return ret;
582
583 pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
584 cycles / 8, cycles / (8 * blen));
585
586 return 0;
587}
588
589static int test_ahash_cycles(struct ahash_request *req, int blen,
590 int plen, char *out)
591{
592 unsigned long cycles = 0;
593 int i, pcount, ret;
594
595 if (plen == blen)
596 return test_ahash_cycles_digest(req, blen, out);
597
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;
607 }
608 ret = do_one_ahash_op(req, crypto_ahash_final(req));
609 if (ret)
610 goto out;
611 }
612
613 /* The real thing. */
614 for (i = 0; i < 8; i++) {
615 cycles_t start, end;
616
617 start = get_cycles();
618
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;
626 }
627 ret = do_one_ahash_op(req, crypto_ahash_final(req));
628 if (ret)
629 goto out;
630
631 end = get_cycles();
632
633 cycles += end - start;
634 }
635
636out:
637 if (ret)
638 return ret;
639
640 pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
641 cycles / 8, cycles / (8 * blen));
642
643 return 0;
644}
645
646static void test_ahash_speed(const char *algo, unsigned int sec,
647 struct hash_speed *speed)
648{
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;
655
656 printk(KERN_INFO "\ntesting speed of async %s\n", algo);
657
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;
663 }
664
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;
669 }
670
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;
676 }
677
678 init_completion(&tresult.completion);
679 ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
680 tcrypt_complete, &tresult);
681
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;
687 }
688
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);
692
693 ahash_request_set_crypt(req, sg, output, speed[i].plen);
694
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);
701
702 if (ret) {
703 pr_err("hashing failed ret=%d\n", ret);
704 break;
705 }
706 }
707
708 ahash_request_free(req);
709
710out:
711 crypto_free_ahash(tfm);
712}
713
714static void test_available(void)
715{
716 char **name = check;
717
718 while (*name) {
719 printk("alg %s ", *name);
720 printk(crypto_has_alg(*name, 0, 0) ?
721 "found\n" : "not found\n");
722 name++;
723 }
724}
725
726static inline int tcrypt_test(const char *alg)
727{
728 int ret;
729
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;
735}
736
737static int do_test(int m)
738{
739 int i;
740 int ret = 0;
741
742 switch (m) {
743 case 0:
744 for (i = 1; i < 200; i++)
745 ret += do_test(i);
746 break;
747
748 case 1:
749 ret += tcrypt_test("md5");
750 break;
751
752 case 2:
753 ret += tcrypt_test("sha1");
754 break;
755
756 case 3:
757 ret += tcrypt_test("ecb(des)");
758 ret += tcrypt_test("cbc(des)");
759 break;
760
761 case 4:
762 ret += tcrypt_test("ecb(des3_ede)");
763 ret += tcrypt_test("cbc(des3_ede)");
764 break;
765
766 case 5:
767 ret += tcrypt_test("md4");
768 break;
769
770 case 6:
771 ret += tcrypt_test("sha256");
772 break;
773
774 case 7:
775 ret += tcrypt_test("ecb(blowfish)");
776 ret += tcrypt_test("cbc(blowfish)");
777 break;
778
779 case 8:
780 ret += tcrypt_test("ecb(twofish)");
781 ret += tcrypt_test("cbc(twofish)");
782 break;
783
784 case 9:
785 ret += tcrypt_test("ecb(serpent)");
786 break;
787
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;
796
797 case 11:
798 ret += tcrypt_test("sha384");
799 break;
800
801 case 12:
802 ret += tcrypt_test("sha512");
803 break;
804
805 case 13:
806 ret += tcrypt_test("deflate");
807 break;
808
809 case 14:
810 ret += tcrypt_test("ecb(cast5)");
811 break;
812
813 case 15:
814 ret += tcrypt_test("ecb(cast6)");
815 break;
816
817 case 16:
818 ret += tcrypt_test("ecb(arc4)");
819 break;
820
821 case 17:
822 ret += tcrypt_test("michael_mic");
823 break;
824
825 case 18:
826 ret += tcrypt_test("crc32c");
827 break;
828
829 case 19:
830 ret += tcrypt_test("ecb(tea)");
831 break;
832
833 case 20:
834 ret += tcrypt_test("ecb(xtea)");
835 break;
836
837 case 21:
838 ret += tcrypt_test("ecb(khazad)");
839 break;
840
841 case 22:
842 ret += tcrypt_test("wp512");
843 break;
844
845 case 23:
846 ret += tcrypt_test("wp384");
847 break;
848
849 case 24:
850 ret += tcrypt_test("wp256");
851 break;
852
853 case 25:
854 ret += tcrypt_test("ecb(tnepres)");
855 break;
856
857 case 26:
858 ret += tcrypt_test("ecb(anubis)");
859 ret += tcrypt_test("cbc(anubis)");
860 break;
861
862 case 27:
863 ret += tcrypt_test("tgr192");
864 break;
865
866 case 28:
867
868 ret += tcrypt_test("tgr160");
869 break;
870
871 case 29:
872 ret += tcrypt_test("tgr128");
873 break;
874
875 case 30:
876 ret += tcrypt_test("ecb(xeta)");
877 break;
878
879 case 31:
880 ret += tcrypt_test("pcbc(fcrypt)");
881 break;
882
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;
890
891 case 34:
892 ret += tcrypt_test("salsa20");
893 break;
894
895 case 35:
896 ret += tcrypt_test("gcm(aes)");
897 break;
898
899 case 36:
900 ret += tcrypt_test("lzo");
901 break;
902
903 case 37:
904 ret += tcrypt_test("ccm(aes)");
905 break;
906
907 case 38:
908 ret += tcrypt_test("cts(cbc(aes))");
909 break;
910
911 case 39:
912 ret += tcrypt_test("rmd128");
913 break;
914
915 case 40:
916 ret += tcrypt_test("rmd160");
917 break;
918
919 case 41:
920 ret += tcrypt_test("rmd256");
921 break;
922
923 case 42:
924 ret += tcrypt_test("rmd320");
925 break;
926
927 case 43:
928 ret += tcrypt_test("ecb(seed)");
929 break;
930
931 case 44:
932 ret += tcrypt_test("zlib");
933 break;
934
935 case 45:
936 ret += tcrypt_test("rfc4309(ccm(aes))");
937 break;
938
939 case 100:
940 ret += tcrypt_test("hmac(md5)");
941 break;
942
943 case 101:
944 ret += tcrypt_test("hmac(sha1)");
945 break;
946
947 case 102:
948 ret += tcrypt_test("hmac(sha256)");
949 break;
950
951 case 103:
952 ret += tcrypt_test("hmac(sha384)");
953 break;
954
955 case 104:
956 ret += tcrypt_test("hmac(sha512)");
957 break;
958
959 case 105:
960 ret += tcrypt_test("hmac(sha224)");
961 break;
962
963 case 106:
964 ret += tcrypt_test("xcbc(aes)");
965 break;
966
967 case 107:
968 ret += tcrypt_test("hmac(rmd128)");
969 break;
970
971 case 108:
972 ret += tcrypt_test("hmac(rmd160)");
973 break;
974
975 case 109:
976 ret += tcrypt_test("vmac(aes)");
977 break;
978
979 case 150:
980 ret += tcrypt_test("ansi_cprng");
981 break;
982
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;
1001
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;
1016
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;
1027
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;
1038
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;
1049
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;
1060
1061 case 206:
1062 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
1063 speed_template_16_32);
1064 break;
1065
1066 case 300:
1067 /* fall through */
1068
1069 case 301:
1070 test_hash_speed("md4", sec, generic_hash_speed_template);
1071 if (mode > 300 && mode < 400) break;
1072
1073 case 302:
1074 test_hash_speed("md5", sec, generic_hash_speed_template);
1075 if (mode > 300 && mode < 400) break;
1076
1077 case 303:
1078 test_hash_speed("sha1", sec, generic_hash_speed_template);
1079 if (mode > 300 && mode < 400) break;
1080
1081 case 304:
1082 test_hash_speed("sha256", sec, generic_hash_speed_template);
1083 if (mode > 300 && mode < 400) break;
1084
1085 case 305:
1086 test_hash_speed("sha384", sec, generic_hash_speed_template);
1087 if (mode > 300 && mode < 400) break;
1088
1089 case 306:
1090 test_hash_speed("sha512", sec, generic_hash_speed_template);
1091 if (mode > 300 && mode < 400) break;
1092
1093 case 307:
1094 test_hash_speed("wp256", sec, generic_hash_speed_template);
1095 if (mode > 300 && mode < 400) break;
1096
1097 case 308:
1098 test_hash_speed("wp384", sec, generic_hash_speed_template);
1099 if (mode > 300 && mode < 400) break;
1100
1101 case 309:
1102 test_hash_speed("wp512", sec, generic_hash_speed_template);
1103 if (mode > 300 && mode < 400) break;
1104
1105 case 310:
1106 test_hash_speed("tgr128", sec, generic_hash_speed_template);
1107 if (mode > 300 && mode < 400) break;
1108
1109 case 311:
1110 test_hash_speed("tgr160", sec, generic_hash_speed_template);
1111 if (mode > 300 && mode < 400) break;
1112
1113 case 312:
1114 test_hash_speed("tgr192", sec, generic_hash_speed_template);
1115 if (mode > 300 && mode < 400) break;
1116
1117 case 313:
1118 test_hash_speed("sha224", sec, generic_hash_speed_template);
1119 if (mode > 300 && mode < 400) break;
1120
1121 case 314:
1122 test_hash_speed("rmd128", sec, generic_hash_speed_template);
1123 if (mode > 300 && mode < 400) break;
1124
1125 case 315:
1126 test_hash_speed("rmd160", sec, generic_hash_speed_template);
1127 if (mode > 300 && mode < 400) break;
1128
1129 case 316:
1130 test_hash_speed("rmd256", sec, generic_hash_speed_template);
1131 if (mode > 300 && mode < 400) break;
1132
1133 case 317:
1134 test_hash_speed("rmd320", sec, generic_hash_speed_template);
1135 if (mode > 300 && mode < 400) break;
1136
1137 case 318:
1138 test_hash_speed("ghash-generic", sec, hash_speed_template_16);
1139 if (mode > 300 && mode < 400) break;
1140
1141 case 399:
1142 break;
1143
1144 case 400:
1145 /* fall through */
1146
1147 case 401:
1148 test_ahash_speed("md4", sec, generic_hash_speed_template);
1149 if (mode > 400 && mode < 500) break;
1150
1151 case 402:
1152 test_ahash_speed("md5", sec, generic_hash_speed_template);
1153 if (mode > 400 && mode < 500) break;
1154
1155 case 403:
1156 test_ahash_speed("sha1", sec, generic_hash_speed_template);
1157 if (mode > 400 && mode < 500) break;
1158
1159 case 404:
1160 test_ahash_speed("sha256", sec, generic_hash_speed_template);
1161 if (mode > 400 && mode < 500) break;
1162
1163 case 405:
1164 test_ahash_speed("sha384", sec, generic_hash_speed_template);
1165 if (mode > 400 && mode < 500) break;
1166
1167 case 406:
1168 test_ahash_speed("sha512", sec, generic_hash_speed_template);
1169 if (mode > 400 && mode < 500) break;
1170
1171 case 407:
1172 test_ahash_speed("wp256", sec, generic_hash_speed_template);
1173 if (mode > 400 && mode < 500) break;
1174
1175 case 408:
1176 test_ahash_speed("wp384", sec, generic_hash_speed_template);
1177 if (mode > 400 && mode < 500) break;
1178
1179 case 409:
1180 test_ahash_speed("wp512", sec, generic_hash_speed_template);
1181 if (mode > 400 && mode < 500) break;
1182
1183 case 410:
1184 test_ahash_speed("tgr128", sec, generic_hash_speed_template);
1185 if (mode > 400 && mode < 500) break;
1186
1187 case 411:
1188 test_ahash_speed("tgr160", sec, generic_hash_speed_template);
1189 if (mode > 400 && mode < 500) break;
1190
1191 case 412:
1192 test_ahash_speed("tgr192", sec, generic_hash_speed_template);
1193 if (mode > 400 && mode < 500) break;
1194
1195 case 413:
1196 test_ahash_speed("sha224", sec, generic_hash_speed_template);
1197 if (mode > 400 && mode < 500) break;
1198
1199 case 414:
1200 test_ahash_speed("rmd128", sec, generic_hash_speed_template);
1201 if (mode > 400 && mode < 500) break;
1202
1203 case 415:
1204 test_ahash_speed("rmd160", sec, generic_hash_speed_template);
1205 if (mode > 400 && mode < 500) break;
1206
1207 case 416:
1208 test_ahash_speed("rmd256", sec, generic_hash_speed_template);
1209 if (mode > 400 && mode < 500) break;
1210
1211 case 417:
1212 test_ahash_speed("rmd320", sec, generic_hash_speed_template);
1213 if (mode > 400 && mode < 500) break;
1214
1215 case 499:
1216 break;
1217
1218 case 1000:
1219 test_available();
1220 break;
1221 }
1222
1223 return ret;
1224}
1225
1226static int do_alg_test(const char *alg, u32 type, u32 mask)
1227{
1228 return crypto_has_alg(alg, type, mask ?: CRYPTO_ALG_TYPE_MASK) ?
1229 0 : -ENOENT;
1230}
1231
1232static int __init tcrypt_mod_init(void)
1233{
1234 int err = -ENOMEM;
1235 int i;
1236
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;
1241 }
1242
1243 if (alg)
1244 err = do_alg_test(alg, type, mask);
1245 else
1246 err = do_test(mode);
1247
1248 if (err) {
1249 printk(KERN_ERR "tcrypt: one or more tests failed!\n");
1250 goto err_free_tv;
1251 }
1252
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
1259 */
1260 if (!fips_enabled)
1261 err = -EAGAIN;
1262
1263err_free_tv:
1264 for (i = 0; i < TVMEMSIZE && tvmem[i]; i++)
1265 free_page((unsigned long)tvmem[i]);
1266
1267 return err;
1268}
1269
1270/*
1271 * If an init function is provided, an exit function must also be provided
1272 * to allow module unload.
1273 */
1274static void __exit tcrypt_mod_fini(void) { }
1275
1276module_init(tcrypt_mod_init);
1277module_exit(tcrypt_mod_fini);
1278
1279module_param(alg, charp, 0);
1280module_param(type, uint, 0);
1281module_param(mask, uint, 0);
1282module_param(mode, int, 0);
1283module_param(sec, uint, 0);
1284MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
1285 "(defaults to zero which uses CPU cycles instead)");
1286
1287MODULE_LICENSE("GPL");
1288MODULE_DESCRIPTION("Quick & dirty crypto testing module");
1289MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
Clone of davem's net-next-2.6 tree