Merge tag 'fbdev-fixes-4.3' of git://git.kernel.org/pub/scm/linux/kernel/git/tomba...
[linux-drm-fsl-dcu.git] / crypto / testmgr.c
1 /*
2  * Algorithm testing framework and tests.
3  *
4  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
5  * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
6  * Copyright (c) 2007 Nokia Siemens Networks
7  * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
8  *
9  * Updated RFC4106 AES-GCM testing.
10  *    Authors: Aidan O'Mahony (aidan.o.mahony@intel.com)
11  *             Adrian Hoban <adrian.hoban@intel.com>
12  *             Gabriele Paoloni <gabriele.paoloni@intel.com>
13  *             Tadeusz Struk (tadeusz.struk@intel.com)
14  *    Copyright (c) 2010, Intel Corporation.
15  *
16  * This program is free software; you can redistribute it and/or modify it
17  * under the terms of the GNU General Public License as published by the Free
18  * Software Foundation; either version 2 of the License, or (at your option)
19  * any later version.
20  *
21  */
22
23 #include <crypto/aead.h>
24 #include <crypto/hash.h>
25 #include <crypto/skcipher.h>
26 #include <linux/err.h>
27 #include <linux/fips.h>
28 #include <linux/module.h>
29 #include <linux/scatterlist.h>
30 #include <linux/slab.h>
31 #include <linux/string.h>
32 #include <crypto/rng.h>
33 #include <crypto/drbg.h>
34 #include <crypto/akcipher.h>
35
36 #include "internal.h"
37
38 #ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
39
40 /* a perfect nop */
41 int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
42 {
43         return 0;
44 }
45
46 #else
47
48 #include "testmgr.h"
49
50 /*
51  * Need slab memory for testing (size in number of pages).
52  */
53 #define XBUFSIZE        8
54
55 /*
56  * Indexes into the xbuf to simulate cross-page access.
57  */
58 #define IDX1            32
59 #define IDX2            32400
60 #define IDX3            1
61 #define IDX4            8193
62 #define IDX5            22222
63 #define IDX6            17101
64 #define IDX7            27333
65 #define IDX8            3000
66
67 /*
68 * Used by test_cipher()
69 */
70 #define ENCRYPT 1
71 #define DECRYPT 0
72
73 struct tcrypt_result {
74         struct completion completion;
75         int err;
76 };
77
78 struct aead_test_suite {
79         struct {
80                 struct aead_testvec *vecs;
81                 unsigned int count;
82         } enc, dec;
83 };
84
85 struct cipher_test_suite {
86         struct {
87                 struct cipher_testvec *vecs;
88                 unsigned int count;
89         } enc, dec;
90 };
91
92 struct comp_test_suite {
93         struct {
94                 struct comp_testvec *vecs;
95                 unsigned int count;
96         } comp, decomp;
97 };
98
99 struct pcomp_test_suite {
100         struct {
101                 struct pcomp_testvec *vecs;
102                 unsigned int count;
103         } comp, decomp;
104 };
105
106 struct hash_test_suite {
107         struct hash_testvec *vecs;
108         unsigned int count;
109 };
110
111 struct cprng_test_suite {
112         struct cprng_testvec *vecs;
113         unsigned int count;
114 };
115
116 struct drbg_test_suite {
117         struct drbg_testvec *vecs;
118         unsigned int count;
119 };
120
121 struct akcipher_test_suite {
122         struct akcipher_testvec *vecs;
123         unsigned int count;
124 };
125
126 struct alg_test_desc {
127         const char *alg;
128         int (*test)(const struct alg_test_desc *desc, const char *driver,
129                     u32 type, u32 mask);
130         int fips_allowed;       /* set if alg is allowed in fips mode */
131
132         union {
133                 struct aead_test_suite aead;
134                 struct cipher_test_suite cipher;
135                 struct comp_test_suite comp;
136                 struct pcomp_test_suite pcomp;
137                 struct hash_test_suite hash;
138                 struct cprng_test_suite cprng;
139                 struct drbg_test_suite drbg;
140                 struct akcipher_test_suite akcipher;
141         } suite;
142 };
143
144 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
145
146 static void hexdump(unsigned char *buf, unsigned int len)
147 {
148         print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
149                         16, 1,
150                         buf, len, false);
151 }
152
153 static void tcrypt_complete(struct crypto_async_request *req, int err)
154 {
155         struct tcrypt_result *res = req->data;
156
157         if (err == -EINPROGRESS)
158                 return;
159
160         res->err = err;
161         complete(&res->completion);
162 }
163
164 static int testmgr_alloc_buf(char *buf[XBUFSIZE])
165 {
166         int i;
167
168         for (i = 0; i < XBUFSIZE; i++) {
169                 buf[i] = (void *)__get_free_page(GFP_KERNEL);
170                 if (!buf[i])
171                         goto err_free_buf;
172         }
173
174         return 0;
175
176 err_free_buf:
177         while (i-- > 0)
178                 free_page((unsigned long)buf[i]);
179
180         return -ENOMEM;
181 }
182
183 static void testmgr_free_buf(char *buf[XBUFSIZE])
184 {
185         int i;
186
187         for (i = 0; i < XBUFSIZE; i++)
188                 free_page((unsigned long)buf[i]);
189 }
190
191 static int wait_async_op(struct tcrypt_result *tr, int ret)
192 {
193         if (ret == -EINPROGRESS || ret == -EBUSY) {
194                 wait_for_completion(&tr->completion);
195                 reinit_completion(&tr->completion);
196                 ret = tr->err;
197         }
198         return ret;
199 }
200
201 static int __test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
202                        unsigned int tcount, bool use_digest,
203                        const int align_offset)
204 {
205         const char *algo = crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm));
206         unsigned int i, j, k, temp;
207         struct scatterlist sg[8];
208         char *result;
209         char *key;
210         struct ahash_request *req;
211         struct tcrypt_result tresult;
212         void *hash_buff;
213         char *xbuf[XBUFSIZE];
214         int ret = -ENOMEM;
215
216         result = kmalloc(MAX_DIGEST_SIZE, GFP_KERNEL);
217         if (!result)
218                 return ret;
219         key = kmalloc(MAX_KEYLEN, GFP_KERNEL);
220         if (!key)
221                 goto out_nobuf;
222         if (testmgr_alloc_buf(xbuf))
223                 goto out_nobuf;
224
225         init_completion(&tresult.completion);
226
227         req = ahash_request_alloc(tfm, GFP_KERNEL);
228         if (!req) {
229                 printk(KERN_ERR "alg: hash: Failed to allocate request for "
230                        "%s\n", algo);
231                 goto out_noreq;
232         }
233         ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
234                                    tcrypt_complete, &tresult);
235
236         j = 0;
237         for (i = 0; i < tcount; i++) {
238                 if (template[i].np)
239                         continue;
240
241                 ret = -EINVAL;
242                 if (WARN_ON(align_offset + template[i].psize > PAGE_SIZE))
243                         goto out;
244
245                 j++;
246                 memset(result, 0, MAX_DIGEST_SIZE);
247
248                 hash_buff = xbuf[0];
249                 hash_buff += align_offset;
250
251                 memcpy(hash_buff, template[i].plaintext, template[i].psize);
252                 sg_init_one(&sg[0], hash_buff, template[i].psize);
253
254                 if (template[i].ksize) {
255                         crypto_ahash_clear_flags(tfm, ~0);
256                         if (template[i].ksize > MAX_KEYLEN) {
257                                 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
258                                        j, algo, template[i].ksize, MAX_KEYLEN);
259                                 ret = -EINVAL;
260                                 goto out;
261                         }
262                         memcpy(key, template[i].key, template[i].ksize);
263                         ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
264                         if (ret) {
265                                 printk(KERN_ERR "alg: hash: setkey failed on "
266                                        "test %d for %s: ret=%d\n", j, algo,
267                                        -ret);
268                                 goto out;
269                         }
270                 }
271
272                 ahash_request_set_crypt(req, sg, result, template[i].psize);
273                 if (use_digest) {
274                         ret = wait_async_op(&tresult, crypto_ahash_digest(req));
275                         if (ret) {
276                                 pr_err("alg: hash: digest failed on test %d "
277                                        "for %s: ret=%d\n", j, algo, -ret);
278                                 goto out;
279                         }
280                 } else {
281                         ret = wait_async_op(&tresult, crypto_ahash_init(req));
282                         if (ret) {
283                                 pr_err("alt: hash: init failed on test %d "
284                                        "for %s: ret=%d\n", j, algo, -ret);
285                                 goto out;
286                         }
287                         ret = wait_async_op(&tresult, crypto_ahash_update(req));
288                         if (ret) {
289                                 pr_err("alt: hash: update failed on test %d "
290                                        "for %s: ret=%d\n", j, algo, -ret);
291                                 goto out;
292                         }
293                         ret = wait_async_op(&tresult, crypto_ahash_final(req));
294                         if (ret) {
295                                 pr_err("alt: hash: final failed on test %d "
296                                        "for %s: ret=%d\n", j, algo, -ret);
297                                 goto out;
298                         }
299                 }
300
301                 if (memcmp(result, template[i].digest,
302                            crypto_ahash_digestsize(tfm))) {
303                         printk(KERN_ERR "alg: hash: Test %d failed for %s\n",
304                                j, algo);
305                         hexdump(result, crypto_ahash_digestsize(tfm));
306                         ret = -EINVAL;
307                         goto out;
308                 }
309         }
310
311         j = 0;
312         for (i = 0; i < tcount; i++) {
313                 /* alignment tests are only done with continuous buffers */
314                 if (align_offset != 0)
315                         break;
316
317                 if (!template[i].np)
318                         continue;
319
320                 j++;
321                 memset(result, 0, MAX_DIGEST_SIZE);
322
323                 temp = 0;
324                 sg_init_table(sg, template[i].np);
325                 ret = -EINVAL;
326                 for (k = 0; k < template[i].np; k++) {
327                         if (WARN_ON(offset_in_page(IDX[k]) +
328                                     template[i].tap[k] > PAGE_SIZE))
329                                 goto out;
330                         sg_set_buf(&sg[k],
331                                    memcpy(xbuf[IDX[k] >> PAGE_SHIFT] +
332                                           offset_in_page(IDX[k]),
333                                           template[i].plaintext + temp,
334                                           template[i].tap[k]),
335                                    template[i].tap[k]);
336                         temp += template[i].tap[k];
337                 }
338
339                 if (template[i].ksize) {
340                         if (template[i].ksize > MAX_KEYLEN) {
341                                 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
342                                        j, algo, template[i].ksize, MAX_KEYLEN);
343                                 ret = -EINVAL;
344                                 goto out;
345                         }
346                         crypto_ahash_clear_flags(tfm, ~0);
347                         memcpy(key, template[i].key, template[i].ksize);
348                         ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
349
350                         if (ret) {
351                                 printk(KERN_ERR "alg: hash: setkey "
352                                        "failed on chunking test %d "
353                                        "for %s: ret=%d\n", j, algo, -ret);
354                                 goto out;
355                         }
356                 }
357
358                 ahash_request_set_crypt(req, sg, result, template[i].psize);
359                 ret = crypto_ahash_digest(req);
360                 switch (ret) {
361                 case 0:
362                         break;
363                 case -EINPROGRESS:
364                 case -EBUSY:
365                         wait_for_completion(&tresult.completion);
366                         reinit_completion(&tresult.completion);
367                         ret = tresult.err;
368                         if (!ret)
369                                 break;
370                         /* fall through */
371                 default:
372                         printk(KERN_ERR "alg: hash: digest failed "
373                                "on chunking test %d for %s: "
374                                "ret=%d\n", j, algo, -ret);
375                         goto out;
376                 }
377
378                 if (memcmp(result, template[i].digest,
379                            crypto_ahash_digestsize(tfm))) {
380                         printk(KERN_ERR "alg: hash: Chunking test %d "
381                                "failed for %s\n", j, algo);
382                         hexdump(result, crypto_ahash_digestsize(tfm));
383                         ret = -EINVAL;
384                         goto out;
385                 }
386         }
387
388         ret = 0;
389
390 out:
391         ahash_request_free(req);
392 out_noreq:
393         testmgr_free_buf(xbuf);
394 out_nobuf:
395         kfree(key);
396         kfree(result);
397         return ret;
398 }
399
400 static int test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
401                      unsigned int tcount, bool use_digest)
402 {
403         unsigned int alignmask;
404         int ret;
405
406         ret = __test_hash(tfm, template, tcount, use_digest, 0);
407         if (ret)
408                 return ret;
409
410         /* test unaligned buffers, check with one byte offset */
411         ret = __test_hash(tfm, template, tcount, use_digest, 1);
412         if (ret)
413                 return ret;
414
415         alignmask = crypto_tfm_alg_alignmask(&tfm->base);
416         if (alignmask) {
417                 /* Check if alignment mask for tfm is correctly set. */
418                 ret = __test_hash(tfm, template, tcount, use_digest,
419                                   alignmask + 1);
420                 if (ret)
421                         return ret;
422         }
423
424         return 0;
425 }
426
427 static int __test_aead(struct crypto_aead *tfm, int enc,
428                        struct aead_testvec *template, unsigned int tcount,
429                        const bool diff_dst, const int align_offset)
430 {
431         const char *algo = crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm));
432         unsigned int i, j, k, n, temp;
433         int ret = -ENOMEM;
434         char *q;
435         char *key;
436         struct aead_request *req;
437         struct scatterlist *sg;
438         struct scatterlist *sgout;
439         const char *e, *d;
440         struct tcrypt_result result;
441         unsigned int authsize, iv_len;
442         void *input;
443         void *output;
444         void *assoc;
445         char *iv;
446         char *xbuf[XBUFSIZE];
447         char *xoutbuf[XBUFSIZE];
448         char *axbuf[XBUFSIZE];
449
450         iv = kzalloc(MAX_IVLEN, GFP_KERNEL);
451         if (!iv)
452                 return ret;
453         key = kmalloc(MAX_KEYLEN, GFP_KERNEL);
454         if (!key)
455                 goto out_noxbuf;
456         if (testmgr_alloc_buf(xbuf))
457                 goto out_noxbuf;
458         if (testmgr_alloc_buf(axbuf))
459                 goto out_noaxbuf;
460         if (diff_dst && testmgr_alloc_buf(xoutbuf))
461                 goto out_nooutbuf;
462
463         /* avoid "the frame size is larger than 1024 bytes" compiler warning */
464         sg = kmalloc(sizeof(*sg) * 8 * (diff_dst ? 4 : 2), GFP_KERNEL);
465         if (!sg)
466                 goto out_nosg;
467         sgout = &sg[16];
468
469         if (diff_dst)
470                 d = "-ddst";
471         else
472                 d = "";
473
474         if (enc == ENCRYPT)
475                 e = "encryption";
476         else
477                 e = "decryption";
478
479         init_completion(&result.completion);
480
481         req = aead_request_alloc(tfm, GFP_KERNEL);
482         if (!req) {
483                 pr_err("alg: aead%s: Failed to allocate request for %s\n",
484                        d, algo);
485                 goto out;
486         }
487
488         aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
489                                   tcrypt_complete, &result);
490
491         for (i = 0, j = 0; i < tcount; i++) {
492                 if (template[i].np)
493                         continue;
494
495                 j++;
496
497                 /* some templates have no input data but they will
498                  * touch input
499                  */
500                 input = xbuf[0];
501                 input += align_offset;
502                 assoc = axbuf[0];
503
504                 ret = -EINVAL;
505                 if (WARN_ON(align_offset + template[i].ilen >
506                             PAGE_SIZE || template[i].alen > PAGE_SIZE))
507                         goto out;
508
509                 memcpy(input, template[i].input, template[i].ilen);
510                 memcpy(assoc, template[i].assoc, template[i].alen);
511                 iv_len = crypto_aead_ivsize(tfm);
512                 if (template[i].iv)
513                         memcpy(iv, template[i].iv, iv_len);
514                 else
515                         memset(iv, 0, iv_len);
516
517                 crypto_aead_clear_flags(tfm, ~0);
518                 if (template[i].wk)
519                         crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
520
521                 if (template[i].klen > MAX_KEYLEN) {
522                         pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
523                                d, j, algo, template[i].klen,
524                                MAX_KEYLEN);
525                         ret = -EINVAL;
526                         goto out;
527                 }
528                 memcpy(key, template[i].key, template[i].klen);
529
530                 ret = crypto_aead_setkey(tfm, key, template[i].klen);
531                 if (!ret == template[i].fail) {
532                         pr_err("alg: aead%s: setkey failed on test %d for %s: flags=%x\n",
533                                d, j, algo, crypto_aead_get_flags(tfm));
534                         goto out;
535                 } else if (ret)
536                         continue;
537
538                 authsize = abs(template[i].rlen - template[i].ilen);
539                 ret = crypto_aead_setauthsize(tfm, authsize);
540                 if (ret) {
541                         pr_err("alg: aead%s: Failed to set authsize to %u on test %d for %s\n",
542                                d, authsize, j, algo);
543                         goto out;
544                 }
545
546                 k = !!template[i].alen;
547                 sg_init_table(sg, k + 1);
548                 sg_set_buf(&sg[0], assoc, template[i].alen);
549                 sg_set_buf(&sg[k], input,
550                            template[i].ilen + (enc ? authsize : 0));
551                 output = input;
552
553                 if (diff_dst) {
554                         sg_init_table(sgout, k + 1);
555                         sg_set_buf(&sgout[0], assoc, template[i].alen);
556
557                         output = xoutbuf[0];
558                         output += align_offset;
559                         sg_set_buf(&sgout[k], output,
560                                    template[i].rlen + (enc ? 0 : authsize));
561                 }
562
563                 aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
564                                        template[i].ilen, iv);
565
566                 aead_request_set_ad(req, template[i].alen);
567
568                 ret = enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req);
569
570                 switch (ret) {
571                 case 0:
572                         if (template[i].novrfy) {
573                                 /* verification was supposed to fail */
574                                 pr_err("alg: aead%s: %s failed on test %d for %s: ret was 0, expected -EBADMSG\n",
575                                        d, e, j, algo);
576                                 /* so really, we got a bad message */
577                                 ret = -EBADMSG;
578                                 goto out;
579                         }
580                         break;
581                 case -EINPROGRESS:
582                 case -EBUSY:
583                         wait_for_completion(&result.completion);
584                         reinit_completion(&result.completion);
585                         ret = result.err;
586                         if (!ret)
587                                 break;
588                 case -EBADMSG:
589                         if (template[i].novrfy)
590                                 /* verification failure was expected */
591                                 continue;
592                         /* fall through */
593                 default:
594                         pr_err("alg: aead%s: %s failed on test %d for %s: ret=%d\n",
595                                d, e, j, algo, -ret);
596                         goto out;
597                 }
598
599                 q = output;
600                 if (memcmp(q, template[i].result, template[i].rlen)) {
601                         pr_err("alg: aead%s: Test %d failed on %s for %s\n",
602                                d, j, e, algo);
603                         hexdump(q, template[i].rlen);
604                         ret = -EINVAL;
605                         goto out;
606                 }
607         }
608
609         for (i = 0, j = 0; i < tcount; i++) {
610                 /* alignment tests are only done with continuous buffers */
611                 if (align_offset != 0)
612                         break;
613
614                 if (!template[i].np)
615                         continue;
616
617                 j++;
618
619                 if (template[i].iv)
620                         memcpy(iv, template[i].iv, MAX_IVLEN);
621                 else
622                         memset(iv, 0, MAX_IVLEN);
623
624                 crypto_aead_clear_flags(tfm, ~0);
625                 if (template[i].wk)
626                         crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
627                 if (template[i].klen > MAX_KEYLEN) {
628                         pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
629                                d, j, algo, template[i].klen, MAX_KEYLEN);
630                         ret = -EINVAL;
631                         goto out;
632                 }
633                 memcpy(key, template[i].key, template[i].klen);
634
635                 ret = crypto_aead_setkey(tfm, key, template[i].klen);
636                 if (!ret == template[i].fail) {
637                         pr_err("alg: aead%s: setkey failed on chunk test %d for %s: flags=%x\n",
638                                d, j, algo, crypto_aead_get_flags(tfm));
639                         goto out;
640                 } else if (ret)
641                         continue;
642
643                 authsize = abs(template[i].rlen - template[i].ilen);
644
645                 ret = -EINVAL;
646                 sg_init_table(sg, template[i].anp + template[i].np);
647                 if (diff_dst)
648                         sg_init_table(sgout, template[i].anp + template[i].np);
649
650                 ret = -EINVAL;
651                 for (k = 0, temp = 0; k < template[i].anp; k++) {
652                         if (WARN_ON(offset_in_page(IDX[k]) +
653                                     template[i].atap[k] > PAGE_SIZE))
654                                 goto out;
655                         sg_set_buf(&sg[k],
656                                    memcpy(axbuf[IDX[k] >> PAGE_SHIFT] +
657                                           offset_in_page(IDX[k]),
658                                           template[i].assoc + temp,
659                                           template[i].atap[k]),
660                                    template[i].atap[k]);
661                         if (diff_dst)
662                                 sg_set_buf(&sgout[k],
663                                            axbuf[IDX[k] >> PAGE_SHIFT] +
664                                            offset_in_page(IDX[k]),
665                                            template[i].atap[k]);
666                         temp += template[i].atap[k];
667                 }
668
669                 for (k = 0, temp = 0; k < template[i].np; k++) {
670                         if (WARN_ON(offset_in_page(IDX[k]) +
671                                     template[i].tap[k] > PAGE_SIZE))
672                                 goto out;
673
674                         q = xbuf[IDX[k] >> PAGE_SHIFT] + offset_in_page(IDX[k]);
675                         memcpy(q, template[i].input + temp, template[i].tap[k]);
676                         sg_set_buf(&sg[template[i].anp + k],
677                                    q, template[i].tap[k]);
678
679                         if (diff_dst) {
680                                 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
681                                     offset_in_page(IDX[k]);
682
683                                 memset(q, 0, template[i].tap[k]);
684
685                                 sg_set_buf(&sgout[template[i].anp + k],
686                                            q, template[i].tap[k]);
687                         }
688
689                         n = template[i].tap[k];
690                         if (k == template[i].np - 1 && enc)
691                                 n += authsize;
692                         if (offset_in_page(q) + n < PAGE_SIZE)
693                                 q[n] = 0;
694
695                         temp += template[i].tap[k];
696                 }
697
698                 ret = crypto_aead_setauthsize(tfm, authsize);
699                 if (ret) {
700                         pr_err("alg: aead%s: Failed to set authsize to %u on chunk test %d for %s\n",
701                                d, authsize, j, algo);
702                         goto out;
703                 }
704
705                 if (enc) {
706                         if (WARN_ON(sg[template[i].anp + k - 1].offset +
707                                     sg[template[i].anp + k - 1].length +
708                                     authsize > PAGE_SIZE)) {
709                                 ret = -EINVAL;
710                                 goto out;
711                         }
712
713                         if (diff_dst)
714                                 sgout[template[i].anp + k - 1].length +=
715                                         authsize;
716                         sg[template[i].anp + k - 1].length += authsize;
717                 }
718
719                 aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
720                                        template[i].ilen,
721                                        iv);
722
723                 aead_request_set_ad(req, template[i].alen);
724
725                 ret = enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req);
726
727                 switch (ret) {
728                 case 0:
729                         if (template[i].novrfy) {
730                                 /* verification was supposed to fail */
731                                 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret was 0, expected -EBADMSG\n",
732                                        d, e, j, algo);
733                                 /* so really, we got a bad message */
734                                 ret = -EBADMSG;
735                                 goto out;
736                         }
737                         break;
738                 case -EINPROGRESS:
739                 case -EBUSY:
740                         wait_for_completion(&result.completion);
741                         reinit_completion(&result.completion);
742                         ret = result.err;
743                         if (!ret)
744                                 break;
745                 case -EBADMSG:
746                         if (template[i].novrfy)
747                                 /* verification failure was expected */
748                                 continue;
749                         /* fall through */
750                 default:
751                         pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret=%d\n",
752                                d, e, j, algo, -ret);
753                         goto out;
754                 }
755
756                 ret = -EINVAL;
757                 for (k = 0, temp = 0; k < template[i].np; k++) {
758                         if (diff_dst)
759                                 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
760                                     offset_in_page(IDX[k]);
761                         else
762                                 q = xbuf[IDX[k] >> PAGE_SHIFT] +
763                                     offset_in_page(IDX[k]);
764
765                         n = template[i].tap[k];
766                         if (k == template[i].np - 1)
767                                 n += enc ? authsize : -authsize;
768
769                         if (memcmp(q, template[i].result + temp, n)) {
770                                 pr_err("alg: aead%s: Chunk test %d failed on %s at page %u for %s\n",
771                                        d, j, e, k, algo);
772                                 hexdump(q, n);
773                                 goto out;
774                         }
775
776                         q += n;
777                         if (k == template[i].np - 1 && !enc) {
778                                 if (!diff_dst &&
779                                         memcmp(q, template[i].input +
780                                               temp + n, authsize))
781                                         n = authsize;
782                                 else
783                                         n = 0;
784                         } else {
785                                 for (n = 0; offset_in_page(q + n) && q[n]; n++)
786                                         ;
787                         }
788                         if (n) {
789                                 pr_err("alg: aead%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
790                                        d, j, e, k, algo, n);
791                                 hexdump(q, n);
792                                 goto out;
793                         }
794
795                         temp += template[i].tap[k];
796                 }
797         }
798
799         ret = 0;
800
801 out:
802         aead_request_free(req);
803         kfree(sg);
804 out_nosg:
805         if (diff_dst)
806                 testmgr_free_buf(xoutbuf);
807 out_nooutbuf:
808         testmgr_free_buf(axbuf);
809 out_noaxbuf:
810         testmgr_free_buf(xbuf);
811 out_noxbuf:
812         kfree(key);
813         kfree(iv);
814         return ret;
815 }
816
817 static int test_aead(struct crypto_aead *tfm, int enc,
818                      struct aead_testvec *template, unsigned int tcount)
819 {
820         unsigned int alignmask;
821         int ret;
822
823         /* test 'dst == src' case */
824         ret = __test_aead(tfm, enc, template, tcount, false, 0);
825         if (ret)
826                 return ret;
827
828         /* test 'dst != src' case */
829         ret = __test_aead(tfm, enc, template, tcount, true, 0);
830         if (ret)
831                 return ret;
832
833         /* test unaligned buffers, check with one byte offset */
834         ret = __test_aead(tfm, enc, template, tcount, true, 1);
835         if (ret)
836                 return ret;
837
838         alignmask = crypto_tfm_alg_alignmask(&tfm->base);
839         if (alignmask) {
840                 /* Check if alignment mask for tfm is correctly set. */
841                 ret = __test_aead(tfm, enc, template, tcount, true,
842                                   alignmask + 1);
843                 if (ret)
844                         return ret;
845         }
846
847         return 0;
848 }
849
850 static int test_cipher(struct crypto_cipher *tfm, int enc,
851                        struct cipher_testvec *template, unsigned int tcount)
852 {
853         const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm));
854         unsigned int i, j, k;
855         char *q;
856         const char *e;
857         void *data;
858         char *xbuf[XBUFSIZE];
859         int ret = -ENOMEM;
860
861         if (testmgr_alloc_buf(xbuf))
862                 goto out_nobuf;
863
864         if (enc == ENCRYPT)
865                 e = "encryption";
866         else
867                 e = "decryption";
868
869         j = 0;
870         for (i = 0; i < tcount; i++) {
871                 if (template[i].np)
872                         continue;
873
874                 j++;
875
876                 ret = -EINVAL;
877                 if (WARN_ON(template[i].ilen > PAGE_SIZE))
878                         goto out;
879
880                 data = xbuf[0];
881                 memcpy(data, template[i].input, template[i].ilen);
882
883                 crypto_cipher_clear_flags(tfm, ~0);
884                 if (template[i].wk)
885                         crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
886
887                 ret = crypto_cipher_setkey(tfm, template[i].key,
888                                            template[i].klen);
889                 if (!ret == template[i].fail) {
890                         printk(KERN_ERR "alg: cipher: setkey failed "
891                                "on test %d for %s: flags=%x\n", j,
892                                algo, crypto_cipher_get_flags(tfm));
893                         goto out;
894                 } else if (ret)
895                         continue;
896
897                 for (k = 0; k < template[i].ilen;
898                      k += crypto_cipher_blocksize(tfm)) {
899                         if (enc)
900                                 crypto_cipher_encrypt_one(tfm, data + k,
901                                                           data + k);
902                         else
903                                 crypto_cipher_decrypt_one(tfm, data + k,
904                                                           data + k);
905                 }
906
907                 q = data;
908                 if (memcmp(q, template[i].result, template[i].rlen)) {
909                         printk(KERN_ERR "alg: cipher: Test %d failed "
910                                "on %s for %s\n", j, e, algo);
911                         hexdump(q, template[i].rlen);
912                         ret = -EINVAL;
913                         goto out;
914                 }
915         }
916
917         ret = 0;
918
919 out:
920         testmgr_free_buf(xbuf);
921 out_nobuf:
922         return ret;
923 }
924
925 static int __test_skcipher(struct crypto_skcipher *tfm, int enc,
926                            struct cipher_testvec *template, unsigned int tcount,
927                            const bool diff_dst, const int align_offset)
928 {
929         const char *algo =
930                 crypto_tfm_alg_driver_name(crypto_skcipher_tfm(tfm));
931         unsigned int i, j, k, n, temp;
932         char *q;
933         struct skcipher_request *req;
934         struct scatterlist sg[8];
935         struct scatterlist sgout[8];
936         const char *e, *d;
937         struct tcrypt_result result;
938         void *data;
939         char iv[MAX_IVLEN];
940         char *xbuf[XBUFSIZE];
941         char *xoutbuf[XBUFSIZE];
942         int ret = -ENOMEM;
943         unsigned int ivsize = crypto_skcipher_ivsize(tfm);
944
945         if (testmgr_alloc_buf(xbuf))
946                 goto out_nobuf;
947
948         if (diff_dst && testmgr_alloc_buf(xoutbuf))
949                 goto out_nooutbuf;
950
951         if (diff_dst)
952                 d = "-ddst";
953         else
954                 d = "";
955
956         if (enc == ENCRYPT)
957                 e = "encryption";
958         else
959                 e = "decryption";
960
961         init_completion(&result.completion);
962
963         req = skcipher_request_alloc(tfm, GFP_KERNEL);
964         if (!req) {
965                 pr_err("alg: skcipher%s: Failed to allocate request for %s\n",
966                        d, algo);
967                 goto out;
968         }
969
970         skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
971                                       tcrypt_complete, &result);
972
973         j = 0;
974         for (i = 0; i < tcount; i++) {
975                 if (template[i].np && !template[i].also_non_np)
976                         continue;
977
978                 if (template[i].iv)
979                         memcpy(iv, template[i].iv, ivsize);
980                 else
981                         memset(iv, 0, MAX_IVLEN);
982
983                 j++;
984                 ret = -EINVAL;
985                 if (WARN_ON(align_offset + template[i].ilen > PAGE_SIZE))
986                         goto out;
987
988                 data = xbuf[0];
989                 data += align_offset;
990                 memcpy(data, template[i].input, template[i].ilen);
991
992                 crypto_skcipher_clear_flags(tfm, ~0);
993                 if (template[i].wk)
994                         crypto_skcipher_set_flags(tfm,
995                                                   CRYPTO_TFM_REQ_WEAK_KEY);
996
997                 ret = crypto_skcipher_setkey(tfm, template[i].key,
998                                              template[i].klen);
999                 if (!ret == template[i].fail) {
1000                         pr_err("alg: skcipher%s: setkey failed on test %d for %s: flags=%x\n",
1001                                d, j, algo, crypto_skcipher_get_flags(tfm));
1002                         goto out;
1003                 } else if (ret)
1004                         continue;
1005
1006                 sg_init_one(&sg[0], data, template[i].ilen);
1007                 if (diff_dst) {
1008                         data = xoutbuf[0];
1009                         data += align_offset;
1010                         sg_init_one(&sgout[0], data, template[i].ilen);
1011                 }
1012
1013                 skcipher_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
1014                                            template[i].ilen, iv);
1015                 ret = enc ? crypto_skcipher_encrypt(req) :
1016                             crypto_skcipher_decrypt(req);
1017
1018                 switch (ret) {
1019                 case 0:
1020                         break;
1021                 case -EINPROGRESS:
1022                 case -EBUSY:
1023                         wait_for_completion(&result.completion);
1024                         reinit_completion(&result.completion);
1025                         ret = result.err;
1026                         if (!ret)
1027                                 break;
1028                         /* fall through */
1029                 default:
1030                         pr_err("alg: skcipher%s: %s failed on test %d for %s: ret=%d\n",
1031                                d, e, j, algo, -ret);
1032                         goto out;
1033                 }
1034
1035                 q = data;
1036                 if (memcmp(q, template[i].result, template[i].rlen)) {
1037                         pr_err("alg: skcipher%s: Test %d failed on %s for %s\n",
1038                                d, j, e, algo);
1039                         hexdump(q, template[i].rlen);
1040                         ret = -EINVAL;
1041                         goto out;
1042                 }
1043         }
1044
1045         j = 0;
1046         for (i = 0; i < tcount; i++) {
1047                 /* alignment tests are only done with continuous buffers */
1048                 if (align_offset != 0)
1049                         break;
1050
1051                 if (!template[i].np)
1052                         continue;
1053
1054                 if (template[i].iv)
1055                         memcpy(iv, template[i].iv, ivsize);
1056                 else
1057                         memset(iv, 0, MAX_IVLEN);
1058
1059                 j++;
1060                 crypto_skcipher_clear_flags(tfm, ~0);
1061                 if (template[i].wk)
1062                         crypto_skcipher_set_flags(tfm,
1063                                                   CRYPTO_TFM_REQ_WEAK_KEY);
1064
1065                 ret = crypto_skcipher_setkey(tfm, template[i].key,
1066                                              template[i].klen);
1067                 if (!ret == template[i].fail) {
1068                         pr_err("alg: skcipher%s: setkey failed on chunk test %d for %s: flags=%x\n",
1069                                d, j, algo, crypto_skcipher_get_flags(tfm));
1070                         goto out;
1071                 } else if (ret)
1072                         continue;
1073
1074                 temp = 0;
1075                 ret = -EINVAL;
1076                 sg_init_table(sg, template[i].np);
1077                 if (diff_dst)
1078                         sg_init_table(sgout, template[i].np);
1079                 for (k = 0; k < template[i].np; k++) {
1080                         if (WARN_ON(offset_in_page(IDX[k]) +
1081                                     template[i].tap[k] > PAGE_SIZE))
1082                                 goto out;
1083
1084                         q = xbuf[IDX[k] >> PAGE_SHIFT] + offset_in_page(IDX[k]);
1085
1086                         memcpy(q, template[i].input + temp, template[i].tap[k]);
1087
1088                         if (offset_in_page(q) + template[i].tap[k] < PAGE_SIZE)
1089                                 q[template[i].tap[k]] = 0;
1090
1091                         sg_set_buf(&sg[k], q, template[i].tap[k]);
1092                         if (diff_dst) {
1093                                 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
1094                                     offset_in_page(IDX[k]);
1095
1096                                 sg_set_buf(&sgout[k], q, template[i].tap[k]);
1097
1098                                 memset(q, 0, template[i].tap[k]);
1099                                 if (offset_in_page(q) +
1100                                     template[i].tap[k] < PAGE_SIZE)
1101                                         q[template[i].tap[k]] = 0;
1102                         }
1103
1104                         temp += template[i].tap[k];
1105                 }
1106
1107                 skcipher_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
1108                                            template[i].ilen, iv);
1109
1110                 ret = enc ? crypto_skcipher_encrypt(req) :
1111                             crypto_skcipher_decrypt(req);
1112
1113                 switch (ret) {
1114                 case 0:
1115                         break;
1116                 case -EINPROGRESS:
1117                 case -EBUSY:
1118                         wait_for_completion(&result.completion);
1119                         reinit_completion(&result.completion);
1120                         ret = result.err;
1121                         if (!ret)
1122                                 break;
1123                         /* fall through */
1124                 default:
1125                         pr_err("alg: skcipher%s: %s failed on chunk test %d for %s: ret=%d\n",
1126                                d, e, j, algo, -ret);
1127                         goto out;
1128                 }
1129
1130                 temp = 0;
1131                 ret = -EINVAL;
1132                 for (k = 0; k < template[i].np; k++) {
1133                         if (diff_dst)
1134                                 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
1135                                     offset_in_page(IDX[k]);
1136                         else
1137                                 q = xbuf[IDX[k] >> PAGE_SHIFT] +
1138                                     offset_in_page(IDX[k]);
1139
1140                         if (memcmp(q, template[i].result + temp,
1141                                    template[i].tap[k])) {
1142                                 pr_err("alg: skcipher%s: Chunk test %d failed on %s at page %u for %s\n",
1143                                        d, j, e, k, algo);
1144                                 hexdump(q, template[i].tap[k]);
1145                                 goto out;
1146                         }
1147
1148                         q += template[i].tap[k];
1149                         for (n = 0; offset_in_page(q + n) && q[n]; n++)
1150                                 ;
1151                         if (n) {
1152                                 pr_err("alg: skcipher%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
1153                                        d, j, e, k, algo, n);
1154                                 hexdump(q, n);
1155                                 goto out;
1156                         }
1157                         temp += template[i].tap[k];
1158                 }
1159         }
1160
1161         ret = 0;
1162
1163 out:
1164         skcipher_request_free(req);
1165         if (diff_dst)
1166                 testmgr_free_buf(xoutbuf);
1167 out_nooutbuf:
1168         testmgr_free_buf(xbuf);
1169 out_nobuf:
1170         return ret;
1171 }
1172
1173 static int test_skcipher(struct crypto_skcipher *tfm, int enc,
1174                          struct cipher_testvec *template, unsigned int tcount)
1175 {
1176         unsigned int alignmask;
1177         int ret;
1178
1179         /* test 'dst == src' case */
1180         ret = __test_skcipher(tfm, enc, template, tcount, false, 0);
1181         if (ret)
1182                 return ret;
1183
1184         /* test 'dst != src' case */
1185         ret = __test_skcipher(tfm, enc, template, tcount, true, 0);
1186         if (ret)
1187                 return ret;
1188
1189         /* test unaligned buffers, check with one byte offset */
1190         ret = __test_skcipher(tfm, enc, template, tcount, true, 1);
1191         if (ret)
1192                 return ret;
1193
1194         alignmask = crypto_tfm_alg_alignmask(&tfm->base);
1195         if (alignmask) {
1196                 /* Check if alignment mask for tfm is correctly set. */
1197                 ret = __test_skcipher(tfm, enc, template, tcount, true,
1198                                       alignmask + 1);
1199                 if (ret)
1200                         return ret;
1201         }
1202
1203         return 0;
1204 }
1205
1206 static int test_comp(struct crypto_comp *tfm, struct comp_testvec *ctemplate,
1207                      struct comp_testvec *dtemplate, int ctcount, int dtcount)
1208 {
1209         const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
1210         unsigned int i;
1211         char result[COMP_BUF_SIZE];
1212         int ret;
1213
1214         for (i = 0; i < ctcount; i++) {
1215                 int ilen;
1216                 unsigned int dlen = COMP_BUF_SIZE;
1217
1218                 memset(result, 0, sizeof (result));
1219
1220                 ilen = ctemplate[i].inlen;
1221                 ret = crypto_comp_compress(tfm, ctemplate[i].input,
1222                                            ilen, result, &dlen);
1223                 if (ret) {
1224                         printk(KERN_ERR "alg: comp: compression failed "
1225                                "on test %d for %s: ret=%d\n", i + 1, algo,
1226                                -ret);
1227                         goto out;
1228                 }
1229
1230                 if (dlen != ctemplate[i].outlen) {
1231                         printk(KERN_ERR "alg: comp: Compression test %d "
1232                                "failed for %s: output len = %d\n", i + 1, algo,
1233                                dlen);
1234                         ret = -EINVAL;
1235                         goto out;
1236                 }
1237
1238                 if (memcmp(result, ctemplate[i].output, dlen)) {
1239                         printk(KERN_ERR "alg: comp: Compression test %d "
1240                                "failed for %s\n", i + 1, algo);
1241                         hexdump(result, dlen);
1242                         ret = -EINVAL;
1243                         goto out;
1244                 }
1245         }
1246
1247         for (i = 0; i < dtcount; i++) {
1248                 int ilen;
1249                 unsigned int dlen = COMP_BUF_SIZE;
1250
1251                 memset(result, 0, sizeof (result));
1252
1253                 ilen = dtemplate[i].inlen;
1254                 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
1255                                              ilen, result, &dlen);
1256                 if (ret) {
1257                         printk(KERN_ERR "alg: comp: decompression failed "
1258                                "on test %d for %s: ret=%d\n", i + 1, algo,
1259                                -ret);
1260                         goto out;
1261                 }
1262
1263                 if (dlen != dtemplate[i].outlen) {
1264                         printk(KERN_ERR "alg: comp: Decompression test %d "
1265                                "failed for %s: output len = %d\n", i + 1, algo,
1266                                dlen);
1267                         ret = -EINVAL;
1268                         goto out;
1269                 }
1270
1271                 if (memcmp(result, dtemplate[i].output, dlen)) {
1272                         printk(KERN_ERR "alg: comp: Decompression test %d "
1273                                "failed for %s\n", i + 1, algo);
1274                         hexdump(result, dlen);
1275                         ret = -EINVAL;
1276                         goto out;
1277                 }
1278         }
1279
1280         ret = 0;
1281
1282 out:
1283         return ret;
1284 }
1285
1286 static int test_pcomp(struct crypto_pcomp *tfm,
1287                       struct pcomp_testvec *ctemplate,
1288                       struct pcomp_testvec *dtemplate, int ctcount,
1289                       int dtcount)
1290 {
1291         const char *algo = crypto_tfm_alg_driver_name(crypto_pcomp_tfm(tfm));
1292         unsigned int i;
1293         char result[COMP_BUF_SIZE];
1294         int res;
1295
1296         for (i = 0; i < ctcount; i++) {
1297                 struct comp_request req;
1298                 unsigned int produced = 0;
1299
1300                 res = crypto_compress_setup(tfm, ctemplate[i].params,
1301                                             ctemplate[i].paramsize);
1302                 if (res) {
1303                         pr_err("alg: pcomp: compression setup failed on test "
1304                                "%d for %s: error=%d\n", i + 1, algo, res);
1305                         return res;
1306                 }
1307
1308                 res = crypto_compress_init(tfm);
1309                 if (res) {
1310                         pr_err("alg: pcomp: compression init failed on test "
1311                                "%d for %s: error=%d\n", i + 1, algo, res);
1312                         return res;
1313                 }
1314
1315                 memset(result, 0, sizeof(result));
1316
1317                 req.next_in = ctemplate[i].input;
1318                 req.avail_in = ctemplate[i].inlen / 2;
1319                 req.next_out = result;
1320                 req.avail_out = ctemplate[i].outlen / 2;
1321
1322                 res = crypto_compress_update(tfm, &req);
1323                 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1324                         pr_err("alg: pcomp: compression update failed on test "
1325                                "%d for %s: error=%d\n", i + 1, algo, res);
1326                         return res;
1327                 }
1328                 if (res > 0)
1329                         produced += res;
1330
1331                 /* Add remaining input data */
1332                 req.avail_in += (ctemplate[i].inlen + 1) / 2;
1333
1334                 res = crypto_compress_update(tfm, &req);
1335                 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1336                         pr_err("alg: pcomp: compression update failed on test "
1337                                "%d for %s: error=%d\n", i + 1, algo, res);
1338                         return res;
1339                 }
1340                 if (res > 0)
1341                         produced += res;
1342
1343                 /* Provide remaining output space */
1344                 req.avail_out += COMP_BUF_SIZE - ctemplate[i].outlen / 2;
1345
1346                 res = crypto_compress_final(tfm, &req);
1347                 if (res < 0) {
1348                         pr_err("alg: pcomp: compression final failed on test "
1349                                "%d for %s: error=%d\n", i + 1, algo, res);
1350                         return res;
1351                 }
1352                 produced += res;
1353
1354                 if (COMP_BUF_SIZE - req.avail_out != ctemplate[i].outlen) {
1355                         pr_err("alg: comp: Compression test %d failed for %s: "
1356                                "output len = %d (expected %d)\n", i + 1, algo,
1357                                COMP_BUF_SIZE - req.avail_out,
1358                                ctemplate[i].outlen);
1359                         return -EINVAL;
1360                 }
1361
1362                 if (produced != ctemplate[i].outlen) {
1363                         pr_err("alg: comp: Compression test %d failed for %s: "
1364                                "returned len = %u (expected %d)\n", i + 1,
1365                                algo, produced, ctemplate[i].outlen);
1366                         return -EINVAL;
1367                 }
1368
1369                 if (memcmp(result, ctemplate[i].output, ctemplate[i].outlen)) {
1370                         pr_err("alg: pcomp: Compression test %d failed for "
1371                                "%s\n", i + 1, algo);
1372                         hexdump(result, ctemplate[i].outlen);
1373                         return -EINVAL;
1374                 }
1375         }
1376
1377         for (i = 0; i < dtcount; i++) {
1378                 struct comp_request req;
1379                 unsigned int produced = 0;
1380
1381                 res = crypto_decompress_setup(tfm, dtemplate[i].params,
1382                                               dtemplate[i].paramsize);
1383                 if (res) {
1384                         pr_err("alg: pcomp: decompression setup failed on "
1385                                "test %d for %s: error=%d\n", i + 1, algo, res);
1386                         return res;
1387                 }
1388
1389                 res = crypto_decompress_init(tfm);
1390                 if (res) {
1391                         pr_err("alg: pcomp: decompression init failed on test "
1392                                "%d for %s: error=%d\n", i + 1, algo, res);
1393                         return res;
1394                 }
1395
1396                 memset(result, 0, sizeof(result));
1397
1398                 req.next_in = dtemplate[i].input;
1399                 req.avail_in = dtemplate[i].inlen / 2;
1400                 req.next_out = result;
1401                 req.avail_out = dtemplate[i].outlen / 2;
1402
1403                 res = crypto_decompress_update(tfm, &req);
1404                 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1405                         pr_err("alg: pcomp: decompression update failed on "
1406                                "test %d for %s: error=%d\n", i + 1, algo, res);
1407                         return res;
1408                 }
1409                 if (res > 0)
1410                         produced += res;
1411
1412                 /* Add remaining input data */
1413                 req.avail_in += (dtemplate[i].inlen + 1) / 2;
1414
1415                 res = crypto_decompress_update(tfm, &req);
1416                 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1417                         pr_err("alg: pcomp: decompression update failed on "
1418                                "test %d for %s: error=%d\n", i + 1, algo, res);
1419                         return res;
1420                 }
1421                 if (res > 0)
1422                         produced += res;
1423
1424                 /* Provide remaining output space */
1425                 req.avail_out += COMP_BUF_SIZE - dtemplate[i].outlen / 2;
1426
1427                 res = crypto_decompress_final(tfm, &req);
1428                 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1429                         pr_err("alg: pcomp: decompression final failed on "
1430                                "test %d for %s: error=%d\n", i + 1, algo, res);
1431                         return res;
1432                 }
1433                 if (res > 0)
1434                         produced += res;
1435
1436                 if (COMP_BUF_SIZE - req.avail_out != dtemplate[i].outlen) {
1437                         pr_err("alg: comp: Decompression test %d failed for "
1438                                "%s: output len = %d (expected %d)\n", i + 1,
1439                                algo, COMP_BUF_SIZE - req.avail_out,
1440                                dtemplate[i].outlen);
1441                         return -EINVAL;
1442                 }
1443
1444                 if (produced != dtemplate[i].outlen) {
1445                         pr_err("alg: comp: Decompression test %d failed for "
1446                                "%s: returned len = %u (expected %d)\n", i + 1,
1447                                algo, produced, dtemplate[i].outlen);
1448                         return -EINVAL;
1449                 }
1450
1451                 if (memcmp(result, dtemplate[i].output, dtemplate[i].outlen)) {
1452                         pr_err("alg: pcomp: Decompression test %d failed for "
1453                                "%s\n", i + 1, algo);
1454                         hexdump(result, dtemplate[i].outlen);
1455                         return -EINVAL;
1456                 }
1457         }
1458
1459         return 0;
1460 }
1461
1462
1463 static int test_cprng(struct crypto_rng *tfm, struct cprng_testvec *template,
1464                       unsigned int tcount)
1465 {
1466         const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm));
1467         int err = 0, i, j, seedsize;
1468         u8 *seed;
1469         char result[32];
1470
1471         seedsize = crypto_rng_seedsize(tfm);
1472
1473         seed = kmalloc(seedsize, GFP_KERNEL);
1474         if (!seed) {
1475                 printk(KERN_ERR "alg: cprng: Failed to allocate seed space "
1476                        "for %s\n", algo);
1477                 return -ENOMEM;
1478         }
1479
1480         for (i = 0; i < tcount; i++) {
1481                 memset(result, 0, 32);
1482
1483                 memcpy(seed, template[i].v, template[i].vlen);
1484                 memcpy(seed + template[i].vlen, template[i].key,
1485                        template[i].klen);
1486                 memcpy(seed + template[i].vlen + template[i].klen,
1487                        template[i].dt, template[i].dtlen);
1488
1489                 err = crypto_rng_reset(tfm, seed, seedsize);
1490                 if (err) {
1491                         printk(KERN_ERR "alg: cprng: Failed to reset rng "
1492                                "for %s\n", algo);
1493                         goto out;
1494                 }
1495
1496                 for (j = 0; j < template[i].loops; j++) {
1497                         err = crypto_rng_get_bytes(tfm, result,
1498                                                    template[i].rlen);
1499                         if (err < 0) {
1500                                 printk(KERN_ERR "alg: cprng: Failed to obtain "
1501                                        "the correct amount of random data for "
1502                                        "%s (requested %d)\n", algo,
1503                                        template[i].rlen);
1504                                 goto out;
1505                         }
1506                 }
1507
1508                 err = memcmp(result, template[i].result,
1509                              template[i].rlen);
1510                 if (err) {
1511                         printk(KERN_ERR "alg: cprng: Test %d failed for %s\n",
1512                                i, algo);
1513                         hexdump(result, template[i].rlen);
1514                         err = -EINVAL;
1515                         goto out;
1516                 }
1517         }
1518
1519 out:
1520         kfree(seed);
1521         return err;
1522 }
1523
1524 static int alg_test_aead(const struct alg_test_desc *desc, const char *driver,
1525                          u32 type, u32 mask)
1526 {
1527         struct crypto_aead *tfm;
1528         int err = 0;
1529
1530         tfm = crypto_alloc_aead(driver, type | CRYPTO_ALG_INTERNAL, mask);
1531         if (IS_ERR(tfm)) {
1532                 printk(KERN_ERR "alg: aead: Failed to load transform for %s: "
1533                        "%ld\n", driver, PTR_ERR(tfm));
1534                 return PTR_ERR(tfm);
1535         }
1536
1537         if (desc->suite.aead.enc.vecs) {
1538                 err = test_aead(tfm, ENCRYPT, desc->suite.aead.enc.vecs,
1539                                 desc->suite.aead.enc.count);
1540                 if (err)
1541                         goto out;
1542         }
1543
1544         if (!err && desc->suite.aead.dec.vecs)
1545                 err = test_aead(tfm, DECRYPT, desc->suite.aead.dec.vecs,
1546                                 desc->suite.aead.dec.count);
1547
1548 out:
1549         crypto_free_aead(tfm);
1550         return err;
1551 }
1552
1553 static int alg_test_cipher(const struct alg_test_desc *desc,
1554                            const char *driver, u32 type, u32 mask)
1555 {
1556         struct crypto_cipher *tfm;
1557         int err = 0;
1558
1559         tfm = crypto_alloc_cipher(driver, type | CRYPTO_ALG_INTERNAL, mask);
1560         if (IS_ERR(tfm)) {
1561                 printk(KERN_ERR "alg: cipher: Failed to load transform for "
1562                        "%s: %ld\n", driver, PTR_ERR(tfm));
1563                 return PTR_ERR(tfm);
1564         }
1565
1566         if (desc->suite.cipher.enc.vecs) {
1567                 err = test_cipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1568                                   desc->suite.cipher.enc.count);
1569                 if (err)
1570                         goto out;
1571         }
1572
1573         if (desc->suite.cipher.dec.vecs)
1574                 err = test_cipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1575                                   desc->suite.cipher.dec.count);
1576
1577 out:
1578         crypto_free_cipher(tfm);
1579         return err;
1580 }
1581
1582 static int alg_test_skcipher(const struct alg_test_desc *desc,
1583                              const char *driver, u32 type, u32 mask)
1584 {
1585         struct crypto_skcipher *tfm;
1586         int err = 0;
1587
1588         tfm = crypto_alloc_skcipher(driver, type | CRYPTO_ALG_INTERNAL, mask);
1589         if (IS_ERR(tfm)) {
1590                 printk(KERN_ERR "alg: skcipher: Failed to load transform for "
1591                        "%s: %ld\n", driver, PTR_ERR(tfm));
1592                 return PTR_ERR(tfm);
1593         }
1594
1595         if (desc->suite.cipher.enc.vecs) {
1596                 err = test_skcipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1597                                     desc->suite.cipher.enc.count);
1598                 if (err)
1599                         goto out;
1600         }
1601
1602         if (desc->suite.cipher.dec.vecs)
1603                 err = test_skcipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1604                                     desc->suite.cipher.dec.count);
1605
1606 out:
1607         crypto_free_skcipher(tfm);
1608         return err;
1609 }
1610
1611 static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
1612                          u32 type, u32 mask)
1613 {
1614         struct crypto_comp *tfm;
1615         int err;
1616
1617         tfm = crypto_alloc_comp(driver, type, mask);
1618         if (IS_ERR(tfm)) {
1619                 printk(KERN_ERR "alg: comp: Failed to load transform for %s: "
1620                        "%ld\n", driver, PTR_ERR(tfm));
1621                 return PTR_ERR(tfm);
1622         }
1623
1624         err = test_comp(tfm, desc->suite.comp.comp.vecs,
1625                         desc->suite.comp.decomp.vecs,
1626                         desc->suite.comp.comp.count,
1627                         desc->suite.comp.decomp.count);
1628
1629         crypto_free_comp(tfm);
1630         return err;
1631 }
1632
1633 static int alg_test_pcomp(const struct alg_test_desc *desc, const char *driver,
1634                           u32 type, u32 mask)
1635 {
1636         struct crypto_pcomp *tfm;
1637         int err;
1638
1639         tfm = crypto_alloc_pcomp(driver, type, mask);
1640         if (IS_ERR(tfm)) {
1641                 pr_err("alg: pcomp: Failed to load transform for %s: %ld\n",
1642                        driver, PTR_ERR(tfm));
1643                 return PTR_ERR(tfm);
1644         }
1645
1646         err = test_pcomp(tfm, desc->suite.pcomp.comp.vecs,
1647                          desc->suite.pcomp.decomp.vecs,
1648                          desc->suite.pcomp.comp.count,
1649                          desc->suite.pcomp.decomp.count);
1650
1651         crypto_free_pcomp(tfm);
1652         return err;
1653 }
1654
1655 static int alg_test_hash(const struct alg_test_desc *desc, const char *driver,
1656                          u32 type, u32 mask)
1657 {
1658         struct crypto_ahash *tfm;
1659         int err;
1660
1661         tfm = crypto_alloc_ahash(driver, type | CRYPTO_ALG_INTERNAL, mask);
1662         if (IS_ERR(tfm)) {
1663                 printk(KERN_ERR "alg: hash: Failed to load transform for %s: "
1664                        "%ld\n", driver, PTR_ERR(tfm));
1665                 return PTR_ERR(tfm);
1666         }
1667
1668         err = test_hash(tfm, desc->suite.hash.vecs,
1669                         desc->suite.hash.count, true);
1670         if (!err)
1671                 err = test_hash(tfm, desc->suite.hash.vecs,
1672                                 desc->suite.hash.count, false);
1673
1674         crypto_free_ahash(tfm);
1675         return err;
1676 }
1677
1678 static int alg_test_crc32c(const struct alg_test_desc *desc,
1679                            const char *driver, u32 type, u32 mask)
1680 {
1681         struct crypto_shash *tfm;
1682         u32 val;
1683         int err;
1684
1685         err = alg_test_hash(desc, driver, type, mask);
1686         if (err)
1687                 goto out;
1688
1689         tfm = crypto_alloc_shash(driver, type | CRYPTO_ALG_INTERNAL, mask);
1690         if (IS_ERR(tfm)) {
1691                 printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: "
1692                        "%ld\n", driver, PTR_ERR(tfm));
1693                 err = PTR_ERR(tfm);
1694                 goto out;
1695         }
1696
1697         do {
1698                 SHASH_DESC_ON_STACK(shash, tfm);
1699                 u32 *ctx = (u32 *)shash_desc_ctx(shash);
1700
1701                 shash->tfm = tfm;
1702                 shash->flags = 0;
1703
1704                 *ctx = le32_to_cpu(420553207);
1705                 err = crypto_shash_final(shash, (u8 *)&val);
1706                 if (err) {
1707                         printk(KERN_ERR "alg: crc32c: Operation failed for "
1708                                "%s: %d\n", driver, err);
1709                         break;
1710                 }
1711
1712                 if (val != ~420553207) {
1713                         printk(KERN_ERR "alg: crc32c: Test failed for %s: "
1714                                "%d\n", driver, val);
1715                         err = -EINVAL;
1716                 }
1717         } while (0);
1718
1719         crypto_free_shash(tfm);
1720
1721 out:
1722         return err;
1723 }
1724
1725 static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver,
1726                           u32 type, u32 mask)
1727 {
1728         struct crypto_rng *rng;
1729         int err;
1730
1731         rng = crypto_alloc_rng(driver, type | CRYPTO_ALG_INTERNAL, mask);
1732         if (IS_ERR(rng)) {
1733                 printk(KERN_ERR "alg: cprng: Failed to load transform for %s: "
1734                        "%ld\n", driver, PTR_ERR(rng));
1735                 return PTR_ERR(rng);
1736         }
1737
1738         err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count);
1739
1740         crypto_free_rng(rng);
1741
1742         return err;
1743 }
1744
1745
1746 static int drbg_cavs_test(struct drbg_testvec *test, int pr,
1747                           const char *driver, u32 type, u32 mask)
1748 {
1749         int ret = -EAGAIN;
1750         struct crypto_rng *drng;
1751         struct drbg_test_data test_data;
1752         struct drbg_string addtl, pers, testentropy;
1753         unsigned char *buf = kzalloc(test->expectedlen, GFP_KERNEL);
1754
1755         if (!buf)
1756                 return -ENOMEM;
1757
1758         drng = crypto_alloc_rng(driver, type | CRYPTO_ALG_INTERNAL, mask);
1759         if (IS_ERR(drng)) {
1760                 printk(KERN_ERR "alg: drbg: could not allocate DRNG handle for "
1761                        "%s\n", driver);
1762                 kzfree(buf);
1763                 return -ENOMEM;
1764         }
1765
1766         test_data.testentropy = &testentropy;
1767         drbg_string_fill(&testentropy, test->entropy, test->entropylen);
1768         drbg_string_fill(&pers, test->pers, test->perslen);
1769         ret = crypto_drbg_reset_test(drng, &pers, &test_data);
1770         if (ret) {
1771                 printk(KERN_ERR "alg: drbg: Failed to reset rng\n");
1772                 goto outbuf;
1773         }
1774
1775         drbg_string_fill(&addtl, test->addtla, test->addtllen);
1776         if (pr) {
1777                 drbg_string_fill(&testentropy, test->entpra, test->entprlen);
1778                 ret = crypto_drbg_get_bytes_addtl_test(drng,
1779                         buf, test->expectedlen, &addtl, &test_data);
1780         } else {
1781                 ret = crypto_drbg_get_bytes_addtl(drng,
1782                         buf, test->expectedlen, &addtl);
1783         }
1784         if (ret < 0) {
1785                 printk(KERN_ERR "alg: drbg: could not obtain random data for "
1786                        "driver %s\n", driver);
1787                 goto outbuf;
1788         }
1789
1790         drbg_string_fill(&addtl, test->addtlb, test->addtllen);
1791         if (pr) {
1792                 drbg_string_fill(&testentropy, test->entprb, test->entprlen);
1793                 ret = crypto_drbg_get_bytes_addtl_test(drng,
1794                         buf, test->expectedlen, &addtl, &test_data);
1795         } else {
1796                 ret = crypto_drbg_get_bytes_addtl(drng,
1797                         buf, test->expectedlen, &addtl);
1798         }
1799         if (ret < 0) {
1800                 printk(KERN_ERR "alg: drbg: could not obtain random data for "
1801                        "driver %s\n", driver);
1802                 goto outbuf;
1803         }
1804
1805         ret = memcmp(test->expected, buf, test->expectedlen);
1806
1807 outbuf:
1808         crypto_free_rng(drng);
1809         kzfree(buf);
1810         return ret;
1811 }
1812
1813
1814 static int alg_test_drbg(const struct alg_test_desc *desc, const char *driver,
1815                          u32 type, u32 mask)
1816 {
1817         int err = 0;
1818         int pr = 0;
1819         int i = 0;
1820         struct drbg_testvec *template = desc->suite.drbg.vecs;
1821         unsigned int tcount = desc->suite.drbg.count;
1822
1823         if (0 == memcmp(driver, "drbg_pr_", 8))
1824                 pr = 1;
1825
1826         for (i = 0; i < tcount; i++) {
1827                 err = drbg_cavs_test(&template[i], pr, driver, type, mask);
1828                 if (err) {
1829                         printk(KERN_ERR "alg: drbg: Test %d failed for %s\n",
1830                                i, driver);
1831                         err = -EINVAL;
1832                         break;
1833                 }
1834         }
1835         return err;
1836
1837 }
1838
1839 static int do_test_rsa(struct crypto_akcipher *tfm,
1840                        struct akcipher_testvec *vecs)
1841 {
1842         struct akcipher_request *req;
1843         void *outbuf_enc = NULL;
1844         void *outbuf_dec = NULL;
1845         struct tcrypt_result result;
1846         unsigned int out_len_max, out_len = 0;
1847         int err = -ENOMEM;
1848
1849         req = akcipher_request_alloc(tfm, GFP_KERNEL);
1850         if (!req)
1851                 return err;
1852
1853         init_completion(&result.completion);
1854         err = crypto_akcipher_setkey(tfm, vecs->key, vecs->key_len);
1855         if (err)
1856                 goto free_req;
1857
1858         akcipher_request_set_crypt(req, vecs->m, outbuf_enc, vecs->m_size,
1859                                    out_len);
1860         /* expect this to fail, and update the required buf len */
1861         crypto_akcipher_encrypt(req);
1862         out_len = req->dst_len;
1863         if (!out_len) {
1864                 err = -EINVAL;
1865                 goto free_req;
1866         }
1867
1868         out_len_max = out_len;
1869         err = -ENOMEM;
1870         outbuf_enc = kzalloc(out_len_max, GFP_KERNEL);
1871         if (!outbuf_enc)
1872                 goto free_req;
1873
1874         akcipher_request_set_crypt(req, vecs->m, outbuf_enc, vecs->m_size,
1875                                    out_len);
1876         akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1877                                       tcrypt_complete, &result);
1878
1879         /* Run RSA encrypt - c = m^e mod n;*/
1880         err = wait_async_op(&result, crypto_akcipher_encrypt(req));
1881         if (err) {
1882                 pr_err("alg: rsa: encrypt test failed. err %d\n", err);
1883                 goto free_all;
1884         }
1885         if (out_len != vecs->c_size) {
1886                 pr_err("alg: rsa: encrypt test failed. Invalid output len\n");
1887                 err = -EINVAL;
1888                 goto free_all;
1889         }
1890         /* verify that encrypted message is equal to expected */
1891         if (memcmp(vecs->c, outbuf_enc, vecs->c_size)) {
1892                 pr_err("alg: rsa: encrypt test failed. Invalid output\n");
1893                 err = -EINVAL;
1894                 goto free_all;
1895         }
1896         /* Don't invoke decrypt for vectors with public key */
1897         if (vecs->public_key_vec) {
1898                 err = 0;
1899                 goto free_all;
1900         }
1901         outbuf_dec = kzalloc(out_len_max, GFP_KERNEL);
1902         if (!outbuf_dec) {
1903                 err = -ENOMEM;
1904                 goto free_all;
1905         }
1906         init_completion(&result.completion);
1907         akcipher_request_set_crypt(req, outbuf_enc, outbuf_dec, vecs->c_size,
1908                                    out_len);
1909
1910         /* Run RSA decrypt - m = c^d mod n;*/
1911         err = wait_async_op(&result, crypto_akcipher_decrypt(req));
1912         if (err) {
1913                 pr_err("alg: rsa: decrypt test failed. err %d\n", err);
1914                 goto free_all;
1915         }
1916         out_len = req->dst_len;
1917         if (out_len != vecs->m_size) {
1918                 pr_err("alg: rsa: decrypt test failed. Invalid output len\n");
1919                 err = -EINVAL;
1920                 goto free_all;
1921         }
1922         /* verify that decrypted message is equal to the original msg */
1923         if (memcmp(vecs->m, outbuf_dec, vecs->m_size)) {
1924                 pr_err("alg: rsa: decrypt test failed. Invalid output\n");
1925                 err = -EINVAL;
1926         }
1927 free_all:
1928         kfree(outbuf_dec);
1929         kfree(outbuf_enc);
1930 free_req:
1931         akcipher_request_free(req);
1932         return err;
1933 }
1934
1935 static int test_rsa(struct crypto_akcipher *tfm, struct akcipher_testvec *vecs,
1936                     unsigned int tcount)
1937 {
1938         int ret, i;
1939
1940         for (i = 0; i < tcount; i++) {
1941                 ret = do_test_rsa(tfm, vecs++);
1942                 if (ret) {
1943                         pr_err("alg: rsa: test failed on vector %d, err=%d\n",
1944                                i + 1, ret);
1945                         return ret;
1946                 }
1947         }
1948         return 0;
1949 }
1950
1951 static int test_akcipher(struct crypto_akcipher *tfm, const char *alg,
1952                          struct akcipher_testvec *vecs, unsigned int tcount)
1953 {
1954         if (strncmp(alg, "rsa", 3) == 0)
1955                 return test_rsa(tfm, vecs, tcount);
1956
1957         return 0;
1958 }
1959
1960 static int alg_test_akcipher(const struct alg_test_desc *desc,
1961                              const char *driver, u32 type, u32 mask)
1962 {
1963         struct crypto_akcipher *tfm;
1964         int err = 0;
1965
1966         tfm = crypto_alloc_akcipher(driver, type | CRYPTO_ALG_INTERNAL, mask);
1967         if (IS_ERR(tfm)) {
1968                 pr_err("alg: akcipher: Failed to load tfm for %s: %ld\n",
1969                        driver, PTR_ERR(tfm));
1970                 return PTR_ERR(tfm);
1971         }
1972         if (desc->suite.akcipher.vecs)
1973                 err = test_akcipher(tfm, desc->alg, desc->suite.akcipher.vecs,
1974                                     desc->suite.akcipher.count);
1975
1976         crypto_free_akcipher(tfm);
1977         return err;
1978 }
1979
1980 static int alg_test_null(const struct alg_test_desc *desc,
1981                              const char *driver, u32 type, u32 mask)
1982 {
1983         return 0;
1984 }
1985
1986 /* Please keep this list sorted by algorithm name. */
1987 static const struct alg_test_desc alg_test_descs[] = {
1988         {
1989                 .alg = "__cbc-cast5-avx",
1990                 .test = alg_test_null,
1991         }, {
1992                 .alg = "__cbc-cast6-avx",
1993                 .test = alg_test_null,
1994         }, {
1995                 .alg = "__cbc-serpent-avx",
1996                 .test = alg_test_null,
1997         }, {
1998                 .alg = "__cbc-serpent-avx2",
1999                 .test = alg_test_null,
2000         }, {
2001                 .alg = "__cbc-serpent-sse2",
2002                 .test = alg_test_null,
2003         }, {
2004                 .alg = "__cbc-twofish-avx",
2005                 .test = alg_test_null,
2006         }, {
2007                 .alg = "__driver-cbc-aes-aesni",
2008                 .test = alg_test_null,
2009                 .fips_allowed = 1,
2010         }, {
2011                 .alg = "__driver-cbc-camellia-aesni",
2012                 .test = alg_test_null,
2013         }, {
2014                 .alg = "__driver-cbc-camellia-aesni-avx2",
2015                 .test = alg_test_null,
2016         }, {
2017                 .alg = "__driver-cbc-cast5-avx",
2018                 .test = alg_test_null,
2019         }, {
2020                 .alg = "__driver-cbc-cast6-avx",
2021                 .test = alg_test_null,
2022         }, {
2023                 .alg = "__driver-cbc-serpent-avx",
2024                 .test = alg_test_null,
2025         }, {
2026                 .alg = "__driver-cbc-serpent-avx2",
2027                 .test = alg_test_null,
2028         }, {
2029                 .alg = "__driver-cbc-serpent-sse2",
2030                 .test = alg_test_null,
2031         }, {
2032                 .alg = "__driver-cbc-twofish-avx",
2033                 .test = alg_test_null,
2034         }, {
2035                 .alg = "__driver-ecb-aes-aesni",
2036                 .test = alg_test_null,
2037                 .fips_allowed = 1,
2038         }, {
2039                 .alg = "__driver-ecb-camellia-aesni",
2040                 .test = alg_test_null,
2041         }, {
2042                 .alg = "__driver-ecb-camellia-aesni-avx2",
2043                 .test = alg_test_null,
2044         }, {
2045                 .alg = "__driver-ecb-cast5-avx",
2046                 .test = alg_test_null,
2047         }, {
2048                 .alg = "__driver-ecb-cast6-avx",
2049                 .test = alg_test_null,
2050         }, {
2051                 .alg = "__driver-ecb-serpent-avx",
2052                 .test = alg_test_null,
2053         }, {
2054                 .alg = "__driver-ecb-serpent-avx2",
2055                 .test = alg_test_null,
2056         }, {
2057                 .alg = "__driver-ecb-serpent-sse2",
2058                 .test = alg_test_null,
2059         }, {
2060                 .alg = "__driver-ecb-twofish-avx",
2061                 .test = alg_test_null,
2062         }, {
2063                 .alg = "__driver-gcm-aes-aesni",
2064                 .test = alg_test_null,
2065                 .fips_allowed = 1,
2066         }, {
2067                 .alg = "__ghash-pclmulqdqni",
2068                 .test = alg_test_null,
2069                 .fips_allowed = 1,
2070         }, {
2071                 .alg = "ansi_cprng",
2072                 .test = alg_test_cprng,
2073                 .fips_allowed = 1,
2074                 .suite = {
2075                         .cprng = {
2076                                 .vecs = ansi_cprng_aes_tv_template,
2077                                 .count = ANSI_CPRNG_AES_TEST_VECTORS
2078                         }
2079                 }
2080         }, {
2081                 .alg = "authenc(hmac(md5),ecb(cipher_null))",
2082                 .test = alg_test_aead,
2083                 .fips_allowed = 1,
2084                 .suite = {
2085                         .aead = {
2086                                 .enc = {
2087                                         .vecs = hmac_md5_ecb_cipher_null_enc_tv_template,
2088                                         .count = HMAC_MD5_ECB_CIPHER_NULL_ENC_TEST_VECTORS
2089                                 },
2090                                 .dec = {
2091                                         .vecs = hmac_md5_ecb_cipher_null_dec_tv_template,
2092                                         .count = HMAC_MD5_ECB_CIPHER_NULL_DEC_TEST_VECTORS
2093                                 }
2094                         }
2095                 }
2096         }, {
2097                 .alg = "authenc(hmac(sha1),cbc(aes))",
2098                 .test = alg_test_aead,
2099                 .fips_allowed = 1,
2100                 .suite = {
2101                         .aead = {
2102                                 .enc = {
2103                                         .vecs =
2104                                         hmac_sha1_aes_cbc_enc_tv_temp,
2105                                         .count =
2106                                         HMAC_SHA1_AES_CBC_ENC_TEST_VEC
2107                                 }
2108                         }
2109                 }
2110         }, {
2111                 .alg = "authenc(hmac(sha1),cbc(des))",
2112                 .test = alg_test_aead,
2113                 .fips_allowed = 1,
2114                 .suite = {
2115                         .aead = {
2116                                 .enc = {
2117                                         .vecs =
2118                                         hmac_sha1_des_cbc_enc_tv_temp,
2119                                         .count =
2120                                         HMAC_SHA1_DES_CBC_ENC_TEST_VEC
2121                                 }
2122                         }
2123                 }
2124         }, {
2125                 .alg = "authenc(hmac(sha1),cbc(des3_ede))",
2126                 .test = alg_test_aead,
2127                 .fips_allowed = 1,
2128                 .suite = {
2129                         .aead = {
2130                                 .enc = {
2131                                         .vecs =
2132                                         hmac_sha1_des3_ede_cbc_enc_tv_temp,
2133                                         .count =
2134                                         HMAC_SHA1_DES3_EDE_CBC_ENC_TEST_VEC
2135                                 }
2136                         }
2137                 }
2138         }, {
2139                 .alg = "authenc(hmac(sha1),ecb(cipher_null))",
2140                 .test = alg_test_aead,
2141                 .fips_allowed = 1,
2142                 .suite = {
2143                         .aead = {
2144                                 .enc = {
2145                                         .vecs =
2146                                         hmac_sha1_ecb_cipher_null_enc_tv_temp,
2147                                         .count =
2148                                         HMAC_SHA1_ECB_CIPHER_NULL_ENC_TEST_VEC
2149                                 },
2150                                 .dec = {
2151                                         .vecs =
2152                                         hmac_sha1_ecb_cipher_null_dec_tv_temp,
2153                                         .count =
2154                                         HMAC_SHA1_ECB_CIPHER_NULL_DEC_TEST_VEC
2155                                 }
2156                         }
2157                 }
2158         }, {
2159                 .alg = "authenc(hmac(sha224),cbc(des))",
2160                 .test = alg_test_aead,
2161                 .fips_allowed = 1,
2162                 .suite = {
2163                         .aead = {
2164                                 .enc = {
2165                                         .vecs =
2166                                         hmac_sha224_des_cbc_enc_tv_temp,
2167                                         .count =
2168                                         HMAC_SHA224_DES_CBC_ENC_TEST_VEC
2169                                 }
2170                         }
2171                 }
2172         }, {
2173                 .alg = "authenc(hmac(sha224),cbc(des3_ede))",
2174                 .test = alg_test_aead,
2175                 .fips_allowed = 1,
2176                 .suite = {
2177                         .aead = {
2178                                 .enc = {
2179                                         .vecs =
2180                                         hmac_sha224_des3_ede_cbc_enc_tv_temp,
2181                                         .count =
2182                                         HMAC_SHA224_DES3_EDE_CBC_ENC_TEST_VEC
2183                                 }
2184                         }
2185                 }
2186         }, {
2187                 .alg = "authenc(hmac(sha256),cbc(aes))",
2188                 .test = alg_test_aead,
2189                 .fips_allowed = 1,
2190                 .suite = {
2191                         .aead = {
2192                                 .enc = {
2193                                         .vecs =
2194                                         hmac_sha256_aes_cbc_enc_tv_temp,
2195                                         .count =
2196                                         HMAC_SHA256_AES_CBC_ENC_TEST_VEC
2197                                 }
2198                         }
2199                 }
2200         }, {
2201                 .alg = "authenc(hmac(sha256),cbc(des))",
2202                 .test = alg_test_aead,
2203                 .fips_allowed = 1,
2204                 .suite = {
2205                         .aead = {
2206                                 .enc = {
2207                                         .vecs =
2208                                         hmac_sha256_des_cbc_enc_tv_temp,
2209                                         .count =
2210                                         HMAC_SHA256_DES_CBC_ENC_TEST_VEC
2211                                 }
2212                         }
2213                 }
2214         }, {
2215                 .alg = "authenc(hmac(sha256),cbc(des3_ede))",
2216                 .test = alg_test_aead,
2217                 .fips_allowed = 1,
2218                 .suite = {
2219                         .aead = {
2220                                 .enc = {
2221                                         .vecs =
2222                                         hmac_sha256_des3_ede_cbc_enc_tv_temp,
2223                                         .count =
2224                                         HMAC_SHA256_DES3_EDE_CBC_ENC_TEST_VEC
2225                                 }
2226                         }
2227                 }
2228         }, {
2229                 .alg = "authenc(hmac(sha384),cbc(des))",
2230                 .test = alg_test_aead,
2231                 .fips_allowed = 1,
2232                 .suite = {
2233                         .aead = {
2234                                 .enc = {
2235                                         .vecs =
2236                                         hmac_sha384_des_cbc_enc_tv_temp,
2237                                         .count =
2238                                         HMAC_SHA384_DES_CBC_ENC_TEST_VEC
2239                                 }
2240                         }
2241                 }
2242         }, {
2243                 .alg = "authenc(hmac(sha384),cbc(des3_ede))",
2244                 .test = alg_test_aead,
2245                 .fips_allowed = 1,
2246                 .suite = {
2247                         .aead = {
2248                                 .enc = {
2249                                         .vecs =
2250                                         hmac_sha384_des3_ede_cbc_enc_tv_temp,
2251                                         .count =
2252                                         HMAC_SHA384_DES3_EDE_CBC_ENC_TEST_VEC
2253                                 }
2254                         }
2255                 }
2256         }, {
2257                 .alg = "authenc(hmac(sha512),cbc(aes))",
2258                 .test = alg_test_aead,
2259                 .fips_allowed = 1,
2260                 .suite = {
2261                         .aead = {
2262                                 .enc = {
2263                                         .vecs =
2264                                         hmac_sha512_aes_cbc_enc_tv_temp,
2265                                         .count =
2266                                         HMAC_SHA512_AES_CBC_ENC_TEST_VEC
2267                                 }
2268                         }
2269                 }
2270         }, {
2271                 .alg = "authenc(hmac(sha512),cbc(des))",
2272                 .test = alg_test_aead,
2273                 .fips_allowed = 1,
2274                 .suite = {
2275                         .aead = {
2276                                 .enc = {
2277                                         .vecs =
2278                                         hmac_sha512_des_cbc_enc_tv_temp,
2279                                         .count =
2280                                         HMAC_SHA512_DES_CBC_ENC_TEST_VEC
2281                                 }
2282                         }
2283                 }
2284         }, {
2285                 .alg = "authenc(hmac(sha512),cbc(des3_ede))",
2286                 .test = alg_test_aead,
2287                 .fips_allowed = 1,
2288                 .suite = {
2289                         .aead = {
2290                                 .enc = {
2291                                         .vecs =
2292                                         hmac_sha512_des3_ede_cbc_enc_tv_temp,
2293                                         .count =
2294                                         HMAC_SHA512_DES3_EDE_CBC_ENC_TEST_VEC
2295                                 }
2296                         }
2297                 }
2298         }, {
2299                 .alg = "cbc(aes)",
2300                 .test = alg_test_skcipher,
2301                 .fips_allowed = 1,
2302                 .suite = {
2303                         .cipher = {
2304                                 .enc = {
2305                                         .vecs = aes_cbc_enc_tv_template,
2306                                         .count = AES_CBC_ENC_TEST_VECTORS
2307                                 },
2308                                 .dec = {
2309                                         .vecs = aes_cbc_dec_tv_template,
2310                                         .count = AES_CBC_DEC_TEST_VECTORS
2311                                 }
2312                         }
2313                 }
2314         }, {
2315                 .alg = "cbc(anubis)",
2316                 .test = alg_test_skcipher,
2317                 .suite = {
2318                         .cipher = {
2319                                 .enc = {
2320                                         .vecs = anubis_cbc_enc_tv_template,
2321                                         .count = ANUBIS_CBC_ENC_TEST_VECTORS
2322                                 },
2323                                 .dec = {
2324                                         .vecs = anubis_cbc_dec_tv_template,
2325                                         .count = ANUBIS_CBC_DEC_TEST_VECTORS
2326                                 }
2327                         }
2328                 }
2329         }, {
2330                 .alg = "cbc(blowfish)",
2331                 .test = alg_test_skcipher,
2332                 .suite = {
2333                         .cipher = {
2334                                 .enc = {
2335                                         .vecs = bf_cbc_enc_tv_template,
2336                                         .count = BF_CBC_ENC_TEST_VECTORS
2337                                 },
2338                                 .dec = {
2339                                         .vecs = bf_cbc_dec_tv_template,
2340                                         .count = BF_CBC_DEC_TEST_VECTORS
2341                                 }
2342                         }
2343                 }
2344         }, {
2345                 .alg = "cbc(camellia)",
2346                 .test = alg_test_skcipher,
2347                 .suite = {
2348                         .cipher = {
2349                                 .enc = {
2350                                         .vecs = camellia_cbc_enc_tv_template,
2351                                         .count = CAMELLIA_CBC_ENC_TEST_VECTORS
2352                                 },
2353                                 .dec = {
2354                                         .vecs = camellia_cbc_dec_tv_template,
2355                                         .count = CAMELLIA_CBC_DEC_TEST_VECTORS
2356                                 }
2357                         }
2358                 }
2359         }, {
2360                 .alg = "cbc(cast5)",
2361                 .test = alg_test_skcipher,
2362                 .suite = {
2363                         .cipher = {
2364                                 .enc = {
2365                                         .vecs = cast5_cbc_enc_tv_template,
2366                                         .count = CAST5_CBC_ENC_TEST_VECTORS
2367                                 },
2368                                 .dec = {
2369                                         .vecs = cast5_cbc_dec_tv_template,
2370                                         .count = CAST5_CBC_DEC_TEST_VECTORS
2371                                 }
2372                         }
2373                 }
2374         }, {
2375                 .alg = "cbc(cast6)",
2376                 .test = alg_test_skcipher,
2377                 .suite = {
2378                         .cipher = {
2379                                 .enc = {
2380                                         .vecs = cast6_cbc_enc_tv_template,
2381                                         .count = CAST6_CBC_ENC_TEST_VECTORS
2382                                 },
2383                                 .dec = {
2384                                         .vecs = cast6_cbc_dec_tv_template,
2385                                         .count = CAST6_CBC_DEC_TEST_VECTORS
2386                                 }
2387                         }
2388                 }
2389         }, {
2390                 .alg = "cbc(des)",
2391                 .test = alg_test_skcipher,
2392                 .suite = {
2393                         .cipher = {
2394                                 .enc = {
2395                                         .vecs = des_cbc_enc_tv_template,
2396                                         .count = DES_CBC_ENC_TEST_VECTORS
2397                                 },
2398                                 .dec = {
2399                                         .vecs = des_cbc_dec_tv_template,
2400                                         .count = DES_CBC_DEC_TEST_VECTORS
2401                                 }
2402                         }
2403                 }
2404         }, {
2405                 .alg = "cbc(des3_ede)",
2406                 .test = alg_test_skcipher,
2407                 .fips_allowed = 1,
2408                 .suite = {
2409                         .cipher = {
2410                                 .enc = {
2411                                         .vecs = des3_ede_cbc_enc_tv_template,
2412                                         .count = DES3_EDE_CBC_ENC_TEST_VECTORS
2413                                 },
2414                                 .dec = {
2415                                         .vecs = des3_ede_cbc_dec_tv_template,
2416                                         .count = DES3_EDE_CBC_DEC_TEST_VECTORS
2417                                 }
2418                         }
2419                 }
2420         }, {
2421                 .alg = "cbc(serpent)",
2422                 .test = alg_test_skcipher,
2423                 .suite = {
2424                         .cipher = {
2425                                 .enc = {
2426                                         .vecs = serpent_cbc_enc_tv_template,
2427                                         .count = SERPENT_CBC_ENC_TEST_VECTORS
2428                                 },
2429                                 .dec = {
2430                                         .vecs = serpent_cbc_dec_tv_template,
2431                                         .count = SERPENT_CBC_DEC_TEST_VECTORS
2432                                 }
2433                         }
2434                 }
2435         }, {
2436                 .alg = "cbc(twofish)",
2437                 .test = alg_test_skcipher,
2438                 .suite = {
2439                         .cipher = {
2440                                 .enc = {
2441                                         .vecs = tf_cbc_enc_tv_template,
2442                                         .count = TF_CBC_ENC_TEST_VECTORS
2443                                 },
2444                                 .dec = {
2445                                         .vecs = tf_cbc_dec_tv_template,
2446                                         .count = TF_CBC_DEC_TEST_VECTORS
2447                                 }
2448                         }
2449                 }
2450         }, {
2451                 .alg = "ccm(aes)",
2452                 .test = alg_test_aead,
2453                 .fips_allowed = 1,
2454                 .suite = {
2455                         .aead = {
2456                                 .enc = {
2457                                         .vecs = aes_ccm_enc_tv_template,
2458                                         .count = AES_CCM_ENC_TEST_VECTORS
2459                                 },
2460                                 .dec = {
2461                                         .vecs = aes_ccm_dec_tv_template,
2462                                         .count = AES_CCM_DEC_TEST_VECTORS
2463                                 }
2464                         }
2465                 }
2466         }, {
2467                 .alg = "chacha20",
2468                 .test = alg_test_skcipher,
2469                 .suite = {
2470                         .cipher = {
2471                                 .enc = {
2472                                         .vecs = chacha20_enc_tv_template,
2473                                         .count = CHACHA20_ENC_TEST_VECTORS
2474                                 },
2475                                 .dec = {
2476                                         .vecs = chacha20_enc_tv_template,
2477                                         .count = CHACHA20_ENC_TEST_VECTORS
2478                                 },
2479                         }
2480                 }
2481         }, {
2482                 .alg = "cmac(aes)",
2483                 .fips_allowed = 1,
2484                 .test = alg_test_hash,
2485                 .suite = {
2486                         .hash = {
2487                                 .vecs = aes_cmac128_tv_template,
2488                                 .count = CMAC_AES_TEST_VECTORS
2489                         }
2490                 }
2491         }, {
2492                 .alg = "cmac(des3_ede)",
2493                 .fips_allowed = 1,
2494                 .test = alg_test_hash,
2495                 .suite = {
2496                         .hash = {
2497                                 .vecs = des3_ede_cmac64_tv_template,
2498                                 .count = CMAC_DES3_EDE_TEST_VECTORS
2499                         }
2500                 }
2501         }, {
2502                 .alg = "compress_null",
2503                 .test = alg_test_null,
2504         }, {
2505                 .alg = "crc32",
2506                 .test = alg_test_hash,
2507                 .suite = {
2508                         .hash = {
2509                                 .vecs = crc32_tv_template,
2510                                 .count = CRC32_TEST_VECTORS
2511                         }
2512                 }
2513         }, {
2514                 .alg = "crc32c",
2515                 .test = alg_test_crc32c,
2516                 .fips_allowed = 1,
2517                 .suite = {
2518                         .hash = {
2519                                 .vecs = crc32c_tv_template,
2520                                 .count = CRC32C_TEST_VECTORS
2521                         }
2522                 }
2523         }, {
2524                 .alg = "crct10dif",
2525                 .test = alg_test_hash,
2526                 .fips_allowed = 1,
2527                 .suite = {
2528                         .hash = {
2529                                 .vecs = crct10dif_tv_template,
2530                                 .count = CRCT10DIF_TEST_VECTORS
2531                         }
2532                 }
2533         }, {
2534                 .alg = "cryptd(__driver-cbc-aes-aesni)",
2535                 .test = alg_test_null,
2536                 .fips_allowed = 1,
2537         }, {
2538                 .alg = "cryptd(__driver-cbc-camellia-aesni)",
2539                 .test = alg_test_null,
2540         }, {
2541                 .alg = "cryptd(__driver-cbc-camellia-aesni-avx2)",
2542                 .test = alg_test_null,
2543         }, {
2544                 .alg = "cryptd(__driver-cbc-serpent-avx2)",
2545                 .test = alg_test_null,
2546         }, {
2547                 .alg = "cryptd(__driver-ecb-aes-aesni)",
2548                 .test = alg_test_null,
2549                 .fips_allowed = 1,
2550         }, {
2551                 .alg = "cryptd(__driver-ecb-camellia-aesni)",
2552                 .test = alg_test_null,
2553         }, {
2554                 .alg = "cryptd(__driver-ecb-camellia-aesni-avx2)",
2555                 .test = alg_test_null,
2556         }, {
2557                 .alg = "cryptd(__driver-ecb-cast5-avx)",
2558                 .test = alg_test_null,
2559         }, {
2560                 .alg = "cryptd(__driver-ecb-cast6-avx)",
2561                 .test = alg_test_null,
2562         }, {
2563                 .alg = "cryptd(__driver-ecb-serpent-avx)",
2564                 .test = alg_test_null,
2565         }, {
2566                 .alg = "cryptd(__driver-ecb-serpent-avx2)",
2567                 .test = alg_test_null,
2568         }, {
2569                 .alg = "cryptd(__driver-ecb-serpent-sse2)",
2570                 .test = alg_test_null,
2571         }, {
2572                 .alg = "cryptd(__driver-ecb-twofish-avx)",
2573                 .test = alg_test_null,
2574         }, {
2575                 .alg = "cryptd(__driver-gcm-aes-aesni)",
2576                 .test = alg_test_null,
2577                 .fips_allowed = 1,
2578         }, {
2579                 .alg = "cryptd(__ghash-pclmulqdqni)",
2580                 .test = alg_test_null,
2581                 .fips_allowed = 1,
2582         }, {
2583                 .alg = "ctr(aes)",
2584                 .test = alg_test_skcipher,
2585                 .fips_allowed = 1,
2586                 .suite = {
2587                         .cipher = {
2588                                 .enc = {
2589                                         .vecs = aes_ctr_enc_tv_template,
2590                                         .count = AES_CTR_ENC_TEST_VECTORS
2591                                 },
2592                                 .dec = {
2593                                         .vecs = aes_ctr_dec_tv_template,
2594                                         .count = AES_CTR_DEC_TEST_VECTORS
2595                                 }
2596                         }
2597                 }
2598         }, {
2599                 .alg = "ctr(blowfish)",
2600                 .test = alg_test_skcipher,
2601                 .suite = {
2602                         .cipher = {
2603                                 .enc = {
2604                                         .vecs = bf_ctr_enc_tv_template,
2605                                         .count = BF_CTR_ENC_TEST_VECTORS
2606                                 },
2607                                 .dec = {
2608                                         .vecs = bf_ctr_dec_tv_template,
2609                                         .count = BF_CTR_DEC_TEST_VECTORS
2610                                 }
2611                         }
2612                 }
2613         }, {
2614                 .alg = "ctr(camellia)",
2615                 .test = alg_test_skcipher,
2616                 .suite = {
2617                         .cipher = {
2618                                 .enc = {
2619                                         .vecs = camellia_ctr_enc_tv_template,
2620                                         .count = CAMELLIA_CTR_ENC_TEST_VECTORS
2621                                 },
2622                                 .dec = {
2623                                         .vecs = camellia_ctr_dec_tv_template,
2624                                         .count = CAMELLIA_CTR_DEC_TEST_VECTORS
2625                                 }
2626                         }
2627                 }
2628         }, {
2629                 .alg = "ctr(cast5)",
2630                 .test = alg_test_skcipher,
2631                 .suite = {
2632                         .cipher = {
2633                                 .enc = {
2634                                         .vecs = cast5_ctr_enc_tv_template,
2635                                         .count = CAST5_CTR_ENC_TEST_VECTORS
2636                                 },
2637                                 .dec = {
2638                                         .vecs = cast5_ctr_dec_tv_template,
2639                                         .count = CAST5_CTR_DEC_TEST_VECTORS
2640                                 }
2641                         }
2642                 }
2643         }, {
2644                 .alg = "ctr(cast6)",
2645                 .test = alg_test_skcipher,
2646                 .suite = {
2647                         .cipher = {
2648                                 .enc = {
2649                                         .vecs = cast6_ctr_enc_tv_template,
2650                                         .count = CAST6_CTR_ENC_TEST_VECTORS
2651                                 },
2652                                 .dec = {
2653                                         .vecs = cast6_ctr_dec_tv_template,
2654                                         .count = CAST6_CTR_DEC_TEST_VECTORS
2655                                 }
2656                         }
2657                 }
2658         }, {
2659                 .alg = "ctr(des)",
2660                 .test = alg_test_skcipher,
2661                 .suite = {
2662                         .cipher = {
2663                                 .enc = {
2664                                         .vecs = des_ctr_enc_tv_template,
2665                                         .count = DES_CTR_ENC_TEST_VECTORS
2666                                 },
2667                                 .dec = {
2668                                         .vecs = des_ctr_dec_tv_template,
2669                                         .count = DES_CTR_DEC_TEST_VECTORS
2670                                 }
2671                         }
2672                 }
2673         }, {
2674                 .alg = "ctr(des3_ede)",
2675                 .test = alg_test_skcipher,
2676                 .suite = {
2677                         .cipher = {
2678                                 .enc = {
2679                                         .vecs = des3_ede_ctr_enc_tv_template,
2680                                         .count = DES3_EDE_CTR_ENC_TEST_VECTORS
2681                                 },
2682                                 .dec = {
2683                                         .vecs = des3_ede_ctr_dec_tv_template,
2684                                         .count = DES3_EDE_CTR_DEC_TEST_VECTORS
2685                                 }
2686                         }
2687                 }
2688         }, {
2689                 .alg = "ctr(serpent)",
2690                 .test = alg_test_skcipher,
2691                 .suite = {
2692                         .cipher = {
2693                                 .enc = {
2694                                         .vecs = serpent_ctr_enc_tv_template,
2695                                         .count = SERPENT_CTR_ENC_TEST_VECTORS
2696                                 },
2697                                 .dec = {
2698                                         .vecs = serpent_ctr_dec_tv_template,
2699                                         .count = SERPENT_CTR_DEC_TEST_VECTORS
2700                                 }
2701                         }
2702                 }
2703         }, {
2704                 .alg = "ctr(twofish)",
2705                 .test = alg_test_skcipher,
2706                 .suite = {
2707                         .cipher = {
2708                                 .enc = {
2709                                         .vecs = tf_ctr_enc_tv_template,
2710                                         .count = TF_CTR_ENC_TEST_VECTORS
2711                                 },
2712                                 .dec = {
2713                                         .vecs = tf_ctr_dec_tv_template,
2714                                         .count = TF_CTR_DEC_TEST_VECTORS
2715                                 }
2716                         }
2717                 }
2718         }, {
2719                 .alg = "cts(cbc(aes))",
2720                 .test = alg_test_skcipher,
2721                 .suite = {
2722                         .cipher = {
2723                                 .enc = {
2724                                         .vecs = cts_mode_enc_tv_template,
2725                                         .count = CTS_MODE_ENC_TEST_VECTORS
2726                                 },
2727                                 .dec = {
2728                                         .vecs = cts_mode_dec_tv_template,
2729                                         .count = CTS_MODE_DEC_TEST_VECTORS
2730                                 }
2731                         }
2732                 }
2733         }, {
2734                 .alg = "deflate",
2735                 .test = alg_test_comp,
2736                 .fips_allowed = 1,
2737                 .suite = {
2738                         .comp = {
2739                                 .comp = {
2740                                         .vecs = deflate_comp_tv_template,
2741                                         .count = DEFLATE_COMP_TEST_VECTORS
2742                                 },
2743                                 .decomp = {
2744                                         .vecs = deflate_decomp_tv_template,
2745                                         .count = DEFLATE_DECOMP_TEST_VECTORS
2746                                 }
2747                         }
2748                 }
2749         }, {
2750                 .alg = "digest_null",
2751                 .test = alg_test_null,
2752         }, {
2753                 .alg = "drbg_nopr_ctr_aes128",
2754                 .test = alg_test_drbg,
2755                 .fips_allowed = 1,
2756                 .suite = {
2757                         .drbg = {
2758                                 .vecs = drbg_nopr_ctr_aes128_tv_template,
2759                                 .count = ARRAY_SIZE(drbg_nopr_ctr_aes128_tv_template)
2760                         }
2761                 }
2762         }, {
2763                 .alg = "drbg_nopr_ctr_aes192",
2764                 .test = alg_test_drbg,
2765                 .fips_allowed = 1,
2766                 .suite = {
2767                         .drbg = {
2768                                 .vecs = drbg_nopr_ctr_aes192_tv_template,
2769                                 .count = ARRAY_SIZE(drbg_nopr_ctr_aes192_tv_template)
2770                         }
2771                 }
2772         }, {
2773                 .alg = "drbg_nopr_ctr_aes256",
2774                 .test = alg_test_drbg,
2775                 .fips_allowed = 1,
2776                 .suite = {
2777                         .drbg = {
2778                                 .vecs = drbg_nopr_ctr_aes256_tv_template,
2779                                 .count = ARRAY_SIZE(drbg_nopr_ctr_aes256_tv_template)
2780                         }
2781                 }
2782         }, {
2783                 /*
2784                  * There is no need to specifically test the DRBG with every
2785                  * backend cipher -- covered by drbg_nopr_hmac_sha256 test
2786                  */
2787                 .alg = "drbg_nopr_hmac_sha1",
2788                 .fips_allowed = 1,
2789                 .test = alg_test_null,
2790         }, {
2791                 .alg = "drbg_nopr_hmac_sha256",
2792                 .test = alg_test_drbg,
2793                 .fips_allowed = 1,
2794                 .suite = {
2795                         .drbg = {
2796                                 .vecs = drbg_nopr_hmac_sha256_tv_template,
2797                                 .count =
2798                                 ARRAY_SIZE(drbg_nopr_hmac_sha256_tv_template)
2799                         }
2800                 }
2801         }, {
2802                 /* covered by drbg_nopr_hmac_sha256 test */
2803                 .alg = "drbg_nopr_hmac_sha384",
2804                 .fips_allowed = 1,
2805                 .test = alg_test_null,
2806         }, {
2807                 .alg = "drbg_nopr_hmac_sha512",
2808                 .test = alg_test_null,
2809                 .fips_allowed = 1,
2810         }, {
2811                 .alg = "drbg_nopr_sha1",
2812                 .fips_allowed = 1,
2813                 .test = alg_test_null,
2814         }, {
2815                 .alg = "drbg_nopr_sha256",
2816                 .test = alg_test_drbg,
2817                 .fips_allowed = 1,
2818                 .suite = {
2819                         .drbg = {
2820                                 .vecs = drbg_nopr_sha256_tv_template,
2821                                 .count = ARRAY_SIZE(drbg_nopr_sha256_tv_template)
2822                         }
2823                 }
2824         }, {
2825                 /* covered by drbg_nopr_sha256 test */
2826                 .alg = "drbg_nopr_sha384",
2827                 .fips_allowed = 1,
2828                 .test = alg_test_null,
2829         }, {
2830                 .alg = "drbg_nopr_sha512",
2831                 .fips_allowed = 1,
2832                 .test = alg_test_null,
2833         }, {
2834                 .alg = "drbg_pr_ctr_aes128",
2835                 .test = alg_test_drbg,
2836                 .fips_allowed = 1,
2837                 .suite = {
2838                         .drbg = {
2839                                 .vecs = drbg_pr_ctr_aes128_tv_template,
2840                                 .count = ARRAY_SIZE(drbg_pr_ctr_aes128_tv_template)
2841                         }
2842                 }
2843         }, {
2844                 /* covered by drbg_pr_ctr_aes128 test */
2845                 .alg = "drbg_pr_ctr_aes192",
2846                 .fips_allowed = 1,
2847                 .test = alg_test_null,
2848         }, {
2849                 .alg = "drbg_pr_ctr_aes256",
2850                 .fips_allowed = 1,
2851                 .test = alg_test_null,
2852         }, {
2853                 .alg = "drbg_pr_hmac_sha1",
2854                 .fips_allowed = 1,
2855                 .test = alg_test_null,
2856         }, {
2857                 .alg = "drbg_pr_hmac_sha256",
2858                 .test = alg_test_drbg,
2859                 .fips_allowed = 1,
2860                 .suite = {
2861                         .drbg = {
2862                                 .vecs = drbg_pr_hmac_sha256_tv_template,
2863                                 .count = ARRAY_SIZE(drbg_pr_hmac_sha256_tv_template)
2864                         }
2865                 }
2866         }, {
2867                 /* covered by drbg_pr_hmac_sha256 test */
2868                 .alg = "drbg_pr_hmac_sha384",
2869                 .fips_allowed = 1,
2870                 .test = alg_test_null,
2871         }, {
2872                 .alg = "drbg_pr_hmac_sha512",
2873                 .test = alg_test_null,
2874                 .fips_allowed = 1,
2875         }, {
2876                 .alg = "drbg_pr_sha1",
2877                 .fips_allowed = 1,
2878                 .test = alg_test_null,
2879         }, {
2880                 .alg = "drbg_pr_sha256",
2881                 .test = alg_test_drbg,
2882                 .fips_allowed = 1,
2883                 .suite = {
2884                         .drbg = {
2885                                 .vecs = drbg_pr_sha256_tv_template,
2886                                 .count = ARRAY_SIZE(drbg_pr_sha256_tv_template)
2887                         }
2888                 }
2889         }, {
2890                 /* covered by drbg_pr_sha256 test */
2891                 .alg = "drbg_pr_sha384",
2892                 .fips_allowed = 1,
2893                 .test = alg_test_null,
2894         }, {
2895                 .alg = "drbg_pr_sha512",
2896                 .fips_allowed = 1,
2897                 .test = alg_test_null,
2898         }, {
2899                 .alg = "ecb(__aes-aesni)",
2900                 .test = alg_test_null,
2901                 .fips_allowed = 1,
2902         }, {
2903                 .alg = "ecb(aes)",
2904                 .test = alg_test_skcipher,
2905                 .fips_allowed = 1,
2906                 .suite = {
2907                         .cipher = {
2908                                 .enc = {
2909                                         .vecs = aes_enc_tv_template,
2910                                         .count = AES_ENC_TEST_VECTORS
2911                                 },
2912                                 .dec = {
2913                                         .vecs = aes_dec_tv_template,
2914                                         .count = AES_DEC_TEST_VECTORS
2915                                 }
2916                         }
2917                 }
2918         }, {
2919                 .alg = "ecb(anubis)",
2920                 .test = alg_test_skcipher,
2921                 .suite = {
2922                         .cipher = {
2923                                 .enc = {
2924                                         .vecs = anubis_enc_tv_template,
2925                                         .count = ANUBIS_ENC_TEST_VECTORS
2926                                 },
2927                                 .dec = {
2928                                         .vecs = anubis_dec_tv_template,
2929                                         .count = ANUBIS_DEC_TEST_VECTORS
2930                                 }
2931                         }
2932                 }
2933         }, {
2934                 .alg = "ecb(arc4)",
2935                 .test = alg_test_skcipher,
2936                 .suite = {
2937                         .cipher = {
2938                                 .enc = {
2939                                         .vecs = arc4_enc_tv_template,
2940                                         .count = ARC4_ENC_TEST_VECTORS
2941                                 },
2942                                 .dec = {
2943                                         .vecs = arc4_dec_tv_template,
2944                                         .count = ARC4_DEC_TEST_VECTORS
2945                                 }
2946                         }
2947                 }
2948         }, {
2949                 .alg = "ecb(blowfish)",
2950                 .test = alg_test_skcipher,
2951                 .suite = {
2952                         .cipher = {
2953                                 .enc = {
2954                                         .vecs = bf_enc_tv_template,
2955                                         .count = BF_ENC_TEST_VECTORS
2956                                 },
2957                                 .dec = {
2958                                         .vecs = bf_dec_tv_template,
2959                                         .count = BF_DEC_TEST_VECTORS
2960                                 }
2961                         }
2962                 }
2963         }, {
2964                 .alg = "ecb(camellia)",
2965                 .test = alg_test_skcipher,