projects / openwrt / openwrt.git / blob
? search:


054cac3ed39f2e24c7453d893a61b05dfb91917c
[openwrt/openwrt.git] / package / kernel / lantiq / ltq-deu / src / ltq_deu_testmgr.c
1 /*
2 * Algorithm testing framework and tests.
3 *
4 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
5 * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
6 * Copyright (c) 2007 Nokia Siemens Networks
7 * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
8 *
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the Free
11 * Software Foundation; either version 2 of the License, or (at your option)
12 * any later version.
13 *
14 */
15
16 #include <crypto/hash.h>
17 #include <linux/err.h>
18 #include <linux/module.h>
19 #include <linux/scatterlist.h>
20 #include <linux/slab.h>
21 #include <linux/string.h>
22 #include <crypto/rng.h>
23 #include <linux/jiffies.h>
24 #include <linux/init.h>
25 #include <linux/moduleparam.h>
26 #include <linux/delay.h>
27 #include <linux/types.h>
28 #include <linux/sched.h>
29
30 #include "internal.h"
31 #include "ifxmips_testmgr.h"
32 #include "ifxmips_tcrypt.h"
33 #include "ifxmips_deu.h"
34
35 /* changes for LQ ablkcipher speedtest */
36 #include <linux/timex.h>
37 #include <linux/interrupt.h>
38 #include <asm/mipsregs.h>
39
40 /*
41 * Need slab memory for testing (size in number of pages).
42 */
43 #define XBUFSIZE 8
44
45 /*
46 * Indexes into the xbuf to simulate cross-page access.
47 */
48 #define IDX1 32
49 #define IDX2 32400
50 #define IDX3 1
51 #define IDX4 8193
52 #define IDX5 22222
53 #define IDX6 17101
54 #define IDX7 27333
55 #define IDX8 3000
56
57 /*
58 * Used by test_cipher()
59 */
60 #define ENCRYPT 1
61 #define DECRYPT 0
62
63 /*
64 * Need slab memory for testing (size in number of pages).
65 */
66 #define TVMEMSIZE 4
67
68 /*
69 * Used by test_cipher_speed()
70 */
71 #define ENCRYPT 1
72 #define DECRYPT 0
73
74 /*
75 * Used by test_cipher_speed()
76 */
77
78 #ifndef INIT_COMPLETION
79 #define INIT_COMPLETION(a) reinit_completion(&a)
80 #endif
81
82
83 static unsigned int sec;
84
85 static char *alg = NULL;
86 static u32 type;
87 static u32 mask;
88 static int mode;
89 static char *tvmem[TVMEMSIZE];
90
91 static char *check[] = {
92 "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256",
93 "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes",
94 "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
95 "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", "fcrypt",
96 "camellia", "seed", "salsa20", "rmd128", "rmd160", "rmd256", "rmd320",
97 "lzo", "cts", "zlib", NULL
98 };
99 struct tcrypt_result {
100 struct completion completion;
101 int err;
102 };
103
104 struct aead_test_suite {
105 struct {
106 struct aead_testvec *vecs;
107 unsigned int count;
108 } enc, dec;
109 };
110
111 struct cipher_test_suite {
112 struct {
113 struct cipher_testvec *vecs;
114 unsigned int count;
115 } enc, dec;
116 };
117
118 struct comp_test_suite {
119 struct {
120 struct comp_testvec *vecs;
121 unsigned int count;
122 } comp, decomp;
123 };
124
125 struct pcomp_test_suite {
126 struct {
127 struct pcomp_testvec *vecs;
128 unsigned int count;
129 } comp, decomp;
130 };
131
132 struct hash_test_suite {
133 struct hash_testvec *vecs;
134 unsigned int count;
135 };
136
137 struct cprng_test_suite {
138 struct cprng_testvec *vecs;
139 unsigned int count;
140 };
141
142 struct alg_test_desc {
143 const char *alg;
144 int (*test)(const struct alg_test_desc *desc, const char *driver,
145 u32 type, u32 mask);
146 int fips_allowed; /* set if alg is allowed in fips mode */
147
148 union {
149 struct aead_test_suite aead;
150 struct cipher_test_suite cipher;
151 struct comp_test_suite comp;
152 struct pcomp_test_suite pcomp;
153 struct hash_test_suite hash;
154 struct cprng_test_suite cprng;
155 } suite;
156 };
157
158 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
159
160 static void hexdump(unsigned char *buf, unsigned int len)
161 {
162 print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
163 16, 1,
164 buf, len, false);
165 }
166
167 static void tcrypt_complete(struct crypto_async_request *req, int err)
168 {
169 struct tcrypt_result *res = req->data;
170
171 //printk("Signal done test\n");
172
173 if (err == -EINPROGRESS) {
174 printk("********************* Completion didnt go too well **************************** \n");
175 return;
176 }
177
178 res->err = err;
179 complete_all(&res->completion);
180 }
181
182 static int testmgr_alloc_buf(char *buf[XBUFSIZE])
183 {
184 int i;
185
186 for (i = 0; i < XBUFSIZE; i++) {
187 buf[i] = (void *)__get_free_page(GFP_KERNEL);
188 if (!buf[i])
189 goto err_free_buf;
190 }
191
192 return 0;
193
194 err_free_buf:
195 while (i-- > 0)
196 free_page((unsigned long)buf[i]);
197
198 return -ENOMEM;
199 }
200
201 static void testmgr_free_buf(char *buf[XBUFSIZE])
202 {
203 int i;
204
205 for (i = 0; i < XBUFSIZE; i++)
206 free_page((unsigned long)buf[i]);
207 }
208
209 static int test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
210 unsigned int tcount)
211 {
212 const char *algo = crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm));
213 unsigned int i, j, k, temp;
214 struct scatterlist sg[8];
215 char result[64];
216 struct ahash_request *req;
217 struct tcrypt_result tresult;
218 void *hash_buff;
219 char *xbuf[XBUFSIZE];
220 int ret = -ENOMEM;
221
222 if (testmgr_alloc_buf(xbuf))
223 goto out_nobuf;
224
225 init_completion(&tresult.completion);
226
227 req = ahash_request_alloc(tfm, GFP_KERNEL);
228 if (!req) {
229 printk(KERN_ERR "alg: hash: Failed to allocate request for "
230 "%s\n", algo);
231 goto out_noreq;
232 }
233 ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
234 tcrypt_complete, &tresult);
235
236 j = 0;
237 for (i = 0; i < tcount; i++) {
238 if (template[i].np)
239 continue;
240
241 j++;
242 memset(result, 0, 64);
243
244 hash_buff = xbuf[0];
245
246 memcpy(hash_buff, template[i].plaintext, template[i].psize);
247 sg_init_one(&sg[0], hash_buff, template[i].psize);
248
249 if (template[i].ksize) {
250 crypto_ahash_clear_flags(tfm, ~0);
251 ret = crypto_ahash_setkey(tfm, template[i].key,
252 template[i].ksize);
253 if (ret) {
254 printk(KERN_ERR "alg: hash: setkey failed on "
255 "test %d for %s: ret=%d\n", j, algo,
256 -ret);
257 goto out;
258 }
259 }
260
261 ahash_request_set_crypt(req, sg, result, template[i].psize);
262 ret = crypto_ahash_digest(req);
263 switch (ret) {
264 case 0:
265 break;
266 case -EINPROGRESS:
267 case -EBUSY:
268 ret = wait_for_completion_interruptible(
269 &tresult.completion);
270 if (!ret && !(ret = tresult.err)) {
271 INIT_COMPLETION(tresult.completion);
272 break;
273 }
274 /* fall through */
275 default:
276 printk(KERN_ERR "alg: hash: digest failed on test %d "
277 "for %s: ret=%d\n", j, algo, -ret);
278 goto out;
279 }
280
281 if (memcmp(result, template[i].digest,
282 crypto_ahash_digestsize(tfm))) {
283 printk(KERN_ERR "alg: hash: Test %d failed for %s\n",
284 j, algo);
285 hexdump(result, crypto_ahash_digestsize(tfm));
286 ret = -EINVAL;
287 goto out;
288 }
289 else {
290 printk(KERN_ERR "alg: hash: Test %d passed for %s\n",
291 j, algo);
292 hexdump(result, crypto_ahash_digestsize(tfm));
293 }
294 }
295
296 j = 0;
297 for (i = 0; i < tcount; i++) {
298 if (template[i].np) {
299 j++;
300 memset(result, 0, 64);
301
302 temp = 0;
303 sg_init_table(sg, template[i].np);
304 ret = -EINVAL;
305 for (k = 0; k < template[i].np; k++) {
306 if (WARN_ON(offset_in_page(IDX[k]) +
307 template[i].tap[k] > PAGE_SIZE))
308 goto out;
309 sg_set_buf(&sg[k],
310 memcpy(xbuf[IDX[k] >> PAGE_SHIFT] +
311 offset_in_page(IDX[k]),
312 template[i].plaintext + temp,
313 template[i].tap[k]),
314 template[i].tap[k]);
315 temp += template[i].tap[k];
316 }
317
318 if (template[i].ksize) {
319 crypto_ahash_clear_flags(tfm, ~0);
320 ret = crypto_ahash_setkey(tfm, template[i].key,
321 template[i].ksize);
322
323 if (ret) {
324 printk(KERN_ERR "alg: hash: setkey "
325 "failed on chunking test %d "
326 "for %s: ret=%d\n", j, algo,
327 -ret);
328 goto out;
329 }
330 }
331
332 ahash_request_set_crypt(req, sg, result,
333 template[i].psize);
334 ret = crypto_ahash_digest(req);
335 switch (ret) {
336 case 0:
337 break;
338 case -EINPROGRESS:
339 case -EBUSY:
340 ret = wait_for_completion_interruptible(
341 &tresult.completion);
342 if (!ret && !(ret = tresult.err)) {
343 INIT_COMPLETION(tresult.completion);
344 break;
345 }
346 /* fall through */
347 default:
348 printk(KERN_ERR "alg: hash: digest failed "
349 "on chunking test %d for %s: "
350 "ret=%d\n", j, algo, -ret);
351 goto out;
352 }
353
354 if (memcmp(result, template[i].digest,
355 crypto_ahash_digestsize(tfm))) {
356 printk(KERN_ERR "alg: hash: Chunking test %d "
357 "failed for %s\n", j, algo);
358 hexdump(result, crypto_ahash_digestsize(tfm));
359 ret = -EINVAL;
360 goto out;
361 }
362 else {
363 printk(KERN_ERR "alg: hash: Chunking test %d "
364 "passed for %s\n", j, algo);
365 hexdump(result, crypto_ahash_digestsize(tfm));
366 }
367 }
368 }
369
370 ret = 0;
371
372 out:
373 ahash_request_free(req);
374 out_noreq:
375 testmgr_free_buf(xbuf);
376 out_nobuf:
377 return ret;
378 }
379
380 static int test_aead(struct crypto_aead *tfm, int enc,
381 struct aead_testvec *template, unsigned int tcount)
382 {
383 const char *algo = crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm));
384 unsigned int i, j, k, n, temp;
385 int ret = -ENOMEM;
386 char *q;
387 char *key;
388 struct aead_request *req;
389 struct scatterlist sg[8];
390 struct scatterlist asg[8];
391 const char *e;
392 struct tcrypt_result result;
393 unsigned int authsize;
394 void *input;
395 void *assoc;
396 char iv[MAX_IVLEN];
397 char *xbuf[XBUFSIZE];
398 char *axbuf[XBUFSIZE];
399
400 if (testmgr_alloc_buf(xbuf))
401 goto out_noxbuf;
402 if (testmgr_alloc_buf(axbuf))
403 goto out_noaxbuf;
404
405 if (enc == ENCRYPT)
406 e = "encryption";
407 else
408 e = "decryption";
409
410 init_completion(&result.completion);
411
412 req = aead_request_alloc(tfm, GFP_KERNEL);
413 if (!req) {
414 printk(KERN_ERR "alg: aead: Failed to allocate request for "
415 "%s\n", algo);
416 goto out;
417 }
418
419 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
420 tcrypt_complete, &result);
421
422 for (i = 0, j = 0; i < tcount; i++) {
423 if (!template[i].np) {
424 j++;
425
426 /* some tepmplates have no input data but they will
427 * touch input
428 */
429 input = xbuf[0];
430 assoc = axbuf[0];
431
432 ret = -EINVAL;
433 if (WARN_ON(template[i].ilen > PAGE_SIZE ||
434 template[i].alen > PAGE_SIZE))
435 goto out;
436
437 memcpy(input, template[i].input, template[i].ilen);
438 memcpy(assoc, template[i].assoc, template[i].alen);
439 if (template[i].iv)
440 memcpy(iv, template[i].iv, MAX_IVLEN);
441 else
442 memset(iv, 0, MAX_IVLEN);
443
444 crypto_aead_clear_flags(tfm, ~0);
445 if (template[i].wk)
446 crypto_aead_set_flags(
447 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
448
449 key = template[i].key;
450
451 ret = crypto_aead_setkey(tfm, key,
452 template[i].klen);
453 if (!ret == template[i].fail) {
454 printk(KERN_ERR "alg: aead: setkey failed on "
455 "test %d for %s: flags=%x\n", j, algo,
456 crypto_aead_get_flags(tfm));
457 goto out;
458 } else if (ret)
459 continue;
460
461 authsize = abs(template[i].rlen - template[i].ilen);
462 ret = crypto_aead_setauthsize(tfm, authsize);
463 if (ret) {
464 printk(KERN_ERR "alg: aead: Failed to set "
465 "authsize to %u on test %d for %s\n",
466 authsize, j, algo);
467 goto out;
468 }
469
470 sg_init_one(&sg[0], input,
471 template[i].ilen + (enc ? authsize : 0));
472
473 sg_init_one(&asg[0], assoc, template[i].alen);
474
475 aead_request_set_crypt(req, sg, sg,
476 template[i].ilen, iv);
477
478 aead_request_set_assoc(req, asg, template[i].alen);
479
480 ret = enc ?
481 crypto_aead_encrypt(req) :
482 crypto_aead_decrypt(req);
483
484 switch (ret) {
485 case 0:
486 if (template[i].novrfy) {
487 /* verification was supposed to fail */
488 printk(KERN_ERR "alg: aead: %s failed "
489 "on test %d for %s: ret was 0, "
490 "expected -EBADMSG\n",
491 e, j, algo);
492 /* so really, we got a bad message */
493 ret = -EBADMSG;
494 goto out;
495 }
496 break;
497 case -EINPROGRESS:
498 case -EBUSY:
499 ret = wait_for_completion_interruptible(
500 &result.completion);
501 if (!ret && !(ret = result.err)) {
502 INIT_COMPLETION(result.completion);
503 break;
504 }
505 case -EBADMSG:
506 if (template[i].novrfy)
507 /* verification failure was expected */
508 continue;
509 /* fall through */
510 default:
511 printk(KERN_ERR "alg: aead: %s failed on test "
512 "%d for %s: ret=%d\n", e, j, algo, -ret);
513 goto out;
514 }
515
516 q = input;
517 if (memcmp(q, template[i].result, template[i].rlen)) {
518 printk(KERN_ERR "alg: aead: Test %d failed on "
519 "%s for %s\n", j, e, algo);
520 hexdump(q, template[i].rlen);
521 ret = -EINVAL;
522 goto out;
523 }
524 else {
525 printk(KERN_ERR "alg: aead: Test %d passed on "
526 "%s for %s\n", j, e, algo);
527 hexdump(q, template[i].rlen);
528 }
529 }
530 }
531
532 for (i = 0, j = 0; i < tcount; i++) {
533 if (template[i].np) {
534 j++;
535
536 if (template[i].iv)
537 memcpy(iv, template[i].iv, MAX_IVLEN);
538 else
539 memset(iv, 0, MAX_IVLEN);
540
541 crypto_aead_clear_flags(tfm, ~0);
542 if (template[i].wk)
543 crypto_aead_set_flags(
544 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
545 key = template[i].key;
546
547 ret = crypto_aead_setkey(tfm, key, template[i].klen);
548 if (!ret == template[i].fail) {
549 printk(KERN_ERR "alg: aead: setkey failed on "
550 "chunk test %d for %s: flags=%x\n", j,
551 algo, crypto_aead_get_flags(tfm));
552 goto out;
553 } else if (ret)
554 continue;
555
556 authsize = abs(template[i].rlen - template[i].ilen);
557
558 ret = -EINVAL;
559 sg_init_table(sg, template[i].np);
560 for (k = 0, temp = 0; k < template[i].np; k++) {
561 if (WARN_ON(offset_in_page(IDX[k]) +
562 template[i].tap[k] > PAGE_SIZE))
563 goto out;
564
565 q = xbuf[IDX[k] >> PAGE_SHIFT] +
566 offset_in_page(IDX[k]);
567
568 memcpy(q, template[i].input + temp,
569 template[i].tap[k]);
570
571 n = template[i].tap[k];
572 if (k == template[i].np - 1 && enc)
573 n += authsize;
574 if (offset_in_page(q) + n < PAGE_SIZE)
575 q[n] = 0;
576
577 sg_set_buf(&sg[k], q, template[i].tap[k]);
578 temp += template[i].tap[k];
579 }
580
581 ret = crypto_aead_setauthsize(tfm, authsize);
582 if (ret) {
583 printk(KERN_ERR "alg: aead: Failed to set "
584 "authsize to %u on chunk test %d for "
585 "%s\n", authsize, j, algo);
586 goto out;
587 }
588
589 if (enc) {
590 if (WARN_ON(sg[k - 1].offset +
591 sg[k - 1].length + authsize >
592 PAGE_SIZE)) {
593 ret = -EINVAL;
594 goto out;
595 }
596
597 sg[k - 1].length += authsize;
598 }
599
600 sg_init_table(asg, template[i].anp);
601 ret = -EINVAL;
602 for (k = 0, temp = 0; k < template[i].anp; k++) {
603 if (WARN_ON(offset_in_page(IDX[k]) +
604 template[i].atap[k] > PAGE_SIZE))
605 goto out;
606 sg_set_buf(&asg[k],
607 memcpy(axbuf[IDX[k] >> PAGE_SHIFT] +
608 offset_in_page(IDX[k]),
609 template[i].assoc + temp,
610 template[i].atap[k]),
611 template[i].atap[k]);
612 temp += template[i].atap[k];
613 }
614
615 aead_request_set_crypt(req, sg, sg,
616 template[i].ilen,
617 iv);
618
619 aead_request_set_assoc(req, asg, template[i].alen);
620
621 ret = enc ?
622 crypto_aead_encrypt(req) :
623 crypto_aead_decrypt(req);
624
625 switch (ret) {
626 case 0:
627 if (template[i].novrfy) {
628 /* verification was supposed to fail */
629 printk(KERN_ERR "alg: aead: %s failed "
630 "on chunk test %d for %s: ret "
631 "was 0, expected -EBADMSG\n",
632 e, j, algo);
633 /* so really, we got a bad message */
634 ret = -EBADMSG;
635 goto out;
636 }
637 break;
638 case -EINPROGRESS:
639 case -EBUSY:
640 ret = wait_for_completion_interruptible(
641 &result.completion);
642 if (!ret && !(ret = result.err)) {
643 INIT_COMPLETION(result.completion);
644 break;
645 }
646 case -EBADMSG:
647 if (template[i].novrfy)
648 /* verification failure was expected */
649 continue;
650 /* fall through */
651 default:
652 printk(KERN_ERR "alg: aead: %s failed on "
653 "chunk test %d for %s: ret=%d\n", e, j,
654 algo, -ret);
655 goto out;
656 }
657
658 ret = -EINVAL;
659 for (k = 0, temp = 0; k < template[i].np; k++) {
660 q = xbuf[IDX[k] >> PAGE_SHIFT] +
661 offset_in_page(IDX[k]);
662
663 n = template[i].tap[k];
664 if (k == template[i].np - 1)
665 n += enc ? authsize : -authsize;
666
667 if (memcmp(q, template[i].result + temp, n)) {
668 printk(KERN_ERR "alg: aead: Chunk "
669 "test %d failed on %s at page "
670 "%u for %s\n", j, e, k, algo);
671 hexdump(q, n);
672 goto out;
673 }
674 else {
675 printk(KERN_ERR "alg: aead: Chunk "
676 "test %d passed on %s at page "
677 "%u for %s\n", j, e, k, algo);
678 hexdump(q, n);
679 }
680
681 q += n;
682 if (k == template[i].np - 1 && !enc) {
683 if (memcmp(q, template[i].input +
684 temp + n, authsize))
685 n = authsize;
686 else
687 n = 0;
688 } else {
689 for (n = 0; offset_in_page(q + n) &&
690 q[n]; n++)
691 ;
692 }
693 if (n) {
694 printk(KERN_ERR "alg: aead: Result "
695 "buffer corruption in chunk "
696 "test %d on %s at page %u for "
697 "%s: %u bytes:\n", j, e, k,
698 algo, n);
699 hexdump(q, n);
700 goto out;
701 }
702 temp += template[i].tap[k];
703 }
704 }
705 }
706
707 ret = 0;
708
709 out:
710 aead_request_free(req);
711 testmgr_free_buf(axbuf);
712 out_noaxbuf:
713 testmgr_free_buf(xbuf);
714 out_noxbuf:
715 return ret;
716 }
717
718 static int test_cipher(struct crypto_cipher *tfm, int enc,
719 struct cipher_testvec *template, unsigned int tcount)
720 {
721 const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm));
722 unsigned int i, j, k;
723 char *q;
724 const char *e;
725 void *data;
726 char *xbuf[XBUFSIZE];
727 int ret = -ENOMEM;
728
729 if (testmgr_alloc_buf(xbuf))
730 goto out_nobuf;
731
732 if (enc == ENCRYPT)
733 e = "encryption";
734 else
735 e = "decryption";
736
737 j = 0;
738 for (i = 0; i < tcount; i++) {
739 if (template[i].np)
740 continue;
741
742 j++;
743
744 ret = -EINVAL;
745 if (WARN_ON(template[i].ilen > PAGE_SIZE))
746 goto out;
747
748 data = xbuf[0];
749 memcpy(data, template[i].input, template[i].ilen);
750
751 crypto_cipher_clear_flags(tfm, ~0);
752 if (template[i].wk)
753 crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
754
755 ret = crypto_cipher_setkey(tfm, template[i].key,
756 template[i].klen);
757 if (!ret == template[i].fail) {
758 printk(KERN_ERR "alg: cipher: setkey failed "
759 "on test %d for %s: flags=%x\n", j,
760 algo, crypto_cipher_get_flags(tfm));
761 goto out;
762 } else if (ret)
763 continue;
764
765 for (k = 0; k < template[i].ilen;
766 k += crypto_cipher_blocksize(tfm)) {
767 if (enc)
768 crypto_cipher_encrypt_one(tfm, data + k,
769 data + k);
770 else
771 crypto_cipher_decrypt_one(tfm, data + k,
772 data + k);
773 }
774
775 q = data;
776 if (memcmp(q, template[i].result, template[i].rlen)) {
777 printk(KERN_ERR "alg: cipher: Test %d failed "
778 "on %s for %s\n", j, e, algo);
779 hexdump(q, template[i].rlen);
780 ret = -EINVAL;
781 goto out;
782 }
783 else {
784 printk(KERN_ERR "alg: cipher: Test %d passed "
785 "on %s for %s\n", j, e, algo);
786 hexdump(q, template[i].rlen);
787 }
788 }
789
790 ret = 0;
791
792 out:
793 testmgr_free_buf(xbuf);
794 out_nobuf:
795 return ret;
796 }
797
798 static int test_skcipher(struct crypto_ablkcipher *tfm, int enc,
799 struct cipher_testvec *template, unsigned int tcount)
800 {
801 const char *algo =
802 crypto_tfm_alg_driver_name(crypto_ablkcipher_tfm(tfm));
803 unsigned int i, j, k, n, temp;
804 char *q;
805 struct ablkcipher_request *req;
806 struct scatterlist sg[8];
807 const char *e;
808 struct tcrypt_result result;
809 void *data;
810 char iv[MAX_IVLEN];
811 char *xbuf[XBUFSIZE];
812 int ret = -ENOMEM;
813
814 if (testmgr_alloc_buf(xbuf))
815 goto out_nobuf;
816
817 if (enc == ENCRYPT)
818 e = "encryption";
819 else
820 e = "decryption";
821
822 init_completion(&result.completion);
823
824 req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
825 if (!req) {
826 printk(KERN_ERR "alg: skcipher: Failed to allocate request "
827 "for %s\n", algo);
828 goto out;
829 }
830
831 //printk("tcount: %u\n", tcount);
832
833 ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
834 tcrypt_complete, &result);
835
836 j = 0;
837 for (i = 0; i < tcount; i++) {
838 if (template[i].iv)
839 memcpy(iv, template[i].iv, MAX_IVLEN);
840 else
841 memset(iv, 0, MAX_IVLEN);
842
843 if (!(template[i].np)) {
844 //printk("np: %d, i: %d, j: %d\n", template[i].np, i, j);
845 j++;
846
847 ret = -EINVAL;
848 if (WARN_ON(template[i].ilen > PAGE_SIZE))
849 goto out;
850
851 data = xbuf[0];
852 memcpy(data, template[i].input, template[i].ilen);
853
854 crypto_ablkcipher_clear_flags(tfm, ~0);
855 if (template[i].wk)
856 crypto_ablkcipher_set_flags(
857 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
858
859 ret = crypto_ablkcipher_setkey(tfm, template[i].key,
860 template[i].klen);
861 if (!ret == template[i].fail) {
862 printk(KERN_ERR "alg: skcipher: setkey failed "
863 "on test %d for %s: flags=%x\n", j,
864 algo, crypto_ablkcipher_get_flags(tfm));
865 printk("ERROR\n");
866 goto out;
867 } else if (ret)
868 continue;
869
870 sg_init_one(&sg[0], data, template[i].ilen);
871
872 ablkcipher_request_set_crypt(req, sg, sg,
873 template[i].ilen, iv);
874 ret = enc ?
875 crypto_ablkcipher_encrypt(req) :
876 crypto_ablkcipher_decrypt(req);
877
878 switch (ret) {
879 case 0:
880 break;
881 case -EINPROGRESS:
882 case -EBUSY:
883 ret = wait_for_completion_interruptible(
884 &result.completion);
885 if (!ret && !((ret = result.err))) {
886 INIT_COMPLETION(result.completion);
887 break;
888 }
889 /* fall through */
890 default:
891 printk(KERN_ERR "alg: skcipher: %s failed on "
892 "test %d for %s: ret=%d\n", e, j, algo,
893 -ret);
894 printk("ERROR\n");
895 goto out;
896 }
897 q = data;
898 if (memcmp(q, template[i].result, template[i].rlen)) {
899 printk(KERN_ERR "alg: skcipher: Test %d "
900 "failed on %s for %s\n", j, e, algo);
901 hexdump(q, template[i].rlen);
902 printk("ERROR\n");
903 ret = -EINVAL;
904 goto out;
905 }
906 else {
907 printk(KERN_ERR "alg: skcipher: Test %d "
908 "*PASSED* on %s for %s\n", j, e, algo);
909 hexdump(q, template[i].rlen);
910 printk("DONE\n");
911 }
912 }
913 }
914 printk("Testing %s chunking across pages.\n", algo);
915 j = 0;
916 for (i = 0; i < tcount; i++) {
917 if (template[i].iv)
918 memcpy(iv, template[i].iv, MAX_IVLEN);
919 else
920 memset(iv, 0, MAX_IVLEN);
921
922 if (template[i].np) {
923 j++;
924
925 crypto_ablkcipher_clear_flags(tfm, ~0);
926 if (template[i].wk)
927 crypto_ablkcipher_set_flags(
928 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
929
930 ret = crypto_ablkcipher_setkey(tfm, template[i].key,
931 template[i].klen);
932 if (!ret == template[i].fail) {
933 printk(KERN_ERR "alg: skcipher: setkey failed "
934 "on chunk test %d for %s: flags=%x\n",
935 j, algo,
936 crypto_ablkcipher_get_flags(tfm));
937 printk("ERROR\n");
938 goto out;
939 } else if (ret)
940 continue;
941
942 temp = 0;
943 ret = -EINVAL;
944 sg_init_table(sg, template[i].np);
945 for (k = 0; k < template[i].np; k++) {
946 if (WARN_ON(offset_in_page(IDX[k]) +
947 template[i].tap[k] > PAGE_SIZE))
948 goto out;
949
950 q = xbuf[IDX[k] >> PAGE_SHIFT] +
951 offset_in_page(IDX[k]);
952
953 memcpy(q, template[i].input + temp,
954 template[i].tap[k]);
955
956 if (offset_in_page(q) + template[i].tap[k] <
957 PAGE_SIZE)
958 q[template[i].tap[k]] = 0;
959
960 sg_set_buf(&sg[k], q, template[i].tap[k]);
961
962 temp += template[i].tap[k];
963 }
964
965 ablkcipher_request_set_crypt(req, sg, sg,
966 template[i].ilen, iv);
967
968 ret = enc ?
969 crypto_ablkcipher_encrypt(req) :
970 crypto_ablkcipher_decrypt(req);
971
972 switch (ret) {
973 case 0:
974 break;
975 case -EINPROGRESS:
976 case -EBUSY:
977 ret = wait_for_completion_interruptible(
978 &result.completion);
979 if (!ret && !((ret = result.err))) {
980 INIT_COMPLETION(result.completion);
981 break;
982 }
983 /* fall through */
984 default:
985 printk(KERN_ERR "alg: skcipher: %s failed on "
986 "chunk test %d for %s: ret=%d\n", e, j,
987 algo, -ret);
988 printk("ERROR\n");
989 goto out;
990 }
991
992 temp = 0;
993 ret = -EINVAL;
994 for (k = 0; k < template[i].np; k++) {
995 q = xbuf[IDX[k] >> PAGE_SHIFT] +
996 offset_in_page(IDX[k]);
997
998 if (memcmp(q, template[i].result + temp,
999 template[i].tap[k])) {
1000 printk(KERN_ERR "alg: skcipher: Chunk "
1001 "test %d failed on %s at page "
1002 "%u for %s\n", j, e, k, algo);
1003 hexdump(q, template[i].tap[k]);
1004 printk("ERROR\n");
1005 goto out;
1006 }
1007 else {
1008 printk(KERN_ERR "alg: skcipher: Chunk "
1009 "test %d *PASSED* on %s at page "
1010 "%u for %s\n", j, e, k, algo);
1011 hexdump(q, template[i].tap[k]);
1012 printk("DONE\n");
1013 }
1014
1015 q += template[i].tap[k];
1016 for (n = 0; offset_in_page(q + n) && q[n]; n++)
1017 ;
1018 #if 1
1019 if (n) {
1020 printk(KERN_ERR "alg: skcipher: "
1021 "Result buffer corruption in "
1022 "chunk test %d on %s at page "
1023 "%u for %s: %u bytes:\n", j, e,
1024 k, algo, n);
1025 hexdump(q, n);
1026 printk("ERROR\n");
1027 goto out;
1028 }
1029 else {
1030 printk(KERN_ERR "alg: skcipher: "
1031 "Result buffer clean in "
1032 "chunk test %d on %s at page "
1033 "%u for %s: %u bytes:\n", j, e,
1034 k, algo, n);
1035 hexdump(q, n);
1036 printk("Chunk Buffer clean\n");
1037 }
1038 #endif
1039 temp += template[i].tap[k];
1040 }
1041 }
1042 }
1043
1044 ret = 0;
1045 out:
1046 ablkcipher_request_free(req);
1047 testmgr_free_buf(xbuf);
1048 out_nobuf:
1049 return ret;
1050 }
1051
1052 static int test_comp(struct crypto_comp *tfm, struct comp_testvec *ctemplate,
1053 struct comp_testvec *dtemplate, int ctcount, int dtcount)
1054 {
1055 const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
1056 unsigned int i;
1057 char result[COMP_BUF_SIZE];
1058 int ret;
1059
1060 for (i = 0; i < ctcount; i++) {
1061 int ilen;
1062 unsigned int dlen = COMP_BUF_SIZE;
1063
1064 memset(result, 0, sizeof (result));
1065
1066 ilen = ctemplate[i].inlen;
1067 ret = crypto_comp_compress(tfm, ctemplate[i].input,
1068 ilen, result, &dlen);
1069 if (ret) {
1070 printk(KERN_ERR "alg: comp: compression failed "
1071 "on test %d for %s: ret=%d\n", i + 1, algo,
1072 -ret);
1073 goto out;
1074 }
1075
1076 if (dlen != ctemplate[i].outlen) {
1077 printk(KERN_ERR "alg: comp: Compression test %d "
1078 "failed for %s: output len = %d\n", i + 1, algo,
1079 dlen);
1080 ret = -EINVAL;
1081 goto out;
1082 }
1083
1084 if (memcmp(result, ctemplate[i].output, dlen)) {
1085 printk(KERN_ERR "alg: comp: Compression test %d "
1086 "failed for %s\n", i + 1, algo);
1087 hexdump(result, dlen);
1088 ret = -EINVAL;
1089 goto out;
1090 }
1091 else {
1092 printk(KERN_ERR "alg: comp: Compression test %d "
1093 "passed for %s\n", i + 1, algo);
1094 hexdump(result, dlen);
1095 }
1096 }
1097
1098 for (i = 0; i < dtcount; i++) {
1099 int ilen;
1100 unsigned int dlen = COMP_BUF_SIZE;
1101
1102 memset(result, 0, sizeof (result));
1103
1104 ilen = dtemplate[i].inlen;
1105 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
1106 ilen, result, &dlen);
1107 if (ret) {
1108 printk(KERN_ERR "alg: comp: decompression failed "
1109 "on test %d for %s: ret=%d\n", i + 1, algo,
1110 -ret);
1111 goto out;
1112 }
1113
1114 if (dlen != dtemplate[i].outlen) {
1115 printk(KERN_ERR "alg: comp: Decompression test %d "
1116 "failed for %s: output len = %d\n", i + 1, algo,
1117 dlen);
1118 ret = -EINVAL;
1119 goto out;
1120 }
1121
1122 if (memcmp(result, dtemplate[i].output, dlen)) {
1123 printk(KERN_ERR "alg: comp: Decompression test %d "
1124 "failed for %s\n", i + 1, algo);
1125 hexdump(result, dlen);
1126 ret = -EINVAL;
1127 goto out;
1128 }
1129 else {
1130 printk(KERN_ERR "alg: comp: Decompression test %d "
1131 "passed for %s\n", i + 1, algo);
1132 hexdump(result, dlen);
1133 }
1134 }
1135
1136 ret = 0;
1137
1138 out:
1139 return ret;
1140 }
1141
1142 static int test_pcomp(struct crypto_pcomp *tfm,
1143 struct pcomp_testvec *ctemplate,
1144 struct pcomp_testvec *dtemplate, int ctcount,
1145 int dtcount)
1146 {
1147 const char *algo = crypto_tfm_alg_driver_name(crypto_pcomp_tfm(tfm));
1148 unsigned int i;
1149 char result[COMP_BUF_SIZE];
1150 int res;
1151
1152 for (i = 0; i < ctcount; i++) {
1153 struct comp_request req;
1154 unsigned int produced = 0;
1155
1156 res = crypto_compress_setup(tfm, ctemplate[i].params,
1157 ctemplate[i].paramsize);
1158 if (res) {
1159 pr_err("alg: pcomp: compression setup failed on test "
1160 "%d for %s: error=%d\n", i + 1, algo, res);
1161 return res;
1162 }
1163
1164 res = crypto_compress_init(tfm);
1165 if (res) {
1166 pr_err("alg: pcomp: compression init failed on test "
1167 "%d for %s: error=%d\n", i + 1, algo, res);
1168 return res;
1169 }
1170
1171 memset(result, 0, sizeof(result));
1172
1173 req.next_in = ctemplate[i].input;
1174 req.avail_in = ctemplate[i].inlen / 2;
1175 req.next_out = result;
1176 req.avail_out = ctemplate[i].outlen / 2;
1177
1178 res = crypto_compress_update(tfm, &req);
1179 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1180 pr_err("alg: pcomp: compression update failed on test "
1181 "%d for %s: error=%d\n", i + 1, algo, res);
1182 return res;
1183 }
1184 if (res > 0)
1185 produced += res;
1186
1187 /* Add remaining input data */
1188 req.avail_in += (ctemplate[i].inlen + 1) / 2;
1189
1190 res = crypto_compress_update(tfm, &req);
1191 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1192 pr_err("alg: pcomp: compression update failed on test "
1193 "%d for %s: error=%d\n", i + 1, algo, res);
1194 return res;
1195 }
1196 if (res > 0)
1197 produced += res;
1198
1199 /* Provide remaining output space */
1200 req.avail_out += COMP_BUF_SIZE - ctemplate[i].outlen / 2;
1201
1202 res = crypto_compress_final(tfm, &req);
1203 if (res < 0) {
1204 pr_err("alg: pcomp: compression final failed on test "
1205 "%d for %s: error=%d\n", i + 1, algo, res);
1206 return res;
1207 }
1208 produced += res;
1209
1210 if (COMP_BUF_SIZE - req.avail_out != ctemplate[i].outlen) {
1211 pr_err("alg: comp: Compression test %d failed for %s: "
1212 "output len = %d (expected %d)\n", i + 1, algo,
1213 COMP_BUF_SIZE - req.avail_out,
1214 ctemplate[i].outlen);
1215 return -EINVAL;
1216 }
1217
1218 if (produced != ctemplate[i].outlen) {
1219 pr_err("alg: comp: Compression test %d failed for %s: "
1220 "returned len = %u (expected %d)\n", i + 1,
1221 algo, produced, ctemplate[i].outlen);
1222 return -EINVAL;
1223 }
1224
1225 if (memcmp(result, ctemplate[i].output, ctemplate[i].outlen)) {
1226 pr_err("alg: pcomp: Compression test %d failed for "
1227 "%s\n", i + 1, algo);
1228 hexdump(result, ctemplate[i].outlen);
1229 return -EINVAL;
1230 }
1231 }
1232
1233 for (i = 0; i < dtcount; i++) {
1234 struct comp_request req;
1235 unsigned int produced = 0;
1236
1237 res = crypto_decompress_setup(tfm, dtemplate[i].params,
1238 dtemplate[i].paramsize);
1239 if (res) {
1240 pr_err("alg: pcomp: decompression setup failed on "
1241 "test %d for %s: error=%d\n", i + 1, algo, res);
1242 return res;
1243 }
1244
1245 res = crypto_decompress_init(tfm);
1246 if (res) {
1247 pr_err("alg: pcomp: decompression init failed on test "
1248 "%d for %s: error=%d\n", i + 1, algo, res);
1249 return res;
1250 }
1251
1252 memset(result, 0, sizeof(result));
1253
1254 req.next_in = dtemplate[i].input;
1255 req.avail_in = dtemplate[i].inlen / 2;
1256 req.next_out = result;
1257 req.avail_out = dtemplate[i].outlen / 2;
1258
1259 res = crypto_decompress_update(tfm, &req);
1260 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1261 pr_err("alg: pcomp: decompression update failed on "
1262 "test %d for %s: error=%d\n", i + 1, algo, res);
1263 return res;
1264 }
1265 if (res > 0)
1266 produced += res;
1267
1268 /* Add remaining input data */
1269 req.avail_in += (dtemplate[i].inlen + 1) / 2;
1270
1271 res = crypto_decompress_update(tfm, &req);
1272 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1273 pr_err("alg: pcomp: decompression update failed on "
1274 "test %d for %s: error=%d\n", i + 1, algo, res);
1275 return res;
1276 }
1277 if (res > 0)
1278 produced += res;
1279
1280 /* Provide remaining output space */
1281 req.avail_out += COMP_BUF_SIZE - dtemplate[i].outlen / 2;
1282
1283 res = crypto_decompress_final(tfm, &req);
1284 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1285 pr_err("alg: pcomp: decompression final failed on "
1286 "test %d for %s: error=%d\n", i + 1, algo, res);
1287 return res;
1288 }
1289 if (res > 0)
1290 produced += res;
1291
1292 if (COMP_BUF_SIZE - req.avail_out != dtemplate[i].outlen) {
1293 pr_err("alg: comp: Decompression test %d failed for "
1294 "%s: output len = %d (expected %d)\n", i + 1,
1295 algo, COMP_BUF_SIZE - req.avail_out,
1296 dtemplate[i].outlen);
1297 return -EINVAL;
1298 }
1299
1300 if (produced != dtemplate[i].outlen) {
1301 pr_err("alg: comp: Decompression test %d failed for "
1302 "%s: returned len = %u (expected %d)\n", i + 1,
1303 algo, produced, dtemplate[i].outlen);
1304 return -EINVAL;
1305 }
1306
1307 if (memcmp(result, dtemplate[i].output, dtemplate[i].outlen)) {
1308 pr_err("alg: pcomp: Decompression test %d failed for "
1309 "%s\n", i + 1, algo);
1310 hexdump(result, dtemplate[i].outlen);
1311 return -EINVAL;
1312 }
1313 }
1314
1315 return 0;
1316 }
1317
1318 static int test_ablkcipher_jiffies(struct ablkcipher_request *req, int enc,
1319 int sec, struct tcrypt_result *result,
1320 int blen)
1321 {
1322 unsigned long start, end;
1323 int bcount;
1324 int ret;
1325
1326 for (start = jiffies, end = start + sec * HZ, bcount = 0;
1327 time_before(jiffies, end); bcount++) {
1328
1329 if (enc)
1330 ret = crypto_ablkcipher_encrypt(req);
1331 else
1332 ret = crypto_ablkcipher_decrypt(req);
1333
1334 switch (ret) {
1335 case 0:
1336 break;
1337 case -EINPROGRESS:
1338 case -EBUSY:
1339 ret = wait_for_completion_interruptible(
1340 &result->completion);
1341 if (!ret && !((ret = result->err))) {
1342 INIT_COMPLETION(result->completion);
1343 break;
1344 }
1345 default:
1346 printk("ERROR\n");
1347 return ret;
1348 }
1349 }
1350
1351 printk("%d operations in %d seconds (%ld bytes)\n",
1352 bcount, sec, (long)bcount * blen);
1353
1354 return 0;
1355 }
1356
1357 static int test_ablkcipher_cycles(struct ablkcipher_request *req, int enc,
1358 int sec, struct tcrypt_result *result,
1359 int blen)
1360 {
1361 unsigned long cycles = 0;
1362 int ret = 0;
1363 int i;
1364 unsigned long start, end = 0;
1365 //local_bh_disable();
1366 //local_irq_disable();
1367 /* Warm-up run. */
1368 for (i = 0; i < 4; i++) {
1369 if (enc)
1370 ret = crypto_ablkcipher_encrypt(req);
1371 else
1372 ret = crypto_ablkcipher_decrypt(req);
1373
1374 switch (ret) {
1375 case 0:
1376 break;
1377 case -EINPROGRESS:
1378 case -EBUSY:
1379 #if 0
1380 ret = wait_for_completion_interruptible(
1381 &result->completion);
1382 if (!ret && !((ret = result->err))) {
1383 INIT_COMPLETION(result->completion);
1384 break;
1385 }
1386 #else
1387
1388 wait_for_completion(&result->completion);
1389 INIT_COMPLETION(result->completion);
1390 break;
1391 #endif
1392 default:
1393 printk("ERROR\n");
1394 return ret;
1395 }
1396
1397 if (signal_pending(current)) {
1398 printk("Signal caught\n");
1399 break;
1400 }
1401
1402 }
1403
1404 //printk("Debug ln: (%d), fn: %s\n", __LINE__, __func__);
1405 /* The real thing. */
1406 for (i = 0; i < 8; i++) {
1407 end = 0;
1408 start = 0;
1409 start = read_c0_count();
1410 if (enc)
1411 ret = crypto_ablkcipher_encrypt(req);
1412 else
1413 ret = crypto_ablkcipher_decrypt(req);
1414
1415 switch (ret) {
1416 case 0:
1417 break;
1418 case -EINPROGRESS:
1419 case -EBUSY:
1420 #if 0
1421 ret = wait_for_completion_interruptible(
1422 &result->completion);
1423 end = get_cycles();
1424 if (!ret && !((ret = result->err))) {
1425 INIT_COMPLETION(result->completion);
1426 break;
1427 }
1428 #else
1429 wait_for_completion(&result->completion);
1430 end = read_c0_count();
1431 INIT_COMPLETION(result->completion);
1432 break;
1433 #endif
1434 default:
1435 printk("ERROR\n");
1436 return ret;
1437 }
1438
1439 if (signal_pending(current)) {
1440 printk("Signal caught\n");
1441 break;
1442 }
1443
1444 cycles += end - start;
1445 }
1446
1447 // local_irq_enable();
1448 // local_bh_enable();
1449
1450 printk("1 operation in %lu cycles (%d bytes)\n",
1451 (cycles + 4) / 8, blen);
1452
1453 return 0;
1454
1455 }
1456
1457 static u32 b_size[] = {16, 64, 256, 1024, 8192, 0};
1458
1459 static int test_skcipher_speed(struct crypto_ablkcipher *tfm, int enc,
1460 struct cipher_speed_template *template,
1461 unsigned int tcount, unsigned int sec,
1462 u8* keysize)
1463 {
1464 const char *algo =
1465 crypto_tfm_alg_driver_name(crypto_ablkcipher_tfm(tfm));
1466
1467 unsigned int i = 0, j, iv_len;
1468 struct ablkcipher_request *req;
1469 //struct scatterlist sg[8];
1470 const char *e;
1471 struct tcrypt_result result;
1472 char iv[MAX_IVLEN];
1473 static char *xbuf[XBUFSIZE];
1474 int ret = -ENOMEM;
1475 u32 *block_size;
1476 static char *tvmem_buf[4];
1477 const char *key;
1478
1479 if (testmgr_alloc_buf(xbuf))
1480 goto out_nobuf;
1481
1482 if (enc == ENCRYPT)
1483 e = "encryption";
1484 else
1485 e = "decryption";
1486
1487 init_completion(&result.completion);
1488
1489 printk("Start ablkcipher speed test\n");
1490
1491 req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
1492 if (!req) {
1493 printk(KERN_ERR "alg: skcipher: Failed to allocate request "
1494 "for %s\n", algo);
1495 goto out;
1496 }
1497
1498 // ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1499 ablkcipher_request_set_callback(req, 0,
1500 tcrypt_complete, &result);
1501
1502 do {
1503
1504 block_size = b_size;
1505
1506 do {
1507 struct scatterlist sg[4];
1508 if ((*keysize + *block_size) > 4 * PAGE_SIZE) {
1509 printk("template (%u) too big for "
1510 "tvmem_buf (%lu)\n", *keysize + *block_size,
1511 4 * PAGE_SIZE);
1512 goto out;
1513 }
1514 crypto_ablkcipher_clear_flags(tfm, ~0);
1515
1516 printk("test %u (%d bit key, %d byte blocks): ", i,
1517 *keysize * 8, *block_size);
1518
1519 memset(tvmem_buf[0], 0xff, PAGE_SIZE);
1520 key = tvmem_buf[0];
1521
1522 for (j = 0; j < tcount; j++) {
1523 if (template[j].klen == *keysize) {
1524 key = template[j].key;
1525 break;
1526 }
1527 }
1528 ret = crypto_ablkcipher_setkey(tfm, key, *keysize);
1529 if (ret) {
1530 printk("Error setting of keys\n");
1531 goto out;
1532 }
1533
1534 sg_init_table(sg, 4);
1535
1536 for (j = 0; j < 4; j++) {
1537 tvmem_buf[j] = xbuf[j];
1538 memset(tvmem_buf[j], 0xff, PAGE_SIZE);
1539 sg_set_buf(sg + j, tvmem_buf[j], PAGE_SIZE);
1540 }
1541
1542 iv_len = crypto_ablkcipher_ivsize(tfm);
1543 if (iv_len) {
1544 memset(&iv, 0xff, iv_len);
1545 }
1546
1547 ablkcipher_request_set_crypt(req, sg, sg,
1548 *block_size, iv);
1549
1550 //printk("Debug ln: %d, %s\n", __LINE__, __func__);
1551 if (sec)
1552 ret = test_ablkcipher_jiffies(req, enc, sec,
1553 &result, *block_size);
1554 else
1555 ret = test_ablkcipher_cycles(req, enc, sec,
1556 &result, *block_size);
1557
1558
1559 if (ret) {
1560 printk(KERN_ERR "alg: skcipher: %s failed on "
1561 "test %d for %s: ret=%d\n", e, j, algo,
1562 -ret);
1563 goto out;
1564 }
1565
1566 block_size++;
1567 i++;
1568 } while (*block_size);
1569 keysize++;
1570 } while (*keysize);
1571
1572 ret = 0;
1573 out:
1574 printk("End ablkcipher speed test\n");
1575 ablkcipher_request_free(req);
1576 testmgr_free_buf(xbuf);
1577 #if 0
1578 if (!completion_done(&result->completion)) {
1579 printk("There are threads waiting for completion, completing all\n");
1580 complete_all(&result->completion);
1581 }
1582 #endif
1583
1584 //testmgr_free_buf(tvbuf);
1585 out_nobuf:
1586 return ret;
1587
1588 }
1589
1590 static int test_cprng(struct crypto_rng *tfm, struct cprng_testvec *template,
1591 unsigned int tcount)
1592 {
1593 const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm));
1594 int err = 0, i, j, seedsize;
1595 u8 *seed;
1596 char result[32];
1597
1598 seedsize = crypto_rng_seedsize(tfm);
1599
1600 seed = kmalloc(seedsize, GFP_KERNEL);
1601 if (!seed) {
1602 printk(KERN_ERR "alg: cprng: Failed to allocate seed space "
1603 "for %s\n", algo);
1604 return -ENOMEM;
1605 }
1606
1607 for (i = 0; i < tcount; i++) {
1608 memset(result, 0, 32);
1609
1610 memcpy(seed, template[i].v, template[i].vlen);
1611 memcpy(seed + template[i].vlen, template[i].key,
1612 template[i].klen);
1613 memcpy(seed + template[i].vlen + template[i].klen,
1614 template[i].dt, template[i].dtlen);
1615
1616 err = crypto_rng_reset(tfm, seed, seedsize);
1617 if (err) {
1618 printk(KERN_ERR "alg: cprng: Failed to reset rng "
1619 "for %s\n", algo);
1620 goto out;
1621 }
1622
1623 for (j = 0; j < template[i].loops; j++) {
1624 err = crypto_rng_get_bytes(tfm, result,
1625 template[i].rlen);
1626 if (err != template[i].rlen) {
1627 printk(KERN_ERR "alg: cprng: Failed to obtain "
1628 "the correct amount of random data for "
1629 "%s (requested %d, got %d)\n", algo,
1630 template[i].rlen, err);
1631 goto out;
1632 }
1633 }
1634
1635 err = memcmp(result, template[i].result,
1636 template[i].rlen);
1637 if (err) {
1638 printk(KERN_ERR "alg: cprng: Test %d failed for %s\n",
1639 i, algo);
1640 hexdump(result, template[i].rlen);
1641 err = -EINVAL;
1642 goto out;
1643 }
1644 }
1645
1646 out:
1647 kfree(seed);
1648 return err;
1649 }
1650
1651 static int alg_test_aead(const struct alg_test_desc *desc, const char *driver,
1652 u32 type, u32 mask)
1653 {
1654 struct crypto_aead *tfm;
1655 int err = 0;
1656
1657 tfm = crypto_alloc_aead(driver, type, mask);
1658 if (IS_ERR(tfm)) {
1659 printk(KERN_ERR "alg: aead: Failed to load transform for %s: "
1660 "%ld\n", driver, PTR_ERR(tfm));
1661 return PTR_ERR(tfm);
1662 }
1663
1664 if (desc->suite.aead.enc.vecs) {
1665 err = test_aead(tfm, ENCRYPT, desc->suite.aead.enc.vecs,
1666 desc->suite.aead.enc.count);
1667 if (err)
1668 goto out;
1669 }
1670
1671 if (!err && desc->suite.aead.dec.vecs)
1672 err = test_aead(tfm, DECRYPT, desc->suite.aead.dec.vecs,
1673 desc->suite.aead.dec.count);
1674
1675 out:
1676 crypto_free_aead(tfm);
1677 return err;
1678 }
1679
1680 static int alg_test_cipher(const struct alg_test_desc *desc,
1681 const char *driver, u32 type, u32 mask)
1682 {
1683 struct crypto_cipher *tfm;
1684 int err = 0;
1685
1686 tfm = crypto_alloc_cipher(driver, type, mask);
1687 if (IS_ERR(tfm)) {
1688 printk(KERN_ERR "alg: cipher: Failed to load transform for "
1689 "%s: %ld\n", driver, PTR_ERR(tfm));
1690 return PTR_ERR(tfm);
1691 }
1692
1693 if (desc->suite.cipher.enc.vecs) {
1694 err = test_cipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1695 desc->suite.cipher.enc.count);
1696 if (err)
1697 goto out;
1698 }
1699
1700 if (desc->suite.cipher.dec.vecs)
1701 err = test_cipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1702 desc->suite.cipher.dec.count);
1703
1704 out:
1705 crypto_free_cipher(tfm);
1706 return err;
1707 }
1708
1709 static int alg_test_skcipher(const struct alg_test_desc *desc,
1710 const char *driver, u32 type, u32 mask)
1711 {
1712 struct crypto_ablkcipher *tfm;
1713 int err = 0;
1714
1715 tfm = crypto_alloc_ablkcipher(driver, type, mask);
1716 if (IS_ERR(tfm)) {
1717 printk(KERN_ERR "alg: skcipher: Failed to load transform for "
1718 "%s: %ld\n", driver, PTR_ERR(tfm));
1719 return PTR_ERR(tfm);
1720 }
1721
1722 if (desc->suite.cipher.enc.vecs) {
1723 err = test_skcipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1724 desc->suite.cipher.enc.count);
1725 if (err)
1726 goto out;
1727 }
1728
1729 if (desc->suite.cipher.dec.vecs)
1730 err = test_skcipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1731 desc->suite.cipher.dec.count);
1732
1733 out:
1734 crypto_free_ablkcipher(tfm);
1735 return err;
1736 }
1737
1738 static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
1739 u32 type, u32 mask)
1740 {
1741 struct crypto_comp *tfm;
1742 int err;
1743
1744 tfm = crypto_alloc_comp(driver, type, mask);
1745 if (IS_ERR(tfm)) {
1746 printk(KERN_ERR "alg: comp: Failed to load transform for %s: "
1747 "%ld\n", driver, PTR_ERR(tfm));
1748 return PTR_ERR(tfm);
1749 }
1750
1751 err = test_comp(tfm, desc->suite.comp.comp.vecs,
1752 desc->suite.comp.decomp.vecs,
1753 desc->suite.comp.comp.count,
1754 desc->suite.comp.decomp.count);
1755
1756 crypto_free_comp(tfm);
1757 return err;
1758 }
1759
1760 static int alg_test_pcomp(const struct alg_test_desc *desc, const char *driver,
1761 u32 type, u32 mask)
1762 {
1763 struct crypto_pcomp *tfm;
1764 int err;
1765
1766 tfm = crypto_alloc_pcomp(driver, type, mask);
1767 if (IS_ERR(tfm)) {
1768 pr_err("alg: pcomp: Failed to load transform for %s: %ld\n",
1769 driver, PTR_ERR(tfm));
1770 return PTR_ERR(tfm);
1771 }
1772
1773 err = test_pcomp(tfm, desc->suite.pcomp.comp.vecs,
1774 desc->suite.pcomp.decomp.vecs,
1775 desc->suite.pcomp.comp.count,
1776 desc->suite.pcomp.decomp.count);
1777
1778 crypto_free_pcomp(tfm);
1779 return err;
1780 }
1781
1782 static int alg_test_hash(const struct alg_test_desc *desc, const char *driver,
1783 u32 type, u32 mask)
1784 {
1785 struct crypto_ahash *tfm;
1786 int err;
1787
1788 tfm = crypto_alloc_ahash(driver, type, mask);
1789 if (IS_ERR(tfm)) {
1790 printk(KERN_ERR "alg: hash: Failed to load transform for %s: "
1791 "%ld\n", driver, PTR_ERR(tfm));
1792 return PTR_ERR(tfm);
1793 }
1794
1795 err = test_hash(tfm, desc->suite.hash.vecs, desc->suite.hash.count);
1796
1797 crypto_free_ahash(tfm);
1798 return err;
1799 }
1800
1801 static int alg_test_crc32c(const struct alg_test_desc *desc,
1802 const char *driver, u32 type, u32 mask)
1803 {
1804 struct crypto_shash *tfm;
1805 u32 val;
1806 int err;
1807
1808 err = alg_test_hash(desc, driver, type, mask);
1809 if (err)
1810 goto out;
1811
1812 tfm = crypto_alloc_shash(driver, type, mask);
1813 if (IS_ERR(tfm)) {
1814 printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: "
1815 "%ld\n", driver, PTR_ERR(tfm));
1816 err = PTR_ERR(tfm);
1817 goto out;
1818 }
1819
1820 do {
1821 struct {
1822 struct shash_desc shash;
1823 char ctx[crypto_shash_descsize(tfm)];
1824 } sdesc;
1825
1826 sdesc.shash.tfm = tfm;
1827 sdesc.shash.flags = 0;
1828
1829 *(u32 *)sdesc.ctx = le32_to_cpu(420553207);
1830 err = crypto_shash_final(&sdesc.shash, (u8 *)&val);
1831 if (err) {
1832 printk(KERN_ERR "alg: crc32c: Operation failed for "
1833 "%s: %d\n", driver, err);
1834 break;
1835 }
1836
1837 if (val != ~420553207) {
1838 printk(KERN_ERR "alg: crc32c: Test failed for %s: "
1839 "%d\n", driver, val);
1840 err = -EINVAL;
1841 }
1842 } while (0);
1843
1844 crypto_free_shash(tfm);
1845
1846 out:
1847 return err;
1848 }
1849
1850 static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver,
1851 u32 type, u32 mask)
1852 {
1853 struct crypto_rng *rng;
1854 int err = 0;
1855
1856 rng = crypto_alloc_rng(driver, type, mask);
1857 if (IS_ERR(rng)) {
1858 printk(KERN_ERR "alg: cprng: Failed to load transform for %s: "
1859 "%ld\n", driver, PTR_ERR(rng));
1860 return PTR_ERR(rng);
1861 }
1862
1863 err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count);
1864
1865 crypto_free_rng(rng);
1866
1867 return err;
1868 }
1869
1870 /* Please keep this list sorted by algorithm name. */
1871 static const struct alg_test_desc alg_test_descs[] = {
1872 {
1873 .alg = "ansi_cprng",
1874 .test = alg_test_cprng,
1875 .fips_allowed = 1,
1876 .suite = {
1877 .cprng = {
1878 .vecs = ansi_cprng_aes_tv_template,
1879 .count = ANSI_CPRNG_AES_TEST_VECTORS
1880 }
1881 }
1882 }, {
1883 .alg = "cbc(aes)",
1884 .test = alg_test_skcipher,
1885 .fips_allowed = 1,
1886 .suite = {
1887 .cipher = {
1888 .enc = {
1889 .vecs = aes_cbc_enc_tv_template,
1890 .count = AES_CBC_ENC_TEST_VECTORS
1891 },
1892 .dec = {
1893 .vecs = aes_cbc_dec_tv_template,
1894 .count = AES_CBC_DEC_TEST_VECTORS
1895 }
1896 }
1897 }
1898 }, {
1899 .alg = "cbc(anubis)",
1900 .test = alg_test_skcipher,
1901 .suite = {
1902 .cipher = {
1903 .enc = {
1904 .vecs = anubis_cbc_enc_tv_template,
1905 .count = ANUBIS_CBC_ENC_TEST_VECTORS
1906 },
1907 .dec = {
1908 .vecs = anubis_cbc_dec_tv_template,
1909 .count = ANUBIS_CBC_DEC_TEST_VECTORS
1910 }
1911 }
1912 }
1913 }, {
1914 .alg = "cbc(blowfish)",
1915 .test = alg_test_skcipher,
1916 .suite = {
1917 .cipher = {
1918 .enc = {
1919 .vecs = bf_cbc_enc_tv_template,
1920 .count = BF_CBC_ENC_TEST_VECTORS
1921 },
1922 .dec = {
1923 .vecs = bf_cbc_dec_tv_template,
1924 .count = BF_CBC_DEC_TEST_VECTORS
1925 }
1926 }
1927 }
1928 }, {
1929 .alg = "cbc(camellia)",
1930 .test = alg_test_skcipher,
1931 .suite = {
1932 .cipher = {
1933 .enc = {
1934 .vecs = camellia_cbc_enc_tv_template,
1935 .count = CAMELLIA_CBC_ENC_TEST_VECTORS
1936 },
1937 .dec = {
1938 .vecs = camellia_cbc_dec_tv_template,
1939 .count = CAMELLIA_CBC_DEC_TEST_VECTORS
1940 }
1941 }
1942 }
1943 }, {
1944 .alg = "cbc(des)",
1945 .test = alg_test_skcipher,
1946 .suite = {
1947 .cipher = {
1948 .enc = {
1949 .vecs = des_cbc_enc_tv_template,
1950 .count = DES_CBC_ENC_TEST_VECTORS
1951 },
1952 .dec = {
1953 .vecs = des_cbc_dec_tv_template,
1954 .count = DES_CBC_DEC_TEST_VECTORS
1955 }
1956 }
1957 }
1958 }, {
1959 .alg = "cbc(des3_ede)",
1960 .test = alg_test_skcipher,
1961 .fips_allowed = 1,
1962 .suite = {
1963 .cipher = {
1964 .enc = {
1965 .vecs = des3_ede_cbc_enc_tv_template,
1966 .count = DES3_EDE_CBC_ENC_TEST_VECTORS
1967 },
1968 .dec = {
1969 .vecs = des3_ede_cbc_dec_tv_template,
1970 .count = DES3_EDE_CBC_DEC_TEST_VECTORS
1971 }
1972 }
1973 }
1974 }, {
1975 .alg = "cbc(twofish)",
1976 .test = alg_test_skcipher,
1977 .suite = {
1978 .cipher = {
1979 .enc = {
1980 .vecs = tf_cbc_enc_tv_template,
1981 .count = TF_CBC_ENC_TEST_VECTORS
1982 },
1983 .dec = {
1984 .vecs = tf_cbc_dec_tv_template,
1985 .count = TF_CBC_DEC_TEST_VECTORS
1986 }
1987 }
1988 }
1989 }, {
1990 .alg = "ccm(aes)",
1991 .test = alg_test_aead,
1992 .fips_allowed = 1,
1993 .suite = {
1994 .aead = {
1995 .enc = {
1996 .vecs = aes_ccm_enc_tv_template,
1997 .count = AES_CCM_ENC_TEST_VECTORS
1998 },
1999 .dec = {
2000 .vecs = aes_ccm_dec_tv_template,
2001 .count = AES_CCM_DEC_TEST_VECTORS
2002 }
2003 }
2004 }
2005 }, {
2006 .alg = "crc32c",
2007 .test = alg_test_crc32c,
2008 .fips_allowed = 1,
2009 .suite = {
2010 .hash = {
2011 .vecs = crc32c_tv_template,
2012 .count = CRC32C_TEST_VECTORS
2013 }
2014 }
2015 }, {
2016 .alg = "ctr(aes)",
2017 .test = alg_test_skcipher,
2018 .fips_allowed = 1,
2019 .suite = {
2020 .cipher = {
2021 .enc = {
2022 .vecs = aes_ctr_enc_tv_template,
2023 .count = AES_CTR_ENC_TEST_VECTORS
2024 },
2025 .dec = {
2026 .vecs = aes_ctr_dec_tv_template,
2027 .count = AES_CTR_DEC_TEST_VECTORS
2028 }
2029 }
2030 }
2031 }, {
2032 .alg = "cts(cbc(aes))",
2033 .test = alg_test_skcipher,
2034 .suite = {
2035 .cipher = {
2036 .enc = {
2037 .vecs = cts_mode_enc_tv_template,
2038 .count = CTS_MODE_ENC_TEST_VECTORS
2039 },
2040 .dec = {
2041 .vecs = cts_mode_dec_tv_template,
2042 .count = CTS_MODE_DEC_TEST_VECTORS
2043 }
2044 }
2045 }
2046 }, {
2047 .alg = "deflate",
2048 .test = alg_test_comp,
2049 .suite = {
2050 .comp = {
2051 .comp = {
2052 .vecs = deflate_comp_tv_template,
2053 .count = DEFLATE_COMP_TEST_VECTORS
2054 },
2055 .decomp = {
2056 .vecs = deflate_decomp_tv_template,
2057 .count = DEFLATE_DECOMP_TEST_VECTORS
2058 }
2059 }
2060 }
2061 }, {
2062 .alg = "ecb(aes)",
2063 .test = alg_test_skcipher,
2064 .fips_allowed = 1,
2065 .suite = {
2066 .cipher = {
2067 .enc = {
2068 .vecs = aes_enc_tv_template,
2069 .count = AES_ENC_TEST_VECTORS
2070 },
2071 .dec = {
2072 .vecs = aes_dec_tv_template,
2073 .count = AES_DEC_TEST_VECTORS
2074 }
2075 }
2076 }
2077 }, {
2078 .alg = "ecb(anubis)",
2079 .test = alg_test_skcipher,
2080 .suite = {
2081 .cipher = {
2082 .enc = {
2083 .vecs = anubis_enc_tv_template,
2084 .count = ANUBIS_ENC_TEST_VECTORS
2085 },
2086 .dec = {
2087 .vecs = anubis_dec_tv_template,
2088 .count = ANUBIS_DEC_TEST_VECTORS
2089 }
2090 }
2091 }
2092 }, {
2093 .alg = "ecb(arc4)",
2094 .test = alg_test_skcipher,
2095 .suite = {
2096 .cipher = {
2097 .enc = {
2098 .vecs = arc4_enc_tv_template,
2099 .count = ARC4_ENC_TEST_VECTORS
2100 },
2101 .dec = {
2102 .vecs = arc4_dec_tv_template,
2103 .count = ARC4_DEC_TEST_VECTORS
2104 }
2105 }
2106 }
2107 }, {
2108 .alg = "ecb(blowfish)",
2109 .test = alg_test_skcipher,
2110 .suite = {
2111 .cipher = {
2112 .enc = {
2113 .vecs = bf_enc_tv_template,
2114 .count = BF_ENC_TEST_VECTORS
2115 },
2116 .dec = {
2117 .vecs = bf_dec_tv_template,
2118 .count = BF_DEC_TEST_VECTORS
2119 }
2120 }
2121 }
2122 }, {
2123 .alg = "ecb(camellia)",
2124 .test = alg_test_skcipher,
2125 .suite = {
2126 .cipher = {
2127 .enc = {
2128 .vecs = camellia_enc_tv_template,
2129 .count = CAMELLIA_ENC_TEST_VECTORS
2130 },
2131 .dec = {
2132 .vecs = camellia_dec_tv_template,
2133 .count = CAMELLIA_DEC_TEST_VECTORS
2134 }
2135 }
2136 }
2137 }, {
2138 .alg = "ecb(cast5)",
2139 .test = alg_test_skcipher,
2140 .suite = {
2141 .cipher = {
2142 .enc = {
2143 .vecs = cast5_enc_tv_template,
2144 .count = CAST5_ENC_TEST_VECTORS
2145 },
2146 .dec = {
2147 .vecs = cast5_dec_tv_template,
2148 .count = CAST5_DEC_TEST_VECTORS
2149 }
2150 }
2151 }
2152 }, {
2153 .alg = "ecb(cast6)",
2154 .test = alg_test_skcipher,
2155 .suite = {
2156 .cipher = {
2157 .enc = {
2158 .vecs = cast6_enc_tv_template,
2159 .count = CAST6_ENC_TEST_VECTORS
2160 },
2161 .dec = {
2162 .vecs = cast6_dec_tv_template,
2163 .count = CAST6_DEC_TEST_VECTORS
2164 }
2165 }
2166 }
2167 }, {
2168 .alg = "ecb(des)",
2169 .test = alg_test_skcipher,
2170 .fips_allowed = 1,
2171 .suite = {
2172 .cipher = {
2173 .enc = {
2174 .vecs = des_enc_tv_template,
2175 .count = DES_ENC_TEST_VECTORS
2176 },
2177 .dec = {
2178 .vecs = des_dec_tv_template,
2179 .count = DES_DEC_TEST_VECTORS
2180 }
2181 }
2182 }
2183 }, {
2184 .alg = "ecb(des3_ede)",
2185 .test = alg_test_skcipher,
2186 .fips_allowed = 1,
2187 .suite = {
2188 .cipher = {
2189 .enc = {
2190 .vecs = des3_ede_enc_tv_template,
2191 .count = DES3_EDE_ENC_TEST_VECTORS
2192 },
2193 .dec = {
2194 .vecs = des3_ede_dec_tv_template,
2195 .count = DES3_EDE_DEC_TEST_VECTORS
2196 }
2197 }
2198 }
2199 }, {
2200 .alg = "ecb(khazad)",
2201 .test = alg_test_skcipher,
2202 .suite = {
2203 .cipher = {
2204 .enc = {
2205 .vecs = khazad_enc_tv_template,
2206 .count = KHAZAD_ENC_TEST_VECTORS
2207 },
2208 .dec = {
2209 .vecs = khazad_dec_tv_template,
2210 .count = KHAZAD_DEC_TEST_VECTORS
2211 }
2212 }
2213 }
2214 }, {
2215 .alg = "ecb(seed)",
2216 .test = alg_test_skcipher,
2217 .suite = {
2218 .cipher = {
2219 .enc = {
2220 .vecs = seed_enc_tv_template,
2221 .count = SEED_ENC_TEST_VECTORS
2222 },
2223 .dec = {
2224 .vecs = seed_dec_tv_template,
2225 .count = SEED_DEC_TEST_VECTORS
2226 }
2227 }
2228 }
2229 }, {
2230 .alg = "ecb(serpent)",
2231 .test = alg_test_skcipher,
2232 .suite = {
2233 .cipher = {
2234 .enc = {
2235 .vecs = serpent_enc_tv_template,
2236 .count = SERPENT_ENC_TEST_VECTORS
2237 },
2238 .dec = {
2239 .vecs = serpent_dec_tv_template,
2240 .count = SERPENT_DEC_TEST_VECTORS
2241 }
2242 }
2243 }
2244 }, {
2245 .alg = "ecb(tea)",
2246 .test = alg_test_skcipher,
2247 .suite = {
2248 .cipher = {
2249 .enc = {
2250 .vecs = tea_enc_tv_template,
2251 .count = TEA_ENC_TEST_VECTORS
2252 },
2253 .dec = {
2254 .vecs = tea_dec_tv_template,
2255 .count = TEA_DEC_TEST_VECTORS
2256 }
2257 }
2258 }
2259 }, {
2260 .alg = "ecb(tnepres)",
2261 .test = alg_test_skcipher,
2262 .suite = {
2263 .cipher = {
2264 .enc = {
2265 .vecs = tnepres_enc_tv_template,
2266 .count = TNEPRES_ENC_TEST_VECTORS
2267 },
2268 .dec = {
2269 .vecs = tnepres_dec_tv_template,
2270 .count = TNEPRES_DEC_TEST_VECTORS
2271 }
2272 }
2273 }
2274 }, {
2275 .alg = "ecb(twofish)",
2276 .test = alg_test_skcipher,
2277 .suite = {
2278 .cipher = {
2279 .enc = {
2280 .vecs = tf_enc_tv_template,
2281 .count = TF_ENC_TEST_VECTORS
2282 },
2283 .dec = {
2284 .vecs = tf_dec_tv_template,
2285 .count = TF_DEC_TEST_VECTORS
2286 }
2287 }
2288 }
2289 }, {
2290 .alg = "ecb(xeta)",
2291 .test = alg_test_skcipher,
2292 .suite = {
2293 .cipher = {
2294 .enc = {
2295 .vecs = xeta_enc_tv_template,
2296 .count = XETA_ENC_TEST_VECTORS
2297 },
2298 .dec = {
2299 .vecs = xeta_dec_tv_template,
2300 .count = XETA_DEC_TEST_VECTORS
2301 }
2302 }
2303 }
2304 }, {
2305 .alg = "ecb(xtea)",
2306 .test = alg_test_skcipher,
2307 .suite = {
2308 .cipher = {
2309 .enc = {
2310 .vecs = xtea_enc_tv_template,
2311 .count = XTEA_ENC_TEST_VECTORS
2312 },
2313 .dec = {
2314 .vecs = xtea_dec_tv_template,
2315 .count = XTEA_DEC_TEST_VECTORS
2316 }
2317 }
2318 }
2319 }, {
2320 .alg = "gcm(aes)",
2321 .test = alg_test_aead,
2322 .fips_allowed = 1,
2323 .suite = {
2324 .aead = {
2325 .enc = {
2326 .vecs = aes_gcm_enc_tv_template,
2327 .count = AES_GCM_ENC_TEST_VECTORS
2328 },
2329 .dec = {
2330 .vecs = aes_gcm_dec_tv_template,
2331 .count = AES_GCM_DEC_TEST_VECTORS
2332 }
2333 }
2334 }
2335 }, {
2336 .alg = "hmac(md5)",
2337 .test = alg_test_hash,
2338 .suite = {
2339 .hash = {
2340 .vecs = hmac_md5_tv_template,
2341 .count = HMAC_MD5_TEST_VECTORS
2342 }
2343 }
2344 }, {
2345 .alg = "hmac(rmd128)",
2346 .test = alg_test_hash,
2347 .suite = {
2348 .hash = {
2349 .vecs = hmac_rmd128_tv_template,
2350 .count = HMAC_RMD128_TEST_VECTORS
2351 }
2352 }
2353 }, {
2354 .alg = "hmac(rmd160)",
2355 .test = alg_test_hash,
2356 .suite = {
2357 .hash = {
2358 .vecs = hmac_rmd160_tv_template,
2359 .count = HMAC_RMD160_TEST_VECTORS
2360 }
2361 }
2362 }, {
2363 .alg = "hmac(sha1)",
2364 .test = alg_test_hash,
2365 .fips_allowed = 1,
2366 .suite = {
2367 .hash = {
2368 .vecs = hmac_sha1_tv_template,
2369 .count = HMAC_SHA1_TEST_VECTORS
2370 }
2371 }
2372 }, {
2373 .alg = "hmac(sha224)",
2374 .test = alg_test_hash,
2375 .fips_allowed = 1,
2376 .suite = {
2377 .hash = {
2378 .vecs = hmac_sha224_tv_template,
2379 .count = HMAC_SHA224_TEST_VECTORS
2380 }
2381 }
2382 }, {
2383 .alg = "hmac(sha256)",
2384 .test = alg_test_hash,
2385 .fips_allowed = 1,
2386 .suite = {
2387 .hash = {
2388 .vecs = hmac_sha256_tv_template,
2389 .count = HMAC_SHA256_TEST_VECTORS
2390 }
2391 }
2392 }, {
2393 .alg = "hmac(sha384)",
2394 .test = alg_test_hash,
2395 .fips_allowed = 1,
2396 .suite = {
2397 .hash = {
2398 .vecs = hmac_sha384_tv_template,
2399 .count = HMAC_SHA384_TEST_VECTORS
2400 }
2401 }
2402 }, {
2403 .alg = "hmac(sha512)",
2404 .test = alg_test_hash,
2405 .fips_allowed = 1,
2406 .suite = {
2407 .hash = {
2408 .vecs = hmac_sha512_tv_template,
2409 .count = HMAC_SHA512_TEST_VECTORS
2410 }
2411 }
2412 #if !defined(CONFIG_CRYPTO_DEV_AES) && !defined(CONFIG_CRYPTO_ASYNC_AES)
2413 }, {
2414 .alg = "lrw(aes)",
2415 .test = alg_test_skcipher,
2416 .suite = {
2417 .cipher = {
2418 .enc = {
2419 .vecs = aes_lrw_enc_tv_template,
2420 .count = AES_LRW_ENC_TEST_VECTORS
2421 },
2422 .dec = {
2423 .vecs = aes_lrw_dec_tv_template,
2424 .count = AES_LRW_DEC_TEST_VECTORS
2425 }
2426 }
2427 }
2428 #endif
2429 }, {
2430 .alg = "lzo",
2431 .test = alg_test_comp,
2432 .suite = {
2433 .comp = {
2434 .comp = {
2435 .vecs = lzo_comp_tv_template,
2436 .count = LZO_COMP_TEST_VECTORS
2437 },
2438 .decomp = {
2439 .vecs = lzo_decomp_tv_template,
2440 .count = LZO_DECOMP_TEST_VECTORS
2441 }
2442 }
2443 }
2444 }, {
2445 .alg = "md4",
2446 .test = alg_test_hash,
2447 .suite = {
2448 .hash = {
2449 .vecs = md4_tv_template,
2450 .count = MD4_TEST_VECTORS
2451 }
2452 }
2453 }, {
2454 .alg = "md5",
2455 .test = alg_test_hash,
2456 .suite = {
2457 .hash = {
2458 .vecs = md5_tv_template,
2459 .count = MD5_TEST_VECTORS
2460 }
2461 }
2462 }, {
2463 .alg = "michael_mic",
2464 .test = alg_test_hash,
2465 .suite = {
2466 .hash = {
2467 .vecs = michael_mic_tv_template,
2468 .count = MICHAEL_MIC_TEST_VECTORS
2469 }
2470 }
2471 }, {
2472 .alg = "pcbc(fcrypt)",
2473 .test = alg_test_skcipher,
2474 .suite = {
2475 .cipher = {
2476 .enc = {
2477 .vecs = fcrypt_pcbc_enc_tv_template,
2478 .count = FCRYPT_ENC_TEST_VECTORS
2479 },
2480 .dec = {
2481 .vecs = fcrypt_pcbc_dec_tv_template,
2482 .count = FCRYPT_DEC_TEST_VECTORS
2483 }
2484 }
2485 }
2486
2487 }, {
2488 .alg = "rfc3686(ctr(aes))",
2489 .test = alg_test_skcipher,
2490 .fips_allowed = 1,
2491 .suite = {
2492 .cipher = {
2493 .enc = {
2494 .vecs = aes_ctr_rfc3686_enc_tv_template,
2495 .count = AES_CTR_3686_ENC_TEST_VECTORS
2496 },
2497 .dec = {
2498 .vecs = aes_ctr_rfc3686_dec_tv_template,
2499 .count = AES_CTR_3686_DEC_TEST_VECTORS
2500 }
2501 }
2502 }
2503 }, {
2504 .alg = "rfc4309(ccm(aes))",
2505 .test = alg_test_aead,
2506 .fips_allowed = 1,
2507 .suite = {
2508 .aead = {
2509 .enc = {
2510 .vecs = aes_ccm_rfc4309_enc_tv_template,
2511 .count = AES_CCM_4309_ENC_TEST_VECTORS
2512 },
2513 .dec = {
2514 .vecs = aes_ccm_rfc4309_dec_tv_template,
2515 .count = AES_CCM_4309_DEC_TEST_VECTORS
2516 }
2517 }
2518 }
2519 }, {
2520 .alg = "rmd128",
2521 .test = alg_test_hash,
2522 .suite = {
2523 .hash = {
2524 .vecs = rmd128_tv_template,
2525 .count = RMD128_TEST_VECTORS
2526 }
2527 }
2528 }, {
2529 .alg = "rmd160",
2530 .test = alg_test_hash,
2531 .suite = {
2532 .hash = {
2533 .vecs = rmd160_tv_template,
2534 .count = RMD160_TEST_VECTORS
2535 }
2536 }
2537 }, {
2538 .alg = "rmd256",
2539 .test = alg_test_hash,
2540 .suite = {
2541 .hash = {
2542 .vecs = rmd256_tv_template,
2543 .count = RMD256_TEST_VECTORS
2544 }
2545 }
2546 }, {
2547 .alg = "rmd320",
2548 .test = alg_test_hash,
2549 .suite = {
2550 .hash = {
2551 .vecs = rmd320_tv_template,
2552 .count = RMD320_TEST_VECTORS
2553 }
2554 }
2555 }, {
2556 .alg = "salsa20",
2557 .test = alg_test_skcipher,
2558 .suite = {
2559 .cipher = {
2560 .enc = {
2561 .vecs = salsa20_stream_enc_tv_template,
2562 .count = SALSA20_STREAM_ENC_TEST_VECTORS
2563 }
2564 }
2565 }
2566 }, {
2567 .alg = "sha1",
2568 .test = alg_test_hash,
2569 .fips_allowed = 1,
2570 .suite = {
2571 .hash = {
2572 .vecs = sha1_tv_template,
2573 .count = SHA1_TEST_VECTORS
2574 }
2575 }
2576 }, {
2577 .alg = "sha224",
2578 .test = alg_test_hash,
2579 .fips_allowed = 1,
2580 .suite = {
2581 .hash = {
2582 .vecs = sha224_tv_template,
2583 .count = SHA224_TEST_VECTORS
2584 }
2585 }
2586 }, {
2587 .alg = "sha256",
2588 .test = alg_test_hash,
2589 .fips_allowed = 1,
2590 .suite = {
2591 .hash = {
2592 .vecs = sha256_tv_template,
2593 .count = SHA256_TEST_VECTORS
2594 }
2595 }
2596 }, {
2597 .alg = "sha384",
2598 .test = alg_test_hash,
2599 .fips_allowed = 1,
2600 .suite = {
2601 .hash = {
2602 .vecs = sha384_tv_template,
2603 .count = SHA384_TEST_VECTORS
2604 }
2605 }
2606 }, {
2607 .alg = "sha512",
2608 .test = alg_test_hash,
2609 .fips_allowed = 1,
2610 .suite = {
2611 .hash = {
2612 .vecs = sha512_tv_template,
2613 .count = SHA512_TEST_VECTORS
2614 }
2615 }
2616 }, {
2617 .alg = "tgr128",
2618 .test = alg_test_hash,
2619 .suite = {
2620 .hash = {
2621 .vecs = tgr128_tv_template,
2622 .count = TGR128_TEST_VECTORS
2623 }
2624 }
2625 }, {
2626 .alg = "tgr160",
2627 .test = alg_test_hash,
2628 .suite = {
2629 .hash = {
2630 .vecs = tgr160_tv_template,
2631 .count = TGR160_TEST_VECTORS
2632 }
2633 }
2634 }, {
2635 .alg = "tgr192",
2636 .test = alg_test_hash,
2637 .suite = {
2638 .hash = {
2639 .vecs = tgr192_tv_template,
2640 .count = TGR192_TEST_VECTORS
2641 }
2642 }
2643 }, {
2644 .alg = "vmac(aes)",
2645 .test = alg_test_hash,
2646 .suite = {
2647 .hash = {
2648 .vecs = aes_vmac128_tv_template,
2649 .count = VMAC_AES_TEST_VECTORS
2650 }
2651 }
2652 }, {
2653 .alg = "wp256",
2654 .test = alg_test_hash,
2655 .suite = {
2656 .hash = {
2657 .vecs = wp256_tv_template,
2658 .count = WP256_TEST_VECTORS
2659 }
2660 }
2661 }, {
2662 .alg = "wp384",
2663 .test = alg_test_hash,
2664 .suite = {
2665 .hash = {
2666 .vecs = wp384_tv_template,
2667 .count = WP384_TEST_VECTORS
2668 }
2669 }
2670 }, {
2671 .alg = "wp512",
2672 .test = alg_test_hash,
2673 .suite = {
2674 .hash = {
2675 .vecs = wp512_tv_template,
2676 .count = WP512_TEST_VECTORS
2677 }
2678 }
2679 }, {
2680 .alg = "xcbc(aes)",
2681 .test = alg_test_hash,
2682 .suite = {
2683 .hash = {
2684 .vecs = aes_xcbc128_tv_template,
2685 .count = XCBC_AES_TEST_VECTORS
2686 }
2687 }
2688 #if 0
2689 }, {
2690 .alg = "xts(aes)",
2691 .test = alg_test_skcipher,
2692 .suite = {
2693 .cipher = {
2694 .enc = {
2695 .vecs = aes_xts_enc_tv_template,
2696 .count = AES_XTS_ENC_TEST_VECTORS
2697 },
2698 .dec = {
2699 .vecs = aes_xts_dec_tv_template,
2700 .count = AES_XTS_DEC_TEST_VECTORS
2701 }
2702 }
2703 }
2704 #endif
2705 }, {
2706 .alg = "zlib",
2707 .test = alg_test_pcomp,
2708 .suite = {
2709 .pcomp = {
2710 .comp = {
2711 .vecs = zlib_comp_tv_template,
2712 .count = ZLIB_COMP_TEST_VECTORS
2713 },
2714 .decomp = {
2715 .vecs = zlib_decomp_tv_template,
2716 .count = ZLIB_DECOMP_TEST_VECTORS
2717 }
2718 }
2719 }
2720 }
2721 };
2722
2723 static int alg_find_test(const char *alg)
2724 {
2725 int start = 0;
2726 int end = ARRAY_SIZE(alg_test_descs);
2727
2728 while (start < end) {
2729 int i = (start + end) / 2;
2730 int diff = strcmp(alg_test_descs[i].alg, alg);
2731
2732 if (diff > 0) {
2733 end = i;
2734 continue;
2735 }
2736
2737 if (diff < 0) {
2738 start = i + 1;
2739 continue;
2740 }
2741
2742 return i;
2743 }
2744
2745 return -1;
2746 }
2747
2748 static int ifx_alg_test(const char *driver, const char *alg, u32 type, u32 mask)
2749 {
2750 int i;
2751 int j;
2752 int rc;
2753
2754 if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) {
2755 char nalg[CRYPTO_MAX_ALG_NAME];
2756
2757 if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >=
2758 sizeof(nalg))
2759 return -ENAMETOOLONG;
2760
2761 i = alg_find_test(nalg);
2762 if (i < 0)
2763 goto notest;
2764
2765 if (fips_enabled && !alg_test_descs[i].fips_allowed)
2766 goto non_fips_alg;
2767
2768 rc = alg_test_cipher(alg_test_descs + i, driver, type, mask);
2769 goto test_done;
2770 }
2771
2772 i = alg_find_test(alg);
2773 j = alg_find_test(driver);
2774 if (i < 0 && j < 0)
2775 goto notest;
2776
2777 if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) ||
2778 (j >= 0 && !alg_test_descs[j].fips_allowed)))
2779 goto non_fips_alg;
2780
2781 rc = 0;
2782 if (i >= 0)
2783 rc |= alg_test_descs[i].test(alg_test_descs + i, driver,
2784 type, mask);
2785 if (j >= 0)
2786 rc |= alg_test_descs[j].test(alg_test_descs + j, driver,
2787 type, mask);
2788
2789 test_done:
2790 if (fips_enabled && rc)
2791 panic("%s: %s alg self test failed in fips mode!\n", driver, alg);
2792
2793 if (fips_enabled && !rc)
2794 printk(KERN_INFO "alg: self-tests for %s (%s) passed\n",
2795 driver, alg);
2796
2797 return rc;
2798
2799 notest:
2800 printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
2801 return 0;
2802 non_fips_alg:
2803 return -EINVAL;
2804 }
2805 EXPORT_SYMBOL_GPL(ifx_alg_test);
2806
2807 /* Modified speed test for async block cipher mode*/
2808
2809 static int ifx_alg_speed_test(const char *driver, const char *alg,
2810 unsigned int sec,
2811 struct cipher_speed_template *template,
2812 unsigned int tcount, u8 *keysize)
2813 {
2814 int i;
2815 int j;
2816 int err;
2817 int type = 0, mask = 0;
2818 struct crypto_ablkcipher *tfm;
2819
2820 i = alg_find_test(alg);
2821 j = alg_find_test(driver);
2822
2823 if (i < 0 && j < 0)
2824 goto notest;
2825
2826 if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) ||
2827 (j >= 0 && !alg_test_descs[j].fips_allowed)))
2828 goto non_fips_alg;
2829
2830 tfm = crypto_alloc_ablkcipher(driver, type, mask);
2831
2832 if (IS_ERR(tfm)) {
2833 printk(KERN_ERR "alg: skcipher: Failed to load transform for "
2834 "%s: %ld\n", driver, PTR_ERR(tfm));
2835 return PTR_ERR(tfm);
2836 }
2837 err = test_skcipher_speed(tfm, ENCRYPT, template,
2838 tcount, sec, keysize);
2839 if (err)
2840 goto test_done;
2841
2842 err = test_skcipher_speed(tfm, DECRYPT, template,
2843 tcount, sec, keysize);
2844 if (!err)
2845 goto test_done;
2846
2847 notest:
2848 return 0;
2849 non_fips_alg:
2850 return -EINVAL;
2851
2852 test_done:
2853 if (fips_enabled && err)
2854 panic("%s: %s alg self test failed in fips mode!\n", driver, alg);
2855
2856 if (fips_enabled && !err)
2857 printk(KERN_INFO "alg: self-tests for %s (%s) passed\n",
2858 driver, alg);
2859
2860 crypto_free_ablkcipher(tfm);
2861 return err;
2862 }
2863 EXPORT_SYMBOL_GPL(ifx_alg_speed_test);
2864
2865
2866 static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc,
2867 struct scatterlist *sg, int blen, int sec)
2868 {
2869 unsigned long start, end;
2870 int bcount;
2871 int ret;
2872
2873 for (start = jiffies, end = start + sec * HZ, bcount = 0;
2874 time_before(jiffies, end); bcount++) {
2875 if (enc)
2876 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
2877 else
2878 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
2879
2880 if (ret)
2881 return ret;
2882 }
2883
2884 printk("%d operations in %d seconds (%ld bytes)\n",
2885 bcount, sec, (long)bcount * blen);
2886 return 0;
2887 }
2888
2889 static int test_cipher_cycles(struct blkcipher_desc *desc, int enc,
2890 struct scatterlist *sg, int blen)
2891 {
2892 unsigned long cycles = 0;
2893 unsigned long start, end;
2894 int ret = 0;
2895 int i;
2896
2897 local_bh_disable();
2898 local_irq_disable();
2899
2900 /* Warm-up run. */
2901 for (i = 0; i < 4; i++) {
2902 if (enc)
2903 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
2904 else
2905 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
2906
2907 if (ret)
2908 goto out;
2909 }
2910
2911 /* The real thing. */
2912 for (i = 0; i < 8; i++) {
2913 /* Original code to get cycles, does not work with MIPS
2914 * cycles_t start, end;
2915 * start = get_cycles();
2916 */
2917
2918 start = read_c0_count(); // LQ modified tcrypt
2919
2920 if (enc)
2921 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
2922 else
2923 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
2924
2925 /* Original code to get cycles, does not work with MIPS
2926 * end = get_cycles();
2927 */
2928
2929 end = read_c0_count(); //LQ modified tcrypt
2930
2931 if (ret)
2932 goto out;
2933
2934 cycles += end - start;
2935 }
2936
2937 out:
2938 local_irq_enable();
2939 local_bh_enable();
2940
2941 if (ret == 0)
2942 printk("1 operation in %lu cycles (%d bytes)\n",
2943 (cycles + 4) / 8, blen);
2944
2945 return ret;
2946 }
2947
2948 static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 };
2949
2950 static void test_cipher_speed(const char *algo, int enc, unsigned int sec,
2951 struct cipher_speed_template *template,
2952 unsigned int tcount, u8 *keysize)
2953 {
2954 unsigned int ret, i, j, iv_len;
2955 const char *key, iv[128];
2956 struct crypto_blkcipher *tfm;
2957 struct blkcipher_desc desc;
2958 const char *e;
2959 u32 *b_size;
2960
2961 if (enc == ENCRYPT)
2962 e = "encryption";
2963 else
2964 e = "decryption";
2965
2966 printk("\n ******* testing speed of %s %s ******* \n", algo, e);
2967
2968 tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);
2969
2970 if (IS_ERR(tfm)) {
2971 printk("failed to load transform for %s: %ld\n", algo,
2972 PTR_ERR(tfm));
2973 return;
2974 }
2975 desc.tfm = tfm;
2976 desc.flags = 0;
2977
2978 i = 0;
2979 do {
2980
2981 b_size = block_sizes;
2982 do {
2983 struct scatterlist sg[TVMEMSIZE];
2984
2985 if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
2986 printk("template (%u) too big for "
2987 "tvmem (%lu)\n", *keysize + *b_size,
2988 TVMEMSIZE * PAGE_SIZE);
2989 goto out;
2990 }
2991
2992 printk("test %u (%d bit key, %d byte blocks): ", i,
2993 *keysize * 8, *b_size);
2994
2995 memset(tvmem[0], 0xff, PAGE_SIZE);
2996
2997 /* set key, plain text and IV */
2998 key = tvmem[0];
2999 for (j = 0; j < tcount; j++) {
3000 if (template[j].klen == *keysize) {
3001 key = template[j].key;
3002 break;
3003 }
3004 }
3005
3006 ret = crypto_blkcipher_setkey(tfm, key, *keysize);
3007 if (ret) {
3008 printk("setkey() failed flags=%x\n",
3009 crypto_blkcipher_get_flags(tfm));
3010 goto out;
3011 }
3012
3013 sg_init_table(sg, TVMEMSIZE);
3014 sg_set_buf(sg, tvmem[0] + *keysize,
3015 PAGE_SIZE - *keysize);
3016 for (j = 1; j < TVMEMSIZE; j++) {
3017 sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
3018 memset (tvmem[j], 0xff, PAGE_SIZE);
3019 }
3020
3021 iv_len = crypto_blkcipher_ivsize(tfm);
3022 if (iv_len) {
3023 memset(&iv, 0xff, iv_len);
3024 crypto_blkcipher_set_iv(tfm, iv, iv_len);
3025 }
3026
3027 if (sec)
3028 ret = test_cipher_jiffies(&desc, enc, sg,
3029 *b_size, sec);
3030 else
3031 ret = test_cipher_cycles(&desc, enc, sg,
3032 *b_size);
3033
3034 if (ret) {
3035 printk("%s() failed flags=%x\n", e, desc.flags);
3036 break;
3037 }
3038 b_size++;
3039 i++;
3040 } while (*b_size);
3041 keysize++;
3042 } while (*keysize);
3043
3044 out:
3045 crypto_free_blkcipher(tfm);
3046 }
3047
3048 static int test_hash_jiffies_digest(struct hash_desc *desc,
3049 struct scatterlist *sg, int blen,
3050 char *out, int sec)
3051 {
3052 unsigned long start, end;
3053 int bcount;
3054 int ret;
3055
3056 for (start = jiffies, end = start + sec * HZ, bcount = 0;
3057 time_before(jiffies, end); bcount++) {
3058 ret = crypto_hash_digest(desc, sg, blen, out);
3059 if (ret)
3060 return ret;
3061 }
3062
3063 printk("%6u opers/sec, %9lu bytes/sec\n",
3064 bcount / sec, ((long)bcount * blen) / sec);
3065
3066 return 0;
3067 }
3068
3069 static int test_hash_jiffies(struct hash_desc *desc, struct scatterlist *sg,
3070 int blen, int plen, char *out, int sec)
3071 {
3072 unsigned long start, end;
3073 int bcount, pcount;
3074 int ret;
3075
3076 if (plen == blen)
3077 return test_hash_jiffies_digest(desc, sg, blen, out, sec);
3078
3079 for (start = jiffies, end = start + sec * HZ, bcount = 0;
3080 time_before(jiffies, end); bcount++) {
3081 ret = crypto_hash_init(desc);
3082 if (ret)
3083 return ret;
3084 for (pcount = 0; pcount < blen; pcount += plen) {
3085 ret = crypto_hash_update(desc, sg, plen);
3086 if (ret)
3087 return ret;
3088 }
3089 /* we assume there is enough space in 'out' for the result */
3090 ret = crypto_hash_final(desc, out);
3091 if (ret)
3092 return ret;
3093 }
3094
3095 printk("%6u opers/sec, %9lu bytes/sec\n",
3096 bcount / sec, ((long)bcount * blen) / sec);
3097
3098 return 0;
3099 }
3100
3101 static int test_hash_cycles_digest(struct hash_desc *desc,
3102 struct scatterlist *sg, int blen, char *out)
3103 {
3104 unsigned long cycles = 0;
3105 unsigned long start, end;
3106 int i;
3107 int ret;
3108
3109 local_bh_disable();
3110 local_irq_disable();
3111
3112 /* Warm-up run. */
3113 for (i = 0; i < 4; i++) {
3114 ret = crypto_hash_digest(desc, sg, blen, out);
3115 if (ret)
3116 goto out;
3117 }
3118
3119 /* The real thing. */
3120 for (i = 0; i < 8; i++) {
3121
3122 /* Original code to get cycles, does not work with MIPS
3123 * cycles_t start, end;
3124 * start = get_cycles();
3125 */
3126
3127 start = read_c0_count(); // LQ modified tcrypt
3128
3129 ret = crypto_hash_digest(desc, sg, blen, out);
3130 if (ret)
3131 goto out;
3132
3133 /* Original code to get cycles, does not work with MIPS
3134 * end = get_cycles();
3135 */
3136
3137 end = read_c0_count(); // LQ modified tcrypt
3138
3139 cycles += end - start;
3140 }
3141
3142 out:
3143 local_irq_enable();
3144 local_bh_enable();
3145
3146 if (ret)
3147 return ret;
3148
3149 printk("%6lu cycles/operation, %4lu cycles/byte\n",
3150 cycles / 8, cycles / (8 * blen));
3151
3152 return 0;
3153 }
3154
3155 static int test_hash_cycles(struct hash_desc *desc, struct scatterlist *sg,
3156 int blen, int plen, char *out)
3157 {
3158 unsigned long cycles = 0;
3159 unsigned long start, end;
3160 int i, pcount;
3161 int ret;
3162
3163 if (plen == blen)
3164 return test_hash_cycles_digest(desc, sg, blen, out);
3165
3166 local_bh_disable();
3167 local_irq_disable();
3168
3169 /* Warm-up run. */
3170 for (i = 0; i < 4; i++) {
3171 ret = crypto_hash_init(desc);
3172 if (ret)
3173 goto out;
3174 for (pcount = 0; pcount < blen; pcount += plen) {
3175 ret = crypto_hash_update(desc, sg, plen);
3176 if (ret)
3177 goto out;
3178 }
3179 ret = crypto_hash_final(desc, out);
3180 if (ret)
3181 goto out;
3182 }
3183
3184 /* The real thing. */
3185 for (i = 0; i < 8; i++) {
3186
3187 /* Original code for getting cycles, not working for MIPS
3188 * cycle_t start, end;
3189 * end = get_cycles();
3190 */
3191
3192 start = read_c0_count(); // LQ modified tcrypt
3193
3194 ret = crypto_hash_init(desc);
3195 if (ret)
3196 goto out;
3197 for (pcount = 0; pcount < blen; pcount += plen) {
3198 ret = crypto_hash_update(desc, sg, plen);
3199 if (ret)
3200 goto out;
3201 }
3202 ret = crypto_hash_final(desc, out);
3203 if (ret)
3204 goto out;
3205
3206 /* Original code for getting cycles, not working for MIPS
3207 * end = get_cycles();
3208 */
3209
3210 end = read_c0_count(); // LQ modified tcrypt
3211
3212 cycles += end - start;
3213 }
3214
3215 out:
3216 local_irq_enable();
3217 local_bh_enable();
3218
3219 if (ret)
3220 return ret;
3221
3222 printk("%6lu cycles/operation, %4lu cycles/byte\n",
3223 cycles / 8, cycles / (8 * blen));
3224
3225 return 0;
3226 }
3227
3228 static void test_hash_speed(const char *algo, unsigned int sec,
3229 struct hash_speed *speed)
3230 {
3231 struct scatterlist sg[TVMEMSIZE];
3232 struct crypto_hash *tfm;
3233 struct hash_desc desc;
3234 static char output[1024];
3235 int i;
3236 int ret;
3237
3238 printk(KERN_INFO "\ntesting speed of %s\n", algo);
3239
3240 tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
3241
3242 if (IS_ERR(tfm)) {
3243 printk(KERN_ERR "failed to load transform for %s: %ld\n", algo,
3244 PTR_ERR(tfm));
3245 return;
3246 }
3247
3248 desc.tfm = tfm;
3249 desc.flags = 0;
3250
3251 if (crypto_hash_digestsize(tfm) > sizeof(output)) {
3252 printk(KERN_ERR "digestsize(%u) > outputbuffer(%zu)\n",
3253 crypto_hash_digestsize(tfm), sizeof(output));
3254 goto out;
3255 }
3256
3257 sg_init_table(sg, TVMEMSIZE);
3258 for (i = 0; i < TVMEMSIZE; i++) {
3259 sg_set_buf(sg + i, tvmem[i], PAGE_SIZE);
3260 memset(tvmem[i], 0xff, PAGE_SIZE);
3261 }
3262
3263 for (i = 0; speed[i].blen != 0; i++) {
3264 if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
3265 printk(KERN_ERR
3266 "template (%u) too big for tvmem (%lu)\n",
3267 speed[i].blen, TVMEMSIZE * PAGE_SIZE);
3268 goto out;
3269 }
3270
3271 printk(KERN_INFO "test%3u "
3272 "(%5u byte blocks,%5u bytes per update,%4u updates): ",
3273 i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
3274
3275 if (sec)
3276 ret = test_hash_jiffies(&desc, sg, speed[i].blen,
3277 speed[i].plen, output, sec);
3278 else
3279 ret = test_hash_cycles(&desc, sg, speed[i].blen,
3280 speed[i].plen, output);
3281
3282 if (ret) {
3283 printk(KERN_ERR "hashing failed ret=%d\n", ret);
3284 break;
3285 }
3286 }
3287
3288 out:
3289 crypto_free_hash(tfm);
3290 }
3291
3292
3293 static void test_available(void)
3294 {
3295 char **name = check;
3296
3297 while (*name) {
3298 printk("alg %s ", *name);
3299 printk(crypto_has_alg(*name, 0, 0) ?
3300 "found\n" : "not found\n");
3301 name++;
3302 }
3303 }
3304
3305 static inline int tcrypt_test(const char *alg)
3306 {
3307 int ret;
3308
3309 printk("Running test %s\n", alg);
3310 ret = ifx_alg_test(alg, alg, 0, 0);
3311 /* non-fips algs return -EINVAL in fips mode */
3312 if (fips_enabled && ret == -EINVAL)
3313 ret = 0;
3314 return ret;
3315 }
3316
3317 static inline int tcrypt_speedtest(const char *alg,
3318 struct cipher_speed_template *template,
3319 unsigned int tcount, u8 *keysize)
3320 {
3321 int ret;
3322
3323 printk("[****** Running speedtest %s *******]\n", alg);
3324 ret = ifx_alg_speed_test(alg, alg, sec, template, tcount, keysize);
3325 if (fips_enabled && ret == -EINVAL)
3326 ret = 0;
3327 return ret;
3328 }
3329
3330
3331 static int do_test(int m)
3332 {
3333 int i;
3334 int ret = 0;
3335
3336 switch (m) {
3337 case 0:
3338 for (i = 1; i < 200; i++)
3339 ret += do_test(i);
3340 break;
3341
3342 case 1:
3343 ret += tcrypt_test("md5");
3344 break;
3345
3346 case 2:
3347 ret += tcrypt_test("sha1");
3348 break;
3349
3350 case 3:
3351 ret += tcrypt_test("ecb(des)");
3352 ret += tcrypt_test("cbc(des)");
3353 break;
3354
3355 case 4:
3356 ret += tcrypt_test("ecb(des3_ede)");
3357 ret += tcrypt_test("cbc(des3_ede)");
3358 break;
3359
3360 case 5:
3361 ret += tcrypt_test("md4");
3362 break;
3363
3364 case 6:
3365 ret += tcrypt_test("sha256");
3366 break;
3367
3368 case 7:
3369 ret += tcrypt_test("ecb(blowfish)");
3370 ret += tcrypt_test("cbc(blowfish)");
3371 break;
3372
3373 case 8:
3374 ret += tcrypt_test("ecb(twofish)");
3375 ret += tcrypt_test("cbc(twofish)");
3376 break;
3377
3378 case 9:
3379 ret += tcrypt_test("ecb(serpent)");
3380 break;
3381
3382 case 10:
3383 ret += tcrypt_test("ecb(aes)");
3384 ret += tcrypt_test("cbc(aes)");
3385 // ret += tcrypt_test("lrw(aes)");
3386 // ret += tcrypt_test("xts(aes)");
3387 ret += tcrypt_test("ctr(aes)");
3388 ret += tcrypt_test("rfc3686(ctr(aes))");
3389 break;
3390
3391 case 11:
3392 ret += tcrypt_test("sha384");
3393 break;
3394
3395 case 12:
3396 ret += tcrypt_test("sha512");
3397 break;
3398
3399 case 13:
3400 ret += tcrypt_test("deflate");
3401 break;
3402
3403 case 14:
3404 ret += tcrypt_test("ecb(cast5)");
3405 break;
3406
3407 case 15:
3408 ret += tcrypt_test("ecb(cast6)");
3409 break;
3410
3411 case 16:
3412 ret += tcrypt_test("ecb(arc4)");
3413 break;
3414
3415 case 17:
3416 ret += tcrypt_test("michael_mic");
3417 break;
3418
3419 case 18:
3420 ret += tcrypt_test("crc32c");
3421 break;
3422
3423 case 19:
3424 ret += tcrypt_test("ecb(tea)");
3425 break;
3426
3427 case 20:
3428 ret += tcrypt_test("ecb(xtea)");
3429 break;
3430
3431 case 21:
3432 ret += tcrypt_test("ecb(khazad)");
3433 break;
3434
3435 case 22:
3436 ret += tcrypt_test("wp512");
3437 break;
3438
3439 case 23:
3440 ret += tcrypt_test("wp384");
3441 break;
3442
3443 case 24:
3444 ret += tcrypt_test("wp256");
3445 break;
3446
3447 case 25:
3448 ret += tcrypt_test("ecb(tnepres)");
3449 break;
3450
3451 case 26:
3452 ret += tcrypt_test("ecb(anubis)");
3453 ret += tcrypt_test("cbc(anubis)");
3454 break;
3455
3456 case 27:
3457 ret += tcrypt_test("tgr192");
3458 break;
3459
3460 case 28:
3461
3462 ret += tcrypt_test("tgr160");
3463 break;
3464
3465 case 29:
3466 ret += tcrypt_test("tgr128");
3467 break;
3468
3469 case 30:
3470 ret += tcrypt_test("ecb(xeta)");
3471 break;
3472
3473 case 31:
3474 ret += tcrypt_test("pcbc(fcrypt)");
3475 break;
3476
3477 case 32:
3478 ret += tcrypt_test("ecb(camellia)");
3479 ret += tcrypt_test("cbc(camellia)");
3480 break;
3481 case 33:
3482 ret += tcrypt_test("sha224");
3483 break;
3484
3485 case 34:
3486 ret += tcrypt_test("salsa20");
3487 break;
3488
3489 case 35:
3490 ret += tcrypt_test("gcm(aes)");
3491 break;
3492
3493 case 36:
3494 ret += tcrypt_test("lzo");
3495 break;
3496
3497 case 37:
3498 ret += tcrypt_test("ccm(aes)");
3499 break;
3500
3501 case 38:
3502 ret += tcrypt_test("cts(cbc(aes))");
3503 break;
3504
3505 case 39:
3506 ret += tcrypt_test("rmd128");
3507 break;
3508
3509 case 40:
3510 ret += tcrypt_test("rmd160");
3511 break;
3512
3513 case 41:
3514 ret += tcrypt_test("rmd256");
3515 break;
3516
3517 case 42:
3518 ret += tcrypt_test("rmd320");
3519 break;
3520
3521 case 43:
3522 ret += tcrypt_test("ecb(seed)");
3523 break;
3524
3525 case 44:
3526 ret += tcrypt_test("zlib");
3527 break;
3528
3529 case 45:
3530 ret += tcrypt_test("rfc4309(ccm(aes))");
3531 break;
3532
3533 case 100:
3534 ret += tcrypt_test("hmac(md5)");
3535 break;
3536
3537 case 101:
3538 ret += tcrypt_test("hmac(sha1)");
3539 break;
3540
3541 case 102:
3542 ret += tcrypt_test("hmac(sha256)");
3543 break;
3544
3545 case 103:
3546 ret += tcrypt_test("hmac(sha384)");
3547 break;
3548
3549 case 104:
3550 ret += tcrypt_test("hmac(sha512)");
3551 break;
3552
3553 case 105:
3554 ret += tcrypt_test("hmac(sha224)");
3555 break;
3556
3557 case 106:
3558 ret += tcrypt_test("xcbc(aes)");
3559 break;
3560
3561 case 107:
3562 ret += tcrypt_test("hmac(rmd128)");
3563 break;
3564
3565 case 108:
3566 ret += tcrypt_test("hmac(rmd160)");
3567 break;
3568
3569 case 109:
3570 ret += tcrypt_test("vmac(aes)");
3571 break;
3572
3573 case 150:
3574 ret += tcrypt_test("ansi_cprng");
3575 break;
3576
3577 case 200:
3578 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
3579 speed_template_16_24_32);
3580 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
3581 speed_template_16_24_32);
3582 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
3583 speed_template_16_24_32);
3584 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
3585 speed_template_16_24_32);
3586 #if !defined(CONFIG_CRYPTO_DEV_AES) && !defined(CONFIG_CRYPTO_ASYNC_AES)
3587 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
3588 speed_template_32_40_48);
3589 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
3590 speed_template_32_40_48);
3591 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
3592 speed_template_32_48_64);
3593 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
3594 speed_template_32_48_64);
3595 #endif
3596 break;
3597
3598 case 201:
3599 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
3600 des3_speed_template, DES3_SPEED_VECTORS,
3601 speed_template_24);
3602 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
3603 des3_speed_template, DES3_SPEED_VECTORS,
3604 speed_template_24);
3605 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
3606 des3_speed_template, DES3_SPEED_VECTORS,
3607 speed_template_24);
3608 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
3609 des3_speed_template, DES3_SPEED_VECTORS,
3610 speed_template_24);
3611 break;
3612
3613 case 202:
3614 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
3615 speed_template_16_24_32);
3616 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
3617 speed_template_16_24_32);
3618 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
3619 speed_template_16_24_32);
3620 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
3621 speed_template_16_24_32);
3622 break;
3623
3624 case 203:
3625 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
3626 speed_template_8_32);
3627 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
3628 speed_template_8_32);
3629 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
3630 speed_template_8_32);
3631 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
3632 speed_template_8_32);
3633 break;
3634
3635 case 204:
3636 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
3637 speed_template_8);
3638 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
3639 speed_template_8);
3640 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
3641 speed_template_8);
3642 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
3643 speed_template_8);
3644 break;
3645
3646 case 205:
3647 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
3648 speed_template_16_24_32);
3649 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
3650 speed_template_16_24_32);
3651 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
3652 speed_template_16_24_32);
3653 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
3654 speed_template_16_24_32);
3655 break;
3656
3657 case 206:
3658 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
3659 speed_template_16_32);
3660 break;
3661
3662 case 300:
3663 /* fall through */
3664
3665 case 301:
3666 test_hash_speed("md4", sec, generic_hash_speed_template);
3667 if (mode > 300 && mode < 400) break;
3668
3669 case 302:
3670 test_hash_speed("md5", sec, generic_hash_speed_template);
3671 if (mode > 300 && mode < 400) break;
3672
3673 case 303:
3674 test_hash_speed("sha1", sec, generic_hash_speed_template);
3675 if (mode > 300 && mode < 400) break;
3676
3677 case 304:
3678 test_hash_speed("sha256", sec, generic_hash_speed_template);
3679 if (mode > 300 && mode < 400) break;
3680
3681 case 305:
3682 test_hash_speed("sha384", sec, generic_hash_speed_template);
3683 if (mode > 300 && mode < 400) break;
3684
3685 case 306:
3686 test_hash_speed("sha512", sec, generic_hash_speed_template);
3687 if (mode > 300 && mode < 400) break;
3688
3689 case 307:
3690 test_hash_speed("wp256", sec, generic_hash_speed_template);
3691 if (mode > 300 && mode < 400) break;
3692
3693 case 308:
3694 test_hash_speed("wp384", sec, generic_hash_speed_template);
3695 if (mode > 300 && mode < 400) break;
3696
3697 case 309:
3698 test_hash_speed("wp512", sec, generic_hash_speed_template);
3699 if (mode > 300 && mode < 400) break;
3700
3701 case 310:
3702 test_hash_speed("tgr128", sec, generic_hash_speed_template);
3703 if (mode > 300 && mode < 400) break;
3704
3705 case 311:
3706 test_hash_speed("tgr160", sec, generic_hash_speed_template);
3707 if (mode > 300 && mode < 400) break;
3708
3709 case 312:
3710 test_hash_speed("tgr192", sec, generic_hash_speed_template);
3711 if (mode > 300 && mode < 400) break;
3712
3713 case 313:
3714 test_hash_speed("sha224", sec, generic_hash_speed_template);
3715 if (mode > 300 && mode < 400) break;
3716
3717 case 314:
3718 test_hash_speed("rmd128", sec, generic_hash_speed_template);
3719 if (mode > 300 && mode < 400) break;
3720
3721 case 315:
3722 test_hash_speed("rmd160", sec, generic_hash_speed_template);
3723 if (mode > 300 && mode < 400) break;
3724
3725 case 316:
3726 test_hash_speed("rmd256", sec, generic_hash_speed_template);
3727 if (mode > 300 && mode < 400) break;
3728
3729 case 317:
3730 test_hash_speed("rmd320", sec, generic_hash_speed_template);
3731 if (mode > 300 && mode < 400) break;
3732
3733 case 399:
3734 break;
3735
3736 /* Modified speed test for async block cipher mode */
3737 case 400:
3738 tcrypt_speedtest("ecb(aes)", NULL, 0,
3739 speed_template_16_24_32);
3740 tcrypt_speedtest("cbc(aes)", NULL, 0,
3741 speed_template_16_24_32);
3742 break;
3743
3744 case 401:
3745 tcrypt_speedtest("ecb(des3_ede)", des3_speed_template,
3746 DES3_SPEED_VECTORS,speed_template_24);
3747 tcrypt_speedtest("cbc(des3_ede)", des3_speed_template,
3748 DES3_SPEED_VECTORS,speed_template_24);
3749 break;
3750
3751 case 404:
3752 tcrypt_speedtest("ecb(des)", NULL, 0,
3753 speed_template_8);
3754 tcrypt_speedtest("cbc(des)", NULL, 0,
3755 speed_template_8);
3756 break;
3757
3758 case 1000:
3759 test_available();
3760 break;
3761 }
3762
3763 return ret;
3764 }
3765 #if !defined(CONFIG_CRYPTO_DEV_DEU)
3766 static int do_alg_test(const char *alg, u32 type, u32 mask)
3767 {
3768 return crypto_has_alg(alg, type, mask ?: CRYPTO_ALG_TYPE_MASK) ?
3769 0 : -ENOENT;
3770 }
3771 #endif
3772
3773 static int __init tcrypt_mod_init(void)
3774 {
3775 int err = -ENOMEM;
3776 int i;
3777
3778 printk("Starting Lantiq DEU Crypto TESTS . . . . . . .\n");
3779
3780 for (i = 0; i < TVMEMSIZE; i++) {
3781 tvmem[i] = (void *)__get_free_page(GFP_KERNEL);
3782 if (!tvmem[i])
3783 goto err_free_tv;
3784 }
3785
3786 #if defined(CONFIG_CRYPTO_DEV_DEU)
3787 #if defined(CONFIG_CRYPTO_DEV_MD5)
3788 mode = 1; // test md5 only
3789 err = do_test(mode);
3790 if (err)
3791 goto md5_err;
3792
3793 md5_err:
3794 if (err) {
3795 printk(KERN_ERR "md5: one or more tests failed!\n");
3796 goto err_free_tv;
3797 }
3798 #endif
3799 #if defined(CONFIG_CRYPTO_DEV_SHA1)
3800 mode = 2; // test sha1 only
3801 err = do_test(mode);
3802 if (err)
3803 goto sha1_err;
3804
3805 sha1_err:
3806 if (err) {
3807 printk(KERN_ERR "sha1: one or more tests failed!\n");
3808 goto err_free_tv;
3809 }
3810 #endif
3811 #if defined (CONFIG_CRYPTO_DEV_DES) || defined (CONFIG_CRYPTO_ASYNC_DES)
3812 mode = 3; // test des only
3813 err = do_test(mode);
3814 if (err)
3815 goto des_err;
3816
3817 mode = 4; // test des3 only
3818 err = do_test(mode);
3819 if (err)
3820 goto des_err;
3821
3822 des_err:
3823 if (err) {
3824 printk(KERN_ERR "des3: one or more tests failed!\n");
3825 goto err_free_tv;
3826 }
3827 #endif
3828 #if defined (CONFIG_CRYPTO_ASYNC_AES) || defined (CONFIG_CRYPTO_DEV_AES)
3829 mode = 10; // test aes only
3830 err = do_test(mode);
3831 if (err)
3832 goto aes_err;
3833
3834 aes_err:
3835 if (err) {
3836 printk(KERN_ERR "aes: one or more tests failed!\n");
3837 goto err_free_tv;
3838 }
3839 #endif
3840 #if defined(CONFIG_CRYPTO_DEV_ARC4)
3841 mode = 16;
3842 err = do_test(mode);
3843
3844 if (err) {
3845 printk(KERN_ERR "arc4: one or more tests failed!\n");
3846 goto err_free_tv;
3847 }
3848 #endif
3849 #if defined (CONFIG_CRYPTO_DEV_MD5_HMAC)
3850 mode = 100;
3851 err = do_test(mode);
3852
3853 if (err) {
3854 printk(KERN_ERR "tcrypt: one or more tests failed!\n");
3855 goto err_free_tv;
3856 }
3857 #endif
3858 #if defined (CONFIG_CRYPTO_DEV_SHA1_HMAC)
3859 mode = 101;
3860 err = do_test(mode);
3861
3862 if (err) {
3863 printk(KERN_ERR "tcrypt: one or more tests failed!\n");
3864 goto err_free_tv;
3865 }
3866 #endif
3867
3868 /* Start Speed tests test modes */
3869 #if defined(CONFIG_CRYPTO_DEV_SPEED_TEST)
3870 #if defined(CONFIG_CRYPTO_DEV_AES)
3871 mode = 200;
3872 err = do_test(mode);
3873 if (err)
3874 goto speed_err;
3875 #endif
3876 #if defined (CONFIG_CRYPTO_DEV_DES)
3877 mode = 201;
3878 err = do_test(mode);
3879 if (err)
3880 goto speed_err;
3881
3882 mode = 204;
3883 err = do_test(mode);
3884 if (err)
3885 goto speed_err;
3886 #endif
3887 #if defined (CONFIG_CRYPTO_DEV_MD5)
3888 mode = 302;
3889 err = do_test(mode);
3890 if (err)
3891 goto speed_err;
3892 #endif
3893 #if defined (CONFIG_CRYPTO_DEV_SHA1)
3894 mode = 303;
3895 err = do_test(mode);
3896 if (err)
3897 goto speed_err;
3898 #endif
3899 printk("Speed tests finished successfully\n");
3900 goto fips_check;
3901
3902 speed_err:
3903 printk(KERN_ERR "tcrypt: one or more tests failed!\n");
3904 goto err_free_tv;
3905 #endif /* CONFIG_CRYPTO_DEV_SPEED_TEST */
3906
3907 #else
3908 if (alg)
3909 err = do_alg_test(alg, type, mask);
3910 else
3911 err = do_test(mode);
3912
3913 if (err) {
3914 printk(KERN_ERR "tcrypt: one or more tests failed!\n");
3915 goto err_free_tv;
3916 }
3917 #endif /* CONFIG_CRYPTO_DEV_DEU */
3918
3919 fips_check:
3920 /* We intentionaly return -EAGAIN to prevent keeping the module,
3921 * unless we're running in fips mode. It does all its work from
3922 * init() and doesn't offer any runtime functionality, but in
3923 * the fips case, checking for a successful load is helpful.
3924 * => we don't need it in the memory, do we?
3925 * -- mludvig
3926 */
3927 if (!fips_enabled)
3928 err = -EAGAIN;
3929
3930 err_free_tv:
3931 for (i = 0; i < TVMEMSIZE && tvmem[i]; i++ ){
3932 printk("Freeing page: %d\n", i);
3933 free_page((unsigned long)tvmem[i]);
3934 }
3935
3936 printk("Finished DEU testing . . . . . .\n");
3937 return err;
3938 }
3939
3940 /*
3941 * If an init function is provided, an exit function must also be provided
3942 * to allow module unload.
3943 */
3944 static void __exit tcrypt_mod_fini(void) {}
3945
3946
3947 module_init(tcrypt_mod_init);
3948 module_exit(tcrypt_mod_fini);
3949
3950 module_param(alg, charp, 0);
3951 module_param(type, uint, 0);
3952 module_param(mask, uint, 0);
3953 module_param(mode, int, 0);
3954 module_param(sec, uint, 0);
3955 MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
3956 "(defaults to zero which uses CPU cycles instead)");
3957
3958 MODULE_LICENSE("GPL");
3959 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
3960 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
3961
OpenWrt Source Repository