]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blame - crypto/tcrypt.c
projects / mirror_ubuntu-zesty-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[CRYPTO] padlock-aes: Use generic setkey function
[mirror_ubuntu-zesty-kernel.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
SS		 588
589 data = kzalloc(template[i].ilen, GFP_KERNEL);
590 if (!data)
591 continue;
592
593 memcpy(data, template[i].input, template[i].ilen);
594
595 if (template[i].iv)
596 memcpy(iv, template[i].iv, MAX_IVLEN);
597 else
598 memset(iv, 0, MAX_IVLEN);
599
600 if (template[i].np) {
ef2736fc 601 j++;
1da177e4 602 printk("test %u (%d bit key):\n",
562954d5 603 j, template[i].klen * 8);
1da177e4 604
6158efc0 605 crypto_ablkcipher_clear_flags(tfm, ~0);
562954d5 606 if (template[i].wk)
6158efc0 607 crypto_ablkcipher_set_flags(
cba83564 608 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
ef2736fc 609
562954d5
SS		 610 ret = crypto_ablkcipher_setkey(tfm, template[i].key,
611 template[i].klen);
1da177e4 612 if (ret) {
cba83564 613 printk("setkey() failed flags=%x\n",
562954d5 614 crypto_ablkcipher_get_flags(tfm));
ef2736fc 615
562954d5
SS		 616 if (!template[i].fail) {
617 kfree(data);
1da177e4 618 goto out;
562954d5 619 }
1da177e4
LT		 620 }
621
622 temp = 0;
562954d5
SS		 623 sg_init_table(sg, template[i].np);
624 for (k = 0; k < template[i].np; k++) {
ef2736fc 625 memcpy(&xbuf[IDX[k]],
562954d5
SS		 626 template[i].input + temp,
627 template[i].tap[k]);
628 temp += template[i].tap[k];
378f058c 629 sg_set_buf(&sg[k], &xbuf[IDX[k]],
562954d5 630 template[i].tap[k]);
1da177e4 631 }
ef2736fc 632
6158efc0 633 ablkcipher_request_set_crypt(req, sg, sg,
562954d5 634 template[i].ilen, iv);
ef2736fc 635
cba83564 636 ret = enc ?
6158efc0
HX		 637 crypto_ablkcipher_encrypt(req) :
638 crypto_ablkcipher_decrypt(req);
ef2736fc 639
6158efc0
HX		 640 switch (ret) {
641 case 0:
642 break;
643 case -EINPROGRESS:
644 case -EBUSY:
645 ret = wait_for_completion_interruptible(
646 &result.completion);
647 if (!ret && !((ret = result.err))) {
648 INIT_COMPLETION(result.completion);
649 break;
650 }
651 /* fall through */
652 default:
653 printk("%s () failed err=%d\n", e, -ret);
1da177e4
LT		 654 goto out;
655 }
656
657 temp = 0;
562954d5 658 for (k = 0; k < template[i].np; k++) {
1da177e4 659 printk("page %u\n", k);
78c2f0b8 660 q = kmap(sg_page(&sg[k])) + sg[k].offset;
562954d5 661 hexdump(q, template[i].tap[k]);
ef2736fc 662 printk("%s\n",
562954d5
SS		 663 memcmp(q, template[i].result + temp,
664 template[i].tap[k]) ? "fail" :
1da177e4 665 "pass");
562954d5
SS		 666 temp += template[i].tap[k];
667 kunmap(sg_page(&sg[k]));
1da177e4
LT		 668 }
669 }
670 }
1da177e4 671out:
6158efc0
HX		 672 crypto_free_ablkcipher(tfm);
673 ablkcipher_request_free(req);
1da177e4
LT		 674}
675
cba83564 676static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc, char *p,
6a17944c
HX		 677 int blen, int sec)
678{
6df5b9f4 679 struct scatterlist sg[1];
6a17944c
HX		 680 unsigned long start, end;
681 int bcount;
682 int ret;
683
b7335885 684 sg_init_one(sg, p, blen);
6a17944c
HX		 685
686 for (start = jiffies, end = start + sec * HZ, bcount = 0;
687 time_before(jiffies, end); bcount++) {
688 if (enc)
cba83564 689 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
6a17944c 690 else
cba83564 691 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
6a17944c
HX		 692
693 if (ret)
694 return ret;
695 }
696
697 printk("%d operations in %d seconds (%ld bytes)\n",
698 bcount, sec, (long)bcount * blen);
699 return 0;
700}
701
cba83564 702static int test_cipher_cycles(struct blkcipher_desc *desc, int enc, char *p,
6a17944c
HX		 703 int blen)
704{
6df5b9f4 705 struct scatterlist sg[1];
6a17944c
HX		 706 unsigned long cycles = 0;
707 int ret = 0;
708 int i;
709
b7335885 710 sg_init_one(sg, p, blen);
6a17944c
HX		 711
712 local_bh_disable();
713 local_irq_disable();
714
715 /* Warm-up run. */
716 for (i = 0; i < 4; i++) {
717 if (enc)
cba83564 718 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
6a17944c 719 else
cba83564 720 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
6a17944c
HX		 721
722 if (ret)
723 goto out;
724 }
725
726 /* The real thing. */
727 for (i = 0; i < 8; i++) {
728 cycles_t start, end;
729
730 start = get_cycles();
731 if (enc)
cba83564 732 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
6a17944c 733 else
cba83564 734 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
6a17944c
HX		 735 end = get_cycles();
736
737 if (ret)
738 goto out;
739
740 cycles += end - start;
741 }
742
743out:
744 local_irq_enable();
745 local_bh_enable();
746
747 if (ret == 0)
748 printk("1 operation in %lu cycles (%d bytes)\n",
749 (cycles + 4) / 8, blen);
750
751 return ret;
752}
753
d5dc3927
SS		 754static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 };
755
cba83564 756static void test_cipher_speed(char *algo, int enc, unsigned int sec,
dce907c0 757 struct cipher_testvec *template,
d5dc3927 758 unsigned int tcount, u8 *keysize)
ebfd9bcf 759{
dce907c0 760 unsigned int ret, i, j, iv_len;
ebfd9bcf 761 unsigned char *key, *p, iv[128];
cba83564
HX		 762 struct crypto_blkcipher *tfm;
763 struct blkcipher_desc desc;
764 const char *e;
d5dc3927 765 u32 *b_size;
ebfd9bcf
HW		 766
767 if (enc == ENCRYPT)
768 e = "encryption";
769 else
770 e = "decryption";
ebfd9bcf 771
cba83564 772 printk("\ntesting speed of %s %s\n", algo, e);
ebfd9bcf 773
cba83564 774 tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);
ebfd9bcf 775
cba83564
HX		 776 if (IS_ERR(tfm)) {
777 printk("failed to load transform for %s: %ld\n", algo,
778 PTR_ERR(tfm));
ebfd9bcf
HW		 779 return;
780 }
cba83564
HX		 781 desc.tfm = tfm;
782 desc.flags = 0;
ebfd9bcf 783
d5dc3927
SS		 784 i = 0;
785 do {
ebfd9bcf 786
d5dc3927
SS		 787 b_size = block_sizes;
788 do {
ebfd9bcf 789
d5dc3927
SS		 790 if ((*keysize + *b_size) > TVMEMSIZE) {
791 printk("template (%u) too big for tvmem (%u)\n",
792 *keysize + *b_size, TVMEMSIZE);
793 goto out;
794 }
ebfd9bcf 795
d5dc3927
SS		 796 printk("test %u (%d bit key, %d byte blocks): ", i,
797 *keysize * 8, *b_size);
798
799 memset(tvmem, 0xff, *keysize + *b_size);
800
801 /* set key, plain text and IV */
802 key = (unsigned char *)tvmem;
803 for (j = 0; j < tcount; j++) {
804 if (template[j].klen == *keysize) {
805 key = template[j].key;
806 break;
807 }
dce907c0 808 }
d5dc3927 809 p = (unsigned char *)tvmem + *keysize;
ebfd9bcf 810
d5dc3927
SS		 811 ret = crypto_blkcipher_setkey(tfm, key, *keysize);
812 if (ret) {
813 printk("setkey() failed flags=%x\n",
814 crypto_blkcipher_get_flags(tfm));
815 goto out;
816 }
ebfd9bcf 817
d5dc3927
SS		 818 iv_len = crypto_blkcipher_ivsize(tfm);
819 if (iv_len) {
820 memset(&iv, 0xff, iv_len);
821 crypto_blkcipher_set_iv(tfm, iv, iv_len);
822 }
ebfd9bcf 823
d5dc3927
SS		 824 if (sec)
825 ret = test_cipher_jiffies(&desc, enc, p, *b_size, sec);
826 else
827 ret = test_cipher_cycles(&desc, enc, p, *b_size);
ebfd9bcf 828
d5dc3927
SS		 829 if (ret) {
830 printk("%s() failed flags=%x\n", e, desc.flags);
831 break;
832 }
833 b_size++;
834 i++;
835 } while (*b_size);
836 keysize++;
837 } while (*keysize);
ebfd9bcf
HW		 838
839out:
cba83564 840 crypto_free_blkcipher(tfm);
ebfd9bcf
HW		 841}
842
e9d41164
HX		 843static int test_hash_jiffies_digest(struct hash_desc *desc, char *p, int blen,
844 char *out, int sec)
845{
846 struct scatterlist sg[1];
847 unsigned long start, end;
848 int bcount;
849 int ret;
850
a5a613a4
HX		 851 sg_init_table(sg, 1);
852
e9d41164
HX		 853 for (start = jiffies, end = start + sec * HZ, bcount = 0;
854 time_before(jiffies, end); bcount++) {
a5a613a4 855 sg_set_buf(sg, p, blen);
e9d41164
HX		 856 ret = crypto_hash_digest(desc, sg, blen, out);
857 if (ret)
858 return ret;
859 }
860
861 printk("%6u opers/sec, %9lu bytes/sec\n",
862 bcount / sec, ((long)bcount * blen) / sec);
863
864 return 0;
865}
866
867static int test_hash_jiffies(struct hash_desc *desc, char *p, int blen,
868 int plen, char *out, int sec)
e8057928
ML		 869{
870 struct scatterlist sg[1];
871 unsigned long start, end;
872 int bcount, pcount;
e9d41164
HX		 873 int ret;
874
875 if (plen == blen)
876 return test_hash_jiffies_digest(desc, p, blen, out, sec);
e8057928 877
a5a613a4
HX		 878 sg_init_table(sg, 1);
879
e8057928
ML		 880 for (start = jiffies, end = start + sec * HZ, bcount = 0;
881 time_before(jiffies, end); bcount++) {
e9d41164
HX		 882 ret = crypto_hash_init(desc);
883 if (ret)
884 return ret;
e8057928 885 for (pcount = 0; pcount < blen; pcount += plen) {
a5a613a4 886 sg_set_buf(sg, p + pcount, plen);
e9d41164
HX		 887 ret = crypto_hash_update(desc, sg, plen);
888 if (ret)
889 return ret;
e8057928
ML		 890 }
891 /* we assume there is enough space in 'out' for the result */
e9d41164
HX		 892 ret = crypto_hash_final(desc, out);
893 if (ret)
894 return ret;
e8057928
ML		 895 }
896
897 printk("%6u opers/sec, %9lu bytes/sec\n",
898 bcount / sec, ((long)bcount * blen) / sec);
899
e9d41164
HX		 900 return 0;
901}
902
903static int test_hash_cycles_digest(struct hash_desc *desc, char *p, int blen,
904 char *out)
905{
906 struct scatterlist sg[1];
907 unsigned long cycles = 0;
908 int i;
909 int ret;
910
a5a613a4
HX		 911 sg_init_table(sg, 1);
912
e9d41164
HX		 913 local_bh_disable();
914 local_irq_disable();
915
916 /* Warm-up run. */
917 for (i = 0; i < 4; i++) {
a5a613a4 918 sg_set_buf(sg, p, blen);
e9d41164
HX		 919 ret = crypto_hash_digest(desc, sg, blen, out);
920 if (ret)
921 goto out;
922 }
923
924 /* The real thing. */
925 for (i = 0; i < 8; i++) {
926 cycles_t start, end;
927
928 start = get_cycles();
929
a5a613a4 930 sg_set_buf(sg, p, blen);
e9d41164
HX		 931 ret = crypto_hash_digest(desc, sg, blen, out);
932 if (ret)
933 goto out;
934
935 end = get_cycles();
936
937 cycles += end - start;
938 }
939
940out:
941 local_irq_enable();
942 local_bh_enable();
943
944 if (ret)
945 return ret;
946
947 printk("%6lu cycles/operation, %4lu cycles/byte\n",
948 cycles / 8, cycles / (8 * blen));
949
950 return 0;
e8057928
ML		 951}
952
e9d41164
HX		 953static int test_hash_cycles(struct hash_desc *desc, char *p, int blen,
954 int plen, char *out)
e8057928
ML		 955{
956 struct scatterlist sg[1];
957 unsigned long cycles = 0;
958 int i, pcount;
e9d41164
HX		 959 int ret;
960
961 if (plen == blen)
962 return test_hash_cycles_digest(desc, p, blen, out);
e8057928 963
a5a613a4
HX		 964 sg_init_table(sg, 1);
965
e8057928
ML		 966 local_bh_disable();
967 local_irq_disable();
968
969 /* Warm-up run. */
970 for (i = 0; i < 4; i++) {
e9d41164
HX		 971 ret = crypto_hash_init(desc);
972 if (ret)
973 goto out;
e8057928 974 for (pcount = 0; pcount < blen; pcount += plen) {
a5a613a4 975 sg_set_buf(sg, p + pcount, plen);
e9d41164
HX		 976 ret = crypto_hash_update(desc, sg, plen);
977 if (ret)
978 goto out;
e8057928 979 }
29059d12 980 ret = crypto_hash_final(desc, out);
e9d41164
HX		 981 if (ret)
982 goto out;
e8057928
ML		 983 }
984
985 /* The real thing. */
986 for (i = 0; i < 8; i++) {
987 cycles_t start, end;
988
e8057928
ML		 989 start = get_cycles();
990
e9d41164
HX		 991 ret = crypto_hash_init(desc);
992 if (ret)
993 goto out;
e8057928 994 for (pcount = 0; pcount < blen; pcount += plen) {
a5a613a4 995 sg_set_buf(sg, p + pcount, plen);
e9d41164
HX		 996 ret = crypto_hash_update(desc, sg, plen);
997 if (ret)
998 goto out;
e8057928 999 }
e9d41164
HX		 1000 ret = crypto_hash_final(desc, out);
1001 if (ret)
1002 goto out;
e8057928
ML		 1003
1004 end = get_cycles();
1005
1006 cycles += end - start;
1007 }
1008
e9d41164 1009out:
e8057928
ML		 1010 local_irq_enable();
1011 local_bh_enable();
1012
e9d41164
HX		 1013 if (ret)
1014 return ret;
1015
e8057928
ML		 1016 printk("%6lu cycles/operation, %4lu cycles/byte\n",
1017 cycles / 8, cycles / (8 * blen));
1018
e9d41164 1019 return 0;
e8057928
ML		 1020}
1021
e9d41164
HX		 1022static void test_hash_speed(char *algo, unsigned int sec,
1023 struct hash_speed *speed)
e8057928 1024{
e9d41164
HX		 1025 struct crypto_hash *tfm;
1026 struct hash_desc desc;
e8057928
ML		 1027 char output[1024];
1028 int i;
e9d41164 1029 int ret;
e8057928
ML		 1030
1031 printk("\ntesting speed of %s\n", algo);
1032
e9d41164 1033 tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
e8057928 1034
e9d41164
HX		 1035 if (IS_ERR(tfm)) {
1036 printk("failed to load transform for %s: %ld\n", algo,
1037 PTR_ERR(tfm));
e8057928
ML		 1038 return;
1039 }
1040
e9d41164
HX		 1041 desc.tfm = tfm;
1042 desc.flags = 0;
1043
1044 if (crypto_hash_digestsize(tfm) > sizeof(output)) {
e8057928 1045 printk("digestsize(%u) > outputbuffer(%zu)\n",
e9d41164 1046 crypto_hash_digestsize(tfm), sizeof(output));
e8057928
ML		 1047 goto out;
1048 }
1049
1050 for (i = 0; speed[i].blen != 0; i++) {
1051 if (speed[i].blen > TVMEMSIZE) {
1052 printk("template (%u) too big for tvmem (%u)\n",
1053 speed[i].blen, TVMEMSIZE);
1054 goto out;
1055 }
1056
1057 printk("test%3u (%5u byte blocks,%5u bytes per update,%4u updates): ",
1058 i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
1059
1060 memset(tvmem, 0xff, speed[i].blen);
1061
1062 if (sec)
e9d41164
HX		 1063 ret = test_hash_jiffies(&desc, tvmem, speed[i].blen,
1064 speed[i].plen, output, sec);
e8057928 1065 else
e9d41164
HX		 1066 ret = test_hash_cycles(&desc, tvmem, speed[i].blen,
1067 speed[i].plen, output);
1068
1069 if (ret) {
1070 printk("hashing failed ret=%d\n", ret);
1071 break;
1072 }
e8057928
ML		 1073 }
1074
1075out:
e9d41164 1076 crypto_free_hash(tfm);
e8057928
ML		 1077}
1078
91755a92
ZS		 1079static void test_comp(char *algo, struct comp_testvec *ctemplate,
1080 struct comp_testvec *dtemplate, int ctcount, int dtcount)
1da177e4
LT		 1081{
1082 unsigned int i;
1083 char result[COMP_BUF_SIZE];
e4d5b79c 1084 struct crypto_comp *tfm;
1da177e4
LT		 1085 unsigned int tsize;
1086
91755a92 1087 printk("\ntesting %s compression\n", algo);
1da177e4 1088
91755a92 1089 tfm = crypto_alloc_comp(algo, 0, CRYPTO_ALG_ASYNC);
7bc301e9 1090 if (IS_ERR(tfm)) {
91755a92 1091 printk("failed to load transform for %s\n", algo);
1da177e4
LT		 1092 return;
1093 }
1094
91755a92 1095 for (i = 0; i < ctcount; i++) {
1da177e4 1096 int ilen, ret, dlen = COMP_BUF_SIZE;
ef2736fc 1097
1da177e4
LT		 1098 printk("test %u:\n", i + 1);
1099 memset(result, 0, sizeof (result));
1100
562954d5
SS		 1101 ilen = ctemplate[i].inlen;
1102 ret = crypto_comp_compress(tfm, ctemplate[i].input,
1da177e4
LT		 1103 ilen, result, &dlen);
1104 if (ret) {
1105 printk("fail: ret=%d\n", ret);
1106 continue;
1107 }
1108 hexdump(result, dlen);
1109 printk("%s (ratio %d:%d)\n",
562954d5 1110 memcmp(result, ctemplate[i].output, dlen) ? "fail" : "pass",
1da177e4
LT		 1111 ilen, dlen);
1112 }
1113
91755a92 1114 printk("\ntesting %s decompression\n", algo);
1da177e4 1115
91755a92
ZS		 1116 tsize = sizeof(struct comp_testvec);
1117 tsize *= dtcount;
1da177e4
LT		 1118 if (tsize > TVMEMSIZE) {
1119 printk("template (%u) too big for tvmem (%u)\n", tsize,
1120 TVMEMSIZE);
1121 goto out;
1122 }
1123
91755a92 1124 for (i = 0; i < dtcount; i++) {
1da177e4 1125 int ilen, ret, dlen = COMP_BUF_SIZE;
ef2736fc 1126
1da177e4
LT		 1127 printk("test %u:\n", i + 1);
1128 memset(result, 0, sizeof (result));
1129
562954d5
SS		 1130 ilen = dtemplate[i].inlen;
1131 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
1da177e4
LT		 1132 ilen, result, &dlen);
1133 if (ret) {
1134 printk("fail: ret=%d\n", ret);
1135 continue;
1136 }
1137 hexdump(result, dlen);
1138 printk("%s (ratio %d:%d)\n",
562954d5 1139 memcmp(result, dtemplate[i].output, dlen) ? "fail" : "pass",
1da177e4
LT		 1140 ilen, dlen);
1141 }
1142out:
e4d5b79c 1143 crypto_free_comp(tfm);
1da177e4
LT		 1144}
1145
ef2736fc 1146static void test_available(void)
1da177e4
LT		 1147{
1148 char **name = check;
ef2736fc 1149
1da177e4
LT		 1150 while (*name) {
1151 printk("alg %s ", *name);
6158efc0 1152 printk(crypto_has_alg(*name, 0, 0) ?
e4d5b79c 1153 "found\n" : "not found\n");
1da177e4 1154 name++;
ef2736fc 1155 }
1da177e4
LT		 1156}
1157
ef2736fc 1158static void do_test(void)
1da177e4
LT		 1159{
1160 switch (mode) {
1161
1162 case 0:
1163 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
ef2736fc 1164
1da177e4 1165 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
ef2736fc 1166
1da177e4 1167 //DES
cba83564
HX		 1168 test_cipher("ecb(des)", ENCRYPT, des_enc_tv_template,
1169 DES_ENC_TEST_VECTORS);
1170 test_cipher("ecb(des)", DECRYPT, des_dec_tv_template,
1171 DES_DEC_TEST_VECTORS);
1172 test_cipher("cbc(des)", ENCRYPT, des_cbc_enc_tv_template,
1173 DES_CBC_ENC_TEST_VECTORS);
1174 test_cipher("cbc(des)", DECRYPT, des_cbc_dec_tv_template,
1175 DES_CBC_DEC_TEST_VECTORS);
ef2736fc 1176
1da177e4 1177 //DES3_EDE
cba83564
HX		 1178 test_cipher("ecb(des3_ede)", ENCRYPT, des3_ede_enc_tv_template,
1179 DES3_EDE_ENC_TEST_VECTORS);
1180 test_cipher("ecb(des3_ede)", DECRYPT, des3_ede_dec_tv_template,
1181 DES3_EDE_DEC_TEST_VECTORS);
ef2736fc 1182
1da177e4 1183 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
ef2736fc 1184
cd12fb90
JL		 1185 test_hash("sha224", sha224_tv_template, SHA224_TEST_VECTORS);
1186
1da177e4 1187 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
ef2736fc 1188
1da177e4 1189 //BLOWFISH
cba83564
HX		 1190 test_cipher("ecb(blowfish)", ENCRYPT, bf_enc_tv_template,
1191 BF_ENC_TEST_VECTORS);
1192 test_cipher("ecb(blowfish)", DECRYPT, bf_dec_tv_template,
1193 BF_DEC_TEST_VECTORS);
1194 test_cipher("cbc(blowfish)", ENCRYPT, bf_cbc_enc_tv_template,
1195 BF_CBC_ENC_TEST_VECTORS);
1196 test_cipher("cbc(blowfish)", DECRYPT, bf_cbc_dec_tv_template,
1197 BF_CBC_DEC_TEST_VECTORS);
ef2736fc 1198
1da177e4 1199 //TWOFISH
cba83564
HX		 1200 test_cipher("ecb(twofish)", ENCRYPT, tf_enc_tv_template,
1201 TF_ENC_TEST_VECTORS);
1202 test_cipher("ecb(twofish)", DECRYPT, tf_dec_tv_template,
1203 TF_DEC_TEST_VECTORS);
1204 test_cipher("cbc(twofish)", ENCRYPT, tf_cbc_enc_tv_template,
1205 TF_CBC_ENC_TEST_VECTORS);
1206 test_cipher("cbc(twofish)", DECRYPT, tf_cbc_dec_tv_template,
1207 TF_CBC_DEC_TEST_VECTORS);
ef2736fc 1208
1da177e4 1209 //SERPENT
cba83564
HX		 1210 test_cipher("ecb(serpent)", ENCRYPT, serpent_enc_tv_template,
1211 SERPENT_ENC_TEST_VECTORS);
1212 test_cipher("ecb(serpent)", DECRYPT, serpent_dec_tv_template,
1213 SERPENT_DEC_TEST_VECTORS);
ef2736fc 1214
1da177e4 1215 //TNEPRES
cba83564
HX		 1216 test_cipher("ecb(tnepres)", ENCRYPT, tnepres_enc_tv_template,
1217 TNEPRES_ENC_TEST_VECTORS);
1218 test_cipher("ecb(tnepres)", DECRYPT, tnepres_dec_tv_template,
1219 TNEPRES_DEC_TEST_VECTORS);
1da177e4
LT		 1220
1221 //AES
cba83564
HX		 1222 test_cipher("ecb(aes)", ENCRYPT, aes_enc_tv_template,
1223 AES_ENC_TEST_VECTORS);
1224 test_cipher("ecb(aes)", DECRYPT, aes_dec_tv_template,
1225 AES_DEC_TEST_VECTORS);
1226 test_cipher("cbc(aes)", ENCRYPT, aes_cbc_enc_tv_template,
1227 AES_CBC_ENC_TEST_VECTORS);
1228 test_cipher("cbc(aes)", DECRYPT, aes_cbc_dec_tv_template,
1229 AES_CBC_DEC_TEST_VECTORS);
f3d1044c
RS		 1230 test_cipher("lrw(aes)", ENCRYPT, aes_lrw_enc_tv_template,
1231 AES_LRW_ENC_TEST_VECTORS);
1232 test_cipher("lrw(aes)", DECRYPT, aes_lrw_dec_tv_template,
1233 AES_LRW_DEC_TEST_VECTORS);
f19f5111
RS		 1234 test_cipher("xts(aes)", ENCRYPT, aes_xts_enc_tv_template,
1235 AES_XTS_ENC_TEST_VECTORS);
1236 test_cipher("xts(aes)", DECRYPT, aes_xts_dec_tv_template,
1237 AES_XTS_DEC_TEST_VECTORS);
5311f248 1238 test_cipher("rfc3686(ctr(aes))", ENCRYPT, aes_ctr_enc_tv_template,
23e353c8 1239 AES_CTR_ENC_TEST_VECTORS);
5311f248 1240 test_cipher("rfc3686(ctr(aes))", DECRYPT, aes_ctr_dec_tv_template,
23e353c8 1241 AES_CTR_DEC_TEST_VECTORS);
28db8e3e
MH		 1242 test_aead("gcm(aes)", ENCRYPT, aes_gcm_enc_tv_template,
1243 AES_GCM_ENC_TEST_VECTORS);
1244 test_aead("gcm(aes)", DECRYPT, aes_gcm_dec_tv_template,
1245 AES_GCM_DEC_TEST_VECTORS);
93cc74e0
JL		 1246 test_aead("ccm(aes)", ENCRYPT, aes_ccm_enc_tv_template,
1247 AES_CCM_ENC_TEST_VECTORS);
1248 test_aead("ccm(aes)", DECRYPT, aes_ccm_dec_tv_template,
1249 AES_CCM_DEC_TEST_VECTORS);
1da177e4
LT		 1250
1251 //CAST5
cba83564
HX		 1252 test_cipher("ecb(cast5)", ENCRYPT, cast5_enc_tv_template,
1253 CAST5_ENC_TEST_VECTORS);
1254 test_cipher("ecb(cast5)", DECRYPT, cast5_dec_tv_template,
1255 CAST5_DEC_TEST_VECTORS);
ef2736fc 1256
1da177e4 1257 //CAST6
cba83564
HX		 1258 test_cipher("ecb(cast6)", ENCRYPT, cast6_enc_tv_template,
1259 CAST6_ENC_TEST_VECTORS);
1260 test_cipher("ecb(cast6)", DECRYPT, cast6_dec_tv_template,
1261 CAST6_DEC_TEST_VECTORS);
1da177e4
LT		 1262
1263 //ARC4
cba83564
HX		 1264 test_cipher("ecb(arc4)", ENCRYPT, arc4_enc_tv_template,
1265 ARC4_ENC_TEST_VECTORS);
1266 test_cipher("ecb(arc4)", DECRYPT, arc4_dec_tv_template,
1267 ARC4_DEC_TEST_VECTORS);
1da177e4
LT		 1268
1269 //TEA
cba83564
HX		 1270 test_cipher("ecb(tea)", ENCRYPT, tea_enc_tv_template,
1271 TEA_ENC_TEST_VECTORS);
1272 test_cipher("ecb(tea)", DECRYPT, tea_dec_tv_template,
1273 TEA_DEC_TEST_VECTORS);
1da177e4
LT		 1274
1275
1276 //XTEA
cba83564
HX		 1277 test_cipher("ecb(xtea)", ENCRYPT, xtea_enc_tv_template,
1278 XTEA_ENC_TEST_VECTORS);
1279 test_cipher("ecb(xtea)", DECRYPT, xtea_dec_tv_template,
1280 XTEA_DEC_TEST_VECTORS);
1da177e4
LT		 1281
1282 //KHAZAD
cba83564
HX		 1283 test_cipher("ecb(khazad)", ENCRYPT, khazad_enc_tv_template,
1284 KHAZAD_ENC_TEST_VECTORS);
1285 test_cipher("ecb(khazad)", DECRYPT, khazad_dec_tv_template,
1286 KHAZAD_DEC_TEST_VECTORS);
1da177e4
LT		 1287
1288 //ANUBIS
cba83564
HX		 1289 test_cipher("ecb(anubis)", ENCRYPT, anubis_enc_tv_template,
1290 ANUBIS_ENC_TEST_VECTORS);
1291 test_cipher("ecb(anubis)", DECRYPT, anubis_dec_tv_template,
1292 ANUBIS_DEC_TEST_VECTORS);
1293 test_cipher("cbc(anubis)", ENCRYPT, anubis_cbc_enc_tv_template,
1294 ANUBIS_CBC_ENC_TEST_VECTORS);
1295 test_cipher("cbc(anubis)", DECRYPT, anubis_cbc_dec_tv_template,
1296 ANUBIS_CBC_ENC_TEST_VECTORS);
1da177e4 1297
fb4f10ed 1298 //XETA
cba83564
HX		 1299 test_cipher("ecb(xeta)", ENCRYPT, xeta_enc_tv_template,
1300 XETA_ENC_TEST_VECTORS);
1301 test_cipher("ecb(xeta)", DECRYPT, xeta_dec_tv_template,
1302 XETA_DEC_TEST_VECTORS);
fb4f10ed 1303
90831639
DH		 1304 //FCrypt
1305 test_cipher("pcbc(fcrypt)", ENCRYPT, fcrypt_pcbc_enc_tv_template,
1306 FCRYPT_ENC_TEST_VECTORS);
1307 test_cipher("pcbc(fcrypt)", DECRYPT, fcrypt_pcbc_dec_tv_template,
1308 FCRYPT_DEC_TEST_VECTORS);
1309
02ab5a70
NT		 1310 //CAMELLIA
1311 test_cipher("ecb(camellia)", ENCRYPT,
1312 camellia_enc_tv_template,
1313 CAMELLIA_ENC_TEST_VECTORS);
1314 test_cipher("ecb(camellia)", DECRYPT,
1315 camellia_dec_tv_template,
1316 CAMELLIA_DEC_TEST_VECTORS);
1317 test_cipher("cbc(camellia)", ENCRYPT,
1318 camellia_cbc_enc_tv_template,
1319 CAMELLIA_CBC_ENC_TEST_VECTORS);
1320 test_cipher("cbc(camellia)", DECRYPT,
1321 camellia_cbc_dec_tv_template,
1322 CAMELLIA_CBC_DEC_TEST_VECTORS);
1323
e2ee95b8
HSC		 1324 //SEED
1325 test_cipher("ecb(seed)", ENCRYPT, seed_enc_tv_template,
1326 SEED_ENC_TEST_VECTORS);
1327 test_cipher("ecb(seed)", DECRYPT, seed_dec_tv_template,
1328 SEED_DEC_TEST_VECTORS);
1329
76cb9521
KC		 1330 //CTS
1331 test_cipher("cts(cbc(aes))", ENCRYPT, cts_mode_enc_tv_template,
1332 CTS_MODE_ENC_TEST_VECTORS);
1333 test_cipher("cts(cbc(aes))", DECRYPT, cts_mode_dec_tv_template,
1334 CTS_MODE_DEC_TEST_VECTORS);
1335
1da177e4
LT		 1336 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
1337 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
1338 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
1339 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
1340 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
1341 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
1342 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
1343 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
91755a92
ZS		 1344 test_comp("deflate", deflate_comp_tv_template,
1345 deflate_decomp_tv_template, DEFLATE_COMP_TEST_VECTORS,
1346 DEFLATE_DECOMP_TEST_VECTORS);
0b77abb3
ZS		 1347 test_comp("lzo", lzo_comp_tv_template, lzo_decomp_tv_template,
1348 LZO_COMP_TEST_VECTORS, LZO_DECOMP_TEST_VECTORS);
c907ee76 1349 test_hash("crc32c", crc32c_tv_template, CRC32C_TEST_VECTORS);
e9d41164
HX		 1350 test_hash("hmac(md5)", hmac_md5_tv_template,
1351 HMAC_MD5_TEST_VECTORS);
1352 test_hash("hmac(sha1)", hmac_sha1_tv_template,
1353 HMAC_SHA1_TEST_VECTORS);
cd12fb90
JL		 1354 test_hash("hmac(sha224)", hmac_sha224_tv_template,
1355 HMAC_SHA224_TEST_VECTORS);
e9d41164
HX		 1356 test_hash("hmac(sha256)", hmac_sha256_tv_template,
1357 HMAC_SHA256_TEST_VECTORS);
a28091ae
AD		 1358 test_hash("hmac(sha384)", hmac_sha384_tv_template,
1359 HMAC_SHA384_TEST_VECTORS);
1360 test_hash("hmac(sha512)", hmac_sha512_tv_template,
1361 HMAC_SHA512_TEST_VECTORS);
1da177e4 1362
5b2becf5
KM		 1363 test_hash("xcbc(aes)", aes_xcbc128_tv_template,
1364 XCBC_AES_TEST_VECTORS);
1365
1da177e4
LT		 1366 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
1367 break;
1368
1369 case 1:
1370 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
1371 break;
1372
1373 case 2:
1374 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
1375 break;
1376
1377 case 3:
cba83564
HX		 1378 test_cipher("ecb(des)", ENCRYPT, des_enc_tv_template,
1379 DES_ENC_TEST_VECTORS);
1380 test_cipher("ecb(des)", DECRYPT, des_dec_tv_template,
1381 DES_DEC_TEST_VECTORS);
1382 test_cipher("cbc(des)", ENCRYPT, des_cbc_enc_tv_template,
1383 DES_CBC_ENC_TEST_VECTORS);
1384 test_cipher("cbc(des)", DECRYPT, des_cbc_dec_tv_template,
1385 DES_CBC_DEC_TEST_VECTORS);
1da177e4
LT		 1386 break;
1387
1388 case 4:
cba83564
HX		 1389 test_cipher("ecb(des3_ede)", ENCRYPT, des3_ede_enc_tv_template,
1390 DES3_EDE_ENC_TEST_VECTORS);
1391 test_cipher("ecb(des3_ede)", DECRYPT, des3_ede_dec_tv_template,
1392 DES3_EDE_DEC_TEST_VECTORS);
1da177e4
LT		 1393 break;
1394
1395 case 5:
1396 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
1397 break;
ef2736fc 1398
1da177e4
LT		 1399 case 6:
1400 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
1401 break;
ef2736fc 1402
1da177e4 1403 case 7:
cba83564
HX		 1404 test_cipher("ecb(blowfish)", ENCRYPT, bf_enc_tv_template,
1405 BF_ENC_TEST_VECTORS);
1406 test_cipher("ecb(blowfish)", DECRYPT, bf_dec_tv_template,
1407 BF_DEC_TEST_VECTORS);
1408 test_cipher("cbc(blowfish)", ENCRYPT, bf_cbc_enc_tv_template,
1409 BF_CBC_ENC_TEST_VECTORS);
1410 test_cipher("cbc(blowfish)", DECRYPT, bf_cbc_dec_tv_template,
1411 BF_CBC_DEC_TEST_VECTORS);
1da177e4
LT		 1412 break;
1413
1414 case 8:
cba83564
HX		 1415 test_cipher("ecb(twofish)", ENCRYPT, tf_enc_tv_template,
1416 TF_ENC_TEST_VECTORS);
1417 test_cipher("ecb(twofish)", DECRYPT, tf_dec_tv_template,
1418 TF_DEC_TEST_VECTORS);
1419 test_cipher("cbc(twofish)", ENCRYPT, tf_cbc_enc_tv_template,
1420 TF_CBC_ENC_TEST_VECTORS);
1421 test_cipher("cbc(twofish)", DECRYPT, tf_cbc_dec_tv_template,
1422 TF_CBC_DEC_TEST_VECTORS);
1da177e4 1423 break;
ef2736fc 1424
1da177e4 1425 case 9:
cba83564
HX		 1426 test_cipher("ecb(serpent)", ENCRYPT, serpent_enc_tv_template,
1427 SERPENT_ENC_TEST_VECTORS);
1428 test_cipher("ecb(serpent)", DECRYPT, serpent_dec_tv_template,
1429 SERPENT_DEC_TEST_VECTORS);
1da177e4
LT		 1430 break;
1431
1432 case 10:
cba83564
HX		 1433 test_cipher("ecb(aes)", ENCRYPT, aes_enc_tv_template,
1434 AES_ENC_TEST_VECTORS);
1435 test_cipher("ecb(aes)", DECRYPT, aes_dec_tv_template,
1436 AES_DEC_TEST_VECTORS);
1437 test_cipher("cbc(aes)", ENCRYPT, aes_cbc_enc_tv_template,
1438 AES_CBC_ENC_TEST_VECTORS);
1439 test_cipher("cbc(aes)", DECRYPT, aes_cbc_dec_tv_template,
1440 AES_CBC_DEC_TEST_VECTORS);
f3d1044c
RS		 1441 test_cipher("lrw(aes)", ENCRYPT, aes_lrw_enc_tv_template,
1442 AES_LRW_ENC_TEST_VECTORS);
1443 test_cipher("lrw(aes)", DECRYPT, aes_lrw_dec_tv_template,
1444 AES_LRW_DEC_TEST_VECTORS);
f19f5111
RS		 1445 test_cipher("xts(aes)", ENCRYPT, aes_xts_enc_tv_template,
1446 AES_XTS_ENC_TEST_VECTORS);
1447 test_cipher("xts(aes)", DECRYPT, aes_xts_dec_tv_template,
1448 AES_XTS_DEC_TEST_VECTORS);
5311f248 1449 test_cipher("rfc3686(ctr(aes))", ENCRYPT, aes_ctr_enc_tv_template,
23e353c8 1450 AES_CTR_ENC_TEST_VECTORS);
5311f248 1451 test_cipher("rfc3686(ctr(aes))", DECRYPT, aes_ctr_dec_tv_template,
23e353c8 1452 AES_CTR_DEC_TEST_VECTORS);
1da177e4
LT		 1453 break;
1454
1455 case 11:
1456 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
1457 break;
ef2736fc 1458
1da177e4
LT		 1459 case 12:
1460 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
1461 break;
1462
1463 case 13:
91755a92
ZS		 1464 test_comp("deflate", deflate_comp_tv_template,
1465 deflate_decomp_tv_template, DEFLATE_COMP_TEST_VECTORS,
1466 DEFLATE_DECOMP_TEST_VECTORS);
1da177e4
LT		 1467 break;
1468
1469 case 14:
cba83564
HX		 1470 test_cipher("ecb(cast5)", ENCRYPT, cast5_enc_tv_template,
1471 CAST5_ENC_TEST_VECTORS);
1472 test_cipher("ecb(cast5)", DECRYPT, cast5_dec_tv_template,
1473 CAST5_DEC_TEST_VECTORS);
1da177e4
LT		 1474 break;
1475
1476 case 15:
cba83564
HX		 1477 test_cipher("ecb(cast6)", ENCRYPT, cast6_enc_tv_template,
1478 CAST6_ENC_TEST_VECTORS);
1479 test_cipher("ecb(cast6)", DECRYPT, cast6_dec_tv_template,
1480 CAST6_DEC_TEST_VECTORS);
1da177e4
LT		 1481 break;
1482
1483 case 16:
cba83564
HX		 1484 test_cipher("ecb(arc4)", ENCRYPT, arc4_enc_tv_template,
1485 ARC4_ENC_TEST_VECTORS);
1486 test_cipher("ecb(arc4)", DECRYPT, arc4_dec_tv_template,
1487 ARC4_DEC_TEST_VECTORS);
1da177e4
LT		 1488 break;
1489
1490 case 17:
1491 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
1492 break;
1493
1494 case 18:
c907ee76 1495 test_hash("crc32c", crc32c_tv_template, CRC32C_TEST_VECTORS);
1da177e4
LT		 1496 break;
1497
1498 case 19:
cba83564
HX		 1499 test_cipher("ecb(tea)", ENCRYPT, tea_enc_tv_template,
1500 TEA_ENC_TEST_VECTORS);
1501 test_cipher("ecb(tea)", DECRYPT, tea_dec_tv_template,
1502 TEA_DEC_TEST_VECTORS);
1da177e4
LT		 1503 break;
1504
1505 case 20:
cba83564
HX		 1506 test_cipher("ecb(xtea)", ENCRYPT, xtea_enc_tv_template,
1507 XTEA_ENC_TEST_VECTORS);
1508 test_cipher("ecb(xtea)", DECRYPT, xtea_dec_tv_template,
1509 XTEA_DEC_TEST_VECTORS);
1da177e4
LT		 1510 break;
1511
1512 case 21:
cba83564
HX		 1513 test_cipher("ecb(khazad)", ENCRYPT, khazad_enc_tv_template,
1514 KHAZAD_ENC_TEST_VECTORS);
1515 test_cipher("ecb(khazad)", DECRYPT, khazad_dec_tv_template,
1516 KHAZAD_DEC_TEST_VECTORS);
1da177e4
LT		 1517 break;
1518
1519 case 22:
1520 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
1521 break;
1522
1523 case 23:
1524 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
1525 break;
1526
1527 case 24:
1528 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
1529 break;
1530
1531 case 25:
cba83564
HX		 1532 test_cipher("ecb(tnepres)", ENCRYPT, tnepres_enc_tv_template,
1533 TNEPRES_ENC_TEST_VECTORS);
1534 test_cipher("ecb(tnepres)", DECRYPT, tnepres_dec_tv_template,
1535 TNEPRES_DEC_TEST_VECTORS);
1da177e4
LT		 1536 break;
1537
1538 case 26:
cba83564
HX		 1539 test_cipher("ecb(anubis)", ENCRYPT, anubis_enc_tv_template,
1540 ANUBIS_ENC_TEST_VECTORS);
1541 test_cipher("ecb(anubis)", DECRYPT, anubis_dec_tv_template,
1542 ANUBIS_DEC_TEST_VECTORS);
1543 test_cipher("cbc(anubis)", ENCRYPT, anubis_cbc_enc_tv_template,
1544 ANUBIS_CBC_ENC_TEST_VECTORS);
1545 test_cipher("cbc(anubis)", DECRYPT, anubis_cbc_dec_tv_template,
1546 ANUBIS_CBC_ENC_TEST_VECTORS);
1da177e4
LT		 1547 break;
1548
1549 case 27:
1550 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
1551 break;
1552
1553 case 28:
1554
1555 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
1556 break;
1557
1558 case 29:
1559 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
1560 break;
fb4f10ed
AG		 1561
1562 case 30:
cba83564
HX		 1563 test_cipher("ecb(xeta)", ENCRYPT, xeta_enc_tv_template,
1564 XETA_ENC_TEST_VECTORS);
1565 test_cipher("ecb(xeta)", DECRYPT, xeta_dec_tv_template,
1566 XETA_DEC_TEST_VECTORS);
fb4f10ed 1567 break;
1da177e4 1568
90831639
DH		 1569 case 31:
1570 test_cipher("pcbc(fcrypt)", ENCRYPT, fcrypt_pcbc_enc_tv_template,
1571 FCRYPT_ENC_TEST_VECTORS);
1572 test_cipher("pcbc(fcrypt)", DECRYPT, fcrypt_pcbc_dec_tv_template,
1573 FCRYPT_DEC_TEST_VECTORS);
1574 break;
1575
02ab5a70
NT		 1576 case 32:
1577 test_cipher("ecb(camellia)", ENCRYPT,
1578 camellia_enc_tv_template,
1579 CAMELLIA_ENC_TEST_VECTORS);
1580 test_cipher("ecb(camellia)", DECRYPT,
1581 camellia_dec_tv_template,
1582 CAMELLIA_DEC_TEST_VECTORS);
1583 test_cipher("cbc(camellia)", ENCRYPT,
1584 camellia_cbc_enc_tv_template,
1585 CAMELLIA_CBC_ENC_TEST_VECTORS);
1586 test_cipher("cbc(camellia)", DECRYPT,
1587 camellia_cbc_dec_tv_template,
1588 CAMELLIA_CBC_DEC_TEST_VECTORS);
1589 break;
cd12fb90
JL		 1590 case 33:
1591 test_hash("sha224", sha224_tv_template, SHA224_TEST_VECTORS);
1592 break;
02ab5a70 1593
2407d608
TSH		 1594 case 34:
1595 test_cipher("salsa20", ENCRYPT,
1596 salsa20_stream_enc_tv_template,
1597 SALSA20_STREAM_ENC_TEST_VECTORS);
1598 break;
1599
8df213d9
HX		 1600 case 35:
1601 test_aead("gcm(aes)", ENCRYPT, aes_gcm_enc_tv_template,
1602 AES_GCM_ENC_TEST_VECTORS);
1603 test_aead("gcm(aes)", DECRYPT, aes_gcm_dec_tv_template,
1604 AES_GCM_DEC_TEST_VECTORS);
1605 break;
1606
0b77abb3
ZS		 1607 case 36:
1608 test_comp("lzo", lzo_comp_tv_template, lzo_decomp_tv_template,
1609 LZO_COMP_TEST_VECTORS, LZO_DECOMP_TEST_VECTORS);
1610 break;
1611
93cc74e0
JL		 1612 case 37:
1613 test_aead("ccm(aes)", ENCRYPT, aes_ccm_enc_tv_template,
1614 AES_CCM_ENC_TEST_VECTORS);
1615 test_aead("ccm(aes)", DECRYPT, aes_ccm_dec_tv_template,
1616 AES_CCM_DEC_TEST_VECTORS);
1617 break;
1618
76cb9521
KC		 1619 case 38:
1620 test_cipher("cts(cbc(aes))", ENCRYPT, cts_mode_enc_tv_template,
1621 CTS_MODE_ENC_TEST_VECTORS);
1622 test_cipher("cts(cbc(aes))", DECRYPT, cts_mode_dec_tv_template,
1623 CTS_MODE_DEC_TEST_VECTORS);
1624 break;
1625
1da177e4 1626 case 100:
e9d41164
HX		 1627 test_hash("hmac(md5)", hmac_md5_tv_template,
1628 HMAC_MD5_TEST_VECTORS);
1da177e4 1629 break;
ef2736fc 1630
1da177e4 1631 case 101:
e9d41164
HX		 1632 test_hash("hmac(sha1)", hmac_sha1_tv_template,
1633 HMAC_SHA1_TEST_VECTORS);
1da177e4 1634 break;
ef2736fc 1635
1da177e4 1636 case 102:
e9d41164
HX		 1637 test_hash("hmac(sha256)", hmac_sha256_tv_template,
1638 HMAC_SHA256_TEST_VECTORS);
1da177e4
LT		 1639 break;
1640
a28091ae
AD		 1641 case 103:
1642 test_hash("hmac(sha384)", hmac_sha384_tv_template,
1643 HMAC_SHA384_TEST_VECTORS);
1644 break;
1645
1646 case 104:
1647 test_hash("hmac(sha512)", hmac_sha512_tv_template,
1648 HMAC_SHA512_TEST_VECTORS);
1649 break;
38ed9ab2 1650
cd12fb90
JL		 1651 case 105:
1652 test_hash("hmac(sha224)", hmac_sha224_tv_template,
1653 HMAC_SHA224_TEST_VECTORS);
1654 break;
1da177e4 1655
38ed9ab2
HX		 1656 case 106:
1657 test_hash("xcbc(aes)", aes_xcbc128_tv_template,
1658 XCBC_AES_TEST_VECTORS);
1659 break;
1660
ebfd9bcf 1661 case 200:
cba83564 1662 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
477035c2 1663 speed_template_16_24_32);
cba83564 1664 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
477035c2 1665 speed_template_16_24_32);
cba83564 1666 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
477035c2 1667 speed_template_16_24_32);
cba83564 1668 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
477035c2 1669 speed_template_16_24_32);
f3d1044c 1670 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
477035c2 1671 speed_template_32_40_48);
f3d1044c 1672 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
477035c2 1673 speed_template_32_40_48);
f19f5111 1674 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
477035c2 1675 speed_template_32_48_64);
f19f5111 1676 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
477035c2 1677 speed_template_32_48_64);
ebfd9bcf
HW		 1678 break;
1679
1680 case 201:
cba83564 1681 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
477035c2
SS		 1682 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1683 speed_template_24);
cba83564 1684 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
477035c2
SS		 1685 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1686 speed_template_24);
cba83564 1687 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
477035c2
SS		 1688 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1689 speed_template_24);
cba83564 1690 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
477035c2
SS		 1691 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1692 speed_template_24);
ebfd9bcf
HW		 1693 break;
1694
1695 case 202:
cba83564 1696 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
477035c2 1697 speed_template_16_24_32);
cba83564 1698 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
477035c2 1699 speed_template_16_24_32);
cba83564 1700 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
477035c2 1701 speed_template_16_24_32);
cba83564 1702 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
477035c2 1703 speed_template_16_24_32);
ebfd9bcf
HW		 1704 break;
1705
1706 case 203:
cba83564 1707 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
477035c2 1708 speed_template_8_32);
cba83564 1709 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
477035c2 1710 speed_template_8_32);
cba83564 1711 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
477035c2 1712 speed_template_8_32);
cba83564 1713 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
477035c2 1714 speed_template_8_32);
ebfd9bcf
HW		 1715 break;
1716
1717 case 204:
cba83564 1718 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
477035c2 1719 speed_template_8);
cba83564 1720 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
477035c2 1721 speed_template_8);
cba83564 1722 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
477035c2 1723 speed_template_8);
cba83564 1724 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
477035c2 1725 speed_template_8);
ebfd9bcf
HW		 1726 break;
1727
02ab5a70
NT		 1728 case 205:
1729 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
477035c2 1730 speed_template_16_24_32);
02ab5a70 1731 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
477035c2 1732 speed_template_16_24_32);
02ab5a70 1733 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
477035c2 1734 speed_template_16_24_32);
02ab5a70 1735 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
477035c2 1736 speed_template_16_24_32);
02ab5a70
NT		 1737 break;
1738
5de8f1b5
TSH		 1739 case 206:
1740 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
477035c2 1741 speed_template_16_32);
5de8f1b5
TSH		 1742 break;
1743
e8057928
ML		 1744 case 300:
1745 /* fall through */
1746
1747 case 301:
e9d41164 1748 test_hash_speed("md4", sec, generic_hash_speed_template);
e8057928
ML		 1749 if (mode > 300 && mode < 400) break;
1750
1751 case 302:
e9d41164 1752 test_hash_speed("md5", sec, generic_hash_speed_template);
e8057928
ML		 1753 if (mode > 300 && mode < 400) break;
1754
1755 case 303:
e9d41164 1756 test_hash_speed("sha1", sec, generic_hash_speed_template);
e8057928
ML		 1757 if (mode > 300 && mode < 400) break;
1758
1759 case 304:
e9d41164 1760 test_hash_speed("sha256", sec, generic_hash_speed_template);
e8057928
ML		 1761 if (mode > 300 && mode < 400) break;
1762
1763 case 305:
e9d41164 1764 test_hash_speed("sha384", sec, generic_hash_speed_template);
e8057928
ML		 1765 if (mode > 300 && mode < 400) break;
1766
1767 case 306:
e9d41164 1768 test_hash_speed("sha512", sec, generic_hash_speed_template);
e8057928
ML		 1769 if (mode > 300 && mode < 400) break;
1770
1771 case 307:
e9d41164 1772 test_hash_speed("wp256", sec, generic_hash_speed_template);
e8057928
ML		 1773 if (mode > 300 && mode < 400) break;
1774
1775 case 308:
e9d41164 1776 test_hash_speed("wp384", sec, generic_hash_speed_template);
e8057928
ML		 1777 if (mode > 300 && mode < 400) break;
1778
1779 case 309:
e9d41164 1780 test_hash_speed("wp512", sec, generic_hash_speed_template);
e8057928
ML		 1781 if (mode > 300 && mode < 400) break;
1782
1783 case 310:
e9d41164 1784 test_hash_speed("tgr128", sec, generic_hash_speed_template);
e8057928
ML		 1785 if (mode > 300 && mode < 400) break;
1786
1787 case 311:
e9d41164 1788 test_hash_speed("tgr160", sec, generic_hash_speed_template);
e8057928
ML		 1789 if (mode > 300 && mode < 400) break;
1790
1791 case 312:
e9d41164 1792 test_hash_speed("tgr192", sec, generic_hash_speed_template);
e8057928
ML		 1793 if (mode > 300 && mode < 400) break;
1794
cd12fb90
JL		 1795 case 313:
1796 test_hash_speed("sha224", sec, generic_hash_speed_template);
1797 if (mode > 300 && mode < 400) break;
1798
e8057928
ML		 1799 case 399:
1800 break;
1801
1da177e4
LT		 1802 case 1000:
1803 test_available();
1804 break;
ef2736fc 1805
1da177e4
LT		 1806 default:
1807 /* useful for debugging */
1808 printk("not testing anything\n");
1809 break;
1810 }
1811}
1812
ef2736fc 1813static int __init init(void)
1da177e4 1814{
e3a4ea4f
MH		 1815 int err = -ENOMEM;
1816
1da177e4
LT		 1817 tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL);
1818 if (tvmem == NULL)
e3a4ea4f 1819 return err;
1da177e4
LT		 1820
1821 xbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
e3a4ea4f
MH		 1822 if (xbuf == NULL)
1823 goto err_free_tv;
1da177e4 1824
e3a4ea4f
MH		 1825 axbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
1826 if (axbuf == NULL)
1827 goto err_free_xbuf;
1da177e4 1828
e3a4ea4f 1829 do_test();
14fdf477
ML		 1830
1831 /* We intentionaly return -EAGAIN to prevent keeping
1832 * the module. It does all its work from init()
1833 * and doesn't offer any runtime functionality
1834 * => we don't need it in the memory, do we?
1835 * -- mludvig
1836 */
e3a4ea4f
MH		 1837 err = -EAGAIN;
1838
1839 kfree(axbuf);
1840 err_free_xbuf:
1841 kfree(xbuf);
1842 err_free_tv:
1843 kfree(tvmem);
1844
1845 return err;
1da177e4
LT		 1846}
1847
1848/*
1849 * If an init function is provided, an exit function must also be provided
1850 * to allow module unload.
1851 */
1852static void __exit fini(void) { }
1853
1854module_init(init);
1855module_exit(fini);
1856
1857module_param(mode, int, 0);
ebfd9bcf 1858module_param(sec, uint, 0);
6a17944c
HX		 1859MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
1860 "(defaults to zero which uses CPU cycles instead)");
1da177e4
LT		 1861
1862MODULE_LICENSE("GPL");
1863MODULE_DESCRIPTION("Quick & dirty crypto testing module");
1864MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
ubuntu-zesty-kernel mirror