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