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