[CRYPTO] crc32c: Fix unconventional setkey usage
[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  *
10  * This program is free software; you can redistribute it and/or modify it
11  * under the terms of the GNU General Public License as published by the Free
12  * Software Foundation; either version 2 of the License, or (at your option)
13  * any later version.
14  *
15  * 2004-08-09 Added cipher speed tests (Reyk Floeter <reyk@vantronix.net>)
16  * 2003-09-14 Rewritten by Kartikey Mahendra Bhatt
17  *
18  */
19
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/highmem.h>
28 #include <linux/moduleparam.h>
29 #include <linux/jiffies.h>
30 #include <linux/timex.h>
31 #include <linux/interrupt.h>
32 #include "tcrypt.h"
33
34 /*
35  * Need to kmalloc() memory for testing kmap().
36  */
37 #define TVMEMSIZE       16384
38 #define XBUFSIZE        32768
39
40 /*
41  * Indexes into the xbuf to simulate cross-page access.
42  */
43 #define IDX1            37
44 #define IDX2            32400
45 #define IDX3            1
46 #define IDX4            8193
47 #define IDX5            22222
48 #define IDX6            17101
49 #define IDX7            27333
50 #define IDX8            3000
51
52 /*
53 * Used by test_cipher()
54 */
55 #define ENCRYPT 1
56 #define DECRYPT 0
57 #define MODE_ECB 1
58 #define MODE_CBC 0
59
60 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
61
62 /*
63  * Used by test_cipher_speed()
64  */
65 static unsigned int sec;
66
67 static int mode;
68 static char *xbuf;
69 static char *tvmem;
70
71 static char *check[] = {
72         "des", "md5", "des3_ede", "rot13", "sha1", "sha256", "blowfish",
73         "twofish", "serpent", "sha384", "sha512", "md4", "aes", "cast6",
74         "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
75         "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", NULL
76 };
77
78 static void hexdump(unsigned char *buf, unsigned int len)
79 {
80         while (len--)
81                 printk("%02x", *buf++);
82
83         printk("\n");
84 }
85
86 static void test_hash(char *algo, struct hash_testvec *template,
87                       unsigned int tcount)
88 {
89         unsigned int i, j, k, temp;
90         struct scatterlist sg[8];
91         char result[64];
92         struct crypto_tfm *tfm;
93         struct hash_testvec *hash_tv;
94         unsigned int tsize;
95
96         printk("\ntesting %s\n", algo);
97
98         tsize = sizeof(struct hash_testvec);
99         tsize *= tcount;
100
101         if (tsize > TVMEMSIZE) {
102                 printk("template (%u) too big for tvmem (%u)\n", tsize, TVMEMSIZE);
103                 return;
104         }
105
106         memcpy(tvmem, template, tsize);
107         hash_tv = (void *)tvmem;
108         tfm = crypto_alloc_tfm(algo, 0);
109         if (tfm == NULL) {
110                 printk("failed to load transform for %s\n", algo);
111                 return;
112         }
113
114         for (i = 0; i < tcount; i++) {
115                 printk("test %u:\n", i + 1);
116                 memset(result, 0, 64);
117
118                 sg_set_buf(&sg[0], hash_tv[i].plaintext, hash_tv[i].psize);
119
120                 crypto_digest_init(tfm);
121                 if (tfm->crt_u.digest.dit_setkey) {
122                         crypto_digest_setkey(tfm, hash_tv[i].key,
123                                              hash_tv[i].ksize);
124                 }
125                 crypto_digest_update(tfm, sg, 1);
126                 crypto_digest_final(tfm, result);
127
128                 hexdump(result, crypto_tfm_alg_digestsize(tfm));
129                 printk("%s\n",
130                        memcmp(result, hash_tv[i].digest,
131                               crypto_tfm_alg_digestsize(tfm)) ?
132                        "fail" : "pass");
133         }
134
135         printk("testing %s across pages\n", algo);
136
137         /* setup the dummy buffer first */
138         memset(xbuf, 0, XBUFSIZE);
139
140         j = 0;
141         for (i = 0; i < tcount; i++) {
142                 if (hash_tv[i].np) {
143                         j++;
144                         printk("test %u:\n", j);
145                         memset(result, 0, 64);
146
147                         temp = 0;
148                         for (k = 0; k < hash_tv[i].np; k++) {
149                                 memcpy(&xbuf[IDX[k]],
150                                        hash_tv[i].plaintext + temp,
151                                        hash_tv[i].tap[k]);
152                                 temp += hash_tv[i].tap[k];
153                                 sg_set_buf(&sg[k], &xbuf[IDX[k]],
154                                             hash_tv[i].tap[k]);
155                         }
156
157                         crypto_digest_digest(tfm, sg, hash_tv[i].np, result);
158
159                         hexdump(result, crypto_tfm_alg_digestsize(tfm));
160                         printk("%s\n",
161                                memcmp(result, hash_tv[i].digest,
162                                       crypto_tfm_alg_digestsize(tfm)) ?
163                                "fail" : "pass");
164                 }
165         }
166
167         crypto_free_tfm(tfm);
168 }
169
170
171 #ifdef CONFIG_CRYPTO_HMAC
172
173 static void test_hmac(char *algo, struct hmac_testvec *template,
174                       unsigned int tcount)
175 {
176         unsigned int i, j, k, temp;
177         struct scatterlist sg[8];
178         char result[64];
179         struct crypto_tfm *tfm;
180         struct hmac_testvec *hmac_tv;
181         unsigned int tsize, klen;
182
183         tfm = crypto_alloc_tfm(algo, 0);
184         if (tfm == NULL) {
185                 printk("failed to load transform for %s\n", algo);
186                 return;
187         }
188
189         printk("\ntesting hmac_%s\n", algo);
190
191         tsize = sizeof(struct hmac_testvec);
192         tsize *= tcount;
193         if (tsize > TVMEMSIZE) {
194                 printk("template (%u) too big for tvmem (%u)\n", tsize,
195                        TVMEMSIZE);
196                 goto out;
197         }
198
199         memcpy(tvmem, template, tsize);
200         hmac_tv = (void *)tvmem;
201
202         for (i = 0; i < tcount; i++) {
203                 printk("test %u:\n", i + 1);
204                 memset(result, 0, sizeof (result));
205
206                 klen = hmac_tv[i].ksize;
207                 sg_set_buf(&sg[0], hmac_tv[i].plaintext, hmac_tv[i].psize);
208
209                 crypto_hmac(tfm, hmac_tv[i].key, &klen, sg, 1, result);
210
211                 hexdump(result, crypto_tfm_alg_digestsize(tfm));
212                 printk("%s\n",
213                        memcmp(result, hmac_tv[i].digest,
214                               crypto_tfm_alg_digestsize(tfm)) ? "fail" :
215                        "pass");
216         }
217
218         printk("\ntesting hmac_%s across pages\n", algo);
219
220         memset(xbuf, 0, XBUFSIZE);
221
222         j = 0;
223         for (i = 0; i < tcount; i++) {
224                 if (hmac_tv[i].np) {
225                         j++;
226                         printk("test %u:\n",j);
227                         memset(result, 0, 64);
228
229                         temp = 0;
230                         klen = hmac_tv[i].ksize;
231                         for (k = 0; k < hmac_tv[i].np; k++) {
232                                 memcpy(&xbuf[IDX[k]],
233                                        hmac_tv[i].plaintext + temp,
234                                        hmac_tv[i].tap[k]);
235                                 temp += hmac_tv[i].tap[k];
236                                 sg_set_buf(&sg[k], &xbuf[IDX[k]],
237                                             hmac_tv[i].tap[k]);
238                         }
239
240                         crypto_hmac(tfm, hmac_tv[i].key, &klen, sg,
241                                     hmac_tv[i].np, result);
242                         hexdump(result, crypto_tfm_alg_digestsize(tfm));
243
244                         printk("%s\n",
245                                memcmp(result, hmac_tv[i].digest,
246                                       crypto_tfm_alg_digestsize(tfm)) ?
247                                "fail" : "pass");
248                 }
249         }
250 out:
251         crypto_free_tfm(tfm);
252 }
253
254 #endif  /* CONFIG_CRYPTO_HMAC */
255
256 static void test_cipher(char *algo, int mode, int enc,
257                         struct cipher_testvec *template, unsigned int tcount)
258 {
259         unsigned int ret, i, j, k, temp;
260         unsigned int tsize;
261         char *q;
262         struct crypto_tfm *tfm;
263         char *key;
264         struct cipher_testvec *cipher_tv;
265         struct scatterlist sg[8];
266         const char *e, *m;
267
268         if (enc == ENCRYPT)
269                 e = "encryption";
270         else
271                 e = "decryption";
272         if (mode == MODE_ECB)
273                 m = "ECB";
274         else
275                 m = "CBC";
276
277         printk("\ntesting %s %s %s\n", algo, m, e);
278
279         tsize = sizeof (struct cipher_testvec);
280         tsize *= tcount;
281
282         if (tsize > TVMEMSIZE) {
283                 printk("template (%u) too big for tvmem (%u)\n", tsize,
284                        TVMEMSIZE);
285                 return;
286         }
287
288         memcpy(tvmem, template, tsize);
289         cipher_tv = (void *)tvmem;
290
291         if (mode)
292                 tfm = crypto_alloc_tfm(algo, 0);
293         else
294                 tfm = crypto_alloc_tfm(algo, CRYPTO_TFM_MODE_CBC);
295
296         if (tfm == NULL) {
297                 printk("failed to load transform for %s %s\n", algo, m);
298                 return;
299         }
300
301         j = 0;
302         for (i = 0; i < tcount; i++) {
303                 if (!(cipher_tv[i].np)) {
304                         j++;
305                         printk("test %u (%d bit key):\n",
306                         j, cipher_tv[i].klen * 8);
307
308                         tfm->crt_flags = 0;
309                         if (cipher_tv[i].wk)
310                                 tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY;
311                         key = cipher_tv[i].key;
312
313                         ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen);
314                         if (ret) {
315                                 printk("setkey() failed flags=%x\n", tfm->crt_flags);
316
317                                 if (!cipher_tv[i].fail)
318                                         goto out;
319                         }
320
321                         sg_set_buf(&sg[0], cipher_tv[i].input,
322                                    cipher_tv[i].ilen);
323
324                         if (!mode) {
325                                 crypto_cipher_set_iv(tfm, cipher_tv[i].iv,
326                                         crypto_tfm_alg_ivsize(tfm));
327                         }
328
329                         if (enc)
330                                 ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen);
331                         else
332                                 ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen);
333
334
335                         if (ret) {
336                                 printk("%s () failed flags=%x\n", e, tfm->crt_flags);
337                                 goto out;
338                         }
339
340                         q = kmap(sg[0].page) + sg[0].offset;
341                         hexdump(q, cipher_tv[i].rlen);
342
343                         printk("%s\n",
344                                memcmp(q, cipher_tv[i].result,
345                                       cipher_tv[i].rlen) ? "fail" : "pass");
346                 }
347         }
348
349         printk("\ntesting %s %s %s across pages (chunking)\n", algo, m, e);
350         memset(xbuf, 0, XBUFSIZE);
351
352         j = 0;
353         for (i = 0; i < tcount; i++) {
354                 if (cipher_tv[i].np) {
355                         j++;
356                         printk("test %u (%d bit key):\n",
357                         j, cipher_tv[i].klen * 8);
358
359                         tfm->crt_flags = 0;
360                         if (cipher_tv[i].wk)
361                                 tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY;
362                         key = cipher_tv[i].key;
363
364                         ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen);
365                         if (ret) {
366                                 printk("setkey() failed flags=%x\n", tfm->crt_flags);
367
368                                 if (!cipher_tv[i].fail)
369                                         goto out;
370                         }
371
372                         temp = 0;
373                         for (k = 0; k < cipher_tv[i].np; k++) {
374                                 memcpy(&xbuf[IDX[k]],
375                                        cipher_tv[i].input + temp,
376                                        cipher_tv[i].tap[k]);
377                                 temp += cipher_tv[i].tap[k];
378                                 sg_set_buf(&sg[k], &xbuf[IDX[k]],
379                                            cipher_tv[i].tap[k]);
380                         }
381
382                         if (!mode) {
383                                 crypto_cipher_set_iv(tfm, cipher_tv[i].iv,
384                                                 crypto_tfm_alg_ivsize(tfm));
385                         }
386
387                         if (enc)
388                                 ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen);
389                         else
390                                 ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen);
391
392                         if (ret) {
393                                 printk("%s () failed flags=%x\n", e, tfm->crt_flags);
394                                 goto out;
395                         }
396
397                         temp = 0;
398                         for (k = 0; k < cipher_tv[i].np; k++) {
399                                 printk("page %u\n", k);
400                                 q = kmap(sg[k].page) + sg[k].offset;
401                                 hexdump(q, cipher_tv[i].tap[k]);
402                                 printk("%s\n",
403                                         memcmp(q, cipher_tv[i].result + temp,
404                                                 cipher_tv[i].tap[k]) ? "fail" :
405                                         "pass");
406                                 temp += cipher_tv[i].tap[k];
407                         }
408                 }
409         }
410
411 out:
412         crypto_free_tfm(tfm);
413 }
414
415 static int test_cipher_jiffies(struct crypto_tfm *tfm, int enc, char *p,
416                                int blen, int sec)
417 {
418         struct scatterlist sg[1];
419         unsigned long start, end;
420         int bcount;
421         int ret;
422
423         sg_set_buf(sg, p, blen);
424
425         for (start = jiffies, end = start + sec * HZ, bcount = 0;
426              time_before(jiffies, end); bcount++) {
427                 if (enc)
428                         ret = crypto_cipher_encrypt(tfm, sg, sg, blen);
429                 else
430                         ret = crypto_cipher_decrypt(tfm, sg, sg, blen);
431
432                 if (ret)
433                         return ret;
434         }
435
436         printk("%d operations in %d seconds (%ld bytes)\n",
437                bcount, sec, (long)bcount * blen);
438         return 0;
439 }
440
441 static int test_cipher_cycles(struct crypto_tfm *tfm, int enc, char *p,
442                               int blen)
443 {
444         struct scatterlist sg[1];
445         unsigned long cycles = 0;
446         int ret = 0;
447         int i;
448
449         sg_set_buf(sg, p, blen);
450
451         local_bh_disable();
452         local_irq_disable();
453
454         /* Warm-up run. */
455         for (i = 0; i < 4; i++) {
456                 if (enc)
457                         ret = crypto_cipher_encrypt(tfm, sg, sg, blen);
458                 else
459                         ret = crypto_cipher_decrypt(tfm, sg, sg, blen);
460
461                 if (ret)
462                         goto out;
463         }
464
465         /* The real thing. */
466         for (i = 0; i < 8; i++) {
467                 cycles_t start, end;
468
469                 start = get_cycles();
470                 if (enc)
471                         ret = crypto_cipher_encrypt(tfm, sg, sg, blen);
472                 else
473                         ret = crypto_cipher_decrypt(tfm, sg, sg, blen);
474                 end = get_cycles();
475
476                 if (ret)
477                         goto out;
478
479                 cycles += end - start;
480         }
481
482 out:
483         local_irq_enable();
484         local_bh_enable();
485
486         if (ret == 0)
487                 printk("1 operation in %lu cycles (%d bytes)\n",
488                        (cycles + 4) / 8, blen);
489
490         return ret;
491 }
492
493 static void test_cipher_speed(char *algo, int mode, int enc, unsigned int sec,
494                               struct cipher_testvec *template,
495                               unsigned int tcount, struct cipher_speed *speed)
496 {
497         unsigned int ret, i, j, iv_len;
498         unsigned char *key, *p, iv[128];
499         struct crypto_tfm *tfm;
500         const char *e, *m;
501
502         if (enc == ENCRYPT)
503                 e = "encryption";
504         else
505                 e = "decryption";
506         if (mode == MODE_ECB)
507                 m = "ECB";
508         else
509                 m = "CBC";
510
511         printk("\ntesting speed of %s %s %s\n", algo, m, e);
512
513         if (mode)
514                 tfm = crypto_alloc_tfm(algo, 0);
515         else
516                 tfm = crypto_alloc_tfm(algo, CRYPTO_TFM_MODE_CBC);
517
518         if (tfm == NULL) {
519                 printk("failed to load transform for %s %s\n", algo, m);
520                 return;
521         }
522
523         for (i = 0; speed[i].klen != 0; i++) {
524                 if ((speed[i].blen + speed[i].klen) > TVMEMSIZE) {
525                         printk("template (%u) too big for tvmem (%u)\n",
526                                speed[i].blen + speed[i].klen, TVMEMSIZE);
527                         goto out;
528                 }
529
530                 printk("test %u (%d bit key, %d byte blocks): ", i,
531                        speed[i].klen * 8, speed[i].blen);
532
533                 memset(tvmem, 0xff, speed[i].klen + speed[i].blen);
534
535                 /* set key, plain text and IV */
536                 key = (unsigned char *)tvmem;
537                 for (j = 0; j < tcount; j++) {
538                         if (template[j].klen == speed[i].klen) {
539                                 key = template[j].key;
540                                 break;
541                         }
542                 }
543                 p = (unsigned char *)tvmem + speed[i].klen;
544
545                 ret = crypto_cipher_setkey(tfm, key, speed[i].klen);
546                 if (ret) {
547                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
548                         goto out;
549                 }
550
551                 if (!mode) {
552                         iv_len = crypto_tfm_alg_ivsize(tfm);
553                         memset(&iv, 0xff, iv_len);
554                         crypto_cipher_set_iv(tfm, iv, iv_len);
555                 }
556
557                 if (sec)
558                         ret = test_cipher_jiffies(tfm, enc, p, speed[i].blen,
559                                                   sec);
560                 else
561                         ret = test_cipher_cycles(tfm, enc, p, speed[i].blen);
562
563                 if (ret) {
564                         printk("%s() failed flags=%x\n", e, tfm->crt_flags);
565                         break;
566                 }
567         }
568
569 out:
570         crypto_free_tfm(tfm);
571 }
572
573 static void test_digest_jiffies(struct crypto_tfm *tfm, char *p, int blen,
574                                 int plen, char *out, int sec)
575 {
576         struct scatterlist sg[1];
577         unsigned long start, end;
578         int bcount, pcount;
579
580         for (start = jiffies, end = start + sec * HZ, bcount = 0;
581              time_before(jiffies, end); bcount++) {
582                 crypto_digest_init(tfm);
583                 for (pcount = 0; pcount < blen; pcount += plen) {
584                         sg_set_buf(sg, p + pcount, plen);
585                         crypto_digest_update(tfm, sg, 1);
586                 }
587                 /* we assume there is enough space in 'out' for the result */
588                 crypto_digest_final(tfm, out);
589         }
590
591         printk("%6u opers/sec, %9lu bytes/sec\n",
592                bcount / sec, ((long)bcount * blen) / sec);
593
594         return;
595 }
596
597 static void test_digest_cycles(struct crypto_tfm *tfm, char *p, int blen,
598                                int plen, char *out)
599 {
600         struct scatterlist sg[1];
601         unsigned long cycles = 0;
602         int i, pcount;
603
604         local_bh_disable();
605         local_irq_disable();
606
607         /* Warm-up run. */
608         for (i = 0; i < 4; i++) {
609                 crypto_digest_init(tfm);
610                 for (pcount = 0; pcount < blen; pcount += plen) {
611                         sg_set_buf(sg, p + pcount, plen);
612                         crypto_digest_update(tfm, sg, 1);
613                 }
614                 crypto_digest_final(tfm, out);
615         }
616
617         /* The real thing. */
618         for (i = 0; i < 8; i++) {
619                 cycles_t start, end;
620
621                 crypto_digest_init(tfm);
622
623                 start = get_cycles();
624
625                 for (pcount = 0; pcount < blen; pcount += plen) {
626                         sg_set_buf(sg, p + pcount, plen);
627                         crypto_digest_update(tfm, sg, 1);
628                 }
629                 crypto_digest_final(tfm, out);
630
631                 end = get_cycles();
632
633                 cycles += end - start;
634         }
635
636         local_irq_enable();
637         local_bh_enable();
638
639         printk("%6lu cycles/operation, %4lu cycles/byte\n",
640                cycles / 8, cycles / (8 * blen));
641
642         return;
643 }
644
645 static void test_digest_speed(char *algo, unsigned int sec,
646                               struct digest_speed *speed)
647 {
648         struct crypto_tfm *tfm;
649         char output[1024];
650         int i;
651
652         printk("\ntesting speed of %s\n", algo);
653
654         tfm = crypto_alloc_tfm(algo, 0);
655
656         if (tfm == NULL) {
657                 printk("failed to load transform for %s\n", algo);
658                 return;
659         }
660
661         if (crypto_tfm_alg_digestsize(tfm) > sizeof(output)) {
662                 printk("digestsize(%u) > outputbuffer(%zu)\n",
663                        crypto_tfm_alg_digestsize(tfm), sizeof(output));
664                 goto out;
665         }
666
667         for (i = 0; speed[i].blen != 0; i++) {
668                 if (speed[i].blen > TVMEMSIZE) {
669                         printk("template (%u) too big for tvmem (%u)\n",
670                                speed[i].blen, TVMEMSIZE);
671                         goto out;
672                 }
673
674                 printk("test%3u (%5u byte blocks,%5u bytes per update,%4u updates): ",
675                        i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
676
677                 memset(tvmem, 0xff, speed[i].blen);
678
679                 if (sec)
680                         test_digest_jiffies(tfm, tvmem, speed[i].blen, speed[i].plen, output, sec);
681                 else
682                         test_digest_cycles(tfm, tvmem, speed[i].blen, speed[i].plen, output);
683         }
684
685 out:
686         crypto_free_tfm(tfm);
687 }
688
689 static void test_deflate(void)
690 {
691         unsigned int i;
692         char result[COMP_BUF_SIZE];
693         struct crypto_tfm *tfm;
694         struct comp_testvec *tv;
695         unsigned int tsize;
696
697         printk("\ntesting deflate compression\n");
698
699         tsize = sizeof (deflate_comp_tv_template);
700         if (tsize > TVMEMSIZE) {
701                 printk("template (%u) too big for tvmem (%u)\n", tsize,
702                        TVMEMSIZE);
703                 return;
704         }
705
706         memcpy(tvmem, deflate_comp_tv_template, tsize);
707         tv = (void *)tvmem;
708
709         tfm = crypto_alloc_tfm("deflate", 0);
710         if (tfm == NULL) {
711                 printk("failed to load transform for deflate\n");
712                 return;
713         }
714
715         for (i = 0; i < DEFLATE_COMP_TEST_VECTORS; i++) {
716                 int ilen, ret, dlen = COMP_BUF_SIZE;
717
718                 printk("test %u:\n", i + 1);
719                 memset(result, 0, sizeof (result));
720
721                 ilen = tv[i].inlen;
722                 ret = crypto_comp_compress(tfm, tv[i].input,
723                                            ilen, result, &dlen);
724                 if (ret) {
725                         printk("fail: ret=%d\n", ret);
726                         continue;
727                 }
728                 hexdump(result, dlen);
729                 printk("%s (ratio %d:%d)\n",
730                        memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
731                        ilen, dlen);
732         }
733
734         printk("\ntesting deflate decompression\n");
735
736         tsize = sizeof (deflate_decomp_tv_template);
737         if (tsize > TVMEMSIZE) {
738                 printk("template (%u) too big for tvmem (%u)\n", tsize,
739                        TVMEMSIZE);
740                 goto out;
741         }
742
743         memcpy(tvmem, deflate_decomp_tv_template, tsize);
744         tv = (void *)tvmem;
745
746         for (i = 0; i < DEFLATE_DECOMP_TEST_VECTORS; i++) {
747                 int ilen, ret, dlen = COMP_BUF_SIZE;
748
749                 printk("test %u:\n", i + 1);
750                 memset(result, 0, sizeof (result));
751
752                 ilen = tv[i].inlen;
753                 ret = crypto_comp_decompress(tfm, tv[i].input,
754                                              ilen, result, &dlen);
755                 if (ret) {
756                         printk("fail: ret=%d\n", ret);
757                         continue;
758                 }
759                 hexdump(result, dlen);
760                 printk("%s (ratio %d:%d)\n",
761                        memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
762                        ilen, dlen);
763         }
764 out:
765         crypto_free_tfm(tfm);
766 }
767
768 static void test_crc32c(void)
769 {
770 #define NUMVEC 6
771 #define VECSIZE 40
772
773         int i, j, pass;
774         u32 crc;
775         u8 b, test_vec[NUMVEC][VECSIZE];
776         static u32 vec_results[NUMVEC] = {
777                 0x0e2c157f, 0xe980ebf6, 0xde74bded,
778                 0xd579c862, 0xba979ad0, 0x2b29d913
779         };
780         static u32 tot_vec_results = 0x24c5d375;
781
782         struct scatterlist sg[NUMVEC];
783         struct crypto_tfm *tfm;
784         char *fmtdata = "testing crc32c initialized to %08x: %s\n";
785 #define SEEDTESTVAL 0xedcba987
786         u32 seed;
787
788         printk("\ntesting crc32c\n");
789
790         tfm = crypto_alloc_tfm("crc32c", 0);
791         if (tfm == NULL) {
792                 printk("failed to load transform for crc32c\n");
793                 return;
794         }
795
796         crypto_digest_init(tfm);
797         crypto_digest_final(tfm, (u8*)&crc);
798         printk(fmtdata, crc, (crc == 0) ? "pass" : "ERROR");
799
800         /*
801          * stuff test_vec with known values, simple incrementing
802          * byte values.
803          */
804         b = 0;
805         for (i = 0; i < NUMVEC; i++) {
806                 for (j = 0; j < VECSIZE; j++)
807                         test_vec[i][j] = ++b;
808                 sg_set_buf(&sg[i], test_vec[i], VECSIZE);
809         }
810
811         seed = SEEDTESTVAL;
812         (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
813         crypto_digest_init(tfm);
814         crypto_digest_final(tfm, (u8*)&crc);
815         printk("testing crc32c setkey returns %08x : %s\n", crc, (crc == (SEEDTESTVAL ^ ~(u32)0)) ?
816                "pass" : "ERROR");
817
818         printk("testing crc32c using update/final:\n");
819
820         pass = 1;                   /* assume all is well */
821
822         for (i = 0; i < NUMVEC; i++) {
823                 seed = ~(u32)0;
824                 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
825                 crypto_digest_init(tfm);
826                 crypto_digest_update(tfm, &sg[i], 1);
827                 crypto_digest_final(tfm, (u8*)&crc);
828                 if (crc == vec_results[i]) {
829                         printk(" %08x:OK", crc);
830                 } else {
831                         printk(" %08x:BAD, wanted %08x\n", crc, vec_results[i]);
832                         pass = 0;
833                 }
834         }
835
836         printk("\ntesting crc32c using incremental accumulator:\n");
837         crc = 0;
838         for (i = 0; i < NUMVEC; i++) {
839                 seed = (crc ^ ~(u32)0);
840                 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
841                 crypto_digest_init(tfm);
842                 crypto_digest_update(tfm, &sg[i], 1);
843                 crypto_digest_final(tfm, (u8*)&crc);
844         }
845         if (crc == tot_vec_results) {
846                 printk(" %08x:OK", crc);
847         } else {
848                 printk(" %08x:BAD, wanted %08x\n", crc, tot_vec_results);
849                 pass = 0;
850         }
851
852         printk("\ntesting crc32c using digest:\n");
853         seed = ~(u32)0;
854         (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
855         crypto_digest_init(tfm);
856         crypto_digest_digest(tfm, sg, NUMVEC, (u8*)&crc);
857         if (crc == tot_vec_results) {
858                 printk(" %08x:OK", crc);
859         } else {
860                 printk(" %08x:BAD, wanted %08x\n", crc, tot_vec_results);
861                 pass = 0;
862         }
863
864         printk("\n%s\n", pass ? "pass" : "ERROR");
865
866         crypto_free_tfm(tfm);
867         printk("crc32c test complete\n");
868 }
869
870 static void test_available(void)
871 {
872         char **name = check;
873
874         while (*name) {
875                 printk("alg %s ", *name);
876                 printk((crypto_alg_available(*name, 0)) ?
877                         "found\n" : "not found\n");
878                 name++;
879         }
880 }
881
882 static void do_test(void)
883 {
884         switch (mode) {
885
886         case 0:
887                 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
888
889                 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
890
891                 //DES
892                 test_cipher ("des", MODE_ECB, ENCRYPT, des_enc_tv_template, DES_ENC_TEST_VECTORS);
893                 test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS);
894                 test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS);
895                 test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS);
896
897                 //DES3_EDE
898                 test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS);
899                 test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS);
900
901                 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
902
903                 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
904
905                 //BLOWFISH
906                 test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS);
907                 test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS);
908                 test_cipher ("blowfish", MODE_CBC, ENCRYPT, bf_cbc_enc_tv_template, BF_CBC_ENC_TEST_VECTORS);
909                 test_cipher ("blowfish", MODE_CBC, DECRYPT, bf_cbc_dec_tv_template, BF_CBC_DEC_TEST_VECTORS);
910
911                 //TWOFISH
912                 test_cipher ("twofish", MODE_ECB, ENCRYPT, tf_enc_tv_template, TF_ENC_TEST_VECTORS);
913                 test_cipher ("twofish", MODE_ECB, DECRYPT, tf_dec_tv_template, TF_DEC_TEST_VECTORS);
914                 test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS);
915                 test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS);
916
917                 //SERPENT
918                 test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS);
919                 test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS);
920
921                 //TNEPRES
922                 test_cipher ("tnepres", MODE_ECB, ENCRYPT, tnepres_enc_tv_template, TNEPRES_ENC_TEST_VECTORS);
923                 test_cipher ("tnepres", MODE_ECB, DECRYPT, tnepres_dec_tv_template, TNEPRES_DEC_TEST_VECTORS);
924
925                 //AES
926                 test_cipher ("aes", MODE_ECB, ENCRYPT, aes_enc_tv_template, AES_ENC_TEST_VECTORS);
927                 test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS);
928                 test_cipher ("aes", MODE_CBC, ENCRYPT, aes_cbc_enc_tv_template, AES_CBC_ENC_TEST_VECTORS);
929                 test_cipher ("aes", MODE_CBC, DECRYPT, aes_cbc_dec_tv_template, AES_CBC_DEC_TEST_VECTORS);
930
931                 //CAST5
932                 test_cipher ("cast5", MODE_ECB, ENCRYPT, cast5_enc_tv_template, CAST5_ENC_TEST_VECTORS);
933                 test_cipher ("cast5", MODE_ECB, DECRYPT, cast5_dec_tv_template, CAST5_DEC_TEST_VECTORS);
934
935                 //CAST6
936                 test_cipher ("cast6", MODE_ECB, ENCRYPT, cast6_enc_tv_template, CAST6_ENC_TEST_VECTORS);
937                 test_cipher ("cast6", MODE_ECB, DECRYPT, cast6_dec_tv_template, CAST6_DEC_TEST_VECTORS);
938
939                 //ARC4
940                 test_cipher ("arc4", MODE_ECB, ENCRYPT, arc4_enc_tv_template, ARC4_ENC_TEST_VECTORS);
941                 test_cipher ("arc4", MODE_ECB, DECRYPT, arc4_dec_tv_template, ARC4_DEC_TEST_VECTORS);
942
943                 //TEA
944                 test_cipher ("tea", MODE_ECB, ENCRYPT, tea_enc_tv_template, TEA_ENC_TEST_VECTORS);
945                 test_cipher ("tea", MODE_ECB, DECRYPT, tea_dec_tv_template, TEA_DEC_TEST_VECTORS);
946
947
948                 //XTEA
949                 test_cipher ("xtea", MODE_ECB, ENCRYPT, xtea_enc_tv_template, XTEA_ENC_TEST_VECTORS);
950                 test_cipher ("xtea", MODE_ECB, DECRYPT, xtea_dec_tv_template, XTEA_DEC_TEST_VECTORS);
951
952                 //KHAZAD
953                 test_cipher ("khazad", MODE_ECB, ENCRYPT, khazad_enc_tv_template, KHAZAD_ENC_TEST_VECTORS);
954                 test_cipher ("khazad", MODE_ECB, DECRYPT, khazad_dec_tv_template, KHAZAD_DEC_TEST_VECTORS);
955
956                 //ANUBIS
957                 test_cipher ("anubis", MODE_ECB, ENCRYPT, anubis_enc_tv_template, ANUBIS_ENC_TEST_VECTORS);
958                 test_cipher ("anubis", MODE_ECB, DECRYPT, anubis_dec_tv_template, ANUBIS_DEC_TEST_VECTORS);
959                 test_cipher ("anubis", MODE_CBC, ENCRYPT, anubis_cbc_enc_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
960                 test_cipher ("anubis", MODE_CBC, DECRYPT, anubis_cbc_dec_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
961
962                 //XETA
963                 test_cipher ("xeta", MODE_ECB, ENCRYPT, xeta_enc_tv_template, XETA_ENC_TEST_VECTORS);
964                 test_cipher ("xeta", MODE_ECB, DECRYPT, xeta_dec_tv_template, XETA_DEC_TEST_VECTORS);
965
966                 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
967                 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
968                 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
969                 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
970                 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
971                 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
972                 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
973                 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
974                 test_deflate();
975                 test_crc32c();
976 #ifdef CONFIG_CRYPTO_HMAC
977                 test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS);
978                 test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS);
979                 test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS);
980 #endif
981
982                 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
983                 break;
984
985         case 1:
986                 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
987                 break;
988
989         case 2:
990                 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
991                 break;
992
993         case 3:
994                 test_cipher ("des", MODE_ECB, ENCRYPT, des_enc_tv_template, DES_ENC_TEST_VECTORS);
995                 test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS);
996                 test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS);
997                 test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS);
998                 break;
999
1000         case 4:
1001                 test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS);
1002                 test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS);
1003                 break;
1004
1005         case 5:
1006                 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
1007                 break;
1008
1009         case 6:
1010                 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
1011                 break;
1012
1013         case 7:
1014                 test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS);
1015                 test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS);
1016                 test_cipher ("blowfish", MODE_CBC, ENCRYPT, bf_cbc_enc_tv_template, BF_CBC_ENC_TEST_VECTORS);
1017                 test_cipher ("blowfish", MODE_CBC, DECRYPT, bf_cbc_dec_tv_template, BF_CBC_DEC_TEST_VECTORS);
1018                 break;
1019
1020         case 8:
1021                 test_cipher ("twofish", MODE_ECB, ENCRYPT, tf_enc_tv_template, TF_ENC_TEST_VECTORS);
1022                 test_cipher ("twofish", MODE_ECB, DECRYPT, tf_dec_tv_template, TF_DEC_TEST_VECTORS);
1023                 test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS);
1024                 test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS);
1025                 break;
1026
1027         case 9:
1028                 test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS);
1029                 test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS);
1030                 break;
1031
1032         case 10:
1033                 test_cipher ("aes", MODE_ECB, ENCRYPT, aes_enc_tv_template, AES_ENC_TEST_VECTORS);
1034                 test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS);
1035                 test_cipher ("aes", MODE_CBC, ENCRYPT, aes_cbc_enc_tv_template, AES_CBC_ENC_TEST_VECTORS);
1036                 test_cipher ("aes", MODE_CBC, DECRYPT, aes_cbc_dec_tv_template, AES_CBC_DEC_TEST_VECTORS);
1037                 break;
1038
1039         case 11:
1040                 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
1041                 break;
1042
1043         case 12:
1044                 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
1045                 break;
1046
1047         case 13:
1048                 test_deflate();
1049                 break;
1050
1051         case 14:
1052                 test_cipher ("cast5", MODE_ECB, ENCRYPT, cast5_enc_tv_template, CAST5_ENC_TEST_VECTORS);
1053                 test_cipher ("cast5", MODE_ECB, DECRYPT, cast5_dec_tv_template, CAST5_DEC_TEST_VECTORS);
1054                 break;
1055
1056         case 15:
1057                 test_cipher ("cast6", MODE_ECB, ENCRYPT, cast6_enc_tv_template, CAST6_ENC_TEST_VECTORS);
1058                 test_cipher ("cast6", MODE_ECB, DECRYPT, cast6_dec_tv_template, CAST6_DEC_TEST_VECTORS);
1059                 break;
1060
1061         case 16:
1062                 test_cipher ("arc4", MODE_ECB, ENCRYPT, arc4_enc_tv_template, ARC4_ENC_TEST_VECTORS);
1063                 test_cipher ("arc4", MODE_ECB, DECRYPT, arc4_dec_tv_template, ARC4_DEC_TEST_VECTORS);
1064                 break;
1065
1066         case 17:
1067                 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
1068                 break;
1069
1070         case 18:
1071                 test_crc32c();
1072                 break;
1073
1074         case 19:
1075                 test_cipher ("tea", MODE_ECB, ENCRYPT, tea_enc_tv_template, TEA_ENC_TEST_VECTORS);
1076                 test_cipher ("tea", MODE_ECB, DECRYPT, tea_dec_tv_template, TEA_DEC_TEST_VECTORS);
1077                 break;
1078
1079         case 20:
1080                 test_cipher ("xtea", MODE_ECB, ENCRYPT, xtea_enc_tv_template, XTEA_ENC_TEST_VECTORS);
1081                 test_cipher ("xtea", MODE_ECB, DECRYPT, xtea_dec_tv_template, XTEA_DEC_TEST_VECTORS);
1082                 break;
1083
1084         case 21:
1085                 test_cipher ("khazad", MODE_ECB, ENCRYPT, khazad_enc_tv_template, KHAZAD_ENC_TEST_VECTORS);
1086                 test_cipher ("khazad", MODE_ECB, DECRYPT, khazad_dec_tv_template, KHAZAD_DEC_TEST_VECTORS);
1087                 break;
1088
1089         case 22:
1090                 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
1091                 break;
1092
1093         case 23:
1094                 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
1095                 break;
1096
1097         case 24:
1098                 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
1099                 break;
1100
1101         case 25:
1102                 test_cipher ("tnepres", MODE_ECB, ENCRYPT, tnepres_enc_tv_template, TNEPRES_ENC_TEST_VECTORS);
1103                 test_cipher ("tnepres", MODE_ECB, DECRYPT, tnepres_dec_tv_template, TNEPRES_DEC_TEST_VECTORS);
1104                 break;
1105
1106         case 26:
1107                 test_cipher ("anubis", MODE_ECB, ENCRYPT, anubis_enc_tv_template, ANUBIS_ENC_TEST_VECTORS);
1108                 test_cipher ("anubis", MODE_ECB, DECRYPT, anubis_dec_tv_template, ANUBIS_DEC_TEST_VECTORS);
1109                 test_cipher ("anubis", MODE_CBC, ENCRYPT, anubis_cbc_enc_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
1110                 test_cipher ("anubis", MODE_CBC, DECRYPT, anubis_cbc_dec_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
1111                 break;
1112
1113         case 27:
1114                 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
1115                 break;
1116
1117         case 28:
1118
1119                 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
1120                 break;
1121
1122         case 29:
1123                 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
1124                 break;
1125                 
1126         case 30:
1127                 test_cipher ("xeta", MODE_ECB, ENCRYPT, xeta_enc_tv_template, XETA_ENC_TEST_VECTORS);
1128                 test_cipher ("xeta", MODE_ECB, DECRYPT, xeta_dec_tv_template, XETA_DEC_TEST_VECTORS);
1129                 break;
1130
1131 #ifdef CONFIG_CRYPTO_HMAC
1132         case 100:
1133                 test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS);
1134                 break;
1135
1136         case 101:
1137                 test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS);
1138                 break;
1139
1140         case 102:
1141                 test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS);
1142                 break;
1143
1144 #endif
1145
1146         case 200:
1147                 test_cipher_speed("aes", MODE_ECB, ENCRYPT, sec, NULL, 0,
1148                                   aes_speed_template);
1149                 test_cipher_speed("aes", MODE_ECB, DECRYPT, sec, NULL, 0,
1150                                   aes_speed_template);
1151                 test_cipher_speed("aes", MODE_CBC, ENCRYPT, sec, NULL, 0,
1152                                   aes_speed_template);
1153                 test_cipher_speed("aes", MODE_CBC, DECRYPT, sec, NULL, 0,
1154                                   aes_speed_template);
1155                 break;
1156
1157         case 201:
1158                 test_cipher_speed("des3_ede", MODE_ECB, ENCRYPT, sec,
1159                                   des3_ede_enc_tv_template,
1160                                   DES3_EDE_ENC_TEST_VECTORS,
1161                                   des3_ede_speed_template);
1162                 test_cipher_speed("des3_ede", MODE_ECB, DECRYPT, sec,
1163                                   des3_ede_dec_tv_template,
1164                                   DES3_EDE_DEC_TEST_VECTORS,
1165                                   des3_ede_speed_template);
1166                 test_cipher_speed("des3_ede", MODE_CBC, ENCRYPT, sec,
1167                                   des3_ede_enc_tv_template,
1168                                   DES3_EDE_ENC_TEST_VECTORS,
1169                                   des3_ede_speed_template);
1170                 test_cipher_speed("des3_ede", MODE_CBC, DECRYPT, sec,
1171                                   des3_ede_dec_tv_template,
1172                                   DES3_EDE_DEC_TEST_VECTORS,
1173                                   des3_ede_speed_template);
1174                 break;
1175
1176         case 202:
1177                 test_cipher_speed("twofish", MODE_ECB, ENCRYPT, sec, NULL, 0,
1178                                   twofish_speed_template);
1179                 test_cipher_speed("twofish", MODE_ECB, DECRYPT, sec, NULL, 0,
1180                                   twofish_speed_template);
1181                 test_cipher_speed("twofish", MODE_CBC, ENCRYPT, sec, NULL, 0,
1182                                   twofish_speed_template);
1183                 test_cipher_speed("twofish", MODE_CBC, DECRYPT, sec, NULL, 0,
1184                                   twofish_speed_template);
1185                 break;
1186
1187         case 203:
1188                 test_cipher_speed("blowfish", MODE_ECB, ENCRYPT, sec, NULL, 0,
1189                                   blowfish_speed_template);
1190                 test_cipher_speed("blowfish", MODE_ECB, DECRYPT, sec, NULL, 0,
1191                                   blowfish_speed_template);
1192                 test_cipher_speed("blowfish", MODE_CBC, ENCRYPT, sec, NULL, 0,
1193                                   blowfish_speed_template);
1194                 test_cipher_speed("blowfish", MODE_CBC, DECRYPT, sec, NULL, 0,
1195                                   blowfish_speed_template);
1196                 break;
1197
1198         case 204:
1199                 test_cipher_speed("des", MODE_ECB, ENCRYPT, sec, NULL, 0,
1200                                   des_speed_template);
1201                 test_cipher_speed("des", MODE_ECB, DECRYPT, sec, NULL, 0,
1202                                   des_speed_template);
1203                 test_cipher_speed("des", MODE_CBC, ENCRYPT, sec, NULL, 0,
1204                                   des_speed_template);
1205                 test_cipher_speed("des", MODE_CBC, DECRYPT, sec, NULL, 0,
1206                                   des_speed_template);
1207                 break;
1208
1209         case 300:
1210                 /* fall through */
1211
1212         case 301:
1213                 test_digest_speed("md4", sec, generic_digest_speed_template);
1214                 if (mode > 300 && mode < 400) break;
1215
1216         case 302:
1217                 test_digest_speed("md5", sec, generic_digest_speed_template);
1218                 if (mode > 300 && mode < 400) break;
1219
1220         case 303:
1221                 test_digest_speed("sha1", sec, generic_digest_speed_template);
1222                 if (mode > 300 && mode < 400) break;
1223
1224         case 304:
1225                 test_digest_speed("sha256", sec, generic_digest_speed_template);
1226                 if (mode > 300 && mode < 400) break;
1227
1228         case 305:
1229                 test_digest_speed("sha384", sec, generic_digest_speed_template);
1230                 if (mode > 300 && mode < 400) break;
1231
1232         case 306:
1233                 test_digest_speed("sha512", sec, generic_digest_speed_template);
1234                 if (mode > 300 && mode < 400) break;
1235
1236         case 307:
1237                 test_digest_speed("wp256", sec, generic_digest_speed_template);
1238                 if (mode > 300 && mode < 400) break;
1239
1240         case 308:
1241                 test_digest_speed("wp384", sec, generic_digest_speed_template);
1242                 if (mode > 300 && mode < 400) break;
1243
1244         case 309:
1245                 test_digest_speed("wp512", sec, generic_digest_speed_template);
1246                 if (mode > 300 && mode < 400) break;
1247
1248         case 310:
1249                 test_digest_speed("tgr128", sec, generic_digest_speed_template);
1250                 if (mode > 300 && mode < 400) break;
1251
1252         case 311:
1253                 test_digest_speed("tgr160", sec, generic_digest_speed_template);
1254                 if (mode > 300 && mode < 400) break;
1255
1256         case 312:
1257                 test_digest_speed("tgr192", sec, generic_digest_speed_template);
1258                 if (mode > 300 && mode < 400) break;
1259
1260         case 399:
1261                 break;
1262
1263         case 1000:
1264                 test_available();
1265                 break;
1266
1267         default:
1268                 /* useful for debugging */
1269                 printk("not testing anything\n");
1270                 break;
1271         }
1272 }
1273
1274 static int __init init(void)
1275 {
1276         tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL);
1277         if (tvmem == NULL)
1278                 return -ENOMEM;
1279
1280         xbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
1281         if (xbuf == NULL) {
1282                 kfree(tvmem);
1283                 return -ENOMEM;
1284         }
1285
1286         do_test();
1287
1288         kfree(xbuf);
1289         kfree(tvmem);
1290
1291         /* We intentionaly return -EAGAIN to prevent keeping
1292          * the module. It does all its work from init()
1293          * and doesn't offer any runtime functionality 
1294          * => we don't need it in the memory, do we?
1295          *                                        -- mludvig
1296          */
1297         return -EAGAIN;
1298 }
1299
1300 /*
1301  * If an init function is provided, an exit function must also be provided
1302  * to allow module unload.
1303  */
1304 static void __exit fini(void) { }
1305
1306 module_init(init);
1307 module_exit(fini);
1308
1309 module_param(mode, int, 0);
1310 module_param(sec, uint, 0);
1311 MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
1312                       "(defaults to zero which uses CPU cycles instead)");
1313
1314 MODULE_LICENSE("GPL");
1315 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
1316 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");