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 * This program is free software; you can redistribute it and/or modify it
  10 * under the terms of the GNU General Public License as published by the Free
  11 * Software Foundation; either version 2 of the License, or (at your option)
  12 * any later version.
  13 *
  14 */
  15
  16#include <crypto/hash.h>
  17#include <linux/err.h>
  18#include <linux/module.h>
  19#include <linux/scatterlist.h>
  20#include <linux/slab.h>
  21#include <linux/string.h>
  22
  23#include "internal.h"
  24#include "testmgr.h"
  25
  26/*
  27 * Need slab memory for testing (size in number of pages).
  28 */
  29#define XBUFSIZE        8
  30
  31/*
  32 * Indexes into the xbuf to simulate cross-page access.
  33 */
  34#define IDX1            32
  35#define IDX2            32400
  36#define IDX3            1
  37#define IDX4            8193
  38#define IDX5            22222
  39#define IDX6            17101
  40#define IDX7            27333
  41#define IDX8            3000
  42
  43/*
  44* Used by test_cipher()
  45*/
  46#define ENCRYPT 1
  47#define DECRYPT 0
  48
  49struct tcrypt_result {
  50        struct completion completion;
  51        int err;
  52};
  53
  54struct aead_test_suite {
  55        struct {
  56                struct aead_testvec *vecs;
  57                unsigned int count;
  58        } enc, dec;
  59};
  60
  61struct cipher_test_suite {
  62        struct {
  63                struct cipher_testvec *vecs;
  64                unsigned int count;
  65        } enc, dec;
  66};
  67
  68struct comp_test_suite {
  69        struct {
  70                struct comp_testvec *vecs;
  71                unsigned int count;
  72        } comp, decomp;
  73};
  74
  75struct hash_test_suite {
  76        struct hash_testvec *vecs;
  77        unsigned int count;
  78};
  79
  80struct alg_test_desc {
  81        const char *alg;
  82        int (*test)(const struct alg_test_desc *desc, const char *driver,
  83                    u32 type, u32 mask);
  84
  85        union {
  86                struct aead_test_suite aead;
  87                struct cipher_test_suite cipher;
  88                struct comp_test_suite comp;
  89                struct hash_test_suite hash;
  90        } suite;
  91};
  92
  93static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
  94
  95static char *xbuf[XBUFSIZE];
  96static char *axbuf[XBUFSIZE];
  97
  98static void hexdump(unsigned char *buf, unsigned int len)
  99{
 100        print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
 101                        16, 1,
 102                        buf, len, false);
 103}
 104
 105static void tcrypt_complete(struct crypto_async_request *req, int err)
 106{
 107        struct tcrypt_result *res = req->data;
 108
 109        if (err == -EINPROGRESS)
 110                return;
 111
 112        res->err = err;
 113        complete(&res->completion);
 114}
 115
 116static int test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
 117                     unsigned int tcount)
 118{
 119        const char *algo = crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm));
 120        unsigned int i, j, k, temp;
 121        struct scatterlist sg[8];
 122        char result[64];
 123        struct ahash_request *req;
 124        struct tcrypt_result tresult;
 125        int ret;
 126        void *hash_buff;
 127
 128        init_completion(&tresult.completion);
 129
 130        req = ahash_request_alloc(tfm, GFP_KERNEL);
 131        if (!req) {
 132                printk(KERN_ERR "alg: hash: Failed to allocate request for "
 133                       "%s\n", algo);
 134                ret = -ENOMEM;
 135                goto out_noreq;
 136        }
 137        ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
 138                                   tcrypt_complete, &tresult);
 139
 140        for (i = 0; i < tcount; i++) {
 141                memset(result, 0, 64);
 142
 143                hash_buff = xbuf[0];
 144
 145                memcpy(hash_buff, template[i].plaintext, template[i].psize);
 146                sg_init_one(&sg[0], hash_buff, template[i].psize);
 147
 148                if (template[i].ksize) {
 149                        crypto_ahash_clear_flags(tfm, ~0);
 150                        ret = crypto_ahash_setkey(tfm, template[i].key,
 151                                                  template[i].ksize);
 152                        if (ret) {
 153                                printk(KERN_ERR "alg: hash: setkey failed on "
 154                                       "test %d for %s: ret=%d\n", i + 1, algo,
 155                                       -ret);
 156                                goto out;
 157                        }
 158                }
 159
 160                ahash_request_set_crypt(req, sg, result, template[i].psize);
 161                ret = crypto_ahash_digest(req);
 162                switch (ret) {
 163                case 0:
 164                        break;
 165                case -EINPROGRESS:
 166                case -EBUSY:
 167                        ret = wait_for_completion_interruptible(
 168                                &tresult.completion);
 169                        if (!ret && !(ret = tresult.err)) {
 170                                INIT_COMPLETION(tresult.completion);
 171                                break;
 172                        }
 173                        /* fall through */
 174                default:
 175                        printk(KERN_ERR "alg: hash: digest failed on test %d "
 176                               "for %s: ret=%d\n", i + 1, algo, -ret);
 177                        goto out;
 178                }
 179
 180                if (memcmp(result, template[i].digest,
 181                           crypto_ahash_digestsize(tfm))) {
 182                        printk(KERN_ERR "alg: hash: Test %d failed for %s\n",
 183                               i + 1, algo);
 184                        hexdump(result, crypto_ahash_digestsize(tfm));
 185                        ret = -EINVAL;
 186                        goto out;
 187                }
 188        }
 189
 190        j = 0;
 191        for (i = 0; i < tcount; i++) {
 192                if (template[i].np) {
 193                        j++;
 194                        memset(result, 0, 64);
 195
 196                        temp = 0;
 197                        sg_init_table(sg, template[i].np);
 198                        for (k = 0; k < template[i].np; k++) {
 199                                sg_set_buf(&sg[k],
 200                                           memcpy(xbuf[IDX[k] >> PAGE_SHIFT] +
 201                                                  offset_in_page(IDX[k]),
 202                                                  template[i].plaintext + temp,
 203                                                  template[i].tap[k]),
 204                                           template[i].tap[k]);
 205                                temp += template[i].tap[k];
 206                        }
 207
 208                        if (template[i].ksize) {
 209                                crypto_ahash_clear_flags(tfm, ~0);
 210                                ret = crypto_ahash_setkey(tfm, template[i].key,
 211                                                          template[i].ksize);
 212
 213                                if (ret) {
 214                                        printk(KERN_ERR "alg: hash: setkey "
 215                                               "failed on chunking test %d "
 216                                               "for %s: ret=%d\n", j, algo,
 217                                               -ret);
 218                                        goto out;
 219                                }
 220                        }
 221
 222                        ahash_request_set_crypt(req, sg, result,
 223                                                template[i].psize);
 224                        ret = crypto_ahash_digest(req);
 225                        switch (ret) {
 226                        case 0:
 227                                break;
 228                        case -EINPROGRESS:
 229                        case -EBUSY:
 230                                ret = wait_for_completion_interruptible(
 231                                        &tresult.completion);
 232                                if (!ret && !(ret = tresult.err)) {
 233                                        INIT_COMPLETION(tresult.completion);
 234                                        break;
 235                                }
 236                                /* fall through */
 237                        default:
 238                                printk(KERN_ERR "alg: hash: digest failed "
 239                                       "on chunking test %d for %s: "
 240                                       "ret=%d\n", j, algo, -ret);
 241                                goto out;
 242                        }
 243
 244                        if (memcmp(result, template[i].digest,
 245                                   crypto_ahash_digestsize(tfm))) {
 246                                printk(KERN_ERR "alg: hash: Chunking test %d "
 247                                       "failed for %s\n", j, algo);
 248                                hexdump(result, crypto_ahash_digestsize(tfm));
 249                                ret = -EINVAL;
 250                                goto out;
 251                        }
 252                }
 253        }
 254
 255        ret = 0;
 256
 257out:
 258        ahash_request_free(req);
 259out_noreq:
 260        return ret;
 261}
 262
 263static int test_aead(struct crypto_aead *tfm, int enc,
 264                     struct aead_testvec *template, unsigned int tcount)
 265{
 266        const char *algo = crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm));
 267        unsigned int i, j, k, n, temp;
 268        int ret = 0;
 269        char *q;
 270        char *key;
 271        struct aead_request *req;
 272        struct scatterlist sg[8];
 273        struct scatterlist asg[8];
 274        const char *e;
 275        struct tcrypt_result result;
 276        unsigned int authsize;
 277        void *input;
 278        void *assoc;
 279        char iv[MAX_IVLEN];
 280
 281        if (enc == ENCRYPT)
 282                e = "encryption";
 283        else
 284                e = "decryption";
 285
 286        init_completion(&result.completion);
 287
 288        req = aead_request_alloc(tfm, GFP_KERNEL);
 289        if (!req) {
 290                printk(KERN_ERR "alg: aead: Failed to allocate request for "
 291                       "%s\n", algo);
 292                ret = -ENOMEM;
 293                goto out;
 294        }
 295
 296        aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
 297                                  tcrypt_complete, &result);
 298
 299        for (i = 0, j = 0; i < tcount; i++) {
 300                if (!template[i].np) {
 301                        j++;
 302
 303                        /* some tepmplates have no input data but they will
 304                         * touch input
 305                         */
 306                        input = xbuf[0];
 307                        assoc = axbuf[0];
 308
 309                        memcpy(input, template[i].input, template[i].ilen);
 310                        memcpy(assoc, template[i].assoc, template[i].alen);
 311                        if (template[i].iv)
 312                                memcpy(iv, template[i].iv, MAX_IVLEN);
 313                        else
 314                                memset(iv, 0, MAX_IVLEN);
 315
 316                        crypto_aead_clear_flags(tfm, ~0);
 317                        if (template[i].wk)
 318                                crypto_aead_set_flags(
 319                                        tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 320
 321                        key = template[i].key;
 322
 323                        ret = crypto_aead_setkey(tfm, key,
 324                                                 template[i].klen);
 325                        if (!ret == template[i].fail) {
 326                                printk(KERN_ERR "alg: aead: setkey failed on "
 327                                       "test %d for %s: flags=%x\n", j, algo,
 328                                       crypto_aead_get_flags(tfm));
 329                                goto out;
 330                        } else if (ret)
 331                                continue;
 332
 333                        authsize = abs(template[i].rlen - template[i].ilen);
 334                        ret = crypto_aead_setauthsize(tfm, authsize);
 335                        if (ret) {
 336                                printk(KERN_ERR "alg: aead: Failed to set "
 337                                       "authsize to %u on test %d for %s\n",
 338                                       authsize, j, algo);
 339                                goto out;
 340                        }
 341
 342                        sg_init_one(&sg[0], input,
 343                                    template[i].ilen + (enc ? authsize : 0));
 344
 345                        sg_init_one(&asg[0], assoc, template[i].alen);
 346
 347                        aead_request_set_crypt(req, sg, sg,
 348                                               template[i].ilen, iv);
 349
 350                        aead_request_set_assoc(req, asg, template[i].alen);
 351
 352                        ret = enc ?
 353                                crypto_aead_encrypt(req) :
 354                                crypto_aead_decrypt(req);
 355
 356                        switch (ret) {
 357                        case 0:
 358                                break;
 359                        case -EINPROGRESS:
 360                        case -EBUSY:
 361                                ret = wait_for_completion_interruptible(
 362                                        &result.completion);
 363                                if (!ret && !(ret = result.err)) {
 364                                        INIT_COMPLETION(result.completion);
 365                                        break;
 366                                }
 367                                /* fall through */
 368                        default:
 369                                printk(KERN_ERR "alg: aead: %s failed on test "
 370                                       "%d for %s: ret=%d\n", e, j, algo, -ret);
 371                                goto out;
 372                        }
 373
 374                        q = input;
 375                        if (memcmp(q, template[i].result, template[i].rlen)) {
 376                                printk(KERN_ERR "alg: aead: Test %d failed on "
 377                                       "%s for %s\n", j, e, algo);
 378                                hexdump(q, template[i].rlen);
 379                                ret = -EINVAL;
 380                                goto out;
 381                        }
 382                }
 383        }
 384
 385        for (i = 0, j = 0; i < tcount; i++) {
 386                if (template[i].np) {
 387                        j++;
 388
 389                        if (template[i].iv)
 390                                memcpy(iv, template[i].iv, MAX_IVLEN);
 391                        else
 392                                memset(iv, 0, MAX_IVLEN);
 393
 394                        crypto_aead_clear_flags(tfm, ~0);
 395                        if (template[i].wk)
 396                                crypto_aead_set_flags(
 397                                        tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 398                        key = template[i].key;
 399
 400                        ret = crypto_aead_setkey(tfm, key, template[i].klen);
 401                        if (!ret == template[i].fail) {
 402                                printk(KERN_ERR "alg: aead: setkey failed on "
 403                                       "chunk test %d for %s: flags=%x\n", j,
 404                                       algo, crypto_aead_get_flags(tfm));
 405                                goto out;
 406                        } else if (ret)
 407                                continue;
 408
 409                        authsize = abs(template[i].rlen - template[i].ilen);
 410
 411                        ret = -EINVAL;
 412                        sg_init_table(sg, template[i].np);
 413                        for (k = 0, temp = 0; k < template[i].np; k++) {
 414                                if (WARN_ON(offset_in_page(IDX[k]) +
 415                                            template[i].tap[k] > PAGE_SIZE))
 416                                        goto out;
 417
 418                                q = xbuf[IDX[k] >> PAGE_SHIFT] +
 419                                    offset_in_page(IDX[k]);
 420
 421                                memcpy(q, template[i].input + temp,
 422                                       template[i].tap[k]);
 423
 424                                n = template[i].tap[k];
 425                                if (k == template[i].np - 1 && enc)
 426                                        n += authsize;
 427                                if (offset_in_page(q) + n < PAGE_SIZE)
 428                                        q[n] = 0;
 429
 430                                sg_set_buf(&sg[k], q, template[i].tap[k]);
 431                                temp += template[i].tap[k];
 432                        }
 433
 434                        ret = crypto_aead_setauthsize(tfm, authsize);
 435                        if (ret) {
 436                                printk(KERN_ERR "alg: aead: Failed to set "
 437                                       "authsize to %u on chunk test %d for "
 438                                       "%s\n", authsize, j, algo);
 439                                goto out;
 440                        }
 441
 442                        if (enc) {
 443                                if (WARN_ON(sg[k - 1].offset +
 444                                            sg[k - 1].length + authsize >
 445                                            PAGE_SIZE)) {
 446                                        ret = -EINVAL;
 447                                        goto out;
 448                                }
 449
 450                                sg[k - 1].length += authsize;
 451                        }
 452
 453                        sg_init_table(asg, template[i].anp);
 454                        for (k = 0, temp = 0; k < template[i].anp; k++) {
 455                                sg_set_buf(&asg[k],
 456                                           memcpy(axbuf[IDX[k] >> PAGE_SHIFT] +
 457                                                  offset_in_page(IDX[k]),
 458                                                  template[i].assoc + temp,
 459                                                  template[i].atap[k]),
 460                                           template[i].atap[k]);
 461                                temp += template[i].atap[k];
 462                        }
 463
 464                        aead_request_set_crypt(req, sg, sg,
 465                                               template[i].ilen,
 466                                               iv);
 467
 468                        aead_request_set_assoc(req, asg, template[i].alen);
 469
 470                        ret = enc ?
 471                                crypto_aead_encrypt(req) :
 472                                crypto_aead_decrypt(req);
 473
 474                        switch (ret) {
 475                        case 0:
 476                                break;
 477                        case -EINPROGRESS:
 478                        case -EBUSY:
 479                                ret = wait_for_completion_interruptible(
 480                                        &result.completion);
 481                                if (!ret && !(ret = result.err)) {
 482                                        INIT_COMPLETION(result.completion);
 483                                        break;
 484                                }
 485                                /* fall through */
 486                        default:
 487                                printk(KERN_ERR "alg: aead: %s failed on "
 488                                       "chunk test %d for %s: ret=%d\n", e, j,
 489                                       algo, -ret);
 490                                goto out;
 491                        }
 492
 493                        ret = -EINVAL;
 494                        for (k = 0, temp = 0; k < template[i].np; k++) {
 495                                q = xbuf[IDX[k] >> PAGE_SHIFT] +
 496                                    offset_in_page(IDX[k]);
 497
 498                                n = template[i].tap[k];
 499                                if (k == template[i].np - 1)
 500                                        n += enc ? authsize : -authsize;
 501
 502                                if (memcmp(q, template[i].result + temp, n)) {
 503                                        printk(KERN_ERR "alg: aead: Chunk "
 504                                               "test %d failed on %s at page "
 505                                               "%u for %s\n", j, e, k, algo);
 506                                        hexdump(q, n);
 507                                        goto out;
 508                                }
 509
 510                                q += n;
 511                                if (k == template[i].np - 1 && !enc) {
 512                                        if (memcmp(q, template[i].input +
 513                                                      temp + n, authsize))
 514                                                n = authsize;
 515                                        else
 516                                                n = 0;
 517                                } else {
 518                                        for (n = 0; offset_in_page(q + n) &&
 519                                                    q[n]; n++)
 520                                                ;
 521                                }
 522                                if (n) {
 523                                        printk(KERN_ERR "alg: aead: Result "
 524                                               "buffer corruption in chunk "
 525                                               "test %d on %s at page %u for "
 526                                               "%s: %u bytes:\n", j, e, k,
 527                                               algo, n);
 528                                        hexdump(q, n);
 529                                        goto out;
 530                                }
 531
 532                                temp += template[i].tap[k];
 533                        }
 534                }
 535        }
 536
 537        ret = 0;
 538
 539out:
 540        aead_request_free(req);
 541        return ret;
 542}
 543
 544static int test_cipher(struct crypto_cipher *tfm, int enc,
 545                       struct cipher_testvec *template, unsigned int tcount)
 546{
 547        const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm));
 548        unsigned int i, j, k;
 549        int ret;
 550        char *q;
 551        const char *e;
 552        void *data;
 553
 554        if (enc == ENCRYPT)
 555                e = "encryption";
 556        else
 557                e = "decryption";
 558
 559        j = 0;
 560        for (i = 0; i < tcount; i++) {
 561                if (template[i].np)
 562                        continue;
 563
 564                j++;
 565
 566                data = xbuf[0];
 567                memcpy(data, template[i].input, template[i].ilen);
 568
 569                crypto_cipher_clear_flags(tfm, ~0);
 570                if (template[i].wk)
 571                        crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 572
 573                ret = crypto_cipher_setkey(tfm, template[i].key,
 574                                           template[i].klen);
 575                if (!ret == template[i].fail) {
 576                        printk(KERN_ERR "alg: cipher: setkey failed "
 577                               "on test %d for %s: flags=%x\n", j,
 578                               algo, crypto_cipher_get_flags(tfm));
 579                        goto out;
 580                } else if (ret)
 581                        continue;
 582
 583                for (k = 0; k < template[i].ilen;
 584                     k += crypto_cipher_blocksize(tfm)) {
 585                        if (enc)
 586                                crypto_cipher_encrypt_one(tfm, data + k,
 587                                                          data + k);
 588                        else
 589                                crypto_cipher_decrypt_one(tfm, data + k,
 590                                                          data + k);
 591                }
 592
 593                q = data;
 594                if (memcmp(q, template[i].result, template[i].rlen)) {
 595                        printk(KERN_ERR "alg: cipher: Test %d failed "
 596                               "on %s for %s\n", j, e, algo);
 597                        hexdump(q, template[i].rlen);
 598                        ret = -EINVAL;
 599                        goto out;
 600                }
 601        }
 602
 603        ret = 0;
 604
 605out:
 606        return ret;
 607}
 608
 609static int test_skcipher(struct crypto_ablkcipher *tfm, int enc,
 610                         struct cipher_testvec *template, unsigned int tcount)
 611{
 612        const char *algo =
 613                crypto_tfm_alg_driver_name(crypto_ablkcipher_tfm(tfm));
 614        unsigned int i, j, k, n, temp;
 615        int ret;
 616        char *q;
 617        struct ablkcipher_request *req;
 618        struct scatterlist sg[8];
 619        const char *e;
 620        struct tcrypt_result result;
 621        void *data;
 622        char iv[MAX_IVLEN];
 623
 624        if (enc == ENCRYPT)
 625                e = "encryption";
 626        else
 627                e = "decryption";
 628
 629        init_completion(&result.completion);
 630
 631        req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
 632        if (!req) {
 633                printk(KERN_ERR "alg: skcipher: Failed to allocate request "
 634                       "for %s\n", algo);
 635                ret = -ENOMEM;
 636                goto out;
 637        }
 638
 639        ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
 640                                        tcrypt_complete, &result);
 641
 642        j = 0;
 643        for (i = 0; i < tcount; i++) {
 644                if (template[i].iv)
 645                        memcpy(iv, template[i].iv, MAX_IVLEN);
 646                else
 647                        memset(iv, 0, MAX_IVLEN);
 648
 649                if (!(template[i].np)) {
 650                        j++;
 651
 652                        data = xbuf[0];
 653                        memcpy(data, template[i].input, template[i].ilen);
 654
 655                        crypto_ablkcipher_clear_flags(tfm, ~0);
 656                        if (template[i].wk)
 657                                crypto_ablkcipher_set_flags(
 658                                        tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 659
 660                        ret = crypto_ablkcipher_setkey(tfm, template[i].key,
 661                                                       template[i].klen);
 662                        if (!ret == template[i].fail) {
 663                                printk(KERN_ERR "alg: skcipher: setkey failed "
 664                                       "on test %d for %s: flags=%x\n", j,
 665                                       algo, crypto_ablkcipher_get_flags(tfm));
 666                                goto out;
 667                        } else if (ret)
 668                                continue;
 669
 670                        sg_init_one(&sg[0], data, template[i].ilen);
 671
 672                        ablkcipher_request_set_crypt(req, sg, sg,
 673                                                     template[i].ilen, iv);
 674                        ret = enc ?
 675                                crypto_ablkcipher_encrypt(req) :
 676                                crypto_ablkcipher_decrypt(req);
 677
 678                        switch (ret) {
 679                        case 0:
 680                                break;
 681                        case -EINPROGRESS:
 682                        case -EBUSY:
 683                                ret = wait_for_completion_interruptible(
 684                                        &result.completion);
 685                                if (!ret && !((ret = result.err))) {
 686                                        INIT_COMPLETION(result.completion);
 687                                        break;
 688                                }
 689                                /* fall through */
 690                        default:
 691                                printk(KERN_ERR "alg: skcipher: %s failed on "
 692                                       "test %d for %s: ret=%d\n", e, j, algo,
 693                                       -ret);
 694                                goto out;
 695                        }
 696
 697                        q = data;
 698                        if (memcmp(q, template[i].result, template[i].rlen)) {
 699                                printk(KERN_ERR "alg: skcipher: Test %d "
 700                                       "failed on %s for %s\n", j, e, algo);
 701                                hexdump(q, template[i].rlen);
 702                                ret = -EINVAL;
 703                                goto out;
 704                        }
 705                }
 706        }
 707
 708        j = 0;
 709        for (i = 0; i < tcount; i++) {
 710
 711                if (template[i].iv)
 712                        memcpy(iv, template[i].iv, MAX_IVLEN);
 713                else
 714                        memset(iv, 0, MAX_IVLEN);
 715
 716                if (template[i].np) {
 717                        j++;
 718
 719                        crypto_ablkcipher_clear_flags(tfm, ~0);
 720                        if (template[i].wk)
 721                                crypto_ablkcipher_set_flags(
 722                                        tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 723
 724                        ret = crypto_ablkcipher_setkey(tfm, template[i].key,
 725                                                       template[i].klen);
 726                        if (!ret == template[i].fail) {
 727                                printk(KERN_ERR "alg: skcipher: setkey failed "
 728                                       "on chunk test %d for %s: flags=%x\n",
 729                                       j, algo,
 730                                       crypto_ablkcipher_get_flags(tfm));
 731                                goto out;
 732                        } else if (ret)
 733                                continue;
 734
 735                        temp = 0;
 736                        ret = -EINVAL;
 737                        sg_init_table(sg, template[i].np);
 738                        for (k = 0; k < template[i].np; k++) {
 739                                if (WARN_ON(offset_in_page(IDX[k]) +
 740                                            template[i].tap[k] > PAGE_SIZE))
 741                                        goto out;
 742
 743                                q = xbuf[IDX[k] >> PAGE_SHIFT] +
 744                                    offset_in_page(IDX[k]);
 745
 746                                memcpy(q, template[i].input + temp,
 747                                       template[i].tap[k]);
 748
 749                                if (offset_in_page(q) + template[i].tap[k] <
 750                                    PAGE_SIZE)
 751                                        q[template[i].tap[k]] = 0;
 752
 753                                sg_set_buf(&sg[k], q, template[i].tap[k]);
 754
 755                                temp += template[i].tap[k];
 756                        }
 757
 758                        ablkcipher_request_set_crypt(req, sg, sg,
 759                                        template[i].ilen, iv);
 760
 761                        ret = enc ?
 762                                crypto_ablkcipher_encrypt(req) :
 763                                crypto_ablkcipher_decrypt(req);
 764
 765                        switch (ret) {
 766                        case 0:
 767                                break;
 768                        case -EINPROGRESS:
 769                        case -EBUSY:
 770                                ret = wait_for_completion_interruptible(
 771                                        &result.completion);
 772                                if (!ret && !((ret = result.err))) {
 773                                        INIT_COMPLETION(result.completion);
 774                                        break;
 775                                }
 776                                /* fall through */
 777                        default:
 778                                printk(KERN_ERR "alg: skcipher: %s failed on "
 779                                       "chunk test %d for %s: ret=%d\n", e, j,
 780                                       algo, -ret);
 781                                goto out;
 782                        }
 783
 784                        temp = 0;
 785                        ret = -EINVAL;
 786                        for (k = 0; k < template[i].np; k++) {
 787                                q = xbuf[IDX[k] >> PAGE_SHIFT] +
 788                                    offset_in_page(IDX[k]);
 789
 790                                if (memcmp(q, template[i].result + temp,
 791                                           template[i].tap[k])) {
 792                                        printk(KERN_ERR "alg: skcipher: Chunk "
 793                                               "test %d failed on %s at page "
 794                                               "%u for %s\n", j, e, k, algo);
 795                                        hexdump(q, template[i].tap[k]);
 796                                        goto out;
 797                                }
 798
 799                                q += template[i].tap[k];
 800                                for (n = 0; offset_in_page(q + n) && q[n]; n++)
 801                                        ;
 802                                if (n) {
 803                                        printk(KERN_ERR "alg: skcipher: "
 804                                               "Result buffer corruption in "
 805                                               "chunk test %d on %s at page "
 806                                               "%u for %s: %u bytes:\n", j, e,
 807                                               k, algo, n);
 808                                        hexdump(q, n);
 809                                        goto out;
 810                                }
 811                                temp += template[i].tap[k];
 812                        }
 813                }
 814        }
 815
 816        ret = 0;
 817
 818out:
 819        ablkcipher_request_free(req);
 820        return ret;
 821}
 822
 823static int test_comp(struct crypto_comp *tfm, struct comp_testvec *ctemplate,
 824                     struct comp_testvec *dtemplate, int ctcount, int dtcount)
 825{
 826        const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
 827        unsigned int i;
 828        char result[COMP_BUF_SIZE];
 829        int ret;
 830
 831        for (i = 0; i < ctcount; i++) {
 832                int ilen, dlen = COMP_BUF_SIZE;
 833
 834                memset(result, 0, sizeof (result));
 835
 836                ilen = ctemplate[i].inlen;
 837                ret = crypto_comp_compress(tfm, ctemplate[i].input,
 838                                           ilen, result, &dlen);
 839                if (ret) {
 840                        printk(KERN_ERR "alg: comp: compression failed "
 841                               "on test %d for %s: ret=%d\n", i + 1, algo,
 842                               -ret);
 843                        goto out;
 844                }
 845
 846                if (dlen != ctemplate[i].outlen) {
 847                        printk(KERN_ERR "alg: comp: Compression test %d "
 848                               "failed for %s: output len = %d\n", i + 1, algo,
 849                               dlen);
 850                        ret = -EINVAL;
 851                        goto out;
 852                }
 853
 854                if (memcmp(result, ctemplate[i].output, dlen)) {
 855                        printk(KERN_ERR "alg: comp: Compression test %d "
 856                               "failed for %s\n", i + 1, algo);
 857                        hexdump(result, dlen);
 858                        ret = -EINVAL;
 859                        goto out;
 860                }
 861        }
 862
 863        for (i = 0; i < dtcount; i++) {
 864                int ilen, dlen = COMP_BUF_SIZE;
 865
 866                memset(result, 0, sizeof (result));
 867
 868                ilen = dtemplate[i].inlen;
 869                ret = crypto_comp_decompress(tfm, dtemplate[i].input,
 870                                             ilen, result, &dlen);
 871                if (ret) {
 872                        printk(KERN_ERR "alg: comp: decompression failed "
 873                               "on test %d for %s: ret=%d\n", i + 1, algo,
 874                               -ret);
 875                        goto out;
 876                }
 877
 878                if (dlen != dtemplate[i].outlen) {
 879                        printk(KERN_ERR "alg: comp: Decompression test %d "
 880                               "failed for %s: output len = %d\n", i + 1, algo,
 881                               dlen);
 882                        ret = -EINVAL;
 883                        goto out;
 884                }
 885
 886                if (memcmp(result, dtemplate[i].output, dlen)) {
 887                        printk(KERN_ERR "alg: comp: Decompression test %d "
 888                               "failed for %s\n", i + 1, algo);
 889                        hexdump(result, dlen);
 890                        ret = -EINVAL;
 891                        goto out;
 892                }
 893        }
 894
 895        ret = 0;
 896
 897out:
 898        return ret;
 899}
 900
 901static int alg_test_aead(const struct alg_test_desc *desc, const char *driver,
 902                         u32 type, u32 mask)
 903{
 904        struct crypto_aead *tfm;
 905        int err = 0;
 906
 907        tfm = crypto_alloc_aead(driver, type, mask);
 908        if (IS_ERR(tfm)) {
 909                printk(KERN_ERR "alg: aead: Failed to load transform for %s: "
 910                       "%ld\n", driver, PTR_ERR(tfm));
 911                return PTR_ERR(tfm);
 912        }
 913
 914        if (desc->suite.aead.enc.vecs) {
 915                err = test_aead(tfm, ENCRYPT, desc->suite.aead.enc.vecs,
 916                                desc->suite.aead.enc.count);
 917                if (err)
 918                        goto out;
 919        }
 920
 921        if (!err && desc->suite.aead.dec.vecs)
 922                err = test_aead(tfm, DECRYPT, desc->suite.aead.dec.vecs,
 923                                desc->suite.aead.dec.count);
 924
 925out:
 926        crypto_free_aead(tfm);
 927        return err;
 928}
 929
 930static int alg_test_cipher(const struct alg_test_desc *desc,
 931                           const char *driver, u32 type, u32 mask)
 932{
 933        struct crypto_cipher *tfm;
 934        int err = 0;
 935
 936        tfm = crypto_alloc_cipher(driver, type, mask);
 937        if (IS_ERR(tfm)) {
 938                printk(KERN_ERR "alg: cipher: Failed to load transform for "
 939                       "%s: %ld\n", driver, PTR_ERR(tfm));
 940                return PTR_ERR(tfm);
 941        }
 942
 943        if (desc->suite.cipher.enc.vecs) {
 944                err = test_cipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
 945                                  desc->suite.cipher.enc.count);
 946                if (err)
 947                        goto out;
 948        }
 949
 950        if (desc->suite.cipher.dec.vecs)
 951                err = test_cipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
 952                                  desc->suite.cipher.dec.count);
 953
 954out:
 955        crypto_free_cipher(tfm);
 956        return err;
 957}
 958
 959static int alg_test_skcipher(const struct alg_test_desc *desc,
 960                             const char *driver, u32 type, u32 mask)
 961{
 962        struct crypto_ablkcipher *tfm;
 963        int err = 0;
 964
 965        tfm = crypto_alloc_ablkcipher(driver, type, mask);
 966        if (IS_ERR(tfm)) {
 967                printk(KERN_ERR "alg: skcipher: Failed to load transform for "
 968                       "%s: %ld\n", driver, PTR_ERR(tfm));
 969                return PTR_ERR(tfm);
 970        }
 971
 972        if (desc->suite.cipher.enc.vecs) {
 973                err = test_skcipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
 974                                    desc->suite.cipher.enc.count);
 975                if (err)
 976                        goto out;
 977        }
 978
 979        if (desc->suite.cipher.dec.vecs)
 980                err = test_skcipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
 981                                    desc->suite.cipher.dec.count);
 982
 983out:
 984        crypto_free_ablkcipher(tfm);
 985        return err;
 986}
 987
 988static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
 989                         u32 type, u32 mask)
 990{
 991        struct crypto_comp *tfm;
 992        int err;
 993
 994        tfm = crypto_alloc_comp(driver, type, mask);
 995        if (IS_ERR(tfm)) {
 996                printk(KERN_ERR "alg: comp: Failed to load transform for %s: "
 997                       "%ld\n", driver, PTR_ERR(tfm));
 998                return PTR_ERR(tfm);
 999        }
1000
1001        err = test_comp(tfm, desc->suite.comp.comp.vecs,
1002                        desc->suite.comp.decomp.vecs,
1003                        desc->suite.comp.comp.count,
1004                        desc->suite.comp.decomp.count);
1005
1006        crypto_free_comp(tfm);
1007        return err;
1008}
1009
1010static int alg_test_hash(const struct alg_test_desc *desc, const char *driver,
1011                         u32 type, u32 mask)
1012{
1013        struct crypto_ahash *tfm;
1014        int err;
1015
1016        tfm = crypto_alloc_ahash(driver, type, mask);
1017        if (IS_ERR(tfm)) {
1018                printk(KERN_ERR "alg: hash: Failed to load transform for %s: "
1019                       "%ld\n", driver, PTR_ERR(tfm));
1020                return PTR_ERR(tfm);
1021        }
1022
1023        err = test_hash(tfm, desc->suite.hash.vecs, desc->suite.hash.count);
1024
1025        crypto_free_ahash(tfm);
1026        return err;
1027}
1028
1029static int alg_test_crc32c(const struct alg_test_desc *desc,
1030                           const char *driver, u32 type, u32 mask)
1031{
1032        struct crypto_shash *tfm;
1033        u32 val;
1034        int err;
1035
1036        err = alg_test_hash(desc, driver, type, mask);
1037        if (err)
1038                goto out;
1039
1040        tfm = crypto_alloc_shash(driver, type, mask);
1041        if (IS_ERR(tfm)) {
1042                printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: "
1043                       "%ld\n", driver, PTR_ERR(tfm));
1044                err = PTR_ERR(tfm);
1045                goto out;
1046        }
1047
1048        do {
1049                struct {
1050                        struct shash_desc shash;
1051                        char ctx[crypto_shash_descsize(tfm)];
1052                } sdesc;
1053
1054                sdesc.shash.tfm = tfm;
1055                sdesc.shash.flags = 0;
1056
1057                *(u32 *)sdesc.ctx = le32_to_cpu(420553207);
1058                err = crypto_shash_final(&sdesc.shash, (u8 *)&val);
1059                if (err) {
1060                        printk(KERN_ERR "alg: crc32c: Operation failed for "
1061                               "%s: %d\n", driver, err);
1062                        break;
1063                }
1064
1065                if (val != ~420553207) {
1066                        printk(KERN_ERR "alg: crc32c: Test failed for %s: "
1067                               "%d\n", driver, val);
1068                        err = -EINVAL;
1069                }
1070        } while (0);
1071
1072        crypto_free_shash(tfm);
1073
1074out:
1075        return err;
1076}
1077
1078/* Please keep this list sorted by algorithm name. */
1079static const struct alg_test_desc alg_test_descs[] = {
1080        {
1081                .alg = "cbc(aes)",
1082                .test = alg_test_skcipher,
1083                .suite = {
1084                        .cipher = {
1085                                .enc = {
1086                                        .vecs = aes_cbc_enc_tv_template,
1087                                        .count = AES_CBC_ENC_TEST_VECTORS
1088                                },
1089                                .dec = {
1090                                        .vecs = aes_cbc_dec_tv_template,
1091                                        .count = AES_CBC_DEC_TEST_VECTORS
1092                                }
1093                        }
1094                }
1095        }, {
1096                .alg = "cbc(anubis)",
1097                .test = alg_test_skcipher,
1098                .suite = {
1099                        .cipher = {
1100                                .enc = {
1101                                        .vecs = anubis_cbc_enc_tv_template,
1102                                        .count = ANUBIS_CBC_ENC_TEST_VECTORS
1103                                },
1104                                .dec = {
1105                                        .vecs = anubis_cbc_dec_tv_template,
1106                                        .count = ANUBIS_CBC_DEC_TEST_VECTORS
1107                                }
1108                        }
1109                }
1110        }, {
1111                .alg = "cbc(blowfish)",
1112                .test = alg_test_skcipher,
1113                .suite = {
1114                        .cipher = {
1115                                .enc = {
1116                                        .vecs = bf_cbc_enc_tv_template,
1117                                        .count = BF_CBC_ENC_TEST_VECTORS
1118                                },
1119                                .dec = {
1120                                        .vecs = bf_cbc_dec_tv_template,
1121                                        .count = BF_CBC_DEC_TEST_VECTORS
1122                                }
1123                        }
1124                }
1125        }, {
1126                .alg = "cbc(camellia)",
1127                .test = alg_test_skcipher,
1128                .suite = {
1129                        .cipher = {
1130                                .enc = {
1131                                        .vecs = camellia_cbc_enc_tv_template,
1132                                        .count = CAMELLIA_CBC_ENC_TEST_VECTORS
1133                                },
1134                                .dec = {
1135                                        .vecs = camellia_cbc_dec_tv_template,
1136                                        .count = CAMELLIA_CBC_DEC_TEST_VECTORS
1137                                }
1138                        }
1139                }
1140        }, {
1141                .alg = "cbc(des)",
1142                .test = alg_test_skcipher,
1143                .suite = {
1144                        .cipher = {
1145                                .enc = {
1146                                        .vecs = des_cbc_enc_tv_template,
1147                                        .count = DES_CBC_ENC_TEST_VECTORS
1148                                },
1149                                .dec = {
1150                                        .vecs = des_cbc_dec_tv_template,
1151                                        .count = DES_CBC_DEC_TEST_VECTORS
1152                                }
1153                        }
1154                }
1155        }, {
1156                .alg = "cbc(des3_ede)",
1157                .test = alg_test_skcipher,
1158                .suite = {
1159                        .cipher = {
1160                                .enc = {
1161                                        .vecs = des3_ede_cbc_enc_tv_template,
1162                                        .count = DES3_EDE_CBC_ENC_TEST_VECTORS
1163                                },
1164                                .dec = {
1165                                        .vecs = des3_ede_cbc_dec_tv_template,
1166                                        .count = DES3_EDE_CBC_DEC_TEST_VECTORS
1167                                }
1168                        }
1169                }
1170        }, {
1171                .alg = "cbc(twofish)",
1172                .test = alg_test_skcipher,
1173                .suite = {
1174                        .cipher = {
1175                                .enc = {
1176                                        .vecs = tf_cbc_enc_tv_template,
1177                                        .count = TF_CBC_ENC_TEST_VECTORS
1178                                },
1179                                .dec = {
1180                                        .vecs = tf_cbc_dec_tv_template,
1181                                        .count = TF_CBC_DEC_TEST_VECTORS
1182                                }
1183                        }
1184                }
1185        }, {
1186                .alg = "ccm(aes)",
1187                .test = alg_test_aead,
1188                .suite = {
1189                        .aead = {
1190                                .enc = {
1191                                        .vecs = aes_ccm_enc_tv_template,
1192                                        .count = AES_CCM_ENC_TEST_VECTORS
1193                                },
1194                                .dec = {
1195                                        .vecs = aes_ccm_dec_tv_template,
1196                                        .count = AES_CCM_DEC_TEST_VECTORS
1197                                }
1198                        }
1199                }
1200        }, {
1201                .alg = "crc32c",
1202                .test = alg_test_crc32c,
1203                .suite = {
1204                        .hash = {
1205                                .vecs = crc32c_tv_template,
1206                                .count = CRC32C_TEST_VECTORS
1207                        }
1208                }
1209        }, {
1210                .alg = "cts(cbc(aes))",
1211                .test = alg_test_skcipher,
1212                .suite = {
1213                        .cipher = {
1214                                .enc = {
1215                                        .vecs = cts_mode_enc_tv_template,
1216                                        .count = CTS_MODE_ENC_TEST_VECTORS
1217                                },
1218                                .dec = {
1219                                        .vecs = cts_mode_dec_tv_template,
1220                                        .count = CTS_MODE_DEC_TEST_VECTORS
1221                                }
1222                        }
1223                }
1224        }, {
1225                .alg = "deflate",
1226                .test = alg_test_comp,
1227                .suite = {
1228                        .comp = {
1229                                .comp = {
1230                                        .vecs = deflate_comp_tv_template,
1231                                        .count = DEFLATE_COMP_TEST_VECTORS
1232                                },
1233                                .decomp = {
1234                                        .vecs = deflate_decomp_tv_template,
1235                                        .count = DEFLATE_DECOMP_TEST_VECTORS
1236                                }
1237                        }
1238                }
1239        }, {
1240                .alg = "ecb(aes)",
1241                .test = alg_test_skcipher,
1242                .suite = {
1243                        .cipher = {
1244                                .enc = {
1245                                        .vecs = aes_enc_tv_template,
1246                                        .count = AES_ENC_TEST_VECTORS
1247                                },
1248                                .dec = {
1249                                        .vecs = aes_dec_tv_template,
1250                                        .count = AES_DEC_TEST_VECTORS
1251                                }
1252                        }
1253                }
1254        }, {
1255                .alg = "ecb(anubis)",
1256                .test = alg_test_skcipher,
1257                .suite = {
1258                        .cipher = {
1259                                .enc = {
1260                                        .vecs = anubis_enc_tv_template,
1261                                        .count = ANUBIS_ENC_TEST_VECTORS
1262                                },
1263                                .dec = {
1264                                        .vecs = anubis_dec_tv_template,
1265                                        .count = ANUBIS_DEC_TEST_VECTORS
1266                                }
1267                        }
1268                }
1269        }, {
1270                .alg = "ecb(arc4)",
1271                .test = alg_test_skcipher,
1272                .suite = {
1273                        .cipher = {
1274                                .enc = {
1275                                        .vecs = arc4_enc_tv_template,
1276                                        .count = ARC4_ENC_TEST_VECTORS
1277                                },
1278                                .dec = {
1279                                        .vecs = arc4_dec_tv_template,
1280                                        .count = ARC4_DEC_TEST_VECTORS
1281                                }
1282                        }
1283                }
1284        }, {
1285                .alg = "ecb(blowfish)",
1286                .test = alg_test_skcipher,
1287                .suite = {
1288                        .cipher = {
1289                                .enc = {
1290                                        .vecs = bf_enc_tv_template,
1291                                        .count = BF_ENC_TEST_VECTORS
1292                                },
1293                                .dec = {
1294                                        .vecs = bf_dec_tv_template,
1295                                        .count = BF_DEC_TEST_VECTORS
1296                                }
1297                        }
1298                }
1299        }, {
1300                .alg = "ecb(camellia)",
1301                .test = alg_test_skcipher,
1302                .suite = {
1303                        .cipher = {
1304                                .enc = {
1305                                        .vecs = camellia_enc_tv_template,
1306                                        .count = CAMELLIA_ENC_TEST_VECTORS
1307                                },
1308                                .dec = {
1309                                        .vecs = camellia_dec_tv_template,
1310                                        .count = CAMELLIA_DEC_TEST_VECTORS
1311                                }
1312                        }
1313                }
1314        }, {
1315                .alg = "ecb(cast5)",
1316                .test = alg_test_skcipher,
1317                .suite = {
1318                        .cipher = {
1319                                .enc = {
1320                                        .vecs = cast5_enc_tv_template,
1321                                        .count = CAST5_ENC_TEST_VECTORS
1322                                },
1323                                .dec = {
1324                                        .vecs = cast5_dec_tv_template,
1325                                        .count = CAST5_DEC_TEST_VECTORS
1326                                }
1327                        }
1328                }
1329        }, {
1330                .alg = "ecb(cast6)",
1331                .test = alg_test_skcipher,
1332                .suite = {
1333                        .cipher = {
1334                                .enc = {
1335                                        .vecs = cast6_enc_tv_template,
1336                                        .count = CAST6_ENC_TEST_VECTORS
1337                                },
1338                                .dec = {
1339                                        .vecs = cast6_dec_tv_template,
1340                                        .count = CAST6_DEC_TEST_VECTORS
1341                                }
1342                        }
1343                }
1344        }, {
1345                .alg = "ecb(des)",
1346                .test = alg_test_skcipher,
1347                .suite = {
1348                        .cipher = {
1349                                .enc = {
1350                                        .vecs = des_enc_tv_template,
1351                                        .count = DES_ENC_TEST_VECTORS
1352                                },
1353                                .dec = {
1354                                        .vecs = des_dec_tv_template,
1355                                        .count = DES_DEC_TEST_VECTORS
1356                                }
1357                        }
1358                }
1359        }, {
1360                .alg = "ecb(des3_ede)",
1361                .test = alg_test_skcipher,
1362                .suite = {
1363                        .cipher = {
1364                                .enc = {
1365                                        .vecs = des3_ede_enc_tv_template,
1366                                        .count = DES3_EDE_ENC_TEST_VECTORS
1367                                },
1368                                .dec = {
1369                                        .vecs = des3_ede_dec_tv_template,
1370                                        .count = DES3_EDE_DEC_TEST_VECTORS
1371                                }
1372                        }
1373                }
1374        }, {
1375                .alg = "ecb(khazad)",
1376                .test = alg_test_skcipher,
1377                .suite = {
1378                        .cipher = {
1379                                .enc = {
1380                                        .vecs = khazad_enc_tv_template,
1381                                        .count = KHAZAD_ENC_TEST_VECTORS
1382                                },
1383                                .dec = {
1384                                        .vecs = khazad_dec_tv_template,
1385                                        .count = KHAZAD_DEC_TEST_VECTORS
1386                                }
1387                        }
1388                }
1389        }, {
1390                .alg = "ecb(seed)",
1391                .test = alg_test_skcipher,
1392                .suite = {
1393                        .cipher = {
1394                                .enc = {
1395                                        .vecs = seed_enc_tv_template,
1396                                        .count = SEED_ENC_TEST_VECTORS
1397                                },
1398                                .dec = {
1399                                        .vecs = seed_dec_tv_template,
1400                                        .count = SEED_DEC_TEST_VECTORS
1401                                }
1402                        }
1403                }
1404        }, {
1405                .alg = "ecb(serpent)",
1406                .test = alg_test_skcipher,
1407                .suite = {
1408                        .cipher = {
1409                                .enc = {
1410                                        .vecs = serpent_enc_tv_template,
1411                                        .count = SERPENT_ENC_TEST_VECTORS
1412                                },
1413                                .dec = {
1414                                        .vecs = serpent_dec_tv_template,
1415                                        .count = SERPENT_DEC_TEST_VECTORS
1416                                }
1417                        }
1418                }
1419        }, {
1420                .alg = "ecb(tea)",
1421                .test = alg_test_skcipher,
1422                .suite = {
1423                        .cipher = {
1424                                .enc = {
1425                                        .vecs = tea_enc_tv_template,
1426                                        .count = TEA_ENC_TEST_VECTORS
1427                                },
1428                                .dec = {
1429                                        .vecs = tea_dec_tv_template,
1430                                        .count = TEA_DEC_TEST_VECTORS
1431                                }
1432                        }
1433                }
1434        }, {
1435                .alg = "ecb(tnepres)",
1436                .test = alg_test_skcipher,
1437                .suite = {
1438                        .cipher = {
1439                                .enc = {
1440                                        .vecs = tnepres_enc_tv_template,
1441                                        .count = TNEPRES_ENC_TEST_VECTORS
1442                                },
1443                                .dec = {
1444                                        .vecs = tnepres_dec_tv_template,
1445                                        .count = TNEPRES_DEC_TEST_VECTORS
1446                                }
1447                        }
1448                }
1449        }, {
1450                .alg = "ecb(twofish)",
1451                .test = alg_test_skcipher,
1452                .suite = {
1453                        .cipher = {
1454                                .enc = {
1455                                        .vecs = tf_enc_tv_template,
1456                                        .count = TF_ENC_TEST_VECTORS
1457                                },
1458                                .dec = {
1459                                        .vecs = tf_dec_tv_template,
1460                                        .count = TF_DEC_TEST_VECTORS
1461                                }
1462                        }
1463                }
1464        }, {
1465                .alg = "ecb(xeta)",
1466                .test = alg_test_skcipher,
1467                .suite = {
1468                        .cipher = {
1469                                .enc = {
1470                                        .vecs = xeta_enc_tv_template,
1471                                        .count = XETA_ENC_TEST_VECTORS
1472                                },
1473                                .dec = {
1474                                        .vecs = xeta_dec_tv_template,
1475                                        .count = XETA_DEC_TEST_VECTORS
1476                                }
1477                        }
1478                }
1479        }, {
1480                .alg = "ecb(xtea)",
1481                .test = alg_test_skcipher,
1482                .suite = {
1483                        .cipher = {
1484                                .enc = {
1485                                        .vecs = xtea_enc_tv_template,
1486                                        .count = XTEA_ENC_TEST_VECTORS
1487                                },
1488                                .dec = {
1489                                        .vecs = xtea_dec_tv_template,
1490                                        .count = XTEA_DEC_TEST_VECTORS
1491                                }
1492                        }
1493                }
1494        }, {
1495                .alg = "gcm(aes)",
1496                .test = alg_test_aead,
1497                .suite = {
1498                        .aead = {
1499                                .enc = {
1500                                        .vecs = aes_gcm_enc_tv_template,
1501                                        .count = AES_GCM_ENC_TEST_VECTORS
1502                                },
1503                                .dec = {
1504                                        .vecs = aes_gcm_dec_tv_template,
1505                                        .count = AES_GCM_DEC_TEST_VECTORS
1506                                }
1507                        }
1508                }
1509        }, {
1510                .alg = "hmac(md5)",
1511                .test = alg_test_hash,
1512                .suite = {
1513                        .hash = {
1514                                .vecs = hmac_md5_tv_template,
1515                                .count = HMAC_MD5_TEST_VECTORS
1516                        }
1517                }
1518        }, {
1519                .alg = "hmac(rmd128)",
1520                .test = alg_test_hash,
1521                .suite = {
1522                        .hash = {
1523                                .vecs = hmac_rmd128_tv_template,
1524                                .count = HMAC_RMD128_TEST_VECTORS
1525                        }
1526                }
1527        }, {
1528                .alg = "hmac(rmd160)",
1529                .test = alg_test_hash,
1530                .suite = {
1531                        .hash = {
1532                                .vecs = hmac_rmd160_tv_template,
1533                                .count = HMAC_RMD160_TEST_VECTORS
1534                        }
1535                }
1536        }, {
1537                .alg = "hmac(sha1)",
1538                .test = alg_test_hash,
1539                .suite = {
1540                        .hash = {
1541                                .vecs = hmac_sha1_tv_template,
1542                                .count = HMAC_SHA1_TEST_VECTORS
1543                        }
1544                }
1545        }, {
1546                .alg = "hmac(sha224)",
1547                .test = alg_test_hash,
1548                .suite = {
1549                        .hash = {
1550                                .vecs = hmac_sha224_tv_template,
1551                                .count = HMAC_SHA224_TEST_VECTORS
1552                        }
1553                }
1554        }, {
1555                .alg = "hmac(sha256)",
1556                .test = alg_test_hash,
1557                .suite = {
1558                        .hash = {
1559                                .vecs = hmac_sha256_tv_template,
1560                                .count = HMAC_SHA256_TEST_VECTORS
1561                        }
1562                }
1563        }, {
1564                .alg = "hmac(sha384)",
1565                .test = alg_test_hash,
1566                .suite = {
1567                        .hash = {
1568                                .vecs = hmac_sha384_tv_template,
1569                                .count = HMAC_SHA384_TEST_VECTORS
1570                        }
1571                }
1572        }, {
1573                .alg = "hmac(sha512)",
1574                .test = alg_test_hash,
1575                .suite = {
1576                        .hash = {
1577                                .vecs = hmac_sha512_tv_template,
1578                                .count = HMAC_SHA512_TEST_VECTORS
1579                        }
1580                }
1581        }, {
1582                .alg = "lrw(aes)",
1583                .test = alg_test_skcipher,
1584                .suite = {
1585                        .cipher = {
1586                                .enc = {
1587                                        .vecs = aes_lrw_enc_tv_template,
1588                                        .count = AES_LRW_ENC_TEST_VECTORS
1589                                },
1590                                .dec = {
1591                                        .vecs = aes_lrw_dec_tv_template,
1592                                        .count = AES_LRW_DEC_TEST_VECTORS
1593                                }
1594                        }
1595                }
1596        }, {
1597                .alg = "lzo",
1598                .test = alg_test_comp,
1599                .suite = {
1600                        .comp = {
1601                                .comp = {
1602                                        .vecs = lzo_comp_tv_template,
1603                                        .count = LZO_COMP_TEST_VECTORS
1604                                },
1605                                .decomp = {
1606                                        .vecs = lzo_decomp_tv_template,
1607                                        .count = LZO_DECOMP_TEST_VECTORS
1608                                }
1609                        }
1610                }
1611        }, {
1612                .alg = "md4",
1613                .test = alg_test_hash,
1614                .suite = {
1615                        .hash = {
1616                                .vecs = md4_tv_template,
1617                                .count = MD4_TEST_VECTORS
1618                        }
1619                }
1620        }, {
1621                .alg = "md5",
1622                .test = alg_test_hash,
1623                .suite = {
1624                        .hash = {
1625                                .vecs = md5_tv_template,
1626                                .count = MD5_TEST_VECTORS
1627                        }
1628                }
1629        }, {
1630                .alg = "michael_mic",
1631                .test = alg_test_hash,
1632                .suite = {
1633                        .hash = {
1634                                .vecs = michael_mic_tv_template,
1635                                .count = MICHAEL_MIC_TEST_VECTORS
1636                        }
1637                }
1638        }, {
1639                .alg = "pcbc(fcrypt)",
1640                .test = alg_test_skcipher,
1641                .suite = {
1642                        .cipher = {
1643                                .enc = {
1644                                        .vecs = fcrypt_pcbc_enc_tv_template,
1645                                        .count = FCRYPT_ENC_TEST_VECTORS
1646                                },
1647                                .dec = {
1648                                        .vecs = fcrypt_pcbc_dec_tv_template,
1649                                        .count = FCRYPT_DEC_TEST_VECTORS
1650                                }
1651                        }
1652                }
1653        }, {
1654                .alg = "rfc3686(ctr(aes))",
1655                .test = alg_test_skcipher,
1656                .suite = {
1657                        .cipher = {
1658                                .enc = {
1659                                        .vecs = aes_ctr_enc_tv_template,
1660                                        .count = AES_CTR_ENC_TEST_VECTORS
1661                                },
1662                                .dec = {
1663                                        .vecs = aes_ctr_dec_tv_template,
1664                                        .count = AES_CTR_DEC_TEST_VECTORS
1665                                }
1666                        }
1667                }
1668        }, {
1669                .alg = "rmd128",
1670                .test = alg_test_hash,
1671                .suite = {
1672                        .hash = {
1673                                .vecs = rmd128_tv_template,
1674                                .count = RMD128_TEST_VECTORS
1675                        }
1676                }
1677        }, {
1678                .alg = "rmd160",
1679                .test = alg_test_hash,
1680                .suite = {
1681                        .hash = {
1682                                .vecs = rmd160_tv_template,
1683                                .count = RMD160_TEST_VECTORS
1684                        }
1685                }
1686        }, {
1687                .alg = "rmd256",
1688                .test = alg_test_hash,
1689                .suite = {
1690                        .hash = {
1691                                .vecs = rmd256_tv_template,
1692                                .count = RMD256_TEST_VECTORS
1693                        }
1694                }
1695        }, {
1696                .alg = "rmd320",
1697                .test = alg_test_hash,
1698                .suite = {
1699                        .hash = {
1700                                .vecs = rmd320_tv_template,
1701                                .count = RMD320_TEST_VECTORS
1702                        }
1703                }
1704        }, {
1705                .alg = "salsa20",
1706                .test = alg_test_skcipher,
1707                .suite = {
1708                        .cipher = {
1709                                .enc = {
1710                                        .vecs = salsa20_stream_enc_tv_template,
1711                                        .count = SALSA20_STREAM_ENC_TEST_VECTORS
1712                                }
1713                        }
1714                }
1715        }, {
1716                .alg = "sha1",
1717                .test = alg_test_hash,
1718                .suite = {
1719                        .hash = {
1720                                .vecs = sha1_tv_template,
1721                                .count = SHA1_TEST_VECTORS
1722                        }
1723                }
1724        }, {
1725                .alg = "sha224",
1726                .test = alg_test_hash,
1727                .suite = {
1728                        .hash = {
1729                                .vecs = sha224_tv_template,
1730                                .count = SHA224_TEST_VECTORS
1731                        }
1732                }
1733        }, {
1734                .alg = "sha256",
1735                .test = alg_test_hash,
1736                .suite = {
1737                        .hash = {
1738                                .vecs = sha256_tv_template,
1739                                .count = SHA256_TEST_VECTORS
1740                        }
1741                }
1742        }, {
1743                .alg = "sha384",
1744                .test = alg_test_hash,
1745                .suite = {
1746                        .hash = {
1747                                .vecs = sha384_tv_template,
1748                                .count = SHA384_TEST_VECTORS
1749                        }
1750                }
1751        }, {
1752                .alg = "sha512",
1753                .test = alg_test_hash,
1754                .suite = {
1755                        .hash = {
1756                                .vecs = sha512_tv_template,
1757                                .count = SHA512_TEST_VECTORS
1758                        }
1759                }
1760        }, {
1761                .alg = "tgr128",
1762                .test = alg_test_hash,
1763                .suite = {
1764                        .hash = {
1765                                .vecs = tgr128_tv_template,
1766                                .count = TGR128_TEST_VECTORS
1767                        }
1768                }
1769        }, {
1770                .alg = "tgr160",
1771                .test = alg_test_hash,
1772                .suite = {
1773                        .hash = {
1774                                .vecs = tgr160_tv_template,
1775                                .count = TGR160_TEST_VECTORS
1776                        }
1777                }
1778        }, {
1779                .alg = "tgr192",
1780                .test = alg_test_hash,
1781                .suite = {
1782                        .hash = {
1783                                .vecs = tgr192_tv_template,
1784                                .count = TGR192_TEST_VECTORS
1785                        }
1786                }
1787        }, {
1788                .alg = "wp256",
1789                .test = alg_test_hash,
1790                .suite = {
1791                        .hash = {
1792                                .vecs = wp256_tv_template,
1793                                .count = WP256_TEST_VECTORS
1794                        }
1795                }
1796        }, {
1797                .alg = "wp384",
1798                .test = alg_test_hash,
1799                .suite = {
1800                        .hash = {
1801                                .vecs = wp384_tv_template,
1802                                .count = WP384_TEST_VECTORS
1803                        }
1804                }
1805        }, {
1806                .alg = "wp512",
1807                .test = alg_test_hash,
1808                .suite = {
1809                        .hash = {
1810                                .vecs = wp512_tv_template,
1811                                .count = WP512_TEST_VECTORS
1812                        }
1813                }
1814        }, {
1815                .alg = "xcbc(aes)",
1816                .test = alg_test_hash,
1817                .suite = {
1818                        .hash = {
1819                                .vecs = aes_xcbc128_tv_template,
1820                                .count = XCBC_AES_TEST_VECTORS
1821                        }
1822                }
1823        }, {
1824                .alg = "xts(aes)",
1825                .test = alg_test_skcipher,
1826                .suite = {
1827                        .cipher = {
1828                                .enc = {
1829                                        .vecs = aes_xts_enc_tv_template,
1830                                        .count = AES_XTS_ENC_TEST_VECTORS
1831                                },
1832                                .dec = {
1833                                        .vecs = aes_xts_dec_tv_template,
1834                                        .count = AES_XTS_DEC_TEST_VECTORS
1835                                }
1836                        }
1837                }
1838        }
1839};
1840
1841static int alg_find_test(const char *alg)
1842{
1843        int start = 0;
1844        int end = ARRAY_SIZE(alg_test_descs);
1845
1846        while (start < end) {
1847                int i = (start + end) / 2;
1848                int diff = strcmp(alg_test_descs[i].alg, alg);
1849
1850                if (diff > 0) {
1851                        end = i;
1852                        continue;
1853                }
1854
1855                if (diff < 0) {
1856                        start = i + 1;
1857                        continue;
1858                }
1859
1860                return i;
1861        }
1862
1863        return -1;
1864}
1865
1866int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
1867{
1868        int i;
1869        int rc;
1870
1871        if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) {
1872                char nalg[CRYPTO_MAX_ALG_NAME];
1873
1874                if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >=
1875                    sizeof(nalg))
1876                        return -ENAMETOOLONG;
1877
1878                i = alg_find_test(nalg);
1879                if (i < 0)
1880                        goto notest;
1881
1882                return alg_test_cipher(alg_test_descs + i, driver, type, mask);
1883        }
1884
1885        i = alg_find_test(alg);
1886        if (i < 0)
1887                goto notest;
1888
1889        rc = alg_test_descs[i].test(alg_test_descs + i, driver,
1890                                      type, mask);
1891        if (fips_enabled && rc)
1892                panic("%s: %s alg self test failed in fips mode!\n", driver, alg);
1893
1894        return rc;
1895
1896notest:
1897        printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
1898        return 0;
1899}
1900EXPORT_SYMBOL_GPL(alg_test);
1901
1902int __init testmgr_init(void)
1903{
1904        int i;
1905
1906        for (i = 0; i < XBUFSIZE; i++) {
1907                xbuf[i] = (void *)__get_free_page(GFP_KERNEL);
1908                if (!xbuf[i])
1909                        goto err_free_xbuf;
1910        }
1911
1912        for (i = 0; i < XBUFSIZE; i++) {
1913                axbuf[i] = (void *)__get_free_page(GFP_KERNEL);
1914                if (!axbuf[i])
1915                        goto err_free_axbuf;
1916        }
1917
1918        return 0;
1919
1920err_free_axbuf:
1921        for (i = 0; i < XBUFSIZE && axbuf[i]; i++)
1922                free_page((unsigned long)axbuf[i]);
1923err_free_xbuf:
1924        for (i = 0; i < XBUFSIZE && xbuf[i]; i++)
1925                free_page((unsigned long)xbuf[i]);
1926
1927        return -ENOMEM;
1928}
1929
1930void testmgr_exit(void)
1931{
1932        int i;
1933
1934        for (i = 0; i < XBUFSIZE; i++)
1935                free_page((unsigned long)axbuf[i]);
1936        for (i = 0; i < XBUFSIZE; i++)
1937                free_page((unsigned long)xbuf[i]);
1938}
1939