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;
  46 static char *xbuf;
  47 static char *tvmem;
  48
  49 static char *check[] = {
  50         "des", "md5", "des3_ede", "rot13", "sha1", "sha256", "blowfish",
  51         "twofish", "serpent", "sha384", "sha512", "md4", "aes", "deflate",
  52          NULL
  53 };
  54
  55 static void
  56 hexdump(unsigned char *buf, unsigned int len)
  57 {
  58         while (len--)
  59                 printk("%02x", *buf++);
  60
  61         printk("\n");
  62 }
  63
  64 static void
  65 test_md5(void)
  66 {
  67         char *p;
  68         unsigned int i;
  69         struct scatterlist sg[2];
  70         char result[128];
  71         struct crypto_tfm *tfm;
  72         struct md5_testvec *md5_tv;
  73         unsigned int tsize;
  74
  75         printk("\ntesting md5\n");
  76
  77         tsize = sizeof (md5_tv_template);
  78         if (tsize > TVMEMSIZE) {
  79                 printk("template (%u) too big for tvmem (%u)\n", tsize,
  80                        TVMEMSIZE);
  81                 return;
  82         }
  83
  84         memcpy(tvmem, md5_tv_template, tsize);
  85         md5_tv = (void *) tvmem;
  86
  87         tfm = crypto_alloc_tfm("md5", 0);
  88         if (tfm == NULL) {
  89                 printk("failed to load transform for md5\n");
  90                 return;
  91         }
  92
  93         for (i = 0; i < MD5_TEST_VECTORS; i++) {
  94                 printk("test %u:\n", i + 1);
  95                 memset(result, 0, sizeof (result));
  96
  97                 p = md5_tv[i].plaintext;
  98                 sg[0].page = virt_to_page(p);
  99                 sg[0].offset = ((long) p & ~PAGE_MASK);
 100                 sg[0].length = strlen(md5_tv[i].plaintext);
 101
 102                 crypto_digest_init(tfm);
 103                 crypto_digest_update(tfm, sg, 1);
 104                 crypto_digest_final(tfm, result);
 105
 106                 hexdump(result, crypto_tfm_alg_digestsize(tfm));
 107                 printk("%s\n",
 108                        memcmp(result, md5_tv[i].digest,
 109                               crypto_tfm_alg_digestsize(tfm)) ? "fail" :
 110                        "pass");
 111         }
 112
 113         printk("\ntesting md5 across pages\n");
 114
 115         /* setup the dummy buffer first */
 116         memset(xbuf, 0, XBUFSIZE);
 117         memcpy(&xbuf[IDX1], "abcdefghijklm", 13);
 118         memcpy(&xbuf[IDX2], "nopqrstuvwxyz", 13);
 119
 120         p = &xbuf[IDX1];
 121         sg[0].page = virt_to_page(p);
 122         sg[0].offset = ((long) p & ~PAGE_MASK);
 123         sg[0].length = 13;
 124
 125         p = &xbuf[IDX2];
 126         sg[1].page = virt_to_page(p);
 127         sg[1].offset = ((long) p & ~PAGE_MASK);
 128         sg[1].length = 13;
 129
 130         memset(result, 0, sizeof (result));
 131         crypto_digest_digest(tfm, sg, 2, result);
 132         hexdump(result, crypto_tfm_alg_digestsize(tfm));
 133
 134         printk("%s\n",
 135                memcmp(result, md5_tv[4].digest,
 136                       crypto_tfm_alg_digestsize(tfm)) ? "fail" : "pass");
 137         crypto_free_tfm(tfm);
 138 }
 139
 140 #ifdef CONFIG_CRYPTO_HMAC
 141 static void
 142 test_hmac_md5(void)
 143 {
 144         char *p;
 145         unsigned int i, klen;
 146         struct scatterlist sg[2];
 147         char result[128];
 148         struct crypto_tfm *tfm;
 149         struct hmac_md5_testvec *hmac_md5_tv;
 150         unsigned int tsize;
 151
 152         tfm = crypto_alloc_tfm("md5", 0);
 153         if (tfm == NULL) {
 154                 printk("failed to load transform for md5\n");
 155                 return;
 156         }
 157
 158         printk("\ntesting hmac_md5\n");
 159
 160         tsize = sizeof (hmac_md5_tv_template);
 161         if (tsize > TVMEMSIZE) {
 162                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 163                        TVMEMSIZE);
 164                 goto out;
 165         }
 166
 167         memcpy(tvmem, hmac_md5_tv_template, tsize);
 168         hmac_md5_tv = (void *) tvmem;
 169
 170         for (i = 0; i < HMAC_MD5_TEST_VECTORS; i++) {
 171                 printk("test %u:\n", i + 1);
 172                 memset(result, 0, sizeof (result));
 173
 174                 p = hmac_md5_tv[i].plaintext;
 175                 sg[0].page = virt_to_page(p);
 176                 sg[0].offset = ((long) p & ~PAGE_MASK);
 177                 sg[0].length = strlen(hmac_md5_tv[i].plaintext);
 178
 179                 klen = strlen(hmac_md5_tv[i].key);
 180                 crypto_hmac(tfm, hmac_md5_tv[i].key, &klen, sg, 1, result);
 181
 182                 hexdump(result, crypto_tfm_alg_digestsize(tfm));
 183                 printk("%s\n",
 184                        memcmp(result, hmac_md5_tv[i].digest,
 185                               crypto_tfm_alg_digestsize(tfm)) ? "fail" :
 186                        "pass");
 187         }
 188
 189         printk("\ntesting hmac_md5 across pages\n");
 190
 191         memset(xbuf, 0, XBUFSIZE);
 192
 193         memcpy(&xbuf[IDX1], "what do ya want ", 16);
 194         memcpy(&xbuf[IDX2], "for nothing?", 12);
 195
 196         p = &xbuf[IDX1];
 197         sg[0].page = virt_to_page(p);
 198         sg[0].offset = ((long) p & ~PAGE_MASK);
 199         sg[0].length = 16;
 200
 201         p = &xbuf[IDX2];
 202         sg[1].page = virt_to_page(p);
 203         sg[1].offset = ((long) p & ~PAGE_MASK);
 204         sg[1].length = 12;
 205
 206         memset(result, 0, sizeof (result));
 207         klen = strlen(hmac_md5_tv[7].key);
 208         crypto_hmac(tfm, hmac_md5_tv[7].key, &klen, sg, 2, result);
 209         hexdump(result, crypto_tfm_alg_digestsize(tfm));
 210
 211         printk("%s\n",
 212                memcmp(result, hmac_md5_tv[7].digest,
 213                       crypto_tfm_alg_digestsize(tfm)) ? "fail" : "pass");
 214 out:
 215         crypto_free_tfm(tfm);
 216 }
 217
 218 static void
 219 test_hmac_sha1(void)
 220 {
 221         char *p;
 222         unsigned int i, klen;
 223         struct crypto_tfm *tfm;
 224         struct hmac_sha1_testvec *hmac_sha1_tv;
 225         struct scatterlist sg[2];
 226         unsigned int tsize;
 227         char result[SHA1_DIGEST_SIZE];
 228
 229         tfm = crypto_alloc_tfm("sha1", 0);
 230         if (tfm == NULL) {
 231                 printk("failed to load transform for sha1\n");
 232                 return;
 233         }
 234
 235         printk("\ntesting hmac_sha1\n");
 236
 237         tsize = sizeof (hmac_sha1_tv_template);
 238         if (tsize > TVMEMSIZE) {
 239                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 240                        TVMEMSIZE);
 241                 goto out;
 242         }
 243
 244         memcpy(tvmem, hmac_sha1_tv_template, tsize);
 245         hmac_sha1_tv = (void *) tvmem;
 246
 247         for (i = 0; i < HMAC_SHA1_TEST_VECTORS; i++) {
 248                 printk("test %u:\n", i + 1);
 249                 memset(result, 0, sizeof (result));
 250
 251                 p = hmac_sha1_tv[i].plaintext;
 252                 sg[0].page = virt_to_page(p);
 253                 sg[0].offset = ((long) p & ~PAGE_MASK);
 254                 sg[0].length = strlen(hmac_sha1_tv[i].plaintext);
 255
 256                 klen = strlen(hmac_sha1_tv[i].key);
 257
 258                 crypto_hmac(tfm, hmac_sha1_tv[i].key, &klen, sg, 1, result);
 259
 260                 hexdump(result, sizeof (result));
 261                 printk("%s\n",
 262                        memcmp(result, hmac_sha1_tv[i].digest,
 263                               crypto_tfm_alg_digestsize(tfm)) ? "fail" :
 264                        "pass");
 265         }
 266
 267         printk("\ntesting hmac_sha1 across pages\n");
 268
 269         /* setup the dummy buffer first */
 270         memset(xbuf, 0, XBUFSIZE);
 271
 272         memcpy(&xbuf[IDX1], "what do ya want ", 16);
 273         memcpy(&xbuf[IDX2], "for nothing?", 12);
 274
 275         p = &xbuf[IDX1];
 276         sg[0].page = virt_to_page(p);
 277         sg[0].offset = ((long) p & ~PAGE_MASK);
 278         sg[0].length = 16;
 279
 280         p = &xbuf[IDX2];
 281         sg[1].page = virt_to_page(p);
 282         sg[1].offset = ((long) p & ~PAGE_MASK);
 283         sg[1].length = 12;
 284
 285         memset(result, 0, sizeof (result));
 286         klen = strlen(hmac_sha1_tv[7].key);
 287         crypto_hmac(tfm, hmac_sha1_tv[7].key, &klen, sg, 2, result);
 288         hexdump(result, crypto_tfm_alg_digestsize(tfm));
 289
 290         printk("%s\n",
 291                memcmp(result, hmac_sha1_tv[7].digest,
 292                       crypto_tfm_alg_digestsize(tfm)) ? "fail" : "pass");
 293 out:
 294         crypto_free_tfm(tfm);
 295 }
 296
 297 static void
 298 test_hmac_sha256(void)
 299 {
 300         char *p;
 301         unsigned int i, klen;
 302         struct crypto_tfm *tfm;
 303         struct hmac_sha256_testvec *hmac_sha256_tv;
 304         struct scatterlist sg[2];
 305         unsigned int tsize;
 306         char result[SHA256_DIGEST_SIZE];
 307
 308         tfm = crypto_alloc_tfm("sha256", 0);
 309         if (tfm == NULL) {
 310                 printk("failed to load transform for sha256\n");
 311                 return;
 312         }
 313
 314         printk("\ntesting hmac_sha256\n");
 315
 316         tsize = sizeof (hmac_sha256_tv_template);
 317         if (tsize > TVMEMSIZE) {
 318                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 319                        TVMEMSIZE);
 320                 goto out;
 321         }
 322
 323         memcpy(tvmem, hmac_sha256_tv_template, tsize);
 324         hmac_sha256_tv = (void *) tvmem;
 325
 326         for (i = 0; i < HMAC_SHA256_TEST_VECTORS; i++) {
 327                 printk("test %u:\n", i + 1);
 328                 memset(result, 0, sizeof (result));
 329
 330                 p = hmac_sha256_tv[i].plaintext;
 331                 sg[0].page = virt_to_page(p);
 332                 sg[0].offset = ((long) p & ~PAGE_MASK);
 333                 sg[0].length = strlen(hmac_sha256_tv[i].plaintext);
 334
 335                 klen = strlen(hmac_sha256_tv[i].key);
 336
 337                 hexdump(hmac_sha256_tv[i].key, strlen(hmac_sha256_tv[i].key));
 338                 crypto_hmac(tfm, hmac_sha256_tv[i].key, &klen, sg, 1, result);
 339                 hexdump(result, crypto_tfm_alg_digestsize(tfm));
 340                 printk("%s\n",
 341                        memcmp(result, hmac_sha256_tv[i].digest,
 342                        crypto_tfm_alg_digestsize(tfm)) ? "fail" : "pass");
 343         }
 344
 345 out:
 346         crypto_free_tfm(tfm);
 347 }
 348
 349 #endif  /* CONFIG_CRYPTO_HMAC */
 350
 351 static void
 352 test_md4(void)
 353 {
 354         char *p;
 355         unsigned int i;
 356         struct scatterlist sg[1];
 357         char result[128];
 358         struct crypto_tfm *tfm;
 359         struct md4_testvec *md4_tv;
 360         unsigned int tsize;
 361
 362         printk("\ntesting md4\n");
 363
 364         tsize = sizeof (md4_tv_template);
 365         if (tsize > TVMEMSIZE) {
 366                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 367                        TVMEMSIZE);
 368                 return;
 369         }
 370
 371         memcpy(tvmem, md4_tv_template, tsize);
 372         md4_tv = (void *) tvmem;
 373
 374         tfm = crypto_alloc_tfm("md4", 0);
 375         if (tfm == NULL) {
 376                 printk("failed to load transform for md4\n");
 377                 return;
 378         }
 379
 380         for (i = 0; i < MD4_TEST_VECTORS; i++) {
 381                 printk("test %u:\n", i + 1);
 382                 memset(result, 0, sizeof (result));
 383
 384                 p = md4_tv[i].plaintext;
 385                 sg[0].page = virt_to_page(p);
 386                 sg[0].offset = ((long) p & ~PAGE_MASK);
 387                 sg[0].length = strlen(md4_tv[i].plaintext);
 388
 389                 crypto_digest_digest(tfm, sg, 1, result);
 390
 391                 hexdump(result, crypto_tfm_alg_digestsize(tfm));
 392                 printk("%s\n",
 393                        memcmp(result, md4_tv[i].digest,
 394                               crypto_tfm_alg_digestsize(tfm)) ? "fail" :
 395                        "pass");
 396         }
 397
 398         crypto_free_tfm(tfm);
 399 }
 400
 401 static void
 402 test_sha1(void)
 403 {
 404         char *p;
 405         unsigned int i;
 406         struct crypto_tfm *tfm;
 407         struct sha1_testvec *sha1_tv;
 408         struct scatterlist sg[2];
 409         unsigned int tsize;
 410         char result[SHA1_DIGEST_SIZE];
 411
 412         printk("\ntesting sha1\n");
 413
 414         tsize = sizeof (sha1_tv_template);
 415         if (tsize > TVMEMSIZE) {
 416                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 417                        TVMEMSIZE);
 418                 return;
 419         }
 420
 421         memcpy(tvmem, sha1_tv_template, tsize);
 422         sha1_tv = (void *) tvmem;
 423
 424         tfm = crypto_alloc_tfm("sha1", 0);
 425         if (tfm == NULL) {
 426                 printk("failed to load transform for sha1\n");
 427                 return;
 428         }
 429
 430         for (i = 0; i < SHA1_TEST_VECTORS; i++) {
 431                 printk("test %u:\n", i + 1);
 432                 memset(result, 0, sizeof (result));
 433
 434                 p = sha1_tv[i].plaintext;
 435                 sg[0].page = virt_to_page(p);
 436                 sg[0].offset = ((long) p & ~PAGE_MASK);
 437                 sg[0].length = strlen(sha1_tv[i].plaintext);
 438
 439                 crypto_digest_init(tfm);
 440                 crypto_digest_update(tfm, sg, 1);
 441                 crypto_digest_final(tfm, result);
 442
 443                 hexdump(result, crypto_tfm_alg_digestsize(tfm));
 444                 printk("%s\n",
 445                        memcmp(result, sha1_tv[i].digest,
 446                               crypto_tfm_alg_digestsize(tfm)) ? "fail" :
 447                        "pass");
 448         }
 449
 450         printk("\ntesting sha1 across pages\n");
 451
 452         /* setup the dummy buffer first */
 453         memset(xbuf, 0, XBUFSIZE);
 454         memcpy(&xbuf[IDX1], "abcdbcdecdefdefgefghfghighij", 28);
 455         memcpy(&xbuf[IDX2], "hijkijkljklmklmnlmnomnopnopq", 28);
 456
 457         p = &xbuf[IDX1];
 458         sg[0].page = virt_to_page(p);
 459         sg[0].offset = ((long) p & ~PAGE_MASK);
 460         sg[0].length = 28;
 461
 462         p = &xbuf[IDX2];
 463         sg[1].page = virt_to_page(p);
 464         sg[1].offset = ((long) p & ~PAGE_MASK);
 465         sg[1].length = 28;
 466
 467         memset(result, 0, sizeof (result));
 468         crypto_digest_digest(tfm, sg, 2, result);
 469         hexdump(result, crypto_tfm_alg_digestsize(tfm));
 470         printk("%s\n",
 471                memcmp(result, sha1_tv[1].digest,
 472                       crypto_tfm_alg_digestsize(tfm)) ? "fail" : "pass");
 473         crypto_free_tfm(tfm);
 474 }
 475
 476 static void
 477 test_sha256(void)
 478 {
 479         char *p;
 480         unsigned int i;
 481         struct crypto_tfm *tfm;
 482         struct sha256_testvec *sha256_tv;
 483         struct scatterlist sg[2];
 484         unsigned int tsize;
 485         char result[SHA256_DIGEST_SIZE];
 486
 487         printk("\ntesting sha256\n");
 488
 489         tsize = sizeof (sha256_tv_template);
 490         if (tsize > TVMEMSIZE) {
 491                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 492                        TVMEMSIZE);
 493                 return;
 494         }
 495
 496         memcpy(tvmem, sha256_tv_template, tsize);
 497         sha256_tv = (void *) tvmem;
 498
 499         tfm = crypto_alloc_tfm("sha256", 0);
 500         if (tfm == NULL) {
 501                 printk("failed to load transform for sha256\n");
 502                 return;
 503         }
 504
 505         for (i = 0; i < SHA256_TEST_VECTORS; i++) {
 506                 printk("test %u:\n", i + 1);
 507                 memset(result, 0, sizeof (result));
 508
 509                 p = sha256_tv[i].plaintext;
 510                 sg[0].page = virt_to_page(p);
 511                 sg[0].offset = ((long) p & ~PAGE_MASK);
 512                 sg[0].length = strlen(sha256_tv[i].plaintext);
 513
 514                 crypto_digest_init(tfm);
 515                 crypto_digest_update(tfm, sg, 1);
 516                 crypto_digest_final(tfm, result);
 517
 518                 hexdump(result, crypto_tfm_alg_digestsize(tfm));
 519                 printk("%s\n",
 520                        memcmp(result, sha256_tv[i].digest,
 521                               crypto_tfm_alg_digestsize(tfm)) ? "fail" :
 522                        "pass");
 523         }
 524
 525         printk("\ntesting sha256 across pages\n");
 526
 527         /* setup the dummy buffer first */
 528         memset(xbuf, 0, XBUFSIZE);
 529         memcpy(&xbuf[IDX1], "abcdbcdecdefdefgefghfghighij", 28);
 530         memcpy(&xbuf[IDX2], "hijkijkljklmklmnlmnomnopnopq", 28);
 531
 532         p = &xbuf[IDX1];
 533         sg[0].page = virt_to_page(p);
 534         sg[0].offset = ((long) p & ~PAGE_MASK);
 535         sg[0].length = 28;
 536
 537         p = &xbuf[IDX2];
 538         sg[1].page = virt_to_page(p);
 539         sg[1].offset = ((long) p & ~PAGE_MASK);
 540         sg[1].length = 28;
 541
 542         memset(result, 0, sizeof (result));
 543         crypto_digest_digest(tfm, sg, 2, result);
 544         hexdump(result, crypto_tfm_alg_digestsize(tfm));
 545         printk("%s\n",
 546                memcmp(result, sha256_tv[1].digest,
 547                       crypto_tfm_alg_digestsize(tfm)) ? "fail" : "pass");
 548
 549         crypto_free_tfm(tfm);
 550 }
 551
 552 static void
 553 test_sha384(void)
 554 {
 555         char *p;
 556         unsigned int i;
 557         struct crypto_tfm *tfm;
 558         struct sha384_testvec *sha384_tv;
 559         struct scatterlist sg[2];
 560         unsigned int tsize;
 561         char result[SHA384_DIGEST_SIZE];
 562
 563         printk("\ntesting sha384\n");
 564
 565         tsize = sizeof (sha384_tv_template);
 566         if (tsize > TVMEMSIZE) {
 567                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 568                        TVMEMSIZE);
 569                 return;
 570         }
 571
 572         memcpy(tvmem, sha384_tv_template, tsize);
 573         sha384_tv = (void *) tvmem;
 574
 575         tfm = crypto_alloc_tfm("sha384", 0);
 576         if (tfm == NULL) {
 577                 printk("failed to load transform for sha384\n");
 578                 return;
 579         }
 580
 581         for (i = 0; i < SHA384_TEST_VECTORS; i++) {
 582                 printk("test %u:\n", i + 1);
 583                 memset(result, 0, sizeof (result));
 584
 585                 p = sha384_tv[i].plaintext;
 586                 sg[0].page = virt_to_page(p);
 587                 sg[0].offset = ((long) p & ~PAGE_MASK);
 588                 sg[0].length = strlen(sha384_tv[i].plaintext);
 589
 590                 crypto_digest_init(tfm);
 591                 crypto_digest_update(tfm, sg, 1);
 592                 crypto_digest_final(tfm, result);
 593
 594                 hexdump(result, crypto_tfm_alg_digestsize(tfm));
 595                 printk("%s\n",
 596                        memcmp(result, sha384_tv[i].digest,
 597                               crypto_tfm_alg_digestsize(tfm)) ? "fail" :
 598                        "pass");
 599         }
 600
 601         crypto_free_tfm(tfm);
 602 }
 603
 604 static void
 605 test_sha512(void)
 606 {
 607         char *p;
 608         unsigned int i;
 609         struct crypto_tfm *tfm;
 610         struct sha512_testvec *sha512_tv;
 611         struct scatterlist sg[2];
 612         unsigned int tsize;
 613         char result[SHA512_DIGEST_SIZE];
 614
 615         printk("\ntesting sha512\n");
 616
 617         tsize = sizeof (sha512_tv_template);
 618         if (tsize > TVMEMSIZE) {
 619                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 620                        TVMEMSIZE);
 621                 return;
 622         }
 623
 624         memcpy(tvmem, sha512_tv_template, tsize);
 625         sha512_tv = (void *) tvmem;
 626
 627         tfm = crypto_alloc_tfm("sha512", 0);
 628         if (tfm == NULL) {
 629                 printk("failed to load transform for sha512\n");
 630                 return;
 631         }
 632
 633         for (i = 0; i < SHA512_TEST_VECTORS; i++) {
 634                 printk("test %u:\n", i + 1);
 635                 memset(result, 0, sizeof (result));
 636
 637                 p = sha512_tv[i].plaintext;
 638                 sg[0].page = virt_to_page(p);
 639                 sg[0].offset = ((long) p & ~PAGE_MASK);
 640                 sg[0].length = strlen(sha512_tv[i].plaintext);
 641
 642                 crypto_digest_init(tfm);
 643                 crypto_digest_update(tfm, sg, 1);
 644                 crypto_digest_final(tfm, result);
 645
 646                 hexdump(result, crypto_tfm_alg_digestsize(tfm));
 647                 printk("%s\n",
 648                        memcmp(result, sha512_tv[i].digest,
 649                               crypto_tfm_alg_digestsize(tfm)) ? "fail" :
 650                        "pass");
 651         }
 652
 653         crypto_free_tfm(tfm);
 654 }
 655
 656 void
 657 test_des(void)
 658 {
 659         unsigned int ret, i, len;
 660         unsigned int tsize;
 661         char *p, *q;
 662         struct crypto_tfm *tfm;
 663         char *key;
 664         char res[8];
 665         struct des_tv *des_tv;
 666         struct scatterlist sg[8];
 667
 668         printk("\ntesting des encryption\n");
 669
 670         tsize = sizeof (des_enc_tv_template);
 671         if (tsize > TVMEMSIZE) {
 672                 printk("template (%u) too big for tvmem (%u)\n", tsize,
 673                        TVMEMSIZE);
 674                 return;
 675         }
 676
 677         memcpy(tvmem, des_enc_tv_template, tsize);
 678         des_tv = (void *) tvmem;
 679
 680         tfm = crypto_alloc_tfm("des", 0);
 681         if (tfm == NULL) {
 682                 printk("failed to load transform for des (default ecb)\n");
 683                 return;
 684         }
 685
 686         for (i = 0; i < DES_ENC_TEST_VECTORS; i++) {
 687                 printk("test %u:\n", i + 1);
 688
 689                 key = des_tv[i].key;
 690                 tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY;
 691
 692                 ret = crypto_cipher_setkey(tfm, key, 8);
 693                 if (ret) {
 694                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
 695
 696                         if (!des_tv[i].fail)
 697                                 goto out;
 698                 }
 699
 700                 len = des_tv[i].len;
 701
 702                 p = des_tv[i].plaintext;
 703                 sg[0].page = virt_to_page(p);
 704                 sg[0].offset = ((long) p & ~PAGE_MASK);
 705                 sg[0].length = len;
 706                 ret = crypto_cipher_encrypt(tfm, sg, sg, len);
 707                 if (ret) {
 708                         printk("encrypt() failed flags=%x\n", tfm->crt_flags);
 709                         goto out;
 710                 }
 711
 712                 q = kmap(sg[0].page) + sg[0].offset;
 713                 hexdump(q, len);
 714
 715                 printk("%s\n",
 716                        memcmp(q, des_tv[i].result, len) ? "fail" : "pass");
 717
 718         }
 719
 720         printk("\ntesting des ecb encryption across pages\n");
 721
 722         i = 5;
 723         key = des_tv[i].key;
 724         tfm->crt_flags = 0;
 725
 726         hexdump(key, 8);
 727
 728         ret = crypto_cipher_setkey(tfm, key, 8);
 729         if (ret) {
 730                 printk("setkey() failed flags=%x\n", tfm->crt_flags);
 731                 goto out;
 732         }
 733
 734         /* setup the dummy buffer first */
 735         memset(xbuf, 0, sizeof (xbuf));
 736         memcpy(&xbuf[IDX1], des_tv[i].plaintext, 8);
 737         memcpy(&xbuf[IDX2], des_tv[i].plaintext + 8, 8);
 738
 739         p = &xbuf[IDX1];
 740         sg[0].page = virt_to_page(p);
 741         sg[0].offset = ((long) p & ~PAGE_MASK);
 742         sg[0].length = 8;
 743
 744         p = &xbuf[IDX2];
 745         sg[1].page = virt_to_page(p);
 746         sg[1].offset = ((long) p & ~PAGE_MASK);
 747         sg[1].length = 8;
 748
 749         ret = crypto_cipher_encrypt(tfm, sg, sg, 16);
 750         if (ret) {
 751                 printk("encrypt() failed flags=%x\n", tfm->crt_flags);
 752                 goto out;
 753         }
 754
 755         printk("page 1\n");
 756         q = kmap(sg[0].page) + sg[0].offset;
 757         hexdump(q, 8);
 758         printk("%s\n", memcmp(q, des_tv[i].result, 8) ? "fail" : "pass");
 759
 760         printk("page 2\n");
 761         q = kmap(sg[1].page) + sg[1].offset;
 762         hexdump(q, 8);
 763         printk("%s\n", memcmp(q, des_tv[i].result + 8, 8) ? "fail" : "pass");
 764
 765         printk("\ntesting des ecb encryption chunking scenario A\n");
 766
 767         /*
 768          * Scenario A:
 769          *
 770          *  F1       F2      F3
 771          *  [8 + 6]  [2 + 8] [8]
 772          *       ^^^^^^   ^
 773          *       a    b   c
 774          *
 775          * Chunking should begin at a, then end with b, and
 776          * continue encrypting at an offset of 2 until c.
 777          *
 778          */
 779         i = 7;
 780
 781         key = des_tv[i].key;
 782         tfm->crt_flags = 0;
 783
 784         ret = crypto_cipher_setkey(tfm, key, 8);
 785         if (ret) {
 786                 printk("setkey() failed flags=%x\n", tfm->crt_flags);
 787                 goto out;
 788         }
 789
 790         /* setup the dummy buffer first */
 791         memset(xbuf, 0, sizeof (xbuf));
 792
 793         /* Frag 1: 8 + 6 */
 794         memcpy(&xbuf[IDX3], des_tv[i].plaintext, 14);
 795
 796         /* Frag 2: 2 + 8 */
 797         memcpy(&xbuf[IDX4], des_tv[i].plaintext + 14, 10);
 798
 799         /* Frag 3: 8 */
 800         memcpy(&xbuf[IDX5], des_tv[i].plaintext + 24, 8);
 801
 802         p = &xbuf[IDX3];
 803         sg[0].page = virt_to_page(p);
 804         sg[0].offset = ((long) p & ~PAGE_MASK);
 805         sg[0].length = 14;
 806
 807         p = &xbuf[IDX4];
 808         sg[1].page = virt_to_page(p);
 809         sg[1].offset = ((long) p & ~PAGE_MASK);
 810         sg[1].length = 10;
 811
 812         p = &xbuf[IDX5];
 813         sg[2].page = virt_to_page(p);
 814         sg[2].offset = ((long) p & ~PAGE_MASK);
 815         sg[2].length = 8;
 816
 817         ret = crypto_cipher_encrypt(tfm, sg, sg, 32);
 818
 819         if (ret) {
 820                 printk("decrypt() failed flags=%x\n", tfm->crt_flags);
 821                 goto out;
 822         }
 823
 824         printk("page 1\n");
 825         q = kmap(sg[0].page) + sg[0].offset;
 826         hexdump(q, 14);
 827         printk("%s\n", memcmp(q, des_tv[i].result, 14) ? "fail" : "pass");
 828
 829         printk("page 2\n");
 830         q = kmap(sg[1].page) + sg[1].offset;
 831         hexdump(q, 10);
 832         printk("%s\n", memcmp(q, des_tv[i].result + 14, 10) ? "fail" : "pass");
 833
 834         printk("page 3\n");
 835         q = kmap(sg[2].page) + sg[2].offset;
 836         hexdump(q, 8);
 837         printk("%s\n", memcmp(q, des_tv[i].result + 24, 8) ? "fail" : "pass");
 838
 839         printk("\ntesting des ecb encryption chunking scenario B\n");
 840
 841         /*
 842          * Scenario B:
 843          *
 844          *  F1  F2  F3  F4
 845          *  [2] [1] [3] [2 + 8 + 8]
 846          */
 847         i = 7;
 848
 849         key = des_tv[i].key;
 850         tfm->crt_flags = 0;
 851
 852         ret = crypto_cipher_setkey(tfm, key, 8);
 853         if (ret) {
 854                 printk("setkey() failed flags=%x\n", tfm->crt_flags);
 855                 goto out;
 856         }
 857
 858         /* setup the dummy buffer first */
 859         memset(xbuf, 0, sizeof (xbuf));
 860
 861         /* Frag 1: 2 */
 862         memcpy(&xbuf[IDX3], des_tv[i].plaintext, 2);
 863
 864         /* Frag 2: 1 */
 865         memcpy(&xbuf[IDX4], des_tv[i].plaintext + 2, 1);
 866
 867         /* Frag 3: 3 */
 868         memcpy(&xbuf[IDX5], des_tv[i].plaintext + 3, 3);
 869
 870         /* Frag 4: 2 + 8 + 8 */
 871         memcpy(&xbuf[IDX6], des_tv[i].plaintext + 6, 18);
 872
 873         p = &xbuf[IDX3];
 874         sg[0].page = virt_to_page(p);
 875         sg[0].offset = ((long) p & ~PAGE_MASK);
 876         sg[0].length = 2;
 877
 878         p = &xbuf[IDX4];
 879         sg[1].page = virt_to_page(p);
 880         sg[1].offset = ((long) p & ~PAGE_MASK);
 881         sg[1].length = 1;
 882
 883         p = &xbuf[IDX5];
 884         sg[2].page = virt_to_page(p);
 885         sg[2].offset = ((long) p & ~PAGE_MASK);
 886         sg[2].length = 3;
 887
 888         p = &xbuf[IDX6];
 889         sg[3].page = virt_to_page(p);
 890         sg[3].offset = ((long) p & ~PAGE_MASK);
 891         sg[3].length = 18;
 892
 893         ret = crypto_cipher_encrypt(tfm, sg, sg, 24);
 894
 895         if (ret) {
 896                 printk("encrypt() failed flags=%x\n", tfm->crt_flags);
 897                 goto out;
 898         }
 899
 900         printk("page 1\n");
 901         q = kmap(sg[0].page) + sg[0].offset;
 902         hexdump(q, 2);
 903         printk("%s\n", memcmp(q, des_tv[i].result, 2) ? "fail" : "pass");
 904
 905         printk("page 2\n");
 906         q = kmap(sg[1].page) + sg[1].offset;
 907         hexdump(q, 1);
 908         printk("%s\n", memcmp(q, des_tv[i].result + 2, 1) ? "fail" : "pass");
 909
 910         printk("page 3\n");
 911         q = kmap(sg[2].page) + sg[2].offset;
 912         hexdump(q, 3);
 913         printk("%s\n", memcmp(q, des_tv[i].result + 3, 3) ? "fail" : "pass");
 914
 915         printk("page 4\n");
 916         q = kmap(sg[3].page) + sg[3].offset;
 917         hexdump(q, 18);
 918         printk("%s\n", memcmp(q, des_tv[i].result + 6, 18) ? "fail" : "pass");
 919
 920         printk("\ntesting des ecb encryption chunking scenario C\n");
 921
 922         /*
 923          * Scenario B:
 924          *
 925          *  F1  F2  F3  F4  F5
 926          *  [2] [2] [2] [2] [8]
 927          */
 928         i = 7;
 929
 930         key = des_tv[i].key;
 931         tfm->crt_flags = 0;
 932
 933         ret = crypto_cipher_setkey(tfm, key, 8);
 934         if (ret) {
 935                 printk("setkey() failed flags=%x\n", tfm->crt_flags);
 936                 goto out;
 937         }
 938
 939         /* setup the dummy buffer first */
 940         memset(xbuf, 0, sizeof (xbuf));
 941
 942         /* Frag 1: 2 */
 943         memcpy(&xbuf[IDX3], des_tv[i].plaintext, 2);
 944
 945         /* Frag 2: 2 */
 946         memcpy(&xbuf[IDX4], des_tv[i].plaintext + 2, 2);
 947
 948         /* Frag 3: 2 */
 949         memcpy(&xbuf[IDX5], des_tv[i].plaintext + 4, 2);
 950
 951         /* Frag 4: 2 */
 952         memcpy(&xbuf[IDX6], des_tv[i].plaintext + 6, 2);
 953
 954         /* Frag 5: 8 */
 955         memcpy(&xbuf[IDX7], des_tv[i].plaintext + 8, 8);
 956
 957         p = &xbuf[IDX3];
 958         sg[0].page = virt_to_page(p);
 959         sg[0].offset = ((long) p & ~PAGE_MASK);
 960         sg[0].length = 2;
 961
 962         p = &xbuf[IDX4];
 963         sg[1].page = virt_to_page(p);
 964         sg[1].offset = ((long) p & ~PAGE_MASK);
 965         sg[1].length = 2;
 966
 967         p = &xbuf[IDX5];
 968         sg[2].page = virt_to_page(p);
 969         sg[2].offset = ((long) p & ~PAGE_MASK);
 970         sg[2].length = 2;
 971
 972         p = &xbuf[IDX6];
 973         sg[3].page = virt_to_page(p);
 974         sg[3].offset = ((long) p & ~PAGE_MASK);
 975         sg[3].length = 2;
 976
 977         p = &xbuf[IDX7];
 978         sg[4].page = virt_to_page(p);
 979         sg[4].offset = ((long) p & ~PAGE_MASK);
 980         sg[4].length = 8;
 981
 982         ret = crypto_cipher_encrypt(tfm, sg, sg, 16);
 983
 984         if (ret) {
 985                 printk("encrypt() failed flags=%x\n", tfm->crt_flags);
 986                 goto out;
 987         }
 988
 989         printk("page 1\n");
 990         q = kmap(sg[0].page) + sg[0].offset;
 991         hexdump(q, 2);
 992         printk("%s\n", memcmp(q, des_tv[i].result, 2) ? "fail" : "pass");
 993
 994         printk("page 2\n");
 995         q = kmap(sg[1].page) + sg[1].offset;
 996         hexdump(q, 2);
 997         printk("%s\n", memcmp(q, des_tv[i].result + 2, 2) ? "fail" : "pass");
 998
 999         printk("page 3\n");
1000         q = kmap(sg[2].page) + sg[2].offset;
1001         hexdump(q, 2);
1002         printk("%s\n", memcmp(q, des_tv[i].result + 4, 2) ? "fail" : "pass");
1003
1004         printk("page 4\n");
1005         q = kmap(sg[3].page) + sg[3].offset;
1006         hexdump(q, 2);
1007         printk("%s\n", memcmp(q, des_tv[i].result + 6, 2) ? "fail" : "pass");
1008
1009         printk("page 5\n");
1010         q = kmap(sg[4].page) + sg[4].offset;
1011         hexdump(q, 8);
1012         printk("%s\n", memcmp(q, des_tv[i].result + 8, 8) ? "fail" : "pass");
1013
1014         printk("\ntesting des ecb encryption chunking scenario D\n");
1015
1016         /*
1017          * Scenario D, torture test, one byte per frag.
1018          */
1019         i = 7;
1020         key = des_tv[i].key;
1021         tfm->crt_flags = 0;
1022
1023         ret = crypto_cipher_setkey(tfm, key, 8);
1024         if (ret) {
1025                 printk("setkey() failed flags=%x\n", tfm->crt_flags);
1026                 goto out;
1027         }
1028
1029         /* setup the dummy buffer first */
1030         memset(xbuf, 0, XBUFSIZE);
1031
1032         xbuf[IDX1] = des_tv[i].plaintext[0];
1033         xbuf[IDX2] = des_tv[i].plaintext[1];
1034         xbuf[IDX3] = des_tv[i].plaintext[2];
1035         xbuf[IDX4] = des_tv[i].plaintext[3];
1036         xbuf[IDX5] = des_tv[i].plaintext[4];
1037         xbuf[IDX6] = des_tv[i].plaintext[5];
1038         xbuf[IDX7] = des_tv[i].plaintext[6];
1039         xbuf[IDX8] = des_tv[i].plaintext[7];
1040
1041         p = &xbuf[IDX1];
1042         sg[0].page = virt_to_page(p);
1043         sg[0].offset = ((long) p & ~PAGE_MASK);
1044         sg[0].length = 1;
1045
1046         p = &xbuf[IDX2];
1047         sg[1].page = virt_to_page(p);
1048         sg[1].offset = ((long) p & ~PAGE_MASK);
1049         sg[1].length = 1;
1050
1051         p = &xbuf[IDX3];
1052         sg[2].page = virt_to_page(p);
1053         sg[2].offset = ((long) p & ~PAGE_MASK);
1054         sg[2].length = 1;
1055
1056         p = &xbuf[IDX4];
1057         sg[3].page = virt_to_page(p);
1058         sg[3].offset = ((long) p & ~PAGE_MASK);
1059         sg[3].length = 1;
1060
1061         p = &xbuf[IDX5];
1062         sg[4].page = virt_to_page(p);
1063         sg[4].offset = ((long) p & ~PAGE_MASK);
1064         sg[4].length = 1;
1065
1066         p = &xbuf[IDX6];
1067         sg[5].page = virt_to_page(p);
1068         sg[5].offset = ((long) p & ~PAGE_MASK);
1069         sg[5].length = 1;
1070
1071         p = &xbuf[IDX7];
1072         sg[6].page = virt_to_page(p);
1073         sg[6].offset = ((long) p & ~PAGE_MASK);
1074         sg[6].length = 1;
1075
1076         p = &xbuf[IDX8];
1077         sg[7].page = virt_to_page(p);
1078         sg[7].offset = ((long) p & ~PAGE_MASK);
1079         sg[7].length = 1;
1080
1081         ret = crypto_cipher_encrypt(tfm, sg, sg, 8);
1082         if (ret) {
1083                 printk("encrypt() failed flags=%x\n", tfm->crt_flags);
1084                 goto out;
1085         }
1086
1087         for (i = 0; i < 8; i++)
1088                 res[i] = *(char *) (kmap(sg[i].page) + sg[i].offset);
1089
1090         hexdump(res, 8);
1091         printk("%s\n", memcmp(res, des_tv[7].result, 8) ? "fail" : "pass");
1092
1093         printk("\ntesting des decryption\n");
1094
1095         tsize = sizeof (des_dec_tv_template);
1096         if (tsize > TVMEMSIZE) {
1097                 printk("template (%u) too big for tvmem (%u)\n", tsize,
1098                        TVMEMSIZE);
1099                 return;
1100         }
1101         memcpy(tvmem, des_dec_tv_template, tsize);
1102         des_tv = (void *) tvmem;
1103
1104         for (i = 0; i < DES_DEC_TEST_VECTORS; i++) {
1105                 printk("test %u:\n", i + 1);
1106
1107                 key = des_tv[i].key;
1108
1109                 tfm->crt_flags = 0;
1110                 ret = crypto_cipher_setkey(tfm, key, 8);
1111                 if (ret) {
1112                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
1113                         goto out;
1114                 }
1115
1116                 len = des_tv[i].len;
1117
1118                 p = des_tv[i].plaintext;
1119                 sg[0].page = virt_to_page(p);
1120                 sg[0].offset = ((long) p & ~PAGE_MASK);
1121                 sg[0].length = len;
1122
1123                 ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length);
1124                 if (ret) {
1125                         printk("des_decrypt() failed flags=%x\n",
1126                                tfm->crt_flags);
1127                         goto out;
1128                 }
1129
1130                 q = kmap(sg[0].page) + sg[0].offset;
1131                 hexdump(q, len);
1132
1133                 printk("%s\n",
1134                        memcmp(q, des_tv[i].result, len) ? "fail" : "pass");
1135
1136         }
1137
1138         printk("\ntesting des ecb decryption across pages\n");
1139
1140         i = 6;
1141
1142         key = des_tv[i].key;
1143         tfm->crt_flags = 0;
1144
1145         ret = crypto_cipher_setkey(tfm, key, 8);
1146         if (ret) {
1147                 printk("setkey() failed flags=%x\n", tfm->crt_flags);
1148                 goto out;
1149         }
1150
1151         /* setup the dummy buffer first */
1152         memset(xbuf, 0, sizeof (xbuf));
1153         memcpy(&xbuf[IDX1], des_tv[i].plaintext, 8);
1154         memcpy(&xbuf[IDX2], des_tv[i].plaintext + 8, 8);
1155
1156         p = &xbuf[IDX1];
1157         sg[0].page = virt_to_page(p);
1158         sg[0].offset = ((long) p & ~PAGE_MASK);
1159         sg[0].length = 8;
1160
1161         p = &xbuf[IDX2];
1162         sg[1].page = virt_to_page(p);
1163         sg[1].offset = ((long) p & ~PAGE_MASK);
1164         sg[1].length = 8;
1165
1166         ret = crypto_cipher_decrypt(tfm, sg, sg, 16);
1167         if (ret) {
1168                 printk("decrypt() failed flags=%x\n", tfm->crt_flags);
1169                 goto out;
1170         }
1171
1172         printk("page 1\n");
1173         q = kmap(sg[0].page) + sg[0].offset;
1174         hexdump(q, 8);
1175         printk("%s\n", memcmp(q, des_tv[i].result, 8) ? "fail" : "pass");
1176
1177         printk("page 2\n");
1178         q = kmap(sg[1].page) + sg[1].offset;
1179         hexdump(q, 8);
1180         printk("%s\n", memcmp(q, des_tv[i].result + 8, 8) ? "fail" : "pass");
1181
1182         /*
1183          * Scenario E:
1184          *
1185          *  F1   F2      F3
1186          *  [3]  [5 + 7] [1]
1187          *
1188          */
1189         printk("\ntesting des ecb decryption chunking scenario E\n");
1190         i = 2;
1191
1192         key = des_tv[i].key;
1193         tfm->crt_flags = 0;
1194
1195         ret = crypto_cipher_setkey(tfm, key, 8);
1196         if (ret) {
1197                 printk("setkey() failed flags=%x\n", tfm->crt_flags);
1198                 goto out;
1199         }
1200
1201         /* setup the dummy buffer first */
1202         memset(xbuf, 0, sizeof (xbuf));
1203
1204         memcpy(&xbuf[IDX1], des_tv[i].plaintext, 3);
1205         memcpy(&xbuf[IDX2], des_tv[i].plaintext + 3, 12);
1206         memcpy(&xbuf[IDX3], des_tv[i].plaintext + 15, 1);
1207
1208         p = &xbuf[IDX1];
1209         sg[0].page = virt_to_page(p);
1210         sg[0].offset = ((long) p & ~PAGE_MASK);
1211         sg[0].length = 3;
1212
1213         p = &xbuf[IDX2];
1214         sg[1].page = virt_to_page(p);
1215         sg[1].offset = ((long) p & ~PAGE_MASK);
1216         sg[1].length = 12;
1217
1218         p = &xbuf[IDX3];
1219         sg[2].page = virt_to_page(p);
1220         sg[2].offset = ((long) p & ~PAGE_MASK);
1221         sg[2].length = 1;
1222
1223         ret = crypto_cipher_decrypt(tfm, sg, sg, 16);
1224
1225         if (ret) {
1226                 printk("decrypt() failed flags=%x\n", tfm->crt_flags);
1227                 goto out;
1228         }
1229
1230         printk("page 1\n");
1231         q = kmap(sg[0].page) + sg[0].offset;
1232         hexdump(q, 3);
1233         printk("%s\n", memcmp(q, des_tv[i].result, 3) ? "fail" : "pass");
1234
1235         printk("page 2\n");
1236         q = kmap(sg[1].page) + sg[1].offset;
1237         hexdump(q, 12);
1238         printk("%s\n", memcmp(q, des_tv[i].result + 3, 12) ? "fail" : "pass");
1239
1240         printk("page 3\n");
1241         q = kmap(sg[2].page) + sg[2].offset;
1242         hexdump(q, 1);
1243         printk("%s\n", memcmp(q, des_tv[i].result + 15, 1) ? "fail" : "pass");
1244
1245         crypto_free_tfm(tfm);
1246
1247         tfm = crypto_alloc_tfm("des", CRYPTO_TFM_MODE_CBC);
1248         if (tfm == NULL) {
1249                 printk("failed to load transform for des cbc\n");
1250                 return;
1251         }
1252
1253         printk("\ntesting des cbc encryption\n");
1254
1255         tsize = sizeof (des_cbc_enc_tv_template);
1256         if (tsize > TVMEMSIZE) {
1257                 printk("template (%u) too big for tvmem (%u)\n", tsize,
1258                        TVMEMSIZE);
1259                 return;
1260         }
1261         memcpy(tvmem, des_cbc_enc_tv_template, tsize);
1262         des_tv = (void *) tvmem;
1263
1264         crypto_cipher_set_iv(tfm, des_tv[i].iv, crypto_tfm_alg_ivsize(tfm));
1265         crypto_cipher_get_iv(tfm, res, crypto_tfm_alg_ivsize(tfm));
1266
1267         if (memcmp(res, des_tv[i].iv, sizeof(res))) {
1268                 printk("crypto_cipher_[set|get]_iv() failed\n");
1269                 goto out;
1270         }
1271
1272         for (i = 0; i < DES_CBC_ENC_TEST_VECTORS; i++) {
1273                 printk("test %u:\n", i + 1);
1274
1275                 key = des_tv[i].key;
1276
1277                 ret = crypto_cipher_setkey(tfm, key, 8);
1278                 if (ret) {
1279                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
1280                         goto out;
1281                 }
1282
1283                 len = des_tv[i].len;
1284                 p = des_tv[i].plaintext;
1285
1286                 sg[0].page = virt_to_page(p);
1287                 sg[0].offset = ((long) p & ~PAGE_MASK);
1288                 sg[0].length = len;
1289
1290                 crypto_cipher_set_iv(tfm, des_tv[i].iv,
1291                                      crypto_tfm_alg_ivsize(tfm));
1292
1293                 ret = crypto_cipher_encrypt(tfm, sg, sg, len);
1294                 if (ret) {
1295                         printk("des_cbc_encrypt() failed flags=%x\n",
1296                                tfm->crt_flags);
1297                         goto out;
1298                 }
1299
1300                 q = kmap(sg[0].page) + sg[0].offset;
1301                 hexdump(q, len);
1302
1303                 printk("%s\n",
1304                        memcmp(q, des_tv[i].result, len) ? "fail" : "pass");
1305         }
1306
1307         crypto_free_tfm(tfm);
1308
1309         /*
1310          * Scenario F:
1311          *
1312          *  F1       F2
1313          *  [8 + 5]  [3 + 8]
1314          *
1315          */
1316         printk("\ntesting des cbc encryption chunking scenario F\n");
1317         i = 4;
1318
1319         tfm = crypto_alloc_tfm("des", CRYPTO_TFM_MODE_CBC);
1320         if (tfm == NULL) {
1321                 printk("failed to load transform for CRYPTO_ALG_DES_CCB\n");
1322                 return;
1323         }
1324
1325         tfm->crt_flags = 0;
1326         key = des_tv[i].key;
1327
1328         ret = crypto_cipher_setkey(tfm, key, 8);
1329         if (ret) {
1330                 printk("setkey() failed flags=%x\n", tfm->crt_flags);
1331                 goto out;
1332         }
1333
1334         /* setup the dummy buffer first */
1335         memset(xbuf, 0, sizeof (xbuf));
1336
1337         memcpy(&xbuf[IDX1], des_tv[i].plaintext, 13);
1338         memcpy(&xbuf[IDX2], des_tv[i].plaintext + 13, 11);
1339
1340         p = &xbuf[IDX1];
1341         sg[0].page = virt_to_page(p);
1342         sg[0].offset = ((long) p & ~PAGE_MASK);
1343         sg[0].length = 13;
1344
1345         p = &xbuf[IDX2];
1346         sg[1].page = virt_to_page(p);
1347         sg[1].offset = ((long) p & ~PAGE_MASK);
1348         sg[1].length = 11;
1349
1350         crypto_cipher_set_iv(tfm, des_tv[i].iv, crypto_tfm_alg_ivsize(tfm));
1351
1352         ret = crypto_cipher_encrypt(tfm, sg, sg, 24);
1353         if (ret) {
1354                 printk("des_cbc_decrypt() failed flags=%x\n", tfm->crt_flags);
1355                 goto out;
1356         }
1357
1358         printk("page 1\n");
1359         q = kmap(sg[0].page) + sg[0].offset;
1360         hexdump(q, 13);
1361         printk("%s\n", memcmp(q, des_tv[i].result, 13) ? "fail" : "pass");
1362
1363         printk("page 2\n");
1364         q = kmap(sg[1].page) + sg[1].offset;
1365         hexdump(q, 11);
1366         printk("%s\n", memcmp(q, des_tv[i].result + 13, 11) ? "fail" : "pass");
1367
1368         tsize = sizeof (des_cbc_dec_tv_template);
1369         if (tsize > TVMEMSIZE) {
1370                 printk("template (%u) too big for tvmem (%u)\n", tsize,
1371                        TVMEMSIZE);
1372                 return;
1373         }
1374         memcpy(tvmem, des_cbc_dec_tv_template, tsize);
1375         des_tv = (void *) tvmem;
1376
1377         printk("\ntesting des cbc decryption\n");
1378
1379         for (i = 0; i < DES_CBC_DEC_TEST_VECTORS; i++) {
1380                 printk("test %u:\n", i + 1);
1381
1382                 tfm->crt_flags = 0;
1383                 key = des_tv[i].key;
1384
1385                 ret = crypto_cipher_setkey(tfm, key, 8);
1386                 if (ret) {
1387                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
1388                         goto out;
1389                 }
1390
1391                 len = des_tv[i].len;
1392                 p = des_tv[i].plaintext;
1393
1394                 sg[0].page = virt_to_page(p);
1395                 sg[0].offset = ((long) p & ~PAGE_MASK);
1396                 sg[0].length = len;
1397
1398                 crypto_cipher_set_iv(tfm, des_tv[i].iv,
1399                                       crypto_tfm_alg_blocksize(tfm));
1400
1401                 ret = crypto_cipher_decrypt(tfm, sg, sg, len);
1402                 if (ret) {
1403                         printk("des_cbc_decrypt() failed flags=%x\n",
1404                                tfm->crt_flags);
1405                         goto out;
1406                 }
1407
1408                 hexdump(tfm->crt_cipher.cit_iv, 8);
1409
1410                 q = kmap(sg[0].page) + sg[0].offset;
1411                 hexdump(q, len);
1412
1413                 printk("%s\n",
1414                        memcmp(q, des_tv[i].result, len) ? "fail" : "pass");
1415         }
1416
1417         /*
1418          * Scenario G:
1419          *
1420          *  F1   F2
1421          *  [4]  [4]
1422          *
1423          */
1424         printk("\ntesting des cbc decryption chunking scenario G\n");
1425         i = 3;
1426
1427         tfm->crt_flags = 0;
1428         key = des_tv[i].key;
1429
1430         ret = crypto_cipher_setkey(tfm, key, 8);
1431         if (ret) {
1432                 printk("setkey() failed flags=%x\n", tfm->crt_flags);
1433                 goto out;
1434         }
1435
1436         /* setup the dummy buffer first */
1437         memset(xbuf, 0, sizeof (xbuf));
1438         memcpy(&xbuf[IDX1], des_tv[i].plaintext, 4);
1439         memcpy(&xbuf[IDX2], des_tv[i].plaintext + 4, 4);
1440
1441         p = &xbuf[IDX1];
1442         sg[0].page = virt_to_page(p);
1443         sg[0].offset = ((long) p & ~PAGE_MASK);
1444         sg[0].length = 4;
1445
1446         p = &xbuf[IDX2];
1447         sg[1].page = virt_to_page(p);
1448         sg[1].offset = ((long) p & ~PAGE_MASK);
1449         sg[1].length = 4;
1450
1451         crypto_cipher_set_iv(tfm, des_tv[i].iv, crypto_tfm_alg_ivsize(tfm));
1452
1453         ret = crypto_cipher_decrypt(tfm, sg, sg, 8);
1454         if (ret) {
1455                 printk("des_cbc_decrypt() failed flags=%x\n", tfm->crt_flags);
1456                 goto out;
1457         }
1458
1459         printk("page 1\n");
1460         q = kmap(sg[0].page) + sg[0].offset;
1461         hexdump(q, 4);
1462         printk("%s\n", memcmp(q, des_tv[i].result, 4) ? "fail" : "pass");
1463
1464         printk("page 2\n");
1465         q = kmap(sg[1].page) + sg[1].offset;
1466         hexdump(q, 4);
1467         printk("%s\n", memcmp(q, des_tv[i].result + 4, 4) ? "fail" : "pass");
1468
1469       out:
1470         crypto_free_tfm(tfm);
1471 }
1472
1473 void
1474 test_des3_ede(void)
1475 {
1476         unsigned int ret, i, len;
1477         unsigned int tsize;
1478         char *p, *q;
1479         struct crypto_tfm *tfm;
1480         char *key;
1481         /*char res[8]; */
1482         struct des_tv *des_tv;
1483         struct scatterlist sg[8];
1484
1485         printk("\ntesting des3 ede encryption\n");
1486
1487         tsize = sizeof (des3_ede_enc_tv_template);
1488         if (tsize > TVMEMSIZE) {
1489                 printk("template (%u) too big for tvmem (%u)\n", tsize,
1490                        TVMEMSIZE);
1491                 return;
1492         }
1493
1494         memcpy(tvmem, des3_ede_enc_tv_template, tsize);
1495         des_tv = (void *) tvmem;
1496
1497         tfm = crypto_alloc_tfm("des3_ede", CRYPTO_TFM_MODE_ECB);
1498         if (tfm == NULL) {
1499                 printk("failed to load transform for 3des ecb\n");
1500                 return;
1501         }
1502
1503         for (i = 0; i < DES3_EDE_ENC_TEST_VECTORS; i++) {
1504                 printk("test %u:\n", i + 1);
1505
1506                 key = des_tv[i].key;
1507                 ret = crypto_cipher_setkey(tfm, key, 24);
1508                 if (ret) {
1509                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
1510
1511                         if (!des_tv[i].fail)
1512                                 goto out;
1513                 }
1514
1515                 len = des_tv[i].len;
1516
1517                 p = des_tv[i].plaintext;
1518                 sg[0].page = virt_to_page(p);
1519                 sg[0].offset = ((long) p & ~PAGE_MASK);
1520                 sg[0].length = len;
1521                 ret = crypto_cipher_encrypt(tfm, sg, sg, len);
1522                 if (ret) {
1523                         printk("encrypt() failed flags=%x\n", tfm->crt_flags);
1524                         goto out;
1525                 }
1526
1527                 q = kmap(sg[0].page) + sg[0].offset;
1528                 hexdump(q, len);
1529
1530                 printk("%s\n",
1531                        memcmp(q, des_tv[i].result, len) ? "fail" : "pass");
1532         }
1533
1534         printk("\ntesting des3 ede decryption\n");
1535
1536         tsize = sizeof (des3_ede_dec_tv_template);
1537         if (tsize > TVMEMSIZE) {
1538                 printk("template (%u) too big for tvmem (%u)\n", tsize,
1539                        TVMEMSIZE);
1540                 return;
1541         }
1542
1543         memcpy(tvmem, des3_ede_dec_tv_template, tsize);
1544         des_tv = (void *) tvmem;
1545
1546         for (i = 0; i < DES3_EDE_DEC_TEST_VECTORS; i++) {
1547                 printk("test %u:\n", i + 1);
1548
1549                 key = des_tv[i].key;
1550                 ret = crypto_cipher_setkey(tfm, key, 24);
1551                 if (ret) {
1552                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
1553
1554                         if (!des_tv[i].fail)
1555                                 goto out;
1556                 }
1557
1558                 len = des_tv[i].len;
1559
1560                 p = des_tv[i].plaintext;
1561                 sg[0].page = virt_to_page(p);
1562                 sg[0].offset = ((long) p & ~PAGE_MASK);
1563                 sg[0].length = len;
1564                 ret = crypto_cipher_decrypt(tfm, sg, sg, len);
1565                 if (ret) {
1566                         printk("decrypt() failed flags=%x\n", tfm->crt_flags);
1567                         goto out;
1568                 }
1569
1570                 q = kmap(sg[0].page) + sg[0].offset;
1571                 hexdump(q, len);
1572
1573                 printk("%s\n",
1574                        memcmp(q, des_tv[i].result, len) ? "fail" : "pass");
1575         }
1576
1577       out:
1578         crypto_free_tfm(tfm);
1579 }
1580
1581 void
1582 test_blowfish(void)
1583 {
1584         unsigned int ret, i;
1585         unsigned int tsize;
1586         char *p, *q;
1587         struct crypto_tfm *tfm;
1588         char *key;
1589         struct bf_tv *bf_tv;
1590         struct scatterlist sg[1];
1591
1592         printk("\ntesting blowfish encryption\n");
1593
1594         tsize = sizeof (bf_enc_tv_template);
1595         if (tsize > TVMEMSIZE) {
1596                 printk("template (%u) too big for tvmem (%u)\n", tsize,
1597                        TVMEMSIZE);
1598                 return;
1599         }
1600
1601         memcpy(tvmem, bf_enc_tv_template, tsize);
1602         bf_tv = (void *) tvmem;
1603
1604         tfm = crypto_alloc_tfm("blowfish", 0);
1605         if (tfm == NULL) {
1606                 printk("failed to load transform for blowfish (default ecb)\n");
1607                 return;
1608         }
1609
1610         for (i = 0; i < BF_ENC_TEST_VECTORS; i++) {
1611                 printk("test %u (%d bit key):\n",
1612                         i + 1, bf_tv[i].keylen * 8);
1613                 key = bf_tv[i].key;
1614
1615                 ret = crypto_cipher_setkey(tfm, key, bf_tv[i].keylen);
1616                 if (ret) {
1617                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
1618
1619                         if (!bf_tv[i].fail)
1620                                 goto out;
1621                 }
1622
1623                 p = bf_tv[i].plaintext;
1624                 sg[0].page = virt_to_page(p);
1625                 sg[0].offset = ((long) p & ~PAGE_MASK);
1626                 sg[0].length = bf_tv[i].plen;
1627                 ret = crypto_cipher_encrypt(tfm, sg, sg, sg[0].length);
1628                 if (ret) {
1629                         printk("encrypt() failed flags=%x\n", tfm->crt_flags);
1630                         goto out;
1631                 }
1632
1633                 q = kmap(sg[0].page) + sg[0].offset;
1634                 hexdump(q, bf_tv[i].rlen);
1635
1636                 printk("%s\n", memcmp(q, bf_tv[i].result, bf_tv[i].rlen) ?
1637                         "fail" : "pass");
1638         }
1639
1640         printk("\ntesting blowfish decryption\n");
1641
1642         tsize = sizeof (bf_dec_tv_template);
1643         if (tsize > TVMEMSIZE) {
1644                 printk("template (%u) too big for tvmem (%u)\n", tsize,
1645                        TVMEMSIZE);
1646                 return;
1647         }
1648
1649         memcpy(tvmem, bf_dec_tv_template, tsize);
1650         bf_tv = (void *) tvmem;
1651
1652         for (i = 0; i < BF_DEC_TEST_VECTORS; i++) {
1653                 printk("test %u (%d bit key):\n",
1654                         i + 1, bf_tv[i].keylen * 8);
1655                 key = bf_tv[i].key;
1656
1657                 ret = crypto_cipher_setkey(tfm, key, bf_tv[i].keylen);
1658                 if (ret) {
1659                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
1660
1661                         if (!bf_tv[i].fail)
1662                                 goto out;
1663                 }
1664
1665                 p = bf_tv[i].plaintext;
1666                 sg[0].page = virt_to_page(p);
1667                 sg[0].offset = ((long) p & ~PAGE_MASK);
1668                 sg[0].length = bf_tv[i].plen;
1669                 ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length);
1670                 if (ret) {
1671                         printk("decrypt() failed flags=%x\n", tfm->crt_flags);
1672                         goto out;
1673                 }
1674
1675                 q = kmap(sg[0].page) + sg[0].offset;
1676                 hexdump(q, bf_tv[i].rlen);
1677
1678                 printk("%s\n", memcmp(q, bf_tv[i].result, bf_tv[i].rlen) ?
1679                         "fail" : "pass");
1680         }
1681
1682         crypto_free_tfm(tfm);
1683
1684         tfm = crypto_alloc_tfm("blowfish", CRYPTO_TFM_MODE_CBC);
1685         if (tfm == NULL) {
1686                 printk("failed to load transform for blowfish cbc\n");
1687                 return;
1688         }
1689
1690         printk("\ntesting blowfish cbc encryption\n");
1691
1692         tsize = sizeof (bf_cbc_enc_tv_template);
1693         if (tsize > TVMEMSIZE) {
1694                 printk("template (%u) too big for tvmem (%u)\n", tsize,
1695                        TVMEMSIZE);
1696                 goto out;
1697         }
1698         memcpy(tvmem, bf_cbc_enc_tv_template, tsize);
1699         bf_tv = (void *) tvmem;
1700
1701         for (i = 0; i < BF_CBC_ENC_TEST_VECTORS; i++) {
1702                 printk("test %u (%d bit key):\n",
1703                         i + 1, bf_tv[i].keylen * 8);
1704
1705                 key = bf_tv[i].key;
1706
1707                 ret = crypto_cipher_setkey(tfm, key, bf_tv[i].keylen);
1708                 if (ret) {
1709                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
1710                         goto out;
1711                 }
1712
1713                 p = bf_tv[i].plaintext;
1714
1715                 sg[0].page = virt_to_page(p);
1716                 sg[0].offset = ((long) p & ~PAGE_MASK);
1717                 sg[0].length =  bf_tv[i].plen;
1718
1719                 crypto_cipher_set_iv(tfm, bf_tv[i].iv,
1720                                      crypto_tfm_alg_ivsize(tfm));
1721
1722                 ret = crypto_cipher_encrypt(tfm, sg, sg, sg[0].length);
1723                 if (ret) {
1724                         printk("blowfish_cbc_encrypt() failed flags=%x\n",
1725                                tfm->crt_flags);
1726                         goto out;
1727                 }
1728
1729                 q = kmap(sg[0].page) + sg[0].offset;
1730                 hexdump(q, bf_tv[i].rlen);
1731
1732                 printk("%s\n", memcmp(q, bf_tv[i].result, bf_tv[i].rlen)
1733                         ? "fail" : "pass");
1734         }
1735
1736         printk("\ntesting blowfish cbc decryption\n");
1737
1738         tsize = sizeof (bf_cbc_dec_tv_template);
1739         if (tsize > TVMEMSIZE) {
1740                 printk("template (%u) too big for tvmem (%u)\n", tsize,
1741                        TVMEMSIZE);
1742                 goto out;
1743         }
1744         memcpy(tvmem, bf_cbc_dec_tv_template, tsize);
1745         bf_tv = (void *) tvmem;
1746
1747         for (i = 0; i < BF_CBC_ENC_TEST_VECTORS; i++) {
1748                 printk("test %u (%d bit key):\n",
1749                         i + 1, bf_tv[i].keylen * 8);
1750                 key = bf_tv[i].key;
1751
1752                 ret = crypto_cipher_setkey(tfm, key, bf_tv[i].keylen);
1753                 if (ret) {
1754                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
1755                         goto out;
1756                 }
1757
1758                 p = bf_tv[i].plaintext;
1759
1760                 sg[0].page = virt_to_page(p);
1761                 sg[0].offset = ((long) p & ~PAGE_MASK);
1762                 sg[0].length =  bf_tv[i].plen;
1763
1764                 crypto_cipher_set_iv(tfm, bf_tv[i].iv,
1765                                      crypto_tfm_alg_ivsize(tfm));
1766
1767                 ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length);
1768                 if (ret) {
1769                         printk("blowfish_cbc_decrypt() failed flags=%x\n",
1770                                tfm->crt_flags);
1771                         goto out;
1772                 }
1773
1774                 q = kmap(sg[0].page) + sg[0].offset;
1775                 hexdump(q, bf_tv[i].rlen);
1776
1777                 printk("%s\n", memcmp(q, bf_tv[i].result, bf_tv[i].rlen)
1778                         ? "fail" : "pass");
1779         }
1780
1781 out:
1782         crypto_free_tfm(tfm);
1783 }
1784
1785
1786 void
1787 test_twofish(void)
1788 {
1789         unsigned int ret, i;
1790         unsigned int tsize;
1791         char *p, *q;
1792         struct crypto_tfm *tfm;
1793         char *key;
1794         struct tf_tv *tf_tv;
1795         struct scatterlist sg[1];
1796
1797         printk("\ntesting twofish encryption\n");
1798
1799         tsize = sizeof (tf_enc_tv_template);
1800         if (tsize > TVMEMSIZE) {
1801                 printk("template (%u) too big for tvmem (%u)\n", tsize,
1802                        TVMEMSIZE);
1803                 return;
1804         }
1805
1806         memcpy(tvmem, tf_enc_tv_template, tsize);
1807         tf_tv = (void *) tvmem;
1808
1809         tfm = crypto_alloc_tfm("twofish", 0);
1810         if (tfm == NULL) {
1811                 printk("failed to load transform for blowfish (default ecb)\n");
1812                 return;
1813         }
1814
1815         for (i = 0; i < TF_ENC_TEST_VECTORS; i++) {
1816                 printk("test %u (%d bit key):\n",
1817                         i + 1, tf_tv[i].keylen * 8);
1818                 key = tf_tv[i].key;
1819
1820                 ret = crypto_cipher_setkey(tfm, key, tf_tv[i].keylen);
1821                 if (ret) {
1822                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
1823
1824                         if (!tf_tv[i].fail)
1825                                 goto out;
1826                 }
1827
1828                 p = tf_tv[i].plaintext;
1829                 sg[0].page = virt_to_page(p);
1830                 sg[0].offset = ((long) p & ~PAGE_MASK);
1831                 sg[0].length = tf_tv[i].plen;
1832                 ret = crypto_cipher_encrypt(tfm, sg, sg, sg[0].length);
1833                 if (ret) {
1834                         printk("encrypt() failed flags=%x\n", tfm->crt_flags);
1835                         goto out;
1836                 }
1837
1838                 q = kmap(sg[0].page) + sg[0].offset;
1839                 hexdump(q, tf_tv[i].rlen);
1840
1841                 printk("%s\n", memcmp(q, tf_tv[i].result, tf_tv[i].rlen) ?
1842                         "fail" : "pass");
1843         }
1844
1845         printk("\ntesting twofish decryption\n");
1846
1847         tsize = sizeof (tf_dec_tv_template);
1848         if (tsize > TVMEMSIZE) {
1849                 printk("template (%u) too big for tvmem (%u)\n", tsize,
1850                        TVMEMSIZE);
1851                 return;
1852         }
1853
1854         memcpy(tvmem, tf_dec_tv_template, tsize);
1855         tf_tv = (void *) tvmem;
1856
1857         for (i = 0; i < TF_DEC_TEST_VECTORS; i++) {
1858                 printk("test %u (%d bit key):\n",
1859                         i + 1, tf_tv[i].keylen * 8);
1860                 key = tf_tv[i].key;
1861
1862                 ret = crypto_cipher_setkey(tfm, key, tf_tv[i].keylen);
1863                 if (ret) {
1864                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
1865
1866                         if (!tf_tv[i].fail)
1867                                 goto out;
1868                 }
1869
1870                 p = tf_tv[i].plaintext;
1871                 sg[0].page = virt_to_page(p);
1872                 sg[0].offset = ((long) p & ~PAGE_MASK);
1873                 sg[0].length = tf_tv[i].plen;
1874                 ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length);
1875                 if (ret) {
1876                         printk("decrypt() failed flags=%x\n", tfm->crt_flags);
1877                         goto out;
1878                 }
1879
1880                 q = kmap(sg[0].page) + sg[0].offset;
1881                 hexdump(q, tf_tv[i].rlen);
1882
1883                 printk("%s\n", memcmp(q, tf_tv[i].result, tf_tv[i].rlen) ?
1884                         "fail" : "pass");
1885         }
1886
1887         crypto_free_tfm(tfm);
1888
1889         tfm = crypto_alloc_tfm("twofish", CRYPTO_TFM_MODE_CBC);
1890         if (tfm == NULL) {
1891                 printk("failed to load transform for twofish cbc\n");
1892                 return;
1893         }
1894
1895         printk("\ntesting twofish cbc encryption\n");
1896
1897         tsize = sizeof (tf_cbc_enc_tv_template);
1898         if (tsize > TVMEMSIZE) {
1899                 printk("template (%u) too big for tvmem (%u)\n", tsize,
1900                        TVMEMSIZE);
1901                 goto out;
1902         }
1903         memcpy(tvmem, tf_cbc_enc_tv_template, tsize);
1904         tf_tv = (void *) tvmem;
1905
1906         for (i = 0; i < TF_CBC_ENC_TEST_VECTORS; i++) {
1907                 printk("test %u (%d bit key):\n",
1908                         i + 1, tf_tv[i].keylen * 8);
1909
1910                 key = tf_tv[i].key;
1911
1912                 ret = crypto_cipher_setkey(tfm, key, tf_tv[i].keylen);
1913                 if (ret) {
1914                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
1915                         goto out;
1916                 }
1917
1918                 p = tf_tv[i].plaintext;
1919
1920                 sg[0].page = virt_to_page(p);
1921                 sg[0].offset = ((long) p & ~PAGE_MASK);
1922                 sg[0].length =  tf_tv[i].plen;
1923
1924                 crypto_cipher_set_iv(tfm, tf_tv[i].iv,
1925                                      crypto_tfm_alg_ivsize(tfm));
1926
1927                 ret = crypto_cipher_encrypt(tfm, sg, sg, sg[0].length);
1928                 if (ret) {
1929                         printk("blowfish_cbc_encrypt() failed flags=%x\n",
1930                                tfm->crt_flags);
1931                         goto out;
1932                 }
1933
1934                 q = kmap(sg[0].page) + sg[0].offset;
1935                 hexdump(q, tf_tv[i].rlen);
1936
1937                 printk("%s\n", memcmp(q, tf_tv[i].result, tf_tv[i].rlen)
1938                         ? "fail" : "pass");
1939         }
1940
1941         printk("\ntesting twofish cbc decryption\n");
1942
1943         tsize = sizeof (tf_cbc_dec_tv_template);
1944         if (tsize > TVMEMSIZE) {
1945                 printk("template (%u) too big for tvmem (%u)\n", tsize,
1946                        TVMEMSIZE);
1947                 goto out;
1948         }
1949         memcpy(tvmem, tf_cbc_dec_tv_template, tsize);
1950         tf_tv = (void *) tvmem;
1951
1952         for (i = 0; i < TF_CBC_DEC_TEST_VECTORS; i++) {
1953                 printk("test %u (%d bit key):\n",
1954                         i + 1, tf_tv[i].keylen * 8);
1955
1956                 key = tf_tv[i].key;
1957
1958                 ret = crypto_cipher_setkey(tfm, key, tf_tv[i].keylen);
1959                 if (ret) {
1960                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
1961                         goto out;
1962                 }
1963
1964                 p = tf_tv[i].plaintext;
1965
1966                 sg[0].page = virt_to_page(p);
1967                 sg[0].offset = ((long) p & ~PAGE_MASK);
1968                 sg[0].length =  tf_tv[i].plen;
1969
1970                 crypto_cipher_set_iv(tfm, tf_tv[i].iv,
1971                                      crypto_tfm_alg_ivsize(tfm));
1972
1973                 ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length);
1974                 if (ret) {
1975                         printk("blowfish_cbc_decrypt() failed flags=%x\n",
1976                                tfm->crt_flags);
1977                         goto out;
1978                 }
1979
1980                 q = kmap(sg[0].page) + sg[0].offset;
1981                 hexdump(q, tf_tv[i].rlen);
1982
1983                 printk("%s\n", memcmp(q, tf_tv[i].result, tf_tv[i].rlen)
1984                         ? "fail" : "pass");
1985         }
1986
1987 out:
1988         crypto_free_tfm(tfm);
1989 }
1990
1991 void
1992 test_serpent(void)
1993 {
1994         unsigned int ret, i, tsize;
1995         u8 *p, *q, *key;
1996         struct crypto_tfm *tfm;
1997         struct serpent_tv *serp_tv;
1998         struct scatterlist sg[1];
1999
2000         printk("\ntesting serpent encryption\n");
2001
2002         tfm = crypto_alloc_tfm("serpent", 0);
2003         if (tfm == NULL) {
2004                 printk("failed to load transform for serpent (default ecb)\n");
2005                 return;
2006         }
2007
2008         tsize = sizeof (serpent_enc_tv_template);
2009         if (tsize > TVMEMSIZE) {
2010                 printk("template (%u) too big for tvmem (%u)\n", tsize,
2011                        TVMEMSIZE);
2012                 return;
2013         }
2014
2015         memcpy(tvmem, serpent_enc_tv_template, tsize);
2016         serp_tv = (void *) tvmem;
2017         for (i = 0; i < SERPENT_ENC_TEST_VECTORS; i++) {
2018                 printk("test %u (%d bit key):\n", i + 1, serp_tv[i].keylen * 8);
2019                 key = serp_tv[i].key;
2020
2021                 ret = crypto_cipher_setkey(tfm, key, serp_tv[i].keylen);
2022                 if (ret) {
2023                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
2024
2025                         if (!serp_tv[i].fail)
2026                                 goto out;
2027                 }
2028
2029                 p = serp_tv[i].plaintext;
2030                 sg[0].page = virt_to_page(p);
2031                 sg[0].offset = ((long) p & ~PAGE_MASK);
2032                 sg[0].length = sizeof(serp_tv[i].plaintext);
2033                 ret = crypto_cipher_encrypt(tfm, sg, sg, sg[0].length);
2034                 if (ret) {
2035                         printk("encrypt() failed flags=%x\n", tfm->crt_flags);
2036                         goto out;
2037                 }
2038
2039                 q = kmap(sg[0].page) + sg[0].offset;
2040                 hexdump(q, sizeof(serp_tv[i].result));
2041
2042                 printk("%s\n", memcmp(q, serp_tv[i].result,
2043                         sizeof(serp_tv[i].result)) ? "fail" : "pass");
2044         }
2045
2046         printk("\ntesting serpent decryption\n");
2047
2048         tsize = sizeof (serpent_dec_tv_template);
2049         if (tsize > TVMEMSIZE) {
2050                 printk("template (%u) too big for tvmem (%u)\n", tsize,
2051                        TVMEMSIZE);
2052                 return;
2053         }
2054
2055         memcpy(tvmem, serpent_dec_tv_template, tsize);
2056         serp_tv = (void *) tvmem;
2057         for (i = 0; i < SERPENT_DEC_TEST_VECTORS; i++) {
2058                 printk("test %u (%d bit key):\n", i + 1, serp_tv[i].keylen * 8);
2059                 key = serp_tv[i].key;
2060
2061                 ret = crypto_cipher_setkey(tfm, key, serp_tv[i].keylen);
2062                 if (ret) {
2063                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
2064
2065                         if (!serp_tv[i].fail)
2066                                 goto out;
2067                 }
2068
2069                 p = serp_tv[i].plaintext;
2070                 sg[0].page = virt_to_page(p);
2071                 sg[0].offset = ((long) p & ~PAGE_MASK);
2072                 sg[0].length = sizeof(serp_tv[i].plaintext);
2073                 ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length);
2074                 if (ret) {
2075                         printk("decrypt() failed flags=%x\n", tfm->crt_flags);
2076                         goto out;
2077                 }
2078
2079                 q = kmap(sg[0].page) + sg[0].offset;
2080                 hexdump(q, sizeof(serp_tv[i].result));
2081
2082                 printk("%s\n", memcmp(q, serp_tv[i].result,
2083                         sizeof(serp_tv[i].result)) ? "fail" : "pass");
2084         }
2085
2086 out:
2087         crypto_free_tfm(tfm);
2088 }
2089
2090 void
2091 test_aes(void)
2092 {
2093         unsigned int ret, i;
2094         unsigned int tsize;
2095         char *p, *q;
2096         struct crypto_tfm *tfm;
2097         char *key;
2098         struct aes_tv *aes_tv;
2099         struct scatterlist sg[1];
2100
2101         printk("\ntesting aes encryption\n");
2102
2103         tsize = sizeof (aes_enc_tv_template);
2104         if (tsize > TVMEMSIZE) {
2105                 printk("template (%u) too big for tvmem (%u)\n", tsize,
2106                        TVMEMSIZE);
2107                 return;
2108         }
2109
2110         memcpy(tvmem, aes_enc_tv_template, tsize);
2111         aes_tv = (void *) tvmem;
2112
2113         tfm = crypto_alloc_tfm("aes", 0);
2114         if (tfm == NULL) {
2115                 printk("failed to load transform for aes (default ecb)\n");
2116                 return;
2117         }
2118
2119         for (i = 0; i < AES_ENC_TEST_VECTORS; i++) {
2120                 printk("test %u (%d bit key):\n",
2121                         i + 1, aes_tv[i].keylen * 8);
2122                 key = aes_tv[i].key;
2123
2124                 ret = crypto_cipher_setkey(tfm, key, aes_tv[i].keylen);
2125                 if (ret) {
2126                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
2127
2128                         if (!aes_tv[i].fail)
2129                                 goto out;
2130                 }
2131
2132                 p = aes_tv[i].plaintext;
2133                 sg[0].page = virt_to_page(p);
2134                 sg[0].offset = ((long) p & ~PAGE_MASK);
2135                 sg[0].length = aes_tv[i].plen;
2136                 ret = crypto_cipher_encrypt(tfm, sg, sg, sg[0].length);
2137                 if (ret) {
2138                         printk("encrypt() failed flags=%x\n", tfm->crt_flags);
2139                         goto out;
2140                 }
2141
2142                 q = kmap(sg[0].page) + sg[0].offset;
2143                 hexdump(q, aes_tv[i].rlen);
2144
2145                 printk("%s\n", memcmp(q, aes_tv[i].result, aes_tv[i].rlen) ?
2146                         "fail" : "pass");
2147         }
2148
2149         printk("\ntesting aes decryption\n");
2150
2151         tsize = sizeof (aes_dec_tv_template);
2152         if (tsize > TVMEMSIZE) {
2153                 printk("template (%u) too big for tvmem (%u)\n", tsize,
2154                        TVMEMSIZE);
2155                 return;
2156         }
2157
2158         memcpy(tvmem, aes_dec_tv_template, tsize);
2159         aes_tv = (void *) tvmem;
2160
2161         for (i = 0; i < AES_DEC_TEST_VECTORS; i++) {
2162                 printk("test %u (%d bit key):\n",
2163                         i + 1, aes_tv[i].keylen * 8);
2164                 key = aes_tv[i].key;
2165
2166                 ret = crypto_cipher_setkey(tfm, key, aes_tv[i].keylen);
2167                 if (ret) {
2168                         printk("setkey() failed flags=%x\n", tfm->crt_flags);
2169
2170                         if (!aes_tv[i].fail)
2171                                 goto out;
2172                 }
2173
2174                 p = aes_tv[i].plaintext;
2175                 sg[0].page = virt_to_page(p);
2176                 sg[0].offset = ((long) p & ~PAGE_MASK);
2177                 sg[0].length = aes_tv[i].plen;
2178                 ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length);
2179                 if (ret) {
2180                         printk("decrypt() failed flags=%x\n", tfm->crt_flags);
2181                         goto out;
2182                 }
2183
2184                 q = kmap(sg[0].page) + sg[0].offset;
2185                 hexdump(q, aes_tv[i].rlen);
2186
2187                 printk("%s\n", memcmp(q, aes_tv[i].result, aes_tv[i].rlen) ?
2188                         "fail" : "pass");
2189         }
2190
2191 out:
2192         crypto_free_tfm(tfm);
2193 }
2194
2195 static void
2196 test_deflate(void)
2197 {
2198         unsigned int i;
2199         char result[COMP_BUF_SIZE];
2200         struct crypto_tfm *tfm;
2201         struct comp_testvec *tv;
2202         unsigned int tsize;
2203
2204         printk("\ntesting deflate compression\n");
2205
2206         tsize = sizeof (deflate_comp_tv_template);
2207         if (tsize > TVMEMSIZE) {
2208                 printk("template (%u) too big for tvmem (%u)\n", tsize,
2209                        TVMEMSIZE);
2210                 return;
2211         }
2212
2213         memcpy(tvmem, deflate_comp_tv_template, tsize);
2214         tv = (void *) tvmem;
2215
2216         tfm = crypto_alloc_tfm("deflate", 0);
2217         if (tfm == NULL) {
2218                 printk("failed to load transform for deflate\n");
2219                 return;
2220         }
2221
2222         for (i = 0; i < DEFLATE_COMP_TEST_VECTORS; i++) {
2223                 int ilen, ret, dlen = COMP_BUF_SIZE;
2224
2225                 printk("test %u:\n", i + 1);
2226                 memset(result, 0, sizeof (result));
2227
2228                 ilen = tv[i].inlen;
2229                 ret = crypto_comp_compress(tfm, tv[i].input,
2230                                            ilen, result, &dlen);
2231                 if (ret) {
2232                         printk("fail: ret=%d\n", ret);
2233                         continue;
2234                 }
2235                 hexdump(result, dlen);
2236                 printk("%s (ratio %d:%d)\n",
2237                        memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
2238                        ilen, dlen);
2239         }
2240
2241         printk("\ntesting deflate decompression\n");
2242
2243         tsize = sizeof (deflate_decomp_tv_template);
2244         if (tsize > TVMEMSIZE) {
2245                 printk("template (%u) too big for tvmem (%u)\n", tsize,
2246                        TVMEMSIZE);
2247                 goto out;
2248         }
2249
2250         memcpy(tvmem, deflate_decomp_tv_template, tsize);
2251         tv = (void *) tvmem;
2252
2253         for (i = 0; i < DEFLATE_DECOMP_TEST_VECTORS; i++) {
2254                 int ilen, ret, dlen = COMP_BUF_SIZE;
2255
2256                 printk("test %u:\n", i + 1);
2257                 memset(result, 0, sizeof (result));
2258
2259                 ilen = tv[i].inlen;
2260                 ret = crypto_comp_decompress(tfm, tv[i].input,
2261                                              ilen, result, &dlen);
2262                 if (ret) {
2263                         printk("fail: ret=%d\n", ret);
2264                         continue;
2265                 }
2266                 hexdump(result, dlen);
2267                 printk("%s (ratio %d:%d)\n",
2268                        memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
2269                        ilen, dlen);
2270         }
2271 out:
2272         crypto_free_tfm(tfm);
2273 }
2274
2275 static void
2276 test_available(void)
2277 {
2278         char **name = check;
2279
2280         while (*name) {
2281                 printk("alg %s ", *name);
2282                 printk((crypto_alg_available(*name, 0)) ?
2283                         "found\n" : "not found\n");
2284                 name++;
2285         }
2286 }
2287
2288 static void
2289 do_test(void)
2290 {
2291         switch (mode) {
2292
2293         case 0:
2294                 test_md5();
2295                 test_sha1();
2296                 test_des();
2297                 test_des3_ede();
2298                 test_md4();
2299                 test_sha256();
2300                 test_blowfish();
2301                 test_twofish();
2302                 test_serpent();
2303                 test_aes();
2304                 test_sha384();
2305                 test_sha512();
2306                 test_deflate();
2307 #ifdef CONFIG_CRYPTO_HMAC
2308                 test_hmac_md5();
2309                 test_hmac_sha1();
2310                 test_hmac_sha256();
2311 #endif
2312                 break;
2313
2314         case 1:
2315                 test_md5();
2316                 break;
2317
2318         case 2:
2319                 test_sha1();
2320                 break;
2321
2322         case 3:
2323                 test_des();
2324                 break;
2325
2326         case 4:
2327                 test_des3_ede();
2328                 break;
2329
2330         case 5:
2331                 test_md4();
2332                 break;
2333
2334         case 6:
2335                 test_sha256();
2336                 break;
2337
2338         case 7:
2339                 test_blowfish();
2340                 break;
2341
2342         case 8:
2343                 test_twofish();
2344                 break;
2345
2346         case 9:
2347                 test_serpent();
2348                 break;
2349
2350         case 10:
2351                 test_aes();
2352                 break;
2353
2354         case 11:
2355                 test_sha384();
2356                 break;
2357
2358         case 12:
2359                 test_sha512();
2360                 break;
2361
2362         case 13:
2363                 test_deflate();
2364                 break;
2365
2366 #ifdef CONFIG_CRYPTO_HMAC
2367         case 100:
2368                 test_hmac_md5();
2369                 break;
2370
2371         case 101:
2372                 test_hmac_sha1();
2373                 break;
2374
2375         case 102:
2376                 test_hmac_sha256();
2377                 break;
2378
2379 #endif
2380
2381         case 1000:
2382                 test_available();
2383                 break;
2384
2385         default:
2386                 /* useful for debugging */
2387                 printk("not testing anything\n");
2388                 break;
2389         }
2390 }
2391
2392 static int __init
2393 init(void)
2394 {
2395         tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL);
2396         if (tvmem == NULL)
2397                 return -ENOMEM;
2398
2399         xbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
2400         if (xbuf == NULL) {
2401                 kfree(tvmem);
2402                 return -ENOMEM;
2403         }
2404
2405         do_test();
2406
2407         kfree(xbuf);
2408         kfree(tvmem);
2409         return 0;
2410 }
2411
2412 module_init(init);
2413
2414 MODULE_PARM(mode, "i");
2415
2416 MODULE_LICENSE("GPL");
2417 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
2418 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");