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