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