projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[CRYPTO] null: Allow setkey on digest_null
[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);
e3a4ea4f 175 memset(axbuf, 0, XBUFSIZE);
1da177e4
LT		 176
177 j = 0;
178 for (i = 0; i < tcount; i++) {
179 if (hash_tv[i].np) {
180 j++;
ef2736fc
HX		 181 printk("test %u:\n", j);
182 memset(result, 0, 64);
1da177e4
LT		 183
184 temp = 0;
b7335885 185 sg_init_table(sg, hash_tv[i].np);
1da177e4 186 for (k = 0; k < hash_tv[i].np; k++) {
ef2736fc
HX		 187 memcpy(&xbuf[IDX[k]],
188 hash_tv[i].plaintext + temp,
189 hash_tv[i].tap[k]);
1da177e4 190 temp += hash_tv[i].tap[k];
378f058c
DH		 191 sg_set_buf(&sg[k], &xbuf[IDX[k]],
192 hash_tv[i].tap[k]);
1da177e4
LT		 193 }
194
e9d41164
HX		 195 if (hash_tv[i].ksize) {
196 ret = crypto_hash_setkey(tfm, hash_tv[i].key,
197 hash_tv[i].ksize);
ef2736fc 198
e9d41164
HX		 199 if (ret) {
200 printk("setkey() failed ret=%d\n", ret);
201 goto out;
202 }
1da177e4
LT		 203 }
204
e9d41164
HX		 205 ret = crypto_hash_digest(&desc, sg, hash_tv[i].psize,
206 result);
207 if (ret) {
208 printk("digest () failed ret=%d\n", ret);
209 goto out;
210 }
ef2736fc 211
e9d41164 212 hexdump(result, crypto_hash_digestsize(tfm));
1da177e4 213 printk("%s\n",
e9d41164
HX		 214 memcmp(result, hash_tv[i].digest,
215 crypto_hash_digestsize(tfm)) ?
ef2736fc 216 "fail" : "pass");
1da177e4
LT		 217 }
218 }
e9d41164 219
1da177e4 220out:
e9d41164 221 crypto_free_hash(tfm);
1da177e4
LT		 222}
223
e3a4ea4f
MH		 224static void test_aead(char *algo, int enc, struct aead_testvec *template,
225 unsigned int tcount)
226{
227 unsigned int ret, i, j, k, temp;
228 unsigned int tsize;
229 char *q;
230 struct crypto_aead *tfm;
231 char *key;
232 struct aead_testvec *aead_tv;
233 struct aead_request *req;
234 struct scatterlist sg[8];
235 struct scatterlist asg[8];
236 const char *e;
237 struct tcrypt_result result;
6160b289 238 unsigned int authsize;
e3a4ea4f
MH		 239
240 if (enc == ENCRYPT)
241 e = "encryption";
242 else
243 e = "decryption";
244
245 printk(KERN_INFO "\ntesting %s %s\n", algo, e);
246
247 tsize = sizeof(struct aead_testvec);
248 tsize *= tcount;
249
250 if (tsize > TVMEMSIZE) {
251 printk(KERN_INFO "template (%u) too big for tvmem (%u)\n",
252 tsize, TVMEMSIZE);
253 return;
254 }
255
256 memcpy(tvmem, template, tsize);
257 aead_tv = (void *)tvmem;
258
259 init_completion(&result.completion);
260
261 tfm = crypto_alloc_aead(algo, 0, 0);
262
263 if (IS_ERR(tfm)) {
264 printk(KERN_INFO "failed to load transform for %s: %ld\n",
265 algo, PTR_ERR(tfm));
266 return;
267 }
268
269 req = aead_request_alloc(tfm, GFP_KERNEL);
270 if (!req) {
271 printk(KERN_INFO "failed to allocate request for %s\n", algo);
272 goto out;
273 }
274
275 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
276 tcrypt_complete, &result);
277
278 for (i = 0, j = 0; i < tcount; i++) {
279 if (!aead_tv[i].np) {
280 printk(KERN_INFO "test %u (%d bit key):\n",
281 ++j, aead_tv[i].klen * 8);
282
283 crypto_aead_clear_flags(tfm, ~0);
284 if (aead_tv[i].wk)
285 crypto_aead_set_flags(
286 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
287 key = aead_tv[i].key;
288
289 ret = crypto_aead_setkey(tfm, key,
290 aead_tv[i].klen);
291 if (ret) {
292 printk(KERN_INFO "setkey() failed flags=%x\n",
293 crypto_aead_get_flags(tfm));
294
295 if (!aead_tv[i].fail)
296 goto out;
297 }
298
93cc74e0
JL		 299 authsize = abs(aead_tv[i].rlen - aead_tv[i].ilen);
300 ret = crypto_aead_setauthsize(tfm, authsize);
301 if (ret) {
302 printk(KERN_INFO
303 "failed to set authsize = %u\n",
304 authsize);
305 goto out;
306 }
307
e3a4ea4f 308 sg_init_one(&sg[0], aead_tv[i].input,
6160b289 309 aead_tv[i].ilen + (enc ? authsize : 0));
e3a4ea4f
MH		 310
311 sg_init_one(&asg[0], aead_tv[i].assoc,
312 aead_tv[i].alen);
313
314 aead_request_set_crypt(req, sg, sg,
315 aead_tv[i].ilen,
316 aead_tv[i].iv);
317
318 aead_request_set_assoc(req, asg, aead_tv[i].alen);
319
6160b289
HX		 320 ret = enc ?
321 crypto_aead_encrypt(req) :
322 crypto_aead_decrypt(req);
e3a4ea4f
MH		 323
324 switch (ret) {
325 case 0:
326 break;
327 case -EINPROGRESS:
328 case -EBUSY:
329 ret = wait_for_completion_interruptible(
330 &result.completion);
331 if (!ret && !(ret = result.err)) {
332 INIT_COMPLETION(result.completion);
333 break;
334 }
335 /* fall through */
336 default:
337 printk(KERN_INFO "%s () failed err=%d\n",
338 e, -ret);
339 goto out;
340 }
341
342 q = kmap(sg_page(&sg[0])) + sg[0].offset;
343 hexdump(q, aead_tv[i].rlen);
e3a4ea4f
MH		 344
345 printk(KERN_INFO "enc/dec: %s\n",
346 memcmp(q, aead_tv[i].result,
347 aead_tv[i].rlen) ? "fail" : "pass");
e3a4ea4f
MH		 348 }
349 }
350
351 printk(KERN_INFO "\ntesting %s %s across pages (chunking)\n", algo, e);
352 memset(xbuf, 0, XBUFSIZE);
353
354 for (i = 0, j = 0; i < tcount; i++) {
355 if (aead_tv[i].np) {
356 printk(KERN_INFO "test %u (%d bit key):\n",
357 ++j, aead_tv[i].klen * 8);
358
359 crypto_aead_clear_flags(tfm, ~0);
360 if (aead_tv[i].wk)
361 crypto_aead_set_flags(
362 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
363 key = aead_tv[i].key;
364
365 ret = crypto_aead_setkey(tfm, key, aead_tv[i].klen);
366 if (ret) {
367 printk(KERN_INFO "setkey() failed flags=%x\n",
368 crypto_aead_get_flags(tfm));
369
370 if (!aead_tv[i].fail)
371 goto out;
372 }
373
374 sg_init_table(sg, aead_tv[i].np);
375 for (k = 0, temp = 0; k < aead_tv[i].np; k++) {
376 memcpy(&xbuf[IDX[k]],
377 aead_tv[i].input + temp,
378 aead_tv[i].tap[k]);
379 temp += aead_tv[i].tap[k];
380 sg_set_buf(&sg[k], &xbuf[IDX[k]],
381 aead_tv[i].tap[k]);
382 }
383
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;
cd12fb90
JL		 1611 case 105:
1612 test_hash("hmac(sha224)", hmac_sha224_tv_template,
1613 HMAC_SHA224_TEST_VECTORS);
1614 break;
1da177e4 1615
ebfd9bcf 1616 case 200:
cba83564 1617 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
dce907c0 1618 aes_speed_template);
cba83564 1619 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
dce907c0 1620 aes_speed_template);
cba83564 1621 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
dce907c0 1622 aes_speed_template);
cba83564 1623 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
dce907c0 1624 aes_speed_template);
f3d1044c
RS		 1625 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
1626 aes_lrw_speed_template);
1627 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
1628 aes_lrw_speed_template);
f19f5111
RS		 1629 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
1630 aes_xts_speed_template);
1631 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
1632 aes_xts_speed_template);
ebfd9bcf
HW		 1633 break;
1634
1635 case 201:
cba83564 1636 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
dce907c0
HX		 1637 des3_ede_enc_tv_template,
1638 DES3_EDE_ENC_TEST_VECTORS,
1639 des3_ede_speed_template);
cba83564 1640 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
dce907c0
HX		 1641 des3_ede_dec_tv_template,
1642 DES3_EDE_DEC_TEST_VECTORS,
1643 des3_ede_speed_template);
cba83564 1644 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
dce907c0
HX		 1645 des3_ede_enc_tv_template,
1646 DES3_EDE_ENC_TEST_VECTORS,
1647 des3_ede_speed_template);
cba83564 1648 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
dce907c0
HX		 1649 des3_ede_dec_tv_template,
1650 DES3_EDE_DEC_TEST_VECTORS,
1651 des3_ede_speed_template);
ebfd9bcf
HW		 1652 break;
1653
1654 case 202:
cba83564 1655 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
dce907c0 1656 twofish_speed_template);
cba83564 1657 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
dce907c0 1658 twofish_speed_template);
cba83564 1659 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
dce907c0 1660 twofish_speed_template);
cba83564 1661 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
dce907c0 1662 twofish_speed_template);
ebfd9bcf
HW		 1663 break;
1664
1665 case 203:
cba83564 1666 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
dce907c0 1667 blowfish_speed_template);
cba83564 1668 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
dce907c0 1669 blowfish_speed_template);
cba83564 1670 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
dce907c0 1671 blowfish_speed_template);
cba83564 1672 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
dce907c0 1673 blowfish_speed_template);
ebfd9bcf
HW		 1674 break;
1675
1676 case 204:
cba83564 1677 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
dce907c0 1678 des_speed_template);
cba83564 1679 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
dce907c0 1680 des_speed_template);
cba83564 1681 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
dce907c0 1682 des_speed_template);
cba83564 1683 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
dce907c0 1684 des_speed_template);
ebfd9bcf
HW		 1685 break;
1686
02ab5a70
NT		 1687 case 205:
1688 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
1689 camellia_speed_template);
1690 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
1691 camellia_speed_template);
1692 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
1693 camellia_speed_template);
1694 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
1695 camellia_speed_template);
1696 break;
1697
5de8f1b5
TSH		 1698 case 206:
1699 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
1700 salsa20_speed_template);
1701 break;
1702
e8057928
ML		 1703 case 300:
1704 /* fall through */
1705
1706 case 301:
e9d41164 1707 test_hash_speed("md4", sec, generic_hash_speed_template);
e8057928
ML		 1708 if (mode > 300 && mode < 400) break;
1709
1710 case 302:
e9d41164 1711 test_hash_speed("md5", sec, generic_hash_speed_template);
e8057928
ML		 1712 if (mode > 300 && mode < 400) break;
1713
1714 case 303:
e9d41164 1715 test_hash_speed("sha1", sec, generic_hash_speed_template);
e8057928
ML		 1716 if (mode > 300 && mode < 400) break;
1717
1718 case 304:
e9d41164 1719 test_hash_speed("sha256", sec, generic_hash_speed_template);
e8057928
ML		 1720 if (mode > 300 && mode < 400) break;
1721
1722 case 305:
e9d41164 1723 test_hash_speed("sha384", sec, generic_hash_speed_template);
e8057928
ML		 1724 if (mode > 300 && mode < 400) break;
1725
1726 case 306:
e9d41164 1727 test_hash_speed("sha512", sec, generic_hash_speed_template);
e8057928
ML		 1728 if (mode > 300 && mode < 400) break;
1729
1730 case 307:
e9d41164 1731 test_hash_speed("wp256", sec, generic_hash_speed_template);
e8057928
ML		 1732 if (mode > 300 && mode < 400) break;
1733
1734 case 308:
e9d41164 1735 test_hash_speed("wp384", sec, generic_hash_speed_template);
e8057928
ML		 1736 if (mode > 300 && mode < 400) break;
1737
1738 case 309:
e9d41164 1739 test_hash_speed("wp512", sec, generic_hash_speed_template);
e8057928
ML		 1740 if (mode > 300 && mode < 400) break;
1741
1742 case 310:
e9d41164 1743 test_hash_speed("tgr128", sec, generic_hash_speed_template);
e8057928
ML		 1744 if (mode > 300 && mode < 400) break;
1745
1746 case 311:
e9d41164 1747 test_hash_speed("tgr160", sec, generic_hash_speed_template);
e8057928
ML		 1748 if (mode > 300 && mode < 400) break;
1749
1750 case 312:
e9d41164 1751 test_hash_speed("tgr192", sec, generic_hash_speed_template);
e8057928
ML		 1752 if (mode > 300 && mode < 400) break;
1753
cd12fb90
JL		 1754 case 313:
1755 test_hash_speed("sha224", sec, generic_hash_speed_template);
1756 if (mode > 300 && mode < 400) break;
1757
e8057928
ML		 1758 case 399:
1759 break;
1760
1da177e4
LT		 1761 case 1000:
1762 test_available();
1763 break;
ef2736fc 1764
1da177e4
LT		 1765 default:
1766 /* useful for debugging */
1767 printk("not testing anything\n");
1768 break;
1769 }
1770}
1771
ef2736fc 1772static int __init init(void)
1da177e4 1773{
e3a4ea4f
MH		 1774 int err = -ENOMEM;
1775
1da177e4
LT		 1776 tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL);
1777 if (tvmem == NULL)
e3a4ea4f 1778 return err;
1da177e4
LT		 1779
1780 xbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
e3a4ea4f
MH		 1781 if (xbuf == NULL)
1782 goto err_free_tv;
1da177e4 1783
e3a4ea4f
MH		 1784 axbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
1785 if (axbuf == NULL)
1786 goto err_free_xbuf;
1da177e4 1787
e3a4ea4f 1788 do_test();
14fdf477
ML		 1789
1790 /* We intentionaly return -EAGAIN to prevent keeping
1791 * the module. It does all its work from init()
1792 * and doesn't offer any runtime functionality
1793 * => we don't need it in the memory, do we?
1794 * -- mludvig
1795 */
e3a4ea4f
MH		 1796 err = -EAGAIN;
1797
1798 kfree(axbuf);
1799 err_free_xbuf:
1800 kfree(xbuf);
1801 err_free_tv:
1802 kfree(tvmem);
1803
1804 return err;
1da177e4
LT		 1805}
1806
1807/*
1808 * If an init function is provided, an exit function must also be provided
1809 * to allow module unload.
1810 */
1811static void __exit fini(void) { }
1812
1813module_init(init);
1814module_exit(fini);
1815
1816module_param(mode, int, 0);
ebfd9bcf 1817module_param(sec, uint, 0);
6a17944c
HX		 1818MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
1819 "(defaults to zero which uses CPU cycles instead)");
1da177e4
LT		 1820
1821MODULE_LICENSE("GPL");
1822MODULE_DESCRIPTION("Quick & dirty crypto testing module");
1823MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
Linux 6.x block layer and io_uring tree(s)