1 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
4 * This package is an SSL implementation written
5 * by Eric Young (eay@cryptsoft.com).
6 * The implementation was written so as to conform with Netscapes SSL.
8 * This library is free for commercial and non-commercial use as long as
9 * the following conditions are aheared to. The following conditions
10 * apply to all code found in this distribution, be it the RC4, RSA,
11 * lhash, DES, etc., code; not just the SSL code. The SSL documentation
12 * included with this distribution is covered by the same copyright terms
13 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15 * Copyright remains Eric Young's, and as such any Copyright notices in
16 * the code are not to be removed.
17 * If this package is used in a product, Eric Young should be given attribution
18 * as the author of the parts of the library used.
19 * This can be in the form of a textual message at program startup or
20 * in documentation (online or textual) provided with the package.
22 * Redistribution and use in source and binary forms, with or without
23 * modification, are permitted provided that the following conditions
25 * 1. Redistributions of source code must retain the copyright
26 * notice, this list of conditions and the following disclaimer.
27 * 2. Redistributions in binary form must reproduce the above copyright
28 * notice, this list of conditions and the following disclaimer in the
29 * documentation and/or other materials provided with the distribution.
30 * 3. All advertising materials mentioning features or use of this software
31 * must display the following acknowledgement:
32 * "This product includes cryptographic software written by
33 * Eric Young (eay@cryptsoft.com)"
34 * The word 'cryptographic' can be left out if the rouines from the library
35 * being used are not cryptographic related :-).
36 * 4. If you include any Windows specific code (or a derivative thereof) from
37 * the apps directory (application code) you must include an acknowledgement:
38 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
41 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
44 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
46 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
52 * The licence and distribution terms for any publically available version or
53 * derivative of this code cannot be changed. i.e. this code cannot simply be
54 * copied and put under another distribution licence
55 * [including the GNU Public Licence.]
57 /* ====================================================================
58 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
60 * Portions of the attached software ("Contribution") are developed by
61 * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
63 * The Contribution is licensed pursuant to the OpenSSL open source
64 * license provided above.
66 * The ECDH and ECDSA speed test software is originally written by
67 * Sumit Gupta of Sun Microsystems Laboratories.
73 #define PRIME_SECONDS 10
74 #define RSA_SECONDS 10
75 #define DSA_SECONDS 10
76 #define ECDSA_SECONDS 10
77 #define ECDH_SECONDS 10
84 #include <openssl/crypto.h>
85 #include <openssl/rand.h>
86 #include <openssl/err.h>
87 #include <openssl/evp.h>
88 #include <openssl/objects.h>
89 #include <openssl/async.h>
90 #if !defined(OPENSSL_SYS_MSDOS)
91 # include OPENSSL_UNISTD
94 #ifndef OPENSSL_SYS_NETWARE
102 #if defined(OPENSSL_SYS_UNIX) && defined(OPENSSL_THREADS)
106 #if !defined(OPENSSL_NO_ASYNC)
107 # if defined(OPENSSL_SYS_UNIX) && defined(OPENSSL_THREADS)
108 # if _POSIX_VERSION >= 200112L
111 # elif defined(_WIN32) || defined(__CYGWIN__)
116 #if !defined(ASYNC_POSIX) && !defined(ASYNC_WIN)
120 #include <openssl/bn.h>
121 #ifndef OPENSSL_NO_DES
122 # include <openssl/des.h>
124 #ifndef OPENSSL_NO_AES
125 # include <openssl/aes.h>
127 #ifndef OPENSSL_NO_CAMELLIA
128 # include <openssl/camellia.h>
130 #ifndef OPENSSL_NO_MD2
131 # include <openssl/md2.h>
133 #ifndef OPENSSL_NO_MDC2
134 # include <openssl/mdc2.h>
136 #ifndef OPENSSL_NO_MD4
137 # include <openssl/md4.h>
139 #ifndef OPENSSL_NO_MD5
140 # include <openssl/md5.h>
142 #include <openssl/hmac.h>
143 #include <openssl/sha.h>
144 #ifndef OPENSSL_NO_RMD160
145 # include <openssl/ripemd.h>
147 #ifndef OPENSSL_NO_WHIRLPOOL
148 # include <openssl/whrlpool.h>
150 #ifndef OPENSSL_NO_RC4
151 # include <openssl/rc4.h>
153 #ifndef OPENSSL_NO_RC5
154 # include <openssl/rc5.h>
156 #ifndef OPENSSL_NO_RC2
157 # include <openssl/rc2.h>
159 #ifndef OPENSSL_NO_IDEA
160 # include <openssl/idea.h>
162 #ifndef OPENSSL_NO_SEED
163 # include <openssl/seed.h>
165 #ifndef OPENSSL_NO_BF
166 # include <openssl/blowfish.h>
168 #ifndef OPENSSL_NO_CAST
169 # include <openssl/cast.h>
171 #ifndef OPENSSL_NO_RSA
172 # include <openssl/rsa.h>
173 # include "./testrsa.h"
175 #include <openssl/x509.h>
176 #ifndef OPENSSL_NO_DSA
177 # include <openssl/dsa.h>
178 # include "./testdsa.h"
180 #ifndef OPENSSL_NO_EC
181 # include <openssl/ec.h>
183 #include <openssl/modes.h>
186 # if defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_OS2) || defined(OPENSSL_SYS_NETWARE)
200 #define BUFSIZE (1024*16+1)
201 #define MAX_MISALIGNMENT 63
210 #define MAX_ECDH_SIZE 256
213 static volatile int run = 0;
216 static int usertime = 1;
218 typedef struct loopargs_st {
219 ASYNC_JOB *inprogress_job;
222 unsigned char *buf_malloc;
223 unsigned char *buf2_malloc;
224 unsigned int *siglen;
225 #ifndef OPENSSL_NO_RSA
226 RSA *rsa_key[RSA_NUM];
228 #ifndef OPENSSL_NO_DSA
229 DSA *dsa_key[DSA_NUM];
231 #ifndef OPENSSL_NO_EC
232 EC_KEY *ecdsa[EC_NUM];
233 EC_KEY *ecdh_a[EC_NUM];
234 EC_KEY *ecdh_b[EC_NUM];
235 unsigned char *secret_a;
236 unsigned char *secret_b;
240 GCM128_CONTEXT *gcm_ctx;
243 #ifndef OPENSSL_NO_MD2
244 static int EVP_Digest_MD2_loop(void *args);
247 #ifndef OPENSSL_NO_MDC2
248 static int EVP_Digest_MDC2_loop(void *args);
250 #ifndef OPENSSL_NO_MD4
251 static int EVP_Digest_MD4_loop(void *args);
253 #ifndef OPENSSL_NO_MD5
254 static int MD5_loop(void *args);
255 static int HMAC_loop(void *args);
257 static int SHA1_loop(void *args);
258 static int SHA256_loop(void *args);
259 static int SHA512_loop(void *args);
260 #ifndef OPENSSL_NO_WHIRLPOOL
261 static int WHIRLPOOL_loop(void *args);
263 #ifndef OPENSSL_NO_RMD160
264 static int EVP_Digest_RMD160_loop(void *args);
266 #ifndef OPENSSL_NO_RC4
267 static int RC4_loop(void *args);
269 #ifndef OPENSSL_NO_DES
270 static int DES_ncbc_encrypt_loop(void *args);
271 static int DES_ede3_cbc_encrypt_loop(void *args);
273 #ifndef OPENSSL_NO_AES
274 static int AES_cbc_128_encrypt_loop(void *args);
275 static int AES_cbc_192_encrypt_loop(void *args);
276 static int AES_ige_128_encrypt_loop(void *args);
277 static int AES_cbc_256_encrypt_loop(void *args);
278 static int AES_ige_192_encrypt_loop(void *args);
279 static int AES_ige_256_encrypt_loop(void *args);
280 static int CRYPTO_gcm128_aad_loop(void *args);
282 static int EVP_Update_loop(void *args);
283 static int EVP_Digest_loop(void *args);
284 #ifndef OPENSSL_NO_RSA
285 static int RSA_sign_loop(void *args);
286 static int RSA_verify_loop(void *args);
288 #ifndef OPENSSL_NO_DSA
289 static int DSA_sign_loop(void *args);
290 static int DSA_verify_loop(void *args);
292 #ifndef OPENSSL_NO_EC
293 static int ECDSA_sign_loop(void *args);
294 static int ECDSA_verify_loop(void *args);
295 static int ECDH_compute_key_loop(void *args);
297 static int run_benchmark(int async_jobs, int (*loop_function)(void *), loopargs_t *loopargs);
299 static double Time_F(int s);
300 static void print_message(const char *s, long num, int length);
301 static void pkey_print_message(const char *str, const char *str2,
302 long num, int bits, int sec);
303 static void print_result(int alg, int run_no, int count, double time_used);
305 static int do_multi(int multi);
308 static const char *names[ALGOR_NUM] = {
309 "md2", "mdc2", "md4", "md5", "hmac(md5)", "sha1", "rmd160", "rc4",
310 "des cbc", "des ede3", "idea cbc", "seed cbc",
311 "rc2 cbc", "rc5-32/12 cbc", "blowfish cbc", "cast cbc",
312 "aes-128 cbc", "aes-192 cbc", "aes-256 cbc",
313 "camellia-128 cbc", "camellia-192 cbc", "camellia-256 cbc",
314 "evp", "sha256", "sha512", "whirlpool",
315 "aes-128 ige", "aes-192 ige", "aes-256 ige", "ghash"
318 static double results[ALGOR_NUM][SIZE_NUM];
319 static int lengths[SIZE_NUM] = {
320 16, 64, 256, 1024, 8 * 1024, 16 * 1024
323 #ifndef OPENSSL_NO_RSA
324 static double rsa_results[RSA_NUM][2];
326 #ifndef OPENSSL_NO_DSA
327 static double dsa_results[DSA_NUM][2];
329 #ifndef OPENSSL_NO_EC
330 static double ecdsa_results[EC_NUM][2];
331 static double ecdh_results[EC_NUM][1];
334 #if defined(OPENSSL_NO_DSA) && !defined(OPENSSL_NO_EC)
335 static const char rnd_seed[] =
336 "string to make the random number generator think it has entropy";
337 static int rnd_fake = 0;
341 # if defined(__STDC__) || defined(sgi) || defined(_AIX)
342 # define SIGRETTYPE void
344 # define SIGRETTYPE int
347 static SIGRETTYPE sig_done(int sig);
348 static SIGRETTYPE sig_done(int sig)
350 signal(SIGALRM, sig_done);
360 # if !defined(SIGALRM)
363 static unsigned int lapse, schlock;
364 static void alarm_win32(unsigned int secs)
369 # define alarm alarm_win32
371 static DWORD WINAPI sleepy(VOID * arg)
379 static double Time_F(int s)
386 thr = CreateThread(NULL, 4096, sleepy, NULL, 0, NULL);
388 DWORD err = GetLastError();
389 BIO_printf(bio_err, "unable to CreateThread (%lu)", err);
393 Sleep(0); /* scheduler spinlock */
394 ret = app_tminterval(s, usertime);
396 ret = app_tminterval(s, usertime);
398 TerminateThread(thr, 0);
406 static double Time_F(int s)
408 double ret = app_tminterval(s, usertime);
415 #ifndef OPENSSL_NO_EC
416 static const int KDF1_SHA1_len = 20;
417 static void *KDF1_SHA1(const void *in, size_t inlen, void *out,
420 if (*outlen < SHA_DIGEST_LENGTH)
422 *outlen = SHA_DIGEST_LENGTH;
423 return SHA1(in, inlen, out);
425 #endif /* OPENSSL_NO_EC */
427 static void multiblock_speed(const EVP_CIPHER *evp_cipher);
429 static int found(const char *name, const OPT_PAIR * pairs, int *result)
431 for (; pairs->name; pairs++)
432 if (strcmp(name, pairs->name) == 0) {
433 *result = pairs->retval;
439 typedef enum OPTION_choice {
440 OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
441 OPT_ELAPSED, OPT_EVP, OPT_DECRYPT, OPT_ENGINE, OPT_MULTI,
442 OPT_MR, OPT_MB, OPT_MISALIGN, OPT_ASYNCJOBS
445 OPTIONS speed_options[] = {
446 {OPT_HELP_STR, 1, '-', "Usage: %s [options] ciphers...\n"},
447 {OPT_HELP_STR, 1, '-', "Valid options are:\n"},
448 {"help", OPT_HELP, '-', "Display this summary"},
449 {"evp", OPT_EVP, 's', "Use specified EVP cipher"},
450 {"decrypt", OPT_DECRYPT, '-',
451 "Time decryption instead of encryption (only EVP)"},
452 {"mr", OPT_MR, '-', "Produce machine readable output"},
454 {"misalign", OPT_MISALIGN, 'n', "Amount to mis-align buffers"},
455 {"elapsed", OPT_ELAPSED, '-',
456 "Measure time in real time instead of CPU user time"},
458 {"multi", OPT_MULTI, 'p', "Run benchmarks in parallel"},
461 {"async_jobs", OPT_ASYNCJOBS, 'p', "Enable async mode and start pnum jobs"},
463 #ifndef OPENSSL_NO_ENGINE
464 {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
479 #define D_CBC_IDEA 10
480 #define D_CBC_SEED 11
484 #define D_CBC_CAST 15
485 #define D_CBC_128_AES 16
486 #define D_CBC_192_AES 17
487 #define D_CBC_256_AES 18
488 #define D_CBC_128_CML 19
489 #define D_CBC_192_CML 20
490 #define D_CBC_256_CML 21
494 #define D_WHIRLPOOL 25
495 #define D_IGE_128_AES 26
496 #define D_IGE_192_AES 27
497 #define D_IGE_256_AES 28
499 static OPT_PAIR doit_choices[] = {
500 #ifndef OPENSSL_NO_MD2
503 #ifndef OPENSSL_NO_MDC2
506 #ifndef OPENSSL_NO_MD4
509 #ifndef OPENSSL_NO_MD5
512 #ifndef OPENSSL_NO_MD5
516 {"sha256", D_SHA256},
517 {"sha512", D_SHA512},
518 #ifndef OPENSSL_NO_WHIRLPOOL
519 {"whirlpool", D_WHIRLPOOL},
521 #ifndef OPENSSL_NO_RMD160
522 {"ripemd", D_RMD160},
523 {"rmd160", D_RMD160},
524 {"ripemd160", D_RMD160},
526 #ifndef OPENSSL_NO_RC4
529 #ifndef OPENSSL_NO_DES
530 {"des-cbc", D_CBC_DES},
531 {"des-ede3", D_EDE3_DES},
533 #ifndef OPENSSL_NO_AES
534 {"aes-128-cbc", D_CBC_128_AES},
535 {"aes-192-cbc", D_CBC_192_AES},
536 {"aes-256-cbc", D_CBC_256_AES},
537 {"aes-128-ige", D_IGE_128_AES},
538 {"aes-192-ige", D_IGE_192_AES},
539 {"aes-256-ige", D_IGE_256_AES},
541 #ifndef OPENSSL_NO_RC2
542 {"rc2-cbc", D_CBC_RC2},
545 #ifndef OPENSSL_NO_RC5
546 {"rc5-cbc", D_CBC_RC5},
549 #ifndef OPENSSL_NO_IDEA
550 {"idea-cbc", D_CBC_IDEA},
551 {"idea", D_CBC_IDEA},
553 #ifndef OPENSSL_NO_SEED
554 {"seed-cbc", D_CBC_SEED},
555 {"seed", D_CBC_SEED},
557 #ifndef OPENSSL_NO_BF
558 {"bf-cbc", D_CBC_BF},
559 {"blowfish", D_CBC_BF},
562 #ifndef OPENSSL_NO_CAST
563 {"cast-cbc", D_CBC_CAST},
564 {"cast", D_CBC_CAST},
565 {"cast5", D_CBC_CAST},
574 static OPT_PAIR dsa_choices[] = {
575 {"dsa512", R_DSA_512},
576 {"dsa1024", R_DSA_1024},
577 {"dsa2048", R_DSA_2048},
587 #define R_RSA_15360 6
588 static OPT_PAIR rsa_choices[] = {
589 {"rsa512", R_RSA_512},
590 {"rsa1024", R_RSA_1024},
591 {"rsa2048", R_RSA_2048},
592 {"rsa3072", R_RSA_3072},
593 {"rsa4096", R_RSA_4096},
594 {"rsa7680", R_RSA_7680},
595 {"rsa15360", R_RSA_15360},
615 #define R_EC_X25519 16
616 #ifndef OPENSSL_NO_EC
617 static OPT_PAIR ecdsa_choices[] = {
618 {"ecdsap160", R_EC_P160},
619 {"ecdsap192", R_EC_P192},
620 {"ecdsap224", R_EC_P224},
621 {"ecdsap256", R_EC_P256},
622 {"ecdsap384", R_EC_P384},
623 {"ecdsap521", R_EC_P521},
624 {"ecdsak163", R_EC_K163},
625 {"ecdsak233", R_EC_K233},
626 {"ecdsak283", R_EC_K283},
627 {"ecdsak409", R_EC_K409},
628 {"ecdsak571", R_EC_K571},
629 {"ecdsab163", R_EC_B163},
630 {"ecdsab233", R_EC_B233},
631 {"ecdsab283", R_EC_B283},
632 {"ecdsab409", R_EC_B409},
633 {"ecdsab571", R_EC_B571},
636 static OPT_PAIR ecdh_choices[] = {
637 {"ecdhp160", R_EC_P160},
638 {"ecdhp192", R_EC_P192},
639 {"ecdhp224", R_EC_P224},
640 {"ecdhp256", R_EC_P256},
641 {"ecdhp384", R_EC_P384},
642 {"ecdhp521", R_EC_P521},
643 {"ecdhk163", R_EC_K163},
644 {"ecdhk233", R_EC_K233},
645 {"ecdhk283", R_EC_K283},
646 {"ecdhk409", R_EC_K409},
647 {"ecdhk571", R_EC_K571},
648 {"ecdhb163", R_EC_B163},
649 {"ecdhb233", R_EC_B233},
650 {"ecdhb283", R_EC_B283},
651 {"ecdhb409", R_EC_B409},
652 {"ecdhb571", R_EC_B571},
653 {"ecdhx25519", R_EC_X25519},
659 # define COND(d) (count < (d))
660 # define COUNT(d) (d)
662 # define COND(c) (run && count<0x7fffffff)
663 # define COUNT(d) (count)
667 static char *engine_id = NULL;
670 #ifndef OPENSSL_NO_MD2
671 static int EVP_Digest_MD2_loop(void *args)
673 loopargs_t *tempargs = (loopargs_t *)args;
674 unsigned char *buf = tempargs->buf;
675 unsigned char md2[MD2_DIGEST_LENGTH];
677 for (count = 0; COND(c[D_MD2][testnum]); count++)
678 EVP_Digest(buf, (unsigned long)lengths[testnum], &(md2[0]), NULL,
684 #ifndef OPENSSL_NO_MDC2
685 static int EVP_Digest_MDC2_loop(void *args)
687 loopargs_t *tempargs = (loopargs_t *)args;
688 unsigned char *buf = tempargs->buf;
689 unsigned char mdc2[MDC2_DIGEST_LENGTH];
691 for (count = 0; COND(c[D_MDC2][testnum]); count++)
692 EVP_Digest(buf, (unsigned long)lengths[testnum], &(mdc2[0]), NULL,
698 #ifndef OPENSSL_NO_MD4
699 static int EVP_Digest_MD4_loop(void *args)
701 loopargs_t *tempargs = (loopargs_t *)args;
702 unsigned char *buf = tempargs->buf;
703 unsigned char md4[MD4_DIGEST_LENGTH];
705 for (count = 0; COND(c[D_MD4][testnum]); count++)
706 EVP_Digest(&(buf[0]), (unsigned long)lengths[testnum], &(md4[0]),
707 NULL, EVP_md4(), NULL);
712 #ifndef OPENSSL_NO_MD5
713 static int MD5_loop(void *args)
715 loopargs_t *tempargs = (loopargs_t *)args;
716 unsigned char *buf = tempargs->buf;
717 unsigned char md5[MD5_DIGEST_LENGTH];
719 for (count = 0; COND(c[D_MD5][testnum]); count++)
720 MD5(buf, lengths[testnum], md5);
724 static int HMAC_loop(void *args)
726 loopargs_t *tempargs = (loopargs_t *)args;
727 unsigned char *buf = tempargs->buf;
728 HMAC_CTX *hctx = tempargs->hctx;
729 unsigned char hmac[MD5_DIGEST_LENGTH];
731 for (count = 0; COND(c[D_HMAC][testnum]); count++) {
732 HMAC_Init_ex(hctx, NULL, 0, NULL, NULL);
733 HMAC_Update(hctx, buf, lengths[testnum]);
734 HMAC_Final(hctx, &(hmac[0]), NULL);
740 static int SHA1_loop(void *args)
742 loopargs_t *tempargs = (loopargs_t *)args;
743 unsigned char *buf = tempargs->buf;
744 unsigned char sha[SHA_DIGEST_LENGTH];
746 for (count = 0; COND(c[D_SHA1][testnum]); count++)
747 SHA1(buf, lengths[testnum], sha);
751 static int SHA256_loop(void *args)
753 loopargs_t *tempargs = (loopargs_t *)args;
754 unsigned char *buf = tempargs->buf;
755 unsigned char sha256[SHA256_DIGEST_LENGTH];
757 for (count = 0; COND(c[D_SHA256][testnum]); count++)
758 SHA256(buf, lengths[testnum], sha256);
762 static int SHA512_loop(void *args)
764 loopargs_t *tempargs = (loopargs_t *)args;
765 unsigned char *buf = tempargs->buf;
766 unsigned char sha512[SHA512_DIGEST_LENGTH];
768 for (count = 0; COND(c[D_SHA512][testnum]); count++)
769 SHA512(buf, lengths[testnum], sha512);
773 #ifndef OPENSSL_NO_WHIRLPOOL
774 static int WHIRLPOOL_loop(void *args)
776 loopargs_t *tempargs = (loopargs_t *)args;
777 unsigned char *buf = tempargs->buf;
778 unsigned char whirlpool[WHIRLPOOL_DIGEST_LENGTH];
780 for (count = 0; COND(c[D_WHIRLPOOL][testnum]); count++)
781 WHIRLPOOL(buf, lengths[testnum], whirlpool);
786 #ifndef OPENSSL_NO_RMD160
787 static int EVP_Digest_RMD160_loop(void *args)
789 loopargs_t *tempargs = (loopargs_t *)args;
790 unsigned char *buf = tempargs->buf;
791 unsigned char rmd160[RIPEMD160_DIGEST_LENGTH];
793 for (count = 0; COND(c[D_RMD160][testnum]); count++)
794 EVP_Digest(buf, (unsigned long)lengths[testnum], &(rmd160[0]), NULL,
795 EVP_ripemd160(), NULL);
800 #ifndef OPENSSL_NO_RC4
801 static RC4_KEY rc4_ks;
802 static int RC4_loop(void *args)
804 loopargs_t *tempargs = (loopargs_t *)args;
805 unsigned char *buf = tempargs->buf;
807 for (count = 0; COND(c[D_RC4][testnum]); count++)
808 RC4(&rc4_ks, (unsigned int)lengths[testnum], buf, buf);
813 #ifndef OPENSSL_NO_DES
814 static unsigned char DES_iv[8];
815 static DES_key_schedule sch;
816 static DES_key_schedule sch2;
817 static DES_key_schedule sch3;
818 static int DES_ncbc_encrypt_loop(void *args)
820 loopargs_t *tempargs = (loopargs_t *)args;
821 unsigned char *buf = tempargs->buf;
823 for (count = 0; COND(c[D_CBC_DES][testnum]); count++)
824 DES_ncbc_encrypt(buf, buf, lengths[testnum], &sch,
825 &DES_iv, DES_ENCRYPT);
829 static int DES_ede3_cbc_encrypt_loop(void *args)
831 loopargs_t *tempargs = (loopargs_t *)args;
832 unsigned char *buf = tempargs->buf;
834 for (count = 0; COND(c[D_EDE3_DES][testnum]); count++)
835 DES_ede3_cbc_encrypt(buf, buf, lengths[testnum],
837 &DES_iv, DES_ENCRYPT);
842 #ifndef OPENSSL_NO_AES
843 # define MAX_BLOCK_SIZE 128
845 # define MAX_BLOCK_SIZE 64
848 static unsigned char iv[2 * MAX_BLOCK_SIZE / 8];
849 #ifndef OPENSSL_NO_AES
850 static AES_KEY aes_ks1, aes_ks2, aes_ks3;
851 static int AES_cbc_128_encrypt_loop(void *args)
853 loopargs_t *tempargs = (loopargs_t *)args;
854 unsigned char *buf = tempargs->buf;
856 for (count = 0; COND(c[D_CBC_128_AES][testnum]); count++)
857 AES_cbc_encrypt(buf, buf,
858 (unsigned long)lengths[testnum], &aes_ks1,
863 static int AES_cbc_192_encrypt_loop(void *args)
865 loopargs_t *tempargs = (loopargs_t *)args;
866 unsigned char *buf = tempargs->buf;
868 for (count = 0; COND(c[D_CBC_192_AES][testnum]); count++)
869 AES_cbc_encrypt(buf, buf,
870 (unsigned long)lengths[testnum], &aes_ks2,
875 static int AES_cbc_256_encrypt_loop(void *args)
877 loopargs_t *tempargs = (loopargs_t *)args;
878 unsigned char *buf = tempargs->buf;
880 for (count = 0; COND(c[D_CBC_256_AES][testnum]); count++)
881 AES_cbc_encrypt(buf, buf,
882 (unsigned long)lengths[testnum], &aes_ks3,
887 static int AES_ige_128_encrypt_loop(void *args)
889 loopargs_t *tempargs = (loopargs_t *)args;
890 unsigned char *buf = tempargs->buf;
891 unsigned char *buf2 = tempargs->buf2;
893 for (count = 0; COND(c[D_IGE_128_AES][testnum]); count++)
894 AES_ige_encrypt(buf, buf2,
895 (unsigned long)lengths[testnum], &aes_ks1,
900 static int AES_ige_192_encrypt_loop(void *args)
902 loopargs_t *tempargs = (loopargs_t *)args;
903 unsigned char *buf = tempargs->buf;
904 unsigned char *buf2 = tempargs->buf2;
906 for (count = 0; COND(c[D_IGE_192_AES][testnum]); count++)
907 AES_ige_encrypt(buf, buf2,
908 (unsigned long)lengths[testnum], &aes_ks2,
913 static int AES_ige_256_encrypt_loop(void *args)
915 loopargs_t *tempargs = (loopargs_t *)args;
916 unsigned char *buf = tempargs->buf;
917 unsigned char *buf2 = tempargs->buf2;
919 for (count = 0; COND(c[D_IGE_256_AES][testnum]); count++)
920 AES_ige_encrypt(buf, buf2,
921 (unsigned long)lengths[testnum], &aes_ks3,
926 static int CRYPTO_gcm128_aad_loop(void *args)
928 loopargs_t *tempargs = (loopargs_t *)args;
929 unsigned char *buf = tempargs->buf;
930 GCM128_CONTEXT *gcm_ctx = tempargs->gcm_ctx;
932 for (count = 0; COND(c[D_GHASH][testnum]); count++)
933 CRYPTO_gcm128_aad(gcm_ctx, buf, lengths[testnum]);
939 static int decrypt = 0;
940 static int EVP_Update_loop(void *args)
942 loopargs_t *tempargs = (loopargs_t *)args;
943 unsigned char *buf = tempargs->buf;
944 EVP_CIPHER_CTX *ctx = tempargs->ctx;
948 COND(save_count * 4 * lengths[0] / lengths[testnum]);
950 EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
953 COND(save_count * 4 * lengths[0] / lengths[testnum]);
955 EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
957 EVP_DecryptFinal_ex(ctx, buf, &outl);
959 EVP_EncryptFinal_ex(ctx, buf, &outl);
963 static const EVP_MD *evp_md = NULL;
964 static int EVP_Digest_loop(void *args)
966 loopargs_t *tempargs = (loopargs_t *)args;
967 unsigned char *buf = tempargs->buf;
968 unsigned char md[EVP_MAX_MD_SIZE];
971 COND(save_count * 4 * lengths[0] / lengths[testnum]); count++)
972 EVP_Digest(buf, lengths[testnum], &(md[0]), NULL, evp_md, NULL);
977 #ifndef OPENSSL_NO_RSA
978 static long rsa_c[RSA_NUM][2];
980 static int RSA_sign_loop(void *args)
982 loopargs_t *tempargs = (loopargs_t *)args;
983 unsigned char *buf = tempargs->buf;
984 unsigned char *buf2 = tempargs->buf2;
985 unsigned int *rsa_num = tempargs->siglen;
986 RSA **rsa_key = tempargs->rsa_key;
988 for (count = 0; COND(rsa_c[testnum][0]); count++) {
989 ret = RSA_sign(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
991 BIO_printf(bio_err, "RSA sign failure\n");
992 ERR_print_errors(bio_err);
1000 static int RSA_verify_loop(void *args)
1002 loopargs_t *tempargs = (loopargs_t *)args;
1003 unsigned char *buf = tempargs->buf;
1004 unsigned char *buf2 = tempargs->buf2;
1005 unsigned int rsa_num = *(tempargs->siglen);
1006 RSA **rsa_key = tempargs->rsa_key;
1008 for (count = 0; COND(rsa_c[testnum][1]); count++) {
1009 ret = RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
1011 BIO_printf(bio_err, "RSA verify failure\n");
1012 ERR_print_errors(bio_err);
1021 #ifndef OPENSSL_NO_DSA
1022 static long dsa_c[DSA_NUM][2];
1023 static int DSA_sign_loop(void *args)
1025 loopargs_t *tempargs = (loopargs_t *)args;
1026 unsigned char *buf = tempargs->buf;
1027 unsigned char *buf2 = tempargs->buf2;
1028 DSA **dsa_key = tempargs->dsa_key;
1029 unsigned int *siglen = tempargs->siglen;
1031 for (count = 0; COND(dsa_c[testnum][0]); count++) {
1032 ret = DSA_sign(0, buf, 20, buf2, siglen, dsa_key[testnum]);
1034 BIO_printf(bio_err, "DSA sign failure\n");
1035 ERR_print_errors(bio_err);
1043 static int DSA_verify_loop(void *args)
1045 loopargs_t *tempargs = (loopargs_t *)args;
1046 unsigned char *buf = tempargs->buf;
1047 unsigned char *buf2 = tempargs->buf2;
1048 DSA **dsa_key = tempargs->dsa_key;
1049 unsigned int siglen = *(tempargs->siglen);
1051 for (count = 0; COND(dsa_c[testnum][1]); count++) {
1052 ret = DSA_verify(0, buf, 20, buf2, siglen, dsa_key[testnum]);
1054 BIO_printf(bio_err, "DSA verify failure\n");
1055 ERR_print_errors(bio_err);
1064 #ifndef OPENSSL_NO_EC
1065 static long ecdsa_c[EC_NUM][2];
1066 static int ECDSA_sign_loop(void *args)
1068 loopargs_t *tempargs = (loopargs_t *)args;
1069 unsigned char *buf = tempargs->buf;
1070 EC_KEY **ecdsa = tempargs->ecdsa;
1071 unsigned char *ecdsasig = tempargs->buf2;
1072 unsigned int *ecdsasiglen = tempargs->siglen;
1074 for (count = 0; COND(ecdsa_c[testnum][0]); count++) {
1075 ret = ECDSA_sign(0, buf, 20,
1076 ecdsasig, ecdsasiglen, ecdsa[testnum]);
1078 BIO_printf(bio_err, "ECDSA sign failure\n");
1079 ERR_print_errors(bio_err);
1087 static int ECDSA_verify_loop(void *args)
1089 loopargs_t *tempargs = (loopargs_t *)args;
1090 unsigned char *buf = tempargs->buf;
1091 EC_KEY **ecdsa = tempargs->ecdsa;
1092 unsigned char *ecdsasig = tempargs->buf2;
1093 unsigned int ecdsasiglen = *(tempargs->siglen);
1095 for (count = 0; COND(ecdsa_c[testnum][1]); count++) {
1096 ret = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen,
1099 BIO_printf(bio_err, "ECDSA verify failure\n");
1100 ERR_print_errors(bio_err);
1109 static void *(*kdf) (const void *in, size_t inlen, void *out,
1112 static int ECDH_compute_key_loop(void *args)
1114 loopargs_t *tempargs = (loopargs_t *)args;
1115 EC_KEY **ecdh_a = tempargs->ecdh_a;
1116 EC_KEY **ecdh_b = tempargs->ecdh_b;
1117 unsigned char *secret_a = tempargs->secret_a;
1119 for (count = 0; COND(ecdh_c[testnum][0]); count++) {
1120 ECDH_compute_key(secret_a, outlen,
1121 EC_KEY_get0_public_key(ecdh_b[testnum]),
1122 ecdh_a[testnum], kdf);
1129 static int run_benchmark(int async_jobs, int (*loop_function)(void *), loopargs_t *loopargs)
1131 int job_op_count = 0;
1132 int total_op_count = 0;
1133 int num_inprogress = 0;
1139 if (async_jobs == 0) {
1140 return loop_function((void *)loopargs);
1143 for (i = 0; i < async_jobs && !error; i++) {
1144 switch (ASYNC_start_job(&(loopargs[i].inprogress_job), &job_op_count,
1145 loop_function, (void *)(loopargs + i), sizeof(loopargs_t))) {
1150 if (job_op_count == -1) {
1153 total_op_count += job_op_count;
1158 BIO_printf(bio_err, "Failure in the job\n");
1159 ERR_print_errors(bio_err);
1165 while (num_inprogress > 0) {
1166 OSSL_ASYNC_FD job_fd = 0;
1167 #if defined(ASYNC_POSIX)
1168 OSSL_ASYNC_FD max_fd = 0;
1169 int select_result = 0;
1171 struct timeval select_timeout;
1172 FD_ZERO(&waitfdset);
1173 select_timeout.tv_sec=0;
1174 select_timeout.tv_usec=0;
1176 for (i = 0; i < async_jobs; i++) {
1177 if (loopargs[i].inprogress_job != NULL) {
1178 job_fd = ASYNC_get_wait_fd(loopargs[i].inprogress_job);
1179 FD_SET(job_fd, &waitfdset);
1180 if (job_fd > max_fd)
1184 select_result = select(max_fd + 1, &waitfdset, NULL, NULL, &select_timeout);
1186 if (select_result == -1 && errno == EINTR)
1189 if (select_result == -1) {
1190 BIO_printf(bio_err, "Failure in the select\n");
1191 ERR_print_errors(bio_err);
1196 if (select_result == 0)
1199 #elif defined(ASYNC_WIN)
1203 for (i = 0; i < async_jobs; i++) {
1204 if (loopargs[i].inprogress_job == NULL)
1207 job_fd = ASYNC_get_wait_fd(loopargs[i].inprogress_job);
1209 #if defined(ASYNC_POSIX)
1210 if (!FD_ISSET(job_fd, &waitfdset))
1212 #elif defined(ASYNC_WIN)
1213 if (!PeekNamedPipe(job_fd, NULL, 0, NULL, &avail, NULL) && avail > 0)
1217 switch (ASYNC_start_job(&(loopargs[i].inprogress_job),
1218 &job_op_count, loop_function, (void *)(loopargs + i),
1219 sizeof(loopargs_t))) {
1223 if (job_op_count == -1) {
1226 total_op_count += job_op_count;
1229 loopargs[i].inprogress_job = NULL;
1234 loopargs[i].inprogress_job = NULL;
1235 BIO_printf(bio_err, "Failure in the job\n");
1236 ERR_print_errors(bio_err);
1243 return error ? -1 : total_op_count;
1246 int speed_main(int argc, char **argv)
1248 loopargs_t *loopargs = NULL;
1249 int loopargs_len = 0;
1251 const EVP_CIPHER *evp_cipher = NULL;
1254 int multiblock = 0, doit[ALGOR_NUM], pr_header = 0;
1255 int dsa_doit[DSA_NUM], rsa_doit[RSA_NUM];
1256 int ret = 1, i, k, misalign = 0;
1257 long c[ALGOR_NUM][SIZE_NUM], count = 0, save_count = 0;
1262 /* What follows are the buffers and key material. */
1263 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA)
1266 #ifndef OPENSSL_NO_RC5
1269 #ifndef OPENSSL_NO_RC2
1272 #ifndef OPENSSL_NO_IDEA
1273 IDEA_KEY_SCHEDULE idea_ks;
1275 #ifndef OPENSSL_NO_SEED
1276 SEED_KEY_SCHEDULE seed_ks;
1278 #ifndef OPENSSL_NO_BF
1281 #ifndef OPENSSL_NO_CAST
1284 static const unsigned char key16[16] = {
1285 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1286 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1288 #ifndef OPENSSL_NO_AES
1289 static const unsigned char key24[24] = {
1290 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1291 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1292 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1294 static const unsigned char key32[32] = {
1295 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1296 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1297 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1298 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1301 #ifndef OPENSSL_NO_CAMELLIA
1302 static const unsigned char ckey24[24] = {
1303 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1304 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1305 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1307 static const unsigned char ckey32[32] = {
1308 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1309 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1310 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1311 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1313 CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
1315 #ifndef OPENSSL_NO_DES
1316 static DES_cblock key = {
1317 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
1319 static DES_cblock key2 = {
1320 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1322 static DES_cblock key3 = {
1323 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1326 #ifndef OPENSSL_NO_RSA
1327 static unsigned int rsa_bits[RSA_NUM] = {
1328 512, 1024, 2048, 3072, 4096, 7680, 15360
1330 static unsigned char *rsa_data[RSA_NUM] = {
1331 test512, test1024, test2048, test3072, test4096, test7680, test15360
1333 static int rsa_data_length[RSA_NUM] = {
1334 sizeof(test512), sizeof(test1024),
1335 sizeof(test2048), sizeof(test3072),
1336 sizeof(test4096), sizeof(test7680),
1340 #ifndef OPENSSL_NO_DSA
1341 static unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
1343 #ifndef OPENSSL_NO_EC
1345 * We only test over the following curves as they are representative, To
1346 * add tests over more curves, simply add the curve NID and curve name to
1347 * the following arrays and increase the EC_NUM value accordingly.
1349 static unsigned int test_curves[EC_NUM] = {
1351 NID_secp160r1, NID_X9_62_prime192v1, NID_secp224r1,
1352 NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
1354 NID_sect163k1, NID_sect233k1, NID_sect283k1,
1355 NID_sect409k1, NID_sect571k1, NID_sect163r2,
1356 NID_sect233r1, NID_sect283r1, NID_sect409r1,
1361 static const char *test_curves_names[EC_NUM] = {
1363 "secp160r1", "nistp192", "nistp224",
1364 "nistp256", "nistp384", "nistp521",
1366 "nistk163", "nistk233", "nistk283",
1367 "nistk409", "nistk571", "nistb163",
1368 "nistb233", "nistb283", "nistb409",
1373 static int test_curves_bits[EC_NUM] = {
1379 571, 253 /* X25519 */
1382 #ifndef OPENSSL_NO_EC
1383 int ecdsa_doit[EC_NUM];
1384 int secret_size_a, secret_size_b;
1385 int ecdh_checks = 1;
1387 long ecdh_c[EC_NUM][2];
1388 int ecdh_doit[EC_NUM];
1391 memset(results, 0, sizeof(results));
1393 memset(c, 0, sizeof(c));
1394 memset(DES_iv, 0, sizeof(DES_iv));
1395 memset(iv, 0, sizeof(iv));
1397 for (i = 0; i < ALGOR_NUM; i++)
1399 for (i = 0; i < RSA_NUM; i++)
1401 for (i = 0; i < DSA_NUM; i++)
1403 #ifndef OPENSSL_NO_EC
1404 for (i = 0; i < EC_NUM; i++)
1406 for (i = 0; i < EC_NUM; i++)
1412 prog = opt_init(argc, argv, speed_options);
1413 while ((o = opt_next()) != OPT_EOF) {
1418 BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
1421 opt_help(speed_options);
1428 evp_cipher = EVP_get_cipherbyname(opt_arg());
1429 if (evp_cipher == NULL)
1430 evp_md = EVP_get_digestbyname(opt_arg());
1431 if (evp_cipher == NULL && evp_md == NULL) {
1433 "%s: %s an unknown cipher or digest\n",
1444 * In a forked execution, an engine might need to be
1445 * initialised by each child process, not by the parent.
1446 * So store the name here and run setup_engine() later on.
1448 engine_id = opt_arg();
1452 multi = atoi(opt_arg());
1457 async_jobs = atoi(opt_arg());
1461 if (!opt_int(opt_arg(), &misalign))
1463 if (misalign > MISALIGN) {
1465 "%s: Maximum offset is %d\n", prog, MISALIGN);
1477 argc = opt_num_rest();
1480 /* Remaining arguments are algorithms. */
1481 for ( ; *argv; argv++) {
1482 if (found(*argv, doit_choices, &i)) {
1486 #ifndef OPENSSL_NO_DES
1487 if (strcmp(*argv, "des") == 0) {
1488 doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
1492 if (strcmp(*argv, "sha") == 0) {
1493 doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
1496 #ifndef OPENSSL_NO_RSA
1498 if (strcmp(*argv, "openssl") == 0) {
1499 RSA_set_default_method(RSA_PKCS1_OpenSSL());
1503 if (strcmp(*argv, "rsa") == 0) {
1504 rsa_doit[R_RSA_512] = rsa_doit[R_RSA_1024] =
1505 rsa_doit[R_RSA_2048] = rsa_doit[R_RSA_3072] =
1506 rsa_doit[R_RSA_4096] = rsa_doit[R_RSA_7680] =
1507 rsa_doit[R_RSA_15360] = 1;
1510 if (found(*argv, rsa_choices, &i)) {
1515 #ifndef OPENSSL_NO_DSA
1516 if (strcmp(*argv, "dsa") == 0) {
1517 dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
1518 dsa_doit[R_DSA_2048] = 1;
1521 if (found(*argv, dsa_choices, &i)) {
1526 #ifndef OPENSSL_NO_AES
1527 if (strcmp(*argv, "aes") == 0) {
1528 doit[D_CBC_128_AES] = doit[D_CBC_192_AES] =
1529 doit[D_CBC_256_AES] = 1;
1533 #ifndef OPENSSL_NO_CAMELLIA
1534 if (strcmp(*argv, "camellia") == 0) {
1535 doit[D_CBC_128_CML] = doit[D_CBC_192_CML] =
1536 doit[D_CBC_256_CML] = 1;
1540 #ifndef OPENSSL_NO_EC
1541 if (strcmp(*argv, "ecdsa") == 0) {
1542 for (i = 0; i < EC_NUM; i++)
1546 if (found(*argv, ecdsa_choices, &i)) {
1550 if (strcmp(*argv, "ecdh") == 0) {
1551 for (i = 0; i < EC_NUM; i++)
1555 if (found(*argv, ecdh_choices, &i)) {
1560 BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
1564 /* Initialize the job pool if async mode is enabled */
1565 if (async_jobs > 0) {
1566 if (!ASYNC_init_thread(async_jobs, async_jobs)) {
1567 BIO_printf(bio_err, "Error creating the ASYNC job pool\n");
1572 loopargs_len = (async_jobs == 0 ? 1 : async_jobs);
1573 loopargs = app_malloc(loopargs_len * sizeof(loopargs_t), "array of loopargs");
1574 memset(loopargs, 0, loopargs_len * sizeof(loopargs_t));
1576 for (i = 0; i < loopargs_len; i++) {
1577 loopargs[i].buf_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1578 loopargs[i].buf2_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1579 /* Align the start of buffers on a 64 byte boundary */
1580 loopargs[i].buf = loopargs[i].buf_malloc + misalign;
1581 loopargs[i].buf2 = loopargs[i].buf2_malloc + misalign;
1582 loopargs[i].siglen = app_malloc(sizeof(unsigned int), "signature length");
1583 #ifndef OPENSSL_NO_EC
1584 loopargs[i].secret_a = app_malloc(MAX_ECDH_SIZE, "ECDH secret a");
1585 loopargs[i].secret_b = app_malloc(MAX_ECDH_SIZE, "ECDH secret b");
1590 if (multi && do_multi(multi))
1594 /* Initialize the engine after the fork */
1595 (void)setup_engine(engine_id, 0);
1597 /* No parameters; turn on everything. */
1598 if ((argc == 0) && !doit[D_EVP]) {
1599 for (i = 0; i < ALGOR_NUM; i++)
1602 for (i = 0; i < RSA_NUM; i++)
1604 for (i = 0; i < DSA_NUM; i++)
1606 #ifndef OPENSSL_NO_EC
1607 for (i = 0; i < EC_NUM; i++)
1609 for (i = 0; i < EC_NUM; i++)
1613 for (i = 0; i < ALGOR_NUM; i++)
1617 if (usertime == 0 && !mr)
1619 "You have chosen to measure elapsed time "
1620 "instead of user CPU time.\n");
1622 #ifndef OPENSSL_NO_RSA
1623 for (i = 0; i < loopargs_len; i++) {
1624 for (k = 0; k < RSA_NUM; k++) {
1625 const unsigned char *p;
1628 loopargs[i].rsa_key[k] = d2i_RSAPrivateKey(NULL, &p, rsa_data_length[k]);
1629 if (loopargs[i].rsa_key[k] == NULL) {
1630 BIO_printf(bio_err, "internal error loading RSA key number %d\n",
1637 #ifndef OPENSSL_NO_DSA
1638 for (i = 0; i < loopargs_len; i++) {
1639 loopargs[i].dsa_key[0] = get_dsa512();
1640 loopargs[i].dsa_key[1] = get_dsa1024();
1641 loopargs[i].dsa_key[2] = get_dsa2048();
1644 #ifndef OPENSSL_NO_DES
1645 DES_set_key_unchecked(&key, &sch);
1646 DES_set_key_unchecked(&key2, &sch2);
1647 DES_set_key_unchecked(&key3, &sch3);
1649 #ifndef OPENSSL_NO_AES
1650 AES_set_encrypt_key(key16, 128, &aes_ks1);
1651 AES_set_encrypt_key(key24, 192, &aes_ks2);
1652 AES_set_encrypt_key(key32, 256, &aes_ks3);
1654 #ifndef OPENSSL_NO_CAMELLIA
1655 Camellia_set_key(key16, 128, &camellia_ks1);
1656 Camellia_set_key(ckey24, 192, &camellia_ks2);
1657 Camellia_set_key(ckey32, 256, &camellia_ks3);
1659 #ifndef OPENSSL_NO_IDEA
1660 idea_set_encrypt_key(key16, &idea_ks);
1662 #ifndef OPENSSL_NO_SEED
1663 SEED_set_key(key16, &seed_ks);
1665 #ifndef OPENSSL_NO_RC4
1666 RC4_set_key(&rc4_ks, 16, key16);
1668 #ifndef OPENSSL_NO_RC2
1669 RC2_set_key(&rc2_ks, 16, key16, 128);
1671 #ifndef OPENSSL_NO_RC5
1672 RC5_32_set_key(&rc5_ks, 16, key16, 12);
1674 #ifndef OPENSSL_NO_BF
1675 BF_set_key(&bf_ks, 16, key16);
1677 #ifndef OPENSSL_NO_CAST
1678 CAST_set_key(&cast_ks, 16, key16);
1680 #ifndef OPENSSL_NO_RSA
1681 memset(rsa_c, 0, sizeof(rsa_c));
1684 # ifndef OPENSSL_NO_DES
1685 BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1691 for (it = count; it; it--)
1692 DES_ecb_encrypt((DES_cblock *)loopargs[0].buf,
1693 (DES_cblock *)loopargs[0].buf, &sch, DES_ENCRYPT);
1697 c[D_MD2][0] = count / 10;
1698 c[D_MDC2][0] = count / 10;
1699 c[D_MD4][0] = count;
1700 c[D_MD5][0] = count;
1701 c[D_HMAC][0] = count;
1702 c[D_SHA1][0] = count;
1703 c[D_RMD160][0] = count;
1704 c[D_RC4][0] = count * 5;
1705 c[D_CBC_DES][0] = count;
1706 c[D_EDE3_DES][0] = count / 3;
1707 c[D_CBC_IDEA][0] = count;
1708 c[D_CBC_SEED][0] = count;
1709 c[D_CBC_RC2][0] = count;
1710 c[D_CBC_RC5][0] = count;
1711 c[D_CBC_BF][0] = count;
1712 c[D_CBC_CAST][0] = count;
1713 c[D_CBC_128_AES][0] = count;
1714 c[D_CBC_192_AES][0] = count;
1715 c[D_CBC_256_AES][0] = count;
1716 c[D_CBC_128_CML][0] = count;
1717 c[D_CBC_192_CML][0] = count;
1718 c[D_CBC_256_CML][0] = count;
1719 c[D_SHA256][0] = count;
1720 c[D_SHA512][0] = count;
1721 c[D_WHIRLPOOL][0] = count;
1722 c[D_IGE_128_AES][0] = count;
1723 c[D_IGE_192_AES][0] = count;
1724 c[D_IGE_256_AES][0] = count;
1725 c[D_GHASH][0] = count;
1727 for (i = 1; i < SIZE_NUM; i++) {
1730 l0 = (long)lengths[0];
1731 l1 = (long)lengths[i];
1733 c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1734 c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1735 c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1736 c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1737 c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1738 c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1739 c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1740 c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1741 c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1742 c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1743 c[D_GHASH][i] = c[D_GHASH][0] * 4 * l0 / l1;
1745 l0 = (long)lengths[i - 1];
1747 c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1748 c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1749 c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1750 c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1751 c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1752 c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1753 c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1754 c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1755 c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1756 c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1757 c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1758 c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1759 c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1760 c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1761 c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1762 c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1763 c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1764 c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1767 # ifndef OPENSSL_NO_RSA
1768 rsa_c[R_RSA_512][0] = count / 2000;
1769 rsa_c[R_RSA_512][1] = count / 400;
1770 for (i = 1; i < RSA_NUM; i++) {
1771 rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1772 rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1773 if ((rsa_doit[i] <= 1) && (rsa_c[i][0] == 0))
1776 if (rsa_c[i][0] == 0) {
1784 # ifndef OPENSSL_NO_DSA
1785 dsa_c[R_DSA_512][0] = count / 1000;
1786 dsa_c[R_DSA_512][1] = count / 1000 / 2;
1787 for (i = 1; i < DSA_NUM; i++) {
1788 dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1789 dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1790 if ((dsa_doit[i] <= 1) && (dsa_c[i][0] == 0))
1793 if (dsa_c[i] == 0) {
1801 # ifndef OPENSSL_NO_EC
1802 ecdsa_c[R_EC_P160][0] = count / 1000;
1803 ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1804 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1805 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1806 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1807 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1810 if (ecdsa_c[i] == 0) {
1816 ecdsa_c[R_EC_K163][0] = count / 1000;
1817 ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1818 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1819 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1820 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1821 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1824 if (ecdsa_c[i] == 0) {
1830 ecdsa_c[R_EC_B163][0] = count / 1000;
1831 ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1832 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1833 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1834 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1835 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1838 if (ecdsa_c[i] == 0) {
1845 ecdh_c[R_EC_P160][0] = count / 1000;
1846 ecdh_c[R_EC_P160][1] = count / 1000;
1847 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1848 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1849 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1850 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1853 if (ecdh_c[i] == 0) {
1859 ecdh_c[R_EC_K163][0] = count / 1000;
1860 ecdh_c[R_EC_K163][1] = count / 1000;
1861 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1862 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1863 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1864 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1867 if (ecdh_c[i] == 0) {
1873 ecdh_c[R_EC_B163][0] = count / 1000;
1874 ecdh_c[R_EC_B163][1] = count / 1000;
1875 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1876 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1877 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1878 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1881 if (ecdh_c[i] == 0) {
1890 /* not worth fixing */
1891 # error "You cannot disable DES on systems without SIGALRM."
1892 # endif /* OPENSSL_NO_DES */
1895 signal(SIGALRM, sig_done);
1897 #endif /* SIGALRM */
1899 #ifndef OPENSSL_NO_MD2
1901 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1902 print_message(names[D_MD2], c[D_MD2][testnum], lengths[testnum]);
1904 count = run_benchmark(async_jobs, EVP_Digest_MD2_loop, loopargs);
1906 print_result(D_MD2, testnum, count, d);
1910 #ifndef OPENSSL_NO_MDC2
1912 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1913 print_message(names[D_MDC2], c[D_MDC2][testnum], lengths[testnum]);
1915 count = run_benchmark(async_jobs, EVP_Digest_MDC2_loop, loopargs);
1917 print_result(D_MDC2, testnum, count, d);
1922 #ifndef OPENSSL_NO_MD4
1924 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1925 print_message(names[D_MD4], c[D_MD4][testnum], lengths[testnum]);
1927 count = run_benchmark(async_jobs, EVP_Digest_MD4_loop, loopargs);
1929 print_result(D_MD4, testnum, count, d);
1934 #ifndef OPENSSL_NO_MD5
1936 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1937 print_message(names[D_MD5], c[D_MD5][testnum], lengths[testnum]);
1939 count = run_benchmark(async_jobs, MD5_loop, loopargs);
1941 print_result(D_MD5, testnum, count, d);
1946 #ifndef OPENSSL_NO_MD5
1948 for (i = 0; i < loopargs_len; i++) {
1949 loopargs[i].hctx = HMAC_CTX_new();
1950 if (loopargs[i].hctx == NULL) {
1951 BIO_printf(bio_err, "HMAC malloc failure, exiting...");
1955 HMAC_Init_ex(loopargs[i].hctx, (unsigned char *)"This is a key...",
1956 16, EVP_md5(), NULL);
1958 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1959 print_message(names[D_HMAC], c[D_HMAC][testnum], lengths[testnum]);
1961 count = run_benchmark(async_jobs, HMAC_loop, loopargs);
1963 print_result(D_HMAC, testnum, count, d);
1965 for (i = 0; i < loopargs_len; i++) {
1966 HMAC_CTX_free(loopargs[i].hctx);
1971 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1972 print_message(names[D_SHA1], c[D_SHA1][testnum], lengths[testnum]);
1974 count = run_benchmark(async_jobs, SHA1_loop, loopargs);
1976 print_result(D_SHA1, testnum, count, d);
1979 if (doit[D_SHA256]) {
1980 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1981 print_message(names[D_SHA256], c[D_SHA256][testnum], lengths[testnum]);
1983 count = run_benchmark(async_jobs, SHA256_loop, loopargs);
1985 print_result(D_SHA256, testnum, count, d);
1988 if (doit[D_SHA512]) {
1989 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1990 print_message(names[D_SHA512], c[D_SHA512][testnum], lengths[testnum]);
1992 count = run_benchmark(async_jobs, SHA512_loop, loopargs);
1994 print_result(D_SHA512, testnum, count, d);
1998 #ifndef OPENSSL_NO_WHIRLPOOL
1999 if (doit[D_WHIRLPOOL]) {
2000 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2001 print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][testnum], lengths[testnum]);
2003 count = run_benchmark(async_jobs, WHIRLPOOL_loop, loopargs);
2005 print_result(D_WHIRLPOOL, testnum, count, d);
2010 #ifndef OPENSSL_NO_RMD160
2011 if (doit[D_RMD160]) {
2012 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2013 print_message(names[D_RMD160], c[D_RMD160][testnum], lengths[testnum]);
2015 count = run_benchmark(async_jobs, EVP_Digest_RMD160_loop, loopargs);
2017 print_result(D_RMD160, testnum, count, d);
2021 #ifndef OPENSSL_NO_RC4
2023 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2024 print_message(names[D_RC4], c[D_RC4][testnum], lengths[testnum]);
2026 count = run_benchmark(async_jobs, RC4_loop, loopargs);
2028 print_result(D_RC4, testnum, count, d);
2032 #ifndef OPENSSL_NO_DES
2033 if (doit[D_CBC_DES]) {
2034 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2035 print_message(names[D_CBC_DES], c[D_CBC_DES][testnum], lengths[testnum]);
2037 count = run_benchmark(async_jobs, DES_ncbc_encrypt_loop, loopargs);
2039 print_result(D_CBC_DES, testnum, count, d);
2043 if (doit[D_EDE3_DES]) {
2044 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2045 print_message(names[D_EDE3_DES], c[D_EDE3_DES][testnum], lengths[testnum]);
2047 count = run_benchmark(async_jobs, DES_ede3_cbc_encrypt_loop, loopargs);
2049 print_result(D_EDE3_DES, testnum, count, d);
2053 #ifndef OPENSSL_NO_AES
2054 if (doit[D_CBC_128_AES]) {
2055 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2056 print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][testnum],
2059 count = run_benchmark(async_jobs, AES_cbc_128_encrypt_loop, loopargs);
2061 print_result(D_CBC_128_AES, testnum, count, d);
2064 if (doit[D_CBC_192_AES]) {
2065 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2066 print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][testnum],
2069 count = run_benchmark(async_jobs, AES_cbc_192_encrypt_loop, loopargs);
2071 print_result(D_CBC_192_AES, testnum, count, d);
2074 if (doit[D_CBC_256_AES]) {
2075 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2076 print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][testnum],
2079 count = run_benchmark(async_jobs, AES_cbc_256_encrypt_loop, loopargs);
2081 print_result(D_CBC_256_AES, testnum, count, d);
2085 if (doit[D_IGE_128_AES]) {
2086 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2087 print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][testnum],
2090 count = run_benchmark(async_jobs, AES_ige_128_encrypt_loop, loopargs);
2092 print_result(D_IGE_128_AES, testnum, count, d);
2095 if (doit[D_IGE_192_AES]) {
2096 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2097 print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][testnum],
2100 count = run_benchmark(async_jobs, AES_ige_192_encrypt_loop, loopargs);
2102 print_result(D_IGE_192_AES, testnum, count, d);
2105 if (doit[D_IGE_256_AES]) {
2106 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2107 print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][testnum],
2110 count = run_benchmark(async_jobs, AES_ige_256_encrypt_loop, loopargs);
2112 print_result(D_IGE_256_AES, testnum, count, d);
2115 if (doit[D_GHASH]) {
2116 for (i = 0; i < loopargs_len; i++) {
2117 loopargs[i].gcm_ctx = CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
2118 CRYPTO_gcm128_setiv(loopargs[i].gcm_ctx, (unsigned char *)"0123456789ab", 12);
2121 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2122 print_message(names[D_GHASH], c[D_GHASH][testnum], lengths[testnum]);
2124 count = run_benchmark(async_jobs, CRYPTO_gcm128_aad_loop, loopargs);
2126 print_result(D_GHASH, testnum, count, d);
2128 for (i = 0; i < loopargs_len; i++)
2129 CRYPTO_gcm128_release(loopargs[i].gcm_ctx);
2132 #ifndef OPENSSL_NO_CAMELLIA
2133 if (doit[D_CBC_128_CML]) {
2134 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2135 print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][testnum],
2137 if (async_jobs > 0) {
2138 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2142 for (count = 0, run = 1; COND(c[D_CBC_128_CML][testnum]); count++)
2143 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2144 (unsigned long)lengths[testnum], &camellia_ks1,
2145 iv, CAMELLIA_ENCRYPT);
2147 print_result(D_CBC_128_CML, testnum, count, d);
2150 if (doit[D_CBC_192_CML]) {
2151 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2152 print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][testnum],
2154 if (async_jobs > 0) {
2155 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2159 for (count = 0, run = 1; COND(c[D_CBC_192_CML][testnum]); count++)
2160 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2161 (unsigned long)lengths[testnum], &camellia_ks2,
2162 iv, CAMELLIA_ENCRYPT);
2164 print_result(D_CBC_192_CML, testnum, count, d);
2167 if (doit[D_CBC_256_CML]) {
2168 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2169 print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][testnum],
2171 if (async_jobs > 0) {
2172 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2176 for (count = 0, run = 1; COND(c[D_CBC_256_CML][testnum]); count++)
2177 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2178 (unsigned long)lengths[testnum], &camellia_ks3,
2179 iv, CAMELLIA_ENCRYPT);
2181 print_result(D_CBC_256_CML, testnum, count, d);
2185 #ifndef OPENSSL_NO_IDEA
2186 if (doit[D_CBC_IDEA]) {
2187 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2188 print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][testnum], lengths[testnum]);
2189 if (async_jobs > 0) {
2190 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2194 for (count = 0, run = 1; COND(c[D_CBC_IDEA][testnum]); count++)
2195 idea_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2196 (unsigned long)lengths[testnum], &idea_ks,
2199 print_result(D_CBC_IDEA, testnum, count, d);
2203 #ifndef OPENSSL_NO_SEED
2204 if (doit[D_CBC_SEED]) {
2205 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2206 print_message(names[D_CBC_SEED], c[D_CBC_SEED][testnum], lengths[testnum]);
2207 if (async_jobs > 0) {
2208 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2212 for (count = 0, run = 1; COND(c[D_CBC_SEED][testnum]); count++)
2213 SEED_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2214 (unsigned long)lengths[testnum], &seed_ks, iv, 1);
2216 print_result(D_CBC_SEED, testnum, count, d);
2220 #ifndef OPENSSL_NO_RC2
2221 if (doit[D_CBC_RC2]) {
2222 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2223 print_message(names[D_CBC_RC2], c[D_CBC_RC2][testnum], lengths[testnum]);
2224 if (async_jobs > 0) {
2225 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2229 for (count = 0, run = 1; COND(c[D_CBC_RC2][testnum]); count++)
2230 RC2_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2231 (unsigned long)lengths[testnum], &rc2_ks,
2234 print_result(D_CBC_RC2, testnum, count, d);
2238 #ifndef OPENSSL_NO_RC5
2239 if (doit[D_CBC_RC5]) {
2240 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2241 print_message(names[D_CBC_RC5], c[D_CBC_RC5][testnum], lengths[testnum]);
2242 if (async_jobs > 0) {
2243 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2247 for (count = 0, run = 1; COND(c[D_CBC_RC5][testnum]); count++)
2248 RC5_32_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2249 (unsigned long)lengths[testnum], &rc5_ks,
2252 print_result(D_CBC_RC5, testnum, count, d);
2256 #ifndef OPENSSL_NO_BF
2257 if (doit[D_CBC_BF]) {
2258 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2259 print_message(names[D_CBC_BF], c[D_CBC_BF][testnum], lengths[testnum]);
2260 if (async_jobs > 0) {
2261 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2265 for (count = 0, run = 1; COND(c[D_CBC_BF][testnum]); count++)
2266 BF_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2267 (unsigned long)lengths[testnum], &bf_ks,
2270 print_result(D_CBC_BF, testnum, count, d);
2274 #ifndef OPENSSL_NO_CAST
2275 if (doit[D_CBC_CAST]) {
2276 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2277 print_message(names[D_CBC_CAST], c[D_CBC_CAST][testnum], lengths[testnum]);
2278 if (async_jobs > 0) {
2279 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2283 for (count = 0, run = 1; COND(c[D_CBC_CAST][testnum]); count++)
2284 CAST_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2285 (unsigned long)lengths[testnum], &cast_ks,
2288 print_result(D_CBC_CAST, testnum, count, d);
2294 #ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
2295 if (multiblock && evp_cipher) {
2297 (EVP_CIPHER_flags(evp_cipher) &
2298 EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
2299 BIO_printf(bio_err, "%s is not multi-block capable\n",
2300 OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher)));
2303 if (async_jobs > 0) {
2304 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2307 multiblock_speed(evp_cipher);
2312 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2315 names[D_EVP] = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
2317 * -O3 -fschedule-insns messes up an optimization here!
2318 * names[D_EVP] somehow becomes NULL
2320 print_message(names[D_EVP], save_count, lengths[testnum]);
2322 for (k = 0; k < loopargs_len; k++) {
2323 loopargs[k].ctx = EVP_CIPHER_CTX_new();
2325 EVP_DecryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
2327 EVP_EncryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
2328 EVP_CIPHER_CTX_set_padding(loopargs[k].ctx, 0);
2332 count = run_benchmark(async_jobs, EVP_Update_loop, loopargs);
2334 for (k = 0; k < loopargs_len; k++) {
2335 EVP_CIPHER_CTX_free(loopargs[k].ctx);
2339 names[D_EVP] = OBJ_nid2ln(EVP_MD_type(evp_md));
2340 print_message(names[D_EVP], save_count, lengths[testnum]);
2342 count = run_benchmark(async_jobs, EVP_Digest_loop, loopargs);
2345 print_result(D_EVP, testnum, count, d);
2349 for (i = 0; i < loopargs_len; i++)
2350 RAND_bytes(loopargs[i].buf, 36);
2352 #ifndef OPENSSL_NO_RSA
2353 for (testnum = 0; testnum < RSA_NUM; testnum++) {
2355 if (!rsa_doit[testnum])
2357 for (i = 0; i < loopargs_len; i++) {
2358 st = RSA_sign(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2359 loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2365 "RSA sign failure. No RSA sign will be done.\n");
2366 ERR_print_errors(bio_err);
2369 pkey_print_message("private", "rsa",
2370 rsa_c[testnum][0], rsa_bits[testnum], RSA_SECONDS);
2371 /* RSA_blinding_on(rsa_key[testnum],NULL); */
2373 count = run_benchmark(async_jobs, RSA_sign_loop, loopargs);
2376 mr ? "+R1:%ld:%d:%.2f\n"
2377 : "%ld %d bit private RSA's in %.2fs\n",
2378 count, rsa_bits[testnum], d);
2379 rsa_results[testnum][0] = d / (double)count;
2383 for (i = 0; i < loopargs_len; i++) {
2384 st = RSA_verify(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2385 *(loopargs[i].siglen), loopargs[i].rsa_key[testnum]);
2391 "RSA verify failure. No RSA verify will be done.\n");
2392 ERR_print_errors(bio_err);
2393 rsa_doit[testnum] = 0;
2395 pkey_print_message("public", "rsa",
2396 rsa_c[testnum][1], rsa_bits[testnum], RSA_SECONDS);
2398 count = run_benchmark(async_jobs, RSA_verify_loop, loopargs);
2401 mr ? "+R2:%ld:%d:%.2f\n"
2402 : "%ld %d bit public RSA's in %.2fs\n",
2403 count, rsa_bits[testnum], d);
2404 rsa_results[testnum][1] = d / (double)count;
2407 if (rsa_count <= 1) {
2408 /* if longer than 10s, don't do any more */
2409 for (testnum++; testnum < RSA_NUM; testnum++)
2410 rsa_doit[testnum] = 0;
2415 for (i = 0; i < loopargs_len; i++)
2416 RAND_bytes(loopargs[i].buf, 36);
2418 #ifndef OPENSSL_NO_DSA
2419 if (RAND_status() != 1) {
2420 RAND_seed(rnd_seed, sizeof rnd_seed);
2423 for (testnum = 0; testnum < DSA_NUM; testnum++) {
2425 if (!dsa_doit[testnum])
2428 /* DSA_generate_key(dsa_key[testnum]); */
2429 /* DSA_sign_setup(dsa_key[testnum],NULL); */
2430 for (i = 0; i < loopargs_len; i++) {
2431 st = DSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2432 loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2438 "DSA sign failure. No DSA sign will be done.\n");
2439 ERR_print_errors(bio_err);
2442 pkey_print_message("sign", "dsa",
2443 dsa_c[testnum][0], dsa_bits[testnum], DSA_SECONDS);
2445 count = run_benchmark(async_jobs, DSA_sign_loop, loopargs);
2448 mr ? "+R3:%ld:%d:%.2f\n"
2449 : "%ld %d bit DSA signs in %.2fs\n",
2450 count, dsa_bits[testnum], d);
2451 dsa_results[testnum][0] = d / (double)count;
2455 for (i = 0; i < loopargs_len; i++) {
2456 st = DSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2457 *(loopargs[i].siglen), loopargs[i].dsa_key[testnum]);
2463 "DSA verify failure. No DSA verify will be done.\n");
2464 ERR_print_errors(bio_err);
2465 dsa_doit[testnum] = 0;
2467 pkey_print_message("verify", "dsa",
2468 dsa_c[testnum][1], dsa_bits[testnum], DSA_SECONDS);
2470 count = run_benchmark(async_jobs, DSA_verify_loop, loopargs);
2473 mr ? "+R4:%ld:%d:%.2f\n"
2474 : "%ld %d bit DSA verify in %.2fs\n",
2475 count, dsa_bits[testnum], d);
2476 dsa_results[testnum][1] = d / (double)count;
2479 if (rsa_count <= 1) {
2480 /* if longer than 10s, don't do any more */
2481 for (testnum++; testnum < DSA_NUM; testnum++)
2482 dsa_doit[testnum] = 0;
2489 #ifndef OPENSSL_NO_EC
2490 if (RAND_status() != 1) {
2491 RAND_seed(rnd_seed, sizeof rnd_seed);
2494 for (testnum = 0; testnum < EC_NUM; testnum++) {
2497 if (!ecdsa_doit[testnum])
2498 continue; /* Ignore Curve */
2499 for (i = 0; i < loopargs_len; i++) {
2500 loopargs[i].ecdsa[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2501 if (loopargs[i].ecdsa[testnum] == NULL) {
2507 BIO_printf(bio_err, "ECDSA failure.\n");
2508 ERR_print_errors(bio_err);
2511 for (i = 0; i < loopargs_len; i++) {
2512 EC_KEY_precompute_mult(loopargs[i].ecdsa[testnum], NULL);
2513 /* Perform ECDSA signature test */
2514 EC_KEY_generate_key(loopargs[i].ecdsa[testnum]);
2515 st = ECDSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2516 loopargs[i].siglen, loopargs[i].ecdsa[testnum]);
2522 "ECDSA sign failure. No ECDSA sign will be done.\n");
2523 ERR_print_errors(bio_err);
2526 pkey_print_message("sign", "ecdsa",
2527 ecdsa_c[testnum][0],
2528 test_curves_bits[testnum], ECDSA_SECONDS);
2530 count = run_benchmark(async_jobs, ECDSA_sign_loop, loopargs);
2534 mr ? "+R5:%ld:%d:%.2f\n" :
2535 "%ld %d bit ECDSA signs in %.2fs \n",
2536 count, test_curves_bits[testnum], d);
2537 ecdsa_results[testnum][0] = d / (double)count;
2541 /* Perform ECDSA verification test */
2542 for (i = 0; i < loopargs_len; i++) {
2543 st = ECDSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2544 *(loopargs[i].siglen), loopargs[i].ecdsa[testnum]);
2550 "ECDSA verify failure. No ECDSA verify will be done.\n");
2551 ERR_print_errors(bio_err);
2552 ecdsa_doit[testnum] = 0;
2554 pkey_print_message("verify", "ecdsa",
2555 ecdsa_c[testnum][1],
2556 test_curves_bits[testnum], ECDSA_SECONDS);
2558 count = run_benchmark(async_jobs, ECDSA_verify_loop, loopargs);
2561 mr ? "+R6:%ld:%d:%.2f\n"
2562 : "%ld %d bit ECDSA verify in %.2fs\n",
2563 count, test_curves_bits[testnum], d);
2564 ecdsa_results[testnum][1] = d / (double)count;
2567 if (rsa_count <= 1) {
2568 /* if longer than 10s, don't do any more */
2569 for (testnum++; testnum < EC_NUM; testnum++)
2570 ecdsa_doit[testnum] = 0;
2578 #ifndef OPENSSL_NO_EC
2579 if (RAND_status() != 1) {
2580 RAND_seed(rnd_seed, sizeof rnd_seed);
2583 for (testnum = 0; testnum < EC_NUM; testnum++) {
2584 if (!ecdh_doit[testnum])
2586 for (i = 0; i < loopargs_len; i++) {
2587 loopargs[i].ecdh_a[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2588 loopargs[i].ecdh_b[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2589 if (loopargs[i].ecdh_a[testnum] == NULL ||
2590 loopargs[i].ecdh_b[testnum] == NULL) {
2595 if (ecdh_checks == 0) {
2596 BIO_printf(bio_err, "ECDH failure.\n");
2597 ERR_print_errors(bio_err);
2600 for (i = 0; i < loopargs_len; i++) {
2601 /* generate two ECDH key pairs */
2602 if (!EC_KEY_generate_key(loopargs[i].ecdh_a[testnum]) ||
2603 !EC_KEY_generate_key(loopargs[i].ecdh_b[testnum])) {
2604 BIO_printf(bio_err, "ECDH key generation failure.\n");
2605 ERR_print_errors(bio_err);
2610 * If field size is not more than 24 octets, then use SHA-1
2611 * hash of result; otherwise, use result (see section 4.8 of
2612 * draft-ietf-tls-ecc-03.txt).
2616 EC_GROUP_get_degree(EC_KEY_get0_group(loopargs[i].ecdh_a[testnum]));
2617 if (field_size <= 24 * 8) {
2618 outlen = KDF1_SHA1_len;
2621 outlen = (field_size + 7) / 8;
2625 ECDH_compute_key(loopargs[i].secret_a, outlen,
2626 EC_KEY_get0_public_key(loopargs[i].ecdh_b[testnum]),
2627 loopargs[i].ecdh_a[testnum], kdf);
2629 ECDH_compute_key(loopargs[i].secret_b, outlen,
2630 EC_KEY_get0_public_key(loopargs[i].ecdh_a[testnum]),
2631 loopargs[i].ecdh_b[testnum], kdf);
2632 if (secret_size_a != secret_size_b)
2637 for (secret_idx = 0; (secret_idx < secret_size_a)
2638 && (ecdh_checks == 1); secret_idx++) {
2639 if (loopargs[i].secret_a[secret_idx] != loopargs[i].secret_b[secret_idx])
2643 if (ecdh_checks == 0) {
2644 BIO_printf(bio_err, "ECDH computations don't match.\n");
2645 ERR_print_errors(bio_err);
2650 if (ecdh_checks != 0) {
2651 pkey_print_message("", "ecdh",
2653 test_curves_bits[testnum], ECDH_SECONDS);
2655 count = run_benchmark(async_jobs, ECDH_compute_key_loop, loopargs);
2658 mr ? "+R7:%ld:%d:%.2f\n" :
2659 "%ld %d-bit ECDH ops in %.2fs\n", count,
2660 test_curves_bits[testnum], d);
2661 ecdh_results[testnum][0] = d / (double)count;
2667 if (rsa_count <= 1) {
2668 /* if longer than 10s, don't do any more */
2669 for (testnum++; testnum < EC_NUM; testnum++)
2670 ecdh_doit[testnum] = 0;
2680 printf("%s\n", OpenSSL_version(OPENSSL_VERSION));
2681 printf("%s\n", OpenSSL_version(OPENSSL_BUILT_ON));
2683 printf("%s ", BN_options());
2684 #ifndef OPENSSL_NO_MD2
2685 printf("%s ", MD2_options());
2687 #ifndef OPENSSL_NO_RC4
2688 printf("%s ", RC4_options());
2690 #ifndef OPENSSL_NO_DES
2691 printf("%s ", DES_options());
2693 #ifndef OPENSSL_NO_AES
2694 printf("%s ", AES_options());
2696 #ifndef OPENSSL_NO_IDEA
2697 printf("%s ", idea_options());
2699 #ifndef OPENSSL_NO_BF
2700 printf("%s ", BF_options());
2702 printf("\n%s\n", OpenSSL_version(OPENSSL_CFLAGS));
2710 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2713 for (testnum = 0; testnum < SIZE_NUM; testnum++)
2714 printf(mr ? ":%d" : "%7d bytes", lengths[testnum]);
2718 for (k = 0; k < ALGOR_NUM; k++) {
2722 printf("+F:%d:%s", k, names[k]);
2724 printf("%-13s", names[k]);
2725 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2726 if (results[k][testnum] > 10000 && !mr)
2727 printf(" %11.2fk", results[k][testnum] / 1e3);
2729 printf(mr ? ":%.2f" : " %11.2f ", results[k][testnum]);
2733 #ifndef OPENSSL_NO_RSA
2735 for (k = 0; k < RSA_NUM; k++) {
2738 if (testnum && !mr) {
2739 printf("%18ssign verify sign/s verify/s\n", " ");
2743 printf("+F2:%u:%u:%f:%f\n",
2744 k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2746 printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2747 rsa_bits[k], rsa_results[k][0], rsa_results[k][1],
2748 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]);
2751 #ifndef OPENSSL_NO_DSA
2753 for (k = 0; k < DSA_NUM; k++) {
2756 if (testnum && !mr) {
2757 printf("%18ssign verify sign/s verify/s\n", " ");
2761 printf("+F3:%u:%u:%f:%f\n",
2762 k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2764 printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2765 dsa_bits[k], dsa_results[k][0], dsa_results[k][1],
2766 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]);
2769 #ifndef OPENSSL_NO_EC
2771 for (k = 0; k < EC_NUM; k++) {
2774 if (testnum && !mr) {
2775 printf("%30ssign verify sign/s verify/s\n", " ");
2780 printf("+F4:%u:%u:%f:%f\n",
2781 k, test_curves_bits[k],
2782 ecdsa_results[k][0], ecdsa_results[k][1]);
2784 printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2785 test_curves_bits[k],
2786 test_curves_names[k],
2787 ecdsa_results[k][0], ecdsa_results[k][1],
2788 1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
2792 #ifndef OPENSSL_NO_EC
2794 for (k = 0; k < EC_NUM; k++) {
2797 if (testnum && !mr) {
2798 printf("%30sop op/s\n", " ");
2802 printf("+F5:%u:%u:%f:%f\n",
2803 k, test_curves_bits[k],
2804 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2807 printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2808 test_curves_bits[k],
2809 test_curves_names[k],
2810 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2817 ERR_print_errors(bio_err);
2818 for (i = 0; i < loopargs_len; i++) {
2819 OPENSSL_free(loopargs[i].buf_malloc);
2820 OPENSSL_free(loopargs[i].buf2_malloc);
2821 OPENSSL_free(loopargs[i].siglen);
2823 OPENSSL_free(loopargs);
2824 #ifndef OPENSSL_NO_RSA
2825 for (i = 0; i < loopargs_len; i++) {
2826 for (k = 0; k < RSA_NUM; k++)
2827 RSA_free(loopargs[i].rsa_key[k]);
2830 #ifndef OPENSSL_NO_DSA
2831 for (i = 0; i < loopargs_len; i++) {
2832 for (k = 0; k < DSA_NUM; k++)
2833 DSA_free(loopargs[i].dsa_key[k]);
2837 #ifndef OPENSSL_NO_EC
2838 for (i = 0; i < loopargs_len; i++) {
2839 for (k = 0; k < EC_NUM; k++) {
2840 EC_KEY_free(loopargs[i].ecdsa[k]);
2841 EC_KEY_free(loopargs[i].ecdh_a[k]);
2842 EC_KEY_free(loopargs[i].ecdh_b[k]);
2844 OPENSSL_free(loopargs[i].secret_a);
2845 OPENSSL_free(loopargs[i].secret_b);
2849 ASYNC_cleanup_thread();
2853 static void print_message(const char *s, long num, int length)
2857 mr ? "+DT:%s:%d:%d\n"
2858 : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length);
2859 (void)BIO_flush(bio_err);
2863 mr ? "+DN:%s:%ld:%d\n"
2864 : "Doing %s %ld times on %d size blocks: ", s, num, length);
2865 (void)BIO_flush(bio_err);
2869 static void pkey_print_message(const char *str, const char *str2, long num,
2874 mr ? "+DTP:%d:%s:%s:%d\n"
2875 : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
2876 (void)BIO_flush(bio_err);
2880 mr ? "+DNP:%ld:%d:%s:%s\n"
2881 : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
2882 (void)BIO_flush(bio_err);
2886 static void print_result(int alg, int run_no, int count, double time_used)
2889 mr ? "+R:%d:%s:%f\n"
2890 : "%d %s's in %.2fs\n", count, names[alg], time_used);
2891 results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
2895 static char *sstrsep(char **string, const char *delim)
2898 char *token = *string;
2903 memset(isdelim, 0, sizeof isdelim);
2907 isdelim[(unsigned char)(*delim)] = 1;
2911 while (!isdelim[(unsigned char)(**string)]) {
2923 static int do_multi(int multi)
2928 static char sep[] = ":";
2930 fds = malloc(sizeof(*fds) * multi);
2931 for (n = 0; n < multi; ++n) {
2932 if (pipe(fd) == -1) {
2933 BIO_printf(bio_err, "pipe failure\n");
2937 (void)BIO_flush(bio_err);
2944 if (dup(fd[1]) == -1) {
2945 BIO_printf(bio_err, "dup failed\n");
2954 printf("Forked child %d\n", n);
2957 /* for now, assume the pipe is long enough to take all the output */
2958 for (n = 0; n < multi; ++n) {
2963 f = fdopen(fds[n], "r");
2964 while (fgets(buf, sizeof buf, f)) {
2965 p = strchr(buf, '\n');
2968 if (buf[0] != '+') {
2969 BIO_printf(bio_err, "Don't understand line '%s' from child %d\n",
2973 printf("Got: %s from %d\n", buf, n);
2974 if (strncmp(buf, "+F:", 3) == 0) {
2979 alg = atoi(sstrsep(&p, sep));
2981 for (j = 0; j < SIZE_NUM; ++j)
2982 results[alg][j] += atof(sstrsep(&p, sep));
2983 } else if (strncmp(buf, "+F2:", 4) == 0) {
2988 k = atoi(sstrsep(&p, sep));
2991 d = atof(sstrsep(&p, sep));
2993 rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
2995 rsa_results[k][0] = d;
2997 d = atof(sstrsep(&p, sep));
2999 rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
3001 rsa_results[k][1] = d;
3003 # ifndef OPENSSL_NO_DSA
3004 else if (strncmp(buf, "+F3:", 4) == 0) {
3009 k = atoi(sstrsep(&p, sep));
3012 d = atof(sstrsep(&p, sep));
3014 dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d);
3016 dsa_results[k][0] = d;
3018 d = atof(sstrsep(&p, sep));
3020 dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d);
3022 dsa_results[k][1] = d;
3025 # ifndef OPENSSL_NO_EC
3026 else if (strncmp(buf, "+F4:", 4) == 0) {
3031 k = atoi(sstrsep(&p, sep));
3034 d = atof(sstrsep(&p, sep));
3036 ecdsa_results[k][0] =
3037 1 / (1 / ecdsa_results[k][0] + 1 / d);
3039 ecdsa_results[k][0] = d;
3041 d = atof(sstrsep(&p, sep));
3043 ecdsa_results[k][1] =
3044 1 / (1 / ecdsa_results[k][1] + 1 / d);
3046 ecdsa_results[k][1] = d;
3050 # ifndef OPENSSL_NO_EC
3051 else if (strncmp(buf, "+F5:", 4) == 0) {
3056 k = atoi(sstrsep(&p, sep));
3059 d = atof(sstrsep(&p, sep));
3061 ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
3063 ecdh_results[k][0] = d;
3068 else if (strncmp(buf, "+H:", 3) == 0) {
3071 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf, n);
3081 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
3083 static int mblengths[] =
3084 { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
3085 int j, count, num = OSSL_NELEM(mblengths);
3086 const char *alg_name;
3087 unsigned char *inp, *out, no_key[32], no_iv[16];
3088 EVP_CIPHER_CTX *ctx;
3091 inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
3092 out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
3093 ctx = EVP_CIPHER_CTX_new();
3094 EVP_EncryptInit_ex(ctx, evp_cipher, NULL, no_key, no_iv);
3095 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key),
3097 alg_name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
3099 for (j = 0; j < num; j++) {
3100 print_message(alg_name, 0, mblengths[j]);
3102 for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
3103 unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
3104 EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
3105 size_t len = mblengths[j];
3108 memset(aad, 0, 8); /* avoid uninitialized values */
3109 aad[8] = 23; /* SSL3_RT_APPLICATION_DATA */
3110 aad[9] = 3; /* version */
3112 aad[11] = 0; /* length */
3114 mb_param.out = NULL;
3117 mb_param.interleave = 8;
3119 packlen = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
3120 sizeof(mb_param), &mb_param);
3126 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
3127 sizeof(mb_param), &mb_param);
3131 RAND_bytes(out, 16);
3135 pad = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_TLS1_AAD,
3136 EVP_AEAD_TLS1_AAD_LEN, aad);
3137 EVP_Cipher(ctx, out, inp, len + pad);
3141 BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
3142 : "%d %s's in %.2fs\n", count, "evp", d);
3143 results[D_EVP][j] = ((double)count) / d * mblengths[j];
3147 fprintf(stdout, "+H");
3148 for (j = 0; j < num; j++)
3149 fprintf(stdout, ":%d", mblengths[j]);
3150 fprintf(stdout, "\n");
3151 fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
3152 for (j = 0; j < num; j++)
3153 fprintf(stdout, ":%.2f", results[D_EVP][j]);
3154 fprintf(stdout, "\n");
3157 "The 'numbers' are in 1000s of bytes per second processed.\n");
3158 fprintf(stdout, "type ");
3159 for (j = 0; j < num; j++)
3160 fprintf(stdout, "%7d bytes", mblengths[j]);
3161 fprintf(stdout, "\n");
3162 fprintf(stdout, "%-24s", alg_name);
3164 for (j = 0; j < num; j++) {
3165 if (results[D_EVP][j] > 10000)
3166 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
3168 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
3170 fprintf(stdout, "\n");
3175 EVP_CIPHER_CTX_free(ctx);