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(int m) 1229 { 1230 int i; 1231 int ret = 0; 1232 1233 switch (m) { 1234 case 0: 1235 for (i = 1; i < 200; i++) 1236 ret += do_test(i); 1237 break; 1238 1239 case 1: 1240 ret += tcrypt_test("md5"); 1241 break; 1242 1243 case 2: 1244 ret += tcrypt_test("sha1"); 1245 break; 1246 1247 case 3: 1248 ret += tcrypt_test("ecb(des)"); 1249 ret += tcrypt_test("cbc(des)"); 1250 ret += tcrypt_test("ctr(des)"); 1251 break; 1252 1253 case 4: 1254 ret += tcrypt_test("ecb(des3_ede)"); 1255 ret += tcrypt_test("cbc(des3_ede)"); 1256 ret += tcrypt_test("ctr(des3_ede)"); 1257 break; 1258 1259 case 5: 1260 ret += tcrypt_test("md4"); 1261 break; 1262 1263 case 6: 1264 ret += tcrypt_test("sha256"); 1265 break; 1266 1267 case 7: 1268 ret += tcrypt_test("ecb(blowfish)"); 1269 ret += tcrypt_test("cbc(blowfish)"); 1270 ret += tcrypt_test("ctr(blowfish)"); 1271 break; 1272 1273 case 8: 1274 ret += tcrypt_test("ecb(twofish)"); 1275 ret += tcrypt_test("cbc(twofish)"); 1276 ret += tcrypt_test("ctr(twofish)"); 1277 ret += tcrypt_test("lrw(twofish)"); 1278 ret += tcrypt_test("xts(twofish)"); 1279 break; 1280 1281 case 9: 1282 ret += tcrypt_test("ecb(serpent)"); 1283 ret += tcrypt_test("cbc(serpent)"); 1284 ret += tcrypt_test("ctr(serpent)"); 1285 ret += tcrypt_test("lrw(serpent)"); 1286 ret += tcrypt_test("xts(serpent)"); 1287 break; 1288 1289 case 10: 1290 ret += tcrypt_test("ecb(aes)"); 1291 ret += tcrypt_test("cbc(aes)"); 1292 ret += tcrypt_test("lrw(aes)"); 1293 ret += tcrypt_test("xts(aes)"); 1294 ret += tcrypt_test("ctr(aes)"); 1295 ret += tcrypt_test("rfc3686(ctr(aes))"); 1296 break; 1297 1298 case 11: 1299 ret += tcrypt_test("sha384"); 1300 break; 1301 1302 case 12: 1303 ret += tcrypt_test("sha512"); 1304 break; 1305 1306 case 13: 1307 ret += tcrypt_test("deflate"); 1308 break; 1309 1310 case 14: 1311 ret += tcrypt_test("ecb(cast5)"); 1312 ret += tcrypt_test("cbc(cast5)"); 1313 ret += tcrypt_test("ctr(cast5)"); 1314 break; 1315 1316 case 15: 1317 ret += tcrypt_test("ecb(cast6)"); 1318 ret += tcrypt_test("cbc(cast6)"); 1319 ret += tcrypt_test("ctr(cast6)"); 1320 ret += tcrypt_test("lrw(cast6)"); 1321 ret += tcrypt_test("xts(cast6)"); 1322 break; 1323 1324 case 16: 1325 ret += tcrypt_test("ecb(arc4)"); 1326 break; 1327 1328 case 17: 1329 ret += tcrypt_test("michael_mic"); 1330 break; 1331 1332 case 18: 1333 ret += tcrypt_test("crc32c"); 1334 break; 1335 1336 case 19: 1337 ret += tcrypt_test("ecb(tea)"); 1338 break; 1339 1340 case 20: 1341 ret += tcrypt_test("ecb(xtea)"); 1342 break; 1343 1344 case 21: 1345 ret += tcrypt_test("ecb(khazad)"); 1346 break; 1347 1348 case 22: 1349 ret += tcrypt_test("wp512"); 1350 break; 1351 1352 case 23: 1353 ret += tcrypt_test("wp384"); 1354 break; 1355 1356 case 24: 1357 ret += tcrypt_test("wp256"); 1358 break; 1359 1360 case 25: 1361 ret += tcrypt_test("ecb(tnepres)"); 1362 break; 1363 1364 case 26: 1365 ret += tcrypt_test("ecb(anubis)"); 1366 ret += tcrypt_test("cbc(anubis)"); 1367 break; 1368 1369 case 27: 1370 ret += tcrypt_test("tgr192"); 1371 break; 1372 1373 case 28: 1374 ret += tcrypt_test("tgr160"); 1375 break; 1376 1377 case 29: 1378 ret += tcrypt_test("tgr128"); 1379 break; 1380 1381 case 30: 1382 ret += tcrypt_test("ecb(xeta)"); 1383 break; 1384 1385 case 31: 1386 ret += tcrypt_test("pcbc(fcrypt)"); 1387 break; 1388 1389 case 32: 1390 ret += tcrypt_test("ecb(camellia)"); 1391 ret += tcrypt_test("cbc(camellia)"); 1392 ret += tcrypt_test("ctr(camellia)"); 1393 ret += tcrypt_test("lrw(camellia)"); 1394 ret += tcrypt_test("xts(camellia)"); 1395 break; 1396 1397 case 33: 1398 ret += tcrypt_test("sha224"); 1399 break; 1400 1401 case 34: 1402 ret += tcrypt_test("salsa20"); 1403 break; 1404 1405 case 35: 1406 ret += tcrypt_test("gcm(aes)"); 1407 break; 1408 1409 case 36: 1410 ret += tcrypt_test("lzo"); 1411 break; 1412 1413 case 37: 1414 ret += tcrypt_test("ccm(aes)"); 1415 break; 1416 1417 case 38: 1418 ret += tcrypt_test("cts(cbc(aes))"); 1419 break; 1420 1421 case 39: 1422 ret += tcrypt_test("rmd128"); 1423 break; 1424 1425 case 40: 1426 ret += tcrypt_test("rmd160"); 1427 break; 1428 1429 case 41: 1430 ret += tcrypt_test("rmd256"); 1431 break; 1432 1433 case 42: 1434 ret += tcrypt_test("rmd320"); 1435 break; 1436 1437 case 43: 1438 ret += tcrypt_test("ecb(seed)"); 1439 break; 1440 1441 case 44: 1442 ret += tcrypt_test("zlib"); 1443 break; 1444 1445 case 45: 1446 ret += tcrypt_test("rfc4309(ccm(aes))"); 1447 break; 1448 1449 case 46: 1450 ret += tcrypt_test("ghash"); 1451 break; 1452 1453 case 47: 1454 ret += tcrypt_test("crct10dif"); 1455 break; 1456 1457 case 100: 1458 ret += tcrypt_test("hmac(md5)"); 1459 break; 1460 1461 case 101: 1462 ret += tcrypt_test("hmac(sha1)"); 1463 break; 1464 1465 case 102: 1466 ret += tcrypt_test("hmac(sha256)"); 1467 break; 1468 1469 case 103: 1470 ret += tcrypt_test("hmac(sha384)"); 1471 break; 1472 1473 case 104: 1474 ret += tcrypt_test("hmac(sha512)"); 1475 break; 1476 1477 case 105: 1478 ret += tcrypt_test("hmac(sha224)"); 1479 break; 1480 1481 case 106: 1482 ret += tcrypt_test("xcbc(aes)"); 1483 break; 1484 1485 case 107: 1486 ret += tcrypt_test("hmac(rmd128)"); 1487 break; 1488 1489 case 108: 1490 ret += tcrypt_test("hmac(rmd160)"); 1491 break; 1492 1493 case 109: 1494 ret += tcrypt_test("vmac(aes)"); 1495 break; 1496 1497 case 110: 1498 ret += tcrypt_test("hmac(crc32)"); 1499 break; 1500 1501 case 150: 1502 ret += tcrypt_test("ansi_cprng"); 1503 break; 1504 1505 case 151: 1506 ret += tcrypt_test("rfc4106(gcm(aes))"); 1507 break; 1508 1509 case 152: 1510 ret += tcrypt_test("rfc4543(gcm(aes))"); 1511 break; 1512 1513 case 153: 1514 ret += tcrypt_test("cmac(aes)"); 1515 break; 1516 1517 case 154: 1518 ret += tcrypt_test("cmac(des3_ede)"); 1519 break; 1520 1521 case 155: 1522 ret += tcrypt_test("authenc(hmac(sha1),cbc(aes))"); 1523 break; 1524 1525 case 156: 1526 ret += tcrypt_test("authenc(hmac(md5),ecb(cipher_null))"); 1527 break; 1528 1529 case 157: 1530 ret += tcrypt_test("authenc(hmac(sha1),ecb(cipher_null))"); 1531 break; 1532 case 181: 1533 ret += tcrypt_test("authenc(hmac(sha1),cbc(des))"); 1534 break; 1535 case 182: 1536 ret += tcrypt_test("authenc(hmac(sha1),cbc(des3_ede))"); 1537 break; 1538 case 183: 1539 ret += tcrypt_test("authenc(hmac(sha224),cbc(des))"); 1540 break; 1541 case 184: 1542 ret += tcrypt_test("authenc(hmac(sha224),cbc(des3_ede))"); 1543 break; 1544 case 185: 1545 ret += tcrypt_test("authenc(hmac(sha256),cbc(des))"); 1546 break; 1547 case 186: 1548 ret += tcrypt_test("authenc(hmac(sha256),cbc(des3_ede))"); 1549 break; 1550 case 187: 1551 ret += tcrypt_test("authenc(hmac(sha384),cbc(des))"); 1552 break; 1553 case 188: 1554 ret += tcrypt_test("authenc(hmac(sha384),cbc(des3_ede))"); 1555 break; 1556 case 189: 1557 ret += tcrypt_test("authenc(hmac(sha512),cbc(des))"); 1558 break; 1559 case 190: 1560 ret += tcrypt_test("authenc(hmac(sha512),cbc(des3_ede))"); 1561 break; 1562 case 200: 1563 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0, 1564 speed_template_16_24_32); 1565 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0, 1566 speed_template_16_24_32); 1567 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0, 1568 speed_template_16_24_32); 1569 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0, 1570 speed_template_16_24_32); 1571 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0, 1572 speed_template_32_40_48); 1573 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0, 1574 speed_template_32_40_48); 1575 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0, 1576 speed_template_32_48_64); 1577 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0, 1578 speed_template_32_48_64); 1579 test_cipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0, 1580 speed_template_16_24_32); 1581 test_cipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0, 1582 speed_template_16_24_32); 1583 break; 1584 1585 case 201: 1586 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec, 1587 des3_speed_template, DES3_SPEED_VECTORS, 1588 speed_template_24); 1589 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec, 1590 des3_speed_template, DES3_SPEED_VECTORS, 1591 speed_template_24); 1592 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec, 1593 des3_speed_template, DES3_SPEED_VECTORS, 1594 speed_template_24); 1595 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec, 1596 des3_speed_template, DES3_SPEED_VECTORS, 1597 speed_template_24); 1598 test_cipher_speed("ctr(des3_ede)", ENCRYPT, sec, 1599 des3_speed_template, DES3_SPEED_VECTORS, 1600 speed_template_24); 1601 test_cipher_speed("ctr(des3_ede)", DECRYPT, sec, 1602 des3_speed_template, DES3_SPEED_VECTORS, 1603 speed_template_24); 1604 break; 1605 1606 case 202: 1607 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0, 1608 speed_template_16_24_32); 1609 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0, 1610 speed_template_16_24_32); 1611 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0, 1612 speed_template_16_24_32); 1613 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0, 1614 speed_template_16_24_32); 1615 test_cipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0, 1616 speed_template_16_24_32); 1617 test_cipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0, 1618 speed_template_16_24_32); 1619 test_cipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0, 1620 speed_template_32_40_48); 1621 test_cipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0, 1622 speed_template_32_40_48); 1623 test_cipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0, 1624 speed_template_32_48_64); 1625 test_cipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0, 1626 speed_template_32_48_64); 1627 break; 1628 1629 case 203: 1630 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0, 1631 speed_template_8_32); 1632 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0, 1633 speed_template_8_32); 1634 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0, 1635 speed_template_8_32); 1636 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0, 1637 speed_template_8_32); 1638 test_cipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0, 1639 speed_template_8_32); 1640 test_cipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0, 1641 speed_template_8_32); 1642 break; 1643 1644 case 204: 1645 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0, 1646 speed_template_8); 1647 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0, 1648 speed_template_8); 1649 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0, 1650 speed_template_8); 1651 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0, 1652 speed_template_8); 1653 break; 1654 1655 case 205: 1656 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0, 1657 speed_template_16_24_32); 1658 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0, 1659 speed_template_16_24_32); 1660 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0, 1661 speed_template_16_24_32); 1662 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0, 1663 speed_template_16_24_32); 1664 test_cipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0, 1665 speed_template_16_24_32); 1666 test_cipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0, 1667 speed_template_16_24_32); 1668 test_cipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0, 1669 speed_template_32_40_48); 1670 test_cipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0, 1671 speed_template_32_40_48); 1672 test_cipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0, 1673 speed_template_32_48_64); 1674 test_cipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0, 1675 speed_template_32_48_64); 1676 break; 1677 1678 case 206: 1679 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0, 1680 speed_template_16_32); 1681 break; 1682 1683 case 207: 1684 test_cipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0, 1685 speed_template_16_32); 1686 test_cipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0, 1687 speed_template_16_32); 1688 test_cipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0, 1689 speed_template_16_32); 1690 test_cipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0, 1691 speed_template_16_32); 1692 test_cipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0, 1693 speed_template_16_32); 1694 test_cipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0, 1695 speed_template_16_32); 1696 test_cipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0, 1697 speed_template_32_48); 1698 test_cipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0, 1699 speed_template_32_48); 1700 test_cipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0, 1701 speed_template_32_64); 1702 test_cipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0, 1703 speed_template_32_64); 1704 break; 1705 1706 case 208: 1707 test_cipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0, 1708 speed_template_8); 1709 break; 1710 1711 case 209: 1712 test_cipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0, 1713 speed_template_8_16); 1714 test_cipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0, 1715 speed_template_8_16); 1716 test_cipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0, 1717 speed_template_8_16); 1718 test_cipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0, 1719 speed_template_8_16); 1720 test_cipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0, 1721 speed_template_8_16); 1722 test_cipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0, 1723 speed_template_8_16); 1724 break; 1725 1726 case 210: 1727 test_cipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0, 1728 speed_template_16_32); 1729 test_cipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0, 1730 speed_template_16_32); 1731 test_cipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0, 1732 speed_template_16_32); 1733 test_cipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0, 1734 speed_template_16_32); 1735 test_cipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0, 1736 speed_template_16_32); 1737 test_cipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0, 1738 speed_template_16_32); 1739 test_cipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0, 1740 speed_template_32_48); 1741 test_cipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0, 1742 speed_template_32_48); 1743 test_cipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0, 1744 speed_template_32_64); 1745 test_cipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0, 1746 speed_template_32_64); 1747 break; 1748 1749 case 211: 1750 test_aead_speed("rfc4106(gcm(aes))", ENCRYPT, sec, 1751 NULL, 0, 16, 8, aead_speed_template_20); 1752 break; 1753 1754 case 300: 1755 /* fall through */ 1756 1757 case 301: 1758 test_hash_speed("md4", sec, generic_hash_speed_template); 1759 if (mode > 300 && mode < 400) break; 1760 1761 case 302: 1762 test_hash_speed("md5", sec, generic_hash_speed_template); 1763 if (mode > 300 && mode < 400) break; 1764 1765 case 303: 1766 test_hash_speed("sha1", sec, generic_hash_speed_template); 1767 if (mode > 300 && mode < 400) break; 1768 1769 case 304: 1770 test_hash_speed("sha256", sec, generic_hash_speed_template); 1771 if (mode > 300 && mode < 400) break; 1772 1773 case 305: 1774 test_hash_speed("sha384", sec, generic_hash_speed_template); 1775 if (mode > 300 && mode < 400) break; 1776 1777 case 306: 1778 test_hash_speed("sha512", sec, generic_hash_speed_template); 1779 if (mode > 300 && mode < 400) break; 1780 1781 case 307: 1782 test_hash_speed("wp256", sec, generic_hash_speed_template); 1783 if (mode > 300 && mode < 400) break; 1784 1785 case 308: 1786 test_hash_speed("wp384", sec, generic_hash_speed_template); 1787 if (mode > 300 && mode < 400) break; 1788 1789 case 309: 1790 test_hash_speed("wp512", sec, generic_hash_speed_template); 1791 if (mode > 300 && mode < 400) break; 1792 1793 case 310: 1794 test_hash_speed("tgr128", sec, generic_hash_speed_template); 1795 if (mode > 300 && mode < 400) break; 1796 1797 case 311: 1798 test_hash_speed("tgr160", sec, generic_hash_speed_template); 1799 if (mode > 300 && mode < 400) break; 1800 1801 case 312: 1802 test_hash_speed("tgr192", sec, generic_hash_speed_template); 1803 if (mode > 300 && mode < 400) break; 1804 1805 case 313: 1806 test_hash_speed("sha224", sec, generic_hash_speed_template); 1807 if (mode > 300 && mode < 400) break; 1808 1809 case 314: 1810 test_hash_speed("rmd128", sec, generic_hash_speed_template); 1811 if (mode > 300 && mode < 400) break; 1812 1813 case 315: 1814 test_hash_speed("rmd160", sec, generic_hash_speed_template); 1815 if (mode > 300 && mode < 400) break; 1816 1817 case 316: 1818 test_hash_speed("rmd256", sec, generic_hash_speed_template); 1819 if (mode > 300 && mode < 400) break; 1820 1821 case 317: 1822 test_hash_speed("rmd320", sec, generic_hash_speed_template); 1823 if (mode > 300 && mode < 400) break; 1824 1825 case 318: 1826 test_hash_speed("ghash-generic", sec, hash_speed_template_16); 1827 if (mode > 300 && mode < 400) break; 1828 1829 case 319: 1830 test_hash_speed("crc32c", sec, generic_hash_speed_template); 1831 if (mode > 300 && mode < 400) break; 1832 1833 case 320: 1834 test_hash_speed("crct10dif", sec, generic_hash_speed_template); 1835 if (mode > 300 && mode < 400) break; 1836 1837 case 399: 1838 break; 1839 1840 case 400: 1841 /* fall through */ 1842 1843 case 401: 1844 test_ahash_speed("md4", sec, generic_hash_speed_template); 1845 if (mode > 400 && mode < 500) break; 1846 1847 case 402: 1848 test_ahash_speed("md5", sec, generic_hash_speed_template); 1849 if (mode > 400 && mode < 500) break; 1850 1851 case 403: 1852 test_ahash_speed("sha1", sec, generic_hash_speed_template); 1853 if (mode > 400 && mode < 500) break; 1854 1855 case 404: 1856 test_ahash_speed("sha256", sec, generic_hash_speed_template); 1857 if (mode > 400 && mode < 500) break; 1858 1859 case 405: 1860 test_ahash_speed("sha384", sec, generic_hash_speed_template); 1861 if (mode > 400 && mode < 500) break; 1862 1863 case 406: 1864 test_ahash_speed("sha512", sec, generic_hash_speed_template); 1865 if (mode > 400 && mode < 500) break; 1866 1867 case 407: 1868 test_ahash_speed("wp256", sec, generic_hash_speed_template); 1869 if (mode > 400 && mode < 500) break; 1870 1871 case 408: 1872 test_ahash_speed("wp384", sec, generic_hash_speed_template); 1873 if (mode > 400 && mode < 500) break; 1874 1875 case 409: 1876 test_ahash_speed("wp512", sec, generic_hash_speed_template); 1877 if (mode > 400 && mode < 500) break; 1878 1879 case 410: 1880 test_ahash_speed("tgr128", sec, generic_hash_speed_template); 1881 if (mode > 400 && mode < 500) break; 1882 1883 case 411: 1884 test_ahash_speed("tgr160", sec, generic_hash_speed_template); 1885 if (mode > 400 && mode < 500) break; 1886 1887 case 412: 1888 test_ahash_speed("tgr192", sec, generic_hash_speed_template); 1889 if (mode > 400 && mode < 500) break; 1890 1891 case 413: 1892 test_ahash_speed("sha224", sec, generic_hash_speed_template); 1893 if (mode > 400 && mode < 500) break; 1894 1895 case 414: 1896 test_ahash_speed("rmd128", sec, generic_hash_speed_template); 1897 if (mode > 400 && mode < 500) break; 1898 1899 case 415: 1900 test_ahash_speed("rmd160", sec, generic_hash_speed_template); 1901 if (mode > 400 && mode < 500) break; 1902 1903 case 416: 1904 test_ahash_speed("rmd256", sec, generic_hash_speed_template); 1905 if (mode > 400 && mode < 500) break; 1906 1907 case 417: 1908 test_ahash_speed("rmd320", sec, generic_hash_speed_template); 1909 if (mode > 400 && mode < 500) break; 1910 1911 case 499: 1912 break; 1913 1914 case 500: 1915 test_acipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0, 1916 speed_template_16_24_32); 1917 test_acipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0, 1918 speed_template_16_24_32); 1919 test_acipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0, 1920 speed_template_16_24_32); 1921 test_acipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0, 1922 speed_template_16_24_32); 1923 test_acipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0, 1924 speed_template_32_40_48); 1925 test_acipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0, 1926 speed_template_32_40_48); 1927 test_acipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0, 1928 speed_template_32_48_64); 1929 test_acipher_speed("xts(aes)", DECRYPT, sec, NULL, 0, 1930 speed_template_32_48_64); 1931 test_acipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0, 1932 speed_template_16_24_32); 1933 test_acipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0, 1934 speed_template_16_24_32); 1935 test_acipher_speed("cfb(aes)", ENCRYPT, sec, NULL, 0, 1936 speed_template_16_24_32); 1937 test_acipher_speed("cfb(aes)", DECRYPT, sec, NULL, 0, 1938 speed_template_16_24_32); 1939 test_acipher_speed("ofb(aes)", ENCRYPT, sec, NULL, 0, 1940 speed_template_16_24_32); 1941 test_acipher_speed("ofb(aes)", DECRYPT, sec, NULL, 0, 1942 speed_template_16_24_32); 1943 test_acipher_speed("rfc3686(ctr(aes))", ENCRYPT, sec, NULL, 0, 1944 speed_template_20_28_36); 1945 test_acipher_speed("rfc3686(ctr(aes))", DECRYPT, sec, NULL, 0, 1946 speed_template_20_28_36); 1947 break; 1948 1949 case 501: 1950 test_acipher_speed("ecb(des3_ede)", ENCRYPT, sec, 1951 des3_speed_template, DES3_SPEED_VECTORS, 1952 speed_template_24); 1953 test_acipher_speed("ecb(des3_ede)", DECRYPT, sec, 1954 des3_speed_template, DES3_SPEED_VECTORS, 1955 speed_template_24); 1956 test_acipher_speed("cbc(des3_ede)", ENCRYPT, sec, 1957 des3_speed_template, DES3_SPEED_VECTORS, 1958 speed_template_24); 1959 test_acipher_speed("cbc(des3_ede)", DECRYPT, sec, 1960 des3_speed_template, DES3_SPEED_VECTORS, 1961 speed_template_24); 1962 test_acipher_speed("cfb(des3_ede)", ENCRYPT, sec, 1963 des3_speed_template, DES3_SPEED_VECTORS, 1964 speed_template_24); 1965 test_acipher_speed("cfb(des3_ede)", DECRYPT, sec, 1966 des3_speed_template, DES3_SPEED_VECTORS, 1967 speed_template_24); 1968 test_acipher_speed("ofb(des3_ede)", ENCRYPT, sec, 1969 des3_speed_template, DES3_SPEED_VECTORS, 1970 speed_template_24); 1971 test_acipher_speed("ofb(des3_ede)", DECRYPT, sec, 1972 des3_speed_template, DES3_SPEED_VECTORS, 1973 speed_template_24); 1974 break; 1975 1976 case 502: 1977 test_acipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0, 1978 speed_template_8); 1979 test_acipher_speed("ecb(des)", DECRYPT, sec, NULL, 0, 1980 speed_template_8); 1981 test_acipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0, 1982 speed_template_8); 1983 test_acipher_speed("cbc(des)", DECRYPT, sec, NULL, 0, 1984 speed_template_8); 1985 test_acipher_speed("cfb(des)", ENCRYPT, sec, NULL, 0, 1986 speed_template_8); 1987 test_acipher_speed("cfb(des)", DECRYPT, sec, NULL, 0, 1988 speed_template_8); 1989 test_acipher_speed("ofb(des)", ENCRYPT, sec, NULL, 0, 1990 speed_template_8); 1991 test_acipher_speed("ofb(des)", DECRYPT, sec, NULL, 0, 1992 speed_template_8); 1993 break; 1994 1995 case 503: 1996 test_acipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0, 1997 speed_template_16_32); 1998 test_acipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0, 1999 speed_template_16_32); 2000 test_acipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0, 2001 speed_template_16_32); 2002 test_acipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0, 2003 speed_template_16_32); 2004 test_acipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0, 2005 speed_template_16_32); 2006 test_acipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0, 2007 speed_template_16_32); 2008 test_acipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0, 2009 speed_template_32_48); 2010 test_acipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0, 2011 speed_template_32_48); 2012 test_acipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0, 2013 speed_template_32_64); 2014 test_acipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0, 2015 speed_template_32_64); 2016 break; 2017 2018 case 504: 2019 test_acipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0, 2020 speed_template_16_24_32); 2021 test_acipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0, 2022 speed_template_16_24_32); 2023 test_acipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0, 2024 speed_template_16_24_32); 2025 test_acipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0, 2026 speed_template_16_24_32); 2027 test_acipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0, 2028 speed_template_16_24_32); 2029 test_acipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0, 2030 speed_template_16_24_32); 2031 test_acipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0, 2032 speed_template_32_40_48); 2033 test_acipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0, 2034 speed_template_32_40_48); 2035 test_acipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0, 2036 speed_template_32_48_64); 2037 test_acipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0, 2038 speed_template_32_48_64); 2039 break; 2040 2041 case 505: 2042 test_acipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0, 2043 speed_template_8); 2044 break; 2045 2046 case 506: 2047 test_acipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0, 2048 speed_template_8_16); 2049 test_acipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0, 2050 speed_template_8_16); 2051 test_acipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0, 2052 speed_template_8_16); 2053 test_acipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0, 2054 speed_template_8_16); 2055 test_acipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0, 2056 speed_template_8_16); 2057 test_acipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0, 2058 speed_template_8_16); 2059 break; 2060 2061 case 507: 2062 test_acipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0, 2063 speed_template_16_32); 2064 test_acipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0, 2065 speed_template_16_32); 2066 test_acipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0, 2067 speed_template_16_32); 2068 test_acipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0, 2069 speed_template_16_32); 2070 test_acipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0, 2071 speed_template_16_32); 2072 test_acipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0, 2073 speed_template_16_32); 2074 test_acipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0, 2075 speed_template_32_48); 2076 test_acipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0, 2077 speed_template_32_48); 2078 test_acipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0, 2079 speed_template_32_64); 2080 test_acipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0, 2081 speed_template_32_64); 2082 break; 2083 2084 case 508: 2085 test_acipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0, 2086 speed_template_16_32); 2087 test_acipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0, 2088 speed_template_16_32); 2089 test_acipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0, 2090 speed_template_16_32); 2091 test_acipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0, 2092 speed_template_16_32); 2093 test_acipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0, 2094 speed_template_16_32); 2095 test_acipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0, 2096 speed_template_16_32); 2097 test_acipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0, 2098 speed_template_32_48); 2099 test_acipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0, 2100 speed_template_32_48); 2101 test_acipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0, 2102 speed_template_32_64); 2103 test_acipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0, 2104 speed_template_32_64); 2105 break; 2106 2107 case 509: 2108 test_acipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0, 2109 speed_template_8_32); 2110 test_acipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0, 2111 speed_template_8_32); 2112 test_acipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0, 2113 speed_template_8_32); 2114 test_acipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0, 2115 speed_template_8_32); 2116 test_acipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0, 2117 speed_template_8_32); 2118 test_acipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0, 2119 speed_template_8_32); 2120 break; 2121 2122 case 1000: 2123 test_available(); 2124 break; 2125 } 2126 2127 return ret; 2128 } 2129 2130 static int do_alg_test(const char *alg, u32 type, u32 mask) 2131 { 2132 return crypto_has_alg(alg, type, mask ?: CRYPTO_ALG_TYPE_MASK) ? 2133 0 : -ENOENT; 2134 } 2135 2136 static int __init tcrypt_mod_init(void) 2137 { 2138 int err = -ENOMEM; 2139 int i; 2140 2141 for (i = 0; i < TVMEMSIZE; i++) { 2142 tvmem[i] = (void *)__get_free_page(GFP_KERNEL); 2143 if (!tvmem[i]) 2144 goto err_free_tv; 2145 } 2146 2147 if (alg) 2148 err = do_alg_test(alg, type, mask); 2149 else 2150 err = do_test(mode); 2151 2152 if (err) { 2153 printk(KERN_ERR "tcrypt: one or more tests failed!\n"); 2154 goto err_free_tv; 2155 } 2156 2157 /* We intentionaly return -EAGAIN to prevent keeping the module, 2158 * unless we're running in fips mode. It does all its work from 2159 * init() and doesn't offer any runtime functionality, but in 2160 * the fips case, checking for a successful load is helpful. 2161 * => we don't need it in the memory, do we? 2162 * -- mludvig 2163 */ 2164 if (!fips_enabled) 2165 err = -EAGAIN; 2166 2167 err_free_tv: 2168 for (i = 0; i < TVMEMSIZE && tvmem[i]; i++) 2169 free_page((unsigned long)tvmem[i]); 2170 2171 return err; 2172 } 2173 2174 /* 2175 * If an init function is provided, an exit function must also be provided 2176 * to allow module unload. 2177 */ 2178 static void __exit tcrypt_mod_fini(void) { } 2179 2180 module_init(tcrypt_mod_init); 2181 module_exit(tcrypt_mod_fini); 2182 2183 module_param(alg, charp, 0); 2184 module_param(type, uint, 0); 2185 module_param(mask, uint, 0); 2186 module_param(mode, int, 0); 2187 module_param(sec, uint, 0); 2188 MODULE_PARM_DESC(sec, "Length in seconds of speed tests " 2189 "(defaults to zero which uses CPU cycles instead)"); 2190 2191 MODULE_LICENSE("GPL"); 2192 MODULE_DESCRIPTION("Quick & dirty crypto testing module"); 2193 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>"); 2194