crypto: tcrypt - Fix memory leak in test_cipher
[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  * 2007-11-13 Added GCM tests
17  * 2007-11-13 Added AEAD support
18  * 2007-11-06 Added SHA-224 and SHA-224-HMAC tests
19  * 2006-12-07 Added SHA384 HMAC and SHA512 HMAC tests
20  * 2004-08-09 Added cipher speed tests (Reyk Floeter <reyk@vantronix.net>)
21  * 2003-09-14 Rewritten by Kartikey Mahendra Bhatt
22  *
23  */
24
25 #include <linux/err.h>
26 #include <linux/init.h>
27 #include <linux/module.h>
28 #include <linux/mm.h>
29 #include <linux/slab.h>
30 #include <linux/scatterlist.h>
31 #include <linux/string.h>
32 #include <linux/crypto.h>
33 #include <linux/highmem.h>
34 #include <linux/moduleparam.h>
35 #include <linux/jiffies.h>
36 #include <linux/timex.h>
37 #include <linux/interrupt.h>
38 #include "tcrypt.h"
39
40 /*
41  * Need to kmalloc() memory for testing kmap().
42  */
43 #define TVMEMSIZE       16384
44 #define XBUFSIZE        32768
45
46 /*
47  * Indexes into the xbuf to simulate cross-page access.
48  */
49 #define IDX1            37
50 #define IDX2            32400
51 #define IDX3            1
52 #define IDX4            8193
53 #define IDX5            22222
54 #define IDX6            17101
55 #define IDX7            27333
56 #define IDX8            3000
57
58 /*
59 * Used by test_cipher()
60 */
61 #define ENCRYPT 1
62 #define DECRYPT 0
63
64 struct tcrypt_result {
65         struct completion completion;
66         int err;
67 };
68
69 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
70
71 /*
72  * Used by test_cipher_speed()
73  */
74 static unsigned int sec;
75
76 static int mode;
77 static char *xbuf;
78 static char *axbuf;
79 static char *tvmem;
80
81 static char *check[] = {
82         "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256",
83         "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes",
84         "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
85         "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta",  "fcrypt",
86         "camellia", "seed", "salsa20", "lzo", "cts", NULL
87 };
88
89 static void hexdump(unsigned char *buf, unsigned int len)
90 {
91         print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
92                         16, 1,
93                         buf, len, false);
94 }
95
96 static void tcrypt_complete(struct crypto_async_request *req, int err)
97 {
98         struct tcrypt_result *res = req->data;
99
100         if (err == -EINPROGRESS)
101                 return;
102
103         res->err = err;
104         complete(&res->completion);
105 }
106
107 static void test_hash(char *algo, struct hash_testvec *template,
108                       unsigned int tcount)
109 {
110         unsigned int i, j, k, temp;
111         struct scatterlist sg[8];
112         char result[64];
113         struct crypto_hash *tfm;
114         struct hash_desc desc;
115         int ret;
116         void *hash_buff;
117
118         printk("\ntesting %s\n", algo);
119
120         tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
121         if (IS_ERR(tfm)) {
122                 printk("failed to load transform for %s: %ld\n", algo,
123                        PTR_ERR(tfm));
124                 return;
125         }
126
127         desc.tfm = tfm;
128         desc.flags = 0;
129
130         for (i = 0; i < tcount; i++) {
131                 printk("test %u:\n", i + 1);
132                 memset(result, 0, 64);
133
134                 hash_buff = kzalloc(template[i].psize, GFP_KERNEL);
135                 if (!hash_buff)
136                         continue;
137
138                 memcpy(hash_buff, template[i].plaintext, template[i].psize);
139                 sg_init_one(&sg[0], hash_buff, template[i].psize);
140
141                 if (template[i].ksize) {
142                         ret = crypto_hash_setkey(tfm, template[i].key,
143                                                  template[i].ksize);
144                         if (ret) {
145                                 printk("setkey() failed ret=%d\n", ret);
146                                 kfree(hash_buff);
147                                 goto out;
148                         }
149                 }
150
151                 ret = crypto_hash_digest(&desc, sg, template[i].psize, result);
152                 if (ret) {
153                         printk("digest () failed ret=%d\n", ret);
154                         kfree(hash_buff);
155                         goto out;
156                 }
157
158                 hexdump(result, crypto_hash_digestsize(tfm));
159                 printk("%s\n",
160                        memcmp(result, template[i].digest,
161                               crypto_hash_digestsize(tfm)) ?
162                        "fail" : "pass");
163                 kfree(hash_buff);
164         }
165
166         printk("testing %s across pages\n", algo);
167
168         /* setup the dummy buffer first */
169         memset(xbuf, 0, XBUFSIZE);
170
171         j = 0;
172         for (i = 0; i < tcount; i++) {
173                 if (template[i].np) {
174                         j++;
175                         printk("test %u:\n", j);
176                         memset(result, 0, 64);
177
178                         temp = 0;
179                         sg_init_table(sg, template[i].np);
180                         for (k = 0; k < template[i].np; k++) {
181                                 memcpy(&xbuf[IDX[k]],
182                                        template[i].plaintext + temp,
183                                        template[i].tap[k]);
184                                 temp += template[i].tap[k];
185                                 sg_set_buf(&sg[k], &xbuf[IDX[k]],
186                                             template[i].tap[k]);
187                         }
188
189                         if (template[i].ksize) {
190                                 ret = crypto_hash_setkey(tfm, template[i].key,
191                                                          template[i].ksize);
192
193                                 if (ret) {
194                                         printk("setkey() failed ret=%d\n", ret);
195                                         goto out;
196                                 }
197                         }
198
199                         ret = crypto_hash_digest(&desc, sg, template[i].psize,
200                                                  result);
201                         if (ret) {
202                                 printk("digest () failed ret=%d\n", ret);
203                                 goto out;
204                         }
205
206                         hexdump(result, crypto_hash_digestsize(tfm));
207                         printk("%s\n",
208                                memcmp(result, template[i].digest,
209                                       crypto_hash_digestsize(tfm)) ?
210                                "fail" : "pass");
211                 }
212         }
213
214 out:
215         crypto_free_hash(tfm);
216 }
217
218 static void test_aead(char *algo, int enc, struct aead_testvec *template,
219                       unsigned int tcount)
220 {
221         unsigned int ret, i, j, k, temp;
222         char *q;
223         struct crypto_aead *tfm;
224         char *key;
225         struct aead_request *req;
226         struct scatterlist sg[8];
227         struct scatterlist asg[8];
228         const char *e;
229         struct tcrypt_result result;
230         unsigned int authsize;
231         void *input;
232         void *assoc;
233         char iv[MAX_IVLEN];
234
235         if (enc == ENCRYPT)
236                 e = "encryption";
237         else
238                 e = "decryption";
239
240         printk(KERN_INFO "\ntesting %s %s\n", algo, e);
241
242         init_completion(&result.completion);
243
244         tfm = crypto_alloc_aead(algo, 0, 0);
245
246         if (IS_ERR(tfm)) {
247                 printk(KERN_INFO "failed to load transform for %s: %ld\n",
248                        algo, PTR_ERR(tfm));
249                 return;
250         }
251
252         req = aead_request_alloc(tfm, GFP_KERNEL);
253         if (!req) {
254                 printk(KERN_INFO "failed to allocate request for %s\n", algo);
255                 goto out;
256         }
257
258         aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
259                                   tcrypt_complete, &result);
260
261         for (i = 0, j = 0; i < tcount; i++) {
262                 if (!template[i].np) {
263                         printk(KERN_INFO "test %u (%d bit key):\n",
264                                ++j, template[i].klen * 8);
265
266                         /* some tepmplates have no input data but they will
267                          * touch input
268                          */
269                         input = kzalloc(template[i].ilen + template[i].rlen, GFP_KERNEL);
270                         if (!input)
271                                 continue;
272
273                         assoc = kzalloc(template[i].alen, GFP_KERNEL);
274                         if (!assoc) {
275                                 kfree(input);
276                                 continue;
277                         }
278
279                         memcpy(input, template[i].input, template[i].ilen);
280                         memcpy(assoc, template[i].assoc, template[i].alen);
281                         if (template[i].iv)
282                                 memcpy(iv, template[i].iv, MAX_IVLEN);
283                         else
284                                 memset(iv, 0, MAX_IVLEN);
285
286                         crypto_aead_clear_flags(tfm, ~0);
287                         if (template[i].wk)
288                                 crypto_aead_set_flags(
289                                         tfm, CRYPTO_TFM_REQ_WEAK_KEY);
290
291                         if (template[i].key)
292                                 key = template[i].key;
293                         else
294                                 key = kzalloc(template[i].klen, GFP_KERNEL);
295
296                         ret = crypto_aead_setkey(tfm, key,
297                                                  template[i].klen);
298                         if (ret) {
299                                 printk(KERN_INFO "setkey() failed flags=%x\n",
300                                        crypto_aead_get_flags(tfm));
301
302                                 if (!template[i].fail)
303                                         goto next_one;
304                         }
305
306                         authsize = abs(template[i].rlen - template[i].ilen);
307                         ret = crypto_aead_setauthsize(tfm, authsize);
308                         if (ret) {
309                                 printk(KERN_INFO
310                                        "failed to set authsize = %u\n",
311                                        authsize);
312                                 goto next_one;
313                         }
314
315                         sg_init_one(&sg[0], input,
316                                     template[i].ilen + (enc ? authsize : 0));
317
318                         sg_init_one(&asg[0], assoc, template[i].alen);
319
320                         aead_request_set_crypt(req, sg, sg,
321                                                template[i].ilen, iv);
322
323                         aead_request_set_assoc(req, asg, template[i].alen);
324
325                         ret = enc ?
326                                 crypto_aead_encrypt(req) :
327                                 crypto_aead_decrypt(req);
328
329                         switch (ret) {
330                         case 0:
331                                 break;
332                         case -EINPROGRESS:
333                         case -EBUSY:
334                                 ret = wait_for_completion_interruptible(
335                                         &result.completion);
336                                 if (!ret && !(ret = result.err)) {
337                                         INIT_COMPLETION(result.completion);
338                                         break;
339                                 }
340                                 /* fall through */
341                         default:
342                                 printk(KERN_INFO "%s () failed err=%d\n",
343                                        e, -ret);
344                                 goto next_one;
345                         }
346
347                         q = kmap(sg_page(&sg[0])) + sg[0].offset;
348                         hexdump(q, template[i].rlen);
349
350                         printk(KERN_INFO "enc/dec: %s\n",
351                                memcmp(q, template[i].result,
352                                       template[i].rlen) ? "fail" : "pass");
353                         kunmap(sg_page(&sg[0]));
354 next_one:
355                         if (!template[i].key)
356                                 kfree(key);
357                         kfree(assoc);
358                         kfree(input);
359                 }
360         }
361
362         printk(KERN_INFO "\ntesting %s %s across pages (chunking)\n", algo, e);
363         memset(xbuf, 0, XBUFSIZE);
364         memset(axbuf, 0, XBUFSIZE);
365
366         for (i = 0, j = 0; i < tcount; i++) {
367                 if (template[i].np) {
368                         printk(KERN_INFO "test %u (%d bit key):\n",
369                                ++j, template[i].klen * 8);
370
371                         if (template[i].iv)
372                                 memcpy(iv, template[i].iv, MAX_IVLEN);
373                         else
374                                 memset(iv, 0, MAX_IVLEN);
375
376                         crypto_aead_clear_flags(tfm, ~0);
377                         if (template[i].wk)
378                                 crypto_aead_set_flags(
379                                         tfm, CRYPTO_TFM_REQ_WEAK_KEY);
380                         key = template[i].key;
381
382                         ret = crypto_aead_setkey(tfm, key, template[i].klen);
383                         if (ret) {
384                                 printk(KERN_INFO "setkey() failed flags=%x\n",
385                                        crypto_aead_get_flags(tfm));
386
387                                 if (!template[i].fail)
388                                         goto out;
389                         }
390
391                         sg_init_table(sg, template[i].np);
392                         for (k = 0, temp = 0; k < template[i].np; k++) {
393                                 memcpy(&xbuf[IDX[k]],
394                                        template[i].input + temp,
395                                        template[i].tap[k]);
396                                 temp += template[i].tap[k];
397                                 sg_set_buf(&sg[k], &xbuf[IDX[k]],
398                                            template[i].tap[k]);
399                         }
400
401                         authsize = abs(template[i].rlen - template[i].ilen);
402                         ret = crypto_aead_setauthsize(tfm, authsize);
403                         if (ret) {
404                                 printk(KERN_INFO
405                                        "failed to set authsize = %u\n",
406                                        authsize);
407                                 goto out;
408                         }
409
410                         if (enc)
411                                 sg[k - 1].length += authsize;
412
413                         sg_init_table(asg, template[i].anp);
414                         for (k = 0, temp = 0; k < template[i].anp; k++) {
415                                 memcpy(&axbuf[IDX[k]],
416                                        template[i].assoc + temp,
417                                        template[i].atap[k]);
418                                 temp += template[i].atap[k];
419                                 sg_set_buf(&asg[k], &axbuf[IDX[k]],
420                                            template[i].atap[k]);
421                         }
422
423                         aead_request_set_crypt(req, sg, sg,
424                                                template[i].ilen,
425                                                iv);
426
427                         aead_request_set_assoc(req, asg, template[i].alen);
428
429                         ret = enc ?
430                                 crypto_aead_encrypt(req) :
431                                 crypto_aead_decrypt(req);
432
433                         switch (ret) {
434                         case 0:
435                                 break;
436                         case -EINPROGRESS:
437                         case -EBUSY:
438                                 ret = wait_for_completion_interruptible(
439                                         &result.completion);
440                                 if (!ret && !(ret = result.err)) {
441                                         INIT_COMPLETION(result.completion);
442                                         break;
443                                 }
444                                 /* fall through */
445                         default:
446                                 printk(KERN_INFO "%s () failed err=%d\n",
447                                        e, -ret);
448                                 goto out;
449                         }
450
451                         for (k = 0, temp = 0; k < template[i].np; k++) {
452                                 printk(KERN_INFO "page %u\n", k);
453                                 q = kmap(sg_page(&sg[k])) + sg[k].offset;
454                                 hexdump(q, template[i].tap[k]);
455                                 printk(KERN_INFO "%s\n",
456                                        memcmp(q, template[i].result + temp,
457                                               template[i].tap[k] -
458                                               (k < template[i].np - 1 || enc ?
459                                                0 : authsize)) ?
460                                        "fail" : "pass");
461
462                                 temp += template[i].tap[k];
463                                 kunmap(sg_page(&sg[k]));
464                         }
465                 }
466         }
467
468 out:
469         crypto_free_aead(tfm);
470         aead_request_free(req);
471 }
472
473 static void test_cipher(char *algo, int enc,
474                         struct cipher_testvec *template, unsigned int tcount)
475 {
476         unsigned int ret, i, j, k, temp;
477         char *q;
478         struct crypto_ablkcipher *tfm;
479         struct ablkcipher_request *req;
480         struct scatterlist sg[8];
481         const char *e;
482         struct tcrypt_result result;
483         void *data;
484         char iv[MAX_IVLEN];
485
486         if (enc == ENCRYPT)
487                 e = "encryption";
488         else
489                 e = "decryption";
490
491         printk("\ntesting %s %s\n", algo, e);
492
493         init_completion(&result.completion);
494         tfm = crypto_alloc_ablkcipher(algo, 0, 0);
495
496         if (IS_ERR(tfm)) {
497                 printk("failed to load transform for %s: %ld\n", algo,
498                        PTR_ERR(tfm));
499                 return;
500         }
501
502         req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
503         if (!req) {
504                 printk("failed to allocate request for %s\n", algo);
505                 goto out;
506         }
507
508         ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
509                                         tcrypt_complete, &result);
510
511         j = 0;
512         for (i = 0; i < tcount; i++) {
513
514                 data = kzalloc(template[i].ilen, GFP_KERNEL);
515                 if (!data)
516                         continue;
517
518                 memcpy(data, template[i].input, template[i].ilen);
519                 if (template[i].iv)
520                         memcpy(iv, template[i].iv, MAX_IVLEN);
521                 else
522                         memset(iv, 0, MAX_IVLEN);
523
524                 if (!(template[i].np)) {
525                         j++;
526                         printk("test %u (%d bit key):\n",
527                         j, template[i].klen * 8);
528
529                         crypto_ablkcipher_clear_flags(tfm, ~0);
530                         if (template[i].wk)
531                                 crypto_ablkcipher_set_flags(
532                                         tfm, CRYPTO_TFM_REQ_WEAK_KEY);
533
534                         ret = crypto_ablkcipher_setkey(tfm, template[i].key,
535                                                        template[i].klen);
536                         if (ret) {
537                                 printk("setkey() failed flags=%x\n",
538                                        crypto_ablkcipher_get_flags(tfm));
539
540                                 if (!template[i].fail) {
541                                         kfree(data);
542                                         goto out;
543                                 }
544                         }
545
546                         sg_init_one(&sg[0], data, template[i].ilen);
547
548                         ablkcipher_request_set_crypt(req, sg, sg,
549                                                      template[i].ilen, iv);
550                         ret = enc ?
551                                 crypto_ablkcipher_encrypt(req) :
552                                 crypto_ablkcipher_decrypt(req);
553
554                         switch (ret) {
555                         case 0:
556                                 break;
557                         case -EINPROGRESS:
558                         case -EBUSY:
559                                 ret = wait_for_completion_interruptible(
560                                         &result.completion);
561                                 if (!ret && !((ret = result.err))) {
562                                         INIT_COMPLETION(result.completion);
563                                         break;
564                                 }
565                                 /* fall through */
566                         default:
567                                 printk("%s () failed err=%d\n", e, -ret);
568                                 kfree(data);
569                                 goto out;
570                         }
571
572                         q = kmap(sg_page(&sg[0])) + sg[0].offset;
573                         hexdump(q, template[i].rlen);
574
575                         printk("%s\n",
576                                memcmp(q, template[i].result,
577                                       template[i].rlen) ? "fail" : "pass");
578                         kunmap(sg_page(&sg[0]));
579                 }
580                 kfree(data);
581         }
582
583         printk("\ntesting %s %s across pages (chunking)\n", algo, e);
584         memset(xbuf, 0, XBUFSIZE);
585
586         j = 0;
587         for (i = 0; i < tcount; i++) {
588
589                 if (template[i].iv)
590                         memcpy(iv, template[i].iv, MAX_IVLEN);
591                 else
592                         memset(iv, 0, MAX_IVLEN);
593
594                 if (template[i].np) {
595                         j++;
596                         printk("test %u (%d bit key):\n",
597                         j, template[i].klen * 8);
598
599                         crypto_ablkcipher_clear_flags(tfm, ~0);
600                         if (template[i].wk)
601                                 crypto_ablkcipher_set_flags(
602                                         tfm, CRYPTO_TFM_REQ_WEAK_KEY);
603
604                         ret = crypto_ablkcipher_setkey(tfm, template[i].key,
605                                                        template[i].klen);
606                         if (ret) {
607                                 printk("setkey() failed flags=%x\n",
608                                                 crypto_ablkcipher_get_flags(tfm));
609
610                                 if (!template[i].fail)
611                                         goto out;
612                         }
613
614                         temp = 0;
615                         sg_init_table(sg, template[i].np);
616                         for (k = 0; k < template[i].np; k++) {
617                                 memcpy(&xbuf[IDX[k]],
618                                                 template[i].input + temp,
619                                                 template[i].tap[k]);
620                                 temp += template[i].tap[k];
621                                 sg_set_buf(&sg[k], &xbuf[IDX[k]],
622                                                 template[i].tap[k]);
623                         }
624
625                         ablkcipher_request_set_crypt(req, sg, sg,
626                                         template[i].ilen, iv);
627
628                         ret = enc ?
629                                 crypto_ablkcipher_encrypt(req) :
630                                 crypto_ablkcipher_decrypt(req);
631
632                         switch (ret) {
633                         case 0:
634                                 break;
635                         case -EINPROGRESS:
636                         case -EBUSY:
637                                 ret = wait_for_completion_interruptible(
638                                         &result.completion);
639                                 if (!ret && !((ret = result.err))) {
640                                         INIT_COMPLETION(result.completion);
641                                         break;
642                                 }
643                                 /* fall through */
644                         default:
645                                 printk("%s () failed err=%d\n", e, -ret);
646                                 goto out;
647                         }
648
649                         temp = 0;
650                         for (k = 0; k < template[i].np; k++) {
651                                 printk("page %u\n", k);
652                                 q = kmap(sg_page(&sg[k])) + sg[k].offset;
653                                 hexdump(q, template[i].tap[k]);
654                                 printk("%s\n",
655                                         memcmp(q, template[i].result + temp,
656                                                 template[i].tap[k]) ? "fail" :
657                                         "pass");
658                                 temp += template[i].tap[k];
659                                 kunmap(sg_page(&sg[k]));
660                         }
661                 }
662         }
663 out:
664         crypto_free_ablkcipher(tfm);
665         ablkcipher_request_free(req);
666 }
667
668 static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc, char *p,
669                                int blen, int sec)
670 {
671         struct scatterlist sg[1];
672         unsigned long start, end;
673         int bcount;
674         int ret;
675
676         sg_init_one(sg, p, blen);
677
678         for (start = jiffies, end = start + sec * HZ, bcount = 0;
679              time_before(jiffies, end); bcount++) {
680                 if (enc)
681                         ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
682                 else
683                         ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
684
685                 if (ret)
686                         return ret;
687         }
688
689         printk("%d operations in %d seconds (%ld bytes)\n",
690                bcount, sec, (long)bcount * blen);
691         return 0;
692 }
693
694 static int test_cipher_cycles(struct blkcipher_desc *desc, int enc, char *p,
695                               int blen)
696 {
697         struct scatterlist sg[1];
698         unsigned long cycles = 0;
699         int ret = 0;
700         int i;
701
702         sg_init_one(sg, p, blen);
703
704         local_bh_disable();
705         local_irq_disable();
706
707         /* Warm-up run. */
708         for (i = 0; i < 4; i++) {
709                 if (enc)
710                         ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
711                 else
712                         ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
713
714                 if (ret)
715                         goto out;
716         }
717
718         /* The real thing. */
719         for (i = 0; i < 8; i++) {
720                 cycles_t start, end;
721
722                 start = get_cycles();
723                 if (enc)
724                         ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
725                 else
726                         ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
727                 end = get_cycles();
728
729                 if (ret)
730                         goto out;
731
732                 cycles += end - start;
733         }
734
735 out:
736         local_irq_enable();
737         local_bh_enable();
738
739         if (ret == 0)
740                 printk("1 operation in %lu cycles (%d bytes)\n",
741                        (cycles + 4) / 8, blen);
742
743         return ret;
744 }
745
746 static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 };
747
748 static void test_cipher_speed(char *algo, int enc, unsigned int sec,
749                               struct cipher_testvec *template,
750                               unsigned int tcount, u8 *keysize)
751 {
752         unsigned int ret, i, j, iv_len;
753         unsigned char *key, *p, iv[128];
754         struct crypto_blkcipher *tfm;
755         struct blkcipher_desc desc;
756         const char *e;
757         u32 *b_size;
758
759         if (enc == ENCRYPT)
760                 e = "encryption";
761         else
762                 e = "decryption";
763
764         printk("\ntesting speed of %s %s\n", algo, e);
765
766         tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);
767
768         if (IS_ERR(tfm)) {
769                 printk("failed to load transform for %s: %ld\n", algo,
770                        PTR_ERR(tfm));
771                 return;
772         }
773         desc.tfm = tfm;
774         desc.flags = 0;
775
776         i = 0;
777         do {
778
779                 b_size = block_sizes;
780                 do {
781
782                         if ((*keysize + *b_size) > TVMEMSIZE) {
783                                 printk("template (%u) too big for tvmem (%u)\n",
784                                                 *keysize + *b_size, TVMEMSIZE);
785                                 goto out;
786                         }
787
788                         printk("test %u (%d bit key, %d byte blocks): ", i,
789                                         *keysize * 8, *b_size);
790
791                         memset(tvmem, 0xff, *keysize + *b_size);
792
793                         /* set key, plain text and IV */
794                         key = (unsigned char *)tvmem;
795                         for (j = 0; j < tcount; j++) {
796                                 if (template[j].klen == *keysize) {
797                                         key = template[j].key;
798                                         break;
799                                 }
800                         }
801                         p = (unsigned char *)tvmem + *keysize;
802
803                         ret = crypto_blkcipher_setkey(tfm, key, *keysize);
804                         if (ret) {
805                                 printk("setkey() failed flags=%x\n",
806                                                 crypto_blkcipher_get_flags(tfm));
807                                 goto out;
808                         }
809
810                         iv_len = crypto_blkcipher_ivsize(tfm);
811                         if (iv_len) {
812                                 memset(&iv, 0xff, iv_len);
813                                 crypto_blkcipher_set_iv(tfm, iv, iv_len);
814                         }
815
816                         if (sec)
817                                 ret = test_cipher_jiffies(&desc, enc, p, *b_size, sec);
818                         else
819                                 ret = test_cipher_cycles(&desc, enc, p, *b_size);
820
821                         if (ret) {
822                                 printk("%s() failed flags=%x\n", e, desc.flags);
823                                 break;
824                         }
825                         b_size++;
826                         i++;
827                 } while (*b_size);
828                 keysize++;
829         } while (*keysize);
830
831 out:
832         crypto_free_blkcipher(tfm);
833 }
834
835 static int test_hash_jiffies_digest(struct hash_desc *desc, char *p, int blen,
836                                     char *out, int sec)
837 {
838         struct scatterlist sg[1];
839         unsigned long start, end;
840         int bcount;
841         int ret;
842
843         sg_init_table(sg, 1);
844
845         for (start = jiffies, end = start + sec * HZ, bcount = 0;
846              time_before(jiffies, end); bcount++) {
847                 sg_set_buf(sg, p, blen);
848                 ret = crypto_hash_digest(desc, sg, blen, out);
849                 if (ret)
850                         return ret;
851         }
852
853         printk("%6u opers/sec, %9lu bytes/sec\n",
854                bcount / sec, ((long)bcount * blen) / sec);
855
856         return 0;
857 }
858
859 static int test_hash_jiffies(struct hash_desc *desc, char *p, int blen,
860                              int plen, char *out, int sec)
861 {
862         struct scatterlist sg[1];
863         unsigned long start, end;
864         int bcount, pcount;
865         int ret;
866
867         if (plen == blen)
868                 return test_hash_jiffies_digest(desc, p, blen, out, sec);
869
870         sg_init_table(sg, 1);
871
872         for (start = jiffies, end = start + sec * HZ, bcount = 0;
873              time_before(jiffies, end); bcount++) {
874                 ret = crypto_hash_init(desc);
875                 if (ret)
876                         return ret;
877                 for (pcount = 0; pcount < blen; pcount += plen) {
878                         sg_set_buf(sg, p + pcount, plen);
879                         ret = crypto_hash_update(desc, sg, plen);
880                         if (ret)
881                                 return ret;
882                 }
883                 /* we assume there is enough space in 'out' for the result */
884                 ret = crypto_hash_final(desc, out);
885                 if (ret)
886                         return ret;
887         }
888
889         printk("%6u opers/sec, %9lu bytes/sec\n",
890                bcount / sec, ((long)bcount * blen) / sec);
891
892         return 0;
893 }
894
895 static int test_hash_cycles_digest(struct hash_desc *desc, char *p, int blen,
896                                    char *out)
897 {
898         struct scatterlist sg[1];
899         unsigned long cycles = 0;
900         int i;
901         int ret;
902
903         sg_init_table(sg, 1);
904
905         local_bh_disable();
906         local_irq_disable();
907
908         /* Warm-up run. */
909         for (i = 0; i < 4; i++) {
910                 sg_set_buf(sg, p, blen);
911                 ret = crypto_hash_digest(desc, sg, blen, out);
912                 if (ret)
913                         goto out;
914         }
915
916         /* The real thing. */
917         for (i = 0; i < 8; i++) {
918                 cycles_t start, end;
919
920                 start = get_cycles();
921
922                 sg_set_buf(sg, p, blen);
923                 ret = crypto_hash_digest(desc, sg, blen, out);
924                 if (ret)
925                         goto out;
926
927                 end = get_cycles();
928
929                 cycles += end - start;
930         }
931
932 out:
933         local_irq_enable();
934         local_bh_enable();
935
936         if (ret)
937                 return ret;
938
939         printk("%6lu cycles/operation, %4lu cycles/byte\n",
940                cycles / 8, cycles / (8 * blen));
941
942         return 0;
943 }
944
945 static int test_hash_cycles(struct hash_desc *desc, char *p, int blen,
946                             int plen, char *out)
947 {
948         struct scatterlist sg[1];
949         unsigned long cycles = 0;
950         int i, pcount;
951         int ret;
952
953         if (plen == blen)
954                 return test_hash_cycles_digest(desc, p, blen, out);
955
956         sg_init_table(sg, 1);
957
958         local_bh_disable();
959         local_irq_disable();
960
961         /* Warm-up run. */
962         for (i = 0; i < 4; i++) {
963                 ret = crypto_hash_init(desc);
964                 if (ret)
965                         goto out;
966                 for (pcount = 0; pcount < blen; pcount += plen) {
967                         sg_set_buf(sg, p + pcount, plen);
968                         ret = crypto_hash_update(desc, sg, plen);
969                         if (ret)
970                                 goto out;
971                 }
972                 ret = crypto_hash_final(desc, out);
973                 if (ret)
974                         goto out;
975         }
976
977         /* The real thing. */
978         for (i = 0; i < 8; i++) {
979                 cycles_t start, end;
980
981                 start = get_cycles();
982
983                 ret = crypto_hash_init(desc);
984                 if (ret)
985                         goto out;
986                 for (pcount = 0; pcount < blen; pcount += plen) {
987                         sg_set_buf(sg, p + pcount, plen);
988                         ret = crypto_hash_update(desc, sg, plen);
989                         if (ret)
990                                 goto out;
991                 }
992                 ret = crypto_hash_final(desc, out);
993                 if (ret)
994                         goto out;
995
996                 end = get_cycles();
997
998                 cycles += end - start;
999         }
1000
1001 out:
1002         local_irq_enable();
1003         local_bh_enable();
1004
1005         if (ret)
1006                 return ret;
1007
1008         printk("%6lu cycles/operation, %4lu cycles/byte\n",
1009                cycles / 8, cycles / (8 * blen));
1010
1011         return 0;
1012 }
1013
1014 static void test_hash_speed(char *algo, unsigned int sec,
1015                               struct hash_speed *speed)
1016 {
1017         struct crypto_hash *tfm;
1018         struct hash_desc desc;
1019         char output[1024];
1020         int i;
1021         int ret;
1022
1023         printk("\ntesting speed of %s\n", algo);
1024
1025         tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
1026
1027         if (IS_ERR(tfm)) {
1028                 printk("failed to load transform for %s: %ld\n", algo,
1029                        PTR_ERR(tfm));
1030                 return;
1031         }
1032
1033         desc.tfm = tfm;
1034         desc.flags = 0;
1035
1036         if (crypto_hash_digestsize(tfm) > sizeof(output)) {
1037                 printk("digestsize(%u) > outputbuffer(%zu)\n",
1038                        crypto_hash_digestsize(tfm), sizeof(output));
1039                 goto out;
1040         }
1041
1042         for (i = 0; speed[i].blen != 0; i++) {
1043                 if (speed[i].blen > TVMEMSIZE) {
1044                         printk("template (%u) too big for tvmem (%u)\n",
1045                                speed[i].blen, TVMEMSIZE);
1046                         goto out;
1047                 }
1048
1049                 printk("test%3u (%5u byte blocks,%5u bytes per update,%4u updates): ",
1050                        i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
1051
1052                 memset(tvmem, 0xff, speed[i].blen);
1053
1054                 if (sec)
1055                         ret = test_hash_jiffies(&desc, tvmem, speed[i].blen,
1056                                                 speed[i].plen, output, sec);
1057                 else
1058                         ret = test_hash_cycles(&desc, tvmem, speed[i].blen,
1059                                                speed[i].plen, output);
1060
1061                 if (ret) {
1062                         printk("hashing failed ret=%d\n", ret);
1063                         break;
1064                 }
1065         }
1066
1067 out:
1068         crypto_free_hash(tfm);
1069 }
1070
1071 static void test_comp(char *algo, struct comp_testvec *ctemplate,
1072                        struct comp_testvec *dtemplate, int ctcount, int dtcount)
1073 {
1074         unsigned int i;
1075         char result[COMP_BUF_SIZE];
1076         struct crypto_comp *tfm;
1077         unsigned int tsize;
1078
1079         printk("\ntesting %s compression\n", algo);
1080
1081         tfm = crypto_alloc_comp(algo, 0, CRYPTO_ALG_ASYNC);
1082         if (IS_ERR(tfm)) {
1083                 printk("failed to load transform for %s\n", algo);
1084                 return;
1085         }
1086
1087         for (i = 0; i < ctcount; i++) {
1088                 int ilen, ret, dlen = COMP_BUF_SIZE;
1089
1090                 printk("test %u:\n", i + 1);
1091                 memset(result, 0, sizeof (result));
1092
1093                 ilen = ctemplate[i].inlen;
1094                 ret = crypto_comp_compress(tfm, ctemplate[i].input,
1095                                            ilen, result, &dlen);
1096                 if (ret) {
1097                         printk("fail: ret=%d\n", ret);
1098                         continue;
1099                 }
1100                 hexdump(result, dlen);
1101                 printk("%s (ratio %d:%d)\n",
1102                        memcmp(result, ctemplate[i].output, dlen) ? "fail" : "pass",
1103                        ilen, dlen);
1104         }
1105
1106         printk("\ntesting %s decompression\n", algo);
1107
1108         tsize = sizeof(struct comp_testvec);
1109         tsize *= dtcount;
1110         if (tsize > TVMEMSIZE) {
1111                 printk("template (%u) too big for tvmem (%u)\n", tsize,
1112                        TVMEMSIZE);
1113                 goto out;
1114         }
1115
1116         for (i = 0; i < dtcount; i++) {
1117                 int ilen, ret, dlen = COMP_BUF_SIZE;
1118
1119                 printk("test %u:\n", i + 1);
1120                 memset(result, 0, sizeof (result));
1121
1122                 ilen = dtemplate[i].inlen;
1123                 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
1124                                              ilen, result, &dlen);
1125                 if (ret) {
1126                         printk("fail: ret=%d\n", ret);
1127                         continue;
1128                 }
1129                 hexdump(result, dlen);
1130                 printk("%s (ratio %d:%d)\n",
1131                        memcmp(result, dtemplate[i].output, dlen) ? "fail" : "pass",
1132                        ilen, dlen);
1133         }
1134 out:
1135         crypto_free_comp(tfm);
1136 }
1137
1138 static void test_available(void)
1139 {
1140         char **name = check;
1141
1142         while (*name) {
1143                 printk("alg %s ", *name);
1144                 printk(crypto_has_alg(*name, 0, 0) ?
1145                        "found\n" : "not found\n");
1146                 name++;
1147         }
1148 }
1149
1150 static void do_test(void)
1151 {
1152         switch (mode) {
1153
1154         case 0:
1155                 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
1156
1157                 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
1158
1159                 //DES
1160                 test_cipher("ecb(des)", ENCRYPT, des_enc_tv_template,
1161                             DES_ENC_TEST_VECTORS);
1162                 test_cipher("ecb(des)", DECRYPT, des_dec_tv_template,
1163                             DES_DEC_TEST_VECTORS);
1164                 test_cipher("cbc(des)", ENCRYPT, des_cbc_enc_tv_template,
1165                             DES_CBC_ENC_TEST_VECTORS);
1166                 test_cipher("cbc(des)", DECRYPT, des_cbc_dec_tv_template,
1167                             DES_CBC_DEC_TEST_VECTORS);
1168
1169                 //DES3_EDE
1170                 test_cipher("ecb(des3_ede)", ENCRYPT, des3_ede_enc_tv_template,
1171                             DES3_EDE_ENC_TEST_VECTORS);
1172                 test_cipher("ecb(des3_ede)", DECRYPT, des3_ede_dec_tv_template,
1173                             DES3_EDE_DEC_TEST_VECTORS);
1174
1175                 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
1176
1177                 test_hash("sha224", sha224_tv_template, SHA224_TEST_VECTORS);
1178
1179                 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
1180
1181                 //BLOWFISH
1182                 test_cipher("ecb(blowfish)", ENCRYPT, bf_enc_tv_template,
1183                             BF_ENC_TEST_VECTORS);
1184                 test_cipher("ecb(blowfish)", DECRYPT, bf_dec_tv_template,
1185                             BF_DEC_TEST_VECTORS);
1186                 test_cipher("cbc(blowfish)", ENCRYPT, bf_cbc_enc_tv_template,
1187                             BF_CBC_ENC_TEST_VECTORS);
1188                 test_cipher("cbc(blowfish)", DECRYPT, bf_cbc_dec_tv_template,
1189                             BF_CBC_DEC_TEST_VECTORS);
1190
1191                 //TWOFISH
1192                 test_cipher("ecb(twofish)", ENCRYPT, tf_enc_tv_template,
1193                             TF_ENC_TEST_VECTORS);
1194                 test_cipher("ecb(twofish)", DECRYPT, tf_dec_tv_template,
1195                             TF_DEC_TEST_VECTORS);
1196                 test_cipher("cbc(twofish)", ENCRYPT, tf_cbc_enc_tv_template,
1197                             TF_CBC_ENC_TEST_VECTORS);
1198                 test_cipher("cbc(twofish)", DECRYPT, tf_cbc_dec_tv_template,
1199                             TF_CBC_DEC_TEST_VECTORS);
1200
1201                 //SERPENT
1202                 test_cipher("ecb(serpent)", ENCRYPT, serpent_enc_tv_template,
1203                             SERPENT_ENC_TEST_VECTORS);
1204                 test_cipher("ecb(serpent)", DECRYPT, serpent_dec_tv_template,
1205                             SERPENT_DEC_TEST_VECTORS);
1206
1207                 //TNEPRES
1208                 test_cipher("ecb(tnepres)", ENCRYPT, tnepres_enc_tv_template,
1209                             TNEPRES_ENC_TEST_VECTORS);
1210                 test_cipher("ecb(tnepres)", DECRYPT, tnepres_dec_tv_template,
1211                             TNEPRES_DEC_TEST_VECTORS);
1212
1213                 //AES
1214                 test_cipher("ecb(aes)", ENCRYPT, aes_enc_tv_template,
1215                             AES_ENC_TEST_VECTORS);
1216                 test_cipher("ecb(aes)", DECRYPT, aes_dec_tv_template,
1217                             AES_DEC_TEST_VECTORS);
1218                 test_cipher("cbc(aes)", ENCRYPT, aes_cbc_enc_tv_template,
1219                             AES_CBC_ENC_TEST_VECTORS);
1220                 test_cipher("cbc(aes)", DECRYPT, aes_cbc_dec_tv_template,
1221                             AES_CBC_DEC_TEST_VECTORS);
1222                 test_cipher("lrw(aes)", ENCRYPT, aes_lrw_enc_tv_template,
1223                             AES_LRW_ENC_TEST_VECTORS);
1224                 test_cipher("lrw(aes)", DECRYPT, aes_lrw_dec_tv_template,
1225                             AES_LRW_DEC_TEST_VECTORS);
1226                 test_cipher("xts(aes)", ENCRYPT, aes_xts_enc_tv_template,
1227                             AES_XTS_ENC_TEST_VECTORS);
1228                 test_cipher("xts(aes)", DECRYPT, aes_xts_dec_tv_template,
1229                             AES_XTS_DEC_TEST_VECTORS);
1230                 test_cipher("rfc3686(ctr(aes))", ENCRYPT, aes_ctr_enc_tv_template,
1231                             AES_CTR_ENC_TEST_VECTORS);
1232                 test_cipher("rfc3686(ctr(aes))", DECRYPT, aes_ctr_dec_tv_template,
1233                             AES_CTR_DEC_TEST_VECTORS);
1234                 test_aead("gcm(aes)", ENCRYPT, aes_gcm_enc_tv_template,
1235                           AES_GCM_ENC_TEST_VECTORS);
1236                 test_aead("gcm(aes)", DECRYPT, aes_gcm_dec_tv_template,
1237                           AES_GCM_DEC_TEST_VECTORS);
1238                 test_aead("ccm(aes)", ENCRYPT, aes_ccm_enc_tv_template,
1239                           AES_CCM_ENC_TEST_VECTORS);
1240                 test_aead("ccm(aes)", DECRYPT, aes_ccm_dec_tv_template,
1241                           AES_CCM_DEC_TEST_VECTORS);
1242
1243                 //CAST5
1244                 test_cipher("ecb(cast5)", ENCRYPT, cast5_enc_tv_template,
1245                             CAST5_ENC_TEST_VECTORS);
1246                 test_cipher("ecb(cast5)", DECRYPT, cast5_dec_tv_template,
1247                             CAST5_DEC_TEST_VECTORS);
1248
1249                 //CAST6
1250                 test_cipher("ecb(cast6)", ENCRYPT, cast6_enc_tv_template,
1251                             CAST6_ENC_TEST_VECTORS);
1252                 test_cipher("ecb(cast6)", DECRYPT, cast6_dec_tv_template,
1253                             CAST6_DEC_TEST_VECTORS);
1254
1255                 //ARC4
1256                 test_cipher("ecb(arc4)", ENCRYPT, arc4_enc_tv_template,
1257                             ARC4_ENC_TEST_VECTORS);
1258                 test_cipher("ecb(arc4)", DECRYPT, arc4_dec_tv_template,
1259                             ARC4_DEC_TEST_VECTORS);
1260
1261                 //TEA
1262                 test_cipher("ecb(tea)", ENCRYPT, tea_enc_tv_template,
1263                             TEA_ENC_TEST_VECTORS);
1264                 test_cipher("ecb(tea)", DECRYPT, tea_dec_tv_template,
1265                             TEA_DEC_TEST_VECTORS);
1266
1267
1268                 //XTEA
1269                 test_cipher("ecb(xtea)", ENCRYPT, xtea_enc_tv_template,
1270                             XTEA_ENC_TEST_VECTORS);
1271                 test_cipher("ecb(xtea)", DECRYPT, xtea_dec_tv_template,
1272                             XTEA_DEC_TEST_VECTORS);
1273
1274                 //KHAZAD
1275                 test_cipher("ecb(khazad)", ENCRYPT, khazad_enc_tv_template,
1276                             KHAZAD_ENC_TEST_VECTORS);
1277                 test_cipher("ecb(khazad)", DECRYPT, khazad_dec_tv_template,
1278                             KHAZAD_DEC_TEST_VECTORS);
1279
1280                 //ANUBIS
1281                 test_cipher("ecb(anubis)", ENCRYPT, anubis_enc_tv_template,
1282                             ANUBIS_ENC_TEST_VECTORS);
1283                 test_cipher("ecb(anubis)", DECRYPT, anubis_dec_tv_template,
1284                             ANUBIS_DEC_TEST_VECTORS);
1285                 test_cipher("cbc(anubis)", ENCRYPT, anubis_cbc_enc_tv_template,
1286                             ANUBIS_CBC_ENC_TEST_VECTORS);
1287                 test_cipher("cbc(anubis)", DECRYPT, anubis_cbc_dec_tv_template,
1288                             ANUBIS_CBC_ENC_TEST_VECTORS);
1289
1290                 //XETA
1291                 test_cipher("ecb(xeta)", ENCRYPT, xeta_enc_tv_template,
1292                             XETA_ENC_TEST_VECTORS);
1293                 test_cipher("ecb(xeta)", DECRYPT, xeta_dec_tv_template,
1294                             XETA_DEC_TEST_VECTORS);
1295
1296                 //FCrypt
1297                 test_cipher("pcbc(fcrypt)", ENCRYPT, fcrypt_pcbc_enc_tv_template,
1298                             FCRYPT_ENC_TEST_VECTORS);
1299                 test_cipher("pcbc(fcrypt)", DECRYPT, fcrypt_pcbc_dec_tv_template,
1300                             FCRYPT_DEC_TEST_VECTORS);
1301
1302                 //CAMELLIA
1303                 test_cipher("ecb(camellia)", ENCRYPT,
1304                             camellia_enc_tv_template,
1305                             CAMELLIA_ENC_TEST_VECTORS);
1306                 test_cipher("ecb(camellia)", DECRYPT,
1307                             camellia_dec_tv_template,
1308                             CAMELLIA_DEC_TEST_VECTORS);
1309                 test_cipher("cbc(camellia)", ENCRYPT,
1310                             camellia_cbc_enc_tv_template,
1311                             CAMELLIA_CBC_ENC_TEST_VECTORS);
1312                 test_cipher("cbc(camellia)", DECRYPT,
1313                             camellia_cbc_dec_tv_template,
1314                             CAMELLIA_CBC_DEC_TEST_VECTORS);
1315
1316                 //SEED
1317                 test_cipher("ecb(seed)", ENCRYPT, seed_enc_tv_template,
1318                             SEED_ENC_TEST_VECTORS);
1319                 test_cipher("ecb(seed)", DECRYPT, seed_dec_tv_template,
1320                             SEED_DEC_TEST_VECTORS);
1321
1322                 //CTS
1323                 test_cipher("cts(cbc(aes))", ENCRYPT, cts_mode_enc_tv_template,
1324                             CTS_MODE_ENC_TEST_VECTORS);
1325                 test_cipher("cts(cbc(aes))", DECRYPT, cts_mode_dec_tv_template,
1326                             CTS_MODE_DEC_TEST_VECTORS);
1327
1328                 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
1329                 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
1330                 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
1331                 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
1332                 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
1333                 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
1334                 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
1335                 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
1336                 test_comp("deflate", deflate_comp_tv_template,
1337                           deflate_decomp_tv_template, DEFLATE_COMP_TEST_VECTORS,
1338                           DEFLATE_DECOMP_TEST_VECTORS);
1339                 test_comp("lzo", lzo_comp_tv_template, lzo_decomp_tv_template,
1340                           LZO_COMP_TEST_VECTORS, LZO_DECOMP_TEST_VECTORS);
1341                 test_hash("crc32c", crc32c_tv_template, CRC32C_TEST_VECTORS);
1342                 test_hash("hmac(md5)", hmac_md5_tv_template,
1343                           HMAC_MD5_TEST_VECTORS);
1344                 test_hash("hmac(sha1)", hmac_sha1_tv_template,
1345                           HMAC_SHA1_TEST_VECTORS);
1346                 test_hash("hmac(sha224)", hmac_sha224_tv_template,
1347                           HMAC_SHA224_TEST_VECTORS);
1348                 test_hash("hmac(sha256)", hmac_sha256_tv_template,
1349                           HMAC_SHA256_TEST_VECTORS);
1350                 test_hash("hmac(sha384)", hmac_sha384_tv_template,
1351                           HMAC_SHA384_TEST_VECTORS);
1352                 test_hash("hmac(sha512)", hmac_sha512_tv_template,
1353                           HMAC_SHA512_TEST_VECTORS);
1354
1355                 test_hash("xcbc(aes)", aes_xcbc128_tv_template,
1356                           XCBC_AES_TEST_VECTORS);
1357
1358                 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
1359                 break;
1360
1361         case 1:
1362                 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
1363                 break;
1364
1365         case 2:
1366                 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
1367                 break;
1368
1369         case 3:
1370                 test_cipher("ecb(des)", ENCRYPT, des_enc_tv_template,
1371                             DES_ENC_TEST_VECTORS);
1372                 test_cipher("ecb(des)", DECRYPT, des_dec_tv_template,
1373                             DES_DEC_TEST_VECTORS);
1374                 test_cipher("cbc(des)", ENCRYPT, des_cbc_enc_tv_template,
1375                             DES_CBC_ENC_TEST_VECTORS);
1376                 test_cipher("cbc(des)", DECRYPT, des_cbc_dec_tv_template,
1377                             DES_CBC_DEC_TEST_VECTORS);
1378                 break;
1379
1380         case 4:
1381                 test_cipher("ecb(des3_ede)", ENCRYPT, des3_ede_enc_tv_template,
1382                             DES3_EDE_ENC_TEST_VECTORS);
1383                 test_cipher("ecb(des3_ede)", DECRYPT, des3_ede_dec_tv_template,
1384                             DES3_EDE_DEC_TEST_VECTORS);
1385                 break;
1386
1387         case 5:
1388                 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
1389                 break;
1390
1391         case 6:
1392                 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
1393                 break;
1394
1395         case 7:
1396                 test_cipher("ecb(blowfish)", ENCRYPT, bf_enc_tv_template,
1397                             BF_ENC_TEST_VECTORS);
1398                 test_cipher("ecb(blowfish)", DECRYPT, bf_dec_tv_template,
1399                             BF_DEC_TEST_VECTORS);
1400                 test_cipher("cbc(blowfish)", ENCRYPT, bf_cbc_enc_tv_template,
1401                             BF_CBC_ENC_TEST_VECTORS);
1402                 test_cipher("cbc(blowfish)", DECRYPT, bf_cbc_dec_tv_template,
1403                             BF_CBC_DEC_TEST_VECTORS);
1404                 break;
1405
1406         case 8:
1407                 test_cipher("ecb(twofish)", ENCRYPT, tf_enc_tv_template,
1408                             TF_ENC_TEST_VECTORS);
1409                 test_cipher("ecb(twofish)", DECRYPT, tf_dec_tv_template,
1410                             TF_DEC_TEST_VECTORS);
1411                 test_cipher("cbc(twofish)", ENCRYPT, tf_cbc_enc_tv_template,
1412                             TF_CBC_ENC_TEST_VECTORS);
1413                 test_cipher("cbc(twofish)", DECRYPT, tf_cbc_dec_tv_template,
1414                             TF_CBC_DEC_TEST_VECTORS);
1415                 break;
1416
1417         case 9:
1418                 test_cipher("ecb(serpent)", ENCRYPT, serpent_enc_tv_template,
1419                             SERPENT_ENC_TEST_VECTORS);
1420                 test_cipher("ecb(serpent)", DECRYPT, serpent_dec_tv_template,
1421                             SERPENT_DEC_TEST_VECTORS);
1422                 break;
1423
1424         case 10:
1425                 test_cipher("ecb(aes)", ENCRYPT, aes_enc_tv_template,
1426                             AES_ENC_TEST_VECTORS);
1427                 test_cipher("ecb(aes)", DECRYPT, aes_dec_tv_template,
1428                             AES_DEC_TEST_VECTORS);
1429                 test_cipher("cbc(aes)", ENCRYPT, aes_cbc_enc_tv_template,
1430                             AES_CBC_ENC_TEST_VECTORS);
1431                 test_cipher("cbc(aes)", DECRYPT, aes_cbc_dec_tv_template,
1432                             AES_CBC_DEC_TEST_VECTORS);
1433                 test_cipher("lrw(aes)", ENCRYPT, aes_lrw_enc_tv_template,
1434                             AES_LRW_ENC_TEST_VECTORS);
1435                 test_cipher("lrw(aes)", DECRYPT, aes_lrw_dec_tv_template,
1436                             AES_LRW_DEC_TEST_VECTORS);
1437                 test_cipher("xts(aes)", ENCRYPT, aes_xts_enc_tv_template,
1438                             AES_XTS_ENC_TEST_VECTORS);
1439                 test_cipher("xts(aes)", DECRYPT, aes_xts_dec_tv_template,
1440                             AES_XTS_DEC_TEST_VECTORS);
1441                 test_cipher("rfc3686(ctr(aes))", ENCRYPT, aes_ctr_enc_tv_template,
1442                             AES_CTR_ENC_TEST_VECTORS);
1443                 test_cipher("rfc3686(ctr(aes))", DECRYPT, aes_ctr_dec_tv_template,
1444                             AES_CTR_DEC_TEST_VECTORS);
1445                 break;
1446
1447         case 11:
1448                 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
1449                 break;
1450
1451         case 12:
1452                 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
1453                 break;
1454
1455         case 13:
1456                 test_comp("deflate", deflate_comp_tv_template,
1457                           deflate_decomp_tv_template, DEFLATE_COMP_TEST_VECTORS,
1458                           DEFLATE_DECOMP_TEST_VECTORS);
1459                 break;
1460
1461         case 14:
1462                 test_cipher("ecb(cast5)", ENCRYPT, cast5_enc_tv_template,
1463                             CAST5_ENC_TEST_VECTORS);
1464                 test_cipher("ecb(cast5)", DECRYPT, cast5_dec_tv_template,
1465                             CAST5_DEC_TEST_VECTORS);
1466                 break;
1467
1468         case 15:
1469                 test_cipher("ecb(cast6)", ENCRYPT, cast6_enc_tv_template,
1470                             CAST6_ENC_TEST_VECTORS);
1471                 test_cipher("ecb(cast6)", DECRYPT, cast6_dec_tv_template,
1472                             CAST6_DEC_TEST_VECTORS);
1473                 break;
1474
1475         case 16:
1476                 test_cipher("ecb(arc4)", ENCRYPT, arc4_enc_tv_template,
1477                             ARC4_ENC_TEST_VECTORS);
1478                 test_cipher("ecb(arc4)", DECRYPT, arc4_dec_tv_template,
1479                             ARC4_DEC_TEST_VECTORS);
1480                 break;
1481
1482         case 17:
1483                 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
1484                 break;
1485
1486         case 18:
1487                 test_hash("crc32c", crc32c_tv_template, CRC32C_TEST_VECTORS);
1488                 break;
1489
1490         case 19:
1491                 test_cipher("ecb(tea)", ENCRYPT, tea_enc_tv_template,
1492                             TEA_ENC_TEST_VECTORS);
1493                 test_cipher("ecb(tea)", DECRYPT, tea_dec_tv_template,
1494                             TEA_DEC_TEST_VECTORS);
1495                 break;
1496
1497         case 20:
1498                 test_cipher("ecb(xtea)", ENCRYPT, xtea_enc_tv_template,
1499                             XTEA_ENC_TEST_VECTORS);
1500                 test_cipher("ecb(xtea)", DECRYPT, xtea_dec_tv_template,
1501                             XTEA_DEC_TEST_VECTORS);
1502                 break;
1503
1504         case 21:
1505                 test_cipher("ecb(khazad)", ENCRYPT, khazad_enc_tv_template,
1506                             KHAZAD_ENC_TEST_VECTORS);
1507                 test_cipher("ecb(khazad)", DECRYPT, khazad_dec_tv_template,
1508                             KHAZAD_DEC_TEST_VECTORS);
1509                 break;
1510
1511         case 22:
1512                 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
1513                 break;
1514
1515         case 23:
1516                 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
1517                 break;
1518
1519         case 24:
1520                 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
1521                 break;
1522
1523         case 25:
1524                 test_cipher("ecb(tnepres)", ENCRYPT, tnepres_enc_tv_template,
1525                             TNEPRES_ENC_TEST_VECTORS);
1526                 test_cipher("ecb(tnepres)", DECRYPT, tnepres_dec_tv_template,
1527                             TNEPRES_DEC_TEST_VECTORS);
1528                 break;
1529
1530         case 26:
1531                 test_cipher("ecb(anubis)", ENCRYPT, anubis_enc_tv_template,
1532                             ANUBIS_ENC_TEST_VECTORS);
1533                 test_cipher("ecb(anubis)", DECRYPT, anubis_dec_tv_template,
1534                             ANUBIS_DEC_TEST_VECTORS);
1535                 test_cipher("cbc(anubis)", ENCRYPT, anubis_cbc_enc_tv_template,
1536                             ANUBIS_CBC_ENC_TEST_VECTORS);
1537                 test_cipher("cbc(anubis)", DECRYPT, anubis_cbc_dec_tv_template,
1538                             ANUBIS_CBC_ENC_TEST_VECTORS);
1539                 break;
1540
1541         case 27:
1542                 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
1543                 break;
1544
1545         case 28:
1546
1547                 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
1548                 break;
1549
1550         case 29:
1551                 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
1552                 break;
1553                 
1554         case 30:
1555                 test_cipher("ecb(xeta)", ENCRYPT, xeta_enc_tv_template,
1556                             XETA_ENC_TEST_VECTORS);
1557                 test_cipher("ecb(xeta)", DECRYPT, xeta_dec_tv_template,
1558                             XETA_DEC_TEST_VECTORS);
1559                 break;
1560
1561         case 31:
1562                 test_cipher("pcbc(fcrypt)", ENCRYPT, fcrypt_pcbc_enc_tv_template,
1563                             FCRYPT_ENC_TEST_VECTORS);
1564                 test_cipher("pcbc(fcrypt)", DECRYPT, fcrypt_pcbc_dec_tv_template,
1565                             FCRYPT_DEC_TEST_VECTORS);
1566                 break;
1567
1568         case 32:
1569                 test_cipher("ecb(camellia)", ENCRYPT,
1570                             camellia_enc_tv_template,
1571                             CAMELLIA_ENC_TEST_VECTORS);
1572                 test_cipher("ecb(camellia)", DECRYPT,
1573                             camellia_dec_tv_template,
1574                             CAMELLIA_DEC_TEST_VECTORS);
1575                 test_cipher("cbc(camellia)", ENCRYPT,
1576                             camellia_cbc_enc_tv_template,
1577                             CAMELLIA_CBC_ENC_TEST_VECTORS);
1578                 test_cipher("cbc(camellia)", DECRYPT,
1579                             camellia_cbc_dec_tv_template,
1580                             CAMELLIA_CBC_DEC_TEST_VECTORS);
1581                 break;
1582         case 33:
1583                 test_hash("sha224", sha224_tv_template, SHA224_TEST_VECTORS);
1584                 break;
1585
1586         case 34:
1587                 test_cipher("salsa20", ENCRYPT,
1588                             salsa20_stream_enc_tv_template,
1589                             SALSA20_STREAM_ENC_TEST_VECTORS);
1590                 break;
1591
1592         case 35:
1593                 test_aead("gcm(aes)", ENCRYPT, aes_gcm_enc_tv_template,
1594                           AES_GCM_ENC_TEST_VECTORS);
1595                 test_aead("gcm(aes)", DECRYPT, aes_gcm_dec_tv_template,
1596                           AES_GCM_DEC_TEST_VECTORS);
1597                 break;
1598
1599         case 36:
1600                 test_comp("lzo", lzo_comp_tv_template, lzo_decomp_tv_template,
1601                           LZO_COMP_TEST_VECTORS, LZO_DECOMP_TEST_VECTORS);
1602                 break;
1603
1604         case 37:
1605                 test_aead("ccm(aes)", ENCRYPT, aes_ccm_enc_tv_template,
1606                           AES_CCM_ENC_TEST_VECTORS);
1607                 test_aead("ccm(aes)", DECRYPT, aes_ccm_dec_tv_template,
1608                           AES_CCM_DEC_TEST_VECTORS);
1609                 break;
1610
1611         case 38:
1612                 test_cipher("cts(cbc(aes))", ENCRYPT, cts_mode_enc_tv_template,
1613                             CTS_MODE_ENC_TEST_VECTORS);
1614                 test_cipher("cts(cbc(aes))", DECRYPT, cts_mode_dec_tv_template,
1615                             CTS_MODE_DEC_TEST_VECTORS);
1616                 break;
1617
1618         case 100:
1619                 test_hash("hmac(md5)", hmac_md5_tv_template,
1620                           HMAC_MD5_TEST_VECTORS);
1621                 break;
1622
1623         case 101:
1624                 test_hash("hmac(sha1)", hmac_sha1_tv_template,
1625                           HMAC_SHA1_TEST_VECTORS);
1626                 break;
1627
1628         case 102:
1629                 test_hash("hmac(sha256)", hmac_sha256_tv_template,
1630                           HMAC_SHA256_TEST_VECTORS);
1631                 break;
1632
1633         case 103:
1634                 test_hash("hmac(sha384)", hmac_sha384_tv_template,
1635                           HMAC_SHA384_TEST_VECTORS);
1636                 break;
1637
1638         case 104:
1639                 test_hash("hmac(sha512)", hmac_sha512_tv_template,
1640                           HMAC_SHA512_TEST_VECTORS);
1641                 break;
1642
1643         case 105:
1644                 test_hash("hmac(sha224)", hmac_sha224_tv_template,
1645                           HMAC_SHA224_TEST_VECTORS);
1646                 break;
1647
1648         case 106:
1649                 test_hash("xcbc(aes)", aes_xcbc128_tv_template,
1650                           XCBC_AES_TEST_VECTORS);
1651                 break;
1652
1653         case 200:
1654                 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
1655                                 speed_template_16_24_32);
1656                 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
1657                                 speed_template_16_24_32);
1658                 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
1659                                 speed_template_16_24_32);
1660                 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
1661                                 speed_template_16_24_32);
1662                 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
1663                                 speed_template_32_40_48);
1664                 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
1665                                 speed_template_32_40_48);
1666                 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
1667                                 speed_template_32_48_64);
1668                 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
1669                                 speed_template_32_48_64);
1670                 break;
1671
1672         case 201:
1673                 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
1674                                 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1675                                 speed_template_24);
1676                 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
1677                                 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1678                                 speed_template_24);
1679                 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
1680                                 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1681                                 speed_template_24);
1682                 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
1683                                 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1684                                 speed_template_24);
1685                 break;
1686
1687         case 202:
1688                 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
1689                                 speed_template_16_24_32);
1690                 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
1691                                 speed_template_16_24_32);
1692                 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
1693                                 speed_template_16_24_32);
1694                 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
1695                                 speed_template_16_24_32);
1696                 break;
1697
1698         case 203:
1699                 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
1700                                   speed_template_8_32);
1701                 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
1702                                   speed_template_8_32);
1703                 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
1704                                   speed_template_8_32);
1705                 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
1706                                   speed_template_8_32);
1707                 break;
1708
1709         case 204:
1710                 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
1711                                   speed_template_8);
1712                 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
1713                                   speed_template_8);
1714                 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
1715                                   speed_template_8);
1716                 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
1717                                   speed_template_8);
1718                 break;
1719
1720         case 205:
1721                 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
1722                                 speed_template_16_24_32);
1723                 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
1724                                 speed_template_16_24_32);
1725                 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
1726                                 speed_template_16_24_32);
1727                 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
1728                                 speed_template_16_24_32);
1729                 break;
1730
1731         case 206:
1732                 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
1733                                   speed_template_16_32);
1734                 break;
1735
1736         case 300:
1737                 /* fall through */
1738
1739         case 301:
1740                 test_hash_speed("md4", sec, generic_hash_speed_template);
1741                 if (mode > 300 && mode < 400) break;
1742
1743         case 302:
1744                 test_hash_speed("md5", sec, generic_hash_speed_template);
1745                 if (mode > 300 && mode < 400) break;
1746
1747         case 303:
1748                 test_hash_speed("sha1", sec, generic_hash_speed_template);
1749                 if (mode > 300 && mode < 400) break;
1750
1751         case 304:
1752                 test_hash_speed("sha256", sec, generic_hash_speed_template);
1753                 if (mode > 300 && mode < 400) break;
1754
1755         case 305:
1756                 test_hash_speed("sha384", sec, generic_hash_speed_template);
1757                 if (mode > 300 && mode < 400) break;
1758
1759         case 306:
1760                 test_hash_speed("sha512", sec, generic_hash_speed_template);
1761                 if (mode > 300 && mode < 400) break;
1762
1763         case 307:
1764                 test_hash_speed("wp256", sec, generic_hash_speed_template);
1765                 if (mode > 300 && mode < 400) break;
1766
1767         case 308:
1768                 test_hash_speed("wp384", sec, generic_hash_speed_template);
1769                 if (mode > 300 && mode < 400) break;
1770
1771         case 309:
1772                 test_hash_speed("wp512", sec, generic_hash_speed_template);
1773                 if (mode > 300 && mode < 400) break;
1774
1775         case 310:
1776                 test_hash_speed("tgr128", sec, generic_hash_speed_template);
1777                 if (mode > 300 && mode < 400) break;
1778
1779         case 311:
1780                 test_hash_speed("tgr160", sec, generic_hash_speed_template);
1781                 if (mode > 300 && mode < 400) break;
1782
1783         case 312:
1784                 test_hash_speed("tgr192", sec, generic_hash_speed_template);
1785                 if (mode > 300 && mode < 400) break;
1786
1787         case 313:
1788                 test_hash_speed("sha224", sec, generic_hash_speed_template);
1789                 if (mode > 300 && mode < 400) break;
1790
1791         case 399:
1792                 break;
1793
1794         case 1000:
1795                 test_available();
1796                 break;
1797
1798         default:
1799                 /* useful for debugging */
1800                 printk("not testing anything\n");
1801                 break;
1802         }
1803 }
1804
1805 static int __init tcrypt_mod_init(void)
1806 {
1807         int err = -ENOMEM;
1808
1809         tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL);
1810         if (tvmem == NULL)
1811                 return err;
1812
1813         xbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
1814         if (xbuf == NULL)
1815                 goto err_free_tv;
1816
1817         axbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
1818         if (axbuf == NULL)
1819                 goto err_free_xbuf;
1820
1821         do_test();
1822
1823         /* We intentionaly return -EAGAIN to prevent keeping
1824          * the module. It does all its work from init()
1825          * and doesn't offer any runtime functionality 
1826          * => we don't need it in the memory, do we?
1827          *                                        -- mludvig
1828          */
1829         err = -EAGAIN;
1830
1831         kfree(axbuf);
1832  err_free_xbuf:
1833         kfree(xbuf);
1834  err_free_tv:
1835         kfree(tvmem);
1836
1837         return err;
1838 }
1839
1840 /*
1841  * If an init function is provided, an exit function must also be provided
1842  * to allow module unload.
1843  */
1844 static void __exit tcrypt_mod_fini(void) { }
1845
1846 module_init(tcrypt_mod_init);
1847 module_exit(tcrypt_mod_fini);
1848
1849 module_param(mode, int, 0);
1850 module_param(sec, uint, 0);
1851 MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
1852                       "(defaults to zero which uses CPU cycles instead)");
1853
1854 MODULE_LICENSE("GPL");
1855 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
1856 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");