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