SAFE public projects git trees. - safe/jmp/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  * Copyright (c) 2007 Nokia Siemens Networks
  10  *
  11  * This program is free software; you can redistribute it and/or modify it
  12  * under the terms of the GNU General Public License as published by the Free
  13  * Software Foundation; either version 2 of the License, or (at your option)
  14  * any later version.
  15  *
  16  * 2007-11-13 Added GCM tests
  17  * 2007-11-13 Added AEAD support
  18  * 2007-11-06 Added SHA-224 and SHA-224-HMAC tests
  19  * 2006-12-07 Added SHA384 HMAC and SHA512 HMAC tests
  20  * 2004-08-09 Added cipher speed tests (Reyk Floeter <reyk@vantronix.net>)
  21  * 2003-09-14 Rewritten by Kartikey Mahendra Bhatt
  22  *
  23  */
  24
  25 #include <linux/err.h>
  26 #include <linux/init.h>
  27 #include <linux/module.h>
  28 #include <linux/mm.h>
  29 #include <linux/slab.h>
  30 #include <linux/scatterlist.h>
  31 #include <linux/string.h>
  32 #include <linux/crypto.h>
  33 #include <linux/highmem.h>
  34 #include <linux/moduleparam.h>
  35 #include <linux/jiffies.h>
  36 #include <linux/timex.h>
  37 #include <linux/interrupt.h>
  38 #include "tcrypt.h"
  39
  40 /*
  41  * Need to kmalloc() memory for testing kmap().
  42  */
  43 #define TVMEMSIZE       16384
  44 #define XBUFSIZE        32768
  45
  46 /*
  47  * Indexes into the xbuf to simulate cross-page access.
  48  */
  49 #define IDX1            37
  50 #define IDX2            32400
  51 #define IDX3            1
  52 #define IDX4            8193
  53 #define IDX5            22222
  54 #define IDX6            17101
  55 #define IDX7            27333
  56 #define IDX8            3000
  57
  58 /*
  59 * Used by test_cipher()
  60 */
  61 #define ENCRYPT 1
  62 #define DECRYPT 0
  63
  64 struct tcrypt_result {
  65         struct completion completion;
  66         int err;
  67 };
  68
  69 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
  70
  71 /*
  72  * Used by test_cipher_speed()
  73  */
  74 static unsigned int sec;
  75
  76 static int mode;
  77 static char *xbuf;
  78 static char *axbuf;
  79 static char *tvmem;
  80
  81 static char *check[] = {
  82         "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256",
  83         "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes",
  84         "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
  85         "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
  86         "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta",  "fcrypt",
  87         "camellia", "seed", "salsa20", "lzo", NULL
  88 };
  89
  90 static void hexdump(unsigned char *buf, unsigned int len)
  91 {
  92         print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
  93                         16, 1,
  94                         buf, len, false);
  95 }
  96
  97 static void tcrypt_complete(struct crypto_async_request *req, int err)
  98 {
  99         struct tcrypt_result *res = req->data;
 100
 101         if (err == -EINPROGRESS)
 102                 return;
 103
 104         res->err = err;
 105         complete(&res->completion);
 106 }
 107
 108 static void test_hash(char *algo, struct hash_testvec *template,
 109                       unsigned int tcount)
 110 {
 111         unsigned int i, j, k, temp;
 112         struct scatterlist sg[8];
 113         char result[64];
 114         struct crypto_hash *tfm;
 115         struct hash_desc desc;
 116         struct hash_testvec *hash_tv;
 117         unsigned int tsize;
 118         int ret;
 119
 120         printk("\ntesting %s\n", algo);
 121
 122         tsize = sizeof(struct hash_testvec);
 123         tsize *= tcount;
 124
 125         if (tsize > TVMEMSIZE) {
 126                 printk("template (%u) too big for tvmem (%u)\n", tsize, TVMEMSIZE);
 127                 return;
 128         }
 129
 130         memcpy(tvmem, template, tsize);
 131         hash_tv = (void *)tvmem;
 132
 133         tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
 134         if (IS_ERR(tfm)) {
 135                 printk("failed to load transform for %s: %ld\n", algo,
 136                        PTR_ERR(tfm));
 137                 return;
 138         }
 139
 140         desc.tfm = tfm;
 141         desc.flags = 0;
 142
 143         for (i = 0; i < tcount; i++) {
 144                 printk("test %u:\n", i + 1);
 145                 memset(result, 0, 64);
 146
 147                 sg_init_one(&sg[0], hash_tv[i].plaintext, hash_tv[i].psize);
 148
 149                 if (hash_tv[i].ksize) {
 150                         ret = crypto_hash_setkey(tfm, hash_tv[i].key,
 151                                                  hash_tv[i].ksize);
 152                         if (ret) {
 153                                 printk("setkey() failed ret=%d\n", ret);
 154                                 goto out;
 155                         }
 156                 }
 157
 158                 ret = crypto_hash_digest(&desc, sg, hash_tv[i].psize, result);
 159                 if (ret) {
 160                         printk("digest () failed ret=%d\n", ret);
 161                         goto out;
 162                 }
 163
 164                 hexdump(result, crypto_hash_digestsize(tfm));
 165                 printk("%s\n",
 166                        memcmp(result, hash_tv[i].digest,
 167                               crypto_hash_digestsize(tfm)) ?
 168                        "fail" : "pass");
 169         }
 170
 171         printk("testing %s across pages\n", algo);
 172
 173         /* setup the dummy buffer first */
 174         memset(xbuf, 0, XBUFSIZE);
 175
 176         j = 0;
 177         for (i = 0; i < tcount; i++) {
 178                 if (hash_tv[i].np) {
 179                         j++;
 180                         printk("test %u:\n", j);
 181                         memset(result, 0, 64);
 182
 183                         temp = 0;
 184                         sg_init_table(sg, hash_tv[i].np);
 185                         for (k = 0; k < hash_tv[i].np; k++) {
 186                                 memcpy(&xbuf[IDX[k]],
 187                                        hash_tv[i].plaintext + temp,
 188                                        hash_tv[i].tap[k]);
 189                                 temp += hash_tv[i].tap[k];
 190                                 sg_set_buf(&sg[k], &xbuf[IDX[k]],
 191                                             hash_tv[i].tap[k]);
 192                         }
 193
 194                         if (hash_tv[i].ksize) {
 195                                 ret = crypto_hash_setkey(tfm, hash_tv[i].key,
 196                                                          hash_tv[i].ksize);
 197
 198                                 if (ret) {
 199                                         printk("setkey() failed ret=%d\n", ret);
 200                                         goto out;
 201                                 }
 202                         }
 203
 204                         ret = crypto_hash_digest(&desc, sg, hash_tv[i].psize,
 205                                                  result);
 206                         if (ret) {
 207                                 printk("digest () failed ret=%d\n", ret);
 208                                 goto out;
 209                         }
 210
 211                         hexdump(result, crypto_hash_digestsize(tfm));
 212                         printk("%s\n",
 213                                memcmp(result, hash_tv[i].digest,
 214                                       crypto_hash_digestsize(tfm)) ?
 215                                "fail" : "pass");
 216                 }
 217         }
 218
 219 out:
 220         crypto_free_hash(tfm);
 221 }
 222
 223 static void test_aead(char *algo, int enc, struct aead_testvec *template,
 224                       unsigned int tcount)
 225 {
 226         unsigned int ret, i, j, k, temp;
 227         unsigned int tsize;
 228         char *q;
 229         struct crypto_aead *tfm;
 230         char *key;
 231         struct aead_testvec *aead_tv;
 232         struct aead_request *req;
 233         struct scatterlist sg[8];
 234         struct scatterlist asg[8];
 235         const char *e;
 236         struct tcrypt_result result;
 237         unsigned int authsize;
 238
 239         if (enc == ENCRYPT)
 240                 e = "encryption";
 241         else
 242                 e = "decryption";
 243
 244         printk(KERN_INFO "\ntesting %s %s\n", algo, e);
 245
 246         tsize = sizeof(struct aead_testvec);
 247         tsize *= tcount;
 248
 249         if (tsize > TVMEMSIZE) {
 250                 printk(KERN_INFO "template (%u) too big for tvmem (%u)\n",
 251                        tsize, TVMEMSIZE);
 252                 return;
 253         }
 254
 255         memcpy(tvmem, template, tsize);
 256         aead_tv = (void *)tvmem;
 257
 258         init_completion(&result.completion);
 259
 260         tfm = crypto_alloc_aead(algo, 0, 0);
 261
 262         if (IS_ERR(tfm)) {
 263                 printk(KERN_INFO "failed to load transform for %s: %ld\n",
 264                        algo, PTR_ERR(tfm));
 265                 return;
 266         }
 267
 268         req = aead_request_alloc(tfm, GFP_KERNEL);
 269         if (!req) {
 270                 printk(KERN_INFO "failed to allocate request for %s\n", algo);
 271                 goto out;
 272         }
 273
 274         aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
 275                                   tcrypt_complete, &result);
 276
 277         for (i = 0, j = 0; i < tcount; i++) {
 278                 if (!aead_tv[i].np) {
 279                         printk(KERN_INFO "test %u (%d bit key):\n",
 280                                ++j, aead_tv[i].klen * 8);
 281
 282                         crypto_aead_clear_flags(tfm, ~0);
 283                         if (aead_tv[i].wk)
 284                                 crypto_aead_set_flags(
 285                                         tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 286                         key = aead_tv[i].key;
 287
 288                         ret = crypto_aead_setkey(tfm, key,
 289                                                  aead_tv[i].klen);
 290                         if (ret) {
 291                                 printk(KERN_INFO "setkey() failed flags=%x\n",
 292                                        crypto_aead_get_flags(tfm));
 293
 294                                 if (!aead_tv[i].fail)
 295                                         goto out;
 296                         }
 297
 298                         authsize = abs(aead_tv[i].rlen - aead_tv[i].ilen);
 299                         ret = crypto_aead_setauthsize(tfm, authsize);
 300                         if (ret) {
 301                                 printk(KERN_INFO
 302                                        "failed to set authsize = %u\n",
 303                                        authsize);
 304                                 goto out;
 305                         }
 306
 307                         sg_init_one(&sg[0], aead_tv[i].input,
 308                                     aead_tv[i].ilen + (enc ? authsize : 0));
 309
 310                         sg_init_one(&asg[0], aead_tv[i].assoc,
 311                                     aead_tv[i].alen);
 312
 313                         aead_request_set_crypt(req, sg, sg,
 314                                                aead_tv[i].ilen,
 315                                                aead_tv[i].iv);
 316
 317                         aead_request_set_assoc(req, asg, aead_tv[i].alen);
 318
 319                         ret = enc ?
 320                                 crypto_aead_encrypt(req) :
 321                                 crypto_aead_decrypt(req);
 322
 323                         switch (ret) {
 324                         case 0:
 325                                 break;
 326                         case -EINPROGRESS:
 327                         case -EBUSY:
 328                                 ret = wait_for_completion_interruptible(
 329                                         &result.completion);
 330                                 if (!ret && !(ret = result.err)) {
 331                                         INIT_COMPLETION(result.completion);
 332                                         break;
 333                                 }
 334                                 /* fall through */
 335                         default:
 336                                 printk(KERN_INFO "%s () failed err=%d\n",
 337                                        e, -ret);
 338                                 goto out;
 339                         }
 340
 341                         q = kmap(sg_page(&sg[0])) + sg[0].offset;
 342                         hexdump(q, aead_tv[i].rlen);
 343
 344                         printk(KERN_INFO "enc/dec: %s\n",
 345                                memcmp(q, aead_tv[i].result,
 346                                       aead_tv[i].rlen) ? "fail" : "pass");
 347                 }
 348         }
 349
 350         printk(KERN_INFO "\ntesting %s %s across pages (chunking)\n", algo, e);
 351         memset(xbuf, 0, XBUFSIZE);
 352         memset(axbuf, 0, XBUFSIZE);
 353
 354         for (i = 0, j = 0; i < tcount; i++) {
 355                 if (aead_tv[i].np) {
 356                         printk(KERN_INFO "test %u (%d bit key):\n",
 357                                ++j, aead_tv[i].klen * 8);
 358
 359                         crypto_aead_clear_flags(tfm, ~0);
 360                         if (aead_tv[i].wk)
 361                                 crypto_aead_set_flags(
 362                                         tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 363                         key = aead_tv[i].key;
 364
 365                         ret = crypto_aead_setkey(tfm, key, aead_tv[i].klen);
 366                         if (ret) {
 367                                 printk(KERN_INFO "setkey() failed flags=%x\n",
 368                                        crypto_aead_get_flags(tfm));
 369
 370                                 if (!aead_tv[i].fail)
 371                                         goto out;
 372                         }
 373
 374                         sg_init_table(sg, aead_tv[i].np);
 375                         for (k = 0, temp = 0; k < aead_tv[i].np; k++) {
 376                                 memcpy(&xbuf[IDX[k]],
 377                                        aead_tv[i].input + temp,
 378                                        aead_tv[i].tap[k]);
 379                                 temp += aead_tv[i].tap[k];
 380                                 sg_set_buf(&sg[k], &xbuf[IDX[k]],
 381                                            aead_tv[i].tap[k]);
 382                         }
 383
 384                         authsize = abs(aead_tv[i].rlen - aead_tv[i].ilen);
 385                         ret = crypto_aead_setauthsize(tfm, authsize);
 386                         if (ret) {
 387                                 printk(KERN_INFO
 388                                        "failed to set authsize = %u\n",
 389                                        authsize);
 390                                 goto out;
 391                         }
 392
 393                         if (enc)
 394                                 sg[k - 1].length += authsize;
 395
 396                         sg_init_table(asg, aead_tv[i].anp);
 397                         for (k = 0, temp = 0; k < aead_tv[i].anp; k++) {
 398                                 memcpy(&axbuf[IDX[k]],
 399                                        aead_tv[i].assoc + temp,
 400                                        aead_tv[i].atap[k]);
 401                                 temp += aead_tv[i].atap[k];
 402                                 sg_set_buf(&asg[k], &axbuf[IDX[k]],
 403                                            aead_tv[i].atap[k]);
 404                         }
 405
 406                         aead_request_set_crypt(req, sg, sg,
 407                                                aead_tv[i].ilen,
 408                                                aead_tv[i].iv);
 409
 410                         aead_request_set_assoc(req, asg, aead_tv[i].alen);
 411
 412                         ret = enc ?
 413                                 crypto_aead_encrypt(req) :
 414                                 crypto_aead_decrypt(req);
 415
 416                         switch (ret) {
 417                         case 0:
 418                                 break;
 419                         case -EINPROGRESS:
 420                         case -EBUSY:
 421                                 ret = wait_for_completion_interruptible(
 422                                         &result.completion);
 423                                 if (!ret && !(ret = result.err)) {
 424                                         INIT_COMPLETION(result.completion);
 425                                         break;
 426                                 }
 427                                 /* fall through */
 428                         default:
 429                                 printk(KERN_INFO "%s () failed err=%d\n",
 430                                        e, -ret);
 431                                 goto out;
 432                         }
 433
 434                         for (k = 0, temp = 0; k < aead_tv[i].np; k++) {
 435                                 printk(KERN_INFO "page %u\n", k);
 436                                 q = kmap(sg_page(&sg[k])) + sg[k].offset;
 437                                 hexdump(q, aead_tv[i].tap[k]);
 438                                 printk(KERN_INFO "%s\n",
 439                                        memcmp(q, aead_tv[i].result + temp,
 440                                               aead_tv[i].tap[k] -
 441                                               (k < aead_tv[i].np - 1 || enc ?
 442                                                0 : authsize)) ?
 443                                        "fail" : "pass");
 444
 445                                 temp += aead_tv[i].tap[k];
 446                         }
 447                 }
 448         }
 449
 450 out:
 451         crypto_free_aead(tfm);
 452         aead_request_free(req);
 453 }
 454
 455 static void test_cipher(char *algo, int enc,
 456                         struct cipher_testvec *template, unsigned int tcount)
 457 {
 458         unsigned int ret, i, j, k, temp;
 459         unsigned int tsize;
 460         char *q;
 461         struct crypto_ablkcipher *tfm;
 462         char *key;
 463         struct cipher_testvec *cipher_tv;
 464         struct ablkcipher_request *req;
 465         struct scatterlist sg[8];
 466         const char *e;
 467         struct tcrypt_result result;
 468
 469         if (enc == ENCRYPT)
 470                 e = "encryption";
 471         else
 472                 e = "decryption";
 473
 474         printk("\ntesting %s %s\n", algo, e);
 475
 476         tsize = sizeof (struct cipher_testvec);
 477         if (tsize > TVMEMSIZE) {
 478                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 479                        TVMEMSIZE);
 480                 return;
 481         }
 482         cipher_tv = (void *)tvmem;
 483
 484         init_completion(&result.completion);
 485
 486         tfm = crypto_alloc_ablkcipher(algo, 0, 0);
 487
 488         if (IS_ERR(tfm)) {
 489                 printk("failed to load transform for %s: %ld\n", algo,
 490                        PTR_ERR(tfm));
 491                 return;
 492         }
 493
 494         req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
 495         if (!req) {
 496                 printk("failed to allocate request for %s\n", algo);
 497                 goto out;
 498         }
 499
 500         ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
 501                                         tcrypt_complete, &result);
 502
 503         j = 0;
 504         for (i = 0; i < tcount; i++) {
 505                 memcpy(cipher_tv, &template[i], tsize);
 506                 if (!(cipher_tv->np)) {
 507                         j++;
 508                         printk("test %u (%d bit key):\n",
 509                         j, cipher_tv->klen * 8);
 510
 511                         crypto_ablkcipher_clear_flags(tfm, ~0);
 512                         if (cipher_tv->wk)
 513                                 crypto_ablkcipher_set_flags(
 514                                         tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 515                         key = cipher_tv->key;
 516
 517                         ret = crypto_ablkcipher_setkey(tfm, key,
 518                                                        cipher_tv->klen);
 519                         if (ret) {
 520                                 printk("setkey() failed flags=%x\n",
 521                                        crypto_ablkcipher_get_flags(tfm));
 522
 523                                 if (!cipher_tv->fail)
 524                                         goto out;
 525                         }
 526
 527                         sg_init_one(&sg[0], cipher_tv->input,
 528                                     cipher_tv->ilen);
 529
 530                         ablkcipher_request_set_crypt(req, sg, sg,
 531                                                      cipher_tv->ilen,
 532                                                      cipher_tv->iv);
 533
 534                         ret = enc ?
 535                                 crypto_ablkcipher_encrypt(req) :
 536                                 crypto_ablkcipher_decrypt(req);
 537
 538                         switch (ret) {
 539                         case 0:
 540                                 break;
 541                         case -EINPROGRESS:
 542                         case -EBUSY:
 543                                 ret = wait_for_completion_interruptible(
 544                                         &result.completion);
 545                                 if (!ret && !((ret = result.err))) {
 546                                         INIT_COMPLETION(result.completion);
 547                                         break;
 548                                 }
 549                                 /* fall through */
 550                         default:
 551                                 printk("%s () failed err=%d\n", e, -ret);
 552                                 goto out;
 553                         }
 554
 555                         q = kmap(sg_page(&sg[0])) + sg[0].offset;
 556                         hexdump(q, cipher_tv->rlen);
 557
 558                         printk("%s\n",
 559                                memcmp(q, cipher_tv->result,
 560                                       cipher_tv->rlen) ? "fail" : "pass");
 561                 }
 562         }
 563
 564         printk("\ntesting %s %s across pages (chunking)\n", algo, e);
 565         memset(xbuf, 0, XBUFSIZE);
 566
 567         j = 0;
 568         for (i = 0; i < tcount; i++) {
 569                 memcpy(cipher_tv, &template[i], tsize);
 570                 if (cipher_tv->np) {
 571                         j++;
 572                         printk("test %u (%d bit key):\n",
 573                         j, cipher_tv->klen * 8);
 574
 575                         crypto_ablkcipher_clear_flags(tfm, ~0);
 576                         if (cipher_tv->wk)
 577                                 crypto_ablkcipher_set_flags(
 578                                         tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 579                         key = cipher_tv->key;
 580
 581                         ret = crypto_ablkcipher_setkey(tfm, key,
 582                                                        cipher_tv->klen);
 583                         if (ret) {
 584                                 printk("setkey() failed flags=%x\n",
 585                                        crypto_ablkcipher_get_flags(tfm));
 586
 587                                 if (!cipher_tv->fail)
 588                                         goto out;
 589                         }
 590
 591                         temp = 0;
 592                         sg_init_table(sg, cipher_tv->np);
 593                         for (k = 0; k < cipher_tv->np; k++) {
 594                                 memcpy(&xbuf[IDX[k]],
 595                                        cipher_tv->input + temp,
 596                                        cipher_tv->tap[k]);
 597                                 temp += cipher_tv->tap[k];
 598                                 sg_set_buf(&sg[k], &xbuf[IDX[k]],
 599                                            cipher_tv->tap[k]);
 600                         }
 601
 602                         ablkcipher_request_set_crypt(req, sg, sg,
 603                                                      cipher_tv->ilen,
 604                                                      cipher_tv->iv);
 605
 606                         ret = enc ?
 607                                 crypto_ablkcipher_encrypt(req) :
 608                                 crypto_ablkcipher_decrypt(req);
 609
 610                         switch (ret) {
 611                         case 0:
 612                                 break;
 613                         case -EINPROGRESS:
 614                         case -EBUSY:
 615                                 ret = wait_for_completion_interruptible(
 616                                         &result.completion);
 617                                 if (!ret && !((ret = result.err))) {
 618                                         INIT_COMPLETION(result.completion);
 619                                         break;
 620                                 }
 621                                 /* fall through */
 622                         default:
 623                                 printk("%s () failed err=%d\n", e, -ret);
 624                                 goto out;
 625                         }
 626
 627                         temp = 0;
 628                         for (k = 0; k < cipher_tv->np; k++) {
 629                                 printk("page %u\n", k);
 630                                 q = kmap(sg_page(&sg[k])) + sg[k].offset;
 631                                 hexdump(q, cipher_tv->tap[k]);
 632                                 printk("%s\n",
 633                                         memcmp(q, cipher_tv->result + temp,
 634                                                 cipher_tv->tap[k]) ? "fail" :
 635                                         "pass");
 636                                 temp += cipher_tv->tap[k];
 637                         }
 638                 }
 639         }
 640
 641 out:
 642         crypto_free_ablkcipher(tfm);
 643         ablkcipher_request_free(req);
 644 }
 645
 646 static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc, char *p,
 647                                int blen, int sec)
 648 {
 649         struct scatterlist sg[1];
 650         unsigned long start, end;
 651         int bcount;
 652         int ret;
 653
 654         sg_init_one(sg, p, blen);
 655
 656         for (start = jiffies, end = start + sec * HZ, bcount = 0;
 657              time_before(jiffies, end); bcount++) {
 658                 if (enc)
 659                         ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
 660                 else
 661                         ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
 662
 663                 if (ret)
 664                         return ret;
 665         }
 666
 667         printk("%d operations in %d seconds (%ld bytes)\n",
 668                bcount, sec, (long)bcount * blen);
 669         return 0;
 670 }
 671
 672 static int test_cipher_cycles(struct blkcipher_desc *desc, int enc, char *p,
 673                               int blen)
 674 {
 675         struct scatterlist sg[1];
 676         unsigned long cycles = 0;
 677         int ret = 0;
 678         int i;
 679
 680         sg_init_one(sg, p, blen);
 681
 682         local_bh_disable();
 683         local_irq_disable();
 684
 685         /* Warm-up run. */
 686         for (i = 0; i < 4; i++) {
 687                 if (enc)
 688                         ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
 689                 else
 690                         ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
 691
 692                 if (ret)
 693                         goto out;
 694         }
 695
 696         /* The real thing. */
 697         for (i = 0; i < 8; i++) {
 698                 cycles_t start, end;
 699
 700                 start = get_cycles();
 701                 if (enc)
 702                         ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
 703                 else
 704                         ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
 705                 end = get_cycles();
 706
 707                 if (ret)
 708                         goto out;
 709
 710                 cycles += end - start;
 711         }
 712
 713 out:
 714         local_irq_enable();
 715         local_bh_enable();
 716
 717         if (ret == 0)
 718                 printk("1 operation in %lu cycles (%d bytes)\n",
 719                        (cycles + 4) / 8, blen);
 720
 721         return ret;
 722 }
 723
 724 static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 };
 725
 726 static void test_cipher_speed(char *algo, int enc, unsigned int sec,
 727                               struct cipher_testvec *template,
 728                               unsigned int tcount, u8 *keysize)
 729 {
 730         unsigned int ret, i, j, iv_len;
 731         unsigned char *key, *p, iv[128];
 732         struct crypto_blkcipher *tfm;
 733         struct blkcipher_desc desc;
 734         const char *e;
 735         u32 *b_size;
 736
 737         if (enc == ENCRYPT)
 738                 e = "encryption";
 739         else
 740                 e = "decryption";
 741
 742         printk("\ntesting speed of %s %s\n", algo, e);
 743
 744         tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);
 745
 746         if (IS_ERR(tfm)) {
 747                 printk("failed to load transform for %s: %ld\n", algo,
 748                        PTR_ERR(tfm));
 749                 return;
 750         }
 751         desc.tfm = tfm;
 752         desc.flags = 0;
 753
 754         i = 0;
 755         do {
 756
 757                 b_size = block_sizes;
 758                 do {
 759
 760                         if ((*keysize + *b_size) > TVMEMSIZE) {
 761                                 printk("template (%u) too big for tvmem (%u)\n",
 762                                                 *keysize + *b_size, TVMEMSIZE);
 763                                 goto out;
 764                         }
 765
 766                         printk("test %u (%d bit key, %d byte blocks): ", i,
 767                                         *keysize * 8, *b_size);
 768
 769                         memset(tvmem, 0xff, *keysize + *b_size);
 770
 771                         /* set key, plain text and IV */
 772                         key = (unsigned char *)tvmem;
 773                         for (j = 0; j < tcount; j++) {
 774                                 if (template[j].klen == *keysize) {
 775                                         key = template[j].key;
 776                                         break;
 777                                 }
 778                         }
 779                         p = (unsigned char *)tvmem + *keysize;
 780
 781                         ret = crypto_blkcipher_setkey(tfm, key, *keysize);
 782                         if (ret) {
 783                                 printk("setkey() failed flags=%x\n",
 784                                                 crypto_blkcipher_get_flags(tfm));
 785                                 goto out;
 786                         }
 787
 788                         iv_len = crypto_blkcipher_ivsize(tfm);
 789                         if (iv_len) {
 790                                 memset(&iv, 0xff, iv_len);
 791                                 crypto_blkcipher_set_iv(tfm, iv, iv_len);
 792                         }
 793
 794                         if (sec)
 795                                 ret = test_cipher_jiffies(&desc, enc, p, *b_size, sec);
 796                         else
 797                                 ret = test_cipher_cycles(&desc, enc, p, *b_size);
 798
 799                         if (ret) {
 800                                 printk("%s() failed flags=%x\n", e, desc.flags);
 801                                 break;
 802                         }
 803                         b_size++;
 804                         i++;
 805                 } while (*b_size);
 806                 keysize++;
 807         } while (*keysize);
 808
 809 out:
 810         crypto_free_blkcipher(tfm);
 811 }
 812
 813 static int test_hash_jiffies_digest(struct hash_desc *desc, char *p, int blen,
 814                                     char *out, int sec)
 815 {
 816         struct scatterlist sg[1];
 817         unsigned long start, end;
 818         int bcount;
 819         int ret;
 820
 821         sg_init_table(sg, 1);
 822
 823         for (start = jiffies, end = start + sec * HZ, bcount = 0;
 824              time_before(jiffies, end); bcount++) {
 825                 sg_set_buf(sg, p, blen);
 826                 ret = crypto_hash_digest(desc, sg, blen, out);
 827                 if (ret)
 828                         return ret;
 829         }
 830
 831         printk("%6u opers/sec, %9lu bytes/sec\n",
 832                bcount / sec, ((long)bcount * blen) / sec);
 833
 834         return 0;
 835 }
 836
 837 static int test_hash_jiffies(struct hash_desc *desc, char *p, int blen,
 838                              int plen, char *out, int sec)
 839 {
 840         struct scatterlist sg[1];
 841         unsigned long start, end;
 842         int bcount, pcount;
 843         int ret;
 844
 845         if (plen == blen)
 846                 return test_hash_jiffies_digest(desc, p, blen, out, sec);
 847
 848         sg_init_table(sg, 1);
 849
 850         for (start = jiffies, end = start + sec * HZ, bcount = 0;
 851              time_before(jiffies, end); bcount++) {
 852                 ret = crypto_hash_init(desc);
 853                 if (ret)
 854                         return ret;
 855                 for (pcount = 0; pcount < blen; pcount += plen) {
 856                         sg_set_buf(sg, p + pcount, plen);
 857                         ret = crypto_hash_update(desc, sg, plen);
 858                         if (ret)
 859                                 return ret;
 860                 }
 861                 /* we assume there is enough space in 'out' for the result */
 862                 ret = crypto_hash_final(desc, out);
 863                 if (ret)
 864                         return ret;
 865         }
 866
 867         printk("%6u opers/sec, %9lu bytes/sec\n",
 868                bcount / sec, ((long)bcount * blen) / sec);
 869
 870         return 0;
 871 }
 872
 873 static int test_hash_cycles_digest(struct hash_desc *desc, char *p, int blen,
 874                                    char *out)
 875 {
 876         struct scatterlist sg[1];
 877         unsigned long cycles = 0;
 878         int i;
 879         int ret;
 880
 881         sg_init_table(sg, 1);
 882
 883         local_bh_disable();
 884         local_irq_disable();
 885
 886         /* Warm-up run. */
 887         for (i = 0; i < 4; i++) {
 888                 sg_set_buf(sg, p, blen);
 889                 ret = crypto_hash_digest(desc, sg, blen, out);
 890                 if (ret)
 891                         goto out;
 892         }
 893
 894         /* The real thing. */
 895         for (i = 0; i < 8; i++) {
 896                 cycles_t start, end;
 897
 898                 start = get_cycles();
 899
 900                 sg_set_buf(sg, p, blen);
 901                 ret = crypto_hash_digest(desc, sg, blen, out);
 902                 if (ret)
 903                         goto out;
 904
 905                 end = get_cycles();
 906
 907                 cycles += end - start;
 908         }
 909
 910 out:
 911         local_irq_enable();
 912         local_bh_enable();
 913
 914         if (ret)
 915                 return ret;
 916
 917         printk("%6lu cycles/operation, %4lu cycles/byte\n",
 918                cycles / 8, cycles / (8 * blen));
 919
 920         return 0;
 921 }
 922
 923 static int test_hash_cycles(struct hash_desc *desc, char *p, int blen,
 924                             int plen, char *out)
 925 {
 926         struct scatterlist sg[1];
 927         unsigned long cycles = 0;
 928         int i, pcount;
 929         int ret;
 930
 931         if (plen == blen)
 932                 return test_hash_cycles_digest(desc, p, blen, out);
 933
 934         sg_init_table(sg, 1);
 935
 936         local_bh_disable();
 937         local_irq_disable();
 938
 939         /* Warm-up run. */
 940         for (i = 0; i < 4; i++) {
 941                 ret = crypto_hash_init(desc);
 942                 if (ret)
 943                         goto out;
 944                 for (pcount = 0; pcount < blen; pcount += plen) {
 945                         sg_set_buf(sg, p + pcount, plen);
 946                         ret = crypto_hash_update(desc, sg, plen);
 947                         if (ret)
 948                                 goto out;
 949                 }
 950                 ret = crypto_hash_final(desc, out);
 951                 if (ret)
 952                         goto out;
 953         }
 954
 955         /* The real thing. */
 956         for (i = 0; i < 8; i++) {
 957                 cycles_t start, end;
 958
 959                 start = get_cycles();
 960
 961                 ret = crypto_hash_init(desc);
 962                 if (ret)
 963                         goto out;
 964                 for (pcount = 0; pcount < blen; pcount += plen) {
 965                         sg_set_buf(sg, p + pcount, plen);
 966                         ret = crypto_hash_update(desc, sg, plen);
 967                         if (ret)
 968                                 goto out;
 969                 }
 970                 ret = crypto_hash_final(desc, out);
 971                 if (ret)
 972                         goto out;
 973
 974                 end = get_cycles();
 975
 976                 cycles += end - start;
 977         }
 978
 979 out:
 980         local_irq_enable();
 981         local_bh_enable();
 982
 983         if (ret)
 984                 return ret;
 985
 986         printk("%6lu cycles/operation, %4lu cycles/byte\n",
 987                cycles / 8, cycles / (8 * blen));
 988
 989         return 0;
 990 }
 991
 992 static void test_hash_speed(char *algo, unsigned int sec,
 993                               struct hash_speed *speed)
 994 {
 995         struct crypto_hash *tfm;
 996         struct hash_desc desc;
 997         char output[1024];
 998         int i;
 999         int ret;
1000
1001         printk("\ntesting speed of %s\n", algo);
1002
1003         tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
1004
1005         if (IS_ERR(tfm)) {
1006                 printk("failed to load transform for %s: %ld\n", algo,
1007                        PTR_ERR(tfm));
1008                 return;
1009         }
1010
1011         desc.tfm = tfm;
1012         desc.flags = 0;
1013
1014         if (crypto_hash_digestsize(tfm) > sizeof(output)) {
1015                 printk("digestsize(%u) > outputbuffer(%zu)\n",
1016                        crypto_hash_digestsize(tfm), sizeof(output));
1017                 goto out;
1018         }
1019
1020         for (i = 0; speed[i].blen != 0; i++) {
1021                 if (speed[i].blen > TVMEMSIZE) {
1022                         printk("template (%u) too big for tvmem (%u)\n",
1023                                speed[i].blen, TVMEMSIZE);
1024                         goto out;
1025                 }
1026
1027                 printk("test%3u (%5u byte blocks,%5u bytes per update,%4u updates): ",
1028                        i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
1029
1030                 memset(tvmem, 0xff, speed[i].blen);
1031
1032                 if (sec)
1033                         ret = test_hash_jiffies(&desc, tvmem, speed[i].blen,
1034                                                 speed[i].plen, output, sec);
1035                 else
1036                         ret = test_hash_cycles(&desc, tvmem, speed[i].blen,
1037                                                speed[i].plen, output);
1038
1039                 if (ret) {
1040                         printk("hashing failed ret=%d\n", ret);
1041                         break;
1042                 }
1043         }
1044
1045 out:
1046         crypto_free_hash(tfm);
1047 }
1048
1049 static void test_comp(char *algo, struct comp_testvec *ctemplate,
1050                        struct comp_testvec *dtemplate, int ctcount, int dtcount)
1051 {
1052         unsigned int i;
1053         char result[COMP_BUF_SIZE];
1054         struct crypto_comp *tfm;
1055         struct comp_testvec *tv;
1056         unsigned int tsize;
1057
1058         printk("\ntesting %s compression\n", algo);
1059
1060         tsize = sizeof(struct comp_testvec);
1061         tsize *= ctcount;
1062         if (tsize > TVMEMSIZE) {
1063                 printk("template (%u) too big for tvmem (%u)\n", tsize,
1064                        TVMEMSIZE);
1065                 return;
1066         }
1067
1068         memcpy(tvmem, ctemplate, tsize);
1069         tv = (void *)tvmem;
1070
1071         tfm = crypto_alloc_comp(algo, 0, CRYPTO_ALG_ASYNC);
1072         if (IS_ERR(tfm)) {
1073                 printk("failed to load transform for %s\n", algo);
1074                 return;
1075         }
1076
1077         for (i = 0; i < ctcount; i++) {
1078                 int ilen, ret, dlen = COMP_BUF_SIZE;
1079
1080                 printk("test %u:\n", i + 1);
1081                 memset(result, 0, sizeof (result));
1082
1083                 ilen = tv[i].inlen;
1084                 ret = crypto_comp_compress(tfm, tv[i].input,
1085                                            ilen, result, &dlen);
1086                 if (ret) {
1087                         printk("fail: ret=%d\n", ret);
1088                         continue;
1089                 }
1090                 hexdump(result, dlen);
1091                 printk("%s (ratio %d:%d)\n",
1092                        memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
1093                        ilen, dlen);
1094         }
1095
1096         printk("\ntesting %s decompression\n", algo);
1097
1098         tsize = sizeof(struct comp_testvec);
1099         tsize *= dtcount;
1100         if (tsize > TVMEMSIZE) {
1101                 printk("template (%u) too big for tvmem (%u)\n", tsize,
1102                        TVMEMSIZE);
1103                 goto out;
1104         }
1105
1106         memcpy(tvmem, dtemplate, tsize);
1107         tv = (void *)tvmem;
1108
1109         for (i = 0; i < dtcount; i++) {
1110                 int ilen, ret, dlen = COMP_BUF_SIZE;
1111
1112                 printk("test %u:\n", i + 1);
1113                 memset(result, 0, sizeof (result));
1114
1115                 ilen = tv[i].inlen;
1116                 ret = crypto_comp_decompress(tfm, tv[i].input,
1117                                              ilen, result, &dlen);
1118                 if (ret) {
1119                         printk("fail: ret=%d\n", ret);
1120                         continue;
1121                 }
1122                 hexdump(result, dlen);
1123                 printk("%s (ratio %d:%d)\n",
1124                        memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
1125                        ilen, dlen);
1126         }
1127 out:
1128         crypto_free_comp(tfm);
1129 }
1130
1131 static void test_available(void)
1132 {
1133         char **name = check;
1134
1135         while (*name) {
1136                 printk("alg %s ", *name);
1137                 printk(crypto_has_alg(*name, 0, 0) ?
1138                        "found\n" : "not found\n");
1139                 name++;
1140         }
1141 }
1142
1143 static void do_test(void)
1144 {
1145         switch (mode) {
1146
1147         case 0:
1148                 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
1149
1150                 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
1151
1152                 //DES
1153                 test_cipher("ecb(des)", ENCRYPT, des_enc_tv_template,
1154                             DES_ENC_TEST_VECTORS);
1155                 test_cipher("ecb(des)", DECRYPT, des_dec_tv_template,
1156                             DES_DEC_TEST_VECTORS);
1157                 test_cipher("cbc(des)", ENCRYPT, des_cbc_enc_tv_template,
1158                             DES_CBC_ENC_TEST_VECTORS);
1159                 test_cipher("cbc(des)", DECRYPT, des_cbc_dec_tv_template,
1160                             DES_CBC_DEC_TEST_VECTORS);
1161
1162                 //DES3_EDE
1163                 test_cipher("ecb(des3_ede)", ENCRYPT, des3_ede_enc_tv_template,
1164                             DES3_EDE_ENC_TEST_VECTORS);
1165                 test_cipher("ecb(des3_ede)", DECRYPT, des3_ede_dec_tv_template,
1166                             DES3_EDE_DEC_TEST_VECTORS);
1167
1168                 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
1169
1170                 test_hash("sha224", sha224_tv_template, SHA224_TEST_VECTORS);
1171
1172                 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
1173
1174                 //BLOWFISH
1175                 test_cipher("ecb(blowfish)", ENCRYPT, bf_enc_tv_template,
1176                             BF_ENC_TEST_VECTORS);
1177                 test_cipher("ecb(blowfish)", DECRYPT, bf_dec_tv_template,
1178                             BF_DEC_TEST_VECTORS);
1179                 test_cipher("cbc(blowfish)", ENCRYPT, bf_cbc_enc_tv_template,
1180                             BF_CBC_ENC_TEST_VECTORS);
1181                 test_cipher("cbc(blowfish)", DECRYPT, bf_cbc_dec_tv_template,
1182                             BF_CBC_DEC_TEST_VECTORS);
1183
1184                 //TWOFISH
1185                 test_cipher("ecb(twofish)", ENCRYPT, tf_enc_tv_template,
1186                             TF_ENC_TEST_VECTORS);
1187                 test_cipher("ecb(twofish)", DECRYPT, tf_dec_tv_template,
1188                             TF_DEC_TEST_VECTORS);
1189                 test_cipher("cbc(twofish)", ENCRYPT, tf_cbc_enc_tv_template,
1190                             TF_CBC_ENC_TEST_VECTORS);
1191                 test_cipher("cbc(twofish)", DECRYPT, tf_cbc_dec_tv_template,
1192                             TF_CBC_DEC_TEST_VECTORS);
1193
1194                 //SERPENT
1195                 test_cipher("ecb(serpent)", ENCRYPT, serpent_enc_tv_template,
1196                             SERPENT_ENC_TEST_VECTORS);
1197                 test_cipher("ecb(serpent)", DECRYPT, serpent_dec_tv_template,
1198                             SERPENT_DEC_TEST_VECTORS);
1199
1200                 //TNEPRES
1201                 test_cipher("ecb(tnepres)", ENCRYPT, tnepres_enc_tv_template,
1202                             TNEPRES_ENC_TEST_VECTORS);
1203                 test_cipher("ecb(tnepres)", DECRYPT, tnepres_dec_tv_template,
1204                             TNEPRES_DEC_TEST_VECTORS);
1205
1206                 //AES
1207                 test_cipher("ecb(aes)", ENCRYPT, aes_enc_tv_template,
1208                             AES_ENC_TEST_VECTORS);
1209                 test_cipher("ecb(aes)", DECRYPT, aes_dec_tv_template,
1210                             AES_DEC_TEST_VECTORS);
1211                 test_cipher("cbc(aes)", ENCRYPT, aes_cbc_enc_tv_template,
1212                             AES_CBC_ENC_TEST_VECTORS);
1213                 test_cipher("cbc(aes)", DECRYPT, aes_cbc_dec_tv_template,
1214                             AES_CBC_DEC_TEST_VECTORS);
1215                 test_cipher("lrw(aes)", ENCRYPT, aes_lrw_enc_tv_template,
1216                             AES_LRW_ENC_TEST_VECTORS);
1217                 test_cipher("lrw(aes)", DECRYPT, aes_lrw_dec_tv_template,
1218                             AES_LRW_DEC_TEST_VECTORS);
1219                 test_cipher("xts(aes)", ENCRYPT, aes_xts_enc_tv_template,
1220                             AES_XTS_ENC_TEST_VECTORS);
1221                 test_cipher("xts(aes)", DECRYPT, aes_xts_dec_tv_template,
1222                             AES_XTS_DEC_TEST_VECTORS);
1223                 test_cipher("rfc3686(ctr(aes))", ENCRYPT, aes_ctr_enc_tv_template,
1224                             AES_CTR_ENC_TEST_VECTORS);
1225                 test_cipher("rfc3686(ctr(aes))", DECRYPT, aes_ctr_dec_tv_template,
1226                             AES_CTR_DEC_TEST_VECTORS);
1227                 test_aead("gcm(aes)", ENCRYPT, aes_gcm_enc_tv_template,
1228                           AES_GCM_ENC_TEST_VECTORS);
1229                 test_aead("gcm(aes)", DECRYPT, aes_gcm_dec_tv_template,
1230                           AES_GCM_DEC_TEST_VECTORS);
1231                 test_aead("ccm(aes)", ENCRYPT, aes_ccm_enc_tv_template,
1232                           AES_CCM_ENC_TEST_VECTORS);
1233                 test_aead("ccm(aes)", DECRYPT, aes_ccm_dec_tv_template,
1234                           AES_CCM_DEC_TEST_VECTORS);
1235
1236                 //CAST5
1237                 test_cipher("ecb(cast5)", ENCRYPT, cast5_enc_tv_template,
1238                             CAST5_ENC_TEST_VECTORS);
1239                 test_cipher("ecb(cast5)", DECRYPT, cast5_dec_tv_template,
1240                             CAST5_DEC_TEST_VECTORS);
1241
1242                 //CAST6
1243                 test_cipher("ecb(cast6)", ENCRYPT, cast6_enc_tv_template,
1244                             CAST6_ENC_TEST_VECTORS);
1245                 test_cipher("ecb(cast6)", DECRYPT, cast6_dec_tv_template,
1246                             CAST6_DEC_TEST_VECTORS);
1247
1248                 //ARC4
1249                 test_cipher("ecb(arc4)", ENCRYPT, arc4_enc_tv_template,
1250                             ARC4_ENC_TEST_VECTORS);
1251                 test_cipher("ecb(arc4)", DECRYPT, arc4_dec_tv_template,
1252                             ARC4_DEC_TEST_VECTORS);
1253
1254                 //TEA
1255                 test_cipher("ecb(tea)", ENCRYPT, tea_enc_tv_template,
1256                             TEA_ENC_TEST_VECTORS);
1257                 test_cipher("ecb(tea)", DECRYPT, tea_dec_tv_template,
1258                             TEA_DEC_TEST_VECTORS);
1259
1260
1261                 //XTEA
1262                 test_cipher("ecb(xtea)", ENCRYPT, xtea_enc_tv_template,
1263                             XTEA_ENC_TEST_VECTORS);
1264                 test_cipher("ecb(xtea)", DECRYPT, xtea_dec_tv_template,
1265                             XTEA_DEC_TEST_VECTORS);
1266
1267                 //KHAZAD
1268                 test_cipher("ecb(khazad)", ENCRYPT, khazad_enc_tv_template,
1269                             KHAZAD_ENC_TEST_VECTORS);
1270                 test_cipher("ecb(khazad)", DECRYPT, khazad_dec_tv_template,
1271                             KHAZAD_DEC_TEST_VECTORS);
1272
1273                 //ANUBIS
1274                 test_cipher("ecb(anubis)", ENCRYPT, anubis_enc_tv_template,
1275                             ANUBIS_ENC_TEST_VECTORS);
1276                 test_cipher("ecb(anubis)", DECRYPT, anubis_dec_tv_template,
1277                             ANUBIS_DEC_TEST_VECTORS);
1278                 test_cipher("cbc(anubis)", ENCRYPT, anubis_cbc_enc_tv_template,
1279                             ANUBIS_CBC_ENC_TEST_VECTORS);
1280                 test_cipher("cbc(anubis)", DECRYPT, anubis_cbc_dec_tv_template,
1281                             ANUBIS_CBC_ENC_TEST_VECTORS);
1282
1283                 //XETA
1284                 test_cipher("ecb(xeta)", ENCRYPT, xeta_enc_tv_template,
1285                             XETA_ENC_TEST_VECTORS);
1286                 test_cipher("ecb(xeta)", DECRYPT, xeta_dec_tv_template,
1287                             XETA_DEC_TEST_VECTORS);
1288
1289                 //FCrypt
1290                 test_cipher("pcbc(fcrypt)", ENCRYPT, fcrypt_pcbc_enc_tv_template,
1291                             FCRYPT_ENC_TEST_VECTORS);
1292                 test_cipher("pcbc(fcrypt)", DECRYPT, fcrypt_pcbc_dec_tv_template,
1293                             FCRYPT_DEC_TEST_VECTORS);
1294
1295                 //CAMELLIA
1296                 test_cipher("ecb(camellia)", ENCRYPT,
1297                             camellia_enc_tv_template,
1298                             CAMELLIA_ENC_TEST_VECTORS);
1299                 test_cipher("ecb(camellia)", DECRYPT,
1300                             camellia_dec_tv_template,
1301                             CAMELLIA_DEC_TEST_VECTORS);
1302                 test_cipher("cbc(camellia)", ENCRYPT,
1303                             camellia_cbc_enc_tv_template,
1304                             CAMELLIA_CBC_ENC_TEST_VECTORS);
1305                 test_cipher("cbc(camellia)", DECRYPT,
1306                             camellia_cbc_dec_tv_template,
1307                             CAMELLIA_CBC_DEC_TEST_VECTORS);
1308
1309                 //SEED
1310                 test_cipher("ecb(seed)", ENCRYPT, seed_enc_tv_template,
1311                             SEED_ENC_TEST_VECTORS);
1312                 test_cipher("ecb(seed)", DECRYPT, seed_dec_tv_template,
1313                             SEED_DEC_TEST_VECTORS);
1314
1315                 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
1316                 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
1317                 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
1318                 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
1319                 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
1320                 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
1321                 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
1322                 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
1323                 test_comp("deflate", deflate_comp_tv_template,
1324                           deflate_decomp_tv_template, DEFLATE_COMP_TEST_VECTORS,
1325                           DEFLATE_DECOMP_TEST_VECTORS);
1326                 test_comp("lzo", lzo_comp_tv_template, lzo_decomp_tv_template,
1327                           LZO_COMP_TEST_VECTORS, LZO_DECOMP_TEST_VECTORS);
1328                 test_hash("crc32c", crc32c_tv_template, CRC32C_TEST_VECTORS);
1329                 test_hash("hmac(md5)", hmac_md5_tv_template,
1330                           HMAC_MD5_TEST_VECTORS);
1331                 test_hash("hmac(sha1)", hmac_sha1_tv_template,
1332                           HMAC_SHA1_TEST_VECTORS);
1333                 test_hash("hmac(sha224)", hmac_sha224_tv_template,
1334                           HMAC_SHA224_TEST_VECTORS);
1335                 test_hash("hmac(sha256)", hmac_sha256_tv_template,
1336                           HMAC_SHA256_TEST_VECTORS);
1337                 test_hash("hmac(sha384)", hmac_sha384_tv_template,
1338                           HMAC_SHA384_TEST_VECTORS);
1339                 test_hash("hmac(sha512)", hmac_sha512_tv_template,
1340                           HMAC_SHA512_TEST_VECTORS);
1341
1342                 test_hash("xcbc(aes)", aes_xcbc128_tv_template,
1343                           XCBC_AES_TEST_VECTORS);
1344
1345                 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
1346                 break;
1347
1348         case 1:
1349                 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
1350                 break;
1351
1352         case 2:
1353                 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
1354                 break;
1355
1356         case 3:
1357                 test_cipher("ecb(des)", ENCRYPT, des_enc_tv_template,
1358                             DES_ENC_TEST_VECTORS);
1359                 test_cipher("ecb(des)", DECRYPT, des_dec_tv_template,
1360                             DES_DEC_TEST_VECTORS);
1361                 test_cipher("cbc(des)", ENCRYPT, des_cbc_enc_tv_template,
1362                             DES_CBC_ENC_TEST_VECTORS);
1363                 test_cipher("cbc(des)", DECRYPT, des_cbc_dec_tv_template,
1364                             DES_CBC_DEC_TEST_VECTORS);
1365                 break;
1366
1367         case 4:
1368                 test_cipher("ecb(des3_ede)", ENCRYPT, des3_ede_enc_tv_template,
1369                             DES3_EDE_ENC_TEST_VECTORS);
1370                 test_cipher("ecb(des3_ede)", DECRYPT, des3_ede_dec_tv_template,
1371                             DES3_EDE_DEC_TEST_VECTORS);
1372                 break;
1373
1374         case 5:
1375                 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
1376                 break;
1377
1378         case 6:
1379                 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
1380                 break;
1381
1382         case 7:
1383                 test_cipher("ecb(blowfish)", ENCRYPT, bf_enc_tv_template,
1384                             BF_ENC_TEST_VECTORS);
1385                 test_cipher("ecb(blowfish)", DECRYPT, bf_dec_tv_template,
1386                             BF_DEC_TEST_VECTORS);
1387                 test_cipher("cbc(blowfish)", ENCRYPT, bf_cbc_enc_tv_template,
1388                             BF_CBC_ENC_TEST_VECTORS);
1389                 test_cipher("cbc(blowfish)", DECRYPT, bf_cbc_dec_tv_template,
1390                             BF_CBC_DEC_TEST_VECTORS);
1391                 break;
1392
1393         case 8:
1394                 test_cipher("ecb(twofish)", ENCRYPT, tf_enc_tv_template,
1395                             TF_ENC_TEST_VECTORS);
1396                 test_cipher("ecb(twofish)", DECRYPT, tf_dec_tv_template,
1397                             TF_DEC_TEST_VECTORS);
1398                 test_cipher("cbc(twofish)", ENCRYPT, tf_cbc_enc_tv_template,
1399                             TF_CBC_ENC_TEST_VECTORS);
1400                 test_cipher("cbc(twofish)", DECRYPT, tf_cbc_dec_tv_template,
1401                             TF_CBC_DEC_TEST_VECTORS);
1402                 break;
1403
1404         case 9:
1405                 test_cipher("ecb(serpent)", ENCRYPT, serpent_enc_tv_template,
1406                             SERPENT_ENC_TEST_VECTORS);
1407                 test_cipher("ecb(serpent)", DECRYPT, serpent_dec_tv_template,
1408                             SERPENT_DEC_TEST_VECTORS);
1409                 break;
1410
1411         case 10:
1412                 test_cipher("ecb(aes)", ENCRYPT, aes_enc_tv_template,
1413                             AES_ENC_TEST_VECTORS);
1414                 test_cipher("ecb(aes)", DECRYPT, aes_dec_tv_template,
1415                             AES_DEC_TEST_VECTORS);
1416                 test_cipher("cbc(aes)", ENCRYPT, aes_cbc_enc_tv_template,
1417                             AES_CBC_ENC_TEST_VECTORS);
1418                 test_cipher("cbc(aes)", DECRYPT, aes_cbc_dec_tv_template,
1419                             AES_CBC_DEC_TEST_VECTORS);
1420                 test_cipher("lrw(aes)", ENCRYPT, aes_lrw_enc_tv_template,
1421                             AES_LRW_ENC_TEST_VECTORS);
1422                 test_cipher("lrw(aes)", DECRYPT, aes_lrw_dec_tv_template,
1423                             AES_LRW_DEC_TEST_VECTORS);
1424                 test_cipher("xts(aes)", ENCRYPT, aes_xts_enc_tv_template,
1425                             AES_XTS_ENC_TEST_VECTORS);
1426                 test_cipher("xts(aes)", DECRYPT, aes_xts_dec_tv_template,
1427                             AES_XTS_DEC_TEST_VECTORS);
1428                 test_cipher("rfc3686(ctr(aes))", ENCRYPT, aes_ctr_enc_tv_template,
1429                             AES_CTR_ENC_TEST_VECTORS);
1430                 test_cipher("rfc3686(ctr(aes))", DECRYPT, aes_ctr_dec_tv_template,
1431                             AES_CTR_DEC_TEST_VECTORS);
1432                 break;
1433
1434         case 11:
1435                 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
1436                 break;
1437
1438         case 12:
1439                 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
1440                 break;
1441
1442         case 13:
1443                 test_comp("deflate", deflate_comp_tv_template,
1444                           deflate_decomp_tv_template, DEFLATE_COMP_TEST_VECTORS,
1445                           DEFLATE_DECOMP_TEST_VECTORS);
1446                 break;
1447
1448         case 14:
1449                 test_cipher("ecb(cast5)", ENCRYPT, cast5_enc_tv_template,
1450                             CAST5_ENC_TEST_VECTORS);
1451                 test_cipher("ecb(cast5)", DECRYPT, cast5_dec_tv_template,
1452                             CAST5_DEC_TEST_VECTORS);
1453                 break;
1454
1455         case 15:
1456                 test_cipher("ecb(cast6)", ENCRYPT, cast6_enc_tv_template,
1457                             CAST6_ENC_TEST_VECTORS);
1458                 test_cipher("ecb(cast6)", DECRYPT, cast6_dec_tv_template,
1459                             CAST6_DEC_TEST_VECTORS);
1460                 break;
1461
1462         case 16:
1463                 test_cipher("ecb(arc4)", ENCRYPT, arc4_enc_tv_template,
1464                             ARC4_ENC_TEST_VECTORS);
1465                 test_cipher("ecb(arc4)", DECRYPT, arc4_dec_tv_template,
1466                             ARC4_DEC_TEST_VECTORS);
1467                 break;
1468
1469         case 17:
1470                 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
1471                 break;
1472
1473         case 18:
1474                 test_hash("crc32c", crc32c_tv_template, CRC32C_TEST_VECTORS);
1475                 break;
1476
1477         case 19:
1478                 test_cipher("ecb(tea)", ENCRYPT, tea_enc_tv_template,
1479                             TEA_ENC_TEST_VECTORS);
1480                 test_cipher("ecb(tea)", DECRYPT, tea_dec_tv_template,
1481                             TEA_DEC_TEST_VECTORS);
1482                 break;
1483
1484         case 20:
1485                 test_cipher("ecb(xtea)", ENCRYPT, xtea_enc_tv_template,
1486                             XTEA_ENC_TEST_VECTORS);
1487                 test_cipher("ecb(xtea)", DECRYPT, xtea_dec_tv_template,
1488                             XTEA_DEC_TEST_VECTORS);
1489                 break;
1490
1491         case 21:
1492                 test_cipher("ecb(khazad)", ENCRYPT, khazad_enc_tv_template,
1493                             KHAZAD_ENC_TEST_VECTORS);
1494                 test_cipher("ecb(khazad)", DECRYPT, khazad_dec_tv_template,
1495                             KHAZAD_DEC_TEST_VECTORS);
1496                 break;
1497
1498         case 22:
1499                 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
1500                 break;
1501
1502         case 23:
1503                 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
1504                 break;
1505
1506         case 24:
1507                 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
1508                 break;
1509
1510         case 25:
1511                 test_cipher("ecb(tnepres)", ENCRYPT, tnepres_enc_tv_template,
1512                             TNEPRES_ENC_TEST_VECTORS);
1513                 test_cipher("ecb(tnepres)", DECRYPT, tnepres_dec_tv_template,
1514                             TNEPRES_DEC_TEST_VECTORS);
1515                 break;
1516
1517         case 26:
1518                 test_cipher("ecb(anubis)", ENCRYPT, anubis_enc_tv_template,
1519                             ANUBIS_ENC_TEST_VECTORS);
1520                 test_cipher("ecb(anubis)", DECRYPT, anubis_dec_tv_template,
1521                             ANUBIS_DEC_TEST_VECTORS);
1522                 test_cipher("cbc(anubis)", ENCRYPT, anubis_cbc_enc_tv_template,
1523                             ANUBIS_CBC_ENC_TEST_VECTORS);
1524                 test_cipher("cbc(anubis)", DECRYPT, anubis_cbc_dec_tv_template,
1525                             ANUBIS_CBC_ENC_TEST_VECTORS);
1526                 break;
1527
1528         case 27:
1529                 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
1530                 break;
1531
1532         case 28:
1533
1534                 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
1535                 break;
1536
1537         case 29:
1538                 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
1539                 break;
1540
1541         case 30:
1542                 test_cipher("ecb(xeta)", ENCRYPT, xeta_enc_tv_template,
1543                             XETA_ENC_TEST_VECTORS);
1544                 test_cipher("ecb(xeta)", DECRYPT, xeta_dec_tv_template,
1545                             XETA_DEC_TEST_VECTORS);
1546                 break;
1547
1548         case 31:
1549                 test_cipher("pcbc(fcrypt)", ENCRYPT, fcrypt_pcbc_enc_tv_template,
1550                             FCRYPT_ENC_TEST_VECTORS);
1551                 test_cipher("pcbc(fcrypt)", DECRYPT, fcrypt_pcbc_dec_tv_template,
1552                             FCRYPT_DEC_TEST_VECTORS);
1553                 break;
1554
1555         case 32:
1556                 test_cipher("ecb(camellia)", ENCRYPT,
1557                             camellia_enc_tv_template,
1558                             CAMELLIA_ENC_TEST_VECTORS);
1559                 test_cipher("ecb(camellia)", DECRYPT,
1560                             camellia_dec_tv_template,
1561                             CAMELLIA_DEC_TEST_VECTORS);
1562                 test_cipher("cbc(camellia)", ENCRYPT,
1563                             camellia_cbc_enc_tv_template,
1564                             CAMELLIA_CBC_ENC_TEST_VECTORS);
1565                 test_cipher("cbc(camellia)", DECRYPT,
1566                             camellia_cbc_dec_tv_template,
1567                             CAMELLIA_CBC_DEC_TEST_VECTORS);
1568                 break;
1569         case 33:
1570                 test_hash("sha224", sha224_tv_template, SHA224_TEST_VECTORS);
1571                 break;
1572
1573         case 34:
1574                 test_cipher("salsa20", ENCRYPT,
1575                             salsa20_stream_enc_tv_template,
1576                             SALSA20_STREAM_ENC_TEST_VECTORS);
1577                 break;
1578
1579         case 35:
1580                 test_aead("gcm(aes)", ENCRYPT, aes_gcm_enc_tv_template,
1581                           AES_GCM_ENC_TEST_VECTORS);
1582                 test_aead("gcm(aes)", DECRYPT, aes_gcm_dec_tv_template,
1583                           AES_GCM_DEC_TEST_VECTORS);
1584                 break;
1585
1586         case 36:
1587                 test_comp("lzo", lzo_comp_tv_template, lzo_decomp_tv_template,
1588                           LZO_COMP_TEST_VECTORS, LZO_DECOMP_TEST_VECTORS);
1589                 break;
1590
1591         case 37:
1592                 test_aead("ccm(aes)", ENCRYPT, aes_ccm_enc_tv_template,
1593                           AES_CCM_ENC_TEST_VECTORS);
1594                 test_aead("ccm(aes)", DECRYPT, aes_ccm_dec_tv_template,
1595                           AES_CCM_DEC_TEST_VECTORS);
1596                 break;
1597
1598         case 100:
1599                 test_hash("hmac(md5)", hmac_md5_tv_template,
1600                           HMAC_MD5_TEST_VECTORS);
1601                 break;
1602
1603         case 101:
1604                 test_hash("hmac(sha1)", hmac_sha1_tv_template,
1605                           HMAC_SHA1_TEST_VECTORS);
1606                 break;
1607
1608         case 102:
1609                 test_hash("hmac(sha256)", hmac_sha256_tv_template,
1610                           HMAC_SHA256_TEST_VECTORS);
1611                 break;
1612
1613         case 103:
1614                 test_hash("hmac(sha384)", hmac_sha384_tv_template,
1615                           HMAC_SHA384_TEST_VECTORS);
1616                 break;
1617
1618         case 104:
1619                 test_hash("hmac(sha512)", hmac_sha512_tv_template,
1620                           HMAC_SHA512_TEST_VECTORS);
1621                 break;
1622
1623         case 105:
1624                 test_hash("hmac(sha224)", hmac_sha224_tv_template,
1625                           HMAC_SHA224_TEST_VECTORS);
1626                 break;
1627
1628         case 106:
1629                 test_hash("xcbc(aes)", aes_xcbc128_tv_template,
1630                           XCBC_AES_TEST_VECTORS);
1631                 break;
1632
1633         case 200:
1634                 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
1635                                 speed_template_16_24_32);
1636                 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
1637                                 speed_template_16_24_32);
1638                 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
1639                                 speed_template_16_24_32);
1640                 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
1641                                 speed_template_16_24_32);
1642                 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
1643                                 speed_template_32_40_48);
1644                 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
1645                                 speed_template_32_40_48);
1646                 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
1647                                 speed_template_32_48_64);
1648                 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
1649                                 speed_template_32_48_64);
1650                 break;
1651
1652         case 201:
1653                 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
1654                                 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1655                                 speed_template_24);
1656                 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
1657                                 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1658                                 speed_template_24);
1659                 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
1660                                 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1661                                 speed_template_24);
1662                 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
1663                                 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1664                                 speed_template_24);
1665                 break;
1666
1667         case 202:
1668                 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
1669                                 speed_template_16_24_32);
1670                 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
1671                                 speed_template_16_24_32);
1672                 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
1673                                 speed_template_16_24_32);
1674                 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
1675                                 speed_template_16_24_32);
1676                 break;
1677
1678         case 203:
1679                 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
1680                                   speed_template_8_32);
1681                 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
1682                                   speed_template_8_32);
1683                 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
1684                                   speed_template_8_32);
1685                 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
1686                                   speed_template_8_32);
1687                 break;
1688
1689         case 204:
1690                 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
1691                                   speed_template_8);
1692                 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
1693                                   speed_template_8);
1694                 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
1695                                   speed_template_8);
1696                 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
1697                                   speed_template_8);
1698                 break;
1699
1700         case 205:
1701                 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
1702                                 speed_template_16_24_32);
1703                 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
1704                                 speed_template_16_24_32);
1705                 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
1706                                 speed_template_16_24_32);
1707                 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
1708                                 speed_template_16_24_32);
1709                 break;
1710
1711         case 206:
1712                 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
1713                                   speed_template_16_32);
1714                 break;
1715
1716         case 300:
1717                 /* fall through */
1718
1719         case 301:
1720                 test_hash_speed("md4", sec, generic_hash_speed_template);
1721                 if (mode > 300 && mode < 400) break;
1722
1723         case 302:
1724                 test_hash_speed("md5", sec, generic_hash_speed_template);
1725                 if (mode > 300 && mode < 400) break;
1726
1727         case 303:
1728                 test_hash_speed("sha1", sec, generic_hash_speed_template);
1729                 if (mode > 300 && mode < 400) break;
1730
1731         case 304:
1732                 test_hash_speed("sha256", sec, generic_hash_speed_template);
1733                 if (mode > 300 && mode < 400) break;
1734
1735         case 305:
1736                 test_hash_speed("sha384", sec, generic_hash_speed_template);
1737                 if (mode > 300 && mode < 400) break;
1738
1739         case 306:
1740                 test_hash_speed("sha512", sec, generic_hash_speed_template);
1741                 if (mode > 300 && mode < 400) break;
1742
1743         case 307:
1744                 test_hash_speed("wp256", sec, generic_hash_speed_template);
1745                 if (mode > 300 && mode < 400) break;
1746
1747         case 308:
1748                 test_hash_speed("wp384", sec, generic_hash_speed_template);
1749                 if (mode > 300 && mode < 400) break;
1750
1751         case 309:
1752                 test_hash_speed("wp512", sec, generic_hash_speed_template);
1753                 if (mode > 300 && mode < 400) break;
1754
1755         case 310:
1756                 test_hash_speed("tgr128", sec, generic_hash_speed_template);
1757                 if (mode > 300 && mode < 400) break;
1758
1759         case 311:
1760                 test_hash_speed("tgr160", sec, generic_hash_speed_template);
1761                 if (mode > 300 && mode < 400) break;
1762
1763         case 312:
1764                 test_hash_speed("tgr192", sec, generic_hash_speed_template);
1765                 if (mode > 300 && mode < 400) break;
1766
1767         case 313:
1768                 test_hash_speed("sha224", sec, generic_hash_speed_template);
1769                 if (mode > 300 && mode < 400) break;
1770
1771         case 399:
1772                 break;
1773
1774         case 1000:
1775                 test_available();
1776                 break;
1777
1778         default:
1779                 /* useful for debugging */
1780                 printk("not testing anything\n");
1781                 break;
1782         }
1783 }
1784
1785 static int __init init(void)
1786 {
1787         int err = -ENOMEM;
1788
1789         tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL);
1790         if (tvmem == NULL)
1791                 return err;
1792
1793         xbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
1794         if (xbuf == NULL)
1795                 goto err_free_tv;
1796
1797         axbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
1798         if (axbuf == NULL)
1799                 goto err_free_xbuf;
1800
1801         do_test();
1802
1803         /* We intentionaly return -EAGAIN to prevent keeping
1804          * the module. It does all its work from init()
1805          * and doesn't offer any runtime functionality
1806          * => we don't need it in the memory, do we?
1807          *                                        -- mludvig
1808          */
1809         err = -EAGAIN;
1810
1811         kfree(axbuf);
1812  err_free_xbuf:
1813         kfree(xbuf);
1814  err_free_tv:
1815         kfree(tvmem);
1816
1817         return err;
1818 }
1819
1820 /*
1821  * If an init function is provided, an exit function must also be provided
1822  * to allow module unload.
1823  */
1824 static void __exit fini(void) { }
1825
1826 module_init(init);
1827 module_exit(fini);
1828
1829 module_param(mode, int, 0);
1830 module_param(sec, uint, 0);
1831 MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
1832                       "(defaults to zero which uses CPU cycles instead)");
1833
1834 MODULE_LICENSE("GPL");
1835 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
1836 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");