?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
KEYS: Fix up comments in key management code
[linux-2.6/next.git] / crypto / tcrypt.c
blob9aac5e58be94063a9502156cbe032905669d8038
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 * Updated RFC4106 AES-GCM testing.
12 * Authors: Aidan O'Mahony (aidan.o.mahony@intel.com)
13 * Adrian Hoban <adrian.hoban@intel.com>
14 * Gabriele Paoloni <gabriele.paoloni@intel.com>
15 * Tadeusz Struk (tadeusz.struk@intel.com)
16 * Copyright (c) 2010, Intel Corporation.
17 *
18 * This program is free software; you can redistribute it and/or modify it
19 * under the terms of the GNU General Public License as published by the Free
20 * Software Foundation; either version 2 of the License, or (at your option)
21 * any later version.
22 *
23 */
24
25 #include <crypto/hash.h>
26 #include <linux/err.h>
27 #include <linux/init.h>
28 #include <linux/gfp.h>
29 #include <linux/module.h>
30 #include <linux/scatterlist.h>
31 #include <linux/string.h>
32 #include <linux/moduleparam.h>
33 #include <linux/jiffies.h>
34 #include <linux/timex.h>
35 #include <linux/interrupt.h>
36 #include "tcrypt.h"
37 #include "internal.h"
38
39 /*
40 * Need slab memory for testing (size in number of pages).
41 */
42 #define TVMEMSIZE 4
43
44 /*
45 * Used by test_cipher_speed()
46 */
47 #define ENCRYPT 1
48 #define DECRYPT 0
49
50 /*
51 * Used by test_cipher_speed()
52 */
53 static unsigned int sec;
54
55 static char *alg = NULL;
56 static u32 type;
57 static u32 mask;
58 static int mode;
59 static char *tvmem[TVMEMSIZE];
60
61 static char *check[] = {
62 "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256",
63 "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes",
64 "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
65 "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", "fcrypt",
66 "camellia", "seed", "salsa20", "rmd128", "rmd160", "rmd256", "rmd320",
67 "lzo", "cts", "zlib", NULL
68 };
69
70 static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc,
71 struct scatterlist *sg, int blen, int sec)
72 {
73 unsigned long start, end;
74 int bcount;
75 int ret;
76
77 for (start = jiffies, end = start + sec * HZ, bcount = 0;
78 time_before(jiffies, end); bcount++) {
79 if (enc)
80 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
81 else
82 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
83
84 if (ret)
85 return ret;
86 }
87
88 printk("%d operations in %d seconds (%ld bytes)\n",
89 bcount, sec, (long)bcount * blen);
90 return 0;
91 }
92
93 static int test_cipher_cycles(struct blkcipher_desc *desc, int enc,
94 struct scatterlist *sg, int blen)
95 {
96 unsigned long cycles = 0;
97 int ret = 0;
98 int i;
99
100 local_bh_disable();
101 local_irq_disable();
102
103 /* Warm-up run. */
104 for (i = 0; i < 4; i++) {
105 if (enc)
106 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
107 else
108 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
109
110 if (ret)
111 goto out;
112 }
113
114 /* The real thing. */
115 for (i = 0; i < 8; i++) {
116 cycles_t start, end;
117
118 start = get_cycles();
119 if (enc)
120 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
121 else
122 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
123 end = get_cycles();
124
125 if (ret)
126 goto out;
127
128 cycles += end - start;
129 }
130
131 out:
132 local_irq_enable();
133 local_bh_enable();
134
135 if (ret == 0)
136 printk("1 operation in %lu cycles (%d bytes)\n",
137 (cycles + 4) / 8, blen);
138
139 return ret;
140 }
141
142 static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 };
143
144 static void test_cipher_speed(const char *algo, int enc, unsigned int sec,
145 struct cipher_speed_template *template,
146 unsigned int tcount, u8 *keysize)
147 {
148 unsigned int ret, i, j, iv_len;
149 const char *key, iv[128];
150 struct crypto_blkcipher *tfm;
151 struct blkcipher_desc desc;
152 const char *e;
153 u32 *b_size;
154
155 if (enc == ENCRYPT)
156 e = "encryption";
157 else
158 e = "decryption";
159
160 printk("\ntesting speed of %s %s\n", algo, e);
161
162 tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);
163
164 if (IS_ERR(tfm)) {
165 printk("failed to load transform for %s: %ld\n", algo,
166 PTR_ERR(tfm));
167 return;
168 }
169 desc.tfm = tfm;
170 desc.flags = 0;
171
172 i = 0;
173 do {
174
175 b_size = block_sizes;
176 do {
177 struct scatterlist sg[TVMEMSIZE];
178
179 if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
180 printk("template (%u) too big for "
181 "tvmem (%lu)\n", *keysize + *b_size,
182 TVMEMSIZE * PAGE_SIZE);
183 goto out;
184 }
185
186 printk("test %u (%d bit key, %d byte blocks): ", i,
187 *keysize * 8, *b_size);
188
189 memset(tvmem[0], 0xff, PAGE_SIZE);
190
191 /* set key, plain text and IV */
192 key = tvmem[0];
193 for (j = 0; j < tcount; j++) {
194 if (template[j].klen == *keysize) {
195 key = template[j].key;
196 break;
197 }
198 }
199
200 ret = crypto_blkcipher_setkey(tfm, key, *keysize);
201 if (ret) {
202 printk("setkey() failed flags=%x\n",
203 crypto_blkcipher_get_flags(tfm));
204 goto out;
205 }
206
207 sg_init_table(sg, TVMEMSIZE);
208 sg_set_buf(sg, tvmem[0] + *keysize,
209 PAGE_SIZE - *keysize);
210 for (j = 1; j < TVMEMSIZE; j++) {
211 sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
212 memset (tvmem[j], 0xff, PAGE_SIZE);
213 }
214
215 iv_len = crypto_blkcipher_ivsize(tfm);
216 if (iv_len) {
217 memset(&iv, 0xff, iv_len);
218 crypto_blkcipher_set_iv(tfm, iv, iv_len);
219 }
220
221 if (sec)
222 ret = test_cipher_jiffies(&desc, enc, sg,
223 *b_size, sec);
224 else
225 ret = test_cipher_cycles(&desc, enc, sg,
226 *b_size);
227
228 if (ret) {
229 printk("%s() failed flags=%x\n", e, desc.flags);
230 break;
231 }
232 b_size++;
233 i++;
234 } while (*b_size);
235 keysize++;
236 } while (*keysize);
237
238 out:
239 crypto_free_blkcipher(tfm);
240 }
241
242 static int test_hash_jiffies_digest(struct hash_desc *desc,
243 struct scatterlist *sg, int blen,
244 char *out, int sec)
245 {
246 unsigned long start, end;
247 int bcount;
248 int ret;
249
250 for (start = jiffies, end = start + sec * HZ, bcount = 0;
251 time_before(jiffies, end); bcount++) {
252 ret = crypto_hash_digest(desc, sg, blen, out);
253 if (ret)
254 return ret;
255 }
256
257 printk("%6u opers/sec, %9lu bytes/sec\n",
258 bcount / sec, ((long)bcount * blen) / sec);
259
260 return 0;
261 }
262
263 static int test_hash_jiffies(struct hash_desc *desc, struct scatterlist *sg,
264 int blen, int plen, char *out, int sec)
265 {
266 unsigned long start, end;
267 int bcount, pcount;
268 int ret;
269
270 if (plen == blen)
271 return test_hash_jiffies_digest(desc, sg, blen, out, sec);
272
273 for (start = jiffies, end = start + sec * HZ, bcount = 0;
274 time_before(jiffies, end); bcount++) {
275 ret = crypto_hash_init(desc);
276 if (ret)
277 return ret;
278 for (pcount = 0; pcount < blen; pcount += plen) {
279 ret = crypto_hash_update(desc, sg, plen);
280 if (ret)
281 return ret;
282 }
283 /* we assume there is enough space in 'out' for the result */
284 ret = crypto_hash_final(desc, out);
285 if (ret)
286 return ret;
287 }
288
289 printk("%6u opers/sec, %9lu bytes/sec\n",
290 bcount / sec, ((long)bcount * blen) / sec);
291
292 return 0;
293 }
294
295 static int test_hash_cycles_digest(struct hash_desc *desc,
296 struct scatterlist *sg, int blen, char *out)
297 {
298 unsigned long cycles = 0;
299 int i;
300 int ret;
301
302 local_bh_disable();
303 local_irq_disable();
304
305 /* Warm-up run. */
306 for (i = 0; i < 4; i++) {
307 ret = crypto_hash_digest(desc, sg, blen, out);
308 if (ret)
309 goto out;
310 }
311
312 /* The real thing. */
313 for (i = 0; i < 8; i++) {
314 cycles_t start, end;
315
316 start = get_cycles();
317
318 ret = crypto_hash_digest(desc, sg, blen, out);
319 if (ret)
320 goto out;
321
322 end = get_cycles();
323
324 cycles += end - start;
325 }
326
327 out:
328 local_irq_enable();
329 local_bh_enable();
330
331 if (ret)
332 return ret;
333
334 printk("%6lu cycles/operation, %4lu cycles/byte\n",
335 cycles / 8, cycles / (8 * blen));
336
337 return 0;
338 }
339
340 static int test_hash_cycles(struct hash_desc *desc, struct scatterlist *sg,
341 int blen, int plen, char *out)
342 {
343 unsigned long cycles = 0;
344 int i, pcount;
345 int ret;
346
347 if (plen == blen)
348 return test_hash_cycles_digest(desc, sg, blen, out);
349
350 local_bh_disable();
351 local_irq_disable();
352
353 /* Warm-up run. */
354 for (i = 0; i < 4; i++) {
355 ret = crypto_hash_init(desc);
356 if (ret)
357 goto out;
358 for (pcount = 0; pcount < blen; pcount += plen) {
359 ret = crypto_hash_update(desc, sg, plen);
360 if (ret)
361 goto out;
362 }
363 ret = crypto_hash_final(desc, out);
364 if (ret)
365 goto out;
366 }
367
368 /* The real thing. */
369 for (i = 0; i < 8; i++) {
370 cycles_t start, end;
371
372 start = get_cycles();
373
374 ret = crypto_hash_init(desc);
375 if (ret)
376 goto out;
377 for (pcount = 0; pcount < blen; pcount += plen) {
378 ret = crypto_hash_update(desc, sg, plen);
379 if (ret)
380 goto out;
381 }
382 ret = crypto_hash_final(desc, out);
383 if (ret)
384 goto out;
385
386 end = get_cycles();
387
388 cycles += end - start;
389 }
390
391 out:
392 local_irq_enable();
393 local_bh_enable();
394
395 if (ret)
396 return ret;
397
398 printk("%6lu cycles/operation, %4lu cycles/byte\n",
399 cycles / 8, cycles / (8 * blen));
400
401 return 0;
402 }
403
404 static void test_hash_sg_init(struct scatterlist *sg)
405 {
406 int i;
407
408 sg_init_table(sg, TVMEMSIZE);
409 for (i = 0; i < TVMEMSIZE; i++) {
410 sg_set_buf(sg + i, tvmem[i], PAGE_SIZE);
411 memset(tvmem[i], 0xff, PAGE_SIZE);
412 }
413 }
414
415 static void test_hash_speed(const char *algo, unsigned int sec,
416 struct hash_speed *speed)
417 {
418 struct scatterlist sg[TVMEMSIZE];
419 struct crypto_hash *tfm;
420 struct hash_desc desc;
421 static char output[1024];
422 int i;
423 int ret;
424
425 printk(KERN_INFO "\ntesting speed of %s\n", algo);
426
427 tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
428
429 if (IS_ERR(tfm)) {
430 printk(KERN_ERR "failed to load transform for %s: %ld\n", algo,
431 PTR_ERR(tfm));
432 return;
433 }
434
435 desc.tfm = tfm;
436 desc.flags = 0;
437
438 if (crypto_hash_digestsize(tfm) > sizeof(output)) {
439 printk(KERN_ERR "digestsize(%u) > outputbuffer(%zu)\n",
440 crypto_hash_digestsize(tfm), sizeof(output));
441 goto out;
442 }
443
444 test_hash_sg_init(sg);
445 for (i = 0; speed[i].blen != 0; i++) {
446 if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
447 printk(KERN_ERR
448 "template (%u) too big for tvmem (%lu)\n",
449 speed[i].blen, TVMEMSIZE * PAGE_SIZE);
450 goto out;
451 }
452
453 if (speed[i].klen)
454 crypto_hash_setkey(tfm, tvmem[0], speed[i].klen);
455
456 printk(KERN_INFO "test%3u "
457 "(%5u byte blocks,%5u bytes per update,%4u updates): ",
458 i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
459
460 if (sec)
461 ret = test_hash_jiffies(&desc, sg, speed[i].blen,
462 speed[i].plen, output, sec);
463 else
464 ret = test_hash_cycles(&desc, sg, speed[i].blen,
465 speed[i].plen, output);
466
467 if (ret) {
468 printk(KERN_ERR "hashing failed ret=%d\n", ret);
469 break;
470 }
471 }
472
473 out:
474 crypto_free_hash(tfm);
475 }
476
477 struct tcrypt_result {
478 struct completion completion;
479 int err;
480 };
481
482 static void tcrypt_complete(struct crypto_async_request *req, int err)
483 {
484 struct tcrypt_result *res = req->data;
485
486 if (err == -EINPROGRESS)
487 return;
488
489 res->err = err;
490 complete(&res->completion);
491 }
492
493 static inline int do_one_ahash_op(struct ahash_request *req, int ret)
494 {
495 if (ret == -EINPROGRESS || ret == -EBUSY) {
496 struct tcrypt_result *tr = req->base.data;
497
498 ret = wait_for_completion_interruptible(&tr->completion);
499 if (!ret)
500 ret = tr->err;
501 INIT_COMPLETION(tr->completion);
502 }
503 return ret;
504 }
505
506 static int test_ahash_jiffies_digest(struct ahash_request *req, int blen,
507 char *out, int sec)
508 {
509 unsigned long start, end;
510 int bcount;
511 int ret;
512
513 for (start = jiffies, end = start + sec * HZ, bcount = 0;
514 time_before(jiffies, end); bcount++) {
515 ret = do_one_ahash_op(req, crypto_ahash_digest(req));
516 if (ret)
517 return ret;
518 }
519
520 printk("%6u opers/sec, %9lu bytes/sec\n",
521 bcount / sec, ((long)bcount * blen) / sec);
522
523 return 0;
524 }
525
526 static int test_ahash_jiffies(struct ahash_request *req, int blen,
527 int plen, char *out, int sec)
528 {
529 unsigned long start, end;
530 int bcount, pcount;
531 int ret;
532
533 if (plen == blen)
534 return test_ahash_jiffies_digest(req, blen, out, sec);
535
536 for (start = jiffies, end = start + sec * HZ, bcount = 0;
537 time_before(jiffies, end); bcount++) {
538 ret = crypto_ahash_init(req);
539 if (ret)
540 return ret;
541 for (pcount = 0; pcount < blen; pcount += plen) {
542 ret = do_one_ahash_op(req, crypto_ahash_update(req));
543 if (ret)
544 return ret;
545 }
546 /* we assume there is enough space in 'out' for the result */
547 ret = do_one_ahash_op(req, crypto_ahash_final(req));
548 if (ret)
549 return ret;
550 }
551
552 pr_cont("%6u opers/sec, %9lu bytes/sec\n",
553 bcount / sec, ((long)bcount * blen) / sec);
554
555 return 0;
556 }
557
558 static int test_ahash_cycles_digest(struct ahash_request *req, int blen,
559 char *out)
560 {
561 unsigned long cycles = 0;
562 int ret, i;
563
564 /* Warm-up run. */
565 for (i = 0; i < 4; i++) {
566 ret = do_one_ahash_op(req, crypto_ahash_digest(req));
567 if (ret)
568 goto out;
569 }
570
571 /* The real thing. */
572 for (i = 0; i < 8; i++) {
573 cycles_t start, end;
574
575 start = get_cycles();
576
577 ret = do_one_ahash_op(req, crypto_ahash_digest(req));
578 if (ret)
579 goto out;
580
581 end = get_cycles();
582
583 cycles += end - start;
584 }
585
586 out:
587 if (ret)
588 return ret;
589
590 pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
591 cycles / 8, cycles / (8 * blen));
592
593 return 0;
594 }
595
596 static int test_ahash_cycles(struct ahash_request *req, int blen,
597 int plen, char *out)
598 {
599 unsigned long cycles = 0;
600 int i, pcount, ret;
601
602 if (plen == blen)
603 return test_ahash_cycles_digest(req, blen, out);
604
605 /* Warm-up run. */
606 for (i = 0; i < 4; i++) {
607 ret = crypto_ahash_init(req);
608 if (ret)
609 goto out;
610 for (pcount = 0; pcount < blen; pcount += plen) {
611 ret = do_one_ahash_op(req, crypto_ahash_update(req));
612 if (ret)
613 goto out;
614 }
615 ret = do_one_ahash_op(req, crypto_ahash_final(req));
616 if (ret)
617 goto out;
618 }
619
620 /* The real thing. */
621 for (i = 0; i < 8; i++) {
622 cycles_t start, end;
623
624 start = get_cycles();
625
626 ret = crypto_ahash_init(req);
627 if (ret)
628 goto out;
629 for (pcount = 0; pcount < blen; pcount += plen) {
630 ret = do_one_ahash_op(req, crypto_ahash_update(req));
631 if (ret)
632 goto out;
633 }
634 ret = do_one_ahash_op(req, crypto_ahash_final(req));
635 if (ret)
636 goto out;
637
638 end = get_cycles();
639
640 cycles += end - start;
641 }
642
643 out:
644 if (ret)
645 return ret;
646
647 pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
648 cycles / 8, cycles / (8 * blen));
649
650 return 0;
651 }
652
653 static void test_ahash_speed(const char *algo, unsigned int sec,
654 struct hash_speed *speed)
655 {
656 struct scatterlist sg[TVMEMSIZE];
657 struct tcrypt_result tresult;
658 struct ahash_request *req;
659 struct crypto_ahash *tfm;
660 static char output[1024];
661 int i, ret;
662
663 printk(KERN_INFO "\ntesting speed of async %s\n", algo);
664
665 tfm = crypto_alloc_ahash(algo, 0, 0);
666 if (IS_ERR(tfm)) {
667 pr_err("failed to load transform for %s: %ld\n",
668 algo, PTR_ERR(tfm));
669 return;
670 }
671
672 if (crypto_ahash_digestsize(tfm) > sizeof(output)) {
673 pr_err("digestsize(%u) > outputbuffer(%zu)\n",
674 crypto_ahash_digestsize(tfm), sizeof(output));
675 goto out;
676 }
677
678 test_hash_sg_init(sg);
679 req = ahash_request_alloc(tfm, GFP_KERNEL);
680 if (!req) {
681 pr_err("ahash request allocation failure\n");
682 goto out;
683 }
684
685 init_completion(&tresult.completion);
686 ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
687 tcrypt_complete, &tresult);
688
689 for (i = 0; speed[i].blen != 0; i++) {
690 if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
691 pr_err("template (%u) too big for tvmem (%lu)\n",
692 speed[i].blen, TVMEMSIZE * PAGE_SIZE);
693 break;
694 }
695
696 pr_info("test%3u "
697 "(%5u byte blocks,%5u bytes per update,%4u updates): ",
698 i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
699
700 ahash_request_set_crypt(req, sg, output, speed[i].plen);
701
702 if (sec)
703 ret = test_ahash_jiffies(req, speed[i].blen,
704 speed[i].plen, output, sec);
705 else
706 ret = test_ahash_cycles(req, speed[i].blen,
707 speed[i].plen, output);
708
709 if (ret) {
710 pr_err("hashing failed ret=%d\n", ret);
711 break;
712 }
713 }
714
715 ahash_request_free(req);
716
717 out:
718 crypto_free_ahash(tfm);
719 }
720
721 static void test_available(void)
722 {
723 char **name = check;
724
725 while (*name) {
726 printk("alg %s ", *name);
727 printk(crypto_has_alg(*name, 0, 0) ?
728 "found\n" : "not found\n");
729 name++;
730 }
731 }
732
733 static inline int tcrypt_test(const char *alg)
734 {
735 int ret;
736
737 ret = alg_test(alg, alg, 0, 0);
738 /* non-fips algs return -EINVAL in fips mode */
739 if (fips_enabled && ret == -EINVAL)
740 ret = 0;
741 return ret;
742 }
743
744 static int do_test(int m)
745 {
746 int i;
747 int ret = 0;
748
749 switch (m) {
750 case 0:
751 for (i = 1; i < 200; i++)
752 ret += do_test(i);
753 break;
754
755 case 1:
756 ret += tcrypt_test("md5");
757 break;
758
759 case 2:
760 ret += tcrypt_test("sha1");
761 break;
762
763 case 3:
764 ret += tcrypt_test("ecb(des)");
765 ret += tcrypt_test("cbc(des)");
766 break;
767
768 case 4:
769 ret += tcrypt_test("ecb(des3_ede)");
770 ret += tcrypt_test("cbc(des3_ede)");
771 break;
772
773 case 5:
774 ret += tcrypt_test("md4");
775 break;
776
777 case 6:
778 ret += tcrypt_test("sha256");
779 break;
780
781 case 7:
782 ret += tcrypt_test("ecb(blowfish)");
783 ret += tcrypt_test("cbc(blowfish)");
784 break;
785
786 case 8:
787 ret += tcrypt_test("ecb(twofish)");
788 ret += tcrypt_test("cbc(twofish)");
789 break;
790
791 case 9:
792 ret += tcrypt_test("ecb(serpent)");
793 break;
794
795 case 10:
796 ret += tcrypt_test("ecb(aes)");
797 ret += tcrypt_test("cbc(aes)");
798 ret += tcrypt_test("lrw(aes)");
799 ret += tcrypt_test("xts(aes)");
800 ret += tcrypt_test("ctr(aes)");
801 ret += tcrypt_test("rfc3686(ctr(aes))");
802 break;
803
804 case 11:
805 ret += tcrypt_test("sha384");
806 break;
807
808 case 12:
809 ret += tcrypt_test("sha512");
810 break;
811
812 case 13:
813 ret += tcrypt_test("deflate");
814 break;
815
816 case 14:
817 ret += tcrypt_test("ecb(cast5)");
818 break;
819
820 case 15:
821 ret += tcrypt_test("ecb(cast6)");
822 break;
823
824 case 16:
825 ret += tcrypt_test("ecb(arc4)");
826 break;
827
828 case 17:
829 ret += tcrypt_test("michael_mic");
830 break;
831
832 case 18:
833 ret += tcrypt_test("crc32c");
834 break;
835
836 case 19:
837 ret += tcrypt_test("ecb(tea)");
838 break;
839
840 case 20:
841 ret += tcrypt_test("ecb(xtea)");
842 break;
843
844 case 21:
845 ret += tcrypt_test("ecb(khazad)");
846 break;
847
848 case 22:
849 ret += tcrypt_test("wp512");
850 break;
851
852 case 23:
853 ret += tcrypt_test("wp384");
854 break;
855
856 case 24:
857 ret += tcrypt_test("wp256");
858 break;
859
860 case 25:
861 ret += tcrypt_test("ecb(tnepres)");
862 break;
863
864 case 26:
865 ret += tcrypt_test("ecb(anubis)");
866 ret += tcrypt_test("cbc(anubis)");
867 break;
868
869 case 27:
870 ret += tcrypt_test("tgr192");
871 break;
872
873 case 28:
874
875 ret += tcrypt_test("tgr160");
876 break;
877
878 case 29:
879 ret += tcrypt_test("tgr128");
880 break;
881
882 case 30:
883 ret += tcrypt_test("ecb(xeta)");
884 break;
885
886 case 31:
887 ret += tcrypt_test("pcbc(fcrypt)");
888 break;
889
890 case 32:
891 ret += tcrypt_test("ecb(camellia)");
892 ret += tcrypt_test("cbc(camellia)");
893 break;
894 case 33:
895 ret += tcrypt_test("sha224");
896 break;
897
898 case 34:
899 ret += tcrypt_test("salsa20");
900 break;
901
902 case 35:
903 ret += tcrypt_test("gcm(aes)");
904 break;
905
906 case 36:
907 ret += tcrypt_test("lzo");
908 break;
909
910 case 37:
911 ret += tcrypt_test("ccm(aes)");
912 break;
913
914 case 38:
915 ret += tcrypt_test("cts(cbc(aes))");
916 break;
917
918 case 39:
919 ret += tcrypt_test("rmd128");
920 break;
921
922 case 40:
923 ret += tcrypt_test("rmd160");
924 break;
925
926 case 41:
927 ret += tcrypt_test("rmd256");
928 break;
929
930 case 42:
931 ret += tcrypt_test("rmd320");
932 break;
933
934 case 43:
935 ret += tcrypt_test("ecb(seed)");
936 break;
937
938 case 44:
939 ret += tcrypt_test("zlib");
940 break;
941
942 case 45:
943 ret += tcrypt_test("rfc4309(ccm(aes))");
944 break;
945
946 case 100:
947 ret += tcrypt_test("hmac(md5)");
948 break;
949
950 case 101:
951 ret += tcrypt_test("hmac(sha1)");
952 break;
953
954 case 102:
955 ret += tcrypt_test("hmac(sha256)");
956 break;
957
958 case 103:
959 ret += tcrypt_test("hmac(sha384)");
960 break;
961
962 case 104:
963 ret += tcrypt_test("hmac(sha512)");
964 break;
965
966 case 105:
967 ret += tcrypt_test("hmac(sha224)");
968 break;
969
970 case 106:
971 ret += tcrypt_test("xcbc(aes)");
972 break;
973
974 case 107:
975 ret += tcrypt_test("hmac(rmd128)");
976 break;
977
978 case 108:
979 ret += tcrypt_test("hmac(rmd160)");
980 break;
981
982 case 109:
983 ret += tcrypt_test("vmac(aes)");
984 break;
985
986 case 150:
987 ret += tcrypt_test("ansi_cprng");
988 break;
989
990 case 151:
991 ret += tcrypt_test("rfc4106(gcm(aes))");
992 break;
993
994 case 200:
995 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
996 speed_template_16_24_32);
997 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
998 speed_template_16_24_32);
999 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
1000 speed_template_16_24_32);
1001 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
1002 speed_template_16_24_32);
1003 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
1004 speed_template_32_40_48);
1005 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
1006 speed_template_32_40_48);
1007 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
1008 speed_template_32_48_64);
1009 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
1010 speed_template_32_48_64);
1011 break;
1012
1013 case 201:
1014 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
1015 des3_speed_template, DES3_SPEED_VECTORS,
1016 speed_template_24);
1017 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
1018 des3_speed_template, DES3_SPEED_VECTORS,
1019 speed_template_24);
1020 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
1021 des3_speed_template, DES3_SPEED_VECTORS,
1022 speed_template_24);
1023 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
1024 des3_speed_template, DES3_SPEED_VECTORS,
1025 speed_template_24);
1026 break;
1027
1028 case 202:
1029 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
1030 speed_template_16_24_32);
1031 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
1032 speed_template_16_24_32);
1033 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
1034 speed_template_16_24_32);
1035 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
1036 speed_template_16_24_32);
1037 break;
1038
1039 case 203:
1040 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
1041 speed_template_8_32);
1042 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
1043 speed_template_8_32);
1044 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
1045 speed_template_8_32);
1046 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
1047 speed_template_8_32);
1048 break;
1049
1050 case 204:
1051 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
1052 speed_template_8);
1053 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
1054 speed_template_8);
1055 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
1056 speed_template_8);
1057 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
1058 speed_template_8);
1059 break;
1060
1061 case 205:
1062 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
1063 speed_template_16_24_32);
1064 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
1065 speed_template_16_24_32);
1066 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
1067 speed_template_16_24_32);
1068 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
1069 speed_template_16_24_32);
1070 break;
1071
1072 case 206:
1073 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
1074 speed_template_16_32);
1075 break;
1076
1077 case 300:
1078 /* fall through */
1079
1080 case 301:
1081 test_hash_speed("md4", sec, generic_hash_speed_template);
1082 if (mode > 300 && mode < 400) break;
1083
1084 case 302:
1085 test_hash_speed("md5", sec, generic_hash_speed_template);
1086 if (mode > 300 && mode < 400) break;
1087
1088 case 303:
1089 test_hash_speed("sha1", sec, generic_hash_speed_template);
1090 if (mode > 300 && mode < 400) break;
1091
1092 case 304:
1093 test_hash_speed("sha256", sec, generic_hash_speed_template);
1094 if (mode > 300 && mode < 400) break;
1095
1096 case 305:
1097 test_hash_speed("sha384", sec, generic_hash_speed_template);
1098 if (mode > 300 && mode < 400) break;
1099
1100 case 306:
1101 test_hash_speed("sha512", sec, generic_hash_speed_template);
1102 if (mode > 300 && mode < 400) break;
1103
1104 case 307:
1105 test_hash_speed("wp256", sec, generic_hash_speed_template);
1106 if (mode > 300 && mode < 400) break;
1107
1108 case 308:
1109 test_hash_speed("wp384", sec, generic_hash_speed_template);
1110 if (mode > 300 && mode < 400) break;
1111
1112 case 309:
1113 test_hash_speed("wp512", sec, generic_hash_speed_template);
1114 if (mode > 300 && mode < 400) break;
1115
1116 case 310:
1117 test_hash_speed("tgr128", sec, generic_hash_speed_template);
1118 if (mode > 300 && mode < 400) break;
1119
1120 case 311:
1121 test_hash_speed("tgr160", sec, generic_hash_speed_template);
1122 if (mode > 300 && mode < 400) break;
1123
1124 case 312:
1125 test_hash_speed("tgr192", sec, generic_hash_speed_template);
1126 if (mode > 300 && mode < 400) break;
1127
1128 case 313:
1129 test_hash_speed("sha224", sec, generic_hash_speed_template);
1130 if (mode > 300 && mode < 400) break;
1131
1132 case 314:
1133 test_hash_speed("rmd128", sec, generic_hash_speed_template);
1134 if (mode > 300 && mode < 400) break;
1135
1136 case 315:
1137 test_hash_speed("rmd160", sec, generic_hash_speed_template);
1138 if (mode > 300 && mode < 400) break;
1139
1140 case 316:
1141 test_hash_speed("rmd256", sec, generic_hash_speed_template);
1142 if (mode > 300 && mode < 400) break;
1143
1144 case 317:
1145 test_hash_speed("rmd320", sec, generic_hash_speed_template);
1146 if (mode > 300 && mode < 400) break;
1147
1148 case 318:
1149 test_hash_speed("ghash-generic", sec, hash_speed_template_16);
1150 if (mode > 300 && mode < 400) break;
1151
1152 case 399:
1153 break;
1154
1155 case 400:
1156 /* fall through */
1157
1158 case 401:
1159 test_ahash_speed("md4", sec, generic_hash_speed_template);
1160 if (mode > 400 && mode < 500) break;
1161
1162 case 402:
1163 test_ahash_speed("md5", sec, generic_hash_speed_template);
1164 if (mode > 400 && mode < 500) break;
1165
1166 case 403:
1167 test_ahash_speed("sha1", sec, generic_hash_speed_template);
1168 if (mode > 400 && mode < 500) break;
1169
1170 case 404:
1171 test_ahash_speed("sha256", sec, generic_hash_speed_template);
1172 if (mode > 400 && mode < 500) break;
1173
1174 case 405:
1175 test_ahash_speed("sha384", sec, generic_hash_speed_template);
1176 if (mode > 400 && mode < 500) break;
1177
1178 case 406:
1179 test_ahash_speed("sha512", sec, generic_hash_speed_template);
1180 if (mode > 400 && mode < 500) break;
1181
1182 case 407:
1183 test_ahash_speed("wp256", sec, generic_hash_speed_template);
1184 if (mode > 400 && mode < 500) break;
1185
1186 case 408:
1187 test_ahash_speed("wp384", sec, generic_hash_speed_template);
1188 if (mode > 400 && mode < 500) break;
1189
1190 case 409:
1191 test_ahash_speed("wp512", sec, generic_hash_speed_template);
1192 if (mode > 400 && mode < 500) break;
1193
1194 case 410:
1195 test_ahash_speed("tgr128", sec, generic_hash_speed_template);
1196 if (mode > 400 && mode < 500) break;
1197
1198 case 411:
1199 test_ahash_speed("tgr160", sec, generic_hash_speed_template);
1200 if (mode > 400 && mode < 500) break;
1201
1202 case 412:
1203 test_ahash_speed("tgr192", sec, generic_hash_speed_template);
1204 if (mode > 400 && mode < 500) break;
1205
1206 case 413:
1207 test_ahash_speed("sha224", sec, generic_hash_speed_template);
1208 if (mode > 400 && mode < 500) break;
1209
1210 case 414:
1211 test_ahash_speed("rmd128", sec, generic_hash_speed_template);
1212 if (mode > 400 && mode < 500) break;
1213
1214 case 415:
1215 test_ahash_speed("rmd160", sec, generic_hash_speed_template);
1216 if (mode > 400 && mode < 500) break;
1217
1218 case 416:
1219 test_ahash_speed("rmd256", sec, generic_hash_speed_template);
1220 if (mode > 400 && mode < 500) break;
1221
1222 case 417:
1223 test_ahash_speed("rmd320", sec, generic_hash_speed_template);
1224 if (mode > 400 && mode < 500) break;
1225
1226 case 499:
1227 break;
1228
1229 case 1000:
1230 test_available();
1231 break;
1232 }
1233
1234 return ret;
1235 }
1236
1237 static int do_alg_test(const char *alg, u32 type, u32 mask)
1238 {
1239 return crypto_has_alg(alg, type, mask ?: CRYPTO_ALG_TYPE_MASK) ?
1240 0 : -ENOENT;
1241 }
1242
1243 static int __init tcrypt_mod_init(void)
1244 {
1245 int err = -ENOMEM;
1246 int i;
1247
1248 for (i = 0; i < TVMEMSIZE; i++) {
1249 tvmem[i] = (void *)__get_free_page(GFP_KERNEL);
1250 if (!tvmem[i])
1251 goto err_free_tv;
1252 }
1253
1254 if (alg)
1255 err = do_alg_test(alg, type, mask);
1256 else
1257 err = do_test(mode);
1258
1259 if (err) {
1260 printk(KERN_ERR "tcrypt: one or more tests failed!\n");
1261 goto err_free_tv;
1262 }
1263
1264 /* We intentionaly return -EAGAIN to prevent keeping the module,
1265 * unless we're running in fips mode. It does all its work from
1266 * init() and doesn't offer any runtime functionality, but in
1267 * the fips case, checking for a successful load is helpful.
1268 * => we don't need it in the memory, do we?
1269 * -- mludvig
1270 */
1271 if (!fips_enabled)
1272 err = -EAGAIN;
1273
1274 err_free_tv:
1275 for (i = 0; i < TVMEMSIZE && tvmem[i]; i++)
1276 free_page((unsigned long)tvmem[i]);
1277
1278 return err;
1279 }
1280
1281 /*
1282 * If an init function is provided, an exit function must also be provided
1283 * to allow module unload.
1284 */
1285 static void __exit tcrypt_mod_fini(void) { }
1286
1287 module_init(tcrypt_mod_init);
1288 module_exit(tcrypt_mod_fini);
1289
1290 module_param(alg, charp, 0);
1291 module_param(type, uint, 0);
1292 module_param(mask, uint, 0);
1293 module_param(mode, int, 0);
1294 module_param(sec, uint, 0);
1295 MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
1296 "(defaults to zero which uses CPU cycles instead)");
1297
1298 MODULE_LICENSE("GPL");
1299 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
1300 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
linux-next