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  *
  10  * This program is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU General Public License as published by the Free
  12  * Software Foundation; either version 2 of the License, or (at your option)
  13  * any later version.
  14  *
  15  * 2004-08-09 Added cipher speed tests (Reyk Floeter <reyk@vantronix.net>)
  16  * 2003-09-14 Rewritten by Kartikey Mahendra Bhatt
  17  *
  18  */
  19
  20 #include <linux/err.h>
  21 #include <linux/init.h>
  22 #include <linux/module.h>
  23 #include <linux/mm.h>
  24 #include <linux/slab.h>
  25 #include <linux/scatterlist.h>
  26 #include <linux/string.h>
  27 #include <linux/crypto.h>
  28 #include <linux/highmem.h>
  29 #include <linux/moduleparam.h>
  30 #include <linux/jiffies.h>
  31 #include <linux/timex.h>
  32 #include <linux/interrupt.h>
  33 #include "tcrypt.h"
  34
  35 /*
  36  * Need to kmalloc() memory for testing kmap().
  37  */
  38 #define TVMEMSIZE       16384
  39 #define XBUFSIZE        32768
  40
  41 /*
  42  * Indexes into the xbuf to simulate cross-page access.
  43  */
  44 #define IDX1            37
  45 #define IDX2            32400
  46 #define IDX3            1
  47 #define IDX4            8193
  48 #define IDX5            22222
  49 #define IDX6            17101
  50 #define IDX7            27333
  51 #define IDX8            3000
  52
  53 /*
  54 * Used by test_cipher()
  55 */
  56 #define ENCRYPT 1
  57 #define DECRYPT 0
  58
  59 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
  60
  61 /*
  62  * Used by test_cipher_speed()
  63  */
  64 static unsigned int sec;
  65
  66 static int mode;
  67 static char *xbuf;
  68 static char *tvmem;
  69
  70 static char *check[] = {
  71         "des", "md5", "des3_ede", "rot13", "sha1", "sha256", "blowfish",
  72         "twofish", "serpent", "sha384", "sha512", "md4", "aes", "cast6",
  73         "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
  74         "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", NULL
  75 };
  76
  77 static void hexdump(unsigned char *buf, unsigned int len)
  78 {
  79         while (len--)
  80                 printk("%02x", *buf++);
  81
  82         printk("\n");
  83 }
  84
  85 static void test_hash(char *algo, struct hash_testvec *template,
  86                       unsigned int tcount)
  87 {
  88         unsigned int i, j, k, temp;
  89         struct scatterlist sg[8];
  90         char result[64];
  91         struct crypto_hash *tfm;
  92         struct hash_desc desc;
  93         struct hash_testvec *hash_tv;
  94         unsigned int tsize;
  95         int ret;
  96
  97         printk("\ntesting %s\n", algo);
  98
  99         tsize = sizeof(struct hash_testvec);
 100         tsize *= tcount;
 101
 102         if (tsize > TVMEMSIZE) {
 103                 printk("template (%u) too big for tvmem (%u)\n", tsize, TVMEMSIZE);
 104                 return;
 105         }
 106
 107         memcpy(tvmem, template, tsize);
 108         hash_tv = (void *)tvmem;
 109
 110         tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
 111         if (IS_ERR(tfm)) {
 112                 printk("failed to load transform for %s: %ld\n", algo,
 113                        PTR_ERR(tfm));
 114                 return;
 115         }
 116
 117         desc.tfm = tfm;
 118         desc.flags = 0;
 119
 120         for (i = 0; i < tcount; i++) {
 121                 printk("test %u:\n", i + 1);
 122                 memset(result, 0, 64);
 123
 124                 sg_set_buf(&sg[0], hash_tv[i].plaintext, hash_tv[i].psize);
 125
 126                 if (hash_tv[i].ksize) {
 127                         ret = crypto_hash_setkey(tfm, hash_tv[i].key,
 128                                                  hash_tv[i].ksize);
 129                         if (ret) {
 130                                 printk("setkey() failed ret=%d\n", ret);
 131                                 goto out;
 132                         }
 133                 }
 134
 135                 ret = crypto_hash_digest(&desc, sg, hash_tv[i].psize, result);
 136                 if (ret) {
 137                         printk("digest () failed ret=%d\n", ret);
 138                         goto out;
 139                 }
 140
 141                 hexdump(result, crypto_hash_digestsize(tfm));
 142                 printk("%s\n",
 143                        memcmp(result, hash_tv[i].digest,
 144                               crypto_hash_digestsize(tfm)) ?
 145                        "fail" : "pass");
 146         }
 147
 148         printk("testing %s across pages\n", algo);
 149
 150         /* setup the dummy buffer first */
 151         memset(xbuf, 0, XBUFSIZE);
 152
 153         j = 0;
 154         for (i = 0; i < tcount; i++) {
 155                 if (hash_tv[i].np) {
 156                         j++;
 157                         printk("test %u:\n", j);
 158                         memset(result, 0, 64);
 159
 160                         temp = 0;
 161                         for (k = 0; k < hash_tv[i].np; k++) {
 162                                 memcpy(&xbuf[IDX[k]],
 163                                        hash_tv[i].plaintext + temp,
 164                                        hash_tv[i].tap[k]);
 165                                 temp += hash_tv[i].tap[k];
 166                                 sg_set_buf(&sg[k], &xbuf[IDX[k]],
 167                                             hash_tv[i].tap[k]);
 168                         }
 169
 170                         if (hash_tv[i].ksize) {
 171                                 ret = crypto_hash_setkey(tfm, hash_tv[i].key,
 172                                                          hash_tv[i].ksize);
 173
 174                                 if (ret) {
 175                                         printk("setkey() failed ret=%d\n", ret);
 176                                         goto out;
 177                                 }
 178                         }
 179
 180                         ret = crypto_hash_digest(&desc, sg, hash_tv[i].psize,
 181                                                  result);
 182                         if (ret) {
 183                                 printk("digest () failed ret=%d\n", ret);
 184                                 goto out;
 185                         }
 186
 187                         hexdump(result, crypto_hash_digestsize(tfm));
 188                         printk("%s\n",
 189                                memcmp(result, hash_tv[i].digest,
 190                                       crypto_hash_digestsize(tfm)) ?
 191                                "fail" : "pass");
 192                 }
 193         }
 194
 195 out:
 196         crypto_free_hash(tfm);
 197 }
 198
 199 static void test_cipher(char *algo, int enc,
 200                         struct cipher_testvec *template, unsigned int tcount)
 201 {
 202         unsigned int ret, i, j, k, temp;
 203         unsigned int tsize;
 204         unsigned int iv_len;
 205         unsigned int len;
 206         char *q;
 207         struct crypto_blkcipher *tfm;
 208         char *key;
 209         struct cipher_testvec *cipher_tv;
 210         struct blkcipher_desc desc;
 211         struct scatterlist sg[8];
 212         const char *e;
 213
 214         if (enc == ENCRYPT)
 215                 e = "encryption";
 216         else
 217                 e = "decryption";
 218
 219         printk("\ntesting %s %s\n", algo, e);
 220
 221         tsize = sizeof (struct cipher_testvec);
 222         tsize *= tcount;
 223
 224         if (tsize > TVMEMSIZE) {
 225                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 226                        TVMEMSIZE);
 227                 return;
 228         }
 229
 230         memcpy(tvmem, template, tsize);
 231         cipher_tv = (void *)tvmem;
 232
 233         tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);
 234
 235         if (IS_ERR(tfm)) {
 236                 printk("failed to load transform for %s: %ld\n", algo,
 237                        PTR_ERR(tfm));
 238                 return;
 239         }
 240         desc.tfm = tfm;
 241         desc.flags = 0;
 242
 243         j = 0;
 244         for (i = 0; i < tcount; i++) {
 245                 if (!(cipher_tv[i].np)) {
 246                         j++;
 247                         printk("test %u (%d bit key):\n",
 248                         j, cipher_tv[i].klen * 8);
 249
 250                         crypto_blkcipher_clear_flags(tfm, ~0);
 251                         if (cipher_tv[i].wk)
 252                                 crypto_blkcipher_set_flags(
 253                                         tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 254                         key = cipher_tv[i].key;
 255
 256                         ret = crypto_blkcipher_setkey(tfm, key,
 257                                                       cipher_tv[i].klen);
 258                         if (ret) {
 259                                 printk("setkey() failed flags=%x\n",
 260                                        crypto_blkcipher_get_flags(tfm));
 261
 262                                 if (!cipher_tv[i].fail)
 263                                         goto out;
 264                         }
 265
 266                         sg_set_buf(&sg[0], cipher_tv[i].input,
 267                                    cipher_tv[i].ilen);
 268
 269                         iv_len = crypto_blkcipher_ivsize(tfm);
 270                         if (iv_len)
 271                                 crypto_blkcipher_set_iv(tfm, cipher_tv[i].iv,
 272                                                         iv_len);
 273
 274                         len = cipher_tv[i].ilen;
 275                         ret = enc ?
 276                                 crypto_blkcipher_encrypt(&desc, sg, sg, len) :
 277                                 crypto_blkcipher_decrypt(&desc, sg, sg, len);
 278
 279                         if (ret) {
 280                                 printk("%s () failed flags=%x\n", e,
 281                                        desc.flags);
 282                                 goto out;
 283                         }
 284
 285                         q = kmap(sg[0].page) + sg[0].offset;
 286                         hexdump(q, cipher_tv[i].rlen);
 287
 288                         printk("%s\n",
 289                                memcmp(q, cipher_tv[i].result,
 290                                       cipher_tv[i].rlen) ? "fail" : "pass");
 291                 }
 292         }
 293
 294         printk("\ntesting %s %s across pages (chunking)\n", algo, e);
 295         memset(xbuf, 0, XBUFSIZE);
 296
 297         j = 0;
 298         for (i = 0; i < tcount; i++) {
 299                 if (cipher_tv[i].np) {
 300                         j++;
 301                         printk("test %u (%d bit key):\n",
 302                         j, cipher_tv[i].klen * 8);
 303
 304                         crypto_blkcipher_clear_flags(tfm, ~0);
 305                         if (cipher_tv[i].wk)
 306                                 crypto_blkcipher_set_flags(
 307                                         tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 308                         key = cipher_tv[i].key;
 309
 310                         ret = crypto_blkcipher_setkey(tfm, key,
 311                                                       cipher_tv[i].klen);
 312                         if (ret) {
 313                                 printk("setkey() failed flags=%x\n",
 314                                        crypto_blkcipher_get_flags(tfm));
 315
 316                                 if (!cipher_tv[i].fail)
 317                                         goto out;
 318                         }
 319
 320                         temp = 0;
 321                         for (k = 0; k < cipher_tv[i].np; k++) {
 322                                 memcpy(&xbuf[IDX[k]],
 323                                        cipher_tv[i].input + temp,
 324                                        cipher_tv[i].tap[k]);
 325                                 temp += cipher_tv[i].tap[k];
 326                                 sg_set_buf(&sg[k], &xbuf[IDX[k]],
 327                                            cipher_tv[i].tap[k]);
 328                         }
 329
 330                         iv_len = crypto_blkcipher_ivsize(tfm);
 331                         if (iv_len)
 332                                 crypto_blkcipher_set_iv(tfm, cipher_tv[i].iv,
 333                                                         iv_len);
 334
 335                         len = cipher_tv[i].ilen;
 336                         ret = enc ?
 337                                 crypto_blkcipher_encrypt(&desc, sg, sg, len) :
 338                                 crypto_blkcipher_decrypt(&desc, sg, sg, len);
 339
 340                         if (ret) {
 341                                 printk("%s () failed flags=%x\n", e,
 342                                        desc.flags);
 343                                 goto out;
 344                         }
 345
 346                         temp = 0;
 347                         for (k = 0; k < cipher_tv[i].np; k++) {
 348                                 printk("page %u\n", k);
 349                                 q = kmap(sg[k].page) + sg[k].offset;
 350                                 hexdump(q, cipher_tv[i].tap[k]);
 351                                 printk("%s\n",
 352                                         memcmp(q, cipher_tv[i].result + temp,
 353                                                 cipher_tv[i].tap[k]) ? "fail" :
 354                                         "pass");
 355                                 temp += cipher_tv[i].tap[k];
 356                         }
 357                 }
 358         }
 359
 360 out:
 361         crypto_free_blkcipher(tfm);
 362 }
 363
 364 static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc, char *p,
 365                                int blen, int sec)
 366 {
 367         struct scatterlist sg[1];
 368         unsigned long start, end;
 369         int bcount;
 370         int ret;
 371
 372         sg_set_buf(sg, p, blen);
 373
 374         for (start = jiffies, end = start + sec * HZ, bcount = 0;
 375              time_before(jiffies, end); bcount++) {
 376                 if (enc)
 377                         ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
 378                 else
 379                         ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
 380
 381                 if (ret)
 382                         return ret;
 383         }
 384
 385         printk("%d operations in %d seconds (%ld bytes)\n",
 386                bcount, sec, (long)bcount * blen);
 387         return 0;
 388 }
 389
 390 static int test_cipher_cycles(struct blkcipher_desc *desc, int enc, char *p,
 391                               int blen)
 392 {
 393         struct scatterlist sg[1];
 394         unsigned long cycles = 0;
 395         int ret = 0;
 396         int i;
 397
 398         sg_set_buf(sg, p, blen);
 399
 400         local_bh_disable();
 401         local_irq_disable();
 402
 403         /* Warm-up run. */
 404         for (i = 0; i < 4; i++) {
 405                 if (enc)
 406                         ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
 407                 else
 408                         ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
 409
 410                 if (ret)
 411                         goto out;
 412         }
 413
 414         /* The real thing. */
 415         for (i = 0; i < 8; i++) {
 416                 cycles_t start, end;
 417
 418                 start = get_cycles();
 419                 if (enc)
 420                         ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
 421                 else
 422                         ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
 423                 end = get_cycles();
 424
 425                 if (ret)
 426                         goto out;
 427
 428                 cycles += end - start;
 429         }
 430
 431 out:
 432         local_irq_enable();
 433         local_bh_enable();
 434
 435         if (ret == 0)
 436                 printk("1 operation in %lu cycles (%d bytes)\n",
 437                        (cycles + 4) / 8, blen);
 438
 439         return ret;
 440 }
 441
 442 static void test_cipher_speed(char *algo, int enc, unsigned int sec,
 443                               struct cipher_testvec *template,
 444                               unsigned int tcount, struct cipher_speed *speed)
 445 {
 446         unsigned int ret, i, j, iv_len;
 447         unsigned char *key, *p, iv[128];
 448         struct crypto_blkcipher *tfm;
 449         struct blkcipher_desc desc;
 450         const char *e;
 451
 452         if (enc == ENCRYPT)
 453                 e = "encryption";
 454         else
 455                 e = "decryption";
 456
 457         printk("\ntesting speed of %s %s\n", algo, e);
 458
 459         tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);
 460
 461         if (IS_ERR(tfm)) {
 462                 printk("failed to load transform for %s: %ld\n", algo,
 463                        PTR_ERR(tfm));
 464                 return;
 465         }
 466         desc.tfm = tfm;
 467         desc.flags = 0;
 468
 469         for (i = 0; speed[i].klen != 0; i++) {
 470                 if ((speed[i].blen + speed[i].klen) > TVMEMSIZE) {
 471                         printk("template (%u) too big for tvmem (%u)\n",
 472                                speed[i].blen + speed[i].klen, TVMEMSIZE);
 473                         goto out;
 474                 }
 475
 476                 printk("test %u (%d bit key, %d byte blocks): ", i,
 477                        speed[i].klen * 8, speed[i].blen);
 478
 479                 memset(tvmem, 0xff, speed[i].klen + speed[i].blen);
 480
 481                 /* set key, plain text and IV */
 482                 key = (unsigned char *)tvmem;
 483                 for (j = 0; j < tcount; j++) {
 484                         if (template[j].klen == speed[i].klen) {
 485                                 key = template[j].key;
 486                                 break;
 487                         }
 488                 }
 489                 p = (unsigned char *)tvmem + speed[i].klen;
 490
 491                 ret = crypto_blkcipher_setkey(tfm, key, speed[i].klen);
 492                 if (ret) {
 493                         printk("setkey() failed flags=%x\n",
 494                                crypto_blkcipher_get_flags(tfm));
 495                         goto out;
 496                 }
 497
 498                 iv_len = crypto_blkcipher_ivsize(tfm);
 499                 if (iv_len) {
 500                         memset(&iv, 0xff, iv_len);
 501                         crypto_blkcipher_set_iv(tfm, iv, iv_len);
 502                 }
 503
 504                 if (sec)
 505                         ret = test_cipher_jiffies(&desc, enc, p, speed[i].blen,
 506                                                   sec);
 507                 else
 508                         ret = test_cipher_cycles(&desc, enc, p, speed[i].blen);
 509
 510                 if (ret) {
 511                         printk("%s() failed flags=%x\n", e, desc.flags);
 512                         break;
 513                 }
 514         }
 515
 516 out:
 517         crypto_free_blkcipher(tfm);
 518 }
 519
 520 static int test_hash_jiffies_digest(struct hash_desc *desc, char *p, int blen,
 521                                     char *out, int sec)
 522 {
 523         struct scatterlist sg[1];
 524         unsigned long start, end;
 525         int bcount;
 526         int ret;
 527
 528         for (start = jiffies, end = start + sec * HZ, bcount = 0;
 529              time_before(jiffies, end); bcount++) {
 530                 sg_set_buf(sg, p, blen);
 531                 ret = crypto_hash_digest(desc, sg, blen, out);
 532                 if (ret)
 533                         return ret;
 534         }
 535
 536         printk("%6u opers/sec, %9lu bytes/sec\n",
 537                bcount / sec, ((long)bcount * blen) / sec);
 538
 539         return 0;
 540 }
 541
 542 static int test_hash_jiffies(struct hash_desc *desc, char *p, int blen,
 543                              int plen, char *out, int sec)
 544 {
 545         struct scatterlist sg[1];
 546         unsigned long start, end;
 547         int bcount, pcount;
 548         int ret;
 549
 550         if (plen == blen)
 551                 return test_hash_jiffies_digest(desc, p, blen, out, sec);
 552
 553         for (start = jiffies, end = start + sec * HZ, bcount = 0;
 554              time_before(jiffies, end); bcount++) {
 555                 ret = crypto_hash_init(desc);
 556                 if (ret)
 557                         return ret;
 558                 for (pcount = 0; pcount < blen; pcount += plen) {
 559                         sg_set_buf(sg, p + pcount, plen);
 560                         ret = crypto_hash_update(desc, sg, plen);
 561                         if (ret)
 562                                 return ret;
 563                 }
 564                 /* we assume there is enough space in 'out' for the result */
 565                 ret = crypto_hash_final(desc, out);
 566                 if (ret)
 567                         return ret;
 568         }
 569
 570         printk("%6u opers/sec, %9lu bytes/sec\n",
 571                bcount / sec, ((long)bcount * blen) / sec);
 572
 573         return 0;
 574 }
 575
 576 static int test_hash_cycles_digest(struct hash_desc *desc, char *p, int blen,
 577                                    char *out)
 578 {
 579         struct scatterlist sg[1];
 580         unsigned long cycles = 0;
 581         int i;
 582         int ret;
 583
 584         local_bh_disable();
 585         local_irq_disable();
 586
 587         /* Warm-up run. */
 588         for (i = 0; i < 4; i++) {
 589                 sg_set_buf(sg, p, blen);
 590                 ret = crypto_hash_digest(desc, sg, blen, out);
 591                 if (ret)
 592                         goto out;
 593         }
 594
 595         /* The real thing. */
 596         for (i = 0; i < 8; i++) {
 597                 cycles_t start, end;
 598
 599                 start = get_cycles();
 600
 601                 sg_set_buf(sg, p, blen);
 602                 ret = crypto_hash_digest(desc, sg, blen, out);
 603                 if (ret)
 604                         goto out;
 605
 606                 end = get_cycles();
 607
 608                 cycles += end - start;
 609         }
 610
 611 out:
 612         local_irq_enable();
 613         local_bh_enable();
 614
 615         if (ret)
 616                 return ret;
 617
 618         printk("%6lu cycles/operation, %4lu cycles/byte\n",
 619                cycles / 8, cycles / (8 * blen));
 620
 621         return 0;
 622 }
 623
 624 static int test_hash_cycles(struct hash_desc *desc, char *p, int blen,
 625                             int plen, char *out)
 626 {
 627         struct scatterlist sg[1];
 628         unsigned long cycles = 0;
 629         int i, pcount;
 630         int ret;
 631
 632         if (plen == blen)
 633                 return test_hash_cycles_digest(desc, p, blen, out);
 634
 635         local_bh_disable();
 636         local_irq_disable();
 637
 638         /* Warm-up run. */
 639         for (i = 0; i < 4; i++) {
 640                 ret = crypto_hash_init(desc);
 641                 if (ret)
 642                         goto out;
 643                 for (pcount = 0; pcount < blen; pcount += plen) {
 644                         sg_set_buf(sg, p + pcount, plen);
 645                         ret = crypto_hash_update(desc, sg, plen);
 646                         if (ret)
 647                                 goto out;
 648                 }
 649                 crypto_hash_final(desc, out);
 650                 if (ret)
 651                         goto out;
 652         }
 653
 654         /* The real thing. */
 655         for (i = 0; i < 8; i++) {
 656                 cycles_t start, end;
 657
 658                 start = get_cycles();
 659
 660                 ret = crypto_hash_init(desc);
 661                 if (ret)
 662                         goto out;
 663                 for (pcount = 0; pcount < blen; pcount += plen) {
 664                         sg_set_buf(sg, p + pcount, plen);
 665                         ret = crypto_hash_update(desc, sg, plen);
 666                         if (ret)
 667                                 goto out;
 668                 }
 669                 ret = crypto_hash_final(desc, out);
 670                 if (ret)
 671                         goto out;
 672
 673                 end = get_cycles();
 674
 675                 cycles += end - start;
 676         }
 677
 678 out:
 679         local_irq_enable();
 680         local_bh_enable();
 681
 682         if (ret)
 683                 return ret;
 684
 685         printk("%6lu cycles/operation, %4lu cycles/byte\n",
 686                cycles / 8, cycles / (8 * blen));
 687
 688         return 0;
 689 }
 690
 691 static void test_hash_speed(char *algo, unsigned int sec,
 692                               struct hash_speed *speed)
 693 {
 694         struct crypto_hash *tfm;
 695         struct hash_desc desc;
 696         char output[1024];
 697         int i;
 698         int ret;
 699
 700         printk("\ntesting speed of %s\n", algo);
 701
 702         tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
 703
 704         if (IS_ERR(tfm)) {
 705                 printk("failed to load transform for %s: %ld\n", algo,
 706                        PTR_ERR(tfm));
 707                 return;
 708         }
 709
 710         desc.tfm = tfm;
 711         desc.flags = 0;
 712
 713         if (crypto_hash_digestsize(tfm) > sizeof(output)) {
 714                 printk("digestsize(%u) > outputbuffer(%zu)\n",
 715                        crypto_hash_digestsize(tfm), sizeof(output));
 716                 goto out;
 717         }
 718
 719         for (i = 0; speed[i].blen != 0; i++) {
 720                 if (speed[i].blen > TVMEMSIZE) {
 721                         printk("template (%u) too big for tvmem (%u)\n",
 722                                speed[i].blen, TVMEMSIZE);
 723                         goto out;
 724                 }
 725
 726                 printk("test%3u (%5u byte blocks,%5u bytes per update,%4u updates): ",
 727                        i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
 728
 729                 memset(tvmem, 0xff, speed[i].blen);
 730
 731                 if (sec)
 732                         ret = test_hash_jiffies(&desc, tvmem, speed[i].blen,
 733                                                 speed[i].plen, output, sec);
 734                 else
 735                         ret = test_hash_cycles(&desc, tvmem, speed[i].blen,
 736                                                speed[i].plen, output);
 737
 738                 if (ret) {
 739                         printk("hashing failed ret=%d\n", ret);
 740                         break;
 741                 }
 742         }
 743
 744 out:
 745         crypto_free_hash(tfm);
 746 }
 747
 748 static void test_deflate(void)
 749 {
 750         unsigned int i;
 751         char result[COMP_BUF_SIZE];
 752         struct crypto_comp *tfm;
 753         struct comp_testvec *tv;
 754         unsigned int tsize;
 755
 756         printk("\ntesting deflate compression\n");
 757
 758         tsize = sizeof (deflate_comp_tv_template);
 759         if (tsize > TVMEMSIZE) {
 760                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 761                        TVMEMSIZE);
 762                 return;
 763         }
 764
 765         memcpy(tvmem, deflate_comp_tv_template, tsize);
 766         tv = (void *)tvmem;
 767
 768         tfm = crypto_alloc_tfm("deflate", 0);
 769         if (tfm == NULL) {
 770                 printk("failed to load transform for deflate\n");
 771                 return;
 772         }
 773
 774         for (i = 0; i < DEFLATE_COMP_TEST_VECTORS; i++) {
 775                 int ilen, ret, dlen = COMP_BUF_SIZE;
 776
 777                 printk("test %u:\n", i + 1);
 778                 memset(result, 0, sizeof (result));
 779
 780                 ilen = tv[i].inlen;
 781                 ret = crypto_comp_compress(tfm, tv[i].input,
 782                                            ilen, result, &dlen);
 783                 if (ret) {
 784                         printk("fail: ret=%d\n", ret);
 785                         continue;
 786                 }
 787                 hexdump(result, dlen);
 788                 printk("%s (ratio %d:%d)\n",
 789                        memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
 790                        ilen, dlen);
 791         }
 792
 793         printk("\ntesting deflate decompression\n");
 794
 795         tsize = sizeof (deflate_decomp_tv_template);
 796         if (tsize > TVMEMSIZE) {
 797                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 798                        TVMEMSIZE);
 799                 goto out;
 800         }
 801
 802         memcpy(tvmem, deflate_decomp_tv_template, tsize);
 803         tv = (void *)tvmem;
 804
 805         for (i = 0; i < DEFLATE_DECOMP_TEST_VECTORS; i++) {
 806                 int ilen, ret, dlen = COMP_BUF_SIZE;
 807
 808                 printk("test %u:\n", i + 1);
 809                 memset(result, 0, sizeof (result));
 810
 811                 ilen = tv[i].inlen;
 812                 ret = crypto_comp_decompress(tfm, tv[i].input,
 813                                              ilen, result, &dlen);
 814                 if (ret) {
 815                         printk("fail: ret=%d\n", ret);
 816                         continue;
 817                 }
 818                 hexdump(result, dlen);
 819                 printk("%s (ratio %d:%d)\n",
 820                        memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
 821                        ilen, dlen);
 822         }
 823 out:
 824         crypto_free_comp(tfm);
 825 }
 826
 827 static void test_available(void)
 828 {
 829         char **name = check;
 830
 831         while (*name) {
 832                 printk("alg %s ", *name);
 833                 printk(crypto_has_alg(*name, 0, CRYPTO_ALG_ASYNC) ?
 834                        "found\n" : "not found\n");
 835                 name++;
 836         }
 837 }
 838
 839 static void do_test(void)
 840 {
 841         switch (mode) {
 842
 843         case 0:
 844                 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
 845
 846                 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
 847
 848                 //DES
 849                 test_cipher("ecb(des)", ENCRYPT, des_enc_tv_template,
 850                             DES_ENC_TEST_VECTORS);
 851                 test_cipher("ecb(des)", DECRYPT, des_dec_tv_template,
 852                             DES_DEC_TEST_VECTORS);
 853                 test_cipher("cbc(des)", ENCRYPT, des_cbc_enc_tv_template,
 854                             DES_CBC_ENC_TEST_VECTORS);
 855                 test_cipher("cbc(des)", DECRYPT, des_cbc_dec_tv_template,
 856                             DES_CBC_DEC_TEST_VECTORS);
 857
 858                 //DES3_EDE
 859                 test_cipher("ecb(des3_ede)", ENCRYPT, des3_ede_enc_tv_template,
 860                             DES3_EDE_ENC_TEST_VECTORS);
 861                 test_cipher("ecb(des3_ede)", DECRYPT, des3_ede_dec_tv_template,
 862                             DES3_EDE_DEC_TEST_VECTORS);
 863
 864                 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
 865
 866                 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
 867
 868                 //BLOWFISH
 869                 test_cipher("ecb(blowfish)", ENCRYPT, bf_enc_tv_template,
 870                             BF_ENC_TEST_VECTORS);
 871                 test_cipher("ecb(blowfish)", DECRYPT, bf_dec_tv_template,
 872                             BF_DEC_TEST_VECTORS);
 873                 test_cipher("cbc(blowfish)", ENCRYPT, bf_cbc_enc_tv_template,
 874                             BF_CBC_ENC_TEST_VECTORS);
 875                 test_cipher("cbc(blowfish)", DECRYPT, bf_cbc_dec_tv_template,
 876                             BF_CBC_DEC_TEST_VECTORS);
 877
 878                 //TWOFISH
 879                 test_cipher("ecb(twofish)", ENCRYPT, tf_enc_tv_template,
 880                             TF_ENC_TEST_VECTORS);
 881                 test_cipher("ecb(twofish)", DECRYPT, tf_dec_tv_template,
 882                             TF_DEC_TEST_VECTORS);
 883                 test_cipher("cbc(twofish)", ENCRYPT, tf_cbc_enc_tv_template,
 884                             TF_CBC_ENC_TEST_VECTORS);
 885                 test_cipher("cbc(twofish)", DECRYPT, tf_cbc_dec_tv_template,
 886                             TF_CBC_DEC_TEST_VECTORS);
 887
 888                 //SERPENT
 889                 test_cipher("ecb(serpent)", ENCRYPT, serpent_enc_tv_template,
 890                             SERPENT_ENC_TEST_VECTORS);
 891                 test_cipher("ecb(serpent)", DECRYPT, serpent_dec_tv_template,
 892                             SERPENT_DEC_TEST_VECTORS);
 893
 894                 //TNEPRES
 895                 test_cipher("ecb(tnepres)", ENCRYPT, tnepres_enc_tv_template,
 896                             TNEPRES_ENC_TEST_VECTORS);
 897                 test_cipher("ecb(tnepres)", DECRYPT, tnepres_dec_tv_template,
 898                             TNEPRES_DEC_TEST_VECTORS);
 899
 900                 //AES
 901                 test_cipher("ecb(aes)", ENCRYPT, aes_enc_tv_template,
 902                             AES_ENC_TEST_VECTORS);
 903                 test_cipher("ecb(aes)", DECRYPT, aes_dec_tv_template,
 904                             AES_DEC_TEST_VECTORS);
 905                 test_cipher("cbc(aes)", ENCRYPT, aes_cbc_enc_tv_template,
 906                             AES_CBC_ENC_TEST_VECTORS);
 907                 test_cipher("cbc(aes)", DECRYPT, aes_cbc_dec_tv_template,
 908                             AES_CBC_DEC_TEST_VECTORS);
 909
 910                 //CAST5
 911                 test_cipher("ecb(cast5)", ENCRYPT, cast5_enc_tv_template,
 912                             CAST5_ENC_TEST_VECTORS);
 913                 test_cipher("ecb(cast5)", DECRYPT, cast5_dec_tv_template,
 914                             CAST5_DEC_TEST_VECTORS);
 915
 916                 //CAST6
 917                 test_cipher("ecb(cast6)", ENCRYPT, cast6_enc_tv_template,
 918                             CAST6_ENC_TEST_VECTORS);
 919                 test_cipher("ecb(cast6)", DECRYPT, cast6_dec_tv_template,
 920                             CAST6_DEC_TEST_VECTORS);
 921
 922                 //ARC4
 923                 test_cipher("ecb(arc4)", ENCRYPT, arc4_enc_tv_template,
 924                             ARC4_ENC_TEST_VECTORS);
 925                 test_cipher("ecb(arc4)", DECRYPT, arc4_dec_tv_template,
 926                             ARC4_DEC_TEST_VECTORS);
 927
 928                 //TEA
 929                 test_cipher("ecb(tea)", ENCRYPT, tea_enc_tv_template,
 930                             TEA_ENC_TEST_VECTORS);
 931                 test_cipher("ecb(tea)", DECRYPT, tea_dec_tv_template,
 932                             TEA_DEC_TEST_VECTORS);
 933
 934
 935                 //XTEA
 936                 test_cipher("ecb(xtea)", ENCRYPT, xtea_enc_tv_template,
 937                             XTEA_ENC_TEST_VECTORS);
 938                 test_cipher("ecb(xtea)", DECRYPT, xtea_dec_tv_template,
 939                             XTEA_DEC_TEST_VECTORS);
 940
 941                 //KHAZAD
 942                 test_cipher("ecb(khazad)", ENCRYPT, khazad_enc_tv_template,
 943                             KHAZAD_ENC_TEST_VECTORS);
 944                 test_cipher("ecb(khazad)", DECRYPT, khazad_dec_tv_template,
 945                             KHAZAD_DEC_TEST_VECTORS);
 946
 947                 //ANUBIS
 948                 test_cipher("ecb(anubis)", ENCRYPT, anubis_enc_tv_template,
 949                             ANUBIS_ENC_TEST_VECTORS);
 950                 test_cipher("ecb(anubis)", DECRYPT, anubis_dec_tv_template,
 951                             ANUBIS_DEC_TEST_VECTORS);
 952                 test_cipher("cbc(anubis)", ENCRYPT, anubis_cbc_enc_tv_template,
 953                             ANUBIS_CBC_ENC_TEST_VECTORS);
 954                 test_cipher("cbc(anubis)", DECRYPT, anubis_cbc_dec_tv_template,
 955                             ANUBIS_CBC_ENC_TEST_VECTORS);
 956
 957                 //XETA
 958                 test_cipher("ecb(xeta)", ENCRYPT, xeta_enc_tv_template,
 959                             XETA_ENC_TEST_VECTORS);
 960                 test_cipher("ecb(xeta)", DECRYPT, xeta_dec_tv_template,
 961                             XETA_DEC_TEST_VECTORS);
 962
 963                 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
 964                 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
 965                 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
 966                 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
 967                 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
 968                 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
 969                 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
 970                 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
 971                 test_deflate();
 972                 test_hash("crc32c", crc32c_tv_template, CRC32C_TEST_VECTORS);
 973                 test_hash("hmac(md5)", hmac_md5_tv_template,
 974                           HMAC_MD5_TEST_VECTORS);
 975                 test_hash("hmac(sha1)", hmac_sha1_tv_template,
 976                           HMAC_SHA1_TEST_VECTORS);
 977                 test_hash("hmac(sha256)", hmac_sha256_tv_template,
 978                           HMAC_SHA256_TEST_VECTORS);
 979
 980                 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
 981                 break;
 982
 983         case 1:
 984                 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
 985                 break;
 986
 987         case 2:
 988                 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
 989                 break;
 990
 991         case 3:
 992                 test_cipher("ecb(des)", ENCRYPT, des_enc_tv_template,
 993                             DES_ENC_TEST_VECTORS);
 994                 test_cipher("ecb(des)", DECRYPT, des_dec_tv_template,
 995                             DES_DEC_TEST_VECTORS);
 996                 test_cipher("cbc(des)", ENCRYPT, des_cbc_enc_tv_template,
 997                             DES_CBC_ENC_TEST_VECTORS);
 998                 test_cipher("cbc(des)", DECRYPT, des_cbc_dec_tv_template,
 999                             DES_CBC_DEC_TEST_VECTORS);
1000                 break;
1001
1002         case 4:
1003                 test_cipher("ecb(des3_ede)", ENCRYPT, des3_ede_enc_tv_template,
1004                             DES3_EDE_ENC_TEST_VECTORS);
1005                 test_cipher("ecb(des3_ede)", DECRYPT, des3_ede_dec_tv_template,
1006                             DES3_EDE_DEC_TEST_VECTORS);
1007                 break;
1008
1009         case 5:
1010                 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
1011                 break;
1012
1013         case 6:
1014                 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
1015                 break;
1016
1017         case 7:
1018                 test_cipher("ecb(blowfish)", ENCRYPT, bf_enc_tv_template,
1019                             BF_ENC_TEST_VECTORS);
1020                 test_cipher("ecb(blowfish)", DECRYPT, bf_dec_tv_template,
1021                             BF_DEC_TEST_VECTORS);
1022                 test_cipher("cbc(blowfish)", ENCRYPT, bf_cbc_enc_tv_template,
1023                             BF_CBC_ENC_TEST_VECTORS);
1024                 test_cipher("cbc(blowfish)", DECRYPT, bf_cbc_dec_tv_template,
1025                             BF_CBC_DEC_TEST_VECTORS);
1026                 break;
1027
1028         case 8:
1029                 test_cipher("ecb(twofish)", ENCRYPT, tf_enc_tv_template,
1030                             TF_ENC_TEST_VECTORS);
1031                 test_cipher("ecb(twofish)", DECRYPT, tf_dec_tv_template,
1032                             TF_DEC_TEST_VECTORS);
1033                 test_cipher("cbc(twofish)", ENCRYPT, tf_cbc_enc_tv_template,
1034                             TF_CBC_ENC_TEST_VECTORS);
1035                 test_cipher("cbc(twofish)", DECRYPT, tf_cbc_dec_tv_template,
1036                             TF_CBC_DEC_TEST_VECTORS);
1037                 break;
1038
1039         case 9:
1040                 test_cipher("ecb(serpent)", ENCRYPT, serpent_enc_tv_template,
1041                             SERPENT_ENC_TEST_VECTORS);
1042                 test_cipher("ecb(serpent)", DECRYPT, serpent_dec_tv_template,
1043                             SERPENT_DEC_TEST_VECTORS);
1044                 break;
1045
1046         case 10:
1047                 test_cipher("ecb(aes)", ENCRYPT, aes_enc_tv_template,
1048                             AES_ENC_TEST_VECTORS);
1049                 test_cipher("ecb(aes)", DECRYPT, aes_dec_tv_template,
1050                             AES_DEC_TEST_VECTORS);
1051                 test_cipher("cbc(aes)", ENCRYPT, aes_cbc_enc_tv_template,
1052                             AES_CBC_ENC_TEST_VECTORS);
1053                 test_cipher("cbc(aes)", DECRYPT, aes_cbc_dec_tv_template,
1054                             AES_CBC_DEC_TEST_VECTORS);
1055                 break;
1056
1057         case 11:
1058                 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
1059                 break;
1060
1061         case 12:
1062                 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
1063                 break;
1064
1065         case 13:
1066                 test_deflate();
1067                 break;
1068
1069         case 14:
1070                 test_cipher("ecb(cast5)", ENCRYPT, cast5_enc_tv_template,
1071                             CAST5_ENC_TEST_VECTORS);
1072                 test_cipher("ecb(cast5)", DECRYPT, cast5_dec_tv_template,
1073                             CAST5_DEC_TEST_VECTORS);
1074                 break;
1075
1076         case 15:
1077                 test_cipher("ecb(cast6)", ENCRYPT, cast6_enc_tv_template,
1078                             CAST6_ENC_TEST_VECTORS);
1079                 test_cipher("ecb(cast6)", DECRYPT, cast6_dec_tv_template,
1080                             CAST6_DEC_TEST_VECTORS);
1081                 break;
1082
1083         case 16:
1084                 test_cipher("ecb(arc4)", ENCRYPT, arc4_enc_tv_template,
1085                             ARC4_ENC_TEST_VECTORS);
1086                 test_cipher("ecb(arc4)", DECRYPT, arc4_dec_tv_template,
1087                             ARC4_DEC_TEST_VECTORS);
1088                 break;
1089
1090         case 17:
1091                 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
1092                 break;
1093
1094         case 18:
1095                 test_hash("crc32c", crc32c_tv_template, CRC32C_TEST_VECTORS);
1096                 break;
1097
1098         case 19:
1099                 test_cipher("ecb(tea)", ENCRYPT, tea_enc_tv_template,
1100                             TEA_ENC_TEST_VECTORS);
1101                 test_cipher("ecb(tea)", DECRYPT, tea_dec_tv_template,
1102                             TEA_DEC_TEST_VECTORS);
1103                 break;
1104
1105         case 20:
1106                 test_cipher("ecb(xtea)", ENCRYPT, xtea_enc_tv_template,
1107                             XTEA_ENC_TEST_VECTORS);
1108                 test_cipher("ecb(xtea)", DECRYPT, xtea_dec_tv_template,
1109                             XTEA_DEC_TEST_VECTORS);
1110                 break;
1111
1112         case 21:
1113                 test_cipher("ecb(khazad)", ENCRYPT, khazad_enc_tv_template,
1114                             KHAZAD_ENC_TEST_VECTORS);
1115                 test_cipher("ecb(khazad)", DECRYPT, khazad_dec_tv_template,
1116                             KHAZAD_DEC_TEST_VECTORS);
1117                 break;
1118
1119         case 22:
1120                 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
1121                 break;
1122
1123         case 23:
1124                 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
1125                 break;
1126
1127         case 24:
1128                 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
1129                 break;
1130
1131         case 25:
1132                 test_cipher("ecb(tnepres)", ENCRYPT, tnepres_enc_tv_template,
1133                             TNEPRES_ENC_TEST_VECTORS);
1134                 test_cipher("ecb(tnepres)", DECRYPT, tnepres_dec_tv_template,
1135                             TNEPRES_DEC_TEST_VECTORS);
1136                 break;
1137
1138         case 26:
1139                 test_cipher("ecb(anubis)", ENCRYPT, anubis_enc_tv_template,
1140                             ANUBIS_ENC_TEST_VECTORS);
1141                 test_cipher("ecb(anubis)", DECRYPT, anubis_dec_tv_template,
1142                             ANUBIS_DEC_TEST_VECTORS);
1143                 test_cipher("cbc(anubis)", ENCRYPT, anubis_cbc_enc_tv_template,
1144                             ANUBIS_CBC_ENC_TEST_VECTORS);
1145                 test_cipher("cbc(anubis)", DECRYPT, anubis_cbc_dec_tv_template,
1146                             ANUBIS_CBC_ENC_TEST_VECTORS);
1147                 break;
1148
1149         case 27:
1150                 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
1151                 break;
1152
1153         case 28:
1154
1155                 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
1156                 break;
1157
1158         case 29:
1159                 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
1160                 break;
1161
1162         case 30:
1163                 test_cipher("ecb(xeta)", ENCRYPT, xeta_enc_tv_template,
1164                             XETA_ENC_TEST_VECTORS);
1165                 test_cipher("ecb(xeta)", DECRYPT, xeta_dec_tv_template,
1166                             XETA_DEC_TEST_VECTORS);
1167                 break;
1168
1169         case 100:
1170                 test_hash("hmac(md5)", hmac_md5_tv_template,
1171                           HMAC_MD5_TEST_VECTORS);
1172                 break;
1173
1174         case 101:
1175                 test_hash("hmac(sha1)", hmac_sha1_tv_template,
1176                           HMAC_SHA1_TEST_VECTORS);
1177                 break;
1178
1179         case 102:
1180                 test_hash("hmac(sha256)", hmac_sha256_tv_template,
1181                           HMAC_SHA256_TEST_VECTORS);
1182                 break;
1183
1184
1185         case 200:
1186                 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
1187                                   aes_speed_template);
1188                 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
1189                                   aes_speed_template);
1190                 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
1191                                   aes_speed_template);
1192                 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
1193                                   aes_speed_template);
1194                 break;
1195
1196         case 201:
1197                 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
1198                                   des3_ede_enc_tv_template,
1199                                   DES3_EDE_ENC_TEST_VECTORS,
1200                                   des3_ede_speed_template);
1201                 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
1202                                   des3_ede_dec_tv_template,
1203                                   DES3_EDE_DEC_TEST_VECTORS,
1204                                   des3_ede_speed_template);
1205                 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
1206                                   des3_ede_enc_tv_template,
1207                                   DES3_EDE_ENC_TEST_VECTORS,
1208                                   des3_ede_speed_template);
1209                 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
1210                                   des3_ede_dec_tv_template,
1211                                   DES3_EDE_DEC_TEST_VECTORS,
1212                                   des3_ede_speed_template);
1213                 break;
1214
1215         case 202:
1216                 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
1217                                   twofish_speed_template);
1218                 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
1219                                   twofish_speed_template);
1220                 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
1221                                   twofish_speed_template);
1222                 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
1223                                   twofish_speed_template);
1224                 break;
1225
1226         case 203:
1227                 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
1228                                   blowfish_speed_template);
1229                 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
1230                                   blowfish_speed_template);
1231                 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
1232                                   blowfish_speed_template);
1233                 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
1234                                   blowfish_speed_template);
1235                 break;
1236
1237         case 204:
1238                 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
1239                                   des_speed_template);
1240                 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
1241                                   des_speed_template);
1242                 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
1243                                   des_speed_template);
1244                 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
1245                                   des_speed_template);
1246                 break;
1247
1248         case 300:
1249                 /* fall through */
1250
1251         case 301:
1252                 test_hash_speed("md4", sec, generic_hash_speed_template);
1253                 if (mode > 300 && mode < 400) break;
1254
1255         case 302:
1256                 test_hash_speed("md5", sec, generic_hash_speed_template);
1257                 if (mode > 300 && mode < 400) break;
1258
1259         case 303:
1260                 test_hash_speed("sha1", sec, generic_hash_speed_template);
1261                 if (mode > 300 && mode < 400) break;
1262
1263         case 304:
1264                 test_hash_speed("sha256", sec, generic_hash_speed_template);
1265                 if (mode > 300 && mode < 400) break;
1266
1267         case 305:
1268                 test_hash_speed("sha384", sec, generic_hash_speed_template);
1269                 if (mode > 300 && mode < 400) break;
1270
1271         case 306:
1272                 test_hash_speed("sha512", sec, generic_hash_speed_template);
1273                 if (mode > 300 && mode < 400) break;
1274
1275         case 307:
1276                 test_hash_speed("wp256", sec, generic_hash_speed_template);
1277                 if (mode > 300 && mode < 400) break;
1278
1279         case 308:
1280                 test_hash_speed("wp384", sec, generic_hash_speed_template);
1281                 if (mode > 300 && mode < 400) break;
1282
1283         case 309:
1284                 test_hash_speed("wp512", sec, generic_hash_speed_template);
1285                 if (mode > 300 && mode < 400) break;
1286
1287         case 310:
1288                 test_hash_speed("tgr128", sec, generic_hash_speed_template);
1289                 if (mode > 300 && mode < 400) break;
1290
1291         case 311:
1292                 test_hash_speed("tgr160", sec, generic_hash_speed_template);
1293                 if (mode > 300 && mode < 400) break;
1294
1295         case 312:
1296                 test_hash_speed("tgr192", sec, generic_hash_speed_template);
1297                 if (mode > 300 && mode < 400) break;
1298
1299         case 399:
1300                 break;
1301
1302         case 1000:
1303                 test_available();
1304                 break;
1305
1306         default:
1307                 /* useful for debugging */
1308                 printk("not testing anything\n");
1309                 break;
1310         }
1311 }
1312
1313 static int __init init(void)
1314 {
1315         tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL);
1316         if (tvmem == NULL)
1317                 return -ENOMEM;
1318
1319         xbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
1320         if (xbuf == NULL) {
1321                 kfree(tvmem);
1322                 return -ENOMEM;
1323         }
1324
1325         do_test();
1326
1327         kfree(xbuf);
1328         kfree(tvmem);
1329
1330         /* We intentionaly return -EAGAIN to prevent keeping
1331          * the module. It does all its work from init()
1332          * and doesn't offer any runtime functionality
1333          * => we don't need it in the memory, do we?
1334          *                                        -- mludvig
1335          */
1336         return -EAGAIN;
1337 }
1338
1339 /*
1340  * If an init function is provided, an exit function must also be provided
1341  * to allow module unload.
1342  */
1343 static void __exit fini(void) { }
1344
1345 module_init(init);
1346 module_exit(fini);
1347
1348 module_param(mode, int, 0);
1349 module_param(sec, uint, 0);
1350 MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
1351                       "(defaults to zero which uses CPU cycles instead)");
1352
1353 MODULE_LICENSE("GPL");
1354 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
1355 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");