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