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