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