2 * Algorithm testing framework and tests.
4 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
5 * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
6 * Copyright (c) 2007 Nokia Siemens Networks
7 * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
9 * Updated RFC4106 AES-GCM testing.
10 * Authors: Aidan O'Mahony (aidan.o.mahony@intel.com)
11 * Adrian Hoban <adrian.hoban@intel.com>
12 * Gabriele Paoloni <gabriele.paoloni@intel.com>
13 * Tadeusz Struk (tadeusz.struk@intel.com)
14 * Copyright (c) 2010, Intel Corporation.
16 * This program is free software; you can redistribute it and/or modify it
17 * under the terms of the GNU General Public License as published by the Free
18 * Software Foundation; either version 2 of the License, or (at your option)
23 #include <crypto/aead.h>
24 #include <crypto/hash.h>
25 #include <crypto/skcipher.h>
26 #include <linux/err.h>
27 #include <linux/fips.h>
28 #include <linux/module.h>
29 #include <linux/scatterlist.h>
30 #include <linux/slab.h>
31 #include <linux/string.h>
32 #include <crypto/rng.h>
33 #include <crypto/drbg.h>
34 #include <crypto/akcipher.h>
35 #include <crypto/kpp.h>
36 #include <crypto/acompress.h>
41 module_param(notests
, bool, 0644);
42 MODULE_PARM_DESC(notests
, "disable crypto self-tests");
44 #ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
47 int alg_test(const char *driver
, const char *alg
, u32 type
, u32 mask
)
57 * Need slab memory for testing (size in number of pages).
62 * Indexes into the xbuf to simulate cross-page access.
74 * Used by test_cipher()
79 struct tcrypt_result
{
80 struct completion completion
;
84 struct aead_test_suite
{
86 struct aead_testvec
*vecs
;
91 struct cipher_test_suite
{
93 struct cipher_testvec
*vecs
;
98 struct comp_test_suite
{
100 struct comp_testvec
*vecs
;
105 struct hash_test_suite
{
106 struct hash_testvec
*vecs
;
110 struct cprng_test_suite
{
111 struct cprng_testvec
*vecs
;
115 struct drbg_test_suite
{
116 struct drbg_testvec
*vecs
;
120 struct akcipher_test_suite
{
121 struct akcipher_testvec
*vecs
;
125 struct kpp_test_suite
{
126 struct kpp_testvec
*vecs
;
130 struct alg_test_desc
{
132 int (*test
)(const struct alg_test_desc
*desc
, const char *driver
,
134 int fips_allowed
; /* set if alg is allowed in fips mode */
137 struct aead_test_suite aead
;
138 struct cipher_test_suite cipher
;
139 struct comp_test_suite comp
;
140 struct hash_test_suite hash
;
141 struct cprng_test_suite cprng
;
142 struct drbg_test_suite drbg
;
143 struct akcipher_test_suite akcipher
;
144 struct kpp_test_suite kpp
;
148 static unsigned int IDX
[8] = { IDX1
, IDX2
, IDX3
, IDX4
, IDX5
, IDX6
, IDX7
, IDX8
};
150 static void hexdump(unsigned char *buf
, unsigned int len
)
152 print_hex_dump(KERN_CONT
, "", DUMP_PREFIX_OFFSET
,
157 static void tcrypt_complete(struct crypto_async_request
*req
, int err
)
159 struct tcrypt_result
*res
= req
->data
;
161 if (err
== -EINPROGRESS
)
165 complete(&res
->completion
);
168 static int testmgr_alloc_buf(char *buf
[XBUFSIZE
])
172 for (i
= 0; i
< XBUFSIZE
; i
++) {
173 buf
[i
] = (void *)__get_free_page(GFP_KERNEL
);
182 free_page((unsigned long)buf
[i
]);
187 static void testmgr_free_buf(char *buf
[XBUFSIZE
])
191 for (i
= 0; i
< XBUFSIZE
; i
++)
192 free_page((unsigned long)buf
[i
]);
195 static int wait_async_op(struct tcrypt_result
*tr
, int ret
)
197 if (ret
== -EINPROGRESS
|| ret
== -EBUSY
) {
198 wait_for_completion(&tr
->completion
);
199 reinit_completion(&tr
->completion
);
205 static int ahash_partial_update(struct ahash_request
**preq
,
206 struct crypto_ahash
*tfm
, struct hash_testvec
*template,
207 void *hash_buff
, int k
, int temp
, struct scatterlist
*sg
,
208 const char *algo
, char *result
, struct tcrypt_result
*tresult
)
211 struct ahash_request
*req
;
212 int statesize
, ret
= -EINVAL
;
213 const char guard
[] = { 0x00, 0xba, 0xad, 0x00 };
216 statesize
= crypto_ahash_statesize(
217 crypto_ahash_reqtfm(req
));
218 state
= kmalloc(statesize
+ sizeof(guard
), GFP_KERNEL
);
220 pr_err("alt: hash: Failed to alloc state for %s\n", algo
);
223 memcpy(state
+ statesize
, guard
, sizeof(guard
));
224 ret
= crypto_ahash_export(req
, state
);
225 WARN_ON(memcmp(state
+ statesize
, guard
, sizeof(guard
)));
227 pr_err("alt: hash: Failed to export() for %s\n", algo
);
230 ahash_request_free(req
);
231 req
= ahash_request_alloc(tfm
, GFP_KERNEL
);
233 pr_err("alg: hash: Failed to alloc request for %s\n", algo
);
236 ahash_request_set_callback(req
,
237 CRYPTO_TFM_REQ_MAY_BACKLOG
,
238 tcrypt_complete
, tresult
);
240 memcpy(hash_buff
, template->plaintext
+ temp
,
242 sg_init_one(&sg
[0], hash_buff
, template->tap
[k
]);
243 ahash_request_set_crypt(req
, sg
, result
, template->tap
[k
]);
244 ret
= crypto_ahash_import(req
, state
);
246 pr_err("alg: hash: Failed to import() for %s\n", algo
);
249 ret
= wait_async_op(tresult
, crypto_ahash_update(req
));
256 ahash_request_free(req
);
263 static int __test_hash(struct crypto_ahash
*tfm
, struct hash_testvec
*template,
264 unsigned int tcount
, bool use_digest
,
265 const int align_offset
)
267 const char *algo
= crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm
));
268 unsigned int i
, j
, k
, temp
;
269 struct scatterlist sg
[8];
272 struct ahash_request
*req
;
273 struct tcrypt_result tresult
;
275 char *xbuf
[XBUFSIZE
];
278 result
= kmalloc(MAX_DIGEST_SIZE
, GFP_KERNEL
);
281 key
= kmalloc(MAX_KEYLEN
, GFP_KERNEL
);
284 if (testmgr_alloc_buf(xbuf
))
287 init_completion(&tresult
.completion
);
289 req
= ahash_request_alloc(tfm
, GFP_KERNEL
);
291 printk(KERN_ERR
"alg: hash: Failed to allocate request for "
295 ahash_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
296 tcrypt_complete
, &tresult
);
299 for (i
= 0; i
< tcount
; i
++) {
304 if (WARN_ON(align_offset
+ template[i
].psize
> PAGE_SIZE
))
308 memset(result
, 0, MAX_DIGEST_SIZE
);
311 hash_buff
+= align_offset
;
313 memcpy(hash_buff
, template[i
].plaintext
, template[i
].psize
);
314 sg_init_one(&sg
[0], hash_buff
, template[i
].psize
);
316 if (template[i
].ksize
) {
317 crypto_ahash_clear_flags(tfm
, ~0);
318 if (template[i
].ksize
> MAX_KEYLEN
) {
319 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
320 j
, algo
, template[i
].ksize
, MAX_KEYLEN
);
324 memcpy(key
, template[i
].key
, template[i
].ksize
);
325 ret
= crypto_ahash_setkey(tfm
, key
, template[i
].ksize
);
327 printk(KERN_ERR
"alg: hash: setkey failed on "
328 "test %d for %s: ret=%d\n", j
, algo
,
334 ahash_request_set_crypt(req
, sg
, result
, template[i
].psize
);
336 ret
= wait_async_op(&tresult
, crypto_ahash_digest(req
));
338 pr_err("alg: hash: digest failed on test %d "
339 "for %s: ret=%d\n", j
, algo
, -ret
);
343 ret
= wait_async_op(&tresult
, crypto_ahash_init(req
));
345 pr_err("alt: hash: init failed on test %d "
346 "for %s: ret=%d\n", j
, algo
, -ret
);
349 ret
= wait_async_op(&tresult
, crypto_ahash_update(req
));
351 pr_err("alt: hash: update failed on test %d "
352 "for %s: ret=%d\n", j
, algo
, -ret
);
355 ret
= wait_async_op(&tresult
, crypto_ahash_final(req
));
357 pr_err("alt: hash: final failed on test %d "
358 "for %s: ret=%d\n", j
, algo
, -ret
);
363 if (memcmp(result
, template[i
].digest
,
364 crypto_ahash_digestsize(tfm
))) {
365 printk(KERN_ERR
"alg: hash: Test %d failed for %s\n",
367 hexdump(result
, crypto_ahash_digestsize(tfm
));
374 for (i
= 0; i
< tcount
; i
++) {
375 /* alignment tests are only done with continuous buffers */
376 if (align_offset
!= 0)
383 memset(result
, 0, MAX_DIGEST_SIZE
);
386 sg_init_table(sg
, template[i
].np
);
388 for (k
= 0; k
< template[i
].np
; k
++) {
389 if (WARN_ON(offset_in_page(IDX
[k
]) +
390 template[i
].tap
[k
] > PAGE_SIZE
))
393 memcpy(xbuf
[IDX
[k
] >> PAGE_SHIFT
] +
394 offset_in_page(IDX
[k
]),
395 template[i
].plaintext
+ temp
,
398 temp
+= template[i
].tap
[k
];
401 if (template[i
].ksize
) {
402 if (template[i
].ksize
> MAX_KEYLEN
) {
403 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
404 j
, algo
, template[i
].ksize
, MAX_KEYLEN
);
408 crypto_ahash_clear_flags(tfm
, ~0);
409 memcpy(key
, template[i
].key
, template[i
].ksize
);
410 ret
= crypto_ahash_setkey(tfm
, key
, template[i
].ksize
);
413 printk(KERN_ERR
"alg: hash: setkey "
414 "failed on chunking test %d "
415 "for %s: ret=%d\n", j
, algo
, -ret
);
420 ahash_request_set_crypt(req
, sg
, result
, template[i
].psize
);
421 ret
= crypto_ahash_digest(req
);
427 wait_for_completion(&tresult
.completion
);
428 reinit_completion(&tresult
.completion
);
434 printk(KERN_ERR
"alg: hash: digest failed "
435 "on chunking test %d for %s: "
436 "ret=%d\n", j
, algo
, -ret
);
440 if (memcmp(result
, template[i
].digest
,
441 crypto_ahash_digestsize(tfm
))) {
442 printk(KERN_ERR
"alg: hash: Chunking test %d "
443 "failed for %s\n", j
, algo
);
444 hexdump(result
, crypto_ahash_digestsize(tfm
));
450 /* partial update exercise */
452 for (i
= 0; i
< tcount
; i
++) {
453 /* alignment tests are only done with continuous buffers */
454 if (align_offset
!= 0)
457 if (template[i
].np
< 2)
461 memset(result
, 0, MAX_DIGEST_SIZE
);
465 memcpy(hash_buff
, template[i
].plaintext
,
467 sg_init_one(&sg
[0], hash_buff
, template[i
].tap
[0]);
469 if (template[i
].ksize
) {
470 crypto_ahash_clear_flags(tfm
, ~0);
471 if (template[i
].ksize
> MAX_KEYLEN
) {
472 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
473 j
, algo
, template[i
].ksize
, MAX_KEYLEN
);
477 memcpy(key
, template[i
].key
, template[i
].ksize
);
478 ret
= crypto_ahash_setkey(tfm
, key
, template[i
].ksize
);
480 pr_err("alg: hash: setkey failed on test %d for %s: ret=%d\n",
486 ahash_request_set_crypt(req
, sg
, result
, template[i
].tap
[0]);
487 ret
= wait_async_op(&tresult
, crypto_ahash_init(req
));
489 pr_err("alt: hash: init failed on test %d for %s: ret=%d\n",
493 ret
= wait_async_op(&tresult
, crypto_ahash_update(req
));
495 pr_err("alt: hash: update failed on test %d for %s: ret=%d\n",
500 temp
= template[i
].tap
[0];
501 for (k
= 1; k
< template[i
].np
; k
++) {
502 ret
= ahash_partial_update(&req
, tfm
, &template[i
],
503 hash_buff
, k
, temp
, &sg
[0], algo
, result
,
506 pr_err("hash: partial update failed on test %d for %s: ret=%d\n",
510 temp
+= template[i
].tap
[k
];
512 ret
= wait_async_op(&tresult
, crypto_ahash_final(req
));
514 pr_err("alt: hash: final failed on test %d for %s: ret=%d\n",
518 if (memcmp(result
, template[i
].digest
,
519 crypto_ahash_digestsize(tfm
))) {
520 pr_err("alg: hash: Partial Test %d failed for %s\n",
522 hexdump(result
, crypto_ahash_digestsize(tfm
));
531 ahash_request_free(req
);
533 testmgr_free_buf(xbuf
);
540 static int test_hash(struct crypto_ahash
*tfm
, struct hash_testvec
*template,
541 unsigned int tcount
, bool use_digest
)
543 unsigned int alignmask
;
546 ret
= __test_hash(tfm
, template, tcount
, use_digest
, 0);
550 /* test unaligned buffers, check with one byte offset */
551 ret
= __test_hash(tfm
, template, tcount
, use_digest
, 1);
555 alignmask
= crypto_tfm_alg_alignmask(&tfm
->base
);
557 /* Check if alignment mask for tfm is correctly set. */
558 ret
= __test_hash(tfm
, template, tcount
, use_digest
,
567 static int __test_aead(struct crypto_aead
*tfm
, int enc
,
568 struct aead_testvec
*template, unsigned int tcount
,
569 const bool diff_dst
, const int align_offset
)
571 const char *algo
= crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm
));
572 unsigned int i
, j
, k
, n
, temp
;
576 struct aead_request
*req
;
577 struct scatterlist
*sg
;
578 struct scatterlist
*sgout
;
580 struct tcrypt_result result
;
581 unsigned int authsize
, iv_len
;
586 char *xbuf
[XBUFSIZE
];
587 char *xoutbuf
[XBUFSIZE
];
588 char *axbuf
[XBUFSIZE
];
590 iv
= kzalloc(MAX_IVLEN
, GFP_KERNEL
);
593 key
= kmalloc(MAX_KEYLEN
, GFP_KERNEL
);
596 if (testmgr_alloc_buf(xbuf
))
598 if (testmgr_alloc_buf(axbuf
))
600 if (diff_dst
&& testmgr_alloc_buf(xoutbuf
))
603 /* avoid "the frame size is larger than 1024 bytes" compiler warning */
604 sg
= kmalloc(sizeof(*sg
) * 8 * (diff_dst
? 4 : 2), GFP_KERNEL
);
619 init_completion(&result
.completion
);
621 req
= aead_request_alloc(tfm
, GFP_KERNEL
);
623 pr_err("alg: aead%s: Failed to allocate request for %s\n",
628 aead_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
629 tcrypt_complete
, &result
);
631 iv_len
= crypto_aead_ivsize(tfm
);
633 for (i
= 0, j
= 0; i
< tcount
; i
++) {
639 /* some templates have no input data but they will
643 input
+= align_offset
;
647 if (WARN_ON(align_offset
+ template[i
].ilen
>
648 PAGE_SIZE
|| template[i
].alen
> PAGE_SIZE
))
651 memcpy(input
, template[i
].input
, template[i
].ilen
);
652 memcpy(assoc
, template[i
].assoc
, template[i
].alen
);
654 memcpy(iv
, template[i
].iv
, iv_len
);
656 memset(iv
, 0, iv_len
);
658 crypto_aead_clear_flags(tfm
, ~0);
660 crypto_aead_set_flags(tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
662 if (template[i
].klen
> MAX_KEYLEN
) {
663 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
664 d
, j
, algo
, template[i
].klen
,
669 memcpy(key
, template[i
].key
, template[i
].klen
);
671 ret
= crypto_aead_setkey(tfm
, key
, template[i
].klen
);
672 if (template[i
].fail
== !ret
) {
673 pr_err("alg: aead%s: setkey failed on test %d for %s: flags=%x\n",
674 d
, j
, algo
, crypto_aead_get_flags(tfm
));
679 authsize
= abs(template[i
].rlen
- template[i
].ilen
);
680 ret
= crypto_aead_setauthsize(tfm
, authsize
);
682 pr_err("alg: aead%s: Failed to set authsize to %u on test %d for %s\n",
683 d
, authsize
, j
, algo
);
687 k
= !!template[i
].alen
;
688 sg_init_table(sg
, k
+ 1);
689 sg_set_buf(&sg
[0], assoc
, template[i
].alen
);
690 sg_set_buf(&sg
[k
], input
,
691 template[i
].ilen
+ (enc
? authsize
: 0));
695 sg_init_table(sgout
, k
+ 1);
696 sg_set_buf(&sgout
[0], assoc
, template[i
].alen
);
699 output
+= align_offset
;
700 sg_set_buf(&sgout
[k
], output
,
701 template[i
].rlen
+ (enc
? 0 : authsize
));
704 aead_request_set_crypt(req
, sg
, (diff_dst
) ? sgout
: sg
,
705 template[i
].ilen
, iv
);
707 aead_request_set_ad(req
, template[i
].alen
);
709 ret
= enc
? crypto_aead_encrypt(req
) : crypto_aead_decrypt(req
);
713 if (template[i
].novrfy
) {
714 /* verification was supposed to fail */
715 pr_err("alg: aead%s: %s failed on test %d for %s: ret was 0, expected -EBADMSG\n",
717 /* so really, we got a bad message */
724 wait_for_completion(&result
.completion
);
725 reinit_completion(&result
.completion
);
730 if (template[i
].novrfy
)
731 /* verification failure was expected */
735 pr_err("alg: aead%s: %s failed on test %d for %s: ret=%d\n",
736 d
, e
, j
, algo
, -ret
);
741 if (memcmp(q
, template[i
].result
, template[i
].rlen
)) {
742 pr_err("alg: aead%s: Test %d failed on %s for %s\n",
744 hexdump(q
, template[i
].rlen
);
750 for (i
= 0, j
= 0; i
< tcount
; i
++) {
751 /* alignment tests are only done with continuous buffers */
752 if (align_offset
!= 0)
761 memcpy(iv
, template[i
].iv
, iv_len
);
763 memset(iv
, 0, MAX_IVLEN
);
765 crypto_aead_clear_flags(tfm
, ~0);
767 crypto_aead_set_flags(tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
768 if (template[i
].klen
> MAX_KEYLEN
) {
769 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
770 d
, j
, algo
, template[i
].klen
, MAX_KEYLEN
);
774 memcpy(key
, template[i
].key
, template[i
].klen
);
776 ret
= crypto_aead_setkey(tfm
, key
, template[i
].klen
);
777 if (template[i
].fail
== !ret
) {
778 pr_err("alg: aead%s: setkey failed on chunk test %d for %s: flags=%x\n",
779 d
, j
, algo
, crypto_aead_get_flags(tfm
));
784 authsize
= abs(template[i
].rlen
- template[i
].ilen
);
787 sg_init_table(sg
, template[i
].anp
+ template[i
].np
);
789 sg_init_table(sgout
, template[i
].anp
+ template[i
].np
);
792 for (k
= 0, temp
= 0; k
< template[i
].anp
; k
++) {
793 if (WARN_ON(offset_in_page(IDX
[k
]) +
794 template[i
].atap
[k
] > PAGE_SIZE
))
797 memcpy(axbuf
[IDX
[k
] >> PAGE_SHIFT
] +
798 offset_in_page(IDX
[k
]),
799 template[i
].assoc
+ temp
,
800 template[i
].atap
[k
]),
801 template[i
].atap
[k
]);
803 sg_set_buf(&sgout
[k
],
804 axbuf
[IDX
[k
] >> PAGE_SHIFT
] +
805 offset_in_page(IDX
[k
]),
806 template[i
].atap
[k
]);
807 temp
+= template[i
].atap
[k
];
810 for (k
= 0, temp
= 0; k
< template[i
].np
; k
++) {
811 if (WARN_ON(offset_in_page(IDX
[k
]) +
812 template[i
].tap
[k
] > PAGE_SIZE
))
815 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] + offset_in_page(IDX
[k
]);
816 memcpy(q
, template[i
].input
+ temp
, template[i
].tap
[k
]);
817 sg_set_buf(&sg
[template[i
].anp
+ k
],
818 q
, template[i
].tap
[k
]);
821 q
= xoutbuf
[IDX
[k
] >> PAGE_SHIFT
] +
822 offset_in_page(IDX
[k
]);
824 memset(q
, 0, template[i
].tap
[k
]);
826 sg_set_buf(&sgout
[template[i
].anp
+ k
],
827 q
, template[i
].tap
[k
]);
830 n
= template[i
].tap
[k
];
831 if (k
== template[i
].np
- 1 && enc
)
833 if (offset_in_page(q
) + n
< PAGE_SIZE
)
836 temp
+= template[i
].tap
[k
];
839 ret
= crypto_aead_setauthsize(tfm
, authsize
);
841 pr_err("alg: aead%s: Failed to set authsize to %u on chunk test %d for %s\n",
842 d
, authsize
, j
, algo
);
847 if (WARN_ON(sg
[template[i
].anp
+ k
- 1].offset
+
848 sg
[template[i
].anp
+ k
- 1].length
+
849 authsize
> PAGE_SIZE
)) {
855 sgout
[template[i
].anp
+ k
- 1].length
+=
857 sg
[template[i
].anp
+ k
- 1].length
+= authsize
;
860 aead_request_set_crypt(req
, sg
, (diff_dst
) ? sgout
: sg
,
864 aead_request_set_ad(req
, template[i
].alen
);
866 ret
= enc
? crypto_aead_encrypt(req
) : crypto_aead_decrypt(req
);
870 if (template[i
].novrfy
) {
871 /* verification was supposed to fail */
872 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret was 0, expected -EBADMSG\n",
874 /* so really, we got a bad message */
881 wait_for_completion(&result
.completion
);
882 reinit_completion(&result
.completion
);
887 if (template[i
].novrfy
)
888 /* verification failure was expected */
892 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret=%d\n",
893 d
, e
, j
, algo
, -ret
);
898 for (k
= 0, temp
= 0; k
< template[i
].np
; k
++) {
900 q
= xoutbuf
[IDX
[k
] >> PAGE_SHIFT
] +
901 offset_in_page(IDX
[k
]);
903 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] +
904 offset_in_page(IDX
[k
]);
906 n
= template[i
].tap
[k
];
907 if (k
== template[i
].np
- 1)
908 n
+= enc
? authsize
: -authsize
;
910 if (memcmp(q
, template[i
].result
+ temp
, n
)) {
911 pr_err("alg: aead%s: Chunk test %d failed on %s at page %u for %s\n",
918 if (k
== template[i
].np
- 1 && !enc
) {
920 memcmp(q
, template[i
].input
+
926 for (n
= 0; offset_in_page(q
+ n
) && q
[n
]; n
++)
930 pr_err("alg: aead%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
931 d
, j
, e
, k
, algo
, n
);
936 temp
+= template[i
].tap
[k
];
943 aead_request_free(req
);
947 testmgr_free_buf(xoutbuf
);
949 testmgr_free_buf(axbuf
);
951 testmgr_free_buf(xbuf
);
958 static int test_aead(struct crypto_aead
*tfm
, int enc
,
959 struct aead_testvec
*template, unsigned int tcount
)
961 unsigned int alignmask
;
964 /* test 'dst == src' case */
965 ret
= __test_aead(tfm
, enc
, template, tcount
, false, 0);
969 /* test 'dst != src' case */
970 ret
= __test_aead(tfm
, enc
, template, tcount
, true, 0);
974 /* test unaligned buffers, check with one byte offset */
975 ret
= __test_aead(tfm
, enc
, template, tcount
, true, 1);
979 alignmask
= crypto_tfm_alg_alignmask(&tfm
->base
);
981 /* Check if alignment mask for tfm is correctly set. */
982 ret
= __test_aead(tfm
, enc
, template, tcount
, true,
991 static int test_cipher(struct crypto_cipher
*tfm
, int enc
,
992 struct cipher_testvec
*template, unsigned int tcount
)
994 const char *algo
= crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm
));
995 unsigned int i
, j
, k
;
999 char *xbuf
[XBUFSIZE
];
1002 if (testmgr_alloc_buf(xbuf
))
1011 for (i
= 0; i
< tcount
; i
++) {
1015 if (fips_enabled
&& template[i
].fips_skip
)
1021 if (WARN_ON(template[i
].ilen
> PAGE_SIZE
))
1025 memcpy(data
, template[i
].input
, template[i
].ilen
);
1027 crypto_cipher_clear_flags(tfm
, ~0);
1029 crypto_cipher_set_flags(tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
1031 ret
= crypto_cipher_setkey(tfm
, template[i
].key
,
1033 if (template[i
].fail
== !ret
) {
1034 printk(KERN_ERR
"alg: cipher: setkey failed "
1035 "on test %d for %s: flags=%x\n", j
,
1036 algo
, crypto_cipher_get_flags(tfm
));
1041 for (k
= 0; k
< template[i
].ilen
;
1042 k
+= crypto_cipher_blocksize(tfm
)) {
1044 crypto_cipher_encrypt_one(tfm
, data
+ k
,
1047 crypto_cipher_decrypt_one(tfm
, data
+ k
,
1052 if (memcmp(q
, template[i
].result
, template[i
].rlen
)) {
1053 printk(KERN_ERR
"alg: cipher: Test %d failed "
1054 "on %s for %s\n", j
, e
, algo
);
1055 hexdump(q
, template[i
].rlen
);
1064 testmgr_free_buf(xbuf
);
1069 static int __test_skcipher(struct crypto_skcipher
*tfm
, int enc
,
1070 struct cipher_testvec
*template, unsigned int tcount
,
1071 const bool diff_dst
, const int align_offset
)
1074 crypto_tfm_alg_driver_name(crypto_skcipher_tfm(tfm
));
1075 unsigned int i
, j
, k
, n
, temp
;
1077 struct skcipher_request
*req
;
1078 struct scatterlist sg
[8];
1079 struct scatterlist sgout
[8];
1081 struct tcrypt_result result
;
1084 char *xbuf
[XBUFSIZE
];
1085 char *xoutbuf
[XBUFSIZE
];
1087 unsigned int ivsize
= crypto_skcipher_ivsize(tfm
);
1089 if (testmgr_alloc_buf(xbuf
))
1092 if (diff_dst
&& testmgr_alloc_buf(xoutbuf
))
1105 init_completion(&result
.completion
);
1107 req
= skcipher_request_alloc(tfm
, GFP_KERNEL
);
1109 pr_err("alg: skcipher%s: Failed to allocate request for %s\n",
1114 skcipher_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
1115 tcrypt_complete
, &result
);
1118 for (i
= 0; i
< tcount
; i
++) {
1119 if (template[i
].np
&& !template[i
].also_non_np
)
1122 if (fips_enabled
&& template[i
].fips_skip
)
1126 memcpy(iv
, template[i
].iv
, ivsize
);
1128 memset(iv
, 0, MAX_IVLEN
);
1132 if (WARN_ON(align_offset
+ template[i
].ilen
> PAGE_SIZE
))
1136 data
+= align_offset
;
1137 memcpy(data
, template[i
].input
, template[i
].ilen
);
1139 crypto_skcipher_clear_flags(tfm
, ~0);
1141 crypto_skcipher_set_flags(tfm
,
1142 CRYPTO_TFM_REQ_WEAK_KEY
);
1144 ret
= crypto_skcipher_setkey(tfm
, template[i
].key
,
1146 if (template[i
].fail
== !ret
) {
1147 pr_err("alg: skcipher%s: setkey failed on test %d for %s: flags=%x\n",
1148 d
, j
, algo
, crypto_skcipher_get_flags(tfm
));
1153 sg_init_one(&sg
[0], data
, template[i
].ilen
);
1156 data
+= align_offset
;
1157 sg_init_one(&sgout
[0], data
, template[i
].ilen
);
1160 skcipher_request_set_crypt(req
, sg
, (diff_dst
) ? sgout
: sg
,
1161 template[i
].ilen
, iv
);
1162 ret
= enc
? crypto_skcipher_encrypt(req
) :
1163 crypto_skcipher_decrypt(req
);
1170 wait_for_completion(&result
.completion
);
1171 reinit_completion(&result
.completion
);
1177 pr_err("alg: skcipher%s: %s failed on test %d for %s: ret=%d\n",
1178 d
, e
, j
, algo
, -ret
);
1183 if (memcmp(q
, template[i
].result
, template[i
].rlen
)) {
1184 pr_err("alg: skcipher%s: Test %d failed (invalid result) on %s for %s\n",
1186 hexdump(q
, template[i
].rlen
);
1191 if (template[i
].iv_out
&&
1192 memcmp(iv
, template[i
].iv_out
,
1193 crypto_skcipher_ivsize(tfm
))) {
1194 pr_err("alg: skcipher%s: Test %d failed (invalid output IV) on %s for %s\n",
1196 hexdump(iv
, crypto_skcipher_ivsize(tfm
));
1203 for (i
= 0; i
< tcount
; i
++) {
1204 /* alignment tests are only done with continuous buffers */
1205 if (align_offset
!= 0)
1208 if (!template[i
].np
)
1211 if (fips_enabled
&& template[i
].fips_skip
)
1215 memcpy(iv
, template[i
].iv
, ivsize
);
1217 memset(iv
, 0, MAX_IVLEN
);
1220 crypto_skcipher_clear_flags(tfm
, ~0);
1222 crypto_skcipher_set_flags(tfm
,
1223 CRYPTO_TFM_REQ_WEAK_KEY
);
1225 ret
= crypto_skcipher_setkey(tfm
, template[i
].key
,
1227 if (template[i
].fail
== !ret
) {
1228 pr_err("alg: skcipher%s: setkey failed on chunk test %d for %s: flags=%x\n",
1229 d
, j
, algo
, crypto_skcipher_get_flags(tfm
));
1236 sg_init_table(sg
, template[i
].np
);
1238 sg_init_table(sgout
, template[i
].np
);
1239 for (k
= 0; k
< template[i
].np
; k
++) {
1240 if (WARN_ON(offset_in_page(IDX
[k
]) +
1241 template[i
].tap
[k
] > PAGE_SIZE
))
1244 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] + offset_in_page(IDX
[k
]);
1246 memcpy(q
, template[i
].input
+ temp
, template[i
].tap
[k
]);
1248 if (offset_in_page(q
) + template[i
].tap
[k
] < PAGE_SIZE
)
1249 q
[template[i
].tap
[k
]] = 0;
1251 sg_set_buf(&sg
[k
], q
, template[i
].tap
[k
]);
1253 q
= xoutbuf
[IDX
[k
] >> PAGE_SHIFT
] +
1254 offset_in_page(IDX
[k
]);
1256 sg_set_buf(&sgout
[k
], q
, template[i
].tap
[k
]);
1258 memset(q
, 0, template[i
].tap
[k
]);
1259 if (offset_in_page(q
) +
1260 template[i
].tap
[k
] < PAGE_SIZE
)
1261 q
[template[i
].tap
[k
]] = 0;
1264 temp
+= template[i
].tap
[k
];
1267 skcipher_request_set_crypt(req
, sg
, (diff_dst
) ? sgout
: sg
,
1268 template[i
].ilen
, iv
);
1270 ret
= enc
? crypto_skcipher_encrypt(req
) :
1271 crypto_skcipher_decrypt(req
);
1278 wait_for_completion(&result
.completion
);
1279 reinit_completion(&result
.completion
);
1285 pr_err("alg: skcipher%s: %s failed on chunk test %d for %s: ret=%d\n",
1286 d
, e
, j
, algo
, -ret
);
1292 for (k
= 0; k
< template[i
].np
; k
++) {
1294 q
= xoutbuf
[IDX
[k
] >> PAGE_SHIFT
] +
1295 offset_in_page(IDX
[k
]);
1297 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] +
1298 offset_in_page(IDX
[k
]);
1300 if (memcmp(q
, template[i
].result
+ temp
,
1301 template[i
].tap
[k
])) {
1302 pr_err("alg: skcipher%s: Chunk test %d failed on %s at page %u for %s\n",
1304 hexdump(q
, template[i
].tap
[k
]);
1308 q
+= template[i
].tap
[k
];
1309 for (n
= 0; offset_in_page(q
+ n
) && q
[n
]; n
++)
1312 pr_err("alg: skcipher%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
1313 d
, j
, e
, k
, algo
, n
);
1317 temp
+= template[i
].tap
[k
];
1324 skcipher_request_free(req
);
1326 testmgr_free_buf(xoutbuf
);
1328 testmgr_free_buf(xbuf
);
1333 static int test_skcipher(struct crypto_skcipher
*tfm
, int enc
,
1334 struct cipher_testvec
*template, unsigned int tcount
)
1336 unsigned int alignmask
;
1339 /* test 'dst == src' case */
1340 ret
= __test_skcipher(tfm
, enc
, template, tcount
, false, 0);
1344 /* test 'dst != src' case */
1345 ret
= __test_skcipher(tfm
, enc
, template, tcount
, true, 0);
1349 /* test unaligned buffers, check with one byte offset */
1350 ret
= __test_skcipher(tfm
, enc
, template, tcount
, true, 1);
1354 alignmask
= crypto_tfm_alg_alignmask(&tfm
->base
);
1356 /* Check if alignment mask for tfm is correctly set. */
1357 ret
= __test_skcipher(tfm
, enc
, template, tcount
, true,
1366 static int test_comp(struct crypto_comp
*tfm
, struct comp_testvec
*ctemplate
,
1367 struct comp_testvec
*dtemplate
, int ctcount
, int dtcount
)
1369 const char *algo
= crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm
));
1371 char result
[COMP_BUF_SIZE
];
1374 for (i
= 0; i
< ctcount
; i
++) {
1376 unsigned int dlen
= COMP_BUF_SIZE
;
1378 memset(result
, 0, sizeof (result
));
1380 ilen
= ctemplate
[i
].inlen
;
1381 ret
= crypto_comp_compress(tfm
, ctemplate
[i
].input
,
1382 ilen
, result
, &dlen
);
1384 printk(KERN_ERR
"alg: comp: compression failed "
1385 "on test %d for %s: ret=%d\n", i
+ 1, algo
,
1390 if (dlen
!= ctemplate
[i
].outlen
) {
1391 printk(KERN_ERR
"alg: comp: Compression test %d "
1392 "failed for %s: output len = %d\n", i
+ 1, algo
,
1398 if (memcmp(result
, ctemplate
[i
].output
, dlen
)) {
1399 printk(KERN_ERR
"alg: comp: Compression test %d "
1400 "failed for %s\n", i
+ 1, algo
);
1401 hexdump(result
, dlen
);
1407 for (i
= 0; i
< dtcount
; i
++) {
1409 unsigned int dlen
= COMP_BUF_SIZE
;
1411 memset(result
, 0, sizeof (result
));
1413 ilen
= dtemplate
[i
].inlen
;
1414 ret
= crypto_comp_decompress(tfm
, dtemplate
[i
].input
,
1415 ilen
, result
, &dlen
);
1417 printk(KERN_ERR
"alg: comp: decompression failed "
1418 "on test %d for %s: ret=%d\n", i
+ 1, algo
,
1423 if (dlen
!= dtemplate
[i
].outlen
) {
1424 printk(KERN_ERR
"alg: comp: Decompression test %d "
1425 "failed for %s: output len = %d\n", i
+ 1, algo
,
1431 if (memcmp(result
, dtemplate
[i
].output
, dlen
)) {
1432 printk(KERN_ERR
"alg: comp: Decompression test %d "
1433 "failed for %s\n", i
+ 1, algo
);
1434 hexdump(result
, dlen
);
1446 static int test_acomp(struct crypto_acomp
*tfm
, struct comp_testvec
*ctemplate
,
1447 struct comp_testvec
*dtemplate
, int ctcount
, int dtcount
)
1449 const char *algo
= crypto_tfm_alg_driver_name(crypto_acomp_tfm(tfm
));
1453 struct scatterlist src
, dst
;
1454 struct acomp_req
*req
;
1455 struct tcrypt_result result
;
1457 output
= kmalloc(COMP_BUF_SIZE
, GFP_KERNEL
);
1461 for (i
= 0; i
< ctcount
; i
++) {
1462 unsigned int dlen
= COMP_BUF_SIZE
;
1463 int ilen
= ctemplate
[i
].inlen
;
1466 input_vec
= kmalloc(ilen
, GFP_KERNEL
);
1472 memcpy(input_vec
, ctemplate
[i
].input
, ilen
);
1473 memset(output
, 0, dlen
);
1474 init_completion(&result
.completion
);
1475 sg_init_one(&src
, input_vec
, ilen
);
1476 sg_init_one(&dst
, output
, dlen
);
1478 req
= acomp_request_alloc(tfm
);
1480 pr_err("alg: acomp: request alloc failed for %s\n",
1487 acomp_request_set_params(req
, &src
, &dst
, ilen
, dlen
);
1488 acomp_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
1489 tcrypt_complete
, &result
);
1491 ret
= wait_async_op(&result
, crypto_acomp_compress(req
));
1493 pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n",
1496 acomp_request_free(req
);
1500 if (req
->dlen
!= ctemplate
[i
].outlen
) {
1501 pr_err("alg: acomp: Compression test %d failed for %s: output len = %d\n",
1502 i
+ 1, algo
, req
->dlen
);
1505 acomp_request_free(req
);
1509 if (memcmp(output
, ctemplate
[i
].output
, req
->dlen
)) {
1510 pr_err("alg: acomp: Compression test %d failed for %s\n",
1512 hexdump(output
, req
->dlen
);
1515 acomp_request_free(req
);
1520 acomp_request_free(req
);
1523 for (i
= 0; i
< dtcount
; i
++) {
1524 unsigned int dlen
= COMP_BUF_SIZE
;
1525 int ilen
= dtemplate
[i
].inlen
;
1528 input_vec
= kmalloc(ilen
, GFP_KERNEL
);
1534 memcpy(input_vec
, dtemplate
[i
].input
, ilen
);
1535 memset(output
, 0, dlen
);
1536 init_completion(&result
.completion
);
1537 sg_init_one(&src
, input_vec
, ilen
);
1538 sg_init_one(&dst
, output
, dlen
);
1540 req
= acomp_request_alloc(tfm
);
1542 pr_err("alg: acomp: request alloc failed for %s\n",
1549 acomp_request_set_params(req
, &src
, &dst
, ilen
, dlen
);
1550 acomp_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
1551 tcrypt_complete
, &result
);
1553 ret
= wait_async_op(&result
, crypto_acomp_decompress(req
));
1555 pr_err("alg: acomp: decompression failed on test %d for %s: ret=%d\n",
1558 acomp_request_free(req
);
1562 if (req
->dlen
!= dtemplate
[i
].outlen
) {
1563 pr_err("alg: acomp: Decompression test %d failed for %s: output len = %d\n",
1564 i
+ 1, algo
, req
->dlen
);
1567 acomp_request_free(req
);
1571 if (memcmp(output
, dtemplate
[i
].output
, req
->dlen
)) {
1572 pr_err("alg: acomp: Decompression test %d failed for %s\n",
1574 hexdump(output
, req
->dlen
);
1577 acomp_request_free(req
);
1582 acomp_request_free(req
);
1592 static int test_cprng(struct crypto_rng
*tfm
, struct cprng_testvec
*template,
1593 unsigned int tcount
)
1595 const char *algo
= crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm
));
1596 int err
= 0, i
, j
, seedsize
;
1600 seedsize
= crypto_rng_seedsize(tfm
);
1602 seed
= kmalloc(seedsize
, GFP_KERNEL
);
1604 printk(KERN_ERR
"alg: cprng: Failed to allocate seed space "
1609 for (i
= 0; i
< tcount
; i
++) {
1610 memset(result
, 0, 32);
1612 memcpy(seed
, template[i
].v
, template[i
].vlen
);
1613 memcpy(seed
+ template[i
].vlen
, template[i
].key
,
1615 memcpy(seed
+ template[i
].vlen
+ template[i
].klen
,
1616 template[i
].dt
, template[i
].dtlen
);
1618 err
= crypto_rng_reset(tfm
, seed
, seedsize
);
1620 printk(KERN_ERR
"alg: cprng: Failed to reset rng "
1625 for (j
= 0; j
< template[i
].loops
; j
++) {
1626 err
= crypto_rng_get_bytes(tfm
, result
,
1629 printk(KERN_ERR
"alg: cprng: Failed to obtain "
1630 "the correct amount of random data for "
1631 "%s (requested %d)\n", algo
,
1637 err
= memcmp(result
, template[i
].result
,
1640 printk(KERN_ERR
"alg: cprng: Test %d failed for %s\n",
1642 hexdump(result
, template[i
].rlen
);
1653 static int alg_test_aead(const struct alg_test_desc
*desc
, const char *driver
,
1656 struct crypto_aead
*tfm
;
1659 tfm
= crypto_alloc_aead(driver
, type
, mask
);
1661 printk(KERN_ERR
"alg: aead: Failed to load transform for %s: "
1662 "%ld\n", driver
, PTR_ERR(tfm
));
1663 return PTR_ERR(tfm
);
1666 if (desc
->suite
.aead
.enc
.vecs
) {
1667 err
= test_aead(tfm
, ENCRYPT
, desc
->suite
.aead
.enc
.vecs
,
1668 desc
->suite
.aead
.enc
.count
);
1673 if (!err
&& desc
->suite
.aead
.dec
.vecs
)
1674 err
= test_aead(tfm
, DECRYPT
, desc
->suite
.aead
.dec
.vecs
,
1675 desc
->suite
.aead
.dec
.count
);
1678 crypto_free_aead(tfm
);
1682 static int alg_test_cipher(const struct alg_test_desc
*desc
,
1683 const char *driver
, u32 type
, u32 mask
)
1685 struct crypto_cipher
*tfm
;
1688 tfm
= crypto_alloc_cipher(driver
, type
, mask
);
1690 printk(KERN_ERR
"alg: cipher: Failed to load transform for "
1691 "%s: %ld\n", driver
, PTR_ERR(tfm
));
1692 return PTR_ERR(tfm
);
1695 if (desc
->suite
.cipher
.enc
.vecs
) {
1696 err
= test_cipher(tfm
, ENCRYPT
, desc
->suite
.cipher
.enc
.vecs
,
1697 desc
->suite
.cipher
.enc
.count
);
1702 if (desc
->suite
.cipher
.dec
.vecs
)
1703 err
= test_cipher(tfm
, DECRYPT
, desc
->suite
.cipher
.dec
.vecs
,
1704 desc
->suite
.cipher
.dec
.count
);
1707 crypto_free_cipher(tfm
);
1711 static int alg_test_skcipher(const struct alg_test_desc
*desc
,
1712 const char *driver
, u32 type
, u32 mask
)
1714 struct crypto_skcipher
*tfm
;
1717 tfm
= crypto_alloc_skcipher(driver
, type
, mask
);
1719 printk(KERN_ERR
"alg: skcipher: Failed to load transform for "
1720 "%s: %ld\n", driver
, PTR_ERR(tfm
));
1721 return PTR_ERR(tfm
);
1724 if (desc
->suite
.cipher
.enc
.vecs
) {
1725 err
= test_skcipher(tfm
, ENCRYPT
, desc
->suite
.cipher
.enc
.vecs
,
1726 desc
->suite
.cipher
.enc
.count
);
1731 if (desc
->suite
.cipher
.dec
.vecs
)
1732 err
= test_skcipher(tfm
, DECRYPT
, desc
->suite
.cipher
.dec
.vecs
,
1733 desc
->suite
.cipher
.dec
.count
);
1736 crypto_free_skcipher(tfm
);
1740 static int alg_test_comp(const struct alg_test_desc
*desc
, const char *driver
,
1743 struct crypto_comp
*comp
;
1744 struct crypto_acomp
*acomp
;
1746 u32 algo_type
= type
& CRYPTO_ALG_TYPE_ACOMPRESS_MASK
;
1748 if (algo_type
== CRYPTO_ALG_TYPE_ACOMPRESS
) {
1749 acomp
= crypto_alloc_acomp(driver
, type
, mask
);
1750 if (IS_ERR(acomp
)) {
1751 pr_err("alg: acomp: Failed to load transform for %s: %ld\n",
1752 driver
, PTR_ERR(acomp
));
1753 return PTR_ERR(acomp
);
1755 err
= test_acomp(acomp
, desc
->suite
.comp
.comp
.vecs
,
1756 desc
->suite
.comp
.decomp
.vecs
,
1757 desc
->suite
.comp
.comp
.count
,
1758 desc
->suite
.comp
.decomp
.count
);
1759 crypto_free_acomp(acomp
);
1761 comp
= crypto_alloc_comp(driver
, type
, mask
);
1763 pr_err("alg: comp: Failed to load transform for %s: %ld\n",
1764 driver
, PTR_ERR(comp
));
1765 return PTR_ERR(comp
);
1768 err
= test_comp(comp
, desc
->suite
.comp
.comp
.vecs
,
1769 desc
->suite
.comp
.decomp
.vecs
,
1770 desc
->suite
.comp
.comp
.count
,
1771 desc
->suite
.comp
.decomp
.count
);
1773 crypto_free_comp(comp
);
1778 static int alg_test_hash(const struct alg_test_desc
*desc
, const char *driver
,
1781 struct crypto_ahash
*tfm
;
1784 tfm
= crypto_alloc_ahash(driver
, type
, mask
);
1786 printk(KERN_ERR
"alg: hash: Failed to load transform for %s: "
1787 "%ld\n", driver
, PTR_ERR(tfm
));
1788 return PTR_ERR(tfm
);
1791 err
= test_hash(tfm
, desc
->suite
.hash
.vecs
,
1792 desc
->suite
.hash
.count
, true);
1794 err
= test_hash(tfm
, desc
->suite
.hash
.vecs
,
1795 desc
->suite
.hash
.count
, false);
1797 crypto_free_ahash(tfm
);
1801 static int alg_test_crc32c(const struct alg_test_desc
*desc
,
1802 const char *driver
, u32 type
, u32 mask
)
1804 struct crypto_shash
*tfm
;
1808 err
= alg_test_hash(desc
, driver
, type
, mask
);
1812 tfm
= crypto_alloc_shash(driver
, type
, mask
);
1814 printk(KERN_ERR
"alg: crc32c: Failed to load transform for %s: "
1815 "%ld\n", driver
, PTR_ERR(tfm
));
1821 SHASH_DESC_ON_STACK(shash
, tfm
);
1822 u32
*ctx
= (u32
*)shash_desc_ctx(shash
);
1827 *ctx
= le32_to_cpu(420553207);
1828 err
= crypto_shash_final(shash
, (u8
*)&val
);
1830 printk(KERN_ERR
"alg: crc32c: Operation failed for "
1831 "%s: %d\n", driver
, err
);
1835 if (val
!= ~420553207) {
1836 printk(KERN_ERR
"alg: crc32c: Test failed for %s: "
1837 "%d\n", driver
, val
);
1842 crypto_free_shash(tfm
);
1848 static int alg_test_cprng(const struct alg_test_desc
*desc
, const char *driver
,
1851 struct crypto_rng
*rng
;
1854 rng
= crypto_alloc_rng(driver
, type
, mask
);
1856 printk(KERN_ERR
"alg: cprng: Failed to load transform for %s: "
1857 "%ld\n", driver
, PTR_ERR(rng
));
1858 return PTR_ERR(rng
);
1861 err
= test_cprng(rng
, desc
->suite
.cprng
.vecs
, desc
->suite
.cprng
.count
);
1863 crypto_free_rng(rng
);
1869 static int drbg_cavs_test(struct drbg_testvec
*test
, int pr
,
1870 const char *driver
, u32 type
, u32 mask
)
1873 struct crypto_rng
*drng
;
1874 struct drbg_test_data test_data
;
1875 struct drbg_string addtl
, pers
, testentropy
;
1876 unsigned char *buf
= kzalloc(test
->expectedlen
, GFP_KERNEL
);
1881 drng
= crypto_alloc_rng(driver
, type
, mask
);
1883 printk(KERN_ERR
"alg: drbg: could not allocate DRNG handle for "
1889 test_data
.testentropy
= &testentropy
;
1890 drbg_string_fill(&testentropy
, test
->entropy
, test
->entropylen
);
1891 drbg_string_fill(&pers
, test
->pers
, test
->perslen
);
1892 ret
= crypto_drbg_reset_test(drng
, &pers
, &test_data
);
1894 printk(KERN_ERR
"alg: drbg: Failed to reset rng\n");
1898 drbg_string_fill(&addtl
, test
->addtla
, test
->addtllen
);
1900 drbg_string_fill(&testentropy
, test
->entpra
, test
->entprlen
);
1901 ret
= crypto_drbg_get_bytes_addtl_test(drng
,
1902 buf
, test
->expectedlen
, &addtl
, &test_data
);
1904 ret
= crypto_drbg_get_bytes_addtl(drng
,
1905 buf
, test
->expectedlen
, &addtl
);
1908 printk(KERN_ERR
"alg: drbg: could not obtain random data for "
1909 "driver %s\n", driver
);
1913 drbg_string_fill(&addtl
, test
->addtlb
, test
->addtllen
);
1915 drbg_string_fill(&testentropy
, test
->entprb
, test
->entprlen
);
1916 ret
= crypto_drbg_get_bytes_addtl_test(drng
,
1917 buf
, test
->expectedlen
, &addtl
, &test_data
);
1919 ret
= crypto_drbg_get_bytes_addtl(drng
,
1920 buf
, test
->expectedlen
, &addtl
);
1923 printk(KERN_ERR
"alg: drbg: could not obtain random data for "
1924 "driver %s\n", driver
);
1928 ret
= memcmp(test
->expected
, buf
, test
->expectedlen
);
1931 crypto_free_rng(drng
);
1937 static int alg_test_drbg(const struct alg_test_desc
*desc
, const char *driver
,
1943 struct drbg_testvec
*template = desc
->suite
.drbg
.vecs
;
1944 unsigned int tcount
= desc
->suite
.drbg
.count
;
1946 if (0 == memcmp(driver
, "drbg_pr_", 8))
1949 for (i
= 0; i
< tcount
; i
++) {
1950 err
= drbg_cavs_test(&template[i
], pr
, driver
, type
, mask
);
1952 printk(KERN_ERR
"alg: drbg: Test %d failed for %s\n",
1962 static int do_test_kpp(struct crypto_kpp
*tfm
, struct kpp_testvec
*vec
,
1965 struct kpp_request
*req
;
1966 void *input_buf
= NULL
;
1967 void *output_buf
= NULL
;
1968 struct tcrypt_result result
;
1969 unsigned int out_len_max
;
1971 struct scatterlist src
, dst
;
1973 req
= kpp_request_alloc(tfm
, GFP_KERNEL
);
1977 init_completion(&result
.completion
);
1979 err
= crypto_kpp_set_secret(tfm
, vec
->secret
, vec
->secret_size
);
1983 out_len_max
= crypto_kpp_maxsize(tfm
);
1984 output_buf
= kzalloc(out_len_max
, GFP_KERNEL
);
1990 /* Use appropriate parameter as base */
1991 kpp_request_set_input(req
, NULL
, 0);
1992 sg_init_one(&dst
, output_buf
, out_len_max
);
1993 kpp_request_set_output(req
, &dst
, out_len_max
);
1994 kpp_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
1995 tcrypt_complete
, &result
);
1997 /* Compute public key */
1998 err
= wait_async_op(&result
, crypto_kpp_generate_public_key(req
));
2000 pr_err("alg: %s: generate public key test failed. err %d\n",
2004 /* Verify calculated public key */
2005 if (memcmp(vec
->expected_a_public
, sg_virt(req
->dst
),
2006 vec
->expected_a_public_size
)) {
2007 pr_err("alg: %s: generate public key test failed. Invalid output\n",
2013 /* Calculate shared secret key by using counter part (b) public key. */
2014 input_buf
= kzalloc(vec
->b_public_size
, GFP_KERNEL
);
2020 memcpy(input_buf
, vec
->b_public
, vec
->b_public_size
);
2021 sg_init_one(&src
, input_buf
, vec
->b_public_size
);
2022 sg_init_one(&dst
, output_buf
, out_len_max
);
2023 kpp_request_set_input(req
, &src
, vec
->b_public_size
);
2024 kpp_request_set_output(req
, &dst
, out_len_max
);
2025 kpp_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
2026 tcrypt_complete
, &result
);
2027 err
= wait_async_op(&result
, crypto_kpp_compute_shared_secret(req
));
2029 pr_err("alg: %s: compute shard secret test failed. err %d\n",
2034 * verify shared secret from which the user will derive
2035 * secret key by executing whatever hash it has chosen
2037 if (memcmp(vec
->expected_ss
, sg_virt(req
->dst
),
2038 vec
->expected_ss_size
)) {
2039 pr_err("alg: %s: compute shared secret test failed. Invalid output\n",
2049 kpp_request_free(req
);
2053 static int test_kpp(struct crypto_kpp
*tfm
, const char *alg
,
2054 struct kpp_testvec
*vecs
, unsigned int tcount
)
2058 for (i
= 0; i
< tcount
; i
++) {
2059 ret
= do_test_kpp(tfm
, vecs
++, alg
);
2061 pr_err("alg: %s: test failed on vector %d, err=%d\n",
2069 static int alg_test_kpp(const struct alg_test_desc
*desc
, const char *driver
,
2072 struct crypto_kpp
*tfm
;
2075 tfm
= crypto_alloc_kpp(driver
, type
, mask
);
2077 pr_err("alg: kpp: Failed to load tfm for %s: %ld\n",
2078 driver
, PTR_ERR(tfm
));
2079 return PTR_ERR(tfm
);
2081 if (desc
->suite
.kpp
.vecs
)
2082 err
= test_kpp(tfm
, desc
->alg
, desc
->suite
.kpp
.vecs
,
2083 desc
->suite
.kpp
.count
);
2085 crypto_free_kpp(tfm
);
2089 static int test_akcipher_one(struct crypto_akcipher
*tfm
,
2090 struct akcipher_testvec
*vecs
)
2092 char *xbuf
[XBUFSIZE
];
2093 struct akcipher_request
*req
;
2094 void *outbuf_enc
= NULL
;
2095 void *outbuf_dec
= NULL
;
2096 struct tcrypt_result result
;
2097 unsigned int out_len_max
, out_len
= 0;
2099 struct scatterlist src
, dst
, src_tab
[2];
2101 if (testmgr_alloc_buf(xbuf
))
2104 req
= akcipher_request_alloc(tfm
, GFP_KERNEL
);
2108 init_completion(&result
.completion
);
2110 if (vecs
->public_key_vec
)
2111 err
= crypto_akcipher_set_pub_key(tfm
, vecs
->key
,
2114 err
= crypto_akcipher_set_priv_key(tfm
, vecs
->key
,
2120 out_len_max
= crypto_akcipher_maxsize(tfm
);
2121 outbuf_enc
= kzalloc(out_len_max
, GFP_KERNEL
);
2125 if (WARN_ON(vecs
->m_size
> PAGE_SIZE
))
2128 memcpy(xbuf
[0], vecs
->m
, vecs
->m_size
);
2130 sg_init_table(src_tab
, 2);
2131 sg_set_buf(&src_tab
[0], xbuf
[0], 8);
2132 sg_set_buf(&src_tab
[1], xbuf
[0] + 8, vecs
->m_size
- 8);
2133 sg_init_one(&dst
, outbuf_enc
, out_len_max
);
2134 akcipher_request_set_crypt(req
, src_tab
, &dst
, vecs
->m_size
,
2136 akcipher_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
2137 tcrypt_complete
, &result
);
2139 /* Run RSA encrypt - c = m^e mod n;*/
2140 err
= wait_async_op(&result
, crypto_akcipher_encrypt(req
));
2142 pr_err("alg: akcipher: encrypt test failed. err %d\n", err
);
2145 if (req
->dst_len
!= vecs
->c_size
) {
2146 pr_err("alg: akcipher: encrypt test failed. Invalid output len\n");
2150 /* verify that encrypted message is equal to expected */
2151 if (memcmp(vecs
->c
, outbuf_enc
, vecs
->c_size
)) {
2152 pr_err("alg: akcipher: encrypt test failed. Invalid output\n");
2153 hexdump(outbuf_enc
, vecs
->c_size
);
2157 /* Don't invoke decrypt for vectors with public key */
2158 if (vecs
->public_key_vec
) {
2162 outbuf_dec
= kzalloc(out_len_max
, GFP_KERNEL
);
2168 if (WARN_ON(vecs
->c_size
> PAGE_SIZE
))
2171 memcpy(xbuf
[0], vecs
->c
, vecs
->c_size
);
2173 sg_init_one(&src
, xbuf
[0], vecs
->c_size
);
2174 sg_init_one(&dst
, outbuf_dec
, out_len_max
);
2175 init_completion(&result
.completion
);
2176 akcipher_request_set_crypt(req
, &src
, &dst
, vecs
->c_size
, out_len_max
);
2178 /* Run RSA decrypt - m = c^d mod n;*/
2179 err
= wait_async_op(&result
, crypto_akcipher_decrypt(req
));
2181 pr_err("alg: akcipher: decrypt test failed. err %d\n", err
);
2184 out_len
= req
->dst_len
;
2185 if (out_len
< vecs
->m_size
) {
2186 pr_err("alg: akcipher: decrypt test failed. "
2187 "Invalid output len %u\n", out_len
);
2191 /* verify that decrypted message is equal to the original msg */
2192 if (memchr_inv(outbuf_dec
, 0, out_len
- vecs
->m_size
) ||
2193 memcmp(vecs
->m
, outbuf_dec
+ out_len
- vecs
->m_size
,
2195 pr_err("alg: akcipher: decrypt test failed. Invalid output\n");
2196 hexdump(outbuf_dec
, out_len
);
2203 akcipher_request_free(req
);
2205 testmgr_free_buf(xbuf
);
2209 static int test_akcipher(struct crypto_akcipher
*tfm
, const char *alg
,
2210 struct akcipher_testvec
*vecs
, unsigned int tcount
)
2213 crypto_tfm_alg_driver_name(crypto_akcipher_tfm(tfm
));
2216 for (i
= 0; i
< tcount
; i
++) {
2217 ret
= test_akcipher_one(tfm
, vecs
++);
2221 pr_err("alg: akcipher: test %d failed for %s, err=%d\n",
2228 static int alg_test_akcipher(const struct alg_test_desc
*desc
,
2229 const char *driver
, u32 type
, u32 mask
)
2231 struct crypto_akcipher
*tfm
;
2234 tfm
= crypto_alloc_akcipher(driver
, type
, mask
);
2236 pr_err("alg: akcipher: Failed to load tfm for %s: %ld\n",
2237 driver
, PTR_ERR(tfm
));
2238 return PTR_ERR(tfm
);
2240 if (desc
->suite
.akcipher
.vecs
)
2241 err
= test_akcipher(tfm
, desc
->alg
, desc
->suite
.akcipher
.vecs
,
2242 desc
->suite
.akcipher
.count
);
2244 crypto_free_akcipher(tfm
);
2248 static int alg_test_null(const struct alg_test_desc
*desc
,
2249 const char *driver
, u32 type
, u32 mask
)
2254 /* Please keep this list sorted by algorithm name. */
2255 static const struct alg_test_desc alg_test_descs
[] = {
2257 .alg
= "ansi_cprng",
2258 .test
= alg_test_cprng
,
2261 .vecs
= ansi_cprng_aes_tv_template
,
2262 .count
= ANSI_CPRNG_AES_TEST_VECTORS
2266 .alg
= "authenc(hmac(md5),ecb(cipher_null))",
2267 .test
= alg_test_aead
,
2271 .vecs
= hmac_md5_ecb_cipher_null_enc_tv_template
,
2272 .count
= HMAC_MD5_ECB_CIPHER_NULL_ENC_TEST_VECTORS
2275 .vecs
= hmac_md5_ecb_cipher_null_dec_tv_template
,
2276 .count
= HMAC_MD5_ECB_CIPHER_NULL_DEC_TEST_VECTORS
2281 .alg
= "authenc(hmac(sha1),cbc(aes))",
2282 .test
= alg_test_aead
,
2287 hmac_sha1_aes_cbc_enc_tv_temp
,
2289 HMAC_SHA1_AES_CBC_ENC_TEST_VEC
2294 .alg
= "authenc(hmac(sha1),cbc(des))",
2295 .test
= alg_test_aead
,
2300 hmac_sha1_des_cbc_enc_tv_temp
,
2302 HMAC_SHA1_DES_CBC_ENC_TEST_VEC
2307 .alg
= "authenc(hmac(sha1),cbc(des3_ede))",
2308 .test
= alg_test_aead
,
2314 hmac_sha1_des3_ede_cbc_enc_tv_temp
,
2316 HMAC_SHA1_DES3_EDE_CBC_ENC_TEST_VEC
2321 .alg
= "authenc(hmac(sha1),ctr(aes))",
2322 .test
= alg_test_null
,
2325 .alg
= "authenc(hmac(sha1),ecb(cipher_null))",
2326 .test
= alg_test_aead
,
2331 hmac_sha1_ecb_cipher_null_enc_tv_temp
,
2333 HMAC_SHA1_ECB_CIPHER_NULL_ENC_TEST_VEC
2337 hmac_sha1_ecb_cipher_null_dec_tv_temp
,
2339 HMAC_SHA1_ECB_CIPHER_NULL_DEC_TEST_VEC
2344 .alg
= "authenc(hmac(sha1),rfc3686(ctr(aes)))",
2345 .test
= alg_test_null
,
2348 .alg
= "authenc(hmac(sha224),cbc(des))",
2349 .test
= alg_test_aead
,
2354 hmac_sha224_des_cbc_enc_tv_temp
,
2356 HMAC_SHA224_DES_CBC_ENC_TEST_VEC
2361 .alg
= "authenc(hmac(sha224),cbc(des3_ede))",
2362 .test
= alg_test_aead
,
2368 hmac_sha224_des3_ede_cbc_enc_tv_temp
,
2370 HMAC_SHA224_DES3_EDE_CBC_ENC_TEST_VEC
2375 .alg
= "authenc(hmac(sha256),cbc(aes))",
2376 .test
= alg_test_aead
,
2382 hmac_sha256_aes_cbc_enc_tv_temp
,
2384 HMAC_SHA256_AES_CBC_ENC_TEST_VEC
2389 .alg
= "authenc(hmac(sha256),cbc(des))",
2390 .test
= alg_test_aead
,
2395 hmac_sha256_des_cbc_enc_tv_temp
,
2397 HMAC_SHA256_DES_CBC_ENC_TEST_VEC
2402 .alg
= "authenc(hmac(sha256),cbc(des3_ede))",
2403 .test
= alg_test_aead
,
2409 hmac_sha256_des3_ede_cbc_enc_tv_temp
,
2411 HMAC_SHA256_DES3_EDE_CBC_ENC_TEST_VEC
2416 .alg
= "authenc(hmac(sha256),ctr(aes))",
2417 .test
= alg_test_null
,
2420 .alg
= "authenc(hmac(sha256),rfc3686(ctr(aes)))",
2421 .test
= alg_test_null
,
2424 .alg
= "authenc(hmac(sha384),cbc(des))",
2425 .test
= alg_test_aead
,
2430 hmac_sha384_des_cbc_enc_tv_temp
,
2432 HMAC_SHA384_DES_CBC_ENC_TEST_VEC
2437 .alg
= "authenc(hmac(sha384),cbc(des3_ede))",
2438 .test
= alg_test_aead
,
2444 hmac_sha384_des3_ede_cbc_enc_tv_temp
,
2446 HMAC_SHA384_DES3_EDE_CBC_ENC_TEST_VEC
2451 .alg
= "authenc(hmac(sha384),ctr(aes))",
2452 .test
= alg_test_null
,
2455 .alg
= "authenc(hmac(sha384),rfc3686(ctr(aes)))",
2456 .test
= alg_test_null
,
2459 .alg
= "authenc(hmac(sha512),cbc(aes))",
2461 .test
= alg_test_aead
,
2466 hmac_sha512_aes_cbc_enc_tv_temp
,
2468 HMAC_SHA512_AES_CBC_ENC_TEST_VEC
2473 .alg
= "authenc(hmac(sha512),cbc(des))",
2474 .test
= alg_test_aead
,
2479 hmac_sha512_des_cbc_enc_tv_temp
,
2481 HMAC_SHA512_DES_CBC_ENC_TEST_VEC
2486 .alg
= "authenc(hmac(sha512),cbc(des3_ede))",
2487 .test
= alg_test_aead
,
2493 hmac_sha512_des3_ede_cbc_enc_tv_temp
,
2495 HMAC_SHA512_DES3_EDE_CBC_ENC_TEST_VEC
2500 .alg
= "authenc(hmac(sha512),ctr(aes))",
2501 .test
= alg_test_null
,
2504 .alg
= "authenc(hmac(sha512),rfc3686(ctr(aes)))",
2505 .test
= alg_test_null
,
2509 .test
= alg_test_skcipher
,
2514 .vecs
= aes_cbc_enc_tv_template
,
2515 .count
= AES_CBC_ENC_TEST_VECTORS
2518 .vecs
= aes_cbc_dec_tv_template
,
2519 .count
= AES_CBC_DEC_TEST_VECTORS
2524 .alg
= "cbc(anubis)",
2525 .test
= alg_test_skcipher
,
2529 .vecs
= anubis_cbc_enc_tv_template
,
2530 .count
= ANUBIS_CBC_ENC_TEST_VECTORS
2533 .vecs
= anubis_cbc_dec_tv_template
,
2534 .count
= ANUBIS_CBC_DEC_TEST_VECTORS
2539 .alg
= "cbc(blowfish)",
2540 .test
= alg_test_skcipher
,
2544 .vecs
= bf_cbc_enc_tv_template
,
2545 .count
= BF_CBC_ENC_TEST_VECTORS
2548 .vecs
= bf_cbc_dec_tv_template
,
2549 .count
= BF_CBC_DEC_TEST_VECTORS
2554 .alg
= "cbc(camellia)",
2555 .test
= alg_test_skcipher
,
2559 .vecs
= camellia_cbc_enc_tv_template
,
2560 .count
= CAMELLIA_CBC_ENC_TEST_VECTORS
2563 .vecs
= camellia_cbc_dec_tv_template
,
2564 .count
= CAMELLIA_CBC_DEC_TEST_VECTORS
2569 .alg
= "cbc(cast5)",
2570 .test
= alg_test_skcipher
,
2574 .vecs
= cast5_cbc_enc_tv_template
,
2575 .count
= CAST5_CBC_ENC_TEST_VECTORS
2578 .vecs
= cast5_cbc_dec_tv_template
,
2579 .count
= CAST5_CBC_DEC_TEST_VECTORS
2584 .alg
= "cbc(cast6)",
2585 .test
= alg_test_skcipher
,
2589 .vecs
= cast6_cbc_enc_tv_template
,
2590 .count
= CAST6_CBC_ENC_TEST_VECTORS
2593 .vecs
= cast6_cbc_dec_tv_template
,
2594 .count
= CAST6_CBC_DEC_TEST_VECTORS
2600 .test
= alg_test_skcipher
,
2604 .vecs
= des_cbc_enc_tv_template
,
2605 .count
= DES_CBC_ENC_TEST_VECTORS
2608 .vecs
= des_cbc_dec_tv_template
,
2609 .count
= DES_CBC_DEC_TEST_VECTORS
2614 .alg
= "cbc(des3_ede)",
2615 .test
= alg_test_skcipher
,
2620 .vecs
= des3_ede_cbc_enc_tv_template
,
2621 .count
= DES3_EDE_CBC_ENC_TEST_VECTORS
2624 .vecs
= des3_ede_cbc_dec_tv_template
,
2625 .count
= DES3_EDE_CBC_DEC_TEST_VECTORS
2630 .alg
= "cbc(serpent)",
2631 .test
= alg_test_skcipher
,
2635 .vecs
= serpent_cbc_enc_tv_template
,
2636 .count
= SERPENT_CBC_ENC_TEST_VECTORS
2639 .vecs
= serpent_cbc_dec_tv_template
,
2640 .count
= SERPENT_CBC_DEC_TEST_VECTORS
2645 .alg
= "cbc(twofish)",
2646 .test
= alg_test_skcipher
,
2650 .vecs
= tf_cbc_enc_tv_template
,
2651 .count
= TF_CBC_ENC_TEST_VECTORS
2654 .vecs
= tf_cbc_dec_tv_template
,
2655 .count
= TF_CBC_DEC_TEST_VECTORS
2661 .test
= alg_test_aead
,
2666 .vecs
= aes_ccm_enc_tv_template
,
2667 .count
= AES_CCM_ENC_TEST_VECTORS
2670 .vecs
= aes_ccm_dec_tv_template
,
2671 .count
= AES_CCM_DEC_TEST_VECTORS
2677 .test
= alg_test_skcipher
,
2681 .vecs
= chacha20_enc_tv_template
,
2682 .count
= CHACHA20_ENC_TEST_VECTORS
2685 .vecs
= chacha20_enc_tv_template
,
2686 .count
= CHACHA20_ENC_TEST_VECTORS
2693 .test
= alg_test_hash
,
2696 .vecs
= aes_cmac128_tv_template
,
2697 .count
= CMAC_AES_TEST_VECTORS
2701 .alg
= "cmac(des3_ede)",
2703 .test
= alg_test_hash
,
2706 .vecs
= des3_ede_cmac64_tv_template
,
2707 .count
= CMAC_DES3_EDE_TEST_VECTORS
2711 .alg
= "compress_null",
2712 .test
= alg_test_null
,
2715 .test
= alg_test_hash
,
2718 .vecs
= crc32_tv_template
,
2719 .count
= CRC32_TEST_VECTORS
2724 .test
= alg_test_crc32c
,
2728 .vecs
= crc32c_tv_template
,
2729 .count
= CRC32C_TEST_VECTORS
2734 .test
= alg_test_hash
,
2738 .vecs
= crct10dif_tv_template
,
2739 .count
= CRCT10DIF_TEST_VECTORS
2744 .test
= alg_test_skcipher
,
2749 .vecs
= aes_ctr_enc_tv_template
,
2750 .count
= AES_CTR_ENC_TEST_VECTORS
2753 .vecs
= aes_ctr_dec_tv_template
,
2754 .count
= AES_CTR_DEC_TEST_VECTORS
2759 .alg
= "ctr(blowfish)",
2760 .test
= alg_test_skcipher
,
2764 .vecs
= bf_ctr_enc_tv_template
,
2765 .count
= BF_CTR_ENC_TEST_VECTORS
2768 .vecs
= bf_ctr_dec_tv_template
,
2769 .count
= BF_CTR_DEC_TEST_VECTORS
2774 .alg
= "ctr(camellia)",
2775 .test
= alg_test_skcipher
,
2779 .vecs
= camellia_ctr_enc_tv_template
,
2780 .count
= CAMELLIA_CTR_ENC_TEST_VECTORS
2783 .vecs
= camellia_ctr_dec_tv_template
,
2784 .count
= CAMELLIA_CTR_DEC_TEST_VECTORS
2789 .alg
= "ctr(cast5)",
2790 .test
= alg_test_skcipher
,
2794 .vecs
= cast5_ctr_enc_tv_template
,
2795 .count
= CAST5_CTR_ENC_TEST_VECTORS
2798 .vecs
= cast5_ctr_dec_tv_template
,
2799 .count
= CAST5_CTR_DEC_TEST_VECTORS
2804 .alg
= "ctr(cast6)",
2805 .test
= alg_test_skcipher
,
2809 .vecs
= cast6_ctr_enc_tv_template
,
2810 .count
= CAST6_CTR_ENC_TEST_VECTORS
2813 .vecs
= cast6_ctr_dec_tv_template
,
2814 .count
= CAST6_CTR_DEC_TEST_VECTORS
2820 .test
= alg_test_skcipher
,
2824 .vecs
= des_ctr_enc_tv_template
,
2825 .count
= DES_CTR_ENC_TEST_VECTORS
2828 .vecs
= des_ctr_dec_tv_template
,
2829 .count
= DES_CTR_DEC_TEST_VECTORS
2834 .alg
= "ctr(des3_ede)",
2835 .test
= alg_test_skcipher
,
2839 .vecs
= des3_ede_ctr_enc_tv_template
,
2840 .count
= DES3_EDE_CTR_ENC_TEST_VECTORS
2843 .vecs
= des3_ede_ctr_dec_tv_template
,
2844 .count
= DES3_EDE_CTR_DEC_TEST_VECTORS
2849 .alg
= "ctr(serpent)",
2850 .test
= alg_test_skcipher
,
2854 .vecs
= serpent_ctr_enc_tv_template
,
2855 .count
= SERPENT_CTR_ENC_TEST_VECTORS
2858 .vecs
= serpent_ctr_dec_tv_template
,
2859 .count
= SERPENT_CTR_DEC_TEST_VECTORS
2864 .alg
= "ctr(twofish)",
2865 .test
= alg_test_skcipher
,
2869 .vecs
= tf_ctr_enc_tv_template
,
2870 .count
= TF_CTR_ENC_TEST_VECTORS
2873 .vecs
= tf_ctr_dec_tv_template
,
2874 .count
= TF_CTR_DEC_TEST_VECTORS
2879 .alg
= "cts(cbc(aes))",
2880 .test
= alg_test_skcipher
,
2884 .vecs
= cts_mode_enc_tv_template
,
2885 .count
= CTS_MODE_ENC_TEST_VECTORS
2888 .vecs
= cts_mode_dec_tv_template
,
2889 .count
= CTS_MODE_DEC_TEST_VECTORS
2895 .test
= alg_test_comp
,
2900 .vecs
= deflate_comp_tv_template
,
2901 .count
= DEFLATE_COMP_TEST_VECTORS
2904 .vecs
= deflate_decomp_tv_template
,
2905 .count
= DEFLATE_DECOMP_TEST_VECTORS
2911 .test
= alg_test_kpp
,
2915 .vecs
= dh_tv_template
,
2916 .count
= DH_TEST_VECTORS
2920 .alg
= "digest_null",
2921 .test
= alg_test_null
,
2923 .alg
= "drbg_nopr_ctr_aes128",
2924 .test
= alg_test_drbg
,
2928 .vecs
= drbg_nopr_ctr_aes128_tv_template
,
2929 .count
= ARRAY_SIZE(drbg_nopr_ctr_aes128_tv_template
)
2933 .alg
= "drbg_nopr_ctr_aes192",
2934 .test
= alg_test_drbg
,
2938 .vecs
= drbg_nopr_ctr_aes192_tv_template
,
2939 .count
= ARRAY_SIZE(drbg_nopr_ctr_aes192_tv_template
)
2943 .alg
= "drbg_nopr_ctr_aes256",
2944 .test
= alg_test_drbg
,
2948 .vecs
= drbg_nopr_ctr_aes256_tv_template
,
2949 .count
= ARRAY_SIZE(drbg_nopr_ctr_aes256_tv_template
)
2954 * There is no need to specifically test the DRBG with every
2955 * backend cipher -- covered by drbg_nopr_hmac_sha256 test
2957 .alg
= "drbg_nopr_hmac_sha1",
2959 .test
= alg_test_null
,
2961 .alg
= "drbg_nopr_hmac_sha256",
2962 .test
= alg_test_drbg
,
2966 .vecs
= drbg_nopr_hmac_sha256_tv_template
,
2968 ARRAY_SIZE(drbg_nopr_hmac_sha256_tv_template
)
2972 /* covered by drbg_nopr_hmac_sha256 test */
2973 .alg
= "drbg_nopr_hmac_sha384",
2975 .test
= alg_test_null
,
2977 .alg
= "drbg_nopr_hmac_sha512",
2978 .test
= alg_test_null
,
2981 .alg
= "drbg_nopr_sha1",
2983 .test
= alg_test_null
,
2985 .alg
= "drbg_nopr_sha256",
2986 .test
= alg_test_drbg
,
2990 .vecs
= drbg_nopr_sha256_tv_template
,
2991 .count
= ARRAY_SIZE(drbg_nopr_sha256_tv_template
)
2995 /* covered by drbg_nopr_sha256 test */
2996 .alg
= "drbg_nopr_sha384",
2998 .test
= alg_test_null
,
3000 .alg
= "drbg_nopr_sha512",
3002 .test
= alg_test_null
,
3004 .alg
= "drbg_pr_ctr_aes128",
3005 .test
= alg_test_drbg
,
3009 .vecs
= drbg_pr_ctr_aes128_tv_template
,
3010 .count
= ARRAY_SIZE(drbg_pr_ctr_aes128_tv_template
)
3014 /* covered by drbg_pr_ctr_aes128 test */
3015 .alg
= "drbg_pr_ctr_aes192",
3017 .test
= alg_test_null
,
3019 .alg
= "drbg_pr_ctr_aes256",
3021 .test
= alg_test_null
,
3023 .alg
= "drbg_pr_hmac_sha1",
3025 .test
= alg_test_null
,
3027 .alg
= "drbg_pr_hmac_sha256",
3028 .test
= alg_test_drbg
,
3032 .vecs
= drbg_pr_hmac_sha256_tv_template
,
3033 .count
= ARRAY_SIZE(drbg_pr_hmac_sha256_tv_template
)
3037 /* covered by drbg_pr_hmac_sha256 test */
3038 .alg
= "drbg_pr_hmac_sha384",
3040 .test
= alg_test_null
,
3042 .alg
= "drbg_pr_hmac_sha512",
3043 .test
= alg_test_null
,
3046 .alg
= "drbg_pr_sha1",
3048 .test
= alg_test_null
,
3050 .alg
= "drbg_pr_sha256",
3051 .test
= alg_test_drbg
,
3055 .vecs
= drbg_pr_sha256_tv_template
,
3056 .count
= ARRAY_SIZE(drbg_pr_sha256_tv_template
)
3060 /* covered by drbg_pr_sha256 test */
3061 .alg
= "drbg_pr_sha384",
3063 .test
= alg_test_null
,
3065 .alg
= "drbg_pr_sha512",
3067 .test
= alg_test_null
,
3070 .test
= alg_test_skcipher
,
3075 .vecs
= aes_enc_tv_template
,
3076 .count
= AES_ENC_TEST_VECTORS
3079 .vecs
= aes_dec_tv_template
,
3080 .count
= AES_DEC_TEST_VECTORS
3085 .alg
= "ecb(anubis)",
3086 .test
= alg_test_skcipher
,
3090 .vecs
= anubis_enc_tv_template
,
3091 .count
= ANUBIS_ENC_TEST_VECTORS
3094 .vecs
= anubis_dec_tv_template
,
3095 .count
= ANUBIS_DEC_TEST_VECTORS
3101 .test
= alg_test_skcipher
,
3105 .vecs
= arc4_enc_tv_template
,
3106 .count
= ARC4_ENC_TEST_VECTORS
3109 .vecs
= arc4_dec_tv_template
,
3110 .count
= ARC4_DEC_TEST_VECTORS
3115 .alg
= "ecb(blowfish)",
3116 .test
= alg_test_skcipher
,
3120 .vecs
= bf_enc_tv_template
,
3121 .count
= BF_ENC_TEST_VECTORS
3124 .vecs
= bf_dec_tv_template
,
3125 .count
= BF_DEC_TEST_VECTORS
3130 .alg
= "ecb(camellia)",
3131 .test
= alg_test_skcipher
,
3135 .vecs
= camellia_enc_tv_template
,
3136 .count
= CAMELLIA_ENC_TEST_VECTORS
3139 .vecs
= camellia_dec_tv_template
,
3140 .count
= CAMELLIA_DEC_TEST_VECTORS
3145 .alg
= "ecb(cast5)",
3146 .test
= alg_test_skcipher
,
3150 .vecs
= cast5_enc_tv_template
,
3151 .count
= CAST5_ENC_TEST_VECTORS
3154 .vecs
= cast5_dec_tv_template
,
3155 .count
= CAST5_DEC_TEST_VECTORS
3160 .alg
= "ecb(cast6)",
3161 .test
= alg_test_skcipher
,
3165 .vecs
= cast6_enc_tv_template
,
3166 .count
= CAST6_ENC_TEST_VECTORS
3169 .vecs
= cast6_dec_tv_template
,
3170 .count
= CAST6_DEC_TEST_VECTORS
3175 .alg
= "ecb(cipher_null)",
3176 .test
= alg_test_null
,
3179 .test
= alg_test_skcipher
,
3183 .vecs
= des_enc_tv_template
,
3184 .count
= DES_ENC_TEST_VECTORS
3187 .vecs
= des_dec_tv_template
,
3188 .count
= DES_DEC_TEST_VECTORS
3193 .alg
= "ecb(des3_ede)",
3194 .test
= alg_test_skcipher
,
3199 .vecs
= des3_ede_enc_tv_template
,
3200 .count
= DES3_EDE_ENC_TEST_VECTORS
3203 .vecs
= des3_ede_dec_tv_template
,
3204 .count
= DES3_EDE_DEC_TEST_VECTORS
3209 .alg
= "ecb(fcrypt)",
3210 .test
= alg_test_skcipher
,
3214 .vecs
= fcrypt_pcbc_enc_tv_template
,
3218 .vecs
= fcrypt_pcbc_dec_tv_template
,
3224 .alg
= "ecb(khazad)",
3225 .test
= alg_test_skcipher
,
3229 .vecs
= khazad_enc_tv_template
,
3230 .count
= KHAZAD_ENC_TEST_VECTORS
3233 .vecs
= khazad_dec_tv_template
,
3234 .count
= KHAZAD_DEC_TEST_VECTORS
3240 .test
= alg_test_skcipher
,
3244 .vecs
= seed_enc_tv_template
,
3245 .count
= SEED_ENC_TEST_VECTORS
3248 .vecs
= seed_dec_tv_template
,
3249 .count
= SEED_DEC_TEST_VECTORS
3254 .alg
= "ecb(serpent)",
3255 .test
= alg_test_skcipher
,
3259 .vecs
= serpent_enc_tv_template
,
3260 .count
= SERPENT_ENC_TEST_VECTORS
3263 .vecs
= serpent_dec_tv_template
,
3264 .count
= SERPENT_DEC_TEST_VECTORS
3270 .test
= alg_test_skcipher
,
3274 .vecs
= tea_enc_tv_template
,
3275 .count
= TEA_ENC_TEST_VECTORS
3278 .vecs
= tea_dec_tv_template
,
3279 .count
= TEA_DEC_TEST_VECTORS
3284 .alg
= "ecb(tnepres)",
3285 .test
= alg_test_skcipher
,
3289 .vecs
= tnepres_enc_tv_template
,
3290 .count
= TNEPRES_ENC_TEST_VECTORS
3293 .vecs
= tnepres_dec_tv_template
,
3294 .count
= TNEPRES_DEC_TEST_VECTORS
3299 .alg
= "ecb(twofish)",
3300 .test
= alg_test_skcipher
,
3304 .vecs
= tf_enc_tv_template
,
3305 .count
= TF_ENC_TEST_VECTORS
3308 .vecs
= tf_dec_tv_template
,
3309 .count
= TF_DEC_TEST_VECTORS
3315 .test
= alg_test_skcipher
,
3319 .vecs
= xeta_enc_tv_template
,
3320 .count
= XETA_ENC_TEST_VECTORS
3323 .vecs
= xeta_dec_tv_template
,
3324 .count
= XETA_DEC_TEST_VECTORS
3330 .test
= alg_test_skcipher
,
3334 .vecs
= xtea_enc_tv_template
,
3335 .count
= XTEA_ENC_TEST_VECTORS
3338 .vecs
= xtea_dec_tv_template
,
3339 .count
= XTEA_DEC_TEST_VECTORS
3345 .test
= alg_test_kpp
,
3349 .vecs
= ecdh_tv_template
,
3350 .count
= ECDH_TEST_VECTORS
3355 .test
= alg_test_aead
,
3360 .vecs
= aes_gcm_enc_tv_template
,
3361 .count
= AES_GCM_ENC_TEST_VECTORS
3364 .vecs
= aes_gcm_dec_tv_template
,
3365 .count
= AES_GCM_DEC_TEST_VECTORS
3371 .test
= alg_test_hash
,
3375 .vecs
= ghash_tv_template
,
3376 .count
= GHASH_TEST_VECTORS
3380 .alg
= "hmac(crc32)",
3381 .test
= alg_test_hash
,
3384 .vecs
= bfin_crc_tv_template
,
3385 .count
= BFIN_CRC_TEST_VECTORS
3390 .test
= alg_test_hash
,
3393 .vecs
= hmac_md5_tv_template
,
3394 .count
= HMAC_MD5_TEST_VECTORS
3398 .alg
= "hmac(rmd128)",
3399 .test
= alg_test_hash
,
3402 .vecs
= hmac_rmd128_tv_template
,
3403 .count
= HMAC_RMD128_TEST_VECTORS
3407 .alg
= "hmac(rmd160)",
3408 .test
= alg_test_hash
,
3411 .vecs
= hmac_rmd160_tv_template
,
3412 .count
= HMAC_RMD160_TEST_VECTORS
3416 .alg
= "hmac(sha1)",
3417 .test
= alg_test_hash
,
3421 .vecs
= hmac_sha1_tv_template
,
3422 .count
= HMAC_SHA1_TEST_VECTORS
3426 .alg
= "hmac(sha224)",
3427 .test
= alg_test_hash
,
3431 .vecs
= hmac_sha224_tv_template
,
3432 .count
= HMAC_SHA224_TEST_VECTORS
3436 .alg
= "hmac(sha256)",
3437 .test
= alg_test_hash
,
3441 .vecs
= hmac_sha256_tv_template
,
3442 .count
= HMAC_SHA256_TEST_VECTORS
3446 .alg
= "hmac(sha3-224)",
3447 .test
= alg_test_hash
,
3451 .vecs
= hmac_sha3_224_tv_template
,
3452 .count
= HMAC_SHA3_224_TEST_VECTORS
3456 .alg
= "hmac(sha3-256)",
3457 .test
= alg_test_hash
,
3461 .vecs
= hmac_sha3_256_tv_template
,
3462 .count
= HMAC_SHA3_256_TEST_VECTORS
3466 .alg
= "hmac(sha3-384)",
3467 .test
= alg_test_hash
,
3471 .vecs
= hmac_sha3_384_tv_template
,
3472 .count
= HMAC_SHA3_384_TEST_VECTORS
3476 .alg
= "hmac(sha3-512)",
3477 .test
= alg_test_hash
,
3481 .vecs
= hmac_sha3_512_tv_template
,
3482 .count
= HMAC_SHA3_512_TEST_VECTORS
3486 .alg
= "hmac(sha384)",
3487 .test
= alg_test_hash
,
3491 .vecs
= hmac_sha384_tv_template
,
3492 .count
= HMAC_SHA384_TEST_VECTORS
3496 .alg
= "hmac(sha512)",
3497 .test
= alg_test_hash
,
3501 .vecs
= hmac_sha512_tv_template
,
3502 .count
= HMAC_SHA512_TEST_VECTORS
3506 .alg
= "jitterentropy_rng",
3508 .test
= alg_test_null
,
3511 .test
= alg_test_skcipher
,
3516 .vecs
= aes_kw_enc_tv_template
,
3517 .count
= ARRAY_SIZE(aes_kw_enc_tv_template
)
3520 .vecs
= aes_kw_dec_tv_template
,
3521 .count
= ARRAY_SIZE(aes_kw_dec_tv_template
)
3527 .test
= alg_test_skcipher
,
3531 .vecs
= aes_lrw_enc_tv_template
,
3532 .count
= AES_LRW_ENC_TEST_VECTORS
3535 .vecs
= aes_lrw_dec_tv_template
,
3536 .count
= AES_LRW_DEC_TEST_VECTORS
3541 .alg
= "lrw(camellia)",
3542 .test
= alg_test_skcipher
,
3546 .vecs
= camellia_lrw_enc_tv_template
,
3547 .count
= CAMELLIA_LRW_ENC_TEST_VECTORS
3550 .vecs
= camellia_lrw_dec_tv_template
,
3551 .count
= CAMELLIA_LRW_DEC_TEST_VECTORS
3556 .alg
= "lrw(cast6)",
3557 .test
= alg_test_skcipher
,
3561 .vecs
= cast6_lrw_enc_tv_template
,
3562 .count
= CAST6_LRW_ENC_TEST_VECTORS
3565 .vecs
= cast6_lrw_dec_tv_template
,
3566 .count
= CAST6_LRW_DEC_TEST_VECTORS
3571 .alg
= "lrw(serpent)",
3572 .test
= alg_test_skcipher
,
3576 .vecs
= serpent_lrw_enc_tv_template
,
3577 .count
= SERPENT_LRW_ENC_TEST_VECTORS
3580 .vecs
= serpent_lrw_dec_tv_template
,
3581 .count
= SERPENT_LRW_DEC_TEST_VECTORS
3586 .alg
= "lrw(twofish)",
3587 .test
= alg_test_skcipher
,
3591 .vecs
= tf_lrw_enc_tv_template
,
3592 .count
= TF_LRW_ENC_TEST_VECTORS
3595 .vecs
= tf_lrw_dec_tv_template
,
3596 .count
= TF_LRW_DEC_TEST_VECTORS
3602 .test
= alg_test_comp
,
3607 .vecs
= lz4_comp_tv_template
,
3608 .count
= LZ4_COMP_TEST_VECTORS
3611 .vecs
= lz4_decomp_tv_template
,
3612 .count
= LZ4_DECOMP_TEST_VECTORS
3618 .test
= alg_test_comp
,
3623 .vecs
= lz4hc_comp_tv_template
,
3624 .count
= LZ4HC_COMP_TEST_VECTORS
3627 .vecs
= lz4hc_decomp_tv_template
,
3628 .count
= LZ4HC_DECOMP_TEST_VECTORS
3634 .test
= alg_test_comp
,
3639 .vecs
= lzo_comp_tv_template
,
3640 .count
= LZO_COMP_TEST_VECTORS
3643 .vecs
= lzo_decomp_tv_template
,
3644 .count
= LZO_DECOMP_TEST_VECTORS
3650 .test
= alg_test_hash
,
3653 .vecs
= md4_tv_template
,
3654 .count
= MD4_TEST_VECTORS
3659 .test
= alg_test_hash
,
3662 .vecs
= md5_tv_template
,
3663 .count
= MD5_TEST_VECTORS
3667 .alg
= "michael_mic",
3668 .test
= alg_test_hash
,
3671 .vecs
= michael_mic_tv_template
,
3672 .count
= MICHAEL_MIC_TEST_VECTORS
3677 .test
= alg_test_skcipher
,
3682 .vecs
= aes_ofb_enc_tv_template
,
3683 .count
= AES_OFB_ENC_TEST_VECTORS
3686 .vecs
= aes_ofb_dec_tv_template
,
3687 .count
= AES_OFB_DEC_TEST_VECTORS
3692 .alg
= "pcbc(fcrypt)",
3693 .test
= alg_test_skcipher
,
3697 .vecs
= fcrypt_pcbc_enc_tv_template
,
3698 .count
= FCRYPT_ENC_TEST_VECTORS
3701 .vecs
= fcrypt_pcbc_dec_tv_template
,
3702 .count
= FCRYPT_DEC_TEST_VECTORS
3708 .test
= alg_test_hash
,
3711 .vecs
= poly1305_tv_template
,
3712 .count
= POLY1305_TEST_VECTORS
3716 .alg
= "rfc3686(ctr(aes))",
3717 .test
= alg_test_skcipher
,
3722 .vecs
= aes_ctr_rfc3686_enc_tv_template
,
3723 .count
= AES_CTR_3686_ENC_TEST_VECTORS
3726 .vecs
= aes_ctr_rfc3686_dec_tv_template
,
3727 .count
= AES_CTR_3686_DEC_TEST_VECTORS
3732 .alg
= "rfc4106(gcm(aes))",
3733 .test
= alg_test_aead
,
3738 .vecs
= aes_gcm_rfc4106_enc_tv_template
,
3739 .count
= AES_GCM_4106_ENC_TEST_VECTORS
3742 .vecs
= aes_gcm_rfc4106_dec_tv_template
,
3743 .count
= AES_GCM_4106_DEC_TEST_VECTORS
3748 .alg
= "rfc4309(ccm(aes))",
3749 .test
= alg_test_aead
,
3754 .vecs
= aes_ccm_rfc4309_enc_tv_template
,
3755 .count
= AES_CCM_4309_ENC_TEST_VECTORS
3758 .vecs
= aes_ccm_rfc4309_dec_tv_template
,
3759 .count
= AES_CCM_4309_DEC_TEST_VECTORS
3764 .alg
= "rfc4543(gcm(aes))",
3765 .test
= alg_test_aead
,
3769 .vecs
= aes_gcm_rfc4543_enc_tv_template
,
3770 .count
= AES_GCM_4543_ENC_TEST_VECTORS
3773 .vecs
= aes_gcm_rfc4543_dec_tv_template
,
3774 .count
= AES_GCM_4543_DEC_TEST_VECTORS
3779 .alg
= "rfc7539(chacha20,poly1305)",
3780 .test
= alg_test_aead
,
3784 .vecs
= rfc7539_enc_tv_template
,
3785 .count
= RFC7539_ENC_TEST_VECTORS
3788 .vecs
= rfc7539_dec_tv_template
,
3789 .count
= RFC7539_DEC_TEST_VECTORS
3794 .alg
= "rfc7539esp(chacha20,poly1305)",
3795 .test
= alg_test_aead
,
3799 .vecs
= rfc7539esp_enc_tv_template
,
3800 .count
= RFC7539ESP_ENC_TEST_VECTORS
3803 .vecs
= rfc7539esp_dec_tv_template
,
3804 .count
= RFC7539ESP_DEC_TEST_VECTORS
3810 .test
= alg_test_hash
,
3813 .vecs
= rmd128_tv_template
,
3814 .count
= RMD128_TEST_VECTORS
3819 .test
= alg_test_hash
,
3822 .vecs
= rmd160_tv_template
,
3823 .count
= RMD160_TEST_VECTORS
3828 .test
= alg_test_hash
,
3831 .vecs
= rmd256_tv_template
,
3832 .count
= RMD256_TEST_VECTORS
3837 .test
= alg_test_hash
,
3840 .vecs
= rmd320_tv_template
,
3841 .count
= RMD320_TEST_VECTORS
3846 .test
= alg_test_akcipher
,
3850 .vecs
= rsa_tv_template
,
3851 .count
= RSA_TEST_VECTORS
3856 .test
= alg_test_skcipher
,
3860 .vecs
= salsa20_stream_enc_tv_template
,
3861 .count
= SALSA20_STREAM_ENC_TEST_VECTORS
3867 .test
= alg_test_hash
,
3871 .vecs
= sha1_tv_template
,
3872 .count
= SHA1_TEST_VECTORS
3877 .test
= alg_test_hash
,
3881 .vecs
= sha224_tv_template
,
3882 .count
= SHA224_TEST_VECTORS
3887 .test
= alg_test_hash
,
3891 .vecs
= sha256_tv_template
,
3892 .count
= SHA256_TEST_VECTORS
3897 .test
= alg_test_hash
,
3901 .vecs
= sha3_224_tv_template
,
3902 .count
= SHA3_224_TEST_VECTORS
3907 .test
= alg_test_hash
,
3911 .vecs
= sha3_256_tv_template
,
3912 .count
= SHA3_256_TEST_VECTORS
3917 .test
= alg_test_hash
,
3921 .vecs
= sha3_384_tv_template
,
3922 .count
= SHA3_384_TEST_VECTORS
3927 .test
= alg_test_hash
,
3931 .vecs
= sha3_512_tv_template
,
3932 .count
= SHA3_512_TEST_VECTORS
3937 .test
= alg_test_hash
,
3941 .vecs
= sha384_tv_template
,
3942 .count
= SHA384_TEST_VECTORS
3947 .test
= alg_test_hash
,
3951 .vecs
= sha512_tv_template
,
3952 .count
= SHA512_TEST_VECTORS
3957 .test
= alg_test_hash
,
3960 .vecs
= tgr128_tv_template
,
3961 .count
= TGR128_TEST_VECTORS
3966 .test
= alg_test_hash
,
3969 .vecs
= tgr160_tv_template
,
3970 .count
= TGR160_TEST_VECTORS
3975 .test
= alg_test_hash
,
3978 .vecs
= tgr192_tv_template
,
3979 .count
= TGR192_TEST_VECTORS
3984 .test
= alg_test_hash
,
3987 .vecs
= aes_vmac128_tv_template
,
3988 .count
= VMAC_AES_TEST_VECTORS
3993 .test
= alg_test_hash
,
3996 .vecs
= wp256_tv_template
,
3997 .count
= WP256_TEST_VECTORS
4002 .test
= alg_test_hash
,
4005 .vecs
= wp384_tv_template
,
4006 .count
= WP384_TEST_VECTORS
4011 .test
= alg_test_hash
,
4014 .vecs
= wp512_tv_template
,
4015 .count
= WP512_TEST_VECTORS
4020 .test
= alg_test_hash
,
4023 .vecs
= aes_xcbc128_tv_template
,
4024 .count
= XCBC_AES_TEST_VECTORS
4029 .test
= alg_test_skcipher
,
4034 .vecs
= aes_xts_enc_tv_template
,
4035 .count
= AES_XTS_ENC_TEST_VECTORS
4038 .vecs
= aes_xts_dec_tv_template
,
4039 .count
= AES_XTS_DEC_TEST_VECTORS
4044 .alg
= "xts(camellia)",
4045 .test
= alg_test_skcipher
,
4049 .vecs
= camellia_xts_enc_tv_template
,
4050 .count
= CAMELLIA_XTS_ENC_TEST_VECTORS
4053 .vecs
= camellia_xts_dec_tv_template
,
4054 .count
= CAMELLIA_XTS_DEC_TEST_VECTORS
4059 .alg
= "xts(cast6)",
4060 .test
= alg_test_skcipher
,
4064 .vecs
= cast6_xts_enc_tv_template
,
4065 .count
= CAST6_XTS_ENC_TEST_VECTORS
4068 .vecs
= cast6_xts_dec_tv_template
,
4069 .count
= CAST6_XTS_DEC_TEST_VECTORS
4074 .alg
= "xts(serpent)",
4075 .test
= alg_test_skcipher
,
4079 .vecs
= serpent_xts_enc_tv_template
,
4080 .count
= SERPENT_XTS_ENC_TEST_VECTORS
4083 .vecs
= serpent_xts_dec_tv_template
,
4084 .count
= SERPENT_XTS_DEC_TEST_VECTORS
4089 .alg
= "xts(twofish)",
4090 .test
= alg_test_skcipher
,
4094 .vecs
= tf_xts_enc_tv_template
,
4095 .count
= TF_XTS_ENC_TEST_VECTORS
4098 .vecs
= tf_xts_dec_tv_template
,
4099 .count
= TF_XTS_DEC_TEST_VECTORS
4106 static bool alg_test_descs_checked
;
4108 static void alg_test_descs_check_order(void)
4112 /* only check once */
4113 if (alg_test_descs_checked
)
4116 alg_test_descs_checked
= true;
4118 for (i
= 1; i
< ARRAY_SIZE(alg_test_descs
); i
++) {
4119 int diff
= strcmp(alg_test_descs
[i
- 1].alg
,
4120 alg_test_descs
[i
].alg
);
4122 if (WARN_ON(diff
> 0)) {
4123 pr_warn("testmgr: alg_test_descs entries in wrong order: '%s' before '%s'\n",
4124 alg_test_descs
[i
- 1].alg
,
4125 alg_test_descs
[i
].alg
);
4128 if (WARN_ON(diff
== 0)) {
4129 pr_warn("testmgr: duplicate alg_test_descs entry: '%s'\n",
4130 alg_test_descs
[i
].alg
);
4135 static int alg_find_test(const char *alg
)
4138 int end
= ARRAY_SIZE(alg_test_descs
);
4140 while (start
< end
) {
4141 int i
= (start
+ end
) / 2;
4142 int diff
= strcmp(alg_test_descs
[i
].alg
, alg
);
4160 int alg_test(const char *driver
, const char *alg
, u32 type
, u32 mask
)
4166 if (!fips_enabled
&& notests
) {
4167 printk_once(KERN_INFO
"alg: self-tests disabled\n");
4171 alg_test_descs_check_order();
4173 if ((type
& CRYPTO_ALG_TYPE_MASK
) == CRYPTO_ALG_TYPE_CIPHER
) {
4174 char nalg
[CRYPTO_MAX_ALG_NAME
];
4176 if (snprintf(nalg
, sizeof(nalg
), "ecb(%s)", alg
) >=
4178 return -ENAMETOOLONG
;
4180 i
= alg_find_test(nalg
);
4184 if (fips_enabled
&& !alg_test_descs
[i
].fips_allowed
)
4187 rc
= alg_test_cipher(alg_test_descs
+ i
, driver
, type
, mask
);
4191 i
= alg_find_test(alg
);
4192 j
= alg_find_test(driver
);
4196 if (fips_enabled
&& ((i
>= 0 && !alg_test_descs
[i
].fips_allowed
) ||
4197 (j
>= 0 && !alg_test_descs
[j
].fips_allowed
)))
4202 rc
|= alg_test_descs
[i
].test(alg_test_descs
+ i
, driver
,
4204 if (j
>= 0 && j
!= i
)
4205 rc
|= alg_test_descs
[j
].test(alg_test_descs
+ j
, driver
,
4209 if (fips_enabled
&& rc
)
4210 panic("%s: %s alg self test failed in fips mode!\n", driver
, alg
);
4212 if (fips_enabled
&& !rc
)
4213 pr_info("alg: self-tests for %s (%s) passed\n", driver
, alg
);
4218 printk(KERN_INFO
"alg: No test for %s (%s)\n", alg
, driver
);
4224 #endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */
4226 EXPORT_SYMBOL_GPL(alg_test
);