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/err.h> 21 #include <linux/init.h> 22 #include <linux/module.h> 23 #include <linux/mm.h> 24 #include <linux/slab.h> 25 #include <linux/scatterlist.h> 26 #include <linux/string.h> 27 #include <linux/crypto.h> 28 #include <linux/highmem.h> 29 #include <linux/moduleparam.h> 30 #include <linux/jiffies.h> 31 #include <linux/timex.h> 32 #include <linux/interrupt.h> 33 #include "tcrypt.h" 34 35 /* 36 * Need to kmalloc() memory for testing kmap(). 37 */ 38 #define TVMEMSIZE 16384 39 #define XBUFSIZE 32768 40 41 /* 42 * Indexes into the xbuf to simulate cross-page access. 43 */ 44 #define IDX1 37 45 #define IDX2 32400 46 #define IDX3 1 47 #define IDX4 8193 48 #define IDX5 22222 49 #define IDX6 17101 50 #define IDX7 27333 51 #define IDX8 3000 52 53 /* 54 * Used by test_cipher() 55 */ 56 #define ENCRYPT 1 57 #define DECRYPT 0 58 59 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 }; 60 61 /* 62 * Used by test_cipher_speed() 63 */ 64 static unsigned int sec; 65 66 static int mode; 67 static char *xbuf; 68 static char *tvmem; 69 70 static char *check[] = { 71 "des", "md5", "des3_ede", "rot13", "sha1", "sha256", "blowfish", 72 "twofish", "serpent", "sha384", "sha512", "md4", "aes", "cast6", 73 "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea", 74 "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", NULL 75 }; 76 77 static void hexdump(unsigned char *buf, unsigned int len) 78 { 79 while (len--) 80 printk("%02x", *buf++); 81 82 printk("\n"); 83 } 84 85 static void test_hash(char *algo, struct hash_testvec *template, 86 unsigned int tcount) 87 { 88 unsigned int i, j, k, temp; 89 struct scatterlist sg[8]; 90 char result[64]; 91 struct crypto_hash *tfm; 92 struct hash_desc desc; 93 struct hash_testvec *hash_tv; 94 unsigned int tsize; 95 int ret; 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 110 tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC); 111 if (IS_ERR(tfm)) { 112 printk("failed to load transform for %s: %ld\n", algo, 113 PTR_ERR(tfm)); 114 return; 115 } 116 117 desc.tfm = tfm; 118 desc.flags = 0; 119 120 for (i = 0; i < tcount; i++) { 121 printk("test %u:\n", i + 1); 122 memset(result, 0, 64); 123 124 sg_set_buf(&sg[0], hash_tv[i].plaintext, hash_tv[i].psize); 125 126 if (hash_tv[i].ksize) { 127 ret = crypto_hash_setkey(tfm, hash_tv[i].key, 128 hash_tv[i].ksize); 129 if (ret) { 130 printk("setkey() failed ret=%d\n", ret); 131 goto out; 132 } 133 } 134 135 ret = crypto_hash_digest(&desc, sg, hash_tv[i].psize, result); 136 if (ret) { 137 printk("digest () failed ret=%d\n", ret); 138 goto out; 139 } 140 141 hexdump(result, crypto_hash_digestsize(tfm)); 142 printk("%s\n", 143 memcmp(result, hash_tv[i].digest, 144 crypto_hash_digestsize(tfm)) ? 145 "fail" : "pass"); 146 } 147 148 printk("testing %s across pages\n", algo); 149 150 /* setup the dummy buffer first */ 151 memset(xbuf, 0, XBUFSIZE); 152 153 j = 0; 154 for (i = 0; i < tcount; i++) { 155 if (hash_tv[i].np) { 156 j++; 157 printk("test %u:\n", j); 158 memset(result, 0, 64); 159 160 temp = 0; 161 for (k = 0; k < hash_tv[i].np; k++) { 162 memcpy(&xbuf[IDX[k]], 163 hash_tv[i].plaintext + temp, 164 hash_tv[i].tap[k]); 165 temp += hash_tv[i].tap[k]; 166 sg_set_buf(&sg[k], &xbuf[IDX[k]], 167 hash_tv[i].tap[k]); 168 } 169 170 if (hash_tv[i].ksize) { 171 ret = crypto_hash_setkey(tfm, hash_tv[i].key, 172 hash_tv[i].ksize); 173 174 if (ret) { 175 printk("setkey() failed ret=%d\n", ret); 176 goto out; 177 } 178 } 179 180 ret = crypto_hash_digest(&desc, sg, hash_tv[i].psize, 181 result); 182 if (ret) { 183 printk("digest () failed ret=%d\n", ret); 184 goto out; 185 } 186 187 hexdump(result, crypto_hash_digestsize(tfm)); 188 printk("%s\n", 189 memcmp(result, hash_tv[i].digest, 190 crypto_hash_digestsize(tfm)) ? 191 "fail" : "pass"); 192 } 193 } 194 195 out: 196 crypto_free_hash(tfm); 197 } 198 199 static void test_cipher(char *algo, int enc, 200 struct cipher_testvec *template, unsigned int tcount) 201 { 202 unsigned int ret, i, j, k, temp; 203 unsigned int tsize; 204 unsigned int iv_len; 205 unsigned int len; 206 char *q; 207 struct crypto_blkcipher *tfm; 208 char *key; 209 struct cipher_testvec *cipher_tv; 210 struct blkcipher_desc desc; 211 struct scatterlist sg[8]; 212 const char *e; 213 214 if (enc == ENCRYPT) 215 e = "encryption"; 216 else 217 e = "decryption"; 218 219 printk("\ntesting %s %s\n", algo, e); 220 221 tsize = sizeof (struct cipher_testvec); 222 tsize *= tcount; 223 224 if (tsize > TVMEMSIZE) { 225 printk("template (%u) too big for tvmem (%u)\n", tsize, 226 TVMEMSIZE); 227 return; 228 } 229 230 memcpy(tvmem, template, tsize); 231 cipher_tv = (void *)tvmem; 232 233 tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC); 234 235 if (IS_ERR(tfm)) { 236 printk("failed to load transform for %s: %ld\n", algo, 237 PTR_ERR(tfm)); 238 return; 239 } 240 desc.tfm = tfm; 241 desc.flags = 0; 242 243 j = 0; 244 for (i = 0; i < tcount; i++) { 245 if (!(cipher_tv[i].np)) { 246 j++; 247 printk("test %u (%d bit key):\n", 248 j, cipher_tv[i].klen * 8); 249 250 crypto_blkcipher_clear_flags(tfm, ~0); 251 if (cipher_tv[i].wk) 252 crypto_blkcipher_set_flags( 253 tfm, CRYPTO_TFM_REQ_WEAK_KEY); 254 key = cipher_tv[i].key; 255 256 ret = crypto_blkcipher_setkey(tfm, key, 257 cipher_tv[i].klen); 258 if (ret) { 259 printk("setkey() failed flags=%x\n", 260 crypto_blkcipher_get_flags(tfm)); 261 262 if (!cipher_tv[i].fail) 263 goto out; 264 } 265 266 sg_set_buf(&sg[0], cipher_tv[i].input, 267 cipher_tv[i].ilen); 268 269 iv_len = crypto_blkcipher_ivsize(tfm); 270 if (iv_len) 271 crypto_blkcipher_set_iv(tfm, cipher_tv[i].iv, 272 iv_len); 273 274 len = cipher_tv[i].ilen; 275 ret = enc ? 276 crypto_blkcipher_encrypt(&desc, sg, sg, len) : 277 crypto_blkcipher_decrypt(&desc, sg, sg, len); 278 279 if (ret) { 280 printk("%s () failed flags=%x\n", e, 281 desc.flags); 282 goto out; 283 } 284 285 q = kmap(sg[0].page) + sg[0].offset; 286 hexdump(q, cipher_tv[i].rlen); 287 288 printk("%s\n", 289 memcmp(q, cipher_tv[i].result, 290 cipher_tv[i].rlen) ? "fail" : "pass"); 291 } 292 } 293 294 printk("\ntesting %s %s across pages (chunking)\n", algo, e); 295 memset(xbuf, 0, XBUFSIZE); 296 297 j = 0; 298 for (i = 0; i < tcount; i++) { 299 if (cipher_tv[i].np) { 300 j++; 301 printk("test %u (%d bit key):\n", 302 j, cipher_tv[i].klen * 8); 303 304 crypto_blkcipher_clear_flags(tfm, ~0); 305 if (cipher_tv[i].wk) 306 crypto_blkcipher_set_flags( 307 tfm, CRYPTO_TFM_REQ_WEAK_KEY); 308 key = cipher_tv[i].key; 309 310 ret = crypto_blkcipher_setkey(tfm, key, 311 cipher_tv[i].klen); 312 if (ret) { 313 printk("setkey() failed flags=%x\n", 314 crypto_blkcipher_get_flags(tfm)); 315 316 if (!cipher_tv[i].fail) 317 goto out; 318 } 319 320 temp = 0; 321 for (k = 0; k < cipher_tv[i].np; k++) { 322 memcpy(&xbuf[IDX[k]], 323 cipher_tv[i].input + temp, 324 cipher_tv[i].tap[k]); 325 temp += cipher_tv[i].tap[k]; 326 sg_set_buf(&sg[k], &xbuf[IDX[k]], 327 cipher_tv[i].tap[k]); 328 } 329 330 iv_len = crypto_blkcipher_ivsize(tfm); 331 if (iv_len) 332 crypto_blkcipher_set_iv(tfm, cipher_tv[i].iv, 333 iv_len); 334 335 len = cipher_tv[i].ilen; 336 ret = enc ? 337 crypto_blkcipher_encrypt(&desc, sg, sg, len) : 338 crypto_blkcipher_decrypt(&desc, sg, sg, len); 339 340 if (ret) { 341 printk("%s () failed flags=%x\n", e, 342 desc.flags); 343 goto out; 344 } 345 346 temp = 0; 347 for (k = 0; k < cipher_tv[i].np; k++) { 348 printk("page %u\n", k); 349 q = kmap(sg[k].page) + sg[k].offset; 350 hexdump(q, cipher_tv[i].tap[k]); 351 printk("%s\n", 352 memcmp(q, cipher_tv[i].result + temp, 353 cipher_tv[i].tap[k]) ? "fail" : 354 "pass"); 355 temp += cipher_tv[i].tap[k]; 356 } 357 } 358 } 359 360 out: 361 crypto_free_blkcipher(tfm); 362 } 363 364 static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc, char *p, 365 int blen, int sec) 366 { 367 struct scatterlist sg[1]; 368 unsigned long start, end; 369 int bcount; 370 int ret; 371 372 sg_set_buf(sg, p, blen); 373 374 for (start = jiffies, end = start + sec * HZ, bcount = 0; 375 time_before(jiffies, end); bcount++) { 376 if (enc) 377 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen); 378 else 379 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen); 380 381 if (ret) 382 return ret; 383 } 384 385 printk("%d operations in %d seconds (%ld bytes)\n", 386 bcount, sec, (long)bcount * blen); 387 return 0; 388 } 389 390 static int test_cipher_cycles(struct blkcipher_desc *desc, int enc, char *p, 391 int blen) 392 { 393 struct scatterlist sg[1]; 394 unsigned long cycles = 0; 395 int ret = 0; 396 int i; 397 398 sg_set_buf(sg, p, blen); 399 400 local_bh_disable(); 401 local_irq_disable(); 402 403 /* Warm-up run. */ 404 for (i = 0; i < 4; i++) { 405 if (enc) 406 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen); 407 else 408 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen); 409 410 if (ret) 411 goto out; 412 } 413 414 /* The real thing. */ 415 for (i = 0; i < 8; i++) { 416 cycles_t start, end; 417 418 start = get_cycles(); 419 if (enc) 420 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen); 421 else 422 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen); 423 end = get_cycles(); 424 425 if (ret) 426 goto out; 427 428 cycles += end - start; 429 } 430 431 out: 432 local_irq_enable(); 433 local_bh_enable(); 434 435 if (ret == 0) 436 printk("1 operation in %lu cycles (%d bytes)\n", 437 (cycles + 4) / 8, blen); 438 439 return ret; 440 } 441 442 static void test_cipher_speed(char *algo, int enc, unsigned int sec, 443 struct cipher_testvec *template, 444 unsigned int tcount, struct cipher_speed *speed) 445 { 446 unsigned int ret, i, j, iv_len; 447 unsigned char *key, *p, iv[128]; 448 struct crypto_blkcipher *tfm; 449 struct blkcipher_desc desc; 450 const char *e; 451 452 if (enc == ENCRYPT) 453 e = "encryption"; 454 else 455 e = "decryption"; 456 457 printk("\ntesting speed of %s %s\n", algo, e); 458 459 tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC); 460 461 if (IS_ERR(tfm)) { 462 printk("failed to load transform for %s: %ld\n", algo, 463 PTR_ERR(tfm)); 464 return; 465 } 466 desc.tfm = tfm; 467 desc.flags = 0; 468 469 for (i = 0; speed[i].klen != 0; i++) { 470 if ((speed[i].blen + speed[i].klen) > TVMEMSIZE) { 471 printk("template (%u) too big for tvmem (%u)\n", 472 speed[i].blen + speed[i].klen, TVMEMSIZE); 473 goto out; 474 } 475 476 printk("test %u (%d bit key, %d byte blocks): ", i, 477 speed[i].klen * 8, speed[i].blen); 478 479 memset(tvmem, 0xff, speed[i].klen + speed[i].blen); 480 481 /* set key, plain text and IV */ 482 key = (unsigned char *)tvmem; 483 for (j = 0; j < tcount; j++) { 484 if (template[j].klen == speed[i].klen) { 485 key = template[j].key; 486 break; 487 } 488 } 489 p = (unsigned char *)tvmem + speed[i].klen; 490 491 ret = crypto_blkcipher_setkey(tfm, key, speed[i].klen); 492 if (ret) { 493 printk("setkey() failed flags=%x\n", 494 crypto_blkcipher_get_flags(tfm)); 495 goto out; 496 } 497 498 iv_len = crypto_blkcipher_ivsize(tfm); 499 if (iv_len) { 500 memset(&iv, 0xff, iv_len); 501 crypto_blkcipher_set_iv(tfm, iv, iv_len); 502 } 503 504 if (sec) 505 ret = test_cipher_jiffies(&desc, enc, p, speed[i].blen, 506 sec); 507 else 508 ret = test_cipher_cycles(&desc, enc, p, speed[i].blen); 509 510 if (ret) { 511 printk("%s() failed flags=%x\n", e, desc.flags); 512 break; 513 } 514 } 515 516 out: 517 crypto_free_blkcipher(tfm); 518 } 519 520 static int test_hash_jiffies_digest(struct hash_desc *desc, char *p, int blen, 521 char *out, int sec) 522 { 523 struct scatterlist sg[1]; 524 unsigned long start, end; 525 int bcount; 526 int ret; 527 528 for (start = jiffies, end = start + sec * HZ, bcount = 0; 529 time_before(jiffies, end); bcount++) { 530 sg_set_buf(sg, p, blen); 531 ret = crypto_hash_digest(desc, sg, blen, out); 532 if (ret) 533 return ret; 534 } 535 536 printk("%6u opers/sec, %9lu bytes/sec\n", 537 bcount / sec, ((long)bcount * blen) / sec); 538 539 return 0; 540 } 541 542 static int test_hash_jiffies(struct hash_desc *desc, char *p, int blen, 543 int plen, char *out, int sec) 544 { 545 struct scatterlist sg[1]; 546 unsigned long start, end; 547 int bcount, pcount; 548 int ret; 549 550 if (plen == blen) 551 return test_hash_jiffies_digest(desc, p, blen, out, sec); 552 553 for (start = jiffies, end = start + sec * HZ, bcount = 0; 554 time_before(jiffies, end); bcount++) { 555 ret = crypto_hash_init(desc); 556 if (ret) 557 return ret; 558 for (pcount = 0; pcount < blen; pcount += plen) { 559 sg_set_buf(sg, p + pcount, plen); 560 ret = crypto_hash_update(desc, sg, plen); 561 if (ret) 562 return ret; 563 } 564 /* we assume there is enough space in 'out' for the result */ 565 ret = crypto_hash_final(desc, out); 566 if (ret) 567 return ret; 568 } 569 570 printk("%6u opers/sec, %9lu bytes/sec\n", 571 bcount / sec, ((long)bcount * blen) / sec); 572 573 return 0; 574 } 575 576 static int test_hash_cycles_digest(struct hash_desc *desc, char *p, int blen, 577 char *out) 578 { 579 struct scatterlist sg[1]; 580 unsigned long cycles = 0; 581 int i; 582 int ret; 583 584 local_bh_disable(); 585 local_irq_disable(); 586 587 /* Warm-up run. */ 588 for (i = 0; i < 4; i++) { 589 sg_set_buf(sg, p, blen); 590 ret = crypto_hash_digest(desc, sg, blen, out); 591 if (ret) 592 goto out; 593 } 594 595 /* The real thing. */ 596 for (i = 0; i < 8; i++) { 597 cycles_t start, end; 598 599 start = get_cycles(); 600 601 sg_set_buf(sg, p, blen); 602 ret = crypto_hash_digest(desc, sg, blen, out); 603 if (ret) 604 goto out; 605 606 end = get_cycles(); 607 608 cycles += end - start; 609 } 610 611 out: 612 local_irq_enable(); 613 local_bh_enable(); 614 615 if (ret) 616 return ret; 617 618 printk("%6lu cycles/operation, %4lu cycles/byte\n", 619 cycles / 8, cycles / (8 * blen)); 620 621 return 0; 622 } 623 624 static int test_hash_cycles(struct hash_desc *desc, char *p, int blen, 625 int plen, char *out) 626 { 627 struct scatterlist sg[1]; 628 unsigned long cycles = 0; 629 int i, pcount; 630 int ret; 631 632 if (plen == blen) 633 return test_hash_cycles_digest(desc, p, blen, out); 634 635 local_bh_disable(); 636 local_irq_disable(); 637 638 /* Warm-up run. */ 639 for (i = 0; i < 4; i++) { 640 ret = crypto_hash_init(desc); 641 if (ret) 642 goto out; 643 for (pcount = 0; pcount < blen; pcount += plen) { 644 sg_set_buf(sg, p + pcount, plen); 645 ret = crypto_hash_update(desc, sg, plen); 646 if (ret) 647 goto out; 648 } 649 crypto_hash_final(desc, out); 650 if (ret) 651 goto out; 652 } 653 654 /* The real thing. */ 655 for (i = 0; i < 8; i++) { 656 cycles_t start, end; 657 658 start = get_cycles(); 659 660 ret = crypto_hash_init(desc); 661 if (ret) 662 goto out; 663 for (pcount = 0; pcount < blen; pcount += plen) { 664 sg_set_buf(sg, p + pcount, plen); 665 ret = crypto_hash_update(desc, sg, plen); 666 if (ret) 667 goto out; 668 } 669 ret = crypto_hash_final(desc, out); 670 if (ret) 671 goto out; 672 673 end = get_cycles(); 674 675 cycles += end - start; 676 } 677 678 out: 679 local_irq_enable(); 680 local_bh_enable(); 681 682 if (ret) 683 return ret; 684 685 printk("%6lu cycles/operation, %4lu cycles/byte\n", 686 cycles / 8, cycles / (8 * blen)); 687 688 return 0; 689 } 690 691 static void test_hash_speed(char *algo, unsigned int sec, 692 struct hash_speed *speed) 693 { 694 struct crypto_hash *tfm; 695 struct hash_desc desc; 696 char output[1024]; 697 int i; 698 int ret; 699 700 printk("\ntesting speed of %s\n", algo); 701 702 tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC); 703 704 if (IS_ERR(tfm)) { 705 printk("failed to load transform for %s: %ld\n", algo, 706 PTR_ERR(tfm)); 707 return; 708 } 709 710 desc.tfm = tfm; 711 desc.flags = 0; 712 713 if (crypto_hash_digestsize(tfm) > sizeof(output)) { 714 printk("digestsize(%u) > outputbuffer(%zu)\n", 715 crypto_hash_digestsize(tfm), sizeof(output)); 716 goto out; 717 } 718 719 for (i = 0; speed[i].blen != 0; i++) { 720 if (speed[i].blen > TVMEMSIZE) { 721 printk("template (%u) too big for tvmem (%u)\n", 722 speed[i].blen, TVMEMSIZE); 723 goto out; 724 } 725 726 printk("test%3u (%5u byte blocks,%5u bytes per update,%4u updates): ", 727 i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen); 728 729 memset(tvmem, 0xff, speed[i].blen); 730 731 if (sec) 732 ret = test_hash_jiffies(&desc, tvmem, speed[i].blen, 733 speed[i].plen, output, sec); 734 else 735 ret = test_hash_cycles(&desc, tvmem, speed[i].blen, 736 speed[i].plen, output); 737 738 if (ret) { 739 printk("hashing failed ret=%d\n", ret); 740 break; 741 } 742 } 743 744 out: 745 crypto_free_hash(tfm); 746 } 747 748 static void test_deflate(void) 749 { 750 unsigned int i; 751 char result[COMP_BUF_SIZE]; 752 struct crypto_comp *tfm; 753 struct comp_testvec *tv; 754 unsigned int tsize; 755 756 printk("\ntesting deflate compression\n"); 757 758 tsize = sizeof (deflate_comp_tv_template); 759 if (tsize > TVMEMSIZE) { 760 printk("template (%u) too big for tvmem (%u)\n", tsize, 761 TVMEMSIZE); 762 return; 763 } 764 765 memcpy(tvmem, deflate_comp_tv_template, tsize); 766 tv = (void *)tvmem; 767 768 tfm = crypto_alloc_tfm("deflate", 0); 769 if (tfm == NULL) { 770 printk("failed to load transform for deflate\n"); 771 return; 772 } 773 774 for (i = 0; i < DEFLATE_COMP_TEST_VECTORS; i++) { 775 int ilen, ret, dlen = COMP_BUF_SIZE; 776 777 printk("test %u:\n", i + 1); 778 memset(result, 0, sizeof (result)); 779 780 ilen = tv[i].inlen; 781 ret = crypto_comp_compress(tfm, tv[i].input, 782 ilen, result, &dlen); 783 if (ret) { 784 printk("fail: ret=%d\n", ret); 785 continue; 786 } 787 hexdump(result, dlen); 788 printk("%s (ratio %d:%d)\n", 789 memcmp(result, tv[i].output, dlen) ? "fail" : "pass", 790 ilen, dlen); 791 } 792 793 printk("\ntesting deflate decompression\n"); 794 795 tsize = sizeof (deflate_decomp_tv_template); 796 if (tsize > TVMEMSIZE) { 797 printk("template (%u) too big for tvmem (%u)\n", tsize, 798 TVMEMSIZE); 799 goto out; 800 } 801 802 memcpy(tvmem, deflate_decomp_tv_template, tsize); 803 tv = (void *)tvmem; 804 805 for (i = 0; i < DEFLATE_DECOMP_TEST_VECTORS; i++) { 806 int ilen, ret, dlen = COMP_BUF_SIZE; 807 808 printk("test %u:\n", i + 1); 809 memset(result, 0, sizeof (result)); 810 811 ilen = tv[i].inlen; 812 ret = crypto_comp_decompress(tfm, tv[i].input, 813 ilen, result, &dlen); 814 if (ret) { 815 printk("fail: ret=%d\n", ret); 816 continue; 817 } 818 hexdump(result, dlen); 819 printk("%s (ratio %d:%d)\n", 820 memcmp(result, tv[i].output, dlen) ? "fail" : "pass", 821 ilen, dlen); 822 } 823 out: 824 crypto_free_comp(tfm); 825 } 826 827 static void test_available(void) 828 { 829 char **name = check; 830 831 while (*name) { 832 printk("alg %s ", *name); 833 printk(crypto_has_alg(*name, 0, CRYPTO_ALG_ASYNC) ? 834 "found\n" : "not found\n"); 835 name++; 836 } 837 } 838 839 static void do_test(void) 840 { 841 switch (mode) { 842 843 case 0: 844 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS); 845 846 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS); 847 848 //DES 849 test_cipher("ecb(des)", ENCRYPT, des_enc_tv_template, 850 DES_ENC_TEST_VECTORS); 851 test_cipher("ecb(des)", DECRYPT, des_dec_tv_template, 852 DES_DEC_TEST_VECTORS); 853 test_cipher("cbc(des)", ENCRYPT, des_cbc_enc_tv_template, 854 DES_CBC_ENC_TEST_VECTORS); 855 test_cipher("cbc(des)", DECRYPT, des_cbc_dec_tv_template, 856 DES_CBC_DEC_TEST_VECTORS); 857 858 //DES3_EDE 859 test_cipher("ecb(des3_ede)", ENCRYPT, des3_ede_enc_tv_template, 860 DES3_EDE_ENC_TEST_VECTORS); 861 test_cipher("ecb(des3_ede)", DECRYPT, des3_ede_dec_tv_template, 862 DES3_EDE_DEC_TEST_VECTORS); 863 864 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS); 865 866 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS); 867 868 //BLOWFISH 869 test_cipher("ecb(blowfish)", ENCRYPT, bf_enc_tv_template, 870 BF_ENC_TEST_VECTORS); 871 test_cipher("ecb(blowfish)", DECRYPT, bf_dec_tv_template, 872 BF_DEC_TEST_VECTORS); 873 test_cipher("cbc(blowfish)", ENCRYPT, bf_cbc_enc_tv_template, 874 BF_CBC_ENC_TEST_VECTORS); 875 test_cipher("cbc(blowfish)", DECRYPT, bf_cbc_dec_tv_template, 876 BF_CBC_DEC_TEST_VECTORS); 877 878 //TWOFISH 879 test_cipher("ecb(twofish)", ENCRYPT, tf_enc_tv_template, 880 TF_ENC_TEST_VECTORS); 881 test_cipher("ecb(twofish)", DECRYPT, tf_dec_tv_template, 882 TF_DEC_TEST_VECTORS); 883 test_cipher("cbc(twofish)", ENCRYPT, tf_cbc_enc_tv_template, 884 TF_CBC_ENC_TEST_VECTORS); 885 test_cipher("cbc(twofish)", DECRYPT, tf_cbc_dec_tv_template, 886 TF_CBC_DEC_TEST_VECTORS); 887 888 //SERPENT 889 test_cipher("ecb(serpent)", ENCRYPT, serpent_enc_tv_template, 890 SERPENT_ENC_TEST_VECTORS); 891 test_cipher("ecb(serpent)", DECRYPT, serpent_dec_tv_template, 892 SERPENT_DEC_TEST_VECTORS); 893 894 //TNEPRES 895 test_cipher("ecb(tnepres)", ENCRYPT, tnepres_enc_tv_template, 896 TNEPRES_ENC_TEST_VECTORS); 897 test_cipher("ecb(tnepres)", DECRYPT, tnepres_dec_tv_template, 898 TNEPRES_DEC_TEST_VECTORS); 899 900 //AES 901 test_cipher("ecb(aes)", ENCRYPT, aes_enc_tv_template, 902 AES_ENC_TEST_VECTORS); 903 test_cipher("ecb(aes)", DECRYPT, aes_dec_tv_template, 904 AES_DEC_TEST_VECTORS); 905 test_cipher("cbc(aes)", ENCRYPT, aes_cbc_enc_tv_template, 906 AES_CBC_ENC_TEST_VECTORS); 907 test_cipher("cbc(aes)", DECRYPT, aes_cbc_dec_tv_template, 908 AES_CBC_DEC_TEST_VECTORS); 909 910 //CAST5 911 test_cipher("ecb(cast5)", ENCRYPT, cast5_enc_tv_template, 912 CAST5_ENC_TEST_VECTORS); 913 test_cipher("ecb(cast5)", DECRYPT, cast5_dec_tv_template, 914 CAST5_DEC_TEST_VECTORS); 915 916 //CAST6 917 test_cipher("ecb(cast6)", ENCRYPT, cast6_enc_tv_template, 918 CAST6_ENC_TEST_VECTORS); 919 test_cipher("ecb(cast6)", DECRYPT, cast6_dec_tv_template, 920 CAST6_DEC_TEST_VECTORS); 921 922 //ARC4 923 test_cipher("ecb(arc4)", ENCRYPT, arc4_enc_tv_template, 924 ARC4_ENC_TEST_VECTORS); 925 test_cipher("ecb(arc4)", DECRYPT, arc4_dec_tv_template, 926 ARC4_DEC_TEST_VECTORS); 927 928 //TEA 929 test_cipher("ecb(tea)", ENCRYPT, tea_enc_tv_template, 930 TEA_ENC_TEST_VECTORS); 931 test_cipher("ecb(tea)", DECRYPT, tea_dec_tv_template, 932 TEA_DEC_TEST_VECTORS); 933 934 935 //XTEA 936 test_cipher("ecb(xtea)", ENCRYPT, xtea_enc_tv_template, 937 XTEA_ENC_TEST_VECTORS); 938 test_cipher("ecb(xtea)", DECRYPT, xtea_dec_tv_template, 939 XTEA_DEC_TEST_VECTORS); 940 941 //KHAZAD 942 test_cipher("ecb(khazad)", ENCRYPT, khazad_enc_tv_template, 943 KHAZAD_ENC_TEST_VECTORS); 944 test_cipher("ecb(khazad)", DECRYPT, khazad_dec_tv_template, 945 KHAZAD_DEC_TEST_VECTORS); 946 947 //ANUBIS 948 test_cipher("ecb(anubis)", ENCRYPT, anubis_enc_tv_template, 949 ANUBIS_ENC_TEST_VECTORS); 950 test_cipher("ecb(anubis)", DECRYPT, anubis_dec_tv_template, 951 ANUBIS_DEC_TEST_VECTORS); 952 test_cipher("cbc(anubis)", ENCRYPT, anubis_cbc_enc_tv_template, 953 ANUBIS_CBC_ENC_TEST_VECTORS); 954 test_cipher("cbc(anubis)", DECRYPT, anubis_cbc_dec_tv_template, 955 ANUBIS_CBC_ENC_TEST_VECTORS); 956 957 //XETA 958 test_cipher("ecb(xeta)", ENCRYPT, xeta_enc_tv_template, 959 XETA_ENC_TEST_VECTORS); 960 test_cipher("ecb(xeta)", DECRYPT, xeta_dec_tv_template, 961 XETA_DEC_TEST_VECTORS); 962 963 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS); 964 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS); 965 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS); 966 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS); 967 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS); 968 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS); 969 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS); 970 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS); 971 test_deflate(); 972 test_hash("crc32c", crc32c_tv_template, CRC32C_TEST_VECTORS); 973 test_hash("hmac(md5)", hmac_md5_tv_template, 974 HMAC_MD5_TEST_VECTORS); 975 test_hash("hmac(sha1)", hmac_sha1_tv_template, 976 HMAC_SHA1_TEST_VECTORS); 977 test_hash("hmac(sha256)", hmac_sha256_tv_template, 978 HMAC_SHA256_TEST_VECTORS); 979 980 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS); 981 break; 982 983 case 1: 984 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS); 985 break; 986 987 case 2: 988 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS); 989 break; 990 991 case 3: 992 test_cipher("ecb(des)", ENCRYPT, des_enc_tv_template, 993 DES_ENC_TEST_VECTORS); 994 test_cipher("ecb(des)", DECRYPT, des_dec_tv_template, 995 DES_DEC_TEST_VECTORS); 996 test_cipher("cbc(des)", ENCRYPT, des_cbc_enc_tv_template, 997 DES_CBC_ENC_TEST_VECTORS); 998 test_cipher("cbc(des)", DECRYPT, des_cbc_dec_tv_template, 999 DES_CBC_DEC_TEST_VECTORS); 1000 break; 1001 1002 case 4: 1003 test_cipher("ecb(des3_ede)", ENCRYPT, des3_ede_enc_tv_template, 1004 DES3_EDE_ENC_TEST_VECTORS); 1005 test_cipher("ecb(des3_ede)", DECRYPT, des3_ede_dec_tv_template, 1006 DES3_EDE_DEC_TEST_VECTORS); 1007 break; 1008 1009 case 5: 1010 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS); 1011 break; 1012 1013 case 6: 1014 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS); 1015 break; 1016 1017 case 7: 1018 test_cipher("ecb(blowfish)", ENCRYPT, bf_enc_tv_template, 1019 BF_ENC_TEST_VECTORS); 1020 test_cipher("ecb(blowfish)", DECRYPT, bf_dec_tv_template, 1021 BF_DEC_TEST_VECTORS); 1022 test_cipher("cbc(blowfish)", ENCRYPT, bf_cbc_enc_tv_template, 1023 BF_CBC_ENC_TEST_VECTORS); 1024 test_cipher("cbc(blowfish)", DECRYPT, bf_cbc_dec_tv_template, 1025 BF_CBC_DEC_TEST_VECTORS); 1026 break; 1027 1028 case 8: 1029 test_cipher("ecb(twofish)", ENCRYPT, tf_enc_tv_template, 1030 TF_ENC_TEST_VECTORS); 1031 test_cipher("ecb(twofish)", DECRYPT, tf_dec_tv_template, 1032 TF_DEC_TEST_VECTORS); 1033 test_cipher("cbc(twofish)", ENCRYPT, tf_cbc_enc_tv_template, 1034 TF_CBC_ENC_TEST_VECTORS); 1035 test_cipher("cbc(twofish)", DECRYPT, tf_cbc_dec_tv_template, 1036 TF_CBC_DEC_TEST_VECTORS); 1037 break; 1038 1039 case 9: 1040 test_cipher("ecb(serpent)", ENCRYPT, serpent_enc_tv_template, 1041 SERPENT_ENC_TEST_VECTORS); 1042 test_cipher("ecb(serpent)", DECRYPT, serpent_dec_tv_template, 1043 SERPENT_DEC_TEST_VECTORS); 1044 break; 1045 1046 case 10: 1047 test_cipher("ecb(aes)", ENCRYPT, aes_enc_tv_template, 1048 AES_ENC_TEST_VECTORS); 1049 test_cipher("ecb(aes)", DECRYPT, aes_dec_tv_template, 1050 AES_DEC_TEST_VECTORS); 1051 test_cipher("cbc(aes)", ENCRYPT, aes_cbc_enc_tv_template, 1052 AES_CBC_ENC_TEST_VECTORS); 1053 test_cipher("cbc(aes)", DECRYPT, aes_cbc_dec_tv_template, 1054 AES_CBC_DEC_TEST_VECTORS); 1055 break; 1056 1057 case 11: 1058 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS); 1059 break; 1060 1061 case 12: 1062 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS); 1063 break; 1064 1065 case 13: 1066 test_deflate(); 1067 break; 1068 1069 case 14: 1070 test_cipher("ecb(cast5)", ENCRYPT, cast5_enc_tv_template, 1071 CAST5_ENC_TEST_VECTORS); 1072 test_cipher("ecb(cast5)", DECRYPT, cast5_dec_tv_template, 1073 CAST5_DEC_TEST_VECTORS); 1074 break; 1075 1076 case 15: 1077 test_cipher("ecb(cast6)", ENCRYPT, cast6_enc_tv_template, 1078 CAST6_ENC_TEST_VECTORS); 1079 test_cipher("ecb(cast6)", DECRYPT, cast6_dec_tv_template, 1080 CAST6_DEC_TEST_VECTORS); 1081 break; 1082 1083 case 16: 1084 test_cipher("ecb(arc4)", ENCRYPT, arc4_enc_tv_template, 1085 ARC4_ENC_TEST_VECTORS); 1086 test_cipher("ecb(arc4)", DECRYPT, arc4_dec_tv_template, 1087 ARC4_DEC_TEST_VECTORS); 1088 break; 1089 1090 case 17: 1091 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS); 1092 break; 1093 1094 case 18: 1095 test_hash("crc32c", crc32c_tv_template, CRC32C_TEST_VECTORS); 1096 break; 1097 1098 case 19: 1099 test_cipher("ecb(tea)", ENCRYPT, tea_enc_tv_template, 1100 TEA_ENC_TEST_VECTORS); 1101 test_cipher("ecb(tea)", DECRYPT, tea_dec_tv_template, 1102 TEA_DEC_TEST_VECTORS); 1103 break; 1104 1105 case 20: 1106 test_cipher("ecb(xtea)", ENCRYPT, xtea_enc_tv_template, 1107 XTEA_ENC_TEST_VECTORS); 1108 test_cipher("ecb(xtea)", DECRYPT, xtea_dec_tv_template, 1109 XTEA_DEC_TEST_VECTORS); 1110 break; 1111 1112 case 21: 1113 test_cipher("ecb(khazad)", ENCRYPT, khazad_enc_tv_template, 1114 KHAZAD_ENC_TEST_VECTORS); 1115 test_cipher("ecb(khazad)", DECRYPT, khazad_dec_tv_template, 1116 KHAZAD_DEC_TEST_VECTORS); 1117 break; 1118 1119 case 22: 1120 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS); 1121 break; 1122 1123 case 23: 1124 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS); 1125 break; 1126 1127 case 24: 1128 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS); 1129 break; 1130 1131 case 25: 1132 test_cipher("ecb(tnepres)", ENCRYPT, tnepres_enc_tv_template, 1133 TNEPRES_ENC_TEST_VECTORS); 1134 test_cipher("ecb(tnepres)", DECRYPT, tnepres_dec_tv_template, 1135 TNEPRES_DEC_TEST_VECTORS); 1136 break; 1137 1138 case 26: 1139 test_cipher("ecb(anubis)", ENCRYPT, anubis_enc_tv_template, 1140 ANUBIS_ENC_TEST_VECTORS); 1141 test_cipher("ecb(anubis)", DECRYPT, anubis_dec_tv_template, 1142 ANUBIS_DEC_TEST_VECTORS); 1143 test_cipher("cbc(anubis)", ENCRYPT, anubis_cbc_enc_tv_template, 1144 ANUBIS_CBC_ENC_TEST_VECTORS); 1145 test_cipher("cbc(anubis)", DECRYPT, anubis_cbc_dec_tv_template, 1146 ANUBIS_CBC_ENC_TEST_VECTORS); 1147 break; 1148 1149 case 27: 1150 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS); 1151 break; 1152 1153 case 28: 1154 1155 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS); 1156 break; 1157 1158 case 29: 1159 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS); 1160 break; 1161 1162 case 30: 1163 test_cipher("ecb(xeta)", ENCRYPT, xeta_enc_tv_template, 1164 XETA_ENC_TEST_VECTORS); 1165 test_cipher("ecb(xeta)", DECRYPT, xeta_dec_tv_template, 1166 XETA_DEC_TEST_VECTORS); 1167 break; 1168 1169 case 100: 1170 test_hash("hmac(md5)", hmac_md5_tv_template, 1171 HMAC_MD5_TEST_VECTORS); 1172 break; 1173 1174 case 101: 1175 test_hash("hmac(sha1)", hmac_sha1_tv_template, 1176 HMAC_SHA1_TEST_VECTORS); 1177 break; 1178 1179 case 102: 1180 test_hash("hmac(sha256)", hmac_sha256_tv_template, 1181 HMAC_SHA256_TEST_VECTORS); 1182 break; 1183 1184 1185 case 200: 1186 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0, 1187 aes_speed_template); 1188 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0, 1189 aes_speed_template); 1190 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0, 1191 aes_speed_template); 1192 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0, 1193 aes_speed_template); 1194 break; 1195 1196 case 201: 1197 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec, 1198 des3_ede_enc_tv_template, 1199 DES3_EDE_ENC_TEST_VECTORS, 1200 des3_ede_speed_template); 1201 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec, 1202 des3_ede_dec_tv_template, 1203 DES3_EDE_DEC_TEST_VECTORS, 1204 des3_ede_speed_template); 1205 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec, 1206 des3_ede_enc_tv_template, 1207 DES3_EDE_ENC_TEST_VECTORS, 1208 des3_ede_speed_template); 1209 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec, 1210 des3_ede_dec_tv_template, 1211 DES3_EDE_DEC_TEST_VECTORS, 1212 des3_ede_speed_template); 1213 break; 1214 1215 case 202: 1216 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0, 1217 twofish_speed_template); 1218 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0, 1219 twofish_speed_template); 1220 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0, 1221 twofish_speed_template); 1222 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0, 1223 twofish_speed_template); 1224 break; 1225 1226 case 203: 1227 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0, 1228 blowfish_speed_template); 1229 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0, 1230 blowfish_speed_template); 1231 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0, 1232 blowfish_speed_template); 1233 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0, 1234 blowfish_speed_template); 1235 break; 1236 1237 case 204: 1238 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0, 1239 des_speed_template); 1240 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0, 1241 des_speed_template); 1242 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0, 1243 des_speed_template); 1244 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0, 1245 des_speed_template); 1246 break; 1247 1248 case 300: 1249 /* fall through */ 1250 1251 case 301: 1252 test_hash_speed("md4", sec, generic_hash_speed_template); 1253 if (mode > 300 && mode < 400) break; 1254 1255 case 302: 1256 test_hash_speed("md5", sec, generic_hash_speed_template); 1257 if (mode > 300 && mode < 400) break; 1258 1259 case 303: 1260 test_hash_speed("sha1", sec, generic_hash_speed_template); 1261 if (mode > 300 && mode < 400) break; 1262 1263 case 304: 1264 test_hash_speed("sha256", sec, generic_hash_speed_template); 1265 if (mode > 300 && mode < 400) break; 1266 1267 case 305: 1268 test_hash_speed("sha384", sec, generic_hash_speed_template); 1269 if (mode > 300 && mode < 400) break; 1270 1271 case 306: 1272 test_hash_speed("sha512", sec, generic_hash_speed_template); 1273 if (mode > 300 && mode < 400) break; 1274 1275 case 307: 1276 test_hash_speed("wp256", sec, generic_hash_speed_template); 1277 if (mode > 300 && mode < 400) break; 1278 1279 case 308: 1280 test_hash_speed("wp384", sec, generic_hash_speed_template); 1281 if (mode > 300 && mode < 400) break; 1282 1283 case 309: 1284 test_hash_speed("wp512", sec, generic_hash_speed_template); 1285 if (mode > 300 && mode < 400) break; 1286 1287 case 310: 1288 test_hash_speed("tgr128", sec, generic_hash_speed_template); 1289 if (mode > 300 && mode < 400) break; 1290 1291 case 311: 1292 test_hash_speed("tgr160", sec, generic_hash_speed_template); 1293 if (mode > 300 && mode < 400) break; 1294 1295 case 312: 1296 test_hash_speed("tgr192", sec, generic_hash_speed_template); 1297 if (mode > 300 && mode < 400) break; 1298 1299 case 399: 1300 break; 1301 1302 case 1000: 1303 test_available(); 1304 break; 1305 1306 default: 1307 /* useful for debugging */ 1308 printk("not testing anything\n"); 1309 break; 1310 } 1311 } 1312 1313 static int __init init(void) 1314 { 1315 tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL); 1316 if (tvmem == NULL) 1317 return -ENOMEM; 1318 1319 xbuf = kmalloc(XBUFSIZE, GFP_KERNEL); 1320 if (xbuf == NULL) { 1321 kfree(tvmem); 1322 return -ENOMEM; 1323 } 1324 1325 do_test(); 1326 1327 kfree(xbuf); 1328 kfree(tvmem); 1329 1330 /* We intentionaly return -EAGAIN to prevent keeping 1331 * the module. It does all its work from init() 1332 * and doesn't offer any runtime functionality 1333 * => we don't need it in the memory, do we? 1334 * -- mludvig 1335 */ 1336 return -EAGAIN; 1337 } 1338 1339 /* 1340 * If an init function is provided, an exit function must also be provided 1341 * to allow module unload. 1342 */ 1343 static void __exit fini(void) { } 1344 1345 module_init(init); 1346 module_exit(fini); 1347 1348 module_param(mode, int, 0); 1349 module_param(sec, uint, 0); 1350 MODULE_PARM_DESC(sec, "Length in seconds of speed tests " 1351 "(defaults to zero which uses CPU cycles instead)"); 1352 1353 MODULE_LICENSE("GPL"); 1354 MODULE_DESCRIPTION("Quick & dirty crypto testing module"); 1355 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>"); 1356