c494d7610be14336262e126434cde7b8b530fae4
[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 = 0, i, j, seedsize;
1205         u8 *seed;
1206         char result[32];
1207
1208         seedsize = crypto_rng_seedsize(tfm);
1209
1210         seed = kmalloc(seedsize, GFP_KERNEL);
1211         if (!seed) {
1212                 printk(KERN_ERR "alg: cprng: Failed to allocate seed space "
1213                        "for %s\n", algo);
1214                 return -ENOMEM;
1215         }
1216
1217         for (i = 0; i < tcount; i++) {
1218                 memset(result, 0, 32);
1219
1220                 memcpy(seed, template[i].v, template[i].vlen);
1221                 memcpy(seed + template[i].vlen, template[i].key,
1222                        template[i].klen);
1223                 memcpy(seed + template[i].vlen + template[i].klen,
1224                        template[i].dt, template[i].dtlen);
1225
1226                 err = crypto_rng_reset(tfm, seed, seedsize);
1227                 if (err) {
1228                         printk(KERN_ERR "alg: cprng: Failed to reset rng "
1229                                "for %s\n", algo);
1230                         goto out;
1231                 }
1232
1233                 for (j = 0; j < template[i].loops; j++) {
1234                         err = crypto_rng_get_bytes(tfm, result,
1235                                                    template[i].rlen);
1236                         if (err != template[i].rlen) {
1237                                 printk(KERN_ERR "alg: cprng: Failed to obtain "
1238                                        "the correct amount of random data for "
1239                                        "%s (requested %d, got %d)\n", algo,
1240                                        template[i].rlen, err);
1241                                 goto out;
1242                         }
1243                 }
1244
1245                 err = memcmp(result, template[i].result,
1246                              template[i].rlen);
1247                 if (err) {
1248                         printk(KERN_ERR "alg: cprng: Test %d failed for %s\n",
1249                                i, algo);
1250                         hexdump(result, template[i].rlen);
1251                         err = -EINVAL;
1252                         goto out;
1253                 }
1254         }
1255
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 static int alg_test_null(const struct alg_test_desc *desc,
1481                              const char *driver, u32 type, u32 mask)
1482 {
1483         return 0;
1484 }
1485
1486 /* Please keep this list sorted by algorithm name. */
1487 static const struct alg_test_desc alg_test_descs[] = {
1488         {
1489                 .alg = "__driver-cbc-aes-aesni",
1490                 .test = alg_test_null,
1491                 .suite = {
1492                         .cipher = {
1493                                 .enc = {
1494                                         .vecs = NULL,
1495                                         .count = 0
1496                                 },
1497                                 .dec = {
1498                                         .vecs = NULL,
1499                                         .count = 0
1500                                 }
1501                         }
1502                 }
1503         }, {
1504                 .alg = "__driver-ecb-aes-aesni",
1505                 .test = alg_test_null,
1506                 .suite = {
1507                         .cipher = {
1508                                 .enc = {
1509                                         .vecs = NULL,
1510                                         .count = 0
1511                                 },
1512                                 .dec = {
1513                                         .vecs = NULL,
1514                                         .count = 0
1515                                 }
1516                         }
1517                 }
1518         }, {
1519                 .alg = "__ghash-pclmulqdqni",
1520                 .test = alg_test_null,
1521                 .suite = {
1522                         .hash = {
1523                                 .vecs = NULL,
1524                                 .count = 0
1525                         }
1526                 }
1527         }, {
1528                 .alg = "ansi_cprng",
1529                 .test = alg_test_cprng,
1530                 .fips_allowed = 1,
1531                 .suite = {
1532                         .cprng = {
1533                                 .vecs = ansi_cprng_aes_tv_template,
1534                                 .count = ANSI_CPRNG_AES_TEST_VECTORS
1535                         }
1536                 }
1537         }, {
1538                 .alg = "cbc(aes)",
1539                 .test = alg_test_skcipher,
1540                 .fips_allowed = 1,
1541                 .suite = {
1542                         .cipher = {
1543                                 .enc = {
1544                                         .vecs = aes_cbc_enc_tv_template,
1545                                         .count = AES_CBC_ENC_TEST_VECTORS
1546                                 },
1547                                 .dec = {
1548                                         .vecs = aes_cbc_dec_tv_template,
1549                                         .count = AES_CBC_DEC_TEST_VECTORS
1550                                 }
1551                         }
1552                 }
1553         }, {
1554                 .alg = "cbc(anubis)",
1555                 .test = alg_test_skcipher,
1556                 .suite = {
1557                         .cipher = {
1558                                 .enc = {
1559                                         .vecs = anubis_cbc_enc_tv_template,
1560                                         .count = ANUBIS_CBC_ENC_TEST_VECTORS
1561                                 },
1562                                 .dec = {
1563                                         .vecs = anubis_cbc_dec_tv_template,
1564                                         .count = ANUBIS_CBC_DEC_TEST_VECTORS
1565                                 }
1566                         }
1567                 }
1568         }, {
1569                 .alg = "cbc(blowfish)",
1570                 .test = alg_test_skcipher,
1571                 .suite = {
1572                         .cipher = {
1573                                 .enc = {
1574                                         .vecs = bf_cbc_enc_tv_template,
1575                                         .count = BF_CBC_ENC_TEST_VECTORS
1576                                 },
1577                                 .dec = {
1578                                         .vecs = bf_cbc_dec_tv_template,
1579                                         .count = BF_CBC_DEC_TEST_VECTORS
1580                                 }
1581                         }
1582                 }
1583         }, {
1584                 .alg = "cbc(camellia)",
1585                 .test = alg_test_skcipher,
1586                 .suite = {
1587                         .cipher = {
1588                                 .enc = {
1589                                         .vecs = camellia_cbc_enc_tv_template,
1590                                         .count = CAMELLIA_CBC_ENC_TEST_VECTORS
1591                                 },
1592                                 .dec = {
1593                                         .vecs = camellia_cbc_dec_tv_template,
1594                                         .count = CAMELLIA_CBC_DEC_TEST_VECTORS
1595                                 }
1596                         }
1597                 }
1598         }, {
1599                 .alg = "cbc(des)",
1600                 .test = alg_test_skcipher,
1601                 .suite = {
1602                         .cipher = {
1603                                 .enc = {
1604                                         .vecs = des_cbc_enc_tv_template,
1605                                         .count = DES_CBC_ENC_TEST_VECTORS
1606                                 },
1607                                 .dec = {
1608                                         .vecs = des_cbc_dec_tv_template,
1609                                         .count = DES_CBC_DEC_TEST_VECTORS
1610                                 }
1611                         }
1612                 }
1613         }, {
1614                 .alg = "cbc(des3_ede)",
1615                 .test = alg_test_skcipher,
1616                 .fips_allowed = 1,
1617                 .suite = {
1618                         .cipher = {
1619                                 .enc = {
1620                                         .vecs = des3_ede_cbc_enc_tv_template,
1621                                         .count = DES3_EDE_CBC_ENC_TEST_VECTORS
1622                                 },
1623                                 .dec = {
1624                                         .vecs = des3_ede_cbc_dec_tv_template,
1625                                         .count = DES3_EDE_CBC_DEC_TEST_VECTORS
1626                                 }
1627                         }
1628                 }
1629         }, {
1630                 .alg = "cbc(twofish)",
1631                 .test = alg_test_skcipher,
1632                 .suite = {
1633                         .cipher = {
1634                                 .enc = {
1635                                         .vecs = tf_cbc_enc_tv_template,
1636                                         .count = TF_CBC_ENC_TEST_VECTORS
1637                                 },
1638                                 .dec = {
1639                                         .vecs = tf_cbc_dec_tv_template,
1640                                         .count = TF_CBC_DEC_TEST_VECTORS
1641                                 }
1642                         }
1643                 }
1644         }, {
1645                 .alg = "ccm(aes)",
1646                 .test = alg_test_aead,
1647                 .fips_allowed = 1,
1648                 .suite = {
1649                         .aead = {
1650                                 .enc = {
1651                                         .vecs = aes_ccm_enc_tv_template,
1652                                         .count = AES_CCM_ENC_TEST_VECTORS
1653                                 },
1654                                 .dec = {
1655                                         .vecs = aes_ccm_dec_tv_template,
1656                                         .count = AES_CCM_DEC_TEST_VECTORS
1657                                 }
1658                         }
1659                 }
1660         }, {
1661                 .alg = "crc32c",
1662                 .test = alg_test_crc32c,
1663                 .fips_allowed = 1,
1664                 .suite = {
1665                         .hash = {
1666                                 .vecs = crc32c_tv_template,
1667                                 .count = CRC32C_TEST_VECTORS
1668                         }
1669                 }
1670         }, {
1671                 .alg = "cryptd(__driver-ecb-aes-aesni)",
1672                 .test = alg_test_null,
1673                 .suite = {
1674                         .cipher = {
1675                                 .enc = {
1676                                         .vecs = NULL,
1677                                         .count = 0
1678                                 },
1679                                 .dec = {
1680                                         .vecs = NULL,
1681                                         .count = 0
1682                                 }
1683                         }
1684                 }
1685         }, {
1686                 .alg = "cryptd(__ghash-pclmulqdqni)",
1687                 .test = alg_test_null,
1688                 .suite = {
1689                         .hash = {
1690                                 .vecs = NULL,
1691                                 .count = 0
1692                         }
1693                 }
1694         }, {
1695                 .alg = "ctr(aes)",
1696                 .test = alg_test_skcipher,
1697                 .fips_allowed = 1,
1698                 .suite = {
1699                         .cipher = {
1700                                 .enc = {
1701                                         .vecs = aes_ctr_enc_tv_template,
1702                                         .count = AES_CTR_ENC_TEST_VECTORS
1703                                 },
1704                                 .dec = {
1705                                         .vecs = aes_ctr_dec_tv_template,
1706                                         .count = AES_CTR_DEC_TEST_VECTORS
1707                                 }
1708                         }
1709                 }
1710         }, {
1711                 .alg = "cts(cbc(aes))",
1712                 .test = alg_test_skcipher,
1713                 .suite = {
1714                         .cipher = {
1715                                 .enc = {
1716                                         .vecs = cts_mode_enc_tv_template,
1717                                         .count = CTS_MODE_ENC_TEST_VECTORS
1718                                 },
1719                                 .dec = {
1720                                         .vecs = cts_mode_dec_tv_template,
1721                                         .count = CTS_MODE_DEC_TEST_VECTORS
1722                                 }
1723                         }
1724                 }
1725         }, {
1726                 .alg = "deflate",
1727                 .test = alg_test_comp,
1728                 .suite = {
1729                         .comp = {
1730                                 .comp = {
1731                                         .vecs = deflate_comp_tv_template,
1732                                         .count = DEFLATE_COMP_TEST_VECTORS
1733                                 },
1734                                 .decomp = {
1735                                         .vecs = deflate_decomp_tv_template,
1736                                         .count = DEFLATE_DECOMP_TEST_VECTORS
1737                                 }
1738                         }
1739                 }
1740         }, {
1741                 .alg = "ecb(__aes-aesni)",
1742                 .test = alg_test_null,
1743                 .suite = {
1744                         .cipher = {
1745                                 .enc = {
1746                                         .vecs = NULL,
1747                                         .count = 0
1748                                 },
1749                                 .dec = {
1750                                         .vecs = NULL,
1751                                         .count = 0
1752                                 }
1753                         }
1754                 }
1755         }, {
1756                 .alg = "ecb(aes)",
1757                 .test = alg_test_skcipher,
1758                 .fips_allowed = 1,
1759                 .suite = {
1760                         .cipher = {
1761                                 .enc = {
1762                                         .vecs = aes_enc_tv_template,
1763                                         .count = AES_ENC_TEST_VECTORS
1764                                 },
1765                                 .dec = {
1766                                         .vecs = aes_dec_tv_template,
1767                                         .count = AES_DEC_TEST_VECTORS
1768                                 }
1769                         }
1770                 }
1771         }, {
1772                 .alg = "ecb(anubis)",
1773                 .test = alg_test_skcipher,
1774                 .suite = {
1775                         .cipher = {
1776                                 .enc = {
1777                                         .vecs = anubis_enc_tv_template,
1778                                         .count = ANUBIS_ENC_TEST_VECTORS
1779                                 },
1780                                 .dec = {
1781                                         .vecs = anubis_dec_tv_template,
1782                                         .count = ANUBIS_DEC_TEST_VECTORS
1783                                 }
1784                         }
1785                 }
1786         }, {
1787                 .alg = "ecb(arc4)",
1788                 .test = alg_test_skcipher,
1789                 .suite = {
1790                         .cipher = {
1791                                 .enc = {
1792                                         .vecs = arc4_enc_tv_template,
1793                                         .count = ARC4_ENC_TEST_VECTORS
1794                                 },
1795                                 .dec = {
1796                                         .vecs = arc4_dec_tv_template,
1797                                         .count = ARC4_DEC_TEST_VECTORS
1798                                 }
1799                         }
1800                 }
1801         }, {
1802                 .alg = "ecb(blowfish)",
1803                 .test = alg_test_skcipher,
1804                 .suite = {
1805                         .cipher = {
1806                                 .enc = {
1807                                         .vecs = bf_enc_tv_template,
1808                                         .count = BF_ENC_TEST_VECTORS
1809                                 },
1810                                 .dec = {
1811                                         .vecs = bf_dec_tv_template,
1812                                         .count = BF_DEC_TEST_VECTORS
1813                                 }
1814                         }
1815                 }
1816         }, {
1817                 .alg = "ecb(camellia)",
1818                 .test = alg_test_skcipher,
1819                 .suite = {
1820                         .cipher = {
1821                                 .enc = {
1822                                         .vecs = camellia_enc_tv_template,
1823                                         .count = CAMELLIA_ENC_TEST_VECTORS
1824                                 },
1825                                 .dec = {
1826                                         .vecs = camellia_dec_tv_template,
1827                                         .count = CAMELLIA_DEC_TEST_VECTORS
1828                                 }
1829                         }
1830                 }
1831         }, {
1832                 .alg = "ecb(cast5)",
1833                 .test = alg_test_skcipher,
1834                 .suite = {
1835                         .cipher = {
1836                                 .enc = {
1837                                         .vecs = cast5_enc_tv_template,
1838                                         .count = CAST5_ENC_TEST_VECTORS
1839                                 },
1840                                 .dec = {
1841                                         .vecs = cast5_dec_tv_template,
1842                                         .count = CAST5_DEC_TEST_VECTORS
1843                                 }
1844                         }
1845                 }
1846         }, {
1847                 .alg = "ecb(cast6)",
1848                 .test = alg_test_skcipher,
1849                 .suite = {
1850                         .cipher = {
1851                                 .enc = {
1852                                         .vecs = cast6_enc_tv_template,
1853                                         .count = CAST6_ENC_TEST_VECTORS
1854                                 },
1855                                 .dec = {
1856                                         .vecs = cast6_dec_tv_template,
1857                                         .count = CAST6_DEC_TEST_VECTORS
1858                                 }
1859                         }
1860                 }
1861         }, {
1862                 .alg = "ecb(des)",
1863                 .test = alg_test_skcipher,
1864                 .fips_allowed = 1,
1865                 .suite = {
1866                         .cipher = {
1867                                 .enc = {
1868                                         .vecs = des_enc_tv_template,
1869                                         .count = DES_ENC_TEST_VECTORS
1870                                 },
1871                                 .dec = {
1872                                         .vecs = des_dec_tv_template,
1873                                         .count = DES_DEC_TEST_VECTORS
1874                                 }
1875                         }
1876                 }
1877         }, {
1878                 .alg = "ecb(des3_ede)",
1879                 .test = alg_test_skcipher,
1880                 .fips_allowed = 1,
1881                 .suite = {
1882                         .cipher = {
1883                                 .enc = {
1884                                         .vecs = des3_ede_enc_tv_template,
1885                                         .count = DES3_EDE_ENC_TEST_VECTORS
1886                                 },
1887                                 .dec = {
1888                                         .vecs = des3_ede_dec_tv_template,
1889                                         .count = DES3_EDE_DEC_TEST_VECTORS
1890                                 }
1891                         }
1892                 }
1893         }, {
1894                 .alg = "ecb(khazad)",
1895                 .test = alg_test_skcipher,
1896                 .suite = {
1897                         .cipher = {
1898                                 .enc = {
1899                                         .vecs = khazad_enc_tv_template,
1900                                         .count = KHAZAD_ENC_TEST_VECTORS
1901                                 },
1902                                 .dec = {
1903                                         .vecs = khazad_dec_tv_template,
1904                                         .count = KHAZAD_DEC_TEST_VECTORS
1905                                 }
1906                         }
1907                 }
1908         }, {
1909                 .alg = "ecb(seed)",
1910                 .test = alg_test_skcipher,
1911                 .suite = {
1912                         .cipher = {
1913                                 .enc = {
1914                                         .vecs = seed_enc_tv_template,
1915                                         .count = SEED_ENC_TEST_VECTORS
1916                                 },
1917                                 .dec = {
1918                                         .vecs = seed_dec_tv_template,
1919                                         .count = SEED_DEC_TEST_VECTORS
1920                                 }
1921                         }
1922                 }
1923         }, {
1924                 .alg = "ecb(serpent)",
1925                 .test = alg_test_skcipher,
1926                 .suite = {
1927                         .cipher = {
1928                                 .enc = {
1929                                         .vecs = serpent_enc_tv_template,
1930                                         .count = SERPENT_ENC_TEST_VECTORS
1931                                 },
1932                                 .dec = {
1933                                         .vecs = serpent_dec_tv_template,
1934                                         .count = SERPENT_DEC_TEST_VECTORS
1935                                 }
1936                         }
1937                 }
1938         }, {
1939                 .alg = "ecb(tea)",
1940                 .test = alg_test_skcipher,
1941                 .suite = {
1942                         .cipher = {
1943                                 .enc = {
1944                                         .vecs = tea_enc_tv_template,
1945                                         .count = TEA_ENC_TEST_VECTORS
1946                                 },
1947                                 .dec = {
1948                                         .vecs = tea_dec_tv_template,
1949                                         .count = TEA_DEC_TEST_VECTORS
1950                                 }
1951                         }
1952                 }
1953         }, {
1954                 .alg = "ecb(tnepres)",
1955                 .test = alg_test_skcipher,
1956                 .suite = {
1957                         .cipher = {
1958                                 .enc = {
1959                                         .vecs = tnepres_enc_tv_template,
1960                                         .count = TNEPRES_ENC_TEST_VECTORS
1961                                 },
1962                                 .dec = {
1963                                         .vecs = tnepres_dec_tv_template,
1964                                         .count = TNEPRES_DEC_TEST_VECTORS
1965                                 }
1966                         }
1967                 }
1968         }, {
1969                 .alg = "ecb(twofish)",
1970                 .test = alg_test_skcipher,
1971                 .suite = {
1972                         .cipher = {
1973                                 .enc = {
1974                                         .vecs = tf_enc_tv_template,
1975                                         .count = TF_ENC_TEST_VECTORS
1976                                 },
1977                                 .dec = {
1978                                         .vecs = tf_dec_tv_template,
1979                                         .count = TF_DEC_TEST_VECTORS
1980                                 }
1981                         }
1982                 }
1983         }, {
1984                 .alg = "ecb(xeta)",
1985                 .test = alg_test_skcipher,
1986                 .suite = {
1987                         .cipher = {
1988                                 .enc = {
1989                                         .vecs = xeta_enc_tv_template,
1990                                         .count = XETA_ENC_TEST_VECTORS
1991                                 },
1992                                 .dec = {
1993                                         .vecs = xeta_dec_tv_template,
1994                                         .count = XETA_DEC_TEST_VECTORS
1995                                 }
1996                         }
1997                 }
1998         }, {
1999                 .alg = "ecb(xtea)",
2000                 .test = alg_test_skcipher,
2001                 .suite = {
2002                         .cipher = {
2003                                 .enc = {
2004                                         .vecs = xtea_enc_tv_template,
2005                                         .count = XTEA_ENC_TEST_VECTORS
2006                                 },
2007                                 .dec = {
2008                                         .vecs = xtea_dec_tv_template,
2009                                         .count = XTEA_DEC_TEST_VECTORS
2010                                 }
2011                         }
2012                 }
2013         }, {
2014                 .alg = "gcm(aes)",
2015                 .test = alg_test_aead,
2016                 .fips_allowed = 1,
2017                 .suite = {
2018                         .aead = {
2019                                 .enc = {
2020                                         .vecs = aes_gcm_enc_tv_template,
2021                                         .count = AES_GCM_ENC_TEST_VECTORS
2022                                 },
2023                                 .dec = {
2024                                         .vecs = aes_gcm_dec_tv_template,
2025                                         .count = AES_GCM_DEC_TEST_VECTORS
2026                                 }
2027                         }
2028                 }
2029         }, {
2030                 .alg = "ghash",
2031                 .test = alg_test_hash,
2032                 .suite = {
2033                         .hash = {
2034                                 .vecs = ghash_tv_template,
2035                                 .count = GHASH_TEST_VECTORS
2036                         }
2037                 }
2038         }, {
2039                 .alg = "hmac(md5)",
2040                 .test = alg_test_hash,
2041                 .suite = {
2042                         .hash = {
2043                                 .vecs = hmac_md5_tv_template,
2044                                 .count = HMAC_MD5_TEST_VECTORS
2045                         }
2046                 }
2047         }, {
2048                 .alg = "hmac(rmd128)",
2049                 .test = alg_test_hash,
2050                 .suite = {
2051                         .hash = {
2052                                 .vecs = hmac_rmd128_tv_template,
2053                                 .count = HMAC_RMD128_TEST_VECTORS
2054                         }
2055                 }
2056         }, {
2057                 .alg = "hmac(rmd160)",
2058                 .test = alg_test_hash,
2059                 .suite = {
2060                         .hash = {
2061                                 .vecs = hmac_rmd160_tv_template,
2062                                 .count = HMAC_RMD160_TEST_VECTORS
2063                         }
2064                 }
2065         }, {
2066                 .alg = "hmac(sha1)",
2067                 .test = alg_test_hash,
2068                 .fips_allowed = 1,
2069                 .suite = {
2070                         .hash = {
2071                                 .vecs = hmac_sha1_tv_template,
2072                                 .count = HMAC_SHA1_TEST_VECTORS
2073                         }
2074                 }
2075         }, {
2076                 .alg = "hmac(sha224)",
2077                 .test = alg_test_hash,
2078                 .fips_allowed = 1,
2079                 .suite = {
2080                         .hash = {
2081                                 .vecs = hmac_sha224_tv_template,
2082                                 .count = HMAC_SHA224_TEST_VECTORS
2083                         }
2084                 }
2085         }, {
2086                 .alg = "hmac(sha256)",
2087                 .test = alg_test_hash,
2088                 .fips_allowed = 1,
2089                 .suite = {
2090                         .hash = {
2091                                 .vecs = hmac_sha256_tv_template,
2092                                 .count = HMAC_SHA256_TEST_VECTORS
2093                         }
2094                 }
2095         }, {
2096                 .alg = "hmac(sha384)",
2097                 .test = alg_test_hash,
2098                 .fips_allowed = 1,
2099                 .suite = {
2100                         .hash = {
2101                                 .vecs = hmac_sha384_tv_template,
2102                                 .count = HMAC_SHA384_TEST_VECTORS
2103                         }
2104                 }
2105         }, {
2106                 .alg = "hmac(sha512)",
2107                 .test = alg_test_hash,
2108                 .fips_allowed = 1,
2109                 .suite = {
2110                         .hash = {
2111                                 .vecs = hmac_sha512_tv_template,
2112                                 .count = HMAC_SHA512_TEST_VECTORS
2113                         }
2114                 }
2115         }, {
2116                 .alg = "lrw(aes)",
2117                 .test = alg_test_skcipher,
2118                 .suite = {
2119                         .cipher = {
2120                                 .enc = {
2121                                         .vecs = aes_lrw_enc_tv_template,
2122                                         .count = AES_LRW_ENC_TEST_VECTORS
2123                                 },
2124                                 .dec = {
2125                                         .vecs = aes_lrw_dec_tv_template,
2126                                         .count = AES_LRW_DEC_TEST_VECTORS
2127                                 }
2128                         }
2129                 }
2130         }, {
2131                 .alg = "lzo",
2132                 .test = alg_test_comp,
2133                 .suite = {
2134                         .comp = {
2135                                 .comp = {
2136                                         .vecs = lzo_comp_tv_template,
2137                                         .count = LZO_COMP_TEST_VECTORS
2138                                 },
2139                                 .decomp = {
2140                                         .vecs = lzo_decomp_tv_template,
2141                                         .count = LZO_DECOMP_TEST_VECTORS
2142                                 }
2143                         }
2144                 }
2145         }, {
2146                 .alg = "md4",
2147                 .test = alg_test_hash,
2148                 .suite = {
2149                         .hash = {
2150                                 .vecs = md4_tv_template,
2151                                 .count = MD4_TEST_VECTORS
2152                         }
2153                 }
2154         }, {
2155                 .alg = "md5",
2156                 .test = alg_test_hash,
2157                 .suite = {
2158                         .hash = {
2159                                 .vecs = md5_tv_template,
2160                                 .count = MD5_TEST_VECTORS
2161                         }
2162                 }
2163         }, {
2164                 .alg = "michael_mic",
2165                 .test = alg_test_hash,
2166                 .suite = {
2167                         .hash = {
2168                                 .vecs = michael_mic_tv_template,
2169                                 .count = MICHAEL_MIC_TEST_VECTORS
2170                         }
2171                 }
2172         }, {
2173                 .alg = "pcbc(fcrypt)",
2174                 .test = alg_test_skcipher,
2175                 .suite = {
2176                         .cipher = {
2177                                 .enc = {
2178                                         .vecs = fcrypt_pcbc_enc_tv_template,
2179                                         .count = FCRYPT_ENC_TEST_VECTORS
2180                                 },
2181                                 .dec = {
2182                                         .vecs = fcrypt_pcbc_dec_tv_template,
2183                                         .count = FCRYPT_DEC_TEST_VECTORS
2184                                 }
2185                         }
2186                 }
2187         }, {
2188                 .alg = "rfc3686(ctr(aes))",
2189                 .test = alg_test_skcipher,
2190                 .fips_allowed = 1,
2191                 .suite = {
2192                         .cipher = {
2193                                 .enc = {
2194                                         .vecs = aes_ctr_rfc3686_enc_tv_template,
2195                                         .count = AES_CTR_3686_ENC_TEST_VECTORS
2196                                 },
2197                                 .dec = {
2198                                         .vecs = aes_ctr_rfc3686_dec_tv_template,
2199                                         .count = AES_CTR_3686_DEC_TEST_VECTORS
2200                                 }
2201                         }
2202                 }
2203         }, {
2204                 .alg = "rfc4309(ccm(aes))",
2205                 .test = alg_test_aead,
2206                 .fips_allowed = 1,
2207                 .suite = {
2208                         .aead = {
2209                                 .enc = {
2210                                         .vecs = aes_ccm_rfc4309_enc_tv_template,
2211                                         .count = AES_CCM_4309_ENC_TEST_VECTORS
2212                                 },
2213                                 .dec = {
2214                                         .vecs = aes_ccm_rfc4309_dec_tv_template,
2215                                         .count = AES_CCM_4309_DEC_TEST_VECTORS
2216                                 }
2217                         }
2218                 }
2219         }, {
2220                 .alg = "rmd128",
2221                 .test = alg_test_hash,
2222                 .suite = {
2223                         .hash = {
2224                                 .vecs = rmd128_tv_template,
2225                                 .count = RMD128_TEST_VECTORS
2226                         }
2227                 }
2228         }, {
2229                 .alg = "rmd160",
2230                 .test = alg_test_hash,
2231                 .suite = {
2232                         .hash = {
2233                                 .vecs = rmd160_tv_template,
2234                                 .count = RMD160_TEST_VECTORS
2235                         }
2236                 }
2237         }, {
2238                 .alg = "rmd256",
2239                 .test = alg_test_hash,
2240                 .suite = {
2241                         .hash = {
2242                                 .vecs = rmd256_tv_template,
2243                                 .count = RMD256_TEST_VECTORS
2244                         }
2245                 }
2246         }, {
2247                 .alg = "rmd320",
2248                 .test = alg_test_hash,
2249                 .suite = {
2250                         .hash = {
2251                                 .vecs = rmd320_tv_template,
2252                                 .count = RMD320_TEST_VECTORS
2253                         }
2254                 }
2255         }, {
2256                 .alg = "salsa20",
2257                 .test = alg_test_skcipher,
2258                 .suite = {
2259                         .cipher = {
2260                                 .enc = {
2261                                         .vecs = salsa20_stream_enc_tv_template,
2262                                         .count = SALSA20_STREAM_ENC_TEST_VECTORS
2263                                 }
2264                         }
2265                 }
2266         }, {
2267                 .alg = "sha1",
2268                 .test = alg_test_hash,
2269                 .fips_allowed = 1,
2270                 .suite = {
2271                         .hash = {
2272                                 .vecs = sha1_tv_template,
2273                                 .count = SHA1_TEST_VECTORS
2274                         }
2275                 }
2276         }, {
2277                 .alg = "sha224",
2278                 .test = alg_test_hash,
2279                 .fips_allowed = 1,
2280                 .suite = {
2281                         .hash = {
2282                                 .vecs = sha224_tv_template,
2283                                 .count = SHA224_TEST_VECTORS
2284                         }
2285                 }
2286         }, {
2287                 .alg = "sha256",
2288                 .test = alg_test_hash,
2289                 .fips_allowed = 1,
2290                 .suite = {
2291                         .hash = {
2292                                 .vecs = sha256_tv_template,
2293                                 .count = SHA256_TEST_VECTORS
2294                         }
2295                 }
2296         }, {
2297                 .alg = "sha384",
2298                 .test = alg_test_hash,
2299                 .fips_allowed = 1,
2300                 .suite = {
2301                         .hash = {
2302                                 .vecs = sha384_tv_template,
2303                                 .count = SHA384_TEST_VECTORS
2304                         }
2305                 }
2306         }, {
2307                 .alg = "sha512",
2308                 .test = alg_test_hash,
2309                 .fips_allowed = 1,
2310                 .suite = {
2311                         .hash = {
2312                                 .vecs = sha512_tv_template,
2313                                 .count = SHA512_TEST_VECTORS
2314                         }
2315                 }
2316         }, {
2317                 .alg = "tgr128",
2318                 .test = alg_test_hash,
2319                 .suite = {
2320                         .hash = {
2321                                 .vecs = tgr128_tv_template,
2322                                 .count = TGR128_TEST_VECTORS
2323                         }
2324                 }
2325         }, {
2326                 .alg = "tgr160",
2327                 .test = alg_test_hash,
2328                 .suite = {
2329                         .hash = {
2330                                 .vecs = tgr160_tv_template,
2331                                 .count = TGR160_TEST_VECTORS
2332                         }
2333                 }
2334         }, {
2335                 .alg = "tgr192",
2336                 .test = alg_test_hash,
2337                 .suite = {
2338                         .hash = {
2339                                 .vecs = tgr192_tv_template,
2340                                 .count = TGR192_TEST_VECTORS
2341                         }
2342                 }
2343         }, {
2344                 .alg = "vmac(aes)",
2345                 .test = alg_test_hash,
2346                 .suite = {
2347                         .hash = {
2348                                 .vecs = aes_vmac128_tv_template,
2349                                 .count = VMAC_AES_TEST_VECTORS
2350                         }
2351                 }
2352         }, {
2353                 .alg = "wp256",
2354                 .test = alg_test_hash,
2355                 .suite = {
2356                         .hash = {
2357                                 .vecs = wp256_tv_template,
2358                                 .count = WP256_TEST_VECTORS
2359                         }
2360                 }
2361         }, {
2362                 .alg = "wp384",
2363                 .test = alg_test_hash,
2364                 .suite = {
2365                         .hash = {
2366                                 .vecs = wp384_tv_template,
2367                                 .count = WP384_TEST_VECTORS
2368                         }
2369                 }
2370         }, {
2371                 .alg = "wp512",
2372                 .test = alg_test_hash,
2373                 .suite = {
2374                         .hash = {
2375                                 .vecs = wp512_tv_template,
2376                                 .count = WP512_TEST_VECTORS
2377                         }
2378                 }
2379         }, {
2380                 .alg = "xcbc(aes)",
2381                 .test = alg_test_hash,
2382                 .suite = {
2383                         .hash = {
2384                                 .vecs = aes_xcbc128_tv_template,
2385                                 .count = XCBC_AES_TEST_VECTORS
2386                         }
2387                 }
2388         }, {
2389                 .alg = "xts(aes)",
2390                 .test = alg_test_skcipher,
2391                 .suite = {
2392                         .cipher = {
2393                                 .enc = {
2394                                         .vecs = aes_xts_enc_tv_template,
2395                                         .count = AES_XTS_ENC_TEST_VECTORS
2396                                 },
2397                                 .dec = {
2398                                         .vecs = aes_xts_dec_tv_template,
2399                                         .count = AES_XTS_DEC_TEST_VECTORS
2400                                 }
2401                         }
2402                 }
2403         }, {
2404                 .alg = "zlib",
2405                 .test = alg_test_pcomp,
2406                 .suite = {
2407                         .pcomp = {
2408                                 .comp = {
2409                                         .vecs = zlib_comp_tv_template,
2410                                         .count = ZLIB_COMP_TEST_VECTORS
2411                                 },
2412                                 .decomp = {
2413                                         .vecs = zlib_decomp_tv_template,
2414                                         .count = ZLIB_DECOMP_TEST_VECTORS
2415                                 }
2416                         }
2417                 }
2418         }
2419 };
2420
2421 static int alg_find_test(const char *alg)
2422 {
2423         int start = 0;
2424         int end = ARRAY_SIZE(alg_test_descs);
2425
2426         while (start < end) {
2427                 int i = (start + end) / 2;
2428                 int diff = strcmp(alg_test_descs[i].alg, alg);
2429
2430                 if (diff > 0) {
2431                         end = i;
2432                         continue;
2433                 }
2434
2435                 if (diff < 0) {
2436                         start = i + 1;
2437                         continue;
2438                 }
2439
2440                 return i;
2441         }
2442
2443         return -1;
2444 }
2445
2446 int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
2447 {
2448         int i;
2449         int j;
2450         int rc;
2451
2452         if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) {
2453                 char nalg[CRYPTO_MAX_ALG_NAME];
2454
2455                 if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >=
2456                     sizeof(nalg))
2457                         return -ENAMETOOLONG;
2458
2459                 i = alg_find_test(nalg);
2460                 if (i < 0)
2461                         goto notest;
2462
2463                 if (fips_enabled && !alg_test_descs[i].fips_allowed)
2464                         goto non_fips_alg;
2465
2466                 rc = alg_test_cipher(alg_test_descs + i, driver, type, mask);
2467                 goto test_done;
2468         }
2469
2470         i = alg_find_test(alg);
2471         j = alg_find_test(driver);
2472         if (i < 0 && j < 0)
2473                 goto notest;
2474
2475         if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) ||
2476                              (j >= 0 && !alg_test_descs[j].fips_allowed)))
2477                 goto non_fips_alg;
2478
2479         rc = 0;
2480         if (i >= 0)
2481                 rc |= alg_test_descs[i].test(alg_test_descs + i, driver,
2482                                              type, mask);
2483         if (j >= 0)
2484                 rc |= alg_test_descs[j].test(alg_test_descs + j, driver,
2485                                              type, mask);
2486
2487 test_done:
2488         if (fips_enabled && rc)
2489                 panic("%s: %s alg self test failed in fips mode!\n", driver, alg);
2490
2491         if (fips_enabled && !rc)
2492                 printk(KERN_INFO "alg: self-tests for %s (%s) passed\n",
2493                        driver, alg);
2494
2495         return rc;
2496
2497 notest:
2498         printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
2499         return 0;
2500 non_fips_alg:
2501         return -EINVAL;
2502 }
2503 EXPORT_SYMBOL_GPL(alg_test);