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 * Updated RFC4106 AES-GCM testing.
10 * Authors: Aidan O'Mahony (aidan.o.mahony@intel.com)
11 * Adrian Hoban <adrian.hoban@intel.com>
12 * Gabriele Paoloni <gabriele.paoloni@intel.com>
13 * Tadeusz Struk (tadeusz.struk@intel.com)
14 * Copyright (c) 2010, Intel Corporation.
16 * This program is free software; you can redistribute it and/or modify it
17 * under the terms of the GNU General Public License as published by the Free
18 * Software Foundation; either version 2 of the License, or (at your option)
23 #include <crypto/aead.h>
24 #include <crypto/hash.h>
25 #include <crypto/skcipher.h>
26 #include <linux/err.h>
27 #include <linux/fips.h>
28 #include <linux/module.h>
29 #include <linux/scatterlist.h>
30 #include <linux/slab.h>
31 #include <linux/string.h>
32 #include <crypto/rng.h>
33 #include <crypto/drbg.h>
34 #include <crypto/akcipher.h>
35 #include <crypto/kpp.h>
36 #include <crypto/acompress.h>
41 module_param(notests, bool, 0644);
42 MODULE_PARM_DESC(notests, "disable crypto self-tests");
44 #ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
47 int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
57 * Need slab memory for testing (size in number of pages).
62 * Indexes into the xbuf to simulate cross-page access.
74 * Used by test_cipher()
79 struct tcrypt_result {
80 struct completion completion;
84 struct aead_test_suite {
86 struct aead_testvec *vecs;
91 struct cipher_test_suite {
93 struct cipher_testvec *vecs;
98 struct comp_test_suite {
100 struct comp_testvec *vecs;
105 struct hash_test_suite {
106 struct hash_testvec *vecs;
110 struct cprng_test_suite {
111 struct cprng_testvec *vecs;
115 struct drbg_test_suite {
116 struct drbg_testvec *vecs;
120 struct akcipher_test_suite {
121 struct akcipher_testvec *vecs;
125 struct kpp_test_suite {
126 struct kpp_testvec *vecs;
130 struct alg_test_desc {
132 int (*test)(const struct alg_test_desc *desc, const char *driver,
134 int fips_allowed; /* set if alg is allowed in fips mode */
137 struct aead_test_suite aead;
138 struct cipher_test_suite cipher;
139 struct comp_test_suite comp;
140 struct hash_test_suite hash;
141 struct cprng_test_suite cprng;
142 struct drbg_test_suite drbg;
143 struct akcipher_test_suite akcipher;
144 struct kpp_test_suite kpp;
148 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
150 static void hexdump(unsigned char *buf, unsigned int len)
152 print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
157 static void tcrypt_complete(struct crypto_async_request *req, int err)
159 struct tcrypt_result *res = req->data;
161 if (err == -EINPROGRESS)
165 complete(&res->completion);
168 static int testmgr_alloc_buf(char *buf[XBUFSIZE])
172 for (i = 0; i < XBUFSIZE; i++) {
173 buf[i] = (void *)__get_free_page(GFP_KERNEL);
182 free_page((unsigned long)buf[i]);
187 static void testmgr_free_buf(char *buf[XBUFSIZE])
191 for (i = 0; i < XBUFSIZE; i++)
192 free_page((unsigned long)buf[i]);
195 static int wait_async_op(struct tcrypt_result *tr, int ret)
197 if (ret == -EINPROGRESS || ret == -EBUSY) {
198 wait_for_completion(&tr->completion);
199 reinit_completion(&tr->completion);
205 static int ahash_partial_update(struct ahash_request **preq,
206 struct crypto_ahash *tfm, struct hash_testvec *template,
207 void *hash_buff, int k, int temp, struct scatterlist *sg,
208 const char *algo, char *result, struct tcrypt_result *tresult)
211 struct ahash_request *req;
212 int statesize, ret = -EINVAL;
213 const char guard[] = { 0x00, 0xba, 0xad, 0x00 };
216 statesize = crypto_ahash_statesize(
217 crypto_ahash_reqtfm(req));
218 state = kmalloc(statesize + sizeof(guard), GFP_KERNEL);
220 pr_err("alt: hash: Failed to alloc state for %s\n", algo);
223 memcpy(state + statesize, guard, sizeof(guard));
224 ret = crypto_ahash_export(req, state);
225 WARN_ON(memcmp(state + statesize, guard, sizeof(guard)));
227 pr_err("alt: hash: Failed to export() for %s\n", algo);
230 ahash_request_free(req);
231 req = ahash_request_alloc(tfm, GFP_KERNEL);
233 pr_err("alg: hash: Failed to alloc request for %s\n", algo);
236 ahash_request_set_callback(req,
237 CRYPTO_TFM_REQ_MAY_BACKLOG,
238 tcrypt_complete, tresult);
240 memcpy(hash_buff, template->plaintext + temp,
242 sg_init_one(&sg[0], hash_buff, template->tap[k]);
243 ahash_request_set_crypt(req, sg, result, template->tap[k]);
244 ret = crypto_ahash_import(req, state);
246 pr_err("alg: hash: Failed to import() for %s\n", algo);
249 ret = wait_async_op(tresult, crypto_ahash_update(req));
256 ahash_request_free(req);
263 static int __test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
264 unsigned int tcount, bool use_digest,
265 const int align_offset)
267 const char *algo = crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm));
268 unsigned int i, j, k, temp;
269 struct scatterlist sg[8];
272 struct ahash_request *req;
273 struct tcrypt_result tresult;
275 char *xbuf[XBUFSIZE];
278 result = kmalloc(MAX_DIGEST_SIZE, GFP_KERNEL);
281 key = kmalloc(MAX_KEYLEN, GFP_KERNEL);
284 if (testmgr_alloc_buf(xbuf))
287 init_completion(&tresult.completion);
289 req = ahash_request_alloc(tfm, GFP_KERNEL);
291 printk(KERN_ERR "alg: hash: Failed to allocate request for "
295 ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
296 tcrypt_complete, &tresult);
299 for (i = 0; i < tcount; i++) {
304 if (WARN_ON(align_offset + template[i].psize > PAGE_SIZE))
308 memset(result, 0, MAX_DIGEST_SIZE);
311 hash_buff += align_offset;
313 memcpy(hash_buff, template[i].plaintext, template[i].psize);
314 sg_init_one(&sg[0], hash_buff, template[i].psize);
316 if (template[i].ksize) {
317 crypto_ahash_clear_flags(tfm, ~0);
318 if (template[i].ksize > MAX_KEYLEN) {
319 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
320 j, algo, template[i].ksize, MAX_KEYLEN);
324 memcpy(key, template[i].key, template[i].ksize);
325 ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
327 printk(KERN_ERR "alg: hash: setkey failed on "
328 "test %d for %s: ret=%d\n", j, algo,
334 ahash_request_set_crypt(req, sg, result, template[i].psize);
336 ret = wait_async_op(&tresult, crypto_ahash_digest(req));
338 pr_err("alg: hash: digest failed on test %d "
339 "for %s: ret=%d\n", j, algo, -ret);
343 ret = wait_async_op(&tresult, crypto_ahash_init(req));
345 pr_err("alt: hash: init failed on test %d "
346 "for %s: ret=%d\n", j, algo, -ret);
349 ret = wait_async_op(&tresult, crypto_ahash_update(req));
351 pr_err("alt: hash: update failed on test %d "
352 "for %s: ret=%d\n", j, algo, -ret);
355 ret = wait_async_op(&tresult, crypto_ahash_final(req));
357 pr_err("alt: hash: final failed on test %d "
358 "for %s: ret=%d\n", j, algo, -ret);
363 if (memcmp(result, template[i].digest,
364 crypto_ahash_digestsize(tfm))) {
365 printk(KERN_ERR "alg: hash: Test %d failed for %s\n",
367 hexdump(result, crypto_ahash_digestsize(tfm));
374 for (i = 0; i < tcount; i++) {
375 /* alignment tests are only done with continuous buffers */
376 if (align_offset != 0)
383 memset(result, 0, MAX_DIGEST_SIZE);
386 sg_init_table(sg, template[i].np);
388 for (k = 0; k < template[i].np; k++) {
389 if (WARN_ON(offset_in_page(IDX[k]) +
390 template[i].tap[k] > PAGE_SIZE))
393 memcpy(xbuf[IDX[k] >> PAGE_SHIFT] +
394 offset_in_page(IDX[k]),
395 template[i].plaintext + temp,
398 temp += template[i].tap[k];
401 if (template[i].ksize) {
402 if (template[i].ksize > MAX_KEYLEN) {
403 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
404 j, algo, template[i].ksize, MAX_KEYLEN);
408 crypto_ahash_clear_flags(tfm, ~0);
409 memcpy(key, template[i].key, template[i].ksize);
410 ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
413 printk(KERN_ERR "alg: hash: setkey "
414 "failed on chunking test %d "
415 "for %s: ret=%d\n", j, algo, -ret);
420 ahash_request_set_crypt(req, sg, result, template[i].psize);
421 ret = crypto_ahash_digest(req);
427 wait_for_completion(&tresult.completion);
428 reinit_completion(&tresult.completion);
434 printk(KERN_ERR "alg: hash: digest failed "
435 "on chunking test %d for %s: "
436 "ret=%d\n", j, algo, -ret);
440 if (memcmp(result, template[i].digest,
441 crypto_ahash_digestsize(tfm))) {
442 printk(KERN_ERR "alg: hash: Chunking test %d "
443 "failed for %s\n", j, algo);
444 hexdump(result, crypto_ahash_digestsize(tfm));
450 /* partial update exercise */
452 for (i = 0; i < tcount; i++) {
453 /* alignment tests are only done with continuous buffers */
454 if (align_offset != 0)
457 if (template[i].np < 2)
461 memset(result, 0, MAX_DIGEST_SIZE);
465 memcpy(hash_buff, template[i].plaintext,
467 sg_init_one(&sg[0], hash_buff, template[i].tap[0]);
469 if (template[i].ksize) {
470 crypto_ahash_clear_flags(tfm, ~0);
471 if (template[i].ksize > MAX_KEYLEN) {
472 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
473 j, algo, template[i].ksize, MAX_KEYLEN);
477 memcpy(key, template[i].key, template[i].ksize);
478 ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
480 pr_err("alg: hash: setkey failed on test %d for %s: ret=%d\n",
486 ahash_request_set_crypt(req, sg, result, template[i].tap[0]);
487 ret = wait_async_op(&tresult, crypto_ahash_init(req));
489 pr_err("alt: hash: init failed on test %d for %s: ret=%d\n",
493 ret = wait_async_op(&tresult, crypto_ahash_update(req));
495 pr_err("alt: hash: update failed on test %d for %s: ret=%d\n",
500 temp = template[i].tap[0];
501 for (k = 1; k < template[i].np; k++) {
502 ret = ahash_partial_update(&req, tfm, &template[i],
503 hash_buff, k, temp, &sg[0], algo, result,
506 pr_err("hash: partial update failed on test %d for %s: ret=%d\n",
510 temp += template[i].tap[k];
512 ret = wait_async_op(&tresult, crypto_ahash_final(req));
514 pr_err("alt: hash: final failed on test %d for %s: ret=%d\n",
518 if (memcmp(result, template[i].digest,
519 crypto_ahash_digestsize(tfm))) {
520 pr_err("alg: hash: Partial Test %d failed for %s\n",
522 hexdump(result, crypto_ahash_digestsize(tfm));
531 ahash_request_free(req);
533 testmgr_free_buf(xbuf);
540 static int test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
541 unsigned int tcount, bool use_digest)
543 unsigned int alignmask;
546 ret = __test_hash(tfm, template, tcount, use_digest, 0);
550 /* test unaligned buffers, check with one byte offset */
551 ret = __test_hash(tfm, template, tcount, use_digest, 1);
555 alignmask = crypto_tfm_alg_alignmask(&tfm->base);
557 /* Check if alignment mask for tfm is correctly set. */
558 ret = __test_hash(tfm, template, tcount, use_digest,
567 static int __test_aead(struct crypto_aead *tfm, int enc,
568 struct aead_testvec *template, unsigned int tcount,
569 const bool diff_dst, const int align_offset)
571 const char *algo = crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm));
572 unsigned int i, j, k, n, temp;
576 struct aead_request *req;
577 struct scatterlist *sg;
578 struct scatterlist *sgout;
580 struct tcrypt_result result;
581 unsigned int authsize, iv_len;
586 char *xbuf[XBUFSIZE];
587 char *xoutbuf[XBUFSIZE];
588 char *axbuf[XBUFSIZE];
590 iv = kzalloc(MAX_IVLEN, GFP_KERNEL);
593 key = kmalloc(MAX_KEYLEN, GFP_KERNEL);
596 if (testmgr_alloc_buf(xbuf))
598 if (testmgr_alloc_buf(axbuf))
600 if (diff_dst && testmgr_alloc_buf(xoutbuf))
603 /* avoid "the frame size is larger than 1024 bytes" compiler warning */
604 sg = kmalloc(sizeof(*sg) * 8 * (diff_dst ? 4 : 2), GFP_KERNEL);
619 init_completion(&result.completion);
621 req = aead_request_alloc(tfm, GFP_KERNEL);
623 pr_err("alg: aead%s: Failed to allocate request for %s\n",
628 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
629 tcrypt_complete, &result);
631 iv_len = crypto_aead_ivsize(tfm);
633 for (i = 0, j = 0; i < tcount; i++) {
639 /* some templates have no input data but they will
643 input += align_offset;
647 if (WARN_ON(align_offset + template[i].ilen >
648 PAGE_SIZE || template[i].alen > PAGE_SIZE))
651 memcpy(input, template[i].input, template[i].ilen);
652 memcpy(assoc, template[i].assoc, template[i].alen);
654 memcpy(iv, template[i].iv, iv_len);
656 memset(iv, 0, iv_len);
658 crypto_aead_clear_flags(tfm, ~0);
660 crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
662 if (template[i].klen > MAX_KEYLEN) {
663 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
664 d, j, algo, template[i].klen,
669 memcpy(key, template[i].key, template[i].klen);
671 ret = crypto_aead_setkey(tfm, key, template[i].klen);
672 if (template[i].fail == !ret) {
673 pr_err("alg: aead%s: setkey failed on test %d for %s: flags=%x\n",
674 d, j, algo, crypto_aead_get_flags(tfm));
679 authsize = abs(template[i].rlen - template[i].ilen);
680 ret = crypto_aead_setauthsize(tfm, authsize);
682 pr_err("alg: aead%s: Failed to set authsize to %u on test %d for %s\n",
683 d, authsize, j, algo);
687 k = !!template[i].alen;
688 sg_init_table(sg, k + 1);
689 sg_set_buf(&sg[0], assoc, template[i].alen);
690 sg_set_buf(&sg[k], input,
691 template[i].ilen + (enc ? authsize : 0));
695 sg_init_table(sgout, k + 1);
696 sg_set_buf(&sgout[0], assoc, template[i].alen);
699 output += align_offset;
700 sg_set_buf(&sgout[k], output,
701 template[i].rlen + (enc ? 0 : authsize));
704 aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
705 template[i].ilen, iv);
707 aead_request_set_ad(req, template[i].alen);
709 ret = enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req);
713 if (template[i].novrfy) {
714 /* verification was supposed to fail */
715 pr_err("alg: aead%s: %s failed on test %d for %s: ret was 0, expected -EBADMSG\n",
717 /* so really, we got a bad message */
724 wait_for_completion(&result.completion);
725 reinit_completion(&result.completion);
730 if (template[i].novrfy)
731 /* verification failure was expected */
735 pr_err("alg: aead%s: %s failed on test %d for %s: ret=%d\n",
736 d, e, j, algo, -ret);
741 if (memcmp(q, template[i].result, template[i].rlen)) {
742 pr_err("alg: aead%s: Test %d failed on %s for %s\n",
744 hexdump(q, template[i].rlen);
750 for (i = 0, j = 0; i < tcount; i++) {
751 /* alignment tests are only done with continuous buffers */
752 if (align_offset != 0)
761 memcpy(iv, template[i].iv, iv_len);
763 memset(iv, 0, MAX_IVLEN);
765 crypto_aead_clear_flags(tfm, ~0);
767 crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
768 if (template[i].klen > MAX_KEYLEN) {
769 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
770 d, j, algo, template[i].klen, MAX_KEYLEN);
774 memcpy(key, template[i].key, template[i].klen);
776 ret = crypto_aead_setkey(tfm, key, template[i].klen);
777 if (template[i].fail == !ret) {
778 pr_err("alg: aead%s: setkey failed on chunk test %d for %s: flags=%x\n",
779 d, j, algo, crypto_aead_get_flags(tfm));
784 authsize = abs(template[i].rlen - template[i].ilen);
787 sg_init_table(sg, template[i].anp + template[i].np);
789 sg_init_table(sgout, template[i].anp + template[i].np);
792 for (k = 0, temp = 0; k < template[i].anp; k++) {
793 if (WARN_ON(offset_in_page(IDX[k]) +
794 template[i].atap[k] > PAGE_SIZE))
797 memcpy(axbuf[IDX[k] >> PAGE_SHIFT] +
798 offset_in_page(IDX[k]),
799 template[i].assoc + temp,
800 template[i].atap[k]),
801 template[i].atap[k]);
803 sg_set_buf(&sgout[k],
804 axbuf[IDX[k] >> PAGE_SHIFT] +
805 offset_in_page(IDX[k]),
806 template[i].atap[k]);
807 temp += template[i].atap[k];
810 for (k = 0, temp = 0; k < template[i].np; k++) {
811 if (WARN_ON(offset_in_page(IDX[k]) +
812 template[i].tap[k] > PAGE_SIZE))
815 q = xbuf[IDX[k] >> PAGE_SHIFT] + offset_in_page(IDX[k]);
816 memcpy(q, template[i].input + temp, template[i].tap[k]);
817 sg_set_buf(&sg[template[i].anp + k],
818 q, template[i].tap[k]);
821 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
822 offset_in_page(IDX[k]);
824 memset(q, 0, template[i].tap[k]);
826 sg_set_buf(&sgout[template[i].anp + k],
827 q, template[i].tap[k]);
830 n = template[i].tap[k];
831 if (k == template[i].np - 1 && enc)
833 if (offset_in_page(q) + n < PAGE_SIZE)
836 temp += template[i].tap[k];
839 ret = crypto_aead_setauthsize(tfm, authsize);
841 pr_err("alg: aead%s: Failed to set authsize to %u on chunk test %d for %s\n",
842 d, authsize, j, algo);
847 if (WARN_ON(sg[template[i].anp + k - 1].offset +
848 sg[template[i].anp + k - 1].length +
849 authsize > PAGE_SIZE)) {
855 sgout[template[i].anp + k - 1].length +=
857 sg[template[i].anp + k - 1].length += authsize;
860 aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
864 aead_request_set_ad(req, template[i].alen);
866 ret = enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req);
870 if (template[i].novrfy) {
871 /* verification was supposed to fail */
872 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret was 0, expected -EBADMSG\n",
874 /* so really, we got a bad message */
881 wait_for_completion(&result.completion);
882 reinit_completion(&result.completion);
887 if (template[i].novrfy)
888 /* verification failure was expected */
892 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret=%d\n",
893 d, e, j, algo, -ret);
898 for (k = 0, temp = 0; k < template[i].np; k++) {
900 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
901 offset_in_page(IDX[k]);
903 q = xbuf[IDX[k] >> PAGE_SHIFT] +
904 offset_in_page(IDX[k]);
906 n = template[i].tap[k];
907 if (k == template[i].np - 1)
908 n += enc ? authsize : -authsize;
910 if (memcmp(q, template[i].result + temp, n)) {
911 pr_err("alg: aead%s: Chunk test %d failed on %s at page %u for %s\n",
918 if (k == template[i].np - 1 && !enc) {
920 memcmp(q, template[i].input +
926 for (n = 0; offset_in_page(q + n) && q[n]; n++)
930 pr_err("alg: aead%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
931 d, j, e, k, algo, n);
936 temp += template[i].tap[k];
943 aead_request_free(req);
947 testmgr_free_buf(xoutbuf);
949 testmgr_free_buf(axbuf);
951 testmgr_free_buf(xbuf);
958 static int test_aead(struct crypto_aead *tfm, int enc,
959 struct aead_testvec *template, unsigned int tcount)
961 unsigned int alignmask;
964 /* test 'dst == src' case */
965 ret = __test_aead(tfm, enc, template, tcount, false, 0);
969 /* test 'dst != src' case */
970 ret = __test_aead(tfm, enc, template, tcount, true, 0);
974 /* test unaligned buffers, check with one byte offset */
975 ret = __test_aead(tfm, enc, template, tcount, true, 1);
979 alignmask = crypto_tfm_alg_alignmask(&tfm->base);
981 /* Check if alignment mask for tfm is correctly set. */
982 ret = __test_aead(tfm, enc, template, tcount, true,
991 static int test_cipher(struct crypto_cipher *tfm, int enc,
992 struct cipher_testvec *template, unsigned int tcount)
994 const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm));
995 unsigned int i, j, k;
999 char *xbuf[XBUFSIZE];
1002 if (testmgr_alloc_buf(xbuf))
1011 for (i = 0; i < tcount; i++) {
1015 if (fips_enabled && template[i].fips_skip)
1021 if (WARN_ON(template[i].ilen > PAGE_SIZE))
1025 memcpy(data, template[i].input, template[i].ilen);
1027 crypto_cipher_clear_flags(tfm, ~0);
1029 crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
1031 ret = crypto_cipher_setkey(tfm, template[i].key,
1033 if (template[i].fail == !ret) {
1034 printk(KERN_ERR "alg: cipher: setkey failed "
1035 "on test %d for %s: flags=%x\n", j,
1036 algo, crypto_cipher_get_flags(tfm));
1041 for (k = 0; k < template[i].ilen;
1042 k += crypto_cipher_blocksize(tfm)) {
1044 crypto_cipher_encrypt_one(tfm, data + k,
1047 crypto_cipher_decrypt_one(tfm, data + k,
1052 if (memcmp(q, template[i].result, template[i].rlen)) {
1053 printk(KERN_ERR "alg: cipher: Test %d failed "
1054 "on %s for %s\n", j, e, algo);
1055 hexdump(q, template[i].rlen);
1064 testmgr_free_buf(xbuf);
1069 static int __test_skcipher(struct crypto_skcipher *tfm, int enc,
1070 struct cipher_testvec *template, unsigned int tcount,
1071 const bool diff_dst, const int align_offset)
1074 crypto_tfm_alg_driver_name(crypto_skcipher_tfm(tfm));
1075 unsigned int i, j, k, n, temp;
1077 struct skcipher_request *req;
1078 struct scatterlist sg[8];
1079 struct scatterlist sgout[8];
1081 struct tcrypt_result result;
1084 char *xbuf[XBUFSIZE];
1085 char *xoutbuf[XBUFSIZE];
1087 unsigned int ivsize = crypto_skcipher_ivsize(tfm);
1089 if (testmgr_alloc_buf(xbuf))
1092 if (diff_dst && testmgr_alloc_buf(xoutbuf))
1105 init_completion(&result.completion);
1107 req = skcipher_request_alloc(tfm, GFP_KERNEL);
1109 pr_err("alg: skcipher%s: Failed to allocate request for %s\n",
1114 skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1115 tcrypt_complete, &result);
1118 for (i = 0; i < tcount; i++) {
1119 if (template[i].np && !template[i].also_non_np)
1122 if (fips_enabled && template[i].fips_skip)
1126 memcpy(iv, template[i].iv, ivsize);
1128 memset(iv, 0, MAX_IVLEN);
1132 if (WARN_ON(align_offset + template[i].ilen > PAGE_SIZE))
1136 data += align_offset;
1137 memcpy(data, template[i].input, template[i].ilen);
1139 crypto_skcipher_clear_flags(tfm, ~0);
1141 crypto_skcipher_set_flags(tfm,
1142 CRYPTO_TFM_REQ_WEAK_KEY);
1144 ret = crypto_skcipher_setkey(tfm, template[i].key,
1146 if (template[i].fail == !ret) {
1147 pr_err("alg: skcipher%s: setkey failed on test %d for %s: flags=%x\n",
1148 d, j, algo, crypto_skcipher_get_flags(tfm));
1153 sg_init_one(&sg[0], data, template[i].ilen);
1156 data += align_offset;
1157 sg_init_one(&sgout[0], data, template[i].ilen);
1160 skcipher_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
1161 template[i].ilen, iv);
1162 ret = enc ? crypto_skcipher_encrypt(req) :
1163 crypto_skcipher_decrypt(req);
1170 wait_for_completion(&result.completion);
1171 reinit_completion(&result.completion);
1177 pr_err("alg: skcipher%s: %s failed on test %d for %s: ret=%d\n",
1178 d, e, j, algo, -ret);
1183 if (memcmp(q, template[i].result, template[i].rlen)) {
1184 pr_err("alg: skcipher%s: Test %d failed (invalid result) on %s for %s\n",
1186 hexdump(q, template[i].rlen);
1191 if (template[i].iv_out &&
1192 memcmp(iv, template[i].iv_out,
1193 crypto_skcipher_ivsize(tfm))) {
1194 pr_err("alg: skcipher%s: Test %d failed (invalid output IV) on %s for %s\n",
1196 hexdump(iv, crypto_skcipher_ivsize(tfm));
1203 for (i = 0; i < tcount; i++) {
1204 /* alignment tests are only done with continuous buffers */
1205 if (align_offset != 0)
1208 if (!template[i].np)
1211 if (fips_enabled && template[i].fips_skip)
1215 memcpy(iv, template[i].iv, ivsize);
1217 memset(iv, 0, MAX_IVLEN);
1220 crypto_skcipher_clear_flags(tfm, ~0);
1222 crypto_skcipher_set_flags(tfm,
1223 CRYPTO_TFM_REQ_WEAK_KEY);
1225 ret = crypto_skcipher_setkey(tfm, template[i].key,
1227 if (template[i].fail == !ret) {
1228 pr_err("alg: skcipher%s: setkey failed on chunk test %d for %s: flags=%x\n",
1229 d, j, algo, crypto_skcipher_get_flags(tfm));
1236 sg_init_table(sg, template[i].np);
1238 sg_init_table(sgout, template[i].np);
1239 for (k = 0; k < template[i].np; k++) {
1240 if (WARN_ON(offset_in_page(IDX[k]) +
1241 template[i].tap[k] > PAGE_SIZE))
1244 q = xbuf[IDX[k] >> PAGE_SHIFT] + offset_in_page(IDX[k]);
1246 memcpy(q, template[i].input + temp, template[i].tap[k]);
1248 if (offset_in_page(q) + template[i].tap[k] < PAGE_SIZE)
1249 q[template[i].tap[k]] = 0;
1251 sg_set_buf(&sg[k], q, template[i].tap[k]);
1253 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
1254 offset_in_page(IDX[k]);
1256 sg_set_buf(&sgout[k], q, template[i].tap[k]);
1258 memset(q, 0, template[i].tap[k]);
1259 if (offset_in_page(q) +
1260 template[i].tap[k] < PAGE_SIZE)
1261 q[template[i].tap[k]] = 0;
1264 temp += template[i].tap[k];
1267 skcipher_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
1268 template[i].ilen, iv);
1270 ret = enc ? crypto_skcipher_encrypt(req) :
1271 crypto_skcipher_decrypt(req);
1278 wait_for_completion(&result.completion);
1279 reinit_completion(&result.completion);
1285 pr_err("alg: skcipher%s: %s failed on chunk test %d for %s: ret=%d\n",
1286 d, e, j, algo, -ret);
1292 for (k = 0; k < template[i].np; k++) {
1294 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
1295 offset_in_page(IDX[k]);
1297 q = xbuf[IDX[k] >> PAGE_SHIFT] +
1298 offset_in_page(IDX[k]);
1300 if (memcmp(q, template[i].result + temp,
1301 template[i].tap[k])) {
1302 pr_err("alg: skcipher%s: Chunk test %d failed on %s at page %u for %s\n",
1304 hexdump(q, template[i].tap[k]);
1308 q += template[i].tap[k];
1309 for (n = 0; offset_in_page(q + n) && q[n]; n++)
1312 pr_err("alg: skcipher%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
1313 d, j, e, k, algo, n);
1317 temp += template[i].tap[k];
1324 skcipher_request_free(req);
1326 testmgr_free_buf(xoutbuf);
1328 testmgr_free_buf(xbuf);
1333 static int test_skcipher(struct crypto_skcipher *tfm, int enc,
1334 struct cipher_testvec *template, unsigned int tcount)
1336 unsigned int alignmask;
1339 /* test 'dst == src' case */
1340 ret = __test_skcipher(tfm, enc, template, tcount, false, 0);
1344 /* test 'dst != src' case */
1345 ret = __test_skcipher(tfm, enc, template, tcount, true, 0);
1349 /* test unaligned buffers, check with one byte offset */
1350 ret = __test_skcipher(tfm, enc, template, tcount, true, 1);
1354 alignmask = crypto_tfm_alg_alignmask(&tfm->base);
1356 /* Check if alignment mask for tfm is correctly set. */
1357 ret = __test_skcipher(tfm, enc, template, tcount, true,
1366 static int test_comp(struct crypto_comp *tfm, struct comp_testvec *ctemplate,
1367 struct comp_testvec *dtemplate, int ctcount, int dtcount)
1369 const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
1371 char result[COMP_BUF_SIZE];
1374 for (i = 0; i < ctcount; i++) {
1376 unsigned int dlen = COMP_BUF_SIZE;
1378 memset(result, 0, sizeof (result));
1380 ilen = ctemplate[i].inlen;
1381 ret = crypto_comp_compress(tfm, ctemplate[i].input,
1382 ilen, result, &dlen);
1384 printk(KERN_ERR "alg: comp: compression failed "
1385 "on test %d for %s: ret=%d\n", i + 1, algo,
1390 if (dlen != ctemplate[i].outlen) {
1391 printk(KERN_ERR "alg: comp: Compression test %d "
1392 "failed for %s: output len = %d\n", i + 1, algo,
1398 if (memcmp(result, ctemplate[i].output, dlen)) {
1399 printk(KERN_ERR "alg: comp: Compression test %d "
1400 "failed for %s\n", i + 1, algo);
1401 hexdump(result, dlen);
1407 for (i = 0; i < dtcount; i++) {
1409 unsigned int dlen = COMP_BUF_SIZE;
1411 memset(result, 0, sizeof (result));
1413 ilen = dtemplate[i].inlen;
1414 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
1415 ilen, result, &dlen);
1417 printk(KERN_ERR "alg: comp: decompression failed "
1418 "on test %d for %s: ret=%d\n", i + 1, algo,
1423 if (dlen != dtemplate[i].outlen) {
1424 printk(KERN_ERR "alg: comp: Decompression test %d "
1425 "failed for %s: output len = %d\n", i + 1, algo,
1431 if (memcmp(result, dtemplate[i].output, dlen)) {
1432 printk(KERN_ERR "alg: comp: Decompression test %d "
1433 "failed for %s\n", i + 1, algo);
1434 hexdump(result, dlen);
1446 static int test_acomp(struct crypto_acomp *tfm, struct comp_testvec *ctemplate,
1447 struct comp_testvec *dtemplate, int ctcount, int dtcount)
1449 const char *algo = crypto_tfm_alg_driver_name(crypto_acomp_tfm(tfm));
1453 struct scatterlist src, dst;
1454 struct acomp_req *req;
1455 struct tcrypt_result result;
1457 output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL);
1461 for (i = 0; i < ctcount; i++) {
1462 unsigned int dlen = COMP_BUF_SIZE;
1463 int ilen = ctemplate[i].inlen;
1466 input_vec = kmalloc(ilen, GFP_KERNEL);
1472 memcpy(input_vec, ctemplate[i].input, ilen);
1473 memset(output, 0, dlen);
1474 init_completion(&result.completion);
1475 sg_init_one(&src, input_vec, ilen);
1476 sg_init_one(&dst, output, dlen);
1478 req = acomp_request_alloc(tfm);
1480 pr_err("alg: acomp: request alloc failed for %s\n",
1487 acomp_request_set_params(req, &src, &dst, ilen, dlen);
1488 acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1489 tcrypt_complete, &result);
1491 ret = wait_async_op(&result, crypto_acomp_compress(req));
1493 pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n",
1496 acomp_request_free(req);
1500 if (req->dlen != ctemplate[i].outlen) {
1501 pr_err("alg: acomp: Compression test %d failed for %s: output len = %d\n",
1502 i + 1, algo, req->dlen);
1505 acomp_request_free(req);
1509 if (memcmp(output, ctemplate[i].output, req->dlen)) {
1510 pr_err("alg: acomp: Compression test %d failed for %s\n",
1512 hexdump(output, req->dlen);
1515 acomp_request_free(req);
1520 acomp_request_free(req);
1523 for (i = 0; i < dtcount; i++) {
1524 unsigned int dlen = COMP_BUF_SIZE;
1525 int ilen = dtemplate[i].inlen;
1528 input_vec = kmalloc(ilen, GFP_KERNEL);
1534 memcpy(input_vec, dtemplate[i].input, ilen);
1535 memset(output, 0, dlen);
1536 init_completion(&result.completion);
1537 sg_init_one(&src, input_vec, ilen);
1538 sg_init_one(&dst, output, dlen);
1540 req = acomp_request_alloc(tfm);
1542 pr_err("alg: acomp: request alloc failed for %s\n",
1549 acomp_request_set_params(req, &src, &dst, ilen, dlen);
1550 acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1551 tcrypt_complete, &result);
1553 ret = wait_async_op(&result, crypto_acomp_decompress(req));
1555 pr_err("alg: acomp: decompression failed on test %d for %s: ret=%d\n",
1558 acomp_request_free(req);
1562 if (req->dlen != dtemplate[i].outlen) {
1563 pr_err("alg: acomp: Decompression test %d failed for %s: output len = %d\n",
1564 i + 1, algo, req->dlen);
1567 acomp_request_free(req);
1571 if (memcmp(output, dtemplate[i].output, req->dlen)) {
1572 pr_err("alg: acomp: Decompression test %d failed for %s\n",
1574 hexdump(output, req->dlen);
1577 acomp_request_free(req);
1582 acomp_request_free(req);
1592 static int test_cprng(struct crypto_rng *tfm, struct cprng_testvec *template,
1593 unsigned int tcount)
1595 const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm));
1596 int err = 0, i, j, seedsize;
1600 seedsize = crypto_rng_seedsize(tfm);
1602 seed = kmalloc(seedsize, GFP_KERNEL);
1604 printk(KERN_ERR "alg: cprng: Failed to allocate seed space "
1609 for (i = 0; i < tcount; i++) {
1610 memset(result, 0, 32);
1612 memcpy(seed, template[i].v, template[i].vlen);
1613 memcpy(seed + template[i].vlen, template[i].key,
1615 memcpy(seed + template[i].vlen + template[i].klen,
1616 template[i].dt, template[i].dtlen);
1618 err = crypto_rng_reset(tfm, seed, seedsize);
1620 printk(KERN_ERR "alg: cprng: Failed to reset rng "
1625 for (j = 0; j < template[i].loops; j++) {
1626 err = crypto_rng_get_bytes(tfm, result,
1629 printk(KERN_ERR "alg: cprng: Failed to obtain "
1630 "the correct amount of random data for "
1631 "%s (requested %d)\n", algo,
1637 err = memcmp(result, template[i].result,
1640 printk(KERN_ERR "alg: cprng: Test %d failed for %s\n",
1642 hexdump(result, template[i].rlen);
1653 static int alg_test_aead(const struct alg_test_desc *desc, const char *driver,
1656 struct crypto_aead *tfm;
1659 tfm = crypto_alloc_aead(driver, type, mask);
1661 printk(KERN_ERR "alg: aead: Failed to load transform for %s: "
1662 "%ld\n", driver, PTR_ERR(tfm));
1663 return PTR_ERR(tfm);
1666 if (desc->suite.aead.enc.vecs) {
1667 err = test_aead(tfm, ENCRYPT, desc->suite.aead.enc.vecs,
1668 desc->suite.aead.enc.count);
1673 if (!err && desc->suite.aead.dec.vecs)
1674 err = test_aead(tfm, DECRYPT, desc->suite.aead.dec.vecs,
1675 desc->suite.aead.dec.count);
1678 crypto_free_aead(tfm);
1682 static int alg_test_cipher(const struct alg_test_desc *desc,
1683 const char *driver, u32 type, u32 mask)
1685 struct crypto_cipher *tfm;
1688 tfm = crypto_alloc_cipher(driver, type, mask);
1690 printk(KERN_ERR "alg: cipher: Failed to load transform for "
1691 "%s: %ld\n", driver, PTR_ERR(tfm));
1692 return PTR_ERR(tfm);
1695 if (desc->suite.cipher.enc.vecs) {
1696 err = test_cipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1697 desc->suite.cipher.enc.count);
1702 if (desc->suite.cipher.dec.vecs)
1703 err = test_cipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1704 desc->suite.cipher.dec.count);
1707 crypto_free_cipher(tfm);
1711 static int alg_test_skcipher(const struct alg_test_desc *desc,
1712 const char *driver, u32 type, u32 mask)
1714 struct crypto_skcipher *tfm;
1717 tfm = crypto_alloc_skcipher(driver, type, mask);
1719 printk(KERN_ERR "alg: skcipher: Failed to load transform for "
1720 "%s: %ld\n", driver, PTR_ERR(tfm));
1721 return PTR_ERR(tfm);
1724 if (desc->suite.cipher.enc.vecs) {
1725 err = test_skcipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1726 desc->suite.cipher.enc.count);
1731 if (desc->suite.cipher.dec.vecs)
1732 err = test_skcipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1733 desc->suite.cipher.dec.count);
1736 crypto_free_skcipher(tfm);
1740 static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
1743 struct crypto_comp *comp;
1744 struct crypto_acomp *acomp;
1746 u32 algo_type = type & CRYPTO_ALG_TYPE_ACOMPRESS_MASK;
1748 if (algo_type == CRYPTO_ALG_TYPE_ACOMPRESS) {
1749 acomp = crypto_alloc_acomp(driver, type, mask);
1750 if (IS_ERR(acomp)) {
1751 pr_err("alg: acomp: Failed to load transform for %s: %ld\n",
1752 driver, PTR_ERR(acomp));
1753 return PTR_ERR(acomp);
1755 err = test_acomp(acomp, desc->suite.comp.comp.vecs,
1756 desc->suite.comp.decomp.vecs,
1757 desc->suite.comp.comp.count,
1758 desc->suite.comp.decomp.count);
1759 crypto_free_acomp(acomp);
1761 comp = crypto_alloc_comp(driver, type, mask);
1763 pr_err("alg: comp: Failed to load transform for %s: %ld\n",
1764 driver, PTR_ERR(comp));
1765 return PTR_ERR(comp);
1768 err = test_comp(comp, desc->suite.comp.comp.vecs,
1769 desc->suite.comp.decomp.vecs,
1770 desc->suite.comp.comp.count,
1771 desc->suite.comp.decomp.count);
1773 crypto_free_comp(comp);
1778 static int alg_test_hash(const struct alg_test_desc *desc, const char *driver,
1781 struct crypto_ahash *tfm;
1784 tfm = crypto_alloc_ahash(driver, type, mask);
1786 printk(KERN_ERR "alg: hash: Failed to load transform for %s: "
1787 "%ld\n", driver, PTR_ERR(tfm));
1788 return PTR_ERR(tfm);
1791 err = test_hash(tfm, desc->suite.hash.vecs,
1792 desc->suite.hash.count, true);
1794 err = test_hash(tfm, desc->suite.hash.vecs,
1795 desc->suite.hash.count, false);
1797 crypto_free_ahash(tfm);
1801 static int alg_test_crc32c(const struct alg_test_desc *desc,
1802 const char *driver, u32 type, u32 mask)
1804 struct crypto_shash *tfm;
1808 err = alg_test_hash(desc, driver, type, mask);
1812 tfm = crypto_alloc_shash(driver, type, mask);
1814 printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: "
1815 "%ld\n", driver, PTR_ERR(tfm));
1821 SHASH_DESC_ON_STACK(shash, tfm);
1822 u32 *ctx = (u32 *)shash_desc_ctx(shash);
1827 *ctx = le32_to_cpu(420553207);
1828 err = crypto_shash_final(shash, (u8 *)&val);
1830 printk(KERN_ERR "alg: crc32c: Operation failed for "
1831 "%s: %d\n", driver, err);
1835 if (val != ~420553207) {
1836 printk(KERN_ERR "alg: crc32c: Test failed for %s: "
1837 "%d\n", driver, val);
1842 crypto_free_shash(tfm);
1848 static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver,
1851 struct crypto_rng *rng;
1854 rng = crypto_alloc_rng(driver, type, mask);
1856 printk(KERN_ERR "alg: cprng: Failed to load transform for %s: "
1857 "%ld\n", driver, PTR_ERR(rng));
1858 return PTR_ERR(rng);
1861 err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count);
1863 crypto_free_rng(rng);
1869 static int drbg_cavs_test(struct drbg_testvec *test, int pr,
1870 const char *driver, u32 type, u32 mask)
1873 struct crypto_rng *drng;
1874 struct drbg_test_data test_data;
1875 struct drbg_string addtl, pers, testentropy;
1876 unsigned char *buf = kzalloc(test->expectedlen, GFP_KERNEL);
1881 drng = crypto_alloc_rng(driver, type, mask);
1883 printk(KERN_ERR "alg: drbg: could not allocate DRNG handle for "
1889 test_data.testentropy = &testentropy;
1890 drbg_string_fill(&testentropy, test->entropy, test->entropylen);
1891 drbg_string_fill(&pers, test->pers, test->perslen);
1892 ret = crypto_drbg_reset_test(drng, &pers, &test_data);
1894 printk(KERN_ERR "alg: drbg: Failed to reset rng\n");
1898 drbg_string_fill(&addtl, test->addtla, test->addtllen);
1900 drbg_string_fill(&testentropy, test->entpra, test->entprlen);
1901 ret = crypto_drbg_get_bytes_addtl_test(drng,
1902 buf, test->expectedlen, &addtl, &test_data);
1904 ret = crypto_drbg_get_bytes_addtl(drng,
1905 buf, test->expectedlen, &addtl);
1908 printk(KERN_ERR "alg: drbg: could not obtain random data for "
1909 "driver %s\n", driver);
1913 drbg_string_fill(&addtl, test->addtlb, test->addtllen);
1915 drbg_string_fill(&testentropy, test->entprb, test->entprlen);
1916 ret = crypto_drbg_get_bytes_addtl_test(drng,
1917 buf, test->expectedlen, &addtl, &test_data);
1919 ret = crypto_drbg_get_bytes_addtl(drng,
1920 buf, test->expectedlen, &addtl);
1923 printk(KERN_ERR "alg: drbg: could not obtain random data for "
1924 "driver %s\n", driver);
1928 ret = memcmp(test->expected, buf, test->expectedlen);
1931 crypto_free_rng(drng);
1937 static int alg_test_drbg(const struct alg_test_desc *desc, const char *driver,
1943 struct drbg_testvec *template = desc->suite.drbg.vecs;
1944 unsigned int tcount = desc->suite.drbg.count;
1946 if (0 == memcmp(driver, "drbg_pr_", 8))
1949 for (i = 0; i < tcount; i++) {
1950 err = drbg_cavs_test(&template[i], pr, driver, type, mask);
1952 printk(KERN_ERR "alg: drbg: Test %d failed for %s\n",
1962 static int do_test_kpp(struct crypto_kpp *tfm, struct kpp_testvec *vec,
1965 struct kpp_request *req;
1966 void *input_buf = NULL;
1967 void *output_buf = NULL;
1968 struct tcrypt_result result;
1969 unsigned int out_len_max;
1971 struct scatterlist src, dst;
1973 req = kpp_request_alloc(tfm, GFP_KERNEL);
1977 init_completion(&result.completion);
1979 err = crypto_kpp_set_secret(tfm, vec->secret, vec->secret_size);
1983 out_len_max = crypto_kpp_maxsize(tfm);
1984 output_buf = kzalloc(out_len_max, GFP_KERNEL);
1990 /* Use appropriate parameter as base */
1991 kpp_request_set_input(req, NULL, 0);
1992 sg_init_one(&dst, output_buf, out_len_max);
1993 kpp_request_set_output(req, &dst, out_len_max);
1994 kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1995 tcrypt_complete, &result);
1997 /* Compute public key */
1998 err = wait_async_op(&result, crypto_kpp_generate_public_key(req));
2000 pr_err("alg: %s: generate public key test failed. err %d\n",
2004 /* Verify calculated public key */
2005 if (memcmp(vec->expected_a_public, sg_virt(req->dst),
2006 vec->expected_a_public_size)) {
2007 pr_err("alg: %s: generate public key test failed. Invalid output\n",
2013 /* Calculate shared secret key by using counter part (b) public key. */
2014 input_buf = kzalloc(vec->b_public_size, GFP_KERNEL);
2020 memcpy(input_buf, vec->b_public, vec->b_public_size);
2021 sg_init_one(&src, input_buf, vec->b_public_size);
2022 sg_init_one(&dst, output_buf, out_len_max);
2023 kpp_request_set_input(req, &src, vec->b_public_size);
2024 kpp_request_set_output(req, &dst, out_len_max);
2025 kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
2026 tcrypt_complete, &result);
2027 err = wait_async_op(&result, crypto_kpp_compute_shared_secret(req));
2029 pr_err("alg: %s: compute shard secret test failed. err %d\n",
2034 * verify shared secret from which the user will derive
2035 * secret key by executing whatever hash it has chosen
2037 if (memcmp(vec->expected_ss, sg_virt(req->dst),
2038 vec->expected_ss_size)) {
2039 pr_err("alg: %s: compute shared secret test failed. Invalid output\n",
2049 kpp_request_free(req);
2053 static int test_kpp(struct crypto_kpp *tfm, const char *alg,
2054 struct kpp_testvec *vecs, unsigned int tcount)
2058 for (i = 0; i < tcount; i++) {
2059 ret = do_test_kpp(tfm, vecs++, alg);
2061 pr_err("alg: %s: test failed on vector %d, err=%d\n",
2069 static int alg_test_kpp(const struct alg_test_desc *desc, const char *driver,
2072 struct crypto_kpp *tfm;
2075 tfm = crypto_alloc_kpp(driver, type, mask);
2077 pr_err("alg: kpp: Failed to load tfm for %s: %ld\n",
2078 driver, PTR_ERR(tfm));
2079 return PTR_ERR(tfm);
2081 if (desc->suite.kpp.vecs)
2082 err = test_kpp(tfm, desc->alg, desc->suite.kpp.vecs,
2083 desc->suite.kpp.count);
2085 crypto_free_kpp(tfm);
2089 static int test_akcipher_one(struct crypto_akcipher *tfm,
2090 struct akcipher_testvec *vecs)
2092 char *xbuf[XBUFSIZE];
2093 struct akcipher_request *req;
2094 void *outbuf_enc = NULL;
2095 void *outbuf_dec = NULL;
2096 struct tcrypt_result result;
2097 unsigned int out_len_max, out_len = 0;
2099 struct scatterlist src, dst, src_tab[2];
2101 if (testmgr_alloc_buf(xbuf))
2104 req = akcipher_request_alloc(tfm, GFP_KERNEL);
2108 init_completion(&result.completion);
2110 if (vecs->public_key_vec)
2111 err = crypto_akcipher_set_pub_key(tfm, vecs->key,
2114 err = crypto_akcipher_set_priv_key(tfm, vecs->key,
2120 out_len_max = crypto_akcipher_maxsize(tfm);
2121 outbuf_enc = kzalloc(out_len_max, GFP_KERNEL);
2125 if (WARN_ON(vecs->m_size > PAGE_SIZE))
2128 memcpy(xbuf[0], vecs->m, vecs->m_size);
2130 sg_init_table(src_tab, 2);
2131 sg_set_buf(&src_tab[0], xbuf[0], 8);
2132 sg_set_buf(&src_tab[1], xbuf[0] + 8, vecs->m_size - 8);
2133 sg_init_one(&dst, outbuf_enc, out_len_max);
2134 akcipher_request_set_crypt(req, src_tab, &dst, vecs->m_size,
2136 akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
2137 tcrypt_complete, &result);
2139 /* Run RSA encrypt - c = m^e mod n;*/
2140 err = wait_async_op(&result, crypto_akcipher_encrypt(req));
2142 pr_err("alg: akcipher: encrypt test failed. err %d\n", err);
2145 if (req->dst_len != vecs->c_size) {
2146 pr_err("alg: akcipher: encrypt test failed. Invalid output len\n");
2150 /* verify that encrypted message is equal to expected */
2151 if (memcmp(vecs->c, outbuf_enc, vecs->c_size)) {
2152 pr_err("alg: akcipher: encrypt test failed. Invalid output\n");
2153 hexdump(outbuf_enc, vecs->c_size);
2157 /* Don't invoke decrypt for vectors with public key */
2158 if (vecs->public_key_vec) {
2162 outbuf_dec = kzalloc(out_len_max, GFP_KERNEL);
2168 if (WARN_ON(vecs->c_size > PAGE_SIZE))
2171 memcpy(xbuf[0], vecs->c, vecs->c_size);
2173 sg_init_one(&src, xbuf[0], vecs->c_size);
2174 sg_init_one(&dst, outbuf_dec, out_len_max);
2175 init_completion(&result.completion);
2176 akcipher_request_set_crypt(req, &src, &dst, vecs->c_size, out_len_max);
2178 /* Run RSA decrypt - m = c^d mod n;*/
2179 err = wait_async_op(&result, crypto_akcipher_decrypt(req));
2181 pr_err("alg: akcipher: decrypt test failed. err %d\n", err);
2184 out_len = req->dst_len;
2185 if (out_len < vecs->m_size) {
2186 pr_err("alg: akcipher: decrypt test failed. "
2187 "Invalid output len %u\n", out_len);
2191 /* verify that decrypted message is equal to the original msg */
2192 if (memchr_inv(outbuf_dec, 0, out_len - vecs->m_size) ||
2193 memcmp(vecs->m, outbuf_dec + out_len - vecs->m_size,
2195 pr_err("alg: akcipher: decrypt test failed. Invalid output\n");
2196 hexdump(outbuf_dec, out_len);
2203 akcipher_request_free(req);
2205 testmgr_free_buf(xbuf);
2209 static int test_akcipher(struct crypto_akcipher *tfm, const char *alg,
2210 struct akcipher_testvec *vecs, unsigned int tcount)
2213 crypto_tfm_alg_driver_name(crypto_akcipher_tfm(tfm));
2216 for (i = 0; i < tcount; i++) {
2217 ret = test_akcipher_one(tfm, vecs++);
2221 pr_err("alg: akcipher: test %d failed for %s, err=%d\n",
2228 static int alg_test_akcipher(const struct alg_test_desc *desc,
2229 const char *driver, u32 type, u32 mask)
2231 struct crypto_akcipher *tfm;
2234 tfm = crypto_alloc_akcipher(driver, type, mask);
2236 pr_err("alg: akcipher: Failed to load tfm for %s: %ld\n",
2237 driver, PTR_ERR(tfm));
2238 return PTR_ERR(tfm);
2240 if (desc->suite.akcipher.vecs)
2241 err = test_akcipher(tfm, desc->alg, desc->suite.akcipher.vecs,
2242 desc->suite.akcipher.count);
2244 crypto_free_akcipher(tfm);
2248 static int alg_test_null(const struct alg_test_desc *desc,
2249 const char *driver, u32 type, u32 mask)
2254 /* Please keep this list sorted by algorithm name. */
2255 static const struct alg_test_desc alg_test_descs[] = {
2257 .alg = "ansi_cprng",
2258 .test = alg_test_cprng,
2261 .vecs = ansi_cprng_aes_tv_template,
2262 .count = ANSI_CPRNG_AES_TEST_VECTORS
2266 .alg = "authenc(hmac(md5),ecb(cipher_null))",
2267 .test = alg_test_aead,
2271 .vecs = hmac_md5_ecb_cipher_null_enc_tv_template,
2272 .count = HMAC_MD5_ECB_CIPHER_NULL_ENC_TEST_VECTORS
2275 .vecs = hmac_md5_ecb_cipher_null_dec_tv_template,
2276 .count = HMAC_MD5_ECB_CIPHER_NULL_DEC_TEST_VECTORS
2281 .alg = "authenc(hmac(sha1),cbc(aes))",
2282 .test = alg_test_aead,
2287 hmac_sha1_aes_cbc_enc_tv_temp,
2289 HMAC_SHA1_AES_CBC_ENC_TEST_VEC
2294 .alg = "authenc(hmac(sha1),cbc(des))",
2295 .test = alg_test_aead,
2300 hmac_sha1_des_cbc_enc_tv_temp,
2302 HMAC_SHA1_DES_CBC_ENC_TEST_VEC
2307 .alg = "authenc(hmac(sha1),cbc(des3_ede))",
2308 .test = alg_test_aead,
2314 hmac_sha1_des3_ede_cbc_enc_tv_temp,
2316 HMAC_SHA1_DES3_EDE_CBC_ENC_TEST_VEC
2321 .alg = "authenc(hmac(sha1),ctr(aes))",
2322 .test = alg_test_null,
2325 .alg = "authenc(hmac(sha1),ecb(cipher_null))",
2326 .test = alg_test_aead,
2331 hmac_sha1_ecb_cipher_null_enc_tv_temp,
2333 HMAC_SHA1_ECB_CIPHER_NULL_ENC_TEST_VEC
2337 hmac_sha1_ecb_cipher_null_dec_tv_temp,
2339 HMAC_SHA1_ECB_CIPHER_NULL_DEC_TEST_VEC
2344 .alg = "authenc(hmac(sha1),rfc3686(ctr(aes)))",
2345 .test = alg_test_null,
2348 .alg = "authenc(hmac(sha224),cbc(des))",
2349 .test = alg_test_aead,
2354 hmac_sha224_des_cbc_enc_tv_temp,
2356 HMAC_SHA224_DES_CBC_ENC_TEST_VEC
2361 .alg = "authenc(hmac(sha224),cbc(des3_ede))",
2362 .test = alg_test_aead,
2368 hmac_sha224_des3_ede_cbc_enc_tv_temp,
2370 HMAC_SHA224_DES3_EDE_CBC_ENC_TEST_VEC
2375 .alg = "authenc(hmac(sha256),cbc(aes))",
2376 .test = alg_test_aead,
2382 hmac_sha256_aes_cbc_enc_tv_temp,
2384 HMAC_SHA256_AES_CBC_ENC_TEST_VEC
2389 .alg = "authenc(hmac(sha256),cbc(des))",
2390 .test = alg_test_aead,
2395 hmac_sha256_des_cbc_enc_tv_temp,
2397 HMAC_SHA256_DES_CBC_ENC_TEST_VEC
2402 .alg = "authenc(hmac(sha256),cbc(des3_ede))",
2403 .test = alg_test_aead,
2409 hmac_sha256_des3_ede_cbc_enc_tv_temp,
2411 HMAC_SHA256_DES3_EDE_CBC_ENC_TEST_VEC
2416 .alg = "authenc(hmac(sha256),ctr(aes))",
2417 .test = alg_test_null,
2420 .alg = "authenc(hmac(sha256),rfc3686(ctr(aes)))",
2421 .test = alg_test_null,
2424 .alg = "authenc(hmac(sha384),cbc(des))",
2425 .test = alg_test_aead,
2430 hmac_sha384_des_cbc_enc_tv_temp,
2432 HMAC_SHA384_DES_CBC_ENC_TEST_VEC
2437 .alg = "authenc(hmac(sha384),cbc(des3_ede))",
2438 .test = alg_test_aead,
2444 hmac_sha384_des3_ede_cbc_enc_tv_temp,
2446 HMAC_SHA384_DES3_EDE_CBC_ENC_TEST_VEC
2451 .alg = "authenc(hmac(sha384),ctr(aes))",
2452 .test = alg_test_null,
2455 .alg = "authenc(hmac(sha384),rfc3686(ctr(aes)))",
2456 .test = alg_test_null,
2459 .alg = "authenc(hmac(sha512),cbc(aes))",
2461 .test = alg_test_aead,
2466 hmac_sha512_aes_cbc_enc_tv_temp,
2468 HMAC_SHA512_AES_CBC_ENC_TEST_VEC
2473 .alg = "authenc(hmac(sha512),cbc(des))",
2474 .test = alg_test_aead,
2479 hmac_sha512_des_cbc_enc_tv_temp,
2481 HMAC_SHA512_DES_CBC_ENC_TEST_VEC
2486 .alg = "authenc(hmac(sha512),cbc(des3_ede))",
2487 .test = alg_test_aead,
2493 hmac_sha512_des3_ede_cbc_enc_tv_temp,
2495 HMAC_SHA512_DES3_EDE_CBC_ENC_TEST_VEC
2500 .alg = "authenc(hmac(sha512),ctr(aes))",
2501 .test = alg_test_null,
2504 .alg = "authenc(hmac(sha512),rfc3686(ctr(aes)))",
2505 .test = alg_test_null,
2509 .test = alg_test_skcipher,
2514 .vecs = aes_cbc_enc_tv_template,
2515 .count = AES_CBC_ENC_TEST_VECTORS
2518 .vecs = aes_cbc_dec_tv_template,
2519 .count = AES_CBC_DEC_TEST_VECTORS
2524 .alg = "cbc(anubis)",
2525 .test = alg_test_skcipher,
2529 .vecs = anubis_cbc_enc_tv_template,
2530 .count = ANUBIS_CBC_ENC_TEST_VECTORS
2533 .vecs = anubis_cbc_dec_tv_template,
2534 .count = ANUBIS_CBC_DEC_TEST_VECTORS
2539 .alg = "cbc(blowfish)",
2540 .test = alg_test_skcipher,
2544 .vecs = bf_cbc_enc_tv_template,
2545 .count = BF_CBC_ENC_TEST_VECTORS
2548 .vecs = bf_cbc_dec_tv_template,
2549 .count = BF_CBC_DEC_TEST_VECTORS
2554 .alg = "cbc(camellia)",
2555 .test = alg_test_skcipher,
2559 .vecs = camellia_cbc_enc_tv_template,
2560 .count = CAMELLIA_CBC_ENC_TEST_VECTORS
2563 .vecs = camellia_cbc_dec_tv_template,
2564 .count = CAMELLIA_CBC_DEC_TEST_VECTORS
2569 .alg = "cbc(cast5)",
2570 .test = alg_test_skcipher,
2574 .vecs = cast5_cbc_enc_tv_template,
2575 .count = CAST5_CBC_ENC_TEST_VECTORS
2578 .vecs = cast5_cbc_dec_tv_template,
2579 .count = CAST5_CBC_DEC_TEST_VECTORS
2584 .alg = "cbc(cast6)",
2585 .test = alg_test_skcipher,
2589 .vecs = cast6_cbc_enc_tv_template,
2590 .count = CAST6_CBC_ENC_TEST_VECTORS
2593 .vecs = cast6_cbc_dec_tv_template,
2594 .count = CAST6_CBC_DEC_TEST_VECTORS
2600 .test = alg_test_skcipher,
2604 .vecs = des_cbc_enc_tv_template,
2605 .count = DES_CBC_ENC_TEST_VECTORS
2608 .vecs = des_cbc_dec_tv_template,
2609 .count = DES_CBC_DEC_TEST_VECTORS
2614 .alg = "cbc(des3_ede)",
2615 .test = alg_test_skcipher,
2620 .vecs = des3_ede_cbc_enc_tv_template,
2621 .count = DES3_EDE_CBC_ENC_TEST_VECTORS
2624 .vecs = des3_ede_cbc_dec_tv_template,
2625 .count = DES3_EDE_CBC_DEC_TEST_VECTORS
2630 .alg = "cbc(serpent)",
2631 .test = alg_test_skcipher,
2635 .vecs = serpent_cbc_enc_tv_template,
2636 .count = SERPENT_CBC_ENC_TEST_VECTORS
2639 .vecs = serpent_cbc_dec_tv_template,
2640 .count = SERPENT_CBC_DEC_TEST_VECTORS
2645 .alg = "cbc(twofish)",
2646 .test = alg_test_skcipher,
2650 .vecs = tf_cbc_enc_tv_template,
2651 .count = TF_CBC_ENC_TEST_VECTORS
2654 .vecs = tf_cbc_dec_tv_template,
2655 .count = TF_CBC_DEC_TEST_VECTORS
2661 .test = alg_test_aead,
2666 .vecs = aes_ccm_enc_tv_template,
2667 .count = AES_CCM_ENC_TEST_VECTORS
2670 .vecs = aes_ccm_dec_tv_template,
2671 .count = AES_CCM_DEC_TEST_VECTORS
2677 .test = alg_test_skcipher,
2681 .vecs = chacha20_enc_tv_template,
2682 .count = CHACHA20_ENC_TEST_VECTORS
2685 .vecs = chacha20_enc_tv_template,
2686 .count = CHACHA20_ENC_TEST_VECTORS
2693 .test = alg_test_hash,
2696 .vecs = aes_cmac128_tv_template,
2697 .count = CMAC_AES_TEST_VECTORS
2701 .alg = "cmac(des3_ede)",
2703 .test = alg_test_hash,
2706 .vecs = des3_ede_cmac64_tv_template,
2707 .count = CMAC_DES3_EDE_TEST_VECTORS
2711 .alg = "compress_null",
2712 .test = alg_test_null,
2715 .test = alg_test_hash,
2718 .vecs = crc32_tv_template,
2719 .count = CRC32_TEST_VECTORS
2724 .test = alg_test_crc32c,
2728 .vecs = crc32c_tv_template,
2729 .count = CRC32C_TEST_VECTORS
2734 .test = alg_test_hash,
2738 .vecs = crct10dif_tv_template,
2739 .count = CRCT10DIF_TEST_VECTORS
2744 .test = alg_test_skcipher,
2749 .vecs = aes_ctr_enc_tv_template,
2750 .count = AES_CTR_ENC_TEST_VECTORS
2753 .vecs = aes_ctr_dec_tv_template,
2754 .count = AES_CTR_DEC_TEST_VECTORS
2759 .alg = "ctr(blowfish)",
2760 .test = alg_test_skcipher,
2764 .vecs = bf_ctr_enc_tv_template,
2765 .count = BF_CTR_ENC_TEST_VECTORS
2768 .vecs = bf_ctr_dec_tv_template,
2769 .count = BF_CTR_DEC_TEST_VECTORS
2774 .alg = "ctr(camellia)",
2775 .test = alg_test_skcipher,
2779 .vecs = camellia_ctr_enc_tv_template,
2780 .count = CAMELLIA_CTR_ENC_TEST_VECTORS
2783 .vecs = camellia_ctr_dec_tv_template,
2784 .count = CAMELLIA_CTR_DEC_TEST_VECTORS
2789 .alg = "ctr(cast5)",
2790 .test = alg_test_skcipher,
2794 .vecs = cast5_ctr_enc_tv_template,
2795 .count = CAST5_CTR_ENC_TEST_VECTORS
2798 .vecs = cast5_ctr_dec_tv_template,
2799 .count = CAST5_CTR_DEC_TEST_VECTORS
2804 .alg = "ctr(cast6)",
2805 .test = alg_test_skcipher,
2809 .vecs = cast6_ctr_enc_tv_template,
2810 .count = CAST6_CTR_ENC_TEST_VECTORS
2813 .vecs = cast6_ctr_dec_tv_template,
2814 .count = CAST6_CTR_DEC_TEST_VECTORS
2820 .test = alg_test_skcipher,
2824 .vecs = des_ctr_enc_tv_template,
2825 .count = DES_CTR_ENC_TEST_VECTORS
2828 .vecs = des_ctr_dec_tv_template,
2829 .count = DES_CTR_DEC_TEST_VECTORS
2834 .alg = "ctr(des3_ede)",
2835 .test = alg_test_skcipher,
2839 .vecs = des3_ede_ctr_enc_tv_template,
2840 .count = DES3_EDE_CTR_ENC_TEST_VECTORS
2843 .vecs = des3_ede_ctr_dec_tv_template,
2844 .count = DES3_EDE_CTR_DEC_TEST_VECTORS
2849 .alg = "ctr(serpent)",
2850 .test = alg_test_skcipher,
2854 .vecs = serpent_ctr_enc_tv_template,
2855 .count = SERPENT_CTR_ENC_TEST_VECTORS
2858 .vecs = serpent_ctr_dec_tv_template,
2859 .count = SERPENT_CTR_DEC_TEST_VECTORS
2864 .alg = "ctr(twofish)",
2865 .test = alg_test_skcipher,
2869 .vecs = tf_ctr_enc_tv_template,
2870 .count = TF_CTR_ENC_TEST_VECTORS
2873 .vecs = tf_ctr_dec_tv_template,
2874 .count = TF_CTR_DEC_TEST_VECTORS
2879 .alg = "cts(cbc(aes))",
2880 .test = alg_test_skcipher,
2884 .vecs = cts_mode_enc_tv_template,
2885 .count = CTS_MODE_ENC_TEST_VECTORS
2888 .vecs = cts_mode_dec_tv_template,
2889 .count = CTS_MODE_DEC_TEST_VECTORS
2895 .test = alg_test_comp,
2900 .vecs = deflate_comp_tv_template,
2901 .count = DEFLATE_COMP_TEST_VECTORS
2904 .vecs = deflate_decomp_tv_template,
2905 .count = DEFLATE_DECOMP_TEST_VECTORS
2911 .test = alg_test_kpp,
2915 .vecs = dh_tv_template,
2916 .count = DH_TEST_VECTORS
2920 .alg = "digest_null",
2921 .test = alg_test_null,
2923 .alg = "drbg_nopr_ctr_aes128",
2924 .test = alg_test_drbg,
2928 .vecs = drbg_nopr_ctr_aes128_tv_template,
2929 .count = ARRAY_SIZE(drbg_nopr_ctr_aes128_tv_template)
2933 .alg = "drbg_nopr_ctr_aes192",
2934 .test = alg_test_drbg,
2938 .vecs = drbg_nopr_ctr_aes192_tv_template,
2939 .count = ARRAY_SIZE(drbg_nopr_ctr_aes192_tv_template)
2943 .alg = "drbg_nopr_ctr_aes256",
2944 .test = alg_test_drbg,
2948 .vecs = drbg_nopr_ctr_aes256_tv_template,
2949 .count = ARRAY_SIZE(drbg_nopr_ctr_aes256_tv_template)
2954 * There is no need to specifically test the DRBG with every
2955 * backend cipher -- covered by drbg_nopr_hmac_sha256 test
2957 .alg = "drbg_nopr_hmac_sha1",
2959 .test = alg_test_null,
2961 .alg = "drbg_nopr_hmac_sha256",
2962 .test = alg_test_drbg,
2966 .vecs = drbg_nopr_hmac_sha256_tv_template,
2968 ARRAY_SIZE(drbg_nopr_hmac_sha256_tv_template)
2972 /* covered by drbg_nopr_hmac_sha256 test */
2973 .alg = "drbg_nopr_hmac_sha384",
2975 .test = alg_test_null,
2977 .alg = "drbg_nopr_hmac_sha512",
2978 .test = alg_test_null,
2981 .alg = "drbg_nopr_sha1",
2983 .test = alg_test_null,
2985 .alg = "drbg_nopr_sha256",
2986 .test = alg_test_drbg,
2990 .vecs = drbg_nopr_sha256_tv_template,
2991 .count = ARRAY_SIZE(drbg_nopr_sha256_tv_template)
2995 /* covered by drbg_nopr_sha256 test */
2996 .alg = "drbg_nopr_sha384",
2998 .test = alg_test_null,
3000 .alg = "drbg_nopr_sha512",
3002 .test = alg_test_null,
3004 .alg = "drbg_pr_ctr_aes128",
3005 .test = alg_test_drbg,
3009 .vecs = drbg_pr_ctr_aes128_tv_template,
3010 .count = ARRAY_SIZE(drbg_pr_ctr_aes128_tv_template)
3014 /* covered by drbg_pr_ctr_aes128 test */
3015 .alg = "drbg_pr_ctr_aes192",
3017 .test = alg_test_null,
3019 .alg = "drbg_pr_ctr_aes256",
3021 .test = alg_test_null,
3023 .alg = "drbg_pr_hmac_sha1",
3025 .test = alg_test_null,
3027 .alg = "drbg_pr_hmac_sha256",
3028 .test = alg_test_drbg,
3032 .vecs = drbg_pr_hmac_sha256_tv_template,
3033 .count = ARRAY_SIZE(drbg_pr_hmac_sha256_tv_template)
3037 /* covered by drbg_pr_hmac_sha256 test */
3038 .alg = "drbg_pr_hmac_sha384",
3040 .test = alg_test_null,
3042 .alg = "drbg_pr_hmac_sha512",
3043 .test = alg_test_null,
3046 .alg = "drbg_pr_sha1",
3048 .test = alg_test_null,
3050 .alg = "drbg_pr_sha256",
3051 .test = alg_test_drbg,
3055 .vecs = drbg_pr_sha256_tv_template,
3056 .count = ARRAY_SIZE(drbg_pr_sha256_tv_template)
3060 /* covered by drbg_pr_sha256 test */
3061 .alg = "drbg_pr_sha384",
3063 .test = alg_test_null,
3065 .alg = "drbg_pr_sha512",
3067 .test = alg_test_null,
3070 .test = alg_test_skcipher,
3075 .vecs = aes_enc_tv_template,
3076 .count = AES_ENC_TEST_VECTORS
3079 .vecs = aes_dec_tv_template,
3080 .count = AES_DEC_TEST_VECTORS
3085 .alg = "ecb(anubis)",
3086 .test = alg_test_skcipher,
3090 .vecs = anubis_enc_tv_template,
3091 .count = ANUBIS_ENC_TEST_VECTORS
3094 .vecs = anubis_dec_tv_template,
3095 .count = ANUBIS_DEC_TEST_VECTORS
3101 .test = alg_test_skcipher,
3105 .vecs = arc4_enc_tv_template,
3106 .count = ARC4_ENC_TEST_VECTORS
3109 .vecs = arc4_dec_tv_template,
3110 .count = ARC4_DEC_TEST_VECTORS
3115 .alg = "ecb(blowfish)",
3116 .test = alg_test_skcipher,
3120 .vecs = bf_enc_tv_template,
3121 .count = BF_ENC_TEST_VECTORS
3124 .vecs = bf_dec_tv_template,
3125 .count = BF_DEC_TEST_VECTORS
3130 .alg = "ecb(camellia)",
3131 .test = alg_test_skcipher,
3135 .vecs = camellia_enc_tv_template,
3136 .count = CAMELLIA_ENC_TEST_VECTORS
3139 .vecs = camellia_dec_tv_template,
3140 .count = CAMELLIA_DEC_TEST_VECTORS
3145 .alg = "ecb(cast5)",
3146 .test = alg_test_skcipher,
3150 .vecs = cast5_enc_tv_template,
3151 .count = CAST5_ENC_TEST_VECTORS
3154 .vecs = cast5_dec_tv_template,
3155 .count = CAST5_DEC_TEST_VECTORS
3160 .alg = "ecb(cast6)",
3161 .test = alg_test_skcipher,
3165 .vecs = cast6_enc_tv_template,
3166 .count = CAST6_ENC_TEST_VECTORS
3169 .vecs = cast6_dec_tv_template,
3170 .count = CAST6_DEC_TEST_VECTORS
3175 .alg = "ecb(cipher_null)",
3176 .test = alg_test_null,
3179 .test = alg_test_skcipher,
3183 .vecs = des_enc_tv_template,
3184 .count = DES_ENC_TEST_VECTORS
3187 .vecs = des_dec_tv_template,
3188 .count = DES_DEC_TEST_VECTORS
3193 .alg = "ecb(des3_ede)",
3194 .test = alg_test_skcipher,
3199 .vecs = des3_ede_enc_tv_template,
3200 .count = DES3_EDE_ENC_TEST_VECTORS
3203 .vecs = des3_ede_dec_tv_template,
3204 .count = DES3_EDE_DEC_TEST_VECTORS
3209 .alg = "ecb(fcrypt)",
3210 .test = alg_test_skcipher,
3214 .vecs = fcrypt_pcbc_enc_tv_template,
3218 .vecs = fcrypt_pcbc_dec_tv_template,
3224 .alg = "ecb(khazad)",
3225 .test = alg_test_skcipher,
3229 .vecs = khazad_enc_tv_template,
3230 .count = KHAZAD_ENC_TEST_VECTORS
3233 .vecs = khazad_dec_tv_template,
3234 .count = KHAZAD_DEC_TEST_VECTORS
3240 .test = alg_test_skcipher,
3244 .vecs = seed_enc_tv_template,
3245 .count = SEED_ENC_TEST_VECTORS
3248 .vecs = seed_dec_tv_template,
3249 .count = SEED_DEC_TEST_VECTORS
3254 .alg = "ecb(serpent)",
3255 .test = alg_test_skcipher,
3259 .vecs = serpent_enc_tv_template,
3260 .count = SERPENT_ENC_TEST_VECTORS
3263 .vecs = serpent_dec_tv_template,
3264 .count = SERPENT_DEC_TEST_VECTORS
3270 .test = alg_test_skcipher,
3274 .vecs = tea_enc_tv_template,
3275 .count = TEA_ENC_TEST_VECTORS
3278 .vecs = tea_dec_tv_template,
3279 .count = TEA_DEC_TEST_VECTORS
3284 .alg = "ecb(tnepres)",
3285 .test = alg_test_skcipher,
3289 .vecs = tnepres_enc_tv_template,
3290 .count = TNEPRES_ENC_TEST_VECTORS
3293 .vecs = tnepres_dec_tv_template,
3294 .count = TNEPRES_DEC_TEST_VECTORS
3299 .alg = "ecb(twofish)",
3300 .test = alg_test_skcipher,
3304 .vecs = tf_enc_tv_template,
3305 .count = TF_ENC_TEST_VECTORS
3308 .vecs = tf_dec_tv_template,
3309 .count = TF_DEC_TEST_VECTORS
3315 .test = alg_test_skcipher,
3319 .vecs = xeta_enc_tv_template,
3320 .count = XETA_ENC_TEST_VECTORS
3323 .vecs = xeta_dec_tv_template,
3324 .count = XETA_DEC_TEST_VECTORS
3330 .test = alg_test_skcipher,
3334 .vecs = xtea_enc_tv_template,
3335 .count = XTEA_ENC_TEST_VECTORS
3338 .vecs = xtea_dec_tv_template,
3339 .count = XTEA_DEC_TEST_VECTORS
3345 .test = alg_test_kpp,
3349 .vecs = ecdh_tv_template,
3350 .count = ECDH_TEST_VECTORS
3355 .test = alg_test_aead,
3360 .vecs = aes_gcm_enc_tv_template,
3361 .count = AES_GCM_ENC_TEST_VECTORS
3364 .vecs = aes_gcm_dec_tv_template,
3365 .count = AES_GCM_DEC_TEST_VECTORS
3371 .test = alg_test_hash,
3375 .vecs = ghash_tv_template,
3376 .count = GHASH_TEST_VECTORS
3380 .alg = "hmac(crc32)",
3381 .test = alg_test_hash,
3384 .vecs = bfin_crc_tv_template,
3385 .count = BFIN_CRC_TEST_VECTORS
3390 .test = alg_test_hash,
3393 .vecs = hmac_md5_tv_template,
3394 .count = HMAC_MD5_TEST_VECTORS
3398 .alg = "hmac(rmd128)",
3399 .test = alg_test_hash,
3402 .vecs = hmac_rmd128_tv_template,
3403 .count = HMAC_RMD128_TEST_VECTORS
3407 .alg = "hmac(rmd160)",
3408 .test = alg_test_hash,
3411 .vecs = hmac_rmd160_tv_template,
3412 .count = HMAC_RMD160_TEST_VECTORS
3416 .alg = "hmac(sha1)",
3417 .test = alg_test_hash,
3421 .vecs = hmac_sha1_tv_template,
3422 .count = HMAC_SHA1_TEST_VECTORS
3426 .alg = "hmac(sha224)",
3427 .test = alg_test_hash,
3431 .vecs = hmac_sha224_tv_template,
3432 .count = HMAC_SHA224_TEST_VECTORS
3436 .alg = "hmac(sha256)",
3437 .test = alg_test_hash,
3441 .vecs = hmac_sha256_tv_template,
3442 .count = HMAC_SHA256_TEST_VECTORS
3446 .alg = "hmac(sha3-224)",
3447 .test = alg_test_hash,
3451 .vecs = hmac_sha3_224_tv_template,
3452 .count = HMAC_SHA3_224_TEST_VECTORS
3456 .alg = "hmac(sha3-256)",
3457 .test = alg_test_hash,
3461 .vecs = hmac_sha3_256_tv_template,
3462 .count = HMAC_SHA3_256_TEST_VECTORS
3466 .alg = "hmac(sha3-384)",
3467 .test = alg_test_hash,
3471 .vecs = hmac_sha3_384_tv_template,
3472 .count = HMAC_SHA3_384_TEST_VECTORS
3476 .alg = "hmac(sha3-512)",
3477 .test = alg_test_hash,
3481 .vecs = hmac_sha3_512_tv_template,
3482 .count = HMAC_SHA3_512_TEST_VECTORS
3486 .alg = "hmac(sha384)",
3487 .test = alg_test_hash,
3491 .vecs = hmac_sha384_tv_template,
3492 .count = HMAC_SHA384_TEST_VECTORS
3496 .alg = "hmac(sha512)",
3497 .test = alg_test_hash,
3501 .vecs = hmac_sha512_tv_template,
3502 .count = HMAC_SHA512_TEST_VECTORS
3506 .alg = "jitterentropy_rng",
3508 .test = alg_test_null,
3511 .test = alg_test_skcipher,
3516 .vecs = aes_kw_enc_tv_template,
3517 .count = ARRAY_SIZE(aes_kw_enc_tv_template)
3520 .vecs = aes_kw_dec_tv_template,
3521 .count = ARRAY_SIZE(aes_kw_dec_tv_template)
3527 .test = alg_test_skcipher,
3531 .vecs = aes_lrw_enc_tv_template,
3532 .count = AES_LRW_ENC_TEST_VECTORS
3535 .vecs = aes_lrw_dec_tv_template,
3536 .count = AES_LRW_DEC_TEST_VECTORS
3541 .alg = "lrw(camellia)",
3542 .test = alg_test_skcipher,
3546 .vecs = camellia_lrw_enc_tv_template,
3547 .count = CAMELLIA_LRW_ENC_TEST_VECTORS
3550 .vecs = camellia_lrw_dec_tv_template,
3551 .count = CAMELLIA_LRW_DEC_TEST_VECTORS
3556 .alg = "lrw(cast6)",
3557 .test = alg_test_skcipher,
3561 .vecs = cast6_lrw_enc_tv_template,
3562 .count = CAST6_LRW_ENC_TEST_VECTORS
3565 .vecs = cast6_lrw_dec_tv_template,
3566 .count = CAST6_LRW_DEC_TEST_VECTORS
3571 .alg = "lrw(serpent)",
3572 .test = alg_test_skcipher,
3576 .vecs = serpent_lrw_enc_tv_template,
3577 .count = SERPENT_LRW_ENC_TEST_VECTORS
3580 .vecs = serpent_lrw_dec_tv_template,
3581 .count = SERPENT_LRW_DEC_TEST_VECTORS
3586 .alg = "lrw(twofish)",
3587 .test = alg_test_skcipher,
3591 .vecs = tf_lrw_enc_tv_template,
3592 .count = TF_LRW_ENC_TEST_VECTORS
3595 .vecs = tf_lrw_dec_tv_template,
3596 .count = TF_LRW_DEC_TEST_VECTORS
3602 .test = alg_test_comp,
3607 .vecs = lz4_comp_tv_template,
3608 .count = LZ4_COMP_TEST_VECTORS
3611 .vecs = lz4_decomp_tv_template,
3612 .count = LZ4_DECOMP_TEST_VECTORS
3618 .test = alg_test_comp,
3623 .vecs = lz4hc_comp_tv_template,
3624 .count = LZ4HC_COMP_TEST_VECTORS
3627 .vecs = lz4hc_decomp_tv_template,
3628 .count = LZ4HC_DECOMP_TEST_VECTORS
3634 .test = alg_test_comp,
3639 .vecs = lzo_comp_tv_template,
3640 .count = LZO_COMP_TEST_VECTORS
3643 .vecs = lzo_decomp_tv_template,
3644 .count = LZO_DECOMP_TEST_VECTORS
3650 .test = alg_test_hash,
3653 .vecs = md4_tv_template,
3654 .count = MD4_TEST_VECTORS
3659 .test = alg_test_hash,
3662 .vecs = md5_tv_template,
3663 .count = MD5_TEST_VECTORS
3667 .alg = "michael_mic",
3668 .test = alg_test_hash,
3671 .vecs = michael_mic_tv_template,
3672 .count = MICHAEL_MIC_TEST_VECTORS
3677 .test = alg_test_skcipher,
3682 .vecs = aes_ofb_enc_tv_template,
3683 .count = AES_OFB_ENC_TEST_VECTORS
3686 .vecs = aes_ofb_dec_tv_template,
3687 .count = AES_OFB_DEC_TEST_VECTORS
3692 .alg = "pcbc(fcrypt)",
3693 .test = alg_test_skcipher,
3697 .vecs = fcrypt_pcbc_enc_tv_template,
3698 .count = FCRYPT_ENC_TEST_VECTORS
3701 .vecs = fcrypt_pcbc_dec_tv_template,
3702 .count = FCRYPT_DEC_TEST_VECTORS
3708 .test = alg_test_hash,
3711 .vecs = poly1305_tv_template,
3712 .count = POLY1305_TEST_VECTORS
3716 .alg = "rfc3686(ctr(aes))",
3717 .test = alg_test_skcipher,
3722 .vecs = aes_ctr_rfc3686_enc_tv_template,
3723 .count = AES_CTR_3686_ENC_TEST_VECTORS
3726 .vecs = aes_ctr_rfc3686_dec_tv_template,
3727 .count = AES_CTR_3686_DEC_TEST_VECTORS
3732 .alg = "rfc4106(gcm(aes))",
3733 .test = alg_test_aead,
3738 .vecs = aes_gcm_rfc4106_enc_tv_template,
3739 .count = AES_GCM_4106_ENC_TEST_VECTORS
3742 .vecs = aes_gcm_rfc4106_dec_tv_template,
3743 .count = AES_GCM_4106_DEC_TEST_VECTORS
3748 .alg = "rfc4309(ccm(aes))",
3749 .test = alg_test_aead,
3754 .vecs = aes_ccm_rfc4309_enc_tv_template,
3755 .count = AES_CCM_4309_ENC_TEST_VECTORS
3758 .vecs = aes_ccm_rfc4309_dec_tv_template,
3759 .count = AES_CCM_4309_DEC_TEST_VECTORS
3764 .alg = "rfc4543(gcm(aes))",
3765 .test = alg_test_aead,
3769 .vecs = aes_gcm_rfc4543_enc_tv_template,
3770 .count = AES_GCM_4543_ENC_TEST_VECTORS
3773 .vecs = aes_gcm_rfc4543_dec_tv_template,
3774 .count = AES_GCM_4543_DEC_TEST_VECTORS
3779 .alg = "rfc7539(chacha20,poly1305)",
3780 .test = alg_test_aead,
3784 .vecs = rfc7539_enc_tv_template,
3785 .count = RFC7539_ENC_TEST_VECTORS
3788 .vecs = rfc7539_dec_tv_template,
3789 .count = RFC7539_DEC_TEST_VECTORS
3794 .alg = "rfc7539esp(chacha20,poly1305)",
3795 .test = alg_test_aead,
3799 .vecs = rfc7539esp_enc_tv_template,
3800 .count = RFC7539ESP_ENC_TEST_VECTORS
3803 .vecs = rfc7539esp_dec_tv_template,
3804 .count = RFC7539ESP_DEC_TEST_VECTORS
3810 .test = alg_test_hash,
3813 .vecs = rmd128_tv_template,
3814 .count = RMD128_TEST_VECTORS
3819 .test = alg_test_hash,
3822 .vecs = rmd160_tv_template,
3823 .count = RMD160_TEST_VECTORS
3828 .test = alg_test_hash,
3831 .vecs = rmd256_tv_template,
3832 .count = RMD256_TEST_VECTORS
3837 .test = alg_test_hash,
3840 .vecs = rmd320_tv_template,
3841 .count = RMD320_TEST_VECTORS
3846 .test = alg_test_akcipher,
3850 .vecs = rsa_tv_template,
3851 .count = RSA_TEST_VECTORS
3856 .test = alg_test_skcipher,
3860 .vecs = salsa20_stream_enc_tv_template,
3861 .count = SALSA20_STREAM_ENC_TEST_VECTORS
3867 .test = alg_test_hash,
3871 .vecs = sha1_tv_template,
3872 .count = SHA1_TEST_VECTORS
3877 .test = alg_test_hash,
3881 .vecs = sha224_tv_template,
3882 .count = SHA224_TEST_VECTORS
3887 .test = alg_test_hash,
3891 .vecs = sha256_tv_template,
3892 .count = SHA256_TEST_VECTORS
3897 .test = alg_test_hash,
3901 .vecs = sha3_224_tv_template,
3902 .count = SHA3_224_TEST_VECTORS
3907 .test = alg_test_hash,
3911 .vecs = sha3_256_tv_template,
3912 .count = SHA3_256_TEST_VECTORS
3917 .test = alg_test_hash,
3921 .vecs = sha3_384_tv_template,
3922 .count = SHA3_384_TEST_VECTORS
3927 .test = alg_test_hash,
3931 .vecs = sha3_512_tv_template,
3932 .count = SHA3_512_TEST_VECTORS
3937 .test = alg_test_hash,
3941 .vecs = sha384_tv_template,
3942 .count = SHA384_TEST_VECTORS
3947 .test = alg_test_hash,
3951 .vecs = sha512_tv_template,
3952 .count = SHA512_TEST_VECTORS
3957 .test = alg_test_hash,
3960 .vecs = tgr128_tv_template,
3961 .count = TGR128_TEST_VECTORS
3966 .test = alg_test_hash,
3969 .vecs = tgr160_tv_template,
3970 .count = TGR160_TEST_VECTORS
3975 .test = alg_test_hash,
3978 .vecs = tgr192_tv_template,
3979 .count = TGR192_TEST_VECTORS
3984 .test = alg_test_hash,
3987 .vecs = aes_vmac128_tv_template,
3988 .count = VMAC_AES_TEST_VECTORS
3993 .test = alg_test_hash,
3996 .vecs = wp256_tv_template,
3997 .count = WP256_TEST_VECTORS
4002 .test = alg_test_hash,
4005 .vecs = wp384_tv_template,
4006 .count = WP384_TEST_VECTORS
4011 .test = alg_test_hash,
4014 .vecs = wp512_tv_template,
4015 .count = WP512_TEST_VECTORS
4020 .test = alg_test_hash,
4023 .vecs = aes_xcbc128_tv_template,
4024 .count = XCBC_AES_TEST_VECTORS
4029 .test = alg_test_skcipher,
4034 .vecs = aes_xts_enc_tv_template,
4035 .count = AES_XTS_ENC_TEST_VECTORS
4038 .vecs = aes_xts_dec_tv_template,
4039 .count = AES_XTS_DEC_TEST_VECTORS
4044 .alg = "xts(camellia)",
4045 .test = alg_test_skcipher,
4049 .vecs = camellia_xts_enc_tv_template,
4050 .count = CAMELLIA_XTS_ENC_TEST_VECTORS
4053 .vecs = camellia_xts_dec_tv_template,
4054 .count = CAMELLIA_XTS_DEC_TEST_VECTORS
4059 .alg = "xts(cast6)",
4060 .test = alg_test_skcipher,
4064 .vecs = cast6_xts_enc_tv_template,
4065 .count = CAST6_XTS_ENC_TEST_VECTORS
4068 .vecs = cast6_xts_dec_tv_template,
4069 .count = CAST6_XTS_DEC_TEST_VECTORS
4074 .alg = "xts(serpent)",
4075 .test = alg_test_skcipher,
4079 .vecs = serpent_xts_enc_tv_template,
4080 .count = SERPENT_XTS_ENC_TEST_VECTORS
4083 .vecs = serpent_xts_dec_tv_template,
4084 .count = SERPENT_XTS_DEC_TEST_VECTORS
4089 .alg = "xts(twofish)",
4090 .test = alg_test_skcipher,
4094 .vecs = tf_xts_enc_tv_template,
4095 .count = TF_XTS_ENC_TEST_VECTORS
4098 .vecs = tf_xts_dec_tv_template,
4099 .count = TF_XTS_DEC_TEST_VECTORS
4106 static bool alg_test_descs_checked;
4108 static void alg_test_descs_check_order(void)
4112 /* only check once */
4113 if (alg_test_descs_checked)
4116 alg_test_descs_checked = true;
4118 for (i = 1; i < ARRAY_SIZE(alg_test_descs); i++) {
4119 int diff = strcmp(alg_test_descs[i - 1].alg,
4120 alg_test_descs[i].alg);
4122 if (WARN_ON(diff > 0)) {
4123 pr_warn("testmgr: alg_test_descs entries in wrong order: '%s' before '%s'\n",
4124 alg_test_descs[i - 1].alg,
4125 alg_test_descs[i].alg);
4128 if (WARN_ON(diff == 0)) {
4129 pr_warn("testmgr: duplicate alg_test_descs entry: '%s'\n",
4130 alg_test_descs[i].alg);
4135 static int alg_find_test(const char *alg)
4138 int end = ARRAY_SIZE(alg_test_descs);
4140 while (start < end) {
4141 int i = (start + end) / 2;
4142 int diff = strcmp(alg_test_descs[i].alg, alg);
4160 int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
4166 if (!fips_enabled && notests) {
4167 printk_once(KERN_INFO "alg: self-tests disabled\n");
4171 alg_test_descs_check_order();
4173 if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) {
4174 char nalg[CRYPTO_MAX_ALG_NAME];
4176 if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >=
4178 return -ENAMETOOLONG;
4180 i = alg_find_test(nalg);
4184 if (fips_enabled && !alg_test_descs[i].fips_allowed)
4187 rc = alg_test_cipher(alg_test_descs + i, driver, type, mask);
4191 i = alg_find_test(alg);
4192 j = alg_find_test(driver);
4196 if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) ||
4197 (j >= 0 && !alg_test_descs[j].fips_allowed)))
4202 rc |= alg_test_descs[i].test(alg_test_descs + i, driver,
4204 if (j >= 0 && j != i)
4205 rc |= alg_test_descs[j].test(alg_test_descs + j, driver,
4209 if (fips_enabled && rc)
4210 panic("%s: %s alg self test failed in fips mode!\n", driver, alg);
4212 if (fips_enabled && !rc)
4213 pr_info("alg: self-tests for %s (%s) passed\n", driver, alg);
4218 printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
4224 #endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */
4226 EXPORT_SYMBOL_GPL(alg_test);