?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] relayfs documentation typo
[usb.git] / crypto / tcrypt.c
blob68639419c5bd0283697d60defb50f6cf109e8f5e
1 /*
2 * Quick & dirty crypto testing module.
3 *
4 * This will only exist until we have a better testing mechanism
5 * (e.g. a char device).
6 *
7 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
8 * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the Free
12 * Software Foundation; either version 2 of the License, or (at your option)
13 * any later version.
14 *
15 * 2004-08-09 Added cipher speed tests (Reyk Floeter <reyk@vantronix.net>)
16 * 2003-09-14 Rewritten by Kartikey Mahendra Bhatt
17 *
18 */
19
20 #include <linux/init.h>
21 #include <linux/module.h>
22 #include <linux/mm.h>
23 #include <linux/slab.h>
24 #include <asm/scatterlist.h>
25 #include <linux/string.h>
26 #include <linux/crypto.h>
27 #include <linux/highmem.h>
28 #include <linux/moduleparam.h>
29 #include <linux/jiffies.h>
30 #include <linux/timex.h>
31 #include <linux/interrupt.h>
32 #include "tcrypt.h"
33
34 /*
35 * Need to kmalloc() memory for testing kmap().
36 */
37 #define TVMEMSIZE 16384
38 #define XBUFSIZE 32768
39
40 /*
41 * Indexes into the xbuf to simulate cross-page access.
42 */
43 #define IDX1 37
44 #define IDX2 32400
45 #define IDX3 1
46 #define IDX4 8193
47 #define IDX5 22222
48 #define IDX6 17101
49 #define IDX7 27333
50 #define IDX8 3000
51
52 /*
53 * Used by test_cipher()
54 */
55 #define ENCRYPT 1
56 #define DECRYPT 0
57 #define MODE_ECB 1
58 #define MODE_CBC 0
59
60 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
61
62 /*
63 * Used by test_cipher_speed()
64 */
65 static unsigned int sec;
66
67 static int mode;
68 static char *xbuf;
69 static char *tvmem;
70
71 static char *check[] = {
72 "des", "md5", "des3_ede", "rot13", "sha1", "sha256", "blowfish",
73 "twofish", "serpent", "sha384", "sha512", "md4", "aes", "cast6",
74 "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
75 "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", NULL
76 };
77
78 static void hexdump(unsigned char *buf, unsigned int len)
79 {
80 while (len--)
81 printk("%02x", *buf++);
82
83 printk("\n");
84 }
85
86 static void test_hash(char *algo, struct hash_testvec *template,
87 unsigned int tcount)
88 {
89 char *p;
90 unsigned int i, j, k, temp;
91 struct scatterlist sg[8];
92 char result[64];
93 struct crypto_tfm *tfm;
94 struct hash_testvec *hash_tv;
95 unsigned int tsize;
96
97 printk("\ntesting %s\n", algo);
98
99 tsize = sizeof(struct hash_testvec);
100 tsize *= tcount;
101
102 if (tsize > TVMEMSIZE) {
103 printk("template (%u) too big for tvmem (%u)\n", tsize, TVMEMSIZE);
104 return;
105 }
106
107 memcpy(tvmem, template, tsize);
108 hash_tv = (void *)tvmem;
109 tfm = crypto_alloc_tfm(algo, 0);
110 if (tfm == NULL) {
111 printk("failed to load transform for %s\n", algo);
112 return;
113 }
114
115 for (i = 0; i < tcount; i++) {
116 printk("test %u:\n", i + 1);
117 memset(result, 0, 64);
118
119 p = hash_tv[i].plaintext;
120 sg[0].page = virt_to_page(p);
121 sg[0].offset = offset_in_page(p);
122 sg[0].length = hash_tv[i].psize;
123
124 crypto_digest_init(tfm);
125 if (tfm->crt_u.digest.dit_setkey) {
126 crypto_digest_setkey(tfm, hash_tv[i].key,
127 hash_tv[i].ksize);
128 }
129 crypto_digest_update(tfm, sg, 1);
130 crypto_digest_final(tfm, result);
131
132 hexdump(result, crypto_tfm_alg_digestsize(tfm));
133 printk("%s\n",
134 memcmp(result, hash_tv[i].digest,
135 crypto_tfm_alg_digestsize(tfm)) ?
136 "fail" : "pass");
137 }
138
139 printk("testing %s across pages\n", algo);
140
141 /* setup the dummy buffer first */
142 memset(xbuf, 0, XBUFSIZE);
143
144 j = 0;
145 for (i = 0; i < tcount; i++) {
146 if (hash_tv[i].np) {
147 j++;
148 printk("test %u:\n", j);
149 memset(result, 0, 64);
150
151 temp = 0;
152 for (k = 0; k < hash_tv[i].np; k++) {
153 memcpy(&xbuf[IDX[k]],
154 hash_tv[i].plaintext + temp,
155 hash_tv[i].tap[k]);
156 temp += hash_tv[i].tap[k];
157 p = &xbuf[IDX[k]];
158 sg[k].page = virt_to_page(p);
159 sg[k].offset = offset_in_page(p);
160 sg[k].length = hash_tv[i].tap[k];
161 }
162
163 crypto_digest_digest(tfm, sg, hash_tv[i].np, result);
164
165 hexdump(result, crypto_tfm_alg_digestsize(tfm));
166 printk("%s\n",
167 memcmp(result, hash_tv[i].digest,
168 crypto_tfm_alg_digestsize(tfm)) ?
169 "fail" : "pass");
170 }
171 }
172
173 crypto_free_tfm(tfm);
174 }
175
176
177 #ifdef CONFIG_CRYPTO_HMAC
178
179 static void test_hmac(char *algo, struct hmac_testvec *template,
180 unsigned int tcount)
181 {
182 char *p;
183 unsigned int i, j, k, temp;
184 struct scatterlist sg[8];
185 char result[64];
186 struct crypto_tfm *tfm;
187 struct hmac_testvec *hmac_tv;
188 unsigned int tsize, klen;
189
190 tfm = crypto_alloc_tfm(algo, 0);
191 if (tfm == NULL) {
192 printk("failed to load transform for %s\n", algo);
193 return;
194 }
195
196 printk("\ntesting hmac_%s\n", algo);
197
198 tsize = sizeof(struct hmac_testvec);
199 tsize *= tcount;
200 if (tsize > TVMEMSIZE) {
201 printk("template (%u) too big for tvmem (%u)\n", tsize,
202 TVMEMSIZE);
203 goto out;
204 }
205
206 memcpy(tvmem, template, tsize);
207 hmac_tv = (void *)tvmem;
208
209 for (i = 0; i < tcount; i++) {
210 printk("test %u:\n", i + 1);
211 memset(result, 0, sizeof (result));
212
213 p = hmac_tv[i].plaintext;
214 klen = hmac_tv[i].ksize;
215 sg[0].page = virt_to_page(p);
216 sg[0].offset = offset_in_page(p);
217 sg[0].length = hmac_tv[i].psize;
218
219 crypto_hmac(tfm, hmac_tv[i].key, &klen, sg, 1, result);
220
221 hexdump(result, crypto_tfm_alg_digestsize(tfm));
222 printk("%s\n",
223 memcmp(result, hmac_tv[i].digest,
224 crypto_tfm_alg_digestsize(tfm)) ? "fail" :
225 "pass");
226 }
227
228 printk("\ntesting hmac_%s across pages\n", algo);
229
230 memset(xbuf, 0, XBUFSIZE);
231
232 j = 0;
233 for (i = 0; i < tcount; i++) {
234 if (hmac_tv[i].np) {
235 j++;
236 printk("test %u:\n",j);
237 memset(result, 0, 64);
238
239 temp = 0;
240 klen = hmac_tv[i].ksize;
241 for (k = 0; k < hmac_tv[i].np; k++) {
242 memcpy(&xbuf[IDX[k]],
243 hmac_tv[i].plaintext + temp,
244 hmac_tv[i].tap[k]);
245 temp += hmac_tv[i].tap[k];
246 p = &xbuf[IDX[k]];
247 sg[k].page = virt_to_page(p);
248 sg[k].offset = offset_in_page(p);
249 sg[k].length = hmac_tv[i].tap[k];
250 }
251
252 crypto_hmac(tfm, hmac_tv[i].key, &klen, sg,
253 hmac_tv[i].np, result);
254 hexdump(result, crypto_tfm_alg_digestsize(tfm));
255
256 printk("%s\n",
257 memcmp(result, hmac_tv[i].digest,
258 crypto_tfm_alg_digestsize(tfm)) ?
259 "fail" : "pass");
260 }
261 }
262 out:
263 crypto_free_tfm(tfm);
264 }
265
266 #endif /* CONFIG_CRYPTO_HMAC */
267
268 static void test_cipher(char *algo, int mode, int enc,
269 struct cipher_testvec *template, unsigned int tcount)
270 {
271 unsigned int ret, i, j, k, temp;
272 unsigned int tsize;
273 char *p, *q;
274 struct crypto_tfm *tfm;
275 char *key;
276 struct cipher_testvec *cipher_tv;
277 struct scatterlist sg[8];
278 const char *e, *m;
279
280 if (enc == ENCRYPT)
281 e = "encryption";
282 else
283 e = "decryption";
284 if (mode == MODE_ECB)
285 m = "ECB";
286 else
287 m = "CBC";
288
289 printk("\ntesting %s %s %s\n", algo, m, e);
290
291 tsize = sizeof (struct cipher_testvec);
292 tsize *= tcount;
293
294 if (tsize > TVMEMSIZE) {
295 printk("template (%u) too big for tvmem (%u)\n", tsize,
296 TVMEMSIZE);
297 return;
298 }
299
300 memcpy(tvmem, template, tsize);
301 cipher_tv = (void *)tvmem;
302
303 if (mode)
304 tfm = crypto_alloc_tfm(algo, 0);
305 else
306 tfm = crypto_alloc_tfm(algo, CRYPTO_TFM_MODE_CBC);
307
308 if (tfm == NULL) {
309 printk("failed to load transform for %s %s\n", algo, m);
310 return;
311 }
312
313 j = 0;
314 for (i = 0; i < tcount; i++) {
315 if (!(cipher_tv[i].np)) {
316 j++;
317 printk("test %u (%d bit key):\n",
318 j, cipher_tv[i].klen * 8);
319
320 tfm->crt_flags = 0;
321 if (cipher_tv[i].wk)
322 tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY;
323 key = cipher_tv[i].key;
324
325 ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen);
326 if (ret) {
327 printk("setkey() failed flags=%x\n", tfm->crt_flags);
328
329 if (!cipher_tv[i].fail)
330 goto out;
331 }
332
333 p = cipher_tv[i].input;
334 sg[0].page = virt_to_page(p);
335 sg[0].offset = offset_in_page(p);
336 sg[0].length = cipher_tv[i].ilen;
337
338 if (!mode) {
339 crypto_cipher_set_iv(tfm, cipher_tv[i].iv,
340 crypto_tfm_alg_ivsize(tfm));
341 }
342
343 if (enc)
344 ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen);
345 else
346 ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen);
347
348
349 if (ret) {
350 printk("%s () failed flags=%x\n", e, tfm->crt_flags);
351 goto out;
352 }
353
354 q = kmap(sg[0].page) + sg[0].offset;
355 hexdump(q, cipher_tv[i].rlen);
356
357 printk("%s\n",
358 memcmp(q, cipher_tv[i].result,
359 cipher_tv[i].rlen) ? "fail" : "pass");
360 }
361 }
362
363 printk("\ntesting %s %s %s across pages (chunking)\n", algo, m, e);
364 memset(xbuf, 0, XBUFSIZE);
365
366 j = 0;
367 for (i = 0; i < tcount; i++) {
368 if (cipher_tv[i].np) {
369 j++;
370 printk("test %u (%d bit key):\n",
371 j, cipher_tv[i].klen * 8);
372
373 tfm->crt_flags = 0;
374 if (cipher_tv[i].wk)
375 tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY;
376 key = cipher_tv[i].key;
377
378 ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen);
379 if (ret) {
380 printk("setkey() failed flags=%x\n", tfm->crt_flags);
381
382 if (!cipher_tv[i].fail)
383 goto out;
384 }
385
386 temp = 0;
387 for (k = 0; k < cipher_tv[i].np; k++) {
388 memcpy(&xbuf[IDX[k]],
389 cipher_tv[i].input + temp,
390 cipher_tv[i].tap[k]);
391 temp += cipher_tv[i].tap[k];
392 p = &xbuf[IDX[k]];
393 sg[k].page = virt_to_page(p);
394 sg[k].offset = offset_in_page(p);
395 sg[k].length = cipher_tv[i].tap[k];
396 }
397
398 if (!mode) {
399 crypto_cipher_set_iv(tfm, cipher_tv[i].iv,
400 crypto_tfm_alg_ivsize(tfm));
401 }
402
403 if (enc)
404 ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen);
405 else
406 ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen);
407
408 if (ret) {
409 printk("%s () failed flags=%x\n", e, tfm->crt_flags);
410 goto out;
411 }
412
413 temp = 0;
414 for (k = 0; k < cipher_tv[i].np; k++) {
415 printk("page %u\n", k);
416 q = kmap(sg[k].page) + sg[k].offset;
417 hexdump(q, cipher_tv[i].tap[k]);
418 printk("%s\n",
419 memcmp(q, cipher_tv[i].result + temp,
420 cipher_tv[i].tap[k]) ? "fail" :
421 "pass");
422 temp += cipher_tv[i].tap[k];
423 }
424 }
425 }
426
427 out:
428 crypto_free_tfm(tfm);
429 }
430
431 static int test_cipher_jiffies(struct crypto_tfm *tfm, int enc, char *p,
432 int blen, int sec)
433 {
434 struct scatterlist sg[8];
435 unsigned long start, end;
436 int bcount;
437 int ret;
438
439 sg[0].page = virt_to_page(p);
440 sg[0].offset = offset_in_page(p);
441 sg[0].length = blen;
442
443 for (start = jiffies, end = start + sec * HZ, bcount = 0;
444 time_before(jiffies, end); bcount++) {
445 if (enc)
446 ret = crypto_cipher_encrypt(tfm, sg, sg, blen);
447 else
448 ret = crypto_cipher_decrypt(tfm, sg, sg, blen);
449
450 if (ret)
451 return ret;
452 }
453
454 printk("%d operations in %d seconds (%ld bytes)\n",
455 bcount, sec, (long)bcount * blen);
456 return 0;
457 }
458
459 static int test_cipher_cycles(struct crypto_tfm *tfm, int enc, char *p,
460 int blen)
461 {
462 struct scatterlist sg[8];
463 unsigned long cycles = 0;
464 int ret = 0;
465 int i;
466
467 sg[0].page = virt_to_page(p);
468 sg[0].offset = offset_in_page(p);
469 sg[0].length = blen;
470
471 local_bh_disable();
472 local_irq_disable();
473
474 /* Warm-up run. */
475 for (i = 0; i < 4; i++) {
476 if (enc)
477 ret = crypto_cipher_encrypt(tfm, sg, sg, blen);
478 else
479 ret = crypto_cipher_decrypt(tfm, sg, sg, blen);
480
481 if (ret)
482 goto out;
483 }
484
485 /* The real thing. */
486 for (i = 0; i < 8; i++) {
487 cycles_t start, end;
488
489 start = get_cycles();
490 if (enc)
491 ret = crypto_cipher_encrypt(tfm, sg, sg, blen);
492 else
493 ret = crypto_cipher_decrypt(tfm, sg, sg, blen);
494 end = get_cycles();
495
496 if (ret)
497 goto out;
498
499 cycles += end - start;
500 }
501
502 out:
503 local_irq_enable();
504 local_bh_enable();
505
506 if (ret == 0)
507 printk("1 operation in %lu cycles (%d bytes)\n",
508 (cycles + 4) / 8, blen);
509
510 return ret;
511 }
512
513 static void test_cipher_speed(char *algo, int mode, int enc, unsigned int sec,
514 struct cipher_testvec *template,
515 unsigned int tcount, struct cipher_speed *speed)
516 {
517 unsigned int ret, i, j, iv_len;
518 unsigned char *key, *p, iv[128];
519 struct crypto_tfm *tfm;
520 const char *e, *m;
521
522 if (enc == ENCRYPT)
523 e = "encryption";
524 else
525 e = "decryption";
526 if (mode == MODE_ECB)
527 m = "ECB";
528 else
529 m = "CBC";
530
531 printk("\ntesting speed of %s %s %s\n", algo, m, e);
532
533 if (mode)
534 tfm = crypto_alloc_tfm(algo, 0);
535 else
536 tfm = crypto_alloc_tfm(algo, CRYPTO_TFM_MODE_CBC);
537
538 if (tfm == NULL) {
539 printk("failed to load transform for %s %s\n", algo, m);
540 return;
541 }
542
543 for (i = 0; speed[i].klen != 0; i++) {
544 if ((speed[i].blen + speed[i].klen) > TVMEMSIZE) {
545 printk("template (%u) too big for tvmem (%u)\n",
546 speed[i].blen + speed[i].klen, TVMEMSIZE);
547 goto out;
548 }
549
550 printk("test %u (%d bit key, %d byte blocks): ", i,
551 speed[i].klen * 8, speed[i].blen);
552
553 memset(tvmem, 0xff, speed[i].klen + speed[i].blen);
554
555 /* set key, plain text and IV */
556 key = (unsigned char *)tvmem;
557 for (j = 0; j < tcount; j++) {
558 if (template[j].klen == speed[i].klen) {
559 key = template[j].key;
560 break;
561 }
562 }
563 p = (unsigned char *)tvmem + speed[i].klen;
564
565 ret = crypto_cipher_setkey(tfm, key, speed[i].klen);
566 if (ret) {
567 printk("setkey() failed flags=%x\n", tfm->crt_flags);
568 goto out;
569 }
570
571 if (!mode) {
572 iv_len = crypto_tfm_alg_ivsize(tfm);
573 memset(&iv, 0xff, iv_len);
574 crypto_cipher_set_iv(tfm, iv, iv_len);
575 }
576
577 if (sec)
578 ret = test_cipher_jiffies(tfm, enc, p, speed[i].blen,
579 sec);
580 else
581 ret = test_cipher_cycles(tfm, enc, p, speed[i].blen);
582
583 if (ret) {
584 printk("%s() failed flags=%x\n", e, tfm->crt_flags);
585 break;
586 }
587 }
588
589 out:
590 crypto_free_tfm(tfm);
591 }
592
593 static void test_deflate(void)
594 {
595 unsigned int i;
596 char result[COMP_BUF_SIZE];
597 struct crypto_tfm *tfm;
598 struct comp_testvec *tv;
599 unsigned int tsize;
600
601 printk("\ntesting deflate compression\n");
602
603 tsize = sizeof (deflate_comp_tv_template);
604 if (tsize > TVMEMSIZE) {
605 printk("template (%u) too big for tvmem (%u)\n", tsize,
606 TVMEMSIZE);
607 return;
608 }
609
610 memcpy(tvmem, deflate_comp_tv_template, tsize);
611 tv = (void *)tvmem;
612
613 tfm = crypto_alloc_tfm("deflate", 0);
614 if (tfm == NULL) {
615 printk("failed to load transform for deflate\n");
616 return;
617 }
618
619 for (i = 0; i < DEFLATE_COMP_TEST_VECTORS; i++) {
620 int ilen, ret, dlen = COMP_BUF_SIZE;
621
622 printk("test %u:\n", i + 1);
623 memset(result, 0, sizeof (result));
624
625 ilen = tv[i].inlen;
626 ret = crypto_comp_compress(tfm, tv[i].input,
627 ilen, result, &dlen);
628 if (ret) {
629 printk("fail: ret=%d\n", ret);
630 continue;
631 }
632 hexdump(result, dlen);
633 printk("%s (ratio %d:%d)\n",
634 memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
635 ilen, dlen);
636 }
637
638 printk("\ntesting deflate decompression\n");
639
640 tsize = sizeof (deflate_decomp_tv_template);
641 if (tsize > TVMEMSIZE) {
642 printk("template (%u) too big for tvmem (%u)\n", tsize,
643 TVMEMSIZE);
644 goto out;
645 }
646
647 memcpy(tvmem, deflate_decomp_tv_template, tsize);
648 tv = (void *)tvmem;
649
650 for (i = 0; i < DEFLATE_DECOMP_TEST_VECTORS; i++) {
651 int ilen, ret, dlen = COMP_BUF_SIZE;
652
653 printk("test %u:\n", i + 1);
654 memset(result, 0, sizeof (result));
655
656 ilen = tv[i].inlen;
657 ret = crypto_comp_decompress(tfm, tv[i].input,
658 ilen, result, &dlen);
659 if (ret) {
660 printk("fail: ret=%d\n", ret);
661 continue;
662 }
663 hexdump(result, dlen);
664 printk("%s (ratio %d:%d)\n",
665 memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
666 ilen, dlen);
667 }
668 out:
669 crypto_free_tfm(tfm);
670 }
671
672 static void test_crc32c(void)
673 {
674 #define NUMVEC 6
675 #define VECSIZE 40
676
677 int i, j, pass;
678 u32 crc;
679 u8 b, test_vec[NUMVEC][VECSIZE];
680 static u32 vec_results[NUMVEC] = {
681 0x0e2c157f, 0xe980ebf6, 0xde74bded,
682 0xd579c862, 0xba979ad0, 0x2b29d913
683 };
684 static u32 tot_vec_results = 0x24c5d375;
685
686 struct scatterlist sg[NUMVEC];
687 struct crypto_tfm *tfm;
688 char *fmtdata = "testing crc32c initialized to %08x: %s\n";
689 #define SEEDTESTVAL 0xedcba987
690 u32 seed;
691
692 printk("\ntesting crc32c\n");
693
694 tfm = crypto_alloc_tfm("crc32c", 0);
695 if (tfm == NULL) {
696 printk("failed to load transform for crc32c\n");
697 return;
698 }
699
700 crypto_digest_init(tfm);
701 crypto_digest_final(tfm, (u8*)&crc);
702 printk(fmtdata, crc, (crc == 0) ? "pass" : "ERROR");
703
704 /*
705 * stuff test_vec with known values, simple incrementing
706 * byte values.
707 */
708 b = 0;
709 for (i = 0; i < NUMVEC; i++) {
710 for (j = 0; j < VECSIZE; j++)
711 test_vec[i][j] = ++b;
712 sg[i].page = virt_to_page(test_vec[i]);
713 sg[i].offset = offset_in_page(test_vec[i]);
714 sg[i].length = VECSIZE;
715 }
716
717 seed = SEEDTESTVAL;
718 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
719 crypto_digest_final(tfm, (u8*)&crc);
720 printk("testing crc32c setkey returns %08x : %s\n", crc, (crc == (SEEDTESTVAL ^ ~(u32)0)) ?
721 "pass" : "ERROR");
722
723 printk("testing crc32c using update/final:\n");
724
725 pass = 1; /* assume all is well */
726
727 for (i = 0; i < NUMVEC; i++) {
728 seed = ~(u32)0;
729 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
730 crypto_digest_update(tfm, &sg[i], 1);
731 crypto_digest_final(tfm, (u8*)&crc);
732 if (crc == vec_results[i]) {
733 printk(" %08x:OK", crc);
734 } else {
735 printk(" %08x:BAD, wanted %08x\n", crc, vec_results[i]);
736 pass = 0;
737 }
738 }
739
740 printk("\ntesting crc32c using incremental accumulator:\n");
741 crc = 0;
742 for (i = 0; i < NUMVEC; i++) {
743 seed = (crc ^ ~(u32)0);
744 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
745 crypto_digest_update(tfm, &sg[i], 1);
746 crypto_digest_final(tfm, (u8*)&crc);
747 }
748 if (crc == tot_vec_results) {
749 printk(" %08x:OK", crc);
750 } else {
751 printk(" %08x:BAD, wanted %08x\n", crc, tot_vec_results);
752 pass = 0;
753 }
754
755 printk("\ntesting crc32c using digest:\n");
756 seed = ~(u32)0;
757 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
758 crypto_digest_digest(tfm, sg, NUMVEC, (u8*)&crc);
759 if (crc == tot_vec_results) {
760 printk(" %08x:OK", crc);
761 } else {
762 printk(" %08x:BAD, wanted %08x\n", crc, tot_vec_results);
763 pass = 0;
764 }
765
766 printk("\n%s\n", pass ? "pass" : "ERROR");
767
768 crypto_free_tfm(tfm);
769 printk("crc32c test complete\n");
770 }
771
772 static void test_available(void)
773 {
774 char **name = check;
775
776 while (*name) {
777 printk("alg %s ", *name);
778 printk((crypto_alg_available(*name, 0)) ?
779 "found\n" : "not found\n");
780 name++;
781 }
782 }
783
784 static void do_test(void)
785 {
786 switch (mode) {
787
788 case 0:
789 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
790
791 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
792
793 //DES
794 test_cipher ("des", MODE_ECB, ENCRYPT, des_enc_tv_template, DES_ENC_TEST_VECTORS);
795 test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS);
796 test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS);
797 test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS);
798
799 //DES3_EDE
800 test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS);
801 test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS);
802
803 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
804
805 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
806
807 //BLOWFISH
808 test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS);
809 test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS);
810 test_cipher ("blowfish", MODE_CBC, ENCRYPT, bf_cbc_enc_tv_template, BF_CBC_ENC_TEST_VECTORS);
811 test_cipher ("blowfish", MODE_CBC, DECRYPT, bf_cbc_dec_tv_template, BF_CBC_DEC_TEST_VECTORS);
812
813 //TWOFISH
814 test_cipher ("twofish", MODE_ECB, ENCRYPT, tf_enc_tv_template, TF_ENC_TEST_VECTORS);
815 test_cipher ("twofish", MODE_ECB, DECRYPT, tf_dec_tv_template, TF_DEC_TEST_VECTORS);
816 test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS);
817 test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS);
818
819 //SERPENT
820 test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS);
821 test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS);
822
823 //TNEPRES
824 test_cipher ("tnepres", MODE_ECB, ENCRYPT, tnepres_enc_tv_template, TNEPRES_ENC_TEST_VECTORS);
825 test_cipher ("tnepres", MODE_ECB, DECRYPT, tnepres_dec_tv_template, TNEPRES_DEC_TEST_VECTORS);
826
827 //AES
828 test_cipher ("aes", MODE_ECB, ENCRYPT, aes_enc_tv_template, AES_ENC_TEST_VECTORS);
829 test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS);
830
831 //CAST5
832 test_cipher ("cast5", MODE_ECB, ENCRYPT, cast5_enc_tv_template, CAST5_ENC_TEST_VECTORS);
833 test_cipher ("cast5", MODE_ECB, DECRYPT, cast5_dec_tv_template, CAST5_DEC_TEST_VECTORS);
834
835 //CAST6
836 test_cipher ("cast6", MODE_ECB, ENCRYPT, cast6_enc_tv_template, CAST6_ENC_TEST_VECTORS);
837 test_cipher ("cast6", MODE_ECB, DECRYPT, cast6_dec_tv_template, CAST6_DEC_TEST_VECTORS);
838
839 //ARC4
840 test_cipher ("arc4", MODE_ECB, ENCRYPT, arc4_enc_tv_template, ARC4_ENC_TEST_VECTORS);
841 test_cipher ("arc4", MODE_ECB, DECRYPT, arc4_dec_tv_template, ARC4_DEC_TEST_VECTORS);
842
843 //TEA
844 test_cipher ("tea", MODE_ECB, ENCRYPT, tea_enc_tv_template, TEA_ENC_TEST_VECTORS);
845 test_cipher ("tea", MODE_ECB, DECRYPT, tea_dec_tv_template, TEA_DEC_TEST_VECTORS);
846
847
848 //XTEA
849 test_cipher ("xtea", MODE_ECB, ENCRYPT, xtea_enc_tv_template, XTEA_ENC_TEST_VECTORS);
850 test_cipher ("xtea", MODE_ECB, DECRYPT, xtea_dec_tv_template, XTEA_DEC_TEST_VECTORS);
851
852 //KHAZAD
853 test_cipher ("khazad", MODE_ECB, ENCRYPT, khazad_enc_tv_template, KHAZAD_ENC_TEST_VECTORS);
854 test_cipher ("khazad", MODE_ECB, DECRYPT, khazad_dec_tv_template, KHAZAD_DEC_TEST_VECTORS);
855
856 //ANUBIS
857 test_cipher ("anubis", MODE_ECB, ENCRYPT, anubis_enc_tv_template, ANUBIS_ENC_TEST_VECTORS);
858 test_cipher ("anubis", MODE_ECB, DECRYPT, anubis_dec_tv_template, ANUBIS_DEC_TEST_VECTORS);
859 test_cipher ("anubis", MODE_CBC, ENCRYPT, anubis_cbc_enc_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
860 test_cipher ("anubis", MODE_CBC, DECRYPT, anubis_cbc_dec_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
861
862 //XETA
863 test_cipher ("xeta", MODE_ECB, ENCRYPT, xeta_enc_tv_template, XETA_ENC_TEST_VECTORS);
864 test_cipher ("xeta", MODE_ECB, DECRYPT, xeta_dec_tv_template, XETA_DEC_TEST_VECTORS);
865
866 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
867 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
868 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
869 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
870 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
871 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
872 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
873 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
874 test_deflate();
875 test_crc32c();
876 #ifdef CONFIG_CRYPTO_HMAC
877 test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS);
878 test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS);
879 test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS);
880 #endif
881
882 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
883 break;
884
885 case 1:
886 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
887 break;
888
889 case 2:
890 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
891 break;
892
893 case 3:
894 test_cipher ("des", MODE_ECB, ENCRYPT, des_enc_tv_template, DES_ENC_TEST_VECTORS);
895 test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS);
896 test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS);
897 test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS);
898 break;
899
900 case 4:
901 test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS);
902 test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS);
903 break;
904
905 case 5:
906 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
907 break;
908
909 case 6:
910 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
911 break;
912
913 case 7:
914 test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS);
915 test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS);
916 test_cipher ("blowfish", MODE_CBC, ENCRYPT, bf_cbc_enc_tv_template, BF_CBC_ENC_TEST_VECTORS);
917 test_cipher ("blowfish", MODE_CBC, DECRYPT, bf_cbc_dec_tv_template, BF_CBC_DEC_TEST_VECTORS);
918 break;
919
920 case 8:
921 test_cipher ("twofish", MODE_ECB, ENCRYPT, tf_enc_tv_template, TF_ENC_TEST_VECTORS);
922 test_cipher ("twofish", MODE_ECB, DECRYPT, tf_dec_tv_template, TF_DEC_TEST_VECTORS);
923 test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS);
924 test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS);
925 break;
926
927 case 9:
928 test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS);
929 test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS);
930 break;
931
932 case 10:
933 test_cipher ("aes", MODE_ECB, ENCRYPT, aes_enc_tv_template, AES_ENC_TEST_VECTORS);
934 test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS);
935 break;
936
937 case 11:
938 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
939 break;
940
941 case 12:
942 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
943 break;
944
945 case 13:
946 test_deflate();
947 break;
948
949 case 14:
950 test_cipher ("cast5", MODE_ECB, ENCRYPT, cast5_enc_tv_template, CAST5_ENC_TEST_VECTORS);
951 test_cipher ("cast5", MODE_ECB, DECRYPT, cast5_dec_tv_template, CAST5_DEC_TEST_VECTORS);
952 break;
953
954 case 15:
955 test_cipher ("cast6", MODE_ECB, ENCRYPT, cast6_enc_tv_template, CAST6_ENC_TEST_VECTORS);
956 test_cipher ("cast6", MODE_ECB, DECRYPT, cast6_dec_tv_template, CAST6_DEC_TEST_VECTORS);
957 break;
958
959 case 16:
960 test_cipher ("arc4", MODE_ECB, ENCRYPT, arc4_enc_tv_template, ARC4_ENC_TEST_VECTORS);
961 test_cipher ("arc4", MODE_ECB, DECRYPT, arc4_dec_tv_template, ARC4_DEC_TEST_VECTORS);
962 break;
963
964 case 17:
965 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
966 break;
967
968 case 18:
969 test_crc32c();
970 break;
971
972 case 19:
973 test_cipher ("tea", MODE_ECB, ENCRYPT, tea_enc_tv_template, TEA_ENC_TEST_VECTORS);
974 test_cipher ("tea", MODE_ECB, DECRYPT, tea_dec_tv_template, TEA_DEC_TEST_VECTORS);
975 break;
976
977 case 20:
978 test_cipher ("xtea", MODE_ECB, ENCRYPT, xtea_enc_tv_template, XTEA_ENC_TEST_VECTORS);
979 test_cipher ("xtea", MODE_ECB, DECRYPT, xtea_dec_tv_template, XTEA_DEC_TEST_VECTORS);
980 break;
981
982 case 21:
983 test_cipher ("khazad", MODE_ECB, ENCRYPT, khazad_enc_tv_template, KHAZAD_ENC_TEST_VECTORS);
984 test_cipher ("khazad", MODE_ECB, DECRYPT, khazad_dec_tv_template, KHAZAD_DEC_TEST_VECTORS);
985 break;
986
987 case 22:
988 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
989 break;
990
991 case 23:
992 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
993 break;
994
995 case 24:
996 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
997 break;
998
999 case 25:
1000 test_cipher ("tnepres", MODE_ECB, ENCRYPT, tnepres_enc_tv_template, TNEPRES_ENC_TEST_VECTORS);
1001 test_cipher ("tnepres", MODE_ECB, DECRYPT, tnepres_dec_tv_template, TNEPRES_DEC_TEST_VECTORS);
1002 break;
1003
1004 case 26:
1005 test_cipher ("anubis", MODE_ECB, ENCRYPT, anubis_enc_tv_template, ANUBIS_ENC_TEST_VECTORS);
1006 test_cipher ("anubis", MODE_ECB, DECRYPT, anubis_dec_tv_template, ANUBIS_DEC_TEST_VECTORS);
1007 test_cipher ("anubis", MODE_CBC, ENCRYPT, anubis_cbc_enc_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
1008 test_cipher ("anubis", MODE_CBC, DECRYPT, anubis_cbc_dec_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
1009 break;
1010
1011 case 27:
1012 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
1013 break;
1014
1015 case 28:
1016
1017 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
1018 break;
1019
1020 case 29:
1021 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
1022 break;
1023
1024 case 30:
1025 test_cipher ("xeta", MODE_ECB, ENCRYPT, xeta_enc_tv_template, XETA_ENC_TEST_VECTORS);
1026 test_cipher ("xeta", MODE_ECB, DECRYPT, xeta_dec_tv_template, XETA_DEC_TEST_VECTORS);
1027 break;
1028
1029 #ifdef CONFIG_CRYPTO_HMAC
1030 case 100:
1031 test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS);
1032 break;
1033
1034 case 101:
1035 test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS);
1036 break;
1037
1038 case 102:
1039 test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS);
1040 break;
1041
1042 #endif
1043
1044 case 200:
1045 test_cipher_speed("aes", MODE_ECB, ENCRYPT, sec, NULL, 0,
1046 aes_speed_template);
1047 test_cipher_speed("aes", MODE_ECB, DECRYPT, sec, NULL, 0,
1048 aes_speed_template);
1049 test_cipher_speed("aes", MODE_CBC, ENCRYPT, sec, NULL, 0,
1050 aes_speed_template);
1051 test_cipher_speed("aes", MODE_CBC, DECRYPT, sec, NULL, 0,
1052 aes_speed_template);
1053 break;
1054
1055 case 201:
1056 test_cipher_speed("des3_ede", MODE_ECB, ENCRYPT, sec,
1057 des3_ede_enc_tv_template,
1058 DES3_EDE_ENC_TEST_VECTORS,
1059 des3_ede_speed_template);
1060 test_cipher_speed("des3_ede", MODE_ECB, DECRYPT, sec,
1061 des3_ede_dec_tv_template,
1062 DES3_EDE_DEC_TEST_VECTORS,
1063 des3_ede_speed_template);
1064 test_cipher_speed("des3_ede", MODE_CBC, ENCRYPT, sec,
1065 des3_ede_enc_tv_template,
1066 DES3_EDE_ENC_TEST_VECTORS,
1067 des3_ede_speed_template);
1068 test_cipher_speed("des3_ede", MODE_CBC, DECRYPT, sec,
1069 des3_ede_dec_tv_template,
1070 DES3_EDE_DEC_TEST_VECTORS,
1071 des3_ede_speed_template);
1072 break;
1073
1074 case 202:
1075 test_cipher_speed("twofish", MODE_ECB, ENCRYPT, sec, NULL, 0,
1076 twofish_speed_template);
1077 test_cipher_speed("twofish", MODE_ECB, DECRYPT, sec, NULL, 0,
1078 twofish_speed_template);
1079 test_cipher_speed("twofish", MODE_CBC, ENCRYPT, sec, NULL, 0,
1080 twofish_speed_template);
1081 test_cipher_speed("twofish", MODE_CBC, DECRYPT, sec, NULL, 0,
1082 twofish_speed_template);
1083 break;
1084
1085 case 203:
1086 test_cipher_speed("blowfish", MODE_ECB, ENCRYPT, sec, NULL, 0,
1087 blowfish_speed_template);
1088 test_cipher_speed("blowfish", MODE_ECB, DECRYPT, sec, NULL, 0,
1089 blowfish_speed_template);
1090 test_cipher_speed("blowfish", MODE_CBC, ENCRYPT, sec, NULL, 0,
1091 blowfish_speed_template);
1092 test_cipher_speed("blowfish", MODE_CBC, DECRYPT, sec, NULL, 0,
1093 blowfish_speed_template);
1094 break;
1095
1096 case 204:
1097 test_cipher_speed("des", MODE_ECB, ENCRYPT, sec, NULL, 0,
1098 des_speed_template);
1099 test_cipher_speed("des", MODE_ECB, DECRYPT, sec, NULL, 0,
1100 des_speed_template);
1101 test_cipher_speed("des", MODE_CBC, ENCRYPT, sec, NULL, 0,
1102 des_speed_template);
1103 test_cipher_speed("des", MODE_CBC, DECRYPT, sec, NULL, 0,
1104 des_speed_template);
1105 break;
1106
1107 case 1000:
1108 test_available();
1109 break;
1110
1111 default:
1112 /* useful for debugging */
1113 printk("not testing anything\n");
1114 break;
1115 }
1116 }
1117
1118 static int __init init(void)
1119 {
1120 tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL);
1121 if (tvmem == NULL)
1122 return -ENOMEM;
1123
1124 xbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
1125 if (xbuf == NULL) {
1126 kfree(tvmem);
1127 return -ENOMEM;
1128 }
1129
1130 do_test();
1131
1132 kfree(xbuf);
1133 kfree(tvmem);
1134 return 0;
1135 }
1136
1137 /*
1138 * If an init function is provided, an exit function must also be provided
1139 * to allow module unload.
1140 */
1141 static void __exit fini(void) { }
1142
1143 module_init(init);
1144 module_exit(fini);
1145
1146 module_param(mode, int, 0);
1147 module_param(sec, uint, 0);
1148 MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
1149 "(defaults to zero which uses CPU cycles instead)");
1150
1151 MODULE_LICENSE("GPL");
1152 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
1153 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
USB Experimental Work