git.oblomov.eu Git - linux-2.6/blob - 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_digest_jiffies(struct crypto_tfm *tfm, char *p, int blen,
 574                                 int plen, char *out, int sec)
 575 {
 576         struct scatterlist sg[1];
 577         unsigned long start, end;
 578         int bcount, pcount;
 579
 580         for (start = jiffies, end = start + sec * HZ, bcount = 0;
 581              time_before(jiffies, end); bcount++) {
 582                 crypto_digest_init(tfm);
 583                 for (pcount = 0; pcount < blen; pcount += plen) {
 584                         sg_set_buf(sg, p + pcount, plen);
 585                         crypto_digest_update(tfm, sg, 1);
 586                 }
 587                 /* we assume there is enough space in 'out' for the result */
 588                 crypto_digest_final(tfm, out);
 589         }
 590
 591         printk("%6u opers/sec, %9lu bytes/sec\n",
 592                bcount / sec, ((long)bcount * blen) / sec);
 593
 594         return;
 595 }
 596
 597 static void test_digest_cycles(struct crypto_tfm *tfm, char *p, int blen,
 598                                int plen, char *out)
 599 {
 600         struct scatterlist sg[1];
 601         unsigned long cycles = 0;
 602         int i, pcount;
 603
 604         local_bh_disable();
 605         local_irq_disable();
 606
 607         /* Warm-up run. */
 608         for (i = 0; i < 4; i++) {
 609                 crypto_digest_init(tfm);
 610                 for (pcount = 0; pcount < blen; pcount += plen) {
 611                         sg_set_buf(sg, p + pcount, plen);
 612                         crypto_digest_update(tfm, sg, 1);
 613                 }
 614                 crypto_digest_final(tfm, out);
 615         }
 616
 617         /* The real thing. */
 618         for (i = 0; i < 8; i++) {
 619                 cycles_t start, end;
 620
 621                 crypto_digest_init(tfm);
 622
 623                 start = get_cycles();
 624
 625                 for (pcount = 0; pcount < blen; pcount += plen) {
 626                         sg_set_buf(sg, p + pcount, plen);
 627                         crypto_digest_update(tfm, sg, 1);
 628                 }
 629                 crypto_digest_final(tfm, out);
 630
 631                 end = get_cycles();
 632
 633                 cycles += end - start;
 634         }
 635
 636         local_irq_enable();
 637         local_bh_enable();
 638
 639         printk("%6lu cycles/operation, %4lu cycles/byte\n",
 640                cycles / 8, cycles / (8 * blen));
 641
 642         return;
 643 }
 644
 645 static void test_digest_speed(char *algo, unsigned int sec,
 646                               struct digest_speed *speed)
 647 {
 648         struct crypto_tfm *tfm;
 649         char output[1024];
 650         int i;
 651
 652         printk("\ntesting speed of %s\n", algo);
 653
 654         tfm = crypto_alloc_tfm(algo, 0);
 655
 656         if (tfm == NULL) {
 657                 printk("failed to load transform for %s\n", algo);
 658                 return;
 659         }
 660
 661         if (crypto_tfm_alg_digestsize(tfm) > sizeof(output)) {
 662                 printk("digestsize(%u) > outputbuffer(%zu)\n",
 663                        crypto_tfm_alg_digestsize(tfm), sizeof(output));
 664                 goto out;
 665         }
 666
 667         for (i = 0; speed[i].blen != 0; i++) {
 668                 if (speed[i].blen > TVMEMSIZE) {
 669                         printk("template (%u) too big for tvmem (%u)\n",
 670                                speed[i].blen, TVMEMSIZE);
 671                         goto out;
 672                 }
 673
 674                 printk("test%3u (%5u byte blocks,%5u bytes per update,%4u updates): ",
 675                        i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
 676
 677                 memset(tvmem, 0xff, speed[i].blen);
 678
 679                 if (sec)
 680                         test_digest_jiffies(tfm, tvmem, speed[i].blen, speed[i].plen, output, sec);
 681                 else
 682                         test_digest_cycles(tfm, tvmem, speed[i].blen, speed[i].plen, output);
 683         }
 684
 685 out:
 686         crypto_free_tfm(tfm);
 687 }
 688
 689 static void test_deflate(void)
 690 {
 691         unsigned int i;
 692         char result[COMP_BUF_SIZE];
 693         struct crypto_tfm *tfm;
 694         struct comp_testvec *tv;
 695         unsigned int tsize;
 696
 697         printk("\ntesting deflate compression\n");
 698
 699         tsize = sizeof (deflate_comp_tv_template);
 700         if (tsize > TVMEMSIZE) {
 701                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 702                        TVMEMSIZE);
 703                 return;
 704         }
 705
 706         memcpy(tvmem, deflate_comp_tv_template, tsize);
 707         tv = (void *)tvmem;
 708
 709         tfm = crypto_alloc_tfm("deflate", 0);
 710         if (tfm == NULL) {
 711                 printk("failed to load transform for deflate\n");
 712                 return;
 713         }
 714
 715         for (i = 0; i < DEFLATE_COMP_TEST_VECTORS; i++) {
 716                 int ilen, ret, dlen = COMP_BUF_SIZE;
 717
 718                 printk("test %u:\n", i + 1);
 719                 memset(result, 0, sizeof (result));
 720
 721                 ilen = tv[i].inlen;
 722                 ret = crypto_comp_compress(tfm, tv[i].input,
 723                                            ilen, result, &dlen);
 724                 if (ret) {
 725                         printk("fail: ret=%d\n", ret);
 726                         continue;
 727                 }
 728                 hexdump(result, dlen);
 729                 printk("%s (ratio %d:%d)\n",
 730                        memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
 731                        ilen, dlen);
 732         }
 733
 734         printk("\ntesting deflate decompression\n");
 735
 736         tsize = sizeof (deflate_decomp_tv_template);
 737         if (tsize > TVMEMSIZE) {
 738                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 739                        TVMEMSIZE);
 740                 goto out;
 741         }
 742
 743         memcpy(tvmem, deflate_decomp_tv_template, tsize);
 744         tv = (void *)tvmem;
 745
 746         for (i = 0; i < DEFLATE_DECOMP_TEST_VECTORS; i++) {
 747                 int ilen, ret, dlen = COMP_BUF_SIZE;
 748
 749                 printk("test %u:\n", i + 1);
 750                 memset(result, 0, sizeof (result));
 751
 752                 ilen = tv[i].inlen;
 753                 ret = crypto_comp_decompress(tfm, tv[i].input,
 754                                              ilen, result, &dlen);
 755                 if (ret) {
 756                         printk("fail: ret=%d\n", ret);
 757                         continue;
 758                 }
 759                 hexdump(result, dlen);
 760                 printk("%s (ratio %d:%d)\n",
 761                        memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
 762                        ilen, dlen);
 763         }
 764 out:
 765         crypto_free_tfm(tfm);
 766 }
 767
 768 static void test_crc32c(void)
 769 {
 770 #define NUMVEC 6
 771 #define VECSIZE 40
 772
 773         int i, j, pass;
 774         u32 crc;
 775         u8 b, test_vec[NUMVEC][VECSIZE];
 776         static u32 vec_results[NUMVEC] = {
 777                 0x0e2c157f, 0xe980ebf6, 0xde74bded,
 778                 0xd579c862, 0xba979ad0, 0x2b29d913
 779         };
 780         static u32 tot_vec_results = 0x24c5d375;
 781
 782         struct scatterlist sg[NUMVEC];
 783         struct crypto_tfm *tfm;
 784         char *fmtdata = "testing crc32c initialized to %08x: %s\n";
 785 #define SEEDTESTVAL 0xedcba987
 786         u32 seed;
 787
 788         printk("\ntesting crc32c\n");
 789
 790         tfm = crypto_alloc_tfm("crc32c", 0);
 791         if (tfm == NULL) {
 792                 printk("failed to load transform for crc32c\n");
 793                 return;
 794         }
 795
 796         crypto_digest_init(tfm);
 797         crypto_digest_final(tfm, (u8*)&crc);
 798         printk(fmtdata, crc, (crc == 0) ? "pass" : "ERROR");
 799
 800         /*
 801          * stuff test_vec with known values, simple incrementing
 802          * byte values.
 803          */
 804         b = 0;
 805         for (i = 0; i < NUMVEC; i++) {
 806                 for (j = 0; j < VECSIZE; j++)
 807                         test_vec[i][j] = ++b;
 808                 sg_set_buf(&sg[i], test_vec[i], VECSIZE);
 809         }
 810
 811         seed = SEEDTESTVAL;
 812         (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
 813         crypto_digest_final(tfm, (u8*)&crc);
 814         printk("testing crc32c setkey returns %08x : %s\n", crc, (crc == (SEEDTESTVAL ^ ~(u32)0)) ?
 815                "pass" : "ERROR");
 816
 817         printk("testing crc32c using update/final:\n");
 818
 819         pass = 1;                   /* assume all is well */
 820
 821         for (i = 0; i < NUMVEC; i++) {
 822                 seed = ~(u32)0;
 823                 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
 824                 crypto_digest_update(tfm, &sg[i], 1);
 825                 crypto_digest_final(tfm, (u8*)&crc);
 826                 if (crc == vec_results[i]) {
 827                         printk(" %08x:OK", crc);
 828                 } else {
 829                         printk(" %08x:BAD, wanted %08x\n", crc, vec_results[i]);
 830                         pass = 0;
 831                 }
 832         }
 833
 834         printk("\ntesting crc32c using incremental accumulator:\n");
 835         crc = 0;
 836         for (i = 0; i < NUMVEC; i++) {
 837                 seed = (crc ^ ~(u32)0);
 838                 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
 839                 crypto_digest_update(tfm, &sg[i], 1);
 840                 crypto_digest_final(tfm, (u8*)&crc);
 841         }
 842         if (crc == tot_vec_results) {
 843                 printk(" %08x:OK", crc);
 844         } else {
 845                 printk(" %08x:BAD, wanted %08x\n", crc, tot_vec_results);
 846                 pass = 0;
 847         }
 848
 849         printk("\ntesting crc32c using digest:\n");
 850         seed = ~(u32)0;
 851         (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
 852         crypto_digest_digest(tfm, sg, NUMVEC, (u8*)&crc);
 853         if (crc == tot_vec_results) {
 854                 printk(" %08x:OK", crc);
 855         } else {
 856                 printk(" %08x:BAD, wanted %08x\n", crc, tot_vec_results);
 857                 pass = 0;
 858         }
 859
 860         printk("\n%s\n", pass ? "pass" : "ERROR");
 861
 862         crypto_free_tfm(tfm);
 863         printk("crc32c test complete\n");
 864 }
 865
 866 static void test_available(void)
 867 {
 868         char **name = check;
 869
 870         while (*name) {
 871                 printk("alg %s ", *name);
 872                 printk((crypto_alg_available(*name, 0)) ?
 873                         "found\n" : "not found\n");
 874                 name++;
 875         }
 876 }
 877
 878 static void do_test(void)
 879 {
 880         switch (mode) {
 881
 882         case 0:
 883                 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
 884
 885                 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
 886
 887                 //DES
 888                 test_cipher ("des", MODE_ECB, ENCRYPT, des_enc_tv_template, DES_ENC_TEST_VECTORS);
 889                 test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS);
 890                 test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS);
 891                 test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS);
 892
 893                 //DES3_EDE
 894                 test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS);
 895                 test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS);
 896
 897                 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
 898
 899                 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
 900
 901                 //BLOWFISH
 902                 test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS);
 903                 test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS);
 904                 test_cipher ("blowfish", MODE_CBC, ENCRYPT, bf_cbc_enc_tv_template, BF_CBC_ENC_TEST_VECTORS);
 905                 test_cipher ("blowfish", MODE_CBC, DECRYPT, bf_cbc_dec_tv_template, BF_CBC_DEC_TEST_VECTORS);
 906
 907                 //TWOFISH
 908                 test_cipher ("twofish", MODE_ECB, ENCRYPT, tf_enc_tv_template, TF_ENC_TEST_VECTORS);
 909                 test_cipher ("twofish", MODE_ECB, DECRYPT, tf_dec_tv_template, TF_DEC_TEST_VECTORS);
 910                 test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS);
 911                 test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS);
 912
 913                 //SERPENT
 914                 test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS);
 915                 test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS);
 916
 917                 //TNEPRES
 918                 test_cipher ("tnepres", MODE_ECB, ENCRYPT, tnepres_enc_tv_template, TNEPRES_ENC_TEST_VECTORS);
 919                 test_cipher ("tnepres", MODE_ECB, DECRYPT, tnepres_dec_tv_template, TNEPRES_DEC_TEST_VECTORS);
 920
 921                 //AES
 922                 test_cipher ("aes", MODE_ECB, ENCRYPT, aes_enc_tv_template, AES_ENC_TEST_VECTORS);
 923                 test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS);
 924                 test_cipher ("aes", MODE_CBC, ENCRYPT, aes_cbc_enc_tv_template, AES_CBC_ENC_TEST_VECTORS);
 925                 test_cipher ("aes", MODE_CBC, DECRYPT, aes_cbc_dec_tv_template, AES_CBC_DEC_TEST_VECTORS);
 926
 927                 //CAST5
 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
 931                 //CAST6
 932                 test_cipher ("cast6", MODE_ECB, ENCRYPT, cast6_enc_tv_template, CAST6_ENC_TEST_VECTORS);
 933                 test_cipher ("cast6", MODE_ECB, DECRYPT, cast6_dec_tv_template, CAST6_DEC_TEST_VECTORS);
 934
 935                 //ARC4
 936                 test_cipher ("arc4", MODE_ECB, ENCRYPT, arc4_enc_tv_template, ARC4_ENC_TEST_VECTORS);
 937                 test_cipher ("arc4", MODE_ECB, DECRYPT, arc4_dec_tv_template, ARC4_DEC_TEST_VECTORS);
 938
 939                 //TEA
 940                 test_cipher ("tea", MODE_ECB, ENCRYPT, tea_enc_tv_template, TEA_ENC_TEST_VECTORS);
 941                 test_cipher ("tea", MODE_ECB, DECRYPT, tea_dec_tv_template, TEA_DEC_TEST_VECTORS);
 942
 943
 944                 //XTEA
 945                 test_cipher ("xtea", MODE_ECB, ENCRYPT, xtea_enc_tv_template, XTEA_ENC_TEST_VECTORS);
 946                 test_cipher ("xtea", MODE_ECB, DECRYPT, xtea_dec_tv_template, XTEA_DEC_TEST_VECTORS);
 947
 948                 //KHAZAD
 949                 test_cipher ("khazad", MODE_ECB, ENCRYPT, khazad_enc_tv_template, KHAZAD_ENC_TEST_VECTORS);
 950                 test_cipher ("khazad", MODE_ECB, DECRYPT, khazad_dec_tv_template, KHAZAD_DEC_TEST_VECTORS);
 951
 952                 //ANUBIS
 953                 test_cipher ("anubis", MODE_ECB, ENCRYPT, anubis_enc_tv_template, ANUBIS_ENC_TEST_VECTORS);
 954                 test_cipher ("anubis", MODE_ECB, DECRYPT, anubis_dec_tv_template, ANUBIS_DEC_TEST_VECTORS);
 955                 test_cipher ("anubis", MODE_CBC, ENCRYPT, anubis_cbc_enc_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
 956                 test_cipher ("anubis", MODE_CBC, DECRYPT, anubis_cbc_dec_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
 957
 958                 //XETA
 959                 test_cipher ("xeta", MODE_ECB, ENCRYPT, xeta_enc_tv_template, XETA_ENC_TEST_VECTORS);
 960                 test_cipher ("xeta", MODE_ECB, DECRYPT, xeta_dec_tv_template, XETA_DEC_TEST_VECTORS);
 961
 962                 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
 963                 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
 964                 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
 965                 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
 966                 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
 967                 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
 968                 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
 969                 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
 970                 test_deflate();
 971                 test_crc32c();
 972 #ifdef CONFIG_CRYPTO_HMAC
 973                 test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS);
 974                 test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS);
 975                 test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS);
 976 #endif
 977
 978                 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
 979                 break;
 980
 981         case 1:
 982                 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
 983                 break;
 984
 985         case 2:
 986                 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
 987                 break;
 988
 989         case 3:
 990                 test_cipher ("des", MODE_ECB, ENCRYPT, des_enc_tv_template, DES_ENC_TEST_VECTORS);
 991                 test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS);
 992                 test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS);
 993                 test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS);
 994                 break;
 995
 996         case 4:
 997                 test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS);
 998                 test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS);
 999                 break;
