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