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>
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the Free
12 * Software Foundation; either version 2 of the License, or (at your option)
15 * 2006-12-07 Added SHA384 HMAC and SHA512 HMAC tests
16 * 2004-08-09 Added cipher speed tests (Reyk Floeter <reyk@vantronix.net>)
17 * 2003-09-14 Rewritten by Kartikey Mahendra Bhatt
21 #include <linux/err.h>
22 #include <linux/init.h>
23 #include <linux/module.h>
25 #include <linux/slab.h>
26 #include <linux/scatterlist.h>
27 #include <linux/string.h>
28 #include <linux/crypto.h>
29 #include <linux/highmem.h>
30 #include <linux/moduleparam.h>
31 #include <linux/jiffies.h>
32 #include <linux/timex.h>
33 #include <linux/interrupt.h>
37 * Need to kmalloc() memory for testing kmap().
39 #define TVMEMSIZE 16384
40 #define XBUFSIZE 32768
43 * Indexes into the xbuf to simulate cross-page access.
55 * Used by test_cipher()
60 struct tcrypt_result
{
61 struct completion completion
;
65 static unsigned int IDX
[8] = { IDX1
, IDX2
, IDX3
, IDX4
, IDX5
, IDX6
, IDX7
, IDX8
};
68 * Used by test_cipher_speed()
70 static unsigned int sec
;
76 static char *check
[] = {
77 "des", "md5", "des3_ede", "rot13", "sha1", "sha256", "blowfish",
78 "twofish", "serpent", "sha384", "sha512", "md4", "aes", "cast6",
79 "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
80 "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", "fcrypt",
81 "camellia", "seed", NULL
84 static void hexdump(unsigned char *buf
, unsigned int len
)
87 printk("%02x", *buf
++);
92 static void tcrypt_complete(struct crypto_async_request
*req
, int err
)
94 struct tcrypt_result
*res
= req
->data
;
96 if (err
== -EINPROGRESS
)
100 complete(&res
->completion
);
103 static void test_hash(char *algo
, struct hash_testvec
*template,
106 unsigned int i
, j
, k
, temp
;
107 struct scatterlist sg
[8];
109 struct crypto_hash
*tfm
;
110 struct hash_desc desc
;
111 struct hash_testvec
*hash_tv
;
115 printk("\ntesting %s\n", algo
);
117 tsize
= sizeof(struct hash_testvec
);
120 if (tsize
> TVMEMSIZE
) {
121 printk("template (%u) too big for tvmem (%u)\n", tsize
, TVMEMSIZE
);
125 memcpy(tvmem
, template, tsize
);
126 hash_tv
= (void *)tvmem
;
128 tfm
= crypto_alloc_hash(algo
, 0, CRYPTO_ALG_ASYNC
);
130 printk("failed to load transform for %s: %ld\n", algo
,
138 for (i
= 0; i
< tcount
; i
++) {
139 printk("test %u:\n", i
+ 1);
140 memset(result
, 0, 64);
142 sg_init_one(&sg
[0], hash_tv
[i
].plaintext
, hash_tv
[i
].psize
);
144 if (hash_tv
[i
].ksize
) {
145 ret
= crypto_hash_setkey(tfm
, hash_tv
[i
].key
,
148 printk("setkey() failed ret=%d\n", ret
);
153 ret
= crypto_hash_digest(&desc
, sg
, hash_tv
[i
].psize
, result
);
155 printk("digest () failed ret=%d\n", ret
);
159 hexdump(result
, crypto_hash_digestsize(tfm
));
161 memcmp(result
, hash_tv
[i
].digest
,
162 crypto_hash_digestsize(tfm
)) ?
166 printk("testing %s across pages\n", algo
);
168 /* setup the dummy buffer first */
169 memset(xbuf
, 0, XBUFSIZE
);
172 for (i
= 0; i
< tcount
; i
++) {
175 printk("test %u:\n", j
);
176 memset(result
, 0, 64);
179 sg_init_table(sg
, hash_tv
[i
].np
);
180 for (k
= 0; k
< hash_tv
[i
].np
; k
++) {
181 memcpy(&xbuf
[IDX
[k
]],
182 hash_tv
[i
].plaintext
+ temp
,
184 temp
+= hash_tv
[i
].tap
[k
];
185 sg_set_buf(&sg
[k
], &xbuf
[IDX
[k
]],
189 if (hash_tv
[i
].ksize
) {
190 ret
= crypto_hash_setkey(tfm
, hash_tv
[i
].key
,
194 printk("setkey() failed ret=%d\n", ret
);
199 ret
= crypto_hash_digest(&desc
, sg
, hash_tv
[i
].psize
,
202 printk("digest () failed ret=%d\n", ret
);
206 hexdump(result
, crypto_hash_digestsize(tfm
));
208 memcmp(result
, hash_tv
[i
].digest
,
209 crypto_hash_digestsize(tfm
)) ?
215 crypto_free_hash(tfm
);
218 static void test_cipher(char *algo
, int enc
,
219 struct cipher_testvec
*template, unsigned int tcount
)
221 unsigned int ret
, i
, j
, k
, temp
;
224 struct crypto_ablkcipher
*tfm
;
226 struct cipher_testvec
*cipher_tv
;
227 struct ablkcipher_request
*req
;
228 struct scatterlist sg
[8];
230 struct tcrypt_result result
;
237 printk("\ntesting %s %s\n", algo
, e
);
239 tsize
= sizeof (struct cipher_testvec
);
242 if (tsize
> TVMEMSIZE
) {
243 printk("template (%u) too big for tvmem (%u)\n", tsize
,
248 memcpy(tvmem
, template, tsize
);
249 cipher_tv
= (void *)tvmem
;
251 init_completion(&result
.completion
);
253 tfm
= crypto_alloc_ablkcipher(algo
, 0, 0);
256 printk("failed to load transform for %s: %ld\n", algo
,
261 req
= ablkcipher_request_alloc(tfm
, GFP_KERNEL
);
263 printk("failed to allocate request for %s\n", algo
);
267 ablkcipher_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
268 tcrypt_complete
, &result
);
271 for (i
= 0; i
< tcount
; i
++) {
272 if (!(cipher_tv
[i
].np
)) {
274 printk("test %u (%d bit key):\n",
275 j
, cipher_tv
[i
].klen
* 8);
277 crypto_ablkcipher_clear_flags(tfm
, ~0);
279 crypto_ablkcipher_set_flags(
280 tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
281 key
= cipher_tv
[i
].key
;
283 ret
= crypto_ablkcipher_setkey(tfm
, key
,
286 printk("setkey() failed flags=%x\n",
287 crypto_ablkcipher_get_flags(tfm
));
289 if (!cipher_tv
[i
].fail
)
293 sg_init_one(&sg
[0], cipher_tv
[i
].input
,
296 ablkcipher_request_set_crypt(req
, sg
, sg
,
301 crypto_ablkcipher_encrypt(req
) :
302 crypto_ablkcipher_decrypt(req
);
309 ret
= wait_for_completion_interruptible(
311 if (!ret
&& !((ret
= result
.err
))) {
312 INIT_COMPLETION(result
.completion
);
317 printk("%s () failed err=%d\n", e
, -ret
);
321 q
= kmap(sg_page(&sg
[0])) + sg
[0].offset
;
322 hexdump(q
, cipher_tv
[i
].rlen
);
325 memcmp(q
, cipher_tv
[i
].result
,
326 cipher_tv
[i
].rlen
) ? "fail" : "pass");
330 printk("\ntesting %s %s across pages (chunking)\n", algo
, e
);
331 memset(xbuf
, 0, XBUFSIZE
);
334 for (i
= 0; i
< tcount
; i
++) {
335 if (cipher_tv
[i
].np
) {
337 printk("test %u (%d bit key):\n",
338 j
, cipher_tv
[i
].klen
* 8);
340 crypto_ablkcipher_clear_flags(tfm
, ~0);
342 crypto_ablkcipher_set_flags(
343 tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
344 key
= cipher_tv
[i
].key
;
346 ret
= crypto_ablkcipher_setkey(tfm
, key
,
349 printk("setkey() failed flags=%x\n",
350 crypto_ablkcipher_get_flags(tfm
));
352 if (!cipher_tv
[i
].fail
)
357 sg_init_table(sg
, cipher_tv
[i
].np
);
358 for (k
= 0; k
< cipher_tv
[i
].np
; k
++) {
359 memcpy(&xbuf
[IDX
[k
]],
360 cipher_tv
[i
].input
+ temp
,
361 cipher_tv
[i
].tap
[k
]);
362 temp
+= cipher_tv
[i
].tap
[k
];
363 sg_set_buf(&sg
[k
], &xbuf
[IDX
[k
]],
364 cipher_tv
[i
].tap
[k
]);
367 ablkcipher_request_set_crypt(req
, sg
, sg
,
372 crypto_ablkcipher_encrypt(req
) :
373 crypto_ablkcipher_decrypt(req
);
380 ret
= wait_for_completion_interruptible(
382 if (!ret
&& !((ret
= result
.err
))) {
383 INIT_COMPLETION(result
.completion
);
388 printk("%s () failed err=%d\n", e
, -ret
);
393 for (k
= 0; k
< cipher_tv
[i
].np
; k
++) {
394 printk("page %u\n", k
);
395 q
= kmap(sg_page(&sg
[k
])) + sg
[k
].offset
;
396 hexdump(q
, cipher_tv
[i
].tap
[k
]);
398 memcmp(q
, cipher_tv
[i
].result
+ temp
,
399 cipher_tv
[i
].tap
[k
]) ? "fail" :
401 temp
+= cipher_tv
[i
].tap
[k
];
407 crypto_free_ablkcipher(tfm
);
408 ablkcipher_request_free(req
);
411 static int test_cipher_jiffies(struct blkcipher_desc
*desc
, int enc
, char *p
,
414 struct scatterlist sg
[1];
415 unsigned long start
, end
;
419 sg_init_one(sg
, p
, blen
);
421 for (start
= jiffies
, end
= start
+ sec
* HZ
, bcount
= 0;
422 time_before(jiffies
, end
); bcount
++) {
424 ret
= crypto_blkcipher_encrypt(desc
, sg
, sg
, blen
);
426 ret
= crypto_blkcipher_decrypt(desc
, sg
, sg
, blen
);
432 printk("%d operations in %d seconds (%ld bytes)\n",
433 bcount
, sec
, (long)bcount
* blen
);
437 static int test_cipher_cycles(struct blkcipher_desc
*desc
, int enc
, char *p
,
440 struct scatterlist sg
[1];
441 unsigned long cycles
= 0;
445 sg_init_one(sg
, p
, blen
);
451 for (i
= 0; i
< 4; i
++) {
453 ret
= crypto_blkcipher_encrypt(desc
, sg
, sg
, blen
);
455 ret
= crypto_blkcipher_decrypt(desc
, sg
, sg
, blen
);
461 /* The real thing. */
462 for (i
= 0; i
< 8; i
++) {
465 start
= get_cycles();
467 ret
= crypto_blkcipher_encrypt(desc
, sg
, sg
, blen
);
469 ret
= crypto_blkcipher_decrypt(desc
, sg
, sg
, blen
);
475 cycles
+= end
- start
;
483 printk("1 operation in %lu cycles (%d bytes)\n",
484 (cycles
+ 4) / 8, blen
);
489 static void test_cipher_speed(char *algo
, int enc
, unsigned int sec
,
490 struct cipher_testvec
*template,
491 unsigned int tcount
, struct cipher_speed
*speed
)
493 unsigned int ret
, i
, j
, iv_len
;
494 unsigned char *key
, *p
, iv
[128];
495 struct crypto_blkcipher
*tfm
;
496 struct blkcipher_desc desc
;
504 printk("\ntesting speed of %s %s\n", algo
, e
);
506 tfm
= crypto_alloc_blkcipher(algo
, 0, CRYPTO_ALG_ASYNC
);
509 printk("failed to load transform for %s: %ld\n", algo
,
516 for (i
= 0; speed
[i
].klen
!= 0; i
++) {
517 if ((speed
[i
].blen
+ speed
[i
].klen
) > TVMEMSIZE
) {
518 printk("template (%u) too big for tvmem (%u)\n",
519 speed
[i
].blen
+ speed
[i
].klen
, TVMEMSIZE
);
523 printk("test %u (%d bit key, %d byte blocks): ", i
,
524 speed
[i
].klen
* 8, speed
[i
].blen
);
526 memset(tvmem
, 0xff, speed
[i
].klen
+ speed
[i
].blen
);
528 /* set key, plain text and IV */
529 key
= (unsigned char *)tvmem
;
530 for (j
= 0; j
< tcount
; j
++) {
531 if (template[j
].klen
== speed
[i
].klen
) {
532 key
= template[j
].key
;
536 p
= (unsigned char *)tvmem
+ speed
[i
].klen
;
538 ret
= crypto_blkcipher_setkey(tfm
, key
, speed
[i
].klen
);
540 printk("setkey() failed flags=%x\n",
541 crypto_blkcipher_get_flags(tfm
));
545 iv_len
= crypto_blkcipher_ivsize(tfm
);
547 memset(&iv
, 0xff, iv_len
);
548 crypto_blkcipher_set_iv(tfm
, iv
, iv_len
);
552 ret
= test_cipher_jiffies(&desc
, enc
, p
, speed
[i
].blen
,
555 ret
= test_cipher_cycles(&desc
, enc
, p
, speed
[i
].blen
);
558 printk("%s() failed flags=%x\n", e
, desc
.flags
);
564 crypto_free_blkcipher(tfm
);
567 static int test_hash_jiffies_digest(struct hash_desc
*desc
, char *p
, int blen
,
570 struct scatterlist sg
[1];
571 unsigned long start
, end
;
575 for (start
= jiffies
, end
= start
+ sec
* HZ
, bcount
= 0;
576 time_before(jiffies
, end
); bcount
++) {
577 sg_init_one(sg
, p
, blen
);
578 ret
= crypto_hash_digest(desc
, sg
, blen
, out
);
583 printk("%6u opers/sec, %9lu bytes/sec\n",
584 bcount
/ sec
, ((long)bcount
* blen
) / sec
);
589 static int test_hash_jiffies(struct hash_desc
*desc
, char *p
, int blen
,
590 int plen
, char *out
, int sec
)
592 struct scatterlist sg
[1];
593 unsigned long start
, end
;
598 return test_hash_jiffies_digest(desc
, p
, blen
, out
, sec
);
600 for (start
= jiffies
, end
= start
+ sec
* HZ
, bcount
= 0;
601 time_before(jiffies
, end
); bcount
++) {
602 ret
= crypto_hash_init(desc
);
605 for (pcount
= 0; pcount
< blen
; pcount
+= plen
) {
606 sg_init_one(sg
, p
+ pcount
, plen
);
607 ret
= crypto_hash_update(desc
, sg
, plen
);
611 /* we assume there is enough space in 'out' for the result */
612 ret
= crypto_hash_final(desc
, out
);
617 printk("%6u opers/sec, %9lu bytes/sec\n",
618 bcount
/ sec
, ((long)bcount
* blen
) / sec
);
623 static int test_hash_cycles_digest(struct hash_desc
*desc
, char *p
, int blen
,
626 struct scatterlist sg
[1];
627 unsigned long cycles
= 0;
635 for (i
= 0; i
< 4; i
++) {
636 sg_init_one(sg
, p
, blen
);
637 ret
= crypto_hash_digest(desc
, sg
, blen
, out
);
642 /* The real thing. */
643 for (i
= 0; i
< 8; i
++) {
646 start
= get_cycles();
648 sg_init_one(sg
, p
, blen
);
649 ret
= crypto_hash_digest(desc
, sg
, blen
, out
);
655 cycles
+= end
- start
;
665 printk("%6lu cycles/operation, %4lu cycles/byte\n",
666 cycles
/ 8, cycles
/ (8 * blen
));
671 static int test_hash_cycles(struct hash_desc
*desc
, char *p
, int blen
,
674 struct scatterlist sg
[1];
675 unsigned long cycles
= 0;
680 return test_hash_cycles_digest(desc
, p
, blen
, out
);
686 for (i
= 0; i
< 4; i
++) {
687 ret
= crypto_hash_init(desc
);
690 for (pcount
= 0; pcount
< blen
; pcount
+= plen
) {
691 sg_init_one(sg
, p
+ pcount
, plen
);
692 ret
= crypto_hash_update(desc
, sg
, plen
);
696 ret
= crypto_hash_final(desc
, out
);
701 /* The real thing. */
702 for (i
= 0; i
< 8; i
++) {
705 start
= get_cycles();
707 ret
= crypto_hash_init(desc
);
710 for (pcount
= 0; pcount
< blen
; pcount
+= plen
) {
711 sg_init_one(sg
, p
+ pcount
, plen
);
712 ret
= crypto_hash_update(desc
, sg
, plen
);
716 ret
= crypto_hash_final(desc
, out
);
722 cycles
+= end
- start
;
732 printk("%6lu cycles/operation, %4lu cycles/byte\n",
733 cycles
/ 8, cycles
/ (8 * blen
));
738 static void test_hash_speed(char *algo
, unsigned int sec
,
739 struct hash_speed
*speed
)
741 struct crypto_hash
*tfm
;
742 struct hash_desc desc
;
747 printk("\ntesting speed of %s\n", algo
);
749 tfm
= crypto_alloc_hash(algo
, 0, CRYPTO_ALG_ASYNC
);
752 printk("failed to load transform for %s: %ld\n", algo
,
760 if (crypto_hash_digestsize(tfm
) > sizeof(output
)) {
761 printk("digestsize(%u) > outputbuffer(%zu)\n",
762 crypto_hash_digestsize(tfm
), sizeof(output
));
766 for (i
= 0; speed
[i
].blen
!= 0; i
++) {
767 if (speed
[i
].blen
> TVMEMSIZE
) {
768 printk("template (%u) too big for tvmem (%u)\n",
769 speed
[i
].blen
, TVMEMSIZE
);
773 printk("test%3u (%5u byte blocks,%5u bytes per update,%4u updates): ",
774 i
, speed
[i
].blen
, speed
[i
].plen
, speed
[i
].blen
/ speed
[i
].plen
);
776 memset(tvmem
, 0xff, speed
[i
].blen
);
779 ret
= test_hash_jiffies(&desc
, tvmem
, speed
[i
].blen
,
780 speed
[i
].plen
, output
, sec
);
782 ret
= test_hash_cycles(&desc
, tvmem
, speed
[i
].blen
,
783 speed
[i
].plen
, output
);
786 printk("hashing failed ret=%d\n", ret
);
792 crypto_free_hash(tfm
);
795 static void test_deflate(void)
798 char result
[COMP_BUF_SIZE
];
799 struct crypto_comp
*tfm
;
800 struct comp_testvec
*tv
;
803 printk("\ntesting deflate compression\n");
805 tsize
= sizeof (deflate_comp_tv_template
);
806 if (tsize
> TVMEMSIZE
) {
807 printk("template (%u) too big for tvmem (%u)\n", tsize
,
812 memcpy(tvmem
, deflate_comp_tv_template
, tsize
);
815 tfm
= crypto_alloc_comp("deflate", 0, CRYPTO_ALG_ASYNC
);
817 printk("failed to load transform for deflate\n");
821 for (i
= 0; i
< DEFLATE_COMP_TEST_VECTORS
; i
++) {
822 int ilen
, ret
, dlen
= COMP_BUF_SIZE
;
824 printk("test %u:\n", i
+ 1);
825 memset(result
, 0, sizeof (result
));
828 ret
= crypto_comp_compress(tfm
, tv
[i
].input
,
829 ilen
, result
, &dlen
);
831 printk("fail: ret=%d\n", ret
);
834 hexdump(result
, dlen
);
835 printk("%s (ratio %d:%d)\n",
836 memcmp(result
, tv
[i
].output
, dlen
) ? "fail" : "pass",
840 printk("\ntesting deflate decompression\n");
842 tsize
= sizeof (deflate_decomp_tv_template
);
843 if (tsize
> TVMEMSIZE
) {
844 printk("template (%u) too big for tvmem (%u)\n", tsize
,
849 memcpy(tvmem
, deflate_decomp_tv_template
, tsize
);
852 for (i
= 0; i
< DEFLATE_DECOMP_TEST_VECTORS
; i
++) {
853 int ilen
, ret
, dlen
= COMP_BUF_SIZE
;
855 printk("test %u:\n", i
+ 1);
856 memset(result
, 0, sizeof (result
));
859 ret
= crypto_comp_decompress(tfm
, tv
[i
].input
,
860 ilen
, result
, &dlen
);
862 printk("fail: ret=%d\n", ret
);
865 hexdump(result
, dlen
);
866 printk("%s (ratio %d:%d)\n",
867 memcmp(result
, tv
[i
].output
, dlen
) ? "fail" : "pass",
871 crypto_free_comp(tfm
);
874 static void test_available(void)
879 printk("alg %s ", *name
);
880 printk(crypto_has_alg(*name
, 0, 0) ?
881 "found\n" : "not found\n");
886 static void do_test(void)
891 test_hash("md5", md5_tv_template
, MD5_TEST_VECTORS
);
893 test_hash("sha1", sha1_tv_template
, SHA1_TEST_VECTORS
);
896 test_cipher("ecb(des)", ENCRYPT
, des_enc_tv_template
,
897 DES_ENC_TEST_VECTORS
);
898 test_cipher("ecb(des)", DECRYPT
, des_dec_tv_template
,
899 DES_DEC_TEST_VECTORS
);
900 test_cipher("cbc(des)", ENCRYPT
, des_cbc_enc_tv_template
,
901 DES_CBC_ENC_TEST_VECTORS
);
902 test_cipher("cbc(des)", DECRYPT
, des_cbc_dec_tv_template
,
903 DES_CBC_DEC_TEST_VECTORS
);
906 test_cipher("ecb(des3_ede)", ENCRYPT
, des3_ede_enc_tv_template
,
907 DES3_EDE_ENC_TEST_VECTORS
);
908 test_cipher("ecb(des3_ede)", DECRYPT
, des3_ede_dec_tv_template
,
909 DES3_EDE_DEC_TEST_VECTORS
);
911 test_hash("md4", md4_tv_template
, MD4_TEST_VECTORS
);
913 test_hash("sha256", sha256_tv_template
, SHA256_TEST_VECTORS
);
916 test_cipher("ecb(blowfish)", ENCRYPT
, bf_enc_tv_template
,
917 BF_ENC_TEST_VECTORS
);
918 test_cipher("ecb(blowfish)", DECRYPT
, bf_dec_tv_template
,
919 BF_DEC_TEST_VECTORS
);
920 test_cipher("cbc(blowfish)", ENCRYPT
, bf_cbc_enc_tv_template
,
921 BF_CBC_ENC_TEST_VECTORS
);
922 test_cipher("cbc(blowfish)", DECRYPT
, bf_cbc_dec_tv_template
,
923 BF_CBC_DEC_TEST_VECTORS
);
926 test_cipher("ecb(twofish)", ENCRYPT
, tf_enc_tv_template
,
927 TF_ENC_TEST_VECTORS
);
928 test_cipher("ecb(twofish)", DECRYPT
, tf_dec_tv_template
,
929 TF_DEC_TEST_VECTORS
);
930 test_cipher("cbc(twofish)", ENCRYPT
, tf_cbc_enc_tv_template
,
931 TF_CBC_ENC_TEST_VECTORS
);
932 test_cipher("cbc(twofish)", DECRYPT
, tf_cbc_dec_tv_template
,
933 TF_CBC_DEC_TEST_VECTORS
);
936 test_cipher("ecb(serpent)", ENCRYPT
, serpent_enc_tv_template
,
937 SERPENT_ENC_TEST_VECTORS
);
938 test_cipher("ecb(serpent)", DECRYPT
, serpent_dec_tv_template
,
939 SERPENT_DEC_TEST_VECTORS
);
942 test_cipher("ecb(tnepres)", ENCRYPT
, tnepres_enc_tv_template
,
943 TNEPRES_ENC_TEST_VECTORS
);
944 test_cipher("ecb(tnepres)", DECRYPT
, tnepres_dec_tv_template
,
945 TNEPRES_DEC_TEST_VECTORS
);
948 test_cipher("ecb(aes)", ENCRYPT
, aes_enc_tv_template
,
949 AES_ENC_TEST_VECTORS
);
950 test_cipher("ecb(aes)", DECRYPT
, aes_dec_tv_template
,
951 AES_DEC_TEST_VECTORS
);
952 test_cipher("cbc(aes)", ENCRYPT
, aes_cbc_enc_tv_template
,
953 AES_CBC_ENC_TEST_VECTORS
);
954 test_cipher("cbc(aes)", DECRYPT
, aes_cbc_dec_tv_template
,
955 AES_CBC_DEC_TEST_VECTORS
);
956 test_cipher("lrw(aes)", ENCRYPT
, aes_lrw_enc_tv_template
,
957 AES_LRW_ENC_TEST_VECTORS
);
958 test_cipher("lrw(aes)", DECRYPT
, aes_lrw_dec_tv_template
,
959 AES_LRW_DEC_TEST_VECTORS
);
960 test_cipher("xts(aes)", ENCRYPT
, aes_xts_enc_tv_template
,
961 AES_XTS_ENC_TEST_VECTORS
);
962 test_cipher("xts(aes)", DECRYPT
, aes_xts_dec_tv_template
,
963 AES_XTS_DEC_TEST_VECTORS
);
966 test_cipher("ecb(cast5)", ENCRYPT
, cast5_enc_tv_template
,
967 CAST5_ENC_TEST_VECTORS
);
968 test_cipher("ecb(cast5)", DECRYPT
, cast5_dec_tv_template
,
969 CAST5_DEC_TEST_VECTORS
);
972 test_cipher("ecb(cast6)", ENCRYPT
, cast6_enc_tv_template
,
973 CAST6_ENC_TEST_VECTORS
);
974 test_cipher("ecb(cast6)", DECRYPT
, cast6_dec_tv_template
,
975 CAST6_DEC_TEST_VECTORS
);
978 test_cipher("ecb(arc4)", ENCRYPT
, arc4_enc_tv_template
,
979 ARC4_ENC_TEST_VECTORS
);
980 test_cipher("ecb(arc4)", DECRYPT
, arc4_dec_tv_template
,
981 ARC4_DEC_TEST_VECTORS
);
984 test_cipher("ecb(tea)", ENCRYPT
, tea_enc_tv_template
,
985 TEA_ENC_TEST_VECTORS
);
986 test_cipher("ecb(tea)", DECRYPT
, tea_dec_tv_template
,
987 TEA_DEC_TEST_VECTORS
);
991 test_cipher("ecb(xtea)", ENCRYPT
, xtea_enc_tv_template
,
992 XTEA_ENC_TEST_VECTORS
);
993 test_cipher("ecb(xtea)", DECRYPT
, xtea_dec_tv_template
,
994 XTEA_DEC_TEST_VECTORS
);
997 test_cipher("ecb(khazad)", ENCRYPT
, khazad_enc_tv_template
,
998 KHAZAD_ENC_TEST_VECTORS
);
999 test_cipher("ecb(khazad)", DECRYPT
, khazad_dec_tv_template
,
1000 KHAZAD_DEC_TEST_VECTORS
);
1003 test_cipher("ecb(anubis)", ENCRYPT
, anubis_enc_tv_template
,
1004 ANUBIS_ENC_TEST_VECTORS
);
1005 test_cipher("ecb(anubis)", DECRYPT
, anubis_dec_tv_template
,
1006 ANUBIS_DEC_TEST_VECTORS
);
1007 test_cipher("cbc(anubis)", ENCRYPT
, anubis_cbc_enc_tv_template
,
1008 ANUBIS_CBC_ENC_TEST_VECTORS
);
1009 test_cipher("cbc(anubis)", DECRYPT
, anubis_cbc_dec_tv_template
,
1010 ANUBIS_CBC_ENC_TEST_VECTORS
);
1013 test_cipher("ecb(xeta)", ENCRYPT
, xeta_enc_tv_template
,
1014 XETA_ENC_TEST_VECTORS
);
1015 test_cipher("ecb(xeta)", DECRYPT
, xeta_dec_tv_template
,
1016 XETA_DEC_TEST_VECTORS
);
1019 test_cipher("pcbc(fcrypt)", ENCRYPT
, fcrypt_pcbc_enc_tv_template
,
1020 FCRYPT_ENC_TEST_VECTORS
);
1021 test_cipher("pcbc(fcrypt)", DECRYPT
, fcrypt_pcbc_dec_tv_template
,
1022 FCRYPT_DEC_TEST_VECTORS
);
1025 test_cipher("ecb(camellia)", ENCRYPT
,
1026 camellia_enc_tv_template
,
1027 CAMELLIA_ENC_TEST_VECTORS
);
1028 test_cipher("ecb(camellia)", DECRYPT
,
1029 camellia_dec_tv_template
,
1030 CAMELLIA_DEC_TEST_VECTORS
);
1031 test_cipher("cbc(camellia)", ENCRYPT
,
1032 camellia_cbc_enc_tv_template
,
1033 CAMELLIA_CBC_ENC_TEST_VECTORS
);
1034 test_cipher("cbc(camellia)", DECRYPT
,
1035 camellia_cbc_dec_tv_template
,
1036 CAMELLIA_CBC_DEC_TEST_VECTORS
);
1039 test_cipher("ecb(seed)", ENCRYPT
, seed_enc_tv_template
,
1040 SEED_ENC_TEST_VECTORS
);
1041 test_cipher("ecb(seed)", DECRYPT
, seed_dec_tv_template
,
1042 SEED_DEC_TEST_VECTORS
);
1044 test_hash("sha384", sha384_tv_template
, SHA384_TEST_VECTORS
);
1045 test_hash("sha512", sha512_tv_template
, SHA512_TEST_VECTORS
);
1046 test_hash("wp512", wp512_tv_template
, WP512_TEST_VECTORS
);
1047 test_hash("wp384", wp384_tv_template
, WP384_TEST_VECTORS
);
1048 test_hash("wp256", wp256_tv_template
, WP256_TEST_VECTORS
);
1049 test_hash("tgr192", tgr192_tv_template
, TGR192_TEST_VECTORS
);
1050 test_hash("tgr160", tgr160_tv_template
, TGR160_TEST_VECTORS
);
1051 test_hash("tgr128", tgr128_tv_template
, TGR128_TEST_VECTORS
);
1053 test_hash("crc32c", crc32c_tv_template
, CRC32C_TEST_VECTORS
);
1054 test_hash("hmac(md5)", hmac_md5_tv_template
,
1055 HMAC_MD5_TEST_VECTORS
);
1056 test_hash("hmac(sha1)", hmac_sha1_tv_template
,
1057 HMAC_SHA1_TEST_VECTORS
);
1058 test_hash("hmac(sha256)", hmac_sha256_tv_template
,
1059 HMAC_SHA256_TEST_VECTORS
);
1060 test_hash("hmac(sha384)", hmac_sha384_tv_template
,
1061 HMAC_SHA384_TEST_VECTORS
);
1062 test_hash("hmac(sha512)", hmac_sha512_tv_template
,
1063 HMAC_SHA512_TEST_VECTORS
);
1065 test_hash("xcbc(aes)", aes_xcbc128_tv_template
,
1066 XCBC_AES_TEST_VECTORS
);
1068 test_hash("michael_mic", michael_mic_tv_template
, MICHAEL_MIC_TEST_VECTORS
);
1072 test_hash("md5", md5_tv_template
, MD5_TEST_VECTORS
);
1076 test_hash("sha1", sha1_tv_template
, SHA1_TEST_VECTORS
);
1080 test_cipher("ecb(des)", ENCRYPT
, des_enc_tv_template
,
1081 DES_ENC_TEST_VECTORS
);
1082 test_cipher("ecb(des)", DECRYPT
, des_dec_tv_template
,
1083 DES_DEC_TEST_VECTORS
);
1084 test_cipher("cbc(des)", ENCRYPT
, des_cbc_enc_tv_template
,
1085 DES_CBC_ENC_TEST_VECTORS
);
1086 test_cipher("cbc(des)", DECRYPT
, des_cbc_dec_tv_template
,
1087 DES_CBC_DEC_TEST_VECTORS
);
1091 test_cipher("ecb(des3_ede)", ENCRYPT
, des3_ede_enc_tv_template
,
1092 DES3_EDE_ENC_TEST_VECTORS
);
1093 test_cipher("ecb(des3_ede)", DECRYPT
, des3_ede_dec_tv_template
,
1094 DES3_EDE_DEC_TEST_VECTORS
);
1098 test_hash("md4", md4_tv_template
, MD4_TEST_VECTORS
);
1102 test_hash("sha256", sha256_tv_template
, SHA256_TEST_VECTORS
);
1106 test_cipher("ecb(blowfish)", ENCRYPT
, bf_enc_tv_template
,
1107 BF_ENC_TEST_VECTORS
);
1108 test_cipher("ecb(blowfish)", DECRYPT
, bf_dec_tv_template
,
1109 BF_DEC_TEST_VECTORS
);
1110 test_cipher("cbc(blowfish)", ENCRYPT
, bf_cbc_enc_tv_template
,
1111 BF_CBC_ENC_TEST_VECTORS
);
1112 test_cipher("cbc(blowfish)", DECRYPT
, bf_cbc_dec_tv_template
,
1113 BF_CBC_DEC_TEST_VECTORS
);
1117 test_cipher("ecb(twofish)", ENCRYPT
, tf_enc_tv_template
,
1118 TF_ENC_TEST_VECTORS
);
1119 test_cipher("ecb(twofish)", DECRYPT
, tf_dec_tv_template
,
1120 TF_DEC_TEST_VECTORS
);
1121 test_cipher("cbc(twofish)", ENCRYPT
, tf_cbc_enc_tv_template
,
1122 TF_CBC_ENC_TEST_VECTORS
);
1123 test_cipher("cbc(twofish)", DECRYPT
, tf_cbc_dec_tv_template
,
1124 TF_CBC_DEC_TEST_VECTORS
);
1128 test_cipher("ecb(serpent)", ENCRYPT
, serpent_enc_tv_template
,
1129 SERPENT_ENC_TEST_VECTORS
);
1130 test_cipher("ecb(serpent)", DECRYPT
, serpent_dec_tv_template
,
1131 SERPENT_DEC_TEST_VECTORS
);
1135 test_cipher("ecb(aes)", ENCRYPT
, aes_enc_tv_template
,
1136 AES_ENC_TEST_VECTORS
);
1137 test_cipher("ecb(aes)", DECRYPT
, aes_dec_tv_template
,
1138 AES_DEC_TEST_VECTORS
);
1139 test_cipher("cbc(aes)", ENCRYPT
, aes_cbc_enc_tv_template
,
1140 AES_CBC_ENC_TEST_VECTORS
);
1141 test_cipher("cbc(aes)", DECRYPT
, aes_cbc_dec_tv_template
,
1142 AES_CBC_DEC_TEST_VECTORS
);
1143 test_cipher("lrw(aes)", ENCRYPT
, aes_lrw_enc_tv_template
,
1144 AES_LRW_ENC_TEST_VECTORS
);
1145 test_cipher("lrw(aes)", DECRYPT
, aes_lrw_dec_tv_template
,
1146 AES_LRW_DEC_TEST_VECTORS
);
1147 test_cipher("xts(aes)", ENCRYPT
, aes_xts_enc_tv_template
,
1148 AES_XTS_ENC_TEST_VECTORS
);
1149 test_cipher("xts(aes)", DECRYPT
, aes_xts_dec_tv_template
,
1150 AES_XTS_DEC_TEST_VECTORS
);
1154 test_hash("sha384", sha384_tv_template
, SHA384_TEST_VECTORS
);
1158 test_hash("sha512", sha512_tv_template
, SHA512_TEST_VECTORS
);
1166 test_cipher("ecb(cast5)", ENCRYPT
, cast5_enc_tv_template
,
1167 CAST5_ENC_TEST_VECTORS
);
1168 test_cipher("ecb(cast5)", DECRYPT
, cast5_dec_tv_template
,
1169 CAST5_DEC_TEST_VECTORS
);
1173 test_cipher("ecb(cast6)", ENCRYPT
, cast6_enc_tv_template
,
1174 CAST6_ENC_TEST_VECTORS
);
1175 test_cipher("ecb(cast6)", DECRYPT
, cast6_dec_tv_template
,
1176 CAST6_DEC_TEST_VECTORS
);
1180 test_cipher("ecb(arc4)", ENCRYPT
, arc4_enc_tv_template
,
1181 ARC4_ENC_TEST_VECTORS
);
1182 test_cipher("ecb(arc4)", DECRYPT
, arc4_dec_tv_template
,
1183 ARC4_DEC_TEST_VECTORS
);
1187 test_hash("michael_mic", michael_mic_tv_template
, MICHAEL_MIC_TEST_VECTORS
);
1191 test_hash("crc32c", crc32c_tv_template
, CRC32C_TEST_VECTORS
);
1195 test_cipher("ecb(tea)", ENCRYPT
, tea_enc_tv_template
,
1196 TEA_ENC_TEST_VECTORS
);
1197 test_cipher("ecb(tea)", DECRYPT
, tea_dec_tv_template
,
1198 TEA_DEC_TEST_VECTORS
);
1202 test_cipher("ecb(xtea)", ENCRYPT
, xtea_enc_tv_template
,
1203 XTEA_ENC_TEST_VECTORS
);
1204 test_cipher("ecb(xtea)", DECRYPT
, xtea_dec_tv_template
,
1205 XTEA_DEC_TEST_VECTORS
);
1209 test_cipher("ecb(khazad)", ENCRYPT
, khazad_enc_tv_template
,
1210 KHAZAD_ENC_TEST_VECTORS
);
1211 test_cipher("ecb(khazad)", DECRYPT
, khazad_dec_tv_template
,
1212 KHAZAD_DEC_TEST_VECTORS
);
1216 test_hash("wp512", wp512_tv_template
, WP512_TEST_VECTORS
);
1220 test_hash("wp384", wp384_tv_template
, WP384_TEST_VECTORS
);
1224 test_hash("wp256", wp256_tv_template
, WP256_TEST_VECTORS
);
1228 test_cipher("ecb(tnepres)", ENCRYPT
, tnepres_enc_tv_template
,
1229 TNEPRES_ENC_TEST_VECTORS
);
1230 test_cipher("ecb(tnepres)", DECRYPT
, tnepres_dec_tv_template
,
1231 TNEPRES_DEC_TEST_VECTORS
);
1235 test_cipher("ecb(anubis)", ENCRYPT
, anubis_enc_tv_template
,
1236 ANUBIS_ENC_TEST_VECTORS
);
1237 test_cipher("ecb(anubis)", DECRYPT
, anubis_dec_tv_template
,
1238 ANUBIS_DEC_TEST_VECTORS
);
1239 test_cipher("cbc(anubis)", ENCRYPT
, anubis_cbc_enc_tv_template
,
1240 ANUBIS_CBC_ENC_TEST_VECTORS
);
1241 test_cipher("cbc(anubis)", DECRYPT
, anubis_cbc_dec_tv_template
,
1242 ANUBIS_CBC_ENC_TEST_VECTORS
);
1246 test_hash("tgr192", tgr192_tv_template
, TGR192_TEST_VECTORS
);
1251 test_hash("tgr160", tgr160_tv_template
, TGR160_TEST_VECTORS
);
1255 test_hash("tgr128", tgr128_tv_template
, TGR128_TEST_VECTORS
);
1259 test_cipher("ecb(xeta)", ENCRYPT
, xeta_enc_tv_template
,
1260 XETA_ENC_TEST_VECTORS
);
1261 test_cipher("ecb(xeta)", DECRYPT
, xeta_dec_tv_template
,
1262 XETA_DEC_TEST_VECTORS
);
1266 test_cipher("pcbc(fcrypt)", ENCRYPT
, fcrypt_pcbc_enc_tv_template
,
1267 FCRYPT_ENC_TEST_VECTORS
);
1268 test_cipher("pcbc(fcrypt)", DECRYPT
, fcrypt_pcbc_dec_tv_template
,
1269 FCRYPT_DEC_TEST_VECTORS
);
1273 test_cipher("ecb(camellia)", ENCRYPT
,
1274 camellia_enc_tv_template
,
1275 CAMELLIA_ENC_TEST_VECTORS
);
1276 test_cipher("ecb(camellia)", DECRYPT
,
1277 camellia_dec_tv_template
,
1278 CAMELLIA_DEC_TEST_VECTORS
);
1279 test_cipher("cbc(camellia)", ENCRYPT
,
1280 camellia_cbc_enc_tv_template
,
1281 CAMELLIA_CBC_ENC_TEST_VECTORS
);
1282 test_cipher("cbc(camellia)", DECRYPT
,
1283 camellia_cbc_dec_tv_template
,
1284 CAMELLIA_CBC_DEC_TEST_VECTORS
);
1288 test_hash("hmac(md5)", hmac_md5_tv_template
,
1289 HMAC_MD5_TEST_VECTORS
);
1293 test_hash("hmac(sha1)", hmac_sha1_tv_template
,
1294 HMAC_SHA1_TEST_VECTORS
);
1298 test_hash("hmac(sha256)", hmac_sha256_tv_template
,
1299 HMAC_SHA256_TEST_VECTORS
);
1303 test_hash("hmac(sha384)", hmac_sha384_tv_template
,
1304 HMAC_SHA384_TEST_VECTORS
);
1308 test_hash("hmac(sha512)", hmac_sha512_tv_template
,
1309 HMAC_SHA512_TEST_VECTORS
);
1314 test_cipher_speed("ecb(aes)", ENCRYPT
, sec
, NULL
, 0,
1315 aes_speed_template
);
1316 test_cipher_speed("ecb(aes)", DECRYPT
, sec
, NULL
, 0,
1317 aes_speed_template
);
1318 test_cipher_speed("cbc(aes)", ENCRYPT
, sec
, NULL
, 0,
1319 aes_speed_template
);
1320 test_cipher_speed("cbc(aes)", DECRYPT
, sec
, NULL
, 0,
1321 aes_speed_template
);
1322 test_cipher_speed("lrw(aes)", ENCRYPT
, sec
, NULL
, 0,
1323 aes_lrw_speed_template
);
1324 test_cipher_speed("lrw(aes)", DECRYPT
, sec
, NULL
, 0,
1325 aes_lrw_speed_template
);
1326 test_cipher_speed("xts(aes)", ENCRYPT
, sec
, NULL
, 0,
1327 aes_xts_speed_template
);
1328 test_cipher_speed("xts(aes)", DECRYPT
, sec
, NULL
, 0,
1329 aes_xts_speed_template
);
1333 test_cipher_speed("ecb(des3_ede)", ENCRYPT
, sec
,
1334 des3_ede_enc_tv_template
,
1335 DES3_EDE_ENC_TEST_VECTORS
,
1336 des3_ede_speed_template
);
1337 test_cipher_speed("ecb(des3_ede)", DECRYPT
, sec
,
1338 des3_ede_dec_tv_template
,
1339 DES3_EDE_DEC_TEST_VECTORS
,
1340 des3_ede_speed_template
);
1341 test_cipher_speed("cbc(des3_ede)", ENCRYPT
, sec
,
1342 des3_ede_enc_tv_template
,
1343 DES3_EDE_ENC_TEST_VECTORS
,
1344 des3_ede_speed_template
);
1345 test_cipher_speed("cbc(des3_ede)", DECRYPT
, sec
,
1346 des3_ede_dec_tv_template
,
1347 DES3_EDE_DEC_TEST_VECTORS
,
1348 des3_ede_speed_template
);
1352 test_cipher_speed("ecb(twofish)", ENCRYPT
, sec
, NULL
, 0,
1353 twofish_speed_template
);
1354 test_cipher_speed("ecb(twofish)", DECRYPT
, sec
, NULL
, 0,
1355 twofish_speed_template
);
1356 test_cipher_speed("cbc(twofish)", ENCRYPT
, sec
, NULL
, 0,
1357 twofish_speed_template
);
1358 test_cipher_speed("cbc(twofish)", DECRYPT
, sec
, NULL
, 0,
1359 twofish_speed_template
);
1363 test_cipher_speed("ecb(blowfish)", ENCRYPT
, sec
, NULL
, 0,
1364 blowfish_speed_template
);
1365 test_cipher_speed("ecb(blowfish)", DECRYPT
, sec
, NULL
, 0,
1366 blowfish_speed_template
);
1367 test_cipher_speed("cbc(blowfish)", ENCRYPT
, sec
, NULL
, 0,
1368 blowfish_speed_template
);
1369 test_cipher_speed("cbc(blowfish)", DECRYPT
, sec
, NULL
, 0,
1370 blowfish_speed_template
);
1374 test_cipher_speed("ecb(des)", ENCRYPT
, sec
, NULL
, 0,
1375 des_speed_template
);
1376 test_cipher_speed("ecb(des)", DECRYPT
, sec
, NULL
, 0,
1377 des_speed_template
);
1378 test_cipher_speed("cbc(des)", ENCRYPT
, sec
, NULL
, 0,
1379 des_speed_template
);
1380 test_cipher_speed("cbc(des)", DECRYPT
, sec
, NULL
, 0,
1381 des_speed_template
);
1385 test_cipher_speed("ecb(camellia)", ENCRYPT
, sec
, NULL
, 0,
1386 camellia_speed_template
);
1387 test_cipher_speed("ecb(camellia)", DECRYPT
, sec
, NULL
, 0,
1388 camellia_speed_template
);
1389 test_cipher_speed("cbc(camellia)", ENCRYPT
, sec
, NULL
, 0,
1390 camellia_speed_template
);
1391 test_cipher_speed("cbc(camellia)", DECRYPT
, sec
, NULL
, 0,
1392 camellia_speed_template
);
1399 test_hash_speed("md4", sec
, generic_hash_speed_template
);
1400 if (mode
> 300 && mode
< 400) break;
1403 test_hash_speed("md5", sec
, generic_hash_speed_template
);
1404 if (mode
> 300 && mode
< 400) break;
1407 test_hash_speed("sha1", sec
, generic_hash_speed_template
);
1408 if (mode
> 300 && mode
< 400) break;
1411 test_hash_speed("sha256", sec
, generic_hash_speed_template
);
1412 if (mode
> 300 && mode
< 400) break;
1415 test_hash_speed("sha384", sec
, generic_hash_speed_template
);
1416 if (mode
> 300 && mode
< 400) break;
1419 test_hash_speed("sha512", sec
, generic_hash_speed_template
);
1420 if (mode
> 300 && mode
< 400) break;
1423 test_hash_speed("wp256", sec
, generic_hash_speed_template
);
1424 if (mode
> 300 && mode
< 400) break;
1427 test_hash_speed("wp384", sec
, generic_hash_speed_template
);
1428 if (mode
> 300 && mode
< 400) break;
1431 test_hash_speed("wp512", sec
, generic_hash_speed_template
);
1432 if (mode
> 300 && mode
< 400) break;
1435 test_hash_speed("tgr128", sec
, generic_hash_speed_template
);
1436 if (mode
> 300 && mode
< 400) break;
1439 test_hash_speed("tgr160", sec
, generic_hash_speed_template
);
1440 if (mode
> 300 && mode
< 400) break;
1443 test_hash_speed("tgr192", sec
, generic_hash_speed_template
);
1444 if (mode
> 300 && mode
< 400) break;
1454 /* useful for debugging */
1455 printk("not testing anything\n");
1460 static int __init
init(void)
1462 tvmem
= kmalloc(TVMEMSIZE
, GFP_KERNEL
);
1466 xbuf
= kmalloc(XBUFSIZE
, GFP_KERNEL
);
1477 /* We intentionaly return -EAGAIN to prevent keeping
1478 * the module. It does all its work from init()
1479 * and doesn't offer any runtime functionality
1480 * => we don't need it in the memory, do we?
1487 * If an init function is provided, an exit function must also be provided
1488 * to allow module unload.
1490 static void __exit
fini(void) { }
1495 module_param(mode
, int, 0);
1496 module_param(sec
, uint
, 0);
1497 MODULE_PARM_DESC(sec
, "Length in seconds of speed tests "
1498 "(defaults to zero which uses CPU cycles instead)");
1500 MODULE_LICENSE("GPL");
1501 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
1502 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");