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/init.h>
  21 #include <linux/module.h>
  22 #include <linux/mm.h>
  23 #include <linux/slab.h>
  24 #include <linux/scatterlist.h>
  25 #include <linux/string.h>
  26 #include <linux/crypto.h>
  27 #include <linux/highmem.h>
  28 #include <linux/moduleparam.h>
  29 #include <linux/jiffies.h>
  30 #include <linux/timex.h>
  31 #include <linux/interrupt.h>
  32 #include "tcrypt.h"
  33
  34 /*
  35  * Need to kmalloc() memory for testing kmap().
  36  */
  37 #define TVMEMSIZE       16384
  38 #define XBUFSIZE        32768
  39
  40 /*
  41  * Indexes into the xbuf to simulate cross-page access.
  42  */
  43 #define IDX1            37
  44 #define IDX2            32400
  45 #define IDX3            1
  46 #define IDX4            8193
  47 #define IDX5            22222
  48 #define IDX6            17101
  49 #define IDX7            27333
  50 #define IDX8            3000
  51
  52 /*
  53 * Used by test_cipher()
  54 */
  55 #define ENCRYPT 1
  56 #define DECRYPT 0
  57 #define MODE_ECB 1
  58 #define MODE_CBC 0
  59
  60 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
  61
  62 /*
  63  * Used by test_cipher_speed()
  64  */
  65 static unsigned int sec;
  66
  67 static int mode;
  68 static char *xbuf;
  69 static char *tvmem;
  70
  71 static char *check[] = {
  72         "des", "md5", "des3_ede", "rot13", "sha1", "sha256", "blowfish",
  73         "twofish", "serpent", "sha384", "sha512", "md4", "aes", "cast6",
  74         "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
  75         "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", NULL
  76 };
  77
  78 static void hexdump(unsigned char *buf, unsigned int len)
  79 {
  80         while (len--)
  81                 printk("%02x", *buf++);
  82
  83         printk("\n");
  84 }
  85
  86 static void test_hash(char *algo, struct hash_testvec *template,
  87                       unsigned int tcount)
  88 {
  89         unsigned int i, j, k, temp;
  90         struct scatterlist sg[8];
  91         char result[64];
  92         struct crypto_tfm *tfm;
  93         struct hash_testvec *hash_tv;
  94         unsigned int tsize;
  95
  96         printk("\ntesting %s\n", algo);
  97
  98         tsize = sizeof(struct hash_testvec);
  99         tsize *= tcount;
 100
 101         if (tsize > TVMEMSIZE) {
 102                 printk("template (%u) too big for tvmem (%u)\n", tsize, TVMEMSIZE);
 103                 return;
 104         }
 105
 106         memcpy(tvmem, template, tsize);
 107         hash_tv = (void *)tvmem;
 108         tfm = crypto_alloc_tfm(algo, 0);
 109         if (tfm == NULL) {
 110                 printk("failed to load transform for %s\n", algo);
 111                 return;
 112         }
 113
 114         for (i = 0; i < tcount; i++) {
 115                 printk("test %u:\n", i + 1);
 116                 memset(result, 0, 64);
 117
 118                 sg_set_buf(&sg[0], hash_tv[i].plaintext, hash_tv[i].psize);
 119
 120                 crypto_digest_init(tfm);
 121                 if (tfm->crt_u.digest.dit_setkey) {
 122                         crypto_digest_setkey(tfm, hash_tv[i].key,
 123                                              hash_tv[i].ksize);
 124                 }
 125                 crypto_digest_update(tfm, sg, 1);
 126                 crypto_digest_final(tfm, result);
 127
 128                 hexdump(result, crypto_tfm_alg_digestsize(tfm));
 129                 printk("%s\n",
 130                        memcmp(result, hash_tv[i].digest,
 131                               crypto_tfm_alg_digestsize(tfm)) ?
 132                        "fail" : "pass");
 133         }
 134
 135         printk("testing %s across pages\n", algo);
 136
 137         /* setup the dummy buffer first */
 138         memset(xbuf, 0, XBUFSIZE);
 139
 140         j = 0;
 141         for (i = 0; i < tcount; i++) {
 142                 if (hash_tv[i].np) {
 143                         j++;
 144                         printk("test %u:\n", j);
 145                         memset(result, 0, 64);
 146
 147                         temp = 0;
 148                         for (k = 0; k < hash_tv[i].np; k++) {
 149                                 memcpy(&xbuf[IDX[k]],
 150                                        hash_tv[i].plaintext + temp,
 151                                        hash_tv[i].tap[k]);
 152                                 temp += hash_tv[i].tap[k];
 153                                 sg_set_buf(&sg[k], &xbuf[IDX[k]],
 154                                             hash_tv[i].tap[k]);
 155                         }
 156
 157                         crypto_digest_digest(tfm, sg, hash_tv[i].np, result);
 158
 159                         hexdump(result, crypto_tfm_alg_digestsize(tfm));
 160                         printk("%s\n",
 161                                memcmp(result, hash_tv[i].digest,
 162                                       crypto_tfm_alg_digestsize(tfm)) ?
 163                                "fail" : "pass");
 164                 }
 165         }
 166
 167         crypto_free_tfm(tfm);
 168 }
 169
 170
 171 #ifdef CONFIG_CRYPTO_HMAC
 172
 173 static void test_hmac(char *algo, struct hmac_testvec *template,
 174                       unsigned int tcount)
 175 {
 176         unsigned int i, j, k, temp;
 177         struct scatterlist sg[8];
 178         char result[64];
 179         struct crypto_tfm *tfm;
 180         struct hmac_testvec *hmac_tv;
 181         unsigned int tsize, klen;
 182
 183         tfm = crypto_alloc_tfm(algo, 0);
 184         if (tfm == NULL) {
 185                 printk("failed to load transform for %s\n", algo);
 186                 return;
 187         }
 188
 189         printk("\ntesting hmac_%s\n", algo);
 190
 191         tsize = sizeof(struct hmac_testvec);
 192         tsize *= tcount;
 193         if (tsize > TVMEMSIZE) {
 194                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 195                        TVMEMSIZE);
 196                 goto out;
 197         }
 198
 199         memcpy(tvmem, template, tsize);
 200         hmac_tv = (void *)tvmem;
 201
 202         for (i = 0; i < tcount; i++) {
 203                 printk("test %u:\n", i + 1);
 204                 memset(result, 0, sizeof (result));
 205
 206                 klen = hmac_tv[i].ksize;
 207                 sg_set_buf(&sg[0], hmac_tv[i].plaintext, hmac_tv[i].psize);
 208
 209                 crypto_hmac(tfm, hmac_tv[i].key, &klen, sg, 1, result);
 210
 211                 hexdump(result, crypto_tfm_alg_digestsize(tfm));
 212                 printk("%s\n",
 213                        memcmp(result, hmac_tv[i].digest,
 214                               crypto_tfm_alg_digestsize(tfm)) ? "fail" :
 215                        "pass");
 216         }
 217
 218         printk("\ntesting hmac_%s across pages\n", algo);
 219
 220         memset(xbuf, 0, XBUFSIZE);
 221
 222         j = 0;
 223         for (i = 0; i < tcount; i++) {
 224                 if (hmac_tv[i].np) {
 225                         j++;
 226                         printk("test %u:\n",j);
 227                         memset(result, 0, 64);
 228
 229                         temp = 0;
 230                         klen = hmac_tv[i].ksize;
 231                         for (k = 0; k < hmac_tv[i].np; k++) {
 232                                 memcpy(&xbuf[IDX[k]],
 233                                        hmac_tv[i].plaintext + temp,
 234                                        hmac_tv[i].tap[k]);
 235                                 temp += hmac_tv[i].tap[k];
 236                                 sg_set_buf(&sg[k], &xbuf[IDX[k]],
 237                                             hmac_tv[i].tap[k]);
 238                         }
 239
 240                         crypto_hmac(tfm, hmac_tv[i].key, &klen, sg,
 241                                     hmac_tv[i].np, result);
 242                         hexdump(result, crypto_tfm_alg_digestsize(tfm));
 243
 244                         printk("%s\n",
 245                                memcmp(result, hmac_tv[i].digest,
 246                                       crypto_tfm_alg_digestsize(tfm)) ?
 247                                "fail" : "pass");
 248                 }
 249         }
 250 out:
 251         crypto_free_tfm(tfm);
 252 }
 253
 254 #endif  /* CONFIG_CRYPTO_HMAC */
 255
 256 static void test_cipher(char *algo, int mode, int enc,
 257                         struct cipher_testvec *template, unsigned int tcount)
 258 {
 259         unsigned int ret, i, j, k, temp;
 260         unsigned int tsize;
 261         char *q;
 262         struct crypto_tfm *tfm;
 263         char *key;
 264         struct cipher_testvec *cipher_tv;
 265         struct scatterlist sg[8];
 266         const char *e, *m;
 267
 268         if (enc == ENCRYPT)
 269                 e = "encryption";
 270         else
 271                 e = "decryption";
 272         if (mode == MODE_ECB)
 273                 m = "ECB";
 274         else
 275                 m = "CBC";
 276
 277         printk("\ntesting %s %s %s\n", algo, m, e);
 278
 279         tsize = sizeof (struct cipher_testvec);
 280         tsize *= tcount;
 281
 282         if (tsize > TVMEMSIZE) {
 283                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 284                        TVMEMSIZE);
 285                 return;
 286         }
 287
 288         memcpy(tvmem, template, tsize);
 289         cipher_tv = (void *)tvmem;
 290
 291         if (mode)
 292                 tfm = crypto_alloc_tfm(algo, 0);
 293         else
 294                 tfm = crypto_alloc_tfm(algo, CRYPTO_TFM_MODE_CBC);
 295
 296         if (tfm == NULL) {
 297                 printk("failed to load transform for %s %s\n", algo, m);
 298                 return;
 299         }
 300
 301         j = 0;
 302         for (i = 0; i < tcount; i++) {
 303                 if (!(cipher_tv[i].np)) {
 304                         j++;
 305                         printk("test %u (%d bit key):\n",
 306                         j, cipher_tv[i].klen * 8);
 307
 308                         tfm->crt_flags = 0;
 309                         if (cipher_tv[i].wk)
 310                                 tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY;
 311                         key = cipher_tv[i].key;
 312
 313                         ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen);
 314                         if (ret) {
 315                                 printk("setkey() failed flags=%x\n", tfm->crt_flags);
 316
 317                                 if (!cipher_tv[i].fail)
 318                                         goto out;
 319                         }
 320
 321                         sg_set_buf(&sg[0], cipher_tv[i].input,
 322                                    cipher_tv[i].ilen);
 323
 324                         if (!mode) {
 325                                 crypto_cipher_set_iv(tfm, cipher_tv[i].iv,
 326                                         crypto_tfm_alg_ivsize(tfm));
 327                         }
 328
 329                         if (enc)
 330                                 ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen);
 331                         else
 332                                 ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen);
 333
 334
 335                         if (ret) {
 336                                 printk("%s () failed flags=%x\n", e, tfm->crt_flags);
 337                                 goto out;
 338                         }
 339
 340                         q = kmap(sg[0].page) + sg[0].offset;
 341                         hexdump(q, cipher_tv[i].rlen);
 342
 343                         printk("%s\n",
 344                                memcmp(q, cipher_tv[i].result,
 345                                       cipher_tv[i].rlen) ? "fail" : "pass");
 346                 }
 347         }
 348
 349         printk("\ntesting %s %s %s across pages (chunking)\n", algo, m, e);
 350         memset(xbuf, 0, XBUFSIZE);
 351
 352         j = 0;
 353         for (i = 0; i < tcount; i++) {
 354                 if (cipher_tv[i].np) {
 355                         j++;
 356                         printk("test %u (%d bit key):\n",
 357                         j, cipher_tv[i].klen * 8);
 358
 359                         tfm->crt_flags = 0;
 360                         if (cipher_tv[i].wk)
 361                                 tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY;
 362                         key = cipher_tv[i].key;
 363
 364                         ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen);
 365                         if (ret) {
 366                                 printk("setkey() failed flags=%x\n", tfm->crt_flags);
 367
 368                                 if (!cipher_tv[i].fail)
 369                                         goto out;
 370                         }
 371
 372                         temp = 0;
 373                         for (k = 0; k < cipher_tv[i].np; k++) {
 374                                 memcpy(&xbuf[IDX[k]],
 375                                        cipher_tv[i].input + temp,
 376                                        cipher_tv[i].tap[k]);
 377                                 temp += cipher_tv[i].tap[k];
 378                                 sg_set_buf(&sg[k], &xbuf[IDX[k]],
 379                                            cipher_tv[i].tap[k]);
 380                         }
 381
 382                         if (!mode) {
 383                                 crypto_cipher_set_iv(tfm, cipher_tv[i].iv,
 384                                                 crypto_tfm_alg_ivsize(tfm));
 385                         }
 386
 387                         if (enc)
 388                                 ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen);
 389                         else
 390                                 ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen);
 391
 392                         if (ret) {
 393                                 printk("%s () failed flags=%x\n", e, tfm->crt_flags);
 394                                 goto out;
 395                         }
 396
 397                         temp = 0;
 398                         for (k = 0; k < cipher_tv[i].np; k++) {
 399                                 printk("page %u\n", k);
 400                                 q = kmap(sg[k].page) + sg[k].offset;
 401                                 hexdump(q, cipher_tv[i].tap[k]);
 402                                 printk("%s\n",
 403                                         memcmp(q, cipher_tv[i].result + temp,
 404                                                 cipher_tv[i].tap[k]) ? "fail" :
 405                                         "pass");
 406                                 temp += cipher_tv[i].tap[k];
 407                         }
 408                 }
 409         }
 410
 411 out:
 412         crypto_free_tfm(tfm);
 413 }
 414
 415 static int test_cipher_jiffies(struct crypto_tfm *tfm, int enc, char *p,
 416                                int blen, int sec)
 417 {
 418         struct scatterlist sg[1];
 419         unsigned long start, end;
 420         int bcount;
 421         int ret;
 422
 423         sg_set_buf(sg, p, blen);
 424
 425         for (start = jiffies, end = start + sec * HZ, bcount = 0;
 426              time_before(jiffies, end); bcount++) {
 427                 if (enc)
 428                         ret = crypto_cipher_encrypt(tfm, sg, sg, blen);
 429                 else
 430                         ret = crypto_cipher_decrypt(tfm, sg, sg, blen);
 431
 432                 if (ret)
 433                         return ret;
 434         }
 435
 436         printk("%d operations in %d seconds (%ld bytes)\n",
 437                bcount, sec, (long)bcount * blen);
 438         return 0;
 439 }
 440
 441 static int test_cipher_cycles(struct crypto_tfm *tfm, int enc, char *p,
 442                               int blen)
 443 {
 444         struct scatterlist sg[1];
 445         unsigned long cycles = 0;
 446         int ret = 0;
 447         int i;
 448
 449         sg_set_buf(sg, p, blen);
 450
 451         local_bh_disable();
 452         local_irq_disable();
 453
 454         /* Warm-up run. */
 455         for (i = 0; i < 4; i++) {
 456                 if (enc)
 457                         ret = crypto_cipher_encrypt(tfm, sg, sg, blen);
 458                 else
 459                         ret = crypto_cipher_decrypt(tfm, sg, sg, blen);
 460
 461                 if (ret)
 462                         goto out;
 463         }
 464
 465         /* The real thing. */
 466         for (i = 0; i < 8; i++) {
 467                 cycles_t start, end;
 468
 469                 start = get_cycles();
 470                 if (enc)
 471                         ret = crypto_cipher_encrypt(tfm, sg, sg, blen);
 472                 else
 473                         ret = crypto_cipher_decrypt(tfm, sg, sg, blen);
 474                 end = get_cycles();
 475
 476                 if (ret)
 477                         goto out;
 478
 479                 cycles += end - start;
 480         }
 481
 482 out:
 483         local_irq_enable();
 484         local_bh_enable();
 485
 486         if (ret == 0)
 487                 printk("1 operation in %lu cycles (%d bytes)\n",
 488                        (cycles + 4) / 8, blen);
 489
 490         return ret;
 491 }
 492
 493 static void test_cipher_speed(char *algo, int mode, int enc, unsigned int sec,
 494                               struct cipher_testvec *template,
 495                               unsigned int tcount, struct cipher_speed *speed)
 496 {
 497         unsigned int ret, i, j, iv_len;
 498         unsigned char *key, *p, iv[128];
 499         struct crypto_tfm *tfm;
 500         const char *e, *m;
 501
 502         if (enc == ENCRYPT)
 503                 e = "encryption";
 504         else
 505                 e = "decryption";
 506         if (mode == MODE_ECB)
 507                 m = "ECB";
 508         else
 509                 m = "CBC";
 510
 511         printk("\ntesting speed of %s %s %s\n", algo, m, e);
 512
 513         if (mode)
 514                 tfm = crypto_alloc_tfm(algo, 0);
 515         else
 516                 tfm = crypto_alloc_tfm(algo, CRYPTO_TFM_MODE_CBC);
 517
 518         if (tfm == NULL) {
 519                 printk("failed to load transform for %s %s\n", algo, m);
 520                 return;
 521         }
 522
 523         for (i = 0; speed[i].klen != 0; i++) {
 524                 if ((speed[i].blen + speed[i].klen) > TVMEMSIZE) {
 525                         printk("template (%u) too big for tvmem (%u)\n",
 526                                speed[i].blen + speed[i].klen, TVMEMSIZE);
 527                         goto out;
 528                 }
 529
 530                 printk("test %u (%d bit key, %d byte blocks): ", i,
 531                        speed[i].klen * 8, speed[i].blen);
 532
 533                 memset(tvmem, 0xff, speed[i].klen + speed[i].blen);
 534
 535                 /* set key, plain text and IV */
 536                 key = (unsigned char *)tvmem;
 537                 for (j = 0; j < tcount; j++) {
 538                         if (template[j].klen == speed[i].klen) {
 539                                 key = template[j].key;
 540                                 break;
 541                         }
 542                 }
 543                 p = (unsigned char *)tvmem + speed[i].klen;
 544
 545                 ret = crypto_cipher_setkey(tfm, key, speed[i].klen);
 546                 if (ret) {
 547                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
 548                         goto out;
 549                 }
 550
 551                 if (!mode) {
 552                         iv_len = crypto_tfm_alg_ivsize(tfm);
 553                         memset(&iv, 0xff, iv_len);
 554                         crypto_cipher_set_iv(tfm, iv, iv_len);
 555                 }
 556
 557                 if (sec)
 558                         ret = test_cipher_jiffies(tfm, enc, p, speed[i].blen,
 559                                                   sec);
 560                 else
 561                         ret = test_cipher_cycles(tfm, enc, p, speed[i].blen);
 562
 563                 if (ret) {
 564                         printk("%s() failed flags=%x\n", e, tfm->crt_flags);
 565                         break;
 566                 }
 567         }
 568
 569 out:
 570         crypto_free_tfm(tfm);
 571 }
 572
 573 static void test_deflate(void)
 574 {
 575         unsigned int i;
 576         char result[COMP_BUF_SIZE];
 577         struct crypto_tfm *tfm;
 578         struct comp_testvec *tv;
 579         unsigned int tsize;
 580
 581         printk("\ntesting deflate compression\n");
 582
 583         tsize = sizeof (deflate_comp_tv_template);
 584         if (tsize > TVMEMSIZE) {
 585                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 586                        TVMEMSIZE);
 587                 return;
 588         }
 589
 590         memcpy(tvmem, deflate_comp_tv_template, tsize);
 591         tv = (void *)tvmem;
 592
 593         tfm = crypto_alloc_tfm("deflate", 0);
 594         if (tfm == NULL) {
 595                 printk("failed to load transform for deflate\n");
 596                 return;
 597         }
 598
 599         for (i = 0; i < DEFLATE_COMP_TEST_VECTORS; i++) {
 600                 int ilen, ret, dlen = COMP_BUF_SIZE;
 601
 602                 printk("test %u:\n", i + 1);
 603                 memset(result, 0, sizeof (result));
 604
 605                 ilen = tv[i].inlen;
 606                 ret = crypto_comp_compress(tfm, tv[i].input,
 607                                            ilen, result, &dlen);
 608                 if (ret) {
 609                         printk("fail: ret=%d\n", ret);
 610                         continue;
 611                 }
 612                 hexdump(result, dlen);
 613                 printk("%s (ratio %d:%d)\n",
 614                        memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
 615                        ilen, dlen);
 616         }
 617
 618         printk("\ntesting deflate decompression\n");
 619
 620         tsize = sizeof (deflate_decomp_tv_template);
 621         if (tsize > TVMEMSIZE) {
 622                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 623                        TVMEMSIZE);
 624                 goto out;
 625         }
 626
 627         memcpy(tvmem, deflate_decomp_tv_template, tsize);
 628         tv = (void *)tvmem;
 629
 630         for (i = 0; i < DEFLATE_DECOMP_TEST_VECTORS; i++) {
 631                 int ilen, ret, dlen = COMP_BUF_SIZE;
 632
 633                 printk("test %u:\n", i + 1);
 634                 memset(result, 0, sizeof (result));
 635
 636                 ilen = tv[i].inlen;
 637                 ret = crypto_comp_decompress(tfm, tv[i].input,
 638                                              ilen, result, &dlen);
 639                 if (ret) {
 640                         printk("fail: ret=%d\n", ret);
 641                         continue;
 642                 }
 643                 hexdump(result, dlen);
 644                 printk("%s (ratio %d:%d)\n",
 645                        memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
 646                        ilen, dlen);
 647         }
 648 out:
 649         crypto_free_tfm(tfm);
 650 }
 651
 652 static void test_crc32c(void)
 653 {
 654 #define NUMVEC 6
 655 #define VECSIZE 40
 656
 657         int i, j, pass;
 658         u32 crc;
 659         u8 b, test_vec[NUMVEC][VECSIZE];
 660         static u32 vec_results[NUMVEC] = {
 661                 0x0e2c157f, 0xe980ebf6, 0xde74bded,
 662                 0xd579c862, 0xba979ad0, 0x2b29d913
 663         };
 664         static u32 tot_vec_results = 0x24c5d375;
 665
 666         struct scatterlist sg[NUMVEC];
 667         struct crypto_tfm *tfm;
 668         char *fmtdata = "testing crc32c initialized to %08x: %s\n";
 669 #define SEEDTESTVAL 0xedcba987
 670         u32 seed;
 671
 672         printk("\ntesting crc32c\n");
 673
 674         tfm = crypto_alloc_tfm("crc32c", 0);
 675         if (tfm == NULL) {
 676                 printk("failed to load transform for crc32c\n");
 677                 return;
 678         }
 679
 680         crypto_digest_init(tfm);
 681         crypto_digest_final(tfm, (u8*)&crc);
 682         printk(fmtdata, crc, (crc == 0) ? "pass" : "ERROR");
 683
 684         /*
 685          * stuff test_vec with known values, simple incrementing
 686          * byte values.
 687          */
 688         b = 0;
 689         for (i = 0; i < NUMVEC; i++) {
 690                 for (j = 0; j < VECSIZE; j++)
 691                         test_vec[i][j] = ++b;
 692                 sg_set_buf(&sg[i], test_vec[i], VECSIZE);
 693         }
 694
 695         seed = SEEDTESTVAL;
 696         (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
 697         crypto_digest_final(tfm, (u8*)&crc);
 698         printk("testing crc32c setkey returns %08x : %s\n", crc, (crc == (SEEDTESTVAL ^ ~(u32)0)) ?
 699                "pass" : "ERROR");
 700
 701         printk("testing crc32c using update/final:\n");
 702
 703         pass = 1;                   /* assume all is well */
 704
 705         for (i = 0; i < NUMVEC; i++) {
 706                 seed = ~(u32)0;
 707                 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
 708                 crypto_digest_update(tfm, &sg[i], 1);
 709                 crypto_digest_final(tfm, (u8*)&crc);
 710                 if (crc == vec_results[i]) {
 711                         printk(" %08x:OK", crc);
 712                 } else {
 713                         printk(" %08x:BAD, wanted %08x\n", crc, vec_results[i]);
 714                         pass = 0;
 715                 }
 716         }
 717
 718         printk("\ntesting crc32c using incremental accumulator:\n");
 719         crc = 0;
 720         for (i = 0; i < NUMVEC; i++) {
 721                 seed = (crc ^ ~(u32)0);
 722                 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
 723                 crypto_digest_update(tfm, &sg[i], 1);
 724                 crypto_digest_final(tfm, (u8*)&crc);
 725         }
 726         if (crc == tot_vec_results) {
 727                 printk(" %08x:OK", crc);
 728         } else {
 729                 printk(" %08x:BAD, wanted %08x\n", crc, tot_vec_results);
 730                 pass = 0;
 731         }
 732
 733         printk("\ntesting crc32c using digest:\n");
 734         seed = ~(u32)0;
 735         (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
 736         crypto_digest_digest(tfm, sg, NUMVEC, (u8*)&crc);
 737         if (crc == tot_vec_results) {
 738                 printk(" %08x:OK", crc);
 739         } else {
 740                 printk(" %08x:BAD, wanted %08x\n", crc, tot_vec_results);
 741                 pass = 0;
 742         }
 743
 744         printk("\n%s\n", pass ? "pass" : "ERROR");
 745
 746         crypto_free_tfm(tfm);
 747         printk("crc32c test complete\n");
 748 }
 749
 750 static void test_available(void)
 751 {
 752         char **name = check;
 753
 754         while (*name) {
 755                 printk("alg %s ", *name);
 756                 printk((crypto_alg_available(*name, 0)) ?
 757                         "found\n" : "not found\n");
 758                 name++;
 759         }
 760 }
 761
 762 static void do_test(void)
 763 {
 764         switch (mode) {
 765
 766         case 0:
 767                 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
 768
 769                 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
 770
 771                 //DES
 772                 test_cipher ("des", MODE_ECB, ENCRYPT, des_enc_tv_template, DES_ENC_TEST_VECTORS);
 773                 test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS);
 774                 test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS);
 775                 test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS);
 776
 777                 //DES3_EDE
 778                 test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS);
 779                 test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS);
 780
 781                 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
 782
 783                 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
 784
 785                 //BLOWFISH
 786                 test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS);
 787                 test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS);
 788                 test_cipher ("blowfish", MODE_CBC, ENCRYPT, bf_cbc_enc_tv_template, BF_CBC_ENC_TEST_VECTORS);
 789                 test_cipher ("blowfish", MODE_CBC, DECRYPT, bf_cbc_dec_tv_template, BF_CBC_DEC_TEST_VECTORS);
 790
 791                 //TWOFISH
 792                 test_cipher ("twofish", MODE_ECB, ENCRYPT, tf_enc_tv_template, TF_ENC_TEST_VECTORS);
 793                 test_cipher ("twofish", MODE_ECB, DECRYPT, tf_dec_tv_template, TF_DEC_TEST_VECTORS);
 794                 test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS);
 795                 test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS);
 796
 797                 //SERPENT
 798                 test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS);
 799                 test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS);
 800
 801                 //TNEPRES
 802                 test_cipher ("tnepres", MODE_ECB, ENCRYPT, tnepres_enc_tv_template, TNEPRES_ENC_TEST_VECTORS);
 803                 test_cipher ("tnepres", MODE_ECB, DECRYPT, tnepres_dec_tv_template, TNEPRES_DEC_TEST_VECTORS);
 804
 805                 //AES
 806                 test_cipher ("aes", MODE_ECB, ENCRYPT, aes_enc_tv_template, AES_ENC_TEST_VECTORS);
 807                 test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS);
 808
 809                 //CAST5
 810                 test_cipher ("cast5", MODE_ECB, ENCRYPT, cast5_enc_tv_template, CAST5_ENC_TEST_VECTORS);
 811                 test_cipher ("cast5", MODE_ECB, DECRYPT, cast5_dec_tv_template, CAST5_DEC_TEST_VECTORS);
 812
 813                 //CAST6
 814                 test_cipher ("cast6", MODE_ECB, ENCRYPT, cast6_enc_tv_template, CAST6_ENC_TEST_VECTORS);
 815                 test_cipher ("cast6", MODE_ECB, DECRYPT, cast6_dec_tv_template, CAST6_DEC_TEST_VECTORS);
 816
 817                 //ARC4
 818                 test_cipher ("arc4", MODE_ECB, ENCRYPT, arc4_enc_tv_template, ARC4_ENC_TEST_VECTORS);
 819                 test_cipher ("arc4", MODE_ECB, DECRYPT, arc4_dec_tv_template, ARC4_DEC_TEST_VECTORS);
 820
 821                 //TEA
 822                 test_cipher ("tea", MODE_ECB, ENCRYPT, tea_enc_tv_template, TEA_ENC_TEST_VECTORS);
 823                 test_cipher ("tea", MODE_ECB, DECRYPT, tea_dec_tv_template, TEA_DEC_TEST_VECTORS);
 824
 825
 826                 //XTEA
 827                 test_cipher ("xtea", MODE_ECB, ENCRYPT, xtea_enc_tv_template, XTEA_ENC_TEST_VECTORS);
 828                 test_cipher ("xtea", MODE_ECB, DECRYPT, xtea_dec_tv_template, XTEA_DEC_TEST_VECTORS);
 829
 830                 //KHAZAD
 831                 test_cipher ("khazad", MODE_ECB, ENCRYPT, khazad_enc_tv_template, KHAZAD_ENC_TEST_VECTORS);
 832                 test_cipher ("khazad", MODE_ECB, DECRYPT, khazad_dec_tv_template, KHAZAD_DEC_TEST_VECTORS);
 833
 834                 //ANUBIS
 835                 test_cipher ("anubis", MODE_ECB, ENCRYPT, anubis_enc_tv_template, ANUBIS_ENC_TEST_VECTORS);
 836                 test_cipher ("anubis", MODE_ECB, DECRYPT, anubis_dec_tv_template, ANUBIS_DEC_TEST_VECTORS);
 837                 test_cipher ("anubis", MODE_CBC, ENCRYPT, anubis_cbc_enc_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
 838                 test_cipher ("anubis", MODE_CBC, DECRYPT, anubis_cbc_dec_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
 839
 840                 //XETA
 841                 test_cipher ("xeta", MODE_ECB, ENCRYPT, xeta_enc_tv_template, XETA_ENC_TEST_VECTORS);
 842                 test_cipher ("xeta", MODE_ECB, DECRYPT, xeta_dec_tv_template, XETA_DEC_TEST_VECTORS);
 843
 844                 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
 845                 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
 846                 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
 847                 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
 848                 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
 849                 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
 850                 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
 851                 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
 852                 test_deflate();
 853                 test_crc32c();
 854 #ifdef CONFIG_CRYPTO_HMAC
 855                 test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS);
 856                 test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS);
 857                 test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS);
 858 #endif
 859
 860                 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
 861                 break;
 862
 863         case 1:
 864                 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
 865                 break;
 866
 867         case 2:
 868                 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
 869                 break;
 870
 871         case 3:
 872                 test_cipher ("des", MODE_ECB, ENCRYPT, des_enc_tv_template, DES_ENC_TEST_VECTORS);
 873                 test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS);
 874                 test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS);
 875                 test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS);
 876                 break;
 877
 878         case 4:
 879                 test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS);
 880                 test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS);
 881                 break;
 882
 883         case 5:
 884                 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
 885                 break;
 886
 887         case 6:
 888                 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
 889                 break;
 890
 891         case 7:
 892                 test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS);
 893                 test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS);
 894                 test_cipher ("blowfish", MODE_CBC, ENCRYPT, bf_cbc_enc_tv_template, BF_CBC_ENC_TEST_VECTORS);
 895                 test_cipher ("blowfish", MODE_CBC, DECRYPT, bf_cbc_dec_tv_template, BF_CBC_DEC_TEST_VECTORS);
 896                 break;
 897
 898         case 8:
 899                 test_cipher ("twofish", MODE_ECB, ENCRYPT, tf_enc_tv_template, TF_ENC_TEST_VECTORS);
 900                 test_cipher ("twofish", MODE_ECB, DECRYPT, tf_dec_tv_template, TF_DEC_TEST_VECTORS);
 901                 test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS);
 902                 test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS);
 903                 break;
 904
 905         case 9:
 906                 test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS);
 907                 test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS);
 908                 break;
 909
 910         case 10:
 911                 test_cipher ("aes", MODE_ECB, ENCRYPT, aes_enc_tv_template, AES_ENC_TEST_VECTORS);
 912                 test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS);
 913                 break;
 914
 915         case 11:
 916                 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
 917                 break;
 918
 919         case 12:
 920                 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
 921                 break;
 922
 923         case 13:
 924                 test_deflate();
 925                 break;
 926
 927         case 14:
 928                 test_cipher ("cast5", MODE_ECB, ENCRYPT, cast5_enc_tv_template, CAST5_ENC_TEST_VECTORS);
 929                 test_cipher ("cast5", MODE_ECB, DECRYPT, cast5_dec_tv_template, CAST5_DEC_TEST_VECTORS);
 930                 break;
 931
 932         case 15:
 933                 test_cipher ("cast6", MODE_ECB, ENCRYPT, cast6_enc_tv_template, CAST6_ENC_TEST_VECTORS);
 934                 test_cipher ("cast6", MODE_ECB, DECRYPT, cast6_dec_tv_template, CAST6_DEC_TEST_VECTORS);
 935                 break;
 936
 937         case 16:
 938                 test_cipher ("arc4", MODE_ECB, ENCRYPT, arc4_enc_tv_template, ARC4_ENC_TEST_VECTORS);
 939                 test_cipher ("arc4", MODE_ECB, DECRYPT, arc4_dec_tv_template, ARC4_DEC_TEST_VECTORS);
 940                 break;
 941
 942         case 17:
 943                 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
 944                 break;
 945
 946         case 18:
 947                 test_crc32c();
 948                 break;
 949
 950         case 19:
 951                 test_cipher ("tea", MODE_ECB, ENCRYPT, tea_enc_tv_template, TEA_ENC_TEST_VECTORS);
 952                 test_cipher ("tea", MODE_ECB, DECRYPT, tea_dec_tv_template, TEA_DEC_TEST_VECTORS);
 953                 break;
 954
 955         case 20:
 956                 test_cipher ("xtea", MODE_ECB, ENCRYPT, xtea_enc_tv_template, XTEA_ENC_TEST_VECTORS);
 957                 test_cipher ("xtea", MODE_ECB, DECRYPT, xtea_dec_tv_template, XTEA_DEC_TEST_VECTORS);
 958                 break;
 959
 960         case 21:
 961                 test_cipher ("khazad", MODE_ECB, ENCRYPT, khazad_enc_tv_template, KHAZAD_ENC_TEST_VECTORS);
 962                 test_cipher ("khazad", MODE_ECB, DECRYPT, khazad_dec_tv_template, KHAZAD_DEC_TEST_VECTORS);
 963                 break;
 964
 965         case 22:
 966                 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
 967                 break;
 968
 969         case 23:
 970                 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
 971                 break;
 972
 973         case 24:
 974                 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
 975                 break;
 976
 977         case 25:
 978                 test_cipher ("tnepres", MODE_ECB, ENCRYPT, tnepres_enc_tv_template, TNEPRES_ENC_TEST_VECTORS);
 979                 test_cipher ("tnepres", MODE_ECB, DECRYPT, tnepres_dec_tv_template, TNEPRES_DEC_TEST_VECTORS);
 980                 break;
 981
 982         case 26:
 983                 test_cipher ("anubis", MODE_ECB, ENCRYPT, anubis_enc_tv_template, ANUBIS_ENC_TEST_VECTORS);
 984                 test_cipher ("anubis", MODE_ECB, DECRYPT, anubis_dec_tv_template, ANUBIS_DEC_TEST_VECTORS);
 985                 test_cipher ("anubis", MODE_CBC, ENCRYPT, anubis_cbc_enc_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
 986                 test_cipher ("anubis", MODE_CBC, DECRYPT, anubis_cbc_dec_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
 987                 break;
 988
 989         case 27:
 990                 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
 991                 break;
 992
 993         case 28:
 994
 995                 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
 996                 break;
 997
 998         case 29:
 999                 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
1000                 break;
1001
1002         case 30:
1003                 test_cipher ("xeta", MODE_ECB, ENCRYPT, xeta_enc_tv_template, XETA_ENC_TEST_VECTORS);
1004                 test_cipher ("xeta", MODE_ECB, DECRYPT, xeta_dec_tv_template, XETA_DEC_TEST_VECTORS);
1005                 break;
1006
1007 #ifdef CONFIG_CRYPTO_HMAC
1008         case 100:
1009                 test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS);
1010                 break;
1011
1012         case 101:
1013                 test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS);
1014                 break;
1015
1016         case 102:
1017                 test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS);
1018                 break;
1019
1020 #endif
1021
1022         case 200:
1023                 test_cipher_speed("aes", MODE_ECB, ENCRYPT, sec, NULL, 0,
1024                                   aes_speed_template);
1025                 test_cipher_speed("aes", MODE_ECB, DECRYPT, sec, NULL, 0,
1026                                   aes_speed_template);
1027                 test_cipher_speed("aes", MODE_CBC, ENCRYPT, sec, NULL, 0,
1028                                   aes_speed_template);
1029                 test_cipher_speed("aes", MODE_CBC, DECRYPT, sec, NULL, 0,
1030                                   aes_speed_template);
1031                 break;
1032
1033         case 201:
1034                 test_cipher_speed("des3_ede", MODE_ECB, ENCRYPT, sec,
1035                                   des3_ede_enc_tv_template,
1036                                   DES3_EDE_ENC_TEST_VECTORS,
1037                                   des3_ede_speed_template);
1038                 test_cipher_speed("des3_ede", MODE_ECB, DECRYPT, sec,
1039                                   des3_ede_dec_tv_template,
1040                                   DES3_EDE_DEC_TEST_VECTORS,
1041                                   des3_ede_speed_template);
1042                 test_cipher_speed("des3_ede", MODE_CBC, ENCRYPT, sec,
1043                                   des3_ede_enc_tv_template,
1044                                   DES3_EDE_ENC_TEST_VECTORS,
1045                                   des3_ede_speed_template);
1046                 test_cipher_speed("des3_ede", MODE_CBC, DECRYPT, sec,
1047                                   des3_ede_dec_tv_template,
1048                                   DES3_EDE_DEC_TEST_VECTORS,
1049                                   des3_ede_speed_template);
1050                 break;
1051
1052         case 202:
1053                 test_cipher_speed("twofish", MODE_ECB, ENCRYPT, sec, NULL, 0,
1054                                   twofish_speed_template);
1055                 test_cipher_speed("twofish", MODE_ECB, DECRYPT, sec, NULL, 0,
1056                                   twofish_speed_template);
1057                 test_cipher_speed("twofish", MODE_CBC, ENCRYPT, sec, NULL, 0,
1058                                   twofish_speed_template);
1059                 test_cipher_speed("twofish", MODE_CBC, DECRYPT, sec, NULL, 0,
1060                                   twofish_speed_template);
1061                 break;
1062
1063         case 203:
1064                 test_cipher_speed("blowfish", MODE_ECB, ENCRYPT, sec, NULL, 0,
1065                                   blowfish_speed_template);
1066                 test_cipher_speed("blowfish", MODE_ECB, DECRYPT, sec, NULL, 0,
1067                                   blowfish_speed_template);
1068                 test_cipher_speed("blowfish", MODE_CBC, ENCRYPT, sec, NULL, 0,
1069                                   blowfish_speed_template);
1070                 test_cipher_speed("blowfish", MODE_CBC, DECRYPT, sec, NULL, 0,
1071                                   blowfish_speed_template);
1072                 break;
1073
1074         case 204:
1075                 test_cipher_speed("des", MODE_ECB, ENCRYPT, sec, NULL, 0,
1076                                   des_speed_template);
1077                 test_cipher_speed("des", MODE_ECB, DECRYPT, sec, NULL, 0,
1078                                   des_speed_template);
1079                 test_cipher_speed("des", MODE_CBC, ENCRYPT, sec, NULL, 0,
1080                                   des_speed_template);
1081                 test_cipher_speed("des", MODE_CBC, DECRYPT, sec, NULL, 0,
1082                                   des_speed_template);
1083                 break;
1084
1085         case 1000:
1086                 test_available();
1087                 break;
1088
1089         default:
1090                 /* useful for debugging */
1091                 printk("not testing anything\n");
1092                 break;
1093         }
1094 }
1095
1096 static int __init init(void)
1097 {
1098         tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL);
1099         if (tvmem == NULL)
1100                 return -ENOMEM;
1101
1102         xbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
1103         if (xbuf == NULL) {
1104                 kfree(tvmem);
1105                 return -ENOMEM;
1106         }
1107
1108         do_test();
1109
1110         kfree(xbuf);
1111         kfree(tvmem);
1112         return 0;
1113 }
1114
1115 /*
1116  * If an init function is provided, an exit function must also be provided
1117  * to allow module unload.
1118  */
1119 static void __exit fini(void) { }
1120
1121 module_init(init);
1122 module_exit(fini);
1123
1124 module_param(mode, int, 0);
1125 module_param(sec, uint, 0);
1126 MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
1127                       "(defaults to zero which uses CPU cycles instead)");
1128
1129 MODULE_LICENSE("GPL");
1130 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
1131 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");