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 + 1); 262 np--; 263 for (k = 0; k < np; k++) 264 sg_set_buf(&sg[k + 1], xbuf[k], PAGE_SIZE); 265 266 sg_set_buf(&sg[k + 1], 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 *sgout; 281 const char *e; 282 void *assoc; 283 char *iv; 284 char *xbuf[XBUFSIZE]; 285 char *xoutbuf[XBUFSIZE]; 286 char *axbuf[XBUFSIZE]; 287 unsigned int *b_size; 288 unsigned int iv_len; 289 290 iv = kzalloc(MAX_IVLEN, GFP_KERNEL); 291 if (!iv) 292 return; 293 294 if (aad_size >= PAGE_SIZE) { 295 pr_err("associate data length (%u) too big\n", aad_size); 296 goto out_noxbuf; 297 } 298 299 if (enc == ENCRYPT) 300 e = "encryption"; 301 else 302 e = "decryption"; 303 304 if (testmgr_alloc_buf(xbuf)) 305 goto out_noxbuf; 306 if (testmgr_alloc_buf(axbuf)) 307 goto out_noaxbuf; 308 if (testmgr_alloc_buf(xoutbuf)) 309 goto out_nooutbuf; 310 311 sg = kmalloc(sizeof(*sg) * 9 * 2, GFP_KERNEL); 312 if (!sg) 313 goto out_nosg; 314 sgout = &sg[9]; 315 316 tfm = crypto_alloc_aead(algo, 0, 0); 317 318 if (IS_ERR(tfm)) { 319 pr_err("alg: aead: Failed to load transform for %s: %ld\n", algo, 320 PTR_ERR(tfm)); 321 goto out_notfm; 322 } 323 324 printk(KERN_INFO "\ntesting speed of %s (%s) %s\n", algo, 325 get_driver_name(crypto_aead, tfm), e); 326 327 req = aead_request_alloc(tfm, GFP_KERNEL); 328 if (!req) { 329 pr_err("alg: aead: Failed to allocate request for %s\n", 330 algo); 331 goto out_noreq; 332 } 333 334 i = 0; 335 do { 336 b_size = aead_sizes; 337 do { 338 assoc = axbuf[0]; 339 memset(assoc, 0xff, aad_size); 340 341 if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) { 342 pr_err("template (%u) too big for tvmem (%lu)\n", 343 *keysize + *b_size, 344 TVMEMSIZE * PAGE_SIZE); 345 goto out; 346 } 347 348 key = tvmem[0]; 349 for (j = 0; j < tcount; j++) { 350 if (template[j].klen == *keysize) { 351 key = template[j].key; 352 break; 353 } 354 } 355 ret = crypto_aead_setkey(tfm, key, *keysize); 356 ret = crypto_aead_setauthsize(tfm, authsize); 357 358 iv_len = crypto_aead_ivsize(tfm); 359 if (iv_len) 360 memset(iv, 0xff, iv_len); 361 362 crypto_aead_clear_flags(tfm, ~0); 363 printk(KERN_INFO "test %u (%d bit key, %d byte blocks): ", 364 i, *keysize * 8, *b_size); 365 366 367 memset(tvmem[0], 0xff, PAGE_SIZE); 368 369 if (ret) { 370 pr_err("setkey() failed flags=%x\n", 371 crypto_aead_get_flags(tfm)); 372 goto out; 373 } 374 375 sg_init_aead(sg, xbuf, 376 *b_size + (enc ? authsize : 0)); 377 378 sg_init_aead(sgout, xoutbuf, 379 *b_size + (enc ? authsize : 0)); 380 381 sg_set_buf(&sg[0], assoc, aad_size); 382 sg_set_buf(&sgout[0], assoc, aad_size); 383 384 aead_request_set_crypt(req, sg, sgout, *b_size, iv); 385 aead_request_set_ad(req, 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 212: 1766 test_aead_speed("rfc4309(ccm(aes))", ENCRYPT, sec, 1767 NULL, 0, 16, 8, aead_speed_template_19); 1768 break; 1769 1770 case 300: 1771 if (alg) { 1772 test_hash_speed(alg, sec, generic_hash_speed_template); 1773 break; 1774 } 1775 1776 /* fall through */ 1777 1778 case 301: 1779 test_hash_speed("md4", sec, generic_hash_speed_template); 1780 if (mode > 300 && mode < 400) break; 1781 1782 case 302: 1783 test_hash_speed("md5", sec, generic_hash_speed_template); 1784 if (mode > 300 && mode < 400) break; 1785 1786 case 303: 1787 test_hash_speed("sha1", sec, generic_hash_speed_template); 1788 if (mode > 300 && mode < 400) break; 1789 1790 case 304: 1791 test_hash_speed("sha256", sec, generic_hash_speed_template); 1792 if (mode > 300 && mode < 400) break; 1793 1794 case 305: 1795 test_hash_speed("sha384", sec, generic_hash_speed_template); 1796 if (mode > 300 && mode < 400) break; 1797 1798 case 306: 1799 test_hash_speed("sha512", sec, generic_hash_speed_template); 1800 if (mode > 300 && mode < 400) break; 1801 1802 case 307: 1803 test_hash_speed("wp256", sec, generic_hash_speed_template); 1804 if (mode > 300 && mode < 400) break; 1805 1806 case 308: 1807 test_hash_speed("wp384", sec, generic_hash_speed_template); 1808 if (mode > 300 && mode < 400) break; 1809 1810 case 309: 1811 test_hash_speed("wp512", sec, generic_hash_speed_template); 1812 if (mode > 300 && mode < 400) break; 1813 1814 case 310: 1815 test_hash_speed("tgr128", sec, generic_hash_speed_template); 1816 if (mode > 300 && mode < 400) break; 1817 1818 case 311: 1819 test_hash_speed("tgr160", sec, generic_hash_speed_template); 1820 if (mode > 300 && mode < 400) break; 1821 1822 case 312: 1823 test_hash_speed("tgr192", sec, generic_hash_speed_template); 1824 if (mode > 300 && mode < 400) break; 1825 1826 case 313: 1827 test_hash_speed("sha224", sec, generic_hash_speed_template); 1828 if (mode > 300 && mode < 400) break; 1829 1830 case 314: 1831 test_hash_speed("rmd128", sec, generic_hash_speed_template); 1832 if (mode > 300 && mode < 400) break; 1833 1834 case 315: 1835 test_hash_speed("rmd160", sec, generic_hash_speed_template); 1836 if (mode > 300 && mode < 400) break; 1837 1838 case 316: 1839 test_hash_speed("rmd256", sec, generic_hash_speed_template); 1840 if (mode > 300 && mode < 400) break; 1841 1842 case 317: 1843 test_hash_speed("rmd320", sec, generic_hash_speed_template); 1844 if (mode > 300 && mode < 400) break; 1845 1846 case 318: 1847 test_hash_speed("ghash-generic", sec, hash_speed_template_16); 1848 if (mode > 300 && mode < 400) break; 1849 1850 case 319: 1851 test_hash_speed("crc32c", sec, generic_hash_speed_template); 1852 if (mode > 300 && mode < 400) break; 1853 1854 case 320: 1855 test_hash_speed("crct10dif", sec, generic_hash_speed_template); 1856 if (mode > 300 && mode < 400) break; 1857 1858 case 399: 1859 break; 1860 1861 case 400: 1862 if (alg) { 1863 test_ahash_speed(alg, sec, generic_hash_speed_template); 1864 break; 1865 } 1866 1867 /* fall through */ 1868 1869 case 401: 1870 test_ahash_speed("md4", sec, generic_hash_speed_template); 1871 if (mode > 400 && mode < 500) break; 1872 1873 case 402: 1874 test_ahash_speed("md5", sec, generic_hash_speed_template); 1875 if (mode > 400 && mode < 500) break; 1876 1877 case 403: 1878 test_ahash_speed("sha1", sec, generic_hash_speed_template); 1879 if (mode > 400 && mode < 500) break; 1880 1881 case 404: 1882 test_ahash_speed("sha256", sec, generic_hash_speed_template); 1883 if (mode > 400 && mode < 500) break; 1884 1885 case 405: 1886 test_ahash_speed("sha384", sec, generic_hash_speed_template); 1887 if (mode > 400 && mode < 500) break; 1888 1889 case 406: 1890 test_ahash_speed("sha512", sec, generic_hash_speed_template); 1891 if (mode > 400 && mode < 500) break; 1892 1893 case 407: 1894 test_ahash_speed("wp256", sec, generic_hash_speed_template); 1895 if (mode > 400 && mode < 500) break; 1896 1897 case 408: 1898 test_ahash_speed("wp384", sec, generic_hash_speed_template); 1899 if (mode > 400 && mode < 500) break; 1900 1901 case 409: 1902 test_ahash_speed("wp512", sec, generic_hash_speed_template); 1903 if (mode > 400 && mode < 500) break; 1904 1905 case 410: 1906 test_ahash_speed("tgr128", sec, generic_hash_speed_template); 1907 if (mode > 400 && mode < 500) break; 1908 1909 case 411: 1910 test_ahash_speed("tgr160", sec, generic_hash_speed_template); 1911 if (mode > 400 && mode < 500) break; 1912 1913 case 412: 1914 test_ahash_speed("tgr192", sec, generic_hash_speed_template); 1915 if (mode > 400 && mode < 500) break; 1916 1917 case 413: 1918 test_ahash_speed("sha224", sec, generic_hash_speed_template); 1919 if (mode > 400 && mode < 500) break; 1920 1921 case 414: 1922 test_ahash_speed("rmd128", sec, generic_hash_speed_template); 1923 if (mode > 400 && mode < 500) break; 1924 1925 case 415: 1926 test_ahash_speed("rmd160", sec, generic_hash_speed_template); 1927 if (mode > 400 && mode < 500) break; 1928 1929 case 416: 1930 test_ahash_speed("rmd256", sec, generic_hash_speed_template); 1931 if (mode > 400 && mode < 500) break; 1932 1933 case 417: 1934 test_ahash_speed("rmd320", sec, generic_hash_speed_template); 1935 if (mode > 400 && mode < 500) break; 1936 1937 case 499: 1938 break; 1939 1940 case 500: 1941 test_acipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0, 1942 speed_template_16_24_32); 1943 test_acipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0, 1944 speed_template_16_24_32); 1945 test_acipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0, 1946 speed_template_16_24_32); 1947 test_acipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0, 1948 speed_template_16_24_32); 1949 test_acipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0, 1950 speed_template_32_40_48); 1951 test_acipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0, 1952 speed_template_32_40_48); 1953 test_acipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0, 1954 speed_template_32_48_64); 1955 test_acipher_speed("xts(aes)", DECRYPT, sec, NULL, 0, 1956 speed_template_32_48_64); 1957 test_acipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0, 1958 speed_template_16_24_32); 1959 test_acipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0, 1960 speed_template_16_24_32); 1961 test_acipher_speed("cfb(aes)", ENCRYPT, sec, NULL, 0, 1962 speed_template_16_24_32); 1963 test_acipher_speed("cfb(aes)", DECRYPT, sec, NULL, 0, 1964 speed_template_16_24_32); 1965 test_acipher_speed("ofb(aes)", ENCRYPT, sec, NULL, 0, 1966 speed_template_16_24_32); 1967 test_acipher_speed("ofb(aes)", DECRYPT, sec, NULL, 0, 1968 speed_template_16_24_32); 1969 test_acipher_speed("rfc3686(ctr(aes))", ENCRYPT, sec, NULL, 0, 1970 speed_template_20_28_36); 1971 test_acipher_speed("rfc3686(ctr(aes))", DECRYPT, sec, NULL, 0, 1972 speed_template_20_28_36); 1973 break; 1974 1975 case 501: 1976 test_acipher_speed("ecb(des3_ede)", ENCRYPT, sec, 1977 des3_speed_template, DES3_SPEED_VECTORS, 1978 speed_template_24); 1979 test_acipher_speed("ecb(des3_ede)", DECRYPT, sec, 1980 des3_speed_template, DES3_SPEED_VECTORS, 1981 speed_template_24); 1982 test_acipher_speed("cbc(des3_ede)", ENCRYPT, sec, 1983 des3_speed_template, DES3_SPEED_VECTORS, 1984 speed_template_24); 1985 test_acipher_speed("cbc(des3_ede)", DECRYPT, sec, 1986 des3_speed_template, DES3_SPEED_VECTORS, 1987 speed_template_24); 1988 test_acipher_speed("cfb(des3_ede)", ENCRYPT, sec, 1989 des3_speed_template, DES3_SPEED_VECTORS, 1990 speed_template_24); 1991 test_acipher_speed("cfb(des3_ede)", DECRYPT, sec, 1992 des3_speed_template, DES3_SPEED_VECTORS, 1993 speed_template_24); 1994 test_acipher_speed("ofb(des3_ede)", ENCRYPT, sec, 1995 des3_speed_template, DES3_SPEED_VECTORS, 1996 speed_template_24); 1997 test_acipher_speed("ofb(des3_ede)", DECRYPT, sec, 1998 des3_speed_template, DES3_SPEED_VECTORS, 1999 speed_template_24); 2000 break; 2001 2002 case 502: 2003 test_acipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0, 2004 speed_template_8); 2005 test_acipher_speed("ecb(des)", DECRYPT, sec, NULL, 0, 2006 speed_template_8); 2007 test_acipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0, 2008 speed_template_8); 2009 test_acipher_speed("cbc(des)", DECRYPT, sec, NULL, 0, 2010 speed_template_8); 2011 test_acipher_speed("cfb(des)", ENCRYPT, sec, NULL, 0, 2012 speed_template_8); 2013 test_acipher_speed("cfb(des)", DECRYPT, sec, NULL, 0, 2014 speed_template_8); 2015 test_acipher_speed("ofb(des)", ENCRYPT, sec, NULL, 0, 2016 speed_template_8); 2017 test_acipher_speed("ofb(des)", DECRYPT, sec, NULL, 0, 2018 speed_template_8); 2019 break; 2020 2021 case 503: 2022 test_acipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0, 2023 speed_template_16_32); 2024 test_acipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0, 2025 speed_template_16_32); 2026 test_acipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0, 2027 speed_template_16_32); 2028 test_acipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0, 2029 speed_template_16_32); 2030 test_acipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0, 2031 speed_template_16_32); 2032 test_acipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0, 2033 speed_template_16_32); 2034 test_acipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0, 2035 speed_template_32_48); 2036 test_acipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0, 2037 speed_template_32_48); 2038 test_acipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0, 2039 speed_template_32_64); 2040 test_acipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0, 2041 speed_template_32_64); 2042 break; 2043 2044 case 504: 2045 test_acipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0, 2046 speed_template_16_24_32); 2047 test_acipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0, 2048 speed_template_16_24_32); 2049 test_acipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0, 2050 speed_template_16_24_32); 2051 test_acipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0, 2052 speed_template_16_24_32); 2053 test_acipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0, 2054 speed_template_16_24_32); 2055 test_acipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0, 2056 speed_template_16_24_32); 2057 test_acipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0, 2058 speed_template_32_40_48); 2059 test_acipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0, 2060 speed_template_32_40_48); 2061 test_acipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0, 2062 speed_template_32_48_64); 2063 test_acipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0, 2064 speed_template_32_48_64); 2065 break; 2066 2067 case 505: 2068 test_acipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0, 2069 speed_template_8); 2070 break; 2071 2072 case 506: 2073 test_acipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0, 2074 speed_template_8_16); 2075 test_acipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0, 2076 speed_template_8_16); 2077 test_acipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0, 2078 speed_template_8_16); 2079 test_acipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0, 2080 speed_template_8_16); 2081 test_acipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0, 2082 speed_template_8_16); 2083 test_acipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0, 2084 speed_template_8_16); 2085 break; 2086 2087 case 507: 2088 test_acipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0, 2089 speed_template_16_32); 2090 test_acipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0, 2091 speed_template_16_32); 2092 test_acipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0, 2093 speed_template_16_32); 2094 test_acipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0, 2095 speed_template_16_32); 2096 test_acipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0, 2097 speed_template_16_32); 2098 test_acipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0, 2099 speed_template_16_32); 2100 test_acipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0, 2101 speed_template_32_48); 2102 test_acipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0, 2103 speed_template_32_48); 2104 test_acipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0, 2105 speed_template_32_64); 2106 test_acipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0, 2107 speed_template_32_64); 2108 break; 2109 2110 case 508: 2111 test_acipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0, 2112 speed_template_16_32); 2113 test_acipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0, 2114 speed_template_16_32); 2115 test_acipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0, 2116 speed_template_16_32); 2117 test_acipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0, 2118 speed_template_16_32); 2119 test_acipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0, 2120 speed_template_16_32); 2121 test_acipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0, 2122 speed_template_16_32); 2123 test_acipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0, 2124 speed_template_32_48); 2125 test_acipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0, 2126 speed_template_32_48); 2127 test_acipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0, 2128 speed_template_32_64); 2129 test_acipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0, 2130 speed_template_32_64); 2131 break; 2132 2133 case 509: 2134 test_acipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0, 2135 speed_template_8_32); 2136 test_acipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0, 2137 speed_template_8_32); 2138 test_acipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0, 2139 speed_template_8_32); 2140 test_acipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0, 2141 speed_template_8_32); 2142 test_acipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0, 2143 speed_template_8_32); 2144 test_acipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0, 2145 speed_template_8_32); 2146 break; 2147 2148 case 1000: 2149 test_available(); 2150 break; 2151 } 2152 2153 return ret; 2154 } 2155 2156 static int __init tcrypt_mod_init(void) 2157 { 2158 int err = -ENOMEM; 2159 int i; 2160 2161 for (i = 0; i < TVMEMSIZE; i++) { 2162 tvmem[i] = (void *)__get_free_page(GFP_KERNEL); 2163 if (!tvmem[i]) 2164 goto err_free_tv; 2165 } 2166 2167 err = do_test(alg, type, mask, mode); 2168 2169 if (err) { 2170 printk(KERN_ERR "tcrypt: one or more tests failed!\n"); 2171 goto err_free_tv; 2172 } 2173 2174 /* We intentionaly return -EAGAIN to prevent keeping the module, 2175 * unless we're running in fips mode. It does all its work from 2176 * init() and doesn't offer any runtime functionality, but in 2177 * the fips case, checking for a successful load is helpful. 2178 * => we don't need it in the memory, do we? 2179 * -- mludvig 2180 */ 2181 if (!fips_enabled) 2182 err = -EAGAIN; 2183 2184 err_free_tv: 2185 for (i = 0; i < TVMEMSIZE && tvmem[i]; i++) 2186 free_page((unsigned long)tvmem[i]); 2187 2188 return err; 2189 } 2190 2191 /* 2192 * If an init function is provided, an exit function must also be provided 2193 * to allow module unload. 2194 */ 2195 static void __exit tcrypt_mod_fini(void) { } 2196 2197 module_init(tcrypt_mod_init); 2198 module_exit(tcrypt_mod_fini); 2199 2200 module_param(alg, charp, 0); 2201 module_param(type, uint, 0); 2202 module_param(mask, uint, 0); 2203 module_param(mode, int, 0); 2204 module_param(sec, uint, 0); 2205 MODULE_PARM_DESC(sec, "Length in seconds of speed tests " 2206 "(defaults to zero which uses CPU cycles instead)"); 2207 2208 MODULE_LICENSE("GPL"); 2209 MODULE_DESCRIPTION("Quick & dirty crypto testing module"); 2210 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>"); 2211