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 aead_test_suite
{
81 const struct aead_testvec
*vecs
;
86 struct cipher_test_suite
{
88 const struct cipher_testvec
*vecs
;
93 struct comp_test_suite
{
95 const struct comp_testvec
*vecs
;
100 struct hash_test_suite
{
101 const struct hash_testvec
*vecs
;
105 struct cprng_test_suite
{
106 const struct cprng_testvec
*vecs
;
110 struct drbg_test_suite
{
111 const struct drbg_testvec
*vecs
;
115 struct akcipher_test_suite
{
116 const struct akcipher_testvec
*vecs
;
120 struct kpp_test_suite
{
121 const struct kpp_testvec
*vecs
;
125 struct alg_test_desc
{
127 int (*test
)(const struct alg_test_desc
*desc
, const char *driver
,
129 int fips_allowed
; /* set if alg is allowed in fips mode */
132 struct aead_test_suite aead
;
133 struct cipher_test_suite cipher
;
134 struct comp_test_suite comp
;
135 struct hash_test_suite hash
;
136 struct cprng_test_suite cprng
;
137 struct drbg_test_suite drbg
;
138 struct akcipher_test_suite akcipher
;
139 struct kpp_test_suite kpp
;
143 static const unsigned int IDX
[8] = {
144 IDX1
, IDX2
, IDX3
, IDX4
, IDX5
, IDX6
, IDX7
, IDX8
};
146 static void hexdump(unsigned char *buf
, unsigned int len
)
148 print_hex_dump(KERN_CONT
, "", DUMP_PREFIX_OFFSET
,
153 static int testmgr_alloc_buf(char *buf
[XBUFSIZE
])
157 for (i
= 0; i
< XBUFSIZE
; i
++) {
158 buf
[i
] = (void *)__get_free_page(GFP_KERNEL
);
167 free_page((unsigned long)buf
[i
]);
172 static void testmgr_free_buf(char *buf
[XBUFSIZE
])
176 for (i
= 0; i
< XBUFSIZE
; i
++)
177 free_page((unsigned long)buf
[i
]);
180 static int ahash_partial_update(struct ahash_request
**preq
,
181 struct crypto_ahash
*tfm
, const struct hash_testvec
*template,
182 void *hash_buff
, int k
, int temp
, struct scatterlist
*sg
,
183 const char *algo
, char *result
, struct crypto_wait
*wait
)
186 struct ahash_request
*req
;
187 int statesize
, ret
= -EINVAL
;
188 const char guard
[] = { 0x00, 0xba, 0xad, 0x00 };
191 statesize
= crypto_ahash_statesize(
192 crypto_ahash_reqtfm(req
));
193 state
= kmalloc(statesize
+ sizeof(guard
), GFP_KERNEL
);
195 pr_err("alg: hash: Failed to alloc state for %s\n", algo
);
198 memcpy(state
+ statesize
, guard
, sizeof(guard
));
199 ret
= crypto_ahash_export(req
, state
);
200 WARN_ON(memcmp(state
+ statesize
, guard
, sizeof(guard
)));
202 pr_err("alg: hash: Failed to export() for %s\n", algo
);
205 ahash_request_free(req
);
206 req
= ahash_request_alloc(tfm
, GFP_KERNEL
);
208 pr_err("alg: hash: Failed to alloc request for %s\n", algo
);
211 ahash_request_set_callback(req
,
212 CRYPTO_TFM_REQ_MAY_BACKLOG
,
213 crypto_req_done
, wait
);
215 memcpy(hash_buff
, template->plaintext
+ temp
,
217 sg_init_one(&sg
[0], hash_buff
, template->tap
[k
]);
218 ahash_request_set_crypt(req
, sg
, result
, template->tap
[k
]);
219 ret
= crypto_ahash_import(req
, state
);
221 pr_err("alg: hash: Failed to import() for %s\n", algo
);
224 ret
= crypto_wait_req(crypto_ahash_update(req
), wait
);
231 ahash_request_free(req
);
238 static int __test_hash(struct crypto_ahash
*tfm
,
239 const struct hash_testvec
*template, unsigned int tcount
,
240 bool use_digest
, const int align_offset
)
242 const char *algo
= crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm
));
243 size_t digest_size
= crypto_ahash_digestsize(tfm
);
244 unsigned int i
, j
, k
, temp
;
245 struct scatterlist sg
[8];
248 struct ahash_request
*req
;
249 struct crypto_wait wait
;
251 char *xbuf
[XBUFSIZE
];
254 result
= kmalloc(digest_size
, GFP_KERNEL
);
257 key
= kmalloc(MAX_KEYLEN
, GFP_KERNEL
);
260 if (testmgr_alloc_buf(xbuf
))
263 crypto_init_wait(&wait
);
265 req
= ahash_request_alloc(tfm
, GFP_KERNEL
);
267 printk(KERN_ERR
"alg: hash: Failed to allocate request for "
271 ahash_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
272 crypto_req_done
, &wait
);
275 for (i
= 0; i
< tcount
; i
++) {
280 if (WARN_ON(align_offset
+ template[i
].psize
> PAGE_SIZE
))
284 memset(result
, 0, digest_size
);
287 hash_buff
+= align_offset
;
289 memcpy(hash_buff
, template[i
].plaintext
, template[i
].psize
);
290 sg_init_one(&sg
[0], hash_buff
, template[i
].psize
);
292 if (template[i
].ksize
) {
293 crypto_ahash_clear_flags(tfm
, ~0);
294 if (template[i
].ksize
> MAX_KEYLEN
) {
295 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
296 j
, algo
, template[i
].ksize
, MAX_KEYLEN
);
300 memcpy(key
, template[i
].key
, template[i
].ksize
);
301 ret
= crypto_ahash_setkey(tfm
, key
, template[i
].ksize
);
303 printk(KERN_ERR
"alg: hash: setkey failed on "
304 "test %d for %s: ret=%d\n", j
, algo
,
310 ahash_request_set_crypt(req
, sg
, result
, template[i
].psize
);
312 ret
= crypto_wait_req(crypto_ahash_digest(req
), &wait
);
314 pr_err("alg: hash: digest failed on test %d "
315 "for %s: ret=%d\n", j
, algo
, -ret
);
319 ret
= crypto_wait_req(crypto_ahash_init(req
), &wait
);
321 pr_err("alg: hash: init failed on test %d "
322 "for %s: ret=%d\n", j
, algo
, -ret
);
325 ret
= crypto_wait_req(crypto_ahash_update(req
), &wait
);
327 pr_err("alg: hash: update failed on test %d "
328 "for %s: ret=%d\n", j
, algo
, -ret
);
331 ret
= crypto_wait_req(crypto_ahash_final(req
), &wait
);
333 pr_err("alg: hash: final failed on test %d "
334 "for %s: ret=%d\n", j
, algo
, -ret
);
339 if (memcmp(result
, template[i
].digest
,
340 crypto_ahash_digestsize(tfm
))) {
341 printk(KERN_ERR
"alg: hash: Test %d failed for %s\n",
343 hexdump(result
, crypto_ahash_digestsize(tfm
));
350 for (i
= 0; i
< tcount
; i
++) {
351 /* alignment tests are only done with continuous buffers */
352 if (align_offset
!= 0)
359 memset(result
, 0, digest_size
);
362 sg_init_table(sg
, template[i
].np
);
364 for (k
= 0; k
< template[i
].np
; k
++) {
365 if (WARN_ON(offset_in_page(IDX
[k
]) +
366 template[i
].tap
[k
] > PAGE_SIZE
))
369 memcpy(xbuf
[IDX
[k
] >> PAGE_SHIFT
] +
370 offset_in_page(IDX
[k
]),
371 template[i
].plaintext
+ temp
,
374 temp
+= template[i
].tap
[k
];
377 if (template[i
].ksize
) {
378 if (template[i
].ksize
> MAX_KEYLEN
) {
379 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
380 j
, algo
, template[i
].ksize
, MAX_KEYLEN
);
384 crypto_ahash_clear_flags(tfm
, ~0);
385 memcpy(key
, template[i
].key
, template[i
].ksize
);
386 ret
= crypto_ahash_setkey(tfm
, key
, template[i
].ksize
);
389 printk(KERN_ERR
"alg: hash: setkey "
390 "failed on chunking test %d "
391 "for %s: ret=%d\n", j
, algo
, -ret
);
396 ahash_request_set_crypt(req
, sg
, result
, template[i
].psize
);
397 ret
= crypto_wait_req(crypto_ahash_digest(req
), &wait
);
399 pr_err("alg: hash: digest failed on chunking test %d for %s: ret=%d\n",
404 if (memcmp(result
, template[i
].digest
,
405 crypto_ahash_digestsize(tfm
))) {
406 printk(KERN_ERR
"alg: hash: Chunking test %d "
407 "failed for %s\n", j
, algo
);
408 hexdump(result
, crypto_ahash_digestsize(tfm
));
414 /* partial update exercise */
416 for (i
= 0; i
< tcount
; i
++) {
417 /* alignment tests are only done with continuous buffers */
418 if (align_offset
!= 0)
421 if (template[i
].np
< 2)
425 memset(result
, 0, digest_size
);
429 memcpy(hash_buff
, template[i
].plaintext
,
431 sg_init_one(&sg
[0], hash_buff
, template[i
].tap
[0]);
433 if (template[i
].ksize
) {
434 crypto_ahash_clear_flags(tfm
, ~0);
435 if (template[i
].ksize
> MAX_KEYLEN
) {
436 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
437 j
, algo
, template[i
].ksize
, MAX_KEYLEN
);
441 memcpy(key
, template[i
].key
, template[i
].ksize
);
442 ret
= crypto_ahash_setkey(tfm
, key
, template[i
].ksize
);
444 pr_err("alg: hash: setkey failed on test %d for %s: ret=%d\n",
450 ahash_request_set_crypt(req
, sg
, result
, template[i
].tap
[0]);
451 ret
= crypto_wait_req(crypto_ahash_init(req
), &wait
);
453 pr_err("alg: hash: init failed on test %d for %s: ret=%d\n",
457 ret
= crypto_wait_req(crypto_ahash_update(req
), &wait
);
459 pr_err("alg: hash: update failed on test %d for %s: ret=%d\n",
464 temp
= template[i
].tap
[0];
465 for (k
= 1; k
< template[i
].np
; k
++) {
466 ret
= ahash_partial_update(&req
, tfm
, &template[i
],
467 hash_buff
, k
, temp
, &sg
[0], algo
, result
,
470 pr_err("alg: hash: partial update failed on test %d for %s: ret=%d\n",
474 temp
+= template[i
].tap
[k
];
476 ret
= crypto_wait_req(crypto_ahash_final(req
), &wait
);
478 pr_err("alg: hash: final failed on test %d for %s: ret=%d\n",
482 if (memcmp(result
, template[i
].digest
,
483 crypto_ahash_digestsize(tfm
))) {
484 pr_err("alg: hash: Partial Test %d failed for %s\n",
486 hexdump(result
, crypto_ahash_digestsize(tfm
));
495 ahash_request_free(req
);
497 testmgr_free_buf(xbuf
);
504 static int test_hash(struct crypto_ahash
*tfm
,
505 const struct hash_testvec
*template,
506 unsigned int tcount
, bool use_digest
)
508 unsigned int alignmask
;
511 ret
= __test_hash(tfm
, template, tcount
, use_digest
, 0);
515 /* test unaligned buffers, check with one byte offset */
516 ret
= __test_hash(tfm
, template, tcount
, use_digest
, 1);
520 alignmask
= crypto_tfm_alg_alignmask(&tfm
->base
);
522 /* Check if alignment mask for tfm is correctly set. */
523 ret
= __test_hash(tfm
, template, tcount
, use_digest
,
532 static int __test_aead(struct crypto_aead
*tfm
, int enc
,
533 const struct aead_testvec
*template, unsigned int tcount
,
534 const bool diff_dst
, const int align_offset
)
536 const char *algo
= crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm
));
537 unsigned int i
, j
, k
, n
, temp
;
541 struct aead_request
*req
;
542 struct scatterlist
*sg
;
543 struct scatterlist
*sgout
;
545 struct crypto_wait wait
;
546 unsigned int authsize
, iv_len
;
551 char *xbuf
[XBUFSIZE
];
552 char *xoutbuf
[XBUFSIZE
];
553 char *axbuf
[XBUFSIZE
];
555 iv
= kzalloc(MAX_IVLEN
, GFP_KERNEL
);
558 key
= kmalloc(MAX_KEYLEN
, GFP_KERNEL
);
561 if (testmgr_alloc_buf(xbuf
))
563 if (testmgr_alloc_buf(axbuf
))
565 if (diff_dst
&& testmgr_alloc_buf(xoutbuf
))
568 /* avoid "the frame size is larger than 1024 bytes" compiler warning */
569 sg
= kmalloc(sizeof(*sg
) * 8 * (diff_dst
? 4 : 2), GFP_KERNEL
);
584 crypto_init_wait(&wait
);
586 req
= aead_request_alloc(tfm
, GFP_KERNEL
);
588 pr_err("alg: aead%s: Failed to allocate request for %s\n",
593 aead_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
594 crypto_req_done
, &wait
);
596 iv_len
= crypto_aead_ivsize(tfm
);
598 for (i
= 0, j
= 0; i
< tcount
; i
++) {
604 /* some templates have no input data but they will
608 input
+= align_offset
;
612 if (WARN_ON(align_offset
+ template[i
].ilen
>
613 PAGE_SIZE
|| template[i
].alen
> PAGE_SIZE
))
616 memcpy(input
, template[i
].input
, template[i
].ilen
);
617 memcpy(assoc
, template[i
].assoc
, template[i
].alen
);
619 memcpy(iv
, template[i
].iv
, iv_len
);
621 memset(iv
, 0, iv_len
);
623 crypto_aead_clear_flags(tfm
, ~0);
625 crypto_aead_set_flags(tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
627 if (template[i
].klen
> MAX_KEYLEN
) {
628 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
629 d
, j
, algo
, template[i
].klen
,
634 memcpy(key
, template[i
].key
, template[i
].klen
);
636 ret
= crypto_aead_setkey(tfm
, key
, template[i
].klen
);
637 if (template[i
].fail
== !ret
) {
638 pr_err("alg: aead%s: setkey failed on test %d for %s: flags=%x\n",
639 d
, j
, algo
, crypto_aead_get_flags(tfm
));
644 authsize
= abs(template[i
].rlen
- template[i
].ilen
);
645 ret
= crypto_aead_setauthsize(tfm
, authsize
);
647 pr_err("alg: aead%s: Failed to set authsize to %u on test %d for %s\n",
648 d
, authsize
, j
, algo
);
652 k
= !!template[i
].alen
;
653 sg_init_table(sg
, k
+ 1);
654 sg_set_buf(&sg
[0], assoc
, template[i
].alen
);
655 sg_set_buf(&sg
[k
], input
,
656 template[i
].ilen
+ (enc
? authsize
: 0));
660 sg_init_table(sgout
, k
+ 1);
661 sg_set_buf(&sgout
[0], assoc
, template[i
].alen
);
664 output
+= align_offset
;
665 sg_set_buf(&sgout
[k
], output
,
666 template[i
].rlen
+ (enc
? 0 : authsize
));
669 aead_request_set_crypt(req
, sg
, (diff_dst
) ? sgout
: sg
,
670 template[i
].ilen
, iv
);
672 aead_request_set_ad(req
, template[i
].alen
);
674 ret
= crypto_wait_req(enc
? crypto_aead_encrypt(req
)
675 : crypto_aead_decrypt(req
), &wait
);
679 if (template[i
].novrfy
) {
680 /* verification was supposed to fail */
681 pr_err("alg: aead%s: %s failed on test %d for %s: ret was 0, expected -EBADMSG\n",
683 /* so really, we got a bad message */
689 if (template[i
].novrfy
)
690 /* verification failure was expected */
694 pr_err("alg: aead%s: %s failed on test %d for %s: ret=%d\n",
695 d
, e
, j
, algo
, -ret
);
700 if (memcmp(q
, template[i
].result
, template[i
].rlen
)) {
701 pr_err("alg: aead%s: Test %d failed on %s for %s\n",
703 hexdump(q
, template[i
].rlen
);
709 for (i
= 0, j
= 0; i
< tcount
; i
++) {
710 /* alignment tests are only done with continuous buffers */
711 if (align_offset
!= 0)
720 memcpy(iv
, template[i
].iv
, iv_len
);
722 memset(iv
, 0, MAX_IVLEN
);
724 crypto_aead_clear_flags(tfm
, ~0);
726 crypto_aead_set_flags(tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
727 if (template[i
].klen
> MAX_KEYLEN
) {
728 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
729 d
, j
, algo
, template[i
].klen
, MAX_KEYLEN
);
733 memcpy(key
, template[i
].key
, template[i
].klen
);
735 ret
= crypto_aead_setkey(tfm
, key
, template[i
].klen
);
736 if (template[i
].fail
== !ret
) {
737 pr_err("alg: aead%s: setkey failed on chunk test %d for %s: flags=%x\n",
738 d
, j
, algo
, crypto_aead_get_flags(tfm
));
743 authsize
= abs(template[i
].rlen
- template[i
].ilen
);
746 sg_init_table(sg
, template[i
].anp
+ template[i
].np
);
748 sg_init_table(sgout
, template[i
].anp
+ template[i
].np
);
751 for (k
= 0, temp
= 0; k
< template[i
].anp
; k
++) {
752 if (WARN_ON(offset_in_page(IDX
[k
]) +
753 template[i
].atap
[k
] > PAGE_SIZE
))
756 memcpy(axbuf
[IDX
[k
] >> PAGE_SHIFT
] +
757 offset_in_page(IDX
[k
]),
758 template[i
].assoc
+ temp
,
759 template[i
].atap
[k
]),
760 template[i
].atap
[k
]);
762 sg_set_buf(&sgout
[k
],
763 axbuf
[IDX
[k
] >> PAGE_SHIFT
] +
764 offset_in_page(IDX
[k
]),
765 template[i
].atap
[k
]);
766 temp
+= template[i
].atap
[k
];
769 for (k
= 0, temp
= 0; k
< template[i
].np
; k
++) {
770 if (WARN_ON(offset_in_page(IDX
[k
]) +
771 template[i
].tap
[k
] > PAGE_SIZE
))
774 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] + offset_in_page(IDX
[k
]);
775 memcpy(q
, template[i
].input
+ temp
, template[i
].tap
[k
]);
776 sg_set_buf(&sg
[template[i
].anp
+ k
],
777 q
, template[i
].tap
[k
]);
780 q
= xoutbuf
[IDX
[k
] >> PAGE_SHIFT
] +
781 offset_in_page(IDX
[k
]);
783 memset(q
, 0, template[i
].tap
[k
]);
785 sg_set_buf(&sgout
[template[i
].anp
+ k
],
786 q
, template[i
].tap
[k
]);
789 n
= template[i
].tap
[k
];
790 if (k
== template[i
].np
- 1 && enc
)
792 if (offset_in_page(q
) + n
< PAGE_SIZE
)
795 temp
+= template[i
].tap
[k
];
798 ret
= crypto_aead_setauthsize(tfm
, authsize
);
800 pr_err("alg: aead%s: Failed to set authsize to %u on chunk test %d for %s\n",
801 d
, authsize
, j
, algo
);
806 if (WARN_ON(sg
[template[i
].anp
+ k
- 1].offset
+
807 sg
[template[i
].anp
+ k
- 1].length
+
808 authsize
> PAGE_SIZE
)) {
814 sgout
[template[i
].anp
+ k
- 1].length
+=
816 sg
[template[i
].anp
+ k
- 1].length
+= authsize
;
819 aead_request_set_crypt(req
, sg
, (diff_dst
) ? sgout
: sg
,
823 aead_request_set_ad(req
, template[i
].alen
);
825 ret
= crypto_wait_req(enc
? crypto_aead_encrypt(req
)
826 : crypto_aead_decrypt(req
), &wait
);
830 if (template[i
].novrfy
) {
831 /* verification was supposed to fail */
832 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret was 0, expected -EBADMSG\n",
834 /* so really, we got a bad message */
840 if (template[i
].novrfy
)
841 /* verification failure was expected */
845 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret=%d\n",
846 d
, e
, j
, algo
, -ret
);
851 for (k
= 0, temp
= 0; k
< template[i
].np
; k
++) {
853 q
= xoutbuf
[IDX
[k
] >> PAGE_SHIFT
] +
854 offset_in_page(IDX
[k
]);
856 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] +
857 offset_in_page(IDX
[k
]);
859 n
= template[i
].tap
[k
];
860 if (k
== template[i
].np
- 1)
861 n
+= enc
? authsize
: -authsize
;
863 if (memcmp(q
, template[i
].result
+ temp
, n
)) {
864 pr_err("alg: aead%s: Chunk test %d failed on %s at page %u for %s\n",
871 if (k
== template[i
].np
- 1 && !enc
) {
873 memcmp(q
, template[i
].input
+
879 for (n
= 0; offset_in_page(q
+ n
) && q
[n
]; n
++)
883 pr_err("alg: aead%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
884 d
, j
, e
, k
, algo
, n
);
889 temp
+= template[i
].tap
[k
];
896 aead_request_free(req
);
900 testmgr_free_buf(xoutbuf
);
902 testmgr_free_buf(axbuf
);
904 testmgr_free_buf(xbuf
);
911 static int test_aead(struct crypto_aead
*tfm
, int enc
,
912 const struct aead_testvec
*template, unsigned int tcount
)
914 unsigned int alignmask
;
917 /* test 'dst == src' case */
918 ret
= __test_aead(tfm
, enc
, template, tcount
, false, 0);
922 /* test 'dst != src' case */
923 ret
= __test_aead(tfm
, enc
, template, tcount
, true, 0);
927 /* test unaligned buffers, check with one byte offset */
928 ret
= __test_aead(tfm
, enc
, template, tcount
, true, 1);
932 alignmask
= crypto_tfm_alg_alignmask(&tfm
->base
);
934 /* Check if alignment mask for tfm is correctly set. */
935 ret
= __test_aead(tfm
, enc
, template, tcount
, true,
944 static int test_cipher(struct crypto_cipher
*tfm
, int enc
,
945 const struct cipher_testvec
*template,
948 const char *algo
= crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm
));
949 unsigned int i
, j
, k
;
953 char *xbuf
[XBUFSIZE
];
956 if (testmgr_alloc_buf(xbuf
))
965 for (i
= 0; i
< tcount
; i
++) {
969 if (fips_enabled
&& template[i
].fips_skip
)
975 if (WARN_ON(template[i
].ilen
> PAGE_SIZE
))
979 memcpy(data
, template[i
].input
, template[i
].ilen
);
981 crypto_cipher_clear_flags(tfm
, ~0);
983 crypto_cipher_set_flags(tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
985 ret
= crypto_cipher_setkey(tfm
, template[i
].key
,
987 if (template[i
].fail
== !ret
) {
988 printk(KERN_ERR
"alg: cipher: setkey failed "
989 "on test %d for %s: flags=%x\n", j
,
990 algo
, crypto_cipher_get_flags(tfm
));
995 for (k
= 0; k
< template[i
].ilen
;
996 k
+= crypto_cipher_blocksize(tfm
)) {
998 crypto_cipher_encrypt_one(tfm
, data
+ k
,
1001 crypto_cipher_decrypt_one(tfm
, data
+ k
,
1006 if (memcmp(q
, template[i
].result
, template[i
].rlen
)) {
1007 printk(KERN_ERR
"alg: cipher: Test %d failed "
1008 "on %s for %s\n", j
, e
, algo
);
1009 hexdump(q
, template[i
].rlen
);
1018 testmgr_free_buf(xbuf
);
1023 static int __test_skcipher(struct crypto_skcipher
*tfm
, int enc
,
1024 const struct cipher_testvec
*template,
1025 unsigned int tcount
,
1026 const bool diff_dst
, const int align_offset
)
1029 crypto_tfm_alg_driver_name(crypto_skcipher_tfm(tfm
));
1030 unsigned int i
, j
, k
, n
, temp
;
1032 struct skcipher_request
*req
;
1033 struct scatterlist sg
[8];
1034 struct scatterlist sgout
[8];
1036 struct crypto_wait wait
;
1039 char *xbuf
[XBUFSIZE
];
1040 char *xoutbuf
[XBUFSIZE
];
1042 unsigned int ivsize
= crypto_skcipher_ivsize(tfm
);
1044 if (testmgr_alloc_buf(xbuf
))
1047 if (diff_dst
&& testmgr_alloc_buf(xoutbuf
))
1060 crypto_init_wait(&wait
);
1062 req
= skcipher_request_alloc(tfm
, GFP_KERNEL
);
1064 pr_err("alg: skcipher%s: Failed to allocate request for %s\n",
1069 skcipher_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
1070 crypto_req_done
, &wait
);
1073 for (i
= 0; i
< tcount
; i
++) {
1074 if (template[i
].np
&& !template[i
].also_non_np
)
1077 if (fips_enabled
&& template[i
].fips_skip
)
1081 memcpy(iv
, template[i
].iv
, ivsize
);
1083 memset(iv
, 0, MAX_IVLEN
);
1087 if (WARN_ON(align_offset
+ template[i
].ilen
> PAGE_SIZE
))
1091 data
+= align_offset
;
1092 memcpy(data
, template[i
].input
, template[i
].ilen
);
1094 crypto_skcipher_clear_flags(tfm
, ~0);
1096 crypto_skcipher_set_flags(tfm
,
1097 CRYPTO_TFM_REQ_WEAK_KEY
);
1099 ret
= crypto_skcipher_setkey(tfm
, template[i
].key
,
1101 if (template[i
].fail
== !ret
) {
1102 pr_err("alg: skcipher%s: setkey failed on test %d for %s: flags=%x\n",
1103 d
, j
, algo
, crypto_skcipher_get_flags(tfm
));
1108 sg_init_one(&sg
[0], data
, template[i
].ilen
);
1111 data
+= align_offset
;
1112 sg_init_one(&sgout
[0], data
, template[i
].ilen
);
1115 skcipher_request_set_crypt(req
, sg
, (diff_dst
) ? sgout
: sg
,
1116 template[i
].ilen
, iv
);
1117 ret
= crypto_wait_req(enc
? crypto_skcipher_encrypt(req
) :
1118 crypto_skcipher_decrypt(req
), &wait
);
1121 pr_err("alg: skcipher%s: %s failed on test %d for %s: ret=%d\n",
1122 d
, e
, j
, algo
, -ret
);
1127 if (memcmp(q
, template[i
].result
, template[i
].rlen
)) {
1128 pr_err("alg: skcipher%s: Test %d failed (invalid result) on %s for %s\n",
1130 hexdump(q
, template[i
].rlen
);
1135 if (template[i
].iv_out
&&
1136 memcmp(iv
, template[i
].iv_out
,
1137 crypto_skcipher_ivsize(tfm
))) {
1138 pr_err("alg: skcipher%s: Test %d failed (invalid output IV) on %s for %s\n",
1140 hexdump(iv
, crypto_skcipher_ivsize(tfm
));
1147 for (i
= 0; i
< tcount
; i
++) {
1148 /* alignment tests are only done with continuous buffers */
1149 if (align_offset
!= 0)
1152 if (!template[i
].np
)
1155 if (fips_enabled
&& template[i
].fips_skip
)
1159 memcpy(iv
, template[i
].iv
, ivsize
);
1161 memset(iv
, 0, MAX_IVLEN
);
1164 crypto_skcipher_clear_flags(tfm
, ~0);
1166 crypto_skcipher_set_flags(tfm
,
1167 CRYPTO_TFM_REQ_WEAK_KEY
);
1169 ret
= crypto_skcipher_setkey(tfm
, template[i
].key
,
1171 if (template[i
].fail
== !ret
) {
1172 pr_err("alg: skcipher%s: setkey failed on chunk test %d for %s: flags=%x\n",
1173 d
, j
, algo
, crypto_skcipher_get_flags(tfm
));
1180 sg_init_table(sg
, template[i
].np
);
1182 sg_init_table(sgout
, template[i
].np
);
1183 for (k
= 0; k
< template[i
].np
; k
++) {
1184 if (WARN_ON(offset_in_page(IDX
[k
]) +
1185 template[i
].tap
[k
] > PAGE_SIZE
))
1188 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] + offset_in_page(IDX
[k
]);
1190 memcpy(q
, template[i
].input
+ temp
, template[i
].tap
[k
]);
1192 if (offset_in_page(q
) + template[i
].tap
[k
] < PAGE_SIZE
)
1193 q
[template[i
].tap
[k
]] = 0;
1195 sg_set_buf(&sg
[k
], q
, template[i
].tap
[k
]);
1197 q
= xoutbuf
[IDX
[k
] >> PAGE_SHIFT
] +
1198 offset_in_page(IDX
[k
]);
1200 sg_set_buf(&sgout
[k
], q
, template[i
].tap
[k
]);
1202 memset(q
, 0, template[i
].tap
[k
]);
1203 if (offset_in_page(q
) +
1204 template[i
].tap
[k
] < PAGE_SIZE
)
1205 q
[template[i
].tap
[k
]] = 0;
1208 temp
+= template[i
].tap
[k
];
1211 skcipher_request_set_crypt(req
, sg
, (diff_dst
) ? sgout
: sg
,
1212 template[i
].ilen
, iv
);
1214 ret
= crypto_wait_req(enc
? crypto_skcipher_encrypt(req
) :
1215 crypto_skcipher_decrypt(req
), &wait
);
1218 pr_err("alg: skcipher%s: %s failed on chunk test %d for %s: ret=%d\n",
1219 d
, e
, j
, algo
, -ret
);
1225 for (k
= 0; k
< template[i
].np
; k
++) {
1227 q
= xoutbuf
[IDX
[k
] >> PAGE_SHIFT
] +
1228 offset_in_page(IDX
[k
]);
1230 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] +
1231 offset_in_page(IDX
[k
]);
1233 if (memcmp(q
, template[i
].result
+ temp
,
1234 template[i
].tap
[k
])) {
1235 pr_err("alg: skcipher%s: Chunk test %d failed on %s at page %u for %s\n",
1237 hexdump(q
, template[i
].tap
[k
]);
1241 q
+= template[i
].tap
[k
];
1242 for (n
= 0; offset_in_page(q
+ n
) && q
[n
]; n
++)
1245 pr_err("alg: skcipher%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
1246 d
, j
, e
, k
, algo
, n
);
1250 temp
+= template[i
].tap
[k
];
1257 skcipher_request_free(req
);
1259 testmgr_free_buf(xoutbuf
);
1261 testmgr_free_buf(xbuf
);
1266 static int test_skcipher(struct crypto_skcipher
*tfm
, int enc
,
1267 const struct cipher_testvec
*template,
1268 unsigned int tcount
)
1270 unsigned int alignmask
;
1273 /* test 'dst == src' case */
1274 ret
= __test_skcipher(tfm
, enc
, template, tcount
, false, 0);
1278 /* test 'dst != src' case */
1279 ret
= __test_skcipher(tfm
, enc
, template, tcount
, true, 0);
1283 /* test unaligned buffers, check with one byte offset */
1284 ret
= __test_skcipher(tfm
, enc
, template, tcount
, true, 1);
1288 alignmask
= crypto_tfm_alg_alignmask(&tfm
->base
);
1290 /* Check if alignment mask for tfm is correctly set. */
1291 ret
= __test_skcipher(tfm
, enc
, template, tcount
, true,
1300 static int test_comp(struct crypto_comp
*tfm
,
1301 const struct comp_testvec
*ctemplate
,
1302 const struct comp_testvec
*dtemplate
,
1303 int ctcount
, int dtcount
)
1305 const char *algo
= crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm
));
1307 char result
[COMP_BUF_SIZE
];
1310 for (i
= 0; i
< ctcount
; i
++) {
1312 unsigned int dlen
= COMP_BUF_SIZE
;
1314 memset(result
, 0, sizeof (result
));
1316 ilen
= ctemplate
[i
].inlen
;
1317 ret
= crypto_comp_compress(tfm
, ctemplate
[i
].input
,
1318 ilen
, result
, &dlen
);
1320 printk(KERN_ERR
"alg: comp: compression failed "
1321 "on test %d for %s: ret=%d\n", i
+ 1, algo
,
1326 if (dlen
!= ctemplate
[i
].outlen
) {
1327 printk(KERN_ERR
"alg: comp: Compression test %d "
1328 "failed for %s: output len = %d\n", i
+ 1, algo
,
1334 if (memcmp(result
, ctemplate
[i
].output
, dlen
)) {
1335 printk(KERN_ERR
"alg: comp: Compression test %d "
1336 "failed for %s\n", i
+ 1, algo
);
1337 hexdump(result
, dlen
);
1343 for (i
= 0; i
< dtcount
; i
++) {
1345 unsigned int dlen
= COMP_BUF_SIZE
;
1347 memset(result
, 0, sizeof (result
));
1349 ilen
= dtemplate
[i
].inlen
;
1350 ret
= crypto_comp_decompress(tfm
, dtemplate
[i
].input
,
1351 ilen
, result
, &dlen
);
1353 printk(KERN_ERR
"alg: comp: decompression failed "
1354 "on test %d for %s: ret=%d\n", i
+ 1, algo
,
1359 if (dlen
!= dtemplate
[i
].outlen
) {
1360 printk(KERN_ERR
"alg: comp: Decompression test %d "
1361 "failed for %s: output len = %d\n", i
+ 1, algo
,
1367 if (memcmp(result
, dtemplate
[i
].output
, dlen
)) {
1368 printk(KERN_ERR
"alg: comp: Decompression test %d "
1369 "failed for %s\n", i
+ 1, algo
);
1370 hexdump(result
, dlen
);
1382 static int test_acomp(struct crypto_acomp
*tfm
,
1383 const struct comp_testvec
*ctemplate
,
1384 const struct comp_testvec
*dtemplate
,
1385 int ctcount
, int dtcount
)
1387 const char *algo
= crypto_tfm_alg_driver_name(crypto_acomp_tfm(tfm
));
1389 char *output
, *decomp_out
;
1391 struct scatterlist src
, dst
;
1392 struct acomp_req
*req
;
1393 struct crypto_wait wait
;
1395 output
= kmalloc(COMP_BUF_SIZE
, GFP_KERNEL
);
1399 decomp_out
= kmalloc(COMP_BUF_SIZE
, GFP_KERNEL
);
1405 for (i
= 0; i
< ctcount
; i
++) {
1406 unsigned int dlen
= COMP_BUF_SIZE
;
1407 int ilen
= ctemplate
[i
].inlen
;
1410 input_vec
= kmemdup(ctemplate
[i
].input
, ilen
, GFP_KERNEL
);
1416 memset(output
, 0, dlen
);
1417 crypto_init_wait(&wait
);
1418 sg_init_one(&src
, input_vec
, ilen
);
1419 sg_init_one(&dst
, output
, dlen
);
1421 req
= acomp_request_alloc(tfm
);
1423 pr_err("alg: acomp: request alloc failed for %s\n",
1430 acomp_request_set_params(req
, &src
, &dst
, ilen
, dlen
);
1431 acomp_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
1432 crypto_req_done
, &wait
);
1434 ret
= crypto_wait_req(crypto_acomp_compress(req
), &wait
);
1436 pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n",
1439 acomp_request_free(req
);
1444 dlen
= COMP_BUF_SIZE
;
1445 sg_init_one(&src
, output
, ilen
);
1446 sg_init_one(&dst
, decomp_out
, dlen
);
1447 crypto_init_wait(&wait
);
1448 acomp_request_set_params(req
, &src
, &dst
, ilen
, dlen
);
1450 ret
= crypto_wait_req(crypto_acomp_decompress(req
), &wait
);
1452 pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n",
1455 acomp_request_free(req
);
1459 if (req
->dlen
!= ctemplate
[i
].inlen
) {
1460 pr_err("alg: acomp: Compression test %d failed for %s: output len = %d\n",
1461 i
+ 1, algo
, req
->dlen
);
1464 acomp_request_free(req
);
1468 if (memcmp(input_vec
, decomp_out
, req
->dlen
)) {
1469 pr_err("alg: acomp: Compression test %d failed for %s\n",
1471 hexdump(output
, req
->dlen
);
1474 acomp_request_free(req
);
1479 acomp_request_free(req
);
1482 for (i
= 0; i
< dtcount
; i
++) {
1483 unsigned int dlen
= COMP_BUF_SIZE
;
1484 int ilen
= dtemplate
[i
].inlen
;
1487 input_vec
= kmemdup(dtemplate
[i
].input
, ilen
, GFP_KERNEL
);
1493 memset(output
, 0, dlen
);
1494 crypto_init_wait(&wait
);
1495 sg_init_one(&src
, input_vec
, ilen
);
1496 sg_init_one(&dst
, output
, dlen
);
1498 req
= acomp_request_alloc(tfm
);
1500 pr_err("alg: acomp: request alloc failed for %s\n",
1507 acomp_request_set_params(req
, &src
, &dst
, ilen
, dlen
);
1508 acomp_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
1509 crypto_req_done
, &wait
);
1511 ret
= crypto_wait_req(crypto_acomp_decompress(req
), &wait
);
1513 pr_err("alg: acomp: decompression failed on test %d for %s: ret=%d\n",
1516 acomp_request_free(req
);
1520 if (req
->dlen
!= dtemplate
[i
].outlen
) {
1521 pr_err("alg: acomp: Decompression test %d failed for %s: output len = %d\n",
1522 i
+ 1, algo
, req
->dlen
);
1525 acomp_request_free(req
);
1529 if (memcmp(output
, dtemplate
[i
].output
, req
->dlen
)) {
1530 pr_err("alg: acomp: Decompression test %d failed for %s\n",
1532 hexdump(output
, req
->dlen
);
1535 acomp_request_free(req
);
1540 acomp_request_free(req
);
1551 static int test_cprng(struct crypto_rng
*tfm
,
1552 const struct cprng_testvec
*template,
1553 unsigned int tcount
)
1555 const char *algo
= crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm
));
1556 int err
= 0, i
, j
, seedsize
;
1560 seedsize
= crypto_rng_seedsize(tfm
);
1562 seed
= kmalloc(seedsize
, GFP_KERNEL
);
1564 printk(KERN_ERR
"alg: cprng: Failed to allocate seed space "
1569 for (i
= 0; i
< tcount
; i
++) {
1570 memset(result
, 0, 32);
1572 memcpy(seed
, template[i
].v
, template[i
].vlen
);
1573 memcpy(seed
+ template[i
].vlen
, template[i
].key
,
1575 memcpy(seed
+ template[i
].vlen
+ template[i
].klen
,
1576 template[i
].dt
, template[i
].dtlen
);
1578 err
= crypto_rng_reset(tfm
, seed
, seedsize
);
1580 printk(KERN_ERR
"alg: cprng: Failed to reset rng "
1585 for (j
= 0; j
< template[i
].loops
; j
++) {
1586 err
= crypto_rng_get_bytes(tfm
, result
,
1589 printk(KERN_ERR
"alg: cprng: Failed to obtain "
1590 "the correct amount of random data for "
1591 "%s (requested %d)\n", algo
,
1597 err
= memcmp(result
, template[i
].result
,
1600 printk(KERN_ERR
"alg: cprng: Test %d failed for %s\n",
1602 hexdump(result
, template[i
].rlen
);
1613 static int alg_test_aead(const struct alg_test_desc
*desc
, const char *driver
,
1616 struct crypto_aead
*tfm
;
1619 tfm
= crypto_alloc_aead(driver
, type
, mask
);
1621 printk(KERN_ERR
"alg: aead: Failed to load transform for %s: "
1622 "%ld\n", driver
, PTR_ERR(tfm
));
1623 return PTR_ERR(tfm
);
1626 if (desc
->suite
.aead
.enc
.vecs
) {
1627 err
= test_aead(tfm
, ENCRYPT
, desc
->suite
.aead
.enc
.vecs
,
1628 desc
->suite
.aead
.enc
.count
);
1633 if (!err
&& desc
->suite
.aead
.dec
.vecs
)
1634 err
= test_aead(tfm
, DECRYPT
, desc
->suite
.aead
.dec
.vecs
,
1635 desc
->suite
.aead
.dec
.count
);
1638 crypto_free_aead(tfm
);
1642 static int alg_test_cipher(const struct alg_test_desc
*desc
,
1643 const char *driver
, u32 type
, u32 mask
)
1645 struct crypto_cipher
*tfm
;
1648 tfm
= crypto_alloc_cipher(driver
, type
, mask
);
1650 printk(KERN_ERR
"alg: cipher: Failed to load transform for "
1651 "%s: %ld\n", driver
, PTR_ERR(tfm
));
1652 return PTR_ERR(tfm
);
1655 if (desc
->suite
.cipher
.enc
.vecs
) {
1656 err
= test_cipher(tfm
, ENCRYPT
, desc
->suite
.cipher
.enc
.vecs
,
1657 desc
->suite
.cipher
.enc
.count
);
1662 if (desc
->suite
.cipher
.dec
.vecs
)
1663 err
= test_cipher(tfm
, DECRYPT
, desc
->suite
.cipher
.dec
.vecs
,
1664 desc
->suite
.cipher
.dec
.count
);
1667 crypto_free_cipher(tfm
);
1671 static int alg_test_skcipher(const struct alg_test_desc
*desc
,
1672 const char *driver
, u32 type
, u32 mask
)
1674 struct crypto_skcipher
*tfm
;
1677 tfm
= crypto_alloc_skcipher(driver
, type
, mask
);
1679 printk(KERN_ERR
"alg: skcipher: Failed to load transform for "
1680 "%s: %ld\n", driver
, PTR_ERR(tfm
));
1681 return PTR_ERR(tfm
);
1684 if (desc
->suite
.cipher
.enc
.vecs
) {
1685 err
= test_skcipher(tfm
, ENCRYPT
, desc
->suite
.cipher
.enc
.vecs
,
1686 desc
->suite
.cipher
.enc
.count
);
1691 if (desc
->suite
.cipher
.dec
.vecs
)
1692 err
= test_skcipher(tfm
, DECRYPT
, desc
->suite
.cipher
.dec
.vecs
,
1693 desc
->suite
.cipher
.dec
.count
);
1696 crypto_free_skcipher(tfm
);
1700 static int alg_test_comp(const struct alg_test_desc
*desc
, const char *driver
,
1703 struct crypto_comp
*comp
;
1704 struct crypto_acomp
*acomp
;
1706 u32 algo_type
= type
& CRYPTO_ALG_TYPE_ACOMPRESS_MASK
;
1708 if (algo_type
== CRYPTO_ALG_TYPE_ACOMPRESS
) {
1709 acomp
= crypto_alloc_acomp(driver
, type
, mask
);
1710 if (IS_ERR(acomp
)) {
1711 pr_err("alg: acomp: Failed to load transform for %s: %ld\n",
1712 driver
, PTR_ERR(acomp
));
1713 return PTR_ERR(acomp
);
1715 err
= test_acomp(acomp
, desc
->suite
.comp
.comp
.vecs
,
1716 desc
->suite
.comp
.decomp
.vecs
,
1717 desc
->suite
.comp
.comp
.count
,
1718 desc
->suite
.comp
.decomp
.count
);
1719 crypto_free_acomp(acomp
);
1721 comp
= crypto_alloc_comp(driver
, type
, mask
);
1723 pr_err("alg: comp: Failed to load transform for %s: %ld\n",
1724 driver
, PTR_ERR(comp
));
1725 return PTR_ERR(comp
);
1728 err
= test_comp(comp
, desc
->suite
.comp
.comp
.vecs
,
1729 desc
->suite
.comp
.decomp
.vecs
,
1730 desc
->suite
.comp
.comp
.count
,
1731 desc
->suite
.comp
.decomp
.count
);
1733 crypto_free_comp(comp
);
1738 static int alg_test_hash(const struct alg_test_desc
*desc
, const char *driver
,
1741 struct crypto_ahash
*tfm
;
1744 tfm
= crypto_alloc_ahash(driver
, type
, mask
);
1746 printk(KERN_ERR
"alg: hash: Failed to load transform for %s: "
1747 "%ld\n", driver
, PTR_ERR(tfm
));
1748 return PTR_ERR(tfm
);
1751 err
= test_hash(tfm
, desc
->suite
.hash
.vecs
,
1752 desc
->suite
.hash
.count
, true);
1754 err
= test_hash(tfm
, desc
->suite
.hash
.vecs
,
1755 desc
->suite
.hash
.count
, false);
1757 crypto_free_ahash(tfm
);
1761 static int alg_test_crc32c(const struct alg_test_desc
*desc
,
1762 const char *driver
, u32 type
, u32 mask
)
1764 struct crypto_shash
*tfm
;
1768 err
= alg_test_hash(desc
, driver
, type
, mask
);
1772 tfm
= crypto_alloc_shash(driver
, type
, mask
);
1774 if (PTR_ERR(tfm
) == -ENOENT
) {
1776 * This crc32c implementation is only available through
1777 * ahash API, not the shash API, so the remaining part
1778 * of the test is not applicable to it.
1782 printk(KERN_ERR
"alg: crc32c: Failed to load transform for %s: "
1783 "%ld\n", driver
, PTR_ERR(tfm
));
1784 return PTR_ERR(tfm
);
1788 SHASH_DESC_ON_STACK(shash
, tfm
);
1789 u32
*ctx
= (u32
*)shash_desc_ctx(shash
);
1794 *ctx
= le32_to_cpu(420553207);
1795 err
= crypto_shash_final(shash
, (u8
*)&val
);
1797 printk(KERN_ERR
"alg: crc32c: Operation failed for "
1798 "%s: %d\n", driver
, err
);
1802 if (val
!= ~420553207) {
1803 printk(KERN_ERR
"alg: crc32c: Test failed for %s: "
1804 "%d\n", driver
, val
);
1809 crypto_free_shash(tfm
);
1814 static int alg_test_cprng(const struct alg_test_desc
*desc
, const char *driver
,
1817 struct crypto_rng
*rng
;
1820 rng
= crypto_alloc_rng(driver
, type
, mask
);
1822 printk(KERN_ERR
"alg: cprng: Failed to load transform for %s: "
1823 "%ld\n", driver
, PTR_ERR(rng
));
1824 return PTR_ERR(rng
);
1827 err
= test_cprng(rng
, desc
->suite
.cprng
.vecs
, desc
->suite
.cprng
.count
);
1829 crypto_free_rng(rng
);
1835 static int drbg_cavs_test(const struct drbg_testvec
*test
, int pr
,
1836 const char *driver
, u32 type
, u32 mask
)
1839 struct crypto_rng
*drng
;
1840 struct drbg_test_data test_data
;
1841 struct drbg_string addtl
, pers
, testentropy
;
1842 unsigned char *buf
= kzalloc(test
->expectedlen
, GFP_KERNEL
);
1847 drng
= crypto_alloc_rng(driver
, type
, mask
);
1849 printk(KERN_ERR
"alg: drbg: could not allocate DRNG handle for "
1855 test_data
.testentropy
= &testentropy
;
1856 drbg_string_fill(&testentropy
, test
->entropy
, test
->entropylen
);
1857 drbg_string_fill(&pers
, test
->pers
, test
->perslen
);
1858 ret
= crypto_drbg_reset_test(drng
, &pers
, &test_data
);
1860 printk(KERN_ERR
"alg: drbg: Failed to reset rng\n");
1864 drbg_string_fill(&addtl
, test
->addtla
, test
->addtllen
);
1866 drbg_string_fill(&testentropy
, test
->entpra
, test
->entprlen
);
1867 ret
= crypto_drbg_get_bytes_addtl_test(drng
,
1868 buf
, test
->expectedlen
, &addtl
, &test_data
);
1870 ret
= crypto_drbg_get_bytes_addtl(drng
,
1871 buf
, test
->expectedlen
, &addtl
);
1874 printk(KERN_ERR
"alg: drbg: could not obtain random data for "
1875 "driver %s\n", driver
);
1879 drbg_string_fill(&addtl
, test
->addtlb
, test
->addtllen
);
1881 drbg_string_fill(&testentropy
, test
->entprb
, test
->entprlen
);
1882 ret
= crypto_drbg_get_bytes_addtl_test(drng
,
1883 buf
, test
->expectedlen
, &addtl
, &test_data
);
1885 ret
= crypto_drbg_get_bytes_addtl(drng
,
1886 buf
, test
->expectedlen
, &addtl
);
1889 printk(KERN_ERR
"alg: drbg: could not obtain random data for "
1890 "driver %s\n", driver
);
1894 ret
= memcmp(test
->expected
, buf
, test
->expectedlen
);
1897 crypto_free_rng(drng
);
1903 static int alg_test_drbg(const struct alg_test_desc
*desc
, const char *driver
,
1909 const struct drbg_testvec
*template = desc
->suite
.drbg
.vecs
;
1910 unsigned int tcount
= desc
->suite
.drbg
.count
;
1912 if (0 == memcmp(driver
, "drbg_pr_", 8))
1915 for (i
= 0; i
< tcount
; i
++) {
1916 err
= drbg_cavs_test(&template[i
], pr
, driver
, type
, mask
);
1918 printk(KERN_ERR
"alg: drbg: Test %d failed for %s\n",
1928 static int do_test_kpp(struct crypto_kpp
*tfm
, const struct kpp_testvec
*vec
,
1931 struct kpp_request
*req
;
1932 void *input_buf
= NULL
;
1933 void *output_buf
= NULL
;
1934 void *a_public
= NULL
;
1936 void *shared_secret
= NULL
;
1937 struct crypto_wait wait
;
1938 unsigned int out_len_max
;
1940 struct scatterlist src
, dst
;
1942 req
= kpp_request_alloc(tfm
, GFP_KERNEL
);
1946 crypto_init_wait(&wait
);
1948 err
= crypto_kpp_set_secret(tfm
, vec
->secret
, vec
->secret_size
);
1952 out_len_max
= crypto_kpp_maxsize(tfm
);
1953 output_buf
= kzalloc(out_len_max
, GFP_KERNEL
);
1959 /* Use appropriate parameter as base */
1960 kpp_request_set_input(req
, NULL
, 0);
1961 sg_init_one(&dst
, output_buf
, out_len_max
);
1962 kpp_request_set_output(req
, &dst
, out_len_max
);
1963 kpp_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
1964 crypto_req_done
, &wait
);
1966 /* Compute party A's public key */
1967 err
= crypto_wait_req(crypto_kpp_generate_public_key(req
), &wait
);
1969 pr_err("alg: %s: Party A: generate public key test failed. err %d\n",
1975 /* Save party A's public key */
1976 a_public
= kzalloc(out_len_max
, GFP_KERNEL
);
1981 memcpy(a_public
, sg_virt(req
->dst
), out_len_max
);
1983 /* Verify calculated public key */
1984 if (memcmp(vec
->expected_a_public
, sg_virt(req
->dst
),
1985 vec
->expected_a_public_size
)) {
1986 pr_err("alg: %s: Party A: generate public key test failed. Invalid output\n",
1993 /* Calculate shared secret key by using counter part (b) public key. */
1994 input_buf
= kzalloc(vec
->b_public_size
, GFP_KERNEL
);
2000 memcpy(input_buf
, vec
->b_public
, vec
->b_public_size
);
2001 sg_init_one(&src
, input_buf
, vec
->b_public_size
);
2002 sg_init_one(&dst
, output_buf
, out_len_max
);
2003 kpp_request_set_input(req
, &src
, vec
->b_public_size
);
2004 kpp_request_set_output(req
, &dst
, out_len_max
);
2005 kpp_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
2006 crypto_req_done
, &wait
);
2007 err
= crypto_wait_req(crypto_kpp_compute_shared_secret(req
), &wait
);
2009 pr_err("alg: %s: Party A: compute shared secret test failed. err %d\n",
2015 /* Save the shared secret obtained by party A */
2016 a_ss
= kzalloc(vec
->expected_ss_size
, GFP_KERNEL
);
2021 memcpy(a_ss
, sg_virt(req
->dst
), vec
->expected_ss_size
);
2024 * Calculate party B's shared secret by using party A's
2027 err
= crypto_kpp_set_secret(tfm
, vec
->b_secret
,
2028 vec
->b_secret_size
);
2032 sg_init_one(&src
, a_public
, vec
->expected_a_public_size
);
2033 sg_init_one(&dst
, output_buf
, out_len_max
);
2034 kpp_request_set_input(req
, &src
, vec
->expected_a_public_size
);
2035 kpp_request_set_output(req
, &dst
, out_len_max
);
2036 kpp_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
2037 crypto_req_done
, &wait
);
2038 err
= crypto_wait_req(crypto_kpp_compute_shared_secret(req
),
2041 pr_err("alg: %s: Party B: compute shared secret failed. err %d\n",
2046 shared_secret
= a_ss
;
2048 shared_secret
= (void *)vec
->expected_ss
;
2052 * verify shared secret from which the user will derive
2053 * secret key by executing whatever hash it has chosen
2055 if (memcmp(shared_secret
, sg_virt(req
->dst
),
2056 vec
->expected_ss_size
)) {
2057 pr_err("alg: %s: compute shared secret test failed. Invalid output\n",
2069 kpp_request_free(req
);
2073 static int test_kpp(struct crypto_kpp
*tfm
, const char *alg
,
2074 const struct kpp_testvec
*vecs
, unsigned int tcount
)
2078 for (i
= 0; i
< tcount
; i
++) {
2079 ret
= do_test_kpp(tfm
, vecs
++, alg
);
2081 pr_err("alg: %s: test failed on vector %d, err=%d\n",
2089 static int alg_test_kpp(const struct alg_test_desc
*desc
, const char *driver
,
2092 struct crypto_kpp
*tfm
;
2095 tfm
= crypto_alloc_kpp(driver
, type
, mask
);
2097 pr_err("alg: kpp: Failed to load tfm for %s: %ld\n",
2098 driver
, PTR_ERR(tfm
));
2099 return PTR_ERR(tfm
);
2101 if (desc
->suite
.kpp
.vecs
)
2102 err
= test_kpp(tfm
, desc
->alg
, desc
->suite
.kpp
.vecs
,
2103 desc
->suite
.kpp
.count
);
2105 crypto_free_kpp(tfm
);
2109 static int test_akcipher_one(struct crypto_akcipher
*tfm
,
2110 const struct akcipher_testvec
*vecs
)
2112 char *xbuf
[XBUFSIZE
];
2113 struct akcipher_request
*req
;
2114 void *outbuf_enc
= NULL
;
2115 void *outbuf_dec
= NULL
;
2116 struct crypto_wait wait
;
2117 unsigned int out_len_max
, out_len
= 0;
2119 struct scatterlist src
, dst
, src_tab
[2];
2121 if (testmgr_alloc_buf(xbuf
))
2124 req
= akcipher_request_alloc(tfm
, GFP_KERNEL
);
2128 crypto_init_wait(&wait
);
2130 if (vecs
->public_key_vec
)
2131 err
= crypto_akcipher_set_pub_key(tfm
, vecs
->key
,
2134 err
= crypto_akcipher_set_priv_key(tfm
, vecs
->key
,
2140 out_len_max
= crypto_akcipher_maxsize(tfm
);
2141 outbuf_enc
= kzalloc(out_len_max
, GFP_KERNEL
);
2145 if (WARN_ON(vecs
->m_size
> PAGE_SIZE
))
2148 memcpy(xbuf
[0], vecs
->m
, vecs
->m_size
);
2150 sg_init_table(src_tab
, 2);
2151 sg_set_buf(&src_tab
[0], xbuf
[0], 8);
2152 sg_set_buf(&src_tab
[1], xbuf
[0] + 8, vecs
->m_size
- 8);
2153 sg_init_one(&dst
, outbuf_enc
, out_len_max
);
2154 akcipher_request_set_crypt(req
, src_tab
, &dst
, vecs
->m_size
,
2156 akcipher_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
2157 crypto_req_done
, &wait
);
2159 err
= crypto_wait_req(vecs
->siggen_sigver_test
?
2160 /* Run asymmetric signature generation */
2161 crypto_akcipher_sign(req
) :
2162 /* Run asymmetric encrypt */
2163 crypto_akcipher_encrypt(req
), &wait
);
2165 pr_err("alg: akcipher: encrypt test failed. err %d\n", err
);
2168 if (req
->dst_len
!= vecs
->c_size
) {
2169 pr_err("alg: akcipher: encrypt test failed. Invalid output len\n");
2173 /* verify that encrypted message is equal to expected */
2174 if (memcmp(vecs
->c
, outbuf_enc
, vecs
->c_size
)) {
2175 pr_err("alg: akcipher: encrypt test failed. Invalid output\n");
2176 hexdump(outbuf_enc
, vecs
->c_size
);
2180 /* Don't invoke decrypt for vectors with public key */
2181 if (vecs
->public_key_vec
) {
2185 outbuf_dec
= kzalloc(out_len_max
, GFP_KERNEL
);
2191 if (WARN_ON(vecs
->c_size
> PAGE_SIZE
))
2194 memcpy(xbuf
[0], vecs
->c
, vecs
->c_size
);
2196 sg_init_one(&src
, xbuf
[0], vecs
->c_size
);
2197 sg_init_one(&dst
, outbuf_dec
, out_len_max
);
2198 crypto_init_wait(&wait
);
2199 akcipher_request_set_crypt(req
, &src
, &dst
, vecs
->c_size
, out_len_max
);
2201 err
= crypto_wait_req(vecs
->siggen_sigver_test
?
2202 /* Run asymmetric signature verification */
2203 crypto_akcipher_verify(req
) :
2204 /* Run asymmetric decrypt */
2205 crypto_akcipher_decrypt(req
), &wait
);
2207 pr_err("alg: akcipher: decrypt test failed. err %d\n", err
);
2210 out_len
= req
->dst_len
;
2211 if (out_len
< vecs
->m_size
) {
2212 pr_err("alg: akcipher: decrypt test failed. "
2213 "Invalid output len %u\n", out_len
);
2217 /* verify that decrypted message is equal to the original msg */
2218 if (memchr_inv(outbuf_dec
, 0, out_len
- vecs
->m_size
) ||
2219 memcmp(vecs
->m
, outbuf_dec
+ out_len
- vecs
->m_size
,
2221 pr_err("alg: akcipher: decrypt test failed. Invalid output\n");
2222 hexdump(outbuf_dec
, out_len
);
2229 akcipher_request_free(req
);
2231 testmgr_free_buf(xbuf
);
2235 static int test_akcipher(struct crypto_akcipher
*tfm
, const char *alg
,
2236 const struct akcipher_testvec
*vecs
,
2237 unsigned int tcount
)
2240 crypto_tfm_alg_driver_name(crypto_akcipher_tfm(tfm
));
2243 for (i
= 0; i
< tcount
; i
++) {
2244 ret
= test_akcipher_one(tfm
, vecs
++);
2248 pr_err("alg: akcipher: test %d failed for %s, err=%d\n",
2255 static int alg_test_akcipher(const struct alg_test_desc
*desc
,
2256 const char *driver
, u32 type
, u32 mask
)
2258 struct crypto_akcipher
*tfm
;
2261 tfm
= crypto_alloc_akcipher(driver
, type
, mask
);
2263 pr_err("alg: akcipher: Failed to load tfm for %s: %ld\n",
2264 driver
, PTR_ERR(tfm
));
2265 return PTR_ERR(tfm
);
2267 if (desc
->suite
.akcipher
.vecs
)
2268 err
= test_akcipher(tfm
, desc
->alg
, desc
->suite
.akcipher
.vecs
,
2269 desc
->suite
.akcipher
.count
);
2271 crypto_free_akcipher(tfm
);
2275 static int alg_test_null(const struct alg_test_desc
*desc
,
2276 const char *driver
, u32 type
, u32 mask
)
2281 #define __VECS(tv) { .vecs = tv, .count = ARRAY_SIZE(tv) }
2283 /* Please keep this list sorted by algorithm name. */
2284 static const struct alg_test_desc alg_test_descs
[] = {
2286 .alg
= "ansi_cprng",
2287 .test
= alg_test_cprng
,
2289 .cprng
= __VECS(ansi_cprng_aes_tv_template
)
2292 .alg
= "authenc(hmac(md5),ecb(cipher_null))",
2293 .test
= alg_test_aead
,
2296 .enc
= __VECS(hmac_md5_ecb_cipher_null_enc_tv_template
),
2297 .dec
= __VECS(hmac_md5_ecb_cipher_null_dec_tv_template
)
2301 .alg
= "authenc(hmac(sha1),cbc(aes))",
2302 .test
= alg_test_aead
,
2306 .enc
= __VECS(hmac_sha1_aes_cbc_enc_tv_temp
)
2310 .alg
= "authenc(hmac(sha1),cbc(des))",
2311 .test
= alg_test_aead
,
2314 .enc
= __VECS(hmac_sha1_des_cbc_enc_tv_temp
)
2318 .alg
= "authenc(hmac(sha1),cbc(des3_ede))",
2319 .test
= alg_test_aead
,
2323 .enc
= __VECS(hmac_sha1_des3_ede_cbc_enc_tv_temp
)
2327 .alg
= "authenc(hmac(sha1),ctr(aes))",
2328 .test
= alg_test_null
,
2331 .alg
= "authenc(hmac(sha1),ecb(cipher_null))",
2332 .test
= alg_test_aead
,
2335 .enc
= __VECS(hmac_sha1_ecb_cipher_null_enc_tv_temp
),
2336 .dec
= __VECS(hmac_sha1_ecb_cipher_null_dec_tv_temp
)
2340 .alg
= "authenc(hmac(sha1),rfc3686(ctr(aes)))",
2341 .test
= alg_test_null
,
2344 .alg
= "authenc(hmac(sha224),cbc(des))",
2345 .test
= alg_test_aead
,
2348 .enc
= __VECS(hmac_sha224_des_cbc_enc_tv_temp
)
2352 .alg
= "authenc(hmac(sha224),cbc(des3_ede))",
2353 .test
= alg_test_aead
,
2357 .enc
= __VECS(hmac_sha224_des3_ede_cbc_enc_tv_temp
)
2361 .alg
= "authenc(hmac(sha256),cbc(aes))",
2362 .test
= alg_test_aead
,
2366 .enc
= __VECS(hmac_sha256_aes_cbc_enc_tv_temp
)
2370 .alg
= "authenc(hmac(sha256),cbc(des))",
2371 .test
= alg_test_aead
,
2374 .enc
= __VECS(hmac_sha256_des_cbc_enc_tv_temp
)
2378 .alg
= "authenc(hmac(sha256),cbc(des3_ede))",
2379 .test
= alg_test_aead
,
2383 .enc
= __VECS(hmac_sha256_des3_ede_cbc_enc_tv_temp
)
2387 .alg
= "authenc(hmac(sha256),ctr(aes))",
2388 .test
= alg_test_null
,
2391 .alg
= "authenc(hmac(sha256),rfc3686(ctr(aes)))",
2392 .test
= alg_test_null
,
2395 .alg
= "authenc(hmac(sha384),cbc(des))",
2396 .test
= alg_test_aead
,
2399 .enc
= __VECS(hmac_sha384_des_cbc_enc_tv_temp
)
2403 .alg
= "authenc(hmac(sha384),cbc(des3_ede))",
2404 .test
= alg_test_aead
,
2408 .enc
= __VECS(hmac_sha384_des3_ede_cbc_enc_tv_temp
)
2412 .alg
= "authenc(hmac(sha384),ctr(aes))",
2413 .test
= alg_test_null
,
2416 .alg
= "authenc(hmac(sha384),rfc3686(ctr(aes)))",
2417 .test
= alg_test_null
,
2420 .alg
= "authenc(hmac(sha512),cbc(aes))",
2422 .test
= alg_test_aead
,
2425 .enc
= __VECS(hmac_sha512_aes_cbc_enc_tv_temp
)
2429 .alg
= "authenc(hmac(sha512),cbc(des))",
2430 .test
= alg_test_aead
,
2433 .enc
= __VECS(hmac_sha512_des_cbc_enc_tv_temp
)
2437 .alg
= "authenc(hmac(sha512),cbc(des3_ede))",
2438 .test
= alg_test_aead
,
2442 .enc
= __VECS(hmac_sha512_des3_ede_cbc_enc_tv_temp
)
2446 .alg
= "authenc(hmac(sha512),ctr(aes))",
2447 .test
= alg_test_null
,
2450 .alg
= "authenc(hmac(sha512),rfc3686(ctr(aes)))",
2451 .test
= alg_test_null
,
2455 .test
= alg_test_skcipher
,
2459 .enc
= __VECS(aes_cbc_enc_tv_template
),
2460 .dec
= __VECS(aes_cbc_dec_tv_template
)
2464 .alg
= "cbc(anubis)",
2465 .test
= alg_test_skcipher
,
2468 .enc
= __VECS(anubis_cbc_enc_tv_template
),
2469 .dec
= __VECS(anubis_cbc_dec_tv_template
)
2473 .alg
= "cbc(blowfish)",
2474 .test
= alg_test_skcipher
,
2477 .enc
= __VECS(bf_cbc_enc_tv_template
),
2478 .dec
= __VECS(bf_cbc_dec_tv_template
)
2482 .alg
= "cbc(camellia)",
2483 .test
= alg_test_skcipher
,
2486 .enc
= __VECS(camellia_cbc_enc_tv_template
),
2487 .dec
= __VECS(camellia_cbc_dec_tv_template
)
2491 .alg
= "cbc(cast5)",
2492 .test
= alg_test_skcipher
,
2495 .enc
= __VECS(cast5_cbc_enc_tv_template
),
2496 .dec
= __VECS(cast5_cbc_dec_tv_template
)
2500 .alg
= "cbc(cast6)",
2501 .test
= alg_test_skcipher
,
2504 .enc
= __VECS(cast6_cbc_enc_tv_template
),
2505 .dec
= __VECS(cast6_cbc_dec_tv_template
)
2510 .test
= alg_test_skcipher
,
2513 .enc
= __VECS(des_cbc_enc_tv_template
),
2514 .dec
= __VECS(des_cbc_dec_tv_template
)
2518 .alg
= "cbc(des3_ede)",
2519 .test
= alg_test_skcipher
,
2523 .enc
= __VECS(des3_ede_cbc_enc_tv_template
),
2524 .dec
= __VECS(des3_ede_cbc_dec_tv_template
)
2528 .alg
= "cbc(serpent)",
2529 .test
= alg_test_skcipher
,
2532 .enc
= __VECS(serpent_cbc_enc_tv_template
),
2533 .dec
= __VECS(serpent_cbc_dec_tv_template
)
2537 .alg
= "cbc(twofish)",
2538 .test
= alg_test_skcipher
,
2541 .enc
= __VECS(tf_cbc_enc_tv_template
),
2542 .dec
= __VECS(tf_cbc_dec_tv_template
)
2546 .alg
= "cbcmac(aes)",
2548 .test
= alg_test_hash
,
2550 .hash
= __VECS(aes_cbcmac_tv_template
)
2554 .test
= alg_test_aead
,
2558 .enc
= __VECS(aes_ccm_enc_tv_template
),
2559 .dec
= __VECS(aes_ccm_dec_tv_template
)
2564 .test
= alg_test_skcipher
,
2567 .enc
= __VECS(chacha20_enc_tv_template
),
2568 .dec
= __VECS(chacha20_enc_tv_template
),
2574 .test
= alg_test_hash
,
2576 .hash
= __VECS(aes_cmac128_tv_template
)
2579 .alg
= "cmac(des3_ede)",
2581 .test
= alg_test_hash
,
2583 .hash
= __VECS(des3_ede_cmac64_tv_template
)
2586 .alg
= "compress_null",
2587 .test
= alg_test_null
,
2590 .test
= alg_test_hash
,
2592 .hash
= __VECS(crc32_tv_template
)
2596 .test
= alg_test_crc32c
,
2599 .hash
= __VECS(crc32c_tv_template
)
2603 .test
= alg_test_hash
,
2606 .hash
= __VECS(crct10dif_tv_template
)
2610 .test
= alg_test_skcipher
,
2614 .enc
= __VECS(aes_ctr_enc_tv_template
),
2615 .dec
= __VECS(aes_ctr_dec_tv_template
)
2619 .alg
= "ctr(blowfish)",
2620 .test
= alg_test_skcipher
,
2623 .enc
= __VECS(bf_ctr_enc_tv_template
),
2624 .dec
= __VECS(bf_ctr_dec_tv_template
)
2628 .alg
= "ctr(camellia)",
2629 .test
= alg_test_skcipher
,
2632 .enc
= __VECS(camellia_ctr_enc_tv_template
),
2633 .dec
= __VECS(camellia_ctr_dec_tv_template
)
2637 .alg
= "ctr(cast5)",
2638 .test
= alg_test_skcipher
,
2641 .enc
= __VECS(cast5_ctr_enc_tv_template
),
2642 .dec
= __VECS(cast5_ctr_dec_tv_template
)
2646 .alg
= "ctr(cast6)",
2647 .test
= alg_test_skcipher
,
2650 .enc
= __VECS(cast6_ctr_enc_tv_template
),
2651 .dec
= __VECS(cast6_ctr_dec_tv_template
)
2656 .test
= alg_test_skcipher
,
2659 .enc
= __VECS(des_ctr_enc_tv_template
),
2660 .dec
= __VECS(des_ctr_dec_tv_template
)
2664 .alg
= "ctr(des3_ede)",
2665 .test
= alg_test_skcipher
,
2669 .enc
= __VECS(des3_ede_ctr_enc_tv_template
),
2670 .dec
= __VECS(des3_ede_ctr_dec_tv_template
)
2674 .alg
= "ctr(serpent)",
2675 .test
= alg_test_skcipher
,
2678 .enc
= __VECS(serpent_ctr_enc_tv_template
),
2679 .dec
= __VECS(serpent_ctr_dec_tv_template
)
2683 .alg
= "ctr(twofish)",
2684 .test
= alg_test_skcipher
,
2687 .enc
= __VECS(tf_ctr_enc_tv_template
),
2688 .dec
= __VECS(tf_ctr_dec_tv_template
)
2692 .alg
= "cts(cbc(aes))",
2693 .test
= alg_test_skcipher
,
2696 .enc
= __VECS(cts_mode_enc_tv_template
),
2697 .dec
= __VECS(cts_mode_dec_tv_template
)
2702 .test
= alg_test_comp
,
2706 .comp
= __VECS(deflate_comp_tv_template
),
2707 .decomp
= __VECS(deflate_decomp_tv_template
)
2712 .test
= alg_test_kpp
,
2715 .kpp
= __VECS(dh_tv_template
)
2718 .alg
= "digest_null",
2719 .test
= alg_test_null
,
2721 .alg
= "drbg_nopr_ctr_aes128",
2722 .test
= alg_test_drbg
,
2725 .drbg
= __VECS(drbg_nopr_ctr_aes128_tv_template
)
2728 .alg
= "drbg_nopr_ctr_aes192",
2729 .test
= alg_test_drbg
,
2732 .drbg
= __VECS(drbg_nopr_ctr_aes192_tv_template
)
2735 .alg
= "drbg_nopr_ctr_aes256",
2736 .test
= alg_test_drbg
,
2739 .drbg
= __VECS(drbg_nopr_ctr_aes256_tv_template
)
2743 * There is no need to specifically test the DRBG with every
2744 * backend cipher -- covered by drbg_nopr_hmac_sha256 test
2746 .alg
= "drbg_nopr_hmac_sha1",
2748 .test
= alg_test_null
,
2750 .alg
= "drbg_nopr_hmac_sha256",
2751 .test
= alg_test_drbg
,
2754 .drbg
= __VECS(drbg_nopr_hmac_sha256_tv_template
)
2757 /* covered by drbg_nopr_hmac_sha256 test */
2758 .alg
= "drbg_nopr_hmac_sha384",
2760 .test
= alg_test_null
,
2762 .alg
= "drbg_nopr_hmac_sha512",
2763 .test
= alg_test_null
,
2766 .alg
= "drbg_nopr_sha1",
2768 .test
= alg_test_null
,
2770 .alg
= "drbg_nopr_sha256",
2771 .test
= alg_test_drbg
,
2774 .drbg
= __VECS(drbg_nopr_sha256_tv_template
)
2777 /* covered by drbg_nopr_sha256 test */
2778 .alg
= "drbg_nopr_sha384",
2780 .test
= alg_test_null
,
2782 .alg
= "drbg_nopr_sha512",
2784 .test
= alg_test_null
,
2786 .alg
= "drbg_pr_ctr_aes128",
2787 .test
= alg_test_drbg
,
2790 .drbg
= __VECS(drbg_pr_ctr_aes128_tv_template
)
2793 /* covered by drbg_pr_ctr_aes128 test */
2794 .alg
= "drbg_pr_ctr_aes192",
2796 .test
= alg_test_null
,
2798 .alg
= "drbg_pr_ctr_aes256",
2800 .test
= alg_test_null
,
2802 .alg
= "drbg_pr_hmac_sha1",
2804 .test
= alg_test_null
,
2806 .alg
= "drbg_pr_hmac_sha256",
2807 .test
= alg_test_drbg
,
2810 .drbg
= __VECS(drbg_pr_hmac_sha256_tv_template
)
2813 /* covered by drbg_pr_hmac_sha256 test */
2814 .alg
= "drbg_pr_hmac_sha384",
2816 .test
= alg_test_null
,
2818 .alg
= "drbg_pr_hmac_sha512",
2819 .test
= alg_test_null
,
2822 .alg
= "drbg_pr_sha1",
2824 .test
= alg_test_null
,
2826 .alg
= "drbg_pr_sha256",
2827 .test
= alg_test_drbg
,
2830 .drbg
= __VECS(drbg_pr_sha256_tv_template
)
2833 /* covered by drbg_pr_sha256 test */
2834 .alg
= "drbg_pr_sha384",
2836 .test
= alg_test_null
,
2838 .alg
= "drbg_pr_sha512",
2840 .test
= alg_test_null
,
2843 .test
= alg_test_skcipher
,
2847 .enc
= __VECS(aes_enc_tv_template
),
2848 .dec
= __VECS(aes_dec_tv_template
)
2852 .alg
= "ecb(anubis)",
2853 .test
= alg_test_skcipher
,
2856 .enc
= __VECS(anubis_enc_tv_template
),
2857 .dec
= __VECS(anubis_dec_tv_template
)
2862 .test
= alg_test_skcipher
,
2865 .enc
= __VECS(arc4_enc_tv_template
),
2866 .dec
= __VECS(arc4_dec_tv_template
)
2870 .alg
= "ecb(blowfish)",
2871 .test
= alg_test_skcipher
,
2874 .enc
= __VECS(bf_enc_tv_template
),
2875 .dec
= __VECS(bf_dec_tv_template
)
2879 .alg
= "ecb(camellia)",
2880 .test
= alg_test_skcipher
,
2883 .enc
= __VECS(camellia_enc_tv_template
),
2884 .dec
= __VECS(camellia_dec_tv_template
)
2888 .alg
= "ecb(cast5)",
2889 .test
= alg_test_skcipher
,
2892 .enc
= __VECS(cast5_enc_tv_template
),
2893 .dec
= __VECS(cast5_dec_tv_template
)
2897 .alg
= "ecb(cast6)",
2898 .test
= alg_test_skcipher
,
2901 .enc
= __VECS(cast6_enc_tv_template
),
2902 .dec
= __VECS(cast6_dec_tv_template
)
2906 .alg
= "ecb(cipher_null)",
2907 .test
= alg_test_null
,
2911 .test
= alg_test_skcipher
,
2914 .enc
= __VECS(des_enc_tv_template
),
2915 .dec
= __VECS(des_dec_tv_template
)
2919 .alg
= "ecb(des3_ede)",
2920 .test
= alg_test_skcipher
,
2924 .enc
= __VECS(des3_ede_enc_tv_template
),
2925 .dec
= __VECS(des3_ede_dec_tv_template
)
2929 .alg
= "ecb(fcrypt)",
2930 .test
= alg_test_skcipher
,
2934 .vecs
= fcrypt_pcbc_enc_tv_template
,
2938 .vecs
= fcrypt_pcbc_dec_tv_template
,
2944 .alg
= "ecb(khazad)",
2945 .test
= alg_test_skcipher
,
2948 .enc
= __VECS(khazad_enc_tv_template
),
2949 .dec
= __VECS(khazad_dec_tv_template
)
2954 .test
= alg_test_skcipher
,
2957 .enc
= __VECS(seed_enc_tv_template
),
2958 .dec
= __VECS(seed_dec_tv_template
)
2962 .alg
= "ecb(serpent)",
2963 .test
= alg_test_skcipher
,
2966 .enc
= __VECS(serpent_enc_tv_template
),
2967 .dec
= __VECS(serpent_dec_tv_template
)
2972 .test
= alg_test_skcipher
,
2975 .enc
= __VECS(tea_enc_tv_template
),
2976 .dec
= __VECS(tea_dec_tv_template
)
2980 .alg
= "ecb(tnepres)",
2981 .test
= alg_test_skcipher
,
2984 .enc
= __VECS(tnepres_enc_tv_template
),
2985 .dec
= __VECS(tnepres_dec_tv_template
)
2989 .alg
= "ecb(twofish)",
2990 .test
= alg_test_skcipher
,
2993 .enc
= __VECS(tf_enc_tv_template
),
2994 .dec
= __VECS(tf_dec_tv_template
)
2999 .test
= alg_test_skcipher
,
3002 .enc
= __VECS(xeta_enc_tv_template
),
3003 .dec
= __VECS(xeta_dec_tv_template
)
3008 .test
= alg_test_skcipher
,
3011 .enc
= __VECS(xtea_enc_tv_template
),
3012 .dec
= __VECS(xtea_dec_tv_template
)
3017 .test
= alg_test_kpp
,
3020 .kpp
= __VECS(ecdh_tv_template
)
3024 .test
= alg_test_aead
,
3028 .enc
= __VECS(aes_gcm_enc_tv_template
),
3029 .dec
= __VECS(aes_gcm_dec_tv_template
)
3034 .test
= alg_test_hash
,
3037 .hash
= __VECS(ghash_tv_template
)
3040 .alg
= "hmac(crc32)",
3041 .test
= alg_test_hash
,
3043 .hash
= __VECS(bfin_crc_tv_template
)
3047 .test
= alg_test_hash
,
3049 .hash
= __VECS(hmac_md5_tv_template
)
3052 .alg
= "hmac(rmd128)",
3053 .test
= alg_test_hash
,
3055 .hash
= __VECS(hmac_rmd128_tv_template
)
3058 .alg
= "hmac(rmd160)",
3059 .test
= alg_test_hash
,
3061 .hash
= __VECS(hmac_rmd160_tv_template
)
3064 .alg
= "hmac(sha1)",
3065 .test
= alg_test_hash
,
3068 .hash
= __VECS(hmac_sha1_tv_template
)
3071 .alg
= "hmac(sha224)",
3072 .test
= alg_test_hash
,
3075 .hash
= __VECS(hmac_sha224_tv_template
)
3078 .alg
= "hmac(sha256)",
3079 .test
= alg_test_hash
,
3082 .hash
= __VECS(hmac_sha256_tv_template
)
3085 .alg
= "hmac(sha3-224)",
3086 .test
= alg_test_hash
,
3089 .hash
= __VECS(hmac_sha3_224_tv_template
)
3092 .alg
= "hmac(sha3-256)",
3093 .test
= alg_test_hash
,
3096 .hash
= __VECS(hmac_sha3_256_tv_template
)
3099 .alg
= "hmac(sha3-384)",
3100 .test
= alg_test_hash
,
3103 .hash
= __VECS(hmac_sha3_384_tv_template
)
3106 .alg
= "hmac(sha3-512)",
3107 .test
= alg_test_hash
,
3110 .hash
= __VECS(hmac_sha3_512_tv_template
)
3113 .alg
= "hmac(sha384)",
3114 .test
= alg_test_hash
,
3117 .hash
= __VECS(hmac_sha384_tv_template
)
3120 .alg
= "hmac(sha512)",
3121 .test
= alg_test_hash
,
3124 .hash
= __VECS(hmac_sha512_tv_template
)
3127 .alg
= "jitterentropy_rng",
3129 .test
= alg_test_null
,
3132 .test
= alg_test_skcipher
,
3136 .enc
= __VECS(aes_kw_enc_tv_template
),
3137 .dec
= __VECS(aes_kw_dec_tv_template
)
3142 .test
= alg_test_skcipher
,
3145 .enc
= __VECS(aes_lrw_enc_tv_template
),
3146 .dec
= __VECS(aes_lrw_dec_tv_template
)
3150 .alg
= "lrw(camellia)",
3151 .test
= alg_test_skcipher
,
3154 .enc
= __VECS(camellia_lrw_enc_tv_template
),
3155 .dec
= __VECS(camellia_lrw_dec_tv_template
)
3159 .alg
= "lrw(cast6)",
3160 .test
= alg_test_skcipher
,
3163 .enc
= __VECS(cast6_lrw_enc_tv_template
),
3164 .dec
= __VECS(cast6_lrw_dec_tv_template
)
3168 .alg
= "lrw(serpent)",
3169 .test
= alg_test_skcipher
,
3172 .enc
= __VECS(serpent_lrw_enc_tv_template
),
3173 .dec
= __VECS(serpent_lrw_dec_tv_template
)
3177 .alg
= "lrw(twofish)",
3178 .test
= alg_test_skcipher
,
3181 .enc
= __VECS(tf_lrw_enc_tv_template
),
3182 .dec
= __VECS(tf_lrw_dec_tv_template
)
3187 .test
= alg_test_comp
,
3191 .comp
= __VECS(lz4_comp_tv_template
),
3192 .decomp
= __VECS(lz4_decomp_tv_template
)
3197 .test
= alg_test_comp
,
3201 .comp
= __VECS(lz4hc_comp_tv_template
),
3202 .decomp
= __VECS(lz4hc_decomp_tv_template
)
3207 .test
= alg_test_comp
,
3211 .comp
= __VECS(lzo_comp_tv_template
),
3212 .decomp
= __VECS(lzo_decomp_tv_template
)
3217 .test
= alg_test_hash
,
3219 .hash
= __VECS(md4_tv_template
)
3223 .test
= alg_test_hash
,
3225 .hash
= __VECS(md5_tv_template
)
3228 .alg
= "michael_mic",
3229 .test
= alg_test_hash
,
3231 .hash
= __VECS(michael_mic_tv_template
)
3235 .test
= alg_test_skcipher
,
3239 .enc
= __VECS(aes_ofb_enc_tv_template
),
3240 .dec
= __VECS(aes_ofb_dec_tv_template
)
3244 .alg
= "pcbc(fcrypt)",
3245 .test
= alg_test_skcipher
,
3248 .enc
= __VECS(fcrypt_pcbc_enc_tv_template
),
3249 .dec
= __VECS(fcrypt_pcbc_dec_tv_template
)
3253 .alg
= "pkcs1pad(rsa,sha224)",
3254 .test
= alg_test_null
,
3257 .alg
= "pkcs1pad(rsa,sha256)",
3258 .test
= alg_test_akcipher
,
3261 .akcipher
= __VECS(pkcs1pad_rsa_tv_template
)
3264 .alg
= "pkcs1pad(rsa,sha384)",
3265 .test
= alg_test_null
,
3268 .alg
= "pkcs1pad(rsa,sha512)",
3269 .test
= alg_test_null
,
3273 .test
= alg_test_hash
,
3275 .hash
= __VECS(poly1305_tv_template
)
3278 .alg
= "rfc3686(ctr(aes))",
3279 .test
= alg_test_skcipher
,
3283 .enc
= __VECS(aes_ctr_rfc3686_enc_tv_template
),
3284 .dec
= __VECS(aes_ctr_rfc3686_dec_tv_template
)
3288 .alg
= "rfc4106(gcm(aes))",
3289 .test
= alg_test_aead
,
3293 .enc
= __VECS(aes_gcm_rfc4106_enc_tv_template
),
3294 .dec
= __VECS(aes_gcm_rfc4106_dec_tv_template
)
3298 .alg
= "rfc4309(ccm(aes))",
3299 .test
= alg_test_aead
,
3303 .enc
= __VECS(aes_ccm_rfc4309_enc_tv_template
),
3304 .dec
= __VECS(aes_ccm_rfc4309_dec_tv_template
)
3308 .alg
= "rfc4543(gcm(aes))",
3309 .test
= alg_test_aead
,
3312 .enc
= __VECS(aes_gcm_rfc4543_enc_tv_template
),
3313 .dec
= __VECS(aes_gcm_rfc4543_dec_tv_template
),
3317 .alg
= "rfc7539(chacha20,poly1305)",
3318 .test
= alg_test_aead
,
3321 .enc
= __VECS(rfc7539_enc_tv_template
),
3322 .dec
= __VECS(rfc7539_dec_tv_template
),
3326 .alg
= "rfc7539esp(chacha20,poly1305)",
3327 .test
= alg_test_aead
,
3330 .enc
= __VECS(rfc7539esp_enc_tv_template
),
3331 .dec
= __VECS(rfc7539esp_dec_tv_template
),
3336 .test
= alg_test_hash
,
3338 .hash
= __VECS(rmd128_tv_template
)
3342 .test
= alg_test_hash
,
3344 .hash
= __VECS(rmd160_tv_template
)
3348 .test
= alg_test_hash
,
3350 .hash
= __VECS(rmd256_tv_template
)
3354 .test
= alg_test_hash
,
3356 .hash
= __VECS(rmd320_tv_template
)
3360 .test
= alg_test_akcipher
,
3363 .akcipher
= __VECS(rsa_tv_template
)
3367 .test
= alg_test_skcipher
,
3370 .enc
= __VECS(salsa20_stream_enc_tv_template
)
3375 .test
= alg_test_hash
,
3378 .hash
= __VECS(sha1_tv_template
)
3382 .test
= alg_test_hash
,
3385 .hash
= __VECS(sha224_tv_template
)
3389 .test
= alg_test_hash
,
3392 .hash
= __VECS(sha256_tv_template
)
3396 .test
= alg_test_hash
,
3399 .hash
= __VECS(sha3_224_tv_template
)
3403 .test
= alg_test_hash
,
3406 .hash
= __VECS(sha3_256_tv_template
)
3410 .test
= alg_test_hash
,
3413 .hash
= __VECS(sha3_384_tv_template
)
3417 .test
= alg_test_hash
,
3420 .hash
= __VECS(sha3_512_tv_template
)
3424 .test
= alg_test_hash
,
3427 .hash
= __VECS(sha384_tv_template
)
3431 .test
= alg_test_hash
,
3434 .hash
= __VECS(sha512_tv_template
)
3438 .test
= alg_test_hash
,
3440 .hash
= __VECS(sm3_tv_template
)
3444 .test
= alg_test_hash
,
3446 .hash
= __VECS(tgr128_tv_template
)
3450 .test
= alg_test_hash
,
3452 .hash
= __VECS(tgr160_tv_template
)
3456 .test
= alg_test_hash
,
3458 .hash
= __VECS(tgr192_tv_template
)
3462 .test
= alg_test_hash
,
3464 .hash
= __VECS(aes_vmac128_tv_template
)
3468 .test
= alg_test_hash
,
3470 .hash
= __VECS(wp256_tv_template
)
3474 .test
= alg_test_hash
,
3476 .hash
= __VECS(wp384_tv_template
)
3480 .test
= alg_test_hash
,
3482 .hash
= __VECS(wp512_tv_template
)
3486 .test
= alg_test_hash
,
3488 .hash
= __VECS(aes_xcbc128_tv_template
)
3492 .test
= alg_test_skcipher
,
3496 .enc
= __VECS(aes_xts_enc_tv_template
),
3497 .dec
= __VECS(aes_xts_dec_tv_template
)
3501 .alg
= "xts(camellia)",
3502 .test
= alg_test_skcipher
,
3505 .enc
= __VECS(camellia_xts_enc_tv_template
),
3506 .dec
= __VECS(camellia_xts_dec_tv_template
)
3510 .alg
= "xts(cast6)",
3511 .test
= alg_test_skcipher
,
3514 .enc
= __VECS(cast6_xts_enc_tv_template
),
3515 .dec
= __VECS(cast6_xts_dec_tv_template
)
3519 .alg
= "xts(serpent)",
3520 .test
= alg_test_skcipher
,
3523 .enc
= __VECS(serpent_xts_enc_tv_template
),
3524 .dec
= __VECS(serpent_xts_dec_tv_template
)
3528 .alg
= "xts(twofish)",
3529 .test
= alg_test_skcipher
,
3532 .enc
= __VECS(tf_xts_enc_tv_template
),
3533 .dec
= __VECS(tf_xts_dec_tv_template
)
3537 .alg
= "zlib-deflate",
3538 .test
= alg_test_comp
,
3542 .comp
= __VECS(zlib_deflate_comp_tv_template
),
3543 .decomp
= __VECS(zlib_deflate_decomp_tv_template
)
3549 static bool alg_test_descs_checked
;
3551 static void alg_test_descs_check_order(void)
3555 /* only check once */
3556 if (alg_test_descs_checked
)
3559 alg_test_descs_checked
= true;
3561 for (i
= 1; i
< ARRAY_SIZE(alg_test_descs
); i
++) {
3562 int diff
= strcmp(alg_test_descs
[i
- 1].alg
,
3563 alg_test_descs
[i
].alg
);
3565 if (WARN_ON(diff
> 0)) {
3566 pr_warn("testmgr: alg_test_descs entries in wrong order: '%s' before '%s'\n",
3567 alg_test_descs
[i
- 1].alg
,
3568 alg_test_descs
[i
].alg
);
3571 if (WARN_ON(diff
== 0)) {
3572 pr_warn("testmgr: duplicate alg_test_descs entry: '%s'\n",
3573 alg_test_descs
[i
].alg
);
3578 static int alg_find_test(const char *alg
)
3581 int end
= ARRAY_SIZE(alg_test_descs
);
3583 while (start
< end
) {
3584 int i
= (start
+ end
) / 2;
3585 int diff
= strcmp(alg_test_descs
[i
].alg
, alg
);
3603 int alg_test(const char *driver
, const char *alg
, u32 type
, u32 mask
)
3609 if (!fips_enabled
&& notests
) {
3610 printk_once(KERN_INFO
"alg: self-tests disabled\n");
3614 alg_test_descs_check_order();
3616 if ((type
& CRYPTO_ALG_TYPE_MASK
) == CRYPTO_ALG_TYPE_CIPHER
) {
3617 char nalg
[CRYPTO_MAX_ALG_NAME
];
3619 if (snprintf(nalg
, sizeof(nalg
), "ecb(%s)", alg
) >=
3621 return -ENAMETOOLONG
;
3623 i
= alg_find_test(nalg
);
3627 if (fips_enabled
&& !alg_test_descs
[i
].fips_allowed
)
3630 rc
= alg_test_cipher(alg_test_descs
+ i
, driver
, type
, mask
);
3634 i
= alg_find_test(alg
);
3635 j
= alg_find_test(driver
);
3639 if (fips_enabled
&& ((i
>= 0 && !alg_test_descs
[i
].fips_allowed
) ||
3640 (j
>= 0 && !alg_test_descs
[j
].fips_allowed
)))
3645 rc
|= alg_test_descs
[i
].test(alg_test_descs
+ i
, driver
,
3647 if (j
>= 0 && j
!= i
)
3648 rc
|= alg_test_descs
[j
].test(alg_test_descs
+ j
, driver
,
3652 if (fips_enabled
&& rc
)
3653 panic("%s: %s alg self test failed in fips mode!\n", driver
, alg
);
3655 if (fips_enabled
&& !rc
)
3656 pr_info("alg: self-tests for %s (%s) passed\n", driver
, alg
);
3661 printk(KERN_INFO
"alg: No test for %s (%s)\n", alg
, driver
);
3667 #endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */
3669 EXPORT_SYMBOL_GPL(alg_test
);