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