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