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