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 * 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.
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)
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>
40 * Need slab memory for testing (size in number of pages).
45 * Used by test_cipher_speed()
51 * Used by test_cipher_speed()
53 static unsigned int sec
;
55 static char *alg
= NULL
;
59 static char *tvmem
[TVMEMSIZE
];
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
70 static int test_cipher_jiffies(struct blkcipher_desc
*desc
, int enc
,
71 struct scatterlist
*sg
, int blen
, int sec
)
73 unsigned long start
, end
;
77 for (start
= jiffies
, end
= start
+ sec
* HZ
, bcount
= 0;
78 time_before(jiffies
, end
); bcount
++) {
80 ret
= crypto_blkcipher_encrypt(desc
, sg
, sg
, blen
);
82 ret
= crypto_blkcipher_decrypt(desc
, sg
, sg
, blen
);
88 printk("%d operations in %d seconds (%ld bytes)\n",
89 bcount
, sec
, (long)bcount
* blen
);
93 static int test_cipher_cycles(struct blkcipher_desc
*desc
, int enc
,
94 struct scatterlist
*sg
, int blen
)
96 unsigned long cycles
= 0;
104 for (i
= 0; i
< 4; i
++) {
106 ret
= crypto_blkcipher_encrypt(desc
, sg
, sg
, blen
);
108 ret
= crypto_blkcipher_decrypt(desc
, sg
, sg
, blen
);
114 /* The real thing. */
115 for (i
= 0; i
< 8; i
++) {
118 start
= get_cycles();
120 ret
= crypto_blkcipher_encrypt(desc
, sg
, sg
, blen
);
122 ret
= crypto_blkcipher_decrypt(desc
, sg
, sg
, blen
);
128 cycles
+= end
- start
;
136 printk("1 operation in %lu cycles (%d bytes)\n",
137 (cycles
+ 4) / 8, blen
);
142 static u32 block_sizes
[] = { 16, 64, 256, 1024, 8192, 0 };
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
)
148 unsigned int ret
, i
, j
, iv_len
;
151 struct crypto_blkcipher
*tfm
;
152 struct blkcipher_desc desc
;
161 printk("\ntesting speed of %s %s\n", algo
, e
);
163 tfm
= crypto_alloc_blkcipher(algo
, 0, CRYPTO_ALG_ASYNC
);
166 printk("failed to load transform for %s: %ld\n", algo
,
176 b_size
= block_sizes
;
178 struct scatterlist sg
[TVMEMSIZE
];
180 if ((*keysize
+ *b_size
) > TVMEMSIZE
* PAGE_SIZE
) {
181 printk("template (%u) too big for "
182 "tvmem (%lu)\n", *keysize
+ *b_size
,
183 TVMEMSIZE
* PAGE_SIZE
);
187 printk("test %u (%d bit key, %d byte blocks): ", i
,
188 *keysize
* 8, *b_size
);
190 memset(tvmem
[0], 0xff, PAGE_SIZE
);
192 /* set key, plain text and IV */
194 for (j
= 0; j
< tcount
; j
++) {
195 if (template[j
].klen
== *keysize
) {
196 key
= template[j
].key
;
201 ret
= crypto_blkcipher_setkey(tfm
, key
, *keysize
);
203 printk("setkey() failed flags=%x\n",
204 crypto_blkcipher_get_flags(tfm
));
208 sg_init_table(sg
, TVMEMSIZE
);
209 sg_set_buf(sg
, tvmem
[0] + *keysize
,
210 PAGE_SIZE
- *keysize
);
211 for (j
= 1; j
< TVMEMSIZE
; j
++) {
212 sg_set_buf(sg
+ j
, tvmem
[j
], PAGE_SIZE
);
213 memset (tvmem
[j
], 0xff, PAGE_SIZE
);
216 iv_len
= crypto_blkcipher_ivsize(tfm
);
218 memset(&iv
, 0xff, iv_len
);
219 crypto_blkcipher_set_iv(tfm
, iv
, iv_len
);
223 ret
= test_cipher_jiffies(&desc
, enc
, sg
,
226 ret
= test_cipher_cycles(&desc
, enc
, sg
,
230 printk("%s() failed flags=%x\n", e
, desc
.flags
);
240 crypto_free_blkcipher(tfm
);
243 static int test_hash_jiffies_digest(struct hash_desc
*desc
,
244 struct scatterlist
*sg
, int blen
,
247 unsigned long start
, end
;
251 for (start
= jiffies
, end
= start
+ sec
* HZ
, bcount
= 0;
252 time_before(jiffies
, end
); bcount
++) {
253 ret
= crypto_hash_digest(desc
, sg
, blen
, out
);
258 printk("%6u opers/sec, %9lu bytes/sec\n",
259 bcount
/ sec
, ((long)bcount
* blen
) / sec
);
264 static int test_hash_jiffies(struct hash_desc
*desc
, struct scatterlist
*sg
,
265 int blen
, int plen
, char *out
, int sec
)
267 unsigned long start
, end
;
272 return test_hash_jiffies_digest(desc
, sg
, blen
, out
, sec
);
274 for (start
= jiffies
, end
= start
+ sec
* HZ
, bcount
= 0;
275 time_before(jiffies
, end
); bcount
++) {
276 ret
= crypto_hash_init(desc
);
279 for (pcount
= 0; pcount
< blen
; pcount
+= plen
) {
280 ret
= crypto_hash_update(desc
, sg
, plen
);
284 /* we assume there is enough space in 'out' for the result */
285 ret
= crypto_hash_final(desc
, out
);
290 printk("%6u opers/sec, %9lu bytes/sec\n",
291 bcount
/ sec
, ((long)bcount
* blen
) / sec
);
296 static int test_hash_cycles_digest(struct hash_desc
*desc
,
297 struct scatterlist
*sg
, int blen
, char *out
)
299 unsigned long cycles
= 0;
307 for (i
= 0; i
< 4; i
++) {
308 ret
= crypto_hash_digest(desc
, sg
, blen
, out
);
313 /* The real thing. */
314 for (i
= 0; i
< 8; i
++) {
317 start
= get_cycles();
319 ret
= crypto_hash_digest(desc
, sg
, blen
, out
);
325 cycles
+= end
- start
;
335 printk("%6lu cycles/operation, %4lu cycles/byte\n",
336 cycles
/ 8, cycles
/ (8 * blen
));
341 static int test_hash_cycles(struct hash_desc
*desc
, struct scatterlist
*sg
,
342 int blen
, int plen
, char *out
)
344 unsigned long cycles
= 0;
349 return test_hash_cycles_digest(desc
, sg
, blen
, out
);
355 for (i
= 0; i
< 4; i
++) {
356 ret
= crypto_hash_init(desc
);
359 for (pcount
= 0; pcount
< blen
; pcount
+= plen
) {
360 ret
= crypto_hash_update(desc
, sg
, plen
);
364 ret
= crypto_hash_final(desc
, out
);
369 /* The real thing. */
370 for (i
= 0; i
< 8; i
++) {
373 start
= get_cycles();
375 ret
= crypto_hash_init(desc
);
378 for (pcount
= 0; pcount
< blen
; pcount
+= plen
) {
379 ret
= crypto_hash_update(desc
, sg
, plen
);
383 ret
= crypto_hash_final(desc
, out
);
389 cycles
+= end
- start
;
399 printk("%6lu cycles/operation, %4lu cycles/byte\n",
400 cycles
/ 8, cycles
/ (8 * blen
));
405 static void test_hash_sg_init(struct scatterlist
*sg
)
409 sg_init_table(sg
, TVMEMSIZE
);
410 for (i
= 0; i
< TVMEMSIZE
; i
++) {
411 sg_set_buf(sg
+ i
, tvmem
[i
], PAGE_SIZE
);
412 memset(tvmem
[i
], 0xff, PAGE_SIZE
);
416 static void test_hash_speed(const char *algo
, unsigned int sec
,
417 struct hash_speed
*speed
)
419 struct scatterlist sg
[TVMEMSIZE
];
420 struct crypto_hash
*tfm
;
421 struct hash_desc desc
;
422 static char output
[1024];
426 printk(KERN_INFO
"\ntesting speed of %s\n", algo
);
428 tfm
= crypto_alloc_hash(algo
, 0, CRYPTO_ALG_ASYNC
);
431 printk(KERN_ERR
"failed to load transform for %s: %ld\n", algo
,
439 if (crypto_hash_digestsize(tfm
) > sizeof(output
)) {
440 printk(KERN_ERR
"digestsize(%u) > outputbuffer(%zu)\n",
441 crypto_hash_digestsize(tfm
), sizeof(output
));
445 test_hash_sg_init(sg
);
446 for (i
= 0; speed
[i
].blen
!= 0; i
++) {
447 if (speed
[i
].blen
> TVMEMSIZE
* PAGE_SIZE
) {
449 "template (%u) too big for tvmem (%lu)\n",
450 speed
[i
].blen
, TVMEMSIZE
* PAGE_SIZE
);
455 crypto_hash_setkey(tfm
, tvmem
[0], speed
[i
].klen
);
457 printk(KERN_INFO
"test%3u "
458 "(%5u byte blocks,%5u bytes per update,%4u updates): ",
459 i
, speed
[i
].blen
, speed
[i
].plen
, speed
[i
].blen
/ speed
[i
].plen
);
462 ret
= test_hash_jiffies(&desc
, sg
, speed
[i
].blen
,
463 speed
[i
].plen
, output
, sec
);
465 ret
= test_hash_cycles(&desc
, sg
, speed
[i
].blen
,
466 speed
[i
].plen
, output
);
469 printk(KERN_ERR
"hashing failed ret=%d\n", ret
);
475 crypto_free_hash(tfm
);
478 struct tcrypt_result
{
479 struct completion completion
;
483 static void tcrypt_complete(struct crypto_async_request
*req
, int err
)
485 struct tcrypt_result
*res
= req
->data
;
487 if (err
== -EINPROGRESS
)
491 complete(&res
->completion
);
494 static inline int do_one_ahash_op(struct ahash_request
*req
, int ret
)
496 if (ret
== -EINPROGRESS
|| ret
== -EBUSY
) {
497 struct tcrypt_result
*tr
= req
->base
.data
;
499 ret
= wait_for_completion_interruptible(&tr
->completion
);
502 INIT_COMPLETION(tr
->completion
);
507 static int test_ahash_jiffies_digest(struct ahash_request
*req
, int blen
,
510 unsigned long start
, end
;
514 for (start
= jiffies
, end
= start
+ sec
* HZ
, bcount
= 0;
515 time_before(jiffies
, end
); bcount
++) {
516 ret
= do_one_ahash_op(req
, crypto_ahash_digest(req
));
521 printk("%6u opers/sec, %9lu bytes/sec\n",
522 bcount
/ sec
, ((long)bcount
* blen
) / sec
);
527 static int test_ahash_jiffies(struct ahash_request
*req
, int blen
,
528 int plen
, char *out
, int sec
)
530 unsigned long start
, end
;
535 return test_ahash_jiffies_digest(req
, blen
, out
, sec
);
537 for (start
= jiffies
, end
= start
+ sec
* HZ
, bcount
= 0;
538 time_before(jiffies
, end
); bcount
++) {
539 ret
= crypto_ahash_init(req
);
542 for (pcount
= 0; pcount
< blen
; pcount
+= plen
) {
543 ret
= do_one_ahash_op(req
, crypto_ahash_update(req
));
547 /* we assume there is enough space in 'out' for the result */
548 ret
= do_one_ahash_op(req
, crypto_ahash_final(req
));
553 pr_cont("%6u opers/sec, %9lu bytes/sec\n",
554 bcount
/ sec
, ((long)bcount
* blen
) / sec
);
559 static int test_ahash_cycles_digest(struct ahash_request
*req
, int blen
,
562 unsigned long cycles
= 0;
566 for (i
= 0; i
< 4; i
++) {
567 ret
= do_one_ahash_op(req
, crypto_ahash_digest(req
));
572 /* The real thing. */
573 for (i
= 0; i
< 8; i
++) {
576 start
= get_cycles();
578 ret
= do_one_ahash_op(req
, crypto_ahash_digest(req
));
584 cycles
+= end
- start
;
591 pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
592 cycles
/ 8, cycles
/ (8 * blen
));
597 static int test_ahash_cycles(struct ahash_request
*req
, int blen
,
600 unsigned long cycles
= 0;
604 return test_ahash_cycles_digest(req
, blen
, out
);
607 for (i
= 0; i
< 4; i
++) {
608 ret
= crypto_ahash_init(req
);
611 for (pcount
= 0; pcount
< blen
; pcount
+= plen
) {
612 ret
= do_one_ahash_op(req
, crypto_ahash_update(req
));
616 ret
= do_one_ahash_op(req
, crypto_ahash_final(req
));
621 /* The real thing. */
622 for (i
= 0; i
< 8; i
++) {
625 start
= get_cycles();
627 ret
= crypto_ahash_init(req
);
630 for (pcount
= 0; pcount
< blen
; pcount
+= plen
) {
631 ret
= do_one_ahash_op(req
, crypto_ahash_update(req
));
635 ret
= do_one_ahash_op(req
, crypto_ahash_final(req
));
641 cycles
+= end
- start
;
648 pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
649 cycles
/ 8, cycles
/ (8 * blen
));
654 static void test_ahash_speed(const char *algo
, unsigned int sec
,
655 struct hash_speed
*speed
)
657 struct scatterlist sg
[TVMEMSIZE
];
658 struct tcrypt_result tresult
;
659 struct ahash_request
*req
;
660 struct crypto_ahash
*tfm
;
661 static char output
[1024];
664 printk(KERN_INFO
"\ntesting speed of async %s\n", algo
);
666 tfm
= crypto_alloc_ahash(algo
, 0, 0);
668 pr_err("failed to load transform for %s: %ld\n",
673 if (crypto_ahash_digestsize(tfm
) > sizeof(output
)) {
674 pr_err("digestsize(%u) > outputbuffer(%zu)\n",
675 crypto_ahash_digestsize(tfm
), sizeof(output
));
679 test_hash_sg_init(sg
);
680 req
= ahash_request_alloc(tfm
, GFP_KERNEL
);
682 pr_err("ahash request allocation failure\n");
686 init_completion(&tresult
.completion
);
687 ahash_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
688 tcrypt_complete
, &tresult
);
690 for (i
= 0; speed
[i
].blen
!= 0; i
++) {
691 if (speed
[i
].blen
> TVMEMSIZE
* PAGE_SIZE
) {
692 pr_err("template (%u) too big for tvmem (%lu)\n",
693 speed
[i
].blen
, TVMEMSIZE
* PAGE_SIZE
);
698 "(%5u byte blocks,%5u bytes per update,%4u updates): ",
699 i
, speed
[i
].blen
, speed
[i
].plen
, speed
[i
].blen
/ speed
[i
].plen
);
701 ahash_request_set_crypt(req
, sg
, output
, speed
[i
].plen
);
704 ret
= test_ahash_jiffies(req
, speed
[i
].blen
,
705 speed
[i
].plen
, output
, sec
);
707 ret
= test_ahash_cycles(req
, speed
[i
].blen
,
708 speed
[i
].plen
, output
);
711 pr_err("hashing failed ret=%d\n", ret
);
716 ahash_request_free(req
);
719 crypto_free_ahash(tfm
);
722 static inline int do_one_acipher_op(struct ablkcipher_request
*req
, int ret
)
724 if (ret
== -EINPROGRESS
|| ret
== -EBUSY
) {
725 struct tcrypt_result
*tr
= req
->base
.data
;
727 ret
= wait_for_completion_interruptible(&tr
->completion
);
730 INIT_COMPLETION(tr
->completion
);
736 static int test_acipher_jiffies(struct ablkcipher_request
*req
, int enc
,
739 unsigned long start
, end
;
743 for (start
= jiffies
, end
= start
+ sec
* HZ
, bcount
= 0;
744 time_before(jiffies
, end
); bcount
++) {
746 ret
= do_one_acipher_op(req
,
747 crypto_ablkcipher_encrypt(req
));
749 ret
= do_one_acipher_op(req
,
750 crypto_ablkcipher_decrypt(req
));
756 pr_cont("%d operations in %d seconds (%ld bytes)\n",
757 bcount
, sec
, (long)bcount
* blen
);
761 static int test_acipher_cycles(struct ablkcipher_request
*req
, int enc
,
764 unsigned long cycles
= 0;
769 for (i
= 0; i
< 4; i
++) {
771 ret
= do_one_acipher_op(req
,
772 crypto_ablkcipher_encrypt(req
));
774 ret
= do_one_acipher_op(req
,
775 crypto_ablkcipher_decrypt(req
));
781 /* The real thing. */
782 for (i
= 0; i
< 8; i
++) {
785 start
= get_cycles();
787 ret
= do_one_acipher_op(req
,
788 crypto_ablkcipher_encrypt(req
));
790 ret
= do_one_acipher_op(req
,
791 crypto_ablkcipher_decrypt(req
));
797 cycles
+= end
- start
;
802 pr_cont("1 operation in %lu cycles (%d bytes)\n",
803 (cycles
+ 4) / 8, blen
);
808 static void test_acipher_speed(const char *algo
, int enc
, unsigned int sec
,
809 struct cipher_speed_template
*template,
810 unsigned int tcount
, u8
*keysize
)
812 unsigned int ret
, i
, j
, k
, iv_len
;
813 struct tcrypt_result tresult
;
816 struct ablkcipher_request
*req
;
817 struct crypto_ablkcipher
*tfm
;
826 pr_info("\ntesting speed of async %s %s\n", algo
, e
);
828 init_completion(&tresult
.completion
);
830 tfm
= crypto_alloc_ablkcipher(algo
, 0, 0);
833 pr_err("failed to load transform for %s: %ld\n", algo
,
838 req
= ablkcipher_request_alloc(tfm
, GFP_KERNEL
);
840 pr_err("tcrypt: skcipher: Failed to allocate request for %s\n",
845 ablkcipher_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
846 tcrypt_complete
, &tresult
);
850 b_size
= block_sizes
;
853 struct scatterlist sg
[TVMEMSIZE
];
855 if ((*keysize
+ *b_size
) > TVMEMSIZE
* PAGE_SIZE
) {
856 pr_err("template (%u) too big for "
857 "tvmem (%lu)\n", *keysize
+ *b_size
,
858 TVMEMSIZE
* PAGE_SIZE
);
862 pr_info("test %u (%d bit key, %d byte blocks): ", i
,
863 *keysize
* 8, *b_size
);
865 memset(tvmem
[0], 0xff, PAGE_SIZE
);
867 /* set key, plain text and IV */
869 for (j
= 0; j
< tcount
; j
++) {
870 if (template[j
].klen
== *keysize
) {
871 key
= template[j
].key
;
876 crypto_ablkcipher_clear_flags(tfm
, ~0);
878 ret
= crypto_ablkcipher_setkey(tfm
, key
, *keysize
);
880 pr_err("setkey() failed flags=%x\n",
881 crypto_ablkcipher_get_flags(tfm
));
885 sg_init_table(sg
, TVMEMSIZE
);
887 k
= *keysize
+ *b_size
;
889 sg_set_buf(sg
, tvmem
[0] + *keysize
,
890 PAGE_SIZE
- *keysize
);
893 while (k
> PAGE_SIZE
) {
894 sg_set_buf(sg
+ j
, tvmem
[j
], PAGE_SIZE
);
895 memset(tvmem
[j
], 0xff, PAGE_SIZE
);
899 sg_set_buf(sg
+ j
, tvmem
[j
], k
);
900 memset(tvmem
[j
], 0xff, k
);
902 sg_set_buf(sg
, tvmem
[0] + *keysize
, *b_size
);
905 iv_len
= crypto_ablkcipher_ivsize(tfm
);
907 memset(&iv
, 0xff, iv_len
);
909 ablkcipher_request_set_crypt(req
, sg
, sg
, *b_size
, iv
);
912 ret
= test_acipher_jiffies(req
, enc
,
915 ret
= test_acipher_cycles(req
, enc
,
919 pr_err("%s() failed flags=%x\n", e
,
920 crypto_ablkcipher_get_flags(tfm
));
930 ablkcipher_request_free(req
);
932 crypto_free_ablkcipher(tfm
);
935 static void test_available(void)
940 printk("alg %s ", *name
);
941 printk(crypto_has_alg(*name
, 0, 0) ?
942 "found\n" : "not found\n");
947 static inline int tcrypt_test(const char *alg
)
951 ret
= alg_test(alg
, alg
, 0, 0);
952 /* non-fips algs return -EINVAL in fips mode */
953 if (fips_enabled
&& ret
== -EINVAL
)
958 static int do_test(int m
)
965 for (i
= 1; i
< 200; i
++)
970 ret
+= tcrypt_test("md5");
974 ret
+= tcrypt_test("sha1");
978 ret
+= tcrypt_test("ecb(des)");
979 ret
+= tcrypt_test("cbc(des)");
983 ret
+= tcrypt_test("ecb(des3_ede)");
984 ret
+= tcrypt_test("cbc(des3_ede)");
988 ret
+= tcrypt_test("md4");
992 ret
+= tcrypt_test("sha256");
996 ret
+= tcrypt_test("ecb(blowfish)");
997 ret
+= tcrypt_test("cbc(blowfish)");
998 ret
+= tcrypt_test("ctr(blowfish)");
1002 ret
+= tcrypt_test("ecb(twofish)");
1003 ret
+= tcrypt_test("cbc(twofish)");
1004 ret
+= tcrypt_test("ctr(twofish)");
1005 ret
+= tcrypt_test("lrw(twofish)");
1006 ret
+= tcrypt_test("xts(twofish)");
1010 ret
+= tcrypt_test("ecb(serpent)");
1011 ret
+= tcrypt_test("cbc(serpent)");
1012 ret
+= tcrypt_test("ctr(serpent)");
1013 ret
+= tcrypt_test("lrw(serpent)");
1014 ret
+= tcrypt_test("xts(serpent)");
1018 ret
+= tcrypt_test("ecb(aes)");
1019 ret
+= tcrypt_test("cbc(aes)");
1020 ret
+= tcrypt_test("lrw(aes)");
1021 ret
+= tcrypt_test("xts(aes)");
1022 ret
+= tcrypt_test("ctr(aes)");
1023 ret
+= tcrypt_test("rfc3686(ctr(aes))");
1027 ret
+= tcrypt_test("sha384");
1031 ret
+= tcrypt_test("sha512");
1035 ret
+= tcrypt_test("deflate");
1039 ret
+= tcrypt_test("ecb(cast5)");
1040 ret
+= tcrypt_test("cbc(cast5)");
1041 ret
+= tcrypt_test("ctr(cast5)");
1045 ret
+= tcrypt_test("ecb(cast6)");
1049 ret
+= tcrypt_test("ecb(arc4)");
1053 ret
+= tcrypt_test("michael_mic");
1057 ret
+= tcrypt_test("crc32c");
1061 ret
+= tcrypt_test("ecb(tea)");
1065 ret
+= tcrypt_test("ecb(xtea)");
1069 ret
+= tcrypt_test("ecb(khazad)");
1073 ret
+= tcrypt_test("wp512");
1077 ret
+= tcrypt_test("wp384");
1081 ret
+= tcrypt_test("wp256");
1085 ret
+= tcrypt_test("ecb(tnepres)");
1089 ret
+= tcrypt_test("ecb(anubis)");
1090 ret
+= tcrypt_test("cbc(anubis)");
1094 ret
+= tcrypt_test("tgr192");
1099 ret
+= tcrypt_test("tgr160");
1103 ret
+= tcrypt_test("tgr128");
1107 ret
+= tcrypt_test("ecb(xeta)");
1111 ret
+= tcrypt_test("pcbc(fcrypt)");
1115 ret
+= tcrypt_test("ecb(camellia)");
1116 ret
+= tcrypt_test("cbc(camellia)");
1119 ret
+= tcrypt_test("sha224");
1123 ret
+= tcrypt_test("salsa20");
1127 ret
+= tcrypt_test("gcm(aes)");
1131 ret
+= tcrypt_test("lzo");
1135 ret
+= tcrypt_test("ccm(aes)");
1139 ret
+= tcrypt_test("cts(cbc(aes))");
1143 ret
+= tcrypt_test("rmd128");
1147 ret
+= tcrypt_test("rmd160");
1151 ret
+= tcrypt_test("rmd256");
1155 ret
+= tcrypt_test("rmd320");
1159 ret
+= tcrypt_test("ecb(seed)");
1163 ret
+= tcrypt_test("zlib");
1167 ret
+= tcrypt_test("rfc4309(ccm(aes))");
1171 ret
+= tcrypt_test("hmac(md5)");
1175 ret
+= tcrypt_test("hmac(sha1)");
1179 ret
+= tcrypt_test("hmac(sha256)");
1183 ret
+= tcrypt_test("hmac(sha384)");
1187 ret
+= tcrypt_test("hmac(sha512)");
1191 ret
+= tcrypt_test("hmac(sha224)");
1195 ret
+= tcrypt_test("xcbc(aes)");
1199 ret
+= tcrypt_test("hmac(rmd128)");
1203 ret
+= tcrypt_test("hmac(rmd160)");
1207 ret
+= tcrypt_test("vmac(aes)");
1210 ret
+= tcrypt_test("hmac(crc32)");
1214 ret
+= tcrypt_test("ansi_cprng");
1218 ret
+= tcrypt_test("rfc4106(gcm(aes))");
1222 test_cipher_speed("ecb(aes)", ENCRYPT
, sec
, NULL
, 0,
1223 speed_template_16_24_32
);
1224 test_cipher_speed("ecb(aes)", DECRYPT
, sec
, NULL
, 0,
1225 speed_template_16_24_32
);
1226 test_cipher_speed("cbc(aes)", ENCRYPT
, sec
, NULL
, 0,
1227 speed_template_16_24_32
);
1228 test_cipher_speed("cbc(aes)", DECRYPT
, sec
, NULL
, 0,
1229 speed_template_16_24_32
);
1230 test_cipher_speed("lrw(aes)", ENCRYPT
, sec
, NULL
, 0,
1231 speed_template_32_40_48
);
1232 test_cipher_speed("lrw(aes)", DECRYPT
, sec
, NULL
, 0,
1233 speed_template_32_40_48
);
1234 test_cipher_speed("xts(aes)", ENCRYPT
, sec
, NULL
, 0,
1235 speed_template_32_48_64
);
1236 test_cipher_speed("xts(aes)", DECRYPT
, sec
, NULL
, 0,
1237 speed_template_32_48_64
);
1238 test_cipher_speed("ctr(aes)", ENCRYPT
, sec
, NULL
, 0,
1239 speed_template_16_24_32
);
1240 test_cipher_speed("ctr(aes)", DECRYPT
, sec
, NULL
, 0,
1241 speed_template_16_24_32
);
1245 test_cipher_speed("ecb(des3_ede)", ENCRYPT
, sec
,
1246 des3_speed_template
, DES3_SPEED_VECTORS
,
1248 test_cipher_speed("ecb(des3_ede)", DECRYPT
, sec
,
1249 des3_speed_template
, DES3_SPEED_VECTORS
,
1251 test_cipher_speed("cbc(des3_ede)", ENCRYPT
, sec
,
1252 des3_speed_template
, DES3_SPEED_VECTORS
,
1254 test_cipher_speed("cbc(des3_ede)", DECRYPT
, sec
,
1255 des3_speed_template
, DES3_SPEED_VECTORS
,
1260 test_cipher_speed("ecb(twofish)", ENCRYPT
, sec
, NULL
, 0,
1261 speed_template_16_24_32
);
1262 test_cipher_speed("ecb(twofish)", DECRYPT
, sec
, NULL
, 0,
1263 speed_template_16_24_32
);
1264 test_cipher_speed("cbc(twofish)", ENCRYPT
, sec
, NULL
, 0,
1265 speed_template_16_24_32
);
1266 test_cipher_speed("cbc(twofish)", DECRYPT
, sec
, NULL
, 0,
1267 speed_template_16_24_32
);
1268 test_cipher_speed("ctr(twofish)", ENCRYPT
, sec
, NULL
, 0,
1269 speed_template_16_24_32
);
1270 test_cipher_speed("ctr(twofish)", DECRYPT
, sec
, NULL
, 0,
1271 speed_template_16_24_32
);
1272 test_cipher_speed("lrw(twofish)", ENCRYPT
, sec
, NULL
, 0,
1273 speed_template_32_40_48
);
1274 test_cipher_speed("lrw(twofish)", DECRYPT
, sec
, NULL
, 0,
1275 speed_template_32_40_48
);
1276 test_cipher_speed("xts(twofish)", ENCRYPT
, sec
, NULL
, 0,
1277 speed_template_32_48_64
);
1278 test_cipher_speed("xts(twofish)", DECRYPT
, sec
, NULL
, 0,
1279 speed_template_32_48_64
);
1283 test_cipher_speed("ecb(blowfish)", ENCRYPT
, sec
, NULL
, 0,
1284 speed_template_8_32
);
1285 test_cipher_speed("ecb(blowfish)", DECRYPT
, sec
, NULL
, 0,
1286 speed_template_8_32
);
1287 test_cipher_speed("cbc(blowfish)", ENCRYPT
, sec
, NULL
, 0,
1288 speed_template_8_32
);
1289 test_cipher_speed("cbc(blowfish)", DECRYPT
, sec
, NULL
, 0,
1290 speed_template_8_32
);
1291 test_cipher_speed("ctr(blowfish)", ENCRYPT
, sec
, NULL
, 0,
1292 speed_template_8_32
);
1293 test_cipher_speed("ctr(blowfish)", DECRYPT
, sec
, NULL
, 0,
1294 speed_template_8_32
);
1298 test_cipher_speed("ecb(des)", ENCRYPT
, sec
, NULL
, 0,
1300 test_cipher_speed("ecb(des)", DECRYPT
, sec
, NULL
, 0,
1302 test_cipher_speed("cbc(des)", ENCRYPT
, sec
, NULL
, 0,
1304 test_cipher_speed("cbc(des)", DECRYPT
, sec
, NULL
, 0,
1309 test_cipher_speed("ecb(camellia)", ENCRYPT
, sec
, NULL
, 0,
1310 speed_template_16_24_32
);
1311 test_cipher_speed("ecb(camellia)", DECRYPT
, sec
, NULL
, 0,
1312 speed_template_16_24_32
);
1313 test_cipher_speed("cbc(camellia)", ENCRYPT
, sec
, NULL
, 0,
1314 speed_template_16_24_32
);
1315 test_cipher_speed("cbc(camellia)", DECRYPT
, sec
, NULL
, 0,
1316 speed_template_16_24_32
);
1317 test_cipher_speed("ctr(camellia)", ENCRYPT
, sec
, NULL
, 0,
1318 speed_template_16_24_32
);
1319 test_cipher_speed("ctr(camellia)", DECRYPT
, sec
, NULL
, 0,
1320 speed_template_16_24_32
);
1321 test_cipher_speed("lrw(camellia)", ENCRYPT
, sec
, NULL
, 0,
1322 speed_template_32_40_48
);
1323 test_cipher_speed("lrw(camellia)", DECRYPT
, sec
, NULL
, 0,
1324 speed_template_32_40_48
);
1325 test_cipher_speed("xts(camellia)", ENCRYPT
, sec
, NULL
, 0,
1326 speed_template_32_48_64
);
1327 test_cipher_speed("xts(camellia)", DECRYPT
, sec
, NULL
, 0,
1328 speed_template_32_48_64
);
1332 test_cipher_speed("salsa20", ENCRYPT
, sec
, NULL
, 0,
1333 speed_template_16_32
);
1337 test_cipher_speed("ecb(serpent)", ENCRYPT
, sec
, NULL
, 0,
1338 speed_template_16_32
);
1339 test_cipher_speed("ecb(serpent)", DECRYPT
, sec
, NULL
, 0,
1340 speed_template_16_32
);
1341 test_cipher_speed("cbc(serpent)", ENCRYPT
, sec
, NULL
, 0,
1342 speed_template_16_32
);
1343 test_cipher_speed("cbc(serpent)", DECRYPT
, sec
, NULL
, 0,
1344 speed_template_16_32
);
1345 test_cipher_speed("ctr(serpent)", ENCRYPT
, sec
, NULL
, 0,
1346 speed_template_16_32
);
1347 test_cipher_speed("ctr(serpent)", DECRYPT
, sec
, NULL
, 0,
1348 speed_template_16_32
);
1349 test_cipher_speed("lrw(serpent)", ENCRYPT
, sec
, NULL
, 0,
1350 speed_template_32_48
);
1351 test_cipher_speed("lrw(serpent)", DECRYPT
, sec
, NULL
, 0,
1352 speed_template_32_48
);
1353 test_cipher_speed("xts(serpent)", ENCRYPT
, sec
, NULL
, 0,
1354 speed_template_32_64
);
1355 test_cipher_speed("xts(serpent)", DECRYPT
, sec
, NULL
, 0,
1356 speed_template_32_64
);
1360 test_cipher_speed("ecb(arc4)", ENCRYPT
, sec
, NULL
, 0,
1365 test_cipher_speed("ecb(cast5)", ENCRYPT
, sec
, NULL
, 0,
1366 speed_template_8_16
);
1367 test_cipher_speed("ecb(cast5)", DECRYPT
, sec
, NULL
, 0,
1368 speed_template_8_16
);
1369 test_cipher_speed("cbc(cast5)", ENCRYPT
, sec
, NULL
, 0,
1370 speed_template_8_16
);
1371 test_cipher_speed("cbc(cast5)", DECRYPT
, sec
, NULL
, 0,
1372 speed_template_8_16
);
1373 test_cipher_speed("ctr(cast5)", ENCRYPT
, sec
, NULL
, 0,
1374 speed_template_8_16
);
1375 test_cipher_speed("ctr(cast5)", DECRYPT
, sec
, NULL
, 0,
1376 speed_template_8_16
);
1383 test_hash_speed("md4", sec
, generic_hash_speed_template
);
1384 if (mode
> 300 && mode
< 400) break;
1387 test_hash_speed("md5", sec
, generic_hash_speed_template
);
1388 if (mode
> 300 && mode
< 400) break;
1391 test_hash_speed("sha1", sec
, generic_hash_speed_template
);
1392 if (mode
> 300 && mode
< 400) break;
1395 test_hash_speed("sha256", sec
, generic_hash_speed_template
);
1396 if (mode
> 300 && mode
< 400) break;
1399 test_hash_speed("sha384", sec
, generic_hash_speed_template
);
1400 if (mode
> 300 && mode
< 400) break;
1403 test_hash_speed("sha512", sec
, generic_hash_speed_template
);
1404 if (mode
> 300 && mode
< 400) break;
1407 test_hash_speed("wp256", sec
, generic_hash_speed_template
);
1408 if (mode
> 300 && mode
< 400) break;
1411 test_hash_speed("wp384", sec
, generic_hash_speed_template
);
1412 if (mode
> 300 && mode
< 400) break;
1415 test_hash_speed("wp512", sec
, generic_hash_speed_template
);
1416 if (mode
> 300 && mode
< 400) break;
1419 test_hash_speed("tgr128", sec
, generic_hash_speed_template
);
1420 if (mode
> 300 && mode
< 400) break;
1423 test_hash_speed("tgr160", sec
, generic_hash_speed_template
);
1424 if (mode
> 300 && mode
< 400) break;
1427 test_hash_speed("tgr192", sec
, generic_hash_speed_template
);
1428 if (mode
> 300 && mode
< 400) break;
1431 test_hash_speed("sha224", sec
, generic_hash_speed_template
);
1432 if (mode
> 300 && mode
< 400) break;
1435 test_hash_speed("rmd128", sec
, generic_hash_speed_template
);
1436 if (mode
> 300 && mode
< 400) break;
1439 test_hash_speed("rmd160", sec
, generic_hash_speed_template
);
1440 if (mode
> 300 && mode
< 400) break;
1443 test_hash_speed("rmd256", sec
, generic_hash_speed_template
);
1444 if (mode
> 300 && mode
< 400) break;
1447 test_hash_speed("rmd320", sec
, generic_hash_speed_template
);
1448 if (mode
> 300 && mode
< 400) break;
1451 test_hash_speed("ghash-generic", sec
, hash_speed_template_16
);
1452 if (mode
> 300 && mode
< 400) break;
1461 test_ahash_speed("md4", sec
, generic_hash_speed_template
);
1462 if (mode
> 400 && mode
< 500) break;
1465 test_ahash_speed("md5", sec
, generic_hash_speed_template
);
1466 if (mode
> 400 && mode
< 500) break;
1469 test_ahash_speed("sha1", sec
, generic_hash_speed_template
);
1470 if (mode
> 400 && mode
< 500) break;
1473 test_ahash_speed("sha256", sec
, generic_hash_speed_template
);
1474 if (mode
> 400 && mode
< 500) break;
1477 test_ahash_speed("sha384", sec
, generic_hash_speed_template
);
1478 if (mode
> 400 && mode
< 500) break;
1481 test_ahash_speed("sha512", sec
, generic_hash_speed_template
);
1482 if (mode
> 400 && mode
< 500) break;
1485 test_ahash_speed("wp256", sec
, generic_hash_speed_template
);
1486 if (mode
> 400 && mode
< 500) break;
1489 test_ahash_speed("wp384", sec
, generic_hash_speed_template
);
1490 if (mode
> 400 && mode
< 500) break;
1493 test_ahash_speed("wp512", sec
, generic_hash_speed_template
);
1494 if (mode
> 400 && mode
< 500) break;
1497 test_ahash_speed("tgr128", sec
, generic_hash_speed_template
);
1498 if (mode
> 400 && mode
< 500) break;
1501 test_ahash_speed("tgr160", sec
, generic_hash_speed_template
);
1502 if (mode
> 400 && mode
< 500) break;
1505 test_ahash_speed("tgr192", sec
, generic_hash_speed_template
);
1506 if (mode
> 400 && mode
< 500) break;
1509 test_ahash_speed("sha224", sec
, generic_hash_speed_template
);
1510 if (mode
> 400 && mode
< 500) break;
1513 test_ahash_speed("rmd128", sec
, generic_hash_speed_template
);
1514 if (mode
> 400 && mode
< 500) break;
1517 test_ahash_speed("rmd160", sec
, generic_hash_speed_template
);
1518 if (mode
> 400 && mode
< 500) break;
1521 test_ahash_speed("rmd256", sec
, generic_hash_speed_template
);
1522 if (mode
> 400 && mode
< 500) break;
1525 test_ahash_speed("rmd320", sec
, generic_hash_speed_template
);
1526 if (mode
> 400 && mode
< 500) break;
1532 test_acipher_speed("ecb(aes)", ENCRYPT
, sec
, NULL
, 0,
1533 speed_template_16_24_32
);
1534 test_acipher_speed("ecb(aes)", DECRYPT
, sec
, NULL
, 0,
1535 speed_template_16_24_32
);
1536 test_acipher_speed("cbc(aes)", ENCRYPT
, sec
, NULL
, 0,
1537 speed_template_16_24_32
);
1538 test_acipher_speed("cbc(aes)", DECRYPT
, sec
, NULL
, 0,
1539 speed_template_16_24_32
);
1540 test_acipher_speed("lrw(aes)", ENCRYPT
, sec
, NULL
, 0,
1541 speed_template_32_40_48
);
1542 test_acipher_speed("lrw(aes)", DECRYPT
, sec
, NULL
, 0,
1543 speed_template_32_40_48
);
1544 test_acipher_speed("xts(aes)", ENCRYPT
, sec
, NULL
, 0,
1545 speed_template_32_48_64
);
1546 test_acipher_speed("xts(aes)", DECRYPT
, sec
, NULL
, 0,
1547 speed_template_32_48_64
);
1548 test_acipher_speed("ctr(aes)", ENCRYPT
, sec
, NULL
, 0,
1549 speed_template_16_24_32
);
1550 test_acipher_speed("ctr(aes)", DECRYPT
, sec
, NULL
, 0,
1551 speed_template_16_24_32
);
1552 test_acipher_speed("cfb(aes)", ENCRYPT
, sec
, NULL
, 0,
1553 speed_template_16_24_32
);
1554 test_acipher_speed("cfb(aes)", DECRYPT
, sec
, NULL
, 0,
1555 speed_template_16_24_32
);
1556 test_acipher_speed("ofb(aes)", ENCRYPT
, sec
, NULL
, 0,
1557 speed_template_16_24_32
);
1558 test_acipher_speed("ofb(aes)", DECRYPT
, sec
, NULL
, 0,
1559 speed_template_16_24_32
);
1563 test_acipher_speed("ecb(des3_ede)", ENCRYPT
, sec
,
1564 des3_speed_template
, DES3_SPEED_VECTORS
,
1566 test_acipher_speed("ecb(des3_ede)", DECRYPT
, sec
,
1567 des3_speed_template
, DES3_SPEED_VECTORS
,
1569 test_acipher_speed("cbc(des3_ede)", ENCRYPT
, sec
,
1570 des3_speed_template
, DES3_SPEED_VECTORS
,
1572 test_acipher_speed("cbc(des3_ede)", DECRYPT
, sec
,
1573 des3_speed_template
, DES3_SPEED_VECTORS
,
1575 test_acipher_speed("cfb(des3_ede)", ENCRYPT
, sec
,
1576 des3_speed_template
, DES3_SPEED_VECTORS
,
1578 test_acipher_speed("cfb(des3_ede)", DECRYPT
, sec
,
1579 des3_speed_template
, DES3_SPEED_VECTORS
,
1581 test_acipher_speed("ofb(des3_ede)", ENCRYPT
, sec
,
1582 des3_speed_template
, DES3_SPEED_VECTORS
,
1584 test_acipher_speed("ofb(des3_ede)", DECRYPT
, sec
,
1585 des3_speed_template
, DES3_SPEED_VECTORS
,
1590 test_acipher_speed("ecb(des)", ENCRYPT
, sec
, NULL
, 0,
1592 test_acipher_speed("ecb(des)", DECRYPT
, sec
, NULL
, 0,
1594 test_acipher_speed("cbc(des)", ENCRYPT
, sec
, NULL
, 0,
1596 test_acipher_speed("cbc(des)", DECRYPT
, sec
, NULL
, 0,
1598 test_acipher_speed("cfb(des)", ENCRYPT
, sec
, NULL
, 0,
1600 test_acipher_speed("cfb(des)", DECRYPT
, sec
, NULL
, 0,
1602 test_acipher_speed("ofb(des)", ENCRYPT
, sec
, NULL
, 0,
1604 test_acipher_speed("ofb(des)", DECRYPT
, sec
, NULL
, 0,
1609 test_acipher_speed("ecb(serpent)", ENCRYPT
, sec
, NULL
, 0,
1610 speed_template_16_32
);
1611 test_acipher_speed("ecb(serpent)", DECRYPT
, sec
, NULL
, 0,
1612 speed_template_16_32
);
1613 test_acipher_speed("cbc(serpent)", ENCRYPT
, sec
, NULL
, 0,
1614 speed_template_16_32
);
1615 test_acipher_speed("cbc(serpent)", DECRYPT
, sec
, NULL
, 0,
1616 speed_template_16_32
);
1617 test_acipher_speed("ctr(serpent)", ENCRYPT
, sec
, NULL
, 0,
1618 speed_template_16_32
);
1619 test_acipher_speed("ctr(serpent)", DECRYPT
, sec
, NULL
, 0,
1620 speed_template_16_32
);
1621 test_acipher_speed("lrw(serpent)", ENCRYPT
, sec
, NULL
, 0,
1622 speed_template_32_48
);
1623 test_acipher_speed("lrw(serpent)", DECRYPT
, sec
, NULL
, 0,
1624 speed_template_32_48
);
1625 test_acipher_speed("xts(serpent)", ENCRYPT
, sec
, NULL
, 0,
1626 speed_template_32_64
);
1627 test_acipher_speed("xts(serpent)", DECRYPT
, sec
, NULL
, 0,
1628 speed_template_32_64
);
1632 test_acipher_speed("ecb(twofish)", ENCRYPT
, sec
, NULL
, 0,
1633 speed_template_16_24_32
);
1634 test_acipher_speed("ecb(twofish)", DECRYPT
, sec
, NULL
, 0,
1635 speed_template_16_24_32
);
1636 test_acipher_speed("cbc(twofish)", ENCRYPT
, sec
, NULL
, 0,
1637 speed_template_16_24_32
);
1638 test_acipher_speed("cbc(twofish)", DECRYPT
, sec
, NULL
, 0,
1639 speed_template_16_24_32
);
1640 test_acipher_speed("ctr(twofish)", ENCRYPT
, sec
, NULL
, 0,
1641 speed_template_16_24_32
);
1642 test_acipher_speed("ctr(twofish)", DECRYPT
, sec
, NULL
, 0,
1643 speed_template_16_24_32
);
1644 test_acipher_speed("lrw(twofish)", ENCRYPT
, sec
, NULL
, 0,
1645 speed_template_32_40_48
);
1646 test_acipher_speed("lrw(twofish)", DECRYPT
, sec
, NULL
, 0,
1647 speed_template_32_40_48
);
1648 test_acipher_speed("xts(twofish)", ENCRYPT
, sec
, NULL
, 0,
1649 speed_template_32_48_64
);
1650 test_acipher_speed("xts(twofish)", DECRYPT
, sec
, NULL
, 0,
1651 speed_template_32_48_64
);
1655 test_acipher_speed("ecb(arc4)", ENCRYPT
, sec
, NULL
, 0,
1660 test_acipher_speed("ecb(cast5)", ENCRYPT
, sec
, NULL
, 0,
1661 speed_template_8_16
);
1662 test_acipher_speed("ecb(cast5)", DECRYPT
, sec
, NULL
, 0,
1663 speed_template_8_16
);
1664 test_acipher_speed("cbc(cast5)", ENCRYPT
, sec
, NULL
, 0,
1665 speed_template_8_16
);
1666 test_acipher_speed("cbc(cast5)", DECRYPT
, sec
, NULL
, 0,
1667 speed_template_8_16
);
1668 test_acipher_speed("ctr(cast5)", ENCRYPT
, sec
, NULL
, 0,
1669 speed_template_8_16
);
1670 test_acipher_speed("ctr(cast5)", DECRYPT
, sec
, NULL
, 0,
1671 speed_template_8_16
);
1682 static int do_alg_test(const char *alg
, u32 type
, u32 mask
)
1684 return crypto_has_alg(alg
, type
, mask
?: CRYPTO_ALG_TYPE_MASK
) ?
1688 static int __init
tcrypt_mod_init(void)
1693 for (i
= 0; i
< TVMEMSIZE
; i
++) {
1694 tvmem
[i
] = (void *)__get_free_page(GFP_KERNEL
);
1700 err
= do_alg_test(alg
, type
, mask
);
1702 err
= do_test(mode
);
1705 printk(KERN_ERR
"tcrypt: one or more tests failed!\n");
1709 /* We intentionaly return -EAGAIN to prevent keeping the module,
1710 * unless we're running in fips mode. It does all its work from
1711 * init() and doesn't offer any runtime functionality, but in
1712 * the fips case, checking for a successful load is helpful.
1713 * => we don't need it in the memory, do we?
1720 for (i
= 0; i
< TVMEMSIZE
&& tvmem
[i
]; i
++)
1721 free_page((unsigned long)tvmem
[i
]);
1727 * If an init function is provided, an exit function must also be provided
1728 * to allow module unload.
1730 static void __exit
tcrypt_mod_fini(void) { }
1732 module_init(tcrypt_mod_init
);
1733 module_exit(tcrypt_mod_fini
);
1735 module_param(alg
, charp
, 0);
1736 module_param(type
, uint
, 0);
1737 module_param(mask
, uint
, 0);
1738 module_param(mode
, int, 0);
1739 module_param(sec
, uint
, 0);
1740 MODULE_PARM_DESC(sec
, "Length in seconds of speed tests "
1741 "(defaults to zero which uses CPU cycles instead)");
1743 MODULE_LICENSE("GPL");
1744 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
1745 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");