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