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 * 2004-08-09 Added cipher speed tests (Reyk Floeter <reyk@vantronix.net>) 16 * 2003-09-14 Rewritten by Kartikey Mahendra Bhatt 17 * 18 */ 19 20 #include <linux/init.h> 21 #include <linux/module.h> 22 #include <linux/mm.h> 23 #include <linux/slab.h> 24 #include <linux/scatterlist.h> 25 #include <linux/string.h> 26 #include <linux/crypto.h> 27 #include <linux/highmem.h> 28 #include <linux/moduleparam.h> 29 #include <linux/jiffies.h> 30 #include <linux/timex.h> 31 #include <linux/interrupt.h> 32 #include "tcrypt.h" 33 34 /* 35 * Need to kmalloc() memory for testing kmap(). 36 */ 37 #define TVMEMSIZE 16384 38 #define XBUFSIZE 32768 39 40 /* 41 * Indexes into the xbuf to simulate cross-page access. 42 */ 43 #define IDX1 37 44 #define IDX2 32400 45 #define IDX3 1 46 #define IDX4 8193 47 #define IDX5 22222 48 #define IDX6 17101 49 #define IDX7 27333 50 #define IDX8 3000 51 52 /* 53 * Used by test_cipher() 54 */ 55 #define ENCRYPT 1 56 #define DECRYPT 0 57 #define MODE_ECB 1 58 #define MODE_CBC 0 59 60 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 }; 61 62 /* 63 * Used by test_cipher_speed() 64 */ 65 static unsigned int sec; 66 67 static int mode; 68 static char *xbuf; 69 static char *tvmem; 70 71 static char *check[] = { 72 "des", "md5", "des3_ede", "rot13", "sha1", "sha256", "blowfish", 73 "twofish", "serpent", "sha384", "sha512", "md4", "aes", "cast6", 74 "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea", 75 "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", NULL 76 }; 77 78 static void hexdump(unsigned char *buf, unsigned int len) 79 { 80 while (len--) 81 printk("%02x", *buf++); 82 83 printk("\n"); 84 } 85 86 static void test_hash(char *algo, struct hash_testvec *template, 87 unsigned int tcount) 88 { 89 unsigned int i, j, k, temp; 90 struct scatterlist sg[8]; 91 char result[64]; 92 struct crypto_tfm *tfm; 93 struct hash_testvec *hash_tv; 94 unsigned int tsize; 95 96 printk("\ntesting %s\n", algo); 97 98 tsize = sizeof(struct hash_testvec); 99 tsize *= tcount; 100 101 if (tsize > TVMEMSIZE) { 102 printk("template (%u) too big for tvmem (%u)\n", tsize, TVMEMSIZE); 103 return; 104 } 105 106 memcpy(tvmem, template, tsize); 107 hash_tv = (void *)tvmem; 108 tfm = crypto_alloc_tfm(algo, 0); 109 if (tfm == NULL) { 110 printk("failed to load transform for %s\n", algo); 111 return; 112 } 113 114 for (i = 0; i < tcount; i++) { 115 printk("test %u:\n", i + 1); 116 memset(result, 0, 64); 117 118 sg_set_buf(&sg[0], hash_tv[i].plaintext, hash_tv[i].psize); 119 120 crypto_digest_init(tfm); 121 if (tfm->crt_u.digest.dit_setkey) { 122 crypto_digest_setkey(tfm, hash_tv[i].key, 123 hash_tv[i].ksize); 124 } 125 crypto_digest_update(tfm, sg, 1); 126 crypto_digest_final(tfm, result); 127 128 hexdump(result, crypto_tfm_alg_digestsize(tfm)); 129 printk("%s\n", 130 memcmp(result, hash_tv[i].digest, 131 crypto_tfm_alg_digestsize(tfm)) ? 132 "fail" : "pass"); 133 } 134 135 printk("testing %s across pages\n", algo); 136 137 /* setup the dummy buffer first */ 138 memset(xbuf, 0, XBUFSIZE); 139 140 j = 0; 141 for (i = 0; i < tcount; i++) { 142 if (hash_tv[i].np) { 143 j++; 144 printk("test %u:\n", j); 145 memset(result, 0, 64); 146 147 temp = 0; 148 for (k = 0; k < hash_tv[i].np; k++) { 149 memcpy(&xbuf[IDX[k]], 150 hash_tv[i].plaintext + temp, 151 hash_tv[i].tap[k]); 152 temp += hash_tv[i].tap[k]; 153 sg_set_buf(&sg[k], &xbuf[IDX[k]], 154 hash_tv[i].tap[k]); 155 } 156 157 crypto_digest_digest(tfm, sg, hash_tv[i].np, result); 158 159 hexdump(result, crypto_tfm_alg_digestsize(tfm)); 160 printk("%s\n", 161 memcmp(result, hash_tv[i].digest, 162 crypto_tfm_alg_digestsize(tfm)) ? 163 "fail" : "pass"); 164 } 165 } 166 167 crypto_free_tfm(tfm); 168 } 169 170 171 #ifdef CONFIG_CRYPTO_HMAC 172 173 static void test_hmac(char *algo, struct hmac_testvec *template, 174 unsigned int tcount) 175 { 176 unsigned int i, j, k, temp; 177 struct scatterlist sg[8]; 178 char result[64]; 179 struct crypto_tfm *tfm; 180 struct hmac_testvec *hmac_tv; 181 unsigned int tsize, klen; 182 183 tfm = crypto_alloc_tfm(algo, 0); 184 if (tfm == NULL) { 185 printk("failed to load transform for %s\n", algo); 186 return; 187 } 188 189 printk("\ntesting hmac_%s\n", algo); 190 191 tsize = sizeof(struct hmac_testvec); 192 tsize *= tcount; 193 if (tsize > TVMEMSIZE) { 194 printk("template (%u) too big for tvmem (%u)\n", tsize, 195 TVMEMSIZE); 196 goto out; 197 } 198 199 memcpy(tvmem, template, tsize); 200 hmac_tv = (void *)tvmem; 201 202 for (i = 0; i < tcount; i++) { 203 printk("test %u:\n", i + 1); 204 memset(result, 0, sizeof (result)); 205 206 klen = hmac_tv[i].ksize; 207 sg_set_buf(&sg[0], hmac_tv[i].plaintext, hmac_tv[i].psize); 208 209 crypto_hmac(tfm, hmac_tv[i].key, &klen, sg, 1, result); 210 211 hexdump(result, crypto_tfm_alg_digestsize(tfm)); 212 printk("%s\n", 213 memcmp(result, hmac_tv[i].digest, 214 crypto_tfm_alg_digestsize(tfm)) ? "fail" : 215 "pass"); 216 } 217 218 printk("\ntesting hmac_%s across pages\n", algo); 219 220 memset(xbuf, 0, XBUFSIZE); 221 222 j = 0; 223 for (i = 0; i < tcount; i++) { 224 if (hmac_tv[i].np) { 225 j++; 226 printk("test %u:\n",j); 227 memset(result, 0, 64); 228 229 temp = 0; 230 klen = hmac_tv[i].ksize; 231 for (k = 0; k < hmac_tv[i].np; k++) { 232 memcpy(&xbuf[IDX[k]], 233 hmac_tv[i].plaintext + temp, 234 hmac_tv[i].tap[k]); 235 temp += hmac_tv[i].tap[k]; 236 sg_set_buf(&sg[k], &xbuf[IDX[k]], 237 hmac_tv[i].tap[k]); 238 } 239 240 crypto_hmac(tfm, hmac_tv[i].key, &klen, sg, 241 hmac_tv[i].np, result); 242 hexdump(result, crypto_tfm_alg_digestsize(tfm)); 243 244 printk("%s\n", 245 memcmp(result, hmac_tv[i].digest, 246 crypto_tfm_alg_digestsize(tfm)) ? 247 "fail" : "pass"); 248 } 249 } 250 out: 251 crypto_free_tfm(tfm); 252 } 253 254 #endif /* CONFIG_CRYPTO_HMAC */ 255 256 static void test_cipher(char *algo, int mode, int enc, 257 struct cipher_testvec *template, unsigned int tcount) 258 { 259 unsigned int ret, i, j, k, temp; 260 unsigned int tsize; 261 char *q; 262 struct crypto_tfm *tfm; 263 char *key; 264 struct cipher_testvec *cipher_tv; 265 struct scatterlist sg[8]; 266 const char *e, *m; 267 268 if (enc == ENCRYPT) 269 e = "encryption"; 270 else 271 e = "decryption"; 272 if (mode == MODE_ECB) 273 m = "ECB"; 274 else 275 m = "CBC"; 276 277 printk("\ntesting %s %s %s\n", algo, m, e); 278 279 tsize = sizeof (struct cipher_testvec); 280 tsize *= tcount; 281 282 if (tsize > TVMEMSIZE) { 283 printk("template (%u) too big for tvmem (%u)\n", tsize, 284 TVMEMSIZE); 285 return; 286 } 287 288 memcpy(tvmem, template, tsize); 289 cipher_tv = (void *)tvmem; 290 291 if (mode) 292 tfm = crypto_alloc_tfm(algo, 0); 293 else 294 tfm = crypto_alloc_tfm(algo, CRYPTO_TFM_MODE_CBC); 295 296 if (tfm == NULL) { 297 printk("failed to load transform for %s %s\n", algo, m); 298 return; 299 } 300 301 j = 0; 302 for (i = 0; i < tcount; i++) { 303 if (!(cipher_tv[i].np)) { 304 j++; 305 printk("test %u (%d bit key):\n", 306 j, cipher_tv[i].klen * 8); 307 308 tfm->crt_flags = 0; 309 if (cipher_tv[i].wk) 310 tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY; 311 key = cipher_tv[i].key; 312 313 ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen); 314 if (ret) { 315 printk("setkey() failed flags=%x\n", tfm->crt_flags); 316 317 if (!cipher_tv[i].fail) 318 goto out; 319 } 320 321 sg_set_buf(&sg[0], cipher_tv[i].input, 322 cipher_tv[i].ilen); 323 324 if (!mode) { 325 crypto_cipher_set_iv(tfm, cipher_tv[i].iv, 326 crypto_tfm_alg_ivsize(tfm)); 327 } 328 329 if (enc) 330 ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen); 331 else 332 ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen); 333 334 335 if (ret) { 336 printk("%s () failed flags=%x\n", e, tfm->crt_flags); 337 goto out; 338 } 339 340 q = kmap(sg[0].page) + sg[0].offset; 341 hexdump(q, cipher_tv[i].rlen); 342 343 printk("%s\n", 344 memcmp(q, cipher_tv[i].result, 345 cipher_tv[i].rlen) ? "fail" : "pass"); 346 } 347 } 348 349 printk("\ntesting %s %s %s across pages (chunking)\n", algo, m, e); 350 memset(xbuf, 0, XBUFSIZE); 351 352 j = 0; 353 for (i = 0; i < tcount; i++) { 354 if (cipher_tv[i].np) { 355 j++; 356 printk("test %u (%d bit key):\n", 357 j, cipher_tv[i].klen * 8); 358 359 tfm->crt_flags = 0; 360 if (cipher_tv[i].wk) 361 tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY; 362 key = cipher_tv[i].key; 363 364 ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen); 365 if (ret) { 366 printk("setkey() failed flags=%x\n", tfm->crt_flags); 367 368 if (!cipher_tv[i].fail) 369 goto out; 370 } 371 372 temp = 0; 373 for (k = 0; k < cipher_tv[i].np; k++) { 374 memcpy(&xbuf[IDX[k]], 375 cipher_tv[i].input + temp, 376 cipher_tv[i].tap[k]); 377 temp += cipher_tv[i].tap[k]; 378 sg_set_buf(&sg[k], &xbuf[IDX[k]], 379 cipher_tv[i].tap[k]); 380 } 381 382 if (!mode) { 383 crypto_cipher_set_iv(tfm, cipher_tv[i].iv, 384 crypto_tfm_alg_ivsize(tfm)); 385 } 386 387 if (enc) 388 ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen); 389 else 390 ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen); 391 392 if (ret) { 393 printk("%s () failed flags=%x\n", e, tfm->crt_flags); 394 goto out; 395 } 396 397 temp = 0; 398 for (k = 0; k < cipher_tv[i].np; k++) { 399 printk("page %u\n", k); 400 q = kmap(sg[k].page) + sg[k].offset; 401 hexdump(q, cipher_tv[i].tap[k]); 402 printk("%s\n", 403 memcmp(q, cipher_tv[i].result + temp, 404 cipher_tv[i].tap[k]) ? "fail" : 405 "pass"); 406 temp += cipher_tv[i].tap[k]; 407 } 408 } 409 } 410 411 out: 412 crypto_free_tfm(tfm); 413 } 414 415 static int test_cipher_jiffies(struct crypto_tfm *tfm, int enc, char *p, 416 int blen, int sec) 417 { 418 struct scatterlist sg[1]; 419 unsigned long start, end; 420 int bcount; 421 int ret; 422 423 sg_set_buf(sg, p, blen); 424 425 for (start = jiffies, end = start + sec * HZ, bcount = 0; 426 time_before(jiffies, end); bcount++) { 427 if (enc) 428 ret = crypto_cipher_encrypt(tfm, sg, sg, blen); 429 else 430 ret = crypto_cipher_decrypt(tfm, sg, sg, blen); 431 432 if (ret) 433 return ret; 434 } 435 436 printk("%d operations in %d seconds (%ld bytes)\n", 437 bcount, sec, (long)bcount * blen); 438 return 0; 439 } 440 441 static int test_cipher_cycles(struct crypto_tfm *tfm, int enc, char *p, 442 int blen) 443 { 444 struct scatterlist sg[1]; 445 unsigned long cycles = 0; 446 int ret = 0; 447 int i; 448 449 sg_set_buf(sg, p, blen); 450 451 local_bh_disable(); 452 local_irq_disable(); 453 454 /* Warm-up run. */ 455 for (i = 0; i < 4; i++) { 456 if (enc) 457 ret = crypto_cipher_encrypt(tfm, sg, sg, blen); 458 else 459 ret = crypto_cipher_decrypt(tfm, sg, sg, blen); 460 461 if (ret) 462 goto out; 463 } 464 465 /* The real thing. */ 466 for (i = 0; i < 8; i++) { 467 cycles_t start, end; 468 469 start = get_cycles(); 470 if (enc) 471 ret = crypto_cipher_encrypt(tfm, sg, sg, blen); 472 else 473 ret = crypto_cipher_decrypt(tfm, sg, sg, blen); 474 end = get_cycles(); 475 476 if (ret) 477 goto out; 478 479 cycles += end - start; 480 } 481 482 out: 483 local_irq_enable(); 484 local_bh_enable(); 485 486 if (ret == 0) 487 printk("1 operation in %lu cycles (%d bytes)\n", 488 (cycles + 4) / 8, blen); 489 490 return ret; 491 } 492 493 static void test_cipher_speed(char *algo, int mode, int enc, unsigned int sec, 494 struct cipher_testvec *template, 495 unsigned int tcount, struct cipher_speed *speed) 496 { 497 unsigned int ret, i, j, iv_len; 498 unsigned char *key, *p, iv[128]; 499 struct crypto_tfm *tfm; 500 const char *e, *m; 501 502 if (enc == ENCRYPT) 503 e = "encryption"; 504 else 505 e = "decryption"; 506 if (mode == MODE_ECB) 507 m = "ECB"; 508 else 509 m = "CBC"; 510 511 printk("\ntesting speed of %s %s %s\n", algo, m, e); 512 513 if (mode) 514 tfm = crypto_alloc_tfm(algo, 0); 515 else 516 tfm = crypto_alloc_tfm(algo, CRYPTO_TFM_MODE_CBC); 517 518 if (tfm == NULL) { 519 printk("failed to load transform for %s %s\n", algo, m); 520 return; 521 } 522 523 for (i = 0; speed[i].klen != 0; i++) { 524 if ((speed[i].blen + speed[i].klen) > TVMEMSIZE) { 525 printk("template (%u) too big for tvmem (%u)\n", 526 speed[i].blen + speed[i].klen, TVMEMSIZE); 527 goto out; 528 } 529 530 printk("test %u (%d bit key, %d byte blocks): ", i, 531 speed[i].klen * 8, speed[i].blen); 532 533 memset(tvmem, 0xff, speed[i].klen + speed[i].blen); 534 535 /* set key, plain text and IV */ 536 key = (unsigned char *)tvmem; 537 for (j = 0; j < tcount; j++) { 538 if (template[j].klen == speed[i].klen) { 539 key = template[j].key; 540 break; 541 } 542 } 543 p = (unsigned char *)tvmem + speed[i].klen; 544 545 ret = crypto_cipher_setkey(tfm, key, speed[i].klen); 546 if (ret) { 547 printk("setkey() failed flags=%x\n", tfm->crt_flags); 548 goto out; 549 } 550 551 if (!mode) { 552 iv_len = crypto_tfm_alg_ivsize(tfm); 553 memset(&iv, 0xff, iv_len); 554 crypto_cipher_set_iv(tfm, iv, iv_len); 555 } 556 557 if (sec) 558 ret = test_cipher_jiffies(tfm, enc, p, speed[i].blen, 559 sec); 560 else 561 ret = test_cipher_cycles(tfm, enc, p, speed[i].blen); 562 563 if (ret) { 564 printk("%s() failed flags=%x\n", e, tfm->crt_flags); 565 break; 566 } 567 } 568 569 out: 570 crypto_free_tfm(tfm); 571 } 572 573 static void test_deflate(void) 574 { 575 unsigned int i; 576 char result[COMP_BUF_SIZE]; 577 struct crypto_tfm *tfm; 578 struct comp_testvec *tv; 579 unsigned int tsize; 580 581 printk("\ntesting deflate compression\n"); 582 583 tsize = sizeof (deflate_comp_tv_template); 584 if (tsize > TVMEMSIZE) { 585 printk("template (%u) too big for tvmem (%u)\n", tsize, 586 TVMEMSIZE); 587 return; 588 } 589 590 memcpy(tvmem, deflate_comp_tv_template, tsize); 591 tv = (void *)tvmem; 592 593 tfm = crypto_alloc_tfm("deflate", 0); 594 if (tfm == NULL) { 595 printk("failed to load transform for deflate\n"); 596 return; 597 } 598 599 for (i = 0; i < DEFLATE_COMP_TEST_VECTORS; i++) { 600 int ilen, ret, dlen = COMP_BUF_SIZE; 601 602 printk("test %u:\n", i + 1); 603 memset(result, 0, sizeof (result)); 604 605 ilen = tv[i].inlen; 606 ret = crypto_comp_compress(tfm, tv[i].input, 607 ilen, result, &dlen); 608 if (ret) { 609 printk("fail: ret=%d\n", ret); 610 continue; 611 } 612 hexdump(result, dlen); 613 printk("%s (ratio %d:%d)\n", 614 memcmp(result, tv[i].output, dlen) ? "fail" : "pass", 615 ilen, dlen); 616 } 617 618 printk("\ntesting deflate decompression\n"); 619 620 tsize = sizeof (deflate_decomp_tv_template); 621 if (tsize > TVMEMSIZE) { 622 printk("template (%u) too big for tvmem (%u)\n", tsize, 623 TVMEMSIZE); 624 goto out; 625 } 626 627 memcpy(tvmem, deflate_decomp_tv_template, tsize); 628 tv = (void *)tvmem; 629 630 for (i = 0; i < DEFLATE_DECOMP_TEST_VECTORS; i++) { 631 int ilen, ret, dlen = COMP_BUF_SIZE; 632 633 printk("test %u:\n", i + 1); 634 memset(result, 0, sizeof (result)); 635 636 ilen = tv[i].inlen; 637 ret = crypto_comp_decompress(tfm, tv[i].input, 638 ilen, result, &dlen); 639 if (ret) { 640 printk("fail: ret=%d\n", ret); 641 continue; 642 } 643 hexdump(result, dlen); 644 printk("%s (ratio %d:%d)\n", 645 memcmp(result, tv[i].output, dlen) ? "fail" : "pass", 646 ilen, dlen); 647 } 648 out: 649 crypto_free_tfm(tfm); 650 } 651 652 static void test_crc32c(void) 653 { 654 #define NUMVEC 6 655 #define VECSIZE 40 656 657 int i, j, pass; 658 u32 crc; 659 u8 b, test_vec[NUMVEC][VECSIZE]; 660 static u32 vec_results[NUMVEC] = { 661 0x0e2c157f, 0xe980ebf6, 0xde74bded, 662 0xd579c862, 0xba979ad0, 0x2b29d913 663 }; 664 static u32 tot_vec_results = 0x24c5d375; 665 666 struct scatterlist sg[NUMVEC]; 667 struct crypto_tfm *tfm; 668 char *fmtdata = "testing crc32c initialized to %08x: %s\n"; 669 #define SEEDTESTVAL 0xedcba987 670 u32 seed; 671 672 printk("\ntesting crc32c\n"); 673 674 tfm = crypto_alloc_tfm("crc32c", 0); 675 if (tfm == NULL) { 676 printk("failed to load transform for crc32c\n"); 677 return; 678 } 679 680 crypto_digest_init(tfm); 681 crypto_digest_final(tfm, (u8*)&crc); 682 printk(fmtdata, crc, (crc == 0) ? "pass" : "ERROR"); 683 684 /* 685 * stuff test_vec with known values, simple incrementing 686 * byte values. 687 */ 688 b = 0; 689 for (i = 0; i < NUMVEC; i++) { 690 for (j = 0; j < VECSIZE; j++) 691 test_vec[i][j] = ++b; 692 sg_set_buf(&sg[i], test_vec[i], VECSIZE); 693 } 694 695 seed = SEEDTESTVAL; 696 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32)); 697 crypto_digest_final(tfm, (u8*)&crc); 698 printk("testing crc32c setkey returns %08x : %s\n", crc, (crc == (SEEDTESTVAL ^ ~(u32)0)) ? 699 "pass" : "ERROR"); 700 701 printk("testing crc32c using update/final:\n"); 702 703 pass = 1; /* assume all is well */ 704 705 for (i = 0; i < NUMVEC; i++) { 706 seed = ~(u32)0; 707 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32)); 708 crypto_digest_update(tfm, &sg[i], 1); 709 crypto_digest_final(tfm, (u8*)&crc); 710 if (crc == vec_results[i]) { 711 printk(" %08x:OK", crc); 712 } else { 713 printk(" %08x:BAD, wanted %08x\n", crc, vec_results[i]); 714 pass = 0; 715 } 716 } 717 718 printk("\ntesting crc32c using incremental accumulator:\n"); 719 crc = 0; 720 for (i = 0; i < NUMVEC; i++) { 721 seed = (crc ^ ~(u32)0); 722 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32)); 723 crypto_digest_update(tfm, &sg[i], 1); 724 crypto_digest_final(tfm, (u8*)&crc); 725 } 726 if (crc == tot_vec_results) { 727 printk(" %08x:OK", crc); 728 } else { 729 printk(" %08x:BAD, wanted %08x\n", crc, tot_vec_results); 730 pass = 0; 731 } 732 733 printk("\ntesting crc32c using digest:\n"); 734 seed = ~(u32)0; 735 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32)); 736 crypto_digest_digest(tfm, sg, NUMVEC, (u8*)&crc); 737 if (crc == tot_vec_results) { 738 printk(" %08x:OK", crc); 739 } else { 740 printk(" %08x:BAD, wanted %08x\n", crc, tot_vec_results); 741 pass = 0; 742 } 743 744 printk("\n%s\n", pass ? "pass" : "ERROR"); 745 746 crypto_free_tfm(tfm); 747 printk("crc32c test complete\n"); 748 } 749 750 static void test_available(void) 751 { 752 char **name = check; 753 754 while (*name) { 755 printk("alg %s ", *name); 756 printk((crypto_alg_available(*name, 0)) ? 757 "found\n" : "not found\n"); 758 name++; 759 } 760 } 761 762 static void do_test(void) 763 { 764 switch (mode) { 765 766 case 0: 767 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS); 768 769 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS); 770 771 //DES 772 test_cipher ("des", MODE_ECB, ENCRYPT, des_enc_tv_template, DES_ENC_TEST_VECTORS); 773 test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS); 774 test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS); 775 test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS); 776 777 //DES3_EDE 778 test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS); 779 test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS); 780 781 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS); 782 783 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS); 784 785 //BLOWFISH 786 test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS); 787 test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS); 788 test_cipher ("blowfish", MODE_CBC, ENCRYPT, bf_cbc_enc_tv_template, BF_CBC_ENC_TEST_VECTORS); 789 test_cipher ("blowfish", MODE_CBC, DECRYPT, bf_cbc_dec_tv_template, BF_CBC_DEC_TEST_VECTORS); 790 791 //TWOFISH 792 test_cipher ("twofish", MODE_ECB, ENCRYPT, tf_enc_tv_template, TF_ENC_TEST_VECTORS); 793 test_cipher ("twofish", MODE_ECB, DECRYPT, tf_dec_tv_template, TF_DEC_TEST_VECTORS); 794 test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS); 795 test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS); 796 797 //SERPENT 798 test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS); 799 test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS); 800 801 //TNEPRES 802 test_cipher ("tnepres", MODE_ECB, ENCRYPT, tnepres_enc_tv_template, TNEPRES_ENC_TEST_VECTORS); 803 test_cipher ("tnepres", MODE_ECB, DECRYPT, tnepres_dec_tv_template, TNEPRES_DEC_TEST_VECTORS); 804 805 //AES 806 test_cipher ("aes", MODE_ECB, ENCRYPT, aes_enc_tv_template, AES_ENC_TEST_VECTORS); 807 test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS); 808 809 //CAST5 810 test_cipher ("cast5", MODE_ECB, ENCRYPT, cast5_enc_tv_template, CAST5_ENC_TEST_VECTORS); 811 test_cipher ("cast5", MODE_ECB, DECRYPT, cast5_dec_tv_template, CAST5_DEC_TEST_VECTORS); 812 813 //CAST6 814 test_cipher ("cast6", MODE_ECB, ENCRYPT, cast6_enc_tv_template, CAST6_ENC_TEST_VECTORS); 815 test_cipher ("cast6", MODE_ECB, DECRYPT, cast6_dec_tv_template, CAST6_DEC_TEST_VECTORS); 816 817 //ARC4 818 test_cipher ("arc4", MODE_ECB, ENCRYPT, arc4_enc_tv_template, ARC4_ENC_TEST_VECTORS); 819 test_cipher ("arc4", MODE_ECB, DECRYPT, arc4_dec_tv_template, ARC4_DEC_TEST_VECTORS); 820 821 //TEA 822 test_cipher ("tea", MODE_ECB, ENCRYPT, tea_enc_tv_template, TEA_ENC_TEST_VECTORS); 823 test_cipher ("tea", MODE_ECB, DECRYPT, tea_dec_tv_template, TEA_DEC_TEST_VECTORS); 824 825 826 //XTEA 827 test_cipher ("xtea", MODE_ECB, ENCRYPT, xtea_enc_tv_template, XTEA_ENC_TEST_VECTORS); 828 test_cipher ("xtea", MODE_ECB, DECRYPT, xtea_dec_tv_template, XTEA_DEC_TEST_VECTORS); 829 830 //KHAZAD 831 test_cipher ("khazad", MODE_ECB, ENCRYPT, khazad_enc_tv_template, KHAZAD_ENC_TEST_VECTORS); 832 test_cipher ("khazad", MODE_ECB, DECRYPT, khazad_dec_tv_template, KHAZAD_DEC_TEST_VECTORS); 833 834 //ANUBIS 835 test_cipher ("anubis", MODE_ECB, ENCRYPT, anubis_enc_tv_template, ANUBIS_ENC_TEST_VECTORS); 836 test_cipher ("anubis", MODE_ECB, DECRYPT, anubis_dec_tv_template, ANUBIS_DEC_TEST_VECTORS); 837 test_cipher ("anubis", MODE_CBC, ENCRYPT, anubis_cbc_enc_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS); 838 test_cipher ("anubis", MODE_CBC, DECRYPT, anubis_cbc_dec_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS); 839 840 //XETA 841 test_cipher ("xeta", MODE_ECB, ENCRYPT, xeta_enc_tv_template, XETA_ENC_TEST_VECTORS); 842 test_cipher ("xeta", MODE_ECB, DECRYPT, xeta_dec_tv_template, XETA_DEC_TEST_VECTORS); 843 844 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS); 845 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS); 846 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS); 847 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS); 848 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS); 849 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS); 850 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS); 851 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS); 852 test_deflate(); 853 test_crc32c(); 854 #ifdef CONFIG_CRYPTO_HMAC 855 test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS); 856 test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS); 857 test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS); 858 #endif 859 860 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS); 861 break; 862 863 case 1: 864 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS); 865 break; 866 867 case 2: 868 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS); 869 break; 870 871 case 3: 872 test_cipher ("des", MODE_ECB, ENCRYPT, des_enc_tv_template, DES_ENC_TEST_VECTORS); 873 test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS); 874 test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS); 875 test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS); 876 break; 877 878 case 4: 879 test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS); 880 test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS); 881 break; 882 883 case 5: 884 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS); 885 break; 886 887 case 6: 888 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS); 889 break; 890 891 case 7: 892 test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS); 893 test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS); 894 test_cipher ("blowfish", MODE_CBC, ENCRYPT, bf_cbc_enc_tv_template, BF_CBC_ENC_TEST_VECTORS); 895 test_cipher ("blowfish", MODE_CBC, DECRYPT, bf_cbc_dec_tv_template, BF_CBC_DEC_TEST_VECTORS); 896 break; 897 898 case 8: 899 test_cipher ("twofish", MODE_ECB, ENCRYPT, tf_enc_tv_template, TF_ENC_TEST_VECTORS); 900 test_cipher ("twofish", MODE_ECB, DECRYPT, tf_dec_tv_template, TF_DEC_TEST_VECTORS); 901 test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS); 902 test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS); 903 break; 904 905 case 9: 906 test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS); 907 test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS); 908 break; 909 910 case 10: 911 test_cipher ("aes", MODE_ECB, ENCRYPT, aes_enc_tv_template, AES_ENC_TEST_VECTORS); 912 test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS); 913 break; 914 915 case 11: 916 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS); 917 break; 918 919 case 12: 920 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS); 921 break; 922 923 case 13: 924 test_deflate(); 925 break; 926 927 case 14: 928 test_cipher ("cast5", MODE_ECB, ENCRYPT, cast5_enc_tv_template, CAST5_ENC_TEST_VECTORS); 929 test_cipher ("cast5", MODE_ECB, DECRYPT, cast5_dec_tv_template, CAST5_DEC_TEST_VECTORS); 930 break; 931 932 case 15: 933 test_cipher ("cast6", MODE_ECB, ENCRYPT, cast6_enc_tv_template, CAST6_ENC_TEST_VECTORS); 934 test_cipher ("cast6", MODE_ECB, DECRYPT, cast6_dec_tv_template, CAST6_DEC_TEST_VECTORS); 935 break; 936 937 case 16: 938 test_cipher ("arc4", MODE_ECB, ENCRYPT, arc4_enc_tv_template, ARC4_ENC_TEST_VECTORS); 939 test_cipher ("arc4", MODE_ECB, DECRYPT, arc4_dec_tv_template, ARC4_DEC_TEST_VECTORS); 940 break; 941 942 case 17: 943 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS); 944 break; 945 946 case 18: 947 test_crc32c(); 948 break; 949 950 case 19: 951 test_cipher ("tea", MODE_ECB, ENCRYPT, tea_enc_tv_template, TEA_ENC_TEST_VECTORS); 952 test_cipher ("tea", MODE_ECB, DECRYPT, tea_dec_tv_template, TEA_DEC_TEST_VECTORS); 953 break; 954 955 case 20: 956 test_cipher ("xtea", MODE_ECB, ENCRYPT, xtea_enc_tv_template, XTEA_ENC_TEST_VECTORS); 957 test_cipher ("xtea", MODE_ECB, DECRYPT, xtea_dec_tv_template, XTEA_DEC_TEST_VECTORS); 958 break; 959 960 case 21: 961 test_cipher ("khazad", MODE_ECB, ENCRYPT, khazad_enc_tv_template, KHAZAD_ENC_TEST_VECTORS); 962 test_cipher ("khazad", MODE_ECB, DECRYPT, khazad_dec_tv_template, KHAZAD_DEC_TEST_VECTORS); 963 break; 964 965 case 22: 966 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS); 967 break; 968 969 case 23: 970 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS); 971 break; 972 973 case 24: 974 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS); 975 break; 976 977 case 25: 978 test_cipher ("tnepres", MODE_ECB, ENCRYPT, tnepres_enc_tv_template, TNEPRES_ENC_TEST_VECTORS); 979 test_cipher ("tnepres", MODE_ECB, DECRYPT, tnepres_dec_tv_template, TNEPRES_DEC_TEST_VECTORS); 980 break; 981 982 case 26: 983 test_cipher ("anubis", MODE_ECB, ENCRYPT, anubis_enc_tv_template, ANUBIS_ENC_TEST_VECTORS); 984 test_cipher ("anubis", MODE_ECB, DECRYPT, anubis_dec_tv_template, ANUBIS_DEC_TEST_VECTORS); 985 test_cipher ("anubis", MODE_CBC, ENCRYPT, anubis_cbc_enc_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS); 986 test_cipher ("anubis", MODE_CBC, DECRYPT, anubis_cbc_dec_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS); 987 break; 988 989 case 27: 990 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS); 991 break; 992 993 case 28: 994 995 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS); 996 break; 997 998 case 29: 999 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS); 1000 break; 1001 1002 case 30: 1003 test_cipher ("xeta", MODE_ECB, ENCRYPT, xeta_enc_tv_template, XETA_ENC_TEST_VECTORS); 1004 test_cipher ("xeta", MODE_ECB, DECRYPT, xeta_dec_tv_template, XETA_DEC_TEST_VECTORS); 1005 break; 1006 1007 #ifdef CONFIG_CRYPTO_HMAC 1008 case 100: 1009 test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS); 1010 break; 1011 1012 case 101: 1013 test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS); 1014 break; 1015 1016 case 102: 1017 test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS); 1018 break; 1019 1020 #endif 1021 1022 case 200: 1023 test_cipher_speed("aes", MODE_ECB, ENCRYPT, sec, NULL, 0, 1024 aes_speed_template); 1025 test_cipher_speed("aes", MODE_ECB, DECRYPT, sec, NULL, 0, 1026 aes_speed_template); 1027 test_cipher_speed("aes", MODE_CBC, ENCRYPT, sec, NULL, 0, 1028 aes_speed_template); 1029 test_cipher_speed("aes", MODE_CBC, DECRYPT, sec, NULL, 0, 1030 aes_speed_template); 1031 break; 1032 1033 case 201: 1034 test_cipher_speed("des3_ede", MODE_ECB, ENCRYPT, sec, 1035 des3_ede_enc_tv_template, 1036 DES3_EDE_ENC_TEST_VECTORS, 1037 des3_ede_speed_template); 1038 test_cipher_speed("des3_ede", MODE_ECB, DECRYPT, sec, 1039 des3_ede_dec_tv_template, 1040 DES3_EDE_DEC_TEST_VECTORS, 1041 des3_ede_speed_template); 1042 test_cipher_speed("des3_ede", MODE_CBC, ENCRYPT, sec, 1043 des3_ede_enc_tv_template, 1044 DES3_EDE_ENC_TEST_VECTORS, 1045 des3_ede_speed_template); 1046 test_cipher_speed("des3_ede", MODE_CBC, DECRYPT, sec, 1047 des3_ede_dec_tv_template, 1048 DES3_EDE_DEC_TEST_VECTORS, 1049 des3_ede_speed_template); 1050 break; 1051 1052 case 202: 1053 test_cipher_speed("twofish", MODE_ECB, ENCRYPT, sec, NULL, 0, 1054 twofish_speed_template); 1055 test_cipher_speed("twofish", MODE_ECB, DECRYPT, sec, NULL, 0, 1056 twofish_speed_template); 1057 test_cipher_speed("twofish", MODE_CBC, ENCRYPT, sec, NULL, 0, 1058 twofish_speed_template); 1059 test_cipher_speed("twofish", MODE_CBC, DECRYPT, sec, NULL, 0, 1060 twofish_speed_template); 1061 break; 1062 1063 case 203: 1064 test_cipher_speed("blowfish", MODE_ECB, ENCRYPT, sec, NULL, 0, 1065 blowfish_speed_template); 1066 test_cipher_speed("blowfish", MODE_ECB, DECRYPT, sec, NULL, 0, 1067 blowfish_speed_template); 1068 test_cipher_speed("blowfish", MODE_CBC, ENCRYPT, sec, NULL, 0, 1069 blowfish_speed_template); 1070 test_cipher_speed("blowfish", MODE_CBC, DECRYPT, sec, NULL, 0, 1071 blowfish_speed_template); 1072 break; 1073 1074 case 204: 1075 test_cipher_speed("des", MODE_ECB, ENCRYPT, sec, NULL, 0, 1076 des_speed_template); 1077 test_cipher_speed("des", MODE_ECB, DECRYPT, sec, NULL, 0, 1078 des_speed_template); 1079 test_cipher_speed("des", MODE_CBC, ENCRYPT, sec, NULL, 0, 1080 des_speed_template); 1081 test_cipher_speed("des", MODE_CBC, DECRYPT, sec, NULL, 0, 1082 des_speed_template); 1083 break; 1084 1085 case 1000: 1086 test_available(); 1087 break; 1088 1089 default: 1090 /* useful for debugging */ 1091 printk("not testing anything\n"); 1092 break; 1093 } 1094 } 1095 1096 static int __init init(void) 1097 { 1098 tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL); 1099 if (tvmem == NULL) 1100 return -ENOMEM; 1101 1102 xbuf = kmalloc(XBUFSIZE, GFP_KERNEL); 1103 if (xbuf == NULL) { 1104 kfree(tvmem); 1105 return -ENOMEM; 1106 } 1107 1108 do_test(); 1109 1110 kfree(xbuf); 1111 kfree(tvmem); 1112 return 0; 1113 } 1114 1115 /* 1116 * If an init function is provided, an exit function must also be provided 1117 * to allow module unload. 1118 */ 1119 static void __exit fini(void) { } 1120 1121 module_init(init); 1122 module_exit(fini); 1123 1124 module_param(mode, int, 0); 1125 module_param(sec, uint, 0); 1126 MODULE_PARM_DESC(sec, "Length in seconds of speed tests " 1127 "(defaults to zero which uses CPU cycles instead)"); 1128 1129 MODULE_LICENSE("GPL"); 1130 MODULE_DESCRIPTION("Quick & dirty crypto testing module"); 1131 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>"); 1132