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
, 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
);
886 sg_set_buf(sg
, tvmem
[0] + *keysize
,
887 PAGE_SIZE
- *keysize
);
888 for (j
= 1; j
< TVMEMSIZE
; j
++) {
889 sg_set_buf(sg
+ j
, tvmem
[j
], PAGE_SIZE
);
890 memset(tvmem
[j
], 0xff, PAGE_SIZE
);
893 iv_len
= crypto_ablkcipher_ivsize(tfm
);
895 memset(&iv
, 0xff, iv_len
);
897 ablkcipher_request_set_crypt(req
, sg
, sg
, *b_size
, iv
);
900 ret
= test_acipher_jiffies(req
, enc
,
903 ret
= test_acipher_cycles(req
, enc
,
907 pr_err("%s() failed flags=%x\n", e
,
908 crypto_ablkcipher_get_flags(tfm
));
918 ablkcipher_request_free(req
);
920 crypto_free_ablkcipher(tfm
);
923 static void test_available(void)
928 printk("alg %s ", *name
);
929 printk(crypto_has_alg(*name
, 0, 0) ?
930 "found\n" : "not found\n");
935 static inline int tcrypt_test(const char *alg
)
939 ret
= alg_test(alg
, alg
, 0, 0);
940 /* non-fips algs return -EINVAL in fips mode */
941 if (fips_enabled
&& ret
== -EINVAL
)
946 static int do_test(int m
)
953 for (i
= 1; i
< 200; i
++)
958 ret
+= tcrypt_test("md5");
962 ret
+= tcrypt_test("sha1");
966 ret
+= tcrypt_test("ecb(des)");
967 ret
+= tcrypt_test("cbc(des)");
971 ret
+= tcrypt_test("ecb(des3_ede)");
972 ret
+= tcrypt_test("cbc(des3_ede)");
976 ret
+= tcrypt_test("md4");
980 ret
+= tcrypt_test("sha256");
984 ret
+= tcrypt_test("ecb(blowfish)");
985 ret
+= tcrypt_test("cbc(blowfish)");
986 ret
+= tcrypt_test("ctr(blowfish)");
990 ret
+= tcrypt_test("ecb(twofish)");
991 ret
+= tcrypt_test("cbc(twofish)");
992 ret
+= tcrypt_test("ctr(twofish)");
993 ret
+= tcrypt_test("lrw(twofish)");
994 ret
+= tcrypt_test("xts(twofish)");
998 ret
+= tcrypt_test("ecb(serpent)");
999 ret
+= tcrypt_test("cbc(serpent)");
1000 ret
+= tcrypt_test("ctr(serpent)");
1001 ret
+= tcrypt_test("lrw(serpent)");
1002 ret
+= tcrypt_test("xts(serpent)");
1006 ret
+= tcrypt_test("ecb(aes)");
1007 ret
+= tcrypt_test("cbc(aes)");
1008 ret
+= tcrypt_test("lrw(aes)");
1009 ret
+= tcrypt_test("xts(aes)");
1010 ret
+= tcrypt_test("ctr(aes)");
1011 ret
+= tcrypt_test("rfc3686(ctr(aes))");
1015 ret
+= tcrypt_test("sha384");
1019 ret
+= tcrypt_test("sha512");
1023 ret
+= tcrypt_test("deflate");
1027 ret
+= tcrypt_test("ecb(cast5)");
1031 ret
+= tcrypt_test("ecb(cast6)");
1035 ret
+= tcrypt_test("ecb(arc4)");
1039 ret
+= tcrypt_test("michael_mic");
1043 ret
+= tcrypt_test("crc32c");
1047 ret
+= tcrypt_test("ecb(tea)");
1051 ret
+= tcrypt_test("ecb(xtea)");
1055 ret
+= tcrypt_test("ecb(khazad)");
1059 ret
+= tcrypt_test("wp512");
1063 ret
+= tcrypt_test("wp384");
1067 ret
+= tcrypt_test("wp256");
1071 ret
+= tcrypt_test("ecb(tnepres)");
1075 ret
+= tcrypt_test("ecb(anubis)");
1076 ret
+= tcrypt_test("cbc(anubis)");
1080 ret
+= tcrypt_test("tgr192");
1085 ret
+= tcrypt_test("tgr160");
1089 ret
+= tcrypt_test("tgr128");
1093 ret
+= tcrypt_test("ecb(xeta)");
1097 ret
+= tcrypt_test("pcbc(fcrypt)");
1101 ret
+= tcrypt_test("ecb(camellia)");
1102 ret
+= tcrypt_test("cbc(camellia)");
1105 ret
+= tcrypt_test("sha224");
1109 ret
+= tcrypt_test("salsa20");
1113 ret
+= tcrypt_test("gcm(aes)");
1117 ret
+= tcrypt_test("lzo");
1121 ret
+= tcrypt_test("ccm(aes)");
1125 ret
+= tcrypt_test("cts(cbc(aes))");
1129 ret
+= tcrypt_test("rmd128");
1133 ret
+= tcrypt_test("rmd160");
1137 ret
+= tcrypt_test("rmd256");
1141 ret
+= tcrypt_test("rmd320");
1145 ret
+= tcrypt_test("ecb(seed)");
1149 ret
+= tcrypt_test("zlib");
1153 ret
+= tcrypt_test("rfc4309(ccm(aes))");
1157 ret
+= tcrypt_test("hmac(md5)");
1161 ret
+= tcrypt_test("hmac(sha1)");
1165 ret
+= tcrypt_test("hmac(sha256)");
1169 ret
+= tcrypt_test("hmac(sha384)");
1173 ret
+= tcrypt_test("hmac(sha512)");
1177 ret
+= tcrypt_test("hmac(sha224)");
1181 ret
+= tcrypt_test("xcbc(aes)");
1185 ret
+= tcrypt_test("hmac(rmd128)");
1189 ret
+= tcrypt_test("hmac(rmd160)");
1193 ret
+= tcrypt_test("vmac(aes)");
1196 ret
+= tcrypt_test("hmac(crc32)");
1200 ret
+= tcrypt_test("ansi_cprng");
1204 ret
+= tcrypt_test("rfc4106(gcm(aes))");
1208 test_cipher_speed("ecb(aes)", ENCRYPT
, sec
, NULL
, 0,
1209 speed_template_16_24_32
);
1210 test_cipher_speed("ecb(aes)", DECRYPT
, sec
, NULL
, 0,
1211 speed_template_16_24_32
);
1212 test_cipher_speed("cbc(aes)", ENCRYPT
, sec
, NULL
, 0,
1213 speed_template_16_24_32
);
1214 test_cipher_speed("cbc(aes)", DECRYPT
, sec
, NULL
, 0,
1215 speed_template_16_24_32
);
1216 test_cipher_speed("lrw(aes)", ENCRYPT
, sec
, NULL
, 0,
1217 speed_template_32_40_48
);
1218 test_cipher_speed("lrw(aes)", DECRYPT
, sec
, NULL
, 0,
1219 speed_template_32_40_48
);
1220 test_cipher_speed("xts(aes)", ENCRYPT
, sec
, NULL
, 0,
1221 speed_template_32_48_64
);
1222 test_cipher_speed("xts(aes)", DECRYPT
, sec
, NULL
, 0,
1223 speed_template_32_48_64
);
1224 test_cipher_speed("ctr(aes)", ENCRYPT
, sec
, NULL
, 0,
1225 speed_template_16_24_32
);
1226 test_cipher_speed("ctr(aes)", DECRYPT
, sec
, NULL
, 0,
1227 speed_template_16_24_32
);
1231 test_cipher_speed("ecb(des3_ede)", ENCRYPT
, sec
,
1232 des3_speed_template
, DES3_SPEED_VECTORS
,
1234 test_cipher_speed("ecb(des3_ede)", DECRYPT
, sec
,
1235 des3_speed_template
, DES3_SPEED_VECTORS
,
1237 test_cipher_speed("cbc(des3_ede)", ENCRYPT
, sec
,
1238 des3_speed_template
, DES3_SPEED_VECTORS
,
1240 test_cipher_speed("cbc(des3_ede)", DECRYPT
, sec
,
1241 des3_speed_template
, DES3_SPEED_VECTORS
,
1246 test_cipher_speed("ecb(twofish)", ENCRYPT
, sec
, NULL
, 0,
1247 speed_template_16_24_32
);
1248 test_cipher_speed("ecb(twofish)", DECRYPT
, sec
, NULL
, 0,
1249 speed_template_16_24_32
);
1250 test_cipher_speed("cbc(twofish)", ENCRYPT
, sec
, NULL
, 0,
1251 speed_template_16_24_32
);
1252 test_cipher_speed("cbc(twofish)", DECRYPT
, sec
, NULL
, 0,
1253 speed_template_16_24_32
);
1254 test_cipher_speed("ctr(twofish)", ENCRYPT
, sec
, NULL
, 0,
1255 speed_template_16_24_32
);
1256 test_cipher_speed("ctr(twofish)", DECRYPT
, sec
, NULL
, 0,
1257 speed_template_16_24_32
);
1258 test_cipher_speed("lrw(twofish)", ENCRYPT
, sec
, NULL
, 0,
1259 speed_template_32_40_48
);
1260 test_cipher_speed("lrw(twofish)", DECRYPT
, sec
, NULL
, 0,
1261 speed_template_32_40_48
);
1262 test_cipher_speed("xts(twofish)", ENCRYPT
, sec
, NULL
, 0,
1263 speed_template_32_48_64
);
1264 test_cipher_speed("xts(twofish)", DECRYPT
, sec
, NULL
, 0,
1265 speed_template_32_48_64
);
1269 test_cipher_speed("ecb(blowfish)", ENCRYPT
, sec
, NULL
, 0,
1270 speed_template_8_32
);
1271 test_cipher_speed("ecb(blowfish)", DECRYPT
, sec
, NULL
, 0,
1272 speed_template_8_32
);
1273 test_cipher_speed("cbc(blowfish)", ENCRYPT
, sec
, NULL
, 0,
1274 speed_template_8_32
);
1275 test_cipher_speed("cbc(blowfish)", DECRYPT
, sec
, NULL
, 0,
1276 speed_template_8_32
);
1277 test_cipher_speed("ctr(blowfish)", ENCRYPT
, sec
, NULL
, 0,
1278 speed_template_8_32
);
1279 test_cipher_speed("ctr(blowfish)", DECRYPT
, sec
, NULL
, 0,
1280 speed_template_8_32
);
1284 test_cipher_speed("ecb(des)", ENCRYPT
, sec
, NULL
, 0,
1286 test_cipher_speed("ecb(des)", DECRYPT
, sec
, NULL
, 0,
1288 test_cipher_speed("cbc(des)", ENCRYPT
, sec
, NULL
, 0,
1290 test_cipher_speed("cbc(des)", DECRYPT
, sec
, NULL
, 0,
1295 test_cipher_speed("ecb(camellia)", ENCRYPT
, sec
, NULL
, 0,
1296 speed_template_16_24_32
);
1297 test_cipher_speed("ecb(camellia)", DECRYPT
, sec
, NULL
, 0,
1298 speed_template_16_24_32
);
1299 test_cipher_speed("cbc(camellia)", ENCRYPT
, sec
, NULL
, 0,
1300 speed_template_16_24_32
);
1301 test_cipher_speed("cbc(camellia)", DECRYPT
, sec
, NULL
, 0,
1302 speed_template_16_24_32
);
1303 test_cipher_speed("ctr(camellia)", ENCRYPT
, sec
, NULL
, 0,
1304 speed_template_16_24_32
);
1305 test_cipher_speed("ctr(camellia)", DECRYPT
, sec
, NULL
, 0,
1306 speed_template_16_24_32
);
1307 test_cipher_speed("lrw(camellia)", ENCRYPT
, sec
, NULL
, 0,
1308 speed_template_32_40_48
);
1309 test_cipher_speed("lrw(camellia)", DECRYPT
, sec
, NULL
, 0,
1310 speed_template_32_40_48
);
1311 test_cipher_speed("xts(camellia)", ENCRYPT
, sec
, NULL
, 0,
1312 speed_template_32_48_64
);
1313 test_cipher_speed("xts(camellia)", DECRYPT
, sec
, NULL
, 0,
1314 speed_template_32_48_64
);
1318 test_cipher_speed("salsa20", ENCRYPT
, sec
, NULL
, 0,
1319 speed_template_16_32
);
1323 test_cipher_speed("ecb(serpent)", ENCRYPT
, sec
, NULL
, 0,
1324 speed_template_16_32
);
1325 test_cipher_speed("ecb(serpent)", DECRYPT
, sec
, NULL
, 0,
1326 speed_template_16_32
);
1327 test_cipher_speed("cbc(serpent)", ENCRYPT
, sec
, NULL
, 0,
1328 speed_template_16_32
);
1329 test_cipher_speed("cbc(serpent)", DECRYPT
, sec
, NULL
, 0,
1330 speed_template_16_32
);
1331 test_cipher_speed("ctr(serpent)", ENCRYPT
, sec
, NULL
, 0,
1332 speed_template_16_32
);
1333 test_cipher_speed("ctr(serpent)", DECRYPT
, sec
, NULL
, 0,
1334 speed_template_16_32
);
1335 test_cipher_speed("lrw(serpent)", ENCRYPT
, sec
, NULL
, 0,
1336 speed_template_32_48
);
1337 test_cipher_speed("lrw(serpent)", DECRYPT
, sec
, NULL
, 0,
1338 speed_template_32_48
);
1339 test_cipher_speed("xts(serpent)", ENCRYPT
, sec
, NULL
, 0,
1340 speed_template_32_64
);
1341 test_cipher_speed("xts(serpent)", DECRYPT
, sec
, NULL
, 0,
1342 speed_template_32_64
);
1349 test_hash_speed("md4", sec
, generic_hash_speed_template
);
1350 if (mode
> 300 && mode
< 400) break;
1353 test_hash_speed("md5", sec
, generic_hash_speed_template
);
1354 if (mode
> 300 && mode
< 400) break;
1357 test_hash_speed("sha1", sec
, generic_hash_speed_template
);
1358 if (mode
> 300 && mode
< 400) break;
1361 test_hash_speed("sha256", sec
, generic_hash_speed_template
);
1362 if (mode
> 300 && mode
< 400) break;
1365 test_hash_speed("sha384", sec
, generic_hash_speed_template
);
1366 if (mode
> 300 && mode
< 400) break;
1369 test_hash_speed("sha512", sec
, generic_hash_speed_template
);
1370 if (mode
> 300 && mode
< 400) break;
1373 test_hash_speed("wp256", sec
, generic_hash_speed_template
);
1374 if (mode
> 300 && mode
< 400) break;
1377 test_hash_speed("wp384", sec
, generic_hash_speed_template
);
1378 if (mode
> 300 && mode
< 400) break;
1381 test_hash_speed("wp512", sec
, generic_hash_speed_template
);
1382 if (mode
> 300 && mode
< 400) break;
1385 test_hash_speed("tgr128", sec
, generic_hash_speed_template
);
1386 if (mode
> 300 && mode
< 400) break;
1389 test_hash_speed("tgr160", sec
, generic_hash_speed_template
);
1390 if (mode
> 300 && mode
< 400) break;
1393 test_hash_speed("tgr192", sec
, generic_hash_speed_template
);
1394 if (mode
> 300 && mode
< 400) break;
1397 test_hash_speed("sha224", sec
, generic_hash_speed_template
);
1398 if (mode
> 300 && mode
< 400) break;
1401 test_hash_speed("rmd128", sec
, generic_hash_speed_template
);
1402 if (mode
> 300 && mode
< 400) break;
1405 test_hash_speed("rmd160", sec
, generic_hash_speed_template
);
1406 if (mode
> 300 && mode
< 400) break;
1409 test_hash_speed("rmd256", sec
, generic_hash_speed_template
);
1410 if (mode
> 300 && mode
< 400) break;
1413 test_hash_speed("rmd320", sec
, generic_hash_speed_template
);
1414 if (mode
> 300 && mode
< 400) break;
1417 test_hash_speed("ghash-generic", sec
, hash_speed_template_16
);
1418 if (mode
> 300 && mode
< 400) break;
1427 test_ahash_speed("md4", sec
, generic_hash_speed_template
);
1428 if (mode
> 400 && mode
< 500) break;
1431 test_ahash_speed("md5", sec
, generic_hash_speed_template
);
1432 if (mode
> 400 && mode
< 500) break;
1435 test_ahash_speed("sha1", sec
, generic_hash_speed_template
);
1436 if (mode
> 400 && mode
< 500) break;
1439 test_ahash_speed("sha256", sec
, generic_hash_speed_template
);
1440 if (mode
> 400 && mode
< 500) break;
1443 test_ahash_speed("sha384", sec
, generic_hash_speed_template
);
1444 if (mode
> 400 && mode
< 500) break;
1447 test_ahash_speed("sha512", sec
, generic_hash_speed_template
);
1448 if (mode
> 400 && mode
< 500) break;
1451 test_ahash_speed("wp256", sec
, generic_hash_speed_template
);
1452 if (mode
> 400 && mode
< 500) break;
1455 test_ahash_speed("wp384", sec
, generic_hash_speed_template
);
1456 if (mode
> 400 && mode
< 500) break;
1459 test_ahash_speed("wp512", sec
, generic_hash_speed_template
);
1460 if (mode
> 400 && mode
< 500) break;
1463 test_ahash_speed("tgr128", sec
, generic_hash_speed_template
);
1464 if (mode
> 400 && mode
< 500) break;
1467 test_ahash_speed("tgr160", sec
, generic_hash_speed_template
);
1468 if (mode
> 400 && mode
< 500) break;
1471 test_ahash_speed("tgr192", sec
, generic_hash_speed_template
);
1472 if (mode
> 400 && mode
< 500) break;
1475 test_ahash_speed("sha224", sec
, generic_hash_speed_template
);
1476 if (mode
> 400 && mode
< 500) break;
1479 test_ahash_speed("rmd128", sec
, generic_hash_speed_template
);
1480 if (mode
> 400 && mode
< 500) break;
1483 test_ahash_speed("rmd160", sec
, generic_hash_speed_template
);
1484 if (mode
> 400 && mode
< 500) break;
1487 test_ahash_speed("rmd256", sec
, generic_hash_speed_template
);
1488 if (mode
> 400 && mode
< 500) break;
1491 test_ahash_speed("rmd320", sec
, generic_hash_speed_template
);
1492 if (mode
> 400 && mode
< 500) break;
1498 test_acipher_speed("ecb(aes)", ENCRYPT
, sec
, NULL
, 0,
1499 speed_template_16_24_32
);
1500 test_acipher_speed("ecb(aes)", DECRYPT
, sec
, NULL
, 0,
1501 speed_template_16_24_32
);
1502 test_acipher_speed("cbc(aes)", ENCRYPT
, sec
, NULL
, 0,
1503 speed_template_16_24_32
);
1504 test_acipher_speed("cbc(aes)", DECRYPT
, sec
, NULL
, 0,
1505 speed_template_16_24_32
);
1506 test_acipher_speed("lrw(aes)", ENCRYPT
, sec
, NULL
, 0,
1507 speed_template_32_40_48
);
1508 test_acipher_speed("lrw(aes)", DECRYPT
, sec
, NULL
, 0,
1509 speed_template_32_40_48
);
1510 test_acipher_speed("xts(aes)", ENCRYPT
, sec
, NULL
, 0,
1511 speed_template_32_48_64
);
1512 test_acipher_speed("xts(aes)", DECRYPT
, sec
, NULL
, 0,
1513 speed_template_32_48_64
);
1514 test_acipher_speed("ctr(aes)", ENCRYPT
, sec
, NULL
, 0,
1515 speed_template_16_24_32
);
1516 test_acipher_speed("ctr(aes)", DECRYPT
, sec
, NULL
, 0,
1517 speed_template_16_24_32
);
1521 test_acipher_speed("ecb(des3_ede)", ENCRYPT
, sec
,
1522 des3_speed_template
, DES3_SPEED_VECTORS
,
1524 test_acipher_speed("ecb(des3_ede)", DECRYPT
, sec
,
1525 des3_speed_template
, DES3_SPEED_VECTORS
,
1527 test_acipher_speed("cbc(des3_ede)", ENCRYPT
, sec
,
1528 des3_speed_template
, DES3_SPEED_VECTORS
,
1530 test_acipher_speed("cbc(des3_ede)", DECRYPT
, sec
,
1531 des3_speed_template
, DES3_SPEED_VECTORS
,
1536 test_acipher_speed("ecb(des)", ENCRYPT
, sec
, NULL
, 0,
1538 test_acipher_speed("ecb(des)", DECRYPT
, sec
, NULL
, 0,
1540 test_acipher_speed("cbc(des)", ENCRYPT
, sec
, NULL
, 0,
1542 test_acipher_speed("cbc(des)", DECRYPT
, sec
, NULL
, 0,
1547 test_acipher_speed("ecb(serpent)", ENCRYPT
, sec
, NULL
, 0,
1548 speed_template_16_32
);
1549 test_acipher_speed("ecb(serpent)", DECRYPT
, sec
, NULL
, 0,
1550 speed_template_16_32
);
1551 test_acipher_speed("cbc(serpent)", ENCRYPT
, sec
, NULL
, 0,
1552 speed_template_16_32
);
1553 test_acipher_speed("cbc(serpent)", DECRYPT
, sec
, NULL
, 0,
1554 speed_template_16_32
);
1555 test_acipher_speed("ctr(serpent)", ENCRYPT
, sec
, NULL
, 0,
1556 speed_template_16_32
);
1557 test_acipher_speed("ctr(serpent)", DECRYPT
, sec
, NULL
, 0,
1558 speed_template_16_32
);
1559 test_acipher_speed("lrw(serpent)", ENCRYPT
, sec
, NULL
, 0,
1560 speed_template_32_48
);
1561 test_acipher_speed("lrw(serpent)", DECRYPT
, sec
, NULL
, 0,
1562 speed_template_32_48
);
1563 test_acipher_speed("xts(serpent)", ENCRYPT
, sec
, NULL
, 0,
1564 speed_template_32_64
);
1565 test_acipher_speed("xts(serpent)", DECRYPT
, sec
, NULL
, 0,
1566 speed_template_32_64
);
1570 test_acipher_speed("ecb(twofish)", ENCRYPT
, sec
, NULL
, 0,
1571 speed_template_16_24_32
);
1572 test_acipher_speed("ecb(twofish)", DECRYPT
, sec
, NULL
, 0,
1573 speed_template_16_24_32
);
1574 test_acipher_speed("cbc(twofish)", ENCRYPT
, sec
, NULL
, 0,
1575 speed_template_16_24_32
);
1576 test_acipher_speed("cbc(twofish)", DECRYPT
, sec
, NULL
, 0,
1577 speed_template_16_24_32
);
1578 test_acipher_speed("ctr(twofish)", ENCRYPT
, sec
, NULL
, 0,
1579 speed_template_16_24_32
);
1580 test_acipher_speed("ctr(twofish)", DECRYPT
, sec
, NULL
, 0,
1581 speed_template_16_24_32
);
1582 test_acipher_speed("lrw(twofish)", ENCRYPT
, sec
, NULL
, 0,
1583 speed_template_32_40_48
);
1584 test_acipher_speed("lrw(twofish)", DECRYPT
, sec
, NULL
, 0,
1585 speed_template_32_40_48
);
1586 test_acipher_speed("xts(twofish)", ENCRYPT
, sec
, NULL
, 0,
1587 speed_template_32_48_64
);
1588 test_acipher_speed("xts(twofish)", DECRYPT
, sec
, NULL
, 0,
1589 speed_template_32_48_64
);
1600 static int do_alg_test(const char *alg
, u32 type
, u32 mask
)
1602 return crypto_has_alg(alg
, type
, mask
?: CRYPTO_ALG_TYPE_MASK
) ?
1606 static int __init
tcrypt_mod_init(void)
1611 for (i
= 0; i
< TVMEMSIZE
; i
++) {
1612 tvmem
[i
] = (void *)__get_free_page(GFP_KERNEL
);
1618 err
= do_alg_test(alg
, type
, mask
);
1620 err
= do_test(mode
);
1623 printk(KERN_ERR
"tcrypt: one or more tests failed!\n");
1627 /* We intentionaly return -EAGAIN to prevent keeping the module,
1628 * unless we're running in fips mode. It does all its work from
1629 * init() and doesn't offer any runtime functionality, but in
1630 * the fips case, checking for a successful load is helpful.
1631 * => we don't need it in the memory, do we?
1638 for (i
= 0; i
< TVMEMSIZE
&& tvmem
[i
]; i
++)
1639 free_page((unsigned long)tvmem
[i
]);
1645 * If an init function is provided, an exit function must also be provided
1646 * to allow module unload.
1648 static void __exit
tcrypt_mod_fini(void) { }
1650 module_init(tcrypt_mod_init
);
1651 module_exit(tcrypt_mod_fini
);
1653 module_param(alg
, charp
, 0);
1654 module_param(type
, uint
, 0);
1655 module_param(mask
, uint
, 0);
1656 module_param(mode
, int, 0);
1657 module_param(sec
, uint
, 0);
1658 MODULE_PARM_DESC(sec
, "Length in seconds of speed tests "
1659 "(defaults to zero which uses CPU cycles instead)");
1661 MODULE_LICENSE("GPL");
1662 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
1663 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");