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 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the Free
11 * Software Foundation; either version 2 of the License, or (at your option)
12 * any later version.
13 *
14 */
15
16#include <crypto/hash.h>
17#include <linux/err.h>
18#include <linux/module.h>
19#include <linux/scatterlist.h>
20#include <linux/slab.h>
21#include <linux/string.h>
22#include <crypto/rng.h>
23
24#include "internal.h"
25#include "testmgr.h"
26
27/*
28 * Need slab memory for testing (size in number of pages).
29 */
30#define XBUFSIZE 8
31
32/*
33 * Indexes into the xbuf to simulate cross-page access.
34 */
35#define IDX1 32
36#define IDX2 32400
37#define IDX3 1
38#define IDX4 8193
39#define IDX5 22222
40#define IDX6 17101
41#define IDX7 27333
42#define IDX8 3000
43
44/*
45* Used by test_cipher()
46*/
47#define ENCRYPT 1
48#define DECRYPT 0
49
50struct tcrypt_result {
51    struct completion completion;
52    int err;
53};
54
55struct aead_test_suite {
56    struct {
57        struct aead_testvec *vecs;
58        unsigned int count;
59    } enc, dec;
60};
61
62struct cipher_test_suite {
63    struct {
64        struct cipher_testvec *vecs;
65        unsigned int count;
66    } enc, dec;
67};
68
69struct comp_test_suite {
70    struct {
71        struct comp_testvec *vecs;
72        unsigned int count;
73    } comp, decomp;
74};
75
76struct pcomp_test_suite {
77    struct {
78        struct pcomp_testvec *vecs;
79        unsigned int count;
80    } comp, decomp;
81};
82
83struct hash_test_suite {
84    struct hash_testvec *vecs;
85    unsigned int count;
86};
87
88struct cprng_test_suite {
89    struct cprng_testvec *vecs;
90    unsigned int count;
91};
92
93struct alg_test_desc {
94    const char *alg;
95    int (*test)(const struct alg_test_desc *desc, const char *driver,
96            u32 type, u32 mask);
97    int fips_allowed; /* set if alg is allowed in fips mode */
98
99    union {
100        struct aead_test_suite aead;
101        struct cipher_test_suite cipher;
102        struct comp_test_suite comp;
103        struct pcomp_test_suite pcomp;
104        struct hash_test_suite hash;
105        struct cprng_test_suite cprng;
106    } suite;
107};
108
109static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
110
111static void hexdump(unsigned char *buf, unsigned int len)
112{
113    print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
114            16, 1,
115            buf, len, false);
116}
117
118static void tcrypt_complete(struct crypto_async_request *req, int err)
119{
120    struct tcrypt_result *res = req->data;
121
122    if (err == -EINPROGRESS)
123        return;
124
125    res->err = err;
126    complete(&res->completion);
127}
128
129static int testmgr_alloc_buf(char *buf[XBUFSIZE])
130{
131    int i;
132
133    for (i = 0; i < XBUFSIZE; i++) {
134        buf[i] = (void *)__get_free_page(GFP_KERNEL);
135        if (!buf[i])
136            goto err_free_buf;
137    }
138
139    return 0;
140
141err_free_buf:
142    while (i-- > 0)
143        free_page((unsigned long)buf[i]);
144
145    return -ENOMEM;
146}
147
148static void testmgr_free_buf(char *buf[XBUFSIZE])
149{
150    int i;
151
152    for (i = 0; i < XBUFSIZE; i++)
153        free_page((unsigned long)buf[i]);
154}
155
156static int test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
157             unsigned int tcount)
158{
159    const char *algo = crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm));
160    unsigned int i, j, k, temp;
161    struct scatterlist sg[8];
162    char result[64];
163    struct ahash_request *req;
164    struct tcrypt_result tresult;
165    void *hash_buff;
166    char *xbuf[XBUFSIZE];
167    int ret = -ENOMEM;
168
169    if (testmgr_alloc_buf(xbuf))
170        goto out_nobuf;
171
172    init_completion(&tresult.completion);
173
174    req = ahash_request_alloc(tfm, GFP_KERNEL);
175    if (!req) {
176        printk(KERN_ERR "alg: hash: Failed to allocate request for "
177               "%s\n", algo);
178        goto out_noreq;
179    }
180    ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
181                   tcrypt_complete, &tresult);
182
183    j = 0;
184    for (i = 0; i < tcount; i++) {
185        if (template[i].np)
186            continue;
187
188        j++;
189        memset(result, 0, 64);
190
191        hash_buff = xbuf[0];
192
193        memcpy(hash_buff, template[i].plaintext, template[i].psize);
194        sg_init_one(&sg[0], hash_buff, template[i].psize);
195
196        if (template[i].ksize) {
197            crypto_ahash_clear_flags(tfm, ~0);
198            ret = crypto_ahash_setkey(tfm, template[i].key,
199                          template[i].ksize);
200            if (ret) {
201                printk(KERN_ERR "alg: hash: setkey failed on "
202                       "test %d for %s: ret=%d\n", j, algo,
203                       -ret);
204                goto out;
205            }
206        }
207
208        ahash_request_set_crypt(req, sg, result, template[i].psize);
209        ret = crypto_ahash_digest(req);
210        switch (ret) {
211        case 0:
212            break;
213        case -EINPROGRESS:
214        case -EBUSY:
215            ret = wait_for_completion_interruptible(
216                &tresult.completion);
217            if (!ret && !(ret = tresult.err)) {
218                INIT_COMPLETION(tresult.completion);
219                break;
220            }
221            /* fall through */
222        default:
223            printk(KERN_ERR "alg: hash: digest failed on test %d "
224                   "for %s: ret=%d\n", j, algo, -ret);
225            goto out;
226        }
227
228        if (memcmp(result, template[i].digest,
229               crypto_ahash_digestsize(tfm))) {
230            printk(KERN_ERR "alg: hash: Test %d failed for %s\n",
231                   j, algo);
232            hexdump(result, crypto_ahash_digestsize(tfm));
233            ret = -EINVAL;
234            goto out;
235        }
236    }
237
238    j = 0;
239    for (i = 0; i < tcount; i++) {
240        if (template[i].np) {
241            j++;
242            memset(result, 0, 64);
243
244            temp = 0;
245            sg_init_table(sg, template[i].np);
246            ret = -EINVAL;
247            for (k = 0; k < template[i].np; k++) {
248                if (WARN_ON(offset_in_page(IDX[k]) +
249                        template[i].tap[k] > PAGE_SIZE))
250                    goto out;
251                sg_set_buf(&sg[k],
252                       memcpy(xbuf[IDX[k] >> PAGE_SHIFT] +
253                          offset_in_page(IDX[k]),
254                          template[i].plaintext + temp,
255                          template[i].tap[k]),
256                       template[i].tap[k]);
257                temp += template[i].tap[k];
258            }
259
260            if (template[i].ksize) {
261                crypto_ahash_clear_flags(tfm, ~0);
262                ret = crypto_ahash_setkey(tfm, template[i].key,
263                              template[i].ksize);
264
265                if (ret) {
266                    printk(KERN_ERR "alg: hash: setkey "
267                           "failed on chunking test %d "
268                           "for %s: ret=%d\n", j, algo,
269                           -ret);
270                    goto out;
271                }
272            }
273
274            ahash_request_set_crypt(req, sg, result,
275                        template[i].psize);
276            ret = crypto_ahash_digest(req);
277            switch (ret) {
278            case 0:
279                break;
280            case -EINPROGRESS:
281            case -EBUSY:
282                ret = wait_for_completion_interruptible(
283                    &tresult.completion);
284                if (!ret && !(ret = tresult.err)) {
285                    INIT_COMPLETION(tresult.completion);
286                    break;
287                }
288                /* fall through */
289            default:
290                printk(KERN_ERR "alg: hash: digest failed "
291                       "on chunking test %d for %s: "
292                       "ret=%d\n", j, algo, -ret);
293                goto out;
294            }
295
296            if (memcmp(result, template[i].digest,
297                   crypto_ahash_digestsize(tfm))) {
298                printk(KERN_ERR "alg: hash: Chunking test %d "
299                       "failed for %s\n", j, algo);
300                hexdump(result, crypto_ahash_digestsize(tfm));
301                ret = -EINVAL;
302                goto out;
303            }
304        }
305    }
306
307    ret = 0;
308
309out:
310    ahash_request_free(req);
311out_noreq:
312    testmgr_free_buf(xbuf);
313out_nobuf:
314    return ret;
315}
316
317static int test_aead(struct crypto_aead *tfm, int enc,
318             struct aead_testvec *template, unsigned int tcount)
319{
320    const char *algo = crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm));
321    unsigned int i, j, k, n, temp;
322    int ret = -ENOMEM;
323    char *q;
324    char *key;
325    struct aead_request *req;
326    struct scatterlist sg[8];
327    struct scatterlist asg[8];
328    const char *e;
329    struct tcrypt_result result;
330    unsigned int authsize;
331    void *input;
332    void *assoc;
333    char iv[MAX_IVLEN];
334    char *xbuf[XBUFSIZE];
335    char *axbuf[XBUFSIZE];
336
337    if (testmgr_alloc_buf(xbuf))
338        goto out_noxbuf;
339    if (testmgr_alloc_buf(axbuf))
340        goto out_noaxbuf;
341
342    if (enc == ENCRYPT)
343        e = "encryption";
344    else
345        e = "decryption";
346
347    init_completion(&result.completion);
348
349    req = aead_request_alloc(tfm, GFP_KERNEL);
350    if (!req) {
351        printk(KERN_ERR "alg: aead: Failed to allocate request for "
352               "%s\n", algo);
353        goto out;
354    }
355
356    aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
357                  tcrypt_complete, &result);
358
359    for (i = 0, j = 0; i < tcount; i++) {
360        if (!template[i].np) {
361            j++;
362
363            /* some tepmplates have no input data but they will
364             * touch input
365             */
366            input = xbuf[0];
367            assoc = axbuf[0];
368
369            ret = -EINVAL;
370            if (WARN_ON(template[i].ilen > PAGE_SIZE ||
371                    template[i].alen > PAGE_SIZE))
372                goto out;
373
374            memcpy(input, template[i].input, template[i].ilen);
375            memcpy(assoc, template[i].assoc, template[i].alen);
376            if (template[i].iv)
377                memcpy(iv, template[i].iv, MAX_IVLEN);
378            else
379                memset(iv, 0, MAX_IVLEN);
380
381            crypto_aead_clear_flags(tfm, ~0);
382            if (template[i].wk)
383                crypto_aead_set_flags(
384                    tfm, CRYPTO_TFM_REQ_WEAK_KEY);
385
386            key = template[i].key;
387
388            ret = crypto_aead_setkey(tfm, key,
389                         template[i].klen);
390            if (!ret == template[i].fail) {
391                printk(KERN_ERR "alg: aead: setkey failed on "
392                       "test %d for %s: flags=%x\n", j, algo,
393                       crypto_aead_get_flags(tfm));
394                goto out;
395            } else if (ret)
396                continue;
397
398            authsize = abs(template[i].rlen - template[i].ilen);
399            ret = crypto_aead_setauthsize(tfm, authsize);
400            if (ret) {
401                printk(KERN_ERR "alg: aead: Failed to set "
402                       "authsize to %u on test %d for %s\n",
403                       authsize, j, algo);
404                goto out;
405            }
406
407            sg_init_one(&sg[0], input,
408                    template[i].ilen + (enc ? authsize : 0));
409
410            sg_init_one(&asg[0], assoc, template[i].alen);
411
412            aead_request_set_crypt(req, sg, sg,
413                           template[i].ilen, iv);
414
415            aead_request_set_assoc(req, asg, template[i].alen);
416
417            ret = enc ?
418                crypto_aead_encrypt(req) :
419                crypto_aead_decrypt(req);
420
421            switch (ret) {
422            case 0:
423                if (template[i].novrfy) {
424                    /* verification was supposed to fail */
425                    printk(KERN_ERR "alg: aead: %s failed "
426                           "on test %d for %s: ret was 0, "
427                           "expected -EBADMSG\n",
428                           e, j, algo);
429                    /* so really, we got a bad message */
430                    ret = -EBADMSG;
431                    goto out;
432                }
433                break;
434            case -EINPROGRESS:
435            case -EBUSY:
436                ret = wait_for_completion_interruptible(
437                    &result.completion);
438                if (!ret && !(ret = result.err)) {
439                    INIT_COMPLETION(result.completion);
440                    break;
441                }
442            case -EBADMSG:
443                if (template[i].novrfy)
444                    /* verification failure was expected */
445                    continue;
446                /* fall through */
447            default:
448                printk(KERN_ERR "alg: aead: %s failed on test "
449                       "%d for %s: ret=%d\n", e, j, algo, -ret);
450                goto out;
451            }
452
453            q = input;
454            if (memcmp(q, template[i].result, template[i].rlen)) {
455                printk(KERN_ERR "alg: aead: Test %d failed on "
456                       "%s for %s\n", j, e, algo);
457                hexdump(q, template[i].rlen);
458                ret = -EINVAL;
459                goto out;
460            }
461        }
462    }
463
464    for (i = 0, j = 0; i < tcount; i++) {
465        if (template[i].np) {
466            j++;
467
468            if (template[i].iv)
469                memcpy(iv, template[i].iv, MAX_IVLEN);
470            else
471                memset(iv, 0, MAX_IVLEN);
472
473            crypto_aead_clear_flags(tfm, ~0);
474            if (template[i].wk)
475                crypto_aead_set_flags(
476                    tfm, CRYPTO_TFM_REQ_WEAK_KEY);
477            key = template[i].key;
478
479            ret = crypto_aead_setkey(tfm, key, template[i].klen);
480            if (!ret == template[i].fail) {
481                printk(KERN_ERR "alg: aead: setkey failed on "
482                       "chunk test %d for %s: flags=%x\n", j,
483                       algo, crypto_aead_get_flags(tfm));
484                goto out;
485            } else if (ret)
486                continue;
487
488            authsize = abs(template[i].rlen - template[i].ilen);
489
490            ret = -EINVAL;
491            sg_init_table(sg, template[i].np);
492            for (k = 0, temp = 0; k < template[i].np; k++) {
493                if (WARN_ON(offset_in_page(IDX[k]) +
494                        template[i].tap[k] > PAGE_SIZE))
495                    goto out;
496
497                q = xbuf[IDX[k] >> PAGE_SHIFT] +
498                    offset_in_page(IDX[k]);
499
500                memcpy(q, template[i].input + temp,
501                       template[i].tap[k]);
502
503                n = template[i].tap[k];
504                if (k == template[i].np - 1 && enc)
505                    n += authsize;
506                if (offset_in_page(q) + n < PAGE_SIZE)
507                    q[n] = 0;
508
509                sg_set_buf(&sg[k], q, template[i].tap[k]);
510                temp += template[i].tap[k];
511            }
512
513            ret = crypto_aead_setauthsize(tfm, authsize);
514            if (ret) {
515                printk(KERN_ERR "alg: aead: Failed to set "
516                       "authsize to %u on chunk test %d for "
517                       "%s\n", authsize, j, algo);
518                goto out;
519            }
520
521            if (enc) {
522                if (WARN_ON(sg[k - 1].offset +
523                        sg[k - 1].length + authsize >
524                        PAGE_SIZE)) {
525                    ret = -EINVAL;
526                    goto out;
527                }
528
529                sg[k - 1].length += authsize;
530            }
531
532            sg_init_table(asg, template[i].anp);
533            ret = -EINVAL;
534            for (k = 0, temp = 0; k < template[i].anp; k++) {
535                if (WARN_ON(offset_in_page(IDX[k]) +
536                        template[i].atap[k] > PAGE_SIZE))
537                    goto out;
538                sg_set_buf(&asg[k],
539                       memcpy(axbuf[IDX[k] >> PAGE_SHIFT] +
540                          offset_in_page(IDX[k]),
541                          template[i].assoc + temp,
542                          template[i].atap[k]),
543                       template[i].atap[k]);
544                temp += template[i].atap[k];
545            }
546
547            aead_request_set_crypt(req, sg, sg,
548                           template[i].ilen,
549                           iv);
550
551            aead_request_set_assoc(req, asg, template[i].alen);
552
553            ret = enc ?
554                crypto_aead_encrypt(req) :
555                crypto_aead_decrypt(req);
556
557            switch (ret) {
558            case 0:
559                if (template[i].novrfy) {
560                    /* verification was supposed to fail */
561                    printk(KERN_ERR "alg: aead: %s failed "
562                           "on chunk test %d for %s: ret "
563                           "was 0, expected -EBADMSG\n",
564                           e, j, algo);
565                    /* so really, we got a bad message */
566                    ret = -EBADMSG;
567                    goto out;
568                }
569                break;
570            case -EINPROGRESS:
571            case -EBUSY:
572                ret = wait_for_completion_interruptible(
573                    &result.completion);
574                if (!ret && !(ret = result.err)) {
575                    INIT_COMPLETION(result.completion);
576                    break;
577                }
578            case -EBADMSG:
579                if (template[i].novrfy)
580                    /* verification failure was expected */
581                    continue;
582                /* fall through */
583            default:
584                printk(KERN_ERR "alg: aead: %s failed on "
585                       "chunk test %d for %s: ret=%d\n", e, j,
586                       algo, -ret);
587                goto out;
588            }
589
590            ret = -EINVAL;
591            for (k = 0, temp = 0; k < template[i].np; k++) {
592                q = xbuf[IDX[k] >> PAGE_SHIFT] +
593                    offset_in_page(IDX[k]);
594
595                n = template[i].tap[k];
596                if (k == template[i].np - 1)
597                    n += enc ? authsize : -authsize;
598
599                if (memcmp(q, template[i].result + temp, n)) {
600                    printk(KERN_ERR "alg: aead: Chunk "
601                           "test %d failed on %s at page "
602                           "%u for %s\n", j, e, k, algo);
603                    hexdump(q, n);
604                    goto out;
605                }
606
607                q += n;
608                if (k == template[i].np - 1 && !enc) {
609                    if (memcmp(q, template[i].input +
610                              temp + n, authsize))
611                        n = authsize;
612                    else
613                        n = 0;
614                } else {
615                    for (n = 0; offset_in_page(q + n) &&
616                            q[n]; n++)
617                        ;
618                }
619                if (n) {
620                    printk(KERN_ERR "alg: aead: Result "
621                           "buffer corruption in chunk "
622                           "test %d on %s at page %u for "
623                           "%s: %u bytes:\n", j, e, k,
624                           algo, n);
625                    hexdump(q, n);
626                    goto out;
627                }
628
629                temp += template[i].tap[k];
630            }
631        }
632    }
633
634    ret = 0;
635
636out:
637    aead_request_free(req);
638    testmgr_free_buf(axbuf);
639out_noaxbuf:
640    testmgr_free_buf(xbuf);
641out_noxbuf:
642    return ret;
643}
644
645static int test_cipher(struct crypto_cipher *tfm, int enc,
646               struct cipher_testvec *template, unsigned int tcount)
647{
648    const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm));
649    unsigned int i, j, k;
650    char *q;
651    const char *e;
652    void *data;
653    char *xbuf[XBUFSIZE];
654    int ret = -ENOMEM;
655
656    if (testmgr_alloc_buf(xbuf))
657        goto out_nobuf;
658
659    if (enc == ENCRYPT)
660            e = "encryption";
661    else
662        e = "decryption";
663
664    j = 0;
665    for (i = 0; i < tcount; i++) {
666        if (template[i].np)
667            continue;
668
669        j++;
670
671        ret = -EINVAL;
672        if (WARN_ON(template[i].ilen > PAGE_SIZE))
673            goto out;
674
675        data = xbuf[0];
676        memcpy(data, template[i].input, template[i].ilen);
677
678        crypto_cipher_clear_flags(tfm, ~0);
679        if (template[i].wk)
680            crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
681
682        ret = crypto_cipher_setkey(tfm, template[i].key,
683                       template[i].klen);
684        if (!ret == template[i].fail) {
685            printk(KERN_ERR "alg: cipher: setkey failed "
686                   "on test %d for %s: flags=%x\n", j,
687                   algo, crypto_cipher_get_flags(tfm));
688            goto out;
689        } else if (ret)
690            continue;
691
692        for (k = 0; k < template[i].ilen;
693             k += crypto_cipher_blocksize(tfm)) {
694            if (enc)
695                crypto_cipher_encrypt_one(tfm, data + k,
696                              data + k);
697            else
698                crypto_cipher_decrypt_one(tfm, data + k,
699                              data + k);
700        }
701
702        q = data;
703        if (memcmp(q, template[i].result, template[i].rlen)) {
704            printk(KERN_ERR "alg: cipher: Test %d failed "
705                   "on %s for %s\n", j, e, algo);
706            hexdump(q, template[i].rlen);
707            ret = -EINVAL;
708            goto out;
709        }
710    }
711
712    ret = 0;
713
714out:
715    testmgr_free_buf(xbuf);
716out_nobuf:
717    return ret;
718}
719
720static int test_skcipher(struct crypto_ablkcipher *tfm, int enc,
721             struct cipher_testvec *template, unsigned int tcount)
722{
723    const char *algo =
724        crypto_tfm_alg_driver_name(crypto_ablkcipher_tfm(tfm));
725    unsigned int i, j, k, n, temp;
726    char *q;
727    struct ablkcipher_request *req;
728    struct scatterlist sg[8];
729    const char *e;
730    struct tcrypt_result result;
731    void *data;
732    char iv[MAX_IVLEN];
733    char *xbuf[XBUFSIZE];
734    int ret = -ENOMEM;
735
736    if (testmgr_alloc_buf(xbuf))
737        goto out_nobuf;
738
739    if (enc == ENCRYPT)
740            e = "encryption";
741    else
742        e = "decryption";
743
744    init_completion(&result.completion);
745
746    req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
747    if (!req) {
748        printk(KERN_ERR "alg: skcipher: Failed to allocate request "
749               "for %s\n", algo);
750        goto out;
751    }
752
753    ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
754                    tcrypt_complete, &result);
755
756    j = 0;
757    for (i = 0; i < tcount; i++) {
758        if (template[i].iv)
759            memcpy(iv, template[i].iv, MAX_IVLEN);
760        else
761            memset(iv, 0, MAX_IVLEN);
762
763        if (!(template[i].np)) {
764            j++;
765
766            ret = -EINVAL;
767            if (WARN_ON(template[i].ilen > PAGE_SIZE))
768                goto out;
769
770            data = xbuf[0];
771            memcpy(data, template[i].input, template[i].ilen);
772
773            crypto_ablkcipher_clear_flags(tfm, ~0);
774            if (template[i].wk)
775                crypto_ablkcipher_set_flags(
776                    tfm, CRYPTO_TFM_REQ_WEAK_KEY);
777
778            ret = crypto_ablkcipher_setkey(tfm, template[i].key,
779                               template[i].klen);
780            if (!ret == template[i].fail) {
781                printk(KERN_ERR "alg: skcipher: setkey failed "
782                       "on test %d for %s: flags=%x\n", j,
783                       algo, crypto_ablkcipher_get_flags(tfm));
784                goto out;
785            } else if (ret)
786                continue;
787
788            sg_init_one(&sg[0], data, template[i].ilen);
789
790            ablkcipher_request_set_crypt(req, sg, sg,
791                             template[i].ilen, iv);
792            ret = enc ?
793                crypto_ablkcipher_encrypt(req) :
794                crypto_ablkcipher_decrypt(req);
795
796            switch (ret) {
797            case 0:
798                break;
799            case -EINPROGRESS:
800            case -EBUSY:
801                ret = wait_for_completion_interruptible(
802                    &result.completion);
803                if (!ret && !((ret = result.err))) {
804                    INIT_COMPLETION(result.completion);
805                    break;
806                }
807                /* fall through */
808            default:
809                printk(KERN_ERR "alg: skcipher: %s failed on "
810                       "test %d for %s: ret=%d\n", e, j, algo,
811                       -ret);
812                goto out;
813            }
814
815            q = data;
816            if (memcmp(q, template[i].result, template[i].rlen)) {
817                printk(KERN_ERR "alg: skcipher: Test %d "
818                       "failed on %s for %s\n", j, e, algo);
819                hexdump(q, template[i].rlen);
820                ret = -EINVAL;
821                goto out;
822            }
823        }
824    }
825
826    j = 0;
827    for (i = 0; i < tcount; i++) {
828
829        if (template[i].iv)
830            memcpy(iv, template[i].iv, MAX_IVLEN);
831        else
832            memset(iv, 0, MAX_IVLEN);
833
834        if (template[i].np) {
835            j++;
836
837            crypto_ablkcipher_clear_flags(tfm, ~0);
838            if (template[i].wk)
839                crypto_ablkcipher_set_flags(
840                    tfm, CRYPTO_TFM_REQ_WEAK_KEY);
841
842            ret = crypto_ablkcipher_setkey(tfm, template[i].key,
843                               template[i].klen);
844            if (!ret == template[i].fail) {
845                printk(KERN_ERR "alg: skcipher: setkey failed "
846                       "on chunk test %d for %s: flags=%x\n",
847                       j, algo,
848                       crypto_ablkcipher_get_flags(tfm));
849                goto out;
850            } else if (ret)
851                continue;
852
853            temp = 0;
854            ret = -EINVAL;
855            sg_init_table(sg, template[i].np);
856            for (k = 0; k < template[i].np; k++) {
857                if (WARN_ON(offset_in_page(IDX[k]) +
858                        template[i].tap[k] > PAGE_SIZE))
859                    goto out;
860
861                q = xbuf[IDX[k] >> PAGE_SHIFT] +
862                    offset_in_page(IDX[k]);
863
864                memcpy(q, template[i].input + temp,
865                       template[i].tap[k]);
866
867                if (offset_in_page(q) + template[i].tap[k] <
868                    PAGE_SIZE)
869                    q[template[i].tap[k]] = 0;
870
871                sg_set_buf(&sg[k], q, template[i].tap[k]);
872
873                temp += template[i].tap[k];
874            }
875
876            ablkcipher_request_set_crypt(req, sg, sg,
877                    template[i].ilen, iv);
878
879            ret = enc ?
880                crypto_ablkcipher_encrypt(req) :
881                crypto_ablkcipher_decrypt(req);
882
883            switch (ret) {
884            case 0:
885                break;
886            case -EINPROGRESS:
887            case -EBUSY:
888                ret = wait_for_completion_interruptible(
889                    &result.completion);
890                if (!ret && !((ret = result.err))) {
891                    INIT_COMPLETION(result.completion);
892                    break;
893                }
894                /* fall through */
895            default:
896                printk(KERN_ERR "alg: skcipher: %s failed on "
897                       "chunk test %d for %s: ret=%d\n", e, j,
898                       algo, -ret);
899                goto out;
900            }
901
902            temp = 0;
903            ret = -EINVAL;
904            for (k = 0; k < template[i].np; k++) {
905                q = xbuf[IDX[k] >> PAGE_SHIFT] +
906                    offset_in_page(IDX[k]);
907
908                if (memcmp(q, template[i].result + temp,
909                       template[i].tap[k])) {
910                    printk(KERN_ERR "alg: skcipher: Chunk "
911                           "test %d failed on %s at page "
912                           "%u for %s\n", j, e, k, algo);
913                    hexdump(q, template[i].tap[k]);
914                    goto out;
915                }
916
917                q += template[i].tap[k];
918                for (n = 0; offset_in_page(q + n) && q[n]; n++)
919                    ;
920                if (n) {
921                    printk(KERN_ERR "alg: skcipher: "
922                           "Result buffer corruption in "
923                           "chunk test %d on %s at page "
924                           "%u for %s: %u bytes:\n", j, e,
925                           k, algo, n);
926                    hexdump(q, n);
927                    goto out;
928                }
929                temp += template[i].tap[k];
930            }
931        }
932    }
933
934    ret = 0;
935
936out:
937    ablkcipher_request_free(req);
938    testmgr_free_buf(xbuf);
939out_nobuf:
940    return ret;
941}
942
943static int test_comp(struct crypto_comp *tfm, struct comp_testvec *ctemplate,
944             struct comp_testvec *dtemplate, int ctcount, int dtcount)
945{
946    const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
947    unsigned int i;
948    char result[COMP_BUF_SIZE];
949    int ret;
950
951    for (i = 0; i < ctcount; i++) {
952        int ilen;
953        unsigned int dlen = COMP_BUF_SIZE;
954
955        memset(result, 0, sizeof (result));
956
957        ilen = ctemplate[i].inlen;
958        ret = crypto_comp_compress(tfm, ctemplate[i].input,
959                                   ilen, result, &dlen);
960        if (ret) {
961            printk(KERN_ERR "alg: comp: compression failed "
962                   "on test %d for %s: ret=%d\n", i + 1, algo,
963                   -ret);
964            goto out;
965        }
966
967        if (dlen != ctemplate[i].outlen) {
968            printk(KERN_ERR "alg: comp: Compression test %d "
969                   "failed for %s: output len = %d\n", i + 1, algo,
970                   dlen);
971            ret = -EINVAL;
972            goto out;
973        }
974
975        if (memcmp(result, ctemplate[i].output, dlen)) {
976            printk(KERN_ERR "alg: comp: Compression test %d "
977                   "failed for %s\n", i + 1, algo);
978            hexdump(result, dlen);
979            ret = -EINVAL;
980            goto out;
981        }
982    }
983
984    for (i = 0; i < dtcount; i++) {
985        int ilen;
986        unsigned int dlen = COMP_BUF_SIZE;
987
988        memset(result, 0, sizeof (result));
989
990        ilen = dtemplate[i].inlen;
991        ret = crypto_comp_decompress(tfm, dtemplate[i].input,
992                                     ilen, result, &dlen);
993        if (ret) {
994            printk(KERN_ERR "alg: comp: decompression failed "
995                   "on test %d for %s: ret=%d\n", i + 1, algo,
996                   -ret);
997            goto out;
998        }
999
1000        if (dlen != dtemplate[i].outlen) {
1001            printk(KERN_ERR "alg: comp: Decompression test %d "
1002                   "failed for %s: output len = %d\n", i + 1, algo,
1003                   dlen);
1004            ret = -EINVAL;
1005            goto out;
1006        }
1007
1008        if (memcmp(result, dtemplate[i].output, dlen)) {
1009            printk(KERN_ERR "alg: comp: Decompression test %d "
1010                   "failed for %s\n", i + 1, algo);
1011            hexdump(result, dlen);
1012            ret = -EINVAL;
1013            goto out;
1014        }
1015    }
1016
1017    ret = 0;
1018
1019out:
1020    return ret;
1021}
1022
1023static int test_pcomp(struct crypto_pcomp *tfm,
1024              struct pcomp_testvec *ctemplate,
1025              struct pcomp_testvec *dtemplate, int ctcount,
1026              int dtcount)
1027{
1028    const char *algo = crypto_tfm_alg_driver_name(crypto_pcomp_tfm(tfm));
1029    unsigned int i;
1030    char result[COMP_BUF_SIZE];
1031    int res;
1032
1033    for (i = 0; i < ctcount; i++) {
1034        struct comp_request req;
1035        unsigned int produced = 0;
1036
1037        res = crypto_compress_setup(tfm, ctemplate[i].params,
1038                        ctemplate[i].paramsize);
1039        if (res) {
1040            pr_err("alg: pcomp: compression setup failed on test "
1041                   "%d for %s: error=%d\n", i + 1, algo, res);
1042            return res;
1043        }
1044
1045        res = crypto_compress_init(tfm);
1046        if (res) {
1047            pr_err("alg: pcomp: compression init failed on test "
1048                   "%d for %s: error=%d\n", i + 1, algo, res);
1049            return res;
1050        }
1051
1052        memset(result, 0, sizeof(result));
1053
1054        req.next_in = ctemplate[i].input;
1055        req.avail_in = ctemplate[i].inlen / 2;
1056        req.next_out = result;
1057        req.avail_out = ctemplate[i].outlen / 2;
1058
1059        res = crypto_compress_update(tfm, &req);
1060        if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1061            pr_err("alg: pcomp: compression update failed on test "
1062                   "%d for %s: error=%d\n", i + 1, algo, res);
1063            return res;
1064        }
1065        if (res > 0)
1066            produced += res;
1067
1068        /* Add remaining input data */
1069        req.avail_in += (ctemplate[i].inlen + 1) / 2;
1070
1071        res = crypto_compress_update(tfm, &req);
1072        if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1073            pr_err("alg: pcomp: compression update failed on test "
1074                   "%d for %s: error=%d\n", i + 1, algo, res);
1075            return res;
1076        }
1077        if (res > 0)
1078            produced += res;
1079
1080        /* Provide remaining output space */
1081        req.avail_out += COMP_BUF_SIZE - ctemplate[i].outlen / 2;
1082
1083        res = crypto_compress_final(tfm, &req);
1084        if (res < 0) {
1085            pr_err("alg: pcomp: compression final failed on test "
1086                   "%d for %s: error=%d\n", i + 1, algo, res);
1087            return res;
1088        }
1089        produced += res;
1090
1091        if (COMP_BUF_SIZE - req.avail_out != ctemplate[i].outlen) {
1092            pr_err("alg: comp: Compression test %d failed for %s: "
1093                   "output len = %d (expected %d)\n", i + 1, algo,
1094                   COMP_BUF_SIZE - req.avail_out,
1095                   ctemplate[i].outlen);
1096            return -EINVAL;
1097        }
1098
1099        if (produced != ctemplate[i].outlen) {
1100            pr_err("alg: comp: Compression test %d failed for %s: "
1101                   "returned len = %u (expected %d)\n", i + 1,
1102                   algo, produced, ctemplate[i].outlen);
1103            return -EINVAL;
1104        }
1105
1106        if (memcmp(result, ctemplate[i].output, ctemplate[i].outlen)) {
1107            pr_err("alg: pcomp: Compression test %d failed for "
1108                   "%s\n", i + 1, algo);
1109            hexdump(result, ctemplate[i].outlen);
1110            return -EINVAL;
1111        }
1112    }
1113
1114    for (i = 0; i < dtcount; i++) {
1115        struct comp_request req;
1116        unsigned int produced = 0;
1117
1118        res = crypto_decompress_setup(tfm, dtemplate[i].params,
1119                          dtemplate[i].paramsize);
1120        if (res) {
1121            pr_err("alg: pcomp: decompression setup failed on "
1122                   "test %d for %s: error=%d\n", i + 1, algo, res);
1123            return res;
1124        }
1125
1126        res = crypto_decompress_init(tfm);
1127        if (res) {
1128            pr_err("alg: pcomp: decompression init failed on test "
1129                   "%d for %s: error=%d\n", i + 1, algo, res);
1130            return res;
1131        }
1132
1133        memset(result, 0, sizeof(result));
1134
1135        req.next_in = dtemplate[i].input;
1136        req.avail_in = dtemplate[i].inlen / 2;
1137        req.next_out = result;
1138        req.avail_out = dtemplate[i].outlen / 2;
1139
1140        res = crypto_decompress_update(tfm, &req);
1141        if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1142            pr_err("alg: pcomp: decompression update failed on "
1143                   "test %d for %s: error=%d\n", i + 1, algo, res);
1144            return res;
1145        }
1146        if (res > 0)
1147            produced += res;
1148
1149        /* Add remaining input data */
1150        req.avail_in += (dtemplate[i].inlen + 1) / 2;
1151
1152        res = crypto_decompress_update(tfm, &req);
1153        if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1154            pr_err("alg: pcomp: decompression update failed on "
1155                   "test %d for %s: error=%d\n", i + 1, algo, res);
1156            return res;
1157        }
1158        if (res > 0)
1159            produced += res;
1160
1161        /* Provide remaining output space */
1162        req.avail_out += COMP_BUF_SIZE - dtemplate[i].outlen / 2;
1163
1164        res = crypto_decompress_final(tfm, &req);
1165        if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1166            pr_err("alg: pcomp: decompression final failed on "
1167                   "test %d for %s: error=%d\n", i + 1, algo, res);
1168            return res;
1169        }
1170        if (res > 0)
1171            produced += res;
1172
1173        if (COMP_BUF_SIZE - req.avail_out != dtemplate[i].outlen) {
1174            pr_err("alg: comp: Decompression test %d failed for "
1175                   "%s: output len = %d (expected %d)\n", i + 1,
1176                   algo, COMP_BUF_SIZE - req.avail_out,
1177                   dtemplate[i].outlen);
1178            return -EINVAL;
1179        }
1180
1181        if (produced != dtemplate[i].outlen) {
1182            pr_err("alg: comp: Decompression test %d failed for "
1183                   "%s: returned len = %u (expected %d)\n", i + 1,
1184                   algo, produced, dtemplate[i].outlen);
1185            return -EINVAL;
1186        }
1187
1188        if (memcmp(result, dtemplate[i].output, dtemplate[i].outlen)) {
1189            pr_err("alg: pcomp: Decompression test %d failed for "
1190                   "%s\n", i + 1, algo);
1191            hexdump(result, dtemplate[i].outlen);
1192            return -EINVAL;
1193        }
1194    }
1195
1196    return 0;
1197}
1198
1199
1200static int test_cprng(struct crypto_rng *tfm, struct cprng_testvec *template,
1201              unsigned int tcount)
1202{
1203    const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm));
1204    int err = 0, i, j, seedsize;
1205    u8 *seed;
1206    char result[32];
1207
1208    seedsize = crypto_rng_seedsize(tfm);
1209
1210    seed = kmalloc(seedsize, GFP_KERNEL);
1211    if (!seed) {
1212        printk(KERN_ERR "alg: cprng: Failed to allocate seed space "
1213               "for %s\n", algo);
1214        return -ENOMEM;
1215    }
1216
1217    for (i = 0; i < tcount; i++) {
1218        memset(result, 0, 32);
1219
1220        memcpy(seed, template[i].v, template[i].vlen);
1221        memcpy(seed + template[i].vlen, template[i].key,
1222               template[i].klen);
1223        memcpy(seed + template[i].vlen + template[i].klen,
1224               template[i].dt, template[i].dtlen);
1225
1226        err = crypto_rng_reset(tfm, seed, seedsize);
1227        if (err) {
1228            printk(KERN_ERR "alg: cprng: Failed to reset rng "
1229                   "for %s\n", algo);
1230            goto out;
1231        }
1232
1233        for (j = 0; j < template[i].loops; j++) {
1234            err = crypto_rng_get_bytes(tfm, result,
1235                           template[i].rlen);
1236            if (err != template[i].rlen) {
1237                printk(KERN_ERR "alg: cprng: Failed to obtain "
1238                       "the correct amount of random data for "
1239                       "%s (requested %d, got %d)\n", algo,
1240                       template[i].rlen, err);
1241                goto out;
1242            }
1243        }
1244
1245        err = memcmp(result, template[i].result,
1246                 template[i].rlen);
1247        if (err) {
1248            printk(KERN_ERR "alg: cprng: Test %d failed for %s\n",
1249                   i, algo);
1250            hexdump(result, template[i].rlen);
1251            err = -EINVAL;
1252            goto out;
1253        }
1254    }
1255
1256out:
1257    kfree(seed);
1258    return err;
1259}
1260
1261static int alg_test_aead(const struct alg_test_desc *desc, const char *driver,
1262             u32 type, u32 mask)
1263{
1264    struct crypto_aead *tfm;
1265    int err = 0;
1266
1267    tfm = crypto_alloc_aead(driver, type, mask);
1268    if (IS_ERR(tfm)) {
1269        printk(KERN_ERR "alg: aead: Failed to load transform for %s: "
1270               "%ld\n", driver, PTR_ERR(tfm));
1271        return PTR_ERR(tfm);
1272    }
1273
1274    if (desc->suite.aead.enc.vecs) {
1275        err = test_aead(tfm, ENCRYPT, desc->suite.aead.enc.vecs,
1276                desc->suite.aead.enc.count);
1277        if (err)
1278            goto out;
1279    }
1280
1281    if (!err && desc->suite.aead.dec.vecs)
1282        err = test_aead(tfm, DECRYPT, desc->suite.aead.dec.vecs,
1283                desc->suite.aead.dec.count);
1284
1285out:
1286    crypto_free_aead(tfm);
1287    return err;
1288}
1289
1290static int alg_test_cipher(const struct alg_test_desc *desc,
1291               const char *driver, u32 type, u32 mask)
1292{
1293    struct crypto_cipher *tfm;
1294    int err = 0;
1295
1296    tfm = crypto_alloc_cipher(driver, type, mask);
1297    if (IS_ERR(tfm)) {
1298        printk(KERN_ERR "alg: cipher: Failed to load transform for "
1299               "%s: %ld\n", driver, PTR_ERR(tfm));
1300        return PTR_ERR(tfm);
1301    }
1302
1303    if (desc->suite.cipher.enc.vecs) {
1304        err = test_cipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1305                  desc->suite.cipher.enc.count);
1306        if (err)
1307            goto out;
1308    }
1309
1310    if (desc->suite.cipher.dec.vecs)
1311        err = test_cipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1312                  desc->suite.cipher.dec.count);
1313
1314out:
1315    crypto_free_cipher(tfm);
1316    return err;
1317}
1318
1319static int alg_test_skcipher(const struct alg_test_desc *desc,
1320                 const char *driver, u32 type, u32 mask)
1321{
1322    struct crypto_ablkcipher *tfm;
1323    int err = 0;
1324
1325    tfm = crypto_alloc_ablkcipher(driver, type, mask);
1326    if (IS_ERR(tfm)) {
1327        printk(KERN_ERR "alg: skcipher: Failed to load transform for "
1328               "%s: %ld\n", driver, PTR_ERR(tfm));
1329        return PTR_ERR(tfm);
1330    }
1331
1332    if (desc->suite.cipher.enc.vecs) {
1333        err = test_skcipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1334                    desc->suite.cipher.enc.count);
1335        if (err)
1336            goto out;
1337    }
1338
1339    if (desc->suite.cipher.dec.vecs)
1340        err = test_skcipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1341                    desc->suite.cipher.dec.count);
1342
1343out:
1344    crypto_free_ablkcipher(tfm);
1345    return err;
1346}
1347
1348static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
1349             u32 type, u32 mask)
1350{
1351    struct crypto_comp *tfm;
1352    int err;
1353
1354    tfm = crypto_alloc_comp(driver, type, mask);
1355    if (IS_ERR(tfm)) {
1356        printk(KERN_ERR "alg: comp: Failed to load transform for %s: "
1357               "%ld\n", driver, PTR_ERR(tfm));
1358        return PTR_ERR(tfm);
1359    }
1360
1361    err = test_comp(tfm, desc->suite.comp.comp.vecs,
1362            desc->suite.comp.decomp.vecs,
1363            desc->suite.comp.comp.count,
1364            desc->suite.comp.decomp.count);
1365
1366    crypto_free_comp(tfm);
1367    return err;
1368}
1369
1370static int alg_test_pcomp(const struct alg_test_desc *desc, const char *driver,
1371              u32 type, u32 mask)
1372{
1373    struct crypto_pcomp *tfm;
1374    int err;
1375
1376    tfm = crypto_alloc_pcomp(driver, type, mask);
1377    if (IS_ERR(tfm)) {
1378        pr_err("alg: pcomp: Failed to load transform for %s: %ld\n",
1379               driver, PTR_ERR(tfm));
1380        return PTR_ERR(tfm);
1381    }
1382
1383    err = test_pcomp(tfm, desc->suite.pcomp.comp.vecs,
1384             desc->suite.pcomp.decomp.vecs,
1385             desc->suite.pcomp.comp.count,
1386             desc->suite.pcomp.decomp.count);
1387
1388    crypto_free_pcomp(tfm);
1389    return err;
1390}
1391
1392static int alg_test_hash(const struct alg_test_desc *desc, const char *driver,
1393             u32 type, u32 mask)
1394{
1395    struct crypto_ahash *tfm;
1396    int err;
1397
1398    tfm = crypto_alloc_ahash(driver, type, mask);
1399    if (IS_ERR(tfm)) {
1400        printk(KERN_ERR "alg: hash: Failed to load transform for %s: "
1401               "%ld\n", driver, PTR_ERR(tfm));
1402        return PTR_ERR(tfm);
1403    }
1404
1405    err = test_hash(tfm, desc->suite.hash.vecs, desc->suite.hash.count);
1406
1407    crypto_free_ahash(tfm);
1408    return err;
1409}
1410
1411static int alg_test_crc32c(const struct alg_test_desc *desc,
1412               const char *driver, u32 type, u32 mask)
1413{
1414    struct crypto_shash *tfm;
1415    u32 val;
1416    int err;
1417
1418    err = alg_test_hash(desc, driver, type, mask);
1419    if (err)
1420        goto out;
1421
1422    tfm = crypto_alloc_shash(driver, type, mask);
1423    if (IS_ERR(tfm)) {
1424        printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: "
1425               "%ld\n", driver, PTR_ERR(tfm));
1426        err = PTR_ERR(tfm);
1427        goto out;
1428    }
1429
1430    do {
1431        struct {
1432            struct shash_desc shash;
1433            char ctx[crypto_shash_descsize(tfm)];
1434        } sdesc;
1435
1436        sdesc.shash.tfm = tfm;
1437        sdesc.shash.flags = 0;
1438
1439        *(u32 *)sdesc.ctx = le32_to_cpu(420553207);
1440        err = crypto_shash_final(&sdesc.shash, (u8 *)&val);
1441        if (err) {
1442            printk(KERN_ERR "alg: crc32c: Operation failed for "
1443                   "%s: %d\n", driver, err);
1444            break;
1445        }
1446
1447        if (val != ~420553207) {
1448            printk(KERN_ERR "alg: crc32c: Test failed for %s: "
1449                   "%d\n", driver, val);
1450            err = -EINVAL;
1451        }
1452    } while (0);
1453
1454    crypto_free_shash(tfm);
1455
1456out:
1457    return err;
1458}
1459
1460static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver,
1461              u32 type, u32 mask)
1462{
1463    struct crypto_rng *rng;
1464    int err;
1465
1466    rng = crypto_alloc_rng(driver, type, mask);
1467    if (IS_ERR(rng)) {
1468        printk(KERN_ERR "alg: cprng: Failed to load transform for %s: "
1469               "%ld\n", driver, PTR_ERR(rng));
1470        return PTR_ERR(rng);
1471    }
1472
1473    err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count);
1474
1475    crypto_free_rng(rng);
1476
1477    return err;
1478}
1479
1480static int alg_test_null(const struct alg_test_desc *desc,
1481                 const char *driver, u32 type, u32 mask)
1482{
1483    return 0;
1484}
1485
1486/* Please keep this list sorted by algorithm name. */
1487static const struct alg_test_desc alg_test_descs[] = {
1488    {
1489        .alg = "__driver-cbc-aes-aesni",
1490        .test = alg_test_null,
1491        .suite = {
1492            .cipher = {
1493                .enc = {
1494                    .vecs = NULL,
1495                    .count = 0
1496                },
1497                .dec = {
1498                    .vecs = NULL,
1499                    .count = 0
1500                }
1501            }
1502        }
1503    }, {
1504        .alg = "__driver-ecb-aes-aesni",
1505        .test = alg_test_null,
1506        .suite = {
1507            .cipher = {
1508                .enc = {
1509                    .vecs = NULL,
1510                    .count = 0
1511                },
1512                .dec = {
1513                    .vecs = NULL,
1514                    .count = 0
1515                }
1516            }
1517        }
1518    }, {
1519        .alg = "__ghash-pclmulqdqni",
1520        .test = alg_test_null,
1521        .suite = {
1522            .hash = {
1523                .vecs = NULL,
1524                .count = 0
1525            }
1526        }
1527    }, {
1528        .alg = "ansi_cprng",
1529        .test = alg_test_cprng,
1530        .fips_allowed = 1,
1531        .suite = {
1532            .cprng = {
1533                .vecs = ansi_cprng_aes_tv_template,
1534                .count = ANSI_CPRNG_AES_TEST_VECTORS
1535            }
1536        }
1537    }, {
1538        .alg = "cbc(aes)",
1539        .test = alg_test_skcipher,
1540        .fips_allowed = 1,
1541        .suite = {
1542            .cipher = {
1543                .enc = {
1544                    .vecs = aes_cbc_enc_tv_template,
1545                    .count = AES_CBC_ENC_TEST_VECTORS
1546                },
1547                .dec = {
1548                    .vecs = aes_cbc_dec_tv_template,
1549                    .count = AES_CBC_DEC_TEST_VECTORS
1550                }
1551            }
1552        }
1553    }, {
1554        .alg = "cbc(anubis)",
1555        .test = alg_test_skcipher,
1556        .suite = {
1557            .cipher = {
1558                .enc = {
1559                    .vecs = anubis_cbc_enc_tv_template,
1560                    .count = ANUBIS_CBC_ENC_TEST_VECTORS
1561                },
1562                .dec = {
1563                    .vecs = anubis_cbc_dec_tv_template,
1564                    .count = ANUBIS_CBC_DEC_TEST_VECTORS
1565                }
1566            }
1567        }
1568    }, {
1569        .alg = "cbc(blowfish)",
1570        .test = alg_test_skcipher,
1571        .suite = {
1572            .cipher = {
1573                .enc = {
1574                    .vecs = bf_cbc_enc_tv_template,
1575                    .count = BF_CBC_ENC_TEST_VECTORS
1576                },
1577                .dec = {
1578                    .vecs = bf_cbc_dec_tv_template,
1579                    .count = BF_CBC_DEC_TEST_VECTORS
1580                }
1581            }
1582        }
1583    }, {
1584        .alg = "cbc(camellia)",
1585        .test = alg_test_skcipher,
1586        .suite = {
1587            .cipher = {
1588                .enc = {
1589                    .vecs = camellia_cbc_enc_tv_template,
1590                    .count = CAMELLIA_CBC_ENC_TEST_VECTORS
1591                },
1592                .dec = {
1593                    .vecs = camellia_cbc_dec_tv_template,
1594                    .count = CAMELLIA_CBC_DEC_TEST_VECTORS
1595                }
1596            }
1597        }
1598    }, {
1599        .alg = "cbc(des)",
1600        .test = alg_test_skcipher,
1601        .suite = {
1602            .cipher = {
1603                .enc = {
1604                    .vecs = des_cbc_enc_tv_template,
1605                    .count = DES_CBC_ENC_TEST_VECTORS
1606                },
1607                .dec = {
1608                    .vecs = des_cbc_dec_tv_template,
1609                    .count = DES_CBC_DEC_TEST_VECTORS
1610                }
1611            }
1612        }
1613    }, {
1614        .alg = "cbc(des3_ede)",
1615        .test = alg_test_skcipher,
1616        .fips_allowed = 1,
1617        .suite = {
1618            .cipher = {
1619                .enc = {
1620                    .vecs = des3_ede_cbc_enc_tv_template,
1621                    .count = DES3_EDE_CBC_ENC_TEST_VECTORS
1622                },
1623                .dec = {
1624                    .vecs = des3_ede_cbc_dec_tv_template,
1625                    .count = DES3_EDE_CBC_DEC_TEST_VECTORS
1626                }
1627            }
1628        }
1629    }, {
1630        .alg = "cbc(twofish)",
1631        .test = alg_test_skcipher,
1632        .suite = {
1633            .cipher = {
1634                .enc = {
1635                    .vecs = tf_cbc_enc_tv_template,
1636                    .count = TF_CBC_ENC_TEST_VECTORS
1637                },
1638                .dec = {
1639                    .vecs = tf_cbc_dec_tv_template,
1640                    .count = TF_CBC_DEC_TEST_VECTORS
1641                }
1642            }
1643        }
1644    }, {
1645        .alg = "ccm(aes)",
1646        .test = alg_test_aead,
1647        .fips_allowed = 1,
1648        .suite = {
1649            .aead = {
1650                .enc = {
1651                    .vecs = aes_ccm_enc_tv_template,
1652                    .count = AES_CCM_ENC_TEST_VECTORS
1653                },
1654                .dec = {
1655                    .vecs = aes_ccm_dec_tv_template,
1656                    .count = AES_CCM_DEC_TEST_VECTORS
1657                }
1658            }
1659        }
1660    }, {
1661        .alg = "crc32c",
1662        .test = alg_test_crc32c,
1663        .fips_allowed = 1,
1664        .suite = {
1665            .hash = {
1666                .vecs = crc32c_tv_template,
1667                .count = CRC32C_TEST_VECTORS
1668            }
1669        }
1670    }, {
1671        .alg = "cryptd(__driver-ecb-aes-aesni)",
1672        .test = alg_test_null,
1673        .suite = {
1674            .cipher = {
1675                .enc = {
1676                    .vecs = NULL,
1677                    .count = 0
1678                },
1679                .dec = {
1680                    .vecs = NULL,
1681                    .count = 0
1682                }
1683            }
1684        }
1685    }, {
1686        .alg = "cryptd(__ghash-pclmulqdqni)",
1687        .test = alg_test_null,
1688        .suite = {
1689            .hash = {
1690                .vecs = NULL,
1691                .count = 0
1692            }
1693        }
1694    }, {
1695        .alg = "ctr(aes)",
1696        .test = alg_test_skcipher,
1697        .fips_allowed = 1,
1698        .suite = {
1699            .cipher = {
1700                .enc = {
1701                    .vecs = aes_ctr_enc_tv_template,
1702                    .count = AES_CTR_ENC_TEST_VECTORS
1703                },
1704                .dec = {
1705                    .vecs = aes_ctr_dec_tv_template,
1706                    .count = AES_CTR_DEC_TEST_VECTORS
1707                }
1708            }
1709        }
1710    }, {
1711        .alg = "cts(cbc(aes))",
1712        .test = alg_test_skcipher,
1713        .suite = {
1714            .cipher = {
1715                .enc = {
1716                    .vecs = cts_mode_enc_tv_template,
1717                    .count = CTS_MODE_ENC_TEST_VECTORS
1718                },
1719                .dec = {
1720                    .vecs = cts_mode_dec_tv_template,
1721                    .count = CTS_MODE_DEC_TEST_VECTORS
1722                }
1723            }
1724        }
1725    }, {
1726        .alg = "deflate",
1727        .test = alg_test_comp,
1728        .suite = {
1729            .comp = {
1730                .comp = {
1731                    .vecs = deflate_comp_tv_template,
1732                    .count = DEFLATE_COMP_TEST_VECTORS
1733                },
1734                .decomp = {
1735                    .vecs = deflate_decomp_tv_template,
1736                    .count = DEFLATE_DECOMP_TEST_VECTORS
1737                }
1738            }
1739        }
1740    }, {
1741        .alg = "ecb(__aes-aesni)",
1742        .test = alg_test_null,
1743        .suite = {
1744            .cipher = {
1745                .enc = {
1746                    .vecs = NULL,
1747                    .count = 0
1748                },
1749                .dec = {
1750                    .vecs = NULL,
1751                    .count = 0
1752                }
1753            }
1754        }
1755    }, {
1756        .alg = "ecb(aes)",
1757        .test = alg_test_skcipher,
1758        .fips_allowed = 1,
1759        .suite = {
1760            .cipher = {
1761                .enc = {
1762                    .vecs = aes_enc_tv_template,
1763                    .count = AES_ENC_TEST_VECTORS
1764                },
1765                .dec = {
1766                    .vecs = aes_dec_tv_template,
1767                    .count = AES_DEC_TEST_VECTORS
1768                }
1769            }
1770        }
1771    }, {
1772        .alg = "ecb(anubis)",
1773        .test = alg_test_skcipher,
1774        .suite = {
1775            .cipher = {
1776                .enc = {
1777                    .vecs = anubis_enc_tv_template,
1778                    .count = ANUBIS_ENC_TEST_VECTORS
1779                },
1780                .dec = {
1781                    .vecs = anubis_dec_tv_template,
1782                    .count = ANUBIS_DEC_TEST_VECTORS
1783                }
1784            }
1785        }
1786    }, {
1787        .alg = "ecb(arc4)",
1788        .test = alg_test_skcipher,
1789        .suite = {
1790            .cipher = {
1791                .enc = {
1792                    .vecs = arc4_enc_tv_template,
1793                    .count = ARC4_ENC_TEST_VECTORS
1794                },
1795                .dec = {
1796                    .vecs = arc4_dec_tv_template,
1797                    .count = ARC4_DEC_TEST_VECTORS
1798                }
1799            }
1800        }
1801    }, {
1802        .alg = "ecb(blowfish)",
1803        .test = alg_test_skcipher,
1804        .suite = {
1805            .cipher = {
1806                .enc = {
1807                    .vecs = bf_enc_tv_template,
1808                    .count = BF_ENC_TEST_VECTORS
1809                },
1810                .dec = {
1811                    .vecs = bf_dec_tv_template,
1812                    .count = BF_DEC_TEST_VECTORS
1813                }
1814            }
1815        }
1816    }, {
1817        .alg = "ecb(camellia)",
1818        .test = alg_test_skcipher,
1819        .suite = {
1820            .cipher = {
1821                .enc = {
1822                    .vecs = camellia_enc_tv_template,
1823                    .count = CAMELLIA_ENC_TEST_VECTORS
1824                },
1825                .dec = {
1826                    .vecs = camellia_dec_tv_template,
1827                    .count = CAMELLIA_DEC_TEST_VECTORS
1828                }
1829            }
1830        }
1831    }, {
1832        .alg = "ecb(cast5)",
1833        .test = alg_test_skcipher,
1834        .suite = {
1835            .cipher = {
1836                .enc = {
1837                    .vecs = cast5_enc_tv_template,
1838                    .count = CAST5_ENC_TEST_VECTORS
1839                },
1840                .dec = {
1841                    .vecs = cast5_dec_tv_template,
1842                    .count = CAST5_DEC_TEST_VECTORS
1843                }
1844            }
1845        }
1846    }, {
1847        .alg = "ecb(cast6)",
1848        .test = alg_test_skcipher,
1849        .suite = {
1850            .cipher = {
1851                .enc = {
1852                    .vecs = cast6_enc_tv_template,
1853                    .count = CAST6_ENC_TEST_VECTORS
1854                },
1855                .dec = {
1856                    .vecs = cast6_dec_tv_template,
1857                    .count = CAST6_DEC_TEST_VECTORS
1858                }
1859            }
1860        }
1861    }, {
1862        .alg = "ecb(des)",
1863        .test = alg_test_skcipher,
1864        .fips_allowed = 1,
1865        .suite = {
1866            .cipher = {
1867                .enc = {
1868                    .vecs = des_enc_tv_template,
1869                    .count = DES_ENC_TEST_VECTORS
1870                },
1871                .dec = {
1872                    .vecs = des_dec_tv_template,
1873                    .count = DES_DEC_TEST_VECTORS
1874                }
1875            }
1876        }
1877    }, {
1878        .alg = "ecb(des3_ede)",
1879        .test = alg_test_skcipher,
1880        .fips_allowed = 1,
1881        .suite = {
1882            .cipher = {
1883                .enc = {
1884                    .vecs = des3_ede_enc_tv_template,
1885                    .count = DES3_EDE_ENC_TEST_VECTORS
1886                },
1887                .dec = {
1888                    .vecs = des3_ede_dec_tv_template,
1889                    .count = DES3_EDE_DEC_TEST_VECTORS
1890                }
1891            }
1892        }
1893    }, {
1894        .alg = "ecb(khazad)",
1895        .test = alg_test_skcipher,
1896        .suite = {
1897            .cipher = {
1898                .enc = {
1899                    .vecs = khazad_enc_tv_template,
1900                    .count = KHAZAD_ENC_TEST_VECTORS
1901                },
1902                .dec = {
1903                    .vecs = khazad_dec_tv_template,
1904                    .count = KHAZAD_DEC_TEST_VECTORS
1905                }
1906            }
1907        }
1908    }, {
1909        .alg = "ecb(seed)",
1910        .test = alg_test_skcipher,
1911        .suite = {
1912            .cipher = {
1913                .enc = {
1914                    .vecs = seed_enc_tv_template,
1915                    .count = SEED_ENC_TEST_VECTORS
1916                },
1917                .dec = {
1918                    .vecs = seed_dec_tv_template,
1919                    .count = SEED_DEC_TEST_VECTORS
1920                }
1921            }
1922        }
1923    }, {
1924        .alg = "ecb(serpent)",
1925        .test = alg_test_skcipher,
1926        .suite = {
1927            .cipher = {
1928                .enc = {
1929                    .vecs = serpent_enc_tv_template,
1930                    .count = SERPENT_ENC_TEST_VECTORS
1931                },
1932                .dec = {
1933                    .vecs = serpent_dec_tv_template,
1934                    .count = SERPENT_DEC_TEST_VECTORS
1935                }
1936            }
1937        }
1938    }, {
1939        .alg = "ecb(tea)",
1940        .test = alg_test_skcipher,
1941        .suite = {
1942            .cipher = {
1943                .enc = {
1944                    .vecs = tea_enc_tv_template,
1945                    .count = TEA_ENC_TEST_VECTORS
1946                },
1947                .dec = {
1948                    .vecs = tea_dec_tv_template,
1949                    .count = TEA_DEC_TEST_VECTORS
1950                }
1951            }
1952        }
1953    }, {
1954        .alg = "ecb(tnepres)",
1955        .test = alg_test_skcipher,
1956        .suite = {
1957            .cipher = {
1958                .enc = {
1959                    .vecs = tnepres_enc_tv_template,
1960                    .count = TNEPRES_ENC_TEST_VECTORS
1961                },
1962                .dec = {
1963                    .vecs = tnepres_dec_tv_template,
1964                    .count = TNEPRES_DEC_TEST_VECTORS
1965                }
1966            }
1967        }
1968    }, {
1969        .alg = "ecb(twofish)",
1970        .test = alg_test_skcipher,
1971        .suite = {
1972            .cipher = {
1973                .enc = {
1974                    .vecs = tf_enc_tv_template,
1975                    .count = TF_ENC_TEST_VECTORS
1976                },
1977                .dec = {
1978                    .vecs = tf_dec_tv_template,
1979                    .count = TF_DEC_TEST_VECTORS
1980                }
1981            }
1982        }
1983    }, {
1984        .alg = "ecb(xeta)",
1985        .test = alg_test_skcipher,
1986        .suite = {
1987            .cipher = {
1988                .enc = {
1989                    .vecs = xeta_enc_tv_template,
1990                    .count = XETA_ENC_TEST_VECTORS
1991                },
1992                .dec = {
1993                    .vecs = xeta_dec_tv_template,
1994                    .count = XETA_DEC_TEST_VECTORS
1995                }
1996            }
1997        }
1998    }, {
1999        .alg = "ecb(xtea)",
2000        .test = alg_test_skcipher,
2001        .suite = {
2002            .cipher = {
2003                .enc = {
2004                    .vecs = xtea_enc_tv_template,
2005                    .count = XTEA_ENC_TEST_VECTORS
2006                },
2007                .dec = {
2008                    .vecs = xtea_dec_tv_template,
2009                    .count = XTEA_DEC_TEST_VECTORS
2010                }
2011            }
2012        }
2013    }, {
2014        .alg = "gcm(aes)",
2015        .test = alg_test_aead,
2016        .fips_allowed = 1,
2017        .suite = {
2018            .aead = {
2019                .enc = {
2020                    .vecs = aes_gcm_enc_tv_template,
2021                    .count = AES_GCM_ENC_TEST_VECTORS
2022                },
2023                .dec = {
2024                    .vecs = aes_gcm_dec_tv_template,
2025                    .count = AES_GCM_DEC_TEST_VECTORS
2026                }
2027            }
2028        }
2029    }, {
2030        .alg = "ghash",
2031        .test = alg_test_hash,
2032        .suite = {
2033            .hash = {
2034                .vecs = ghash_tv_template,
2035                .count = GHASH_TEST_VECTORS
2036            }
2037        }
2038    }, {
2039        .alg = "hmac(md5)",
2040        .test = alg_test_hash,
2041        .suite = {
2042            .hash = {
2043                .vecs = hmac_md5_tv_template,
2044                .count = HMAC_MD5_TEST_VECTORS
2045            }
2046        }
2047    }, {
2048        .alg = "hmac(rmd128)",
2049        .test = alg_test_hash,
2050        .suite = {
2051            .hash = {
2052                .vecs = hmac_rmd128_tv_template,
2053                .count = HMAC_RMD128_TEST_VECTORS
2054            }
2055        }
2056    }, {
2057        .alg = "hmac(rmd160)",
2058        .test = alg_test_hash,
2059        .suite = {
2060            .hash = {
2061                .vecs = hmac_rmd160_tv_template,
2062                .count = HMAC_RMD160_TEST_VECTORS
2063            }
2064        }
2065    }, {
2066        .alg = "hmac(sha1)",
2067        .test = alg_test_hash,
2068        .fips_allowed = 1,
2069        .suite = {
2070            .hash = {
2071                .vecs = hmac_sha1_tv_template,
2072                .count = HMAC_SHA1_TEST_VECTORS
2073            }
2074        }
2075    }, {
2076        .alg = "hmac(sha224)",
2077        .test = alg_test_hash,
2078        .fips_allowed = 1,
2079        .suite = {
2080            .hash = {
2081                .vecs = hmac_sha224_tv_template,
2082                .count = HMAC_SHA224_TEST_VECTORS
2083            }
2084        }
2085    }, {
2086        .alg = "hmac(sha256)",
2087        .test = alg_test_hash,
2088        .fips_allowed = 1,
2089        .suite = {
2090            .hash = {
2091                .vecs = hmac_sha256_tv_template,
2092                .count = HMAC_SHA256_TEST_VECTORS
2093            }
2094        }
2095    }, {
2096        .alg = "hmac(sha384)",
2097        .test = alg_test_hash,
2098        .fips_allowed = 1,
2099        .suite = {
2100            .hash = {
2101                .vecs = hmac_sha384_tv_template,
2102                .count = HMAC_SHA384_TEST_VECTORS
2103            }
2104        }
2105    }, {
2106        .alg = "hmac(sha512)",
2107        .test = alg_test_hash,
2108        .fips_allowed = 1,
2109        .suite = {
2110            .hash = {
2111                .vecs = hmac_sha512_tv_template,
2112                .count = HMAC_SHA512_TEST_VECTORS
2113            }
2114        }
2115    }, {
2116        .alg = "lrw(aes)",
2117        .test = alg_test_skcipher,
2118        .suite = {
2119            .cipher = {
2120                .enc = {
2121                    .vecs = aes_lrw_enc_tv_template,
2122                    .count = AES_LRW_ENC_TEST_VECTORS
2123                },
2124                .dec = {
2125                    .vecs = aes_lrw_dec_tv_template,
2126                    .count = AES_LRW_DEC_TEST_VECTORS
2127                }
2128            }
2129        }
2130    }, {
2131        .alg = "lzo",
2132        .test = alg_test_comp,
2133        .suite = {
2134            .comp = {
2135                .comp = {
2136                    .vecs = lzo_comp_tv_template,
2137                    .count = LZO_COMP_TEST_VECTORS
2138                },
2139                .decomp = {
2140                    .vecs = lzo_decomp_tv_template,
2141                    .count = LZO_DECOMP_TEST_VECTORS
2142                }
2143            }
2144        }
2145    }, {
2146        .alg = "md4",
2147        .test = alg_test_hash,
2148        .suite = {
2149            .hash = {
2150                .vecs = md4_tv_template,
2151                .count = MD4_TEST_VECTORS
2152            }
2153        }
2154    }, {
2155        .alg = "md5",
2156        .test = alg_test_hash,
2157        .suite = {
2158            .hash = {
2159                .vecs = md5_tv_template,
2160                .count = MD5_TEST_VECTORS
2161            }
2162        }
2163    }, {
2164        .alg = "michael_mic",
2165        .test = alg_test_hash,
2166        .suite = {
2167            .hash = {
2168                .vecs = michael_mic_tv_template,
2169                .count = MICHAEL_MIC_TEST_VECTORS
2170            }
2171        }
2172    }, {
2173        .alg = "pcbc(fcrypt)",
2174        .test = alg_test_skcipher,
2175        .suite = {
2176            .cipher = {
2177                .enc = {
2178                    .vecs = fcrypt_pcbc_enc_tv_template,
2179                    .count = FCRYPT_ENC_TEST_VECTORS
2180                },
2181                .dec = {
2182                    .vecs = fcrypt_pcbc_dec_tv_template,
2183                    .count = FCRYPT_DEC_TEST_VECTORS
2184                }
2185            }
2186        }
2187    }, {
2188        .alg = "rfc3686(ctr(aes))",
2189        .test = alg_test_skcipher,
2190        .fips_allowed = 1,
2191        .suite = {
2192            .cipher = {
2193                .enc = {
2194                    .vecs = aes_ctr_rfc3686_enc_tv_template,
2195                    .count = AES_CTR_3686_ENC_TEST_VECTORS
2196                },
2197                .dec = {
2198                    .vecs = aes_ctr_rfc3686_dec_tv_template,
2199                    .count = AES_CTR_3686_DEC_TEST_VECTORS
2200                }
2201            }
2202        }
2203    }, {
2204        .alg = "rfc4309(ccm(aes))",
2205        .test = alg_test_aead,
2206        .fips_allowed = 1,
2207        .suite = {
2208            .aead = {
2209                .enc = {
2210                    .vecs = aes_ccm_rfc4309_enc_tv_template,
2211                    .count = AES_CCM_4309_ENC_TEST_VECTORS
2212                },
2213                .dec = {
2214                    .vecs = aes_ccm_rfc4309_dec_tv_template,
2215                    .count = AES_CCM_4309_DEC_TEST_VECTORS
2216                }
2217            }
2218        }
2219    }, {
2220        .alg = "rmd128",
2221        .test = alg_test_hash,
2222        .suite = {
2223            .hash = {
2224                .vecs = rmd128_tv_template,
2225                .count = RMD128_TEST_VECTORS
2226            }
2227        }
2228    }, {
2229        .alg = "rmd160",
2230        .test = alg_test_hash,
2231        .suite = {
2232            .hash = {
2233                .vecs = rmd160_tv_template,
2234                .count = RMD160_TEST_VECTORS
2235            }
2236        }
2237    }, {
2238        .alg = "rmd256",
2239        .test = alg_test_hash,
2240        .suite = {
2241            .hash = {
2242                .vecs = rmd256_tv_template,
2243                .count = RMD256_TEST_VECTORS
2244            }
2245        }
2246    }, {
2247        .alg = "rmd320",
2248        .test = alg_test_hash,
2249        .suite = {
2250            .hash = {
2251                .vecs = rmd320_tv_template,
2252                .count = RMD320_TEST_VECTORS
2253            }
2254        }
2255    }, {
2256        .alg = "salsa20",
2257        .test = alg_test_skcipher,
2258        .suite = {
2259            .cipher = {
2260                .enc = {
2261                    .vecs = salsa20_stream_enc_tv_template,
2262                    .count = SALSA20_STREAM_ENC_TEST_VECTORS
2263                }
2264            }
2265        }
2266    }, {
2267        .alg = "sha1",
2268        .test = alg_test_hash,
2269        .fips_allowed = 1,
2270        .suite = {
2271            .hash = {
2272                .vecs = sha1_tv_template,
2273                .count = SHA1_TEST_VECTORS
2274            }
2275        }
2276    }, {
2277        .alg = "sha224",
2278        .test = alg_test_hash,
2279        .fips_allowed = 1,
2280        .suite = {
2281            .hash = {
2282                .vecs = sha224_tv_template,
2283                .count = SHA224_TEST_VECTORS
2284            }
2285        }
2286    }, {
2287        .alg = "sha256",
2288        .test = alg_test_hash,
2289        .fips_allowed = 1,
2290        .suite = {
2291            .hash = {
2292                .vecs = sha256_tv_template,
2293                .count = SHA256_TEST_VECTORS
2294            }
2295        }
2296    }, {
2297        .alg = "sha384",
2298        .test = alg_test_hash,
2299        .fips_allowed = 1,
2300        .suite = {
2301            .hash = {
2302                .vecs = sha384_tv_template,
2303                .count = SHA384_TEST_VECTORS
2304            }
2305        }
2306    }, {
2307        .alg = "sha512",
2308        .test = alg_test_hash,
2309        .fips_allowed = 1,
2310        .suite = {
2311            .hash = {
2312                .vecs = sha512_tv_template,
2313                .count = SHA512_TEST_VECTORS
2314            }
2315        }
2316    }, {
2317        .alg = "tgr128",
2318        .test = alg_test_hash,
2319        .suite = {
2320            .hash = {
2321                .vecs = tgr128_tv_template,
2322                .count = TGR128_TEST_VECTORS
2323            }
2324        }
2325    }, {
2326        .alg = "tgr160",
2327        .test = alg_test_hash,
2328        .suite = {
2329            .hash = {
2330                .vecs = tgr160_tv_template,
2331                .count = TGR160_TEST_VECTORS
2332            }
2333        }
2334    }, {
2335        .alg = "tgr192",
2336        .test = alg_test_hash,
2337        .suite = {
2338            .hash = {
2339                .vecs = tgr192_tv_template,
2340                .count = TGR192_TEST_VECTORS
2341            }
2342        }
2343    }, {
2344        .alg = "vmac(aes)",
2345        .test = alg_test_hash,
2346        .suite = {
2347            .hash = {
2348                .vecs = aes_vmac128_tv_template,
2349                .count = VMAC_AES_TEST_VECTORS
2350            }
2351        }
2352    }, {
2353        .alg = "wp256",
2354        .test = alg_test_hash,
2355        .suite = {
2356            .hash = {
2357                .vecs = wp256_tv_template,
2358                .count = WP256_TEST_VECTORS
2359            }
2360        }
2361    }, {
2362        .alg = "wp384",
2363        .test = alg_test_hash,
2364        .suite = {
2365            .hash = {
2366                .vecs = wp384_tv_template,
2367                .count = WP384_TEST_VECTORS
2368            }
2369        }
2370    }, {
2371        .alg = "wp512",
2372        .test = alg_test_hash,
2373        .suite = {
2374            .hash = {
2375                .vecs = wp512_tv_template,
2376                .count = WP512_TEST_VECTORS
2377            }
2378        }
2379    }, {
2380        .alg = "xcbc(aes)",
2381        .test = alg_test_hash,
2382        .suite = {
2383            .hash = {
2384                .vecs = aes_xcbc128_tv_template,
2385                .count = XCBC_AES_TEST_VECTORS
2386            }
2387        }
2388    }, {
2389        .alg = "xts(aes)",
2390        .test = alg_test_skcipher,
2391        .suite = {
2392            .cipher = {
2393                .enc = {
2394                    .vecs = aes_xts_enc_tv_template,
2395                    .count = AES_XTS_ENC_TEST_VECTORS
2396                },
2397                .dec = {
2398                    .vecs = aes_xts_dec_tv_template,
2399                    .count = AES_XTS_DEC_TEST_VECTORS
2400                }
2401            }
2402        }
2403    }, {
2404        .alg = "zlib",
2405        .test = alg_test_pcomp,
2406        .suite = {
2407            .pcomp = {
2408                .comp = {
2409                    .vecs = zlib_comp_tv_template,
2410                    .count = ZLIB_COMP_TEST_VECTORS
2411                },
2412                .decomp = {
2413                    .vecs = zlib_decomp_tv_template,
2414                    .count = ZLIB_DECOMP_TEST_VECTORS
2415                }
2416            }
2417        }
2418    }
2419};
2420
2421static int alg_find_test(const char *alg)
2422{
2423    int start = 0;
2424    int end = ARRAY_SIZE(alg_test_descs);
2425
2426    while (start < end) {
2427        int i = (start + end) / 2;
2428        int diff = strcmp(alg_test_descs[i].alg, alg);
2429
2430        if (diff > 0) {
2431            end = i;
2432            continue;
2433        }
2434
2435        if (diff < 0) {
2436            start = i + 1;
2437            continue;
2438        }
2439
2440        return i;
2441    }
2442
2443    return -1;
2444}
2445
2446int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
2447{
2448    int i;
2449    int j;
2450    int rc;
2451
2452    if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) {
2453        char nalg[CRYPTO_MAX_ALG_NAME];
2454
2455        if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >=
2456            sizeof(nalg))
2457            return -ENAMETOOLONG;
2458
2459        i = alg_find_test(nalg);
2460        if (i < 0)
2461            goto notest;
2462
2463        if (fips_enabled && !alg_test_descs[i].fips_allowed)
2464            goto non_fips_alg;
2465
2466        rc = alg_test_cipher(alg_test_descs + i, driver, type, mask);
2467        goto test_done;
2468    }
2469
2470    i = alg_find_test(alg);
2471    j = alg_find_test(driver);
2472    if (i < 0 && j < 0)
2473        goto notest;
2474
2475    if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) ||
2476                 (j >= 0 && !alg_test_descs[j].fips_allowed)))
2477        goto non_fips_alg;
2478
2479    rc = 0;
2480    if (i >= 0)
2481        rc |= alg_test_descs[i].test(alg_test_descs + i, driver,
2482                         type, mask);
2483    if (j >= 0)
2484        rc |= alg_test_descs[j].test(alg_test_descs + j, driver,
2485                         type, mask);
2486
2487test_done:
2488    if (fips_enabled && rc)
2489        panic("%s: %s alg self test failed in fips mode!\n", driver, alg);
2490
2491    if (fips_enabled && !rc)
2492        printk(KERN_INFO "alg: self-tests for %s (%s) passed\n",
2493               driver, alg);
2494
2495    return rc;
2496
2497notest:
2498    printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
2499    return 0;
2500non_fips_alg:
2501    return -EINVAL;
2502}
2503EXPORT_SYMBOL_GPL(alg_test);
2504

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive