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