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