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>
33 #ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
36 int alg_test(const char *driver
, const char *alg
, u32 type
, u32 mask
)
46 * Need slab memory for testing (size in number of pages).
51 * Indexes into the xbuf to simulate cross-page access.
63 * Used by test_cipher()
68 struct tcrypt_result
{
69 struct completion completion
;
73 struct aead_test_suite
{
75 struct aead_testvec
*vecs
;
80 struct cipher_test_suite
{
82 struct cipher_testvec
*vecs
;
87 struct comp_test_suite
{
89 struct comp_testvec
*vecs
;
94 struct pcomp_test_suite
{
96 struct pcomp_testvec
*vecs
;
101 struct hash_test_suite
{
102 struct hash_testvec
*vecs
;
106 struct cprng_test_suite
{
107 struct cprng_testvec
*vecs
;
111 struct alg_test_desc
{
113 int (*test
)(const struct alg_test_desc
*desc
, const char *driver
,
115 int fips_allowed
; /* set if alg is allowed in fips mode */
118 struct aead_test_suite aead
;
119 struct cipher_test_suite cipher
;
120 struct comp_test_suite comp
;
121 struct pcomp_test_suite pcomp
;
122 struct hash_test_suite hash
;
123 struct cprng_test_suite cprng
;
127 static unsigned int IDX
[8] = { IDX1
, IDX2
, IDX3
, IDX4
, IDX5
, IDX6
, IDX7
, IDX8
};
129 static void hexdump(unsigned char *buf
, unsigned int len
)
131 print_hex_dump(KERN_CONT
, "", DUMP_PREFIX_OFFSET
,
136 static void tcrypt_complete(struct crypto_async_request
*req
, int err
)
138 struct tcrypt_result
*res
= req
->data
;
140 if (err
== -EINPROGRESS
)
144 complete(&res
->completion
);
147 static int testmgr_alloc_buf(char *buf
[XBUFSIZE
])
151 for (i
= 0; i
< XBUFSIZE
; i
++) {
152 buf
[i
] = (void *)__get_free_page(GFP_KERNEL
);
161 free_page((unsigned long)buf
[i
]);
166 static void testmgr_free_buf(char *buf
[XBUFSIZE
])
170 for (i
= 0; i
< XBUFSIZE
; i
++)
171 free_page((unsigned long)buf
[i
]);
174 static int do_one_async_hash_op(struct ahash_request
*req
,
175 struct tcrypt_result
*tr
,
178 if (ret
== -EINPROGRESS
|| ret
== -EBUSY
) {
179 ret
= wait_for_completion_interruptible(&tr
->completion
);
182 reinit_completion(&tr
->completion
);
187 static int __test_hash(struct crypto_ahash
*tfm
, struct hash_testvec
*template,
188 unsigned int tcount
, bool use_digest
,
189 const int align_offset
)
191 const char *algo
= crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm
));
192 unsigned int i
, j
, k
, temp
;
193 struct scatterlist sg
[8];
195 struct ahash_request
*req
;
196 struct tcrypt_result tresult
;
198 char *xbuf
[XBUFSIZE
];
201 if (testmgr_alloc_buf(xbuf
))
204 init_completion(&tresult
.completion
);
206 req
= ahash_request_alloc(tfm
, GFP_KERNEL
);
208 printk(KERN_ERR
"alg: hash: Failed to allocate request for "
212 ahash_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
213 tcrypt_complete
, &tresult
);
216 for (i
= 0; i
< tcount
; i
++) {
221 if (WARN_ON(align_offset
+ template[i
].psize
> PAGE_SIZE
))
225 memset(result
, 0, 64);
228 hash_buff
+= align_offset
;
230 memcpy(hash_buff
, template[i
].plaintext
, template[i
].psize
);
231 sg_init_one(&sg
[0], hash_buff
, template[i
].psize
);
233 if (template[i
].ksize
) {
234 crypto_ahash_clear_flags(tfm
, ~0);
235 ret
= crypto_ahash_setkey(tfm
, template[i
].key
,
238 printk(KERN_ERR
"alg: hash: setkey failed on "
239 "test %d for %s: ret=%d\n", j
, algo
,
245 ahash_request_set_crypt(req
, sg
, result
, template[i
].psize
);
247 ret
= do_one_async_hash_op(req
, &tresult
,
248 crypto_ahash_digest(req
));
250 pr_err("alg: hash: digest failed on test %d "
251 "for %s: ret=%d\n", j
, algo
, -ret
);
255 ret
= do_one_async_hash_op(req
, &tresult
,
256 crypto_ahash_init(req
));
258 pr_err("alt: hash: init failed on test %d "
259 "for %s: ret=%d\n", j
, algo
, -ret
);
262 ret
= do_one_async_hash_op(req
, &tresult
,
263 crypto_ahash_update(req
));
265 pr_err("alt: hash: update failed on test %d "
266 "for %s: ret=%d\n", j
, algo
, -ret
);
269 ret
= do_one_async_hash_op(req
, &tresult
,
270 crypto_ahash_final(req
));
272 pr_err("alt: hash: final failed on test %d "
273 "for %s: ret=%d\n", j
, algo
, -ret
);
278 if (memcmp(result
, template[i
].digest
,
279 crypto_ahash_digestsize(tfm
))) {
280 printk(KERN_ERR
"alg: hash: Test %d failed for %s\n",
282 hexdump(result
, crypto_ahash_digestsize(tfm
));
289 for (i
= 0; i
< tcount
; i
++) {
290 /* alignment tests are only done with continuous buffers */
291 if (align_offset
!= 0)
294 if (template[i
].np
) {
296 memset(result
, 0, 64);
299 sg_init_table(sg
, template[i
].np
);
301 for (k
= 0; k
< template[i
].np
; k
++) {
302 if (WARN_ON(offset_in_page(IDX
[k
]) +
303 template[i
].tap
[k
] > PAGE_SIZE
))
306 memcpy(xbuf
[IDX
[k
] >> PAGE_SHIFT
] +
307 offset_in_page(IDX
[k
]),
308 template[i
].plaintext
+ temp
,
311 temp
+= template[i
].tap
[k
];
314 if (template[i
].ksize
) {
315 crypto_ahash_clear_flags(tfm
, ~0);
316 ret
= crypto_ahash_setkey(tfm
, template[i
].key
,
320 printk(KERN_ERR
"alg: hash: setkey "
321 "failed on chunking test %d "
322 "for %s: ret=%d\n", j
, algo
,
328 ahash_request_set_crypt(req
, sg
, result
,
330 ret
= crypto_ahash_digest(req
);
336 ret
= wait_for_completion_interruptible(
337 &tresult
.completion
);
338 if (!ret
&& !(ret
= tresult
.err
)) {
339 reinit_completion(&tresult
.completion
);
344 printk(KERN_ERR
"alg: hash: digest failed "
345 "on chunking test %d for %s: "
346 "ret=%d\n", j
, algo
, -ret
);
350 if (memcmp(result
, template[i
].digest
,
351 crypto_ahash_digestsize(tfm
))) {
352 printk(KERN_ERR
"alg: hash: Chunking test %d "
353 "failed for %s\n", j
, algo
);
354 hexdump(result
, crypto_ahash_digestsize(tfm
));
364 ahash_request_free(req
);
366 testmgr_free_buf(xbuf
);
371 static int test_hash(struct crypto_ahash
*tfm
, struct hash_testvec
*template,
372 unsigned int tcount
, bool use_digest
)
374 unsigned int alignmask
;
377 ret
= __test_hash(tfm
, template, tcount
, use_digest
, 0);
381 /* test unaligned buffers, check with one byte offset */
382 ret
= __test_hash(tfm
, template, tcount
, use_digest
, 1);
386 alignmask
= crypto_tfm_alg_alignmask(&tfm
->base
);
388 /* Check if alignment mask for tfm is correctly set. */
389 ret
= __test_hash(tfm
, template, tcount
, use_digest
,
398 static int __test_aead(struct crypto_aead
*tfm
, int enc
,
399 struct aead_testvec
*template, unsigned int tcount
,
400 const bool diff_dst
, const int align_offset
)
402 const char *algo
= crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm
));
403 unsigned int i
, j
, k
, n
, temp
;
407 struct aead_request
*req
;
408 struct scatterlist
*sg
;
409 struct scatterlist
*asg
;
410 struct scatterlist
*sgout
;
412 struct tcrypt_result result
;
413 unsigned int authsize
;
418 char *xbuf
[XBUFSIZE
];
419 char *xoutbuf
[XBUFSIZE
];
420 char *axbuf
[XBUFSIZE
];
422 if (testmgr_alloc_buf(xbuf
))
424 if (testmgr_alloc_buf(axbuf
))
427 if (diff_dst
&& testmgr_alloc_buf(xoutbuf
))
430 /* avoid "the frame size is larger than 1024 bytes" compiler warning */
431 sg
= kmalloc(sizeof(*sg
) * 8 * (diff_dst
? 3 : 2), GFP_KERNEL
);
447 init_completion(&result
.completion
);
449 req
= aead_request_alloc(tfm
, GFP_KERNEL
);
451 pr_err("alg: aead%s: Failed to allocate request for %s\n",
456 aead_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
457 tcrypt_complete
, &result
);
459 for (i
= 0, j
= 0; i
< tcount
; i
++) {
460 if (!template[i
].np
) {
463 /* some templates have no input data but they will
467 input
+= align_offset
;
471 if (WARN_ON(align_offset
+ template[i
].ilen
>
472 PAGE_SIZE
|| template[i
].alen
> PAGE_SIZE
))
475 memcpy(input
, template[i
].input
, template[i
].ilen
);
476 memcpy(assoc
, template[i
].assoc
, template[i
].alen
);
478 memcpy(iv
, template[i
].iv
, MAX_IVLEN
);
480 memset(iv
, 0, MAX_IVLEN
);
482 crypto_aead_clear_flags(tfm
, ~0);
484 crypto_aead_set_flags(
485 tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
487 key
= template[i
].key
;
489 ret
= crypto_aead_setkey(tfm
, key
,
491 if (!ret
== template[i
].fail
) {
492 pr_err("alg: aead%s: setkey failed on test %d for %s: flags=%x\n",
493 d
, j
, algo
, crypto_aead_get_flags(tfm
));
498 authsize
= abs(template[i
].rlen
- template[i
].ilen
);
499 ret
= crypto_aead_setauthsize(tfm
, authsize
);
501 pr_err("alg: aead%s: Failed to set authsize to %u on test %d for %s\n",
502 d
, authsize
, j
, algo
);
508 output
+= align_offset
;
509 sg_init_one(&sg
[0], input
, template[i
].ilen
);
510 sg_init_one(&sgout
[0], output
,
513 sg_init_one(&sg
[0], input
,
515 (enc
? authsize
: 0));
519 sg_init_one(&asg
[0], assoc
, template[i
].alen
);
521 aead_request_set_crypt(req
, sg
, (diff_dst
) ? sgout
: sg
,
522 template[i
].ilen
, iv
);
524 aead_request_set_assoc(req
, asg
, template[i
].alen
);
527 crypto_aead_encrypt(req
) :
528 crypto_aead_decrypt(req
);
532 if (template[i
].novrfy
) {
533 /* verification was supposed to fail */
534 pr_err("alg: aead%s: %s failed on test %d for %s: ret was 0, expected -EBADMSG\n",
536 /* so really, we got a bad message */
543 ret
= wait_for_completion_interruptible(
545 if (!ret
&& !(ret
= result
.err
)) {
546 reinit_completion(&result
.completion
);
550 if (template[i
].novrfy
)
551 /* verification failure was expected */
555 pr_err("alg: aead%s: %s failed on test %d for %s: ret=%d\n",
556 d
, e
, j
, algo
, -ret
);
561 if (memcmp(q
, template[i
].result
, template[i
].rlen
)) {
562 pr_err("alg: aead%s: Test %d failed on %s for %s\n",
564 hexdump(q
, template[i
].rlen
);
571 for (i
= 0, j
= 0; i
< tcount
; i
++) {
572 /* alignment tests are only done with continuous buffers */
573 if (align_offset
!= 0)
576 if (template[i
].np
) {
580 memcpy(iv
, template[i
].iv
, MAX_IVLEN
);
582 memset(iv
, 0, MAX_IVLEN
);
584 crypto_aead_clear_flags(tfm
, ~0);
586 crypto_aead_set_flags(
587 tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
588 key
= template[i
].key
;
590 ret
= crypto_aead_setkey(tfm
, key
, template[i
].klen
);
591 if (!ret
== template[i
].fail
) {
592 pr_err("alg: aead%s: setkey failed on chunk test %d for %s: flags=%x\n",
593 d
, j
, algo
, crypto_aead_get_flags(tfm
));
598 authsize
= abs(template[i
].rlen
- template[i
].ilen
);
601 sg_init_table(sg
, template[i
].np
);
603 sg_init_table(sgout
, template[i
].np
);
604 for (k
= 0, temp
= 0; k
< template[i
].np
; k
++) {
605 if (WARN_ON(offset_in_page(IDX
[k
]) +
606 template[i
].tap
[k
] > PAGE_SIZE
))
609 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] +
610 offset_in_page(IDX
[k
]);
612 memcpy(q
, template[i
].input
+ temp
,
615 sg_set_buf(&sg
[k
], q
, template[i
].tap
[k
]);
618 q
= xoutbuf
[IDX
[k
] >> PAGE_SHIFT
] +
619 offset_in_page(IDX
[k
]);
621 memset(q
, 0, template[i
].tap
[k
]);
623 sg_set_buf(&sgout
[k
], q
,
627 n
= template[i
].tap
[k
];
628 if (k
== template[i
].np
- 1 && enc
)
630 if (offset_in_page(q
) + n
< PAGE_SIZE
)
633 temp
+= template[i
].tap
[k
];
636 ret
= crypto_aead_setauthsize(tfm
, authsize
);
638 pr_err("alg: aead%s: Failed to set authsize to %u on chunk test %d for %s\n",
639 d
, authsize
, j
, algo
);
644 if (WARN_ON(sg
[k
- 1].offset
+
645 sg
[k
- 1].length
+ authsize
>
652 sgout
[k
- 1].length
+= authsize
;
654 sg
[k
- 1].length
+= authsize
;
657 sg_init_table(asg
, template[i
].anp
);
659 for (k
= 0, temp
= 0; k
< template[i
].anp
; k
++) {
660 if (WARN_ON(offset_in_page(IDX
[k
]) +
661 template[i
].atap
[k
] > PAGE_SIZE
))
664 memcpy(axbuf
[IDX
[k
] >> PAGE_SHIFT
] +
665 offset_in_page(IDX
[k
]),
666 template[i
].assoc
+ temp
,
667 template[i
].atap
[k
]),
668 template[i
].atap
[k
]);
669 temp
+= template[i
].atap
[k
];
672 aead_request_set_crypt(req
, sg
, (diff_dst
) ? sgout
: sg
,
676 aead_request_set_assoc(req
, asg
, template[i
].alen
);
679 crypto_aead_encrypt(req
) :
680 crypto_aead_decrypt(req
);
684 if (template[i
].novrfy
) {
685 /* verification was supposed to fail */
686 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret was 0, expected -EBADMSG\n",
688 /* so really, we got a bad message */
695 ret
= wait_for_completion_interruptible(
697 if (!ret
&& !(ret
= result
.err
)) {
698 reinit_completion(&result
.completion
);
702 if (template[i
].novrfy
)
703 /* verification failure was expected */
707 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret=%d\n",
708 d
, e
, j
, algo
, -ret
);
713 for (k
= 0, temp
= 0; k
< template[i
].np
; k
++) {
715 q
= xoutbuf
[IDX
[k
] >> PAGE_SHIFT
] +
716 offset_in_page(IDX
[k
]);
718 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] +
719 offset_in_page(IDX
[k
]);
721 n
= template[i
].tap
[k
];
722 if (k
== template[i
].np
- 1)
723 n
+= enc
? authsize
: -authsize
;
725 if (memcmp(q
, template[i
].result
+ temp
, n
)) {
726 pr_err("alg: aead%s: Chunk test %d failed on %s at page %u for %s\n",
733 if (k
== template[i
].np
- 1 && !enc
) {
735 memcmp(q
, template[i
].input
+
741 for (n
= 0; offset_in_page(q
+ n
) &&
746 pr_err("alg: aead%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
747 d
, j
, e
, k
, algo
, n
);
752 temp
+= template[i
].tap
[k
];
760 aead_request_free(req
);
764 testmgr_free_buf(xoutbuf
);
766 testmgr_free_buf(axbuf
);
768 testmgr_free_buf(xbuf
);
773 static int test_aead(struct crypto_aead
*tfm
, int enc
,
774 struct aead_testvec
*template, unsigned int tcount
)
776 unsigned int alignmask
;
779 /* test 'dst == src' case */
780 ret
= __test_aead(tfm
, enc
, template, tcount
, false, 0);
784 /* test 'dst != src' case */
785 ret
= __test_aead(tfm
, enc
, template, tcount
, true, 0);
789 /* test unaligned buffers, check with one byte offset */
790 ret
= __test_aead(tfm
, enc
, template, tcount
, true, 1);
794 alignmask
= crypto_tfm_alg_alignmask(&tfm
->base
);
796 /* Check if alignment mask for tfm is correctly set. */
797 ret
= __test_aead(tfm
, enc
, template, tcount
, true,
806 static int test_cipher(struct crypto_cipher
*tfm
, int enc
,
807 struct cipher_testvec
*template, unsigned int tcount
)
809 const char *algo
= crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm
));
810 unsigned int i
, j
, k
;
814 char *xbuf
[XBUFSIZE
];
817 if (testmgr_alloc_buf(xbuf
))
826 for (i
= 0; i
< tcount
; i
++) {
833 if (WARN_ON(template[i
].ilen
> PAGE_SIZE
))
837 memcpy(data
, template[i
].input
, template[i
].ilen
);
839 crypto_cipher_clear_flags(tfm
, ~0);
841 crypto_cipher_set_flags(tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
843 ret
= crypto_cipher_setkey(tfm
, template[i
].key
,
845 if (!ret
== template[i
].fail
) {
846 printk(KERN_ERR
"alg: cipher: setkey failed "
847 "on test %d for %s: flags=%x\n", j
,
848 algo
, crypto_cipher_get_flags(tfm
));
853 for (k
= 0; k
< template[i
].ilen
;
854 k
+= crypto_cipher_blocksize(tfm
)) {
856 crypto_cipher_encrypt_one(tfm
, data
+ k
,
859 crypto_cipher_decrypt_one(tfm
, data
+ k
,
864 if (memcmp(q
, template[i
].result
, template[i
].rlen
)) {
865 printk(KERN_ERR
"alg: cipher: Test %d failed "
866 "on %s for %s\n", j
, e
, algo
);
867 hexdump(q
, template[i
].rlen
);
876 testmgr_free_buf(xbuf
);
881 static int __test_skcipher(struct crypto_ablkcipher
*tfm
, int enc
,
882 struct cipher_testvec
*template, unsigned int tcount
,
883 const bool diff_dst
, const int align_offset
)
886 crypto_tfm_alg_driver_name(crypto_ablkcipher_tfm(tfm
));
887 unsigned int i
, j
, k
, n
, temp
;
889 struct ablkcipher_request
*req
;
890 struct scatterlist sg
[8];
891 struct scatterlist sgout
[8];
893 struct tcrypt_result result
;
896 char *xbuf
[XBUFSIZE
];
897 char *xoutbuf
[XBUFSIZE
];
900 if (testmgr_alloc_buf(xbuf
))
903 if (diff_dst
&& testmgr_alloc_buf(xoutbuf
))
916 init_completion(&result
.completion
);
918 req
= ablkcipher_request_alloc(tfm
, GFP_KERNEL
);
920 pr_err("alg: skcipher%s: Failed to allocate request for %s\n",
925 ablkcipher_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
926 tcrypt_complete
, &result
);
929 for (i
= 0; i
< tcount
; i
++) {
931 memcpy(iv
, template[i
].iv
, MAX_IVLEN
);
933 memset(iv
, 0, MAX_IVLEN
);
935 if (!(template[i
].np
) || (template[i
].also_non_np
)) {
939 if (WARN_ON(align_offset
+ template[i
].ilen
>
944 data
+= align_offset
;
945 memcpy(data
, template[i
].input
, template[i
].ilen
);
947 crypto_ablkcipher_clear_flags(tfm
, ~0);
949 crypto_ablkcipher_set_flags(
950 tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
952 ret
= crypto_ablkcipher_setkey(tfm
, template[i
].key
,
954 if (!ret
== template[i
].fail
) {
955 pr_err("alg: skcipher%s: setkey failed on test %d for %s: flags=%x\n",
957 crypto_ablkcipher_get_flags(tfm
));
962 sg_init_one(&sg
[0], data
, template[i
].ilen
);
965 data
+= align_offset
;
966 sg_init_one(&sgout
[0], data
, template[i
].ilen
);
969 ablkcipher_request_set_crypt(req
, sg
,
970 (diff_dst
) ? sgout
: sg
,
971 template[i
].ilen
, iv
);
973 crypto_ablkcipher_encrypt(req
) :
974 crypto_ablkcipher_decrypt(req
);
981 ret
= wait_for_completion_interruptible(
983 if (!ret
&& !((ret
= result
.err
))) {
984 reinit_completion(&result
.completion
);
989 pr_err("alg: skcipher%s: %s failed on test %d for %s: ret=%d\n",
990 d
, e
, j
, algo
, -ret
);
995 if (memcmp(q
, template[i
].result
, template[i
].rlen
)) {
996 pr_err("alg: skcipher%s: Test %d failed on %s for %s\n",
998 hexdump(q
, template[i
].rlen
);
1006 for (i
= 0; i
< tcount
; i
++) {
1007 /* alignment tests are only done with continuous buffers */
1008 if (align_offset
!= 0)
1012 memcpy(iv
, template[i
].iv
, MAX_IVLEN
);
1014 memset(iv
, 0, MAX_IVLEN
);
1016 if (template[i
].np
) {
1019 crypto_ablkcipher_clear_flags(tfm
, ~0);
1021 crypto_ablkcipher_set_flags(
1022 tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
1024 ret
= crypto_ablkcipher_setkey(tfm
, template[i
].key
,
1026 if (!ret
== template[i
].fail
) {
1027 pr_err("alg: skcipher%s: setkey failed on chunk test %d for %s: flags=%x\n",
1029 crypto_ablkcipher_get_flags(tfm
));
1036 sg_init_table(sg
, template[i
].np
);
1038 sg_init_table(sgout
, template[i
].np
);
1039 for (k
= 0; k
< template[i
].np
; k
++) {
1040 if (WARN_ON(offset_in_page(IDX
[k
]) +
1041 template[i
].tap
[k
] > PAGE_SIZE
))
1044 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] +
1045 offset_in_page(IDX
[k
]);
1047 memcpy(q
, template[i
].input
+ temp
,
1048 template[i
].tap
[k
]);
1050 if (offset_in_page(q
) + template[i
].tap
[k
] <
1052 q
[template[i
].tap
[k
]] = 0;
1054 sg_set_buf(&sg
[k
], q
, template[i
].tap
[k
]);
1056 q
= xoutbuf
[IDX
[k
] >> PAGE_SHIFT
] +
1057 offset_in_page(IDX
[k
]);
1059 sg_set_buf(&sgout
[k
], q
,
1060 template[i
].tap
[k
]);
1062 memset(q
, 0, template[i
].tap
[k
]);
1063 if (offset_in_page(q
) +
1064 template[i
].tap
[k
] < PAGE_SIZE
)
1065 q
[template[i
].tap
[k
]] = 0;
1068 temp
+= template[i
].tap
[k
];
1071 ablkcipher_request_set_crypt(req
, sg
,
1072 (diff_dst
) ? sgout
: sg
,
1073 template[i
].ilen
, iv
);
1076 crypto_ablkcipher_encrypt(req
) :
1077 crypto_ablkcipher_decrypt(req
);
1084 ret
= wait_for_completion_interruptible(
1085 &result
.completion
);
1086 if (!ret
&& !((ret
= result
.err
))) {
1087 reinit_completion(&result
.completion
);
1092 pr_err("alg: skcipher%s: %s failed on chunk test %d for %s: ret=%d\n",
1093 d
, e
, j
, algo
, -ret
);
1099 for (k
= 0; k
< template[i
].np
; k
++) {
1101 q
= xoutbuf
[IDX
[k
] >> PAGE_SHIFT
] +
1102 offset_in_page(IDX
[k
]);
1104 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] +
1105 offset_in_page(IDX
[k
]);
1107 if (memcmp(q
, template[i
].result
+ temp
,
1108 template[i
].tap
[k
])) {
1109 pr_err("alg: skcipher%s: Chunk test %d failed on %s at page %u for %s\n",
1111 hexdump(q
, template[i
].tap
[k
]);
1115 q
+= template[i
].tap
[k
];
1116 for (n
= 0; offset_in_page(q
+ n
) && q
[n
]; n
++)
1119 pr_err("alg: skcipher%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
1120 d
, j
, e
, k
, algo
, n
);
1124 temp
+= template[i
].tap
[k
];
1132 ablkcipher_request_free(req
);
1134 testmgr_free_buf(xoutbuf
);
1136 testmgr_free_buf(xbuf
);
1141 static int test_skcipher(struct crypto_ablkcipher
*tfm
, int enc
,
1142 struct cipher_testvec
*template, unsigned int tcount
)
1144 unsigned int alignmask
;
1147 /* test 'dst == src' case */
1148 ret
= __test_skcipher(tfm
, enc
, template, tcount
, false, 0);
1152 /* test 'dst != src' case */
1153 ret
= __test_skcipher(tfm
, enc
, template, tcount
, true, 0);
1157 /* test unaligned buffers, check with one byte offset */
1158 ret
= __test_skcipher(tfm
, enc
, template, tcount
, true, 1);
1162 alignmask
= crypto_tfm_alg_alignmask(&tfm
->base
);
1164 /* Check if alignment mask for tfm is correctly set. */
1165 ret
= __test_skcipher(tfm
, enc
, template, tcount
, true,
1174 static int test_comp(struct crypto_comp
*tfm
, struct comp_testvec
*ctemplate
,
1175 struct comp_testvec
*dtemplate
, int ctcount
, int dtcount
)
1177 const char *algo
= crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm
));
1179 char result
[COMP_BUF_SIZE
];
1182 for (i
= 0; i
< ctcount
; i
++) {
1184 unsigned int dlen
= COMP_BUF_SIZE
;
1186 memset(result
, 0, sizeof (result
));
1188 ilen
= ctemplate
[i
].inlen
;
1189 ret
= crypto_comp_compress(tfm
, ctemplate
[i
].input
,
1190 ilen
, result
, &dlen
);
1192 printk(KERN_ERR
"alg: comp: compression failed "
1193 "on test %d for %s: ret=%d\n", i
+ 1, algo
,
1198 if (dlen
!= ctemplate
[i
].outlen
) {
1199 printk(KERN_ERR
"alg: comp: Compression test %d "
1200 "failed for %s: output len = %d\n", i
+ 1, algo
,
1206 if (memcmp(result
, ctemplate
[i
].output
, dlen
)) {
1207 printk(KERN_ERR
"alg: comp: Compression test %d "
1208 "failed for %s\n", i
+ 1, algo
);
1209 hexdump(result
, dlen
);
1215 for (i
= 0; i
< dtcount
; i
++) {
1217 unsigned int dlen
= COMP_BUF_SIZE
;
1219 memset(result
, 0, sizeof (result
));
1221 ilen
= dtemplate
[i
].inlen
;
1222 ret
= crypto_comp_decompress(tfm
, dtemplate
[i
].input
,
1223 ilen
, result
, &dlen
);
1225 printk(KERN_ERR
"alg: comp: decompression failed "
1226 "on test %d for %s: ret=%d\n", i
+ 1, algo
,
1231 if (dlen
!= dtemplate
[i
].outlen
) {
1232 printk(KERN_ERR
"alg: comp: Decompression test %d "
1233 "failed for %s: output len = %d\n", i
+ 1, algo
,
1239 if (memcmp(result
, dtemplate
[i
].output
, dlen
)) {
1240 printk(KERN_ERR
"alg: comp: Decompression test %d "
1241 "failed for %s\n", i
+ 1, algo
);
1242 hexdump(result
, dlen
);
1254 static int test_pcomp(struct crypto_pcomp
*tfm
,
1255 struct pcomp_testvec
*ctemplate
,
1256 struct pcomp_testvec
*dtemplate
, int ctcount
,
1259 const char *algo
= crypto_tfm_alg_driver_name(crypto_pcomp_tfm(tfm
));
1261 char result
[COMP_BUF_SIZE
];
1264 for (i
= 0; i
< ctcount
; i
++) {
1265 struct comp_request req
;
1266 unsigned int produced
= 0;
1268 res
= crypto_compress_setup(tfm
, ctemplate
[i
].params
,
1269 ctemplate
[i
].paramsize
);
1271 pr_err("alg: pcomp: compression setup failed on test "
1272 "%d for %s: error=%d\n", i
+ 1, algo
, res
);
1276 res
= crypto_compress_init(tfm
);
1278 pr_err("alg: pcomp: compression init failed on test "
1279 "%d for %s: error=%d\n", i
+ 1, algo
, res
);
1283 memset(result
, 0, sizeof(result
));
1285 req
.next_in
= ctemplate
[i
].input
;
1286 req
.avail_in
= ctemplate
[i
].inlen
/ 2;
1287 req
.next_out
= result
;
1288 req
.avail_out
= ctemplate
[i
].outlen
/ 2;
1290 res
= crypto_compress_update(tfm
, &req
);
1291 if (res
< 0 && (res
!= -EAGAIN
|| req
.avail_in
)) {
1292 pr_err("alg: pcomp: compression update failed on test "
1293 "%d for %s: error=%d\n", i
+ 1, algo
, res
);
1299 /* Add remaining input data */
1300 req
.avail_in
+= (ctemplate
[i
].inlen
+ 1) / 2;
1302 res
= crypto_compress_update(tfm
, &req
);
1303 if (res
< 0 && (res
!= -EAGAIN
|| req
.avail_in
)) {
1304 pr_err("alg: pcomp: compression update failed on test "
1305 "%d for %s: error=%d\n", i
+ 1, algo
, res
);
1311 /* Provide remaining output space */
1312 req
.avail_out
+= COMP_BUF_SIZE
- ctemplate
[i
].outlen
/ 2;
1314 res
= crypto_compress_final(tfm
, &req
);
1316 pr_err("alg: pcomp: compression final failed on test "
1317 "%d for %s: error=%d\n", i
+ 1, algo
, res
);
1322 if (COMP_BUF_SIZE
- req
.avail_out
!= ctemplate
[i
].outlen
) {
1323 pr_err("alg: comp: Compression test %d failed for %s: "
1324 "output len = %d (expected %d)\n", i
+ 1, algo
,
1325 COMP_BUF_SIZE
- req
.avail_out
,
1326 ctemplate
[i
].outlen
);
1330 if (produced
!= ctemplate
[i
].outlen
) {
1331 pr_err("alg: comp: Compression test %d failed for %s: "
1332 "returned len = %u (expected %d)\n", i
+ 1,
1333 algo
, produced
, ctemplate
[i
].outlen
);
1337 if (memcmp(result
, ctemplate
[i
].output
, ctemplate
[i
].outlen
)) {
1338 pr_err("alg: pcomp: Compression test %d failed for "
1339 "%s\n", i
+ 1, algo
);
1340 hexdump(result
, ctemplate
[i
].outlen
);
1345 for (i
= 0; i
< dtcount
; i
++) {
1346 struct comp_request req
;
1347 unsigned int produced
= 0;
1349 res
= crypto_decompress_setup(tfm
, dtemplate
[i
].params
,
1350 dtemplate
[i
].paramsize
);
1352 pr_err("alg: pcomp: decompression setup failed on "
1353 "test %d for %s: error=%d\n", i
+ 1, algo
, res
);
1357 res
= crypto_decompress_init(tfm
);
1359 pr_err("alg: pcomp: decompression init failed on test "
1360 "%d for %s: error=%d\n", i
+ 1, algo
, res
);
1364 memset(result
, 0, sizeof(result
));
1366 req
.next_in
= dtemplate
[i
].input
;
1367 req
.avail_in
= dtemplate
[i
].inlen
/ 2;
1368 req
.next_out
= result
;
1369 req
.avail_out
= dtemplate
[i
].outlen
/ 2;
1371 res
= crypto_decompress_update(tfm
, &req
);
1372 if (res
< 0 && (res
!= -EAGAIN
|| req
.avail_in
)) {
1373 pr_err("alg: pcomp: decompression update failed on "
1374 "test %d for %s: error=%d\n", i
+ 1, algo
, res
);
1380 /* Add remaining input data */
1381 req
.avail_in
+= (dtemplate
[i
].inlen
+ 1) / 2;
1383 res
= crypto_decompress_update(tfm
, &req
);
1384 if (res
< 0 && (res
!= -EAGAIN
|| req
.avail_in
)) {
1385 pr_err("alg: pcomp: decompression update failed on "
1386 "test %d for %s: error=%d\n", i
+ 1, algo
, res
);
1392 /* Provide remaining output space */
1393 req
.avail_out
+= COMP_BUF_SIZE
- dtemplate
[i
].outlen
/ 2;
1395 res
= crypto_decompress_final(tfm
, &req
);
1396 if (res
< 0 && (res
!= -EAGAIN
|| req
.avail_in
)) {
1397 pr_err("alg: pcomp: decompression final failed on "
1398 "test %d for %s: error=%d\n", i
+ 1, algo
, res
);
1404 if (COMP_BUF_SIZE
- req
.avail_out
!= dtemplate
[i
].outlen
) {
1405 pr_err("alg: comp: Decompression test %d failed for "
1406 "%s: output len = %d (expected %d)\n", i
+ 1,
1407 algo
, COMP_BUF_SIZE
- req
.avail_out
,
1408 dtemplate
[i
].outlen
);
1412 if (produced
!= dtemplate
[i
].outlen
) {
1413 pr_err("alg: comp: Decompression test %d failed for "
1414 "%s: returned len = %u (expected %d)\n", i
+ 1,
1415 algo
, produced
, dtemplate
[i
].outlen
);
1419 if (memcmp(result
, dtemplate
[i
].output
, dtemplate
[i
].outlen
)) {
1420 pr_err("alg: pcomp: Decompression test %d failed for "
1421 "%s\n", i
+ 1, algo
);
1422 hexdump(result
, dtemplate
[i
].outlen
);
1431 static int test_cprng(struct crypto_rng
*tfm
, struct cprng_testvec
*template,
1432 unsigned int tcount
)
1434 const char *algo
= crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm
));
1435 int err
= 0, i
, j
, seedsize
;
1439 seedsize
= crypto_rng_seedsize(tfm
);
1441 seed
= kmalloc(seedsize
, GFP_KERNEL
);
1443 printk(KERN_ERR
"alg: cprng: Failed to allocate seed space "
1448 for (i
= 0; i
< tcount
; i
++) {
1449 memset(result
, 0, 32);
1451 memcpy(seed
, template[i
].v
, template[i
].vlen
);
1452 memcpy(seed
+ template[i
].vlen
, template[i
].key
,
1454 memcpy(seed
+ template[i
].vlen
+ template[i
].klen
,
1455 template[i
].dt
, template[i
].dtlen
);
1457 err
= crypto_rng_reset(tfm
, seed
, seedsize
);
1459 printk(KERN_ERR
"alg: cprng: Failed to reset rng "
1464 for (j
= 0; j
< template[i
].loops
; j
++) {
1465 err
= crypto_rng_get_bytes(tfm
, result
,
1467 if (err
!= template[i
].rlen
) {
1468 printk(KERN_ERR
"alg: cprng: Failed to obtain "
1469 "the correct amount of random data for "
1470 "%s (requested %d, got %d)\n", algo
,
1471 template[i
].rlen
, err
);
1476 err
= memcmp(result
, template[i
].result
,
1479 printk(KERN_ERR
"alg: cprng: Test %d failed for %s\n",
1481 hexdump(result
, template[i
].rlen
);
1492 static int alg_test_aead(const struct alg_test_desc
*desc
, const char *driver
,
1495 struct crypto_aead
*tfm
;
1498 tfm
= crypto_alloc_aead(driver
, type
, mask
);
1500 printk(KERN_ERR
"alg: aead: Failed to load transform for %s: "
1501 "%ld\n", driver
, PTR_ERR(tfm
));
1502 return PTR_ERR(tfm
);
1505 if (desc
->suite
.aead
.enc
.vecs
) {
1506 err
= test_aead(tfm
, ENCRYPT
, desc
->suite
.aead
.enc
.vecs
,
1507 desc
->suite
.aead
.enc
.count
);
1512 if (!err
&& desc
->suite
.aead
.dec
.vecs
)
1513 err
= test_aead(tfm
, DECRYPT
, desc
->suite
.aead
.dec
.vecs
,
1514 desc
->suite
.aead
.dec
.count
);
1517 crypto_free_aead(tfm
);
1521 static int alg_test_cipher(const struct alg_test_desc
*desc
,
1522 const char *driver
, u32 type
, u32 mask
)
1524 struct crypto_cipher
*tfm
;
1527 tfm
= crypto_alloc_cipher(driver
, type
, mask
);
1529 printk(KERN_ERR
"alg: cipher: Failed to load transform for "
1530 "%s: %ld\n", driver
, PTR_ERR(tfm
));
1531 return PTR_ERR(tfm
);
1534 if (desc
->suite
.cipher
.enc
.vecs
) {
1535 err
= test_cipher(tfm
, ENCRYPT
, desc
->suite
.cipher
.enc
.vecs
,
1536 desc
->suite
.cipher
.enc
.count
);
1541 if (desc
->suite
.cipher
.dec
.vecs
)
1542 err
= test_cipher(tfm
, DECRYPT
, desc
->suite
.cipher
.dec
.vecs
,
1543 desc
->suite
.cipher
.dec
.count
);
1546 crypto_free_cipher(tfm
);
1550 static int alg_test_skcipher(const struct alg_test_desc
*desc
,
1551 const char *driver
, u32 type
, u32 mask
)
1553 struct crypto_ablkcipher
*tfm
;
1556 tfm
= crypto_alloc_ablkcipher(driver
, type
, mask
);
1558 printk(KERN_ERR
"alg: skcipher: Failed to load transform for "
1559 "%s: %ld\n", driver
, PTR_ERR(tfm
));
1560 return PTR_ERR(tfm
);
1563 if (desc
->suite
.cipher
.enc
.vecs
) {
1564 err
= test_skcipher(tfm
, ENCRYPT
, desc
->suite
.cipher
.enc
.vecs
,
1565 desc
->suite
.cipher
.enc
.count
);
1570 if (desc
->suite
.cipher
.dec
.vecs
)
1571 err
= test_skcipher(tfm
, DECRYPT
, desc
->suite
.cipher
.dec
.vecs
,
1572 desc
->suite
.cipher
.dec
.count
);
1575 crypto_free_ablkcipher(tfm
);
1579 static int alg_test_comp(const struct alg_test_desc
*desc
, const char *driver
,
1582 struct crypto_comp
*tfm
;
1585 tfm
= crypto_alloc_comp(driver
, type
, mask
);
1587 printk(KERN_ERR
"alg: comp: Failed to load transform for %s: "
1588 "%ld\n", driver
, PTR_ERR(tfm
));
1589 return PTR_ERR(tfm
);
1592 err
= test_comp(tfm
, desc
->suite
.comp
.comp
.vecs
,
1593 desc
->suite
.comp
.decomp
.vecs
,
1594 desc
->suite
.comp
.comp
.count
,
1595 desc
->suite
.comp
.decomp
.count
);
1597 crypto_free_comp(tfm
);
1601 static int alg_test_pcomp(const struct alg_test_desc
*desc
, const char *driver
,
1604 struct crypto_pcomp
*tfm
;
1607 tfm
= crypto_alloc_pcomp(driver
, type
, mask
);
1609 pr_err("alg: pcomp: Failed to load transform for %s: %ld\n",
1610 driver
, PTR_ERR(tfm
));
1611 return PTR_ERR(tfm
);
1614 err
= test_pcomp(tfm
, desc
->suite
.pcomp
.comp
.vecs
,
1615 desc
->suite
.pcomp
.decomp
.vecs
,
1616 desc
->suite
.pcomp
.comp
.count
,
1617 desc
->suite
.pcomp
.decomp
.count
);
1619 crypto_free_pcomp(tfm
);
1623 static int alg_test_hash(const struct alg_test_desc
*desc
, const char *driver
,
1626 struct crypto_ahash
*tfm
;
1629 tfm
= crypto_alloc_ahash(driver
, type
, mask
);
1631 printk(KERN_ERR
"alg: hash: Failed to load transform for %s: "
1632 "%ld\n", driver
, PTR_ERR(tfm
));
1633 return PTR_ERR(tfm
);
1636 err
= test_hash(tfm
, desc
->suite
.hash
.vecs
,
1637 desc
->suite
.hash
.count
, true);
1639 err
= test_hash(tfm
, desc
->suite
.hash
.vecs
,
1640 desc
->suite
.hash
.count
, false);
1642 crypto_free_ahash(tfm
);
1646 static int alg_test_crc32c(const struct alg_test_desc
*desc
,
1647 const char *driver
, u32 type
, u32 mask
)
1649 struct crypto_shash
*tfm
;
1653 err
= alg_test_hash(desc
, driver
, type
, mask
);
1657 tfm
= crypto_alloc_shash(driver
, type
, mask
);
1659 printk(KERN_ERR
"alg: crc32c: Failed to load transform for %s: "
1660 "%ld\n", driver
, PTR_ERR(tfm
));
1667 struct shash_desc shash
;
1668 char ctx
[crypto_shash_descsize(tfm
)];
1671 sdesc
.shash
.tfm
= tfm
;
1672 sdesc
.shash
.flags
= 0;
1674 *(u32
*)sdesc
.ctx
= le32_to_cpu(420553207);
1675 err
= crypto_shash_final(&sdesc
.shash
, (u8
*)&val
);
1677 printk(KERN_ERR
"alg: crc32c: Operation failed for "
1678 "%s: %d\n", driver
, err
);
1682 if (val
!= ~420553207) {
1683 printk(KERN_ERR
"alg: crc32c: Test failed for %s: "
1684 "%d\n", driver
, val
);
1689 crypto_free_shash(tfm
);
1695 static int alg_test_cprng(const struct alg_test_desc
*desc
, const char *driver
,
1698 struct crypto_rng
*rng
;
1701 rng
= crypto_alloc_rng(driver
, type
, mask
);
1703 printk(KERN_ERR
"alg: cprng: Failed to load transform for %s: "
1704 "%ld\n", driver
, PTR_ERR(rng
));
1705 return PTR_ERR(rng
);
1708 err
= test_cprng(rng
, desc
->suite
.cprng
.vecs
, desc
->suite
.cprng
.count
);
1710 crypto_free_rng(rng
);
1715 static int alg_test_null(const struct alg_test_desc
*desc
,
1716 const char *driver
, u32 type
, u32 mask
)
1721 /* Please keep this list sorted by algorithm name. */
1722 static const struct alg_test_desc alg_test_descs
[] = {
1724 .alg
= "__cbc-cast5-avx",
1725 .test
= alg_test_null
,
1727 .alg
= "__cbc-cast6-avx",
1728 .test
= alg_test_null
,
1730 .alg
= "__cbc-serpent-avx",
1731 .test
= alg_test_null
,
1733 .alg
= "__cbc-serpent-avx2",
1734 .test
= alg_test_null
,
1736 .alg
= "__cbc-serpent-sse2",
1737 .test
= alg_test_null
,
1739 .alg
= "__cbc-twofish-avx",
1740 .test
= alg_test_null
,
1742 .alg
= "__driver-cbc-aes-aesni",
1743 .test
= alg_test_null
,
1746 .alg
= "__driver-cbc-camellia-aesni",
1747 .test
= alg_test_null
,
1749 .alg
= "__driver-cbc-camellia-aesni-avx2",
1750 .test
= alg_test_null
,
1752 .alg
= "__driver-cbc-cast5-avx",
1753 .test
= alg_test_null
,
1755 .alg
= "__driver-cbc-cast6-avx",
1756 .test
= alg_test_null
,
1758 .alg
= "__driver-cbc-serpent-avx",
1759 .test
= alg_test_null
,
1761 .alg
= "__driver-cbc-serpent-avx2",
1762 .test
= alg_test_null
,
1764 .alg
= "__driver-cbc-serpent-sse2",
1765 .test
= alg_test_null
,
1767 .alg
= "__driver-cbc-twofish-avx",
1768 .test
= alg_test_null
,
1770 .alg
= "__driver-ecb-aes-aesni",
1771 .test
= alg_test_null
,
1774 .alg
= "__driver-ecb-camellia-aesni",
1775 .test
= alg_test_null
,
1777 .alg
= "__driver-ecb-camellia-aesni-avx2",
1778 .test
= alg_test_null
,
1780 .alg
= "__driver-ecb-cast5-avx",
1781 .test
= alg_test_null
,
1783 .alg
= "__driver-ecb-cast6-avx",
1784 .test
= alg_test_null
,
1786 .alg
= "__driver-ecb-serpent-avx",
1787 .test
= alg_test_null
,
1789 .alg
= "__driver-ecb-serpent-avx2",
1790 .test
= alg_test_null
,
1792 .alg
= "__driver-ecb-serpent-sse2",
1793 .test
= alg_test_null
,
1795 .alg
= "__driver-ecb-twofish-avx",
1796 .test
= alg_test_null
,
1798 .alg
= "__ghash-pclmulqdqni",
1799 .test
= alg_test_null
,
1802 .alg
= "ansi_cprng",
1803 .test
= alg_test_cprng
,
1807 .vecs
= ansi_cprng_aes_tv_template
,
1808 .count
= ANSI_CPRNG_AES_TEST_VECTORS
1812 .alg
= "authenc(hmac(md5),ecb(cipher_null))",
1813 .test
= alg_test_aead
,
1818 .vecs
= hmac_md5_ecb_cipher_null_enc_tv_template
,
1819 .count
= HMAC_MD5_ECB_CIPHER_NULL_ENC_TEST_VECTORS
1822 .vecs
= hmac_md5_ecb_cipher_null_dec_tv_template
,
1823 .count
= HMAC_MD5_ECB_CIPHER_NULL_DEC_TEST_VECTORS
1828 .alg
= "authenc(hmac(sha1),cbc(aes))",
1829 .test
= alg_test_aead
,
1834 .vecs
= hmac_sha1_aes_cbc_enc_tv_template
,
1835 .count
= HMAC_SHA1_AES_CBC_ENC_TEST_VECTORS
1840 .alg
= "authenc(hmac(sha1),ecb(cipher_null))",
1841 .test
= alg_test_aead
,
1846 .vecs
= hmac_sha1_ecb_cipher_null_enc_tv_template
,
1847 .count
= HMAC_SHA1_ECB_CIPHER_NULL_ENC_TEST_VECTORS
1850 .vecs
= hmac_sha1_ecb_cipher_null_dec_tv_template
,
1851 .count
= HMAC_SHA1_ECB_CIPHER_NULL_DEC_TEST_VECTORS
1856 .alg
= "authenc(hmac(sha256),cbc(aes))",
1857 .test
= alg_test_aead
,
1862 .vecs
= hmac_sha256_aes_cbc_enc_tv_template
,
1863 .count
= HMAC_SHA256_AES_CBC_ENC_TEST_VECTORS
1868 .alg
= "authenc(hmac(sha512),cbc(aes))",
1869 .test
= alg_test_aead
,
1874 .vecs
= hmac_sha512_aes_cbc_enc_tv_template
,
1875 .count
= HMAC_SHA512_AES_CBC_ENC_TEST_VECTORS
1881 .test
= alg_test_skcipher
,
1886 .vecs
= aes_cbc_enc_tv_template
,
1887 .count
= AES_CBC_ENC_TEST_VECTORS
1890 .vecs
= aes_cbc_dec_tv_template
,
1891 .count
= AES_CBC_DEC_TEST_VECTORS
1896 .alg
= "cbc(anubis)",
1897 .test
= alg_test_skcipher
,
1901 .vecs
= anubis_cbc_enc_tv_template
,
1902 .count
= ANUBIS_CBC_ENC_TEST_VECTORS
1905 .vecs
= anubis_cbc_dec_tv_template
,
1906 .count
= ANUBIS_CBC_DEC_TEST_VECTORS
1911 .alg
= "cbc(blowfish)",
1912 .test
= alg_test_skcipher
,
1916 .vecs
= bf_cbc_enc_tv_template
,
1917 .count
= BF_CBC_ENC_TEST_VECTORS
1920 .vecs
= bf_cbc_dec_tv_template
,
1921 .count
= BF_CBC_DEC_TEST_VECTORS
1926 .alg
= "cbc(camellia)",
1927 .test
= alg_test_skcipher
,
1931 .vecs
= camellia_cbc_enc_tv_template
,
1932 .count
= CAMELLIA_CBC_ENC_TEST_VECTORS
1935 .vecs
= camellia_cbc_dec_tv_template
,
1936 .count
= CAMELLIA_CBC_DEC_TEST_VECTORS
1941 .alg
= "cbc(cast5)",
1942 .test
= alg_test_skcipher
,
1946 .vecs
= cast5_cbc_enc_tv_template
,
1947 .count
= CAST5_CBC_ENC_TEST_VECTORS
1950 .vecs
= cast5_cbc_dec_tv_template
,
1951 .count
= CAST5_CBC_DEC_TEST_VECTORS
1956 .alg
= "cbc(cast6)",
1957 .test
= alg_test_skcipher
,
1961 .vecs
= cast6_cbc_enc_tv_template
,
1962 .count
= CAST6_CBC_ENC_TEST_VECTORS
1965 .vecs
= cast6_cbc_dec_tv_template
,
1966 .count
= CAST6_CBC_DEC_TEST_VECTORS
1972 .test
= alg_test_skcipher
,
1976 .vecs
= des_cbc_enc_tv_template
,
1977 .count
= DES_CBC_ENC_TEST_VECTORS
1980 .vecs
= des_cbc_dec_tv_template
,
1981 .count
= DES_CBC_DEC_TEST_VECTORS
1986 .alg
= "cbc(des3_ede)",
1987 .test
= alg_test_skcipher
,
1992 .vecs
= des3_ede_cbc_enc_tv_template
,
1993 .count
= DES3_EDE_CBC_ENC_TEST_VECTORS
1996 .vecs
= des3_ede_cbc_dec_tv_template
,
1997 .count
= DES3_EDE_CBC_DEC_TEST_VECTORS
2002 .alg
= "cbc(serpent)",
2003 .test
= alg_test_skcipher
,
2007 .vecs
= serpent_cbc_enc_tv_template
,
2008 .count
= SERPENT_CBC_ENC_TEST_VECTORS
2011 .vecs
= serpent_cbc_dec_tv_template
,
2012 .count
= SERPENT_CBC_DEC_TEST_VECTORS
2017 .alg
= "cbc(twofish)",
2018 .test
= alg_test_skcipher
,
2022 .vecs
= tf_cbc_enc_tv_template
,
2023 .count
= TF_CBC_ENC_TEST_VECTORS
2026 .vecs
= tf_cbc_dec_tv_template
,
2027 .count
= TF_CBC_DEC_TEST_VECTORS
2033 .test
= alg_test_aead
,
2038 .vecs
= aes_ccm_enc_tv_template
,
2039 .count
= AES_CCM_ENC_TEST_VECTORS
2042 .vecs
= aes_ccm_dec_tv_template
,
2043 .count
= AES_CCM_DEC_TEST_VECTORS
2049 .test
= alg_test_hash
,
2052 .vecs
= aes_cmac128_tv_template
,
2053 .count
= CMAC_AES_TEST_VECTORS
2057 .alg
= "cmac(des3_ede)",
2058 .test
= alg_test_hash
,
2061 .vecs
= des3_ede_cmac64_tv_template
,
2062 .count
= CMAC_DES3_EDE_TEST_VECTORS
2066 .alg
= "compress_null",
2067 .test
= alg_test_null
,
2070 .test
= alg_test_crc32c
,
2074 .vecs
= crc32c_tv_template
,
2075 .count
= CRC32C_TEST_VECTORS
2080 .test
= alg_test_hash
,
2084 .vecs
= crct10dif_tv_template
,
2085 .count
= CRCT10DIF_TEST_VECTORS
2089 .alg
= "cryptd(__driver-cbc-aes-aesni)",
2090 .test
= alg_test_null
,
2093 .alg
= "cryptd(__driver-cbc-camellia-aesni)",
2094 .test
= alg_test_null
,
2096 .alg
= "cryptd(__driver-cbc-camellia-aesni-avx2)",
2097 .test
= alg_test_null
,
2099 .alg
= "cryptd(__driver-cbc-serpent-avx2)",
2100 .test
= alg_test_null
,
2102 .alg
= "cryptd(__driver-ecb-aes-aesni)",
2103 .test
= alg_test_null
,
2106 .alg
= "cryptd(__driver-ecb-camellia-aesni)",
2107 .test
= alg_test_null
,
2109 .alg
= "cryptd(__driver-ecb-camellia-aesni-avx2)",
2110 .test
= alg_test_null
,
2112 .alg
= "cryptd(__driver-ecb-cast5-avx)",
2113 .test
= alg_test_null
,
2115 .alg
= "cryptd(__driver-ecb-cast6-avx)",
2116 .test
= alg_test_null
,
2118 .alg
= "cryptd(__driver-ecb-serpent-avx)",
2119 .test
= alg_test_null
,
2121 .alg
= "cryptd(__driver-ecb-serpent-avx2)",
2122 .test
= alg_test_null
,
2124 .alg
= "cryptd(__driver-ecb-serpent-sse2)",
2125 .test
= alg_test_null
,
2127 .alg
= "cryptd(__driver-ecb-twofish-avx)",
2128 .test
= alg_test_null
,
2130 .alg
= "cryptd(__driver-gcm-aes-aesni)",
2131 .test
= alg_test_null
,
2134 .alg
= "cryptd(__ghash-pclmulqdqni)",
2135 .test
= alg_test_null
,
2139 .test
= alg_test_skcipher
,
2144 .vecs
= aes_ctr_enc_tv_template
,
2145 .count
= AES_CTR_ENC_TEST_VECTORS
2148 .vecs
= aes_ctr_dec_tv_template
,
2149 .count
= AES_CTR_DEC_TEST_VECTORS
2154 .alg
= "ctr(blowfish)",
2155 .test
= alg_test_skcipher
,
2159 .vecs
= bf_ctr_enc_tv_template
,
2160 .count
= BF_CTR_ENC_TEST_VECTORS
2163 .vecs
= bf_ctr_dec_tv_template
,
2164 .count
= BF_CTR_DEC_TEST_VECTORS
2169 .alg
= "ctr(camellia)",
2170 .test
= alg_test_skcipher
,
2174 .vecs
= camellia_ctr_enc_tv_template
,
2175 .count
= CAMELLIA_CTR_ENC_TEST_VECTORS
2178 .vecs
= camellia_ctr_dec_tv_template
,
2179 .count
= CAMELLIA_CTR_DEC_TEST_VECTORS
2184 .alg
= "ctr(cast5)",
2185 .test
= alg_test_skcipher
,
2189 .vecs
= cast5_ctr_enc_tv_template
,
2190 .count
= CAST5_CTR_ENC_TEST_VECTORS
2193 .vecs
= cast5_ctr_dec_tv_template
,
2194 .count
= CAST5_CTR_DEC_TEST_VECTORS
2199 .alg
= "ctr(cast6)",
2200 .test
= alg_test_skcipher
,
2204 .vecs
= cast6_ctr_enc_tv_template
,
2205 .count
= CAST6_CTR_ENC_TEST_VECTORS
2208 .vecs
= cast6_ctr_dec_tv_template
,
2209 .count
= CAST6_CTR_DEC_TEST_VECTORS
2215 .test
= alg_test_skcipher
,
2219 .vecs
= des_ctr_enc_tv_template
,
2220 .count
= DES_CTR_ENC_TEST_VECTORS
2223 .vecs
= des_ctr_dec_tv_template
,
2224 .count
= DES_CTR_DEC_TEST_VECTORS
2229 .alg
= "ctr(des3_ede)",
2230 .test
= alg_test_skcipher
,
2234 .vecs
= des3_ede_ctr_enc_tv_template
,
2235 .count
= DES3_EDE_CTR_ENC_TEST_VECTORS
2238 .vecs
= des3_ede_ctr_dec_tv_template
,
2239 .count
= DES3_EDE_CTR_DEC_TEST_VECTORS
2244 .alg
= "ctr(serpent)",
2245 .test
= alg_test_skcipher
,
2249 .vecs
= serpent_ctr_enc_tv_template
,
2250 .count
= SERPENT_CTR_ENC_TEST_VECTORS
2253 .vecs
= serpent_ctr_dec_tv_template
,
2254 .count
= SERPENT_CTR_DEC_TEST_VECTORS
2259 .alg
= "ctr(twofish)",
2260 .test
= alg_test_skcipher
,
2264 .vecs
= tf_ctr_enc_tv_template
,
2265 .count
= TF_CTR_ENC_TEST_VECTORS
2268 .vecs
= tf_ctr_dec_tv_template
,
2269 .count
= TF_CTR_DEC_TEST_VECTORS
2274 .alg
= "cts(cbc(aes))",
2275 .test
= alg_test_skcipher
,
2279 .vecs
= cts_mode_enc_tv_template
,
2280 .count
= CTS_MODE_ENC_TEST_VECTORS
2283 .vecs
= cts_mode_dec_tv_template
,
2284 .count
= CTS_MODE_DEC_TEST_VECTORS
2290 .test
= alg_test_comp
,
2295 .vecs
= deflate_comp_tv_template
,
2296 .count
= DEFLATE_COMP_TEST_VECTORS
2299 .vecs
= deflate_decomp_tv_template
,
2300 .count
= DEFLATE_DECOMP_TEST_VECTORS
2305 .alg
= "digest_null",
2306 .test
= alg_test_null
,
2308 .alg
= "ecb(__aes-aesni)",
2309 .test
= alg_test_null
,
2313 .test
= alg_test_skcipher
,
2318 .vecs
= aes_enc_tv_template
,
2319 .count
= AES_ENC_TEST_VECTORS
2322 .vecs
= aes_dec_tv_template
,
2323 .count
= AES_DEC_TEST_VECTORS
2328 .alg
= "ecb(anubis)",
2329 .test
= alg_test_skcipher
,
2333 .vecs
= anubis_enc_tv_template
,
2334 .count
= ANUBIS_ENC_TEST_VECTORS
2337 .vecs
= anubis_dec_tv_template
,
2338 .count
= ANUBIS_DEC_TEST_VECTORS
2344 .test
= alg_test_skcipher
,
2348 .vecs
= arc4_enc_tv_template
,
2349 .count
= ARC4_ENC_TEST_VECTORS
2352 .vecs
= arc4_dec_tv_template
,
2353 .count
= ARC4_DEC_TEST_VECTORS
2358 .alg
= "ecb(blowfish)",
2359 .test
= alg_test_skcipher
,
2363 .vecs
= bf_enc_tv_template
,
2364 .count
= BF_ENC_TEST_VECTORS
2367 .vecs
= bf_dec_tv_template
,
2368 .count
= BF_DEC_TEST_VECTORS
2373 .alg
= "ecb(camellia)",
2374 .test
= alg_test_skcipher
,
2378 .vecs
= camellia_enc_tv_template
,
2379 .count
= CAMELLIA_ENC_TEST_VECTORS
2382 .vecs
= camellia_dec_tv_template
,
2383 .count
= CAMELLIA_DEC_TEST_VECTORS
2388 .alg
= "ecb(cast5)",
2389 .test
= alg_test_skcipher
,
2393 .vecs
= cast5_enc_tv_template
,
2394 .count
= CAST5_ENC_TEST_VECTORS
2397 .vecs
= cast5_dec_tv_template
,
2398 .count
= CAST5_DEC_TEST_VECTORS
2403 .alg
= "ecb(cast6)",
2404 .test
= alg_test_skcipher
,
2408 .vecs
= cast6_enc_tv_template
,
2409 .count
= CAST6_ENC_TEST_VECTORS
2412 .vecs
= cast6_dec_tv_template
,
2413 .count
= CAST6_DEC_TEST_VECTORS
2418 .alg
= "ecb(cipher_null)",
2419 .test
= alg_test_null
,
2422 .test
= alg_test_skcipher
,
2427 .vecs
= des_enc_tv_template
,
2428 .count
= DES_ENC_TEST_VECTORS
2431 .vecs
= des_dec_tv_template
,
2432 .count
= DES_DEC_TEST_VECTORS
2437 .alg
= "ecb(des3_ede)",
2438 .test
= alg_test_skcipher
,
2443 .vecs
= des3_ede_enc_tv_template
,
2444 .count
= DES3_EDE_ENC_TEST_VECTORS
2447 .vecs
= des3_ede_dec_tv_template
,
2448 .count
= DES3_EDE_DEC_TEST_VECTORS
2453 .alg
= "ecb(fcrypt)",
2454 .test
= alg_test_skcipher
,
2458 .vecs
= fcrypt_pcbc_enc_tv_template
,
2462 .vecs
= fcrypt_pcbc_dec_tv_template
,
2468 .alg
= "ecb(khazad)",
2469 .test
= alg_test_skcipher
,
2473 .vecs
= khazad_enc_tv_template
,
2474 .count
= KHAZAD_ENC_TEST_VECTORS
2477 .vecs
= khazad_dec_tv_template
,
2478 .count
= KHAZAD_DEC_TEST_VECTORS
2484 .test
= alg_test_skcipher
,
2488 .vecs
= seed_enc_tv_template
,
2489 .count
= SEED_ENC_TEST_VECTORS
2492 .vecs
= seed_dec_tv_template
,
2493 .count
= SEED_DEC_TEST_VECTORS
2498 .alg
= "ecb(serpent)",
2499 .test
= alg_test_skcipher
,
2503 .vecs
= serpent_enc_tv_template
,
2504 .count
= SERPENT_ENC_TEST_VECTORS
2507 .vecs
= serpent_dec_tv_template
,
2508 .count
= SERPENT_DEC_TEST_VECTORS
2514 .test
= alg_test_skcipher
,
2518 .vecs
= tea_enc_tv_template
,
2519 .count
= TEA_ENC_TEST_VECTORS
2522 .vecs
= tea_dec_tv_template
,
2523 .count
= TEA_DEC_TEST_VECTORS
2528 .alg
= "ecb(tnepres)",
2529 .test
= alg_test_skcipher
,
2533 .vecs
= tnepres_enc_tv_template
,
2534 .count
= TNEPRES_ENC_TEST_VECTORS
2537 .vecs
= tnepres_dec_tv_template
,
2538 .count
= TNEPRES_DEC_TEST_VECTORS
2543 .alg
= "ecb(twofish)",
2544 .test
= alg_test_skcipher
,
2548 .vecs
= tf_enc_tv_template
,
2549 .count
= TF_ENC_TEST_VECTORS
2552 .vecs
= tf_dec_tv_template
,
2553 .count
= TF_DEC_TEST_VECTORS
2559 .test
= alg_test_skcipher
,
2563 .vecs
= xeta_enc_tv_template
,
2564 .count
= XETA_ENC_TEST_VECTORS
2567 .vecs
= xeta_dec_tv_template
,
2568 .count
= XETA_DEC_TEST_VECTORS
2574 .test
= alg_test_skcipher
,
2578 .vecs
= xtea_enc_tv_template
,
2579 .count
= XTEA_ENC_TEST_VECTORS
2582 .vecs
= xtea_dec_tv_template
,
2583 .count
= XTEA_DEC_TEST_VECTORS
2589 .test
= alg_test_aead
,
2594 .vecs
= aes_gcm_enc_tv_template
,
2595 .count
= AES_GCM_ENC_TEST_VECTORS
2598 .vecs
= aes_gcm_dec_tv_template
,
2599 .count
= AES_GCM_DEC_TEST_VECTORS
2605 .test
= alg_test_hash
,
2609 .vecs
= ghash_tv_template
,
2610 .count
= GHASH_TEST_VECTORS
2614 .alg
= "hmac(crc32)",
2615 .test
= alg_test_hash
,
2618 .vecs
= bfin_crc_tv_template
,
2619 .count
= BFIN_CRC_TEST_VECTORS
2624 .test
= alg_test_hash
,
2627 .vecs
= hmac_md5_tv_template
,
2628 .count
= HMAC_MD5_TEST_VECTORS
2632 .alg
= "hmac(rmd128)",
2633 .test
= alg_test_hash
,
2636 .vecs
= hmac_rmd128_tv_template
,
2637 .count
= HMAC_RMD128_TEST_VECTORS
2641 .alg
= "hmac(rmd160)",
2642 .test
= alg_test_hash
,
2645 .vecs
= hmac_rmd160_tv_template
,
2646 .count
= HMAC_RMD160_TEST_VECTORS
2650 .alg
= "hmac(sha1)",
2651 .test
= alg_test_hash
,
2655 .vecs
= hmac_sha1_tv_template
,
2656 .count
= HMAC_SHA1_TEST_VECTORS
2660 .alg
= "hmac(sha224)",
2661 .test
= alg_test_hash
,
2665 .vecs
= hmac_sha224_tv_template
,
2666 .count
= HMAC_SHA224_TEST_VECTORS
2670 .alg
= "hmac(sha256)",
2671 .test
= alg_test_hash
,
2675 .vecs
= hmac_sha256_tv_template
,
2676 .count
= HMAC_SHA256_TEST_VECTORS
2680 .alg
= "hmac(sha384)",
2681 .test
= alg_test_hash
,
2685 .vecs
= hmac_sha384_tv_template
,
2686 .count
= HMAC_SHA384_TEST_VECTORS
2690 .alg
= "hmac(sha512)",
2691 .test
= alg_test_hash
,
2695 .vecs
= hmac_sha512_tv_template
,
2696 .count
= HMAC_SHA512_TEST_VECTORS
2701 .test
= alg_test_skcipher
,
2705 .vecs
= aes_lrw_enc_tv_template
,
2706 .count
= AES_LRW_ENC_TEST_VECTORS
2709 .vecs
= aes_lrw_dec_tv_template
,
2710 .count
= AES_LRW_DEC_TEST_VECTORS
2715 .alg
= "lrw(camellia)",
2716 .test
= alg_test_skcipher
,
2720 .vecs
= camellia_lrw_enc_tv_template
,
2721 .count
= CAMELLIA_LRW_ENC_TEST_VECTORS
2724 .vecs
= camellia_lrw_dec_tv_template
,
2725 .count
= CAMELLIA_LRW_DEC_TEST_VECTORS
2730 .alg
= "lrw(cast6)",
2731 .test
= alg_test_skcipher
,
2735 .vecs
= cast6_lrw_enc_tv_template
,
2736 .count
= CAST6_LRW_ENC_TEST_VECTORS
2739 .vecs
= cast6_lrw_dec_tv_template
,
2740 .count
= CAST6_LRW_DEC_TEST_VECTORS
2745 .alg
= "lrw(serpent)",
2746 .test
= alg_test_skcipher
,
2750 .vecs
= serpent_lrw_enc_tv_template
,
2751 .count
= SERPENT_LRW_ENC_TEST_VECTORS
2754 .vecs
= serpent_lrw_dec_tv_template
,
2755 .count
= SERPENT_LRW_DEC_TEST_VECTORS
2760 .alg
= "lrw(twofish)",
2761 .test
= alg_test_skcipher
,
2765 .vecs
= tf_lrw_enc_tv_template
,
2766 .count
= TF_LRW_ENC_TEST_VECTORS
2769 .vecs
= tf_lrw_dec_tv_template
,
2770 .count
= TF_LRW_DEC_TEST_VECTORS
2776 .test
= alg_test_comp
,
2781 .vecs
= lzo_comp_tv_template
,
2782 .count
= LZO_COMP_TEST_VECTORS
2785 .vecs
= lzo_decomp_tv_template
,
2786 .count
= LZO_DECOMP_TEST_VECTORS
2792 .test
= alg_test_hash
,
2795 .vecs
= md4_tv_template
,
2796 .count
= MD4_TEST_VECTORS
2801 .test
= alg_test_hash
,
2804 .vecs
= md5_tv_template
,
2805 .count
= MD5_TEST_VECTORS
2809 .alg
= "michael_mic",
2810 .test
= alg_test_hash
,
2813 .vecs
= michael_mic_tv_template
,
2814 .count
= MICHAEL_MIC_TEST_VECTORS
2819 .test
= alg_test_skcipher
,
2824 .vecs
= aes_ofb_enc_tv_template
,
2825 .count
= AES_OFB_ENC_TEST_VECTORS
2828 .vecs
= aes_ofb_dec_tv_template
,
2829 .count
= AES_OFB_DEC_TEST_VECTORS
2834 .alg
= "pcbc(fcrypt)",
2835 .test
= alg_test_skcipher
,
2839 .vecs
= fcrypt_pcbc_enc_tv_template
,
2840 .count
= FCRYPT_ENC_TEST_VECTORS
2843 .vecs
= fcrypt_pcbc_dec_tv_template
,
2844 .count
= FCRYPT_DEC_TEST_VECTORS
2849 .alg
= "rfc3686(ctr(aes))",
2850 .test
= alg_test_skcipher
,
2855 .vecs
= aes_ctr_rfc3686_enc_tv_template
,
2856 .count
= AES_CTR_3686_ENC_TEST_VECTORS
2859 .vecs
= aes_ctr_rfc3686_dec_tv_template
,
2860 .count
= AES_CTR_3686_DEC_TEST_VECTORS
2865 .alg
= "rfc4106(gcm(aes))",
2866 .test
= alg_test_aead
,
2870 .vecs
= aes_gcm_rfc4106_enc_tv_template
,
2871 .count
= AES_GCM_4106_ENC_TEST_VECTORS
2874 .vecs
= aes_gcm_rfc4106_dec_tv_template
,
2875 .count
= AES_GCM_4106_DEC_TEST_VECTORS
2880 .alg
= "rfc4309(ccm(aes))",
2881 .test
= alg_test_aead
,
2886 .vecs
= aes_ccm_rfc4309_enc_tv_template
,
2887 .count
= AES_CCM_4309_ENC_TEST_VECTORS
2890 .vecs
= aes_ccm_rfc4309_dec_tv_template
,
2891 .count
= AES_CCM_4309_DEC_TEST_VECTORS
2896 .alg
= "rfc4543(gcm(aes))",
2897 .test
= alg_test_aead
,
2901 .vecs
= aes_gcm_rfc4543_enc_tv_template
,
2902 .count
= AES_GCM_4543_ENC_TEST_VECTORS
2905 .vecs
= aes_gcm_rfc4543_dec_tv_template
,
2906 .count
= AES_GCM_4543_DEC_TEST_VECTORS
2912 .test
= alg_test_hash
,
2915 .vecs
= rmd128_tv_template
,
2916 .count
= RMD128_TEST_VECTORS
2921 .test
= alg_test_hash
,
2924 .vecs
= rmd160_tv_template
,
2925 .count
= RMD160_TEST_VECTORS
2930 .test
= alg_test_hash
,
2933 .vecs
= rmd256_tv_template
,
2934 .count
= RMD256_TEST_VECTORS
2939 .test
= alg_test_hash
,
2942 .vecs
= rmd320_tv_template
,
2943 .count
= RMD320_TEST_VECTORS
2948 .test
= alg_test_skcipher
,
2952 .vecs
= salsa20_stream_enc_tv_template
,
2953 .count
= SALSA20_STREAM_ENC_TEST_VECTORS
2959 .test
= alg_test_hash
,
2963 .vecs
= sha1_tv_template
,
2964 .count
= SHA1_TEST_VECTORS
2969 .test
= alg_test_hash
,
2973 .vecs
= sha224_tv_template
,
2974 .count
= SHA224_TEST_VECTORS
2979 .test
= alg_test_hash
,
2983 .vecs
= sha256_tv_template
,
2984 .count
= SHA256_TEST_VECTORS
2989 .test
= alg_test_hash
,
2993 .vecs
= sha384_tv_template
,
2994 .count
= SHA384_TEST_VECTORS
2999 .test
= alg_test_hash
,
3003 .vecs
= sha512_tv_template
,
3004 .count
= SHA512_TEST_VECTORS
3009 .test
= alg_test_hash
,
3012 .vecs
= tgr128_tv_template
,
3013 .count
= TGR128_TEST_VECTORS
3018 .test
= alg_test_hash
,
3021 .vecs
= tgr160_tv_template
,
3022 .count
= TGR160_TEST_VECTORS
3027 .test
= alg_test_hash
,
3030 .vecs
= tgr192_tv_template
,
3031 .count
= TGR192_TEST_VECTORS
3036 .test
= alg_test_hash
,
3039 .vecs
= aes_vmac128_tv_template
,
3040 .count
= VMAC_AES_TEST_VECTORS
3045 .test
= alg_test_hash
,
3048 .vecs
= wp256_tv_template
,
3049 .count
= WP256_TEST_VECTORS
3054 .test
= alg_test_hash
,
3057 .vecs
= wp384_tv_template
,
3058 .count
= WP384_TEST_VECTORS
3063 .test
= alg_test_hash
,
3066 .vecs
= wp512_tv_template
,
3067 .count
= WP512_TEST_VECTORS
3072 .test
= alg_test_hash
,
3075 .vecs
= aes_xcbc128_tv_template
,
3076 .count
= XCBC_AES_TEST_VECTORS
3081 .test
= alg_test_skcipher
,
3086 .vecs
= aes_xts_enc_tv_template
,
3087 .count
= AES_XTS_ENC_TEST_VECTORS
3090 .vecs
= aes_xts_dec_tv_template
,
3091 .count
= AES_XTS_DEC_TEST_VECTORS
3096 .alg
= "xts(camellia)",
3097 .test
= alg_test_skcipher
,
3101 .vecs
= camellia_xts_enc_tv_template
,
3102 .count
= CAMELLIA_XTS_ENC_TEST_VECTORS
3105 .vecs
= camellia_xts_dec_tv_template
,
3106 .count
= CAMELLIA_XTS_DEC_TEST_VECTORS
3111 .alg
= "xts(cast6)",
3112 .test
= alg_test_skcipher
,
3116 .vecs
= cast6_xts_enc_tv_template
,
3117 .count
= CAST6_XTS_ENC_TEST_VECTORS
3120 .vecs
= cast6_xts_dec_tv_template
,
3121 .count
= CAST6_XTS_DEC_TEST_VECTORS
3126 .alg
= "xts(serpent)",
3127 .test
= alg_test_skcipher
,
3131 .vecs
= serpent_xts_enc_tv_template
,
3132 .count
= SERPENT_XTS_ENC_TEST_VECTORS
3135 .vecs
= serpent_xts_dec_tv_template
,
3136 .count
= SERPENT_XTS_DEC_TEST_VECTORS
3141 .alg
= "xts(twofish)",
3142 .test
= alg_test_skcipher
,
3146 .vecs
= tf_xts_enc_tv_template
,
3147 .count
= TF_XTS_ENC_TEST_VECTORS
3150 .vecs
= tf_xts_dec_tv_template
,
3151 .count
= TF_XTS_DEC_TEST_VECTORS
3157 .test
= alg_test_pcomp
,
3162 .vecs
= zlib_comp_tv_template
,
3163 .count
= ZLIB_COMP_TEST_VECTORS
3166 .vecs
= zlib_decomp_tv_template
,
3167 .count
= ZLIB_DECOMP_TEST_VECTORS
3174 static bool alg_test_descs_checked
;
3176 static void alg_test_descs_check_order(void)
3180 /* only check once */
3181 if (alg_test_descs_checked
)
3184 alg_test_descs_checked
= true;
3186 for (i
= 1; i
< ARRAY_SIZE(alg_test_descs
); i
++) {
3187 int diff
= strcmp(alg_test_descs
[i
- 1].alg
,
3188 alg_test_descs
[i
].alg
);
3190 if (WARN_ON(diff
> 0)) {
3191 pr_warn("testmgr: alg_test_descs entries in wrong order: '%s' before '%s'\n",
3192 alg_test_descs
[i
- 1].alg
,
3193 alg_test_descs
[i
].alg
);
3196 if (WARN_ON(diff
== 0)) {
3197 pr_warn("testmgr: duplicate alg_test_descs entry: '%s'\n",
3198 alg_test_descs
[i
].alg
);
3203 static int alg_find_test(const char *alg
)
3206 int end
= ARRAY_SIZE(alg_test_descs
);
3208 while (start
< end
) {
3209 int i
= (start
+ end
) / 2;
3210 int diff
= strcmp(alg_test_descs
[i
].alg
, alg
);
3228 int alg_test(const char *driver
, const char *alg
, u32 type
, u32 mask
)
3234 alg_test_descs_check_order();
3236 if ((type
& CRYPTO_ALG_TYPE_MASK
) == CRYPTO_ALG_TYPE_CIPHER
) {
3237 char nalg
[CRYPTO_MAX_ALG_NAME
];
3239 if (snprintf(nalg
, sizeof(nalg
), "ecb(%s)", alg
) >=
3241 return -ENAMETOOLONG
;
3243 i
= alg_find_test(nalg
);
3247 if (fips_enabled
&& !alg_test_descs
[i
].fips_allowed
)
3250 rc
= alg_test_cipher(alg_test_descs
+ i
, driver
, type
, mask
);
3254 i
= alg_find_test(alg
);
3255 j
= alg_find_test(driver
);
3259 if (fips_enabled
&& ((i
>= 0 && !alg_test_descs
[i
].fips_allowed
) ||
3260 (j
>= 0 && !alg_test_descs
[j
].fips_allowed
)))
3265 rc
|= alg_test_descs
[i
].test(alg_test_descs
+ i
, driver
,
3267 if (j
>= 0 && j
!= i
)
3268 rc
|= alg_test_descs
[j
].test(alg_test_descs
+ j
, driver
,
3272 if (fips_enabled
&& rc
)
3273 panic("%s: %s alg self test failed in fips mode!\n", driver
, alg
);
3275 if (fips_enabled
&& !rc
)
3276 printk(KERN_INFO
"alg: self-tests for %s (%s) passed\n",
3282 printk(KERN_INFO
"alg: No test for %s (%s)\n", alg
, driver
);
3288 #endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */
3290 EXPORT_SYMBOL_GPL(alg_test
);