treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 152
[muen/linux.git] / crypto / testmgr.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Algorithm testing framework and tests.
4  *
5  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
6  * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
7  * Copyright (c) 2007 Nokia Siemens Networks
8  * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
9  * Copyright (c) 2019 Google LLC
10  *
11  * Updated RFC4106 AES-GCM testing.
12  *    Authors: Aidan O'Mahony (aidan.o.mahony@intel.com)
13  *             Adrian Hoban <adrian.hoban@intel.com>
14  *             Gabriele Paoloni <gabriele.paoloni@intel.com>
15  *             Tadeusz Struk (tadeusz.struk@intel.com)
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 <crypto/rng.h>
31 #include <crypto/drbg.h>
32 #include <crypto/akcipher.h>
33 #include <crypto/kpp.h>
34 #include <crypto/acompress.h>
35 #include <crypto/internal/simd.h>
36
37 #include "internal.h"
38
39 static bool notests;
40 module_param(notests, bool, 0644);
41 MODULE_PARM_DESC(notests, "disable crypto self-tests");
42
43 static bool panic_on_fail;
44 module_param(panic_on_fail, bool, 0444);
45
46 #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS
47 static bool noextratests;
48 module_param(noextratests, bool, 0644);
49 MODULE_PARM_DESC(noextratests, "disable expensive crypto self-tests");
50
51 static unsigned int fuzz_iterations = 100;
52 module_param(fuzz_iterations, uint, 0644);
53 MODULE_PARM_DESC(fuzz_iterations, "number of fuzz test iterations");
54
55 DEFINE_PER_CPU(bool, crypto_simd_disabled_for_test);
56 EXPORT_PER_CPU_SYMBOL_GPL(crypto_simd_disabled_for_test);
57 #endif
58
59 #ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
60
61 /* a perfect nop */
62 int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
63 {
64         return 0;
65 }
66
67 #else
68
69 #include "testmgr.h"
70
71 /*
72  * Need slab memory for testing (size in number of pages).
73  */
74 #define XBUFSIZE        8
75
76 /*
77 * Used by test_cipher()
78 */
79 #define ENCRYPT 1
80 #define DECRYPT 0
81
82 struct aead_test_suite {
83         const struct aead_testvec *vecs;
84         unsigned int count;
85 };
86
87 struct cipher_test_suite {
88         const struct cipher_testvec *vecs;
89         unsigned int count;
90 };
91
92 struct comp_test_suite {
93         struct {
94                 const struct comp_testvec *vecs;
95                 unsigned int count;
96         } comp, decomp;
97 };
98
99 struct hash_test_suite {
100         const struct hash_testvec *vecs;
101         unsigned int count;
102 };
103
104 struct cprng_test_suite {
105         const struct cprng_testvec *vecs;
106         unsigned int count;
107 };
108
109 struct drbg_test_suite {
110         const struct drbg_testvec *vecs;
111         unsigned int count;
112 };
113
114 struct akcipher_test_suite {
115         const struct akcipher_testvec *vecs;
116         unsigned int count;
117 };
118
119 struct kpp_test_suite {
120         const struct kpp_testvec *vecs;
121         unsigned int count;
122 };
123
124 struct alg_test_desc {
125         const char *alg;
126         const char *generic_driver;
127         int (*test)(const struct alg_test_desc *desc, const char *driver,
128                     u32 type, u32 mask);
129         int fips_allowed;       /* set if alg is allowed in fips mode */
130
131         union {
132                 struct aead_test_suite aead;
133                 struct cipher_test_suite cipher;
134                 struct comp_test_suite comp;
135                 struct hash_test_suite hash;
136                 struct cprng_test_suite cprng;
137                 struct drbg_test_suite drbg;
138                 struct akcipher_test_suite akcipher;
139                 struct kpp_test_suite kpp;
140         } suite;
141 };
142
143 static void hexdump(unsigned char *buf, unsigned int len)
144 {
145         print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
146                         16, 1,
147                         buf, len, false);
148 }
149
150 static int __testmgr_alloc_buf(char *buf[XBUFSIZE], int order)
151 {
152         int i;
153
154         for (i = 0; i < XBUFSIZE; i++) {
155                 buf[i] = (char *)__get_free_pages(GFP_KERNEL, order);
156                 if (!buf[i])
157                         goto err_free_buf;
158         }
159
160         return 0;
161
162 err_free_buf:
163         while (i-- > 0)
164                 free_pages((unsigned long)buf[i], order);
165
166         return -ENOMEM;
167 }
168
169 static int testmgr_alloc_buf(char *buf[XBUFSIZE])
170 {
171         return __testmgr_alloc_buf(buf, 0);
172 }
173
174 static void __testmgr_free_buf(char *buf[XBUFSIZE], int order)
175 {
176         int i;
177
178         for (i = 0; i < XBUFSIZE; i++)
179                 free_pages((unsigned long)buf[i], order);
180 }
181
182 static void testmgr_free_buf(char *buf[XBUFSIZE])
183 {
184         __testmgr_free_buf(buf, 0);
185 }
186
187 #define TESTMGR_POISON_BYTE     0xfe
188 #define TESTMGR_POISON_LEN      16
189
190 static inline void testmgr_poison(void *addr, size_t len)
191 {
192         memset(addr, TESTMGR_POISON_BYTE, len);
193 }
194
195 /* Is the memory region still fully poisoned? */
196 static inline bool testmgr_is_poison(const void *addr, size_t len)
197 {
198         return memchr_inv(addr, TESTMGR_POISON_BYTE, len) == NULL;
199 }
200
201 /* flush type for hash algorithms */
202 enum flush_type {
203         /* merge with update of previous buffer(s) */
204         FLUSH_TYPE_NONE = 0,
205
206         /* update with previous buffer(s) before doing this one */
207         FLUSH_TYPE_FLUSH,
208
209         /* likewise, but also export and re-import the intermediate state */
210         FLUSH_TYPE_REIMPORT,
211 };
212
213 /* finalization function for hash algorithms */
214 enum finalization_type {
215         FINALIZATION_TYPE_FINAL,        /* use final() */
216         FINALIZATION_TYPE_FINUP,        /* use finup() */
217         FINALIZATION_TYPE_DIGEST,       /* use digest() */
218 };
219
220 #define TEST_SG_TOTAL   10000
221
222 /**
223  * struct test_sg_division - description of a scatterlist entry
224  *
225  * This struct describes one entry of a scatterlist being constructed to check a
226  * crypto test vector.
227  *
228  * @proportion_of_total: length of this chunk relative to the total length,
229  *                       given as a proportion out of TEST_SG_TOTAL so that it
230  *                       scales to fit any test vector
231  * @offset: byte offset into a 2-page buffer at which this chunk will start
232  * @offset_relative_to_alignmask: if true, add the algorithm's alignmask to the
233  *                                @offset
234  * @flush_type: for hashes, whether an update() should be done now vs.
235  *              continuing to accumulate data
236  * @nosimd: if doing the pending update(), do it with SIMD disabled?
237  */
238 struct test_sg_division {
239         unsigned int proportion_of_total;
240         unsigned int offset;
241         bool offset_relative_to_alignmask;
242         enum flush_type flush_type;
243         bool nosimd;
244 };
245
246 /**
247  * struct testvec_config - configuration for testing a crypto test vector
248  *
249  * This struct describes the data layout and other parameters with which each
250  * crypto test vector can be tested.
251  *
252  * @name: name of this config, logged for debugging purposes if a test fails
253  * @inplace: operate on the data in-place, if applicable for the algorithm type?
254  * @req_flags: extra request_flags, e.g. CRYPTO_TFM_REQ_MAY_SLEEP
255  * @src_divs: description of how to arrange the source scatterlist
256  * @dst_divs: description of how to arrange the dst scatterlist, if applicable
257  *            for the algorithm type.  Defaults to @src_divs if unset.
258  * @iv_offset: misalignment of the IV in the range [0..MAX_ALGAPI_ALIGNMASK+1],
259  *             where 0 is aligned to a 2*(MAX_ALGAPI_ALIGNMASK+1) byte boundary
260  * @iv_offset_relative_to_alignmask: if true, add the algorithm's alignmask to
261  *                                   the @iv_offset
262  * @finalization_type: what finalization function to use for hashes
263  * @nosimd: execute with SIMD disabled?  Requires !CRYPTO_TFM_REQ_MAY_SLEEP.
264  */
265 struct testvec_config {
266         const char *name;
267         bool inplace;
268         u32 req_flags;
269         struct test_sg_division src_divs[XBUFSIZE];
270         struct test_sg_division dst_divs[XBUFSIZE];
271         unsigned int iv_offset;
272         bool iv_offset_relative_to_alignmask;
273         enum finalization_type finalization_type;
274         bool nosimd;
275 };
276
277 #define TESTVEC_CONFIG_NAMELEN  192
278
279 /*
280  * The following are the lists of testvec_configs to test for each algorithm
281  * type when the basic crypto self-tests are enabled, i.e. when
282  * CONFIG_CRYPTO_MANAGER_DISABLE_TESTS is unset.  They aim to provide good test
283  * coverage, while keeping the test time much shorter than the full fuzz tests
284  * so that the basic tests can be enabled in a wider range of circumstances.
285  */
286
287 /* Configs for skciphers and aeads */
288 static const struct testvec_config default_cipher_testvec_configs[] = {
289         {
290                 .name = "in-place",
291                 .inplace = true,
292                 .src_divs = { { .proportion_of_total = 10000 } },
293         }, {
294                 .name = "out-of-place",
295                 .src_divs = { { .proportion_of_total = 10000 } },
296         }, {
297                 .name = "unaligned buffer, offset=1",
298                 .src_divs = { { .proportion_of_total = 10000, .offset = 1 } },
299                 .iv_offset = 1,
300         }, {
301                 .name = "buffer aligned only to alignmask",
302                 .src_divs = {
303                         {
304                                 .proportion_of_total = 10000,
305                                 .offset = 1,
306                                 .offset_relative_to_alignmask = true,
307                         },
308                 },
309                 .iv_offset = 1,
310                 .iv_offset_relative_to_alignmask = true,
311         }, {
312                 .name = "two even aligned splits",
313                 .src_divs = {
314                         { .proportion_of_total = 5000 },
315                         { .proportion_of_total = 5000 },
316                 },
317         }, {
318                 .name = "uneven misaligned splits, may sleep",
319                 .req_flags = CRYPTO_TFM_REQ_MAY_SLEEP,
320                 .src_divs = {
321                         { .proportion_of_total = 1900, .offset = 33 },
322                         { .proportion_of_total = 3300, .offset = 7  },
323                         { .proportion_of_total = 4800, .offset = 18 },
324                 },
325                 .iv_offset = 3,
326         }, {
327                 .name = "misaligned splits crossing pages, inplace",
328                 .inplace = true,
329                 .src_divs = {
330                         {
331                                 .proportion_of_total = 7500,
332                                 .offset = PAGE_SIZE - 32
333                         }, {
334                                 .proportion_of_total = 2500,
335                                 .offset = PAGE_SIZE - 7
336                         },
337                 },
338         }
339 };
340
341 static const struct testvec_config default_hash_testvec_configs[] = {
342         {
343                 .name = "init+update+final aligned buffer",
344                 .src_divs = { { .proportion_of_total = 10000 } },
345                 .finalization_type = FINALIZATION_TYPE_FINAL,
346         }, {
347                 .name = "init+finup aligned buffer",
348                 .src_divs = { { .proportion_of_total = 10000 } },
349                 .finalization_type = FINALIZATION_TYPE_FINUP,
350         }, {
351                 .name = "digest aligned buffer",
352                 .src_divs = { { .proportion_of_total = 10000 } },
353                 .finalization_type = FINALIZATION_TYPE_DIGEST,
354         }, {
355                 .name = "init+update+final misaligned buffer",
356                 .src_divs = { { .proportion_of_total = 10000, .offset = 1 } },
357                 .finalization_type = FINALIZATION_TYPE_FINAL,
358         }, {
359                 .name = "digest buffer aligned only to alignmask",
360                 .src_divs = {
361                         {
362                                 .proportion_of_total = 10000,
363                                 .offset = 1,
364                                 .offset_relative_to_alignmask = true,
365                         },
366                 },
367                 .finalization_type = FINALIZATION_TYPE_DIGEST,
368         }, {
369                 .name = "init+update+update+final two even splits",
370                 .src_divs = {
371                         { .proportion_of_total = 5000 },
372                         {
373                                 .proportion_of_total = 5000,
374                                 .flush_type = FLUSH_TYPE_FLUSH,
375                         },
376                 },
377                 .finalization_type = FINALIZATION_TYPE_FINAL,
378         }, {
379                 .name = "digest uneven misaligned splits, may sleep",
380                 .req_flags = CRYPTO_TFM_REQ_MAY_SLEEP,
381                 .src_divs = {
382                         { .proportion_of_total = 1900, .offset = 33 },
383                         { .proportion_of_total = 3300, .offset = 7  },
384                         { .proportion_of_total = 4800, .offset = 18 },
385                 },
386                 .finalization_type = FINALIZATION_TYPE_DIGEST,
387         }, {
388                 .name = "digest misaligned splits crossing pages",
389                 .src_divs = {
390                         {
391                                 .proportion_of_total = 7500,
392                                 .offset = PAGE_SIZE - 32,
393                         }, {
394                                 .proportion_of_total = 2500,
395                                 .offset = PAGE_SIZE - 7,
396                         },
397                 },
398                 .finalization_type = FINALIZATION_TYPE_DIGEST,
399         }, {
400                 .name = "import/export",
401                 .src_divs = {
402                         {
403                                 .proportion_of_total = 6500,
404                                 .flush_type = FLUSH_TYPE_REIMPORT,
405                         }, {
406                                 .proportion_of_total = 3500,
407                                 .flush_type = FLUSH_TYPE_REIMPORT,
408                         },
409                 },
410                 .finalization_type = FINALIZATION_TYPE_FINAL,
411         }
412 };
413
414 static unsigned int count_test_sg_divisions(const struct test_sg_division *divs)
415 {
416         unsigned int remaining = TEST_SG_TOTAL;
417         unsigned int ndivs = 0;
418
419         do {
420                 remaining -= divs[ndivs++].proportion_of_total;
421         } while (remaining);
422
423         return ndivs;
424 }
425
426 #define SGDIVS_HAVE_FLUSHES     BIT(0)
427 #define SGDIVS_HAVE_NOSIMD      BIT(1)
428
429 static bool valid_sg_divisions(const struct test_sg_division *divs,
430                                unsigned int count, int *flags_ret)
431 {
432         unsigned int total = 0;
433         unsigned int i;
434
435         for (i = 0; i < count && total != TEST_SG_TOTAL; i++) {
436                 if (divs[i].proportion_of_total <= 0 ||
437                     divs[i].proportion_of_total > TEST_SG_TOTAL - total)
438                         return false;
439                 total += divs[i].proportion_of_total;
440                 if (divs[i].flush_type != FLUSH_TYPE_NONE)
441                         *flags_ret |= SGDIVS_HAVE_FLUSHES;
442                 if (divs[i].nosimd)
443                         *flags_ret |= SGDIVS_HAVE_NOSIMD;
444         }
445         return total == TEST_SG_TOTAL &&
446                 memchr_inv(&divs[i], 0, (count - i) * sizeof(divs[0])) == NULL;
447 }
448
449 /*
450  * Check whether the given testvec_config is valid.  This isn't strictly needed
451  * since every testvec_config should be valid, but check anyway so that people
452  * don't unknowingly add broken configs that don't do what they wanted.
453  */
454 static bool valid_testvec_config(const struct testvec_config *cfg)
455 {
456         int flags = 0;
457
458         if (cfg->name == NULL)
459                 return false;
460
461         if (!valid_sg_divisions(cfg->src_divs, ARRAY_SIZE(cfg->src_divs),
462                                 &flags))
463                 return false;
464
465         if (cfg->dst_divs[0].proportion_of_total) {
466                 if (!valid_sg_divisions(cfg->dst_divs,
467                                         ARRAY_SIZE(cfg->dst_divs), &flags))
468                         return false;
469         } else {
470                 if (memchr_inv(cfg->dst_divs, 0, sizeof(cfg->dst_divs)))
471                         return false;
472                 /* defaults to dst_divs=src_divs */
473         }
474
475         if (cfg->iv_offset +
476             (cfg->iv_offset_relative_to_alignmask ? MAX_ALGAPI_ALIGNMASK : 0) >
477             MAX_ALGAPI_ALIGNMASK + 1)
478                 return false;
479
480         if ((flags & (SGDIVS_HAVE_FLUSHES | SGDIVS_HAVE_NOSIMD)) &&
481             cfg->finalization_type == FINALIZATION_TYPE_DIGEST)
482                 return false;
483
484         if ((cfg->nosimd || (flags & SGDIVS_HAVE_NOSIMD)) &&
485             (cfg->req_flags & CRYPTO_TFM_REQ_MAY_SLEEP))
486                 return false;
487
488         return true;
489 }
490
491 struct test_sglist {
492         char *bufs[XBUFSIZE];
493         struct scatterlist sgl[XBUFSIZE];
494         struct scatterlist sgl_saved[XBUFSIZE];
495         struct scatterlist *sgl_ptr;
496         unsigned int nents;
497 };
498
499 static int init_test_sglist(struct test_sglist *tsgl)
500 {
501         return __testmgr_alloc_buf(tsgl->bufs, 1 /* two pages per buffer */);
502 }
503
504 static void destroy_test_sglist(struct test_sglist *tsgl)
505 {
506         return __testmgr_free_buf(tsgl->bufs, 1 /* two pages per buffer */);
507 }
508
509 /**
510  * build_test_sglist() - build a scatterlist for a crypto test
511  *
512  * @tsgl: the scatterlist to build.  @tsgl->bufs[] contains an array of 2-page
513  *        buffers which the scatterlist @tsgl->sgl[] will be made to point into.
514  * @divs: the layout specification on which the scatterlist will be based
515  * @alignmask: the algorithm's alignmask
516  * @total_len: the total length of the scatterlist to build in bytes
517  * @data: if non-NULL, the buffers will be filled with this data until it ends.
518  *        Otherwise the buffers will be poisoned.  In both cases, some bytes
519  *        past the end of each buffer will be poisoned to help detect overruns.
520  * @out_divs: if non-NULL, the test_sg_division to which each scatterlist entry
521  *            corresponds will be returned here.  This will match @divs except
522  *            that divisions resolving to a length of 0 are omitted as they are
523  *            not included in the scatterlist.
524  *
525  * Return: 0 or a -errno value
526  */
527 static int build_test_sglist(struct test_sglist *tsgl,
528                              const struct test_sg_division *divs,
529                              const unsigned int alignmask,
530                              const unsigned int total_len,
531                              struct iov_iter *data,
532                              const struct test_sg_division *out_divs[XBUFSIZE])
533 {
534         struct {
535                 const struct test_sg_division *div;
536                 size_t length;
537         } partitions[XBUFSIZE];
538         const unsigned int ndivs = count_test_sg_divisions(divs);
539         unsigned int len_remaining = total_len;
540         unsigned int i;
541
542         BUILD_BUG_ON(ARRAY_SIZE(partitions) != ARRAY_SIZE(tsgl->sgl));
543         if (WARN_ON(ndivs > ARRAY_SIZE(partitions)))
544                 return -EINVAL;
545
546         /* Calculate the (div, length) pairs */
547         tsgl->nents = 0;
548         for (i = 0; i < ndivs; i++) {
549                 unsigned int len_this_sg =
550                         min(len_remaining,
551                             (total_len * divs[i].proportion_of_total +
552                              TEST_SG_TOTAL / 2) / TEST_SG_TOTAL);
553
554                 if (len_this_sg != 0) {
555                         partitions[tsgl->nents].div = &divs[i];
556                         partitions[tsgl->nents].length = len_this_sg;
557                         tsgl->nents++;
558                         len_remaining -= len_this_sg;
559                 }
560         }
561         if (tsgl->nents == 0) {
562                 partitions[tsgl->nents].div = &divs[0];
563                 partitions[tsgl->nents].length = 0;
564                 tsgl->nents++;
565         }
566         partitions[tsgl->nents - 1].length += len_remaining;
567
568         /* Set up the sgl entries and fill the data or poison */
569         sg_init_table(tsgl->sgl, tsgl->nents);
570         for (i = 0; i < tsgl->nents; i++) {
571                 unsigned int offset = partitions[i].div->offset;
572                 void *addr;
573
574                 if (partitions[i].div->offset_relative_to_alignmask)
575                         offset += alignmask;
576
577                 while (offset + partitions[i].length + TESTMGR_POISON_LEN >
578                        2 * PAGE_SIZE) {
579                         if (WARN_ON(offset <= 0))
580                                 return -EINVAL;
581                         offset /= 2;
582                 }
583
584                 addr = &tsgl->bufs[i][offset];
585                 sg_set_buf(&tsgl->sgl[i], addr, partitions[i].length);
586
587                 if (out_divs)
588                         out_divs[i] = partitions[i].div;
589
590                 if (data) {
591                         size_t copy_len, copied;
592
593                         copy_len = min(partitions[i].length, data->count);
594                         copied = copy_from_iter(addr, copy_len, data);
595                         if (WARN_ON(copied != copy_len))
596                                 return -EINVAL;
597                         testmgr_poison(addr + copy_len, partitions[i].length +
598                                        TESTMGR_POISON_LEN - copy_len);
599                 } else {
600                         testmgr_poison(addr, partitions[i].length +
601                                        TESTMGR_POISON_LEN);
602                 }
603         }
604
605         sg_mark_end(&tsgl->sgl[tsgl->nents - 1]);
606         tsgl->sgl_ptr = tsgl->sgl;
607         memcpy(tsgl->sgl_saved, tsgl->sgl, tsgl->nents * sizeof(tsgl->sgl[0]));
608         return 0;
609 }
610
611 /*
612  * Verify that a scatterlist crypto operation produced the correct output.
613  *
614  * @tsgl: scatterlist containing the actual output
615  * @expected_output: buffer containing the expected output
616  * @len_to_check: length of @expected_output in bytes
617  * @unchecked_prefix_len: number of ignored bytes in @tsgl prior to real result
618  * @check_poison: verify that the poison bytes after each chunk are intact?
619  *
620  * Return: 0 if correct, -EINVAL if incorrect, -EOVERFLOW if buffer overrun.
621  */
622 static int verify_correct_output(const struct test_sglist *tsgl,
623                                  const char *expected_output,
624                                  unsigned int len_to_check,
625                                  unsigned int unchecked_prefix_len,
626                                  bool check_poison)
627 {
628         unsigned int i;
629
630         for (i = 0; i < tsgl->nents; i++) {
631                 struct scatterlist *sg = &tsgl->sgl_ptr[i];
632                 unsigned int len = sg->length;
633                 unsigned int offset = sg->offset;
634                 const char *actual_output;
635
636                 if (unchecked_prefix_len) {
637                         if (unchecked_prefix_len >= len) {
638                                 unchecked_prefix_len -= len;
639                                 continue;
640                         }
641                         offset += unchecked_prefix_len;
642                         len -= unchecked_prefix_len;
643                         unchecked_prefix_len = 0;
644                 }
645                 len = min(len, len_to_check);
646                 actual_output = page_address(sg_page(sg)) + offset;
647                 if (memcmp(expected_output, actual_output, len) != 0)
648                         return -EINVAL;
649                 if (check_poison &&
650                     !testmgr_is_poison(actual_output + len, TESTMGR_POISON_LEN))
651                         return -EOVERFLOW;
652                 len_to_check -= len;
653                 expected_output += len;
654         }
655         if (WARN_ON(len_to_check != 0))
656                 return -EINVAL;
657         return 0;
658 }
659
660 static bool is_test_sglist_corrupted(const struct test_sglist *tsgl)
661 {
662         unsigned int i;
663
664         for (i = 0; i < tsgl->nents; i++) {
665                 if (tsgl->sgl[i].page_link != tsgl->sgl_saved[i].page_link)
666                         return true;
667                 if (tsgl->sgl[i].offset != tsgl->sgl_saved[i].offset)
668                         return true;
669                 if (tsgl->sgl[i].length != tsgl->sgl_saved[i].length)
670                         return true;
671         }
672         return false;
673 }
674
675 struct cipher_test_sglists {
676         struct test_sglist src;
677         struct test_sglist dst;
678 };
679
680 static struct cipher_test_sglists *alloc_cipher_test_sglists(void)
681 {
682         struct cipher_test_sglists *tsgls;
683
684         tsgls = kmalloc(sizeof(*tsgls), GFP_KERNEL);
685         if (!tsgls)
686                 return NULL;
687
688         if (init_test_sglist(&tsgls->src) != 0)
689                 goto fail_kfree;
690         if (init_test_sglist(&tsgls->dst) != 0)
691                 goto fail_destroy_src;
692
693         return tsgls;
694
695 fail_destroy_src:
696         destroy_test_sglist(&tsgls->src);
697 fail_kfree:
698         kfree(tsgls);
699         return NULL;
700 }
701
702 static void free_cipher_test_sglists(struct cipher_test_sglists *tsgls)
703 {
704         if (tsgls) {
705                 destroy_test_sglist(&tsgls->src);
706                 destroy_test_sglist(&tsgls->dst);
707                 kfree(tsgls);
708         }
709 }
710
711 /* Build the src and dst scatterlists for an skcipher or AEAD test */
712 static int build_cipher_test_sglists(struct cipher_test_sglists *tsgls,
713                                      const struct testvec_config *cfg,
714                                      unsigned int alignmask,
715                                      unsigned int src_total_len,
716                                      unsigned int dst_total_len,
717                                      const struct kvec *inputs,
718                                      unsigned int nr_inputs)
719 {
720         struct iov_iter input;
721         int err;
722
723         iov_iter_kvec(&input, WRITE, inputs, nr_inputs, src_total_len);
724         err = build_test_sglist(&tsgls->src, cfg->src_divs, alignmask,
725                                 cfg->inplace ?
726                                         max(dst_total_len, src_total_len) :
727                                         src_total_len,
728                                 &input, NULL);
729         if (err)
730                 return err;
731
732         if (cfg->inplace) {
733                 tsgls->dst.sgl_ptr = tsgls->src.sgl;
734                 tsgls->dst.nents = tsgls->src.nents;
735                 return 0;
736         }
737         return build_test_sglist(&tsgls->dst,
738                                  cfg->dst_divs[0].proportion_of_total ?
739                                         cfg->dst_divs : cfg->src_divs,
740                                  alignmask, dst_total_len, NULL, NULL);
741 }
742
743 #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS
744
745 /* Generate a random length in range [0, max_len], but prefer smaller values */
746 static unsigned int generate_random_length(unsigned int max_len)
747 {
748         unsigned int len = prandom_u32() % (max_len + 1);
749
750         switch (prandom_u32() % 4) {
751         case 0:
752                 return len % 64;
753         case 1:
754                 return len % 256;
755         case 2:
756                 return len % 1024;
757         default:
758                 return len;
759         }
760 }
761
762 /* Sometimes make some random changes to the given data buffer */
763 static void mutate_buffer(u8 *buf, size_t count)
764 {
765         size_t num_flips;
766         size_t i;
767         size_t pos;
768
769         /* Sometimes flip some bits */
770         if (prandom_u32() % 4 == 0) {
771                 num_flips = min_t(size_t, 1 << (prandom_u32() % 8), count * 8);
772                 for (i = 0; i < num_flips; i++) {
773                         pos = prandom_u32() % (count * 8);
774                         buf[pos / 8] ^= 1 << (pos % 8);
775                 }
776         }
777
778         /* Sometimes flip some bytes */
779         if (prandom_u32() % 4 == 0) {
780                 num_flips = min_t(size_t, 1 << (prandom_u32() % 8), count);
781                 for (i = 0; i < num_flips; i++)
782                         buf[prandom_u32() % count] ^= 0xff;
783         }
784 }
785
786 /* Randomly generate 'count' bytes, but sometimes make them "interesting" */
787 static void generate_random_bytes(u8 *buf, size_t count)
788 {
789         u8 b;
790         u8 increment;
791         size_t i;
792
793         if (count == 0)
794                 return;
795
796         switch (prandom_u32() % 8) { /* Choose a generation strategy */
797         case 0:
798         case 1:
799                 /* All the same byte, plus optional mutations */
800                 switch (prandom_u32() % 4) {
801                 case 0:
802                         b = 0x00;
803                         break;
804                 case 1:
805                         b = 0xff;
806                         break;
807                 default:
808                         b = (u8)prandom_u32();
809                         break;
810                 }
811                 memset(buf, b, count);
812                 mutate_buffer(buf, count);
813                 break;
814         case 2:
815                 /* Ascending or descending bytes, plus optional mutations */
816                 increment = (u8)prandom_u32();
817                 b = (u8)prandom_u32();
818                 for (i = 0; i < count; i++, b += increment)
819                         buf[i] = b;
820                 mutate_buffer(buf, count);
821                 break;
822         default:
823                 /* Fully random bytes */
824                 for (i = 0; i < count; i++)
825                         buf[i] = (u8)prandom_u32();
826         }
827 }
828
829 static char *generate_random_sgl_divisions(struct test_sg_division *divs,
830                                            size_t max_divs, char *p, char *end,
831                                            bool gen_flushes, u32 req_flags)
832 {
833         struct test_sg_division *div = divs;
834         unsigned int remaining = TEST_SG_TOTAL;
835
836         do {
837                 unsigned int this_len;
838                 const char *flushtype_str;
839
840                 if (div == &divs[max_divs - 1] || prandom_u32() % 2 == 0)
841                         this_len = remaining;
842                 else
843                         this_len = 1 + (prandom_u32() % remaining);
844                 div->proportion_of_total = this_len;
845
846                 if (prandom_u32() % 4 == 0)
847                         div->offset = (PAGE_SIZE - 128) + (prandom_u32() % 128);
848                 else if (prandom_u32() % 2 == 0)
849                         div->offset = prandom_u32() % 32;
850                 else
851                         div->offset = prandom_u32() % PAGE_SIZE;
852                 if (prandom_u32() % 8 == 0)
853                         div->offset_relative_to_alignmask = true;
854
855                 div->flush_type = FLUSH_TYPE_NONE;
856                 if (gen_flushes) {
857                         switch (prandom_u32() % 4) {
858                         case 0:
859                                 div->flush_type = FLUSH_TYPE_REIMPORT;
860                                 break;
861                         case 1:
862                                 div->flush_type = FLUSH_TYPE_FLUSH;
863                                 break;
864                         }
865                 }
866
867                 if (div->flush_type != FLUSH_TYPE_NONE &&
868                     !(req_flags & CRYPTO_TFM_REQ_MAY_SLEEP) &&
869                     prandom_u32() % 2 == 0)
870                         div->nosimd = true;
871
872                 switch (div->flush_type) {
873                 case FLUSH_TYPE_FLUSH:
874                         if (div->nosimd)
875                                 flushtype_str = "<flush,nosimd>";
876                         else
877                                 flushtype_str = "<flush>";
878                         break;
879                 case FLUSH_TYPE_REIMPORT:
880                         if (div->nosimd)
881                                 flushtype_str = "<reimport,nosimd>";
882                         else
883                                 flushtype_str = "<reimport>";
884                         break;
885                 default:
886                         flushtype_str = "";
887                         break;
888                 }
889
890                 BUILD_BUG_ON(TEST_SG_TOTAL != 10000); /* for "%u.%u%%" */
891                 p += scnprintf(p, end - p, "%s%u.%u%%@%s+%u%s", flushtype_str,
892                                this_len / 100, this_len % 100,
893                                div->offset_relative_to_alignmask ?
894                                         "alignmask" : "",
895                                div->offset, this_len == remaining ? "" : ", ");
896                 remaining -= this_len;
897                 div++;
898         } while (remaining);
899
900         return p;
901 }
902
903 /* Generate a random testvec_config for fuzz testing */
904 static void generate_random_testvec_config(struct testvec_config *cfg,
905                                            char *name, size_t max_namelen)
906 {
907         char *p = name;
908         char * const end = name + max_namelen;
909
910         memset(cfg, 0, sizeof(*cfg));
911
912         cfg->name = name;
913
914         p += scnprintf(p, end - p, "random:");
915
916         if (prandom_u32() % 2 == 0) {
917                 cfg->inplace = true;
918                 p += scnprintf(p, end - p, " inplace");
919         }
920
921         if (prandom_u32() % 2 == 0) {
922                 cfg->req_flags |= CRYPTO_TFM_REQ_MAY_SLEEP;
923                 p += scnprintf(p, end - p, " may_sleep");
924         }
925
926         switch (prandom_u32() % 4) {
927         case 0:
928                 cfg->finalization_type = FINALIZATION_TYPE_FINAL;
929                 p += scnprintf(p, end - p, " use_final");
930                 break;
931         case 1:
932                 cfg->finalization_type = FINALIZATION_TYPE_FINUP;
933                 p += scnprintf(p, end - p, " use_finup");
934                 break;
935         default:
936                 cfg->finalization_type = FINALIZATION_TYPE_DIGEST;
937                 p += scnprintf(p, end - p, " use_digest");
938                 break;
939         }
940
941         if (!(cfg->req_flags & CRYPTO_TFM_REQ_MAY_SLEEP) &&
942             prandom_u32() % 2 == 0) {
943                 cfg->nosimd = true;
944                 p += scnprintf(p, end - p, " nosimd");
945         }
946
947         p += scnprintf(p, end - p, " src_divs=[");
948         p = generate_random_sgl_divisions(cfg->src_divs,
949                                           ARRAY_SIZE(cfg->src_divs), p, end,
950                                           (cfg->finalization_type !=
951                                            FINALIZATION_TYPE_DIGEST),
952                                           cfg->req_flags);
953         p += scnprintf(p, end - p, "]");
954
955         if (!cfg->inplace && prandom_u32() % 2 == 0) {
956                 p += scnprintf(p, end - p, " dst_divs=[");
957                 p = generate_random_sgl_divisions(cfg->dst_divs,
958                                                   ARRAY_SIZE(cfg->dst_divs),
959                                                   p, end, false,
960                                                   cfg->req_flags);
961                 p += scnprintf(p, end - p, "]");
962         }
963
964         if (prandom_u32() % 2 == 0) {
965                 cfg->iv_offset = 1 + (prandom_u32() % MAX_ALGAPI_ALIGNMASK);
966                 p += scnprintf(p, end - p, " iv_offset=%u", cfg->iv_offset);
967         }
968
969         WARN_ON_ONCE(!valid_testvec_config(cfg));
970 }
971
972 static void crypto_disable_simd_for_test(void)
973 {
974         preempt_disable();
975         __this_cpu_write(crypto_simd_disabled_for_test, true);
976 }
977
978 static void crypto_reenable_simd_for_test(void)
979 {
980         __this_cpu_write(crypto_simd_disabled_for_test, false);
981         preempt_enable();
982 }
983
984 /*
985  * Given an algorithm name, build the name of the generic implementation of that
986  * algorithm, assuming the usual naming convention.  Specifically, this appends
987  * "-generic" to every part of the name that is not a template name.  Examples:
988  *
989  *      aes => aes-generic
990  *      cbc(aes) => cbc(aes-generic)
991  *      cts(cbc(aes)) => cts(cbc(aes-generic))
992  *      rfc7539(chacha20,poly1305) => rfc7539(chacha20-generic,poly1305-generic)
993  *
994  * Return: 0 on success, or -ENAMETOOLONG if the generic name would be too long
995  */
996 static int build_generic_driver_name(const char *algname,
997                                      char driver_name[CRYPTO_MAX_ALG_NAME])
998 {
999         const char *in = algname;
1000         char *out = driver_name;
1001         size_t len = strlen(algname);
1002
1003         if (len >= CRYPTO_MAX_ALG_NAME)
1004                 goto too_long;
1005         do {
1006                 const char *in_saved = in;
1007
1008                 while (*in && *in != '(' && *in != ')' && *in != ',')
1009                         *out++ = *in++;
1010                 if (*in != '(' && in > in_saved) {
1011                         len += 8;
1012                         if (len >= CRYPTO_MAX_ALG_NAME)
1013                                 goto too_long;
1014                         memcpy(out, "-generic", 8);
1015                         out += 8;
1016                 }
1017         } while ((*out++ = *in++) != '\0');
1018         return 0;
1019
1020 too_long:
1021         pr_err("alg: generic driver name for \"%s\" would be too long\n",
1022                algname);
1023         return -ENAMETOOLONG;
1024 }
1025 #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */
1026 static void crypto_disable_simd_for_test(void)
1027 {
1028 }
1029
1030 static void crypto_reenable_simd_for_test(void)
1031 {
1032 }
1033 #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */
1034
1035 static int do_ahash_op(int (*op)(struct ahash_request *req),
1036                        struct ahash_request *req,
1037                        struct crypto_wait *wait, bool nosimd)
1038 {
1039         int err;
1040
1041         if (nosimd)
1042                 crypto_disable_simd_for_test();
1043
1044         err = op(req);
1045
1046         if (nosimd)
1047                 crypto_reenable_simd_for_test();
1048
1049         return crypto_wait_req(err, wait);
1050 }
1051
1052 static int check_nonfinal_hash_op(const char *op, int err,
1053                                   u8 *result, unsigned int digestsize,
1054                                   const char *driver, const char *vec_name,
1055                                   const struct testvec_config *cfg)
1056 {
1057         if (err) {
1058                 pr_err("alg: hash: %s %s() failed with err %d on test vector %s, cfg=\"%s\"\n",
1059                        driver, op, err, vec_name, cfg->name);
1060                 return err;
1061         }
1062         if (!testmgr_is_poison(result, digestsize)) {
1063                 pr_err("alg: hash: %s %s() used result buffer on test vector %s, cfg=\"%s\"\n",
1064                        driver, op, vec_name, cfg->name);
1065                 return -EINVAL;
1066         }
1067         return 0;
1068 }
1069
1070 static int test_hash_vec_cfg(const char *driver,
1071                              const struct hash_testvec *vec,
1072                              const char *vec_name,
1073                              const struct testvec_config *cfg,
1074                              struct ahash_request *req,
1075                              struct test_sglist *tsgl,
1076                              u8 *hashstate)
1077 {
1078         struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
1079         const unsigned int alignmask = crypto_ahash_alignmask(tfm);
1080         const unsigned int digestsize = crypto_ahash_digestsize(tfm);
1081         const unsigned int statesize = crypto_ahash_statesize(tfm);
1082         const u32 req_flags = CRYPTO_TFM_REQ_MAY_BACKLOG | cfg->req_flags;
1083         const struct test_sg_division *divs[XBUFSIZE];
1084         DECLARE_CRYPTO_WAIT(wait);
1085         struct kvec _input;
1086         struct iov_iter input;
1087         unsigned int i;
1088         struct scatterlist *pending_sgl;
1089         unsigned int pending_len;
1090         u8 result[HASH_MAX_DIGESTSIZE + TESTMGR_POISON_LEN];
1091         int err;
1092
1093         /* Set the key, if specified */
1094         if (vec->ksize) {
1095                 err = crypto_ahash_setkey(tfm, vec->key, vec->ksize);
1096                 if (err) {
1097                         if (err == vec->setkey_error)
1098                                 return 0;
1099                         pr_err("alg: hash: %s setkey failed on test vector %s; expected_error=%d, actual_error=%d, flags=%#x\n",
1100                                driver, vec_name, vec->setkey_error, err,
1101                                crypto_ahash_get_flags(tfm));
1102                         return err;
1103                 }
1104                 if (vec->setkey_error) {
1105                         pr_err("alg: hash: %s setkey unexpectedly succeeded on test vector %s; expected_error=%d\n",
1106                                driver, vec_name, vec->setkey_error);
1107                         return -EINVAL;
1108                 }
1109         }
1110
1111         /* Build the scatterlist for the source data */
1112         _input.iov_base = (void *)vec->plaintext;
1113         _input.iov_len = vec->psize;
1114         iov_iter_kvec(&input, WRITE, &_input, 1, vec->psize);
1115         err = build_test_sglist(tsgl, cfg->src_divs, alignmask, vec->psize,
1116                                 &input, divs);
1117         if (err) {
1118                 pr_err("alg: hash: %s: error preparing scatterlist for test vector %s, cfg=\"%s\"\n",
1119                        driver, vec_name, cfg->name);
1120                 return err;
1121         }
1122
1123         /* Do the actual hashing */
1124
1125         testmgr_poison(req->__ctx, crypto_ahash_reqsize(tfm));
1126         testmgr_poison(result, digestsize + TESTMGR_POISON_LEN);
1127
1128         if (cfg->finalization_type == FINALIZATION_TYPE_DIGEST ||
1129             vec->digest_error) {
1130                 /* Just using digest() */
1131                 ahash_request_set_callback(req, req_flags, crypto_req_done,
1132                                            &wait);
1133                 ahash_request_set_crypt(req, tsgl->sgl, result, vec->psize);
1134                 err = do_ahash_op(crypto_ahash_digest, req, &wait, cfg->nosimd);
1135                 if (err) {
1136                         if (err == vec->digest_error)
1137                                 return 0;
1138                         pr_err("alg: hash: %s digest() failed on test vector %s; expected_error=%d, actual_error=%d, cfg=\"%s\"\n",
1139                                driver, vec_name, vec->digest_error, err,
1140                                cfg->name);
1141                         return err;
1142                 }
1143                 if (vec->digest_error) {
1144                         pr_err("alg: hash: %s digest() unexpectedly succeeded on test vector %s; expected_error=%d, cfg=\"%s\"\n",
1145                                driver, vec_name, vec->digest_error, cfg->name);
1146                         return -EINVAL;
1147                 }
1148                 goto result_ready;
1149         }
1150
1151         /* Using init(), zero or more update(), then final() or finup() */
1152
1153         ahash_request_set_callback(req, req_flags, crypto_req_done, &wait);
1154         ahash_request_set_crypt(req, NULL, result, 0);
1155         err = do_ahash_op(crypto_ahash_init, req, &wait, cfg->nosimd);
1156         err = check_nonfinal_hash_op("init", err, result, digestsize,
1157                                      driver, vec_name, cfg);
1158         if (err)
1159                 return err;
1160
1161         pending_sgl = NULL;
1162         pending_len = 0;
1163         for (i = 0; i < tsgl->nents; i++) {
1164                 if (divs[i]->flush_type != FLUSH_TYPE_NONE &&
1165                     pending_sgl != NULL) {
1166                         /* update() with the pending data */
1167                         ahash_request_set_callback(req, req_flags,
1168                                                    crypto_req_done, &wait);
1169                         ahash_request_set_crypt(req, pending_sgl, result,
1170                                                 pending_len);
1171                         err = do_ahash_op(crypto_ahash_update, req, &wait,
1172                                           divs[i]->nosimd);
1173                         err = check_nonfinal_hash_op("update", err,
1174                                                      result, digestsize,
1175                                                      driver, vec_name, cfg);
1176                         if (err)
1177                                 return err;
1178                         pending_sgl = NULL;
1179                         pending_len = 0;
1180                 }
1181                 if (divs[i]->flush_type == FLUSH_TYPE_REIMPORT) {
1182                         /* Test ->export() and ->import() */
1183                         testmgr_poison(hashstate + statesize,
1184                                        TESTMGR_POISON_LEN);
1185                         err = crypto_ahash_export(req, hashstate);
1186                         err = check_nonfinal_hash_op("export", err,
1187                                                      result, digestsize,
1188                                                      driver, vec_name, cfg);
1189                         if (err)
1190                                 return err;
1191                         if (!testmgr_is_poison(hashstate + statesize,
1192                                                TESTMGR_POISON_LEN)) {
1193                                 pr_err("alg: hash: %s export() overran state buffer on test vector %s, cfg=\"%s\"\n",
1194                                        driver, vec_name, cfg->name);
1195                                 return -EOVERFLOW;
1196                         }
1197
1198                         testmgr_poison(req->__ctx, crypto_ahash_reqsize(tfm));
1199                         err = crypto_ahash_import(req, hashstate);
1200                         err = check_nonfinal_hash_op("import", err,
1201                                                      result, digestsize,
1202                                                      driver, vec_name, cfg);
1203                         if (err)
1204                                 return err;
1205                 }
1206                 if (pending_sgl == NULL)
1207                         pending_sgl = &tsgl->sgl[i];
1208                 pending_len += tsgl->sgl[i].length;
1209         }
1210
1211         ahash_request_set_callback(req, req_flags, crypto_req_done, &wait);
1212         ahash_request_set_crypt(req, pending_sgl, result, pending_len);
1213         if (cfg->finalization_type == FINALIZATION_TYPE_FINAL) {
1214                 /* finish with update() and final() */
1215                 err = do_ahash_op(crypto_ahash_update, req, &wait, cfg->nosimd);
1216                 err = check_nonfinal_hash_op("update", err, result, digestsize,
1217                                              driver, vec_name, cfg);
1218                 if (err)
1219                         return err;
1220                 err = do_ahash_op(crypto_ahash_final, req, &wait, cfg->nosimd);
1221                 if (err) {
1222                         pr_err("alg: hash: %s final() failed with err %d on test vector %s, cfg=\"%s\"\n",
1223                                driver, err, vec_name, cfg->name);
1224                         return err;
1225                 }
1226         } else {
1227                 /* finish with finup() */
1228                 err = do_ahash_op(crypto_ahash_finup, req, &wait, cfg->nosimd);
1229                 if (err) {
1230                         pr_err("alg: hash: %s finup() failed with err %d on test vector %s, cfg=\"%s\"\n",
1231                                driver, err, vec_name, cfg->name);
1232                         return err;
1233                 }
1234         }
1235
1236 result_ready:
1237         /* Check that the algorithm produced the correct digest */
1238         if (memcmp(result, vec->digest, digestsize) != 0) {
1239                 pr_err("alg: hash: %s test failed (wrong result) on test vector %s, cfg=\"%s\"\n",
1240                        driver, vec_name, cfg->name);
1241                 return -EINVAL;
1242         }
1243         if (!testmgr_is_poison(&result[digestsize], TESTMGR_POISON_LEN)) {
1244                 pr_err("alg: hash: %s overran result buffer on test vector %s, cfg=\"%s\"\n",
1245                        driver, vec_name, cfg->name);
1246                 return -EOVERFLOW;
1247         }
1248
1249         return 0;
1250 }
1251
1252 static int test_hash_vec(const char *driver, const struct hash_testvec *vec,
1253                          unsigned int vec_num, struct ahash_request *req,
1254                          struct test_sglist *tsgl, u8 *hashstate)
1255 {
1256         char vec_name[16];
1257         unsigned int i;
1258         int err;
1259
1260         sprintf(vec_name, "%u", vec_num);
1261
1262         for (i = 0; i < ARRAY_SIZE(default_hash_testvec_configs); i++) {
1263                 err = test_hash_vec_cfg(driver, vec, vec_name,
1264                                         &default_hash_testvec_configs[i],
1265                                         req, tsgl, hashstate);
1266                 if (err)
1267                         return err;
1268         }
1269
1270 #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS
1271         if (!noextratests) {
1272                 struct testvec_config cfg;
1273                 char cfgname[TESTVEC_CONFIG_NAMELEN];
1274
1275                 for (i = 0; i < fuzz_iterations; i++) {
1276                         generate_random_testvec_config(&cfg, cfgname,
1277                                                        sizeof(cfgname));
1278                         err = test_hash_vec_cfg(driver, vec, vec_name, &cfg,
1279                                                 req, tsgl, hashstate);
1280                         if (err)
1281                                 return err;
1282                 }
1283         }
1284 #endif
1285         return 0;
1286 }
1287
1288 #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS
1289 /*
1290  * Generate a hash test vector from the given implementation.
1291  * Assumes the buffers in 'vec' were already allocated.
1292  */
1293 static void generate_random_hash_testvec(struct crypto_shash *tfm,
1294                                          struct hash_testvec *vec,
1295                                          unsigned int maxkeysize,
1296                                          unsigned int maxdatasize,
1297                                          char *name, size_t max_namelen)
1298 {
1299         SHASH_DESC_ON_STACK(desc, tfm);
1300
1301         /* Data */
1302         vec->psize = generate_random_length(maxdatasize);
1303         generate_random_bytes((u8 *)vec->plaintext, vec->psize);
1304
1305         /*
1306          * Key: length in range [1, maxkeysize], but usually choose maxkeysize.
1307          * If algorithm is unkeyed, then maxkeysize == 0 and set ksize = 0.
1308          */
1309         vec->setkey_error = 0;
1310         vec->ksize = 0;
1311         if (maxkeysize) {
1312                 vec->ksize = maxkeysize;
1313                 if (prandom_u32() % 4 == 0)
1314                         vec->ksize = 1 + (prandom_u32() % maxkeysize);
1315                 generate_random_bytes((u8 *)vec->key, vec->ksize);
1316
1317                 vec->setkey_error = crypto_shash_setkey(tfm, vec->key,
1318                                                         vec->ksize);
1319                 /* If the key couldn't be set, no need to continue to digest. */
1320                 if (vec->setkey_error)
1321                         goto done;
1322         }
1323
1324         /* Digest */
1325         desc->tfm = tfm;
1326         vec->digest_error = crypto_shash_digest(desc, vec->plaintext,
1327                                                 vec->psize, (u8 *)vec->digest);
1328 done:
1329         snprintf(name, max_namelen, "\"random: psize=%u ksize=%u\"",
1330                  vec->psize, vec->ksize);
1331 }
1332
1333 /*
1334  * Test the hash algorithm represented by @req against the corresponding generic
1335  * implementation, if one is available.
1336  */
1337 static int test_hash_vs_generic_impl(const char *driver,
1338                                      const char *generic_driver,
1339                                      unsigned int maxkeysize,
1340                                      struct ahash_request *req,
1341                                      struct test_sglist *tsgl,
1342                                      u8 *hashstate)
1343 {
1344         struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
1345         const unsigned int digestsize = crypto_ahash_digestsize(tfm);
1346         const unsigned int blocksize = crypto_ahash_blocksize(tfm);
1347         const unsigned int maxdatasize = (2 * PAGE_SIZE) - TESTMGR_POISON_LEN;
1348         const char *algname = crypto_hash_alg_common(tfm)->base.cra_name;
1349         char _generic_driver[CRYPTO_MAX_ALG_NAME];
1350         struct crypto_shash *generic_tfm = NULL;
1351         unsigned int i;
1352         struct hash_testvec vec = { 0 };
1353         char vec_name[64];
1354         struct testvec_config cfg;
1355         char cfgname[TESTVEC_CONFIG_NAMELEN];
1356         int err;
1357
1358         if (noextratests)
1359                 return 0;
1360
1361         if (!generic_driver) { /* Use default naming convention? */
1362                 err = build_generic_driver_name(algname, _generic_driver);
1363                 if (err)
1364                         return err;
1365                 generic_driver = _generic_driver;
1366         }
1367
1368         if (strcmp(generic_driver, driver) == 0) /* Already the generic impl? */
1369                 return 0;
1370
1371         generic_tfm = crypto_alloc_shash(generic_driver, 0, 0);
1372         if (IS_ERR(generic_tfm)) {
1373                 err = PTR_ERR(generic_tfm);
1374                 if (err == -ENOENT) {
1375                         pr_warn("alg: hash: skipping comparison tests for %s because %s is unavailable\n",
1376                                 driver, generic_driver);
1377                         return 0;
1378                 }
1379                 pr_err("alg: hash: error allocating %s (generic impl of %s): %d\n",
1380                        generic_driver, algname, err);
1381                 return err;
1382         }
1383
1384         /* Check the algorithm properties for consistency. */
1385
1386         if (digestsize != crypto_shash_digestsize(generic_tfm)) {
1387                 pr_err("alg: hash: digestsize for %s (%u) doesn't match generic impl (%u)\n",
1388                        driver, digestsize,
1389                        crypto_shash_digestsize(generic_tfm));
1390                 err = -EINVAL;
1391                 goto out;
1392         }
1393
1394         if (blocksize != crypto_shash_blocksize(generic_tfm)) {
1395                 pr_err("alg: hash: blocksize for %s (%u) doesn't match generic impl (%u)\n",
1396                        driver, blocksize, crypto_shash_blocksize(generic_tfm));
1397                 err = -EINVAL;
1398                 goto out;
1399         }
1400
1401         /*
1402          * Now generate test vectors using the generic implementation, and test
1403          * the other implementation against them.
1404          */
1405
1406         vec.key = kmalloc(maxkeysize, GFP_KERNEL);
1407         vec.plaintext = kmalloc(maxdatasize, GFP_KERNEL);
1408         vec.digest = kmalloc(digestsize, GFP_KERNEL);
1409         if (!vec.key || !vec.plaintext || !vec.digest) {
1410                 err = -ENOMEM;
1411                 goto out;
1412         }
1413
1414         for (i = 0; i < fuzz_iterations * 8; i++) {
1415                 generate_random_hash_testvec(generic_tfm, &vec,
1416                                              maxkeysize, maxdatasize,
1417                                              vec_name, sizeof(vec_name));
1418                 generate_random_testvec_config(&cfg, cfgname, sizeof(cfgname));
1419
1420                 err = test_hash_vec_cfg(driver, &vec, vec_name, &cfg,
1421                                         req, tsgl, hashstate);
1422                 if (err)
1423                         goto out;
1424                 cond_resched();
1425         }
1426         err = 0;
1427 out:
1428         kfree(vec.key);
1429         kfree(vec.plaintext);
1430         kfree(vec.digest);
1431         crypto_free_shash(generic_tfm);
1432         return err;
1433 }
1434 #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */
1435 static int test_hash_vs_generic_impl(const char *driver,
1436                                      const char *generic_driver,
1437                                      unsigned int maxkeysize,
1438                                      struct ahash_request *req,
1439                                      struct test_sglist *tsgl,
1440                                      u8 *hashstate)
1441 {
1442         return 0;
1443 }
1444 #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */
1445
1446 static int __alg_test_hash(const struct hash_testvec *vecs,
1447                            unsigned int num_vecs, const char *driver,
1448                            u32 type, u32 mask,
1449                            const char *generic_driver, unsigned int maxkeysize)
1450 {
1451         struct crypto_ahash *tfm;
1452         struct ahash_request *req = NULL;
1453         struct test_sglist *tsgl = NULL;
1454         u8 *hashstate = NULL;
1455         unsigned int i;
1456         int err;
1457
1458         tfm = crypto_alloc_ahash(driver, type, mask);
1459         if (IS_ERR(tfm)) {
1460                 pr_err("alg: hash: failed to allocate transform for %s: %ld\n",
1461                        driver, PTR_ERR(tfm));
1462                 return PTR_ERR(tfm);
1463         }
1464
1465         req = ahash_request_alloc(tfm, GFP_KERNEL);
1466         if (!req) {
1467                 pr_err("alg: hash: failed to allocate request for %s\n",
1468                        driver);
1469                 err = -ENOMEM;
1470                 goto out;
1471         }
1472
1473         tsgl = kmalloc(sizeof(*tsgl), GFP_KERNEL);
1474         if (!tsgl || init_test_sglist(tsgl) != 0) {
1475                 pr_err("alg: hash: failed to allocate test buffers for %s\n",
1476                        driver);
1477                 kfree(tsgl);
1478                 tsgl = NULL;
1479                 err = -ENOMEM;
1480                 goto out;
1481         }
1482
1483         hashstate = kmalloc(crypto_ahash_statesize(tfm) + TESTMGR_POISON_LEN,
1484                             GFP_KERNEL);
1485         if (!hashstate) {
1486                 pr_err("alg: hash: failed to allocate hash state buffer for %s\n",
1487                        driver);
1488                 err = -ENOMEM;
1489                 goto out;
1490         }
1491
1492         for (i = 0; i < num_vecs; i++) {
1493                 err = test_hash_vec(driver, &vecs[i], i, req, tsgl, hashstate);
1494                 if (err)
1495                         goto out;
1496         }
1497         err = test_hash_vs_generic_impl(driver, generic_driver, maxkeysize, req,
1498                                         tsgl, hashstate);
1499 out:
1500         kfree(hashstate);
1501         if (tsgl) {
1502                 destroy_test_sglist(tsgl);
1503                 kfree(tsgl);
1504         }
1505         ahash_request_free(req);
1506         crypto_free_ahash(tfm);
1507         return err;
1508 }
1509
1510 static int alg_test_hash(const struct alg_test_desc *desc, const char *driver,
1511                          u32 type, u32 mask)
1512 {
1513         const struct hash_testvec *template = desc->suite.hash.vecs;
1514         unsigned int tcount = desc->suite.hash.count;
1515         unsigned int nr_unkeyed, nr_keyed;
1516         unsigned int maxkeysize = 0;
1517         int err;
1518
1519         /*
1520          * For OPTIONAL_KEY algorithms, we have to do all the unkeyed tests
1521          * first, before setting a key on the tfm.  To make this easier, we
1522          * require that the unkeyed test vectors (if any) are listed first.
1523          */
1524
1525         for (nr_unkeyed = 0; nr_unkeyed < tcount; nr_unkeyed++) {
1526                 if (template[nr_unkeyed].ksize)
1527                         break;
1528         }
1529         for (nr_keyed = 0; nr_unkeyed + nr_keyed < tcount; nr_keyed++) {
1530                 if (!template[nr_unkeyed + nr_keyed].ksize) {
1531                         pr_err("alg: hash: test vectors for %s out of order, "
1532                                "unkeyed ones must come first\n", desc->alg);
1533                         return -EINVAL;
1534                 }
1535                 maxkeysize = max_t(unsigned int, maxkeysize,
1536                                    template[nr_unkeyed + nr_keyed].ksize);
1537         }
1538
1539         err = 0;
1540         if (nr_unkeyed) {
1541                 err = __alg_test_hash(template, nr_unkeyed, driver, type, mask,
1542                                       desc->generic_driver, maxkeysize);
1543                 template += nr_unkeyed;
1544         }
1545
1546         if (!err && nr_keyed)
1547                 err = __alg_test_hash(template, nr_keyed, driver, type, mask,
1548                                       desc->generic_driver, maxkeysize);
1549
1550         return err;
1551 }
1552
1553 static int test_aead_vec_cfg(const char *driver, int enc,
1554                              const struct aead_testvec *vec,
1555                              const char *vec_name,
1556                              const struct testvec_config *cfg,
1557                              struct aead_request *req,
1558                              struct cipher_test_sglists *tsgls)
1559 {
1560         struct crypto_aead *tfm = crypto_aead_reqtfm(req);
1561         const unsigned int alignmask = crypto_aead_alignmask(tfm);
1562         const unsigned int ivsize = crypto_aead_ivsize(tfm);
1563         const unsigned int authsize = vec->clen - vec->plen;
1564         const u32 req_flags = CRYPTO_TFM_REQ_MAY_BACKLOG | cfg->req_flags;
1565         const char *op = enc ? "encryption" : "decryption";
1566         DECLARE_CRYPTO_WAIT(wait);
1567         u8 _iv[3 * (MAX_ALGAPI_ALIGNMASK + 1) + MAX_IVLEN];
1568         u8 *iv = PTR_ALIGN(&_iv[0], 2 * (MAX_ALGAPI_ALIGNMASK + 1)) +
1569                  cfg->iv_offset +
1570                  (cfg->iv_offset_relative_to_alignmask ? alignmask : 0);
1571         struct kvec input[2];
1572         int expected_error;
1573         int err;
1574
1575         /* Set the key */
1576         if (vec->wk)
1577                 crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS);
1578         else
1579                 crypto_aead_clear_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS);
1580         err = crypto_aead_setkey(tfm, vec->key, vec->klen);
1581         if (err && err != vec->setkey_error) {
1582                 pr_err("alg: aead: %s setkey failed on test vector %s; expected_error=%d, actual_error=%d, flags=%#x\n",
1583                        driver, vec_name, vec->setkey_error, err,
1584                        crypto_aead_get_flags(tfm));
1585                 return err;
1586         }
1587         if (!err && vec->setkey_error) {
1588                 pr_err("alg: aead: %s setkey unexpectedly succeeded on test vector %s; expected_error=%d\n",
1589                        driver, vec_name, vec->setkey_error);
1590                 return -EINVAL;
1591         }
1592
1593         /* Set the authentication tag size */
1594         err = crypto_aead_setauthsize(tfm, authsize);
1595         if (err && err != vec->setauthsize_error) {
1596                 pr_err("alg: aead: %s setauthsize failed on test vector %s; expected_error=%d, actual_error=%d\n",
1597                        driver, vec_name, vec->setauthsize_error, err);
1598                 return err;
1599         }
1600         if (!err && vec->setauthsize_error) {
1601                 pr_err("alg: aead: %s setauthsize unexpectedly succeeded on test vector %s; expected_error=%d\n",
1602                        driver, vec_name, vec->setauthsize_error);
1603                 return -EINVAL;
1604         }
1605
1606         if (vec->setkey_error || vec->setauthsize_error)
1607                 return 0;
1608
1609         /* The IV must be copied to a buffer, as the algorithm may modify it */
1610         if (WARN_ON(ivsize > MAX_IVLEN))
1611                 return -EINVAL;
1612         if (vec->iv)
1613                 memcpy(iv, vec->iv, ivsize);
1614         else
1615                 memset(iv, 0, ivsize);
1616
1617         /* Build the src/dst scatterlists */
1618         input[0].iov_base = (void *)vec->assoc;
1619         input[0].iov_len = vec->alen;
1620         input[1].iov_base = enc ? (void *)vec->ptext : (void *)vec->ctext;
1621         input[1].iov_len = enc ? vec->plen : vec->clen;
1622         err = build_cipher_test_sglists(tsgls, cfg, alignmask,
1623                                         vec->alen + (enc ? vec->plen :
1624                                                      vec->clen),
1625                                         vec->alen + (enc ? vec->clen :
1626                                                      vec->plen),
1627                                         input, 2);
1628         if (err) {
1629                 pr_err("alg: aead: %s %s: error preparing scatterlists for test vector %s, cfg=\"%s\"\n",
1630                        driver, op, vec_name, cfg->name);
1631                 return err;
1632         }
1633
1634         /* Do the actual encryption or decryption */
1635         testmgr_poison(req->__ctx, crypto_aead_reqsize(tfm));
1636         aead_request_set_callback(req, req_flags, crypto_req_done, &wait);
1637         aead_request_set_crypt(req, tsgls->src.sgl_ptr, tsgls->dst.sgl_ptr,
1638                                enc ? vec->plen : vec->clen, iv);
1639         aead_request_set_ad(req, vec->alen);
1640         if (cfg->nosimd)
1641                 crypto_disable_simd_for_test();
1642         err = enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req);
1643         if (cfg->nosimd)
1644                 crypto_reenable_simd_for_test();
1645         err = crypto_wait_req(err, &wait);
1646
1647         /* Check that the algorithm didn't overwrite things it shouldn't have */
1648         if (req->cryptlen != (enc ? vec->plen : vec->clen) ||
1649             req->assoclen != vec->alen ||
1650             req->iv != iv ||
1651             req->src != tsgls->src.sgl_ptr ||
1652             req->dst != tsgls->dst.sgl_ptr ||
1653             crypto_aead_reqtfm(req) != tfm ||
1654             req->base.complete != crypto_req_done ||
1655             req->base.flags != req_flags ||
1656             req->base.data != &wait) {
1657                 pr_err("alg: aead: %s %s corrupted request struct on test vector %s, cfg=\"%s\"\n",
1658                        driver, op, vec_name, cfg->name);
1659                 if (req->cryptlen != (enc ? vec->plen : vec->clen))
1660                         pr_err("alg: aead: changed 'req->cryptlen'\n");
1661                 if (req->assoclen != vec->alen)
1662                         pr_err("alg: aead: changed 'req->assoclen'\n");
1663                 if (req->iv != iv)
1664                         pr_err("alg: aead: changed 'req->iv'\n");
1665                 if (req->src != tsgls->src.sgl_ptr)
1666                         pr_err("alg: aead: changed 'req->src'\n");
1667                 if (req->dst != tsgls->dst.sgl_ptr)
1668                         pr_err("alg: aead: changed 'req->dst'\n");
1669                 if (crypto_aead_reqtfm(req) != tfm)
1670                         pr_err("alg: aead: changed 'req->base.tfm'\n");
1671                 if (req->base.complete != crypto_req_done)
1672                         pr_err("alg: aead: changed 'req->base.complete'\n");
1673                 if (req->base.flags != req_flags)
1674                         pr_err("alg: aead: changed 'req->base.flags'\n");
1675                 if (req->base.data != &wait)
1676                         pr_err("alg: aead: changed 'req->base.data'\n");
1677                 return -EINVAL;
1678         }
1679         if (is_test_sglist_corrupted(&tsgls->src)) {
1680                 pr_err("alg: aead: %s %s corrupted src sgl on test vector %s, cfg=\"%s\"\n",
1681                        driver, op, vec_name, cfg->name);
1682                 return -EINVAL;
1683         }
1684         if (tsgls->dst.sgl_ptr != tsgls->src.sgl &&
1685             is_test_sglist_corrupted(&tsgls->dst)) {
1686                 pr_err("alg: aead: %s %s corrupted dst sgl on test vector %s, cfg=\"%s\"\n",
1687                        driver, op, vec_name, cfg->name);
1688                 return -EINVAL;
1689         }
1690
1691         /* Check for success or failure */
1692         expected_error = vec->novrfy ? -EBADMSG : vec->crypt_error;
1693         if (err) {
1694                 if (err == expected_error)
1695                         return 0;
1696                 pr_err("alg: aead: %s %s failed on test vector %s; expected_error=%d, actual_error=%d, cfg=\"%s\"\n",
1697                        driver, op, vec_name, expected_error, err, cfg->name);
1698                 return err;
1699         }
1700         if (expected_error) {
1701                 pr_err("alg: aead: %s %s unexpectedly succeeded on test vector %s; expected_error=%d, cfg=\"%s\"\n",
1702                        driver, op, vec_name, expected_error, cfg->name);
1703                 return -EINVAL;
1704         }
1705
1706         /* Check for the correct output (ciphertext or plaintext) */
1707         err = verify_correct_output(&tsgls->dst, enc ? vec->ctext : vec->ptext,
1708                                     enc ? vec->clen : vec->plen,
1709                                     vec->alen, enc || !cfg->inplace);
1710         if (err == -EOVERFLOW) {
1711                 pr_err("alg: aead: %s %s overran dst buffer on test vector %s, cfg=\"%s\"\n",
1712                        driver, op, vec_name, cfg->name);
1713                 return err;
1714         }
1715         if (err) {
1716                 pr_err("alg: aead: %s %s test failed (wrong result) on test vector %s, cfg=\"%s\"\n",
1717                        driver, op, vec_name, cfg->name);
1718                 return err;
1719         }
1720
1721         return 0;
1722 }
1723
1724 static int test_aead_vec(const char *driver, int enc,
1725                          const struct aead_testvec *vec, unsigned int vec_num,
1726                          struct aead_request *req,
1727                          struct cipher_test_sglists *tsgls)
1728 {
1729         char vec_name[16];
1730         unsigned int i;
1731         int err;
1732
1733         if (enc && vec->novrfy)
1734                 return 0;
1735
1736         sprintf(vec_name, "%u", vec_num);
1737
1738         for (i = 0; i < ARRAY_SIZE(default_cipher_testvec_configs); i++) {
1739                 err = test_aead_vec_cfg(driver, enc, vec, vec_name,
1740                                         &default_cipher_testvec_configs[i],
1741                                         req, tsgls);
1742                 if (err)
1743                         return err;
1744         }
1745
1746 #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS
1747         if (!noextratests) {
1748                 struct testvec_config cfg;
1749                 char cfgname[TESTVEC_CONFIG_NAMELEN];
1750
1751                 for (i = 0; i < fuzz_iterations; i++) {
1752                         generate_random_testvec_config(&cfg, cfgname,
1753                                                        sizeof(cfgname));
1754                         err = test_aead_vec_cfg(driver, enc, vec, vec_name,
1755                                                 &cfg, req, tsgls);
1756                         if (err)
1757                                 return err;
1758                 }
1759         }
1760 #endif
1761         return 0;
1762 }
1763
1764 #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS
1765 /*
1766  * Generate an AEAD test vector from the given implementation.
1767  * Assumes the buffers in 'vec' were already allocated.
1768  */
1769 static void generate_random_aead_testvec(struct aead_request *req,
1770                                          struct aead_testvec *vec,
1771                                          unsigned int maxkeysize,
1772                                          unsigned int maxdatasize,
1773                                          char *name, size_t max_namelen)
1774 {
1775         struct crypto_aead *tfm = crypto_aead_reqtfm(req);
1776         const unsigned int ivsize = crypto_aead_ivsize(tfm);
1777         unsigned int maxauthsize = crypto_aead_alg(tfm)->maxauthsize;
1778         unsigned int authsize;
1779         unsigned int total_len;
1780         int i;
1781         struct scatterlist src[2], dst;
1782         u8 iv[MAX_IVLEN];
1783         DECLARE_CRYPTO_WAIT(wait);
1784
1785         /* Key: length in [0, maxkeysize], but usually choose maxkeysize */
1786         vec->klen = maxkeysize;
1787         if (prandom_u32() % 4 == 0)
1788                 vec->klen = prandom_u32() % (maxkeysize + 1);
1789         generate_random_bytes((u8 *)vec->key, vec->klen);
1790         vec->setkey_error = crypto_aead_setkey(tfm, vec->key, vec->klen);
1791
1792         /* IV */
1793         generate_random_bytes((u8 *)vec->iv, ivsize);
1794
1795         /* Tag length: in [0, maxauthsize], but usually choose maxauthsize */
1796         authsize = maxauthsize;
1797         if (prandom_u32() % 4 == 0)
1798                 authsize = prandom_u32() % (maxauthsize + 1);
1799         if (WARN_ON(authsize > maxdatasize))
1800                 authsize = maxdatasize;
1801         maxdatasize -= authsize;
1802         vec->setauthsize_error = crypto_aead_setauthsize(tfm, authsize);
1803
1804         /* Plaintext and associated data */
1805         total_len = generate_random_length(maxdatasize);
1806         if (prandom_u32() % 4 == 0)
1807                 vec->alen = 0;
1808         else
1809                 vec->alen = generate_random_length(total_len);
1810         vec->plen = total_len - vec->alen;
1811         generate_random_bytes((u8 *)vec->assoc, vec->alen);
1812         generate_random_bytes((u8 *)vec->ptext, vec->plen);
1813
1814         vec->clen = vec->plen + authsize;
1815
1816         /*
1817          * If the key or authentication tag size couldn't be set, no need to
1818          * continue to encrypt.
1819          */
1820         if (vec->setkey_error || vec->setauthsize_error)
1821                 goto done;
1822
1823         /* Ciphertext */
1824         sg_init_table(src, 2);
1825         i = 0;
1826         if (vec->alen)
1827                 sg_set_buf(&src[i++], vec->assoc, vec->alen);
1828         if (vec->plen)
1829                 sg_set_buf(&src[i++], vec->ptext, vec->plen);
1830         sg_init_one(&dst, vec->ctext, vec->alen + vec->clen);
1831         memcpy(iv, vec->iv, ivsize);
1832         aead_request_set_callback(req, 0, crypto_req_done, &wait);
1833         aead_request_set_crypt(req, src, &dst, vec->plen, iv);
1834         aead_request_set_ad(req, vec->alen);
1835         vec->crypt_error = crypto_wait_req(crypto_aead_encrypt(req), &wait);
1836         if (vec->crypt_error == 0)
1837                 memmove((u8 *)vec->ctext, vec->ctext + vec->alen, vec->clen);
1838 done:
1839         snprintf(name, max_namelen,
1840                  "\"random: alen=%u plen=%u authsize=%u klen=%u\"",
1841                  vec->alen, vec->plen, authsize, vec->klen);
1842 }
1843
1844 /*
1845  * Test the AEAD algorithm represented by @req against the corresponding generic
1846  * implementation, if one is available.
1847  */
1848 static int test_aead_vs_generic_impl(const char *driver,
1849                                      const struct alg_test_desc *test_desc,
1850                                      struct aead_request *req,
1851                                      struct cipher_test_sglists *tsgls)
1852 {
1853         struct crypto_aead *tfm = crypto_aead_reqtfm(req);
1854         const unsigned int ivsize = crypto_aead_ivsize(tfm);
1855         const unsigned int maxauthsize = crypto_aead_alg(tfm)->maxauthsize;
1856         const unsigned int blocksize = crypto_aead_blocksize(tfm);
1857         const unsigned int maxdatasize = (2 * PAGE_SIZE) - TESTMGR_POISON_LEN;
1858         const char *algname = crypto_aead_alg(tfm)->base.cra_name;
1859         const char *generic_driver = test_desc->generic_driver;
1860         char _generic_driver[CRYPTO_MAX_ALG_NAME];
1861         struct crypto_aead *generic_tfm = NULL;
1862         struct aead_request *generic_req = NULL;
1863         unsigned int maxkeysize;
1864         unsigned int i;
1865         struct aead_testvec vec = { 0 };
1866         char vec_name[64];
1867         struct testvec_config cfg;
1868         char cfgname[TESTVEC_CONFIG_NAMELEN];
1869         int err;
1870
1871         if (noextratests)
1872                 return 0;
1873
1874         if (!generic_driver) { /* Use default naming convention? */
1875                 err = build_generic_driver_name(algname, _generic_driver);
1876                 if (err)
1877                         return err;
1878                 generic_driver = _generic_driver;
1879         }
1880
1881         if (strcmp(generic_driver, driver) == 0) /* Already the generic impl? */
1882                 return 0;
1883
1884         generic_tfm = crypto_alloc_aead(generic_driver, 0, 0);
1885         if (IS_ERR(generic_tfm)) {
1886                 err = PTR_ERR(generic_tfm);
1887                 if (err == -ENOENT) {
1888                         pr_warn("alg: aead: skipping comparison tests for %s because %s is unavailable\n",
1889                                 driver, generic_driver);
1890                         return 0;
1891                 }
1892                 pr_err("alg: aead: error allocating %s (generic impl of %s): %d\n",
1893                        generic_driver, algname, err);
1894                 return err;
1895         }
1896
1897         generic_req = aead_request_alloc(generic_tfm, GFP_KERNEL);
1898         if (!generic_req) {
1899                 err = -ENOMEM;
1900                 goto out;
1901         }
1902
1903         /* Check the algorithm properties for consistency. */
1904
1905         if (maxauthsize != crypto_aead_alg(generic_tfm)->maxauthsize) {
1906                 pr_err("alg: aead: maxauthsize for %s (%u) doesn't match generic impl (%u)\n",
1907                        driver, maxauthsize,
1908                        crypto_aead_alg(generic_tfm)->maxauthsize);
1909                 err = -EINVAL;
1910                 goto out;
1911         }
1912
1913         if (ivsize != crypto_aead_ivsize(generic_tfm)) {
1914                 pr_err("alg: aead: ivsize for %s (%u) doesn't match generic impl (%u)\n",
1915                        driver, ivsize, crypto_aead_ivsize(generic_tfm));
1916                 err = -EINVAL;
1917                 goto out;
1918         }
1919
1920         if (blocksize != crypto_aead_blocksize(generic_tfm)) {
1921                 pr_err("alg: aead: blocksize for %s (%u) doesn't match generic impl (%u)\n",
1922                        driver, blocksize, crypto_aead_blocksize(generic_tfm));
1923                 err = -EINVAL;
1924                 goto out;
1925         }
1926
1927         /*
1928          * Now generate test vectors using the generic implementation, and test
1929          * the other implementation against them.
1930          */
1931
1932         maxkeysize = 0;
1933         for (i = 0; i < test_desc->suite.aead.count; i++)
1934                 maxkeysize = max_t(unsigned int, maxkeysize,
1935                                    test_desc->suite.aead.vecs[i].klen);
1936
1937         vec.key = kmalloc(maxkeysize, GFP_KERNEL);
1938         vec.iv = kmalloc(ivsize, GFP_KERNEL);
1939         vec.assoc = kmalloc(maxdatasize, GFP_KERNEL);
1940         vec.ptext = kmalloc(maxdatasize, GFP_KERNEL);
1941         vec.ctext = kmalloc(maxdatasize, GFP_KERNEL);
1942         if (!vec.key || !vec.iv || !vec.assoc || !vec.ptext || !vec.ctext) {
1943                 err = -ENOMEM;
1944                 goto out;
1945         }
1946
1947         for (i = 0; i < fuzz_iterations * 8; i++) {
1948                 generate_random_aead_testvec(generic_req, &vec,
1949                                              maxkeysize, maxdatasize,
1950                                              vec_name, sizeof(vec_name));
1951                 generate_random_testvec_config(&cfg, cfgname, sizeof(cfgname));
1952
1953                 err = test_aead_vec_cfg(driver, ENCRYPT, &vec, vec_name, &cfg,
1954                                         req, tsgls);
1955                 if (err)
1956                         goto out;
1957                 err = test_aead_vec_cfg(driver, DECRYPT, &vec, vec_name, &cfg,
1958                                         req, tsgls);
1959                 if (err)
1960                         goto out;
1961                 cond_resched();
1962         }
1963         err = 0;
1964 out:
1965         kfree(vec.key);
1966         kfree(vec.iv);
1967         kfree(vec.assoc);
1968         kfree(vec.ptext);
1969         kfree(vec.ctext);
1970         crypto_free_aead(generic_tfm);
1971         aead_request_free(generic_req);
1972         return err;
1973 }
1974 #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */
1975 static int test_aead_vs_generic_impl(const char *driver,
1976                                      const struct alg_test_desc *test_desc,
1977                                      struct aead_request *req,
1978                                      struct cipher_test_sglists *tsgls)
1979 {
1980         return 0;
1981 }
1982 #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */
1983
1984 static int test_aead(const char *driver, int enc,
1985                      const struct aead_test_suite *suite,
1986                      struct aead_request *req,
1987                      struct cipher_test_sglists *tsgls)
1988 {
1989         unsigned int i;
1990         int err;
1991
1992         for (i = 0; i < suite->count; i++) {
1993                 err = test_aead_vec(driver, enc, &suite->vecs[i], i, req,
1994                                     tsgls);
1995                 if (err)
1996                         return err;
1997         }
1998         return 0;
1999 }
2000
2001 static int alg_test_aead(const struct alg_test_desc *desc, const char *driver,
2002                          u32 type, u32 mask)
2003 {
2004         const struct aead_test_suite *suite = &desc->suite.aead;
2005         struct crypto_aead *tfm;
2006         struct aead_request *req = NULL;
2007         struct cipher_test_sglists *tsgls = NULL;
2008         int err;
2009
2010         if (suite->count <= 0) {
2011                 pr_err("alg: aead: empty test suite for %s\n", driver);
2012                 return -EINVAL;
2013         }
2014
2015         tfm = crypto_alloc_aead(driver, type, mask);
2016         if (IS_ERR(tfm)) {
2017                 pr_err("alg: aead: failed to allocate transform for %s: %ld\n",
2018                        driver, PTR_ERR(tfm));
2019                 return PTR_ERR(tfm);
2020         }
2021
2022         req = aead_request_alloc(tfm, GFP_KERNEL);
2023         if (!req) {
2024                 pr_err("alg: aead: failed to allocate request for %s\n",
2025                        driver);
2026                 err = -ENOMEM;
2027                 goto out;
2028         }
2029
2030         tsgls = alloc_cipher_test_sglists();
2031         if (!tsgls) {
2032                 pr_err("alg: aead: failed to allocate test buffers for %s\n",
2033                        driver);
2034                 err = -ENOMEM;
2035                 goto out;
2036         }
2037
2038         err = test_aead(driver, ENCRYPT, suite, req, tsgls);
2039         if (err)
2040                 goto out;
2041
2042         err = test_aead(driver, DECRYPT, suite, req, tsgls);
2043         if (err)
2044                 goto out;
2045
2046         err = test_aead_vs_generic_impl(driver, desc, req, tsgls);
2047 out:
2048         free_cipher_test_sglists(tsgls);
2049         aead_request_free(req);
2050         crypto_free_aead(tfm);
2051         return err;
2052 }
2053
2054 static int test_cipher(struct crypto_cipher *tfm, int enc,
2055                        const struct cipher_testvec *template,
2056                        unsigned int tcount)
2057 {
2058         const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm));
2059         unsigned int i, j, k;
2060         char *q;
2061         const char *e;
2062         const char *input, *result;
2063         void *data;
2064         char *xbuf[XBUFSIZE];
2065         int ret = -ENOMEM;
2066
2067         if (testmgr_alloc_buf(xbuf))
2068                 goto out_nobuf;
2069
2070         if (enc == ENCRYPT)
2071                 e = "encryption";
2072         else
2073                 e = "decryption";
2074
2075         j = 0;
2076         for (i = 0; i < tcount; i++) {
2077
2078                 if (fips_enabled && template[i].fips_skip)
2079                         continue;
2080
2081                 input  = enc ? template[i].ptext : template[i].ctext;
2082                 result = enc ? template[i].ctext : template[i].ptext;
2083                 j++;
2084
2085                 ret = -EINVAL;
2086                 if (WARN_ON(template[i].len > PAGE_SIZE))
2087                         goto out;
2088
2089                 data = xbuf[0];
2090                 memcpy(data, input, template[i].len);
2091
2092                 crypto_cipher_clear_flags(tfm, ~0);
2093                 if (template[i].wk)
2094                         crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS);
2095
2096                 ret = crypto_cipher_setkey(tfm, template[i].key,
2097                                            template[i].klen);
2098                 if (ret) {
2099                         if (ret == template[i].setkey_error)
2100                                 continue;
2101                         pr_err("alg: cipher: %s setkey failed on test vector %u; expected_error=%d, actual_error=%d, flags=%#x\n",
2102                                algo, j, template[i].setkey_error, ret,
2103                                crypto_cipher_get_flags(tfm));
2104                         goto out;
2105                 }
2106                 if (template[i].setkey_error) {
2107                         pr_err("alg: cipher: %s setkey unexpectedly succeeded on test vector %u; expected_error=%d\n",
2108                                algo, j, template[i].setkey_error);
2109                         ret = -EINVAL;
2110                         goto out;
2111                 }
2112
2113                 for (k = 0; k < template[i].len;
2114                      k += crypto_cipher_blocksize(tfm)) {
2115                         if (enc)
2116                                 crypto_cipher_encrypt_one(tfm, data + k,
2117                                                           data + k);
2118                         else
2119                                 crypto_cipher_decrypt_one(tfm, data + k,
2120                                                           data + k);
2121                 }
2122
2123                 q = data;
2124                 if (memcmp(q, result, template[i].len)) {
2125                         printk(KERN_ERR "alg: cipher: Test %d failed "
2126                                "on %s for %s\n", j, e, algo);
2127                         hexdump(q, template[i].len);
2128                         ret = -EINVAL;
2129                         goto out;
2130                 }
2131         }
2132
2133         ret = 0;
2134
2135 out:
2136         testmgr_free_buf(xbuf);
2137 out_nobuf:
2138         return ret;
2139 }
2140
2141 static int test_skcipher_vec_cfg(const char *driver, int enc,
2142                                  const struct cipher_testvec *vec,
2143                                  const char *vec_name,
2144                                  const struct testvec_config *cfg,
2145                                  struct skcipher_request *req,
2146                                  struct cipher_test_sglists *tsgls)
2147 {
2148         struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
2149         const unsigned int alignmask = crypto_skcipher_alignmask(tfm);
2150         const unsigned int ivsize = crypto_skcipher_ivsize(tfm);
2151         const u32 req_flags = CRYPTO_TFM_REQ_MAY_BACKLOG | cfg->req_flags;
2152         const char *op = enc ? "encryption" : "decryption";
2153         DECLARE_CRYPTO_WAIT(wait);
2154         u8 _iv[3 * (MAX_ALGAPI_ALIGNMASK + 1) + MAX_IVLEN];
2155         u8 *iv = PTR_ALIGN(&_iv[0], 2 * (MAX_ALGAPI_ALIGNMASK + 1)) +
2156                  cfg->iv_offset +
2157                  (cfg->iv_offset_relative_to_alignmask ? alignmask : 0);
2158         struct kvec input;
2159         int err;
2160
2161         /* Set the key */
2162         if (vec->wk)
2163                 crypto_skcipher_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS);
2164         else
2165                 crypto_skcipher_clear_flags(tfm,
2166                                             CRYPTO_TFM_REQ_FORBID_WEAK_KEYS);
2167         err = crypto_skcipher_setkey(tfm, vec->key, vec->klen);
2168         if (err) {
2169                 if (err == vec->setkey_error)
2170                         return 0;
2171                 pr_err("alg: skcipher: %s setkey failed on test vector %s; expected_error=%d, actual_error=%d, flags=%#x\n",
2172                        driver, vec_name, vec->setkey_error, err,
2173                        crypto_skcipher_get_flags(tfm));
2174                 return err;
2175         }
2176         if (vec->setkey_error) {
2177                 pr_err("alg: skcipher: %s setkey unexpectedly succeeded on test vector %s; expected_error=%d\n",
2178                        driver, vec_name, vec->setkey_error);
2179                 return -EINVAL;
2180         }
2181
2182         /* The IV must be copied to a buffer, as the algorithm may modify it */
2183         if (ivsize) {
2184                 if (WARN_ON(ivsize > MAX_IVLEN))
2185                         return -EINVAL;
2186                 if (vec->generates_iv && !enc)
2187                         memcpy(iv, vec->iv_out, ivsize);
2188                 else if (vec->iv)
2189                         memcpy(iv, vec->iv, ivsize);
2190                 else
2191                         memset(iv, 0, ivsize);
2192         } else {
2193                 if (vec->generates_iv) {
2194                         pr_err("alg: skcipher: %s has ivsize=0 but test vector %s generates IV!\n",
2195                                driver, vec_name);
2196                         return -EINVAL;
2197                 }
2198                 iv = NULL;
2199         }
2200
2201         /* Build the src/dst scatterlists */
2202         input.iov_base = enc ? (void *)vec->ptext : (void *)vec->ctext;
2203         input.iov_len = vec->len;
2204         err = build_cipher_test_sglists(tsgls, cfg, alignmask,
2205                                         vec->len, vec->len, &input, 1);
2206         if (err) {
2207                 pr_err("alg: skcipher: %s %s: error preparing scatterlists for test vector %s, cfg=\"%s\"\n",
2208                        driver, op, vec_name, cfg->name);
2209                 return err;
2210         }
2211
2212         /* Do the actual encryption or decryption */
2213         testmgr_poison(req->__ctx, crypto_skcipher_reqsize(tfm));
2214         skcipher_request_set_callback(req, req_flags, crypto_req_done, &wait);
2215         skcipher_request_set_crypt(req, tsgls->src.sgl_ptr, tsgls->dst.sgl_ptr,
2216                                    vec->len, iv);
2217         if (cfg->nosimd)
2218                 crypto_disable_simd_for_test();
2219         err = enc ? crypto_skcipher_encrypt(req) : crypto_skcipher_decrypt(req);
2220         if (cfg->nosimd)
2221                 crypto_reenable_simd_for_test();
2222         err = crypto_wait_req(err, &wait);
2223
2224         /* Check that the algorithm didn't overwrite things it shouldn't have */
2225         if (req->cryptlen != vec->len ||
2226             req->iv != iv ||
2227             req->src != tsgls->src.sgl_ptr ||
2228             req->dst != tsgls->dst.sgl_ptr ||
2229             crypto_skcipher_reqtfm(req) != tfm ||
2230             req->base.complete != crypto_req_done ||
2231             req->base.flags != req_flags ||
2232             req->base.data != &wait) {
2233                 pr_err("alg: skcipher: %s %s corrupted request struct on test vector %s, cfg=\"%s\"\n",
2234                        driver, op, vec_name, cfg->name);
2235                 if (req->cryptlen != vec->len)
2236                         pr_err("alg: skcipher: changed 'req->cryptlen'\n");
2237                 if (req->iv != iv)
2238                         pr_err("alg: skcipher: changed 'req->iv'\n");
2239                 if (req->src != tsgls->src.sgl_ptr)
2240                         pr_err("alg: skcipher: changed 'req->src'\n");
2241                 if (req->dst != tsgls->dst.sgl_ptr)
2242                         pr_err("alg: skcipher: changed 'req->dst'\n");
2243                 if (crypto_skcipher_reqtfm(req) != tfm)
2244                         pr_err("alg: skcipher: changed 'req->base.tfm'\n");
2245                 if (req->base.complete != crypto_req_done)
2246                         pr_err("alg: skcipher: changed 'req->base.complete'\n");
2247                 if (req->base.flags != req_flags)
2248                         pr_err("alg: skcipher: changed 'req->base.flags'\n");
2249                 if (req->base.data != &wait)
2250                         pr_err("alg: skcipher: changed 'req->base.data'\n");
2251                 return -EINVAL;
2252         }
2253         if (is_test_sglist_corrupted(&tsgls->src)) {
2254                 pr_err("alg: skcipher: %s %s corrupted src sgl on test vector %s, cfg=\"%s\"\n",
2255                        driver, op, vec_name, cfg->name);
2256                 return -EINVAL;
2257         }
2258         if (tsgls->dst.sgl_ptr != tsgls->src.sgl &&
2259             is_test_sglist_corrupted(&tsgls->dst)) {
2260                 pr_err("alg: skcipher: %s %s corrupted dst sgl on test vector %s, cfg=\"%s\"\n",
2261                        driver, op, vec_name, cfg->name);
2262                 return -EINVAL;
2263         }
2264
2265         /* Check for success or failure */
2266         if (err) {
2267                 if (err == vec->crypt_error)
2268                         return 0;
2269                 pr_err("alg: skcipher: %s %s failed on test vector %s; expected_error=%d, actual_error=%d, cfg=\"%s\"\n",
2270                        driver, op, vec_name, vec->crypt_error, err, cfg->name);
2271                 return err;
2272         }
2273         if (vec->crypt_error) {
2274                 pr_err("alg: skcipher: %s %s unexpectedly succeeded on test vector %s; expected_error=%d, cfg=\"%s\"\n",
2275                        driver, op, vec_name, vec->crypt_error, cfg->name);
2276                 return -EINVAL;
2277         }
2278
2279         /* Check for the correct output (ciphertext or plaintext) */
2280         err = verify_correct_output(&tsgls->dst, enc ? vec->ctext : vec->ptext,
2281                                     vec->len, 0, true);
2282         if (err == -EOVERFLOW) {
2283                 pr_err("alg: skcipher: %s %s overran dst buffer on test vector %s, cfg=\"%s\"\n",
2284                        driver, op, vec_name, cfg->name);
2285                 return err;
2286         }
2287         if (err) {
2288                 pr_err("alg: skcipher: %s %s test failed (wrong result) on test vector %s, cfg=\"%s\"\n",
2289                        driver, op, vec_name, cfg->name);
2290                 return err;
2291         }
2292
2293         /* If applicable, check that the algorithm generated the correct IV */
2294         if (vec->iv_out && memcmp(iv, vec->iv_out, ivsize) != 0) {
2295                 pr_err("alg: skcipher: %s %s test failed (wrong output IV) on test vector %s, cfg=\"%s\"\n",
2296                        driver, op, vec_name, cfg->name);
2297                 hexdump(iv, ivsize);
2298                 return -EINVAL;
2299         }
2300
2301         return 0;
2302 }
2303
2304 static int test_skcipher_vec(const char *driver, int enc,
2305                              const struct cipher_testvec *vec,
2306                              unsigned int vec_num,
2307                              struct skcipher_request *req,
2308                              struct cipher_test_sglists *tsgls)
2309 {
2310         char vec_name[16];
2311         unsigned int i;
2312         int err;
2313
2314         if (fips_enabled && vec->fips_skip)
2315                 return 0;
2316
2317         sprintf(vec_name, "%u", vec_num);
2318
2319         for (i = 0; i < ARRAY_SIZE(default_cipher_testvec_configs); i++) {
2320                 err = test_skcipher_vec_cfg(driver, enc, vec, vec_name,
2321                                             &default_cipher_testvec_configs[i],
2322                                             req, tsgls);
2323                 if (err)
2324                         return err;
2325         }
2326
2327 #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS
2328         if (!noextratests) {
2329                 struct testvec_config cfg;
2330                 char cfgname[TESTVEC_CONFIG_NAMELEN];
2331
2332                 for (i = 0; i < fuzz_iterations; i++) {
2333                         generate_random_testvec_config(&cfg, cfgname,
2334                                                        sizeof(cfgname));
2335                         err = test_skcipher_vec_cfg(driver, enc, vec, vec_name,
2336                                                     &cfg, req, tsgls);
2337                         if (err)
2338                                 return err;
2339                 }
2340         }
2341 #endif
2342         return 0;
2343 }
2344
2345 #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS
2346 /*
2347  * Generate a symmetric cipher test vector from the given implementation.
2348  * Assumes the buffers in 'vec' were already allocated.
2349  */
2350 static void generate_random_cipher_testvec(struct skcipher_request *req,
2351                                            struct cipher_testvec *vec,
2352                                            unsigned int maxdatasize,
2353                                            char *name, size_t max_namelen)
2354 {
2355         struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
2356         const unsigned int maxkeysize = tfm->keysize;
2357         const unsigned int ivsize = crypto_skcipher_ivsize(tfm);
2358         struct scatterlist src, dst;
2359         u8 iv[MAX_IVLEN];
2360         DECLARE_CRYPTO_WAIT(wait);
2361
2362         /* Key: length in [0, maxkeysize], but usually choose maxkeysize */
2363         vec->klen = maxkeysize;
2364         if (prandom_u32() % 4 == 0)
2365                 vec->klen = prandom_u32() % (maxkeysize + 1);
2366         generate_random_bytes((u8 *)vec->key, vec->klen);
2367         vec->setkey_error = crypto_skcipher_setkey(tfm, vec->key, vec->klen);
2368
2369         /* IV */
2370         generate_random_bytes((u8 *)vec->iv, ivsize);
2371
2372         /* Plaintext */
2373         vec->len = generate_random_length(maxdatasize);
2374         generate_random_bytes((u8 *)vec->ptext, vec->len);
2375
2376         /* If the key couldn't be set, no need to continue to encrypt. */
2377         if (vec->setkey_error)
2378                 goto done;
2379
2380         /* Ciphertext */
2381         sg_init_one(&src, vec->ptext, vec->len);
2382         sg_init_one(&dst, vec->ctext, vec->len);
2383         memcpy(iv, vec->iv, ivsize);
2384         skcipher_request_set_callback(req, 0, crypto_req_done, &wait);
2385         skcipher_request_set_crypt(req, &src, &dst, vec->len, iv);
2386         vec->crypt_error = crypto_wait_req(crypto_skcipher_encrypt(req), &wait);
2387 done:
2388         snprintf(name, max_namelen, "\"random: len=%u klen=%u\"",
2389                  vec->len, vec->klen);
2390 }
2391
2392 /*
2393  * Test the skcipher algorithm represented by @req against the corresponding
2394  * generic implementation, if one is available.
2395  */
2396 static int test_skcipher_vs_generic_impl(const char *driver,
2397                                          const char *generic_driver,
2398                                          struct skcipher_request *req,
2399                                          struct cipher_test_sglists *tsgls)
2400 {
2401         struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
2402         const unsigned int ivsize = crypto_skcipher_ivsize(tfm);
2403         const unsigned int blocksize = crypto_skcipher_blocksize(tfm);
2404         const unsigned int maxdatasize = (2 * PAGE_SIZE) - TESTMGR_POISON_LEN;
2405         const char *algname = crypto_skcipher_alg(tfm)->base.cra_name;
2406         char _generic_driver[CRYPTO_MAX_ALG_NAME];
2407         struct crypto_skcipher *generic_tfm = NULL;
2408         struct skcipher_request *generic_req = NULL;
2409         unsigned int i;
2410         struct cipher_testvec vec = { 0 };
2411         char vec_name[64];
2412         struct testvec_config cfg;
2413         char cfgname[TESTVEC_CONFIG_NAMELEN];
2414         int err;
2415
2416         if (noextratests)
2417                 return 0;
2418
2419         /* Keywrap isn't supported here yet as it handles its IV differently. */
2420         if (strncmp(algname, "kw(", 3) == 0)
2421                 return 0;
2422
2423         if (!generic_driver) { /* Use default naming convention? */
2424                 err = build_generic_driver_name(algname, _generic_driver);
2425                 if (err)
2426                         return err;
2427                 generic_driver = _generic_driver;
2428         }
2429
2430         if (strcmp(generic_driver, driver) == 0) /* Already the generic impl? */
2431                 return 0;
2432
2433         generic_tfm = crypto_alloc_skcipher(generic_driver, 0, 0);
2434         if (IS_ERR(generic_tfm)) {
2435                 err = PTR_ERR(generic_tfm);
2436                 if (err == -ENOENT) {
2437                         pr_warn("alg: skcipher: skipping comparison tests for %s because %s is unavailable\n",
2438                                 driver, generic_driver);
2439                         return 0;
2440                 }
2441                 pr_err("alg: skcipher: error allocating %s (generic impl of %s): %d\n",
2442                        generic_driver, algname, err);
2443                 return err;
2444         }
2445
2446         generic_req = skcipher_request_alloc(generic_tfm, GFP_KERNEL);
2447         if (!generic_req) {
2448                 err = -ENOMEM;
2449                 goto out;
2450         }
2451
2452         /* Check the algorithm properties for consistency. */
2453
2454         if (tfm->keysize != generic_tfm->keysize) {
2455                 pr_err("alg: skcipher: max keysize for %s (%u) doesn't match generic impl (%u)\n",
2456                        driver, tfm->keysize, generic_tfm->keysize);
2457                 err = -EINVAL;
2458                 goto out;
2459         }
2460
2461         if (ivsize != crypto_skcipher_ivsize(generic_tfm)) {
2462                 pr_err("alg: skcipher: ivsize for %s (%u) doesn't match generic impl (%u)\n",
2463                        driver, ivsize, crypto_skcipher_ivsize(generic_tfm));
2464                 err = -EINVAL;
2465                 goto out;
2466         }
2467
2468         if (blocksize != crypto_skcipher_blocksize(generic_tfm)) {
2469                 pr_err("alg: skcipher: blocksize for %s (%u) doesn't match generic impl (%u)\n",
2470                        driver, blocksize,
2471                        crypto_skcipher_blocksize(generic_tfm));
2472                 err = -EINVAL;
2473                 goto out;
2474         }
2475
2476         /*
2477          * Now generate test vectors using the generic implementation, and test
2478          * the other implementation against them.
2479          */
2480
2481         vec.key = kmalloc(tfm->keysize, GFP_KERNEL);
2482         vec.iv = kmalloc(ivsize, GFP_KERNEL);
2483         vec.ptext = kmalloc(maxdatasize, GFP_KERNEL);
2484         vec.ctext = kmalloc(maxdatasize, GFP_KERNEL);
2485         if (!vec.key || !vec.iv || !vec.ptext || !vec.ctext) {
2486                 err = -ENOMEM;
2487                 goto out;
2488         }
2489
2490         for (i = 0; i < fuzz_iterations * 8; i++) {
2491                 generate_random_cipher_testvec(generic_req, &vec, maxdatasize,
2492                                                vec_name, sizeof(vec_name));
2493                 generate_random_testvec_config(&cfg, cfgname, sizeof(cfgname));
2494
2495                 err = test_skcipher_vec_cfg(driver, ENCRYPT, &vec, vec_name,
2496                                             &cfg, req, tsgls);
2497                 if (err)
2498                         goto out;
2499                 err = test_skcipher_vec_cfg(driver, DECRYPT, &vec, vec_name,
2500                                             &cfg, req, tsgls);
2501                 if (err)
2502                         goto out;
2503                 cond_resched();
2504         }
2505         err = 0;
2506 out:
2507         kfree(vec.key);
2508         kfree(vec.iv);
2509         kfree(vec.ptext);
2510         kfree(vec.ctext);
2511         crypto_free_skcipher(generic_tfm);
2512         skcipher_request_free(generic_req);
2513         return err;
2514 }
2515 #else /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */
2516 static int test_skcipher_vs_generic_impl(const char *driver,
2517                                          const char *generic_driver,
2518                                          struct skcipher_request *req,
2519                                          struct cipher_test_sglists *tsgls)
2520 {
2521         return 0;
2522 }
2523 #endif /* !CONFIG_CRYPTO_MANAGER_EXTRA_TESTS */
2524
2525 static int test_skcipher(const char *driver, int enc,
2526                          const struct cipher_test_suite *suite,
2527                          struct skcipher_request *req,
2528                          struct cipher_test_sglists *tsgls)
2529 {
2530         unsigned int i;
2531         int err;
2532
2533         for (i = 0; i < suite->count; i++) {
2534                 err = test_skcipher_vec(driver, enc, &suite->vecs[i], i, req,
2535                                         tsgls);
2536                 if (err)
2537                         return err;
2538         }
2539         return 0;
2540 }
2541
2542 static int alg_test_skcipher(const struct alg_test_desc *desc,
2543                              const char *driver, u32 type, u32 mask)
2544 {
2545         const struct cipher_test_suite *suite = &desc->suite.cipher;
2546         struct crypto_skcipher *tfm;
2547         struct skcipher_request *req = NULL;
2548         struct cipher_test_sglists *tsgls = NULL;
2549         int err;
2550
2551         if (suite->count <= 0) {
2552                 pr_err("alg: skcipher: empty test suite for %s\n", driver);
2553                 return -EINVAL;
2554         }
2555
2556         tfm = crypto_alloc_skcipher(driver, type, mask);
2557         if (IS_ERR(tfm)) {
2558                 pr_err("alg: skcipher: failed to allocate transform for %s: %ld\n",
2559                        driver, PTR_ERR(tfm));
2560                 return PTR_ERR(tfm);
2561         }
2562
2563         req = skcipher_request_alloc(tfm, GFP_KERNEL);
2564         if (!req) {
2565                 pr_err("alg: skcipher: failed to allocate request for %s\n",
2566                        driver);
2567                 err = -ENOMEM;
2568                 goto out;
2569         }
2570
2571         tsgls = alloc_cipher_test_sglists();
2572         if (!tsgls) {
2573                 pr_err("alg: skcipher: failed to allocate test buffers for %s\n",
2574                        driver);
2575                 err = -ENOMEM;
2576                 goto out;
2577         }
2578
2579         err = test_skcipher(driver, ENCRYPT, suite, req, tsgls);
2580         if (err)
2581                 goto out;
2582
2583         err = test_skcipher(driver, DECRYPT, suite, req, tsgls);
2584         if (err)
2585                 goto out;
2586
2587         err = test_skcipher_vs_generic_impl(driver, desc->generic_driver, req,
2588                                             tsgls);
2589 out:
2590         free_cipher_test_sglists(tsgls);
2591         skcipher_request_free(req);
2592         crypto_free_skcipher(tfm);
2593         return err;
2594 }
2595
2596 static int test_comp(struct crypto_comp *tfm,
2597                      const struct comp_testvec *ctemplate,
2598                      const struct comp_testvec *dtemplate,
2599                      int ctcount, int dtcount)
2600 {
2601         const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
2602         char *output, *decomp_output;
2603         unsigned int i;
2604         int ret;
2605
2606         output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL);
2607         if (!output)
2608                 return -ENOMEM;
2609
2610         decomp_output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL);
2611         if (!decomp_output) {
2612                 kfree(output);
2613                 return -ENOMEM;
2614         }
2615
2616         for (i = 0; i < ctcount; i++) {
2617                 int ilen;
2618                 unsigned int dlen = COMP_BUF_SIZE;
2619
2620                 memset(output, 0, COMP_BUF_SIZE);
2621                 memset(decomp_output, 0, COMP_BUF_SIZE);
2622
2623                 ilen = ctemplate[i].inlen;
2624                 ret = crypto_comp_compress(tfm, ctemplate[i].input,
2625                                            ilen, output, &dlen);
2626                 if (ret) {
2627                         printk(KERN_ERR "alg: comp: compression failed "
2628                                "on test %d for %s: ret=%d\n", i + 1, algo,
2629                                -ret);
2630                         goto out;
2631                 }
2632
2633                 ilen = dlen;
2634                 dlen = COMP_BUF_SIZE;
2635                 ret = crypto_comp_decompress(tfm, output,
2636                                              ilen, decomp_output, &dlen);
2637                 if (ret) {
2638                         pr_err("alg: comp: compression failed: decompress: on test %d for %s failed: ret=%d\n",
2639                                i + 1, algo, -ret);
2640                         goto out;
2641                 }
2642
2643                 if (dlen != ctemplate[i].inlen) {
2644                         printk(KERN_ERR "alg: comp: Compression test %d "
2645                                "failed for %s: output len = %d\n", i + 1, algo,
2646                                dlen);
2647                         ret = -EINVAL;
2648                         goto out;
2649                 }
2650
2651                 if (memcmp(decomp_output, ctemplate[i].input,
2652                            ctemplate[i].inlen)) {
2653                         pr_err("alg: comp: compression failed: output differs: on test %d for %s\n",
2654                                i + 1, algo);
2655                         hexdump(decomp_output, dlen);
2656                         ret = -EINVAL;
2657                         goto out;
2658                 }
2659         }
2660
2661         for (i = 0; i < dtcount; i++) {
2662                 int ilen;
2663                 unsigned int dlen = COMP_BUF_SIZE;
2664
2665                 memset(decomp_output, 0, COMP_BUF_SIZE);
2666
2667                 ilen = dtemplate[i].inlen;
2668                 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
2669                                              ilen, decomp_output, &dlen);
2670                 if (ret) {
2671                         printk(KERN_ERR "alg: comp: decompression failed "
2672                                "on test %d for %s: ret=%d\n", i + 1, algo,
2673                                -ret);
2674                         goto out;
2675                 }
2676
2677                 if (dlen != dtemplate[i].outlen) {
2678                         printk(KERN_ERR "alg: comp: Decompression test %d "
2679                                "failed for %s: output len = %d\n", i + 1, algo,
2680                                dlen);
2681                         ret = -EINVAL;
2682                         goto out;
2683                 }
2684
2685                 if (memcmp(decomp_output, dtemplate[i].output, dlen)) {
2686                         printk(KERN_ERR "alg: comp: Decompression test %d "
2687                                "failed for %s\n", i + 1, algo);
2688                         hexdump(decomp_output, dlen);
2689                         ret = -EINVAL;
2690                         goto out;
2691                 }
2692         }
2693
2694         ret = 0;
2695
2696 out:
2697         kfree(decomp_output);
2698         kfree(output);
2699         return ret;
2700 }
2701
2702 static int test_acomp(struct crypto_acomp *tfm,
2703                               const struct comp_testvec *ctemplate,
2704                       const struct comp_testvec *dtemplate,
2705                       int ctcount, int dtcount)
2706 {
2707         const char *algo = crypto_tfm_alg_driver_name(crypto_acomp_tfm(tfm));
2708         unsigned int i;
2709         char *output, *decomp_out;
2710         int ret;
2711         struct scatterlist src, dst;
2712         struct acomp_req *req;
2713         struct crypto_wait wait;
2714
2715         output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL);
2716         if (!output)
2717                 return -ENOMEM;
2718
2719         decomp_out = kmalloc(COMP_BUF_SIZE, GFP_KERNEL);
2720         if (!decomp_out) {
2721                 kfree(output);
2722                 return -ENOMEM;
2723         }
2724
2725         for (i = 0; i < ctcount; i++) {
2726                 unsigned int dlen = COMP_BUF_SIZE;
2727                 int ilen = ctemplate[i].inlen;
2728                 void *input_vec;
2729
2730                 input_vec = kmemdup(ctemplate[i].input, ilen, GFP_KERNEL);
2731                 if (!input_vec) {
2732                         ret = -ENOMEM;
2733                         goto out;
2734                 }
2735
2736                 memset(output, 0, dlen);
2737                 crypto_init_wait(&wait);
2738                 sg_init_one(&src, input_vec, ilen);
2739                 sg_init_one(&dst, output, dlen);
2740
2741                 req = acomp_request_alloc(tfm);
2742                 if (!req) {
2743                         pr_err("alg: acomp: request alloc failed for %s\n",
2744                                algo);
2745                         kfree(input_vec);
2746                         ret = -ENOMEM;
2747                         goto out;
2748                 }
2749
2750                 acomp_request_set_params(req, &src, &dst, ilen, dlen);
2751                 acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
2752                                            crypto_req_done, &wait);
2753
2754                 ret = crypto_wait_req(crypto_acomp_compress(req), &wait);
2755                 if (ret) {
2756                         pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n",
2757                                i + 1, algo, -ret);
2758                         kfree(input_vec);
2759                         acomp_request_free(req);
2760                         goto out;
2761                 }
2762
2763                 ilen = req->dlen;
2764                 dlen = COMP_BUF_SIZE;
2765                 sg_init_one(&src, output, ilen);
2766                 sg_init_one(&dst, decomp_out, dlen);
2767                 crypto_init_wait(&wait);
2768                 acomp_request_set_params(req, &src, &dst, ilen, dlen);
2769
2770                 ret = crypto_wait_req(crypto_acomp_decompress(req), &wait);
2771                 if (ret) {
2772                         pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n",
2773                                i + 1, algo, -ret);
2774                         kfree(input_vec);
2775                         acomp_request_free(req);
2776                         goto out;
2777                 }
2778
2779                 if (req->dlen != ctemplate[i].inlen) {
2780                         pr_err("alg: acomp: Compression test %d failed for %s: output len = %d\n",
2781                                i + 1, algo, req->dlen);
2782                         ret = -EINVAL;
2783                         kfree(input_vec);
2784                         acomp_request_free(req);
2785                         goto out;
2786                 }
2787
2788                 if (memcmp(input_vec, decomp_out, req->dlen)) {
2789                         pr_err("alg: acomp: Compression test %d failed for %s\n",
2790                                i + 1, algo);
2791                         hexdump(output, req->dlen);
2792                         ret = -EINVAL;
2793                         kfree(input_vec);
2794                         acomp_request_free(req);
2795                         goto out;
2796                 }
2797
2798                 kfree(input_vec);
2799                 acomp_request_free(req);
2800         }
2801
2802         for (i = 0; i < dtcount; i++) {
2803                 unsigned int dlen = COMP_BUF_SIZE;
2804                 int ilen = dtemplate[i].inlen;
2805                 void *input_vec;
2806
2807                 input_vec = kmemdup(dtemplate[i].input, ilen, GFP_KERNEL);
2808                 if (!input_vec) {
2809                         ret = -ENOMEM;
2810                         goto out;
2811                 }
2812
2813                 memset(output, 0, dlen);
2814                 crypto_init_wait(&wait);
2815                 sg_init_one(&src, input_vec, ilen);
2816                 sg_init_one(&dst, output, dlen);
2817
2818                 req = acomp_request_alloc(tfm);
2819                 if (!req) {
2820                         pr_err("alg: acomp: request alloc failed for %s\n",
2821                                algo);
2822                         kfree(input_vec);
2823                         ret = -ENOMEM;
2824                         goto out;
2825                 }
2826
2827                 acomp_request_set_params(req, &src, &dst, ilen, dlen);
2828                 acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
2829                                            crypto_req_done, &wait);
2830
2831                 ret = crypto_wait_req(crypto_acomp_decompress(req), &wait);
2832                 if (ret) {
2833                         pr_err("alg: acomp: decompression failed on test %d for %s: ret=%d\n",
2834                                i + 1, algo, -ret);
2835                         kfree(input_vec);
2836                         acomp_request_free(req);
2837                         goto out;
2838                 }
2839
2840                 if (req->dlen != dtemplate[i].outlen) {
2841                         pr_err("alg: acomp: Decompression test %d failed for %s: output len = %d\n",
2842                                i + 1, algo, req->dlen);
2843                         ret = -EINVAL;
2844                         kfree(input_vec);
2845                         acomp_request_free(req);
2846                         goto out;
2847                 }
2848
2849                 if (memcmp(output, dtemplate[i].output, req->dlen)) {
2850                         pr_err("alg: acomp: Decompression test %d failed for %s\n",
2851                                i + 1, algo);
2852                         hexdump(output, req->dlen);
2853                         ret = -EINVAL;
2854                         kfree(input_vec);
2855                         acomp_request_free(req);
2856                         goto out;
2857                 }
2858
2859                 kfree(input_vec);
2860                 acomp_request_free(req);
2861         }
2862
2863         ret = 0;
2864
2865 out:
2866         kfree(decomp_out);
2867         kfree(output);
2868         return ret;
2869 }
2870
2871 static int test_cprng(struct crypto_rng *tfm,
2872                       const struct cprng_testvec *template,
2873                       unsigned int tcount)
2874 {
2875         const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm));
2876         int err = 0, i, j, seedsize;
2877         u8 *seed;
2878         char result[32];
2879
2880         seedsize = crypto_rng_seedsize(tfm);
2881
2882         seed = kmalloc(seedsize, GFP_KERNEL);
2883         if (!seed) {
2884                 printk(KERN_ERR "alg: cprng: Failed to allocate seed space "
2885                        "for %s\n", algo);
2886                 return -ENOMEM;
2887         }
2888
2889         for (i = 0; i < tcount; i++) {
2890                 memset(result, 0, 32);
2891
2892                 memcpy(seed, template[i].v, template[i].vlen);
2893                 memcpy(seed + template[i].vlen, template[i].key,
2894                        template[i].klen);
2895                 memcpy(seed + template[i].vlen + template[i].klen,
2896                        template[i].dt, template[i].dtlen);
2897
2898                 err = crypto_rng_reset(tfm, seed, seedsize);
2899                 if (err) {
2900                         printk(KERN_ERR "alg: cprng: Failed to reset rng "
2901                                "for %s\n", algo);
2902                         goto out;
2903                 }
2904
2905                 for (j = 0; j < template[i].loops; j++) {
2906                         err = crypto_rng_get_bytes(tfm, result,
2907                                                    template[i].rlen);
2908                         if (err < 0) {
2909                                 printk(KERN_ERR "alg: cprng: Failed to obtain "
2910                                        "the correct amount of random data for "
2911                                        "%s (requested %d)\n", algo,
2912                                        template[i].rlen);
2913                                 goto out;
2914                         }
2915                 }
2916
2917                 err = memcmp(result, template[i].result,
2918                              template[i].rlen);
2919                 if (err) {
2920                         printk(KERN_ERR "alg: cprng: Test %d failed for %s\n",
2921                                i, algo);
2922                         hexdump(result, template[i].rlen);
2923                         err = -EINVAL;
2924                         goto out;
2925                 }
2926         }
2927
2928 out:
2929         kfree(seed);
2930         return err;
2931 }
2932
2933 static int alg_test_cipher(const struct alg_test_desc *desc,
2934                            const char *driver, u32 type, u32 mask)
2935 {
2936         const struct cipher_test_suite *suite = &desc->suite.cipher;
2937         struct crypto_cipher *tfm;
2938         int err;
2939
2940         tfm = crypto_alloc_cipher(driver, type, mask);
2941         if (IS_ERR(tfm)) {
2942                 printk(KERN_ERR "alg: cipher: Failed to load transform for "
2943                        "%s: %ld\n", driver, PTR_ERR(tfm));
2944                 return PTR_ERR(tfm);
2945         }
2946
2947         err = test_cipher(tfm, ENCRYPT, suite->vecs, suite->count);
2948         if (!err)
2949                 err = test_cipher(tfm, DECRYPT, suite->vecs, suite->count);
2950
2951         crypto_free_cipher(tfm);
2952         return err;
2953 }
2954
2955 static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
2956                          u32 type, u32 mask)
2957 {
2958         struct crypto_comp *comp;
2959         struct crypto_acomp *acomp;
2960         int err;
2961         u32 algo_type = type & CRYPTO_ALG_TYPE_ACOMPRESS_MASK;
2962
2963         if (algo_type == CRYPTO_ALG_TYPE_ACOMPRESS) {
2964                 acomp = crypto_alloc_acomp(driver, type, mask);
2965                 if (IS_ERR(acomp)) {
2966                         pr_err("alg: acomp: Failed to load transform for %s: %ld\n",
2967                                driver, PTR_ERR(acomp));
2968                         return PTR_ERR(acomp);
2969                 }
2970                 err = test_acomp(acomp, desc->suite.comp.comp.vecs,
2971                                  desc->suite.comp.decomp.vecs,
2972                                  desc->suite.comp.comp.count,
2973                                  desc->suite.comp.decomp.count);
2974                 crypto_free_acomp(acomp);
2975         } else {
2976                 comp = crypto_alloc_comp(driver, type, mask);
2977                 if (IS_ERR(comp)) {
2978                         pr_err("alg: comp: Failed to load transform for %s: %ld\n",
2979                                driver, PTR_ERR(comp));
2980                         return PTR_ERR(comp);
2981                 }
2982
2983                 err = test_comp(comp, desc->suite.comp.comp.vecs,
2984                                 desc->suite.comp.decomp.vecs,
2985                                 desc->suite.comp.comp.count,
2986                                 desc->suite.comp.decomp.count);
2987
2988                 crypto_free_comp(comp);
2989         }
2990         return err;
2991 }
2992
2993 static int alg_test_crc32c(const struct alg_test_desc *desc,
2994                            const char *driver, u32 type, u32 mask)
2995 {
2996         struct crypto_shash *tfm;
2997         __le32 val;
2998         int err;
2999
3000         err = alg_test_hash(desc, driver, type, mask);
3001         if (err)
3002                 return err;
3003
3004         tfm = crypto_alloc_shash(driver, type, mask);
3005         if (IS_ERR(tfm)) {
3006                 if (PTR_ERR(tfm) == -ENOENT) {
3007                         /*
3008                          * This crc32c implementation is only available through
3009                          * ahash API, not the shash API, so the remaining part
3010                          * of the test is not applicable to it.
3011                          */
3012                         return 0;
3013                 }
3014                 printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: "
3015                        "%ld\n", driver, PTR_ERR(tfm));
3016                 return PTR_ERR(tfm);
3017         }
3018
3019         do {
3020                 SHASH_DESC_ON_STACK(shash, tfm);
3021                 u32 *ctx = (u32 *)shash_desc_ctx(shash);
3022
3023                 shash->tfm = tfm;
3024
3025                 *ctx = 420553207;
3026                 err = crypto_shash_final(shash, (u8 *)&val);
3027                 if (err) {
3028                         printk(KERN_ERR "alg: crc32c: Operation failed for "
3029                                "%s: %d\n", driver, err);
3030                         break;
3031                 }
3032
3033                 if (val != cpu_to_le32(~420553207)) {
3034                         pr_err("alg: crc32c: Test failed for %s: %u\n",
3035                                driver, le32_to_cpu(val));
3036                         err = -EINVAL;
3037                 }
3038         } while (0);
3039
3040         crypto_free_shash(tfm);
3041
3042         return err;
3043 }
3044
3045 static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver,
3046                           u32 type, u32 mask)
3047 {
3048         struct crypto_rng *rng;
3049         int err;
3050
3051         rng = crypto_alloc_rng(driver, type, mask);
3052         if (IS_ERR(rng)) {
3053                 printk(KERN_ERR "alg: cprng: Failed to load transform for %s: "
3054                        "%ld\n", driver, PTR_ERR(rng));
3055                 return PTR_ERR(rng);
3056         }
3057
3058         err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count);
3059
3060         crypto_free_rng(rng);
3061
3062         return err;
3063 }
3064
3065
3066 static int drbg_cavs_test(const struct drbg_testvec *test, int pr,
3067                           const char *driver, u32 type, u32 mask)
3068 {
3069         int ret = -EAGAIN;
3070         struct crypto_rng *drng;
3071         struct drbg_test_data test_data;
3072         struct drbg_string addtl, pers, testentropy;
3073         unsigned char *buf = kzalloc(test->expectedlen, GFP_KERNEL);
3074
3075         if (!buf)
3076                 return -ENOMEM;
3077
3078         drng = crypto_alloc_rng(driver, type, mask);
3079         if (IS_ERR(drng)) {
3080                 printk(KERN_ERR "alg: drbg: could not allocate DRNG handle for "
3081                        "%s\n", driver);
3082                 kzfree(buf);
3083                 return -ENOMEM;
3084         }
3085
3086         test_data.testentropy = &testentropy;
3087         drbg_string_fill(&testentropy, test->entropy, test->entropylen);
3088         drbg_string_fill(&pers, test->pers, test->perslen);
3089         ret = crypto_drbg_reset_test(drng, &pers, &test_data);
3090         if (ret) {
3091                 printk(KERN_ERR "alg: drbg: Failed to reset rng\n");
3092                 goto outbuf;
3093         }
3094
3095         drbg_string_fill(&addtl, test->addtla, test->addtllen);
3096         if (pr) {
3097                 drbg_string_fill(&testentropy, test->entpra, test->entprlen);
3098                 ret = crypto_drbg_get_bytes_addtl_test(drng,
3099                         buf, test->expectedlen, &addtl, &test_data);
3100         } else {
3101                 ret = crypto_drbg_get_bytes_addtl(drng,
3102                         buf, test->expectedlen, &addtl);
3103         }
3104         if (ret < 0) {
3105                 printk(KERN_ERR "alg: drbg: could not obtain random data for "
3106                        "driver %s\n", driver);
3107                 goto outbuf;
3108         }
3109
3110         drbg_string_fill(&addtl, test->addtlb, test->addtllen);
3111         if (pr) {
3112                 drbg_string_fill(&testentropy, test->entprb, test->entprlen);
3113                 ret = crypto_drbg_get_bytes_addtl_test(drng,
3114                         buf, test->expectedlen, &addtl, &test_data);
3115         } else {
3116                 ret = crypto_drbg_get_bytes_addtl(drng,
3117                         buf, test->expectedlen, &addtl);
3118         }
3119         if (ret < 0) {
3120                 printk(KERN_ERR "alg: drbg: could not obtain random data for "
3121                        "driver %s\n", driver);
3122                 goto outbuf;
3123         }
3124
3125         ret = memcmp(test->expected, buf, test->expectedlen);
3126
3127 outbuf:
3128         crypto_free_rng(drng);
3129         kzfree(buf);
3130         return ret;
3131 }
3132
3133
3134 static int alg_test_drbg(const struct alg_test_desc *desc, const char *driver,
3135                          u32 type, u32 mask)
3136 {
3137         int err = 0;
3138         int pr = 0;
3139         int i = 0;
3140         const struct drbg_testvec *template = desc->suite.drbg.vecs;
3141         unsigned int tcount = desc->suite.drbg.count;
3142
3143         if (0 == memcmp(driver, "drbg_pr_", 8))
3144                 pr = 1;
3145
3146         for (i = 0; i < tcount; i++) {
3147                 err = drbg_cavs_test(&template[i], pr, driver, type, mask);
3148                 if (err) {
3149                         printk(KERN_ERR "alg: drbg: Test %d failed for %s\n",
3150                                i, driver);
3151                         err = -EINVAL;
3152                         break;
3153                 }
3154         }
3155         return err;
3156
3157 }
3158
3159 static int do_test_kpp(struct crypto_kpp *tfm, const struct kpp_testvec *vec,
3160                        const char *alg)
3161 {
3162         struct kpp_request *req;
3163         void *input_buf = NULL;
3164         void *output_buf = NULL;
3165         void *a_public = NULL;
3166         void *a_ss = NULL;
3167         void *shared_secret = NULL;
3168         struct crypto_wait wait;
3169         unsigned int out_len_max;
3170         int err = -ENOMEM;
3171         struct scatterlist src, dst;
3172
3173         req = kpp_request_alloc(tfm, GFP_KERNEL);
3174         if (!req)
3175                 return err;
3176
3177         crypto_init_wait(&wait);
3178
3179         err = crypto_kpp_set_secret(tfm, vec->secret, vec->secret_size);
3180         if (err < 0)
3181                 goto free_req;
3182
3183         out_len_max = crypto_kpp_maxsize(tfm);
3184         output_buf = kzalloc(out_len_max, GFP_KERNEL);
3185         if (!output_buf) {
3186                 err = -ENOMEM;
3187                 goto free_req;
3188         }
3189
3190         /* Use appropriate parameter as base */
3191         kpp_request_set_input(req, NULL, 0);
3192         sg_init_one(&dst, output_buf, out_len_max);
3193         kpp_request_set_output(req, &dst, out_len_max);
3194         kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
3195                                  crypto_req_done, &wait);
3196
3197         /* Compute party A's public key */
3198         err = crypto_wait_req(crypto_kpp_generate_public_key(req), &wait);
3199         if (err) {
3200                 pr_err("alg: %s: Party A: generate public key test failed. err %d\n",
3201                        alg, err);
3202                 goto free_output;
3203         }
3204
3205         if (vec->genkey) {
3206                 /* Save party A's public key */
3207                 a_public = kmemdup(sg_virt(req->dst), out_len_max, GFP_KERNEL);
3208                 if (!a_public) {
3209                         err = -ENOMEM;
3210                         goto free_output;
3211                 }
3212         } else {
3213                 /* Verify calculated public key */
3214                 if (memcmp(vec->expected_a_public, sg_virt(req->dst),
3215                            vec->expected_a_public_size)) {
3216                         pr_err("alg: %s: Party A: generate public key test failed. Invalid output\n",
3217                                alg);
3218                         err = -EINVAL;
3219                         goto free_output;
3220                 }
3221         }
3222
3223         /* Calculate shared secret key by using counter part (b) public key. */
3224         input_buf = kmemdup(vec->b_public, vec->b_public_size, GFP_KERNEL);
3225         if (!input_buf) {
3226                 err = -ENOMEM;
3227                 goto free_output;
3228         }
3229
3230         sg_init_one(&src, input_buf, vec->b_public_size);
3231         sg_init_one(&dst, output_buf, out_len_max);
3232         kpp_request_set_input(req, &src, vec->b_public_size);
3233         kpp_request_set_output(req, &dst, out_len_max);
3234         kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
3235                                  crypto_req_done, &wait);
3236         err = crypto_wait_req(crypto_kpp_compute_shared_secret(req), &wait);
3237         if (err) {
3238                 pr_err("alg: %s: Party A: compute shared secret test failed. err %d\n",
3239                        alg, err);
3240                 goto free_all;
3241         }
3242
3243         if (vec->genkey) {
3244                 /* Save the shared secret obtained by party A */
3245                 a_ss = kmemdup(sg_virt(req->dst), vec->expected_ss_size, GFP_KERNEL);
3246                 if (!a_ss) {
3247                         err = -ENOMEM;
3248                         goto free_all;
3249                 }
3250
3251                 /*
3252                  * Calculate party B's shared secret by using party A's
3253                  * public key.
3254                  */
3255                 err = crypto_kpp_set_secret(tfm, vec->b_secret,
3256                                             vec->b_secret_size);
3257                 if (err < 0)
3258                         goto free_all;
3259
3260                 sg_init_one(&src, a_public, vec->expected_a_public_size);
3261                 sg_init_one(&dst, output_buf, out_len_max);
3262                 kpp_request_set_input(req, &src, vec->expected_a_public_size);
3263                 kpp_request_set_output(req, &dst, out_len_max);
3264                 kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
3265                                          crypto_req_done, &wait);
3266                 err = crypto_wait_req(crypto_kpp_compute_shared_secret(req),
3267                                       &wait);
3268                 if (err) {
3269                         pr_err("alg: %s: Party B: compute shared secret failed. err %d\n",
3270                                alg, err);
3271                         goto free_all;
3272                 }
3273
3274                 shared_secret = a_ss;
3275       &