crypto/tcrypt.c

   1 /*
   2  * Quick & dirty crypto testing module.
   3  *
   4  * This will only exist until we have a better testing mechanism
   5  * (e.g. a char device).
   6  *
   7  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
   8  * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
   9  *
  10  * This program is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU General Public License as published by the Free
  12  * Software Foundation; either version 2 of the License, or (at your option)
  13  * any later version.
  14  *
  15  * 14 - 09 - 2003
  16  *      Rewritten by Kartikey Mahendra Bhatt
  17  */
  18
  19 #include <linux/init.h>
  20 #include <linux/module.h>
  21 #include <linux/mm.h>
  22 #include <linux/slab.h>
  23 #include <asm/scatterlist.h>
  24 #include <linux/string.h>
  25 #include <linux/crypto.h>
  26 #include <linux/highmem.h>
  27 #include <linux/moduleparam.h>
  28 #include "tcrypt.h"
  29
  30 /*
  31  * Need to kmalloc() memory for testing kmap().
  32  */
  33 #define TVMEMSIZE       4096
  34 #define XBUFSIZE        32768
  35
  36 /*
  37  * Indexes into the xbuf to simulate cross-page access.
  38  */
  39 #define IDX1            37
  40 #define IDX2            32400
  41 #define IDX3            1
  42 #define IDX4            8193
  43 #define IDX5            22222
  44 #define IDX6            17101
  45 #define IDX7            27333
  46 #define IDX8            3000
  47
  48 /*
  49 * Used by test_cipher()
  50 */
  51 #define ENCRYPT 1
  52 #define DECRYPT 0
  53 #define MODE_ECB 1
  54 #define MODE_CBC 0
  55
  56 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
  57
  58 static int mode;
  59 static char *xbuf;
  60 static char *tvmem;
  61
  62 static char *check[] = {
  63         "des", "md5", "des3_ede", "rot13", "sha1", "sha256", "blowfish",
  64         "twofish", "serpent", "sha384", "sha512", "md4", "aes", "cast6",
  65         "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
  66         "khazad", "wp512", "wp384", "wp256", "tnepres", NULL
  67 };
  68
  69 static void
  70 hexdump(unsigned char *buf, unsigned int len)
  71 {
  72         while (len--)
  73                 printk("%02x", *buf++);
  74
  75         printk("\n");
  76 }
  77
  78 static void
  79 test_hash (char * algo, struct hash_testvec * template, unsigned int tcount)
  80 {
  81         char *p;
  82         unsigned int i, j, k, temp;
  83         struct scatterlist sg[8];
  84         char result[64];
  85         struct crypto_tfm *tfm;
  86         struct hash_testvec *hash_tv;
  87         unsigned int tsize;
  88
  89         printk("\ntesting %s\n", algo);
  90
  91         tsize = sizeof (struct hash_testvec);
  92         tsize *= tcount;
  93
  94         if (tsize > TVMEMSIZE) {
  95                 printk("template (%u) too big for tvmem (%u)\n", tsize, TVMEMSIZE);
  96                 return;
  97         }
  98
  99         memcpy(tvmem, template, tsize);
 100         hash_tv = (void *) tvmem;
 101         tfm = crypto_alloc_tfm(algo, 0);
 102         if (tfm == NULL) {
 103                 printk("failed to load transform for %s\n", algo);
 104                 return;
 105         }
 106
 107         for (i = 0; i < tcount; i++) {
 108                 printk ("test %u:\n", i + 1);
 109                 memset (result, 0, 64);
 110
 111                 p = hash_tv[i].plaintext;
 112                 sg[0].page = virt_to_page (p);
 113                 sg[0].offset = offset_in_page (p);
 114                 sg[0].length = hash_tv[i].psize;
 115
 116                 crypto_digest_init (tfm);
 117                 if (tfm->crt_u.digest.dit_setkey) {
 118                         crypto_digest_setkey (tfm, hash_tv[i].key,
 119                                               hash_tv[i].ksize);
 120                 }
 121                 crypto_digest_update (tfm, sg, 1);
 122                 crypto_digest_final (tfm, result);
 123
 124                 hexdump (result, crypto_tfm_alg_digestsize (tfm));
 125                 printk("%s\n",
 126                         memcmp(result, hash_tv[i].digest,
 127                                 crypto_tfm_alg_digestsize(tfm)) ? "fail" :
 128                         "pass");
 129         }
 130
 131         printk ("testing %s across pages\n", algo);
 132
 133         /* setup the dummy buffer first */
 134         memset(xbuf, 0, XBUFSIZE);
 135
 136         j = 0;
 137         for (i = 0; i < tcount; i++) {
 138                 if (hash_tv[i].np) {
 139                         j++;
 140                         printk ("test %u:\n", j);
 141                         memset (result, 0, 64);
 142
 143                         temp = 0;
 144                         for (k = 0; k < hash_tv[i].np; k++) {
 145                                 memcpy (&xbuf[IDX[k]], hash_tv[i].plaintext + temp,
 146                                                 hash_tv[i].tap[k]);
 147                                 temp += hash_tv[i].tap[k];
 148                                 p = &xbuf[IDX[k]];
 149                                 sg[k].page = virt_to_page (p);
 150                                 sg[k].offset = offset_in_page (p);
 151                                 sg[k].length = hash_tv[i].tap[k];
 152                         }
 153
 154                         crypto_digest_digest (tfm, sg, hash_tv[i].np, result);
 155
 156                         hexdump (result, crypto_tfm_alg_digestsize (tfm));
 157                         printk("%s\n",
 158                                 memcmp(result, hash_tv[i].digest,
 159                                         crypto_tfm_alg_digestsize(tfm)) ? "fail" :
 160                                 "pass");
 161                 }
 162         }
 163
 164         crypto_free_tfm (tfm);
 165 }
 166
 167
 168 #ifdef CONFIG_CRYPTO_HMAC
 169
 170 static void
 171 test_hmac(char *algo, struct hmac_testvec * template, unsigned int tcount)
 172 {
 173         char *p;
 174         unsigned int i, j, k, temp;
 175         struct scatterlist sg[8];
 176         char result[64];
 177         struct crypto_tfm *tfm;
 178         struct hmac_testvec *hmac_tv;
 179         unsigned int tsize, klen;
 180
 181         tfm = crypto_alloc_tfm(algo, 0);
 182         if (tfm == NULL) {
 183                 printk("failed to load transform for %s\n", algo);
 184                 return;
 185         }
 186
 187         printk("\ntesting hmac_%s\n", algo);
 188
 189         tsize = sizeof (struct hmac_testvec);
 190         tsize *= tcount;
 191         if (tsize > TVMEMSIZE) {
 192                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 193                        TVMEMSIZE);
 194                 goto out;
 195         }
 196
 197         memcpy(tvmem, template, tsize);
 198         hmac_tv = (void *) tvmem;
 199
 200         for (i = 0; i < tcount; i++) {
 201                 printk("test %u:\n", i + 1);
 202                 memset(result, 0, sizeof (result));
 203
 204                 p = hmac_tv[i].plaintext;
 205                 klen = hmac_tv[i].ksize;
 206                 sg[0].page = virt_to_page(p);
 207                 sg[0].offset = offset_in_page(p);
 208                 sg[0].length = hmac_tv[i].psize;
 209
 210                 crypto_hmac(tfm, hmac_tv[i].key, &klen, sg, 1, result);
 211
 212                 hexdump(result, crypto_tfm_alg_digestsize(tfm));
 213                 printk("%s\n",
 214                        memcmp(result, hmac_tv[i].digest,
 215                               crypto_tfm_alg_digestsize(tfm)) ? "fail" :
 216                        "pass");
 217         }
 218
 219         printk("\ntesting hmac_%s across pages\n", algo);
 220
 221         memset(xbuf, 0, XBUFSIZE);
 222
 223         j = 0;
 224         for (i = 0; i < tcount; i++) {
 225                 if (hmac_tv[i].np) {
 226                         j++;
 227                         printk ("test %u:\n",j);
 228                         memset (result, 0, 64);
 229
 230                         temp = 0;
 231                         klen = hmac_tv[i].ksize;
 232                         for (k = 0; k < hmac_tv[i].np; k++) {
 233                                 memcpy (&xbuf[IDX[k]], hmac_tv[i].plaintext + temp,
 234                                                 hmac_tv[i].tap[k]);
 235                                 temp += hmac_tv[i].tap[k];
 236                                 p = &xbuf[IDX[k]];
 237                                 sg[k].page = virt_to_page (p);
 238                                 sg[k].offset = offset_in_page (p);
 239                                 sg[k].length = hmac_tv[i].tap[k];
 240                         }
 241
 242                         crypto_hmac(tfm, hmac_tv[i].key, &klen, sg, hmac_tv[i].np,
 243                                         result);
 244                         hexdump(result, crypto_tfm_alg_digestsize(tfm));
 245
 246                         printk("%s\n",
 247                                 memcmp(result, hmac_tv[i].digest,
 248                                         crypto_tfm_alg_digestsize(tfm)) ? "fail" :
 249                                 "pass");
 250                 }
 251         }
 252 out:
 253         crypto_free_tfm(tfm);
 254 }
 255
 256 #endif  /* CONFIG_CRYPTO_HMAC */
 257
 258 static void
 259 test_cipher(char * algo, int mode, int enc, struct cipher_testvec * template, unsigned int tcount)
 260 {
 261         unsigned int ret, i, j, k, temp;
 262         unsigned int tsize;
 263         char *p, *q;
 264         struct crypto_tfm *tfm;
 265         char *key;
 266         struct cipher_testvec *cipher_tv;
 267         struct scatterlist sg[8];
 268         char e[11], m[4];
 269
 270         if (enc == ENCRYPT)
 271                 strncpy(e, "encryption", 11);
 272         else
 273                 strncpy(e, "decryption", 11);
 274         if (mode == MODE_ECB)
 275                 strncpy(m, "ECB", 4);
 276         else
 277                 strncpy(m, "CBC", 4);
 278
 279         printk("\ntesting %s %s %s \n", algo, m, e);
 280
 281         tsize = sizeof (struct cipher_testvec);
 282         tsize *= tcount;
 283
 284         if (tsize > TVMEMSIZE) {
 285                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 286                        TVMEMSIZE);
 287                 return;
 288         }
 289
 290         memcpy(tvmem, template, tsize);
 291         cipher_tv = (void *) tvmem;
 292
 293         if (mode)
 294                 tfm = crypto_alloc_tfm (algo, 0);
 295         else
 296                 tfm = crypto_alloc_tfm (algo, CRYPTO_TFM_MODE_CBC);
 297
 298         if (tfm == NULL) {
 299                 printk("failed to load transform for %s %s\n", algo, m);
 300                 return;
 301         }
 302
 303         j = 0;
 304         for (i = 0; i < tcount; i++) {
 305                 if (!(cipher_tv[i].np)) {
 306                         j++;
 307                         printk("test %u (%d bit key):\n",
 308                         j, cipher_tv[i].klen * 8);
 309
 310                         tfm->crt_flags = 0;
 311                         if (cipher_tv[i].wk)
 312                                 tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY;
 313                         key = cipher_tv[i].key;
 314
 315                         ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen);
 316                         if (ret) {
 317                                 printk("setkey() failed flags=%x\n", tfm->crt_flags);
 318
 319                                 if (!cipher_tv[i].fail)
 320                                         goto out;
 321                         }
 322
 323                         p = cipher_tv[i].input;
 324                         sg[0].page = virt_to_page(p);
 325                         sg[0].offset = offset_in_page(p);
 326                         sg[0].length = cipher_tv[i].ilen;
 327
 328                         if (!mode) {
 329                                 crypto_cipher_set_iv(tfm, cipher_tv[i].iv,
 330                                         crypto_tfm_alg_ivsize (tfm));
 331                         }
 332
 333                         if (enc)
 334                                 ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen);
 335                         else
 336                                 ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen);
 337
 338
 339                         if (ret) {
 340                                 printk("%s () failed flags=%x\n", e, tfm->crt_flags);
 341                                 goto out;
 342                         }
 343
 344                         q = kmap(sg[0].page) + sg[0].offset;
 345                         hexdump(q, cipher_tv[i].rlen);
 346
 347                         printk("%s\n",
 348                                 memcmp(q, cipher_tv[i].result, cipher_tv[i].rlen) ? "fail" :
 349                         "pass");
 350                 }
 351         }
 352
 353         printk("\ntesting %s %s %s across pages (chunking) \n", algo, m, e);
 354         memset(xbuf, 0, XBUFSIZE);
 355
 356         j = 0;
 357         for (i = 0; i < tcount; i++) {
 358                 if (cipher_tv[i].np) {
 359                         j++;
 360                         printk("test %u (%d bit key):\n",
 361                         j, cipher_tv[i].klen * 8);
 362
 363                         tfm->crt_flags = 0;
 364                         if (cipher_tv[i].wk)
 365                                 tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY;
 366                         key = cipher_tv[i].key;
 367
 368                         ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen);
 369                         if (ret) {
 370                                 printk("setkey() failed flags=%x\n", tfm->crt_flags);
 371
 372                                 if (!cipher_tv[i].fail)
 373                                         goto out;
 374                         }
 375
 376                         temp = 0;
 377                         for (k = 0; k < cipher_tv[i].np; k++) {
 378                                 memcpy (&xbuf[IDX[k]], cipher_tv[i].input + temp,
 379                                                 cipher_tv[i].tap[k]);
 380                                 temp += cipher_tv[i].tap[k];
 381                                 p = &xbuf[IDX[k]];
 382                                 sg[k].page = virt_to_page (p);
 383                                 sg[k].offset = offset_in_page (p);
 384                                 sg[k].length = cipher_tv[i].tap[k];
 385                         }
 386
 387                         if (!mode) {
 388                                 crypto_cipher_set_iv(tfm, cipher_tv[i].iv,
 389                                                 crypto_tfm_alg_ivsize (tfm));
 390                         }
 391
 392                         if (enc)
 393                                 ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen);
 394                         else
 395                                 ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen);
 396
 397                         if (ret) {
 398                                 printk("%s () failed flags=%x\n", e, tfm->crt_flags);
 399                                 goto out;
 400                         }
 401
 402                         temp = 0;
 403                         for (k = 0; k < cipher_tv[i].np; k++) {
 404                                 printk("page %u\n", k);
 405                                 q = kmap(sg[k].page) + sg[k].offset;
 406                                 hexdump(q, cipher_tv[i].tap[k]);
 407                                 printk("%s\n",
 408                                         memcmp(q, cipher_tv[i].result + temp,
 409                                                 cipher_tv[i].tap[k]) ? "fail" :
 410                                         "pass");
 411                                 temp += cipher_tv[i].tap[k];
 412                         }
 413                 }
 414         }
 415
 416 out:
 417         crypto_free_tfm(tfm);
 418 }
 419
 420 static void
 421 test_deflate(void)
 422 {
 423         unsigned int i;
 424         char result[COMP_BUF_SIZE];
 425         struct crypto_tfm *tfm;
 426         struct comp_testvec *tv;
 427         unsigned int tsize;
 428
 429         printk("\ntesting deflate compression\n");
 430
 431         tsize = sizeof (deflate_comp_tv_template);
 432         if (tsize > TVMEMSIZE) {
 433                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 434                        TVMEMSIZE);
 435                 return;
 436         }
 437
 438         memcpy(tvmem, deflate_comp_tv_template, tsize);
 439         tv = (void *) tvmem;
 440
 441         tfm = crypto_alloc_tfm("deflate", 0);
 442         if (tfm == NULL) {
 443                 printk("failed to load transform for deflate\n");
 444                 return;
 445         }
 446
 447         for (i = 0; i < DEFLATE_COMP_TEST_VECTORS; i++) {
 448                 int ilen, ret, dlen = COMP_BUF_SIZE;
 449
 450                 printk("test %u:\n", i + 1);
 451                 memset(result, 0, sizeof (result));
 452
 453                 ilen = tv[i].inlen;
 454                 ret = crypto_comp_compress(tfm, tv[i].input,
 455                                            ilen, result, &dlen);
 456                 if (ret) {
 457                         printk("fail: ret=%d\n", ret);
 458                         continue;
 459                 }
 460                 hexdump(result, dlen);
 461                 printk("%s (ratio %d:%d)\n",
 462                        memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
 463                        ilen, dlen);
 464         }
 465
 466         printk("\ntesting deflate decompression\n");
 467
 468         tsize = sizeof (deflate_decomp_tv_template);
 469         if (tsize > TVMEMSIZE) {
 470                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 471                        TVMEMSIZE);
 472                 goto out;
 473         }
 474
 475         memcpy(tvmem, deflate_decomp_tv_template, tsize);
 476         tv = (void *) tvmem;
 477
 478         for (i = 0; i < DEFLATE_DECOMP_TEST_VECTORS; i++) {
 479                 int ilen, ret, dlen = COMP_BUF_SIZE;
 480
 481                 printk("test %u:\n", i + 1);
 482                 memset(result, 0, sizeof (result));
 483
 484                 ilen = tv[i].inlen;
 485                 ret = crypto_comp_decompress(tfm, tv[i].input,
 486                                              ilen, result, &dlen);
 487                 if (ret) {
 488                         printk("fail: ret=%d\n", ret);
 489                         continue;
 490                 }
 491                 hexdump(result, dlen);
 492                 printk("%s (ratio %d:%d)\n",
 493                        memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
 494                        ilen, dlen);
 495         }
 496 out:
 497         crypto_free_tfm(tfm);
 498 }
 499
 500 static void
 501 test_crc32c(void)
 502 {
 503 #define NUMVEC 6
 504 #define VECSIZE 40
 505
 506         int i, j, pass;
 507         u32 crc;
 508         u8 b, test_vec[NUMVEC][VECSIZE];
 509         static u32 vec_results[NUMVEC] = {
 510                 0x0e2c157f, 0xe980ebf6, 0xde74bded,
 511                 0xd579c862, 0xba979ad0, 0x2b29d913
 512         };
 513         static u32 tot_vec_results = 0x24c5d375;
 514
 515         struct scatterlist sg[NUMVEC];
 516         struct crypto_tfm *tfm;
 517         char *fmtdata = "testing crc32c initialized to %08x: %s\n";
 518 #define SEEDTESTVAL 0xedcba987
 519         u32 seed;
 520
 521         printk("\ntesting crc32c\n");
 522
 523         tfm = crypto_alloc_tfm("crc32c", 0);
 524         if (tfm == NULL) {
 525                 printk("failed to load transform for crc32c\n");
 526                 return;
 527         }
 528
 529         crypto_digest_init(tfm);
 530         crypto_digest_final(tfm, (u8*)&crc);
 531         printk(fmtdata, crc, (crc == 0) ? "pass" : "ERROR");
 532
 533         /*
 534          * stuff test_vec with known values, simple incrementing
 535          * byte values.
 536          */
 537         b = 0;
 538         for (i = 0; i < NUMVEC; i++) {
 539                 for (j = 0; j < VECSIZE; j++)
 540                         test_vec[i][j] = ++b;
 541                 sg[i].page = virt_to_page(test_vec[i]);
 542                 sg[i].offset = offset_in_page(test_vec[i]);
 543                 sg[i].length = VECSIZE;
 544         }
 545
 546         seed = SEEDTESTVAL;
 547         (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
 548         crypto_digest_final(tfm, (u8*)&crc);
 549         printk("testing crc32c setkey returns %08x : %s\n", crc, (crc == (SEEDTESTVAL ^ ~(u32)0)) ?
 550                "pass" : "ERROR");
 551
 552         printk("testing crc32c using update/final:\n");
 553
 554         pass = 1;                   /* assume all is well */
 555
 556         for (i = 0; i < NUMVEC; i++) {
 557                 seed = ~(u32)0;
 558                 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
 559                 crypto_digest_update(tfm, &sg[i], 1);
 560                 crypto_digest_final(tfm, (u8*)&crc);
 561                 if (crc == vec_results[i]) {
 562                         printk(" %08x:OK", crc);
 563                 } else {
 564                         printk(" %08x:BAD, wanted %08x\n", crc, vec_results[i]);
 565                         pass = 0;
 566                 }
 567         }
 568
 569         printk("\ntesting crc32c using incremental accumulator:\n");
 570         crc = 0;
 571         for (i = 0; i < NUMVEC; i++) {
 572                 seed = (crc ^ ~(u32)0);
 573                 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
 574                 crypto_digest_update(tfm, &sg[i], 1);
 575                 crypto_digest_final(tfm, (u8*)&crc);
 576         }
 577         if (crc == tot_vec_results) {
 578                 printk(" %08x:OK", crc);
 579         } else {
 580                 printk(" %08x:BAD, wanted %08x\n", crc, tot_vec_results);
 581                 pass = 0;
 582         }
 583
 584         printk("\ntesting crc32c using digest:\n");
 585         seed = ~(u32)0;
 586         (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
 587         crypto_digest_digest(tfm, sg, NUMVEC, (u8*)&crc);
 588         if (crc == tot_vec_results) {
 589                 printk(" %08x:OK", crc);
 590         } else {
 591                 printk(" %08x:BAD, wanted %08x\n", crc, tot_vec_results);
 592                 pass = 0;
 593         }
 594
 595         printk("\n%s\n", pass ? "pass" : "ERROR");
 596
 597         crypto_free_tfm(tfm);
 598         printk("crc32c test complete\n");
 599 }
 600
 601 static void
 602 test_available(void)
 603 {
 604         char **name = check;
 605
 606         while (*name) {
 607                 printk("alg %s ", *name);
 608                 printk((crypto_alg_available(*name, 0)) ?
 609                         "found\n" : "not found\n");
 610                 name++;
 611         }
 612 }
 613
 614 static void
 615 do_test(void)
 616 {
 617         switch (mode) {
 618
 619         case 0:
 620                 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
 621
 622                 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
 623
 624                 //DES
 625                 test_cipher ("des", MODE_ECB, ENCRYPT, des_enc_tv_template, DES_ENC_TEST_VECTORS);
 626                 test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS);
 627                 test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS);
 628                 test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS);
 629
 630                 //DES3_EDE
 631                 test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS);
 632                 test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS);
 633
 634                 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
 635
 636                 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
 637
 638                 //BLOWFISH
 639                 test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS);
 640                 test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS);
 641                 test_cipher ("blowfish", MODE_CBC, ENCRYPT, bf_cbc_enc_tv_template, BF_CBC_ENC_TEST_VECTORS);
 642                 test_cipher ("blowfish", MODE_CBC, DECRYPT, bf_cbc_dec_tv_template, BF_CBC_DEC_TEST_VECTORS);
 643
 644                 //TWOFISH
 645                 test_cipher ("twofish", MODE_ECB, ENCRYPT, tf_enc_tv_template, TF_ENC_TEST_VECTORS);
 646                 test_cipher ("twofish", MODE_ECB, DECRYPT, tf_dec_tv_template, TF_DEC_TEST_VECTORS);
 647                 test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS);
 648                 test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS);
 649
 650                 //SERPENT
 651                 test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS);
 652                 test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS);
 653
 654                 //TNEPRES
 655                 test_cipher ("tnepres", MODE_ECB, ENCRYPT, tnepres_enc_tv_template, TNEPRES_ENC_TEST_VECTORS);
 656                 test_cipher ("tnepres", MODE_ECB, DECRYPT, tnepres_dec_tv_template, TNEPRES_DEC_TEST_VECTORS);
 657
 658                 //AES
 659                 test_cipher ("aes", MODE_ECB, ENCRYPT, aes_enc_tv_template, AES_ENC_TEST_VECTORS);
 660                 test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS);
 661
 662                 //CAST5
 663                 test_cipher ("cast5", MODE_ECB, ENCRYPT, cast5_enc_tv_template, CAST5_ENC_TEST_VECTORS);
 664                 test_cipher ("cast5", MODE_ECB, DECRYPT, cast5_dec_tv_template, CAST5_DEC_TEST_VECTORS);
 665
 666                 //CAST6
 667                 test_cipher ("cast6", MODE_ECB, ENCRYPT, cast6_enc_tv_template, CAST6_ENC_TEST_VECTORS);
 668                 test_cipher ("cast6", MODE_ECB, DECRYPT, cast6_dec_tv_template, CAST6_DEC_TEST_VECTORS);
 669
 670                 //ARC4
 671                 test_cipher ("arc4", MODE_ECB, ENCRYPT, arc4_enc_tv_template, ARC4_ENC_TEST_VECTORS);
 672                 test_cipher ("arc4", MODE_ECB, DECRYPT, arc4_dec_tv_template, ARC4_DEC_TEST_VECTORS);
 673
 674                 //TEA
 675                 test_cipher ("tea", MODE_ECB, ENCRYPT, tea_enc_tv_template, TEA_ENC_TEST_VECTORS);
 676                 test_cipher ("tea", MODE_ECB, DECRYPT, tea_dec_tv_template, TEA_DEC_TEST_VECTORS);
 677
 678
 679                 //XTEA
 680                 test_cipher ("xtea", MODE_ECB, ENCRYPT, xtea_enc_tv_template, XTEA_ENC_TEST_VECTORS);
 681                 test_cipher ("xtea", MODE_ECB, DECRYPT, xtea_dec_tv_template, XTEA_DEC_TEST_VECTORS);
 682
 683                 //KHAZAD
 684                 test_cipher ("khazad", MODE_ECB, ENCRYPT, khazad_enc_tv_template, KHAZAD_ENC_TEST_VECTORS);
 685                 test_cipher ("khazad", MODE_ECB, DECRYPT, khazad_dec_tv_template, KHAZAD_DEC_TEST_VECTORS);
 686
 687                 //ANUBIS
 688                 test_cipher ("anubis", MODE_ECB, ENCRYPT, anubis_enc_tv_template, ANUBIS_ENC_TEST_VECTORS);
 689                 test_cipher ("anubis", MODE_ECB, DECRYPT, anubis_dec_tv_template, ANUBIS_DEC_TEST_VECTORS);
 690                 test_cipher ("anubis", MODE_CBC, ENCRYPT, anubis_cbc_enc_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
 691                 test_cipher ("anubis", MODE_CBC, DECRYPT, anubis_cbc_dec_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
 692
 693                 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
 694                 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
 695                 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
 696                 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
 697                 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
 698                 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
 699                 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
 700                 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
 701                 test_deflate();
 702                 test_crc32c();
 703 #ifdef CONFIG_CRYPTO_HMAC
 704                 test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS);
 705                 test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS);
 706                 test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS);
 707 #endif
 708
 709                 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
 710                 break;
 711
 712         case 1:
 713                 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
 714                 break;
 715
 716         case 2:
 717                 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
 718                 break;
 719
 720         case 3:
 721                 test_cipher ("des", MODE_ECB, ENCRYPT, des_enc_tv_template, DES_ENC_TEST_VECTORS);
 722                 test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS);
 723                 test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS);
 724                 test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS);
 725                 break;
 726
 727         case 4:
 728                 test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS);
 729                 test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS);
 730                 break;
 731
 732         case 5:
 733                 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
 734                 break;
 735
 736         case 6:
 737                 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
 738                 break;
 739
 740         case 7:
 741                 test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS);
 742                 test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS);
 743                 test_cipher ("blowfish", MODE_CBC, ENCRYPT, bf_cbc_enc_tv_template, BF_CBC_ENC_TEST_VECTORS);
 744                 test_cipher ("blowfish", MODE_CBC, DECRYPT, bf_cbc_dec_tv_template, BF_CBC_DEC_TEST_VECTORS);
 745                 break;
 746
 747         case 8:
 748                 test_cipher ("twofish", MODE_ECB, ENCRYPT, tf_enc_tv_template, TF_ENC_TEST_VECTORS);
 749                 test_cipher ("twofish", MODE_ECB, DECRYPT, tf_dec_tv_template, TF_DEC_TEST_VECTORS);
 750                 test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS);
 751                 test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS);
 752                 break;
 753
 754         case 9:
 755                 test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS);
 756                 test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS);
 757                 break;
 758
 759         case 10:
 760                 test_cipher ("aes", MODE_ECB, ENCRYPT, aes_enc_tv_template, AES_ENC_TEST_VECTORS);
 761                 test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS);
 762                 break;
 763
 764         case 11:
 765                 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
 766                 break;
 767
 768         case 12:
 769                 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
 770                 break;
 771
 772         case 13:
 773                 test_deflate();
 774                 break;
 775
 776         case 14:
 777                 test_cipher ("cast5", MODE_ECB, ENCRYPT, cast5_enc_tv_template, CAST5_ENC_TEST_VECTORS);
 778                 test_cipher ("cast5", MODE_ECB, DECRYPT, cast5_dec_tv_template, CAST5_DEC_TEST_VECTORS);
 779                 break;
 780
 781         case 15:
 782                 test_cipher ("cast6", MODE_ECB, ENCRYPT, cast6_enc_tv_template, CAST6_ENC_TEST_VECTORS);
 783                 test_cipher ("cast6", MODE_ECB, DECRYPT, cast6_dec_tv_template, CAST6_DEC_TEST_VECTORS);
 784                 break;
 785
 786         case 16:
 787                 test_cipher ("arc4", MODE_ECB, ENCRYPT, arc4_enc_tv_template, ARC4_ENC_TEST_VECTORS);
 788                 test_cipher ("arc4", MODE_ECB, DECRYPT, arc4_dec_tv_template, ARC4_DEC_TEST_VECTORS);
 789                 break;
 790
 791         case 17:
 792                 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
 793                 break;
 794
 795         case 18:
 796                 test_crc32c();
 797                 break;
 798
 799         case 19:
 800                 test_cipher ("tea", MODE_ECB, ENCRYPT, tea_enc_tv_template, TEA_ENC_TEST_VECTORS);
 801                 test_cipher ("tea", MODE_ECB, DECRYPT, tea_dec_tv_template, TEA_DEC_TEST_VECTORS);
 802                 break;
 803
 804         case 20:
 805                 test_cipher ("xtea", MODE_ECB, ENCRYPT, xtea_enc_tv_template, XTEA_ENC_TEST_VECTORS);
 806                 test_cipher ("xtea", MODE_ECB, DECRYPT, xtea_dec_tv_template, XTEA_DEC_TEST_VECTORS);
 807                 break;
 808
 809         case 21:
 810                 test_cipher ("khazad", MODE_ECB, ENCRYPT, khazad_enc_tv_template, KHAZAD_ENC_TEST_VECTORS);
 811                 test_cipher ("khazad", MODE_ECB, DECRYPT, khazad_dec_tv_template, KHAZAD_DEC_TEST_VECTORS);
 812                 break;
 813
 814         case 22:
 815                 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
 816                 break;
 817
 818         case 23:
 819                 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
 820                 break;
 821
 822         case 24:
 823                 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
 824                 break;
 825
 826         case 25:
 827                 test_cipher ("tnepres", MODE_ECB, ENCRYPT, tnepres_enc_tv_template, TNEPRES_ENC_TEST_VECTORS);
 828                 test_cipher ("tnepres", MODE_ECB, DECRYPT, tnepres_dec_tv_template, TNEPRES_DEC_TEST_VECTORS);
 829                 break;
 830
 831         case 26:
 832                 test_cipher ("anubis", MODE_ECB, ENCRYPT, anubis_enc_tv_template, ANUBIS_ENC_TEST_VECTORS);
 833                 test_cipher ("anubis", MODE_ECB, DECRYPT, anubis_dec_tv_template, ANUBIS_DEC_TEST_VECTORS);
 834                 test_cipher ("anubis", MODE_CBC, ENCRYPT, anubis_cbc_enc_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
 835                 test_cipher ("anubis", MODE_CBC, DECRYPT, anubis_cbc_dec_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
 836                 break;
 837
 838         case 27:
 839                 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
 840                 break;
 841
 842         case 28:
 843
 844                 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
 845                 break;
 846
 847         case 29:
 848                 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
 849                 break;
 850
 851 #ifdef CONFIG_CRYPTO_HMAC
 852         case 100:
 853                 test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS);
 854                 break;
 855
 856         case 101:
 857                 test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS);
 858                 break;
 859
 860         case 102:
 861                 test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS);
 862                 break;
 863
 864 #endif
 865
 866         case 1000:
 867                 test_available();
 868                 break;
 869
 870         default:
 871                 /* useful for debugging */
 872                 printk("not testing anything\n");
 873                 break;
 874         }
 875 }
 876
 877 static int __init
 878 init(void)
 879 {
 880         tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL);
 881         if (tvmem == NULL)
 882                 return -ENOMEM;
 883
 884         xbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
 885         if (xbuf == NULL) {
 886                 kfree(tvmem);
 887                 return -ENOMEM;
 888         }
 889
 890         do_test();
 891
 892         kfree(xbuf);
 893         kfree(tvmem);
 894         return 0;
 895 }
 896
 897 /*
 898  * If an init function is provided, an exit function must also be provided
 899  * to allow module unload.
 900  */
 901 static void __exit fini(void) { }
 902
 903 module_init(init);
 904 module_exit(fini);
 905
 906 module_param(mode, int, 0);
 907
 908 MODULE_LICENSE("GPL");
 909 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
 910 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");