1 /* 2 * Algorithm testing framework and tests. 3 * 4 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au> 5 * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org> 6 * Copyright (c) 2007 Nokia Siemens Networks 7 * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au> 8 * 9 * Updated RFC4106 AES-GCM testing. 10 * Authors: Aidan O'Mahony (aidan.o.mahony@intel.com) 11 * Adrian Hoban <adrian.hoban@intel.com> 12 * Gabriele Paoloni <gabriele.paoloni@intel.com> 13 * Tadeusz Struk (tadeusz.struk@intel.com) 14 * Copyright (c) 2010, Intel Corporation. 15 * 16 * This program is free software; you can redistribute it and/or modify it 17 * under the terms of the GNU General Public License as published by the Free 18 * Software Foundation; either version 2 of the License, or (at your option) 19 * any later version. 20 * 21 */ 22 23 #include <crypto/hash.h> 24 #include <linux/err.h> 25 #include <linux/module.h> 26 #include <linux/scatterlist.h> 27 #include <linux/slab.h> 28 #include <linux/string.h> 29 #include <crypto/rng.h> 30 31 #include "internal.h" 32 33 #ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS 34 35 /* a perfect nop */ 36 int alg_test(const char *driver, const char *alg, u32 type, u32 mask) 37 { 38 return 0; 39 } 40 41 #else 42 43 #include "testmgr.h" 44 45 /* 46 * Need slab memory for testing (size in number of pages). 47 */ 48 #define XBUFSIZE 8 49 50 /* 51 * Indexes into the xbuf to simulate cross-page access. 52 */ 53 #define IDX1 32 54 #define IDX2 32400 55 #define IDX3 1 56 #define IDX4 8193 57 #define IDX5 22222 58 #define IDX6 17101 59 #define IDX7 27333 60 #define IDX8 3000 61 62 /* 63 * Used by test_cipher() 64 */ 65 #define ENCRYPT 1 66 #define DECRYPT 0 67 68 struct tcrypt_result { 69 struct completion completion; 70 int err; 71 }; 72 73 struct aead_test_suite { 74 struct { 75 struct aead_testvec *vecs; 76 unsigned int count; 77 } enc, dec; 78 }; 79 80 struct cipher_test_suite { 81 struct { 82 struct cipher_testvec *vecs; 83 unsigned int count; 84 } enc, dec; 85 }; 86 87 struct comp_test_suite { 88 struct { 89 struct comp_testvec *vecs; 90 unsigned int count; 91 } comp, decomp; 92 }; 93 94 struct pcomp_test_suite { 95 struct { 96 struct pcomp_testvec *vecs; 97 unsigned int count; 98 } comp, decomp; 99 }; 100 101 struct hash_test_suite { 102 struct hash_testvec *vecs; 103 unsigned int count; 104 }; 105 106 struct cprng_test_suite { 107 struct cprng_testvec *vecs; 108 unsigned int count; 109 }; 110 111 struct alg_test_desc { 112 const char *alg; 113 int (*test)(const struct alg_test_desc *desc, const char *driver, 114 u32 type, u32 mask); 115 int fips_allowed; /* set if alg is allowed in fips mode */ 116 117 union { 118 struct aead_test_suite aead; 119 struct cipher_test_suite cipher; 120 struct comp_test_suite comp; 121 struct pcomp_test_suite pcomp; 122 struct hash_test_suite hash; 123 struct cprng_test_suite cprng; 124 } suite; 125 }; 126 127 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 }; 128 129 static void hexdump(unsigned char *buf, unsigned int len) 130 { 131 print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET, 132 16, 1, 133 buf, len, false); 134 } 135 136 static void tcrypt_complete(struct crypto_async_request *req, int err) 137 { 138 struct tcrypt_result *res = req->data; 139 140 if (err == -EINPROGRESS) 141 return; 142 143 res->err = err; 144 complete(&res->completion); 145 } 146 147 static int testmgr_alloc_buf(char *buf[XBUFSIZE]) 148 { 149 int i; 150 151 for (i = 0; i < XBUFSIZE; i++) { 152 buf[i] = (void *)__get_free_page(GFP_KERNEL); 153 if (!buf[i]) 154 goto err_free_buf; 155 } 156 157 return 0; 158 159 err_free_buf: 160 while (i-- > 0) 161 free_page((unsigned long)buf[i]); 162 163 return -ENOMEM; 164 } 165 166 static void testmgr_free_buf(char *buf[XBUFSIZE]) 167 { 168 int i; 169 170 for (i = 0; i < XBUFSIZE; i++) 171 free_page((unsigned long)buf[i]); 172 } 173 174 static int do_one_async_hash_op(struct ahash_request *req, 175 struct tcrypt_result *tr, 176 int ret) 177 { 178 if (ret == -EINPROGRESS || ret == -EBUSY) { 179 ret = wait_for_completion_interruptible(&tr->completion); 180 if (!ret) 181 ret = tr->err; 182 reinit_completion(&tr->completion); 183 } 184 return ret; 185 } 186 187 static int __test_hash(struct crypto_ahash *tfm, struct hash_testvec *template, 188 unsigned int tcount, bool use_digest, 189 const int align_offset) 190 { 191 const char *algo = crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm)); 192 unsigned int i, j, k, temp; 193 struct scatterlist sg[8]; 194 char result[64]; 195 struct ahash_request *req; 196 struct tcrypt_result tresult; 197 void *hash_buff; 198 char *xbuf[XBUFSIZE]; 199 int ret = -ENOMEM; 200 201 if (testmgr_alloc_buf(xbuf)) 202 goto out_nobuf; 203 204 init_completion(&tresult.completion); 205 206 req = ahash_request_alloc(tfm, GFP_KERNEL); 207 if (!req) { 208 printk(KERN_ERR "alg: hash: Failed to allocate request for " 209 "%s\n", algo); 210 goto out_noreq; 211 } 212 ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 213 tcrypt_complete, &tresult); 214 215 j = 0; 216 for (i = 0; i < tcount; i++) { 217 if (template[i].np) 218 continue; 219 220 ret = -EINVAL; 221 if (WARN_ON(align_offset + template[i].psize > PAGE_SIZE)) 222 goto out; 223 224 j++; 225 memset(result, 0, 64); 226 227 hash_buff = xbuf[0]; 228 hash_buff += align_offset; 229 230 memcpy(hash_buff, template[i].plaintext, template[i].psize); 231 sg_init_one(&sg[0], hash_buff, template[i].psize); 232 233 if (template[i].ksize) { 234 crypto_ahash_clear_flags(tfm, ~0); 235 ret = crypto_ahash_setkey(tfm, template[i].key, 236 template[i].ksize); 237 if (ret) { 238 printk(KERN_ERR "alg: hash: setkey failed on " 239 "test %d for %s: ret=%d\n", j, algo, 240 -ret); 241 goto out; 242 } 243 } 244 245 ahash_request_set_crypt(req, sg, result, template[i].psize); 246 if (use_digest) { 247 ret = do_one_async_hash_op(req, &tresult, 248 crypto_ahash_digest(req)); 249 if (ret) { 250 pr_err("alg: hash: digest failed on test %d " 251 "for %s: ret=%d\n", j, algo, -ret); 252 goto out; 253 } 254 } else { 255 ret = do_one_async_hash_op(req, &tresult, 256 crypto_ahash_init(req)); 257 if (ret) { 258 pr_err("alt: hash: init failed on test %d " 259 "for %s: ret=%d\n", j, algo, -ret); 260 goto out; 261 } 262 ret = do_one_async_hash_op(req, &tresult, 263 crypto_ahash_update(req)); 264 if (ret) { 265 pr_err("alt: hash: update failed on test %d " 266 "for %s: ret=%d\n", j, algo, -ret); 267 goto out; 268 } 269 ret = do_one_async_hash_op(req, &tresult, 270 crypto_ahash_final(req)); 271 if (ret) { 272 pr_err("alt: hash: final failed on test %d " 273 "for %s: ret=%d\n", j, algo, -ret); 274 goto out; 275 } 276 } 277 278 if (memcmp(result, template[i].digest, 279 crypto_ahash_digestsize(tfm))) { 280 printk(KERN_ERR "alg: hash: Test %d failed for %s\n", 281 j, algo); 282 hexdump(result, crypto_ahash_digestsize(tfm)); 283 ret = -EINVAL; 284 goto out; 285 } 286 } 287 288 j = 0; 289 for (i = 0; i < tcount; i++) { 290 /* alignment tests are only done with continuous buffers */ 291 if (align_offset != 0) 292 break; 293 294 if (template[i].np) { 295 j++; 296 memset(result, 0, 64); 297 298 temp = 0; 299 sg_init_table(sg, template[i].np); 300 ret = -EINVAL; 301 for (k = 0; k < template[i].np; k++) { 302 if (WARN_ON(offset_in_page(IDX[k]) + 303 template[i].tap[k] > PAGE_SIZE)) 304 goto out; 305 sg_set_buf(&sg[k], 306 memcpy(xbuf[IDX[k] >> PAGE_SHIFT] + 307 offset_in_page(IDX[k]), 308 template[i].plaintext + temp, 309 template[i].tap[k]), 310 template[i].tap[k]); 311 temp += template[i].tap[k]; 312 } 313 314 if (template[i].ksize) { 315 crypto_ahash_clear_flags(tfm, ~0); 316 ret = crypto_ahash_setkey(tfm, template[i].key, 317 template[i].ksize); 318 319 if (ret) { 320 printk(KERN_ERR "alg: hash: setkey " 321 "failed on chunking test %d " 322 "for %s: ret=%d\n", j, algo, 323 -ret); 324 goto out; 325 } 326 } 327 328 ahash_request_set_crypt(req, sg, result, 329 template[i].psize); 330 ret = crypto_ahash_digest(req); 331 switch (ret) { 332 case 0: 333 break; 334 case -EINPROGRESS: 335 case -EBUSY: 336 ret = wait_for_completion_interruptible( 337 &tresult.completion); 338 if (!ret && !(ret = tresult.err)) { 339 reinit_completion(&tresult.completion); 340 break; 341 } 342 /* fall through */ 343 default: 344 printk(KERN_ERR "alg: hash: digest failed " 345 "on chunking test %d for %s: " 346 "ret=%d\n", j, algo, -ret); 347 goto out; 348 } 349 350 if (memcmp(result, template[i].digest, 351 crypto_ahash_digestsize(tfm))) { 352 printk(KERN_ERR "alg: hash: Chunking test %d " 353 "failed for %s\n", j, algo); 354 hexdump(result, crypto_ahash_digestsize(tfm)); 355 ret = -EINVAL; 356 goto out; 357 } 358 } 359 } 360 361 ret = 0; 362 363 out: 364 ahash_request_free(req); 365 out_noreq: 366 testmgr_free_buf(xbuf); 367 out_nobuf: 368 return ret; 369 } 370 371 static int test_hash(struct crypto_ahash *tfm, struct hash_testvec *template, 372 unsigned int tcount, bool use_digest) 373 { 374 unsigned int alignmask; 375 int ret; 376 377 ret = __test_hash(tfm, template, tcount, use_digest, 0); 378 if (ret) 379 return ret; 380 381 /* test unaligned buffers, check with one byte offset */ 382 ret = __test_hash(tfm, template, tcount, use_digest, 1); 383 if (ret) 384 return ret; 385 386 alignmask = crypto_tfm_alg_alignmask(&tfm->base); 387 if (alignmask) { 388 /* Check if alignment mask for tfm is correctly set. */ 389 ret = __test_hash(tfm, template, tcount, use_digest, 390 alignmask + 1); 391 if (ret) 392 return ret; 393 } 394 395 return 0; 396 } 397 398 static int __test_aead(struct crypto_aead *tfm, int enc, 399 struct aead_testvec *template, unsigned int tcount, 400 const bool diff_dst, const int align_offset) 401 { 402 const char *algo = crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm)); 403 unsigned int i, j, k, n, temp; 404 int ret = -ENOMEM; 405 char *q; 406 char *key; 407 struct aead_request *req; 408 struct scatterlist *sg; 409 struct scatterlist *asg; 410 struct scatterlist *sgout; 411 const char *e, *d; 412 struct tcrypt_result result; 413 unsigned int authsize; 414 void *input; 415 void *output; 416 void *assoc; 417 char iv[MAX_IVLEN]; 418 char *xbuf[XBUFSIZE]; 419 char *xoutbuf[XBUFSIZE]; 420 char *axbuf[XBUFSIZE]; 421 422 if (testmgr_alloc_buf(xbuf)) 423 goto out_noxbuf; 424 if (testmgr_alloc_buf(axbuf)) 425 goto out_noaxbuf; 426 427 if (diff_dst && testmgr_alloc_buf(xoutbuf)) 428 goto out_nooutbuf; 429 430 /* avoid "the frame size is larger than 1024 bytes" compiler warning */ 431 sg = kmalloc(sizeof(*sg) * 8 * (diff_dst ? 3 : 2), GFP_KERNEL); 432 if (!sg) 433 goto out_nosg; 434 asg = &sg[8]; 435 sgout = &asg[8]; 436 437 if (diff_dst) 438 d = "-ddst"; 439 else 440 d = ""; 441 442 if (enc == ENCRYPT) 443 e = "encryption"; 444 else 445 e = "decryption"; 446 447 init_completion(&result.completion); 448 449 req = aead_request_alloc(tfm, GFP_KERNEL); 450 if (!req) { 451 pr_err("alg: aead%s: Failed to allocate request for %s\n", 452 d, algo); 453 goto out; 454 } 455 456 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 457 tcrypt_complete, &result); 458 459 for (i = 0, j = 0; i < tcount; i++) { 460 if (!template[i].np) { 461 j++; 462 463 /* some templates have no input data but they will 464 * touch input 465 */ 466 input = xbuf[0]; 467 input += align_offset; 468 assoc = axbuf[0]; 469 470 ret = -EINVAL; 471 if (WARN_ON(align_offset + template[i].ilen > 472 PAGE_SIZE || template[i].alen > PAGE_SIZE)) 473 goto out; 474 475 memcpy(input, template[i].input, template[i].ilen); 476 memcpy(assoc, template[i].assoc, template[i].alen); 477 if (template[i].iv) 478 memcpy(iv, template[i].iv, MAX_IVLEN); 479 else 480 memset(iv, 0, MAX_IVLEN); 481 482 crypto_aead_clear_flags(tfm, ~0); 483 if (template[i].wk) 484 crypto_aead_set_flags( 485 tfm, CRYPTO_TFM_REQ_WEAK_KEY); 486 487 key = template[i].key; 488 489 ret = crypto_aead_setkey(tfm, key, 490 template[i].klen); 491 if (!ret == template[i].fail) { 492 pr_err("alg: aead%s: setkey failed on test %d for %s: flags=%x\n", 493 d, j, algo, crypto_aead_get_flags(tfm)); 494 goto out; 495 } else if (ret) 496 continue; 497 498 authsize = abs(template[i].rlen - template[i].ilen); 499 ret = crypto_aead_setauthsize(tfm, authsize); 500 if (ret) { 501 pr_err("alg: aead%s: Failed to set authsize to %u on test %d for %s\n", 502 d, authsize, j, algo); 503 goto out; 504 } 505 506 if (diff_dst) { 507 output = xoutbuf[0]; 508 output += align_offset; 509 sg_init_one(&sg[0], input, template[i].ilen); 510 sg_init_one(&sgout[0], output, 511 template[i].rlen); 512 } else { 513 sg_init_one(&sg[0], input, 514 template[i].ilen + 515 (enc ? authsize : 0)); 516 output = input; 517 } 518 519 sg_init_one(&asg[0], assoc, template[i].alen); 520 521 aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg, 522 template[i].ilen, iv); 523 524 aead_request_set_assoc(req, asg, template[i].alen); 525 526 ret = enc ? 527 crypto_aead_encrypt(req) : 528 crypto_aead_decrypt(req); 529 530 switch (ret) { 531 case 0: 532 if (template[i].novrfy) { 533 /* verification was supposed to fail */ 534 pr_err("alg: aead%s: %s failed on test %d for %s: ret was 0, expected -EBADMSG\n", 535 d, e, j, algo); 536 /* so really, we got a bad message */ 537 ret = -EBADMSG; 538 goto out; 539 } 540 break; 541 case -EINPROGRESS: 542 case -EBUSY: 543 ret = wait_for_completion_interruptible( 544 &result.completion); 545 if (!ret && !(ret = result.err)) { 546 reinit_completion(&result.completion); 547 break; 548 } 549 case -EBADMSG: 550 if (template[i].novrfy) 551 /* verification failure was expected */ 552 continue; 553 /* fall through */ 554 default: 555 pr_err("alg: aead%s: %s failed on test %d for %s: ret=%d\n", 556 d, e, j, algo, -ret); 557 goto out; 558 } 559 560 q = output; 561 if (memcmp(q, template[i].result, template[i].rlen)) { 562 pr_err("alg: aead%s: Test %d failed on %s for %s\n", 563 d, j, e, algo); 564 hexdump(q, template[i].rlen); 565 ret = -EINVAL; 566 goto out; 567 } 568 } 569 } 570 571 for (i = 0, j = 0; i < tcount; i++) { 572 /* alignment tests are only done with continuous buffers */ 573 if (align_offset != 0) 574 break; 575 576 if (template[i].np) { 577 j++; 578 579 if (template[i].iv) 580 memcpy(iv, template[i].iv, MAX_IVLEN); 581 else 582 memset(iv, 0, MAX_IVLEN); 583 584 crypto_aead_clear_flags(tfm, ~0); 585 if (template[i].wk) 586 crypto_aead_set_flags( 587 tfm, CRYPTO_TFM_REQ_WEAK_KEY); 588 key = template[i].key; 589 590 ret = crypto_aead_setkey(tfm, key, template[i].klen); 591 if (!ret == template[i].fail) { 592 pr_err("alg: aead%s: setkey failed on chunk test %d for %s: flags=%x\n", 593 d, j, algo, crypto_aead_get_flags(tfm)); 594 goto out; 595 } else if (ret) 596 continue; 597 598 authsize = abs(template[i].rlen - template[i].ilen); 599 600 ret = -EINVAL; 601 sg_init_table(sg, template[i].np); 602 if (diff_dst) 603 sg_init_table(sgout, template[i].np); 604 for (k = 0, temp = 0; k < template[i].np; k++) { 605 if (WARN_ON(offset_in_page(IDX[k]) + 606 template[i].tap[k] > PAGE_SIZE)) 607 goto out; 608 609 q = xbuf[IDX[k] >> PAGE_SHIFT] + 610 offset_in_page(IDX[k]); 611 612 memcpy(q, template[i].input + temp, 613 template[i].tap[k]); 614 615 sg_set_buf(&sg[k], q, template[i].tap[k]); 616 617 if (diff_dst) { 618 q = xoutbuf[IDX[k] >> PAGE_SHIFT] + 619 offset_in_page(IDX[k]); 620 621 memset(q, 0, template[i].tap[k]); 622 623 sg_set_buf(&sgout[k], q, 624 template[i].tap[k]); 625 } 626 627 n = template[i].tap[k]; 628 if (k == template[i].np - 1 && enc) 629 n += authsize; 630 if (offset_in_page(q) + n < PAGE_SIZE) 631 q[n] = 0; 632 633 temp += template[i].tap[k]; 634 } 635 636 ret = crypto_aead_setauthsize(tfm, authsize); 637 if (ret) { 638 pr_err("alg: aead%s: Failed to set authsize to %u on chunk test %d for %s\n", 639 d, authsize, j, algo); 640 goto out; 641 } 642 643 if (enc) { 644 if (WARN_ON(sg[k - 1].offset + 645 sg[k - 1].length + authsize > 646 PAGE_SIZE)) { 647 ret = -EINVAL; 648 goto out; 649 } 650 651 if (diff_dst) 652 sgout[k - 1].length += authsize; 653 else 654 sg[k - 1].length += authsize; 655 } 656 657 sg_init_table(asg, template[i].anp); 658 ret = -EINVAL; 659 for (k = 0, temp = 0; k < template[i].anp; k++) { 660 if (WARN_ON(offset_in_page(IDX[k]) + 661 template[i].atap[k] > PAGE_SIZE)) 662 goto out; 663 sg_set_buf(&asg[k], 664 memcpy(axbuf[IDX[k] >> PAGE_SHIFT] + 665 offset_in_page(IDX[k]), 666 template[i].assoc + temp, 667 template[i].atap[k]), 668 template[i].atap[k]); 669 temp += template[i].atap[k]; 670 } 671 672 aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg, 673 template[i].ilen, 674 iv); 675 676 aead_request_set_assoc(req, asg, template[i].alen); 677 678 ret = enc ? 679 crypto_aead_encrypt(req) : 680 crypto_aead_decrypt(req); 681 682 switch (ret) { 683 case 0: 684 if (template[i].novrfy) { 685 /* verification was supposed to fail */ 686 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret was 0, expected -EBADMSG\n", 687 d, e, j, algo); 688 /* so really, we got a bad message */ 689 ret = -EBADMSG; 690 goto out; 691 } 692 break; 693 case -EINPROGRESS: 694 case -EBUSY: 695 ret = wait_for_completion_interruptible( 696 &result.completion); 697 if (!ret && !(ret = result.err)) { 698 reinit_completion(&result.completion); 699 break; 700 } 701 case -EBADMSG: 702 if (template[i].novrfy) 703 /* verification failure was expected */ 704 continue; 705 /* fall through */ 706 default: 707 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret=%d\n", 708 d, e, j, algo, -ret); 709 goto out; 710 } 711 712 ret = -EINVAL; 713 for (k = 0, temp = 0; k < template[i].np; k++) { 714 if (diff_dst) 715 q = xoutbuf[IDX[k] >> PAGE_SHIFT] + 716 offset_in_page(IDX[k]); 717 else 718 q = xbuf[IDX[k] >> PAGE_SHIFT] + 719 offset_in_page(IDX[k]); 720 721 n = template[i].tap[k]; 722 if (k == template[i].np - 1) 723 n += enc ? authsize : -authsize; 724 725 if (memcmp(q, template[i].result + temp, n)) { 726 pr_err("alg: aead%s: Chunk test %d failed on %s at page %u for %s\n", 727 d, j, e, k, algo); 728 hexdump(q, n); 729 goto out; 730 } 731 732 q += n; 733 if (k == template[i].np - 1 && !enc) { 734 if (!diff_dst && 735 memcmp(q, template[i].input + 736 temp + n, authsize)) 737 n = authsize; 738 else 739 n = 0; 740 } else { 741 for (n = 0; offset_in_page(q + n) && 742 q[n]; n++) 743 ; 744 } 745 if (n) { 746 pr_err("alg: aead%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n", 747 d, j, e, k, algo, n); 748 hexdump(q, n); 749 goto out; 750 } 751 752 temp += template[i].tap[k]; 753 } 754 } 755 } 756 757 ret = 0; 758 759 out: 760 aead_request_free(req); 761 kfree(sg); 762 out_nosg: 763 if (diff_dst) 764 testmgr_free_buf(xoutbuf); 765 out_nooutbuf: 766 testmgr_free_buf(axbuf); 767 out_noaxbuf: 768 testmgr_free_buf(xbuf); 769 out_noxbuf: 770 return ret; 771 } 772 773 static int test_aead(struct crypto_aead *tfm, int enc, 774 struct aead_testvec *template, unsigned int tcount) 775 { 776 unsigned int alignmask; 777 int ret; 778 779 /* test 'dst == src' case */ 780 ret = __test_aead(tfm, enc, template, tcount, false, 0); 781 if (ret) 782 return ret; 783 784 /* test 'dst != src' case */ 785 ret = __test_aead(tfm, enc, template, tcount, true, 0); 786 if (ret) 787 return ret; 788 789 /* test unaligned buffers, check with one byte offset */ 790 ret = __test_aead(tfm, enc, template, tcount, true, 1); 791 if (ret) 792 return ret; 793 794 alignmask = crypto_tfm_alg_alignmask(&tfm->base); 795 if (alignmask) { 796 /* Check if alignment mask for tfm is correctly set. */ 797 ret = __test_aead(tfm, enc, template, tcount, true, 798 alignmask + 1); 799 if (ret) 800 return ret; 801 } 802 803 return 0; 804 } 805 806 static int test_cipher(struct crypto_cipher *tfm, int enc, 807 struct cipher_testvec *template, unsigned int tcount) 808 { 809 const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm)); 810 unsigned int i, j, k; 811 char *q; 812 const char *e; 813 void *data; 814 char *xbuf[XBUFSIZE]; 815 int ret = -ENOMEM; 816 817 if (testmgr_alloc_buf(xbuf)) 818 goto out_nobuf; 819 820 if (enc == ENCRYPT) 821 e = "encryption"; 822 else 823 e = "decryption"; 824 825 j = 0; 826 for (i = 0; i < tcount; i++) { 827 if (template[i].np) 828 continue; 829 830 j++; 831 832 ret = -EINVAL; 833 if (WARN_ON(template[i].ilen > PAGE_SIZE)) 834 goto out; 835 836 data = xbuf[0]; 837 memcpy(data, template[i].input, template[i].ilen); 838 839 crypto_cipher_clear_flags(tfm, ~0); 840 if (template[i].wk) 841 crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY); 842 843 ret = crypto_cipher_setkey(tfm, template[i].key, 844 template[i].klen); 845 if (!ret == template[i].fail) { 846 printk(KERN_ERR "alg: cipher: setkey failed " 847 "on test %d for %s: flags=%x\n", j, 848 algo, crypto_cipher_get_flags(tfm)); 849 goto out; 850 } else if (ret) 851 continue; 852 853 for (k = 0; k < template[i].ilen; 854 k += crypto_cipher_blocksize(tfm)) { 855 if (enc) 856 crypto_cipher_encrypt_one(tfm, data + k, 857 data + k); 858 else 859 crypto_cipher_decrypt_one(tfm, data + k, 860 data + k); 861 } 862 863 q = data; 864 if (memcmp(q, template[i].result, template[i].rlen)) { 865 printk(KERN_ERR "alg: cipher: Test %d failed " 866 "on %s for %s\n", j, e, algo); 867 hexdump(q, template[i].rlen); 868 ret = -EINVAL; 869 goto out; 870 } 871 } 872 873 ret = 0; 874 875 out: 876 testmgr_free_buf(xbuf); 877 out_nobuf: 878 return ret; 879 } 880 881 static int __test_skcipher(struct crypto_ablkcipher *tfm, int enc, 882 struct cipher_testvec *template, unsigned int tcount, 883 const bool diff_dst, const int align_offset) 884 { 885 const char *algo = 886 crypto_tfm_alg_driver_name(crypto_ablkcipher_tfm(tfm)); 887 unsigned int i, j, k, n, temp; 888 char *q; 889 struct ablkcipher_request *req; 890 struct scatterlist sg[8]; 891 struct scatterlist sgout[8]; 892 const char *e, *d; 893 struct tcrypt_result result; 894 void *data; 895 char iv[MAX_IVLEN]; 896 char *xbuf[XBUFSIZE]; 897 char *xoutbuf[XBUFSIZE]; 898 int ret = -ENOMEM; 899 900 if (testmgr_alloc_buf(xbuf)) 901 goto out_nobuf; 902 903 if (diff_dst && testmgr_alloc_buf(xoutbuf)) 904 goto out_nooutbuf; 905 906 if (diff_dst) 907 d = "-ddst"; 908 else 909 d = ""; 910 911 if (enc == ENCRYPT) 912 e = "encryption"; 913 else 914 e = "decryption"; 915 916 init_completion(&result.completion); 917 918 req = ablkcipher_request_alloc(tfm, GFP_KERNEL); 919 if (!req) { 920 pr_err("alg: skcipher%s: Failed to allocate request for %s\n", 921 d, algo); 922 goto out; 923 } 924 925 ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 926 tcrypt_complete, &result); 927 928 j = 0; 929 for (i = 0; i < tcount; i++) { 930 if (template[i].iv) 931 memcpy(iv, template[i].iv, MAX_IVLEN); 932 else 933 memset(iv, 0, MAX_IVLEN); 934 935 if (!(template[i].np) || (template[i].also_non_np)) { 936 j++; 937 938 ret = -EINVAL; 939 if (WARN_ON(align_offset + template[i].ilen > 940 PAGE_SIZE)) 941 goto out; 942 943 data = xbuf[0]; 944 data += align_offset; 945 memcpy(data, template[i].input, template[i].ilen); 946 947 crypto_ablkcipher_clear_flags(tfm, ~0); 948 if (template[i].wk) 949 crypto_ablkcipher_set_flags( 950 tfm, CRYPTO_TFM_REQ_WEAK_KEY); 951 952 ret = crypto_ablkcipher_setkey(tfm, template[i].key, 953 template[i].klen); 954 if (!ret == template[i].fail) { 955 pr_err("alg: skcipher%s: setkey failed on test %d for %s: flags=%x\n", 956 d, j, algo, 957 crypto_ablkcipher_get_flags(tfm)); 958 goto out; 959 } else if (ret) 960 continue; 961 962 sg_init_one(&sg[0], data, template[i].ilen); 963 if (diff_dst) { 964 data = xoutbuf[0]; 965 data += align_offset; 966 sg_init_one(&sgout[0], data, template[i].ilen); 967 } 968 969 ablkcipher_request_set_crypt(req, sg, 970 (diff_dst) ? sgout : sg, 971 template[i].ilen, iv); 972 ret = enc ? 973 crypto_ablkcipher_encrypt(req) : 974 crypto_ablkcipher_decrypt(req); 975 976 switch (ret) { 977 case 0: 978 break; 979 case -EINPROGRESS: 980 case -EBUSY: 981 ret = wait_for_completion_interruptible( 982 &result.completion); 983 if (!ret && !((ret = result.err))) { 984 reinit_completion(&result.completion); 985 break; 986 } 987 /* fall through */ 988 default: 989 pr_err("alg: skcipher%s: %s failed on test %d for %s: ret=%d\n", 990 d, e, j, algo, -ret); 991 goto out; 992 } 993 994 q = data; 995 if (memcmp(q, template[i].result, template[i].rlen)) { 996 pr_err("alg: skcipher%s: Test %d failed on %s for %s\n", 997 d, j, e, algo); 998 hexdump(q, template[i].rlen); 999 ret = -EINVAL; 1000 goto out; 1001 } 1002 } 1003 } 1004 1005 j = 0; 1006 for (i = 0; i < tcount; i++) { 1007 /* alignment tests are only done with continuous buffers */ 1008 if (align_offset != 0) 1009 break; 1010 1011 if (template[i].iv) 1012 memcpy(iv, template[i].iv, MAX_IVLEN); 1013 else 1014 memset(iv, 0, MAX_IVLEN); 1015 1016 if (template[i].np) { 1017 j++; 1018 1019 crypto_ablkcipher_clear_flags(tfm, ~0); 1020 if (template[i].wk) 1021 crypto_ablkcipher_set_flags( 1022 tfm, CRYPTO_TFM_REQ_WEAK_KEY); 1023 1024 ret = crypto_ablkcipher_setkey(tfm, template[i].key, 1025 template[i].klen); 1026 if (!ret == template[i].fail) { 1027 pr_err("alg: skcipher%s: setkey failed on chunk test %d for %s: flags=%x\n", 1028 d, j, algo, 1029 crypto_ablkcipher_get_flags(tfm)); 1030 goto out; 1031 } else if (ret) 1032 continue; 1033 1034 temp = 0; 1035 ret = -EINVAL; 1036 sg_init_table(sg, template[i].np); 1037 if (diff_dst) 1038 sg_init_table(sgout, template[i].np); 1039 for (k = 0; k < template[i].np; k++) { 1040 if (WARN_ON(offset_in_page(IDX[k]) + 1041 template[i].tap[k] > PAGE_SIZE)) 1042 goto out; 1043 1044 q = xbuf[IDX[k] >> PAGE_SHIFT] + 1045 offset_in_page(IDX[k]); 1046 1047 memcpy(q, template[i].input + temp, 1048 template[i].tap[k]); 1049 1050 if (offset_in_page(q) + template[i].tap[k] < 1051 PAGE_SIZE) 1052 q[template[i].tap[k]] = 0; 1053 1054 sg_set_buf(&sg[k], q, template[i].tap[k]); 1055 if (diff_dst) { 1056 q = xoutbuf[IDX[k] >> PAGE_SHIFT] + 1057 offset_in_page(IDX[k]); 1058 1059 sg_set_buf(&sgout[k], q, 1060 template[i].tap[k]); 1061 1062 memset(q, 0, template[i].tap[k]); 1063 if (offset_in_page(q) + 1064 template[i].tap[k] < PAGE_SIZE) 1065 q[template[i].tap[k]] = 0; 1066 } 1067 1068 temp += template[i].tap[k]; 1069 } 1070 1071 ablkcipher_request_set_crypt(req, sg, 1072 (diff_dst) ? sgout : sg, 1073 template[i].ilen, iv); 1074 1075 ret = enc ? 1076 crypto_ablkcipher_encrypt(req) : 1077 crypto_ablkcipher_decrypt(req); 1078 1079 switch (ret) { 1080 case 0: 1081 break; 1082 case -EINPROGRESS: 1083 case -EBUSY: 1084 ret = wait_for_completion_interruptible( 1085 &result.completion); 1086 if (!ret && !((ret = result.err))) { 1087 reinit_completion(&result.completion); 1088 break; 1089 } 1090 /* fall through */ 1091 default: 1092 pr_err("alg: skcipher%s: %s failed on chunk test %d for %s: ret=%d\n", 1093 d, e, j, algo, -ret); 1094 goto out; 1095 } 1096 1097 temp = 0; 1098 ret = -EINVAL; 1099 for (k = 0; k < template[i].np; k++) { 1100 if (diff_dst) 1101 q = xoutbuf[IDX[k] >> PAGE_SHIFT] + 1102 offset_in_page(IDX[k]); 1103 else 1104 q = xbuf[IDX[k] >> PAGE_SHIFT] + 1105 offset_in_page(IDX[k]); 1106 1107 if (memcmp(q, template[i].result + temp, 1108 template[i].tap[k])) { 1109 pr_err("alg: skcipher%s: Chunk test %d failed on %s at page %u for %s\n", 1110 d, j, e, k, algo); 1111 hexdump(q, template[i].tap[k]); 1112 goto out; 1113 } 1114 1115 q += template[i].tap[k]; 1116 for (n = 0; offset_in_page(q + n) && q[n]; n++) 1117 ; 1118 if (n) { 1119 pr_err("alg: skcipher%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n", 1120 d, j, e, k, algo, n); 1121 hexdump(q, n); 1122 goto out; 1123 } 1124 temp += template[i].tap[k]; 1125 } 1126 } 1127 } 1128 1129 ret = 0; 1130 1131 out: 1132 ablkcipher_request_free(req); 1133 if (diff_dst) 1134 testmgr_free_buf(xoutbuf); 1135 out_nooutbuf: 1136 testmgr_free_buf(xbuf); 1137 out_nobuf: 1138 return ret; 1139 } 1140 1141 static int test_skcipher(struct crypto_ablkcipher *tfm, int enc, 1142 struct cipher_testvec *template, unsigned int tcount) 1143 { 1144 unsigned int alignmask; 1145 int ret; 1146 1147 /* test 'dst == src' case */ 1148 ret = __test_skcipher(tfm, enc, template, tcount, false, 0); 1149 if (ret) 1150 return ret; 1151 1152 /* test 'dst != src' case */ 1153 ret = __test_skcipher(tfm, enc, template, tcount, true, 0); 1154 if (ret) 1155 return ret; 1156 1157 /* test unaligned buffers, check with one byte offset */ 1158 ret = __test_skcipher(tfm, enc, template, tcount, true, 1); 1159 if (ret) 1160 return ret; 1161 1162 alignmask = crypto_tfm_alg_alignmask(&tfm->base); 1163 if (alignmask) { 1164 /* Check if alignment mask for tfm is correctly set. */ 1165 ret = __test_skcipher(tfm, enc, template, tcount, true, 1166 alignmask + 1); 1167 if (ret) 1168 return ret; 1169 } 1170 1171 return 0; 1172 } 1173 1174 static int test_comp(struct crypto_comp *tfm, struct comp_testvec *ctemplate, 1175 struct comp_testvec *dtemplate, int ctcount, int dtcount) 1176 { 1177 const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm)); 1178 unsigned int i; 1179 char result[COMP_BUF_SIZE]; 1180 int ret; 1181 1182 for (i = 0; i < ctcount; i++) { 1183 int ilen; 1184 unsigned int dlen = COMP_BUF_SIZE; 1185 1186 memset(result, 0, sizeof (result)); 1187 1188 ilen = ctemplate[i].inlen; 1189 ret = crypto_comp_compress(tfm, ctemplate[i].input, 1190 ilen, result, &dlen); 1191 if (ret) { 1192 printk(KERN_ERR "alg: comp: compression failed " 1193 "on test %d for %s: ret=%d\n", i + 1, algo, 1194 -ret); 1195 goto out; 1196 } 1197 1198 if (dlen != ctemplate[i].outlen) { 1199 printk(KERN_ERR "alg: comp: Compression test %d " 1200 "failed for %s: output len = %d\n", i + 1, algo, 1201 dlen); 1202 ret = -EINVAL; 1203 goto out; 1204 } 1205 1206 if (memcmp(result, ctemplate[i].output, dlen)) { 1207 printk(KERN_ERR "alg: comp: Compression test %d " 1208 "failed for %s\n", i + 1, algo); 1209 hexdump(result, dlen); 1210 ret = -EINVAL; 1211 goto out; 1212 } 1213 } 1214 1215 for (i = 0; i < dtcount; i++) { 1216 int ilen; 1217 unsigned int dlen = COMP_BUF_SIZE; 1218 1219 memset(result, 0, sizeof (result)); 1220 1221 ilen = dtemplate[i].inlen; 1222 ret = crypto_comp_decompress(tfm, dtemplate[i].input, 1223 ilen, result, &dlen); 1224 if (ret) { 1225 printk(KERN_ERR "alg: comp: decompression failed " 1226 "on test %d for %s: ret=%d\n", i + 1, algo, 1227 -ret); 1228 goto out; 1229 } 1230 1231 if (dlen != dtemplate[i].outlen) { 1232 printk(KERN_ERR "alg: comp: Decompression test %d " 1233 "failed for %s: output len = %d\n", i + 1, algo, 1234 dlen); 1235 ret = -EINVAL; 1236 goto out; 1237 } 1238 1239 if (memcmp(result, dtemplate[i].output, dlen)) { 1240 printk(KERN_ERR "alg: comp: Decompression test %d " 1241 "failed for %s\n", i + 1, algo); 1242 hexdump(result, dlen); 1243 ret = -EINVAL; 1244 goto out; 1245 } 1246 } 1247 1248 ret = 0; 1249 1250 out: 1251 return ret; 1252 } 1253 1254 static int test_pcomp(struct crypto_pcomp *tfm, 1255 struct pcomp_testvec *ctemplate, 1256 struct pcomp_testvec *dtemplate, int ctcount, 1257 int dtcount) 1258 { 1259 const char *algo = crypto_tfm_alg_driver_name(crypto_pcomp_tfm(tfm)); 1260 unsigned int i; 1261 char result[COMP_BUF_SIZE]; 1262 int res; 1263 1264 for (i = 0; i < ctcount; i++) { 1265 struct comp_request req; 1266 unsigned int produced = 0; 1267 1268 res = crypto_compress_setup(tfm, ctemplate[i].params, 1269 ctemplate[i].paramsize); 1270 if (res) { 1271 pr_err("alg: pcomp: compression setup failed on test " 1272 "%d for %s: error=%d\n", i + 1, algo, res); 1273 return res; 1274 } 1275 1276 res = crypto_compress_init(tfm); 1277 if (res) { 1278 pr_err("alg: pcomp: compression init failed on test " 1279 "%d for %s: error=%d\n", i + 1, algo, res); 1280 return res; 1281 } 1282 1283 memset(result, 0, sizeof(result)); 1284 1285 req.next_in = ctemplate[i].input; 1286 req.avail_in = ctemplate[i].inlen / 2; 1287 req.next_out = result; 1288 req.avail_out = ctemplate[i].outlen / 2; 1289 1290 res = crypto_compress_update(tfm, &req); 1291 if (res < 0 && (res != -EAGAIN || req.avail_in)) { 1292 pr_err("alg: pcomp: compression update failed on test " 1293 "%d for %s: error=%d\n", i + 1, algo, res); 1294 return res; 1295 } 1296 if (res > 0) 1297 produced += res; 1298 1299 /* Add remaining input data */ 1300 req.avail_in += (ctemplate[i].inlen + 1) / 2; 1301 1302 res = crypto_compress_update(tfm, &req); 1303 if (res < 0 && (res != -EAGAIN || req.avail_in)) { 1304 pr_err("alg: pcomp: compression update failed on test " 1305 "%d for %s: error=%d\n", i + 1, algo, res); 1306 return res; 1307 } 1308 if (res > 0) 1309 produced += res; 1310 1311 /* Provide remaining output space */ 1312 req.avail_out += COMP_BUF_SIZE - ctemplate[i].outlen / 2; 1313 1314 res = crypto_compress_final(tfm, &req); 1315 if (res < 0) { 1316 pr_err("alg: pcomp: compression final failed on test " 1317 "%d for %s: error=%d\n", i + 1, algo, res); 1318 return res; 1319 } 1320 produced += res; 1321 1322 if (COMP_BUF_SIZE - req.avail_out != ctemplate[i].outlen) { 1323 pr_err("alg: comp: Compression test %d failed for %s: " 1324 "output len = %d (expected %d)\n", i + 1, algo, 1325 COMP_BUF_SIZE - req.avail_out, 1326 ctemplate[i].outlen); 1327 return -EINVAL; 1328 } 1329 1330 if (produced != ctemplate[i].outlen) { 1331 pr_err("alg: comp: Compression test %d failed for %s: " 1332 "returned len = %u (expected %d)\n", i + 1, 1333 algo, produced, ctemplate[i].outlen); 1334 return -EINVAL; 1335 } 1336 1337 if (memcmp(result, ctemplate[i].output, ctemplate[i].outlen)) { 1338 pr_err("alg: pcomp: Compression test %d failed for " 1339 "%s\n", i + 1, algo); 1340 hexdump(result, ctemplate[i].outlen); 1341 return -EINVAL; 1342 } 1343 } 1344 1345 for (i = 0; i < dtcount; i++) { 1346 struct comp_request req; 1347 unsigned int produced = 0; 1348 1349 res = crypto_decompress_setup(tfm, dtemplate[i].params, 1350 dtemplate[i].paramsize); 1351 if (res) { 1352 pr_err("alg: pcomp: decompression setup failed on " 1353 "test %d for %s: error=%d\n", i + 1, algo, res); 1354 return res; 1355 } 1356 1357 res = crypto_decompress_init(tfm); 1358 if (res) { 1359 pr_err("alg: pcomp: decompression init failed on test " 1360 "%d for %s: error=%d\n", i + 1, algo, res); 1361 return res; 1362 } 1363 1364 memset(result, 0, sizeof(result)); 1365 1366 req.next_in = dtemplate[i].input; 1367 req.avail_in = dtemplate[i].inlen / 2; 1368 req.next_out = result; 1369 req.avail_out = dtemplate[i].outlen / 2; 1370 1371 res = crypto_decompress_update(tfm, &req); 1372 if (res < 0 && (res != -EAGAIN || req.avail_in)) { 1373 pr_err("alg: pcomp: decompression update failed on " 1374 "test %d for %s: error=%d\n", i + 1, algo, res); 1375 return res; 1376 } 1377 if (res > 0) 1378 produced += res; 1379 1380 /* Add remaining input data */ 1381 req.avail_in += (dtemplate[i].inlen + 1) / 2; 1382 1383 res = crypto_decompress_update(tfm, &req); 1384 if (res < 0 && (res != -EAGAIN || req.avail_in)) { 1385 pr_err("alg: pcomp: decompression update failed on " 1386 "test %d for %s: error=%d\n", i + 1, algo, res); 1387 return res; 1388 } 1389 if (res > 0) 1390 produced += res; 1391 1392 /* Provide remaining output space */ 1393 req.avail_out += COMP_BUF_SIZE - dtemplate[i].outlen / 2; 1394 1395 res = crypto_decompress_final(tfm, &req); 1396 if (res < 0 && (res != -EAGAIN || req.avail_in)) { 1397 pr_err("alg: pcomp: decompression final failed on " 1398 "test %d for %s: error=%d\n", i + 1, algo, res); 1399 return res; 1400 } 1401 if (res > 0) 1402 produced += res; 1403 1404 if (COMP_BUF_SIZE - req.avail_out != dtemplate[i].outlen) { 1405 pr_err("alg: comp: Decompression test %d failed for " 1406 "%s: output len = %d (expected %d)\n", i + 1, 1407 algo, COMP_BUF_SIZE - req.avail_out, 1408 dtemplate[i].outlen); 1409 return -EINVAL; 1410 } 1411 1412 if (produced != dtemplate[i].outlen) { 1413 pr_err("alg: comp: Decompression test %d failed for " 1414 "%s: returned len = %u (expected %d)\n", i + 1, 1415 algo, produced, dtemplate[i].outlen); 1416 return -EINVAL; 1417 } 1418 1419 if (memcmp(result, dtemplate[i].output, dtemplate[i].outlen)) { 1420 pr_err("alg: pcomp: Decompression test %d failed for " 1421 "%s\n", i + 1, algo); 1422 hexdump(result, dtemplate[i].outlen); 1423 return -EINVAL; 1424 } 1425 } 1426 1427 return 0; 1428 } 1429 1430 1431 static int test_cprng(struct crypto_rng *tfm, struct cprng_testvec *template, 1432 unsigned int tcount) 1433 { 1434 const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm)); 1435 int err = 0, i, j, seedsize; 1436 u8 *seed; 1437 char result[32]; 1438 1439 seedsize = crypto_rng_seedsize(tfm); 1440 1441 seed = kmalloc(seedsize, GFP_KERNEL); 1442 if (!seed) { 1443 printk(KERN_ERR "alg: cprng: Failed to allocate seed space " 1444 "for %s\n", algo); 1445 return -ENOMEM; 1446 } 1447 1448 for (i = 0; i < tcount; i++) { 1449 memset(result, 0, 32); 1450 1451 memcpy(seed, template[i].v, template[i].vlen); 1452 memcpy(seed + template[i].vlen, template[i].key, 1453 template[i].klen); 1454 memcpy(seed + template[i].vlen + template[i].klen, 1455 template[i].dt, template[i].dtlen); 1456 1457 err = crypto_rng_reset(tfm, seed, seedsize); 1458 if (err) { 1459 printk(KERN_ERR "alg: cprng: Failed to reset rng " 1460 "for %s\n", algo); 1461 goto out; 1462 } 1463 1464 for (j = 0; j < template[i].loops; j++) { 1465 err = crypto_rng_get_bytes(tfm, result, 1466 template[i].rlen); 1467 if (err != template[i].rlen) { 1468 printk(KERN_ERR "alg: cprng: Failed to obtain " 1469 "the correct amount of random data for " 1470 "%s (requested %d, got %d)\n", algo, 1471 template[i].rlen, err); 1472 goto out; 1473 } 1474 } 1475 1476 err = memcmp(result, template[i].result, 1477 template[i].rlen); 1478 if (err) { 1479 printk(KERN_ERR "alg: cprng: Test %d failed for %s\n", 1480 i, algo); 1481 hexdump(result, template[i].rlen); 1482 err = -EINVAL; 1483 goto out; 1484 } 1485 } 1486 1487 out: 1488 kfree(seed); 1489 return err; 1490 } 1491 1492 static int alg_test_aead(const struct alg_test_desc *desc, const char *driver, 1493 u32 type, u32 mask) 1494 { 1495 struct crypto_aead *tfm; 1496 int err = 0; 1497 1498 tfm = crypto_alloc_aead(driver, type, mask); 1499 if (IS_ERR(tfm)) { 1500 printk(KERN_ERR "alg: aead: Failed to load transform for %s: " 1501 "%ld\n", driver, PTR_ERR(tfm)); 1502 return PTR_ERR(tfm); 1503 } 1504 1505 if (desc->suite.aead.enc.vecs) { 1506 err = test_aead(tfm, ENCRYPT, desc->suite.aead.enc.vecs, 1507 desc->suite.aead.enc.count); 1508 if (err) 1509 goto out; 1510 } 1511 1512 if (!err && desc->suite.aead.dec.vecs) 1513 err = test_aead(tfm, DECRYPT, desc->suite.aead.dec.vecs, 1514 desc->suite.aead.dec.count); 1515 1516 out: 1517 crypto_free_aead(tfm); 1518 return err; 1519 } 1520 1521 static int alg_test_cipher(const struct alg_test_desc *desc, 1522 const char *driver, u32 type, u32 mask) 1523 { 1524 struct crypto_cipher *tfm; 1525 int err = 0; 1526 1527 tfm = crypto_alloc_cipher(driver, type, mask); 1528 if (IS_ERR(tfm)) { 1529 printk(KERN_ERR "alg: cipher: Failed to load transform for " 1530 "%s: %ld\n", driver, PTR_ERR(tfm)); 1531 return PTR_ERR(tfm); 1532 } 1533 1534 if (desc->suite.cipher.enc.vecs) { 1535 err = test_cipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs, 1536 desc->suite.cipher.enc.count); 1537 if (err) 1538 goto out; 1539 } 1540 1541 if (desc->suite.cipher.dec.vecs) 1542 err = test_cipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs, 1543 desc->suite.cipher.dec.count); 1544 1545 out: 1546 crypto_free_cipher(tfm); 1547 return err; 1548 } 1549 1550 static int alg_test_skcipher(const struct alg_test_desc *desc, 1551 const char *driver, u32 type, u32 mask) 1552 { 1553 struct crypto_ablkcipher *tfm; 1554 int err = 0; 1555 1556 tfm = crypto_alloc_ablkcipher(driver, type, mask); 1557 if (IS_ERR(tfm)) { 1558 printk(KERN_ERR "alg: skcipher: Failed to load transform for " 1559 "%s: %ld\n", driver, PTR_ERR(tfm)); 1560 return PTR_ERR(tfm); 1561 } 1562 1563 if (desc->suite.cipher.enc.vecs) { 1564 err = test_skcipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs, 1565 desc->suite.cipher.enc.count); 1566 if (err) 1567 goto out; 1568 } 1569 1570 if (desc->suite.cipher.dec.vecs) 1571 err = test_skcipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs, 1572 desc->suite.cipher.dec.count); 1573 1574 out: 1575 crypto_free_ablkcipher(tfm); 1576 return err; 1577 } 1578 1579 static int alg_test_comp(const struct alg_test_desc *desc, const char *driver, 1580 u32 type, u32 mask) 1581 { 1582 struct crypto_comp *tfm; 1583 int err; 1584 1585 tfm = crypto_alloc_comp(driver, type, mask); 1586 if (IS_ERR(tfm)) { 1587 printk(KERN_ERR "alg: comp: Failed to load transform for %s: " 1588 "%ld\n", driver, PTR_ERR(tfm)); 1589 return PTR_ERR(tfm); 1590 } 1591 1592 err = test_comp(tfm, desc->suite.comp.comp.vecs, 1593 desc->suite.comp.decomp.vecs, 1594 desc->suite.comp.comp.count, 1595 desc->suite.comp.decomp.count); 1596 1597 crypto_free_comp(tfm); 1598 return err; 1599 } 1600 1601 static int alg_test_pcomp(const struct alg_test_desc *desc, const char *driver, 1602 u32 type, u32 mask) 1603 { 1604 struct crypto_pcomp *tfm; 1605 int err; 1606 1607 tfm = crypto_alloc_pcomp(driver, type, mask); 1608 if (IS_ERR(tfm)) { 1609 pr_err("alg: pcomp: Failed to load transform for %s: %ld\n", 1610 driver, PTR_ERR(tfm)); 1611 return PTR_ERR(tfm); 1612 } 1613 1614 err = test_pcomp(tfm, desc->suite.pcomp.comp.vecs, 1615 desc->suite.pcomp.decomp.vecs, 1616 desc->suite.pcomp.comp.count, 1617 desc->suite.pcomp.decomp.count); 1618 1619 crypto_free_pcomp(tfm); 1620 return err; 1621 } 1622 1623 static int alg_test_hash(const struct alg_test_desc *desc, const char *driver, 1624 u32 type, u32 mask) 1625 { 1626 struct crypto_ahash *tfm; 1627 int err; 1628 1629 tfm = crypto_alloc_ahash(driver, type, mask); 1630 if (IS_ERR(tfm)) { 1631 printk(KERN_ERR "alg: hash: Failed to load transform for %s: " 1632 "%ld\n", driver, PTR_ERR(tfm)); 1633 return PTR_ERR(tfm); 1634 } 1635 1636 err = test_hash(tfm, desc->suite.hash.vecs, 1637 desc->suite.hash.count, true); 1638 if (!err) 1639 err = test_hash(tfm, desc->suite.hash.vecs, 1640 desc->suite.hash.count, false); 1641 1642 crypto_free_ahash(tfm); 1643 return err; 1644 } 1645 1646 static int alg_test_crc32c(const struct alg_test_desc *desc, 1647 const char *driver, u32 type, u32 mask) 1648 { 1649 struct crypto_shash *tfm; 1650 u32 val; 1651 int err; 1652 1653 err = alg_test_hash(desc, driver, type, mask); 1654 if (err) 1655 goto out; 1656 1657 tfm = crypto_alloc_shash(driver, type, mask); 1658 if (IS_ERR(tfm)) { 1659 printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: " 1660 "%ld\n", driver, PTR_ERR(tfm)); 1661 err = PTR_ERR(tfm); 1662 goto out; 1663 } 1664 1665 do { 1666 struct { 1667 struct shash_desc shash; 1668 char ctx[crypto_shash_descsize(tfm)]; 1669 } sdesc; 1670 1671 sdesc.shash.tfm = tfm; 1672 sdesc.shash.flags = 0; 1673 1674 *(u32 *)sdesc.ctx = le32_to_cpu(420553207); 1675 err = crypto_shash_final(&sdesc.shash, (u8 *)&val); 1676 if (err) { 1677 printk(KERN_ERR "alg: crc32c: Operation failed for " 1678 "%s: %d\n", driver, err); 1679 break; 1680 } 1681 1682 if (val != ~420553207) { 1683 printk(KERN_ERR "alg: crc32c: Test failed for %s: " 1684 "%d\n", driver, val); 1685 err = -EINVAL; 1686 } 1687 } while (0); 1688 1689 crypto_free_shash(tfm); 1690 1691 out: 1692 return err; 1693 } 1694 1695 static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver, 1696 u32 type, u32 mask) 1697 { 1698 struct crypto_rng *rng; 1699 int err; 1700 1701 rng = crypto_alloc_rng(driver, type, mask); 1702 if (IS_ERR(rng)) { 1703 printk(KERN_ERR "alg: cprng: Failed to load transform for %s: " 1704 "%ld\n", driver, PTR_ERR(rng)); 1705 return PTR_ERR(rng); 1706 } 1707 1708 err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count); 1709 1710 crypto_free_rng(rng); 1711 1712 return err; 1713 } 1714 1715 static int alg_test_null(const struct alg_test_desc *desc, 1716 const char *driver, u32 type, u32 mask) 1717 { 1718 return 0; 1719 } 1720 1721 /* Please keep this list sorted by algorithm name. */ 1722 static const struct alg_test_desc alg_test_descs[] = { 1723 { 1724 .alg = "__cbc-cast5-avx", 1725 .test = alg_test_null, 1726 }, { 1727 .alg = "__cbc-cast6-avx", 1728 .test = alg_test_null, 1729 }, { 1730 .alg = "__cbc-serpent-avx", 1731 .test = alg_test_null, 1732 }, { 1733 .alg = "__cbc-serpent-avx2", 1734 .test = alg_test_null, 1735 }, { 1736 .alg = "__cbc-serpent-sse2", 1737 .test = alg_test_null, 1738 }, { 1739 .alg = "__cbc-twofish-avx", 1740 .test = alg_test_null, 1741 }, { 1742 .alg = "__driver-cbc-aes-aesni", 1743 .test = alg_test_null, 1744 .fips_allowed = 1, 1745 }, { 1746 .alg = "__driver-cbc-camellia-aesni", 1747 .test = alg_test_null, 1748 }, { 1749 .alg = "__driver-cbc-camellia-aesni-avx2", 1750 .test = alg_test_null, 1751 }, { 1752 .alg = "__driver-cbc-cast5-avx", 1753 .test = alg_test_null, 1754 }, { 1755 .alg = "__driver-cbc-cast6-avx", 1756 .test = alg_test_null, 1757 }, { 1758 .alg = "__driver-cbc-serpent-avx", 1759 .test = alg_test_null, 1760 }, { 1761 .alg = "__driver-cbc-serpent-avx2", 1762 .test = alg_test_null, 1763 }, { 1764 .alg = "__driver-cbc-serpent-sse2", 1765 .test = alg_test_null, 1766 }, { 1767 .alg = "__driver-cbc-twofish-avx", 1768 .test = alg_test_null, 1769 }, { 1770 .alg = "__driver-ecb-aes-aesni", 1771 .test = alg_test_null, 1772 .fips_allowed = 1, 1773 }, { 1774 .alg = "__driver-ecb-camellia-aesni", 1775 .test = alg_test_null, 1776 }, { 1777 .alg = "__driver-ecb-camellia-aesni-avx2", 1778 .test = alg_test_null, 1779 }, { 1780 .alg = "__driver-ecb-cast5-avx", 1781 .test = alg_test_null, 1782 }, { 1783 .alg = "__driver-ecb-cast6-avx", 1784 .test = alg_test_null, 1785 }, { 1786 .alg = "__driver-ecb-serpent-avx", 1787 .test = alg_test_null, 1788 }, { 1789 .alg = "__driver-ecb-serpent-avx2", 1790 .test = alg_test_null, 1791 }, { 1792 .alg = "__driver-ecb-serpent-sse2", 1793 .test = alg_test_null, 1794 }, { 1795 .alg = "__driver-ecb-twofish-avx", 1796 .test = alg_test_null, 1797 }, { 1798 .alg = "__ghash-pclmulqdqni", 1799 .test = alg_test_null, 1800 .fips_allowed = 1, 1801 }, { 1802 .alg = "ansi_cprng", 1803 .test = alg_test_cprng, 1804 .fips_allowed = 1, 1805 .suite = { 1806 .cprng = { 1807 .vecs = ansi_cprng_aes_tv_template, 1808 .count = ANSI_CPRNG_AES_TEST_VECTORS 1809 } 1810 } 1811 }, { 1812 .alg = "authenc(hmac(md5),ecb(cipher_null))", 1813 .test = alg_test_aead, 1814 .fips_allowed = 1, 1815 .suite = { 1816 .aead = { 1817 .enc = { 1818 .vecs = hmac_md5_ecb_cipher_null_enc_tv_template, 1819 .count = HMAC_MD5_ECB_CIPHER_NULL_ENC_TEST_VECTORS 1820 }, 1821 .dec = { 1822 .vecs = hmac_md5_ecb_cipher_null_dec_tv_template, 1823 .count = HMAC_MD5_ECB_CIPHER_NULL_DEC_TEST_VECTORS 1824 } 1825 } 1826 } 1827 }, { 1828 .alg = "authenc(hmac(sha1),cbc(aes))", 1829 .test = alg_test_aead, 1830 .fips_allowed = 1, 1831 .suite = { 1832 .aead = { 1833 .enc = { 1834 .vecs = hmac_sha1_aes_cbc_enc_tv_template, 1835 .count = HMAC_SHA1_AES_CBC_ENC_TEST_VECTORS 1836 } 1837 } 1838 } 1839 }, { 1840 .alg = "authenc(hmac(sha1),ecb(cipher_null))", 1841 .test = alg_test_aead, 1842 .fips_allowed = 1, 1843 .suite = { 1844 .aead = { 1845 .enc = { 1846 .vecs = hmac_sha1_ecb_cipher_null_enc_tv_template, 1847 .count = HMAC_SHA1_ECB_CIPHER_NULL_ENC_TEST_VECTORS 1848 }, 1849 .dec = { 1850 .vecs = hmac_sha1_ecb_cipher_null_dec_tv_template, 1851 .count = HMAC_SHA1_ECB_CIPHER_NULL_DEC_TEST_VECTORS 1852 } 1853 } 1854 } 1855 }, { 1856 .alg = "authenc(hmac(sha256),cbc(aes))", 1857 .test = alg_test_aead, 1858 .fips_allowed = 1, 1859 .suite = { 1860 .aead = { 1861 .enc = { 1862 .vecs = hmac_sha256_aes_cbc_enc_tv_template, 1863 .count = HMAC_SHA256_AES_CBC_ENC_TEST_VECTORS 1864 } 1865 } 1866 } 1867 }, { 1868 .alg = "authenc(hmac(sha512),cbc(aes))", 1869 .test = alg_test_aead, 1870 .fips_allowed = 1, 1871 .suite = { 1872 .aead = { 1873 .enc = { 1874 .vecs = hmac_sha512_aes_cbc_enc_tv_template, 1875 .count = HMAC_SHA512_AES_CBC_ENC_TEST_VECTORS 1876 } 1877 } 1878 } 1879 }, { 1880 .alg = "cbc(aes)", 1881 .test = alg_test_skcipher, 1882 .fips_allowed = 1, 1883 .suite = { 1884 .cipher = { 1885 .enc = { 1886 .vecs = aes_cbc_enc_tv_template, 1887 .count = AES_CBC_ENC_TEST_VECTORS 1888 }, 1889 .dec = { 1890 .vecs = aes_cbc_dec_tv_template, 1891 .count = AES_CBC_DEC_TEST_VECTORS 1892 } 1893 } 1894 } 1895 }, { 1896 .alg = "cbc(anubis)", 1897 .test = alg_test_skcipher, 1898 .suite = { 1899 .cipher = { 1900 .enc = { 1901 .vecs = anubis_cbc_enc_tv_template, 1902 .count = ANUBIS_CBC_ENC_TEST_VECTORS 1903 }, 1904 .dec = { 1905 .vecs = anubis_cbc_dec_tv_template, 1906 .count = ANUBIS_CBC_DEC_TEST_VECTORS 1907 } 1908 } 1909 } 1910 }, { 1911 .alg = "cbc(blowfish)", 1912 .test = alg_test_skcipher, 1913 .suite = { 1914 .cipher = { 1915 .enc = { 1916 .vecs = bf_cbc_enc_tv_template, 1917 .count = BF_CBC_ENC_TEST_VECTORS 1918 }, 1919 .dec = { 1920 .vecs = bf_cbc_dec_tv_template, 1921 .count = BF_CBC_DEC_TEST_VECTORS 1922 } 1923 } 1924 } 1925 }, { 1926 .alg = "cbc(camellia)", 1927 .test = alg_test_skcipher, 1928 .suite = { 1929 .cipher = { 1930 .enc = { 1931 .vecs = camellia_cbc_enc_tv_template, 1932 .count = CAMELLIA_CBC_ENC_TEST_VECTORS 1933 }, 1934 .dec = { 1935 .vecs = camellia_cbc_dec_tv_template, 1936 .count = CAMELLIA_CBC_DEC_TEST_VECTORS 1937 } 1938 } 1939 } 1940 }, { 1941 .alg = "cbc(cast5)", 1942 .test = alg_test_skcipher, 1943 .suite = { 1944 .cipher = { 1945 .enc = { 1946 .vecs = cast5_cbc_enc_tv_template, 1947 .count = CAST5_CBC_ENC_TEST_VECTORS 1948 }, 1949 .dec = { 1950 .vecs = cast5_cbc_dec_tv_template, 1951 .count = CAST5_CBC_DEC_TEST_VECTORS 1952 } 1953 } 1954 } 1955 }, { 1956 .alg = "cbc(cast6)", 1957 .test = alg_test_skcipher, 1958 .suite = { 1959 .cipher = { 1960 .enc = { 1961 .vecs = cast6_cbc_enc_tv_template, 1962 .count = CAST6_CBC_ENC_TEST_VECTORS 1963 }, 1964 .dec = { 1965 .vecs = cast6_cbc_dec_tv_template, 1966 .count = CAST6_CBC_DEC_TEST_VECTORS 1967 } 1968 } 1969 } 1970 }, { 1971 .alg = "cbc(des)", 1972 .test = alg_test_skcipher, 1973 .suite = { 1974 .cipher = { 1975 .enc = { 1976 .vecs = des_cbc_enc_tv_template, 1977 .count = DES_CBC_ENC_TEST_VECTORS 1978 }, 1979 .dec = { 1980 .vecs = des_cbc_dec_tv_template, 1981 .count = DES_CBC_DEC_TEST_VECTORS 1982 } 1983 } 1984 } 1985 }, { 1986 .alg = "cbc(des3_ede)", 1987 .test = alg_test_skcipher, 1988 .fips_allowed = 1, 1989 .suite = { 1990 .cipher = { 1991 .enc = { 1992 .vecs = des3_ede_cbc_enc_tv_template, 1993 .count = DES3_EDE_CBC_ENC_TEST_VECTORS 1994 }, 1995 .dec = { 1996 .vecs = des3_ede_cbc_dec_tv_template, 1997 .count = DES3_EDE_CBC_DEC_TEST_VECTORS 1998 } 1999 } 2000 } 2001 }, { 2002 .alg = "cbc(serpent)", 2003 .test = alg_test_skcipher, 2004 .suite = { 2005 .cipher = { 2006 .enc = { 2007 .vecs = serpent_cbc_enc_tv_template, 2008 .count = SERPENT_CBC_ENC_TEST_VECTORS 2009 }, 2010 .dec = { 2011 .vecs = serpent_cbc_dec_tv_template, 2012 .count = SERPENT_CBC_DEC_TEST_VECTORS 2013 } 2014 } 2015 } 2016 }, { 2017 .alg = "cbc(twofish)", 2018 .test = alg_test_skcipher, 2019 .suite = { 2020 .cipher = { 2021 .enc = { 2022 .vecs = tf_cbc_enc_tv_template, 2023 .count = TF_CBC_ENC_TEST_VECTORS 2024 }, 2025 .dec = { 2026 .vecs = tf_cbc_dec_tv_template, 2027 .count = TF_CBC_DEC_TEST_VECTORS 2028 } 2029 } 2030 } 2031 }, { 2032 .alg = "ccm(aes)", 2033 .test = alg_test_aead, 2034 .fips_allowed = 1, 2035 .suite = { 2036 .aead = { 2037 .enc = { 2038 .vecs = aes_ccm_enc_tv_template, 2039 .count = AES_CCM_ENC_TEST_VECTORS 2040 }, 2041 .dec = { 2042 .vecs = aes_ccm_dec_tv_template, 2043 .count = AES_CCM_DEC_TEST_VECTORS 2044 } 2045 } 2046 } 2047 }, { 2048 .alg = "cmac(aes)", 2049 .test = alg_test_hash, 2050 .suite = { 2051 .hash = { 2052 .vecs = aes_cmac128_tv_template, 2053 .count = CMAC_AES_TEST_VECTORS 2054 } 2055 } 2056 }, { 2057 .alg = "cmac(des3_ede)", 2058 .test = alg_test_hash, 2059 .suite = { 2060 .hash = { 2061 .vecs = des3_ede_cmac64_tv_template, 2062 .count = CMAC_DES3_EDE_TEST_VECTORS 2063 } 2064 } 2065 }, { 2066 .alg = "compress_null", 2067 .test = alg_test_null, 2068 }, { 2069 .alg = "crc32c", 2070 .test = alg_test_crc32c, 2071 .fips_allowed = 1, 2072 .suite = { 2073 .hash = { 2074 .vecs = crc32c_tv_template, 2075 .count = CRC32C_TEST_VECTORS 2076 } 2077 } 2078 }, { 2079 .alg = "crct10dif", 2080 .test = alg_test_hash, 2081 .fips_allowed = 1, 2082 .suite = { 2083 .hash = { 2084 .vecs = crct10dif_tv_template, 2085 .count = CRCT10DIF_TEST_VECTORS 2086 } 2087 } 2088 }, { 2089 .alg = "cryptd(__driver-cbc-aes-aesni)", 2090 .test = alg_test_null, 2091 .fips_allowed = 1, 2092 }, { 2093 .alg = "cryptd(__driver-cbc-camellia-aesni)", 2094 .test = alg_test_null, 2095 }, { 2096 .alg = "cryptd(__driver-cbc-camellia-aesni-avx2)", 2097 .test = alg_test_null, 2098 }, { 2099 .alg = "cryptd(__driver-cbc-serpent-avx2)", 2100 .test = alg_test_null, 2101 }, { 2102 .alg = "cryptd(__driver-ecb-aes-aesni)", 2103 .test = alg_test_null, 2104 .fips_allowed = 1, 2105 }, { 2106 .alg = "cryptd(__driver-ecb-camellia-aesni)", 2107 .test = alg_test_null, 2108 }, { 2109 .alg = "cryptd(__driver-ecb-camellia-aesni-avx2)", 2110 .test = alg_test_null, 2111 }, { 2112 .alg = "cryptd(__driver-ecb-cast5-avx)", 2113 .test = alg_test_null, 2114 }, { 2115 .alg = "cryptd(__driver-ecb-cast6-avx)", 2116 .test = alg_test_null, 2117 }, { 2118 .alg = "cryptd(__driver-ecb-serpent-avx)", 2119 .test = alg_test_null, 2120 }, { 2121 .alg = "cryptd(__driver-ecb-serpent-avx2)", 2122 .test = alg_test_null, 2123 }, { 2124 .alg = "cryptd(__driver-ecb-serpent-sse2)", 2125 .test = alg_test_null, 2126 }, { 2127 .alg = "cryptd(__driver-ecb-twofish-avx)", 2128 .test = alg_test_null, 2129 }, { 2130 .alg = "cryptd(__driver-gcm-aes-aesni)", 2131 .test = alg_test_null, 2132 .fips_allowed = 1, 2133 }, { 2134 .alg = "cryptd(__ghash-pclmulqdqni)", 2135 .test = alg_test_null, 2136 .fips_allowed = 1, 2137 }, { 2138 .alg = "ctr(aes)", 2139 .test = alg_test_skcipher, 2140 .fips_allowed = 1, 2141 .suite = { 2142 .cipher = { 2143 .enc = { 2144 .vecs = aes_ctr_enc_tv_template, 2145 .count = AES_CTR_ENC_TEST_VECTORS 2146 }, 2147 .dec = { 2148 .vecs = aes_ctr_dec_tv_template, 2149 .count = AES_CTR_DEC_TEST_VECTORS 2150 } 2151 } 2152 } 2153 }, { 2154 .alg = "ctr(blowfish)", 2155 .test = alg_test_skcipher, 2156 .suite = { 2157 .cipher = { 2158 .enc = { 2159 .vecs = bf_ctr_enc_tv_template, 2160 .count = BF_CTR_ENC_TEST_VECTORS 2161 }, 2162 .dec = { 2163 .vecs = bf_ctr_dec_tv_template, 2164 .count = BF_CTR_DEC_TEST_VECTORS 2165 } 2166 } 2167 } 2168 }, { 2169 .alg = "ctr(camellia)", 2170 .test = alg_test_skcipher, 2171 .suite = { 2172 .cipher = { 2173 .enc = { 2174 .vecs = camellia_ctr_enc_tv_template, 2175 .count = CAMELLIA_CTR_ENC_TEST_VECTORS 2176 }, 2177 .dec = { 2178 .vecs = camellia_ctr_dec_tv_template, 2179 .count = CAMELLIA_CTR_DEC_TEST_VECTORS 2180 } 2181 } 2182 } 2183 }, { 2184 .alg = "ctr(cast5)", 2185 .test = alg_test_skcipher, 2186 .suite = { 2187 .cipher = { 2188 .enc = { 2189 .vecs = cast5_ctr_enc_tv_template, 2190 .count = CAST5_CTR_ENC_TEST_VECTORS 2191 }, 2192 .dec = { 2193 .vecs = cast5_ctr_dec_tv_template, 2194 .count = CAST5_CTR_DEC_TEST_VECTORS 2195 } 2196 } 2197 } 2198 }, { 2199 .alg = "ctr(cast6)", 2200 .test = alg_test_skcipher, 2201 .suite = { 2202 .cipher = { 2203 .enc = { 2204 .vecs = cast6_ctr_enc_tv_template, 2205 .count = CAST6_CTR_ENC_TEST_VECTORS 2206 }, 2207 .dec = { 2208 .vecs = cast6_ctr_dec_tv_template, 2209 .count = CAST6_CTR_DEC_TEST_VECTORS 2210 } 2211 } 2212 } 2213 }, { 2214 .alg = "ctr(des)", 2215 .test = alg_test_skcipher, 2216 .suite = { 2217 .cipher = { 2218 .enc = { 2219 .vecs = des_ctr_enc_tv_template, 2220 .count = DES_CTR_ENC_TEST_VECTORS 2221 }, 2222 .dec = { 2223 .vecs = des_ctr_dec_tv_template, 2224 .count = DES_CTR_DEC_TEST_VECTORS 2225 } 2226 } 2227 } 2228 }, { 2229 .alg = "ctr(des3_ede)", 2230 .test = alg_test_skcipher, 2231 .suite = { 2232 .cipher = { 2233 .enc = { 2234 .vecs = des3_ede_ctr_enc_tv_template, 2235 .count = DES3_EDE_CTR_ENC_TEST_VECTORS 2236 }, 2237 .dec = { 2238 .vecs = des3_ede_ctr_dec_tv_template, 2239 .count = DES3_EDE_CTR_DEC_TEST_VECTORS 2240 } 2241 } 2242 } 2243 }, { 2244 .alg = "ctr(serpent)", 2245 .test = alg_test_skcipher, 2246 .suite = { 2247 .cipher = { 2248 .enc = { 2249 .vecs = serpent_ctr_enc_tv_template, 2250 .count = SERPENT_CTR_ENC_TEST_VECTORS 2251 }, 2252 .dec = { 2253 .vecs = serpent_ctr_dec_tv_template, 2254 .count = SERPENT_CTR_DEC_TEST_VECTORS 2255 } 2256 } 2257 } 2258 }, { 2259 .alg = "ctr(twofish)", 2260 .test = alg_test_skcipher, 2261 .suite = { 2262 .cipher = { 2263 .enc = { 2264 .vecs = tf_ctr_enc_tv_template, 2265 .count = TF_CTR_ENC_TEST_VECTORS 2266 }, 2267 .dec = { 2268 .vecs = tf_ctr_dec_tv_template, 2269 .count = TF_CTR_DEC_TEST_VECTORS 2270 } 2271 } 2272 } 2273 }, { 2274 .alg = "cts(cbc(aes))", 2275 .test = alg_test_skcipher, 2276 .suite = { 2277 .cipher = { 2278 .enc = { 2279 .vecs = cts_mode_enc_tv_template, 2280 .count = CTS_MODE_ENC_TEST_VECTORS 2281 }, 2282 .dec = { 2283 .vecs = cts_mode_dec_tv_template, 2284 .count = CTS_MODE_DEC_TEST_VECTORS 2285 } 2286 } 2287 } 2288 }, { 2289 .alg = "deflate", 2290 .test = alg_test_comp, 2291 .fips_allowed = 1, 2292 .suite = { 2293 .comp = { 2294 .comp = { 2295 .vecs = deflate_comp_tv_template, 2296 .count = DEFLATE_COMP_TEST_VECTORS 2297 }, 2298 .decomp = { 2299 .vecs = deflate_decomp_tv_template, 2300 .count = DEFLATE_DECOMP_TEST_VECTORS 2301 } 2302 } 2303 } 2304 }, { 2305 .alg = "digest_null", 2306 .test = alg_test_null, 2307 }, { 2308 .alg = "ecb(__aes-aesni)", 2309 .test = alg_test_null, 2310 .fips_allowed = 1, 2311 }, { 2312 .alg = "ecb(aes)", 2313 .test = alg_test_skcipher, 2314 .fips_allowed = 1, 2315 .suite = { 2316 .cipher = { 2317 .enc = { 2318 .vecs = aes_enc_tv_template, 2319 .count = AES_ENC_TEST_VECTORS 2320 }, 2321 .dec = { 2322 .vecs = aes_dec_tv_template, 2323 .count = AES_DEC_TEST_VECTORS 2324 } 2325 } 2326 } 2327 }, { 2328 .alg = "ecb(anubis)", 2329 .test = alg_test_skcipher, 2330 .suite = { 2331 .cipher = { 2332 .enc = { 2333 .vecs = anubis_enc_tv_template, 2334 .count = ANUBIS_ENC_TEST_VECTORS 2335 }, 2336 .dec = { 2337 .vecs = anubis_dec_tv_template, 2338 .count = ANUBIS_DEC_TEST_VECTORS 2339 } 2340 } 2341 } 2342 }, { 2343 .alg = "ecb(arc4)", 2344 .test = alg_test_skcipher, 2345 .suite = { 2346 .cipher = { 2347 .enc = { 2348 .vecs = arc4_enc_tv_template, 2349 .count = ARC4_ENC_TEST_VECTORS 2350 }, 2351 .dec = { 2352 .vecs = arc4_dec_tv_template, 2353 .count = ARC4_DEC_TEST_VECTORS 2354 } 2355 } 2356 } 2357 }, { 2358 .alg = "ecb(blowfish)", 2359 .test = alg_test_skcipher, 2360 .suite = { 2361 .cipher = { 2362 .enc = { 2363 .vecs = bf_enc_tv_template, 2364 .count = BF_ENC_TEST_VECTORS 2365 }, 2366 .dec = { 2367 .vecs = bf_dec_tv_template, 2368 .count = BF_DEC_TEST_VECTORS 2369 } 2370 } 2371 } 2372 }, { 2373 .alg = "ecb(camellia)", 2374 .test = alg_test_skcipher, 2375 .suite = { 2376 .cipher = { 2377 .enc = { 2378 .vecs = camellia_enc_tv_template, 2379 .count = CAMELLIA_ENC_TEST_VECTORS 2380 }, 2381 .dec = { 2382 .vecs = camellia_dec_tv_template, 2383 .count = CAMELLIA_DEC_TEST_VECTORS 2384 } 2385 } 2386 } 2387 }, { 2388 .alg = "ecb(cast5)", 2389 .test = alg_test_skcipher, 2390 .suite = { 2391 .cipher = { 2392 .enc = { 2393 .vecs = cast5_enc_tv_template, 2394 .count = CAST5_ENC_TEST_VECTORS 2395 }, 2396 .dec = { 2397 .vecs = cast5_dec_tv_template, 2398 .count = CAST5_DEC_TEST_VECTORS 2399 } 2400 } 2401 } 2402 }, { 2403 .alg = "ecb(cast6)", 2404 .test = alg_test_skcipher, 2405 .suite = { 2406 .cipher = { 2407 .enc = { 2408 .vecs = cast6_enc_tv_template, 2409 .count = CAST6_ENC_TEST_VECTORS 2410 }, 2411 .dec = { 2412 .vecs = cast6_dec_tv_template, 2413 .count = CAST6_DEC_TEST_VECTORS 2414 } 2415 } 2416 } 2417 }, { 2418 .alg = "ecb(cipher_null)", 2419 .test = alg_test_null, 2420 }, { 2421 .alg = "ecb(des)", 2422 .test = alg_test_skcipher, 2423 .fips_allowed = 1, 2424 .suite = { 2425 .cipher = { 2426 .enc = { 2427 .vecs = des_enc_tv_template, 2428 .count = DES_ENC_TEST_VECTORS 2429 }, 2430 .dec = { 2431 .vecs = des_dec_tv_template, 2432 .count = DES_DEC_TEST_VECTORS 2433 } 2434 } 2435 } 2436 }, { 2437 .alg = "ecb(des3_ede)", 2438 .test = alg_test_skcipher, 2439 .fips_allowed = 1, 2440 .suite = { 2441 .cipher = { 2442 .enc = { 2443 .vecs = des3_ede_enc_tv_template, 2444 .count = DES3_EDE_ENC_TEST_VECTORS 2445 }, 2446 .dec = { 2447 .vecs = des3_ede_dec_tv_template, 2448 .count = DES3_EDE_DEC_TEST_VECTORS 2449 } 2450 } 2451 } 2452 }, { 2453 .alg = "ecb(fcrypt)", 2454 .test = alg_test_skcipher, 2455 .suite = { 2456 .cipher = { 2457 .enc = { 2458 .vecs = fcrypt_pcbc_enc_tv_template, 2459 .count = 1 2460 }, 2461 .dec = { 2462 .vecs = fcrypt_pcbc_dec_tv_template, 2463 .count = 1 2464 } 2465 } 2466 } 2467 }, { 2468 .alg = "ecb(khazad)", 2469 .test = alg_test_skcipher, 2470 .suite = { 2471 .cipher = { 2472 .enc = { 2473 .vecs = khazad_enc_tv_template, 2474 .count = KHAZAD_ENC_TEST_VECTORS 2475 }, 2476 .dec = { 2477 .vecs = khazad_dec_tv_template, 2478 .count = KHAZAD_DEC_TEST_VECTORS 2479 } 2480 } 2481 } 2482 }, { 2483 .alg = "ecb(seed)", 2484 .test = alg_test_skcipher, 2485 .suite = { 2486 .cipher = { 2487 .enc = { 2488 .vecs = seed_enc_tv_template, 2489 .count = SEED_ENC_TEST_VECTORS 2490 }, 2491 .dec = { 2492 .vecs = seed_dec_tv_template, 2493 .count = SEED_DEC_TEST_VECTORS 2494 } 2495 } 2496 } 2497 }, { 2498 .alg = "ecb(serpent)", 2499 .test = alg_test_skcipher, 2500 .suite = { 2501 .cipher = { 2502 .enc = { 2503 .vecs = serpent_enc_tv_template, 2504 .count = SERPENT_ENC_TEST_VECTORS 2505 }, 2506 .dec = { 2507 .vecs = serpent_dec_tv_template, 2508 .count = SERPENT_DEC_TEST_VECTORS 2509 } 2510 } 2511 } 2512 }, { 2513 .alg = "ecb(tea)", 2514 .test = alg_test_skcipher, 2515 .suite = { 2516 .cipher = { 2517 .enc = { 2518 .vecs = tea_enc_tv_template, 2519 .count = TEA_ENC_TEST_VECTORS 2520 }, 2521 .dec = { 2522 .vecs = tea_dec_tv_template, 2523 .count = TEA_DEC_TEST_VECTORS 2524 } 2525 } 2526 } 2527 }, { 2528 .alg = "ecb(tnepres)", 2529 .test = alg_test_skcipher, 2530 .suite = { 2531 .cipher = { 2532 .enc = { 2533 .vecs = tnepres_enc_tv_template, 2534 .count = TNEPRES_ENC_TEST_VECTORS 2535 }, 2536 .dec = { 2537 .vecs = tnepres_dec_tv_template, 2538 .count = TNEPRES_DEC_TEST_VECTORS 2539 } 2540 } 2541 } 2542 }, { 2543 .alg = "ecb(twofish)", 2544 .test = alg_test_skcipher, 2545 .suite = { 2546 .cipher = { 2547 .enc = { 2548 .vecs = tf_enc_tv_template, 2549 .count = TF_ENC_TEST_VECTORS 2550 }, 2551 .dec = { 2552 .vecs = tf_dec_tv_template, 2553 .count = TF_DEC_TEST_VECTORS 2554 } 2555 } 2556 } 2557 }, { 2558 .alg = "ecb(xeta)", 2559 .test = alg_test_skcipher, 2560 .suite = { 2561 .cipher = { 2562 .enc = { 2563 .vecs = xeta_enc_tv_template, 2564 .count = XETA_ENC_TEST_VECTORS 2565 }, 2566 .dec = { 2567 .vecs = xeta_dec_tv_template, 2568 .count = XETA_DEC_TEST_VECTORS 2569 } 2570 } 2571 } 2572 }, { 2573 .alg = "ecb(xtea)", 2574 .test = alg_test_skcipher, 2575 .suite = { 2576 .cipher = { 2577 .enc = { 2578 .vecs = xtea_enc_tv_template, 2579 .count = XTEA_ENC_TEST_VECTORS 2580 }, 2581 .dec = { 2582 .vecs = xtea_dec_tv_template, 2583 .count = XTEA_DEC_TEST_VECTORS 2584 } 2585 } 2586 } 2587 }, { 2588 .alg = "gcm(aes)", 2589 .test = alg_test_aead, 2590 .fips_allowed = 1, 2591 .suite = { 2592 .aead = { 2593 .enc = { 2594 .vecs = aes_gcm_enc_tv_template, 2595 .count = AES_GCM_ENC_TEST_VECTORS 2596 }, 2597 .dec = { 2598 .vecs = aes_gcm_dec_tv_template, 2599 .count = AES_GCM_DEC_TEST_VECTORS 2600 } 2601 } 2602 } 2603 }, { 2604 .alg = "ghash", 2605 .test = alg_test_hash, 2606 .fips_allowed = 1, 2607 .suite = { 2608 .hash = { 2609 .vecs = ghash_tv_template, 2610 .count = GHASH_TEST_VECTORS 2611 } 2612 } 2613 }, { 2614 .alg = "hmac(crc32)", 2615 .test = alg_test_hash, 2616 .suite = { 2617 .hash = { 2618 .vecs = bfin_crc_tv_template, 2619 .count = BFIN_CRC_TEST_VECTORS 2620 } 2621 } 2622 }, { 2623 .alg = "hmac(md5)", 2624 .test = alg_test_hash, 2625 .suite = { 2626 .hash = { 2627 .vecs = hmac_md5_tv_template, 2628 .count = HMAC_MD5_TEST_VECTORS 2629 } 2630 } 2631 }, { 2632 .alg = "hmac(rmd128)", 2633 .test = alg_test_hash, 2634 .suite = { 2635 .hash = { 2636 .vecs = hmac_rmd128_tv_template, 2637 .count = HMAC_RMD128_TEST_VECTORS 2638 } 2639 } 2640 }, { 2641 .alg = "hmac(rmd160)", 2642 .test = alg_test_hash, 2643 .suite = { 2644 .hash = { 2645 .vecs = hmac_rmd160_tv_template, 2646 .count = HMAC_RMD160_TEST_VECTORS 2647 } 2648 } 2649 }, { 2650 .alg = "hmac(sha1)", 2651 .test = alg_test_hash, 2652 .fips_allowed = 1, 2653 .suite = { 2654 .hash = { 2655 .vecs = hmac_sha1_tv_template, 2656 .count = HMAC_SHA1_TEST_VECTORS 2657 } 2658 } 2659 }, { 2660 .alg = "hmac(sha224)", 2661 .test = alg_test_hash, 2662 .fips_allowed = 1, 2663 .suite = { 2664 .hash = { 2665 .vecs = hmac_sha224_tv_template, 2666 .count = HMAC_SHA224_TEST_VECTORS 2667 } 2668 } 2669 }, { 2670 .alg = "hmac(sha256)", 2671 .test = alg_test_hash, 2672 .fips_allowed = 1, 2673 .suite = { 2674 .hash = { 2675 .vecs = hmac_sha256_tv_template, 2676 .count = HMAC_SHA256_TEST_VECTORS 2677 } 2678 } 2679 }, { 2680 .alg = "hmac(sha384)", 2681 .test = alg_test_hash, 2682 .fips_allowed = 1, 2683 .suite = { 2684 .hash = { 2685 .vecs = hmac_sha384_tv_template, 2686 .count = HMAC_SHA384_TEST_VECTORS 2687 } 2688 } 2689 }, { 2690 .alg = "hmac(sha512)", 2691 .test = alg_test_hash, 2692 .fips_allowed = 1, 2693 .suite = { 2694 .hash = { 2695 .vecs = hmac_sha512_tv_template, 2696 .count = HMAC_SHA512_TEST_VECTORS 2697 } 2698 } 2699 }, { 2700 .alg = "lrw(aes)", 2701 .test = alg_test_skcipher, 2702 .suite = { 2703 .cipher = { 2704 .enc = { 2705 .vecs = aes_lrw_enc_tv_template, 2706 .count = AES_LRW_ENC_TEST_VECTORS 2707 }, 2708 .dec = { 2709 .vecs = aes_lrw_dec_tv_template, 2710 .count = AES_LRW_DEC_TEST_VECTORS 2711 } 2712 } 2713 } 2714 }, { 2715 .alg = "lrw(camellia)", 2716 .test = alg_test_skcipher, 2717 .suite = { 2718 .cipher = { 2719 .enc = { 2720 .vecs = camellia_lrw_enc_tv_template, 2721 .count = CAMELLIA_LRW_ENC_TEST_VECTORS 2722 }, 2723 .dec = { 2724 .vecs = camellia_lrw_dec_tv_template, 2725 .count = CAMELLIA_LRW_DEC_TEST_VECTORS 2726 } 2727 } 2728 } 2729 }, { 2730 .alg = "lrw(cast6)", 2731 .test = alg_test_skcipher, 2732 .suite = { 2733 .cipher = { 2734 .enc = { 2735 .vecs = cast6_lrw_enc_tv_template, 2736 .count = CAST6_LRW_ENC_TEST_VECTORS 2737 }, 2738 .dec = { 2739 .vecs = cast6_lrw_dec_tv_template, 2740 .count = CAST6_LRW_DEC_TEST_VECTORS 2741 } 2742 } 2743 } 2744 }, { 2745 .alg = "lrw(serpent)", 2746 .test = alg_test_skcipher, 2747 .suite = { 2748 .cipher = { 2749 .enc = { 2750 .vecs = serpent_lrw_enc_tv_template, 2751 .count = SERPENT_LRW_ENC_TEST_VECTORS 2752 }, 2753 .dec = { 2754 .vecs = serpent_lrw_dec_tv_template, 2755 .count = SERPENT_LRW_DEC_TEST_VECTORS 2756 } 2757 } 2758 } 2759 }, { 2760 .alg = "lrw(twofish)", 2761 .test = alg_test_skcipher, 2762 .suite = { 2763 .cipher = { 2764 .enc = { 2765 .vecs = tf_lrw_enc_tv_template, 2766 .count = TF_LRW_ENC_TEST_VECTORS 2767 }, 2768 .dec = { 2769 .vecs = tf_lrw_dec_tv_template, 2770 .count = TF_LRW_DEC_TEST_VECTORS 2771 } 2772 } 2773 } 2774 }, { 2775 .alg = "lzo", 2776 .test = alg_test_comp, 2777 .fips_allowed = 1, 2778 .suite = { 2779 .comp = { 2780 .comp = { 2781 .vecs = lzo_comp_tv_template, 2782 .count = LZO_COMP_TEST_VECTORS 2783 }, 2784 .decomp = { 2785 .vecs = lzo_decomp_tv_template, 2786 .count = LZO_DECOMP_TEST_VECTORS 2787 } 2788 } 2789 } 2790 }, { 2791 .alg = "md4", 2792 .test = alg_test_hash, 2793 .suite = { 2794 .hash = { 2795 .vecs = md4_tv_template, 2796 .count = MD4_TEST_VECTORS 2797 } 2798 } 2799 }, { 2800 .alg = "md5", 2801 .test = alg_test_hash, 2802 .suite = { 2803 .hash = { 2804 .vecs = md5_tv_template, 2805 .count = MD5_TEST_VECTORS 2806 } 2807 } 2808 }, { 2809 .alg = "michael_mic", 2810 .test = alg_test_hash, 2811 .suite = { 2812 .hash = { 2813 .vecs = michael_mic_tv_template, 2814 .count = MICHAEL_MIC_TEST_VECTORS 2815 } 2816 } 2817 }, { 2818 .alg = "ofb(aes)", 2819 .test = alg_test_skcipher, 2820 .fips_allowed = 1, 2821 .suite = { 2822 .cipher = { 2823 .enc = { 2824 .vecs = aes_ofb_enc_tv_template, 2825 .count = AES_OFB_ENC_TEST_VECTORS 2826 }, 2827 .dec = { 2828 .vecs = aes_ofb_dec_tv_template, 2829 .count = AES_OFB_DEC_TEST_VECTORS 2830 } 2831 } 2832 } 2833 }, { 2834 .alg = "pcbc(fcrypt)", 2835 .test = alg_test_skcipher, 2836 .suite = { 2837 .cipher = { 2838 .enc = { 2839 .vecs = fcrypt_pcbc_enc_tv_template, 2840 .count = FCRYPT_ENC_TEST_VECTORS 2841 }, 2842 .dec = { 2843 .vecs = fcrypt_pcbc_dec_tv_template, 2844 .count = FCRYPT_DEC_TEST_VECTORS 2845 } 2846 } 2847 } 2848 }, { 2849 .alg = "rfc3686(ctr(aes))", 2850 .test = alg_test_skcipher, 2851 .fips_allowed = 1, 2852 .suite = { 2853 .cipher = { 2854 .enc = { 2855 .vecs = aes_ctr_rfc3686_enc_tv_template, 2856 .count = AES_CTR_3686_ENC_TEST_VECTORS 2857 }, 2858 .dec = { 2859 .vecs = aes_ctr_rfc3686_dec_tv_template, 2860 .count = AES_CTR_3686_DEC_TEST_VECTORS 2861 } 2862 } 2863 } 2864 }, { 2865 .alg = "rfc4106(gcm(aes))", 2866 .test = alg_test_aead, 2867 .suite = { 2868 .aead = { 2869 .enc = { 2870 .vecs = aes_gcm_rfc4106_enc_tv_template, 2871 .count = AES_GCM_4106_ENC_TEST_VECTORS 2872 }, 2873 .dec = { 2874 .vecs = aes_gcm_rfc4106_dec_tv_template, 2875 .count = AES_GCM_4106_DEC_TEST_VECTORS 2876 } 2877 } 2878 } 2879 }, { 2880 .alg = "rfc4309(ccm(aes))", 2881 .test = alg_test_aead, 2882 .fips_allowed = 1, 2883 .suite = { 2884 .aead = { 2885 .enc = { 2886 .vecs = aes_ccm_rfc4309_enc_tv_template, 2887 .count = AES_CCM_4309_ENC_TEST_VECTORS 2888 }, 2889 .dec = { 2890 .vecs = aes_ccm_rfc4309_dec_tv_template, 2891 .count = AES_CCM_4309_DEC_TEST_VECTORS 2892 } 2893 } 2894 } 2895 }, { 2896 .alg = "rfc4543(gcm(aes))", 2897 .test = alg_test_aead, 2898 .suite = { 2899 .aead = { 2900 .enc = { 2901 .vecs = aes_gcm_rfc4543_enc_tv_template, 2902 .count = AES_GCM_4543_ENC_TEST_VECTORS 2903 }, 2904 .dec = { 2905 .vecs = aes_gcm_rfc4543_dec_tv_template, 2906 .count = AES_GCM_4543_DEC_TEST_VECTORS 2907 }, 2908 } 2909 } 2910 }, { 2911 .alg = "rmd128", 2912 .test = alg_test_hash, 2913 .suite = { 2914 .hash = { 2915 .vecs = rmd128_tv_template, 2916 .count = RMD128_TEST_VECTORS 2917 } 2918 } 2919 }, { 2920 .alg = "rmd160", 2921 .test = alg_test_hash, 2922 .suite = { 2923 .hash = { 2924 .vecs = rmd160_tv_template, 2925 .count = RMD160_TEST_VECTORS 2926 } 2927 } 2928 }, { 2929 .alg = "rmd256", 2930 .test = alg_test_hash, 2931 .suite = { 2932 .hash = { 2933 .vecs = rmd256_tv_template, 2934 .count = RMD256_TEST_VECTORS 2935 } 2936 } 2937 }, { 2938 .alg = "rmd320", 2939 .test = alg_test_hash, 2940 .suite = { 2941 .hash = { 2942 .vecs = rmd320_tv_template, 2943 .count = RMD320_TEST_VECTORS 2944 } 2945 } 2946 }, { 2947 .alg = "salsa20", 2948 .test = alg_test_skcipher, 2949 .suite = { 2950 .cipher = { 2951 .enc = { 2952 .vecs = salsa20_stream_enc_tv_template, 2953 .count = SALSA20_STREAM_ENC_TEST_VECTORS 2954 } 2955 } 2956 } 2957 }, { 2958 .alg = "sha1", 2959 .test = alg_test_hash, 2960 .fips_allowed = 1, 2961 .suite = { 2962 .hash = { 2963 .vecs = sha1_tv_template, 2964 .count = SHA1_TEST_VECTORS 2965 } 2966 } 2967 }, { 2968 .alg = "sha224", 2969 .test = alg_test_hash, 2970 .fips_allowed = 1, 2971 .suite = { 2972 .hash = { 2973 .vecs = sha224_tv_template, 2974 .count = SHA224_TEST_VECTORS 2975 } 2976 } 2977 }, { 2978 .alg = "sha256", 2979 .test = alg_test_hash, 2980 .fips_allowed = 1, 2981 .suite = { 2982 .hash = { 2983 .vecs = sha256_tv_template, 2984 .count = SHA256_TEST_VECTORS 2985 } 2986 } 2987 }, { 2988 .alg = "sha384", 2989 .test = alg_test_hash, 2990 .fips_allowed = 1, 2991 .suite = { 2992 .hash = { 2993 .vecs = sha384_tv_template, 2994 .count = SHA384_TEST_VECTORS 2995 } 2996 } 2997 }, { 2998 .alg = "sha512", 2999 .test = alg_test_hash, 3000 .fips_allowed = 1, 3001 .suite = { 3002 .hash = { 3003 .vecs = sha512_tv_template, 3004 .count = SHA512_TEST_VECTORS 3005 } 3006 } 3007 }, { 3008 .alg = "tgr128", 3009 .test = alg_test_hash, 3010 .suite = { 3011 .hash = { 3012 .vecs = tgr128_tv_template, 3013 .count = TGR128_TEST_VECTORS 3014 } 3015 } 3016 }, { 3017 .alg = "tgr160", 3018 .test = alg_test_hash, 3019 .suite = { 3020 .hash = { 3021 .vecs = tgr160_tv_template, 3022 .count = TGR160_TEST_VECTORS 3023 } 3024 } 3025 }, { 3026 .alg = "tgr192", 3027 .test = alg_test_hash, 3028 .suite = { 3029 .hash = { 3030 .vecs = tgr192_tv_template, 3031 .count = TGR192_TEST_VECTORS 3032 } 3033 } 3034 }, { 3035 .alg = "vmac(aes)", 3036 .test = alg_test_hash, 3037 .suite = { 3038 .hash = { 3039 .vecs = aes_vmac128_tv_template, 3040 .count = VMAC_AES_TEST_VECTORS 3041 } 3042 } 3043 }, { 3044 .alg = "wp256", 3045 .test = alg_test_hash, 3046 .suite = { 3047 .hash = { 3048 .vecs = wp256_tv_template, 3049 .count = WP256_TEST_VECTORS 3050 } 3051 } 3052 }, { 3053 .alg = "wp384", 3054 .test = alg_test_hash, 3055 .suite = { 3056 .hash = { 3057 .vecs = wp384_tv_template, 3058 .count = WP384_TEST_VECTORS 3059 } 3060 } 3061 }, { 3062 .alg = "wp512", 3063 .test = alg_test_hash, 3064 .suite = { 3065 .hash = { 3066 .vecs = wp512_tv_template, 3067 .count = WP512_TEST_VECTORS 3068 } 3069 } 3070 }, { 3071 .alg = "xcbc(aes)", 3072 .test = alg_test_hash, 3073 .suite = { 3074 .hash = { 3075 .vecs = aes_xcbc128_tv_template, 3076 .count = XCBC_AES_TEST_VECTORS 3077 } 3078 } 3079 }, { 3080 .alg = "xts(aes)", 3081 .test = alg_test_skcipher, 3082 .fips_allowed = 1, 3083 .suite = { 3084 .cipher = { 3085 .enc = { 3086 .vecs = aes_xts_enc_tv_template, 3087 .count = AES_XTS_ENC_TEST_VECTORS 3088 }, 3089 .dec = { 3090 .vecs = aes_xts_dec_tv_template, 3091 .count = AES_XTS_DEC_TEST_VECTORS 3092 } 3093 } 3094 } 3095 }, { 3096 .alg = "xts(camellia)", 3097 .test = alg_test_skcipher, 3098 .suite = { 3099 .cipher = { 3100 .enc = { 3101 .vecs = camellia_xts_enc_tv_template, 3102 .count = CAMELLIA_XTS_ENC_TEST_VECTORS 3103 }, 3104 .dec = { 3105 .vecs = camellia_xts_dec_tv_template, 3106 .count = CAMELLIA_XTS_DEC_TEST_VECTORS 3107 } 3108 } 3109 } 3110 }, { 3111 .alg = "xts(cast6)", 3112 .test = alg_test_skcipher, 3113 .suite = { 3114 .cipher = { 3115 .enc = { 3116 .vecs = cast6_xts_enc_tv_template, 3117 .count = CAST6_XTS_ENC_TEST_VECTORS 3118 }, 3119 .dec = { 3120 .vecs = cast6_xts_dec_tv_template, 3121 .count = CAST6_XTS_DEC_TEST_VECTORS 3122 } 3123 } 3124 } 3125 }, { 3126 .alg = "xts(serpent)", 3127 .test = alg_test_skcipher, 3128 .suite = { 3129 .cipher = { 3130 .enc = { 3131 .vecs = serpent_xts_enc_tv_template, 3132 .count = SERPENT_XTS_ENC_TEST_VECTORS 3133 }, 3134 .dec = { 3135 .vecs = serpent_xts_dec_tv_template, 3136 .count = SERPENT_XTS_DEC_TEST_VECTORS 3137 } 3138 } 3139 } 3140 }, { 3141 .alg = "xts(twofish)", 3142 .test = alg_test_skcipher, 3143 .suite = { 3144 .cipher = { 3145 .enc = { 3146 .vecs = tf_xts_enc_tv_template, 3147 .count = TF_XTS_ENC_TEST_VECTORS 3148 }, 3149 .dec = { 3150 .vecs = tf_xts_dec_tv_template, 3151 .count = TF_XTS_DEC_TEST_VECTORS 3152 } 3153 } 3154 } 3155 }, { 3156 .alg = "zlib", 3157 .test = alg_test_pcomp, 3158 .fips_allowed = 1, 3159 .suite = { 3160 .pcomp = { 3161 .comp = { 3162 .vecs = zlib_comp_tv_template, 3163 .count = ZLIB_COMP_TEST_VECTORS 3164 }, 3165 .decomp = { 3166 .vecs = zlib_decomp_tv_template, 3167 .count = ZLIB_DECOMP_TEST_VECTORS 3168 } 3169 } 3170 } 3171 } 3172 }; 3173 3174 static bool alg_test_descs_checked; 3175 3176 static void alg_test_descs_check_order(void) 3177 { 3178 int i; 3179 3180 /* only check once */ 3181 if (alg_test_descs_checked) 3182 return; 3183 3184 alg_test_descs_checked = true; 3185 3186 for (i = 1; i < ARRAY_SIZE(alg_test_descs); i++) { 3187 int diff = strcmp(alg_test_descs[i - 1].alg, 3188 alg_test_descs[i].alg); 3189 3190 if (WARN_ON(diff > 0)) { 3191 pr_warn("testmgr: alg_test_descs entries in wrong order: '%s' before '%s'\n", 3192 alg_test_descs[i - 1].alg, 3193 alg_test_descs[i].alg); 3194 } 3195 3196 if (WARN_ON(diff == 0)) { 3197 pr_warn("testmgr: duplicate alg_test_descs entry: '%s'\n", 3198 alg_test_descs[i].alg); 3199 } 3200 } 3201 } 3202 3203 static int alg_find_test(const char *alg) 3204 { 3205 int start = 0; 3206 int end = ARRAY_SIZE(alg_test_descs); 3207 3208 while (start < end) { 3209 int i = (start + end) / 2; 3210 int diff = strcmp(alg_test_descs[i].alg, alg); 3211 3212 if (diff > 0) { 3213 end = i; 3214 continue; 3215 } 3216 3217 if (diff < 0) { 3218 start = i + 1; 3219 continue; 3220 } 3221 3222 return i; 3223 } 3224 3225 return -1; 3226 } 3227 3228 int alg_test(const char *driver, const char *alg, u32 type, u32 mask) 3229 { 3230 int i; 3231 int j; 3232 int rc; 3233 3234 alg_test_descs_check_order(); 3235 3236 if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) { 3237 char nalg[CRYPTO_MAX_ALG_NAME]; 3238 3239 if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >= 3240 sizeof(nalg)) 3241 return -ENAMETOOLONG; 3242 3243 i = alg_find_test(nalg); 3244 if (i < 0) 3245 goto notest; 3246 3247 if (fips_enabled && !alg_test_descs[i].fips_allowed) 3248 goto non_fips_alg; 3249 3250 rc = alg_test_cipher(alg_test_descs + i, driver, type, mask); 3251 goto test_done; 3252 } 3253 3254 i = alg_find_test(alg); 3255 j = alg_find_test(driver); 3256 if (i < 0 && j < 0) 3257 goto notest; 3258 3259 if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) || 3260 (j >= 0 && !alg_test_descs[j].fips_allowed))) 3261 goto non_fips_alg; 3262 3263 rc = 0; 3264 if (i >= 0) 3265 rc |= alg_test_descs[i].test(alg_test_descs + i, driver, 3266 type, mask); 3267 if (j >= 0 && j != i) 3268 rc |= alg_test_descs[j].test(alg_test_descs + j, driver, 3269 type, mask); 3270 3271 test_done: 3272 if (fips_enabled && rc) 3273 panic("%s: %s alg self test failed in fips mode!\n", driver, alg); 3274 3275 if (fips_enabled && !rc) 3276 printk(KERN_INFO "alg: self-tests for %s (%s) passed\n", 3277 driver, alg); 3278 3279 return rc; 3280 3281 notest: 3282 printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver); 3283 return 0; 3284 non_fips_alg: 3285 return -EINVAL; 3286 } 3287 3288 #endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */ 3289 3290 EXPORT_SYMBOL_GPL(alg_test); 3291