?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
AHCI: Remove an unnecessary flush from ahci_qc_issue
[linux-2.6/mini2440.git] / crypto / tcrypt.c
blobe47f6e02133c155622d477567d88f890489f151f
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 if (template[i].iv)
590 memcpy(iv, template[i].iv, MAX_IVLEN);
591 else
592 memset(iv, 0, MAX_IVLEN);
593
594 if (template[i].np) {
595 j++;
596 printk("test %u (%d bit key):\n",
597 j, template[i].klen * 8);
598
599 crypto_ablkcipher_clear_flags(tfm, ~0);
600 if (template[i].wk)
601 crypto_ablkcipher_set_flags(
602 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
603
604 ret = crypto_ablkcipher_setkey(tfm, template[i].key,
605 template[i].klen);
606 if (ret) {
607 printk("setkey() failed flags=%x\n",
608 crypto_ablkcipher_get_flags(tfm));
609
610 if (!template[i].fail)
611 goto out;
612 }
613
614 temp = 0;
615 sg_init_table(sg, template[i].np);
616 for (k = 0; k < template[i].np; k++) {
617 memcpy(&xbuf[IDX[k]],
618 template[i].input + temp,
619 template[i].tap[k]);
620 temp += template[i].tap[k];
621 sg_set_buf(&sg[k], &xbuf[IDX[k]],
622 template[i].tap[k]);
623 }
624
625 ablkcipher_request_set_crypt(req, sg, sg,
626 template[i].ilen, iv);
627
628 ret = enc ?
629 crypto_ablkcipher_encrypt(req) :
630 crypto_ablkcipher_decrypt(req);
631
632 switch (ret) {
633 case 0:
634 break;
635 case -EINPROGRESS:
636 case -EBUSY:
637 ret = wait_for_completion_interruptible(
638 &result.completion);
639 if (!ret && !((ret = result.err))) {
640 INIT_COMPLETION(result.completion);
641 break;
642 }
643 /* fall through */
644 default:
645 printk("%s () failed err=%d\n", e, -ret);
646 goto out;
647 }
648
649 temp = 0;
650 for (k = 0; k < template[i].np; k++) {
651 printk("page %u\n", k);
652 q = kmap(sg_page(&sg[k])) + sg[k].offset;
653 hexdump(q, template[i].tap[k]);
654 printk("%s\n",
655 memcmp(q, template[i].result + temp,
656 template[i].tap[k]) ? "fail" :
657 "pass");
658 temp += template[i].tap[k];
659 kunmap(sg_page(&sg[k]));
660 }
661 }
662 }
663 out:
664 crypto_free_ablkcipher(tfm);
665 ablkcipher_request_free(req);
666 }
667
668 static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc, char *p,
669 int blen, int sec)
670 {
671 struct scatterlist sg[1];
672 unsigned long start, end;
673 int bcount;
674 int ret;
675
676 sg_init_one(sg, p, blen);
677
678 for (start = jiffies, end = start + sec * HZ, bcount = 0;
679 time_before(jiffies, end); bcount++) {
680 if (enc)
681 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
682 else
683 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
684
685 if (ret)
686 return ret;
687 }
688
689 printk("%d operations in %d seconds (%ld bytes)\n",
690 bcount, sec, (long)bcount * blen);
691 return 0;
692 }
693
694 static int test_cipher_cycles(struct blkcipher_desc *desc, int enc, char *p,
695 int blen)
696 {
697 struct scatterlist sg[1];
698 unsigned long cycles = 0;
699 int ret = 0;
700 int i;
701
702 sg_init_one(sg, p, blen);
703
704 local_bh_disable();
705 local_irq_disable();
706
707 /* Warm-up run. */
708 for (i = 0; i < 4; i++) {
709 if (enc)
710 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
711 else
712 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
713
714 if (ret)
715 goto out;
716 }
717
718 /* The real thing. */
719 for (i = 0; i < 8; i++) {
720 cycles_t start, end;
721
722 start = get_cycles();
723 if (enc)
724 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
725 else
726 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
727 end = get_cycles();
728
729 if (ret)
730 goto out;
731
732 cycles += end - start;
733 }
734
735 out:
736 local_irq_enable();
737 local_bh_enable();
738
739 if (ret == 0)
740 printk("1 operation in %lu cycles (%d bytes)\n",
741 (cycles + 4) / 8, blen);
742
743 return ret;
744 }
745
746 static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 };
747
748 static void test_cipher_speed(char *algo, int enc, unsigned int sec,
749 struct cipher_testvec *template,
750 unsigned int tcount, u8 *keysize)
751 {
752 unsigned int ret, i, j, iv_len;
753 unsigned char *key, *p, iv[128];
754 struct crypto_blkcipher *tfm;
755 struct blkcipher_desc desc;
756 const char *e;
757 u32 *b_size;
758
759 if (enc == ENCRYPT)
760 e = "encryption";
761 else
762 e = "decryption";
763
764 printk("\ntesting speed of %s %s\n", algo, e);
765
766 tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);
767
768 if (IS_ERR(tfm)) {
769 printk("failed to load transform for %s: %ld\n", algo,
770 PTR_ERR(tfm));
771 return;
772 }
773 desc.tfm = tfm;
774 desc.flags = 0;
775
776 i = 0;
777 do {
778
779 b_size = block_sizes;
780 do {
781
782 if ((*keysize + *b_size) > TVMEMSIZE) {
783 printk("template (%u) too big for tvmem (%u)\n",
784 *keysize + *b_size, TVMEMSIZE);
785 goto out;
786 }
787
788 printk("test %u (%d bit key, %d byte blocks): ", i,
789 *keysize * 8, *b_size);
790
791 memset(tvmem, 0xff, *keysize + *b_size);
792
793 /* set key, plain text and IV */
794 key = (unsigned char *)tvmem;
795 for (j = 0; j < tcount; j++) {
796 if (template[j].klen == *keysize) {
797 key = template[j].key;
798 break;
799 }
800 }
801 p = (unsigned char *)tvmem + *keysize;
802
803 ret = crypto_blkcipher_setkey(tfm, key, *keysize);
804 if (ret) {
805 printk("setkey() failed flags=%x\n",
806 crypto_blkcipher_get_flags(tfm));
807 goto out;
808 }
809
810 iv_len = crypto_blkcipher_ivsize(tfm);
811 if (iv_len) {
812 memset(&iv, 0xff, iv_len);
813 crypto_blkcipher_set_iv(tfm, iv, iv_len);
814 }
815
816 if (sec)
817 ret = test_cipher_jiffies(&desc, enc, p, *b_size, sec);
818 else
819 ret = test_cipher_cycles(&desc, enc, p, *b_size);
820
821 if (ret) {
822 printk("%s() failed flags=%x\n", e, desc.flags);
823 break;
824 }
825 b_size++;
826 i++;
827 } while (*b_size);
828 keysize++;
829 } while (*keysize);
830
831 out:
832 crypto_free_blkcipher(tfm);
833 }
834
835 static int test_hash_jiffies_digest(struct hash_desc *desc, char *p, int blen,
836 char *out, int sec)
837 {
838 struct scatterlist sg[1];
839 unsigned long start, end;
840 int bcount;
841 int ret;
842
843 sg_init_table(sg, 1);
844
845 for (start = jiffies, end = start + sec * HZ, bcount = 0;
846 time_before(jiffies, end); bcount++) {
847 sg_set_buf(sg, p, blen);
848 ret = crypto_hash_digest(desc, sg, blen, out);
849 if (ret)
850 return ret;
851 }
852
853 printk("%6u opers/sec, %9lu bytes/sec\n",
854 bcount / sec, ((long)bcount * blen) / sec);
855
856 return 0;
857 }
858
859 static int test_hash_jiffies(struct hash_desc *desc, char *p, int blen,
860 int plen, char *out, int sec)
861 {
862 struct scatterlist sg[1];
863 unsigned long start, end;
864 int bcount, pcount;
865 int ret;
866
867 if (plen == blen)
868 return test_hash_jiffies_digest(desc, p, blen, out, sec);
869
870 sg_init_table(sg, 1);
871
872 for (start = jiffies, end = start + sec * HZ, bcount = 0;
873 time_before(jiffies, end); bcount++) {
874 ret = crypto_hash_init(desc);
875 if (ret)
876 return ret;
877 for (pcount = 0; pcount < blen; pcount += plen) {
878 sg_set_buf(sg, p + pcount, plen);
879 ret = crypto_hash_update(desc, sg, plen);
880 if (ret)
881 return ret;
882 }
883 /* we assume there is enough space in 'out' for the result */
884 ret = crypto_hash_final(desc, out);
885 if (ret)
886 return ret;
887 }
888
889 printk("%6u opers/sec, %9lu bytes/sec\n",
890 bcount / sec, ((long)bcount * blen) / sec);
891
892 return 0;
893 }
894
895 static int test_hash_cycles_digest(struct hash_desc *desc, char *p, int blen,
896 char *out)
897 {
898 struct scatterlist sg[1];
899 unsigned long cycles = 0;
900 int i;
901 int ret;
902
903 sg_init_table(sg, 1);
904
905 local_bh_disable();
906 local_irq_disable();
907
908 /* Warm-up run. */
909 for (i = 0; i < 4; i++) {
910 sg_set_buf(sg, p, blen);
911 ret = crypto_hash_digest(desc, sg, blen, out);
912 if (ret)
913 goto out;
914 }
915
916 /* The real thing. */
917 for (i = 0; i < 8; i++) {
918 cycles_t start, end;
919
920 start = get_cycles();
921
922 sg_set_buf(sg, p, blen);
923 ret = crypto_hash_digest(desc, sg, blen, out);
924 if (ret)
925 goto out;
926
927 end = get_cycles();
928
929 cycles += end - start;
930 }
931
932 out:
933 local_irq_enable();
934 local_bh_enable();
935
936 if (ret)
937 return ret;
938
939 printk("%6lu cycles/operation, %4lu cycles/byte\n",
940 cycles / 8, cycles / (8 * blen));
941
942 return 0;
943 }
944
945 static int test_hash_cycles(struct hash_desc *desc, char *p, int blen,
946 int plen, char *out)
947 {
948 struct scatterlist sg[1];
949 unsigned long cycles = 0;
950 int i, pcount;
951 int ret;
952
953 if (plen == blen)
954 return test_hash_cycles_digest(desc, p, blen, out);
955
956 sg_init_table(sg, 1);
957
958 local_bh_disable();
959 local_irq_disable();
960
961 /* Warm-up run. */
962 for (i = 0; i < 4; i++) {
963 ret = crypto_hash_init(desc);
964 if (ret)
965 goto out;
966 for (pcount = 0; pcount < blen; pcount += plen) {
967 sg_set_buf(sg, p + pcount, plen);
968 ret = crypto_hash_update(desc, sg, plen);
969 if (ret)
970 goto out;
971 }
972 ret = crypto_hash_final(desc, out);
973 if (ret)
974 goto out;
975 }
976
977 /* The real thing. */
978 for (i = 0; i < 8; i++) {
979 cycles_t start, end;
980
981 start = get_cycles();
982
983 ret = crypto_hash_init(desc);
984 if (ret)
985 goto out;
986 for (pcount = 0; pcount < blen; pcount += plen) {
987 sg_set_buf(sg, p + pcount, plen);
988 ret = crypto_hash_update(desc, sg, plen);
989 if (ret)
990 goto out;
991 }
992 ret = crypto_hash_final(desc, out);
993 if (ret)
994 goto out;
995
996 end = get_cycles();
997
998 cycles += end - start;
999 }
1000
1001 out:
1002 local_irq_enable();
1003 local_bh_enable();
1004
1005 if (ret)
1006 return ret;
1007
1008 printk("%6lu cycles/operation, %4lu cycles/byte\n",
1009 cycles / 8, cycles / (8 * blen));
1010
1011 return 0;
1012 }
1013
1014 static void test_hash_speed(char *algo, unsigned int sec,
1015 struct hash_speed *speed)
1016 {
1017 struct crypto_hash *tfm;
1018 struct hash_desc desc;
1019 char output[1024];
1020 int i;
1021 int ret;
1022
1023 printk("\ntesting speed of %s\n", algo);
1024
1025 tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
1026
1027 if (IS_ERR(tfm)) {
1028 printk("failed to load transform for %s: %ld\n", algo,
1029 PTR_ERR(tfm));
1030 return;
1031 }
1032
1033 desc.tfm = tfm;
1034 desc.flags = 0;
1035
1036 if (crypto_hash_digestsize(tfm) > sizeof(output)) {
1037 printk("digestsize(%u) > outputbuffer(%zu)\n",
1038 crypto_hash_digestsize(tfm), sizeof(output));
1039 goto out;
1040 }
1041
1042 for (i = 0; speed[i].blen != 0; i++) {
1043 if (speed[i].blen > TVMEMSIZE) {
1044 printk("template (%u) too big for tvmem (%u)\n",
1045 speed[i].blen, TVMEMSIZE);
1046 goto out;
1047 }
1048
1049 printk("test%3u (%5u byte blocks,%5u bytes per update,%4u updates): ",
1050 i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
1051
1052 memset(tvmem, 0xff, speed[i].blen);
1053
1054 if (sec)
1055 ret = test_hash_jiffies(&desc, tvmem, speed[i].blen,
1056 speed[i].plen, output, sec);
1057 else
1058 ret = test_hash_cycles(&desc, tvmem, speed[i].blen,
1059 speed[i].plen, output);
1060
1061 if (ret) {
1062 printk("hashing failed ret=%d\n", ret);
1063 break;
1064 }
1065 }
1066
1067 out:
1068 crypto_free_hash(tfm);
1069 }
1070
1071 static void test_comp(char *algo, struct comp_testvec *ctemplate,
1072 struct comp_testvec *dtemplate, int ctcount, int dtcount)
1073 {
1074 unsigned int i;
1075 char result[COMP_BUF_SIZE];
1076 struct crypto_comp *tfm;
1077 unsigned int tsize;
1078
1079 printk("\ntesting %s compression\n", algo);
1080
1081 tfm = crypto_alloc_comp(algo, 0, CRYPTO_ALG_ASYNC);
1082 if (IS_ERR(tfm)) {
1083 printk("failed to load transform for %s\n", algo);
1084 return;
1085 }
1086
1087 for (i = 0; i < ctcount; i++) {
1088 int ilen, ret, dlen = COMP_BUF_SIZE;
1089
1090 printk("test %u:\n", i + 1);
1091 memset(result, 0, sizeof (result));
1092
1093 ilen = ctemplate[i].inlen;
1094 ret = crypto_comp_compress(tfm, ctemplate[i].input,
1095 ilen, result, &dlen);
1096 if (ret) {
1097 printk("fail: ret=%d\n", ret);
1098 continue;
1099 }
1100 hexdump(result, dlen);
1101 printk("%s (ratio %d:%d)\n",
1102 memcmp(result, ctemplate[i].output, dlen) ? "fail" : "pass",
1103 ilen, dlen);
1104 }
1105
1106 printk("\ntesting %s decompression\n", algo);
1107
1108 tsize = sizeof(struct comp_testvec);
1109 tsize *= dtcount;
1110 if (tsize > TVMEMSIZE) {
1111 printk("template (%u) too big for tvmem (%u)\n", tsize,
1112 TVMEMSIZE);
1113 goto out;
1114 }
1115
1116 for (i = 0; i < dtcount; i++) {
1117 int ilen, ret, dlen = COMP_BUF_SIZE;
1118
1119 printk("test %u:\n", i + 1);
1120 memset(result, 0, sizeof (result));
1121
1122 ilen = dtemplate[i].inlen;
1123 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
1124 ilen, result, &dlen);
1125 if (ret) {
1126 printk("fail: ret=%d\n", ret);
1127 continue;
1128 }
1129 hexdump(result, dlen);
1130 printk("%s (ratio %d:%d)\n",
1131 memcmp(result, dtemplate[i].output, dlen) ? "fail" : "pass",
1132 ilen, dlen);
1133 }
1134 out:
1135 crypto_free_comp(tfm);
1136 }
1137
1138 static void test_available(void)
1139 {
1140 char **name = check;
1141
1142 while (*name) {
1143 printk("alg %s ", *name);
1144 printk(crypto_has_alg(*name, 0, 0) ?
1145 "found\n" : "not found\n");
1146 name++;
1147 }
1148 }
1149
1150 static void do_test(void)
1151 {
1152 switch (mode) {
1153
1154 case 0:
1155 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
1156
1157 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
1158
1159 //DES
1160 test_cipher("ecb(des)", ENCRYPT, des_enc_tv_template,
1161 DES_ENC_TEST_VECTORS);
1162 test_cipher("ecb(des)", DECRYPT, des_dec_tv_template,
1163 DES_DEC_TEST_VECTORS);
1164 test_cipher("cbc(des)", ENCRYPT, des_cbc_enc_tv_template,
1165 DES_CBC_ENC_TEST_VECTORS);
1166 test_cipher("cbc(des)", DECRYPT, des_cbc_dec_tv_template,
1167 DES_CBC_DEC_TEST_VECTORS);
1168
1169 //DES3_EDE
1170 test_cipher("ecb(des3_ede)", ENCRYPT, des3_ede_enc_tv_template,
1171 DES3_EDE_ENC_TEST_VECTORS);
1172 test_cipher("ecb(des3_ede)", DECRYPT, des3_ede_dec_tv_template,
1173 DES3_EDE_DEC_TEST_VECTORS);
1174
1175 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
1176
1177 test_hash("sha224", sha224_tv_template, SHA224_TEST_VECTORS);
1178
1179 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
1180
1181 //BLOWFISH
1182 test_cipher("ecb(blowfish)", ENCRYPT, bf_enc_tv_template,
1183 BF_ENC_TEST_VECTORS);
1184 test_cipher("ecb(blowfish)", DECRYPT, bf_dec_tv_template,
1185 BF_DEC_TEST_VECTORS);
1186 test_cipher("cbc(blowfish)", ENCRYPT, bf_cbc_enc_tv_template,
1187 BF_CBC_ENC_TEST_VECTORS);
1188 test_cipher("cbc(blowfish)", DECRYPT, bf_cbc_dec_tv_template,
1189 BF_CBC_DEC_TEST_VECTORS);
1190
1191 //TWOFISH
1192 test_cipher("ecb(twofish)", ENCRYPT, tf_enc_tv_template,
1193 TF_ENC_TEST_VECTORS);
1194 test_cipher("ecb(twofish)", DECRYPT, tf_dec_tv_template,
1195 TF_DEC_TEST_VECTORS);
1196 test_cipher("cbc(twofish)", ENCRYPT, tf_cbc_enc_tv_template,
1197 TF_CBC_ENC_TEST_VECTORS);
1198 test_cipher("cbc(twofish)", DECRYPT, tf_cbc_dec_tv_template,
1199 TF_CBC_DEC_TEST_VECTORS);
1200
1201 //SERPENT
1202 test_cipher("ecb(serpent)", ENCRYPT, serpent_enc_tv_template,
1203 SERPENT_ENC_TEST_VECTORS);
1204 test_cipher("ecb(serpent)", DECRYPT, serpent_dec_tv_template,
1205 SERPENT_DEC_TEST_VECTORS);
1206
1207 //TNEPRES
1208 test_cipher("ecb(tnepres)", ENCRYPT, tnepres_enc_tv_template,
1209 TNEPRES_ENC_TEST_VECTORS);
1210 test_cipher("ecb(tnepres)", DECRYPT, tnepres_dec_tv_template,
1211 TNEPRES_DEC_TEST_VECTORS);
1212
1213 //AES
1214 test_cipher("ecb(aes)", ENCRYPT, aes_enc_tv_template,
1215 AES_ENC_TEST_VECTORS);
1216 test_cipher("ecb(aes)", DECRYPT, aes_dec_tv_template,
1217 AES_DEC_TEST_VECTORS);
1218 test_cipher("cbc(aes)", ENCRYPT, aes_cbc_enc_tv_template,
1219 AES_CBC_ENC_TEST_VECTORS);
1220 test_cipher("cbc(aes)", DECRYPT, aes_cbc_dec_tv_template,
1221 AES_CBC_DEC_TEST_VECTORS);
1222 test_cipher("lrw(aes)", ENCRYPT, aes_lrw_enc_tv_template,
1223 AES_LRW_ENC_TEST_VECTORS);
1224 test_cipher("lrw(aes)", DECRYPT, aes_lrw_dec_tv_template,
1225 AES_LRW_DEC_TEST_VECTORS);
1226 test_cipher("xts(aes)", ENCRYPT, aes_xts_enc_tv_template,
1227 AES_XTS_ENC_TEST_VECTORS);
1228 test_cipher("xts(aes)", DECRYPT, aes_xts_dec_tv_template,
1229 AES_XTS_DEC_TEST_VECTORS);
1230 test_cipher("rfc3686(ctr(aes))", ENCRYPT, aes_ctr_enc_tv_template,
1231 AES_CTR_ENC_TEST_VECTORS);
1232 test_cipher("rfc3686(ctr(aes))", DECRYPT, aes_ctr_dec_tv_template,
1233 AES_CTR_DEC_TEST_VECTORS);
1234 test_aead("gcm(aes)", ENCRYPT, aes_gcm_enc_tv_template,
1235 AES_GCM_ENC_TEST_VECTORS);
1236 test_aead("gcm(aes)", DECRYPT, aes_gcm_dec_tv_template,
1237 AES_GCM_DEC_TEST_VECTORS);
1238 test_aead("ccm(aes)", ENCRYPT, aes_ccm_enc_tv_template,
1239 AES_CCM_ENC_TEST_VECTORS);
1240 test_aead("ccm(aes)", DECRYPT, aes_ccm_dec_tv_template,
1241 AES_CCM_DEC_TEST_VECTORS);
1242
1243 //CAST5
1244 test_cipher("ecb(cast5)", ENCRYPT, cast5_enc_tv_template,
1245 CAST5_ENC_TEST_VECTORS);
1246 test_cipher("ecb(cast5)", DECRYPT, cast5_dec_tv_template,
1247 CAST5_DEC_TEST_VECTORS);
1248
1249 //CAST6
1250 test_cipher("ecb(cast6)", ENCRYPT, cast6_enc_tv_template,
1251 CAST6_ENC_TEST_VECTORS);
1252 test_cipher("ecb(cast6)", DECRYPT, cast6_dec_tv_template,
1253 CAST6_DEC_TEST_VECTORS);
1254
1255 //ARC4
1256 test_cipher("ecb(arc4)", ENCRYPT, arc4_enc_tv_template,
1257 ARC4_ENC_TEST_VECTORS);
1258 test_cipher("ecb(arc4)", DECRYPT, arc4_dec_tv_template,
1259 ARC4_DEC_TEST_VECTORS);
1260
1261 //TEA
1262 test_cipher("ecb(tea)", ENCRYPT, tea_enc_tv_template,
1263 TEA_ENC_TEST_VECTORS);
1264 test_cipher("ecb(tea)", DECRYPT, tea_dec_tv_template,
1265 TEA_DEC_TEST_VECTORS);
1266
1267
1268 //XTEA
1269 test_cipher("ecb(xtea)", ENCRYPT, xtea_enc_tv_template,
1270 XTEA_ENC_TEST_VECTORS);
1271 test_cipher("ecb(xtea)", DECRYPT, xtea_dec_tv_template,
1272 XTEA_DEC_TEST_VECTORS);
1273
1274 //KHAZAD
1275 test_cipher("ecb(khazad)", ENCRYPT, khazad_enc_tv_template,
1276 KHAZAD_ENC_TEST_VECTORS);
1277 test_cipher("ecb(khazad)", DECRYPT, khazad_dec_tv_template,
1278 KHAZAD_DEC_TEST_VECTORS);
1279
1280 //ANUBIS
1281 test_cipher("ecb(anubis)", ENCRYPT, anubis_enc_tv_template,
1282 ANUBIS_ENC_TEST_VECTORS);
1283 test_cipher("ecb(anubis)", DECRYPT, anubis_dec_tv_template,
1284 ANUBIS_DEC_TEST_VECTORS);
1285 test_cipher("cbc(anubis)", ENCRYPT, anubis_cbc_enc_tv_template,
1286 ANUBIS_CBC_ENC_TEST_VECTORS);
1287 test_cipher("cbc(anubis)", DECRYPT, anubis_cbc_dec_tv_template,
1288 ANUBIS_CBC_ENC_TEST_VECTORS);
1289
1290 //XETA
1291 test_cipher("ecb(xeta)", ENCRYPT, xeta_enc_tv_template,
1292 XETA_ENC_TEST_VECTORS);
1293 test_cipher("ecb(xeta)", DECRYPT, xeta_dec_tv_template,
1294 XETA_DEC_TEST_VECTORS);
1295
1296 //FCrypt
1297 test_cipher("pcbc(fcrypt)", ENCRYPT, fcrypt_pcbc_enc_tv_template,
1298 FCRYPT_ENC_TEST_VECTORS);
1299 test_cipher("pcbc(fcrypt)", DECRYPT, fcrypt_pcbc_dec_tv_template,
1300 FCRYPT_DEC_TEST_VECTORS);
1301
1302 //CAMELLIA
1303 test_cipher("ecb(camellia)", ENCRYPT,
1304 camellia_enc_tv_template,
1305 CAMELLIA_ENC_TEST_VECTORS);
1306 test_cipher("ecb(camellia)", DECRYPT,
1307 camellia_dec_tv_template,
1308 CAMELLIA_DEC_TEST_VECTORS);
1309 test_cipher("cbc(camellia)", ENCRYPT,
1310 camellia_cbc_enc_tv_template,
1311 CAMELLIA_CBC_ENC_TEST_VECTORS);
1312 test_cipher("cbc(camellia)", DECRYPT,
1313 camellia_cbc_dec_tv_template,
1314 CAMELLIA_CBC_DEC_TEST_VECTORS);
1315
1316 //SEED
1317 test_cipher("ecb(seed)", ENCRYPT, seed_enc_tv_template,
1318 SEED_ENC_TEST_VECTORS);
1319 test_cipher("ecb(seed)", DECRYPT, seed_dec_tv_template,
1320 SEED_DEC_TEST_VECTORS);
1321
1322 //CTS
1323 test_cipher("cts(cbc(aes))", ENCRYPT, cts_mode_enc_tv_template,
1324 CTS_MODE_ENC_TEST_VECTORS);
1325 test_cipher("cts(cbc(aes))", DECRYPT, cts_mode_dec_tv_template,
1326 CTS_MODE_DEC_TEST_VECTORS);
1327
1328 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
1329 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
1330 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
1331 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
1332 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
1333 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
1334 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
1335 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
1336 test_comp("deflate", deflate_comp_tv_template,
1337 deflate_decomp_tv_template, DEFLATE_COMP_TEST_VECTORS,
1338 DEFLATE_DECOMP_TEST_VECTORS);
1339 test_comp("lzo", lzo_comp_tv_template, lzo_decomp_tv_template,
1340 LZO_COMP_TEST_VECTORS, LZO_DECOMP_TEST_VECTORS);
1341 test_hash("crc32c", crc32c_tv_template, CRC32C_TEST_VECTORS);
1342 test_hash("hmac(md5)", hmac_md5_tv_template,
1343 HMAC_MD5_TEST_VECTORS);
1344 test_hash("hmac(sha1)", hmac_sha1_tv_template,
1345 HMAC_SHA1_TEST_VECTORS);
1346 test_hash("hmac(sha224)", hmac_sha224_tv_template,
1347 HMAC_SHA224_TEST_VECTORS);
1348 test_hash("hmac(sha256)", hmac_sha256_tv_template,
1349 HMAC_SHA256_TEST_VECTORS);
1350 test_hash("hmac(sha384)", hmac_sha384_tv_template,
1351 HMAC_SHA384_TEST_VECTORS);
1352 test_hash("hmac(sha512)", hmac_sha512_tv_template,
1353 HMAC_SHA512_TEST_VECTORS);
1354
1355 test_hash("xcbc(aes)", aes_xcbc128_tv_template,
1356 XCBC_AES_TEST_VECTORS);
1357
1358 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
1359 break;
1360
1361 case 1:
1362 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
1363 break;
1364
1365 case 2:
1366 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
1367 break;
1368
1369 case 3:
1370 test_cipher("ecb(des)", ENCRYPT, des_enc_tv_template,
1371 DES_ENC_TEST_VECTORS);
1372 test_cipher("ecb(des)", DECRYPT, des_dec_tv_template,
1373 DES_DEC_TEST_VECTORS);
1374 test_cipher("cbc(des)", ENCRYPT, des_cbc_enc_tv_template,
1375 DES_CBC_ENC_TEST_VECTORS);
1376 test_cipher("cbc(des)", DECRYPT, des_cbc_dec_tv_template,
1377 DES_CBC_DEC_TEST_VECTORS);
1378 break;
1379
1380 case 4:
1381 test_cipher("ecb(des3_ede)", ENCRYPT, des3_ede_enc_tv_template,
1382 DES3_EDE_ENC_TEST_VECTORS);
1383 test_cipher("ecb(des3_ede)", DECRYPT, des3_ede_dec_tv_template,
1384 DES3_EDE_DEC_TEST_VECTORS);
1385 break;
1386
1387 case 5:
1388 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
1389 break;
1390
1391 case 6:
1392 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
1393 break;
1394
1395 case 7:
1396 test_cipher("ecb(blowfish)", ENCRYPT, bf_enc_tv_template,
1397 BF_ENC_TEST_VECTORS);
1398 test_cipher("ecb(blowfish)", DECRYPT, bf_dec_tv_template,
1399 BF_DEC_TEST_VECTORS);
1400 test_cipher("cbc(blowfish)", ENCRYPT, bf_cbc_enc_tv_template,
1401 BF_CBC_ENC_TEST_VECTORS);
1402 test_cipher("cbc(blowfish)", DECRYPT, bf_cbc_dec_tv_template,
1403 BF_CBC_DEC_TEST_VECTORS);
1404 break;
1405
1406 case 8:
1407 test_cipher("ecb(twofish)", ENCRYPT, tf_enc_tv_template,
1408 TF_ENC_TEST_VECTORS);
1409 test_cipher("ecb(twofish)", DECRYPT, tf_dec_tv_template,
1410 TF_DEC_TEST_VECTORS);
1411 test_cipher("cbc(twofish)", ENCRYPT, tf_cbc_enc_tv_template,
1412 TF_CBC_ENC_TEST_VECTORS);
1413 test_cipher("cbc(twofish)", DECRYPT, tf_cbc_dec_tv_template,
1414 TF_CBC_DEC_TEST_VECTORS);
1415 break;
1416
1417 case 9:
1418 test_cipher("ecb(serpent)", ENCRYPT, serpent_enc_tv_template,
1419 SERPENT_ENC_TEST_VECTORS);
1420 test_cipher("ecb(serpent)", DECRYPT, serpent_dec_tv_template,
1421 SERPENT_DEC_TEST_VECTORS);
1422 break;
1423
1424 case 10:
1425 test_cipher("ecb(aes)", ENCRYPT, aes_enc_tv_template,
1426 AES_ENC_TEST_VECTORS);
1427 test_cipher("ecb(aes)", DECRYPT, aes_dec_tv_template,
1428 AES_DEC_TEST_VECTORS);
1429 test_cipher("cbc(aes)", ENCRYPT, aes_cbc_enc_tv_template,
1430 AES_CBC_ENC_TEST_VECTORS);
1431 test_cipher("cbc(aes)", DECRYPT, aes_cbc_dec_tv_template,
1432 AES_CBC_DEC_TEST_VECTORS);
1433 test_cipher("lrw(aes)", ENCRYPT, aes_lrw_enc_tv_template,
1434 AES_LRW_ENC_TEST_VECTORS);
1435 test_cipher("lrw(aes)", DECRYPT, aes_lrw_dec_tv_template,
1436 AES_LRW_DEC_TEST_VECTORS);
1437 test_cipher("xts(aes)", ENCRYPT, aes_xts_enc_tv_template,
1438 AES_XTS_ENC_TEST_VECTORS);
1439 test_cipher("xts(aes)", DECRYPT, aes_xts_dec_tv_template,
1440 AES_XTS_DEC_TEST_VECTORS);
1441 test_cipher("rfc3686(ctr(aes))", ENCRYPT, aes_ctr_enc_tv_template,
1442 AES_CTR_ENC_TEST_VECTORS);
1443 test_cipher("rfc3686(ctr(aes))", DECRYPT, aes_ctr_dec_tv_template,
1444 AES_CTR_DEC_TEST_VECTORS);
1445 break;
1446
1447 case 11:
1448 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
1449 break;
1450
1451 case 12:
1452 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
1453 break;
1454
1455 case 13:
1456 test_comp("deflate", deflate_comp_tv_template,
1457 deflate_decomp_tv_template, DEFLATE_COMP_TEST_VECTORS,
1458 DEFLATE_DECOMP_TEST_VECTORS);
1459 break;
1460
1461 case 14:
1462 test_cipher("ecb(cast5)", ENCRYPT, cast5_enc_tv_template,
1463 CAST5_ENC_TEST_VECTORS);
1464 test_cipher("ecb(cast5)", DECRYPT, cast5_dec_tv_template,
1465 CAST5_DEC_TEST_VECTORS);
1466 break;
1467
1468 case 15:
1469 test_cipher("ecb(cast6)", ENCRYPT, cast6_enc_tv_template,
1470 CAST6_ENC_TEST_VECTORS);
1471 test_cipher("ecb(cast6)", DECRYPT, cast6_dec_tv_template,
1472 CAST6_DEC_TEST_VECTORS);
1473 break;
1474
1475 case 16:
1476 test_cipher("ecb(arc4)", ENCRYPT, arc4_enc_tv_template,
1477 ARC4_ENC_TEST_VECTORS);
1478 test_cipher("ecb(arc4)", DECRYPT, arc4_dec_tv_template,
1479 ARC4_DEC_TEST_VECTORS);
1480 break;
1481
1482 case 17:
1483 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
1484 break;
1485
1486 case 18:
1487 test_hash("crc32c", crc32c_tv_template, CRC32C_TEST_VECTORS);
1488 break;
1489
1490 case 19:
1491 test_cipher("ecb(tea)", ENCRYPT, tea_enc_tv_template,
1492 TEA_ENC_TEST_VECTORS);
1493 test_cipher("ecb(tea)", DECRYPT, tea_dec_tv_template,
1494 TEA_DEC_TEST_VECTORS);
1495 break;
1496
1497 case 20:
1498 test_cipher("ecb(xtea)", ENCRYPT, xtea_enc_tv_template,
1499 XTEA_ENC_TEST_VECTORS);
1500 test_cipher("ecb(xtea)", DECRYPT, xtea_dec_tv_template,
1501 XTEA_DEC_TEST_VECTORS);
1502 break;
1503
1504 case 21:
1505 test_cipher("ecb(khazad)", ENCRYPT, khazad_enc_tv_template,
1506 KHAZAD_ENC_TEST_VECTORS);
1507 test_cipher("ecb(khazad)", DECRYPT, khazad_dec_tv_template,
1508 KHAZAD_DEC_TEST_VECTORS);
1509 break;
1510
1511 case 22:
1512 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
1513 break;
1514
1515 case 23:
1516 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
1517 break;
1518
1519 case 24:
1520 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
1521 break;
1522
1523 case 25:
1524 test_cipher("ecb(tnepres)", ENCRYPT, tnepres_enc_tv_template,
1525 TNEPRES_ENC_TEST_VECTORS);
1526 test_cipher("ecb(tnepres)", DECRYPT, tnepres_dec_tv_template,
1527 TNEPRES_DEC_TEST_VECTORS);
1528 break;
1529
1530 case 26:
1531 test_cipher("ecb(anubis)", ENCRYPT, anubis_enc_tv_template,
1532 ANUBIS_ENC_TEST_VECTORS);
1533 test_cipher("ecb(anubis)", DECRYPT, anubis_dec_tv_template,
1534 ANUBIS_DEC_TEST_VECTORS);
1535 test_cipher("cbc(anubis)", ENCRYPT, anubis_cbc_enc_tv_template,
1536 ANUBIS_CBC_ENC_TEST_VECTORS);
1537 test_cipher("cbc(anubis)", DECRYPT, anubis_cbc_dec_tv_template,
1538 ANUBIS_CBC_ENC_TEST_VECTORS);
1539 break;
1540
1541 case 27:
1542 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
1543 break;
1544
1545 case 28:
1546
1547 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
1548 break;
1549
1550 case 29:
1551 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
1552 break;
1553
1554 case 30:
1555 test_cipher("ecb(xeta)", ENCRYPT, xeta_enc_tv_template,
1556 XETA_ENC_TEST_VECTORS);
1557 test_cipher("ecb(xeta)", DECRYPT, xeta_dec_tv_template,
1558 XETA_DEC_TEST_VECTORS);
1559 break;
1560
1561 case 31:
1562 test_cipher("pcbc(fcrypt)", ENCRYPT, fcrypt_pcbc_enc_tv_template,
1563 FCRYPT_ENC_TEST_VECTORS);
1564 test_cipher("pcbc(fcrypt)", DECRYPT, fcrypt_pcbc_dec_tv_template,
1565 FCRYPT_DEC_TEST_VECTORS);
1566 break;
1567
1568 case 32:
1569 test_cipher("ecb(camellia)", ENCRYPT,
1570 camellia_enc_tv_template,
1571 CAMELLIA_ENC_TEST_VECTORS);
1572 test_cipher("ecb(camellia)", DECRYPT,
1573 camellia_dec_tv_template,
1574 CAMELLIA_DEC_TEST_VECTORS);
1575 test_cipher("cbc(camellia)", ENCRYPT,
1576 camellia_cbc_enc_tv_template,
1577 CAMELLIA_CBC_ENC_TEST_VECTORS);
1578 test_cipher("cbc(camellia)", DECRYPT,
1579 camellia_cbc_dec_tv_template,
1580 CAMELLIA_CBC_DEC_TEST_VECTORS);
1581 break;
1582 case 33:
1583 test_hash("sha224", sha224_tv_template, SHA224_TEST_VECTORS);
1584 break;
1585
1586 case 34:
1587 test_cipher("salsa20", ENCRYPT,
1588 salsa20_stream_enc_tv_template,
1589 SALSA20_STREAM_ENC_TEST_VECTORS);
1590 break;
1591
1592 case 35:
1593 test_aead("gcm(aes)", ENCRYPT, aes_gcm_enc_tv_template,
1594 AES_GCM_ENC_TEST_VECTORS);
1595 test_aead("gcm(aes)", DECRYPT, aes_gcm_dec_tv_template,
1596 AES_GCM_DEC_TEST_VECTORS);
1597 break;
1598
1599 case 36:
1600 test_comp("lzo", lzo_comp_tv_template, lzo_decomp_tv_template,
1601 LZO_COMP_TEST_VECTORS, LZO_DECOMP_TEST_VECTORS);
1602 break;
1603
1604 case 37:
1605 test_aead("ccm(aes)", ENCRYPT, aes_ccm_enc_tv_template,
1606 AES_CCM_ENC_TEST_VECTORS);
1607 test_aead("ccm(aes)", DECRYPT, aes_ccm_dec_tv_template,
1608 AES_CCM_DEC_TEST_VECTORS);
1609 break;
1610
1611 case 38:
1612 test_cipher("cts(cbc(aes))", ENCRYPT, cts_mode_enc_tv_template,
1613 CTS_MODE_ENC_TEST_VECTORS);
1614 test_cipher("cts(cbc(aes))", DECRYPT, cts_mode_dec_tv_template,
1615 CTS_MODE_DEC_TEST_VECTORS);
1616 break;
1617
1618 case 100:
1619 test_hash("hmac(md5)", hmac_md5_tv_template,
1620 HMAC_MD5_TEST_VECTORS);
1621 break;
1622
1623 case 101:
1624 test_hash("hmac(sha1)", hmac_sha1_tv_template,
1625 HMAC_SHA1_TEST_VECTORS);
1626 break;
1627
1628 case 102:
1629 test_hash("hmac(sha256)", hmac_sha256_tv_template,
1630 HMAC_SHA256_TEST_VECTORS);
1631 break;
1632
1633 case 103:
1634 test_hash("hmac(sha384)", hmac_sha384_tv_template,
1635 HMAC_SHA384_TEST_VECTORS);
1636 break;
1637
1638 case 104:
1639 test_hash("hmac(sha512)", hmac_sha512_tv_template,
1640 HMAC_SHA512_TEST_VECTORS);
1641 break;
1642
1643 case 105:
1644 test_hash("hmac(sha224)", hmac_sha224_tv_template,
1645 HMAC_SHA224_TEST_VECTORS);
1646 break;
1647
1648 case 106:
1649 test_hash("xcbc(aes)", aes_xcbc128_tv_template,
1650 XCBC_AES_TEST_VECTORS);
1651 break;
1652
1653 case 200:
1654 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
1655 speed_template_16_24_32);
1656 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
1657 speed_template_16_24_32);
1658 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
1659 speed_template_16_24_32);
1660 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
1661 speed_template_16_24_32);
1662 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
1663 speed_template_32_40_48);
1664 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
1665 speed_template_32_40_48);
1666 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
1667 speed_template_32_48_64);
1668 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
1669 speed_template_32_48_64);
1670 break;
1671
1672 case 201:
1673 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
1674 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1675 speed_template_24);
1676 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
1677 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1678 speed_template_24);
1679 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
1680 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1681 speed_template_24);
1682 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
1683 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1684 speed_template_24);
1685 break;
1686
1687 case 202:
1688 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
1689 speed_template_16_24_32);
1690 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
1691 speed_template_16_24_32);
1692 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
1693 speed_template_16_24_32);
1694 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
1695 speed_template_16_24_32);
1696 break;
1697
1698 case 203:
1699 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
1700 speed_template_8_32);
1701 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
1702 speed_template_8_32);
1703 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
1704 speed_template_8_32);
1705 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
1706 speed_template_8_32);
1707 break;
1708
1709 case 204:
1710 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
1711 speed_template_8);
1712 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
1713 speed_template_8);
1714 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
1715 speed_template_8);
1716 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
1717 speed_template_8);
1718 break;
1719
1720 case 205:
1721 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
1722 speed_template_16_24_32);
1723 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
1724 speed_template_16_24_32);
1725 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
1726 speed_template_16_24_32);
1727 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
1728 speed_template_16_24_32);
1729 break;
1730
1731 case 206:
1732 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
1733 speed_template_16_32);
1734 break;
1735
1736 case 300:
1737 /* fall through */
1738
1739 case 301:
1740 test_hash_speed("md4", sec, generic_hash_speed_template);
1741 if (mode > 300 && mode < 400) break;
1742
1743 case 302:
1744 test_hash_speed("md5", sec, generic_hash_speed_template);
1745 if (mode > 300 && mode < 400) break;
1746
1747 case 303:
1748 test_hash_speed("sha1", sec, generic_hash_speed_template);
1749 if (mode > 300 && mode < 400) break;
1750
1751 case 304:
1752 test_hash_speed("sha256", sec, generic_hash_speed_template);
1753 if (mode > 300 && mode < 400) break;
1754
1755 case 305:
1756 test_hash_speed("sha384", sec, generic_hash_speed_template);
1757 if (mode > 300 && mode < 400) break;
1758
1759 case 306:
1760 test_hash_speed("sha512", sec, generic_hash_speed_template);
1761 if (mode > 300 && mode < 400) break;
1762
1763 case 307:
1764 test_hash_speed("wp256", sec, generic_hash_speed_template);
1765 if (mode > 300 && mode < 400) break;
1766
1767 case 308:
1768 test_hash_speed("wp384", sec, generic_hash_speed_template);
1769 if (mode > 300 && mode < 400) break;
1770
1771 case 309:
1772 test_hash_speed("wp512", sec, generic_hash_speed_template);
1773 if (mode > 300 && mode < 400) break;
1774
1775 case 310:
1776 test_hash_speed("tgr128", sec, generic_hash_speed_template);
1777 if (mode > 300 && mode < 400) break;
1778
1779 case 311:
1780 test_hash_speed("tgr160", sec, generic_hash_speed_template);
1781 if (mode > 300 && mode < 400) break;
1782
1783 case 312:
1784 test_hash_speed("tgr192", sec, generic_hash_speed_template);
1785 if (mode > 300 && mode < 400) break;
1786
1787 case 313:
1788 test_hash_speed("sha224", sec, generic_hash_speed_template);
1789 if (mode > 300 && mode < 400) break;
1790
1791 case 399:
1792 break;
1793
1794 case 1000:
1795 test_available();
1796 break;
1797
1798 default:
1799 /* useful for debugging */
1800 printk("not testing anything\n");
1801 break;
1802 }
1803 }
1804
1805 static int __init tcrypt_mod_init(void)
1806 {
1807 int err = -ENOMEM;
1808
1809 tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL);
1810 if (tvmem == NULL)
1811 return err;
1812
1813 xbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
1814 if (xbuf == NULL)
1815 goto err_free_tv;
1816
1817 axbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
1818 if (axbuf == NULL)
1819 goto err_free_xbuf;
1820
1821 do_test();
1822
1823 /* We intentionaly return -EAGAIN to prevent keeping
1824 * the module. It does all its work from init()
1825 * and doesn't offer any runtime functionality
1826 * => we don't need it in the memory, do we?
1827 * -- mludvig
1828 */
1829 err = -EAGAIN;
1830
1831 kfree(axbuf);
1832 err_free_xbuf:
1833 kfree(xbuf);
1834 err_free_tv:
1835 kfree(tvmem);
1836
1837 return err;
1838 }
1839
1840 /*
1841 * If an init function is provided, an exit function must also be provided
1842 * to allow module unload.
1843 */
1844 static void __exit tcrypt_mod_fini(void) { }
1845
1846 module_init(tcrypt_mod_init);
1847 module_exit(tcrypt_mod_fini);
1848
1849 module_param(mode, int, 0);
1850 module_param(sec, uint, 0);
1851 MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
1852 "(defaults to zero which uses CPU cycles instead)");
1853
1854 MODULE_LICENSE("GPL");
1855 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
1856 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
Support for the Chinese Samsung S3C2440 based development boards