crypto: vmac - New hash algorithm for intel_txt support
[linux-2.6.git] / crypto / testmgr.c
1 /*
2  * Algorithm testing framework and tests.
3  *
4  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
5  * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
6  * Copyright (c) 2007 Nokia Siemens Networks
7  * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
8  *
9  * 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
50 struct tcrypt_result {
51         struct completion completion;
52         int err;
53 };
54
55 struct aead_test_suite {
56         struct {
57                 struct aead_testvec *vecs;
58                 unsigned int count;
59         } enc, dec;
60 };
61
62 struct cipher_test_suite {
63         struct {
64                 struct cipher_testvec *vecs;
65                 unsigned int count;
66         } enc, dec;
67 };
68
69 struct comp_test_suite {
70         struct {
71                 struct comp_testvec *vecs;
72                 unsigned int count;
73         } comp, decomp;
74 };
75
76 struct pcomp_test_suite {
77         struct {
78                 struct pcomp_testvec *vecs;
79                 unsigned int count;
80         } comp, decomp;
81 };
82
83 struct hash_test_suite {
84         struct hash_testvec *vecs;
85         unsigned int count;
86 };
87
88 struct cprng_test_suite {
89         struct cprng_testvec *vecs;
90         unsigned int count;
91 };
92
93 struct 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
109 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
110
111 static 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
118 static 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
129 static 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
141 err_free_buf:
142         while (i-- > 0)
143                 free_page((unsigned long)buf[i]);
144
145         return -ENOMEM;
146 }
147
148 static 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
156 static 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
309 out:
310         ahash_request_free(req);
311 out_noreq:
312         testmgr_free_buf(xbuf);
313 out_nobuf:
314         return ret;
315 }
316
317 static 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
636 out:
637         aead_request_free(req);
638         testmgr_free_buf(axbuf);
639 out_noaxbuf:
640         testmgr_free_buf(xbuf);
641 out_noxbuf:
642         return ret;
643 }
644
645 static 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
714 out:
715         testmgr_free_buf(xbuf);
716 out_nobuf:
717         return ret;
718 }
719
720 static 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
936 out:
937         ablkcipher_request_free(req);
938         testmgr_free_buf(xbuf);
939 out_nobuf:
940         return ret;
941 }
942
943 static 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
1019 out:
1020         return ret;
1021 }
1022
1023 static 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
1200 static 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, 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
1256 out:
1257         kfree(seed);
1258         return err;
1259 }
1260
1261 static 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
1285 out:
1286         crypto_free_aead(tfm);
1287         return err;
1288 }
1289
1290 static 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
1314 out:
1315         crypto_free_cipher(tfm);
1316         return err;
1317 }
1318
1319 static 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
1343 out:
1344         crypto_free_ablkcipher(tfm);
1345         return err;
1346 }
1347
1348 static 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
1370 static 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
1392 static 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
1411 static 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
1456 out:
1457         return err;
1458 }
1459
1460 static 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
1480 /* Please keep this list sorted by algorithm name. */
1481 static const struct alg_test_desc alg_test_descs[] = {
1482         {
1483                 .alg = "ansi_cprng",
1484                 .test = alg_test_cprng,
1485                 .fips_allowed = 1,
1486                 .suite = {
1487                         .cprng = {
1488                                 .vecs = ansi_cprng_aes_tv_template,
1489                                 .count = ANSI_CPRNG_AES_TEST_VECTORS
1490                         }
1491                 }
1492         }, {
1493                 .alg = "cbc(aes)",
1494                 .test = alg_test_skcipher,
1495                 .fips_allowed = 1,
1496                 .suite = {
1497                         .cipher = {
1498                                 .enc = {
1499                                         .vecs = aes_cbc_enc_tv_template,
1500                                         .count = AES_CBC_ENC_TEST_VECTORS
1501                                 },
1502                                 .dec = {
1503                                         .vecs = aes_cbc_dec_tv_template,
1504                                         .count = AES_CBC_DEC_TEST_VECTORS
1505                                 }
1506                         }
1507                 }
1508         }, {
1509                 .alg = "cbc(anubis)",
1510                 .test = alg_test_skcipher,
1511                 .suite = {
1512                         .cipher = {
1513                                 .enc = {
1514                                         .vecs = anubis_cbc_enc_tv_template,
1515                                         .count = ANUBIS_CBC_ENC_TEST_VECTORS
1516                                 },
1517                                 .dec = {
1518                                         .vecs = anubis_cbc_dec_tv_template,
1519                                         .count = ANUBIS_CBC_DEC_TEST_VECTORS
1520                                 }
1521                         }
1522                 }
1523         }, {
1524                 .alg = "cbc(blowfish)",
1525                 .test = alg_test_skcipher,
1526                 .suite = {
1527                         .cipher = {
1528                                 .enc = {
1529                                         .vecs = bf_cbc_enc_tv_template,
1530                                         .count = BF_CBC_ENC_TEST_VECTORS
1531                                 },
1532                                 .dec = {
1533                                         .vecs = bf_cbc_dec_tv_template,
1534                                         .count = BF_CBC_DEC_TEST_VECTORS
1535                                 }
1536                         }
1537                 }
1538         }, {
1539                 .alg = "cbc(camellia)",
1540                 .test = alg_test_skcipher,
1541                 .suite = {
1542                         .cipher = {
1543                                 .enc = {
1544                                         .vecs = camellia_cbc_enc_tv_template,
1545                                         .count = CAMELLIA_CBC_ENC_TEST_VECTORS
1546                                 },
1547                                 .dec = {
1548                                         .vecs = camellia_cbc_dec_tv_template,
1549                                         .count = CAMELLIA_CBC_DEC_TEST_VECTORS
1550                                 }
1551                         }
1552                 }
1553         }, {
1554                 .alg = "cbc(des)",
1555                 .test = alg_test_skcipher,
1556                 .suite = {
1557                         .cipher = {
1558                                 .enc = {
1559                                         .vecs = des_cbc_enc_tv_template,
1560                                         .count = DES_CBC_ENC_TEST_VECTORS
1561                                 },
1562                                 .dec = {
1563                                         .vecs = des_cbc_dec_tv_template,
1564                                         .count = DES_CBC_DEC_TEST_VECTORS
1565                                 }
1566                         }
1567                 }
1568         }, {
1569                 .alg = "cbc(des3_ede)",
1570                 .test = alg_test_skcipher,
1571                 .fips_allowed = 1,
1572                 .suite = {
1573                         .cipher = {
1574                                 .enc = {
1575                                         .vecs = des3_ede_cbc_enc_tv_template,
1576                                         .count = DES3_EDE_CBC_ENC_TEST_VECTORS
1577                                 },
1578                                 .dec = {
1579                                         .vecs = des3_ede_cbc_dec_tv_template,
1580                                         .count = DES3_EDE_CBC_DEC_TEST_VECTORS
1581                                 }
1582                         }
1583                 }
1584         }, {
1585                 .alg = "cbc(twofish)",
1586                 .test = alg_test_skcipher,
1587                 .suite = {
1588                         .cipher = {
1589                                 .enc = {
1590                                         .vecs = tf_cbc_enc_tv_template,
1591                                         .count = TF_CBC_ENC_TEST_VECTORS
1592                                 },
1593                                 .dec = {
1594                                         .vecs = tf_cbc_dec_tv_template,
1595                                         .count = TF_CBC_DEC_TEST_VECTORS
1596                                 }
1597                         }
1598                 }
1599         }, {
1600                 .alg = "ccm(aes)",
1601                 .test = alg_test_aead,
1602                 .fips_allowed = 1,
1603                 .suite = {
1604                         .aead = {
1605                                 .enc = {
1606                                         .vecs = aes_ccm_enc_tv_template,
1607                                         .count = AES_CCM_ENC_TEST_VECTORS
1608                                 },
1609                                 .dec = {
1610                                         .vecs = aes_ccm_dec_tv_template,
1611                                         .count = AES_CCM_DEC_TEST_VECTORS
1612                                 }
1613                         }
1614                 }
1615         }, {
1616                 .alg = "crc32c",
1617                 .test = alg_test_crc32c,
1618                 .fips_allowed = 1,
1619                 .suite = {
1620                         .hash = {
1621                                 .vecs = crc32c_tv_template,
1622                                 .count = CRC32C_TEST_VECTORS
1623                         }
1624                 }
1625         }, {
1626                 .alg = "ctr(aes)",
1627                 .test = alg_test_skcipher,
1628                 .fips_allowed = 1,
1629                 .suite = {
1630                         .cipher = {
1631                                 .enc = {
1632                                         .vecs = aes_ctr_enc_tv_template,
1633                                         .count = AES_CTR_ENC_TEST_VECTORS
1634                                 },
1635                                 .dec = {
1636                                         .vecs = aes_ctr_dec_tv_template,
1637                                         .count = AES_CTR_DEC_TEST_VECTORS
1638                                 }
1639                         }
1640                 }
1641         }, {
1642                 .alg = "cts(cbc(aes))",
1643                 .test = alg_test_skcipher,
1644                 .suite = {
1645                         .cipher = {
1646                                 .enc = {
1647                                         .vecs = cts_mode_enc_tv_template,
1648                                         .count = CTS_MODE_ENC_TEST_VECTORS
1649                                 },
1650                                 .dec = {
1651                                         .vecs = cts_mode_dec_tv_template,
1652                                         .count = CTS_MODE_DEC_TEST_VECTORS
1653                                 }
1654                         }
1655                 }
1656         }, {
1657                 .alg = "deflate",
1658                 .test = alg_test_comp,
1659                 .suite = {
1660                         .comp = {
1661                                 .comp = {
1662                                         .vecs = deflate_comp_tv_template,
1663                                         .count = DEFLATE_COMP_TEST_VECTORS
1664                                 },
1665                                 .decomp = {
1666                                         .vecs = deflate_decomp_tv_template,
1667                                         .count = DEFLATE_DECOMP_TEST_VECTORS
1668                                 }
1669                         }
1670                 }
1671         }, {
1672                 .alg = "ecb(aes)",
1673                 .test = alg_test_skcipher,
1674                 .fips_allowed = 1,
1675                 .suite = {
1676                         .cipher = {
1677                                 .enc = {
1678                                         .vecs = aes_enc_tv_template,
1679                                         .count = AES_ENC_TEST_VECTORS
1680                                 },
1681                                 .dec = {
1682                                         .vecs = aes_dec_tv_template,
1683                                         .count = AES_DEC_TEST_VECTORS
1684                                 }
1685                         }
1686                 }
1687         }, {
1688                 .alg = "ecb(anubis)",
1689                 .test = alg_test_skcipher,
1690                 .suite = {
1691                         .cipher = {
1692                                 .enc = {
1693                                         .vecs = anubis_enc_tv_template,
1694                                         .count = ANUBIS_ENC_TEST_VECTORS
1695                                 },
1696                                 .dec = {
1697                                         .vecs = anubis_dec_tv_template,
1698                                         .count = ANUBIS_DEC_TEST_VECTORS
1699                                 }
1700                         }
1701                 }
1702         }, {
1703                 .alg = "ecb(arc4)",
1704                 .test = alg_test_skcipher,
1705                 .suite = {
1706                         .cipher = {
1707                                 .enc = {
1708                                         .vecs = arc4_enc_tv_template,
1709                                         .count = ARC4_ENC_TEST_VECTORS
1710                                 },
1711                                 .dec = {
1712                                         .vecs = arc4_dec_tv_template,
1713                                         .count = ARC4_DEC_TEST_VECTORS
1714                                 }
1715                         }
1716                 }
1717         }, {
1718                 .alg = "ecb(blowfish)",
1719                 .test = alg_test_skcipher,
1720                 .suite = {
1721                         .cipher = {
1722                                 .enc = {
1723                                         .vecs = bf_enc_tv_template,
1724                                         .count = BF_ENC_TEST_VECTORS
1725                                 },
1726                                 .dec = {
1727                                         .vecs = bf_dec_tv_template,
1728                                         .count = BF_DEC_TEST_VECTORS
1729                                 }
1730                         }
1731                 }
1732         }, {
1733                 .alg = "ecb(camellia)",
1734                 .test = alg_test_skcipher,
1735                 .suite = {
1736                         .cipher = {
1737                                 .enc = {
1738                                         .vecs = camellia_enc_tv_template,
1739                                         .count = CAMELLIA_ENC_TEST_VECTORS
1740                                 },
1741                                 .dec = {
1742                                         .vecs = camellia_dec_tv_template,
1743                                         .count = CAMELLIA_DEC_TEST_VECTORS
1744                                 }
1745                         }
1746                 }
1747         }, {
1748                 .alg = "ecb(cast5)",
1749                 .test = alg_test_skcipher,
1750                 .suite = {
1751                         .cipher = {
1752                                 .enc = {
1753                                         .vecs = cast5_enc_tv_template,
1754                                         .count = CAST5_ENC_TEST_VECTORS
1755                                 },
1756                                 .dec = {
1757                                         .vecs = cast5_dec_tv_template,
1758                                         .count = CAST5_DEC_TEST_VECTORS
1759                                 }
1760                         }
1761                 }
1762         }, {
1763                 .alg = "ecb(cast6)",
1764                 .test = alg_test_skcipher,
1765                 .suite = {
1766                         .cipher = {
1767                                 .enc = {
1768                                         .vecs = cast6_enc_tv_template,
1769                                         .count = CAST6_ENC_TEST_VECTORS
1770                                 },
1771                                 .dec = {
1772                                         .vecs = cast6_dec_tv_template,
1773                                         .count = CAST6_DEC_TEST_VECTORS
1774                                 }
1775                         }
1776                 }
1777         }, {
1778                 .alg = "ecb(des)",
1779                 .test = alg_test_skcipher,
1780                 .fips_allowed = 1,
1781                 .suite = {
1782                         .cipher = {
1783                                 .enc = {
1784                                         .vecs = des_enc_tv_template,
1785                                         .count = DES_ENC_TEST_VECTORS
1786                                 },
1787                                 .dec = {
1788                                         .vecs = des_dec_tv_template,
1789                                         .count = DES_DEC_TEST_VECTORS
1790                                 }
1791                         }
1792                 }
1793         }, {
1794                 .alg = "ecb(des3_ede)",
1795                 .test = alg_test_skcipher,
1796                 .fips_allowed = 1,
1797                 .suite = {
1798                         .cipher = {
1799                                 .enc = {
1800                                         .vecs = des3_ede_enc_tv_template,
1801                                         .count = DES3_EDE_ENC_TEST_VECTORS
1802                                 },
1803                                 .dec = {
1804                                         .vecs = des3_ede_dec_tv_template,
1805                                         .count = DES3_EDE_DEC_TEST_VECTORS
1806                                 }
1807                         }
1808                 }
1809         }, {
1810                 .alg = "ecb(khazad)",
1811                 .test = alg_test_skcipher,
1812                 .suite = {
1813                         .cipher = {
1814                                 .enc = {
1815                                         .vecs = khazad_enc_tv_template,
1816                                         .count = KHAZAD_ENC_TEST_VECTORS
1817                                 },
1818                                 .dec = {
1819                                         .vecs = khazad_dec_tv_template,
1820                                         .count = KHAZAD_DEC_TEST_VECTORS
1821                                 }
1822                         }
1823                 }
1824         }, {
1825                 .alg = "ecb(seed)",
1826                 .test = alg_test_skcipher,
1827                 .suite = {
1828                         .cipher = {
1829                                 .enc = {
1830                                         .vecs = seed_enc_tv_template,
1831                                         .count = SEED_ENC_TEST_VECTORS
1832                                 },
1833                                 .dec = {
1834                                         .vecs = seed_dec_tv_template,
1835                                         .count = SEED_DEC_TEST_VECTORS
1836                                 }
1837                         }
1838                 }
1839         }, {
1840                 .alg = "ecb(serpent)",
1841                 .test = alg_test_skcipher,
1842                 .suite = {
1843                         .cipher = {
1844                                 .enc = {
1845                                         .vecs = serpent_enc_tv_template,
1846                                         .count = SERPENT_ENC_TEST_VECTORS
1847                                 },
1848                                 .dec = {
1849                                         .vecs = serpent_dec_tv_template,
1850                                         .count = SERPENT_DEC_TEST_VECTORS
1851                                 }
1852                         }
1853                 }
1854         }, {
1855                 .alg = "ecb(tea)",
1856                 .test = alg_test_skcipher,
1857                 .suite = {
1858                         .cipher = {
1859                                 .enc = {
1860                                         .vecs = tea_enc_tv_template,
1861                                         .count = TEA_ENC_TEST_VECTORS
1862                                 },
1863                                 .dec = {
1864                                         .vecs = tea_dec_tv_template,
1865                                         .count = TEA_DEC_TEST_VECTORS
1866                                 }
1867                         }
1868                 }
1869         }, {
1870                 .alg = "ecb(tnepres)",
1871                 .test = alg_test_skcipher,
1872                 .suite = {
1873                         .cipher = {
1874                                 .enc = {
1875                                         .vecs = tnepres_enc_tv_template,
1876                                         .count = TNEPRES_ENC_TEST_VECTORS
1877                                 },
1878                                 .dec = {
1879                                         .vecs = tnepres_dec_tv_template,
1880                                         .count = TNEPRES_DEC_TEST_VECTORS
1881                                 }
1882                         }
1883                 }
1884         }, {
1885                 .alg = "ecb(twofish)",
1886                 .test = alg_test_skcipher,
1887                 .suite = {
1888                         .cipher = {
1889                                 .enc = {
1890                                         .vecs = tf_enc_tv_template,
1891                                         .count = TF_ENC_TEST_VECTORS
1892                                 },
1893                                 .dec = {
1894                                         .vecs = tf_dec_tv_template,
1895                                         .count = TF_DEC_TEST_VECTORS
1896                                 }
1897                         }
1898                 }
1899         }, {
1900                 .alg = "ecb(xeta)",
1901                 .test = alg_test_skcipher,
1902                 .suite = {
1903                         .cipher = {
1904                                 .enc = {
1905                                         .vecs = xeta_enc_tv_template,
1906                                         .count = XETA_ENC_TEST_VECTORS
1907                                 },
1908                                 .dec = {
1909                                         .vecs = xeta_dec_tv_template,
1910                                         .count = XETA_DEC_TEST_VECTORS
1911                                 }
1912                         }
1913                 }
1914         }, {
1915                 .alg = "ecb(xtea)",
1916                 .test = alg_test_skcipher,
1917                 .suite = {
1918                         .cipher = {
1919                                 .enc = {
1920                                         .vecs = xtea_enc_tv_template,
1921                                         .count = XTEA_ENC_TEST_VECTORS
1922                                 },
1923                                 .dec = {
1924                                         .vecs = xtea_dec_tv_template,
1925                                         .count = XTEA_DEC_TEST_VECTORS
1926                                 }
1927                         }
1928                 }
1929         }, {
1930                 .alg = "gcm(aes)",
1931                 .test = alg_test_aead,
1932                 .fips_allowed = 1,
1933                 .suite = {
1934                         .aead = {
1935                                 .enc = {
1936                                         .vecs = aes_gcm_enc_tv_template,
1937                                         .count = AES_GCM_ENC_TEST_VECTORS
1938                                 },
1939                                 .dec = {
1940                                         .vecs = aes_gcm_dec_tv_template,
1941                                         .count = AES_GCM_DEC_TEST_VECTORS
1942                                 }
1943                         }
1944                 }
1945         }, {
1946                 .alg = "hmac(md5)",
1947                 .test = alg_test_hash,
1948                 .suite = {
1949                         .hash = {
1950                                 .vecs = hmac_md5_tv_template,
1951                                 .count = HMAC_MD5_TEST_VECTORS
1952                         }
1953                 }
1954         }, {
1955                 .alg = "hmac(rmd128)",
1956                 .test = alg_test_hash,
1957                 .suite = {
1958                         .hash = {
1959                                 .vecs = hmac_rmd128_tv_template,
1960                                 .count = HMAC_RMD128_TEST_VECTORS
1961                         }
1962                 }
1963         }, {
1964                 .alg = "hmac(rmd160)",
1965                 .test = alg_test_hash,
1966                 .suite = {
1967                         .hash = {
1968                                 .vecs = hmac_rmd160_tv_template,
1969                                 .count = HMAC_RMD160_TEST_VECTORS
1970                         }
1971                 }
1972         }, {
1973                 .alg = "hmac(sha1)",
1974                 .test = alg_test_hash,
1975                 .fips_allowed = 1,
1976                 .suite = {
1977                         .hash = {
1978                                 .vecs = hmac_sha1_tv_template,
1979                                 .count = HMAC_SHA1_TEST_VECTORS
1980                         }
1981                 }
1982         }, {
1983                 .alg = "hmac(sha224)",
1984                 .test = alg_test_hash,
1985                 .fips_allowed = 1,
1986                 .suite = {
1987                         .hash = {
1988                                 .vecs = hmac_sha224_tv_template,
1989                                 .count = HMAC_SHA224_TEST_VECTORS
1990                         }
1991                 }
1992         }, {
1993                 .alg = "hmac(sha256)",
1994                 .test = alg_test_hash,
1995                 .fips_allowed = 1,
1996                 .suite = {
1997                         .hash = {
1998                                 .vecs = hmac_sha256_tv_template,
1999                                 .count = HMAC_SHA256_TEST_VECTORS
2000                         }
2001                 }
2002         }, {
2003                 .alg = "hmac(sha384)",
2004                 .test = alg_test_hash,
2005                 .fips_allowed = 1,
2006                 .suite = {
2007                         .hash = {
2008                                 .vecs = hmac_sha384_tv_template,
2009                                 .count = HMAC_SHA384_TEST_VECTORS
2010                         }
2011                 }
2012         }, {
2013                 .alg = "hmac(sha512)",
2014                 .test = alg_test_hash,
2015                 .fips_allowed = 1,
2016                 .suite = {
2017                         .hash = {
2018                                 .vecs = hmac_sha512_tv_template,
2019                                 .count = HMAC_SHA512_TEST_VECTORS
2020                         }
2021                 }
2022         }, {
2023                 .alg = "lrw(aes)",
2024                 .test = alg_test_skcipher,
2025                 .suite = {
2026                         .cipher = {
2027                                 .enc = {
2028                                         .vecs = aes_lrw_enc_tv_template,
2029                                         .count = AES_LRW_ENC_TEST_VECTORS
2030                                 },
2031                                 .dec = {
2032                                         .vecs = aes_lrw_dec_tv_template,
2033                                         .count = AES_LRW_DEC_TEST_VECTORS
2034                                 }
2035                         }
2036                 }
2037         }, {
2038                 .alg = "lzo",
2039                 .test = alg_test_comp,
2040                 .suite = {
2041                         .comp = {
2042                                 .comp = {
2043                                         .vecs = lzo_comp_tv_template,
2044                                         .count = LZO_COMP_TEST_VECTORS
2045                                 },
2046                                 .decomp = {
2047                                         .vecs = lzo_decomp_tv_template,
2048                                         .count = LZO_DECOMP_TEST_VECTORS
2049                                 }
2050                         }
2051                 }
2052         }, {
2053                 .alg = "md4",
2054                 .test = alg_test_hash,
2055                 .suite = {
2056                         .hash = {
2057                                 .vecs = md4_tv_template,
2058                                 .count = MD4_TEST_VECTORS
2059                         }
2060                 }
2061         }, {
2062                 .alg = "md5",
2063                 .test = alg_test_hash,
2064                 .suite = {
2065                         .hash = {
2066                                 .vecs = md5_tv_template,
2067                                 .count = MD5_TEST_VECTORS
2068                         }
2069                 }
2070         }, {
2071                 .alg = "michael_mic",
2072                 .test = alg_test_hash,
2073                 .suite = {
2074                         .hash = {
2075                                 .vecs = michael_mic_tv_template,
2076                                 .count = MICHAEL_MIC_TEST_VECTORS
2077                         }
2078                 }
2079         }, {
2080                 .alg = "pcbc(fcrypt)",
2081                 .test = alg_test_skcipher,
2082                 .suite = {
2083                         .cipher = {
2084                                 .enc = {
2085                                         .vecs = fcrypt_pcbc_enc_tv_template,
2086                                         .count = FCRYPT_ENC_TEST_VECTORS
2087                                 },
2088                                 .dec = {
2089                                         .vecs = fcrypt_pcbc_dec_tv_template,
2090                                         .count = FCRYPT_DEC_TEST_VECTORS
2091                                 }
2092                         }
2093                 }
2094         }, {
2095                 .alg = "rfc3686(ctr(aes))",
2096                 .test = alg_test_skcipher,
2097                 .fips_allowed = 1,
2098                 .suite = {
2099                         .cipher = {
2100                                 .enc = {
2101                                         .vecs = aes_ctr_rfc3686_enc_tv_template,
2102                                         .count = AES_CTR_3686_ENC_TEST_VECTORS
2103                                 },
2104                                 .dec = {
2105                                         .vecs = aes_ctr_rfc3686_dec_tv_template,
2106                                         .count = AES_CTR_3686_DEC_TEST_VECTORS
2107                                 }
2108                         }
2109                 }
2110         }, {
2111                 .alg = "rfc4309(ccm(aes))",
2112                 .test = alg_test_aead,
2113                 .fips_allowed = 1,
2114                 .suite = {
2115                         .aead = {
2116                                 .enc = {
2117                                         .vecs = aes_ccm_rfc4309_enc_tv_template,
2118                                         .count = AES_CCM_4309_ENC_TEST_VECTORS
2119                                 },
2120                                 .dec = {
2121                                         .vecs = aes_ccm_rfc4309_dec_tv_template,
2122                                         .count = AES_CCM_4309_DEC_TEST_VECTORS
2123                                 }
2124                         }
2125                 }
2126         }, {
2127                 .alg = "rmd128",
2128                 .test = alg_test_hash,
2129                 .suite = {
2130                         .hash = {
2131                                 .vecs = rmd128_tv_template,
2132                                 .count = RMD128_TEST_VECTORS
2133                         }
2134                 }
2135         }, {
2136                 .alg = "rmd160",
2137                 .test = alg_test_hash,
2138                 .suite = {
2139                         .hash = {
2140                                 .vecs = rmd160_tv_template,
2141                                 .count = RMD160_TEST_VECTORS
2142                         }
2143                 }
2144         }, {
2145                 .alg = "rmd256",
2146                 .test = alg_test_hash,
2147                 .suite = {
2148                         .hash = {
2149                                 .vecs = rmd256_tv_template,
2150                                 .count = RMD256_TEST_VECTORS
2151                         }
2152                 }
2153         }, {
2154                 .alg = "rmd320",
2155                 .test = alg_test_hash,
2156                 .suite = {
2157                         .hash = {
2158                                 .vecs = rmd320_tv_template,
2159                                 .count = RMD320_TEST_VECTORS
2160                         }
2161                 }
2162         }, {
2163                 .alg = "salsa20",
2164                 .test = alg_test_skcipher,
2165                 .suite = {
2166                         .cipher = {
2167                                 .enc = {
2168                                         .vecs = salsa20_stream_enc_tv_template,
2169                                         .count = SALSA20_STREAM_ENC_TEST_VECTORS
2170                                 }
2171                         }
2172                 }
2173         }, {
2174                 .alg = "sha1",
2175                 .test = alg_test_hash,
2176                 .fips_allowed = 1,
2177                 .suite = {
2178                         .hash = {
2179                                 .vecs = sha1_tv_template,
2180                                 .count = SHA1_TEST_VECTORS
2181                         }
2182                 }
2183         }, {
2184                 .alg = "sha224",
2185                 .test = alg_test_hash,
2186                 .fips_allowed = 1,
2187                 .suite = {
2188                         .hash = {
2189                                 .vecs = sha224_tv_template,
2190                                 .count = SHA224_TEST_VECTORS
2191                         }
2192                 }
2193         }, {
2194                 .alg = "sha256",
2195                 .test = alg_test_hash,
2196                 .fips_allowed = 1,
2197                 .suite = {
2198                         .hash = {
2199                                 .vecs = sha256_tv_template,
2200                                 .count = SHA256_TEST_VECTORS
2201                         }
2202                 }
2203         }, {
2204                 .alg = "sha384",
2205                 .test = alg_test_hash,
2206                 .fips_allowed = 1,
2207                 .suite = {
2208                         .hash = {
2209                                 .vecs = sha384_tv_template,
2210                                 .count = SHA384_TEST_VECTORS
2211                         }
2212                 }
2213         }, {
2214                 .alg = "sha512",
2215                 .test = alg_test_hash,
2216                 .fips_allowed = 1,
2217                 .suite = {
2218                         .hash = {
2219                                 .vecs = sha512_tv_template,
2220                                 .count = SHA512_TEST_VECTORS
2221                         }
2222                 }
2223         }, {
2224                 .alg = "tgr128",
2225                 .test = alg_test_hash,
2226                 .suite = {
2227                         .hash = {
2228                                 .vecs = tgr128_tv_template,
2229                                 .count = TGR128_TEST_VECTORS
2230                         }
2231                 }
2232         }, {
2233                 .alg = "tgr160",
2234                 .test = alg_test_hash,
2235                 .suite = {
2236                         .hash = {
2237                                 .vecs = tgr160_tv_template,
2238                                 .count = TGR160_TEST_VECTORS
2239                         }
2240                 }
2241         }, {
2242                 .alg = "tgr192",
2243                 .test = alg_test_hash,
2244                 .suite = {
2245                         .hash = {
2246                                 .vecs = tgr192_tv_template,
2247                                 .count = TGR192_TEST_VECTORS
2248                         }
2249                 }
2250         }, {
2251                 .alg = "vmac(aes)",
2252                 .test = alg_test_hash,
2253                 .suite = {
2254                         .hash = {
2255                                 .vecs = aes_vmac128_tv_template,
2256                                 .count = VMAC_AES_TEST_VECTORS
2257                         }
2258                 }
2259         }, {
2260                 .alg = "wp256",
2261                 .test = alg_test_hash,
2262                 .suite = {
2263                         .hash = {
2264                                 .vecs = wp256_tv_template,
2265                                 .count = WP256_TEST_VECTORS
2266                         }
2267                 }
2268         }, {
2269                 .alg = "wp384",
2270                 .test = alg_test_hash,
2271                 .suite = {
2272                         .hash = {
2273                                 .vecs = wp384_tv_template,
2274                                 .count = WP384_TEST_VECTORS
2275                         }
2276                 }
2277         }, {
2278                 .alg = "wp512",
2279                 .test = alg_test_hash,
2280                 .suite = {
2281                         .hash = {
2282                                 .vecs = wp512_tv_template,
2283                                 .count = WP512_TEST_VECTORS
2284                         }
2285                 }
2286         }, {
2287                 .alg = "xcbc(aes)",
2288                 .test = alg_test_hash,
2289                 .suite = {
2290                         .hash = {
2291                                 .vecs = aes_xcbc128_tv_template,
2292                                 .count = XCBC_AES_TEST_VECTORS
2293                         }
2294                 }
2295         }, {
2296                 .alg = "xts(aes)",
2297                 .test = alg_test_skcipher,
2298                 .suite = {
2299                         .cipher = {
2300                                 .enc = {
2301                                         .vecs = aes_xts_enc_tv_template,
2302                                         .count = AES_XTS_ENC_TEST_VECTORS
2303                                 },
2304                                 .dec = {
2305                                         .vecs = aes_xts_dec_tv_template,
2306                                         .count = AES_XTS_DEC_TEST_VECTORS
2307                                 }
2308                         }
2309                 }
2310         }, {
2311                 .alg = "zlib",
2312                 .test = alg_test_pcomp,
2313                 .suite = {
2314                         .pcomp = {
2315                                 .comp = {
2316                                         .vecs = zlib_comp_tv_template,
2317                                         .count = ZLIB_COMP_TEST_VECTORS
2318                                 },
2319                                 .decomp = {
2320                                         .vecs = zlib_decomp_tv_template,
2321                                         .count = ZLIB_DECOMP_TEST_VECTORS
2322                                 }
2323                         }
2324                 }
2325         }
2326 };
2327
2328 static int alg_find_test(const char *alg)
2329 {
2330         int start = 0;
2331         int end = ARRAY_SIZE(alg_test_descs);
2332
2333         while (start < end) {
2334                 int i = (start + end) / 2;
2335                 int diff = strcmp(alg_test_descs[i].alg, alg);
2336
2337                 if (diff > 0) {
2338                         end = i;
2339                         continue;
2340                 }
2341
2342                 if (diff < 0) {
2343                         start = i + 1;
2344                         continue;
2345                 }
2346
2347                 return i;
2348         }
2349
2350         return -1;
2351 }
2352
2353 int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
2354 {
2355         int i;
2356         int j;
2357         int rc;
2358
2359         if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) {
2360                 char nalg[CRYPTO_MAX_ALG_NAME];
2361
2362                 if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >=
2363                     sizeof(nalg))
2364                         return -ENAMETOOLONG;
2365
2366                 i = alg_find_test(nalg);
2367                 if (i < 0)
2368                         goto notest;
2369
2370                 if (fips_enabled && !alg_test_descs[i].fips_allowed)
2371                         goto non_fips_alg;
2372
2373                 rc = alg_test_cipher(alg_test_descs + i, driver, type, mask);
2374                 goto test_done;
2375         }
2376
2377         i = alg_find_test(alg);
2378         j = alg_find_test(driver);
2379         if (i < 0 && j < 0)
2380                 goto notest;
2381
2382         if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) ||
2383                              (j >= 0 && !alg_test_descs[j].fips_allowed)))
2384                 goto non_fips_alg;
2385
2386         rc = 0;
2387         if (i >= 0)
2388                 rc |= alg_test_descs[i].test(alg_test_descs + i, driver,
2389                                              type, mask);
2390         if (j >= 0)
2391                 rc |= alg_test_descs[j].test(alg_test_descs + j, driver,
2392                                              type, mask);
2393
2394 test_done:
2395         if (fips_enabled && rc)
2396                 panic("%s: %s alg self test failed in fips mode!\n", driver, alg);
2397
2398         if (fips_enabled && !rc)
2399                 printk(KERN_INFO "alg: self-tests for %s (%s) passed\n",
2400                        driver, alg);
2401
2402         return rc;
2403
2404 notest:
2405         printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
2406         return 0;
2407 non_fips_alg:
2408         return -EINVAL;
2409 }
2410 EXPORT_SYMBOL_GPL(alg_test);