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