1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Quick & dirty crypto benchmarking module. 4 * 5 * This will only exist until we have a better benchmarking mechanism 6 * (e.g. a char device). 7 * 8 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au> 9 * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org> 10 * Copyright (c) 2007 Nokia Siemens Networks 11 * 12 * Updated RFC4106 AES-GCM testing. 13 * Authors: Aidan O'Mahony (aidan.o.mahony@intel.com) 14 * Adrian Hoban <adrian.hoban@intel.com> 15 * Gabriele Paoloni <gabriele.paoloni@intel.com> 16 * Tadeusz Struk (tadeusz.struk@intel.com) 17 * Copyright (c) 2010, Intel Corporation. 18 */ 19 20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 21 22 #include <crypto/aead.h> 23 #include <crypto/hash.h> 24 #include <crypto/skcipher.h> 25 #include <linux/err.h> 26 #include <linux/fips.h> 27 #include <linux/init.h> 28 #include <linux/interrupt.h> 29 #include <linux/jiffies.h> 30 #include <linux/kernel.h> 31 #include <linux/module.h> 32 #include <linux/moduleparam.h> 33 #include <linux/scatterlist.h> 34 #include <linux/slab.h> 35 #include <linux/string.h> 36 #include <linux/timex.h> 37 38 #include "internal.h" 39 #include "tcrypt.h" 40 41 /* 42 * Need slab memory for benchmarking (size in number of pages). 43 */ 44 #define TVMEMSIZE 4 45 46 /* 47 * Used by test_cipher_speed() 48 */ 49 #define ENCRYPT 1 50 #define DECRYPT 0 51 52 #define MAX_DIGEST_SIZE 64 53 54 /* 55 * return a string with the driver name 56 */ 57 #define get_driver_name(tfm_type, tfm) crypto_tfm_alg_driver_name(tfm_type ## _tfm(tfm)) 58 59 struct tcrypt_aead_request { 60 struct aead_request *req; 61 struct crypto_wait wait; 62 }; 63 64 struct tcrypt_ahash_request { 65 struct ahash_request *req; 66 struct crypto_wait wait; 67 }; 68 69 struct tcrypt_skcipher_request { 70 struct skcipher_request *req; 71 struct crypto_wait wait; 72 }; 73 74 /* 75 * Used by test_cipher_speed() 76 */ 77 static unsigned int sec; 78 79 static char *alg; 80 static u32 type; 81 static u32 mask; 82 static int mode; 83 static u32 num_mb = 8; 84 static unsigned int klen; 85 static char *tvmem[TVMEMSIZE]; 86 87 static const int block_sizes[] = { 16, 64, 128, 256, 1024, 1420, 4096, 0 }; 88 static const int aead_sizes[] = { 16, 64, 256, 512, 1024, 1420, 4096, 8192, 0 }; 89 90 #define XBUFSIZE 8 91 #define MAX_IVLEN 32 92 93 static int testmgr_alloc_buf(char *buf[XBUFSIZE]) 94 { 95 int i; 96 97 for (i = 0; i < XBUFSIZE; i++) { 98 buf[i] = (void *)__get_free_page(GFP_KERNEL); 99 if (!buf[i]) 100 goto err_free_buf; 101 } 102 103 return 0; 104 105 err_free_buf: 106 while (i-- > 0) 107 free_page((unsigned long)buf[i]); 108 109 return -ENOMEM; 110 } 111 112 static void testmgr_free_buf(char *buf[XBUFSIZE]) 113 { 114 int i; 115 116 for (i = 0; i < XBUFSIZE; i++) 117 free_page((unsigned long)buf[i]); 118 } 119 120 static void sg_init_aead(struct scatterlist *sg, char *xbuf[XBUFSIZE], 121 unsigned int buflen, const void *assoc, 122 unsigned int aad_size) 123 { 124 int np = (buflen + PAGE_SIZE - 1)/PAGE_SIZE; 125 int k, rem; 126 127 if (np > XBUFSIZE) { 128 rem = PAGE_SIZE; 129 np = XBUFSIZE; 130 } else { 131 rem = buflen % PAGE_SIZE; 132 } 133 134 sg_init_table(sg, np + 1); 135 136 sg_set_buf(&sg[0], assoc, aad_size); 137 138 if (rem) 139 np--; 140 for (k = 0; k < np; k++) 141 sg_set_buf(&sg[k + 1], xbuf[k], PAGE_SIZE); 142 143 if (rem) 144 sg_set_buf(&sg[k + 1], xbuf[k], rem); 145 } 146 147 static inline int do_one_aead_op(struct tcrypt_aead_request *req, int ret) 148 { 149 return crypto_wait_req(ret, &req->wait); 150 } 151 152 struct test_mb_aead_data { 153 struct scatterlist sg[XBUFSIZE]; 154 struct scatterlist sgout[XBUFSIZE]; 155 struct tcrypt_aead_request req; 156 char *xbuf[XBUFSIZE]; 157 char *xoutbuf[XBUFSIZE]; 158 char *axbuf[XBUFSIZE]; 159 }; 160 161 static int do_mult_aead_op(struct test_mb_aead_data *data, int enc, 162 u32 num_mb, int *rc) 163 { 164 int i, err = 0; 165 166 /* Fire up a bunch of concurrent requests */ 167 for (i = 0; i < num_mb; i++) { 168 if (enc == ENCRYPT) 169 rc[i] = crypto_aead_encrypt(data[i].req.req); 170 else 171 rc[i] = crypto_aead_decrypt(data[i].req.req); 172 } 173 174 /* Wait for all requests to finish */ 175 for (i = 0; i < num_mb; i++) { 176 rc[i] = crypto_wait_req(rc[i], &data[i].req.wait); 177 178 if (rc[i]) { 179 pr_info("concurrent request %d error %d\n", i, rc[i]); 180 err = rc[i]; 181 } 182 } 183 184 return err; 185 } 186 187 static int test_mb_aead_jiffies(struct test_mb_aead_data *data, int enc, 188 int blen, int secs, u32 num_mb) 189 { 190 unsigned long start, end; 191 int bcount; 192 int ret = 0; 193 int *rc; 194 195 rc = kzalloc_objs(*rc, num_mb); 196 if (!rc) 197 return -ENOMEM; 198 199 for (start = jiffies, end = start + secs * HZ, bcount = 0; 200 time_before(jiffies, end); bcount++) { 201 ret = do_mult_aead_op(data, enc, num_mb, rc); 202 if (ret) 203 goto out; 204 } 205 206 pr_cont("%d operations in %d seconds (%llu bytes)\n", 207 bcount * num_mb, secs, (u64)bcount * blen * num_mb); 208 209 out: 210 kfree(rc); 211 return ret; 212 } 213 214 static int test_mb_aead_cycles(struct test_mb_aead_data *data, int enc, 215 int blen, u32 num_mb) 216 { 217 unsigned long cycles = 0; 218 int ret = 0; 219 int i; 220 int *rc; 221 222 rc = kzalloc_objs(*rc, num_mb); 223 if (!rc) 224 return -ENOMEM; 225 226 /* Warm-up run. */ 227 for (i = 0; i < 4; i++) { 228 ret = do_mult_aead_op(data, enc, num_mb, rc); 229 if (ret) 230 goto out; 231 } 232 233 /* The real thing. */ 234 for (i = 0; i < 8; i++) { 235 cycles_t start, end; 236 237 start = get_cycles(); 238 ret = do_mult_aead_op(data, enc, num_mb, rc); 239 end = get_cycles(); 240 241 if (ret) 242 goto out; 243 244 cycles += end - start; 245 } 246 247 pr_cont("1 operation in %lu cycles (%d bytes)\n", 248 (cycles + 4) / (8 * num_mb), blen); 249 250 out: 251 kfree(rc); 252 return ret; 253 } 254 255 static void test_mb_aead_speed(const char *algo, int enc, int secs, 256 struct aead_speed_template *template, 257 unsigned int tcount, u8 authsize, 258 unsigned int aad_size, u8 *keysize, u32 num_mb) 259 { 260 struct test_mb_aead_data *data; 261 struct crypto_aead *tfm; 262 unsigned int i, j, iv_len; 263 const int *b_size; 264 const char *key; 265 const char *e; 266 void *assoc; 267 char *iv; 268 int ret; 269 270 271 if (aad_size >= PAGE_SIZE) { 272 pr_err("associate data length (%u) too big\n", aad_size); 273 return; 274 } 275 276 iv = kzalloc(MAX_IVLEN, GFP_KERNEL); 277 if (!iv) 278 return; 279 280 if (enc == ENCRYPT) 281 e = "encryption"; 282 else 283 e = "decryption"; 284 285 data = kzalloc_objs(*data, num_mb); 286 if (!data) 287 goto out_free_iv; 288 289 tfm = crypto_alloc_aead(algo, 0, 0); 290 if (IS_ERR(tfm)) { 291 pr_err("failed to load transform for %s: %ld\n", 292 algo, PTR_ERR(tfm)); 293 goto out_free_data; 294 } 295 296 ret = crypto_aead_setauthsize(tfm, authsize); 297 if (ret) { 298 pr_err("alg: aead: Failed to setauthsize for %s: %d\n", algo, 299 ret); 300 goto out_free_tfm; 301 } 302 303 for (i = 0; i < num_mb; ++i) 304 if (testmgr_alloc_buf(data[i].xbuf)) { 305 while (i--) 306 testmgr_free_buf(data[i].xbuf); 307 goto out_free_tfm; 308 } 309 310 for (i = 0; i < num_mb; ++i) 311 if (testmgr_alloc_buf(data[i].axbuf)) { 312 while (i--) 313 testmgr_free_buf(data[i].axbuf); 314 goto out_free_xbuf; 315 } 316 317 for (i = 0; i < num_mb; ++i) 318 if (testmgr_alloc_buf(data[i].xoutbuf)) { 319 while (i--) 320 testmgr_free_buf(data[i].xoutbuf); 321 goto out_free_axbuf; 322 } 323 324 for (i = 0; i < num_mb; ++i) { 325 data[i].req.req = aead_request_alloc(tfm, GFP_KERNEL); 326 if (!data[i].req.req) { 327 pr_err("alg: aead: Failed to allocate request for %s\n", 328 algo); 329 while (i--) 330 aead_request_free(data[i].req.req); 331 goto out_free_xoutbuf; 332 } 333 } 334 335 for (i = 0; i < num_mb; ++i) { 336 crypto_init_wait(&data[i].req.wait); 337 aead_request_set_callback(data[i].req.req, 338 CRYPTO_TFM_REQ_MAY_BACKLOG, 339 crypto_req_done, &data[i].req.wait); 340 } 341 342 pr_info("testing speed of multibuffer %s (%s) %s\n", algo, 343 get_driver_name(crypto_aead, tfm), e); 344 345 i = 0; 346 do { 347 b_size = aead_sizes; 348 do { 349 int bs = round_up(*b_size, crypto_aead_blocksize(tfm)); 350 351 if (bs + authsize > XBUFSIZE * PAGE_SIZE) { 352 pr_err("template (%u) too big for buffer (%lu)\n", 353 authsize + bs, 354 XBUFSIZE * PAGE_SIZE); 355 goto out; 356 } 357 358 pr_info("test %u (%d bit key, %d byte blocks): ", i, 359 *keysize * 8, bs); 360 361 /* Set up tfm global state, i.e. the key */ 362 363 memset(tvmem[0], 0xff, PAGE_SIZE); 364 key = tvmem[0]; 365 for (j = 0; j < tcount; j++) { 366 if (template[j].klen == *keysize) { 367 key = template[j].key; 368 break; 369 } 370 } 371 372 crypto_aead_clear_flags(tfm, ~0); 373 374 ret = crypto_aead_setkey(tfm, key, *keysize); 375 if (ret) { 376 pr_err("setkey() failed flags=%x\n", 377 crypto_aead_get_flags(tfm)); 378 goto out; 379 } 380 381 iv_len = crypto_aead_ivsize(tfm); 382 if (iv_len) 383 memset(iv, 0xff, iv_len); 384 385 /* Now setup per request stuff, i.e. buffers */ 386 387 for (j = 0; j < num_mb; ++j) { 388 struct test_mb_aead_data *cur = &data[j]; 389 390 assoc = cur->axbuf[0]; 391 memset(assoc, 0xff, aad_size); 392 393 sg_init_aead(cur->sg, cur->xbuf, 394 bs + (enc ? 0 : authsize), 395 assoc, aad_size); 396 397 sg_init_aead(cur->sgout, cur->xoutbuf, 398 bs + (enc ? authsize : 0), 399 assoc, aad_size); 400 401 aead_request_set_ad(cur->req.req, aad_size); 402 403 if (!enc) { 404 405 aead_request_set_crypt(cur->req.req, 406 cur->sgout, 407 cur->sg, 408 bs, iv); 409 ret = crypto_aead_encrypt(cur->req.req); 410 ret = do_one_aead_op(&cur->req, ret); 411 412 if (ret) { 413 pr_err("calculating auth failed (%d)\n", 414 ret); 415 break; 416 } 417 } 418 419 aead_request_set_crypt(cur->req.req, cur->sg, 420 cur->sgout, bs + 421 (enc ? 0 : authsize), 422 iv); 423 424 } 425 426 if (secs) { 427 ret = test_mb_aead_jiffies(data, enc, bs, 428 secs, num_mb); 429 cond_resched(); 430 } else { 431 ret = test_mb_aead_cycles(data, enc, bs, 432 num_mb); 433 } 434 435 if (ret) { 436 pr_err("%s() failed return code=%d\n", e, ret); 437 break; 438 } 439 b_size++; 440 i++; 441 } while (*b_size); 442 keysize++; 443 } while (*keysize); 444 445 out: 446 for (i = 0; i < num_mb; ++i) 447 aead_request_free(data[i].req.req); 448 out_free_xoutbuf: 449 for (i = 0; i < num_mb; ++i) 450 testmgr_free_buf(data[i].xoutbuf); 451 out_free_axbuf: 452 for (i = 0; i < num_mb; ++i) 453 testmgr_free_buf(data[i].axbuf); 454 out_free_xbuf: 455 for (i = 0; i < num_mb; ++i) 456 testmgr_free_buf(data[i].xbuf); 457 out_free_tfm: 458 crypto_free_aead(tfm); 459 out_free_data: 460 kfree(data); 461 out_free_iv: 462 kfree(iv); 463 } 464 465 static int test_aead_jiffies(struct tcrypt_aead_request *treq, int enc, 466 int blen, int secs) 467 { 468 struct aead_request *req = treq->req; 469 unsigned long start, end; 470 int bcount; 471 int ret; 472 473 for (start = jiffies, end = start + secs * HZ, bcount = 0; 474 time_before(jiffies, end); bcount++) { 475 if (enc) 476 ret = do_one_aead_op(treq, crypto_aead_encrypt(req)); 477 else 478 ret = do_one_aead_op(treq, crypto_aead_decrypt(req)); 479 480 if (ret) 481 return ret; 482 } 483 484 pr_cont("%d operations in %d seconds (%llu bytes)\n", 485 bcount, secs, (u64)bcount * blen); 486 return 0; 487 } 488 489 static int test_aead_cycles(struct tcrypt_aead_request *treq, int enc, int blen) 490 { 491 struct aead_request *req = treq->req; 492 unsigned long cycles = 0; 493 int ret = 0; 494 int i; 495 496 /* Warm-up run. */ 497 for (i = 0; i < 4; i++) { 498 if (enc) 499 ret = do_one_aead_op(treq, crypto_aead_encrypt(req)); 500 else 501 ret = do_one_aead_op(treq, crypto_aead_decrypt(req)); 502 503 if (ret) 504 goto out; 505 } 506 507 /* The real thing. */ 508 for (i = 0; i < 8; i++) { 509 cycles_t start, end; 510 511 start = get_cycles(); 512 if (enc) 513 ret = do_one_aead_op(treq, crypto_aead_encrypt(req)); 514 else 515 ret = do_one_aead_op(treq, crypto_aead_decrypt(req)); 516 end = get_cycles(); 517 518 if (ret) 519 goto out; 520 521 cycles += end - start; 522 } 523 524 out: 525 if (ret == 0) 526 pr_cont("1 operation in %lu cycles (%d bytes)\n", 527 (cycles + 4) / 8, blen); 528 529 return ret; 530 } 531 532 static void test_aead_speed(const char *algo, int enc, unsigned int secs, 533 struct aead_speed_template *template, 534 unsigned int tcount, u8 authsize, 535 unsigned int aad_size, u8 *keysize) 536 { 537 struct tcrypt_aead_request treq; 538 unsigned int i, j; 539 struct crypto_aead *tfm; 540 int ret = -ENOMEM; 541 const char *key; 542 struct aead_request *req; 543 struct scatterlist *sg; 544 struct scatterlist *sgout; 545 const char *e; 546 void *assoc; 547 char *iv; 548 char *xbuf[XBUFSIZE]; 549 char *xoutbuf[XBUFSIZE]; 550 char *axbuf[XBUFSIZE]; 551 const int *b_size; 552 unsigned int iv_len; 553 554 iv = kzalloc(MAX_IVLEN, GFP_KERNEL); 555 if (!iv) 556 return; 557 558 if (aad_size >= PAGE_SIZE) { 559 pr_err("associate data length (%u) too big\n", aad_size); 560 goto out_noxbuf; 561 } 562 563 if (enc == ENCRYPT) 564 e = "encryption"; 565 else 566 e = "decryption"; 567 568 if (testmgr_alloc_buf(xbuf)) 569 goto out_noxbuf; 570 if (testmgr_alloc_buf(axbuf)) 571 goto out_noaxbuf; 572 if (testmgr_alloc_buf(xoutbuf)) 573 goto out_nooutbuf; 574 575 sg = kmalloc(sizeof(*sg) * 9 * 2, GFP_KERNEL); 576 if (!sg) 577 goto out_nosg; 578 sgout = &sg[9]; 579 580 tfm = crypto_alloc_aead(algo, 0, 0); 581 if (IS_ERR(tfm)) { 582 pr_err("alg: aead: Failed to load transform for %s: %ld\n", algo, 583 PTR_ERR(tfm)); 584 goto out_notfm; 585 } 586 587 ret = crypto_aead_setauthsize(tfm, authsize); 588 if (ret) { 589 pr_err("alg: aead: Failed to setauthsize for %s: %d\n", algo, 590 ret); 591 goto out_noreq; 592 } 593 594 crypto_init_wait(&treq.wait); 595 pr_info("testing speed of %s (%s) %s\n", algo, 596 get_driver_name(crypto_aead, tfm), e); 597 598 req = aead_request_alloc(tfm, GFP_KERNEL); 599 if (!req) { 600 pr_err("alg: aead: Failed to allocate request for %s\n", 601 algo); 602 goto out_noreq; 603 } 604 treq.req = req; 605 606 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 607 crypto_req_done, &treq.wait); 608 609 i = 0; 610 do { 611 b_size = aead_sizes; 612 do { 613 u32 bs = round_up(*b_size, crypto_aead_blocksize(tfm)); 614 615 assoc = axbuf[0]; 616 memset(assoc, 0xff, aad_size); 617 618 if ((*keysize + bs) > TVMEMSIZE * PAGE_SIZE) { 619 pr_err("template (%u) too big for tvmem (%lu)\n", 620 *keysize + bs, 621 TVMEMSIZE * PAGE_SIZE); 622 goto out; 623 } 624 625 key = tvmem[0]; 626 for (j = 0; j < tcount; j++) { 627 if (template[j].klen == *keysize) { 628 key = template[j].key; 629 break; 630 } 631 } 632 633 ret = crypto_aead_setkey(tfm, key, *keysize); 634 if (ret) { 635 pr_err("setkey() failed flags=%x: %d\n", 636 crypto_aead_get_flags(tfm), ret); 637 goto out; 638 } 639 640 iv_len = crypto_aead_ivsize(tfm); 641 if (iv_len) 642 memset(iv, 0xff, iv_len); 643 644 crypto_aead_clear_flags(tfm, ~0); 645 pr_info("test %u (%d bit key, %d byte blocks): ", 646 i, *keysize * 8, bs); 647 648 memset(tvmem[0], 0xff, PAGE_SIZE); 649 650 sg_init_aead(sg, xbuf, bs + (enc ? 0 : authsize), 651 assoc, aad_size); 652 653 sg_init_aead(sgout, xoutbuf, 654 bs + (enc ? authsize : 0), assoc, 655 aad_size); 656 657 aead_request_set_ad(req, aad_size); 658 659 if (!enc) { 660 661 /* 662 * For decryption we need a proper auth so 663 * we do the encryption path once with buffers 664 * reversed (input <-> output) to calculate it 665 */ 666 aead_request_set_crypt(req, sgout, sg, 667 bs, iv); 668 ret = do_one_aead_op(&treq, 669 crypto_aead_encrypt(req)); 670 671 if (ret) { 672 pr_err("calculating auth failed (%d)\n", 673 ret); 674 break; 675 } 676 } 677 678 aead_request_set_crypt(req, sg, sgout, 679 bs + (enc ? 0 : authsize), 680 iv); 681 682 if (secs) { 683 ret = test_aead_jiffies(&treq, enc, bs, 684 secs); 685 cond_resched(); 686 } else { 687 ret = test_aead_cycles(&treq, enc, bs); 688 } 689 690 if (ret) { 691 pr_err("%s() failed return code=%d\n", e, ret); 692 break; 693 } 694 b_size++; 695 i++; 696 } while (*b_size); 697 keysize++; 698 } while (*keysize); 699 700 out: 701 aead_request_free(req); 702 out_noreq: 703 crypto_free_aead(tfm); 704 out_notfm: 705 kfree(sg); 706 out_nosg: 707 testmgr_free_buf(xoutbuf); 708 out_nooutbuf: 709 testmgr_free_buf(axbuf); 710 out_noaxbuf: 711 testmgr_free_buf(xbuf); 712 out_noxbuf: 713 kfree(iv); 714 } 715 716 static void test_hash_sg_init(struct scatterlist *sg) 717 { 718 int i; 719 720 sg_init_table(sg, TVMEMSIZE); 721 for (i = 0; i < TVMEMSIZE; i++) { 722 sg_set_buf(sg + i, tvmem[i], PAGE_SIZE); 723 memset(tvmem[i], 0xff, PAGE_SIZE); 724 } 725 } 726 727 static inline int do_one_ahash_op(struct tcrypt_ahash_request *treq, int ret) 728 { 729 return crypto_wait_req(ret, &treq->wait); 730 } 731 732 static int test_ahash_jiffies_digest(struct tcrypt_ahash_request *treq, 733 int blen, char *out, int secs) 734 { 735 struct ahash_request *req = treq->req; 736 unsigned long start, end; 737 int bcount; 738 int ret; 739 740 for (start = jiffies, end = start + secs * HZ, bcount = 0; 741 time_before(jiffies, end); bcount++) { 742 ret = do_one_ahash_op(treq, crypto_ahash_digest(req)); 743 if (ret) 744 return ret; 745 } 746 747 pr_cont("%6u opers/sec, %9lu bytes/sec\n", 748 bcount / secs, ((long)bcount * blen) / secs); 749 750 return 0; 751 } 752 753 static int test_ahash_jiffies(struct tcrypt_ahash_request *treq, int blen, 754 int plen, char *out, int secs) 755 { 756 struct ahash_request *req = treq->req; 757 unsigned long start, end; 758 int bcount, pcount; 759 int ret; 760 761 if (plen == blen) 762 return test_ahash_jiffies_digest(treq, blen, out, secs); 763 764 for (start = jiffies, end = start + secs * HZ, bcount = 0; 765 time_before(jiffies, end); bcount++) { 766 ret = do_one_ahash_op(treq, crypto_ahash_init(req)); 767 if (ret) 768 return ret; 769 for (pcount = 0; pcount < blen; pcount += plen) { 770 ret = do_one_ahash_op(treq, crypto_ahash_update(req)); 771 if (ret) 772 return ret; 773 } 774 /* we assume there is enough space in 'out' for the result */ 775 ret = do_one_ahash_op(treq, crypto_ahash_final(req)); 776 if (ret) 777 return ret; 778 } 779 780 pr_cont("%6u opers/sec, %9lu bytes/sec\n", 781 bcount / secs, ((long)bcount * blen) / secs); 782 783 return 0; 784 } 785 786 static int test_ahash_cycles_digest(struct tcrypt_ahash_request *treq, 787 int blen, char *out) 788 { 789 struct ahash_request *req = treq->req; 790 unsigned long cycles = 0; 791 int ret, i; 792 793 /* Warm-up run. */ 794 for (i = 0; i < 4; i++) { 795 ret = do_one_ahash_op(treq, crypto_ahash_digest(req)); 796 if (ret) 797 goto out; 798 } 799 800 /* The real thing. */ 801 for (i = 0; i < 8; i++) { 802 cycles_t start, end; 803 804 start = get_cycles(); 805 806 ret = do_one_ahash_op(treq, crypto_ahash_digest(req)); 807 if (ret) 808 goto out; 809 810 end = get_cycles(); 811 812 cycles += end - start; 813 } 814 815 out: 816 if (ret) 817 return ret; 818 819 pr_cont("%6lu cycles/operation, %4lu cycles/byte\n", 820 cycles / 8, cycles / (8 * blen)); 821 822 return 0; 823 } 824 825 static int test_ahash_cycles(struct tcrypt_ahash_request *treq, int blen, 826 int plen, char *out) 827 { 828 struct ahash_request *req = treq->req; 829 unsigned long cycles = 0; 830 int i, pcount, ret; 831 832 if (plen == blen) 833 return test_ahash_cycles_digest(treq, blen, out); 834 835 /* Warm-up run. */ 836 for (i = 0; i < 4; i++) { 837 ret = do_one_ahash_op(treq, crypto_ahash_init(req)); 838 if (ret) 839 goto out; 840 for (pcount = 0; pcount < blen; pcount += plen) { 841 ret = do_one_ahash_op(treq, crypto_ahash_update(req)); 842 if (ret) 843 goto out; 844 } 845 ret = do_one_ahash_op(treq, crypto_ahash_final(req)); 846 if (ret) 847 goto out; 848 } 849 850 /* The real thing. */ 851 for (i = 0; i < 8; i++) { 852 cycles_t start, end; 853 854 start = get_cycles(); 855 856 ret = do_one_ahash_op(treq, crypto_ahash_init(req)); 857 if (ret) 858 goto out; 859 for (pcount = 0; pcount < blen; pcount += plen) { 860 ret = do_one_ahash_op(treq, crypto_ahash_update(req)); 861 if (ret) 862 goto out; 863 } 864 ret = do_one_ahash_op(treq, crypto_ahash_final(req)); 865 if (ret) 866 goto out; 867 868 end = get_cycles(); 869 870 cycles += end - start; 871 } 872 873 out: 874 if (ret) 875 return ret; 876 877 pr_cont("%6lu cycles/operation, %4lu cycles/byte\n", 878 cycles / 8, cycles / (8 * blen)); 879 880 return 0; 881 } 882 883 static void test_ahash_speed_common(const char *algo, unsigned int secs, 884 struct hash_speed *speed, unsigned mask) 885 { 886 struct scatterlist sg[TVMEMSIZE]; 887 struct tcrypt_ahash_request treq; 888 struct ahash_request *req; 889 struct crypto_ahash *tfm; 890 char *output; 891 int i, ret; 892 893 tfm = crypto_alloc_ahash(algo, 0, mask); 894 if (IS_ERR(tfm)) { 895 pr_err("failed to load transform for %s: %ld\n", 896 algo, PTR_ERR(tfm)); 897 return; 898 } 899 900 pr_info("testing speed of async %s (%s)\n", algo, 901 get_driver_name(crypto_ahash, tfm)); 902 903 if (crypto_ahash_digestsize(tfm) > MAX_DIGEST_SIZE) { 904 pr_err("digestsize(%u) > %d\n", crypto_ahash_digestsize(tfm), 905 MAX_DIGEST_SIZE); 906 goto out; 907 } 908 909 test_hash_sg_init(sg); 910 req = ahash_request_alloc(tfm, GFP_KERNEL); 911 if (!req) { 912 pr_err("ahash request allocation failure\n"); 913 goto out; 914 } 915 916 treq.req = req; 917 crypto_init_wait(&treq.wait); 918 ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 919 crypto_req_done, &treq.wait); 920 921 output = kmalloc(MAX_DIGEST_SIZE, GFP_KERNEL); 922 if (!output) 923 goto out_nomem; 924 925 for (i = 0; speed[i].blen != 0; i++) { 926 if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) { 927 pr_err("template (%u) too big for tvmem (%lu)\n", 928 speed[i].blen, TVMEMSIZE * PAGE_SIZE); 929 break; 930 } 931 932 if (klen) { 933 ret = crypto_ahash_setkey(tfm, tvmem[0], klen); 934 if (ret) { 935 pr_err("setkey() failed flags=%x: %d\n", 936 crypto_ahash_get_flags(tfm), ret); 937 break; 938 } 939 } 940 941 pr_info("test%3u " 942 "(%5u byte blocks,%5u bytes per update,%4u updates): ", 943 i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen); 944 945 ahash_request_set_crypt(req, sg, output, speed[i].plen); 946 947 if (secs) { 948 ret = test_ahash_jiffies(&treq, speed[i].blen, 949 speed[i].plen, output, secs); 950 cond_resched(); 951 } else { 952 ret = test_ahash_cycles(&treq, speed[i].blen, 953 speed[i].plen, output); 954 } 955 956 if (ret) { 957 pr_err("hashing failed ret=%d\n", ret); 958 break; 959 } 960 } 961 962 kfree(output); 963 964 out_nomem: 965 ahash_request_free(req); 966 967 out: 968 crypto_free_ahash(tfm); 969 } 970 971 static void test_ahash_speed(const char *algo, unsigned int secs, 972 struct hash_speed *speed) 973 { 974 return test_ahash_speed_common(algo, secs, speed, 0); 975 } 976 977 static void test_hash_speed(const char *algo, unsigned int secs, 978 struct hash_speed *speed) 979 { 980 return test_ahash_speed_common(algo, secs, speed, CRYPTO_ALG_ASYNC); 981 } 982 983 struct test_mb_skcipher_data { 984 struct scatterlist sg[XBUFSIZE]; 985 struct skcipher_request *req; 986 struct crypto_wait wait; 987 char *xbuf[XBUFSIZE]; 988 }; 989 990 static int do_mult_acipher_op(struct test_mb_skcipher_data *data, int enc, 991 u32 num_mb, int *rc) 992 { 993 int i, err = 0; 994 995 /* Fire up a bunch of concurrent requests */ 996 for (i = 0; i < num_mb; i++) { 997 if (enc == ENCRYPT) 998 rc[i] = crypto_skcipher_encrypt(data[i].req); 999 else 1000 rc[i] = crypto_skcipher_decrypt(data[i].req); 1001 } 1002 1003 /* Wait for all requests to finish */ 1004 for (i = 0; i < num_mb; i++) { 1005 rc[i] = crypto_wait_req(rc[i], &data[i].wait); 1006 1007 if (rc[i]) { 1008 pr_info("concurrent request %d error %d\n", i, rc[i]); 1009 err = rc[i]; 1010 } 1011 } 1012 1013 return err; 1014 } 1015 1016 static int test_mb_acipher_jiffies(struct test_mb_skcipher_data *data, int enc, 1017 int blen, int secs, u32 num_mb) 1018 { 1019 unsigned long start, end; 1020 int bcount; 1021 int ret = 0; 1022 int *rc; 1023 1024 rc = kzalloc_objs(*rc, num_mb); 1025 if (!rc) 1026 return -ENOMEM; 1027 1028 for (start = jiffies, end = start + secs * HZ, bcount = 0; 1029 time_before(jiffies, end); bcount++) { 1030 ret = do_mult_acipher_op(data, enc, num_mb, rc); 1031 if (ret) 1032 goto out; 1033 } 1034 1035 pr_cont("%d operations in %d seconds (%llu bytes)\n", 1036 bcount * num_mb, secs, (u64)bcount * blen * num_mb); 1037 1038 out: 1039 kfree(rc); 1040 return ret; 1041 } 1042 1043 static int test_mb_acipher_cycles(struct test_mb_skcipher_data *data, int enc, 1044 int blen, u32 num_mb) 1045 { 1046 unsigned long cycles = 0; 1047 int ret = 0; 1048 int i; 1049 int *rc; 1050 1051 rc = kzalloc_objs(*rc, num_mb); 1052 if (!rc) 1053 return -ENOMEM; 1054 1055 /* Warm-up run. */ 1056 for (i = 0; i < 4; i++) { 1057 ret = do_mult_acipher_op(data, enc, num_mb, rc); 1058 if (ret) 1059 goto out; 1060 } 1061 1062 /* The real thing. */ 1063 for (i = 0; i < 8; i++) { 1064 cycles_t start, end; 1065 1066 start = get_cycles(); 1067 ret = do_mult_acipher_op(data, enc, num_mb, rc); 1068 end = get_cycles(); 1069 1070 if (ret) 1071 goto out; 1072 1073 cycles += end - start; 1074 } 1075 1076 pr_cont("1 operation in %lu cycles (%d bytes)\n", 1077 (cycles + 4) / (8 * num_mb), blen); 1078 1079 out: 1080 kfree(rc); 1081 return ret; 1082 } 1083 1084 static void test_mb_skcipher_speed(const char *algo, int enc, int secs, 1085 struct cipher_speed_template *template, 1086 unsigned int tcount, u8 *keysize, u32 num_mb) 1087 { 1088 struct test_mb_skcipher_data *data; 1089 struct crypto_skcipher *tfm; 1090 unsigned int i, j, iv_len; 1091 const int *b_size; 1092 const char *key; 1093 const char *e; 1094 char iv[128]; 1095 int ret; 1096 1097 if (enc == ENCRYPT) 1098 e = "encryption"; 1099 else 1100 e = "decryption"; 1101 1102 data = kzalloc_objs(*data, num_mb); 1103 if (!data) 1104 return; 1105 1106 tfm = crypto_alloc_skcipher(algo, 0, 0); 1107 if (IS_ERR(tfm)) { 1108 pr_err("failed to load transform for %s: %ld\n", 1109 algo, PTR_ERR(tfm)); 1110 goto out_free_data; 1111 } 1112 1113 for (i = 0; i < num_mb; ++i) 1114 if (testmgr_alloc_buf(data[i].xbuf)) { 1115 while (i--) 1116 testmgr_free_buf(data[i].xbuf); 1117 goto out_free_tfm; 1118 } 1119 1120 for (i = 0; i < num_mb; ++i) { 1121 data[i].req = skcipher_request_alloc(tfm, GFP_KERNEL); 1122 if (!data[i].req) { 1123 pr_err("alg: skcipher: Failed to allocate request for %s\n", 1124 algo); 1125 while (i--) 1126 skcipher_request_free(data[i].req); 1127 goto out_free_xbuf; 1128 } 1129 } 1130 1131 for (i = 0; i < num_mb; ++i) { 1132 skcipher_request_set_callback(data[i].req, 1133 CRYPTO_TFM_REQ_MAY_BACKLOG, 1134 crypto_req_done, &data[i].wait); 1135 crypto_init_wait(&data[i].wait); 1136 } 1137 1138 pr_info("testing speed of multibuffer %s (%s) %s\n", algo, 1139 get_driver_name(crypto_skcipher, tfm), e); 1140 1141 i = 0; 1142 do { 1143 b_size = block_sizes; 1144 do { 1145 u32 bs = round_up(*b_size, crypto_skcipher_blocksize(tfm)); 1146 1147 if (bs > XBUFSIZE * PAGE_SIZE) { 1148 pr_err("template (%u) too big for buffer (%lu)\n", 1149 bs, XBUFSIZE * PAGE_SIZE); 1150 goto out; 1151 } 1152 1153 pr_info("test %u (%d bit key, %d byte blocks): ", i, 1154 *keysize * 8, bs); 1155 1156 /* Set up tfm global state, i.e. the key */ 1157 1158 memset(tvmem[0], 0xff, PAGE_SIZE); 1159 key = tvmem[0]; 1160 for (j = 0; j < tcount; j++) { 1161 if (template[j].klen == *keysize) { 1162 key = template[j].key; 1163 break; 1164 } 1165 } 1166 1167 crypto_skcipher_clear_flags(tfm, ~0); 1168 1169 ret = crypto_skcipher_setkey(tfm, key, *keysize); 1170 if (ret) { 1171 pr_err("setkey() failed flags=%x\n", 1172 crypto_skcipher_get_flags(tfm)); 1173 goto out; 1174 } 1175 1176 iv_len = crypto_skcipher_ivsize(tfm); 1177 if (iv_len) 1178 memset(&iv, 0xff, iv_len); 1179 1180 /* Now setup per request stuff, i.e. buffers */ 1181 1182 for (j = 0; j < num_mb; ++j) { 1183 struct test_mb_skcipher_data *cur = &data[j]; 1184 unsigned int k = bs; 1185 unsigned int pages = DIV_ROUND_UP(k, PAGE_SIZE); 1186 unsigned int p = 0; 1187 1188 sg_init_table(cur->sg, pages); 1189 1190 while (k > PAGE_SIZE) { 1191 sg_set_buf(cur->sg + p, cur->xbuf[p], 1192 PAGE_SIZE); 1193 memset(cur->xbuf[p], 0xff, PAGE_SIZE); 1194 p++; 1195 k -= PAGE_SIZE; 1196 } 1197 1198 sg_set_buf(cur->sg + p, cur->xbuf[p], k); 1199 memset(cur->xbuf[p], 0xff, k); 1200 1201 skcipher_request_set_crypt(cur->req, cur->sg, 1202 cur->sg, bs, iv); 1203 } 1204 1205 if (secs) { 1206 ret = test_mb_acipher_jiffies(data, enc, 1207 bs, secs, 1208 num_mb); 1209 cond_resched(); 1210 } else { 1211 ret = test_mb_acipher_cycles(data, enc, 1212 bs, num_mb); 1213 } 1214 1215 if (ret) { 1216 pr_err("%s() failed flags=%x\n", e, 1217 crypto_skcipher_get_flags(tfm)); 1218 break; 1219 } 1220 b_size++; 1221 i++; 1222 } while (*b_size); 1223 keysize++; 1224 } while (*keysize); 1225 1226 out: 1227 for (i = 0; i < num_mb; ++i) 1228 skcipher_request_free(data[i].req); 1229 out_free_xbuf: 1230 for (i = 0; i < num_mb; ++i) 1231 testmgr_free_buf(data[i].xbuf); 1232 out_free_tfm: 1233 crypto_free_skcipher(tfm); 1234 out_free_data: 1235 kfree(data); 1236 } 1237 1238 static inline int do_one_acipher_op(struct tcrypt_skcipher_request *req, 1239 int ret) 1240 { 1241 return crypto_wait_req(ret, &req->wait); 1242 } 1243 1244 static int test_acipher_jiffies(struct tcrypt_skcipher_request *treq, int enc, 1245 int blen, int secs) 1246 { 1247 struct skcipher_request *req = treq->req; 1248 unsigned long start, end; 1249 int bcount; 1250 int ret; 1251 1252 for (start = jiffies, end = start + secs * HZ, bcount = 0; 1253 time_before(jiffies, end); bcount++) { 1254 if (enc) 1255 ret = do_one_acipher_op(treq, 1256 crypto_skcipher_encrypt(req)); 1257 else 1258 ret = do_one_acipher_op(treq, 1259 crypto_skcipher_decrypt(req)); 1260 1261 if (ret) 1262 return ret; 1263 } 1264 1265 pr_cont("%d operations in %d seconds (%llu bytes)\n", 1266 bcount, secs, (u64)bcount * blen); 1267 return 0; 1268 } 1269 1270 static int test_acipher_cycles(struct tcrypt_skcipher_request *treq, int enc, 1271 int blen) 1272 { 1273 struct skcipher_request *req = treq->req; 1274 unsigned long cycles = 0; 1275 int ret = 0; 1276 int i; 1277 1278 /* Warm-up run. */ 1279 for (i = 0; i < 4; i++) { 1280 if (enc) 1281 ret = do_one_acipher_op(treq, 1282 crypto_skcipher_encrypt(req)); 1283 else 1284 ret = do_one_acipher_op(treq, 1285 crypto_skcipher_decrypt(req)); 1286 1287 if (ret) 1288 goto out; 1289 } 1290 1291 /* The real thing. */ 1292 for (i = 0; i < 8; i++) { 1293 cycles_t start, end; 1294 1295 start = get_cycles(); 1296 if (enc) 1297 ret = do_one_acipher_op(treq, 1298 crypto_skcipher_encrypt(req)); 1299 else 1300 ret = do_one_acipher_op(treq, 1301 crypto_skcipher_decrypt(req)); 1302 end = get_cycles(); 1303 1304 if (ret) 1305 goto out; 1306 1307 cycles += end - start; 1308 } 1309 1310 out: 1311 if (ret == 0) 1312 pr_cont("1 operation in %lu cycles (%d bytes)\n", 1313 (cycles + 4) / 8, blen); 1314 1315 return ret; 1316 } 1317 1318 static void test_skcipher_speed(const char *algo, int enc, unsigned int secs, 1319 struct cipher_speed_template *template, 1320 unsigned int tcount, u8 *keysize, bool async) 1321 { 1322 struct tcrypt_skcipher_request treq; 1323 unsigned int ret, i, j, k, iv_len; 1324 const char *key; 1325 char iv[128]; 1326 struct skcipher_request *req; 1327 struct crypto_skcipher *tfm; 1328 const int *b_size; 1329 const char *e; 1330 1331 if (enc == ENCRYPT) 1332 e = "encryption"; 1333 else 1334 e = "decryption"; 1335 1336 crypto_init_wait(&treq.wait); 1337 1338 tfm = crypto_alloc_skcipher(algo, 0, async ? 0 : CRYPTO_ALG_ASYNC); 1339 1340 if (IS_ERR(tfm)) { 1341 pr_err("failed to load transform for %s: %ld\n", algo, 1342 PTR_ERR(tfm)); 1343 return; 1344 } 1345 1346 pr_info("testing speed of %s %s (%s) %s\n", async ? "async" : "sync", 1347 algo, get_driver_name(crypto_skcipher, tfm), e); 1348 1349 req = skcipher_request_alloc(tfm, GFP_KERNEL); 1350 if (!req) { 1351 pr_err("skcipher: Failed to allocate request for %s\n", algo); 1352 goto out; 1353 } 1354 1355 treq.req = req; 1356 skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 1357 crypto_req_done, &treq.wait); 1358 1359 i = 0; 1360 do { 1361 b_size = block_sizes; 1362 1363 do { 1364 u32 bs = round_up(*b_size, crypto_skcipher_blocksize(tfm)); 1365 struct scatterlist sg[TVMEMSIZE]; 1366 1367 if ((*keysize + bs) > TVMEMSIZE * PAGE_SIZE) { 1368 pr_err("template (%u) too big for " 1369 "tvmem (%lu)\n", *keysize + bs, 1370 TVMEMSIZE * PAGE_SIZE); 1371 goto out_free_req; 1372 } 1373 1374 pr_info("test %u (%d bit key, %d byte blocks): ", i, 1375 *keysize * 8, bs); 1376 1377 memset(tvmem[0], 0xff, PAGE_SIZE); 1378 1379 /* set key, plain text and IV */ 1380 key = tvmem[0]; 1381 for (j = 0; j < tcount; j++) { 1382 if (template[j].klen == *keysize) { 1383 key = template[j].key; 1384 break; 1385 } 1386 } 1387 1388 crypto_skcipher_clear_flags(tfm, ~0); 1389 1390 ret = crypto_skcipher_setkey(tfm, key, *keysize); 1391 if (ret) { 1392 pr_err("setkey() failed flags=%x\n", 1393 crypto_skcipher_get_flags(tfm)); 1394 goto out_free_req; 1395 } 1396 1397 k = *keysize + bs; 1398 sg_init_table(sg, DIV_ROUND_UP(k, PAGE_SIZE)); 1399 1400 if (k > PAGE_SIZE) { 1401 sg_set_buf(sg, tvmem[0] + *keysize, 1402 PAGE_SIZE - *keysize); 1403 k -= PAGE_SIZE; 1404 j = 1; 1405 while (k > PAGE_SIZE) { 1406 sg_set_buf(sg + j, tvmem[j], PAGE_SIZE); 1407 memset(tvmem[j], 0xff, PAGE_SIZE); 1408 j++; 1409 k -= PAGE_SIZE; 1410 } 1411 sg_set_buf(sg + j, tvmem[j], k); 1412 memset(tvmem[j], 0xff, k); 1413 } else { 1414 sg_set_buf(sg, tvmem[0] + *keysize, bs); 1415 } 1416 1417 iv_len = crypto_skcipher_ivsize(tfm); 1418 if (iv_len) 1419 memset(&iv, 0xff, iv_len); 1420 1421 skcipher_request_set_crypt(req, sg, sg, bs, iv); 1422 1423 if (secs) { 1424 ret = test_acipher_jiffies(&treq, enc, 1425 bs, secs); 1426 cond_resched(); 1427 } else { 1428 ret = test_acipher_cycles(&treq, enc, 1429 bs); 1430 } 1431 1432 if (ret) { 1433 pr_err("%s() failed flags=%x\n", e, 1434 crypto_skcipher_get_flags(tfm)); 1435 break; 1436 } 1437 b_size++; 1438 i++; 1439 } while (*b_size); 1440 keysize++; 1441 } while (*keysize); 1442 1443 out_free_req: 1444 skcipher_request_free(req); 1445 out: 1446 crypto_free_skcipher(tfm); 1447 } 1448 1449 static void test_acipher_speed(const char *algo, int enc, unsigned int secs, 1450 struct cipher_speed_template *template, 1451 unsigned int tcount, u8 *keysize) 1452 { 1453 return test_skcipher_speed(algo, enc, secs, template, tcount, keysize, 1454 true); 1455 } 1456 1457 static void test_cipher_speed(const char *algo, int enc, unsigned int secs, 1458 struct cipher_speed_template *template, 1459 unsigned int tcount, u8 *keysize) 1460 { 1461 return test_skcipher_speed(algo, enc, secs, template, tcount, keysize, 1462 false); 1463 } 1464 1465 static inline int tcrypt_test(const char *alg) 1466 { 1467 int ret; 1468 1469 pr_debug("testing %s\n", alg); 1470 1471 ret = alg_test(alg, alg, 0, 0); 1472 /* non-fips algs return -EINVAL or -ECANCELED in fips mode */ 1473 if (fips_enabled && (ret == -EINVAL || ret == -ECANCELED)) 1474 ret = 0; 1475 return ret; 1476 } 1477 1478 static int do_test(const char *alg, u32 type, u32 mask, int m, u32 num_mb) 1479 { 1480 int i; 1481 int ret = 0; 1482 1483 switch (m) { 1484 case 0: 1485 if (alg) { 1486 if (!crypto_has_alg(alg, type, 1487 mask ?: CRYPTO_ALG_TYPE_MASK)) 1488 ret = -ENOENT; 1489 break; 1490 } 1491 1492 for (i = 1; i < 200; i++) 1493 ret = min(ret, do_test(NULL, 0, 0, i, num_mb)); 1494 break; 1495 1496 case 1: 1497 ret = min(ret, tcrypt_test("md5")); 1498 break; 1499 1500 case 2: 1501 ret = min(ret, tcrypt_test("sha1")); 1502 break; 1503 1504 case 3: 1505 ret = min(ret, tcrypt_test("ecb(des)")); 1506 ret = min(ret, tcrypt_test("cbc(des)")); 1507 ret = min(ret, tcrypt_test("ctr(des)")); 1508 break; 1509 1510 case 4: 1511 ret = min(ret, tcrypt_test("ecb(des3_ede)")); 1512 ret = min(ret, tcrypt_test("cbc(des3_ede)")); 1513 ret = min(ret, tcrypt_test("ctr(des3_ede)")); 1514 break; 1515 1516 case 5: 1517 ret = min(ret, tcrypt_test("md4")); 1518 break; 1519 1520 case 6: 1521 ret = min(ret, tcrypt_test("sha256")); 1522 break; 1523 1524 case 7: 1525 ret = min(ret, tcrypt_test("ecb(blowfish)")); 1526 ret = min(ret, tcrypt_test("cbc(blowfish)")); 1527 ret = min(ret, tcrypt_test("ctr(blowfish)")); 1528 break; 1529 1530 case 8: 1531 ret = min(ret, tcrypt_test("ecb(twofish)")); 1532 ret = min(ret, tcrypt_test("cbc(twofish)")); 1533 ret = min(ret, tcrypt_test("ctr(twofish)")); 1534 ret = min(ret, tcrypt_test("lrw(twofish)")); 1535 ret = min(ret, tcrypt_test("xts(twofish)")); 1536 break; 1537 1538 case 9: 1539 ret = min(ret, tcrypt_test("ecb(serpent)")); 1540 ret = min(ret, tcrypt_test("cbc(serpent)")); 1541 ret = min(ret, tcrypt_test("ctr(serpent)")); 1542 ret = min(ret, tcrypt_test("lrw(serpent)")); 1543 ret = min(ret, tcrypt_test("xts(serpent)")); 1544 break; 1545 1546 case 10: 1547 ret = min(ret, tcrypt_test("ecb(aes)")); 1548 ret = min(ret, tcrypt_test("cbc(aes)")); 1549 ret = min(ret, tcrypt_test("lrw(aes)")); 1550 ret = min(ret, tcrypt_test("xts(aes)")); 1551 ret = min(ret, tcrypt_test("ctr(aes)")); 1552 ret = min(ret, tcrypt_test("rfc3686(ctr(aes))")); 1553 ret = min(ret, tcrypt_test("xctr(aes)")); 1554 break; 1555 1556 case 11: 1557 ret = min(ret, tcrypt_test("sha384")); 1558 break; 1559 1560 case 12: 1561 ret = min(ret, tcrypt_test("sha512")); 1562 break; 1563 1564 case 13: 1565 ret = min(ret, tcrypt_test("deflate")); 1566 break; 1567 1568 case 14: 1569 ret = min(ret, tcrypt_test("ecb(cast5)")); 1570 ret = min(ret, tcrypt_test("cbc(cast5)")); 1571 ret = min(ret, tcrypt_test("ctr(cast5)")); 1572 break; 1573 1574 case 15: 1575 ret = min(ret, tcrypt_test("ecb(cast6)")); 1576 ret = min(ret, tcrypt_test("cbc(cast6)")); 1577 ret = min(ret, tcrypt_test("ctr(cast6)")); 1578 ret = min(ret, tcrypt_test("lrw(cast6)")); 1579 ret = min(ret, tcrypt_test("xts(cast6)")); 1580 break; 1581 1582 case 16: 1583 ret = min(ret, tcrypt_test("ecb(arc4)")); 1584 break; 1585 1586 case 18: 1587 ret = min(ret, tcrypt_test("crc32c")); 1588 break; 1589 1590 case 19: 1591 ret = min(ret, tcrypt_test("ecb(tea)")); 1592 break; 1593 1594 case 20: 1595 ret = min(ret, tcrypt_test("ecb(xtea)")); 1596 break; 1597 1598 case 21: 1599 ret = min(ret, tcrypt_test("ecb(khazad)")); 1600 break; 1601 1602 case 22: 1603 ret = min(ret, tcrypt_test("wp512")); 1604 break; 1605 1606 case 23: 1607 ret = min(ret, tcrypt_test("wp384")); 1608 break; 1609 1610 case 24: 1611 ret = min(ret, tcrypt_test("wp256")); 1612 break; 1613 1614 case 26: 1615 ret = min(ret, tcrypt_test("ecb(anubis)")); 1616 ret = min(ret, tcrypt_test("cbc(anubis)")); 1617 break; 1618 1619 case 30: 1620 ret = min(ret, tcrypt_test("ecb(xeta)")); 1621 break; 1622 1623 case 32: 1624 ret = min(ret, tcrypt_test("ecb(camellia)")); 1625 ret = min(ret, tcrypt_test("cbc(camellia)")); 1626 ret = min(ret, tcrypt_test("ctr(camellia)")); 1627 ret = min(ret, tcrypt_test("lrw(camellia)")); 1628 ret = min(ret, tcrypt_test("xts(camellia)")); 1629 break; 1630 1631 case 33: 1632 ret = min(ret, tcrypt_test("sha224")); 1633 break; 1634 1635 case 35: 1636 ret = min(ret, tcrypt_test("gcm(aes)")); 1637 break; 1638 1639 case 36: 1640 ret = min(ret, tcrypt_test("lzo")); 1641 break; 1642 1643 case 37: 1644 ret = min(ret, tcrypt_test("ccm(aes)")); 1645 break; 1646 1647 case 38: 1648 ret = min(ret, tcrypt_test("cts(cbc(aes))")); 1649 break; 1650 1651 case 39: 1652 ret = min(ret, tcrypt_test("xxhash64")); 1653 break; 1654 1655 case 40: 1656 ret = min(ret, tcrypt_test("rmd160")); 1657 break; 1658 1659 case 42: 1660 ret = min(ret, tcrypt_test("blake2b-512")); 1661 break; 1662 1663 case 43: 1664 ret = min(ret, tcrypt_test("ecb(seed)")); 1665 break; 1666 1667 case 45: 1668 ret = min(ret, tcrypt_test("rfc4309(ccm(aes))")); 1669 break; 1670 1671 case 48: 1672 ret = min(ret, tcrypt_test("sha3-224")); 1673 break; 1674 1675 case 49: 1676 ret = min(ret, tcrypt_test("sha3-256")); 1677 break; 1678 1679 case 50: 1680 ret = min(ret, tcrypt_test("sha3-384")); 1681 break; 1682 1683 case 51: 1684 ret = min(ret, tcrypt_test("sha3-512")); 1685 break; 1686 1687 case 52: 1688 ret = min(ret, tcrypt_test("sm3")); 1689 break; 1690 1691 case 53: 1692 ret = min(ret, tcrypt_test("streebog256")); 1693 break; 1694 1695 case 54: 1696 ret = min(ret, tcrypt_test("streebog512")); 1697 break; 1698 1699 case 55: 1700 ret = min(ret, tcrypt_test("gcm(sm4)")); 1701 break; 1702 1703 case 56: 1704 ret = min(ret, tcrypt_test("ccm(sm4)")); 1705 break; 1706 1707 case 58: 1708 ret = min(ret, tcrypt_test("gcm(aria)")); 1709 break; 1710 1711 case 59: 1712 ret = min(ret, tcrypt_test("cts(cbc(sm4))")); 1713 break; 1714 1715 case 100: 1716 ret = min(ret, tcrypt_test("hmac(md5)")); 1717 break; 1718 1719 case 101: 1720 ret = min(ret, tcrypt_test("hmac(sha1)")); 1721 break; 1722 1723 case 102: 1724 ret = min(ret, tcrypt_test("hmac(sha256)")); 1725 break; 1726 1727 case 103: 1728 ret = min(ret, tcrypt_test("hmac(sha384)")); 1729 break; 1730 1731 case 104: 1732 ret = min(ret, tcrypt_test("hmac(sha512)")); 1733 break; 1734 1735 case 105: 1736 ret = min(ret, tcrypt_test("hmac(sha224)")); 1737 break; 1738 1739 case 106: 1740 ret = min(ret, tcrypt_test("xcbc(aes)")); 1741 break; 1742 1743 case 108: 1744 ret = min(ret, tcrypt_test("hmac(rmd160)")); 1745 break; 1746 1747 case 111: 1748 ret = min(ret, tcrypt_test("hmac(sha3-224)")); 1749 break; 1750 1751 case 112: 1752 ret = min(ret, tcrypt_test("hmac(sha3-256)")); 1753 break; 1754 1755 case 113: 1756 ret = min(ret, tcrypt_test("hmac(sha3-384)")); 1757 break; 1758 1759 case 114: 1760 ret = min(ret, tcrypt_test("hmac(sha3-512)")); 1761 break; 1762 1763 case 115: 1764 ret = min(ret, tcrypt_test("hmac(streebog256)")); 1765 break; 1766 1767 case 116: 1768 ret = min(ret, tcrypt_test("hmac(streebog512)")); 1769 break; 1770 1771 case 151: 1772 ret = min(ret, tcrypt_test("rfc4106(gcm(aes))")); 1773 break; 1774 1775 case 152: 1776 ret = min(ret, tcrypt_test("rfc4543(gcm(aes))")); 1777 break; 1778 1779 case 153: 1780 ret = min(ret, tcrypt_test("cmac(aes)")); 1781 break; 1782 1783 case 154: 1784 ret = min(ret, tcrypt_test("cmac(des3_ede)")); 1785 break; 1786 1787 case 155: 1788 ret = min(ret, tcrypt_test("authenc(hmac(sha1),cbc(aes))")); 1789 break; 1790 1791 case 156: 1792 ret = min(ret, tcrypt_test("authenc(hmac(md5),ecb(cipher_null))")); 1793 break; 1794 1795 case 157: 1796 ret = min(ret, tcrypt_test("authenc(hmac(sha1),ecb(cipher_null))")); 1797 break; 1798 1799 case 158: 1800 ret = min(ret, tcrypt_test("cbcmac(sm4)")); 1801 break; 1802 1803 case 159: 1804 ret = min(ret, tcrypt_test("cmac(sm4)")); 1805 break; 1806 1807 case 160: 1808 ret = min(ret, tcrypt_test("xcbc(sm4)")); 1809 break; 1810 1811 case 181: 1812 ret = min(ret, tcrypt_test("authenc(hmac(sha1),cbc(des))")); 1813 break; 1814 case 182: 1815 ret = min(ret, tcrypt_test("authenc(hmac(sha1),cbc(des3_ede))")); 1816 break; 1817 case 183: 1818 ret = min(ret, tcrypt_test("authenc(hmac(sha224),cbc(des))")); 1819 break; 1820 case 184: 1821 ret = min(ret, tcrypt_test("authenc(hmac(sha224),cbc(des3_ede))")); 1822 break; 1823 case 185: 1824 ret = min(ret, tcrypt_test("authenc(hmac(sha256),cbc(des))")); 1825 break; 1826 case 186: 1827 ret = min(ret, tcrypt_test("authenc(hmac(sha256),cbc(des3_ede))")); 1828 break; 1829 case 187: 1830 ret = min(ret, tcrypt_test("authenc(hmac(sha384),cbc(des))")); 1831 break; 1832 case 188: 1833 ret = min(ret, tcrypt_test("authenc(hmac(sha384),cbc(des3_ede))")); 1834 break; 1835 case 189: 1836 ret = min(ret, tcrypt_test("authenc(hmac(sha512),cbc(des))")); 1837 break; 1838 case 190: 1839 ret = min(ret, tcrypt_test("authenc(hmac(sha512),cbc(des3_ede))")); 1840 break; 1841 case 191: 1842 ret = min(ret, tcrypt_test("ecb(sm4)")); 1843 ret = min(ret, tcrypt_test("cbc(sm4)")); 1844 ret = min(ret, tcrypt_test("ctr(sm4)")); 1845 ret = min(ret, tcrypt_test("xts(sm4)")); 1846 break; 1847 case 192: 1848 ret = min(ret, tcrypt_test("ecb(aria)")); 1849 ret = min(ret, tcrypt_test("cbc(aria)")); 1850 ret = min(ret, tcrypt_test("ctr(aria)")); 1851 break; 1852 case 193: 1853 ret = min(ret, tcrypt_test("ffdhe2048(dh)")); 1854 break; 1855 case 200: 1856 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0, 1857 speed_template_16_24_32); 1858 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0, 1859 speed_template_16_24_32); 1860 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0, 1861 speed_template_16_24_32); 1862 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0, 1863 speed_template_16_24_32); 1864 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0, 1865 speed_template_32_40_48); 1866 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0, 1867 speed_template_32_40_48); 1868 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0, 1869 speed_template_32_64); 1870 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0, 1871 speed_template_32_64); 1872 test_cipher_speed("cts(cbc(aes))", ENCRYPT, sec, NULL, 0, 1873 speed_template_16_24_32); 1874 test_cipher_speed("cts(cbc(aes))", DECRYPT, sec, NULL, 0, 1875 speed_template_16_24_32); 1876 test_cipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0, 1877 speed_template_16_24_32); 1878 test_cipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0, 1879 speed_template_16_24_32); 1880 break; 1881 1882 case 201: 1883 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec, 1884 des3_speed_template, DES3_SPEED_VECTORS, 1885 speed_template_24); 1886 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec, 1887 des3_speed_template, DES3_SPEED_VECTORS, 1888 speed_template_24); 1889 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec, 1890 des3_speed_template, DES3_SPEED_VECTORS, 1891 speed_template_24); 1892 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec, 1893 des3_speed_template, DES3_SPEED_VECTORS, 1894 speed_template_24); 1895 test_cipher_speed("ctr(des3_ede)", ENCRYPT, sec, 1896 des3_speed_template, DES3_SPEED_VECTORS, 1897 speed_template_24); 1898 test_cipher_speed("ctr(des3_ede)", DECRYPT, sec, 1899 des3_speed_template, DES3_SPEED_VECTORS, 1900 speed_template_24); 1901 break; 1902 1903 case 202: 1904 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0, 1905 speed_template_16_24_32); 1906 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0, 1907 speed_template_16_24_32); 1908 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0, 1909 speed_template_16_24_32); 1910 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0, 1911 speed_template_16_24_32); 1912 test_cipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0, 1913 speed_template_16_24_32); 1914 test_cipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0, 1915 speed_template_16_24_32); 1916 test_cipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0, 1917 speed_template_32_40_48); 1918 test_cipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0, 1919 speed_template_32_40_48); 1920 test_cipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0, 1921 speed_template_32_48_64); 1922 test_cipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0, 1923 speed_template_32_48_64); 1924 break; 1925 1926 case 203: 1927 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0, 1928 speed_template_8_32); 1929 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0, 1930 speed_template_8_32); 1931 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0, 1932 speed_template_8_32); 1933 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0, 1934 speed_template_8_32); 1935 test_cipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0, 1936 speed_template_8_32); 1937 test_cipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0, 1938 speed_template_8_32); 1939 break; 1940 1941 case 204: 1942 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0, 1943 speed_template_8); 1944 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0, 1945 speed_template_8); 1946 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0, 1947 speed_template_8); 1948 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0, 1949 speed_template_8); 1950 break; 1951 1952 case 205: 1953 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0, 1954 speed_template_16_24_32); 1955 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0, 1956 speed_template_16_24_32); 1957 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0, 1958 speed_template_16_24_32); 1959 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0, 1960 speed_template_16_24_32); 1961 test_cipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0, 1962 speed_template_16_24_32); 1963 test_cipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0, 1964 speed_template_16_24_32); 1965 test_cipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0, 1966 speed_template_32_40_48); 1967 test_cipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0, 1968 speed_template_32_40_48); 1969 test_cipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0, 1970 speed_template_32_48_64); 1971 test_cipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0, 1972 speed_template_32_48_64); 1973 break; 1974 1975 case 207: 1976 test_cipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0, 1977 speed_template_16_32); 1978 test_cipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0, 1979 speed_template_16_32); 1980 test_cipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0, 1981 speed_template_16_32); 1982 test_cipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0, 1983 speed_template_16_32); 1984 test_cipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0, 1985 speed_template_16_32); 1986 test_cipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0, 1987 speed_template_16_32); 1988 test_cipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0, 1989 speed_template_32_48); 1990 test_cipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0, 1991 speed_template_32_48); 1992 test_cipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0, 1993 speed_template_32_64); 1994 test_cipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0, 1995 speed_template_32_64); 1996 break; 1997 1998 case 208: 1999 test_cipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0, 2000 speed_template_8); 2001 break; 2002 2003 case 209: 2004 test_cipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0, 2005 speed_template_8_16); 2006 test_cipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0, 2007 speed_template_8_16); 2008 test_cipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0, 2009 speed_template_8_16); 2010 test_cipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0, 2011 speed_template_8_16); 2012 test_cipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0, 2013 speed_template_8_16); 2014 test_cipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0, 2015 speed_template_8_16); 2016 break; 2017 2018 case 210: 2019 test_cipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0, 2020 speed_template_16_32); 2021 test_cipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0, 2022 speed_template_16_32); 2023 test_cipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0, 2024 speed_template_16_32); 2025 test_cipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0, 2026 speed_template_16_32); 2027 test_cipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0, 2028 speed_template_16_32); 2029 test_cipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0, 2030 speed_template_16_32); 2031 test_cipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0, 2032 speed_template_32_48); 2033 test_cipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0, 2034 speed_template_32_48); 2035 test_cipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0, 2036 speed_template_32_64); 2037 test_cipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0, 2038 speed_template_32_64); 2039 break; 2040 2041 case 211: 2042 test_aead_speed("rfc4106(gcm(aes))", ENCRYPT, sec, 2043 NULL, 0, 16, 16, aead_speed_template_20_28_36); 2044 test_aead_speed("gcm(aes)", ENCRYPT, sec, 2045 NULL, 0, 16, 8, speed_template_16_24_32); 2046 test_aead_speed("rfc4106(gcm(aes))", DECRYPT, sec, 2047 NULL, 0, 16, 16, aead_speed_template_20_28_36); 2048 test_aead_speed("gcm(aes)", DECRYPT, sec, 2049 NULL, 0, 16, 8, speed_template_16_24_32); 2050 break; 2051 2052 case 212: 2053 test_aead_speed("rfc4309(ccm(aes))", ENCRYPT, sec, 2054 NULL, 0, 16, 16, aead_speed_template_19); 2055 test_aead_speed("rfc4309(ccm(aes))", DECRYPT, sec, 2056 NULL, 0, 16, 16, aead_speed_template_19); 2057 break; 2058 2059 case 213: 2060 test_aead_speed("rfc7539esp(chacha20,poly1305)", ENCRYPT, sec, 2061 NULL, 0, 16, 8, aead_speed_template_36); 2062 test_aead_speed("rfc7539esp(chacha20,poly1305)", DECRYPT, sec, 2063 NULL, 0, 16, 8, aead_speed_template_36); 2064 break; 2065 2066 case 214: 2067 test_cipher_speed("chacha20", ENCRYPT, sec, NULL, 0, 2068 speed_template_32); 2069 break; 2070 2071 case 215: 2072 test_mb_aead_speed("rfc4106(gcm(aes))", ENCRYPT, sec, NULL, 2073 0, 16, 16, aead_speed_template_20_28_36, num_mb); 2074 test_mb_aead_speed("gcm(aes)", ENCRYPT, sec, NULL, 0, 16, 8, 2075 speed_template_16_24_32, num_mb); 2076 test_mb_aead_speed("rfc4106(gcm(aes))", DECRYPT, sec, NULL, 2077 0, 16, 16, aead_speed_template_20_28_36, num_mb); 2078 test_mb_aead_speed("gcm(aes)", DECRYPT, sec, NULL, 0, 16, 8, 2079 speed_template_16_24_32, num_mb); 2080 break; 2081 2082 case 216: 2083 test_mb_aead_speed("rfc4309(ccm(aes))", ENCRYPT, sec, NULL, 0, 2084 16, 16, aead_speed_template_19, num_mb); 2085 test_mb_aead_speed("rfc4309(ccm(aes))", DECRYPT, sec, NULL, 0, 2086 16, 16, aead_speed_template_19, num_mb); 2087 break; 2088 2089 case 217: 2090 test_mb_aead_speed("rfc7539esp(chacha20,poly1305)", ENCRYPT, 2091 sec, NULL, 0, 16, 8, aead_speed_template_36, 2092 num_mb); 2093 test_mb_aead_speed("rfc7539esp(chacha20,poly1305)", DECRYPT, 2094 sec, NULL, 0, 16, 8, aead_speed_template_36, 2095 num_mb); 2096 break; 2097 2098 case 218: 2099 test_cipher_speed("ecb(sm4)", ENCRYPT, sec, NULL, 0, 2100 speed_template_16); 2101 test_cipher_speed("ecb(sm4)", DECRYPT, sec, NULL, 0, 2102 speed_template_16); 2103 test_cipher_speed("cbc(sm4)", ENCRYPT, sec, NULL, 0, 2104 speed_template_16); 2105 test_cipher_speed("cbc(sm4)", DECRYPT, sec, NULL, 0, 2106 speed_template_16); 2107 test_cipher_speed("cts(cbc(sm4))", ENCRYPT, sec, NULL, 0, 2108 speed_template_16); 2109 test_cipher_speed("cts(cbc(sm4))", DECRYPT, sec, NULL, 0, 2110 speed_template_16); 2111 test_cipher_speed("ctr(sm4)", ENCRYPT, sec, NULL, 0, 2112 speed_template_16); 2113 test_cipher_speed("ctr(sm4)", DECRYPT, sec, NULL, 0, 2114 speed_template_16); 2115 test_cipher_speed("xts(sm4)", ENCRYPT, sec, NULL, 0, 2116 speed_template_32); 2117 test_cipher_speed("xts(sm4)", DECRYPT, sec, NULL, 0, 2118 speed_template_32); 2119 break; 2120 2121 case 219: 2122 test_cipher_speed("adiantum(xchacha12,aes)", ENCRYPT, sec, NULL, 2123 0, speed_template_32); 2124 test_cipher_speed("adiantum(xchacha12,aes)", DECRYPT, sec, NULL, 2125 0, speed_template_32); 2126 test_cipher_speed("adiantum(xchacha20,aes)", ENCRYPT, sec, NULL, 2127 0, speed_template_32); 2128 test_cipher_speed("adiantum(xchacha20,aes)", DECRYPT, sec, NULL, 2129 0, speed_template_32); 2130 break; 2131 2132 case 220: 2133 test_acipher_speed("essiv(cbc(aes),sha256)", 2134 ENCRYPT, sec, NULL, 0, 2135 speed_template_16_24_32); 2136 test_acipher_speed("essiv(cbc(aes),sha256)", 2137 DECRYPT, sec, NULL, 0, 2138 speed_template_16_24_32); 2139 break; 2140 2141 case 221: 2142 test_aead_speed("aegis128", ENCRYPT, sec, 2143 NULL, 0, 16, 8, speed_template_16); 2144 test_aead_speed("aegis128", DECRYPT, sec, 2145 NULL, 0, 16, 8, speed_template_16); 2146 break; 2147 2148 case 222: 2149 test_aead_speed("gcm(sm4)", ENCRYPT, sec, 2150 NULL, 0, 16, 8, speed_template_16); 2151 test_aead_speed("gcm(sm4)", DECRYPT, sec, 2152 NULL, 0, 16, 8, speed_template_16); 2153 break; 2154 2155 case 223: 2156 test_aead_speed("rfc4309(ccm(sm4))", ENCRYPT, sec, 2157 NULL, 0, 16, 16, aead_speed_template_19); 2158 test_aead_speed("rfc4309(ccm(sm4))", DECRYPT, sec, 2159 NULL, 0, 16, 16, aead_speed_template_19); 2160 break; 2161 2162 case 224: 2163 test_mb_aead_speed("gcm(sm4)", ENCRYPT, sec, NULL, 0, 16, 8, 2164 speed_template_16, num_mb); 2165 test_mb_aead_speed("gcm(sm4)", DECRYPT, sec, NULL, 0, 16, 8, 2166 speed_template_16, num_mb); 2167 break; 2168 2169 case 225: 2170 test_mb_aead_speed("rfc4309(ccm(sm4))", ENCRYPT, sec, NULL, 0, 2171 16, 16, aead_speed_template_19, num_mb); 2172 test_mb_aead_speed("rfc4309(ccm(sm4))", DECRYPT, sec, NULL, 0, 2173 16, 16, aead_speed_template_19, num_mb); 2174 break; 2175 2176 case 226: 2177 test_cipher_speed("hctr2(aes)", ENCRYPT, sec, NULL, 2178 0, speed_template_32); 2179 break; 2180 2181 case 227: 2182 test_cipher_speed("ecb(aria)", ENCRYPT, sec, NULL, 0, 2183 speed_template_16_24_32); 2184 test_cipher_speed("ecb(aria)", DECRYPT, sec, NULL, 0, 2185 speed_template_16_24_32); 2186 test_cipher_speed("cbc(aria)", ENCRYPT, sec, NULL, 0, 2187 speed_template_16_24_32); 2188 test_cipher_speed("cbc(aria)", DECRYPT, sec, NULL, 0, 2189 speed_template_16_24_32); 2190 test_cipher_speed("ctr(aria)", ENCRYPT, sec, NULL, 0, 2191 speed_template_16_24_32); 2192 test_cipher_speed("ctr(aria)", DECRYPT, sec, NULL, 0, 2193 speed_template_16_24_32); 2194 break; 2195 2196 case 228: 2197 test_aead_speed("gcm(aria)", ENCRYPT, sec, 2198 NULL, 0, 16, 8, speed_template_16_24_32); 2199 test_aead_speed("gcm(aria)", DECRYPT, sec, 2200 NULL, 0, 16, 8, speed_template_16_24_32); 2201 break; 2202 2203 case 229: 2204 test_mb_aead_speed("gcm(aria)", ENCRYPT, sec, NULL, 0, 16, 8, 2205 speed_template_16, num_mb); 2206 test_mb_aead_speed("gcm(aria)", DECRYPT, sec, NULL, 0, 16, 8, 2207 speed_template_16, num_mb); 2208 break; 2209 2210 case 300: 2211 if (alg) { 2212 test_hash_speed(alg, sec, generic_hash_speed_template); 2213 break; 2214 } 2215 fallthrough; 2216 case 301: 2217 test_hash_speed("md4", sec, generic_hash_speed_template); 2218 if (mode > 300 && mode < 400) break; 2219 fallthrough; 2220 case 302: 2221 test_hash_speed("md5", sec, generic_hash_speed_template); 2222 if (mode > 300 && mode < 400) break; 2223 fallthrough; 2224 case 303: 2225 test_hash_speed("sha1", sec, generic_hash_speed_template); 2226 if (mode > 300 && mode < 400) break; 2227 fallthrough; 2228 case 304: 2229 test_hash_speed("sha256", sec, generic_hash_speed_template); 2230 if (mode > 300 && mode < 400) break; 2231 fallthrough; 2232 case 305: 2233 test_hash_speed("sha384", sec, generic_hash_speed_template); 2234 if (mode > 300 && mode < 400) break; 2235 fallthrough; 2236 case 306: 2237 test_hash_speed("sha512", sec, generic_hash_speed_template); 2238 if (mode > 300 && mode < 400) break; 2239 fallthrough; 2240 case 307: 2241 test_hash_speed("wp256", sec, generic_hash_speed_template); 2242 if (mode > 300 && mode < 400) break; 2243 fallthrough; 2244 case 308: 2245 test_hash_speed("wp384", sec, generic_hash_speed_template); 2246 if (mode > 300 && mode < 400) break; 2247 fallthrough; 2248 case 309: 2249 test_hash_speed("wp512", sec, generic_hash_speed_template); 2250 if (mode > 300 && mode < 400) break; 2251 fallthrough; 2252 case 313: 2253 test_hash_speed("sha224", sec, generic_hash_speed_template); 2254 if (mode > 300 && mode < 400) break; 2255 fallthrough; 2256 case 314: 2257 test_hash_speed("xxhash64", sec, generic_hash_speed_template); 2258 if (mode > 300 && mode < 400) break; 2259 fallthrough; 2260 case 315: 2261 test_hash_speed("rmd160", sec, generic_hash_speed_template); 2262 if (mode > 300 && mode < 400) break; 2263 fallthrough; 2264 case 317: 2265 test_hash_speed("blake2b-512", sec, generic_hash_speed_template); 2266 if (mode > 300 && mode < 400) break; 2267 fallthrough; 2268 case 319: 2269 test_hash_speed("crc32c", sec, generic_hash_speed_template); 2270 if (mode > 300 && mode < 400) break; 2271 fallthrough; 2272 case 322: 2273 test_hash_speed("sha3-224", sec, generic_hash_speed_template); 2274 if (mode > 300 && mode < 400) break; 2275 fallthrough; 2276 case 323: 2277 test_hash_speed("sha3-256", sec, generic_hash_speed_template); 2278 if (mode > 300 && mode < 400) break; 2279 fallthrough; 2280 case 324: 2281 test_hash_speed("sha3-384", sec, generic_hash_speed_template); 2282 if (mode > 300 && mode < 400) break; 2283 fallthrough; 2284 case 325: 2285 test_hash_speed("sha3-512", sec, generic_hash_speed_template); 2286 if (mode > 300 && mode < 400) break; 2287 fallthrough; 2288 case 326: 2289 test_hash_speed("sm3", sec, generic_hash_speed_template); 2290 if (mode > 300 && mode < 400) break; 2291 fallthrough; 2292 case 327: 2293 test_hash_speed("streebog256", sec, 2294 generic_hash_speed_template); 2295 if (mode > 300 && mode < 400) break; 2296 fallthrough; 2297 case 328: 2298 test_hash_speed("streebog512", sec, 2299 generic_hash_speed_template); 2300 if (mode > 300 && mode < 400) break; 2301 fallthrough; 2302 case 399: 2303 break; 2304 2305 case 400: 2306 if (alg) { 2307 test_ahash_speed(alg, sec, generic_hash_speed_template); 2308 break; 2309 } 2310 fallthrough; 2311 case 401: 2312 test_ahash_speed("md4", sec, generic_hash_speed_template); 2313 if (mode > 400 && mode < 500) break; 2314 fallthrough; 2315 case 402: 2316 test_ahash_speed("md5", sec, generic_hash_speed_template); 2317 if (mode > 400 && mode < 500) break; 2318 fallthrough; 2319 case 403: 2320 test_ahash_speed("sha1", sec, generic_hash_speed_template); 2321 if (mode > 400 && mode < 500) break; 2322 fallthrough; 2323 case 404: 2324 test_ahash_speed("sha256", sec, generic_hash_speed_template); 2325 if (mode > 400 && mode < 500) break; 2326 fallthrough; 2327 case 405: 2328 test_ahash_speed("sha384", sec, generic_hash_speed_template); 2329 if (mode > 400 && mode < 500) break; 2330 fallthrough; 2331 case 406: 2332 test_ahash_speed("sha512", sec, generic_hash_speed_template); 2333 if (mode > 400 && mode < 500) break; 2334 fallthrough; 2335 case 407: 2336 test_ahash_speed("wp256", sec, generic_hash_speed_template); 2337 if (mode > 400 && mode < 500) break; 2338 fallthrough; 2339 case 408: 2340 test_ahash_speed("wp384", sec, generic_hash_speed_template); 2341 if (mode > 400 && mode < 500) break; 2342 fallthrough; 2343 case 409: 2344 test_ahash_speed("wp512", sec, generic_hash_speed_template); 2345 if (mode > 400 && mode < 500) break; 2346 fallthrough; 2347 case 413: 2348 test_ahash_speed("sha224", sec, generic_hash_speed_template); 2349 if (mode > 400 && mode < 500) break; 2350 fallthrough; 2351 case 414: 2352 test_ahash_speed("xxhash64", sec, generic_hash_speed_template); 2353 if (mode > 400 && mode < 500) break; 2354 fallthrough; 2355 case 415: 2356 test_ahash_speed("rmd160", sec, generic_hash_speed_template); 2357 if (mode > 400 && mode < 500) break; 2358 fallthrough; 2359 case 417: 2360 test_ahash_speed("blake2b-512", sec, generic_hash_speed_template); 2361 if (mode > 400 && mode < 500) break; 2362 fallthrough; 2363 case 418: 2364 test_ahash_speed("sha3-224", sec, generic_hash_speed_template); 2365 if (mode > 400 && mode < 500) break; 2366 fallthrough; 2367 case 419: 2368 test_ahash_speed("sha3-256", sec, generic_hash_speed_template); 2369 if (mode > 400 && mode < 500) break; 2370 fallthrough; 2371 case 420: 2372 test_ahash_speed("sha3-384", sec, generic_hash_speed_template); 2373 if (mode > 400 && mode < 500) break; 2374 fallthrough; 2375 case 421: 2376 test_ahash_speed("sha3-512", sec, generic_hash_speed_template); 2377 if (mode > 400 && mode < 500) break; 2378 fallthrough; 2379 case 422: 2380 test_ahash_speed("sm3", sec, generic_hash_speed_template); 2381 if (mode > 400 && mode < 500) break; 2382 fallthrough; 2383 case 499: 2384 break; 2385 2386 case 500: 2387 test_acipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0, 2388 speed_template_16_24_32); 2389 test_acipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0, 2390 speed_template_16_24_32); 2391 test_acipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0, 2392 speed_template_16_24_32); 2393 test_acipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0, 2394 speed_template_16_24_32); 2395 test_acipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0, 2396 speed_template_32_40_48); 2397 test_acipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0, 2398 speed_template_32_40_48); 2399 test_acipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0, 2400 speed_template_32_64); 2401 test_acipher_speed("xts(aes)", DECRYPT, sec, NULL, 0, 2402 speed_template_32_64); 2403 test_acipher_speed("cts(cbc(aes))", ENCRYPT, sec, NULL, 0, 2404 speed_template_16_24_32); 2405 test_acipher_speed("cts(cbc(aes))", DECRYPT, sec, NULL, 0, 2406 speed_template_16_24_32); 2407 test_acipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0, 2408 speed_template_16_24_32); 2409 test_acipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0, 2410 speed_template_16_24_32); 2411 test_acipher_speed("rfc3686(ctr(aes))", ENCRYPT, sec, NULL, 0, 2412 speed_template_20_28_36); 2413 test_acipher_speed("rfc3686(ctr(aes))", DECRYPT, sec, NULL, 0, 2414 speed_template_20_28_36); 2415 break; 2416 2417 case 501: 2418 test_acipher_speed("ecb(des3_ede)", ENCRYPT, sec, 2419 des3_speed_template, DES3_SPEED_VECTORS, 2420 speed_template_24); 2421 test_acipher_speed("ecb(des3_ede)", DECRYPT, sec, 2422 des3_speed_template, DES3_SPEED_VECTORS, 2423 speed_template_24); 2424 test_acipher_speed("cbc(des3_ede)", ENCRYPT, sec, 2425 des3_speed_template, DES3_SPEED_VECTORS, 2426 speed_template_24); 2427 test_acipher_speed("cbc(des3_ede)", DECRYPT, sec, 2428 des3_speed_template, DES3_SPEED_VECTORS, 2429 speed_template_24); 2430 break; 2431 2432 case 502: 2433 test_acipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0, 2434 speed_template_8); 2435 test_acipher_speed("ecb(des)", DECRYPT, sec, NULL, 0, 2436 speed_template_8); 2437 test_acipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0, 2438 speed_template_8); 2439 test_acipher_speed("cbc(des)", DECRYPT, sec, NULL, 0, 2440 speed_template_8); 2441 break; 2442 2443 case 503: 2444 test_acipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0, 2445 speed_template_16_32); 2446 test_acipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0, 2447 speed_template_16_32); 2448 test_acipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0, 2449 speed_template_16_32); 2450 test_acipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0, 2451 speed_template_16_32); 2452 test_acipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0, 2453 speed_template_16_32); 2454 test_acipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0, 2455 speed_template_16_32); 2456 test_acipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0, 2457 speed_template_32_48); 2458 test_acipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0, 2459 speed_template_32_48); 2460 test_acipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0, 2461 speed_template_32_64); 2462 test_acipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0, 2463 speed_template_32_64); 2464 break; 2465 2466 case 504: 2467 test_acipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0, 2468 speed_template_16_24_32); 2469 test_acipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0, 2470 speed_template_16_24_32); 2471 test_acipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0, 2472 speed_template_16_24_32); 2473 test_acipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0, 2474 speed_template_16_24_32); 2475 test_acipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0, 2476 speed_template_16_24_32); 2477 test_acipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0, 2478 speed_template_16_24_32); 2479 test_acipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0, 2480 speed_template_32_40_48); 2481 test_acipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0, 2482 speed_template_32_40_48); 2483 test_acipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0, 2484 speed_template_32_48_64); 2485 test_acipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0, 2486 speed_template_32_48_64); 2487 break; 2488 2489 case 505: 2490 test_acipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0, 2491 speed_template_8); 2492 break; 2493 2494 case 506: 2495 test_acipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0, 2496 speed_template_8_16); 2497 test_acipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0, 2498 speed_template_8_16); 2499 test_acipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0, 2500 speed_template_8_16); 2501 test_acipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0, 2502 speed_template_8_16); 2503 test_acipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0, 2504 speed_template_8_16); 2505 test_acipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0, 2506 speed_template_8_16); 2507 break; 2508 2509 case 507: 2510 test_acipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0, 2511 speed_template_16_32); 2512 test_acipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0, 2513 speed_template_16_32); 2514 test_acipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0, 2515 speed_template_16_32); 2516 test_acipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0, 2517 speed_template_16_32); 2518 test_acipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0, 2519 speed_template_16_32); 2520 test_acipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0, 2521 speed_template_16_32); 2522 test_acipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0, 2523 speed_template_32_48); 2524 test_acipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0, 2525 speed_template_32_48); 2526 test_acipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0, 2527 speed_template_32_64); 2528 test_acipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0, 2529 speed_template_32_64); 2530 break; 2531 2532 case 508: 2533 test_acipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0, 2534 speed_template_16_32); 2535 test_acipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0, 2536 speed_template_16_32); 2537 test_acipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0, 2538 speed_template_16_32); 2539 test_acipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0, 2540 speed_template_16_32); 2541 test_acipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0, 2542 speed_template_16_32); 2543 test_acipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0, 2544 speed_template_16_32); 2545 test_acipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0, 2546 speed_template_32_48); 2547 test_acipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0, 2548 speed_template_32_48); 2549 test_acipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0, 2550 speed_template_32_64); 2551 test_acipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0, 2552 speed_template_32_64); 2553 break; 2554 2555 case 509: 2556 test_acipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0, 2557 speed_template_8_32); 2558 test_acipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0, 2559 speed_template_8_32); 2560 test_acipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0, 2561 speed_template_8_32); 2562 test_acipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0, 2563 speed_template_8_32); 2564 test_acipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0, 2565 speed_template_8_32); 2566 test_acipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0, 2567 speed_template_8_32); 2568 break; 2569 2570 case 518: 2571 test_acipher_speed("ecb(sm4)", ENCRYPT, sec, NULL, 0, 2572 speed_template_16); 2573 test_acipher_speed("ecb(sm4)", DECRYPT, sec, NULL, 0, 2574 speed_template_16); 2575 test_acipher_speed("cbc(sm4)", ENCRYPT, sec, NULL, 0, 2576 speed_template_16); 2577 test_acipher_speed("cbc(sm4)", DECRYPT, sec, NULL, 0, 2578 speed_template_16); 2579 test_acipher_speed("ctr(sm4)", ENCRYPT, sec, NULL, 0, 2580 speed_template_16); 2581 test_acipher_speed("ctr(sm4)", DECRYPT, sec, NULL, 0, 2582 speed_template_16); 2583 test_acipher_speed("xts(sm4)", ENCRYPT, sec, NULL, 0, 2584 speed_template_32); 2585 test_acipher_speed("xts(sm4)", DECRYPT, sec, NULL, 0, 2586 speed_template_32); 2587 break; 2588 2589 case 519: 2590 test_acipher_speed("ecb(aria)", ENCRYPT, sec, NULL, 0, 2591 speed_template_16_24_32); 2592 test_acipher_speed("ecb(aria)", DECRYPT, sec, NULL, 0, 2593 speed_template_16_24_32); 2594 test_acipher_speed("ctr(aria)", ENCRYPT, sec, NULL, 0, 2595 speed_template_16_24_32); 2596 test_acipher_speed("ctr(aria)", DECRYPT, sec, NULL, 0, 2597 speed_template_16_24_32); 2598 break; 2599 2600 case 600: 2601 if (alg) { 2602 u8 speed_template[2] = {klen, 0}; 2603 test_mb_skcipher_speed(alg, ENCRYPT, sec, NULL, 0, 2604 speed_template, num_mb); 2605 test_mb_skcipher_speed(alg, DECRYPT, sec, NULL, 0, 2606 speed_template, num_mb); 2607 break; 2608 } 2609 2610 test_mb_skcipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0, 2611 speed_template_16_24_32, num_mb); 2612 test_mb_skcipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0, 2613 speed_template_16_24_32, num_mb); 2614 test_mb_skcipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0, 2615 speed_template_16_24_32, num_mb); 2616 test_mb_skcipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0, 2617 speed_template_16_24_32, num_mb); 2618 test_mb_skcipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0, 2619 speed_template_32_40_48, num_mb); 2620 test_mb_skcipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0, 2621 speed_template_32_40_48, num_mb); 2622 test_mb_skcipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0, 2623 speed_template_32_64, num_mb); 2624 test_mb_skcipher_speed("xts(aes)", DECRYPT, sec, NULL, 0, 2625 speed_template_32_64, num_mb); 2626 test_mb_skcipher_speed("cts(cbc(aes))", ENCRYPT, sec, NULL, 0, 2627 speed_template_16_24_32, num_mb); 2628 test_mb_skcipher_speed("cts(cbc(aes))", DECRYPT, sec, NULL, 0, 2629 speed_template_16_24_32, num_mb); 2630 test_mb_skcipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0, 2631 speed_template_16_24_32, num_mb); 2632 test_mb_skcipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0, 2633 speed_template_16_24_32, num_mb); 2634 test_mb_skcipher_speed("rfc3686(ctr(aes))", ENCRYPT, sec, NULL, 2635 0, speed_template_20_28_36, num_mb); 2636 test_mb_skcipher_speed("rfc3686(ctr(aes))", DECRYPT, sec, NULL, 2637 0, speed_template_20_28_36, num_mb); 2638 break; 2639 2640 case 601: 2641 test_mb_skcipher_speed("ecb(des3_ede)", ENCRYPT, sec, 2642 des3_speed_template, DES3_SPEED_VECTORS, 2643 speed_template_24, num_mb); 2644 test_mb_skcipher_speed("ecb(des3_ede)", DECRYPT, sec, 2645 des3_speed_template, DES3_SPEED_VECTORS, 2646 speed_template_24, num_mb); 2647 test_mb_skcipher_speed("cbc(des3_ede)", ENCRYPT, sec, 2648 des3_speed_template, DES3_SPEED_VECTORS, 2649 speed_template_24, num_mb); 2650 test_mb_skcipher_speed("cbc(des3_ede)", DECRYPT, sec, 2651 des3_speed_template, DES3_SPEED_VECTORS, 2652 speed_template_24, num_mb); 2653 break; 2654 2655 case 602: 2656 test_mb_skcipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0, 2657 speed_template_8, num_mb); 2658 test_mb_skcipher_speed("ecb(des)", DECRYPT, sec, NULL, 0, 2659 speed_template_8, num_mb); 2660 test_mb_skcipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0, 2661 speed_template_8, num_mb); 2662 test_mb_skcipher_speed("cbc(des)", DECRYPT, sec, NULL, 0, 2663 speed_template_8, num_mb); 2664 break; 2665 2666 case 603: 2667 test_mb_skcipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0, 2668 speed_template_16_32, num_mb); 2669 test_mb_skcipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0, 2670 speed_template_16_32, num_mb); 2671 test_mb_skcipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0, 2672 speed_template_16_32, num_mb); 2673 test_mb_skcipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0, 2674 speed_template_16_32, num_mb); 2675 test_mb_skcipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0, 2676 speed_template_16_32, num_mb); 2677 test_mb_skcipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0, 2678 speed_template_16_32, num_mb); 2679 test_mb_skcipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0, 2680 speed_template_32_48, num_mb); 2681 test_mb_skcipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0, 2682 speed_template_32_48, num_mb); 2683 test_mb_skcipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0, 2684 speed_template_32_64, num_mb); 2685 test_mb_skcipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0, 2686 speed_template_32_64, num_mb); 2687 break; 2688 2689 case 604: 2690 test_mb_skcipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0, 2691 speed_template_16_24_32, num_mb); 2692 test_mb_skcipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0, 2693 speed_template_16_24_32, num_mb); 2694 test_mb_skcipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0, 2695 speed_template_16_24_32, num_mb); 2696 test_mb_skcipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0, 2697 speed_template_16_24_32, num_mb); 2698 test_mb_skcipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0, 2699 speed_template_16_24_32, num_mb); 2700 test_mb_skcipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0, 2701 speed_template_16_24_32, num_mb); 2702 test_mb_skcipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0, 2703 speed_template_32_40_48, num_mb); 2704 test_mb_skcipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0, 2705 speed_template_32_40_48, num_mb); 2706 test_mb_skcipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0, 2707 speed_template_32_48_64, num_mb); 2708 test_mb_skcipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0, 2709 speed_template_32_48_64, num_mb); 2710 break; 2711 2712 case 605: 2713 test_mb_skcipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0, 2714 speed_template_8, num_mb); 2715 break; 2716 2717 case 606: 2718 test_mb_skcipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0, 2719 speed_template_8_16, num_mb); 2720 test_mb_skcipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0, 2721 speed_template_8_16, num_mb); 2722 test_mb_skcipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0, 2723 speed_template_8_16, num_mb); 2724 test_mb_skcipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0, 2725 speed_template_8_16, num_mb); 2726 test_mb_skcipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0, 2727 speed_template_8_16, num_mb); 2728 test_mb_skcipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0, 2729 speed_template_8_16, num_mb); 2730 break; 2731 2732 case 607: 2733 test_mb_skcipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0, 2734 speed_template_16_32, num_mb); 2735 test_mb_skcipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0, 2736 speed_template_16_32, num_mb); 2737 test_mb_skcipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0, 2738 speed_template_16_32, num_mb); 2739 test_mb_skcipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0, 2740 speed_template_16_32, num_mb); 2741 test_mb_skcipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0, 2742 speed_template_16_32, num_mb); 2743 test_mb_skcipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0, 2744 speed_template_16_32, num_mb); 2745 test_mb_skcipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0, 2746 speed_template_32_48, num_mb); 2747 test_mb_skcipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0, 2748 speed_template_32_48, num_mb); 2749 test_mb_skcipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0, 2750 speed_template_32_64, num_mb); 2751 test_mb_skcipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0, 2752 speed_template_32_64, num_mb); 2753 break; 2754 2755 case 608: 2756 test_mb_skcipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0, 2757 speed_template_16_32, num_mb); 2758 test_mb_skcipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0, 2759 speed_template_16_32, num_mb); 2760 test_mb_skcipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0, 2761 speed_template_16_32, num_mb); 2762 test_mb_skcipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0, 2763 speed_template_16_32, num_mb); 2764 test_mb_skcipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0, 2765 speed_template_16_32, num_mb); 2766 test_mb_skcipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0, 2767 speed_template_16_32, num_mb); 2768 test_mb_skcipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0, 2769 speed_template_32_48, num_mb); 2770 test_mb_skcipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0, 2771 speed_template_32_48, num_mb); 2772 test_mb_skcipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0, 2773 speed_template_32_64, num_mb); 2774 test_mb_skcipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0, 2775 speed_template_32_64, num_mb); 2776 break; 2777 2778 case 609: 2779 test_mb_skcipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0, 2780 speed_template_8_32, num_mb); 2781 test_mb_skcipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0, 2782 speed_template_8_32, num_mb); 2783 test_mb_skcipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0, 2784 speed_template_8_32, num_mb); 2785 test_mb_skcipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0, 2786 speed_template_8_32, num_mb); 2787 test_mb_skcipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0, 2788 speed_template_8_32, num_mb); 2789 test_mb_skcipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0, 2790 speed_template_8_32, num_mb); 2791 break; 2792 2793 case 610: 2794 test_mb_skcipher_speed("ecb(aria)", ENCRYPT, sec, NULL, 0, 2795 speed_template_16_32, num_mb); 2796 test_mb_skcipher_speed("ecb(aria)", DECRYPT, sec, NULL, 0, 2797 speed_template_16_32, num_mb); 2798 test_mb_skcipher_speed("ctr(aria)", ENCRYPT, sec, NULL, 0, 2799 speed_template_16_32, num_mb); 2800 test_mb_skcipher_speed("ctr(aria)", DECRYPT, sec, NULL, 0, 2801 speed_template_16_32, num_mb); 2802 break; 2803 2804 } 2805 2806 return ret; 2807 } 2808 2809 static int __init tcrypt_mod_init(void) 2810 { 2811 int err = -ENOMEM; 2812 int i; 2813 2814 for (i = 0; i < TVMEMSIZE; i++) { 2815 tvmem[i] = (void *)__get_free_page(GFP_KERNEL); 2816 if (!tvmem[i]) 2817 goto err_free_tv; 2818 } 2819 2820 if (!num_mb) { 2821 pr_warn("num_mb must be at least 1; forcing to 1\n"); 2822 num_mb = 1; 2823 } 2824 2825 err = do_test(alg, type, mask, mode, num_mb); 2826 2827 if (err) { 2828 pr_err("one or more tests failed!\n"); 2829 goto err_free_tv; 2830 } else { 2831 pr_debug("all tests passed\n"); 2832 } 2833 2834 /* We intentionally return -EAGAIN to prevent keeping the module, 2835 * unless we're running in fips mode. It does all its work from 2836 * init() and doesn't offer any runtime functionality, but in 2837 * the fips case, checking for a successful load is helpful. 2838 * => we don't need it in the memory, do we? 2839 * -- mludvig 2840 */ 2841 if (!fips_enabled) 2842 err = -EAGAIN; 2843 2844 err_free_tv: 2845 for (i = 0; i < TVMEMSIZE && tvmem[i]; i++) 2846 free_page((unsigned long)tvmem[i]); 2847 2848 return err; 2849 } 2850 2851 /* 2852 * If an init function is provided, an exit function must also be provided 2853 * to allow module unload. 2854 */ 2855 static void __exit tcrypt_mod_fini(void) { } 2856 2857 late_initcall(tcrypt_mod_init); 2858 module_exit(tcrypt_mod_fini); 2859 2860 module_param(alg, charp, 0); 2861 module_param(type, uint, 0); 2862 module_param(mask, uint, 0); 2863 module_param(mode, int, 0); 2864 module_param(sec, uint, 0); 2865 MODULE_PARM_DESC(sec, "Length in seconds of speed tests " 2866 "(defaults to zero which uses CPU cycles instead)"); 2867 module_param(num_mb, uint, 0000); 2868 MODULE_PARM_DESC(num_mb, "Number of concurrent requests to be used in mb speed tests (defaults to 8)"); 2869 module_param(klen, uint, 0); 2870 MODULE_PARM_DESC(klen, "Key length (defaults to 0)"); 2871 2872 MODULE_LICENSE("GPL"); 2873 MODULE_DESCRIPTION("Quick & dirty crypto benchmarking module"); 2874 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>"); 2875