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