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/gfp.h>
  22 #include <linux/module.h>
  23 #include <linux/scatterlist.h>
  24 #include <linux/string.h>
  25 #include <linux/moduleparam.h>
  26 #include <linux/jiffies.h>
  27 #include <linux/timex.h>
  28 #include <linux/interrupt.h>
  29 #include "tcrypt.h"
  30 #include "internal.h"
  31
  32 /*
  33  * Need slab memory for testing (size in number of pages).
  34  */
  35 #define TVMEMSIZE       4
  36
  37 /*
  38 * Used by test_cipher_speed()
  39 */
  40 #define ENCRYPT 1
  41 #define DECRYPT 0
  42
  43 /*
  44  * Used by test_cipher_speed()
  45  */
  46 static unsigned int sec;
  47
  48 static char *alg = NULL;
  49 static u32 type;
  50 static u32 mask;
  51 static int mode;
  52 static char *tvmem[TVMEMSIZE];
  53
  54 static char *check[] = {
  55         "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256",
  56         "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes",
  57         "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
  58         "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta",  "fcrypt",
  59         "camellia", "seed", "salsa20", "rmd128", "rmd160", "rmd256", "rmd320",
  60         "lzo", "cts", "zlib", NULL
  61 };
  62
  63 static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc,
  64                                struct scatterlist *sg, int blen, int sec)
  65 {
  66         unsigned long start, end;
  67         int bcount;
  68         int ret;
  69
  70         for (start = jiffies, end = start + sec * HZ, bcount = 0;
  71              time_before(jiffies, end); bcount++) {
  72                 if (enc)
  73                         ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
  74                 else
  75                         ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
  76
  77                 if (ret)
  78                         return ret;
  79         }
  80
  81         printk("%d operations in %d seconds (%ld bytes)\n",
  82                bcount, sec, (long)bcount * blen);
  83         return 0;
  84 }
  85
  86 static int test_cipher_cycles(struct blkcipher_desc *desc, int enc,
  87                               struct scatterlist *sg, int blen)
  88 {
  89         unsigned long cycles = 0;
  90         int ret = 0;
  91         int i;
  92
  93         local_bh_disable();
  94         local_irq_disable();
  95
  96         /* Warm-up run. */
  97         for (i = 0; i < 4; i++) {
  98                 if (enc)
  99                         ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
 100                 else
 101                         ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
 102
 103                 if (ret)
 104                         goto out;
 105         }
 106
 107         /* The real thing. */
 108         for (i = 0; i < 8; i++) {
 109                 cycles_t start, end;
 110
 111                 start = get_cycles();
 112                 if (enc)
 113                         ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
 114                 else
 115                         ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
 116                 end = get_cycles();
 117
 118                 if (ret)
 119                         goto out;
 120
 121                 cycles += end - start;
 122         }
 123
 124 out:
 125         local_irq_enable();
 126         local_bh_enable();
 127
 128         if (ret == 0)
 129                 printk("1 operation in %lu cycles (%d bytes)\n",
 130                        (cycles + 4) / 8, blen);
 131
 132         return ret;
 133 }
 134
 135 static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 };
 136
 137 static void test_cipher_speed(const char *algo, int enc, unsigned int sec,
 138                               struct cipher_speed_template *template,
 139                               unsigned int tcount, u8 *keysize)
 140 {
 141         unsigned int ret, i, j, iv_len;
 142         const char *key, iv[128];
 143         struct crypto_blkcipher *tfm;
 144         struct blkcipher_desc desc;
 145         const char *e;
 146         u32 *b_size;
 147
 148         if (enc == ENCRYPT)
 149                 e = "encryption";
 150         else
 151                 e = "decryption";
 152
 153         printk("\ntesting speed of %s %s\n", algo, e);
 154
 155         tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);
 156
 157         if (IS_ERR(tfm)) {
 158                 printk("failed to load transform for %s: %ld\n", algo,
 159                        PTR_ERR(tfm));
 160                 return;
 161         }
 162         desc.tfm = tfm;
 163         desc.flags = 0;
 164
 165         i = 0;
 166         do {
 167
 168                 b_size = block_sizes;
 169                 do {
 170                         struct scatterlist sg[TVMEMSIZE];
 171
 172                         if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
 173                                 printk("template (%u) too big for "
 174                                        "tvmem (%lu)\n", *keysize + *b_size,
 175                                        TVMEMSIZE * PAGE_SIZE);
 176                                 goto out;
 177                         }
 178
 179                         printk("test %u (%d bit key, %d byte blocks): ", i,
 180                                         *keysize * 8, *b_size);
 181
 182                         memset(tvmem[0], 0xff, PAGE_SIZE);
 183
 184                         /* set key, plain text and IV */
 185                         key = tvmem[0];
 186                         for (j = 0; j < tcount; j++) {
 187                                 if (template[j].klen == *keysize) {
 188                                         key = template[j].key;
 189                                         break;
 190                                 }
 191                         }
 192
 193                         ret = crypto_blkcipher_setkey(tfm, key, *keysize);
 194                         if (ret) {
 195                                 printk("setkey() failed flags=%x\n",
 196                                                 crypto_blkcipher_get_flags(tfm));
 197                                 goto out;
 198                         }
 199
 200                         sg_init_table(sg, TVMEMSIZE);
 201                         sg_set_buf(sg, tvmem[0] + *keysize,
 202                                    PAGE_SIZE - *keysize);
 203                         for (j = 1; j < TVMEMSIZE; j++) {
 204                                 sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
 205                                 memset (tvmem[j], 0xff, PAGE_SIZE);
 206                         }
 207
 208                         iv_len = crypto_blkcipher_ivsize(tfm);
 209                         if (iv_len) {
 210                                 memset(&iv, 0xff, iv_len);
 211                                 crypto_blkcipher_set_iv(tfm, iv, iv_len);
 212                         }
 213
 214                         if (sec)
 215                                 ret = test_cipher_jiffies(&desc, enc, sg,
 216                                                           *b_size, sec);
 217                         else
 218                                 ret = test_cipher_cycles(&desc, enc, sg,
 219                                                          *b_size);
 220
 221                         if (ret) {
 222                                 printk("%s() failed flags=%x\n", e, desc.flags);
 223                                 break;
 224                         }
 225                         b_size++;
 226                         i++;
 227                 } while (*b_size);
 228                 keysize++;
 229         } while (*keysize);
 230
 231 out:
 232         crypto_free_blkcipher(tfm);
 233 }
 234
 235 static int test_hash_jiffies_digest(struct hash_desc *desc,
 236                                     struct scatterlist *sg, int blen,
 237                                     char *out, int sec)
 238 {
 239         unsigned long start, end;
 240         int bcount;
 241         int ret;
 242
 243         for (start = jiffies, end = start + sec * HZ, bcount = 0;
 244              time_before(jiffies, end); bcount++) {
 245                 ret = crypto_hash_digest(desc, sg, blen, out);
 246                 if (ret)
 247                         return ret;
 248         }
 249
 250         printk("%6u opers/sec, %9lu bytes/sec\n",
 251                bcount / sec, ((long)bcount * blen) / sec);
 252
 253         return 0;
 254 }
 255
 256 static int test_hash_jiffies(struct hash_desc *desc, struct scatterlist *sg,
 257                              int blen, int plen, char *out, int sec)
 258 {
 259         unsigned long start, end;
 260         int bcount, pcount;
 261         int ret;
 262
 263         if (plen == blen)
 264                 return test_hash_jiffies_digest(desc, sg, blen, out, sec);
 265
 266         for (start = jiffies, end = start + sec * HZ, bcount = 0;
 267              time_before(jiffies, end); bcount++) {
 268                 ret = crypto_hash_init(desc);
 269                 if (ret)
 270                         return ret;
 271                 for (pcount = 0; pcount < blen; pcount += plen) {
 272                         ret = crypto_hash_update(desc, sg, plen);
 273                         if (ret)
 274                                 return ret;
 275                 }
 276                 /* we assume there is enough space in 'out' for the result */
 277                 ret = crypto_hash_final(desc, out);
 278                 if (ret)
 279                         return ret;
 280         }
 281
 282         printk("%6u opers/sec, %9lu bytes/sec\n",
 283                bcount / sec, ((long)bcount * blen) / sec);
 284
 285         return 0;
 286 }
 287
 288 static int test_hash_cycles_digest(struct hash_desc *desc,
 289                                    struct scatterlist *sg, int blen, char *out)
 290 {
 291         unsigned long cycles = 0;
 292         int i;
 293         int ret;
 294
 295         local_bh_disable();
 296         local_irq_disable();
 297
 298         /* Warm-up run. */
 299         for (i = 0; i < 4; i++) {
 300                 ret = crypto_hash_digest(desc, sg, blen, out);
 301                 if (ret)
 302                         goto out;
 303         }
 304
 305         /* The real thing. */
 306         for (i = 0; i < 8; i++) {
 307                 cycles_t start, end;
 308
 309                 start = get_cycles();
 310
 311                 ret = crypto_hash_digest(desc, sg, blen, out);
 312                 if (ret)
 313                         goto out;
 314
 315                 end = get_cycles();
 316
 317                 cycles += end - start;
 318         }
 319
 320 out:
 321         local_irq_enable();
 322         local_bh_enable();
 323
 324         if (ret)
 325                 return ret;
 326
 327         printk("%6lu cycles/operation, %4lu cycles/byte\n",
 328                cycles / 8, cycles / (8 * blen));
 329
 330         return 0;
 331 }
 332
 333 static int test_hash_cycles(struct hash_desc *desc, struct scatterlist *sg,
 334                             int blen, int plen, char *out)
 335 {
 336         unsigned long cycles = 0;
 337         int i, pcount;
 338         int ret;
 339
 340         if (plen == blen)
 341                 return test_hash_cycles_digest(desc, sg, blen, out);
 342
 343         local_bh_disable();
 344         local_irq_disable();
 345
 346         /* Warm-up run. */
 347         for (i = 0; i < 4; i++) {
 348                 ret = crypto_hash_init(desc);
 349                 if (ret)
 350                         goto out;
 351                 for (pcount = 0; pcount < blen; pcount += plen) {
 352                         ret = crypto_hash_update(desc, sg, plen);
 353                         if (ret)
 354                                 goto out;
 355                 }
 356                 ret = crypto_hash_final(desc, out);
 357                 if (ret)
 358                         goto out;
 359         }
 360
 361         /* The real thing. */
 362         for (i = 0; i < 8; i++) {
 363                 cycles_t start, end;
 364
 365                 start = get_cycles();
 366
 367                 ret = crypto_hash_init(desc);
 368                 if (ret)
 369                         goto out;
 370                 for (pcount = 0; pcount < blen; pcount += plen) {
 371                         ret = crypto_hash_update(desc, sg, plen);
 372                         if (ret)
 373                                 goto out;
 374                 }
 375                 ret = crypto_hash_final(desc, out);
 376                 if (ret)
 377                         goto out;
 378
 379                 end = get_cycles();
 380
 381                 cycles += end - start;
 382         }
 383
 384 out:
 385         local_irq_enable();
 386         local_bh_enable();
 387
 388         if (ret)
 389                 return ret;
 390
 391         printk("%6lu cycles/operation, %4lu cycles/byte\n",
 392                cycles / 8, cycles / (8 * blen));
 393
 394         return 0;
 395 }
 396
 397 static void test_hash_speed(const char *algo, unsigned int sec,
 398                             struct hash_speed *speed)
 399 {
 400         struct scatterlist sg[TVMEMSIZE];
 401         struct crypto_hash *tfm;
 402         struct hash_desc desc;
 403         static char output[1024];
 404         int i;
 405         int ret;
 406
 407         printk(KERN_INFO "\ntesting speed of %s\n", algo);
 408
 409         tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
 410
 411         if (IS_ERR(tfm)) {
 412                 printk(KERN_ERR "failed to load transform for %s: %ld\n", algo,
 413                        PTR_ERR(tfm));
 414                 return;
 415         }
 416
 417         desc.tfm = tfm;
 418         desc.flags = 0;
 419
 420         if (crypto_hash_digestsize(tfm) > sizeof(output)) {
 421                 printk(KERN_ERR "digestsize(%u) > outputbuffer(%zu)\n",
 422                        crypto_hash_digestsize(tfm), sizeof(output));
 423                 goto out;
 424         }
 425
 426         sg_init_table(sg, TVMEMSIZE);
 427         for (i = 0; i < TVMEMSIZE; i++) {
 428                 sg_set_buf(sg + i, tvmem[i], PAGE_SIZE);
 429                 memset(tvmem[i], 0xff, PAGE_SIZE);
 430         }
 431
 432         for (i = 0; speed[i].blen != 0; i++) {
 433                 if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
 434                         printk(KERN_ERR
 435                                "template (%u) too big for tvmem (%lu)\n",
 436                                speed[i].blen, TVMEMSIZE * PAGE_SIZE);
 437                         goto out;
 438                 }
 439
 440                 printk(KERN_INFO "test%3u "
 441                        "(%5u byte blocks,%5u bytes per update,%4u updates): ",
 442                        i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
 443
 444                 if (sec)
 445                         ret = test_hash_jiffies(&desc, sg, speed[i].blen,
 446                                                 speed[i].plen, output, sec);
 447                 else
 448                         ret = test_hash_cycles(&desc, sg, speed[i].blen,
 449                                                speed[i].plen, output);
 450
 451                 if (ret) {
 452                         printk(KERN_ERR "hashing failed ret=%d\n", ret);
 453                         break;
 454                 }
 455         }
 456
 457 out:
 458         crypto_free_hash(tfm);
 459 }
 460
 461 static void test_available(void)
 462 {
 463         char **name = check;
 464
 465         while (*name) {
 466                 printk("alg %s ", *name);
 467                 printk(crypto_has_alg(*name, 0, 0) ?
 468                        "found\n" : "not found\n");
 469                 name++;
 470         }
 471 }
 472
 473 static inline int tcrypt_test(const char *alg)
 474 {
 475         int ret;
 476
 477         ret = alg_test(alg, alg, 0, 0);
 478         /* non-fips algs return -EINVAL in fips mode */
 479         if (fips_enabled && ret == -EINVAL)
 480                 ret = 0;
 481         return ret;
 482 }
 483
 484 static int do_test(int m)
 485 {
 486         int i;
 487         int ret = 0;
 488
 489         switch (m) {
 490         case 0:
 491                 for (i = 1; i < 200; i++)
 492                         ret += do_test(i);
 493                 break;
 494
 495         case 1:
 496                 ret += tcrypt_test("md5");
 497                 break;
 498
 499         case 2:
 500                 ret += tcrypt_test("sha1");
 501                 break;
 502
 503         case 3:
 504                 ret += tcrypt_test("ecb(des)");
 505                 ret += tcrypt_test("cbc(des)");
 506                 break;
 507
 508         case 4:
 509                 ret += tcrypt_test("ecb(des3_ede)");
 510                 ret += tcrypt_test("cbc(des3_ede)");
 511                 break;
 512
 513         case 5:
 514                 ret += tcrypt_test("md4");
 515                 break;
 516
 517         case 6:
 518                 ret += tcrypt_test("sha256");
 519                 break;
 520
 521         case 7:
 522                 ret += tcrypt_test("ecb(blowfish)");
 523                 ret += tcrypt_test("cbc(blowfish)");
 524                 break;
 525
 526         case 8:
 527                 ret += tcrypt_test("ecb(twofish)");
 528                 ret += tcrypt_test("cbc(twofish)");
 529                 break;
 530
 531         case 9:
 532                 ret += tcrypt_test("ecb(serpent)");
 533                 break;
 534
 535         case 10:
 536                 ret += tcrypt_test("ecb(aes)");
 537                 ret += tcrypt_test("cbc(aes)");
 538                 ret += tcrypt_test("lrw(aes)");
 539                 ret += tcrypt_test("xts(aes)");
 540                 ret += tcrypt_test("ctr(aes)");
 541                 ret += tcrypt_test("rfc3686(ctr(aes))");
 542                 break;
 543
 544         case 11:
 545                 ret += tcrypt_test("sha384");
 546                 break;
 547
 548         case 12:
 549                 ret += tcrypt_test("sha512");
 550                 break;
 551
 552         case 13:
 553                 ret += tcrypt_test("deflate");
 554                 break;
 555
 556         case 14:
 557                 ret += tcrypt_test("ecb(cast5)");
 558                 break;
 559
 560         case 15:
 561                 ret += tcrypt_test("ecb(cast6)");
 562                 break;
 563
 564         case 16:
 565                 ret += tcrypt_test("ecb(arc4)");
 566                 break;
 567
 568         case 17:
 569                 ret += tcrypt_test("michael_mic");
 570                 break;
 571
 572         case 18:
 573                 ret += tcrypt_test("crc32c");
 574                 break;
 575
 576         case 19:
 577                 ret += tcrypt_test("ecb(tea)");
 578                 break;
 579
 580         case 20:
 581                 ret += tcrypt_test("ecb(xtea)");
 582                 break;
 583
 584         case 21:
 585                 ret += tcrypt_test("ecb(khazad)");
 586                 break;
 587
 588         case 22:
 589                 ret += tcrypt_test("wp512");
 590                 break;
 591
 592         case 23:
 593                 ret += tcrypt_test("wp384");
 594                 break;
 595
 596         case 24:
 597                 ret += tcrypt_test("wp256");
 598                 break;
 599
 600         case 25:
 601                 ret += tcrypt_test("ecb(tnepres)");
 602                 break;
 603
 604         case 26:
 605                 ret += tcrypt_test("ecb(anubis)");
 606                 ret += tcrypt_test("cbc(anubis)");
 607                 break;
 608
 609         case 27:
 610                 ret += tcrypt_test("tgr192");
 611                 break;
 612
 613         case 28:
 614
 615                 ret += tcrypt_test("tgr160");
 616                 break;
 617
 618         case 29:
 619                 ret += tcrypt_test("tgr128");
 620                 break;
 621
 622         case 30:
 623                 ret += tcrypt_test("ecb(xeta)");
 624                 break;
 625
 626         case 31:
 627                 ret += tcrypt_test("pcbc(fcrypt)");
 628                 break;
 629
 630         case 32:
 631                 ret += tcrypt_test("ecb(camellia)");
 632                 ret += tcrypt_test("cbc(camellia)");
 633                 break;
 634         case 33:
 635                 ret += tcrypt_test("sha224");
 636                 break;
 637
 638         case 34:
 639                 ret += tcrypt_test("salsa20");
 640                 break;
 641
 642         case 35:
 643                 ret += tcrypt_test("gcm(aes)");
 644                 break;
 645
 646         case 36:
 647                 ret += tcrypt_test("lzo");
 648                 break;
 649
 650         case 37:
 651                 ret += tcrypt_test("ccm(aes)");
 652                 break;
 653
 654         case 38:
 655                 ret += tcrypt_test("cts(cbc(aes))");
 656                 break;
 657
 658         case 39:
 659                 ret += tcrypt_test("rmd128");
 660                 break;
 661
 662         case 40:
 663                 ret += tcrypt_test("rmd160");
 664                 break;
 665
 666         case 41:
 667                 ret += tcrypt_test("rmd256");
 668                 break;
 669
 670         case 42:
 671                 ret += tcrypt_test("rmd320");
 672                 break;
 673
 674         case 43:
 675                 ret += tcrypt_test("ecb(seed)");
 676                 break;
 677
 678         case 44:
 679                 ret += tcrypt_test("zlib");
 680                 break;
 681
 682         case 45:
 683                 ret += tcrypt_test("rfc4309(ccm(aes))");
 684                 break;
 685
 686         case 100:
 687                 ret += tcrypt_test("hmac(md5)");
 688                 break;
 689
 690         case 101:
 691                 ret += tcrypt_test("hmac(sha1)");
 692                 break;
 693
 694         case 102:
 695                 ret += tcrypt_test("hmac(sha256)");
 696                 break;
 697
 698         case 103:
 699                 ret += tcrypt_test("hmac(sha384)");
 700                 break;
 701
 702         case 104:
 703                 ret += tcrypt_test("hmac(sha512)");
 704                 break;
 705
 706         case 105:
 707                 ret += tcrypt_test("hmac(sha224)");
 708                 break;
 709
 710         case 106:
 711                 ret += tcrypt_test("xcbc(aes)");
 712                 break;
 713
 714         case 107:
 715                 ret += tcrypt_test("hmac(rmd128)");
 716                 break;
 717
 718         case 108:
 719                 ret += tcrypt_test("hmac(rmd160)");
 720                 break;
 721
 722         case 109:
 723                 ret += tcrypt_test("vmac(aes)");
 724                 break;
 725
 726         case 150:
 727                 ret += tcrypt_test("ansi_cprng");
 728                 break;
 729
 730         case 200:
 731                 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
 732                                 speed_template_16_24_32);
 733                 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
 734                                 speed_template_16_24_32);
 735                 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
 736                                 speed_template_16_24_32);
 737                 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
 738                                 speed_template_16_24_32);
 739                 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
 740                                 speed_template_32_40_48);
 741                 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
 742                                 speed_template_32_40_48);
 743                 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
 744                                 speed_template_32_48_64);
 745                 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
 746                                 speed_template_32_48_64);
 747                 break;
 748
 749         case 201:
 750                 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
 751                                 des3_speed_template, DES3_SPEED_VECTORS,
 752                                 speed_template_24);
 753                 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
 754                                 des3_speed_template, DES3_SPEED_VECTORS,
 755                                 speed_template_24);
 756                 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
 757                                 des3_speed_template, DES3_SPEED_VECTORS,
 758                                 speed_template_24);
 759                 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
 760                                 des3_speed_template, DES3_SPEED_VECTORS,
 761                                 speed_template_24);
 762                 break;
 763
 764         case 202:
 765                 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
 766                                 speed_template_16_24_32);
 767                 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
 768                                 speed_template_16_24_32);
 769                 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
 770                                 speed_template_16_24_32);
 771                 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
 772                                 speed_template_16_24_32);
 773                 break;
 774
 775         case 203:
 776                 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
 777                                   speed_template_8_32);
 778                 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
 779                                   speed_template_8_32);
 780                 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
 781                                   speed_template_8_32);
 782                 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
 783                                   speed_template_8_32);
 784                 break;
 785
 786         case 204:
 787                 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
 788                                   speed_template_8);
 789                 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
 790                                   speed_template_8);
 791                 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
 792                                   speed_template_8);
 793                 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
 794                                   speed_template_8);
 795                 break;
 796
 797         case 205:
 798                 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
 799                                 speed_template_16_24_32);
 800                 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
 801                                 speed_template_16_24_32);
 802                 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
 803                                 speed_template_16_24_32);
 804                 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
 805                                 speed_template_16_24_32);
 806                 break;
 807
 808         case 206:
 809                 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
 810                                   speed_template_16_32);
 811                 break;
 812
 813         case 300:
 814                 /* fall through */
 815
 816         case 301:
 817                 test_hash_speed("md4", sec, generic_hash_speed_template);
 818                 if (mode > 300 && mode < 400) break;
 819
 820         case 302:
 821                 test_hash_speed("md5", sec, generic_hash_speed_template);
 822                 if (mode > 300 && mode < 400) break;
 823
 824         case 303:
 825                 test_hash_speed("sha1", sec, generic_hash_speed_template);
 826                 if (mode > 300 && mode < 400) break;
 827
 828         case 304:
 829                 test_hash_speed("sha256", sec, generic_hash_speed_template);
 830                 if (mode > 300 && mode < 400) break;
 831
 832         case 305:
 833                 test_hash_speed("sha384", sec, generic_hash_speed_template);
 834                 if (mode > 300 && mode < 400) break;
 835
 836         case 306:
 837                 test_hash_speed("sha512", sec, generic_hash_speed_template);
 838                 if (mode > 300 && mode < 400) break;
 839
 840         case 307:
 841                 test_hash_speed("wp256", sec, generic_hash_speed_template);
 842                 if (mode > 300 && mode < 400) break;
 843
 844         case 308:
 845                 test_hash_speed("wp384", sec, generic_hash_speed_template);
 846                 if (mode > 300 && mode < 400) break;
 847
 848         case 309:
 849                 test_hash_speed("wp512", sec, generic_hash_speed_template);
 850                 if (mode > 300 && mode < 400) break;
 851
 852         case 310:
 853                 test_hash_speed("tgr128", sec, generic_hash_speed_template);
 854                 if (mode > 300 && mode < 400) break;
 855
 856         case 311:
 857                 test_hash_speed("tgr160", sec, generic_hash_speed_template);
 858                 if (mode > 300 && mode < 400) break;
 859
 860         case 312:
 861                 test_hash_speed("tgr192", sec, generic_hash_speed_template);
 862                 if (mode > 300 && mode < 400) break;
 863
 864         case 313:
 865                 test_hash_speed("sha224", sec, generic_hash_speed_template);
 866                 if (mode > 300 && mode < 400) break;
 867
 868         case 314:
 869                 test_hash_speed("rmd128", sec, generic_hash_speed_template);
 870                 if (mode > 300 && mode < 400) break;
 871
 872         case 315:
 873                 test_hash_speed("rmd160", sec, generic_hash_speed_template);
 874                 if (mode > 300 && mode < 400) break;
 875
 876         case 316:
 877                 test_hash_speed("rmd256", sec, generic_hash_speed_template);
 878                 if (mode > 300 && mode < 400) break;
 879
 880         case 317:
 881                 test_hash_speed("rmd320", sec, generic_hash_speed_template);
 882                 if (mode > 300 && mode < 400) break;
 883
 884         case 399:
 885                 break;
 886
 887         case 1000:
 888                 test_available();
 889                 break;
 890         }
 891
 892         return ret;
 893 }
 894
 895 static int do_alg_test(const char *alg, u32 type, u32 mask)
 896 {
 897         return crypto_has_alg(alg, type, mask ?: CRYPTO_ALG_TYPE_MASK) ?
 898                0 : -ENOENT;
 899 }
 900
 901 static int __init tcrypt_mod_init(void)
 902 {
 903         int err = -ENOMEM;
 904         int i;
 905
 906         for (i = 0; i < TVMEMSIZE; i++) {
 907                 tvmem[i] = (void *)__get_free_page(GFP_KERNEL);
 908                 if (!tvmem[i])
 909                         goto err_free_tv;
 910         }
 911
 912         if (alg)
 913                 err = do_alg_test(alg, type, mask);
 914         else
 915                 err = do_test(mode);
 916
 917         if (err) {
 918                 printk(KERN_ERR "tcrypt: one or more tests failed!\n");
 919                 goto err_free_tv;
 920         }
 921
 922         /* We intentionaly return -EAGAIN to prevent keeping the module,
 923          * unless we're running in fips mode. It does all its work from
 924          * init() and doesn't offer any runtime functionality, but in
 925          * the fips case, checking for a successful load is helpful.
 926          * => we don't need it in the memory, do we?
 927          *                                        -- mludvig
 928          */
 929         if (!fips_enabled)
 930                 err = -EAGAIN;
 931
 932 err_free_tv:
 933         for (i = 0; i < TVMEMSIZE && tvmem[i]; i++)
 934                 free_page((unsigned long)tvmem[i]);
 935
 936         return err;
 937 }
 938
 939 /*
 940  * If an init function is provided, an exit function must also be provided
 941  * to allow module unload.
 942  */
 943 static void __exit tcrypt_mod_fini(void) { }
 944
 945 module_init(tcrypt_mod_init);
 946 module_exit(tcrypt_mod_fini);
 947
 948 module_param(alg, charp, 0);
 949 module_param(type, uint, 0);
 950 module_param(mask, uint, 0);
 951 module_param(mode, int, 0);
 952 module_param(sec, uint, 0);
 953 MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
 954                       "(defaults to zero which uses CPU cycles instead)");
 955
 956 MODULE_LICENSE("GPL");
 957 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
 958 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");