1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Quick & dirty crypto benchmarking module.
4 *
5 * This will only exist until we have a better benchmarking mechanism
6 * (e.g. a char device).
7 *
8 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
9 * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
10 * Copyright (c) 2007 Nokia Siemens Networks
11 *
12 * Updated RFC4106 AES-GCM testing.
13 * Authors: Aidan O'Mahony (aidan.o.mahony@intel.com)
14 * Adrian Hoban <adrian.hoban@intel.com>
15 * Gabriele Paoloni <gabriele.paoloni@intel.com>
16 * Tadeusz Struk (tadeusz.struk@intel.com)
17 * Copyright (c) 2010, Intel Corporation.
18 */
19
20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
21
22 #include <crypto/aead.h>
23 #include <crypto/hash.h>
24 #include <crypto/skcipher.h>
25 #include <linux/err.h>
26 #include <linux/fips.h>
27 #include <linux/init.h>
28 #include <linux/interrupt.h>
29 #include <linux/jiffies.h>
30 #include <linux/kernel.h>
31 #include <linux/module.h>
32 #include <linux/moduleparam.h>
33 #include <linux/scatterlist.h>
34 #include <linux/slab.h>
35 #include <linux/string.h>
36 #include <linux/timex.h>
37
38 #include "internal.h"
39 #include "tcrypt.h"
40
41 /*
42 * Need slab memory for benchmarking (size in number of pages).
43 */
44 #define TVMEMSIZE 4
45
46 /*
47 * Used by test_cipher_speed()
48 */
49 #define ENCRYPT 1
50 #define DECRYPT 0
51
52 #define MAX_DIGEST_SIZE 64
53
54 /*
55 * return a string with the driver name
56 */
57 #define get_driver_name(tfm_type, tfm) crypto_tfm_alg_driver_name(tfm_type ## _tfm(tfm))
58
59 /*
60 * Used by test_cipher_speed()
61 */
62 static unsigned int sec;
63
64 static char *alg;
65 static u32 type;
66 static u32 mask;
67 static int mode;
68 static u32 num_mb = 8;
69 static unsigned int klen;
70 static char *tvmem[TVMEMSIZE];
71
72 static const int block_sizes[] = { 16, 64, 128, 256, 1024, 1420, 4096, 0 };
73 static const int aead_sizes[] = { 16, 64, 256, 512, 1024, 1420, 4096, 8192, 0 };
74
75 #define XBUFSIZE 8
76 #define MAX_IVLEN 32
77
testmgr_alloc_buf(char * buf[XBUFSIZE])78 static int testmgr_alloc_buf(char *buf[XBUFSIZE])
79 {
80 int i;
81
82 for (i = 0; i < XBUFSIZE; i++) {
83 buf[i] = (void *)__get_free_page(GFP_KERNEL);
84 if (!buf[i])
85 goto err_free_buf;
86 }
87
88 return 0;
89
90 err_free_buf:
91 while (i-- > 0)
92 free_page((unsigned long)buf[i]);
93
94 return -ENOMEM;
95 }
96
testmgr_free_buf(char * buf[XBUFSIZE])97 static void testmgr_free_buf(char *buf[XBUFSIZE])
98 {
99 int i;
100
101 for (i = 0; i < XBUFSIZE; i++)
102 free_page((unsigned long)buf[i]);
103 }
104
sg_init_aead(struct scatterlist * sg,char * xbuf[XBUFSIZE],unsigned int buflen,const void * assoc,unsigned int aad_size)105 static void sg_init_aead(struct scatterlist *sg, char *xbuf[XBUFSIZE],
106 unsigned int buflen, const void *assoc,
107 unsigned int aad_size)
108 {
109 int np = (buflen + PAGE_SIZE - 1)/PAGE_SIZE;
110 int k, rem;
111
112 if (np > XBUFSIZE) {
113 rem = PAGE_SIZE;
114 np = XBUFSIZE;
115 } else {
116 rem = buflen % PAGE_SIZE;
117 }
118
119 sg_init_table(sg, np + 1);
120
121 sg_set_buf(&sg[0], assoc, aad_size);
122
123 if (rem)
124 np--;
125 for (k = 0; k < np; k++)
126 sg_set_buf(&sg[k + 1], xbuf[k], PAGE_SIZE);
127
128 if (rem)
129 sg_set_buf(&sg[k + 1], xbuf[k], rem);
130 }
131
do_one_aead_op(struct aead_request * req,int ret)132 static inline int do_one_aead_op(struct aead_request *req, int ret)
133 {
134 struct crypto_wait *wait = req->base.data;
135
136 return crypto_wait_req(ret, wait);
137 }
138
139 struct test_mb_aead_data {
140 struct scatterlist sg[XBUFSIZE];
141 struct scatterlist sgout[XBUFSIZE];
142 struct aead_request *req;
143 struct crypto_wait wait;
144 char *xbuf[XBUFSIZE];
145 char *xoutbuf[XBUFSIZE];
146 char *axbuf[XBUFSIZE];
147 };
148
do_mult_aead_op(struct test_mb_aead_data * data,int enc,u32 num_mb,int * rc)149 static int do_mult_aead_op(struct test_mb_aead_data *data, int enc,
150 u32 num_mb, int *rc)
151 {
152 int i, err = 0;
153
154 /* Fire up a bunch of concurrent requests */
155 for (i = 0; i < num_mb; i++) {
156 if (enc == ENCRYPT)
157 rc[i] = crypto_aead_encrypt(data[i].req);
158 else
159 rc[i] = crypto_aead_decrypt(data[i].req);
160 }
161
162 /* Wait for all requests to finish */
163 for (i = 0; i < num_mb; i++) {
164 rc[i] = crypto_wait_req(rc[i], &data[i].wait);
165
166 if (rc[i]) {
167 pr_info("concurrent request %d error %d\n", i, rc[i]);
168 err = rc[i];
169 }
170 }
171
172 return err;
173 }
174
test_mb_aead_jiffies(struct test_mb_aead_data * data,int enc,int blen,int secs,u32 num_mb)175 static int test_mb_aead_jiffies(struct test_mb_aead_data *data, int enc,
176 int blen, int secs, u32 num_mb)
177 {
178 unsigned long start, end;
179 int bcount;
180 int ret = 0;
181 int *rc;
182
183 rc = kzalloc_objs(*rc, num_mb);
184 if (!rc)
185 return -ENOMEM;
186
187 for (start = jiffies, end = start + secs * HZ, bcount = 0;
188 time_before(jiffies, end); bcount++) {
189 ret = do_mult_aead_op(data, enc, num_mb, rc);
190 if (ret)
191 goto out;
192 }
193
194 pr_cont("%d operations in %d seconds (%llu bytes)\n",
195 bcount * num_mb, secs, (u64)bcount * blen * num_mb);
196
197 out:
198 kfree(rc);
199 return ret;
200 }
201
test_mb_aead_cycles(struct test_mb_aead_data * data,int enc,int blen,u32 num_mb)202 static int test_mb_aead_cycles(struct test_mb_aead_data *data, int enc,
203 int blen, u32 num_mb)
204 {
205 unsigned long cycles = 0;
206 int ret = 0;
207 int i;
208 int *rc;
209
210 rc = kzalloc_objs(*rc, num_mb);
211 if (!rc)
212 return -ENOMEM;
213
214 /* Warm-up run. */
215 for (i = 0; i < 4; i++) {
216 ret = do_mult_aead_op(data, enc, num_mb, rc);
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 ret = do_mult_aead_op(data, enc, num_mb, rc);
227 end = get_cycles();
228
229 if (ret)
230 goto out;
231
232 cycles += end - start;
233 }
234
235 pr_cont("1 operation in %lu cycles (%d bytes)\n",
236 (cycles + 4) / (8 * num_mb), blen);
237
238 out:
239 kfree(rc);
240 return ret;
241 }
242
test_mb_aead_speed(const char * algo,int enc,int secs,struct aead_speed_template * template,unsigned int tcount,u8 authsize,unsigned int aad_size,u8 * keysize,u32 num_mb)243 static void test_mb_aead_speed(const char *algo, int enc, int secs,
244 struct aead_speed_template *template,
245 unsigned int tcount, u8 authsize,
246 unsigned int aad_size, u8 *keysize, u32 num_mb)
247 {
248 struct test_mb_aead_data *data;
249 struct crypto_aead *tfm;
250 unsigned int i, j, iv_len;
251 const int *b_size;
252 const char *key;
253 const char *e;
254 void *assoc;
255 char *iv;
256 int ret;
257
258
259 if (aad_size >= PAGE_SIZE) {
260 pr_err("associate data length (%u) too big\n", aad_size);
261 return;
262 }
263
264 iv = kzalloc(MAX_IVLEN, GFP_KERNEL);
265 if (!iv)
266 return;
267
268 if (enc == ENCRYPT)
269 e = "encryption";
270 else
271 e = "decryption";
272
273 data = kzalloc_objs(*data, num_mb);
274 if (!data)
275 goto out_free_iv;
276
277 tfm = crypto_alloc_aead(algo, 0, 0);
278 if (IS_ERR(tfm)) {
279 pr_err("failed to load transform for %s: %ld\n",
280 algo, PTR_ERR(tfm));
281 goto out_free_data;
282 }
283
284 ret = crypto_aead_setauthsize(tfm, authsize);
285 if (ret) {
286 pr_err("alg: aead: Failed to setauthsize for %s: %d\n", algo,
287 ret);
288 goto out_free_tfm;
289 }
290
291 for (i = 0; i < num_mb; ++i)
292 if (testmgr_alloc_buf(data[i].xbuf)) {
293 while (i--)
294 testmgr_free_buf(data[i].xbuf);
295 goto out_free_tfm;
296 }
297
298 for (i = 0; i < num_mb; ++i)
299 if (testmgr_alloc_buf(data[i].axbuf)) {
300 while (i--)
301 testmgr_free_buf(data[i].axbuf);
302 goto out_free_xbuf;
303 }
304
305 for (i = 0; i < num_mb; ++i)
306 if (testmgr_alloc_buf(data[i].xoutbuf)) {
307 while (i--)
308 testmgr_free_buf(data[i].xoutbuf);
309 goto out_free_axbuf;
310 }
311
312 for (i = 0; i < num_mb; ++i) {
313 data[i].req = aead_request_alloc(tfm, GFP_KERNEL);
314 if (!data[i].req) {
315 pr_err("alg: aead: Failed to allocate request for %s\n",
316 algo);
317 while (i--)
318 aead_request_free(data[i].req);
319 goto out_free_xoutbuf;
320 }
321 }
322
323 for (i = 0; i < num_mb; ++i) {
324 crypto_init_wait(&data[i].wait);
325 aead_request_set_callback(data[i].req,
326 CRYPTO_TFM_REQ_MAY_BACKLOG,
327 crypto_req_done, &data[i].wait);
328 }
329
330 pr_info("testing speed of multibuffer %s (%s) %s\n", algo,
331 get_driver_name(crypto_aead, tfm), e);
332
333 i = 0;
334 do {
335 b_size = aead_sizes;
336 do {
337 int bs = round_up(*b_size, crypto_aead_blocksize(tfm));
338
339 if (bs + authsize > XBUFSIZE * PAGE_SIZE) {
340 pr_err("template (%u) too big for buffer (%lu)\n",
341 authsize + bs,
342 XBUFSIZE * PAGE_SIZE);
343 goto out;
344 }
345
346 pr_info("test %u (%d bit key, %d byte blocks): ", i,
347 *keysize * 8, bs);
348
349 /* Set up tfm global state, i.e. the key */
350
351 memset(tvmem[0], 0xff, PAGE_SIZE);
352 key = tvmem[0];
353 for (j = 0; j < tcount; j++) {
354 if (template[j].klen == *keysize) {
355 key = template[j].key;
356 break;
357 }
358 }
359
360 crypto_aead_clear_flags(tfm, ~0);
361
362 ret = crypto_aead_setkey(tfm, key, *keysize);
363 if (ret) {
364 pr_err("setkey() failed flags=%x\n",
365 crypto_aead_get_flags(tfm));
366 goto out;
367 }
368
369 iv_len = crypto_aead_ivsize(tfm);
370 if (iv_len)
371 memset(iv, 0xff, iv_len);
372
373 /* Now setup per request stuff, i.e. buffers */
374
375 for (j = 0; j < num_mb; ++j) {
376 struct test_mb_aead_data *cur = &data[j];
377
378 assoc = cur->axbuf[0];
379 memset(assoc, 0xff, aad_size);
380
381 sg_init_aead(cur->sg, cur->xbuf,
382 bs + (enc ? 0 : authsize),
383 assoc, aad_size);
384
385 sg_init_aead(cur->sgout, cur->xoutbuf,
386 bs + (enc ? authsize : 0),
387 assoc, aad_size);
388
389 aead_request_set_ad(cur->req, aad_size);
390
391 if (!enc) {
392
393 aead_request_set_crypt(cur->req,
394 cur->sgout,
395 cur->sg,
396 bs, iv);
397 ret = crypto_aead_encrypt(cur->req);
398 ret = do_one_aead_op(cur->req, ret);
399
400 if (ret) {
401 pr_err("calculating auth failed (%d)\n",
402 ret);
403 break;
404 }
405 }
406
407 aead_request_set_crypt(cur->req, cur->sg,
408 cur->sgout, bs +
409 (enc ? 0 : authsize),
410 iv);
411
412 }
413
414 if (secs) {
415 ret = test_mb_aead_jiffies(data, enc, bs,
416 secs, num_mb);
417 cond_resched();
418 } else {
419 ret = test_mb_aead_cycles(data, enc, bs,
420 num_mb);
421 }
422
423 if (ret) {
424 pr_err("%s() failed return code=%d\n", e, ret);
425 break;
426 }
427 b_size++;
428 i++;
429 } while (*b_size);
430 keysize++;
431 } while (*keysize);
432
433 out:
434 for (i = 0; i < num_mb; ++i)
435 aead_request_free(data[i].req);
436 out_free_xoutbuf:
437 for (i = 0; i < num_mb; ++i)
438 testmgr_free_buf(data[i].xoutbuf);
439 out_free_axbuf:
440 for (i = 0; i < num_mb; ++i)
441 testmgr_free_buf(data[i].axbuf);
442 out_free_xbuf:
443 for (i = 0; i < num_mb; ++i)
444 testmgr_free_buf(data[i].xbuf);
445 out_free_tfm:
446 crypto_free_aead(tfm);
447 out_free_data:
448 kfree(data);
449 out_free_iv:
450 kfree(iv);
451 }
452
test_aead_jiffies(struct aead_request * req,int enc,int blen,int secs)453 static int test_aead_jiffies(struct aead_request *req, int enc,
454 int blen, int secs)
455 {
456 unsigned long start, end;
457 int bcount;
458 int ret;
459
460 for (start = jiffies, end = start + secs * HZ, bcount = 0;
461 time_before(jiffies, end); bcount++) {
462 if (enc)
463 ret = do_one_aead_op(req, crypto_aead_encrypt(req));
464 else
465 ret = do_one_aead_op(req, crypto_aead_decrypt(req));
466
467 if (ret)
468 return ret;
469 }
470
471 pr_cont("%d operations in %d seconds (%llu bytes)\n",
472 bcount, secs, (u64)bcount * blen);
473 return 0;
474 }
475
test_aead_cycles(struct aead_request * req,int enc,int blen)476 static int test_aead_cycles(struct aead_request *req, int enc, int blen)
477 {
478 unsigned long cycles = 0;
479 int ret = 0;
480 int i;
481
482 /* Warm-up run. */
483 for (i = 0; i < 4; i++) {
484 if (enc)
485 ret = do_one_aead_op(req, crypto_aead_encrypt(req));
486 else
487 ret = do_one_aead_op(req, crypto_aead_decrypt(req));
488
489 if (ret)
490 goto out;
491 }
492
493 /* The real thing. */
494 for (i = 0; i < 8; i++) {
495 cycles_t start, end;
496
497 start = get_cycles();
498 if (enc)
499 ret = do_one_aead_op(req, crypto_aead_encrypt(req));
500 else
501 ret = do_one_aead_op(req, crypto_aead_decrypt(req));
502 end = get_cycles();
503
504 if (ret)
505 goto out;
506
507 cycles += end - start;
508 }
509
510 out:
511 if (ret == 0)
512 pr_cont("1 operation in %lu cycles (%d bytes)\n",
513 (cycles + 4) / 8, blen);
514
515 return ret;
516 }
517
test_aead_speed(const char * algo,int enc,unsigned int secs,struct aead_speed_template * template,unsigned int tcount,u8 authsize,unsigned int aad_size,u8 * keysize)518 static void test_aead_speed(const char *algo, int enc, unsigned int secs,
519 struct aead_speed_template *template,
520 unsigned int tcount, u8 authsize,
521 unsigned int aad_size, u8 *keysize)
522 {
523 unsigned int i, j;
524 struct crypto_aead *tfm;
525 int ret = -ENOMEM;
526 const char *key;
527 struct aead_request *req;
528 struct scatterlist *sg;
529 struct scatterlist *sgout;
530 const char *e;
531 void *assoc;
532 char *iv;
533 char *xbuf[XBUFSIZE];
534 char *xoutbuf[XBUFSIZE];
535 char *axbuf[XBUFSIZE];
536 const int *b_size;
537 unsigned int iv_len;
538 struct crypto_wait wait;
539
540 iv = kzalloc(MAX_IVLEN, GFP_KERNEL);
541 if (!iv)
542 return;
543
544 if (aad_size >= PAGE_SIZE) {
545 pr_err("associate data length (%u) too big\n", aad_size);
546 goto out_noxbuf;
547 }
548
549 if (enc == ENCRYPT)
550 e = "encryption";
551 else
552 e = "decryption";
553
554 if (testmgr_alloc_buf(xbuf))
555 goto out_noxbuf;
556 if (testmgr_alloc_buf(axbuf))
557 goto out_noaxbuf;
558 if (testmgr_alloc_buf(xoutbuf))
559 goto out_nooutbuf;
560
561 sg = kmalloc(sizeof(*sg) * 9 * 2, GFP_KERNEL);
562 if (!sg)
563 goto out_nosg;
564 sgout = &sg[9];
565
566 tfm = crypto_alloc_aead(algo, 0, 0);
567 if (IS_ERR(tfm)) {
568 pr_err("alg: aead: Failed to load transform for %s: %ld\n", algo,
569 PTR_ERR(tfm));
570 goto out_notfm;
571 }
572
573 ret = crypto_aead_setauthsize(tfm, authsize);
574 if (ret) {
575 pr_err("alg: aead: Failed to setauthsize for %s: %d\n", algo,
576 ret);
577 goto out_noreq;
578 }
579
580 crypto_init_wait(&wait);
581 pr_info("testing speed of %s (%s) %s\n", algo,
582 get_driver_name(crypto_aead, tfm), e);
583
584 req = aead_request_alloc(tfm, GFP_KERNEL);
585 if (!req) {
586 pr_err("alg: aead: Failed to allocate request for %s\n",
587 algo);
588 goto out_noreq;
589 }
590
591 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
592 crypto_req_done, &wait);
593
594 i = 0;
595 do {
596 b_size = aead_sizes;
597 do {
598 u32 bs = round_up(*b_size, crypto_aead_blocksize(tfm));
599
600 assoc = axbuf[0];
601 memset(assoc, 0xff, aad_size);
602
603 if ((*keysize + bs) > TVMEMSIZE * PAGE_SIZE) {
604 pr_err("template (%u) too big for tvmem (%lu)\n",
605 *keysize + bs,
606 TVMEMSIZE * PAGE_SIZE);
607 goto out;
608 }
609
610 key = tvmem[0];
611 for (j = 0; j < tcount; j++) {
612 if (template[j].klen == *keysize) {
613 key = template[j].key;
614 break;
615 }
616 }
617
618 ret = crypto_aead_setkey(tfm, key, *keysize);
619 if (ret) {
620 pr_err("setkey() failed flags=%x: %d\n",
621 crypto_aead_get_flags(tfm), ret);
622 goto out;
623 }
624
625 iv_len = crypto_aead_ivsize(tfm);
626 if (iv_len)
627 memset(iv, 0xff, iv_len);
628
629 crypto_aead_clear_flags(tfm, ~0);
630 pr_info("test %u (%d bit key, %d byte blocks): ",
631 i, *keysize * 8, bs);
632
633 memset(tvmem[0], 0xff, PAGE_SIZE);
634
635 sg_init_aead(sg, xbuf, bs + (enc ? 0 : authsize),
636 assoc, aad_size);
637
638 sg_init_aead(sgout, xoutbuf,
639 bs + (enc ? authsize : 0), assoc,
640 aad_size);
641
642 aead_request_set_ad(req, aad_size);
643
644 if (!enc) {
645
646 /*
647 * For decryption we need a proper auth so
648 * we do the encryption path once with buffers
649 * reversed (input <-> output) to calculate it
650 */
651 aead_request_set_crypt(req, sgout, sg,
652 bs, iv);
653 ret = do_one_aead_op(req,
654 crypto_aead_encrypt(req));
655
656 if (ret) {
657 pr_err("calculating auth failed (%d)\n",
658 ret);
659 break;
660 }
661 }
662
663 aead_request_set_crypt(req, sg, sgout,
664 bs + (enc ? 0 : authsize),
665 iv);
666
667 if (secs) {
668 ret = test_aead_jiffies(req, enc, bs,
669 secs);
670 cond_resched();
671 } else {
672 ret = test_aead_cycles(req, enc, bs);
673 }
674
675 if (ret) {
676 pr_err("%s() failed return code=%d\n", e, ret);
677 break;
678 }
679 b_size++;
680 i++;
681 } while (*b_size);
682 keysize++;
683 } while (*keysize);
684
685 out:
686 aead_request_free(req);
687 out_noreq:
688 crypto_free_aead(tfm);
689 out_notfm:
690 kfree(sg);
691 out_nosg:
692 testmgr_free_buf(xoutbuf);
693 out_nooutbuf:
694 testmgr_free_buf(axbuf);
695 out_noaxbuf:
696 testmgr_free_buf(xbuf);
697 out_noxbuf:
698 kfree(iv);
699 }
700
test_hash_sg_init(struct scatterlist * sg)701 static void test_hash_sg_init(struct scatterlist *sg)
702 {
703 int i;
704
705 sg_init_table(sg, TVMEMSIZE);
706 for (i = 0; i < TVMEMSIZE; i++) {
707 sg_set_buf(sg + i, tvmem[i], PAGE_SIZE);
708 memset(tvmem[i], 0xff, PAGE_SIZE);
709 }
710 }
711
do_one_ahash_op(struct ahash_request * req,int ret)712 static inline int do_one_ahash_op(struct ahash_request *req, int ret)
713 {
714 struct crypto_wait *wait = req->base.data;
715
716 return crypto_wait_req(ret, wait);
717 }
718
test_ahash_jiffies_digest(struct ahash_request * req,int blen,char * out,int secs)719 static int test_ahash_jiffies_digest(struct ahash_request *req, int blen,
720 char *out, int secs)
721 {
722 unsigned long start, end;
723 int bcount;
724 int ret;
725
726 for (start = jiffies, end = start + secs * HZ, bcount = 0;
727 time_before(jiffies, end); bcount++) {
728 ret = do_one_ahash_op(req, crypto_ahash_digest(req));
729 if (ret)
730 return ret;
731 }
732
733 pr_cont("%6u opers/sec, %9lu bytes/sec\n",
734 bcount / secs, ((long)bcount * blen) / secs);
735
736 return 0;
737 }
738
test_ahash_jiffies(struct ahash_request * req,int blen,int plen,char * out,int secs)739 static int test_ahash_jiffies(struct ahash_request *req, int blen,
740 int plen, char *out, int secs)
741 {
742 unsigned long start, end;
743 int bcount, pcount;
744 int ret;
745
746 if (plen == blen)
747 return test_ahash_jiffies_digest(req, blen, out, secs);
748
749 for (start = jiffies, end = start + secs * HZ, bcount = 0;
750 time_before(jiffies, end); bcount++) {
751 ret = do_one_ahash_op(req, crypto_ahash_init(req));
752 if (ret)
753 return ret;
754 for (pcount = 0; pcount < blen; pcount += plen) {
755 ret = do_one_ahash_op(req, crypto_ahash_update(req));
756 if (ret)
757 return ret;
758 }
759 /* we assume there is enough space in 'out' for the result */
760 ret = do_one_ahash_op(req, crypto_ahash_final(req));
761 if (ret)
762 return ret;
763 }
764
765 pr_cont("%6u opers/sec, %9lu bytes/sec\n",
766 bcount / secs, ((long)bcount * blen) / secs);
767
768 return 0;
769 }
770
test_ahash_cycles_digest(struct ahash_request * req,int blen,char * out)771 static int test_ahash_cycles_digest(struct ahash_request *req, int blen,
772 char *out)
773 {
774 unsigned long cycles = 0;
775 int ret, i;
776
777 /* Warm-up run. */
778 for (i = 0; i < 4; i++) {
779 ret = do_one_ahash_op(req, crypto_ahash_digest(req));
780 if (ret)
781 goto out;
782 }
783
784 /* The real thing. */
785 for (i = 0; i < 8; i++) {
786 cycles_t start, end;
787
788 start = get_cycles();
789
790 ret = do_one_ahash_op(req, crypto_ahash_digest(req));
791 if (ret)
792 goto out;
793
794 end = get_cycles();
795
796 cycles += end - start;
797 }
798
799 out:
800 if (ret)
801 return ret;
802
803 pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
804 cycles / 8, cycles / (8 * blen));
805
806 return 0;
807 }
808
test_ahash_cycles(struct ahash_request * req,int blen,int plen,char * out)809 static int test_ahash_cycles(struct ahash_request *req, int blen,
810 int plen, char *out)
811 {
812 unsigned long cycles = 0;
813 int i, pcount, ret;
814
815 if (plen == blen)
816 return test_ahash_cycles_digest(req, blen, out);
817
818 /* Warm-up run. */
819 for (i = 0; i < 4; i++) {
820 ret = do_one_ahash_op(req, crypto_ahash_init(req));
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
833 /* The real thing. */
834 for (i = 0; i < 8; i++) {
835 cycles_t start, end;
836
837 start = get_cycles();
838
839 ret = do_one_ahash_op(req, crypto_ahash_init(req));
840 if (ret)
841 goto out;
842 for (pcount = 0; pcount < blen; pcount += plen) {
843 ret = do_one_ahash_op(req, crypto_ahash_update(req));
844 if (ret)
845 goto out;
846 }
847 ret = do_one_ahash_op(req, crypto_ahash_final(req));
848 if (ret)
849 goto out;
850
851 end = get_cycles();
852
853 cycles += end - start;
854 }
855
856 out:
857 if (ret)
858 return ret;
859
860 pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
861 cycles / 8, cycles / (8 * blen));
862
863 return 0;
864 }
865
test_ahash_speed_common(const char * algo,unsigned int secs,struct hash_speed * speed,unsigned mask)866 static void test_ahash_speed_common(const char *algo, unsigned int secs,
867 struct hash_speed *speed, unsigned mask)
868 {
869 struct scatterlist sg[TVMEMSIZE];
870 struct crypto_wait wait;
871 struct ahash_request *req;
872 struct crypto_ahash *tfm;
873 char *output;
874 int i, ret;
875
876 tfm = crypto_alloc_ahash(algo, 0, mask);
877 if (IS_ERR(tfm)) {
878 pr_err("failed to load transform for %s: %ld\n",
879 algo, PTR_ERR(tfm));
880 return;
881 }
882
883 pr_info("testing speed of async %s (%s)\n", algo,
884 get_driver_name(crypto_ahash, tfm));
885
886 if (crypto_ahash_digestsize(tfm) > MAX_DIGEST_SIZE) {
887 pr_err("digestsize(%u) > %d\n", crypto_ahash_digestsize(tfm),
888 MAX_DIGEST_SIZE);
889 goto out;
890 }
891
892 test_hash_sg_init(sg);
893 req = ahash_request_alloc(tfm, GFP_KERNEL);
894 if (!req) {
895 pr_err("ahash request allocation failure\n");
896 goto out;
897 }
898
899 crypto_init_wait(&wait);
900 ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
901 crypto_req_done, &wait);
902
903 output = kmalloc(MAX_DIGEST_SIZE, GFP_KERNEL);
904 if (!output)
905 goto out_nomem;
906
907 for (i = 0; speed[i].blen != 0; i++) {
908 if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
909 pr_err("template (%u) too big for tvmem (%lu)\n",
910 speed[i].blen, TVMEMSIZE * PAGE_SIZE);
911 break;
912 }
913
914 if (klen) {
915 ret = crypto_ahash_setkey(tfm, tvmem[0], klen);
916 if (ret) {
917 pr_err("setkey() failed flags=%x: %d\n",
918 crypto_ahash_get_flags(tfm), ret);
919 break;
920 }
921 }
922
923 pr_info("test%3u "
924 "(%5u byte blocks,%5u bytes per update,%4u updates): ",
925 i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
926
927 ahash_request_set_crypt(req, sg, output, speed[i].plen);
928
929 if (secs) {
930 ret = test_ahash_jiffies(req, speed[i].blen,
931 speed[i].plen, output, secs);
932 cond_resched();
933 } else {
934 ret = test_ahash_cycles(req, speed[i].blen,
935 speed[i].plen, output);
936 }
937
938 if (ret) {
939 pr_err("hashing failed ret=%d\n", ret);
940 break;
941 }
942 }
943
944 kfree(output);
945
946 out_nomem:
947 ahash_request_free(req);
948
949 out:
950 crypto_free_ahash(tfm);
951 }
952
test_ahash_speed(const char * algo,unsigned int secs,struct hash_speed * speed)953 static void test_ahash_speed(const char *algo, unsigned int secs,
954 struct hash_speed *speed)
955 {
956 return test_ahash_speed_common(algo, secs, speed, 0);
957 }
958
test_hash_speed(const char * algo,unsigned int secs,struct hash_speed * speed)959 static void test_hash_speed(const char *algo, unsigned int secs,
960 struct hash_speed *speed)
961 {
962 return test_ahash_speed_common(algo, secs, speed, CRYPTO_ALG_ASYNC);
963 }
964
965 struct test_mb_skcipher_data {
966 struct scatterlist sg[XBUFSIZE];
967 struct skcipher_request *req;
968 struct crypto_wait wait;
969 char *xbuf[XBUFSIZE];
970 };
971
do_mult_acipher_op(struct test_mb_skcipher_data * data,int enc,u32 num_mb,int * rc)972 static int do_mult_acipher_op(struct test_mb_skcipher_data *data, int enc,
973 u32 num_mb, int *rc)
974 {
975 int i, err = 0;
976
977 /* Fire up a bunch of concurrent requests */
978 for (i = 0; i < num_mb; i++) {
979 if (enc == ENCRYPT)
980 rc[i] = crypto_skcipher_encrypt(data[i].req);
981 else
982 rc[i] = crypto_skcipher_decrypt(data[i].req);
983 }
984
985 /* Wait for all requests to finish */
986 for (i = 0; i < num_mb; i++) {
987 rc[i] = crypto_wait_req(rc[i], &data[i].wait);
988
989 if (rc[i]) {
990 pr_info("concurrent request %d error %d\n", i, rc[i]);
991 err = rc[i];
992 }
993 }
994
995 return err;
996 }
997
test_mb_acipher_jiffies(struct test_mb_skcipher_data * data,int enc,int blen,int secs,u32 num_mb)998 static int test_mb_acipher_jiffies(struct test_mb_skcipher_data *data, int enc,
999 int blen, int secs, u32 num_mb)
1000 {
1001 unsigned long start, end;
1002 int bcount;
1003 int ret = 0;
1004 int *rc;
1005
1006 rc = kzalloc_objs(*rc, num_mb);
1007 if (!rc)
1008 return -ENOMEM;
1009
1010 for (start = jiffies, end = start + secs * HZ, bcount = 0;
1011 time_before(jiffies, end); bcount++) {
1012 ret = do_mult_acipher_op(data, enc, num_mb, rc);
1013 if (ret)
1014 goto out;
1015 }
1016
1017 pr_cont("%d operations in %d seconds (%llu bytes)\n",
1018 bcount * num_mb, secs, (u64)bcount * blen * num_mb);
1019
1020 out:
1021 kfree(rc);
1022 return ret;
1023 }
1024
test_mb_acipher_cycles(struct test_mb_skcipher_data * data,int enc,int blen,u32 num_mb)1025 static int test_mb_acipher_cycles(struct test_mb_skcipher_data *data, int enc,
1026 int blen, u32 num_mb)
1027 {
1028 unsigned long cycles = 0;
1029 int ret = 0;
1030 int i;
1031 int *rc;
1032
1033 rc = kzalloc_objs(*rc, num_mb);
1034 if (!rc)
1035 return -ENOMEM;
1036
1037 /* Warm-up run. */
1038 for (i = 0; i < 4; i++) {
1039 ret = do_mult_acipher_op(data, enc, num_mb, rc);
1040 if (ret)
1041 goto out;
1042 }
1043
1044 /* The real thing. */
1045 for (i = 0; i < 8; i++) {
1046 cycles_t start, end;
1047
1048 start = get_cycles();
1049 ret = do_mult_acipher_op(data, enc, num_mb, rc);
1050 end = get_cycles();
1051
1052 if (ret)
1053 goto out;
1054
1055 cycles += end - start;
1056 }
1057
1058 pr_cont("1 operation in %lu cycles (%d bytes)\n",
1059 (cycles + 4) / (8 * num_mb), blen);
1060
1061 out:
1062 kfree(rc);
1063 return ret;
1064 }
1065
test_mb_skcipher_speed(const char * algo,int enc,int secs,struct cipher_speed_template * template,unsigned int tcount,u8 * keysize,u32 num_mb)1066 static void test_mb_skcipher_speed(const char *algo, int enc, int secs,
1067 struct cipher_speed_template *template,
1068 unsigned int tcount, u8 *keysize, u32 num_mb)
1069 {
1070 struct test_mb_skcipher_data *data;
1071 struct crypto_skcipher *tfm;
1072 unsigned int i, j, iv_len;
1073 const int *b_size;
1074 const char *key;
1075 const char *e;
1076 char iv[128];
1077 int ret;
1078
1079 if (enc == ENCRYPT)
1080 e = "encryption";
1081 else
1082 e = "decryption";
1083
1084 data = kzalloc_objs(*data, num_mb);
1085 if (!data)
1086 return;
1087
1088 tfm = crypto_alloc_skcipher(algo, 0, 0);
1089 if (IS_ERR(tfm)) {
1090 pr_err("failed to load transform for %s: %ld\n",
1091 algo, PTR_ERR(tfm));
1092 goto out_free_data;
1093 }
1094
1095 for (i = 0; i < num_mb; ++i)
1096 if (testmgr_alloc_buf(data[i].xbuf)) {
1097 while (i--)
1098 testmgr_free_buf(data[i].xbuf);
1099 goto out_free_tfm;
1100 }
1101
1102 for (i = 0; i < num_mb; ++i) {
1103 data[i].req = skcipher_request_alloc(tfm, GFP_KERNEL);
1104 if (!data[i].req) {
1105 pr_err("alg: skcipher: Failed to allocate request for %s\n",
1106 algo);
1107 while (i--)
1108 skcipher_request_free(data[i].req);
1109 goto out_free_xbuf;
1110 }
1111 }
1112
1113 for (i = 0; i < num_mb; ++i) {
1114 skcipher_request_set_callback(data[i].req,
1115 CRYPTO_TFM_REQ_MAY_BACKLOG,
1116 crypto_req_done, &data[i].wait);
1117 crypto_init_wait(&data[i].wait);
1118 }
1119
1120 pr_info("testing speed of multibuffer %s (%s) %s\n", algo,
1121 get_driver_name(crypto_skcipher, tfm), e);
1122
1123 i = 0;
1124 do {
1125 b_size = block_sizes;
1126 do {
1127 u32 bs = round_up(*b_size, crypto_skcipher_blocksize(tfm));
1128
1129 if (bs > XBUFSIZE * PAGE_SIZE) {
1130 pr_err("template (%u) too big for buffer (%lu)\n",
1131 bs, XBUFSIZE * PAGE_SIZE);
1132 goto out;
1133 }
1134
1135 pr_info("test %u (%d bit key, %d byte blocks): ", i,
1136 *keysize * 8, bs);
1137
1138 /* Set up tfm global state, i.e. the key */
1139
1140 memset(tvmem[0], 0xff, PAGE_SIZE);
1141 key = tvmem[0];
1142 for (j = 0; j < tcount; j++) {
1143 if (template[j].klen == *keysize) {
1144 key = template[j].key;
1145 break;
1146 }
1147 }
1148
1149 crypto_skcipher_clear_flags(tfm, ~0);
1150
1151 ret = crypto_skcipher_setkey(tfm, key, *keysize);
1152 if (ret) {
1153 pr_err("setkey() failed flags=%x\n",
1154 crypto_skcipher_get_flags(tfm));
1155 goto out;
1156 }
1157
1158 iv_len = crypto_skcipher_ivsize(tfm);
1159 if (iv_len)
1160 memset(&iv, 0xff, iv_len);
1161
1162 /* Now setup per request stuff, i.e. buffers */
1163
1164 for (j = 0; j < num_mb; ++j) {
1165 struct test_mb_skcipher_data *cur = &data[j];
1166 unsigned int k = bs;
1167 unsigned int pages = DIV_ROUND_UP(k, PAGE_SIZE);
1168 unsigned int p = 0;
1169
1170 sg_init_table(cur->sg, pages);
1171
1172 while (k > PAGE_SIZE) {
1173 sg_set_buf(cur->sg + p, cur->xbuf[p],
1174 PAGE_SIZE);
1175 memset(cur->xbuf[p], 0xff, PAGE_SIZE);
1176 p++;
1177 k -= PAGE_SIZE;
1178 }
1179
1180 sg_set_buf(cur->sg + p, cur->xbuf[p], k);
1181 memset(cur->xbuf[p], 0xff, k);
1182
1183 skcipher_request_set_crypt(cur->req, cur->sg,
1184 cur->sg, bs, iv);
1185 }
1186
1187 if (secs) {
1188 ret = test_mb_acipher_jiffies(data, enc,
1189 bs, secs,
1190 num_mb);
1191 cond_resched();
1192 } else {
1193 ret = test_mb_acipher_cycles(data, enc,
1194 bs, num_mb);
1195 }
1196
1197 if (ret) {
1198 pr_err("%s() failed flags=%x\n", e,
1199 crypto_skcipher_get_flags(tfm));
1200 break;
1201 }
1202 b_size++;
1203 i++;
1204 } while (*b_size);
1205 keysize++;
1206 } while (*keysize);
1207
1208 out:
1209 for (i = 0; i < num_mb; ++i)
1210 skcipher_request_free(data[i].req);
1211 out_free_xbuf:
1212 for (i = 0; i < num_mb; ++i)
1213 testmgr_free_buf(data[i].xbuf);
1214 out_free_tfm:
1215 crypto_free_skcipher(tfm);
1216 out_free_data:
1217 kfree(data);
1218 }
1219
do_one_acipher_op(struct skcipher_request * req,int ret)1220 static inline int do_one_acipher_op(struct skcipher_request *req, int ret)
1221 {
1222 struct crypto_wait *wait = req->base.data;
1223
1224 return crypto_wait_req(ret, wait);
1225 }
1226
test_acipher_jiffies(struct skcipher_request * req,int enc,int blen,int secs)1227 static int test_acipher_jiffies(struct skcipher_request *req, int enc,
1228 int blen, int secs)
1229 {
1230 unsigned long start, end;
1231 int bcount;
1232 int ret;
1233
1234 for (start = jiffies, end = start + secs * HZ, bcount = 0;
1235 time_before(jiffies, end); bcount++) {
1236 if (enc)
1237 ret = do_one_acipher_op(req,
1238 crypto_skcipher_encrypt(req));
1239 else
1240 ret = do_one_acipher_op(req,
1241 crypto_skcipher_decrypt(req));
1242
1243 if (ret)
1244 return ret;
1245 }
1246
1247 pr_cont("%d operations in %d seconds (%llu bytes)\n",
1248 bcount, secs, (u64)bcount * blen);
1249 return 0;
1250 }
1251
test_acipher_cycles(struct skcipher_request * req,int enc,int blen)1252 static int test_acipher_cycles(struct skcipher_request *req, int enc,
1253 int blen)
1254 {
1255 unsigned long cycles = 0;
1256 int ret = 0;
1257 int i;
1258
1259 /* Warm-up run. */
1260 for (i = 0; i < 4; i++) {
1261 if (enc)
1262 ret = do_one_acipher_op(req,
1263 crypto_skcipher_encrypt(req));
1264 else
1265 ret = do_one_acipher_op(req,
1266 crypto_skcipher_decrypt(req));
1267
1268 if (ret)
1269 goto out;
1270 }
1271
1272 /* The real thing. */
1273 for (i = 0; i < 8; i++) {
1274 cycles_t start, end;
1275
1276 start = get_cycles();
1277 if (enc)
1278 ret = do_one_acipher_op(req,
1279 crypto_skcipher_encrypt(req));
1280 else
1281 ret = do_one_acipher_op(req,
1282 crypto_skcipher_decrypt(req));
1283 end = get_cycles();
1284
1285 if (ret)
1286 goto out;
1287
1288 cycles += end - start;
1289 }
1290
1291 out:
1292 if (ret == 0)
1293 pr_cont("1 operation in %lu cycles (%d bytes)\n",
1294 (cycles + 4) / 8, blen);
1295
1296 return ret;
1297 }
1298
test_skcipher_speed(const char * algo,int enc,unsigned int secs,struct cipher_speed_template * template,unsigned int tcount,u8 * keysize,bool async)1299 static void test_skcipher_speed(const char *algo, int enc, unsigned int secs,
1300 struct cipher_speed_template *template,
1301 unsigned int tcount, u8 *keysize, bool async)
1302 {
1303 unsigned int ret, i, j, k, iv_len;
1304 struct crypto_wait wait;
1305 const char *key;
1306 char iv[128];
1307 struct skcipher_request *req;
1308 struct crypto_skcipher *tfm;
1309 const int *b_size;
1310 const char *e;
1311
1312 if (enc == ENCRYPT)
1313 e = "encryption";
1314 else
1315 e = "decryption";
1316
1317 crypto_init_wait(&wait);
1318
1319 tfm = crypto_alloc_skcipher(algo, 0, async ? 0 : CRYPTO_ALG_ASYNC);
1320
1321 if (IS_ERR(tfm)) {
1322 pr_err("failed to load transform for %s: %ld\n", algo,
1323 PTR_ERR(tfm));
1324 return;
1325 }
1326
1327 pr_info("testing speed of %s %s (%s) %s\n", async ? "async" : "sync",
1328 algo, get_driver_name(crypto_skcipher, tfm), e);
1329
1330 req = skcipher_request_alloc(tfm, GFP_KERNEL);
1331 if (!req) {
1332 pr_err("skcipher: Failed to allocate request for %s\n", algo);
1333 goto out;
1334 }
1335
1336 skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1337 crypto_req_done, &wait);
1338
1339 i = 0;
1340 do {
1341 b_size = block_sizes;
1342
1343 do {
1344 u32 bs = round_up(*b_size, crypto_skcipher_blocksize(tfm));
1345 struct scatterlist sg[TVMEMSIZE];
1346
1347 if ((*keysize + bs) > TVMEMSIZE * PAGE_SIZE) {
1348 pr_err("template (%u) too big for "
1349 "tvmem (%lu)\n", *keysize + bs,
1350 TVMEMSIZE * PAGE_SIZE);
1351 goto out_free_req;
1352 }
1353
1354 pr_info("test %u (%d bit key, %d byte blocks): ", i,
1355 *keysize * 8, bs);
1356
1357 memset(tvmem[0], 0xff, PAGE_SIZE);
1358
1359 /* set key, plain text and IV */
1360 key = tvmem[0];
1361 for (j = 0; j < tcount; j++) {
1362 if (template[j].klen == *keysize) {
1363 key = template[j].key;
1364 break;
1365 }
1366 }
1367
1368 crypto_skcipher_clear_flags(tfm, ~0);
1369
1370 ret = crypto_skcipher_setkey(tfm, key, *keysize);
1371 if (ret) {
1372 pr_err("setkey() failed flags=%x\n",
1373 crypto_skcipher_get_flags(tfm));
1374 goto out_free_req;
1375 }
1376
1377 k = *keysize + bs;
1378 sg_init_table(sg, DIV_ROUND_UP(k, PAGE_SIZE));
1379
1380 if (k > PAGE_SIZE) {
1381 sg_set_buf(sg, tvmem[0] + *keysize,
1382 PAGE_SIZE - *keysize);
1383 k -= PAGE_SIZE;
1384 j = 1;
1385 while (k > PAGE_SIZE) {
1386 sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
1387 memset(tvmem[j], 0xff, PAGE_SIZE);
1388 j++;
1389 k -= PAGE_SIZE;
1390 }
1391 sg_set_buf(sg + j, tvmem[j], k);
1392 memset(tvmem[j], 0xff, k);
1393 } else {
1394 sg_set_buf(sg, tvmem[0] + *keysize, bs);
1395 }
1396
1397 iv_len = crypto_skcipher_ivsize(tfm);
1398 if (iv_len)
1399 memset(&iv, 0xff, iv_len);
1400
1401 skcipher_request_set_crypt(req, sg, sg, bs, iv);
1402
1403 if (secs) {
1404 ret = test_acipher_jiffies(req, enc,
1405 bs, secs);
1406 cond_resched();
1407 } else {
1408 ret = test_acipher_cycles(req, enc,
1409 bs);
1410 }
1411
1412 if (ret) {
1413 pr_err("%s() failed flags=%x\n", e,
1414 crypto_skcipher_get_flags(tfm));
1415 break;
1416 }
1417 b_size++;
1418 i++;
1419 } while (*b_size);
1420 keysize++;
1421 } while (*keysize);
1422
1423 out_free_req:
1424 skcipher_request_free(req);
1425 out:
1426 crypto_free_skcipher(tfm);
1427 }
1428
test_acipher_speed(const char * algo,int enc,unsigned int secs,struct cipher_speed_template * template,unsigned int tcount,u8 * keysize)1429 static void test_acipher_speed(const char *algo, int enc, unsigned int secs,
1430 struct cipher_speed_template *template,
1431 unsigned int tcount, u8 *keysize)
1432 {
1433 return test_skcipher_speed(algo, enc, secs, template, tcount, keysize,
1434 true);
1435 }
1436
test_cipher_speed(const char * algo,int enc,unsigned int secs,struct cipher_speed_template * template,unsigned int tcount,u8 * keysize)1437 static void test_cipher_speed(const char *algo, int enc, unsigned int secs,
1438 struct cipher_speed_template *template,
1439 unsigned int tcount, u8 *keysize)
1440 {
1441 return test_skcipher_speed(algo, enc, secs, template, tcount, keysize,
1442 false);
1443 }
1444
tcrypt_test(const char * alg)1445 static inline int tcrypt_test(const char *alg)
1446 {
1447 int ret;
1448
1449 pr_debug("testing %s\n", alg);
1450
1451 ret = alg_test(alg, alg, 0, 0);
1452 /* non-fips algs return -EINVAL or -ECANCELED in fips mode */
1453 if (fips_enabled && (ret == -EINVAL || ret == -ECANCELED))
1454 ret = 0;
1455 return ret;
1456 }
1457
do_test(const char * alg,u32 type,u32 mask,int m,u32 num_mb)1458 static int do_test(const char *alg, u32 type, u32 mask, int m, u32 num_mb)
1459 {
1460 int i;
1461 int ret = 0;
1462
1463 switch (m) {
1464 case 0:
1465 if (alg) {
1466 if (!crypto_has_alg(alg, type,
1467 mask ?: CRYPTO_ALG_TYPE_MASK))
1468 ret = -ENOENT;
1469 break;
1470 }
1471
1472 for (i = 1; i < 200; i++)
1473 ret = min(ret, do_test(NULL, 0, 0, i, num_mb));
1474 break;
1475
1476 case 1:
1477 ret = min(ret, tcrypt_test("md5"));
1478 break;
1479
1480 case 2:
1481 ret = min(ret, tcrypt_test("sha1"));
1482 break;
1483
1484 case 3:
1485 ret = min(ret, tcrypt_test("ecb(des)"));
1486 ret = min(ret, tcrypt_test("cbc(des)"));
1487 ret = min(ret, tcrypt_test("ctr(des)"));
1488 break;
1489
1490 case 4:
1491 ret = min(ret, tcrypt_test("ecb(des3_ede)"));
1492 ret = min(ret, tcrypt_test("cbc(des3_ede)"));
1493 ret = min(ret, tcrypt_test("ctr(des3_ede)"));
1494 break;
1495
1496 case 5:
1497 ret = min(ret, tcrypt_test("md4"));
1498 break;
1499
1500 case 6:
1501 ret = min(ret, tcrypt_test("sha256"));
1502 break;
1503
1504 case 7:
1505 ret = min(ret, tcrypt_test("ecb(blowfish)"));
1506 ret = min(ret, tcrypt_test("cbc(blowfish)"));
1507 ret = min(ret, tcrypt_test("ctr(blowfish)"));
1508 break;
1509
1510 case 8:
1511 ret = min(ret, tcrypt_test("ecb(twofish)"));
1512 ret = min(ret, tcrypt_test("cbc(twofish)"));
1513 ret = min(ret, tcrypt_test("ctr(twofish)"));
1514 ret = min(ret, tcrypt_test("lrw(twofish)"));
1515 ret = min(ret, tcrypt_test("xts(twofish)"));
1516 break;
1517
1518 case 9:
1519 ret = min(ret, tcrypt_test("ecb(serpent)"));
1520 ret = min(ret, tcrypt_test("cbc(serpent)"));
1521 ret = min(ret, tcrypt_test("ctr(serpent)"));
1522 ret = min(ret, tcrypt_test("lrw(serpent)"));
1523 ret = min(ret, tcrypt_test("xts(serpent)"));
1524 break;
1525
1526 case 10:
1527 ret = min(ret, tcrypt_test("ecb(aes)"));
1528 ret = min(ret, tcrypt_test("cbc(aes)"));
1529 ret = min(ret, tcrypt_test("lrw(aes)"));
1530 ret = min(ret, tcrypt_test("xts(aes)"));
1531 ret = min(ret, tcrypt_test("ctr(aes)"));
1532 ret = min(ret, tcrypt_test("rfc3686(ctr(aes))"));
1533 ret = min(ret, tcrypt_test("xctr(aes)"));
1534 break;
1535
1536 case 11:
1537 ret = min(ret, tcrypt_test("sha384"));
1538 break;
1539
1540 case 12:
1541 ret = min(ret, tcrypt_test("sha512"));
1542 break;
1543
1544 case 13:
1545 ret = min(ret, tcrypt_test("deflate"));
1546 break;
1547
1548 case 14:
1549 ret = min(ret, tcrypt_test("ecb(cast5)"));
1550 ret = min(ret, tcrypt_test("cbc(cast5)"));
1551 ret = min(ret, tcrypt_test("ctr(cast5)"));
1552 break;
1553
1554 case 15:
1555 ret = min(ret, tcrypt_test("ecb(cast6)"));
1556 ret = min(ret, tcrypt_test("cbc(cast6)"));
1557 ret = min(ret, tcrypt_test("ctr(cast6)"));
1558 ret = min(ret, tcrypt_test("lrw(cast6)"));
1559 ret = min(ret, tcrypt_test("xts(cast6)"));
1560 break;
1561
1562 case 16:
1563 ret = min(ret, tcrypt_test("ecb(arc4)"));
1564 break;
1565
1566 case 18:
1567 ret = min(ret, tcrypt_test("crc32c"));
1568 break;
1569
1570 case 19:
1571 ret = min(ret, tcrypt_test("ecb(tea)"));
1572 break;
1573
1574 case 20:
1575 ret = min(ret, tcrypt_test("ecb(xtea)"));
1576 break;
1577
1578 case 21:
1579 ret = min(ret, tcrypt_test("ecb(khazad)"));
1580 break;
1581
1582 case 22:
1583 ret = min(ret, tcrypt_test("wp512"));
1584 break;
1585
1586 case 23:
1587 ret = min(ret, tcrypt_test("wp384"));
1588 break;
1589
1590 case 24:
1591 ret = min(ret, tcrypt_test("wp256"));
1592 break;
1593
1594 case 26:
1595 ret = min(ret, tcrypt_test("ecb(anubis)"));
1596 ret = min(ret, tcrypt_test("cbc(anubis)"));
1597 break;
1598
1599 case 30:
1600 ret = min(ret, tcrypt_test("ecb(xeta)"));
1601 break;
1602
1603 case 31:
1604 ret = min(ret, tcrypt_test("pcbc(fcrypt)"));
1605 break;
1606
1607 case 32:
1608 ret = min(ret, tcrypt_test("ecb(camellia)"));
1609 ret = min(ret, tcrypt_test("cbc(camellia)"));
1610 ret = min(ret, tcrypt_test("ctr(camellia)"));
1611 ret = min(ret, tcrypt_test("lrw(camellia)"));
1612 ret = min(ret, tcrypt_test("xts(camellia)"));
1613 break;
1614
1615 case 33:
1616 ret = min(ret, tcrypt_test("sha224"));
1617 break;
1618
1619 case 35:
1620 ret = min(ret, tcrypt_test("gcm(aes)"));
1621 break;
1622
1623 case 36:
1624 ret = min(ret, tcrypt_test("lzo"));
1625 break;
1626
1627 case 37:
1628 ret = min(ret, tcrypt_test("ccm(aes)"));
1629 break;
1630
1631 case 38:
1632 ret = min(ret, tcrypt_test("cts(cbc(aes))"));
1633 break;
1634
1635 case 39:
1636 ret = min(ret, tcrypt_test("xxhash64"));
1637 break;
1638
1639 case 40:
1640 ret = min(ret, tcrypt_test("rmd160"));
1641 break;
1642
1643 case 42:
1644 ret = min(ret, tcrypt_test("blake2b-512"));
1645 break;
1646
1647 case 43:
1648 ret = min(ret, tcrypt_test("ecb(seed)"));
1649 break;
1650
1651 case 45:
1652 ret = min(ret, tcrypt_test("rfc4309(ccm(aes))"));
1653 break;
1654
1655 case 48:
1656 ret = min(ret, tcrypt_test("sha3-224"));
1657 break;
1658
1659 case 49:
1660 ret = min(ret, tcrypt_test("sha3-256"));
1661 break;
1662
1663 case 50:
1664 ret = min(ret, tcrypt_test("sha3-384"));
1665 break;
1666
1667 case 51:
1668 ret = min(ret, tcrypt_test("sha3-512"));
1669 break;
1670
1671 case 52:
1672 ret = min(ret, tcrypt_test("sm3"));
1673 break;
1674
1675 case 53:
1676 ret = min(ret, tcrypt_test("streebog256"));
1677 break;
1678
1679 case 54:
1680 ret = min(ret, tcrypt_test("streebog512"));
1681 break;
1682
1683 case 55:
1684 ret = min(ret, tcrypt_test("gcm(sm4)"));
1685 break;
1686
1687 case 56:
1688 ret = min(ret, tcrypt_test("ccm(sm4)"));
1689 break;
1690
1691 case 58:
1692 ret = min(ret, tcrypt_test("gcm(aria)"));
1693 break;
1694
1695 case 59:
1696 ret = min(ret, tcrypt_test("cts(cbc(sm4))"));
1697 break;
1698
1699 case 100:
1700 ret = min(ret, tcrypt_test("hmac(md5)"));
1701 break;
1702
1703 case 101:
1704 ret = min(ret, tcrypt_test("hmac(sha1)"));
1705 break;
1706
1707 case 102:
1708 ret = min(ret, tcrypt_test("hmac(sha256)"));
1709 break;
1710
1711 case 103:
1712 ret = min(ret, tcrypt_test("hmac(sha384)"));
1713 break;
1714
1715 case 104:
1716 ret = min(ret, tcrypt_test("hmac(sha512)"));
1717 break;
1718
1719 case 105:
1720 ret = min(ret, tcrypt_test("hmac(sha224)"));
1721 break;
1722
1723 case 106:
1724 ret = min(ret, tcrypt_test("xcbc(aes)"));
1725 break;
1726
1727 case 108:
1728 ret = min(ret, tcrypt_test("hmac(rmd160)"));
1729 break;
1730
1731 case 111:
1732 ret = min(ret, tcrypt_test("hmac(sha3-224)"));
1733 break;
1734
1735 case 112:
1736 ret = min(ret, tcrypt_test("hmac(sha3-256)"));
1737 break;
1738
1739 case 113:
1740 ret = min(ret, tcrypt_test("hmac(sha3-384)"));
1741 break;
1742
1743 case 114:
1744 ret = min(ret, tcrypt_test("hmac(sha3-512)"));
1745 break;
1746
1747 case 115:
1748 ret = min(ret, tcrypt_test("hmac(streebog256)"));
1749 break;
1750
1751 case 116:
1752 ret = min(ret, tcrypt_test("hmac(streebog512)"));
1753 break;
1754
1755 case 151:
1756 ret = min(ret, tcrypt_test("rfc4106(gcm(aes))"));
1757 break;
1758
1759 case 152:
1760 ret = min(ret, tcrypt_test("rfc4543(gcm(aes))"));
1761 break;
1762
1763 case 153:
1764 ret = min(ret, tcrypt_test("cmac(aes)"));
1765 break;
1766
1767 case 154:
1768 ret = min(ret, tcrypt_test("cmac(des3_ede)"));
1769 break;
1770
1771 case 155:
1772 ret = min(ret, tcrypt_test("authenc(hmac(sha1),cbc(aes))"));
1773 break;
1774
1775 case 156:
1776 ret = min(ret, tcrypt_test("authenc(hmac(md5),ecb(cipher_null))"));
1777 break;
1778
1779 case 157:
1780 ret = min(ret, tcrypt_test("authenc(hmac(sha1),ecb(cipher_null))"));
1781 break;
1782
1783 case 158:
1784 ret = min(ret, tcrypt_test("cbcmac(sm4)"));
1785 break;
1786
1787 case 159:
1788 ret = min(ret, tcrypt_test("cmac(sm4)"));
1789 break;
1790
1791 case 160:
1792 ret = min(ret, tcrypt_test("xcbc(sm4)"));
1793 break;
1794
1795 case 181:
1796 ret = min(ret, tcrypt_test("authenc(hmac(sha1),cbc(des))"));
1797 break;
1798 case 182:
1799 ret = min(ret, tcrypt_test("authenc(hmac(sha1),cbc(des3_ede))"));
1800 break;
1801 case 183:
1802 ret = min(ret, tcrypt_test("authenc(hmac(sha224),cbc(des))"));
1803 break;
1804 case 184:
1805 ret = min(ret, tcrypt_test("authenc(hmac(sha224),cbc(des3_ede))"));
1806 break;
1807 case 185:
1808 ret = min(ret, tcrypt_test("authenc(hmac(sha256),cbc(des))"));
1809 break;
1810 case 186:
1811 ret = min(ret, tcrypt_test("authenc(hmac(sha256),cbc(des3_ede))"));
1812 break;
1813 case 187:
1814 ret = min(ret, tcrypt_test("authenc(hmac(sha384),cbc(des))"));
1815 break;
1816 case 188:
1817 ret = min(ret, tcrypt_test("authenc(hmac(sha384),cbc(des3_ede))"));
1818 break;
1819 case 189:
1820 ret = min(ret, tcrypt_test("authenc(hmac(sha512),cbc(des))"));
1821 break;
1822 case 190:
1823 ret = min(ret, tcrypt_test("authenc(hmac(sha512),cbc(des3_ede))"));
1824 break;
1825 case 191:
1826 ret = min(ret, tcrypt_test("ecb(sm4)"));
1827 ret = min(ret, tcrypt_test("cbc(sm4)"));
1828 ret = min(ret, tcrypt_test("ctr(sm4)"));
1829 ret = min(ret, tcrypt_test("xts(sm4)"));
1830 break;
1831 case 192:
1832 ret = min(ret, tcrypt_test("ecb(aria)"));
1833 ret = min(ret, tcrypt_test("cbc(aria)"));
1834 ret = min(ret, tcrypt_test("ctr(aria)"));
1835 break;
1836 case 193:
1837 ret = min(ret, tcrypt_test("ffdhe2048(dh)"));
1838 break;
1839 case 200:
1840 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
1841 speed_template_16_24_32);
1842 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
1843 speed_template_16_24_32);
1844 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
1845 speed_template_16_24_32);
1846 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
1847 speed_template_16_24_32);
1848 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
1849 speed_template_32_40_48);
1850 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
1851 speed_template_32_40_48);
1852 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
1853 speed_template_32_64);
1854 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
1855 speed_template_32_64);
1856 test_cipher_speed("cts(cbc(aes))", ENCRYPT, sec, NULL, 0,
1857 speed_template_16_24_32);
1858 test_cipher_speed("cts(cbc(aes))", DECRYPT, sec, NULL, 0,
1859 speed_template_16_24_32);
1860 test_cipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
1861 speed_template_16_24_32);
1862 test_cipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
1863 speed_template_16_24_32);
1864 break;
1865
1866 case 201:
1867 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
1868 des3_speed_template, DES3_SPEED_VECTORS,
1869 speed_template_24);
1870 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
1871 des3_speed_template, DES3_SPEED_VECTORS,
1872 speed_template_24);
1873 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
1874 des3_speed_template, DES3_SPEED_VECTORS,
1875 speed_template_24);
1876 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
1877 des3_speed_template, DES3_SPEED_VECTORS,
1878 speed_template_24);
1879 test_cipher_speed("ctr(des3_ede)", ENCRYPT, sec,
1880 des3_speed_template, DES3_SPEED_VECTORS,
1881 speed_template_24);
1882 test_cipher_speed("ctr(des3_ede)", DECRYPT, sec,
1883 des3_speed_template, DES3_SPEED_VECTORS,
1884 speed_template_24);
1885 break;
1886
1887 case 202:
1888 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
1889 speed_template_16_24_32);
1890 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
1891 speed_template_16_24_32);
1892 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
1893 speed_template_16_24_32);
1894 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
1895 speed_template_16_24_32);
1896 test_cipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0,
1897 speed_template_16_24_32);
1898 test_cipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
1899 speed_template_16_24_32);
1900 test_cipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
1901 speed_template_32_40_48);
1902 test_cipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
1903 speed_template_32_40_48);
1904 test_cipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
1905 speed_template_32_48_64);
1906 test_cipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
1907 speed_template_32_48_64);
1908 break;
1909
1910 case 203:
1911 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
1912 speed_template_8_32);
1913 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
1914 speed_template_8_32);
1915 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
1916 speed_template_8_32);
1917 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
1918 speed_template_8_32);
1919 test_cipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0,
1920 speed_template_8_32);
1921 test_cipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0,
1922 speed_template_8_32);
1923 break;
1924
1925 case 204:
1926 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
1927 speed_template_8);
1928 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
1929 speed_template_8);
1930 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
1931 speed_template_8);
1932 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
1933 speed_template_8);
1934 break;
1935
1936 case 205:
1937 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
1938 speed_template_16_24_32);
1939 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
1940 speed_template_16_24_32);
1941 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
1942 speed_template_16_24_32);
1943 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
1944 speed_template_16_24_32);
1945 test_cipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0,
1946 speed_template_16_24_32);
1947 test_cipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0,
1948 speed_template_16_24_32);
1949 test_cipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0,
1950 speed_template_32_40_48);
1951 test_cipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0,
1952 speed_template_32_40_48);
1953 test_cipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0,
1954 speed_template_32_48_64);
1955 test_cipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0,
1956 speed_template_32_48_64);
1957 break;
1958
1959 case 207:
1960 test_cipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
1961 speed_template_16_32);
1962 test_cipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
1963 speed_template_16_32);
1964 test_cipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
1965 speed_template_16_32);
1966 test_cipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
1967 speed_template_16_32);
1968 test_cipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
1969 speed_template_16_32);
1970 test_cipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
1971 speed_template_16_32);
1972 test_cipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
1973 speed_template_32_48);
1974 test_cipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
1975 speed_template_32_48);
1976 test_cipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
1977 speed_template_32_64);
1978 test_cipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
1979 speed_template_32_64);
1980 break;
1981
1982 case 208:
1983 test_cipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0,
1984 speed_template_8);
1985 break;
1986
1987 case 209:
1988 test_cipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0,
1989 speed_template_8_16);
1990 test_cipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0,
1991 speed_template_8_16);
1992 test_cipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0,
1993 speed_template_8_16);
1994 test_cipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0,
1995 speed_template_8_16);
1996 test_cipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0,
1997 speed_template_8_16);
1998 test_cipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0,
1999 speed_template_8_16);
2000 break;
2001
2002 case 210:
2003 test_cipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0,
2004 speed_template_16_32);
2005 test_cipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0,
2006 speed_template_16_32);
2007 test_cipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0,
2008 speed_template_16_32);
2009 test_cipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0,
2010 speed_template_16_32);
2011 test_cipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0,
2012 speed_template_16_32);
2013 test_cipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0,
2014 speed_template_16_32);
2015 test_cipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0,
2016 speed_template_32_48);
2017 test_cipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0,
2018 speed_template_32_48);
2019 test_cipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0,
2020 speed_template_32_64);
2021 test_cipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0,
2022 speed_template_32_64);
2023 break;
2024
2025 case 211:
2026 test_aead_speed("rfc4106(gcm(aes))", ENCRYPT, sec,
2027 NULL, 0, 16, 16, aead_speed_template_20_28_36);
2028 test_aead_speed("gcm(aes)", ENCRYPT, sec,
2029 NULL, 0, 16, 8, speed_template_16_24_32);
2030 test_aead_speed("rfc4106(gcm(aes))", DECRYPT, sec,
2031 NULL, 0, 16, 16, aead_speed_template_20_28_36);
2032 test_aead_speed("gcm(aes)", DECRYPT, sec,
2033 NULL, 0, 16, 8, speed_template_16_24_32);
2034 break;
2035
2036 case 212:
2037 test_aead_speed("rfc4309(ccm(aes))", ENCRYPT, sec,
2038 NULL, 0, 16, 16, aead_speed_template_19);
2039 test_aead_speed("rfc4309(ccm(aes))", DECRYPT, sec,
2040 NULL, 0, 16, 16, aead_speed_template_19);
2041 break;
2042
2043 case 213:
2044 test_aead_speed("rfc7539esp(chacha20,poly1305)", ENCRYPT, sec,
2045 NULL, 0, 16, 8, aead_speed_template_36);
2046 test_aead_speed("rfc7539esp(chacha20,poly1305)", DECRYPT, sec,
2047 NULL, 0, 16, 8, aead_speed_template_36);
2048 break;
2049
2050 case 214:
2051 test_cipher_speed("chacha20", ENCRYPT, sec, NULL, 0,
2052 speed_template_32);
2053 break;
2054
2055 case 215:
2056 test_mb_aead_speed("rfc4106(gcm(aes))", ENCRYPT, sec, NULL,
2057 0, 16, 16, aead_speed_template_20_28_36, num_mb);
2058 test_mb_aead_speed("gcm(aes)", ENCRYPT, sec, NULL, 0, 16, 8,
2059 speed_template_16_24_32, num_mb);
2060 test_mb_aead_speed("rfc4106(gcm(aes))", DECRYPT, sec, NULL,
2061 0, 16, 16, aead_speed_template_20_28_36, num_mb);
2062 test_mb_aead_speed("gcm(aes)", DECRYPT, sec, NULL, 0, 16, 8,
2063 speed_template_16_24_32, num_mb);
2064 break;
2065
2066 case 216:
2067 test_mb_aead_speed("rfc4309(ccm(aes))", ENCRYPT, sec, NULL, 0,
2068 16, 16, aead_speed_template_19, num_mb);
2069 test_mb_aead_speed("rfc4309(ccm(aes))", DECRYPT, sec, NULL, 0,
2070 16, 16, aead_speed_template_19, num_mb);
2071 break;
2072
2073 case 217:
2074 test_mb_aead_speed("rfc7539esp(chacha20,poly1305)", ENCRYPT,
2075 sec, NULL, 0, 16, 8, aead_speed_template_36,
2076 num_mb);
2077 test_mb_aead_speed("rfc7539esp(chacha20,poly1305)", DECRYPT,
2078 sec, NULL, 0, 16, 8, aead_speed_template_36,
2079 num_mb);
2080 break;
2081
2082 case 218:
2083 test_cipher_speed("ecb(sm4)", ENCRYPT, sec, NULL, 0,
2084 speed_template_16);
2085 test_cipher_speed("ecb(sm4)", DECRYPT, sec, NULL, 0,
2086 speed_template_16);
2087 test_cipher_speed("cbc(sm4)", ENCRYPT, sec, NULL, 0,
2088 speed_template_16);
2089 test_cipher_speed("cbc(sm4)", DECRYPT, sec, NULL, 0,
2090 speed_template_16);
2091 test_cipher_speed("cts(cbc(sm4))", ENCRYPT, sec, NULL, 0,
2092 speed_template_16);
2093 test_cipher_speed("cts(cbc(sm4))", DECRYPT, sec, NULL, 0,
2094 speed_template_16);
2095 test_cipher_speed("ctr(sm4)", ENCRYPT, sec, NULL, 0,
2096 speed_template_16);
2097 test_cipher_speed("ctr(sm4)", DECRYPT, sec, NULL, 0,
2098 speed_template_16);
2099 test_cipher_speed("xts(sm4)", ENCRYPT, sec, NULL, 0,
2100 speed_template_32);
2101 test_cipher_speed("xts(sm4)", DECRYPT, sec, NULL, 0,
2102 speed_template_32);
2103 break;
2104
2105 case 219:
2106 test_cipher_speed("adiantum(xchacha12,aes)", ENCRYPT, sec, NULL,
2107 0, speed_template_32);
2108 test_cipher_speed("adiantum(xchacha12,aes)", DECRYPT, sec, NULL,
2109 0, speed_template_32);
2110 test_cipher_speed("adiantum(xchacha20,aes)", ENCRYPT, sec, NULL,
2111 0, speed_template_32);
2112 test_cipher_speed("adiantum(xchacha20,aes)", DECRYPT, sec, NULL,
2113 0, speed_template_32);
2114 break;
2115
2116 case 220:
2117 test_acipher_speed("essiv(cbc(aes),sha256)",
2118 ENCRYPT, sec, NULL, 0,
2119 speed_template_16_24_32);
2120 test_acipher_speed("essiv(cbc(aes),sha256)",
2121 DECRYPT, sec, NULL, 0,
2122 speed_template_16_24_32);
2123 break;
2124
2125 case 221:
2126 test_aead_speed("aegis128", ENCRYPT, sec,
2127 NULL, 0, 16, 8, speed_template_16);
2128 test_aead_speed("aegis128", DECRYPT, sec,
2129 NULL, 0, 16, 8, speed_template_16);
2130 break;
2131
2132 case 222:
2133 test_aead_speed("gcm(sm4)", ENCRYPT, sec,
2134 NULL, 0, 16, 8, speed_template_16);
2135 test_aead_speed("gcm(sm4)", DECRYPT, sec,
2136 NULL, 0, 16, 8, speed_template_16);
2137 break;
2138
2139 case 223:
2140 test_aead_speed("rfc4309(ccm(sm4))", ENCRYPT, sec,
2141 NULL, 0, 16, 16, aead_speed_template_19);
2142 test_aead_speed("rfc4309(ccm(sm4))", DECRYPT, sec,
2143 NULL, 0, 16, 16, aead_speed_template_19);
2144 break;
2145
2146 case 224:
2147 test_mb_aead_speed("gcm(sm4)", ENCRYPT, sec, NULL, 0, 16, 8,
2148 speed_template_16, num_mb);
2149 test_mb_aead_speed("gcm(sm4)", DECRYPT, sec, NULL, 0, 16, 8,
2150 speed_template_16, num_mb);
2151 break;
2152
2153 case 225:
2154 test_mb_aead_speed("rfc4309(ccm(sm4))", ENCRYPT, sec, NULL, 0,
2155 16, 16, aead_speed_template_19, num_mb);
2156 test_mb_aead_speed("rfc4309(ccm(sm4))", DECRYPT, sec, NULL, 0,
2157 16, 16, aead_speed_template_19, num_mb);
2158 break;
2159
2160 case 226:
2161 test_cipher_speed("hctr2(aes)", ENCRYPT, sec, NULL,
2162 0, speed_template_32);
2163 break;
2164
2165 case 227:
2166 test_cipher_speed("ecb(aria)", ENCRYPT, sec, NULL, 0,
2167 speed_template_16_24_32);
2168 test_cipher_speed("ecb(aria)", DECRYPT, sec, NULL, 0,
2169 speed_template_16_24_32);
2170 test_cipher_speed("cbc(aria)", ENCRYPT, sec, NULL, 0,
2171 speed_template_16_24_32);
2172 test_cipher_speed("cbc(aria)", DECRYPT, sec, NULL, 0,
2173 speed_template_16_24_32);
2174 test_cipher_speed("ctr(aria)", ENCRYPT, sec, NULL, 0,
2175 speed_template_16_24_32);
2176 test_cipher_speed("ctr(aria)", DECRYPT, sec, NULL, 0,
2177 speed_template_16_24_32);
2178 break;
2179
2180 case 228:
2181 test_aead_speed("gcm(aria)", ENCRYPT, sec,
2182 NULL, 0, 16, 8, speed_template_16_24_32);
2183 test_aead_speed("gcm(aria)", DECRYPT, sec,
2184 NULL, 0, 16, 8, speed_template_16_24_32);
2185 break;
2186
2187 case 229:
2188 test_mb_aead_speed("gcm(aria)", ENCRYPT, sec, NULL, 0, 16, 8,
2189 speed_template_16, num_mb);
2190 test_mb_aead_speed("gcm(aria)", DECRYPT, sec, NULL, 0, 16, 8,
2191 speed_template_16, num_mb);
2192 break;
2193
2194 case 300:
2195 if (alg) {
2196 test_hash_speed(alg, sec, generic_hash_speed_template);
2197 break;
2198 }
2199 fallthrough;
2200 case 301:
2201 test_hash_speed("md4", sec, generic_hash_speed_template);
2202 if (mode > 300 && mode < 400) break;
2203 fallthrough;
2204 case 302:
2205 test_hash_speed("md5", sec, generic_hash_speed_template);
2206 if (mode > 300 && mode < 400) break;
2207 fallthrough;
2208 case 303:
2209 test_hash_speed("sha1", sec, generic_hash_speed_template);
2210 if (mode > 300 && mode < 400) break;
2211 fallthrough;
2212 case 304:
2213 test_hash_speed("sha256", sec, generic_hash_speed_template);
2214 if (mode > 300 && mode < 400) break;
2215 fallthrough;
2216 case 305:
2217 test_hash_speed("sha384", sec, generic_hash_speed_template);
2218 if (mode > 300 && mode < 400) break;
2219 fallthrough;
2220 case 306:
2221 test_hash_speed("sha512", sec, generic_hash_speed_template);
2222 if (mode > 300 && mode < 400) break;
2223 fallthrough;
2224 case 307:
2225 test_hash_speed("wp256", sec, generic_hash_speed_template);
2226 if (mode > 300 && mode < 400) break;
2227 fallthrough;
2228 case 308:
2229 test_hash_speed("wp384", sec, generic_hash_speed_template);
2230 if (mode > 300 && mode < 400) break;
2231 fallthrough;
2232 case 309:
2233 test_hash_speed("wp512", sec, generic_hash_speed_template);
2234 if (mode > 300 && mode < 400) break;
2235 fallthrough;
2236 case 313:
2237 test_hash_speed("sha224", sec, generic_hash_speed_template);
2238 if (mode > 300 && mode < 400) break;
2239 fallthrough;
2240 case 314:
2241 test_hash_speed("xxhash64", sec, generic_hash_speed_template);
2242 if (mode > 300 && mode < 400) break;
2243 fallthrough;
2244 case 315:
2245 test_hash_speed("rmd160", sec, generic_hash_speed_template);
2246 if (mode > 300 && mode < 400) break;
2247 fallthrough;
2248 case 317:
2249 test_hash_speed("blake2b-512", sec, generic_hash_speed_template);
2250 if (mode > 300 && mode < 400) break;
2251 fallthrough;
2252 case 319:
2253 test_hash_speed("crc32c", sec, generic_hash_speed_template);
2254 if (mode > 300 && mode < 400) break;
2255 fallthrough;
2256 case 322:
2257 test_hash_speed("sha3-224", sec, generic_hash_speed_template);
2258 if (mode > 300 && mode < 400) break;
2259 fallthrough;
2260 case 323:
2261 test_hash_speed("sha3-256", sec, generic_hash_speed_template);
2262 if (mode > 300 && mode < 400) break;
2263 fallthrough;
2264 case 324:
2265 test_hash_speed("sha3-384", sec, generic_hash_speed_template);
2266 if (mode > 300 && mode < 400) break;
2267 fallthrough;
2268 case 325:
2269 test_hash_speed("sha3-512", sec, generic_hash_speed_template);
2270 if (mode > 300 && mode < 400) break;
2271 fallthrough;
2272 case 326:
2273 test_hash_speed("sm3", sec, generic_hash_speed_template);
2274 if (mode > 300 && mode < 400) break;
2275 fallthrough;
2276 case 327:
2277 test_hash_speed("streebog256", sec,
2278 generic_hash_speed_template);
2279 if (mode > 300 && mode < 400) break;
2280 fallthrough;
2281 case 328:
2282 test_hash_speed("streebog512", sec,
2283 generic_hash_speed_template);
2284 if (mode > 300 && mode < 400) break;
2285 fallthrough;
2286 case 399:
2287 break;
2288
2289 case 400:
2290 if (alg) {
2291 test_ahash_speed(alg, sec, generic_hash_speed_template);
2292 break;
2293 }
2294 fallthrough;
2295 case 401:
2296 test_ahash_speed("md4", sec, generic_hash_speed_template);
2297 if (mode > 400 && mode < 500) break;
2298 fallthrough;
2299 case 402:
2300 test_ahash_speed("md5", sec, generic_hash_speed_template);
2301 if (mode > 400 && mode < 500) break;
2302 fallthrough;
2303 case 403:
2304 test_ahash_speed("sha1", sec, generic_hash_speed_template);
2305 if (mode > 400 && mode < 500) break;
2306 fallthrough;
2307 case 404:
2308 test_ahash_speed("sha256", sec, generic_hash_speed_template);
2309 if (mode > 400 && mode < 500) break;
2310 fallthrough;
2311 case 405:
2312 test_ahash_speed("sha384", sec, generic_hash_speed_template);
2313 if (mode > 400 && mode < 500) break;
2314 fallthrough;
2315 case 406:
2316 test_ahash_speed("sha512", sec, generic_hash_speed_template);
2317 if (mode > 400 && mode < 500) break;
2318 fallthrough;
2319 case 407:
2320 test_ahash_speed("wp256", sec, generic_hash_speed_template);
2321 if (mode > 400 && mode < 500) break;
2322 fallthrough;
2323 case 408:
2324 test_ahash_speed("wp384", sec, generic_hash_speed_template);
2325 if (mode > 400 && mode < 500) break;
2326 fallthrough;
2327 case 409:
2328 test_ahash_speed("wp512", sec, generic_hash_speed_template);
2329 if (mode > 400 && mode < 500) break;
2330 fallthrough;
2331 case 413:
2332 test_ahash_speed("sha224", sec, generic_hash_speed_template);
2333 if (mode > 400 && mode < 500) break;
2334 fallthrough;
2335 case 414:
2336 test_ahash_speed("xxhash64", sec, generic_hash_speed_template);
2337 if (mode > 400 && mode < 500) break;
2338 fallthrough;
2339 case 415:
2340 test_ahash_speed("rmd160", sec, generic_hash_speed_template);
2341 if (mode > 400 && mode < 500) break;
2342 fallthrough;
2343 case 417:
2344 test_ahash_speed("blake2b-512", sec, generic_hash_speed_template);
2345 if (mode > 400 && mode < 500) break;
2346 fallthrough;
2347 case 418:
2348 test_ahash_speed("sha3-224", sec, generic_hash_speed_template);
2349 if (mode > 400 && mode < 500) break;
2350 fallthrough;
2351 case 419:
2352 test_ahash_speed("sha3-256", sec, generic_hash_speed_template);
2353 if (mode > 400 && mode < 500) break;
2354 fallthrough;
2355 case 420:
2356 test_ahash_speed("sha3-384", sec, generic_hash_speed_template);
2357 if (mode > 400 && mode < 500) break;
2358 fallthrough;
2359 case 421:
2360 test_ahash_speed("sha3-512", sec, generic_hash_speed_template);
2361 if (mode > 400 && mode < 500) break;
2362 fallthrough;
2363 case 422:
2364 test_ahash_speed("sm3", sec, generic_hash_speed_template);
2365 if (mode > 400 && mode < 500) break;
2366 fallthrough;
2367 case 499:
2368 break;
2369
2370 case 500:
2371 test_acipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
2372 speed_template_16_24_32);
2373 test_acipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
2374 speed_template_16_24_32);
2375 test_acipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
2376 speed_template_16_24_32);
2377 test_acipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
2378 speed_template_16_24_32);
2379 test_acipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
2380 speed_template_32_40_48);
2381 test_acipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
2382 speed_template_32_40_48);
2383 test_acipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
2384 speed_template_32_64);
2385 test_acipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
2386 speed_template_32_64);
2387 test_acipher_speed("cts(cbc(aes))", ENCRYPT, sec, NULL, 0,
2388 speed_template_16_24_32);
2389 test_acipher_speed("cts(cbc(aes))", DECRYPT, sec, NULL, 0,
2390 speed_template_16_24_32);
2391 test_acipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
2392 speed_template_16_24_32);
2393 test_acipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
2394 speed_template_16_24_32);
2395 test_acipher_speed("rfc3686(ctr(aes))", ENCRYPT, sec, NULL, 0,
2396 speed_template_20_28_36);
2397 test_acipher_speed("rfc3686(ctr(aes))", DECRYPT, sec, NULL, 0,
2398 speed_template_20_28_36);
2399 break;
2400
2401 case 501:
2402 test_acipher_speed("ecb(des3_ede)", ENCRYPT, sec,
2403 des3_speed_template, DES3_SPEED_VECTORS,
2404 speed_template_24);
2405 test_acipher_speed("ecb(des3_ede)", DECRYPT, sec,
2406 des3_speed_template, DES3_SPEED_VECTORS,
2407 speed_template_24);
2408 test_acipher_speed("cbc(des3_ede)", ENCRYPT, sec,
2409 des3_speed_template, DES3_SPEED_VECTORS,
2410 speed_template_24);
2411 test_acipher_speed("cbc(des3_ede)", DECRYPT, sec,
2412 des3_speed_template, DES3_SPEED_VECTORS,
2413 speed_template_24);
2414 break;
2415
2416 case 502:
2417 test_acipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
2418 speed_template_8);
2419 test_acipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
2420 speed_template_8);
2421 test_acipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
2422 speed_template_8);
2423 test_acipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
2424 speed_template_8);
2425 break;
2426
2427 case 503:
2428 test_acipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
2429 speed_template_16_32);
2430 test_acipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
2431 speed_template_16_32);
2432 test_acipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
2433 speed_template_16_32);
2434 test_acipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
2435 speed_template_16_32);
2436 test_acipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
2437 speed_template_16_32);
2438 test_acipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
2439 speed_template_16_32);
2440 test_acipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
2441 speed_template_32_48);
2442 test_acipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
2443 speed_template_32_48);
2444 test_acipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
2445 speed_template_32_64);
2446 test_acipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
2447 speed_template_32_64);
2448 break;
2449
2450 case 504:
2451 test_acipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
2452 speed_template_16_24_32);
2453 test_acipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
2454 speed_template_16_24_32);
2455 test_acipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
2456 speed_template_16_24_32);
2457 test_acipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
2458 speed_template_16_24_32);
2459 test_acipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0,
2460 speed_template_16_24_32);
2461 test_acipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
2462 speed_template_16_24_32);
2463 test_acipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
2464 speed_template_32_40_48);
2465 test_acipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
2466 speed_template_32_40_48);
2467 test_acipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
2468 speed_template_32_48_64);
2469 test_acipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
2470 speed_template_32_48_64);
2471 break;
2472
2473 case 505:
2474 test_acipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0,
2475 speed_template_8);
2476 break;
2477
2478 case 506:
2479 test_acipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0,
2480 speed_template_8_16);
2481 test_acipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0,
2482 speed_template_8_16);
2483 test_acipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0,
2484 speed_template_8_16);
2485 test_acipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0,
2486 speed_template_8_16);
2487 test_acipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0,
2488 speed_template_8_16);
2489 test_acipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0,
2490 speed_template_8_16);
2491 break;
2492
2493 case 507:
2494 test_acipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0,
2495 speed_template_16_32);
2496 test_acipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0,
2497 speed_template_16_32);
2498 test_acipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0,
2499 speed_template_16_32);
2500 test_acipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0,
2501 speed_template_16_32);
2502 test_acipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0,
2503 speed_template_16_32);
2504 test_acipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0,
2505 speed_template_16_32);
2506 test_acipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0,
2507 speed_template_32_48);
2508 test_acipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0,
2509 speed_template_32_48);
2510 test_acipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0,
2511 speed_template_32_64);
2512 test_acipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0,
2513 speed_template_32_64);
2514 break;
2515
2516 case 508:
2517 test_acipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
2518 speed_template_16_32);
2519 test_acipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
2520 speed_template_16_32);
2521 test_acipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
2522 speed_template_16_32);
2523 test_acipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
2524 speed_template_16_32);
2525 test_acipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0,
2526 speed_template_16_32);
2527 test_acipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0,
2528 speed_template_16_32);
2529 test_acipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0,
2530 speed_template_32_48);
2531 test_acipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0,
2532 speed_template_32_48);
2533 test_acipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0,
2534 speed_template_32_64);
2535 test_acipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0,
2536 speed_template_32_64);
2537 break;
2538
2539 case 509:
2540 test_acipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
2541 speed_template_8_32);
2542 test_acipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
2543 speed_template_8_32);
2544 test_acipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
2545 speed_template_8_32);
2546 test_acipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
2547 speed_template_8_32);
2548 test_acipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0,
2549 speed_template_8_32);
2550 test_acipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0,
2551 speed_template_8_32);
2552 break;
2553
2554 case 518:
2555 test_acipher_speed("ecb(sm4)", ENCRYPT, sec, NULL, 0,
2556 speed_template_16);
2557 test_acipher_speed("ecb(sm4)", DECRYPT, sec, NULL, 0,
2558 speed_template_16);
2559 test_acipher_speed("cbc(sm4)", ENCRYPT, sec, NULL, 0,
2560 speed_template_16);
2561 test_acipher_speed("cbc(sm4)", DECRYPT, sec, NULL, 0,
2562 speed_template_16);
2563 test_acipher_speed("ctr(sm4)", ENCRYPT, sec, NULL, 0,
2564 speed_template_16);
2565 test_acipher_speed("ctr(sm4)", DECRYPT, sec, NULL, 0,
2566 speed_template_16);
2567 test_acipher_speed("xts(sm4)", ENCRYPT, sec, NULL, 0,
2568 speed_template_32);
2569 test_acipher_speed("xts(sm4)", DECRYPT, sec, NULL, 0,
2570 speed_template_32);
2571 break;
2572
2573 case 519:
2574 test_acipher_speed("ecb(aria)", ENCRYPT, sec, NULL, 0,
2575 speed_template_16_24_32);
2576 test_acipher_speed("ecb(aria)", DECRYPT, sec, NULL, 0,
2577 speed_template_16_24_32);
2578 test_acipher_speed("ctr(aria)", ENCRYPT, sec, NULL, 0,
2579 speed_template_16_24_32);
2580 test_acipher_speed("ctr(aria)", DECRYPT, sec, NULL, 0,
2581 speed_template_16_24_32);
2582 break;
2583
2584 case 600:
2585 if (alg) {
2586 u8 speed_template[2] = {klen, 0};
2587 test_mb_skcipher_speed(alg, ENCRYPT, sec, NULL, 0,
2588 speed_template, num_mb);
2589 test_mb_skcipher_speed(alg, DECRYPT, sec, NULL, 0,
2590 speed_template, num_mb);
2591 break;
2592 }
2593
2594 test_mb_skcipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
2595 speed_template_16_24_32, num_mb);
2596 test_mb_skcipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
2597 speed_template_16_24_32, num_mb);
2598 test_mb_skcipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
2599 speed_template_16_24_32, num_mb);
2600 test_mb_skcipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
2601 speed_template_16_24_32, num_mb);
2602 test_mb_skcipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
2603 speed_template_32_40_48, num_mb);
2604 test_mb_skcipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
2605 speed_template_32_40_48, num_mb);
2606 test_mb_skcipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
2607 speed_template_32_64, num_mb);
2608 test_mb_skcipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
2609 speed_template_32_64, num_mb);
2610 test_mb_skcipher_speed("cts(cbc(aes))", ENCRYPT, sec, NULL, 0,
2611 speed_template_16_24_32, num_mb);
2612 test_mb_skcipher_speed("cts(cbc(aes))", DECRYPT, sec, NULL, 0,
2613 speed_template_16_24_32, num_mb);
2614 test_mb_skcipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
2615 speed_template_16_24_32, num_mb);
2616 test_mb_skcipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
2617 speed_template_16_24_32, num_mb);
2618 test_mb_skcipher_speed("rfc3686(ctr(aes))", ENCRYPT, sec, NULL,
2619 0, speed_template_20_28_36, num_mb);
2620 test_mb_skcipher_speed("rfc3686(ctr(aes))", DECRYPT, sec, NULL,
2621 0, speed_template_20_28_36, num_mb);
2622 break;
2623
2624 case 601:
2625 test_mb_skcipher_speed("ecb(des3_ede)", ENCRYPT, sec,
2626 des3_speed_template, DES3_SPEED_VECTORS,
2627 speed_template_24, num_mb);
2628 test_mb_skcipher_speed("ecb(des3_ede)", DECRYPT, sec,
2629 des3_speed_template, DES3_SPEED_VECTORS,
2630 speed_template_24, num_mb);
2631 test_mb_skcipher_speed("cbc(des3_ede)", ENCRYPT, sec,
2632 des3_speed_template, DES3_SPEED_VECTORS,
2633 speed_template_24, num_mb);
2634 test_mb_skcipher_speed("cbc(des3_ede)", DECRYPT, sec,
2635 des3_speed_template, DES3_SPEED_VECTORS,
2636 speed_template_24, num_mb);
2637 break;
2638
2639 case 602:
2640 test_mb_skcipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
2641 speed_template_8, num_mb);
2642 test_mb_skcipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
2643 speed_template_8, num_mb);
2644 test_mb_skcipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
2645 speed_template_8, num_mb);
2646 test_mb_skcipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
2647 speed_template_8, num_mb);
2648 break;
2649
2650 case 603:
2651 test_mb_skcipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
2652 speed_template_16_32, num_mb);
2653 test_mb_skcipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
2654 speed_template_16_32, num_mb);
2655 test_mb_skcipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
2656 speed_template_16_32, num_mb);
2657 test_mb_skcipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
2658 speed_template_16_32, num_mb);
2659 test_mb_skcipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
2660 speed_template_16_32, num_mb);
2661 test_mb_skcipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
2662 speed_template_16_32, num_mb);
2663 test_mb_skcipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
2664 speed_template_32_48, num_mb);
2665 test_mb_skcipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
2666 speed_template_32_48, num_mb);
2667 test_mb_skcipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
2668 speed_template_32_64, num_mb);
2669 test_mb_skcipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
2670 speed_template_32_64, num_mb);
2671 break;
2672
2673 case 604:
2674 test_mb_skcipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
2675 speed_template_16_24_32, num_mb);
2676 test_mb_skcipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
2677 speed_template_16_24_32, num_mb);
2678 test_mb_skcipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
2679 speed_template_16_24_32, num_mb);
2680 test_mb_skcipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
2681 speed_template_16_24_32, num_mb);
2682 test_mb_skcipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0,
2683 speed_template_16_24_32, num_mb);
2684 test_mb_skcipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
2685 speed_template_16_24_32, num_mb);
2686 test_mb_skcipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
2687 speed_template_32_40_48, num_mb);
2688 test_mb_skcipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
2689 speed_template_32_40_48, num_mb);
2690 test_mb_skcipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
2691 speed_template_32_48_64, num_mb);
2692 test_mb_skcipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
2693 speed_template_32_48_64, num_mb);
2694 break;
2695
2696 case 605:
2697 test_mb_skcipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0,
2698 speed_template_8, num_mb);
2699 break;
2700
2701 case 606:
2702 test_mb_skcipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0,
2703 speed_template_8_16, num_mb);
2704 test_mb_skcipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0,
2705 speed_template_8_16, num_mb);
2706 test_mb_skcipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0,
2707 speed_template_8_16, num_mb);
2708 test_mb_skcipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0,
2709 speed_template_8_16, num_mb);
2710 test_mb_skcipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0,
2711 speed_template_8_16, num_mb);
2712 test_mb_skcipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0,
2713 speed_template_8_16, num_mb);
2714 break;
2715
2716 case 607:
2717 test_mb_skcipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0,
2718 speed_template_16_32, num_mb);
2719 test_mb_skcipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0,
2720 speed_template_16_32, num_mb);
2721 test_mb_skcipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0,
2722 speed_template_16_32, num_mb);
2723 test_mb_skcipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0,
2724 speed_template_16_32, num_mb);
2725 test_mb_skcipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0,
2726 speed_template_16_32, num_mb);
2727 test_mb_skcipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0,
2728 speed_template_16_32, num_mb);
2729 test_mb_skcipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0,
2730 speed_template_32_48, num_mb);
2731 test_mb_skcipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0,
2732 speed_template_32_48, num_mb);
2733 test_mb_skcipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0,
2734 speed_template_32_64, num_mb);
2735 test_mb_skcipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0,
2736 speed_template_32_64, num_mb);
2737 break;
2738
2739 case 608:
2740 test_mb_skcipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
2741 speed_template_16_32, num_mb);
2742 test_mb_skcipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
2743 speed_template_16_32, num_mb);
2744 test_mb_skcipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
2745 speed_template_16_32, num_mb);
2746 test_mb_skcipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
2747 speed_template_16_32, num_mb);
2748 test_mb_skcipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0,
2749 speed_template_16_32, num_mb);
2750 test_mb_skcipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0,
2751 speed_template_16_32, num_mb);
2752 test_mb_skcipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0,
2753 speed_template_32_48, num_mb);
2754 test_mb_skcipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0,
2755 speed_template_32_48, num_mb);
2756 test_mb_skcipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0,
2757 speed_template_32_64, num_mb);
2758 test_mb_skcipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0,
2759 speed_template_32_64, num_mb);
2760 break;
2761
2762 case 609:
2763 test_mb_skcipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
2764 speed_template_8_32, num_mb);
2765 test_mb_skcipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
2766 speed_template_8_32, num_mb);
2767 test_mb_skcipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
2768 speed_template_8_32, num_mb);
2769 test_mb_skcipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
2770 speed_template_8_32, num_mb);
2771 test_mb_skcipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0,
2772 speed_template_8_32, num_mb);
2773 test_mb_skcipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0,
2774 speed_template_8_32, num_mb);
2775 break;
2776
2777 case 610:
2778 test_mb_skcipher_speed("ecb(aria)", ENCRYPT, sec, NULL, 0,
2779 speed_template_16_32, num_mb);
2780 test_mb_skcipher_speed("ecb(aria)", DECRYPT, sec, NULL, 0,
2781 speed_template_16_32, num_mb);
2782 test_mb_skcipher_speed("ctr(aria)", ENCRYPT, sec, NULL, 0,
2783 speed_template_16_32, num_mb);
2784 test_mb_skcipher_speed("ctr(aria)", DECRYPT, sec, NULL, 0,
2785 speed_template_16_32, num_mb);
2786 break;
2787
2788 }
2789
2790 return ret;
2791 }
2792
tcrypt_mod_init(void)2793 static int __init tcrypt_mod_init(void)
2794 {
2795 int err = -ENOMEM;
2796 int i;
2797
2798 for (i = 0; i < TVMEMSIZE; i++) {
2799 tvmem[i] = (void *)__get_free_page(GFP_KERNEL);
2800 if (!tvmem[i])
2801 goto err_free_tv;
2802 }
2803
2804 if (!num_mb) {
2805 pr_warn("num_mb must be at least 1; forcing to 1\n");
2806 num_mb = 1;
2807 }
2808
2809 err = do_test(alg, type, mask, mode, num_mb);
2810
2811 if (err) {
2812 pr_err("one or more tests failed!\n");
2813 goto err_free_tv;
2814 } else {
2815 pr_debug("all tests passed\n");
2816 }
2817
2818 /* We intentionally return -EAGAIN to prevent keeping the module,
2819 * unless we're running in fips mode. It does all its work from
2820 * init() and doesn't offer any runtime functionality, but in
2821 * the fips case, checking for a successful load is helpful.
2822 * => we don't need it in the memory, do we?
2823 * -- mludvig
2824 */
2825 if (!fips_enabled)
2826 err = -EAGAIN;
2827
2828 err_free_tv:
2829 for (i = 0; i < TVMEMSIZE && tvmem[i]; i++)
2830 free_page((unsigned long)tvmem[i]);
2831
2832 return err;
2833 }
2834
2835 /*
2836 * If an init function is provided, an exit function must also be provided
2837 * to allow module unload.
2838 */
tcrypt_mod_fini(void)2839 static void __exit tcrypt_mod_fini(void) { }
2840
2841 late_initcall(tcrypt_mod_init);
2842 module_exit(tcrypt_mod_fini);
2843
2844 module_param(alg, charp, 0);
2845 module_param(type, uint, 0);
2846 module_param(mask, uint, 0);
2847 module_param(mode, int, 0);
2848 module_param(sec, uint, 0);
2849 MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
2850 "(defaults to zero which uses CPU cycles instead)");
2851 module_param(num_mb, uint, 0000);
2852 MODULE_PARM_DESC(num_mb, "Number of concurrent requests to be used in mb speed tests (defaults to 8)");
2853 module_param(klen, uint, 0);
2854 MODULE_PARM_DESC(klen, "Key length (defaults to 0)");
2855
2856 MODULE_LICENSE("GPL");
2857 MODULE_DESCRIPTION("Quick & dirty crypto benchmarking module");
2858 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
2859