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