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