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