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>
40 module_param(notests
, bool, 0644);
41 MODULE_PARM_DESC(notests
, "disable crypto self-tests");
43 #ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
46 int alg_test(const char *driver
, const char *alg
, u32 type
, u32 mask
)
56 * Need slab memory for testing (size in number of pages).
61 * Indexes into the xbuf to simulate cross-page access.
73 * Used by test_cipher()
78 struct tcrypt_result
{
79 struct completion completion
;
83 struct aead_test_suite
{
85 struct aead_testvec
*vecs
;
90 struct cipher_test_suite
{
92 struct cipher_testvec
*vecs
;
97 struct comp_test_suite
{
99 struct comp_testvec
*vecs
;
104 struct hash_test_suite
{
105 struct hash_testvec
*vecs
;
109 struct cprng_test_suite
{
110 struct cprng_testvec
*vecs
;
114 struct drbg_test_suite
{
115 struct drbg_testvec
*vecs
;
119 struct akcipher_test_suite
{
120 struct akcipher_testvec
*vecs
;
124 struct kpp_test_suite
{
125 struct kpp_testvec
*vecs
;
129 struct alg_test_desc
{
131 int (*test
)(const struct alg_test_desc
*desc
, const char *driver
,
133 int fips_allowed
; /* set if alg is allowed in fips mode */
136 struct aead_test_suite aead
;
137 struct cipher_test_suite cipher
;
138 struct comp_test_suite comp
;
139 struct hash_test_suite hash
;
140 struct cprng_test_suite cprng
;
141 struct drbg_test_suite drbg
;
142 struct akcipher_test_suite akcipher
;
143 struct kpp_test_suite kpp
;
147 static unsigned int IDX
[8] = { IDX1
, IDX2
, IDX3
, IDX4
, IDX5
, IDX6
, IDX7
, IDX8
};
149 static void hexdump(unsigned char *buf
, unsigned int len
)
151 print_hex_dump(KERN_CONT
, "", DUMP_PREFIX_OFFSET
,
156 static void tcrypt_complete(struct crypto_async_request
*req
, int err
)
158 struct tcrypt_result
*res
= req
->data
;
160 if (err
== -EINPROGRESS
)
164 complete(&res
->completion
);
167 static int testmgr_alloc_buf(char *buf
[XBUFSIZE
])
171 for (i
= 0; i
< XBUFSIZE
; i
++) {
172 buf
[i
] = (void *)__get_free_page(GFP_KERNEL
);
181 free_page((unsigned long)buf
[i
]);
186 static void testmgr_free_buf(char *buf
[XBUFSIZE
])
190 for (i
= 0; i
< XBUFSIZE
; i
++)
191 free_page((unsigned long)buf
[i
]);
194 static int wait_async_op(struct tcrypt_result
*tr
, int ret
)
196 if (ret
== -EINPROGRESS
|| ret
== -EBUSY
) {
197 wait_for_completion(&tr
->completion
);
198 reinit_completion(&tr
->completion
);
204 static int ahash_partial_update(struct ahash_request
**preq
,
205 struct crypto_ahash
*tfm
, struct hash_testvec
*template,
206 void *hash_buff
, int k
, int temp
, struct scatterlist
*sg
,
207 const char *algo
, char *result
, struct tcrypt_result
*tresult
)
210 struct ahash_request
*req
;
211 int statesize
, ret
= -EINVAL
;
214 statesize
= crypto_ahash_statesize(
215 crypto_ahash_reqtfm(req
));
216 state
= kmalloc(statesize
, GFP_KERNEL
);
218 pr_err("alt: hash: Failed to alloc state for %s\n", algo
);
221 ret
= crypto_ahash_export(req
, state
);
223 pr_err("alt: hash: Failed to export() for %s\n", algo
);
226 ahash_request_free(req
);
227 req
= ahash_request_alloc(tfm
, GFP_KERNEL
);
229 pr_err("alg: hash: Failed to alloc request for %s\n", algo
);
232 ahash_request_set_callback(req
,
233 CRYPTO_TFM_REQ_MAY_BACKLOG
,
234 tcrypt_complete
, tresult
);
236 memcpy(hash_buff
, template->plaintext
+ temp
,
238 sg_init_one(&sg
[0], hash_buff
, template->tap
[k
]);
239 ahash_request_set_crypt(req
, sg
, result
, template->tap
[k
]);
240 ret
= crypto_ahash_import(req
, state
);
242 pr_err("alg: hash: Failed to import() for %s\n", algo
);
245 ret
= wait_async_op(tresult
, crypto_ahash_update(req
));
252 ahash_request_free(req
);
259 static int __test_hash(struct crypto_ahash
*tfm
, struct hash_testvec
*template,
260 unsigned int tcount
, bool use_digest
,
261 const int align_offset
)
263 const char *algo
= crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm
));
264 unsigned int i
, j
, k
, temp
;
265 struct scatterlist sg
[8];
268 struct ahash_request
*req
;
269 struct tcrypt_result tresult
;
271 char *xbuf
[XBUFSIZE
];
274 result
= kmalloc(MAX_DIGEST_SIZE
, GFP_KERNEL
);
277 key
= kmalloc(MAX_KEYLEN
, GFP_KERNEL
);
280 if (testmgr_alloc_buf(xbuf
))
283 init_completion(&tresult
.completion
);
285 req
= ahash_request_alloc(tfm
, GFP_KERNEL
);
287 printk(KERN_ERR
"alg: hash: Failed to allocate request for "
291 ahash_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
292 tcrypt_complete
, &tresult
);
295 for (i
= 0; i
< tcount
; i
++) {
300 if (WARN_ON(align_offset
+ template[i
].psize
> PAGE_SIZE
))
304 memset(result
, 0, MAX_DIGEST_SIZE
);
307 hash_buff
+= align_offset
;
309 memcpy(hash_buff
, template[i
].plaintext
, template[i
].psize
);
310 sg_init_one(&sg
[0], hash_buff
, template[i
].psize
);
312 if (template[i
].ksize
) {
313 crypto_ahash_clear_flags(tfm
, ~0);
314 if (template[i
].ksize
> MAX_KEYLEN
) {
315 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
316 j
, algo
, template[i
].ksize
, MAX_KEYLEN
);
320 memcpy(key
, template[i
].key
, template[i
].ksize
);
321 ret
= crypto_ahash_setkey(tfm
, key
, template[i
].ksize
);
323 printk(KERN_ERR
"alg: hash: setkey failed on "
324 "test %d for %s: ret=%d\n", j
, algo
,
330 ahash_request_set_crypt(req
, sg
, result
, template[i
].psize
);
332 ret
= wait_async_op(&tresult
, crypto_ahash_digest(req
));
334 pr_err("alg: hash: digest failed on test %d "
335 "for %s: ret=%d\n", j
, algo
, -ret
);
339 ret
= wait_async_op(&tresult
, crypto_ahash_init(req
));
341 pr_err("alt: hash: init failed on test %d "
342 "for %s: ret=%d\n", j
, algo
, -ret
);
345 ret
= wait_async_op(&tresult
, crypto_ahash_update(req
));
347 pr_err("alt: hash: update failed on test %d "
348 "for %s: ret=%d\n", j
, algo
, -ret
);
351 ret
= wait_async_op(&tresult
, crypto_ahash_final(req
));
353 pr_err("alt: hash: final failed on test %d "
354 "for %s: ret=%d\n", j
, algo
, -ret
);
359 if (memcmp(result
, template[i
].digest
,
360 crypto_ahash_digestsize(tfm
))) {
361 printk(KERN_ERR
"alg: hash: Test %d failed for %s\n",
363 hexdump(result
, crypto_ahash_digestsize(tfm
));
370 for (i
= 0; i
< tcount
; i
++) {
371 /* alignment tests are only done with continuous buffers */
372 if (align_offset
!= 0)
379 memset(result
, 0, MAX_DIGEST_SIZE
);
382 sg_init_table(sg
, template[i
].np
);
384 for (k
= 0; k
< template[i
].np
; k
++) {
385 if (WARN_ON(offset_in_page(IDX
[k
]) +
386 template[i
].tap
[k
] > PAGE_SIZE
))
389 memcpy(xbuf
[IDX
[k
] >> PAGE_SHIFT
] +
390 offset_in_page(IDX
[k
]),
391 template[i
].plaintext
+ temp
,
394 temp
+= template[i
].tap
[k
];
397 if (template[i
].ksize
) {
398 if (template[i
].ksize
> MAX_KEYLEN
) {
399 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
400 j
, algo
, template[i
].ksize
, MAX_KEYLEN
);
404 crypto_ahash_clear_flags(tfm
, ~0);
405 memcpy(key
, template[i
].key
, template[i
].ksize
);
406 ret
= crypto_ahash_setkey(tfm
, key
, template[i
].ksize
);
409 printk(KERN_ERR
"alg: hash: setkey "
410 "failed on chunking test %d "
411 "for %s: ret=%d\n", j
, algo
, -ret
);
416 ahash_request_set_crypt(req
, sg
, result
, template[i
].psize
);
417 ret
= crypto_ahash_digest(req
);
423 wait_for_completion(&tresult
.completion
);
424 reinit_completion(&tresult
.completion
);
430 printk(KERN_ERR
"alg: hash: digest failed "
431 "on chunking test %d for %s: "
432 "ret=%d\n", j
, algo
, -ret
);
436 if (memcmp(result
, template[i
].digest
,
437 crypto_ahash_digestsize(tfm
))) {
438 printk(KERN_ERR
"alg: hash: Chunking test %d "
439 "failed for %s\n", j
, algo
);
440 hexdump(result
, crypto_ahash_digestsize(tfm
));
446 /* partial update exercise */
448 for (i
= 0; i
< tcount
; i
++) {
449 /* alignment tests are only done with continuous buffers */
450 if (align_offset
!= 0)
453 if (template[i
].np
< 2)
457 memset(result
, 0, MAX_DIGEST_SIZE
);
461 memcpy(hash_buff
, template[i
].plaintext
,
463 sg_init_one(&sg
[0], hash_buff
, template[i
].tap
[0]);
465 if (template[i
].ksize
) {
466 crypto_ahash_clear_flags(tfm
, ~0);
467 if (template[i
].ksize
> MAX_KEYLEN
) {
468 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
469 j
, algo
, template[i
].ksize
, MAX_KEYLEN
);
473 memcpy(key
, template[i
].key
, template[i
].ksize
);
474 ret
= crypto_ahash_setkey(tfm
, key
, template[i
].ksize
);
476 pr_err("alg: hash: setkey failed on test %d for %s: ret=%d\n",
482 ahash_request_set_crypt(req
, sg
, result
, template[i
].tap
[0]);
483 ret
= wait_async_op(&tresult
, crypto_ahash_init(req
));
485 pr_err("alt: hash: init failed on test %d for %s: ret=%d\n",
489 ret
= wait_async_op(&tresult
, crypto_ahash_update(req
));
491 pr_err("alt: hash: update failed on test %d for %s: ret=%d\n",
496 temp
= template[i
].tap
[0];
497 for (k
= 1; k
< template[i
].np
; k
++) {
498 ret
= ahash_partial_update(&req
, tfm
, &template[i
],
499 hash_buff
, k
, temp
, &sg
[0], algo
, result
,
502 pr_err("hash: partial update failed on test %d for %s: ret=%d\n",
506 temp
+= template[i
].tap
[k
];
508 ret
= wait_async_op(&tresult
, crypto_ahash_final(req
));
510 pr_err("alt: hash: final failed on test %d for %s: ret=%d\n",
514 if (memcmp(result
, template[i
].digest
,
515 crypto_ahash_digestsize(tfm
))) {
516 pr_err("alg: hash: Partial Test %d failed for %s\n",
518 hexdump(result
, crypto_ahash_digestsize(tfm
));
527 ahash_request_free(req
);
529 testmgr_free_buf(xbuf
);
536 static int test_hash(struct crypto_ahash
*tfm
, struct hash_testvec
*template,
537 unsigned int tcount
, bool use_digest
)
539 unsigned int alignmask
;
542 ret
= __test_hash(tfm
, template, tcount
, use_digest
, 0);
546 /* test unaligned buffers, check with one byte offset */
547 ret
= __test_hash(tfm
, template, tcount
, use_digest
, 1);
551 alignmask
= crypto_tfm_alg_alignmask(&tfm
->base
);
553 /* Check if alignment mask for tfm is correctly set. */
554 ret
= __test_hash(tfm
, template, tcount
, use_digest
,
563 static int __test_aead(struct crypto_aead
*tfm
, int enc
,
564 struct aead_testvec
*template, unsigned int tcount
,
565 const bool diff_dst
, const int align_offset
)
567 const char *algo
= crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm
));
568 unsigned int i
, j
, k
, n
, temp
;
572 struct aead_request
*req
;
573 struct scatterlist
*sg
;
574 struct scatterlist
*sgout
;
576 struct tcrypt_result result
;
577 unsigned int authsize
, iv_len
;
582 char *xbuf
[XBUFSIZE
];
583 char *xoutbuf
[XBUFSIZE
];
584 char *axbuf
[XBUFSIZE
];
586 iv
= kzalloc(MAX_IVLEN
, GFP_KERNEL
);
589 key
= kmalloc(MAX_KEYLEN
, GFP_KERNEL
);
592 if (testmgr_alloc_buf(xbuf
))
594 if (testmgr_alloc_buf(axbuf
))
596 if (diff_dst
&& testmgr_alloc_buf(xoutbuf
))
599 /* avoid "the frame size is larger than 1024 bytes" compiler warning */
600 sg
= kmalloc(sizeof(*sg
) * 8 * (diff_dst
? 4 : 2), GFP_KERNEL
);
615 init_completion(&result
.completion
);
617 req
= aead_request_alloc(tfm
, GFP_KERNEL
);
619 pr_err("alg: aead%s: Failed to allocate request for %s\n",
624 aead_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
625 tcrypt_complete
, &result
);
627 iv_len
= crypto_aead_ivsize(tfm
);
629 for (i
= 0, j
= 0; i
< tcount
; i
++) {
635 /* some templates have no input data but they will
639 input
+= align_offset
;
643 if (WARN_ON(align_offset
+ template[i
].ilen
>
644 PAGE_SIZE
|| template[i
].alen
> PAGE_SIZE
))
647 memcpy(input
, template[i
].input
, template[i
].ilen
);
648 memcpy(assoc
, template[i
].assoc
, template[i
].alen
);
650 memcpy(iv
, template[i
].iv
, iv_len
);
652 memset(iv
, 0, iv_len
);
654 crypto_aead_clear_flags(tfm
, ~0);
656 crypto_aead_set_flags(tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
658 if (template[i
].klen
> MAX_KEYLEN
) {
659 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
660 d
, j
, algo
, template[i
].klen
,
665 memcpy(key
, template[i
].key
, template[i
].klen
);
667 ret
= crypto_aead_setkey(tfm
, key
, template[i
].klen
);
668 if (template[i
].fail
== !ret
) {
669 pr_err("alg: aead%s: setkey failed on test %d for %s: flags=%x\n",
670 d
, j
, algo
, crypto_aead_get_flags(tfm
));
675 authsize
= abs(template[i
].rlen
- template[i
].ilen
);
676 ret
= crypto_aead_setauthsize(tfm
, authsize
);
678 pr_err("alg: aead%s: Failed to set authsize to %u on test %d for %s\n",
679 d
, authsize
, j
, algo
);
683 k
= !!template[i
].alen
;
684 sg_init_table(sg
, k
+ 1);
685 sg_set_buf(&sg
[0], assoc
, template[i
].alen
);
686 sg_set_buf(&sg
[k
], input
,
687 template[i
].ilen
+ (enc
? authsize
: 0));
691 sg_init_table(sgout
, k
+ 1);
692 sg_set_buf(&sgout
[0], assoc
, template[i
].alen
);
695 output
+= align_offset
;
696 sg_set_buf(&sgout
[k
], output
,
697 template[i
].rlen
+ (enc
? 0 : authsize
));
700 aead_request_set_crypt(req
, sg
, (diff_dst
) ? sgout
: sg
,
701 template[i
].ilen
, iv
);
703 aead_request_set_ad(req
, template[i
].alen
);
705 ret
= enc
? crypto_aead_encrypt(req
) : crypto_aead_decrypt(req
);
709 if (template[i
].novrfy
) {
710 /* verification was supposed to fail */
711 pr_err("alg: aead%s: %s failed on test %d for %s: ret was 0, expected -EBADMSG\n",
713 /* so really, we got a bad message */
720 wait_for_completion(&result
.completion
);
721 reinit_completion(&result
.completion
);
726 if (template[i
].novrfy
)
727 /* verification failure was expected */
731 pr_err("alg: aead%s: %s failed on test %d for %s: ret=%d\n",
732 d
, e
, j
, algo
, -ret
);
737 if (memcmp(q
, template[i
].result
, template[i
].rlen
)) {
738 pr_err("alg: aead%s: Test %d failed on %s for %s\n",
740 hexdump(q
, template[i
].rlen
);
746 for (i
= 0, j
= 0; i
< tcount
; i
++) {
747 /* alignment tests are only done with continuous buffers */
748 if (align_offset
!= 0)
757 memcpy(iv
, template[i
].iv
, iv_len
);
759 memset(iv
, 0, MAX_IVLEN
);
761 crypto_aead_clear_flags(tfm
, ~0);
763 crypto_aead_set_flags(tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
764 if (template[i
].klen
> MAX_KEYLEN
) {
765 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
766 d
, j
, algo
, template[i
].klen
, MAX_KEYLEN
);
770 memcpy(key
, template[i
].key
, template[i
].klen
);
772 ret
= crypto_aead_setkey(tfm
, key
, template[i
].klen
);
773 if (template[i
].fail
== !ret
) {
774 pr_err("alg: aead%s: setkey failed on chunk test %d for %s: flags=%x\n",
775 d
, j
, algo
, crypto_aead_get_flags(tfm
));
780 authsize
= abs(template[i
].rlen
- template[i
].ilen
);
783 sg_init_table(sg
, template[i
].anp
+ template[i
].np
);
785 sg_init_table(sgout
, template[i
].anp
+ template[i
].np
);
788 for (k
= 0, temp
= 0; k
< template[i
].anp
; k
++) {
789 if (WARN_ON(offset_in_page(IDX
[k
]) +
790 template[i
].atap
[k
] > PAGE_SIZE
))
793 memcpy(axbuf
[IDX
[k
] >> PAGE_SHIFT
] +
794 offset_in_page(IDX
[k
]),
795 template[i
].assoc
+ temp
,
796 template[i
].atap
[k
]),
797 template[i
].atap
[k
]);
799 sg_set_buf(&sgout
[k
],
800 axbuf
[IDX
[k
] >> PAGE_SHIFT
] +
801 offset_in_page(IDX
[k
]),
802 template[i
].atap
[k
]);
803 temp
+= template[i
].atap
[k
];
806 for (k
= 0, temp
= 0; k
< template[i
].np
; k
++) {
807 if (WARN_ON(offset_in_page(IDX
[k
]) +
808 template[i
].tap
[k
] > PAGE_SIZE
))
811 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] + offset_in_page(IDX
[k
]);
812 memcpy(q
, template[i
].input
+ temp
, template[i
].tap
[k
]);
813 sg_set_buf(&sg
[template[i
].anp
+ k
],
814 q
, template[i
].tap
[k
]);
817 q
= xoutbuf
[IDX
[k
] >> PAGE_SHIFT
] +
818 offset_in_page(IDX
[k
]);
820 memset(q
, 0, template[i
].tap
[k
]);
822 sg_set_buf(&sgout
[template[i
].anp
+ k
],
823 q
, template[i
].tap
[k
]);
826 n
= template[i
].tap
[k
];
827 if (k
== template[i
].np
- 1 && enc
)
829 if (offset_in_page(q
) + n
< PAGE_SIZE
)
832 temp
+= template[i
].tap
[k
];
835 ret
= crypto_aead_setauthsize(tfm
, authsize
);
837 pr_err("alg: aead%s: Failed to set authsize to %u on chunk test %d for %s\n",
838 d
, authsize
, j
, algo
);
843 if (WARN_ON(sg
[template[i
].anp
+ k
- 1].offset
+
844 sg
[template[i
].anp
+ k
- 1].length
+
845 authsize
> PAGE_SIZE
)) {
851 sgout
[template[i
].anp
+ k
- 1].length
+=
853 sg
[template[i
].anp
+ k
- 1].length
+= authsize
;
856 aead_request_set_crypt(req
, sg
, (diff_dst
) ? sgout
: sg
,
860 aead_request_set_ad(req
, template[i
].alen
);
862 ret
= enc
? crypto_aead_encrypt(req
) : crypto_aead_decrypt(req
);
866 if (template[i
].novrfy
) {
867 /* verification was supposed to fail */
868 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret was 0, expected -EBADMSG\n",
870 /* so really, we got a bad message */
877 wait_for_completion(&result
.completion
);
878 reinit_completion(&result
.completion
);
883 if (template[i
].novrfy
)
884 /* verification failure was expected */
888 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret=%d\n",
889 d
, e
, j
, algo
, -ret
);
894 for (k
= 0, temp
= 0; k
< template[i
].np
; k
++) {
896 q
= xoutbuf
[IDX
[k
] >> PAGE_SHIFT
] +
897 offset_in_page(IDX
[k
]);
899 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] +
900 offset_in_page(IDX
[k
]);
902 n
= template[i
].tap
[k
];
903 if (k
== template[i
].np
- 1)
904 n
+= enc
? authsize
: -authsize
;
906 if (memcmp(q
, template[i
].result
+ temp
, n
)) {
907 pr_err("alg: aead%s: Chunk test %d failed on %s at page %u for %s\n",
914 if (k
== template[i
].np
- 1 && !enc
) {
916 memcmp(q
, template[i
].input
+
922 for (n
= 0; offset_in_page(q
+ n
) && q
[n
]; n
++)
926 pr_err("alg: aead%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
927 d
, j
, e
, k
, algo
, n
);
932 temp
+= template[i
].tap
[k
];
939 aead_request_free(req
);
943 testmgr_free_buf(xoutbuf
);
945 testmgr_free_buf(axbuf
);
947 testmgr_free_buf(xbuf
);
954 static int test_aead(struct crypto_aead
*tfm
, int enc
,
955 struct aead_testvec
*template, unsigned int tcount
)
957 unsigned int alignmask
;
960 /* test 'dst == src' case */
961 ret
= __test_aead(tfm
, enc
, template, tcount
, false, 0);
965 /* test 'dst != src' case */
966 ret
= __test_aead(tfm
, enc
, template, tcount
, true, 0);
970 /* test unaligned buffers, check with one byte offset */
971 ret
= __test_aead(tfm
, enc
, template, tcount
, true, 1);
975 alignmask
= crypto_tfm_alg_alignmask(&tfm
->base
);
977 /* Check if alignment mask for tfm is correctly set. */
978 ret
= __test_aead(tfm
, enc
, template, tcount
, true,
987 static int test_cipher(struct crypto_cipher
*tfm
, int enc
,
988 struct cipher_testvec
*template, unsigned int tcount
)
990 const char *algo
= crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm
));
991 unsigned int i
, j
, k
;
995 char *xbuf
[XBUFSIZE
];
998 if (testmgr_alloc_buf(xbuf
))
1007 for (i
= 0; i
< tcount
; i
++) {
1011 if (fips_enabled
&& template[i
].fips_skip
)
1017 if (WARN_ON(template[i
].ilen
> PAGE_SIZE
))
1021 memcpy(data
, template[i
].input
, template[i
].ilen
);
1023 crypto_cipher_clear_flags(tfm
, ~0);
1025 crypto_cipher_set_flags(tfm
, CRYPTO_TFM_REQ_WEAK_KEY
);
1027 ret
= crypto_cipher_setkey(tfm
, template[i
].key
,
1029 if (template[i
].fail
== !ret
) {
1030 printk(KERN_ERR
"alg: cipher: setkey failed "
1031 "on test %d for %s: flags=%x\n", j
,
1032 algo
, crypto_cipher_get_flags(tfm
));
1037 for (k
= 0; k
< template[i
].ilen
;
1038 k
+= crypto_cipher_blocksize(tfm
)) {
1040 crypto_cipher_encrypt_one(tfm
, data
+ k
,
1043 crypto_cipher_decrypt_one(tfm
, data
+ k
,
1048 if (memcmp(q
, template[i
].result
, template[i
].rlen
)) {
1049 printk(KERN_ERR
"alg: cipher: Test %d failed "
1050 "on %s for %s\n", j
, e
, algo
);
1051 hexdump(q
, template[i
].rlen
);
1060 testmgr_free_buf(xbuf
);
1065 static int __test_skcipher(struct crypto_skcipher
*tfm
, int enc
,
1066 struct cipher_testvec
*template, unsigned int tcount
,
1067 const bool diff_dst
, const int align_offset
)
1070 crypto_tfm_alg_driver_name(crypto_skcipher_tfm(tfm
));
1071 unsigned int i
, j
, k
, n
, temp
;
1073 struct skcipher_request
*req
;
1074 struct scatterlist sg
[8];
1075 struct scatterlist sgout
[8];
1077 struct tcrypt_result result
;
1080 char *xbuf
[XBUFSIZE
];
1081 char *xoutbuf
[XBUFSIZE
];
1083 unsigned int ivsize
= crypto_skcipher_ivsize(tfm
);
1085 if (testmgr_alloc_buf(xbuf
))
1088 if (diff_dst
&& testmgr_alloc_buf(xoutbuf
))
1101 init_completion(&result
.completion
);
1103 req
= skcipher_request_alloc(tfm
, GFP_KERNEL
);
1105 pr_err("alg: skcipher%s: Failed to allocate request for %s\n",
1110 skcipher_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
1111 tcrypt_complete
, &result
);
1114 for (i
= 0; i
< tcount
; i
++) {
1115 if (template[i
].np
&& !template[i
].also_non_np
)
1118 if (fips_enabled
&& template[i
].fips_skip
)
1122 memcpy(iv
, template[i
].iv
, ivsize
);
1124 memset(iv
, 0, MAX_IVLEN
);
1128 if (WARN_ON(align_offset
+ template[i
].ilen
> PAGE_SIZE
))
1132 data
+= align_offset
;
1133 memcpy(data
, template[i
].input
, template[i
].ilen
);
1135 crypto_skcipher_clear_flags(tfm
, ~0);
1137 crypto_skcipher_set_flags(tfm
,
1138 CRYPTO_TFM_REQ_WEAK_KEY
);
1140 ret
= crypto_skcipher_setkey(tfm
, template[i
].key
,
1142 if (template[i
].fail
== !ret
) {
1143 pr_err("alg: skcipher%s: setkey failed on test %d for %s: flags=%x\n",
1144 d
, j
, algo
, crypto_skcipher_get_flags(tfm
));
1149 sg_init_one(&sg
[0], data
, template[i
].ilen
);
1152 data
+= align_offset
;
1153 sg_init_one(&sgout
[0], data
, template[i
].ilen
);
1156 skcipher_request_set_crypt(req
, sg
, (diff_dst
) ? sgout
: sg
,
1157 template[i
].ilen
, iv
);
1158 ret
= enc
? crypto_skcipher_encrypt(req
) :
1159 crypto_skcipher_decrypt(req
);
1166 wait_for_completion(&result
.completion
);
1167 reinit_completion(&result
.completion
);
1173 pr_err("alg: skcipher%s: %s failed on test %d for %s: ret=%d\n",
1174 d
, e
, j
, algo
, -ret
);
1179 if (memcmp(q
, template[i
].result
, template[i
].rlen
)) {
1180 pr_err("alg: skcipher%s: Test %d failed (invalid result) on %s for %s\n",
1182 hexdump(q
, template[i
].rlen
);
1187 if (template[i
].iv_out
&&
1188 memcmp(iv
, template[i
].iv_out
,
1189 crypto_skcipher_ivsize(tfm
))) {
1190 pr_err("alg: skcipher%s: Test %d failed (invalid output IV) on %s for %s\n",
1192 hexdump(iv
, crypto_skcipher_ivsize(tfm
));
1199 for (i
= 0; i
< tcount
; i
++) {
1200 /* alignment tests are only done with continuous buffers */
1201 if (align_offset
!= 0)
1204 if (!template[i
].np
)
1207 if (fips_enabled
&& template[i
].fips_skip
)
1211 memcpy(iv
, template[i
].iv
, ivsize
);
1213 memset(iv
, 0, MAX_IVLEN
);
1216 crypto_skcipher_clear_flags(tfm
, ~0);
1218 crypto_skcipher_set_flags(tfm
,
1219 CRYPTO_TFM_REQ_WEAK_KEY
);
1221 ret
= crypto_skcipher_setkey(tfm
, template[i
].key
,
1223 if (template[i
].fail
== !ret
) {
1224 pr_err("alg: skcipher%s: setkey failed on chunk test %d for %s: flags=%x\n",
1225 d
, j
, algo
, crypto_skcipher_get_flags(tfm
));
1232 sg_init_table(sg
, template[i
].np
);
1234 sg_init_table(sgout
, template[i
].np
);
1235 for (k
= 0; k
< template[i
].np
; k
++) {
1236 if (WARN_ON(offset_in_page(IDX
[k
]) +
1237 template[i
].tap
[k
] > PAGE_SIZE
))
1240 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] + offset_in_page(IDX
[k
]);
1242 memcpy(q
, template[i
].input
+ temp
, template[i
].tap
[k
]);
1244 if (offset_in_page(q
) + template[i
].tap
[k
] < PAGE_SIZE
)
1245 q
[template[i
].tap
[k
]] = 0;
1247 sg_set_buf(&sg
[k
], q
, template[i
].tap
[k
]);
1249 q
= xoutbuf
[IDX
[k
] >> PAGE_SHIFT
] +
1250 offset_in_page(IDX
[k
]);
1252 sg_set_buf(&sgout
[k
], q
, template[i
].tap
[k
]);
1254 memset(q
, 0, template[i
].tap
[k
]);
1255 if (offset_in_page(q
) +
1256 template[i
].tap
[k
] < PAGE_SIZE
)
1257 q
[template[i
].tap
[k
]] = 0;
1260 temp
+= template[i
].tap
[k
];
1263 skcipher_request_set_crypt(req
, sg
, (diff_dst
) ? sgout
: sg
,
1264 template[i
].ilen
, iv
);
1266 ret
= enc
? crypto_skcipher_encrypt(req
) :
1267 crypto_skcipher_decrypt(req
);
1274 wait_for_completion(&result
.completion
);
1275 reinit_completion(&result
.completion
);
1281 pr_err("alg: skcipher%s: %s failed on chunk test %d for %s: ret=%d\n",
1282 d
, e
, j
, algo
, -ret
);
1288 for (k
= 0; k
< template[i
].np
; k
++) {
1290 q
= xoutbuf
[IDX
[k
] >> PAGE_SHIFT
] +
1291 offset_in_page(IDX
[k
]);
1293 q
= xbuf
[IDX
[k
] >> PAGE_SHIFT
] +
1294 offset_in_page(IDX
[k
]);
1296 if (memcmp(q
, template[i
].result
+ temp
,
1297 template[i
].tap
[k
])) {
1298 pr_err("alg: skcipher%s: Chunk test %d failed on %s at page %u for %s\n",
1300 hexdump(q
, template[i
].tap
[k
]);
1304 q
+= template[i
].tap
[k
];
1305 for (n
= 0; offset_in_page(q
+ n
) && q
[n
]; n
++)
1308 pr_err("alg: skcipher%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
1309 d
, j
, e
, k
, algo
, n
);
1313 temp
+= template[i
].tap
[k
];
1320 skcipher_request_free(req
);
1322 testmgr_free_buf(xoutbuf
);
1324 testmgr_free_buf(xbuf
);
1329 static int test_skcipher(struct crypto_skcipher
*tfm
, int enc
,
1330 struct cipher_testvec
*template, unsigned int tcount
)
1332 unsigned int alignmask
;
1335 /* test 'dst == src' case */
1336 ret
= __test_skcipher(tfm
, enc
, template, tcount
, false, 0);
1340 /* test 'dst != src' case */
1341 ret
= __test_skcipher(tfm
, enc
, template, tcount
, true, 0);
1345 /* test unaligned buffers, check with one byte offset */
1346 ret
= __test_skcipher(tfm
, enc
, template, tcount
, true, 1);
1350 alignmask
= crypto_tfm_alg_alignmask(&tfm
->base
);
1352 /* Check if alignment mask for tfm is correctly set. */
1353 ret
= __test_skcipher(tfm
, enc
, template, tcount
, true,
1362 static int test_comp(struct crypto_comp
*tfm
, struct comp_testvec
*ctemplate
,
1363 struct comp_testvec
*dtemplate
, int ctcount
, int dtcount
)
1365 const char *algo
= crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm
));
1367 char result
[COMP_BUF_SIZE
];
1370 for (i
= 0; i
< ctcount
; i
++) {
1372 unsigned int dlen
= COMP_BUF_SIZE
;
1374 memset(result
, 0, sizeof (result
));
1376 ilen
= ctemplate
[i
].inlen
;
1377 ret
= crypto_comp_compress(tfm
, ctemplate
[i
].input
,
1378 ilen
, result
, &dlen
);
1380 printk(KERN_ERR
"alg: comp: compression failed "
1381 "on test %d for %s: ret=%d\n", i
+ 1, algo
,
1386 if (dlen
!= ctemplate
[i
].outlen
) {
1387 printk(KERN_ERR
"alg: comp: Compression test %d "
1388 "failed for %s: output len = %d\n", i
+ 1, algo
,
1394 if (memcmp(result
, ctemplate
[i
].output
, dlen
)) {
1395 printk(KERN_ERR
"alg: comp: Compression test %d "
1396 "failed for %s\n", i
+ 1, algo
);
1397 hexdump(result
, dlen
);
1403 for (i
= 0; i
< dtcount
; i
++) {
1405 unsigned int dlen
= COMP_BUF_SIZE
;
1407 memset(result
, 0, sizeof (result
));
1409 ilen
= dtemplate
[i
].inlen
;
1410 ret
= crypto_comp_decompress(tfm
, dtemplate
[i
].input
,
1411 ilen
, result
, &dlen
);
1413 printk(KERN_ERR
"alg: comp: decompression failed "
1414 "on test %d for %s: ret=%d\n", i
+ 1, algo
,
1419 if (dlen
!= dtemplate
[i
].outlen
) {
1420 printk(KERN_ERR
"alg: comp: Decompression test %d "
1421 "failed for %s: output len = %d\n", i
+ 1, algo
,
1427 if (memcmp(result
, dtemplate
[i
].output
, dlen
)) {
1428 printk(KERN_ERR
"alg: comp: Decompression test %d "
1429 "failed for %s\n", i
+ 1, algo
);
1430 hexdump(result
, dlen
);
1442 static int test_cprng(struct crypto_rng
*tfm
, struct cprng_testvec
*template,
1443 unsigned int tcount
)
1445 const char *algo
= crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm
));
1446 int err
= 0, i
, j
, seedsize
;
1450 seedsize
= crypto_rng_seedsize(tfm
);
1452 seed
= kmalloc(seedsize
, GFP_KERNEL
);
1454 printk(KERN_ERR
"alg: cprng: Failed to allocate seed space "
1459 for (i
= 0; i
< tcount
; i
++) {
1460 memset(result
, 0, 32);
1462 memcpy(seed
, template[i
].v
, template[i
].vlen
);
1463 memcpy(seed
+ template[i
].vlen
, template[i
].key
,
1465 memcpy(seed
+ template[i
].vlen
+ template[i
].klen
,
1466 template[i
].dt
, template[i
].dtlen
);
1468 err
= crypto_rng_reset(tfm
, seed
, seedsize
);
1470 printk(KERN_ERR
"alg: cprng: Failed to reset rng "
1475 for (j
= 0; j
< template[i
].loops
; j
++) {
1476 err
= crypto_rng_get_bytes(tfm
, result
,
1479 printk(KERN_ERR
"alg: cprng: Failed to obtain "
1480 "the correct amount of random data for "
1481 "%s (requested %d)\n", algo
,
1487 err
= memcmp(result
, template[i
].result
,
1490 printk(KERN_ERR
"alg: cprng: Test %d failed for %s\n",
1492 hexdump(result
, template[i
].rlen
);
1503 static int alg_test_aead(const struct alg_test_desc
*desc
, const char *driver
,
1506 struct crypto_aead
*tfm
;
1509 tfm
= crypto_alloc_aead(driver
, type
| CRYPTO_ALG_INTERNAL
, mask
);
1511 printk(KERN_ERR
"alg: aead: Failed to load transform for %s: "
1512 "%ld\n", driver
, PTR_ERR(tfm
));
1513 return PTR_ERR(tfm
);
1516 if (desc
->suite
.aead
.enc
.vecs
) {
1517 err
= test_aead(tfm
, ENCRYPT
, desc
->suite
.aead
.enc
.vecs
,
1518 desc
->suite
.aead
.enc
.count
);
1523 if (!err
&& desc
->suite
.aead
.dec
.vecs
)
1524 err
= test_aead(tfm
, DECRYPT
, desc
->suite
.aead
.dec
.vecs
,
1525 desc
->suite
.aead
.dec
.count
);
1528 crypto_free_aead(tfm
);
1532 static int alg_test_cipher(const struct alg_test_desc
*desc
,
1533 const char *driver
, u32 type
, u32 mask
)
1535 struct crypto_cipher
*tfm
;
1538 tfm
= crypto_alloc_cipher(driver
, type
| CRYPTO_ALG_INTERNAL
, mask
);
1540 printk(KERN_ERR
"alg: cipher: Failed to load transform for "
1541 "%s: %ld\n", driver
, PTR_ERR(tfm
));
1542 return PTR_ERR(tfm
);
1545 if (desc
->suite
.cipher
.enc
.vecs
) {
1546 err
= test_cipher(tfm
, ENCRYPT
, desc
->suite
.cipher
.enc
.vecs
,
1547 desc
->suite
.cipher
.enc
.count
);
1552 if (desc
->suite
.cipher
.dec
.vecs
)
1553 err
= test_cipher(tfm
, DECRYPT
, desc
->suite
.cipher
.dec
.vecs
,
1554 desc
->suite
.cipher
.dec
.count
);
1557 crypto_free_cipher(tfm
);
1561 static int alg_test_skcipher(const struct alg_test_desc
*desc
,
1562 const char *driver
, u32 type
, u32 mask
)
1564 struct crypto_skcipher
*tfm
;
1567 tfm
= crypto_alloc_skcipher(driver
, type
| CRYPTO_ALG_INTERNAL
, mask
);
1569 printk(KERN_ERR
"alg: skcipher: Failed to load transform for "
1570 "%s: %ld\n", driver
, PTR_ERR(tfm
));
1571 return PTR_ERR(tfm
);
1574 if (desc
->suite
.cipher
.enc
.vecs
) {
1575 err
= test_skcipher(tfm
, ENCRYPT
, desc
->suite
.cipher
.enc
.vecs
,
1576 desc
->suite
.cipher
.enc
.count
);
1581 if (desc
->suite
.cipher
.dec
.vecs
)
1582 err
= test_skcipher(tfm
, DECRYPT
, desc
->suite
.cipher
.dec
.vecs
,
1583 desc
->suite
.cipher
.dec
.count
);
1586 crypto_free_skcipher(tfm
);
1590 static int alg_test_comp(const struct alg_test_desc
*desc
, const char *driver
,
1593 struct crypto_comp
*tfm
;
1596 tfm
= crypto_alloc_comp(driver
, type
, mask
);
1598 printk(KERN_ERR
"alg: comp: Failed to load transform for %s: "
1599 "%ld\n", driver
, PTR_ERR(tfm
));
1600 return PTR_ERR(tfm
);
1603 err
= test_comp(tfm
, desc
->suite
.comp
.comp
.vecs
,
1604 desc
->suite
.comp
.decomp
.vecs
,
1605 desc
->suite
.comp
.comp
.count
,
1606 desc
->suite
.comp
.decomp
.count
);
1608 crypto_free_comp(tfm
);
1612 static int alg_test_hash(const struct alg_test_desc
*desc
, const char *driver
,
1615 struct crypto_ahash
*tfm
;
1618 tfm
= crypto_alloc_ahash(driver
, type
| CRYPTO_ALG_INTERNAL
, mask
);
1620 printk(KERN_ERR
"alg: hash: Failed to load transform for %s: "
1621 "%ld\n", driver
, PTR_ERR(tfm
));
1622 return PTR_ERR(tfm
);
1625 err
= test_hash(tfm
, desc
->suite
.hash
.vecs
,
1626 desc
->suite
.hash
.count
, true);
1628 err
= test_hash(tfm
, desc
->suite
.hash
.vecs
,
1629 desc
->suite
.hash
.count
, false);
1631 crypto_free_ahash(tfm
);
1635 static int alg_test_crc32c(const struct alg_test_desc
*desc
,
1636 const char *driver
, u32 type
, u32 mask
)
1638 struct crypto_shash
*tfm
;
1642 err
= alg_test_hash(desc
, driver
, type
, mask
);
1646 tfm
= crypto_alloc_shash(driver
, type
| CRYPTO_ALG_INTERNAL
, mask
);
1648 printk(KERN_ERR
"alg: crc32c: Failed to load transform for %s: "
1649 "%ld\n", driver
, PTR_ERR(tfm
));
1655 SHASH_DESC_ON_STACK(shash
, tfm
);
1656 u32
*ctx
= (u32
*)shash_desc_ctx(shash
);
1661 *ctx
= le32_to_cpu(420553207);
1662 err
= crypto_shash_final(shash
, (u8
*)&val
);
1664 printk(KERN_ERR
"alg: crc32c: Operation failed for "
1665 "%s: %d\n", driver
, err
);
1669 if (val
!= ~420553207) {
1670 printk(KERN_ERR
"alg: crc32c: Test failed for %s: "
1671 "%d\n", driver
, val
);
1676 crypto_free_shash(tfm
);
1682 static int alg_test_cprng(const struct alg_test_desc
*desc
, const char *driver
,
1685 struct crypto_rng
*rng
;
1688 rng
= crypto_alloc_rng(driver
, type
| CRYPTO_ALG_INTERNAL
, mask
);
1690 printk(KERN_ERR
"alg: cprng: Failed to load transform for %s: "
1691 "%ld\n", driver
, PTR_ERR(rng
));
1692 return PTR_ERR(rng
);
1695 err
= test_cprng(rng
, desc
->suite
.cprng
.vecs
, desc
->suite
.cprng
.count
);
1697 crypto_free_rng(rng
);
1703 static int drbg_cavs_test(struct drbg_testvec
*test
, int pr
,
1704 const char *driver
, u32 type
, u32 mask
)
1707 struct crypto_rng
*drng
;
1708 struct drbg_test_data test_data
;
1709 struct drbg_string addtl
, pers
, testentropy
;
1710 unsigned char *buf
= kzalloc(test
->expectedlen
, GFP_KERNEL
);
1715 drng
= crypto_alloc_rng(driver
, type
| CRYPTO_ALG_INTERNAL
, mask
);
1717 printk(KERN_ERR
"alg: drbg: could not allocate DRNG handle for "
1723 test_data
.testentropy
= &testentropy
;
1724 drbg_string_fill(&testentropy
, test
->entropy
, test
->entropylen
);
1725 drbg_string_fill(&pers
, test
->pers
, test
->perslen
);
1726 ret
= crypto_drbg_reset_test(drng
, &pers
, &test_data
);
1728 printk(KERN_ERR
"alg: drbg: Failed to reset rng\n");
1732 drbg_string_fill(&addtl
, test
->addtla
, test
->addtllen
);
1734 drbg_string_fill(&testentropy
, test
->entpra
, test
->entprlen
);
1735 ret
= crypto_drbg_get_bytes_addtl_test(drng
,
1736 buf
, test
->expectedlen
, &addtl
, &test_data
);
1738 ret
= crypto_drbg_get_bytes_addtl(drng
,
1739 buf
, test
->expectedlen
, &addtl
);
1742 printk(KERN_ERR
"alg: drbg: could not obtain random data for "
1743 "driver %s\n", driver
);
1747 drbg_string_fill(&addtl
, test
->addtlb
, test
->addtllen
);
1749 drbg_string_fill(&testentropy
, test
->entprb
, test
->entprlen
);
1750 ret
= crypto_drbg_get_bytes_addtl_test(drng
,
1751 buf
, test
->expectedlen
, &addtl
, &test_data
);
1753 ret
= crypto_drbg_get_bytes_addtl(drng
,
1754 buf
, test
->expectedlen
, &addtl
);
1757 printk(KERN_ERR
"alg: drbg: could not obtain random data for "
1758 "driver %s\n", driver
);
1762 ret
= memcmp(test
->expected
, buf
, test
->expectedlen
);
1765 crypto_free_rng(drng
);
1771 static int alg_test_drbg(const struct alg_test_desc
*desc
, const char *driver
,
1777 struct drbg_testvec
*template = desc
->suite
.drbg
.vecs
;
1778 unsigned int tcount
= desc
->suite
.drbg
.count
;
1780 if (0 == memcmp(driver
, "drbg_pr_", 8))
1783 for (i
= 0; i
< tcount
; i
++) {
1784 err
= drbg_cavs_test(&template[i
], pr
, driver
, type
, mask
);
1786 printk(KERN_ERR
"alg: drbg: Test %d failed for %s\n",
1796 static int do_test_kpp(struct crypto_kpp
*tfm
, struct kpp_testvec
*vec
,
1799 struct kpp_request
*req
;
1800 void *input_buf
= NULL
;
1801 void *output_buf
= NULL
;
1802 struct tcrypt_result result
;
1803 unsigned int out_len_max
;
1805 struct scatterlist src
, dst
;
1807 req
= kpp_request_alloc(tfm
, GFP_KERNEL
);
1811 init_completion(&result
.completion
);
1813 err
= crypto_kpp_set_secret(tfm
, vec
->secret
, vec
->secret_size
);
1817 out_len_max
= crypto_kpp_maxsize(tfm
);
1818 output_buf
= kzalloc(out_len_max
, GFP_KERNEL
);
1824 /* Use appropriate parameter as base */
1825 kpp_request_set_input(req
, NULL
, 0);
1826 sg_init_one(&dst
, output_buf
, out_len_max
);
1827 kpp_request_set_output(req
, &dst
, out_len_max
);
1828 kpp_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
1829 tcrypt_complete
, &result
);
1831 /* Compute public key */
1832 err
= wait_async_op(&result
, crypto_kpp_generate_public_key(req
));
1834 pr_err("alg: %s: generate public key test failed. err %d\n",
1838 /* Verify calculated public key */
1839 if (memcmp(vec
->expected_a_public
, sg_virt(req
->dst
),
1840 vec
->expected_a_public_size
)) {
1841 pr_err("alg: %s: generate public key test failed. Invalid output\n",
1847 /* Calculate shared secret key by using counter part (b) public key. */
1848 input_buf
= kzalloc(vec
->b_public_size
, GFP_KERNEL
);
1854 memcpy(input_buf
, vec
->b_public
, vec
->b_public_size
);
1855 sg_init_one(&src
, input_buf
, vec
->b_public_size
);
1856 sg_init_one(&dst
, output_buf
, out_len_max
);
1857 kpp_request_set_input(req
, &src
, vec
->b_public_size
);
1858 kpp_request_set_output(req
, &dst
, out_len_max
);
1859 kpp_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
1860 tcrypt_complete
, &result
);
1861 err
= wait_async_op(&result
, crypto_kpp_compute_shared_secret(req
));
1863 pr_err("alg: %s: compute shard secret test failed. err %d\n",
1868 * verify shared secret from which the user will derive
1869 * secret key by executing whatever hash it has chosen
1871 if (memcmp(vec
->expected_ss
, sg_virt(req
->dst
),
1872 vec
->expected_ss_size
)) {
1873 pr_err("alg: %s: compute shared secret test failed. Invalid output\n",
1883 kpp_request_free(req
);
1887 static int test_kpp(struct crypto_kpp
*tfm
, const char *alg
,
1888 struct kpp_testvec
*vecs
, unsigned int tcount
)
1892 for (i
= 0; i
< tcount
; i
++) {
1893 ret
= do_test_kpp(tfm
, vecs
++, alg
);
1895 pr_err("alg: %s: test failed on vector %d, err=%d\n",
1903 static int alg_test_kpp(const struct alg_test_desc
*desc
, const char *driver
,
1906 struct crypto_kpp
*tfm
;
1909 tfm
= crypto_alloc_kpp(driver
, type
| CRYPTO_ALG_INTERNAL
, mask
);
1911 pr_err("alg: kpp: Failed to load tfm for %s: %ld\n",
1912 driver
, PTR_ERR(tfm
));
1913 return PTR_ERR(tfm
);
1915 if (desc
->suite
.kpp
.vecs
)
1916 err
= test_kpp(tfm
, desc
->alg
, desc
->suite
.kpp
.vecs
,
1917 desc
->suite
.kpp
.count
);
1919 crypto_free_kpp(tfm
);
1923 static int test_akcipher_one(struct crypto_akcipher
*tfm
,
1924 struct akcipher_testvec
*vecs
)
1926 char *xbuf
[XBUFSIZE
];
1927 struct akcipher_request
*req
;
1928 void *outbuf_enc
= NULL
;
1929 void *outbuf_dec
= NULL
;
1930 struct tcrypt_result result
;
1931 unsigned int out_len_max
, out_len
= 0;
1933 struct scatterlist src
, dst
, src_tab
[2];
1935 if (testmgr_alloc_buf(xbuf
))
1938 req
= akcipher_request_alloc(tfm
, GFP_KERNEL
);
1942 init_completion(&result
.completion
);
1944 if (vecs
->public_key_vec
)
1945 err
= crypto_akcipher_set_pub_key(tfm
, vecs
->key
,
1948 err
= crypto_akcipher_set_priv_key(tfm
, vecs
->key
,
1954 out_len_max
= crypto_akcipher_maxsize(tfm
);
1955 outbuf_enc
= kzalloc(out_len_max
, GFP_KERNEL
);
1959 if (WARN_ON(vecs
->m_size
> PAGE_SIZE
))
1962 memcpy(xbuf
[0], vecs
->m
, vecs
->m_size
);
1964 sg_init_table(src_tab
, 2);
1965 sg_set_buf(&src_tab
[0], xbuf
[0], 8);
1966 sg_set_buf(&src_tab
[1], xbuf
[0] + 8, vecs
->m_size
- 8);
1967 sg_init_one(&dst
, outbuf_enc
, out_len_max
);
1968 akcipher_request_set_crypt(req
, src_tab
, &dst
, vecs
->m_size
,
1970 akcipher_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
1971 tcrypt_complete
, &result
);
1973 /* Run RSA encrypt - c = m^e mod n;*/
1974 err
= wait_async_op(&result
, crypto_akcipher_encrypt(req
));
1976 pr_err("alg: akcipher: encrypt test failed. err %d\n", err
);
1979 if (req
->dst_len
!= vecs
->c_size
) {
1980 pr_err("alg: akcipher: encrypt test failed. Invalid output len\n");
1984 /* verify that encrypted message is equal to expected */
1985 if (memcmp(vecs
->c
, outbuf_enc
, vecs
->c_size
)) {
1986 pr_err("alg: akcipher: encrypt test failed. Invalid output\n");
1987 hexdump(outbuf_enc
, vecs
->c_size
);
1991 /* Don't invoke decrypt for vectors with public key */
1992 if (vecs
->public_key_vec
) {
1996 outbuf_dec
= kzalloc(out_len_max
, GFP_KERNEL
);
2002 if (WARN_ON(vecs
->c_size
> PAGE_SIZE
))
2005 memcpy(xbuf
[0], vecs
->c
, vecs
->c_size
);
2007 sg_init_one(&src
, xbuf
[0], vecs
->c_size
);
2008 sg_init_one(&dst
, outbuf_dec
, out_len_max
);
2009 init_completion(&result
.completion
);
2010 akcipher_request_set_crypt(req
, &src
, &dst
, vecs
->c_size
, out_len_max
);
2012 /* Run RSA decrypt - m = c^d mod n;*/
2013 err
= wait_async_op(&result
, crypto_akcipher_decrypt(req
));
2015 pr_err("alg: akcipher: decrypt test failed. err %d\n", err
);
2018 out_len
= req
->dst_len
;
2019 if (out_len
< vecs
->m_size
) {
2020 pr_err("alg: akcipher: decrypt test failed. "
2021 "Invalid output len %u\n", out_len
);
2025 /* verify that decrypted message is equal to the original msg */
2026 if (memchr_inv(outbuf_dec
, 0, out_len
- vecs
->m_size
) ||
2027 memcmp(vecs
->m
, outbuf_dec
+ out_len
- vecs
->m_size
,
2029 pr_err("alg: akcipher: decrypt test failed. Invalid output\n");
2030 hexdump(outbuf_dec
, out_len
);
2037 akcipher_request_free(req
);
2039 testmgr_free_buf(xbuf
);
2043 static int test_akcipher(struct crypto_akcipher
*tfm
, const char *alg
,
2044 struct akcipher_testvec
*vecs
, unsigned int tcount
)
2047 crypto_tfm_alg_driver_name(crypto_akcipher_tfm(tfm
));
2050 for (i
= 0; i
< tcount
; i
++) {
2051 ret
= test_akcipher_one(tfm
, vecs
++);
2055 pr_err("alg: akcipher: test %d failed for %s, err=%d\n",
2062 static int alg_test_akcipher(const struct alg_test_desc
*desc
,
2063 const char *driver
, u32 type
, u32 mask
)
2065 struct crypto_akcipher
*tfm
;
2068 tfm
= crypto_alloc_akcipher(driver
, type
| CRYPTO_ALG_INTERNAL
, mask
);
2070 pr_err("alg: akcipher: Failed to load tfm for %s: %ld\n",
2071 driver
, PTR_ERR(tfm
));
2072 return PTR_ERR(tfm
);
2074 if (desc
->suite
.akcipher
.vecs
)
2075 err
= test_akcipher(tfm
, desc
->alg
, desc
->suite
.akcipher
.vecs
,
2076 desc
->suite
.akcipher
.count
);
2078 crypto_free_akcipher(tfm
);
2082 static int alg_test_null(const struct alg_test_desc
*desc
,
2083 const char *driver
, u32 type
, u32 mask
)
2088 /* Please keep this list sorted by algorithm name. */
2089 static const struct alg_test_desc alg_test_descs
[] = {
2091 .alg
= "__cbc-cast5-avx",
2092 .test
= alg_test_null
,
2094 .alg
= "__cbc-cast6-avx",
2095 .test
= alg_test_null
,
2097 .alg
= "__cbc-serpent-avx",
2098 .test
= alg_test_null
,
2100 .alg
= "__cbc-serpent-avx2",
2101 .test
= alg_test_null
,
2103 .alg
= "__cbc-serpent-sse2",
2104 .test
= alg_test_null
,
2106 .alg
= "__cbc-twofish-avx",
2107 .test
= alg_test_null
,
2109 .alg
= "__driver-cbc-aes-aesni",
2110 .test
= alg_test_null
,
2113 .alg
= "__driver-cbc-camellia-aesni",
2114 .test
= alg_test_null
,
2116 .alg
= "__driver-cbc-camellia-aesni-avx2",
2117 .test
= alg_test_null
,
2119 .alg
= "__driver-cbc-cast5-avx",
2120 .test
= alg_test_null
,
2122 .alg
= "__driver-cbc-cast6-avx",
2123 .test
= alg_test_null
,
2125 .alg
= "__driver-cbc-serpent-avx",
2126 .test
= alg_test_null
,
2128 .alg
= "__driver-cbc-serpent-avx2",
2129 .test
= alg_test_null
,
2131 .alg
= "__driver-cbc-serpent-sse2",
2132 .test
= alg_test_null
,
2134 .alg
= "__driver-cbc-twofish-avx",
2135 .test
= alg_test_null
,
2137 .alg
= "__driver-ecb-aes-aesni",
2138 .test
= alg_test_null
,
2141 .alg
= "__driver-ecb-camellia-aesni",
2142 .test
= alg_test_null
,
2144 .alg
= "__driver-ecb-camellia-aesni-avx2",
2145 .test
= alg_test_null
,
2147 .alg
= "__driver-ecb-cast5-avx",
2148 .test
= alg_test_null
,
2150 .alg
= "__driver-ecb-cast6-avx",
2151 .test
= alg_test_null
,
2153 .alg
= "__driver-ecb-serpent-avx",
2154 .test
= alg_test_null
,
2156 .alg
= "__driver-ecb-serpent-avx2",
2157 .test
= alg_test_null
,
2159 .alg
= "__driver-ecb-serpent-sse2",
2160 .test
= alg_test_null
,
2162 .alg
= "__driver-ecb-twofish-avx",
2163 .test
= alg_test_null
,
2165 .alg
= "__driver-gcm-aes-aesni",
2166 .test
= alg_test_null
,
2169 .alg
= "__ghash-pclmulqdqni",
2170 .test
= alg_test_null
,
2173 .alg
= "ansi_cprng",
2174 .test
= alg_test_cprng
,
2177 .vecs
= ansi_cprng_aes_tv_template
,
2178 .count
= ANSI_CPRNG_AES_TEST_VECTORS
2182 .alg
= "authenc(hmac(md5),ecb(cipher_null))",
2183 .test
= alg_test_aead
,
2187 .vecs
= hmac_md5_ecb_cipher_null_enc_tv_template
,
2188 .count
= HMAC_MD5_ECB_CIPHER_NULL_ENC_TEST_VECTORS
2191 .vecs
= hmac_md5_ecb_cipher_null_dec_tv_template
,
2192 .count
= HMAC_MD5_ECB_CIPHER_NULL_DEC_TEST_VECTORS
2197 .alg
= "authenc(hmac(sha1),cbc(aes))",
2198 .test
= alg_test_aead
,
2203 hmac_sha1_aes_cbc_enc_tv_temp
,
2205 HMAC_SHA1_AES_CBC_ENC_TEST_VEC
2210 .alg
= "authenc(hmac(sha1),cbc(des))",
2211 .test
= alg_test_aead
,
2216 hmac_sha1_des_cbc_enc_tv_temp
,
2218 HMAC_SHA1_DES_CBC_ENC_TEST_VEC
2223 .alg
= "authenc(hmac(sha1),cbc(des3_ede))",
2224 .test
= alg_test_aead
,
2230 hmac_sha1_des3_ede_cbc_enc_tv_temp
,
2232 HMAC_SHA1_DES3_EDE_CBC_ENC_TEST_VEC
2237 .alg
= "authenc(hmac(sha1),ctr(aes))",
2238 .test
= alg_test_null
,
2241 .alg
= "authenc(hmac(sha1),ecb(cipher_null))",
2242 .test
= alg_test_aead
,
2247 hmac_sha1_ecb_cipher_null_enc_tv_temp
,
2249 HMAC_SHA1_ECB_CIPHER_NULL_ENC_TEST_VEC
2253 hmac_sha1_ecb_cipher_null_dec_tv_temp
,
2255 HMAC_SHA1_ECB_CIPHER_NULL_DEC_TEST_VEC
2260 .alg
= "authenc(hmac(sha1),rfc3686(ctr(aes)))",
2261 .test
= alg_test_null
,
2264 .alg
= "authenc(hmac(sha224),cbc(des))",
2265 .test
= alg_test_aead
,
2270 hmac_sha224_des_cbc_enc_tv_temp
,
2272 HMAC_SHA224_DES_CBC_ENC_TEST_VEC
2277 .alg
= "authenc(hmac(sha224),cbc(des3_ede))",
2278 .test
= alg_test_aead
,
2284 hmac_sha224_des3_ede_cbc_enc_tv_temp
,
2286 HMAC_SHA224_DES3_EDE_CBC_ENC_TEST_VEC
2291 .alg
= "authenc(hmac(sha256),cbc(aes))",
2292 .test
= alg_test_aead
,
2298 hmac_sha256_aes_cbc_enc_tv_temp
,
2300 HMAC_SHA256_AES_CBC_ENC_TEST_VEC
2305 .alg
= "authenc(hmac(sha256),cbc(des))",
2306 .test
= alg_test_aead
,
2311 hmac_sha256_des_cbc_enc_tv_temp
,
2313 HMAC_SHA256_DES_CBC_ENC_TEST_VEC
2318 .alg
= "authenc(hmac(sha256),cbc(des3_ede))",
2319 .test
= alg_test_aead
,
2325 hmac_sha256_des3_ede_cbc_enc_tv_temp
,
2327 HMAC_SHA256_DES3_EDE_CBC_ENC_TEST_VEC
2332 .alg
= "authenc(hmac(sha256),ctr(aes))",
2333 .test
= alg_test_null
,
2336 .alg
= "authenc(hmac(sha256),rfc3686(ctr(aes)))",
2337 .test
= alg_test_null
,
2340 .alg
= "authenc(hmac(sha384),cbc(des))",
2341 .test
= alg_test_aead
,
2346 hmac_sha384_des_cbc_enc_tv_temp
,
2348 HMAC_SHA384_DES_CBC_ENC_TEST_VEC
2353 .alg
= "authenc(hmac(sha384),cbc(des3_ede))",
2354 .test
= alg_test_aead
,
2360 hmac_sha384_des3_ede_cbc_enc_tv_temp
,
2362 HMAC_SHA384_DES3_EDE_CBC_ENC_TEST_VEC
2367 .alg
= "authenc(hmac(sha384),ctr(aes))",
2368 .test
= alg_test_null
,
2371 .alg
= "authenc(hmac(sha384),rfc3686(ctr(aes)))",
2372 .test
= alg_test_null
,
2375 .alg
= "authenc(hmac(sha512),cbc(aes))",
2377 .test
= alg_test_aead
,
2382 hmac_sha512_aes_cbc_enc_tv_temp
,
2384 HMAC_SHA512_AES_CBC_ENC_TEST_VEC
2389 .alg
= "authenc(hmac(sha512),cbc(des))",
2390 .test
= alg_test_aead
,
2395 hmac_sha512_des_cbc_enc_tv_temp
,
2397 HMAC_SHA512_DES_CBC_ENC_TEST_VEC
2402 .alg
= "authenc(hmac(sha512),cbc(des3_ede))",
2403 .test
= alg_test_aead
,
2409 hmac_sha512_des3_ede_cbc_enc_tv_temp
,
2411 HMAC_SHA512_DES3_EDE_CBC_ENC_TEST_VEC
2416 .alg
= "authenc(hmac(sha512),ctr(aes))",
2417 .test
= alg_test_null
,
2420 .alg
= "authenc(hmac(sha512),rfc3686(ctr(aes)))",
2421 .test
= alg_test_null
,
2425 .test
= alg_test_skcipher
,
2430 .vecs
= aes_cbc_enc_tv_template
,
2431 .count
= AES_CBC_ENC_TEST_VECTORS
2434 .vecs
= aes_cbc_dec_tv_template
,
2435 .count
= AES_CBC_DEC_TEST_VECTORS
2440 .alg
= "cbc(anubis)",
2441 .test
= alg_test_skcipher
,
2445 .vecs
= anubis_cbc_enc_tv_template
,
2446 .count
= ANUBIS_CBC_ENC_TEST_VECTORS
2449 .vecs
= anubis_cbc_dec_tv_template
,
2450 .count
= ANUBIS_CBC_DEC_TEST_VECTORS
2455 .alg
= "cbc(blowfish)",
2456 .test
= alg_test_skcipher
,
2460 .vecs
= bf_cbc_enc_tv_template
,
2461 .count
= BF_CBC_ENC_TEST_VECTORS
2464 .vecs
= bf_cbc_dec_tv_template
,
2465 .count
= BF_CBC_DEC_TEST_VECTORS
2470 .alg
= "cbc(camellia)",
2471 .test
= alg_test_skcipher
,
2475 .vecs
= camellia_cbc_enc_tv_template
,
2476 .count
= CAMELLIA_CBC_ENC_TEST_VECTORS
2479 .vecs
= camellia_cbc_dec_tv_template
,
2480 .count
= CAMELLIA_CBC_DEC_TEST_VECTORS
2485 .alg
= "cbc(cast5)",
2486 .test
= alg_test_skcipher
,
2490 .vecs
= cast5_cbc_enc_tv_template
,
2491 .count
= CAST5_CBC_ENC_TEST_VECTORS
2494 .vecs
= cast5_cbc_dec_tv_template
,
2495 .count
= CAST5_CBC_DEC_TEST_VECTORS
2500 .alg
= "cbc(cast6)",
2501 .test
= alg_test_skcipher
,
2505 .vecs
= cast6_cbc_enc_tv_template
,
2506 .count
= CAST6_CBC_ENC_TEST_VECTORS
2509 .vecs
= cast6_cbc_dec_tv_template
,
2510 .count
= CAST6_CBC_DEC_TEST_VECTORS
2516 .test
= alg_test_skcipher
,
2520 .vecs
= des_cbc_enc_tv_template
,
2521 .count
= DES_CBC_ENC_TEST_VECTORS
2524 .vecs
= des_cbc_dec_tv_template
,
2525 .count
= DES_CBC_DEC_TEST_VECTORS
2530 .alg
= "cbc(des3_ede)",
2531 .test
= alg_test_skcipher
,
2536 .vecs
= des3_ede_cbc_enc_tv_template
,
2537 .count
= DES3_EDE_CBC_ENC_TEST_VECTORS
2540 .vecs
= des3_ede_cbc_dec_tv_template
,
2541 .count
= DES3_EDE_CBC_DEC_TEST_VECTORS
2546 .alg
= "cbc(serpent)",
2547 .test
= alg_test_skcipher
,
2551 .vecs
= serpent_cbc_enc_tv_template
,
2552 .count
= SERPENT_CBC_ENC_TEST_VECTORS
2555 .vecs
= serpent_cbc_dec_tv_template
,
2556 .count
= SERPENT_CBC_DEC_TEST_VECTORS
2561 .alg
= "cbc(twofish)",
2562 .test
= alg_test_skcipher
,
2566 .vecs
= tf_cbc_enc_tv_template
,
2567 .count
= TF_CBC_ENC_TEST_VECTORS
2570 .vecs
= tf_cbc_dec_tv_template
,
2571 .count
= TF_CBC_DEC_TEST_VECTORS
2577 .test
= alg_test_aead
,
2582 .vecs
= aes_ccm_enc_tv_template
,
2583 .count
= AES_CCM_ENC_TEST_VECTORS
2586 .vecs
= aes_ccm_dec_tv_template
,
2587 .count
= AES_CCM_DEC_TEST_VECTORS
2593 .test
= alg_test_skcipher
,
2597 .vecs
= chacha20_enc_tv_template
,
2598 .count
= CHACHA20_ENC_TEST_VECTORS
2601 .vecs
= chacha20_enc_tv_template
,
2602 .count
= CHACHA20_ENC_TEST_VECTORS
2609 .test
= alg_test_hash
,
2612 .vecs
= aes_cmac128_tv_template
,
2613 .count
= CMAC_AES_TEST_VECTORS
2617 .alg
= "cmac(des3_ede)",
2619 .test
= alg_test_hash
,
2622 .vecs
= des3_ede_cmac64_tv_template
,
2623 .count
= CMAC_DES3_EDE_TEST_VECTORS
2627 .alg
= "compress_null",
2628 .test
= alg_test_null
,
2631 .test
= alg_test_hash
,
2634 .vecs
= crc32_tv_template
,
2635 .count
= CRC32_TEST_VECTORS
2640 .test
= alg_test_crc32c
,
2644 .vecs
= crc32c_tv_template
,
2645 .count
= CRC32C_TEST_VECTORS
2650 .test
= alg_test_hash
,
2654 .vecs
= crct10dif_tv_template
,
2655 .count
= CRCT10DIF_TEST_VECTORS
2659 .alg
= "cryptd(__driver-cbc-aes-aesni)",
2660 .test
= alg_test_null
,
2663 .alg
= "cryptd(__driver-cbc-camellia-aesni)",
2664 .test
= alg_test_null
,
2666 .alg
= "cryptd(__driver-cbc-camellia-aesni-avx2)",
2667 .test
= alg_test_null
,
2669 .alg
= "cryptd(__driver-cbc-serpent-avx2)",
2670 .test
= alg_test_null
,
2672 .alg
= "cryptd(__driver-ecb-aes-aesni)",
2673 .test
= alg_test_null
,
2676 .alg
= "cryptd(__driver-ecb-camellia-aesni)",
2677 .test
= alg_test_null
,
2679 .alg
= "cryptd(__driver-ecb-camellia-aesni-avx2)",
2680 .test
= alg_test_null
,
2682 .alg
= "cryptd(__driver-ecb-cast5-avx)",
2683 .test
= alg_test_null
,
2685 .alg
= "cryptd(__driver-ecb-cast6-avx)",
2686 .test
= alg_test_null
,
2688 .alg
= "cryptd(__driver-ecb-serpent-avx)",
2689 .test
= alg_test_null
,
2691 .alg
= "cryptd(__driver-ecb-serpent-avx2)",
2692 .test
= alg_test_null
,
2694 .alg
= "cryptd(__driver-ecb-serpent-sse2)",
2695 .test
= alg_test_null
,
2697 .alg
= "cryptd(__driver-ecb-twofish-avx)",
2698 .test
= alg_test_null
,
2700 .alg
= "cryptd(__driver-gcm-aes-aesni)",
2701 .test
= alg_test_null
,
2704 .alg
= "cryptd(__ghash-pclmulqdqni)",
2705 .test
= alg_test_null
,
2709 .test
= alg_test_skcipher
,
2714 .vecs
= aes_ctr_enc_tv_template
,
2715 .count
= AES_CTR_ENC_TEST_VECTORS
2718 .vecs
= aes_ctr_dec_tv_template
,
2719 .count
= AES_CTR_DEC_TEST_VECTORS
2724 .alg
= "ctr(blowfish)",
2725 .test
= alg_test_skcipher
,
2729 .vecs
= bf_ctr_enc_tv_template
,
2730 .count
= BF_CTR_ENC_TEST_VECTORS
2733 .vecs
= bf_ctr_dec_tv_template
,
2734 .count
= BF_CTR_DEC_TEST_VECTORS
2739 .alg
= "ctr(camellia)",
2740 .test
= alg_test_skcipher
,
2744 .vecs
= camellia_ctr_enc_tv_template
,
2745 .count
= CAMELLIA_CTR_ENC_TEST_VECTORS
2748 .vecs
= camellia_ctr_dec_tv_template
,
2749 .count
= CAMELLIA_CTR_DEC_TEST_VECTORS
2754 .alg
= "ctr(cast5)",
2755 .test
= alg_test_skcipher
,
2759 .vecs
= cast5_ctr_enc_tv_template
,
2760 .count
= CAST5_CTR_ENC_TEST_VECTORS
2763 .vecs
= cast5_ctr_dec_tv_template
,
2764 .count
= CAST5_CTR_DEC_TEST_VECTORS
2769 .alg
= "ctr(cast6)",
2770 .test
= alg_test_skcipher
,
2774 .vecs
= cast6_ctr_enc_tv_template
,
2775 .count
= CAST6_CTR_ENC_TEST_VECTORS
2778 .vecs
= cast6_ctr_dec_tv_template
,
2779 .count
= CAST6_CTR_DEC_TEST_VECTORS
2785 .test
= alg_test_skcipher
,
2789 .vecs
= des_ctr_enc_tv_template
,
2790 .count
= DES_CTR_ENC_TEST_VECTORS
2793 .vecs
= des_ctr_dec_tv_template
,
2794 .count
= DES_CTR_DEC_TEST_VECTORS
2799 .alg
= "ctr(des3_ede)",
2800 .test
= alg_test_skcipher
,
2804 .vecs
= des3_ede_ctr_enc_tv_template
,
2805 .count
= DES3_EDE_CTR_ENC_TEST_VECTORS
2808 .vecs
= des3_ede_ctr_dec_tv_template
,
2809 .count
= DES3_EDE_CTR_DEC_TEST_VECTORS
2814 .alg
= "ctr(serpent)",
2815 .test
= alg_test_skcipher
,
2819 .vecs
= serpent_ctr_enc_tv_template
,
2820 .count
= SERPENT_CTR_ENC_TEST_VECTORS
2823 .vecs
= serpent_ctr_dec_tv_template
,
2824 .count
= SERPENT_CTR_DEC_TEST_VECTORS
2829 .alg
= "ctr(twofish)",
2830 .test
= alg_test_skcipher
,
2834 .vecs
= tf_ctr_enc_tv_template
,
2835 .count
= TF_CTR_ENC_TEST_VECTORS
2838 .vecs
= tf_ctr_dec_tv_template
,
2839 .count
= TF_CTR_DEC_TEST_VECTORS
2844 .alg
= "cts(cbc(aes))",
2845 .test
= alg_test_skcipher
,
2849 .vecs
= cts_mode_enc_tv_template
,
2850 .count
= CTS_MODE_ENC_TEST_VECTORS
2853 .vecs
= cts_mode_dec_tv_template
,
2854 .count
= CTS_MODE_DEC_TEST_VECTORS
2860 .test
= alg_test_comp
,
2865 .vecs
= deflate_comp_tv_template
,
2866 .count
= DEFLATE_COMP_TEST_VECTORS
2869 .vecs
= deflate_decomp_tv_template
,
2870 .count
= DEFLATE_DECOMP_TEST_VECTORS
2876 .test
= alg_test_kpp
,
2880 .vecs
= dh_tv_template
,
2881 .count
= DH_TEST_VECTORS
2885 .alg
= "digest_null",
2886 .test
= alg_test_null
,
2888 .alg
= "drbg_nopr_ctr_aes128",
2889 .test
= alg_test_drbg
,
2893 .vecs
= drbg_nopr_ctr_aes128_tv_template
,
2894 .count
= ARRAY_SIZE(drbg_nopr_ctr_aes128_tv_template
)
2898 .alg
= "drbg_nopr_ctr_aes192",
2899 .test
= alg_test_drbg
,
2903 .vecs
= drbg_nopr_ctr_aes192_tv_template
,
2904 .count
= ARRAY_SIZE(drbg_nopr_ctr_aes192_tv_template
)
2908 .alg
= "drbg_nopr_ctr_aes256",
2909 .test
= alg_test_drbg
,
2913 .vecs
= drbg_nopr_ctr_aes256_tv_template
,
2914 .count
= ARRAY_SIZE(drbg_nopr_ctr_aes256_tv_template
)
2919 * There is no need to specifically test the DRBG with every
2920 * backend cipher -- covered by drbg_nopr_hmac_sha256 test
2922 .alg
= "drbg_nopr_hmac_sha1",
2924 .test
= alg_test_null
,
2926 .alg
= "drbg_nopr_hmac_sha256",
2927 .test
= alg_test_drbg
,
2931 .vecs
= drbg_nopr_hmac_sha256_tv_template
,
2933 ARRAY_SIZE(drbg_nopr_hmac_sha256_tv_template
)
2937 /* covered by drbg_nopr_hmac_sha256 test */
2938 .alg
= "drbg_nopr_hmac_sha384",
2940 .test
= alg_test_null
,
2942 .alg
= "drbg_nopr_hmac_sha512",
2943 .test
= alg_test_null
,
2946 .alg
= "drbg_nopr_sha1",
2948 .test
= alg_test_null
,
2950 .alg
= "drbg_nopr_sha256",
2951 .test
= alg_test_drbg
,
2955 .vecs
= drbg_nopr_sha256_tv_template
,
2956 .count
= ARRAY_SIZE(drbg_nopr_sha256_tv_template
)
2960 /* covered by drbg_nopr_sha256 test */
2961 .alg
= "drbg_nopr_sha384",
2963 .test
= alg_test_null
,
2965 .alg
= "drbg_nopr_sha512",
2967 .test
= alg_test_null
,
2969 .alg
= "drbg_pr_ctr_aes128",
2970 .test
= alg_test_drbg
,
2974 .vecs
= drbg_pr_ctr_aes128_tv_template
,
2975 .count
= ARRAY_SIZE(drbg_pr_ctr_aes128_tv_template
)
2979 /* covered by drbg_pr_ctr_aes128 test */
2980 .alg
= "drbg_pr_ctr_aes192",
2982 .test
= alg_test_null
,
2984 .alg
= "drbg_pr_ctr_aes256",
2986 .test
= alg_test_null
,
2988 .alg
= "drbg_pr_hmac_sha1",
2990 .test
= alg_test_null
,
2992 .alg
= "drbg_pr_hmac_sha256",
2993 .test
= alg_test_drbg
,
2997 .vecs
= drbg_pr_hmac_sha256_tv_template
,
2998 .count
= ARRAY_SIZE(drbg_pr_hmac_sha256_tv_template
)
3002 /* covered by drbg_pr_hmac_sha256 test */
3003 .alg
= "drbg_pr_hmac_sha384",
3005 .test
= alg_test_null
,
3007 .alg
= "drbg_pr_hmac_sha512",
3008 .test
= alg_test_null
,
3011 .alg
= "drbg_pr_sha1",
3013 .test
= alg_test_null
,
3015 .alg
= "drbg_pr_sha256",
3016 .test
= alg_test_drbg
,
3020 .vecs
= drbg_pr_sha256_tv_template
,
3021 .count
= ARRAY_SIZE(drbg_pr_sha256_tv_template
)
3025 /* covered by drbg_pr_sha256 test */
3026 .alg
= "drbg_pr_sha384",
3028 .test
= alg_test_null
,
3030 .alg
= "drbg_pr_sha512",
3032 .test
= alg_test_null
,
3034 .alg
= "ecb(__aes-aesni)",
3035 .test
= alg_test_null
,
3039 .test
= alg_test_skcipher
,
3044 .vecs
= aes_enc_tv_template
,
3045 .count
= AES_ENC_TEST_VECTORS
3048 .vecs
= aes_dec_tv_template
,
3049 .count
= AES_DEC_TEST_VECTORS
3054 .alg
= "ecb(anubis)",
3055 .test
= alg_test_skcipher
,
3059 .vecs
= anubis_enc_tv_template
,
3060 .count
= ANUBIS_ENC_TEST_VECTORS
3063 .vecs
= anubis_dec_tv_template
,
3064 .count
= ANUBIS_DEC_TEST_VECTORS
3070 .test
= alg_test_skcipher
,
3074 .vecs
= arc4_enc_tv_template
,
3075 .count
= ARC4_ENC_TEST_VECTORS
3078 .vecs
= arc4_dec_tv_template
,
3079 .count
= ARC4_DEC_TEST_VECTORS
3084 .alg
= "ecb(blowfish)",
3085 .test
= alg_test_skcipher
,
3089 .vecs
= bf_enc_tv_template
,
3090 .count
= BF_ENC_TEST_VECTORS
3093 .vecs
= bf_dec_tv_template
,
3094 .count
= BF_DEC_TEST_VECTORS
3099 .alg
= "ecb(camellia)",
3100 .test
= alg_test_skcipher
,
3104 .vecs
= camellia_enc_tv_template
,
3105 .count
= CAMELLIA_ENC_TEST_VECTORS
3108 .vecs
= camellia_dec_tv_template
,
3109 .count
= CAMELLIA_DEC_TEST_VECTORS
3114 .alg
= "ecb(cast5)",
3115 .test
= alg_test_skcipher
,
3119 .vecs
= cast5_enc_tv_template
,
3120 .count
= CAST5_ENC_TEST_VECTORS
3123 .vecs
= cast5_dec_tv_template
,
3124 .count
= CAST5_DEC_TEST_VECTORS
3129 .alg
= "ecb(cast6)",
3130 .test
= alg_test_skcipher
,
3134 .vecs
= cast6_enc_tv_template
,
3135 .count
= CAST6_ENC_TEST_VECTORS
3138 .vecs
= cast6_dec_tv_template
,
3139 .count
= CAST6_DEC_TEST_VECTORS
3144 .alg
= "ecb(cipher_null)",
3145 .test
= alg_test_null
,
3148 .test
= alg_test_skcipher
,
3152 .vecs
= des_enc_tv_template
,
3153 .count
= DES_ENC_TEST_VECTORS
3156 .vecs
= des_dec_tv_template
,
3157 .count
= DES_DEC_TEST_VECTORS
3162 .alg
= "ecb(des3_ede)",
3163 .test
= alg_test_skcipher
,
3168 .vecs
= des3_ede_enc_tv_template
,
3169 .count
= DES3_EDE_ENC_TEST_VECTORS
3172 .vecs
= des3_ede_dec_tv_template
,
3173 .count
= DES3_EDE_DEC_TEST_VECTORS
3178 .alg
= "ecb(fcrypt)",
3179 .test
= alg_test_skcipher
,
3183 .vecs
= fcrypt_pcbc_enc_tv_template
,
3187 .vecs
= fcrypt_pcbc_dec_tv_template
,
3193 .alg
= "ecb(khazad)",
3194 .test
= alg_test_skcipher
,
3198 .vecs
= khazad_enc_tv_template
,
3199 .count
= KHAZAD_ENC_TEST_VECTORS
3202 .vecs
= khazad_dec_tv_template
,
3203 .count
= KHAZAD_DEC_TEST_VECTORS
3209 .test
= alg_test_skcipher
,
3213 .vecs
= seed_enc_tv_template
,
3214 .count
= SEED_ENC_TEST_VECTORS
3217 .vecs
= seed_dec_tv_template
,
3218 .count
= SEED_DEC_TEST_VECTORS
3223 .alg
= "ecb(serpent)",
3224 .test
= alg_test_skcipher
,
3228 .vecs
= serpent_enc_tv_template
,
3229 .count
= SERPENT_ENC_TEST_VECTORS
3232 .vecs
= serpent_dec_tv_template
,
3233 .count
= SERPENT_DEC_TEST_VECTORS
3239 .test
= alg_test_skcipher
,
3243 .vecs
= tea_enc_tv_template
,
3244 .count
= TEA_ENC_TEST_VECTORS
3247 .vecs
= tea_dec_tv_template
,
3248 .count
= TEA_DEC_TEST_VECTORS
3253 .alg
= "ecb(tnepres)",
3254 .test
= alg_test_skcipher
,
3258 .vecs
= tnepres_enc_tv_template
,
3259 .count
= TNEPRES_ENC_TEST_VECTORS
3262 .vecs
= tnepres_dec_tv_template
,
3263 .count
= TNEPRES_DEC_TEST_VECTORS
3268 .alg
= "ecb(twofish)",
3269 .test
= alg_test_skcipher
,
3273 .vecs
= tf_enc_tv_template
,
3274 .count
= TF_ENC_TEST_VECTORS
3277 .vecs
= tf_dec_tv_template
,
3278 .count
= TF_DEC_TEST_VECTORS
3284 .test
= alg_test_skcipher
,
3288 .vecs
= xeta_enc_tv_template
,
3289 .count
= XETA_ENC_TEST_VECTORS
3292 .vecs
= xeta_dec_tv_template
,
3293 .count
= XETA_DEC_TEST_VECTORS
3299 .test
= alg_test_skcipher
,
3303 .vecs
= xtea_enc_tv_template
,
3304 .count
= XTEA_ENC_TEST_VECTORS
3307 .vecs
= xtea_dec_tv_template
,
3308 .count
= XTEA_DEC_TEST_VECTORS
3314 .test
= alg_test_kpp
,
3318 .vecs
= ecdh_tv_template
,
3319 .count
= ECDH_TEST_VECTORS
3324 .test
= alg_test_aead
,
3329 .vecs
= aes_gcm_enc_tv_template
,
3330 .count
= AES_GCM_ENC_TEST_VECTORS
3333 .vecs
= aes_gcm_dec_tv_template
,
3334 .count
= AES_GCM_DEC_TEST_VECTORS
3340 .test
= alg_test_hash
,
3344 .vecs
= ghash_tv_template
,
3345 .count
= GHASH_TEST_VECTORS
3349 .alg
= "hmac(crc32)",
3350 .test
= alg_test_hash
,
3353 .vecs
= bfin_crc_tv_template
,
3354 .count
= BFIN_CRC_TEST_VECTORS
3359 .test
= alg_test_hash
,
3362 .vecs
= hmac_md5_tv_template
,
3363 .count
= HMAC_MD5_TEST_VECTORS
3367 .alg
= "hmac(rmd128)",
3368 .test
= alg_test_hash
,
3371 .vecs
= hmac_rmd128_tv_template
,
3372 .count
= HMAC_RMD128_TEST_VECTORS
3376 .alg
= "hmac(rmd160)",
3377 .test
= alg_test_hash
,
3380 .vecs
= hmac_rmd160_tv_template
,
3381 .count
= HMAC_RMD160_TEST_VECTORS
3385 .alg
= "hmac(sha1)",
3386 .test
= alg_test_hash
,
3390 .vecs
= hmac_sha1_tv_template
,
3391 .count
= HMAC_SHA1_TEST_VECTORS
3395 .alg
= "hmac(sha224)",
3396 .test
= alg_test_hash
,
3400 .vecs
= hmac_sha224_tv_template
,
3401 .count
= HMAC_SHA224_TEST_VECTORS
3405 .alg
= "hmac(sha256)",
3406 .test
= alg_test_hash
,
3410 .vecs
= hmac_sha256_tv_template
,
3411 .count
= HMAC_SHA256_TEST_VECTORS
3415 .alg
= "hmac(sha3-224)",
3416 .test
= alg_test_hash
,
3420 .vecs
= hmac_sha3_224_tv_template
,
3421 .count
= HMAC_SHA3_224_TEST_VECTORS
3425 .alg
= "hmac(sha3-256)",
3426 .test
= alg_test_hash
,
3430 .vecs
= hmac_sha3_256_tv_template
,
3431 .count
= HMAC_SHA3_256_TEST_VECTORS
3435 .alg
= "hmac(sha3-384)",
3436 .test
= alg_test_hash
,
3440 .vecs
= hmac_sha3_384_tv_template
,
3441 .count
= HMAC_SHA3_384_TEST_VECTORS
3445 .alg
= "hmac(sha3-512)",
3446 .test
= alg_test_hash
,
3450 .vecs
= hmac_sha3_512_tv_template
,
3451 .count
= HMAC_SHA3_512_TEST_VECTORS
3455 .alg
= "hmac(sha384)",
3456 .test
= alg_test_hash
,
3460 .vecs
= hmac_sha384_tv_template
,
3461 .count
= HMAC_SHA384_TEST_VECTORS
3465 .alg
= "hmac(sha512)",
3466 .test
= alg_test_hash
,
3470 .vecs
= hmac_sha512_tv_template
,
3471 .count
= HMAC_SHA512_TEST_VECTORS
3475 .alg
= "jitterentropy_rng",
3477 .test
= alg_test_null
,
3480 .test
= alg_test_skcipher
,
3485 .vecs
= aes_kw_enc_tv_template
,
3486 .count
= ARRAY_SIZE(aes_kw_enc_tv_template
)
3489 .vecs
= aes_kw_dec_tv_template
,
3490 .count
= ARRAY_SIZE(aes_kw_dec_tv_template
)
3496 .test
= alg_test_skcipher
,
3500 .vecs
= aes_lrw_enc_tv_template
,
3501 .count
= AES_LRW_ENC_TEST_VECTORS
3504 .vecs
= aes_lrw_dec_tv_template
,
3505 .count
= AES_LRW_DEC_TEST_VECTORS
3510 .alg
= "lrw(camellia)",
3511 .test
= alg_test_skcipher
,
3515 .vecs
= camellia_lrw_enc_tv_template
,
3516 .count
= CAMELLIA_LRW_ENC_TEST_VECTORS
3519 .vecs
= camellia_lrw_dec_tv_template
,
3520 .count
= CAMELLIA_LRW_DEC_TEST_VECTORS
3525 .alg
= "lrw(cast6)",
3526 .test
= alg_test_skcipher
,
3530 .vecs
= cast6_lrw_enc_tv_template
,
3531 .count
= CAST6_LRW_ENC_TEST_VECTORS
3534 .vecs
= cast6_lrw_dec_tv_template
,
3535 .count
= CAST6_LRW_DEC_TEST_VECTORS
3540 .alg
= "lrw(serpent)",
3541 .test
= alg_test_skcipher
,
3545 .vecs
= serpent_lrw_enc_tv_template
,
3546 .count
= SERPENT_LRW_ENC_TEST_VECTORS
3549 .vecs
= serpent_lrw_dec_tv_template
,
3550 .count
= SERPENT_LRW_DEC_TEST_VECTORS
3555 .alg
= "lrw(twofish)",
3556 .test
= alg_test_skcipher
,
3560 .vecs
= tf_lrw_enc_tv_template
,
3561 .count
= TF_LRW_ENC_TEST_VECTORS
3564 .vecs
= tf_lrw_dec_tv_template
,
3565 .count
= TF_LRW_DEC_TEST_VECTORS
3571 .test
= alg_test_comp
,
3576 .vecs
= lz4_comp_tv_template
,
3577 .count
= LZ4_COMP_TEST_VECTORS
3580 .vecs
= lz4_decomp_tv_template
,
3581 .count
= LZ4_DECOMP_TEST_VECTORS
3587 .test
= alg_test_comp
,
3592 .vecs
= lz4hc_comp_tv_template
,
3593 .count
= LZ4HC_COMP_TEST_VECTORS
3596 .vecs
= lz4hc_decomp_tv_template
,
3597 .count
= LZ4HC_DECOMP_TEST_VECTORS
3603 .test
= alg_test_comp
,
3608 .vecs
= lzo_comp_tv_template
,
3609 .count
= LZO_COMP_TEST_VECTORS
3612 .vecs
= lzo_decomp_tv_template
,
3613 .count
= LZO_DECOMP_TEST_VECTORS
3619 .test
= alg_test_hash
,
3622 .vecs
= md4_tv_template
,
3623 .count
= MD4_TEST_VECTORS
3628 .test
= alg_test_hash
,
3631 .vecs
= md5_tv_template
,
3632 .count
= MD5_TEST_VECTORS
3636 .alg
= "michael_mic",
3637 .test
= alg_test_hash
,
3640 .vecs
= michael_mic_tv_template
,
3641 .count
= MICHAEL_MIC_TEST_VECTORS
3646 .test
= alg_test_skcipher
,
3651 .vecs
= aes_ofb_enc_tv_template
,
3652 .count
= AES_OFB_ENC_TEST_VECTORS
3655 .vecs
= aes_ofb_dec_tv_template
,
3656 .count
= AES_OFB_DEC_TEST_VECTORS
3661 .alg
= "pcbc(fcrypt)",
3662 .test
= alg_test_skcipher
,
3666 .vecs
= fcrypt_pcbc_enc_tv_template
,
3667 .count
= FCRYPT_ENC_TEST_VECTORS
3670 .vecs
= fcrypt_pcbc_dec_tv_template
,
3671 .count
= FCRYPT_DEC_TEST_VECTORS
3677 .test
= alg_test_hash
,
3680 .vecs
= poly1305_tv_template
,
3681 .count
= POLY1305_TEST_VECTORS
3685 .alg
= "rfc3686(ctr(aes))",
3686 .test
= alg_test_skcipher
,
3691 .vecs
= aes_ctr_rfc3686_enc_tv_template
,
3692 .count
= AES_CTR_3686_ENC_TEST_VECTORS
3695 .vecs
= aes_ctr_rfc3686_dec_tv_template
,
3696 .count
= AES_CTR_3686_DEC_TEST_VECTORS
3701 .alg
= "rfc4106(gcm(aes))",
3702 .test
= alg_test_aead
,
3707 .vecs
= aes_gcm_rfc4106_enc_tv_template
,
3708 .count
= AES_GCM_4106_ENC_TEST_VECTORS
3711 .vecs
= aes_gcm_rfc4106_dec_tv_template
,
3712 .count
= AES_GCM_4106_DEC_TEST_VECTORS
3717 .alg
= "rfc4309(ccm(aes))",
3718 .test
= alg_test_aead
,
3723 .vecs
= aes_ccm_rfc4309_enc_tv_template
,
3724 .count
= AES_CCM_4309_ENC_TEST_VECTORS
3727 .vecs
= aes_ccm_rfc4309_dec_tv_template
,
3728 .count
= AES_CCM_4309_DEC_TEST_VECTORS
3733 .alg
= "rfc4543(gcm(aes))",
3734 .test
= alg_test_aead
,
3738 .vecs
= aes_gcm_rfc4543_enc_tv_template
,
3739 .count
= AES_GCM_4543_ENC_TEST_VECTORS
3742 .vecs
= aes_gcm_rfc4543_dec_tv_template
,
3743 .count
= AES_GCM_4543_DEC_TEST_VECTORS
3748 .alg
= "rfc7539(chacha20,poly1305)",
3749 .test
= alg_test_aead
,
3753 .vecs
= rfc7539_enc_tv_template
,
3754 .count
= RFC7539_ENC_TEST_VECTORS
3757 .vecs
= rfc7539_dec_tv_template
,
3758 .count
= RFC7539_DEC_TEST_VECTORS
3763 .alg
= "rfc7539esp(chacha20,poly1305)",
3764 .test
= alg_test_aead
,
3768 .vecs
= rfc7539esp_enc_tv_template
,
3769 .count
= RFC7539ESP_ENC_TEST_VECTORS
3772 .vecs
= rfc7539esp_dec_tv_template
,
3773 .count
= RFC7539ESP_DEC_TEST_VECTORS
3779 .test
= alg_test_hash
,
3782 .vecs
= rmd128_tv_template
,
3783 .count
= RMD128_TEST_VECTORS
3788 .test
= alg_test_hash
,
3791 .vecs
= rmd160_tv_template
,
3792 .count
= RMD160_TEST_VECTORS
3797 .test
= alg_test_hash
,
3800 .vecs
= rmd256_tv_template
,
3801 .count
= RMD256_TEST_VECTORS
3806 .test
= alg_test_hash
,
3809 .vecs
= rmd320_tv_template
,
3810 .count
= RMD320_TEST_VECTORS
3815 .test
= alg_test_akcipher
,
3819 .vecs
= rsa_tv_template
,
3820 .count
= RSA_TEST_VECTORS
3825 .test
= alg_test_skcipher
,
3829 .vecs
= salsa20_stream_enc_tv_template
,
3830 .count
= SALSA20_STREAM_ENC_TEST_VECTORS
3836 .test
= alg_test_hash
,
3840 .vecs
= sha1_tv_template
,
3841 .count
= SHA1_TEST_VECTORS
3846 .test
= alg_test_hash
,
3850 .vecs
= sha224_tv_template
,
3851 .count
= SHA224_TEST_VECTORS
3856 .test
= alg_test_hash
,
3860 .vecs
= sha256_tv_template
,
3861 .count
= SHA256_TEST_VECTORS
3866 .test
= alg_test_hash
,
3870 .vecs
= sha3_224_tv_template
,
3871 .count
= SHA3_224_TEST_VECTORS
3876 .test
= alg_test_hash
,
3880 .vecs
= sha3_256_tv_template
,
3881 .count
= SHA3_256_TEST_VECTORS
3886 .test
= alg_test_hash
,
3890 .vecs
= sha3_384_tv_template
,
3891 .count
= SHA3_384_TEST_VECTORS
3896 .test
= alg_test_hash
,
3900 .vecs
= sha3_512_tv_template
,
3901 .count
= SHA3_512_TEST_VECTORS
3906 .test
= alg_test_hash
,
3910 .vecs
= sha384_tv_template
,
3911 .count
= SHA384_TEST_VECTORS
3916 .test
= alg_test_hash
,
3920 .vecs
= sha512_tv_template
,
3921 .count
= SHA512_TEST_VECTORS
3926 .test
= alg_test_hash
,
3929 .vecs
= tgr128_tv_template
,
3930 .count
= TGR128_TEST_VECTORS
3935 .test
= alg_test_hash
,
3938 .vecs
= tgr160_tv_template
,
3939 .count
= TGR160_TEST_VECTORS
3944 .test
= alg_test_hash
,
3947 .vecs
= tgr192_tv_template
,
3948 .count
= TGR192_TEST_VECTORS
3953 .test
= alg_test_hash
,
3956 .vecs
= aes_vmac128_tv_template
,
3957 .count
= VMAC_AES_TEST_VECTORS
3962 .test
= alg_test_hash
,
3965 .vecs
= wp256_tv_template
,
3966 .count
= WP256_TEST_VECTORS
3971 .test
= alg_test_hash
,
3974 .vecs
= wp384_tv_template
,
3975 .count
= WP384_TEST_VECTORS
3980 .test
= alg_test_hash
,
3983 .vecs
= wp512_tv_template
,
3984 .count
= WP512_TEST_VECTORS
3989 .test
= alg_test_hash
,
3992 .vecs
= aes_xcbc128_tv_template
,
3993 .count
= XCBC_AES_TEST_VECTORS
3998 .test
= alg_test_skcipher
,
4003 .vecs
= aes_xts_enc_tv_template
,
4004 .count
= AES_XTS_ENC_TEST_VECTORS
4007 .vecs
= aes_xts_dec_tv_template
,
4008 .count
= AES_XTS_DEC_TEST_VECTORS
4013 .alg
= "xts(camellia)",
4014 .test
= alg_test_skcipher
,
4018 .vecs
= camellia_xts_enc_tv_template
,
4019 .count
= CAMELLIA_XTS_ENC_TEST_VECTORS
4022 .vecs
= camellia_xts_dec_tv_template
,
4023 .count
= CAMELLIA_XTS_DEC_TEST_VECTORS
4028 .alg
= "xts(cast6)",
4029 .test
= alg_test_skcipher
,
4033 .vecs
= cast6_xts_enc_tv_template
,
4034 .count
= CAST6_XTS_ENC_TEST_VECTORS
4037 .vecs
= cast6_xts_dec_tv_template
,
4038 .count
= CAST6_XTS_DEC_TEST_VECTORS
4043 .alg
= "xts(serpent)",
4044 .test
= alg_test_skcipher
,
4048 .vecs
= serpent_xts_enc_tv_template
,
4049 .count
= SERPENT_XTS_ENC_TEST_VECTORS
4052 .vecs
= serpent_xts_dec_tv_template
,
4053 .count
= SERPENT_XTS_DEC_TEST_VECTORS
4058 .alg
= "xts(twofish)",
4059 .test
= alg_test_skcipher
,
4063 .vecs
= tf_xts_enc_tv_template
,
4064 .count
= TF_XTS_ENC_TEST_VECTORS
4067 .vecs
= tf_xts_dec_tv_template
,
4068 .count
= TF_XTS_DEC_TEST_VECTORS
4075 static bool alg_test_descs_checked
;
4077 static void alg_test_descs_check_order(void)
4081 /* only check once */
4082 if (alg_test_descs_checked
)
4085 alg_test_descs_checked
= true;
4087 for (i
= 1; i
< ARRAY_SIZE(alg_test_descs
); i
++) {
4088 int diff
= strcmp(alg_test_descs
[i
- 1].alg
,
4089 alg_test_descs
[i
].alg
);
4091 if (WARN_ON(diff
> 0)) {
4092 pr_warn("testmgr: alg_test_descs entries in wrong order: '%s' before '%s'\n",
4093 alg_test_descs
[i
- 1].alg
,
4094 alg_test_descs
[i
].alg
);
4097 if (WARN_ON(diff
== 0)) {
4098 pr_warn("testmgr: duplicate alg_test_descs entry: '%s'\n",
4099 alg_test_descs
[i
].alg
);
4104 static int alg_find_test(const char *alg
)
4107 int end
= ARRAY_SIZE(alg_test_descs
);
4109 while (start
< end
) {
4110 int i
= (start
+ end
) / 2;
4111 int diff
= strcmp(alg_test_descs
[i
].alg
, alg
);
4129 int alg_test(const char *driver
, const char *alg
, u32 type
, u32 mask
)
4135 if (!fips_enabled
&& notests
) {
4136 printk_once(KERN_INFO
"alg: self-tests disabled\n");
4140 alg_test_descs_check_order();
4142 if ((type
& CRYPTO_ALG_TYPE_MASK
) == CRYPTO_ALG_TYPE_CIPHER
) {
4143 char nalg
[CRYPTO_MAX_ALG_NAME
];
4145 if (snprintf(nalg
, sizeof(nalg
), "ecb(%s)", alg
) >=
4147 return -ENAMETOOLONG
;
4149 i
= alg_find_test(nalg
);
4153 if (fips_enabled
&& !alg_test_descs
[i
].fips_allowed
)
4156 rc
= alg_test_cipher(alg_test_descs
+ i
, driver
, type
, mask
);
4160 i
= alg_find_test(alg
);
4161 j
= alg_find_test(driver
);
4165 if (fips_enabled
&& ((i
>= 0 && !alg_test_descs
[i
].fips_allowed
) ||
4166 (j
>= 0 && !alg_test_descs
[j
].fips_allowed
)))
4171 rc
|= alg_test_descs
[i
].test(alg_test_descs
+ i
, driver
,
4173 if (j
>= 0 && j
!= i
)
4174 rc
|= alg_test_descs
[j
].test(alg_test_descs
+ j
, driver
,
4178 if (fips_enabled
&& rc
)
4179 panic("%s: %s alg self test failed in fips mode!\n", driver
, alg
);
4181 if (fips_enabled
&& !rc
)
4182 pr_info("alg: self-tests for %s (%s) passed\n", driver
, alg
);
4187 printk(KERN_INFO
"alg: No test for %s (%s)\n", alg
, driver
);
4193 #endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */
4195 EXPORT_SYMBOL_GPL(alg_test
);