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