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