1 /* 2 * Quick & dirty crypto testing module. 3 * 4 * This will only exist until we have a better testing mechanism 5 * (e.g. a char device). 6 * 7 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au> 8 * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org> 9 * Copyright (c) 2007 Nokia Siemens Networks 10 * 11 * This program is free software; you can redistribute it and/or modify it 12 * under the terms of the GNU General Public License as published by the Free 13 * Software Foundation; either version 2 of the License, or (at your option) 14 * any later version. 15 * 16 */ 17 18 #include <crypto/hash.h> 19 #include <linux/err.h> 20 #include <linux/init.h> 21 #include <linux/module.h> 22 #include <linux/slab.h> 23 #include <linux/scatterlist.h> 24 #include <linux/string.h> 25 #include <linux/moduleparam.h> 26 #include <linux/jiffies.h> 27 #include <linux/timex.h> 28 #include <linux/interrupt.h> 29 #include "tcrypt.h" 30 #include "internal.h" 31 32 /* 33 * Need slab memory for testing (size in number of pages). 34 */ 35 #define TVMEMSIZE 4 36 37 /* 38 * Used by test_cipher_speed() 39 */ 40 #define ENCRYPT 1 41 #define DECRYPT 0 42 43 /* 44 * Used by test_cipher_speed() 45 */ 46 static unsigned int sec; 47 48 static int mode; 49 static char *tvmem[TVMEMSIZE]; 50 51 static char *check[] = { 52 "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256", 53 "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes", 54 "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea", 55 "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", "fcrypt", 56 "camellia", "seed", "salsa20", "rmd128", "rmd160", "rmd256", "rmd320", 57 "lzo", "cts", "zlib", NULL 58 }; 59 60 static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc, 61 struct scatterlist *sg, int blen, int sec) 62 { 63 unsigned long start, end; 64 int bcount; 65 int ret; 66 67 for (start = jiffies, end = start + sec * HZ, bcount = 0; 68 time_before(jiffies, end); bcount++) { 69 if (enc) 70 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen); 71 else 72 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen); 73 74 if (ret) 75 return ret; 76 } 77 78 printk("%d operations in %d seconds (%ld bytes)\n", 79 bcount, sec, (long)bcount * blen); 80 return 0; 81 } 82 83 static int test_cipher_cycles(struct blkcipher_desc *desc, int enc, 84 struct scatterlist *sg, int blen) 85 { 86 unsigned long cycles = 0; 87 int ret = 0; 88 int i; 89 90 local_bh_disable(); 91 local_irq_disable(); 92 93 /* Warm-up run. */ 94 for (i = 0; i < 4; i++) { 95 if (enc) 96 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen); 97 else 98 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen); 99 100 if (ret) 101 goto out; 102 } 103 104 /* The real thing. */ 105 for (i = 0; i < 8; i++) { 106 cycles_t start, end; 107 108 start = get_cycles(); 109 if (enc) 110 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen); 111 else 112 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen); 113 end = get_cycles(); 114 115 if (ret) 116 goto out; 117 118 cycles += end - start; 119 } 120 121 out: 122 local_irq_enable(); 123 local_bh_enable(); 124 125 if (ret == 0) 126 printk("1 operation in %lu cycles (%d bytes)\n", 127 (cycles + 4) / 8, blen); 128 129 return ret; 130 } 131 132 static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 }; 133 134 static void test_cipher_speed(const char *algo, int enc, unsigned int sec, 135 struct cipher_speed_template *template, 136 unsigned int tcount, u8 *keysize) 137 { 138 unsigned int ret, i, j, iv_len; 139 const char *key, iv[128]; 140 struct crypto_blkcipher *tfm; 141 struct blkcipher_desc desc; 142 const char *e; 143 u32 *b_size; 144 145 if (enc == ENCRYPT) 146 e = "encryption"; 147 else 148 e = "decryption"; 149 150 printk("\ntesting speed of %s %s\n", algo, e); 151 152 tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC); 153 154 if (IS_ERR(tfm)) { 155 printk("failed to load transform for %s: %ld\n", algo, 156 PTR_ERR(tfm)); 157 return; 158 } 159 desc.tfm = tfm; 160 desc.flags = 0; 161 162 i = 0; 163 do { 164 165 b_size = block_sizes; 166 do { 167 struct scatterlist sg[TVMEMSIZE]; 168 169 if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) { 170 printk("template (%u) too big for " 171 "tvmem (%lu)\n", *keysize + *b_size, 172 TVMEMSIZE * PAGE_SIZE); 173 goto out; 174 } 175 176 printk("test %u (%d bit key, %d byte blocks): ", i, 177 *keysize * 8, *b_size); 178 179 memset(tvmem[0], 0xff, PAGE_SIZE); 180 181 /* set key, plain text and IV */ 182 key = tvmem[0]; 183 for (j = 0; j < tcount; j++) { 184 if (template[j].klen == *keysize) { 185 key = template[j].key; 186 break; 187 } 188 } 189 190 ret = crypto_blkcipher_setkey(tfm, key, *keysize); 191 if (ret) { 192 printk("setkey() failed flags=%x\n", 193 crypto_blkcipher_get_flags(tfm)); 194 goto out; 195 } 196 197 sg_init_table(sg, TVMEMSIZE); 198 sg_set_buf(sg, tvmem[0] + *keysize, 199 PAGE_SIZE - *keysize); 200 for (j = 1; j < TVMEMSIZE; j++) { 201 sg_set_buf(sg + j, tvmem[j], PAGE_SIZE); 202 memset (tvmem[j], 0xff, PAGE_SIZE); 203 } 204 205 iv_len = crypto_blkcipher_ivsize(tfm); 206 if (iv_len) { 207 memset(&iv, 0xff, iv_len); 208 crypto_blkcipher_set_iv(tfm, iv, iv_len); 209 } 210 211 if (sec) 212 ret = test_cipher_jiffies(&desc, enc, sg, 213 *b_size, sec); 214 else 215 ret = test_cipher_cycles(&desc, enc, sg, 216 *b_size); 217 218 if (ret) { 219 printk("%s() failed flags=%x\n", e, desc.flags); 220 break; 221 } 222 b_size++; 223 i++; 224 } while (*b_size); 225 keysize++; 226 } while (*keysize); 227 228 out: 229 crypto_free_blkcipher(tfm); 230 } 231 232 static int test_hash_jiffies_digest(struct hash_desc *desc, 233 struct scatterlist *sg, int blen, 234 char *out, int sec) 235 { 236 unsigned long start, end; 237 int bcount; 238 int ret; 239 240 for (start = jiffies, end = start + sec * HZ, bcount = 0; 241 time_before(jiffies, end); bcount++) { 242 ret = crypto_hash_digest(desc, sg, blen, out); 243 if (ret) 244 return ret; 245 } 246 247 printk("%6u opers/sec, %9lu bytes/sec\n", 248 bcount / sec, ((long)bcount * blen) / sec); 249 250 return 0; 251 } 252 253 static int test_hash_jiffies(struct hash_desc *desc, struct scatterlist *sg, 254 int blen, int plen, char *out, int sec) 255 { 256 unsigned long start, end; 257 int bcount, pcount; 258 int ret; 259 260 if (plen == blen) 261 return test_hash_jiffies_digest(desc, sg, blen, out, sec); 262 263 for (start = jiffies, end = start + sec * HZ, bcount = 0; 264 time_before(jiffies, end); bcount++) { 265 ret = crypto_hash_init(desc); 266 if (ret) 267 return ret; 268 for (pcount = 0; pcount < blen; pcount += plen) { 269 ret = crypto_hash_update(desc, sg, plen); 270 if (ret) 271 return ret; 272 } 273 /* we assume there is enough space in 'out' for the result */ 274 ret = crypto_hash_final(desc, out); 275 if (ret) 276 return ret; 277 } 278 279 printk("%6u opers/sec, %9lu bytes/sec\n", 280 bcount / sec, ((long)bcount * blen) / sec); 281 282 return 0; 283 } 284 285 static int test_hash_cycles_digest(struct hash_desc *desc, 286 struct scatterlist *sg, int blen, char *out) 287 { 288 unsigned long cycles = 0; 289 int i; 290 int ret; 291 292 local_bh_disable(); 293 local_irq_disable(); 294 295 /* Warm-up run. */ 296 for (i = 0; i < 4; i++) { 297 ret = crypto_hash_digest(desc, sg, blen, out); 298 if (ret) 299 goto out; 300 } 301 302 /* The real thing. */ 303 for (i = 0; i < 8; i++) { 304 cycles_t start, end; 305 306 start = get_cycles(); 307 308 ret = crypto_hash_digest(desc, sg, blen, out); 309 if (ret) 310 goto out; 311 312 end = get_cycles(); 313 314 cycles += end - start; 315 } 316 317 out: 318 local_irq_enable(); 319 local_bh_enable(); 320 321 if (ret) 322 return ret; 323 324 printk("%6lu cycles/operation, %4lu cycles/byte\n", 325 cycles / 8, cycles / (8 * blen)); 326 327 return 0; 328 } 329 330 static int test_hash_cycles(struct hash_desc *desc, struct scatterlist *sg, 331 int blen, int plen, char *out) 332 { 333 unsigned long cycles = 0; 334 int i, pcount; 335 int ret; 336 337 if (plen == blen) 338 return test_hash_cycles_digest(desc, sg, blen, out); 339 340 local_bh_disable(); 341 local_irq_disable(); 342 343 /* Warm-up run. */ 344 for (i = 0; i < 4; i++) { 345 ret = crypto_hash_init(desc); 346 if (ret) 347 goto out; 348 for (pcount = 0; pcount < blen; pcount += plen) { 349 ret = crypto_hash_update(desc, sg, plen); 350 if (ret) 351 goto out; 352 } 353 ret = crypto_hash_final(desc, out); 354 if (ret) 355 goto out; 356 } 357 358 /* The real thing. */ 359 for (i = 0; i < 8; i++) { 360 cycles_t start, end; 361 362 start = get_cycles(); 363 364 ret = crypto_hash_init(desc); 365 if (ret) 366 goto out; 367 for (pcount = 0; pcount < blen; pcount += plen) { 368 ret = crypto_hash_update(desc, sg, plen); 369 if (ret) 370 goto out; 371 } 372 ret = crypto_hash_final(desc, out); 373 if (ret) 374 goto out; 375 376 end = get_cycles(); 377 378 cycles += end - start; 379 } 380 381 out: 382 local_irq_enable(); 383 local_bh_enable(); 384 385 if (ret) 386 return ret; 387 388 printk("%6lu cycles/operation, %4lu cycles/byte\n", 389 cycles / 8, cycles / (8 * blen)); 390 391 return 0; 392 } 393 394 static void test_hash_speed(const char *algo, unsigned int sec, 395 struct hash_speed *speed) 396 { 397 struct scatterlist sg[TVMEMSIZE]; 398 struct crypto_hash *tfm; 399 struct hash_desc desc; 400 static char output[1024]; 401 int i; 402 int ret; 403 404 printk(KERN_INFO "\ntesting speed of %s\n", algo); 405 406 tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC); 407 408 if (IS_ERR(tfm)) { 409 printk(KERN_ERR "failed to load transform for %s: %ld\n", algo, 410 PTR_ERR(tfm)); 411 return; 412 } 413 414 desc.tfm = tfm; 415 desc.flags = 0; 416 417 if (crypto_hash_digestsize(tfm) > sizeof(output)) { 418 printk(KERN_ERR "digestsize(%u) > outputbuffer(%zu)\n", 419 crypto_hash_digestsize(tfm), sizeof(output)); 420 goto out; 421 } 422 423 sg_init_table(sg, TVMEMSIZE); 424 for (i = 0; i < TVMEMSIZE; i++) { 425 sg_set_buf(sg + i, tvmem[i], PAGE_SIZE); 426 memset(tvmem[i], 0xff, PAGE_SIZE); 427 } 428 429 for (i = 0; speed[i].blen != 0; i++) { 430 if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) { 431 printk(KERN_ERR 432 "template (%u) too big for tvmem (%lu)\n", 433 speed[i].blen, TVMEMSIZE * PAGE_SIZE); 434 goto out; 435 } 436 437 printk(KERN_INFO "test%3u " 438 "(%5u byte blocks,%5u bytes per update,%4u updates): ", 439 i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen); 440 441 if (sec) 442 ret = test_hash_jiffies(&desc, sg, speed[i].blen, 443 speed[i].plen, output, sec); 444 else 445 ret = test_hash_cycles(&desc, sg, speed[i].blen, 446 speed[i].plen, output); 447 448 if (ret) { 449 printk(KERN_ERR "hashing failed ret=%d\n", ret); 450 break; 451 } 452 } 453 454 out: 455 crypto_free_hash(tfm); 456 } 457 458 static void test_available(void) 459 { 460 char **name = check; 461 462 while (*name) { 463 printk("alg %s ", *name); 464 printk(crypto_has_alg(*name, 0, 0) ? 465 "found\n" : "not found\n"); 466 name++; 467 } 468 } 469 470 static inline int tcrypt_test(const char *alg) 471 { 472 int ret; 473 474 ret = alg_test(alg, alg, 0, 0); 475 /* non-fips algs return -EINVAL in fips mode */ 476 if (fips_enabled && ret == -EINVAL) 477 ret = 0; 478 return ret; 479 } 480 481 static int do_test(int m) 482 { 483 int i; 484 int ret = 0; 485 486 switch (m) { 487 case 0: 488 for (i = 1; i < 200; i++) 489 ret += do_test(i); 490 break; 491 492 case 1: 493 ret += tcrypt_test("md5"); 494 break; 495 496 case 2: 497 ret += tcrypt_test("sha1"); 498 break; 499 500 case 3: 501 ret += tcrypt_test("ecb(des)"); 502 ret += tcrypt_test("cbc(des)"); 503 break; 504 505 case 4: 506 ret += tcrypt_test("ecb(des3_ede)"); 507 ret += tcrypt_test("cbc(des3_ede)"); 508 break; 509 510 case 5: 511 ret += tcrypt_test("md4"); 512 break; 513 514 case 6: 515 ret += tcrypt_test("sha256"); 516 break; 517 518 case 7: 519 ret += tcrypt_test("ecb(blowfish)"); 520 ret += tcrypt_test("cbc(blowfish)"); 521 break; 522 523 case 8: 524 ret += tcrypt_test("ecb(twofish)"); 525 ret += tcrypt_test("cbc(twofish)"); 526 break; 527 528 case 9: 529 ret += tcrypt_test("ecb(serpent)"); 530 break; 531 532 case 10: 533 ret += tcrypt_test("ecb(aes)"); 534 ret += tcrypt_test("cbc(aes)"); 535 ret += tcrypt_test("lrw(aes)"); 536 ret += tcrypt_test("xts(aes)"); 537 ret += tcrypt_test("ctr(aes)"); 538 ret += tcrypt_test("rfc3686(ctr(aes))"); 539 break; 540 541 case 11: 542 ret += tcrypt_test("sha384"); 543 break; 544 545 case 12: 546 ret += tcrypt_test("sha512"); 547 break; 548 549 case 13: 550 ret += tcrypt_test("deflate"); 551 break; 552 553 case 14: 554 ret += tcrypt_test("ecb(cast5)"); 555 break; 556 557 case 15: 558 ret += tcrypt_test("ecb(cast6)"); 559 break; 560 561 case 16: 562 ret += tcrypt_test("ecb(arc4)"); 563 break; 564 565 case 17: 566 ret += tcrypt_test("michael_mic"); 567 break; 568 569 case 18: 570 ret += tcrypt_test("crc32c"); 571 break; 572 573 case 19: 574 ret += tcrypt_test("ecb(tea)"); 575 break; 576 577 case 20: 578 ret += tcrypt_test("ecb(xtea)"); 579 break; 580 581 case 21: 582 ret += tcrypt_test("ecb(khazad)"); 583 break; 584 585 case 22: 586 ret += tcrypt_test("wp512"); 587 break; 588 589 case 23: 590 ret += tcrypt_test("wp384"); 591 break; 592 593 case 24: 594 ret += tcrypt_test("wp256"); 595 break; 596 597 case 25: 598 ret += tcrypt_test("ecb(tnepres)"); 599 break; 600 601 case 26: 602 ret += tcrypt_test("ecb(anubis)"); 603 ret += tcrypt_test("cbc(anubis)"); 604 break; 605 606 case 27: 607 ret += tcrypt_test("tgr192"); 608 break; 609 610 case 28: 611 612 ret += tcrypt_test("tgr160"); 613 break; 614 615 case 29: 616 ret += tcrypt_test("tgr128"); 617 break; 618 619 case 30: 620 ret += tcrypt_test("ecb(xeta)"); 621 break; 622 623 case 31: 624 ret += tcrypt_test("pcbc(fcrypt)"); 625 break; 626 627 case 32: 628 ret += tcrypt_test("ecb(camellia)"); 629 ret += tcrypt_test("cbc(camellia)"); 630 break; 631 case 33: 632 ret += tcrypt_test("sha224"); 633 break; 634 635 case 34: 636 ret += tcrypt_test("salsa20"); 637 break; 638 639 case 35: 640 ret += tcrypt_test("gcm(aes)"); 641 break; 642 643 case 36: 644 ret += tcrypt_test("lzo"); 645 break; 646 647 case 37: 648 ret += tcrypt_test("ccm(aes)"); 649 break; 650 651 case 38: 652 ret += tcrypt_test("cts(cbc(aes))"); 653 break; 654 655 case 39: 656 ret += tcrypt_test("rmd128"); 657 break; 658 659 case 40: 660 ret += tcrypt_test("rmd160"); 661 break; 662 663 case 41: 664 ret += tcrypt_test("rmd256"); 665 break; 666 667 case 42: 668 ret += tcrypt_test("rmd320"); 669 break; 670 671 case 43: 672 ret += tcrypt_test("ecb(seed)"); 673 break; 674 675 case 44: 676 ret += tcrypt_test("zlib"); 677 break; 678 679 case 45: 680 ret += tcrypt_test("rfc4309(ccm(aes))"); 681 break; 682 683 case 100: 684 ret += tcrypt_test("hmac(md5)"); 685 break; 686 687 case 101: 688 ret += tcrypt_test("hmac(sha1)"); 689 break; 690 691 case 102: 692 ret += tcrypt_test("hmac(sha256)"); 693 break; 694 695 case 103: 696 ret += tcrypt_test("hmac(sha384)"); 697 break; 698 699 case 104: 700 ret += tcrypt_test("hmac(sha512)"); 701 break; 702 703 case 105: 704 ret += tcrypt_test("hmac(sha224)"); 705 break; 706 707 case 106: 708 ret += tcrypt_test("xcbc(aes)"); 709 break; 710 711 case 107: 712 ret += tcrypt_test("hmac(rmd128)"); 713 break; 714 715 case 108: 716 ret += tcrypt_test("hmac(rmd160)"); 717 break; 718 719 case 150: 720 ret += tcrypt_test("ansi_cprng"); 721 break; 722 723 case 200: 724 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0, 725 speed_template_16_24_32); 726 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0, 727 speed_template_16_24_32); 728 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0, 729 speed_template_16_24_32); 730 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0, 731 speed_template_16_24_32); 732 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0, 733 speed_template_32_40_48); 734 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0, 735 speed_template_32_40_48); 736 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0, 737 speed_template_32_48_64); 738 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0, 739 speed_template_32_48_64); 740 break; 741 742 case 201: 743 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec, 744 des3_speed_template, DES3_SPEED_VECTORS, 745 speed_template_24); 746 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec, 747 des3_speed_template, DES3_SPEED_VECTORS, 748 speed_template_24); 749 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec, 750 des3_speed_template, DES3_SPEED_VECTORS, 751 speed_template_24); 752 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec, 753 des3_speed_template, DES3_SPEED_VECTORS, 754 speed_template_24); 755 break; 756 757 case 202: 758 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0, 759 speed_template_16_24_32); 760 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0, 761 speed_template_16_24_32); 762 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0, 763 speed_template_16_24_32); 764 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0, 765 speed_template_16_24_32); 766 break; 767 768 case 203: 769 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0, 770 speed_template_8_32); 771 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0, 772 speed_template_8_32); 773 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0, 774 speed_template_8_32); 775 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0, 776 speed_template_8_32); 777 break; 778 779 case 204: 780 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0, 781 speed_template_8); 782 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0, 783 speed_template_8); 784 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0, 785 speed_template_8); 786 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0, 787 speed_template_8); 788 break; 789 790 case 205: 791 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0, 792 speed_template_16_24_32); 793 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0, 794 speed_template_16_24_32); 795 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0, 796 speed_template_16_24_32); 797 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0, 798 speed_template_16_24_32); 799 break; 800 801 case 206: 802 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0, 803 speed_template_16_32); 804 break; 805 806 case 300: 807 /* fall through */ 808 809 case 301: 810 test_hash_speed("md4", sec, generic_hash_speed_template); 811 if (mode > 300 && mode < 400) break; 812 813 case 302: 814 test_hash_speed("md5", sec, generic_hash_speed_template); 815 if (mode > 300 && mode < 400) break; 816 817 case 303: 818 test_hash_speed("sha1", sec, generic_hash_speed_template); 819 if (mode > 300 && mode < 400) break; 820 821 case 304: 822 test_hash_speed("sha256", sec, generic_hash_speed_template); 823 if (mode > 300 && mode < 400) break; 824 825 case 305: 826 test_hash_speed("sha384", sec, generic_hash_speed_template); 827 if (mode > 300 && mode < 400) break; 828 829 case 306: 830 test_hash_speed("sha512", sec, generic_hash_speed_template); 831 if (mode > 300 && mode < 400) break; 832 833 case 307: 834 test_hash_speed("wp256", sec, generic_hash_speed_template); 835 if (mode > 300 && mode < 400) break; 836 837 case 308: 838 test_hash_speed("wp384", sec, generic_hash_speed_template); 839 if (mode > 300 && mode < 400) break; 840 841 case 309: 842 test_hash_speed("wp512", sec, generic_hash_speed_template); 843 if (mode > 300 && mode < 400) break; 844 845 case 310: 846 test_hash_speed("tgr128", sec, generic_hash_speed_template); 847 if (mode > 300 && mode < 400) break; 848 849 case 311: 850 test_hash_speed("tgr160", sec, generic_hash_speed_template); 851 if (mode > 300 && mode < 400) break; 852 853 case 312: 854 test_hash_speed("tgr192", sec, generic_hash_speed_template); 855 if (mode > 300 && mode < 400) break; 856 857 case 313: 858 test_hash_speed("sha224", sec, generic_hash_speed_template); 859 if (mode > 300 && mode < 400) break; 860 861 case 314: 862 test_hash_speed("rmd128", sec, generic_hash_speed_template); 863 if (mode > 300 && mode < 400) break; 864 865 case 315: 866 test_hash_speed("rmd160", sec, generic_hash_speed_template); 867 if (mode > 300 && mode < 400) break; 868 869 case 316: 870 test_hash_speed("rmd256", sec, generic_hash_speed_template); 871 if (mode > 300 && mode < 400) break; 872 873 case 317: 874 test_hash_speed("rmd320", sec, generic_hash_speed_template); 875 if (mode > 300 && mode < 400) break; 876 877 case 399: 878 break; 879 880 case 1000: 881 test_available(); 882 break; 883 } 884 885 return ret; 886 } 887 888 static int __init tcrypt_mod_init(void) 889 { 890 int err = -ENOMEM; 891 int i; 892 893 for (i = 0; i < TVMEMSIZE; i++) { 894 tvmem[i] = (void *)__get_free_page(GFP_KERNEL); 895 if (!tvmem[i]) 896 goto err_free_tv; 897 } 898 899 err = do_test(mode); 900 if (err) { 901 printk(KERN_ERR "tcrypt: one or more tests failed!\n"); 902 goto err_free_tv; 903 } 904 905 /* We intentionaly return -EAGAIN to prevent keeping the module, 906 * unless we're running in fips mode. It does all its work from 907 * init() and doesn't offer any runtime functionality, but in 908 * the fips case, checking for a successful load is helpful. 909 * => we don't need it in the memory, do we? 910 * -- mludvig 911 */ 912 if (!fips_enabled) 913 err = -EAGAIN; 914 915 err_free_tv: 916 for (i = 0; i < TVMEMSIZE && tvmem[i]; i++) 917 free_page((unsigned long)tvmem[i]); 918 919 return err; 920 } 921 922 /* 923 * If an init function is provided, an exit function must also be provided 924 * to allow module unload. 925 */ 926 static void __exit tcrypt_mod_fini(void) { } 927 928 module_init(tcrypt_mod_init); 929 module_exit(tcrypt_mod_fini); 930 931 module_param(mode, int, 0); 932 module_param(sec, uint, 0); 933 MODULE_PARM_DESC(sec, "Length in seconds of speed tests " 934 "(defaults to zero which uses CPU cycles instead)"); 935 936 MODULE_LICENSE("GPL"); 937 MODULE_DESCRIPTION("Quick & dirty crypto testing module"); 938 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>"); 939