1000
1001         case 5:
1002                 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
1003                 break;
1004
1005         case 6:
1006                 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
1007                 break;
1008
1009         case 7:
1010                 test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS);
1011                 test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS);
1012                 test_cipher ("blowfish", MODE_CBC, ENCRYPT, bf_cbc_enc_tv_template, BF_CBC_ENC_TEST_VECTORS);
1013                 test_cipher ("blowfish", MODE_CBC, DECRYPT, bf_cbc_dec_tv_template, BF_CBC_DEC_TEST_VECTORS);
1014                 break;
1015
1016         case 8:
1017                 test_cipher ("twofish", MODE_ECB, ENCRYPT, tf_enc_tv_template, TF_ENC_TEST_VECTORS);
1018                 test_cipher ("twofish", MODE_ECB, DECRYPT, tf_dec_tv_template, TF_DEC_TEST_VECTORS);
1019                 test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS);
1020                 test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS);
1021                 break;
1022
1023         case 9:
1024                 test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS);
1025                 test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS);
1026                 break;
1027
1028         case 10:
1029                 test_cipher ("aes", MODE_ECB, ENCRYPT, aes_enc_tv_template, AES_ENC_TEST_VECTORS);
1030                 test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS);
1031                 test_cipher ("aes", MODE_CBC, ENCRYPT, aes_cbc_enc_tv_template, AES_CBC_ENC_TEST_VECTORS);
1032                 test_cipher ("aes", MODE_CBC, DECRYPT, aes_cbc_dec_tv_template, AES_CBC_DEC_TEST_VECTORS);
1033                 break;
1034
1035         case 11:
1036                 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
1037                 break;
1038
1039         case 12:
1040                 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
1041                 break;
1042
1043         case 13:
1044                 test_deflate();
1045                 break;
1046
1047         case 14:
1048                 test_cipher ("cast5", MODE_ECB, ENCRYPT, cast5_enc_tv_template, CAST5_ENC_TEST_VECTORS);
1049                 test_cipher ("cast5", MODE_ECB, DECRYPT, cast5_dec_tv_template, CAST5_DEC_TEST_VECTORS);
1050                 break;
1051
1052         case 15:
1053                 test_cipher ("cast6", MODE_ECB, ENCRYPT, cast6_enc_tv_template, CAST6_ENC_TEST_VECTORS);
1054                 test_cipher ("cast6", MODE_ECB, DECRYPT, cast6_dec_tv_template, CAST6_DEC_TEST_VECTORS);
1055                 break;
1056
1057         case 16:
1058                 test_cipher ("arc4", MODE_ECB, ENCRYPT, arc4_enc_tv_template, ARC4_ENC_TEST_VECTORS);
1059                 test_cipher ("arc4", MODE_ECB, DECRYPT, arc4_dec_tv_template, ARC4_DEC_TEST_VECTORS);
1060                 break;
1061
1062         case 17:
1063                 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
1064                 break;
1065
1066         case 18:
1067                 test_crc32c();
1068                 break;
1069
1070         case 19:
1071                 test_cipher ("tea", MODE_ECB, ENCRYPT, tea_enc_tv_template, TEA_ENC_TEST_VECTORS);
1072                 test_cipher ("tea", MODE_ECB, DECRYPT, tea_dec_tv_template, TEA_DEC_TEST_VECTORS);
1073                 break;
1074
1075         case 20:
1076                 test_cipher ("xtea", MODE_ECB, ENCRYPT, xtea_enc_tv_template, XTEA_ENC_TEST_VECTORS);
1077                 test_cipher ("xtea", MODE_ECB, DECRYPT, xtea_dec_tv_template, XTEA_DEC_TEST_VECTORS);
1078                 break;
1079
1080         case 21:
1081                 test_cipher ("khazad", MODE_ECB, ENCRYPT, khazad_enc_tv_template, KHAZAD_ENC_TEST_VECTORS);
1082                 test_cipher ("khazad", MODE_ECB, DECRYPT, khazad_dec_tv_template, KHAZAD_DEC_TEST_VECTORS);
1083                 break;
1084
1085         case 22:
1086                 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
1087                 break;
1088
1089         case 23:
1090                 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
1091                 break;
1092
1093         case 24:
1094                 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
1095                 break;
1096
1097         case 25:
1098                 test_cipher ("tnepres", MODE_ECB, ENCRYPT, tnepres_enc_tv_template, TNEPRES_ENC_TEST_VECTORS);
1099                 test_cipher ("tnepres", MODE_ECB, DECRYPT, tnepres_dec_tv_template, TNEPRES_DEC_TEST_VECTORS);
1100                 break;
1101
1102         case 26:
1103                 test_cipher ("anubis", MODE_ECB, ENCRYPT, anubis_enc_tv_template, ANUBIS_ENC_TEST_VECTORS);
1104                 test_cipher ("anubis", MODE_ECB, DECRYPT, anubis_dec_tv_template, ANUBIS_DEC_TEST_VECTORS);
1105                 test_cipher ("anubis", MODE_CBC, ENCRYPT, anubis_cbc_enc_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
1106                 test_cipher ("anubis", MODE_CBC, DECRYPT, anubis_cbc_dec_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
1107                 break;
1108
1109         case 27:
1110                 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
1111                 break;
1112
1113         case 28:
1114
1115                 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
1116                 break;
1117
1118         case 29:
1119                 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
1120                 break;
1121
1122         case 30:
1123                 test_cipher ("xeta", MODE_ECB, ENCRYPT, xeta_enc_tv_template, XETA_ENC_TEST_VECTORS);
1124                 test_cipher ("xeta", MODE_ECB, DECRYPT, xeta_dec_tv_template, XETA_DEC_TEST_VECTORS);
1125                 break;
1126
1127 #ifdef CONFIG_CRYPTO_HMAC
1128         case 100:
1129                 test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS);
1130                 break;
1131
1132         case 101:
1133                 test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS);
1134                 break;
1135
1136         case 102:
1137                 test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS);
1138                 break;
1139
1140 #endif
1141
1142         case 200:
1143                 test_cipher_speed("aes", MODE_ECB, ENCRYPT, sec, NULL, 0,
1144                                   aes_speed_template);
1145                 test_cipher_speed("aes", MODE_ECB, DECRYPT, sec, NULL, 0,
1146                                   aes_speed_template);
1147                 test_cipher_speed("aes", MODE_CBC, ENCRYPT, sec, NULL, 0,
1148                                   aes_speed_template);
1149                 test_cipher_speed("aes", MODE_CBC, DECRYPT, sec, NULL, 0,
1150                                   aes_speed_template);
1151                 break;
1152
1153         case 201:
1154                 test_cipher_speed("des3_ede", MODE_ECB, ENCRYPT, sec,
1155                                   des3_ede_enc_tv_template,
1156                                   DES3_EDE_ENC_TEST_VECTORS,
1157                                   des3_ede_speed_template);
1158                 test_cipher_speed("des3_ede", MODE_ECB, DECRYPT, sec,
1159                                   des3_ede_dec_tv_template,
1160                                   DES3_EDE_DEC_TEST_VECTORS,
1161                                   des3_ede_speed_template);
1162                 test_cipher_speed("des3_ede", MODE_CBC, ENCRYPT, sec,
1163                                   des3_ede_enc_tv_template,
1164                                   DES3_EDE_ENC_TEST_VECTORS,
1165                                   des3_ede_speed_template);
1166                 test_cipher_speed("des3_ede", MODE_CBC, DECRYPT, sec,
1167                                   des3_ede_dec_tv_template,
1168                                   DES3_EDE_DEC_TEST_VECTORS,
1169                                   des3_ede_speed_template);
1170                 break;
1171
1172         case 202:
1173                 test_cipher_speed("twofish", MODE_ECB, ENCRYPT, sec, NULL, 0,
1174                                   twofish_speed_template);
1175                 test_cipher_speed("twofish", MODE_ECB, DECRYPT, sec, NULL, 0,
1176                                   twofish_speed_template);
1177                 test_cipher_speed("twofish", MODE_CBC, ENCRYPT, sec, NULL, 0,
1178                                   twofish_speed_template);
1179                 test_cipher_speed("twofish", MODE_CBC, DECRYPT, sec, NULL, 0,
1180                                   twofish_speed_template);
1181                 break;
1182
1183         case 203:
1184                 test_cipher_speed("blowfish", MODE_ECB, ENCRYPT, sec, NULL, 0,
1185                                   blowfish_speed_template);
1186                 test_cipher_speed("blowfish", MODE_ECB, DECRYPT, sec, NULL, 0,
1187                                   blowfish_speed_template);
1188                 test_cipher_speed("blowfish", MODE_CBC, ENCRYPT, sec, NULL, 0,
1189                                   blowfish_speed_template);
1190                 test_cipher_speed("blowfish", MODE_CBC, DECRYPT, sec, NULL, 0,
1191                                   blowfish_speed_template);
1192                 break;
1193
1194         case 204:
1195                 test_cipher_speed("des", MODE_ECB, ENCRYPT, sec, NULL, 0,
1196                                   des_speed_template);
1197                 test_cipher_speed("des", MODE_ECB, DECRYPT, sec, NULL, 0,
1198                                   des_speed_template);
1199                 test_cipher_speed("des", MODE_CBC, ENCRYPT, sec, NULL, 0,
1200                                   des_speed_template);
1201                 test_cipher_speed("des", MODE_CBC, DECRYPT, sec, NULL, 0,
1202                                   des_speed_template);
1203                 break;
1204
1205         case 300:
1206                 /* fall through */
1207
1208         case 301:
1209                 test_digest_speed("md4", sec, generic_digest_speed_template);
1210                 if (mode > 300 && mode < 400) break;
1211
1212         case 302:
1213                 test_digest_speed("md5", sec, generic_digest_speed_template);
1214                 if (mode > 300 && mode < 400) break;
1215
1216         case 303:
1217                 test_digest_speed("sha1", sec, generic_digest_speed_template);
1218                 if (mode > 300 && mode < 400) break;
1219
1220         case 304:
1221                 test_digest_speed("sha256", sec, generic_digest_speed_template);
1222                 if (mode > 300 && mode < 400) break;
1223
1224         case 305:
1225                 test_digest_speed("sha384", sec, generic_digest_speed_template);
1226                 if (mode > 300 && mode < 400) break;
1227
1228         case 306:
1229                 test_digest_speed("sha512", sec, generic_digest_speed_template);
1230                 if (mode > 300 && mode < 400) break;
1231
1232         case 307:
1233                 test_digest_speed("wp256", sec, generic_digest_speed_template);
1234                 if (mode > 300 && mode < 400) break;
1235
1236         case 308:
1237                 test_digest_speed("wp384", sec, generic_digest_speed_template);
1238                 if (mode > 300 && mode < 400) break;
1239
1240         case 309:
1241                 test_digest_speed("wp512", sec, generic_digest_speed_template);
1242                 if (mode > 300 && mode < 400) break;
1243
1244         case 310:
1245                 test_digest_speed("tgr128", sec, generic_digest_speed_template);
1246                 if (mode > 300 && mode < 400) break;
1247
1248         case 311:
1249                 test_digest_speed("tgr160", sec, generic_digest_speed_template);
1250                 if (mode > 300 && mode < 400) break;
1251
1252         case 312:
1253                 test_digest_speed("tgr192", sec, generic_digest_speed_template);
1254                 if (mode > 300 && mode < 400) break;
1255
1256         case 399:
1257                 break;
1258
1259         case 1000:
1260                 test_available();
1261                 break;
1262
1263         default:
1264                 /* useful for debugging */
1265                 printk("not testing anything\n");
1266                 break;
1267         }
1268 }
1269
1270 static int __init init(void)
1271 {
1272         tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL);
1273         if (tvmem == NULL)
1274                 return -ENOMEM;
1275
1276         xbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
1277         if (xbuf == NULL) {
1278                 kfree(tvmem);
1279                 return -ENOMEM;
1280         }
1281
1282         do_test();
1283
1284         kfree(xbuf);
1285         kfree(tvmem);
1286
1287         /* We intentionaly return -EAGAIN to prevent keeping
1288          * the module. It does all its work from init()
1289          * and doesn't offer any runtime functionality
1290          * => we don't need it in the memory, do we?
1291          *                                        -- mludvig
1292          */
1293         return -EAGAIN;
1294 }
1295
1296 /*
1297  * If an init function is provided, an exit function must also be provided
1298  * to allow module unload.
1299  */
1300 static void __exit fini(void) { }
1301
1302 module_init(init);
1303 module_exit(fini);
1304
1305 module_param(mode, int, 0);
1306 module_param(sec, uint, 0);
1307 MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
1308                       "(defaults to zero which uses CPU cycles instead)");
1309
1310 MODULE_LICENSE("GPL");
1311 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
1312 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");