crypto/testmgr.c

   1 /*
   2  * Algorithm testing framework and tests.
   3  *
   4  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
   5  * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
   6  * Copyright (c) 2007 Nokia Siemens Networks
   7  * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
   8  *
   9  * 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 #include <crypto/rng.h>
  23
  24 #include "internal.h"
  25 #include "testmgr.h"
  26
  27 /*
  28  * Need slab memory for testing (size in number of pages).
  29  */
  30 #define XBUFSIZE        8
  31
  32 /*
  33  * Indexes into the xbuf to simulate cross-page access.
  34  */
  35 #define IDX1            32
  36 #define IDX2            32400
  37 #define IDX3            1
  38 #define IDX4            8193
  39 #define IDX5            22222
  40 #define IDX6            17101
  41 #define IDX7            27333
  42 #define IDX8            3000
  43
  44 /*
  45 * Used by test_cipher()
  46 */
  47 #define ENCRYPT 1
  48 #define DECRYPT 0
  49
  50 struct tcrypt_result {
  51         struct completion completion;
  52         int err;
  53 };
  54
  55 struct aead_test_suite {
  56         struct {
  57                 struct aead_testvec *vecs;
  58                 unsigned int count;
  59         } enc, dec;
  60 };
  61
  62 struct cipher_test_suite {
  63         struct {
  64                 struct cipher_testvec *vecs;
  65                 unsigned int count;
  66         } enc, dec;
  67 };
  68
  69 struct comp_test_suite {
  70         struct {
  71                 struct comp_testvec *vecs;
  72                 unsigned int count;
  73         } comp, decomp;
  74 };
  75
  76 struct pcomp_test_suite {
  77         struct {
  78                 struct pcomp_testvec *vecs;
  79                 unsigned int count;
  80         } comp, decomp;
  81 };
  82
  83 struct hash_test_suite {
  84         struct hash_testvec *vecs;
  85         unsigned int count;
  86 };
  87
  88 struct cprng_test_suite {
  89         struct cprng_testvec *vecs;
  90         unsigned int count;
  91 };
  92
  93 struct alg_test_desc {
  94         const char *alg;
  95         int (*test)(const struct alg_test_desc *desc, const char *driver,
  96                     u32 type, u32 mask);
  97         int fips_allowed;       /* set if alg is allowed in fips mode */
  98
  99         union {
 100                 struct aead_test_suite aead;
 101                 struct cipher_test_suite cipher;
 102                 struct comp_test_suite comp;
 103                 struct pcomp_test_suite pcomp;
 104                 struct hash_test_suite hash;
 105                 struct cprng_test_suite cprng;
 106         } suite;
 107 };
 108
 109 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
 110
 111 static void hexdump(unsigned char *buf, unsigned int len)
 112 {
 113         print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
 114                         16, 1,
 115                         buf, len, false);
 116 }
 117
 118 static void tcrypt_complete(struct crypto_async_request *req, int err)
 119 {
 120         struct tcrypt_result *res = req->data;
 121
 122         if (err == -EINPROGRESS)
 123                 return;
 124
 125         res->err = err;
 126         complete(&res->completion);
 127 }
 128
 129 static int testmgr_alloc_buf(char *buf[XBUFSIZE])
 130 {
 131         int i;
 132
 133         for (i = 0; i < XBUFSIZE; i++) {
 134                 buf[i] = (void *)__get_free_page(GFP_KERNEL);
 135                 if (!buf[i])
 136                         goto err_free_buf;
 137         }
 138
 139         return 0;
 140
 141 err_free_buf:
 142         while (i-- > 0)
 143                 free_page((unsigned long)buf[i]);
 144
 145         return -ENOMEM;
 146 }
 147
 148 static void testmgr_free_buf(char *buf[XBUFSIZE])
 149 {
 150         int i;
 151
 152         for (i = 0; i < XBUFSIZE; i++)
 153                 free_page((unsigned long)buf[i]);
 154 }
 155
 156 static int do_one_async_hash_op(struct ahash_request *req,
 157                                 struct tcrypt_result *tr,
 158                                 int ret)
 159 {
 160         if (ret == -EINPROGRESS || ret == -EBUSY) {
 161                 ret = wait_for_completion_interruptible(&tr->completion);
 162                 if (!ret)
 163                         ret = tr->err;
 164                 INIT_COMPLETION(tr->completion);
 165         }
 166         return ret;
 167 }
 168
 169 static int test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
 170                      unsigned int tcount, bool use_digest)
 171 {
 172         const char *algo = crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm));
 173         unsigned int i, j, k, temp;
 174         struct scatterlist sg[8];
 175         char result[64];
 176         struct ahash_request *req;
 177         struct tcrypt_result tresult;
 178         void *hash_buff;
 179         char *xbuf[XBUFSIZE];
 180         int ret = -ENOMEM;
 181
 182         if (testmgr_alloc_buf(xbuf))
 183                 goto out_nobuf;
 184
 185         init_completion(&tresult.completion);
 186
 187         req = ahash_request_alloc(tfm, GFP_KERNEL);
 188         if (!req) {
 189                 printk(KERN_ERR "alg: hash: Failed to allocate request for "
 190                        "%s\n", algo);
 191                 goto out_noreq;
 192         }
 193         ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
 194                                    tcrypt_complete, &tresult);
 195
 196         j = 0;
 197         for (i = 0; i < tcount; i++) {
 198                 if (template[i].np)
 199                         continue;
 200
 201                 j++;
 202                 memset(result, 0, 64);
 203
 204                 hash_buff = xbuf[0];
 205
 206                 memcpy(hash_buff, template[i].plaintext, template[i].psize);
 207                 sg_init_one(&sg[0], hash_buff, template[i].psize);
 208
 209                 if (template[i].ksize) {
 210                         crypto_ahash_clear_flags(tfm, ~0);
 211                         ret = crypto_ahash_setkey(tfm, template[i].key,
 212                                                   template[i].ksize);
 213                         if (ret) {
 214                                 printk(KERN_ERR "alg: hash: setkey failed on "
 215                                        "test %d for %s: ret=%d\n", j, algo,
 216                                        -ret);
 217                                 goto out;
 218                         }
 219                 }
 220
 221                 ahash_request_set_crypt(req, sg, result, template[i].psize);
 222                 if (use_digest) {
 223                         ret = do_one_async_hash_op(req, &tresult,
 224                                                    crypto_ahash_digest(req));
 225                         if (ret) {
 226                                 pr_err("alg: hash: digest failed on test %d "
 227                                        "for %s: ret=%d\n", j, algo, -ret);
 228                                 goto out;
 229                         }
 230                 } else {
 231                         ret = do_one_async_hash_op(req, &tresult,
 232                                                    crypto_ahash_init(req));
 233                         if (ret) {
 234                                 pr_err("alt: hash: init failed on test %d "
 235                                        "for %s: ret=%d\n", j, algo, -ret);
 236                                 goto out;
 237                         }
 238                         ret = do_one_async_hash_op(req, &tresult,
 239                                                    crypto_ahash_update(req));
 240                         if (ret) {
 241                                 pr_err("alt: hash: update failed on test %d "
 242                                        "for %s: ret=%d\n", j, algo, -ret);
 243                                 goto out;
 244                         }
 245                         ret = do_one_async_hash_op(req, &tresult,
 246                                                    crypto_ahash_final(req));
 247                         if (ret) {
 248                                 pr_err("alt: hash: final failed on test %d "
 249                                        "for %s: ret=%d\n", j, algo, -ret);
 250                                 goto out;
 251                         }
 252                 }
 253
 254                 if (memcmp(result, template[i].digest,
 255                            crypto_ahash_digestsize(tfm))) {
 256                         printk(KERN_ERR "alg: hash: Test %d failed for %s\n",
 257                                j, algo);
 258                         hexdump(result, crypto_ahash_digestsize(tfm));
 259                         ret = -EINVAL;
 260                         goto out;
 261                 }
 262         }
 263
 264         j = 0;
 265         for (i = 0; i < tcount; i++) {
 266                 if (template[i].np) {
 267                         j++;
 268                         memset(result, 0, 64);
 269
 270                         temp = 0;
 271                         sg_init_table(sg, template[i].np);
 272                         ret = -EINVAL;
 273                         for (k = 0; k < template[i].np; k++) {
 274                                 if (WARN_ON(offset_in_page(IDX[k]) +
 275                                             template[i].tap[k] > PAGE_SIZE))
 276                                         goto out;
 277                                 sg_set_buf(&sg[k],
 278                                            memcpy(xbuf[IDX[k] >> PAGE_SHIFT] +
 279                                                   offset_in_page(IDX[k]),
 280                                                   template[i].plaintext + temp,
 281                                                   template[i].tap[k]),
 282                                            template[i].tap[k]);
 283                                 temp += template[i].tap[k];
 284                         }
 285
 286                         if (template[i].ksize) {
 287                                 crypto_ahash_clear_flags(tfm, ~0);
 288                                 ret = crypto_ahash_setkey(tfm, template[i].key,
 289                                                           template[i].ksize);
 290
 291                                 if (ret) {
 292                                         printk(KERN_ERR "alg: hash: setkey "
 293                                                "failed on chunking test %d "
 294                                                "for %s: ret=%d\n", j, algo,
 295                                                -ret);
 296                                         goto out;
 297                                 }
 298                         }
 299
 300                         ahash_request_set_crypt(req, sg, result,
 301                                                 template[i].psize);
 302                         ret = crypto_ahash_digest(req);
 303                         switch (ret) {
 304                         case 0:
 305                                 break;
 306                         case -EINPROGRESS:
 307                         case -EBUSY:
 308                                 ret = wait_for_completion_interruptible(
 309                                         &tresult.completion);
 310                                 if (!ret && !(ret = tresult.err)) {
 311                                         INIT_COMPLETION(tresult.completion);
 312                                         break;
 313                                 }
 314                                 /* fall through */
 315                         default:
 316                                 printk(KERN_ERR "alg: hash: digest failed "
 317                                        "on chunking test %d for %s: "
 318                                        "ret=%d\n", j, algo, -ret);
 319                                 goto out;
 320                         }
 321
 322                         if (memcmp(result, template[i].digest,
 323                                    crypto_ahash_digestsize(tfm))) {
 324                                 printk(KERN_ERR "alg: hash: Chunking test %d "
 325                                        "failed for %s\n", j, algo);
 326                                 hexdump(result, crypto_ahash_digestsize(tfm));
 327                                 ret = -EINVAL;
 328                                 goto out;
 329                         }
 330                 }
 331         }
 332
 333         ret = 0;
 334
 335 out:
 336         ahash_request_free(req);
 337 out_noreq:
 338         testmgr_free_buf(xbuf);
 339 out_nobuf:
 340         return ret;
 341 }
 342
 343 static int test_aead(struct crypto_aead *tfm, int enc,
 344                      struct aead_testvec *template, unsigned int tcount)
 345 {
 346         const char *algo = crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm));
 347         unsigned int i, j, k, n, temp;
 348         int ret = -ENOMEM;
 349         char *q;
 350         char *key;
 351         struct aead_request *req;
 352         struct scatterlist sg[8];
 353         struct scatterlist asg[8];
 354         const char *e;
 355         struct tcrypt_result result;
 356         unsigned int authsize;
 357         void *input;
 358         void *assoc;
 359         char iv[MAX_IVLEN];
 360         char *xbuf[XBUFSIZE];
 361         char *axbuf[XBUFSIZE];
 362
 363         if (testmgr_alloc_buf(xbuf))
 364                 goto out_noxbuf;
 365         if (testmgr_alloc_buf(axbuf))
 366                 goto out_noaxbuf;
 367
 368         if (enc == ENCRYPT)
 369                 e = "encryption";
 370         else
 371                 e = "decryption";
 372
 373         init_completion(&result.completion);
 374
 375         req = aead_request_alloc(tfm, GFP_KERNEL);
 376         if (!req) {
 377                 printk(KERN_ERR "alg: aead: Failed to allocate request for "
 378                        "%s\n", algo);
 379                 goto out;
 380         }
 381
 382         aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
 383                                   tcrypt_complete, &result);
 384
 385         for (i = 0, j = 0; i < tcount; i++) {
 386                 if (!template[i].np) {
 387                         j++;
 388
 389                         /* some tepmplates have no input data but they will
 390                          * touch input
 391                          */
 392                         input = xbuf[0];
 393                         assoc = axbuf[0];
 394
 395                         ret = -EINVAL;
 396                         if (WARN_ON(template[i].ilen > PAGE_SIZE ||
 397                                     template[i].alen > PAGE_SIZE))
 398                                 goto out;
 399
 400                         memcpy(input, template[i].input, template[i].ilen);
 401                         memcpy(assoc, template[i].assoc, template[i].alen);
 402                         if (template[i].iv)
 403                                 memcpy(iv, template[i].iv, MAX_IVLEN);
 404                         else
 405                                 memset(iv, 0, MAX_IVLEN);
 406
 407                         crypto_aead_clear_flags(tfm, ~0);
 408                         if (template[i].wk)
 409                                 crypto_aead_set_flags(
 410                                         tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 411
 412                         key = template[i].key;
 413
 414                         ret = crypto_aead_setkey(tfm, key,
 415                                                  template[i].klen);
 416                         if (!ret == template[i].fail) {
 417                                 printk(KERN_ERR "alg: aead: setkey failed on "
 418                                        "test %d for %s: flags=%x\n", j, algo,
 419                                        crypto_aead_get_flags(tfm));
 420                                 goto out;
 421                         } else if (ret)
 422                                 continue;
 423
 424                         authsize = abs(template[i].rlen - template[i].ilen);
 425                         ret = crypto_aead_setauthsize(tfm, authsize);
 426                         if (ret) {
 427                                 printk(KERN_ERR "alg: aead: Failed to set "
 428                                        "authsize to %u on test %d for %s\n",
 429                                        authsize, j, algo);
 430                                 goto out;
 431                         }
 432
 433                         sg_init_one(&sg[0], input,
 434                                     template[i].ilen + (enc ? authsize : 0));
 435
 436                         sg_init_one(&asg[0], assoc, template[i].alen);
 437
 438                         aead_request_set_crypt(req, sg, sg,
 439                                                template[i].ilen, iv);
 440
 441                         aead_request_set_assoc(req, asg, template[i].alen);
 442
 443                         ret = enc ?
 444                                 crypto_aead_encrypt(req) :
 445                                 crypto_aead_decrypt(req);
 446
 447                         switch (ret) {
 448                         case 0:
 449                                 if (template[i].novrfy) {
 450                                         /* verification was supposed to fail */
 451                                         printk(KERN_ERR "alg: aead: %s failed "
 452                                                "on test %d for %s: ret was 0, "
 453                                                "expected -EBADMSG\n",
 454                                                e, j, algo);
 455                                         /* so really, we got a bad message */
 456                                         ret = -EBADMSG;
 457                                         goto out;
 458                                 }
 459                                 break;
 460                         case -EINPROGRESS:
 461                         case -EBUSY:
 462                                 ret = wait_for_completion_interruptible(
 463                                         &result.completion);
 464                                 if (!ret && !(ret = result.err)) {
 465                                         INIT_COMPLETION(result.completion);
 466                                         break;
 467                                 }
 468                         case -EBADMSG:
 469                                 if (template[i].novrfy)
 470                                         /* verification failure was expected */
 471                                         continue;
 472                                 /* fall through */
 473                         default:
 474                                 printk(KERN_ERR "alg: aead: %s failed on test "
 475                                        "%d for %s: ret=%d\n", e, j, algo, -ret);
 476                                 goto out;
 477                         }
 478
 479                         q = input;
 480                         if (memcmp(q, template[i].result, template[i].rlen)) {
 481                                 printk(KERN_ERR "alg: aead: Test %d failed on "
 482                                        "%s for %s\n", j, e, algo);
 483                                 hexdump(q, template[i].rlen);
 484                                 ret = -EINVAL;
 485                                 goto out;
 486                         }
 487                 }
 488         }
 489
 490         for (i = 0, j = 0; i < tcount; i++) {
 491                 if (template[i].np) {
 492                         j++;
 493
 494                         if (template[i].iv)
 495                                 memcpy(iv, template[i].iv, MAX_IVLEN);
 496                         else
 497                                 memset(iv, 0, MAX_IVLEN);
 498
 499                         crypto_aead_clear_flags(tfm, ~0);
 500                         if (template[i].wk)
 501                                 crypto_aead_set_flags(
 502                                         tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 503                         key = template[i].key;
 504
 505                         ret = crypto_aead_setkey(tfm, key, template[i].klen);
 506                         if (!ret == template[i].fail) {
 507                                 printk(KERN_ERR "alg: aead: setkey failed on "
 508                                        "chunk test %d for %s: flags=%x\n", j,
 509                                        algo, crypto_aead_get_flags(tfm));
 510                                 goto out;
 511                         } else if (ret)
 512                                 continue;
 513
 514                         authsize = abs(template[i].rlen - template[i].ilen);
 515
 516                         ret = -EINVAL;
 517                         sg_init_table(sg, template[i].np);
 518                         for (k = 0, temp = 0; k < template[i].np; k++) {
 519                                 if (WARN_ON(offset_in_page(IDX[k]) +
 520                                             template[i].tap[k] > PAGE_SIZE))
 521                                         goto out;
 522
 523                                 q = xbuf[IDX[k] >> PAGE_SHIFT] +
 524                                     offset_in_page(IDX[k]);
 525
 526                                 memcpy(q, template[i].input + temp,
 527                                        template[i].tap[k]);
 528
 529                                 n = template[i].tap[k];
 530                                 if (k == template[i].np - 1 && enc)
 531                                         n += authsize;
 532                                 if (offset_in_page(q) + n < PAGE_SIZE)
 533                                         q[n] = 0;
 534
 535                                 sg_set_buf(&sg[k], q, template[i].tap[k]);
 536                                 temp += template[i].tap[k];
 537                         }
 538
 539                         ret = crypto_aead_setauthsize(tfm, authsize);
 540                         if (ret) {
 541                                 printk(KERN_ERR "alg: aead: Failed to set "
 542                                        "authsize to %u on chunk test %d for "
 543                                        "%s\n", authsize, j, algo);
 544                                 goto out;
 545                         }
 546
 547                         if (enc) {
 548                                 if (WARN_ON(sg[k - 1].offset +
 549                                             sg[k - 1].length + authsize >
 550                                             PAGE_SIZE)) {
 551                                         ret = -EINVAL;
 552                                         goto out;
 553                                 }
 554
 555                                 sg[k - 1].length += authsize;
 556                         }
 557
 558                         sg_init_table(asg, template[i].anp);
 559                         ret = -EINVAL;
 560                         for (k = 0, temp = 0; k < template[i].anp; k++) {
 561                                 if (WARN_ON(offset_in_page(IDX[k]) +
 562                                             template[i].atap[k] > PAGE_SIZE))
 563                                         goto out;
 564                                 sg_set_buf(&asg[k],
 565                                            memcpy(axbuf[IDX[k] >> PAGE_SHIFT] +
 566                                                   offset_in_page(IDX[k]),
 567                                                   template[i].assoc + temp,
 568                                                   template[i].atap[k]),
 569                                            template[i].atap[k]);
 570                                 temp += template[i].atap[k];
 571                         }
 572
 573                         aead_request_set_crypt(req, sg, sg,
 574                                                template[i].ilen,
 575                                                iv);
 576
 577                         aead_request_set_assoc(req, asg, template[i].alen);
 578
 579                         ret = enc ?
 580                                 crypto_aead_encrypt(req) :
 581                                 crypto_aead_decrypt(req);
 582
 583                         switch (ret) {
 584                         case 0:
 585                                 if (template[i].novrfy) {
 586                                         /* verification was supposed to fail */
 587                                         printk(KERN_ERR "alg: aead: %s failed "
 588                                                "on chunk test %d for %s: ret "
 589                                                "was 0, expected -EBADMSG\n",
 590                                                e, j, algo);
 591                                         /* so really, we got a bad message */
 592                                         ret = -EBADMSG;
 593                                         goto out;
 594                                 }
 595                                 break;
 596                         case -EINPROGRESS:
 597                         case -EBUSY:
 598                                 ret = wait_for_completion_interruptible(
 599                                         &result.completion);
 600                                 if (!ret && !(ret = result.err)) {
 601                                         INIT_COMPLETION(result.completion);
 602                                         break;
 603                                 }
 604                         case -EBADMSG:
 605                                 if (template[i].novrfy)
 606                                         /* verification failure was expected */
 607                                         continue;
 608                                 /* fall through */
 609                         default:
 610                                 printk(KERN_ERR "alg: aead: %s failed on "
 611                                        "chunk test %d for %s: ret=%d\n", e, j,
 612                                        algo, -ret);
 613                                 goto out;
 614                         }
 615
 616                         ret = -EINVAL;
 617                         for (k = 0, temp = 0; k < template[i].np; k++) {
 618                                 q = xbuf[IDX[k] >> PAGE_SHIFT] +
 619                                     offset_in_page(IDX[k]);
 620
 621                                 n = template[i].tap[k];
 622                                 if (k == template[i].np - 1)
 623                                         n += enc ? authsize : -authsize;
 624
 625                                 if (memcmp(q, template[i].result + temp, n)) {
 626                                         printk(KERN_ERR "alg: aead: Chunk "
 627                                                "test %d failed on %s at page "
 628                                                "%u for %s\n", j, e, k, algo);
 629                                         hexdump(q, n);
 630                                         goto out;
 631                                 }
 632
 633                                 q += n;
 634                                 if (k == template[i].np - 1 && !enc) {
 635                                         if (memcmp(q, template[i].input +
 636                                                       temp + n, authsize))
 637                                                 n = authsize;
 638                                         else
 639                                                 n = 0;
 640                                 } else {
 641                                         for (n = 0; offset_in_page(q + n) &&
 642                                                     q[n]; n++)
 643                                                 ;
 644                                 }
 645                                 if (n) {
 646                                         printk(KERN_ERR "alg: aead: Result "
 647                                                "buffer corruption in chunk "
 648                                                "test %d on %s at page %u for "
 649                                                "%s: %u bytes:\n", j, e, k,
 650                                                algo, n);
 651                                         hexdump(q, n);
 652                                         goto out;
 653                                 }
 654
 655                                 temp += template[i].tap[k];
 656                         }
 657                 }
 658         }
 659
 660         ret = 0;
 661
 662 out:
 663         aead_request_free(req);
 664         testmgr_free_buf(axbuf);
 665 out_noaxbuf:
 666         testmgr_free_buf(xbuf);
 667 out_noxbuf:
 668         return ret;
 669 }
 670
 671 static int test_cipher(struct crypto_cipher *tfm, int enc,
 672                        struct cipher_testvec *template, unsigned int tcount)
 673 {
 674         const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm));
 675         unsigned int i, j, k;
 676         char *q;
 677         const char *e;
 678         void *data;
 679         char *xbuf[XBUFSIZE];
 680         int ret = -ENOMEM;
 681
 682         if (testmgr_alloc_buf(xbuf))
 683                 goto out_nobuf;
 684
 685         if (enc == ENCRYPT)
 686                 e = "encryption";
 687         else
 688                 e = "decryption";
 689
 690         j = 0;
 691         for (i = 0; i < tcount; i++) {
 692                 if (template[i].np)
 693                         continue;
 694
 695                 j++;
 696
 697                 ret = -EINVAL;
 698                 if (WARN_ON(template[i].ilen > PAGE_SIZE))
 699                         goto out;
 700
 701                 data = xbuf[0];
 702                 memcpy(data, template[i].input, template[i].ilen);
 703
 704                 crypto_cipher_clear_flags(tfm, ~0);
 705                 if (template[i].wk)
 706                         crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 707
 708                 ret = crypto_cipher_setkey(tfm, template[i].key,
 709                                            template[i].klen);
 710                 if (!ret == template[i].fail) {
 711                         printk(KERN_ERR "alg: cipher: setkey failed "
 712                                "on test %d for %s: flags=%x\n", j,
 713                                algo, crypto_cipher_get_flags(tfm));
 714                         goto out;
 715                 } else if (ret)
 716                         continue;
 717
 718                 for (k = 0; k < template[i].ilen;
 719                      k += crypto_cipher_blocksize(tfm)) {
 720                         if (enc)
 721                                 crypto_cipher_encrypt_one(tfm, data + k,
 722                                                           data + k);
 723                         else
 724                                 crypto_cipher_decrypt_one(tfm, data + k,
 725                                                           data + k);
 726                 }
 727
 728                 q = data;
 729                 if (memcmp(q, template[i].result, template[i].rlen)) {
 730                         printk(KERN_ERR "alg: cipher: Test %d failed "
 731                                "on %s for %s\n", j, e, algo);
 732                         hexdump(q, template[i].rlen);
 733                         ret = -EINVAL;
 734                         goto out;
 735                 }
 736         }
 737
 738         ret = 0;
 739
 740 out:
 741         testmgr_free_buf(xbuf);
 742 out_nobuf:
 743         return ret;
 744 }
 745
 746 static int test_skcipher(struct crypto_ablkcipher *tfm, int enc,
 747                          struct cipher_testvec *template, unsigned int tcount)
 748 {
 749         const char *algo =
 750                 crypto_tfm_alg_driver_name(crypto_ablkcipher_tfm(tfm));
 751         unsigned int i, j, k, n, temp;
 752         char *q;
 753         struct ablkcipher_request *req;
 754         struct scatterlist sg[8];
 755         const char *e;
 756         struct tcrypt_result result;
 757         void *data;
 758         char iv[MAX_IVLEN];
 759         char *xbuf[XBUFSIZE];
 760         int ret = -ENOMEM;
 761
 762         if (testmgr_alloc_buf(xbuf))
 763                 goto out_nobuf;
 764
 765         if (enc == ENCRYPT)
 766                 e = "encryption";
 767         else
 768                 e = "decryption";
 769
 770         init_completion(&result.completion);
 771
 772         req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
 773         if (!req) {
 774                 printk(KERN_ERR "alg: skcipher: Failed to allocate request "
 775                        "for %s\n", algo);
 776                 goto out;
 777         }
 778
 779         ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
 780                                         tcrypt_complete, &result);
 781
 782         j = 0;
 783         for (i = 0; i < tcount; i++) {
 784                 if (template[i].iv)
 785                         memcpy(iv, template[i].iv, MAX_IVLEN);
 786                 else
 787                         memset(iv, 0, MAX_IVLEN);
 788
 789                 if (!(template[i].np)) {
 790                         j++;
 791
 792                         ret = -EINVAL;
 793                         if (WARN_ON(template[i].ilen > PAGE_SIZE))
 794                                 goto out;
 795
 796                         data = xbuf[0];
 797                         memcpy(data, template[i].input, template[i].ilen);
 798
 799                         crypto_ablkcipher_clear_flags(tfm, ~0);
 800                         if (template[i].wk)
 801                                 crypto_ablkcipher_set_flags(
 802                                         tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 803
 804                         ret = crypto_ablkcipher_setkey(tfm, template[i].key,
 805                                                        template[i].klen);
 806                         if (!ret == template[i].fail) {
 807                                 printk(KERN_ERR "alg: skcipher: setkey failed "
 808                                        "on test %d for %s: flags=%x\n", j,
 809                                        algo, crypto_ablkcipher_get_flags(tfm));
 810                                 goto out;
 811                         } else if (ret)
 812                                 continue;
 813
 814                         sg_init_one(&sg[0], data, template[i].ilen);
 815
 816                         ablkcipher_request_set_crypt(req, sg, sg,
 817                                                      template[i].ilen, iv);
 818                         ret = enc ?
 819                                 crypto_ablkcipher_encrypt(req) :
 820                                 crypto_ablkcipher_decrypt(req);
 821
 822                         switch (ret) {
 823                         case 0:
 824                                 break;
 825                         case -EINPROGRESS:
 826                         case -EBUSY:
 827                                 ret = wait_for_completion_interruptible(
 828                                         &result.completion);
 829                                 if (!ret && !((ret = result.err))) {
 830                                         INIT_COMPLETION(result.completion);
 831                                         break;
 832                                 }
 833                                 /* fall through */
 834                         default:
 835                                 printk(KERN_ERR "alg: skcipher: %s failed on "
 836                                        "test %d for %s: ret=%d\n", e, j, algo,
 837                                        -ret);
 838                                 goto out;
 839                         }
 840
 841                         q = data;
 842                         if (memcmp(q, template[i].result, template[i].rlen)) {
 843                                 printk(KERN_ERR "alg: skcipher: Test %d "
 844                                        "failed on %s for %s\n", j, e, algo);
 845                                 hexdump(q, template[i].rlen);
 846                                 ret = -EINVAL;
 847                                 goto out;
 848                         }
 849                 }
 850         }
 851
 852         j = 0;
 853         for (i = 0; i < tcount; i++) {
 854
 855                 if (template[i].iv)
 856                         memcpy(iv, template[i].iv, MAX_IVLEN);
 857                 else
 858                         memset(iv, 0, MAX_IVLEN);
 859
 860                 if (template[i].np) {
 861                         j++;
 862
 863                         crypto_ablkcipher_clear_flags(tfm, ~0);
 864                         if (template[i].wk)
 865                                 crypto_ablkcipher_set_flags(
 866                                         tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 867
 868                         ret = crypto_ablkcipher_setkey(tfm, template[i].key,
 869                                                        template[i].klen);
 870                         if (!ret == template[i].fail) {
 871                                 printk(KERN_ERR "alg: skcipher: setkey failed "
 872                                        "on chunk test %d for %s: flags=%x\n",
 873                                        j, algo,
 874                                        crypto_ablkcipher_get_flags(tfm));
 875                                 goto out;
 876                         } else if (ret)
 877                                 continue;
 878
 879                         temp = 0;
 880                         ret = -EINVAL;
 881                         sg_init_table(sg, template[i].np);
 882                         for (k = 0; k < template[i].np; k++) {
 883                                 if (WARN_ON(offset_in_page(IDX[k]) +
 884                                             template[i].tap[k] > PAGE_SIZE))
 885                                         goto out;
 886
 887                                 q = xbuf[IDX[k] >> PAGE_SHIFT] +
 888                                     offset_in_page(IDX[k]);
 889
 890                                 memcpy(q, template[i].input + temp,
 891                                        template[i].tap[k]);
 892
 893                                 if (offset_in_page(q) + template[i].tap[k] <
 894                                     PAGE_SIZE)
 895                                         q[template[i].tap[k]] = 0;
 896
 897                                 sg_set_buf(&sg[k], q, template[i].tap[k]);
 898
 899                                 temp += template[i].tap[k];
 900                         }
 901
 902                         ablkcipher_request_set_crypt(req, sg, sg,
 903                                         template[i].ilen, iv);
 904
 905                         ret = enc ?
 906                                 crypto_ablkcipher_encrypt(req) :
 907                                 crypto_ablkcipher_decrypt(req);
 908
 909                         switch (ret) {
 910                         case 0:
 911                                 break;
 912                         case -EINPROGRESS:
 913                         case -EBUSY:
 914                                 ret = wait_for_completion_interruptible(
 915                                         &result.completion);
 916                                 if (!ret && !((ret = result.err))) {
 917                                         INIT_COMPLETION(result.completion);
 918                                         break;
 919                                 }
 920                                 /* fall through */
 921                         default:
 922                                 printk(KERN_ERR "alg: skcipher: %s failed on "
 923                                        "chunk test %d for %s: ret=%d\n", e, j,
 924                                        algo, -ret);
 925                                 goto out;
 926                         }
 927
 928                         temp = 0;
 929                         ret = -EINVAL;
 930                         for (k = 0; k < template[i].np; k++) {
 931                                 q = xbuf[IDX[k] >> PAGE_SHIFT] +
 932                                     offset_in_page(IDX[k]);
 933
 934                                 if (memcmp(q, template[i].result + temp,
 935                                            template[i].tap[k])) {
 936                                         printk(KERN_ERR "alg: skcipher: Chunk "
 937                                                "test %d failed on %s at page "
 938                                                "%u for %s\n", j, e, k, algo);
 939                                         hexdump(q, template[i].tap[k]);
 940                                         goto out;
 941                                 }
 942
 943                                 q += template[i].tap[k];
 944                                 for (n = 0; offset_in_page(q + n) && q[n]; n++)
 945                                         ;
 946                                 if (n) {
 947                                         printk(KERN_ERR "alg: skcipher: "
 948                                                "Result buffer corruption in "
 949                                                "chunk test %d on %s at page "
 950                                                "%u for %s: %u bytes:\n", j, e,
 951                                                k, algo, n);
 952                                         hexdump(q, n);
 953                                         goto out;
 954                                 }
 955                                 temp += template[i].tap[k];
 956                         }
 957                 }
 958         }
 959
 960         ret = 0;
 961
 962 out:
 963         ablkcipher_request_free(req);
 964         testmgr_free_buf(xbuf);
 965 out_nobuf:
 966         return ret;
 967 }
 968
 969 static int test_comp(struct crypto_comp *tfm, struct comp_testvec *ctemplate,
 970                      struct comp_testvec *dtemplate, int ctcount, int dtcount)
 971 {
 972         const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
 973         unsigned int i;
 974         char result[COMP_BUF_SIZE];
 975         int ret;
 976
 977         for (i = 0; i < ctcount; i++) {
 978                 int ilen;
 979                 unsigned int dlen = COMP_BUF_SIZE;
 980
 981                 memset(result, 0, sizeof (result));
 982
 983                 ilen = ctemplate[i].inlen;
 984                 ret = crypto_comp_compress(tfm, ctemplate[i].input,
 985                                            ilen, result, &dlen);
 986                 if (ret) {
 987                         printk(KERN_ERR "alg: comp: compression failed "
 988                                "on test %d for %s: ret=%d\n", i + 1, algo,
 989                                -ret);
 990                         goto out;
 991                 }
 992
 993                 if (dlen != ctemplate[i].outlen) {
 994                         printk(KERN_ERR "alg: comp: Compression test %d "
 995                                "failed for %s: output len = %d\n", i + 1, algo,
 996                                dlen);
 997                         ret = -EINVAL;
 998                         goto out;
 999                 }
1000
1001                 if (memcmp(result, ctemplate[i].output, dlen)) {
1002                         printk(KERN_ERR "alg: comp: Compression test %d "
1003                                "failed for %s\n", i + 1, algo);
1004                         hexdump(result, dlen);
1005                         ret = -EINVAL;
1006                         goto out;
1007                 }
1008         }
1009
1010         for (i = 0; i < dtcount; i++) {
1011                 int ilen;
1012                 unsigned int dlen = COMP_BUF_SIZE;
1013
1014                 memset(result, 0, sizeof (result));
1015
1016                 ilen = dtemplate[i].inlen;
1017                 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
1018                                              ilen, result, &dlen);
1019                 if (ret) {
1020                         printk(KERN_ERR "alg: comp: decompression failed "
1021                                "on test %d for %s: ret=%d\n", i + 1, algo,
1022                                -ret);
1023                         goto out;
1024                 }
1025
1026                 if (dlen != dtemplate[i].outlen) {
1027                         printk(KERN_ERR "alg: comp: Decompression test %d "
1028                                "failed for %s: output len = %d\n", i + 1, algo,
1029                                dlen);
1030                         ret = -EINVAL;
1031                         goto out;
1032                 }
1033
1034                 if (memcmp(result, dtemplate[i].output, dlen)) {
1035                         printk(KERN_ERR "alg: comp: Decompression test %d "
1036                                "failed for %s\n", i + 1, algo);
1037                         hexdump(result, dlen);
1038                         ret = -EINVAL;
1039                         goto out;
1040                 }
1041         }
1042
1043         ret = 0;
1044
1045 out:
1046         return ret;
1047 }
1048
1049 static int test_pcomp(struct crypto_pcomp *tfm,
1050                       struct pcomp_testvec *ctemplate,
1051                       struct pcomp_testvec *dtemplate, int ctcount,
1052                       int dtcount)
1053 {
1054         const char *algo = crypto_tfm_alg_driver_name(crypto_pcomp_tfm(tfm));
1055         unsigned int i;
1056         char result[COMP_BUF_SIZE];
1057         int res;
1058
1059         for (i = 0; i < ctcount; i++) {
1060                 struct comp_request req;
1061                 unsigned int produced = 0;
1062
1063                 res = crypto_compress_setup(tfm, ctemplate[i].params,
1064                                             ctemplate[i].paramsize);
1065                 if (res) {
1066                         pr_err("alg: pcomp: compression setup failed on test "
1067                                "%d for %s: error=%d\n", i + 1, algo, res);
1068                         return res;
1069                 }
1070
1071                 res = crypto_compress_init(tfm);
1072                 if (res) {
1073                         pr_err("alg: pcomp: compression init failed on test "
1074                                "%d for %s: error=%d\n", i + 1, algo, res);
1075                         return res;
1076                 }
1077
1078                 memset(result, 0, sizeof(result));
1079
1080                 req.next_in = ctemplate[i].input;
1081                 req.avail_in = ctemplate[i].inlen / 2;
1082                 req.next_out = result;
1083                 req.avail_out = ctemplate[i].outlen / 2;
1084
1085                 res = crypto_compress_update(tfm, &req);
1086                 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1087                         pr_err("alg: pcomp: compression update failed on test "
1088                                "%d for %s: error=%d\n", i + 1, algo, res);
1089                         return res;
1090                 }
1091                 if (res > 0)
1092                         produced += res;
1093
1094                 /* Add remaining input data */
1095                 req.avail_in += (ctemplate[i].inlen + 1) / 2;
1096
1097                 res = crypto_compress_update(tfm, &req);
1098                 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1099                         pr_err("alg: pcomp: compression update failed on test "
1100                                "%d for %s: error=%d\n", i + 1, algo, res);
1101                         return res;
1102                 }
1103                 if (res > 0)
1104                         produced += res;
1105
1106                 /* Provide remaining output space */
1107                 req.avail_out += COMP_BUF_SIZE - ctemplate[i].outlen / 2;
1108
1109                 res = crypto_compress_final(tfm, &req);
1110                 if (res < 0) {
1111                         pr_err("alg: pcomp: compression final failed on test "
1112                                "%d for %s: error=%d\n", i + 1, algo, res);
1113                         return res;
1114                 }
1115                 produced += res;
1116
1117                 if (COMP_BUF_SIZE - req.avail_out != ctemplate[i].outlen) {
1118                         pr_err("alg: comp: Compression test %d failed for %s: "
1119                                "output len = %d (expected %d)\n", i + 1, algo,
1120                                COMP_BUF_SIZE - req.avail_out,
1121                                ctemplate[i].outlen);
1122                         return -EINVAL;
1123                 }
1124
1125                 if (produced != ctemplate[i].outlen) {
1126                         pr_err("alg: comp: Compression test %d failed for %s: "
1127                                "returned len = %u (expected %d)\n", i + 1,
1128                                algo, produced, ctemplate[i].outlen);
1129                         return -EINVAL;
1130                 }
1131
1132                 if (memcmp(result, ctemplate[i].output, ctemplate[i].outlen)) {
1133                         pr_err("alg: pcomp: Compression test %d failed for "
1134                                "%s\n", i + 1, algo);
1135                         hexdump(result, ctemplate[i].outlen);
1136                         return -EINVAL;
1137                 }
1138         }
1139
1140         for (i = 0; i < dtcount; i++) {
1141                 struct comp_request req;
1142                 unsigned int produced = 0;
1143
1144                 res = crypto_decompress_setup(tfm, dtemplate[i].params,
1145                                               dtemplate[i].paramsize);
1146                 if (res) {
1147                         pr_err("alg: pcomp: decompression setup failed on "
1148                                "test %d for %s: error=%d\n", i + 1, algo, res);
1149                         return res;
1150                 }
1151
1152                 res = crypto_decompress_init(tfm);
1153                 if (res) {
1154                         pr_err("alg: pcomp: decompression init failed on test "
1155                                "%d for %s: error=%d\n", i + 1, algo, res);
1156                         return res;
1157                 }
1158
1159                 memset(result, 0, sizeof(result));
1160
1161                 req.next_in = dtemplate[i].input;
1162                 req.avail_in = dtemplate[i].inlen / 2;
1163                 req.next_out = result;
1164                 req.avail_out = dtemplate[i].outlen / 2;
1165
1166                 res = crypto_decompress_update(tfm, &req);
1167                 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1168                         pr_err("alg: pcomp: decompression update failed on "
1169                                "test %d for %s: error=%d\n", i + 1, algo, res);
1170                         return res;
1171                 }
1172                 if (res > 0)
1173                         produced += res;
1174
1175                 /* Add remaining input data */
1176                 req.avail_in += (dtemplate[i].inlen + 1) / 2;
1177
1178                 res = crypto_decompress_update(tfm, &req);
1179                 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1180                         pr_err("alg: pcomp: decompression update failed on "
1181                                "test %d for %s: error=%d\n", i + 1, algo, res);
1182                         return res;
1183                 }
1184                 if (res > 0)
1185                         produced += res;
1186
1187                 /* Provide remaining output space */
1188                 req.avail_out += COMP_BUF_SIZE - dtemplate[i].outlen / 2;
1189
1190                 res = crypto_decompress_final(tfm, &req);
1191                 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1192                         pr_err("alg: pcomp: decompression final failed on "
1193                                "test %d for %s: error=%d\n", i + 1, algo, res);
1194                         return res;
1195                 }
1196                 if (res > 0)
1197                         produced += res;
1198
1199                 if (COMP_BUF_SIZE - req.avail_out != dtemplate[i].outlen) {
1200                         pr_err("alg: comp: Decompression test %d failed for "
1201                                "%s: output len = %d (expected %d)\n", i + 1,
1202                                algo, COMP_BUF_SIZE - req.avail_out,
1203                                dtemplate[i].outlen);
1204                         return -EINVAL;
1205                 }
1206
1207                 if (produced != dtemplate[i].outlen) {
1208                         pr_err("alg: comp: Decompression test %d failed for "
1209                                "%s: returned len = %u (expected %d)\n", i + 1,
1210                                algo, produced, dtemplate[i].outlen);
1211                         return -EINVAL;
1212                 }
1213
1214                 if (memcmp(result, dtemplate[i].output, dtemplate[i].outlen)) {
1215                         pr_err("alg: pcomp: Decompression test %d failed for "
1216                                "%s\n", i + 1, algo);
1217                         hexdump(result, dtemplate[i].outlen);
1218                         return -EINVAL;
1219                 }
1220         }
1221
1222         return 0;
1223 }
1224
1225
1226 static int test_cprng(struct crypto_rng *tfm, struct cprng_testvec *template,
1227                       unsigned int tcount)
1228 {
1229         const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm));
1230         int err = 0, i, j, seedsize;
1231         u8 *seed;
1232         char result[32];
1233
1234         seedsize = crypto_rng_seedsize(tfm);
1235
1236         seed = kmalloc(seedsize, GFP_KERNEL);
1237         if (!seed) {
1238                 printk(KERN_ERR "alg: cprng: Failed to allocate seed space "
1239                        "for %s\n", algo);
1240                 return -ENOMEM;
1241         }
1242
1243         for (i = 0; i < tcount; i++) {
1244                 memset(result, 0, 32);
1245
1246                 memcpy(seed, template[i].v, template[i].vlen);
1247                 memcpy(seed + template[i].vlen, template[i].key,
1248                        template[i].klen);
1249                 memcpy(seed + template[i].vlen + template[i].klen,
1250                        template[i].dt, template[i].dtlen);
1251
1252                 err = crypto_rng_reset(tfm, seed, seedsize);
1253                 if (err) {
1254                         printk(KERN_ERR "alg: cprng: Failed to reset rng "
1255                                "for %s\n", algo);
1256                         goto out;
1257                 }
1258
1259                 for (j = 0; j < template[i].loops; j++) {
1260                         err = crypto_rng_get_bytes(tfm, result,
1261                                                    template[i].rlen);
1262                         if (err != template[i].rlen) {
1263                                 printk(KERN_ERR "alg: cprng: Failed to obtain "
1264                                        "the correct amount of random data for "
1265                                        "%s (requested %d, got %d)\n", algo,
1266                                        template[i].rlen, err);
1267                                 goto out;
1268                         }
1269                 }
1270
1271                 err = memcmp(result, template[i].result,
1272                              template[i].rlen);
1273                 if (err) {
1274                         printk(KERN_ERR "alg: cprng: Test %d failed for %s\n",
1275                                i, algo);
1276                         hexdump(result, template[i].rlen);
1277                         err = -EINVAL;
1278                         goto out;
1279                 }
1280         }
1281
1282 out:
1283         kfree(seed);
1284         return err;
1285 }
1286
1287 static int alg_test_aead(const struct alg_test_desc *desc, const char *driver,
1288                          u32 type, u32 mask)
1289 {
1290         struct crypto_aead *tfm;
1291         int err = 0;
1292
1293         tfm = crypto_alloc_aead(driver, type, mask);
1294         if (IS_ERR(tfm)) {
1295                 printk(KERN_ERR "alg: aead: Failed to load transform for %s: "
1296                        "%ld\n", driver, PTR_ERR(tfm));
1297                 return PTR_ERR(tfm);
1298         }
1299
1300         if (desc->suite.aead.enc.vecs) {
1301                 err = test_aead(tfm, ENCRYPT, desc->suite.aead.enc.vecs,
1302                                 desc->suite.aead.enc.count);
1303                 if (err)
1304                         goto out;
1305         }
1306
1307         if (!err && desc->suite.aead.dec.vecs)
1308                 err = test_aead(tfm, DECRYPT, desc->suite.aead.dec.vecs,
1309                                 desc->suite.aead.dec.count);
1310
1311 out:
1312         crypto_free_aead(tfm);
1313         return err;
1314 }
1315
1316 static int alg_test_cipher(const struct alg_test_desc *desc,
1317                            const char *driver, u32 type, u32 mask)
1318 {
1319         struct crypto_cipher *tfm;
1320         int err = 0;
1321
1322         tfm = crypto_alloc_cipher(driver, type, mask);
1323         if (IS_ERR(tfm)) {
1324                 printk(KERN_ERR "alg: cipher: Failed to load transform for "
1325                        "%s: %ld\n", driver, PTR_ERR(tfm));
1326                 return PTR_ERR(tfm);
1327         }
1328
1329         if (desc->suite.cipher.enc.vecs) {
1330                 err = test_cipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1331                                   desc->suite.cipher.enc.count);
1332                 if (err)
1333                         goto out;
1334         }
1335
1336         if (desc->suite.cipher.dec.vecs)
1337                 err = test_cipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1338                                   desc->suite.cipher.dec.count);
1339
1340 out:
1341         crypto_free_cipher(tfm);
1342         return err;
1343 }
1344
1345 static int alg_test_skcipher(const struct alg_test_desc *desc,
1346                              const char *driver, u32 type, u32 mask)
1347 {
1348         struct crypto_ablkcipher *tfm;
1349         int err = 0;
1350
1351         tfm = crypto_alloc_ablkcipher(driver, type, mask);
1352         if (IS_ERR(tfm)) {
1353                 printk(KERN_ERR "alg: skcipher: Failed to load transform for "
1354                        "%s: %ld\n", driver, PTR_ERR(tfm));
1355                 return PTR_ERR(tfm);
1356         }
1357
1358         if (desc->suite.cipher.enc.vecs) {
1359                 err = test_skcipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1360                                     desc->suite.cipher.enc.count);
1361                 if (err)
1362                         goto out;
1363         }
1364
1365         if (desc->suite.cipher.dec.vecs)
1366                 err = test_skcipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1367                                     desc->suite.cipher.dec.count);
1368
1369 out:
1370         crypto_free_ablkcipher(tfm);
1371         return err;
1372 }
1373
1374 static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
1375                          u32 type, u32 mask)
1376 {
1377         struct crypto_comp *tfm;
1378         int err;
1379
1380         tfm = crypto_alloc_comp(driver, type, mask);
1381         if (IS_ERR(tfm)) {
1382                 printk(KERN_ERR "alg: comp: Failed to load transform for %s: "
1383                        "%ld\n", driver, PTR_ERR(tfm));
1384                 return PTR_ERR(tfm);
1385         }
1386
1387         err = test_comp(tfm, desc->suite.comp.comp.vecs,
1388                         desc->suite.comp.decomp.vecs,
1389                         desc->suite.comp.comp.count,
1390                         desc->suite.comp.decomp.count);
1391
1392         crypto_free_comp(tfm);
1393         return err;
1394 }
1395
1396 static int alg_test_pcomp(const struct alg_test_desc *desc, const char *driver,
1397                           u32 type, u32 mask)
1398 {
1399         struct crypto_pcomp *tfm;
1400         int err;
1401
1402         tfm = crypto_alloc_pcomp(driver, type, mask);
1403         if (IS_ERR(tfm)) {
1404                 pr_err("alg: pcomp: Failed to load transform for %s: %ld\n",
1405                        driver, PTR_ERR(tfm));
1406                 return PTR_ERR(tfm);
1407         }
1408
1409         err = test_pcomp(tfm, desc->suite.pcomp.comp.vecs,
1410                          desc->suite.pcomp.decomp.vecs,
1411                          desc->suite.pcomp.comp.count,
1412                          desc->suite.pcomp.decomp.count);
1413
1414         crypto_free_pcomp(tfm);
1415         return err;
1416 }
1417
1418 static int alg_test_hash(const struct alg_test_desc *desc, const char *driver,
1419                          u32 type, u32 mask)
1420 {
1421         struct crypto_ahash *tfm;
1422         int err;
1423
1424         tfm = crypto_alloc_ahash(driver, type, mask);
1425         if (IS_ERR(tfm)) {
1426                 printk(KERN_ERR "alg: hash: Failed to load transform for %s: "
1427                        "%ld\n", driver, PTR_ERR(tfm));
1428                 return PTR_ERR(tfm);
1429         }
1430
1431         err = test_hash(tfm, desc->suite.hash.vecs,
1432                         desc->suite.hash.count, true);
1433         if (!err)
1434                 err = test_hash(tfm, desc->suite.hash.vecs,
1435                                 desc->suite.hash.count, false);
1436
1437         crypto_free_ahash(tfm);
1438         return err;
1439 }
1440
1441 static int alg_test_crc32c(const struct alg_test_desc *desc,
1442                            const char *driver, u32 type, u32 mask)
1443 {
1444         struct crypto_shash *tfm;
1445         u32 val;
1446         int err;
1447
1448         err = alg_test_hash(desc, driver, type, mask);
1449         if (err)
1450                 goto out;
1451
1452         tfm = crypto_alloc_shash(driver, type, mask);
1453         if (IS_ERR(tfm)) {
1454                 printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: "
1455                        "%ld\n", driver, PTR_ERR(tfm));
1456                 err = PTR_ERR(tfm);
1457                 goto out;
1458         }
1459
1460         do {
1461                 struct {
1462                         struct shash_desc shash;
1463                         char ctx[crypto_shash_descsize(tfm)];
1464                 } sdesc;
1465
1466                 sdesc.shash.tfm = tfm;
1467                 sdesc.shash.flags = 0;
1468
1469                 *(u32 *)sdesc.ctx = le32_to_cpu(420553207);
1470                 err = crypto_shash_final(&sdesc.shash, (u8 *)&val);
1471                 if (err) {
1472                         printk(KERN_ERR "alg: crc32c: Operation failed for "
1473                                "%s: %d\n", driver, err);
1474                         break;
1475                 }
1476
1477                 if (val != ~420553207) {
1478                         printk(KERN_ERR "alg: crc32c: Test failed for %s: "
1479                                "%d\n", driver, val);
1480                         err = -EINVAL;
1481                 }
1482         } while (0);
1483
1484         crypto_free_shash(tfm);
1485
1486 out:
1487         return err;
1488 }
1489
1490 static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver,
1491                           u32 type, u32 mask)
1492 {
1493         struct crypto_rng *rng;
1494         int err;
1495
1496         rng = crypto_alloc_rng(driver, type, mask);
1497         if (IS_ERR(rng)) {
1498                 printk(KERN_ERR "alg: cprng: Failed to load transform for %s: "
1499                        "%ld\n", driver, PTR_ERR(rng));
1500                 return PTR_ERR(rng);
1501         }
1502
1503         err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count);
1504
1505         crypto_free_rng(rng);
1506
1507         return err;
1508 }
1509
1510 static int alg_test_null(const struct alg_test_desc *desc,
1511                              const char *driver, u32 type, u32 mask)
1512 {
1513         return 0;
1514 }
1515
1516 /* Please keep this list sorted by algorithm name. */
1517 static const struct alg_test_desc alg_test_descs[] = {
1518         {
1519                 .alg = "__driver-cbc-aes-aesni",
1520                 .test = alg_test_null,
1521                 .suite = {
1522                         .cipher = {
1523                                 .enc = {
1524                                         .vecs = NULL,
1525                                         .count = 0
1526                                 },
1527                                 .dec = {
1528                                         .vecs = NULL,
1529                                         .count = 0
1530                                 }
1531                         }
1532                 }
1533         }, {
1534                 .alg = "__driver-ecb-aes-aesni",
1535                 .test = alg_test_null,
1536                 .suite = {
1537                         .cipher = {
1538                                 .enc = {
1539                                         .vecs = NULL,
1540                                         .count = 0
1541                                 },
1542                                 .dec = {
1543                                         .vecs = NULL,
1544                                         .count = 0
1545                                 }
1546                         }
1547                 }
1548         }, {
1549                 .alg = "__ghash-pclmulqdqni",
1550                 .test = alg_test_null,
1551                 .suite = {
1552                         .hash = {
1553                                 .vecs = NULL,
1554                                 .count = 0
1555                         }
1556                 }
1557         }, {
1558                 .alg = "ansi_cprng",
1559                 .test = alg_test_cprng,
1560                 .fips_allowed = 1,
1561                 .suite = {
1562                         .cprng = {
1563                                 .vecs = ansi_cprng_aes_tv_template,
1564                                 .count = ANSI_CPRNG_AES_TEST_VECTORS
1565                         }
1566                 }
1567         }, {
1568                 .alg = "cbc(aes)",
1569                 .test = alg_test_skcipher,
1570                 .fips_allowed = 1,
1571                 .suite = {
1572                         .cipher = {
1573                                 .enc = {
1574                                         .vecs = aes_cbc_enc_tv_template,
1575                                         .count = AES_CBC_ENC_TEST_VECTORS
1576                                 },
1577                                 .dec = {
1578                                         .vecs = aes_cbc_dec_tv_template,
1579                                         .count = AES_CBC_DEC_TEST_VECTORS
1580                                 }
1581                         }
1582                 }
1583         }, {
1584                 .alg = "cbc(anubis)",
1585                 .test = alg_test_skcipher,
1586                 .suite = {
1587                         .cipher = {
1588                                 .enc = {
1589                                         .vecs = anubis_cbc_enc_tv_template,
1590                                         .count = ANUBIS_CBC_ENC_TEST_VECTORS
1591                                 },
1592                                 .dec = {
1593                                         .vecs = anubis_cbc_dec_tv_template,
1594                                         .count = ANUBIS_CBC_DEC_TEST_VECTORS
1595                                 }
1596                         }
1597                 }
1598         }, {
1599                 .alg = "cbc(blowfish)",
1600                 .test = alg_test_skcipher,
1601                 .suite = {
1602                         .cipher = {
1603                                 .enc = {
1604                                         .vecs = bf_cbc_enc_tv_template,
1605                                         .count = BF_CBC_ENC_TEST_VECTORS
1606                                 },
1607                                 .dec = {
1608                                         .vecs = bf_cbc_dec_tv_template,
1609                                         .count = BF_CBC_DEC_TEST_VECTORS
1610                                 }
1611                         }
1612                 }
1613         }, {
1614                 .alg = "cbc(camellia)",
1615                 .test = alg_test_skcipher,
1616                 .suite = {
1617                         .cipher = {
1618                                 .enc = {
1619                                         .vecs = camellia_cbc_enc_tv_template,
1620                                         .count = CAMELLIA_CBC_ENC_TEST_VECTORS
1621                                 },
1622                                 .dec = {
1623                                         .vecs = camellia_cbc_dec_tv_template,
1624                                         .count = CAMELLIA_CBC_DEC_TEST_VECTORS
1625                                 }
1626                         }
1627                 }
1628         }, {
1629                 .alg = "cbc(des)",
1630                 .test = alg_test_skcipher,
1631                 .suite = {
1632                         .cipher = {
1633                                 .enc = {
1634                                         .vecs = des_cbc_enc_tv_template,
1635                                         .count = DES_CBC_ENC_TEST_VECTORS
1636                                 },
1637                                 .dec = {
1638                                         .vecs = des_cbc_dec_tv_template,
1639                                         .count = DES_CBC_DEC_TEST_VECTORS
1640                                 }
1641                         }
1642                 }
1643         }, {
1644                 .alg = "cbc(des3_ede)",
1645                 .test = alg_test_skcipher,
1646                 .fips_allowed = 1,
1647                 .suite = {
1648                         .cipher = {
1649                                 .enc = {
1650                                         .vecs = des3_ede_cbc_enc_tv_template,
1651                                         .count = DES3_EDE_CBC_ENC_TEST_VECTORS
1652                                 },
1653                                 .dec = {
1654                                         .vecs = des3_ede_cbc_dec_tv_template,
1655                                         .count = DES3_EDE_CBC_DEC_TEST_VECTORS
1656                                 }
1657                         }
1658                 }
1659         }, {
1660                 .alg = "cbc(twofish)",
1661                 .test = alg_test_skcipher,
1662                 .suite = {
1663                         .cipher = {
1664                                 .enc = {
1665                                         .vecs = tf_cbc_enc_tv_template,
1666                                         .count = TF_CBC_ENC_TEST_VECTORS
1667                                 },
1668                                 .dec = {
1669                                         .vecs = tf_cbc_dec_tv_template,
1670                                         .count = TF_CBC_DEC_TEST_VECTORS
1671                                 }
1672                         }
1673                 }
1674         }, {
1675                 .alg = "ccm(aes)",
1676                 .test = alg_test_aead,
1677                 .fips_allowed = 1,
1678                 .suite = {
1679                         .aead = {
1680                                 .enc = {
1681                                         .vecs = aes_ccm_enc_tv_template,
1682                                         .count = AES_CCM_ENC_TEST_VECTORS
1683                                 },
1684                                 .dec = {
1685                                         .vecs = aes_ccm_dec_tv_template,
1686                                         .count = AES_CCM_DEC_TEST_VECTORS
1687                                 }
1688                         }
1689                 }
1690         }, {
1691                 .alg = "crc32c",
1692                 .test = alg_test_crc32c,
1693                 .fips_allowed = 1,
1694                 .suite = {
1695                         .hash = {
1696                                 .vecs = crc32c_tv_template,
1697                                 .count = CRC32C_TEST_VECTORS
1698                         }
1699                 }
1700         }, {
1701                 .alg = "cryptd(__driver-ecb-aes-aesni)",
1702                 .test = alg_test_null,
1703                 .suite = {
1704                         .cipher = {
1705                                 .enc = {
1706                                         .vecs = NULL,
1707                                         .count = 0
1708                                 },
1709                                 .dec = {
1710                                         .vecs = NULL,
1711                                         .count = 0
1712                                 }
1713                         }
1714                 }
1715         }, {
1716                 .alg = "cryptd(__ghash-pclmulqdqni)",
1717                 .test = alg_test_null,
1718                 .suite = {
1719                         .hash = {
1720                                 .vecs = NULL,
1721                                 .count = 0
1722                         }
1723                 }
1724         }, {
1725                 .alg = "ctr(aes)",
1726                 .test = alg_test_skcipher,
1727                 .fips_allowed = 1,
1728                 .suite = {
1729                         .cipher = {
1730                                 .enc = {
1731                                         .vecs = aes_ctr_enc_tv_template,
1732                                         .count = AES_CTR_ENC_TEST_VECTORS
1733                                 },
1734                                 .dec = {
1735                                         .vecs = aes_ctr_dec_tv_template,
1736                                         .count = AES_CTR_DEC_TEST_VECTORS
1737                                 }
1738                         }
1739                 }
1740         }, {
1741                 .alg = "cts(cbc(aes))",
1742                 .test = alg_test_skcipher,
1743                 .suite = {
1744                         .cipher = {
1745                                 .enc = {
1746                                         .vecs = cts_mode_enc_tv_template,
1747                                         .count = CTS_MODE_ENC_TEST_VECTORS
1748                                 },
1749                                 .dec = {
1750                                         .vecs = cts_mode_dec_tv_template,
1751                                         .count = CTS_MODE_DEC_TEST_VECTORS
1752                                 }
1753                         }
1754                 }
1755         }, {
1756                 .alg = "deflate",
1757                 .test = alg_test_comp,
1758                 .suite = {
1759                         .comp = {
1760                                 .comp = {
1761                                         .vecs = deflate_comp_tv_template,
1762                                         .count = DEFLATE_COMP_TEST_VECTORS
1763                                 },
1764                                 .decomp = {
1765                                         .vecs = deflate_decomp_tv_template,
1766                                         .count = DEFLATE_DECOMP_TEST_VECTORS
1767                                 }
1768                         }
1769                 }
1770         }, {
1771                 .alg = "ecb(__aes-aesni)",
1772                 .test = alg_test_null,
1773                 .suite = {
1774                         .cipher = {
1775                                 .enc = {
1776                                         .vecs = NULL,
1777                                         .count = 0
1778                                 },
1779                                 .dec = {
1780                                         .vecs = NULL,
1781                                         .count = 0
1782                                 }
1783                         }
1784                 }
1785         }, {
1786                 .alg = "ecb(aes)",
1787                 .test = alg_test_skcipher,
1788                 .fips_allowed = 1,
1789                 .suite = {
1790                         .cipher = {
1791                                 .enc = {
1792                                         .vecs = aes_enc_tv_template,
1793                                         .count = AES_ENC_TEST_VECTORS
1794                                 },
1795                                 .dec = {
1796                                         .vecs = aes_dec_tv_template,
1797                                         .count = AES_DEC_TEST_VECTORS
1798                                 }
1799                         }
1800                 }
1801         }, {
1802                 .alg = "ecb(anubis)",
1803                 .test = alg_test_skcipher,
1804                 .suite = {
1805                         .cipher = {
1806                                 .enc = {
1807                                         .vecs = anubis_enc_tv_template,
1808                                         .count = ANUBIS_ENC_TEST_VECTORS
1809                                 },
1810                                 .dec = {
1811                                         .vecs = anubis_dec_tv_template,
1812                                         .count = ANUBIS_DEC_TEST_VECTORS
1813                                 }
1814                         }
1815                 }
1816         }, {
1817                 .alg = "ecb(arc4)",
1818                 .test = alg_test_skcipher,
1819                 .suite = {
1820                         .cipher = {
1821                                 .enc = {
1822                                         .vecs = arc4_enc_tv_template,
1823                                         .count = ARC4_ENC_TEST_VECTORS
1824                                 },
1825                                 .dec = {
1826                                         .vecs = arc4_dec_tv_template,
1827                                         .count = ARC4_DEC_TEST_VECTORS
1828                                 }
1829                         }
1830                 }
1831         }, {
1832                 .alg = "ecb(blowfish)",
1833                 .test = alg_test_skcipher,
1834                 .suite = {
1835                         .cipher = {
1836                                 .enc = {
1837                                         .vecs = bf_enc_tv_template,
1838                                         .count = BF_ENC_TEST_VECTORS
1839                                 },
1840                                 .dec = {
1841                                         .vecs = bf_dec_tv_template,
1842                                         .count = BF_DEC_TEST_VECTORS
1843                                 }
1844                         }
1845                 }
1846         }, {
1847                 .alg = "ecb(camellia)",
1848                 .test = alg_test_skcipher,
1849                 .suite = {
1850                         .cipher = {
1851                                 .enc = {
1852                                         .vecs = camellia_enc_tv_template,
1853                                         .count = CAMELLIA_ENC_TEST_VECTORS
1854                                 },
1855                                 .dec = {
1856                                         .vecs = camellia_dec_tv_template,
1857                                         .count = CAMELLIA_DEC_TEST_VECTORS
1858                                 }
1859                         }
1860                 }
1861         }, {
1862                 .alg = "ecb(cast5)",
1863                 .test = alg_test_skcipher,
1864                 .suite = {
1865                         .cipher = {
1866                                 .enc = {
1867                                         .vecs = cast5_enc_tv_template,
1868                                         .count = CAST5_ENC_TEST_VECTORS
1869                                 },
1870                                 .dec = {
1871                                         .vecs = cast5_dec_tv_template,
1872                                         .count = CAST5_DEC_TEST_VECTORS
1873                                 }
1874                         }
1875                 }
1876         }, {
1877                 .alg = "ecb(cast6)",
1878                 .test = alg_test_skcipher,
1879                 .suite = {
1880                         .cipher = {
1881                                 .enc = {
1882                                         .vecs = cast6_enc_tv_template,
1883                                         .count = CAST6_ENC_TEST_VECTORS
1884                                 },
1885                                 .dec = {
1886                                         .vecs = cast6_dec_tv_template,
1887                                         .count = CAST6_DEC_TEST_VECTORS
1888                                 }
1889                         }
1890                 }
1891         }, {
1892                 .alg = "ecb(des)",
1893                 .test = alg_test_skcipher,
1894                 .fips_allowed = 1,
1895                 .suite = {
1896                         .cipher = {
1897                                 .enc = {
1898                                         .vecs = des_enc_tv_template,
1899                                         .count = DES_ENC_TEST_VECTORS
1900                                 },
1901                                 .dec = {
1902                                         .vecs = des_dec_tv_template,
1903                                         .count = DES_DEC_TEST_VECTORS
1904                                 }
1905                         }
1906                 }
1907         }, {
1908                 .alg = "ecb(des3_ede)",
1909                 .test = alg_test_skcipher,
1910                 .fips_allowed = 1,
1911                 .suite = {
1912                         .cipher = {
1913                                 .enc = {
1914                                         .vecs = des3_ede_enc_tv_template,
1915                                         .count = DES3_EDE_ENC_TEST_VECTORS
1916                                 },
1917                                 .dec = {
1918                                         .vecs = des3_ede_dec_tv_template,
1919                                         .count = DES3_EDE_DEC_TEST_VECTORS
1920                                 }
1921                         }
1922                 }
1923         }, {
1924                 .alg = "ecb(khazad)",
1925                 .test = alg_test_skcipher,
1926                 .suite = {
1927                         .cipher = {
1928                                 .enc = {
1929                                         .vecs = khazad_enc_tv_template,
1930                                         .count = KHAZAD_ENC_TEST_VECTORS
1931                                 },
1932                                 .dec = {
1933                                         .vecs = khazad_dec_tv_template,
1934                                         .count = KHAZAD_DEC_TEST_VECTORS
1935                                 }
1936                         }
1937                 }
1938         }, {
1939                 .alg = "ecb(seed)",
1940                 .test = alg_test_skcipher,
1941                 .suite = {
1942                         .cipher = {
1943                                 .enc = {
1944                                         .vecs = seed_enc_tv_template,
1945                                         .count = SEED_ENC_TEST_VECTORS
1946                                 },
1947                                 .dec = {
1948                                         .vecs = seed_dec_tv_template,
1949                                         .count = SEED_DEC_TEST_VECTORS
1950                                 }
1951                         }
1952                 }
1953         }, {
1954                 .alg = "ecb(serpent)",
1955                 .test = alg_test_skcipher,
1956                 .suite = {
1957                         .cipher = {
1958                                 .enc = {
1959                                         .vecs = serpent_enc_tv_template,
1960                                         .count = SERPENT_ENC_TEST_VECTORS
1961                                 },
1962                                 .dec = {
1963                                         .vecs = serpent_dec_tv_template,
1964                                         .count = SERPENT_DEC_TEST_VECTORS
1965                                 }
1966                         }
1967                 }
1968         }, {
1969                 .alg = "ecb(tea)",
1970                 .test = alg_test_skcipher,
1971                 .suite = {
1972                         .cipher = {
1973                                 .enc = {
1974                                         .vecs = tea_enc_tv_template,
1975                                         .count = TEA_ENC_TEST_VECTORS
1976                                 },
1977                                 .dec = {
1978                                         .vecs = tea_dec_tv_template,
1979                                         .count = TEA_DEC_TEST_VECTORS
1980                                 }
1981                         }
1982                 }
1983         }, {
1984                 .alg = "ecb(tnepres)",
1985                 .test = alg_test_skcipher,
1986                 .suite = {
1987                         .cipher = {
1988                                 .enc = {
1989                                         .vecs = tnepres_enc_tv_template,
1990                                         .count = TNEPRES_ENC_TEST_VECTORS
1991                                 },
1992                                 .dec = {
1993                                         .vecs = tnepres_dec_tv_template,
1994                                         .count = TNEPRES_DEC_TEST_VECTORS
1995                                 }
1996                         }
1997                 }
1998         }, {
1999                 .alg = "ecb(twofish)",
2000                 .test = alg_test_skcipher,
2001                 .suite = {
2002                         .cipher = {
2003                                 .enc = {
2004                                         .vecs = tf_enc_tv_template,
2005                                         .count = TF_ENC_TEST_VECTORS
2006                                 },
2007                                 .dec = {
2008                                         .vecs = tf_dec_tv_template,
2009                                         .count = TF_DEC_TEST_VECTORS
2010                                 }
2011                         }
2012                 }
2013         }, {
2014                 .alg = "ecb(xeta)",
2015                 .test = alg_test_skcipher,
2016                 .suite = {
2017                         .cipher = {
2018                                 .enc = {
2019                                         .vecs = xeta_enc_tv_template,
2020                                         .count = XETA_ENC_TEST_VECTORS
2021                                 },
2022                                 .dec = {
2023                                         .vecs = xeta_dec_tv_template,
2024                                         .count = XETA_DEC_TEST_VECTORS
2025                                 }
2026                         }
2027                 }
2028         }, {
2029                 .alg = "ecb(xtea)",
2030                 .test = alg_test_skcipher,
2031                 .suite = {
2032                         .cipher = {
2033                                 .enc = {
2034                                         .vecs = xtea_enc_tv_template,
2035                                         .count = XTEA_ENC_TEST_VECTORS
2036                                 },
2037                                 .dec = {
2038                                         .vecs = xtea_dec_tv_template,
2039                                         .count = XTEA_DEC_TEST_VECTORS
2040                                 }
2041                         }
2042                 }
2043         }, {
2044                 .alg = "gcm(aes)",
2045                 .test = alg_test_aead,
2046                 .fips_allowed = 1,
2047                 .suite = {
2048                         .aead = {
2049                                 .enc = {
2050                                         .vecs = aes_gcm_enc_tv_template,
2051                                         .count = AES_GCM_ENC_TEST_VECTORS
2052                                 },
2053                                 .dec = {
2054                                         .vecs = aes_gcm_dec_tv_template,
2055                                         .count = AES_GCM_DEC_TEST_VECTORS
2056                                 }
2057                         }
2058                 }
2059         }, {
2060                 .alg = "ghash",
2061                 .test = alg_test_hash,
2062                 .suite = {
2063                         .hash = {
2064                                 .vecs = ghash_tv_template,
2065                                 .count = GHASH_TEST_VECTORS
2066                         }
2067                 }
2068         }, {
2069                 .alg = "hmac(md5)",
2070                 .test = alg_test_hash,
2071                 .suite = {
2072                         .hash = {
2073                                 .vecs = hmac_md5_tv_template,
2074                                 .count = HMAC_MD5_TEST_VECTORS
2075                         }
2076                 }
2077         }, {
2078                 .alg = "hmac(rmd128)",
2079                 .test = alg_test_hash,
2080                 .suite = {
2081                         .hash = {
2082                                 .vecs = hmac_rmd128_tv_template,
2083                                 .count = HMAC_RMD128_TEST_VECTORS
2084                         }
2085                 }
2086         }, {
2087                 .alg = "hmac(rmd160)",
2088                 .test = alg_test_hash,
2089                 .suite = {
2090                         .hash = {
2091                                 .vecs = hmac_rmd160_tv_template,
2092                                 .count = HMAC_RMD160_TEST_VECTORS
2093                         }
2094                 }
2095         }, {
2096                 .alg = "hmac(sha1)",
2097                 .test = alg_test_hash,
2098                 .fips_allowed = 1,
2099                 .suite = {
2100                         .hash = {
2101                                 .vecs = hmac_sha1_tv_template,
2102                                 .count = HMAC_SHA1_TEST_VECTORS
2103                         }
2104                 }
2105         }, {
2106                 .alg = "hmac(sha224)",
2107                 .test = alg_test_hash,
2108                 .fips_allowed = 1,
2109                 .suite = {
2110                         .hash = {
2111                                 .vecs = hmac_sha224_tv_template,
2112                                 .count = HMAC_SHA224_TEST_VECTORS
2113                         }
2114                 }
2115         }, {
2116                 .alg = "hmac(sha256)",
2117                 .test = alg_test_hash,
2118                 .fips_allowed = 1,
2119                 .suite = {
2120                         .hash = {
2121                                 .vecs = hmac_sha256_tv_template,
2122                                 .count = HMAC_SHA256_TEST_VECTORS
2123                         }
2124                 }
2125         }, {
2126                 .alg = "hmac(sha384)",
2127                 .test = alg_test_hash,
2128                 .fips_allowed = 1,
2129                 .suite = {
2130                         .hash = {
2131                                 .vecs = hmac_sha384_tv_template,
2132                                 .count = HMAC_SHA384_TEST_VECTORS
2133                         }
2134                 }
2135         }, {
2136                 .alg = "hmac(sha512)",
2137                 .test = alg_test_hash,
2138                 .fips_allowed = 1,
2139                 .suite = {
2140                         .hash = {
2141                                 .vecs = hmac_sha512_tv_template,
2142                                 .count = HMAC_SHA512_TEST_VECTORS
2143                         }
2144                 }
2145         }, {
2146                 .alg = "lrw(aes)",
2147                 .test = alg_test_skcipher,
2148                 .suite = {
2149                         .cipher = {
2150                                 .enc = {
2151                                         .vecs = aes_lrw_enc_tv_template,
2152                                         .count = AES_LRW_ENC_TEST_VECTORS
2153                                 },
2154                                 .dec = {
2155                                         .vecs = aes_lrw_dec_tv_template,
2156                                         .count = AES_LRW_DEC_TEST_VECTORS
2157                                 }
2158                         }
2159                 }
2160         }, {
2161                 .alg = "lzo",
2162                 .test = alg_test_comp,
2163                 .suite = {
2164                         .comp = {
2165                                 .comp = {
2166                                         .vecs = lzo_comp_tv_template,
2167                                         .count = LZO_COMP_TEST_VECTORS
2168                                 },
2169                                 .decomp = {
2170                                         .vecs = lzo_decomp_tv_template,
2171                                         .count = LZO_DECOMP_TEST_VECTORS
2172                                 }
2173                         }
2174                 }
2175         }, {
2176                 .alg = "md4",
2177                 .test = alg_test_hash,
2178                 .suite = {
2179                         .hash = {
2180                                 .vecs = md4_tv_template,
2181                                 .count = MD4_TEST_VECTORS
2182                         }
2183                 }
2184         }, {
2185                 .alg = "md5",
2186                 .test = alg_test_hash,
2187                 .suite = {
2188                         .hash = {
2189                                 .vecs = md5_tv_template,
2190                                 .count = MD5_TEST_VECTORS
2191                         }
2192                 }
2193         }, {
2194                 .alg = "michael_mic",
2195                 .test = alg_test_hash,
2196                 .suite = {
2197                         .hash = {
2198                                 .vecs = michael_mic_tv_template,
2199                                 .count = MICHAEL_MIC_TEST_VECTORS
2200                         }
2201                 }
2202         }, {
2203                 .alg = "pcbc(fcrypt)",
2204                 .test = alg_test_skcipher,
2205                 .suite = {
2206                         .cipher = {
2207                                 .enc = {
2208                                         .vecs = fcrypt_pcbc_enc_tv_template,
2209                                         .count = FCRYPT_ENC_TEST_VECTORS
2210                                 },
2211                                 .dec = {
2212                                         .vecs = fcrypt_pcbc_dec_tv_template,
2213                                         .count = FCRYPT_DEC_TEST_VECTORS
2214                                 }
2215                         }
2216                 }
2217         }, {
2218                 .alg = "rfc3686(ctr(aes))",
2219                 .test = alg_test_skcipher,
2220                 .fips_allowed = 1,
2221                 .suite = {
2222                         .cipher = {
2223                                 .enc = {
2224                                         .vecs = aes_ctr_rfc3686_enc_tv_template,
2225                                         .count = AES_CTR_3686_ENC_TEST_VECTORS
2226                                 },
2227                                 .dec = {
2228                                         .vecs = aes_ctr_rfc3686_dec_tv_template,
2229                                         .count = AES_CTR_3686_DEC_TEST_VECTORS
2230                                 }
2231                         }
2232                 }
2233         }, {
2234                 .alg = "rfc4309(ccm(aes))",
2235                 .test = alg_test_aead,
2236                 .fips_allowed = 1,
2237                 .suite = {
2238                         .aead = {
2239                                 .enc = {
2240                                         .vecs = aes_ccm_rfc4309_enc_tv_template,
2241                                         .count = AES_CCM_4309_ENC_TEST_VECTORS
2242                                 },
2243                                 .dec = {
2244                                         .vecs = aes_ccm_rfc4309_dec_tv_template,
2245                                         .count = AES_CCM_4309_DEC_TEST_VECTORS
2246                                 }
2247                         }
2248                 }
2249         }, {
2250                 .alg = "rmd128",
2251                 .test = alg_test_hash,
2252                 .suite = {
2253                         .hash = {
2254                                 .vecs = rmd128_tv_template,
2255                                 .count = RMD128_TEST_VECTORS
2256                         }
2257                 }
2258         }, {
2259                 .alg = "rmd160",
2260                 .test = alg_test_hash,
2261                 .suite = {
2262                         .hash = {
2263                                 .vecs = rmd160_tv_template,
2264                                 .count = RMD160_TEST_VECTORS
2265                         }
2266                 }
2267         }, {
2268                 .alg = "rmd256",
2269                 .test = alg_test_hash,
2270                 .suite = {
2271                         .hash = {
2272                                 .vecs = rmd256_tv_template,
2273                                 .count = RMD256_TEST_VECTORS
2274                         }
2275                 }
2276         }, {
2277                 .alg = "rmd320",
2278                 .test = alg_test_hash,
2279                 .suite = {
2280                         .hash = {
2281                                 .vecs = rmd320_tv_template,
2282                                 .count = RMD320_TEST_VECTORS
2283                         }
2284                 }
2285         }, {
2286                 .alg = "salsa20",
2287                 .test = alg_test_skcipher,
2288                 .suite = {
2289                         .cipher = {
2290                                 .enc = {
2291                                         .vecs = salsa20_stream_enc_tv_template,
2292                                         .count = SALSA20_STREAM_ENC_TEST_VECTORS
2293                                 }
2294                         }
2295                 }
2296         }, {
2297                 .alg = "sha1",
2298                 .test = alg_test_hash,
2299                 .fips_allowed = 1,
2300                 .suite = {
2301                         .hash = {
2302                                 .vecs = sha1_tv_template,
2303                                 .count = SHA1_TEST_VECTORS
2304                         }
2305                 }
2306         }, {
2307                 .alg = "sha224",
2308                 .test = alg_test_hash,
2309                 .fips_allowed = 1,
2310                 .suite = {
2311                         .hash = {
2312                                 .vecs = sha224_tv_template,
2313                                 .count = SHA224_TEST_VECTORS
2314                         }
2315                 }
2316         }, {
2317                 .alg = "sha256",
2318                 .test = alg_test_hash,
2319                 .fips_allowed = 1,
2320                 .suite = {
2321                         .hash = {
2322                                 .vecs = sha256_tv_template,
2323                                 .count = SHA256_TEST_VECTORS
2324                         }
2325                 }
2326         }, {
2327                 .alg = "sha384",
2328                 .test = alg_test_hash,
2329                 .fips_allowed = 1,
2330                 .suite = {
2331                         .hash = {
2332                                 .vecs = sha384_tv_template,
2333                                 .count = SHA384_TEST_VECTORS
2334                         }
2335                 }
2336         }, {
2337                 .alg = "sha512",
2338                 .test = alg_test_hash,
2339                 .fips_allowed = 1,
2340                 .suite = {
2341                         .hash = {
2342                                 .vecs = sha512_tv_template,
2343                                 .count = SHA512_TEST_VECTORS
2344                         }
2345                 }
2346         }, {
2347                 .alg = "tgr128",
2348                 .test = alg_test_hash,
2349                 .suite = {
2350                         .hash = {
2351                                 .vecs = tgr128_tv_template,
2352                                 .count = TGR128_TEST_VECTORS
2353                         }
2354                 }
2355         }, {
2356                 .alg = "tgr160",
2357                 .test = alg_test_hash,
2358                 .suite = {
2359                         .hash = {
2360                                 .vecs = tgr160_tv_template,
2361                                 .count = TGR160_TEST_VECTORS
2362                         }
2363                 }
2364         }, {
2365                 .alg = "tgr192",
2366                 .test = alg_test_hash,
2367                 .suite = {
2368                         .hash = {
2369                                 .vecs = tgr192_tv_template,
2370                                 .count = TGR192_TEST_VECTORS
2371                         }
2372                 }
2373         }, {
2374                 .alg = "vmac(aes)",
2375                 .test = alg_test_hash,
2376                 .suite = {
2377                         .hash = {
2378                                 .vecs = aes_vmac128_tv_template,
2379                                 .count = VMAC_AES_TEST_VECTORS
2380                         }
2381                 }
2382         }, {
2383                 .alg = "wp256",
2384                 .test = alg_test_hash,
2385                 .suite = {
2386                         .hash = {
2387                                 .vecs = wp256_tv_template,
2388                                 .count = WP256_TEST_VECTORS
2389                         }
2390                 }
2391         }, {
2392                 .alg = "wp384",
2393                 .test = alg_test_hash,
2394                 .suite = {
2395                         .hash = {
2396                                 .vecs = wp384_tv_template,
2397                                 .count = WP384_TEST_VECTORS
2398                         }
2399                 }
2400         }, {
2401                 .alg = "wp512",
2402                 .test = alg_test_hash,
2403                 .suite = {
2404                         .hash = {
2405                                 .vecs = wp512_tv_template,
2406                                 .count = WP512_TEST_VECTORS
2407                         }
2408                 }
2409         }, {
2410                 .alg = "xcbc(aes)",
2411                 .test = alg_test_hash,
2412                 .suite = {
2413                         .hash = {
2414                                 .vecs = aes_xcbc128_tv_template,
2415                                 .count = XCBC_AES_TEST_VECTORS
2416                         }
2417                 }
2418         }, {
2419                 .alg = "xts(aes)",
2420                 .test = alg_test_skcipher,
2421                 .suite = {
2422                         .cipher = {
2423                                 .enc = {
2424                                         .vecs = aes_xts_enc_tv_template,
2425                                         .count = AES_XTS_ENC_TEST_VECTORS
2426                                 },
2427                                 .dec = {
2428                                         .vecs = aes_xts_dec_tv_template,
2429                                         .count = AES_XTS_DEC_TEST_VECTORS
2430                                 }
2431                         }
2432                 }
2433         }, {
2434                 .alg = "zlib",
2435                 .test = alg_test_pcomp,
2436                 .suite = {
2437                         .pcomp = {
2438                                 .comp = {
2439                                         .vecs = zlib_comp_tv_template,
2440                                         .count = ZLIB_COMP_TEST_VECTORS
2441                                 },
2442                                 .decomp = {
2443                                         .vecs = zlib_decomp_tv_template,
2444                                         .count = ZLIB_DECOMP_TEST_VECTORS
2445                                 }
2446                         }
2447                 }
2448         }
2449 };
2450
2451 static int alg_find_test(const char *alg)
2452 {
2453         int start = 0;
2454         int end = ARRAY_SIZE(alg_test_descs);
2455
2456         while (start < end) {
2457                 int i = (start + end) / 2;
2458                 int diff = strcmp(alg_test_descs[i].alg, alg);
2459
2460                 if (diff > 0) {
2461                         end = i;
2462                         continue;
2463                 }
2464
2465                 if (diff < 0) {
2466                         start = i + 1;
2467                         continue;
2468                 }
2469
2470                 return i;
2471         }
2472
2473         return -1;
2474 }
2475
2476 int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
2477 {
2478         int i;
2479         int j;
2480         int rc;
2481
2482         if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) {
2483                 char nalg[CRYPTO_MAX_ALG_NAME];
2484
2485                 if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >=
2486                     sizeof(nalg))
2487                         return -ENAMETOOLONG;
2488
2489                 i = alg_find_test(nalg);
2490                 if (i < 0)
2491                         goto notest;
2492
2493                 if (fips_enabled && !alg_test_descs[i].fips_allowed)
2494                         goto non_fips_alg;
2495
2496                 rc = alg_test_cipher(alg_test_descs + i, driver, type, mask);
2497                 goto test_done;
2498         }
2499
2500         i = alg_find_test(alg);
2501         j = alg_find_test(driver);
2502         if (i < 0 && j < 0)
2503                 goto notest;
2504
2505         if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) ||
2506                              (j >= 0 && !alg_test_descs[j].fips_allowed)))
2507                 goto non_fips_alg;
2508
2509         rc = 0;
2510         if (i >= 0)
2511                 rc |= alg_test_descs[i].test(alg_test_descs + i, driver,
2512                                              type, mask);
2513         if (j >= 0)
2514                 rc |= alg_test_descs[j].test(alg_test_descs + j, driver,
2515                                              type, mask);
2516
2517 test_done:
2518         if (fips_enabled && rc)
2519                 panic("%s: %s alg self test failed in fips mode!\n", driver, alg);
2520
2521         if (fips_enabled && !rc)
2522                 printk(KERN_INFO "alg: self-tests for %s (%s) passed\n",
2523                        driver, alg);
2524
2525         return rc;
2526
2527 notest:
2528         printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
2529         return 0;
2530 non_fips_alg:
2531         return -EINVAL;
2532 }
2533 EXPORT_SYMBOL_GPL(alg_test);