Root/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/hash.h>
24#include <linux/err.h>
25#include <linux/module.h>
26#include <linux/scatterlist.h>
27#include <linux/slab.h>
28#include <linux/string.h>
29#include <crypto/rng.h>
30
31#include "internal.h"
32
33#ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
34
35/* a perfect nop */
36int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
37{
38    return 0;
39}
40
41#else
42
43#include "testmgr.h"
44
45/*
46 * Need slab memory for testing (size in number of pages).
47 */
48#define XBUFSIZE 8
49
50/*
51 * Indexes into the xbuf to simulate cross-page access.
52 */
53#define IDX1 32
54#define IDX2 32400
55#define IDX3 1
56#define IDX4 8193
57#define IDX5 22222
58#define IDX6 17101
59#define IDX7 27333
60#define IDX8 3000
61
62/*
63* Used by test_cipher()
64*/
65#define ENCRYPT 1
66#define DECRYPT 0
67
68struct tcrypt_result {
69    struct completion completion;
70    int err;
71};
72
73struct aead_test_suite {
74    struct {
75        struct aead_testvec *vecs;
76        unsigned int count;
77    } enc, dec;
78};
79
80struct cipher_test_suite {
81    struct {
82        struct cipher_testvec *vecs;
83        unsigned int count;
84    } enc, dec;
85};
86
87struct comp_test_suite {
88    struct {
89        struct comp_testvec *vecs;
90        unsigned int count;
91    } comp, decomp;
92};
93
94struct pcomp_test_suite {
95    struct {
96        struct pcomp_testvec *vecs;
97        unsigned int count;
98    } comp, decomp;
99};
100
101struct hash_test_suite {
102    struct hash_testvec *vecs;
103    unsigned int count;
104};
105
106struct cprng_test_suite {
107    struct cprng_testvec *vecs;
108    unsigned int count;
109};
110
111struct alg_test_desc {
112    const char *alg;
113    int (*test)(const struct alg_test_desc *desc, const char *driver,
114            u32 type, u32 mask);
115    int fips_allowed; /* set if alg is allowed in fips mode */
116
117    union {
118        struct aead_test_suite aead;
119        struct cipher_test_suite cipher;
120        struct comp_test_suite comp;
121        struct pcomp_test_suite pcomp;
122        struct hash_test_suite hash;
123        struct cprng_test_suite cprng;
124    } suite;
125};
126
127static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
128
129static void hexdump(unsigned char *buf, unsigned int len)
130{
131    print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
132            16, 1,
133            buf, len, false);
134}
135
136static void tcrypt_complete(struct crypto_async_request *req, int err)
137{
138    struct tcrypt_result *res = req->data;
139
140    if (err == -EINPROGRESS)
141        return;
142
143    res->err = err;
144    complete(&res->completion);
145}
146
147static int testmgr_alloc_buf(char *buf[XBUFSIZE])
148{
149    int i;
150
151    for (i = 0; i < XBUFSIZE; i++) {
152        buf[i] = (void *)__get_free_page(GFP_KERNEL);
153        if (!buf[i])
154            goto err_free_buf;
155    }
156
157    return 0;
158
159err_free_buf:
160    while (i-- > 0)
161        free_page((unsigned long)buf[i]);
162
163    return -ENOMEM;
164}
165
166static void testmgr_free_buf(char *buf[XBUFSIZE])
167{
168    int i;
169
170    for (i = 0; i < XBUFSIZE; i++)
171        free_page((unsigned long)buf[i]);
172}
173
174static int do_one_async_hash_op(struct ahash_request *req,
175                struct tcrypt_result *tr,
176                int ret)
177{
178    if (ret == -EINPROGRESS || ret == -EBUSY) {
179        ret = wait_for_completion_interruptible(&tr->completion);
180        if (!ret)
181            ret = tr->err;
182        reinit_completion(&tr->completion);
183    }
184    return ret;
185}
186
187static int __test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
188               unsigned int tcount, bool use_digest,
189               const int align_offset)
190{
191    const char *algo = crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm));
192    unsigned int i, j, k, temp;
193    struct scatterlist sg[8];
194    char result[64];
195    struct ahash_request *req;
196    struct tcrypt_result tresult;
197    void *hash_buff;
198    char *xbuf[XBUFSIZE];
199    int ret = -ENOMEM;
200
201    if (testmgr_alloc_buf(xbuf))
202        goto out_nobuf;
203
204    init_completion(&tresult.completion);
205
206    req = ahash_request_alloc(tfm, GFP_KERNEL);
207    if (!req) {
208        printk(KERN_ERR "alg: hash: Failed to allocate request for "
209               "%s\n", algo);
210        goto out_noreq;
211    }
212    ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
213                   tcrypt_complete, &tresult);
214
215    j = 0;
216    for (i = 0; i < tcount; i++) {
217        if (template[i].np)
218            continue;
219
220        ret = -EINVAL;
221        if (WARN_ON(align_offset + template[i].psize > PAGE_SIZE))
222            goto out;
223
224        j++;
225        memset(result, 0, 64);
226
227        hash_buff = xbuf[0];
228        hash_buff += align_offset;
229
230        memcpy(hash_buff, template[i].plaintext, template[i].psize);
231        sg_init_one(&sg[0], hash_buff, template[i].psize);
232
233        if (template[i].ksize) {
234            crypto_ahash_clear_flags(tfm, ~0);
235            ret = crypto_ahash_setkey(tfm, template[i].key,
236                          template[i].ksize);
237            if (ret) {
238                printk(KERN_ERR "alg: hash: setkey failed on "
239                       "test %d for %s: ret=%d\n", j, algo,
240                       -ret);
241                goto out;
242            }
243        }
244
245        ahash_request_set_crypt(req, sg, result, template[i].psize);
246        if (use_digest) {
247            ret = do_one_async_hash_op(req, &tresult,
248                           crypto_ahash_digest(req));
249            if (ret) {
250                pr_err("alg: hash: digest failed on test %d "
251                       "for %s: ret=%d\n", j, algo, -ret);
252                goto out;
253            }
254        } else {
255            ret = do_one_async_hash_op(req, &tresult,
256                           crypto_ahash_init(req));
257            if (ret) {
258                pr_err("alt: hash: init failed on test %d "
259                       "for %s: ret=%d\n", j, algo, -ret);
260                goto out;
261            }
262            ret = do_one_async_hash_op(req, &tresult,
263                           crypto_ahash_update(req));
264            if (ret) {
265                pr_err("alt: hash: update failed on test %d "
266                       "for %s: ret=%d\n", j, algo, -ret);
267                goto out;
268            }
269            ret = do_one_async_hash_op(req, &tresult,
270                           crypto_ahash_final(req));
271            if (ret) {
272                pr_err("alt: hash: final failed on test %d "
273                       "for %s: ret=%d\n", j, algo, -ret);
274                goto out;
275            }
276        }
277
278        if (memcmp(result, template[i].digest,
279               crypto_ahash_digestsize(tfm))) {
280            printk(KERN_ERR "alg: hash: Test %d failed for %s\n",
281                   j, algo);
282            hexdump(result, crypto_ahash_digestsize(tfm));
283            ret = -EINVAL;
284            goto out;
285        }
286    }
287
288    j = 0;
289    for (i = 0; i < tcount; i++) {
290        /* alignment tests are only done with continuous buffers */
291        if (align_offset != 0)
292            break;
293
294        if (template[i].np) {
295            j++;
296            memset(result, 0, 64);
297
298            temp = 0;
299            sg_init_table(sg, template[i].np);
300            ret = -EINVAL;
301            for (k = 0; k < template[i].np; k++) {
302                if (WARN_ON(offset_in_page(IDX[k]) +
303                        template[i].tap[k] > PAGE_SIZE))
304                    goto out;
305                sg_set_buf(&sg[k],
306                       memcpy(xbuf[IDX[k] >> PAGE_SHIFT] +
307                          offset_in_page(IDX[k]),
308                          template[i].plaintext + temp,
309                          template[i].tap[k]),
310                       template[i].tap[k]);
311                temp += template[i].tap[k];
312            }
313
314            if (template[i].ksize) {
315                crypto_ahash_clear_flags(tfm, ~0);
316                ret = crypto_ahash_setkey(tfm, template[i].key,
317                              template[i].ksize);
318
319                if (ret) {
320                    printk(KERN_ERR "alg: hash: setkey "
321                           "failed on chunking test %d "
322                           "for %s: ret=%d\n", j, algo,
323                           -ret);
324                    goto out;
325                }
326            }
327
328            ahash_request_set_crypt(req, sg, result,
329                        template[i].psize);
330            ret = crypto_ahash_digest(req);
331            switch (ret) {
332            case 0:
333                break;
334            case -EINPROGRESS:
335            case -EBUSY:
336                ret = wait_for_completion_interruptible(
337                    &tresult.completion);
338                if (!ret && !(ret = tresult.err)) {
339                    reinit_completion(&tresult.completion);
340                    break;
341                }
342                /* fall through */
343            default:
344                printk(KERN_ERR "alg: hash: digest failed "
345                       "on chunking test %d for %s: "
346                       "ret=%d\n", j, algo, -ret);
347                goto out;
348            }
349
350            if (memcmp(result, template[i].digest,
351                   crypto_ahash_digestsize(tfm))) {
352                printk(KERN_ERR "alg: hash: Chunking test %d "
353                       "failed for %s\n", j, algo);
354                hexdump(result, crypto_ahash_digestsize(tfm));
355                ret = -EINVAL;
356                goto out;
357            }
358        }
359    }
360
361    ret = 0;
362
363out:
364    ahash_request_free(req);
365out_noreq:
366    testmgr_free_buf(xbuf);
367out_nobuf:
368    return ret;
369}
370
371static int test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
372             unsigned int tcount, bool use_digest)
373{
374    unsigned int alignmask;
375    int ret;
376
377    ret = __test_hash(tfm, template, tcount, use_digest, 0);
378    if (ret)
379        return ret;
380
381    /* test unaligned buffers, check with one byte offset */
382    ret = __test_hash(tfm, template, tcount, use_digest, 1);
383    if (ret)
384        return ret;
385
386    alignmask = crypto_tfm_alg_alignmask(&tfm->base);
387    if (alignmask) {
388        /* Check if alignment mask for tfm is correctly set. */
389        ret = __test_hash(tfm, template, tcount, use_digest,
390                  alignmask + 1);
391        if (ret)
392            return ret;
393    }
394
395    return 0;
396}
397
398static int __test_aead(struct crypto_aead *tfm, int enc,
399               struct aead_testvec *template, unsigned int tcount,
400               const bool diff_dst, const int align_offset)
401{
402    const char *algo = crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm));
403    unsigned int i, j, k, n, temp;
404    int ret = -ENOMEM;
405    char *q;
406    char *key;
407    struct aead_request *req;
408    struct scatterlist *sg;
409    struct scatterlist *asg;
410    struct scatterlist *sgout;
411    const char *e, *d;
412    struct tcrypt_result result;
413    unsigned int authsize;
414    void *input;
415    void *output;
416    void *assoc;
417    char iv[MAX_IVLEN];
418    char *xbuf[XBUFSIZE];
419    char *xoutbuf[XBUFSIZE];
420    char *axbuf[XBUFSIZE];
421
422    if (testmgr_alloc_buf(xbuf))
423        goto out_noxbuf;
424    if (testmgr_alloc_buf(axbuf))
425        goto out_noaxbuf;
426
427    if (diff_dst && testmgr_alloc_buf(xoutbuf))
428        goto out_nooutbuf;
429
430    /* avoid "the frame size is larger than 1024 bytes" compiler warning */
431    sg = kmalloc(sizeof(*sg) * 8 * (diff_dst ? 3 : 2), GFP_KERNEL);
432    if (!sg)
433        goto out_nosg;
434    asg = &sg[8];
435    sgout = &asg[8];
436
437    if (diff_dst)
438        d = "-ddst";
439    else
440        d = "";
441
442    if (enc == ENCRYPT)
443        e = "encryption";
444    else
445        e = "decryption";
446
447    init_completion(&result.completion);
448
449    req = aead_request_alloc(tfm, GFP_KERNEL);
450    if (!req) {
451        pr_err("alg: aead%s: Failed to allocate request for %s\n",
452               d, algo);
453        goto out;
454    }
455
456    aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
457                  tcrypt_complete, &result);
458
459    for (i = 0, j = 0; i < tcount; i++) {
460        if (!template[i].np) {
461            j++;
462
463            /* some templates have no input data but they will
464             * touch input
465             */
466            input = xbuf[0];
467            input += align_offset;
468            assoc = axbuf[0];
469
470            ret = -EINVAL;
471            if (WARN_ON(align_offset + template[i].ilen >
472                    PAGE_SIZE || template[i].alen > PAGE_SIZE))
473                goto out;
474
475            memcpy(input, template[i].input, template[i].ilen);
476            memcpy(assoc, template[i].assoc, template[i].alen);
477            if (template[i].iv)
478                memcpy(iv, template[i].iv, MAX_IVLEN);
479            else
480                memset(iv, 0, MAX_IVLEN);
481
482            crypto_aead_clear_flags(tfm, ~0);
483            if (template[i].wk)
484                crypto_aead_set_flags(
485                    tfm, CRYPTO_TFM_REQ_WEAK_KEY);
486
487            key = template[i].key;
488
489            ret = crypto_aead_setkey(tfm, key,
490                         template[i].klen);
491            if (!ret == template[i].fail) {
492                pr_err("alg: aead%s: setkey failed on test %d for %s: flags=%x\n",
493                       d, j, algo, crypto_aead_get_flags(tfm));
494                goto out;
495            } else if (ret)
496                continue;
497
498            authsize = abs(template[i].rlen - template[i].ilen);
499            ret = crypto_aead_setauthsize(tfm, authsize);
500            if (ret) {
501                pr_err("alg: aead%s: Failed to set authsize to %u on test %d for %s\n",
502                       d, authsize, j, algo);
503                goto out;
504            }
505
506            if (diff_dst) {
507                output = xoutbuf[0];
508                output += align_offset;
509                sg_init_one(&sg[0], input, template[i].ilen);
510                sg_init_one(&sgout[0], output,
511                        template[i].rlen);
512            } else {
513                sg_init_one(&sg[0], input,
514                        template[i].ilen +
515                        (enc ? authsize : 0));
516                output = input;
517            }
518
519            sg_init_one(&asg[0], assoc, template[i].alen);
520
521            aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
522                           template[i].ilen, iv);
523
524            aead_request_set_assoc(req, asg, template[i].alen);
525
526            ret = enc ?
527                crypto_aead_encrypt(req) :
528                crypto_aead_decrypt(req);
529
530            switch (ret) {
531            case 0:
532                if (template[i].novrfy) {
533                    /* verification was supposed to fail */
534                    pr_err("alg: aead%s: %s failed on test %d for %s: ret was 0, expected -EBADMSG\n",
535                           d, e, j, algo);
536                    /* so really, we got a bad message */
537                    ret = -EBADMSG;
538                    goto out;
539                }
540                break;
541            case -EINPROGRESS:
542            case -EBUSY:
543                ret = wait_for_completion_interruptible(
544                    &result.completion);
545                if (!ret && !(ret = result.err)) {
546                    reinit_completion(&result.completion);
547                    break;
548                }
549            case -EBADMSG:
550                if (template[i].novrfy)
551                    /* verification failure was expected */
552                    continue;
553                /* fall through */
554            default:
555                pr_err("alg: aead%s: %s failed on test %d for %s: ret=%d\n",
556                       d, e, j, algo, -ret);
557                goto out;
558            }
559
560            q = output;
561            if (memcmp(q, template[i].result, template[i].rlen)) {
562                pr_err("alg: aead%s: Test %d failed on %s for %s\n",
563                       d, j, e, algo);
564                hexdump(q, template[i].rlen);
565                ret = -EINVAL;
566                goto out;
567            }
568        }
569    }
570
571    for (i = 0, j = 0; i < tcount; i++) {
572        /* alignment tests are only done with continuous buffers */
573        if (align_offset != 0)
574            break;
575
576        if (template[i].np) {
577            j++;
578
579            if (template[i].iv)
580                memcpy(iv, template[i].iv, MAX_IVLEN);
581            else
582                memset(iv, 0, MAX_IVLEN);
583
584            crypto_aead_clear_flags(tfm, ~0);
585            if (template[i].wk)
586                crypto_aead_set_flags(
587                    tfm, CRYPTO_TFM_REQ_WEAK_KEY);
588            key = template[i].key;
589
590            ret = crypto_aead_setkey(tfm, key, template[i].klen);
591            if (!ret == template[i].fail) {
592                pr_err("alg: aead%s: setkey failed on chunk test %d for %s: flags=%x\n",
593                       d, j, algo, crypto_aead_get_flags(tfm));
594                goto out;
595            } else if (ret)
596                continue;
597
598            authsize = abs(template[i].rlen - template[i].ilen);
599
600            ret = -EINVAL;
601            sg_init_table(sg, template[i].np);
602            if (diff_dst)
603                sg_init_table(sgout, template[i].np);
604            for (k = 0, temp = 0; k < template[i].np; k++) {
605                if (WARN_ON(offset_in_page(IDX[k]) +
606                        template[i].tap[k] > PAGE_SIZE))
607                    goto out;
608
609                q = xbuf[IDX[k] >> PAGE_SHIFT] +
610                    offset_in_page(IDX[k]);
611
612                memcpy(q, template[i].input + temp,
613                       template[i].tap[k]);
614
615                sg_set_buf(&sg[k], q, template[i].tap[k]);
616
617                if (diff_dst) {
618                    q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
619                        offset_in_page(IDX[k]);
620
621                    memset(q, 0, template[i].tap[k]);
622
623                    sg_set_buf(&sgout[k], q,
624                           template[i].tap[k]);
625                }
626
627                n = template[i].tap[k];
628                if (k == template[i].np - 1 && enc)
629                    n += authsize;
630                if (offset_in_page(q) + n < PAGE_SIZE)
631                    q[n] = 0;
632
633                temp += template[i].tap[k];
634            }
635
636            ret = crypto_aead_setauthsize(tfm, authsize);
637            if (ret) {
638                pr_err("alg: aead%s: Failed to set authsize to %u on chunk test %d for %s\n",
639                       d, authsize, j, algo);
640                goto out;
641            }
642
643            if (enc) {
644                if (WARN_ON(sg[k - 1].offset +
645                        sg[k - 1].length + authsize >
646                        PAGE_SIZE)) {
647                    ret = -EINVAL;
648                    goto out;
649                }
650
651                if (diff_dst)
652                    sgout[k - 1].length += authsize;
653                else
654                    sg[k - 1].length += authsize;
655            }
656
657            sg_init_table(asg, template[i].anp);
658            ret = -EINVAL;
659            for (k = 0, temp = 0; k < template[i].anp; k++) {
660                if (WARN_ON(offset_in_page(IDX[k]) +
661                        template[i].atap[k] > PAGE_SIZE))
662                    goto out;
663                sg_set_buf(&asg[k],
664                       memcpy(axbuf[IDX[k] >> PAGE_SHIFT] +
665                          offset_in_page(IDX[k]),
666                          template[i].assoc + temp,
667                          template[i].atap[k]),
668                       template[i].atap[k]);
669                temp += template[i].atap[k];
670            }
671
672            aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
673                           template[i].ilen,
674                           iv);
675
676            aead_request_set_assoc(req, asg, template[i].alen);
677
678            ret = enc ?
679                crypto_aead_encrypt(req) :
680                crypto_aead_decrypt(req);
681
682            switch (ret) {
683            case 0:
684                if (template[i].novrfy) {
685                    /* verification was supposed to fail */
686                    pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret was 0, expected -EBADMSG\n",
687                           d, e, j, algo);
688                    /* so really, we got a bad message */
689                    ret = -EBADMSG;
690                    goto out;
691                }
692                break;
693            case -EINPROGRESS:
694            case -EBUSY:
695                ret = wait_for_completion_interruptible(
696                    &result.completion);
697                if (!ret && !(ret = result.err)) {
698                    reinit_completion(&result.completion);
699                    break;
700                }
701            case -EBADMSG:
702                if (template[i].novrfy)
703                    /* verification failure was expected */
704                    continue;
705                /* fall through */
706            default:
707                pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret=%d\n",
708                       d, e, j, algo, -ret);
709                goto out;
710            }
711
712            ret = -EINVAL;
713            for (k = 0, temp = 0; k < template[i].np; k++) {
714                if (diff_dst)
715                    q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
716                        offset_in_page(IDX[k]);
717                else
718                    q = xbuf[IDX[k] >> PAGE_SHIFT] +
719                        offset_in_page(IDX[k]);
720
721                n = template[i].tap[k];
722                if (k == template[i].np - 1)
723                    n += enc ? authsize : -authsize;
724
725                if (memcmp(q, template[i].result + temp, n)) {
726                    pr_err("alg: aead%s: Chunk test %d failed on %s at page %u for %s\n",
727                           d, j, e, k, algo);
728                    hexdump(q, n);
729                    goto out;
730                }
731
732                q += n;
733                if (k == template[i].np - 1 && !enc) {
734                    if (!diff_dst &&
735                        memcmp(q, template[i].input +
736                              temp + n, authsize))
737                        n = authsize;
738                    else
739                        n = 0;
740                } else {
741                    for (n = 0; offset_in_page(q + n) &&
742                            q[n]; n++)
743                        ;
744                }
745                if (n) {
746                    pr_err("alg: aead%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
747                           d, j, e, k, algo, n);
748                    hexdump(q, n);
749                    goto out;
750                }
751
752                temp += template[i].tap[k];
753            }
754        }
755    }
756
757    ret = 0;
758
759out:
760    aead_request_free(req);
761    kfree(sg);
762out_nosg:
763    if (diff_dst)
764        testmgr_free_buf(xoutbuf);
765out_nooutbuf:
766    testmgr_free_buf(axbuf);
767out_noaxbuf:
768    testmgr_free_buf(xbuf);
769out_noxbuf:
770    return ret;
771}
772
773static int test_aead(struct crypto_aead *tfm, int enc,
774             struct aead_testvec *template, unsigned int tcount)
775{
776    unsigned int alignmask;
777    int ret;
778
779    /* test 'dst == src' case */
780    ret = __test_aead(tfm, enc, template, tcount, false, 0);
781    if (ret)
782        return ret;
783
784    /* test 'dst != src' case */
785    ret = __test_aead(tfm, enc, template, tcount, true, 0);
786    if (ret)
787        return ret;
788
789    /* test unaligned buffers, check with one byte offset */
790    ret = __test_aead(tfm, enc, template, tcount, true, 1);
791    if (ret)
792        return ret;
793
794    alignmask = crypto_tfm_alg_alignmask(&tfm->base);
795    if (alignmask) {
796        /* Check if alignment mask for tfm is correctly set. */
797        ret = __test_aead(tfm, enc, template, tcount, true,
798                  alignmask + 1);
799        if (ret)
800            return ret;
801    }
802
803    return 0;
804}
805
806static int test_cipher(struct crypto_cipher *tfm, int enc,
807               struct cipher_testvec *template, unsigned int tcount)
808{
809    const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm));
810    unsigned int i, j, k;
811    char *q;
812    const char *e;
813    void *data;
814    char *xbuf[XBUFSIZE];
815    int ret = -ENOMEM;
816
817    if (testmgr_alloc_buf(xbuf))
818        goto out_nobuf;
819
820    if (enc == ENCRYPT)
821            e = "encryption";
822    else
823        e = "decryption";
824
825    j = 0;
826    for (i = 0; i < tcount; i++) {
827        if (template[i].np)
828            continue;
829
830        j++;
831
832        ret = -EINVAL;
833        if (WARN_ON(template[i].ilen > PAGE_SIZE))
834            goto out;
835
836        data = xbuf[0];
837        memcpy(data, template[i].input, template[i].ilen);
838
839        crypto_cipher_clear_flags(tfm, ~0);
840        if (template[i].wk)
841            crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
842
843        ret = crypto_cipher_setkey(tfm, template[i].key,
844                       template[i].klen);
845        if (!ret == template[i].fail) {
846            printk(KERN_ERR "alg: cipher: setkey failed "
847                   "on test %d for %s: flags=%x\n", j,
848                   algo, crypto_cipher_get_flags(tfm));
849            goto out;
850        } else if (ret)
851            continue;
852
853        for (k = 0; k < template[i].ilen;
854             k += crypto_cipher_blocksize(tfm)) {
855            if (enc)
856                crypto_cipher_encrypt_one(tfm, data + k,
857                              data + k);
858            else
859                crypto_cipher_decrypt_one(tfm, data + k,
860                              data + k);
861        }
862
863        q = data;
864        if (memcmp(q, template[i].result, template[i].rlen)) {
865            printk(KERN_ERR "alg: cipher: Test %d failed "
866                   "on %s for %s\n", j, e, algo);
867            hexdump(q, template[i].rlen);
868            ret = -EINVAL;
869            goto out;
870        }
871    }
872
873    ret = 0;
874
875out:
876    testmgr_free_buf(xbuf);
877out_nobuf:
878    return ret;
879}
880
881static int __test_skcipher(struct crypto_ablkcipher *tfm, int enc,
882               struct cipher_testvec *template, unsigned int tcount,
883               const bool diff_dst, const int align_offset)
884{
885    const char *algo =
886        crypto_tfm_alg_driver_name(crypto_ablkcipher_tfm(tfm));
887    unsigned int i, j, k, n, temp;
888    char *q;
889    struct ablkcipher_request *req;
890    struct scatterlist sg[8];
891    struct scatterlist sgout[8];
892    const char *e, *d;
893    struct tcrypt_result result;
894    void *data;
895    char iv[MAX_IVLEN];
896    char *xbuf[XBUFSIZE];
897    char *xoutbuf[XBUFSIZE];
898    int ret = -ENOMEM;
899
900    if (testmgr_alloc_buf(xbuf))
901        goto out_nobuf;
902
903    if (diff_dst && testmgr_alloc_buf(xoutbuf))
904        goto out_nooutbuf;
905
906    if (diff_dst)
907        d = "-ddst";
908    else
909        d = "";
910
911    if (enc == ENCRYPT)
912            e = "encryption";
913    else
914        e = "decryption";
915
916    init_completion(&result.completion);
917
918    req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
919    if (!req) {
920        pr_err("alg: skcipher%s: Failed to allocate request for %s\n",
921               d, algo);
922        goto out;
923    }
924
925    ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
926                    tcrypt_complete, &result);
927
928    j = 0;
929    for (i = 0; i < tcount; i++) {
930        if (template[i].iv)
931            memcpy(iv, template[i].iv, MAX_IVLEN);
932        else
933            memset(iv, 0, MAX_IVLEN);
934
935        if (!(template[i].np) || (template[i].also_non_np)) {
936            j++;
937
938            ret = -EINVAL;
939            if (WARN_ON(align_offset + template[i].ilen >
940                    PAGE_SIZE))
941                goto out;
942
943            data = xbuf[0];
944            data += align_offset;
945            memcpy(data, template[i].input, template[i].ilen);
946
947            crypto_ablkcipher_clear_flags(tfm, ~0);
948            if (template[i].wk)
949                crypto_ablkcipher_set_flags(
950                    tfm, CRYPTO_TFM_REQ_WEAK_KEY);
951
952            ret = crypto_ablkcipher_setkey(tfm, template[i].key,
953                               template[i].klen);
954            if (!ret == template[i].fail) {
955                pr_err("alg: skcipher%s: setkey failed on test %d for %s: flags=%x\n",
956                       d, j, algo,
957                       crypto_ablkcipher_get_flags(tfm));
958                goto out;
959            } else if (ret)
960                continue;
961
962            sg_init_one(&sg[0], data, template[i].ilen);
963            if (diff_dst) {
964                data = xoutbuf[0];
965                data += align_offset;
966                sg_init_one(&sgout[0], data, template[i].ilen);
967            }
968
969            ablkcipher_request_set_crypt(req, sg,
970                             (diff_dst) ? sgout : sg,
971                             template[i].ilen, iv);
972            ret = enc ?
973                crypto_ablkcipher_encrypt(req) :
974                crypto_ablkcipher_decrypt(req);
975
976            switch (ret) {
977            case 0:
978                break;
979            case -EINPROGRESS:
980            case -EBUSY:
981                ret = wait_for_completion_interruptible(
982                    &result.completion);
983                if (!ret && !((ret = result.err))) {
984                    reinit_completion(&result.completion);
985                    break;
986                }
987                /* fall through */
988            default:
989                pr_err("alg: skcipher%s: %s failed on test %d for %s: ret=%d\n",
990                       d, e, j, algo, -ret);
991                goto out;
992            }
993
994            q = data;
995            if (memcmp(q, template[i].result, template[i].rlen)) {
996                pr_err("alg: skcipher%s: Test %d failed on %s for %s\n",
997                       d, j, e, algo);
998                hexdump(q, template[i].rlen);
999                ret = -EINVAL;
1000                goto out;
1001            }
1002        }
1003    }
1004
1005    j = 0;
1006    for (i = 0; i < tcount; i++) {
1007        /* alignment tests are only done with continuous buffers */
1008        if (align_offset != 0)
1009            break;
1010
1011        if (template[i].iv)
1012            memcpy(iv, template[i].iv, MAX_IVLEN);
1013        else
1014            memset(iv, 0, MAX_IVLEN);
1015
1016        if (template[i].np) {
1017            j++;
1018
1019            crypto_ablkcipher_clear_flags(tfm, ~0);
1020            if (template[i].wk)
1021                crypto_ablkcipher_set_flags(
1022                    tfm, CRYPTO_TFM_REQ_WEAK_KEY);
1023
1024            ret = crypto_ablkcipher_setkey(tfm, template[i].key,
1025                               template[i].klen);
1026            if (!ret == template[i].fail) {
1027                pr_err("alg: skcipher%s: setkey failed on chunk test %d for %s: flags=%x\n",
1028                       d, j, algo,
1029                       crypto_ablkcipher_get_flags(tfm));
1030                goto out;
1031            } else if (ret)
1032                continue;
1033
1034            temp = 0;
1035            ret = -EINVAL;
1036            sg_init_table(sg, template[i].np);
1037            if (diff_dst)
1038                sg_init_table(sgout, template[i].np);
1039            for (k = 0; k < template[i].np; k++) {
1040                if (WARN_ON(offset_in_page(IDX[k]) +
1041                        template[i].tap[k] > PAGE_SIZE))
1042                    goto out;
1043
1044                q = xbuf[IDX[k] >> PAGE_SHIFT] +
1045                    offset_in_page(IDX[k]);
1046
1047                memcpy(q, template[i].input + temp,
1048                       template[i].tap[k]);
1049
1050                if (offset_in_page(q) + template[i].tap[k] <
1051                    PAGE_SIZE)
1052                    q[template[i].tap[k]] = 0;
1053
1054                sg_set_buf(&sg[k], q, template[i].tap[k]);
1055                if (diff_dst) {
1056                    q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
1057                        offset_in_page(IDX[k]);
1058
1059                    sg_set_buf(&sgout[k], q,
1060                           template[i].tap[k]);
1061
1062                    memset(q, 0, template[i].tap[k]);
1063                    if (offset_in_page(q) +
1064                        template[i].tap[k] < PAGE_SIZE)
1065                        q[template[i].tap[k]] = 0;
1066                }
1067
1068                temp += template[i].tap[k];
1069            }
1070
1071            ablkcipher_request_set_crypt(req, sg,
1072                    (diff_dst) ? sgout : sg,
1073                    template[i].ilen, iv);
1074
1075            ret = enc ?
1076                crypto_ablkcipher_encrypt(req) :
1077                crypto_ablkcipher_decrypt(req);
1078
1079            switch (ret) {
1080            case 0:
1081                break;
1082            case -EINPROGRESS:
1083            case -EBUSY:
1084                ret = wait_for_completion_interruptible(
1085                    &result.completion);
1086                if (!ret && !((ret = result.err))) {
1087                    reinit_completion(&result.completion);
1088                    break;
1089                }
1090                /* fall through */
1091            default:
1092                pr_err("alg: skcipher%s: %s failed on chunk test %d for %s: ret=%d\n",
1093                       d, e, j, algo, -ret);
1094                goto out;
1095            }
1096
1097            temp = 0;
1098            ret = -EINVAL;
1099            for (k = 0; k < template[i].np; k++) {
1100                if (diff_dst)
1101                    q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
1102                        offset_in_page(IDX[k]);
1103                else
1104                    q = xbuf[IDX[k] >> PAGE_SHIFT] +
1105                        offset_in_page(IDX[k]);
1106
1107                if (memcmp(q, template[i].result + temp,
1108                       template[i].tap[k])) {
1109                    pr_err("alg: skcipher%s: Chunk test %d failed on %s at page %u for %s\n",
1110                           d, j, e, k, algo);
1111                    hexdump(q, template[i].tap[k]);
1112                    goto out;
1113                }
1114
1115                q += template[i].tap[k];
1116                for (n = 0; offset_in_page(q + n) && q[n]; n++)
1117                    ;
1118                if (n) {
1119                    pr_err("alg: skcipher%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
1120                           d, j, e, k, algo, n);
1121                    hexdump(q, n);
1122                    goto out;
1123                }
1124                temp += template[i].tap[k];
1125            }
1126        }
1127    }
1128
1129    ret = 0;
1130
1131out:
1132    ablkcipher_request_free(req);
1133    if (diff_dst)
1134        testmgr_free_buf(xoutbuf);
1135out_nooutbuf:
1136    testmgr_free_buf(xbuf);
1137out_nobuf:
1138    return ret;
1139}
1140
1141static int test_skcipher(struct crypto_ablkcipher *tfm, int enc,
1142             struct cipher_testvec *template, unsigned int tcount)
1143{
1144    unsigned int alignmask;
1145    int ret;
1146
1147    /* test 'dst == src' case */
1148    ret = __test_skcipher(tfm, enc, template, tcount, false, 0);
1149    if (ret)
1150        return ret;
1151
1152    /* test 'dst != src' case */
1153    ret = __test_skcipher(tfm, enc, template, tcount, true, 0);
1154    if (ret)
1155        return ret;
1156
1157    /* test unaligned buffers, check with one byte offset */
1158    ret = __test_skcipher(tfm, enc, template, tcount, true, 1);
1159    if (ret)
1160        return ret;
1161
1162    alignmask = crypto_tfm_alg_alignmask(&tfm->base);
1163    if (alignmask) {
1164        /* Check if alignment mask for tfm is correctly set. */
1165        ret = __test_skcipher(tfm, enc, template, tcount, true,
1166                      alignmask + 1);
1167        if (ret)
1168            return ret;
1169    }
1170
1171    return 0;
1172}
1173
1174static int test_comp(struct crypto_comp *tfm, struct comp_testvec *ctemplate,
1175             struct comp_testvec *dtemplate, int ctcount, int dtcount)
1176{
1177    const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
1178    unsigned int i;
1179    char result[COMP_BUF_SIZE];
1180    int ret;
1181
1182    for (i = 0; i < ctcount; i++) {
1183        int ilen;
1184        unsigned int dlen = COMP_BUF_SIZE;
1185
1186        memset(result, 0, sizeof (result));
1187
1188        ilen = ctemplate[i].inlen;
1189        ret = crypto_comp_compress(tfm, ctemplate[i].input,
1190                                   ilen, result, &dlen);
1191        if (ret) {
1192            printk(KERN_ERR "alg: comp: compression failed "
1193                   "on test %d for %s: ret=%d\n", i + 1, algo,
1194                   -ret);
1195            goto out;
1196        }
1197
1198        if (dlen != ctemplate[i].outlen) {
1199            printk(KERN_ERR "alg: comp: Compression test %d "
1200                   "failed for %s: output len = %d\n", i + 1, algo,
1201                   dlen);
1202            ret = -EINVAL;
1203            goto out;
1204        }
1205
1206        if (memcmp(result, ctemplate[i].output, dlen)) {
1207            printk(KERN_ERR "alg: comp: Compression test %d "
1208                   "failed for %s\n", i + 1, algo);
1209            hexdump(result, dlen);
1210            ret = -EINVAL;
1211            goto out;
1212        }
1213    }
1214
1215    for (i = 0; i < dtcount; i++) {
1216        int ilen;
1217        unsigned int dlen = COMP_BUF_SIZE;
1218
1219        memset(result, 0, sizeof (result));
1220
1221        ilen = dtemplate[i].inlen;
1222        ret = crypto_comp_decompress(tfm, dtemplate[i].input,
1223                                     ilen, result, &dlen);
1224        if (ret) {
1225            printk(KERN_ERR "alg: comp: decompression failed "
1226                   "on test %d for %s: ret=%d\n", i + 1, algo,
1227                   -ret);
1228            goto out;
1229        }
1230
1231        if (dlen != dtemplate[i].outlen) {
1232            printk(KERN_ERR "alg: comp: Decompression test %d "
1233                   "failed for %s: output len = %d\n", i + 1, algo,
1234                   dlen);
1235            ret = -EINVAL;
1236            goto out;
1237        }
1238
1239        if (memcmp(result, dtemplate[i].output, dlen)) {
1240            printk(KERN_ERR "alg: comp: Decompression test %d "
1241                   "failed for %s\n", i + 1, algo);
1242            hexdump(result, dlen);
1243            ret = -EINVAL;
1244            goto out;
1245        }
1246    }
1247
1248    ret = 0;
1249
1250out:
1251    return ret;
1252}
1253
1254static int test_pcomp(struct crypto_pcomp *tfm,
1255              struct pcomp_testvec *ctemplate,
1256              struct pcomp_testvec *dtemplate, int ctcount,
1257              int dtcount)
1258{
1259    const char *algo = crypto_tfm_alg_driver_name(crypto_pcomp_tfm(tfm));
1260    unsigned int i;
1261    char result[COMP_BUF_SIZE];
1262    int res;
1263
1264    for (i = 0; i < ctcount; i++) {
1265        struct comp_request req;
1266        unsigned int produced = 0;
1267
1268        res = crypto_compress_setup(tfm, ctemplate[i].params,
1269                        ctemplate[i].paramsize);
1270        if (res) {
1271            pr_err("alg: pcomp: compression setup failed on test "
1272                   "%d for %s: error=%d\n", i + 1, algo, res);
1273            return res;
1274        }
1275
1276        res = crypto_compress_init(tfm);
1277        if (res) {
1278            pr_err("alg: pcomp: compression init failed on test "
1279                   "%d for %s: error=%d\n", i + 1, algo, res);
1280            return res;
1281        }
1282
1283        memset(result, 0, sizeof(result));
1284
1285        req.next_in = ctemplate[i].input;
1286        req.avail_in = ctemplate[i].inlen / 2;
1287        req.next_out = result;
1288        req.avail_out = ctemplate[i].outlen / 2;
1289
1290        res = crypto_compress_update(tfm, &req);
1291        if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1292            pr_err("alg: pcomp: compression update failed on test "
1293                   "%d for %s: error=%d\n", i + 1, algo, res);
1294            return res;
1295        }
1296        if (res > 0)
1297            produced += res;
1298
1299        /* Add remaining input data */
1300        req.avail_in += (ctemplate[i].inlen + 1) / 2;
1301
1302        res = crypto_compress_update(tfm, &req);
1303        if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1304            pr_err("alg: pcomp: compression update failed on test "
1305                   "%d for %s: error=%d\n", i + 1, algo, res);
1306            return res;
1307        }
1308        if (res > 0)
1309            produced += res;
1310
1311        /* Provide remaining output space */
1312        req.avail_out += COMP_BUF_SIZE - ctemplate[i].outlen / 2;
1313
1314        res = crypto_compress_final(tfm, &req);
1315        if (res < 0) {
1316            pr_err("alg: pcomp: compression final failed on test "
1317                   "%d for %s: error=%d\n", i + 1, algo, res);
1318            return res;
1319        }
1320        produced += res;
1321
1322        if (COMP_BUF_SIZE - req.avail_out != ctemplate[i].outlen) {
1323            pr_err("alg: comp: Compression test %d failed for %s: "
1324                   "output len = %d (expected %d)\n", i + 1, algo,
1325                   COMP_BUF_SIZE - req.avail_out,
1326                   ctemplate[i].outlen);
1327            return -EINVAL;
1328        }
1329
1330        if (produced != ctemplate[i].outlen) {
1331            pr_err("alg: comp: Compression test %d failed for %s: "
1332                   "returned len = %u (expected %d)\n", i + 1,
1333                   algo, produced, ctemplate[i].outlen);
1334            return -EINVAL;
1335        }
1336
1337        if (memcmp(result, ctemplate[i].output, ctemplate[i].outlen)) {
1338            pr_err("alg: pcomp: Compression test %d failed for "
1339                   "%s\n", i + 1, algo);
1340            hexdump(result, ctemplate[i].outlen);
1341            return -EINVAL;
1342        }
1343    }
1344
1345    for (i = 0; i < dtcount; i++) {
1346        struct comp_request req;
1347        unsigned int produced = 0;
1348
1349        res = crypto_decompress_setup(tfm, dtemplate[i].params,
1350                          dtemplate[i].paramsize);
1351        if (res) {
1352            pr_err("alg: pcomp: decompression setup failed on "
1353                   "test %d for %s: error=%d\n", i + 1, algo, res);
1354            return res;
1355        }
1356
1357        res = crypto_decompress_init(tfm);
1358        if (res) {
1359            pr_err("alg: pcomp: decompression init failed on test "
1360                   "%d for %s: error=%d\n", i + 1, algo, res);
1361            return res;
1362        }
1363
1364        memset(result, 0, sizeof(result));
1365
1366        req.next_in = dtemplate[i].input;
1367        req.avail_in = dtemplate[i].inlen / 2;
1368        req.next_out = result;
1369        req.avail_out = dtemplate[i].outlen / 2;
1370
1371        res = crypto_decompress_update(tfm, &req);
1372        if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1373            pr_err("alg: pcomp: decompression update failed on "
1374                   "test %d for %s: error=%d\n", i + 1, algo, res);
1375            return res;
1376        }
1377        if (res > 0)
1378            produced += res;
1379
1380        /* Add remaining input data */
1381        req.avail_in += (dtemplate[i].inlen + 1) / 2;
1382
1383        res = crypto_decompress_update(tfm, &req);
1384        if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1385            pr_err("alg: pcomp: decompression update failed on "
1386                   "test %d for %s: error=%d\n", i + 1, algo, res);
1387            return res;
1388        }
1389        if (res > 0)
1390            produced += res;
1391
1392        /* Provide remaining output space */
1393        req.avail_out += COMP_BUF_SIZE - dtemplate[i].outlen / 2;
1394
1395        res = crypto_decompress_final(tfm, &req);
1396        if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1397            pr_err("alg: pcomp: decompression final failed on "
1398                   "test %d for %s: error=%d\n", i + 1, algo, res);
1399            return res;
1400        }
1401        if (res > 0)
1402            produced += res;
1403
1404        if (COMP_BUF_SIZE - req.avail_out != dtemplate[i].outlen) {
1405            pr_err("alg: comp: Decompression test %d failed for "
1406                   "%s: output len = %d (expected %d)\n", i + 1,
1407                   algo, COMP_BUF_SIZE - req.avail_out,
1408                   dtemplate[i].outlen);
1409            return -EINVAL;
1410        }
1411
1412        if (produced != dtemplate[i].outlen) {
1413            pr_err("alg: comp: Decompression test %d failed for "
1414                   "%s: returned len = %u (expected %d)\n", i + 1,
1415                   algo, produced, dtemplate[i].outlen);
1416            return -EINVAL;
1417        }
1418
1419        if (memcmp(result, dtemplate[i].output, dtemplate[i].outlen)) {
1420            pr_err("alg: pcomp: Decompression test %d failed for "
1421                   "%s\n", i + 1, algo);
1422            hexdump(result, dtemplate[i].outlen);
1423            return -EINVAL;
1424        }
1425    }
1426
1427    return 0;
1428}
1429
1430
1431static int test_cprng(struct crypto_rng *tfm, struct cprng_testvec *template,
1432              unsigned int tcount)
1433{
1434    const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm));
1435    int err = 0, i, j, seedsize;
1436    u8 *seed;
1437    char result[32];
1438
1439    seedsize = crypto_rng_seedsize(tfm);
1440
1441    seed = kmalloc(seedsize, GFP_KERNEL);
1442    if (!seed) {
1443        printk(KERN_ERR "alg: cprng: Failed to allocate seed space "
1444               "for %s\n", algo);
1445        return -ENOMEM;
1446    }
1447
1448    for (i = 0; i < tcount; i++) {
1449        memset(result, 0, 32);
1450
1451        memcpy(seed, template[i].v, template[i].vlen);
1452        memcpy(seed + template[i].vlen, template[i].key,
1453               template[i].klen);
1454        memcpy(seed + template[i].vlen + template[i].klen,
1455               template[i].dt, template[i].dtlen);
1456
1457        err = crypto_rng_reset(tfm, seed, seedsize);
1458        if (err) {
1459            printk(KERN_ERR "alg: cprng: Failed to reset rng "
1460                   "for %s\n", algo);
1461            goto out;
1462        }
1463
1464        for (j = 0; j < template[i].loops; j++) {
1465            err = crypto_rng_get_bytes(tfm, result,
1466                           template[i].rlen);
1467            if (err != template[i].rlen) {
1468                printk(KERN_ERR "alg: cprng: Failed to obtain "
1469                       "the correct amount of random data for "
1470                       "%s (requested %d, got %d)\n", algo,
1471                       template[i].rlen, err);
1472                goto out;
1473            }
1474        }
1475
1476        err = memcmp(result, template[i].result,
1477                 template[i].rlen);
1478        if (err) {
1479            printk(KERN_ERR "alg: cprng: Test %d failed for %s\n",
1480                   i, algo);
1481            hexdump(result, template[i].rlen);
1482            err = -EINVAL;
1483            goto out;
1484        }
1485    }
1486
1487out:
1488    kfree(seed);
1489    return err;
1490}
1491
1492static int alg_test_aead(const struct alg_test_desc *desc, const char *driver,
1493             u32 type, u32 mask)
1494{
1495    struct crypto_aead *tfm;
1496    int err = 0;
1497
1498    tfm = crypto_alloc_aead(driver, type, mask);
1499    if (IS_ERR(tfm)) {
1500        printk(KERN_ERR "alg: aead: Failed to load transform for %s: "
1501               "%ld\n", driver, PTR_ERR(tfm));
1502        return PTR_ERR(tfm);
1503    }
1504
1505    if (desc->suite.aead.enc.vecs) {
1506        err = test_aead(tfm, ENCRYPT, desc->suite.aead.enc.vecs,
1507                desc->suite.aead.enc.count);
1508        if (err)
1509            goto out;
1510    }
1511
1512    if (!err && desc->suite.aead.dec.vecs)
1513        err = test_aead(tfm, DECRYPT, desc->suite.aead.dec.vecs,
1514                desc->suite.aead.dec.count);
1515
1516out:
1517    crypto_free_aead(tfm);
1518    return err;
1519}
1520
1521static int alg_test_cipher(const struct alg_test_desc *desc,
1522               const char *driver, u32 type, u32 mask)
1523{
1524    struct crypto_cipher *tfm;
1525    int err = 0;
1526
1527    tfm = crypto_alloc_cipher(driver, type, mask);
1528    if (IS_ERR(tfm)) {
1529        printk(KERN_ERR "alg: cipher: Failed to load transform for "
1530               "%s: %ld\n", driver, PTR_ERR(tfm));
1531        return PTR_ERR(tfm);
1532    }
1533
1534    if (desc->suite.cipher.enc.vecs) {
1535        err = test_cipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1536                  desc->suite.cipher.enc.count);
1537        if (err)
1538            goto out;
1539    }
1540
1541    if (desc->suite.cipher.dec.vecs)
1542        err = test_cipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1543                  desc->suite.cipher.dec.count);
1544
1545out:
1546    crypto_free_cipher(tfm);
1547    return err;
1548}
1549
1550static int alg_test_skcipher(const struct alg_test_desc *desc,
1551                 const char *driver, u32 type, u32 mask)
1552{
1553    struct crypto_ablkcipher *tfm;
1554    int err = 0;
1555
1556    tfm = crypto_alloc_ablkcipher(driver, type, mask);
1557    if (IS_ERR(tfm)) {
1558        printk(KERN_ERR "alg: skcipher: Failed to load transform for "
1559               "%s: %ld\n", driver, PTR_ERR(tfm));
1560        return PTR_ERR(tfm);
1561    }
1562
1563    if (desc->suite.cipher.enc.vecs) {
1564        err = test_skcipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1565                    desc->suite.cipher.enc.count);
1566        if (err)
1567            goto out;
1568    }
1569
1570    if (desc->suite.cipher.dec.vecs)
1571        err = test_skcipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1572                    desc->suite.cipher.dec.count);
1573
1574out:
1575    crypto_free_ablkcipher(tfm);
1576    return err;
1577}
1578
1579static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
1580             u32 type, u32 mask)
1581{
1582    struct crypto_comp *tfm;
1583    int err;
1584
1585    tfm = crypto_alloc_comp(driver, type, mask);
1586    if (IS_ERR(tfm)) {
1587        printk(KERN_ERR "alg: comp: Failed to load transform for %s: "
1588               "%ld\n", driver, PTR_ERR(tfm));
1589        return PTR_ERR(tfm);
1590    }
1591
1592    err = test_comp(tfm, desc->suite.comp.comp.vecs,
1593            desc->suite.comp.decomp.vecs,
1594            desc->suite.comp.comp.count,
1595            desc->suite.comp.decomp.count);
1596
1597    crypto_free_comp(tfm);
1598    return err;
1599}
1600
1601static int alg_test_pcomp(const struct alg_test_desc *desc, const char *driver,
1602              u32 type, u32 mask)
1603{
1604    struct crypto_pcomp *tfm;
1605    int err;
1606
1607    tfm = crypto_alloc_pcomp(driver, type, mask);
1608    if (IS_ERR(tfm)) {
1609        pr_err("alg: pcomp: Failed to load transform for %s: %ld\n",
1610               driver, PTR_ERR(tfm));
1611        return PTR_ERR(tfm);
1612    }
1613
1614    err = test_pcomp(tfm, desc->suite.pcomp.comp.vecs,
1615             desc->suite.pcomp.decomp.vecs,
1616             desc->suite.pcomp.comp.count,
1617             desc->suite.pcomp.decomp.count);
1618
1619    crypto_free_pcomp(tfm);
1620    return err;
1621}
1622
1623static int alg_test_hash(const struct alg_test_desc *desc, const char *driver,
1624             u32 type, u32 mask)
1625{
1626    struct crypto_ahash *tfm;
1627    int err;
1628
1629    tfm = crypto_alloc_ahash(driver, type, mask);
1630    if (IS_ERR(tfm)) {
1631        printk(KERN_ERR "alg: hash: Failed to load transform for %s: "
1632               "%ld\n", driver, PTR_ERR(tfm));
1633        return PTR_ERR(tfm);
1634    }
1635
1636    err = test_hash(tfm, desc->suite.hash.vecs,
1637            desc->suite.hash.count, true);
1638    if (!err)
1639        err = test_hash(tfm, desc->suite.hash.vecs,
1640                desc->suite.hash.count, false);
1641
1642    crypto_free_ahash(tfm);
1643    return err;
1644}
1645
1646static int alg_test_crc32c(const struct alg_test_desc *desc,
1647               const char *driver, u32 type, u32 mask)
1648{
1649    struct crypto_shash *tfm;
1650    u32 val;
1651    int err;
1652
1653    err = alg_test_hash(desc, driver, type, mask);
1654    if (err)
1655        goto out;
1656
1657    tfm = crypto_alloc_shash(driver, type, mask);
1658    if (IS_ERR(tfm)) {
1659        printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: "
1660               "%ld\n", driver, PTR_ERR(tfm));
1661        err = PTR_ERR(tfm);
1662        goto out;
1663    }
1664
1665    do {
1666        struct {
1667            struct shash_desc shash;
1668            char ctx[crypto_shash_descsize(tfm)];
1669        } sdesc;
1670
1671        sdesc.shash.tfm = tfm;
1672        sdesc.shash.flags = 0;
1673
1674        *(u32 *)sdesc.ctx = le32_to_cpu(420553207);
1675        err = crypto_shash_final(&sdesc.shash, (u8 *)&val);
1676        if (err) {
1677            printk(KERN_ERR "alg: crc32c: Operation failed for "
1678                   "%s: %d\n", driver, err);
1679            break;
1680        }
1681
1682        if (val != ~420553207) {
1683            printk(KERN_ERR "alg: crc32c: Test failed for %s: "
1684                   "%d\n", driver, val);
1685            err = -EINVAL;
1686        }
1687    } while (0);
1688
1689    crypto_free_shash(tfm);
1690
1691out:
1692    return err;
1693}
1694
1695static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver,
1696              u32 type, u32 mask)
1697{
1698    struct crypto_rng *rng;
1699    int err;
1700
1701    rng = crypto_alloc_rng(driver, type, mask);
1702    if (IS_ERR(rng)) {
1703        printk(KERN_ERR "alg: cprng: Failed to load transform for %s: "
1704               "%ld\n", driver, PTR_ERR(rng));
1705        return PTR_ERR(rng);
1706    }
1707
1708    err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count);
1709
1710    crypto_free_rng(rng);
1711
1712    return err;
1713}
1714
1715static int alg_test_null(const struct alg_test_desc *desc,
1716                 const char *driver, u32 type, u32 mask)
1717{
1718    return 0;
1719}
1720
1721/* Please keep this list sorted by algorithm name. */
1722static const struct alg_test_desc alg_test_descs[] = {
1723    {
1724        .alg = "__cbc-cast5-avx",
1725        .test = alg_test_null,
1726    }, {
1727        .alg = "__cbc-cast6-avx",
1728        .test = alg_test_null,
1729    }, {
1730        .alg = "__cbc-serpent-avx",
1731        .test = alg_test_null,
1732    }, {
1733        .alg = "__cbc-serpent-avx2",
1734        .test = alg_test_null,
1735    }, {
1736        .alg = "__cbc-serpent-sse2",
1737        .test = alg_test_null,
1738    }, {
1739        .alg = "__cbc-twofish-avx",
1740        .test = alg_test_null,
1741    }, {
1742        .alg = "__driver-cbc-aes-aesni",
1743        .test = alg_test_null,
1744        .fips_allowed = 1,
1745    }, {
1746        .alg = "__driver-cbc-camellia-aesni",
1747        .test = alg_test_null,
1748    }, {
1749        .alg = "__driver-cbc-camellia-aesni-avx2",
1750        .test = alg_test_null,
1751    }, {
1752        .alg = "__driver-cbc-cast5-avx",
1753        .test = alg_test_null,
1754    }, {
1755        .alg = "__driver-cbc-cast6-avx",
1756        .test = alg_test_null,
1757    }, {
1758        .alg = "__driver-cbc-serpent-avx",
1759        .test = alg_test_null,
1760    }, {
1761        .alg = "__driver-cbc-serpent-avx2",
1762        .test = alg_test_null,
1763    }, {
1764        .alg = "__driver-cbc-serpent-sse2",
1765        .test = alg_test_null,
1766    }, {
1767        .alg = "__driver-cbc-twofish-avx",
1768        .test = alg_test_null,
1769    }, {
1770        .alg = "__driver-ecb-aes-aesni",
1771        .test = alg_test_null,
1772        .fips_allowed = 1,
1773    }, {
1774        .alg = "__driver-ecb-camellia-aesni",
1775        .test = alg_test_null,
1776    }, {
1777        .alg = "__driver-ecb-camellia-aesni-avx2",
1778        .test = alg_test_null,
1779    }, {
1780        .alg = "__driver-ecb-cast5-avx",
1781        .test = alg_test_null,
1782    }, {
1783        .alg = "__driver-ecb-cast6-avx",
1784        .test = alg_test_null,
1785    }, {
1786        .alg = "__driver-ecb-serpent-avx",
1787        .test = alg_test_null,
1788    }, {
1789        .alg = "__driver-ecb-serpent-avx2",
1790        .test = alg_test_null,
1791    }, {
1792        .alg = "__driver-ecb-serpent-sse2",
1793        .test = alg_test_null,
1794    }, {
1795        .alg = "__driver-ecb-twofish-avx",
1796        .test = alg_test_null,
1797    }, {
1798        .alg = "__ghash-pclmulqdqni",
1799        .test = alg_test_null,
1800        .fips_allowed = 1,
1801    }, {
1802        .alg = "ansi_cprng",
1803        .test = alg_test_cprng,
1804        .fips_allowed = 1,
1805        .suite = {
1806            .cprng = {
1807                .vecs = ansi_cprng_aes_tv_template,
1808                .count = ANSI_CPRNG_AES_TEST_VECTORS
1809            }
1810        }
1811    }, {
1812        .alg = "authenc(hmac(md5),ecb(cipher_null))",
1813        .test = alg_test_aead,
1814        .fips_allowed = 1,
1815        .suite = {
1816            .aead = {
1817                .enc = {
1818                    .vecs = hmac_md5_ecb_cipher_null_enc_tv_template,
1819                    .count = HMAC_MD5_ECB_CIPHER_NULL_ENC_TEST_VECTORS
1820                },
1821                .dec = {
1822                    .vecs = hmac_md5_ecb_cipher_null_dec_tv_template,
1823                    .count = HMAC_MD5_ECB_CIPHER_NULL_DEC_TEST_VECTORS
1824                }
1825            }
1826        }
1827    }, {
1828        .alg = "authenc(hmac(sha1),cbc(aes))",
1829        .test = alg_test_aead,
1830        .fips_allowed = 1,
1831        .suite = {
1832            .aead = {
1833                .enc = {
1834                    .vecs = hmac_sha1_aes_cbc_enc_tv_template,
1835                    .count = HMAC_SHA1_AES_CBC_ENC_TEST_VECTORS
1836                }
1837            }
1838        }
1839    }, {
1840        .alg = "authenc(hmac(sha1),ecb(cipher_null))",
1841        .test = alg_test_aead,
1842        .fips_allowed = 1,
1843        .suite = {
1844            .aead = {
1845                .enc = {
1846                    .vecs = hmac_sha1_ecb_cipher_null_enc_tv_template,
1847                    .count = HMAC_SHA1_ECB_CIPHER_NULL_ENC_TEST_VECTORS
1848                },
1849                .dec = {
1850                    .vecs = hmac_sha1_ecb_cipher_null_dec_tv_template,
1851                    .count = HMAC_SHA1_ECB_CIPHER_NULL_DEC_TEST_VECTORS
1852                }
1853            }
1854        }
1855    }, {
1856        .alg = "authenc(hmac(sha256),cbc(aes))",
1857        .test = alg_test_aead,
1858        .fips_allowed = 1,
1859        .suite = {
1860            .aead = {
1861                .enc = {
1862                    .vecs = hmac_sha256_aes_cbc_enc_tv_template,
1863                    .count = HMAC_SHA256_AES_CBC_ENC_TEST_VECTORS
1864                }
1865            }
1866        }
1867    }, {
1868        .alg = "authenc(hmac(sha512),cbc(aes))",
1869        .test = alg_test_aead,
1870        .fips_allowed = 1,
1871        .suite = {
1872            .aead = {
1873                .enc = {
1874                    .vecs = hmac_sha512_aes_cbc_enc_tv_template,
1875                    .count = HMAC_SHA512_AES_CBC_ENC_TEST_VECTORS
1876                }
1877            }
1878        }
1879    }, {
1880        .alg = "cbc(aes)",
1881        .test = alg_test_skcipher,
1882        .fips_allowed = 1,
1883        .suite = {
1884            .cipher = {
1885                .enc = {
1886                    .vecs = aes_cbc_enc_tv_template,
1887                    .count = AES_CBC_ENC_TEST_VECTORS
1888                },
1889                .dec = {
1890                    .vecs = aes_cbc_dec_tv_template,
1891                    .count = AES_CBC_DEC_TEST_VECTORS
1892                }
1893            }
1894        }
1895    }, {
1896        .alg = "cbc(anubis)",
1897        .test = alg_test_skcipher,
1898        .suite = {
1899            .cipher = {
1900                .enc = {
1901                    .vecs = anubis_cbc_enc_tv_template,
1902                    .count = ANUBIS_CBC_ENC_TEST_VECTORS
1903                },
1904                .dec = {
1905                    .vecs = anubis_cbc_dec_tv_template,
1906                    .count = ANUBIS_CBC_DEC_TEST_VECTORS
1907                }
1908            }
1909        }
1910    }, {
1911        .alg = "cbc(blowfish)",
1912        .test = alg_test_skcipher,
1913        .suite = {
1914            .cipher = {
1915                .enc = {
1916                    .vecs = bf_cbc_enc_tv_template,
1917                    .count = BF_CBC_ENC_TEST_VECTORS
1918                },
1919                .dec = {
1920                    .vecs = bf_cbc_dec_tv_template,
1921                    .count = BF_CBC_DEC_TEST_VECTORS
1922                }
1923            }
1924        }
1925    }, {
1926        .alg = "cbc(camellia)",
1927        .test = alg_test_skcipher,
1928        .suite = {
1929            .cipher = {
1930                .enc = {
1931                    .vecs = camellia_cbc_enc_tv_template,
1932                    .count = CAMELLIA_CBC_ENC_TEST_VECTORS
1933                },
1934                .dec = {
1935                    .vecs = camellia_cbc_dec_tv_template,
1936                    .count = CAMELLIA_CBC_DEC_TEST_VECTORS
1937                }
1938            }
1939        }
1940    }, {
1941        .alg = "cbc(cast5)",
1942        .test = alg_test_skcipher,
1943        .suite = {
1944            .cipher = {
1945                .enc = {
1946                    .vecs = cast5_cbc_enc_tv_template,
1947                    .count = CAST5_CBC_ENC_TEST_VECTORS
1948                },
1949                .dec = {
1950                    .vecs = cast5_cbc_dec_tv_template,
1951                    .count = CAST5_CBC_DEC_TEST_VECTORS
1952                }
1953            }
1954        }
1955    }, {
1956        .alg = "cbc(cast6)",
1957        .test = alg_test_skcipher,
1958        .suite = {
1959            .cipher = {
1960                .enc = {
1961                    .vecs = cast6_cbc_enc_tv_template,
1962                    .count = CAST6_CBC_ENC_TEST_VECTORS
1963                },
1964                .dec = {
1965                    .vecs = cast6_cbc_dec_tv_template,
1966                    .count = CAST6_CBC_DEC_TEST_VECTORS
1967                }
1968            }
1969        }
1970    }, {
1971        .alg = "cbc(des)",
1972        .test = alg_test_skcipher,
1973        .suite = {
1974            .cipher = {
1975                .enc = {
1976                    .vecs = des_cbc_enc_tv_template,
1977                    .count = DES_CBC_ENC_TEST_VECTORS
1978                },
1979                .dec = {
1980                    .vecs = des_cbc_dec_tv_template,
1981                    .count = DES_CBC_DEC_TEST_VECTORS
1982                }
1983            }
1984        }
1985    }, {
1986        .alg = "cbc(des3_ede)",
1987        .test = alg_test_skcipher,
1988        .fips_allowed = 1,
1989        .suite = {
1990            .cipher = {
1991                .enc = {
1992                    .vecs = des3_ede_cbc_enc_tv_template,
1993                    .count = DES3_EDE_CBC_ENC_TEST_VECTORS
1994                },
1995                .dec = {
1996                    .vecs = des3_ede_cbc_dec_tv_template,
1997                    .count = DES3_EDE_CBC_DEC_TEST_VECTORS
1998                }
1999            }
2000        }
2001    }, {
2002        .alg = "cbc(serpent)",
2003        .test = alg_test_skcipher,
2004        .suite = {
2005            .cipher = {
2006                .enc = {
2007                    .vecs = serpent_cbc_enc_tv_template,
2008                    .count = SERPENT_CBC_ENC_TEST_VECTORS
2009                },
2010                .dec = {
2011                    .vecs = serpent_cbc_dec_tv_template,
2012                    .count = SERPENT_CBC_DEC_TEST_VECTORS
2013                }
2014            }
2015        }
2016    }, {
2017        .alg = "cbc(twofish)",
2018        .test = alg_test_skcipher,
2019        .suite = {
2020            .cipher = {
2021                .enc = {
2022                    .vecs = tf_cbc_enc_tv_template,
2023                    .count = TF_CBC_ENC_TEST_VECTORS
2024                },
2025                .dec = {
2026                    .vecs = tf_cbc_dec_tv_template,
2027                    .count = TF_CBC_DEC_TEST_VECTORS
2028                }
2029            }
2030        }
2031    }, {
2032        .alg = "ccm(aes)",
2033        .test = alg_test_aead,
2034        .fips_allowed = 1,
2035        .suite = {
2036            .aead = {
2037                .enc = {
2038                    .vecs = aes_ccm_enc_tv_template,
2039                    .count = AES_CCM_ENC_TEST_VECTORS
2040                },
2041                .dec = {
2042                    .vecs = aes_ccm_dec_tv_template,
2043                    .count = AES_CCM_DEC_TEST_VECTORS
2044                }
2045            }
2046        }
2047    }, {
2048        .alg = "cmac(aes)",
2049        .test = alg_test_hash,
2050        .suite = {
2051            .hash = {
2052                .vecs = aes_cmac128_tv_template,
2053                .count = CMAC_AES_TEST_VECTORS
2054            }
2055        }
2056    }, {
2057        .alg = "cmac(des3_ede)",
2058        .test = alg_test_hash,
2059        .suite = {
2060            .hash = {
2061                .vecs = des3_ede_cmac64_tv_template,
2062                .count = CMAC_DES3_EDE_TEST_VECTORS
2063            }
2064        }
2065    }, {
2066        .alg = "compress_null",
2067        .test = alg_test_null,
2068    }, {
2069        .alg = "crc32c",
2070        .test = alg_test_crc32c,
2071        .fips_allowed = 1,
2072        .suite = {
2073            .hash = {
2074                .vecs = crc32c_tv_template,
2075                .count = CRC32C_TEST_VECTORS
2076            }
2077        }
2078    }, {
2079        .alg = "crct10dif",
2080        .test = alg_test_hash,
2081        .fips_allowed = 1,
2082        .suite = {
2083            .hash = {
2084                .vecs = crct10dif_tv_template,
2085                .count = CRCT10DIF_TEST_VECTORS
2086            }
2087        }
2088    }, {
2089        .alg = "cryptd(__driver-cbc-aes-aesni)",
2090        .test = alg_test_null,
2091        .fips_allowed = 1,
2092    }, {
2093        .alg = "cryptd(__driver-cbc-camellia-aesni)",
2094        .test = alg_test_null,
2095    }, {
2096        .alg = "cryptd(__driver-cbc-camellia-aesni-avx2)",
2097        .test = alg_test_null,
2098    }, {
2099        .alg = "cryptd(__driver-cbc-serpent-avx2)",
2100        .test = alg_test_null,
2101    }, {
2102        .alg = "cryptd(__driver-ecb-aes-aesni)",
2103        .test = alg_test_null,
2104        .fips_allowed = 1,
2105    }, {
2106        .alg = "cryptd(__driver-ecb-camellia-aesni)",
2107        .test = alg_test_null,
2108    }, {
2109        .alg = "cryptd(__driver-ecb-camellia-aesni-avx2)",
2110        .test = alg_test_null,
2111    }, {
2112        .alg = "cryptd(__driver-ecb-cast5-avx)",
2113        .test = alg_test_null,
2114    }, {
2115        .alg = "cryptd(__driver-ecb-cast6-avx)",
2116        .test = alg_test_null,
2117    }, {
2118        .alg = "cryptd(__driver-ecb-serpent-avx)",
2119        .test = alg_test_null,
2120    }, {
2121        .alg = "cryptd(__driver-ecb-serpent-avx2)",
2122        .test = alg_test_null,
2123    }, {
2124        .alg = "cryptd(__driver-ecb-serpent-sse2)",
2125        .test = alg_test_null,
2126    }, {
2127        .alg = "cryptd(__driver-ecb-twofish-avx)",
2128        .test = alg_test_null,
2129    }, {
2130        .alg = "cryptd(__driver-gcm-aes-aesni)",
2131        .test = alg_test_null,
2132        .fips_allowed = 1,
2133    }, {
2134        .alg = "cryptd(__ghash-pclmulqdqni)",
2135        .test = alg_test_null,
2136        .fips_allowed = 1,
2137    }, {
2138        .alg = "ctr(aes)",
2139        .test = alg_test_skcipher,
2140        .fips_allowed = 1,
2141        .suite = {
2142            .cipher = {
2143                .enc = {
2144                    .vecs = aes_ctr_enc_tv_template,
2145                    .count = AES_CTR_ENC_TEST_VECTORS
2146                },
2147                .dec = {
2148                    .vecs = aes_ctr_dec_tv_template,
2149                    .count = AES_CTR_DEC_TEST_VECTORS
2150                }
2151            }
2152        }
2153    }, {
2154        .alg = "ctr(blowfish)",
2155        .test = alg_test_skcipher,
2156        .suite = {
2157            .cipher = {
2158                .enc = {
2159                    .vecs = bf_ctr_enc_tv_template,
2160                    .count = BF_CTR_ENC_TEST_VECTORS
2161                },
2162                .dec = {
2163                    .vecs = bf_ctr_dec_tv_template,
2164                    .count = BF_CTR_DEC_TEST_VECTORS
2165                }
2166            }
2167        }
2168    }, {
2169        .alg = "ctr(camellia)",
2170        .test = alg_test_skcipher,
2171        .suite = {
2172            .cipher = {
2173                .enc = {
2174                    .vecs = camellia_ctr_enc_tv_template,
2175                    .count = CAMELLIA_CTR_ENC_TEST_VECTORS
2176                },
2177                .dec = {
2178                    .vecs = camellia_ctr_dec_tv_template,
2179                    .count = CAMELLIA_CTR_DEC_TEST_VECTORS
2180                }
2181            }
2182        }
2183    }, {
2184        .alg = "ctr(cast5)",
2185        .test = alg_test_skcipher,
2186        .suite = {
2187            .cipher = {
2188                .enc = {
2189                    .vecs = cast5_ctr_enc_tv_template,
2190                    .count = CAST5_CTR_ENC_TEST_VECTORS
2191                },
2192                .dec = {
2193                    .vecs = cast5_ctr_dec_tv_template,
2194                    .count = CAST5_CTR_DEC_TEST_VECTORS
2195                }
2196            }
2197        }
2198    }, {
2199        .alg = "ctr(cast6)",
2200        .test = alg_test_skcipher,
2201        .suite = {
2202            .cipher = {
2203                .enc = {
2204                    .vecs = cast6_ctr_enc_tv_template,
2205                    .count = CAST6_CTR_ENC_TEST_VECTORS
2206                },
2207                .dec = {
2208                    .vecs = cast6_ctr_dec_tv_template,
2209                    .count = CAST6_CTR_DEC_TEST_VECTORS
2210                }
2211            }
2212        }
2213    }, {
2214        .alg = "ctr(des)",
2215        .test = alg_test_skcipher,
2216        .suite = {
2217            .cipher = {
2218                .enc = {
2219                    .vecs = des_ctr_enc_tv_template,
2220                    .count = DES_CTR_ENC_TEST_VECTORS
2221                },
2222                .dec = {
2223                    .vecs = des_ctr_dec_tv_template,
2224                    .count = DES_CTR_DEC_TEST_VECTORS
2225                }
2226            }
2227        }
2228    }, {
2229        .alg = "ctr(des3_ede)",
2230        .test = alg_test_skcipher,
2231        .suite = {
2232            .cipher = {
2233                .enc = {
2234                    .vecs = des3_ede_ctr_enc_tv_template,
2235                    .count = DES3_EDE_CTR_ENC_TEST_VECTORS
2236                },
2237                .dec = {
2238                    .vecs = des3_ede_ctr_dec_tv_template,
2239                    .count = DES3_EDE_CTR_DEC_TEST_VECTORS
2240                }
2241            }
2242        }
2243    }, {
2244        .alg = "ctr(serpent)",
2245        .test = alg_test_skcipher,
2246        .suite = {
2247            .cipher = {
2248                .enc = {
2249                    .vecs = serpent_ctr_enc_tv_template,
2250                    .count = SERPENT_CTR_ENC_TEST_VECTORS
2251                },
2252                .dec = {
2253                    .vecs = serpent_ctr_dec_tv_template,
2254                    .count = SERPENT_CTR_DEC_TEST_VECTORS
2255                }
2256            }
2257        }
2258    }, {
2259        .alg = "ctr(twofish)",
2260        .test = alg_test_skcipher,
2261        .suite = {
2262            .cipher = {
2263                .enc = {
2264                    .vecs = tf_ctr_enc_tv_template,
2265                    .count = TF_CTR_ENC_TEST_VECTORS
2266                },
2267                .dec = {
2268                    .vecs = tf_ctr_dec_tv_template,
2269                    .count = TF_CTR_DEC_TEST_VECTORS
2270                }
2271            }
2272        }
2273    }, {
2274        .alg = "cts(cbc(aes))",
2275        .test = alg_test_skcipher,
2276        .suite = {
2277            .cipher = {
2278                .enc = {
2279                    .vecs = cts_mode_enc_tv_template,
2280                    .count = CTS_MODE_ENC_TEST_VECTORS
2281                },
2282                .dec = {
2283                    .vecs = cts_mode_dec_tv_template,
2284                    .count = CTS_MODE_DEC_TEST_VECTORS
2285                }
2286            }
2287        }
2288    }, {
2289        .alg = "deflate",
2290        .test = alg_test_comp,
2291        .fips_allowed = 1,
2292        .suite = {
2293            .comp = {
2294                .comp = {
2295                    .vecs = deflate_comp_tv_template,
2296                    .count = DEFLATE_COMP_TEST_VECTORS
2297                },
2298                .decomp = {
2299                    .vecs = deflate_decomp_tv_template,
2300                    .count = DEFLATE_DECOMP_TEST_VECTORS
2301                }
2302            }
2303        }
2304    }, {
2305        .alg = "digest_null",
2306        .test = alg_test_null,
2307    }, {
2308        .alg = "ecb(__aes-aesni)",
2309        .test = alg_test_null,
2310        .fips_allowed = 1,
2311    }, {
2312        .alg = "ecb(aes)",
2313        .test = alg_test_skcipher,
2314        .fips_allowed = 1,
2315        .suite = {
2316            .cipher = {
2317                .enc = {
2318                    .vecs = aes_enc_tv_template,
2319                    .count = AES_ENC_TEST_VECTORS
2320                },
2321                .dec = {
2322                    .vecs = aes_dec_tv_template,
2323                    .count = AES_DEC_TEST_VECTORS
2324                }
2325            }
2326        }
2327    }, {
2328        .alg = "ecb(anubis)",
2329        .test = alg_test_skcipher,
2330        .suite = {
2331            .cipher = {
2332                .enc = {
2333                    .vecs = anubis_enc_tv_template,
2334                    .count = ANUBIS_ENC_TEST_VECTORS
2335                },
2336                .dec = {
2337                    .vecs = anubis_dec_tv_template,
2338                    .count = ANUBIS_DEC_TEST_VECTORS
2339                }
2340            }
2341        }
2342    }, {
2343        .alg = "ecb(arc4)",
2344        .test = alg_test_skcipher,
2345        .suite = {
2346            .cipher = {
2347                .enc = {
2348                    .vecs = arc4_enc_tv_template,
2349                    .count = ARC4_ENC_TEST_VECTORS
2350                },
2351                .dec = {
2352                    .vecs = arc4_dec_tv_template,
2353                    .count = ARC4_DEC_TEST_VECTORS
2354                }
2355            }
2356        }
2357    }, {
2358        .alg = "ecb(blowfish)",
2359        .test = alg_test_skcipher,
2360        .suite = {
2361            .cipher = {
2362                .enc = {
2363                    .vecs = bf_enc_tv_template,
2364                    .count = BF_ENC_TEST_VECTORS
2365                },
2366                .dec = {
2367                    .vecs = bf_dec_tv_template,
2368                    .count = BF_DEC_TEST_VECTORS
2369                }
2370            }
2371        }
2372    }, {
2373        .alg = "ecb(camellia)",
2374        .test = alg_test_skcipher,
2375        .suite = {
2376            .cipher = {
2377                .enc = {
2378                    .vecs = camellia_enc_tv_template,
2379                    .count = CAMELLIA_ENC_TEST_VECTORS
2380                },
2381                .dec = {
2382                    .vecs = camellia_dec_tv_template,
2383                    .count = CAMELLIA_DEC_TEST_VECTORS
2384                }
2385            }
2386        }
2387    }, {
2388        .alg = "ecb(cast5)",
2389        .test = alg_test_skcipher,
2390        .suite = {
2391            .cipher = {
2392                .enc = {
2393                    .vecs = cast5_enc_tv_template,
2394                    .count = CAST5_ENC_TEST_VECTORS
2395                },
2396                .dec = {
2397                    .vecs = cast5_dec_tv_template,
2398                    .count = CAST5_DEC_TEST_VECTORS
2399                }
2400            }
2401        }
2402    }, {
2403        .alg = "ecb(cast6)",
2404        .test = alg_test_skcipher,
2405        .suite = {
2406            .cipher = {
2407                .enc = {
2408                    .vecs = cast6_enc_tv_template,
2409                    .count = CAST6_ENC_TEST_VECTORS
2410                },
2411                .dec = {
2412                    .vecs = cast6_dec_tv_template,
2413                    .count = CAST6_DEC_TEST_VECTORS
2414                }
2415            }
2416        }
2417    }, {
2418        .alg = "ecb(cipher_null)",
2419        .test = alg_test_null,
2420    }, {
2421        .alg = "ecb(des)",
2422        .test = alg_test_skcipher,
2423        .fips_allowed = 1,
2424        .suite = {
2425            .cipher = {
2426                .enc = {
2427                    .vecs = des_enc_tv_template,
2428                    .count = DES_ENC_TEST_VECTORS
2429                },
2430                .dec = {
2431                    .vecs = des_dec_tv_template,
2432                    .count = DES_DEC_TEST_VECTORS
2433                }
2434            }
2435        }
2436    }, {
2437        .alg = "ecb(des3_ede)",
2438        .test = alg_test_skcipher,
2439        .fips_allowed = 1,
2440        .suite = {
2441            .cipher = {
2442                .enc = {
2443                    .vecs = des3_ede_enc_tv_template,
2444                    .count = DES3_EDE_ENC_TEST_VECTORS
2445                },
2446                .dec = {
2447                    .vecs = des3_ede_dec_tv_template,
2448                    .count = DES3_EDE_DEC_TEST_VECTORS
2449                }
2450            }
2451        }
2452    }, {
2453        .alg = "ecb(fcrypt)",
2454        .test = alg_test_skcipher,
2455        .suite = {
2456            .cipher = {
2457                .enc = {
2458                    .vecs = fcrypt_pcbc_enc_tv_template,
2459                    .count = 1
2460                },
2461                .dec = {
2462                    .vecs = fcrypt_pcbc_dec_tv_template,
2463                    .count = 1
2464                }
2465            }
2466        }
2467    }, {
2468        .alg = "ecb(khazad)",
2469        .test = alg_test_skcipher,
2470        .suite = {
2471            .cipher = {
2472                .enc = {
2473                    .vecs = khazad_enc_tv_template,
2474                    .count = KHAZAD_ENC_TEST_VECTORS
2475                },
2476                .dec = {
2477                    .vecs = khazad_dec_tv_template,
2478                    .count = KHAZAD_DEC_TEST_VECTORS
2479                }
2480            }
2481        }
2482    }, {
2483        .alg = "ecb(seed)",
2484        .test = alg_test_skcipher,
2485        .suite = {
2486            .cipher = {
2487                .enc = {
2488                    .vecs = seed_enc_tv_template,
2489                    .count = SEED_ENC_TEST_VECTORS
2490                },
2491                .dec = {
2492                    .vecs = seed_dec_tv_template,
2493                    .count = SEED_DEC_TEST_VECTORS
2494                }
2495            }
2496        }
2497    }, {
2498        .alg = "ecb(serpent)",
2499        .test = alg_test_skcipher,
2500        .suite = {
2501            .cipher = {
2502                .enc = {
2503                    .vecs = serpent_enc_tv_template,
2504                    .count = SERPENT_ENC_TEST_VECTORS
2505                },
2506                .dec = {
2507                    .vecs = serpent_dec_tv_template,
2508                    .count = SERPENT_DEC_TEST_VECTORS
2509                }
2510            }
2511        }
2512    }, {
2513        .alg = "ecb(tea)",
2514        .test = alg_test_skcipher,
2515        .suite = {
2516            .cipher = {
2517                .enc = {
2518                    .vecs = tea_enc_tv_template,
2519                    .count = TEA_ENC_TEST_VECTORS
2520                },
2521                .dec = {
2522                    .vecs = tea_dec_tv_template,
2523                    .count = TEA_DEC_TEST_VECTORS
2524                }
2525            }
2526        }
2527    }, {
2528        .alg = "ecb(tnepres)",
2529        .test = alg_test_skcipher,
2530        .suite = {
2531            .cipher = {
2532                .enc = {
2533                    .vecs = tnepres_enc_tv_template,
2534                    .count = TNEPRES_ENC_TEST_VECTORS
2535                },
2536                .dec = {
2537                    .vecs = tnepres_dec_tv_template,
2538                    .count = TNEPRES_DEC_TEST_VECTORS
2539                }
2540            }
2541        }
2542    }, {
2543        .alg = "ecb(twofish)",
2544        .test = alg_test_skcipher,
2545        .suite = {
2546            .cipher = {
2547                .enc = {
2548                    .vecs = tf_enc_tv_template,
2549                    .count = TF_ENC_TEST_VECTORS
2550                },
2551                .dec = {
2552                    .vecs = tf_dec_tv_template,
2553                    .count = TF_DEC_TEST_VECTORS
2554                }
2555            }
2556        }
2557    }, {
2558        .alg = "ecb(xeta)",
2559        .test = alg_test_skcipher,
2560        .suite = {
2561            .cipher = {
2562                .enc = {
2563                    .vecs = xeta_enc_tv_template,
2564                    .count = XETA_ENC_TEST_VECTORS
2565                },
2566                .dec = {
2567                    .vecs = xeta_dec_tv_template,
2568                    .count = XETA_DEC_TEST_VECTORS
2569                }
2570            }
2571        }
2572    }, {
2573        .alg = "ecb(xtea)",
2574        .test = alg_test_skcipher,
2575        .suite = {
2576            .cipher = {
2577                .enc = {
2578                    .vecs = xtea_enc_tv_template,
2579                    .count = XTEA_ENC_TEST_VECTORS
2580                },
2581                .dec = {
2582                    .vecs = xtea_dec_tv_template,
2583                    .count = XTEA_DEC_TEST_VECTORS
2584                }
2585            }
2586        }
2587    }, {
2588        .alg = "gcm(aes)",
2589        .test = alg_test_aead,
2590        .fips_allowed = 1,
2591        .suite = {
2592            .aead = {
2593                .enc = {
2594                    .vecs = aes_gcm_enc_tv_template,
2595                    .count = AES_GCM_ENC_TEST_VECTORS
2596                },
2597                .dec = {
2598                    .vecs = aes_gcm_dec_tv_template,
2599                    .count = AES_GCM_DEC_TEST_VECTORS
2600                }
2601            }
2602        }
2603    }, {
2604        .alg = "ghash",
2605        .test = alg_test_hash,
2606        .fips_allowed = 1,
2607        .suite = {
2608            .hash = {
2609                .vecs = ghash_tv_template,
2610                .count = GHASH_TEST_VECTORS
2611            }
2612        }
2613    }, {
2614        .alg = "hmac(crc32)",
2615        .test = alg_test_hash,
2616        .suite = {
2617            .hash = {
2618                .vecs = bfin_crc_tv_template,
2619                .count = BFIN_CRC_TEST_VECTORS
2620            }
2621        }
2622    }, {
2623        .alg = "hmac(md5)",
2624        .test = alg_test_hash,
2625        .suite = {
2626            .hash = {
2627                .vecs = hmac_md5_tv_template,
2628                .count = HMAC_MD5_TEST_VECTORS
2629            }
2630        }
2631    }, {
2632        .alg = "hmac(rmd128)",
2633        .test = alg_test_hash,
2634        .suite = {
2635            .hash = {
2636                .vecs = hmac_rmd128_tv_template,
2637                .count = HMAC_RMD128_TEST_VECTORS
2638            }
2639        }
2640    }, {
2641        .alg = "hmac(rmd160)",
2642        .test = alg_test_hash,
2643        .suite = {
2644            .hash = {
2645                .vecs = hmac_rmd160_tv_template,
2646                .count = HMAC_RMD160_TEST_VECTORS
2647            }
2648        }
2649    }, {
2650        .alg = "hmac(sha1)",
2651        .test = alg_test_hash,
2652        .fips_allowed = 1,
2653        .suite = {
2654            .hash = {
2655                .vecs = hmac_sha1_tv_template,
2656                .count = HMAC_SHA1_TEST_VECTORS
2657            }
2658        }
2659    }, {
2660        .alg = "hmac(sha224)",
2661        .test = alg_test_hash,
2662        .fips_allowed = 1,
2663        .suite = {
2664            .hash = {
2665                .vecs = hmac_sha224_tv_template,
2666                .count = HMAC_SHA224_TEST_VECTORS
2667            }
2668        }
2669    }, {
2670        .alg = "hmac(sha256)",
2671        .test = alg_test_hash,
2672        .fips_allowed = 1,
2673        .suite = {
2674            .hash = {
2675                .vecs = hmac_sha256_tv_template,
2676                .count = HMAC_SHA256_TEST_VECTORS
2677            }
2678        }
2679    }, {
2680        .alg = "hmac(sha384)",
2681        .test = alg_test_hash,
2682        .fips_allowed = 1,
2683        .suite = {
2684            .hash = {
2685                .vecs = hmac_sha384_tv_template,
2686                .count = HMAC_SHA384_TEST_VECTORS
2687            }
2688        }
2689    }, {
2690        .alg = "hmac(sha512)",
2691        .test = alg_test_hash,
2692        .fips_allowed = 1,
2693        .suite = {
2694            .hash = {
2695                .vecs = hmac_sha512_tv_template,
2696                .count = HMAC_SHA512_TEST_VECTORS
2697            }
2698        }
2699    }, {
2700        .alg = "lrw(aes)",
2701        .test = alg_test_skcipher,
2702        .suite = {
2703            .cipher = {
2704                .enc = {
2705                    .vecs = aes_lrw_enc_tv_template,
2706                    .count = AES_LRW_ENC_TEST_VECTORS
2707                },
2708                .dec = {
2709                    .vecs = aes_lrw_dec_tv_template,
2710                    .count = AES_LRW_DEC_TEST_VECTORS
2711                }
2712            }
2713        }
2714    }, {
2715        .alg = "lrw(camellia)",
2716        .test = alg_test_skcipher,
2717        .suite = {
2718            .cipher = {
2719                .enc = {
2720                    .vecs = camellia_lrw_enc_tv_template,
2721                    .count = CAMELLIA_LRW_ENC_TEST_VECTORS
2722                },
2723                .dec = {
2724                    .vecs = camellia_lrw_dec_tv_template,
2725                    .count = CAMELLIA_LRW_DEC_TEST_VECTORS
2726                }
2727            }
2728        }
2729    }, {
2730        .alg = "lrw(cast6)",
2731        .test = alg_test_skcipher,
2732        .suite = {
2733            .cipher = {
2734                .enc = {
2735                    .vecs = cast6_lrw_enc_tv_template,
2736                    .count = CAST6_LRW_ENC_TEST_VECTORS
2737                },
2738                .dec = {
2739                    .vecs = cast6_lrw_dec_tv_template,
2740                    .count = CAST6_LRW_DEC_TEST_VECTORS
2741                }
2742            }
2743        }
2744    }, {
2745        .alg = "lrw(serpent)",
2746        .test = alg_test_skcipher,
2747        .suite = {
2748            .cipher = {
2749                .enc = {
2750                    .vecs = serpent_lrw_enc_tv_template,
2751                    .count = SERPENT_LRW_ENC_TEST_VECTORS
2752                },
2753                .dec = {
2754                    .vecs = serpent_lrw_dec_tv_template,
2755                    .count = SERPENT_LRW_DEC_TEST_VECTORS
2756                }
2757            }
2758        }
2759    }, {
2760        .alg = "lrw(twofish)",
2761        .test = alg_test_skcipher,
2762        .suite = {
2763            .cipher = {
2764                .enc = {
2765                    .vecs = tf_lrw_enc_tv_template,
2766                    .count = TF_LRW_ENC_TEST_VECTORS
2767                },
2768                .dec = {
2769                    .vecs = tf_lrw_dec_tv_template,
2770                    .count = TF_LRW_DEC_TEST_VECTORS
2771                }
2772            }
2773        }
2774    }, {
2775        .alg = "lzo",
2776        .test = alg_test_comp,
2777        .fips_allowed = 1,
2778        .suite = {
2779            .comp = {
2780                .comp = {
2781                    .vecs = lzo_comp_tv_template,
2782                    .count = LZO_COMP_TEST_VECTORS
2783                },
2784                .decomp = {
2785                    .vecs = lzo_decomp_tv_template,
2786                    .count = LZO_DECOMP_TEST_VECTORS
2787                }
2788            }
2789        }
2790    }, {
2791        .alg = "md4",
2792        .test = alg_test_hash,
2793        .suite = {
2794            .hash = {
2795                .vecs = md4_tv_template,
2796                .count = MD4_TEST_VECTORS
2797            }
2798        }
2799    }, {
2800        .alg = "md5",
2801        .test = alg_test_hash,
2802        .suite = {
2803            .hash = {
2804                .vecs = md5_tv_template,
2805                .count = MD5_TEST_VECTORS
2806            }
2807        }
2808    }, {
2809        .alg = "michael_mic",
2810        .test = alg_test_hash,
2811        .suite = {
2812            .hash = {
2813                .vecs = michael_mic_tv_template,
2814                .count = MICHAEL_MIC_TEST_VECTORS
2815            }
2816        }
2817    }, {
2818        .alg = "ofb(aes)",
2819        .test = alg_test_skcipher,
2820        .fips_allowed = 1,
2821        .suite = {
2822            .cipher = {
2823                .enc = {
2824                    .vecs = aes_ofb_enc_tv_template,
2825                    .count = AES_OFB_ENC_TEST_VECTORS
2826                },
2827                .dec = {
2828                    .vecs = aes_ofb_dec_tv_template,
2829                    .count = AES_OFB_DEC_TEST_VECTORS
2830                }
2831            }
2832        }
2833    }, {
2834        .alg = "pcbc(fcrypt)",
2835        .test = alg_test_skcipher,
2836        .suite = {
2837            .cipher = {
2838                .enc = {
2839                    .vecs = fcrypt_pcbc_enc_tv_template,
2840                    .count = FCRYPT_ENC_TEST_VECTORS
2841                },
2842                .dec = {
2843                    .vecs = fcrypt_pcbc_dec_tv_template,
2844                    .count = FCRYPT_DEC_TEST_VECTORS
2845                }
2846            }
2847        }
2848    }, {
2849        .alg = "rfc3686(ctr(aes))",
2850        .test = alg_test_skcipher,
2851        .fips_allowed = 1,
2852        .suite = {
2853            .cipher = {
2854                .enc = {
2855                    .vecs = aes_ctr_rfc3686_enc_tv_template,
2856                    .count = AES_CTR_3686_ENC_TEST_VECTORS
2857                },
2858                .dec = {
2859                    .vecs = aes_ctr_rfc3686_dec_tv_template,
2860                    .count = AES_CTR_3686_DEC_TEST_VECTORS
2861                }
2862            }
2863        }
2864    }, {
2865        .alg = "rfc4106(gcm(aes))",
2866        .test = alg_test_aead,
2867        .suite = {
2868            .aead = {
2869                .enc = {
2870                    .vecs = aes_gcm_rfc4106_enc_tv_template,
2871                    .count = AES_GCM_4106_ENC_TEST_VECTORS
2872                },
2873                .dec = {
2874                    .vecs = aes_gcm_rfc4106_dec_tv_template,
2875                    .count = AES_GCM_4106_DEC_TEST_VECTORS
2876                }
2877            }
2878        }
2879    }, {
2880        .alg = "rfc4309(ccm(aes))",
2881        .test = alg_test_aead,
2882        .fips_allowed = 1,
2883        .suite = {
2884            .aead = {
2885                .enc = {
2886                    .vecs = aes_ccm_rfc4309_enc_tv_template,
2887                    .count = AES_CCM_4309_ENC_TEST_VECTORS
2888                },
2889                .dec = {
2890                    .vecs = aes_ccm_rfc4309_dec_tv_template,
2891                    .count = AES_CCM_4309_DEC_TEST_VECTORS
2892                }
2893            }
2894        }
2895    }, {
2896        .alg = "rfc4543(gcm(aes))",
2897        .test = alg_test_aead,
2898        .suite = {
2899            .aead = {
2900                .enc = {
2901                    .vecs = aes_gcm_rfc4543_enc_tv_template,
2902                    .count = AES_GCM_4543_ENC_TEST_VECTORS
2903                },
2904                .dec = {
2905                    .vecs = aes_gcm_rfc4543_dec_tv_template,
2906                    .count = AES_GCM_4543_DEC_TEST_VECTORS
2907                },
2908            }
2909        }
2910    }, {
2911        .alg = "rmd128",
2912        .test = alg_test_hash,
2913        .suite = {
2914            .hash = {
2915                .vecs = rmd128_tv_template,
2916                .count = RMD128_TEST_VECTORS
2917            }
2918        }
2919    }, {
2920        .alg = "rmd160",
2921        .test = alg_test_hash,
2922        .suite = {
2923            .hash = {
2924                .vecs = rmd160_tv_template,
2925                .count = RMD160_TEST_VECTORS
2926            }
2927        }
2928    }, {
2929        .alg = "rmd256",
2930        .test = alg_test_hash,
2931        .suite = {
2932            .hash = {
2933                .vecs = rmd256_tv_template,
2934                .count = RMD256_TEST_VECTORS
2935            }
2936        }
2937    }, {
2938        .alg = "rmd320",
2939        .test = alg_test_hash,
2940        .suite = {
2941            .hash = {
2942                .vecs = rmd320_tv_template,
2943                .count = RMD320_TEST_VECTORS
2944            }
2945        }
2946    }, {
2947        .alg = "salsa20",
2948        .test = alg_test_skcipher,
2949        .suite = {
2950            .cipher = {
2951                .enc = {
2952                    .vecs = salsa20_stream_enc_tv_template,
2953                    .count = SALSA20_STREAM_ENC_TEST_VECTORS
2954                }
2955            }
2956        }
2957    }, {
2958        .alg = "sha1",
2959        .test = alg_test_hash,
2960        .fips_allowed = 1,
2961        .suite = {
2962            .hash = {
2963                .vecs = sha1_tv_template,
2964                .count = SHA1_TEST_VECTORS
2965            }
2966        }
2967    }, {
2968        .alg = "sha224",
2969        .test = alg_test_hash,
2970        .fips_allowed = 1,
2971        .suite = {
2972            .hash = {
2973                .vecs = sha224_tv_template,
2974                .count = SHA224_TEST_VECTORS
2975            }
2976        }
2977    }, {
2978        .alg = "sha256",
2979        .test = alg_test_hash,
2980        .fips_allowed = 1,
2981        .suite = {
2982            .hash = {
2983                .vecs = sha256_tv_template,
2984                .count = SHA256_TEST_VECTORS
2985            }
2986        }
2987    }, {
2988        .alg = "sha384",
2989        .test = alg_test_hash,
2990        .fips_allowed = 1,
2991        .suite = {
2992            .hash = {
2993                .vecs = sha384_tv_template,
2994                .count = SHA384_TEST_VECTORS
2995            }
2996        }
2997    }, {
2998        .alg = "sha512",
2999        .test = alg_test_hash,
3000        .fips_allowed = 1,
3001        .suite = {
3002            .hash = {
3003                .vecs = sha512_tv_template,
3004                .count = SHA512_TEST_VECTORS
3005            }
3006        }
3007    }, {
3008        .alg = "tgr128",
3009        .test = alg_test_hash,
3010        .suite = {
3011            .hash = {
3012                .vecs = tgr128_tv_template,
3013                .count = TGR128_TEST_VECTORS
3014            }
3015        }
3016    }, {
3017        .alg = "tgr160",
3018        .test = alg_test_hash,
3019        .suite = {
3020            .hash = {
3021                .vecs = tgr160_tv_template,
3022                .count = TGR160_TEST_VECTORS
3023            }
3024        }
3025    }, {
3026        .alg = "tgr192",
3027        .test = alg_test_hash,
3028        .suite = {
3029            .hash = {
3030                .vecs = tgr192_tv_template,
3031                .count = TGR192_TEST_VECTORS
3032            }
3033        }
3034    }, {
3035        .alg = "vmac(aes)",
3036        .test = alg_test_hash,
3037        .suite = {
3038            .hash = {
3039                .vecs = aes_vmac128_tv_template,
3040                .count = VMAC_AES_TEST_VECTORS
3041            }
3042        }
3043    }, {
3044        .alg = "wp256",
3045        .test = alg_test_hash,
3046        .suite = {
3047            .hash = {
3048                .vecs = wp256_tv_template,
3049                .count = WP256_TEST_VECTORS
3050            }
3051        }
3052    }, {
3053        .alg = "wp384",
3054        .test = alg_test_hash,
3055        .suite = {
3056            .hash = {
3057                .vecs = wp384_tv_template,
3058                .count = WP384_TEST_VECTORS
3059            }
3060        }
3061    }, {
3062        .alg = "wp512",
3063        .test = alg_test_hash,
3064        .suite = {
3065            .hash = {
3066                .vecs = wp512_tv_template,
3067                .count = WP512_TEST_VECTORS
3068            }
3069        }
3070    }, {
3071        .alg = "xcbc(aes)",
3072        .test = alg_test_hash,
3073        .suite = {
3074            .hash = {
3075                .vecs = aes_xcbc128_tv_template,
3076                .count = XCBC_AES_TEST_VECTORS
3077            }
3078        }
3079    }, {
3080        .alg = "xts(aes)",
3081        .test = alg_test_skcipher,
3082        .fips_allowed = 1,
3083        .suite = {
3084            .cipher = {
3085                .enc = {
3086                    .vecs = aes_xts_enc_tv_template,
3087                    .count = AES_XTS_ENC_TEST_VECTORS
3088                },
3089                .dec = {
3090                    .vecs = aes_xts_dec_tv_template,
3091                    .count = AES_XTS_DEC_TEST_VECTORS
3092                }
3093            }
3094        }
3095    }, {
3096        .alg = "xts(camellia)",
3097        .test = alg_test_skcipher,
3098        .suite = {
3099            .cipher = {
3100                .enc = {
3101                    .vecs = camellia_xts_enc_tv_template,
3102                    .count = CAMELLIA_XTS_ENC_TEST_VECTORS
3103                },
3104                .dec = {
3105                    .vecs = camellia_xts_dec_tv_template,
3106                    .count = CAMELLIA_XTS_DEC_TEST_VECTORS
3107                }
3108            }
3109        }
3110    }, {
3111        .alg = "xts(cast6)",
3112        .test = alg_test_skcipher,
3113        .suite = {
3114            .cipher = {
3115                .enc = {
3116                    .vecs = cast6_xts_enc_tv_template,
3117                    .count = CAST6_XTS_ENC_TEST_VECTORS
3118                },
3119                .dec = {
3120                    .vecs = cast6_xts_dec_tv_template,
3121                    .count = CAST6_XTS_DEC_TEST_VECTORS
3122                }
3123            }
3124        }
3125    }, {
3126        .alg = "xts(serpent)",
3127        .test = alg_test_skcipher,
3128        .suite = {
3129            .cipher = {
3130                .enc = {
3131                    .vecs = serpent_xts_enc_tv_template,
3132                    .count = SERPENT_XTS_ENC_TEST_VECTORS
3133                },
3134                .dec = {
3135                    .vecs = serpent_xts_dec_tv_template,
3136                    .count = SERPENT_XTS_DEC_TEST_VECTORS
3137                }
3138            }
3139        }
3140    }, {
3141        .alg = "xts(twofish)",
3142        .test = alg_test_skcipher,
3143        .suite = {
3144            .cipher = {
3145                .enc = {
3146                    .vecs = tf_xts_enc_tv_template,
3147                    .count = TF_XTS_ENC_TEST_VECTORS
3148                },
3149                .dec = {
3150                    .vecs = tf_xts_dec_tv_template,
3151                    .count = TF_XTS_DEC_TEST_VECTORS
3152                }
3153            }
3154        }
3155    }, {
3156        .alg = "zlib",
3157        .test = alg_test_pcomp,
3158        .fips_allowed = 1,
3159        .suite = {
3160            .pcomp = {
3161                .comp = {
3162                    .vecs = zlib_comp_tv_template,
3163                    .count = ZLIB_COMP_TEST_VECTORS
3164                },
3165                .decomp = {
3166                    .vecs = zlib_decomp_tv_template,
3167                    .count = ZLIB_DECOMP_TEST_VECTORS
3168                }
3169            }
3170        }
3171    }
3172};
3173
3174static bool alg_test_descs_checked;
3175
3176static void alg_test_descs_check_order(void)
3177{
3178    int i;
3179
3180    /* only check once */
3181    if (alg_test_descs_checked)
3182        return;
3183
3184    alg_test_descs_checked = true;
3185
3186    for (i = 1; i < ARRAY_SIZE(alg_test_descs); i++) {
3187        int diff = strcmp(alg_test_descs[i - 1].alg,
3188                  alg_test_descs[i].alg);
3189
3190        if (WARN_ON(diff > 0)) {
3191            pr_warn("testmgr: alg_test_descs entries in wrong order: '%s' before '%s'\n",
3192                alg_test_descs[i - 1].alg,
3193                alg_test_descs[i].alg);
3194        }
3195
3196        if (WARN_ON(diff == 0)) {
3197            pr_warn("testmgr: duplicate alg_test_descs entry: '%s'\n",
3198                alg_test_descs[i].alg);
3199        }
3200    }
3201}
3202
3203static int alg_find_test(const char *alg)
3204{
3205    int start = 0;
3206    int end = ARRAY_SIZE(alg_test_descs);
3207
3208    while (start < end) {
3209        int i = (start + end) / 2;
3210        int diff = strcmp(alg_test_descs[i].alg, alg);
3211
3212        if (diff > 0) {
3213            end = i;
3214            continue;
3215        }
3216
3217        if (diff < 0) {
3218            start = i + 1;
3219            continue;
3220        }
3221
3222        return i;
3223    }
3224
3225    return -1;
3226}
3227
3228int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
3229{
3230    int i;
3231    int j;
3232    int rc;
3233
3234    alg_test_descs_check_order();
3235
3236    if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) {
3237        char nalg[CRYPTO_MAX_ALG_NAME];
3238
3239        if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >=
3240            sizeof(nalg))
3241            return -ENAMETOOLONG;
3242
3243        i = alg_find_test(nalg);
3244        if (i < 0)
3245            goto notest;
3246
3247        if (fips_enabled && !alg_test_descs[i].fips_allowed)
3248            goto non_fips_alg;
3249
3250        rc = alg_test_cipher(alg_test_descs + i, driver, type, mask);
3251        goto test_done;
3252    }
3253
3254    i = alg_find_test(alg);
3255    j = alg_find_test(driver);
3256    if (i < 0 && j < 0)
3257        goto notest;
3258
3259    if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) ||
3260                 (j >= 0 && !alg_test_descs[j].fips_allowed)))
3261        goto non_fips_alg;
3262
3263    rc = 0;
3264    if (i >= 0)
3265        rc |= alg_test_descs[i].test(alg_test_descs + i, driver,
3266                         type, mask);
3267    if (j >= 0 && j != i)
3268        rc |= alg_test_descs[j].test(alg_test_descs + j, driver,
3269                         type, mask);
3270
3271test_done:
3272    if (fips_enabled && rc)
3273        panic("%s: %s alg self test failed in fips mode!\n", driver, alg);
3274
3275    if (fips_enabled && !rc)
3276        printk(KERN_INFO "alg: self-tests for %s (%s) passed\n",
3277               driver, alg);
3278
3279    return rc;
3280
3281notest:
3282    printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
3283    return 0;
3284non_fips_alg:
3285    return -EINVAL;
3286}
3287
3288#endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */
3289
3290EXPORT_SYMBOL_GPL(alg_test);
3291

Archive Download this file



interactive