crypto/testmgr.c

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