crypto/tcrypt.c

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