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  */
  16 #include <linux/init.h>
  17 #include <linux/module.h>
  18 #include <linux/string.h>
  19 #include <linux/mm.h>
  20 #include <linux/slab.h>
  21 #include <asm/scatterlist.h>
  22 #include <linux/string.h>
  23 #include <linux/crypto.h>
  24 #include <linux/highmem.h>
  25 #include "tcrypt.h"
  26
  27 /*
  28  * Need to kmalloc() memory for testing kmap().
  29  */
  30 #define TVMEMSIZE       4096
  31 #define XBUFSIZE        32768
  32
  33 /*
  34  * Indexes into the xbuf to simulate cross-page access.
  35  */
  36 #define IDX1            37
  37 #define IDX2            32400
  38 #define IDX3            1
  39 #define IDX4            8193
  40 #define IDX5            22222
  41 #define IDX6            17101
  42 #define IDX7            27333
  43 #define IDX8            3000
  44
  45 static int mode = 0;
  46 static char *xbuf;
  47 static char *tvmem;
  48
  49 static void
  50 hexdump(unsigned char *buf, unsigned int len)
  51 {
  52         while (len--)
  53                 printk("%02x", *buf++);
  54
  55         printk("\n");
  56 }
  57
  58 static void
  59 test_md5(void)
  60 {
  61         char *p;
  62         unsigned int i;
  63         struct scatterlist sg[2];
  64         char result[128];
  65         struct crypto_tfm *tfm;
  66         struct md5_testvec *md5_tv;
  67         struct hmac_md5_testvec *hmac_md5_tv;
  68         unsigned int tsize;
  69
  70         printk("\ntesting md5\n");
  71
  72         tsize = sizeof (md5_tv_template);
  73         if (tsize > TVMEMSIZE) {
  74                 printk("template (%u) too big for tvmem (%u)\n", tsize,
  75                        TVMEMSIZE);
  76                 return;
  77         }
  78
  79         memcpy(tvmem, md5_tv_template, tsize);
  80         md5_tv = (void *) tvmem;
  81
  82         tfm = crypto_alloc_tfm("md5", 0);
  83         if (tfm == NULL) {
  84                 printk("failed to load transform for md5\n");
  85                 return;
  86         }
  87
  88         for (i = 0; i < MD5_TEST_VECTORS; i++) {
  89                 printk("test %u:\n", i + 1);
  90                 memset(result, 0, sizeof (result));
  91
  92                 p = md5_tv[i].plaintext;
  93                 sg[0].page = virt_to_page(p);
  94                 sg[0].offset = ((long) p & ~PAGE_MASK);
  95                 sg[0].length = strlen(md5_tv[i].plaintext);
  96
  97                 crypto_digest_init(tfm);
  98                 crypto_digest_update(tfm, sg, 1);
  99                 crypto_digest_final(tfm, result);
 100
 101                 hexdump(result, crypto_tfm_alg_digestsize(tfm));
 102                 printk("%s\n",
 103                        memcmp(result, md5_tv[i].digest,
 104                               crypto_tfm_alg_digestsize(tfm)) ? "fail" :
 105                        "pass");
 106         }
 107
 108         printk("\ntesting md5 across pages\n");
 109
 110         /* setup the dummy buffer first */
 111         memset(xbuf, 0, sizeof (xbuf));
 112         memcpy(&xbuf[IDX1], "abcdefghijklm", 13);
 113         memcpy(&xbuf[IDX2], "nopqrstuvwxyz", 13);
 114
 115         p = &xbuf[IDX1];
 116         sg[0].page = virt_to_page(p);
 117         sg[0].offset = ((long) p & ~PAGE_MASK);
 118         sg[0].length = 13;
 119
 120         p = &xbuf[IDX2];
 121         sg[1].page = virt_to_page(p);
 122         sg[1].offset = ((long) p & ~PAGE_MASK);
 123         sg[1].length = 13;
 124
 125         memset(result, 0, sizeof (result));
 126         crypto_digest_digest(tfm, sg, 2, result);
 127         hexdump(result, crypto_tfm_alg_digestsize(tfm));
 128
 129         printk("%s\n",
 130                memcmp(result, md5_tv[4].digest,
 131                       crypto_tfm_alg_digestsize(tfm)) ? "fail" : "pass");
 132
 133         printk("\ntesting hmac_md5\n");
 134
 135         tsize = sizeof (hmac_md5_tv_template);
 136         if (tsize > TVMEMSIZE) {
 137                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 138                        TVMEMSIZE);
 139                 return;
 140         }
 141
 142         memcpy(tvmem, hmac_md5_tv_template, tsize);
 143         hmac_md5_tv = (void *) tvmem;
 144
 145         for (i = 0; i < HMAC_MD5_TEST_VECTORS; i++) {
 146                 printk("test %u:\n", i + 1);
 147                 memset(result, 0, sizeof (result));
 148
 149                 p = hmac_md5_tv[i].plaintext;
 150                 sg[0].page = virt_to_page(p);
 151                 sg[0].offset = ((long) p & ~PAGE_MASK);
 152                 sg[0].length = strlen(hmac_md5_tv[i].plaintext);
 153
 154                 crypto_digest_hmac(tfm, hmac_md5_tv[i].key,
 155                                    strlen(hmac_md5_tv[i].key), sg, 1, result);
 156
 157                 hexdump(result, crypto_tfm_alg_digestsize(tfm));
 158                 printk("%s\n",
 159                        memcmp(result, hmac_md5_tv[i].digest,
 160                               crypto_tfm_alg_digestsize(tfm)) ? "fail" :
 161                        "pass");
 162         }
 163
 164         printk("\ntesting hmac_md5 across pages\n");
 165
 166         memset(xbuf, 0, sizeof (xbuf));
 167
 168         memcpy(&xbuf[IDX1], "what do ya want ", 16);
 169         memcpy(&xbuf[IDX2], "for nothing?", 12);
 170
 171         p = &xbuf[IDX1];
 172         sg[0].page = virt_to_page(p);
 173         sg[0].offset = ((long) p & ~PAGE_MASK);
 174         sg[0].length = 16;
 175
 176         p = &xbuf[IDX2];
 177         sg[1].page = virt_to_page(p);
 178         sg[1].offset = ((long) p & ~PAGE_MASK);
 179         sg[1].length = 12;
 180
 181         memset(result, 0, sizeof (result));
 182         crypto_digest_hmac(tfm, hmac_md5_tv[1].key, strlen(hmac_md5_tv[1].key),
 183                            sg, 2, result);
 184         hexdump(result, crypto_tfm_alg_digestsize(tfm));
 185
 186         printk("%s\n",
 187                memcmp(result, hmac_md5_tv[1].digest,
 188                       crypto_tfm_alg_digestsize(tfm)) ? "fail" : "pass");
 189
 190         crypto_free_tfm(tfm);
 191 }
 192
 193 static void
 194 test_md4(void)
 195 {
 196         char *p;
 197         unsigned int i;
 198         struct scatterlist sg[1];
 199         char result[128];
 200         struct crypto_tfm *tfm;
 201         struct md4_testvec *md4_tv;
 202         unsigned int tsize;
 203
 204         printk("\ntesting md4\n");
 205
 206         tsize = sizeof (md4_tv_template);
 207         if (tsize > TVMEMSIZE) {
 208                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 209                        TVMEMSIZE);
 210                 return;
 211         }
 212
 213         memcpy(tvmem, md4_tv_template, tsize);
 214         md4_tv = (void *) tvmem;
 215
 216         tfm = crypto_alloc_tfm("md4", 0);
 217         if (tfm == NULL) {
 218                 printk("failed to load transform for md4\n");
 219                 return;
 220         }
 221
 222         for (i = 0; i < MD4_TEST_VECTORS; i++) {
 223                 printk("test %u:\n", i + 1);
 224                 memset(result, 0, sizeof (result));
 225
 226                 p = md4_tv[i].plaintext;
 227                 sg[0].page = virt_to_page(p);
 228                 sg[0].offset = ((long) p & ~PAGE_MASK);
 229                 sg[0].length = strlen(md4_tv[i].plaintext);
 230
 231                 crypto_digest_digest(tfm, sg, 1, result);
 232
 233                 hexdump(result, crypto_tfm_alg_digestsize(tfm));
 234                 printk("%s\n",
 235                        memcmp(result, md4_tv[i].digest,
 236                               crypto_tfm_alg_digestsize(tfm)) ? "fail" :
 237                        "pass");
 238         }
 239
 240         crypto_free_tfm(tfm);
 241 }
 242
 243 static void
 244 test_sha1(void)
 245 {
 246         char *p;
 247         unsigned int i;
 248         struct crypto_tfm *tfm;
 249         struct sha1_testvec *sha1_tv;
 250         struct hmac_sha1_testvec *hmac_sha1_tv;
 251         struct scatterlist sg[2];
 252         unsigned int tsize;
 253         char result[SHA1_DIGEST_SIZE];
 254
 255         printk("\ntesting sha1\n");
 256
 257         tsize = sizeof (sha1_tv_template);
 258         if (tsize > TVMEMSIZE) {
 259                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 260                        TVMEMSIZE);
 261                 return;
 262         }
 263
 264         memcpy(tvmem, sha1_tv_template, tsize);
 265         sha1_tv = (void *) tvmem;
 266
 267         tfm = crypto_alloc_tfm("sha1", 0);
 268         if (tfm == NULL) {
 269                 printk("failed to load transform for sha1\n");
 270                 return;
 271         }
 272
 273         for (i = 0; i < SHA1_TEST_VECTORS; i++) {
 274                 printk("test %u:\n", i + 1);
 275                 memset(result, 0, sizeof (result));
 276
 277                 p = sha1_tv[i].plaintext;
 278                 sg[0].page = virt_to_page(p);
 279                 sg[0].offset = ((long) p & ~PAGE_MASK);
 280                 sg[0].length = strlen(sha1_tv[i].plaintext);
 281
 282                 crypto_digest_init(tfm);
 283                 crypto_digest_update(tfm, sg, 1);
 284                 crypto_digest_final(tfm, result);
 285
 286                 hexdump(result, crypto_tfm_alg_digestsize(tfm));
 287                 printk("%s\n",
 288                        memcmp(result, sha1_tv[i].digest,
 289                               crypto_tfm_alg_digestsize(tfm)) ? "fail" :
 290                        "pass");
 291         }
 292
 293         printk("\ntesting sha1 across pages\n");
 294
 295         /* setup the dummy buffer first */
 296         memset(xbuf, 0, sizeof (xbuf));
 297         memcpy(&xbuf[IDX1], "abcdbcdecdefdefgefghfghighij", 28);
 298         memcpy(&xbuf[IDX2], "hijkijkljklmklmnlmnomnopnopq", 28);
 299
 300         p = &xbuf[IDX1];
 301         sg[0].page = virt_to_page(p);
 302         sg[0].offset = ((long) p & ~PAGE_MASK);
 303         sg[0].length = 28;
 304
 305         p = &xbuf[IDX2];
 306         sg[1].page = virt_to_page(p);
 307         sg[1].offset = ((long) p & ~PAGE_MASK);
 308         sg[1].length = 28;
 309
 310         memset(result, 0, sizeof (result));
 311         crypto_digest_digest(tfm, sg, 2, result);
 312         hexdump(result, crypto_tfm_alg_digestsize(tfm));
 313         printk("%s\n",
 314                memcmp(result, sha1_tv[1].digest,
 315                       crypto_tfm_alg_digestsize(tfm)) ? "fail" : "pass");
 316
 317         printk("\ntesting hmac_sha1\n");
 318
 319         tsize = sizeof (hmac_sha1_tv_template);
 320         if (tsize > TVMEMSIZE) {
 321                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 322                        TVMEMSIZE);
 323                 return;
 324         }
 325
 326         memcpy(tvmem, hmac_sha1_tv_template, tsize);
 327         hmac_sha1_tv = (void *) tvmem;
 328
 329         for (i = 0; i < HMAC_SHA1_TEST_VECTORS; i++) {
 330                 printk("test %u:\n", i + 1);
 331                 memset(result, 0, sizeof (result));
 332
 333                 p = hmac_sha1_tv[i].plaintext;
 334                 sg[0].page = virt_to_page(p);
 335                 sg[0].offset = ((long) p & ~PAGE_MASK);
 336                 sg[0].length = strlen(hmac_sha1_tv[i].plaintext);
 337
 338                 crypto_digest_hmac(tfm, hmac_sha1_tv[i].key,
 339                                    strlen(hmac_sha1_tv[i].key), sg, 1, result);
 340
 341                 hexdump(result, sizeof (result));
 342                 printk("%s\n",
 343                        memcmp(result, hmac_sha1_tv[i].digest,
 344                               crypto_tfm_alg_digestsize(tfm)) ? "fail" :
 345                        "pass");
 346         }
 347
 348         printk("\ntesting hmac_sha1 across pages\n");
 349
 350         /* setup the dummy buffer first */
 351         memset(xbuf, 0, sizeof (xbuf));
 352
 353         memcpy(&xbuf[IDX1], "what do ya want ", 16);
 354         memcpy(&xbuf[IDX2], "for nothing?", 12);
 355
 356         p = &xbuf[IDX1];
 357         sg[0].page = virt_to_page(p);
 358         sg[0].offset = ((long) p & ~PAGE_MASK);
 359         sg[0].length = 16;
 360
 361         p = &xbuf[IDX2];
 362         sg[1].page = virt_to_page(p);
 363         sg[1].offset = ((long) p & ~PAGE_MASK);
 364         sg[1].length = 12;
 365
 366         memset(result, 0, sizeof (result));
 367         crypto_digest_hmac(tfm, hmac_sha1_tv[1].key,
 368                            strlen(hmac_sha1_tv[1].key), sg, 2, result);
 369         hexdump(result, crypto_tfm_alg_digestsize(tfm));
 370
 371         printk("%s\n",
 372                memcmp(result, hmac_sha1_tv[1].digest,
 373                       crypto_tfm_alg_digestsize(tfm)) ? "fail" : "pass");
 374         crypto_free_tfm(tfm);
 375 }
 376
 377 void
 378 test_des(void)
 379 {
 380         unsigned int ret, i, len;
 381         unsigned int tsize;
 382         char *p, *q;
 383         struct crypto_tfm *tfm;
 384         char *key;
 385         char res[8];
 386         struct des_tv *des_tv;
 387         struct scatterlist sg[8];
 388
 389         printk("\ntesting des encryption\n");
 390
 391         tsize = sizeof (des_enc_tv_template);
 392         if (tsize > TVMEMSIZE) {
 393                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 394                        TVMEMSIZE);
 395                 return;
 396         }
 397
 398         memcpy(tvmem, des_enc_tv_template, tsize);
 399         des_tv = (void *) tvmem;
 400
 401         tfm = crypto_alloc_tfm("des", 0);
 402         if (tfm == NULL) {
 403                 printk("failed to load transform for des (default ecb)\n");
 404                 return;
 405         }
 406
 407         for (i = 0; i < DES_ENC_TEST_VECTORS; i++) {
 408                 printk("test %u:\n", i + 1);
 409
 410                 key = des_tv[i].key;
 411                 tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY;
 412
 413                 ret = crypto_cipher_setkey(tfm, key, 8);
 414                 if (ret) {
 415                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
 416
 417                         if (!des_tv[i].fail)
 418                                 goto out;
 419                 }
 420
 421                 len = des_tv[i].len;
 422
 423                 p = des_tv[i].plaintext;
 424                 sg[0].page = virt_to_page(p);
 425                 sg[0].offset = ((long) p & ~PAGE_MASK);
 426                 sg[0].length = len;
 427                 ret = crypto_cipher_encrypt(tfm, sg, 1);
 428                 if (ret) {
 429                         printk("encrypt() failed flags=%x\n", tfm->crt_flags);
 430                         goto out;
 431                 }
 432
 433                 q = kmap(sg[0].page) + sg[0].offset;
 434                 hexdump(q, len);
 435
 436                 printk("%s\n",
 437                        memcmp(q, des_tv[i].result, len) ? "fail" : "pass");
 438
 439         }
 440
 441         printk("\ntesting des ecb encryption across pages\n");
 442
 443         i = 5;
 444         key = des_tv[i].key;
 445         tfm->crt_flags = 0;
 446
 447         hexdump(key, 8);
 448
 449         ret = crypto_cipher_setkey(tfm, key, 8);
 450         if (ret) {
 451                 printk("setkey() failed flags=%x\n", tfm->crt_flags);
 452                 goto out;
 453         }
 454
 455         /* setup the dummy buffer first */
 456         memset(xbuf, 0, sizeof (xbuf));
 457         memcpy(&xbuf[IDX1], des_tv[i].plaintext, 8);
 458         memcpy(&xbuf[IDX2], des_tv[i].plaintext + 8, 8);
 459
 460         p = &xbuf[IDX1];
 461         sg[0].page = virt_to_page(p);
 462         sg[0].offset = ((long) p & ~PAGE_MASK);
 463         sg[0].length = 8;
 464
 465         p = &xbuf[IDX2];
 466         sg[1].page = virt_to_page(p);
 467         sg[1].offset = ((long) p & ~PAGE_MASK);
 468         sg[1].length = 8;
 469
 470         ret = crypto_cipher_encrypt(tfm, sg, 2);
 471         if (ret) {
 472                 printk("encrypt() failed flags=%x\n", tfm->crt_flags);
 473                 goto out;
 474         }
 475
 476         printk("page 1\n");
 477         q = kmap(sg[0].page) + sg[0].offset;
 478         hexdump(q, 8);
 479         printk("%s\n", memcmp(q, des_tv[i].result, 8) ? "fail" : "pass");
 480
 481         printk("page 2\n");
 482         q = kmap(sg[1].page) + sg[1].offset;
 483         hexdump(q, 8);
 484         printk("%s\n", memcmp(q, des_tv[i].result + 8, 8) ? "fail" : "pass");
 485
 486         printk("\ntesting des ecb encryption chunking scenario A\n");
 487
 488         /*
 489          * Scenario A:
 490          *
 491          *  F1       F2      F3
 492          *  [8 + 6]  [2 + 8] [8]
 493          *       ^^^^^^   ^
 494          *       a    b   c
 495          *
 496          * Chunking should begin at a, then end with b, and
 497          * continue encrypting at an offset of 2 until c.
 498          *
 499          */
 500         i = 7;
 501
 502         key = des_tv[i].key;
 503         tfm->crt_flags = 0;
 504
 505         ret = crypto_cipher_setkey(tfm, key, 8);
 506         if (ret) {
 507                 printk("setkey() failed flags=%x\n", tfm->crt_flags);
 508                 goto out;
 509         }
 510
 511         /* setup the dummy buffer first */
 512         memset(xbuf, 0, sizeof (xbuf));
 513
 514         /* Frag 1: 8 + 6 */
 515         memcpy(&xbuf[IDX3], des_tv[i].plaintext, 14);
 516
 517         /* Frag 2: 2 + 8 */
 518         memcpy(&xbuf[IDX4], des_tv[i].plaintext + 14, 10);
 519
 520         /* Frag 3: 8 */
 521         memcpy(&xbuf[IDX5], des_tv[i].plaintext + 24, 8);
 522
 523         p = &xbuf[IDX3];
 524         sg[0].page = virt_to_page(p);
 525         sg[0].offset = ((long) p & ~PAGE_MASK);
 526         sg[0].length = 14;
 527
 528         p = &xbuf[IDX4];
 529         sg[1].page = virt_to_page(p);
 530         sg[1].offset = ((long) p & ~PAGE_MASK);
 531         sg[1].length = 10;
 532
 533         p = &xbuf[IDX5];
 534         sg[2].page = virt_to_page(p);
 535         sg[2].offset = ((long) p & ~PAGE_MASK);
 536         sg[2].length = 8;
 537
 538         ret = crypto_cipher_encrypt(tfm, sg, 3);
 539
 540         if (ret) {
 541                 printk("decrypt() failed flags=%x\n", tfm->crt_flags);
 542                 goto out;
 543         }
 544
 545         printk("page 1\n");
 546         q = kmap(sg[0].page) + sg[0].offset;
 547         hexdump(q, 14);
 548         printk("%s\n", memcmp(q, des_tv[i].result, 14) ? "fail" : "pass");
 549
 550         printk("page 2\n");
 551         q = kmap(sg[1].page) + sg[1].offset;
 552         hexdump(q, 10);
 553         printk("%s\n", memcmp(q, des_tv[i].result + 14, 10) ? "fail" : "pass");
 554
 555         printk("page 3\n");
 556         q = kmap(sg[2].page) + sg[2].offset;
 557         hexdump(q, 8);
 558         printk("%s\n", memcmp(q, des_tv[i].result + 24, 8) ? "fail" : "pass");
 559
 560         printk("\ntesting des ecb encryption chunking scenario B\n");
 561
 562         /*
 563          * Scenario B:
 564          *
 565          *  F1  F2  F3  F4
 566          *  [2] [1] [3] [2 + 8 + 8]
 567          */
 568         i = 7;
 569
 570         key = des_tv[i].key;
 571         tfm->crt_flags = 0;
 572
 573         ret = crypto_cipher_setkey(tfm, key, 8);
 574         if (ret) {
 575                 printk("setkey() failed flags=%x\n", tfm->crt_flags);
 576                 goto out;
 577         }
 578
 579         /* setup the dummy buffer first */
 580         memset(xbuf, 0, sizeof (xbuf));
 581
 582         /* Frag 1: 2 */
 583         memcpy(&xbuf[IDX3], des_tv[i].plaintext, 2);
 584
 585         /* Frag 2: 1 */
 586         memcpy(&xbuf[IDX4], des_tv[i].plaintext + 2, 1);
 587
 588         /* Frag 3: 3 */
 589         memcpy(&xbuf[IDX5], des_tv[i].plaintext + 3, 3);
 590
 591         /* Frag 4: 2 + 8 + 8 */
 592         memcpy(&xbuf[IDX6], des_tv[i].plaintext + 6, 18);
 593
 594         p = &xbuf[IDX3];
 595         sg[0].page = virt_to_page(p);
 596         sg[0].offset = ((long) p & ~PAGE_MASK);
 597         sg[0].length = 2;
 598
 599         p = &xbuf[IDX4];
 600         sg[1].page = virt_to_page(p);
 601         sg[1].offset = ((long) p & ~PAGE_MASK);
 602         sg[1].length = 1;
 603
 604         p = &xbuf[IDX5];
 605         sg[2].page = virt_to_page(p);
 606         sg[2].offset = ((long) p & ~PAGE_MASK);
 607         sg[2].length = 3;
 608
 609         p = &xbuf[IDX6];
 610         sg[3].page = virt_to_page(p);
 611         sg[3].offset = ((long) p & ~PAGE_MASK);
 612         sg[3].length = 18;
 613
 614         ret = crypto_cipher_encrypt(tfm, sg, 4);
 615
 616         if (ret) {
 617                 printk("encrypt() failed flags=%x\n", tfm->crt_flags);
 618                 goto out;
 619         }
 620
 621         printk("page 1\n");
 622         q = kmap(sg[0].page) + sg[0].offset;
 623         hexdump(q, 2);
 624         printk("%s\n", memcmp(q, des_tv[i].result, 2) ? "fail" : "pass");
 625
 626         printk("page 2\n");
 627         q = kmap(sg[1].page) + sg[1].offset;
 628         hexdump(q, 1);
 629         printk("%s\n", memcmp(q, des_tv[i].result + 2, 1) ? "fail" : "pass");
 630
 631         printk("page 3\n");
 632         q = kmap(sg[2].page) + sg[2].offset;
 633         hexdump(q, 3);
 634         printk("%s\n", memcmp(q, des_tv[i].result + 3, 3) ? "fail" : "pass");
 635
 636         printk("page 4\n");
 637         q = kmap(sg[3].page) + sg[3].offset;
 638         hexdump(q, 18);
 639         printk("%s\n", memcmp(q, des_tv[i].result + 6, 18) ? "fail" : "pass");
 640
 641         printk("\ntesting des ecb encryption chunking scenario C\n");
 642
 643         /*
 644          * Scenario B:
 645          *
 646          *  F1  F2  F3  F4  F5
 647          *  [2] [2] [2] [2] [8]
 648          */
 649         i = 7;
 650
 651         key = des_tv[i].key;
 652         tfm->crt_flags = 0;
 653
 654         ret = crypto_cipher_setkey(tfm, key, 8);
 655         if (ret) {
 656                 printk("setkey() failed flags=%x\n", tfm->crt_flags);
 657                 goto out;
 658         }
 659
 660         /* setup the dummy buffer first */
 661         memset(xbuf, 0, sizeof (xbuf));
 662
 663         /* Frag 1: 2 */
 664         memcpy(&xbuf[IDX3], des_tv[i].plaintext, 2);
 665
 666         /* Frag 2: 2 */
 667         memcpy(&xbuf[IDX4], des_tv[i].plaintext + 2, 2);
 668
 669         /* Frag 3: 2 */
 670         memcpy(&xbuf[IDX5], des_tv[i].plaintext + 4, 2);
 671
 672         /* Frag 4: 2 */
 673         memcpy(&xbuf[IDX6], des_tv[i].plaintext + 6, 2);
 674
 675         /* Frag 5: 8 */
 676         memcpy(&xbuf[IDX7], des_tv[i].plaintext + 8, 8);
 677
 678         p = &xbuf[IDX3];
 679         sg[0].page = virt_to_page(p);
 680         sg[0].offset = ((long) p & ~PAGE_MASK);
 681         sg[0].length = 2;
 682
 683         p = &xbuf[IDX4];
 684         sg[1].page = virt_to_page(p);
 685         sg[1].offset = ((long) p & ~PAGE_MASK);
 686         sg[1].length = 2;
 687
 688         p = &xbuf[IDX5];
 689         sg[2].page = virt_to_page(p);
 690         sg[2].offset = ((long) p & ~PAGE_MASK);
 691         sg[2].length = 2;
 692
 693         p = &xbuf[IDX6];
 694         sg[3].page = virt_to_page(p);
 695         sg[3].offset = ((long) p & ~PAGE_MASK);
 696         sg[3].length = 2;
 697
 698         p = &xbuf[IDX7];
 699         sg[4].page = virt_to_page(p);
 700         sg[4].offset = ((long) p & ~PAGE_MASK);
 701         sg[4].length = 8;
 702
 703         ret = crypto_cipher_encrypt(tfm, sg, 5);
 704
 705         if (ret) {
 706                 printk("encrypt() failed flags=%x\n", tfm->crt_flags);
 707                 goto out;
 708         }
 709
 710         printk("page 1\n");
 711         q = kmap(sg[0].page) + sg[0].offset;
 712         hexdump(q, 2);
 713         printk("%s\n", memcmp(q, des_tv[i].result, 2) ? "fail" : "pass");
 714
 715         printk("page 2\n");
 716         q = kmap(sg[1].page) + sg[1].offset;
 717         hexdump(q, 2);
 718         printk("%s\n", memcmp(q, des_tv[i].result + 2, 2) ? "fail" : "pass");
 719
 720         printk("page 3\n");
 721         q = kmap(sg[2].page) + sg[2].offset;
 722         hexdump(q, 2);
 723         printk("%s\n", memcmp(q, des_tv[i].result + 4, 2) ? "fail" : "pass");
 724
 725         printk("page 4\n");
 726         q = kmap(sg[3].page) + sg[3].offset;
 727         hexdump(q, 2);
 728         printk("%s\n", memcmp(q, des_tv[i].result + 6, 2) ? "fail" : "pass");
 729
 730         printk("page 5\n");
 731         q = kmap(sg[4].page) + sg[4].offset;
 732         hexdump(q, 8);
 733         printk("%s\n", memcmp(q, des_tv[i].result + 8, 8) ? "fail" : "pass");
 734
 735         printk("\ntesting des ecb encryption chunking scenario D (atomic)\n");
 736
 737         /*
 738          * Scenario D, torture test, one byte per frag.
 739          */
 740         i = 7;
 741         key = des_tv[i].key;
 742         tfm->crt_flags = 0;
 743
 744         ret = crypto_cipher_setkey(tfm, key, 8);
 745         if (ret) {
 746                 printk("setkey() failed flags=%x\n", tfm->crt_flags);
 747                 goto out;
 748         }
 749
 750         /* setup the dummy buffer first */
 751         memset(xbuf, 0, sizeof (xbuf));
 752
 753         xbuf[IDX1] = des_tv[i].plaintext[0];
 754         xbuf[IDX2] = des_tv[i].plaintext[1];
 755         xbuf[IDX3] = des_tv[i].plaintext[2];
 756         xbuf[IDX4] = des_tv[i].plaintext[3];
 757         xbuf[IDX5] = des_tv[i].plaintext[4];
 758         xbuf[IDX6] = des_tv[i].plaintext[5];
 759         xbuf[IDX7] = des_tv[i].plaintext[6];
 760         xbuf[IDX8] = des_tv[i].plaintext[7];
 761
 762         p = &xbuf[IDX1];
 763         sg[0].page = virt_to_page(p);
 764         sg[0].offset = ((long) p & ~PAGE_MASK);
 765         sg[0].length = 1;
 766
 767         p = &xbuf[IDX2];
 768         sg[1].page = virt_to_page(p);
 769         sg[1].offset = ((long) p & ~PAGE_MASK);
 770         sg[1].length = 1;
 771
 772         p = &xbuf[IDX3];
 773         sg[2].page = virt_to_page(p);
 774         sg[2].offset = ((long) p & ~PAGE_MASK);
 775         sg[2].length = 1;
 776
 777         p = &xbuf[IDX4];
 778         sg[3].page = virt_to_page(p);
 779         sg[3].offset = ((long) p & ~PAGE_MASK);
 780         sg[3].length = 1;
 781
 782         p = &xbuf[IDX5];
 783         sg[4].page = virt_to_page(p);
 784         sg[4].offset = ((long) p & ~PAGE_MASK);
 785         sg[4].length = 1;
 786
 787         p = &xbuf[IDX6];
 788         sg[5].page = virt_to_page(p);
 789         sg[5].offset = ((long) p & ~PAGE_MASK);
 790         sg[5].length = 1;
 791
 792         p = &xbuf[IDX7];
 793         sg[6].page = virt_to_page(p);
 794         sg[6].offset = ((long) p & ~PAGE_MASK);
 795         sg[6].length = 1;
 796
 797         p = &xbuf[IDX8];
 798         sg[7].page = virt_to_page(p);
 799         sg[7].offset = ((long) p & ~PAGE_MASK);
 800         sg[7].length = 1;
 801
 802         ret = crypto_cipher_encrypt(tfm, sg, 8);
 803         if (ret) {
 804                 printk("encrypt() failed flags=%x\n", tfm->crt_flags);
 805                 goto out;
 806         }
 807
 808         for (i = 0; i < 8; i++)
 809                 res[i] = *(char *) (kmap(sg[i].page) + sg[i].offset);
 810
 811         hexdump(res, 8);
 812         printk("%s\n", memcmp(res, des_tv[7].result, 8) ? "fail" : "pass");
 813
 814         printk("\ntesting des decryption\n");
 815
 816         tsize = sizeof (des_dec_tv_template);
 817         if (tsize > TVMEMSIZE) {
 818                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 819                        TVMEMSIZE);
 820                 return;
 821         }
 822         memcpy(tvmem, des_dec_tv_template, tsize);
 823         des_tv = (void *) tvmem;
 824
 825         for (i = 0; i < DES_DEC_TEST_VECTORS; i++) {
 826                 printk("test %u:\n", i + 1);
 827
 828                 key = des_tv[i].key;
 829
 830                 tfm->crt_flags = 0;
 831                 ret = crypto_cipher_setkey(tfm, key, 8);
 832                 if (ret) {
 833                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
 834                         goto out;
 835                 }
 836
 837                 len = des_tv[i].len;
 838
 839                 p = des_tv[i].plaintext;
 840                 sg[0].page = virt_to_page(p);
 841                 sg[0].offset = ((long) p & ~PAGE_MASK);
 842                 sg[0].length = len;
 843
 844                 ret = crypto_cipher_decrypt(tfm, sg, 1);
 845                 if (ret) {
 846                         printk("des_decrypt() failed flags=%x\n",
 847                                tfm->crt_flags);
 848                         goto out;
 849                 }
 850
 851                 q = kmap(sg[0].page) + sg[0].offset;
 852                 hexdump(q, len);
 853
 854                 printk("%s\n",
 855                        memcmp(q, des_tv[i].result, len) ? "fail" : "pass");
 856
 857         }
 858
 859         printk("\ntesting des ecb decryption across pages\n");
 860
 861         i = 6;
 862
 863         key = des_tv[i].key;
 864         tfm->crt_flags = 0;
 865
 866         ret = crypto_cipher_setkey(tfm, key, 8);
 867         if (ret) {
 868                 printk("setkey() failed flags=%x\n", tfm->crt_flags);
 869                 goto out;
 870         }
 871
 872         /* setup the dummy buffer first */
 873         memset(xbuf, 0, sizeof (xbuf));
 874         memcpy(&xbuf[IDX1], des_tv[i].plaintext, 8);
 875         memcpy(&xbuf[IDX2], des_tv[i].plaintext + 8, 8);
 876
 877         p = &xbuf[IDX1];
 878         sg[0].page = virt_to_page(p);
 879         sg[0].offset = ((long) p & ~PAGE_MASK);
 880         sg[0].length = 8;
 881
 882         p = &xbuf[IDX2];
 883         sg[1].page = virt_to_page(p);
 884         sg[1].offset = ((long) p & ~PAGE_MASK);
 885         sg[1].length = 8;
 886
 887         ret = crypto_cipher_decrypt(tfm, sg, 2);
 888         if (ret) {
 889                 printk("decrypt() failed flags=%x\n", tfm->crt_flags);
 890                 goto out;
 891         }
 892
 893         printk("page 1\n");
 894         q = kmap(sg[0].page) + sg[0].offset;
 895         hexdump(q, 8);
 896         printk("%s\n", memcmp(q, des_tv[i].result, 8) ? "fail" : "pass");
 897
 898         printk("page 2\n");
 899         q = kmap(sg[1].page) + sg[1].offset;
 900         hexdump(q, 8);
 901         printk("%s\n", memcmp(q, des_tv[i].result + 8, 8) ? "fail" : "pass");
 902
 903         /*
 904          * Scenario E:
 905          *
 906          *  F1   F2      F3
 907          *  [3]  [5 + 7] [1]
 908          *
 909          */
 910         printk("\ntesting des ecb decryption chunking scenario E\n");
 911         i = 2;
 912
 913         key = des_tv[i].key;
 914         tfm->crt_flags = 0;
 915
 916         ret = crypto_cipher_setkey(tfm, key, 8);
 917         if (ret) {
 918                 printk("setkey() failed flags=%x\n", tfm->crt_flags);
 919                 goto out;
 920         }
 921
 922         /* setup the dummy buffer first */
 923         memset(xbuf, 0, sizeof (xbuf));
 924
 925         memcpy(&xbuf[IDX1], des_tv[i].plaintext, 3);
 926         memcpy(&xbuf[IDX2], des_tv[i].plaintext + 3, 12);
 927         memcpy(&xbuf[IDX3], des_tv[i].plaintext + 15, 1);
 928
 929         p = &xbuf[IDX1];
 930         sg[0].page = virt_to_page(p);
 931         sg[0].offset = ((long) p & ~PAGE_MASK);
 932         sg[0].length = 3;
 933
 934         p = &xbuf[IDX2];
 935         sg[1].page = virt_to_page(p);
 936         sg[1].offset = ((long) p & ~PAGE_MASK);
 937         sg[1].length = 12;
 938
 939         p = &xbuf[IDX3];
 940         sg[2].page = virt_to_page(p);
 941         sg[2].offset = ((long) p & ~PAGE_MASK);
 942         sg[2].length = 1;
 943
 944         ret = crypto_cipher_decrypt(tfm, sg, 3);
 945
 946         if (ret) {
 947                 printk("decrypt() failed flags=%x\n", tfm->crt_flags);
 948                 goto out;
 949         }
 950
 951         printk("page 1\n");
 952         q = kmap(sg[0].page) + sg[0].offset;
 953         hexdump(q, 3);
 954         printk("%s\n", memcmp(q, des_tv[i].result, 3) ? "fail" : "pass");
 955
 956         printk("page 2\n");
 957         q = kmap(sg[1].page) + sg[1].offset;
 958         hexdump(q, 12);
 959         printk("%s\n", memcmp(q, des_tv[i].result + 3, 12) ? "fail" : "pass");
 960
 961         printk("page 3\n");
 962         q = kmap(sg[2].page) + sg[2].offset;
 963         hexdump(q, 1);
 964         printk("%s\n", memcmp(q, des_tv[i].result + 15, 1) ? "fail" : "pass");
 965
 966         crypto_free_tfm(tfm);
 967
 968         tfm = crypto_alloc_tfm("des", CRYPTO_TFM_MODE_CBC);
 969         if (tfm == NULL) {
 970                 printk("failed to load transform for des cbc\n");
 971                 return;
 972         }
 973
 974         printk("\ntesting des cbc encryption (atomic)\n");
 975
 976         tsize = sizeof (des_cbc_enc_tv_template);
 977         if (tsize > TVMEMSIZE) {
 978                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 979                        TVMEMSIZE);
 980                 return;
 981         }
 982         memcpy(tvmem, des_cbc_enc_tv_template, tsize);
 983         des_tv = (void *) tvmem;
 984
 985         crypto_cipher_set_iv(tfm, des_tv[i].iv, crypto_tfm_alg_ivsize(tfm));
 986         crypto_cipher_get_iv(tfm, res, crypto_tfm_alg_ivsize(tfm));
 987
 988         if (memcmp(res, des_tv[i].iv, sizeof(res))) {
 989                 printk("crypto_cipher_[set|get]_iv() failed\n");
 990                 goto out;
 991         }
 992
 993         for (i = 0; i < DES_CBC_ENC_TEST_VECTORS; i++) {
 994                 printk("test %u:\n", i + 1);
 995
 996                 key = des_tv[i].key;
 997
 998                 ret = crypto_cipher_setkey(tfm, key, 8);
 999                 if (ret) {
1000                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
1001                         goto out;
1002                 }
1003
1004                 len = des_tv[i].len;
1005                 p = des_tv[i].plaintext;
1006
1007                 sg[0].page = virt_to_page(p);
1008                 sg[0].offset = ((long) p & ~PAGE_MASK);
1009                 sg[0].length = len;
1010
1011                 crypto_cipher_set_iv(tfm, des_tv[i].iv,
1012                                      crypto_tfm_alg_ivsize(tfm));
1013
1014                 ret = crypto_cipher_encrypt(tfm, sg, 1);
1015                 if (ret) {
1016                         printk("des_cbc_encrypt() failed flags=%x\n",
1017                                tfm->crt_flags);
1018                         goto out;
1019                 }
1020
1021                 q = kmap(sg[0].page) + sg[0].offset;
1022                 hexdump(q, len);
1023
1024                 printk("%s\n",
1025                        memcmp(q, des_tv[i].result, len) ? "fail" : "pass");
1026         }
1027
1028         crypto_free_tfm(tfm);
1029
1030         /*
1031          * Scenario F:
1032          *
1033          *  F1       F2
1034          *  [8 + 5]  [3 + 8]
1035          *
1036          */
1037         printk("\ntesting des cbc encryption chunking scenario F\n");
1038         i = 4;
1039
1040         tfm = crypto_alloc_tfm("des", CRYPTO_TFM_MODE_CBC);
1041         if (tfm == NULL) {
1042                 printk("failed to load transform for CRYPTO_ALG_DES_CCB\n");
1043                 return;
1044         }
1045
1046         tfm->crt_flags = 0;
1047         key = des_tv[i].key;
1048
1049         ret = crypto_cipher_setkey(tfm, key, 8);
1050         if (ret) {
1051                 printk("setkey() failed flags=%x\n", tfm->crt_flags);
1052                 goto out;
1053         }
1054
1055         /* setup the dummy buffer first */
1056         memset(xbuf, 0, sizeof (xbuf));
1057
1058         memcpy(&xbuf[IDX1], des_tv[i].plaintext, 13);
1059         memcpy(&xbuf[IDX2], des_tv[i].plaintext + 13, 11);
1060
1061         p = &xbuf[IDX1];
1062         sg[0].page = virt_to_page(p);
1063         sg[0].offset = ((long) p & ~PAGE_MASK);
1064         sg[0].length = 13;
1065
1066         p = &xbuf[IDX2];
1067         sg[1].page = virt_to_page(p);
1068         sg[1].offset = ((long) p & ~PAGE_MASK);
1069         sg[1].length = 11;
1070
1071         crypto_cipher_set_iv(tfm, des_tv[i].iv, crypto_tfm_alg_ivsize(tfm));
1072
1073         ret = crypto_cipher_encrypt(tfm, sg, 2);
1074         if (ret) {
1075                 printk("des_cbc_decrypt() failed flags=%x\n", tfm->crt_flags);
1076                 goto out;
1077         }
1078
1079         printk("page 1\n");
1080         q = kmap(sg[0].page) + sg[0].offset;
1081         hexdump(q, 13);
1082         printk("%s\n", memcmp(q, des_tv[i].result, 13) ? "fail" : "pass");
1083
1084         printk("page 2\n");
1085         q = kmap(sg[1].page) + sg[1].offset;
1086         hexdump(q, 11);
1087         printk("%s\n", memcmp(q, des_tv[i].result + 13, 11) ? "fail" : "pass");
1088
1089         tsize = sizeof (des_cbc_dec_tv_template);
1090         if (tsize > TVMEMSIZE) {
1091                 printk("template (%u) too big for tvmem (%u)\n", tsize,
1092                        TVMEMSIZE);
1093                 return;
1094         }
1095         memcpy(tvmem, des_cbc_dec_tv_template, tsize);
1096         des_tv = (void *) tvmem;
1097
1098         printk("\ntesting des cbc decryption\n");
1099
1100         for (i = 0; i < DES_CBC_DEC_TEST_VECTORS; i++) {
1101                 printk("test %u:\n", i + 1);
1102
1103                 tfm->crt_flags = 0;
1104                 key = des_tv[i].key;
1105
1106                 ret = crypto_cipher_setkey(tfm, key, 8);
1107                 if (ret) {
1108                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
1109                         goto out;
1110                 }
1111
1112                 len = des_tv[i].len;
1113                 p = des_tv[i].plaintext;
1114
1115                 sg[0].page = virt_to_page(p);
1116                 sg[0].offset = ((long) p & ~PAGE_MASK);
1117                 sg[0].length = len;
1118
1119                 crypto_cipher_set_iv(tfm, des_tv[i].iv,
1120                                       crypto_tfm_alg_blocksize(tfm));
1121
1122                 ret = crypto_cipher_decrypt(tfm, sg, 1);
1123                 if (ret) {
1124                         printk("des_cbc_decrypt() failed flags=%x\n",
1125                                tfm->crt_flags);
1126                         goto out;
1127                 }
1128
1129                 hexdump(tfm->crt_cipher.cit_iv, 8);
1130
1131                 q = kmap(sg[0].page) + sg[0].offset;
1132                 hexdump(q, len);
1133
1134                 printk("%s\n",
1135                        memcmp(q, des_tv[i].result, len) ? "fail" : "pass");
1136         }
1137
1138         /*
1139          * Scenario G:
1140          *
1141          *  F1   F2
1142          *  [4]  [4]
1143          *
1144          */
1145         printk("\ntesting des cbc decryption chunking scenario G\n");
1146         i = 3;
1147
1148         tfm->crt_flags = 0;
1149         key = des_tv[i].key;
1150
1151         ret = crypto_cipher_setkey(tfm, key, 8);
1152         if (ret) {
1153                 printk("setkey() failed flags=%x\n", tfm->crt_flags);
1154                 goto out;
1155         }
1156
1157         /* setup the dummy buffer first */
1158         memset(xbuf, 0, sizeof (xbuf));
1159         memcpy(&xbuf[IDX1], des_tv[i].plaintext, 4);
1160         memcpy(&xbuf[IDX2], des_tv[i].plaintext + 4, 4);
1161
1162         p = &xbuf[IDX1];
1163         sg[0].page = virt_to_page(p);
1164         sg[0].offset = ((long) p & ~PAGE_MASK);
1165         sg[0].length = 4;
1166
1167         p = &xbuf[IDX2];
1168         sg[1].page = virt_to_page(p);
1169         sg[1].offset = ((long) p & ~PAGE_MASK);
1170         sg[1].length = 4;
1171
1172         crypto_cipher_set_iv(tfm, des_tv[i].iv, crypto_tfm_alg_ivsize(tfm));
1173
1174         ret = crypto_cipher_decrypt(tfm, sg, 2);
1175         if (ret) {
1176                 printk("des_cbc_decrypt() failed flags=%x\n", tfm->crt_flags);
1177                 goto out;
1178         }
1179
1180         printk("page 1\n");
1181         q = kmap(sg[0].page) + sg[0].offset;
1182         hexdump(q, 4);
1183         printk("%s\n", memcmp(q, des_tv[i].result, 4) ? "fail" : "pass");
1184
1185         printk("page 2\n");
1186         q = kmap(sg[1].page) + sg[1].offset;
1187         hexdump(q, 4);
1188         printk("%s\n", memcmp(q, des_tv[i].result + 4, 4) ? "fail" : "pass");
1189
1190       out:
1191         crypto_free_tfm(tfm);
1192 }
1193
1194 void
1195 test_des3_ede(void)
1196 {
1197         unsigned int ret, i, len;
1198         unsigned int tsize;
1199         char *p, *q;
1200         struct crypto_tfm *tfm;
1201         char *key;
1202         /*char res[8]; */
1203         struct des_tv *des_tv;
1204         struct scatterlist sg[8];
1205
1206         printk("\ntesting des3 ede encryption\n");
1207
1208         tsize = sizeof (des3_ede_enc_tv_template);
1209         if (tsize > TVMEMSIZE) {
1210                 printk("template (%u) too big for tvmem (%u)\n", tsize,
1211                        TVMEMSIZE);
1212                 return;
1213         }
1214
1215         memcpy(tvmem, des3_ede_enc_tv_template, tsize);
1216         des_tv = (void *) tvmem;
1217
1218         tfm = crypto_alloc_tfm("des3_ede", CRYPTO_TFM_MODE_ECB);
1219         if (tfm == NULL) {
1220                 printk("failed to load transform for 3des ecb\n");
1221                 return;
1222         }
1223
1224         for (i = 0; i < DES3_EDE_ENC_TEST_VECTORS; i++) {
1225                 printk("test %u:\n", i + 1);
1226
1227                 key = des_tv[i].key;
1228                 ret = crypto_cipher_setkey(tfm, key, 24);
1229                 if (ret) {
1230                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
1231
1232                         if (!des_tv[i].fail)
1233                                 goto out;
1234                 }
1235
1236                 len = des_tv[i].len;
1237
1238                 p = des_tv[i].plaintext;
1239                 sg[0].page = virt_to_page(p);
1240                 sg[0].offset = ((long) p & ~PAGE_MASK);
1241                 sg[0].length = len;
1242                 ret = crypto_cipher_encrypt(tfm, sg, 1);
1243                 if (ret) {
1244                         printk("encrypt() failed flags=%x\n", tfm->crt_flags);
1245                         goto out;
1246                 }
1247
1248                 q = kmap(sg[0].page) + sg[0].offset;
1249                 hexdump(q, len);
1250
1251                 printk("%s\n",
1252                        memcmp(q, des_tv[i].result, len) ? "fail" : "pass");
1253         }
1254
1255         printk("\ntesting des3 ede decryption\n");
1256
1257         tsize = sizeof (des3_ede_dec_tv_template);
1258         if (tsize > TVMEMSIZE) {
1259                 printk("template (%u) too big for tvmem (%u)\n", tsize,
1260                        TVMEMSIZE);
1261                 return;
1262         }
1263
1264         memcpy(tvmem, des3_ede_dec_tv_template, tsize);
1265         des_tv = (void *) tvmem;
1266
1267         for (i = 0; i < DES3_EDE_DEC_TEST_VECTORS; i++) {
1268                 printk("test %u:\n", i + 1);
1269
1270                 key = des_tv[i].key;
1271                 ret = crypto_cipher_setkey(tfm, key, 24);
1272                 if (ret) {
1273                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
1274
1275                         if (!des_tv[i].fail)
1276                                 goto out;
1277                 }
1278
1279                 len = des_tv[i].len;
1280
1281                 p = des_tv[i].plaintext;
1282                 sg[0].page = virt_to_page(p);
1283                 sg[0].offset = ((long) p & ~PAGE_MASK);
1284                 sg[0].length = len;
1285                 ret = crypto_cipher_decrypt(tfm, sg, 1);
1286                 if (ret) {
1287                         printk("decrypt() failed flags=%x\n", tfm->crt_flags);
1288                         goto out;
1289                 }
1290
1291                 q = kmap(sg[0].page) + sg[0].offset;
1292                 hexdump(q, len);
1293
1294                 printk("%s\n",
1295                        memcmp(q, des_tv[i].result, len) ? "fail" : "pass");
1296         }
1297
1298       out:
1299         crypto_free_tfm(tfm);
1300 }
1301
1302 static void
1303 do_test(void)
1304 {
1305         switch (mode) {
1306
1307         case 0:
1308                 test_md5();
1309                 test_sha1();
1310                 test_des();
1311                 test_des3_ede();
1312                 test_md4();
1313                 break;
1314
1315         case 1:
1316                 test_md5();
1317                 break;
1318
1319         case 2:
1320                 test_sha1();
1321                 break;
1322
1323         case 3:
1324                 test_des();
1325                 break;
1326
1327         case 4:
1328                 test_des3_ede();
1329                 break;
1330
1331         case 5:
1332                 test_md4();
1333                 break;
1334
1335         default:
1336                 /* useful for debugging */
1337                 printk("not testing anything\n");
1338                 break;
1339         }
1340 }
1341
1342 static int __init
1343 init(void)
1344 {
1345         tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL);
1346         if (tvmem == NULL)
1347                 return -ENOMEM;
1348
1349         xbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
1350         if (xbuf == NULL) {
1351                 kfree(tvmem);
1352                 return -ENOMEM;
1353         }
1354
1355         do_test();
1356
1357         kfree(xbuf);
1358         kfree(tvmem);
1359         return 0;
1360 }
1361
1362 module_init(init);
1363
1364 MODULE_PARM(mode, "i");
1365
1366 MODULE_LICENSE("GPL");
1367 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
1368 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");