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
{
87 const struct cipher_testvec
*vecs
;
91 struct comp_test_suite
{
93 const struct comp_testvec
*vecs
;
98 struct hash_test_suite
{
99 const struct hash_testvec
*vecs
;
103 struct cprng_test_suite
{
104 const struct cprng_testvec
*vecs
;
108 struct drbg_test_suite
{
109 const struct drbg_testvec
*vecs
;
113 struct akcipher_test_suite
{
114 const struct akcipher_testvec
*vecs
;
118 struct kpp_test_suite
{
119 const struct kpp_testvec
*vecs
;
123 struct alg_test_desc
{
125 int (*test
)(const struct alg_test_desc
*desc
, const char *driver
,
127 int fips_allowed
; /* set if alg is allowed in fips mode */
130 struct aead_test_suite aead
;
131 struct cipher_test_suite cipher
;
132 struct comp_test_suite comp
;
133 struct hash_test_suite hash
;
134 struct cprng_test_suite cprng
;
135 struct drbg_test_suite drbg
;
136 struct akcipher_test_suite akcipher
;
137 struct kpp_test_suite kpp
;
141 static const unsigned int IDX
[8] = {
142 IDX1
, IDX2
, IDX3
, IDX4
, IDX5
, IDX6
, IDX7
, IDX8
};
144 static void hexdump(unsigned char *buf
, unsigned int len
)
146 print_hex_dump(KERN_CONT
, "", DUMP_PREFIX_OFFSET
,
151 static int testmgr_alloc_buf(char *buf
[XBUFSIZE
])
155 for (i
= 0; i
< XBUFSIZE
; i
++) {
156 buf
[i
] = (void *)__get_free_page(GFP_KERNEL
);
165 free_page((unsigned long)buf
[i
]);
170 static void testmgr_free_buf(char *buf
[XBUFSIZE
])
174 for (i
= 0; i
< XBUFSIZE
; i
++)
175 free_page((unsigned long)buf
[i
]);
178 static int ahash_guard_result(char *result
, char c
, int size
)
182 for (i
= 0; i
< size
; i
++) {
190 static int ahash_partial_update(struct ahash_request
**preq
,
191 struct crypto_ahash
*tfm
, const struct hash_testvec
*template,
192 void *hash_buff
, int k
, int temp
, struct scatterlist
*sg
,
193 const char *algo
, char *result
, struct crypto_wait
*wait
)
196 struct ahash_request
*req
;
197 int statesize
, ret
= -EINVAL
;
198 static const unsigned char guard
[] = { 0x00, 0xba, 0xad, 0x00 };
199 int digestsize
= crypto_ahash_digestsize(tfm
);
202 statesize
= crypto_ahash_statesize(
203 crypto_ahash_reqtfm(req
));
204 state
= kmalloc(statesize
+ sizeof(guard
), GFP_KERNEL
);
206 pr_err("alg: hash: Failed to alloc state for %s\n", algo
);
209 memcpy(state
+ statesize
, guard
, sizeof(guard
));
210 memset(result
, 1, digestsize
);
211 ret
= crypto_ahash_export(req
, state
);
212 WARN_ON(memcmp(state
+ statesize
, guard
, sizeof(guard
)));
214 pr_err("alg: hash: Failed to export() for %s\n", algo
);
217 ret
= ahash_guard_result(result
, 1, digestsize
);
219 pr_err("alg: hash: Failed, export used req->result for %s\n",
223 ahash_request_free(req
);
224 req
= ahash_request_alloc(tfm
, GFP_KERNEL
);
226 pr_err("alg: hash: Failed to alloc request for %s\n", algo
);
229 ahash_request_set_callback(req
,
230 CRYPTO_TFM_REQ_MAY_BACKLOG
,
231 crypto_req_done
, wait
);
233 memcpy(hash_buff
, template->plaintext
+ temp
,
235 sg_init_one(&sg
[0], hash_buff
, template->tap
[k
]);
236 ahash_request_set_crypt(req
, sg
, result
, template->tap
[k
]);
237 ret
= crypto_ahash_import(req
, state
);
239 pr_err("alg: hash: Failed to import() for %s\n", algo
);
242 ret
= ahash_guard_result(result
, 1, digestsize
);
244 pr_err("alg: hash: Failed, import used req->result for %s\n",
248 ret
= crypto_wait_req(crypto_ahash_update(req
), wait
);
255 ahash_request_free(req
);
268 static int __test_hash(struct crypto_ahash
*tfm
,
269 const struct hash_testvec
*template, unsigned int tcount
,
270 enum hash_test test_type
, const int align_offset
)
272 const char *algo
= crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm
));
273 size_t digest_size
= crypto_ahash_digestsize(tfm
);
274 unsigned int i
, j
, k
, temp
;
275 struct scatterlist sg
[8];
278 struct ahash_request
*req
;
279 struct crypto_wait wait
;
281 char *xbuf
[XBUFSIZE
];
284 result
= kmalloc(digest_size
, GFP_KERNEL
);
287 key
= kmalloc(MAX_KEYLEN
, GFP_KERNEL
);
290 if (testmgr_alloc_buf(xbuf
))
293 crypto_init_wait(&wait
);
295 req
= ahash_request_alloc(tfm
, GFP_KERNEL
);
297 printk(KERN_ERR
"alg: hash: Failed to allocate request for "
301 ahash_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
302 crypto_req_done
, &wait
);
305 for (i
= 0; i
< tcount
; i
++) {
310 if (WARN_ON(align_offset
+ template[i
].psize
> PAGE_SIZE
))
314 memset(result
, 0, digest_size
);
317 hash_buff
+= align_offset
;
319 memcpy(hash_buff
, template[i
].plaintext
, template[i
].psize
);
320 sg_init_one(&sg
[0], hash_buff
, template[i
].psize
);
322 if (template[i
].ksize
) {
323 crypto_ahash_clear_flags(tfm
, ~0);
324 if (template[i
].ksize
> MAX_KEYLEN
) {
325 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
326 j
, algo
, template[i
].ksize
, MAX_KEYLEN
);
330 memcpy(key
, template[i
].key
, template[i
].ksize
);
331 ret
= crypto_ahash_setkey(tfm
, key
, template[i
].ksize
);
333 printk(KERN_ERR
"alg: hash: setkey failed on "
334 "test %d for %s: ret=%d\n", j
, algo
,
340 ahash_request_set_crypt(req
, sg
, result
, template[i
].psize
);
342 case HASH_TEST_DIGEST
:
343 ret
= crypto_wait_req(crypto_ahash_digest(req
), &wait
);
345 pr_err("alg: hash: digest failed on test %d "
346 "for %s: ret=%d\n", j
, algo
, -ret
);
351 case HASH_TEST_FINAL
:
352 memset(result
, 1, digest_size
);
353 ret
= crypto_wait_req(crypto_ahash_init(req
), &wait
);
355 pr_err("alg: hash: init failed on test %d "
356 "for %s: ret=%d\n", j
, algo
, -ret
);
359 ret
= ahash_guard_result(result
, 1, digest_size
);
361 pr_err("alg: hash: init failed on test %d "
362 "for %s: used req->result\n", j
, algo
);
365 ret
= crypto_wait_req(crypto_ahash_update(req
), &wait
);
367 pr_err("alg: hash: update failed on test %d "
368 "for %s: ret=%d\n", j
, algo
, -ret
);
371 ret
= ahash_guard_result(result
, 1, digest_size
);
373 pr_err("alg: hash: update failed on test %d "
374 "for %s: used req->result\n", j
, algo
);
377 ret
= crypto_wait_req(crypto_ahash_final(req
), &wait
);
379 pr_err("alg: hash: final failed on test %d "
380 "for %s: ret=%d\n", j
, algo
, -ret
);
385 case HASH_TEST_FINUP
:
386 memset(result
, 1, digest_size
);
387 ret
= crypto_wait_req(crypto_ahash_init(req
), &wait
);
389 pr_err("alg: hash: init failed on test %d "
390 "for %s: ret=%d\n", j
, algo
, -ret
);
393 ret
= ahash_guard_result(result
, 1, digest_size
);
395 pr_err("alg: hash: init failed on test %d "
396 "for %s: used req->result\n", j
, algo
);
399 ret
= crypto_wait_req(crypto_ahash_finup(req
), &wait
);
401 pr_err("alg: hash: final failed on test %d "
402 "for %s: ret=%d\n", j
, algo
, -ret
);
408 if (memcmp(result
, template[i
].digest
,
409 crypto_ahash_digestsize(tfm
))) {
410 printk(KERN_ERR
"alg: hash: Test %d failed for %s\n",
412 hexdump(result
, crypto_ahash_digestsize(tfm
));
422 for (i
= 0; i
< tcount
; i
++) {
423 /* alignment tests are only done with continuous buffers */
424 if (align_offset
!= 0)
431 memset(result
, 0, digest_size
);
434 sg_init_table(sg
, template[i
].np
);
436 for (k
= 0; k
< template[i
].np
; k
++) {
437 if (WARN_ON(offset_in_page(IDX
[k
]) +
438 template[i
].tap
[k
] > PAGE_SIZE
))
441 memcpy(xbuf
[IDX
[k
] >> PAGE_SHIFT
] +
442 offset_in_page(IDX
[k
]),
443 template[i
].plaintext
+ temp
,
446 temp
+= template[i
].tap
[k
];
449 if (template[i
].ksize
) {
450 if (template[i
].ksize
> MAX_KEYLEN
) {
451 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
452 j
, algo
, template[i
].ksize
, MAX_KEYLEN
);
456 crypto_ahash_clear_flags(tfm
, ~0);
457 memcpy(key
, template[i
].key
, template[i
].ksize
);
458 ret
= crypto_ahash_setkey(tfm
, key
, template[i
].ksize
);
461 printk(KERN_ERR
"alg: hash: setkey "
462 "failed on chunking test %d "
463 "for %s: ret=%d\n", j
, algo
, -ret
);
468 ahash_request_set_crypt(req
, sg
, result
, template[i
].psize
);
469 ret
= crypto_wait_req(crypto_ahash_digest(req
), &wait
);
471 pr_err("alg: hash: digest failed on chunking test %d for %s: ret=%d\n",
476 if (memcmp(result
, template[i
].digest
,
477 crypto_ahash_digestsize(tfm
))) {
478 printk(KERN_ERR
"alg: hash: Chunking test %d "
479 "failed for %s\n", j
, algo
);
480 hexdump(result
, crypto_ahash_digestsize(tfm
));
486 /* partial update exercise */
488 for (i
= 0; i
< tcount
; i
++) {
489 /* alignment tests are only done with continuous buffers */
490 if (align_offset
!= 0)
493 if (template[i
].np
< 2)
497 memset(result
, 0, digest_size
);
501 memcpy(hash_buff
, template[i
].plaintext
,
503 sg_init_one(&sg
[0], hash_buff
, template[i
].tap
[0]);
505 if (template[i
].ksize
) {
506 crypto_ahash_clear_flags(tfm
, ~0);
507 if (template[i
].ksize
> MAX_KEYLEN
) {
508 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
509 j
, algo
, template[i
].ksize
, MAX_KEYLEN
);
513 memcpy(key
, template[i
].key
, template[i
].ksize
);
514 ret
= crypto_ahash_setkey(tfm
, key
, template[i
].ksize
);
516 pr_err("alg: hash: setkey failed on test %d for %s: ret=%d\n",
522 ahash_request_set_crypt(req
, sg
, result
, template[i
].tap
[0]);
523 ret
= crypto_wait_req(crypto_ahash_init(req
), &wait
);
525 pr_err("alg: hash: init failed on test %d for %s: ret=%d\n",
529 ret
= crypto_wait_req(crypto_ahash_update(req
), &wait
);
531 pr_err("alg: hash: update failed on test %d for %s: ret=%d\n",
536 temp
= template[i
].tap
[0];
537 for (k
= 1; k
< template[i
].np
; k
++) {
538 ret
= ahash_partial_update(&req
, tfm
, &template[i
],
539 hash_buff
, k
, temp
, &sg
[0], algo
, result
,
542 pr_err("alg: hash: partial update failed on test %d for %s: ret=%d\n",
546 temp
+= template[i
].tap
[k
];
548 ret
= crypto_wait_req(crypto_ahash_final(req
), &wait
);
550 pr_err("alg: hash: final failed on test %d for %s: ret=%d\n",
554 if (memcmp(result
, template[i
].digest
,
555 crypto_ahash_digestsize(tfm
))) {
556 pr_err("alg: hash: Partial Test %d failed for %s\n",
558 hexdump(result
, crypto_ahash_digestsize(tfm
));
567 ahash_request_free(req
);
569 testmgr_free_buf(xbuf
);
576 static int test_hash(struct crypto_ahash
*tfm
,
577 const struct hash_testvec
*template,
578 unsigned int tcount
, enum hash_test test_type
)
580 unsigned int alignmask
;
583 ret
= __test_hash(tfm
, template, tcount
, test_type
, 0);
587 /* test unaligned buffers, check with one byte offset */
588 ret
= __test_hash(tfm
, template, tcount
, test_type
, 1);
592 alignmask
= crypto_tfm_alg_alignmask(&tfm
->base
);
594 /* Check if alignment mask for tfm is correctly set. */
595 ret
= __test_hash(tfm
, template, tcount
, test_type
,
604 static int __test_aead(struct crypto_aead
*tfm
, int enc
,
605 const struct aead_testvec
*template, unsigned int tcount
,
606 const bool diff_dst
, const int align_offset
)
608 const char *algo
= crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm
));
609 unsigned int i
, j
, k
, n
, temp
;
613 struct aead_request
*req
;
614 struct scatterlist
*sg
;
615 struct scatterlist
*sgout
;
617 struct crypto_wait wait
;
618 unsigned int authsize
, iv_len
;
623 char *xbuf
[XBUFSIZE
];
624 char *xoutbuf
[XBUFSIZE
];
625 char *axbuf
[XBUFSIZE
];
627 iv
= kzalloc(MAX_IVLEN
, GFP_KERNEL
);
630 key
= kmalloc(MAX_KEYLEN
, GFP_KERNEL
);
633 if (testmgr_alloc_buf(xbuf
))
635 if (testmgr_alloc_buf(axbuf
))
637 if (diff_dst
&& testmgr_alloc_buf(xoutbuf
))
640 /* avoid "the frame size is larger than 1024 bytes" compiler warning */
641 sg
= kmalloc(array3_size(sizeof(*sg
), 8, (diff_dst
? 4 : 2)),
657 crypto_init_wait(&wait
);
659 req
= aead_request_alloc(tfm
, GFP_KERNEL
);
661 pr_err("alg: aead%s: Failed to allocate request for %s\n",
666 aead_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
667 crypto_req_done
, &wait
);
669 iv_len
= crypto_aead_ivsize(tfm
);
671 for (i
= 0, j
= 0; i
< tcount
; i
++) {
677 /* some templates have no input data but they will
681 input
+= align_offset
;
685 if (WARN_ON(align_offset
+ template[i
].ilen
>
686 PAGE_SIZE
|| template[i
].alen
> PAGE_SIZE
))
689 memcpy(input
, template[i
].input
, template[i
].ilen
);
690 memcpy(assoc
, template[i
].assoc
, template[i
].alen
);
692 memcpy(iv
, template[i
].iv
, iv_len
);
694 memset(iv
, 0, iv_len
);
696 crypto_aead_clear_flags(tfm
, ~0);
698 crypto_aead_set_flags(tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
700 if (template[i
].klen
> MAX_KEYLEN
) {
701 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
702 d
, j
, algo
, template[i
].klen
,
707 memcpy(key
, template[i
].key
, template[i
].klen
);
709 ret
= crypto_aead_setkey(tfm
, key
, template[i
].klen
);
710 if (template[i
].fail
== !ret
) {
711 pr_err("alg: aead%s: setkey failed on test %d for %s: flags=%x\n",
712 d
, j
, algo
, crypto_aead_get_flags(tfm
));
717 authsize
= abs(template[i
].rlen
- template[i
].ilen
);
718 ret
= crypto_aead_setauthsize(tfm
, authsize
);
720 pr_err("alg: aead%s: Failed to set authsize to %u on test %d for %s\n",
721 d
, authsize
, j
, algo
);
725 k
= !!template[i
].alen
;
726 sg_init_table(sg
, k
+ 1);
727 sg_set_buf(&sg
[0], assoc
, template[i
].alen
);
728 sg_set_buf(&sg
[k
], input
,
729 template[i
].ilen
+ (enc
? authsize
: 0));
733 sg_init_table(sgout
, k
+ 1);
734 sg_set_buf(&sgout
[0], assoc
, template[i
].alen
);
737 output
+= align_offset
;
738 sg_set_buf(&sgout
[k
], output
,
739 template[i
].rlen
+ (enc
? 0 : authsize
));
742 aead_request_set_crypt(req
, sg
, (diff_dst
) ? sgout
: sg
,
743 template[i
].ilen
, iv
);
745 aead_request_set_ad(req
, template[i
].alen
);
747 ret
= crypto_wait_req(enc
? crypto_aead_encrypt(req
)
748 : crypto_aead_decrypt(req
), &wait
);
752 if (template[i
].novrfy
) {
753 /* verification was supposed to fail */
754 pr_err("alg: aead%s: %s failed on test %d for %s: ret was 0, expected -EBADMSG\n",
756 /* so really, we got a bad message */
762 if (template[i
].novrfy
)
763 /* verification failure was expected */
767 pr_err("alg: aead%s: %s failed on test %d for %s: ret=%d\n",
768 d
, e
, j
, algo
, -ret
);
773 if (memcmp(q
, template[i
].result
, template[i
].rlen
)) {
774 pr_err("alg: aead%s: Test %d failed on %s for %s\n",
776 hexdump(q
, template[i
].rlen
);
782 for (i
= 0, j
= 0; i
< tcount
; i
++) {
783 /* alignment tests are only done with continuous buffers */
784 if (align_offset
!= 0)
793 memcpy(iv
, template[i
].iv
, iv_len
);
795 memset(iv
, 0, MAX_IVLEN
);
797 crypto_aead_clear_flags(tfm
, ~0);
799 crypto_aead_set_flags(tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
800 if (template[i
].klen
> MAX_KEYLEN
) {
801 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
802 d
, j
, algo
, template[i
].klen
, MAX_KEYLEN
);
806 memcpy(key
, template[i
].key
, template[i
].klen
);
808 ret
= crypto_aead_setkey(tfm
, key
, template[i
].klen
);
809 if (template[i
].fail
== !ret
) {
810 pr_err("alg: aead%s: setkey failed on chunk test %d for %s: flags=%x\n",
811 d
, j
, algo
, crypto_aead_get_flags(tfm
));
816 authsize
= abs(template[i
].rlen
- template[i
].ilen
);
819 sg_init_table(sg
, template[i
].anp
+ template[i
].np
);
821 sg_init_table(sgout
, template[i
].anp
+ template[i
].np
);
824 for (k
= 0, temp
= 0; k
< template[i
].anp
; k
++) {
825 if (WARN_ON(offset_in_page(IDX
[k
]) +
826 template[i
].atap
[k
] > PAGE_SIZE
))
829 memcpy(axbuf
[IDX
[k
] >> PAGE_SHIFT
] +
830 offset_in_page(IDX
[k
]),
831 template[i
].assoc
+ temp
,
832 template[i
].atap
[k
]),
833 template[i
].atap
[k
]);
835 sg_set_buf(&sgout
[k
],
836 axbuf
[IDX
[k
] >> PAGE_SHIFT
] +
837 offset_in_page(IDX
[k
]),
838 template[i
].atap
[k
]);
839 temp
+= template[i
].atap
[k
];
842 for (k
= 0, temp
= 0; k
< template[i
].np
; k
++) {
843 if (WARN_ON(offset_in_page(IDX
[k
]) +
844 template[i
].tap
[k
] > PAGE_SIZE
))
847 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] + offset_in_page(IDX
[k
]);
848 memcpy(q
, template[i
].input
+ temp
, template[i
].tap
[k
]);
849 sg_set_buf(&sg
[template[i
].anp
+ k
],
850 q
, template[i
].tap
[k
]);
853 q
= xoutbuf
[IDX
[k
] >> PAGE_SHIFT
] +
854 offset_in_page(IDX
[k
]);
856 memset(q
, 0, template[i
].tap
[k
]);
858 sg_set_buf(&sgout
[template[i
].anp
+ k
],
859 q
, template[i
].tap
[k
]);
862 n
= template[i
].tap
[k
];
863 if (k
== template[i
].np
- 1 && enc
)
865 if (offset_in_page(q
) + n
< PAGE_SIZE
)
868 temp
+= template[i
].tap
[k
];
871 ret
= crypto_aead_setauthsize(tfm
, authsize
);
873 pr_err("alg: aead%s: Failed to set authsize to %u on chunk test %d for %s\n",
874 d
, authsize
, j
, algo
);
879 if (WARN_ON(sg
[template[i
].anp
+ k
- 1].offset
+
880 sg
[template[i
].anp
+ k
- 1].length
+
881 authsize
> PAGE_SIZE
)) {
887 sgout
[template[i
].anp
+ k
- 1].length
+=
889 sg
[template[i
].anp
+ k
- 1].length
+= authsize
;
892 aead_request_set_crypt(req
, sg
, (diff_dst
) ? sgout
: sg
,
896 aead_request_set_ad(req
, template[i
].alen
);
898 ret
= crypto_wait_req(enc
? crypto_aead_encrypt(req
)
899 : crypto_aead_decrypt(req
), &wait
);
903 if (template[i
].novrfy
) {
904 /* verification was supposed to fail */
905 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret was 0, expected -EBADMSG\n",
907 /* so really, we got a bad message */
913 if (template[i
].novrfy
)
914 /* verification failure was expected */
918 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret=%d\n",
919 d
, e
, j
, algo
, -ret
);
924 for (k
= 0, temp
= 0; k
< template[i
].np
; k
++) {
926 q
= xoutbuf
[IDX
[k
] >> PAGE_SHIFT
] +
927 offset_in_page(IDX
[k
]);
929 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] +
930 offset_in_page(IDX
[k
]);
932 n
= template[i
].tap
[k
];
933 if (k
== template[i
].np
- 1)
934 n
+= enc
? authsize
: -authsize
;
936 if (memcmp(q
, template[i
].result
+ temp
, n
)) {
937 pr_err("alg: aead%s: Chunk test %d failed on %s at page %u for %s\n",
944 if (k
== template[i
].np
- 1 && !enc
) {
946 memcmp(q
, template[i
].input
+
952 for (n
= 0; offset_in_page(q
+ n
) && q
[n
]; n
++)
956 pr_err("alg: aead%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
957 d
, j
, e
, k
, algo
, n
);
962 temp
+= template[i
].tap
[k
];
969 aead_request_free(req
);
973 testmgr_free_buf(xoutbuf
);
975 testmgr_free_buf(axbuf
);
977 testmgr_free_buf(xbuf
);
984 static int test_aead(struct crypto_aead
*tfm
, int enc
,
985 const struct aead_testvec
*template, unsigned int tcount
)
987 unsigned int alignmask
;
990 /* test 'dst == src' case */
991 ret
= __test_aead(tfm
, enc
, template, tcount
, false, 0);
995 /* test 'dst != src' case */
996 ret
= __test_aead(tfm
, enc
, template, tcount
, true, 0);
1000 /* test unaligned buffers, check with one byte offset */
1001 ret
= __test_aead(tfm
, enc
, template, tcount
, true, 1);
1005 alignmask
= crypto_tfm_alg_alignmask(&tfm
->base
);
1007 /* Check if alignment mask for tfm is correctly set. */
1008 ret
= __test_aead(tfm
, enc
, template, tcount
, true,
1017 static int test_cipher(struct crypto_cipher
*tfm
, int enc
,
1018 const struct cipher_testvec
*template,
1019 unsigned int tcount
)
1021 const char *algo
= crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm
));
1022 unsigned int i
, j
, k
;
1025 const char *input
, *result
;
1027 char *xbuf
[XBUFSIZE
];
1030 if (testmgr_alloc_buf(xbuf
))
1039 for (i
= 0; i
< tcount
; i
++) {
1043 if (fips_enabled
&& template[i
].fips_skip
)
1046 input
= enc
? template[i
].ptext
: template[i
].ctext
;
1047 result
= enc
? template[i
].ctext
: template[i
].ptext
;
1051 if (WARN_ON(template[i
].len
> PAGE_SIZE
))
1055 memcpy(data
, input
, template[i
].len
);
1057 crypto_cipher_clear_flags(tfm
, ~0);
1059 crypto_cipher_set_flags(tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
1061 ret
= crypto_cipher_setkey(tfm
, template[i
].key
,
1063 if (template[i
].fail
== !ret
) {
1064 printk(KERN_ERR
"alg: cipher: setkey failed "
1065 "on test %d for %s: flags=%x\n", j
,
1066 algo
, crypto_cipher_get_flags(tfm
));
1071 for (k
= 0; k
< template[i
].len
;
1072 k
+= crypto_cipher_blocksize(tfm
)) {
1074 crypto_cipher_encrypt_one(tfm
, data
+ k
,
1077 crypto_cipher_decrypt_one(tfm
, data
+ k
,
1082 if (memcmp(q
, result
, template[i
].len
)) {
1083 printk(KERN_ERR
"alg: cipher: Test %d failed "
1084 "on %s for %s\n", j
, e
, algo
);
1085 hexdump(q
, template[i
].len
);
1094 testmgr_free_buf(xbuf
);
1099 static int __test_skcipher(struct crypto_skcipher
*tfm
, int enc
,
1100 const struct cipher_testvec
*template,
1101 unsigned int tcount
,
1102 const bool diff_dst
, const int align_offset
)
1105 crypto_tfm_alg_driver_name(crypto_skcipher_tfm(tfm
));
1106 unsigned int i
, j
, k
, n
, temp
;
1108 struct skcipher_request
*req
;
1109 struct scatterlist sg
[8];
1110 struct scatterlist sgout
[8];
1112 struct crypto_wait wait
;
1113 const char *input
, *result
;
1116 char *xbuf
[XBUFSIZE
];
1117 char *xoutbuf
[XBUFSIZE
];
1119 unsigned int ivsize
= crypto_skcipher_ivsize(tfm
);
1121 if (testmgr_alloc_buf(xbuf
))
1124 if (diff_dst
&& testmgr_alloc_buf(xoutbuf
))
1137 crypto_init_wait(&wait
);
1139 req
= skcipher_request_alloc(tfm
, GFP_KERNEL
);
1141 pr_err("alg: skcipher%s: Failed to allocate request for %s\n",
1146 skcipher_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
1147 crypto_req_done
, &wait
);
1150 for (i
= 0; i
< tcount
; i
++) {
1151 if (template[i
].np
&& !template[i
].also_non_np
)
1154 if (fips_enabled
&& template[i
].fips_skip
)
1157 if (template[i
].iv
&& !(template[i
].generates_iv
&& enc
))
1158 memcpy(iv
, template[i
].iv
, ivsize
);
1160 memset(iv
, 0, MAX_IVLEN
);
1162 input
= enc
? template[i
].ptext
: template[i
].ctext
;
1163 result
= enc
? template[i
].ctext
: template[i
].ptext
;
1166 if (WARN_ON(align_offset
+ template[i
].len
> PAGE_SIZE
))
1170 data
+= align_offset
;
1171 memcpy(data
, input
, template[i
].len
);
1173 crypto_skcipher_clear_flags(tfm
, ~0);
1175 crypto_skcipher_set_flags(tfm
,
1176 CRYPTO_TFM_REQ_WEAK_KEY
);
1178 ret
= crypto_skcipher_setkey(tfm
, template[i
].key
,
1180 if (template[i
].fail
== !ret
) {
1181 pr_err("alg: skcipher%s: setkey failed on test %d for %s: flags=%x\n",
1182 d
, j
, algo
, crypto_skcipher_get_flags(tfm
));
1187 sg_init_one(&sg
[0], data
, template[i
].len
);
1190 data
+= align_offset
;
1191 sg_init_one(&sgout
[0], data
, template[i
].len
);
1194 skcipher_request_set_crypt(req
, sg
, (diff_dst
) ? sgout
: sg
,
1195 template[i
].len
, iv
);
1196 ret
= crypto_wait_req(enc
? crypto_skcipher_encrypt(req
) :
1197 crypto_skcipher_decrypt(req
), &wait
);
1200 pr_err("alg: skcipher%s: %s failed on test %d for %s: ret=%d\n",
1201 d
, e
, j
, algo
, -ret
);
1206 if (memcmp(q
, result
, template[i
].len
)) {
1207 pr_err("alg: skcipher%s: Test %d failed (invalid result) on %s for %s\n",
1209 hexdump(q
, template[i
].len
);
1214 if (template[i
].generates_iv
&& enc
&&
1215 memcmp(iv
, template[i
].iv
, crypto_skcipher_ivsize(tfm
))) {
1216 pr_err("alg: skcipher%s: Test %d failed (invalid output IV) on %s for %s\n",
1218 hexdump(iv
, crypto_skcipher_ivsize(tfm
));
1225 for (i
= 0; i
< tcount
; i
++) {
1226 /* alignment tests are only done with continuous buffers */
1227 if (align_offset
!= 0)
1230 if (!template[i
].np
)
1233 if (fips_enabled
&& template[i
].fips_skip
)
1236 if (template[i
].iv
&& !(template[i
].generates_iv
&& enc
))
1237 memcpy(iv
, template[i
].iv
, ivsize
);
1239 memset(iv
, 0, MAX_IVLEN
);
1241 input
= enc
? template[i
].ptext
: template[i
].ctext
;
1242 result
= enc
? template[i
].ctext
: template[i
].ptext
;
1244 crypto_skcipher_clear_flags(tfm
, ~0);
1246 crypto_skcipher_set_flags(tfm
,
1247 CRYPTO_TFM_REQ_WEAK_KEY
);
1249 ret
= crypto_skcipher_setkey(tfm
, template[i
].key
,
1251 if (template[i
].fail
== !ret
) {
1252 pr_err("alg: skcipher%s: setkey failed on chunk test %d for %s: flags=%x\n",
1253 d
, j
, algo
, crypto_skcipher_get_flags(tfm
));
1260 sg_init_table(sg
, template[i
].np
);
1262 sg_init_table(sgout
, template[i
].np
);
1263 for (k
= 0; k
< template[i
].np
; k
++) {
1264 if (WARN_ON(offset_in_page(IDX
[k
]) +
1265 template[i
].tap
[k
] > PAGE_SIZE
))
1268 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] + offset_in_page(IDX
[k
]);
1270 memcpy(q
, input
+ temp
, template[i
].tap
[k
]);
1272 if (offset_in_page(q
) + template[i
].tap
[k
] < PAGE_SIZE
)
1273 q
[template[i
].tap
[k
]] = 0;
1275 sg_set_buf(&sg
[k
], q
, template[i
].tap
[k
]);
1277 q
= xoutbuf
[IDX
[k
] >> PAGE_SHIFT
] +
1278 offset_in_page(IDX
[k
]);
1280 sg_set_buf(&sgout
[k
], q
, template[i
].tap
[k
]);
1282 memset(q
, 0, template[i
].tap
[k
]);
1283 if (offset_in_page(q
) +
1284 template[i
].tap
[k
] < PAGE_SIZE
)
1285 q
[template[i
].tap
[k
]] = 0;
1288 temp
+= template[i
].tap
[k
];
1291 skcipher_request_set_crypt(req
, sg
, (diff_dst
) ? sgout
: sg
,
1292 template[i
].len
, iv
);
1294 ret
= crypto_wait_req(enc
? crypto_skcipher_encrypt(req
) :
1295 crypto_skcipher_decrypt(req
), &wait
);
1298 pr_err("alg: skcipher%s: %s failed on chunk test %d for %s: ret=%d\n",
1299 d
, e
, j
, algo
, -ret
);
1305 for (k
= 0; k
< template[i
].np
; k
++) {
1307 q
= xoutbuf
[IDX
[k
] >> PAGE_SHIFT
] +
1308 offset_in_page(IDX
[k
]);
1310 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] +
1311 offset_in_page(IDX
[k
]);
1313 if (memcmp(q
, result
+ temp
, template[i
].tap
[k
])) {
1314 pr_err("alg: skcipher%s: Chunk test %d failed on %s at page %u for %s\n",
1316 hexdump(q
, template[i
].tap
[k
]);
1320 q
+= template[i
].tap
[k
];
1321 for (n
= 0; offset_in_page(q
+ n
) && q
[n
]; n
++)
1324 pr_err("alg: skcipher%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
1325 d
, j
, e
, k
, algo
, n
);
1329 temp
+= template[i
].tap
[k
];
1336 skcipher_request_free(req
);
1338 testmgr_free_buf(xoutbuf
);
1340 testmgr_free_buf(xbuf
);
1345 static int test_skcipher(struct crypto_skcipher
*tfm
, int enc
,
1346 const struct cipher_testvec
*template,
1347 unsigned int tcount
)
1349 unsigned int alignmask
;
1352 /* test 'dst == src' case */
1353 ret
= __test_skcipher(tfm
, enc
, template, tcount
, false, 0);
1357 /* test 'dst != src' case */
1358 ret
= __test_skcipher(tfm
, enc
, template, tcount
, true, 0);
1362 /* test unaligned buffers, check with one byte offset */
1363 ret
= __test_skcipher(tfm
, enc
, template, tcount
, true, 1);
1367 alignmask
= crypto_tfm_alg_alignmask(&tfm
->base
);
1369 /* Check if alignment mask for tfm is correctly set. */
1370 ret
= __test_skcipher(tfm
, enc
, template, tcount
, true,
1379 static int test_comp(struct crypto_comp
*tfm
,
1380 const struct comp_testvec
*ctemplate
,
1381 const struct comp_testvec
*dtemplate
,
1382 int ctcount
, int dtcount
)
1384 const char *algo
= crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm
));
1385 char *output
, *decomp_output
;
1389 output
= kmalloc(COMP_BUF_SIZE
, GFP_KERNEL
);
1393 decomp_output
= kmalloc(COMP_BUF_SIZE
, GFP_KERNEL
);
1394 if (!decomp_output
) {
1399 for (i
= 0; i
< ctcount
; i
++) {
1401 unsigned int dlen
= COMP_BUF_SIZE
;
1403 memset(output
, 0, COMP_BUF_SIZE
);
1404 memset(decomp_output
, 0, COMP_BUF_SIZE
);
1406 ilen
= ctemplate
[i
].inlen
;
1407 ret
= crypto_comp_compress(tfm
, ctemplate
[i
].input
,
1408 ilen
, output
, &dlen
);
1410 printk(KERN_ERR
"alg: comp: compression failed "
1411 "on test %d for %s: ret=%d\n", i
+ 1, algo
,
1417 dlen
= COMP_BUF_SIZE
;
1418 ret
= crypto_comp_decompress(tfm
, output
,
1419 ilen
, decomp_output
, &dlen
);
1421 pr_err("alg: comp: compression failed: decompress: on test %d for %s failed: ret=%d\n",
1426 if (dlen
!= ctemplate
[i
].inlen
) {
1427 printk(KERN_ERR
"alg: comp: Compression test %d "
1428 "failed for %s: output len = %d\n", i
+ 1, algo
,
1434 if (memcmp(decomp_output
, ctemplate
[i
].input
,
1435 ctemplate
[i
].inlen
)) {
1436 pr_err("alg: comp: compression failed: output differs: on test %d for %s\n",
1438 hexdump(decomp_output
, dlen
);
1444 for (i
= 0; i
< dtcount
; i
++) {
1446 unsigned int dlen
= COMP_BUF_SIZE
;
1448 memset(decomp_output
, 0, COMP_BUF_SIZE
);
1450 ilen
= dtemplate
[i
].inlen
;
1451 ret
= crypto_comp_decompress(tfm
, dtemplate
[i
].input
,
1452 ilen
, decomp_output
, &dlen
);
1454 printk(KERN_ERR
"alg: comp: decompression failed "
1455 "on test %d for %s: ret=%d\n", i
+ 1, algo
,
1460 if (dlen
!= dtemplate
[i
].outlen
) {
1461 printk(KERN_ERR
"alg: comp: Decompression test %d "
1462 "failed for %s: output len = %d\n", i
+ 1, algo
,
1468 if (memcmp(decomp_output
, dtemplate
[i
].output
, dlen
)) {
1469 printk(KERN_ERR
"alg: comp: Decompression test %d "
1470 "failed for %s\n", i
+ 1, algo
);
1471 hexdump(decomp_output
, dlen
);
1480 kfree(decomp_output
);
1485 static int test_acomp(struct crypto_acomp
*tfm
,
1486 const struct comp_testvec
*ctemplate
,
1487 const struct comp_testvec
*dtemplate
,
1488 int ctcount
, int dtcount
)
1490 const char *algo
= crypto_tfm_alg_driver_name(crypto_acomp_tfm(tfm
));
1492 char *output
, *decomp_out
;
1494 struct scatterlist src
, dst
;
1495 struct acomp_req
*req
;
1496 struct crypto_wait wait
;
1498 output
= kmalloc(COMP_BUF_SIZE
, GFP_KERNEL
);
1502 decomp_out
= kmalloc(COMP_BUF_SIZE
, GFP_KERNEL
);
1508 for (i
= 0; i
< ctcount
; i
++) {
1509 unsigned int dlen
= COMP_BUF_SIZE
;
1510 int ilen
= ctemplate
[i
].inlen
;
1513 input_vec
= kmemdup(ctemplate
[i
].input
, ilen
, GFP_KERNEL
);
1519 memset(output
, 0, dlen
);
1520 crypto_init_wait(&wait
);
1521 sg_init_one(&src
, input_vec
, ilen
);
1522 sg_init_one(&dst
, output
, dlen
);
1524 req
= acomp_request_alloc(tfm
);
1526 pr_err("alg: acomp: request alloc failed for %s\n",
1533 acomp_request_set_params(req
, &src
, &dst
, ilen
, dlen
);
1534 acomp_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
1535 crypto_req_done
, &wait
);
1537 ret
= crypto_wait_req(crypto_acomp_compress(req
), &wait
);
1539 pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n",
1542 acomp_request_free(req
);
1547 dlen
= COMP_BUF_SIZE
;
1548 sg_init_one(&src
, output
, ilen
);
1549 sg_init_one(&dst
, decomp_out
, dlen
);
1550 crypto_init_wait(&wait
);
1551 acomp_request_set_params(req
, &src
, &dst
, ilen
, dlen
);
1553 ret
= crypto_wait_req(crypto_acomp_decompress(req
), &wait
);
1555 pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n",
1558 acomp_request_free(req
);
1562 if (req
->dlen
!= ctemplate
[i
].inlen
) {
1563 pr_err("alg: acomp: Compression test %d failed for %s: output len = %d\n",
1564 i
+ 1, algo
, req
->dlen
);
1567 acomp_request_free(req
);
1571 if (memcmp(input_vec
, decomp_out
, req
->dlen
)) {
1572 pr_err("alg: acomp: Compression test %d failed for %s\n",
1574 hexdump(output
, req
->dlen
);
1577 acomp_request_free(req
);
1582 acomp_request_free(req
);
1585 for (i
= 0; i
< dtcount
; i
++) {
1586 unsigned int dlen
= COMP_BUF_SIZE
;
1587 int ilen
= dtemplate
[i
].inlen
;
1590 input_vec
= kmemdup(dtemplate
[i
].input
, ilen
, GFP_KERNEL
);
1596 memset(output
, 0, dlen
);
1597 crypto_init_wait(&wait
);
1598 sg_init_one(&src
, input_vec
, ilen
);
1599 sg_init_one(&dst
, output
, dlen
);
1601 req
= acomp_request_alloc(tfm
);
1603 pr_err("alg: acomp: request alloc failed for %s\n",
1610 acomp_request_set_params(req
, &src
, &dst
, ilen
, dlen
);
1611 acomp_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
1612 crypto_req_done
, &wait
);
1614 ret
= crypto_wait_req(crypto_acomp_decompress(req
), &wait
);
1616 pr_err("alg: acomp: decompression failed on test %d for %s: ret=%d\n",
1619 acomp_request_free(req
);
1623 if (req
->dlen
!= dtemplate
[i
].outlen
) {
1624 pr_err("alg: acomp: Decompression test %d failed for %s: output len = %d\n",
1625 i
+ 1, algo
, req
->dlen
);
1628 acomp_request_free(req
);
1632 if (memcmp(output
, dtemplate
[i
].output
, req
->dlen
)) {
1633 pr_err("alg: acomp: Decompression test %d failed for %s\n",
1635 hexdump(output
, req
->dlen
);
1638 acomp_request_free(req
);
1643 acomp_request_free(req
);
1654 static int test_cprng(struct crypto_rng
*tfm
,
1655 const struct cprng_testvec
*template,
1656 unsigned int tcount
)
1658 const char *algo
= crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm
));
1659 int err
= 0, i
, j
, seedsize
;
1663 seedsize
= crypto_rng_seedsize(tfm
);
1665 seed
= kmalloc(seedsize
, GFP_KERNEL
);
1667 printk(KERN_ERR
"alg: cprng: Failed to allocate seed space "
1672 for (i
= 0; i
< tcount
; i
++) {
1673 memset(result
, 0, 32);
1675 memcpy(seed
, template[i
].v
, template[i
].vlen
);
1676 memcpy(seed
+ template[i
].vlen
, template[i
].key
,
1678 memcpy(seed
+ template[i
].vlen
+ template[i
].klen
,
1679 template[i
].dt
, template[i
].dtlen
);
1681 err
= crypto_rng_reset(tfm
, seed
, seedsize
);
1683 printk(KERN_ERR
"alg: cprng: Failed to reset rng "
1688 for (j
= 0; j
< template[i
].loops
; j
++) {
1689 err
= crypto_rng_get_bytes(tfm
, result
,
1692 printk(KERN_ERR
"alg: cprng: Failed to obtain "
1693 "the correct amount of random data for "
1694 "%s (requested %d)\n", algo
,
1700 err
= memcmp(result
, template[i
].result
,
1703 printk(KERN_ERR
"alg: cprng: Test %d failed for %s\n",
1705 hexdump(result
, template[i
].rlen
);
1716 static int alg_test_aead(const struct alg_test_desc
*desc
, const char *driver
,
1719 struct crypto_aead
*tfm
;
1722 tfm
= crypto_alloc_aead(driver
, type
, mask
);
1724 printk(KERN_ERR
"alg: aead: Failed to load transform for %s: "
1725 "%ld\n", driver
, PTR_ERR(tfm
));
1726 return PTR_ERR(tfm
);
1729 if (desc
->suite
.aead
.enc
.vecs
) {
1730 err
= test_aead(tfm
, ENCRYPT
, desc
->suite
.aead
.enc
.vecs
,
1731 desc
->suite
.aead
.enc
.count
);
1736 if (!err
&& desc
->suite
.aead
.dec
.vecs
)
1737 err
= test_aead(tfm
, DECRYPT
, desc
->suite
.aead
.dec
.vecs
,
1738 desc
->suite
.aead
.dec
.count
);
1741 crypto_free_aead(tfm
);
1745 static int alg_test_cipher(const struct alg_test_desc
*desc
,
1746 const char *driver
, u32 type
, u32 mask
)
1748 const struct cipher_test_suite
*suite
= &desc
->suite
.cipher
;
1749 struct crypto_cipher
*tfm
;
1752 tfm
= crypto_alloc_cipher(driver
, type
, mask
);
1754 printk(KERN_ERR
"alg: cipher: Failed to load transform for "
1755 "%s: %ld\n", driver
, PTR_ERR(tfm
));
1756 return PTR_ERR(tfm
);
1759 err
= test_cipher(tfm
, ENCRYPT
, suite
->vecs
, suite
->count
);
1761 err
= test_cipher(tfm
, DECRYPT
, suite
->vecs
, suite
->count
);
1763 crypto_free_cipher(tfm
);
1767 static int alg_test_skcipher(const struct alg_test_desc
*desc
,
1768 const char *driver
, u32 type
, u32 mask
)
1770 const struct cipher_test_suite
*suite
= &desc
->suite
.cipher
;
1771 struct crypto_skcipher
*tfm
;
1774 tfm
= crypto_alloc_skcipher(driver
, type
, mask
);
1776 printk(KERN_ERR
"alg: skcipher: Failed to load transform for "
1777 "%s: %ld\n", driver
, PTR_ERR(tfm
));
1778 return PTR_ERR(tfm
);
1781 err
= test_skcipher(tfm
, ENCRYPT
, suite
->vecs
, suite
->count
);
1783 err
= test_skcipher(tfm
, DECRYPT
, suite
->vecs
, suite
->count
);
1785 crypto_free_skcipher(tfm
);
1789 static int alg_test_comp(const struct alg_test_desc
*desc
, const char *driver
,
1792 struct crypto_comp
*comp
;
1793 struct crypto_acomp
*acomp
;
1795 u32 algo_type
= type
& CRYPTO_ALG_TYPE_ACOMPRESS_MASK
;
1797 if (algo_type
== CRYPTO_ALG_TYPE_ACOMPRESS
) {
1798 acomp
= crypto_alloc_acomp(driver
, type
, mask
);
1799 if (IS_ERR(acomp
)) {
1800 pr_err("alg: acomp: Failed to load transform for %s: %ld\n",
1801 driver
, PTR_ERR(acomp
));
1802 return PTR_ERR(acomp
);
1804 err
= test_acomp(acomp
, desc
->suite
.comp
.comp
.vecs
,
1805 desc
->suite
.comp
.decomp
.vecs
,
1806 desc
->suite
.comp
.comp
.count
,
1807 desc
->suite
.comp
.decomp
.count
);
1808 crypto_free_acomp(acomp
);
1810 comp
= crypto_alloc_comp(driver
, type
, mask
);
1812 pr_err("alg: comp: Failed to load transform for %s: %ld\n",
1813 driver
, PTR_ERR(comp
));
1814 return PTR_ERR(comp
);
1817 err
= test_comp(comp
, desc
->suite
.comp
.comp
.vecs
,
1818 desc
->suite
.comp
.decomp
.vecs
,
1819 desc
->suite
.comp
.comp
.count
,
1820 desc
->suite
.comp
.decomp
.count
);
1822 crypto_free_comp(comp
);
1827 static int __alg_test_hash(const struct hash_testvec
*template,
1828 unsigned int tcount
, const char *driver
,
1831 struct crypto_ahash
*tfm
;
1834 tfm
= crypto_alloc_ahash(driver
, type
, mask
);
1836 printk(KERN_ERR
"alg: hash: Failed to load transform for %s: "
1837 "%ld\n", driver
, PTR_ERR(tfm
));
1838 return PTR_ERR(tfm
);
1841 err
= test_hash(tfm
, template, tcount
, HASH_TEST_DIGEST
);
1843 err
= test_hash(tfm
, template, tcount
, HASH_TEST_FINAL
);
1845 err
= test_hash(tfm
, template, tcount
, HASH_TEST_FINUP
);
1846 crypto_free_ahash(tfm
);
1850 static int alg_test_hash(const struct alg_test_desc
*desc
, const char *driver
,
1853 const struct hash_testvec
*template = desc
->suite
.hash
.vecs
;
1854 unsigned int tcount
= desc
->suite
.hash
.count
;
1855 unsigned int nr_unkeyed
, nr_keyed
;
1859 * For OPTIONAL_KEY algorithms, we have to do all the unkeyed tests
1860 * first, before setting a key on the tfm. To make this easier, we
1861 * require that the unkeyed test vectors (if any) are listed first.
1864 for (nr_unkeyed
= 0; nr_unkeyed
< tcount
; nr_unkeyed
++) {
1865 if (template[nr_unkeyed
].ksize
)
1868 for (nr_keyed
= 0; nr_unkeyed
+ nr_keyed
< tcount
; nr_keyed
++) {
1869 if (!template[nr_unkeyed
+ nr_keyed
].ksize
) {
1870 pr_err("alg: hash: test vectors for %s out of order, "
1871 "unkeyed ones must come first\n", desc
->alg
);
1878 err
= __alg_test_hash(template, nr_unkeyed
, driver
, type
, mask
);
1879 template += nr_unkeyed
;
1882 if (!err
&& nr_keyed
)
1883 err
= __alg_test_hash(template, nr_keyed
, driver
, type
, mask
);
1888 static int alg_test_crc32c(const struct alg_test_desc
*desc
,
1889 const char *driver
, u32 type
, u32 mask
)
1891 struct crypto_shash
*tfm
;
1895 err
= alg_test_hash(desc
, driver
, type
, mask
);
1899 tfm
= crypto_alloc_shash(driver
, type
, mask
);
1901 printk(KERN_ERR
"alg: crc32c: Failed to load transform for %s: "
1902 "%ld\n", driver
, PTR_ERR(tfm
));
1908 SHASH_DESC_ON_STACK(shash
, tfm
);
1909 u32
*ctx
= (u32
*)shash_desc_ctx(shash
);
1914 *ctx
= le32_to_cpu(420553207);
1915 err
= crypto_shash_final(shash
, (u8
*)&val
);
1917 printk(KERN_ERR
"alg: crc32c: Operation failed for "
1918 "%s: %d\n", driver
, err
);
1922 if (val
!= ~420553207) {
1923 printk(KERN_ERR
"alg: crc32c: Test failed for %s: "
1924 "%d\n", driver
, val
);
1929 crypto_free_shash(tfm
);
1935 static int alg_test_cprng(const struct alg_test_desc
*desc
, const char *driver
,
1938 struct crypto_rng
*rng
;
1941 rng
= crypto_alloc_rng(driver
, type
, mask
);
1943 printk(KERN_ERR
"alg: cprng: Failed to load transform for %s: "
1944 "%ld\n", driver
, PTR_ERR(rng
));
1945 return PTR_ERR(rng
);
1948 err
= test_cprng(rng
, desc
->suite
.cprng
.vecs
, desc
->suite
.cprng
.count
);
1950 crypto_free_rng(rng
);
1956 static int drbg_cavs_test(const struct drbg_testvec
*test
, int pr
,
1957 const char *driver
, u32 type
, u32 mask
)
1960 struct crypto_rng
*drng
;
1961 struct drbg_test_data test_data
;
1962 struct drbg_string addtl
, pers
, testentropy
;
1963 unsigned char *buf
= kzalloc(test
->expectedlen
, GFP_KERNEL
);
1968 drng
= crypto_alloc_rng(driver
, type
, mask
);
1970 printk(KERN_ERR
"alg: drbg: could not allocate DRNG handle for "
1976 test_data
.testentropy
= &testentropy
;
1977 drbg_string_fill(&testentropy
, test
->entropy
, test
->entropylen
);
1978 drbg_string_fill(&pers
, test
->pers
, test
->perslen
);
1979 ret
= crypto_drbg_reset_test(drng
, &pers
, &test_data
);
1981 printk(KERN_ERR
"alg: drbg: Failed to reset rng\n");
1985 drbg_string_fill(&addtl
, test
->addtla
, test
->addtllen
);
1987 drbg_string_fill(&testentropy
, test
->entpra
, test
->entprlen
);
1988 ret
= crypto_drbg_get_bytes_addtl_test(drng
,
1989 buf
, test
->expectedlen
, &addtl
, &test_data
);
1991 ret
= crypto_drbg_get_bytes_addtl(drng
,
1992 buf
, test
->expectedlen
, &addtl
);
1995 printk(KERN_ERR
"alg: drbg: could not obtain random data for "
1996 "driver %s\n", driver
);
2000 drbg_string_fill(&addtl
, test
->addtlb
, test
->addtllen
);
2002 drbg_string_fill(&testentropy
, test
->entprb
, test
->entprlen
);
2003 ret
= crypto_drbg_get_bytes_addtl_test(drng
,
2004 buf
, test
->expectedlen
, &addtl
, &test_data
);
2006 ret
= crypto_drbg_get_bytes_addtl(drng
,
2007 buf
, test
->expectedlen
, &addtl
);
2010 printk(KERN_ERR
"alg: drbg: could not obtain random data for "
2011 "driver %s\n", driver
);
2015 ret
= memcmp(test
->expected
, buf
, test
->expectedlen
);
2018 crypto_free_rng(drng
);
2024 static int alg_test_drbg(const struct alg_test_desc
*desc
, const char *driver
,
2030 const struct drbg_testvec
*template = desc
->suite
.drbg
.vecs
;
2031 unsigned int tcount
= desc
->suite
.drbg
.count
;
2033 if (0 == memcmp(driver
, "drbg_pr_", 8))
2036 for (i
= 0; i
< tcount
; i
++) {
2037 err
= drbg_cavs_test(&template[i
], pr
, driver
, type
, mask
);
2039 printk(KERN_ERR
"alg: drbg: Test %d failed for %s\n",
2049 static int do_test_kpp(struct crypto_kpp
*tfm
, const struct kpp_testvec
*vec
,
2052 struct kpp_request
*req
;
2053 void *input_buf
= NULL
;
2054 void *output_buf
= NULL
;
2055 void *a_public
= NULL
;
2057 void *shared_secret
= NULL
;
2058 struct crypto_wait wait
;
2059 unsigned int out_len_max
;
2061 struct scatterlist src
, dst
;
2063 req
= kpp_request_alloc(tfm
, GFP_KERNEL
);
2067 crypto_init_wait(&wait
);
2069 err
= crypto_kpp_set_secret(tfm
, vec
->secret
, vec
->secret_size
);
2073 out_len_max
= crypto_kpp_maxsize(tfm
);
2074 output_buf
= kzalloc(out_len_max
, GFP_KERNEL
);
2080 /* Use appropriate parameter as base */
2081 kpp_request_set_input(req
, NULL
, 0);
2082 sg_init_one(&dst
, output_buf
, out_len_max
);
2083 kpp_request_set_output(req
, &dst
, out_len_max
);
2084 kpp_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
2085 crypto_req_done
, &wait
);
2087 /* Compute party A's public key */
2088 err
= crypto_wait_req(crypto_kpp_generate_public_key(req
), &wait
);
2090 pr_err("alg: %s: Party A: generate public key test failed. err %d\n",
2096 /* Save party A's public key */
2097 a_public
= kzalloc(out_len_max
, GFP_KERNEL
);
2102 memcpy(a_public
, sg_virt(req
->dst
), out_len_max
);
2104 /* Verify calculated public key */
2105 if (memcmp(vec
->expected_a_public
, sg_virt(req
->dst
),
2106 vec
->expected_a_public_size
)) {
2107 pr_err("alg: %s: Party A: generate public key test failed. Invalid output\n",
2114 /* Calculate shared secret key by using counter part (b) public key. */
2115 input_buf
= kzalloc(vec
->b_public_size
, GFP_KERNEL
);
2121 memcpy(input_buf
, vec
->b_public
, vec
->b_public_size
);
2122 sg_init_one(&src
, input_buf
, vec
->b_public_size
);
2123 sg_init_one(&dst
, output_buf
, out_len_max
);
2124 kpp_request_set_input(req
, &src
, vec
->b_public_size
);
2125 kpp_request_set_output(req
, &dst
, out_len_max
);
2126 kpp_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
2127 crypto_req_done
, &wait
);
2128 err
= crypto_wait_req(crypto_kpp_compute_shared_secret(req
), &wait
);
2130 pr_err("alg: %s: Party A: compute shared secret test failed. err %d\n",
2136 /* Save the shared secret obtained by party A */
2137 a_ss
= kzalloc(vec
->expected_ss_size
, GFP_KERNEL
);
2142 memcpy(a_ss
, sg_virt(req
->dst
), vec
->expected_ss_size
);
2145 * Calculate party B's shared secret by using party A's
2148 err
= crypto_kpp_set_secret(tfm
, vec
->b_secret
,
2149 vec
->b_secret_size
);
2153 sg_init_one(&src
, a_public
, vec
->expected_a_public_size
);
2154 sg_init_one(&dst
, output_buf
, out_len_max
);
2155 kpp_request_set_input(req
, &src
, vec
->expected_a_public_size
);
2156 kpp_request_set_output(req
, &dst
, out_len_max
);
2157 kpp_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
2158 crypto_req_done
, &wait
);
2159 err
= crypto_wait_req(crypto_kpp_compute_shared_secret(req
),
2162 pr_err("alg: %s: Party B: compute shared secret failed. err %d\n",
2167 shared_secret
= a_ss
;
2169 shared_secret
= (void *)vec
->expected_ss
;
2173 * verify shared secret from which the user will derive
2174 * secret key by executing whatever hash it has chosen
2176 if (memcmp(shared_secret
, sg_virt(req
->dst
),
2177 vec
->expected_ss_size
)) {
2178 pr_err("alg: %s: compute shared secret test failed. Invalid output\n",
2190 kpp_request_free(req
);
2194 static int test_kpp(struct crypto_kpp
*tfm
, const char *alg
,
2195 const struct kpp_testvec
*vecs
, unsigned int tcount
)
2199 for (i
= 0; i
< tcount
; i
++) {
2200 ret
= do_test_kpp(tfm
, vecs
++, alg
);
2202 pr_err("alg: %s: test failed on vector %d, err=%d\n",
2210 static int alg_test_kpp(const struct alg_test_desc
*desc
, const char *driver
,
2213 struct crypto_kpp
*tfm
;
2216 tfm
= crypto_alloc_kpp(driver
, type
, mask
);
2218 pr_err("alg: kpp: Failed to load tfm for %s: %ld\n",
2219 driver
, PTR_ERR(tfm
));
2220 return PTR_ERR(tfm
);
2222 if (desc
->suite
.kpp
.vecs
)
2223 err
= test_kpp(tfm
, desc
->alg
, desc
->suite
.kpp
.vecs
,
2224 desc
->suite
.kpp
.count
);
2226 crypto_free_kpp(tfm
);
2230 static int test_akcipher_one(struct crypto_akcipher
*tfm
,
2231 const struct akcipher_testvec
*vecs
)
2233 char *xbuf
[XBUFSIZE
];
2234 struct akcipher_request
*req
;
2235 void *outbuf_enc
= NULL
;
2236 void *outbuf_dec
= NULL
;
2237 struct crypto_wait wait
;
2238 unsigned int out_len_max
, out_len
= 0;
2240 struct scatterlist src
, dst
, src_tab
[2];
2242 if (testmgr_alloc_buf(xbuf
))
2245 req
= akcipher_request_alloc(tfm
, GFP_KERNEL
);
2249 crypto_init_wait(&wait
);
2251 if (vecs
->public_key_vec
)
2252 err
= crypto_akcipher_set_pub_key(tfm
, vecs
->key
,
2255 err
= crypto_akcipher_set_priv_key(tfm
, vecs
->key
,
2261 out_len_max
= crypto_akcipher_maxsize(tfm
);
2262 outbuf_enc
= kzalloc(out_len_max
, GFP_KERNEL
);
2266 if (WARN_ON(vecs
->m_size
> PAGE_SIZE
))
2269 memcpy(xbuf
[0], vecs
->m
, vecs
->m_size
);
2271 sg_init_table(src_tab
, 2);
2272 sg_set_buf(&src_tab
[0], xbuf
[0], 8);
2273 sg_set_buf(&src_tab
[1], xbuf
[0] + 8, vecs
->m_size
- 8);
2274 sg_init_one(&dst
, outbuf_enc
, out_len_max
);
2275 akcipher_request_set_crypt(req
, src_tab
, &dst
, vecs
->m_size
,
2277 akcipher_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
2278 crypto_req_done
, &wait
);
2280 err
= crypto_wait_req(vecs
->siggen_sigver_test
?
2281 /* Run asymmetric signature generation */
2282 crypto_akcipher_sign(req
) :
2283 /* Run asymmetric encrypt */
2284 crypto_akcipher_encrypt(req
), &wait
);
2286 pr_err("alg: akcipher: encrypt test failed. err %d\n", err
);
2289 if (req
->dst_len
!= vecs
->c_size
) {
2290 pr_err("alg: akcipher: encrypt test failed. Invalid output len\n");
2294 /* verify that encrypted message is equal to expected */
2295 if (memcmp(vecs
->c
, outbuf_enc
, vecs
->c_size
)) {
2296 pr_err("alg: akcipher: encrypt test failed. Invalid output\n");
2297 hexdump(outbuf_enc
, vecs
->c_size
);
2301 /* Don't invoke decrypt for vectors with public key */
2302 if (vecs
->public_key_vec
) {
2306 outbuf_dec
= kzalloc(out_len_max
, GFP_KERNEL
);
2312 if (WARN_ON(vecs
->c_size
> PAGE_SIZE
))
2315 memcpy(xbuf
[0], vecs
->c
, vecs
->c_size
);
2317 sg_init_one(&src
, xbuf
[0], vecs
->c_size
);
2318 sg_init_one(&dst
, outbuf_dec
, out_len_max
);
2319 crypto_init_wait(&wait
);
2320 akcipher_request_set_crypt(req
, &src
, &dst
, vecs
->c_size
, out_len_max
);
2322 err
= crypto_wait_req(vecs
->siggen_sigver_test
?
2323 /* Run asymmetric signature verification */
2324 crypto_akcipher_verify(req
) :
2325 /* Run asymmetric decrypt */
2326 crypto_akcipher_decrypt(req
), &wait
);
2328 pr_err("alg: akcipher: decrypt test failed. err %d\n", err
);
2331 out_len
= req
->dst_len
;
2332 if (out_len
< vecs
->m_size
) {
2333 pr_err("alg: akcipher: decrypt test failed. "
2334 "Invalid output len %u\n", out_len
);
2338 /* verify that decrypted message is equal to the original msg */
2339 if (memchr_inv(outbuf_dec
, 0, out_len
- vecs
->m_size
) ||
2340 memcmp(vecs
->m
, outbuf_dec
+ out_len
- vecs
->m_size
,
2342 pr_err("alg: akcipher: decrypt test failed. Invalid output\n");
2343 hexdump(outbuf_dec
, out_len
);
2350 akcipher_request_free(req
);
2352 testmgr_free_buf(xbuf
);
2356 static int test_akcipher(struct crypto_akcipher
*tfm
, const char *alg
,
2357 const struct akcipher_testvec
*vecs
,
2358 unsigned int tcount
)
2361 crypto_tfm_alg_driver_name(crypto_akcipher_tfm(tfm
));
2364 for (i
= 0; i
< tcount
; i
++) {
2365 ret
= test_akcipher_one(tfm
, vecs
++);
2369 pr_err("alg: akcipher: test %d failed for %s, err=%d\n",
2376 static int alg_test_akcipher(const struct alg_test_desc
*desc
,
2377 const char *driver
, u32 type
, u32 mask
)
2379 struct crypto_akcipher
*tfm
;
2382 tfm
= crypto_alloc_akcipher(driver
, type
, mask
);
2384 pr_err("alg: akcipher: Failed to load tfm for %s: %ld\n",
2385 driver
, PTR_ERR(tfm
));
2386 return PTR_ERR(tfm
);
2388 if (desc
->suite
.akcipher
.vecs
)
2389 err
= test_akcipher(tfm
, desc
->alg
, desc
->suite
.akcipher
.vecs
,
2390 desc
->suite
.akcipher
.count
);
2392 crypto_free_akcipher(tfm
);
2396 static int alg_test_null(const struct alg_test_desc
*desc
,
2397 const char *driver
, u32 type
, u32 mask
)
2402 #define __VECS(tv) { .vecs = tv, .count = ARRAY_SIZE(tv) }
2404 /* Please keep this list sorted by algorithm name. */
2405 static const struct alg_test_desc alg_test_descs
[] = {
2408 .test
= alg_test_aead
,
2411 .enc
= __VECS(aegis128_enc_tv_template
),
2412 .dec
= __VECS(aegis128_dec_tv_template
),
2417 .test
= alg_test_aead
,
2420 .enc
= __VECS(aegis128l_enc_tv_template
),
2421 .dec
= __VECS(aegis128l_dec_tv_template
),
2426 .test
= alg_test_aead
,
2429 .enc
= __VECS(aegis256_enc_tv_template
),
2430 .dec
= __VECS(aegis256_dec_tv_template
),
2434 .alg
= "ansi_cprng",
2435 .test
= alg_test_cprng
,
2437 .cprng
= __VECS(ansi_cprng_aes_tv_template
)
2440 .alg
= "authenc(hmac(md5),ecb(cipher_null))",
2441 .test
= alg_test_aead
,
2444 .enc
= __VECS(hmac_md5_ecb_cipher_null_enc_tv_template
),
2445 .dec
= __VECS(hmac_md5_ecb_cipher_null_dec_tv_template
)
2449 .alg
= "authenc(hmac(sha1),cbc(aes))",
2450 .test
= alg_test_aead
,
2454 .enc
= __VECS(hmac_sha1_aes_cbc_enc_tv_temp
)
2458 .alg
= "authenc(hmac(sha1),cbc(des))",
2459 .test
= alg_test_aead
,
2462 .enc
= __VECS(hmac_sha1_des_cbc_enc_tv_temp
)
2466 .alg
= "authenc(hmac(sha1),cbc(des3_ede))",
2467 .test
= alg_test_aead
,
2471 .enc
= __VECS(hmac_sha1_des3_ede_cbc_enc_tv_temp
)
2475 .alg
= "authenc(hmac(sha1),ctr(aes))",
2476 .test
= alg_test_null
,
2479 .alg
= "authenc(hmac(sha1),ecb(cipher_null))",
2480 .test
= alg_test_aead
,
2483 .enc
= __VECS(hmac_sha1_ecb_cipher_null_enc_tv_temp
),
2484 .dec
= __VECS(hmac_sha1_ecb_cipher_null_dec_tv_temp
)
2488 .alg
= "authenc(hmac(sha1),rfc3686(ctr(aes)))",
2489 .test
= alg_test_null
,
2492 .alg
= "authenc(hmac(sha224),cbc(des))",
2493 .test
= alg_test_aead
,
2496 .enc
= __VECS(hmac_sha224_des_cbc_enc_tv_temp
)
2500 .alg
= "authenc(hmac(sha224),cbc(des3_ede))",
2501 .test
= alg_test_aead
,
2505 .enc
= __VECS(hmac_sha224_des3_ede_cbc_enc_tv_temp
)
2509 .alg
= "authenc(hmac(sha256),cbc(aes))",
2510 .test
= alg_test_aead
,
2514 .enc
= __VECS(hmac_sha256_aes_cbc_enc_tv_temp
)
2518 .alg
= "authenc(hmac(sha256),cbc(des))",
2519 .test
= alg_test_aead
,
2522 .enc
= __VECS(hmac_sha256_des_cbc_enc_tv_temp
)
2526 .alg
= "authenc(hmac(sha256),cbc(des3_ede))",
2527 .test
= alg_test_aead
,
2531 .enc
= __VECS(hmac_sha256_des3_ede_cbc_enc_tv_temp
)
2535 .alg
= "authenc(hmac(sha256),ctr(aes))",
2536 .test
= alg_test_null
,
2539 .alg
= "authenc(hmac(sha256),rfc3686(ctr(aes)))",
2540 .test
= alg_test_null
,
2543 .alg
= "authenc(hmac(sha384),cbc(des))",
2544 .test
= alg_test_aead
,
2547 .enc
= __VECS(hmac_sha384_des_cbc_enc_tv_temp
)
2551 .alg
= "authenc(hmac(sha384),cbc(des3_ede))",
2552 .test
= alg_test_aead
,
2556 .enc
= __VECS(hmac_sha384_des3_ede_cbc_enc_tv_temp
)
2560 .alg
= "authenc(hmac(sha384),ctr(aes))",
2561 .test
= alg_test_null
,
2564 .alg
= "authenc(hmac(sha384),rfc3686(ctr(aes)))",
2565 .test
= alg_test_null
,
2568 .alg
= "authenc(hmac(sha512),cbc(aes))",
2570 .test
= alg_test_aead
,
2573 .enc
= __VECS(hmac_sha512_aes_cbc_enc_tv_temp
)
2577 .alg
= "authenc(hmac(sha512),cbc(des))",
2578 .test
= alg_test_aead
,
2581 .enc
= __VECS(hmac_sha512_des_cbc_enc_tv_temp
)
2585 .alg
= "authenc(hmac(sha512),cbc(des3_ede))",
2586 .test
= alg_test_aead
,
2590 .enc
= __VECS(hmac_sha512_des3_ede_cbc_enc_tv_temp
)
2594 .alg
= "authenc(hmac(sha512),ctr(aes))",
2595 .test
= alg_test_null
,
2598 .alg
= "authenc(hmac(sha512),rfc3686(ctr(aes)))",
2599 .test
= alg_test_null
,
2603 .test
= alg_test_skcipher
,
2606 .cipher
= __VECS(aes_cbc_tv_template
)
2609 .alg
= "cbc(anubis)",
2610 .test
= alg_test_skcipher
,
2612 .cipher
= __VECS(anubis_cbc_tv_template
)
2615 .alg
= "cbc(blowfish)",
2616 .test
= alg_test_skcipher
,
2618 .cipher
= __VECS(bf_cbc_tv_template
)
2621 .alg
= "cbc(camellia)",
2622 .test
= alg_test_skcipher
,
2624 .cipher
= __VECS(camellia_cbc_tv_template
)
2627 .alg
= "cbc(cast5)",
2628 .test
= alg_test_skcipher
,
2630 .cipher
= __VECS(cast5_cbc_tv_template
)
2633 .alg
= "cbc(cast6)",
2634 .test
= alg_test_skcipher
,
2636 .cipher
= __VECS(cast6_cbc_tv_template
)
2640 .test
= alg_test_skcipher
,
2642 .cipher
= __VECS(des_cbc_tv_template
)
2645 .alg
= "cbc(des3_ede)",
2646 .test
= alg_test_skcipher
,
2649 .cipher
= __VECS(des3_ede_cbc_tv_template
)
2652 /* Same as cbc(aes) except the key is stored in
2653 * hardware secure memory which we reference by index
2656 .test
= alg_test_null
,
2659 .alg
= "cbc(serpent)",
2660 .test
= alg_test_skcipher
,
2662 .cipher
= __VECS(serpent_cbc_tv_template
)
2666 .test
= alg_test_skcipher
,
2668 .cipher
= __VECS(sm4_cbc_tv_template
)
2671 .alg
= "cbc(twofish)",
2672 .test
= alg_test_skcipher
,
2674 .cipher
= __VECS(tf_cbc_tv_template
)
2677 .alg
= "cbcmac(aes)",
2679 .test
= alg_test_hash
,
2681 .hash
= __VECS(aes_cbcmac_tv_template
)
2685 .test
= alg_test_aead
,
2689 .enc
= __VECS(aes_ccm_enc_tv_template
),
2690 .dec
= __VECS(aes_ccm_dec_tv_template
)
2695 .test
= alg_test_skcipher
,
2698 .cipher
= __VECS(aes_cfb_tv_template
)
2702 .test
= alg_test_skcipher
,
2704 .cipher
= __VECS(chacha20_tv_template
)
2709 .test
= alg_test_hash
,
2711 .hash
= __VECS(aes_cmac128_tv_template
)
2714 .alg
= "cmac(des3_ede)",
2716 .test
= alg_test_hash
,
2718 .hash
= __VECS(des3_ede_cmac64_tv_template
)
2721 .alg
= "compress_null",
2722 .test
= alg_test_null
,
2725 .test
= alg_test_hash
,
2727 .hash
= __VECS(crc32_tv_template
)
2731 .test
= alg_test_crc32c
,
2734 .hash
= __VECS(crc32c_tv_template
)
2738 .test
= alg_test_hash
,
2741 .hash
= __VECS(crct10dif_tv_template
)
2745 .test
= alg_test_skcipher
,
2748 .cipher
= __VECS(aes_ctr_tv_template
)
2751 .alg
= "ctr(blowfish)",
2752 .test
= alg_test_skcipher
,
2754 .cipher
= __VECS(bf_ctr_tv_template
)
2757 .alg
= "ctr(camellia)",
2758 .test
= alg_test_skcipher
,
2760 .cipher
= __VECS(camellia_ctr_tv_template
)
2763 .alg
= "ctr(cast5)",
2764 .test
= alg_test_skcipher
,
2766 .cipher
= __VECS(cast5_ctr_tv_template
)
2769 .alg
= "ctr(cast6)",
2770 .test
= alg_test_skcipher
,
2772 .cipher
= __VECS(cast6_ctr_tv_template
)
2776 .test
= alg_test_skcipher
,
2778 .cipher
= __VECS(des_ctr_tv_template
)
2781 .alg
= "ctr(des3_ede)",
2782 .test
= alg_test_skcipher
,
2785 .cipher
= __VECS(des3_ede_ctr_tv_template
)
2788 /* Same as ctr(aes) except the key is stored in
2789 * hardware secure memory which we reference by index
2792 .test
= alg_test_null
,
2795 .alg
= "ctr(serpent)",
2796 .test
= alg_test_skcipher
,
2798 .cipher
= __VECS(serpent_ctr_tv_template
)
2802 .test
= alg_test_skcipher
,
2804 .cipher
= __VECS(sm4_ctr_tv_template
)
2807 .alg
= "ctr(twofish)",
2808 .test
= alg_test_skcipher
,
2810 .cipher
= __VECS(tf_ctr_tv_template
)
2813 .alg
= "cts(cbc(aes))",
2814 .test
= alg_test_skcipher
,
2817 .cipher
= __VECS(cts_mode_tv_template
)
2821 .test
= alg_test_comp
,
2825 .comp
= __VECS(deflate_comp_tv_template
),
2826 .decomp
= __VECS(deflate_decomp_tv_template
)
2831 .test
= alg_test_kpp
,
2834 .kpp
= __VECS(dh_tv_template
)
2837 .alg
= "digest_null",
2838 .test
= alg_test_null
,
2840 .alg
= "drbg_nopr_ctr_aes128",
2841 .test
= alg_test_drbg
,
2844 .drbg
= __VECS(drbg_nopr_ctr_aes128_tv_template
)
2847 .alg
= "drbg_nopr_ctr_aes192",
2848 .test
= alg_test_drbg
,
2851 .drbg
= __VECS(drbg_nopr_ctr_aes192_tv_template
)
2854 .alg
= "drbg_nopr_ctr_aes256",
2855 .test
= alg_test_drbg
,
2858 .drbg
= __VECS(drbg_nopr_ctr_aes256_tv_template
)
2862 * There is no need to specifically test the DRBG with every
2863 * backend cipher -- covered by drbg_nopr_hmac_sha256 test
2865 .alg
= "drbg_nopr_hmac_sha1",
2867 .test
= alg_test_null
,
2869 .alg
= "drbg_nopr_hmac_sha256",
2870 .test
= alg_test_drbg
,
2873 .drbg
= __VECS(drbg_nopr_hmac_sha256_tv_template
)
2876 /* covered by drbg_nopr_hmac_sha256 test */
2877 .alg
= "drbg_nopr_hmac_sha384",
2879 .test
= alg_test_null
,
2881 .alg
= "drbg_nopr_hmac_sha512",
2882 .test
= alg_test_null
,
2885 .alg
= "drbg_nopr_sha1",
2887 .test
= alg_test_null
,
2889 .alg
= "drbg_nopr_sha256",
2890 .test
= alg_test_drbg
,
2893 .drbg
= __VECS(drbg_nopr_sha256_tv_template
)
2896 /* covered by drbg_nopr_sha256 test */
2897 .alg
= "drbg_nopr_sha384",
2899 .test
= alg_test_null
,
2901 .alg
= "drbg_nopr_sha512",
2903 .test
= alg_test_null
,
2905 .alg
= "drbg_pr_ctr_aes128",
2906 .test
= alg_test_drbg
,
2909 .drbg
= __VECS(drbg_pr_ctr_aes128_tv_template
)
2912 /* covered by drbg_pr_ctr_aes128 test */
2913 .alg
= "drbg_pr_ctr_aes192",
2915 .test
= alg_test_null
,
2917 .alg
= "drbg_pr_ctr_aes256",
2919 .test
= alg_test_null
,
2921 .alg
= "drbg_pr_hmac_sha1",
2923 .test
= alg_test_null
,
2925 .alg
= "drbg_pr_hmac_sha256",
2926 .test
= alg_test_drbg
,
2929 .drbg
= __VECS(drbg_pr_hmac_sha256_tv_template
)
2932 /* covered by drbg_pr_hmac_sha256 test */
2933 .alg
= "drbg_pr_hmac_sha384",
2935 .test
= alg_test_null
,
2937 .alg
= "drbg_pr_hmac_sha512",
2938 .test
= alg_test_null
,
2941 .alg
= "drbg_pr_sha1",
2943 .test
= alg_test_null
,
2945 .alg
= "drbg_pr_sha256",
2946 .test
= alg_test_drbg
,
2949 .drbg
= __VECS(drbg_pr_sha256_tv_template
)
2952 /* covered by drbg_pr_sha256 test */
2953 .alg
= "drbg_pr_sha384",
2955 .test
= alg_test_null
,
2957 .alg
= "drbg_pr_sha512",
2959 .test
= alg_test_null
,
2962 .test
= alg_test_skcipher
,
2965 .cipher
= __VECS(aes_tv_template
)
2968 .alg
= "ecb(anubis)",
2969 .test
= alg_test_skcipher
,
2971 .cipher
= __VECS(anubis_tv_template
)
2975 .test
= alg_test_skcipher
,
2977 .cipher
= __VECS(arc4_tv_template
)
2980 .alg
= "ecb(blowfish)",
2981 .test
= alg_test_skcipher
,
2983 .cipher
= __VECS(bf_tv_template
)
2986 .alg
= "ecb(camellia)",
2987 .test
= alg_test_skcipher
,
2989 .cipher
= __VECS(camellia_tv_template
)
2992 .alg
= "ecb(cast5)",
2993 .test
= alg_test_skcipher
,
2995 .cipher
= __VECS(cast5_tv_template
)
2998 .alg
= "ecb(cast6)",
2999 .test
= alg_test_skcipher
,
3001 .cipher
= __VECS(cast6_tv_template
)
3004 .alg
= "ecb(cipher_null)",
3005 .test
= alg_test_null
,
3009 .test
= alg_test_skcipher
,
3011 .cipher
= __VECS(des_tv_template
)
3014 .alg
= "ecb(des3_ede)",
3015 .test
= alg_test_skcipher
,
3018 .cipher
= __VECS(des3_ede_tv_template
)
3021 .alg
= "ecb(fcrypt)",
3022 .test
= alg_test_skcipher
,
3025 .vecs
= fcrypt_pcbc_tv_template
,
3030 .alg
= "ecb(khazad)",
3031 .test
= alg_test_skcipher
,
3033 .cipher
= __VECS(khazad_tv_template
)
3036 /* Same as ecb(aes) except the key is stored in
3037 * hardware secure memory which we reference by index
3040 .test
= alg_test_null
,
3044 .test
= alg_test_skcipher
,
3046 .cipher
= __VECS(seed_tv_template
)
3049 .alg
= "ecb(serpent)",
3050 .test
= alg_test_skcipher
,
3052 .cipher
= __VECS(serpent_tv_template
)
3056 .test
= alg_test_skcipher
,
3058 .cipher
= __VECS(sm4_tv_template
)
3062 .test
= alg_test_skcipher
,
3064 .cipher
= __VECS(tea_tv_template
)
3067 .alg
= "ecb(tnepres)",
3068 .test
= alg_test_skcipher
,
3070 .cipher
= __VECS(tnepres_tv_template
)
3073 .alg
= "ecb(twofish)",
3074 .test
= alg_test_skcipher
,
3076 .cipher
= __VECS(tf_tv_template
)
3080 .test
= alg_test_skcipher
,
3082 .cipher
= __VECS(xeta_tv_template
)
3086 .test
= alg_test_skcipher
,
3088 .cipher
= __VECS(xtea_tv_template
)
3092 .test
= alg_test_kpp
,
3095 .kpp
= __VECS(ecdh_tv_template
)
3099 .test
= alg_test_aead
,
3103 .enc
= __VECS(aes_gcm_enc_tv_template
),
3104 .dec
= __VECS(aes_gcm_dec_tv_template
)
3109 .test
= alg_test_hash
,
3112 .hash
= __VECS(ghash_tv_template
)
3116 .test
= alg_test_hash
,
3118 .hash
= __VECS(hmac_md5_tv_template
)
3121 .alg
= "hmac(rmd128)",
3122 .test
= alg_test_hash
,
3124 .hash
= __VECS(hmac_rmd128_tv_template
)
3127 .alg
= "hmac(rmd160)",
3128 .test
= alg_test_hash
,
3130 .hash
= __VECS(hmac_rmd160_tv_template
)
3133 .alg
= "hmac(sha1)",
3134 .test
= alg_test_hash
,
3137 .hash
= __VECS(hmac_sha1_tv_template
)
3140 .alg
= "hmac(sha224)",
3141 .test
= alg_test_hash
,
3144 .hash
= __VECS(hmac_sha224_tv_template
)
3147 .alg
= "hmac(sha256)",
3148 .test
= alg_test_hash
,
3151 .hash
= __VECS(hmac_sha256_tv_template
)
3154 .alg
= "hmac(sha3-224)",
3155 .test
= alg_test_hash
,
3158 .hash
= __VECS(hmac_sha3_224_tv_template
)
3161 .alg
= "hmac(sha3-256)",
3162 .test
= alg_test_hash
,
3165 .hash
= __VECS(hmac_sha3_256_tv_template
)
3168 .alg
= "hmac(sha3-384)",
3169 .test
= alg_test_hash
,
3172 .hash
= __VECS(hmac_sha3_384_tv_template
)
3175 .alg
= "hmac(sha3-512)",
3176 .test
= alg_test_hash
,
3179 .hash
= __VECS(hmac_sha3_512_tv_template
)
3182 .alg
= "hmac(sha384)",
3183 .test
= alg_test_hash
,
3186 .hash
= __VECS(hmac_sha384_tv_template
)
3189 .alg
= "hmac(sha512)",
3190 .test
= alg_test_hash
,
3193 .hash
= __VECS(hmac_sha512_tv_template
)
3196 .alg
= "hmac(streebog256)",
3197 .test
= alg_test_hash
,
3199 .hash
= __VECS(hmac_streebog256_tv_template
)
3202 .alg
= "hmac(streebog512)",
3203 .test
= alg_test_hash
,
3205 .hash
= __VECS(hmac_streebog512_tv_template
)
3208 .alg
= "jitterentropy_rng",
3210 .test
= alg_test_null
,
3213 .test
= alg_test_skcipher
,
3216 .cipher
= __VECS(aes_kw_tv_template
)
3220 .test
= alg_test_skcipher
,
3222 .cipher
= __VECS(aes_lrw_tv_template
)
3225 .alg
= "lrw(camellia)",
3226 .test
= alg_test_skcipher
,
3228 .cipher
= __VECS(camellia_lrw_tv_template
)
3231 .alg
= "lrw(cast6)",
3232 .test
= alg_test_skcipher
,
3234 .cipher
= __VECS(cast6_lrw_tv_template
)
3237 .alg
= "lrw(serpent)",
3238 .test
= alg_test_skcipher
,
3240 .cipher
= __VECS(serpent_lrw_tv_template
)
3243 .alg
= "lrw(twofish)",
3244 .test
= alg_test_skcipher
,
3246 .cipher
= __VECS(tf_lrw_tv_template
)
3250 .test
= alg_test_comp
,
3254 .comp
= __VECS(lz4_comp_tv_template
),
3255 .decomp
= __VECS(lz4_decomp_tv_template
)
3260 .test
= alg_test_comp
,
3264 .comp
= __VECS(lz4hc_comp_tv_template
),
3265 .decomp
= __VECS(lz4hc_decomp_tv_template
)
3270 .test
= alg_test_comp
,
3274 .comp
= __VECS(lzo_comp_tv_template
),
3275 .decomp
= __VECS(lzo_decomp_tv_template
)
3280 .test
= alg_test_hash
,
3282 .hash
= __VECS(md4_tv_template
)
3286 .test
= alg_test_hash
,
3288 .hash
= __VECS(md5_tv_template
)
3291 .alg
= "michael_mic",
3292 .test
= alg_test_hash
,
3294 .hash
= __VECS(michael_mic_tv_template
)
3298 .test
= alg_test_aead
,
3301 .enc
= __VECS(morus1280_enc_tv_template
),
3302 .dec
= __VECS(morus1280_dec_tv_template
),
3307 .test
= alg_test_aead
,
3310 .enc
= __VECS(morus640_enc_tv_template
),
3311 .dec
= __VECS(morus640_dec_tv_template
),
3316 .test
= alg_test_skcipher
,
3319 .cipher
= __VECS(aes_ofb_tv_template
)
3322 /* Same as ofb(aes) except the key is stored in
3323 * hardware secure memory which we reference by index
3326 .test
= alg_test_null
,
3329 .alg
= "pcbc(fcrypt)",
3330 .test
= alg_test_skcipher
,
3332 .cipher
= __VECS(fcrypt_pcbc_tv_template
)
3335 .alg
= "pkcs1pad(rsa,sha224)",
3336 .test
= alg_test_null
,
3339 .alg
= "pkcs1pad(rsa,sha256)",
3340 .test
= alg_test_akcipher
,
3343 .akcipher
= __VECS(pkcs1pad_rsa_tv_template
)
3346 .alg
= "pkcs1pad(rsa,sha384)",
3347 .test
= alg_test_null
,
3350 .alg
= "pkcs1pad(rsa,sha512)",
3351 .test
= alg_test_null
,
3355 .test
= alg_test_hash
,
3357 .hash
= __VECS(poly1305_tv_template
)
3360 .alg
= "rfc3686(ctr(aes))",
3361 .test
= alg_test_skcipher
,
3364 .cipher
= __VECS(aes_ctr_rfc3686_tv_template
)
3367 .alg
= "rfc4106(gcm(aes))",
3368 .test
= alg_test_aead
,
3372 .enc
= __VECS(aes_gcm_rfc4106_enc_tv_template
),
3373 .dec
= __VECS(aes_gcm_rfc4106_dec_tv_template
)
3377 .alg
= "rfc4309(ccm(aes))",
3378 .test
= alg_test_aead
,
3382 .enc
= __VECS(aes_ccm_rfc4309_enc_tv_template
),
3383 .dec
= __VECS(aes_ccm_rfc4309_dec_tv_template
)
3387 .alg
= "rfc4543(gcm(aes))",
3388 .test
= alg_test_aead
,
3391 .enc
= __VECS(aes_gcm_rfc4543_enc_tv_template
),
3392 .dec
= __VECS(aes_gcm_rfc4543_dec_tv_template
),
3396 .alg
= "rfc7539(chacha20,poly1305)",
3397 .test
= alg_test_aead
,
3400 .enc
= __VECS(rfc7539_enc_tv_template
),
3401 .dec
= __VECS(rfc7539_dec_tv_template
),
3405 .alg
= "rfc7539esp(chacha20,poly1305)",
3406 .test
= alg_test_aead
,
3409 .enc
= __VECS(rfc7539esp_enc_tv_template
),
3410 .dec
= __VECS(rfc7539esp_dec_tv_template
),
3415 .test
= alg_test_hash
,
3417 .hash
= __VECS(rmd128_tv_template
)
3421 .test
= alg_test_hash
,
3423 .hash
= __VECS(rmd160_tv_template
)
3427 .test
= alg_test_hash
,
3429 .hash
= __VECS(rmd256_tv_template
)
3433 .test
= alg_test_hash
,
3435 .hash
= __VECS(rmd320_tv_template
)
3439 .test
= alg_test_akcipher
,
3442 .akcipher
= __VECS(rsa_tv_template
)
3446 .test
= alg_test_skcipher
,
3448 .cipher
= __VECS(salsa20_stream_tv_template
)
3452 .test
= alg_test_hash
,
3455 .hash
= __VECS(sha1_tv_template
)
3459 .test
= alg_test_hash
,
3462 .hash
= __VECS(sha224_tv_template
)
3466 .test
= alg_test_hash
,
3469 .hash
= __VECS(sha256_tv_template
)
3473 .test
= alg_test_hash
,
3476 .hash
= __VECS(sha3_224_tv_template
)
3480 .test
= alg_test_hash
,
3483 .hash
= __VECS(sha3_256_tv_template
)
3487 .test
= alg_test_hash
,
3490 .hash
= __VECS(sha3_384_tv_template
)
3494 .test
= alg_test_hash
,
3497 .hash
= __VECS(sha3_512_tv_template
)
3501 .test
= alg_test_hash
,
3504 .hash
= __VECS(sha384_tv_template
)
3508 .test
= alg_test_hash
,
3511 .hash
= __VECS(sha512_tv_template
)
3515 .test
= alg_test_hash
,
3517 .hash
= __VECS(sm3_tv_template
)
3520 .alg
= "streebog256",
3521 .test
= alg_test_hash
,
3523 .hash
= __VECS(streebog256_tv_template
)
3526 .alg
= "streebog512",
3527 .test
= alg_test_hash
,
3529 .hash
= __VECS(streebog512_tv_template
)
3533 .test
= alg_test_hash
,
3535 .hash
= __VECS(tgr128_tv_template
)
3539 .test
= alg_test_hash
,
3541 .hash
= __VECS(tgr160_tv_template
)
3545 .test
= alg_test_hash
,
3547 .hash
= __VECS(tgr192_tv_template
)
3550 .alg
= "vmac64(aes)",
3551 .test
= alg_test_hash
,
3553 .hash
= __VECS(vmac64_aes_tv_template
)
3557 .test
= alg_test_hash
,
3559 .hash
= __VECS(wp256_tv_template
)
3563 .test
= alg_test_hash
,
3565 .hash
= __VECS(wp384_tv_template
)
3569 .test
= alg_test_hash
,
3571 .hash
= __VECS(wp512_tv_template
)
3575 .test
= alg_test_hash
,
3577 .hash
= __VECS(aes_xcbc128_tv_template
)
3581 .test
= alg_test_skcipher
,
3583 .cipher
= __VECS(xchacha20_tv_template
)
3587 .test
= alg_test_skcipher
,
3590 .cipher
= __VECS(aes_xts_tv_template
)
3593 .alg
= "xts(camellia)",
3594 .test
= alg_test_skcipher
,
3596 .cipher
= __VECS(camellia_xts_tv_template
)
3599 .alg
= "xts(cast6)",
3600 .test
= alg_test_skcipher
,
3602 .cipher
= __VECS(cast6_xts_tv_template
)
3605 /* Same as xts(aes) except the key is stored in
3606 * hardware secure memory which we reference by index
3609 .test
= alg_test_null
,
3612 .alg
= "xts(serpent)",
3613 .test
= alg_test_skcipher
,
3615 .cipher
= __VECS(serpent_xts_tv_template
)
3618 .alg
= "xts(twofish)",
3619 .test
= alg_test_skcipher
,
3621 .cipher
= __VECS(tf_xts_tv_template
)
3624 .alg
= "xts4096(paes)",
3625 .test
= alg_test_null
,
3628 .alg
= "xts512(paes)",
3629 .test
= alg_test_null
,
3632 .alg
= "zlib-deflate",
3633 .test
= alg_test_comp
,
3637 .comp
= __VECS(zlib_deflate_comp_tv_template
),
3638 .decomp
= __VECS(zlib_deflate_decomp_tv_template
)
3643 .test
= alg_test_comp
,
3647 .comp
= __VECS(zstd_comp_tv_template
),
3648 .decomp
= __VECS(zstd_decomp_tv_template
)
3654 static bool alg_test_descs_checked
;
3656 static void alg_test_descs_check_order(void)
3660 /* only check once */
3661 if (alg_test_descs_checked
)
3664 alg_test_descs_checked
= true;
3666 for (i
= 1; i
< ARRAY_SIZE(alg_test_descs
); i
++) {
3667 int diff
= strcmp(alg_test_descs
[i
- 1].alg
,
3668 alg_test_descs
[i
].alg
);
3670 if (WARN_ON(diff
> 0)) {
3671 pr_warn("testmgr: alg_test_descs entries in wrong order: '%s' before '%s'\n",
3672 alg_test_descs
[i
- 1].alg
,
3673 alg_test_descs
[i
].alg
);
3676 if (WARN_ON(diff
== 0)) {
3677 pr_warn("testmgr: duplicate alg_test_descs entry: '%s'\n",
3678 alg_test_descs
[i
].alg
);
3683 static int alg_find_test(const char *alg
)
3686 int end
= ARRAY_SIZE(alg_test_descs
);
3688 while (start
< end
) {
3689 int i
= (start
+ end
) / 2;
3690 int diff
= strcmp(alg_test_descs
[i
].alg
, alg
);
3708 int alg_test(const char *driver
, const char *alg
, u32 type
, u32 mask
)
3714 if (!fips_enabled
&& notests
) {
3715 printk_once(KERN_INFO
"alg: self-tests disabled\n");
3719 alg_test_descs_check_order();
3721 if ((type
& CRYPTO_ALG_TYPE_MASK
) == CRYPTO_ALG_TYPE_CIPHER
) {
3722 char nalg
[CRYPTO_MAX_ALG_NAME
];
3724 if (snprintf(nalg
, sizeof(nalg
), "ecb(%s)", alg
) >=
3726 return -ENAMETOOLONG
;
3728 i
= alg_find_test(nalg
);
3732 if (fips_enabled
&& !alg_test_descs
[i
].fips_allowed
)
3735 rc
= alg_test_cipher(alg_test_descs
+ i
, driver
, type
, mask
);
3739 i
= alg_find_test(alg
);
3740 j
= alg_find_test(driver
);
3744 if (fips_enabled
&& ((i
>= 0 && !alg_test_descs
[i
].fips_allowed
) ||
3745 (j
>= 0 && !alg_test_descs
[j
].fips_allowed
)))
3750 rc
|= alg_test_descs
[i
].test(alg_test_descs
+ i
, driver
,
3752 if (j
>= 0 && j
!= i
)
3753 rc
|= alg_test_descs
[j
].test(alg_test_descs
+ j
, driver
,
3757 if (fips_enabled
&& rc
)
3758 panic("%s: %s alg self test failed in fips mode!\n", driver
, alg
);
3760 if (fips_enabled
&& !rc
)
3761 pr_info("alg: self-tests for %s (%s) passed\n", driver
, alg
);
3766 printk(KERN_INFO
"alg: No test for %s (%s)\n", alg
, driver
);
3772 #endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */
3774 EXPORT_SYMBOL_GPL(alg_test
);