1 // SPDX-License-Identifier: GPL-2.0-or-later 1
2 /*
3 * Algorithm testing framework and tests.
4 *
5 * Copyright (c) 2002 James Morris <jmorris@in
6 * Copyright (c) 2002 Jean-Francois Dive <jef@
7 * Copyright (c) 2007 Nokia Siemens Networks
8 * Copyright (c) 2008 Herbert Xu <herbert@gond
9 * Copyright (c) 2019 Google LLC
10 *
11 * Updated RFC4106 AES-GCM testing.
12 * Authors: Aidan O'Mahony (aidan.o.mahony@
13 * Adrian Hoban <adrian.hoban@inte
14 * Gabriele Paoloni <gabriele.paol
15 * Tadeusz Struk (tadeusz.struk@in
16 * Copyright (c) 2010, Intel Corporation.
17 */
18
19 #include <crypto/aead.h>
20 #include <crypto/hash.h>
21 #include <crypto/skcipher.h>
22 #include <linux/err.h>
23 #include <linux/fips.h>
24 #include <linux/module.h>
25 #include <linux/once.h>
26 #include <linux/random.h>
27 #include <linux/scatterlist.h>
28 #include <linux/slab.h>
29 #include <linux/string.h>
30 #include <linux/uio.h>
31 #include <crypto/rng.h>
32 #include <crypto/drbg.h>
33 #include <crypto/akcipher.h>
34 #include <crypto/kpp.h>
35 #include <crypto/acompress.h>
36 #include <crypto/internal/cipher.h>
37 #include <crypto/internal/simd.h>
38
39 #include "internal.h"
40
41 MODULE_IMPORT_NS(CRYPTO_INTERNAL);
42
43 static bool notests;
44 module_param(notests, bool, 0644);
45 MODULE_PARM_DESC(notests, "disable crypto self
46
47 static bool panic_on_fail;
48 module_param(panic_on_fail, bool, 0444);
49
50 #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS
51 static bool noextratests;
52 module_param(noextratests, bool, 0644);
53 MODULE_PARM_DESC(noextratests, "disable expens
54
55 static unsigned int fuzz_iterations = 100;
56 module_param(fuzz_iterations, uint, 0644);
57 MODULE_PARM_DESC(fuzz_iterations, "number of f
58 #endif
59
60 #ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
61
62 /* a perfect nop */
63 int alg_test(const char *driver, const char *a
64 {
65 return 0;
66 }
67
68 #else
69
70 #include "testmgr.h"
71
72 /*
73 * Need slab memory for testing (size in numbe
74 */
75 #define XBUFSIZE 8
76
77 /*
78 * Used by test_cipher()
79 */
80 #define ENCRYPT 1
81 #define DECRYPT 0
82
83 struct aead_test_suite {
84 const struct aead_testvec *vecs;
85 unsigned int count;
86
87 /*
88 * Set if trying to decrypt an inauthe
89 * algorithm might result in EINVAL ra
90 * validation the algorithm does on th
91 */
92 unsigned int einval_allowed : 1;
93
94 /*
95 * Set if this algorithm requires that
96 * the AAD buffer, in addition to bein
97 * behavior when the two IV copies dif
98 */
99 unsigned int aad_iv : 1;
100 };
101
102 struct cipher_test_suite {
103 const struct cipher_testvec *vecs;
104 unsigned int count;
105 };
106
107 struct comp_test_suite {
108 struct {
109 const struct comp_testvec *vec
110 unsigned int count;
111 } comp, decomp;
112 };
113
114 struct hash_test_suite {
115 const struct hash_testvec *vecs;
116 unsigned int count;
117 };
118
119 struct cprng_test_suite {
120 const struct cprng_testvec *vecs;
121 unsigned int count;
122 };
123
124 struct drbg_test_suite {
125 const struct drbg_testvec *vecs;
126 unsigned int count;
127 };
128
129 struct akcipher_test_suite {
130 const struct akcipher_testvec *vecs;
131 unsigned int count;
132 };
133
134 struct kpp_test_suite {
135 const struct kpp_testvec *vecs;
136 unsigned int count;
137 };
138
139 struct alg_test_desc {
140 const char *alg;
141 const char *generic_driver;
142 int (*test)(const struct alg_test_desc
143 u32 type, u32 mask);
144 int fips_allowed; /* set if alg
145
146 union {
147 struct aead_test_suite aead;
148 struct cipher_test_suite ciphe
149 struct comp_test_suite comp;
150 struct hash_test_suite hash;
151 struct cprng_test_suite cprng;
152 struct drbg_test_suite drbg;
153 struct akcipher_test_suite akc
154 struct kpp_test_suite kpp;
155 } suite;
156 };
157
158 static void hexdump(unsigned char *buf, unsign
159 {
160 print_hex_dump(KERN_CONT, "", DUMP_PRE
161 16, 1,
162 buf, len, false);
163 }
164
165 static int __testmgr_alloc_buf(char *buf[XBUFS
166 {
167 int i;
168
169 for (i = 0; i < XBUFSIZE; i++) {
170 buf[i] = (char *)__get_free_pa
171 if (!buf[i])
172 goto err_free_buf;
173 }
174
175 return 0;
176
177 err_free_buf:
178 while (i-- > 0)
179 free_pages((unsigned long)buf[
180
181 return -ENOMEM;
182 }
183
184 static int testmgr_alloc_buf(char *buf[XBUFSIZ
185 {
186 return __testmgr_alloc_buf(buf, 0);
187 }
188
189 static void __testmgr_free_buf(char *buf[XBUFS
190 {
191 int i;
192
193 for (i = 0; i < XBUFSIZE; i++)
194 free_pages((unsigned long)buf[
195 }
196
197 static void testmgr_free_buf(char *buf[XBUFSIZ
198 {
199 __testmgr_free_buf(buf, 0);
200 }
201
202 #define TESTMGR_POISON_BYTE 0xfe
203 #define TESTMGR_POISON_LEN 16
204
205 static inline void testmgr_poison(void *addr,
206 {
207 memset(addr, TESTMGR_POISON_BYTE, len)
208 }
209
210 /* Is the memory region still fully poisoned?
211 static inline bool testmgr_is_poison(const voi
212 {
213 return memchr_inv(addr, TESTMGR_POISON
214 }
215
216 /* flush type for hash algorithms */
217 enum flush_type {
218 /* merge with update of previous buffe
219 FLUSH_TYPE_NONE = 0,
220
221 /* update with previous buffer(s) befo
222 FLUSH_TYPE_FLUSH,
223
224 /* likewise, but also export and re-im
225 FLUSH_TYPE_REIMPORT,
226 };
227
228 /* finalization function for hash algorithms *
229 enum finalization_type {
230 FINALIZATION_TYPE_FINAL, /* use
231 FINALIZATION_TYPE_FINUP, /* use
232 FINALIZATION_TYPE_DIGEST, /* use
233 };
234
235 /*
236 * Whether the crypto operation will occur in-
237 * source and destination scatterlist pointers
238 * req->dst), or whether they'll merely point
239 * (req->src != req->dst) that reference the s
240 *
241 * This is only relevant for algorithm types t
242 */
243 enum inplace_mode {
244 OUT_OF_PLACE,
245 INPLACE_ONE_SGLIST,
246 INPLACE_TWO_SGLISTS,
247 };
248
249 #define TEST_SG_TOTAL 10000
250
251 /**
252 * struct test_sg_division - description of a
253 *
254 * This struct describes one entry of a scatte
255 * crypto test vector.
256 *
257 * @proportion_of_total: length of this chunk
258 * given as a proportion
259 * scales to fit any tes
260 * @offset: byte offset into a 2-page buffer a
261 * @offset_relative_to_alignmask: if true, add
262 * @offset
263 * @flush_type: for hashes, whether an update(
264 * continuing to accumulate data
265 * @nosimd: if doing the pending update(), do
266 */
267 struct test_sg_division {
268 unsigned int proportion_of_total;
269 unsigned int offset;
270 bool offset_relative_to_alignmask;
271 enum flush_type flush_type;
272 bool nosimd;
273 };
274
275 /**
276 * struct testvec_config - configuration for t
277 *
278 * This struct describes the data layout and o
279 * crypto test vector can be tested.
280 *
281 * @name: name of this config, logged for debu
282 * @inplace_mode: whether and how to operate o
283 * @req_flags: extra request_flags, e.g. CRYPT
284 * @src_divs: description of how to arrange th
285 * @dst_divs: description of how to arrange th
286 * for the algorithm type. Default
287 * @iv_offset: misalignment of the IV in the r
288 * where 0 is aligned to a 2*(MAX_
289 * @iv_offset_relative_to_alignmask: if true,
290 * the @iv_o
291 * @key_offset: misalignment of the key, where
292 * @key_offset_relative_to_alignmask: if true,
293 * the @key
294 * @finalization_type: what finalization funct
295 * @nosimd: execute with SIMD disabled? Requi
296 * This applies to the parts of the o
297 * individually by @nosimd_setkey or
298 * @nosimd_setkey: set the key (if applicable)
299 * !CRYPTO_TFM_REQ_MAY_SLEEP.
300 */
301 struct testvec_config {
302 const char *name;
303 enum inplace_mode inplace_mode;
304 u32 req_flags;
305 struct test_sg_division src_divs[XBUFS
306 struct test_sg_division dst_divs[XBUFS
307 unsigned int iv_offset;
308 unsigned int key_offset;
309 bool iv_offset_relative_to_alignmask;
310 bool key_offset_relative_to_alignmask;
311 enum finalization_type finalization_ty
312 bool nosimd;
313 bool nosimd_setkey;
314 };
315
316 #define TESTVEC_CONFIG_NAMELEN 192
317
318 /*
319 * The following are the lists of testvec_conf
320 * type when the basic crypto self-tests are e
321 * CONFIG_CRYPTO_MANAGER_DISABLE_TESTS is unse
322 * coverage, while keeping the test time much
323 * so that the basic tests can be enabled in a
324 */
325
326 /* Configs for skciphers and aeads */
327 static const struct testvec_config default_cip
328 {
329 .name = "in-place (one sglist)
330 .inplace_mode = INPLACE_ONE_SG
331 .src_divs = { { .proportion_of
332 }, {
333 .name = "in-place (two sglists
334 .inplace_mode = INPLACE_TWO_SG
335 .src_divs = { { .proportion_of
336 }, {
337 .name = "out-of-place",
338 .inplace_mode = OUT_OF_PLACE,
339 .src_divs = { { .proportion_of
340 }, {
341 .name = "unaligned buffer, off
342 .src_divs = { { .proportion_of
343 .iv_offset = 1,
344 .key_offset = 1,
345 }, {
346 .name = "buffer aligned only t
347 .src_divs = {
348 {
349 .proportion_of
350 .offset = 1,
351 .offset_relati
352 },
353 },
354 .iv_offset = 1,
355 .iv_offset_relative_to_alignma
356 .key_offset = 1,
357 .key_offset_relative_to_alignm
358 }, {
359 .name = "two even aligned spli
360 .src_divs = {
361 { .proportion_of_total
362 { .proportion_of_total
363 },
364 }, {
365 .name = "one src, two even spl
366 .inplace_mode = OUT_OF_PLACE,
367 .src_divs = { { .proportion_of
368 .dst_divs = {
369 { .proportion_of_total
370 { .proportion_of_total
371 },
372 }, {
373 .name = "uneven misaligned spl
374 .req_flags = CRYPTO_TFM_REQ_MA
375 .src_divs = {
376 { .proportion_of_total
377 { .proportion_of_total
378 { .proportion_of_total
379 },
380 .iv_offset = 3,
381 .key_offset = 3,
382 }, {
383 .name = "misaligned splits cro
384 .inplace_mode = INPLACE_ONE_SG
385 .src_divs = {
386 {
387 .proportion_of
388 .offset = PAGE
389 }, {
390 .proportion_of
391 .offset = PAGE
392 },
393 },
394 }
395 };
396
397 static const struct testvec_config default_has
398 {
399 .name = "init+update+final ali
400 .src_divs = { { .proportion_of
401 .finalization_type = FINALIZAT
402 }, {
403 .name = "init+finup aligned bu
404 .src_divs = { { .proportion_of
405 .finalization_type = FINALIZAT
406 }, {
407 .name = "digest aligned buffer
408 .src_divs = { { .proportion_of
409 .finalization_type = FINALIZAT
410 }, {
411 .name = "init+update+final mis
412 .src_divs = { { .proportion_of
413 .finalization_type = FINALIZAT
414 .key_offset = 1,
415 }, {
416 .name = "digest misaligned buf
417 .src_divs = {
418 {
419 .proportion_of
420 .offset = 1,
421 },
422 },
423 .finalization_type = FINALIZAT
424 .key_offset = 1,
425 }, {
426 .name = "init+update+update+fi
427 .src_divs = {
428 { .proportion_of_total
429 {
430 .proportion_of
431 .flush_type =
432 },
433 },
434 .finalization_type = FINALIZAT
435 }, {
436 .name = "digest uneven misalig
437 .req_flags = CRYPTO_TFM_REQ_MA
438 .src_divs = {
439 { .proportion_of_total
440 { .proportion_of_total
441 { .proportion_of_total
442 },
443 .finalization_type = FINALIZAT
444 }, {
445 .name = "digest misaligned spl
446 .src_divs = {
447 {
448 .proportion_of
449 .offset = PAGE
450 }, {
451 .proportion_of
452 .offset = PAGE
453 },
454 },
455 .finalization_type = FINALIZAT
456 }, {
457 .name = "import/export",
458 .src_divs = {
459 {
460 .proportion_of
461 .flush_type =
462 }, {
463 .proportion_of
464 .flush_type =
465 },
466 },
467 .finalization_type = FINALIZAT
468 }
469 };
470
471 static unsigned int count_test_sg_divisions(co
472 {
473 unsigned int remaining = TEST_SG_TOTAL
474 unsigned int ndivs = 0;
475
476 do {
477 remaining -= divs[ndivs++].pro
478 } while (remaining);
479
480 return ndivs;
481 }
482
483 #define SGDIVS_HAVE_FLUSHES BIT(0)
484 #define SGDIVS_HAVE_NOSIMD BIT(1)
485
486 static bool valid_sg_divisions(const struct te
487 unsigned int co
488 {
489 unsigned int total = 0;
490 unsigned int i;
491
492 for (i = 0; i < count && total != TEST
493 if (divs[i].proportion_of_tota
494 divs[i].proportion_of_tota
495 return false;
496 total += divs[i].proportion_of
497 if (divs[i].flush_type != FLUS
498 *flags_ret |= SGDIVS_H
499 if (divs[i].nosimd)
500 *flags_ret |= SGDIVS_H
501 }
502 return total == TEST_SG_TOTAL &&
503 memchr_inv(&divs[i], 0, (count
504 }
505
506 /*
507 * Check whether the given testvec_config is v
508 * since every testvec_config should be valid,
509 * don't unknowingly add broken configs that d
510 */
511 static bool valid_testvec_config(const struct
512 {
513 int flags = 0;
514
515 if (cfg->name == NULL)
516 return false;
517
518 if (!valid_sg_divisions(cfg->src_divs,
519 &flags))
520 return false;
521
522 if (cfg->dst_divs[0].proportion_of_tot
523 if (!valid_sg_divisions(cfg->d
524 ARRAY_
525 return false;
526 } else {
527 if (memchr_inv(cfg->dst_divs,
528 return false;
529 /* defaults to dst_divs=src_di
530 }
531
532 if (cfg->iv_offset +
533 (cfg->iv_offset_relative_to_alignm
534 MAX_ALGAPI_ALIGNMASK + 1)
535 return false;
536
537 if ((flags & (SGDIVS_HAVE_FLUSHES | SG
538 cfg->finalization_type == FINALIZA
539 return false;
540
541 if ((cfg->nosimd || cfg->nosimd_setkey
542 (flags & SGDIVS_HAVE_NOSIMD)) &&
543 (cfg->req_flags & CRYPTO_TFM_REQ_M
544 return false;
545
546 return true;
547 }
548
549 struct test_sglist {
550 char *bufs[XBUFSIZE];
551 struct scatterlist sgl[XBUFSIZE];
552 struct scatterlist sgl_saved[XBUFSIZE]
553 struct scatterlist *sgl_ptr;
554 unsigned int nents;
555 };
556
557 static int init_test_sglist(struct test_sglist
558 {
559 return __testmgr_alloc_buf(tsgl->bufs,
560 }
561
562 static void destroy_test_sglist(struct test_sg
563 {
564 return __testmgr_free_buf(tsgl->bufs,
565 }
566
567 /**
568 * build_test_sglist() - build a scatterlist f
569 *
570 * @tsgl: the scatterlist to build. @tsgl->bu
571 * buffers which the scatterlist @tsgl-
572 * @divs: the layout specification on which th
573 * @alignmask: the algorithm's alignmask
574 * @total_len: the total length of the scatter
575 * @data: if non-NULL, the buffers will be fil
576 * Otherwise the buffers will be poison
577 * past the end of each buffer will be
578 * @out_divs: if non-NULL, the test_sg_divisio
579 * corresponds will be returned her
580 * that divisions resolving to a le
581 * not included in the scatterlist.
582 *
583 * Return: 0 or a -errno value
584 */
585 static int build_test_sglist(struct test_sglis
586 const struct test
587 const unsigned in
588 const unsigned in
589 struct iov_iter *
590 const struct test
591 {
592 struct {
593 const struct test_sg_division
594 size_t length;
595 } partitions[XBUFSIZE];
596 const unsigned int ndivs = count_test_
597 unsigned int len_remaining = total_len
598 unsigned int i;
599
600 BUILD_BUG_ON(ARRAY_SIZE(partitions) !=
601 if (WARN_ON(ndivs > ARRAY_SIZE(partiti
602 return -EINVAL;
603
604 /* Calculate the (div, length) pairs *
605 tsgl->nents = 0;
606 for (i = 0; i < ndivs; i++) {
607 unsigned int len_this_sg =
608 min(len_remaining,
609 (total_len * divs[
610 TEST_SG_TOTAL / 2
611
612 if (len_this_sg != 0) {
613 partitions[tsgl->nents
614 partitions[tsgl->nents
615 tsgl->nents++;
616 len_remaining -= len_t
617 }
618 }
619 if (tsgl->nents == 0) {
620 partitions[tsgl->nents].div =
621 partitions[tsgl->nents].length
622 tsgl->nents++;
623 }
624 partitions[tsgl->nents - 1].length +=
625
626 /* Set up the sgl entries and fill the
627 sg_init_table(tsgl->sgl, tsgl->nents);
628 for (i = 0; i < tsgl->nents; i++) {
629 unsigned int offset = partitio
630 void *addr;
631
632 if (partitions[i].div->offset_
633 offset += alignmask;
634
635 while (offset + partitions[i].
636 2 * PAGE_SIZE) {
637 if (WARN_ON(offset <=
638 return -EINVAL
639 offset /= 2;
640 }
641
642 addr = &tsgl->bufs[i][offset];
643 sg_set_buf(&tsgl->sgl[i], addr
644
645 if (out_divs)
646 out_divs[i] = partitio
647
648 if (data) {
649 size_t copy_len, copie
650
651 copy_len = min(partiti
652 copied = copy_from_ite
653 if (WARN_ON(copied !=
654 return -EINVAL
655 testmgr_poison(addr +
656 TESTMGR
657 } else {
658 testmgr_poison(addr, p
659 TESTMGR
660 }
661 }
662
663 sg_mark_end(&tsgl->sgl[tsgl->nents - 1
664 tsgl->sgl_ptr = tsgl->sgl;
665 memcpy(tsgl->sgl_saved, tsgl->sgl, tsg
666 return 0;
667 }
668
669 /*
670 * Verify that a scatterlist crypto operation
671 *
672 * @tsgl: scatterlist containing the actual ou
673 * @expected_output: buffer containing the exp
674 * @len_to_check: length of @expected_output i
675 * @unchecked_prefix_len: number of ignored by
676 * @check_poison: verify that the poison bytes
677 *
678 * Return: 0 if correct, -EINVAL if incorrect,
679 */
680 static int verify_correct_output(const struct
681 const char *e
682 unsigned int
683 unsigned int
684 bool check_po
685 {
686 unsigned int i;
687
688 for (i = 0; i < tsgl->nents; i++) {
689 struct scatterlist *sg = &tsgl
690 unsigned int len = sg->length;
691 unsigned int offset = sg->offs
692 const char *actual_output;
693
694 if (unchecked_prefix_len) {
695 if (unchecked_prefix_l
696 unchecked_pref
697 continue;
698 }
699 offset += unchecked_pr
700 len -= unchecked_prefi
701 unchecked_prefix_len =
702 }
703 len = min(len, len_to_check);
704 actual_output = page_address(s
705 if (memcmp(expected_output, ac
706 return -EINVAL;
707 if (check_poison &&
708 !testmgr_is_poison(actual_
709 return -EOVERFLOW;
710 len_to_check -= len;
711 expected_output += len;
712 }
713 if (WARN_ON(len_to_check != 0))
714 return -EINVAL;
715 return 0;
716 }
717
718 static bool is_test_sglist_corrupted(const str
719 {
720 unsigned int i;
721
722 for (i = 0; i < tsgl->nents; i++) {
723 if (tsgl->sgl[i].page_link !=
724 return true;
725 if (tsgl->sgl[i].offset != tsg
726 return true;
727 if (tsgl->sgl[i].length != tsg
728 return true;
729 }
730 return false;
731 }
732
733 struct cipher_test_sglists {
734 struct test_sglist src;
735 struct test_sglist dst;
736 };
737
738 static struct cipher_test_sglists *alloc_ciphe
739 {
740 struct cipher_test_sglists *tsgls;
741
742 tsgls = kmalloc(sizeof(*tsgls), GFP_KE
743 if (!tsgls)
744 return NULL;
745
746 if (init_test_sglist(&tsgls->src) != 0
747 goto fail_kfree;
748 if (init_test_sglist(&tsgls->dst) != 0
749 goto fail_destroy_src;
750
751 return tsgls;
752
753 fail_destroy_src:
754 destroy_test_sglist(&tsgls->src);
755 fail_kfree:
756 kfree(tsgls);
757 return NULL;
758 }
759
760 static void free_cipher_test_sglists(struct ci
761 {
762 if (tsgls) {
763 destroy_test_sglist(&tsgls->sr
764 destroy_test_sglist(&tsgls->ds
765 kfree(tsgls);
766 }
767 }
768
769 /* Build the src and dst scatterlists for an s
770 static int build_cipher_test_sglists(struct ci
771 const str
772 unsigned
773 unsigned
774 unsigned
775 const str
776 unsigned
777 {
778 struct iov_iter input;
779 int err;
780
781 iov_iter_kvec(&input, ITER_SOURCE, inp
782 err = build_test_sglist(&tsgls->src, c
783 cfg->inplace_m
784 max(ds
785 src_to
786 &input, NULL);
787 if (err)
788 return err;
789
790 /*
791 * In-place crypto operations can use
792 * source and destination (req->src ==
793 * scatterlists (req->src != req->dst)
794 * underlying memory. Make sure to te
795 */
796 if (cfg->inplace_mode == INPLACE_ONE_S
797 tsgls->dst.sgl_ptr = tsgls->sr
798 tsgls->dst.nents = tsgls->src.
799 return 0;
800 }
801 if (cfg->inplace_mode == INPLACE_TWO_S
802 /*
803 * For now we keep it simple a
804 * two scatterlists have ident
805 * different entries that spli
806 */
807 memcpy(tsgls->dst.sgl, tsgls->
808 tsgls->src.nents * size
809 memcpy(tsgls->dst.sgl_saved, t
810 tsgls->src.nents * size
811 tsgls->dst.sgl_ptr = tsgls->ds
812 tsgls->dst.nents = tsgls->src.
813 return 0;
814 }
815 /* Out of place */
816 return build_test_sglist(&tsgls->dst,
817 cfg->dst_divs
818 cfg->d
819 alignmask, ds
820 }
821
822 /*
823 * Support for testing passing a misaligned ke
824 *
825 * If cfg->key_offset is set, copy the key int
826 * optionally adding alignmask. Else, just us
827 */
828 static int prepare_keybuf(const u8 *key, unsig
829 const struct testvec
830 unsigned int alignma
831 const u8 **keybuf_re
832 {
833 unsigned int key_offset = cfg->key_off
834 u8 *keybuf = NULL, *keyptr = (u8 *)key
835
836 if (key_offset != 0) {
837 if (cfg->key_offset_relative_t
838 key_offset += alignmas
839 keybuf = kmalloc(key_offset +
840 if (!keybuf)
841 return -ENOMEM;
842 keyptr = keybuf + key_offset;
843 memcpy(keyptr, key, ksize);
844 }
845 *keybuf_ret = keybuf;
846 *keyptr_ret = keyptr;
847 return 0;
848 }
849
850 /*
851 * Like setkey_f(tfm, key, ksize), but sometim
852 * In addition, run the setkey function in no-
853 */
854 #define do_setkey(setkey_f, tfm, key, ksize, c
855 ({
856 const u8 *keybuf, *keyptr;
857 int err;
858
859 err = prepare_keybuf((key), (ksize), (
860 &keybuf, &keyptr)
861 if (err == 0) {
862 if ((cfg)->nosimd_setkey)
863 crypto_disable_simd_fo
864 err = setkey_f((tfm), keyptr,
865 if ((cfg)->nosimd_setkey)
866 crypto_reenable_simd_f
867 kfree(keybuf);
868 }
869 err;
870 })
871
872 #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS
873
874 /*
875 * The fuzz tests use prandom instead of the n
876 * need cryptographically secure random number
877 * performance of these tests, especially if t
878 * has been initialized or if they are run on
879 */
880
881 static inline void init_rnd_state(struct rnd_s
882 {
883 prandom_seed_state(rng, get_random_u64
884 }
885
886 static inline u8 prandom_u8(struct rnd_state *
887 {
888 return prandom_u32_state(rng);
889 }
890
891 static inline u32 prandom_u32_below(struct rnd
892 {
893 /*
894 * This is slightly biased for non-pow
895 * isn't important here.
896 */
897 return prandom_u32_state(rng) % ceil;
898 }
899
900 static inline bool prandom_bool(struct rnd_sta
901 {
902 return prandom_u32_below(rng, 2);
903 }
904
905 static inline u32 prandom_u32_inclusive(struct
906 u32 fl
907 {
908 return floor + prandom_u32_below(rng,
909 }
910
911 /* Generate a random length in range [0, max_l
912 static unsigned int generate_random_length(str
913 uns
914 {
915 unsigned int len = prandom_u32_below(r
916
917 switch (prandom_u32_below(rng, 4)) {
918 case 0:
919 len %= 64;
920 break;
921 case 1:
922 len %= 256;
923 break;
924 case 2:
925 len %= 1024;
926 break;
927 default:
928 break;
929 }
930 if (len && prandom_u32_below(rng, 4) =
931 len = rounddown_pow_of_two(len
932 return len;
933 }
934
935 /* Flip a random bit in the given nonempty dat
936 static void flip_random_bit(struct rnd_state *
937 {
938 size_t bitpos;
939
940 bitpos = prandom_u32_below(rng, size *
941 buf[bitpos / 8] ^= 1 << (bitpos % 8);
942 }
943
944 /* Flip a random byte in the given nonempty da
945 static void flip_random_byte(struct rnd_state
946 {
947 buf[prandom_u32_below(rng, size)] ^= 0
948 }
949
950 /* Sometimes make some random changes to the g
951 static void mutate_buffer(struct rnd_state *rn
952 {
953 size_t num_flips;
954 size_t i;
955
956 /* Sometimes flip some bits */
957 if (prandom_u32_below(rng, 4) == 0) {
958 num_flips = min_t(size_t, 1 <<
959 size * 8);
960 for (i = 0; i < num_flips; i++
961 flip_random_bit(rng, b
962 }
963
964 /* Sometimes flip some bytes */
965 if (prandom_u32_below(rng, 4) == 0) {
966 num_flips = min_t(size_t, 1 <<
967 for (i = 0; i < num_flips; i++
968 flip_random_byte(rng,
969 }
970 }
971
972 /* Randomly generate 'count' bytes, but someti
973 static void generate_random_bytes(struct rnd_s
974 {
975 u8 b;
976 u8 increment;
977 size_t i;
978
979 if (count == 0)
980 return;
981
982 switch (prandom_u32_below(rng, 8)) { /
983 case 0:
984 case 1:
985 /* All the same byte, plus opt
986 switch (prandom_u32_below(rng,
987 case 0:
988 b = 0x00;
989 break;
990 case 1:
991 b = 0xff;
992 break;
993 default:
994 b = prandom_u8(rng);
995 break;
996 }
997 memset(buf, b, count);
998 mutate_buffer(rng, buf, count)
999 break;
1000 case 2:
1001 /* Ascending or descending by
1002 increment = prandom_u8(rng);
1003 b = prandom_u8(rng);
1004 for (i = 0; i < count; i++, b
1005 buf[i] = b;
1006 mutate_buffer(rng, buf, count
1007 break;
1008 default:
1009 /* Fully random bytes */
1010 prandom_bytes_state(rng, buf,
1011 }
1012 }
1013
1014 static char *generate_random_sgl_divisions(st
1015 st
1016 si
1017 bo
1018 {
1019 struct test_sg_division *div = divs;
1020 unsigned int remaining = TEST_SG_TOTA
1021
1022 do {
1023 unsigned int this_len;
1024 const char *flushtype_str;
1025
1026 if (div == &divs[max_divs - 1
1027 this_len = remaining;
1028 else if (prandom_u32_below(rn
1029 this_len = (remaining
1030 else
1031 this_len = prandom_u3
1032 div->proportion_of_total = th
1033
1034 if (prandom_u32_below(rng, 4)
1035 div->offset = prandom
1036
1037
1038 else if (prandom_bool(rng))
1039 div->offset = prandom
1040 else
1041 div->offset = prandom
1042 if (prandom_u32_below(rng, 8)
1043 div->offset_relative_
1044
1045 div->flush_type = FLUSH_TYPE_
1046 if (gen_flushes) {
1047 switch (prandom_u32_b
1048 case 0:
1049 div->flush_ty
1050 break;
1051 case 1:
1052 div->flush_ty
1053 break;
1054 }
1055 }
1056
1057 if (div->flush_type != FLUSH_
1058 !(req_flags & CRYPTO_TFM_
1059 prandom_bool(rng))
1060 div->nosimd = true;
1061
1062 switch (div->flush_type) {
1063 case FLUSH_TYPE_FLUSH:
1064 if (div->nosimd)
1065 flushtype_str
1066 else
1067 flushtype_str
1068 break;
1069 case FLUSH_TYPE_REIMPORT:
1070 if (div->nosimd)
1071 flushtype_str
1072 else
1073 flushtype_str
1074 break;
1075 default:
1076 flushtype_str = "";
1077 break;
1078 }
1079
1080 BUILD_BUG_ON(TEST_SG_TOTAL !=
1081 p += scnprintf(p, end - p, "%
1082 this_len / 100
1083 div->offset_re
1084 "alig
1085 div->offset, t
1086 remaining -= this_len;
1087 div++;
1088 } while (remaining);
1089
1090 return p;
1091 }
1092
1093 /* Generate a random testvec_config for fuzz
1094 static void generate_random_testvec_config(st
1095 st
1096 ch
1097 {
1098 char *p = name;
1099 char * const end = name + max_namelen
1100
1101 memset(cfg, 0, sizeof(*cfg));
1102
1103 cfg->name = name;
1104
1105 p += scnprintf(p, end - p, "random:")
1106
1107 switch (prandom_u32_below(rng, 4)) {
1108 case 0:
1109 case 1:
1110 cfg->inplace_mode = OUT_OF_PL
1111 break;
1112 case 2:
1113 cfg->inplace_mode = INPLACE_O
1114 p += scnprintf(p, end - p, "
1115 break;
1116 default:
1117 cfg->inplace_mode = INPLACE_T
1118 p += scnprintf(p, end - p, "
1119 break;
1120 }
1121
1122 if (prandom_bool(rng)) {
1123 cfg->req_flags |= CRYPTO_TFM_
1124 p += scnprintf(p, end - p, "
1125 }
1126
1127 switch (prandom_u32_below(rng, 4)) {
1128 case 0:
1129 cfg->finalization_type = FINA
1130 p += scnprintf(p, end - p, "
1131 break;
1132 case 1:
1133 cfg->finalization_type = FINA
1134 p += scnprintf(p, end - p, "
1135 break;
1136 default:
1137 cfg->finalization_type = FINA
1138 p += scnprintf(p, end - p, "
1139 break;
1140 }
1141
1142 if (!(cfg->req_flags & CRYPTO_TFM_REQ
1143 if (prandom_bool(rng)) {
1144 cfg->nosimd = true;
1145 p += scnprintf(p, end
1146 }
1147 if (prandom_bool(rng)) {
1148 cfg->nosimd_setkey =
1149 p += scnprintf(p, end
1150 }
1151 }
1152
1153 p += scnprintf(p, end - p, " src_divs
1154 p = generate_random_sgl_divisions(rng
1155 ARR
1156 (cf
1157 FI
1158 cfg
1159 p += scnprintf(p, end - p, "]");
1160
1161 if (cfg->inplace_mode == OUT_OF_PLACE
1162 p += scnprintf(p, end - p, "
1163 p = generate_random_sgl_divis
1164
1165
1166
1167 p += scnprintf(p, end - p, "]
1168 }
1169
1170 if (prandom_bool(rng)) {
1171 cfg->iv_offset = prandom_u32_
1172
1173 p += scnprintf(p, end - p, "
1174 }
1175
1176 if (prandom_bool(rng)) {
1177 cfg->key_offset = prandom_u32
1178
1179 p += scnprintf(p, end - p, "
1180 }
1181
1182 WARN_ON_ONCE(!valid_testvec_config(cf
1183 }
1184
1185 static void crypto_disable_simd_for_test(void
1186 {
1187 migrate_disable();
1188 __this_cpu_write(crypto_simd_disabled
1189 }
1190
1191 static void crypto_reenable_simd_for_test(voi
1192 {
1193 __this_cpu_write(crypto_simd_disabled
1194 migrate_enable();
1195 }
1196
1197 /*
1198 * Given an algorithm name, build the name of
1199 * algorithm, assuming the usual naming conve
1200 * "-generic" to every part of the name that
1201 *
1202 * aes => aes-generic
1203 * cbc(aes) => cbc(aes-generic)
1204 * cts(cbc(aes)) => cts(cbc(aes-generic)
1205 * rfc7539(chacha20,poly1305) => rfc7539
1206 *
1207 * Return: 0 on success, or -ENAMETOOLONG if
1208 */
1209 static int build_generic_driver_name(const ch
1210 char dri
1211 {
1212 const char *in = algname;
1213 char *out = driver_name;
1214 size_t len = strlen(algname);
1215
1216 if (len >= CRYPTO_MAX_ALG_NAME)
1217 goto too_long;
1218 do {
1219 const char *in_saved = in;
1220
1221 while (*in && *in != '(' && *
1222 *out++ = *in++;
1223 if (*in != '(' && in > in_sav
1224 len += 8;
1225 if (len >= CRYPTO_MAX
1226 goto too_long
1227 memcpy(out, "-generic
1228 out += 8;
1229 }
1230 } while ((*out++ = *in++) != '\0');
1231 return 0;
1232
1233 too_long:
1234 pr_err("alg: generic driver name for
1235 algname);
1236 return -ENAMETOOLONG;
1237 }
1238 #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS *
1239 static void crypto_disable_simd_for_test(void
1240 {
1241 }
1242
1243 static void crypto_reenable_simd_for_test(voi
1244 {
1245 }
1246 #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS
1247
1248 static int build_hash_sglist(struct test_sgli
1249 const struct has
1250 const struct tes
1251 unsigned int ali
1252 const struct tes
1253 {
1254 struct kvec kv;
1255 struct iov_iter input;
1256
1257 kv.iov_base = (void *)vec->plaintext;
1258 kv.iov_len = vec->psize;
1259 iov_iter_kvec(&input, ITER_SOURCE, &k
1260 return build_test_sglist(tsgl, cfg->s
1261 &input, divs
1262 }
1263
1264 static int check_hash_result(const char *type
1265 const u8 *result
1266 const struct has
1267 const char *vec_
1268 const char *driv
1269 const struct tes
1270 {
1271 if (memcmp(result, vec->digest, diges
1272 pr_err("alg: %s: %s test fail
1273 type, driver, vec_name
1274 return -EINVAL;
1275 }
1276 if (!testmgr_is_poison(&result[digest
1277 pr_err("alg: %s: %s overran r
1278 type, driver, vec_name
1279 return -EOVERFLOW;
1280 }
1281 return 0;
1282 }
1283
1284 static inline int check_shash_op(const char *
1285 const char *
1286 const struct
1287 {
1288 if (err)
1289 pr_err("alg: shash: %s %s() f
1290 driver, op, err, vec_n
1291 return err;
1292 }
1293
1294 /* Test one hash test vector in one configura
1295 static int test_shash_vec_cfg(const struct ha
1296 const char *vec
1297 const struct te
1298 struct shash_de
1299 struct test_sgl
1300 u8 *hashstate)
1301 {
1302 struct crypto_shash *tfm = desc->tfm;
1303 const unsigned int digestsize = crypt
1304 const unsigned int statesize = crypto
1305 const char *driver = crypto_shash_dri
1306 const struct test_sg_division *divs[X
1307 unsigned int i;
1308 u8 result[HASH_MAX_DIGESTSIZE + TESTM
1309 int err;
1310
1311 /* Set the key, if specified */
1312 if (vec->ksize) {
1313 err = do_setkey(crypto_shash_
1314 cfg, 0);
1315 if (err) {
1316 if (err == vec->setke
1317 return 0;
1318 pr_err("alg: shash: %
1319 driver, vec_na
1320 crypto_shash_g
1321 return err;
1322 }
1323 if (vec->setkey_error) {
1324 pr_err("alg: shash: %
1325 driver, vec_na
1326 return -EINVAL;
1327 }
1328 }
1329
1330 /* Build the scatterlist for the sour
1331 err = build_hash_sglist(tsgl, vec, cf
1332 if (err) {
1333 pr_err("alg: shash: %s: error
1334 driver, vec_name, cfg-
1335 return err;
1336 }
1337
1338 /* Do the actual hashing */
1339
1340 testmgr_poison(desc->__ctx, crypto_sh
1341 testmgr_poison(result, digestsize + T
1342
1343 if (cfg->finalization_type == FINALIZ
1344 vec->digest_error) {
1345 /* Just using digest() */
1346 if (tsgl->nents != 1)
1347 return 0;
1348 if (cfg->nosimd)
1349 crypto_disable_simd_f
1350 err = crypto_shash_digest(des
1351 tsg
1352 if (cfg->nosimd)
1353 crypto_reenable_simd_
1354 if (err) {
1355 if (err == vec->diges
1356 return 0;
1357 pr_err("alg: shash: %
1358 driver, vec_na
1359 cfg->name);
1360 return err;
1361 }
1362 if (vec->digest_error) {
1363 pr_err("alg: shash: %
1364 driver, vec_na
1365 return -EINVAL;
1366 }
1367 goto result_ready;
1368 }
1369
1370 /* Using init(), zero or more update(
1371
1372 if (cfg->nosimd)
1373 crypto_disable_simd_for_test(
1374 err = crypto_shash_init(desc);
1375 if (cfg->nosimd)
1376 crypto_reenable_simd_for_test
1377 err = check_shash_op("init", err, dri
1378 if (err)
1379 return err;
1380
1381 for (i = 0; i < tsgl->nents; i++) {
1382 if (i + 1 == tsgl->nents &&
1383 cfg->finalization_type ==
1384 if (divs[i]->nosimd)
1385 crypto_disabl
1386 err = crypto_shash_fi
1387
1388 if (divs[i]->nosimd)
1389 crypto_reenab
1390 err = check_shash_op(
1391
1392 if (err)
1393 return err;
1394 goto result_ready;
1395 }
1396 if (divs[i]->nosimd)
1397 crypto_disable_simd_f
1398 err = crypto_shash_update(des
1399 tsg
1400 if (divs[i]->nosimd)
1401 crypto_reenable_simd_
1402 err = check_shash_op("update"
1403 if (err)
1404 return err;
1405 if (divs[i]->flush_type == FL
1406 /* Test ->export() an
1407 testmgr_poison(hashst
1408 TESTMG
1409 err = crypto_shash_ex
1410 err = check_shash_op(
1411
1412 if (err)
1413 return err;
1414 if (!testmgr_is_poiso
1415
1416 pr_err("alg:
1417 driver
1418 return -EOVER
1419 }
1420 testmgr_poison(desc->
1421 err = crypto_shash_im
1422 err = check_shash_op(
1423
1424 if (err)
1425 return err;
1426 }
1427 }
1428
1429 if (cfg->nosimd)
1430 crypto_disable_simd_for_test(
1431 err = crypto_shash_final(desc, result
1432 if (cfg->nosimd)
1433 crypto_reenable_simd_for_test
1434 err = check_shash_op("final", err, dr
1435 if (err)
1436 return err;
1437 result_ready:
1438 return check_hash_result("shash", res
1439 driver, cfg)
1440 }
1441
1442 static int do_ahash_op(int (*op)(struct ahash
1443 struct ahash_request *
1444 struct crypto_wait *wa
1445 {
1446 int err;
1447
1448 if (nosimd)
1449 crypto_disable_simd_for_test(
1450
1451 err = op(req);
1452
1453 if (nosimd)
1454 crypto_reenable_simd_for_test
1455
1456 return crypto_wait_req(err, wait);
1457 }
1458
1459 static int check_nonfinal_ahash_op(const char
1460 u8 *result
1461 const char
1462 const stru
1463 {
1464 if (err) {
1465 pr_err("alg: ahash: %s %s() f
1466 driver, op, err, vec_n
1467 return err;
1468 }
1469 if (!testmgr_is_poison(result, digest
1470 pr_err("alg: ahash: %s %s() u
1471 driver, op, vec_name,
1472 return -EINVAL;
1473 }
1474 return 0;
1475 }
1476
1477 /* Test one hash test vector in one configura
1478 static int test_ahash_vec_cfg(const struct ha
1479 const char *vec
1480 const struct te
1481 struct ahash_re
1482 struct test_sgl
1483 u8 *hashstate)
1484 {
1485 struct crypto_ahash *tfm = crypto_aha
1486 const unsigned int digestsize = crypt
1487 const unsigned int statesize = crypto
1488 const char *driver = crypto_ahash_dri
1489 const u32 req_flags = CRYPTO_TFM_REQ_
1490 const struct test_sg_division *divs[X
1491 DECLARE_CRYPTO_WAIT(wait);
1492 unsigned int i;
1493 struct scatterlist *pending_sgl;
1494 unsigned int pending_len;
1495 u8 result[HASH_MAX_DIGESTSIZE + TESTM
1496 int err;
1497
1498 /* Set the key, if specified */
1499 if (vec->ksize) {
1500 err = do_setkey(crypto_ahash_
1501 cfg, 0);
1502 if (err) {
1503 if (err == vec->setke
1504 return 0;
1505 pr_err("alg: ahash: %
1506 driver, vec_na
1507 crypto_ahash_g
1508 return err;
1509 }
1510 if (vec->setkey_error) {
1511 pr_err("alg: ahash: %
1512 driver, vec_na
1513 return -EINVAL;
1514 }
1515 }
1516
1517 /* Build the scatterlist for the sour
1518 err = build_hash_sglist(tsgl, vec, cf
1519 if (err) {
1520 pr_err("alg: ahash: %s: error
1521 driver, vec_name, cfg-
1522 return err;
1523 }
1524
1525 /* Do the actual hashing */
1526
1527 testmgr_poison(req->__ctx, crypto_aha
1528 testmgr_poison(result, digestsize + T
1529
1530 if (cfg->finalization_type == FINALIZ
1531 vec->digest_error) {
1532 /* Just using digest() */
1533 ahash_request_set_callback(re
1534 &w
1535 ahash_request_set_crypt(req,
1536 err = do_ahash_op(crypto_ahas
1537 if (err) {
1538 if (err == vec->diges
1539 return 0;
1540 pr_err("alg: ahash: %
1541 driver, vec_na
1542 cfg->name);
1543 return err;
1544 }
1545 if (vec->digest_error) {
1546 pr_err("alg: ahash: %
1547 driver, vec_na
1548 return -EINVAL;
1549 }
1550 goto result_ready;
1551 }
1552
1553 /* Using init(), zero or more update(
1554
1555 ahash_request_set_callback(req, req_f
1556 ahash_request_set_crypt(req, NULL, re
1557 err = do_ahash_op(crypto_ahash_init,
1558 err = check_nonfinal_ahash_op("init",
1559 driver,
1560 if (err)
1561 return err;
1562
1563 pending_sgl = NULL;
1564 pending_len = 0;
1565 for (i = 0; i < tsgl->nents; i++) {
1566 if (divs[i]->flush_type != FL
1567 pending_sgl != NULL) {
1568 /* update() with the
1569 ahash_request_set_cal
1570
1571 ahash_request_set_cry
1572
1573 err = do_ahash_op(cry
1574 div
1575 err = check_nonfinal_
1576
1577
1578 if (err)
1579 return err;
1580 pending_sgl = NULL;
1581 pending_len = 0;
1582 }
1583 if (divs[i]->flush_type == FL
1584 /* Test ->export() an
1585 testmgr_poison(hashst
1586 TESTMG
1587 err = crypto_ahash_ex
1588 err = check_nonfinal_
1589
1590
1591 if (err)
1592 return err;
1593 if (!testmgr_is_poiso
1594
1595 pr_err("alg:
1596 driver
1597 return -EOVER
1598 }
1599
1600 testmgr_poison(req->_
1601 err = crypto_ahash_im
1602 err = check_nonfinal_
1603
1604
1605 if (err)
1606 return err;
1607 }
1608 if (pending_sgl == NULL)
1609 pending_sgl = &tsgl->
1610 pending_len += tsgl->sgl[i].l
1611 }
1612
1613 ahash_request_set_callback(req, req_f
1614 ahash_request_set_crypt(req, pending_
1615 if (cfg->finalization_type == FINALIZ
1616 /* finish with update() and f
1617 err = do_ahash_op(crypto_ahas
1618 err = check_nonfinal_ahash_op
1619
1620 if (err)
1621 return err;
1622 err = do_ahash_op(crypto_ahas
1623 if (err) {
1624 pr_err("alg: ahash: %
1625 driver, err, v
1626 return err;
1627 }
1628 } else {
1629 /* finish with finup() */
1630 err = do_ahash_op(crypto_ahas
1631 if (err) {
1632 pr_err("alg: ahash: %
1633 driver, err, v
1634 return err;
1635 }
1636 }
1637
1638 result_ready:
1639 return check_hash_result("ahash", res
1640 driver, cfg)
1641 }
1642
1643 static int test_hash_vec_cfg(const struct has
1644 const char *vec_
1645 const struct tes
1646 struct ahash_req
1647 struct shash_des
1648 struct test_sgli
1649 u8 *hashstate)
1650 {
1651 int err;
1652
1653 /*
1654 * For algorithms implemented as "sha
1655 * both the shash and ahash tests. T
1656 * failures involve less indirection,
1657 */
1658
1659 if (desc) {
1660 err = test_shash_vec_cfg(vec,
1661 hash
1662 if (err)
1663 return err;
1664 }
1665
1666 return test_ahash_vec_cfg(vec, vec_na
1667 }
1668
1669 static int test_hash_vec(const struct hash_te
1670 struct ahash_request
1671 struct test_sglist *
1672 {
1673 char vec_name[16];
1674 unsigned int i;
1675 int err;
1676
1677 sprintf(vec_name, "%u", vec_num);
1678
1679 for (i = 0; i < ARRAY_SIZE(default_ha
1680 err = test_hash_vec_cfg(vec,
1681 &defa
1682 req,
1683 if (err)
1684 return err;
1685 }
1686
1687 #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS
1688 if (!noextratests) {
1689 struct rnd_state rng;
1690 struct testvec_config cfg;
1691 char cfgname[TESTVEC_CONFIG_N
1692
1693 init_rnd_state(&rng);
1694
1695 for (i = 0; i < fuzz_iteratio
1696 generate_random_testv
1697
1698 err = test_hash_vec_c
1699
1700 if (err)
1701 return err;
1702 cond_resched();
1703 }
1704 }
1705 #endif
1706 return 0;
1707 }
1708
1709 #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS
1710 /*
1711 * Generate a hash test vector from the given
1712 * Assumes the buffers in 'vec' were already
1713 */
1714 static void generate_random_hash_testvec(stru
1715 stru
1716 stru
1717 unsi
1718 unsi
1719 char
1720 {
1721 /* Data */
1722 vec->psize = generate_random_length(r
1723 generate_random_bytes(rng, (u8 *)vec-
1724
1725 /*
1726 * Key: length in range [1, maxkeysiz
1727 * If algorithm is unkeyed, then maxk
1728 */
1729 vec->setkey_error = 0;
1730 vec->ksize = 0;
1731 if (maxkeysize) {
1732 vec->ksize = maxkeysize;
1733 if (prandom_u32_below(rng, 4)
1734 vec->ksize = prandom_
1735 generate_random_bytes(rng, (u
1736
1737 vec->setkey_error = crypto_sh
1738
1739 /* If the key couldn't be set
1740 if (vec->setkey_error)
1741 goto done;
1742 }
1743
1744 /* Digest */
1745 vec->digest_error = crypto_shash_dige
1746
1747 done:
1748 snprintf(name, max_namelen, "\"random
1749 vec->psize, vec->ksize);
1750 }
1751
1752 /*
1753 * Test the hash algorithm represented by @re
1754 * implementation, if one is available.
1755 */
1756 static int test_hash_vs_generic_impl(const ch
1757 unsigned
1758 struct a
1759 struct s
1760 struct t
1761 u8 *hash
1762 {
1763 struct crypto_ahash *tfm = crypto_aha
1764 const unsigned int digestsize = crypt
1765 const unsigned int blocksize = crypto
1766 const unsigned int maxdatasize = (2 *
1767 const char *algname = crypto_hash_alg
1768 const char *driver = crypto_ahash_dri
1769 struct rnd_state rng;
1770 char _generic_driver[CRYPTO_MAX_ALG_N
1771 struct crypto_shash *generic_tfm = NU
1772 struct shash_desc *generic_desc = NUL
1773 unsigned int i;
1774 struct hash_testvec vec = { 0 };
1775 char vec_name[64];
1776 struct testvec_config *cfg;
1777 char cfgname[TESTVEC_CONFIG_NAMELEN];
1778 int err;
1779
1780 if (noextratests)
1781 return 0;
1782
1783 init_rnd_state(&rng);
1784
1785 if (!generic_driver) { /* Use default
1786 err = build_generic_driver_na
1787 if (err)
1788 return err;
1789 generic_driver = _generic_dri
1790 }
1791
1792 if (strcmp(generic_driver, driver) ==
1793 return 0;
1794
1795 generic_tfm = crypto_alloc_shash(gene
1796 if (IS_ERR(generic_tfm)) {
1797 err = PTR_ERR(generic_tfm);
1798 if (err == -ENOENT) {
1799 pr_warn("alg: hash: s
1800 driver, gener
1801 return 0;
1802 }
1803 pr_err("alg: hash: error allo
1804 generic_driver, algnam
1805 return err;
1806 }
1807
1808 cfg = kzalloc(sizeof(*cfg), GFP_KERNE
1809 if (!cfg) {
1810 err = -ENOMEM;
1811 goto out;
1812 }
1813
1814 generic_desc = kzalloc(sizeof(*desc)
1815 crypto_shash_d
1816 if (!generic_desc) {
1817 err = -ENOMEM;
1818 goto out;
1819 }
1820 generic_desc->tfm = generic_tfm;
1821
1822 /* Check the algorithm properties for
1823
1824 if (digestsize != crypto_shash_digest
1825 pr_err("alg: hash: digestsize
1826 driver, digestsize,
1827 crypto_shash_digestsiz
1828 err = -EINVAL;
1829 goto out;
1830 }
1831
1832 if (blocksize != crypto_shash_blocksi
1833 pr_err("alg: hash: blocksize
1834 driver, blocksize, cry
1835 err = -EINVAL;
1836 goto out;
1837 }
1838
1839 /*
1840 * Now generate test vectors using th
1841 * the other implementation against t
1842 */
1843
1844 vec.key = kmalloc(maxkeysize, GFP_KER
1845 vec.plaintext = kmalloc(maxdatasize,
1846 vec.digest = kmalloc(digestsize, GFP_
1847 if (!vec.key || !vec.plaintext || !ve
1848 err = -ENOMEM;
1849 goto out;
1850 }
1851
1852 for (i = 0; i < fuzz_iterations * 8;
1853 generate_random_hash_testvec(
1854
1855
1856 generate_random_testvec_confi
1857
1858
1859 err = test_hash_vec_cfg(&vec,
1860 req,
1861 if (err)
1862 goto out;
1863 cond_resched();
1864 }
1865 err = 0;
1866 out:
1867 kfree(cfg);
1868 kfree(vec.key);
1869 kfree(vec.plaintext);
1870 kfree(vec.digest);
1871 crypto_free_shash(generic_tfm);
1872 kfree_sensitive(generic_desc);
1873 return err;
1874 }
1875 #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS *
1876 static int test_hash_vs_generic_impl(const ch
1877 unsigned
1878 struct a
1879 struct s
1880 struct t
1881 u8 *hash
1882 {
1883 return 0;
1884 }
1885 #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS
1886
1887 static int alloc_shash(const char *driver, u3
1888 struct crypto_shash **
1889 struct shash_desc **de
1890 {
1891 struct crypto_shash *tfm;
1892 struct shash_desc *desc;
1893
1894 tfm = crypto_alloc_shash(driver, type
1895 if (IS_ERR(tfm)) {
1896 if (PTR_ERR(tfm) == -ENOENT)
1897 /*
1898 * This algorithm is
1899 * API, not the shash
1900 */
1901 return 0;
1902 }
1903 pr_err("alg: hash: failed to
1904 driver, PTR_ERR(tfm));
1905 return PTR_ERR(tfm);
1906 }
1907
1908 desc = kmalloc(sizeof(*desc) + crypto
1909 if (!desc) {
1910 crypto_free_shash(tfm);
1911 return -ENOMEM;
1912 }
1913 desc->tfm = tfm;
1914
1915 *tfm_ret = tfm;
1916 *desc_ret = desc;
1917 return 0;
1918 }
1919
1920 static int __alg_test_hash(const struct hash_
1921 unsigned int num_v
1922 u32 type, u32 mask
1923 const char *generi
1924 {
1925 struct crypto_ahash *atfm = NULL;
1926 struct ahash_request *req = NULL;
1927 struct crypto_shash *stfm = NULL;
1928 struct shash_desc *desc = NULL;
1929 struct test_sglist *tsgl = NULL;
1930 u8 *hashstate = NULL;
1931 unsigned int statesize;
1932 unsigned int i;
1933 int err;
1934
1935 /*
1936 * Always test the ahash API. This w
1937 * algorithm is implemented as ahash
1938 */
1939
1940 atfm = crypto_alloc_ahash(driver, typ
1941 if (IS_ERR(atfm)) {
1942 if (PTR_ERR(atfm) == -ENOENT)
1943 return 0;
1944 pr_err("alg: hash: failed to
1945 driver, PTR_ERR(atfm))
1946 return PTR_ERR(atfm);
1947 }
1948 driver = crypto_ahash_driver_name(atf
1949
1950 req = ahash_request_alloc(atfm, GFP_K
1951 if (!req) {
1952 pr_err("alg: hash: failed to
1953 driver);
1954 err = -ENOMEM;
1955 goto out;
1956 }
1957
1958 /*
1959 * If available also test the shash A
1960 * be missed by testing the ahash API
1961 */
1962 err = alloc_shash(driver, type, mask,
1963 if (err)
1964 goto out;
1965
1966 tsgl = kmalloc(sizeof(*tsgl), GFP_KER
1967 if (!tsgl || init_test_sglist(tsgl) !
1968 pr_err("alg: hash: failed to
1969 driver);
1970 kfree(tsgl);
1971 tsgl = NULL;
1972 err = -ENOMEM;
1973 goto out;
1974 }
1975
1976 statesize = crypto_ahash_statesize(at
1977 if (stfm)
1978 statesize = max(statesize, cr
1979 hashstate = kmalloc(statesize + TESTM
1980 if (!hashstate) {
1981 pr_err("alg: hash: failed to
1982 driver);
1983 err = -ENOMEM;
1984 goto out;
1985 }
1986
1987 for (i = 0; i < num_vecs; i++) {
1988 if (fips_enabled && vecs[i].f
1989 continue;
1990
1991 err = test_hash_vec(&vecs[i],
1992 if (err)
1993 goto out;
1994 cond_resched();
1995 }
1996 err = test_hash_vs_generic_impl(gener
1997 desc,
1998 out:
1999 kfree(hashstate);
2000 if (tsgl) {
2001 destroy_test_sglist(tsgl);
2002 kfree(tsgl);
2003 }
2004 kfree(desc);
2005 crypto_free_shash(stfm);
2006 ahash_request_free(req);
2007 crypto_free_ahash(atfm);
2008 return err;
2009 }
2010
2011 static int alg_test_hash(const struct alg_tes
2012 u32 type, u32 mask)
2013 {
2014 const struct hash_testvec *template =
2015 unsigned int tcount = desc->suite.has
2016 unsigned int nr_unkeyed, nr_keyed;
2017 unsigned int maxkeysize = 0;
2018 int err;
2019
2020 /*
2021 * For OPTIONAL_KEY algorithms, we ha
2022 * first, before setting a key on the
2023 * require that the unkeyed test vect
2024 */
2025
2026 for (nr_unkeyed = 0; nr_unkeyed < tco
2027 if (template[nr_unkeyed].ksiz
2028 break;
2029 }
2030 for (nr_keyed = 0; nr_unkeyed + nr_ke
2031 if (!template[nr_unkeyed + nr
2032 pr_err("alg: hash: te
2033 "unkeyed ones
2034 return -EINVAL;
2035 }
2036 maxkeysize = max_t(unsigned i
2037 template[n
2038 }
2039
2040 err = 0;
2041 if (nr_unkeyed) {
2042 err = __alg_test_hash(templat
2043 desc->g
2044 template += nr_unkeyed;
2045 }
2046
2047 if (!err && nr_keyed)
2048 err = __alg_test_hash(templat
2049 desc->g
2050
2051 return err;
2052 }
2053
2054 static int test_aead_vec_cfg(int enc, const s
2055 const char *vec_
2056 const struct tes
2057 struct aead_requ
2058 struct cipher_te
2059 {
2060 struct crypto_aead *tfm = crypto_aead
2061 const unsigned int alignmask = crypto
2062 const unsigned int ivsize = crypto_ae
2063 const unsigned int authsize = vec->cl
2064 const char *driver = crypto_aead_driv
2065 const u32 req_flags = CRYPTO_TFM_REQ_
2066 const char *op = enc ? "encryption" :
2067 DECLARE_CRYPTO_WAIT(wait);
2068 u8 _iv[3 * (MAX_ALGAPI_ALIGNMASK + 1)
2069 u8 *iv = PTR_ALIGN(&_iv[0], 2 * (MAX_
2070 cfg->iv_offset +
2071 (cfg->iv_offset_relative_to_
2072 struct kvec input[2];
2073 int err;
2074
2075 /* Set the key */
2076 if (vec->wk)
2077 crypto_aead_set_flags(tfm, CR
2078 else
2079 crypto_aead_clear_flags(tfm,
2080
2081 err = do_setkey(crypto_aead_setkey, t
2082 cfg, alignmask);
2083 if (err && err != vec->setkey_error)
2084 pr_err("alg: aead: %s setkey
2085 driver, vec_name, vec-
2086 crypto_aead_get_flags(
2087 return err;
2088 }
2089 if (!err && vec->setkey_error) {
2090 pr_err("alg: aead: %s setkey
2091 driver, vec_name, vec-
2092 return -EINVAL;
2093 }
2094
2095 /* Set the authentication tag size */
2096 err = crypto_aead_setauthsize(tfm, au
2097 if (err && err != vec->setauthsize_er
2098 pr_err("alg: aead: %s setauth
2099 driver, vec_name, vec-
2100 return err;
2101 }
2102 if (!err && vec->setauthsize_error) {
2103 pr_err("alg: aead: %s setauth
2104 driver, vec_name, vec-
2105 return -EINVAL;
2106 }
2107
2108 if (vec->setkey_error || vec->setauth
2109 return 0;
2110
2111 /* The IV must be copied to a buffer,
2112 if (WARN_ON(ivsize > MAX_IVLEN))
2113 return -EINVAL;
2114 if (vec->iv)
2115 memcpy(iv, vec->iv, ivsize);
2116 else
2117 memset(iv, 0, ivsize);
2118
2119 /* Build the src/dst scatterlists */
2120 input[0].iov_base = (void *)vec->asso
2121 input[0].iov_len = vec->alen;
2122 input[1].iov_base = enc ? (void *)vec
2123 input[1].iov_len = enc ? vec->plen :
2124 err = build_cipher_test_sglists(tsgls
2125 vec->
2126
2127 vec->
2128
2129 input
2130 if (err) {
2131 pr_err("alg: aead: %s %s: err
2132 driver, op, vec_name,
2133 return err;
2134 }
2135
2136 /* Do the actual encryption or decryp
2137 testmgr_poison(req->__ctx, crypto_aea
2138 aead_request_set_callback(req, req_fl
2139 aead_request_set_crypt(req, tsgls->sr
2140 enc ? vec->ple
2141 aead_request_set_ad(req, vec->alen);
2142 if (cfg->nosimd)
2143 crypto_disable_simd_for_test(
2144 err = enc ? crypto_aead_encrypt(req)
2145 if (cfg->nosimd)
2146 crypto_reenable_simd_for_test
2147 err = crypto_wait_req(err, &wait);
2148
2149 /* Check that the algorithm didn't ov
2150 if (req->cryptlen != (enc ? vec->plen
2151 req->assoclen != vec->alen ||
2152 req->iv != iv ||
2153 req->src != tsgls->src.sgl_ptr ||
2154 req->dst != tsgls->dst.sgl_ptr ||
2155 crypto_aead_reqtfm(req) != tfm ||
2156 req->base.complete != crypto_req_
2157 req->base.flags != req_flags ||
2158 req->base.data != &wait) {
2159 pr_err("alg: aead: %s %s corr
2160 driver, op, vec_name,
2161 if (req->cryptlen != (enc ? v
2162 pr_err("alg: aead: ch
2163 if (req->assoclen != vec->ale
2164 pr_err("alg: aead: ch
2165 if (req->iv != iv)
2166 pr_err("alg: aead: ch
2167 if (req->src != tsgls->src.sg
2168 pr_err("alg: aead: ch
2169 if (req->dst != tsgls->dst.sg
2170 pr_err("alg: aead: ch
2171 if (crypto_aead_reqtfm(req) !
2172 pr_err("alg: aead: ch
2173 if (req->base.complete != cry
2174 pr_err("alg: aead: ch
2175 if (req->base.flags != req_fl
2176 pr_err("alg: aead: ch
2177 if (req->base.data != &wait)
2178 pr_err("alg: aead: ch
2179 return -EINVAL;
2180 }
2181 if (is_test_sglist_corrupted(&tsgls->
2182 pr_err("alg: aead: %s %s corr
2183 driver, op, vec_name,
2184 return -EINVAL;
2185 }
2186 if (tsgls->dst.sgl_ptr != tsgls->src.
2187 is_test_sglist_corrupted(&tsgls->
2188 pr_err("alg: aead: %s %s corr
2189 driver, op, vec_name,
2190 return -EINVAL;
2191 }
2192
2193 /* Check for unexpected success or fa
2194 if ((err == 0 && vec->novrfy) ||
2195 (err != vec->crypt_error && !(err
2196 char expected_error[32];
2197
2198 if (vec->novrfy &&
2199 vec->crypt_error != 0 &&
2200 sprintf(expected_erro
2201 vec->crypt_er
2202 else if (vec->novrfy)
2203 sprintf(expected_erro
2204 else
2205 sprintf(expected_erro
2206 if (err) {
2207 pr_err("alg: aead: %s
2208 driver, op, ve
2209 cfg->name);
2210 return err;
2211 }
2212 pr_err("alg: aead: %s %s unex
2213 driver, op, vec_name,
2214 return -EINVAL;
2215 }
2216 if (err) /* Expectedly failed. */
2217 return 0;
2218
2219 /* Check for the correct output (ciph
2220 err = verify_correct_output(&tsgls->d
2221 enc ? vec
2222 vec->alen
2223 enc || cf
2224 if (err == -EOVERFLOW) {
2225 pr_err("alg: aead: %s %s over
2226 driver, op, vec_name,
2227 return err;
2228 }
2229 if (err) {
2230 pr_err("alg: aead: %s %s test
2231 driver, op, vec_name,
2232 return err;
2233 }
2234
2235 return 0;
2236 }
2237
2238 static int test_aead_vec(int enc, const struc
2239 unsigned int vec_num
2240 struct cipher_test_s
2241 {
2242 char vec_name[16];
2243 unsigned int i;
2244 int err;
2245
2246 if (enc && vec->novrfy)
2247 return 0;
2248
2249 sprintf(vec_name, "%u", vec_num);
2250
2251 for (i = 0; i < ARRAY_SIZE(default_ci
2252 err = test_aead_vec_cfg(enc,
2253 &defa
2254 req,
2255 if (err)
2256 return err;
2257 }
2258
2259 #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS
2260 if (!noextratests) {
2261 struct rnd_state rng;
2262 struct testvec_config cfg;
2263 char cfgname[TESTVEC_CONFIG_N
2264
2265 init_rnd_state(&rng);
2266
2267 for (i = 0; i < fuzz_iteratio
2268 generate_random_testv
2269
2270 err = test_aead_vec_c
2271
2272 if (err)
2273 return err;
2274 cond_resched();
2275 }
2276 }
2277 #endif
2278 return 0;
2279 }
2280
2281 #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS
2282
2283 struct aead_extra_tests_ctx {
2284 struct rnd_state rng;
2285 struct aead_request *req;
2286 struct crypto_aead *tfm;
2287 const struct alg_test_desc *test_desc
2288 struct cipher_test_sglists *tsgls;
2289 unsigned int maxdatasize;
2290 unsigned int maxkeysize;
2291
2292 struct aead_testvec vec;
2293 char vec_name[64];
2294 char cfgname[TESTVEC_CONFIG_NAMELEN];
2295 struct testvec_config cfg;
2296 };
2297
2298 /*
2299 * Make at least one random change to a (ciph
2300 * here means the full ciphertext including t
2301 * authentication tag (and hence also the cip
2302 */
2303 static void mutate_aead_message(struct rnd_st
2304 struct aead_t
2305 unsigned int
2306 {
2307 const unsigned int aad_tail_size = aa
2308 const unsigned int authsize = vec->cl
2309
2310 if (prandom_bool(rng) && vec->alen >
2311 /* Mutate the AAD */
2312 flip_random_bit(rng, (u8 *)ve
2313 vec->alen - a
2314 if (prandom_bool(rng))
2315 return;
2316 }
2317 if (prandom_bool(rng)) {
2318 /* Mutate auth tag (assuming
2319 flip_random_bit(rng, (u8 *)ve
2320 } else {
2321 /* Mutate any part of the cip
2322 flip_random_bit(rng, (u8 *)ve
2323 }
2324 }
2325
2326 /*
2327 * Minimum authentication tag size in bytes a
2328 * reliably generate inauthentic messages, i.
2329 * message by chance.
2330 */
2331 #define MIN_COLLISION_FREE_AUTHSIZE 8
2332
2333 static void generate_aead_message(struct rnd_
2334 struct aead
2335 const struc
2336 struct aead
2337 bool prefer
2338 {
2339 struct crypto_aead *tfm = crypto_aead
2340 const unsigned int ivsize = crypto_ae
2341 const unsigned int authsize = vec->cl
2342 const bool inauthentic = (authsize >=
2343 (prefer_inau
2344 prandom_u32
2345
2346 /* Generate the AAD. */
2347 generate_random_bytes(rng, (u8 *)vec-
2348 if (suite->aad_iv && vec->alen >= ivs
2349 /* Avoid implementation-defin
2350 memcpy((u8 *)vec->assoc + vec
2351
2352 if (inauthentic && prandom_bool(rng))
2353 /* Generate a random cipherte
2354 generate_random_bytes(rng, (u
2355 } else {
2356 int i = 0;
2357 struct scatterlist src[2], ds
2358 u8 iv[MAX_IVLEN];
2359 DECLARE_CRYPTO_WAIT(wait);
2360
2361 /* Generate a random plaintex
2362 sg_init_table(src, 2);
2363 if (vec->alen)
2364 sg_set_buf(&src[i++],
2365 if (vec->plen) {
2366 generate_random_bytes
2367 sg_set_buf(&src[i++],
2368 }
2369 sg_init_one(&dst, vec->ctext,
2370 memcpy(iv, vec->iv, ivsize);
2371 aead_request_set_callback(req
2372 aead_request_set_crypt(req, s
2373 aead_request_set_ad(req, vec-
2374 vec->crypt_error = crypto_wai
2375
2376 /* If encryption failed, we'r
2377 if (vec->crypt_error != 0)
2378 return;
2379 memmove((u8 *)vec->ctext, vec
2380 if (!inauthentic)
2381 return;
2382 /*
2383 * Mutate the authentic (ciph
2384 * inauthentic one.
2385 */
2386 mutate_aead_message(rng, vec,
2387 }
2388 vec->novrfy = 1;
2389 if (suite->einval_allowed)
2390 vec->crypt_error = -EINVAL;
2391 }
2392
2393 /*
2394 * Generate an AEAD test vector 'vec' using t
2395 * 'req'. The buffers in 'vec' must already
2396 *
2397 * If 'prefer_inauthentic' is true, then this
2398 * test vectors (i.e. vectors with 'vec->novr
2399 */
2400 static void generate_random_aead_testvec(stru
2401 stru
2402 stru
2403 cons
2404 unsi
2405 unsi
2406 char
2407 bool
2408 {
2409 struct crypto_aead *tfm = crypto_aead
2410 const unsigned int ivsize = crypto_ae
2411 const unsigned int maxauthsize = cryp
2412 unsigned int authsize;
2413 unsigned int total_len;
2414
2415 /* Key: length in [0, maxkeysize], bu
2416 vec->klen = maxkeysize;
2417 if (prandom_u32_below(rng, 4) == 0)
2418 vec->klen = prandom_u32_below
2419 generate_random_bytes(rng, (u8 *)vec-
2420 vec->setkey_error = crypto_aead_setke
2421
2422 /* IV */
2423 generate_random_bytes(rng, (u8 *)vec-
2424
2425 /* Tag length: in [0, maxauthsize], b
2426 authsize = maxauthsize;
2427 if (prandom_u32_below(rng, 4) == 0)
2428 authsize = prandom_u32_below(
2429 if (prefer_inauthentic && authsize <
2430 authsize = MIN_COLLISION_FREE
2431 if (WARN_ON(authsize > maxdatasize))
2432 authsize = maxdatasize;
2433 maxdatasize -= authsize;
2434 vec->setauthsize_error = crypto_aead_
2435
2436 /* AAD, plaintext, and ciphertext len
2437 total_len = generate_random_length(rn
2438 if (prandom_u32_below(rng, 4) == 0)
2439 vec->alen = 0;
2440 else
2441 vec->alen = generate_random_l
2442 vec->plen = total_len - vec->alen;
2443 vec->clen = vec->plen + authsize;
2444
2445 /*
2446 * Generate the AAD, plaintext, and c
2447 * key or the authentication tag size
2448 */
2449 vec->novrfy = 0;
2450 vec->crypt_error = 0;
2451 if (vec->setkey_error == 0 && vec->se
2452 generate_aead_message(rng, re
2453 snprintf(name, max_namelen,
2454 "\"random: alen=%u plen=%u a
2455 vec->alen, vec->plen, authsi
2456 }
2457
2458 static void try_to_generate_inauthentic_testv
2459 struc
2460 {
2461 int i;
2462
2463 for (i = 0; i < 10; i++) {
2464 generate_random_aead_testvec(
2465
2466
2467
2468
2469 if (ctx->vec.novrfy)
2470 return;
2471 }
2472 }
2473
2474 /*
2475 * Generate inauthentic test vectors (i.e. ci
2476 * result of an encryption with the key) and
2477 */
2478 static int test_aead_inauthentic_inputs(struc
2479 {
2480 unsigned int i;
2481 int err;
2482
2483 for (i = 0; i < fuzz_iterations * 8;
2484 /*
2485 * Since this part of the tes
2486 * implementation to another,
2487 * test vectors other than in
2488 *
2489 * If we're having trouble ge
2490 * if the algorithm keeps rej
2491 * retry forever; just contin
2492 */
2493 try_to_generate_inauthentic_t
2494 if (ctx->vec.novrfy) {
2495 generate_random_testv
2496
2497
2498 err = test_aead_vec_c
2499
2500
2501 if (err)
2502 return err;
2503 }
2504 cond_resched();
2505 }
2506 return 0;
2507 }
2508
2509 /*
2510 * Test the AEAD algorithm against the corres
2511 * one is available.
2512 */
2513 static int test_aead_vs_generic_impl(struct a
2514 {
2515 struct crypto_aead *tfm = ctx->tfm;
2516 const char *algname = crypto_aead_alg
2517 const char *driver = crypto_aead_driv
2518 const char *generic_driver = ctx->tes
2519 char _generic_driver[CRYPTO_MAX_ALG_N
2520 struct crypto_aead *generic_tfm = NUL
2521 struct aead_request *generic_req = NU
2522 unsigned int i;
2523 int err;
2524
2525 if (!generic_driver) { /* Use default
2526 err = build_generic_driver_na
2527 if (err)
2528 return err;
2529 generic_driver = _generic_dri
2530 }
2531
2532 if (strcmp(generic_driver, driver) ==
2533 return 0;
2534
2535 generic_tfm = crypto_alloc_aead(gener
2536 if (IS_ERR(generic_tfm)) {
2537 err = PTR_ERR(generic_tfm);
2538 if (err == -ENOENT) {
2539 pr_warn("alg: aead: s
2540 driver, gener
2541 return 0;
2542 }
2543 pr_err("alg: aead: error allo
2544 generic_driver, algnam
2545 return err;
2546 }
2547
2548 generic_req = aead_request_alloc(gene
2549 if (!generic_req) {
2550 err = -ENOMEM;
2551 goto out;
2552 }
2553
2554 /* Check the algorithm properties for
2555
2556 if (crypto_aead_maxauthsize(tfm) !=
2557 crypto_aead_maxauthsize(generic_t
2558 pr_err("alg: aead: maxauthsiz
2559 driver, crypto_aead_ma
2560 crypto_aead_maxauthsiz
2561 err = -EINVAL;
2562 goto out;
2563 }
2564
2565 if (crypto_aead_ivsize(tfm) != crypto
2566 pr_err("alg: aead: ivsize for
2567 driver, crypto_aead_iv
2568 crypto_aead_ivsize(gen
2569 err = -EINVAL;
2570 goto out;
2571 }
2572
2573 if (crypto_aead_blocksize(tfm) != cry
2574 pr_err("alg: aead: blocksize
2575 driver, crypto_aead_bl
2576 crypto_aead_blocksize(
2577 err = -EINVAL;
2578 goto out;
2579 }
2580
2581 /*
2582 * Now generate test vectors using th
2583 * the other implementation against t
2584 */
2585 for (i = 0; i < fuzz_iterations * 8;
2586 generate_random_aead_testvec(
2587
2588
2589
2590
2591 generate_random_testvec_confi
2592
2593
2594 if (!ctx->vec.novrfy) {
2595 err = test_aead_vec_c
2596
2597
2598 if (err)
2599 goto out;
2600 }
2601 if (ctx->vec.crypt_error == 0
2602 err = test_aead_vec_c
2603
2604
2605 if (err)
2606 goto out;
2607 }
2608 cond_resched();
2609 }
2610 err = 0;
2611 out:
2612 crypto_free_aead(generic_tfm);
2613 aead_request_free(generic_req);
2614 return err;
2615 }
2616
2617 static int test_aead_extra(const struct alg_t
2618 struct aead_reques
2619 struct cipher_test
2620 {
2621 struct aead_extra_tests_ctx *ctx;
2622 unsigned int i;
2623 int err;
2624
2625 if (noextratests)
2626 return 0;
2627
2628 ctx = kzalloc(sizeof(*ctx), GFP_KERNE
2629 if (!ctx)
2630 return -ENOMEM;
2631 init_rnd_state(&ctx->rng);
2632 ctx->req = req;
2633 ctx->tfm = crypto_aead_reqtfm(req);
2634 ctx->test_desc = test_desc;
2635 ctx->tsgls = tsgls;
2636 ctx->maxdatasize = (2 * PAGE_SIZE) -
2637 ctx->maxkeysize = 0;
2638 for (i = 0; i < test_desc->suite.aead
2639 ctx->maxkeysize = max_t(unsig
2640 test_
2641
2642 ctx->vec.key = kmalloc(ctx->maxkeysiz
2643 ctx->vec.iv = kmalloc(crypto_aead_ivs
2644 ctx->vec.assoc = kmalloc(ctx->maxdata
2645 ctx->vec.ptext = kmalloc(ctx->maxdata
2646 ctx->vec.ctext = kmalloc(ctx->maxdata
2647 if (!ctx->vec.key || !ctx->vec.iv ||
2648 !ctx->vec.ptext || !ctx->vec.ctex
2649 err = -ENOMEM;
2650 goto out;
2651 }
2652
2653 err = test_aead_vs_generic_impl(ctx);
2654 if (err)
2655 goto out;
2656
2657 err = test_aead_inauthentic_inputs(ct
2658 out:
2659 kfree(ctx->vec.key);
2660 kfree(ctx->vec.iv);
2661 kfree(ctx->vec.assoc);
2662 kfree(ctx->vec.ptext);
2663 kfree(ctx->vec.ctext);
2664 kfree(ctx);
2665 return err;
2666 }
2667 #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS *
2668 static int test_aead_extra(const struct alg_t
2669 struct aead_reques
2670 struct cipher_test
2671 {
2672 return 0;
2673 }
2674 #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS
2675
2676 static int test_aead(int enc, const struct ae
2677 struct aead_request *req
2678 struct cipher_test_sglis
2679 {
2680 unsigned int i;
2681 int err;
2682
2683 for (i = 0; i < suite->count; i++) {
2684 err = test_aead_vec(enc, &sui
2685 if (err)
2686 return err;
2687 cond_resched();
2688 }
2689 return 0;
2690 }
2691
2692 static int alg_test_aead(const struct alg_tes
2693 u32 type, u32 mask)
2694 {
2695 const struct aead_test_suite *suite =
2696 struct crypto_aead *tfm;
2697 struct aead_request *req = NULL;
2698 struct cipher_test_sglists *tsgls = N
2699 int err;
2700
2701 if (suite->count <= 0) {
2702 pr_err("alg: aead: empty test
2703 return -EINVAL;
2704 }
2705
2706 tfm = crypto_alloc_aead(driver, type,
2707 if (IS_ERR(tfm)) {
2708 if (PTR_ERR(tfm) == -ENOENT)
2709 return 0;
2710 pr_err("alg: aead: failed to
2711 driver, PTR_ERR(tfm));
2712 return PTR_ERR(tfm);
2713 }
2714 driver = crypto_aead_driver_name(tfm)
2715
2716 req = aead_request_alloc(tfm, GFP_KER
2717 if (!req) {
2718 pr_err("alg: aead: failed to
2719 driver);
2720 err = -ENOMEM;
2721 goto out;
2722 }
2723
2724 tsgls = alloc_cipher_test_sglists();
2725 if (!tsgls) {
2726 pr_err("alg: aead: failed to
2727 driver);
2728 err = -ENOMEM;
2729 goto out;
2730 }
2731
2732 err = test_aead(ENCRYPT, suite, req,
2733 if (err)
2734 goto out;
2735
2736 err = test_aead(DECRYPT, suite, req,
2737 if (err)
2738 goto out;
2739
2740 err = test_aead_extra(desc, req, tsgl
2741 out:
2742 free_cipher_test_sglists(tsgls);
2743 aead_request_free(req);
2744 crypto_free_aead(tfm);
2745 return err;
2746 }
2747
2748 static int test_cipher(struct crypto_cipher *
2749 const struct cipher_te
2750 unsigned int tcount)
2751 {
2752 const char *algo = crypto_tfm_alg_dri
2753 unsigned int i, j, k;
2754 char *q;
2755 const char *e;
2756 const char *input, *result;
2757 void *data;
2758 char *xbuf[XBUFSIZE];
2759 int ret = -ENOMEM;
2760
2761 if (testmgr_alloc_buf(xbuf))
2762 goto out_nobuf;
2763
2764 if (enc == ENCRYPT)
2765 e = "encryption";
2766 else
2767 e = "decryption";
2768
2769 j = 0;
2770 for (i = 0; i < tcount; i++) {
2771
2772 if (fips_enabled && template[
2773 continue;
2774
2775 input = enc ? template[i].pt
2776 result = enc ? template[i].ct
2777 j++;
2778
2779 ret = -EINVAL;
2780 if (WARN_ON(template[i].len >
2781 goto out;
2782
2783 data = xbuf[0];
2784 memcpy(data, input, template[
2785
2786 crypto_cipher_clear_flags(tfm
2787 if (template[i].wk)
2788 crypto_cipher_set_fla
2789
2790 ret = crypto_cipher_setkey(tf
2791 te
2792 if (ret) {
2793 if (ret == template[i
2794 continue;
2795 pr_err("alg: cipher:
2796 algo, j, templ
2797 crypto_cipher_
2798 goto out;
2799 }
2800 if (template[i].setkey_error)
2801 pr_err("alg: cipher:
2802 algo, j, templ
2803 ret = -EINVAL;
2804 goto out;
2805 }
2806
2807 for (k = 0; k < template[i].l
2808 k += crypto_cipher_block
2809 if (enc)
2810 crypto_cipher
2811
2812 else
2813 crypto_cipher
2814
2815 }
2816
2817 q = data;
2818 if (memcmp(q, result, templat
2819 printk(KERN_ERR "alg:
2820 "on %s for %s\
2821 hexdump(q, template[i
2822 ret = -EINVAL;
2823 goto out;
2824 }
2825 }
2826
2827 ret = 0;
2828
2829 out:
2830 testmgr_free_buf(xbuf);
2831 out_nobuf:
2832 return ret;
2833 }
2834
2835 static int test_skcipher_vec_cfg(int enc, con
2836 const char *
2837 const struct
2838 struct skcip
2839 struct ciphe
2840 {
2841 struct crypto_skcipher *tfm = crypto_
2842 const unsigned int alignmask = crypto
2843 const unsigned int ivsize = crypto_sk
2844 const char *driver = crypto_skcipher_
2845 const u32 req_flags = CRYPTO_TFM_REQ_
2846 const char *op = enc ? "encryption" :
2847 DECLARE_CRYPTO_WAIT(wait);
2848 u8 _iv[3 * (MAX_ALGAPI_ALIGNMASK + 1)
2849 u8 *iv = PTR_ALIGN(&_iv[0], 2 * (MAX_
2850 cfg->iv_offset +
2851 (cfg->iv_offset_relative_to_
2852 struct kvec input;
2853 int err;
2854
2855 /* Set the key */
2856 if (vec->wk)
2857 crypto_skcipher_set_flags(tfm
2858 else
2859 crypto_skcipher_clear_flags(t
2860 C
2861 err = do_setkey(crypto_skcipher_setke
2862 cfg, alignmask);
2863 if (err) {
2864 if (err == vec->setkey_error)
2865 return 0;
2866 pr_err("alg: skcipher: %s set
2867 driver, vec_name, vec-
2868 crypto_skcipher_get_fl
2869 return err;
2870 }
2871 if (vec->setkey_error) {
2872 pr_err("alg: skcipher: %s set
2873 driver, vec_name, vec-
2874 return -EINVAL;
2875 }
2876
2877 /* The IV must be copied to a buffer,
2878 if (ivsize) {
2879 if (WARN_ON(ivsize > MAX_IVLE
2880 return -EINVAL;
2881 if (vec->generates_iv && !enc
2882 memcpy(iv, vec->iv_ou
2883 else if (vec->iv)
2884 memcpy(iv, vec->iv, i
2885 else
2886 memset(iv, 0, ivsize)
2887 } else {
2888 if (vec->generates_iv) {
2889 pr_err("alg: skcipher
2890 driver, vec_na
2891 return -EINVAL;
2892 }
2893 iv = NULL;
2894 }
2895
2896 /* Build the src/dst scatterlists */
2897 input.iov_base = enc ? (void *)vec->p
2898 input.iov_len = vec->len;
2899 err = build_cipher_test_sglists(tsgls
2900 vec->
2901 if (err) {
2902 pr_err("alg: skcipher: %s %s:
2903 driver, op, vec_name,
2904 return err;
2905 }
2906
2907 /* Do the actual encryption or decryp
2908 testmgr_poison(req->__ctx, crypto_skc
2909 skcipher_request_set_callback(req, re
2910 skcipher_request_set_crypt(req, tsgls
2911 vec->len,
2912 if (cfg->nosimd)
2913 crypto_disable_simd_for_test(
2914 err = enc ? crypto_skcipher_encrypt(r
2915 if (cfg->nosimd)
2916 crypto_reenable_simd_for_test
2917 err = crypto_wait_req(err, &wait);
2918
2919 /* Check that the algorithm didn't ov
2920 if (req->cryptlen != vec->len ||
2921 req->iv != iv ||
2922 req->src != tsgls->src.sgl_ptr ||
2923 req->dst != tsgls->dst.sgl_ptr ||
2924 crypto_skcipher_reqtfm(req) != tf
2925 req->base.complete != crypto_req_
2926 req->base.flags != req_flags ||
2927 req->base.data != &wait) {
2928 pr_err("alg: skcipher: %s %s
2929 driver, op, vec_name,
2930 if (req->cryptlen != vec->len
2931 pr_err("alg: skcipher
2932 if (req->iv != iv)
2933 pr_err("alg: skcipher
2934 if (req->src != tsgls->src.sg
2935 pr_err("alg: skcipher
2936 if (req->dst != tsgls->dst.sg
2937 pr_err("alg: skcipher
2938 if (crypto_skcipher_reqtfm(re
2939 pr_err("alg: skcipher
2940 if (req->base.complete != cry
2941 pr_err("alg: skcipher
2942 if (req->base.flags != req_fl
2943 pr_err("alg: skcipher
2944 if (req->base.data != &wait)
2945 pr_err("alg: skcipher
2946 return -EINVAL;
2947 }
2948 if (is_test_sglist_corrupted(&tsgls->
2949 pr_err("alg: skcipher: %s %s
2950 driver, op, vec_name,
2951 return -EINVAL;
2952 }
2953 if (tsgls->dst.sgl_ptr != tsgls->src.
2954 is_test_sglist_corrupted(&tsgls->
2955 pr_err("alg: skcipher: %s %s
2956 driver, op, vec_name,
2957 return -EINVAL;
2958 }
2959
2960 /* Check for success or failure */
2961 if (err) {
2962 if (err == vec->crypt_error)
2963 return 0;
2964 pr_err("alg: skcipher: %s %s
2965 driver, op, vec_name,
2966 return err;
2967 }
2968 if (vec->crypt_error) {
2969 pr_err("alg: skcipher: %s %s
2970 driver, op, vec_name,
2971 return -EINVAL;
2972 }
2973
2974 /* Check for the correct output (ciph
2975 err = verify_correct_output(&tsgls->d
2976 vec->len,
2977 if (err == -EOVERFLOW) {
2978 pr_err("alg: skcipher: %s %s
2979 driver, op, vec_name,
2980 return err;
2981 }
2982 if (err) {
2983 pr_err("alg: skcipher: %s %s
2984 driver, op, vec_name,
2985 return err;
2986 }
2987
2988 /* If applicable, check that the algo
2989 if (vec->iv_out && memcmp(iv, vec->iv
2990 pr_err("alg: skcipher: %s %s
2991 driver, op, vec_name,
2992 hexdump(iv, ivsize);
2993 return -EINVAL;
2994 }
2995
2996 return 0;
2997 }
2998
2999 static int test_skcipher_vec(int enc, const s
3000 unsigned int vec
3001 struct skcipher_
3002 struct cipher_te
3003 {
3004 char vec_name[16];
3005 unsigned int i;
3006 int err;
3007
3008 if (fips_enabled && vec->fips_skip)
3009 return 0;
3010
3011 sprintf(vec_name, "%u", vec_num);
3012
3013 for (i = 0; i < ARRAY_SIZE(default_ci
3014 err = test_skcipher_vec_cfg(e
3015 &
3016 r
3017 if (err)
3018 return err;
3019 }
3020
3021 #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS
3022 if (!noextratests) {
3023 struct rnd_state rng;
3024 struct testvec_config cfg;
3025 char cfgname[TESTVEC_CONFIG_N
3026
3027 init_rnd_state(&rng);
3028
3029 for (i = 0; i < fuzz_iteratio
3030 generate_random_testv
3031
3032 err = test_skcipher_v
3033
3034 if (err)
3035 return err;
3036 cond_resched();
3037 }
3038 }
3039 #endif
3040 return 0;
3041 }
3042
3043 #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS
3044 /*
3045 * Generate a symmetric cipher test vector fr
3046 * Assumes the buffers in 'vec' were already
3047 */
3048 static void generate_random_cipher_testvec(st
3049 st
3050 st
3051 un
3052 ch
3053 {
3054 struct crypto_skcipher *tfm = crypto_
3055 const unsigned int maxkeysize = crypt
3056 const unsigned int ivsize = crypto_sk
3057 struct scatterlist src, dst;
3058 u8 iv[MAX_IVLEN];
3059 DECLARE_CRYPTO_WAIT(wait);
3060
3061 /* Key: length in [0, maxkeysize], bu
3062 vec->klen = maxkeysize;
3063 if (prandom_u32_below(rng, 4) == 0)
3064 vec->klen = prandom_u32_below
3065 generate_random_bytes(rng, (u8 *)vec-
3066 vec->setkey_error = crypto_skcipher_s
3067
3068 /* IV */
3069 generate_random_bytes(rng, (u8 *)vec-
3070
3071 /* Plaintext */
3072 vec->len = generate_random_length(rng
3073 generate_random_bytes(rng, (u8 *)vec-
3074
3075 /* If the key couldn't be set, no nee
3076 if (vec->setkey_error)
3077 goto done;
3078
3079 /* Ciphertext */
3080 sg_init_one(&src, vec->ptext, vec->le
3081 sg_init_one(&dst, vec->ctext, vec->le
3082 memcpy(iv, vec->iv, ivsize);
3083 skcipher_request_set_callback(req, 0,
3084 skcipher_request_set_crypt(req, &src,
3085 vec->crypt_error = crypto_wait_req(cr
3086 if (vec->crypt_error != 0) {
3087 /*
3088 * The only acceptable error
3089 * skcipher decryption should
3090 * We'll test for this. But
3091 * explicitly initialize the
3092 */
3093 memset((u8 *)vec->ctext, 0, v
3094 }
3095 done:
3096 snprintf(name, max_namelen, "\"random
3097 vec->len, vec->klen);
3098 }
3099
3100 /*
3101 * Test the skcipher algorithm represented by
3102 * generic implementation, if one is availabl
3103 */
3104 static int test_skcipher_vs_generic_impl(cons
3105 stru
3106 stru
3107 {
3108 struct crypto_skcipher *tfm = crypto_
3109 const unsigned int maxkeysize = crypt
3110 const unsigned int ivsize = crypto_sk
3111 const unsigned int blocksize = crypto
3112 const unsigned int maxdatasize = (2 *
3113 const char *algname = crypto_skcipher
3114 const char *driver = crypto_skcipher_
3115 struct rnd_state rng;
3116 char _generic_driver[CRYPTO_MAX_ALG_N
3117 struct crypto_skcipher *generic_tfm =
3118 struct skcipher_request *generic_req
3119 unsigned int i;
3120 struct cipher_testvec vec = { 0 };
3121 char vec_name[64];
3122 struct testvec_config *cfg;
3123 char cfgname[TESTVEC_CONFIG_NAMELEN];
3124 int err;
3125
3126 if (noextratests)
3127 return 0;
3128
3129 /* Keywrap isn't supported here yet a
3130 if (strncmp(algname, "kw(", 3) == 0)
3131 return 0;
3132
3133 init_rnd_state(&rng);
3134
3135 if (!generic_driver) { /* Use default
3136 err = build_generic_driver_na
3137 if (err)
3138 return err;
3139 generic_driver = _generic_dri
3140 }
3141
3142 if (strcmp(generic_driver, driver) ==
3143 return 0;
3144
3145 generic_tfm = crypto_alloc_skcipher(g
3146 if (IS_ERR(generic_tfm)) {
3147 err = PTR_ERR(generic_tfm);
3148 if (err == -ENOENT) {
3149 pr_warn("alg: skciphe
3150 driver, gener
3151 return 0;
3152 }
3153 pr_err("alg: skcipher: error
3154 generic_driver, algnam
3155 return err;
3156 }
3157
3158 cfg = kzalloc(sizeof(*cfg), GFP_KERNE
3159 if (!cfg) {
3160 err = -ENOMEM;
3161 goto out;
3162 }
3163
3164 generic_req = skcipher_request_alloc(
3165 if (!generic_req) {
3166 err = -ENOMEM;
3167 goto out;
3168 }
3169
3170 /* Check the algorithm properties for
3171
3172 if (crypto_skcipher_min_keysize(tfm)
3173 crypto_skcipher_min_keysize(gener
3174 pr_err("alg: skcipher: min ke
3175 driver, crypto_skciphe
3176 crypto_skcipher_min_ke
3177 err = -EINVAL;
3178 goto out;
3179 }
3180
3181 if (maxkeysize != crypto_skcipher_max
3182 pr_err("alg: skcipher: max ke
3183 driver, maxkeysize,
3184 crypto_skcipher_max_ke
3185 err = -EINVAL;
3186 goto out;
3187 }
3188
3189 if (ivsize != crypto_skcipher_ivsize(
3190 pr_err("alg: skcipher: ivsize
3191 driver, ivsize, crypto
3192 err = -EINVAL;
3193 goto out;
3194 }
3195
3196 if (blocksize != crypto_skcipher_bloc
3197 pr_err("alg: skcipher: blocks
3198 driver, blocksize,
3199 crypto_skcipher_blocks
3200 err = -EINVAL;
3201 goto out;
3202 }
3203
3204 /*
3205 * Now generate test vectors using th
3206 * the other implementation against t
3207 */
3208
3209 vec.key = kmalloc(maxkeysize, GFP_KER
3210 vec.iv = kmalloc(ivsize, GFP_KERNEL);
3211 vec.ptext = kmalloc(maxdatasize, GFP_
3212 vec.ctext = kmalloc(maxdatasize, GFP_
3213 if (!vec.key || !vec.iv || !vec.ptext
3214 err = -ENOMEM;
3215 goto out;
3216 }
3217
3218 for (i = 0; i < fuzz_iterations * 8;
3219 generate_random_cipher_testve
3220
3221
3222 generate_random_testvec_confi
3223
3224
3225 err = test_skcipher_vec_cfg(E
3226 c
3227 if (err)
3228 goto out;
3229 err = test_skcipher_vec_cfg(D
3230 c
3231 if (err)
3232 goto out;
3233 cond_resched();
3234 }
3235 err = 0;
3236 out:
3237 kfree(cfg);
3238 kfree(vec.key);
3239 kfree(vec.iv);
3240 kfree(vec.ptext);
3241 kfree(vec.ctext);
3242 crypto_free_skcipher(generic_tfm);
3243 skcipher_request_free(generic_req);
3244 return err;
3245 }
3246 #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS *
3247 static int test_skcipher_vs_generic_impl(cons
3248 stru
3249 stru
3250 {
3251 return 0;
3252 }
3253 #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS
3254
3255 static int test_skcipher(int enc, const struc
3256 struct skcipher_requ
3257 struct cipher_test_s
3258 {
3259 unsigned int i;
3260 int err;
3261
3262 for (i = 0; i < suite->count; i++) {
3263 err = test_skcipher_vec(enc,
3264 if (err)
3265 return err;
3266 cond_resched();
3267 }
3268 return 0;
3269 }
3270
3271 static int alg_test_skcipher(const struct alg
3272 const char *driv
3273 {
3274 const struct cipher_test_suite *suite
3275 struct crypto_skcipher *tfm;
3276 struct skcipher_request *req = NULL;
3277 struct cipher_test_sglists *tsgls = N
3278 int err;
3279
3280 if (suite->count <= 0) {
3281 pr_err("alg: skcipher: empty
3282 return -EINVAL;
3283 }
3284
3285 tfm = crypto_alloc_skcipher(driver, t
3286 if (IS_ERR(tfm)) {
3287 if (PTR_ERR(tfm) == -ENOENT)
3288 return 0;
3289 pr_err("alg: skcipher: failed
3290 driver, PTR_ERR(tfm));
3291 return PTR_ERR(tfm);
3292 }
3293 driver = crypto_skcipher_driver_name(
3294
3295 req = skcipher_request_alloc(tfm, GFP
3296 if (!req) {
3297 pr_err("alg: skcipher: failed
3298 driver);
3299 err = -ENOMEM;
3300 goto out;
3301 }
3302
3303 tsgls = alloc_cipher_test_sglists();
3304 if (!tsgls) {
3305 pr_err("alg: skcipher: failed
3306 driver);
3307 err = -ENOMEM;
3308 goto out;
3309 }
3310
3311 err = test_skcipher(ENCRYPT, suite, r
3312 if (err)
3313 goto out;
3314
3315 err = test_skcipher(DECRYPT, suite, r
3316 if (err)
3317 goto out;
3318
3319 err = test_skcipher_vs_generic_impl(d
3320 out:
3321 free_cipher_test_sglists(tsgls);
3322 skcipher_request_free(req);
3323 crypto_free_skcipher(tfm);
3324 return err;
3325 }
3326
3327 static int test_comp(struct crypto_comp *tfm,
3328 const struct comp_testve
3329 const struct comp_testve
3330 int ctcount, int dtcount
3331 {
3332 const char *algo = crypto_tfm_alg_dri
3333 char *output, *decomp_output;
3334 unsigned int i;
3335 int ret;
3336
3337 output = kmalloc(COMP_BUF_SIZE, GFP_K
3338 if (!output)
3339 return -ENOMEM;
3340
3341 decomp_output = kmalloc(COMP_BUF_SIZE
3342 if (!decomp_output) {
3343 kfree(output);
3344 return -ENOMEM;
3345 }
3346
3347 for (i = 0; i < ctcount; i++) {
3348 int ilen;
3349 unsigned int dlen = COMP_BUF_
3350
3351 memset(output, 0, COMP_BUF_SI
3352 memset(decomp_output, 0, COMP
3353
3354 ilen = ctemplate[i].inlen;
3355 ret = crypto_comp_compress(tf
3356 il
3357 if (ret) {
3358 printk(KERN_ERR "alg:
3359 "on test %d fo
3360 -ret);
3361 goto out;
3362 }
3363
3364 ilen = dlen;
3365 dlen = COMP_BUF_SIZE;
3366 ret = crypto_comp_decompress(
3367
3368 if (ret) {
3369 pr_err("alg: comp: co
3370 i + 1, algo, -
3371 goto out;
3372 }
3373
3374 if (dlen != ctemplate[i].inle
3375 printk(KERN_ERR "alg:
3376 "failed for %s
3377 dlen);
3378 ret = -EINVAL;
3379 goto out;
3380 }
3381
3382 if (memcmp(decomp_output, cte
3383 ctemplate[i].inlen
3384 pr_err("alg: comp: co
3385 i + 1, algo);
3386 hexdump(decomp_output
3387 ret = -EINVAL;
3388 goto out;
3389 }
3390 }
3391
3392 for (i = 0; i < dtcount; i++) {
3393 int ilen;
3394 unsigned int dlen = COMP_BUF_
3395
3396 memset(decomp_output, 0, COMP
3397
3398 ilen = dtemplate[i].inlen;
3399 ret = crypto_comp_decompress(
3400
3401 if (ret) {
3402 printk(KERN_ERR "alg:
3403 "on test %d fo
3404 -ret);
3405 goto out;
3406 }
3407
3408 if (dlen != dtemplate[i].outl
3409 printk(KERN_ERR "alg:
3410 "failed for %s
3411 dlen);
3412 ret = -EINVAL;
3413 goto out;
3414 }
3415
3416 if (memcmp(decomp_output, dte
3417 printk(KERN_ERR "alg:
3418 "failed for %s
3419 hexdump(decomp_output
3420 ret = -EINVAL;
3421 goto out;
3422 }
3423 }
3424
3425 ret = 0;
3426
3427 out:
3428 kfree(decomp_output);
3429 kfree(output);
3430 return ret;
3431 }
3432
3433 static int test_acomp(struct crypto_acomp *tf
3434 const struct comp_testv
3435 const struct comp_testv
3436 int ctcount, int dtcoun
3437 {
3438 const char *algo = crypto_tfm_alg_dri
3439 unsigned int i;
3440 char *output, *decomp_out;
3441 int ret;
3442 struct scatterlist src, dst;
3443 struct acomp_req *req;
3444 struct crypto_wait wait;
3445
3446 output = kmalloc(COMP_BUF_SIZE, GFP_K
3447 if (!output)
3448 return -ENOMEM;
3449
3450 decomp_out = kmalloc(COMP_BUF_SIZE, G
3451 if (!decomp_out) {
3452 kfree(output);
3453 return -ENOMEM;
3454 }
3455
3456 for (i = 0; i < ctcount; i++) {
3457 unsigned int dlen = COMP_BUF_
3458 int ilen = ctemplate[i].inlen
3459 void *input_vec;
3460
3461 input_vec = kmemdup(ctemplate
3462 if (!input_vec) {
3463 ret = -ENOMEM;
3464 goto out;
3465 }
3466
3467 memset(output, 0, dlen);
3468 crypto_init_wait(&wait);
3469 sg_init_one(&src, input_vec,
3470 sg_init_one(&dst, output, dle
3471
3472 req = acomp_request_alloc(tfm
3473 if (!req) {
3474 pr_err("alg: acomp: r
3475 algo);
3476 kfree(input_vec);
3477 ret = -ENOMEM;
3478 goto out;
3479 }
3480
3481 acomp_request_set_params(req,
3482 acomp_request_set_callback(re
3483 cr
3484
3485 ret = crypto_wait_req(crypto_
3486 if (ret) {
3487 pr_err("alg: acomp: c
3488 i + 1, algo, -
3489 kfree(input_vec);
3490 acomp_request_free(re
3491 goto out;
3492 }
3493
3494 ilen = req->dlen;
3495 dlen = COMP_BUF_SIZE;
3496 sg_init_one(&src, output, ile
3497 sg_init_one(&dst, decomp_out,
3498 crypto_init_wait(&wait);
3499 acomp_request_set_params(req,
3500
3501 ret = crypto_wait_req(crypto_
3502 if (ret) {
3503 pr_err("alg: acomp: c
3504 i + 1, algo, -
3505 kfree(input_vec);
3506 acomp_request_free(re
3507 goto out;
3508 }
3509
3510 if (req->dlen != ctemplate[i]
3511 pr_err("alg: acomp: C
3512 i + 1, algo, r
3513 ret = -EINVAL;
3514 kfree(input_vec);
3515 acomp_request_free(re
3516 goto out;
3517 }
3518
3519 if (memcmp(input_vec, decomp_
3520 pr_err("alg: acomp: C
3521 i + 1, algo);
3522 hexdump(output, req->
3523 ret = -EINVAL;
3524 kfree(input_vec);
3525 acomp_request_free(re
3526 goto out;
3527 }
3528
3529 #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS
3530 crypto_init_wait(&wait);
3531 sg_init_one(&src, input_vec,
3532 acomp_request_set_params(req,
3533
3534 ret = crypto_wait_req(crypto_
3535 if (ret) {
3536 pr_err("alg: acomp: c
3537 i + 1, algo, -
3538 kfree(input_vec);
3539 acomp_request_free(re
3540 goto out;
3541 }
3542 #endif
3543
3544 kfree(input_vec);
3545 acomp_request_free(req);
3546 }
3547
3548 for (i = 0; i < dtcount; i++) {
3549 unsigned int dlen = COMP_BUF_
3550 int ilen = dtemplate[i].inlen
3551 void *input_vec;
3552
3553 input_vec = kmemdup(dtemplate
3554 if (!input_vec) {
3555 ret = -ENOMEM;
3556 goto out;
3557 }
3558
3559 memset(output, 0, dlen);
3560 crypto_init_wait(&wait);
3561 sg_init_one(&src, input_vec,
3562 sg_init_one(&dst, output, dle
3563
3564 req = acomp_request_alloc(tfm
3565 if (!req) {
3566 pr_err("alg: acomp: r
3567 algo);
3568 kfree(input_vec);
3569 ret = -ENOMEM;
3570 goto out;
3571 }
3572
3573 acomp_request_set_params(req,
3574 acomp_request_set_callback(re
3575 cr
3576
3577 ret = crypto_wait_req(crypto_
3578 if (ret) {
3579 pr_err("alg: acomp: d
3580 i + 1, algo, -
3581 kfree(input_vec);
3582 acomp_request_free(re
3583 goto out;
3584 }
3585
3586 if (req->dlen != dtemplate[i]
3587 pr_err("alg: acomp: D
3588 i + 1, algo, r
3589 ret = -EINVAL;
3590 kfree(input_vec);
3591 acomp_request_free(re
3592 goto out;
3593 }
3594
3595 if (memcmp(output, dtemplate[
3596 pr_err("alg: acomp: D
3597 i + 1, algo);
3598 hexdump(output, req->
3599 ret = -EINVAL;
3600 kfree(input_vec);
3601 acomp_request_free(re
3602 goto out;
3603 }
3604
3605 #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS
3606 crypto_init_wait(&wait);
3607 acomp_request_set_params(req,
3608
3609 ret = crypto_wait_req(crypto_
3610 if (ret) {
3611 pr_err("alg: acomp: d
3612 i + 1, algo, -
3613 kfree(input_vec);
3614 acomp_request_free(re
3615 goto out;
3616 }
3617 #endif
3618
3619 kfree(input_vec);
3620 acomp_request_free(req);
3621 }
3622
3623 ret = 0;
3624
3625 out:
3626 kfree(decomp_out);
3627 kfree(output);
3628 return ret;
3629 }
3630
3631 static int test_cprng(struct crypto_rng *tfm,
3632 const struct cprng_test
3633 unsigned int tcount)
3634 {
3635 const char *algo = crypto_tfm_alg_dri
3636 int err = 0, i, j, seedsize;
3637 u8 *seed;
3638 char result[32];
3639
3640 seedsize = crypto_rng_seedsize(tfm);
3641
3642 seed = kmalloc(seedsize, GFP_KERNEL);
3643 if (!seed) {
3644 printk(KERN_ERR "alg: cprng:
3645 "for %s\n", algo);
3646 return -ENOMEM;
3647 }
3648
3649 for (i = 0; i < tcount; i++) {
3650 memset(result, 0, 32);
3651
3652 memcpy(seed, template[i].v, t
3653 memcpy(seed + template[i].vle
3654 template[i].klen);
3655 memcpy(seed + template[i].vle
3656 template[i].dt, templa
3657
3658 err = crypto_rng_reset(tfm, s
3659 if (err) {
3660 printk(KERN_ERR "alg:
3661 "for %s\n", al
3662 goto out;
3663 }
3664
3665 for (j = 0; j < template[i].l
3666 err = crypto_rng_get_
3667
3668 if (err < 0) {
3669 printk(KERN_E
3670 "the c
3671 "%s (r
3672 templa
3673 goto out;
3674 }
3675 }
3676
3677 err = memcmp(result, template
3678 template[i].rlen
3679 if (err) {
3680 printk(KERN_ERR "alg:
3681 i, algo);
3682 hexdump(result, templ
3683 err = -EINVAL;
3684 goto out;
3685 }
3686 }
3687
3688 out:
3689 kfree(seed);
3690 return err;
3691 }
3692
3693 static int alg_test_cipher(const struct alg_t
3694 const char *driver
3695 {
3696 const struct cipher_test_suite *suite
3697 struct crypto_cipher *tfm;
3698 int err;
3699
3700 tfm = crypto_alloc_cipher(driver, typ
3701 if (IS_ERR(tfm)) {
3702 if (PTR_ERR(tfm) == -ENOENT)
3703 return 0;
3704 printk(KERN_ERR "alg: cipher:
3705 "%s: %ld\n", driver, P
3706 return PTR_ERR(tfm);
3707 }
3708
3709 err = test_cipher(tfm, ENCRYPT, suite
3710 if (!err)
3711 err = test_cipher(tfm, DECRYP
3712
3713 crypto_free_cipher(tfm);
3714 return err;
3715 }
3716
3717 static int alg_test_comp(const struct alg_tes
3718 u32 type, u32 mask)
3719 {
3720 struct crypto_comp *comp;
3721 struct crypto_acomp *acomp;
3722 int err;
3723 u32 algo_type = type & CRYPTO_ALG_TYP
3724
3725 if (algo_type == CRYPTO_ALG_TYPE_ACOM
3726 acomp = crypto_alloc_acomp(dr
3727 if (IS_ERR(acomp)) {
3728 if (PTR_ERR(acomp) ==
3729 return 0;
3730 pr_err("alg: acomp: F
3731 driver, PTR_ER
3732 return PTR_ERR(acomp)
3733 }
3734 err = test_acomp(acomp, desc-
3735 desc->suite.
3736 desc->suite.
3737 desc->suite.
3738 crypto_free_acomp(acomp);
3739 } else {
3740 comp = crypto_alloc_comp(driv
3741 if (IS_ERR(comp)) {
3742 if (PTR_ERR(comp) ==
3743 return 0;
3744 pr_err("alg: comp: Fa
3745 driver, PTR_ER
3746 return PTR_ERR(comp);
3747 }
3748
3749 err = test_comp(comp, desc->s
3750 desc->suite.c
3751 desc->suite.c
3752 desc->suite.c
3753
3754 crypto_free_comp(comp);
3755 }
3756 return err;
3757 }
3758
3759 static int alg_test_crc32c(const struct alg_t
3760 const char *driver
3761 {
3762 struct crypto_shash *tfm;
3763 __le32 val;
3764 int err;
3765
3766 err = alg_test_hash(desc, driver, typ
3767 if (err)
3768 return err;
3769
3770 tfm = crypto_alloc_shash(driver, type
3771 if (IS_ERR(tfm)) {
3772 if (PTR_ERR(tfm) == -ENOENT)
3773 /*
3774 * This crc32c implem
3775 * ahash API, not the
3776 * of the test is not
3777 */
3778 return 0;
3779 }
3780 printk(KERN_ERR "alg: crc32c:
3781 "%ld\n", driver, PTR_E
3782 return PTR_ERR(tfm);
3783 }
3784 driver = crypto_shash_driver_name(tfm
3785
3786 do {
3787 SHASH_DESC_ON_STACK(shash, tf
3788 u32 *ctx = (u32 *)shash_desc_
3789
3790 shash->tfm = tfm;
3791
3792 *ctx = 420553207;
3793 err = crypto_shash_final(shas
3794 if (err) {
3795 printk(KERN_ERR "alg:
3796 "%s: %d\n", dr
3797 break;
3798 }
3799
3800 if (val != cpu_to_le32(~42055
3801 pr_err("alg: crc32c:
3802 driver, le32_t
3803 err = -EINVAL;
3804 }
3805 } while (0);
3806
3807 crypto_free_shash(tfm);
3808
3809 return err;
3810 }
3811
3812 static int alg_test_cprng(const struct alg_te
3813 u32 type, u32 mask)
3814 {
3815 struct crypto_rng *rng;
3816 int err;
3817
3818 rng = crypto_alloc_rng(driver, type,
3819 if (IS_ERR(rng)) {
3820 if (PTR_ERR(rng) == -ENOENT)
3821 return 0;
3822 printk(KERN_ERR "alg: cprng:
3823 "%ld\n", driver, PTR_E
3824 return PTR_ERR(rng);
3825 }
3826
3827 err = test_cprng(rng, desc->suite.cpr
3828
3829 crypto_free_rng(rng);
3830
3831 return err;
3832 }
3833
3834
3835 static int drbg_cavs_test(const struct drbg_t
3836 const char *driver,
3837 {
3838 int ret = -EAGAIN;
3839 struct crypto_rng *drng;
3840 struct drbg_test_data test_data;
3841 struct drbg_string addtl, pers, teste
3842 unsigned char *buf = kzalloc(test->ex
3843
3844 if (!buf)
3845 return -ENOMEM;
3846
3847 drng = crypto_alloc_rng(driver, type,
3848 if (IS_ERR(drng)) {
3849 kfree_sensitive(buf);
3850 if (PTR_ERR(drng) == -ENOENT)
3851 return 0;
3852 printk(KERN_ERR "alg: drbg: c
3853 "%s\n", driver);
3854 return PTR_ERR(drng);
3855 }
3856
3857 test_data.testentropy = &testentropy;
3858 drbg_string_fill(&testentropy, test->
3859 drbg_string_fill(&pers, test->pers, t
3860 ret = crypto_drbg_reset_test(drng, &p
3861 if (ret) {
3862 printk(KERN_ERR "alg: drbg: F
3863 goto outbuf;
3864 }
3865
3866 drbg_string_fill(&addtl, test->addtla
3867 if (pr) {
3868 drbg_string_fill(&testentropy
3869 ret = crypto_drbg_get_bytes_a
3870 buf, test->expectedle
3871 } else {
3872 ret = crypto_drbg_get_bytes_a
3873 buf, test->expectedle
3874 }
3875 if (ret < 0) {
3876 printk(KERN_ERR "alg: drbg: c
3877 "driver %s\n", driver)
3878 goto outbuf;
3879 }
3880
3881 drbg_string_fill(&addtl, test->addtlb
3882 if (pr) {
3883 drbg_string_fill(&testentropy
3884 ret = crypto_drbg_get_bytes_a
3885 buf, test->expectedle
3886 } else {
3887 ret = crypto_drbg_get_bytes_a
3888 buf, test->expectedle
3889 }
3890 if (ret < 0) {
3891 printk(KERN_ERR "alg: drbg: c
3892 "driver %s\n", driver)
3893 goto outbuf;
3894 }
3895
3896 ret = memcmp(test->expected, buf, tes
3897
3898 outbuf:
3899 crypto_free_rng(drng);
3900 kfree_sensitive(buf);
3901 return ret;
3902 }
3903
3904
3905 static int alg_test_drbg(const struct alg_tes
3906 u32 type, u32 mask)
3907 {
3908 int err = 0;
3909 int pr = 0;
3910 int i = 0;
3911 const struct drbg_testvec *template =
3912 unsigned int tcount = desc->suite.drb
3913
3914 if (0 == memcmp(driver, "drbg_pr_", 8
3915 pr = 1;
3916
3917 for (i = 0; i < tcount; i++) {
3918 err = drbg_cavs_test(&templat
3919 if (err) {
3920 printk(KERN_ERR "alg:
3921 i, driver);
3922 err = -EINVAL;
3923 break;
3924 }
3925 }
3926 return err;
3927
3928 }
3929
3930 static int do_test_kpp(struct crypto_kpp *tfm
3931 const char *alg)
3932 {
3933 struct kpp_request *req;
3934 void *input_buf = NULL;
3935 void *output_buf = NULL;
3936 void *a_public = NULL;
3937 void *a_ss = NULL;
3938 void *shared_secret = NULL;
3939 struct crypto_wait wait;
3940 unsigned int out_len_max;
3941 int err = -ENOMEM;
3942 struct scatterlist src, dst;
3943
3944 req = kpp_request_alloc(tfm, GFP_KERN
3945 if (!req)
3946 return err;
3947
3948 crypto_init_wait(&wait);
3949
3950 err = crypto_kpp_set_secret(tfm, vec-
3951 if (err < 0)
3952 goto free_req;
3953
3954 out_len_max = crypto_kpp_maxsize(tfm)
3955 output_buf = kzalloc(out_len_max, GFP
3956 if (!output_buf) {
3957 err = -ENOMEM;
3958 goto free_req;
3959 }
3960
3961 /* Use appropriate parameter as base
3962 kpp_request_set_input(req, NULL, 0);
3963 sg_init_one(&dst, output_buf, out_len
3964 kpp_request_set_output(req, &dst, out
3965 kpp_request_set_callback(req, CRYPTO_
3966 crypto_req_d
3967
3968 /* Compute party A's public key */
3969 err = crypto_wait_req(crypto_kpp_gene
3970 if (err) {
3971 pr_err("alg: %s: Party A: gen
3972 alg, err);
3973 goto free_output;
3974 }
3975
3976 if (vec->genkey) {
3977 /* Save party A's public key
3978 a_public = kmemdup(sg_virt(re
3979 if (!a_public) {
3980 err = -ENOMEM;
3981 goto free_output;
3982 }
3983 } else {
3984 /* Verify calculated public k
3985 if (memcmp(vec->expected_a_pu
3986 vec->expected_a_pu
3987 pr_err("alg: %s: Part
3988 alg);
3989 err = -EINVAL;
3990 goto free_output;
3991 }
3992 }
3993
3994 /* Calculate shared secret key by usi
3995 input_buf = kmemdup(vec->b_public, ve
3996 if (!input_buf) {
3997 err = -ENOMEM;
3998 goto free_output;
3999 }
4000
4001 sg_init_one(&src, input_buf, vec->b_p
4002 sg_init_one(&dst, output_buf, out_len
4003 kpp_request_set_input(req, &src, vec-
4004 kpp_request_set_output(req, &dst, out
4005 kpp_request_set_callback(req, CRYPTO_
4006 crypto_req_d
4007 err = crypto_wait_req(crypto_kpp_comp
4008 if (err) {
4009 pr_err("alg: %s: Party A: com
4010 alg, err);
4011 goto free_all;
4012 }
4013
4014 if (vec->genkey) {
4015 /* Save the shared secret obt
4016 a_ss = kmemdup(sg_virt(req->d
4017 if (!a_ss) {
4018 err = -ENOMEM;
4019 goto free_all;
4020 }
4021
4022 /*
4023 * Calculate party B's shared
4024 * public key.
4025 */
4026 err = crypto_kpp_set_secret(t
4027 v
4028 if (err < 0)
4029 goto free_all;
4030
4031 sg_init_one(&src, a_public, v
4032 sg_init_one(&dst, output_buf,
4033 kpp_request_set_input(req, &s
4034 kpp_request_set_output(req, &
4035 kpp_request_set_callback(req,
4036 cryp
4037 err = crypto_wait_req(crypto_
4038 &wait);
4039 if (err) {
4040 pr_err("alg: %s: Part
4041 alg, err);
4042 goto free_all;
4043 }
4044
4045 shared_secret = a_ss;
4046 } else {
4047 shared_secret = (void *)vec->
4048 }
4049
4050 /*
4051 * verify shared secret from which th
4052 * secret key by executing whatever h
4053 */
4054 if (memcmp(shared_secret, sg_virt(req
4055 vec->expected_ss_size)) {
4056 pr_err("alg: %s: compute shar
4057 alg);
4058 err = -EINVAL;
4059 }
4060
4061 free_all:
4062 kfree(a_ss);
4063 kfree(input_buf);
4064 free_output:
4065 kfree(a_public);
4066 kfree(output_buf);
4067 free_req:
4068 kpp_request_free(req);
4069 return err;
4070 }
4071
4072 static int test_kpp(struct crypto_kpp *tfm, c
4073 const struct kpp_testvec
4074 {
4075 int ret, i;
4076
4077 for (i = 0; i < tcount; i++) {
4078 ret = do_test_kpp(tfm, vecs++
4079 if (ret) {
4080 pr_err("alg: %s: test
4081 alg, i + 1, re
4082 return ret;
4083 }
4084 }
4085 return 0;
4086 }
4087
4088 static int alg_test_kpp(const struct alg_test
4089 u32 type, u32 mask)
4090 {
4091 struct crypto_kpp *tfm;
4092 int err = 0;
4093
4094 tfm = crypto_alloc_kpp(driver, type,
4095 if (IS_ERR(tfm)) {
4096 if (PTR_ERR(tfm) == -ENOENT)
4097 return 0;
4098 pr_err("alg: kpp: Failed to l
4099 driver, PTR_ERR(tfm));
4100 return PTR_ERR(tfm);
4101 }
4102 if (desc->suite.kpp.vecs)
4103 err = test_kpp(tfm, desc->alg
4104 desc->suite.kp
4105
4106 crypto_free_kpp(tfm);
4107 return err;
4108 }
4109
4110 static u8 *test_pack_u32(u8 *dst, u32 val)
4111 {
4112 memcpy(dst, &val, sizeof(val));
4113 return dst + sizeof(val);
4114 }
4115
4116 static int test_akcipher_one(struct crypto_ak
4117 const struct akc
4118 {
4119 char *xbuf[XBUFSIZE];
4120 struct akcipher_request *req;
4121 void *outbuf_enc = NULL;
4122 void *outbuf_dec = NULL;
4123 struct crypto_wait wait;
4124 unsigned int out_len_max, out_len = 0
4125 int err = -ENOMEM;
4126 struct scatterlist src, dst, src_tab[
4127 const char *m, *c;
4128 unsigned int m_size, c_size;
4129 const char *op;
4130 u8 *key, *ptr;
4131
4132 if (testmgr_alloc_buf(xbuf))
4133 return err;
4134
4135 req = akcipher_request_alloc(tfm, GFP
4136 if (!req)
4137 goto free_xbuf;
4138
4139 crypto_init_wait(&wait);
4140
4141 key = kmalloc(vecs->key_len + sizeof(
4142 GFP_KERNEL);
4143 if (!key)
4144 goto free_req;
4145 memcpy(key, vecs->key, vecs->key_len)
4146 ptr = key + vecs->key_len;
4147 ptr = test_pack_u32(ptr, vecs->algo);
4148 ptr = test_pack_u32(ptr, vecs->param_
4149 memcpy(ptr, vecs->params, vecs->param
4150
4151 if (vecs->public_key_vec)
4152 err = crypto_akcipher_set_pub
4153 else
4154 err = crypto_akcipher_set_pri
4155 if (err)
4156 goto free_key;
4157
4158 /*
4159 * First run test which do not requir
4160 * encrypt or verify.
4161 */
4162 err = -ENOMEM;
4163 out_len_max = crypto_akcipher_maxsize
4164 outbuf_enc = kzalloc(out_len_max, GFP
4165 if (!outbuf_enc)
4166 goto free_key;
4167
4168 if (!vecs->siggen_sigver_test) {
4169 m = vecs->m;
4170 m_size = vecs->m_size;
4171 c = vecs->c;
4172 c_size = vecs->c_size;
4173 op = "encrypt";
4174 } else {
4175 /* Swap args so we could keep
4176 * in vecs->m, and cooked sig
4177 */
4178 m = vecs->c; /* signature */
4179 m_size = vecs->c_size;
4180 c = vecs->m; /* digest */
4181 c_size = vecs->m_size;
4182 op = "verify";
4183 }
4184
4185 err = -E2BIG;
4186 if (WARN_ON(m_size > PAGE_SIZE))
4187 goto free_all;
4188 memcpy(xbuf[0], m, m_size);
4189
4190 sg_init_table(src_tab, 3);
4191 sg_set_buf(&src_tab[0], xbuf[0], 8);
4192 sg_set_buf(&src_tab[1], xbuf[0] + 8,
4193 if (vecs->siggen_sigver_test) {
4194 if (WARN_ON(c_size > PAGE_SIZ
4195 goto free_all;
4196 memcpy(xbuf[1], c, c_size);
4197 sg_set_buf(&src_tab[2], xbuf[
4198 akcipher_request_set_crypt(re
4199 } else {
4200 sg_init_one(&dst, outbuf_enc,
4201 akcipher_request_set_crypt(re
4202 ou
4203 }
4204 akcipher_request_set_callback(req, CR
4205 crypto_
4206
4207 err = crypto_wait_req(vecs->siggen_si
4208 /* Run asymmetr
4209 crypto_akcipher
4210 /* Run asymmetr
4211 crypto_akcipher
4212 if (err) {
4213 pr_err("alg: akcipher: %s tes
4214 goto free_all;
4215 }
4216 if (!vecs->siggen_sigver_test && c) {
4217 if (req->dst_len != c_size) {
4218 pr_err("alg: akcipher
4219 op);
4220 err = -EINVAL;
4221 goto free_all;
4222 }
4223 /* verify that encrypted mess
4224 if (memcmp(c, outbuf_enc, c_s
4225 pr_err("alg: akcipher
4226 op);
4227 hexdump(outbuf_enc, c
4228 err = -EINVAL;
4229 goto free_all;
4230 }
4231 }
4232
4233 /*
4234 * Don't invoke (decrypt or sign) tes
4235 * for vectors with only a public key
4236 */
4237 if (vecs->public_key_vec) {
4238 err = 0;
4239 goto free_all;
4240 }
4241 outbuf_dec = kzalloc(out_len_max, GFP
4242 if (!outbuf_dec) {
4243 err = -ENOMEM;
4244 goto free_all;
4245 }
4246
4247 if (!vecs->siggen_sigver_test && !c)
4248 c = outbuf_enc;
4249 c_size = req->dst_len;
4250 }
4251
4252 err = -E2BIG;
4253 op = vecs->siggen_sigver_test ? "sign
4254 if (WARN_ON(c_size > PAGE_SIZE))
4255 goto free_all;
4256 memcpy(xbuf[0], c, c_size);
4257
4258 sg_init_one(&src, xbuf[0], c_size);
4259 sg_init_one(&dst, outbuf_dec, out_len
4260 crypto_init_wait(&wait);
4261 akcipher_request_set_crypt(req, &src,
4262
4263 err = crypto_wait_req(vecs->siggen_si
4264 /* Run asymmetr
4265 crypto_akcipher
4266 /* Run asymmetr
4267 crypto_akcipher
4268 if (err) {
4269 pr_err("alg: akcipher: %s tes
4270 goto free_all;
4271 }
4272 out_len = req->dst_len;
4273 if (out_len < m_size) {
4274 pr_err("alg: akcipher: %s tes
4275 op, out_len);
4276 err = -EINVAL;
4277 goto free_all;
4278 }
4279 /* verify that decrypted message is e
4280 if (memchr_inv(outbuf_dec, 0, out_len
4281 memcmp(m, outbuf_dec + out_len -
4282 pr_err("alg: akcipher: %s tes
4283 hexdump(outbuf_dec, out_len);
4284 err = -EINVAL;
4285 }
4286 free_all:
4287 kfree(outbuf_dec);
4288 kfree(outbuf_enc);
4289 free_key:
4290 kfree(key);
4291 free_req:
4292 akcipher_request_free(req);
4293 free_xbuf:
4294 testmgr_free_buf(xbuf);
4295 return err;
4296 }
4297
4298 static int test_akcipher(struct crypto_akciph
4299 const struct akciphe
4300 unsigned int tcount)
4301 {
4302 const char *algo =
4303 crypto_tfm_alg_driver_name(cr
4304 int ret, i;
4305
4306 for (i = 0; i < tcount; i++) {
4307 ret = test_akcipher_one(tfm,
4308 if (!ret)
4309 continue;
4310
4311 pr_err("alg: akcipher: test %
4312 i + 1, algo, ret);
4313 return ret;
4314 }
4315 return 0;
4316 }
4317
4318 static int alg_test_akcipher(const struct alg
4319 const char *driv
4320 {
4321 struct crypto_akcipher *tfm;
4322 int err = 0;
4323
4324 tfm = crypto_alloc_akcipher(driver, t
4325 if (IS_ERR(tfm)) {
4326 if (PTR_ERR(tfm) == -ENOENT)
4327 return 0;
4328 pr_err("alg: akcipher: Failed
4329 driver, PTR_ERR(tfm));
4330 return PTR_ERR(tfm);
4331 }
4332 if (desc->suite.akcipher.vecs)
4333 err = test_akcipher(tfm, desc
4334 desc->sui
4335
4336 crypto_free_akcipher(tfm);
4337 return err;
4338 }
4339
4340 static int alg_test_null(const struct alg_tes
4341 const char *driv
4342 {
4343 return 0;
4344 }
4345
4346 #define ____VECS(tv) .vecs = tv, .count =
4347 #define __VECS(tv) { ____VECS(tv) }
4348
4349 /* Please keep this list sorted by algorithm
4350 static const struct alg_test_desc alg_test_de
4351 {
4352 .alg = "adiantum(xchacha12,ae
4353 .generic_driver = "adiantum(x
4354 .test = alg_test_skcipher,
4355 .suite = {
4356 .cipher = __VECS(adia
4357 },
4358 }, {
4359 .alg = "adiantum(xchacha20,ae
4360 .generic_driver = "adiantum(x
4361 .test = alg_test_skcipher,
4362 .suite = {
4363 .cipher = __VECS(adia
4364 },
4365 }, {
4366 .alg = "aegis128",
4367 .test = alg_test_aead,
4368 .suite = {
4369 .aead = __VECS(aegis1
4370 }
4371 }, {
4372 .alg = "ansi_cprng",
4373 .test = alg_test_cprng,
4374 .suite = {
4375 .cprng = __VECS(ansi_
4376 }
4377 }, {
4378 .alg = "authenc(hmac(md5),ecb
4379 .test = alg_test_aead,
4380 .suite = {
4381 .aead = __VECS(hmac_m
4382 }
4383 }, {
4384 .alg = "authenc(hmac(sha1),cb
4385 .test = alg_test_aead,
4386 .fips_allowed = 1,
4387 .suite = {
4388 .aead = __VECS(hmac_s
4389 }
4390 }, {
4391 .alg = "authenc(hmac(sha1),cb
4392 .test = alg_test_aead,
4393 .suite = {
4394 .aead = __VECS(hmac_s
4395 }
4396 }, {
4397 .alg = "authenc(hmac(sha1),cb
4398 .test = alg_test_aead,
4399 .suite = {
4400 .aead = __VECS(hmac_s
4401 }
4402 }, {
4403 .alg = "authenc(hmac(sha1),ct
4404 .test = alg_test_null,
4405 .fips_allowed = 1,
4406 }, {
4407 .alg = "authenc(hmac(sha1),ec
4408 .test = alg_test_aead,
4409 .suite = {
4410 .aead = __VECS(hmac_s
4411 }
4412 }, {
4413 .alg = "authenc(hmac(sha1),rf
4414 .test = alg_test_null,
4415 .fips_allowed = 1,
4416 }, {
4417 .alg = "authenc(hmac(sha224),
4418 .test = alg_test_aead,
4419 .suite = {
4420 .aead = __VECS(hmac_s
4421 }
4422 }, {
4423 .alg = "authenc(hmac(sha224),
4424 .test = alg_test_aead,
4425 .suite = {
4426 .aead = __VECS(hmac_s
4427 }
4428 }, {
4429 .alg = "authenc(hmac(sha256),
4430 .test = alg_test_aead,
4431 .fips_allowed = 1,
4432 .suite = {
4433 .aead = __VECS(hmac_s
4434 }
4435 }, {
4436 .alg = "authenc(hmac(sha256),
4437 .test = alg_test_aead,
4438 .suite = {
4439 .aead = __VECS(hmac_s
4440 }
4441 }, {
4442 .alg = "authenc(hmac(sha256),
4443 .test = alg_test_aead,
4444 .suite = {
4445 .aead = __VECS(hmac_s
4446 }
4447 }, {
4448 .alg = "authenc(hmac(sha256),
4449 .test = alg_test_null,
4450 .fips_allowed = 1,
4451 }, {
4452 .alg = "authenc(hmac(sha256),
4453 .test = alg_test_null,
4454 .fips_allowed = 1,
4455 }, {
4456 .alg = "authenc(hmac(sha384),
4457 .test = alg_test_aead,
4458 .suite = {
4459 .aead = __VECS(hmac_s
4460 }
4461 }, {
4462 .alg = "authenc(hmac(sha384),
4463 .test = alg_test_aead,
4464 .suite = {
4465 .aead = __VECS(hmac_s
4466 }
4467 }, {
4468 .alg = "authenc(hmac(sha384),
4469 .test = alg_test_null,
4470 .fips_allowed = 1,
4471 }, {
4472 .alg = "authenc(hmac(sha384),
4473 .test = alg_test_null,
4474 .fips_allowed = 1,
4475 }, {
4476 .alg = "authenc(hmac(sha512),
4477 .fips_allowed = 1,
4478 .test = alg_test_aead,
4479 .suite = {
4480 .aead = __VECS(hmac_s
4481 }
4482 }, {
4483 .alg = "authenc(hmac(sha512),
4484 .test = alg_test_aead,
4485 .suite = {
4486 .aead = __VECS(hmac_s
4487 }
4488 }, {
4489 .alg = "authenc(hmac(sha512),
4490 .test = alg_test_aead,
4491 .suite = {
4492 .aead = __VECS(hmac_s
4493 }
4494 }, {
4495 .alg = "authenc(hmac(sha512),
4496 .test = alg_test_null,
4497 .fips_allowed = 1,
4498 }, {
4499 .alg = "authenc(hmac(sha512),
4500 .test = alg_test_null,
4501 .fips_allowed = 1,
4502 }, {
4503 .alg = "blake2b-160",
4504 .test = alg_test_hash,
4505 .fips_allowed = 0,
4506 .suite = {
4507 .hash = __VECS(blake2
4508 }
4509 }, {
4510 .alg = "blake2b-256",
4511 .test = alg_test_hash,
4512 .fips_allowed = 0,
4513 .suite = {
4514 .hash = __VECS(blake2
4515 }
4516 }, {
4517 .alg = "blake2b-384",
4518 .test = alg_test_hash,
4519 .fips_allowed = 0,
4520 .suite = {
4521 .hash = __VECS(blake2
4522 }
4523 }, {
4524 .alg = "blake2b-512",
4525 .test = alg_test_hash,
4526 .fips_allowed = 0,
4527 .suite = {
4528 .hash = __VECS(blake2
4529 }
4530 }, {
4531 .alg = "cbc(aes)",
4532 .test = alg_test_skcipher,
4533 .fips_allowed = 1,
4534 .suite = {
4535 .cipher = __VECS(aes_
4536 },
4537 }, {
4538 .alg = "cbc(anubis)",
4539 .test = alg_test_skcipher,
4540 .suite = {
4541 .cipher = __VECS(anub
4542 },
4543 }, {
4544 .alg = "cbc(aria)",
4545 .test = alg_test_skcipher,
4546 .suite = {
4547 .cipher = __VECS(aria
4548 },
4549 }, {
4550 .alg = "cbc(blowfish)",
4551 .test = alg_test_skcipher,
4552 .suite = {
4553 .cipher = __VECS(bf_c
4554 },
4555 }, {
4556 .alg = "cbc(camellia)",
4557 .test = alg_test_skcipher,
4558 .suite = {
4559 .cipher = __VECS(came
4560 },
4561 }, {
4562 .alg = "cbc(cast5)",
4563 .test = alg_test_skcipher,
4564 .suite = {
4565 .cipher = __VECS(cast
4566 },
4567 }, {
4568 .alg = "cbc(cast6)",
4569 .test = alg_test_skcipher,
4570 .suite = {
4571 .cipher = __VECS(cast
4572 },
4573 }, {
4574 .alg = "cbc(des)",
4575 .test = alg_test_skcipher,
4576 .suite = {
4577 .cipher = __VECS(des_
4578 },
4579 }, {
4580 .alg = "cbc(des3_ede)",
4581 .test = alg_test_skcipher,
4582 .suite = {
4583 .cipher = __VECS(des3
4584 },
4585 }, {
4586 /* Same as cbc(aes) except th
4587 * hardware secure memory whi
4588 */
4589 .alg = "cbc(paes)",
4590 .test = alg_test_null,
4591 .fips_allowed = 1,
4592 }, {
4593 /* Same as cbc(sm4) except th
4594 * hardware secure memory whi
4595 */
4596 .alg = "cbc(psm4)",
4597 .test = alg_test_null,
4598 }, {
4599 .alg = "cbc(serpent)",
4600 .test = alg_test_skcipher,
4601 .suite = {
4602 .cipher = __VECS(serp
4603 },
4604 }, {
4605 .alg = "cbc(sm4)",
4606 .test = alg_test_skcipher,
4607 .suite = {
4608 .cipher = __VECS(sm4_
4609 }
4610 }, {
4611 .alg = "cbc(twofish)",
4612 .test = alg_test_skcipher,
4613 .suite = {
4614 .cipher = __VECS(tf_c
4615 },
4616 }, {
4617 #if IS_ENABLED(CONFIG_CRYPTO_PAES_S390)
4618 .alg = "cbc-paes-s390",
4619 .fips_allowed = 1,
4620 .test = alg_test_skcipher,
4621 .suite = {
4622 .cipher = __VECS(aes_
4623 }
4624 }, {
4625 #endif
4626 .alg = "cbcmac(aes)",
4627 .test = alg_test_hash,
4628 .suite = {
4629 .hash = __VECS(aes_cb
4630 }
4631 }, {
4632 .alg = "cbcmac(sm4)",
4633 .test = alg_test_hash,
4634 .suite = {
4635 .hash = __VECS(sm4_cb
4636 }
4637 }, {
4638 .alg = "ccm(aes)",
4639 .generic_driver = "ccm_base(c
4640 .test = alg_test_aead,
4641 .fips_allowed = 1,
4642 .suite = {
4643 .aead = {
4644 ____VECS(aes_
4645 .einval_allow
4646 }
4647 }
4648 }, {
4649 .alg = "ccm(sm4)",
4650 .generic_driver = "ccm_base(c
4651 .test = alg_test_aead,
4652 .suite = {
4653 .aead = {
4654 ____VECS(sm4_
4655 .einval_allow
4656 }
4657 }
4658 }, {
4659 .alg = "chacha20",
4660 .test = alg_test_skcipher,
4661 .suite = {
4662 .cipher = __VECS(chac
4663 },
4664 }, {
4665 .alg = "cmac(aes)",
4666 .fips_allowed = 1,
4667 .test = alg_test_hash,
4668 .suite = {
4669 .hash = __VECS(aes_cm
4670 }
4671 }, {
4672 .alg = "cmac(camellia)",
4673 .test = alg_test_hash,
4674 .suite = {
4675 .hash = __VECS(camell
4676 }
4677 }, {
4678 .alg = "cmac(des3_ede)",
4679 .test = alg_test_hash,
4680 .suite = {
4681 .hash = __VECS(des3_e
4682 }
4683 }, {
4684 .alg = "cmac(sm4)",
4685 .test = alg_test_hash,
4686 .suite = {
4687 .hash = __VECS(sm4_cm
4688 }
4689 }, {
4690 .alg = "compress_null",
4691 .test = alg_test_null,
4692 }, {
4693 .alg = "crc32",
4694 .test = alg_test_hash,
4695 .fips_allowed = 1,
4696 .suite = {
4697 .hash = __VECS(crc32_
4698 }
4699 }, {
4700 .alg = "crc32c",
4701 .test = alg_test_crc32c,
4702 .fips_allowed = 1,
4703 .suite = {
4704 .hash = __VECS(crc32c
4705 }
4706 }, {
4707 .alg = "crc64-rocksoft",
4708 .test = alg_test_hash,
4709 .fips_allowed = 1,
4710 .suite = {
4711 .hash = __VECS(crc64_
4712 }
4713 }, {
4714 .alg = "crct10dif",
4715 .test = alg_test_hash,
4716 .fips_allowed = 1,
4717 .suite = {
4718 .hash = __VECS(crct10
4719 }
4720 }, {
4721 .alg = "ctr(aes)",
4722 .test = alg_test_skcipher,
4723 .fips_allowed = 1,
4724 .suite = {
4725 .cipher = __VECS(aes_
4726 }
4727 }, {
4728 .alg = "ctr(aria)",
4729 .test = alg_test_skcipher,
4730 .suite = {
4731 .cipher = __VECS(aria
4732 }
4733 }, {
4734 .alg = "ctr(blowfish)",
4735 .test = alg_test_skcipher,
4736 .suite = {
4737 .cipher = __VECS(bf_c
4738 }
4739 }, {
4740 .alg = "ctr(camellia)",
4741 .test = alg_test_skcipher,
4742 .suite = {
4743 .cipher = __VECS(came
4744 }
4745 }, {
4746 .alg = "ctr(cast5)",
4747 .test = alg_test_skcipher,
4748 .suite = {
4749 .cipher = __VECS(cast
4750 }
4751 }, {
4752 .alg = "ctr(cast6)",
4753 .test = alg_test_skcipher,
4754 .suite = {
4755 .cipher = __VECS(cast
4756 }
4757 }, {
4758 .alg = "ctr(des)",
4759 .test = alg_test_skcipher,
4760 .suite = {
4761 .cipher = __VECS(des_
4762 }
4763 }, {
4764 .alg = "ctr(des3_ede)",
4765 .test = alg_test_skcipher,
4766 .suite = {
4767 .cipher = __VECS(des3
4768 }
4769 }, {
4770 /* Same as ctr(aes) except th
4771 * hardware secure memory whi
4772 */
4773 .alg = "ctr(paes)",
4774 .test = alg_test_null,
4775 .fips_allowed = 1,
4776 }, {
4777
4778 /* Same as ctr(sm4) except th
4779 * hardware secure memory whi
4780 */
4781 .alg = "ctr(psm4)",
4782 .test = alg_test_null,
4783 }, {
4784 .alg = "ctr(serpent)",
4785 .test = alg_test_skcipher,
4786 .suite = {
4787 .cipher = __VECS(serp
4788 }
4789 }, {
4790 .alg = "ctr(sm4)",
4791 .test = alg_test_skcipher,
4792 .suite = {
4793 .cipher = __VECS(sm4_
4794 }
4795 }, {
4796 .alg = "ctr(twofish)",
4797 .test = alg_test_skcipher,
4798 .suite = {
4799 .cipher = __VECS(tf_c
4800 }
4801 }, {
4802 #if IS_ENABLED(CONFIG_CRYPTO_PAES_S390)
4803 .alg = "ctr-paes-s390",
4804 .fips_allowed = 1,
4805 .test = alg_test_skcipher,
4806 .suite = {
4807 .cipher = __VECS(aes_
4808 }
4809 }, {
4810 #endif
4811 .alg = "cts(cbc(aes))",
4812 .test = alg_test_skcipher,
4813 .fips_allowed = 1,
4814 .suite = {
4815 .cipher = __VECS(cts_
4816 }
4817 }, {
4818 /* Same as cts(cbc((aes)) exc
4819 * hardware secure memory whi
4820 */
4821 .alg = "cts(cbc(paes))",
4822 .test = alg_test_null,
4823 .fips_allowed = 1,
4824 }, {
4825 .alg = "cts(cbc(sm4))",
4826 .test = alg_test_skcipher,
4827 .suite = {
4828 .cipher = __VECS(sm4_
4829 }
4830 }, {
4831 .alg = "curve25519",
4832 .test = alg_test_kpp,
4833 .suite = {
4834 .kpp = __VECS(curve25
4835 }
4836 }, {
4837 .alg = "deflate",
4838 .test = alg_test_comp,
4839 .fips_allowed = 1,
4840 .suite = {
4841 .comp = {
4842 .comp = __VEC
4843 .decomp = __V
4844 }
4845 }
4846 }, {
4847 .alg = "deflate-iaa",
4848 .test = alg_test_comp,
4849 .fips_allowed = 1,
4850 .suite = {
4851 .comp = {
4852 .comp = __VEC
4853 .decomp = __V
4854 }
4855 }
4856 }, {
4857 .alg = "dh",
4858 .test = alg_test_kpp,
4859 .suite = {
4860 .kpp = __VECS(dh_tv_t
4861 }
4862 }, {
4863 .alg = "digest_null",
4864 .test = alg_test_null,
4865 }, {
4866 .alg = "drbg_nopr_ctr_aes128"
4867 .test = alg_test_drbg,
4868 .fips_allowed = 1,
4869 .suite = {
4870 .drbg = __VECS(drbg_n
4871 }
4872 }, {
4873 .alg = "drbg_nopr_ctr_aes192"
4874 .test = alg_test_drbg,
4875 .fips_allowed = 1,
4876 .suite = {
4877 .drbg = __VECS(drbg_n
4878 }
4879 }, {
4880 .alg = "drbg_nopr_ctr_aes256"
4881 .test = alg_test_drbg,
4882 .fips_allowed = 1,
4883 .suite = {
4884 .drbg = __VECS(drbg_n
4885 }
4886 }, {
4887 .alg = "drbg_nopr_hmac_sha256
4888 .test = alg_test_drbg,
4889 .fips_allowed = 1,
4890 .suite = {
4891 .drbg = __VECS(drbg_n
4892 }
4893 }, {
4894 /*
4895 * There is no need to specif
4896 * backend cipher -- covered
4897 */
4898 .alg = "drbg_nopr_hmac_sha384
4899 .test = alg_test_null,
4900 }, {
4901 .alg = "drbg_nopr_hmac_sha512
4902 .test = alg_test_drbg,
4903 .fips_allowed = 1,
4904 .suite = {
4905 .drbg = __VECS(drbg_n
4906 }
4907 }, {
4908 .alg = "drbg_nopr_sha256",
4909 .test = alg_test_drbg,
4910 .fips_allowed = 1,
4911 .suite = {
4912 .drbg = __VECS(drbg_n
4913 }
4914 }, {
4915 /* covered by drbg_nopr_sha25
4916 .alg = "drbg_nopr_sha384",
4917 .test = alg_test_null,
4918 }, {
4919 .alg = "drbg_nopr_sha512",
4920 .fips_allowed = 1,
4921 .test = alg_test_null,
4922 }, {
4923 .alg = "drbg_pr_ctr_aes128",
4924 .test = alg_test_drbg,
4925 .fips_allowed = 1,
4926 .suite = {
4927 .drbg = __VECS(drbg_p
4928 }
4929 }, {
4930 /* covered by drbg_pr_ctr_aes
4931 .alg = "drbg_pr_ctr_aes192",
4932 .fips_allowed = 1,
4933 .test = alg_test_null,
4934 }, {
4935 .alg = "drbg_pr_ctr_aes256",
4936 .fips_allowed = 1,
4937 .test = alg_test_null,
4938 }, {
4939 .alg = "drbg_pr_hmac_sha256",
4940 .test = alg_test_drbg,
4941 .fips_allowed = 1,
4942 .suite = {
4943 .drbg = __VECS(drbg_p
4944 }
4945 }, {
4946 /* covered by drbg_pr_hmac_sh
4947 .alg = "drbg_pr_hmac_sha384",
4948 .test = alg_test_null,
4949 }, {
4950 .alg = "drbg_pr_hmac_sha512",
4951 .test = alg_test_null,
4952 .fips_allowed = 1,
4953 }, {
4954 .alg = "drbg_pr_sha256",
4955 .test = alg_test_drbg,
4956 .fips_allowed = 1,
4957 .suite = {
4958 .drbg = __VECS(drbg_p
4959 }
4960 }, {
4961 /* covered by drbg_pr_sha256
4962 .alg = "drbg_pr_sha384",
4963 .test = alg_test_null,
4964 }, {
4965 .alg = "drbg_pr_sha512",
4966 .fips_allowed = 1,
4967 .test = alg_test_null,
4968 }, {
4969 .alg = "ecb(aes)",
4970 .test = alg_test_skcipher,
4971 .fips_allowed = 1,
4972 .suite = {
4973 .cipher = __VECS(aes_
4974 }
4975 }, {
4976 .alg = "ecb(anubis)",
4977 .test = alg_test_skcipher,
4978 .suite = {
4979 .cipher = __VECS(anub
4980 }
4981 }, {
4982 .alg = "ecb(arc4)",
4983 .generic_driver = "arc4-gener
4984 .test = alg_test_skcipher,
4985 .suite = {
4986 .cipher = __VECS(arc4
4987 }
4988 }, {
4989 .alg = "ecb(aria)",
4990 .test = alg_test_skcipher,
4991 .suite = {
4992 .cipher = __VECS(aria
4993 }
4994 }, {
4995 .alg = "ecb(blowfish)",
4996 .test = alg_test_skcipher,
4997 .suite = {
4998 .cipher = __VECS(bf_t
4999 }
5000 }, {
5001 .alg = "ecb(camellia)",
5002 .test = alg_test_skcipher,
5003 .suite = {
5004 .cipher = __VECS(came
5005 }
5006 }, {
5007 .alg = "ecb(cast5)",
5008 .test = alg_test_skcipher,
5009 .suite = {
5010 .cipher = __VECS(cast
5011 }
5012 }, {
5013 .alg = "ecb(cast6)",
5014 .test = alg_test_skcipher,
5015 .suite = {
5016 .cipher = __VECS(cast
5017 }
5018 }, {
5019 .alg = "ecb(cipher_null)",
5020 .test = alg_test_null,
5021 .fips_allowed = 1,
5022 }, {
5023 .alg = "ecb(des)",
5024 .test = alg_test_skcipher,
5025 .suite = {
5026 .cipher = __VECS(des_
5027 }
5028 }, {
5029 .alg = "ecb(des3_ede)",
5030 .test = alg_test_skcipher,
5031 .suite = {
5032 .cipher = __VECS(des3
5033 }
5034 }, {
5035 .alg = "ecb(fcrypt)",
5036 .test = alg_test_skcipher,
5037 .suite = {
5038 .cipher = {
5039 .vecs = fcryp
5040 .count = 1
5041 }
5042 }
5043 }, {
5044 .alg = "ecb(khazad)",
5045 .test = alg_test_skcipher,
5046 .suite = {
5047 .cipher = __VECS(khaz
5048 }
5049 }, {
5050 /* Same as ecb(aes) except th
5051 * hardware secure memory whi
5052 */
5053 .alg = "ecb(paes)",
5054 .test = alg_test_null,
5055 .fips_allowed = 1,
5056 }, {
5057 .alg = "ecb(seed)",
5058 .test = alg_test_skcipher,
5059 .suite = {
5060 .cipher = __VECS(seed
5061 }
5062 }, {
5063 .alg = "ecb(serpent)",
5064 .test = alg_test_skcipher,
5065 .suite = {
5066 .cipher = __VECS(serp
5067 }
5068 }, {
5069 .alg = "ecb(sm4)",
5070 .test = alg_test_skcipher,
5071 .suite = {
5072 .cipher = __VECS(sm4_
5073 }
5074 }, {
5075 .alg = "ecb(tea)",
5076 .test = alg_test_skcipher,
5077 .suite = {
5078 .cipher = __VECS(tea_
5079 }
5080 }, {
5081 .alg = "ecb(twofish)",
5082 .test = alg_test_skcipher,
5083 .suite = {
5084 .cipher = __VECS(tf_t
5085 }
5086 }, {
5087 .alg = "ecb(xeta)",
5088 .test = alg_test_skcipher,
5089 .suite = {
5090 .cipher = __VECS(xeta
5091 }
5092 }, {
5093 .alg = "ecb(xtea)",
5094 .test = alg_test_skcipher,
5095 .suite = {
5096 .cipher = __VECS(xtea
5097 }
5098 }, {
5099 #if IS_ENABLED(CONFIG_CRYPTO_PAES_S390)
5100 .alg = "ecb-paes-s390",
5101 .fips_allowed = 1,
5102 .test = alg_test_skcipher,
5103 .suite = {
5104 .cipher = __VECS(aes_
5105 }
5106 }, {
5107 #endif
5108 .alg = "ecdh-nist-p192",
5109 .test = alg_test_kpp,
5110 .suite = {
5111 .kpp = __VECS(ecdh_p1
5112 }
5113 }, {
5114 .alg = "ecdh-nist-p256",
5115 .test = alg_test_kpp,
5116 .fips_allowed = 1,
5117 .suite = {
5118 .kpp = __VECS(ecdh_p2
5119 }
5120 }, {
5121 .alg = "ecdh-nist-p384",
5122 .test = alg_test_kpp,
5123 .fips_allowed = 1,
5124 .suite = {
5125 .kpp = __VECS(ecdh_p3
5126 }
5127 }, {
5128 .alg = "ecdsa-nist-p192",
5129 .test = alg_test_akcipher,
5130 .suite = {
5131 .akcipher = __VECS(ec
5132 }
5133 }, {
5134 .alg = "ecdsa-nist-p256",
5135 .test = alg_test_akcipher,
5136 .fips_allowed = 1,
5137 .suite = {
5138 .akcipher = __VECS(ec
5139 }
5140 }, {
5141 .alg = "ecdsa-nist-p384",
5142 .test = alg_test_akcipher,
5143 .fips_allowed = 1,
5144 .suite = {
5145 .akcipher = __VECS(ec
5146 }
5147 }, {
5148 .alg = "ecdsa-nist-p521",
5149 .test = alg_test_akcipher,
5150 .fips_allowed = 1,
5151 .suite = {
5152 .akcipher = __VECS(ec
5153 }
5154 }, {
5155 .alg = "ecrdsa",
5156 .test = alg_test_akcipher,
5157 .suite = {
5158 .akcipher = __VECS(ec
5159 }
5160 }, {
5161 .alg = "essiv(authenc(hmac(sh
5162 .test = alg_test_aead,
5163 .fips_allowed = 1,
5164 .suite = {
5165 .aead = __VECS(essiv_
5166 }
5167 }, {
5168 .alg = "essiv(cbc(aes),sha256
5169 .test = alg_test_skcipher,
5170 .fips_allowed = 1,
5171 .suite = {
5172 .cipher = __VECS(essi
5173 }
5174 }, {
5175 #if IS_ENABLED(CONFIG_CRYPTO_DH_RFC7919_GROUP
5176 .alg = "ffdhe2048(dh)",
5177 .test = alg_test_kpp,
5178 .fips_allowed = 1,
5179 .suite = {
5180 .kpp = __VECS(ffdhe20
5181 }
5182 }, {
5183 .alg = "ffdhe3072(dh)",
5184 .test = alg_test_kpp,
5185 .fips_allowed = 1,
5186 .suite = {
5187 .kpp = __VECS(ffdhe30
5188 }
5189 }, {
5190 .alg = "ffdhe4096(dh)",
5191 .test = alg_test_kpp,
5192 .fips_allowed = 1,
5193 .suite = {
5194 .kpp = __VECS(ffdhe40
5195 }
5196 }, {
5197 .alg = "ffdhe6144(dh)",
5198 .test = alg_test_kpp,
5199 .fips_allowed = 1,
5200 .suite = {
5201 .kpp = __VECS(ffdhe61
5202 }
5203 }, {
5204 .alg = "ffdhe8192(dh)",
5205 .test = alg_test_kpp,
5206 .fips_allowed = 1,
5207 .suite = {
5208 .kpp = __VECS(ffdhe81
5209 }
5210 }, {
5211 #endif /* CONFIG_CRYPTO_DH_RFC7919_GROUPS */
5212 .alg = "gcm(aes)",
5213 .generic_driver = "gcm_base(c
5214 .test = alg_test_aead,
5215 .fips_allowed = 1,
5216 .suite = {
5217 .aead = __VECS(aes_gc
5218 }
5219 }, {
5220 .alg = "gcm(aria)",
5221 .generic_driver = "gcm_base(c
5222 .test = alg_test_aead,
5223 .suite = {
5224 .aead = __VECS(aria_g
5225 }
5226 }, {
5227 .alg = "gcm(sm4)",
5228 .generic_driver = "gcm_base(c
5229 .test = alg_test_aead,
5230 .suite = {
5231 .aead = __VECS(sm4_gc
5232 }
5233 }, {
5234 .alg = "ghash",
5235 .test = alg_test_hash,
5236 .suite = {
5237 .hash = __VECS(ghash_
5238 }
5239 }, {
5240 .alg = "hctr2(aes)",
5241 .generic_driver =
5242 "hctr2_base(xctr(aes-gene
5243 .test = alg_test_skcipher,
5244 .suite = {
5245 .cipher = __VECS(aes_
5246 }
5247 }, {
5248 .alg = "hmac(md5)",
5249 .test = alg_test_hash,
5250 .suite = {
5251 .hash = __VECS(hmac_m
5252 }
5253 }, {
5254 .alg = "hmac(rmd160)",
5255 .test = alg_test_hash,
5256 .suite = {
5257 .hash = __VECS(hmac_r
5258 }
5259 }, {
5260 .alg = "hmac(sha1)",
5261 .test = alg_test_hash,
5262 .fips_allowed = 1,
5263 .suite = {
5264 .hash = __VECS(hmac_s
5265 }
5266 }, {
5267 .alg = "hmac(sha224)",
5268 .test = alg_test_hash,
5269 .fips_allowed = 1,
5270 .suite = {
5271 .hash = __VECS(hmac_s
5272 }
5273 }, {
5274 .alg = "hmac(sha256)",
5275 .test = alg_test_hash,
5276 .fips_allowed = 1,
5277 .suite = {
5278 .hash = __VECS(hmac_s
5279 }
5280 }, {
5281 .alg = "hmac(sha3-224)",
5282 .test = alg_test_hash,
5283 .fips_allowed = 1,
5284 .suite = {
5285 .hash = __VECS(hmac_s
5286 }
5287 }, {
5288 .alg = "hmac(sha3-256)",
5289 .test = alg_test_hash,
5290 .fips_allowed = 1,
5291 .suite = {
5292 .hash = __VECS(hmac_s
5293 }
5294 }, {
5295 .alg = "hmac(sha3-384)",
5296 .test = alg_test_hash,
5297 .fips_allowed = 1,
5298 .suite = {
5299 .hash = __VECS(hmac_s
5300 }
5301 }, {
5302 .alg = "hmac(sha3-512)",
5303 .test = alg_test_hash,
5304 .fips_allowed = 1,
5305 .suite = {
5306 .hash = __VECS(hmac_s
5307 }
5308 }, {
5309 .alg = "hmac(sha384)",
5310 .test = alg_test_hash,
5311 .fips_allowed = 1,
5312 .suite = {
5313 .hash = __VECS(hmac_s
5314 }
5315 }, {
5316 .alg = "hmac(sha512)",
5317 .test = alg_test_hash,
5318 .fips_allowed = 1,
5319 .suite = {
5320 .hash = __VECS(hmac_s
5321 }
5322 }, {
5323 .alg = "hmac(sm3)",
5324 .test = alg_test_hash,
5325 .suite = {
5326 .hash = __VECS(hmac_s
5327 }
5328 }, {
5329 .alg = "hmac(streebog256)",
5330 .test = alg_test_hash,
5331 .suite = {
5332 .hash = __VECS(hmac_s
5333 }
5334 }, {
5335 .alg = "hmac(streebog512)",
5336 .test = alg_test_hash,
5337 .suite = {
5338 .hash = __VECS(hmac_s
5339 }
5340 }, {
5341 .alg = "jitterentropy_rng",
5342 .fips_allowed = 1,
5343 .test = alg_test_null,
5344 }, {
5345 .alg = "kw(aes)",
5346 .test = alg_test_skcipher,
5347 .fips_allowed = 1,
5348 .suite = {
5349 .cipher = __VECS(aes_
5350 }
5351 }, {
5352 .alg = "lrw(aes)",
5353 .generic_driver = "lrw(ecb(ae
5354 .test = alg_test_skcipher,
5355 .suite = {
5356 .cipher = __VECS(aes_
5357 }
5358 }, {
5359 .alg = "lrw(camellia)",
5360 .generic_driver = "lrw(ecb(ca
5361 .test = alg_test_skcipher,
5362 .suite = {
5363 .cipher = __VECS(came
5364 }
5365 }, {
5366 .alg = "lrw(cast6)",
5367 .generic_driver = "lrw(ecb(ca
5368 .test = alg_test_skcipher,
5369 .suite = {
5370 .cipher = __VECS(cast
5371 }
5372 }, {
5373 .alg = "lrw(serpent)",
5374 .generic_driver = "lrw(ecb(se
5375 .test = alg_test_skcipher,
5376 .suite = {
5377 .cipher = __VECS(serp
5378 }
5379 }, {
5380 .alg = "lrw(twofish)",
5381 .generic_driver = "lrw(ecb(tw
5382 .test = alg_test_skcipher,
5383 .suite = {
5384 .cipher = __VECS(tf_l
5385 }
5386 }, {
5387 .alg = "lz4",
5388 .test = alg_test_comp,
5389 .fips_allowed = 1,
5390 .suite = {
5391 .comp = {
5392 .comp = __VEC
5393 .decomp = __V
5394 }
5395 }
5396 }, {
5397 .alg = "lz4hc",
5398 .test = alg_test_comp,
5399 .fips_allowed = 1,
5400 .suite = {
5401 .comp = {
5402 .comp = __VEC
5403 .decomp = __V
5404 }
5405 }
5406 }, {
5407 .alg = "lzo",
5408 .test = alg_test_comp,
5409 .fips_allowed = 1,
5410 .suite = {
5411 .comp = {
5412 .comp = __VEC
5413 .decomp = __V
5414 }
5415 }
5416 }, {
5417 .alg = "lzo-rle",
5418 .test = alg_test_comp,
5419 .fips_allowed = 1,
5420 .suite = {
5421 .comp = {
5422 .comp = __VEC
5423 .decomp = __V
5424 }
5425 }
5426 }, {
5427 .alg = "md4",
5428 .test = alg_test_hash,
5429 .suite = {
5430 .hash = __VECS(md4_tv
5431 }
5432 }, {
5433 .alg = "md5",
5434 .test = alg_test_hash,
5435 .suite = {
5436 .hash = __VECS(md5_tv
5437 }
5438 }, {
5439 .alg = "michael_mic",
5440 .test = alg_test_hash,
5441 .suite = {
5442 .hash = __VECS(michae
5443 }
5444 }, {
5445 .alg = "nhpoly1305",
5446 .test = alg_test_hash,
5447 .suite = {
5448 .hash = __VECS(nhpoly
5449 }
5450 }, {
5451 .alg = "pcbc(fcrypt)",
5452 .test = alg_test_skcipher,
5453 .suite = {
5454 .cipher = __VECS(fcry
5455 }
5456 }, {
5457 .alg = "pkcs1pad(rsa,sha224)"
5458 .test = alg_test_null,
5459 .fips_allowed = 1,
5460 }, {
5461 .alg = "pkcs1pad(rsa,sha256)"
5462 .test = alg_test_akcipher,
5463 .fips_allowed = 1,
5464 .suite = {
5465 .akcipher = __VECS(pk
5466 }
5467 }, {
5468 .alg = "pkcs1pad(rsa,sha3-256
5469 .test = alg_test_null,
5470 .fips_allowed = 1,
5471 }, {
5472 .alg = "pkcs1pad(rsa,sha3-384
5473 .test = alg_test_null,
5474 .fips_allowed = 1,
5475 }, {
5476 .alg = "pkcs1pad(rsa,sha3-512
5477 .test = alg_test_null,
5478 .fips_allowed = 1,
5479 }, {
5480 .alg = "pkcs1pad(rsa,sha384)"
5481 .test = alg_test_null,
5482 .fips_allowed = 1,
5483 }, {
5484 .alg = "pkcs1pad(rsa,sha512)"
5485 .test = alg_test_null,
5486 .fips_allowed = 1,
5487 }, {
5488 .alg = "poly1305",
5489 .test = alg_test_hash,
5490 .suite = {
5491 .hash = __VECS(poly13
5492 }
5493 }, {
5494 .alg = "polyval",
5495 .test = alg_test_hash,
5496 .suite = {
5497 .hash = __VECS(polyva
5498 }
5499 }, {
5500 .alg = "rfc3686(ctr(aes))",
5501 .test = alg_test_skcipher,
5502 .fips_allowed = 1,
5503 .suite = {
5504 .cipher = __VECS(aes_
5505 }
5506 }, {
5507 .alg = "rfc3686(ctr(sm4))",
5508 .test = alg_test_skcipher,
5509 .suite = {
5510 .cipher = __VECS(sm4_
5511 }
5512 }, {
5513 .alg = "rfc4106(gcm(aes))",
5514 .generic_driver = "rfc4106(gc
5515 .test = alg_test_aead,
5516 .fips_allowed = 1,
5517 .suite = {
5518 .aead = {
5519 ____VECS(aes_
5520 .einval_allow
5521 .aad_iv = 1,
5522 }
5523 }
5524 }, {
5525 .alg = "rfc4309(ccm(aes))",
5526 .generic_driver = "rfc4309(cc
5527 .test = alg_test_aead,
5528 .fips_allowed = 1,
5529 .suite = {
5530 .aead = {
5531 ____VECS(aes_
5532 .einval_allow
5533 .aad_iv = 1,
5534 }
5535 }
5536 }, {
5537 .alg = "rfc4543(gcm(aes))",
5538 .generic_driver = "rfc4543(gc
5539 .test = alg_test_aead,
5540 .suite = {
5541 .aead = {
5542 ____VECS(aes_
5543 .einval_allow
5544 .aad_iv = 1,
5545 }
5546 }
5547 }, {
5548 .alg = "rfc7539(chacha20,poly
5549 .test = alg_test_aead,
5550 .suite = {
5551 .aead = __VECS(rfc753
5552 }
5553 }, {
5554 .alg = "rfc7539esp(chacha20,p
5555 .test = alg_test_aead,
5556 .suite = {
5557 .aead = {
5558 ____VECS(rfc7
5559 .einval_allow
5560 .aad_iv = 1,
5561 }
5562 }
5563 }, {
5564 .alg = "rmd160",
5565 .test = alg_test_hash,
5566 .suite = {
5567 .hash = __VECS(rmd160
5568 }
5569 }, {
5570 .alg = "rsa",
5571 .test = alg_test_akcipher,
5572 .fips_allowed = 1,
5573 .suite = {
5574 .akcipher = __VECS(rs
5575 }
5576 }, {
5577 .alg = "sha1",
5578 .test = alg_test_hash,
5579 .fips_allowed = 1,
5580 .suite = {
5581 .hash = __VECS(sha1_t
5582 }
5583 }, {
5584 .alg = "sha224",
5585 .test = alg_test_hash,
5586 .fips_allowed = 1,
5587 .suite = {
5588 .hash = __VECS(sha224
5589 }
5590 }, {
5591 .alg = "sha256",
5592 .test = alg_test_hash,
5593 .fips_allowed = 1,
5594 .suite = {
5595 .hash = __VECS(sha256
5596 }
5597 }, {
5598 .alg = "sha3-224",
5599 .test = alg_test_hash,
5600 .fips_allowed = 1,
5601 .suite = {
5602 .hash = __VECS(sha3_2
5603 }
5604 }, {
5605 .alg = "sha3-256",
5606 .test = alg_test_hash,
5607 .fips_allowed = 1,
5608 .suite = {
5609 .hash = __VECS(sha3_2
5610 }
5611 }, {
5612 .alg = "sha3-384",
5613 .test = alg_test_hash,
5614 .fips_allowed = 1,
5615 .suite = {
5616 .hash = __VECS(sha3_3
5617 }
5618 }, {
5619 .alg = "sha3-512",
5620 .test = alg_test_hash,
5621 .fips_allowed = 1,
5622 .suite = {
5623 .hash = __VECS(sha3_5
5624 }
5625 }, {
5626 .alg = "sha384",
5627 .test = alg_test_hash,
5628 .fips_allowed = 1,
5629 .suite = {
5630 .hash = __VECS(sha384
5631 }
5632 }, {
5633 .alg = "sha512",
5634 .test = alg_test_hash,
5635 .fips_allowed = 1,
5636 .suite = {
5637 .hash = __VECS(sha512
5638 }
5639 }, {
5640 .alg = "sm3",
5641 .test = alg_test_hash,
5642 .suite = {
5643 .hash = __VECS(sm3_tv
5644 }
5645 }, {
5646 .alg = "streebog256",
5647 .test = alg_test_hash,
5648 .suite = {
5649 .hash = __VECS(streeb
5650 }
5651 }, {
5652 .alg = "streebog512",
5653 .test = alg_test_hash,
5654 .suite = {
5655 .hash = __VECS(streeb
5656 }
5657 }, {
5658 .alg = "vmac64(aes)",
5659 .test = alg_test_hash,
5660 .suite = {
5661 .hash = __VECS(vmac64
5662 }
5663 }, {
5664 .alg = "wp256",
5665 .test = alg_test_hash,
5666 .suite = {
5667 .hash = __VECS(wp256_
5668 }
5669 }, {
5670 .alg = "wp384",
5671 .test = alg_test_hash,
5672 .suite = {
5673 .hash = __VECS(wp384_
5674 }
5675 }, {
5676 .alg = "wp512",
5677 .test = alg_test_hash,
5678 .suite = {
5679 .hash = __VECS(wp512_
5680 }
5681 }, {
5682 .alg = "xcbc(aes)",
5683 .test = alg_test_hash,
5684 .suite = {
5685 .hash = __VECS(aes_xc
5686 }
5687 }, {
5688 .alg = "xcbc(sm4)",
5689 .test = alg_test_hash,
5690 .suite = {
5691 .hash = __VECS(sm4_xc
5692 }
5693 }, {
5694 .alg = "xchacha12",
5695 .test = alg_test_skcipher,
5696 .suite = {
5697 .cipher = __VECS(xcha
5698 },
5699 }, {
5700 .alg = "xchacha20",
5701 .test = alg_test_skcipher,
5702 .suite = {
5703 .cipher = __VECS(xcha
5704 },
5705 }, {
5706 .alg = "xctr(aes)",
5707 .test = alg_test_skcipher,
5708 .suite = {
5709 .cipher = __VECS(aes_
5710 }
5711 }, {
5712 .alg = "xts(aes)",
5713 .generic_driver = "xts(ecb(ae
5714 .test = alg_test_skcipher,
5715 .fips_allowed = 1,
5716 .suite = {
5717 .cipher = __VECS(aes_
5718 }
5719 }, {
5720 .alg = "xts(camellia)",
5721 .generic_driver = "xts(ecb(ca
5722 .test = alg_test_skcipher,
5723 .suite = {
5724 .cipher = __VECS(came
5725 }
5726 }, {
5727 .alg = "xts(cast6)",
5728 .generic_driver = "xts(ecb(ca
5729 .test = alg_test_skcipher,
5730 .suite = {
5731 .cipher = __VECS(cast
5732 }
5733 }, {
5734 /* Same as xts(aes) except th
5735 * hardware secure memory whi
5736 */
5737 .alg = "xts(paes)",
5738 .test = alg_test_null,
5739 .fips_allowed = 1,
5740 }, {
5741 .alg = "xts(serpent)",
5742 .generic_driver = "xts(ecb(se
5743 .test = alg_test_skcipher,
5744 .suite = {
5745 .cipher = __VECS(serp
5746 }
5747 }, {
5748 .alg = "xts(sm4)",
5749 .generic_driver = "xts(ecb(sm
5750 .test = alg_test_skcipher,
5751 .suite = {
5752 .cipher = __VECS(sm4_
5753 }
5754 }, {
5755 .alg = "xts(twofish)",
5756 .generic_driver = "xts(ecb(tw
5757 .test = alg_test_skcipher,
5758 .suite = {
5759 .cipher = __VECS(tf_x
5760 }
5761 }, {
5762 #if IS_ENABLED(CONFIG_CRYPTO_PAES_S390)
5763 .alg = "xts-paes-s390",
5764 .fips_allowed = 1,
5765 .test = alg_test_skcipher,
5766 .suite = {
5767 .cipher = __VECS(aes_
5768 }
5769 }, {
5770 #endif
5771 .alg = "xxhash64",
5772 .test = alg_test_hash,
5773 .fips_allowed = 1,
5774 .suite = {
5775 .hash = __VECS(xxhash
5776 }
5777 }, {
5778 .alg = "zstd",
5779 .test = alg_test_comp,
5780 .fips_allowed = 1,
5781 .suite = {
5782 .comp = {
5783 .comp = __VEC
5784 .decomp = __V
5785 }
5786 }
5787 }
5788 };
5789
5790 static void alg_check_test_descs_order(void)
5791 {
5792 int i;
5793
5794 for (i = 1; i < ARRAY_SIZE(alg_test_d
5795 int diff = strcmp(alg_test_de
5796 alg_test_de
5797
5798 if (WARN_ON(diff > 0)) {
5799 pr_warn("testmgr: alg
5800 alg_test_desc
5801 alg_test_desc
5802 }
5803
5804 if (WARN_ON(diff == 0)) {
5805 pr_warn("testmgr: dup
5806 alg_test_desc
5807 }
5808 }
5809 }
5810
5811 static void alg_check_testvec_configs(void)
5812 {
5813 int i;
5814
5815 for (i = 0; i < ARRAY_SIZE(default_ci
5816 WARN_ON(!valid_testvec_config
5817 &default_ciph
5818
5819 for (i = 0; i < ARRAY_SIZE(default_ha
5820 WARN_ON(!valid_testvec_config
5821 &default_hash
5822 }
5823
5824 static void testmgr_onetime_init(void)
5825 {
5826 alg_check_test_descs_order();
5827 alg_check_testvec_configs();
5828
5829 #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS
5830 pr_warn("alg: extra crypto tests enab
5831 #endif
5832 }
5833
5834 static int alg_find_test(const char *alg)
5835 {
5836 int start = 0;
5837 int end = ARRAY_SIZE(alg_test_descs);
5838
5839 while (start < end) {
5840 int i = (start + end) / 2;
5841 int diff = strcmp(alg_test_de
5842
5843 if (diff > 0) {
5844 end = i;
5845 continue;
5846 }
5847
5848 if (diff < 0) {
5849 start = i + 1;
5850 continue;
5851 }
5852
5853 return i;
5854 }
5855
5856 return -1;
5857 }
5858
5859 static int alg_fips_disabled(const char *driv
5860 {
5861 pr_info("alg: %s (%s) is disabled due
5862
5863 return -ECANCELED;
5864 }
5865
5866 int alg_test(const char *driver, const char *
5867 {
5868 int i;
5869 int j;
5870 int rc;
5871
5872 if (!fips_enabled && notests) {
5873 printk_once(KERN_INFO "alg: s
5874 return 0;
5875 }
5876
5877 DO_ONCE(testmgr_onetime_init);
5878
5879 if ((type & CRYPTO_ALG_TYPE_MASK) ==
5880 char nalg[CRYPTO_MAX_ALG_NAME
5881
5882 if (snprintf(nalg, sizeof(nal
5883 sizeof(nalg))
5884 return -ENAMETOOLONG;
5885
5886 i = alg_find_test(nalg);
5887 if (i < 0)
5888 goto notest;
5889
5890 if (fips_enabled && !alg_test
5891 goto non_fips_alg;
5892
5893 rc = alg_test_cipher(alg_test
5894 goto test_done;
5895 }
5896
5897 i = alg_find_test(alg);
5898 j = alg_find_test(driver);
5899 if (i < 0 && j < 0)
5900 goto notest;
5901
5902 if (fips_enabled) {
5903 if (j >= 0 && !alg_test_descs
5904 return -EINVAL;
5905
5906 if (i >= 0 && !alg_test_descs
5907 goto non_fips_alg;
5908 }
5909
5910 rc = 0;
5911 if (i >= 0)
5912 rc |= alg_test_descs[i].test(
5913
5914 if (j >= 0 && j != i)
5915 rc |= alg_test_descs[j].test(
5916
5917
5918 test_done:
5919 if (rc) {
5920 if (fips_enabled || panic_on_
5921 fips_fail_notify();
5922 panic("alg: self-test
5923 driver, alg,
5924 fips_enabled ?
5925 }
5926 pr_warn("alg: self-tests for
5927 alg, driver, rc);
5928 WARN(rc != -ENOENT,
5929 "alg: self-tests for %s
5930 alg, driver, rc);
5931 } else {
5932 if (fips_enabled)
5933 pr_info("alg: self-te
5934 driver, alg);
5935 }
5936
5937 return rc;
5938
5939 notest:
5940 if ((type & CRYPTO_ALG_TYPE_MASK) ==
5941 char nalg[CRYPTO_MAX_ALG_NAME
5942
5943 if (snprintf(nalg, sizeof(nal
5944 sizeof(nalg))
5945 goto notest2;
5946
5947 i = alg_find_test(nalg);
5948 if (i < 0)
5949 goto notest2;
5950
5951 if (fips_enabled && !alg_test
5952 goto non_fips_alg;
5953
5954 rc = alg_test_skcipher(alg_te
5955 goto test_done;
5956 }
5957
5958 notest2:
5959 printk(KERN_INFO "alg: No test for %s
5960
5961 if (type & CRYPTO_ALG_FIPS_INTERNAL)
5962 return alg_fips_disabled(driv
5963
5964 return 0;
5965 non_fips_alg:
5966 return alg_fips_disabled(driver, alg)
5967 }
5968
5969 #endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
5970
5971 EXPORT_SYMBOL_GPL(alg_test);
5972
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.