crypto/testmgr.c

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