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