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>
40 module_param(notests, bool, 0644);
41 MODULE_PARM_DESC(notests, "disable crypto self-tests");
43 #ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
46 int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
56 * Need slab memory for testing (size in number of pages).
61 * Indexes into the xbuf to simulate cross-page access.
73 * Used by test_cipher()
78 struct tcrypt_result {
79 struct completion completion;
83 struct aead_test_suite {
85 struct aead_testvec *vecs;
90 struct cipher_test_suite {
92 struct cipher_testvec *vecs;
97 struct comp_test_suite {
99 struct comp_testvec *vecs;
104 struct hash_test_suite {
105 struct hash_testvec *vecs;
109 struct cprng_test_suite {
110 struct cprng_testvec *vecs;
114 struct drbg_test_suite {
115 struct drbg_testvec *vecs;
119 struct akcipher_test_suite {
120 struct akcipher_testvec *vecs;
124 struct kpp_test_suite {
125 struct kpp_testvec *vecs;
129 struct alg_test_desc {
131 int (*test)(const struct alg_test_desc *desc, const char *driver,
133 int fips_allowed; /* set if alg is allowed in fips mode */
136 struct aead_test_suite aead;
137 struct cipher_test_suite cipher;
138 struct comp_test_suite comp;
139 struct hash_test_suite hash;
140 struct cprng_test_suite cprng;
141 struct drbg_test_suite drbg;
142 struct akcipher_test_suite akcipher;
143 struct kpp_test_suite kpp;
147 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
149 static void hexdump(unsigned char *buf, unsigned int len)
151 print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
156 static void tcrypt_complete(struct crypto_async_request *req, int err)
158 struct tcrypt_result *res = req->data;
160 if (err == -EINPROGRESS)
164 complete(&res->completion);
167 static int testmgr_alloc_buf(char *buf[XBUFSIZE])
171 for (i = 0; i < XBUFSIZE; i++) {
172 buf[i] = (void *)__get_free_page(GFP_KERNEL);
181 free_page((unsigned long)buf[i]);
186 static void testmgr_free_buf(char *buf[XBUFSIZE])
190 for (i = 0; i < XBUFSIZE; i++)
191 free_page((unsigned long)buf[i]);
194 static int wait_async_op(struct tcrypt_result *tr, int ret)
196 if (ret == -EINPROGRESS || ret == -EBUSY) {
197 wait_for_completion(&tr->completion);
198 reinit_completion(&tr->completion);
204 static int ahash_partial_update(struct ahash_request **preq,
205 struct crypto_ahash *tfm, struct hash_testvec *template,
206 void *hash_buff, int k, int temp, struct scatterlist *sg,
207 const char *algo, char *result, struct tcrypt_result *tresult)
210 struct ahash_request *req;
211 int statesize, ret = -EINVAL;
214 statesize = crypto_ahash_statesize(
215 crypto_ahash_reqtfm(req));
216 state = kmalloc(statesize, GFP_KERNEL);
218 pr_err("alt: hash: Failed to alloc state for %s\n", algo);
221 ret = crypto_ahash_export(req, state);
223 pr_err("alt: hash: Failed to export() for %s\n", algo);
226 ahash_request_free(req);
227 req = ahash_request_alloc(tfm, GFP_KERNEL);
229 pr_err("alg: hash: Failed to alloc request for %s\n", algo);
232 ahash_request_set_callback(req,
233 CRYPTO_TFM_REQ_MAY_BACKLOG,
234 tcrypt_complete, tresult);
236 memcpy(hash_buff, template->plaintext + temp,
238 sg_init_one(&sg[0], hash_buff, template->tap[k]);
239 ahash_request_set_crypt(req, sg, result, template->tap[k]);
240 ret = crypto_ahash_import(req, state);
242 pr_err("alg: hash: Failed to import() for %s\n", algo);
245 ret = wait_async_op(tresult, crypto_ahash_update(req));
252 ahash_request_free(req);
259 static int __test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
260 unsigned int tcount, bool use_digest,
261 const int align_offset)
263 const char *algo = crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm));
264 unsigned int i, j, k, temp;
265 struct scatterlist sg[8];
268 struct ahash_request *req;
269 struct tcrypt_result tresult;
271 char *xbuf[XBUFSIZE];
274 result = kmalloc(MAX_DIGEST_SIZE, GFP_KERNEL);
277 key = kmalloc(MAX_KEYLEN, GFP_KERNEL);
280 if (testmgr_alloc_buf(xbuf))
283 init_completion(&tresult.completion);
285 req = ahash_request_alloc(tfm, GFP_KERNEL);
287 printk(KERN_ERR "alg: hash: Failed to allocate request for "
291 ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
292 tcrypt_complete, &tresult);
295 for (i = 0; i < tcount; i++) {
300 if (WARN_ON(align_offset + template[i].psize > PAGE_SIZE))
304 memset(result, 0, MAX_DIGEST_SIZE);
307 hash_buff += align_offset;
309 memcpy(hash_buff, template[i].plaintext, template[i].psize);
310 sg_init_one(&sg[0], hash_buff, template[i].psize);
312 if (template[i].ksize) {
313 crypto_ahash_clear_flags(tfm, ~0);
314 if (template[i].ksize > MAX_KEYLEN) {
315 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
316 j, algo, template[i].ksize, MAX_KEYLEN);
320 memcpy(key, template[i].key, template[i].ksize);
321 ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
323 printk(KERN_ERR "alg: hash: setkey failed on "
324 "test %d for %s: ret=%d\n", j, algo,
330 ahash_request_set_crypt(req, sg, result, template[i].psize);
332 ret = wait_async_op(&tresult, crypto_ahash_digest(req));
334 pr_err("alg: hash: digest failed on test %d "
335 "for %s: ret=%d\n", j, algo, -ret);
339 ret = wait_async_op(&tresult, crypto_ahash_init(req));
341 pr_err("alt: hash: init failed on test %d "
342 "for %s: ret=%d\n", j, algo, -ret);
345 ret = wait_async_op(&tresult, crypto_ahash_update(req));
347 pr_err("alt: hash: update failed on test %d "
348 "for %s: ret=%d\n", j, algo, -ret);
351 ret = wait_async_op(&tresult, crypto_ahash_final(req));
353 pr_err("alt: hash: final failed on test %d "
354 "for %s: ret=%d\n", j, algo, -ret);
359 if (memcmp(result, template[i].digest,
360 crypto_ahash_digestsize(tfm))) {
361 printk(KERN_ERR "alg: hash: Test %d failed for %s\n",
363 hexdump(result, crypto_ahash_digestsize(tfm));
370 for (i = 0; i < tcount; i++) {
371 /* alignment tests are only done with continuous buffers */
372 if (align_offset != 0)
379 memset(result, 0, MAX_DIGEST_SIZE);
382 sg_init_table(sg, template[i].np);
384 for (k = 0; k < template[i].np; k++) {
385 if (WARN_ON(offset_in_page(IDX[k]) +
386 template[i].tap[k] > PAGE_SIZE))
389 memcpy(xbuf[IDX[k] >> PAGE_SHIFT] +
390 offset_in_page(IDX[k]),
391 template[i].plaintext + temp,
394 temp += template[i].tap[k];
397 if (template[i].ksize) {
398 if (template[i].ksize > MAX_KEYLEN) {
399 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
400 j, algo, template[i].ksize, MAX_KEYLEN);
404 crypto_ahash_clear_flags(tfm, ~0);
405 memcpy(key, template[i].key, template[i].ksize);
406 ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
409 printk(KERN_ERR "alg: hash: setkey "
410 "failed on chunking test %d "
411 "for %s: ret=%d\n", j, algo, -ret);
416 ahash_request_set_crypt(req, sg, result, template[i].psize);
417 ret = crypto_ahash_digest(req);
423 wait_for_completion(&tresult.completion);
424 reinit_completion(&tresult.completion);
430 printk(KERN_ERR "alg: hash: digest failed "
431 "on chunking test %d for %s: "
432 "ret=%d\n", j, algo, -ret);
436 if (memcmp(result, template[i].digest,
437 crypto_ahash_digestsize(tfm))) {
438 printk(KERN_ERR "alg: hash: Chunking test %d "
439 "failed for %s\n", j, algo);
440 hexdump(result, crypto_ahash_digestsize(tfm));
446 /* partial update exercise */
448 for (i = 0; i < tcount; i++) {
449 /* alignment tests are only done with continuous buffers */
450 if (align_offset != 0)
453 if (template[i].np < 2)
457 memset(result, 0, MAX_DIGEST_SIZE);
461 memcpy(hash_buff, template[i].plaintext,
463 sg_init_one(&sg[0], hash_buff, template[i].tap[0]);
465 if (template[i].ksize) {
466 crypto_ahash_clear_flags(tfm, ~0);
467 if (template[i].ksize > MAX_KEYLEN) {
468 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
469 j, algo, template[i].ksize, MAX_KEYLEN);
473 memcpy(key, template[i].key, template[i].ksize);
474 ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
476 pr_err("alg: hash: setkey failed on test %d for %s: ret=%d\n",
482 ahash_request_set_crypt(req, sg, result, template[i].tap[0]);
483 ret = wait_async_op(&tresult, crypto_ahash_init(req));
485 pr_err("alt: hash: init failed on test %d for %s: ret=%d\n",
489 ret = wait_async_op(&tresult, crypto_ahash_update(req));
491 pr_err("alt: hash: update failed on test %d for %s: ret=%d\n",
496 temp = template[i].tap[0];
497 for (k = 1; k < template[i].np; k++) {
498 ret = ahash_partial_update(&req, tfm, &template[i],
499 hash_buff, k, temp, &sg[0], algo, result,
502 pr_err("hash: partial update failed on test %d for %s: ret=%d\n",
506 temp += template[i].tap[k];
508 ret = wait_async_op(&tresult, crypto_ahash_final(req));
510 pr_err("alt: hash: final failed on test %d for %s: ret=%d\n",
514 if (memcmp(result, template[i].digest,
515 crypto_ahash_digestsize(tfm))) {
516 pr_err("alg: hash: Partial Test %d failed for %s\n",
518 hexdump(result, crypto_ahash_digestsize(tfm));
527 ahash_request_free(req);
529 testmgr_free_buf(xbuf);
536 static int test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
537 unsigned int tcount, bool use_digest)
539 unsigned int alignmask;
542 ret = __test_hash(tfm, template, tcount, use_digest, 0);
546 /* test unaligned buffers, check with one byte offset */
547 ret = __test_hash(tfm, template, tcount, use_digest, 1);
551 alignmask = crypto_tfm_alg_alignmask(&tfm->base);
553 /* Check if alignment mask for tfm is correctly set. */
554 ret = __test_hash(tfm, template, tcount, use_digest,
563 static int __test_aead(struct crypto_aead *tfm, int enc,
564 struct aead_testvec *template, unsigned int tcount,
565 const bool diff_dst, const int align_offset)
567 const char *algo = crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm));
568 unsigned int i, j, k, n, temp;
572 struct aead_request *req;
573 struct scatterlist *sg;
574 struct scatterlist *sgout;
576 struct tcrypt_result result;
577 unsigned int authsize, iv_len;
582 char *xbuf[XBUFSIZE];
583 char *xoutbuf[XBUFSIZE];
584 char *axbuf[XBUFSIZE];
586 iv = kzalloc(MAX_IVLEN, GFP_KERNEL);
589 key = kmalloc(MAX_KEYLEN, GFP_KERNEL);
592 if (testmgr_alloc_buf(xbuf))
594 if (testmgr_alloc_buf(axbuf))
596 if (diff_dst && testmgr_alloc_buf(xoutbuf))
599 /* avoid "the frame size is larger than 1024 bytes" compiler warning */
600 sg = kmalloc(sizeof(*sg) * 8 * (diff_dst ? 4 : 2), GFP_KERNEL);
615 init_completion(&result.completion);
617 req = aead_request_alloc(tfm, GFP_KERNEL);
619 pr_err("alg: aead%s: Failed to allocate request for %s\n",
624 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
625 tcrypt_complete, &result);
627 iv_len = crypto_aead_ivsize(tfm);
629 for (i = 0, j = 0; i < tcount; i++) {
635 /* some templates have no input data but they will
639 input += align_offset;
643 if (WARN_ON(align_offset + template[i].ilen >
644 PAGE_SIZE || template[i].alen > PAGE_SIZE))
647 memcpy(input, template[i].input, template[i].ilen);
648 memcpy(assoc, template[i].assoc, template[i].alen);
650 memcpy(iv, template[i].iv, iv_len);
652 memset(iv, 0, iv_len);
654 crypto_aead_clear_flags(tfm, ~0);
656 crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
658 if (template[i].klen > MAX_KEYLEN) {
659 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
660 d, j, algo, template[i].klen,
665 memcpy(key, template[i].key, template[i].klen);
667 ret = crypto_aead_setkey(tfm, key, template[i].klen);
668 if (template[i].fail == !ret) {
669 pr_err("alg: aead%s: setkey failed on test %d for %s: flags=%x\n",
670 d, j, algo, crypto_aead_get_flags(tfm));
675 authsize = abs(template[i].rlen - template[i].ilen);
676 ret = crypto_aead_setauthsize(tfm, authsize);
678 pr_err("alg: aead%s: Failed to set authsize to %u on test %d for %s\n",
679 d, authsize, j, algo);
683 k = !!template[i].alen;
684 sg_init_table(sg, k + 1);
685 sg_set_buf(&sg[0], assoc, template[i].alen);
686 sg_set_buf(&sg[k], input,
687 template[i].ilen + (enc ? authsize : 0));
691 sg_init_table(sgout, k + 1);
692 sg_set_buf(&sgout[0], assoc, template[i].alen);
695 output += align_offset;
696 sg_set_buf(&sgout[k], output,
697 template[i].rlen + (enc ? 0 : authsize));
700 aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
701 template[i].ilen, iv);
703 aead_request_set_ad(req, template[i].alen);
705 ret = enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req);
709 if (template[i].novrfy) {
710 /* verification was supposed to fail */
711 pr_err("alg: aead%s: %s failed on test %d for %s: ret was 0, expected -EBADMSG\n",
713 /* so really, we got a bad message */
720 wait_for_completion(&result.completion);
721 reinit_completion(&result.completion);
726 if (template[i].novrfy)
727 /* verification failure was expected */
731 pr_err("alg: aead%s: %s failed on test %d for %s: ret=%d\n",
732 d, e, j, algo, -ret);
737 if (memcmp(q, template[i].result, template[i].rlen)) {
738 pr_err("alg: aead%s: Test %d failed on %s for %s\n",
740 hexdump(q, template[i].rlen);
746 for (i = 0, j = 0; i < tcount; i++) {
747 /* alignment tests are only done with continuous buffers */
748 if (align_offset != 0)
757 memcpy(iv, template[i].iv, iv_len);
759 memset(iv, 0, MAX_IVLEN);
761 crypto_aead_clear_flags(tfm, ~0);
763 crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
764 if (template[i].klen > MAX_KEYLEN) {
765 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
766 d, j, algo, template[i].klen, MAX_KEYLEN);
770 memcpy(key, template[i].key, template[i].klen);
772 ret = crypto_aead_setkey(tfm, key, template[i].klen);
773 if (template[i].fail == !ret) {
774 pr_err("alg: aead%s: setkey failed on chunk test %d for %s: flags=%x\n",
775 d, j, algo, crypto_aead_get_flags(tfm));
780 authsize = abs(template[i].rlen - template[i].ilen);
783 sg_init_table(sg, template[i].anp + template[i].np);
785 sg_init_table(sgout, template[i].anp + template[i].np);
788 for (k = 0, temp = 0; k < template[i].anp; k++) {
789 if (WARN_ON(offset_in_page(IDX[k]) +
790 template[i].atap[k] > PAGE_SIZE))
793 memcpy(axbuf[IDX[k] >> PAGE_SHIFT] +
794 offset_in_page(IDX[k]),
795 template[i].assoc + temp,
796 template[i].atap[k]),
797 template[i].atap[k]);
799 sg_set_buf(&sgout[k],
800 axbuf[IDX[k] >> PAGE_SHIFT] +
801 offset_in_page(IDX[k]),
802 template[i].atap[k]);
803 temp += template[i].atap[k];
806 for (k = 0, temp = 0; k < template[i].np; k++) {
807 if (WARN_ON(offset_in_page(IDX[k]) +
808 template[i].tap[k] > PAGE_SIZE))
811 q = xbuf[IDX[k] >> PAGE_SHIFT] + offset_in_page(IDX[k]);
812 memcpy(q, template[i].input + temp, template[i].tap[k]);
813 sg_set_buf(&sg[template[i].anp + k],
814 q, template[i].tap[k]);
817 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
818 offset_in_page(IDX[k]);
820 memset(q, 0, template[i].tap[k]);
822 sg_set_buf(&sgout[template[i].anp + k],
823 q, template[i].tap[k]);
826 n = template[i].tap[k];
827 if (k == template[i].np - 1 && enc)
829 if (offset_in_page(q) + n < PAGE_SIZE)
832 temp += template[i].tap[k];
835 ret = crypto_aead_setauthsize(tfm, authsize);
837 pr_err("alg: aead%s: Failed to set authsize to %u on chunk test %d for %s\n",
838 d, authsize, j, algo);
843 if (WARN_ON(sg[template[i].anp + k - 1].offset +
844 sg[template[i].anp + k - 1].length +
845 authsize > PAGE_SIZE)) {
851 sgout[template[i].anp + k - 1].length +=
853 sg[template[i].anp + k - 1].length += authsize;
856 aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
860 aead_request_set_ad(req, template[i].alen);
862 ret = enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req);
866 if (template[i].novrfy) {
867 /* verification was supposed to fail */
868 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret was 0, expected -EBADMSG\n",
870 /* so really, we got a bad message */
877 wait_for_completion(&result.completion);
878 reinit_completion(&result.completion);
883 if (template[i].novrfy)
884 /* verification failure was expected */
888 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret=%d\n",
889 d, e, j, algo, -ret);
894 for (k = 0, temp = 0; k < template[i].np; k++) {
896 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
897 offset_in_page(IDX[k]);
899 q = xbuf[IDX[k] >> PAGE_SHIFT] +
900 offset_in_page(IDX[k]);
902 n = template[i].tap[k];
903 if (k == template[i].np - 1)
904 n += enc ? authsize : -authsize;
906 if (memcmp(q, template[i].result + temp, n)) {
907 pr_err("alg: aead%s: Chunk test %d failed on %s at page %u for %s\n",
914 if (k == template[i].np - 1 && !enc) {
916 memcmp(q, template[i].input +
922 for (n = 0; offset_in_page(q + n) && q[n]; n++)
926 pr_err("alg: aead%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
927 d, j, e, k, algo, n);
932 temp += template[i].tap[k];
939 aead_request_free(req);
943 testmgr_free_buf(xoutbuf);
945 testmgr_free_buf(axbuf);
947 testmgr_free_buf(xbuf);
954 static int test_aead(struct crypto_aead *tfm, int enc,
955 struct aead_testvec *template, unsigned int tcount)
957 unsigned int alignmask;
960 /* test 'dst == src' case */
961 ret = __test_aead(tfm, enc, template, tcount, false, 0);
965 /* test 'dst != src' case */
966 ret = __test_aead(tfm, enc, template, tcount, true, 0);
970 /* test unaligned buffers, check with one byte offset */
971 ret = __test_aead(tfm, enc, template, tcount, true, 1);
975 alignmask = crypto_tfm_alg_alignmask(&tfm->base);
977 /* Check if alignment mask for tfm is correctly set. */
978 ret = __test_aead(tfm, enc, template, tcount, true,
987 static int test_cipher(struct crypto_cipher *tfm, int enc,
988 struct cipher_testvec *template, unsigned int tcount)
990 const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm));
991 unsigned int i, j, k;
995 char *xbuf[XBUFSIZE];
998 if (testmgr_alloc_buf(xbuf))
1007 for (i = 0; i < tcount; i++) {
1011 if (fips_enabled && template[i].fips_skip)
1017 if (WARN_ON(template[i].ilen > PAGE_SIZE))
1021 memcpy(data, template[i].input, template[i].ilen);
1023 crypto_cipher_clear_flags(tfm, ~0);
1025 crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
1027 ret = crypto_cipher_setkey(tfm, template[i].key,
1029 if (template[i].fail == !ret) {
1030 printk(KERN_ERR "alg: cipher: setkey failed "
1031 "on test %d for %s: flags=%x\n", j,
1032 algo, crypto_cipher_get_flags(tfm));
1037 for (k = 0; k < template[i].ilen;
1038 k += crypto_cipher_blocksize(tfm)) {
1040 crypto_cipher_encrypt_one(tfm, data + k,
1043 crypto_cipher_decrypt_one(tfm, data + k,
1048 if (memcmp(q, template[i].result, template[i].rlen)) {
1049 printk(KERN_ERR "alg: cipher: Test %d failed "
1050 "on %s for %s\n", j, e, algo);
1051 hexdump(q, template[i].rlen);
1060 testmgr_free_buf(xbuf);
1065 static int __test_skcipher(struct crypto_skcipher *tfm, int enc,
1066 struct cipher_testvec *template, unsigned int tcount,
1067 const bool diff_dst, const int align_offset)
1070 crypto_tfm_alg_driver_name(crypto_skcipher_tfm(tfm));
1071 unsigned int i, j, k, n, temp;
1073 struct skcipher_request *req;
1074 struct scatterlist sg[8];
1075 struct scatterlist sgout[8];
1077 struct tcrypt_result result;
1080 char *xbuf[XBUFSIZE];
1081 char *xoutbuf[XBUFSIZE];
1083 unsigned int ivsize = crypto_skcipher_ivsize(tfm);
1085 if (testmgr_alloc_buf(xbuf))
1088 if (diff_dst && testmgr_alloc_buf(xoutbuf))
1101 init_completion(&result.completion);
1103 req = skcipher_request_alloc(tfm, GFP_KERNEL);
1105 pr_err("alg: skcipher%s: Failed to allocate request for %s\n",
1110 skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1111 tcrypt_complete, &result);
1114 for (i = 0; i < tcount; i++) {
1115 if (template[i].np && !template[i].also_non_np)
1118 if (fips_enabled && template[i].fips_skip)
1122 memcpy(iv, template[i].iv, ivsize);
1124 memset(iv, 0, MAX_IVLEN);
1128 if (WARN_ON(align_offset + template[i].ilen > PAGE_SIZE))
1132 data += align_offset;
1133 memcpy(data, template[i].input, template[i].ilen);
1135 crypto_skcipher_clear_flags(tfm, ~0);
1137 crypto_skcipher_set_flags(tfm,
1138 CRYPTO_TFM_REQ_WEAK_KEY);
1140 ret = crypto_skcipher_setkey(tfm, template[i].key,
1142 if (template[i].fail == !ret) {
1143 pr_err("alg: skcipher%s: setkey failed on test %d for %s: flags=%x\n",
1144 d, j, algo, crypto_skcipher_get_flags(tfm));
1149 sg_init_one(&sg[0], data, template[i].ilen);
1152 data += align_offset;
1153 sg_init_one(&sgout[0], data, template[i].ilen);
1156 skcipher_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
1157 template[i].ilen, iv);
1158 ret = enc ? crypto_skcipher_encrypt(req) :
1159 crypto_skcipher_decrypt(req);
1166 wait_for_completion(&result.completion);
1167 reinit_completion(&result.completion);
1173 pr_err("alg: skcipher%s: %s failed on test %d for %s: ret=%d\n",
1174 d, e, j, algo, -ret);
1179 if (memcmp(q, template[i].result, template[i].rlen)) {
1180 pr_err("alg: skcipher%s: Test %d failed (invalid result) on %s for %s\n",
1182 hexdump(q, template[i].rlen);
1187 if (template[i].iv_out &&
1188 memcmp(iv, template[i].iv_out,
1189 crypto_skcipher_ivsize(tfm))) {
1190 pr_err("alg: skcipher%s: Test %d failed (invalid output IV) on %s for %s\n",
1192 hexdump(iv, crypto_skcipher_ivsize(tfm));
1199 for (i = 0; i < tcount; i++) {
1200 /* alignment tests are only done with continuous buffers */
1201 if (align_offset != 0)
1204 if (!template[i].np)
1207 if (fips_enabled && template[i].fips_skip)
1211 memcpy(iv, template[i].iv, ivsize);
1213 memset(iv, 0, MAX_IVLEN);
1216 crypto_skcipher_clear_flags(tfm, ~0);
1218 crypto_skcipher_set_flags(tfm,
1219 CRYPTO_TFM_REQ_WEAK_KEY);
1221 ret = crypto_skcipher_setkey(tfm, template[i].key,
1223 if (template[i].fail == !ret) {
1224 pr_err("alg: skcipher%s: setkey failed on chunk test %d for %s: flags=%x\n",
1225 d, j, algo, crypto_skcipher_get_flags(tfm));
1232 sg_init_table(sg, template[i].np);
1234 sg_init_table(sgout, template[i].np);
1235 for (k = 0; k < template[i].np; k++) {
1236 if (WARN_ON(offset_in_page(IDX[k]) +
1237 template[i].tap[k] > PAGE_SIZE))
1240 q = xbuf[IDX[k] >> PAGE_SHIFT] + offset_in_page(IDX[k]);
1242 memcpy(q, template[i].input + temp, template[i].tap[k]);
1244 if (offset_in_page(q) + template[i].tap[k] < PAGE_SIZE)
1245 q[template[i].tap[k]] = 0;
1247 sg_set_buf(&sg[k], q, template[i].tap[k]);
1249 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
1250 offset_in_page(IDX[k]);
1252 sg_set_buf(&sgout[k], q, template[i].tap[k]);
1254 memset(q, 0, template[i].tap[k]);
1255 if (offset_in_page(q) +
1256 template[i].tap[k] < PAGE_SIZE)
1257 q[template[i].tap[k]] = 0;
1260 temp += template[i].tap[k];
1263 skcipher_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
1264 template[i].ilen, iv);
1266 ret = enc ? crypto_skcipher_encrypt(req) :
1267 crypto_skcipher_decrypt(req);
1274 wait_for_completion(&result.completion);
1275 reinit_completion(&result.completion);
1281 pr_err("alg: skcipher%s: %s failed on chunk test %d for %s: ret=%d\n",
1282 d, e, j, algo, -ret);
1288 for (k = 0; k < template[i].np; k++) {
1290 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
1291 offset_in_page(IDX[k]);
1293 q = xbuf[IDX[k] >> PAGE_SHIFT] +
1294 offset_in_page(IDX[k]);
1296 if (memcmp(q, template[i].result + temp,
1297 template[i].tap[k])) {
1298 pr_err("alg: skcipher%s: Chunk test %d failed on %s at page %u for %s\n",
1300 hexdump(q, template[i].tap[k]);
1304 q += template[i].tap[k];
1305 for (n = 0; offset_in_page(q + n) && q[n]; n++)
1308 pr_err("alg: skcipher%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
1309 d, j, e, k, algo, n);
1313 temp += template[i].tap[k];
1320 skcipher_request_free(req);
1322 testmgr_free_buf(xoutbuf);
1324 testmgr_free_buf(xbuf);
1329 static int test_skcipher(struct crypto_skcipher *tfm, int enc,
1330 struct cipher_testvec *template, unsigned int tcount)
1332 unsigned int alignmask;
1335 /* test 'dst == src' case */
1336 ret = __test_skcipher(tfm, enc, template, tcount, false, 0);
1340 /* test 'dst != src' case */
1341 ret = __test_skcipher(tfm, enc, template, tcount, true, 0);
1345 /* test unaligned buffers, check with one byte offset */
1346 ret = __test_skcipher(tfm, enc, template, tcount, true, 1);
1350 alignmask = crypto_tfm_alg_alignmask(&tfm->base);
1352 /* Check if alignment mask for tfm is correctly set. */
1353 ret = __test_skcipher(tfm, enc, template, tcount, true,
1362 static int test_comp(struct crypto_comp *tfm, struct comp_testvec *ctemplate,
1363 struct comp_testvec *dtemplate, int ctcount, int dtcount)
1365 const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
1367 char result[COMP_BUF_SIZE];
1370 for (i = 0; i < ctcount; i++) {
1372 unsigned int dlen = COMP_BUF_SIZE;
1374 memset(result, 0, sizeof (result));
1376 ilen = ctemplate[i].inlen;
1377 ret = crypto_comp_compress(tfm, ctemplate[i].input,
1378 ilen, result, &dlen);
1380 printk(KERN_ERR "alg: comp: compression failed "
1381 "on test %d for %s: ret=%d\n", i + 1, algo,
1386 if (dlen != ctemplate[i].outlen) {
1387 printk(KERN_ERR "alg: comp: Compression test %d "
1388 "failed for %s: output len = %d\n", i + 1, algo,
1394 if (memcmp(result, ctemplate[i].output, dlen)) {
1395 printk(KERN_ERR "alg: comp: Compression test %d "
1396 "failed for %s\n", i + 1, algo);
1397 hexdump(result, dlen);
1403 for (i = 0; i < dtcount; i++) {
1405 unsigned int dlen = COMP_BUF_SIZE;
1407 memset(result, 0, sizeof (result));
1409 ilen = dtemplate[i].inlen;
1410 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
1411 ilen, result, &dlen);
1413 printk(KERN_ERR "alg: comp: decompression failed "
1414 "on test %d for %s: ret=%d\n", i + 1, algo,
1419 if (dlen != dtemplate[i].outlen) {
1420 printk(KERN_ERR "alg: comp: Decompression test %d "
1421 "failed for %s: output len = %d\n", i + 1, algo,
1427 if (memcmp(result, dtemplate[i].output, dlen)) {
1428 printk(KERN_ERR "alg: comp: Decompression test %d "
1429 "failed for %s\n", i + 1, algo);
1430 hexdump(result, dlen);
1442 static int test_cprng(struct crypto_rng *tfm, struct cprng_testvec *template,
1443 unsigned int tcount)
1445 const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm));
1446 int err = 0, i, j, seedsize;
1450 seedsize = crypto_rng_seedsize(tfm);
1452 seed = kmalloc(seedsize, GFP_KERNEL);
1454 printk(KERN_ERR "alg: cprng: Failed to allocate seed space "
1459 for (i = 0; i < tcount; i++) {
1460 memset(result, 0, 32);
1462 memcpy(seed, template[i].v, template[i].vlen);
1463 memcpy(seed + template[i].vlen, template[i].key,
1465 memcpy(seed + template[i].vlen + template[i].klen,
1466 template[i].dt, template[i].dtlen);
1468 err = crypto_rng_reset(tfm, seed, seedsize);
1470 printk(KERN_ERR "alg: cprng: Failed to reset rng "
1475 for (j = 0; j < template[i].loops; j++) {
1476 err = crypto_rng_get_bytes(tfm, result,
1479 printk(KERN_ERR "alg: cprng: Failed to obtain "
1480 "the correct amount of random data for "
1481 "%s (requested %d)\n", algo,
1487 err = memcmp(result, template[i].result,
1490 printk(KERN_ERR "alg: cprng: Test %d failed for %s\n",
1492 hexdump(result, template[i].rlen);
1503 static int alg_test_aead(const struct alg_test_desc *desc, const char *driver,
1506 struct crypto_aead *tfm;
1509 tfm = crypto_alloc_aead(driver, type | CRYPTO_ALG_INTERNAL, mask);
1511 printk(KERN_ERR "alg: aead: Failed to load transform for %s: "
1512 "%ld\n", driver, PTR_ERR(tfm));
1513 return PTR_ERR(tfm);
1516 if (desc->suite.aead.enc.vecs) {
1517 err = test_aead(tfm, ENCRYPT, desc->suite.aead.enc.vecs,
1518 desc->suite.aead.enc.count);
1523 if (!err && desc->suite.aead.dec.vecs)
1524 err = test_aead(tfm, DECRYPT, desc->suite.aead.dec.vecs,
1525 desc->suite.aead.dec.count);
1528 crypto_free_aead(tfm);
1532 static int alg_test_cipher(const struct alg_test_desc *desc,
1533 const char *driver, u32 type, u32 mask)
1535 struct crypto_cipher *tfm;
1538 tfm = crypto_alloc_cipher(driver, type | CRYPTO_ALG_INTERNAL, mask);
1540 printk(KERN_ERR "alg: cipher: Failed to load transform for "
1541 "%s: %ld\n", driver, PTR_ERR(tfm));
1542 return PTR_ERR(tfm);
1545 if (desc->suite.cipher.enc.vecs) {
1546 err = test_cipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1547 desc->suite.cipher.enc.count);
1552 if (desc->suite.cipher.dec.vecs)
1553 err = test_cipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1554 desc->suite.cipher.dec.count);
1557 crypto_free_cipher(tfm);
1561 static int alg_test_skcipher(const struct alg_test_desc *desc,
1562 const char *driver, u32 type, u32 mask)
1564 struct crypto_skcipher *tfm;
1567 tfm = crypto_alloc_skcipher(driver, type | CRYPTO_ALG_INTERNAL, mask);
1569 printk(KERN_ERR "alg: skcipher: Failed to load transform for "
1570 "%s: %ld\n", driver, PTR_ERR(tfm));
1571 return PTR_ERR(tfm);
1574 if (desc->suite.cipher.enc.vecs) {
1575 err = test_skcipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1576 desc->suite.cipher.enc.count);
1581 if (desc->suite.cipher.dec.vecs)
1582 err = test_skcipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1583 desc->suite.cipher.dec.count);
1586 crypto_free_skcipher(tfm);
1590 static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
1593 struct crypto_comp *tfm;
1596 tfm = crypto_alloc_comp(driver, type, mask);
1598 printk(KERN_ERR "alg: comp: Failed to load transform for %s: "
1599 "%ld\n", driver, PTR_ERR(tfm));
1600 return PTR_ERR(tfm);
1603 err = test_comp(tfm, desc->suite.comp.comp.vecs,
1604 desc->suite.comp.decomp.vecs,
1605 desc->suite.comp.comp.count,
1606 desc->suite.comp.decomp.count);
1608 crypto_free_comp(tfm);
1612 static int alg_test_hash(const struct alg_test_desc *desc, const char *driver,
1615 struct crypto_ahash *tfm;
1618 tfm = crypto_alloc_ahash(driver, type | CRYPTO_ALG_INTERNAL, mask);
1620 printk(KERN_ERR "alg: hash: Failed to load transform for %s: "
1621 "%ld\n", driver, PTR_ERR(tfm));
1622 return PTR_ERR(tfm);
1625 err = test_hash(tfm, desc->suite.hash.vecs,
1626 desc->suite.hash.count, true);
1628 err = test_hash(tfm, desc->suite.hash.vecs,
1629 desc->suite.hash.count, false);
1631 crypto_free_ahash(tfm);
1635 static int alg_test_crc32c(const struct alg_test_desc *desc,
1636 const char *driver, u32 type, u32 mask)
1638 struct crypto_shash *tfm;
1642 err = alg_test_hash(desc, driver, type, mask);
1646 tfm = crypto_alloc_shash(driver, type | CRYPTO_ALG_INTERNAL, mask);
1648 printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: "
1649 "%ld\n", driver, PTR_ERR(tfm));
1655 SHASH_DESC_ON_STACK(shash, tfm);
1656 u32 *ctx = (u32 *)shash_desc_ctx(shash);
1661 *ctx = le32_to_cpu(420553207);
1662 err = crypto_shash_final(shash, (u8 *)&val);
1664 printk(KERN_ERR "alg: crc32c: Operation failed for "
1665 "%s: %d\n", driver, err);
1669 if (val != ~420553207) {
1670 printk(KERN_ERR "alg: crc32c: Test failed for %s: "
1671 "%d\n", driver, val);
1676 crypto_free_shash(tfm);
1682 static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver,
1685 struct crypto_rng *rng;
1688 rng = crypto_alloc_rng(driver, type | CRYPTO_ALG_INTERNAL, mask);
1690 printk(KERN_ERR "alg: cprng: Failed to load transform for %s: "
1691 "%ld\n", driver, PTR_ERR(rng));
1692 return PTR_ERR(rng);
1695 err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count);
1697 crypto_free_rng(rng);
1703 static int drbg_cavs_test(struct drbg_testvec *test, int pr,
1704 const char *driver, u32 type, u32 mask)
1707 struct crypto_rng *drng;
1708 struct drbg_test_data test_data;
1709 struct drbg_string addtl, pers, testentropy;
1710 unsigned char *buf = kzalloc(test->expectedlen, GFP_KERNEL);
1715 drng = crypto_alloc_rng(driver, type | CRYPTO_ALG_INTERNAL, mask);
1717 printk(KERN_ERR "alg: drbg: could not allocate DRNG handle for "
1723 test_data.testentropy = &testentropy;
1724 drbg_string_fill(&testentropy, test->entropy, test->entropylen);
1725 drbg_string_fill(&pers, test->pers, test->perslen);
1726 ret = crypto_drbg_reset_test(drng, &pers, &test_data);
1728 printk(KERN_ERR "alg: drbg: Failed to reset rng\n");
1732 drbg_string_fill(&addtl, test->addtla, test->addtllen);
1734 drbg_string_fill(&testentropy, test->entpra, test->entprlen);
1735 ret = crypto_drbg_get_bytes_addtl_test(drng,
1736 buf, test->expectedlen, &addtl, &test_data);
1738 ret = crypto_drbg_get_bytes_addtl(drng,
1739 buf, test->expectedlen, &addtl);
1742 printk(KERN_ERR "alg: drbg: could not obtain random data for "
1743 "driver %s\n", driver);
1747 drbg_string_fill(&addtl, test->addtlb, test->addtllen);
1749 drbg_string_fill(&testentropy, test->entprb, test->entprlen);
1750 ret = crypto_drbg_get_bytes_addtl_test(drng,
1751 buf, test->expectedlen, &addtl, &test_data);
1753 ret = crypto_drbg_get_bytes_addtl(drng,
1754 buf, test->expectedlen, &addtl);
1757 printk(KERN_ERR "alg: drbg: could not obtain random data for "
1758 "driver %s\n", driver);
1762 ret = memcmp(test->expected, buf, test->expectedlen);
1765 crypto_free_rng(drng);
1771 static int alg_test_drbg(const struct alg_test_desc *desc, const char *driver,
1777 struct drbg_testvec *template = desc->suite.drbg.vecs;
1778 unsigned int tcount = desc->suite.drbg.count;
1780 if (0 == memcmp(driver, "drbg_pr_", 8))
1783 for (i = 0; i < tcount; i++) {
1784 err = drbg_cavs_test(&template[i], pr, driver, type, mask);
1786 printk(KERN_ERR "alg: drbg: Test %d failed for %s\n",
1796 static int do_test_kpp(struct crypto_kpp *tfm, struct kpp_testvec *vec,
1799 struct kpp_request *req;
1800 void *input_buf = NULL;
1801 void *output_buf = NULL;
1802 struct tcrypt_result result;
1803 unsigned int out_len_max;
1805 struct scatterlist src, dst;
1807 req = kpp_request_alloc(tfm, GFP_KERNEL);
1811 init_completion(&result.completion);
1813 err = crypto_kpp_set_secret(tfm, vec->secret, vec->secret_size);
1817 out_len_max = crypto_kpp_maxsize(tfm);
1818 output_buf = kzalloc(out_len_max, GFP_KERNEL);
1824 /* Use appropriate parameter as base */
1825 kpp_request_set_input(req, NULL, 0);
1826 sg_init_one(&dst, output_buf, out_len_max);
1827 kpp_request_set_output(req, &dst, out_len_max);
1828 kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1829 tcrypt_complete, &result);
1831 /* Compute public key */
1832 err = wait_async_op(&result, crypto_kpp_generate_public_key(req));
1834 pr_err("alg: %s: generate public key test failed. err %d\n",
1838 /* Verify calculated public key */
1839 if (memcmp(vec->expected_a_public, sg_virt(req->dst),
1840 vec->expected_a_public_size)) {
1841 pr_err("alg: %s: generate public key test failed. Invalid output\n",
1847 /* Calculate shared secret key by using counter part (b) public key. */
1848 input_buf = kzalloc(vec->b_public_size, GFP_KERNEL);
1854 memcpy(input_buf, vec->b_public, vec->b_public_size);
1855 sg_init_one(&src, input_buf, vec->b_public_size);
1856 sg_init_one(&dst, output_buf, out_len_max);
1857 kpp_request_set_input(req, &src, vec->b_public_size);
1858 kpp_request_set_output(req, &dst, out_len_max);
1859 kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1860 tcrypt_complete, &result);
1861 err = wait_async_op(&result, crypto_kpp_compute_shared_secret(req));
1863 pr_err("alg: %s: compute shard secret test failed. err %d\n",
1868 * verify shared secret from which the user will derive
1869 * secret key by executing whatever hash it has chosen
1871 if (memcmp(vec->expected_ss, sg_virt(req->dst),
1872 vec->expected_ss_size)) {
1873 pr_err("alg: %s: compute shared secret test failed. Invalid output\n",
1883 kpp_request_free(req);
1887 static int test_kpp(struct crypto_kpp *tfm, const char *alg,
1888 struct kpp_testvec *vecs, unsigned int tcount)
1892 for (i = 0; i < tcount; i++) {
1893 ret = do_test_kpp(tfm, vecs++, alg);
1895 pr_err("alg: %s: test failed on vector %d, err=%d\n",
1903 static int alg_test_kpp(const struct alg_test_desc *desc, const char *driver,
1906 struct crypto_kpp *tfm;
1909 tfm = crypto_alloc_kpp(driver, type | CRYPTO_ALG_INTERNAL, mask);
1911 pr_err("alg: kpp: Failed to load tfm for %s: %ld\n",
1912 driver, PTR_ERR(tfm));
1913 return PTR_ERR(tfm);
1915 if (desc->suite.kpp.vecs)
1916 err = test_kpp(tfm, desc->alg, desc->suite.kpp.vecs,
1917 desc->suite.kpp.count);
1919 crypto_free_kpp(tfm);
1923 static int test_akcipher_one(struct crypto_akcipher *tfm,
1924 struct akcipher_testvec *vecs)
1926 char *xbuf[XBUFSIZE];
1927 struct akcipher_request *req;
1928 void *outbuf_enc = NULL;
1929 void *outbuf_dec = NULL;
1930 struct tcrypt_result result;
1931 unsigned int out_len_max, out_len = 0;
1933 struct scatterlist src, dst, src_tab[2];
1935 if (testmgr_alloc_buf(xbuf))
1938 req = akcipher_request_alloc(tfm, GFP_KERNEL);
1942 init_completion(&result.completion);
1944 if (vecs->public_key_vec)
1945 err = crypto_akcipher_set_pub_key(tfm, vecs->key,
1948 err = crypto_akcipher_set_priv_key(tfm, vecs->key,
1954 out_len_max = crypto_akcipher_maxsize(tfm);
1955 outbuf_enc = kzalloc(out_len_max, GFP_KERNEL);
1959 if (WARN_ON(vecs->m_size > PAGE_SIZE))
1962 memcpy(xbuf[0], vecs->m, vecs->m_size);
1964 sg_init_table(src_tab, 2);
1965 sg_set_buf(&src_tab[0], xbuf[0], 8);
1966 sg_set_buf(&src_tab[1], xbuf[0] + 8, vecs->m_size - 8);
1967 sg_init_one(&dst, outbuf_enc, out_len_max);
1968 akcipher_request_set_crypt(req, src_tab, &dst, vecs->m_size,
1970 akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1971 tcrypt_complete, &result);
1973 /* Run RSA encrypt - c = m^e mod n;*/
1974 err = wait_async_op(&result, crypto_akcipher_encrypt(req));
1976 pr_err("alg: akcipher: encrypt test failed. err %d\n", err);
1979 if (req->dst_len != vecs->c_size) {
1980 pr_err("alg: akcipher: encrypt test failed. Invalid output len\n");
1984 /* verify that encrypted message is equal to expected */
1985 if (memcmp(vecs->c, outbuf_enc, vecs->c_size)) {
1986 pr_err("alg: akcipher: encrypt test failed. Invalid output\n");
1987 hexdump(outbuf_enc, vecs->c_size);
1991 /* Don't invoke decrypt for vectors with public key */
1992 if (vecs->public_key_vec) {
1996 outbuf_dec = kzalloc(out_len_max, GFP_KERNEL);
2002 if (WARN_ON(vecs->c_size > PAGE_SIZE))
2005 memcpy(xbuf[0], vecs->c, vecs->c_size);
2007 sg_init_one(&src, xbuf[0], vecs->c_size);
2008 sg_init_one(&dst, outbuf_dec, out_len_max);
2009 init_completion(&result.completion);
2010 akcipher_request_set_crypt(req, &src, &dst, vecs->c_size, out_len_max);
2012 /* Run RSA decrypt - m = c^d mod n;*/
2013 err = wait_async_op(&result, crypto_akcipher_decrypt(req));
2015 pr_err("alg: akcipher: decrypt test failed. err %d\n", err);
2018 out_len = req->dst_len;
2019 if (out_len < vecs->m_size) {
2020 pr_err("alg: akcipher: decrypt test failed. "
2021 "Invalid output len %u\n", out_len);
2025 /* verify that decrypted message is equal to the original msg */
2026 if (memchr_inv(outbuf_dec, 0, out_len - vecs->m_size) ||
2027 memcmp(vecs->m, outbuf_dec + out_len - vecs->m_size,
2029 pr_err("alg: akcipher: decrypt test failed. Invalid output\n");
2030 hexdump(outbuf_dec, out_len);
2037 akcipher_request_free(req);
2039 testmgr_free_buf(xbuf);
2043 static int test_akcipher(struct crypto_akcipher *tfm, const char *alg,
2044 struct akcipher_testvec *vecs, unsigned int tcount)
2047 crypto_tfm_alg_driver_name(crypto_akcipher_tfm(tfm));
2050 for (i = 0; i < tcount; i++) {
2051 ret = test_akcipher_one(tfm, vecs++);
2055 pr_err("alg: akcipher: test %d failed for %s, err=%d\n",
2062 static int alg_test_akcipher(const struct alg_test_desc *desc,
2063 const char *driver, u32 type, u32 mask)
2065 struct crypto_akcipher *tfm;
2068 tfm = crypto_alloc_akcipher(driver, type | CRYPTO_ALG_INTERNAL, mask);
2070 pr_err("alg: akcipher: Failed to load tfm for %s: %ld\n",
2071 driver, PTR_ERR(tfm));
2072 return PTR_ERR(tfm);
2074 if (desc->suite.akcipher.vecs)
2075 err = test_akcipher(tfm, desc->alg, desc->suite.akcipher.vecs,
2076 desc->suite.akcipher.count);
2078 crypto_free_akcipher(tfm);
2082 static int alg_test_null(const struct alg_test_desc *desc,
2083 const char *driver, u32 type, u32 mask)
2088 /* Please keep this list sorted by algorithm name. */
2089 static const struct alg_test_desc alg_test_descs[] = {
2091 .alg = "__cbc-cast5-avx",
2092 .test = alg_test_null,
2094 .alg = "__cbc-cast6-avx",
2095 .test = alg_test_null,
2097 .alg = "__cbc-serpent-avx",
2098 .test = alg_test_null,
2100 .alg = "__cbc-serpent-avx2",
2101 .test = alg_test_null,
2103 .alg = "__cbc-serpent-sse2",
2104 .test = alg_test_null,
2106 .alg = "__cbc-twofish-avx",
2107 .test = alg_test_null,
2109 .alg = "__driver-cbc-aes-aesni",
2110 .test = alg_test_null,
2113 .alg = "__driver-cbc-camellia-aesni",
2114 .test = alg_test_null,
2116 .alg = "__driver-cbc-camellia-aesni-avx2",
2117 .test = alg_test_null,
2119 .alg = "__driver-cbc-cast5-avx",
2120 .test = alg_test_null,
2122 .alg = "__driver-cbc-cast6-avx",
2123 .test = alg_test_null,
2125 .alg = "__driver-cbc-serpent-avx",
2126 .test = alg_test_null,
2128 .alg = "__driver-cbc-serpent-avx2",
2129 .test = alg_test_null,
2131 .alg = "__driver-cbc-serpent-sse2",
2132 .test = alg_test_null,
2134 .alg = "__driver-cbc-twofish-avx",
2135 .test = alg_test_null,
2137 .alg = "__driver-ecb-aes-aesni",
2138 .test = alg_test_null,
2141 .alg = "__driver-ecb-camellia-aesni",
2142 .test = alg_test_null,
2144 .alg = "__driver-ecb-camellia-aesni-avx2",
2145 .test = alg_test_null,
2147 .alg = "__driver-ecb-cast5-avx",
2148 .test = alg_test_null,
2150 .alg = "__driver-ecb-cast6-avx",
2151 .test = alg_test_null,
2153 .alg = "__driver-ecb-serpent-avx",
2154 .test = alg_test_null,
2156 .alg = "__driver-ecb-serpent-avx2",
2157 .test = alg_test_null,
2159 .alg = "__driver-ecb-serpent-sse2",
2160 .test = alg_test_null,
2162 .alg = "__driver-ecb-twofish-avx",
2163 .test = alg_test_null,
2165 .alg = "__driver-gcm-aes-aesni",
2166 .test = alg_test_null,
2169 .alg = "__ghash-pclmulqdqni",
2170 .test = alg_test_null,
2173 .alg = "ansi_cprng",
2174 .test = alg_test_cprng,
2177 .vecs = ansi_cprng_aes_tv_template,
2178 .count = ANSI_CPRNG_AES_TEST_VECTORS
2182 .alg = "authenc(hmac(md5),ecb(cipher_null))",
2183 .test = alg_test_aead,
2187 .vecs = hmac_md5_ecb_cipher_null_enc_tv_template,
2188 .count = HMAC_MD5_ECB_CIPHER_NULL_ENC_TEST_VECTORS
2191 .vecs = hmac_md5_ecb_cipher_null_dec_tv_template,
2192 .count = HMAC_MD5_ECB_CIPHER_NULL_DEC_TEST_VECTORS
2197 .alg = "authenc(hmac(sha1),cbc(aes))",
2198 .test = alg_test_aead,
2203 hmac_sha1_aes_cbc_enc_tv_temp,
2205 HMAC_SHA1_AES_CBC_ENC_TEST_VEC
2210 .alg = "authenc(hmac(sha1),cbc(des))",
2211 .test = alg_test_aead,
2216 hmac_sha1_des_cbc_enc_tv_temp,
2218 HMAC_SHA1_DES_CBC_ENC_TEST_VEC
2223 .alg = "authenc(hmac(sha1),cbc(des3_ede))",
2224 .test = alg_test_aead,
2230 hmac_sha1_des3_ede_cbc_enc_tv_temp,
2232 HMAC_SHA1_DES3_EDE_CBC_ENC_TEST_VEC
2237 .alg = "authenc(hmac(sha1),ctr(aes))",
2238 .test = alg_test_null,
2241 .alg = "authenc(hmac(sha1),ecb(cipher_null))",
2242 .test = alg_test_aead,
2247 hmac_sha1_ecb_cipher_null_enc_tv_temp,
2249 HMAC_SHA1_ECB_CIPHER_NULL_ENC_TEST_VEC
2253 hmac_sha1_ecb_cipher_null_dec_tv_temp,
2255 HMAC_SHA1_ECB_CIPHER_NULL_DEC_TEST_VEC
2260 .alg = "authenc(hmac(sha1),rfc3686(ctr(aes)))",
2261 .test = alg_test_null,
2264 .alg = "authenc(hmac(sha224),cbc(des))",
2265 .test = alg_test_aead,
2270 hmac_sha224_des_cbc_enc_tv_temp,
2272 HMAC_SHA224_DES_CBC_ENC_TEST_VEC
2277 .alg = "authenc(hmac(sha224),cbc(des3_ede))",
2278 .test = alg_test_aead,
2284 hmac_sha224_des3_ede_cbc_enc_tv_temp,
2286 HMAC_SHA224_DES3_EDE_CBC_ENC_TEST_VEC
2291 .alg = "authenc(hmac(sha256),cbc(aes))",
2292 .test = alg_test_aead,
2298 hmac_sha256_aes_cbc_enc_tv_temp,
2300 HMAC_SHA256_AES_CBC_ENC_TEST_VEC
2305 .alg = "authenc(hmac(sha256),cbc(des))",
2306 .test = alg_test_aead,
2311 hmac_sha256_des_cbc_enc_tv_temp,
2313 HMAC_SHA256_DES_CBC_ENC_TEST_VEC
2318 .alg = "authenc(hmac(sha256),cbc(des3_ede))",
2319 .test = alg_test_aead,
2325 hmac_sha256_des3_ede_cbc_enc_tv_temp,
2327 HMAC_SHA256_DES3_EDE_CBC_ENC_TEST_VEC
2332 .alg = "authenc(hmac(sha256),ctr(aes))",
2333 .test = alg_test_null,
2336 .alg = "authenc(hmac(sha256),rfc3686(ctr(aes)))",
2337 .test = alg_test_null,
2340 .alg = "authenc(hmac(sha384),cbc(des))",
2341 .test = alg_test_aead,
2346 hmac_sha384_des_cbc_enc_tv_temp,
2348 HMAC_SHA384_DES_CBC_ENC_TEST_VEC
2353 .alg = "authenc(hmac(sha384),cbc(des3_ede))",
2354 .test = alg_test_aead,
2360 hmac_sha384_des3_ede_cbc_enc_tv_temp,
2362 HMAC_SHA384_DES3_EDE_CBC_ENC_TEST_VEC
2367 .alg = "authenc(hmac(sha384),ctr(aes))",
2368 .test = alg_test_null,
2371 .alg = "authenc(hmac(sha384),rfc3686(ctr(aes)))",
2372 .test = alg_test_null,
2375 .alg = "authenc(hmac(sha512),cbc(aes))",
2377 .test = alg_test_aead,
2382 hmac_sha512_aes_cbc_enc_tv_temp,
2384 HMAC_SHA512_AES_CBC_ENC_TEST_VEC
2389 .alg = "authenc(hmac(sha512),cbc(des))",
2390 .test = alg_test_aead,
2395 hmac_sha512_des_cbc_enc_tv_temp,
2397 HMAC_SHA512_DES_CBC_ENC_TEST_VEC
2402 .alg = "authenc(hmac(sha512),cbc(des3_ede))",
2403 .test = alg_test_aead,
2409 hmac_sha512_des3_ede_cbc_enc_tv_temp,
2411 HMAC_SHA512_DES3_EDE_CBC_ENC_TEST_VEC
2416 .alg = "authenc(hmac(sha512),ctr(aes))",
2417 .test = alg_test_null,
2420 .alg = "authenc(hmac(sha512),rfc3686(ctr(aes)))",
2421 .test = alg_test_null,
2425 .test = alg_test_skcipher,
2430 .vecs = aes_cbc_enc_tv_template,
2431 .count = AES_CBC_ENC_TEST_VECTORS
2434 .vecs = aes_cbc_dec_tv_template,
2435 .count = AES_CBC_DEC_TEST_VECTORS
2440 .alg = "cbc(anubis)",
2441 .test = alg_test_skcipher,
2445 .vecs = anubis_cbc_enc_tv_template,
2446 .count = ANUBIS_CBC_ENC_TEST_VECTORS
2449 .vecs = anubis_cbc_dec_tv_template,
2450 .count = ANUBIS_CBC_DEC_TEST_VECTORS
2455 .alg = "cbc(blowfish)",
2456 .test = alg_test_skcipher,
2460 .vecs = bf_cbc_enc_tv_template,
2461 .count = BF_CBC_ENC_TEST_VECTORS
2464 .vecs = bf_cbc_dec_tv_template,
2465 .count = BF_CBC_DEC_TEST_VECTORS
2470 .alg = "cbc(camellia)",
2471 .test = alg_test_skcipher,
2475 .vecs = camellia_cbc_enc_tv_template,
2476 .count = CAMELLIA_CBC_ENC_TEST_VECTORS
2479 .vecs = camellia_cbc_dec_tv_template,
2480 .count = CAMELLIA_CBC_DEC_TEST_VECTORS
2485 .alg = "cbc(cast5)",
2486 .test = alg_test_skcipher,
2490 .vecs = cast5_cbc_enc_tv_template,
2491 .count = CAST5_CBC_ENC_TEST_VECTORS
2494 .vecs = cast5_cbc_dec_tv_template,
2495 .count = CAST5_CBC_DEC_TEST_VECTORS
2500 .alg = "cbc(cast6)",
2501 .test = alg_test_skcipher,
2505 .vecs = cast6_cbc_enc_tv_template,
2506 .count = CAST6_CBC_ENC_TEST_VECTORS
2509 .vecs = cast6_cbc_dec_tv_template,
2510 .count = CAST6_CBC_DEC_TEST_VECTORS
2516 .test = alg_test_skcipher,
2520 .vecs = des_cbc_enc_tv_template,
2521 .count = DES_CBC_ENC_TEST_VECTORS
2524 .vecs = des_cbc_dec_tv_template,
2525 .count = DES_CBC_DEC_TEST_VECTORS
2530 .alg = "cbc(des3_ede)",
2531 .test = alg_test_skcipher,
2536 .vecs = des3_ede_cbc_enc_tv_template,
2537 .count = DES3_EDE_CBC_ENC_TEST_VECTORS
2540 .vecs = des3_ede_cbc_dec_tv_template,
2541 .count = DES3_EDE_CBC_DEC_TEST_VECTORS
2546 .alg = "cbc(serpent)",
2547 .test = alg_test_skcipher,
2551 .vecs = serpent_cbc_enc_tv_template,
2552 .count = SERPENT_CBC_ENC_TEST_VECTORS
2555 .vecs = serpent_cbc_dec_tv_template,
2556 .count = SERPENT_CBC_DEC_TEST_VECTORS
2561 .alg = "cbc(twofish)",
2562 .test = alg_test_skcipher,
2566 .vecs = tf_cbc_enc_tv_template,
2567 .count = TF_CBC_ENC_TEST_VECTORS
2570 .vecs = tf_cbc_dec_tv_template,
2571 .count = TF_CBC_DEC_TEST_VECTORS
2577 .test = alg_test_aead,
2582 .vecs = aes_ccm_enc_tv_template,
2583 .count = AES_CCM_ENC_TEST_VECTORS
2586 .vecs = aes_ccm_dec_tv_template,
2587 .count = AES_CCM_DEC_TEST_VECTORS
2593 .test = alg_test_skcipher,
2597 .vecs = chacha20_enc_tv_template,
2598 .count = CHACHA20_ENC_TEST_VECTORS
2601 .vecs = chacha20_enc_tv_template,
2602 .count = CHACHA20_ENC_TEST_VECTORS
2609 .test = alg_test_hash,
2612 .vecs = aes_cmac128_tv_template,
2613 .count = CMAC_AES_TEST_VECTORS
2617 .alg = "cmac(des3_ede)",
2619 .test = alg_test_hash,
2622 .vecs = des3_ede_cmac64_tv_template,
2623 .count = CMAC_DES3_EDE_TEST_VECTORS
2627 .alg = "compress_null",
2628 .test = alg_test_null,
2631 .test = alg_test_hash,
2634 .vecs = crc32_tv_template,
2635 .count = CRC32_TEST_VECTORS
2640 .test = alg_test_crc32c,
2644 .vecs = crc32c_tv_template,
2645 .count = CRC32C_TEST_VECTORS
2650 .test = alg_test_hash,
2654 .vecs = crct10dif_tv_template,
2655 .count = CRCT10DIF_TEST_VECTORS
2659 .alg = "cryptd(__driver-cbc-aes-aesni)",
2660 .test = alg_test_null,
2663 .alg = "cryptd(__driver-cbc-camellia-aesni)",
2664 .test = alg_test_null,
2666 .alg = "cryptd(__driver-cbc-camellia-aesni-avx2)",
2667 .test = alg_test_null,
2669 .alg = "cryptd(__driver-cbc-serpent-avx2)",
2670 .test = alg_test_null,
2672 .alg = "cryptd(__driver-ecb-aes-aesni)",
2673 .test = alg_test_null,
2676 .alg = "cryptd(__driver-ecb-camellia-aesni)",
2677 .test = alg_test_null,
2679 .alg = "cryptd(__driver-ecb-camellia-aesni-avx2)",
2680 .test = alg_test_null,
2682 .alg = "cryptd(__driver-ecb-cast5-avx)",
2683 .test = alg_test_null,
2685 .alg = "cryptd(__driver-ecb-cast6-avx)",
2686 .test = alg_test_null,
2688 .alg = "cryptd(__driver-ecb-serpent-avx)",
2689 .test = alg_test_null,
2691 .alg = "cryptd(__driver-ecb-serpent-avx2)",
2692 .test = alg_test_null,
2694 .alg = "cryptd(__driver-ecb-serpent-sse2)",
2695 .test = alg_test_null,
2697 .alg = "cryptd(__driver-ecb-twofish-avx)",
2698 .test = alg_test_null,
2700 .alg = "cryptd(__driver-gcm-aes-aesni)",
2701 .test = alg_test_null,
2704 .alg = "cryptd(__ghash-pclmulqdqni)",
2705 .test = alg_test_null,
2709 .test = alg_test_skcipher,
2714 .vecs = aes_ctr_enc_tv_template,
2715 .count = AES_CTR_ENC_TEST_VECTORS
2718 .vecs = aes_ctr_dec_tv_template,
2719 .count = AES_CTR_DEC_TEST_VECTORS
2724 .alg = "ctr(blowfish)",
2725 .test = alg_test_skcipher,
2729 .vecs = bf_ctr_enc_tv_template,
2730 .count = BF_CTR_ENC_TEST_VECTORS
2733 .vecs = bf_ctr_dec_tv_template,
2734 .count = BF_CTR_DEC_TEST_VECTORS
2739 .alg = "ctr(camellia)",
2740 .test = alg_test_skcipher,
2744 .vecs = camellia_ctr_enc_tv_template,
2745 .count = CAMELLIA_CTR_ENC_TEST_VECTORS
2748 .vecs = camellia_ctr_dec_tv_template,
2749 .count = CAMELLIA_CTR_DEC_TEST_VECTORS
2754 .alg = "ctr(cast5)",
2755 .test = alg_test_skcipher,
2759 .vecs = cast5_ctr_enc_tv_template,
2760 .count = CAST5_CTR_ENC_TEST_VECTORS
2763 .vecs = cast5_ctr_dec_tv_template,
2764 .count = CAST5_CTR_DEC_TEST_VECTORS
2769 .alg = "ctr(cast6)",
2770 .test = alg_test_skcipher,
2774 .vecs = cast6_ctr_enc_tv_template,
2775 .count = CAST6_CTR_ENC_TEST_VECTORS
2778 .vecs = cast6_ctr_dec_tv_template,
2779 .count = CAST6_CTR_DEC_TEST_VECTORS
2785 .test = alg_test_skcipher,
2789 .vecs = des_ctr_enc_tv_template,
2790 .count = DES_CTR_ENC_TEST_VECTORS
2793 .vecs = des_ctr_dec_tv_template,
2794 .count = DES_CTR_DEC_TEST_VECTORS
2799 .alg = "ctr(des3_ede)",
2800 .test = alg_test_skcipher,
2804 .vecs = des3_ede_ctr_enc_tv_template,
2805 .count = DES3_EDE_CTR_ENC_TEST_VECTORS
2808 .vecs = des3_ede_ctr_dec_tv_template,
2809 .count = DES3_EDE_CTR_DEC_TEST_VECTORS
2814 .alg = "ctr(serpent)",
2815 .test = alg_test_skcipher,
2819 .vecs = serpent_ctr_enc_tv_template,
2820 .count = SERPENT_CTR_ENC_TEST_VECTORS
2823 .vecs = serpent_ctr_dec_tv_template,
2824 .count = SERPENT_CTR_DEC_TEST_VECTORS
2829 .alg = "ctr(twofish)",
2830 .test = alg_test_skcipher,
2834 .vecs = tf_ctr_enc_tv_template,
2835 .count = TF_CTR_ENC_TEST_VECTORS
2838 .vecs = tf_ctr_dec_tv_template,
2839 .count = TF_CTR_DEC_TEST_VECTORS
2844 .alg = "cts(cbc(aes))",
2845 .test = alg_test_skcipher,
2849 .vecs = cts_mode_enc_tv_template,
2850 .count = CTS_MODE_ENC_TEST_VECTORS
2853 .vecs = cts_mode_dec_tv_template,
2854 .count = CTS_MODE_DEC_TEST_VECTORS
2860 .test = alg_test_comp,
2865 .vecs = deflate_comp_tv_template,
2866 .count = DEFLATE_COMP_TEST_VECTORS
2869 .vecs = deflate_decomp_tv_template,
2870 .count = DEFLATE_DECOMP_TEST_VECTORS
2876 .test = alg_test_kpp,
2880 .vecs = dh_tv_template,
2881 .count = DH_TEST_VECTORS
2885 .alg = "digest_null",
2886 .test = alg_test_null,
2888 .alg = "drbg_nopr_ctr_aes128",
2889 .test = alg_test_drbg,
2893 .vecs = drbg_nopr_ctr_aes128_tv_template,
2894 .count = ARRAY_SIZE(drbg_nopr_ctr_aes128_tv_template)
2898 .alg = "drbg_nopr_ctr_aes192",
2899 .test = alg_test_drbg,
2903 .vecs = drbg_nopr_ctr_aes192_tv_template,
2904 .count = ARRAY_SIZE(drbg_nopr_ctr_aes192_tv_template)
2908 .alg = "drbg_nopr_ctr_aes256",
2909 .test = alg_test_drbg,
2913 .vecs = drbg_nopr_ctr_aes256_tv_template,
2914 .count = ARRAY_SIZE(drbg_nopr_ctr_aes256_tv_template)
2919 * There is no need to specifically test the DRBG with every
2920 * backend cipher -- covered by drbg_nopr_hmac_sha256 test
2922 .alg = "drbg_nopr_hmac_sha1",
2924 .test = alg_test_null,
2926 .alg = "drbg_nopr_hmac_sha256",
2927 .test = alg_test_drbg,
2931 .vecs = drbg_nopr_hmac_sha256_tv_template,
2933 ARRAY_SIZE(drbg_nopr_hmac_sha256_tv_template)
2937 /* covered by drbg_nopr_hmac_sha256 test */
2938 .alg = "drbg_nopr_hmac_sha384",
2940 .test = alg_test_null,
2942 .alg = "drbg_nopr_hmac_sha512",
2943 .test = alg_test_null,
2946 .alg = "drbg_nopr_sha1",
2948 .test = alg_test_null,
2950 .alg = "drbg_nopr_sha256",
2951 .test = alg_test_drbg,
2955 .vecs = drbg_nopr_sha256_tv_template,
2956 .count = ARRAY_SIZE(drbg_nopr_sha256_tv_template)
2960 /* covered by drbg_nopr_sha256 test */
2961 .alg = "drbg_nopr_sha384",
2963 .test = alg_test_null,
2965 .alg = "drbg_nopr_sha512",
2967 .test = alg_test_null,
2969 .alg = "drbg_pr_ctr_aes128",
2970 .test = alg_test_drbg,
2974 .vecs = drbg_pr_ctr_aes128_tv_template,
2975 .count = ARRAY_SIZE(drbg_pr_ctr_aes128_tv_template)
2979 /* covered by drbg_pr_ctr_aes128 test */
2980 .alg = "drbg_pr_ctr_aes192",
2982 .test = alg_test_null,
2984 .alg = "drbg_pr_ctr_aes256",
2986 .test = alg_test_null,
2988 .alg = "drbg_pr_hmac_sha1",
2990 .test = alg_test_null,
2992 .alg = "drbg_pr_hmac_sha256",
2993 .test = alg_test_drbg,
2997 .vecs = drbg_pr_hmac_sha256_tv_template,
2998 .count = ARRAY_SIZE(drbg_pr_hmac_sha256_tv_template)
3002 /* covered by drbg_pr_hmac_sha256 test */
3003 .alg = "drbg_pr_hmac_sha384",
3005 .test = alg_test_null,
3007 .alg = "drbg_pr_hmac_sha512",
3008 .test = alg_test_null,
3011 .alg = "drbg_pr_sha1",
3013 .test = alg_test_null,
3015 .alg = "drbg_pr_sha256",
3016 .test = alg_test_drbg,
3020 .vecs = drbg_pr_sha256_tv_template,
3021 .count = ARRAY_SIZE(drbg_pr_sha256_tv_template)
3025 /* covered by drbg_pr_sha256 test */
3026 .alg = "drbg_pr_sha384",
3028 .test = alg_test_null,
3030 .alg = "drbg_pr_sha512",
3032 .test = alg_test_null,
3034 .alg = "ecb(__aes-aesni)",
3035 .test = alg_test_null,
3039 .test = alg_test_skcipher,
3044 .vecs = aes_enc_tv_template,
3045 .count = AES_ENC_TEST_VECTORS
3048 .vecs = aes_dec_tv_template,
3049 .count = AES_DEC_TEST_VECTORS
3054 .alg = "ecb(anubis)",
3055 .test = alg_test_skcipher,
3059 .vecs = anubis_enc_tv_template,
3060 .count = ANUBIS_ENC_TEST_VECTORS
3063 .vecs = anubis_dec_tv_template,
3064 .count = ANUBIS_DEC_TEST_VECTORS
3070 .test = alg_test_skcipher,
3074 .vecs = arc4_enc_tv_template,
3075 .count = ARC4_ENC_TEST_VECTORS
3078 .vecs = arc4_dec_tv_template,
3079 .count = ARC4_DEC_TEST_VECTORS
3084 .alg = "ecb(blowfish)",
3085 .test = alg_test_skcipher,
3089 .vecs = bf_enc_tv_template,
3090 .count = BF_ENC_TEST_VECTORS
3093 .vecs = bf_dec_tv_template,
3094 .count = BF_DEC_TEST_VECTORS
3099 .alg = "ecb(camellia)",
3100 .test = alg_test_skcipher,
3104 .vecs = camellia_enc_tv_template,
3105 .count = CAMELLIA_ENC_TEST_VECTORS
3108 .vecs = camellia_dec_tv_template,
3109 .count = CAMELLIA_DEC_TEST_VECTORS
3114 .alg = "ecb(cast5)",
3115 .test = alg_test_skcipher,
3119 .vecs = cast5_enc_tv_template,
3120 .count = CAST5_ENC_TEST_VECTORS
3123 .vecs = cast5_dec_tv_template,
3124 .count = CAST5_DEC_TEST_VECTORS
3129 .alg = "ecb(cast6)",
3130 .test = alg_test_skcipher,
3134 .vecs = cast6_enc_tv_template,
3135 .count = CAST6_ENC_TEST_VECTORS
3138 .vecs = cast6_dec_tv_template,
3139 .count = CAST6_DEC_TEST_VECTORS
3144 .alg = "ecb(cipher_null)",
3145 .test = alg_test_null,
3148 .test = alg_test_skcipher,
3152 .vecs = des_enc_tv_template,
3153 .count = DES_ENC_TEST_VECTORS
3156 .vecs = des_dec_tv_template,
3157 .count = DES_DEC_TEST_VECTORS
3162 .alg = "ecb(des3_ede)",
3163 .test = alg_test_skcipher,
3168 .vecs = des3_ede_enc_tv_template,
3169 .count = DES3_EDE_ENC_TEST_VECTORS
3172 .vecs = des3_ede_dec_tv_template,
3173 .count = DES3_EDE_DEC_TEST_VECTORS
3178 .alg = "ecb(fcrypt)",
3179 .test = alg_test_skcipher,
3183 .vecs = fcrypt_pcbc_enc_tv_template,
3187 .vecs = fcrypt_pcbc_dec_tv_template,
3193 .alg = "ecb(khazad)",
3194 .test = alg_test_skcipher,
3198 .vecs = khazad_enc_tv_template,
3199 .count = KHAZAD_ENC_TEST_VECTORS
3202 .vecs = khazad_dec_tv_template,
3203 .count = KHAZAD_DEC_TEST_VECTORS
3209 .test = alg_test_skcipher,
3213 .vecs = seed_enc_tv_template,
3214 .count = SEED_ENC_TEST_VECTORS
3217 .vecs = seed_dec_tv_template,
3218 .count = SEED_DEC_TEST_VECTORS
3223 .alg = "ecb(serpent)",
3224 .test = alg_test_skcipher,
3228 .vecs = serpent_enc_tv_template,
3229 .count = SERPENT_ENC_TEST_VECTORS
3232 .vecs = serpent_dec_tv_template,
3233 .count = SERPENT_DEC_TEST_VECTORS
3239 .test = alg_test_skcipher,
3243 .vecs = tea_enc_tv_template,
3244 .count = TEA_ENC_TEST_VECTORS
3247 .vecs = tea_dec_tv_template,
3248 .count = TEA_DEC_TEST_VECTORS
3253 .alg = "ecb(tnepres)",
3254 .test = alg_test_skcipher,
3258 .vecs = tnepres_enc_tv_template,
3259 .count = TNEPRES_ENC_TEST_VECTORS
3262 .vecs = tnepres_dec_tv_template,
3263 .count = TNEPRES_DEC_TEST_VECTORS
3268 .alg = "ecb(twofish)",
3269 .test = alg_test_skcipher,
3273 .vecs = tf_enc_tv_template,
3274 .count = TF_ENC_TEST_VECTORS
3277 .vecs = tf_dec_tv_template,
3278 .count = TF_DEC_TEST_VECTORS
3284 .test = alg_test_skcipher,
3288 .vecs = xeta_enc_tv_template,
3289 .count = XETA_ENC_TEST_VECTORS
3292 .vecs = xeta_dec_tv_template,
3293 .count = XETA_DEC_TEST_VECTORS
3299 .test = alg_test_skcipher,
3303 .vecs = xtea_enc_tv_template,
3304 .count = XTEA_ENC_TEST_VECTORS
3307 .vecs = xtea_dec_tv_template,
3308 .count = XTEA_DEC_TEST_VECTORS
3314 .test = alg_test_kpp,
3318 .vecs = ecdh_tv_template,
3319 .count = ECDH_TEST_VECTORS
3324 .test = alg_test_aead,
3329 .vecs = aes_gcm_enc_tv_template,
3330 .count = AES_GCM_ENC_TEST_VECTORS
3333 .vecs = aes_gcm_dec_tv_template,
3334 .count = AES_GCM_DEC_TEST_VECTORS
3340 .test = alg_test_hash,
3344 .vecs = ghash_tv_template,
3345 .count = GHASH_TEST_VECTORS
3349 .alg = "hmac(crc32)",
3350 .test = alg_test_hash,
3353 .vecs = bfin_crc_tv_template,
3354 .count = BFIN_CRC_TEST_VECTORS
3359 .test = alg_test_hash,
3362 .vecs = hmac_md5_tv_template,
3363 .count = HMAC_MD5_TEST_VECTORS
3367 .alg = "hmac(rmd128)",
3368 .test = alg_test_hash,
3371 .vecs = hmac_rmd128_tv_template,
3372 .count = HMAC_RMD128_TEST_VECTORS
3376 .alg = "hmac(rmd160)",
3377 .test = alg_test_hash,
3380 .vecs = hmac_rmd160_tv_template,
3381 .count = HMAC_RMD160_TEST_VECTORS
3385 .alg = "hmac(sha1)",
3386 .test = alg_test_hash,
3390 .vecs = hmac_sha1_tv_template,
3391 .count = HMAC_SHA1_TEST_VECTORS
3395 .alg = "hmac(sha224)",
3396 .test = alg_test_hash,
3400 .vecs = hmac_sha224_tv_template,
3401 .count = HMAC_SHA224_TEST_VECTORS
3405 .alg = "hmac(sha256)",
3406 .test = alg_test_hash,
3410 .vecs = hmac_sha256_tv_template,
3411 .count = HMAC_SHA256_TEST_VECTORS
3415 .alg = "hmac(sha3-224)",
3416 .test = alg_test_hash,
3420 .vecs = hmac_sha3_224_tv_template,
3421 .count = HMAC_SHA3_224_TEST_VECTORS
3425 .alg = "hmac(sha3-256)",
3426 .test = alg_test_hash,
3430 .vecs = hmac_sha3_256_tv_template,
3431 .count = HMAC_SHA3_256_TEST_VECTORS
3435 .alg = "hmac(sha3-384)",
3436 .test = alg_test_hash,
3440 .vecs = hmac_sha3_384_tv_template,
3441 .count = HMAC_SHA3_384_TEST_VECTORS
3445 .alg = "hmac(sha3-512)",
3446 .test = alg_test_hash,
3450 .vecs = hmac_sha3_512_tv_template,
3451 .count = HMAC_SHA3_512_TEST_VECTORS
3455 .alg = "hmac(sha384)",
3456 .test = alg_test_hash,
3460 .vecs = hmac_sha384_tv_template,
3461 .count = HMAC_SHA384_TEST_VECTORS
3465 .alg = "hmac(sha512)",
3466 .test = alg_test_hash,
3470 .vecs = hmac_sha512_tv_template,
3471 .count = HMAC_SHA512_TEST_VECTORS
3475 .alg = "jitterentropy_rng",
3477 .test = alg_test_null,
3480 .test = alg_test_skcipher,
3485 .vecs = aes_kw_enc_tv_template,
3486 .count = ARRAY_SIZE(aes_kw_enc_tv_template)
3489 .vecs = aes_kw_dec_tv_template,
3490 .count = ARRAY_SIZE(aes_kw_dec_tv_template)
3496 .test = alg_test_skcipher,
3500 .vecs = aes_lrw_enc_tv_template,
3501 .count = AES_LRW_ENC_TEST_VECTORS
3504 .vecs = aes_lrw_dec_tv_template,
3505 .count = AES_LRW_DEC_TEST_VECTORS
3510 .alg = "lrw(camellia)",
3511 .test = alg_test_skcipher,
3515 .vecs = camellia_lrw_enc_tv_template,
3516 .count = CAMELLIA_LRW_ENC_TEST_VECTORS
3519 .vecs = camellia_lrw_dec_tv_template,
3520 .count = CAMELLIA_LRW_DEC_TEST_VECTORS
3525 .alg = "lrw(cast6)",
3526 .test = alg_test_skcipher,
3530 .vecs = cast6_lrw_enc_tv_template,
3531 .count = CAST6_LRW_ENC_TEST_VECTORS
3534 .vecs = cast6_lrw_dec_tv_template,
3535 .count = CAST6_LRW_DEC_TEST_VECTORS
3540 .alg = "lrw(serpent)",
3541 .test = alg_test_skcipher,
3545 .vecs = serpent_lrw_enc_tv_template,
3546 .count = SERPENT_LRW_ENC_TEST_VECTORS
3549 .vecs = serpent_lrw_dec_tv_template,
3550 .count = SERPENT_LRW_DEC_TEST_VECTORS
3555 .alg = "lrw(twofish)",
3556 .test = alg_test_skcipher,
3560 .vecs = tf_lrw_enc_tv_template,
3561 .count = TF_LRW_ENC_TEST_VECTORS
3564 .vecs = tf_lrw_dec_tv_template,
3565 .count = TF_LRW_DEC_TEST_VECTORS
3571 .test = alg_test_comp,
3576 .vecs = lz4_comp_tv_template,
3577 .count = LZ4_COMP_TEST_VECTORS
3580 .vecs = lz4_decomp_tv_template,
3581 .count = LZ4_DECOMP_TEST_VECTORS
3587 .test = alg_test_comp,
3592 .vecs = lz4hc_comp_tv_template,
3593 .count = LZ4HC_COMP_TEST_VECTORS
3596 .vecs = lz4hc_decomp_tv_template,
3597 .count = LZ4HC_DECOMP_TEST_VECTORS
3603 .test = alg_test_comp,
3608 .vecs = lzo_comp_tv_template,
3609 .count = LZO_COMP_TEST_VECTORS
3612 .vecs = lzo_decomp_tv_template,
3613 .count = LZO_DECOMP_TEST_VECTORS
3619 .test = alg_test_hash,
3622 .vecs = md4_tv_template,
3623 .count = MD4_TEST_VECTORS
3628 .test = alg_test_hash,
3631 .vecs = md5_tv_template,
3632 .count = MD5_TEST_VECTORS
3636 .alg = "michael_mic",
3637 .test = alg_test_hash,
3640 .vecs = michael_mic_tv_template,
3641 .count = MICHAEL_MIC_TEST_VECTORS
3646 .test = alg_test_skcipher,
3651 .vecs = aes_ofb_enc_tv_template,
3652 .count = AES_OFB_ENC_TEST_VECTORS
3655 .vecs = aes_ofb_dec_tv_template,
3656 .count = AES_OFB_DEC_TEST_VECTORS
3661 .alg = "pcbc(fcrypt)",
3662 .test = alg_test_skcipher,
3666 .vecs = fcrypt_pcbc_enc_tv_template,
3667 .count = FCRYPT_ENC_TEST_VECTORS
3670 .vecs = fcrypt_pcbc_dec_tv_template,
3671 .count = FCRYPT_DEC_TEST_VECTORS
3677 .test = alg_test_hash,
3680 .vecs = poly1305_tv_template,
3681 .count = POLY1305_TEST_VECTORS
3685 .alg = "rfc3686(ctr(aes))",
3686 .test = alg_test_skcipher,
3691 .vecs = aes_ctr_rfc3686_enc_tv_template,
3692 .count = AES_CTR_3686_ENC_TEST_VECTORS
3695 .vecs = aes_ctr_rfc3686_dec_tv_template,
3696 .count = AES_CTR_3686_DEC_TEST_VECTORS
3701 .alg = "rfc4106(gcm(aes))",
3702 .test = alg_test_aead,
3707 .vecs = aes_gcm_rfc4106_enc_tv_template,
3708 .count = AES_GCM_4106_ENC_TEST_VECTORS
3711 .vecs = aes_gcm_rfc4106_dec_tv_template,
3712 .count = AES_GCM_4106_DEC_TEST_VECTORS
3717 .alg = "rfc4309(ccm(aes))",
3718 .test = alg_test_aead,
3723 .vecs = aes_ccm_rfc4309_enc_tv_template,
3724 .count = AES_CCM_4309_ENC_TEST_VECTORS
3727 .vecs = aes_ccm_rfc4309_dec_tv_template,
3728 .count = AES_CCM_4309_DEC_TEST_VECTORS
3733 .alg = "rfc4543(gcm(aes))",
3734 .test = alg_test_aead,
3738 .vecs = aes_gcm_rfc4543_enc_tv_template,
3739 .count = AES_GCM_4543_ENC_TEST_VECTORS
3742 .vecs = aes_gcm_rfc4543_dec_tv_template,
3743 .count = AES_GCM_4543_DEC_TEST_VECTORS
3748 .alg = "rfc7539(chacha20,poly1305)",
3749 .test = alg_test_aead,
3753 .vecs = rfc7539_enc_tv_template,
3754 .count = RFC7539_ENC_TEST_VECTORS
3757 .vecs = rfc7539_dec_tv_template,
3758 .count = RFC7539_DEC_TEST_VECTORS
3763 .alg = "rfc7539esp(chacha20,poly1305)",
3764 .test = alg_test_aead,
3768 .vecs = rfc7539esp_enc_tv_template,
3769 .count = RFC7539ESP_ENC_TEST_VECTORS
3772 .vecs = rfc7539esp_dec_tv_template,
3773 .count = RFC7539ESP_DEC_TEST_VECTORS
3779 .test = alg_test_hash,
3782 .vecs = rmd128_tv_template,
3783 .count = RMD128_TEST_VECTORS
3788 .test = alg_test_hash,
3791 .vecs = rmd160_tv_template,
3792 .count = RMD160_TEST_VECTORS
3797 .test = alg_test_hash,
3800 .vecs = rmd256_tv_template,
3801 .count = RMD256_TEST_VECTORS
3806 .test = alg_test_hash,
3809 .vecs = rmd320_tv_template,
3810 .count = RMD320_TEST_VECTORS
3815 .test = alg_test_akcipher,
3819 .vecs = rsa_tv_template,
3820 .count = RSA_TEST_VECTORS
3825 .test = alg_test_skcipher,
3829 .vecs = salsa20_stream_enc_tv_template,
3830 .count = SALSA20_STREAM_ENC_TEST_VECTORS
3836 .test = alg_test_hash,
3840 .vecs = sha1_tv_template,
3841 .count = SHA1_TEST_VECTORS
3846 .test = alg_test_hash,
3850 .vecs = sha224_tv_template,
3851 .count = SHA224_TEST_VECTORS
3856 .test = alg_test_hash,
3860 .vecs = sha256_tv_template,
3861 .count = SHA256_TEST_VECTORS
3866 .test = alg_test_hash,
3870 .vecs = sha3_224_tv_template,
3871 .count = SHA3_224_TEST_VECTORS
3876 .test = alg_test_hash,
3880 .vecs = sha3_256_tv_template,
3881 .count = SHA3_256_TEST_VECTORS
3886 .test = alg_test_hash,
3890 .vecs = sha3_384_tv_template,
3891 .count = SHA3_384_TEST_VECTORS
3896 .test = alg_test_hash,
3900 .vecs = sha3_512_tv_template,
3901 .count = SHA3_512_TEST_VECTORS
3906 .test = alg_test_hash,
3910 .vecs = sha384_tv_template,
3911 .count = SHA384_TEST_VECTORS
3916 .test = alg_test_hash,
3920 .vecs = sha512_tv_template,
3921 .count = SHA512_TEST_VECTORS
3926 .test = alg_test_hash,
3929 .vecs = tgr128_tv_template,
3930 .count = TGR128_TEST_VECTORS
3935 .test = alg_test_hash,
3938 .vecs = tgr160_tv_template,
3939 .count = TGR160_TEST_VECTORS
3944 .test = alg_test_hash,
3947 .vecs = tgr192_tv_template,
3948 .count = TGR192_TEST_VECTORS
3953 .test = alg_test_hash,
3956 .vecs = aes_vmac128_tv_template,
3957 .count = VMAC_AES_TEST_VECTORS
3962 .test = alg_test_hash,
3965 .vecs = wp256_tv_template,
3966 .count = WP256_TEST_VECTORS
3971 .test = alg_test_hash,
3974 .vecs = wp384_tv_template,
3975 .count = WP384_TEST_VECTORS
3980 .test = alg_test_hash,
3983 .vecs = wp512_tv_template,
3984 .count = WP512_TEST_VECTORS
3989 .test = alg_test_hash,
3992 .vecs = aes_xcbc128_tv_template,
3993 .count = XCBC_AES_TEST_VECTORS
3998 .test = alg_test_skcipher,
4003 .vecs = aes_xts_enc_tv_template,
4004 .count = AES_XTS_ENC_TEST_VECTORS
4007 .vecs = aes_xts_dec_tv_template,
4008 .count = AES_XTS_DEC_TEST_VECTORS
4013 .alg = "xts(camellia)",
4014 .test = alg_test_skcipher,
4018 .vecs = camellia_xts_enc_tv_template,
4019 .count = CAMELLIA_XTS_ENC_TEST_VECTORS
4022 .vecs = camellia_xts_dec_tv_template,
4023 .count = CAMELLIA_XTS_DEC_TEST_VECTORS
4028 .alg = "xts(cast6)",
4029 .test = alg_test_skcipher,
4033 .vecs = cast6_xts_enc_tv_template,
4034 .count = CAST6_XTS_ENC_TEST_VECTORS
4037 .vecs = cast6_xts_dec_tv_template,
4038 .count = CAST6_XTS_DEC_TEST_VECTORS
4043 .alg = "xts(serpent)",
4044 .test = alg_test_skcipher,
4048 .vecs = serpent_xts_enc_tv_template,
4049 .count = SERPENT_XTS_ENC_TEST_VECTORS
4052 .vecs = serpent_xts_dec_tv_template,
4053 .count = SERPENT_XTS_DEC_TEST_VECTORS
4058 .alg = "xts(twofish)",
4059 .test = alg_test_skcipher,
4063 .vecs = tf_xts_enc_tv_template,
4064 .count = TF_XTS_ENC_TEST_VECTORS
4067 .vecs = tf_xts_dec_tv_template,
4068 .count = TF_XTS_DEC_TEST_VECTORS
4075 static bool alg_test_descs_checked;
4077 static void alg_test_descs_check_order(void)
4081 /* only check once */
4082 if (alg_test_descs_checked)
4085 alg_test_descs_checked = true;
4087 for (i = 1; i < ARRAY_SIZE(alg_test_descs); i++) {
4088 int diff = strcmp(alg_test_descs[i - 1].alg,
4089 alg_test_descs[i].alg);
4091 if (WARN_ON(diff > 0)) {
4092 pr_warn("testmgr: alg_test_descs entries in wrong order: '%s' before '%s'\n",
4093 alg_test_descs[i - 1].alg,
4094 alg_test_descs[i].alg);
4097 if (WARN_ON(diff == 0)) {
4098 pr_warn("testmgr: duplicate alg_test_descs entry: '%s'\n",
4099 alg_test_descs[i].alg);
4104 static int alg_find_test(const char *alg)
4107 int end = ARRAY_SIZE(alg_test_descs);
4109 while (start < end) {
4110 int i = (start + end) / 2;
4111 int diff = strcmp(alg_test_descs[i].alg, alg);
4129 int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
4135 if (!fips_enabled && notests) {
4136 printk_once(KERN_INFO "alg: self-tests disabled\n");
4140 alg_test_descs_check_order();
4142 if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) {
4143 char nalg[CRYPTO_MAX_ALG_NAME];
4145 if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >=
4147 return -ENAMETOOLONG;
4149 i = alg_find_test(nalg);
4153 if (fips_enabled && !alg_test_descs[i].fips_allowed)
4156 rc = alg_test_cipher(alg_test_descs + i, driver, type, mask);
4160 i = alg_find_test(alg);
4161 j = alg_find_test(driver);
4165 if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) ||
4166 (j >= 0 && !alg_test_descs[j].fips_allowed)))
4171 rc |= alg_test_descs[i].test(alg_test_descs + i, driver,
4173 if (j >= 0 && j != i)
4174 rc |= alg_test_descs[j].test(alg_test_descs + j, driver,
4178 if (fips_enabled && rc)
4179 panic("%s: %s alg self test failed in fips mode!\n", driver, alg);
4181 if (fips_enabled && !rc)
4182 pr_info("alg: self-tests for %s (%s) passed\n", driver, alg);
4187 printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
4193 #endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */
4195 EXPORT_SYMBOL_GPL(alg_test);