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 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by the Free
13 * Software Foundation; either version 2 of the License, or (at your option)
16 * 2007-11-13 Added GCM tests
17 * 2007-11-13 Added AEAD support
18 * 2007-11-06 Added SHA-224 and SHA-224-HMAC tests
19 * 2006-12-07 Added SHA384 HMAC and SHA512 HMAC tests
20 * 2004-08-09 Added cipher speed tests (Reyk Floeter <reyk@vantronix.net>)
21 * 2003-09-14 Rewritten by Kartikey Mahendra Bhatt
25 #include <linux/err.h>
26 #include <linux/init.h>
27 #include <linux/module.h>
29 #include <linux/slab.h>
30 #include <linux/scatterlist.h>
31 #include <linux/string.h>
32 #include <linux/crypto.h>
33 #include <linux/highmem.h>
34 #include <linux/moduleparam.h>
35 #include <linux/jiffies.h>
36 #include <linux/timex.h>
37 #include <linux/interrupt.h>
41 * Need to kmalloc() memory for testing kmap().
43 #define TVMEMSIZE 16384
44 #define XBUFSIZE 32768
47 * Indexes into the xbuf to simulate cross-page access.
59 * Used by test_cipher()
64 struct tcrypt_result {
65 struct completion completion;
69 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
72 * Used by test_cipher_speed()
74 static unsigned int sec;
81 static char *check[] = {
82 "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256",
83 "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes",
84 "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
85 "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
86 "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", "fcrypt",
87 "camellia", "seed", "salsa20", "lzo", NULL
90 static void hexdump(unsigned char *buf, unsigned int len)
92 print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
97 static void tcrypt_complete(struct crypto_async_request *req, int err)
99 struct tcrypt_result *res = req->data;
101 if (err == -EINPROGRESS)
105 complete(&res->completion);
108 static void test_hash(char *algo, struct hash_testvec *template,
111 unsigned int i, j, k, temp;
112 struct scatterlist sg[8];
114 struct crypto_hash *tfm;
115 struct hash_desc desc;
116 struct hash_testvec *hash_tv;
120 printk("\ntesting %s\n", algo);
122 tsize = sizeof(struct hash_testvec);
125 if (tsize > TVMEMSIZE) {
126 printk("template (%u) too big for tvmem (%u)\n", tsize, TVMEMSIZE);
130 memcpy(tvmem, template, tsize);
131 hash_tv = (void *)tvmem;
133 tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
135 printk("failed to load transform for %s: %ld\n", algo,
143 for (i = 0; i < tcount; i++) {
144 printk("test %u:\n", i + 1);
145 memset(result, 0, 64);
147 sg_init_one(&sg[0], hash_tv[i].plaintext, hash_tv[i].psize);
149 if (hash_tv[i].ksize) {
150 ret = crypto_hash_setkey(tfm, hash_tv[i].key,
153 printk("setkey() failed ret=%d\n", ret);
158 ret = crypto_hash_digest(&desc, sg, hash_tv[i].psize, result);
160 printk("digest () failed ret=%d\n", ret);
164 hexdump(result, crypto_hash_digestsize(tfm));
166 memcmp(result, hash_tv[i].digest,
167 crypto_hash_digestsize(tfm)) ?
171 printk("testing %s across pages\n", algo);
173 /* setup the dummy buffer first */
174 memset(xbuf, 0, XBUFSIZE);
177 for (i = 0; i < tcount; i++) {
180 printk("test %u:\n", j);
181 memset(result, 0, 64);
184 sg_init_table(sg, hash_tv[i].np);
185 for (k = 0; k < hash_tv[i].np; k++) {
186 memcpy(&xbuf[IDX[k]],
187 hash_tv[i].plaintext + temp,
189 temp += hash_tv[i].tap[k];
190 sg_set_buf(&sg[k], &xbuf[IDX[k]],
194 if (hash_tv[i].ksize) {
195 ret = crypto_hash_setkey(tfm, hash_tv[i].key,
199 printk("setkey() failed ret=%d\n", ret);
204 ret = crypto_hash_digest(&desc, sg, hash_tv[i].psize,
207 printk("digest () failed ret=%d\n", ret);
211 hexdump(result, crypto_hash_digestsize(tfm));
213 memcmp(result, hash_tv[i].digest,
214 crypto_hash_digestsize(tfm)) ?
220 crypto_free_hash(tfm);
223 static void test_aead(char *algo, int enc, struct aead_testvec *template,
226 unsigned int ret, i, j, k, temp;
229 struct crypto_aead *tfm;
231 struct aead_testvec *aead_tv;
232 struct aead_request *req;
233 struct scatterlist sg[8];
234 struct scatterlist asg[8];
236 struct tcrypt_result result;
237 unsigned int authsize;
244 printk(KERN_INFO "\ntesting %s %s\n", algo, e);
246 tsize = sizeof(struct aead_testvec);
249 if (tsize > TVMEMSIZE) {
250 printk(KERN_INFO "template (%u) too big for tvmem (%u)\n",
255 memcpy(tvmem, template, tsize);
256 aead_tv = (void *)tvmem;
258 init_completion(&result.completion);
260 tfm = crypto_alloc_aead(algo, 0, 0);
263 printk(KERN_INFO "failed to load transform for %s: %ld\n",
268 req = aead_request_alloc(tfm, GFP_KERNEL);
270 printk(KERN_INFO "failed to allocate request for %s\n", algo);
274 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
275 tcrypt_complete, &result);
277 for (i = 0, j = 0; i < tcount; i++) {
278 if (!aead_tv[i].np) {
279 printk(KERN_INFO "test %u (%d bit key):\n",
280 ++j, aead_tv[i].klen * 8);
282 crypto_aead_clear_flags(tfm, ~0);
284 crypto_aead_set_flags(
285 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
286 key = aead_tv[i].key;
288 ret = crypto_aead_setkey(tfm, key,
291 printk(KERN_INFO "setkey() failed flags=%x\n",
292 crypto_aead_get_flags(tfm));
294 if (!aead_tv[i].fail)
298 authsize = abs(aead_tv[i].rlen - aead_tv[i].ilen);
299 ret = crypto_aead_setauthsize(tfm, authsize);
302 "failed to set authsize = %u\n",
307 sg_init_one(&sg[0], aead_tv[i].input,
308 aead_tv[i].ilen + (enc ? authsize : 0));
310 sg_init_one(&asg[0], aead_tv[i].assoc,
313 aead_request_set_crypt(req, sg, sg,
317 aead_request_set_assoc(req, asg, aead_tv[i].alen);
320 crypto_aead_encrypt(req) :
321 crypto_aead_decrypt(req);
328 ret = wait_for_completion_interruptible(
330 if (!ret && !(ret = result.err)) {
331 INIT_COMPLETION(result.completion);
336 printk(KERN_INFO "%s () failed err=%d\n",
341 q = kmap(sg_page(&sg[0])) + sg[0].offset;
342 hexdump(q, aead_tv[i].rlen);
344 printk(KERN_INFO "enc/dec: %s\n",
345 memcmp(q, aead_tv[i].result,
346 aead_tv[i].rlen) ? "fail" : "pass");
350 printk(KERN_INFO "\ntesting %s %s across pages (chunking)\n", algo, e);
351 memset(xbuf, 0, XBUFSIZE);
352 memset(axbuf, 0, XBUFSIZE);
354 for (i = 0, j = 0; i < tcount; i++) {
356 printk(KERN_INFO "test %u (%d bit key):\n",
357 ++j, aead_tv[i].klen * 8);
359 crypto_aead_clear_flags(tfm, ~0);
361 crypto_aead_set_flags(
362 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
363 key = aead_tv[i].key;
365 ret = crypto_aead_setkey(tfm, key, aead_tv[i].klen);
367 printk(KERN_INFO "setkey() failed flags=%x\n",
368 crypto_aead_get_flags(tfm));
370 if (!aead_tv[i].fail)
374 sg_init_table(sg, aead_tv[i].np);
375 for (k = 0, temp = 0; k < aead_tv[i].np; k++) {
376 memcpy(&xbuf[IDX[k]],
377 aead_tv[i].input + temp,
379 temp += aead_tv[i].tap[k];
380 sg_set_buf(&sg[k], &xbuf[IDX[k]],
384 authsize = abs(aead_tv[i].rlen - aead_tv[i].ilen);
385 ret = crypto_aead_setauthsize(tfm, authsize);
388 "failed to set authsize = %u\n",
394 sg[k - 1].length += authsize;
396 sg_init_table(asg, aead_tv[i].anp);
397 for (k = 0, temp = 0; k < aead_tv[i].anp; k++) {
398 memcpy(&axbuf[IDX[k]],
399 aead_tv[i].assoc + temp,
401 temp += aead_tv[i].atap[k];
402 sg_set_buf(&asg[k], &axbuf[IDX[k]],
406 aead_request_set_crypt(req, sg, sg,
410 aead_request_set_assoc(req, asg, aead_tv[i].alen);
413 crypto_aead_encrypt(req) :
414 crypto_aead_decrypt(req);
421 ret = wait_for_completion_interruptible(
423 if (!ret && !(ret = result.err)) {
424 INIT_COMPLETION(result.completion);
429 printk(KERN_INFO "%s () failed err=%d\n",
434 for (k = 0, temp = 0; k < aead_tv[i].np; k++) {
435 printk(KERN_INFO "page %u\n", k);
436 q = kmap(sg_page(&sg[k])) + sg[k].offset;
437 hexdump(q, aead_tv[i].tap[k]);
438 printk(KERN_INFO "%s\n",
439 memcmp(q, aead_tv[i].result + temp,
441 (k < aead_tv[i].np - 1 || enc ?
445 temp += aead_tv[i].tap[k];
451 crypto_free_aead(tfm);
452 aead_request_free(req);
455 static void test_cipher(char *algo, int enc,
456 struct cipher_testvec *template, unsigned int tcount)
458 unsigned int ret, i, j, k, temp;
461 struct crypto_ablkcipher *tfm;
463 struct cipher_testvec *cipher_tv;
464 struct ablkcipher_request *req;
465 struct scatterlist sg[8];
467 struct tcrypt_result result;
474 printk("\ntesting %s %s\n", algo, e);
476 tsize = sizeof (struct cipher_testvec);
477 if (tsize > TVMEMSIZE) {
478 printk("template (%u) too big for tvmem (%u)\n", tsize,
482 cipher_tv = (void *)tvmem;
484 init_completion(&result.completion);
486 tfm = crypto_alloc_ablkcipher(algo, 0, 0);
489 printk("failed to load transform for %s: %ld\n", algo,
494 req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
496 printk("failed to allocate request for %s\n", algo);
500 ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
501 tcrypt_complete, &result);
504 for (i = 0; i < tcount; i++) {
505 memcpy(cipher_tv, &template[i], tsize);
506 if (!(cipher_tv->np)) {
508 printk("test %u (%d bit key):\n",
509 j, cipher_tv->klen * 8);
511 crypto_ablkcipher_clear_flags(tfm, ~0);
513 crypto_ablkcipher_set_flags(
514 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
515 key = cipher_tv->key;
517 ret = crypto_ablkcipher_setkey(tfm, key,
520 printk("setkey() failed flags=%x\n",
521 crypto_ablkcipher_get_flags(tfm));
523 if (!cipher_tv->fail)
527 sg_init_one(&sg[0], cipher_tv->input,
530 ablkcipher_request_set_crypt(req, sg, sg,
535 crypto_ablkcipher_encrypt(req) :
536 crypto_ablkcipher_decrypt(req);
543 ret = wait_for_completion_interruptible(
545 if (!ret && !((ret = result.err))) {
546 INIT_COMPLETION(result.completion);
551 printk("%s () failed err=%d\n", e, -ret);
555 q = kmap(sg_page(&sg[0])) + sg[0].offset;
556 hexdump(q, cipher_tv->rlen);
559 memcmp(q, cipher_tv->result,
560 cipher_tv->rlen) ? "fail" : "pass");
564 printk("\ntesting %s %s across pages (chunking)\n", algo, e);
565 memset(xbuf, 0, XBUFSIZE);
568 for (i = 0; i < tcount; i++) {
569 memcpy(cipher_tv, &template[i], tsize);
572 printk("test %u (%d bit key):\n",
573 j, cipher_tv->klen * 8);
575 crypto_ablkcipher_clear_flags(tfm, ~0);
577 crypto_ablkcipher_set_flags(
578 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
579 key = cipher_tv->key;
581 ret = crypto_ablkcipher_setkey(tfm, key,
584 printk("setkey() failed flags=%x\n",
585 crypto_ablkcipher_get_flags(tfm));
587 if (!cipher_tv->fail)
592 sg_init_table(sg, cipher_tv->np);
593 for (k = 0; k < cipher_tv->np; k++) {
594 memcpy(&xbuf[IDX[k]],
595 cipher_tv->input + temp,
597 temp += cipher_tv->tap[k];
598 sg_set_buf(&sg[k], &xbuf[IDX[k]],
602 ablkcipher_request_set_crypt(req, sg, sg,
607 crypto_ablkcipher_encrypt(req) :
608 crypto_ablkcipher_decrypt(req);
615 ret = wait_for_completion_interruptible(
617 if (!ret && !((ret = result.err))) {
618 INIT_COMPLETION(result.completion);
623 printk("%s () failed err=%d\n", e, -ret);
628 for (k = 0; k < cipher_tv->np; k++) {
629 printk("page %u\n", k);
630 q = kmap(sg_page(&sg[k])) + sg[k].offset;
631 hexdump(q, cipher_tv->tap[k]);
633 memcmp(q, cipher_tv->result + temp,
634 cipher_tv->tap[k]) ? "fail" :
636 temp += cipher_tv->tap[k];
642 crypto_free_ablkcipher(tfm);
643 ablkcipher_request_free(req);
646 static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc, char *p,
649 struct scatterlist sg[1];
650 unsigned long start, end;
654 sg_init_one(sg, p, blen);
656 for (start = jiffies, end = start + sec * HZ, bcount = 0;
657 time_before(jiffies, end); bcount++) {
659 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
661 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
667 printk("%d operations in %d seconds (%ld bytes)\n",
668 bcount, sec, (long)bcount * blen);
672 static int test_cipher_cycles(struct blkcipher_desc *desc, int enc, char *p,
675 struct scatterlist sg[1];
676 unsigned long cycles = 0;
680 sg_init_one(sg, p, blen);
686 for (i = 0; i < 4; i++) {
688 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
690 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
696 /* The real thing. */
697 for (i = 0; i < 8; i++) {
700 start = get_cycles();
702 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
704 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
710 cycles += end - start;
718 printk("1 operation in %lu cycles (%d bytes)\n",
719 (cycles + 4) / 8, blen);
724 static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 };
726 static void test_cipher_speed(char *algo, int enc, unsigned int sec,
727 struct cipher_testvec *template,
728 unsigned int tcount, u8 *keysize)
730 unsigned int ret, i, j, iv_len;
731 unsigned char *key, *p, iv[128];
732 struct crypto_blkcipher *tfm;
733 struct blkcipher_desc desc;
742 printk("\ntesting speed of %s %s\n", algo, e);
744 tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);
747 printk("failed to load transform for %s: %ld\n", algo,
757 b_size = block_sizes;
760 if ((*keysize + *b_size) > TVMEMSIZE) {
761 printk("template (%u) too big for tvmem (%u)\n",
762 *keysize + *b_size, TVMEMSIZE);
766 printk("test %u (%d bit key, %d byte blocks): ", i,
767 *keysize * 8, *b_size);
769 memset(tvmem, 0xff, *keysize + *b_size);
771 /* set key, plain text and IV */
772 key = (unsigned char *)tvmem;
773 for (j = 0; j < tcount; j++) {
774 if (template[j].klen == *keysize) {
775 key = template[j].key;
779 p = (unsigned char *)tvmem + *keysize;
781 ret = crypto_blkcipher_setkey(tfm, key, *keysize);
783 printk("setkey() failed flags=%x\n",
784 crypto_blkcipher_get_flags(tfm));
788 iv_len = crypto_blkcipher_ivsize(tfm);
790 memset(&iv, 0xff, iv_len);
791 crypto_blkcipher_set_iv(tfm, iv, iv_len);
795 ret = test_cipher_jiffies(&desc, enc, p, *b_size, sec);
797 ret = test_cipher_cycles(&desc, enc, p, *b_size);
800 printk("%s() failed flags=%x\n", e, desc.flags);
810 crypto_free_blkcipher(tfm);
813 static int test_hash_jiffies_digest(struct hash_desc *desc, char *p, int blen,
816 struct scatterlist sg[1];
817 unsigned long start, end;
821 sg_init_table(sg, 1);
823 for (start = jiffies, end = start + sec * HZ, bcount = 0;
824 time_before(jiffies, end); bcount++) {
825 sg_set_buf(sg, p, blen);
826 ret = crypto_hash_digest(desc, sg, blen, out);
831 printk("%6u opers/sec, %9lu bytes/sec\n",
832 bcount / sec, ((long)bcount * blen) / sec);
837 static int test_hash_jiffies(struct hash_desc *desc, char *p, int blen,
838 int plen, char *out, int sec)
840 struct scatterlist sg[1];
841 unsigned long start, end;
846 return test_hash_jiffies_digest(desc, p, blen, out, sec);
848 sg_init_table(sg, 1);
850 for (start = jiffies, end = start + sec * HZ, bcount = 0;
851 time_before(jiffies, end); bcount++) {
852 ret = crypto_hash_init(desc);
855 for (pcount = 0; pcount < blen; pcount += plen) {
856 sg_set_buf(sg, p + pcount, plen);
857 ret = crypto_hash_update(desc, sg, plen);
861 /* we assume there is enough space in 'out' for the result */
862 ret = crypto_hash_final(desc, out);
867 printk("%6u opers/sec, %9lu bytes/sec\n",
868 bcount / sec, ((long)bcount * blen) / sec);
873 static int test_hash_cycles_digest(struct hash_desc *desc, char *p, int blen,
876 struct scatterlist sg[1];
877 unsigned long cycles = 0;
881 sg_init_table(sg, 1);
887 for (i = 0; i < 4; i++) {
888 sg_set_buf(sg, p, blen);
889 ret = crypto_hash_digest(desc, sg, blen, out);
894 /* The real thing. */
895 for (i = 0; i < 8; i++) {
898 start = get_cycles();
900 sg_set_buf(sg, p, blen);
901 ret = crypto_hash_digest(desc, sg, blen, out);
907 cycles += end - start;
917 printk("%6lu cycles/operation, %4lu cycles/byte\n",
918 cycles / 8, cycles / (8 * blen));
923 static int test_hash_cycles(struct hash_desc *desc, char *p, int blen,
926 struct scatterlist sg[1];
927 unsigned long cycles = 0;
932 return test_hash_cycles_digest(desc, p, blen, out);
934 sg_init_table(sg, 1);
940 for (i = 0; i < 4; i++) {
941 ret = crypto_hash_init(desc);
944 for (pcount = 0; pcount < blen; pcount += plen) {
945 sg_set_buf(sg, p + pcount, plen);
946 ret = crypto_hash_update(desc, sg, plen);
950 ret = crypto_hash_final(desc, out);
955 /* The real thing. */
956 for (i = 0; i < 8; i++) {
959 start = get_cycles();
961 ret = crypto_hash_init(desc);
964 for (pcount = 0; pcount < blen; pcount += plen) {
965 sg_set_buf(sg, p + pcount, plen);
966 ret = crypto_hash_update(desc, sg, plen);
970 ret = crypto_hash_final(desc, out);
976 cycles += end - start;
986 printk("%6lu cycles/operation, %4lu cycles/byte\n",
987 cycles / 8, cycles / (8 * blen));
992 static void test_hash_speed(char *algo, unsigned int sec,
993 struct hash_speed *speed)
995 struct crypto_hash *tfm;
996 struct hash_desc desc;
1001 printk("\ntesting speed of %s\n", algo);
1003 tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
1006 printk("failed to load transform for %s: %ld\n", algo,
1014 if (crypto_hash_digestsize(tfm) > sizeof(output)) {
1015 printk("digestsize(%u) > outputbuffer(%zu)\n",
1016 crypto_hash_digestsize(tfm), sizeof(output));
1020 for (i = 0; speed[i].blen != 0; i++) {
1021 if (speed[i].blen > TVMEMSIZE) {
1022 printk("template (%u) too big for tvmem (%u)\n",
1023 speed[i].blen, TVMEMSIZE);
1027 printk("test%3u (%5u byte blocks,%5u bytes per update,%4u updates): ",
1028 i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
1030 memset(tvmem, 0xff, speed[i].blen);
1033 ret = test_hash_jiffies(&desc, tvmem, speed[i].blen,
1034 speed[i].plen, output, sec);
1036 ret = test_hash_cycles(&desc, tvmem, speed[i].blen,
1037 speed[i].plen, output);
1040 printk("hashing failed ret=%d\n", ret);
1046 crypto_free_hash(tfm);
1049 static void test_comp(char *algo, struct comp_testvec *ctemplate,
1050 struct comp_testvec *dtemplate, int ctcount, int dtcount)
1053 char result[COMP_BUF_SIZE];
1054 struct crypto_comp *tfm;
1055 struct comp_testvec *tv;
1058 printk("\ntesting %s compression\n", algo);
1060 tsize = sizeof(struct comp_testvec);
1062 if (tsize > TVMEMSIZE) {
1063 printk("template (%u) too big for tvmem (%u)\n", tsize,
1068 memcpy(tvmem, ctemplate, tsize);
1071 tfm = crypto_alloc_comp(algo, 0, CRYPTO_ALG_ASYNC);
1073 printk("failed to load transform for %s\n", algo);
1077 for (i = 0; i < ctcount; i++) {
1078 int ilen, ret, dlen = COMP_BUF_SIZE;
1080 printk("test %u:\n", i + 1);
1081 memset(result, 0, sizeof (result));
1084 ret = crypto_comp_compress(tfm, tv[i].input,
1085 ilen, result, &dlen);
1087 printk("fail: ret=%d\n", ret);
1090 hexdump(result, dlen);
1091 printk("%s (ratio %d:%d)\n",
1092 memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
1096 printk("\ntesting %s decompression\n", algo);
1098 tsize = sizeof(struct comp_testvec);
1100 if (tsize > TVMEMSIZE) {
1101 printk("template (%u) too big for tvmem (%u)\n", tsize,
1106 memcpy(tvmem, dtemplate, tsize);
1109 for (i = 0; i < dtcount; i++) {
1110 int ilen, ret, dlen = COMP_BUF_SIZE;
1112 printk("test %u:\n", i + 1);
1113 memset(result, 0, sizeof (result));
1116 ret = crypto_comp_decompress(tfm, tv[i].input,
1117 ilen, result, &dlen);
1119 printk("fail: ret=%d\n", ret);
1122 hexdump(result, dlen);
1123 printk("%s (ratio %d:%d)\n",
1124 memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
1128 crypto_free_comp(tfm);
1131 static void test_available(void)
1133 char **name = check;
1136 printk("alg %s ", *name);
1137 printk(crypto_has_alg(*name, 0, 0) ?
1138 "found\n" : "not found\n");
1143 static void do_test(void)
1148 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
1150 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
1153 test_cipher("ecb(des)", ENCRYPT, des_enc_tv_template,
1154 DES_ENC_TEST_VECTORS);
1155 test_cipher("ecb(des)", DECRYPT, des_dec_tv_template,
1156 DES_DEC_TEST_VECTORS);
1157 test_cipher("cbc(des)", ENCRYPT, des_cbc_enc_tv_template,
1158 DES_CBC_ENC_TEST_VECTORS);
1159 test_cipher("cbc(des)", DECRYPT, des_cbc_dec_tv_template,
1160 DES_CBC_DEC_TEST_VECTORS);
1163 test_cipher("ecb(des3_ede)", ENCRYPT, des3_ede_enc_tv_template,
1164 DES3_EDE_ENC_TEST_VECTORS);
1165 test_cipher("ecb(des3_ede)", DECRYPT, des3_ede_dec_tv_template,
1166 DES3_EDE_DEC_TEST_VECTORS);
1168 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
1170 test_hash("sha224", sha224_tv_template, SHA224_TEST_VECTORS);
1172 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
1175 test_cipher("ecb(blowfish)", ENCRYPT, bf_enc_tv_template,
1176 BF_ENC_TEST_VECTORS);
1177 test_cipher("ecb(blowfish)", DECRYPT, bf_dec_tv_template,
1178 BF_DEC_TEST_VECTORS);
1179 test_cipher("cbc(blowfish)", ENCRYPT, bf_cbc_enc_tv_template,
1180 BF_CBC_ENC_TEST_VECTORS);
1181 test_cipher("cbc(blowfish)", DECRYPT, bf_cbc_dec_tv_template,
1182 BF_CBC_DEC_TEST_VECTORS);
1185 test_cipher("ecb(twofish)", ENCRYPT, tf_enc_tv_template,
1186 TF_ENC_TEST_VECTORS);
1187 test_cipher("ecb(twofish)", DECRYPT, tf_dec_tv_template,
1188 TF_DEC_TEST_VECTORS);
1189 test_cipher("cbc(twofish)", ENCRYPT, tf_cbc_enc_tv_template,
1190 TF_CBC_ENC_TEST_VECTORS);
1191 test_cipher("cbc(twofish)", DECRYPT, tf_cbc_dec_tv_template,
1192 TF_CBC_DEC_TEST_VECTORS);
1195 test_cipher("ecb(serpent)", ENCRYPT, serpent_enc_tv_template,
1196 SERPENT_ENC_TEST_VECTORS);
1197 test_cipher("ecb(serpent)", DECRYPT, serpent_dec_tv_template,
1198 SERPENT_DEC_TEST_VECTORS);
1201 test_cipher("ecb(tnepres)", ENCRYPT, tnepres_enc_tv_template,
1202 TNEPRES_ENC_TEST_VECTORS);
1203 test_cipher("ecb(tnepres)", DECRYPT, tnepres_dec_tv_template,
1204 TNEPRES_DEC_TEST_VECTORS);
1207 test_cipher("ecb(aes)", ENCRYPT, aes_enc_tv_template,
1208 AES_ENC_TEST_VECTORS);
1209 test_cipher("ecb(aes)", DECRYPT, aes_dec_tv_template,
1210 AES_DEC_TEST_VECTORS);
1211 test_cipher("cbc(aes)", ENCRYPT, aes_cbc_enc_tv_template,
1212 AES_CBC_ENC_TEST_VECTORS);
1213 test_cipher("cbc(aes)", DECRYPT, aes_cbc_dec_tv_template,
1214 AES_CBC_DEC_TEST_VECTORS);
1215 test_cipher("lrw(aes)", ENCRYPT, aes_lrw_enc_tv_template,
1216 AES_LRW_ENC_TEST_VECTORS);
1217 test_cipher("lrw(aes)", DECRYPT, aes_lrw_dec_tv_template,
1218 AES_LRW_DEC_TEST_VECTORS);
1219 test_cipher("xts(aes)", ENCRYPT, aes_xts_enc_tv_template,
1220 AES_XTS_ENC_TEST_VECTORS);
1221 test_cipher("xts(aes)", DECRYPT, aes_xts_dec_tv_template,
1222 AES_XTS_DEC_TEST_VECTORS);
1223 test_cipher("rfc3686(ctr(aes))", ENCRYPT, aes_ctr_enc_tv_template,
1224 AES_CTR_ENC_TEST_VECTORS);
1225 test_cipher("rfc3686(ctr(aes))", DECRYPT, aes_ctr_dec_tv_template,
1226 AES_CTR_DEC_TEST_VECTORS);
1227 test_aead("gcm(aes)", ENCRYPT, aes_gcm_enc_tv_template,
1228 AES_GCM_ENC_TEST_VECTORS);
1229 test_aead("gcm(aes)", DECRYPT, aes_gcm_dec_tv_template,
1230 AES_GCM_DEC_TEST_VECTORS);
1231 test_aead("ccm(aes)", ENCRYPT, aes_ccm_enc_tv_template,
1232 AES_CCM_ENC_TEST_VECTORS);
1233 test_aead("ccm(aes)", DECRYPT, aes_ccm_dec_tv_template,
1234 AES_CCM_DEC_TEST_VECTORS);
1237 test_cipher("ecb(cast5)", ENCRYPT, cast5_enc_tv_template,
1238 CAST5_ENC_TEST_VECTORS);
1239 test_cipher("ecb(cast5)", DECRYPT, cast5_dec_tv_template,
1240 CAST5_DEC_TEST_VECTORS);
1243 test_cipher("ecb(cast6)", ENCRYPT, cast6_enc_tv_template,
1244 CAST6_ENC_TEST_VECTORS);
1245 test_cipher("ecb(cast6)", DECRYPT, cast6_dec_tv_template,
1246 CAST6_DEC_TEST_VECTORS);
1249 test_cipher("ecb(arc4)", ENCRYPT, arc4_enc_tv_template,
1250 ARC4_ENC_TEST_VECTORS);
1251 test_cipher("ecb(arc4)", DECRYPT, arc4_dec_tv_template,
1252 ARC4_DEC_TEST_VECTORS);
1255 test_cipher("ecb(tea)", ENCRYPT, tea_enc_tv_template,
1256 TEA_ENC_TEST_VECTORS);
1257 test_cipher("ecb(tea)", DECRYPT, tea_dec_tv_template,
1258 TEA_DEC_TEST_VECTORS);
1262 test_cipher("ecb(xtea)", ENCRYPT, xtea_enc_tv_template,
1263 XTEA_ENC_TEST_VECTORS);
1264 test_cipher("ecb(xtea)", DECRYPT, xtea_dec_tv_template,
1265 XTEA_DEC_TEST_VECTORS);
1268 test_cipher("ecb(khazad)", ENCRYPT, khazad_enc_tv_template,
1269 KHAZAD_ENC_TEST_VECTORS);
1270 test_cipher("ecb(khazad)", DECRYPT, khazad_dec_tv_template,
1271 KHAZAD_DEC_TEST_VECTORS);
1274 test_cipher("ecb(anubis)", ENCRYPT, anubis_enc_tv_template,
1275 ANUBIS_ENC_TEST_VECTORS);
1276 test_cipher("ecb(anubis)", DECRYPT, anubis_dec_tv_template,
1277 ANUBIS_DEC_TEST_VECTORS);
1278 test_cipher("cbc(anubis)", ENCRYPT, anubis_cbc_enc_tv_template,
1279 ANUBIS_CBC_ENC_TEST_VECTORS);
1280 test_cipher("cbc(anubis)", DECRYPT, anubis_cbc_dec_tv_template,
1281 ANUBIS_CBC_ENC_TEST_VECTORS);
1284 test_cipher("ecb(xeta)", ENCRYPT, xeta_enc_tv_template,
1285 XETA_ENC_TEST_VECTORS);
1286 test_cipher("ecb(xeta)", DECRYPT, xeta_dec_tv_template,
1287 XETA_DEC_TEST_VECTORS);
1290 test_cipher("pcbc(fcrypt)", ENCRYPT, fcrypt_pcbc_enc_tv_template,
1291 FCRYPT_ENC_TEST_VECTORS);
1292 test_cipher("pcbc(fcrypt)", DECRYPT, fcrypt_pcbc_dec_tv_template,
1293 FCRYPT_DEC_TEST_VECTORS);
1296 test_cipher("ecb(camellia)", ENCRYPT,
1297 camellia_enc_tv_template,
1298 CAMELLIA_ENC_TEST_VECTORS);
1299 test_cipher("ecb(camellia)", DECRYPT,
1300 camellia_dec_tv_template,
1301 CAMELLIA_DEC_TEST_VECTORS);
1302 test_cipher("cbc(camellia)", ENCRYPT,
1303 camellia_cbc_enc_tv_template,
1304 CAMELLIA_CBC_ENC_TEST_VECTORS);
1305 test_cipher("cbc(camellia)", DECRYPT,
1306 camellia_cbc_dec_tv_template,
1307 CAMELLIA_CBC_DEC_TEST_VECTORS);
1310 test_cipher("ecb(seed)", ENCRYPT, seed_enc_tv_template,
1311 SEED_ENC_TEST_VECTORS);
1312 test_cipher("ecb(seed)", DECRYPT, seed_dec_tv_template,
1313 SEED_DEC_TEST_VECTORS);
1315 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
1316 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
1317 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
1318 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
1319 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
1320 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
1321 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
1322 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
1323 test_comp("deflate", deflate_comp_tv_template,
1324 deflate_decomp_tv_template, DEFLATE_COMP_TEST_VECTORS,
1325 DEFLATE_DECOMP_TEST_VECTORS);
1326 test_comp("lzo", lzo_comp_tv_template, lzo_decomp_tv_template,
1327 LZO_COMP_TEST_VECTORS, LZO_DECOMP_TEST_VECTORS);
1328 test_hash("crc32c", crc32c_tv_template, CRC32C_TEST_VECTORS);
1329 test_hash("hmac(md5)", hmac_md5_tv_template,
1330 HMAC_MD5_TEST_VECTORS);
1331 test_hash("hmac(sha1)", hmac_sha1_tv_template,
1332 HMAC_SHA1_TEST_VECTORS);
1333 test_hash("hmac(sha224)", hmac_sha224_tv_template,
1334 HMAC_SHA224_TEST_VECTORS);
1335 test_hash("hmac(sha256)", hmac_sha256_tv_template,
1336 HMAC_SHA256_TEST_VECTORS);
1337 test_hash("hmac(sha384)", hmac_sha384_tv_template,
1338 HMAC_SHA384_TEST_VECTORS);
1339 test_hash("hmac(sha512)", hmac_sha512_tv_template,
1340 HMAC_SHA512_TEST_VECTORS);
1342 test_hash("xcbc(aes)", aes_xcbc128_tv_template,
1343 XCBC_AES_TEST_VECTORS);
1345 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
1349 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
1353 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
1357 test_cipher("ecb(des)", ENCRYPT, des_enc_tv_template,
1358 DES_ENC_TEST_VECTORS);
1359 test_cipher("ecb(des)", DECRYPT, des_dec_tv_template,
1360 DES_DEC_TEST_VECTORS);
1361 test_cipher("cbc(des)", ENCRYPT, des_cbc_enc_tv_template,
1362 DES_CBC_ENC_TEST_VECTORS);
1363 test_cipher("cbc(des)", DECRYPT, des_cbc_dec_tv_template,
1364 DES_CBC_DEC_TEST_VECTORS);
1368 test_cipher("ecb(des3_ede)", ENCRYPT, des3_ede_enc_tv_template,
1369 DES3_EDE_ENC_TEST_VECTORS);
1370 test_cipher("ecb(des3_ede)", DECRYPT, des3_ede_dec_tv_template,
1371 DES3_EDE_DEC_TEST_VECTORS);
1375 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
1379 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
1383 test_cipher("ecb(blowfish)", ENCRYPT, bf_enc_tv_template,
1384 BF_ENC_TEST_VECTORS);
1385 test_cipher("ecb(blowfish)", DECRYPT, bf_dec_tv_template,
1386 BF_DEC_TEST_VECTORS);
1387 test_cipher("cbc(blowfish)", ENCRYPT, bf_cbc_enc_tv_template,
1388 BF_CBC_ENC_TEST_VECTORS);
1389 test_cipher("cbc(blowfish)", DECRYPT, bf_cbc_dec_tv_template,
1390 BF_CBC_DEC_TEST_VECTORS);
1394 test_cipher("ecb(twofish)", ENCRYPT, tf_enc_tv_template,
1395 TF_ENC_TEST_VECTORS);
1396 test_cipher("ecb(twofish)", DECRYPT, tf_dec_tv_template,
1397 TF_DEC_TEST_VECTORS);
1398 test_cipher("cbc(twofish)", ENCRYPT, tf_cbc_enc_tv_template,
1399 TF_CBC_ENC_TEST_VECTORS);
1400 test_cipher("cbc(twofish)", DECRYPT, tf_cbc_dec_tv_template,
1401 TF_CBC_DEC_TEST_VECTORS);
1405 test_cipher("ecb(serpent)", ENCRYPT, serpent_enc_tv_template,
1406 SERPENT_ENC_TEST_VECTORS);
1407 test_cipher("ecb(serpent)", DECRYPT, serpent_dec_tv_template,
1408 SERPENT_DEC_TEST_VECTORS);
1412 test_cipher("ecb(aes)", ENCRYPT, aes_enc_tv_template,
1413 AES_ENC_TEST_VECTORS);
1414 test_cipher("ecb(aes)", DECRYPT, aes_dec_tv_template,
1415 AES_DEC_TEST_VECTORS);
1416 test_cipher("cbc(aes)", ENCRYPT, aes_cbc_enc_tv_template,
1417 AES_CBC_ENC_TEST_VECTORS);
1418 test_cipher("cbc(aes)", DECRYPT, aes_cbc_dec_tv_template,
1419 AES_CBC_DEC_TEST_VECTORS);
1420 test_cipher("lrw(aes)", ENCRYPT, aes_lrw_enc_tv_template,
1421 AES_LRW_ENC_TEST_VECTORS);
1422 test_cipher("lrw(aes)", DECRYPT, aes_lrw_dec_tv_template,
1423 AES_LRW_DEC_TEST_VECTORS);
1424 test_cipher("xts(aes)", ENCRYPT, aes_xts_enc_tv_template,
1425 AES_XTS_ENC_TEST_VECTORS);
1426 test_cipher("xts(aes)", DECRYPT, aes_xts_dec_tv_template,
1427 AES_XTS_DEC_TEST_VECTORS);
1428 test_cipher("rfc3686(ctr(aes))", ENCRYPT, aes_ctr_enc_tv_template,
1429 AES_CTR_ENC_TEST_VECTORS);
1430 test_cipher("rfc3686(ctr(aes))", DECRYPT, aes_ctr_dec_tv_template,
1431 AES_CTR_DEC_TEST_VECTORS);
1435 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
1439 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
1443 test_comp("deflate", deflate_comp_tv_template,
1444 deflate_decomp_tv_template, DEFLATE_COMP_TEST_VECTORS,
1445 DEFLATE_DECOMP_TEST_VECTORS);
1449 test_cipher("ecb(cast5)", ENCRYPT, cast5_enc_tv_template,
1450 CAST5_ENC_TEST_VECTORS);
1451 test_cipher("ecb(cast5)", DECRYPT, cast5_dec_tv_template,
1452 CAST5_DEC_TEST_VECTORS);
1456 test_cipher("ecb(cast6)", ENCRYPT, cast6_enc_tv_template,
1457 CAST6_ENC_TEST_VECTORS);
1458 test_cipher("ecb(cast6)", DECRYPT, cast6_dec_tv_template,
1459 CAST6_DEC_TEST_VECTORS);
1463 test_cipher("ecb(arc4)", ENCRYPT, arc4_enc_tv_template,
1464 ARC4_ENC_TEST_VECTORS);
1465 test_cipher("ecb(arc4)", DECRYPT, arc4_dec_tv_template,
1466 ARC4_DEC_TEST_VECTORS);
1470 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
1474 test_hash("crc32c", crc32c_tv_template, CRC32C_TEST_VECTORS);
1478 test_cipher("ecb(tea)", ENCRYPT, tea_enc_tv_template,
1479 TEA_ENC_TEST_VECTORS);
1480 test_cipher("ecb(tea)", DECRYPT, tea_dec_tv_template,
1481 TEA_DEC_TEST_VECTORS);
1485 test_cipher("ecb(xtea)", ENCRYPT, xtea_enc_tv_template,
1486 XTEA_ENC_TEST_VECTORS);
1487 test_cipher("ecb(xtea)", DECRYPT, xtea_dec_tv_template,
1488 XTEA_DEC_TEST_VECTORS);
1492 test_cipher("ecb(khazad)", ENCRYPT, khazad_enc_tv_template,
1493 KHAZAD_ENC_TEST_VECTORS);
1494 test_cipher("ecb(khazad)", DECRYPT, khazad_dec_tv_template,
1495 KHAZAD_DEC_TEST_VECTORS);
1499 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
1503 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
1507 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
1511 test_cipher("ecb(tnepres)", ENCRYPT, tnepres_enc_tv_template,
1512 TNEPRES_ENC_TEST_VECTORS);
1513 test_cipher("ecb(tnepres)", DECRYPT, tnepres_dec_tv_template,
1514 TNEPRES_DEC_TEST_VECTORS);
1518 test_cipher("ecb(anubis)", ENCRYPT, anubis_enc_tv_template,
1519 ANUBIS_ENC_TEST_VECTORS);
1520 test_cipher("ecb(anubis)", DECRYPT, anubis_dec_tv_template,
1521 ANUBIS_DEC_TEST_VECTORS);
1522 test_cipher("cbc(anubis)", ENCRYPT, anubis_cbc_enc_tv_template,
1523 ANUBIS_CBC_ENC_TEST_VECTORS);
1524 test_cipher("cbc(anubis)", DECRYPT, anubis_cbc_dec_tv_template,
1525 ANUBIS_CBC_ENC_TEST_VECTORS);
1529 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
1534 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
1538 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
1542 test_cipher("ecb(xeta)", ENCRYPT, xeta_enc_tv_template,
1543 XETA_ENC_TEST_VECTORS);
1544 test_cipher("ecb(xeta)", DECRYPT, xeta_dec_tv_template,
1545 XETA_DEC_TEST_VECTORS);
1549 test_cipher("pcbc(fcrypt)", ENCRYPT, fcrypt_pcbc_enc_tv_template,
1550 FCRYPT_ENC_TEST_VECTORS);
1551 test_cipher("pcbc(fcrypt)", DECRYPT, fcrypt_pcbc_dec_tv_template,
1552 FCRYPT_DEC_TEST_VECTORS);
1556 test_cipher("ecb(camellia)", ENCRYPT,
1557 camellia_enc_tv_template,
1558 CAMELLIA_ENC_TEST_VECTORS);
1559 test_cipher("ecb(camellia)", DECRYPT,
1560 camellia_dec_tv_template,
1561 CAMELLIA_DEC_TEST_VECTORS);
1562 test_cipher("cbc(camellia)", ENCRYPT,
1563 camellia_cbc_enc_tv_template,
1564 CAMELLIA_CBC_ENC_TEST_VECTORS);
1565 test_cipher("cbc(camellia)", DECRYPT,
1566 camellia_cbc_dec_tv_template,
1567 CAMELLIA_CBC_DEC_TEST_VECTORS);
1570 test_hash("sha224", sha224_tv_template, SHA224_TEST_VECTORS);
1574 test_cipher("salsa20", ENCRYPT,
1575 salsa20_stream_enc_tv_template,
1576 SALSA20_STREAM_ENC_TEST_VECTORS);
1580 test_aead("gcm(aes)", ENCRYPT, aes_gcm_enc_tv_template,
1581 AES_GCM_ENC_TEST_VECTORS);
1582 test_aead("gcm(aes)", DECRYPT, aes_gcm_dec_tv_template,
1583 AES_GCM_DEC_TEST_VECTORS);
1587 test_comp("lzo", lzo_comp_tv_template, lzo_decomp_tv_template,
1588 LZO_COMP_TEST_VECTORS, LZO_DECOMP_TEST_VECTORS);
1592 test_aead("ccm(aes)", ENCRYPT, aes_ccm_enc_tv_template,
1593 AES_CCM_ENC_TEST_VECTORS);
1594 test_aead("ccm(aes)", DECRYPT, aes_ccm_dec_tv_template,
1595 AES_CCM_DEC_TEST_VECTORS);
1599 test_hash("hmac(md5)", hmac_md5_tv_template,
1600 HMAC_MD5_TEST_VECTORS);
1604 test_hash("hmac(sha1)", hmac_sha1_tv_template,
1605 HMAC_SHA1_TEST_VECTORS);
1609 test_hash("hmac(sha256)", hmac_sha256_tv_template,
1610 HMAC_SHA256_TEST_VECTORS);
1614 test_hash("hmac(sha384)", hmac_sha384_tv_template,
1615 HMAC_SHA384_TEST_VECTORS);
1619 test_hash("hmac(sha512)", hmac_sha512_tv_template,
1620 HMAC_SHA512_TEST_VECTORS);
1624 test_hash("hmac(sha224)", hmac_sha224_tv_template,
1625 HMAC_SHA224_TEST_VECTORS);
1629 test_hash("xcbc(aes)", aes_xcbc128_tv_template,
1630 XCBC_AES_TEST_VECTORS);
1634 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
1635 speed_template_16_24_32);
1636 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
1637 speed_template_16_24_32);
1638 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
1639 speed_template_16_24_32);
1640 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
1641 speed_template_16_24_32);
1642 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
1643 speed_template_32_40_48);
1644 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
1645 speed_template_32_40_48);
1646 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
1647 speed_template_32_48_64);
1648 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
1649 speed_template_32_48_64);
1653 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
1654 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1656 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
1657 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1659 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
1660 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1662 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
1663 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1668 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
1669 speed_template_16_24_32);
1670 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
1671 speed_template_16_24_32);
1672 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
1673 speed_template_16_24_32);
1674 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
1675 speed_template_16_24_32);
1679 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
1680 speed_template_8_32);
1681 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
1682 speed_template_8_32);
1683 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
1684 speed_template_8_32);
1685 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
1686 speed_template_8_32);
1690 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
1692 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
1694 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
1696 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
1701 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
1702 speed_template_16_24_32);
1703 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
1704 speed_template_16_24_32);
1705 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
1706 speed_template_16_24_32);
1707 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
1708 speed_template_16_24_32);
1712 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
1713 speed_template_16_32);
1720 test_hash_speed("md4", sec, generic_hash_speed_template);
1721 if (mode > 300 && mode < 400) break;
1724 test_hash_speed("md5", sec, generic_hash_speed_template);
1725 if (mode > 300 && mode < 400) break;
1728 test_hash_speed("sha1", sec, generic_hash_speed_template);
1729 if (mode > 300 && mode < 400) break;
1732 test_hash_speed("sha256", sec, generic_hash_speed_template);
1733 if (mode > 300 && mode < 400) break;
1736 test_hash_speed("sha384", sec, generic_hash_speed_template);
1737 if (mode > 300 && mode < 400) break;
1740 test_hash_speed("sha512", sec, generic_hash_speed_template);
1741 if (mode > 300 && mode < 400) break;
1744 test_hash_speed("wp256", sec, generic_hash_speed_template);
1745 if (mode > 300 && mode < 400) break;
1748 test_hash_speed("wp384", sec, generic_hash_speed_template);
1749 if (mode > 300 && mode < 400) break;
1752 test_hash_speed("wp512", sec, generic_hash_speed_template);
1753 if (mode > 300 && mode < 400) break;
1756 test_hash_speed("tgr128", sec, generic_hash_speed_template);
1757 if (mode > 300 && mode < 400) break;
1760 test_hash_speed("tgr160", sec, generic_hash_speed_template);
1761 if (mode > 300 && mode < 400) break;
1764 test_hash_speed("tgr192", sec, generic_hash_speed_template);
1765 if (mode > 300 && mode < 400) break;
1768 test_hash_speed("sha224", sec, generic_hash_speed_template);
1769 if (mode > 300 && mode < 400) break;
1779 /* useful for debugging */
1780 printk("not testing anything\n");
1785 static int __init init(void)
1789 tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL);
1793 xbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
1797 axbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
1803 /* We intentionaly return -EAGAIN to prevent keeping
1804 * the module. It does all its work from init()
1805 * and doesn't offer any runtime functionality
1806 * => we don't need it in the memory, do we?
1821 * If an init function is provided, an exit function must also be provided
1822 * to allow module unload.
1824 static void __exit fini(void) { }
1829 module_param(mode, int, 0);
1830 module_param(sec, uint, 0);
1831 MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
1832 "(defaults to zero which uses CPU cycles instead)");
1834 MODULE_LICENSE("GPL");
1835 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
1836 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");