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_cipher *tfm, int enc,
545 struct cipher_testvec *template, unsigned int tcount)
547 const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm));
548 unsigned int i, j, k;
560 for (i = 0; i < tcount; i++) {
567 memcpy(data, template[i].input, template[i].ilen);
569 crypto_cipher_clear_flags(tfm, ~0);
571 crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
573 ret = crypto_cipher_setkey(tfm, template[i].key,
575 if (!ret == template[i].fail) {
576 printk(KERN_ERR "alg: cipher: setkey failed "
577 "on test %d for %s: flags=%x\n", j,
578 algo, crypto_cipher_get_flags(tfm));
583 for (k = 0; k < template[i].ilen;
584 k += crypto_cipher_blocksize(tfm)) {
586 crypto_cipher_encrypt_one(tfm, data + k,
589 crypto_cipher_decrypt_one(tfm, data + k,
594 if (memcmp(q, template[i].result, template[i].rlen)) {
595 printk(KERN_ERR "alg: cipher: Test %d failed "
596 "on %s for %s\n", j, e, algo);
597 hexdump(q, template[i].rlen);
609 static int test_skcipher(struct crypto_ablkcipher *tfm, int enc,
610 struct cipher_testvec *template, unsigned int tcount)
613 crypto_tfm_alg_driver_name(crypto_ablkcipher_tfm(tfm));
614 unsigned int i, j, k, n, temp;
617 struct ablkcipher_request *req;
618 struct scatterlist sg[8];
620 struct tcrypt_result result;
629 init_completion(&result.completion);
631 req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
633 printk(KERN_ERR "alg: skcipher: Failed to allocate request "
639 ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
640 tcrypt_complete, &result);
643 for (i = 0; i < tcount; i++) {
645 memcpy(iv, template[i].iv, MAX_IVLEN);
647 memset(iv, 0, MAX_IVLEN);
649 if (!(template[i].np)) {
653 memcpy(data, template[i].input, template[i].ilen);
655 crypto_ablkcipher_clear_flags(tfm, ~0);
657 crypto_ablkcipher_set_flags(
658 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
660 ret = crypto_ablkcipher_setkey(tfm, template[i].key,
662 if (!ret == template[i].fail) {
663 printk(KERN_ERR "alg: skcipher: setkey failed "
664 "on test %d for %s: flags=%x\n", j,
665 algo, crypto_ablkcipher_get_flags(tfm));
670 sg_init_one(&sg[0], data, template[i].ilen);
672 ablkcipher_request_set_crypt(req, sg, sg,
673 template[i].ilen, iv);
675 crypto_ablkcipher_encrypt(req) :
676 crypto_ablkcipher_decrypt(req);
683 ret = wait_for_completion_interruptible(
685 if (!ret && !((ret = result.err))) {
686 INIT_COMPLETION(result.completion);
691 printk(KERN_ERR "alg: skcipher: %s failed on "
692 "test %d for %s: ret=%d\n", e, j, algo,
698 if (memcmp(q, template[i].result, template[i].rlen)) {
699 printk(KERN_ERR "alg: skcipher: Test %d "
700 "failed on %s for %s\n", j, e, algo);
701 hexdump(q, template[i].rlen);
709 for (i = 0; i < tcount; i++) {
712 memcpy(iv, template[i].iv, MAX_IVLEN);
714 memset(iv, 0, MAX_IVLEN);
716 if (template[i].np) {
719 crypto_ablkcipher_clear_flags(tfm, ~0);
721 crypto_ablkcipher_set_flags(
722 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
724 ret = crypto_ablkcipher_setkey(tfm, template[i].key,
726 if (!ret == template[i].fail) {
727 printk(KERN_ERR "alg: skcipher: setkey failed "
728 "on chunk test %d for %s: flags=%x\n",
730 crypto_ablkcipher_get_flags(tfm));
737 sg_init_table(sg, template[i].np);
738 for (k = 0; k < template[i].np; k++) {
739 if (WARN_ON(offset_in_page(IDX[k]) +
740 template[i].tap[k] > PAGE_SIZE))
743 q = xbuf[IDX[k] >> PAGE_SHIFT] +
744 offset_in_page(IDX[k]);
746 memcpy(q, template[i].input + temp,
749 if (offset_in_page(q) + template[i].tap[k] <
751 q[template[i].tap[k]] = 0;
753 sg_set_buf(&sg[k], q, template[i].tap[k]);
755 temp += template[i].tap[k];
758 ablkcipher_request_set_crypt(req, sg, sg,
759 template[i].ilen, iv);
762 crypto_ablkcipher_encrypt(req) :
763 crypto_ablkcipher_decrypt(req);
770 ret = wait_for_completion_interruptible(
772 if (!ret && !((ret = result.err))) {
773 INIT_COMPLETION(result.completion);
778 printk(KERN_ERR "alg: skcipher: %s failed on "
779 "chunk test %d for %s: ret=%d\n", e, j,
786 for (k = 0; k < template[i].np; k++) {
787 q = xbuf[IDX[k] >> PAGE_SHIFT] +
788 offset_in_page(IDX[k]);
790 if (memcmp(q, template[i].result + temp,
791 template[i].tap[k])) {
792 printk(KERN_ERR "alg: skcipher: Chunk "
793 "test %d failed on %s at page "
794 "%u for %s\n", j, e, k, algo);
795 hexdump(q, template[i].tap[k]);
799 q += template[i].tap[k];
800 for (n = 0; offset_in_page(q + n) && q[n]; n++)
803 printk(KERN_ERR "alg: skcipher: "
804 "Result buffer corruption in "
805 "chunk test %d on %s at page "
806 "%u for %s: %u bytes:\n", j, e,
811 temp += template[i].tap[k];
819 ablkcipher_request_free(req);
823 static int test_comp(struct crypto_comp *tfm, struct comp_testvec *ctemplate,
824 struct comp_testvec *dtemplate, int ctcount, int dtcount)
826 const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
828 char result[COMP_BUF_SIZE];
831 for (i = 0; i < ctcount; i++) {
832 int ilen, dlen = COMP_BUF_SIZE;
834 memset(result, 0, sizeof (result));
836 ilen = ctemplate[i].inlen;
837 ret = crypto_comp_compress(tfm, ctemplate[i].input,
838 ilen, result, &dlen);
840 printk(KERN_ERR "alg: comp: compression failed "
841 "on test %d for %s: ret=%d\n", i + 1, algo,
846 if (memcmp(result, ctemplate[i].output, dlen)) {
847 printk(KERN_ERR "alg: comp: Compression test %d "
848 "failed for %s\n", i + 1, algo);
849 hexdump(result, dlen);
855 for (i = 0; i < dtcount; i++) {
856 int ilen, dlen = COMP_BUF_SIZE;
858 memset(result, 0, sizeof (result));
860 ilen = dtemplate[i].inlen;
861 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
862 ilen, result, &dlen);
864 printk(KERN_ERR "alg: comp: decompression failed "
865 "on test %d for %s: ret=%d\n", i + 1, algo,
870 if (memcmp(result, dtemplate[i].output, dlen)) {
871 printk(KERN_ERR "alg: comp: Decompression test %d "
872 "failed for %s\n", i + 1, algo);
873 hexdump(result, dlen);
885 static int alg_test_aead(const struct alg_test_desc *desc, const char *driver,
888 struct crypto_aead *tfm;
891 tfm = crypto_alloc_aead(driver, type, mask);
893 printk(KERN_ERR "alg: aead: Failed to load transform for %s: "
894 "%ld\n", driver, PTR_ERR(tfm));
898 if (desc->suite.aead.enc.vecs) {
899 err = test_aead(tfm, ENCRYPT, desc->suite.aead.enc.vecs,
900 desc->suite.aead.enc.count);
905 if (!err && desc->suite.aead.dec.vecs)
906 err = test_aead(tfm, DECRYPT, desc->suite.aead.dec.vecs,
907 desc->suite.aead.dec.count);
910 crypto_free_aead(tfm);
914 static int alg_test_cipher(const struct alg_test_desc *desc,
915 const char *driver, u32 type, u32 mask)
917 struct crypto_cipher *tfm;
920 tfm = crypto_alloc_cipher(driver, type, mask);
922 printk(KERN_ERR "alg: cipher: Failed to load transform for "
923 "%s: %ld\n", driver, PTR_ERR(tfm));
927 if (desc->suite.cipher.enc.vecs) {
928 err = test_cipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
929 desc->suite.cipher.enc.count);
934 if (desc->suite.cipher.dec.vecs)
935 err = test_cipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
936 desc->suite.cipher.dec.count);
939 crypto_free_cipher(tfm);
943 static int alg_test_skcipher(const struct alg_test_desc *desc,
944 const char *driver, u32 type, u32 mask)
946 struct crypto_ablkcipher *tfm;
949 tfm = crypto_alloc_ablkcipher(driver, type, mask);
951 printk(KERN_ERR "alg: skcipher: Failed to load transform for "
952 "%s: %ld\n", driver, PTR_ERR(tfm));
956 if (desc->suite.cipher.enc.vecs) {
957 err = test_skcipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
958 desc->suite.cipher.enc.count);
963 if (desc->suite.cipher.dec.vecs)
964 err = test_skcipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
965 desc->suite.cipher.dec.count);
968 crypto_free_ablkcipher(tfm);
972 static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
975 struct crypto_comp *tfm;
978 tfm = crypto_alloc_comp(driver, type, mask);
980 printk(KERN_ERR "alg: comp: Failed to load transform for %s: "
981 "%ld\n", driver, PTR_ERR(tfm));
985 err = test_comp(tfm, desc->suite.comp.comp.vecs,
986 desc->suite.comp.decomp.vecs,
987 desc->suite.comp.comp.count,
988 desc->suite.comp.decomp.count);
990 crypto_free_comp(tfm);
994 static int alg_test_hash(const struct alg_test_desc *desc, const char *driver,
997 struct crypto_ahash *tfm;
1000 tfm = crypto_alloc_ahash(driver, type, mask);
1002 printk(KERN_ERR "alg: hash: Failed to load transform for %s: "
1003 "%ld\n", driver, PTR_ERR(tfm));
1004 return PTR_ERR(tfm);
1007 err = test_hash(tfm, desc->suite.hash.vecs, desc->suite.hash.count);
1009 crypto_free_ahash(tfm);
1013 static int alg_test_crc32c(const struct alg_test_desc *desc,
1014 const char *driver, u32 type, u32 mask)
1016 struct crypto_shash *tfm;
1020 err = alg_test_hash(desc, driver, type, mask);
1024 tfm = crypto_alloc_shash(driver, type, mask);
1026 printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: "
1027 "%ld\n", driver, PTR_ERR(tfm));
1034 struct shash_desc shash;
1035 char ctx[crypto_shash_descsize(tfm)];
1038 sdesc.shash.tfm = tfm;
1039 sdesc.shash.flags = 0;
1041 *(u32 *)sdesc.ctx = le32_to_cpu(420553207);
1042 err = crypto_shash_final(&sdesc.shash, (u8 *)&val);
1044 printk(KERN_ERR "alg: crc32c: Operation failed for "
1045 "%s: %d\n", driver, err);
1049 if (val != ~420553207) {
1050 printk(KERN_ERR "alg: crc32c: Test failed for %s: "
1051 "%d\n", driver, val);
1056 crypto_free_shash(tfm);
1062 /* Please keep this list sorted by algorithm name. */
1063 static const struct alg_test_desc alg_test_descs[] = {
1066 .test = alg_test_skcipher,
1070 .vecs = aes_cbc_enc_tv_template,
1071 .count = AES_CBC_ENC_TEST_VECTORS
1074 .vecs = aes_cbc_dec_tv_template,
1075 .count = AES_CBC_DEC_TEST_VECTORS
1080 .alg = "cbc(anubis)",
1081 .test = alg_test_skcipher,
1085 .vecs = anubis_cbc_enc_tv_template,
1086 .count = ANUBIS_CBC_ENC_TEST_VECTORS
1089 .vecs = anubis_cbc_dec_tv_template,
1090 .count = ANUBIS_CBC_DEC_TEST_VECTORS
1095 .alg = "cbc(blowfish)",
1096 .test = alg_test_skcipher,
1100 .vecs = bf_cbc_enc_tv_template,
1101 .count = BF_CBC_ENC_TEST_VECTORS
1104 .vecs = bf_cbc_dec_tv_template,
1105 .count = BF_CBC_DEC_TEST_VECTORS
1110 .alg = "cbc(camellia)",
1111 .test = alg_test_skcipher,
1115 .vecs = camellia_cbc_enc_tv_template,
1116 .count = CAMELLIA_CBC_ENC_TEST_VECTORS
1119 .vecs = camellia_cbc_dec_tv_template,
1120 .count = CAMELLIA_CBC_DEC_TEST_VECTORS
1126 .test = alg_test_skcipher,
1130 .vecs = des_cbc_enc_tv_template,
1131 .count = DES_CBC_ENC_TEST_VECTORS
1134 .vecs = des_cbc_dec_tv_template,
1135 .count = DES_CBC_DEC_TEST_VECTORS
1140 .alg = "cbc(des3_ede)",
1141 .test = alg_test_skcipher,
1145 .vecs = des3_ede_cbc_enc_tv_template,
1146 .count = DES3_EDE_CBC_ENC_TEST_VECTORS
1149 .vecs = des3_ede_cbc_dec_tv_template,
1150 .count = DES3_EDE_CBC_DEC_TEST_VECTORS
1155 .alg = "cbc(twofish)",
1156 .test = alg_test_skcipher,
1160 .vecs = tf_cbc_enc_tv_template,
1161 .count = TF_CBC_ENC_TEST_VECTORS
1164 .vecs = tf_cbc_dec_tv_template,
1165 .count = TF_CBC_DEC_TEST_VECTORS
1171 .test = alg_test_aead,
1175 .vecs = aes_ccm_enc_tv_template,
1176 .count = AES_CCM_ENC_TEST_VECTORS
1179 .vecs = aes_ccm_dec_tv_template,
1180 .count = AES_CCM_DEC_TEST_VECTORS
1186 .test = alg_test_crc32c,
1189 .vecs = crc32c_tv_template,
1190 .count = CRC32C_TEST_VECTORS
1194 .alg = "cts(cbc(aes))",
1195 .test = alg_test_skcipher,
1199 .vecs = cts_mode_enc_tv_template,
1200 .count = CTS_MODE_ENC_TEST_VECTORS
1203 .vecs = cts_mode_dec_tv_template,
1204 .count = CTS_MODE_DEC_TEST_VECTORS
1210 .test = alg_test_comp,
1214 .vecs = deflate_comp_tv_template,
1215 .count = DEFLATE_COMP_TEST_VECTORS
1218 .vecs = deflate_decomp_tv_template,
1219 .count = DEFLATE_DECOMP_TEST_VECTORS
1225 .test = alg_test_skcipher,
1229 .vecs = aes_enc_tv_template,
1230 .count = AES_ENC_TEST_VECTORS
1233 .vecs = aes_dec_tv_template,
1234 .count = AES_DEC_TEST_VECTORS
1239 .alg = "ecb(anubis)",
1240 .test = alg_test_skcipher,
1244 .vecs = anubis_enc_tv_template,
1245 .count = ANUBIS_ENC_TEST_VECTORS
1248 .vecs = anubis_dec_tv_template,
1249 .count = ANUBIS_DEC_TEST_VECTORS
1255 .test = alg_test_skcipher,
1259 .vecs = arc4_enc_tv_template,
1260 .count = ARC4_ENC_TEST_VECTORS
1263 .vecs = arc4_dec_tv_template,
1264 .count = ARC4_DEC_TEST_VECTORS
1269 .alg = "ecb(blowfish)",
1270 .test = alg_test_skcipher,
1274 .vecs = bf_enc_tv_template,
1275 .count = BF_ENC_TEST_VECTORS
1278 .vecs = bf_dec_tv_template,
1279 .count = BF_DEC_TEST_VECTORS
1284 .alg = "ecb(camellia)",
1285 .test = alg_test_skcipher,
1289 .vecs = camellia_enc_tv_template,
1290 .count = CAMELLIA_ENC_TEST_VECTORS
1293 .vecs = camellia_dec_tv_template,
1294 .count = CAMELLIA_DEC_TEST_VECTORS
1299 .alg = "ecb(cast5)",
1300 .test = alg_test_skcipher,
1304 .vecs = cast5_enc_tv_template,
1305 .count = CAST5_ENC_TEST_VECTORS
1308 .vecs = cast5_dec_tv_template,
1309 .count = CAST5_DEC_TEST_VECTORS
1314 .alg = "ecb(cast6)",
1315 .test = alg_test_skcipher,
1319 .vecs = cast6_enc_tv_template,
1320 .count = CAST6_ENC_TEST_VECTORS
1323 .vecs = cast6_dec_tv_template,
1324 .count = CAST6_DEC_TEST_VECTORS
1330 .test = alg_test_skcipher,
1334 .vecs = des_enc_tv_template,
1335 .count = DES_ENC_TEST_VECTORS
1338 .vecs = des_dec_tv_template,
1339 .count = DES_DEC_TEST_VECTORS
1344 .alg = "ecb(des3_ede)",
1345 .test = alg_test_skcipher,
1349 .vecs = des3_ede_enc_tv_template,
1350 .count = DES3_EDE_ENC_TEST_VECTORS
1353 .vecs = des3_ede_dec_tv_template,
1354 .count = DES3_EDE_DEC_TEST_VECTORS
1359 .alg = "ecb(khazad)",
1360 .test = alg_test_skcipher,
1364 .vecs = khazad_enc_tv_template,
1365 .count = KHAZAD_ENC_TEST_VECTORS
1368 .vecs = khazad_dec_tv_template,
1369 .count = KHAZAD_DEC_TEST_VECTORS
1375 .test = alg_test_skcipher,
1379 .vecs = seed_enc_tv_template,
1380 .count = SEED_ENC_TEST_VECTORS
1383 .vecs = seed_dec_tv_template,
1384 .count = SEED_DEC_TEST_VECTORS
1389 .alg = "ecb(serpent)",
1390 .test = alg_test_skcipher,
1394 .vecs = serpent_enc_tv_template,
1395 .count = SERPENT_ENC_TEST_VECTORS
1398 .vecs = serpent_dec_tv_template,
1399 .count = SERPENT_DEC_TEST_VECTORS
1405 .test = alg_test_skcipher,
1409 .vecs = tea_enc_tv_template,
1410 .count = TEA_ENC_TEST_VECTORS
1413 .vecs = tea_dec_tv_template,
1414 .count = TEA_DEC_TEST_VECTORS
1419 .alg = "ecb(tnepres)",
1420 .test = alg_test_skcipher,
1424 .vecs = tnepres_enc_tv_template,
1425 .count = TNEPRES_ENC_TEST_VECTORS
1428 .vecs = tnepres_dec_tv_template,
1429 .count = TNEPRES_DEC_TEST_VECTORS
1434 .alg = "ecb(twofish)",
1435 .test = alg_test_skcipher,
1439 .vecs = tf_enc_tv_template,
1440 .count = TF_ENC_TEST_VECTORS
1443 .vecs = tf_dec_tv_template,
1444 .count = TF_DEC_TEST_VECTORS
1450 .test = alg_test_skcipher,
1454 .vecs = xeta_enc_tv_template,
1455 .count = XETA_ENC_TEST_VECTORS
1458 .vecs = xeta_dec_tv_template,
1459 .count = XETA_DEC_TEST_VECTORS
1465 .test = alg_test_skcipher,
1469 .vecs = xtea_enc_tv_template,
1470 .count = XTEA_ENC_TEST_VECTORS
1473 .vecs = xtea_dec_tv_template,
1474 .count = XTEA_DEC_TEST_VECTORS
1480 .test = alg_test_aead,
1484 .vecs = aes_gcm_enc_tv_template,
1485 .count = AES_GCM_ENC_TEST_VECTORS
1488 .vecs = aes_gcm_dec_tv_template,
1489 .count = AES_GCM_DEC_TEST_VECTORS
1495 .test = alg_test_hash,
1498 .vecs = hmac_md5_tv_template,
1499 .count = HMAC_MD5_TEST_VECTORS
1503 .alg = "hmac(rmd128)",
1504 .test = alg_test_hash,
1507 .vecs = hmac_rmd128_tv_template,
1508 .count = HMAC_RMD128_TEST_VECTORS
1512 .alg = "hmac(rmd160)",
1513 .test = alg_test_hash,
1516 .vecs = hmac_rmd160_tv_template,
1517 .count = HMAC_RMD160_TEST_VECTORS
1521 .alg = "hmac(sha1)",
1522 .test = alg_test_hash,
1525 .vecs = hmac_sha1_tv_template,
1526 .count = HMAC_SHA1_TEST_VECTORS
1530 .alg = "hmac(sha224)",
1531 .test = alg_test_hash,
1534 .vecs = hmac_sha224_tv_template,
1535 .count = HMAC_SHA224_TEST_VECTORS
1539 .alg = "hmac(sha256)",
1540 .test = alg_test_hash,
1543 .vecs = hmac_sha256_tv_template,
1544 .count = HMAC_SHA256_TEST_VECTORS
1548 .alg = "hmac(sha384)",
1549 .test = alg_test_hash,
1552 .vecs = hmac_sha384_tv_template,
1553 .count = HMAC_SHA384_TEST_VECTORS
1557 .alg = "hmac(sha512)",
1558 .test = alg_test_hash,
1561 .vecs = hmac_sha512_tv_template,
1562 .count = HMAC_SHA512_TEST_VECTORS
1567 .test = alg_test_skcipher,
1571 .vecs = aes_lrw_enc_tv_template,
1572 .count = AES_LRW_ENC_TEST_VECTORS
1575 .vecs = aes_lrw_dec_tv_template,
1576 .count = AES_LRW_DEC_TEST_VECTORS
1582 .test = alg_test_comp,
1586 .vecs = lzo_comp_tv_template,
1587 .count = LZO_COMP_TEST_VECTORS
1590 .vecs = lzo_decomp_tv_template,
1591 .count = LZO_DECOMP_TEST_VECTORS
1597 .test = alg_test_hash,
1600 .vecs = md4_tv_template,
1601 .count = MD4_TEST_VECTORS
1606 .test = alg_test_hash,
1609 .vecs = md5_tv_template,
1610 .count = MD5_TEST_VECTORS
1614 .alg = "michael_mic",
1615 .test = alg_test_hash,
1618 .vecs = michael_mic_tv_template,
1619 .count = MICHAEL_MIC_TEST_VECTORS
1623 .alg = "pcbc(fcrypt)",
1624 .test = alg_test_skcipher,
1628 .vecs = fcrypt_pcbc_enc_tv_template,
1629 .count = FCRYPT_ENC_TEST_VECTORS
1632 .vecs = fcrypt_pcbc_dec_tv_template,
1633 .count = FCRYPT_DEC_TEST_VECTORS
1638 .alg = "rfc3686(ctr(aes))",
1639 .test = alg_test_skcipher,
1643 .vecs = aes_ctr_enc_tv_template,
1644 .count = AES_CTR_ENC_TEST_VECTORS
1647 .vecs = aes_ctr_dec_tv_template,
1648 .count = AES_CTR_DEC_TEST_VECTORS
1654 .test = alg_test_hash,
1657 .vecs = rmd128_tv_template,
1658 .count = RMD128_TEST_VECTORS
1663 .test = alg_test_hash,
1666 .vecs = rmd160_tv_template,
1667 .count = RMD160_TEST_VECTORS
1672 .test = alg_test_hash,
1675 .vecs = rmd256_tv_template,
1676 .count = RMD256_TEST_VECTORS
1681 .test = alg_test_hash,
1684 .vecs = rmd320_tv_template,
1685 .count = RMD320_TEST_VECTORS
1690 .test = alg_test_skcipher,
1694 .vecs = salsa20_stream_enc_tv_template,
1695 .count = SALSA20_STREAM_ENC_TEST_VECTORS
1701 .test = alg_test_hash,
1704 .vecs = sha1_tv_template,
1705 .count = SHA1_TEST_VECTORS
1710 .test = alg_test_hash,
1713 .vecs = sha224_tv_template,
1714 .count = SHA224_TEST_VECTORS
1719 .test = alg_test_hash,
1722 .vecs = sha256_tv_template,
1723 .count = SHA256_TEST_VECTORS
1728 .test = alg_test_hash,
1731 .vecs = sha384_tv_template,
1732 .count = SHA384_TEST_VECTORS
1737 .test = alg_test_hash,
1740 .vecs = sha512_tv_template,
1741 .count = SHA512_TEST_VECTORS
1746 .test = alg_test_hash,
1749 .vecs = tgr128_tv_template,
1750 .count = TGR128_TEST_VECTORS
1755 .test = alg_test_hash,
1758 .vecs = tgr160_tv_template,
1759 .count = TGR160_TEST_VECTORS
1764 .test = alg_test_hash,
1767 .vecs = tgr192_tv_template,
1768 .count = TGR192_TEST_VECTORS
1773 .test = alg_test_hash,
1776 .vecs = wp256_tv_template,
1777 .count = WP256_TEST_VECTORS
1782 .test = alg_test_hash,
1785 .vecs = wp384_tv_template,
1786 .count = WP384_TEST_VECTORS
1791 .test = alg_test_hash,
1794 .vecs = wp512_tv_template,
1795 .count = WP512_TEST_VECTORS
1800 .test = alg_test_hash,
1803 .vecs = aes_xcbc128_tv_template,
1804 .count = XCBC_AES_TEST_VECTORS
1809 .test = alg_test_skcipher,
1813 .vecs = aes_xts_enc_tv_template,
1814 .count = AES_XTS_ENC_TEST_VECTORS
1817 .vecs = aes_xts_dec_tv_template,
1818 .count = AES_XTS_DEC_TEST_VECTORS
1825 static int alg_find_test(const char *alg)
1828 int end = ARRAY_SIZE(alg_test_descs);
1830 while (start < end) {
1831 int i = (start + end) / 2;
1832 int diff = strcmp(alg_test_descs[i].alg, alg);
1850 int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
1855 if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) {
1856 char nalg[CRYPTO_MAX_ALG_NAME];
1858 if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >=
1860 return -ENAMETOOLONG;
1862 i = alg_find_test(nalg);
1866 return alg_test_cipher(alg_test_descs + i, driver, type, mask);
1869 i = alg_find_test(alg);
1873 rc = alg_test_descs[i].test(alg_test_descs + i, driver,
1875 if (fips_enabled && rc)
1876 panic("%s: %s alg self test failed in fips mode!\n", driver, alg);
1881 printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
1884 EXPORT_SYMBOL_GPL(alg_test);
1886 int __init testmgr_init(void)
1890 for (i = 0; i < XBUFSIZE; i++) {
1891 xbuf[i] = (void *)__get_free_page(GFP_KERNEL);
1896 for (i = 0; i < XBUFSIZE; i++) {
1897 axbuf[i] = (void *)__get_free_page(GFP_KERNEL);
1899 goto err_free_axbuf;
1905 for (i = 0; i < XBUFSIZE && axbuf[i]; i++)
1906 free_page((unsigned long)axbuf[i]);
1908 for (i = 0; i < XBUFSIZE && xbuf[i]; i++)
1909 free_page((unsigned long)xbuf[i]);
1914 void testmgr_exit(void)
1918 for (i = 0; i < XBUFSIZE; i++)
1919 free_page((unsigned long)axbuf[i]);
1920 for (i = 0; i < XBUFSIZE; i++)
1921 free_page((unsigned long)xbuf[i]);