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 * 2004-08-09 Added cipher speed tests (Reyk Floeter <reyk@vantronix.net>)
16 * 2003-09-14 Rewritten by Kartikey Mahendra Bhatt
20 #include <linux/init.h>
21 #include <linux/module.h>
23 #include <linux/slab.h>
24 #include <linux/scatterlist.h>
25 #include <linux/string.h>
26 #include <linux/crypto.h>
27 #include <linux/highmem.h>
28 #include <linux/moduleparam.h>
29 #include <linux/jiffies.h>
30 #include <linux/timex.h>
31 #include <linux/interrupt.h>
35 * Need to kmalloc() memory for testing kmap().
37 #define TVMEMSIZE 16384
38 #define XBUFSIZE 32768
41 * Indexes into the xbuf to simulate cross-page access.
53 * Used by test_cipher()
60 static unsigned int IDX
[8] = { IDX1
, IDX2
, IDX3
, IDX4
, IDX5
, IDX6
, IDX7
, IDX8
};
63 * Used by test_cipher_speed()
65 static unsigned int sec
;
71 static char *check
[] = {
72 "des", "md5", "des3_ede", "rot13", "sha1", "sha256", "blowfish",
73 "twofish", "serpent", "sha384", "sha512", "md4", "aes", "cast6",
74 "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
75 "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", NULL
78 static void hexdump(unsigned char *buf
, unsigned int len
)
81 printk("%02x", *buf
++);
86 static void test_hash(char *algo
, struct hash_testvec
*template,
89 unsigned int i
, j
, k
, temp
;
90 struct scatterlist sg
[8];
92 struct crypto_tfm
*tfm
;
93 struct hash_testvec
*hash_tv
;
96 printk("\ntesting %s\n", algo
);
98 tsize
= sizeof(struct hash_testvec
);
101 if (tsize
> TVMEMSIZE
) {
102 printk("template (%u) too big for tvmem (%u)\n", tsize
, TVMEMSIZE
);
106 memcpy(tvmem
, template, tsize
);
107 hash_tv
= (void *)tvmem
;
108 tfm
= crypto_alloc_tfm(algo
, 0);
110 printk("failed to load transform for %s\n", algo
);
114 for (i
= 0; i
< tcount
; i
++) {
115 printk("test %u:\n", i
+ 1);
116 memset(result
, 0, 64);
118 sg_set_buf(&sg
[0], hash_tv
[i
].plaintext
, hash_tv
[i
].psize
);
120 crypto_digest_init(tfm
);
121 crypto_digest_setkey(tfm
, hash_tv
[i
].key
, hash_tv
[i
].ksize
);
122 crypto_digest_update(tfm
, sg
, 1);
123 crypto_digest_final(tfm
, result
);
125 hexdump(result
, crypto_tfm_alg_digestsize(tfm
));
127 memcmp(result
, hash_tv
[i
].digest
,
128 crypto_tfm_alg_digestsize(tfm
)) ?
132 printk("testing %s across pages\n", algo
);
134 /* setup the dummy buffer first */
135 memset(xbuf
, 0, XBUFSIZE
);
138 for (i
= 0; i
< tcount
; i
++) {
141 printk("test %u:\n", j
);
142 memset(result
, 0, 64);
145 for (k
= 0; k
< hash_tv
[i
].np
; k
++) {
146 memcpy(&xbuf
[IDX
[k
]],
147 hash_tv
[i
].plaintext
+ temp
,
149 temp
+= hash_tv
[i
].tap
[k
];
150 sg_set_buf(&sg
[k
], &xbuf
[IDX
[k
]],
154 crypto_digest_digest(tfm
, sg
, hash_tv
[i
].np
, result
);
156 hexdump(result
, crypto_tfm_alg_digestsize(tfm
));
158 memcmp(result
, hash_tv
[i
].digest
,
159 crypto_tfm_alg_digestsize(tfm
)) ?
164 crypto_free_tfm(tfm
);
168 #ifdef CONFIG_CRYPTO_HMAC
170 static void test_hmac(char *algo
, struct hmac_testvec
*template,
173 unsigned int i
, j
, k
, temp
;
174 struct scatterlist sg
[8];
176 struct crypto_tfm
*tfm
;
177 struct hmac_testvec
*hmac_tv
;
178 unsigned int tsize
, klen
;
180 tfm
= crypto_alloc_tfm(algo
, 0);
182 printk("failed to load transform for %s\n", algo
);
186 printk("\ntesting hmac_%s\n", algo
);
188 tsize
= sizeof(struct hmac_testvec
);
190 if (tsize
> TVMEMSIZE
) {
191 printk("template (%u) too big for tvmem (%u)\n", tsize
,
196 memcpy(tvmem
, template, tsize
);
197 hmac_tv
= (void *)tvmem
;
199 for (i
= 0; i
< tcount
; i
++) {
200 printk("test %u:\n", i
+ 1);
201 memset(result
, 0, sizeof (result
));
203 klen
= hmac_tv
[i
].ksize
;
204 sg_set_buf(&sg
[0], hmac_tv
[i
].plaintext
, hmac_tv
[i
].psize
);
206 crypto_hmac(tfm
, hmac_tv
[i
].key
, &klen
, sg
, 1, result
);
208 hexdump(result
, crypto_tfm_alg_digestsize(tfm
));
210 memcmp(result
, hmac_tv
[i
].digest
,
211 crypto_tfm_alg_digestsize(tfm
)) ? "fail" :
215 printk("\ntesting hmac_%s across pages\n", algo
);
217 memset(xbuf
, 0, XBUFSIZE
);
220 for (i
= 0; i
< tcount
; i
++) {
223 printk("test %u:\n",j
);
224 memset(result
, 0, 64);
227 klen
= hmac_tv
[i
].ksize
;
228 for (k
= 0; k
< hmac_tv
[i
].np
; k
++) {
229 memcpy(&xbuf
[IDX
[k
]],
230 hmac_tv
[i
].plaintext
+ temp
,
232 temp
+= hmac_tv
[i
].tap
[k
];
233 sg_set_buf(&sg
[k
], &xbuf
[IDX
[k
]],
237 crypto_hmac(tfm
, hmac_tv
[i
].key
, &klen
, sg
,
238 hmac_tv
[i
].np
, result
);
239 hexdump(result
, crypto_tfm_alg_digestsize(tfm
));
242 memcmp(result
, hmac_tv
[i
].digest
,
243 crypto_tfm_alg_digestsize(tfm
)) ?
248 crypto_free_tfm(tfm
);
251 #endif /* CONFIG_CRYPTO_HMAC */
253 static void test_cipher(char *algo
, int mode
, int enc
,
254 struct cipher_testvec
*template, unsigned int tcount
)
256 unsigned int ret
, i
, j
, k
, temp
;
259 struct crypto_tfm
*tfm
;
261 struct cipher_testvec
*cipher_tv
;
262 struct scatterlist sg
[8];
269 if (mode
== MODE_ECB
)
274 printk("\ntesting %s %s %s\n", algo
, m
, e
);
276 tsize
= sizeof (struct cipher_testvec
);
279 if (tsize
> TVMEMSIZE
) {
280 printk("template (%u) too big for tvmem (%u)\n", tsize
,
285 memcpy(tvmem
, template, tsize
);
286 cipher_tv
= (void *)tvmem
;
289 tfm
= crypto_alloc_tfm(algo
, 0);
291 tfm
= crypto_alloc_tfm(algo
, CRYPTO_TFM_MODE_CBC
);
294 printk("failed to load transform for %s %s\n", algo
, m
);
299 for (i
= 0; i
< tcount
; i
++) {
300 if (!(cipher_tv
[i
].np
)) {
302 printk("test %u (%d bit key):\n",
303 j
, cipher_tv
[i
].klen
* 8);
307 tfm
->crt_flags
|= CRYPTO_TFM_REQ_WEAK_KEY
;
308 key
= cipher_tv
[i
].key
;
310 ret
= crypto_cipher_setkey(tfm
, key
, cipher_tv
[i
].klen
);
312 printk("setkey() failed flags=%x\n", tfm
->crt_flags
);
314 if (!cipher_tv
[i
].fail
)
318 sg_set_buf(&sg
[0], cipher_tv
[i
].input
,
322 crypto_cipher_set_iv(tfm
, cipher_tv
[i
].iv
,
323 crypto_tfm_alg_ivsize(tfm
));
327 ret
= crypto_cipher_encrypt(tfm
, sg
, sg
, cipher_tv
[i
].ilen
);
329 ret
= crypto_cipher_decrypt(tfm
, sg
, sg
, cipher_tv
[i
].ilen
);
333 printk("%s () failed flags=%x\n", e
, tfm
->crt_flags
);
337 q
= kmap(sg
[0].page
) + sg
[0].offset
;
338 hexdump(q
, cipher_tv
[i
].rlen
);
341 memcmp(q
, cipher_tv
[i
].result
,
342 cipher_tv
[i
].rlen
) ? "fail" : "pass");
346 printk("\ntesting %s %s %s across pages (chunking)\n", algo
, m
, e
);
347 memset(xbuf
, 0, XBUFSIZE
);
350 for (i
= 0; i
< tcount
; i
++) {
351 if (cipher_tv
[i
].np
) {
353 printk("test %u (%d bit key):\n",
354 j
, cipher_tv
[i
].klen
* 8);
358 tfm
->crt_flags
|= CRYPTO_TFM_REQ_WEAK_KEY
;
359 key
= cipher_tv
[i
].key
;
361 ret
= crypto_cipher_setkey(tfm
, key
, cipher_tv
[i
].klen
);
363 printk("setkey() failed flags=%x\n", tfm
->crt_flags
);
365 if (!cipher_tv
[i
].fail
)
370 for (k
= 0; k
< cipher_tv
[i
].np
; k
++) {
371 memcpy(&xbuf
[IDX
[k
]],
372 cipher_tv
[i
].input
+ temp
,
373 cipher_tv
[i
].tap
[k
]);
374 temp
+= cipher_tv
[i
].tap
[k
];
375 sg_set_buf(&sg
[k
], &xbuf
[IDX
[k
]],
376 cipher_tv
[i
].tap
[k
]);
380 crypto_cipher_set_iv(tfm
, cipher_tv
[i
].iv
,
381 crypto_tfm_alg_ivsize(tfm
));
385 ret
= crypto_cipher_encrypt(tfm
, sg
, sg
, cipher_tv
[i
].ilen
);
387 ret
= crypto_cipher_decrypt(tfm
, sg
, sg
, cipher_tv
[i
].ilen
);
390 printk("%s () failed flags=%x\n", e
, tfm
->crt_flags
);
395 for (k
= 0; k
< cipher_tv
[i
].np
; k
++) {
396 printk("page %u\n", k
);
397 q
= kmap(sg
[k
].page
) + sg
[k
].offset
;
398 hexdump(q
, cipher_tv
[i
].tap
[k
]);
400 memcmp(q
, cipher_tv
[i
].result
+ temp
,
401 cipher_tv
[i
].tap
[k
]) ? "fail" :
403 temp
+= cipher_tv
[i
].tap
[k
];
409 crypto_free_tfm(tfm
);
412 static int test_cipher_jiffies(struct crypto_tfm
*tfm
, int enc
, char *p
,
415 struct scatterlist sg
[1];
416 unsigned long start
, end
;
420 sg_set_buf(sg
, p
, blen
);
422 for (start
= jiffies
, end
= start
+ sec
* HZ
, bcount
= 0;
423 time_before(jiffies
, end
); bcount
++) {
425 ret
= crypto_cipher_encrypt(tfm
, sg
, sg
, blen
);
427 ret
= crypto_cipher_decrypt(tfm
, sg
, sg
, blen
);
433 printk("%d operations in %d seconds (%ld bytes)\n",
434 bcount
, sec
, (long)bcount
* blen
);
438 static int test_cipher_cycles(struct crypto_tfm
*tfm
, int enc
, char *p
,
441 struct scatterlist sg
[1];
442 unsigned long cycles
= 0;
446 sg_set_buf(sg
, p
, blen
);
452 for (i
= 0; i
< 4; i
++) {
454 ret
= crypto_cipher_encrypt(tfm
, sg
, sg
, blen
);
456 ret
= crypto_cipher_decrypt(tfm
, sg
, sg
, blen
);
462 /* The real thing. */
463 for (i
= 0; i
< 8; i
++) {
466 start
= get_cycles();
468 ret
= crypto_cipher_encrypt(tfm
, sg
, sg
, blen
);
470 ret
= crypto_cipher_decrypt(tfm
, sg
, sg
, blen
);
476 cycles
+= end
- start
;
484 printk("1 operation in %lu cycles (%d bytes)\n",
485 (cycles
+ 4) / 8, blen
);
490 static void test_cipher_speed(char *algo
, int mode
, int enc
, unsigned int sec
,
491 struct cipher_testvec
*template,
492 unsigned int tcount
, struct cipher_speed
*speed
)
494 unsigned int ret
, i
, j
, iv_len
;
495 unsigned char *key
, *p
, iv
[128];
496 struct crypto_tfm
*tfm
;
503 if (mode
== MODE_ECB
)
508 printk("\ntesting speed of %s %s %s\n", algo
, m
, e
);
511 tfm
= crypto_alloc_tfm(algo
, 0);
513 tfm
= crypto_alloc_tfm(algo
, CRYPTO_TFM_MODE_CBC
);
516 printk("failed to load transform for %s %s\n", algo
, m
);
520 for (i
= 0; speed
[i
].klen
!= 0; i
++) {
521 if ((speed
[i
].blen
+ speed
[i
].klen
) > TVMEMSIZE
) {
522 printk("template (%u) too big for tvmem (%u)\n",
523 speed
[i
].blen
+ speed
[i
].klen
, TVMEMSIZE
);
527 printk("test %u (%d bit key, %d byte blocks): ", i
,
528 speed
[i
].klen
* 8, speed
[i
].blen
);
530 memset(tvmem
, 0xff, speed
[i
].klen
+ speed
[i
].blen
);
532 /* set key, plain text and IV */
533 key
= (unsigned char *)tvmem
;
534 for (j
= 0; j
< tcount
; j
++) {
535 if (template[j
].klen
== speed
[i
].klen
) {
536 key
= template[j
].key
;
540 p
= (unsigned char *)tvmem
+ speed
[i
].klen
;
542 ret
= crypto_cipher_setkey(tfm
, key
, speed
[i
].klen
);
544 printk("setkey() failed flags=%x\n", tfm
->crt_flags
);
549 iv_len
= crypto_tfm_alg_ivsize(tfm
);
550 memset(&iv
, 0xff, iv_len
);
551 crypto_cipher_set_iv(tfm
, iv
, iv_len
);
555 ret
= test_cipher_jiffies(tfm
, enc
, p
, speed
[i
].blen
,
558 ret
= test_cipher_cycles(tfm
, enc
, p
, speed
[i
].blen
);
561 printk("%s() failed flags=%x\n", e
, tfm
->crt_flags
);
567 crypto_free_tfm(tfm
);
570 static void test_digest_jiffies(struct crypto_tfm
*tfm
, char *p
, int blen
,
571 int plen
, char *out
, int sec
)
573 struct scatterlist sg
[1];
574 unsigned long start
, end
;
577 for (start
= jiffies
, end
= start
+ sec
* HZ
, bcount
= 0;
578 time_before(jiffies
, end
); bcount
++) {
579 crypto_digest_init(tfm
);
580 for (pcount
= 0; pcount
< blen
; pcount
+= plen
) {
581 sg_set_buf(sg
, p
+ pcount
, plen
);
582 crypto_digest_update(tfm
, sg
, 1);
584 /* we assume there is enough space in 'out' for the result */
585 crypto_digest_final(tfm
, out
);
588 printk("%6u opers/sec, %9lu bytes/sec\n",
589 bcount
/ sec
, ((long)bcount
* blen
) / sec
);
594 static void test_digest_cycles(struct crypto_tfm
*tfm
, char *p
, int blen
,
597 struct scatterlist sg
[1];
598 unsigned long cycles
= 0;
605 for (i
= 0; i
< 4; i
++) {
606 crypto_digest_init(tfm
);
607 for (pcount
= 0; pcount
< blen
; pcount
+= plen
) {
608 sg_set_buf(sg
, p
+ pcount
, plen
);
609 crypto_digest_update(tfm
, sg
, 1);
611 crypto_digest_final(tfm
, out
);
614 /* The real thing. */
615 for (i
= 0; i
< 8; i
++) {
618 crypto_digest_init(tfm
);
620 start
= get_cycles();
622 for (pcount
= 0; pcount
< blen
; pcount
+= plen
) {
623 sg_set_buf(sg
, p
+ pcount
, plen
);
624 crypto_digest_update(tfm
, sg
, 1);
626 crypto_digest_final(tfm
, out
);
630 cycles
+= end
- start
;
636 printk("%6lu cycles/operation, %4lu cycles/byte\n",
637 cycles
/ 8, cycles
/ (8 * blen
));
642 static void test_digest_speed(char *algo
, unsigned int sec
,
643 struct digest_speed
*speed
)
645 struct crypto_tfm
*tfm
;
649 printk("\ntesting speed of %s\n", algo
);
651 tfm
= crypto_alloc_tfm(algo
, 0);
654 printk("failed to load transform for %s\n", algo
);
658 if (crypto_tfm_alg_digestsize(tfm
) > sizeof(output
)) {
659 printk("digestsize(%u) > outputbuffer(%zu)\n",
660 crypto_tfm_alg_digestsize(tfm
), sizeof(output
));
664 for (i
= 0; speed
[i
].blen
!= 0; i
++) {
665 if (speed
[i
].blen
> TVMEMSIZE
) {
666 printk("template (%u) too big for tvmem (%u)\n",
667 speed
[i
].blen
, TVMEMSIZE
);
671 printk("test%3u (%5u byte blocks,%5u bytes per update,%4u updates): ",
672 i
, speed
[i
].blen
, speed
[i
].plen
, speed
[i
].blen
/ speed
[i
].plen
);
674 memset(tvmem
, 0xff, speed
[i
].blen
);
677 test_digest_jiffies(tfm
, tvmem
, speed
[i
].blen
, speed
[i
].plen
, output
, sec
);
679 test_digest_cycles(tfm
, tvmem
, speed
[i
].blen
, speed
[i
].plen
, output
);
683 crypto_free_tfm(tfm
);
686 static void test_deflate(void)
689 char result
[COMP_BUF_SIZE
];
690 struct crypto_tfm
*tfm
;
691 struct comp_testvec
*tv
;
694 printk("\ntesting deflate compression\n");
696 tsize
= sizeof (deflate_comp_tv_template
);
697 if (tsize
> TVMEMSIZE
) {
698 printk("template (%u) too big for tvmem (%u)\n", tsize
,
703 memcpy(tvmem
, deflate_comp_tv_template
, tsize
);
706 tfm
= crypto_alloc_tfm("deflate", 0);
708 printk("failed to load transform for deflate\n");
712 for (i
= 0; i
< DEFLATE_COMP_TEST_VECTORS
; i
++) {
713 int ilen
, ret
, dlen
= COMP_BUF_SIZE
;
715 printk("test %u:\n", i
+ 1);
716 memset(result
, 0, sizeof (result
));
719 ret
= crypto_comp_compress(tfm
, tv
[i
].input
,
720 ilen
, result
, &dlen
);
722 printk("fail: ret=%d\n", ret
);
725 hexdump(result
, dlen
);
726 printk("%s (ratio %d:%d)\n",
727 memcmp(result
, tv
[i
].output
, dlen
) ? "fail" : "pass",
731 printk("\ntesting deflate decompression\n");
733 tsize
= sizeof (deflate_decomp_tv_template
);
734 if (tsize
> TVMEMSIZE
) {
735 printk("template (%u) too big for tvmem (%u)\n", tsize
,
740 memcpy(tvmem
, deflate_decomp_tv_template
, tsize
);
743 for (i
= 0; i
< DEFLATE_DECOMP_TEST_VECTORS
; i
++) {
744 int ilen
, ret
, dlen
= COMP_BUF_SIZE
;
746 printk("test %u:\n", i
+ 1);
747 memset(result
, 0, sizeof (result
));
750 ret
= crypto_comp_decompress(tfm
, tv
[i
].input
,
751 ilen
, result
, &dlen
);
753 printk("fail: ret=%d\n", ret
);
756 hexdump(result
, dlen
);
757 printk("%s (ratio %d:%d)\n",
758 memcmp(result
, tv
[i
].output
, dlen
) ? "fail" : "pass",
762 crypto_free_tfm(tfm
);
765 static void test_available(void)
770 printk("alg %s ", *name
);
771 printk((crypto_alg_available(*name
, 0)) ?
772 "found\n" : "not found\n");
777 static void do_test(void)
782 test_hash("md5", md5_tv_template
, MD5_TEST_VECTORS
);
784 test_hash("sha1", sha1_tv_template
, SHA1_TEST_VECTORS
);
787 test_cipher ("des", MODE_ECB
, ENCRYPT
, des_enc_tv_template
, DES_ENC_TEST_VECTORS
);
788 test_cipher ("des", MODE_ECB
, DECRYPT
, des_dec_tv_template
, DES_DEC_TEST_VECTORS
);
789 test_cipher ("des", MODE_CBC
, ENCRYPT
, des_cbc_enc_tv_template
, DES_CBC_ENC_TEST_VECTORS
);
790 test_cipher ("des", MODE_CBC
, DECRYPT
, des_cbc_dec_tv_template
, DES_CBC_DEC_TEST_VECTORS
);
793 test_cipher ("des3_ede", MODE_ECB
, ENCRYPT
, des3_ede_enc_tv_template
, DES3_EDE_ENC_TEST_VECTORS
);
794 test_cipher ("des3_ede", MODE_ECB
, DECRYPT
, des3_ede_dec_tv_template
, DES3_EDE_DEC_TEST_VECTORS
);
796 test_hash("md4", md4_tv_template
, MD4_TEST_VECTORS
);
798 test_hash("sha256", sha256_tv_template
, SHA256_TEST_VECTORS
);
801 test_cipher ("blowfish", MODE_ECB
, ENCRYPT
, bf_enc_tv_template
, BF_ENC_TEST_VECTORS
);
802 test_cipher ("blowfish", MODE_ECB
, DECRYPT
, bf_dec_tv_template
, BF_DEC_TEST_VECTORS
);
803 test_cipher ("blowfish", MODE_CBC
, ENCRYPT
, bf_cbc_enc_tv_template
, BF_CBC_ENC_TEST_VECTORS
);
804 test_cipher ("blowfish", MODE_CBC
, DECRYPT
, bf_cbc_dec_tv_template
, BF_CBC_DEC_TEST_VECTORS
);
807 test_cipher ("twofish", MODE_ECB
, ENCRYPT
, tf_enc_tv_template
, TF_ENC_TEST_VECTORS
);
808 test_cipher ("twofish", MODE_ECB
, DECRYPT
, tf_dec_tv_template
, TF_DEC_TEST_VECTORS
);
809 test_cipher ("twofish", MODE_CBC
, ENCRYPT
, tf_cbc_enc_tv_template
, TF_CBC_ENC_TEST_VECTORS
);
810 test_cipher ("twofish", MODE_CBC
, DECRYPT
, tf_cbc_dec_tv_template
, TF_CBC_DEC_TEST_VECTORS
);
813 test_cipher ("serpent", MODE_ECB
, ENCRYPT
, serpent_enc_tv_template
, SERPENT_ENC_TEST_VECTORS
);
814 test_cipher ("serpent", MODE_ECB
, DECRYPT
, serpent_dec_tv_template
, SERPENT_DEC_TEST_VECTORS
);
817 test_cipher ("tnepres", MODE_ECB
, ENCRYPT
, tnepres_enc_tv_template
, TNEPRES_ENC_TEST_VECTORS
);
818 test_cipher ("tnepres", MODE_ECB
, DECRYPT
, tnepres_dec_tv_template
, TNEPRES_DEC_TEST_VECTORS
);
821 test_cipher ("aes", MODE_ECB
, ENCRYPT
, aes_enc_tv_template
, AES_ENC_TEST_VECTORS
);
822 test_cipher ("aes", MODE_ECB
, DECRYPT
, aes_dec_tv_template
, AES_DEC_TEST_VECTORS
);
823 test_cipher ("aes", MODE_CBC
, ENCRYPT
, aes_cbc_enc_tv_template
, AES_CBC_ENC_TEST_VECTORS
);
824 test_cipher ("aes", MODE_CBC
, DECRYPT
, aes_cbc_dec_tv_template
, AES_CBC_DEC_TEST_VECTORS
);
827 test_cipher ("cast5", MODE_ECB
, ENCRYPT
, cast5_enc_tv_template
, CAST5_ENC_TEST_VECTORS
);
828 test_cipher ("cast5", MODE_ECB
, DECRYPT
, cast5_dec_tv_template
, CAST5_DEC_TEST_VECTORS
);
831 test_cipher ("cast6", MODE_ECB
, ENCRYPT
, cast6_enc_tv_template
, CAST6_ENC_TEST_VECTORS
);
832 test_cipher ("cast6", MODE_ECB
, DECRYPT
, cast6_dec_tv_template
, CAST6_DEC_TEST_VECTORS
);
835 test_cipher ("arc4", MODE_ECB
, ENCRYPT
, arc4_enc_tv_template
, ARC4_ENC_TEST_VECTORS
);
836 test_cipher ("arc4", MODE_ECB
, DECRYPT
, arc4_dec_tv_template
, ARC4_DEC_TEST_VECTORS
);
839 test_cipher ("tea", MODE_ECB
, ENCRYPT
, tea_enc_tv_template
, TEA_ENC_TEST_VECTORS
);
840 test_cipher ("tea", MODE_ECB
, DECRYPT
, tea_dec_tv_template
, TEA_DEC_TEST_VECTORS
);
844 test_cipher ("xtea", MODE_ECB
, ENCRYPT
, xtea_enc_tv_template
, XTEA_ENC_TEST_VECTORS
);
845 test_cipher ("xtea", MODE_ECB
, DECRYPT
, xtea_dec_tv_template
, XTEA_DEC_TEST_VECTORS
);
848 test_cipher ("khazad", MODE_ECB
, ENCRYPT
, khazad_enc_tv_template
, KHAZAD_ENC_TEST_VECTORS
);
849 test_cipher ("khazad", MODE_ECB
, DECRYPT
, khazad_dec_tv_template
, KHAZAD_DEC_TEST_VECTORS
);
852 test_cipher ("anubis", MODE_ECB
, ENCRYPT
, anubis_enc_tv_template
, ANUBIS_ENC_TEST_VECTORS
);
853 test_cipher ("anubis", MODE_ECB
, DECRYPT
, anubis_dec_tv_template
, ANUBIS_DEC_TEST_VECTORS
);
854 test_cipher ("anubis", MODE_CBC
, ENCRYPT
, anubis_cbc_enc_tv_template
, ANUBIS_CBC_ENC_TEST_VECTORS
);
855 test_cipher ("anubis", MODE_CBC
, DECRYPT
, anubis_cbc_dec_tv_template
, ANUBIS_CBC_ENC_TEST_VECTORS
);
858 test_cipher ("xeta", MODE_ECB
, ENCRYPT
, xeta_enc_tv_template
, XETA_ENC_TEST_VECTORS
);
859 test_cipher ("xeta", MODE_ECB
, DECRYPT
, xeta_dec_tv_template
, XETA_DEC_TEST_VECTORS
);
861 test_hash("sha384", sha384_tv_template
, SHA384_TEST_VECTORS
);
862 test_hash("sha512", sha512_tv_template
, SHA512_TEST_VECTORS
);
863 test_hash("wp512", wp512_tv_template
, WP512_TEST_VECTORS
);
864 test_hash("wp384", wp384_tv_template
, WP384_TEST_VECTORS
);
865 test_hash("wp256", wp256_tv_template
, WP256_TEST_VECTORS
);
866 test_hash("tgr192", tgr192_tv_template
, TGR192_TEST_VECTORS
);
867 test_hash("tgr160", tgr160_tv_template
, TGR160_TEST_VECTORS
);
868 test_hash("tgr128", tgr128_tv_template
, TGR128_TEST_VECTORS
);
870 test_hash("crc32c", crc32c_tv_template
, CRC32C_TEST_VECTORS
);
871 #ifdef CONFIG_CRYPTO_HMAC
872 test_hmac("md5", hmac_md5_tv_template
, HMAC_MD5_TEST_VECTORS
);
873 test_hmac("sha1", hmac_sha1_tv_template
, HMAC_SHA1_TEST_VECTORS
);
874 test_hmac("sha256", hmac_sha256_tv_template
, HMAC_SHA256_TEST_VECTORS
);
877 test_hash("michael_mic", michael_mic_tv_template
, MICHAEL_MIC_TEST_VECTORS
);
881 test_hash("md5", md5_tv_template
, MD5_TEST_VECTORS
);
885 test_hash("sha1", sha1_tv_template
, SHA1_TEST_VECTORS
);
889 test_cipher ("des", MODE_ECB
, ENCRYPT
, des_enc_tv_template
, DES_ENC_TEST_VECTORS
);
890 test_cipher ("des", MODE_ECB
, DECRYPT
, des_dec_tv_template
, DES_DEC_TEST_VECTORS
);
891 test_cipher ("des", MODE_CBC
, ENCRYPT
, des_cbc_enc_tv_template
, DES_CBC_ENC_TEST_VECTORS
);
892 test_cipher ("des", MODE_CBC
, DECRYPT
, des_cbc_dec_tv_template
, DES_CBC_DEC_TEST_VECTORS
);
896 test_cipher ("des3_ede", MODE_ECB
, ENCRYPT
, des3_ede_enc_tv_template
, DES3_EDE_ENC_TEST_VECTORS
);
897 test_cipher ("des3_ede", MODE_ECB
, DECRYPT
, des3_ede_dec_tv_template
, DES3_EDE_DEC_TEST_VECTORS
);
901 test_hash("md4", md4_tv_template
, MD4_TEST_VECTORS
);
905 test_hash("sha256", sha256_tv_template
, SHA256_TEST_VECTORS
);
909 test_cipher ("blowfish", MODE_ECB
, ENCRYPT
, bf_enc_tv_template
, BF_ENC_TEST_VECTORS
);
910 test_cipher ("blowfish", MODE_ECB
, DECRYPT
, bf_dec_tv_template
, BF_DEC_TEST_VECTORS
);
911 test_cipher ("blowfish", MODE_CBC
, ENCRYPT
, bf_cbc_enc_tv_template
, BF_CBC_ENC_TEST_VECTORS
);
912 test_cipher ("blowfish", MODE_CBC
, DECRYPT
, bf_cbc_dec_tv_template
, BF_CBC_DEC_TEST_VECTORS
);
916 test_cipher ("twofish", MODE_ECB
, ENCRYPT
, tf_enc_tv_template
, TF_ENC_TEST_VECTORS
);
917 test_cipher ("twofish", MODE_ECB
, DECRYPT
, tf_dec_tv_template
, TF_DEC_TEST_VECTORS
);
918 test_cipher ("twofish", MODE_CBC
, ENCRYPT
, tf_cbc_enc_tv_template
, TF_CBC_ENC_TEST_VECTORS
);
919 test_cipher ("twofish", MODE_CBC
, DECRYPT
, tf_cbc_dec_tv_template
, TF_CBC_DEC_TEST_VECTORS
);
923 test_cipher ("serpent", MODE_ECB
, ENCRYPT
, serpent_enc_tv_template
, SERPENT_ENC_TEST_VECTORS
);
924 test_cipher ("serpent", MODE_ECB
, DECRYPT
, serpent_dec_tv_template
, SERPENT_DEC_TEST_VECTORS
);
928 test_cipher ("aes", MODE_ECB
, ENCRYPT
, aes_enc_tv_template
, AES_ENC_TEST_VECTORS
);
929 test_cipher ("aes", MODE_ECB
, DECRYPT
, aes_dec_tv_template
, AES_DEC_TEST_VECTORS
);
930 test_cipher ("aes", MODE_CBC
, ENCRYPT
, aes_cbc_enc_tv_template
, AES_CBC_ENC_TEST_VECTORS
);
931 test_cipher ("aes", MODE_CBC
, DECRYPT
, aes_cbc_dec_tv_template
, AES_CBC_DEC_TEST_VECTORS
);
935 test_hash("sha384", sha384_tv_template
, SHA384_TEST_VECTORS
);
939 test_hash("sha512", sha512_tv_template
, SHA512_TEST_VECTORS
);
947 test_cipher ("cast5", MODE_ECB
, ENCRYPT
, cast5_enc_tv_template
, CAST5_ENC_TEST_VECTORS
);
948 test_cipher ("cast5", MODE_ECB
, DECRYPT
, cast5_dec_tv_template
, CAST5_DEC_TEST_VECTORS
);
952 test_cipher ("cast6", MODE_ECB
, ENCRYPT
, cast6_enc_tv_template
, CAST6_ENC_TEST_VECTORS
);
953 test_cipher ("cast6", MODE_ECB
, DECRYPT
, cast6_dec_tv_template
, CAST6_DEC_TEST_VECTORS
);
957 test_cipher ("arc4", MODE_ECB
, ENCRYPT
, arc4_enc_tv_template
, ARC4_ENC_TEST_VECTORS
);
958 test_cipher ("arc4", MODE_ECB
, DECRYPT
, arc4_dec_tv_template
, ARC4_DEC_TEST_VECTORS
);
962 test_hash("michael_mic", michael_mic_tv_template
, MICHAEL_MIC_TEST_VECTORS
);
966 test_hash("crc32c", crc32c_tv_template
, CRC32C_TEST_VECTORS
);
970 test_cipher ("tea", MODE_ECB
, ENCRYPT
, tea_enc_tv_template
, TEA_ENC_TEST_VECTORS
);
971 test_cipher ("tea", MODE_ECB
, DECRYPT
, tea_dec_tv_template
, TEA_DEC_TEST_VECTORS
);
975 test_cipher ("xtea", MODE_ECB
, ENCRYPT
, xtea_enc_tv_template
, XTEA_ENC_TEST_VECTORS
);
976 test_cipher ("xtea", MODE_ECB
, DECRYPT
, xtea_dec_tv_template
, XTEA_DEC_TEST_VECTORS
);
980 test_cipher ("khazad", MODE_ECB
, ENCRYPT
, khazad_enc_tv_template
, KHAZAD_ENC_TEST_VECTORS
);
981 test_cipher ("khazad", MODE_ECB
, DECRYPT
, khazad_dec_tv_template
, KHAZAD_DEC_TEST_VECTORS
);
985 test_hash("wp512", wp512_tv_template
, WP512_TEST_VECTORS
);
989 test_hash("wp384", wp384_tv_template
, WP384_TEST_VECTORS
);
993 test_hash("wp256", wp256_tv_template
, WP256_TEST_VECTORS
);
997 test_cipher ("tnepres", MODE_ECB
, ENCRYPT
, tnepres_enc_tv_template
, TNEPRES_ENC_TEST_VECTORS
);
998 test_cipher ("tnepres", MODE_ECB
, DECRYPT
, tnepres_dec_tv_template
, TNEPRES_DEC_TEST_VECTORS
);
1002 test_cipher ("anubis", MODE_ECB
, ENCRYPT
, anubis_enc_tv_template
, ANUBIS_ENC_TEST_VECTORS
);
1003 test_cipher ("anubis", MODE_ECB
, DECRYPT
, anubis_dec_tv_template
, ANUBIS_DEC_TEST_VECTORS
);
1004 test_cipher ("anubis", MODE_CBC
, ENCRYPT
, anubis_cbc_enc_tv_template
, ANUBIS_CBC_ENC_TEST_VECTORS
);
1005 test_cipher ("anubis", MODE_CBC
, DECRYPT
, anubis_cbc_dec_tv_template
, ANUBIS_CBC_ENC_TEST_VECTORS
);
1009 test_hash("tgr192", tgr192_tv_template
, TGR192_TEST_VECTORS
);
1014 test_hash("tgr160", tgr160_tv_template
, TGR160_TEST_VECTORS
);
1018 test_hash("tgr128", tgr128_tv_template
, TGR128_TEST_VECTORS
);
1022 test_cipher ("xeta", MODE_ECB
, ENCRYPT
, xeta_enc_tv_template
, XETA_ENC_TEST_VECTORS
);
1023 test_cipher ("xeta", MODE_ECB
, DECRYPT
, xeta_dec_tv_template
, XETA_DEC_TEST_VECTORS
);
1026 #ifdef CONFIG_CRYPTO_HMAC
1028 test_hmac("md5", hmac_md5_tv_template
, HMAC_MD5_TEST_VECTORS
);
1032 test_hmac("sha1", hmac_sha1_tv_template
, HMAC_SHA1_TEST_VECTORS
);
1036 test_hmac("sha256", hmac_sha256_tv_template
, HMAC_SHA256_TEST_VECTORS
);
1042 test_cipher_speed("aes", MODE_ECB
, ENCRYPT
, sec
, NULL
, 0,
1043 aes_speed_template
);
1044 test_cipher_speed("aes", MODE_ECB
, DECRYPT
, sec
, NULL
, 0,
1045 aes_speed_template
);
1046 test_cipher_speed("aes", MODE_CBC
, ENCRYPT
, sec
, NULL
, 0,
1047 aes_speed_template
);
1048 test_cipher_speed("aes", MODE_CBC
, DECRYPT
, sec
, NULL
, 0,
1049 aes_speed_template
);
1053 test_cipher_speed("des3_ede", MODE_ECB
, ENCRYPT
, sec
,
1054 des3_ede_enc_tv_template
,
1055 DES3_EDE_ENC_TEST_VECTORS
,
1056 des3_ede_speed_template
);
1057 test_cipher_speed("des3_ede", MODE_ECB
, DECRYPT
, sec
,
1058 des3_ede_dec_tv_template
,
1059 DES3_EDE_DEC_TEST_VECTORS
,
1060 des3_ede_speed_template
);
1061 test_cipher_speed("des3_ede", MODE_CBC
, ENCRYPT
, sec
,
1062 des3_ede_enc_tv_template
,
1063 DES3_EDE_ENC_TEST_VECTORS
,
1064 des3_ede_speed_template
);
1065 test_cipher_speed("des3_ede", MODE_CBC
, DECRYPT
, sec
,
1066 des3_ede_dec_tv_template
,
1067 DES3_EDE_DEC_TEST_VECTORS
,
1068 des3_ede_speed_template
);
1072 test_cipher_speed("twofish", MODE_ECB
, ENCRYPT
, sec
, NULL
, 0,
1073 twofish_speed_template
);
1074 test_cipher_speed("twofish", MODE_ECB
, DECRYPT
, sec
, NULL
, 0,
1075 twofish_speed_template
);
1076 test_cipher_speed("twofish", MODE_CBC
, ENCRYPT
, sec
, NULL
, 0,
1077 twofish_speed_template
);
1078 test_cipher_speed("twofish", MODE_CBC
, DECRYPT
, sec
, NULL
, 0,
1079 twofish_speed_template
);
1083 test_cipher_speed("blowfish", MODE_ECB
, ENCRYPT
, sec
, NULL
, 0,
1084 blowfish_speed_template
);
1085 test_cipher_speed("blowfish", MODE_ECB
, DECRYPT
, sec
, NULL
, 0,
1086 blowfish_speed_template
);
1087 test_cipher_speed("blowfish", MODE_CBC
, ENCRYPT
, sec
, NULL
, 0,
1088 blowfish_speed_template
);
1089 test_cipher_speed("blowfish", MODE_CBC
, DECRYPT
, sec
, NULL
, 0,
1090 blowfish_speed_template
);
1094 test_cipher_speed("des", MODE_ECB
, ENCRYPT
, sec
, NULL
, 0,
1095 des_speed_template
);
1096 test_cipher_speed("des", MODE_ECB
, DECRYPT
, sec
, NULL
, 0,
1097 des_speed_template
);
1098 test_cipher_speed("des", MODE_CBC
, ENCRYPT
, sec
, NULL
, 0,
1099 des_speed_template
);
1100 test_cipher_speed("des", MODE_CBC
, DECRYPT
, sec
, NULL
, 0,
1101 des_speed_template
);
1108 test_digest_speed("md4", sec
, generic_digest_speed_template
);
1109 if (mode
> 300 && mode
< 400) break;
1112 test_digest_speed("md5", sec
, generic_digest_speed_template
);
1113 if (mode
> 300 && mode
< 400) break;
1116 test_digest_speed("sha1", sec
, generic_digest_speed_template
);
1117 if (mode
> 300 && mode
< 400) break;
1120 test_digest_speed("sha256", sec
, generic_digest_speed_template
);
1121 if (mode
> 300 && mode
< 400) break;
1124 test_digest_speed("sha384", sec
, generic_digest_speed_template
);
1125 if (mode
> 300 && mode
< 400) break;
1128 test_digest_speed("sha512", sec
, generic_digest_speed_template
);
1129 if (mode
> 300 && mode
< 400) break;
1132 test_digest_speed("wp256", sec
, generic_digest_speed_template
);
1133 if (mode
> 300 && mode
< 400) break;
1136 test_digest_speed("wp384", sec
, generic_digest_speed_template
);
1137 if (mode
> 300 && mode
< 400) break;
1140 test_digest_speed("wp512", sec
, generic_digest_speed_template
);
1141 if (mode
> 300 && mode
< 400) break;
1144 test_digest_speed("tgr128", sec
, generic_digest_speed_template
);
1145 if (mode
> 300 && mode
< 400) break;
1148 test_digest_speed("tgr160", sec
, generic_digest_speed_template
);
1149 if (mode
> 300 && mode
< 400) break;
1152 test_digest_speed("tgr192", sec
, generic_digest_speed_template
);
1153 if (mode
> 300 && mode
< 400) break;
1163 /* useful for debugging */
1164 printk("not testing anything\n");
1169 static int __init
init(void)
1171 tvmem
= kmalloc(TVMEMSIZE
, GFP_KERNEL
);
1175 xbuf
= kmalloc(XBUFSIZE
, GFP_KERNEL
);
1186 /* We intentionaly return -EAGAIN to prevent keeping
1187 * the module. It does all its work from init()
1188 * and doesn't offer any runtime functionality
1189 * => we don't need it in the memory, do we?
1196 * If an init function is provided, an exit function must also be provided
1197 * to allow module unload.
1199 static void __exit
fini(void) { }
1204 module_param(mode
, int, 0);
1205 module_param(sec
, uint
, 0);
1206 MODULE_PARM_DESC(sec
, "Length in seconds of speed tests "
1207 "(defaults to zero which uses CPU cycles instead)");
1209 MODULE_LICENSE("GPL");
1210 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
1211 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");