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