Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/crypto/tcrypt.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
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 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>");
Cache object: e41eb498998989734b9811f862f422ca
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]