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/gfp.h> 22#include <linux/module.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 */ 46static unsigned int sec; 47 48static char *alg = NULL; 49static u32 type; 50static u32 mask; 51static int mode; 52static char *tvmem[TVMEMSIZE]; 53 54static 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 63static 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 86static 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 124out: 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 135static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 }; 136 137static 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 231out: 232 crypto_free_blkcipher(tfm); 233} 234 235static 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 256static 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 288static 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 320out: 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 333static 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 384out: 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 397static void test_hash_sg_init(struct scatterlist *sg) 398{ 399 int i; 400 401 sg_init_table(sg, TVMEMSIZE); 402 for (i = 0; i < TVMEMSIZE; i++) { 403 sg_set_buf(sg + i, tvmem[i], PAGE_SIZE); 404 memset(tvmem[i], 0xff, PAGE_SIZE); 405 } 406} 407 408static void test_hash_speed(const char *algo, unsigned int sec, 409 struct hash_speed *speed) 410{ 411 struct scatterlist sg[TVMEMSIZE]; 412 struct crypto_hash *tfm; 413 struct hash_desc desc; 414 static char output[1024]; 415 int i; 416 int ret; 417 418 printk(KERN_INFO "\ntesting speed of %s\n", algo); 419 420 tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC); 421 422 if (IS_ERR(tfm)) { 423 printk(KERN_ERR "failed to load transform for %s: %ld\n", algo, 424 PTR_ERR(tfm)); 425 return; 426 } 427 428 desc.tfm = tfm; 429 desc.flags = 0; 430 431 if (crypto_hash_digestsize(tfm) > sizeof(output)) { 432 printk(KERN_ERR "digestsize(%u) > outputbuffer(%zu)\n", 433 crypto_hash_digestsize(tfm), sizeof(output)); 434 goto out; 435 } 436 437 test_hash_sg_init(sg); 438 for (i = 0; speed[i].blen != 0; i++) { 439 if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) { 440 printk(KERN_ERR 441 "template (%u) too big for tvmem (%lu)\n", 442 speed[i].blen, TVMEMSIZE * PAGE_SIZE); 443 goto out; 444 } 445 446 if (speed[i].klen) 447 crypto_hash_setkey(tfm, tvmem[0], speed[i].klen); 448 449 printk(KERN_INFO "test%3u " 450 "(%5u byte blocks,%5u bytes per update,%4u updates): ", 451 i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen); 452 453 if (sec) 454 ret = test_hash_jiffies(&desc, sg, speed[i].blen, 455 speed[i].plen, output, sec); 456 else 457 ret = test_hash_cycles(&desc, sg, speed[i].blen, 458 speed[i].plen, output); 459 460 if (ret) { 461 printk(KERN_ERR "hashing failed ret=%d\n", ret); 462 break; 463 } 464 } 465 466out: 467 crypto_free_hash(tfm); 468} 469 470struct tcrypt_result { 471 struct completion completion; 472 int err; 473}; 474 475static void tcrypt_complete(struct crypto_async_request *req, int err) 476{ 477 struct tcrypt_result *res = req->data; 478 479 if (err == -EINPROGRESS) 480 return; 481 482 res->err = err; 483 complete(&res->completion); 484} 485 486static inline int do_one_ahash_op(struct ahash_request *req, int ret) 487{ 488 if (ret == -EINPROGRESS || ret == -EBUSY) { 489 struct tcrypt_result *tr = req->base.data; 490 491 ret = wait_for_completion_interruptible(&tr->completion); 492 if (!ret) 493 ret = tr->err; 494 INIT_COMPLETION(tr->completion); 495 } 496 return ret; 497} 498 499static int test_ahash_jiffies_digest(struct ahash_request *req, int blen, 500 char *out, int sec) 501{ 502 unsigned long start, end; 503 int bcount; 504 int ret; 505 506 for (start = jiffies, end = start + sec * HZ, bcount = 0; 507 time_before(jiffies, end); bcount++) { 508 ret = do_one_ahash_op(req, crypto_ahash_digest(req)); 509 if (ret) 510 return ret; 511 } 512 513 printk("%6u opers/sec, %9lu bytes/sec\n", 514 bcount / sec, ((long)bcount * blen) / sec); 515 516 return 0; 517} 518 519static int test_ahash_jiffies(struct ahash_request *req, int blen, 520 int plen, char *out, int sec) 521{ 522 unsigned long start, end; 523 int bcount, pcount; 524 int ret; 525 526 if (plen == blen) 527 return test_ahash_jiffies_digest(req, blen, out, sec); 528 529 for (start = jiffies, end = start + sec * HZ, bcount = 0; 530 time_before(jiffies, end); bcount++) { 531 ret = crypto_ahash_init(req); 532 if (ret) 533 return ret; 534 for (pcount = 0; pcount < blen; pcount += plen) { 535 ret = do_one_ahash_op(req, crypto_ahash_update(req)); 536 if (ret) 537 return ret; 538 } 539 /* we assume there is enough space in 'out' for the result */ 540 ret = do_one_ahash_op(req, crypto_ahash_final(req)); 541 if (ret) 542 return ret; 543 } 544 545 pr_cont("%6u opers/sec, %9lu bytes/sec\n", 546 bcount / sec, ((long)bcount * blen) / sec); 547 548 return 0; 549} 550 551static int test_ahash_cycles_digest(struct ahash_request *req, int blen, 552 char *out) 553{ 554 unsigned long cycles = 0; 555 int ret, i; 556 557 /* Warm-up run. */ 558 for (i = 0; i < 4; i++) { 559 ret = do_one_ahash_op(req, crypto_ahash_digest(req)); 560 if (ret) 561 goto out; 562 } 563 564 /* The real thing. */ 565 for (i = 0; i < 8; i++) { 566 cycles_t start, end; 567 568 start = get_cycles(); 569 570 ret = do_one_ahash_op(req, crypto_ahash_digest(req)); 571 if (ret) 572 goto out; 573 574 end = get_cycles(); 575 576 cycles += end - start; 577 } 578 579out: 580 if (ret) 581 return ret; 582 583 pr_cont("%6lu cycles/operation, %4lu cycles/byte\n", 584 cycles / 8, cycles / (8 * blen)); 585 586 return 0; 587} 588 589static int test_ahash_cycles(struct ahash_request *req, int blen, 590 int plen, char *out) 591{ 592 unsigned long cycles = 0; 593 int i, pcount, ret; 594 595 if (plen == blen) 596 return test_ahash_cycles_digest(req, blen, out); 597 598 /* Warm-up run. */ 599 for (i = 0; i < 4; i++) { 600 ret = crypto_ahash_init(req); 601 if (ret) 602 goto out; 603 for (pcount = 0; pcount < blen; pcount += plen) { 604 ret = do_one_ahash_op(req, crypto_ahash_update(req)); 605 if (ret) 606 goto out; 607 } 608 ret = do_one_ahash_op(req, crypto_ahash_final(req)); 609 if (ret) 610 goto out; 611 } 612 613 /* The real thing. */ 614 for (i = 0; i < 8; i++) { 615 cycles_t start, end; 616 617 start = get_cycles(); 618 619 ret = crypto_ahash_init(req); 620 if (ret) 621 goto out; 622 for (pcount = 0; pcount < blen; pcount += plen) { 623 ret = do_one_ahash_op(req, crypto_ahash_update(req)); 624 if (ret) 625 goto out; 626 } 627 ret = do_one_ahash_op(req, crypto_ahash_final(req)); 628 if (ret) 629 goto out; 630 631 end = get_cycles(); 632 633 cycles += end - start; 634 } 635 636out: 637 if (ret) 638 return ret; 639 640 pr_cont("%6lu cycles/operation, %4lu cycles/byte\n", 641 cycles / 8, cycles / (8 * blen)); 642 643 return 0; 644} 645 646static void test_ahash_speed(const char *algo, unsigned int sec, 647 struct hash_speed *speed) 648{ 649 struct scatterlist sg[TVMEMSIZE]; 650 struct tcrypt_result tresult; 651 struct ahash_request *req; 652 struct crypto_ahash *tfm; 653 static char output[1024]; 654 int i, ret; 655 656 printk(KERN_INFO "\ntesting speed of async %s\n", algo); 657 658 tfm = crypto_alloc_ahash(algo, 0, 0); 659 if (IS_ERR(tfm)) { 660 pr_err("failed to load transform for %s: %ld\n", 661 algo, PTR_ERR(tfm)); 662 return; 663 } 664 665 if (crypto_ahash_digestsize(tfm) > sizeof(output)) { 666 pr_err("digestsize(%u) > outputbuffer(%zu)\n", 667 crypto_ahash_digestsize(tfm), sizeof(output)); 668 goto out; 669 } 670 671 test_hash_sg_init(sg); 672 req = ahash_request_alloc(tfm, GFP_KERNEL); 673 if (!req) { 674 pr_err("ahash request allocation failure\n"); 675 goto out; 676 } 677 678 init_completion(&tresult.completion); 679 ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 680 tcrypt_complete, &tresult); 681 682 for (i = 0; speed[i].blen != 0; i++) { 683 if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) { 684 pr_err("template (%u) too big for tvmem (%lu)\n", 685 speed[i].blen, TVMEMSIZE * PAGE_SIZE); 686 break; 687 } 688 689 pr_info("test%3u " 690 "(%5u byte blocks,%5u bytes per update,%4u updates): ", 691 i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen); 692 693 ahash_request_set_crypt(req, sg, output, speed[i].plen); 694 695 if (sec) 696 ret = test_ahash_jiffies(req, speed[i].blen, 697 speed[i].plen, output, sec); 698 else 699 ret = test_ahash_cycles(req, speed[i].blen, 700 speed[i].plen, output); 701 702 if (ret) { 703 pr_err("hashing failed ret=%d\n", ret); 704 break; 705 } 706 } 707 708 ahash_request_free(req); 709 710out: 711 crypto_free_ahash(tfm); 712} 713 714static void test_available(void) 715{ 716 char **name = check; 717 718 while (*name) { 719 printk("alg %s ", *name); 720 printk(crypto_has_alg(*name, 0, 0) ? 721 "found\n" : "not found\n"); 722 name++; 723 } 724} 725 726static inline int tcrypt_test(const char *alg) 727{ 728 int ret; 729 730 ret = alg_test(alg, alg, 0, 0); 731 /* non-fips algs return -EINVAL in fips mode */ 732 if (fips_enabled && ret == -EINVAL) 733 ret = 0; 734 return ret; 735} 736 737static int do_test(int m) 738{ 739 int i; 740 int ret = 0; 741 742 switch (m) { 743 case 0: 744 for (i = 1; i < 200; i++) 745 ret += do_test(i); 746 break; 747 748 case 1: 749 ret += tcrypt_test("md5"); 750 break; 751 752 case 2: 753 ret += tcrypt_test("sha1"); 754 break; 755 756 case 3: 757 ret += tcrypt_test("ecb(des)"); 758 ret += tcrypt_test("cbc(des)"); 759 break; 760 761 case 4: 762 ret += tcrypt_test("ecb(des3_ede)"); 763 ret += tcrypt_test("cbc(des3_ede)"); 764 break; 765 766 case 5: 767 ret += tcrypt_test("md4"); 768 break; 769 770 case 6: 771 ret += tcrypt_test("sha256"); 772 break; 773 774 case 7: 775 ret += tcrypt_test("ecb(blowfish)"); 776 ret += tcrypt_test("cbc(blowfish)"); 777 break; 778 779 case 8: 780 ret += tcrypt_test("ecb(twofish)"); 781 ret += tcrypt_test("cbc(twofish)"); 782 break; 783 784 case 9: 785 ret += tcrypt_test("ecb(serpent)"); 786 break; 787 788 case 10: 789 ret += tcrypt_test("ecb(aes)"); 790 ret += tcrypt_test("cbc(aes)"); 791 ret += tcrypt_test("lrw(aes)"); 792 ret += tcrypt_test("xts(aes)"); 793 ret += tcrypt_test("ctr(aes)"); 794 ret += tcrypt_test("rfc3686(ctr(aes))"); 795 break; 796 797 case 11: 798 ret += tcrypt_test("sha384"); 799 break; 800 801 case 12: 802 ret += tcrypt_test("sha512"); 803 break; 804 805 case 13: 806 ret += tcrypt_test("deflate"); 807 break; 808 809 case 14: 810 ret += tcrypt_test("ecb(cast5)"); 811 break; 812 813 case 15: 814 ret += tcrypt_test("ecb(cast6)"); 815 break; 816 817 case 16: 818 ret += tcrypt_test("ecb(arc4)"); 819 break; 820 821 case 17: 822 ret += tcrypt_test("michael_mic"); 823 break; 824 825 case 18: 826 ret += tcrypt_test("crc32c"); 827 break; 828 829 case 19: 830 ret += tcrypt_test("ecb(tea)"); 831 break; 832 833 case 20: 834 ret += tcrypt_test("ecb(xtea)"); 835 break; 836 837 case 21: 838 ret += tcrypt_test("ecb(khazad)"); 839 break; 840 841 case 22: 842 ret += tcrypt_test("wp512"); 843 break; 844 845 case 23: 846 ret += tcrypt_test("wp384"); 847 break; 848 849 case 24: 850 ret += tcrypt_test("wp256"); 851 break; 852 853 case 25: 854 ret += tcrypt_test("ecb(tnepres)"); 855 break; 856 857 case 26: 858 ret += tcrypt_test("ecb(anubis)"); 859 ret += tcrypt_test("cbc(anubis)"); 860 break; 861 862 case 27: 863 ret += tcrypt_test("tgr192"); 864 break; 865 866 case 28: 867 868 ret += tcrypt_test("tgr160"); 869 break; 870 871 case 29: 872 ret += tcrypt_test("tgr128"); 873 break; 874 875 case 30: 876 ret += tcrypt_test("ecb(xeta)"); 877 break; 878 879 case 31: 880 ret += tcrypt_test("pcbc(fcrypt)"); 881 break; 882 883 case 32: 884 ret += tcrypt_test("ecb(camellia)"); 885 ret += tcrypt_test("cbc(camellia)"); 886 break; 887 case 33: 888 ret += tcrypt_test("sha224"); 889 break; 890 891 case 34: 892 ret += tcrypt_test("salsa20"); 893 break; 894 895 case 35: 896 ret += tcrypt_test("gcm(aes)"); 897 break; 898 899 case 36: 900 ret += tcrypt_test("lzo"); 901 break; 902 903 case 37: 904 ret += tcrypt_test("ccm(aes)"); 905 break; 906 907 case 38: 908 ret += tcrypt_test("cts(cbc(aes))"); 909 break; 910 911 case 39: 912 ret += tcrypt_test("rmd128"); 913 break; 914 915 case 40: 916 ret += tcrypt_test("rmd160"); 917 break; 918 919 case 41: 920 ret += tcrypt_test("rmd256"); 921 break; 922 923 case 42: 924 ret += tcrypt_test("rmd320"); 925 break; 926 927 case 43: 928 ret += tcrypt_test("ecb(seed)"); 929 break; 930 931 case 44: 932 ret += tcrypt_test("zlib"); 933 break; 934 935 case 45: 936 ret += tcrypt_test("rfc4309(ccm(aes))"); 937 break; 938 939 case 100: 940 ret += tcrypt_test("hmac(md5)"); 941 break; 942 943 case 101: 944 ret += tcrypt_test("hmac(sha1)"); 945 break; 946 947 case 102: 948 ret += tcrypt_test("hmac(sha256)"); 949 break; 950 951 case 103: 952 ret += tcrypt_test("hmac(sha384)"); 953 break; 954 955 case 104: 956 ret += tcrypt_test("hmac(sha512)"); 957 break; 958 959 case 105: 960 ret += tcrypt_test("hmac(sha224)"); 961 break; 962 963 case 106: 964 ret += tcrypt_test("xcbc(aes)"); 965 break; 966 967 case 107: 968 ret += tcrypt_test("hmac(rmd128)"); 969 break; 970 971 case 108: 972 ret += tcrypt_test("hmac(rmd160)"); 973 break; 974 975 case 109: 976 ret += tcrypt_test("vmac(aes)"); 977 break; 978 979 case 150: 980 ret += tcrypt_test("ansi_cprng"); 981 break; 982 983 case 200: 984 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0, 985 speed_template_16_24_32); 986 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0, 987 speed_template_16_24_32); 988 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0, 989 speed_template_16_24_32); 990 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0, 991 speed_template_16_24_32); 992 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0, 993 speed_template_32_40_48); 994 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0, 995 speed_template_32_40_48); 996 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0, 997 speed_template_32_48_64); 998 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0, 999 speed_template_32_48_64); 1000 break; 1001 1002 case 201: 1003 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec, 1004 des3_speed_template, DES3_SPEED_VECTORS, 1005 speed_template_24); 1006 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec, 1007 des3_speed_template, DES3_SPEED_VECTORS, 1008 speed_template_24); 1009 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec, 1010 des3_speed_template, DES3_SPEED_VECTORS, 1011 speed_template_24); 1012 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec, 1013 des3_speed_template, DES3_SPEED_VECTORS, 1014 speed_template_24); 1015 break; 1016 1017 case 202: 1018 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0, 1019 speed_template_16_24_32); 1020 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0, 1021 speed_template_16_24_32); 1022 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0, 1023 speed_template_16_24_32); 1024 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0, 1025 speed_template_16_24_32); 1026 break; 1027 1028 case 203: 1029 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0, 1030 speed_template_8_32); 1031 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0, 1032 speed_template_8_32); 1033 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0, 1034 speed_template_8_32); 1035 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0, 1036 speed_template_8_32); 1037 break; 1038 1039 case 204: 1040 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0, 1041 speed_template_8); 1042 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0, 1043 speed_template_8); 1044 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0, 1045 speed_template_8); 1046 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0, 1047 speed_template_8); 1048 break; 1049 1050 case 205: 1051 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0, 1052 speed_template_16_24_32); 1053 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0, 1054 speed_template_16_24_32); 1055 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0, 1056 speed_template_16_24_32); 1057 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0, 1058 speed_template_16_24_32); 1059 break; 1060 1061 case 206: 1062 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0, 1063 speed_template_16_32); 1064 break; 1065 1066 case 300: 1067 /* fall through */ 1068 1069 case 301: 1070 test_hash_speed("md4", sec, generic_hash_speed_template); 1071 if (mode > 300 && mode < 400) break; 1072 1073 case 302: 1074 test_hash_speed("md5", sec, generic_hash_speed_template); 1075 if (mode > 300 && mode < 400) break; 1076 1077 case 303: 1078 test_hash_speed("sha1", sec, generic_hash_speed_template); 1079 if (mode > 300 && mode < 400) break; 1080 1081 case 304: 1082 test_hash_speed("sha256", sec, generic_hash_speed_template); 1083 if (mode > 300 && mode < 400) break; 1084 1085 case 305: 1086 test_hash_speed("sha384", sec, generic_hash_speed_template); 1087 if (mode > 300 && mode < 400) break; 1088 1089 case 306: 1090 test_hash_speed("sha512", sec, generic_hash_speed_template); 1091 if (mode > 300 && mode < 400) break; 1092 1093 case 307: 1094 test_hash_speed("wp256", sec, generic_hash_speed_template); 1095 if (mode > 300 && mode < 400) break; 1096 1097 case 308: 1098 test_hash_speed("wp384", sec, generic_hash_speed_template); 1099 if (mode > 300 && mode < 400) break; 1100 1101 case 309: 1102 test_hash_speed("wp512", sec, generic_hash_speed_template); 1103 if (mode > 300 && mode < 400) break; 1104 1105 case 310: 1106 test_hash_speed("tgr128", sec, generic_hash_speed_template); 1107 if (mode > 300 && mode < 400) break; 1108 1109 case 311: 1110 test_hash_speed("tgr160", sec, generic_hash_speed_template); 1111 if (mode > 300 && mode < 400) break; 1112 1113 case 312: 1114 test_hash_speed("tgr192", sec, generic_hash_speed_template); 1115 if (mode > 300 && mode < 400) break; 1116 1117 case 313: 1118 test_hash_speed("sha224", sec, generic_hash_speed_template); 1119 if (mode > 300 && mode < 400) break; 1120 1121 case 314: 1122 test_hash_speed("rmd128", sec, generic_hash_speed_template); 1123 if (mode > 300 && mode < 400) break; 1124 1125 case 315: 1126 test_hash_speed("rmd160", sec, generic_hash_speed_template); 1127 if (mode > 300 && mode < 400) break; 1128 1129 case 316: 1130 test_hash_speed("rmd256", sec, generic_hash_speed_template); 1131 if (mode > 300 && mode < 400) break; 1132 1133 case 317: 1134 test_hash_speed("rmd320", sec, generic_hash_speed_template); 1135 if (mode > 300 && mode < 400) break; 1136 1137 case 318: 1138 test_hash_speed("ghash-generic", sec, hash_speed_template_16); 1139 if (mode > 300 && mode < 400) break; 1140 1141 case 399: 1142 break; 1143 1144 case 400: 1145 /* fall through */ 1146 1147 case 401: 1148 test_ahash_speed("md4", sec, generic_hash_speed_template); 1149 if (mode > 400 && mode < 500) break; 1150 1151 case 402: 1152 test_ahash_speed("md5", sec, generic_hash_speed_template); 1153 if (mode > 400 && mode < 500) break; 1154 1155 case 403: 1156 test_ahash_speed("sha1", sec, generic_hash_speed_template); 1157 if (mode > 400 && mode < 500) break; 1158 1159 case 404: 1160 test_ahash_speed("sha256", sec, generic_hash_speed_template); 1161 if (mode > 400 && mode < 500) break; 1162 1163 case 405: 1164 test_ahash_speed("sha384", sec, generic_hash_speed_template); 1165 if (mode > 400 && mode < 500) break; 1166 1167 case 406: 1168 test_ahash_speed("sha512", sec, generic_hash_speed_template); 1169 if (mode > 400 && mode < 500) break; 1170 1171 case 407: 1172 test_ahash_speed("wp256", sec, generic_hash_speed_template); 1173 if (mode > 400 && mode < 500) break; 1174 1175 case 408: 1176 test_ahash_speed("wp384", sec, generic_hash_speed_template); 1177 if (mode > 400 && mode < 500) break; 1178 1179 case 409: 1180 test_ahash_speed("wp512", sec, generic_hash_speed_template); 1181 if (mode > 400 && mode < 500) break; 1182 1183 case 410: 1184 test_ahash_speed("tgr128", sec, generic_hash_speed_template); 1185 if (mode > 400 && mode < 500) break; 1186 1187 case 411: 1188 test_ahash_speed("tgr160", sec, generic_hash_speed_template); 1189 if (mode > 400 && mode < 500) break; 1190 1191 case 412: 1192 test_ahash_speed("tgr192", sec, generic_hash_speed_template); 1193 if (mode > 400 && mode < 500) break; 1194 1195 case 413: 1196 test_ahash_speed("sha224", sec, generic_hash_speed_template); 1197 if (mode > 400 && mode < 500) break; 1198 1199 case 414: 1200 test_ahash_speed("rmd128", sec, generic_hash_speed_template); 1201 if (mode > 400 && mode < 500) break; 1202 1203 case 415: 1204 test_ahash_speed("rmd160", sec, generic_hash_speed_template); 1205 if (mode > 400 && mode < 500) break; 1206 1207 case 416: 1208 test_ahash_speed("rmd256", sec, generic_hash_speed_template); 1209 if (mode > 400 && mode < 500) break; 1210 1211 case 417: 1212 test_ahash_speed("rmd320", sec, generic_hash_speed_template); 1213 if (mode > 400 && mode < 500) break; 1214 1215 case 499: 1216 break; 1217 1218 case 1000: 1219 test_available(); 1220 break; 1221 } 1222 1223 return ret; 1224} 1225 1226static int do_alg_test(const char *alg, u32 type, u32 mask) 1227{ 1228 return crypto_has_alg(alg, type, mask ?: CRYPTO_ALG_TYPE_MASK) ? 1229 0 : -ENOENT; 1230} 1231 1232static int __init tcrypt_mod_init(void) 1233{ 1234 int err = -ENOMEM; 1235 int i; 1236 1237 for (i = 0; i < TVMEMSIZE; i++) { 1238 tvmem[i] = (void *)__get_free_page(GFP_KERNEL); 1239 if (!tvmem[i]) 1240 goto err_free_tv; 1241 } 1242 1243 if (alg) 1244 err = do_alg_test(alg, type, mask); 1245 else 1246 err = do_test(mode); 1247 1248 if (err) { 1249 printk(KERN_ERR "tcrypt: one or more tests failed!\n"); 1250 goto err_free_tv; 1251 } 1252 1253 /* We intentionaly return -EAGAIN to prevent keeping the module, 1254 * unless we're running in fips mode. It does all its work from 1255 * init() and doesn't offer any runtime functionality, but in 1256 * the fips case, checking for a successful load is helpful. 1257 * => we don't need it in the memory, do we? 1258 * -- mludvig 1259 */ 1260 if (!fips_enabled) 1261 err = -EAGAIN; 1262 1263err_free_tv: 1264 for (i = 0; i < TVMEMSIZE && tvmem[i]; i++) 1265 free_page((unsigned long)tvmem[i]); 1266 1267 return err; 1268} 1269 1270/* 1271 * If an init function is provided, an exit function must also be provided 1272 * to allow module unload. 1273 */ 1274static void __exit tcrypt_mod_fini(void) { } 1275 1276module_init(tcrypt_mod_init); 1277module_exit(tcrypt_mod_fini); 1278 1279module_param(alg, charp, 0); 1280module_param(type, uint, 0); 1281module_param(mask, uint, 0); 1282module_param(mode, int, 0); 1283module_param(sec, uint, 0); 1284MODULE_PARM_DESC(sec, "Length in seconds of speed tests " 1285 "(defaults to zero which uses CPU cycles instead)"); 1286 1287MODULE_LICENSE("GPL"); 1288MODULE_DESCRIPTION("Quick & dirty crypto testing module"); 1289MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>"); 1290