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