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