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 * Updated RFC4106 AES-GCM testing. 12 * Authors: Aidan O'Mahony (aidan.o.mahony@intel.com) 13 * Adrian Hoban <adrian.hoban@intel.com> 14 * Gabriele Paoloni <gabriele.paoloni@intel.com> 15 * Tadeusz Struk (tadeusz.struk@intel.com) 16 * Copyright (c) 2010, Intel Corporation. 17 * 18 * This program is free software; you can redistribute it and/or modify it 19 * under the terms of the GNU General Public License as published by the Free 20 * Software Foundation; either version 2 of the License, or (at your option) 21 * any later version. 22 * 23 */ 24 25 #include <crypto/hash.h> 26 #include <linux/err.h> 27 #include <linux/init.h> 28 #include <linux/gfp.h> 29 #include <linux/module.h> 30 #include <linux/scatterlist.h> 31 #include <linux/string.h> 32 #include <linux/moduleparam.h> 33 #include <linux/jiffies.h> 34 #include <linux/timex.h> 35 #include <linux/interrupt.h> 36 #include "tcrypt.h" 37 #include "internal.h" 38 39 /* 40 * Need slab memory for testing (size in number of pages). 41 */ 42 #define TVMEMSIZE 4 43 44 /* 45 * Used by test_cipher_speed() 46 */ 47 #define ENCRYPT 1 48 #define DECRYPT 0 49 50 /* 51 * Used by test_cipher_speed() 52 */ 53 static unsigned int sec; 54 55 static char *alg = NULL; 56 static u32 type; 57 static u32 mask; 58 static int mode; 59 static char *tvmem[TVMEMSIZE]; 60 61 static char *check[] = { 62 "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256", 63 "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes", 64 "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea", 65 "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", "fcrypt", 66 "camellia", "seed", "salsa20", "rmd128", "rmd160", "rmd256", "rmd320", 67 "lzo", "cts", "zlib", NULL 68 }; 69 70 static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc, 71 struct scatterlist *sg, int blen, int sec) 72 { 73 unsigned long start, end; 74 int bcount; 75 int ret; 76 77 for (start = jiffies, end = start + sec * HZ, bcount = 0; 78 time_before(jiffies, end); bcount++) { 79 if (enc) 80 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen); 81 else 82 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen); 83 84 if (ret) 85 return ret; 86 } 87 88 printk("%d operations in %d seconds (%ld bytes)\n", 89 bcount, sec, (long)bcount * blen); 90 return 0; 91 } 92 93 static int test_cipher_cycles(struct blkcipher_desc *desc, int enc, 94 struct scatterlist *sg, int blen) 95 { 96 unsigned long cycles = 0; 97 int ret = 0; 98 int i; 99 100 local_bh_disable(); 101 local_irq_disable(); 102 103 /* Warm-up run. */ 104 for (i = 0; i < 4; i++) { 105 if (enc) 106 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen); 107 else 108 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen); 109 110 if (ret) 111 goto out; 112 } 113 114 /* The real thing. */ 115 for (i = 0; i < 8; i++) { 116 cycles_t start, end; 117 118 start = get_cycles(); 119 if (enc) 120 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen); 121 else 122 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen); 123 end = get_cycles(); 124 125 if (ret) 126 goto out; 127 128 cycles += end - start; 129 } 130 131 out: 132 local_irq_enable(); 133 local_bh_enable(); 134 135 if (ret == 0) 136 printk("1 operation in %lu cycles (%d bytes)\n", 137 (cycles + 4) / 8, blen); 138 139 return ret; 140 } 141 142 static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 }; 143 144 static void test_cipher_speed(const char *algo, int enc, unsigned int sec, 145 struct cipher_speed_template *template, 146 unsigned int tcount, u8 *keysize) 147 { 148 unsigned int ret, i, j, iv_len; 149 const char *key; 150 char iv[128]; 151 struct crypto_blkcipher *tfm; 152 struct blkcipher_desc desc; 153 const char *e; 154 u32 *b_size; 155 156 if (enc == ENCRYPT) 157 e = "encryption"; 158 else 159 e = "decryption"; 160 161 printk("\ntesting speed of %s %s\n", algo, e); 162 163 tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC); 164 165 if (IS_ERR(tfm)) { 166 printk("failed to load transform for %s: %ld\n", algo, 167 PTR_ERR(tfm)); 168 return; 169 } 170 desc.tfm = tfm; 171 desc.flags = 0; 172 173 i = 0; 174 do { 175 176 b_size = block_sizes; 177 do { 178 struct scatterlist sg[TVMEMSIZE]; 179 180 if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) { 181 printk("template (%u) too big for " 182 "tvmem (%lu)\n", *keysize + *b_size, 183 TVMEMSIZE * PAGE_SIZE); 184 goto out; 185 } 186 187 printk("test %u (%d bit key, %d byte blocks): ", i, 188 *keysize * 8, *b_size); 189 190 memset(tvmem[0], 0xff, PAGE_SIZE); 191 192 /* set key, plain text and IV */ 193 key = tvmem[0]; 194 for (j = 0; j < tcount; j++) { 195 if (template[j].klen == *keysize) { 196 key = template[j].key; 197 break; 198 } 199 } 200 201 ret = crypto_blkcipher_setkey(tfm, key, *keysize); 202 if (ret) { 203 printk("setkey() failed flags=%x\n", 204 crypto_blkcipher_get_flags(tfm)); 205 goto out; 206 } 207 208 sg_init_table(sg, TVMEMSIZE); 209 sg_set_buf(sg, tvmem[0] + *keysize, 210 PAGE_SIZE - *keysize); 211 for (j = 1; j < TVMEMSIZE; j++) { 212 sg_set_buf(sg + j, tvmem[j], PAGE_SIZE); 213 memset (tvmem[j], 0xff, PAGE_SIZE); 214 } 215 216 iv_len = crypto_blkcipher_ivsize(tfm); 217 if (iv_len) { 218 memset(&iv, 0xff, iv_len); 219 crypto_blkcipher_set_iv(tfm, iv, iv_len); 220 } 221 222 if (sec) 223 ret = test_cipher_jiffies(&desc, enc, sg, 224 *b_size, sec); 225 else 226 ret = test_cipher_cycles(&desc, enc, sg, 227 *b_size); 228 229 if (ret) { 230 printk("%s() failed flags=%x\n", e, desc.flags); 231 break; 232 } 233 b_size++; 234 i++; 235 } while (*b_size); 236 keysize++; 237 } while (*keysize); 238 239 out: 240 crypto_free_blkcipher(tfm); 241 } 242 243 static int test_hash_jiffies_digest(struct hash_desc *desc, 244 struct scatterlist *sg, int blen, 245 char *out, int sec) 246 { 247 unsigned long start, end; 248 int bcount; 249 int ret; 250 251 for (start = jiffies, end = start + sec * HZ, bcount = 0; 252 time_before(jiffies, end); bcount++) { 253 ret = crypto_hash_digest(desc, sg, blen, out); 254 if (ret) 255 return ret; 256 } 257 258 printk("%6u opers/sec, %9lu bytes/sec\n", 259 bcount / sec, ((long)bcount * blen) / sec); 260 261 return 0; 262 } 263 264 static int test_hash_jiffies(struct hash_desc *desc, struct scatterlist *sg, 265 int blen, int plen, char *out, int sec) 266 { 267 unsigned long start, end; 268 int bcount, pcount; 269 int ret; 270 271 if (plen == blen) 272 return test_hash_jiffies_digest(desc, sg, blen, out, sec); 273 274 for (start = jiffies, end = start + sec * HZ, bcount = 0; 275 time_before(jiffies, end); bcount++) { 276 ret = crypto_hash_init(desc); 277 if (ret) 278 return ret; 279 for (pcount = 0; pcount < blen; pcount += plen) { 280 ret = crypto_hash_update(desc, sg, plen); 281 if (ret) 282 return ret; 283 } 284 /* we assume there is enough space in 'out' for the result */ 285 ret = crypto_hash_final(desc, out); 286 if (ret) 287 return ret; 288 } 289 290 printk("%6u opers/sec, %9lu bytes/sec\n", 291 bcount / sec, ((long)bcount * blen) / sec); 292 293 return 0; 294 } 295 296 static int test_hash_cycles_digest(struct hash_desc *desc, 297 struct scatterlist *sg, int blen, char *out) 298 { 299 unsigned long cycles = 0; 300 int i; 301 int ret; 302 303 local_bh_disable(); 304 local_irq_disable(); 305 306 /* Warm-up run. */ 307 for (i = 0; i < 4; i++) { 308 ret = crypto_hash_digest(desc, sg, blen, out); 309 if (ret) 310 goto out; 311 } 312 313 /* The real thing. */ 314 for (i = 0; i < 8; i++) { 315 cycles_t start, end; 316 317 start = get_cycles(); 318 319 ret = crypto_hash_digest(desc, sg, blen, out); 320 if (ret) 321 goto out; 322 323 end = get_cycles(); 324 325 cycles += end - start; 326 } 327 328 out: 329 local_irq_enable(); 330 local_bh_enable(); 331 332 if (ret) 333 return ret; 334 335 printk("%6lu cycles/operation, %4lu cycles/byte\n", 336 cycles / 8, cycles / (8 * blen)); 337 338 return 0; 339 } 340 341 static int test_hash_cycles(struct hash_desc *desc, struct scatterlist *sg, 342 int blen, int plen, char *out) 343 { 344 unsigned long cycles = 0; 345 int i, pcount; 346 int ret; 347 348 if (plen == blen) 349 return test_hash_cycles_digest(desc, sg, blen, out); 350 351 local_bh_disable(); 352 local_irq_disable(); 353 354 /* Warm-up run. */ 355 for (i = 0; i < 4; i++) { 356 ret = crypto_hash_init(desc); 357 if (ret) 358 goto out; 359 for (pcount = 0; pcount < blen; pcount += plen) { 360 ret = crypto_hash_update(desc, sg, plen); 361 if (ret) 362 goto out; 363 } 364 ret = crypto_hash_final(desc, out); 365 if (ret) 366 goto out; 367 } 368 369 /* The real thing. */ 370 for (i = 0; i < 8; i++) { 371 cycles_t start, end; 372 373 start = get_cycles(); 374 375 ret = crypto_hash_init(desc); 376 if (ret) 377 goto out; 378 for (pcount = 0; pcount < blen; pcount += plen) { 379 ret = crypto_hash_update(desc, sg, plen); 380 if (ret) 381 goto out; 382 } 383 ret = crypto_hash_final(desc, out); 384 if (ret) 385 goto out; 386 387 end = get_cycles(); 388 389 cycles += end - start; 390 } 391 392 out: 393 local_irq_enable(); 394 local_bh_enable(); 395 396 if (ret) 397 return ret; 398 399 printk("%6lu cycles/operation, %4lu cycles/byte\n", 400 cycles / 8, cycles / (8 * blen)); 401 402 return 0; 403 } 404 405 static void test_hash_sg_init(struct scatterlist *sg) 406 { 407 int i; 408 409 sg_init_table(sg, TVMEMSIZE); 410 for (i = 0; i < TVMEMSIZE; i++) { 411 sg_set_buf(sg + i, tvmem[i], PAGE_SIZE); 412 memset(tvmem[i], 0xff, PAGE_SIZE); 413 } 414 } 415 416 static void test_hash_speed(const char *algo, unsigned int sec, 417 struct hash_speed *speed) 418 { 419 struct scatterlist sg[TVMEMSIZE]; 420 struct crypto_hash *tfm; 421 struct hash_desc desc; 422 static char output[1024]; 423 int i; 424 int ret; 425 426 printk(KERN_INFO "\ntesting speed of %s\n", algo); 427 428 tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC); 429 430 if (IS_ERR(tfm)) { 431 printk(KERN_ERR "failed to load transform for %s: %ld\n", algo, 432 PTR_ERR(tfm)); 433 return; 434 } 435 436 desc.tfm = tfm; 437 desc.flags = 0; 438 439 if (crypto_hash_digestsize(tfm) > sizeof(output)) { 440 printk(KERN_ERR "digestsize(%u) > outputbuffer(%zu)\n", 441 crypto_hash_digestsize(tfm), sizeof(output)); 442 goto out; 443 } 444 445 test_hash_sg_init(sg); 446 for (i = 0; speed[i].blen != 0; i++) { 447 if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) { 448 printk(KERN_ERR 449 "template (%u) too big for tvmem (%lu)\n", 450 speed[i].blen, TVMEMSIZE * PAGE_SIZE); 451 goto out; 452 } 453 454 if (speed[i].klen) 455 crypto_hash_setkey(tfm, tvmem[0], speed[i].klen); 456 457 printk(KERN_INFO "test%3u " 458 "(%5u byte blocks,%5u bytes per update,%4u updates): ", 459 i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen); 460 461 if (sec) 462 ret = test_hash_jiffies(&desc, sg, speed[i].blen, 463 speed[i].plen, output, sec); 464 else 465 ret = test_hash_cycles(&desc, sg, speed[i].blen, 466 speed[i].plen, output); 467 468 if (ret) { 469 printk(KERN_ERR "hashing failed ret=%d\n", ret); 470 break; 471 } 472 } 473 474 out: 475 crypto_free_hash(tfm); 476 } 477 478 struct tcrypt_result { 479 struct completion completion; 480 int err; 481 }; 482 483 static void tcrypt_complete(struct crypto_async_request *req, int err) 484 { 485 struct tcrypt_result *res = req->data; 486 487 if (err == -EINPROGRESS) 488 return; 489 490 res->err = err; 491 complete(&res->completion); 492 } 493 494 static inline int do_one_ahash_op(struct ahash_request *req, int ret) 495 { 496 if (ret == -EINPROGRESS || ret == -EBUSY) { 497 struct tcrypt_result *tr = req->base.data; 498 499 ret = wait_for_completion_interruptible(&tr->completion); 500 if (!ret) 501 ret = tr->err; 502 INIT_COMPLETION(tr->completion); 503 } 504 return ret; 505 } 506 507 static int test_ahash_jiffies_digest(struct ahash_request *req, int blen, 508 char *out, int sec) 509 { 510 unsigned long start, end; 511 int bcount; 512 int ret; 513 514 for (start = jiffies, end = start + sec * HZ, bcount = 0; 515 time_before(jiffies, end); bcount++) { 516 ret = do_one_ahash_op(req, crypto_ahash_digest(req)); 517 if (ret) 518 return ret; 519 } 520 521 printk("%6u opers/sec, %9lu bytes/sec\n", 522 bcount / sec, ((long)bcount * blen) / sec); 523 524 return 0; 525 } 526 527 static int test_ahash_jiffies(struct ahash_request *req, int blen, 528 int plen, char *out, int sec) 529 { 530 unsigned long start, end; 531 int bcount, pcount; 532 int ret; 533 534 if (plen == blen) 535 return test_ahash_jiffies_digest(req, blen, out, sec); 536 537 for (start = jiffies, end = start + sec * HZ, bcount = 0; 538 time_before(jiffies, end); bcount++) { 539 ret = crypto_ahash_init(req); 540 if (ret) 541 return ret; 542 for (pcount = 0; pcount < blen; pcount += plen) { 543 ret = do_one_ahash_op(req, crypto_ahash_update(req)); 544 if (ret) 545 return ret; 546 } 547 /* we assume there is enough space in 'out' for the result */ 548 ret = do_one_ahash_op(req, crypto_ahash_final(req)); 549 if (ret) 550 return ret; 551 } 552 553 pr_cont("%6u opers/sec, %9lu bytes/sec\n", 554 bcount / sec, ((long)bcount * blen) / sec); 555 556 return 0; 557 } 558 559 static int test_ahash_cycles_digest(struct ahash_request *req, int blen, 560 char *out) 561 { 562 unsigned long cycles = 0; 563 int ret, i; 564 565 /* Warm-up run. */ 566 for (i = 0; i < 4; i++) { 567 ret = do_one_ahash_op(req, crypto_ahash_digest(req)); 568 if (ret) 569 goto out; 570 } 571 572 /* The real thing. */ 573 for (i = 0; i < 8; i++) { 574 cycles_t start, end; 575 576 start = get_cycles(); 577 578 ret = do_one_ahash_op(req, crypto_ahash_digest(req)); 579 if (ret) 580 goto out; 581 582 end = get_cycles(); 583 584 cycles += end - start; 585 } 586 587 out: 588 if (ret) 589 return ret; 590 591 pr_cont("%6lu cycles/operation, %4lu cycles/byte\n", 592 cycles / 8, cycles / (8 * blen)); 593 594 return 0; 595 } 596 597 static int test_ahash_cycles(struct ahash_request *req, int blen, 598 int plen, char *out) 599 { 600 unsigned long cycles = 0; 601 int i, pcount, ret; 602 603 if (plen == blen) 604 return test_ahash_cycles_digest(req, blen, out); 605 606 /* Warm-up run. */ 607 for (i = 0; i < 4; i++) { 608 ret = crypto_ahash_init(req); 609 if (ret) 610 goto out; 611 for (pcount = 0; pcount < blen; pcount += plen) { 612 ret = do_one_ahash_op(req, crypto_ahash_update(req)); 613 if (ret) 614 goto out; 615 } 616 ret = do_one_ahash_op(req, crypto_ahash_final(req)); 617 if (ret) 618 goto out; 619 } 620 621 /* The real thing. */ 622 for (i = 0; i < 8; i++) { 623 cycles_t start, end; 624 625 start = get_cycles(); 626 627 ret = crypto_ahash_init(req); 628 if (ret) 629 goto out; 630 for (pcount = 0; pcount < blen; pcount += plen) { 631 ret = do_one_ahash_op(req, crypto_ahash_update(req)); 632 if (ret) 633 goto out; 634 } 635 ret = do_one_ahash_op(req, crypto_ahash_final(req)); 636 if (ret) 637 goto out; 638 639 end = get_cycles(); 640 641 cycles += end - start; 642 } 643 644 out: 645 if (ret) 646 return ret; 647 648 pr_cont("%6lu cycles/operation, %4lu cycles/byte\n", 649 cycles / 8, cycles / (8 * blen)); 650 651 return 0; 652 } 653 654 static void test_ahash_speed(const char *algo, unsigned int sec, 655 struct hash_speed *speed) 656 { 657 struct scatterlist sg[TVMEMSIZE]; 658 struct tcrypt_result tresult; 659 struct ahash_request *req; 660 struct crypto_ahash *tfm; 661 static char output[1024]; 662 int i, ret; 663 664 printk(KERN_INFO "\ntesting speed of async %s\n", algo); 665 666 tfm = crypto_alloc_ahash(algo, 0, 0); 667 if (IS_ERR(tfm)) { 668 pr_err("failed to load transform for %s: %ld\n", 669 algo, PTR_ERR(tfm)); 670 return; 671 } 672 673 if (crypto_ahash_digestsize(tfm) > sizeof(output)) { 674 pr_err("digestsize(%u) > outputbuffer(%zu)\n", 675 crypto_ahash_digestsize(tfm), sizeof(output)); 676 goto out; 677 } 678 679 test_hash_sg_init(sg); 680 req = ahash_request_alloc(tfm, GFP_KERNEL); 681 if (!req) { 682 pr_err("ahash request allocation failure\n"); 683 goto out; 684 } 685 686 init_completion(&tresult.completion); 687 ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 688 tcrypt_complete, &tresult); 689 690 for (i = 0; speed[i].blen != 0; i++) { 691 if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) { 692 pr_err("template (%u) too big for tvmem (%lu)\n", 693 speed[i].blen, TVMEMSIZE * PAGE_SIZE); 694 break; 695 } 696 697 pr_info("test%3u " 698 "(%5u byte blocks,%5u bytes per update,%4u updates): ", 699 i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen); 700 701 ahash_request_set_crypt(req, sg, output, speed[i].plen); 702 703 if (sec) 704 ret = test_ahash_jiffies(req, speed[i].blen, 705 speed[i].plen, output, sec); 706 else 707 ret = test_ahash_cycles(req, speed[i].blen, 708 speed[i].plen, output); 709 710 if (ret) { 711 pr_err("hashing failed ret=%d\n", ret); 712 break; 713 } 714 } 715 716 ahash_request_free(req); 717 718 out: 719 crypto_free_ahash(tfm); 720 } 721 722 static inline int do_one_acipher_op(struct ablkcipher_request *req, int ret) 723 { 724 if (ret == -EINPROGRESS || ret == -EBUSY) { 725 struct tcrypt_result *tr = req->base.data; 726 727 ret = wait_for_completion_interruptible(&tr->completion); 728 if (!ret) 729 ret = tr->err; 730 INIT_COMPLETION(tr->completion); 731 } 732 733 return ret; 734 } 735 736 static int test_acipher_jiffies(struct ablkcipher_request *req, int enc, 737 int blen, int sec) 738 { 739 unsigned long start, end; 740 int bcount; 741 int ret; 742 743 for (start = jiffies, end = start + sec * HZ, bcount = 0; 744 time_before(jiffies, end); bcount++) { 745 if (enc) 746 ret = do_one_acipher_op(req, 747 crypto_ablkcipher_encrypt(req)); 748 else 749 ret = do_one_acipher_op(req, 750 crypto_ablkcipher_decrypt(req)); 751 752 if (ret) 753 return ret; 754 } 755 756 pr_cont("%d operations in %d seconds (%ld bytes)\n", 757 bcount, sec, (long)bcount * blen); 758 return 0; 759 } 760 761 static int test_acipher_cycles(struct ablkcipher_request *req, int enc, 762 int blen) 763 { 764 unsigned long cycles = 0; 765 int ret = 0; 766 int i; 767 768 /* Warm-up run. */ 769 for (i = 0; i < 4; i++) { 770 if (enc) 771 ret = do_one_acipher_op(req, 772 crypto_ablkcipher_encrypt(req)); 773 else 774 ret = do_one_acipher_op(req, 775 crypto_ablkcipher_decrypt(req)); 776 777 if (ret) 778 goto out; 779 } 780 781 /* The real thing. */ 782 for (i = 0; i < 8; i++) { 783 cycles_t start, end; 784 785 start = get_cycles(); 786 if (enc) 787 ret = do_one_acipher_op(req, 788 crypto_ablkcipher_encrypt(req)); 789 else 790 ret = do_one_acipher_op(req, 791 crypto_ablkcipher_decrypt(req)); 792 end = get_cycles(); 793 794 if (ret) 795 goto out; 796 797 cycles += end - start; 798 } 799 800 out: 801 if (ret == 0) 802 pr_cont("1 operation in %lu cycles (%d bytes)\n", 803 (cycles + 4) / 8, blen); 804 805 return ret; 806 } 807 808 static void test_acipher_speed(const char *algo, int enc, unsigned int sec, 809 struct cipher_speed_template *template, 810 unsigned int tcount, u8 *keysize) 811 { 812 unsigned int ret, i, j, k, iv_len; 813 struct tcrypt_result tresult; 814 const char *key; 815 char iv[128]; 816 struct ablkcipher_request *req; 817 struct crypto_ablkcipher *tfm; 818 const char *e; 819 u32 *b_size; 820 821 if (enc == ENCRYPT) 822 e = "encryption"; 823 else 824 e = "decryption"; 825 826 pr_info("\ntesting speed of async %s %s\n", algo, e); 827 828 init_completion(&tresult.completion); 829 830 tfm = crypto_alloc_ablkcipher(algo, 0, 0); 831 832 if (IS_ERR(tfm)) { 833 pr_err("failed to load transform for %s: %ld\n", algo, 834 PTR_ERR(tfm)); 835 return; 836 } 837 838 req = ablkcipher_request_alloc(tfm, GFP_KERNEL); 839 if (!req) { 840 pr_err("tcrypt: skcipher: Failed to allocate request for %s\n", 841 algo); 842 goto out; 843 } 844 845 ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 846 tcrypt_complete, &tresult); 847 848 i = 0; 849 do { 850 b_size = block_sizes; 851 852 do { 853 struct scatterlist sg[TVMEMSIZE]; 854 855 if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) { 856 pr_err("template (%u) too big for " 857 "tvmem (%lu)\n", *keysize + *b_size, 858 TVMEMSIZE * PAGE_SIZE); 859 goto out_free_req; 860 } 861 862 pr_info("test %u (%d bit key, %d byte blocks): ", i, 863 *keysize * 8, *b_size); 864 865 memset(tvmem[0], 0xff, PAGE_SIZE); 866 867 /* set key, plain text and IV */ 868 key = tvmem[0]; 869 for (j = 0; j < tcount; j++) { 870 if (template[j].klen == *keysize) { 871 key = template[j].key; 872 break; 873 } 874 } 875 876 crypto_ablkcipher_clear_flags(tfm, ~0); 877 878 ret = crypto_ablkcipher_setkey(tfm, key, *keysize); 879 if (ret) { 880 pr_err("setkey() failed flags=%x\n", 881 crypto_ablkcipher_get_flags(tfm)); 882 goto out_free_req; 883 } 884 885 sg_init_table(sg, TVMEMSIZE); 886 887 k = *keysize + *b_size; 888 if (k > PAGE_SIZE) { 889 sg_set_buf(sg, tvmem[0] + *keysize, 890 PAGE_SIZE - *keysize); 891 k -= PAGE_SIZE; 892 j = 1; 893 while (k > PAGE_SIZE) { 894 sg_set_buf(sg + j, tvmem[j], PAGE_SIZE); 895 memset(tvmem[j], 0xff, PAGE_SIZE); 896 j++; 897 k -= PAGE_SIZE; 898 } 899 sg_set_buf(sg + j, tvmem[j], k); 900 memset(tvmem[j], 0xff, k); 901 } else { 902 sg_set_buf(sg, tvmem[0] + *keysize, *b_size); 903 } 904 905 iv_len = crypto_ablkcipher_ivsize(tfm); 906 if (iv_len) 907 memset(&iv, 0xff, iv_len); 908 909 ablkcipher_request_set_crypt(req, sg, sg, *b_size, iv); 910 911 if (sec) 912 ret = test_acipher_jiffies(req, enc, 913 *b_size, sec); 914 else 915 ret = test_acipher_cycles(req, enc, 916 *b_size); 917 918 if (ret) { 919 pr_err("%s() failed flags=%x\n", e, 920 crypto_ablkcipher_get_flags(tfm)); 921 break; 922 } 923 b_size++; 924 i++; 925 } while (*b_size); 926 keysize++; 927 } while (*keysize); 928 929 out_free_req: 930 ablkcipher_request_free(req); 931 out: 932 crypto_free_ablkcipher(tfm); 933 } 934 935 static void test_available(void) 936 { 937 char **name = check; 938 939 while (*name) { 940 printk("alg %s ", *name); 941 printk(crypto_has_alg(*name, 0, 0) ? 942 "found\n" : "not found\n"); 943 name++; 944 } 945 } 946 947 static inline int tcrypt_test(const char *alg) 948 { 949 int ret; 950 951 ret = alg_test(alg, alg, 0, 0); 952 /* non-fips algs return -EINVAL in fips mode */ 953 if (fips_enabled && ret == -EINVAL) 954 ret = 0; 955 return ret; 956 } 957 958 static int do_test(int m) 959 { 960 int i; 961 int ret = 0; 962 963 switch (m) { 964 case 0: 965 for (i = 1; i < 200; i++) 966 ret += do_test(i); 967 break; 968 969 case 1: 970 ret += tcrypt_test("md5"); 971 break; 972 973 case 2: 974 ret += tcrypt_test("sha1"); 975 break; 976 977 case 3: 978 ret += tcrypt_test("ecb(des)"); 979 ret += tcrypt_test("cbc(des)"); 980 break; 981 982 case 4: 983 ret += tcrypt_test("ecb(des3_ede)"); 984 ret += tcrypt_test("cbc(des3_ede)"); 985 break; 986 987 case 5: 988 ret += tcrypt_test("md4"); 989 break; 990 991 case 6: 992 ret += tcrypt_test("sha256"); 993 break; 994 995 case 7: 996 ret += tcrypt_test("ecb(blowfish)"); 997 ret += tcrypt_test("cbc(blowfish)"); 998 ret += tcrypt_test("ctr(blowfish)"); 999 break; 1000 1001 case 8: 1002 ret += tcrypt_test("ecb(twofish)"); 1003 ret += tcrypt_test("cbc(twofish)"); 1004 ret += tcrypt_test("ctr(twofish)"); 1005 ret += tcrypt_test("lrw(twofish)"); 1006 ret += tcrypt_test("xts(twofish)"); 1007 break; 1008 1009 case 9: 1010 ret += tcrypt_test("ecb(serpent)"); 1011 ret += tcrypt_test("cbc(serpent)"); 1012 ret += tcrypt_test("ctr(serpent)"); 1013 ret += tcrypt_test("lrw(serpent)"); 1014 ret += tcrypt_test("xts(serpent)"); 1015 break; 1016 1017 case 10: 1018 ret += tcrypt_test("ecb(aes)"); 1019 ret += tcrypt_test("cbc(aes)"); 1020 ret += tcrypt_test("lrw(aes)"); 1021 ret += tcrypt_test("xts(aes)"); 1022 ret += tcrypt_test("ctr(aes)"); 1023 ret += tcrypt_test("rfc3686(ctr(aes))"); 1024 break; 1025 1026 case 11: 1027 ret += tcrypt_test("sha384"); 1028 break; 1029 1030 case 12: 1031 ret += tcrypt_test("sha512"); 1032 break; 1033 1034 case 13: 1035 ret += tcrypt_test("deflate"); 1036 break; 1037 1038 case 14: 1039 ret += tcrypt_test("ecb(cast5)"); 1040 break; 1041 1042 case 15: 1043 ret += tcrypt_test("ecb(cast6)"); 1044 break; 1045 1046 case 16: 1047 ret += tcrypt_test("ecb(arc4)"); 1048 break; 1049 1050 case 17: 1051 ret += tcrypt_test("michael_mic"); 1052 break; 1053 1054 case 18: 1055 ret += tcrypt_test("crc32c"); 1056 break; 1057 1058 case 19: 1059 ret += tcrypt_test("ecb(tea)"); 1060 break; 1061 1062 case 20: 1063 ret += tcrypt_test("ecb(xtea)"); 1064 break; 1065 1066 case 21: 1067 ret += tcrypt_test("ecb(khazad)"); 1068 break; 1069 1070 case 22: 1071 ret += tcrypt_test("wp512"); 1072 break; 1073 1074 case 23: 1075 ret += tcrypt_test("wp384"); 1076 break; 1077 1078 case 24: 1079 ret += tcrypt_test("wp256"); 1080 break; 1081 1082 case 25: 1083 ret += tcrypt_test("ecb(tnepres)"); 1084 break; 1085 1086 case 26: 1087 ret += tcrypt_test("ecb(anubis)"); 1088 ret += tcrypt_test("cbc(anubis)"); 1089 break; 1090 1091 case 27: 1092 ret += tcrypt_test("tgr192"); 1093 break; 1094 1095 case 28: 1096 1097 ret += tcrypt_test("tgr160"); 1098 break; 1099 1100 case 29: 1101 ret += tcrypt_test("tgr128"); 1102 break; 1103 1104 case 30: 1105 ret += tcrypt_test("ecb(xeta)"); 1106 break; 1107 1108 case 31: 1109 ret += tcrypt_test("pcbc(fcrypt)"); 1110 break; 1111 1112 case 32: 1113 ret += tcrypt_test("ecb(camellia)"); 1114 ret += tcrypt_test("cbc(camellia)"); 1115 break; 1116 case 33: 1117 ret += tcrypt_test("sha224"); 1118 break; 1119 1120 case 34: 1121 ret += tcrypt_test("salsa20"); 1122 break; 1123 1124 case 35: 1125 ret += tcrypt_test("gcm(aes)"); 1126 break; 1127 1128 case 36: 1129 ret += tcrypt_test("lzo"); 1130 break; 1131 1132 case 37: 1133 ret += tcrypt_test("ccm(aes)"); 1134 break; 1135 1136 case 38: 1137 ret += tcrypt_test("cts(cbc(aes))"); 1138 break; 1139 1140 case 39: 1141 ret += tcrypt_test("rmd128"); 1142 break; 1143 1144 case 40: 1145 ret += tcrypt_test("rmd160"); 1146 break; 1147 1148 case 41: 1149 ret += tcrypt_test("rmd256"); 1150 break; 1151 1152 case 42: 1153 ret += tcrypt_test("rmd320"); 1154 break; 1155 1156 case 43: 1157 ret += tcrypt_test("ecb(seed)"); 1158 break; 1159 1160 case 44: 1161 ret += tcrypt_test("zlib"); 1162 break; 1163 1164 case 45: 1165 ret += tcrypt_test("rfc4309(ccm(aes))"); 1166 break; 1167 1168 case 100: 1169 ret += tcrypt_test("hmac(md5)"); 1170 break; 1171 1172 case 101: 1173 ret += tcrypt_test("hmac(sha1)"); 1174 break; 1175 1176 case 102: 1177 ret += tcrypt_test("hmac(sha256)"); 1178 break; 1179 1180 case 103: 1181 ret += tcrypt_test("hmac(sha384)"); 1182 break; 1183 1184 case 104: 1185 ret += tcrypt_test("hmac(sha512)"); 1186 break; 1187 1188 case 105: 1189 ret += tcrypt_test("hmac(sha224)"); 1190 break; 1191 1192 case 106: 1193 ret += tcrypt_test("xcbc(aes)"); 1194 break; 1195 1196 case 107: 1197 ret += tcrypt_test("hmac(rmd128)"); 1198 break; 1199 1200 case 108: 1201 ret += tcrypt_test("hmac(rmd160)"); 1202 break; 1203 1204 case 109: 1205 ret += tcrypt_test("vmac(aes)"); 1206 break; 1207 case 110: 1208 ret += tcrypt_test("hmac(crc32)"); 1209 break; 1210 1211 case 150: 1212 ret += tcrypt_test("ansi_cprng"); 1213 break; 1214 1215 case 151: 1216 ret += tcrypt_test("rfc4106(gcm(aes))"); 1217 break; 1218 1219 case 200: 1220 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0, 1221 speed_template_16_24_32); 1222 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0, 1223 speed_template_16_24_32); 1224 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0, 1225 speed_template_16_24_32); 1226 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0, 1227 speed_template_16_24_32); 1228 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0, 1229 speed_template_32_40_48); 1230 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0, 1231 speed_template_32_40_48); 1232 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0, 1233 speed_template_32_48_64); 1234 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0, 1235 speed_template_32_48_64); 1236 test_cipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0, 1237 speed_template_16_24_32); 1238 test_cipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0, 1239 speed_template_16_24_32); 1240 break; 1241 1242 case 201: 1243 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec, 1244 des3_speed_template, DES3_SPEED_VECTORS, 1245 speed_template_24); 1246 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec, 1247 des3_speed_template, DES3_SPEED_VECTORS, 1248 speed_template_24); 1249 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec, 1250 des3_speed_template, DES3_SPEED_VECTORS, 1251 speed_template_24); 1252 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec, 1253 des3_speed_template, DES3_SPEED_VECTORS, 1254 speed_template_24); 1255 break; 1256 1257 case 202: 1258 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0, 1259 speed_template_16_24_32); 1260 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0, 1261 speed_template_16_24_32); 1262 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0, 1263 speed_template_16_24_32); 1264 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0, 1265 speed_template_16_24_32); 1266 test_cipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0, 1267 speed_template_16_24_32); 1268 test_cipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0, 1269 speed_template_16_24_32); 1270 test_cipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0, 1271 speed_template_32_40_48); 1272 test_cipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0, 1273 speed_template_32_40_48); 1274 test_cipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0, 1275 speed_template_32_48_64); 1276 test_cipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0, 1277 speed_template_32_48_64); 1278 break; 1279 1280 case 203: 1281 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0, 1282 speed_template_8_32); 1283 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0, 1284 speed_template_8_32); 1285 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0, 1286 speed_template_8_32); 1287 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0, 1288 speed_template_8_32); 1289 test_cipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0, 1290 speed_template_8_32); 1291 test_cipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0, 1292 speed_template_8_32); 1293 break; 1294 1295 case 204: 1296 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0, 1297 speed_template_8); 1298 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0, 1299 speed_template_8); 1300 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0, 1301 speed_template_8); 1302 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0, 1303 speed_template_8); 1304 break; 1305 1306 case 205: 1307 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0, 1308 speed_template_16_24_32); 1309 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0, 1310 speed_template_16_24_32); 1311 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0, 1312 speed_template_16_24_32); 1313 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0, 1314 speed_template_16_24_32); 1315 test_cipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0, 1316 speed_template_16_24_32); 1317 test_cipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0, 1318 speed_template_16_24_32); 1319 test_cipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0, 1320 speed_template_32_40_48); 1321 test_cipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0, 1322 speed_template_32_40_48); 1323 test_cipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0, 1324 speed_template_32_48_64); 1325 test_cipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0, 1326 speed_template_32_48_64); 1327 break; 1328 1329 case 206: 1330 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0, 1331 speed_template_16_32); 1332 break; 1333 1334 case 207: 1335 test_cipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0, 1336 speed_template_16_32); 1337 test_cipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0, 1338 speed_template_16_32); 1339 test_cipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0, 1340 speed_template_16_32); 1341 test_cipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0, 1342 speed_template_16_32); 1343 test_cipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0, 1344 speed_template_16_32); 1345 test_cipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0, 1346 speed_template_16_32); 1347 test_cipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0, 1348 speed_template_32_48); 1349 test_cipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0, 1350 speed_template_32_48); 1351 test_cipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0, 1352 speed_template_32_64); 1353 test_cipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0, 1354 speed_template_32_64); 1355 break; 1356 1357 case 208: 1358 test_cipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0, 1359 speed_template_8); 1360 break; 1361 1362 case 300: 1363 /* fall through */ 1364 1365 case 301: 1366 test_hash_speed("md4", sec, generic_hash_speed_template); 1367 if (mode > 300 && mode < 400) break; 1368 1369 case 302: 1370 test_hash_speed("md5", sec, generic_hash_speed_template); 1371 if (mode > 300 && mode < 400) break; 1372 1373 case 303: 1374 test_hash_speed("sha1", sec, generic_hash_speed_template); 1375 if (mode > 300 && mode < 400) break; 1376 1377 case 304: 1378 test_hash_speed("sha256", sec, generic_hash_speed_template); 1379 if (mode > 300 && mode < 400) break; 1380 1381 case 305: 1382 test_hash_speed("sha384", sec, generic_hash_speed_template); 1383 if (mode > 300 && mode < 400) break; 1384 1385 case 306: 1386 test_hash_speed("sha512", sec, generic_hash_speed_template); 1387 if (mode > 300 && mode < 400) break; 1388 1389 case 307: 1390 test_hash_speed("wp256", sec, generic_hash_speed_template); 1391 if (mode > 300 && mode < 400) break; 1392 1393 case 308: 1394 test_hash_speed("wp384", sec, generic_hash_speed_template); 1395 if (mode > 300 && mode < 400) break; 1396 1397 case 309: 1398 test_hash_speed("wp512", sec, generic_hash_speed_template); 1399 if (mode > 300 && mode < 400) break; 1400 1401 case 310: 1402 test_hash_speed("tgr128", sec, generic_hash_speed_template); 1403 if (mode > 300 && mode < 400) break; 1404 1405 case 311: 1406 test_hash_speed("tgr160", sec, generic_hash_speed_template); 1407 if (mode > 300 && mode < 400) break; 1408 1409 case 312: 1410 test_hash_speed("tgr192", sec, generic_hash_speed_template); 1411 if (mode > 300 && mode < 400) break; 1412 1413 case 313: 1414 test_hash_speed("sha224", sec, generic_hash_speed_template); 1415 if (mode > 300 && mode < 400) break; 1416 1417 case 314: 1418 test_hash_speed("rmd128", sec, generic_hash_speed_template); 1419 if (mode > 300 && mode < 400) break; 1420 1421 case 315: 1422 test_hash_speed("rmd160", sec, generic_hash_speed_template); 1423 if (mode > 300 && mode < 400) break; 1424 1425 case 316: 1426 test_hash_speed("rmd256", sec, generic_hash_speed_template); 1427 if (mode > 300 && mode < 400) break; 1428 1429 case 317: 1430 test_hash_speed("rmd320", sec, generic_hash_speed_template); 1431 if (mode > 300 && mode < 400) break; 1432 1433 case 318: 1434 test_hash_speed("ghash-generic", sec, hash_speed_template_16); 1435 if (mode > 300 && mode < 400) break; 1436 1437 case 399: 1438 break; 1439 1440 case 400: 1441 /* fall through */ 1442 1443 case 401: 1444 test_ahash_speed("md4", sec, generic_hash_speed_template); 1445 if (mode > 400 && mode < 500) break; 1446 1447 case 402: 1448 test_ahash_speed("md5", sec, generic_hash_speed_template); 1449 if (mode > 400 && mode < 500) break; 1450 1451 case 403: 1452 test_ahash_speed("sha1", sec, generic_hash_speed_template); 1453 if (mode > 400 && mode < 500) break; 1454 1455 case 404: 1456 test_ahash_speed("sha256", sec, generic_hash_speed_template); 1457 if (mode > 400 && mode < 500) break; 1458 1459 case 405: 1460 test_ahash_speed("sha384", sec, generic_hash_speed_template); 1461 if (mode > 400 && mode < 500) break; 1462 1463 case 406: 1464 test_ahash_speed("sha512", sec, generic_hash_speed_template); 1465 if (mode > 400 && mode < 500) break; 1466 1467 case 407: 1468 test_ahash_speed("wp256", sec, generic_hash_speed_template); 1469 if (mode > 400 && mode < 500) break; 1470 1471 case 408: 1472 test_ahash_speed("wp384", sec, generic_hash_speed_template); 1473 if (mode > 400 && mode < 500) break; 1474 1475 case 409: 1476 test_ahash_speed("wp512", sec, generic_hash_speed_template); 1477 if (mode > 400 && mode < 500) break; 1478 1479 case 410: 1480 test_ahash_speed("tgr128", sec, generic_hash_speed_template); 1481 if (mode > 400 && mode < 500) break; 1482 1483 case 411: 1484 test_ahash_speed("tgr160", sec, generic_hash_speed_template); 1485 if (mode > 400 && mode < 500) break; 1486 1487 case 412: 1488 test_ahash_speed("tgr192", sec, generic_hash_speed_template); 1489 if (mode > 400 && mode < 500) break; 1490 1491 case 413: 1492 test_ahash_speed("sha224", sec, generic_hash_speed_template); 1493 if (mode > 400 && mode < 500) break; 1494 1495 case 414: 1496 test_ahash_speed("rmd128", sec, generic_hash_speed_template); 1497 if (mode > 400 && mode < 500) break; 1498 1499 case 415: 1500 test_ahash_speed("rmd160", sec, generic_hash_speed_template); 1501 if (mode > 400 && mode < 500) break; 1502 1503 case 416: 1504 test_ahash_speed("rmd256", sec, generic_hash_speed_template); 1505 if (mode > 400 && mode < 500) break; 1506 1507 case 417: 1508 test_ahash_speed("rmd320", sec, generic_hash_speed_template); 1509 if (mode > 400 && mode < 500) break; 1510 1511 case 499: 1512 break; 1513 1514 case 500: 1515 test_acipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0, 1516 speed_template_16_24_32); 1517 test_acipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0, 1518 speed_template_16_24_32); 1519 test_acipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0, 1520 speed_template_16_24_32); 1521 test_acipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0, 1522 speed_template_16_24_32); 1523 test_acipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0, 1524 speed_template_32_40_48); 1525 test_acipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0, 1526 speed_template_32_40_48); 1527 test_acipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0, 1528 speed_template_32_48_64); 1529 test_acipher_speed("xts(aes)", DECRYPT, sec, NULL, 0, 1530 speed_template_32_48_64); 1531 test_acipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0, 1532 speed_template_16_24_32); 1533 test_acipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0, 1534 speed_template_16_24_32); 1535 test_acipher_speed("cfb(aes)", ENCRYPT, sec, NULL, 0, 1536 speed_template_16_24_32); 1537 test_acipher_speed("cfb(aes)", DECRYPT, sec, NULL, 0, 1538 speed_template_16_24_32); 1539 test_acipher_speed("ofb(aes)", ENCRYPT, sec, NULL, 0, 1540 speed_template_16_24_32); 1541 test_acipher_speed("ofb(aes)", DECRYPT, sec, NULL, 0, 1542 speed_template_16_24_32); 1543 break; 1544 1545 case 501: 1546 test_acipher_speed("ecb(des3_ede)", ENCRYPT, sec, 1547 des3_speed_template, DES3_SPEED_VECTORS, 1548 speed_template_24); 1549 test_acipher_speed("ecb(des3_ede)", DECRYPT, sec, 1550 des3_speed_template, DES3_SPEED_VECTORS, 1551 speed_template_24); 1552 test_acipher_speed("cbc(des3_ede)", ENCRYPT, sec, 1553 des3_speed_template, DES3_SPEED_VECTORS, 1554 speed_template_24); 1555 test_acipher_speed("cbc(des3_ede)", DECRYPT, sec, 1556 des3_speed_template, DES3_SPEED_VECTORS, 1557 speed_template_24); 1558 test_acipher_speed("cfb(des3_ede)", ENCRYPT, sec, 1559 des3_speed_template, DES3_SPEED_VECTORS, 1560 speed_template_24); 1561 test_acipher_speed("cfb(des3_ede)", DECRYPT, sec, 1562 des3_speed_template, DES3_SPEED_VECTORS, 1563 speed_template_24); 1564 test_acipher_speed("ofb(des3_ede)", ENCRYPT, sec, 1565 des3_speed_template, DES3_SPEED_VECTORS, 1566 speed_template_24); 1567 test_acipher_speed("ofb(des3_ede)", DECRYPT, sec, 1568 des3_speed_template, DES3_SPEED_VECTORS, 1569 speed_template_24); 1570 break; 1571 1572 case 502: 1573 test_acipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0, 1574 speed_template_8); 1575 test_acipher_speed("ecb(des)", DECRYPT, sec, NULL, 0, 1576 speed_template_8); 1577 test_acipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0, 1578 speed_template_8); 1579 test_acipher_speed("cbc(des)", DECRYPT, sec, NULL, 0, 1580 speed_template_8); 1581 test_acipher_speed("cfb(des)", ENCRYPT, sec, NULL, 0, 1582 speed_template_8); 1583 test_acipher_speed("cfb(des)", DECRYPT, sec, NULL, 0, 1584 speed_template_8); 1585 test_acipher_speed("ofb(des)", ENCRYPT, sec, NULL, 0, 1586 speed_template_8); 1587 test_acipher_speed("ofb(des)", DECRYPT, sec, NULL, 0, 1588 speed_template_8); 1589 break; 1590 1591 case 503: 1592 test_acipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0, 1593 speed_template_16_32); 1594 test_acipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0, 1595 speed_template_16_32); 1596 test_acipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0, 1597 speed_template_16_32); 1598 test_acipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0, 1599 speed_template_16_32); 1600 test_acipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0, 1601 speed_template_16_32); 1602 test_acipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0, 1603 speed_template_16_32); 1604 test_acipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0, 1605 speed_template_32_48); 1606 test_acipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0, 1607 speed_template_32_48); 1608 test_acipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0, 1609 speed_template_32_64); 1610 test_acipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0, 1611 speed_template_32_64); 1612 break; 1613 1614 case 504: 1615 test_acipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0, 1616 speed_template_16_24_32); 1617 test_acipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0, 1618 speed_template_16_24_32); 1619 test_acipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0, 1620 speed_template_16_24_32); 1621 test_acipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0, 1622 speed_template_16_24_32); 1623 test_acipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0, 1624 speed_template_16_24_32); 1625 test_acipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0, 1626 speed_template_16_24_32); 1627 test_acipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0, 1628 speed_template_32_40_48); 1629 test_acipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0, 1630 speed_template_32_40_48); 1631 test_acipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0, 1632 speed_template_32_48_64); 1633 test_acipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0, 1634 speed_template_32_48_64); 1635 break; 1636 1637 case 505: 1638 test_acipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0, 1639 speed_template_8); 1640 break; 1641 1642 case 1000: 1643 test_available(); 1644 break; 1645 } 1646 1647 return ret; 1648 } 1649 1650 static int do_alg_test(const char *alg, u32 type, u32 mask) 1651 { 1652 return crypto_has_alg(alg, type, mask ?: CRYPTO_ALG_TYPE_MASK) ? 1653 0 : -ENOENT; 1654 } 1655 1656 static int __init tcrypt_mod_init(void) 1657 { 1658 int err = -ENOMEM; 1659 int i; 1660 1661 for (i = 0; i < TVMEMSIZE; i++) { 1662 tvmem[i] = (void *)__get_free_page(GFP_KERNEL); 1663 if (!tvmem[i]) 1664 goto err_free_tv; 1665 } 1666 1667 if (alg) 1668 err = do_alg_test(alg, type, mask); 1669 else 1670 err = do_test(mode); 1671 1672 if (err) { 1673 printk(KERN_ERR "tcrypt: one or more tests failed!\n"); 1674 goto err_free_tv; 1675 } 1676 1677 /* We intentionaly return -EAGAIN to prevent keeping the module, 1678 * unless we're running in fips mode. It does all its work from 1679 * init() and doesn't offer any runtime functionality, but in 1680 * the fips case, checking for a successful load is helpful. 1681 * => we don't need it in the memory, do we? 1682 * -- mludvig 1683 */ 1684 if (!fips_enabled) 1685 err = -EAGAIN; 1686 1687 err_free_tv: 1688 for (i = 0; i < TVMEMSIZE && tvmem[i]; i++) 1689 free_page((unsigned long)tvmem[i]); 1690 1691 return err; 1692 } 1693 1694 /* 1695 * If an init function is provided, an exit function must also be provided 1696 * to allow module unload. 1697 */ 1698 static void __exit tcrypt_mod_fini(void) { } 1699 1700 module_init(tcrypt_mod_init); 1701 module_exit(tcrypt_mod_fini); 1702 1703 module_param(alg, charp, 0); 1704 module_param(type, uint, 0); 1705 module_param(mask, uint, 0); 1706 module_param(mode, int, 0); 1707 module_param(sec, uint, 0); 1708 MODULE_PARM_DESC(sec, "Length in seconds of speed tests " 1709 "(defaults to zero which uses CPU cycles instead)"); 1710 1711 MODULE_LICENSE("GPL"); 1712 MODULE_DESCRIPTION("Quick & dirty crypto testing module"); 1713 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>"); 1714