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