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