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