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)
16 * Rewritten by Kartikey Mahendra Bhatt
19 #include <linux/init.h>
20 #include <linux/module.h>
22 #include <linux/slab.h>
23 #include <asm/scatterlist.h>
24 #include <linux/string.h>
25 #include <linux/crypto.h>
26 #include <linux/highmem.h>
27 #include <linux/moduleparam.h>
31 * Need to kmalloc() memory for testing kmap().
33 #define TVMEMSIZE 4096
34 #define XBUFSIZE 32768
37 * Indexes into the xbuf to simulate cross-page access.
49 * Used by test_cipher()
56 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
62 static char *check[] = {
63 "des", "md5", "des3_ede", "rot13", "sha1", "sha256", "blowfish",
64 "twofish", "serpent", "sha384", "sha512", "md4", "aes", "cast6",
65 "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
66 "khazad", "wp512", "wp384", "wp256", "tnepres", NULL
69 static void hexdump(unsigned char *buf, unsigned int len)
72 printk("%02x", *buf++);
77 static void test_hash(char *algo, struct hash_testvec *template,
81 unsigned int i, j, k, temp;
82 struct scatterlist sg[8];
84 struct crypto_tfm *tfm;
85 struct hash_testvec *hash_tv;
88 printk("\ntesting %s\n", algo);
90 tsize = sizeof(struct hash_testvec);
93 if (tsize > TVMEMSIZE) {
94 printk("template (%u) too big for tvmem (%u)\n", tsize, TVMEMSIZE);
98 memcpy(tvmem, template, tsize);
99 hash_tv = (void *)tvmem;
100 tfm = crypto_alloc_tfm(algo, 0);
102 printk("failed to load transform for %s\n", algo);
106 for (i = 0; i < tcount; i++) {
107 printk("test %u:\n", i + 1);
108 memset(result, 0, 64);
110 p = hash_tv[i].plaintext;
111 sg[0].page = virt_to_page(p);
112 sg[0].offset = offset_in_page(p);
113 sg[0].length = hash_tv[i].psize;
115 crypto_digest_init(tfm);
116 if (tfm->crt_u.digest.dit_setkey) {
117 crypto_digest_setkey(tfm, hash_tv[i].key,
120 crypto_digest_update(tfm, sg, 1);
121 crypto_digest_final(tfm, result);
123 hexdump(result, crypto_tfm_alg_digestsize(tfm));
125 memcmp(result, hash_tv[i].digest,
126 crypto_tfm_alg_digestsize(tfm)) ?
130 printk("testing %s across pages\n", algo);
132 /* setup the dummy buffer first */
133 memset(xbuf, 0, XBUFSIZE);
136 for (i = 0; i < tcount; i++) {
139 printk("test %u:\n", j);
140 memset(result, 0, 64);
143 for (k = 0; k < hash_tv[i].np; k++) {
144 memcpy(&xbuf[IDX[k]],
145 hash_tv[i].plaintext + temp,
147 temp += hash_tv[i].tap[k];
149 sg[k].page = virt_to_page(p);
150 sg[k].offset = offset_in_page(p);
151 sg[k].length = hash_tv[i].tap[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,
174 unsigned int i, j, k, temp;
175 struct scatterlist sg[8];
177 struct crypto_tfm *tfm;
178 struct hmac_testvec *hmac_tv;
179 unsigned int tsize, klen;
181 tfm = crypto_alloc_tfm(algo, 0);
183 printk("failed to load transform for %s\n", algo);
187 printk("\ntesting hmac_%s\n", algo);
189 tsize = sizeof(struct hmac_testvec);
191 if (tsize > TVMEMSIZE) {
192 printk("template (%u) too big for tvmem (%u)\n", tsize,
197 memcpy(tvmem, template, tsize);
198 hmac_tv = (void *)tvmem;
200 for (i = 0; i < tcount; i++) {
201 printk("test %u:\n", i + 1);
202 memset(result, 0, sizeof (result));
204 p = hmac_tv[i].plaintext;
205 klen = hmac_tv[i].ksize;
206 sg[0].page = virt_to_page(p);
207 sg[0].offset = offset_in_page(p);
208 sg[0].length = hmac_tv[i].psize;
210 crypto_hmac(tfm, hmac_tv[i].key, &klen, sg, 1, result);
212 hexdump(result, crypto_tfm_alg_digestsize(tfm));
214 memcmp(result, hmac_tv[i].digest,
215 crypto_tfm_alg_digestsize(tfm)) ? "fail" :
219 printk("\ntesting hmac_%s across pages\n", algo);
221 memset(xbuf, 0, XBUFSIZE);
224 for (i = 0; i < tcount; i++) {
227 printk("test %u:\n",j);
228 memset(result, 0, 64);
231 klen = hmac_tv[i].ksize;
232 for (k = 0; k < hmac_tv[i].np; k++) {
233 memcpy(&xbuf[IDX[k]],
234 hmac_tv[i].plaintext + temp,
236 temp += hmac_tv[i].tap[k];
238 sg[k].page = virt_to_page(p);
239 sg[k].offset = offset_in_page(p);
240 sg[k].length = hmac_tv[i].tap[k];
243 crypto_hmac(tfm, hmac_tv[i].key, &klen, sg,
244 hmac_tv[i].np, result);
245 hexdump(result, crypto_tfm_alg_digestsize(tfm));
248 memcmp(result, hmac_tv[i].digest,
249 crypto_tfm_alg_digestsize(tfm)) ?
254 crypto_free_tfm(tfm);
257 #endif /* CONFIG_CRYPTO_HMAC */
259 static void test_cipher(char *algo, int mode, int enc,
260 struct cipher_testvec *template, unsigned int tcount)
262 unsigned int ret, i, j, k, temp;
265 struct crypto_tfm *tfm;
267 struct cipher_testvec *cipher_tv;
268 struct scatterlist sg[8];
272 strncpy(e, "encryption", 11);
274 strncpy(e, "decryption", 11);
275 if (mode == MODE_ECB)
276 strncpy(m, "ECB", 4);
278 strncpy(m, "CBC", 4);
280 printk("\ntesting %s %s %s\n", algo, m, e);
282 tsize = sizeof (struct cipher_testvec);
285 if (tsize > TVMEMSIZE) {
286 printk("template (%u) too big for tvmem (%u)\n", tsize,
291 memcpy(tvmem, template, tsize);
292 cipher_tv = (void *)tvmem;
295 tfm = crypto_alloc_tfm(algo, 0);
297 tfm = crypto_alloc_tfm(algo, CRYPTO_TFM_MODE_CBC);
300 printk("failed to load transform for %s %s\n", algo, m);
305 for (i = 0; i < tcount; i++) {
306 if (!(cipher_tv[i].np)) {
308 printk("test %u (%d bit key):\n",
309 j, cipher_tv[i].klen * 8);
313 tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY;
314 key = cipher_tv[i].key;
316 ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen);
318 printk("setkey() failed flags=%x\n", tfm->crt_flags);
320 if (!cipher_tv[i].fail)
324 p = cipher_tv[i].input;
325 sg[0].page = virt_to_page(p);
326 sg[0].offset = offset_in_page(p);
327 sg[0].length = cipher_tv[i].ilen;
330 crypto_cipher_set_iv(tfm, cipher_tv[i].iv,
331 crypto_tfm_alg_ivsize(tfm));
335 ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen);
337 ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen);
341 printk("%s () failed flags=%x\n", e, tfm->crt_flags);
345 q = kmap(sg[0].page) + sg[0].offset;
346 hexdump(q, cipher_tv[i].rlen);
349 memcmp(q, cipher_tv[i].result,
350 cipher_tv[i].rlen) ? "fail" : "pass");
354 printk("\ntesting %s %s %s across pages (chunking)\n", algo, m, e);
355 memset(xbuf, 0, XBUFSIZE);
358 for (i = 0; i < tcount; i++) {
359 if (cipher_tv[i].np) {
361 printk("test %u (%d bit key):\n",
362 j, cipher_tv[i].klen * 8);
366 tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY;
367 key = cipher_tv[i].key;
369 ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen);
371 printk("setkey() failed flags=%x\n", tfm->crt_flags);
373 if (!cipher_tv[i].fail)
378 for (k = 0; k < cipher_tv[i].np; k++) {
379 memcpy(&xbuf[IDX[k]],
380 cipher_tv[i].input + temp,
381 cipher_tv[i].tap[k]);
382 temp += cipher_tv[i].tap[k];
384 sg[k].page = virt_to_page(p);
385 sg[k].offset = offset_in_page(p);
386 sg[k].length = cipher_tv[i].tap[k];
390 crypto_cipher_set_iv(tfm, cipher_tv[i].iv,
391 crypto_tfm_alg_ivsize(tfm));
395 ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen);
397 ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen);
400 printk("%s () failed flags=%x\n", e, tfm->crt_flags);
405 for (k = 0; k < cipher_tv[i].np; k++) {
406 printk("page %u\n", k);
407 q = kmap(sg[k].page) + sg[k].offset;
408 hexdump(q, cipher_tv[i].tap[k]);
410 memcmp(q, cipher_tv[i].result + temp,
411 cipher_tv[i].tap[k]) ? "fail" :
413 temp += cipher_tv[i].tap[k];
419 crypto_free_tfm(tfm);
422 static void test_deflate(void)
425 char result[COMP_BUF_SIZE];
426 struct crypto_tfm *tfm;
427 struct comp_testvec *tv;
430 printk("\ntesting deflate compression\n");
432 tsize = sizeof (deflate_comp_tv_template);
433 if (tsize > TVMEMSIZE) {
434 printk("template (%u) too big for tvmem (%u)\n", tsize,
439 memcpy(tvmem, deflate_comp_tv_template, tsize);
442 tfm = crypto_alloc_tfm("deflate", 0);
444 printk("failed to load transform for deflate\n");
448 for (i = 0; i < DEFLATE_COMP_TEST_VECTORS; i++) {
449 int ilen, ret, dlen = COMP_BUF_SIZE;
451 printk("test %u:\n", i + 1);
452 memset(result, 0, sizeof (result));
455 ret = crypto_comp_compress(tfm, tv[i].input,
456 ilen, result, &dlen);
458 printk("fail: ret=%d\n", ret);
461 hexdump(result, dlen);
462 printk("%s (ratio %d:%d)\n",
463 memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
467 printk("\ntesting deflate decompression\n");
469 tsize = sizeof (deflate_decomp_tv_template);
470 if (tsize > TVMEMSIZE) {
471 printk("template (%u) too big for tvmem (%u)\n", tsize,
476 memcpy(tvmem, deflate_decomp_tv_template, tsize);
479 for (i = 0; i < DEFLATE_DECOMP_TEST_VECTORS; i++) {
480 int ilen, ret, dlen = COMP_BUF_SIZE;
482 printk("test %u:\n", i + 1);
483 memset(result, 0, sizeof (result));
486 ret = crypto_comp_decompress(tfm, tv[i].input,
487 ilen, result, &dlen);
489 printk("fail: ret=%d\n", ret);
492 hexdump(result, dlen);
493 printk("%s (ratio %d:%d)\n",
494 memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
498 crypto_free_tfm(tfm);
501 static void test_crc32c(void)
508 u8 b, test_vec[NUMVEC][VECSIZE];
509 static u32 vec_results[NUMVEC] = {
510 0x0e2c157f, 0xe980ebf6, 0xde74bded,
511 0xd579c862, 0xba979ad0, 0x2b29d913
513 static u32 tot_vec_results = 0x24c5d375;
515 struct scatterlist sg[NUMVEC];
516 struct crypto_tfm *tfm;
517 char *fmtdata = "testing crc32c initialized to %08x: %s\n";
518 #define SEEDTESTVAL 0xedcba987
521 printk("\ntesting crc32c\n");
523 tfm = crypto_alloc_tfm("crc32c", 0);
525 printk("failed to load transform for crc32c\n");
529 crypto_digest_init(tfm);
530 crypto_digest_final(tfm, (u8*)&crc);
531 printk(fmtdata, crc, (crc == 0) ? "pass" : "ERROR");
534 * stuff test_vec with known values, simple incrementing
538 for (i = 0; i < NUMVEC; i++) {
539 for (j = 0; j < VECSIZE; j++)
540 test_vec[i][j] = ++b;
541 sg[i].page = virt_to_page(test_vec[i]);
542 sg[i].offset = offset_in_page(test_vec[i]);
543 sg[i].length = VECSIZE;
547 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
548 crypto_digest_final(tfm, (u8*)&crc);
549 printk("testing crc32c setkey returns %08x : %s\n", crc, (crc == (SEEDTESTVAL ^ ~(u32)0)) ?
552 printk("testing crc32c using update/final:\n");
554 pass = 1; /* assume all is well */
556 for (i = 0; i < NUMVEC; i++) {
558 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
559 crypto_digest_update(tfm, &sg[i], 1);
560 crypto_digest_final(tfm, (u8*)&crc);
561 if (crc == vec_results[i]) {
562 printk(" %08x:OK", crc);
564 printk(" %08x:BAD, wanted %08x\n", crc, vec_results[i]);
569 printk("\ntesting crc32c using incremental accumulator:\n");
571 for (i = 0; i < NUMVEC; i++) {
572 seed = (crc ^ ~(u32)0);
573 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
574 crypto_digest_update(tfm, &sg[i], 1);
575 crypto_digest_final(tfm, (u8*)&crc);
577 if (crc == tot_vec_results) {
578 printk(" %08x:OK", crc);
580 printk(" %08x:BAD, wanted %08x\n", crc, tot_vec_results);
584 printk("\ntesting crc32c using digest:\n");
586 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
587 crypto_digest_digest(tfm, sg, NUMVEC, (u8*)&crc);
588 if (crc == tot_vec_results) {
589 printk(" %08x:OK", crc);
591 printk(" %08x:BAD, wanted %08x\n", crc, tot_vec_results);
595 printk("\n%s\n", pass ? "pass" : "ERROR");
597 crypto_free_tfm(tfm);
598 printk("crc32c test complete\n");
601 static void test_available(void)
606 printk("alg %s ", *name);
607 printk((crypto_alg_available(*name, 0)) ?
608 "found\n" : "not found\n");
613 static void do_test(void)
618 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
620 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
623 test_cipher ("des", MODE_ECB, ENCRYPT, des_enc_tv_template, DES_ENC_TEST_VECTORS);
624 test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS);
625 test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS);
626 test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS);
629 test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS);
630 test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS);
632 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
634 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
637 test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS);
638 test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS);
639 test_cipher ("blowfish", MODE_CBC, ENCRYPT, bf_cbc_enc_tv_template, BF_CBC_ENC_TEST_VECTORS);
640 test_cipher ("blowfish", MODE_CBC, DECRYPT, bf_cbc_dec_tv_template, BF_CBC_DEC_TEST_VECTORS);
643 test_cipher ("twofish", MODE_ECB, ENCRYPT, tf_enc_tv_template, TF_ENC_TEST_VECTORS);
644 test_cipher ("twofish", MODE_ECB, DECRYPT, tf_dec_tv_template, TF_DEC_TEST_VECTORS);
645 test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS);
646 test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS);
649 test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS);
650 test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS);
653 test_cipher ("tnepres", MODE_ECB, ENCRYPT, tnepres_enc_tv_template, TNEPRES_ENC_TEST_VECTORS);
654 test_cipher ("tnepres", MODE_ECB, DECRYPT, tnepres_dec_tv_template, TNEPRES_DEC_TEST_VECTORS);
657 test_cipher ("aes", MODE_ECB, ENCRYPT, aes_enc_tv_template, AES_ENC_TEST_VECTORS);
658 test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS);
661 test_cipher ("cast5", MODE_ECB, ENCRYPT, cast5_enc_tv_template, CAST5_ENC_TEST_VECTORS);
662 test_cipher ("cast5", MODE_ECB, DECRYPT, cast5_dec_tv_template, CAST5_DEC_TEST_VECTORS);
665 test_cipher ("cast6", MODE_ECB, ENCRYPT, cast6_enc_tv_template, CAST6_ENC_TEST_VECTORS);
666 test_cipher ("cast6", MODE_ECB, DECRYPT, cast6_dec_tv_template, CAST6_DEC_TEST_VECTORS);
669 test_cipher ("arc4", MODE_ECB, ENCRYPT, arc4_enc_tv_template, ARC4_ENC_TEST_VECTORS);
670 test_cipher ("arc4", MODE_ECB, DECRYPT, arc4_dec_tv_template, ARC4_DEC_TEST_VECTORS);
673 test_cipher ("tea", MODE_ECB, ENCRYPT, tea_enc_tv_template, TEA_ENC_TEST_VECTORS);
674 test_cipher ("tea", MODE_ECB, DECRYPT, tea_dec_tv_template, TEA_DEC_TEST_VECTORS);
678 test_cipher ("xtea", MODE_ECB, ENCRYPT, xtea_enc_tv_template, XTEA_ENC_TEST_VECTORS);
679 test_cipher ("xtea", MODE_ECB, DECRYPT, xtea_dec_tv_template, XTEA_DEC_TEST_VECTORS);
682 test_cipher ("khazad", MODE_ECB, ENCRYPT, khazad_enc_tv_template, KHAZAD_ENC_TEST_VECTORS);
683 test_cipher ("khazad", MODE_ECB, DECRYPT, khazad_dec_tv_template, KHAZAD_DEC_TEST_VECTORS);
686 test_cipher ("anubis", MODE_ECB, ENCRYPT, anubis_enc_tv_template, ANUBIS_ENC_TEST_VECTORS);
687 test_cipher ("anubis", MODE_ECB, DECRYPT, anubis_dec_tv_template, ANUBIS_DEC_TEST_VECTORS);
688 test_cipher ("anubis", MODE_CBC, ENCRYPT, anubis_cbc_enc_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
689 test_cipher ("anubis", MODE_CBC, DECRYPT, anubis_cbc_dec_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
691 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
692 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
693 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
694 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
695 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
696 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
697 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
698 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
701 #ifdef CONFIG_CRYPTO_HMAC
702 test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS);
703 test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS);
704 test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS);
707 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
711 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
715 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
719 test_cipher ("des", MODE_ECB, ENCRYPT, des_enc_tv_template, DES_ENC_TEST_VECTORS);
720 test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS);
721 test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS);
722 test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS);
726 test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS);
727 test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS);
731 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
735 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
739 test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS);
740 test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS);
741 test_cipher ("blowfish", MODE_CBC, ENCRYPT, bf_cbc_enc_tv_template, BF_CBC_ENC_TEST_VECTORS);
742 test_cipher ("blowfish", MODE_CBC, DECRYPT, bf_cbc_dec_tv_template, BF_CBC_DEC_TEST_VECTORS);
746 test_cipher ("twofish", MODE_ECB, ENCRYPT, tf_enc_tv_template, TF_ENC_TEST_VECTORS);
747 test_cipher ("twofish", MODE_ECB, DECRYPT, tf_dec_tv_template, TF_DEC_TEST_VECTORS);
748 test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS);
749 test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS);
753 test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS);
754 test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS);
758 test_cipher ("aes", MODE_ECB, ENCRYPT, aes_enc_tv_template, AES_ENC_TEST_VECTORS);
759 test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS);
763 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
767 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
775 test_cipher ("cast5", MODE_ECB, ENCRYPT, cast5_enc_tv_template, CAST5_ENC_TEST_VECTORS);
776 test_cipher ("cast5", MODE_ECB, DECRYPT, cast5_dec_tv_template, CAST5_DEC_TEST_VECTORS);
780 test_cipher ("cast6", MODE_ECB, ENCRYPT, cast6_enc_tv_template, CAST6_ENC_TEST_VECTORS);
781 test_cipher ("cast6", MODE_ECB, DECRYPT, cast6_dec_tv_template, CAST6_DEC_TEST_VECTORS);
785 test_cipher ("arc4", MODE_ECB, ENCRYPT, arc4_enc_tv_template, ARC4_ENC_TEST_VECTORS);
786 test_cipher ("arc4", MODE_ECB, DECRYPT, arc4_dec_tv_template, ARC4_DEC_TEST_VECTORS);
790 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
798 test_cipher ("tea", MODE_ECB, ENCRYPT, tea_enc_tv_template, TEA_ENC_TEST_VECTORS);
799 test_cipher ("tea", MODE_ECB, DECRYPT, tea_dec_tv_template, TEA_DEC_TEST_VECTORS);
803 test_cipher ("xtea", MODE_ECB, ENCRYPT, xtea_enc_tv_template, XTEA_ENC_TEST_VECTORS);
804 test_cipher ("xtea", MODE_ECB, DECRYPT, xtea_dec_tv_template, XTEA_DEC_TEST_VECTORS);
808 test_cipher ("khazad", MODE_ECB, ENCRYPT, khazad_enc_tv_template, KHAZAD_ENC_TEST_VECTORS);
809 test_cipher ("khazad", MODE_ECB, DECRYPT, khazad_dec_tv_template, KHAZAD_DEC_TEST_VECTORS);
813 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
817 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
821 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
825 test_cipher ("tnepres", MODE_ECB, ENCRYPT, tnepres_enc_tv_template, TNEPRES_ENC_TEST_VECTORS);
826 test_cipher ("tnepres", MODE_ECB, DECRYPT, tnepres_dec_tv_template, TNEPRES_DEC_TEST_VECTORS);
830 test_cipher ("anubis", MODE_ECB, ENCRYPT, anubis_enc_tv_template, ANUBIS_ENC_TEST_VECTORS);
831 test_cipher ("anubis", MODE_ECB, DECRYPT, anubis_dec_tv_template, ANUBIS_DEC_TEST_VECTORS);
832 test_cipher ("anubis", MODE_CBC, ENCRYPT, anubis_cbc_enc_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
833 test_cipher ("anubis", MODE_CBC, DECRYPT, anubis_cbc_dec_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
837 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
842 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
846 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
849 #ifdef CONFIG_CRYPTO_HMAC
851 test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS);
855 test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS);
859 test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS);
869 /* useful for debugging */
870 printk("not testing anything\n");
875 static int __init init(void)
877 tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL);
881 xbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
895 * If an init function is provided, an exit function must also be provided
896 * to allow module unload.
898 static void __exit fini(void) { }
903 module_param(mode, int, 0);
905 MODULE_LICENSE("GPL");
906 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
907 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");