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