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 * Copyright (c) 2007 Nokia Siemens Networks 10 * 11 * This program is free software; you can redistribute it and/or modify it 12 * under the terms of the GNU General Public License as published by the Free 13 * Software Foundation; either version 2 of the License, or (at your option) 14 * any later version. 15 * 16 * 2007-11-13 Added GCM tests 17 * 2007-11-13 Added AEAD support 18 * 2007-11-06 Added SHA-224 and SHA-224-HMAC tests 19 * 2006-12-07 Added SHA384 HMAC and SHA512 HMAC tests 20 * 2004-08-09 Added cipher speed tests (Reyk Floeter <reyk@vantronix.net>) 21 * 2003-09-14 Rewritten by Kartikey Mahendra Bhatt 22 * 23 */ 24 25 #include <linux/err.h> 26 #include <linux/init.h> 27 #include <linux/module.h> 28 #include <linux/mm.h> 29 #include <linux/slab.h> 30 #include <linux/scatterlist.h> 31 #include <linux/string.h> 32 #include <linux/crypto.h> 33 #include <linux/highmem.h> 34 #include <linux/moduleparam.h> 35 #include <linux/jiffies.h> 36 #include <linux/timex.h> 37 #include <linux/interrupt.h> 38 #include "tcrypt.h" 39 40 /* 41 * Need to kmalloc() memory for testing kmap(). 42 */ 43 #define TVMEMSIZE 16384 44 #define XBUFSIZE 32768 45 46 /* 47 * Indexes into the xbuf to simulate cross-page access. 48 */ 49 #define IDX1 37 50 #define IDX2 32400 51 #define IDX3 1 52 #define IDX4 8193 53 #define IDX5 22222 54 #define IDX6 17101 55 #define IDX7 27333 56 #define IDX8 3000 57 58 /* 59 * Used by test_cipher() 60 */ 61 #define ENCRYPT 1 62 #define DECRYPT 0 63 64 struct tcrypt_result { 65 struct completion completion; 66 int err; 67 }; 68 69 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 }; 70 71 /* 72 * Used by test_cipher_speed() 73 */ 74 static unsigned int sec; 75 76 static int mode; 77 static char *xbuf; 78 static char *axbuf; 79 static char *tvmem; 80 81 static char *check[] = { 82 "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256", 83 "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes", 84 "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea", 85 "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea", 86 "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", "fcrypt", 87 "camellia", "seed", "salsa20", "lzo", NULL 88 }; 89 90 static void hexdump(unsigned char *buf, unsigned int len) 91 { 92 print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET, 93 16, 1, 94 buf, len, false); 95 } 96 97 static void tcrypt_complete(struct crypto_async_request *req, int err) 98 { 99 struct tcrypt_result *res = req->data; 100 101 if (err == -EINPROGRESS) 102 return; 103 104 res->err = err; 105 complete(&res->completion); 106 } 107 108 static void test_hash(char *algo, struct hash_testvec *template, 109 unsigned int tcount) 110 { 111 unsigned int i, j, k, temp; 112 struct scatterlist sg[8]; 113 char result[64]; 114 struct crypto_hash *tfm; 115 struct hash_desc desc; 116 struct hash_testvec *hash_tv; 117 unsigned int tsize; 118 int ret; 119 120 printk("\ntesting %s\n", algo); 121 122 tsize = sizeof(struct hash_testvec); 123 tsize *= tcount; 124 125 if (tsize > TVMEMSIZE) { 126 printk("template (%u) too big for tvmem (%u)\n", tsize, TVMEMSIZE); 127 return; 128 } 129 130 memcpy(tvmem, template, tsize); 131 hash_tv = (void *)tvmem; 132 133 tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC); 134 if (IS_ERR(tfm)) { 135 printk("failed to load transform for %s: %ld\n", algo, 136 PTR_ERR(tfm)); 137 return; 138 } 139 140 desc.tfm = tfm; 141 desc.flags = 0; 142 143 for (i = 0; i < tcount; i++) { 144 printk("test %u:\n", i + 1); 145 memset(result, 0, 64); 146 147 sg_init_one(&sg[0], hash_tv[i].plaintext, hash_tv[i].psize); 148 149 if (hash_tv[i].ksize) { 150 ret = crypto_hash_setkey(tfm, hash_tv[i].key, 151 hash_tv[i].ksize); 152 if (ret) { 153 printk("setkey() failed ret=%d\n", ret); 154 goto out; 155 } 156 } 157 158 ret = crypto_hash_digest(&desc, sg, hash_tv[i].psize, result); 159 if (ret) { 160 printk("digest () failed ret=%d\n", ret); 161 goto out; 162 } 163 164 hexdump(result, crypto_hash_digestsize(tfm)); 165 printk("%s\n", 166 memcmp(result, hash_tv[i].digest, 167 crypto_hash_digestsize(tfm)) ? 168 "fail" : "pass"); 169 } 170 171 printk("testing %s across pages\n", algo); 172 173 /* setup the dummy buffer first */ 174 memset(xbuf, 0, XBUFSIZE); 175 176 j = 0; 177 for (i = 0; i < tcount; i++) { 178 if (hash_tv[i].np) { 179 j++; 180 printk("test %u:\n", j); 181 memset(result, 0, 64); 182 183 temp = 0; 184 sg_init_table(sg, hash_tv[i].np); 185 for (k = 0; k < hash_tv[i].np; k++) { 186 memcpy(&xbuf[IDX[k]], 187 hash_tv[i].plaintext + temp, 188 hash_tv[i].tap[k]); 189 temp += hash_tv[i].tap[k]; 190 sg_set_buf(&sg[k], &xbuf[IDX[k]], 191 hash_tv[i].tap[k]); 192 } 193 194 if (hash_tv[i].ksize) { 195 ret = crypto_hash_setkey(tfm, hash_tv[i].key, 196 hash_tv[i].ksize); 197 198 if (ret) { 199 printk("setkey() failed ret=%d\n", ret); 200 goto out; 201 } 202 } 203 204 ret = crypto_hash_digest(&desc, sg, hash_tv[i].psize, 205 result); 206 if (ret) { 207 printk("digest () failed ret=%d\n", ret); 208 goto out; 209 } 210 211 hexdump(result, crypto_hash_digestsize(tfm)); 212 printk("%s\n", 213 memcmp(result, hash_tv[i].digest, 214 crypto_hash_digestsize(tfm)) ? 215 "fail" : "pass"); 216 } 217 } 218 219 out: 220 crypto_free_hash(tfm); 221 } 222 223 static void test_aead(char *algo, int enc, struct aead_testvec *template, 224 unsigned int tcount) 225 { 226 unsigned int ret, i, j, k, temp; 227 unsigned int tsize; 228 char *q; 229 struct crypto_aead *tfm; 230 char *key; 231 struct aead_testvec *aead_tv; 232 struct aead_request *req; 233 struct scatterlist sg[8]; 234 struct scatterlist asg[8]; 235 const char *e; 236 struct tcrypt_result result; 237 unsigned int authsize; 238 239 if (enc == ENCRYPT) 240 e = "encryption"; 241 else 242 e = "decryption"; 243 244 printk(KERN_INFO "\ntesting %s %s\n", algo, e); 245 246 tsize = sizeof(struct aead_testvec); 247 tsize *= tcount; 248 249 if (tsize > TVMEMSIZE) { 250 printk(KERN_INFO "template (%u) too big for tvmem (%u)\n", 251 tsize, TVMEMSIZE); 252 return; 253 } 254 255 memcpy(tvmem, template, tsize); 256 aead_tv = (void *)tvmem; 257 258 init_completion(&result.completion); 259 260 tfm = crypto_alloc_aead(algo, 0, 0); 261 262 if (IS_ERR(tfm)) { 263 printk(KERN_INFO "failed to load transform for %s: %ld\n", 264 algo, PTR_ERR(tfm)); 265 return; 266 } 267 268 req = aead_request_alloc(tfm, GFP_KERNEL); 269 if (!req) { 270 printk(KERN_INFO "failed to allocate request for %s\n", algo); 271 goto out; 272 } 273 274 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 275 tcrypt_complete, &result); 276 277 for (i = 0, j = 0; i < tcount; i++) { 278 if (!aead_tv[i].np) { 279 printk(KERN_INFO "test %u (%d bit key):\n", 280 ++j, aead_tv[i].klen * 8); 281 282 crypto_aead_clear_flags(tfm, ~0); 283 if (aead_tv[i].wk) 284 crypto_aead_set_flags( 285 tfm, CRYPTO_TFM_REQ_WEAK_KEY); 286 key = aead_tv[i].key; 287 288 ret = crypto_aead_setkey(tfm, key, 289 aead_tv[i].klen); 290 if (ret) { 291 printk(KERN_INFO "setkey() failed flags=%x\n", 292 crypto_aead_get_flags(tfm)); 293 294 if (!aead_tv[i].fail) 295 goto out; 296 } 297 298 authsize = abs(aead_tv[i].rlen - aead_tv[i].ilen); 299 ret = crypto_aead_setauthsize(tfm, authsize); 300 if (ret) { 301 printk(KERN_INFO 302 "failed to set authsize = %u\n", 303 authsize); 304 goto out; 305 } 306 307 sg_init_one(&sg[0], aead_tv[i].input, 308 aead_tv[i].ilen + (enc ? authsize : 0)); 309 310 sg_init_one(&asg[0], aead_tv[i].assoc, 311 aead_tv[i].alen); 312 313 aead_request_set_crypt(req, sg, sg, 314 aead_tv[i].ilen, 315 aead_tv[i].iv); 316 317 aead_request_set_assoc(req, asg, aead_tv[i].alen); 318 319 ret = enc ? 320 crypto_aead_encrypt(req) : 321 crypto_aead_decrypt(req); 322 323 switch (ret) { 324 case 0: 325 break; 326 case -EINPROGRESS: 327 case -EBUSY: 328 ret = wait_for_completion_interruptible( 329 &result.completion); 330 if (!ret && !(ret = result.err)) { 331 INIT_COMPLETION(result.completion); 332 break; 333 } 334 /* fall through */ 335 default: 336 printk(KERN_INFO "%s () failed err=%d\n", 337 e, -ret); 338 goto out; 339 } 340 341 q = kmap(sg_page(&sg[0])) + sg[0].offset; 342 hexdump(q, aead_tv[i].rlen); 343 344 printk(KERN_INFO "enc/dec: %s\n", 345 memcmp(q, aead_tv[i].result, 346 aead_tv[i].rlen) ? "fail" : "pass"); 347 } 348 } 349 350 printk(KERN_INFO "\ntesting %s %s across pages (chunking)\n", algo, e); 351 memset(xbuf, 0, XBUFSIZE); 352 memset(axbuf, 0, XBUFSIZE); 353 354 for (i = 0, j = 0; i < tcount; i++) { 355 if (aead_tv[i].np) { 356 printk(KERN_INFO "test %u (%d bit key):\n", 357 ++j, aead_tv[i].klen * 8); 358 359 crypto_aead_clear_flags(tfm, ~0); 360 if (aead_tv[i].wk) 361 crypto_aead_set_flags( 362 tfm, CRYPTO_TFM_REQ_WEAK_KEY); 363 key = aead_tv[i].key; 364 365 ret = crypto_aead_setkey(tfm, key, aead_tv[i].klen); 366 if (ret) { 367 printk(KERN_INFO "setkey() failed flags=%x\n", 368 crypto_aead_get_flags(tfm)); 369 370 if (!aead_tv[i].fail) 371 goto out; 372 } 373 374 sg_init_table(sg, aead_tv[i].np); 375 for (k = 0, temp = 0; k < aead_tv[i].np; k++) { 376 memcpy(&xbuf[IDX[k]], 377 aead_tv[i].input + temp, 378 aead_tv[i].tap[k]); 379 temp += aead_tv[i].tap[k]; 380 sg_set_buf(&sg[k], &xbuf[IDX[k]], 381 aead_tv[i].tap[k]); 382 } 383 384 authsize = abs(aead_tv[i].rlen - aead_tv[i].ilen); 385 ret = crypto_aead_setauthsize(tfm, authsize); 386 if (ret) { 387 printk(KERN_INFO 388 "failed to set authsize = %u\n", 389 authsize); 390 goto out; 391 } 392 393 if (enc) 394 sg[k - 1].length += authsize; 395 396 sg_init_table(asg, aead_tv[i].anp); 397 for (k = 0, temp = 0; k < aead_tv[i].anp; k++) { 398 memcpy(&axbuf[IDX[k]], 399 aead_tv[i].assoc + temp, 400 aead_tv[i].atap[k]); 401 temp += aead_tv[i].atap[k]; 402 sg_set_buf(&asg[k], &axbuf[IDX[k]], 403 aead_tv[i].atap[k]); 404 } 405 406 aead_request_set_crypt(req, sg, sg, 407 aead_tv[i].ilen, 408 aead_tv[i].iv); 409 410 aead_request_set_assoc(req, asg, aead_tv[i].alen); 411 412 ret = enc ? 413 crypto_aead_encrypt(req) : 414 crypto_aead_decrypt(req); 415 416 switch (ret) { 417 case 0: 418 break; 419 case -EINPROGRESS: 420 case -EBUSY: 421 ret = wait_for_completion_interruptible( 422 &result.completion); 423 if (!ret && !(ret = result.err)) { 424 INIT_COMPLETION(result.completion); 425 break; 426 } 427 /* fall through */ 428 default: 429 printk(KERN_INFO "%s () failed err=%d\n", 430 e, -ret); 431 goto out; 432 } 433 434 for (k = 0, temp = 0; k < aead_tv[i].np; k++) { 435 printk(KERN_INFO "page %u\n", k); 436 q = kmap(sg_page(&sg[k])) + sg[k].offset; 437 hexdump(q, aead_tv[i].tap[k]); 438 printk(KERN_INFO "%s\n", 439 memcmp(q, aead_tv[i].result + temp, 440 aead_tv[i].tap[k] - 441 (k < aead_tv[i].np - 1 || enc ? 442 0 : authsize)) ? 443 "fail" : "pass"); 444 445 temp += aead_tv[i].tap[k]; 446 } 447 } 448 } 449 450 out: 451 crypto_free_aead(tfm); 452 aead_request_free(req); 453 } 454 455 static void test_cipher(char *algo, int enc, 456 struct cipher_testvec *template, unsigned int tcount) 457 { 458 unsigned int ret, i, j, k, temp; 459 unsigned int tsize; 460 char *q; 461 struct crypto_ablkcipher *tfm; 462 char *key; 463 struct cipher_testvec *cipher_tv; 464 struct ablkcipher_request *req; 465 struct scatterlist sg[8]; 466 const char *e; 467 struct tcrypt_result result; 468 469 if (enc == ENCRYPT) 470 e = "encryption"; 471 else 472 e = "decryption"; 473 474 printk("\ntesting %s %s\n", algo, e); 475 476 tsize = sizeof (struct cipher_testvec); 477 if (tsize > TVMEMSIZE) { 478 printk("template (%u) too big for tvmem (%u)\n", tsize, 479 TVMEMSIZE); 480 return; 481 } 482 cipher_tv = (void *)tvmem; 483 484 init_completion(&result.completion); 485 486 tfm = crypto_alloc_ablkcipher(algo, 0, 0); 487 488 if (IS_ERR(tfm)) { 489 printk("failed to load transform for %s: %ld\n", algo, 490 PTR_ERR(tfm)); 491 return; 492 } 493 494 req = ablkcipher_request_alloc(tfm, GFP_KERNEL); 495 if (!req) { 496 printk("failed to allocate request for %s\n", algo); 497 goto out; 498 } 499 500 ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, 501 tcrypt_complete, &result); 502 503 j = 0; 504 for (i = 0; i < tcount; i++) { 505 memcpy(cipher_tv, &template[i], tsize); 506 if (!(cipher_tv->np)) { 507 j++; 508 printk("test %u (%d bit key):\n", 509 j, cipher_tv->klen * 8); 510 511 crypto_ablkcipher_clear_flags(tfm, ~0); 512 if (cipher_tv->wk) 513 crypto_ablkcipher_set_flags( 514 tfm, CRYPTO_TFM_REQ_WEAK_KEY); 515 key = cipher_tv->key; 516 517 ret = crypto_ablkcipher_setkey(tfm, key, 518 cipher_tv->klen); 519 if (ret) { 520 printk("setkey() failed flags=%x\n", 521 crypto_ablkcipher_get_flags(tfm)); 522 523 if (!cipher_tv->fail) 524 goto out; 525 } 526 527 sg_init_one(&sg[0], cipher_tv->input, 528 cipher_tv->ilen); 529 530 ablkcipher_request_set_crypt(req, sg, sg, 531 cipher_tv->ilen, 532 cipher_tv->iv); 533 534 ret = enc ? 535 crypto_ablkcipher_encrypt(req) : 536 crypto_ablkcipher_decrypt(req); 537 538 switch (ret) { 539 case 0: 540 break; 541 case -EINPROGRESS: 542 case -EBUSY: 543 ret = wait_for_completion_interruptible( 544 &result.completion); 545 if (!ret && !((ret = result.err))) { 546 INIT_COMPLETION(result.completion); 547 break; 548 } 549 /* fall through */ 550 default: 551 printk("%s () failed err=%d\n", e, -ret); 552 goto out; 553 } 554 555 q = kmap(sg_page(&sg[0])) + sg[0].offset; 556 hexdump(q, cipher_tv->rlen); 557 558 printk("%s\n", 559 memcmp(q, cipher_tv->result, 560 cipher_tv->rlen) ? "fail" : "pass"); 561 } 562 } 563 564 printk("\ntesting %s %s across pages (chunking)\n", algo, e); 565 memset(xbuf, 0, XBUFSIZE); 566 567 j = 0; 568 for (i = 0; i < tcount; i++) { 569 memcpy(cipher_tv, &template[i], tsize); 570 if (cipher_tv->np) { 571 j++; 572 printk("test %u (%d bit key):\n", 573 j, cipher_tv->klen * 8); 574 575 crypto_ablkcipher_clear_flags(tfm, ~0); 576 if (cipher_tv->wk) 577 crypto_ablkcipher_set_flags( 578 tfm, CRYPTO_TFM_REQ_WEAK_KEY); 579 key = cipher_tv->key; 580 581 ret = crypto_ablkcipher_setkey(tfm, key, 582 cipher_tv->klen); 583 if (ret) { 584 printk("setkey() failed flags=%x\n", 585 crypto_ablkcipher_get_flags(tfm)); 586 587 if (!cipher_tv->fail) 588 goto out; 589 } 590 591 temp = 0; 592 sg_init_table(sg, cipher_tv->np); 593 for (k = 0; k < cipher_tv->np; k++) { 594 memcpy(&xbuf[IDX[k]], 595 cipher_tv->input + temp, 596 cipher_tv->tap[k]); 597 temp += cipher_tv->tap[k]; 598 sg_set_buf(&sg[k], &xbuf[IDX[k]], 599 cipher_tv->tap[k]); 600 } 601 602 ablkcipher_request_set_crypt(req, sg, sg, 603 cipher_tv->ilen, 604 cipher_tv->iv); 605 606 ret = enc ? 607 crypto_ablkcipher_encrypt(req) : 608 crypto_ablkcipher_decrypt(req); 609 610 switch (ret) { 611 case 0: 612 break; 613 case -EINPROGRESS: 614 case -EBUSY: 615 ret = wait_for_completion_interruptible( 616 &result.completion); 617 if (!ret && !((ret = result.err))) { 618 INIT_COMPLETION(result.completion); 619 break; 620 } 621 /* fall through */ 622 default: 623 printk("%s () failed err=%d\n", e, -ret); 624 goto out; 625 } 626 627 temp = 0; 628 for (k = 0; k < cipher_tv->np; k++) { 629 printk("page %u\n", k); 630 q = kmap(sg_page(&sg[k])) + sg[k].offset; 631 hexdump(q, cipher_tv->tap[k]); 632 printk("%s\n", 633 memcmp(q, cipher_tv->result + temp, 634 cipher_tv->tap[k]) ? "fail" : 635 "pass"); 636 temp += cipher_tv->tap[k]; 637 } 638 } 639 } 640 641 out: 642 crypto_free_ablkcipher(tfm); 643 ablkcipher_request_free(req); 644 } 645 646 static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc, char *p, 647 int blen, int sec) 648 { 649 struct scatterlist sg[1]; 650 unsigned long start, end; 651 int bcount; 652 int ret; 653 654 sg_init_one(sg, p, blen); 655 656 for (start = jiffies, end = start + sec * HZ, bcount = 0; 657 time_before(jiffies, end); bcount++) { 658 if (enc) 659 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen); 660 else 661 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen); 662 663 if (ret) 664 return ret; 665 } 666 667 printk("%d operations in %d seconds (%ld bytes)\n", 668 bcount, sec, (long)bcount * blen); 669 return 0; 670 } 671 672 static int test_cipher_cycles(struct blkcipher_desc *desc, int enc, char *p, 673 int blen) 674 { 675 struct scatterlist sg[1]; 676 unsigned long cycles = 0; 677 int ret = 0; 678 int i; 679 680 sg_init_one(sg, p, blen); 681 682 local_bh_disable(); 683 local_irq_disable(); 684 685 /* Warm-up run. */ 686 for (i = 0; i < 4; i++) { 687 if (enc) 688 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen); 689 else 690 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen); 691 692 if (ret) 693 goto out; 694 } 695 696 /* The real thing. */ 697 for (i = 0; i < 8; i++) { 698 cycles_t start, end; 699 700 start = get_cycles(); 701 if (enc) 702 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen); 703 else 704 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen); 705 end = get_cycles(); 706 707 if (ret) 708 goto out; 709 710 cycles += end - start; 711 } 712 713 out: 714 local_irq_enable(); 715 local_bh_enable(); 716 717 if (ret == 0) 718 printk("1 operation in %lu cycles (%d bytes)\n", 719 (cycles + 4) / 8, blen); 720 721 return ret; 722 } 723 724 static void test_cipher_speed(char *algo, int enc, unsigned int sec, 725 struct cipher_testvec *template, 726 unsigned int tcount, struct cipher_speed *speed) 727 { 728 unsigned int ret, i, j, iv_len; 729 unsigned char *key, *p, iv[128]; 730 struct crypto_blkcipher *tfm; 731 struct blkcipher_desc desc; 732 const char *e; 733 734 if (enc == ENCRYPT) 735 e = "encryption"; 736 else 737 e = "decryption"; 738 739 printk("\ntesting speed of %s %s\n", algo, e); 740 741 tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC); 742 743 if (IS_ERR(tfm)) { 744 printk("failed to load transform for %s: %ld\n", algo, 745 PTR_ERR(tfm)); 746 return; 747 } 748 desc.tfm = tfm; 749 desc.flags = 0; 750 751 for (i = 0; speed[i].klen != 0; i++) { 752 if ((speed[i].blen + speed[i].klen) > TVMEMSIZE) { 753 printk("template (%u) too big for tvmem (%u)\n", 754 speed[i].blen + speed[i].klen, TVMEMSIZE); 755 goto out; 756 } 757 758 printk("test %u (%d bit key, %d byte blocks): ", i, 759 speed[i].klen * 8, speed[i].blen); 760 761 memset(tvmem, 0xff, speed[i].klen + speed[i].blen); 762 763 /* set key, plain text and IV */ 764 key = (unsigned char *)tvmem; 765 for (j = 0; j < tcount; j++) { 766 if (template[j].klen == speed[i].klen) { 767 key = template[j].key; 768 break; 769 } 770 } 771 p = (unsigned char *)tvmem + speed[i].klen; 772 773 ret = crypto_blkcipher_setkey(tfm, key, speed[i].klen); 774 if (ret) { 775 printk("setkey() failed flags=%x\n", 776 crypto_blkcipher_get_flags(tfm)); 777 goto out; 778 } 779 780 iv_len = crypto_blkcipher_ivsize(tfm); 781 if (iv_len) { 782 memset(&iv, 0xff, iv_len); 783 crypto_blkcipher_set_iv(tfm, iv, iv_len); 784 } 785 786 if (sec) 787 ret = test_cipher_jiffies(&desc, enc, p, speed[i].blen, 788 sec); 789 else 790 ret = test_cipher_cycles(&desc, enc, p, speed[i].blen); 791 792 if (ret) { 793 printk("%s() failed flags=%x\n", e, desc.flags); 794 break; 795 } 796 } 797 798 out: 799 crypto_free_blkcipher(tfm); 800 } 801 802 static int test_hash_jiffies_digest(struct hash_desc *desc, char *p, int blen, 803 char *out, int sec) 804 { 805 struct scatterlist sg[1]; 806 unsigned long start, end; 807 int bcount; 808 int ret; 809 810 sg_init_table(sg, 1); 811 812 for (start = jiffies, end = start + sec * HZ, bcount = 0; 813 time_before(jiffies, end); bcount++) { 814 sg_set_buf(sg, p, blen); 815 ret = crypto_hash_digest(desc, sg, blen, out); 816 if (ret) 817 return ret; 818 } 819 820 printk("%6u opers/sec, %9lu bytes/sec\n", 821 bcount / sec, ((long)bcount * blen) / sec); 822 823 return 0; 824 } 825 826 static int test_hash_jiffies(struct hash_desc *desc, char *p, int blen, 827 int plen, char *out, int sec) 828 { 829 struct scatterlist sg[1]; 830 unsigned long start, end; 831 int bcount, pcount; 832 int ret; 833 834 if (plen == blen) 835 return test_hash_jiffies_digest(desc, p, blen, out, sec); 836 837 sg_init_table(sg, 1); 838 839 for (start = jiffies, end = start + sec * HZ, bcount = 0; 840 time_before(jiffies, end); bcount++) { 841 ret = crypto_hash_init(desc); 842 if (ret) 843 return ret; 844 for (pcount = 0; pcount < blen; pcount += plen) { 845 sg_set_buf(sg, p + pcount, plen); 846 ret = crypto_hash_update(desc, sg, plen); 847 if (ret) 848 return ret; 849 } 850 /* we assume there is enough space in 'out' for the result */ 851 ret = crypto_hash_final(desc, out); 852 if (ret) 853 return ret; 854 } 855 856 printk("%6u opers/sec, %9lu bytes/sec\n", 857 bcount / sec, ((long)bcount * blen) / sec); 858 859 return 0; 860 } 861 862 static int test_hash_cycles_digest(struct hash_desc *desc, char *p, int blen, 863 char *out) 864 { 865 struct scatterlist sg[1]; 866 unsigned long cycles = 0; 867 int i; 868 int ret; 869 870 sg_init_table(sg, 1); 871 872 local_bh_disable(); 873 local_irq_disable(); 874 875 /* Warm-up run. */ 876 for (i = 0; i < 4; i++) { 877 sg_set_buf(sg, p, blen); 878 ret = crypto_hash_digest(desc, sg, blen, out); 879 if (ret) 880 goto out; 881 } 882 883 /* The real thing. */ 884 for (i = 0; i < 8; i++) { 885 cycles_t start, end; 886 887 start = get_cycles(); 888 889 sg_set_buf(sg, p, blen); 890 ret = crypto_hash_digest(desc, sg, blen, out); 891 if (ret) 892 goto out; 893 894 end = get_cycles(); 895 896 cycles += end - start; 897 } 898 899 out: 900 local_irq_enable(); 901 local_bh_enable(); 902 903 if (ret) 904 return ret; 905 906 printk("%6lu cycles/operation, %4lu cycles/byte\n", 907 cycles / 8, cycles / (8 * blen)); 908 909 return 0; 910 } 911 912 static int test_hash_cycles(struct hash_desc *desc, char *p, int blen, 913 int plen, char *out) 914 { 915 struct scatterlist sg[1]; 916 unsigned long cycles = 0; 917 int i, pcount; 918 int ret; 919 920 if (plen == blen) 921 return test_hash_cycles_digest(desc, p, blen, out); 922 923 sg_init_table(sg, 1); 924 925 local_bh_disable(); 926 local_irq_disable(); 927 928 /* Warm-up run. */ 929 for (i = 0; i < 4; i++) { 930 ret = crypto_hash_init(desc); 931 if (ret) 932 goto out; 933 for (pcount = 0; pcount < blen; pcount += plen) { 934 sg_set_buf(sg, p + pcount, plen); 935 ret = crypto_hash_update(desc, sg, plen); 936 if (ret) 937 goto out; 938 } 939 ret = crypto_hash_final(desc, out); 940 if (ret) 941 goto out; 942 } 943 944 /* The real thing. */ 945 for (i = 0; i < 8; i++) { 946 cycles_t start, end; 947 948 start = get_cycles(); 949 950 ret = crypto_hash_init(desc); 951 if (ret) 952 goto out; 953 for (pcount = 0; pcount < blen; pcount += plen) { 954 sg_set_buf(sg, p + pcount, plen); 955 ret = crypto_hash_update(desc, sg, plen); 956 if (ret) 957 goto out; 958 } 959 ret = crypto_hash_final(desc, out); 960 if (ret) 961 goto out; 962 963 end = get_cycles(); 964 965 cycles += end - start; 966 } 967 968 out: 969 local_irq_enable(); 970 local_bh_enable(); 971 972 if (ret) 973 return ret; 974 975 printk("%6lu cycles/operation, %4lu cycles/byte\n", 976 cycles / 8, cycles / (8 * blen)); 977 978 return 0; 979 } 980 981 static void test_hash_speed(char *algo, unsigned int sec, 982 struct hash_speed *speed) 983 { 984 struct crypto_hash *tfm; 985 struct hash_desc desc; 986 char output[1024]; 987 int i; 988 int ret; 989 990 printk("\ntesting speed of %s\n", algo); 991 992 tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC); 993 994 if (IS_ERR(tfm)) { 995 printk("failed to load transform for %s: %ld\n", algo, 996 PTR_ERR(tfm)); 997 return; 998 } 999 1000 desc.tfm = tfm; 1001 desc.flags = 0; 1002 1003 if (crypto_hash_digestsize(tfm) > sizeof(output)) { 1004 printk("digestsize(%u) > outputbuffer(%zu)\n", 1005 crypto_hash_digestsize(tfm), sizeof(output)); 1006 goto out; 1007 } 1008 1009 for (i = 0; speed[i].blen != 0; i++) { 1010 if (speed[i].blen > TVMEMSIZE) { 1011 printk("template (%u) too big for tvmem (%u)\n", 1012 speed[i].blen, TVMEMSIZE); 1013 goto out; 1014 } 1015 1016 printk("test%3u (%5u byte blocks,%5u bytes per update,%4u updates): ", 1017 i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen); 1018 1019 memset(tvmem, 0xff, speed[i].blen); 1020 1021 if (sec) 1022 ret = test_hash_jiffies(&desc, tvmem, speed[i].blen, 1023 speed[i].plen, output, sec); 1024 else 1025 ret = test_hash_cycles(&desc, tvmem, speed[i].blen, 1026 speed[i].plen, output); 1027 1028 if (ret) { 1029 printk("hashing failed ret=%d\n", ret); 1030 break; 1031 } 1032 } 1033 1034 out: 1035 crypto_free_hash(tfm); 1036 } 1037 1038 static void test_comp(char *algo, struct comp_testvec *ctemplate, 1039 struct comp_testvec *dtemplate, int ctcount, int dtcount) 1040 { 1041 unsigned int i; 1042 char result[COMP_BUF_SIZE]; 1043 struct crypto_comp *tfm; 1044 struct comp_testvec *tv; 1045 unsigned int tsize; 1046 1047 printk("\ntesting %s compression\n", algo); 1048 1049 tsize = sizeof(struct comp_testvec); 1050 tsize *= ctcount; 1051 if (tsize > TVMEMSIZE) { 1052 printk("template (%u) too big for tvmem (%u)\n", tsize, 1053 TVMEMSIZE); 1054 return; 1055 } 1056 1057 memcpy(tvmem, ctemplate, tsize); 1058 tv = (void *)tvmem; 1059 1060 tfm = crypto_alloc_comp(algo, 0, CRYPTO_ALG_ASYNC); 1061 if (IS_ERR(tfm)) { 1062 printk("failed to load transform for %s\n", algo); 1063 return; 1064 } 1065 1066 for (i = 0; i < ctcount; i++) { 1067 int ilen, ret, dlen = COMP_BUF_SIZE; 1068 1069 printk("test %u:\n", i + 1); 1070 memset(result, 0, sizeof (result)); 1071 1072 ilen = tv[i].inlen; 1073 ret = crypto_comp_compress(tfm, tv[i].input, 1074 ilen, result, &dlen); 1075 if (ret) { 1076 printk("fail: ret=%d\n", ret); 1077 continue; 1078 } 1079 hexdump(result, dlen); 1080 printk("%s (ratio %d:%d)\n", 1081 memcmp(result, tv[i].output, dlen) ? "fail" : "pass", 1082 ilen, dlen); 1083 } 1084 1085 printk("\ntesting %s decompression\n", algo); 1086 1087 tsize = sizeof(struct comp_testvec); 1088 tsize *= dtcount; 1089 if (tsize > TVMEMSIZE) { 1090 printk("template (%u) too big for tvmem (%u)\n", tsize, 1091 TVMEMSIZE); 1092 goto out; 1093 } 1094 1095 memcpy(tvmem, dtemplate, tsize); 1096 tv = (void *)tvmem; 1097 1098 for (i = 0; i < dtcount; i++) { 1099 int ilen, ret, dlen = COMP_BUF_SIZE; 1100 1101 printk("test %u:\n", i + 1); 1102 memset(result, 0, sizeof (result)); 1103 1104 ilen = tv[i].inlen; 1105 ret = crypto_comp_decompress(tfm, tv[i].input, 1106 ilen, result, &dlen); 1107 if (ret) { 1108 printk("fail: ret=%d\n", ret); 1109 continue; 1110 } 1111 hexdump(result, dlen); 1112 printk("%s (ratio %d:%d)\n", 1113 memcmp(result, tv[i].output, dlen) ? "fail" : "pass", 1114 ilen, dlen); 1115 } 1116 out: 1117 crypto_free_comp(tfm); 1118 } 1119 1120 static void test_available(void) 1121 { 1122 char **name = check; 1123 1124 while (*name) { 1125 printk("alg %s ", *name); 1126 printk(crypto_has_alg(*name, 0, 0) ? 1127 "found\n" : "not found\n"); 1128 name++; 1129 } 1130 } 1131 1132 static void do_test(void) 1133 { 1134 switch (mode) { 1135 1136 case 0: 1137 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS); 1138 1139 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS); 1140 1141 //DES 1142 test_cipher("ecb(des)", ENCRYPT, des_enc_tv_template, 1143 DES_ENC_TEST_VECTORS); 1144 test_cipher("ecb(des)", DECRYPT, des_dec_tv_template, 1145 DES_DEC_TEST_VECTORS); 1146 test_cipher("cbc(des)", ENCRYPT, des_cbc_enc_tv_template, 1147 DES_CBC_ENC_TEST_VECTORS); 1148 test_cipher("cbc(des)", DECRYPT, des_cbc_dec_tv_template, 1149 DES_CBC_DEC_TEST_VECTORS); 1150 1151 //DES3_EDE 1152 test_cipher("ecb(des3_ede)", ENCRYPT, des3_ede_enc_tv_template, 1153 DES3_EDE_ENC_TEST_VECTORS); 1154 test_cipher("ecb(des3_ede)", DECRYPT, des3_ede_dec_tv_template, 1155 DES3_EDE_DEC_TEST_VECTORS); 1156 1157 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS); 1158 1159 test_hash("sha224", sha224_tv_template, SHA224_TEST_VECTORS); 1160 1161 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS); 1162 1163 //BLOWFISH 1164 test_cipher("ecb(blowfish)", ENCRYPT, bf_enc_tv_template, 1165 BF_ENC_TEST_VECTORS); 1166 test_cipher("ecb(blowfish)", DECRYPT, bf_dec_tv_template, 1167 BF_DEC_TEST_VECTORS); 1168 test_cipher("cbc(blowfish)", ENCRYPT, bf_cbc_enc_tv_template, 1169 BF_CBC_ENC_TEST_VECTORS); 1170 test_cipher("cbc(blowfish)", DECRYPT, bf_cbc_dec_tv_template, 1171 BF_CBC_DEC_TEST_VECTORS); 1172 1173 //TWOFISH 1174 test_cipher("ecb(twofish)", ENCRYPT, tf_enc_tv_template, 1175 TF_ENC_TEST_VECTORS); 1176 test_cipher("ecb(twofish)", DECRYPT, tf_dec_tv_template, 1177 TF_DEC_TEST_VECTORS); 1178 test_cipher("cbc(twofish)", ENCRYPT, tf_cbc_enc_tv_template, 1179 TF_CBC_ENC_TEST_VECTORS); 1180 test_cipher("cbc(twofish)", DECRYPT, tf_cbc_dec_tv_template, 1181 TF_CBC_DEC_TEST_VECTORS); 1182 1183 //SERPENT 1184 test_cipher("ecb(serpent)", ENCRYPT, serpent_enc_tv_template, 1185 SERPENT_ENC_TEST_VECTORS); 1186 test_cipher("ecb(serpent)", DECRYPT, serpent_dec_tv_template, 1187 SERPENT_DEC_TEST_VECTORS); 1188 1189 //TNEPRES 1190 test_cipher("ecb(tnepres)", ENCRYPT, tnepres_enc_tv_template, 1191 TNEPRES_ENC_TEST_VECTORS); 1192 test_cipher("ecb(tnepres)", DECRYPT, tnepres_dec_tv_template, 1193 TNEPRES_DEC_TEST_VECTORS); 1194 1195 //AES 1196 test_cipher("ecb(aes)", ENCRYPT, aes_enc_tv_template, 1197 AES_ENC_TEST_VECTORS); 1198 test_cipher("ecb(aes)", DECRYPT, aes_dec_tv_template, 1199 AES_DEC_TEST_VECTORS); 1200 test_cipher("cbc(aes)", ENCRYPT, aes_cbc_enc_tv_template, 1201 AES_CBC_ENC_TEST_VECTORS); 1202 test_cipher("cbc(aes)", DECRYPT, aes_cbc_dec_tv_template, 1203 AES_CBC_DEC_TEST_VECTORS); 1204 test_cipher("lrw(aes)", ENCRYPT, aes_lrw_enc_tv_template, 1205 AES_LRW_ENC_TEST_VECTORS); 1206 test_cipher("lrw(aes)", DECRYPT, aes_lrw_dec_tv_template, 1207 AES_LRW_DEC_TEST_VECTORS); 1208 test_cipher("xts(aes)", ENCRYPT, aes_xts_enc_tv_template, 1209 AES_XTS_ENC_TEST_VECTORS); 1210 test_cipher("xts(aes)", DECRYPT, aes_xts_dec_tv_template, 1211 AES_XTS_DEC_TEST_VECTORS); 1212 test_cipher("rfc3686(ctr(aes))", ENCRYPT, aes_ctr_enc_tv_template, 1213 AES_CTR_ENC_TEST_VECTORS); 1214 test_cipher("rfc3686(ctr(aes))", DECRYPT, aes_ctr_dec_tv_template, 1215 AES_CTR_DEC_TEST_VECTORS); 1216 test_aead("gcm(aes)", ENCRYPT, aes_gcm_enc_tv_template, 1217 AES_GCM_ENC_TEST_VECTORS); 1218 test_aead("gcm(aes)", DECRYPT, aes_gcm_dec_tv_template, 1219 AES_GCM_DEC_TEST_VECTORS); 1220 test_aead("ccm(aes)", ENCRYPT, aes_ccm_enc_tv_template, 1221 AES_CCM_ENC_TEST_VECTORS); 1222 test_aead("ccm(aes)", DECRYPT, aes_ccm_dec_tv_template, 1223 AES_CCM_DEC_TEST_VECTORS); 1224 1225 //CAST5 1226 test_cipher("ecb(cast5)", ENCRYPT, cast5_enc_tv_template, 1227 CAST5_ENC_TEST_VECTORS); 1228 test_cipher("ecb(cast5)", DECRYPT, cast5_dec_tv_template, 1229 CAST5_DEC_TEST_VECTORS); 1230 1231 //CAST6 1232 test_cipher("ecb(cast6)", ENCRYPT, cast6_enc_tv_template, 1233 CAST6_ENC_TEST_VECTORS); 1234 test_cipher("ecb(cast6)", DECRYPT, cast6_dec_tv_template, 1235 CAST6_DEC_TEST_VECTORS); 1236 1237 //ARC4 1238 test_cipher("ecb(arc4)", ENCRYPT, arc4_enc_tv_template, 1239 ARC4_ENC_TEST_VECTORS); 1240 test_cipher("ecb(arc4)", DECRYPT, arc4_dec_tv_template, 1241 ARC4_DEC_TEST_VECTORS); 1242 1243 //TEA 1244 test_cipher("ecb(tea)", ENCRYPT, tea_enc_tv_template, 1245 TEA_ENC_TEST_VECTORS); 1246 test_cipher("ecb(tea)", DECRYPT, tea_dec_tv_template, 1247 TEA_DEC_TEST_VECTORS); 1248 1249 1250 //XTEA 1251 test_cipher("ecb(xtea)", ENCRYPT, xtea_enc_tv_template, 1252 XTEA_ENC_TEST_VECTORS); 1253 test_cipher("ecb(xtea)", DECRYPT, xtea_dec_tv_template, 1254 XTEA_DEC_TEST_VECTORS); 1255 1256 //KHAZAD 1257 test_cipher("ecb(khazad)", ENCRYPT, khazad_enc_tv_template, 1258 KHAZAD_ENC_TEST_VECTORS); 1259 test_cipher("ecb(khazad)", DECRYPT, khazad_dec_tv_template, 1260 KHAZAD_DEC_TEST_VECTORS); 1261 1262 //ANUBIS 1263 test_cipher("ecb(anubis)", ENCRYPT, anubis_enc_tv_template, 1264 ANUBIS_ENC_TEST_VECTORS); 1265 test_cipher("ecb(anubis)", DECRYPT, anubis_dec_tv_template, 1266 ANUBIS_DEC_TEST_VECTORS); 1267 test_cipher("cbc(anubis)", ENCRYPT, anubis_cbc_enc_tv_template, 1268 ANUBIS_CBC_ENC_TEST_VECTORS); 1269 test_cipher("cbc(anubis)", DECRYPT, anubis_cbc_dec_tv_template, 1270 ANUBIS_CBC_ENC_TEST_VECTORS); 1271 1272 //XETA 1273 test_cipher("ecb(xeta)", ENCRYPT, xeta_enc_tv_template, 1274 XETA_ENC_TEST_VECTORS); 1275 test_cipher("ecb(xeta)", DECRYPT, xeta_dec_tv_template, 1276 XETA_DEC_TEST_VECTORS); 1277 1278 //FCrypt 1279 test_cipher("pcbc(fcrypt)", ENCRYPT, fcrypt_pcbc_enc_tv_template, 1280 FCRYPT_ENC_TEST_VECTORS); 1281 test_cipher("pcbc(fcrypt)", DECRYPT, fcrypt_pcbc_dec_tv_template, 1282 FCRYPT_DEC_TEST_VECTORS); 1283 1284 //CAMELLIA 1285 test_cipher("ecb(camellia)", ENCRYPT, 1286 camellia_enc_tv_template, 1287 CAMELLIA_ENC_TEST_VECTORS); 1288 test_cipher("ecb(camellia)", DECRYPT, 1289 camellia_dec_tv_template, 1290 CAMELLIA_DEC_TEST_VECTORS); 1291 test_cipher("cbc(camellia)", ENCRYPT, 1292 camellia_cbc_enc_tv_template, 1293 CAMELLIA_CBC_ENC_TEST_VECTORS); 1294 test_cipher("cbc(camellia)", DECRYPT, 1295 camellia_cbc_dec_tv_template, 1296 CAMELLIA_CBC_DEC_TEST_VECTORS); 1297 1298 //SEED 1299 test_cipher("ecb(seed)", ENCRYPT, seed_enc_tv_template, 1300 SEED_ENC_TEST_VECTORS); 1301 test_cipher("ecb(seed)", DECRYPT, seed_dec_tv_template, 1302 SEED_DEC_TEST_VECTORS); 1303 1304 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS); 1305 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS); 1306 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS); 1307 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS); 1308 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS); 1309 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS); 1310 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS); 1311 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS); 1312 test_comp("deflate", deflate_comp_tv_template, 1313 deflate_decomp_tv_template, DEFLATE_COMP_TEST_VECTORS, 1314 DEFLATE_DECOMP_TEST_VECTORS); 1315 test_comp("lzo", lzo_comp_tv_template, lzo_decomp_tv_template, 1316 LZO_COMP_TEST_VECTORS, LZO_DECOMP_TEST_VECTORS); 1317 test_hash("crc32c", crc32c_tv_template, CRC32C_TEST_VECTORS); 1318 test_hash("hmac(md5)", hmac_md5_tv_template, 1319 HMAC_MD5_TEST_VECTORS); 1320 test_hash("hmac(sha1)", hmac_sha1_tv_template, 1321 HMAC_SHA1_TEST_VECTORS); 1322 test_hash("hmac(sha224)", hmac_sha224_tv_template, 1323 HMAC_SHA224_TEST_VECTORS); 1324 test_hash("hmac(sha256)", hmac_sha256_tv_template, 1325 HMAC_SHA256_TEST_VECTORS); 1326 test_hash("hmac(sha384)", hmac_sha384_tv_template, 1327 HMAC_SHA384_TEST_VECTORS); 1328 test_hash("hmac(sha512)", hmac_sha512_tv_template, 1329 HMAC_SHA512_TEST_VECTORS); 1330 1331 test_hash("xcbc(aes)", aes_xcbc128_tv_template, 1332 XCBC_AES_TEST_VECTORS); 1333 1334 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS); 1335 break; 1336 1337 case 1: 1338 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS); 1339 break; 1340 1341 case 2: 1342 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS); 1343 break; 1344 1345 case 3: 1346 test_cipher("ecb(des)", ENCRYPT, des_enc_tv_template, 1347 DES_ENC_TEST_VECTORS); 1348 test_cipher("ecb(des)", DECRYPT, des_dec_tv_template, 1349 DES_DEC_TEST_VECTORS); 1350 test_cipher("cbc(des)", ENCRYPT, des_cbc_enc_tv_template, 1351 DES_CBC_ENC_TEST_VECTORS); 1352 test_cipher("cbc(des)", DECRYPT, des_cbc_dec_tv_template, 1353 DES_CBC_DEC_TEST_VECTORS); 1354 break; 1355 1356 case 4: 1357 test_cipher("ecb(des3_ede)", ENCRYPT, des3_ede_enc_tv_template, 1358 DES3_EDE_ENC_TEST_VECTORS); 1359 test_cipher("ecb(des3_ede)", DECRYPT, des3_ede_dec_tv_template, 1360 DES3_EDE_DEC_TEST_VECTORS); 1361 break; 1362 1363 case 5: 1364 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS); 1365 break; 1366 1367 case 6: 1368 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS); 1369 break; 1370 1371 case 7: 1372 test_cipher("ecb(blowfish)", ENCRYPT, bf_enc_tv_template, 1373 BF_ENC_TEST_VECTORS); 1374 test_cipher("ecb(blowfish)", DECRYPT, bf_dec_tv_template, 1375 BF_DEC_TEST_VECTORS); 1376 test_cipher("cbc(blowfish)", ENCRYPT, bf_cbc_enc_tv_template, 1377 BF_CBC_ENC_TEST_VECTORS); 1378 test_cipher("cbc(blowfish)", DECRYPT, bf_cbc_dec_tv_template, 1379 BF_CBC_DEC_TEST_VECTORS); 1380 break; 1381 1382 case 8: 1383 test_cipher("ecb(twofish)", ENCRYPT, tf_enc_tv_template, 1384 TF_ENC_TEST_VECTORS); 1385 test_cipher("ecb(twofish)", DECRYPT, tf_dec_tv_template, 1386 TF_DEC_TEST_VECTORS); 1387 test_cipher("cbc(twofish)", ENCRYPT, tf_cbc_enc_tv_template, 1388 TF_CBC_ENC_TEST_VECTORS); 1389 test_cipher("cbc(twofish)", DECRYPT, tf_cbc_dec_tv_template, 1390 TF_CBC_DEC_TEST_VECTORS); 1391 break; 1392 1393 case 9: 1394 test_cipher("ecb(serpent)", ENCRYPT, serpent_enc_tv_template, 1395 SERPENT_ENC_TEST_VECTORS); 1396 test_cipher("ecb(serpent)", DECRYPT, serpent_dec_tv_template, 1397 SERPENT_DEC_TEST_VECTORS); 1398 break; 1399 1400 case 10: 1401 test_cipher("ecb(aes)", ENCRYPT, aes_enc_tv_template, 1402 AES_ENC_TEST_VECTORS); 1403 test_cipher("ecb(aes)", DECRYPT, aes_dec_tv_template, 1404 AES_DEC_TEST_VECTORS); 1405 test_cipher("cbc(aes)", ENCRYPT, aes_cbc_enc_tv_template, 1406 AES_CBC_ENC_TEST_VECTORS); 1407 test_cipher("cbc(aes)", DECRYPT, aes_cbc_dec_tv_template, 1408 AES_CBC_DEC_TEST_VECTORS); 1409 test_cipher("lrw(aes)", ENCRYPT, aes_lrw_enc_tv_template, 1410 AES_LRW_ENC_TEST_VECTORS); 1411 test_cipher("lrw(aes)", DECRYPT, aes_lrw_dec_tv_template, 1412 AES_LRW_DEC_TEST_VECTORS); 1413 test_cipher("xts(aes)", ENCRYPT, aes_xts_enc_tv_template, 1414 AES_XTS_ENC_TEST_VECTORS); 1415 test_cipher("xts(aes)", DECRYPT, aes_xts_dec_tv_template, 1416 AES_XTS_DEC_TEST_VECTORS); 1417 test_cipher("rfc3686(ctr(aes))", ENCRYPT, aes_ctr_enc_tv_template, 1418 AES_CTR_ENC_TEST_VECTORS); 1419 test_cipher("rfc3686(ctr(aes))", DECRYPT, aes_ctr_dec_tv_template, 1420 AES_CTR_DEC_TEST_VECTORS); 1421 break; 1422 1423 case 11: 1424 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS); 1425 break; 1426 1427 case 12: 1428 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS); 1429 break; 1430 1431 case 13: 1432 test_comp("deflate", deflate_comp_tv_template, 1433 deflate_decomp_tv_template, DEFLATE_COMP_TEST_VECTORS, 1434 DEFLATE_DECOMP_TEST_VECTORS); 1435 break; 1436 1437 case 14: 1438 test_cipher("ecb(cast5)", ENCRYPT, cast5_enc_tv_template, 1439 CAST5_ENC_TEST_VECTORS); 1440 test_cipher("ecb(cast5)", DECRYPT, cast5_dec_tv_template, 1441 CAST5_DEC_TEST_VECTORS); 1442 break; 1443 1444 case 15: 1445 test_cipher("ecb(cast6)", ENCRYPT, cast6_enc_tv_template, 1446 CAST6_ENC_TEST_VECTORS); 1447 test_cipher("ecb(cast6)", DECRYPT, cast6_dec_tv_template, 1448 CAST6_DEC_TEST_VECTORS); 1449 break; 1450 1451 case 16: 1452 test_cipher("ecb(arc4)", ENCRYPT, arc4_enc_tv_template, 1453 ARC4_ENC_TEST_VECTORS); 1454 test_cipher("ecb(arc4)", DECRYPT, arc4_dec_tv_template, 1455 ARC4_DEC_TEST_VECTORS); 1456 break; 1457 1458 case 17: 1459 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS); 1460 break; 1461 1462 case 18: 1463 test_hash("crc32c", crc32c_tv_template, CRC32C_TEST_VECTORS); 1464 break; 1465 1466 case 19: 1467 test_cipher("ecb(tea)", ENCRYPT, tea_enc_tv_template, 1468 TEA_ENC_TEST_VECTORS); 1469 test_cipher("ecb(tea)", DECRYPT, tea_dec_tv_template, 1470 TEA_DEC_TEST_VECTORS); 1471 break; 1472 1473 case 20: 1474 test_cipher("ecb(xtea)", ENCRYPT, xtea_enc_tv_template, 1475 XTEA_ENC_TEST_VECTORS); 1476 test_cipher("ecb(xtea)", DECRYPT, xtea_dec_tv_template, 1477 XTEA_DEC_TEST_VECTORS); 1478 break; 1479 1480 case 21: 1481 test_cipher("ecb(khazad)", ENCRYPT, khazad_enc_tv_template, 1482 KHAZAD_ENC_TEST_VECTORS); 1483 test_cipher("ecb(khazad)", DECRYPT, khazad_dec_tv_template, 1484 KHAZAD_DEC_TEST_VECTORS); 1485 break; 1486 1487 case 22: 1488 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS); 1489 break; 1490 1491 case 23: 1492 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS); 1493 break; 1494 1495 case 24: 1496 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS); 1497 break; 1498 1499 case 25: 1500 test_cipher("ecb(tnepres)", ENCRYPT, tnepres_enc_tv_template, 1501 TNEPRES_ENC_TEST_VECTORS); 1502 test_cipher("ecb(tnepres)", DECRYPT, tnepres_dec_tv_template, 1503 TNEPRES_DEC_TEST_VECTORS); 1504 break; 1505 1506 case 26: 1507 test_cipher("ecb(anubis)", ENCRYPT, anubis_enc_tv_template, 1508 ANUBIS_ENC_TEST_VECTORS); 1509 test_cipher("ecb(anubis)", DECRYPT, anubis_dec_tv_template, 1510 ANUBIS_DEC_TEST_VECTORS); 1511 test_cipher("cbc(anubis)", ENCRYPT, anubis_cbc_enc_tv_template, 1512 ANUBIS_CBC_ENC_TEST_VECTORS); 1513 test_cipher("cbc(anubis)", DECRYPT, anubis_cbc_dec_tv_template, 1514 ANUBIS_CBC_ENC_TEST_VECTORS); 1515 break; 1516 1517 case 27: 1518 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS); 1519 break; 1520 1521 case 28: 1522 1523 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS); 1524 break; 1525 1526 case 29: 1527 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS); 1528 break; 1529 1530 case 30: 1531 test_cipher("ecb(xeta)", ENCRYPT, xeta_enc_tv_template, 1532 XETA_ENC_TEST_VECTORS); 1533 test_cipher("ecb(xeta)", DECRYPT, xeta_dec_tv_template, 1534 XETA_DEC_TEST_VECTORS); 1535 break; 1536 1537 case 31: 1538 test_cipher("pcbc(fcrypt)", ENCRYPT, fcrypt_pcbc_enc_tv_template, 1539 FCRYPT_ENC_TEST_VECTORS); 1540 test_cipher("pcbc(fcrypt)", DECRYPT, fcrypt_pcbc_dec_tv_template, 1541 FCRYPT_DEC_TEST_VECTORS); 1542 break; 1543 1544 case 32: 1545 test_cipher("ecb(camellia)", ENCRYPT, 1546 camellia_enc_tv_template, 1547 CAMELLIA_ENC_TEST_VECTORS); 1548 test_cipher("ecb(camellia)", DECRYPT, 1549 camellia_dec_tv_template, 1550 CAMELLIA_DEC_TEST_VECTORS); 1551 test_cipher("cbc(camellia)", ENCRYPT, 1552 camellia_cbc_enc_tv_template, 1553 CAMELLIA_CBC_ENC_TEST_VECTORS); 1554 test_cipher("cbc(camellia)", DECRYPT, 1555 camellia_cbc_dec_tv_template, 1556 CAMELLIA_CBC_DEC_TEST_VECTORS); 1557 break; 1558 case 33: 1559 test_hash("sha224", sha224_tv_template, SHA224_TEST_VECTORS); 1560 break; 1561 1562 case 34: 1563 test_cipher("salsa20", ENCRYPT, 1564 salsa20_stream_enc_tv_template, 1565 SALSA20_STREAM_ENC_TEST_VECTORS); 1566 break; 1567 1568 case 35: 1569 test_aead("gcm(aes)", ENCRYPT, aes_gcm_enc_tv_template, 1570 AES_GCM_ENC_TEST_VECTORS); 1571 test_aead("gcm(aes)", DECRYPT, aes_gcm_dec_tv_template, 1572 AES_GCM_DEC_TEST_VECTORS); 1573 break; 1574 1575 case 36: 1576 test_comp("lzo", lzo_comp_tv_template, lzo_decomp_tv_template, 1577 LZO_COMP_TEST_VECTORS, LZO_DECOMP_TEST_VECTORS); 1578 break; 1579 1580 case 37: 1581 test_aead("ccm(aes)", ENCRYPT, aes_ccm_enc_tv_template, 1582 AES_CCM_ENC_TEST_VECTORS); 1583 test_aead("ccm(aes)", DECRYPT, aes_ccm_dec_tv_template, 1584 AES_CCM_DEC_TEST_VECTORS); 1585 break; 1586 1587 case 100: 1588 test_hash("hmac(md5)", hmac_md5_tv_template, 1589 HMAC_MD5_TEST_VECTORS); 1590 break; 1591 1592 case 101: 1593 test_hash("hmac(sha1)", hmac_sha1_tv_template, 1594 HMAC_SHA1_TEST_VECTORS); 1595 break; 1596 1597 case 102: 1598 test_hash("hmac(sha256)", hmac_sha256_tv_template, 1599 HMAC_SHA256_TEST_VECTORS); 1600 break; 1601 1602 case 103: 1603 test_hash("hmac(sha384)", hmac_sha384_tv_template, 1604 HMAC_SHA384_TEST_VECTORS); 1605 break; 1606 1607 case 104: 1608 test_hash("hmac(sha512)", hmac_sha512_tv_template, 1609 HMAC_SHA512_TEST_VECTORS); 1610 break; 1611 1612 case 105: 1613 test_hash("hmac(sha224)", hmac_sha224_tv_template, 1614 HMAC_SHA224_TEST_VECTORS); 1615 break; 1616 1617 case 106: 1618 test_hash("xcbc(aes)", aes_xcbc128_tv_template, 1619 XCBC_AES_TEST_VECTORS); 1620 break; 1621 1622 case 200: 1623 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0, 1624 aes_speed_template); 1625 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0, 1626 aes_speed_template); 1627 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0, 1628 aes_speed_template); 1629 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0, 1630 aes_speed_template); 1631 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0, 1632 aes_lrw_speed_template); 1633 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0, 1634 aes_lrw_speed_template); 1635 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0, 1636 aes_xts_speed_template); 1637 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0, 1638 aes_xts_speed_template); 1639 break; 1640 1641 case 201: 1642 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec, 1643 des3_ede_enc_tv_template, 1644 DES3_EDE_ENC_TEST_VECTORS, 1645 des3_ede_speed_template); 1646 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec, 1647 des3_ede_dec_tv_template, 1648 DES3_EDE_DEC_TEST_VECTORS, 1649 des3_ede_speed_template); 1650 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec, 1651 des3_ede_enc_tv_template, 1652 DES3_EDE_ENC_TEST_VECTORS, 1653 des3_ede_speed_template); 1654 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec, 1655 des3_ede_dec_tv_template, 1656 DES3_EDE_DEC_TEST_VECTORS, 1657 des3_ede_speed_template); 1658 break; 1659 1660 case 202: 1661 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0, 1662 twofish_speed_template); 1663 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0, 1664 twofish_speed_template); 1665 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0, 1666 twofish_speed_template); 1667 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0, 1668 twofish_speed_template); 1669 break; 1670 1671 case 203: 1672 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0, 1673 blowfish_speed_template); 1674 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0, 1675 blowfish_speed_template); 1676 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0, 1677 blowfish_speed_template); 1678 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0, 1679 blowfish_speed_template); 1680 break; 1681 1682 case 204: 1683 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0, 1684 des_speed_template); 1685 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0, 1686 des_speed_template); 1687 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0, 1688 des_speed_template); 1689 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0, 1690 des_speed_template); 1691 break; 1692 1693 case 205: 1694 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0, 1695 camellia_speed_template); 1696 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0, 1697 camellia_speed_template); 1698 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0, 1699 camellia_speed_template); 1700 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0, 1701 camellia_speed_template); 1702 break; 1703 1704 case 206: 1705 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0, 1706 salsa20_speed_template); 1707 break; 1708 1709 case 300: 1710 /* fall through */ 1711 1712 case 301: 1713 test_hash_speed("md4", sec, generic_hash_speed_template); 1714 if (mode > 300 && mode < 400) break; 1715 1716 case 302: 1717 test_hash_speed("md5", sec, generic_hash_speed_template); 1718 if (mode > 300 && mode < 400) break; 1719 1720 case 303: 1721 test_hash_speed("sha1", sec, generic_hash_speed_template); 1722 if (mode > 300 && mode < 400) break; 1723 1724 case 304: 1725 test_hash_speed("sha256", sec, generic_hash_speed_template); 1726 if (mode > 300 && mode < 400) break; 1727 1728 case 305: 1729 test_hash_speed("sha384", sec, generic_hash_speed_template); 1730 if (mode > 300 && mode < 400) break; 1731 1732 case 306: 1733 test_hash_speed("sha512", sec, generic_hash_speed_template); 1734 if (mode > 300 && mode < 400) break; 1735 1736 case 307: 1737 test_hash_speed("wp256", sec, generic_hash_speed_template); 1738 if (mode > 300 && mode < 400) break; 1739 1740 case 308: 1741 test_hash_speed("wp384", sec, generic_hash_speed_template); 1742 if (mode > 300 && mode < 400) break; 1743 1744 case 309: 1745 test_hash_speed("wp512", sec, generic_hash_speed_template); 1746 if (mode > 300 && mode < 400) break; 1747 1748 case 310: 1749 test_hash_speed("tgr128", sec, generic_hash_speed_template); 1750 if (mode > 300 && mode < 400) break; 1751 1752 case 311: 1753 test_hash_speed("tgr160", sec, generic_hash_speed_template); 1754 if (mode > 300 && mode < 400) break; 1755 1756 case 312: 1757 test_hash_speed("tgr192", sec, generic_hash_speed_template); 1758 if (mode > 300 && mode < 400) break; 1759 1760 case 313: 1761 test_hash_speed("sha224", sec, generic_hash_speed_template); 1762 if (mode > 300 && mode < 400) break; 1763 1764 case 399: 1765 break; 1766 1767 case 1000: 1768 test_available(); 1769 break; 1770 1771 default: 1772 /* useful for debugging */ 1773 printk("not testing anything\n"); 1774 break; 1775 } 1776 } 1777 1778 static int __init init(void) 1779 { 1780 int err = -ENOMEM; 1781 1782 tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL); 1783 if (tvmem == NULL) 1784 return err; 1785 1786 xbuf = kmalloc(XBUFSIZE, GFP_KERNEL); 1787 if (xbuf == NULL) 1788 goto err_free_tv; 1789 1790 axbuf = kmalloc(XBUFSIZE, GFP_KERNEL); 1791 if (axbuf == NULL) 1792 goto err_free_xbuf; 1793 1794 do_test(); 1795 1796 /* We intentionaly return -EAGAIN to prevent keeping 1797 * the module. It does all its work from init() 1798 * and doesn't offer any runtime functionality 1799 * => we don't need it in the memory, do we? 1800 * -- mludvig 1801 */ 1802 err = -EAGAIN; 1803 1804 kfree(axbuf); 1805 err_free_xbuf: 1806 kfree(xbuf); 1807 err_free_tv: 1808 kfree(tvmem); 1809 1810 return err; 1811 } 1812 1813 /* 1814 * If an init function is provided, an exit function must also be provided 1815 * to allow module unload. 1816 */ 1817 static void __exit fini(void) { } 1818 1819 module_init(init); 1820 module_exit(fini); 1821 1822 module_param(mode, int, 0); 1823 module_param(sec, uint, 0); 1824 MODULE_PARM_DESC(sec, "Length in seconds of speed tests " 1825 "(defaults to zero which uses CPU cycles instead)"); 1826 1827 MODULE_LICENSE("GPL"); 1828 MODULE_DESCRIPTION("Quick & dirty crypto testing module"); 1829 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>"); 1830