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/hash.h>
24 #include <linux/err.h>
25 #include <linux/module.h>
26 #include <linux/scatterlist.h>
27 #include <linux/slab.h>
28 #include <linux/string.h>
29 #include <crypto/rng.h>
30 #include <crypto/drbg.h>
34 #ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
37 int alg_test(const char *driver
, const char *alg
, u32 type
, u32 mask
)
47 * Need slab memory for testing (size in number of pages).
52 * Indexes into the xbuf to simulate cross-page access.
64 * Used by test_cipher()
69 struct tcrypt_result
{
70 struct completion completion
;
74 struct aead_test_suite
{
76 struct aead_testvec
*vecs
;
81 struct cipher_test_suite
{
83 struct cipher_testvec
*vecs
;
88 struct comp_test_suite
{
90 struct comp_testvec
*vecs
;
95 struct pcomp_test_suite
{
97 struct pcomp_testvec
*vecs
;
102 struct hash_test_suite
{
103 struct hash_testvec
*vecs
;
107 struct cprng_test_suite
{
108 struct cprng_testvec
*vecs
;
112 struct drbg_test_suite
{
113 struct drbg_testvec
*vecs
;
117 struct alg_test_desc
{
119 int (*test
)(const struct alg_test_desc
*desc
, const char *driver
,
121 int fips_allowed
; /* set if alg is allowed in fips mode */
124 struct aead_test_suite aead
;
125 struct cipher_test_suite cipher
;
126 struct comp_test_suite comp
;
127 struct pcomp_test_suite pcomp
;
128 struct hash_test_suite hash
;
129 struct cprng_test_suite cprng
;
130 struct drbg_test_suite drbg
;
134 static unsigned int IDX
[8] = { IDX1
, IDX2
, IDX3
, IDX4
, IDX5
, IDX6
, IDX7
, IDX8
};
136 static void hexdump(unsigned char *buf
, unsigned int len
)
138 print_hex_dump(KERN_CONT
, "", DUMP_PREFIX_OFFSET
,
143 static void tcrypt_complete(struct crypto_async_request
*req
, int err
)
145 struct tcrypt_result
*res
= req
->data
;
147 if (err
== -EINPROGRESS
)
151 complete(&res
->completion
);
154 static int testmgr_alloc_buf(char *buf
[XBUFSIZE
])
158 for (i
= 0; i
< XBUFSIZE
; i
++) {
159 buf
[i
] = (void *)__get_free_page(GFP_KERNEL
);
168 free_page((unsigned long)buf
[i
]);
173 static void testmgr_free_buf(char *buf
[XBUFSIZE
])
177 for (i
= 0; i
< XBUFSIZE
; i
++)
178 free_page((unsigned long)buf
[i
]);
181 static int wait_async_op(struct tcrypt_result
*tr
, int ret
)
183 if (ret
== -EINPROGRESS
|| ret
== -EBUSY
) {
184 ret
= wait_for_completion_interruptible(&tr
->completion
);
187 reinit_completion(&tr
->completion
);
192 static int __test_hash(struct crypto_ahash
*tfm
, struct hash_testvec
*template,
193 unsigned int tcount
, bool use_digest
,
194 const int align_offset
)
196 const char *algo
= crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm
));
197 unsigned int i
, j
, k
, temp
;
198 struct scatterlist sg
[8];
201 struct ahash_request
*req
;
202 struct tcrypt_result tresult
;
204 char *xbuf
[XBUFSIZE
];
207 result
= kmalloc(MAX_DIGEST_SIZE
, GFP_KERNEL
);
210 key
= kmalloc(MAX_KEYLEN
, GFP_KERNEL
);
213 if (testmgr_alloc_buf(xbuf
))
216 init_completion(&tresult
.completion
);
218 req
= ahash_request_alloc(tfm
, GFP_KERNEL
);
220 printk(KERN_ERR
"alg: hash: Failed to allocate request for "
224 ahash_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
225 tcrypt_complete
, &tresult
);
228 for (i
= 0; i
< tcount
; i
++) {
233 if (WARN_ON(align_offset
+ template[i
].psize
> PAGE_SIZE
))
237 memset(result
, 0, MAX_DIGEST_SIZE
);
240 hash_buff
+= align_offset
;
242 memcpy(hash_buff
, template[i
].plaintext
, template[i
].psize
);
243 sg_init_one(&sg
[0], hash_buff
, template[i
].psize
);
245 if (template[i
].ksize
) {
246 crypto_ahash_clear_flags(tfm
, ~0);
247 if (template[i
].ksize
> MAX_KEYLEN
) {
248 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
249 j
, algo
, template[i
].ksize
, MAX_KEYLEN
);
253 memcpy(key
, template[i
].key
, template[i
].ksize
);
254 ret
= crypto_ahash_setkey(tfm
, key
, template[i
].ksize
);
256 printk(KERN_ERR
"alg: hash: setkey failed on "
257 "test %d for %s: ret=%d\n", j
, algo
,
263 ahash_request_set_crypt(req
, sg
, result
, template[i
].psize
);
265 ret
= wait_async_op(&tresult
, crypto_ahash_digest(req
));
267 pr_err("alg: hash: digest failed on test %d "
268 "for %s: ret=%d\n", j
, algo
, -ret
);
272 ret
= wait_async_op(&tresult
, crypto_ahash_init(req
));
274 pr_err("alt: hash: init failed on test %d "
275 "for %s: ret=%d\n", j
, algo
, -ret
);
278 ret
= wait_async_op(&tresult
, crypto_ahash_update(req
));
280 pr_err("alt: hash: update failed on test %d "
281 "for %s: ret=%d\n", j
, algo
, -ret
);
284 ret
= wait_async_op(&tresult
, crypto_ahash_final(req
));
286 pr_err("alt: hash: final failed on test %d "
287 "for %s: ret=%d\n", j
, algo
, -ret
);
292 if (memcmp(result
, template[i
].digest
,
293 crypto_ahash_digestsize(tfm
))) {
294 printk(KERN_ERR
"alg: hash: Test %d failed for %s\n",
296 hexdump(result
, crypto_ahash_digestsize(tfm
));
303 for (i
= 0; i
< tcount
; i
++) {
304 /* alignment tests are only done with continuous buffers */
305 if (align_offset
!= 0)
312 memset(result
, 0, MAX_DIGEST_SIZE
);
315 sg_init_table(sg
, template[i
].np
);
317 for (k
= 0; k
< template[i
].np
; k
++) {
318 if (WARN_ON(offset_in_page(IDX
[k
]) +
319 template[i
].tap
[k
] > PAGE_SIZE
))
322 memcpy(xbuf
[IDX
[k
] >> PAGE_SHIFT
] +
323 offset_in_page(IDX
[k
]),
324 template[i
].plaintext
+ temp
,
327 temp
+= template[i
].tap
[k
];
330 if (template[i
].ksize
) {
331 if (template[i
].ksize
> MAX_KEYLEN
) {
332 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
333 j
, algo
, template[i
].ksize
, MAX_KEYLEN
);
337 crypto_ahash_clear_flags(tfm
, ~0);
338 memcpy(key
, template[i
].key
, template[i
].ksize
);
339 ret
= crypto_ahash_setkey(tfm
, key
, template[i
].ksize
);
342 printk(KERN_ERR
"alg: hash: setkey "
343 "failed on chunking test %d "
344 "for %s: ret=%d\n", j
, algo
, -ret
);
349 ahash_request_set_crypt(req
, sg
, result
, template[i
].psize
);
350 ret
= crypto_ahash_digest(req
);
356 ret
= wait_for_completion_interruptible(
357 &tresult
.completion
);
358 if (!ret
&& !(ret
= tresult
.err
)) {
359 reinit_completion(&tresult
.completion
);
364 printk(KERN_ERR
"alg: hash: digest failed "
365 "on chunking test %d for %s: "
366 "ret=%d\n", j
, algo
, -ret
);
370 if (memcmp(result
, template[i
].digest
,
371 crypto_ahash_digestsize(tfm
))) {
372 printk(KERN_ERR
"alg: hash: Chunking test %d "
373 "failed for %s\n", j
, algo
);
374 hexdump(result
, crypto_ahash_digestsize(tfm
));
383 ahash_request_free(req
);
385 testmgr_free_buf(xbuf
);
392 static int test_hash(struct crypto_ahash
*tfm
, struct hash_testvec
*template,
393 unsigned int tcount
, bool use_digest
)
395 unsigned int alignmask
;
398 ret
= __test_hash(tfm
, template, tcount
, use_digest
, 0);
402 /* test unaligned buffers, check with one byte offset */
403 ret
= __test_hash(tfm
, template, tcount
, use_digest
, 1);
407 alignmask
= crypto_tfm_alg_alignmask(&tfm
->base
);
409 /* Check if alignment mask for tfm is correctly set. */
410 ret
= __test_hash(tfm
, template, tcount
, use_digest
,
419 static int __test_aead(struct crypto_aead
*tfm
, int enc
,
420 struct aead_testvec
*template, unsigned int tcount
,
421 const bool diff_dst
, const int align_offset
)
423 const char *algo
= crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm
));
424 unsigned int i
, j
, k
, n
, temp
;
428 struct aead_request
*req
;
429 struct scatterlist
*sg
;
430 struct scatterlist
*asg
;
431 struct scatterlist
*sgout
;
433 struct tcrypt_result result
;
434 unsigned int authsize
;
439 char *xbuf
[XBUFSIZE
];
440 char *xoutbuf
[XBUFSIZE
];
441 char *axbuf
[XBUFSIZE
];
443 iv
= kzalloc(MAX_IVLEN
, GFP_KERNEL
);
446 key
= kmalloc(MAX_KEYLEN
, GFP_KERNEL
);
449 if (testmgr_alloc_buf(xbuf
))
451 if (testmgr_alloc_buf(axbuf
))
453 if (diff_dst
&& testmgr_alloc_buf(xoutbuf
))
456 /* avoid "the frame size is larger than 1024 bytes" compiler warning */
457 sg
= kmalloc(sizeof(*sg
) * 8 * (diff_dst
? 3 : 2), GFP_KERNEL
);
473 init_completion(&result
.completion
);
475 req
= aead_request_alloc(tfm
, GFP_KERNEL
);
477 pr_err("alg: aead%s: Failed to allocate request for %s\n",
482 aead_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
483 tcrypt_complete
, &result
);
485 for (i
= 0, j
= 0; i
< tcount
; i
++) {
491 /* some templates have no input data but they will
495 input
+= align_offset
;
499 if (WARN_ON(align_offset
+ template[i
].ilen
>
500 PAGE_SIZE
|| template[i
].alen
> PAGE_SIZE
))
503 memcpy(input
, template[i
].input
, template[i
].ilen
);
504 memcpy(assoc
, template[i
].assoc
, template[i
].alen
);
506 memcpy(iv
, template[i
].iv
, MAX_IVLEN
);
508 memset(iv
, 0, MAX_IVLEN
);
510 crypto_aead_clear_flags(tfm
, ~0);
512 crypto_aead_set_flags(tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
514 if (template[i
].klen
> MAX_KEYLEN
) {
515 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
516 d
, j
, algo
, template[i
].klen
,
521 memcpy(key
, template[i
].key
, template[i
].klen
);
523 ret
= crypto_aead_setkey(tfm
, key
, template[i
].klen
);
524 if (!ret
== template[i
].fail
) {
525 pr_err("alg: aead%s: setkey failed on test %d for %s: flags=%x\n",
526 d
, j
, algo
, crypto_aead_get_flags(tfm
));
531 authsize
= abs(template[i
].rlen
- template[i
].ilen
);
532 ret
= crypto_aead_setauthsize(tfm
, authsize
);
534 pr_err("alg: aead%s: Failed to set authsize to %u on test %d for %s\n",
535 d
, authsize
, j
, algo
);
541 output
+= align_offset
;
542 sg_init_one(&sg
[0], input
, template[i
].ilen
);
543 sg_init_one(&sgout
[0], output
, template[i
].rlen
);
545 sg_init_one(&sg
[0], input
,
546 template[i
].ilen
+ (enc
? authsize
: 0));
550 sg_init_one(&asg
[0], assoc
, template[i
].alen
);
552 aead_request_set_crypt(req
, sg
, (diff_dst
) ? sgout
: sg
,
553 template[i
].ilen
, iv
);
555 aead_request_set_assoc(req
, asg
, template[i
].alen
);
557 ret
= enc
? crypto_aead_encrypt(req
) : crypto_aead_decrypt(req
);
561 if (template[i
].novrfy
) {
562 /* verification was supposed to fail */
563 pr_err("alg: aead%s: %s failed on test %d for %s: ret was 0, expected -EBADMSG\n",
565 /* so really, we got a bad message */
572 ret
= wait_for_completion_interruptible(
574 if (!ret
&& !(ret
= result
.err
)) {
575 reinit_completion(&result
.completion
);
579 if (template[i
].novrfy
)
580 /* verification failure was expected */
584 pr_err("alg: aead%s: %s failed on test %d for %s: ret=%d\n",
585 d
, e
, j
, algo
, -ret
);
590 if (memcmp(q
, template[i
].result
, template[i
].rlen
)) {
591 pr_err("alg: aead%s: Test %d failed on %s for %s\n",
593 hexdump(q
, template[i
].rlen
);
599 for (i
= 0, j
= 0; i
< tcount
; i
++) {
600 /* alignment tests are only done with continuous buffers */
601 if (align_offset
!= 0)
610 memcpy(iv
, template[i
].iv
, MAX_IVLEN
);
612 memset(iv
, 0, MAX_IVLEN
);
614 crypto_aead_clear_flags(tfm
, ~0);
616 crypto_aead_set_flags(tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
617 if (template[i
].klen
> MAX_KEYLEN
) {
618 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
619 d
, j
, algo
, template[i
].klen
, MAX_KEYLEN
);
623 memcpy(key
, template[i
].key
, template[i
].klen
);
625 ret
= crypto_aead_setkey(tfm
, key
, template[i
].klen
);
626 if (!ret
== template[i
].fail
) {
627 pr_err("alg: aead%s: setkey failed on chunk test %d for %s: flags=%x\n",
628 d
, j
, algo
, crypto_aead_get_flags(tfm
));
633 authsize
= abs(template[i
].rlen
- template[i
].ilen
);
636 sg_init_table(sg
, template[i
].np
);
638 sg_init_table(sgout
, template[i
].np
);
639 for (k
= 0, temp
= 0; k
< template[i
].np
; k
++) {
640 if (WARN_ON(offset_in_page(IDX
[k
]) +
641 template[i
].tap
[k
] > PAGE_SIZE
))
644 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] + offset_in_page(IDX
[k
]);
645 memcpy(q
, template[i
].input
+ temp
, template[i
].tap
[k
]);
646 sg_set_buf(&sg
[k
], q
, template[i
].tap
[k
]);
649 q
= xoutbuf
[IDX
[k
] >> PAGE_SHIFT
] +
650 offset_in_page(IDX
[k
]);
652 memset(q
, 0, template[i
].tap
[k
]);
654 sg_set_buf(&sgout
[k
], q
, template[i
].tap
[k
]);
657 n
= template[i
].tap
[k
];
658 if (k
== template[i
].np
- 1 && enc
)
660 if (offset_in_page(q
) + n
< PAGE_SIZE
)
663 temp
+= template[i
].tap
[k
];
666 ret
= crypto_aead_setauthsize(tfm
, authsize
);
668 pr_err("alg: aead%s: Failed to set authsize to %u on chunk test %d for %s\n",
669 d
, authsize
, j
, algo
);
674 if (WARN_ON(sg
[k
- 1].offset
+
675 sg
[k
- 1].length
+ authsize
>
682 sgout
[k
- 1].length
+= authsize
;
684 sg
[k
- 1].length
+= authsize
;
687 sg_init_table(asg
, template[i
].anp
);
689 for (k
= 0, temp
= 0; k
< template[i
].anp
; k
++) {
690 if (WARN_ON(offset_in_page(IDX
[k
]) +
691 template[i
].atap
[k
] > PAGE_SIZE
))
694 memcpy(axbuf
[IDX
[k
] >> PAGE_SHIFT
] +
695 offset_in_page(IDX
[k
]),
696 template[i
].assoc
+ temp
,
697 template[i
].atap
[k
]),
698 template[i
].atap
[k
]);
699 temp
+= template[i
].atap
[k
];
702 aead_request_set_crypt(req
, sg
, (diff_dst
) ? sgout
: sg
,
706 aead_request_set_assoc(req
, asg
, template[i
].alen
);
708 ret
= enc
? crypto_aead_encrypt(req
) : crypto_aead_decrypt(req
);
712 if (template[i
].novrfy
) {
713 /* verification was supposed to fail */
714 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret was 0, expected -EBADMSG\n",
716 /* so really, we got a bad message */
723 ret
= wait_for_completion_interruptible(
725 if (!ret
&& !(ret
= result
.err
)) {
726 reinit_completion(&result
.completion
);
730 if (template[i
].novrfy
)
731 /* verification failure was expected */
735 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret=%d\n",
736 d
, e
, j
, algo
, -ret
);
741 for (k
= 0, temp
= 0; k
< template[i
].np
; k
++) {
743 q
= xoutbuf
[IDX
[k
] >> PAGE_SHIFT
] +
744 offset_in_page(IDX
[k
]);
746 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] +
747 offset_in_page(IDX
[k
]);
749 n
= template[i
].tap
[k
];
750 if (k
== template[i
].np
- 1)
751 n
+= enc
? authsize
: -authsize
;
753 if (memcmp(q
, template[i
].result
+ temp
, n
)) {
754 pr_err("alg: aead%s: Chunk test %d failed on %s at page %u for %s\n",
761 if (k
== template[i
].np
- 1 && !enc
) {
763 memcmp(q
, template[i
].input
+
769 for (n
= 0; offset_in_page(q
+ n
) && q
[n
]; n
++)
773 pr_err("alg: aead%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
774 d
, j
, e
, k
, algo
, n
);
779 temp
+= template[i
].tap
[k
];
786 aead_request_free(req
);
790 testmgr_free_buf(xoutbuf
);
792 testmgr_free_buf(axbuf
);
794 testmgr_free_buf(xbuf
);
801 static int test_aead(struct crypto_aead
*tfm
, int enc
,
802 struct aead_testvec
*template, unsigned int tcount
)
804 unsigned int alignmask
;
807 /* test 'dst == src' case */
808 ret
= __test_aead(tfm
, enc
, template, tcount
, false, 0);
812 /* test 'dst != src' case */
813 ret
= __test_aead(tfm
, enc
, template, tcount
, true, 0);
817 /* test unaligned buffers, check with one byte offset */
818 ret
= __test_aead(tfm
, enc
, template, tcount
, true, 1);
822 alignmask
= crypto_tfm_alg_alignmask(&tfm
->base
);
824 /* Check if alignment mask for tfm is correctly set. */
825 ret
= __test_aead(tfm
, enc
, template, tcount
, true,
834 static int test_cipher(struct crypto_cipher
*tfm
, int enc
,
835 struct cipher_testvec
*template, unsigned int tcount
)
837 const char *algo
= crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm
));
838 unsigned int i
, j
, k
;
842 char *xbuf
[XBUFSIZE
];
845 if (testmgr_alloc_buf(xbuf
))
854 for (i
= 0; i
< tcount
; i
++) {
861 if (WARN_ON(template[i
].ilen
> PAGE_SIZE
))
865 memcpy(data
, template[i
].input
, template[i
].ilen
);
867 crypto_cipher_clear_flags(tfm
, ~0);
869 crypto_cipher_set_flags(tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
871 ret
= crypto_cipher_setkey(tfm
, template[i
].key
,
873 if (!ret
== template[i
].fail
) {
874 printk(KERN_ERR
"alg: cipher: setkey failed "
875 "on test %d for %s: flags=%x\n", j
,
876 algo
, crypto_cipher_get_flags(tfm
));
881 for (k
= 0; k
< template[i
].ilen
;
882 k
+= crypto_cipher_blocksize(tfm
)) {
884 crypto_cipher_encrypt_one(tfm
, data
+ k
,
887 crypto_cipher_decrypt_one(tfm
, data
+ k
,
892 if (memcmp(q
, template[i
].result
, template[i
].rlen
)) {
893 printk(KERN_ERR
"alg: cipher: Test %d failed "
894 "on %s for %s\n", j
, e
, algo
);
895 hexdump(q
, template[i
].rlen
);
904 testmgr_free_buf(xbuf
);
909 static int __test_skcipher(struct crypto_ablkcipher
*tfm
, int enc
,
910 struct cipher_testvec
*template, unsigned int tcount
,
911 const bool diff_dst
, const int align_offset
)
914 crypto_tfm_alg_driver_name(crypto_ablkcipher_tfm(tfm
));
915 unsigned int i
, j
, k
, n
, temp
;
917 struct ablkcipher_request
*req
;
918 struct scatterlist sg
[8];
919 struct scatterlist sgout
[8];
921 struct tcrypt_result result
;
924 char *xbuf
[XBUFSIZE
];
925 char *xoutbuf
[XBUFSIZE
];
928 if (testmgr_alloc_buf(xbuf
))
931 if (diff_dst
&& testmgr_alloc_buf(xoutbuf
))
944 init_completion(&result
.completion
);
946 req
= ablkcipher_request_alloc(tfm
, GFP_KERNEL
);
948 pr_err("alg: skcipher%s: Failed to allocate request for %s\n",
953 ablkcipher_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
954 tcrypt_complete
, &result
);
957 for (i
= 0; i
< tcount
; i
++) {
958 if (template[i
].np
&& !template[i
].also_non_np
)
962 memcpy(iv
, template[i
].iv
, MAX_IVLEN
);
964 memset(iv
, 0, MAX_IVLEN
);
968 if (WARN_ON(align_offset
+ template[i
].ilen
> PAGE_SIZE
))
972 data
+= align_offset
;
973 memcpy(data
, template[i
].input
, template[i
].ilen
);
975 crypto_ablkcipher_clear_flags(tfm
, ~0);
977 crypto_ablkcipher_set_flags(tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
979 ret
= crypto_ablkcipher_setkey(tfm
, template[i
].key
,
981 if (!ret
== template[i
].fail
) {
982 pr_err("alg: skcipher%s: setkey failed on test %d for %s: flags=%x\n",
983 d
, j
, algo
, crypto_ablkcipher_get_flags(tfm
));
988 sg_init_one(&sg
[0], data
, template[i
].ilen
);
991 data
+= align_offset
;
992 sg_init_one(&sgout
[0], data
, template[i
].ilen
);
995 ablkcipher_request_set_crypt(req
, sg
, (diff_dst
) ? sgout
: sg
,
996 template[i
].ilen
, iv
);
997 ret
= enc
? crypto_ablkcipher_encrypt(req
) :
998 crypto_ablkcipher_decrypt(req
);
1005 ret
= wait_for_completion_interruptible(
1006 &result
.completion
);
1007 if (!ret
&& !((ret
= result
.err
))) {
1008 reinit_completion(&result
.completion
);
1013 pr_err("alg: skcipher%s: %s failed on test %d for %s: ret=%d\n",
1014 d
, e
, j
, algo
, -ret
);
1019 if (memcmp(q
, template[i
].result
, template[i
].rlen
)) {
1020 pr_err("alg: skcipher%s: Test %d failed on %s for %s\n",
1022 hexdump(q
, template[i
].rlen
);
1029 for (i
= 0; i
< tcount
; i
++) {
1030 /* alignment tests are only done with continuous buffers */
1031 if (align_offset
!= 0)
1034 if (!template[i
].np
)
1038 memcpy(iv
, template[i
].iv
, MAX_IVLEN
);
1040 memset(iv
, 0, MAX_IVLEN
);
1043 crypto_ablkcipher_clear_flags(tfm
, ~0);
1045 crypto_ablkcipher_set_flags(tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
1047 ret
= crypto_ablkcipher_setkey(tfm
, template[i
].key
,
1049 if (!ret
== template[i
].fail
) {
1050 pr_err("alg: skcipher%s: setkey failed on chunk test %d for %s: flags=%x\n",
1051 d
, j
, algo
, crypto_ablkcipher_get_flags(tfm
));
1058 sg_init_table(sg
, template[i
].np
);
1060 sg_init_table(sgout
, template[i
].np
);
1061 for (k
= 0; k
< template[i
].np
; k
++) {
1062 if (WARN_ON(offset_in_page(IDX
[k
]) +
1063 template[i
].tap
[k
] > PAGE_SIZE
))
1066 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] + offset_in_page(IDX
[k
]);
1068 memcpy(q
, template[i
].input
+ temp
, template[i
].tap
[k
]);
1070 if (offset_in_page(q
) + template[i
].tap
[k
] < PAGE_SIZE
)
1071 q
[template[i
].tap
[k
]] = 0;
1073 sg_set_buf(&sg
[k
], q
, template[i
].tap
[k
]);
1075 q
= xoutbuf
[IDX
[k
] >> PAGE_SHIFT
] +
1076 offset_in_page(IDX
[k
]);
1078 sg_set_buf(&sgout
[k
], q
, template[i
].tap
[k
]);
1080 memset(q
, 0, template[i
].tap
[k
]);
1081 if (offset_in_page(q
) +
1082 template[i
].tap
[k
] < PAGE_SIZE
)
1083 q
[template[i
].tap
[k
]] = 0;
1086 temp
+= template[i
].tap
[k
];
1089 ablkcipher_request_set_crypt(req
, sg
, (diff_dst
) ? sgout
: sg
,
1090 template[i
].ilen
, iv
);
1092 ret
= enc
? crypto_ablkcipher_encrypt(req
) :
1093 crypto_ablkcipher_decrypt(req
);
1100 ret
= wait_for_completion_interruptible(
1101 &result
.completion
);
1102 if (!ret
&& !((ret
= result
.err
))) {
1103 reinit_completion(&result
.completion
);
1108 pr_err("alg: skcipher%s: %s failed on chunk test %d for %s: ret=%d\n",
1109 d
, e
, j
, algo
, -ret
);
1115 for (k
= 0; k
< template[i
].np
; k
++) {
1117 q
= xoutbuf
[IDX
[k
] >> PAGE_SHIFT
] +
1118 offset_in_page(IDX
[k
]);
1120 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] +
1121 offset_in_page(IDX
[k
]);
1123 if (memcmp(q
, template[i
].result
+ temp
,
1124 template[i
].tap
[k
])) {
1125 pr_err("alg: skcipher%s: Chunk test %d failed on %s at page %u for %s\n",
1127 hexdump(q
, template[i
].tap
[k
]);
1131 q
+= template[i
].tap
[k
];
1132 for (n
= 0; offset_in_page(q
+ n
) && q
[n
]; n
++)
1135 pr_err("alg: skcipher%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
1136 d
, j
, e
, k
, algo
, n
);
1140 temp
+= template[i
].tap
[k
];
1147 ablkcipher_request_free(req
);
1149 testmgr_free_buf(xoutbuf
);
1151 testmgr_free_buf(xbuf
);
1156 static int test_skcipher(struct crypto_ablkcipher
*tfm
, int enc
,
1157 struct cipher_testvec
*template, unsigned int tcount
)
1159 unsigned int alignmask
;
1162 /* test 'dst == src' case */
1163 ret
= __test_skcipher(tfm
, enc
, template, tcount
, false, 0);
1167 /* test 'dst != src' case */
1168 ret
= __test_skcipher(tfm
, enc
, template, tcount
, true, 0);
1172 /* test unaligned buffers, check with one byte offset */
1173 ret
= __test_skcipher(tfm
, enc
, template, tcount
, true, 1);
1177 alignmask
= crypto_tfm_alg_alignmask(&tfm
->base
);
1179 /* Check if alignment mask for tfm is correctly set. */
1180 ret
= __test_skcipher(tfm
, enc
, template, tcount
, true,
1189 static int test_comp(struct crypto_comp
*tfm
, struct comp_testvec
*ctemplate
,
1190 struct comp_testvec
*dtemplate
, int ctcount
, int dtcount
)
1192 const char *algo
= crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm
));
1194 char result
[COMP_BUF_SIZE
];
1197 for (i
= 0; i
< ctcount
; i
++) {
1199 unsigned int dlen
= COMP_BUF_SIZE
;
1201 memset(result
, 0, sizeof (result
));
1203 ilen
= ctemplate
[i
].inlen
;
1204 ret
= crypto_comp_compress(tfm
, ctemplate
[i
].input
,
1205 ilen
, result
, &dlen
);
1207 printk(KERN_ERR
"alg: comp: compression failed "
1208 "on test %d for %s: ret=%d\n", i
+ 1, algo
,
1213 if (dlen
!= ctemplate
[i
].outlen
) {
1214 printk(KERN_ERR
"alg: comp: Compression test %d "
1215 "failed for %s: output len = %d\n", i
+ 1, algo
,
1221 if (memcmp(result
, ctemplate
[i
].output
, dlen
)) {
1222 printk(KERN_ERR
"alg: comp: Compression test %d "
1223 "failed for %s\n", i
+ 1, algo
);
1224 hexdump(result
, dlen
);
1230 for (i
= 0; i
< dtcount
; i
++) {
1232 unsigned int dlen
= COMP_BUF_SIZE
;
1234 memset(result
, 0, sizeof (result
));
1236 ilen
= dtemplate
[i
].inlen
;
1237 ret
= crypto_comp_decompress(tfm
, dtemplate
[i
].input
,
1238 ilen
, result
, &dlen
);
1240 printk(KERN_ERR
"alg: comp: decompression failed "
1241 "on test %d for %s: ret=%d\n", i
+ 1, algo
,
1246 if (dlen
!= dtemplate
[i
].outlen
) {
1247 printk(KERN_ERR
"alg: comp: Decompression test %d "
1248 "failed for %s: output len = %d\n", i
+ 1, algo
,
1254 if (memcmp(result
, dtemplate
[i
].output
, dlen
)) {
1255 printk(KERN_ERR
"alg: comp: Decompression test %d "
1256 "failed for %s\n", i
+ 1, algo
);
1257 hexdump(result
, dlen
);
1269 static int test_pcomp(struct crypto_pcomp
*tfm
,
1270 struct pcomp_testvec
*ctemplate
,
1271 struct pcomp_testvec
*dtemplate
, int ctcount
,
1274 const char *algo
= crypto_tfm_alg_driver_name(crypto_pcomp_tfm(tfm
));
1276 char result
[COMP_BUF_SIZE
];
1279 for (i
= 0; i
< ctcount
; i
++) {
1280 struct comp_request req
;
1281 unsigned int produced
= 0;
1283 res
= crypto_compress_setup(tfm
, ctemplate
[i
].params
,
1284 ctemplate
[i
].paramsize
);
1286 pr_err("alg: pcomp: compression setup failed on test "
1287 "%d for %s: error=%d\n", i
+ 1, algo
, res
);
1291 res
= crypto_compress_init(tfm
);
1293 pr_err("alg: pcomp: compression init failed on test "
1294 "%d for %s: error=%d\n", i
+ 1, algo
, res
);
1298 memset(result
, 0, sizeof(result
));
1300 req
.next_in
= ctemplate
[i
].input
;
1301 req
.avail_in
= ctemplate
[i
].inlen
/ 2;
1302 req
.next_out
= result
;
1303 req
.avail_out
= ctemplate
[i
].outlen
/ 2;
1305 res
= crypto_compress_update(tfm
, &req
);
1306 if (res
< 0 && (res
!= -EAGAIN
|| req
.avail_in
)) {
1307 pr_err("alg: pcomp: compression update failed on test "
1308 "%d for %s: error=%d\n", i
+ 1, algo
, res
);
1314 /* Add remaining input data */
1315 req
.avail_in
+= (ctemplate
[i
].inlen
+ 1) / 2;
1317 res
= crypto_compress_update(tfm
, &req
);
1318 if (res
< 0 && (res
!= -EAGAIN
|| req
.avail_in
)) {
1319 pr_err("alg: pcomp: compression update failed on test "
1320 "%d for %s: error=%d\n", i
+ 1, algo
, res
);
1326 /* Provide remaining output space */
1327 req
.avail_out
+= COMP_BUF_SIZE
- ctemplate
[i
].outlen
/ 2;
1329 res
= crypto_compress_final(tfm
, &req
);
1331 pr_err("alg: pcomp: compression final failed on test "
1332 "%d for %s: error=%d\n", i
+ 1, algo
, res
);
1337 if (COMP_BUF_SIZE
- req
.avail_out
!= ctemplate
[i
].outlen
) {
1338 pr_err("alg: comp: Compression test %d failed for %s: "
1339 "output len = %d (expected %d)\n", i
+ 1, algo
,
1340 COMP_BUF_SIZE
- req
.avail_out
,
1341 ctemplate
[i
].outlen
);
1345 if (produced
!= ctemplate
[i
].outlen
) {
1346 pr_err("alg: comp: Compression test %d failed for %s: "
1347 "returned len = %u (expected %d)\n", i
+ 1,
1348 algo
, produced
, ctemplate
[i
].outlen
);
1352 if (memcmp(result
, ctemplate
[i
].output
, ctemplate
[i
].outlen
)) {
1353 pr_err("alg: pcomp: Compression test %d failed for "
1354 "%s\n", i
+ 1, algo
);
1355 hexdump(result
, ctemplate
[i
].outlen
);
1360 for (i
= 0; i
< dtcount
; i
++) {
1361 struct comp_request req
;
1362 unsigned int produced
= 0;
1364 res
= crypto_decompress_setup(tfm
, dtemplate
[i
].params
,
1365 dtemplate
[i
].paramsize
);
1367 pr_err("alg: pcomp: decompression setup failed on "
1368 "test %d for %s: error=%d\n", i
+ 1, algo
, res
);
1372 res
= crypto_decompress_init(tfm
);
1374 pr_err("alg: pcomp: decompression init failed on test "
1375 "%d for %s: error=%d\n", i
+ 1, algo
, res
);
1379 memset(result
, 0, sizeof(result
));
1381 req
.next_in
= dtemplate
[i
].input
;
1382 req
.avail_in
= dtemplate
[i
].inlen
/ 2;
1383 req
.next_out
= result
;
1384 req
.avail_out
= dtemplate
[i
].outlen
/ 2;
1386 res
= crypto_decompress_update(tfm
, &req
);
1387 if (res
< 0 && (res
!= -EAGAIN
|| req
.avail_in
)) {
1388 pr_err("alg: pcomp: decompression update failed on "
1389 "test %d for %s: error=%d\n", i
+ 1, algo
, res
);
1395 /* Add remaining input data */
1396 req
.avail_in
+= (dtemplate
[i
].inlen
+ 1) / 2;
1398 res
= crypto_decompress_update(tfm
, &req
);
1399 if (res
< 0 && (res
!= -EAGAIN
|| req
.avail_in
)) {
1400 pr_err("alg: pcomp: decompression update failed on "
1401 "test %d for %s: error=%d\n", i
+ 1, algo
, res
);
1407 /* Provide remaining output space */
1408 req
.avail_out
+= COMP_BUF_SIZE
- dtemplate
[i
].outlen
/ 2;
1410 res
= crypto_decompress_final(tfm
, &req
);
1411 if (res
< 0 && (res
!= -EAGAIN
|| req
.avail_in
)) {
1412 pr_err("alg: pcomp: decompression final failed on "
1413 "test %d for %s: error=%d\n", i
+ 1, algo
, res
);
1419 if (COMP_BUF_SIZE
- req
.avail_out
!= dtemplate
[i
].outlen
) {
1420 pr_err("alg: comp: Decompression test %d failed for "
1421 "%s: output len = %d (expected %d)\n", i
+ 1,
1422 algo
, COMP_BUF_SIZE
- req
.avail_out
,
1423 dtemplate
[i
].outlen
);
1427 if (produced
!= dtemplate
[i
].outlen
) {
1428 pr_err("alg: comp: Decompression test %d failed for "
1429 "%s: returned len = %u (expected %d)\n", i
+ 1,
1430 algo
, produced
, dtemplate
[i
].outlen
);
1434 if (memcmp(result
, dtemplate
[i
].output
, dtemplate
[i
].outlen
)) {
1435 pr_err("alg: pcomp: Decompression test %d failed for "
1436 "%s\n", i
+ 1, algo
);
1437 hexdump(result
, dtemplate
[i
].outlen
);
1446 static int test_cprng(struct crypto_rng
*tfm
, struct cprng_testvec
*template,
1447 unsigned int tcount
)
1449 const char *algo
= crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm
));
1450 int err
= 0, i
, j
, seedsize
;
1454 seedsize
= crypto_rng_seedsize(tfm
);
1456 seed
= kmalloc(seedsize
, GFP_KERNEL
);
1458 printk(KERN_ERR
"alg: cprng: Failed to allocate seed space "
1463 for (i
= 0; i
< tcount
; i
++) {
1464 memset(result
, 0, 32);
1466 memcpy(seed
, template[i
].v
, template[i
].vlen
);
1467 memcpy(seed
+ template[i
].vlen
, template[i
].key
,
1469 memcpy(seed
+ template[i
].vlen
+ template[i
].klen
,
1470 template[i
].dt
, template[i
].dtlen
);
1472 err
= crypto_rng_reset(tfm
, seed
, seedsize
);
1474 printk(KERN_ERR
"alg: cprng: Failed to reset rng "
1479 for (j
= 0; j
< template[i
].loops
; j
++) {
1480 err
= crypto_rng_get_bytes(tfm
, result
,
1482 if (err
!= template[i
].rlen
) {
1483 printk(KERN_ERR
"alg: cprng: Failed to obtain "
1484 "the correct amount of random data for "
1485 "%s (requested %d, got %d)\n", algo
,
1486 template[i
].rlen
, err
);
1491 err
= memcmp(result
, template[i
].result
,
1494 printk(KERN_ERR
"alg: cprng: Test %d failed for %s\n",
1496 hexdump(result
, template[i
].rlen
);
1507 static int alg_test_aead(const struct alg_test_desc
*desc
, const char *driver
,
1510 struct crypto_aead
*tfm
;
1513 tfm
= crypto_alloc_aead(driver
, type
, mask
);
1515 printk(KERN_ERR
"alg: aead: Failed to load transform for %s: "
1516 "%ld\n", driver
, PTR_ERR(tfm
));
1517 return PTR_ERR(tfm
);
1520 if (desc
->suite
.aead
.enc
.vecs
) {
1521 err
= test_aead(tfm
, ENCRYPT
, desc
->suite
.aead
.enc
.vecs
,
1522 desc
->suite
.aead
.enc
.count
);
1527 if (!err
&& desc
->suite
.aead
.dec
.vecs
)
1528 err
= test_aead(tfm
, DECRYPT
, desc
->suite
.aead
.dec
.vecs
,
1529 desc
->suite
.aead
.dec
.count
);
1532 crypto_free_aead(tfm
);
1536 static int alg_test_cipher(const struct alg_test_desc
*desc
,
1537 const char *driver
, u32 type
, u32 mask
)
1539 struct crypto_cipher
*tfm
;
1542 tfm
= crypto_alloc_cipher(driver
, type
, mask
);
1544 printk(KERN_ERR
"alg: cipher: Failed to load transform for "
1545 "%s: %ld\n", driver
, PTR_ERR(tfm
));
1546 return PTR_ERR(tfm
);
1549 if (desc
->suite
.cipher
.enc
.vecs
) {
1550 err
= test_cipher(tfm
, ENCRYPT
, desc
->suite
.cipher
.enc
.vecs
,
1551 desc
->suite
.cipher
.enc
.count
);
1556 if (desc
->suite
.cipher
.dec
.vecs
)
1557 err
= test_cipher(tfm
, DECRYPT
, desc
->suite
.cipher
.dec
.vecs
,
1558 desc
->suite
.cipher
.dec
.count
);
1561 crypto_free_cipher(tfm
);
1565 static int alg_test_skcipher(const struct alg_test_desc
*desc
,
1566 const char *driver
, u32 type
, u32 mask
)
1568 struct crypto_ablkcipher
*tfm
;
1571 tfm
= crypto_alloc_ablkcipher(driver
, type
, mask
);
1573 printk(KERN_ERR
"alg: skcipher: Failed to load transform for "
1574 "%s: %ld\n", driver
, PTR_ERR(tfm
));
1575 return PTR_ERR(tfm
);
1578 if (desc
->suite
.cipher
.enc
.vecs
) {
1579 err
= test_skcipher(tfm
, ENCRYPT
, desc
->suite
.cipher
.enc
.vecs
,
1580 desc
->suite
.cipher
.enc
.count
);
1585 if (desc
->suite
.cipher
.dec
.vecs
)
1586 err
= test_skcipher(tfm
, DECRYPT
, desc
->suite
.cipher
.dec
.vecs
,
1587 desc
->suite
.cipher
.dec
.count
);
1590 crypto_free_ablkcipher(tfm
);
1594 static int alg_test_comp(const struct alg_test_desc
*desc
, const char *driver
,
1597 struct crypto_comp
*tfm
;
1600 tfm
= crypto_alloc_comp(driver
, type
, mask
);
1602 printk(KERN_ERR
"alg: comp: Failed to load transform for %s: "
1603 "%ld\n", driver
, PTR_ERR(tfm
));
1604 return PTR_ERR(tfm
);
1607 err
= test_comp(tfm
, desc
->suite
.comp
.comp
.vecs
,
1608 desc
->suite
.comp
.decomp
.vecs
,
1609 desc
->suite
.comp
.comp
.count
,
1610 desc
->suite
.comp
.decomp
.count
);
1612 crypto_free_comp(tfm
);
1616 static int alg_test_pcomp(const struct alg_test_desc
*desc
, const char *driver
,
1619 struct crypto_pcomp
*tfm
;
1622 tfm
= crypto_alloc_pcomp(driver
, type
, mask
);
1624 pr_err("alg: pcomp: Failed to load transform for %s: %ld\n",
1625 driver
, PTR_ERR(tfm
));
1626 return PTR_ERR(tfm
);
1629 err
= test_pcomp(tfm
, desc
->suite
.pcomp
.comp
.vecs
,
1630 desc
->suite
.pcomp
.decomp
.vecs
,
1631 desc
->suite
.pcomp
.comp
.count
,
1632 desc
->suite
.pcomp
.decomp
.count
);
1634 crypto_free_pcomp(tfm
);
1638 static int alg_test_hash(const struct alg_test_desc
*desc
, const char *driver
,
1641 struct crypto_ahash
*tfm
;
1644 tfm
= crypto_alloc_ahash(driver
, type
, mask
);
1646 printk(KERN_ERR
"alg: hash: Failed to load transform for %s: "
1647 "%ld\n", driver
, PTR_ERR(tfm
));
1648 return PTR_ERR(tfm
);
1651 err
= test_hash(tfm
, desc
->suite
.hash
.vecs
,
1652 desc
->suite
.hash
.count
, true);
1654 err
= test_hash(tfm
, desc
->suite
.hash
.vecs
,
1655 desc
->suite
.hash
.count
, false);
1657 crypto_free_ahash(tfm
);
1661 static int alg_test_crc32c(const struct alg_test_desc
*desc
,
1662 const char *driver
, u32 type
, u32 mask
)
1664 struct crypto_shash
*tfm
;
1668 err
= alg_test_hash(desc
, driver
, type
, mask
);
1672 tfm
= crypto_alloc_shash(driver
, type
, mask
);
1674 printk(KERN_ERR
"alg: crc32c: Failed to load transform for %s: "
1675 "%ld\n", driver
, PTR_ERR(tfm
));
1682 struct shash_desc shash
;
1683 char ctx
[crypto_shash_descsize(tfm
)];
1686 sdesc
.shash
.tfm
= tfm
;
1687 sdesc
.shash
.flags
= 0;
1689 *(u32
*)sdesc
.ctx
= le32_to_cpu(420553207);
1690 err
= crypto_shash_final(&sdesc
.shash
, (u8
*)&val
);
1692 printk(KERN_ERR
"alg: crc32c: Operation failed for "
1693 "%s: %d\n", driver
, err
);
1697 if (val
!= ~420553207) {
1698 printk(KERN_ERR
"alg: crc32c: Test failed for %s: "
1699 "%d\n", driver
, val
);
1704 crypto_free_shash(tfm
);
1710 static int alg_test_cprng(const struct alg_test_desc
*desc
, const char *driver
,
1713 struct crypto_rng
*rng
;
1716 rng
= crypto_alloc_rng(driver
, type
, mask
);
1718 printk(KERN_ERR
"alg: cprng: Failed to load transform for %s: "
1719 "%ld\n", driver
, PTR_ERR(rng
));
1720 return PTR_ERR(rng
);
1723 err
= test_cprng(rng
, desc
->suite
.cprng
.vecs
, desc
->suite
.cprng
.count
);
1725 crypto_free_rng(rng
);
1731 static int drbg_cavs_test(struct drbg_testvec
*test
, int pr
,
1732 const char *driver
, u32 type
, u32 mask
)
1735 struct crypto_rng
*drng
;
1736 struct drbg_test_data test_data
;
1737 struct drbg_string addtl
, pers
, testentropy
;
1738 unsigned char *buf
= kzalloc(test
->expectedlen
, GFP_KERNEL
);
1743 drng
= crypto_alloc_rng(driver
, type
, mask
);
1745 printk(KERN_ERR
"alg: drbg: could not allocate DRNG handle for "
1751 test_data
.testentropy
= &testentropy
;
1752 drbg_string_fill(&testentropy
, test
->entropy
, test
->entropylen
);
1753 drbg_string_fill(&pers
, test
->pers
, test
->perslen
);
1754 ret
= crypto_drbg_reset_test(drng
, &pers
, &test_data
);
1756 printk(KERN_ERR
"alg: drbg: Failed to reset rng\n");
1760 drbg_string_fill(&addtl
, test
->addtla
, test
->addtllen
);
1762 drbg_string_fill(&testentropy
, test
->entpra
, test
->entprlen
);
1763 ret
= crypto_drbg_get_bytes_addtl_test(drng
,
1764 buf
, test
->expectedlen
, &addtl
, &test_data
);
1766 ret
= crypto_drbg_get_bytes_addtl(drng
,
1767 buf
, test
->expectedlen
, &addtl
);
1770 printk(KERN_ERR
"alg: drbg: could not obtain random data for "
1771 "driver %s\n", driver
);
1775 drbg_string_fill(&addtl
, test
->addtlb
, test
->addtllen
);
1777 drbg_string_fill(&testentropy
, test
->entprb
, test
->entprlen
);
1778 ret
= crypto_drbg_get_bytes_addtl_test(drng
,
1779 buf
, test
->expectedlen
, &addtl
, &test_data
);
1781 ret
= crypto_drbg_get_bytes_addtl(drng
,
1782 buf
, test
->expectedlen
, &addtl
);
1785 printk(KERN_ERR
"alg: drbg: could not obtain random data for "
1786 "driver %s\n", driver
);
1790 ret
= memcmp(test
->expected
, buf
, test
->expectedlen
);
1793 crypto_free_rng(drng
);
1799 static int alg_test_drbg(const struct alg_test_desc
*desc
, const char *driver
,
1805 struct drbg_testvec
*template = desc
->suite
.drbg
.vecs
;
1806 unsigned int tcount
= desc
->suite
.drbg
.count
;
1808 if (0 == memcmp(driver
, "drbg_pr_", 8))
1811 for (i
= 0; i
< tcount
; i
++) {
1812 err
= drbg_cavs_test(&template[i
], pr
, driver
, type
, mask
);
1814 printk(KERN_ERR
"alg: drbg: Test %d failed for %s\n",
1824 static int alg_test_null(const struct alg_test_desc
*desc
,
1825 const char *driver
, u32 type
, u32 mask
)
1830 /* Please keep this list sorted by algorithm name. */
1831 static const struct alg_test_desc alg_test_descs
[] = {
1833 .alg
= "__cbc-cast5-avx",
1834 .test
= alg_test_null
,
1836 .alg
= "__cbc-cast6-avx",
1837 .test
= alg_test_null
,
1839 .alg
= "__cbc-serpent-avx",
1840 .test
= alg_test_null
,
1842 .alg
= "__cbc-serpent-avx2",
1843 .test
= alg_test_null
,
1845 .alg
= "__cbc-serpent-sse2",
1846 .test
= alg_test_null
,
1848 .alg
= "__cbc-twofish-avx",
1849 .test
= alg_test_null
,
1851 .alg
= "__driver-cbc-aes-aesni",
1852 .test
= alg_test_null
,
1855 .alg
= "__driver-cbc-camellia-aesni",
1856 .test
= alg_test_null
,
1858 .alg
= "__driver-cbc-camellia-aesni-avx2",
1859 .test
= alg_test_null
,
1861 .alg
= "__driver-cbc-cast5-avx",
1862 .test
= alg_test_null
,
1864 .alg
= "__driver-cbc-cast6-avx",
1865 .test
= alg_test_null
,
1867 .alg
= "__driver-cbc-serpent-avx",
1868 .test
= alg_test_null
,
1870 .alg
= "__driver-cbc-serpent-avx2",
1871 .test
= alg_test_null
,
1873 .alg
= "__driver-cbc-serpent-sse2",
1874 .test
= alg_test_null
,
1876 .alg
= "__driver-cbc-twofish-avx",
1877 .test
= alg_test_null
,
1879 .alg
= "__driver-ecb-aes-aesni",
1880 .test
= alg_test_null
,
1883 .alg
= "__driver-ecb-camellia-aesni",
1884 .test
= alg_test_null
,
1886 .alg
= "__driver-ecb-camellia-aesni-avx2",
1887 .test
= alg_test_null
,
1889 .alg
= "__driver-ecb-cast5-avx",
1890 .test
= alg_test_null
,
1892 .alg
= "__driver-ecb-cast6-avx",
1893 .test
= alg_test_null
,
1895 .alg
= "__driver-ecb-serpent-avx",
1896 .test
= alg_test_null
,
1898 .alg
= "__driver-ecb-serpent-avx2",
1899 .test
= alg_test_null
,
1901 .alg
= "__driver-ecb-serpent-sse2",
1902 .test
= alg_test_null
,
1904 .alg
= "__driver-ecb-twofish-avx",
1905 .test
= alg_test_null
,
1907 .alg
= "__ghash-pclmulqdqni",
1908 .test
= alg_test_null
,
1911 .alg
= "ansi_cprng",
1912 .test
= alg_test_cprng
,
1916 .vecs
= ansi_cprng_aes_tv_template
,
1917 .count
= ANSI_CPRNG_AES_TEST_VECTORS
1921 .alg
= "authenc(hmac(md5),ecb(cipher_null))",
1922 .test
= alg_test_aead
,
1927 .vecs
= hmac_md5_ecb_cipher_null_enc_tv_template
,
1928 .count
= HMAC_MD5_ECB_CIPHER_NULL_ENC_TEST_VECTORS
1931 .vecs
= hmac_md5_ecb_cipher_null_dec_tv_template
,
1932 .count
= HMAC_MD5_ECB_CIPHER_NULL_DEC_TEST_VECTORS
1937 .alg
= "authenc(hmac(sha1),cbc(aes))",
1938 .test
= alg_test_aead
,
1944 hmac_sha1_aes_cbc_enc_tv_temp
,
1946 HMAC_SHA1_AES_CBC_ENC_TEST_VEC
1951 .alg
= "authenc(hmac(sha1),cbc(des))",
1952 .test
= alg_test_aead
,
1958 hmac_sha1_des_cbc_enc_tv_temp
,
1960 HMAC_SHA1_DES_CBC_ENC_TEST_VEC
1965 .alg
= "authenc(hmac(sha1),cbc(des3_ede))",
1966 .test
= alg_test_aead
,
1972 hmac_sha1_des3_ede_cbc_enc_tv_temp
,
1974 HMAC_SHA1_DES3_EDE_CBC_ENC_TEST_VEC
1979 .alg
= "authenc(hmac(sha1),ecb(cipher_null))",
1980 .test
= alg_test_aead
,
1986 hmac_sha1_ecb_cipher_null_enc_tv_temp
,
1988 HMAC_SHA1_ECB_CIPHER_NULL_ENC_TEST_VEC
1992 hmac_sha1_ecb_cipher_null_dec_tv_temp
,
1994 HMAC_SHA1_ECB_CIPHER_NULL_DEC_TEST_VEC
1999 .alg
= "authenc(hmac(sha224),cbc(des))",
2000 .test
= alg_test_aead
,
2006 hmac_sha224_des_cbc_enc_tv_temp
,
2008 HMAC_SHA224_DES_CBC_ENC_TEST_VEC
2013 .alg
= "authenc(hmac(sha224),cbc(des3_ede))",
2014 .test
= alg_test_aead
,
2020 hmac_sha224_des3_ede_cbc_enc_tv_temp
,
2022 HMAC_SHA224_DES3_EDE_CBC_ENC_TEST_VEC
2027 .alg
= "authenc(hmac(sha256),cbc(aes))",
2028 .test
= alg_test_aead
,
2034 hmac_sha256_aes_cbc_enc_tv_temp
,
2036 HMAC_SHA256_AES_CBC_ENC_TEST_VEC
2041 .alg
= "authenc(hmac(sha256),cbc(des))",
2042 .test
= alg_test_aead
,
2048 hmac_sha256_des_cbc_enc_tv_temp
,
2050 HMAC_SHA256_DES_CBC_ENC_TEST_VEC
2055 .alg
= "authenc(hmac(sha256),cbc(des3_ede))",
2056 .test
= alg_test_aead
,
2062 hmac_sha256_des3_ede_cbc_enc_tv_temp
,
2064 HMAC_SHA256_DES3_EDE_CBC_ENC_TEST_VEC
2069 .alg
= "authenc(hmac(sha384),cbc(des))",
2070 .test
= alg_test_aead
,
2076 hmac_sha384_des_cbc_enc_tv_temp
,
2078 HMAC_SHA384_DES_CBC_ENC_TEST_VEC
2083 .alg
= "authenc(hmac(sha384),cbc(des3_ede))",
2084 .test
= alg_test_aead
,
2090 hmac_sha384_des3_ede_cbc_enc_tv_temp
,
2092 HMAC_SHA384_DES3_EDE_CBC_ENC_TEST_VEC
2097 .alg
= "authenc(hmac(sha512),cbc(aes))",
2098 .test
= alg_test_aead
,
2104 hmac_sha512_aes_cbc_enc_tv_temp
,
2106 HMAC_SHA512_AES_CBC_ENC_TEST_VEC
2111 .alg
= "authenc(hmac(sha512),cbc(des))",
2112 .test
= alg_test_aead
,
2118 hmac_sha512_des_cbc_enc_tv_temp
,
2120 HMAC_SHA512_DES_CBC_ENC_TEST_VEC
2125 .alg
= "authenc(hmac(sha512),cbc(des3_ede))",
2126 .test
= alg_test_aead
,
2132 hmac_sha512_des3_ede_cbc_enc_tv_temp
,
2134 HMAC_SHA512_DES3_EDE_CBC_ENC_TEST_VEC
2140 .test
= alg_test_skcipher
,
2145 .vecs
= aes_cbc_enc_tv_template
,
2146 .count
= AES_CBC_ENC_TEST_VECTORS
2149 .vecs
= aes_cbc_dec_tv_template
,
2150 .count
= AES_CBC_DEC_TEST_VECTORS
2155 .alg
= "cbc(anubis)",
2156 .test
= alg_test_skcipher
,
2160 .vecs
= anubis_cbc_enc_tv_template
,
2161 .count
= ANUBIS_CBC_ENC_TEST_VECTORS
2164 .vecs
= anubis_cbc_dec_tv_template
,
2165 .count
= ANUBIS_CBC_DEC_TEST_VECTORS
2170 .alg
= "cbc(blowfish)",
2171 .test
= alg_test_skcipher
,
2175 .vecs
= bf_cbc_enc_tv_template
,
2176 .count
= BF_CBC_ENC_TEST_VECTORS
2179 .vecs
= bf_cbc_dec_tv_template
,
2180 .count
= BF_CBC_DEC_TEST_VECTORS
2185 .alg
= "cbc(camellia)",
2186 .test
= alg_test_skcipher
,
2190 .vecs
= camellia_cbc_enc_tv_template
,
2191 .count
= CAMELLIA_CBC_ENC_TEST_VECTORS
2194 .vecs
= camellia_cbc_dec_tv_template
,
2195 .count
= CAMELLIA_CBC_DEC_TEST_VECTORS
2200 .alg
= "cbc(cast5)",
2201 .test
= alg_test_skcipher
,
2205 .vecs
= cast5_cbc_enc_tv_template
,
2206 .count
= CAST5_CBC_ENC_TEST_VECTORS
2209 .vecs
= cast5_cbc_dec_tv_template
,
2210 .count
= CAST5_CBC_DEC_TEST_VECTORS
2215 .alg
= "cbc(cast6)",
2216 .test
= alg_test_skcipher
,
2220 .vecs
= cast6_cbc_enc_tv_template
,
2221 .count
= CAST6_CBC_ENC_TEST_VECTORS
2224 .vecs
= cast6_cbc_dec_tv_template
,
2225 .count
= CAST6_CBC_DEC_TEST_VECTORS
2231 .test
= alg_test_skcipher
,
2235 .vecs
= des_cbc_enc_tv_template
,
2236 .count
= DES_CBC_ENC_TEST_VECTORS
2239 .vecs
= des_cbc_dec_tv_template
,
2240 .count
= DES_CBC_DEC_TEST_VECTORS
2245 .alg
= "cbc(des3_ede)",
2246 .test
= alg_test_skcipher
,
2251 .vecs
= des3_ede_cbc_enc_tv_template
,
2252 .count
= DES3_EDE_CBC_ENC_TEST_VECTORS
2255 .vecs
= des3_ede_cbc_dec_tv_template
,
2256 .count
= DES3_EDE_CBC_DEC_TEST_VECTORS
2261 .alg
= "cbc(serpent)",
2262 .test
= alg_test_skcipher
,
2266 .vecs
= serpent_cbc_enc_tv_template
,
2267 .count
= SERPENT_CBC_ENC_TEST_VECTORS
2270 .vecs
= serpent_cbc_dec_tv_template
,
2271 .count
= SERPENT_CBC_DEC_TEST_VECTORS
2276 .alg
= "cbc(twofish)",
2277 .test
= alg_test_skcipher
,
2281 .vecs
= tf_cbc_enc_tv_template
,
2282 .count
= TF_CBC_ENC_TEST_VECTORS
2285 .vecs
= tf_cbc_dec_tv_template
,
2286 .count
= TF_CBC_DEC_TEST_VECTORS
2292 .test
= alg_test_aead
,
2297 .vecs
= aes_ccm_enc_tv_template
,
2298 .count
= AES_CCM_ENC_TEST_VECTORS
2301 .vecs
= aes_ccm_dec_tv_template
,
2302 .count
= AES_CCM_DEC_TEST_VECTORS
2308 .test
= alg_test_hash
,
2311 .vecs
= aes_cmac128_tv_template
,
2312 .count
= CMAC_AES_TEST_VECTORS
2316 .alg
= "cmac(des3_ede)",
2317 .test
= alg_test_hash
,
2320 .vecs
= des3_ede_cmac64_tv_template
,
2321 .count
= CMAC_DES3_EDE_TEST_VECTORS
2325 .alg
= "compress_null",
2326 .test
= alg_test_null
,
2329 .test
= alg_test_crc32c
,
2333 .vecs
= crc32c_tv_template
,
2334 .count
= CRC32C_TEST_VECTORS
2339 .test
= alg_test_hash
,
2343 .vecs
= crct10dif_tv_template
,
2344 .count
= CRCT10DIF_TEST_VECTORS
2348 .alg
= "cryptd(__driver-cbc-aes-aesni)",
2349 .test
= alg_test_null
,
2352 .alg
= "cryptd(__driver-cbc-camellia-aesni)",
2353 .test
= alg_test_null
,
2355 .alg
= "cryptd(__driver-cbc-camellia-aesni-avx2)",
2356 .test
= alg_test_null
,
2358 .alg
= "cryptd(__driver-cbc-serpent-avx2)",
2359 .test
= alg_test_null
,
2361 .alg
= "cryptd(__driver-ecb-aes-aesni)",
2362 .test
= alg_test_null
,
2365 .alg
= "cryptd(__driver-ecb-camellia-aesni)",
2366 .test
= alg_test_null
,
2368 .alg
= "cryptd(__driver-ecb-camellia-aesni-avx2)",
2369 .test
= alg_test_null
,
2371 .alg
= "cryptd(__driver-ecb-cast5-avx)",
2372 .test
= alg_test_null
,
2374 .alg
= "cryptd(__driver-ecb-cast6-avx)",
2375 .test
= alg_test_null
,
2377 .alg
= "cryptd(__driver-ecb-serpent-avx)",
2378 .test
= alg_test_null
,
2380 .alg
= "cryptd(__driver-ecb-serpent-avx2)",
2381 .test
= alg_test_null
,
2383 .alg
= "cryptd(__driver-ecb-serpent-sse2)",
2384 .test
= alg_test_null
,
2386 .alg
= "cryptd(__driver-ecb-twofish-avx)",
2387 .test
= alg_test_null
,
2389 .alg
= "cryptd(__driver-gcm-aes-aesni)",
2390 .test
= alg_test_null
,
2393 .alg
= "cryptd(__ghash-pclmulqdqni)",
2394 .test
= alg_test_null
,
2398 .test
= alg_test_skcipher
,
2403 .vecs
= aes_ctr_enc_tv_template
,
2404 .count
= AES_CTR_ENC_TEST_VECTORS
2407 .vecs
= aes_ctr_dec_tv_template
,
2408 .count
= AES_CTR_DEC_TEST_VECTORS
2413 .alg
= "ctr(blowfish)",
2414 .test
= alg_test_skcipher
,
2418 .vecs
= bf_ctr_enc_tv_template
,
2419 .count
= BF_CTR_ENC_TEST_VECTORS
2422 .vecs
= bf_ctr_dec_tv_template
,
2423 .count
= BF_CTR_DEC_TEST_VECTORS
2428 .alg
= "ctr(camellia)",
2429 .test
= alg_test_skcipher
,
2433 .vecs
= camellia_ctr_enc_tv_template
,
2434 .count
= CAMELLIA_CTR_ENC_TEST_VECTORS
2437 .vecs
= camellia_ctr_dec_tv_template
,
2438 .count
= CAMELLIA_CTR_DEC_TEST_VECTORS
2443 .alg
= "ctr(cast5)",
2444 .test
= alg_test_skcipher
,
2448 .vecs
= cast5_ctr_enc_tv_template
,
2449 .count
= CAST5_CTR_ENC_TEST_VECTORS
2452 .vecs
= cast5_ctr_dec_tv_template
,
2453 .count
= CAST5_CTR_DEC_TEST_VECTORS
2458 .alg
= "ctr(cast6)",
2459 .test
= alg_test_skcipher
,
2463 .vecs
= cast6_ctr_enc_tv_template
,
2464 .count
= CAST6_CTR_ENC_TEST_VECTORS
2467 .vecs
= cast6_ctr_dec_tv_template
,
2468 .count
= CAST6_CTR_DEC_TEST_VECTORS
2474 .test
= alg_test_skcipher
,
2478 .vecs
= des_ctr_enc_tv_template
,
2479 .count
= DES_CTR_ENC_TEST_VECTORS
2482 .vecs
= des_ctr_dec_tv_template
,
2483 .count
= DES_CTR_DEC_TEST_VECTORS
2488 .alg
= "ctr(des3_ede)",
2489 .test
= alg_test_skcipher
,
2493 .vecs
= des3_ede_ctr_enc_tv_template
,
2494 .count
= DES3_EDE_CTR_ENC_TEST_VECTORS
2497 .vecs
= des3_ede_ctr_dec_tv_template
,
2498 .count
= DES3_EDE_CTR_DEC_TEST_VECTORS
2503 .alg
= "ctr(serpent)",
2504 .test
= alg_test_skcipher
,
2508 .vecs
= serpent_ctr_enc_tv_template
,
2509 .count
= SERPENT_CTR_ENC_TEST_VECTORS
2512 .vecs
= serpent_ctr_dec_tv_template
,
2513 .count
= SERPENT_CTR_DEC_TEST_VECTORS
2518 .alg
= "ctr(twofish)",
2519 .test
= alg_test_skcipher
,
2523 .vecs
= tf_ctr_enc_tv_template
,
2524 .count
= TF_CTR_ENC_TEST_VECTORS
2527 .vecs
= tf_ctr_dec_tv_template
,
2528 .count
= TF_CTR_DEC_TEST_VECTORS
2533 .alg
= "cts(cbc(aes))",
2534 .test
= alg_test_skcipher
,
2538 .vecs
= cts_mode_enc_tv_template
,
2539 .count
= CTS_MODE_ENC_TEST_VECTORS
2542 .vecs
= cts_mode_dec_tv_template
,
2543 .count
= CTS_MODE_DEC_TEST_VECTORS
2549 .test
= alg_test_comp
,
2554 .vecs
= deflate_comp_tv_template
,
2555 .count
= DEFLATE_COMP_TEST_VECTORS
2558 .vecs
= deflate_decomp_tv_template
,
2559 .count
= DEFLATE_DECOMP_TEST_VECTORS
2564 .alg
= "digest_null",
2565 .test
= alg_test_null
,
2567 .alg
= "drbg_nopr_ctr_aes128",
2568 .test
= alg_test_drbg
,
2572 .vecs
= drbg_nopr_ctr_aes128_tv_template
,
2573 .count
= ARRAY_SIZE(drbg_nopr_ctr_aes128_tv_template
)
2577 .alg
= "drbg_nopr_ctr_aes192",
2578 .test
= alg_test_drbg
,
2582 .vecs
= drbg_nopr_ctr_aes192_tv_template
,
2583 .count
= ARRAY_SIZE(drbg_nopr_ctr_aes192_tv_template
)
2587 .alg
= "drbg_nopr_ctr_aes256",
2588 .test
= alg_test_drbg
,
2592 .vecs
= drbg_nopr_ctr_aes256_tv_template
,
2593 .count
= ARRAY_SIZE(drbg_nopr_ctr_aes256_tv_template
)
2598 * There is no need to specifically test the DRBG with every
2599 * backend cipher -- covered by drbg_nopr_hmac_sha256 test
2601 .alg
= "drbg_nopr_hmac_sha1",
2603 .test
= alg_test_null
,
2605 .alg
= "drbg_nopr_hmac_sha256",
2606 .test
= alg_test_drbg
,
2610 .vecs
= drbg_nopr_hmac_sha256_tv_template
,
2612 ARRAY_SIZE(drbg_nopr_hmac_sha256_tv_template
)
2616 /* covered by drbg_nopr_hmac_sha256 test */
2617 .alg
= "drbg_nopr_hmac_sha384",
2619 .test
= alg_test_null
,
2621 .alg
= "drbg_nopr_hmac_sha512",
2622 .test
= alg_test_null
,
2625 .alg
= "drbg_nopr_sha1",
2627 .test
= alg_test_null
,
2629 .alg
= "drbg_nopr_sha256",
2630 .test
= alg_test_drbg
,
2634 .vecs
= drbg_nopr_sha256_tv_template
,
2635 .count
= ARRAY_SIZE(drbg_nopr_sha256_tv_template
)
2639 /* covered by drbg_nopr_sha256 test */
2640 .alg
= "drbg_nopr_sha384",
2642 .test
= alg_test_null
,
2644 .alg
= "drbg_nopr_sha512",
2646 .test
= alg_test_null
,
2648 .alg
= "drbg_pr_ctr_aes128",
2649 .test
= alg_test_drbg
,
2653 .vecs
= drbg_pr_ctr_aes128_tv_template
,
2654 .count
= ARRAY_SIZE(drbg_pr_ctr_aes128_tv_template
)
2658 /* covered by drbg_pr_ctr_aes128 test */
2659 .alg
= "drbg_pr_ctr_aes192",
2661 .test
= alg_test_null
,
2663 .alg
= "drbg_pr_ctr_aes256",
2665 .test
= alg_test_null
,
2667 .alg
= "drbg_pr_hmac_sha1",
2669 .test
= alg_test_null
,
2671 .alg
= "drbg_pr_hmac_sha256",
2672 .test
= alg_test_drbg
,
2676 .vecs
= drbg_pr_hmac_sha256_tv_template
,
2677 .count
= ARRAY_SIZE(drbg_pr_hmac_sha256_tv_template
)
2681 /* covered by drbg_pr_hmac_sha256 test */
2682 .alg
= "drbg_pr_hmac_sha384",
2684 .test
= alg_test_null
,
2686 .alg
= "drbg_pr_hmac_sha512",
2687 .test
= alg_test_null
,
2690 .alg
= "drbg_pr_sha1",
2692 .test
= alg_test_null
,
2694 .alg
= "drbg_pr_sha256",
2695 .test
= alg_test_drbg
,
2699 .vecs
= drbg_pr_sha256_tv_template
,
2700 .count
= ARRAY_SIZE(drbg_pr_sha256_tv_template
)
2704 /* covered by drbg_pr_sha256 test */
2705 .alg
= "drbg_pr_sha384",
2707 .test
= alg_test_null
,
2709 .alg
= "drbg_pr_sha512",
2711 .test
= alg_test_null
,
2713 .alg
= "ecb(__aes-aesni)",
2714 .test
= alg_test_null
,
2718 .test
= alg_test_skcipher
,
2723 .vecs
= aes_enc_tv_template
,
2724 .count
= AES_ENC_TEST_VECTORS
2727 .vecs
= aes_dec_tv_template
,
2728 .count
= AES_DEC_TEST_VECTORS
2733 .alg
= "ecb(anubis)",
2734 .test
= alg_test_skcipher
,
2738 .vecs
= anubis_enc_tv_template
,
2739 .count
= ANUBIS_ENC_TEST_VECTORS
2742 .vecs
= anubis_dec_tv_template
,
2743 .count
= ANUBIS_DEC_TEST_VECTORS
2749 .test
= alg_test_skcipher
,
2753 .vecs
= arc4_enc_tv_template
,
2754 .count
= ARC4_ENC_TEST_VECTORS
2757 .vecs
= arc4_dec_tv_template
,
2758 .count
= ARC4_DEC_TEST_VECTORS
2763 .alg
= "ecb(blowfish)",
2764 .test
= alg_test_skcipher
,
2768 .vecs
= bf_enc_tv_template
,
2769 .count
= BF_ENC_TEST_VECTORS
2772 .vecs
= bf_dec_tv_template
,
2773 .count
= BF_DEC_TEST_VECTORS
2778 .alg
= "ecb(camellia)",
2779 .test
= alg_test_skcipher
,
2783 .vecs
= camellia_enc_tv_template
,
2784 .count
= CAMELLIA_ENC_TEST_VECTORS
2787 .vecs
= camellia_dec_tv_template
,
2788 .count
= CAMELLIA_DEC_TEST_VECTORS
2793 .alg
= "ecb(cast5)",
2794 .test
= alg_test_skcipher
,
2798 .vecs
= cast5_enc_tv_template
,
2799 .count
= CAST5_ENC_TEST_VECTORS
2802 .vecs
= cast5_dec_tv_template
,
2803 .count
= CAST5_DEC_TEST_VECTORS
2808 .alg
= "ecb(cast6)",
2809 .test
= alg_test_skcipher
,
2813 .vecs
= cast6_enc_tv_template
,
2814 .count
= CAST6_ENC_TEST_VECTORS
2817 .vecs
= cast6_dec_tv_template
,
2818 .count
= CAST6_DEC_TEST_VECTORS
2823 .alg
= "ecb(cipher_null)",
2824 .test
= alg_test_null
,
2827 .test
= alg_test_skcipher
,
2832 .vecs
= des_enc_tv_template
,
2833 .count
= DES_ENC_TEST_VECTORS
2836 .vecs
= des_dec_tv_template
,
2837 .count
= DES_DEC_TEST_VECTORS
2842 .alg
= "ecb(des3_ede)",
2843 .test
= alg_test_skcipher
,
2848 .vecs
= des3_ede_enc_tv_template
,
2849 .count
= DES3_EDE_ENC_TEST_VECTORS
2852 .vecs
= des3_ede_dec_tv_template
,
2853 .count
= DES3_EDE_DEC_TEST_VECTORS
2858 .alg
= "ecb(fcrypt)",
2859 .test
= alg_test_skcipher
,
2863 .vecs
= fcrypt_pcbc_enc_tv_template
,
2867 .vecs
= fcrypt_pcbc_dec_tv_template
,
2873 .alg
= "ecb(khazad)",
2874 .test
= alg_test_skcipher
,
2878 .vecs
= khazad_enc_tv_template
,
2879 .count
= KHAZAD_ENC_TEST_VECTORS
2882 .vecs
= khazad_dec_tv_template
,
2883 .count
= KHAZAD_DEC_TEST_VECTORS
2889 .test
= alg_test_skcipher
,
2893 .vecs
= seed_enc_tv_template
,
2894 .count
= SEED_ENC_TEST_VECTORS
2897 .vecs
= seed_dec_tv_template
,
2898 .count
= SEED_DEC_TEST_VECTORS
2903 .alg
= "ecb(serpent)",
2904 .test
= alg_test_skcipher
,
2908 .vecs
= serpent_enc_tv_template
,
2909 .count
= SERPENT_ENC_TEST_VECTORS
2912 .vecs
= serpent_dec_tv_template
,
2913 .count
= SERPENT_DEC_TEST_VECTORS
2919 .test
= alg_test_skcipher
,
2923 .vecs
= tea_enc_tv_template
,
2924 .count
= TEA_ENC_TEST_VECTORS
2927 .vecs
= tea_dec_tv_template
,
2928 .count
= TEA_DEC_TEST_VECTORS
2933 .alg
= "ecb(tnepres)",
2934 .test
= alg_test_skcipher
,
2938 .vecs
= tnepres_enc_tv_template
,
2939 .count
= TNEPRES_ENC_TEST_VECTORS
2942 .vecs
= tnepres_dec_tv_template
,
2943 .count
= TNEPRES_DEC_TEST_VECTORS
2948 .alg
= "ecb(twofish)",
2949 .test
= alg_test_skcipher
,
2953 .vecs
= tf_enc_tv_template
,
2954 .count
= TF_ENC_TEST_VECTORS
2957 .vecs
= tf_dec_tv_template
,
2958 .count
= TF_DEC_TEST_VECTORS
2964 .test
= alg_test_skcipher
,
2968 .vecs
= xeta_enc_tv_template
,
2969 .count
= XETA_ENC_TEST_VECTORS
2972 .vecs
= xeta_dec_tv_template
,
2973 .count
= XETA_DEC_TEST_VECTORS
2979 .test
= alg_test_skcipher
,
2983 .vecs
= xtea_enc_tv_template
,
2984 .count
= XTEA_ENC_TEST_VECTORS
2987 .vecs
= xtea_dec_tv_template
,
2988 .count
= XTEA_DEC_TEST_VECTORS
2994 .test
= alg_test_aead
,
2999 .vecs
= aes_gcm_enc_tv_template
,
3000 .count
= AES_GCM_ENC_TEST_VECTORS
3003 .vecs
= aes_gcm_dec_tv_template
,
3004 .count
= AES_GCM_DEC_TEST_VECTORS
3010 .test
= alg_test_hash
,
3014 .vecs
= ghash_tv_template
,
3015 .count
= GHASH_TEST_VECTORS
3019 .alg
= "hmac(crc32)",
3020 .test
= alg_test_hash
,
3023 .vecs
= bfin_crc_tv_template
,
3024 .count
= BFIN_CRC_TEST_VECTORS
3029 .test
= alg_test_hash
,
3032 .vecs
= hmac_md5_tv_template
,
3033 .count
= HMAC_MD5_TEST_VECTORS
3037 .alg
= "hmac(rmd128)",
3038 .test
= alg_test_hash
,
3041 .vecs
= hmac_rmd128_tv_template
,
3042 .count
= HMAC_RMD128_TEST_VECTORS
3046 .alg
= "hmac(rmd160)",
3047 .test
= alg_test_hash
,
3050 .vecs
= hmac_rmd160_tv_template
,
3051 .count
= HMAC_RMD160_TEST_VECTORS
3055 .alg
= "hmac(sha1)",
3056 .test
= alg_test_hash
,
3060 .vecs
= hmac_sha1_tv_template
,
3061 .count
= HMAC_SHA1_TEST_VECTORS
3065 .alg
= "hmac(sha224)",
3066 .test
= alg_test_hash
,
3070 .vecs
= hmac_sha224_tv_template
,
3071 .count
= HMAC_SHA224_TEST_VECTORS
3075 .alg
= "hmac(sha256)",
3076 .test
= alg_test_hash
,
3080 .vecs
= hmac_sha256_tv_template
,
3081 .count
= HMAC_SHA256_TEST_VECTORS
3085 .alg
= "hmac(sha384)",
3086 .test
= alg_test_hash
,
3090 .vecs
= hmac_sha384_tv_template
,
3091 .count
= HMAC_SHA384_TEST_VECTORS
3095 .alg
= "hmac(sha512)",
3096 .test
= alg_test_hash
,
3100 .vecs
= hmac_sha512_tv_template
,
3101 .count
= HMAC_SHA512_TEST_VECTORS
3106 .test
= alg_test_skcipher
,
3110 .vecs
= aes_lrw_enc_tv_template
,
3111 .count
= AES_LRW_ENC_TEST_VECTORS
3114 .vecs
= aes_lrw_dec_tv_template
,
3115 .count
= AES_LRW_DEC_TEST_VECTORS
3120 .alg
= "lrw(camellia)",
3121 .test
= alg_test_skcipher
,
3125 .vecs
= camellia_lrw_enc_tv_template
,
3126 .count
= CAMELLIA_LRW_ENC_TEST_VECTORS
3129 .vecs
= camellia_lrw_dec_tv_template
,
3130 .count
= CAMELLIA_LRW_DEC_TEST_VECTORS
3135 .alg
= "lrw(cast6)",
3136 .test
= alg_test_skcipher
,
3140 .vecs
= cast6_lrw_enc_tv_template
,
3141 .count
= CAST6_LRW_ENC_TEST_VECTORS
3144 .vecs
= cast6_lrw_dec_tv_template
,
3145 .count
= CAST6_LRW_DEC_TEST_VECTORS
3150 .alg
= "lrw(serpent)",
3151 .test
= alg_test_skcipher
,
3155 .vecs
= serpent_lrw_enc_tv_template
,
3156 .count
= SERPENT_LRW_ENC_TEST_VECTORS
3159 .vecs
= serpent_lrw_dec_tv_template
,
3160 .count
= SERPENT_LRW_DEC_TEST_VECTORS
3165 .alg
= "lrw(twofish)",
3166 .test
= alg_test_skcipher
,
3170 .vecs
= tf_lrw_enc_tv_template
,
3171 .count
= TF_LRW_ENC_TEST_VECTORS
3174 .vecs
= tf_lrw_dec_tv_template
,
3175 .count
= TF_LRW_DEC_TEST_VECTORS
3181 .test
= alg_test_comp
,
3186 .vecs
= lz4_comp_tv_template
,
3187 .count
= LZ4_COMP_TEST_VECTORS
3190 .vecs
= lz4_decomp_tv_template
,
3191 .count
= LZ4_DECOMP_TEST_VECTORS
3197 .test
= alg_test_comp
,
3202 .vecs
= lz4hc_comp_tv_template
,
3203 .count
= LZ4HC_COMP_TEST_VECTORS
3206 .vecs
= lz4hc_decomp_tv_template
,
3207 .count
= LZ4HC_DECOMP_TEST_VECTORS
3213 .test
= alg_test_comp
,
3218 .vecs
= lzo_comp_tv_template
,
3219 .count
= LZO_COMP_TEST_VECTORS
3222 .vecs
= lzo_decomp_tv_template
,
3223 .count
= LZO_DECOMP_TEST_VECTORS
3229 .test
= alg_test_hash
,
3232 .vecs
= md4_tv_template
,
3233 .count
= MD4_TEST_VECTORS
3238 .test
= alg_test_hash
,
3241 .vecs
= md5_tv_template
,
3242 .count
= MD5_TEST_VECTORS
3246 .alg
= "michael_mic",
3247 .test
= alg_test_hash
,
3250 .vecs
= michael_mic_tv_template
,
3251 .count
= MICHAEL_MIC_TEST_VECTORS
3256 .test
= alg_test_skcipher
,
3261 .vecs
= aes_ofb_enc_tv_template
,
3262 .count
= AES_OFB_ENC_TEST_VECTORS
3265 .vecs
= aes_ofb_dec_tv_template
,
3266 .count
= AES_OFB_DEC_TEST_VECTORS
3271 .alg
= "pcbc(fcrypt)",
3272 .test
= alg_test_skcipher
,
3276 .vecs
= fcrypt_pcbc_enc_tv_template
,
3277 .count
= FCRYPT_ENC_TEST_VECTORS
3280 .vecs
= fcrypt_pcbc_dec_tv_template
,
3281 .count
= FCRYPT_DEC_TEST_VECTORS
3286 .alg
= "rfc3686(ctr(aes))",
3287 .test
= alg_test_skcipher
,
3292 .vecs
= aes_ctr_rfc3686_enc_tv_template
,
3293 .count
= AES_CTR_3686_ENC_TEST_VECTORS
3296 .vecs
= aes_ctr_rfc3686_dec_tv_template
,
3297 .count
= AES_CTR_3686_DEC_TEST_VECTORS
3302 .alg
= "rfc4106(gcm(aes))",
3303 .test
= alg_test_aead
,
3307 .vecs
= aes_gcm_rfc4106_enc_tv_template
,
3308 .count
= AES_GCM_4106_ENC_TEST_VECTORS
3311 .vecs
= aes_gcm_rfc4106_dec_tv_template
,
3312 .count
= AES_GCM_4106_DEC_TEST_VECTORS
3317 .alg
= "rfc4309(ccm(aes))",
3318 .test
= alg_test_aead
,
3323 .vecs
= aes_ccm_rfc4309_enc_tv_template
,
3324 .count
= AES_CCM_4309_ENC_TEST_VECTORS
3327 .vecs
= aes_ccm_rfc4309_dec_tv_template
,
3328 .count
= AES_CCM_4309_DEC_TEST_VECTORS
3333 .alg
= "rfc4543(gcm(aes))",
3334 .test
= alg_test_aead
,
3338 .vecs
= aes_gcm_rfc4543_enc_tv_template
,
3339 .count
= AES_GCM_4543_ENC_TEST_VECTORS
3342 .vecs
= aes_gcm_rfc4543_dec_tv_template
,
3343 .count
= AES_GCM_4543_DEC_TEST_VECTORS
3349 .test
= alg_test_hash
,
3352 .vecs
= rmd128_tv_template
,
3353 .count
= RMD128_TEST_VECTORS
3358 .test
= alg_test_hash
,
3361 .vecs
= rmd160_tv_template
,
3362 .count
= RMD160_TEST_VECTORS
3367 .test
= alg_test_hash
,
3370 .vecs
= rmd256_tv_template
,
3371 .count
= RMD256_TEST_VECTORS
3376 .test
= alg_test_hash
,
3379 .vecs
= rmd320_tv_template
,
3380 .count
= RMD320_TEST_VECTORS
3385 .test
= alg_test_skcipher
,
3389 .vecs
= salsa20_stream_enc_tv_template
,
3390 .count
= SALSA20_STREAM_ENC_TEST_VECTORS
3396 .test
= alg_test_hash
,
3400 .vecs
= sha1_tv_template
,
3401 .count
= SHA1_TEST_VECTORS
3406 .test
= alg_test_hash
,
3410 .vecs
= sha224_tv_template
,
3411 .count
= SHA224_TEST_VECTORS
3416 .test
= alg_test_hash
,
3420 .vecs
= sha256_tv_template
,
3421 .count
= SHA256_TEST_VECTORS
3426 .test
= alg_test_hash
,
3430 .vecs
= sha384_tv_template
,
3431 .count
= SHA384_TEST_VECTORS
3436 .test
= alg_test_hash
,
3440 .vecs
= sha512_tv_template
,
3441 .count
= SHA512_TEST_VECTORS
3446 .test
= alg_test_hash
,
3449 .vecs
= tgr128_tv_template
,
3450 .count
= TGR128_TEST_VECTORS
3455 .test
= alg_test_hash
,
3458 .vecs
= tgr160_tv_template
,
3459 .count
= TGR160_TEST_VECTORS
3464 .test
= alg_test_hash
,
3467 .vecs
= tgr192_tv_template
,
3468 .count
= TGR192_TEST_VECTORS
3473 .test
= alg_test_hash
,
3476 .vecs
= aes_vmac128_tv_template
,
3477 .count
= VMAC_AES_TEST_VECTORS
3482 .test
= alg_test_hash
,
3485 .vecs
= wp256_tv_template
,
3486 .count
= WP256_TEST_VECTORS
3491 .test
= alg_test_hash
,
3494 .vecs
= wp384_tv_template
,
3495 .count
= WP384_TEST_VECTORS
3500 .test
= alg_test_hash
,
3503 .vecs
= wp512_tv_template
,
3504 .count
= WP512_TEST_VECTORS
3509 .test
= alg_test_hash
,
3512 .vecs
= aes_xcbc128_tv_template
,
3513 .count
= XCBC_AES_TEST_VECTORS
3518 .test
= alg_test_skcipher
,
3523 .vecs
= aes_xts_enc_tv_template
,
3524 .count
= AES_XTS_ENC_TEST_VECTORS
3527 .vecs
= aes_xts_dec_tv_template
,
3528 .count
= AES_XTS_DEC_TEST_VECTORS
3533 .alg
= "xts(camellia)",
3534 .test
= alg_test_skcipher
,
3538 .vecs
= camellia_xts_enc_tv_template
,
3539 .count
= CAMELLIA_XTS_ENC_TEST_VECTORS
3542 .vecs
= camellia_xts_dec_tv_template
,
3543 .count
= CAMELLIA_XTS_DEC_TEST_VECTORS
3548 .alg
= "xts(cast6)",
3549 .test
= alg_test_skcipher
,
3553 .vecs
= cast6_xts_enc_tv_template
,
3554 .count
= CAST6_XTS_ENC_TEST_VECTORS
3557 .vecs
= cast6_xts_dec_tv_template
,
3558 .count
= CAST6_XTS_DEC_TEST_VECTORS
3563 .alg
= "xts(serpent)",
3564 .test
= alg_test_skcipher
,
3568 .vecs
= serpent_xts_enc_tv_template
,
3569 .count
= SERPENT_XTS_ENC_TEST_VECTORS
3572 .vecs
= serpent_xts_dec_tv_template
,
3573 .count
= SERPENT_XTS_DEC_TEST_VECTORS
3578 .alg
= "xts(twofish)",
3579 .test
= alg_test_skcipher
,
3583 .vecs
= tf_xts_enc_tv_template
,
3584 .count
= TF_XTS_ENC_TEST_VECTORS
3587 .vecs
= tf_xts_dec_tv_template
,
3588 .count
= TF_XTS_DEC_TEST_VECTORS
3594 .test
= alg_test_pcomp
,
3599 .vecs
= zlib_comp_tv_template
,
3600 .count
= ZLIB_COMP_TEST_VECTORS
3603 .vecs
= zlib_decomp_tv_template
,
3604 .count
= ZLIB_DECOMP_TEST_VECTORS
3611 static bool alg_test_descs_checked
;
3613 static void alg_test_descs_check_order(void)
3617 /* only check once */
3618 if (alg_test_descs_checked
)
3621 alg_test_descs_checked
= true;
3623 for (i
= 1; i
< ARRAY_SIZE(alg_test_descs
); i
++) {
3624 int diff
= strcmp(alg_test_descs
[i
- 1].alg
,
3625 alg_test_descs
[i
].alg
);
3627 if (WARN_ON(diff
> 0)) {
3628 pr_warn("testmgr: alg_test_descs entries in wrong order: '%s' before '%s'\n",
3629 alg_test_descs
[i
- 1].alg
,
3630 alg_test_descs
[i
].alg
);
3633 if (WARN_ON(diff
== 0)) {
3634 pr_warn("testmgr: duplicate alg_test_descs entry: '%s'\n",
3635 alg_test_descs
[i
].alg
);
3640 static int alg_find_test(const char *alg
)
3643 int end
= ARRAY_SIZE(alg_test_descs
);
3645 while (start
< end
) {
3646 int i
= (start
+ end
) / 2;
3647 int diff
= strcmp(alg_test_descs
[i
].alg
, alg
);
3665 int alg_test(const char *driver
, const char *alg
, u32 type
, u32 mask
)
3671 alg_test_descs_check_order();
3673 if ((type
& CRYPTO_ALG_TYPE_MASK
) == CRYPTO_ALG_TYPE_CIPHER
) {
3674 char nalg
[CRYPTO_MAX_ALG_NAME
];
3676 if (snprintf(nalg
, sizeof(nalg
), "ecb(%s)", alg
) >=
3678 return -ENAMETOOLONG
;
3680 i
= alg_find_test(nalg
);
3684 if (fips_enabled
&& !alg_test_descs
[i
].fips_allowed
)
3687 rc
= alg_test_cipher(alg_test_descs
+ i
, driver
, type
, mask
);
3691 i
= alg_find_test(alg
);
3692 j
= alg_find_test(driver
);
3696 if (fips_enabled
&& ((i
>= 0 && !alg_test_descs
[i
].fips_allowed
) ||
3697 (j
>= 0 && !alg_test_descs
[j
].fips_allowed
)))
3702 rc
|= alg_test_descs
[i
].test(alg_test_descs
+ i
, driver
,
3704 if (j
>= 0 && j
!= i
)
3705 rc
|= alg_test_descs
[j
].test(alg_test_descs
+ j
, driver
,
3709 if (fips_enabled
&& rc
)
3710 panic("%s: %s alg self test failed in fips mode!\n", driver
, alg
);
3712 if (fips_enabled
&& !rc
)
3713 pr_info(KERN_INFO
"alg: self-tests for %s (%s) passed\n",
3719 printk(KERN_INFO
"alg: No test for %s (%s)\n", alg
, driver
);
3725 #endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */
3727 EXPORT_SYMBOL_GPL(alg_test
);