1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Quick & dirty crypto testing module.
5 * This will only exist until we have a better testing mechanism
6 * (e.g. a char device).
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
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.
20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
42 * Need slab memory for testing (size in number of pages).
47 * Used by test_cipher_speed()
52 #define MAX_DIGEST_SIZE 64
55 * return a string with the driver name
57 #define get_driver_name(tfm_type, tfm) crypto_tfm_alg_driver_name(tfm_type ## _tfm(tfm))
60 * Used by test_cipher_speed()
62 static unsigned int sec
;
68 static u32 num_mb
= 8;
69 static unsigned int klen
;
70 static char *tvmem
[TVMEMSIZE
];
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 };
78 static int testmgr_alloc_buf(char *buf
[XBUFSIZE
])
82 for (i
= 0; i
< XBUFSIZE
; i
++) {
83 buf
[i
] = (void *)__get_free_page(GFP_KERNEL
);
92 free_page((unsigned long)buf
[i
]);
97 static void testmgr_free_buf(char *buf
[XBUFSIZE
])
101 for (i
= 0; i
< XBUFSIZE
; i
++)
102 free_page((unsigned long)buf
[i
]);
105 static void sg_init_aead(struct scatterlist
*sg
, char *xbuf
[XBUFSIZE
],
106 unsigned int buflen
, const void *assoc
,
107 unsigned int aad_size
)
109 int np
= (buflen
+ PAGE_SIZE
- 1)/PAGE_SIZE
;
116 rem
= buflen
% PAGE_SIZE
;
119 sg_init_table(sg
, np
+ 1);
121 sg_set_buf(&sg
[0], assoc
, aad_size
);
125 for (k
= 0; k
< np
; k
++)
126 sg_set_buf(&sg
[k
+ 1], xbuf
[k
], PAGE_SIZE
);
129 sg_set_buf(&sg
[k
+ 1], xbuf
[k
], rem
);
132 static inline int do_one_aead_op(struct aead_request
*req
, int ret
)
134 struct crypto_wait
*wait
= req
->base
.data
;
136 return crypto_wait_req(ret
, wait
);
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
];
149 static int do_mult_aead_op(struct test_mb_aead_data
*data
, int enc
,
154 /* Fire up a bunch of concurrent requests */
155 for (i
= 0; i
< num_mb
; i
++) {
157 rc
[i
] = crypto_aead_encrypt(data
[i
].req
);
159 rc
[i
] = crypto_aead_decrypt(data
[i
].req
);
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
);
167 pr_info("concurrent request %d error %d\n", i
, rc
[i
]);
175 static int test_mb_aead_jiffies(struct test_mb_aead_data
*data
, int enc
,
176 int blen
, int secs
, u32 num_mb
)
178 unsigned long start
, end
;
183 rc
= kcalloc(num_mb
, sizeof(*rc
), GFP_KERNEL
);
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
);
194 pr_cont("%d operations in %d seconds (%llu bytes)\n",
195 bcount
* num_mb
, secs
, (u64
)bcount
* blen
* num_mb
);
202 static int test_mb_aead_cycles(struct test_mb_aead_data
*data
, int enc
,
203 int blen
, u32 num_mb
)
205 unsigned long cycles
= 0;
210 rc
= kcalloc(num_mb
, sizeof(*rc
), GFP_KERNEL
);
215 for (i
= 0; i
< 4; i
++) {
216 ret
= do_mult_aead_op(data
, enc
, num_mb
, rc
);
221 /* The real thing. */
222 for (i
= 0; i
< 8; i
++) {
225 start
= get_cycles();
226 ret
= do_mult_aead_op(data
, enc
, num_mb
, rc
);
232 cycles
+= end
- start
;
235 pr_cont("1 operation in %lu cycles (%d bytes)\n",
236 (cycles
+ 4) / (8 * num_mb
), blen
);
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
)
248 struct test_mb_aead_data
*data
;
249 struct crypto_aead
*tfm
;
250 unsigned int i
, j
, iv_len
;
259 if (aad_size
>= PAGE_SIZE
) {
260 pr_err("associate data length (%u) too big\n", aad_size
);
264 iv
= kzalloc(MAX_IVLEN
, GFP_KERNEL
);
273 data
= kcalloc(num_mb
, sizeof(*data
), GFP_KERNEL
);
277 tfm
= crypto_alloc_aead(algo
, 0, 0);
279 pr_err("failed to load transform for %s: %ld\n",
284 ret
= crypto_aead_setauthsize(tfm
, authsize
);
286 pr_err("alg: aead: Failed to setauthsize for %s: %d\n", algo
,
291 for (i
= 0; i
< num_mb
; ++i
)
292 if (testmgr_alloc_buf(data
[i
].xbuf
)) {
294 testmgr_free_buf(data
[i
].xbuf
);
298 for (i
= 0; i
< num_mb
; ++i
)
299 if (testmgr_alloc_buf(data
[i
].axbuf
)) {
301 testmgr_free_buf(data
[i
].axbuf
);
305 for (i
= 0; i
< num_mb
; ++i
)
306 if (testmgr_alloc_buf(data
[i
].xoutbuf
)) {
308 testmgr_free_buf(data
[i
].xoutbuf
);
312 for (i
= 0; i
< num_mb
; ++i
) {
313 data
[i
].req
= aead_request_alloc(tfm
, GFP_KERNEL
);
315 pr_err("alg: aead: Failed to allocate request for %s\n",
318 aead_request_free(data
[i
].req
);
319 goto out_free_xoutbuf
;
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
);
330 pr_info("testing speed of multibuffer %s (%s) %s\n", algo
,
331 get_driver_name(crypto_aead
, tfm
), e
);
337 int bs
= round_up(*b_size
, crypto_aead_blocksize(tfm
));
339 if (bs
+ authsize
> XBUFSIZE
* PAGE_SIZE
) {
340 pr_err("template (%u) too big for buffer (%lu)\n",
342 XBUFSIZE
* PAGE_SIZE
);
346 pr_info("test %u (%d bit key, %d byte blocks): ", i
,
349 /* Set up tfm global state, i.e. the key */
351 memset(tvmem
[0], 0xff, PAGE_SIZE
);
353 for (j
= 0; j
< tcount
; j
++) {
354 if (template[j
].klen
== *keysize
) {
355 key
= template[j
].key
;
360 crypto_aead_clear_flags(tfm
, ~0);
362 ret
= crypto_aead_setkey(tfm
, key
, *keysize
);
364 pr_err("setkey() failed flags=%x\n",
365 crypto_aead_get_flags(tfm
));
369 iv_len
= crypto_aead_ivsize(tfm
);
371 memset(iv
, 0xff, iv_len
);
373 /* Now setup per request stuff, i.e. buffers */
375 for (j
= 0; j
< num_mb
; ++j
) {
376 struct test_mb_aead_data
*cur
= &data
[j
];
378 assoc
= cur
->axbuf
[0];
379 memset(assoc
, 0xff, aad_size
);
381 sg_init_aead(cur
->sg
, cur
->xbuf
,
382 bs
+ (enc
? 0 : authsize
),
385 sg_init_aead(cur
->sgout
, cur
->xoutbuf
,
386 bs
+ (enc
? authsize
: 0),
389 aead_request_set_ad(cur
->req
, aad_size
);
393 aead_request_set_crypt(cur
->req
,
397 ret
= crypto_aead_encrypt(cur
->req
);
398 ret
= do_one_aead_op(cur
->req
, ret
);
401 pr_err("calculating auth failed (%d)\n",
407 aead_request_set_crypt(cur
->req
, cur
->sg
,
409 (enc
? 0 : authsize
),
415 ret
= test_mb_aead_jiffies(data
, enc
, bs
,
419 ret
= test_mb_aead_cycles(data
, enc
, bs
,
424 pr_err("%s() failed return code=%d\n", e
, ret
);
434 for (i
= 0; i
< num_mb
; ++i
)
435 aead_request_free(data
[i
].req
);
437 for (i
= 0; i
< num_mb
; ++i
)
438 testmgr_free_buf(data
[i
].xoutbuf
);
440 for (i
= 0; i
< num_mb
; ++i
)
441 testmgr_free_buf(data
[i
].axbuf
);
443 for (i
= 0; i
< num_mb
; ++i
)
444 testmgr_free_buf(data
[i
].xbuf
);
446 crypto_free_aead(tfm
);
453 static int test_aead_jiffies(struct aead_request
*req
, int enc
,
456 unsigned long start
, end
;
460 for (start
= jiffies
, end
= start
+ secs
* HZ
, bcount
= 0;
461 time_before(jiffies
, end
); bcount
++) {
463 ret
= do_one_aead_op(req
, crypto_aead_encrypt(req
));
465 ret
= do_one_aead_op(req
, crypto_aead_decrypt(req
));
471 pr_cont("%d operations in %d seconds (%llu bytes)\n",
472 bcount
, secs
, (u64
)bcount
* blen
);
476 static int test_aead_cycles(struct aead_request
*req
, int enc
, int blen
)
478 unsigned long cycles
= 0;
483 for (i
= 0; i
< 4; i
++) {
485 ret
= do_one_aead_op(req
, crypto_aead_encrypt(req
));
487 ret
= do_one_aead_op(req
, crypto_aead_decrypt(req
));
493 /* The real thing. */
494 for (i
= 0; i
< 8; i
++) {
497 start
= get_cycles();
499 ret
= do_one_aead_op(req
, crypto_aead_encrypt(req
));
501 ret
= do_one_aead_op(req
, crypto_aead_decrypt(req
));
507 cycles
+= end
- start
;
512 pr_cont("1 operation in %lu cycles (%d bytes)\n",
513 (cycles
+ 4) / 8, blen
);
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
)
524 struct crypto_aead
*tfm
;
527 struct aead_request
*req
;
528 struct scatterlist
*sg
;
529 struct scatterlist
*sgout
;
533 char *xbuf
[XBUFSIZE
];
534 char *xoutbuf
[XBUFSIZE
];
535 char *axbuf
[XBUFSIZE
];
538 struct crypto_wait wait
;
540 iv
= kzalloc(MAX_IVLEN
, GFP_KERNEL
);
544 if (aad_size
>= PAGE_SIZE
) {
545 pr_err("associate data length (%u) too big\n", aad_size
);
554 if (testmgr_alloc_buf(xbuf
))
556 if (testmgr_alloc_buf(axbuf
))
558 if (testmgr_alloc_buf(xoutbuf
))
561 sg
= kmalloc(sizeof(*sg
) * 9 * 2, GFP_KERNEL
);
566 tfm
= crypto_alloc_aead(algo
, 0, 0);
568 pr_err("alg: aead: Failed to load transform for %s: %ld\n", algo
,
573 ret
= crypto_aead_setauthsize(tfm
, authsize
);
575 pr_err("alg: aead: Failed to setauthsize for %s: %d\n", algo
,
580 crypto_init_wait(&wait
);
581 pr_info("testing speed of %s (%s) %s\n", algo
,
582 get_driver_name(crypto_aead
, tfm
), e
);
584 req
= aead_request_alloc(tfm
, GFP_KERNEL
);
586 pr_err("alg: aead: Failed to allocate request for %s\n",
591 aead_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
592 crypto_req_done
, &wait
);
598 u32 bs
= round_up(*b_size
, crypto_aead_blocksize(tfm
));
601 memset(assoc
, 0xff, aad_size
);
603 if ((*keysize
+ bs
) > TVMEMSIZE
* PAGE_SIZE
) {
604 pr_err("template (%u) too big for tvmem (%lu)\n",
606 TVMEMSIZE
* PAGE_SIZE
);
611 for (j
= 0; j
< tcount
; j
++) {
612 if (template[j
].klen
== *keysize
) {
613 key
= template[j
].key
;
618 ret
= crypto_aead_setkey(tfm
, key
, *keysize
);
620 pr_err("setkey() failed flags=%x: %d\n",
621 crypto_aead_get_flags(tfm
), ret
);
625 iv_len
= crypto_aead_ivsize(tfm
);
627 memset(iv
, 0xff, iv_len
);
629 crypto_aead_clear_flags(tfm
, ~0);
630 pr_info("test %u (%d bit key, %d byte blocks): ",
631 i
, *keysize
* 8, bs
);
633 memset(tvmem
[0], 0xff, PAGE_SIZE
);
635 sg_init_aead(sg
, xbuf
, bs
+ (enc
? 0 : authsize
),
638 sg_init_aead(sgout
, xoutbuf
,
639 bs
+ (enc
? authsize
: 0), assoc
,
642 aead_request_set_ad(req
, aad_size
);
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
651 aead_request_set_crypt(req
, sgout
, sg
,
653 ret
= do_one_aead_op(req
,
654 crypto_aead_encrypt(req
));
657 pr_err("calculating auth failed (%d)\n",
663 aead_request_set_crypt(req
, sg
, sgout
,
664 bs
+ (enc
? 0 : authsize
),
668 ret
= test_aead_jiffies(req
, enc
, bs
,
672 ret
= test_aead_cycles(req
, enc
, bs
);
676 pr_err("%s() failed return code=%d\n", e
, ret
);
686 aead_request_free(req
);
688 crypto_free_aead(tfm
);
692 testmgr_free_buf(xoutbuf
);
694 testmgr_free_buf(axbuf
);
696 testmgr_free_buf(xbuf
);
701 static void test_hash_sg_init(struct scatterlist
*sg
)
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
);
712 static inline int do_one_ahash_op(struct ahash_request
*req
, int ret
)
714 struct crypto_wait
*wait
= req
->base
.data
;
716 return crypto_wait_req(ret
, wait
);
719 static int test_ahash_jiffies_digest(struct ahash_request
*req
, int blen
,
722 unsigned long start
, end
;
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
));
733 pr_cont("%6u opers/sec, %9lu bytes/sec\n",
734 bcount
/ secs
, ((long)bcount
* blen
) / secs
);
739 static int test_ahash_jiffies(struct ahash_request
*req
, int blen
,
740 int plen
, char *out
, int secs
)
742 unsigned long start
, end
;
747 return test_ahash_jiffies_digest(req
, blen
, out
, secs
);
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
));
754 for (pcount
= 0; pcount
< blen
; pcount
+= plen
) {
755 ret
= do_one_ahash_op(req
, crypto_ahash_update(req
));
759 /* we assume there is enough space in 'out' for the result */
760 ret
= do_one_ahash_op(req
, crypto_ahash_final(req
));
765 pr_cont("%6u opers/sec, %9lu bytes/sec\n",
766 bcount
/ secs
, ((long)bcount
* blen
) / secs
);
771 static int test_ahash_cycles_digest(struct ahash_request
*req
, int blen
,
774 unsigned long cycles
= 0;
778 for (i
= 0; i
< 4; i
++) {
779 ret
= do_one_ahash_op(req
, crypto_ahash_digest(req
));
784 /* The real thing. */
785 for (i
= 0; i
< 8; i
++) {
788 start
= get_cycles();
790 ret
= do_one_ahash_op(req
, crypto_ahash_digest(req
));
796 cycles
+= end
- start
;
803 pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
804 cycles
/ 8, cycles
/ (8 * blen
));
809 static int test_ahash_cycles(struct ahash_request
*req
, int blen
,
812 unsigned long cycles
= 0;
816 return test_ahash_cycles_digest(req
, blen
, out
);
819 for (i
= 0; i
< 4; i
++) {
820 ret
= do_one_ahash_op(req
, crypto_ahash_init(req
));
823 for (pcount
= 0; pcount
< blen
; pcount
+= plen
) {
824 ret
= do_one_ahash_op(req
, crypto_ahash_update(req
));
828 ret
= do_one_ahash_op(req
, crypto_ahash_final(req
));
833 /* The real thing. */
834 for (i
= 0; i
< 8; i
++) {
837 start
= get_cycles();
839 ret
= do_one_ahash_op(req
, crypto_ahash_init(req
));
842 for (pcount
= 0; pcount
< blen
; pcount
+= plen
) {
843 ret
= do_one_ahash_op(req
, crypto_ahash_update(req
));
847 ret
= do_one_ahash_op(req
, crypto_ahash_final(req
));
853 cycles
+= end
- start
;
860 pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
861 cycles
/ 8, cycles
/ (8 * blen
));
866 static void test_ahash_speed_common(const char *algo
, unsigned int secs
,
867 struct hash_speed
*speed
, unsigned mask
)
869 struct scatterlist sg
[TVMEMSIZE
];
870 struct crypto_wait wait
;
871 struct ahash_request
*req
;
872 struct crypto_ahash
*tfm
;
876 tfm
= crypto_alloc_ahash(algo
, 0, mask
);
878 pr_err("failed to load transform for %s: %ld\n",
883 pr_info("testing speed of async %s (%s)\n", algo
,
884 get_driver_name(crypto_ahash
, tfm
));
886 if (crypto_ahash_digestsize(tfm
) > MAX_DIGEST_SIZE
) {
887 pr_err("digestsize(%u) > %d\n", crypto_ahash_digestsize(tfm
),
892 test_hash_sg_init(sg
);
893 req
= ahash_request_alloc(tfm
, GFP_KERNEL
);
895 pr_err("ahash request allocation failure\n");
899 crypto_init_wait(&wait
);
900 ahash_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
901 crypto_req_done
, &wait
);
903 output
= kmalloc(MAX_DIGEST_SIZE
, GFP_KERNEL
);
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
);
915 crypto_ahash_setkey(tfm
, tvmem
[0], klen
);
918 "(%5u byte blocks,%5u bytes per update,%4u updates): ",
919 i
, speed
[i
].blen
, speed
[i
].plen
, speed
[i
].blen
/ speed
[i
].plen
);
921 ahash_request_set_crypt(req
, sg
, output
, speed
[i
].plen
);
924 ret
= test_ahash_jiffies(req
, speed
[i
].blen
,
925 speed
[i
].plen
, output
, secs
);
928 ret
= test_ahash_cycles(req
, speed
[i
].blen
,
929 speed
[i
].plen
, output
);
933 pr_err("hashing failed ret=%d\n", ret
);
941 ahash_request_free(req
);
944 crypto_free_ahash(tfm
);
947 static void test_ahash_speed(const char *algo
, unsigned int secs
,
948 struct hash_speed
*speed
)
950 return test_ahash_speed_common(algo
, secs
, speed
, 0);
953 static void test_hash_speed(const char *algo
, unsigned int secs
,
954 struct hash_speed
*speed
)
956 return test_ahash_speed_common(algo
, secs
, speed
, CRYPTO_ALG_ASYNC
);
959 struct test_mb_skcipher_data
{
960 struct scatterlist sg
[XBUFSIZE
];
961 struct skcipher_request
*req
;
962 struct crypto_wait wait
;
963 char *xbuf
[XBUFSIZE
];
966 static int do_mult_acipher_op(struct test_mb_skcipher_data
*data
, int enc
,
971 /* Fire up a bunch of concurrent requests */
972 for (i
= 0; i
< num_mb
; i
++) {
974 rc
[i
] = crypto_skcipher_encrypt(data
[i
].req
);
976 rc
[i
] = crypto_skcipher_decrypt(data
[i
].req
);
979 /* Wait for all requests to finish */
980 for (i
= 0; i
< num_mb
; i
++) {
981 rc
[i
] = crypto_wait_req(rc
[i
], &data
[i
].wait
);
984 pr_info("concurrent request %d error %d\n", i
, rc
[i
]);
992 static int test_mb_acipher_jiffies(struct test_mb_skcipher_data
*data
, int enc
,
993 int blen
, int secs
, u32 num_mb
)
995 unsigned long start
, end
;
1000 rc
= kcalloc(num_mb
, sizeof(*rc
), GFP_KERNEL
);
1004 for (start
= jiffies
, end
= start
+ secs
* HZ
, bcount
= 0;
1005 time_before(jiffies
, end
); bcount
++) {
1006 ret
= do_mult_acipher_op(data
, enc
, num_mb
, rc
);
1011 pr_cont("%d operations in %d seconds (%llu bytes)\n",
1012 bcount
* num_mb
, secs
, (u64
)bcount
* blen
* num_mb
);
1019 static int test_mb_acipher_cycles(struct test_mb_skcipher_data
*data
, int enc
,
1020 int blen
, u32 num_mb
)
1022 unsigned long cycles
= 0;
1027 rc
= kcalloc(num_mb
, sizeof(*rc
), GFP_KERNEL
);
1032 for (i
= 0; i
< 4; i
++) {
1033 ret
= do_mult_acipher_op(data
, enc
, num_mb
, rc
);
1038 /* The real thing. */
1039 for (i
= 0; i
< 8; i
++) {
1040 cycles_t start
, end
;
1042 start
= get_cycles();
1043 ret
= do_mult_acipher_op(data
, enc
, num_mb
, rc
);
1049 cycles
+= end
- start
;
1052 pr_cont("1 operation in %lu cycles (%d bytes)\n",
1053 (cycles
+ 4) / (8 * num_mb
), blen
);
1060 static void test_mb_skcipher_speed(const char *algo
, int enc
, int secs
,
1061 struct cipher_speed_template
*template,
1062 unsigned int tcount
, u8
*keysize
, u32 num_mb
)
1064 struct test_mb_skcipher_data
*data
;
1065 struct crypto_skcipher
*tfm
;
1066 unsigned int i
, j
, iv_len
;
1078 data
= kcalloc(num_mb
, sizeof(*data
), GFP_KERNEL
);
1082 tfm
= crypto_alloc_skcipher(algo
, 0, 0);
1084 pr_err("failed to load transform for %s: %ld\n",
1085 algo
, PTR_ERR(tfm
));
1089 for (i
= 0; i
< num_mb
; ++i
)
1090 if (testmgr_alloc_buf(data
[i
].xbuf
)) {
1092 testmgr_free_buf(data
[i
].xbuf
);
1096 for (i
= 0; i
< num_mb
; ++i
) {
1097 data
[i
].req
= skcipher_request_alloc(tfm
, GFP_KERNEL
);
1099 pr_err("alg: skcipher: Failed to allocate request for %s\n",
1102 skcipher_request_free(data
[i
].req
);
1107 for (i
= 0; i
< num_mb
; ++i
) {
1108 skcipher_request_set_callback(data
[i
].req
,
1109 CRYPTO_TFM_REQ_MAY_BACKLOG
,
1110 crypto_req_done
, &data
[i
].wait
);
1111 crypto_init_wait(&data
[i
].wait
);
1114 pr_info("testing speed of multibuffer %s (%s) %s\n", algo
,
1115 get_driver_name(crypto_skcipher
, tfm
), e
);
1119 b_size
= block_sizes
;
1121 u32 bs
= round_up(*b_size
, crypto_skcipher_blocksize(tfm
));
1123 if (bs
> XBUFSIZE
* PAGE_SIZE
) {
1124 pr_err("template (%u) too big for buffer (%lu)\n",
1125 bs
, XBUFSIZE
* PAGE_SIZE
);
1129 pr_info("test %u (%d bit key, %d byte blocks): ", i
,
1132 /* Set up tfm global state, i.e. the key */
1134 memset(tvmem
[0], 0xff, PAGE_SIZE
);
1136 for (j
= 0; j
< tcount
; j
++) {
1137 if (template[j
].klen
== *keysize
) {
1138 key
= template[j
].key
;
1143 crypto_skcipher_clear_flags(tfm
, ~0);
1145 ret
= crypto_skcipher_setkey(tfm
, key
, *keysize
);
1147 pr_err("setkey() failed flags=%x\n",
1148 crypto_skcipher_get_flags(tfm
));
1152 iv_len
= crypto_skcipher_ivsize(tfm
);
1154 memset(&iv
, 0xff, iv_len
);
1156 /* Now setup per request stuff, i.e. buffers */
1158 for (j
= 0; j
< num_mb
; ++j
) {
1159 struct test_mb_skcipher_data
*cur
= &data
[j
];
1160 unsigned int k
= bs
;
1161 unsigned int pages
= DIV_ROUND_UP(k
, PAGE_SIZE
);
1164 sg_init_table(cur
->sg
, pages
);
1166 while (k
> PAGE_SIZE
) {
1167 sg_set_buf(cur
->sg
+ p
, cur
->xbuf
[p
],
1169 memset(cur
->xbuf
[p
], 0xff, PAGE_SIZE
);
1174 sg_set_buf(cur
->sg
+ p
, cur
->xbuf
[p
], k
);
1175 memset(cur
->xbuf
[p
], 0xff, k
);
1177 skcipher_request_set_crypt(cur
->req
, cur
->sg
,
1182 ret
= test_mb_acipher_jiffies(data
, enc
,
1187 ret
= test_mb_acipher_cycles(data
, enc
,
1192 pr_err("%s() failed flags=%x\n", e
,
1193 crypto_skcipher_get_flags(tfm
));
1203 for (i
= 0; i
< num_mb
; ++i
)
1204 skcipher_request_free(data
[i
].req
);
1206 for (i
= 0; i
< num_mb
; ++i
)
1207 testmgr_free_buf(data
[i
].xbuf
);
1209 crypto_free_skcipher(tfm
);
1214 static inline int do_one_acipher_op(struct skcipher_request
*req
, int ret
)
1216 struct crypto_wait
*wait
= req
->base
.data
;
1218 return crypto_wait_req(ret
, wait
);
1221 static int test_acipher_jiffies(struct skcipher_request
*req
, int enc
,
1224 unsigned long start
, end
;
1228 for (start
= jiffies
, end
= start
+ secs
* HZ
, bcount
= 0;
1229 time_before(jiffies
, end
); bcount
++) {
1231 ret
= do_one_acipher_op(req
,
1232 crypto_skcipher_encrypt(req
));
1234 ret
= do_one_acipher_op(req
,
1235 crypto_skcipher_decrypt(req
));
1241 pr_cont("%d operations in %d seconds (%llu bytes)\n",
1242 bcount
, secs
, (u64
)bcount
* blen
);
1246 static int test_acipher_cycles(struct skcipher_request
*req
, int enc
,
1249 unsigned long cycles
= 0;
1254 for (i
= 0; i
< 4; i
++) {
1256 ret
= do_one_acipher_op(req
,
1257 crypto_skcipher_encrypt(req
));
1259 ret
= do_one_acipher_op(req
,
1260 crypto_skcipher_decrypt(req
));
1266 /* The real thing. */
1267 for (i
= 0; i
< 8; i
++) {
1268 cycles_t start
, end
;
1270 start
= get_cycles();
1272 ret
= do_one_acipher_op(req
,
1273 crypto_skcipher_encrypt(req
));
1275 ret
= do_one_acipher_op(req
,
1276 crypto_skcipher_decrypt(req
));
1282 cycles
+= end
- start
;
1287 pr_cont("1 operation in %lu cycles (%d bytes)\n",
1288 (cycles
+ 4) / 8, blen
);
1293 static void test_skcipher_speed(const char *algo
, int enc
, unsigned int secs
,
1294 struct cipher_speed_template
*template,
1295 unsigned int tcount
, u8
*keysize
, bool async
)
1297 unsigned int ret
, i
, j
, k
, iv_len
;
1298 struct crypto_wait wait
;
1301 struct skcipher_request
*req
;
1302 struct crypto_skcipher
*tfm
;
1311 crypto_init_wait(&wait
);
1313 tfm
= crypto_alloc_skcipher(algo
, 0, async
? 0 : CRYPTO_ALG_ASYNC
);
1316 pr_err("failed to load transform for %s: %ld\n", algo
,
1321 pr_info("testing speed of %s %s (%s) %s\n", async
? "async" : "sync",
1322 algo
, get_driver_name(crypto_skcipher
, tfm
), e
);
1324 req
= skcipher_request_alloc(tfm
, GFP_KERNEL
);
1326 pr_err("skcipher: Failed to allocate request for %s\n", algo
);
1330 skcipher_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
1331 crypto_req_done
, &wait
);
1335 b_size
= block_sizes
;
1338 u32 bs
= round_up(*b_size
, crypto_skcipher_blocksize(tfm
));
1339 struct scatterlist sg
[TVMEMSIZE
];
1341 if ((*keysize
+ bs
) > TVMEMSIZE
* PAGE_SIZE
) {
1342 pr_err("template (%u) too big for "
1343 "tvmem (%lu)\n", *keysize
+ bs
,
1344 TVMEMSIZE
* PAGE_SIZE
);
1348 pr_info("test %u (%d bit key, %d byte blocks): ", i
,
1351 memset(tvmem
[0], 0xff, PAGE_SIZE
);
1353 /* set key, plain text and IV */
1355 for (j
= 0; j
< tcount
; j
++) {
1356 if (template[j
].klen
== *keysize
) {
1357 key
= template[j
].key
;
1362 crypto_skcipher_clear_flags(tfm
, ~0);
1364 ret
= crypto_skcipher_setkey(tfm
, key
, *keysize
);
1366 pr_err("setkey() failed flags=%x\n",
1367 crypto_skcipher_get_flags(tfm
));
1372 sg_init_table(sg
, DIV_ROUND_UP(k
, PAGE_SIZE
));
1374 if (k
> PAGE_SIZE
) {
1375 sg_set_buf(sg
, tvmem
[0] + *keysize
,
1376 PAGE_SIZE
- *keysize
);
1379 while (k
> PAGE_SIZE
) {
1380 sg_set_buf(sg
+ j
, tvmem
[j
], PAGE_SIZE
);
1381 memset(tvmem
[j
], 0xff, PAGE_SIZE
);
1385 sg_set_buf(sg
+ j
, tvmem
[j
], k
);
1386 memset(tvmem
[j
], 0xff, k
);
1388 sg_set_buf(sg
, tvmem
[0] + *keysize
, bs
);
1391 iv_len
= crypto_skcipher_ivsize(tfm
);
1393 memset(&iv
, 0xff, iv_len
);
1395 skcipher_request_set_crypt(req
, sg
, sg
, bs
, iv
);
1398 ret
= test_acipher_jiffies(req
, enc
,
1402 ret
= test_acipher_cycles(req
, enc
,
1407 pr_err("%s() failed flags=%x\n", e
,
1408 crypto_skcipher_get_flags(tfm
));
1418 skcipher_request_free(req
);
1420 crypto_free_skcipher(tfm
);
1423 static void test_acipher_speed(const char *algo
, int enc
, unsigned int secs
,
1424 struct cipher_speed_template
*template,
1425 unsigned int tcount
, u8
*keysize
)
1427 return test_skcipher_speed(algo
, enc
, secs
, template, tcount
, keysize
,
1431 static void test_cipher_speed(const char *algo
, int enc
, unsigned int secs
,
1432 struct cipher_speed_template
*template,
1433 unsigned int tcount
, u8
*keysize
)
1435 return test_skcipher_speed(algo
, enc
, secs
, template, tcount
, keysize
,
1439 static inline int tcrypt_test(const char *alg
)
1443 pr_debug("testing %s\n", alg
);
1445 ret
= alg_test(alg
, alg
, 0, 0);
1446 /* non-fips algs return -EINVAL or -ECANCELED in fips mode */
1447 if (fips_enabled
&& (ret
== -EINVAL
|| ret
== -ECANCELED
))
1452 static int do_test(const char *alg
, u32 type
, u32 mask
, int m
, u32 num_mb
)
1460 if (!crypto_has_alg(alg
, type
,
1461 mask
?: CRYPTO_ALG_TYPE_MASK
))
1466 for (i
= 1; i
< 200; i
++)
1467 ret
= min(ret
, do_test(NULL
, 0, 0, i
, num_mb
));
1471 ret
= min(ret
, tcrypt_test("md5"));
1475 ret
= min(ret
, tcrypt_test("sha1"));
1479 ret
= min(ret
, tcrypt_test("ecb(des)"));
1480 ret
= min(ret
, tcrypt_test("cbc(des)"));
1481 ret
= min(ret
, tcrypt_test("ctr(des)"));
1485 ret
= min(ret
, tcrypt_test("ecb(des3_ede)"));
1486 ret
= min(ret
, tcrypt_test("cbc(des3_ede)"));
1487 ret
= min(ret
, tcrypt_test("ctr(des3_ede)"));
1491 ret
= min(ret
, tcrypt_test("md4"));
1495 ret
= min(ret
, tcrypt_test("sha256"));
1499 ret
= min(ret
, tcrypt_test("ecb(blowfish)"));
1500 ret
= min(ret
, tcrypt_test("cbc(blowfish)"));
1501 ret
= min(ret
, tcrypt_test("ctr(blowfish)"));
1505 ret
= min(ret
, tcrypt_test("ecb(twofish)"));
1506 ret
= min(ret
, tcrypt_test("cbc(twofish)"));
1507 ret
= min(ret
, tcrypt_test("ctr(twofish)"));
1508 ret
= min(ret
, tcrypt_test("lrw(twofish)"));
1509 ret
= min(ret
, tcrypt_test("xts(twofish)"));
1513 ret
= min(ret
, tcrypt_test("ecb(serpent)"));
1514 ret
= min(ret
, tcrypt_test("cbc(serpent)"));
1515 ret
= min(ret
, tcrypt_test("ctr(serpent)"));
1516 ret
= min(ret
, tcrypt_test("lrw(serpent)"));
1517 ret
= min(ret
, tcrypt_test("xts(serpent)"));
1521 ret
= min(ret
, tcrypt_test("ecb(aes)"));
1522 ret
= min(ret
, tcrypt_test("cbc(aes)"));
1523 ret
= min(ret
, tcrypt_test("lrw(aes)"));
1524 ret
= min(ret
, tcrypt_test("xts(aes)"));
1525 ret
= min(ret
, tcrypt_test("ctr(aes)"));
1526 ret
= min(ret
, tcrypt_test("rfc3686(ctr(aes))"));
1527 ret
= min(ret
, tcrypt_test("ofb(aes)"));
1528 ret
= min(ret
, tcrypt_test("cfb(aes)"));
1529 ret
= min(ret
, tcrypt_test("xctr(aes)"));
1533 ret
= min(ret
, tcrypt_test("sha384"));
1537 ret
= min(ret
, tcrypt_test("sha512"));
1541 ret
= min(ret
, tcrypt_test("deflate"));
1545 ret
= min(ret
, tcrypt_test("ecb(cast5)"));
1546 ret
= min(ret
, tcrypt_test("cbc(cast5)"));
1547 ret
= min(ret
, tcrypt_test("ctr(cast5)"));
1551 ret
= min(ret
, tcrypt_test("ecb(cast6)"));
1552 ret
= min(ret
, tcrypt_test("cbc(cast6)"));
1553 ret
= min(ret
, tcrypt_test("ctr(cast6)"));
1554 ret
= min(ret
, tcrypt_test("lrw(cast6)"));
1555 ret
= min(ret
, tcrypt_test("xts(cast6)"));
1559 ret
= min(ret
, tcrypt_test("ecb(arc4)"));
1563 ret
= min(ret
, tcrypt_test("michael_mic"));
1567 ret
= min(ret
, tcrypt_test("crc32c"));
1571 ret
= min(ret
, tcrypt_test("ecb(tea)"));
1575 ret
= min(ret
, tcrypt_test("ecb(xtea)"));
1579 ret
= min(ret
, tcrypt_test("ecb(khazad)"));
1583 ret
= min(ret
, tcrypt_test("wp512"));
1587 ret
= min(ret
, tcrypt_test("wp384"));
1591 ret
= min(ret
, tcrypt_test("wp256"));
1595 ret
= min(ret
, tcrypt_test("ecb(anubis)"));
1596 ret
= min(ret
, tcrypt_test("cbc(anubis)"));
1600 ret
= min(ret
, tcrypt_test("ecb(xeta)"));
1604 ret
= min(ret
, tcrypt_test("pcbc(fcrypt)"));
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)"));
1616 ret
= min(ret
, tcrypt_test("sha224"));
1620 ret
= min(ret
, tcrypt_test("gcm(aes)"));
1624 ret
= min(ret
, tcrypt_test("lzo"));
1628 ret
= min(ret
, tcrypt_test("ccm(aes)"));
1632 ret
= min(ret
, tcrypt_test("cts(cbc(aes))"));
1636 ret
= min(ret
, tcrypt_test("xxhash64"));
1640 ret
= min(ret
, tcrypt_test("rmd160"));
1644 ret
= min(ret
, tcrypt_test("blake2b-512"));
1648 ret
= min(ret
, tcrypt_test("ecb(seed)"));
1652 ret
= min(ret
, tcrypt_test("rfc4309(ccm(aes))"));
1656 ret
= min(ret
, tcrypt_test("ghash"));
1660 ret
= min(ret
, tcrypt_test("crct10dif"));
1664 ret
= min(ret
, tcrypt_test("sha3-224"));
1668 ret
= min(ret
, tcrypt_test("sha3-256"));
1672 ret
= min(ret
, tcrypt_test("sha3-384"));
1676 ret
= min(ret
, tcrypt_test("sha3-512"));
1680 ret
= min(ret
, tcrypt_test("sm3"));
1684 ret
= min(ret
, tcrypt_test("streebog256"));
1688 ret
= min(ret
, tcrypt_test("streebog512"));
1692 ret
= min(ret
, tcrypt_test("gcm(sm4)"));
1696 ret
= min(ret
, tcrypt_test("ccm(sm4)"));
1700 ret
= min(ret
, tcrypt_test("polyval"));
1704 ret
= min(ret
, tcrypt_test("gcm(aria)"));
1708 ret
= min(ret
, tcrypt_test("cts(cbc(sm4))"));
1712 ret
= min(ret
, tcrypt_test("hmac(md5)"));
1716 ret
= min(ret
, tcrypt_test("hmac(sha1)"));
1720 ret
= min(ret
, tcrypt_test("hmac(sha256)"));
1724 ret
= min(ret
, tcrypt_test("hmac(sha384)"));
1728 ret
= min(ret
, tcrypt_test("hmac(sha512)"));
1732 ret
= min(ret
, tcrypt_test("hmac(sha224)"));
1736 ret
= min(ret
, tcrypt_test("xcbc(aes)"));
1740 ret
= min(ret
, tcrypt_test("hmac(rmd160)"));
1744 ret
= min(ret
, tcrypt_test("vmac64(aes)"));
1748 ret
= min(ret
, tcrypt_test("hmac(sha3-224)"));
1752 ret
= min(ret
, tcrypt_test("hmac(sha3-256)"));
1756 ret
= min(ret
, tcrypt_test("hmac(sha3-384)"));
1760 ret
= min(ret
, tcrypt_test("hmac(sha3-512)"));
1764 ret
= min(ret
, tcrypt_test("hmac(streebog256)"));
1768 ret
= min(ret
, tcrypt_test("hmac(streebog512)"));
1772 ret
= min(ret
, tcrypt_test("ansi_cprng"));
1776 ret
= min(ret
, tcrypt_test("rfc4106(gcm(aes))"));
1780 ret
= min(ret
, tcrypt_test("rfc4543(gcm(aes))"));
1784 ret
= min(ret
, tcrypt_test("cmac(aes)"));
1788 ret
= min(ret
, tcrypt_test("cmac(des3_ede)"));
1792 ret
= min(ret
, tcrypt_test("authenc(hmac(sha1),cbc(aes))"));
1796 ret
= min(ret
, tcrypt_test("authenc(hmac(md5),ecb(cipher_null))"));
1800 ret
= min(ret
, tcrypt_test("authenc(hmac(sha1),ecb(cipher_null))"));
1804 ret
= min(ret
, tcrypt_test("cbcmac(sm4)"));
1808 ret
= min(ret
, tcrypt_test("cmac(sm4)"));
1812 ret
= min(ret
, tcrypt_test("xcbc(sm4)"));
1816 ret
= min(ret
, tcrypt_test("authenc(hmac(sha1),cbc(des))"));
1819 ret
= min(ret
, tcrypt_test("authenc(hmac(sha1),cbc(des3_ede))"));
1822 ret
= min(ret
, tcrypt_test("authenc(hmac(sha224),cbc(des))"));
1825 ret
= min(ret
, tcrypt_test("authenc(hmac(sha224),cbc(des3_ede))"));
1828 ret
= min(ret
, tcrypt_test("authenc(hmac(sha256),cbc(des))"));
1831 ret
= min(ret
, tcrypt_test("authenc(hmac(sha256),cbc(des3_ede))"));
1834 ret
= min(ret
, tcrypt_test("authenc(hmac(sha384),cbc(des))"));
1837 ret
= min(ret
, tcrypt_test("authenc(hmac(sha384),cbc(des3_ede))"));
1840 ret
= min(ret
, tcrypt_test("authenc(hmac(sha512),cbc(des))"));
1843 ret
= min(ret
, tcrypt_test("authenc(hmac(sha512),cbc(des3_ede))"));
1846 ret
= min(ret
, tcrypt_test("ecb(sm4)"));
1847 ret
= min(ret
, tcrypt_test("cbc(sm4)"));
1848 ret
= min(ret
, tcrypt_test("cfb(sm4)"));
1849 ret
= min(ret
, tcrypt_test("ctr(sm4)"));
1850 ret
= min(ret
, tcrypt_test("xts(sm4)"));
1853 ret
= min(ret
, tcrypt_test("ecb(aria)"));
1854 ret
= min(ret
, tcrypt_test("cbc(aria)"));
1855 ret
= min(ret
, tcrypt_test("cfb(aria)"));
1856 ret
= min(ret
, tcrypt_test("ctr(aria)"));
1859 test_cipher_speed("ecb(aes)", ENCRYPT
, sec
, NULL
, 0,
1860 speed_template_16_24_32
);
1861 test_cipher_speed("ecb(aes)", DECRYPT
, sec
, NULL
, 0,
1862 speed_template_16_24_32
);
1863 test_cipher_speed("cbc(aes)", ENCRYPT
, sec
, NULL
, 0,
1864 speed_template_16_24_32
);
1865 test_cipher_speed("cbc(aes)", DECRYPT
, sec
, NULL
, 0,
1866 speed_template_16_24_32
);
1867 test_cipher_speed("lrw(aes)", ENCRYPT
, sec
, NULL
, 0,
1868 speed_template_32_40_48
);
1869 test_cipher_speed("lrw(aes)", DECRYPT
, sec
, NULL
, 0,
1870 speed_template_32_40_48
);
1871 test_cipher_speed("xts(aes)", ENCRYPT
, sec
, NULL
, 0,
1872 speed_template_32_64
);
1873 test_cipher_speed("xts(aes)", DECRYPT
, sec
, NULL
, 0,
1874 speed_template_32_64
);
1875 test_cipher_speed("cts(cbc(aes))", ENCRYPT
, sec
, NULL
, 0,
1876 speed_template_16_24_32
);
1877 test_cipher_speed("cts(cbc(aes))", DECRYPT
, sec
, NULL
, 0,
1878 speed_template_16_24_32
);
1879 test_cipher_speed("ctr(aes)", ENCRYPT
, sec
, NULL
, 0,
1880 speed_template_16_24_32
);
1881 test_cipher_speed("ctr(aes)", DECRYPT
, sec
, NULL
, 0,
1882 speed_template_16_24_32
);
1883 test_cipher_speed("cfb(aes)", ENCRYPT
, sec
, NULL
, 0,
1884 speed_template_16_24_32
);
1885 test_cipher_speed("cfb(aes)", DECRYPT
, sec
, NULL
, 0,
1886 speed_template_16_24_32
);
1890 test_cipher_speed("ecb(des3_ede)", ENCRYPT
, sec
,
1891 des3_speed_template
, DES3_SPEED_VECTORS
,
1893 test_cipher_speed("ecb(des3_ede)", DECRYPT
, sec
,
1894 des3_speed_template
, DES3_SPEED_VECTORS
,
1896 test_cipher_speed("cbc(des3_ede)", ENCRYPT
, sec
,
1897 des3_speed_template
, DES3_SPEED_VECTORS
,
1899 test_cipher_speed("cbc(des3_ede)", DECRYPT
, sec
,
1900 des3_speed_template
, DES3_SPEED_VECTORS
,
1902 test_cipher_speed("ctr(des3_ede)", ENCRYPT
, sec
,
1903 des3_speed_template
, DES3_SPEED_VECTORS
,
1905 test_cipher_speed("ctr(des3_ede)", DECRYPT
, sec
,
1906 des3_speed_template
, DES3_SPEED_VECTORS
,
1911 test_cipher_speed("ecb(twofish)", ENCRYPT
, sec
, NULL
, 0,
1912 speed_template_16_24_32
);
1913 test_cipher_speed("ecb(twofish)", DECRYPT
, sec
, NULL
, 0,
1914 speed_template_16_24_32
);
1915 test_cipher_speed("cbc(twofish)", ENCRYPT
, sec
, NULL
, 0,
1916 speed_template_16_24_32
);
1917 test_cipher_speed("cbc(twofish)", DECRYPT
, sec
, NULL
, 0,
1918 speed_template_16_24_32
);
1919 test_cipher_speed("ctr(twofish)", ENCRYPT
, sec
, NULL
, 0,
1920 speed_template_16_24_32
);
1921 test_cipher_speed("ctr(twofish)", DECRYPT
, sec
, NULL
, 0,
1922 speed_template_16_24_32
);
1923 test_cipher_speed("lrw(twofish)", ENCRYPT
, sec
, NULL
, 0,
1924 speed_template_32_40_48
);
1925 test_cipher_speed("lrw(twofish)", DECRYPT
, sec
, NULL
, 0,
1926 speed_template_32_40_48
);
1927 test_cipher_speed("xts(twofish)", ENCRYPT
, sec
, NULL
, 0,
1928 speed_template_32_48_64
);
1929 test_cipher_speed("xts(twofish)", DECRYPT
, sec
, NULL
, 0,
1930 speed_template_32_48_64
);
1934 test_cipher_speed("ecb(blowfish)", ENCRYPT
, sec
, NULL
, 0,
1935 speed_template_8_32
);
1936 test_cipher_speed("ecb(blowfish)", DECRYPT
, sec
, NULL
, 0,
1937 speed_template_8_32
);
1938 test_cipher_speed("cbc(blowfish)", ENCRYPT
, sec
, NULL
, 0,
1939 speed_template_8_32
);
1940 test_cipher_speed("cbc(blowfish)", DECRYPT
, sec
, NULL
, 0,
1941 speed_template_8_32
);
1942 test_cipher_speed("ctr(blowfish)", ENCRYPT
, sec
, NULL
, 0,
1943 speed_template_8_32
);
1944 test_cipher_speed("ctr(blowfish)", DECRYPT
, sec
, NULL
, 0,
1945 speed_template_8_32
);
1949 test_cipher_speed("ecb(des)", ENCRYPT
, sec
, NULL
, 0,
1951 test_cipher_speed("ecb(des)", DECRYPT
, sec
, NULL
, 0,
1953 test_cipher_speed("cbc(des)", ENCRYPT
, sec
, NULL
, 0,
1955 test_cipher_speed("cbc(des)", DECRYPT
, sec
, NULL
, 0,
1960 test_cipher_speed("ecb(camellia)", ENCRYPT
, sec
, NULL
, 0,
1961 speed_template_16_24_32
);
1962 test_cipher_speed("ecb(camellia)", DECRYPT
, sec
, NULL
, 0,
1963 speed_template_16_24_32
);
1964 test_cipher_speed("cbc(camellia)", ENCRYPT
, sec
, NULL
, 0,
1965 speed_template_16_24_32
);
1966 test_cipher_speed("cbc(camellia)", DECRYPT
, sec
, NULL
, 0,
1967 speed_template_16_24_32
);
1968 test_cipher_speed("ctr(camellia)", ENCRYPT
, sec
, NULL
, 0,
1969 speed_template_16_24_32
);
1970 test_cipher_speed("ctr(camellia)", DECRYPT
, sec
, NULL
, 0,
1971 speed_template_16_24_32
);
1972 test_cipher_speed("lrw(camellia)", ENCRYPT
, sec
, NULL
, 0,
1973 speed_template_32_40_48
);
1974 test_cipher_speed("lrw(camellia)", DECRYPT
, sec
, NULL
, 0,
1975 speed_template_32_40_48
);
1976 test_cipher_speed("xts(camellia)", ENCRYPT
, sec
, NULL
, 0,
1977 speed_template_32_48_64
);
1978 test_cipher_speed("xts(camellia)", DECRYPT
, sec
, NULL
, 0,
1979 speed_template_32_48_64
);
1983 test_cipher_speed("ecb(serpent)", ENCRYPT
, sec
, NULL
, 0,
1984 speed_template_16_32
);
1985 test_cipher_speed("ecb(serpent)", DECRYPT
, sec
, NULL
, 0,
1986 speed_template_16_32
);
1987 test_cipher_speed("cbc(serpent)", ENCRYPT
, sec
, NULL
, 0,
1988 speed_template_16_32
);
1989 test_cipher_speed("cbc(serpent)", DECRYPT
, sec
, NULL
, 0,
1990 speed_template_16_32
);
1991 test_cipher_speed("ctr(serpent)", ENCRYPT
, sec
, NULL
, 0,
1992 speed_template_16_32
);
1993 test_cipher_speed("ctr(serpent)", DECRYPT
, sec
, NULL
, 0,
1994 speed_template_16_32
);
1995 test_cipher_speed("lrw(serpent)", ENCRYPT
, sec
, NULL
, 0,
1996 speed_template_32_48
);
1997 test_cipher_speed("lrw(serpent)", DECRYPT
, sec
, NULL
, 0,
1998 speed_template_32_48
);
1999 test_cipher_speed("xts(serpent)", ENCRYPT
, sec
, NULL
, 0,
2000 speed_template_32_64
);
2001 test_cipher_speed("xts(serpent)", DECRYPT
, sec
, NULL
, 0,
2002 speed_template_32_64
);
2006 test_cipher_speed("ecb(arc4)", ENCRYPT
, sec
, NULL
, 0,
2011 test_cipher_speed("ecb(cast5)", ENCRYPT
, sec
, NULL
, 0,
2012 speed_template_8_16
);
2013 test_cipher_speed("ecb(cast5)", DECRYPT
, sec
, NULL
, 0,
2014 speed_template_8_16
);
2015 test_cipher_speed("cbc(cast5)", ENCRYPT
, sec
, NULL
, 0,
2016 speed_template_8_16
);
2017 test_cipher_speed("cbc(cast5)", DECRYPT
, sec
, NULL
, 0,
2018 speed_template_8_16
);
2019 test_cipher_speed("ctr(cast5)", ENCRYPT
, sec
, NULL
, 0,
2020 speed_template_8_16
);
2021 test_cipher_speed("ctr(cast5)", DECRYPT
, sec
, NULL
, 0,
2022 speed_template_8_16
);
2026 test_cipher_speed("ecb(cast6)", ENCRYPT
, sec
, NULL
, 0,
2027 speed_template_16_32
);
2028 test_cipher_speed("ecb(cast6)", DECRYPT
, sec
, NULL
, 0,
2029 speed_template_16_32
);
2030 test_cipher_speed("cbc(cast6)", ENCRYPT
, sec
, NULL
, 0,
2031 speed_template_16_32
);
2032 test_cipher_speed("cbc(cast6)", DECRYPT
, sec
, NULL
, 0,
2033 speed_template_16_32
);
2034 test_cipher_speed("ctr(cast6)", ENCRYPT
, sec
, NULL
, 0,
2035 speed_template_16_32
);
2036 test_cipher_speed("ctr(cast6)", DECRYPT
, sec
, NULL
, 0,
2037 speed_template_16_32
);
2038 test_cipher_speed("lrw(cast6)", ENCRYPT
, sec
, NULL
, 0,
2039 speed_template_32_48
);
2040 test_cipher_speed("lrw(cast6)", DECRYPT
, sec
, NULL
, 0,
2041 speed_template_32_48
);
2042 test_cipher_speed("xts(cast6)", ENCRYPT
, sec
, NULL
, 0,
2043 speed_template_32_64
);
2044 test_cipher_speed("xts(cast6)", DECRYPT
, sec
, NULL
, 0,
2045 speed_template_32_64
);
2049 test_aead_speed("rfc4106(gcm(aes))", ENCRYPT
, sec
,
2050 NULL
, 0, 16, 16, aead_speed_template_20_28_36
);
2051 test_aead_speed("gcm(aes)", ENCRYPT
, sec
,
2052 NULL
, 0, 16, 8, speed_template_16_24_32
);
2053 test_aead_speed("rfc4106(gcm(aes))", DECRYPT
, sec
,
2054 NULL
, 0, 16, 16, aead_speed_template_20_28_36
);
2055 test_aead_speed("gcm(aes)", DECRYPT
, sec
,
2056 NULL
, 0, 16, 8, speed_template_16_24_32
);
2060 test_aead_speed("rfc4309(ccm(aes))", ENCRYPT
, sec
,
2061 NULL
, 0, 16, 16, aead_speed_template_19
);
2062 test_aead_speed("rfc4309(ccm(aes))", DECRYPT
, sec
,
2063 NULL
, 0, 16, 16, aead_speed_template_19
);
2067 test_aead_speed("rfc7539esp(chacha20,poly1305)", ENCRYPT
, sec
,
2068 NULL
, 0, 16, 8, aead_speed_template_36
);
2069 test_aead_speed("rfc7539esp(chacha20,poly1305)", DECRYPT
, sec
,
2070 NULL
, 0, 16, 8, aead_speed_template_36
);
2074 test_cipher_speed("chacha20", ENCRYPT
, sec
, NULL
, 0,
2079 test_mb_aead_speed("rfc4106(gcm(aes))", ENCRYPT
, sec
, NULL
,
2080 0, 16, 16, aead_speed_template_20_28_36
, num_mb
);
2081 test_mb_aead_speed("gcm(aes)", ENCRYPT
, sec
, NULL
, 0, 16, 8,
2082 speed_template_16_24_32
, num_mb
);
2083 test_mb_aead_speed("rfc4106(gcm(aes))", DECRYPT
, sec
, NULL
,
2084 0, 16, 16, aead_speed_template_20_28_36
, num_mb
);
2085 test_mb_aead_speed("gcm(aes)", DECRYPT
, sec
, NULL
, 0, 16, 8,
2086 speed_template_16_24_32
, num_mb
);
2090 test_mb_aead_speed("rfc4309(ccm(aes))", ENCRYPT
, sec
, NULL
, 0,
2091 16, 16, aead_speed_template_19
, num_mb
);
2092 test_mb_aead_speed("rfc4309(ccm(aes))", DECRYPT
, sec
, NULL
, 0,
2093 16, 16, aead_speed_template_19
, num_mb
);
2097 test_mb_aead_speed("rfc7539esp(chacha20,poly1305)", ENCRYPT
,
2098 sec
, NULL
, 0, 16, 8, aead_speed_template_36
,
2100 test_mb_aead_speed("rfc7539esp(chacha20,poly1305)", DECRYPT
,
2101 sec
, NULL
, 0, 16, 8, aead_speed_template_36
,
2106 test_cipher_speed("ecb(sm4)", ENCRYPT
, sec
, NULL
, 0,
2108 test_cipher_speed("ecb(sm4)", DECRYPT
, sec
, NULL
, 0,
2110 test_cipher_speed("cbc(sm4)", ENCRYPT
, sec
, NULL
, 0,
2112 test_cipher_speed("cbc(sm4)", DECRYPT
, sec
, NULL
, 0,
2114 test_cipher_speed("cts(cbc(sm4))", ENCRYPT
, sec
, NULL
, 0,
2116 test_cipher_speed("cts(cbc(sm4))", DECRYPT
, sec
, NULL
, 0,
2118 test_cipher_speed("cfb(sm4)", ENCRYPT
, sec
, NULL
, 0,
2120 test_cipher_speed("cfb(sm4)", DECRYPT
, sec
, NULL
, 0,
2122 test_cipher_speed("ctr(sm4)", ENCRYPT
, sec
, NULL
, 0,
2124 test_cipher_speed("ctr(sm4)", DECRYPT
, sec
, NULL
, 0,
2126 test_cipher_speed("xts(sm4)", ENCRYPT
, sec
, NULL
, 0,
2128 test_cipher_speed("xts(sm4)", DECRYPT
, sec
, NULL
, 0,
2133 test_cipher_speed("adiantum(xchacha12,aes)", ENCRYPT
, sec
, NULL
,
2134 0, speed_template_32
);
2135 test_cipher_speed("adiantum(xchacha12,aes)", DECRYPT
, sec
, NULL
,
2136 0, speed_template_32
);
2137 test_cipher_speed("adiantum(xchacha20,aes)", ENCRYPT
, sec
, NULL
,
2138 0, speed_template_32
);
2139 test_cipher_speed("adiantum(xchacha20,aes)", DECRYPT
, sec
, NULL
,
2140 0, speed_template_32
);
2144 test_acipher_speed("essiv(cbc(aes),sha256)",
2145 ENCRYPT
, sec
, NULL
, 0,
2146 speed_template_16_24_32
);
2147 test_acipher_speed("essiv(cbc(aes),sha256)",
2148 DECRYPT
, sec
, NULL
, 0,
2149 speed_template_16_24_32
);
2153 test_aead_speed("aegis128", ENCRYPT
, sec
,
2154 NULL
, 0, 16, 8, speed_template_16
);
2155 test_aead_speed("aegis128", DECRYPT
, sec
,
2156 NULL
, 0, 16, 8, speed_template_16
);
2160 test_aead_speed("gcm(sm4)", ENCRYPT
, sec
,
2161 NULL
, 0, 16, 8, speed_template_16
);
2162 test_aead_speed("gcm(sm4)", DECRYPT
, sec
,
2163 NULL
, 0, 16, 8, speed_template_16
);
2167 test_aead_speed("rfc4309(ccm(sm4))", ENCRYPT
, sec
,
2168 NULL
, 0, 16, 16, aead_speed_template_19
);
2169 test_aead_speed("rfc4309(ccm(sm4))", DECRYPT
, sec
,
2170 NULL
, 0, 16, 16, aead_speed_template_19
);
2174 test_mb_aead_speed("gcm(sm4)", ENCRYPT
, sec
, NULL
, 0, 16, 8,
2175 speed_template_16
, num_mb
);
2176 test_mb_aead_speed("gcm(sm4)", DECRYPT
, sec
, NULL
, 0, 16, 8,
2177 speed_template_16
, num_mb
);
2181 test_mb_aead_speed("rfc4309(ccm(sm4))", ENCRYPT
, sec
, NULL
, 0,
2182 16, 16, aead_speed_template_19
, num_mb
);
2183 test_mb_aead_speed("rfc4309(ccm(sm4))", DECRYPT
, sec
, NULL
, 0,
2184 16, 16, aead_speed_template_19
, num_mb
);
2188 test_cipher_speed("hctr2(aes)", ENCRYPT
, sec
, NULL
,
2189 0, speed_template_32
);
2193 test_cipher_speed("ecb(aria)", ENCRYPT
, sec
, NULL
, 0,
2194 speed_template_16_24_32
);
2195 test_cipher_speed("ecb(aria)", DECRYPT
, sec
, NULL
, 0,
2196 speed_template_16_24_32
);
2197 test_cipher_speed("cbc(aria)", ENCRYPT
, sec
, NULL
, 0,
2198 speed_template_16_24_32
);
2199 test_cipher_speed("cbc(aria)", DECRYPT
, sec
, NULL
, 0,
2200 speed_template_16_24_32
);
2201 test_cipher_speed("cfb(aria)", ENCRYPT
, sec
, NULL
, 0,
2202 speed_template_16_24_32
);
2203 test_cipher_speed("cfb(aria)", DECRYPT
, sec
, NULL
, 0,
2204 speed_template_16_24_32
);
2205 test_cipher_speed("ctr(aria)", ENCRYPT
, sec
, NULL
, 0,
2206 speed_template_16_24_32
);
2207 test_cipher_speed("ctr(aria)", DECRYPT
, sec
, NULL
, 0,
2208 speed_template_16_24_32
);
2212 test_aead_speed("gcm(aria)", ENCRYPT
, sec
,
2213 NULL
, 0, 16, 8, speed_template_16_24_32
);
2214 test_aead_speed("gcm(aria)", DECRYPT
, sec
,
2215 NULL
, 0, 16, 8, speed_template_16_24_32
);
2219 test_mb_aead_speed("gcm(aria)", ENCRYPT
, sec
, NULL
, 0, 16, 8,
2220 speed_template_16
, num_mb
);
2221 test_mb_aead_speed("gcm(aria)", DECRYPT
, sec
, NULL
, 0, 16, 8,
2222 speed_template_16
, num_mb
);
2227 test_hash_speed(alg
, sec
, generic_hash_speed_template
);
2232 test_hash_speed("md4", sec
, generic_hash_speed_template
);
2233 if (mode
> 300 && mode
< 400) break;
2236 test_hash_speed("md5", sec
, generic_hash_speed_template
);
2237 if (mode
> 300 && mode
< 400) break;
2240 test_hash_speed("sha1", sec
, generic_hash_speed_template
);
2241 if (mode
> 300 && mode
< 400) break;
2244 test_hash_speed("sha256", sec
, generic_hash_speed_template
);
2245 if (mode
> 300 && mode
< 400) break;
2248 test_hash_speed("sha384", sec
, generic_hash_speed_template
);
2249 if (mode
> 300 && mode
< 400) break;
2252 test_hash_speed("sha512", sec
, generic_hash_speed_template
);
2253 if (mode
> 300 && mode
< 400) break;
2256 test_hash_speed("wp256", sec
, generic_hash_speed_template
);
2257 if (mode
> 300 && mode
< 400) break;
2260 test_hash_speed("wp384", sec
, generic_hash_speed_template
);
2261 if (mode
> 300 && mode
< 400) break;
2264 test_hash_speed("wp512", sec
, generic_hash_speed_template
);
2265 if (mode
> 300 && mode
< 400) break;
2268 test_hash_speed("sha224", sec
, generic_hash_speed_template
);
2269 if (mode
> 300 && mode
< 400) break;
2272 test_hash_speed("xxhash64", sec
, generic_hash_speed_template
);
2273 if (mode
> 300 && mode
< 400) break;
2276 test_hash_speed("rmd160", sec
, generic_hash_speed_template
);
2277 if (mode
> 300 && mode
< 400) break;
2280 test_hash_speed("blake2b-512", sec
, generic_hash_speed_template
);
2281 if (mode
> 300 && mode
< 400) break;
2285 test_hash_speed("ghash", sec
, generic_hash_speed_template
);
2286 if (mode
> 300 && mode
< 400) break;
2289 test_hash_speed("crc32c", sec
, generic_hash_speed_template
);
2290 if (mode
> 300 && mode
< 400) break;
2293 test_hash_speed("crct10dif", sec
, generic_hash_speed_template
);
2294 if (mode
> 300 && mode
< 400) break;
2297 test_hash_speed("poly1305", sec
, poly1305_speed_template
);
2298 if (mode
> 300 && mode
< 400) break;
2301 test_hash_speed("sha3-224", sec
, generic_hash_speed_template
);
2302 if (mode
> 300 && mode
< 400) break;
2305 test_hash_speed("sha3-256", sec
, generic_hash_speed_template
);
2306 if (mode
> 300 && mode
< 400) break;
2309 test_hash_speed("sha3-384", sec
, generic_hash_speed_template
);
2310 if (mode
> 300 && mode
< 400) break;
2313 test_hash_speed("sha3-512", sec
, generic_hash_speed_template
);
2314 if (mode
> 300 && mode
< 400) break;
2317 test_hash_speed("sm3", sec
, generic_hash_speed_template
);
2318 if (mode
> 300 && mode
< 400) break;
2321 test_hash_speed("streebog256", sec
,
2322 generic_hash_speed_template
);
2323 if (mode
> 300 && mode
< 400) break;
2326 test_hash_speed("streebog512", sec
,
2327 generic_hash_speed_template
);
2328 if (mode
> 300 && mode
< 400) break;
2335 test_ahash_speed(alg
, sec
, generic_hash_speed_template
);
2340 test_ahash_speed("md4", sec
, generic_hash_speed_template
);
2341 if (mode
> 400 && mode
< 500) break;
2344 test_ahash_speed("md5", sec
, generic_hash_speed_template
);
2345 if (mode
> 400 && mode
< 500) break;
2348 test_ahash_speed("sha1", sec
, generic_hash_speed_template
);
2349 if (mode
> 400 && mode
< 500) break;
2352 test_ahash_speed("sha256", sec
, generic_hash_speed_template
);
2353 if (mode
> 400 && mode
< 500) break;
2356 test_ahash_speed("sha384", sec
, generic_hash_speed_template
);
2357 if (mode
> 400 && mode
< 500) break;
2360 test_ahash_speed("sha512", sec
, generic_hash_speed_template
);
2361 if (mode
> 400 && mode
< 500) break;
2364 test_ahash_speed("wp256", sec
, generic_hash_speed_template
);
2365 if (mode
> 400 && mode
< 500) break;
2368 test_ahash_speed("wp384", sec
, generic_hash_speed_template
);
2369 if (mode
> 400 && mode
< 500) break;
2372 test_ahash_speed("wp512", sec
, generic_hash_speed_template
);
2373 if (mode
> 400 && mode
< 500) break;
2376 test_ahash_speed("sha224", sec
, generic_hash_speed_template
);
2377 if (mode
> 400 && mode
< 500) break;
2380 test_ahash_speed("xxhash64", sec
, generic_hash_speed_template
);
2381 if (mode
> 400 && mode
< 500) break;
2384 test_ahash_speed("rmd160", sec
, generic_hash_speed_template
);
2385 if (mode
> 400 && mode
< 500) break;
2388 test_ahash_speed("blake2b-512", sec
, generic_hash_speed_template
);
2389 if (mode
> 400 && mode
< 500) break;
2392 test_ahash_speed("sha3-224", sec
, generic_hash_speed_template
);
2393 if (mode
> 400 && mode
< 500) break;
2396 test_ahash_speed("sha3-256", sec
, generic_hash_speed_template
);
2397 if (mode
> 400 && mode
< 500) break;
2400 test_ahash_speed("sha3-384", sec
, generic_hash_speed_template
);
2401 if (mode
> 400 && mode
< 500) break;
2404 test_ahash_speed("sha3-512", sec
, generic_hash_speed_template
);
2405 if (mode
> 400 && mode
< 500) break;
2408 test_ahash_speed("sm3", sec
, generic_hash_speed_template
);
2409 if (mode
> 400 && mode
< 500) break;
2415 test_acipher_speed("ecb(aes)", ENCRYPT
, sec
, NULL
, 0,
2416 speed_template_16_24_32
);
2417 test_acipher_speed("ecb(aes)", DECRYPT
, sec
, NULL
, 0,
2418 speed_template_16_24_32
);
2419 test_acipher_speed("cbc(aes)", ENCRYPT
, sec
, NULL
, 0,
2420 speed_template_16_24_32
);
2421 test_acipher_speed("cbc(aes)", DECRYPT
, sec
, NULL
, 0,
2422 speed_template_16_24_32
);
2423 test_acipher_speed("lrw(aes)", ENCRYPT
, sec
, NULL
, 0,
2424 speed_template_32_40_48
);
2425 test_acipher_speed("lrw(aes)", DECRYPT
, sec
, NULL
, 0,
2426 speed_template_32_40_48
);
2427 test_acipher_speed("xts(aes)", ENCRYPT
, sec
, NULL
, 0,
2428 speed_template_32_64
);
2429 test_acipher_speed("xts(aes)", DECRYPT
, sec
, NULL
, 0,
2430 speed_template_32_64
);
2431 test_acipher_speed("cts(cbc(aes))", ENCRYPT
, sec
, NULL
, 0,
2432 speed_template_16_24_32
);
2433 test_acipher_speed("cts(cbc(aes))", DECRYPT
, sec
, NULL
, 0,
2434 speed_template_16_24_32
);
2435 test_acipher_speed("ctr(aes)", ENCRYPT
, sec
, NULL
, 0,
2436 speed_template_16_24_32
);
2437 test_acipher_speed("ctr(aes)", DECRYPT
, sec
, NULL
, 0,
2438 speed_template_16_24_32
);
2439 test_acipher_speed("cfb(aes)", ENCRYPT
, sec
, NULL
, 0,
2440 speed_template_16_24_32
);
2441 test_acipher_speed("cfb(aes)", DECRYPT
, sec
, NULL
, 0,
2442 speed_template_16_24_32
);
2443 test_acipher_speed("ofb(aes)", ENCRYPT
, sec
, NULL
, 0,
2444 speed_template_16_24_32
);
2445 test_acipher_speed("ofb(aes)", DECRYPT
, sec
, NULL
, 0,
2446 speed_template_16_24_32
);
2447 test_acipher_speed("rfc3686(ctr(aes))", ENCRYPT
, sec
, NULL
, 0,
2448 speed_template_20_28_36
);
2449 test_acipher_speed("rfc3686(ctr(aes))", DECRYPT
, sec
, NULL
, 0,
2450 speed_template_20_28_36
);
2454 test_acipher_speed("ecb(des3_ede)", ENCRYPT
, sec
,
2455 des3_speed_template
, DES3_SPEED_VECTORS
,
2457 test_acipher_speed("ecb(des3_ede)", DECRYPT
, sec
,
2458 des3_speed_template
, DES3_SPEED_VECTORS
,
2460 test_acipher_speed("cbc(des3_ede)", ENCRYPT
, sec
,
2461 des3_speed_template
, DES3_SPEED_VECTORS
,
2463 test_acipher_speed("cbc(des3_ede)", DECRYPT
, sec
,
2464 des3_speed_template
, DES3_SPEED_VECTORS
,
2466 test_acipher_speed("cfb(des3_ede)", ENCRYPT
, sec
,
2467 des3_speed_template
, DES3_SPEED_VECTORS
,
2469 test_acipher_speed("cfb(des3_ede)", DECRYPT
, sec
,
2470 des3_speed_template
, DES3_SPEED_VECTORS
,
2472 test_acipher_speed("ofb(des3_ede)", ENCRYPT
, sec
,
2473 des3_speed_template
, DES3_SPEED_VECTORS
,
2475 test_acipher_speed("ofb(des3_ede)", DECRYPT
, sec
,
2476 des3_speed_template
, DES3_SPEED_VECTORS
,
2481 test_acipher_speed("ecb(des)", ENCRYPT
, sec
, NULL
, 0,
2483 test_acipher_speed("ecb(des)", DECRYPT
, sec
, NULL
, 0,
2485 test_acipher_speed("cbc(des)", ENCRYPT
, sec
, NULL
, 0,
2487 test_acipher_speed("cbc(des)", DECRYPT
, sec
, NULL
, 0,
2489 test_acipher_speed("cfb(des)", ENCRYPT
, sec
, NULL
, 0,
2491 test_acipher_speed("cfb(des)", DECRYPT
, sec
, NULL
, 0,
2493 test_acipher_speed("ofb(des)", ENCRYPT
, sec
, NULL
, 0,
2495 test_acipher_speed("ofb(des)", DECRYPT
, sec
, NULL
, 0,
2500 test_acipher_speed("ecb(serpent)", ENCRYPT
, sec
, NULL
, 0,
2501 speed_template_16_32
);
2502 test_acipher_speed("ecb(serpent)", DECRYPT
, sec
, NULL
, 0,
2503 speed_template_16_32
);
2504 test_acipher_speed("cbc(serpent)", ENCRYPT
, sec
, NULL
, 0,
2505 speed_template_16_32
);
2506 test_acipher_speed("cbc(serpent)", DECRYPT
, sec
, NULL
, 0,
2507 speed_template_16_32
);
2508 test_acipher_speed("ctr(serpent)", ENCRYPT
, sec
, NULL
, 0,
2509 speed_template_16_32
);
2510 test_acipher_speed("ctr(serpent)", DECRYPT
, sec
, NULL
, 0,
2511 speed_template_16_32
);
2512 test_acipher_speed("lrw(serpent)", ENCRYPT
, sec
, NULL
, 0,
2513 speed_template_32_48
);
2514 test_acipher_speed("lrw(serpent)", DECRYPT
, sec
, NULL
, 0,
2515 speed_template_32_48
);
2516 test_acipher_speed("xts(serpent)", ENCRYPT
, sec
, NULL
, 0,
2517 speed_template_32_64
);
2518 test_acipher_speed("xts(serpent)", DECRYPT
, sec
, NULL
, 0,
2519 speed_template_32_64
);
2523 test_acipher_speed("ecb(twofish)", ENCRYPT
, sec
, NULL
, 0,
2524 speed_template_16_24_32
);
2525 test_acipher_speed("ecb(twofish)", DECRYPT
, sec
, NULL
, 0,
2526 speed_template_16_24_32
);
2527 test_acipher_speed("cbc(twofish)", ENCRYPT
, sec
, NULL
, 0,
2528 speed_template_16_24_32
);
2529 test_acipher_speed("cbc(twofish)", DECRYPT
, sec
, NULL
, 0,
2530 speed_template_16_24_32
);
2531 test_acipher_speed("ctr(twofish)", ENCRYPT
, sec
, NULL
, 0,
2532 speed_template_16_24_32
);
2533 test_acipher_speed("ctr(twofish)", DECRYPT
, sec
, NULL
, 0,
2534 speed_template_16_24_32
);
2535 test_acipher_speed("lrw(twofish)", ENCRYPT
, sec
, NULL
, 0,
2536 speed_template_32_40_48
);
2537 test_acipher_speed("lrw(twofish)", DECRYPT
, sec
, NULL
, 0,
2538 speed_template_32_40_48
);
2539 test_acipher_speed("xts(twofish)", ENCRYPT
, sec
, NULL
, 0,
2540 speed_template_32_48_64
);
2541 test_acipher_speed("xts(twofish)", DECRYPT
, sec
, NULL
, 0,
2542 speed_template_32_48_64
);
2546 test_acipher_speed("ecb(arc4)", ENCRYPT
, sec
, NULL
, 0,
2551 test_acipher_speed("ecb(cast5)", ENCRYPT
, sec
, NULL
, 0,
2552 speed_template_8_16
);
2553 test_acipher_speed("ecb(cast5)", DECRYPT
, sec
, NULL
, 0,
2554 speed_template_8_16
);
2555 test_acipher_speed("cbc(cast5)", ENCRYPT
, sec
, NULL
, 0,
2556 speed_template_8_16
);
2557 test_acipher_speed("cbc(cast5)", DECRYPT
, sec
, NULL
, 0,
2558 speed_template_8_16
);
2559 test_acipher_speed("ctr(cast5)", ENCRYPT
, sec
, NULL
, 0,
2560 speed_template_8_16
);
2561 test_acipher_speed("ctr(cast5)", DECRYPT
, sec
, NULL
, 0,
2562 speed_template_8_16
);
2566 test_acipher_speed("ecb(cast6)", ENCRYPT
, sec
, NULL
, 0,
2567 speed_template_16_32
);
2568 test_acipher_speed("ecb(cast6)", DECRYPT
, sec
, NULL
, 0,
2569 speed_template_16_32
);
2570 test_acipher_speed("cbc(cast6)", ENCRYPT
, sec
, NULL
, 0,
2571 speed_template_16_32
);
2572 test_acipher_speed("cbc(cast6)", DECRYPT
, sec
, NULL
, 0,
2573 speed_template_16_32
);
2574 test_acipher_speed("ctr(cast6)", ENCRYPT
, sec
, NULL
, 0,
2575 speed_template_16_32
);
2576 test_acipher_speed("ctr(cast6)", DECRYPT
, sec
, NULL
, 0,
2577 speed_template_16_32
);
2578 test_acipher_speed("lrw(cast6)", ENCRYPT
, sec
, NULL
, 0,
2579 speed_template_32_48
);
2580 test_acipher_speed("lrw(cast6)", DECRYPT
, sec
, NULL
, 0,
2581 speed_template_32_48
);
2582 test_acipher_speed("xts(cast6)", ENCRYPT
, sec
, NULL
, 0,
2583 speed_template_32_64
);
2584 test_acipher_speed("xts(cast6)", DECRYPT
, sec
, NULL
, 0,
2585 speed_template_32_64
);
2589 test_acipher_speed("ecb(camellia)", ENCRYPT
, sec
, NULL
, 0,
2590 speed_template_16_32
);
2591 test_acipher_speed("ecb(camellia)", DECRYPT
, sec
, NULL
, 0,
2592 speed_template_16_32
);
2593 test_acipher_speed("cbc(camellia)", ENCRYPT
, sec
, NULL
, 0,
2594 speed_template_16_32
);
2595 test_acipher_speed("cbc(camellia)", DECRYPT
, sec
, NULL
, 0,
2596 speed_template_16_32
);
2597 test_acipher_speed("ctr(camellia)", ENCRYPT
, sec
, NULL
, 0,
2598 speed_template_16_32
);
2599 test_acipher_speed("ctr(camellia)", DECRYPT
, sec
, NULL
, 0,
2600 speed_template_16_32
);
2601 test_acipher_speed("lrw(camellia)", ENCRYPT
, sec
, NULL
, 0,
2602 speed_template_32_48
);
2603 test_acipher_speed("lrw(camellia)", DECRYPT
, sec
, NULL
, 0,
2604 speed_template_32_48
);
2605 test_acipher_speed("xts(camellia)", ENCRYPT
, sec
, NULL
, 0,
2606 speed_template_32_64
);
2607 test_acipher_speed("xts(camellia)", DECRYPT
, sec
, NULL
, 0,
2608 speed_template_32_64
);
2612 test_acipher_speed("ecb(blowfish)", ENCRYPT
, sec
, NULL
, 0,
2613 speed_template_8_32
);
2614 test_acipher_speed("ecb(blowfish)", DECRYPT
, sec
, NULL
, 0,
2615 speed_template_8_32
);
2616 test_acipher_speed("cbc(blowfish)", ENCRYPT
, sec
, NULL
, 0,
2617 speed_template_8_32
);
2618 test_acipher_speed("cbc(blowfish)", DECRYPT
, sec
, NULL
, 0,
2619 speed_template_8_32
);
2620 test_acipher_speed("ctr(blowfish)", ENCRYPT
, sec
, NULL
, 0,
2621 speed_template_8_32
);
2622 test_acipher_speed("ctr(blowfish)", DECRYPT
, sec
, NULL
, 0,
2623 speed_template_8_32
);
2627 test_acipher_speed("ecb(sm4)", ENCRYPT
, sec
, NULL
, 0,
2629 test_acipher_speed("ecb(sm4)", DECRYPT
, sec
, NULL
, 0,
2631 test_acipher_speed("cbc(sm4)", ENCRYPT
, sec
, NULL
, 0,
2633 test_acipher_speed("cbc(sm4)", DECRYPT
, sec
, NULL
, 0,
2635 test_acipher_speed("cfb(sm4)", ENCRYPT
, sec
, NULL
, 0,
2637 test_acipher_speed("cfb(sm4)", DECRYPT
, sec
, NULL
, 0,
2639 test_acipher_speed("ctr(sm4)", ENCRYPT
, sec
, NULL
, 0,
2641 test_acipher_speed("ctr(sm4)", DECRYPT
, sec
, NULL
, 0,
2643 test_acipher_speed("xts(sm4)", ENCRYPT
, sec
, NULL
, 0,
2645 test_acipher_speed("xts(sm4)", DECRYPT
, sec
, NULL
, 0,
2650 test_acipher_speed("ecb(aria)", ENCRYPT
, sec
, NULL
, 0,
2651 speed_template_16_24_32
);
2652 test_acipher_speed("ecb(aria)", DECRYPT
, sec
, NULL
, 0,
2653 speed_template_16_24_32
);
2654 test_acipher_speed("ctr(aria)", ENCRYPT
, sec
, NULL
, 0,
2655 speed_template_16_24_32
);
2656 test_acipher_speed("ctr(aria)", DECRYPT
, sec
, NULL
, 0,
2657 speed_template_16_24_32
);
2661 test_mb_skcipher_speed("ecb(aes)", ENCRYPT
, sec
, NULL
, 0,
2662 speed_template_16_24_32
, num_mb
);
2663 test_mb_skcipher_speed("ecb(aes)", DECRYPT
, sec
, NULL
, 0,
2664 speed_template_16_24_32
, num_mb
);
2665 test_mb_skcipher_speed("cbc(aes)", ENCRYPT
, sec
, NULL
, 0,
2666 speed_template_16_24_32
, num_mb
);
2667 test_mb_skcipher_speed("cbc(aes)", DECRYPT
, sec
, NULL
, 0,
2668 speed_template_16_24_32
, num_mb
);
2669 test_mb_skcipher_speed("lrw(aes)", ENCRYPT
, sec
, NULL
, 0,
2670 speed_template_32_40_48
, num_mb
);
2671 test_mb_skcipher_speed("lrw(aes)", DECRYPT
, sec
, NULL
, 0,
2672 speed_template_32_40_48
, num_mb
);
2673 test_mb_skcipher_speed("xts(aes)", ENCRYPT
, sec
, NULL
, 0,
2674 speed_template_32_64
, num_mb
);
2675 test_mb_skcipher_speed("xts(aes)", DECRYPT
, sec
, NULL
, 0,
2676 speed_template_32_64
, num_mb
);
2677 test_mb_skcipher_speed("cts(cbc(aes))", ENCRYPT
, sec
, NULL
, 0,
2678 speed_template_16_24_32
, num_mb
);
2679 test_mb_skcipher_speed("cts(cbc(aes))", DECRYPT
, sec
, NULL
, 0,
2680 speed_template_16_24_32
, num_mb
);
2681 test_mb_skcipher_speed("ctr(aes)", ENCRYPT
, sec
, NULL
, 0,
2682 speed_template_16_24_32
, num_mb
);
2683 test_mb_skcipher_speed("ctr(aes)", DECRYPT
, sec
, NULL
, 0,
2684 speed_template_16_24_32
, num_mb
);
2685 test_mb_skcipher_speed("cfb(aes)", ENCRYPT
, sec
, NULL
, 0,
2686 speed_template_16_24_32
, num_mb
);
2687 test_mb_skcipher_speed("cfb(aes)", DECRYPT
, sec
, NULL
, 0,
2688 speed_template_16_24_32
, num_mb
);
2689 test_mb_skcipher_speed("ofb(aes)", ENCRYPT
, sec
, NULL
, 0,
2690 speed_template_16_24_32
, num_mb
);
2691 test_mb_skcipher_speed("ofb(aes)", DECRYPT
, sec
, NULL
, 0,
2692 speed_template_16_24_32
, num_mb
);
2693 test_mb_skcipher_speed("rfc3686(ctr(aes))", ENCRYPT
, sec
, NULL
,
2694 0, speed_template_20_28_36
, num_mb
);
2695 test_mb_skcipher_speed("rfc3686(ctr(aes))", DECRYPT
, sec
, NULL
,
2696 0, speed_template_20_28_36
, num_mb
);
2700 test_mb_skcipher_speed("ecb(des3_ede)", ENCRYPT
, sec
,
2701 des3_speed_template
, DES3_SPEED_VECTORS
,
2702 speed_template_24
, num_mb
);
2703 test_mb_skcipher_speed("ecb(des3_ede)", DECRYPT
, sec
,
2704 des3_speed_template
, DES3_SPEED_VECTORS
,
2705 speed_template_24
, num_mb
);
2706 test_mb_skcipher_speed("cbc(des3_ede)", ENCRYPT
, sec
,
2707 des3_speed_template
, DES3_SPEED_VECTORS
,
2708 speed_template_24
, num_mb
);
2709 test_mb_skcipher_speed("cbc(des3_ede)", DECRYPT
, sec
,
2710 des3_speed_template
, DES3_SPEED_VECTORS
,
2711 speed_template_24
, num_mb
);
2712 test_mb_skcipher_speed("cfb(des3_ede)", ENCRYPT
, sec
,
2713 des3_speed_template
, DES3_SPEED_VECTORS
,
2714 speed_template_24
, num_mb
);
2715 test_mb_skcipher_speed("cfb(des3_ede)", DECRYPT
, sec
,
2716 des3_speed_template
, DES3_SPEED_VECTORS
,
2717 speed_template_24
, num_mb
);
2718 test_mb_skcipher_speed("ofb(des3_ede)", ENCRYPT
, sec
,
2719 des3_speed_template
, DES3_SPEED_VECTORS
,
2720 speed_template_24
, num_mb
);
2721 test_mb_skcipher_speed("ofb(des3_ede)", DECRYPT
, sec
,
2722 des3_speed_template
, DES3_SPEED_VECTORS
,
2723 speed_template_24
, num_mb
);
2727 test_mb_skcipher_speed("ecb(des)", ENCRYPT
, sec
, NULL
, 0,
2728 speed_template_8
, num_mb
);
2729 test_mb_skcipher_speed("ecb(des)", DECRYPT
, sec
, NULL
, 0,
2730 speed_template_8
, num_mb
);
2731 test_mb_skcipher_speed("cbc(des)", ENCRYPT
, sec
, NULL
, 0,
2732 speed_template_8
, num_mb
);
2733 test_mb_skcipher_speed("cbc(des)", DECRYPT
, sec
, NULL
, 0,
2734 speed_template_8
, num_mb
);
2735 test_mb_skcipher_speed("cfb(des)", ENCRYPT
, sec
, NULL
, 0,
2736 speed_template_8
, num_mb
);
2737 test_mb_skcipher_speed("cfb(des)", DECRYPT
, sec
, NULL
, 0,
2738 speed_template_8
, num_mb
);
2739 test_mb_skcipher_speed("ofb(des)", ENCRYPT
, sec
, NULL
, 0,
2740 speed_template_8
, num_mb
);
2741 test_mb_skcipher_speed("ofb(des)", DECRYPT
, sec
, NULL
, 0,
2742 speed_template_8
, num_mb
);
2746 test_mb_skcipher_speed("ecb(serpent)", ENCRYPT
, sec
, NULL
, 0,
2747 speed_template_16_32
, num_mb
);
2748 test_mb_skcipher_speed("ecb(serpent)", DECRYPT
, sec
, NULL
, 0,
2749 speed_template_16_32
, num_mb
);
2750 test_mb_skcipher_speed("cbc(serpent)", ENCRYPT
, sec
, NULL
, 0,
2751 speed_template_16_32
, num_mb
);
2752 test_mb_skcipher_speed("cbc(serpent)", DECRYPT
, sec
, NULL
, 0,
2753 speed_template_16_32
, num_mb
);
2754 test_mb_skcipher_speed("ctr(serpent)", ENCRYPT
, sec
, NULL
, 0,
2755 speed_template_16_32
, num_mb
);
2756 test_mb_skcipher_speed("ctr(serpent)", DECRYPT
, sec
, NULL
, 0,
2757 speed_template_16_32
, num_mb
);
2758 test_mb_skcipher_speed("lrw(serpent)", ENCRYPT
, sec
, NULL
, 0,
2759 speed_template_32_48
, num_mb
);
2760 test_mb_skcipher_speed("lrw(serpent)", DECRYPT
, sec
, NULL
, 0,
2761 speed_template_32_48
, num_mb
);
2762 test_mb_skcipher_speed("xts(serpent)", ENCRYPT
, sec
, NULL
, 0,
2763 speed_template_32_64
, num_mb
);
2764 test_mb_skcipher_speed("xts(serpent)", DECRYPT
, sec
, NULL
, 0,
2765 speed_template_32_64
, num_mb
);
2769 test_mb_skcipher_speed("ecb(twofish)", ENCRYPT
, sec
, NULL
, 0,
2770 speed_template_16_24_32
, num_mb
);
2771 test_mb_skcipher_speed("ecb(twofish)", DECRYPT
, sec
, NULL
, 0,
2772 speed_template_16_24_32
, num_mb
);
2773 test_mb_skcipher_speed("cbc(twofish)", ENCRYPT
, sec
, NULL
, 0,
2774 speed_template_16_24_32
, num_mb
);
2775 test_mb_skcipher_speed("cbc(twofish)", DECRYPT
, sec
, NULL
, 0,
2776 speed_template_16_24_32
, num_mb
);
2777 test_mb_skcipher_speed("ctr(twofish)", ENCRYPT
, sec
, NULL
, 0,
2778 speed_template_16_24_32
, num_mb
);
2779 test_mb_skcipher_speed("ctr(twofish)", DECRYPT
, sec
, NULL
, 0,
2780 speed_template_16_24_32
, num_mb
);
2781 test_mb_skcipher_speed("lrw(twofish)", ENCRYPT
, sec
, NULL
, 0,
2782 speed_template_32_40_48
, num_mb
);
2783 test_mb_skcipher_speed("lrw(twofish)", DECRYPT
, sec
, NULL
, 0,
2784 speed_template_32_40_48
, num_mb
);
2785 test_mb_skcipher_speed("xts(twofish)", ENCRYPT
, sec
, NULL
, 0,
2786 speed_template_32_48_64
, num_mb
);
2787 test_mb_skcipher_speed("xts(twofish)", DECRYPT
, sec
, NULL
, 0,
2788 speed_template_32_48_64
, num_mb
);
2792 test_mb_skcipher_speed("ecb(arc4)", ENCRYPT
, sec
, NULL
, 0,
2793 speed_template_8
, num_mb
);
2797 test_mb_skcipher_speed("ecb(cast5)", ENCRYPT
, sec
, NULL
, 0,
2798 speed_template_8_16
, num_mb
);
2799 test_mb_skcipher_speed("ecb(cast5)", DECRYPT
, sec
, NULL
, 0,
2800 speed_template_8_16
, num_mb
);
2801 test_mb_skcipher_speed("cbc(cast5)", ENCRYPT
, sec
, NULL
, 0,
2802 speed_template_8_16
, num_mb
);
2803 test_mb_skcipher_speed("cbc(cast5)", DECRYPT
, sec
, NULL
, 0,
2804 speed_template_8_16
, num_mb
);
2805 test_mb_skcipher_speed("ctr(cast5)", ENCRYPT
, sec
, NULL
, 0,
2806 speed_template_8_16
, num_mb
);
2807 test_mb_skcipher_speed("ctr(cast5)", DECRYPT
, sec
, NULL
, 0,
2808 speed_template_8_16
, num_mb
);
2812 test_mb_skcipher_speed("ecb(cast6)", ENCRYPT
, sec
, NULL
, 0,
2813 speed_template_16_32
, num_mb
);
2814 test_mb_skcipher_speed("ecb(cast6)", DECRYPT
, sec
, NULL
, 0,
2815 speed_template_16_32
, num_mb
);
2816 test_mb_skcipher_speed("cbc(cast6)", ENCRYPT
, sec
, NULL
, 0,
2817 speed_template_16_32
, num_mb
);
2818 test_mb_skcipher_speed("cbc(cast6)", DECRYPT
, sec
, NULL
, 0,
2819 speed_template_16_32
, num_mb
);
2820 test_mb_skcipher_speed("ctr(cast6)", ENCRYPT
, sec
, NULL
, 0,
2821 speed_template_16_32
, num_mb
);
2822 test_mb_skcipher_speed("ctr(cast6)", DECRYPT
, sec
, NULL
, 0,
2823 speed_template_16_32
, num_mb
);
2824 test_mb_skcipher_speed("lrw(cast6)", ENCRYPT
, sec
, NULL
, 0,
2825 speed_template_32_48
, num_mb
);
2826 test_mb_skcipher_speed("lrw(cast6)", DECRYPT
, sec
, NULL
, 0,
2827 speed_template_32_48
, num_mb
);
2828 test_mb_skcipher_speed("xts(cast6)", ENCRYPT
, sec
, NULL
, 0,
2829 speed_template_32_64
, num_mb
);
2830 test_mb_skcipher_speed("xts(cast6)", DECRYPT
, sec
, NULL
, 0,
2831 speed_template_32_64
, num_mb
);
2835 test_mb_skcipher_speed("ecb(camellia)", ENCRYPT
, sec
, NULL
, 0,
2836 speed_template_16_32
, num_mb
);
2837 test_mb_skcipher_speed("ecb(camellia)", DECRYPT
, sec
, NULL
, 0,
2838 speed_template_16_32
, num_mb
);
2839 test_mb_skcipher_speed("cbc(camellia)", ENCRYPT
, sec
, NULL
, 0,
2840 speed_template_16_32
, num_mb
);
2841 test_mb_skcipher_speed("cbc(camellia)", DECRYPT
, sec
, NULL
, 0,
2842 speed_template_16_32
, num_mb
);
2843 test_mb_skcipher_speed("ctr(camellia)", ENCRYPT
, sec
, NULL
, 0,
2844 speed_template_16_32
, num_mb
);
2845 test_mb_skcipher_speed("ctr(camellia)", DECRYPT
, sec
, NULL
, 0,
2846 speed_template_16_32
, num_mb
);
2847 test_mb_skcipher_speed("lrw(camellia)", ENCRYPT
, sec
, NULL
, 0,
2848 speed_template_32_48
, num_mb
);
2849 test_mb_skcipher_speed("lrw(camellia)", DECRYPT
, sec
, NULL
, 0,
2850 speed_template_32_48
, num_mb
);
2851 test_mb_skcipher_speed("xts(camellia)", ENCRYPT
, sec
, NULL
, 0,
2852 speed_template_32_64
, num_mb
);
2853 test_mb_skcipher_speed("xts(camellia)", DECRYPT
, sec
, NULL
, 0,
2854 speed_template_32_64
, num_mb
);
2858 test_mb_skcipher_speed("ecb(blowfish)", ENCRYPT
, sec
, NULL
, 0,
2859 speed_template_8_32
, num_mb
);
2860 test_mb_skcipher_speed("ecb(blowfish)", DECRYPT
, sec
, NULL
, 0,
2861 speed_template_8_32
, num_mb
);
2862 test_mb_skcipher_speed("cbc(blowfish)", ENCRYPT
, sec
, NULL
, 0,
2863 speed_template_8_32
, num_mb
);
2864 test_mb_skcipher_speed("cbc(blowfish)", DECRYPT
, sec
, NULL
, 0,
2865 speed_template_8_32
, num_mb
);
2866 test_mb_skcipher_speed("ctr(blowfish)", ENCRYPT
, sec
, NULL
, 0,
2867 speed_template_8_32
, num_mb
);
2868 test_mb_skcipher_speed("ctr(blowfish)", DECRYPT
, sec
, NULL
, 0,
2869 speed_template_8_32
, num_mb
);
2873 test_mb_skcipher_speed("ecb(aria)", ENCRYPT
, sec
, NULL
, 0,
2874 speed_template_16_32
, num_mb
);
2875 test_mb_skcipher_speed("ecb(aria)", DECRYPT
, sec
, NULL
, 0,
2876 speed_template_16_32
, num_mb
);
2877 test_mb_skcipher_speed("ctr(aria)", ENCRYPT
, sec
, NULL
, 0,
2878 speed_template_16_32
, num_mb
);
2879 test_mb_skcipher_speed("ctr(aria)", DECRYPT
, sec
, NULL
, 0,
2880 speed_template_16_32
, num_mb
);
2888 static int __init
tcrypt_mod_init(void)
2893 for (i
= 0; i
< TVMEMSIZE
; i
++) {
2894 tvmem
[i
] = (void *)__get_free_page(GFP_KERNEL
);
2899 err
= do_test(alg
, type
, mask
, mode
, num_mb
);
2902 pr_err("one or more tests failed!\n");
2905 pr_debug("all tests passed\n");
2908 /* We intentionaly return -EAGAIN to prevent keeping the module,
2909 * unless we're running in fips mode. It does all its work from
2910 * init() and doesn't offer any runtime functionality, but in
2911 * the fips case, checking for a successful load is helpful.
2912 * => we don't need it in the memory, do we?
2919 for (i
= 0; i
< TVMEMSIZE
&& tvmem
[i
]; i
++)
2920 free_page((unsigned long)tvmem
[i
]);
2926 * If an init function is provided, an exit function must also be provided
2927 * to allow module unload.
2929 static void __exit
tcrypt_mod_fini(void) { }
2931 late_initcall(tcrypt_mod_init
);
2932 module_exit(tcrypt_mod_fini
);
2934 module_param(alg
, charp
, 0);
2935 module_param(type
, uint
, 0);
2936 module_param(mask
, uint
, 0);
2937 module_param(mode
, int, 0);
2938 module_param(sec
, uint
, 0);
2939 MODULE_PARM_DESC(sec
, "Length in seconds of speed tests "
2940 "(defaults to zero which uses CPU cycles instead)");
2941 module_param(num_mb
, uint
, 0000);
2942 MODULE_PARM_DESC(num_mb
, "Number of concurrent requests to be used in mb speed tests (defaults to 8)");
2943 module_param(klen
, uint
, 0);
2944 MODULE_PARM_DESC(klen
, "Key length (defaults to 0)");
2946 MODULE_LICENSE("GPL");
2947 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
2948 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");