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