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