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