]> 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: ahash - Add padding in crypto_ahash_extsize
[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 10 *
69435b94
AH		 11 * Updated RFC4106 AES-GCM testing.
12 * Authors: Aidan O'Mahony (aidan.o.mahony@intel.com)
13 * Adrian Hoban <adrian.hoban@intel.com>
14 * Gabriele Paoloni <gabriele.paoloni@intel.com>
15 * Tadeusz Struk (tadeusz.struk@intel.com)
16 * Copyright (c) 2010, Intel Corporation.
17 *
1da177e4
LT		 18 * This program is free software; you can redistribute it and/or modify it
19 * under the terms of the GNU General Public License as published by the Free
ef2736fc 20 * Software Foundation; either version 2 of the License, or (at your option)
1da177e4
LT		 21 * any later version.
22 *
1da177e4
LT		 23 */
24
1ce5a04d 25#include <crypto/aead.h>
18e33e6d 26#include <crypto/hash.h>
cba83564 27#include <linux/err.h>
daf0944c 28#include <linux/fips.h>
1da177e4 29#include <linux/init.h>
5a0e3ad6 30#include <linux/gfp.h>
1da177e4 31#include <linux/module.h>
378f058c 32#include <linux/scatterlist.h>
1da177e4 33#include <linux/string.h>
1da177e4 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/*
f139cfa7 41 * Need slab memory for testing (size in number of pages).
1da177e4 42 */
f139cfa7 43#define TVMEMSIZE 4
1da177e4
LT		 44
45/*
da7f033d 46* Used by test_cipher_speed()
1da177e4
LT		 47*/
48#define ENCRYPT 1
49#define DECRYPT 0
1da177e4 50
f074f7b1
HG		 51#define MAX_DIGEST_SIZE 64
52
263a8df0
LC		 53/*
54 * return a string with the driver name
55 */
56#define get_driver_name(tfm_type, tfm) crypto_tfm_alg_driver_name(tfm_type ## _tfm(tfm))
57
ebfd9bcf
HW		 58/*
59 * Used by test_cipher_speed()
60 */
6a17944c 61static unsigned int sec;
ebfd9bcf 62
a873a5f1
SK		 63static char *alg = NULL;
64static u32 type;
7be380f7 65static u32 mask;
1da177e4 66static int mode;
f139cfa7 67static char *tvmem[TVMEMSIZE];
1da177e4
LT		 68
69static char *check[] = {
cd12fb90
JL		 70 "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256",
71 "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes",
72 "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
90831639 73 "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", "fcrypt",
2998db37 74 "camellia", "seed", "salsa20", "rmd128", "rmd160", "rmd256", "rmd320",
79cc6ab8 75 "lzo", "cts", "zlib", "sha3-224", "sha3-256", "sha3-384", "sha3-512",
76 NULL
1da177e4
LT		 77};
78
1425d2d1
VL		 79struct tcrypt_result {
80 struct completion completion;
81 int err;
82};
83
84static void tcrypt_complete(struct crypto_async_request *req, int err)
85{
86 struct tcrypt_result *res = req->data;
87
88 if (err == -EINPROGRESS)
89 return;
90
91 res->err = err;
92 complete(&res->completion);
93}
94
f139cfa7 95static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc,
3e3dc25f 96 struct scatterlist *sg, int blen, int secs)
6a17944c 97{
6a17944c
HX		 98 unsigned long start, end;
99 int bcount;
100 int ret;
101
3e3dc25f 102 for (start = jiffies, end = start + secs * HZ, bcount = 0;
6a17944c
HX		 103 time_before(jiffies, end); bcount++) {
104 if (enc)
cba83564 105 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
6a17944c 106 else
cba83564 107 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
6a17944c
HX		 108
109 if (ret)
110 return ret;
111 }
112
113 printk("%d operations in %d seconds (%ld bytes)\n",
3e3dc25f 114 bcount, secs, (long)bcount * blen);
6a17944c
HX		 115 return 0;
116}
117
f139cfa7
HX		 118static int test_cipher_cycles(struct blkcipher_desc *desc, int enc,
119 struct scatterlist *sg, int blen)
6a17944c 120{
6a17944c
HX		 121 unsigned long cycles = 0;
122 int ret = 0;
123 int i;
124
6a17944c
HX		 125 local_irq_disable();
126
127 /* Warm-up run. */
128 for (i = 0; i < 4; i++) {
129 if (enc)
cba83564 130 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
6a17944c 131 else
cba83564 132 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
6a17944c
HX		 133
134 if (ret)
135 goto out;
136 }
137
138 /* The real thing. */
139 for (i = 0; i < 8; i++) {
140 cycles_t start, end;
141
142 start = get_cycles();
143 if (enc)
cba83564 144 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
6a17944c 145 else
cba83564 146 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
6a17944c
HX		 147 end = get_cycles();
148
149 if (ret)
150 goto out;
151
152 cycles += end - start;
153 }
154
155out:
156 local_irq_enable();
6a17944c
HX		 157
158 if (ret == 0)
159 printk("1 operation in %lu cycles (%d bytes)\n",
160 (cycles + 4) / 8, blen);
161
162 return ret;
163}
164
1425d2d1
VL		 165static inline int do_one_aead_op(struct aead_request *req, int ret)
166{
167 if (ret == -EINPROGRESS || ret == -EBUSY) {
168 struct tcrypt_result *tr = req->base.data;
169
170 ret = wait_for_completion_interruptible(&tr->completion);
171 if (!ret)
172 ret = tr->err;
173 reinit_completion(&tr->completion);
174 }
175
176 return ret;
177}
178
53f52d7a 179static int test_aead_jiffies(struct aead_request *req, int enc,
3e3dc25f 180 int blen, int secs)
53f52d7a
TC		 181{
182 unsigned long start, end;
183 int bcount;
184 int ret;
185
3e3dc25f 186 for (start = jiffies, end = start + secs * HZ, bcount = 0;
53f52d7a
TC		 187 time_before(jiffies, end); bcount++) {
188 if (enc)
1425d2d1 189 ret = do_one_aead_op(req, crypto_aead_encrypt(req));
53f52d7a 190 else
1425d2d1 191 ret = do_one_aead_op(req, crypto_aead_decrypt(req));
53f52d7a
TC		 192
193 if (ret)
194 return ret;
195 }
196
197 printk("%d operations in %d seconds (%ld bytes)\n",
3e3dc25f 198 bcount, secs, (long)bcount * blen);
53f52d7a
TC		 199 return 0;
200}
201
202static int test_aead_cycles(struct aead_request *req, int enc, int blen)
203{
204 unsigned long cycles = 0;
205 int ret = 0;
206 int i;
207
208 local_irq_disable();
209
210 /* Warm-up run. */
211 for (i = 0; i < 4; i++) {
212 if (enc)
1425d2d1 213 ret = do_one_aead_op(req, crypto_aead_encrypt(req));
53f52d7a 214 else
1425d2d1 215 ret = do_one_aead_op(req, crypto_aead_decrypt(req));
53f52d7a
TC		 216
217 if (ret)
218 goto out;
219 }
220
221 /* The real thing. */
222 for (i = 0; i < 8; i++) {
223 cycles_t start, end;
224
225 start = get_cycles();
226 if (enc)
1425d2d1 227 ret = do_one_aead_op(req, crypto_aead_encrypt(req));
53f52d7a 228 else
1425d2d1 229 ret = do_one_aead_op(req, crypto_aead_decrypt(req));
53f52d7a
TC		 230 end = get_cycles();
231
232 if (ret)
233 goto out;
234
235 cycles += end - start;
236 }
237
238out:
239 local_irq_enable();
240
241 if (ret == 0)
242 printk("1 operation in %lu cycles (%d bytes)\n",
243 (cycles + 4) / 8, blen);
244
245 return ret;
246}
247
d5dc3927 248static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 };
53f52d7a
TC		 249static u32 aead_sizes[] = { 16, 64, 256, 512, 1024, 2048, 4096, 8192, 0 };
250
251#define XBUFSIZE 8
252#define MAX_IVLEN 32
253
254static int testmgr_alloc_buf(char *buf[XBUFSIZE])
255{
256 int i;
257
258 for (i = 0; i < XBUFSIZE; i++) {
259 buf[i] = (void *)__get_free_page(GFP_KERNEL);
260 if (!buf[i])
261 goto err_free_buf;
262 }
263
264 return 0;
265
266err_free_buf:
267 while (i-- > 0)
268 free_page((unsigned long)buf[i]);
269
270 return -ENOMEM;
271}
272
273static void testmgr_free_buf(char *buf[XBUFSIZE])
274{
275 int i;
276
277 for (i = 0; i < XBUFSIZE; i++)
278 free_page((unsigned long)buf[i]);
279}
280
281static void sg_init_aead(struct scatterlist *sg, char *xbuf[XBUFSIZE],
282 unsigned int buflen)
283{
284 int np = (buflen + PAGE_SIZE - 1)/PAGE_SIZE;
285 int k, rem;
286
53f52d7a
TC		 287 if (np > XBUFSIZE) {
288 rem = PAGE_SIZE;
289 np = XBUFSIZE;
c4768993
CS		 290 } else {
291 rem = buflen % PAGE_SIZE;
53f52d7a 292 }
c4768993 293
31267270 294 sg_init_table(sg, np + 1);
c4768993
CS		 295 np--;
296 for (k = 0; k < np; k++)
31267270 297 sg_set_buf(&sg[k + 1], xbuf[k], PAGE_SIZE);
c4768993 298
31267270 299 sg_set_buf(&sg[k + 1], xbuf[k], rem);
53f52d7a
TC		 300}
301
3e3dc25f 302static void test_aead_speed(const char *algo, int enc, unsigned int secs,
53f52d7a
TC		 303 struct aead_speed_template *template,
304 unsigned int tcount, u8 authsize,
305 unsigned int aad_size, u8 *keysize)
306{
307 unsigned int i, j;
308 struct crypto_aead *tfm;
309 int ret = -ENOMEM;
310 const char *key;
311 struct aead_request *req;
312 struct scatterlist *sg;
53f52d7a
TC		 313 struct scatterlist *sgout;
314 const char *e;
315 void *assoc;
96692a73 316 char *iv;
53f52d7a
TC		 317 char *xbuf[XBUFSIZE];
318 char *xoutbuf[XBUFSIZE];
319 char *axbuf[XBUFSIZE];
320 unsigned int *b_size;
321 unsigned int iv_len;
1425d2d1 322 struct tcrypt_result result;
53f52d7a 323
96692a73
CS		 324 iv = kzalloc(MAX_IVLEN, GFP_KERNEL);
325 if (!iv)
326 return;
327
ac5f863f
CE		 328 if (aad_size >= PAGE_SIZE) {
329 pr_err("associate data length (%u) too big\n", aad_size);
96692a73 330 goto out_noxbuf;
ac5f863f
CE		 331 }
332
53f52d7a
TC		 333 if (enc == ENCRYPT)
334 e = "encryption";
335 else
336 e = "decryption";
337
338 if (testmgr_alloc_buf(xbuf))
339 goto out_noxbuf;
340 if (testmgr_alloc_buf(axbuf))
341 goto out_noaxbuf;
342 if (testmgr_alloc_buf(xoutbuf))
343 goto out_nooutbuf;
344
a3f2185a 345 sg = kmalloc(sizeof(*sg) * 9 * 2, GFP_KERNEL);
53f52d7a
TC		 346 if (!sg)
347 goto out_nosg;
a3f2185a 348 sgout = &sg[9];
53f52d7a 349
5e4b8c1f 350 tfm = crypto_alloc_aead(algo, 0, 0);
53f52d7a
TC		 351
352 if (IS_ERR(tfm)) {
353 pr_err("alg: aead: Failed to load transform for %s: %ld\n", algo,
354 PTR_ERR(tfm));
a2ea6ed6 355 goto out_notfm;
53f52d7a
TC		 356 }
357
1425d2d1 358 init_completion(&result.completion);
263a8df0
LC		 359 printk(KERN_INFO "\ntesting speed of %s (%s) %s\n", algo,
360 get_driver_name(crypto_aead, tfm), e);
361
53f52d7a
TC		 362 req = aead_request_alloc(tfm, GFP_KERNEL);
363 if (!req) {
364 pr_err("alg: aead: Failed to allocate request for %s\n",
365 algo);
6af1f93e 366 goto out_noreq;
53f52d7a
TC		 367 }
368
1425d2d1
VL		 369 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
370 tcrypt_complete, &result);
371
53f52d7a
TC		 372 i = 0;
373 do {
374 b_size = aead_sizes;
375 do {
376 assoc = axbuf[0];
ac5f863f 377 memset(assoc, 0xff, aad_size);
53f52d7a
TC		 378
379 if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
380 pr_err("template (%u) too big for tvmem (%lu)\n",
381 *keysize + *b_size,
382 TVMEMSIZE * PAGE_SIZE);
383 goto out;
384 }
385
386 key = tvmem[0];
387 for (j = 0; j < tcount; j++) {
388 if (template[j].klen == *keysize) {
389 key = template[j].key;
390 break;
391 }
392 }
393 ret = crypto_aead_setkey(tfm, key, *keysize);
394 ret = crypto_aead_setauthsize(tfm, authsize);
395
396 iv_len = crypto_aead_ivsize(tfm);
397 if (iv_len)
96692a73 398 memset(iv, 0xff, iv_len);
53f52d7a
TC		 399
400 crypto_aead_clear_flags(tfm, ~0);
401 printk(KERN_INFO "test %u (%d bit key, %d byte blocks): ",
402 i, *keysize * 8, *b_size);
403
404
405 memset(tvmem[0], 0xff, PAGE_SIZE);
406
407 if (ret) {
408 pr_err("setkey() failed flags=%x\n",
409 crypto_aead_get_flags(tfm));
410 goto out;
411 }
412
31267270 413 sg_init_aead(sg, xbuf,
53f52d7a
TC		 414 *b_size + (enc ? authsize : 0));
415
31267270 416 sg_init_aead(sgout, xoutbuf,
53f52d7a
TC		 417 *b_size + (enc ? authsize : 0));
418
31267270
HX		 419 sg_set_buf(&sg[0], assoc, aad_size);
420 sg_set_buf(&sgout[0], assoc, aad_size);
421
53f52d7a 422 aead_request_set_crypt(req, sg, sgout, *b_size, iv);
a3f2185a 423 aead_request_set_ad(req, aad_size);
53f52d7a 424
3e3dc25f
MR		 425 if (secs)
426 ret = test_aead_jiffies(req, enc, *b_size,
427 secs);
53f52d7a
TC		 428 else
429 ret = test_aead_cycles(req, enc, *b_size);
430
431 if (ret) {
432 pr_err("%s() failed return code=%d\n", e, ret);
433 break;
434 }
435 b_size++;
436 i++;
437 } while (*b_size);
438 keysize++;
439 } while (*keysize);
440
441out:
6af1f93e
CE		 442 aead_request_free(req);
443out_noreq:
53f52d7a 444 crypto_free_aead(tfm);
a2ea6ed6 445out_notfm:
53f52d7a
TC		 446 kfree(sg);
447out_nosg:
448 testmgr_free_buf(xoutbuf);
449out_nooutbuf:
450 testmgr_free_buf(axbuf);
451out_noaxbuf:
452 testmgr_free_buf(xbuf);
453out_noxbuf:
96692a73 454 kfree(iv);
53f52d7a
TC		 455 return;
456}
d5dc3927 457
3e3dc25f 458static void test_cipher_speed(const char *algo, int enc, unsigned int secs,
da7f033d 459 struct cipher_speed_template *template,
d5dc3927 460 unsigned int tcount, u8 *keysize)
ebfd9bcf 461{
dce907c0 462 unsigned int ret, i, j, iv_len;
f07ef1de
DS		 463 const char *key;
464 char iv[128];
cba83564
HX		 465 struct crypto_blkcipher *tfm;
466 struct blkcipher_desc desc;
467 const char *e;
d5dc3927 468 u32 *b_size;
ebfd9bcf
HW		 469
470 if (enc == ENCRYPT)
471 e = "encryption";
472 else
473 e = "decryption";
ebfd9bcf 474
cba83564 475 tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);
ebfd9bcf 476
cba83564
HX		 477 if (IS_ERR(tfm)) {
478 printk("failed to load transform for %s: %ld\n", algo,
479 PTR_ERR(tfm));
ebfd9bcf
HW		 480 return;
481 }
cba83564
HX		 482 desc.tfm = tfm;
483 desc.flags = 0;
ebfd9bcf 484
263a8df0
LC		 485 printk(KERN_INFO "\ntesting speed of %s (%s) %s\n", algo,
486 get_driver_name(crypto_blkcipher, tfm), e);
487
d5dc3927
SS		 488 i = 0;
489 do {
ebfd9bcf 490
d5dc3927
SS		 491 b_size = block_sizes;
492 do {
f139cfa7 493 struct scatterlist sg[TVMEMSIZE];
ebfd9bcf 494
f139cfa7
HX		 495 if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
496 printk("template (%u) too big for "
497 "tvmem (%lu)\n", *keysize + *b_size,
498 TVMEMSIZE * PAGE_SIZE);
d5dc3927
SS		 499 goto out;
500 }
ebfd9bcf 501
d5dc3927
SS		 502 printk("test %u (%d bit key, %d byte blocks): ", i,
503 *keysize * 8, *b_size);
504
f139cfa7 505 memset(tvmem[0], 0xff, PAGE_SIZE);
d5dc3927
SS		 506
507 /* set key, plain text and IV */
da7f033d 508 key = tvmem[0];
d5dc3927
SS		 509 for (j = 0; j < tcount; j++) {
510 if (template[j].klen == *keysize) {
511 key = template[j].key;
512 break;
513 }
dce907c0 514 }
ebfd9bcf 515
d5dc3927
SS		 516 ret = crypto_blkcipher_setkey(tfm, key, *keysize);
517 if (ret) {
518 printk("setkey() failed flags=%x\n",
519 crypto_blkcipher_get_flags(tfm));
520 goto out;
521 }
ebfd9bcf 522
f139cfa7
HX		 523 sg_init_table(sg, TVMEMSIZE);
524 sg_set_buf(sg, tvmem[0] + *keysize,
525 PAGE_SIZE - *keysize);
526 for (j = 1; j < TVMEMSIZE; j++) {
527 sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
528 memset (tvmem[j], 0xff, PAGE_SIZE);
529 }
530
d5dc3927
SS		 531 iv_len = crypto_blkcipher_ivsize(tfm);
532 if (iv_len) {
533 memset(&iv, 0xff, iv_len);
534 crypto_blkcipher_set_iv(tfm, iv, iv_len);
535 }
ebfd9bcf 536
3e3dc25f 537 if (secs)
f139cfa7 538 ret = test_cipher_jiffies(&desc, enc, sg,
3e3dc25f 539 *b_size, secs);
d5dc3927 540 else
f139cfa7
HX		 541 ret = test_cipher_cycles(&desc, enc, sg,
542 *b_size);
ebfd9bcf 543
d5dc3927
SS		 544 if (ret) {
545 printk("%s() failed flags=%x\n", e, desc.flags);
546 break;
547 }
548 b_size++;
549 i++;
550 } while (*b_size);
551 keysize++;
552 } while (*keysize);
ebfd9bcf
HW		 553
554out:
cba83564 555 crypto_free_blkcipher(tfm);
ebfd9bcf
HW		 556}
557
beb63da7
DM		 558static void test_hash_sg_init(struct scatterlist *sg)
559{
560 int i;
561
562 sg_init_table(sg, TVMEMSIZE);
563 for (i = 0; i < TVMEMSIZE; i++) {
564 sg_set_buf(sg + i, tvmem[i], PAGE_SIZE);
565 memset(tvmem[i], 0xff, PAGE_SIZE);
566 }
567}
568
beb63da7
DM		 569static inline int do_one_ahash_op(struct ahash_request *req, int ret)
570{
571 if (ret == -EINPROGRESS || ret == -EBUSY) {
572 struct tcrypt_result *tr = req->base.data;
573
8a45ac12 574 wait_for_completion(&tr->completion);
16735d02 575 reinit_completion(&tr->completion);
8a45ac12 576 ret = tr->err;
beb63da7
DM		 577 }
578 return ret;
579}
580
72259deb
HX		 581struct test_mb_ahash_data {
582 struct scatterlist sg[TVMEMSIZE];
583 char result[64];
584 struct ahash_request *req;
585 struct tcrypt_result tresult;
586 char *xbuf[XBUFSIZE];
587};
087bcd22
MD		 588
589static void test_mb_ahash_speed(const char *algo, unsigned int sec,
72259deb 590 struct hash_speed *speed)
087bcd22 591{
72259deb 592 struct test_mb_ahash_data *data;
087bcd22 593 struct crypto_ahash *tfm;
72259deb 594 unsigned long start, end;
f8de55b6 595 unsigned long cycles;
72259deb
HX		 596 unsigned int i, j, k;
597 int ret;
598
599 data = kzalloc(sizeof(*data) * 8, GFP_KERNEL);
600 if (!data)
601 return;
087bcd22
MD		 602
603 tfm = crypto_alloc_ahash(algo, 0, 0);
604 if (IS_ERR(tfm)) {
605 pr_err("failed to load transform for %s: %ld\n",
606 algo, PTR_ERR(tfm));
72259deb 607 goto free_data;
087bcd22 608 }
72259deb 609
087bcd22 610 for (i = 0; i < 8; ++i) {
72259deb
HX		 611 if (testmgr_alloc_buf(data[i].xbuf))
612 goto out;
087bcd22 613
72259deb 614 init_completion(&data[i].tresult.completion);
087bcd22 615
72259deb
HX		 616 data[i].req = ahash_request_alloc(tfm, GFP_KERNEL);
617 if (!data[i].req) {
f83f5b12
KK		 618 pr_err("alg: hash: Failed to allocate request for %s\n",
619 algo);
72259deb 620 goto out;
087bcd22 621 }
087bcd22 622
72259deb
HX		 623 ahash_request_set_callback(data[i].req, 0,
624 tcrypt_complete, &data[i].tresult);
625 test_hash_sg_init(data[i].sg);
087bcd22
MD		 626 }
627
72259deb
HX		 628 pr_info("\ntesting speed of multibuffer %s (%s)\n", algo,
629 get_driver_name(crypto_ahash, tfm));
087bcd22
MD		 630
631 for (i = 0; speed[i].blen != 0; i++) {
72259deb
HX		 632 /* For some reason this only tests digests. */
633 if (speed[i].blen != speed[i].plen)
634 continue;
635
087bcd22 636 if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
f83f5b12
KK		 637 pr_err("template (%u) too big for tvmem (%lu)\n",
638 speed[i].blen, TVMEMSIZE * PAGE_SIZE);
639 goto out;
087bcd22
MD		 640 }
641
642 if (speed[i].klen)
643 crypto_ahash_setkey(tfm, tvmem[0], speed[i].klen);
644
72259deb
HX		 645 for (k = 0; k < 8; k++)
646 ahash_request_set_crypt(data[k].req, data[k].sg,
647 data[k].result, speed[i].blen);
087bcd22 648
72259deb
HX		 649 pr_info("test%3u "
650 "(%5u byte blocks,%5u bytes per update,%4u updates): ",
087bcd22
MD		 651 i, speed[i].blen, speed[i].plen,
652 speed[i].blen / speed[i].plen);
653
72259deb
HX		 654 start = get_cycles();
655
656 for (k = 0; k < 8; k++) {
657 ret = crypto_ahash_digest(data[k].req);
658 if (ret == -EINPROGRESS)
087bcd22 659 continue;
72259deb
HX		 660
661 if (ret)
662 break;
663
664 complete(&data[k].tresult.completion);
665 data[k].tresult.err = 0;
087bcd22 666 }
087bcd22 667
72259deb
HX		 668 for (j = 0; j < k; j++) {
669 struct tcrypt_result *tr = &data[j].tresult;
087bcd22 670
72259deb
HX		 671 wait_for_completion(&tr->completion);
672 if (tr->err)
673 ret = tr->err;
087bcd22
MD		 674 }
675
72259deb
HX		 676 end = get_cycles();
677 cycles = end - start;
678 pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
679 cycles, cycles / (8 * speed[i].blen));
680
681 if (ret) {
682 pr_err("At least one hashing failed ret=%d\n", ret);
683 break;
684 }
087bcd22 685 }
087bcd22
MD		 686
687out:
688 for (k = 0; k < 8; ++k)
72259deb
HX		 689 ahash_request_free(data[k].req);
690
087bcd22 691 for (k = 0; k < 8; ++k)
72259deb
HX		 692 testmgr_free_buf(data[k].xbuf);
693
694 crypto_free_ahash(tfm);
695
696free_data:
697 kfree(data);
087bcd22
MD		 698}
699
beb63da7 700static int test_ahash_jiffies_digest(struct ahash_request *req, int blen,
3e3dc25f 701 char *out, int secs)
beb63da7
DM		 702{
703 unsigned long start, end;
704 int bcount;
705 int ret;
706
3e3dc25f 707 for (start = jiffies, end = start + secs * HZ, bcount = 0;
beb63da7
DM		 708 time_before(jiffies, end); bcount++) {
709 ret = do_one_ahash_op(req, crypto_ahash_digest(req));
710 if (ret)
711 return ret;
712 }
713
714 printk("%6u opers/sec, %9lu bytes/sec\n",
3e3dc25f 715 bcount / secs, ((long)bcount * blen) / secs);
beb63da7
DM		 716
717 return 0;
718}
719
720static int test_ahash_jiffies(struct ahash_request *req, int blen,
3e3dc25f 721 int plen, char *out, int secs)
beb63da7
DM		 722{
723 unsigned long start, end;
724 int bcount, pcount;
725 int ret;
726
727 if (plen == blen)
3e3dc25f 728 return test_ahash_jiffies_digest(req, blen, out, secs);
beb63da7 729
3e3dc25f 730 for (start = jiffies, end = start + secs * HZ, bcount = 0;
beb63da7 731 time_before(jiffies, end); bcount++) {
43a9607d 732 ret = do_one_ahash_op(req, crypto_ahash_init(req));
beb63da7
DM		 733 if (ret)
734 return ret;
735 for (pcount = 0; pcount < blen; pcount += plen) {
736 ret = do_one_ahash_op(req, crypto_ahash_update(req));
737 if (ret)
738 return ret;
739 }
740 /* we assume there is enough space in 'out' for the result */
741 ret = do_one_ahash_op(req, crypto_ahash_final(req));
742 if (ret)
743 return ret;
744 }
745
746 pr_cont("%6u opers/sec, %9lu bytes/sec\n",
3e3dc25f 747 bcount / secs, ((long)bcount * blen) / secs);
beb63da7
DM		 748
749 return 0;
750}
751
752static int test_ahash_cycles_digest(struct ahash_request *req, int blen,
753 char *out)
754{
755 unsigned long cycles = 0;
756 int ret, i;
757
758 /* Warm-up run. */
759 for (i = 0; i < 4; i++) {
760 ret = do_one_ahash_op(req, crypto_ahash_digest(req));
761 if (ret)
762 goto out;
763 }
764
765 /* The real thing. */
766 for (i = 0; i < 8; i++) {
767 cycles_t start, end;
768
769 start = get_cycles();
770
771 ret = do_one_ahash_op(req, crypto_ahash_digest(req));
772 if (ret)
773 goto out;
774
775 end = get_cycles();
776
777 cycles += end - start;
778 }
779
780out:
781 if (ret)
782 return ret;
783
784 pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
785 cycles / 8, cycles / (8 * blen));
786
787 return 0;
788}
789
790static int test_ahash_cycles(struct ahash_request *req, int blen,
791 int plen, char *out)
792{
793 unsigned long cycles = 0;
794 int i, pcount, ret;
795
796 if (plen == blen)
797 return test_ahash_cycles_digest(req, blen, out);
798
799 /* Warm-up run. */
800 for (i = 0; i < 4; i++) {
43a9607d 801 ret = do_one_ahash_op(req, crypto_ahash_init(req));
beb63da7
DM		 802 if (ret)
803 goto out;
804 for (pcount = 0; pcount < blen; pcount += plen) {
805 ret = do_one_ahash_op(req, crypto_ahash_update(req));
806 if (ret)
807 goto out;
808 }
809 ret = do_one_ahash_op(req, crypto_ahash_final(req));
810 if (ret)
811 goto out;
812 }
813
814 /* The real thing. */
815 for (i = 0; i < 8; i++) {
816 cycles_t start, end;
817
818 start = get_cycles();
819
43a9607d 820 ret = do_one_ahash_op(req, crypto_ahash_init(req));
beb63da7
DM		 821 if (ret)
822 goto out;
823 for (pcount = 0; pcount < blen; pcount += plen) {
824 ret = do_one_ahash_op(req, crypto_ahash_update(req));
825 if (ret)
826 goto out;
827 }
828 ret = do_one_ahash_op(req, crypto_ahash_final(req));
829 if (ret)
830 goto out;
831
832 end = get_cycles();
833
834 cycles += end - start;
835 }
836
837out:
838 if (ret)
839 return ret;
840
841 pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
842 cycles / 8, cycles / (8 * blen));
843
844 return 0;
845}
846
0660511c
HX		 847static void test_ahash_speed_common(const char *algo, unsigned int secs,
848 struct hash_speed *speed, unsigned mask)
beb63da7
DM		 849{
850 struct scatterlist sg[TVMEMSIZE];
851 struct tcrypt_result tresult;
852 struct ahash_request *req;
853 struct crypto_ahash *tfm;
f074f7b1 854 char *output;
beb63da7
DM		 855 int i, ret;
856
0660511c 857 tfm = crypto_alloc_ahash(algo, 0, mask);
beb63da7
DM		 858 if (IS_ERR(tfm)) {
859 pr_err("failed to load transform for %s: %ld\n",
860 algo, PTR_ERR(tfm));
861 return;
862 }
863
263a8df0
LC		 864 printk(KERN_INFO "\ntesting speed of async %s (%s)\n", algo,
865 get_driver_name(crypto_ahash, tfm));
866
f074f7b1
HG		 867 if (crypto_ahash_digestsize(tfm) > MAX_DIGEST_SIZE) {
868 pr_err("digestsize(%u) > %d\n", crypto_ahash_digestsize(tfm),
869 MAX_DIGEST_SIZE);
beb63da7
DM		 870 goto out;
871 }
872
873 test_hash_sg_init(sg);
874 req = ahash_request_alloc(tfm, GFP_KERNEL);
875 if (!req) {
876 pr_err("ahash request allocation failure\n");
877 goto out;
878 }
879
880 init_completion(&tresult.completion);
881 ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
882 tcrypt_complete, &tresult);
883
f074f7b1
HG		 884 output = kmalloc(MAX_DIGEST_SIZE, GFP_KERNEL);
885 if (!output)
886 goto out_nomem;
887
beb63da7
DM		 888 for (i = 0; speed[i].blen != 0; i++) {
889 if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
890 pr_err("template (%u) too big for tvmem (%lu)\n",
891 speed[i].blen, TVMEMSIZE * PAGE_SIZE);
892 break;
893 }
894
895 pr_info("test%3u "
896 "(%5u byte blocks,%5u bytes per update,%4u updates): ",
897 i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
898
899 ahash_request_set_crypt(req, sg, output, speed[i].plen);
900
3e3dc25f 901 if (secs)
beb63da7 902 ret = test_ahash_jiffies(req, speed[i].blen,
3e3dc25f 903 speed[i].plen, output, secs);
beb63da7
DM		 904 else
905 ret = test_ahash_cycles(req, speed[i].blen,
906 speed[i].plen, output);
907
908 if (ret) {
909 pr_err("hashing failed ret=%d\n", ret);
910 break;
911 }
912 }
913
f074f7b1
HG		 914 kfree(output);
915
916out_nomem:
beb63da7
DM		 917 ahash_request_free(req);
918
919out:
920 crypto_free_ahash(tfm);
921}
922
0660511c
HX		 923static void test_ahash_speed(const char *algo, unsigned int secs,
924 struct hash_speed *speed)
925{
926 return test_ahash_speed_common(algo, secs, speed, 0);
927}
928
929static void test_hash_speed(const char *algo, unsigned int secs,
930 struct hash_speed *speed)
931{
932 return test_ahash_speed_common(algo, secs, speed, CRYPTO_ALG_ASYNC);
933}
934
3f3baf35
JK		 935static inline int do_one_acipher_op(struct ablkcipher_request *req, int ret)
936{
937 if (ret == -EINPROGRESS || ret == -EBUSY) {
938 struct tcrypt_result *tr = req->base.data;
939
8a45ac12 940 wait_for_completion(&tr->completion);
16735d02 941 reinit_completion(&tr->completion);
8a45ac12 942 ret = tr->err;
3f3baf35
JK		 943 }
944
945 return ret;
946}
947
948static int test_acipher_jiffies(struct ablkcipher_request *req, int enc,
3e3dc25f 949 int blen, int secs)
3f3baf35
JK		 950{
951 unsigned long start, end;
952 int bcount;
953 int ret;
954
3e3dc25f 955 for (start = jiffies, end = start + secs * HZ, bcount = 0;
3f3baf35
JK		 956 time_before(jiffies, end); bcount++) {
957 if (enc)
958 ret = do_one_acipher_op(req,
959 crypto_ablkcipher_encrypt(req));
960 else
961 ret = do_one_acipher_op(req,
962 crypto_ablkcipher_decrypt(req));
963
964 if (ret)
965 return ret;
966 }
967
968 pr_cont("%d operations in %d seconds (%ld bytes)\n",
3e3dc25f 969 bcount, secs, (long)bcount * blen);
3f3baf35
JK		 970 return 0;
971}
972
973static int test_acipher_cycles(struct ablkcipher_request *req, int enc,
974 int blen)
975{
976 unsigned long cycles = 0;
977 int ret = 0;
978 int i;
979
980 /* Warm-up run. */
981 for (i = 0; i < 4; i++) {
982 if (enc)
983 ret = do_one_acipher_op(req,
984 crypto_ablkcipher_encrypt(req));
985 else
986 ret = do_one_acipher_op(req,
987 crypto_ablkcipher_decrypt(req));
988
989 if (ret)
990 goto out;
991 }
992
993 /* The real thing. */
994 for (i = 0; i < 8; i++) {
995 cycles_t start, end;
996
997 start = get_cycles();
998 if (enc)
999 ret = do_one_acipher_op(req,
1000 crypto_ablkcipher_encrypt(req));
1001 else
1002 ret = do_one_acipher_op(req,
1003 crypto_ablkcipher_decrypt(req));
1004 end = get_cycles();
1005
1006 if (ret)
1007 goto out;
1008
1009 cycles += end - start;
1010 }
1011
1012out:
1013 if (ret == 0)
1014 pr_cont("1 operation in %lu cycles (%d bytes)\n",
1015 (cycles + 4) / 8, blen);
1016
1017 return ret;
1018}
1019
3e3dc25f 1020static void test_acipher_speed(const char *algo, int enc, unsigned int secs,
3f3baf35
JK		 1021 struct cipher_speed_template *template,
1022 unsigned int tcount, u8 *keysize)
1023{
de197533 1024 unsigned int ret, i, j, k, iv_len;
3f3baf35
JK		 1025 struct tcrypt_result tresult;
1026 const char *key;
1027 char iv[128];
1028 struct ablkcipher_request *req;
1029 struct crypto_ablkcipher *tfm;
1030 const char *e;
1031 u32 *b_size;
1032
1033 if (enc == ENCRYPT)
1034 e = "encryption";
1035 else
1036 e = "decryption";
1037
3f3baf35
JK		 1038 init_completion(&tresult.completion);
1039
1040 tfm = crypto_alloc_ablkcipher(algo, 0, 0);
1041
1042 if (IS_ERR(tfm)) {
1043 pr_err("failed to load transform for %s: %ld\n", algo,
1044 PTR_ERR(tfm));
1045 return;
1046 }
1047
263a8df0
LC		 1048 pr_info("\ntesting speed of async %s (%s) %s\n", algo,
1049 get_driver_name(crypto_ablkcipher, tfm), e);
1050
3f3baf35
JK		 1051 req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
1052 if (!req) {
1053 pr_err("tcrypt: skcipher: Failed to allocate request for %s\n",
1054 algo);
1055 goto out;
1056 }
1057
1058 ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1059 tcrypt_complete, &tresult);
1060
1061 i = 0;
1062 do {
1063 b_size = block_sizes;
1064
1065 do {
1066 struct scatterlist sg[TVMEMSIZE];
1067
1068 if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
1069 pr_err("template (%u) too big for "
1070 "tvmem (%lu)\n", *keysize + *b_size,
1071 TVMEMSIZE * PAGE_SIZE);
1072 goto out_free_req;
1073 }
1074
1075 pr_info("test %u (%d bit key, %d byte blocks): ", i,
1076 *keysize * 8, *b_size);
1077
1078 memset(tvmem[0], 0xff, PAGE_SIZE);
1079
1080 /* set key, plain text and IV */
1081 key = tvmem[0];
1082 for (j = 0; j < tcount; j++) {
1083 if (template[j].klen == *keysize) {
1084 key = template[j].key;
1085 break;
1086 }
1087 }
1088
1089 crypto_ablkcipher_clear_flags(tfm, ~0);
1090
1091 ret = crypto_ablkcipher_setkey(tfm, key, *keysize);
1092 if (ret) {
1093 pr_err("setkey() failed flags=%x\n",
1094 crypto_ablkcipher_get_flags(tfm));
1095 goto out_free_req;
1096 }
1097
de197533 1098 k = *keysize + *b_size;
007ee8de
HG		 1099 sg_init_table(sg, DIV_ROUND_UP(k, PAGE_SIZE));
1100
de197533
NR		 1101 if (k > PAGE_SIZE) {
1102 sg_set_buf(sg, tvmem[0] + *keysize,
3f3baf35 1103 PAGE_SIZE - *keysize);
de197533
NR		 1104 k -= PAGE_SIZE;
1105 j = 1;
1106 while (k > PAGE_SIZE) {
1107 sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
1108 memset(tvmem[j], 0xff, PAGE_SIZE);
1109 j++;
1110 k -= PAGE_SIZE;
1111 }
1112 sg_set_buf(sg + j, tvmem[j], k);
1113 memset(tvmem[j], 0xff, k);
1114 } else {
1115 sg_set_buf(sg, tvmem[0] + *keysize, *b_size);
3f3baf35
JK		 1116 }
1117
1118 iv_len = crypto_ablkcipher_ivsize(tfm);
1119 if (iv_len)
1120 memset(&iv, 0xff, iv_len);
1121
1122 ablkcipher_request_set_crypt(req, sg, sg, *b_size, iv);
1123
3e3dc25f 1124 if (secs)
3f3baf35 1125 ret = test_acipher_jiffies(req, enc,
3e3dc25f 1126 *b_size, secs);
3f3baf35
JK		 1127 else
1128 ret = test_acipher_cycles(req, enc,
1129 *b_size);
1130
1131 if (ret) {
1132 pr_err("%s() failed flags=%x\n", e,
1133 crypto_ablkcipher_get_flags(tfm));
1134 break;
1135 }
1136 b_size++;
1137 i++;
1138 } while (*b_size);
1139 keysize++;
1140 } while (*keysize);
1141
1142out_free_req:
1143 ablkcipher_request_free(req);
1144out:
1145 crypto_free_ablkcipher(tfm);
1146}
1147
ef2736fc 1148static void test_available(void)
1da177e4
LT		 1149{
1150 char **name = check;
ef2736fc 1151
1da177e4
LT		 1152 while (*name) {
1153 printk("alg %s ", *name);
6158efc0 1154 printk(crypto_has_alg(*name, 0, 0) ?
e4d5b79c 1155 "found\n" : "not found\n");
1da177e4 1156 name++;
ef2736fc 1157 }
1da177e4
LT		 1158}
1159
01b32324
HX		 1160static inline int tcrypt_test(const char *alg)
1161{
4e033a6b
JW		 1162 int ret;
1163
1164 ret = alg_test(alg, alg, 0, 0);
1165 /* non-fips algs return -EINVAL in fips mode */
1166 if (fips_enabled && ret == -EINVAL)
1167 ret = 0;
1168 return ret;
01b32324
HX		 1169}
1170
8606813a 1171static int do_test(const char *alg, u32 type, u32 mask, int m)
01b32324
HX		 1172{
1173 int i;
4e033a6b 1174 int ret = 0;
01b32324
HX		 1175
1176 switch (m) {
1da177e4 1177 case 0:
8606813a
HX		 1178 if (alg) {
1179 if (!crypto_has_alg(alg, type,
1180 mask ?: CRYPTO_ALG_TYPE_MASK))
1181 ret = -ENOENT;
1182 break;
1183 }
1184
01b32324 1185 for (i = 1; i < 200; i++)
8606813a 1186 ret += do_test(NULL, 0, 0, i);
1da177e4
LT		 1187 break;
1188
1189 case 1:
4e033a6b 1190 ret += tcrypt_test("md5");
1da177e4
LT		 1191 break;
1192
1193 case 2:
4e033a6b 1194 ret += tcrypt_test("sha1");
1da177e4
LT		 1195 break;
1196
1197 case 3:
4e033a6b
JW		 1198 ret += tcrypt_test("ecb(des)");
1199 ret += tcrypt_test("cbc(des)");
8163fc30 1200 ret += tcrypt_test("ctr(des)");
1da177e4
LT		 1201 break;
1202
1203 case 4:
4e033a6b
JW		 1204 ret += tcrypt_test("ecb(des3_ede)");
1205 ret += tcrypt_test("cbc(des3_ede)");
e080b17a 1206 ret += tcrypt_test("ctr(des3_ede)");
1da177e4
LT		 1207 break;
1208
1209 case 5:
4e033a6b 1210 ret += tcrypt_test("md4");
1da177e4 1211 break;
ef2736fc 1212
1da177e4 1213 case 6:
4e033a6b 1214 ret += tcrypt_test("sha256");
1da177e4 1215 break;
ef2736fc 1216
1da177e4 1217 case 7:
4e033a6b
JW		 1218 ret += tcrypt_test("ecb(blowfish)");
1219 ret += tcrypt_test("cbc(blowfish)");
85b63e34 1220 ret += tcrypt_test("ctr(blowfish)");
1da177e4
LT		 1221 break;
1222
1223 case 8:
4e033a6b
JW		 1224 ret += tcrypt_test("ecb(twofish)");
1225 ret += tcrypt_test("cbc(twofish)");
573da620 1226 ret += tcrypt_test("ctr(twofish)");
bee3a90e 1227 ret += tcrypt_test("lrw(twofish)");
131f7541 1228 ret += tcrypt_test("xts(twofish)");
1da177e4 1229 break;
ef2736fc 1230
1da177e4 1231 case 9:
4e033a6b 1232 ret += tcrypt_test("ecb(serpent)");
9d25917d
JK		 1233 ret += tcrypt_test("cbc(serpent)");
1234 ret += tcrypt_test("ctr(serpent)");
87aae4bf 1235 ret += tcrypt_test("lrw(serpent)");
5209c07a 1236 ret += tcrypt_test("xts(serpent)");
1da177e4
LT		 1237 break;
1238
1239 case 10:
4e033a6b
JW		 1240 ret += tcrypt_test("ecb(aes)");
1241 ret += tcrypt_test("cbc(aes)");
1242 ret += tcrypt_test("lrw(aes)");
1243 ret += tcrypt_test("xts(aes)");
1244 ret += tcrypt_test("ctr(aes)");
1245 ret += tcrypt_test("rfc3686(ctr(aes))");
1da177e4
LT		 1246 break;
1247
1248 case 11:
4e033a6b 1249 ret += tcrypt_test("sha384");
1da177e4 1250 break;
ef2736fc 1251
1da177e4 1252 case 12:
4e033a6b 1253 ret += tcrypt_test("sha512");
1da177e4
LT		 1254 break;
1255
1256 case 13:
4e033a6b 1257 ret += tcrypt_test("deflate");
1da177e4
LT		 1258 break;
1259
1260 case 14:
4e033a6b 1261 ret += tcrypt_test("ecb(cast5)");
a2c58260
JG		 1262 ret += tcrypt_test("cbc(cast5)");
1263 ret += tcrypt_test("ctr(cast5)");
1da177e4
LT		 1264 break;
1265
1266 case 15:
4e033a6b 1267 ret += tcrypt_test("ecb(cast6)");
9b8b0405
JG		 1268 ret += tcrypt_test("cbc(cast6)");
1269 ret += tcrypt_test("ctr(cast6)");
1270 ret += tcrypt_test("lrw(cast6)");
1271 ret += tcrypt_test("xts(cast6)");
1da177e4
LT		 1272 break;
1273
1274 case 16:
4e033a6b 1275 ret += tcrypt_test("ecb(arc4)");
1da177e4
LT		 1276 break;
1277
1278 case 17:
4e033a6b 1279 ret += tcrypt_test("michael_mic");
1da177e4
LT		 1280 break;
1281
1282 case 18:
4e033a6b 1283 ret += tcrypt_test("crc32c");
1da177e4
LT		 1284 break;
1285
1286 case 19:
4e033a6b 1287 ret += tcrypt_test("ecb(tea)");
1da177e4
LT		 1288 break;
1289
1290 case 20:
4e033a6b 1291 ret += tcrypt_test("ecb(xtea)");
1da177e4
LT		 1292 break;
1293
1294 case 21:
4e033a6b 1295 ret += tcrypt_test("ecb(khazad)");
1da177e4
LT		 1296 break;
1297
1298 case 22:
4e033a6b 1299 ret += tcrypt_test("wp512");
1da177e4
LT		 1300 break;
1301
1302 case 23:
4e033a6b 1303 ret += tcrypt_test("wp384");
1da177e4
LT		 1304 break;
1305
1306 case 24:
4e033a6b 1307 ret += tcrypt_test("wp256");
1da177e4
LT		 1308 break;
1309
1310 case 25:
4e033a6b 1311 ret += tcrypt_test("ecb(tnepres)");
1da177e4
LT		 1312 break;
1313
1314 case 26:
4e033a6b
JW		 1315 ret += tcrypt_test("ecb(anubis)");
1316 ret += tcrypt_test("cbc(anubis)");
1da177e4
LT		 1317 break;
1318
1319 case 27:
4e033a6b 1320 ret += tcrypt_test("tgr192");
1da177e4
LT		 1321 break;
1322
1323 case 28:
4e033a6b 1324 ret += tcrypt_test("tgr160");
1da177e4
LT		 1325 break;
1326
1327 case 29:
4e033a6b 1328 ret += tcrypt_test("tgr128");
1da177e4 1329 break;
2998db37 1330
fb4f10ed 1331 case 30:
4e033a6b 1332 ret += tcrypt_test("ecb(xeta)");
fb4f10ed 1333 break;
1da177e4 1334
90831639 1335 case 31:
4e033a6b 1336 ret += tcrypt_test("pcbc(fcrypt)");
90831639
DH		 1337 break;
1338
02ab5a70 1339 case 32:
4e033a6b
JW		 1340 ret += tcrypt_test("ecb(camellia)");
1341 ret += tcrypt_test("cbc(camellia)");
54216bbd
JK		 1342 ret += tcrypt_test("ctr(camellia)");
1343 ret += tcrypt_test("lrw(camellia)");
1344 ret += tcrypt_test("xts(camellia)");
02ab5a70 1345 break;
93b5e86a 1346
cd12fb90 1347 case 33:
4e033a6b 1348 ret += tcrypt_test("sha224");
cd12fb90 1349 break;
02ab5a70 1350
2407d608 1351 case 34:
4e033a6b 1352 ret += tcrypt_test("salsa20");
2407d608
TSH		 1353 break;
1354
8df213d9 1355 case 35:
4e033a6b 1356 ret += tcrypt_test("gcm(aes)");
8df213d9
HX		 1357 break;
1358
0b77abb3 1359 case 36:
4e033a6b 1360 ret += tcrypt_test("lzo");
0b77abb3
ZS		 1361 break;
1362
93cc74e0 1363 case 37:
4e033a6b 1364 ret += tcrypt_test("ccm(aes)");
93cc74e0
JL		 1365 break;
1366
76cb9521 1367 case 38:
4e033a6b 1368 ret += tcrypt_test("cts(cbc(aes))");
76cb9521
KC		 1369 break;
1370
fd4adf1a 1371 case 39:
4e033a6b 1372 ret += tcrypt_test("rmd128");
fd4adf1a
AKR		 1373 break;
1374
1375 case 40:
4e033a6b 1376 ret += tcrypt_test("rmd160");
fd4adf1a
AKR		 1377 break;
1378
2998db37 1379 case 41:
4e033a6b 1380 ret += tcrypt_test("rmd256");
2998db37
AKR		 1381 break;
1382
1383 case 42:
4e033a6b 1384 ret += tcrypt_test("rmd320");
01b32324
HX		 1385 break;
1386
1387 case 43:
4e033a6b 1388 ret += tcrypt_test("ecb(seed)");
2998db37
AKR		 1389 break;
1390
0c01aed5 1391 case 44:
4e033a6b 1392 ret += tcrypt_test("zlib");
0c01aed5
GU		 1393 break;
1394
5d667322 1395 case 45:
4e033a6b 1396 ret += tcrypt_test("rfc4309(ccm(aes))");
5d667322
JW		 1397 break;
1398
54216bbd
JK		 1399 case 46:
1400 ret += tcrypt_test("ghash");
1401 break;
1402
68411521
HX		 1403 case 47:
1404 ret += tcrypt_test("crct10dif");
1405 break;
1406
79cc6ab8 1407 case 48:
1408 ret += tcrypt_test("sha3-224");
1409 break;
1410
1411 case 49:
1412 ret += tcrypt_test("sha3-256");
1413 break;
1414
1415 case 50:
1416 ret += tcrypt_test("sha3-384");
1417 break;
1418
1419 case 51:
1420 ret += tcrypt_test("sha3-512");
1421 break;
1422
1da177e4 1423 case 100:
4e033a6b 1424 ret += tcrypt_test("hmac(md5)");
1da177e4 1425 break;
ef2736fc 1426
1da177e4 1427 case 101:
4e033a6b 1428 ret += tcrypt_test("hmac(sha1)");
1da177e4 1429 break;
ef2736fc 1430
1da177e4 1431 case 102:
4e033a6b 1432 ret += tcrypt_test("hmac(sha256)");
1da177e4
LT		 1433 break;
1434
a28091ae 1435 case 103:
4e033a6b 1436 ret += tcrypt_test("hmac(sha384)");
a28091ae
AD		 1437 break;
1438
1439 case 104:
4e033a6b 1440 ret += tcrypt_test("hmac(sha512)");
a28091ae 1441 break;
38ed9ab2 1442
cd12fb90 1443 case 105:
4e033a6b 1444 ret += tcrypt_test("hmac(sha224)");
cd12fb90 1445 break;
1da177e4 1446
38ed9ab2 1447 case 106:
4e033a6b 1448 ret += tcrypt_test("xcbc(aes)");
38ed9ab2
HX		 1449 break;
1450
fd4adf1a 1451 case 107:
4e033a6b 1452 ret += tcrypt_test("hmac(rmd128)");
fd4adf1a
AKR		 1453 break;
1454
1455 case 108:
4e033a6b 1456 ret += tcrypt_test("hmac(rmd160)");
fd4adf1a
AKR		 1457 break;
1458
f1939f7c
SW		 1459 case 109:
1460 ret += tcrypt_test("vmac(aes)");
1461 break;
93b5e86a 1462
a482b081
SZ		 1463 case 110:
1464 ret += tcrypt_test("hmac(crc32)");
1465 break;
f1939f7c 1466
e08ca2da 1467 case 150:
4e033a6b 1468 ret += tcrypt_test("ansi_cprng");
e08ca2da
JW		 1469 break;
1470
69435b94
AH		 1471 case 151:
1472 ret += tcrypt_test("rfc4106(gcm(aes))");
1473 break;
1474
e9b7441a
JK		 1475 case 152:
1476 ret += tcrypt_test("rfc4543(gcm(aes))");
1477 break;
1478
93b5e86a
JK		 1479 case 153:
1480 ret += tcrypt_test("cmac(aes)");
1481 break;
1482
1483 case 154:
1484 ret += tcrypt_test("cmac(des3_ede)");
1485 break;
1486
bbf9c893
HG		 1487 case 155:
1488 ret += tcrypt_test("authenc(hmac(sha1),cbc(aes))");
1489 break;
1490
bca4feb0
HG		 1491 case 156:
1492 ret += tcrypt_test("authenc(hmac(md5),ecb(cipher_null))");
1493 break;
1494
1495 case 157:
1496 ret += tcrypt_test("authenc(hmac(sha1),ecb(cipher_null))");
1497 break;
5208ed2c
NL		 1498 case 181:
1499 ret += tcrypt_test("authenc(hmac(sha1),cbc(des))");
1500 break;
1501 case 182:
1502 ret += tcrypt_test("authenc(hmac(sha1),cbc(des3_ede))");
1503 break;
1504 case 183:
1505 ret += tcrypt_test("authenc(hmac(sha224),cbc(des))");
1506 break;
1507 case 184:
1508 ret += tcrypt_test("authenc(hmac(sha224),cbc(des3_ede))");
1509 break;
1510 case 185:
1511 ret += tcrypt_test("authenc(hmac(sha256),cbc(des))");
1512 break;
1513 case 186:
1514 ret += tcrypt_test("authenc(hmac(sha256),cbc(des3_ede))");
1515 break;
1516 case 187:
1517 ret += tcrypt_test("authenc(hmac(sha384),cbc(des))");
1518 break;
1519 case 188:
1520 ret += tcrypt_test("authenc(hmac(sha384),cbc(des3_ede))");
1521 break;
1522 case 189:
1523 ret += tcrypt_test("authenc(hmac(sha512),cbc(des))");
1524 break;
1525 case 190:
1526 ret += tcrypt_test("authenc(hmac(sha512),cbc(des3_ede))");
1527 break;
ebfd9bcf 1528 case 200:
cba83564 1529 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
477035c2 1530 speed_template_16_24_32);
cba83564 1531 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
477035c2 1532 speed_template_16_24_32);
cba83564 1533 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
477035c2 1534 speed_template_16_24_32);
cba83564 1535 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
477035c2 1536 speed_template_16_24_32);
f3d1044c 1537 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
477035c2 1538 speed_template_32_40_48);
f3d1044c 1539 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
477035c2 1540 speed_template_32_40_48);
f19f5111 1541 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
477035c2 1542 speed_template_32_48_64);
f19f5111 1543 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
477035c2 1544 speed_template_32_48_64);
9996e342
JG		 1545 test_cipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
1546 speed_template_16_24_32);
1547 test_cipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
1548 speed_template_16_24_32);
ebfd9bcf
HW		 1549 break;
1550
1551 case 201:
cba83564 1552 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
da7f033d 1553 des3_speed_template, DES3_SPEED_VECTORS,
477035c2 1554 speed_template_24);
cba83564 1555 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
da7f033d 1556 des3_speed_template, DES3_SPEED_VECTORS,
477035c2 1557 speed_template_24);
cba83564 1558 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
da7f033d 1559 des3_speed_template, DES3_SPEED_VECTORS,
477035c2 1560 speed_template_24);
cba83564 1561 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
da7f033d 1562 des3_speed_template, DES3_SPEED_VECTORS,
477035c2 1563 speed_template_24);
87131507
JK		 1564 test_cipher_speed("ctr(des3_ede)", ENCRYPT, sec,
1565 des3_speed_template, DES3_SPEED_VECTORS,
1566 speed_template_24);
1567 test_cipher_speed("ctr(des3_ede)", DECRYPT, sec,
1568 des3_speed_template, DES3_SPEED_VECTORS,
1569 speed_template_24);
ebfd9bcf
HW		 1570 break;
1571
1572 case 202:
cba83564 1573 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
477035c2 1574 speed_template_16_24_32);
cba83564 1575 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
477035c2 1576 speed_template_16_24_32);
cba83564 1577 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
477035c2 1578 speed_template_16_24_32);
cba83564 1579 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
477035c2 1580 speed_template_16_24_32);
ee5002a5
JK		 1581 test_cipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0,
1582 speed_template_16_24_32);
1583 test_cipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
1584 speed_template_16_24_32);
bee3a90e
JK		 1585 test_cipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
1586 speed_template_32_40_48);
1587 test_cipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
1588 speed_template_32_40_48);
131f7541
JK		 1589 test_cipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
1590 speed_template_32_48_64);
1591 test_cipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
1592 speed_template_32_48_64);
ebfd9bcf
HW		 1593 break;
1594
1595 case 203:
cba83564 1596 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
477035c2 1597 speed_template_8_32);
cba83564 1598 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
477035c2 1599 speed_template_8_32);
cba83564 1600 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
477035c2 1601 speed_template_8_32);
cba83564 1602 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
477035c2 1603 speed_template_8_32);
7d47b86c
JK		 1604 test_cipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0,
1605 speed_template_8_32);
1606 test_cipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0,
1607 speed_template_8_32);
ebfd9bcf
HW		 1608 break;
1609
1610 case 204:
cba83564 1611 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
477035c2 1612 speed_template_8);
cba83564 1613 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
477035c2 1614 speed_template_8);
cba83564 1615 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
477035c2 1616 speed_template_8);
cba83564 1617 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
477035c2 1618 speed_template_8);
ebfd9bcf
HW		 1619 break;
1620
02ab5a70
NT		 1621 case 205:
1622 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
477035c2 1623 speed_template_16_24_32);
02ab5a70 1624 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
477035c2 1625 speed_template_16_24_32);
02ab5a70 1626 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
477035c2 1627 speed_template_16_24_32);
02ab5a70 1628 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
477035c2 1629 speed_template_16_24_32);
4de59337
JK		 1630 test_cipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0,
1631 speed_template_16_24_32);
1632 test_cipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0,
1633 speed_template_16_24_32);
1634 test_cipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0,
1635 speed_template_32_40_48);
1636 test_cipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0,
1637 speed_template_32_40_48);
1638 test_cipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0,
1639 speed_template_32_48_64);
1640 test_cipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0,
1641 speed_template_32_48_64);
02ab5a70
NT		 1642 break;
1643
5de8f1b5
TSH		 1644 case 206:
1645 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
477035c2 1646 speed_template_16_32);
5de8f1b5
TSH		 1647 break;
1648
7fb7fe44
JK		 1649 case 207:
1650 test_cipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
1651 speed_template_16_32);
1652 test_cipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
1653 speed_template_16_32);
1654 test_cipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
1655 speed_template_16_32);
1656 test_cipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
1657 speed_template_16_32);
1658 test_cipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
1659 speed_template_16_32);
1660 test_cipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
1661 speed_template_16_32);
87aae4bf
JK		 1662 test_cipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
1663 speed_template_32_48);
1664 test_cipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
1665 speed_template_32_48);
5209c07a
JK		 1666 test_cipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
1667 speed_template_32_64);
1668 test_cipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
1669 speed_template_32_64);
7fb7fe44
JK		 1670 break;
1671
31b4cd29
JK		 1672 case 208:
1673 test_cipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0,
1674 speed_template_8);
1675 break;
1676
a2c58260
JG		 1677 case 209:
1678 test_cipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0,
1679 speed_template_8_16);
1680 test_cipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0,
1681 speed_template_8_16);
1682 test_cipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0,
1683 speed_template_8_16);
1684 test_cipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0,
1685 speed_template_8_16);
1686 test_cipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0,
1687 speed_template_8_16);
1688 test_cipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0,
1689 speed_template_8_16);
1690 break;
1691
9b8b0405
JG		 1692 case 210:
1693 test_cipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0,
1694 speed_template_16_32);
1695 test_cipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0,
1696 speed_template_16_32);
1697 test_cipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0,
1698 speed_template_16_32);
1699 test_cipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0,
1700 speed_template_16_32);
1701 test_cipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0,
1702 speed_template_16_32);
1703 test_cipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0,
1704 speed_template_16_32);
1705 test_cipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0,
1706 speed_template_32_48);
1707 test_cipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0,
1708 speed_template_32_48);
1709 test_cipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0,
1710 speed_template_32_64);
1711 test_cipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0,
1712 speed_template_32_64);
1713 break;
1714
53f52d7a
TC		 1715 case 211:
1716 test_aead_speed("rfc4106(gcm(aes))", ENCRYPT, sec,
34a1c740 1717 NULL, 0, 16, 16, aead_speed_template_20);
1425d2d1 1718 test_aead_speed("gcm(aes)", ENCRYPT, sec,
f18611da 1719 NULL, 0, 16, 8, speed_template_16_24_32);
53f52d7a
TC		 1720 break;
1721
4e4aab63
HX		 1722 case 212:
1723 test_aead_speed("rfc4309(ccm(aes))", ENCRYPT, sec,
34a1c740 1724 NULL, 0, 16, 16, aead_speed_template_19);
4e4aab63
HX		 1725 break;
1726
2dce063a
MW		 1727 case 213:
1728 test_aead_speed("rfc7539esp(chacha20,poly1305)", ENCRYPT, sec,
1729 NULL, 0, 16, 8, aead_speed_template_36);
1730 break;
1731
1732 case 214:
1733 test_cipher_speed("chacha20", ENCRYPT, sec, NULL, 0,
1734 speed_template_32);
1735 break;
1736
1737
e8057928 1738 case 300:
8606813a
HX		 1739 if (alg) {
1740 test_hash_speed(alg, sec, generic_hash_speed_template);
1741 break;
1742 }
1743
e8057928
ML		 1744 /* fall through */
1745
1746 case 301:
e9d41164 1747 test_hash_speed("md4", sec, generic_hash_speed_template);
e8057928
ML		 1748 if (mode > 300 && mode < 400) break;
1749
1750 case 302:
e9d41164 1751 test_hash_speed("md5", sec, generic_hash_speed_template);
e8057928
ML		 1752 if (mode > 300 && mode < 400) break;
1753
1754 case 303:
e9d41164 1755 test_hash_speed("sha1", sec, generic_hash_speed_template);
e8057928
ML		 1756 if (mode > 300 && mode < 400) break;
1757
1758 case 304:
e9d41164 1759 test_hash_speed("sha256", sec, generic_hash_speed_template);
e8057928
ML		 1760 if (mode > 300 && mode < 400) break;
1761
1762 case 305:
e9d41164 1763 test_hash_speed("sha384", sec, generic_hash_speed_template);
e8057928
ML		 1764 if (mode > 300 && mode < 400) break;
1765
1766 case 306:
e9d41164 1767 test_hash_speed("sha512", sec, generic_hash_speed_template);
e8057928
ML		 1768 if (mode > 300 && mode < 400) break;
1769
1770 case 307:
e9d41164 1771 test_hash_speed("wp256", sec, generic_hash_speed_template);
e8057928
ML		 1772 if (mode > 300 && mode < 400) break;
1773
1774 case 308:
e9d41164 1775 test_hash_speed("wp384", sec, generic_hash_speed_template);
e8057928
ML		 1776 if (mode > 300 && mode < 400) break;
1777
1778 case 309:
e9d41164 1779 test_hash_speed("wp512", sec, generic_hash_speed_template);
e8057928
ML		 1780 if (mode > 300 && mode < 400) break;
1781
1782 case 310:
e9d41164 1783 test_hash_speed("tgr128", sec, generic_hash_speed_template);
e8057928
ML		 1784 if (mode > 300 && mode < 400) break;
1785
1786 case 311:
e9d41164 1787 test_hash_speed("tgr160", sec, generic_hash_speed_template);
e8057928
ML		 1788 if (mode > 300 && mode < 400) break;
1789
1790 case 312:
e9d41164 1791 test_hash_speed("tgr192", sec, generic_hash_speed_template);
e8057928
ML		 1792 if (mode > 300 && mode < 400) break;
1793
cd12fb90
JL		 1794 case 313:
1795 test_hash_speed("sha224", sec, generic_hash_speed_template);
1796 if (mode > 300 && mode < 400) break;
1797
fd4adf1a
AKR		 1798 case 314:
1799 test_hash_speed("rmd128", sec, generic_hash_speed_template);
1800 if (mode > 300 && mode < 400) break;
1801
1802 case 315:
1803 test_hash_speed("rmd160", sec, generic_hash_speed_template);
1804 if (mode > 300 && mode < 400) break;
1805
2998db37
AKR		 1806 case 316:
1807 test_hash_speed("rmd256", sec, generic_hash_speed_template);
1808 if (mode > 300 && mode < 400) break;
1809
1810 case 317:
1811 test_hash_speed("rmd320", sec, generic_hash_speed_template);
1812 if (mode > 300 && mode < 400) break;
1813
18bcc919
HY		 1814 case 318:
1815 test_hash_speed("ghash-generic", sec, hash_speed_template_16);
1816 if (mode > 300 && mode < 400) break;
1817
e3899e4d
TC		 1818 case 319:
1819 test_hash_speed("crc32c", sec, generic_hash_speed_template);
1820 if (mode > 300 && mode < 400) break;
1821
68411521
HX		 1822 case 320:
1823 test_hash_speed("crct10dif", sec, generic_hash_speed_template);
1824 if (mode > 300 && mode < 400) break;
1825
2dce063a
MW		 1826 case 321:
1827 test_hash_speed("poly1305", sec, poly1305_speed_template);
1828 if (mode > 300 && mode < 400) break;
1829
79cc6ab8 1830 case 322:
1831 test_hash_speed("sha3-224", sec, generic_hash_speed_template);
1832 if (mode > 300 && mode < 400) break;
1833
1834 case 323:
1835 test_hash_speed("sha3-256", sec, generic_hash_speed_template);
1836 if (mode > 300 && mode < 400) break;
1837
1838 case 324:
1839 test_hash_speed("sha3-384", sec, generic_hash_speed_template);
1840 if (mode > 300 && mode < 400) break;
1841
1842 case 325:
1843 test_hash_speed("sha3-512", sec, generic_hash_speed_template);
1844 if (mode > 300 && mode < 400) break;
1845
e8057928
ML		 1846 case 399:
1847 break;
1848
beb63da7 1849 case 400:
8606813a
HX		 1850 if (alg) {
1851 test_ahash_speed(alg, sec, generic_hash_speed_template);
1852 break;
1853 }
1854
beb63da7
DM		 1855 /* fall through */
1856
1857 case 401:
1858 test_ahash_speed("md4", sec, generic_hash_speed_template);
1859 if (mode > 400 && mode < 500) break;
1860
1861 case 402:
1862 test_ahash_speed("md5", sec, generic_hash_speed_template);
1863 if (mode > 400 && mode < 500) break;
1864
1865 case 403:
1866 test_ahash_speed("sha1", sec, generic_hash_speed_template);
1867 if (mode > 400 && mode < 500) break;
1868
1869 case 404:
1870 test_ahash_speed("sha256", sec, generic_hash_speed_template);
1871 if (mode > 400 && mode < 500) break;
1872
1873 case 405:
1874 test_ahash_speed("sha384", sec, generic_hash_speed_template);
1875 if (mode > 400 && mode < 500) break;
1876
1877 case 406:
1878 test_ahash_speed("sha512", sec, generic_hash_speed_template);
1879 if (mode > 400 && mode < 500) break;
1880
1881 case 407:
1882 test_ahash_speed("wp256", sec, generic_hash_speed_template);
1883 if (mode > 400 && mode < 500) break;
1884
1885 case 408:
1886 test_ahash_speed("wp384", sec, generic_hash_speed_template);
1887 if (mode > 400 && mode < 500) break;
1888
1889 case 409:
1890 test_ahash_speed("wp512", sec, generic_hash_speed_template);
1891 if (mode > 400 && mode < 500) break;
1892
1893 case 410:
1894 test_ahash_speed("tgr128", sec, generic_hash_speed_template);
1895 if (mode > 400 && mode < 500) break;
1896
1897 case 411:
1898 test_ahash_speed("tgr160", sec, generic_hash_speed_template);
1899 if (mode > 400 && mode < 500) break;
1900
1901 case 412:
1902 test_ahash_speed("tgr192", sec, generic_hash_speed_template);
1903 if (mode > 400 && mode < 500) break;
1904
1905 case 413:
1906 test_ahash_speed("sha224", sec, generic_hash_speed_template);
1907 if (mode > 400 && mode < 500) break;
1908
1909 case 414:
1910 test_ahash_speed("rmd128", sec, generic_hash_speed_template);
1911 if (mode > 400 && mode < 500) break;
1912
1913 case 415:
1914 test_ahash_speed("rmd160", sec, generic_hash_speed_template);
1915 if (mode > 400 && mode < 500) break;
1916
1917 case 416:
1918 test_ahash_speed("rmd256", sec, generic_hash_speed_template);
1919 if (mode > 400 && mode < 500) break;
1920
1921 case 417:
1922 test_ahash_speed("rmd320", sec, generic_hash_speed_template);
1923 if (mode > 400 && mode < 500) break;
1924
79cc6ab8 1925 case 418:
1926 test_ahash_speed("sha3-224", sec, generic_hash_speed_template);
1927 if (mode > 400 && mode < 500) break;
1928
1929 case 419:
1930 test_ahash_speed("sha3-256", sec, generic_hash_speed_template);
1931 if (mode > 400 && mode < 500) break;
1932
1933 case 420:
1934 test_ahash_speed("sha3-384", sec, generic_hash_speed_template);
1935 if (mode > 400 && mode < 500) break;
1936
1937
1938 case 421:
1939 test_ahash_speed("sha3-512", sec, generic_hash_speed_template);
1940 if (mode > 400 && mode < 500) break;
1941
087bcd22
MD		 1942 case 422:
1943 test_mb_ahash_speed("sha1", sec, generic_hash_speed_template);
1944 if (mode > 400 && mode < 500) break;
1945
1946 case 423:
1947 test_mb_ahash_speed("sha256", sec, generic_hash_speed_template);
1948 if (mode > 400 && mode < 500) break;
79cc6ab8 1949
14009c4b
MD		 1950 case 424:
1951 test_mb_ahash_speed("sha512", sec, generic_hash_speed_template);
1952 if (mode > 400 && mode < 500) break;
1953
beb63da7
DM		 1954 case 499:
1955 break;
1956
3f3baf35
JK		 1957 case 500:
1958 test_acipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
1959 speed_template_16_24_32);
1960 test_acipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
1961 speed_template_16_24_32);
1962 test_acipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
1963 speed_template_16_24_32);
1964 test_acipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
1965 speed_template_16_24_32);
1966 test_acipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
1967 speed_template_32_40_48);
1968 test_acipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
1969 speed_template_32_40_48);
1970 test_acipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
1971 speed_template_32_48_64);
1972 test_acipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
1973 speed_template_32_48_64);
1974 test_acipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
1975 speed_template_16_24_32);
1976 test_acipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
1977 speed_template_16_24_32);
de197533
NR		 1978 test_acipher_speed("cfb(aes)", ENCRYPT, sec, NULL, 0,
1979 speed_template_16_24_32);
1980 test_acipher_speed("cfb(aes)", DECRYPT, sec, NULL, 0,
1981 speed_template_16_24_32);
1982 test_acipher_speed("ofb(aes)", ENCRYPT, sec, NULL, 0,
1983 speed_template_16_24_32);
1984 test_acipher_speed("ofb(aes)", DECRYPT, sec, NULL, 0,
1985 speed_template_16_24_32);
69d3150c
JK		 1986 test_acipher_speed("rfc3686(ctr(aes))", ENCRYPT, sec, NULL, 0,
1987 speed_template_20_28_36);
1988 test_acipher_speed("rfc3686(ctr(aes))", DECRYPT, sec, NULL, 0,
1989 speed_template_20_28_36);
3f3baf35
JK		 1990 break;
1991
1992 case 501:
1993 test_acipher_speed("ecb(des3_ede)", ENCRYPT, sec,
1994 des3_speed_template, DES3_SPEED_VECTORS,
1995 speed_template_24);
1996 test_acipher_speed("ecb(des3_ede)", DECRYPT, sec,
1997 des3_speed_template, DES3_SPEED_VECTORS,
1998 speed_template_24);
1999 test_acipher_speed("cbc(des3_ede)", ENCRYPT, sec,
2000 des3_speed_template, DES3_SPEED_VECTORS,
2001 speed_template_24);
2002 test_acipher_speed("cbc(des3_ede)", DECRYPT, sec,
2003 des3_speed_template, DES3_SPEED_VECTORS,
2004 speed_template_24);
de197533
NR		 2005 test_acipher_speed("cfb(des3_ede)", ENCRYPT, sec,
2006 des3_speed_template, DES3_SPEED_VECTORS,
2007 speed_template_24);
2008 test_acipher_speed("cfb(des3_ede)", DECRYPT, sec,
2009 des3_speed_template, DES3_SPEED_VECTORS,
2010 speed_template_24);
2011 test_acipher_speed("ofb(des3_ede)", ENCRYPT, sec,
2012 des3_speed_template, DES3_SPEED_VECTORS,
2013 speed_template_24);
2014 test_acipher_speed("ofb(des3_ede)", DECRYPT, sec,
2015 des3_speed_template, DES3_SPEED_VECTORS,
2016 speed_template_24);
3f3baf35
JK		 2017 break;
2018
2019 case 502:
2020 test_acipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
2021 speed_template_8);
2022 test_acipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
2023 speed_template_8);
2024 test_acipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
2025 speed_template_8);
2026 test_acipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
2027 speed_template_8);
de197533
NR		 2028 test_acipher_speed("cfb(des)", ENCRYPT, sec, NULL, 0,
2029 speed_template_8);
2030 test_acipher_speed("cfb(des)", DECRYPT, sec, NULL, 0,
2031 speed_template_8);
2032 test_acipher_speed("ofb(des)", ENCRYPT, sec, NULL, 0,
2033 speed_template_8);
2034 test_acipher_speed("ofb(des)", DECRYPT, sec, NULL, 0,
2035 speed_template_8);
3f3baf35
JK		 2036 break;
2037
7fb7fe44
JK		 2038 case 503:
2039 test_acipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
2040 speed_template_16_32);
2041 test_acipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
2042 speed_template_16_32);
2043 test_acipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
2044 speed_template_16_32);
2045 test_acipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
2046 speed_template_16_32);
2047 test_acipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
2048 speed_template_16_32);
2049 test_acipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
2050 speed_template_16_32);
87aae4bf
JK		 2051 test_acipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
2052 speed_template_32_48);
2053 test_acipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
2054 speed_template_32_48);
5209c07a
JK		 2055 test_acipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
2056 speed_template_32_64);
2057 test_acipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
2058 speed_template_32_64);
7fb7fe44
JK		 2059 break;
2060
107778b5
JG		 2061 case 504:
2062 test_acipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
2063 speed_template_16_24_32);
2064 test_acipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
2065 speed_template_16_24_32);
2066 test_acipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
2067 speed_template_16_24_32);
2068 test_acipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
2069 speed_template_16_24_32);
2070 test_acipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0,
2071 speed_template_16_24_32);
2072 test_acipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
2073 speed_template_16_24_32);
2074 test_acipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
2075 speed_template_32_40_48);
2076 test_acipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
2077 speed_template_32_40_48);
2078 test_acipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
2079 speed_template_32_48_64);
2080 test_acipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
2081 speed_template_32_48_64);
2082 break;
2083
31b4cd29
JK		 2084 case 505:
2085 test_acipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0,
2086 speed_template_8);
2087 break;
2088
a2c58260
JG		 2089 case 506:
2090 test_acipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0,
2091 speed_template_8_16);
2092 test_acipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0,
2093 speed_template_8_16);
2094 test_acipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0,
2095 speed_template_8_16);
2096 test_acipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0,
2097 speed_template_8_16);
2098 test_acipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0,
2099 speed_template_8_16);
2100 test_acipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0,
2101 speed_template_8_16);
2102 break;
2103
9b8b0405
JG		 2104 case 507:
2105 test_acipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0,
2106 speed_template_16_32);
2107 test_acipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0,
2108 speed_template_16_32);
2109 test_acipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0,
2110 speed_template_16_32);
2111 test_acipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0,
2112 speed_template_16_32);
2113 test_acipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0,
2114 speed_template_16_32);
2115 test_acipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0,
2116 speed_template_16_32);
2117 test_acipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0,
2118 speed_template_32_48);
2119 test_acipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0,
2120 speed_template_32_48);
2121 test_acipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0,
2122 speed_template_32_64);
2123 test_acipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0,
2124 speed_template_32_64);
2125 break;
2126
bf9c5181
JK		 2127 case 508:
2128 test_acipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
2129 speed_template_16_32);
2130 test_acipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
2131 speed_template_16_32);
2132 test_acipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
2133 speed_template_16_32);
2134 test_acipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
2135 speed_template_16_32);
2136 test_acipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0,
2137 speed_template_16_32);
2138 test_acipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0,
2139 speed_template_16_32);
2140 test_acipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0,
2141 speed_template_32_48);
2142 test_acipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0,
2143 speed_template_32_48);
2144 test_acipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0,
2145 speed_template_32_64);
2146 test_acipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0,
2147 speed_template_32_64);
2148 break;
2149
ad8b7c3e
JK		 2150 case 509:
2151 test_acipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
2152 speed_template_8_32);
2153 test_acipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
2154 speed_template_8_32);
2155 test_acipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
2156 speed_template_8_32);
2157 test_acipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
2158 speed_template_8_32);
2159 test_acipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0,
2160 speed_template_8_32);
2161 test_acipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0,
2162 speed_template_8_32);
2163 break;
2164
1da177e4
LT		 2165 case 1000:
2166 test_available();
2167 break;
1da177e4 2168 }
4e033a6b
JW		 2169
2170 return ret;
1da177e4
LT		 2171}
2172
3af5b90b 2173static int __init tcrypt_mod_init(void)
1da177e4 2174{
e3a4ea4f 2175 int err = -ENOMEM;
f139cfa7 2176 int i;
e3a4ea4f 2177
f139cfa7
HX		 2178 for (i = 0; i < TVMEMSIZE; i++) {
2179 tvmem[i] = (void *)__get_free_page(GFP_KERNEL);
2180 if (!tvmem[i])
2181 goto err_free_tv;
2182 }
1da177e4 2183
8606813a 2184 err = do_test(alg, type, mask, mode);
a873a5f1 2185
4e033a6b
JW		 2186 if (err) {
2187 printk(KERN_ERR "tcrypt: one or more tests failed!\n");
2188 goto err_free_tv;
2189 }
14fdf477 2190
4e033a6b
JW		 2191 /* We intentionaly return -EAGAIN to prevent keeping the module,
2192 * unless we're running in fips mode. It does all its work from
2193 * init() and doesn't offer any runtime functionality, but in
2194 * the fips case, checking for a successful load is helpful.
14fdf477
ML		 2195 * => we don't need it in the memory, do we?
2196 * -- mludvig
2197 */
4e033a6b
JW		 2198 if (!fips_enabled)
2199 err = -EAGAIN;
e3a4ea4f 2200
f139cfa7
HX		 2201err_free_tv:
2202 for (i = 0; i < TVMEMSIZE && tvmem[i]; i++)
2203 free_page((unsigned long)tvmem[i]);
e3a4ea4f
MH		 2204
2205 return err;
1da177e4
LT		 2206}
2207
2208/*
2209 * If an init function is provided, an exit function must also be provided
2210 * to allow module unload.
2211 */
3af5b90b 2212static void __exit tcrypt_mod_fini(void) { }
1da177e4 2213
3af5b90b
KB		 2214module_init(tcrypt_mod_init);
2215module_exit(tcrypt_mod_fini);
1da177e4 2216
a873a5f1
SK		 2217module_param(alg, charp, 0);
2218module_param(type, uint, 0);
7be380f7 2219module_param(mask, uint, 0);
1da177e4 2220module_param(mode, int, 0);
ebfd9bcf 2221module_param(sec, uint, 0);
6a17944c
HX		 2222MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
2223 "(defaults to zero which uses CPU cycles instead)");
1da177e4
LT		 2224
2225MODULE_LICENSE("GPL");
2226MODULE_DESCRIPTION("Quick & dirty crypto testing module");
2227MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
ubuntu-zesty-kernel mirror