crypto/testmgr.c

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