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