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