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