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