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