2 * Algorithm testing framework and tests.
4 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
5 * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
6 * Copyright (c) 2007 Nokia Siemens Networks
7 * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the Free
11 * Software Foundation; either version 2 of the License, or (at your option)
16 #include <crypto/hash.h>
17 #include <linux/err.h>
18 #include <linux/module.h>
19 #include <linux/scatterlist.h>
20 #include <linux/slab.h>
21 #include <linux/string.h>
27 * Need slab memory for testing (size in number of pages).
32 * Indexes into the xbuf to simulate cross-page access.
44 * Used by test_cipher()
49 struct tcrypt_result {
50 struct completion completion;
54 struct aead_test_suite {
56 struct aead_testvec *vecs;
61 struct cipher_test_suite {
63 struct cipher_testvec *vecs;
68 struct comp_test_suite {
70 struct comp_testvec *vecs;
75 struct hash_test_suite {
76 struct hash_testvec *vecs;
80 struct alg_test_desc {
82 int (*test)(const struct alg_test_desc *desc, const char *driver,
86 struct aead_test_suite aead;
87 struct cipher_test_suite cipher;
88 struct comp_test_suite comp;
89 struct hash_test_suite hash;
93 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
95 static char *xbuf[XBUFSIZE];
96 static char *axbuf[XBUFSIZE];
98 static void hexdump(unsigned char *buf, unsigned int len)
100 print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
105 static void tcrypt_complete(struct crypto_async_request *req, int err)
107 struct tcrypt_result *res = req->data;
109 if (err == -EINPROGRESS)
113 complete(&res->completion);
116 static int test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
119 const char *algo = crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm));
120 unsigned int i, j, k, temp;
121 struct scatterlist sg[8];
123 struct ahash_request *req;
124 struct tcrypt_result tresult;
128 init_completion(&tresult.completion);
130 req = ahash_request_alloc(tfm, GFP_KERNEL);
132 printk(KERN_ERR "alg: hash: Failed to allocate request for "
137 ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
138 tcrypt_complete, &tresult);
140 for (i = 0; i < tcount; i++) {
141 memset(result, 0, 64);
145 memcpy(hash_buff, template[i].plaintext, template[i].psize);
146 sg_init_one(&sg[0], hash_buff, template[i].psize);
148 if (template[i].ksize) {
149 crypto_ahash_clear_flags(tfm, ~0);
150 ret = crypto_ahash_setkey(tfm, template[i].key,
153 printk(KERN_ERR "alg: hash: setkey failed on "
154 "test %d for %s: ret=%d\n", i + 1, algo,
160 ahash_request_set_crypt(req, sg, result, template[i].psize);
161 ret = crypto_ahash_digest(req);
167 ret = wait_for_completion_interruptible(
168 &tresult.completion);
169 if (!ret && !(ret = tresult.err)) {
170 INIT_COMPLETION(tresult.completion);
175 printk(KERN_ERR "alg: hash: digest failed on test %d "
176 "for %s: ret=%d\n", i + 1, algo, -ret);
180 if (memcmp(result, template[i].digest,
181 crypto_ahash_digestsize(tfm))) {
182 printk(KERN_ERR "alg: hash: Test %d failed for %s\n",
184 hexdump(result, crypto_ahash_digestsize(tfm));
191 for (i = 0; i < tcount; i++) {
192 if (template[i].np) {
194 memset(result, 0, 64);
197 sg_init_table(sg, template[i].np);
198 for (k = 0; k < template[i].np; k++) {
200 memcpy(xbuf[IDX[k] >> PAGE_SHIFT] +
201 offset_in_page(IDX[k]),
202 template[i].plaintext + temp,
205 temp += template[i].tap[k];
208 if (template[i].ksize) {
209 crypto_ahash_clear_flags(tfm, ~0);
210 ret = crypto_ahash_setkey(tfm, template[i].key,
214 printk(KERN_ERR "alg: hash: setkey "
215 "failed on chunking test %d "
216 "for %s: ret=%d\n", j, algo,
222 ahash_request_set_crypt(req, sg, result,
224 ret = crypto_ahash_digest(req);
230 ret = wait_for_completion_interruptible(
231 &tresult.completion);
232 if (!ret && !(ret = tresult.err)) {
233 INIT_COMPLETION(tresult.completion);
238 printk(KERN_ERR "alg: hash: digest failed "
239 "on chunking test %d for %s: "
240 "ret=%d\n", j, algo, -ret);
244 if (memcmp(result, template[i].digest,
245 crypto_ahash_digestsize(tfm))) {
246 printk(KERN_ERR "alg: hash: Chunking test %d "
247 "failed for %s\n", j, algo);
248 hexdump(result, crypto_ahash_digestsize(tfm));
258 ahash_request_free(req);
263 static int test_aead(struct crypto_aead *tfm, int enc,
264 struct aead_testvec *template, unsigned int tcount)
266 const char *algo = crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm));
267 unsigned int i, j, k, n, temp;
271 struct aead_request *req;
272 struct scatterlist sg[8];
273 struct scatterlist asg[8];
275 struct tcrypt_result result;
276 unsigned int authsize;
286 init_completion(&result.completion);
288 req = aead_request_alloc(tfm, GFP_KERNEL);
290 printk(KERN_ERR "alg: aead: Failed to allocate request for "
296 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
297 tcrypt_complete, &result);
299 for (i = 0, j = 0; i < tcount; i++) {
300 if (!template[i].np) {
303 /* some tepmplates have no input data but they will
309 memcpy(input, template[i].input, template[i].ilen);
310 memcpy(assoc, template[i].assoc, template[i].alen);
312 memcpy(iv, template[i].iv, MAX_IVLEN);
314 memset(iv, 0, MAX_IVLEN);
316 crypto_aead_clear_flags(tfm, ~0);
318 crypto_aead_set_flags(
319 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
321 key = template[i].key;
323 ret = crypto_aead_setkey(tfm, key,
325 if (!ret == template[i].fail) {
326 printk(KERN_ERR "alg: aead: setkey failed on "
327 "test %d for %s: flags=%x\n", j, algo,
328 crypto_aead_get_flags(tfm));
333 authsize = abs(template[i].rlen - template[i].ilen);
334 ret = crypto_aead_setauthsize(tfm, authsize);
336 printk(KERN_ERR "alg: aead: Failed to set "
337 "authsize to %u on test %d for %s\n",
342 sg_init_one(&sg[0], input,
343 template[i].ilen + (enc ? authsize : 0));
345 sg_init_one(&asg[0], assoc, template[i].alen);
347 aead_request_set_crypt(req, sg, sg,
348 template[i].ilen, iv);
350 aead_request_set_assoc(req, asg, template[i].alen);
353 crypto_aead_encrypt(req) :
354 crypto_aead_decrypt(req);
361 ret = wait_for_completion_interruptible(
363 if (!ret && !(ret = result.err)) {
364 INIT_COMPLETION(result.completion);
369 printk(KERN_ERR "alg: aead: %s failed on test "
370 "%d for %s: ret=%d\n", e, j, algo, -ret);
375 if (memcmp(q, template[i].result, template[i].rlen)) {
376 printk(KERN_ERR "alg: aead: Test %d failed on "
377 "%s for %s\n", j, e, algo);
378 hexdump(q, template[i].rlen);
385 for (i = 0, j = 0; i < tcount; i++) {
386 if (template[i].np) {
390 memcpy(iv, template[i].iv, MAX_IVLEN);
392 memset(iv, 0, MAX_IVLEN);
394 crypto_aead_clear_flags(tfm, ~0);
396 crypto_aead_set_flags(
397 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
398 key = template[i].key;
400 ret = crypto_aead_setkey(tfm, key, template[i].klen);
401 if (!ret == template[i].fail) {
402 printk(KERN_ERR "alg: aead: setkey failed on "
403 "chunk test %d for %s: flags=%x\n", j,
404 algo, crypto_aead_get_flags(tfm));
409 authsize = abs(template[i].rlen - template[i].ilen);
412 sg_init_table(sg, template[i].np);
413 for (k = 0, temp = 0; k < template[i].np; k++) {
414 if (WARN_ON(offset_in_page(IDX[k]) +
415 template[i].tap[k] > PAGE_SIZE))
418 q = xbuf[IDX[k] >> PAGE_SHIFT] +
419 offset_in_page(IDX[k]);
421 memcpy(q, template[i].input + temp,
424 n = template[i].tap[k];
425 if (k == template[i].np - 1 && enc)
427 if (offset_in_page(q) + n < PAGE_SIZE)
430 sg_set_buf(&sg[k], q, template[i].tap[k]);
431 temp += template[i].tap[k];
434 ret = crypto_aead_setauthsize(tfm, authsize);
436 printk(KERN_ERR "alg: aead: Failed to set "
437 "authsize to %u on chunk test %d for "
438 "%s\n", authsize, j, algo);
443 if (WARN_ON(sg[k - 1].offset +
444 sg[k - 1].length + authsize >
450 sg[k - 1].length += authsize;
453 sg_init_table(asg, template[i].anp);
454 for (k = 0, temp = 0; k < template[i].anp; k++) {
456 memcpy(axbuf[IDX[k] >> PAGE_SHIFT] +
457 offset_in_page(IDX[k]),
458 template[i].assoc + temp,
459 template[i].atap[k]),
460 template[i].atap[k]);
461 temp += template[i].atap[k];
464 aead_request_set_crypt(req, sg, sg,
468 aead_request_set_assoc(req, asg, template[i].alen);
471 crypto_aead_encrypt(req) :
472 crypto_aead_decrypt(req);
479 ret = wait_for_completion_interruptible(
481 if (!ret && !(ret = result.err)) {
482 INIT_COMPLETION(result.completion);
487 printk(KERN_ERR "alg: aead: %s failed on "
488 "chunk test %d for %s: ret=%d\n", e, j,
494 for (k = 0, temp = 0; k < template[i].np; k++) {
495 q = xbuf[IDX[k] >> PAGE_SHIFT] +
496 offset_in_page(IDX[k]);
498 n = template[i].tap[k];
499 if (k == template[i].np - 1)
500 n += enc ? authsize : -authsize;
502 if (memcmp(q, template[i].result + temp, n)) {
503 printk(KERN_ERR "alg: aead: Chunk "
504 "test %d failed on %s at page "
505 "%u for %s\n", j, e, k, algo);
511 if (k == template[i].np - 1 && !enc) {
512 if (memcmp(q, template[i].input +
518 for (n = 0; offset_in_page(q + n) &&
523 printk(KERN_ERR "alg: aead: Result "
524 "buffer corruption in chunk "
525 "test %d on %s at page %u for "
526 "%s: %u bytes:\n", j, e, k,
532 temp += template[i].tap[k];
540 aead_request_free(req);
544 static int test_cipher(struct crypto_ablkcipher *tfm, int enc,
545 struct cipher_testvec *template, unsigned int tcount)
548 crypto_tfm_alg_driver_name(crypto_ablkcipher_tfm(tfm));
549 unsigned int i, j, k, n, temp;
552 struct ablkcipher_request *req;
553 struct scatterlist sg[8];
555 struct tcrypt_result result;
564 init_completion(&result.completion);
566 req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
568 printk(KERN_ERR "alg: cipher: Failed to allocate request for "
574 ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
575 tcrypt_complete, &result);
578 for (i = 0; i < tcount; i++) {
580 memcpy(iv, template[i].iv, MAX_IVLEN);
582 memset(iv, 0, MAX_IVLEN);
584 if (!(template[i].np)) {
588 memcpy(data, template[i].input, template[i].ilen);
590 crypto_ablkcipher_clear_flags(tfm, ~0);
592 crypto_ablkcipher_set_flags(
593 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
595 ret = crypto_ablkcipher_setkey(tfm, template[i].key,
597 if (!ret == template[i].fail) {
598 printk(KERN_ERR "alg: cipher: setkey failed "
599 "on test %d for %s: flags=%x\n", j,
600 algo, crypto_ablkcipher_get_flags(tfm));
605 sg_init_one(&sg[0], data, template[i].ilen);
607 ablkcipher_request_set_crypt(req, sg, sg,
608 template[i].ilen, iv);
610 crypto_ablkcipher_encrypt(req) :
611 crypto_ablkcipher_decrypt(req);
618 ret = wait_for_completion_interruptible(
620 if (!ret && !((ret = result.err))) {
621 INIT_COMPLETION(result.completion);
626 printk(KERN_ERR "alg: cipher: %s failed on "
627 "test %d for %s: ret=%d\n", e, j, algo,
633 if (memcmp(q, template[i].result, template[i].rlen)) {
634 printk(KERN_ERR "alg: cipher: Test %d failed "
635 "on %s for %s\n", j, e, algo);
636 hexdump(q, template[i].rlen);
644 for (i = 0; i < tcount; i++) {
647 memcpy(iv, template[i].iv, MAX_IVLEN);
649 memset(iv, 0, MAX_IVLEN);
651 if (template[i].np) {
654 crypto_ablkcipher_clear_flags(tfm, ~0);
656 crypto_ablkcipher_set_flags(
657 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
659 ret = crypto_ablkcipher_setkey(tfm, template[i].key,
661 if (!ret == template[i].fail) {
662 printk(KERN_ERR "alg: cipher: setkey failed "
663 "on chunk test %d for %s: flags=%x\n",
665 crypto_ablkcipher_get_flags(tfm));
672 sg_init_table(sg, template[i].np);
673 for (k = 0; k < template[i].np; k++) {
674 if (WARN_ON(offset_in_page(IDX[k]) +
675 template[i].tap[k] > PAGE_SIZE))
678 q = xbuf[IDX[k] >> PAGE_SHIFT] +
679 offset_in_page(IDX[k]);
681 memcpy(q, template[i].input + temp,
684 if (offset_in_page(q) + template[i].tap[k] <
686 q[template[i].tap[k]] = 0;
688 sg_set_buf(&sg[k], q, template[i].tap[k]);
690 temp += template[i].tap[k];
693 ablkcipher_request_set_crypt(req, sg, sg,
694 template[i].ilen, iv);
697 crypto_ablkcipher_encrypt(req) :
698 crypto_ablkcipher_decrypt(req);
705 ret = wait_for_completion_interruptible(
707 if (!ret && !((ret = result.err))) {
708 INIT_COMPLETION(result.completion);
713 printk(KERN_ERR "alg: cipher: %s failed on "
714 "chunk test %d for %s: ret=%d\n", e, j,
721 for (k = 0; k < template[i].np; k++) {
722 q = xbuf[IDX[k] >> PAGE_SHIFT] +
723 offset_in_page(IDX[k]);
725 if (memcmp(q, template[i].result + temp,
726 template[i].tap[k])) {
727 printk(KERN_ERR "alg: cipher: Chunk "
728 "test %d failed on %s at page "
729 "%u for %s\n", j, e, k, algo);
730 hexdump(q, template[i].tap[k]);
734 q += template[i].tap[k];
735 for (n = 0; offset_in_page(q + n) && q[n]; n++)
738 printk(KERN_ERR "alg: cipher: "
739 "Result buffer corruption in "
740 "chunk test %d on %s at page "
741 "%u for %s: %u bytes:\n", j, e,
746 temp += template[i].tap[k];
754 ablkcipher_request_free(req);
758 static int test_comp(struct crypto_comp *tfm, struct comp_testvec *ctemplate,
759 struct comp_testvec *dtemplate, int ctcount, int dtcount)
761 const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
763 char result[COMP_BUF_SIZE];
766 for (i = 0; i < ctcount; i++) {
767 int ilen, dlen = COMP_BUF_SIZE;
769 memset(result, 0, sizeof (result));
771 ilen = ctemplate[i].inlen;
772 ret = crypto_comp_compress(tfm, ctemplate[i].input,
773 ilen, result, &dlen);
775 printk(KERN_ERR "alg: comp: compression failed "
776 "on test %d for %s: ret=%d\n", i + 1, algo,
781 if (memcmp(result, ctemplate[i].output, dlen)) {
782 printk(KERN_ERR "alg: comp: Compression test %d "
783 "failed for %s\n", i + 1, algo);
784 hexdump(result, dlen);
790 for (i = 0; i < dtcount; i++) {
791 int ilen, ret, dlen = COMP_BUF_SIZE;
793 memset(result, 0, sizeof (result));
795 ilen = dtemplate[i].inlen;
796 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
797 ilen, result, &dlen);
799 printk(KERN_ERR "alg: comp: decompression failed "
800 "on test %d for %s: ret=%d\n", i + 1, algo,
805 if (memcmp(result, dtemplate[i].output, dlen)) {
806 printk(KERN_ERR "alg: comp: Decompression test %d "
807 "failed for %s\n", i + 1, algo);
808 hexdump(result, dlen);
820 static int alg_test_aead(const struct alg_test_desc *desc, const char *driver,
823 struct crypto_aead *tfm;
826 tfm = crypto_alloc_aead(driver, type, mask);
828 printk(KERN_ERR "alg: aead: Failed to load transform for %s: "
829 "%ld\n", driver, PTR_ERR(tfm));
833 if (desc->suite.aead.enc.vecs) {
834 err = test_aead(tfm, ENCRYPT, desc->suite.aead.enc.vecs,
835 desc->suite.aead.enc.count);
840 if (!err && desc->suite.aead.dec.vecs)
841 err = test_aead(tfm, DECRYPT, desc->suite.aead.dec.vecs,
842 desc->suite.aead.dec.count);
845 crypto_free_aead(tfm);
849 static int alg_test_cipher(const struct alg_test_desc *desc,
850 const char *driver, u32 type, u32 mask)
852 struct crypto_ablkcipher *tfm;
855 tfm = crypto_alloc_ablkcipher(driver, type, mask);
857 printk(KERN_ERR "alg: cipher: Failed to load transform for "
858 "%s: %ld\n", driver, PTR_ERR(tfm));
862 if (desc->suite.cipher.enc.vecs) {
863 err = test_cipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
864 desc->suite.cipher.enc.count);
869 if (desc->suite.cipher.dec.vecs)
870 err = test_cipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
871 desc->suite.cipher.dec.count);
874 crypto_free_ablkcipher(tfm);
878 static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
881 struct crypto_comp *tfm;
884 tfm = crypto_alloc_comp(driver, type, mask);
886 printk(KERN_ERR "alg: comp: Failed to load transform for %s: "
887 "%ld\n", driver, PTR_ERR(tfm));
891 err = test_comp(tfm, desc->suite.comp.comp.vecs,
892 desc->suite.comp.decomp.vecs,
893 desc->suite.comp.comp.count,
894 desc->suite.comp.decomp.count);
896 crypto_free_comp(tfm);
900 static int alg_test_hash(const struct alg_test_desc *desc, const char *driver,
903 struct crypto_ahash *tfm;
906 tfm = crypto_alloc_ahash(driver, type, mask);
908 printk(KERN_ERR "alg: hash: Failed to load transform for %s: "
909 "%ld\n", driver, PTR_ERR(tfm));
913 err = test_hash(tfm, desc->suite.hash.vecs, desc->suite.hash.count);
915 crypto_free_ahash(tfm);
919 /* Please keep this list sorted by algorithm name. */
920 static const struct alg_test_desc alg_test_descs[] = {
923 .test = alg_test_cipher,
927 .vecs = aes_cbc_enc_tv_template,
928 .count = AES_CBC_ENC_TEST_VECTORS
931 .vecs = aes_cbc_dec_tv_template,
932 .count = AES_CBC_DEC_TEST_VECTORS
937 .alg = "cbc(anubis)",
938 .test = alg_test_cipher,
942 .vecs = anubis_cbc_enc_tv_template,
943 .count = ANUBIS_CBC_ENC_TEST_VECTORS
946 .vecs = anubis_cbc_dec_tv_template,
947 .count = ANUBIS_CBC_DEC_TEST_VECTORS
952 .alg = "cbc(blowfish)",
953 .test = alg_test_cipher,
957 .vecs = bf_cbc_enc_tv_template,
958 .count = BF_CBC_ENC_TEST_VECTORS
961 .vecs = bf_cbc_dec_tv_template,
962 .count = BF_CBC_DEC_TEST_VECTORS
967 .alg = "cbc(camellia)",
968 .test = alg_test_cipher,
972 .vecs = camellia_cbc_enc_tv_template,
973 .count = CAMELLIA_CBC_ENC_TEST_VECTORS
976 .vecs = camellia_cbc_dec_tv_template,
977 .count = CAMELLIA_CBC_DEC_TEST_VECTORS
983 .test = alg_test_cipher,
987 .vecs = des_cbc_enc_tv_template,
988 .count = DES_CBC_ENC_TEST_VECTORS
991 .vecs = des_cbc_dec_tv_template,
992 .count = DES_CBC_DEC_TEST_VECTORS
997 .alg = "cbc(des3_ede)",
998 .test = alg_test_cipher,
1002 .vecs = des3_ede_cbc_enc_tv_template,
1003 .count = DES3_EDE_CBC_ENC_TEST_VECTORS
1006 .vecs = des3_ede_cbc_dec_tv_template,
1007 .count = DES3_EDE_CBC_DEC_TEST_VECTORS
1012 .alg = "cbc(twofish)",
1013 .test = alg_test_cipher,
1017 .vecs = tf_cbc_enc_tv_template,
1018 .count = TF_CBC_ENC_TEST_VECTORS
1021 .vecs = tf_cbc_dec_tv_template,
1022 .count = TF_CBC_DEC_TEST_VECTORS
1028 .test = alg_test_aead,
1032 .vecs = aes_ccm_enc_tv_template,
1033 .count = AES_CCM_ENC_TEST_VECTORS
1036 .vecs = aes_ccm_dec_tv_template,
1037 .count = AES_CCM_DEC_TEST_VECTORS
1043 .test = alg_test_hash,
1046 .vecs = crc32c_tv_template,
1047 .count = CRC32C_TEST_VECTORS
1051 .alg = "cts(cbc(aes))",
1052 .test = alg_test_cipher,
1056 .vecs = cts_mode_enc_tv_template,
1057 .count = CTS_MODE_ENC_TEST_VECTORS
1060 .vecs = cts_mode_dec_tv_template,
1061 .count = CTS_MODE_DEC_TEST_VECTORS
1067 .test = alg_test_comp,
1071 .vecs = deflate_comp_tv_template,
1072 .count = DEFLATE_COMP_TEST_VECTORS
1075 .vecs = deflate_decomp_tv_template,
1076 .count = DEFLATE_DECOMP_TEST_VECTORS
1082 .test = alg_test_cipher,
1086 .vecs = aes_enc_tv_template,
1087 .count = AES_ENC_TEST_VECTORS
1090 .vecs = aes_dec_tv_template,
1091 .count = AES_DEC_TEST_VECTORS
1096 .alg = "ecb(anubis)",
1097 .test = alg_test_cipher,
1101 .vecs = anubis_enc_tv_template,
1102 .count = ANUBIS_ENC_TEST_VECTORS
1105 .vecs = anubis_dec_tv_template,
1106 .count = ANUBIS_DEC_TEST_VECTORS
1112 .test = alg_test_cipher,
1116 .vecs = arc4_enc_tv_template,
1117 .count = ARC4_ENC_TEST_VECTORS
1120 .vecs = arc4_dec_tv_template,
1121 .count = ARC4_DEC_TEST_VECTORS
1126 .alg = "ecb(blowfish)",
1127 .test = alg_test_cipher,
1131 .vecs = bf_enc_tv_template,
1132 .count = BF_ENC_TEST_VECTORS
1135 .vecs = bf_dec_tv_template,
1136 .count = BF_DEC_TEST_VECTORS
1141 .alg = "ecb(camellia)",
1142 .test = alg_test_cipher,
1146 .vecs = camellia_enc_tv_template,
1147 .count = CAMELLIA_ENC_TEST_VECTORS
1150 .vecs = camellia_dec_tv_template,
1151 .count = CAMELLIA_DEC_TEST_VECTORS
1156 .alg = "ecb(cast5)",
1157 .test = alg_test_cipher,
1161 .vecs = cast5_enc_tv_template,
1162 .count = CAST5_ENC_TEST_VECTORS
1165 .vecs = cast5_dec_tv_template,
1166 .count = CAST5_DEC_TEST_VECTORS
1171 .alg = "ecb(cast6)",
1172 .test = alg_test_cipher,
1176 .vecs = cast6_enc_tv_template,
1177 .count = CAST6_ENC_TEST_VECTORS
1180 .vecs = cast6_dec_tv_template,
1181 .count = CAST6_DEC_TEST_VECTORS
1187 .test = alg_test_cipher,
1191 .vecs = des_enc_tv_template,
1192 .count = DES_ENC_TEST_VECTORS
1195 .vecs = des_dec_tv_template,
1196 .count = DES_DEC_TEST_VECTORS
1201 .alg = "ecb(des3_ede)",
1202 .test = alg_test_cipher,
1206 .vecs = des3_ede_enc_tv_template,
1207 .count = DES3_EDE_ENC_TEST_VECTORS
1210 .vecs = des3_ede_dec_tv_template,
1211 .count = DES3_EDE_DEC_TEST_VECTORS
1216 .alg = "ecb(khazad)",
1217 .test = alg_test_cipher,
1221 .vecs = khazad_enc_tv_template,
1222 .count = KHAZAD_ENC_TEST_VECTORS
1225 .vecs = khazad_dec_tv_template,
1226 .count = KHAZAD_DEC_TEST_VECTORS
1232 .test = alg_test_cipher,
1236 .vecs = seed_enc_tv_template,
1237 .count = SEED_ENC_TEST_VECTORS
1240 .vecs = seed_dec_tv_template,
1241 .count = SEED_DEC_TEST_VECTORS
1246 .alg = "ecb(serpent)",
1247 .test = alg_test_cipher,
1251 .vecs = serpent_enc_tv_template,
1252 .count = SERPENT_ENC_TEST_VECTORS
1255 .vecs = serpent_dec_tv_template,
1256 .count = SERPENT_DEC_TEST_VECTORS
1262 .test = alg_test_cipher,
1266 .vecs = tea_enc_tv_template,
1267 .count = TEA_ENC_TEST_VECTORS
1270 .vecs = tea_dec_tv_template,
1271 .count = TEA_DEC_TEST_VECTORS
1276 .alg = "ecb(tnepres)",
1277 .test = alg_test_cipher,
1281 .vecs = tnepres_enc_tv_template,
1282 .count = TNEPRES_ENC_TEST_VECTORS
1285 .vecs = tnepres_dec_tv_template,
1286 .count = TNEPRES_DEC_TEST_VECTORS
1291 .alg = "ecb(twofish)",
1292 .test = alg_test_cipher,
1296 .vecs = tf_enc_tv_template,
1297 .count = TF_ENC_TEST_VECTORS
1300 .vecs = tf_dec_tv_template,
1301 .count = TF_DEC_TEST_VECTORS
1307 .test = alg_test_cipher,
1311 .vecs = xeta_enc_tv_template,
1312 .count = XETA_ENC_TEST_VECTORS
1315 .vecs = xeta_dec_tv_template,
1316 .count = XETA_DEC_TEST_VECTORS
1322 .test = alg_test_cipher,
1326 .vecs = xtea_enc_tv_template,
1327 .count = XTEA_ENC_TEST_VECTORS
1330 .vecs = xtea_dec_tv_template,
1331 .count = XTEA_DEC_TEST_VECTORS
1337 .test = alg_test_aead,
1341 .vecs = aes_gcm_enc_tv_template,
1342 .count = AES_GCM_ENC_TEST_VECTORS
1345 .vecs = aes_gcm_dec_tv_template,
1346 .count = AES_GCM_DEC_TEST_VECTORS
1352 .test = alg_test_hash,
1355 .vecs = hmac_md5_tv_template,
1356 .count = HMAC_MD5_TEST_VECTORS
1360 .alg = "hmac(rmd128)",
1361 .test = alg_test_hash,
1364 .vecs = hmac_rmd128_tv_template,
1365 .count = HMAC_RMD128_TEST_VECTORS
1369 .alg = "hmac(rmd160)",
1370 .test = alg_test_hash,
1373 .vecs = hmac_rmd160_tv_template,
1374 .count = HMAC_RMD160_TEST_VECTORS
1378 .alg = "hmac(sha1)",
1379 .test = alg_test_hash,
1382 .vecs = hmac_sha1_tv_template,
1383 .count = HMAC_SHA1_TEST_VECTORS
1387 .alg = "hmac(sha224)",
1388 .test = alg_test_hash,
1391 .vecs = hmac_sha224_tv_template,
1392 .count = HMAC_SHA224_TEST_VECTORS
1396 .alg = "hmac(sha256)",
1397 .test = alg_test_hash,
1400 .vecs = hmac_sha256_tv_template,
1401 .count = HMAC_SHA256_TEST_VECTORS
1405 .alg = "hmac(sha384)",
1406 .test = alg_test_hash,
1409 .vecs = hmac_sha384_tv_template,
1410 .count = HMAC_SHA384_TEST_VECTORS
1414 .alg = "hmac(sha512)",
1415 .test = alg_test_hash,
1418 .vecs = hmac_sha512_tv_template,
1419 .count = HMAC_SHA512_TEST_VECTORS
1424 .test = alg_test_cipher,
1428 .vecs = aes_lrw_enc_tv_template,
1429 .count = AES_LRW_ENC_TEST_VECTORS
1432 .vecs = aes_lrw_dec_tv_template,
1433 .count = AES_LRW_DEC_TEST_VECTORS
1439 .test = alg_test_comp,
1443 .vecs = lzo_comp_tv_template,
1444 .count = LZO_COMP_TEST_VECTORS
1447 .vecs = lzo_decomp_tv_template,
1448 .count = LZO_DECOMP_TEST_VECTORS
1454 .test = alg_test_hash,
1457 .vecs = md4_tv_template,
1458 .count = MD4_TEST_VECTORS
1463 .test = alg_test_hash,
1466 .vecs = md5_tv_template,
1467 .count = MD5_TEST_VECTORS
1471 .alg = "michael_mic",
1472 .test = alg_test_hash,
1475 .vecs = michael_mic_tv_template,
1476 .count = MICHAEL_MIC_TEST_VECTORS
1480 .alg = "pcbc(fcrypt)",
1481 .test = alg_test_cipher,
1485 .vecs = fcrypt_pcbc_enc_tv_template,
1486 .count = FCRYPT_ENC_TEST_VECTORS
1489 .vecs = fcrypt_pcbc_dec_tv_template,
1490 .count = FCRYPT_DEC_TEST_VECTORS
1495 .alg = "rfc3686(ctr(aes))",
1496 .test = alg_test_cipher,
1500 .vecs = aes_ctr_enc_tv_template,
1501 .count = AES_CTR_ENC_TEST_VECTORS
1504 .vecs = aes_ctr_dec_tv_template,
1505 .count = AES_CTR_DEC_TEST_VECTORS
1511 .test = alg_test_hash,
1514 .vecs = rmd128_tv_template,
1515 .count = RMD128_TEST_VECTORS
1520 .test = alg_test_hash,
1523 .vecs = rmd160_tv_template,
1524 .count = RMD160_TEST_VECTORS
1529 .test = alg_test_hash,
1532 .vecs = rmd256_tv_template,
1533 .count = RMD256_TEST_VECTORS
1538 .test = alg_test_hash,
1541 .vecs = rmd320_tv_template,
1542 .count = RMD320_TEST_VECTORS
1547 .test = alg_test_cipher,
1551 .vecs = salsa20_stream_enc_tv_template,
1552 .count = SALSA20_STREAM_ENC_TEST_VECTORS
1558 .test = alg_test_hash,
1561 .vecs = sha1_tv_template,
1562 .count = SHA1_TEST_VECTORS
1567 .test = alg_test_hash,
1570 .vecs = sha224_tv_template,
1571 .count = SHA224_TEST_VECTORS
1576 .test = alg_test_hash,
1579 .vecs = sha256_tv_template,
1580 .count = SHA256_TEST_VECTORS
1585 .test = alg_test_hash,
1588 .vecs = sha384_tv_template,
1589 .count = SHA384_TEST_VECTORS
1594 .test = alg_test_hash,
1597 .vecs = sha512_tv_template,
1598 .count = SHA512_TEST_VECTORS
1603 .test = alg_test_hash,
1606 .vecs = tgr128_tv_template,
1607 .count = TGR128_TEST_VECTORS
1612 .test = alg_test_hash,
1615 .vecs = tgr160_tv_template,
1616 .count = TGR160_TEST_VECTORS
1621 .test = alg_test_hash,
1624 .vecs = tgr192_tv_template,
1625 .count = TGR192_TEST_VECTORS
1630 .test = alg_test_hash,
1633 .vecs = wp256_tv_template,
1634 .count = WP256_TEST_VECTORS
1639 .test = alg_test_hash,
1642 .vecs = wp384_tv_template,
1643 .count = WP384_TEST_VECTORS
1648 .test = alg_test_hash,
1651 .vecs = wp512_tv_template,
1652 .count = WP512_TEST_VECTORS
1657 .test = alg_test_hash,
1660 .vecs = aes_xcbc128_tv_template,
1661 .count = XCBC_AES_TEST_VECTORS
1666 .test = alg_test_cipher,
1670 .vecs = aes_xts_enc_tv_template,
1671 .count = AES_XTS_ENC_TEST_VECTORS
1674 .vecs = aes_xts_dec_tv_template,
1675 .count = AES_XTS_DEC_TEST_VECTORS
1682 int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
1685 int end = ARRAY_SIZE(alg_test_descs);
1687 while (start < end) {
1688 int i = (start + end) / 2;
1689 int diff = strcmp(alg_test_descs[i].alg, alg);
1701 return alg_test_descs[i].test(alg_test_descs + i, driver,
1705 printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
1708 EXPORT_SYMBOL_GPL(alg_test);
1710 int __init testmgr_init(void)
1714 for (i = 0; i < XBUFSIZE; i++) {
1715 xbuf[i] = (void *)__get_free_page(GFP_KERNEL);
1720 for (i = 0; i < XBUFSIZE; i++) {
1721 axbuf[i] = (void *)__get_free_page(GFP_KERNEL);
1723 goto err_free_axbuf;
1729 for (i = 0; i < XBUFSIZE && axbuf[i]; i++)
1730 free_page((unsigned long)axbuf[i]);
1732 for (i = 0; i < XBUFSIZE && xbuf[i]; i++)
1733 free_page((unsigned long)xbuf[i]);
1738 void testmgr_exit(void)
1742 for (i = 0; i < XBUFSIZE; i++)
1743 free_page((unsigned long)axbuf[i]);
1744 for (i = 0; i < XBUFSIZE; i++)
1745 free_page((unsigned long)xbuf[i]);