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 #include <openssl/bn.h>
103 #ifndef OPENSSL_NO_DES
104 # include <openssl/des.h>
106 #ifndef OPENSSL_NO_AES
107 # include <openssl/aes.h>
109 #ifndef OPENSSL_NO_CAMELLIA
110 # include <openssl/camellia.h>
112 #ifndef OPENSSL_NO_MD2
113 # include <openssl/md2.h>
115 #ifndef OPENSSL_NO_MDC2
116 # include <openssl/mdc2.h>
118 #ifndef OPENSSL_NO_MD4
119 # include <openssl/md4.h>
121 #ifndef OPENSSL_NO_MD5
122 # include <openssl/md5.h>
124 #include <openssl/hmac.h>
125 #include <openssl/sha.h>
126 #ifndef OPENSSL_NO_RMD160
127 # include <openssl/ripemd.h>
129 #ifndef OPENSSL_NO_WHIRLPOOL
130 # include <openssl/whrlpool.h>
132 #ifndef OPENSSL_NO_RC4
133 # include <openssl/rc4.h>
135 #ifndef OPENSSL_NO_RC5
136 # include <openssl/rc5.h>
138 #ifndef OPENSSL_NO_RC2
139 # include <openssl/rc2.h>
141 #ifndef OPENSSL_NO_IDEA
142 # include <openssl/idea.h>
144 #ifndef OPENSSL_NO_SEED
145 # include <openssl/seed.h>
147 #ifndef OPENSSL_NO_BF
148 # include <openssl/blowfish.h>
150 #ifndef OPENSSL_NO_CAST
151 # include <openssl/cast.h>
153 #ifndef OPENSSL_NO_RSA
154 # include <openssl/rsa.h>
155 # include "./testrsa.h"
157 #include <openssl/x509.h>
158 #ifndef OPENSSL_NO_DSA
159 # include <openssl/dsa.h>
160 # include "./testdsa.h"
162 #ifndef OPENSSL_NO_EC
163 # include <openssl/ec.h>
165 #include <openssl/modes.h>
168 # if defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_OS2) || defined(OPENSSL_SYS_NETWARE)
182 #define BUFSIZE (1024*16+1)
183 #define MAX_MISALIGNMENT 63
192 #define MAX_ECDH_SIZE 256
195 static volatile int run = 0;
198 static int usertime = 1;
200 typedef struct loopargs_st {
201 ASYNC_JOB *inprogress_job;
202 ASYNC_WAIT_CTX *wait_ctx;
205 unsigned char *buf_malloc;
206 unsigned char *buf2_malloc;
207 unsigned int *siglen;
208 #ifndef OPENSSL_NO_RSA
209 RSA *rsa_key[RSA_NUM];
211 #ifndef OPENSSL_NO_DSA
212 DSA *dsa_key[DSA_NUM];
214 #ifndef OPENSSL_NO_EC
215 EC_KEY *ecdsa[EC_NUM];
216 EC_KEY *ecdh_a[EC_NUM];
217 EC_KEY *ecdh_b[EC_NUM];
218 unsigned char *secret_a;
219 unsigned char *secret_b;
223 GCM128_CONTEXT *gcm_ctx;
226 #ifndef OPENSSL_NO_MD2
227 static int EVP_Digest_MD2_loop(void *args);
230 #ifndef OPENSSL_NO_MDC2
231 static int EVP_Digest_MDC2_loop(void *args);
233 #ifndef OPENSSL_NO_MD4
234 static int EVP_Digest_MD4_loop(void *args);
236 #ifndef OPENSSL_NO_MD5
237 static int MD5_loop(void *args);
238 static int HMAC_loop(void *args);
240 static int SHA1_loop(void *args);
241 static int SHA256_loop(void *args);
242 static int SHA512_loop(void *args);
243 #ifndef OPENSSL_NO_WHIRLPOOL
244 static int WHIRLPOOL_loop(void *args);
246 #ifndef OPENSSL_NO_RMD160
247 static int EVP_Digest_RMD160_loop(void *args);
249 #ifndef OPENSSL_NO_RC4
250 static int RC4_loop(void *args);
252 #ifndef OPENSSL_NO_DES
253 static int DES_ncbc_encrypt_loop(void *args);
254 static int DES_ede3_cbc_encrypt_loop(void *args);
256 #ifndef OPENSSL_NO_AES
257 static int AES_cbc_128_encrypt_loop(void *args);
258 static int AES_cbc_192_encrypt_loop(void *args);
259 static int AES_ige_128_encrypt_loop(void *args);
260 static int AES_cbc_256_encrypt_loop(void *args);
261 static int AES_ige_192_encrypt_loop(void *args);
262 static int AES_ige_256_encrypt_loop(void *args);
263 static int CRYPTO_gcm128_aad_loop(void *args);
265 static int EVP_Update_loop(void *args);
266 static int EVP_Digest_loop(void *args);
267 #ifndef OPENSSL_NO_RSA
268 static int RSA_sign_loop(void *args);
269 static int RSA_verify_loop(void *args);
271 #ifndef OPENSSL_NO_DSA
272 static int DSA_sign_loop(void *args);
273 static int DSA_verify_loop(void *args);
275 #ifndef OPENSSL_NO_EC
276 static int ECDSA_sign_loop(void *args);
277 static int ECDSA_verify_loop(void *args);
278 static int ECDH_compute_key_loop(void *args);
280 static int run_benchmark(int async_jobs, int (*loop_function)(void *), loopargs_t *loopargs);
282 static double Time_F(int s);
283 static void print_message(const char *s, long num, int length);
284 static void pkey_print_message(const char *str, const char *str2,
285 long num, int bits, int sec);
286 static void print_result(int alg, int run_no, int count, double time_used);
288 static int do_multi(int multi);
291 static const char *names[ALGOR_NUM] = {
292 "md2", "mdc2", "md4", "md5", "hmac(md5)", "sha1", "rmd160", "rc4",
293 "des cbc", "des ede3", "idea cbc", "seed cbc",
294 "rc2 cbc", "rc5-32/12 cbc", "blowfish cbc", "cast cbc",
295 "aes-128 cbc", "aes-192 cbc", "aes-256 cbc",
296 "camellia-128 cbc", "camellia-192 cbc", "camellia-256 cbc",
297 "evp", "sha256", "sha512", "whirlpool",
298 "aes-128 ige", "aes-192 ige", "aes-256 ige", "ghash"
301 static double results[ALGOR_NUM][SIZE_NUM];
302 static int lengths[SIZE_NUM] = {
303 16, 64, 256, 1024, 8 * 1024, 16 * 1024
306 #ifndef OPENSSL_NO_RSA
307 static double rsa_results[RSA_NUM][2];
309 #ifndef OPENSSL_NO_DSA
310 static double dsa_results[DSA_NUM][2];
312 #ifndef OPENSSL_NO_EC
313 static double ecdsa_results[EC_NUM][2];
314 static double ecdh_results[EC_NUM][1];
317 #if defined(OPENSSL_NO_DSA) && !defined(OPENSSL_NO_EC)
318 static const char rnd_seed[] =
319 "string to make the random number generator think it has entropy";
320 static int rnd_fake = 0;
324 # if defined(__STDC__) || defined(sgi) || defined(_AIX)
325 # define SIGRETTYPE void
327 # define SIGRETTYPE int
330 static SIGRETTYPE sig_done(int sig);
331 static SIGRETTYPE sig_done(int sig)
333 signal(SIGALRM, sig_done);
343 # if !defined(SIGALRM)
346 static unsigned int lapse, schlock;
347 static void alarm_win32(unsigned int secs)
352 # define alarm alarm_win32
354 static DWORD WINAPI sleepy(VOID * arg)
362 static double Time_F(int s)
369 thr = CreateThread(NULL, 4096, sleepy, NULL, 0, NULL);
371 DWORD err = GetLastError();
372 BIO_printf(bio_err, "unable to CreateThread (%lu)", err);
376 Sleep(0); /* scheduler spinlock */
377 ret = app_tminterval(s, usertime);
379 ret = app_tminterval(s, usertime);
381 TerminateThread(thr, 0);
389 static double Time_F(int s)
391 double ret = app_tminterval(s, usertime);
398 #ifndef OPENSSL_NO_EC
399 static const int KDF1_SHA1_len = 20;
400 static void *KDF1_SHA1(const void *in, size_t inlen, void *out,
403 if (*outlen < SHA_DIGEST_LENGTH)
405 *outlen = SHA_DIGEST_LENGTH;
406 return SHA1(in, inlen, out);
408 #endif /* OPENSSL_NO_EC */
410 static void multiblock_speed(const EVP_CIPHER *evp_cipher);
412 static int found(const char *name, const OPT_PAIR * pairs, int *result)
414 for (; pairs->name; pairs++)
415 if (strcmp(name, pairs->name) == 0) {
416 *result = pairs->retval;
422 typedef enum OPTION_choice {
423 OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
424 OPT_ELAPSED, OPT_EVP, OPT_DECRYPT, OPT_ENGINE, OPT_MULTI,
425 OPT_MR, OPT_MB, OPT_MISALIGN, OPT_ASYNCJOBS
428 OPTIONS speed_options[] = {
429 {OPT_HELP_STR, 1, '-', "Usage: %s [options] ciphers...\n"},
430 {OPT_HELP_STR, 1, '-', "Valid options are:\n"},
431 {"help", OPT_HELP, '-', "Display this summary"},
432 {"evp", OPT_EVP, 's', "Use specified EVP cipher"},
433 {"decrypt", OPT_DECRYPT, '-',
434 "Time decryption instead of encryption (only EVP)"},
435 {"mr", OPT_MR, '-', "Produce machine readable output"},
437 {"misalign", OPT_MISALIGN, 'n', "Amount to mis-align buffers"},
438 {"elapsed", OPT_ELAPSED, '-',
439 "Measure time in real time instead of CPU user time"},
441 {"multi", OPT_MULTI, 'p', "Run benchmarks in parallel"},
443 #ifndef OPENSSL_NO_ASYNC
444 {"async_jobs", OPT_ASYNCJOBS, 'p', "Enable async mode and start pnum jobs"},
446 #ifndef OPENSSL_NO_ENGINE
447 {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
462 #define D_CBC_IDEA 10
463 #define D_CBC_SEED 11
467 #define D_CBC_CAST 15
468 #define D_CBC_128_AES 16
469 #define D_CBC_192_AES 17
470 #define D_CBC_256_AES 18
471 #define D_CBC_128_CML 19
472 #define D_CBC_192_CML 20
473 #define D_CBC_256_CML 21
477 #define D_WHIRLPOOL 25
478 #define D_IGE_128_AES 26
479 #define D_IGE_192_AES 27
480 #define D_IGE_256_AES 28
482 static OPT_PAIR doit_choices[] = {
483 #ifndef OPENSSL_NO_MD2
486 #ifndef OPENSSL_NO_MDC2
489 #ifndef OPENSSL_NO_MD4
492 #ifndef OPENSSL_NO_MD5
495 #ifndef OPENSSL_NO_MD5
499 {"sha256", D_SHA256},
500 {"sha512", D_SHA512},
501 #ifndef OPENSSL_NO_WHIRLPOOL
502 {"whirlpool", D_WHIRLPOOL},
504 #ifndef OPENSSL_NO_RMD160
505 {"ripemd", D_RMD160},
506 {"rmd160", D_RMD160},
507 {"ripemd160", D_RMD160},
509 #ifndef OPENSSL_NO_RC4
512 #ifndef OPENSSL_NO_DES
513 {"des-cbc", D_CBC_DES},
514 {"des-ede3", D_EDE3_DES},
516 #ifndef OPENSSL_NO_AES
517 {"aes-128-cbc", D_CBC_128_AES},
518 {"aes-192-cbc", D_CBC_192_AES},
519 {"aes-256-cbc", D_CBC_256_AES},
520 {"aes-128-ige", D_IGE_128_AES},
521 {"aes-192-ige", D_IGE_192_AES},
522 {"aes-256-ige", D_IGE_256_AES},
524 #ifndef OPENSSL_NO_RC2
525 {"rc2-cbc", D_CBC_RC2},
528 #ifndef OPENSSL_NO_RC5
529 {"rc5-cbc", D_CBC_RC5},
532 #ifndef OPENSSL_NO_IDEA
533 {"idea-cbc", D_CBC_IDEA},
534 {"idea", D_CBC_IDEA},
536 #ifndef OPENSSL_NO_SEED
537 {"seed-cbc", D_CBC_SEED},
538 {"seed", D_CBC_SEED},
540 #ifndef OPENSSL_NO_BF
541 {"bf-cbc", D_CBC_BF},
542 {"blowfish", D_CBC_BF},
545 #ifndef OPENSSL_NO_CAST
546 {"cast-cbc", D_CBC_CAST},
547 {"cast", D_CBC_CAST},
548 {"cast5", D_CBC_CAST},
557 static OPT_PAIR dsa_choices[] = {
558 {"dsa512", R_DSA_512},
559 {"dsa1024", R_DSA_1024},
560 {"dsa2048", R_DSA_2048},
570 #define R_RSA_15360 6
571 static OPT_PAIR rsa_choices[] = {
572 {"rsa512", R_RSA_512},
573 {"rsa1024", R_RSA_1024},
574 {"rsa2048", R_RSA_2048},
575 {"rsa3072", R_RSA_3072},
576 {"rsa4096", R_RSA_4096},
577 {"rsa7680", R_RSA_7680},
578 {"rsa15360", R_RSA_15360},
598 #define R_EC_X25519 16
599 #ifndef OPENSSL_NO_EC
600 static OPT_PAIR ecdsa_choices[] = {
601 {"ecdsap160", R_EC_P160},
602 {"ecdsap192", R_EC_P192},
603 {"ecdsap224", R_EC_P224},
604 {"ecdsap256", R_EC_P256},
605 {"ecdsap384", R_EC_P384},
606 {"ecdsap521", R_EC_P521},
607 {"ecdsak163", R_EC_K163},
608 {"ecdsak233", R_EC_K233},
609 {"ecdsak283", R_EC_K283},
610 {"ecdsak409", R_EC_K409},
611 {"ecdsak571", R_EC_K571},
612 {"ecdsab163", R_EC_B163},
613 {"ecdsab233", R_EC_B233},
614 {"ecdsab283", R_EC_B283},
615 {"ecdsab409", R_EC_B409},
616 {"ecdsab571", R_EC_B571},
619 static OPT_PAIR ecdh_choices[] = {
620 {"ecdhp160", R_EC_P160},
621 {"ecdhp192", R_EC_P192},
622 {"ecdhp224", R_EC_P224},
623 {"ecdhp256", R_EC_P256},
624 {"ecdhp384", R_EC_P384},
625 {"ecdhp521", R_EC_P521},
626 {"ecdhk163", R_EC_K163},
627 {"ecdhk233", R_EC_K233},
628 {"ecdhk283", R_EC_K283},
629 {"ecdhk409", R_EC_K409},
630 {"ecdhk571", R_EC_K571},
631 {"ecdhb163", R_EC_B163},
632 {"ecdhb233", R_EC_B233},
633 {"ecdhb283", R_EC_B283},
634 {"ecdhb409", R_EC_B409},
635 {"ecdhb571", R_EC_B571},
636 {"ecdhx25519", R_EC_X25519},
642 # define COND(d) (count < (d))
643 # define COUNT(d) (d)
645 # define COND(c) (run && count<0x7fffffff)
646 # define COUNT(d) (count)
650 static char *engine_id = NULL;
653 #ifndef OPENSSL_NO_MD2
654 static int EVP_Digest_MD2_loop(void *args)
656 loopargs_t *tempargs = (loopargs_t *)args;
657 unsigned char *buf = tempargs->buf;
658 unsigned char md2[MD2_DIGEST_LENGTH];
660 for (count = 0; COND(c[D_MD2][testnum]); count++)
661 EVP_Digest(buf, (unsigned long)lengths[testnum], &(md2[0]), NULL,
667 #ifndef OPENSSL_NO_MDC2
668 static int EVP_Digest_MDC2_loop(void *args)
670 loopargs_t *tempargs = (loopargs_t *)args;
671 unsigned char *buf = tempargs->buf;
672 unsigned char mdc2[MDC2_DIGEST_LENGTH];
674 for (count = 0; COND(c[D_MDC2][testnum]); count++)
675 EVP_Digest(buf, (unsigned long)lengths[testnum], &(mdc2[0]), NULL,
681 #ifndef OPENSSL_NO_MD4
682 static int EVP_Digest_MD4_loop(void *args)
684 loopargs_t *tempargs = (loopargs_t *)args;
685 unsigned char *buf = tempargs->buf;
686 unsigned char md4[MD4_DIGEST_LENGTH];
688 for (count = 0; COND(c[D_MD4][testnum]); count++)
689 EVP_Digest(&(buf[0]), (unsigned long)lengths[testnum], &(md4[0]),
690 NULL, EVP_md4(), NULL);
695 #ifndef OPENSSL_NO_MD5
696 static int MD5_loop(void *args)
698 loopargs_t *tempargs = (loopargs_t *)args;
699 unsigned char *buf = tempargs->buf;
700 unsigned char md5[MD5_DIGEST_LENGTH];
702 for (count = 0; COND(c[D_MD5][testnum]); count++)
703 MD5(buf, lengths[testnum], md5);
707 static int HMAC_loop(void *args)
709 loopargs_t *tempargs = (loopargs_t *)args;
710 unsigned char *buf = tempargs->buf;
711 HMAC_CTX *hctx = tempargs->hctx;
712 unsigned char hmac[MD5_DIGEST_LENGTH];
714 for (count = 0; COND(c[D_HMAC][testnum]); count++) {
715 HMAC_Init_ex(hctx, NULL, 0, NULL, NULL);
716 HMAC_Update(hctx, buf, lengths[testnum]);
717 HMAC_Final(hctx, &(hmac[0]), NULL);
723 static int SHA1_loop(void *args)
725 loopargs_t *tempargs = (loopargs_t *)args;
726 unsigned char *buf = tempargs->buf;
727 unsigned char sha[SHA_DIGEST_LENGTH];
729 for (count = 0; COND(c[D_SHA1][testnum]); count++)
730 SHA1(buf, lengths[testnum], sha);
734 static int SHA256_loop(void *args)
736 loopargs_t *tempargs = (loopargs_t *)args;
737 unsigned char *buf = tempargs->buf;
738 unsigned char sha256[SHA256_DIGEST_LENGTH];
740 for (count = 0; COND(c[D_SHA256][testnum]); count++)
741 SHA256(buf, lengths[testnum], sha256);
745 static int SHA512_loop(void *args)
747 loopargs_t *tempargs = (loopargs_t *)args;
748 unsigned char *buf = tempargs->buf;
749 unsigned char sha512[SHA512_DIGEST_LENGTH];
751 for (count = 0; COND(c[D_SHA512][testnum]); count++)
752 SHA512(buf, lengths[testnum], sha512);
756 #ifndef OPENSSL_NO_WHIRLPOOL
757 static int WHIRLPOOL_loop(void *args)
759 loopargs_t *tempargs = (loopargs_t *)args;
760 unsigned char *buf = tempargs->buf;
761 unsigned char whirlpool[WHIRLPOOL_DIGEST_LENGTH];
763 for (count = 0; COND(c[D_WHIRLPOOL][testnum]); count++)
764 WHIRLPOOL(buf, lengths[testnum], whirlpool);
769 #ifndef OPENSSL_NO_RMD160
770 static int EVP_Digest_RMD160_loop(void *args)
772 loopargs_t *tempargs = (loopargs_t *)args;
773 unsigned char *buf = tempargs->buf;
774 unsigned char rmd160[RIPEMD160_DIGEST_LENGTH];
776 for (count = 0; COND(c[D_RMD160][testnum]); count++)
777 EVP_Digest(buf, (unsigned long)lengths[testnum], &(rmd160[0]), NULL,
778 EVP_ripemd160(), NULL);
783 #ifndef OPENSSL_NO_RC4
784 static RC4_KEY rc4_ks;
785 static int RC4_loop(void *args)
787 loopargs_t *tempargs = (loopargs_t *)args;
788 unsigned char *buf = tempargs->buf;
790 for (count = 0; COND(c[D_RC4][testnum]); count++)
791 RC4(&rc4_ks, (unsigned int)lengths[testnum], buf, buf);
796 #ifndef OPENSSL_NO_DES
797 static unsigned char DES_iv[8];
798 static DES_key_schedule sch;
799 static DES_key_schedule sch2;
800 static DES_key_schedule sch3;
801 static int DES_ncbc_encrypt_loop(void *args)
803 loopargs_t *tempargs = (loopargs_t *)args;
804 unsigned char *buf = tempargs->buf;
806 for (count = 0; COND(c[D_CBC_DES][testnum]); count++)
807 DES_ncbc_encrypt(buf, buf, lengths[testnum], &sch,
808 &DES_iv, DES_ENCRYPT);
812 static int DES_ede3_cbc_encrypt_loop(void *args)
814 loopargs_t *tempargs = (loopargs_t *)args;
815 unsigned char *buf = tempargs->buf;
817 for (count = 0; COND(c[D_EDE3_DES][testnum]); count++)
818 DES_ede3_cbc_encrypt(buf, buf, lengths[testnum],
820 &DES_iv, DES_ENCRYPT);
825 #ifndef OPENSSL_NO_AES
826 # define MAX_BLOCK_SIZE 128
828 # define MAX_BLOCK_SIZE 64
831 static unsigned char iv[2 * MAX_BLOCK_SIZE / 8];
832 #ifndef OPENSSL_NO_AES
833 static AES_KEY aes_ks1, aes_ks2, aes_ks3;
834 static int AES_cbc_128_encrypt_loop(void *args)
836 loopargs_t *tempargs = (loopargs_t *)args;
837 unsigned char *buf = tempargs->buf;
839 for (count = 0; COND(c[D_CBC_128_AES][testnum]); count++)
840 AES_cbc_encrypt(buf, buf,
841 (unsigned long)lengths[testnum], &aes_ks1,
846 static int AES_cbc_192_encrypt_loop(void *args)
848 loopargs_t *tempargs = (loopargs_t *)args;
849 unsigned char *buf = tempargs->buf;
851 for (count = 0; COND(c[D_CBC_192_AES][testnum]); count++)
852 AES_cbc_encrypt(buf, buf,
853 (unsigned long)lengths[testnum], &aes_ks2,
858 static int AES_cbc_256_encrypt_loop(void *args)
860 loopargs_t *tempargs = (loopargs_t *)args;
861 unsigned char *buf = tempargs->buf;
863 for (count = 0; COND(c[D_CBC_256_AES][testnum]); count++)
864 AES_cbc_encrypt(buf, buf,
865 (unsigned long)lengths[testnum], &aes_ks3,
870 static int AES_ige_128_encrypt_loop(void *args)
872 loopargs_t *tempargs = (loopargs_t *)args;
873 unsigned char *buf = tempargs->buf;
874 unsigned char *buf2 = tempargs->buf2;
876 for (count = 0; COND(c[D_IGE_128_AES][testnum]); count++)
877 AES_ige_encrypt(buf, buf2,
878 (unsigned long)lengths[testnum], &aes_ks1,
883 static int AES_ige_192_encrypt_loop(void *args)
885 loopargs_t *tempargs = (loopargs_t *)args;
886 unsigned char *buf = tempargs->buf;
887 unsigned char *buf2 = tempargs->buf2;
889 for (count = 0; COND(c[D_IGE_192_AES][testnum]); count++)
890 AES_ige_encrypt(buf, buf2,
891 (unsigned long)lengths[testnum], &aes_ks2,
896 static int AES_ige_256_encrypt_loop(void *args)
898 loopargs_t *tempargs = (loopargs_t *)args;
899 unsigned char *buf = tempargs->buf;
900 unsigned char *buf2 = tempargs->buf2;
902 for (count = 0; COND(c[D_IGE_256_AES][testnum]); count++)
903 AES_ige_encrypt(buf, buf2,
904 (unsigned long)lengths[testnum], &aes_ks3,
909 static int CRYPTO_gcm128_aad_loop(void *args)
911 loopargs_t *tempargs = (loopargs_t *)args;
912 unsigned char *buf = tempargs->buf;
913 GCM128_CONTEXT *gcm_ctx = tempargs->gcm_ctx;
915 for (count = 0; COND(c[D_GHASH][testnum]); count++)
916 CRYPTO_gcm128_aad(gcm_ctx, buf, lengths[testnum]);
922 static int decrypt = 0;
923 static int EVP_Update_loop(void *args)
925 loopargs_t *tempargs = (loopargs_t *)args;
926 unsigned char *buf = tempargs->buf;
927 EVP_CIPHER_CTX *ctx = tempargs->ctx;
931 COND(save_count * 4 * lengths[0] / lengths[testnum]);
933 EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
936 COND(save_count * 4 * lengths[0] / lengths[testnum]);
938 EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
940 EVP_DecryptFinal_ex(ctx, buf, &outl);
942 EVP_EncryptFinal_ex(ctx, buf, &outl);
946 static const EVP_MD *evp_md = NULL;
947 static int EVP_Digest_loop(void *args)
949 loopargs_t *tempargs = (loopargs_t *)args;
950 unsigned char *buf = tempargs->buf;
951 unsigned char md[EVP_MAX_MD_SIZE];
954 COND(save_count * 4 * lengths[0] / lengths[testnum]); count++)
955 EVP_Digest(buf, lengths[testnum], &(md[0]), NULL, evp_md, NULL);
960 #ifndef OPENSSL_NO_RSA
961 static long rsa_c[RSA_NUM][2];
963 static int RSA_sign_loop(void *args)
965 loopargs_t *tempargs = (loopargs_t *)args;
966 unsigned char *buf = tempargs->buf;
967 unsigned char *buf2 = tempargs->buf2;
968 unsigned int *rsa_num = tempargs->siglen;
969 RSA **rsa_key = tempargs->rsa_key;
971 for (count = 0; COND(rsa_c[testnum][0]); count++) {
972 ret = RSA_sign(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
974 BIO_printf(bio_err, "RSA sign failure\n");
975 ERR_print_errors(bio_err);
983 static int RSA_verify_loop(void *args)
985 loopargs_t *tempargs = (loopargs_t *)args;
986 unsigned char *buf = tempargs->buf;
987 unsigned char *buf2 = tempargs->buf2;
988 unsigned int rsa_num = *(tempargs->siglen);
989 RSA **rsa_key = tempargs->rsa_key;
991 for (count = 0; COND(rsa_c[testnum][1]); count++) {
992 ret = RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
994 BIO_printf(bio_err, "RSA verify failure\n");
995 ERR_print_errors(bio_err);
1004 #ifndef OPENSSL_NO_DSA
1005 static long dsa_c[DSA_NUM][2];
1006 static int DSA_sign_loop(void *args)
1008 loopargs_t *tempargs = (loopargs_t *)args;
1009 unsigned char *buf = tempargs->buf;
1010 unsigned char *buf2 = tempargs->buf2;
1011 DSA **dsa_key = tempargs->dsa_key;
1012 unsigned int *siglen = tempargs->siglen;
1014 for (count = 0; COND(dsa_c[testnum][0]); count++) {
1015 ret = DSA_sign(0, buf, 20, buf2, siglen, dsa_key[testnum]);
1017 BIO_printf(bio_err, "DSA sign failure\n");
1018 ERR_print_errors(bio_err);
1026 static int DSA_verify_loop(void *args)
1028 loopargs_t *tempargs = (loopargs_t *)args;
1029 unsigned char *buf = tempargs->buf;
1030 unsigned char *buf2 = tempargs->buf2;
1031 DSA **dsa_key = tempargs->dsa_key;
1032 unsigned int siglen = *(tempargs->siglen);
1034 for (count = 0; COND(dsa_c[testnum][1]); count++) {
1035 ret = DSA_verify(0, buf, 20, buf2, siglen, dsa_key[testnum]);
1037 BIO_printf(bio_err, "DSA verify failure\n");
1038 ERR_print_errors(bio_err);
1047 #ifndef OPENSSL_NO_EC
1048 static long ecdsa_c[EC_NUM][2];
1049 static int ECDSA_sign_loop(void *args)
1051 loopargs_t *tempargs = (loopargs_t *)args;
1052 unsigned char *buf = tempargs->buf;
1053 EC_KEY **ecdsa = tempargs->ecdsa;
1054 unsigned char *ecdsasig = tempargs->buf2;
1055 unsigned int *ecdsasiglen = tempargs->siglen;
1057 for (count = 0; COND(ecdsa_c[testnum][0]); count++) {
1058 ret = ECDSA_sign(0, buf, 20,
1059 ecdsasig, ecdsasiglen, ecdsa[testnum]);
1061 BIO_printf(bio_err, "ECDSA sign failure\n");
1062 ERR_print_errors(bio_err);
1070 static int ECDSA_verify_loop(void *args)
1072 loopargs_t *tempargs = (loopargs_t *)args;
1073 unsigned char *buf = tempargs->buf;
1074 EC_KEY **ecdsa = tempargs->ecdsa;
1075 unsigned char *ecdsasig = tempargs->buf2;
1076 unsigned int ecdsasiglen = *(tempargs->siglen);
1078 for (count = 0; COND(ecdsa_c[testnum][1]); count++) {
1079 ret = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen,
1082 BIO_printf(bio_err, "ECDSA verify failure\n");
1083 ERR_print_errors(bio_err);
1092 static void *(*kdf) (const void *in, size_t inlen, void *out,
1095 static int ECDH_compute_key_loop(void *args)
1097 loopargs_t *tempargs = (loopargs_t *)args;
1098 EC_KEY **ecdh_a = tempargs->ecdh_a;
1099 EC_KEY **ecdh_b = tempargs->ecdh_b;
1100 unsigned char *secret_a = tempargs->secret_a;
1102 for (count = 0; COND(ecdh_c[testnum][0]); count++) {
1103 ECDH_compute_key(secret_a, outlen,
1104 EC_KEY_get0_public_key(ecdh_b[testnum]),
1105 ecdh_a[testnum], kdf);
1112 static int run_benchmark(int async_jobs, int (*loop_function)(void *), loopargs_t *loopargs)
1114 int job_op_count = 0;
1115 int total_op_count = 0;
1116 int num_inprogress = 0;
1119 OSSL_ASYNC_FD job_fd = 0;
1120 size_t num_job_fds = 0;
1124 if (async_jobs == 0) {
1125 return loop_function((void *)loopargs);
1129 for (i = 0; i < async_jobs && !error; i++) {
1130 switch (ASYNC_start_job(&(loopargs[i].inprogress_job), loopargs[i].wait_ctx,
1131 &job_op_count, loop_function,
1132 (void *)(loopargs + i), sizeof(loopargs_t))) {
1137 if (job_op_count == -1) {
1140 total_op_count += job_op_count;
1145 BIO_printf(bio_err, "Failure in the job\n");
1146 ERR_print_errors(bio_err);
1152 while (num_inprogress > 0) {
1153 #if defined(OPENSSL_SYS_WINDOWS)
1155 #elif defined(OPENSSL_SYS_UNIX)
1156 int select_result = 0;
1157 OSSL_ASYNC_FD max_fd = 0;
1160 FD_ZERO(&waitfdset);
1162 for (i = 0; i < async_jobs && num_inprogress > 0; i++) {
1163 if (loopargs[i].inprogress_job == NULL)
1166 if (!ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, NULL, &num_job_fds)
1167 || num_job_fds > 1) {
1168 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1169 ERR_print_errors(bio_err);
1173 ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd, &num_job_fds);
1174 FD_SET(job_fd, &waitfdset);
1175 if (job_fd > max_fd)
1179 select_result = select(max_fd + 1, &waitfdset, NULL, NULL, NULL);
1180 if (select_result == -1 && errno == EINTR)
1183 if (select_result == -1) {
1184 BIO_printf(bio_err, "Failure in the select\n");
1185 ERR_print_errors(bio_err);
1190 if (select_result == 0)
1194 for (i = 0; i < async_jobs; i++) {
1195 if (loopargs[i].inprogress_job == NULL)
1198 if (!ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, NULL, &num_job_fds)
1199 || num_job_fds > 1) {
1200 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1201 ERR_print_errors(bio_err);
1205 ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd, &num_job_fds);
1207 #if defined(OPENSSL_SYS_UNIX)
1208 if (num_job_fds == 1 && !FD_ISSET(job_fd, &waitfdset))
1210 #elif defined(OPENSSL_SYS_WINDOWS)
1211 if (num_job_fds == 1 &&
1212 !PeekNamedPipe(job_fd, NULL, 0, NULL, &avail, NULL) && avail > 0)
1216 switch (ASYNC_start_job(&(loopargs[i].inprogress_job), loopargs[i].wait_ctx,
1217 &job_op_count, loop_function, (void *)(loopargs + i),
1218 sizeof(loopargs_t))) {
1222 if (job_op_count == -1) {
1225 total_op_count += job_op_count;
1228 loopargs[i].inprogress_job = NULL;
1233 loopargs[i].inprogress_job = NULL;
1234 BIO_printf(bio_err, "Failure in the job\n");
1235 ERR_print_errors(bio_err);
1242 return error ? -1 : total_op_count;
1245 int speed_main(int argc, char **argv)
1247 loopargs_t *loopargs = NULL;
1248 int loopargs_len = 0;
1250 const EVP_CIPHER *evp_cipher = NULL;
1253 int multiblock = 0, doit[ALGOR_NUM], pr_header = 0;
1254 int dsa_doit[DSA_NUM], rsa_doit[RSA_NUM];
1255 int ret = 1, i, k, misalign = 0;
1256 long c[ALGOR_NUM][SIZE_NUM], count = 0, save_count = 0;
1261 /* What follows are the buffers and key material. */
1262 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA)
1265 #ifndef OPENSSL_NO_RC5
1268 #ifndef OPENSSL_NO_RC2
1271 #ifndef OPENSSL_NO_IDEA
1272 IDEA_KEY_SCHEDULE idea_ks;
1274 #ifndef OPENSSL_NO_SEED
1275 SEED_KEY_SCHEDULE seed_ks;
1277 #ifndef OPENSSL_NO_BF
1280 #ifndef OPENSSL_NO_CAST
1283 static const unsigned char key16[16] = {
1284 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1285 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1287 #ifndef OPENSSL_NO_AES
1288 static const unsigned char key24[24] = {
1289 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1290 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1291 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1293 static const unsigned char key32[32] = {
1294 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1295 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1296 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1297 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1300 #ifndef OPENSSL_NO_CAMELLIA
1301 static const unsigned char ckey24[24] = {
1302 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1303 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1304 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1306 static const unsigned char ckey32[32] = {
1307 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1308 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1309 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1310 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1312 CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
1314 #ifndef OPENSSL_NO_DES
1315 static DES_cblock key = {
1316 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
1318 static DES_cblock key2 = {
1319 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1321 static DES_cblock key3 = {
1322 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1325 #ifndef OPENSSL_NO_RSA
1326 static unsigned int rsa_bits[RSA_NUM] = {
1327 512, 1024, 2048, 3072, 4096, 7680, 15360
1329 static unsigned char *rsa_data[RSA_NUM] = {
1330 test512, test1024, test2048, test3072, test4096, test7680, test15360
1332 static int rsa_data_length[RSA_NUM] = {
1333 sizeof(test512), sizeof(test1024),
1334 sizeof(test2048), sizeof(test3072),
1335 sizeof(test4096), sizeof(test7680),
1339 #ifndef OPENSSL_NO_DSA
1340 static unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
1342 #ifndef OPENSSL_NO_EC
1344 * We only test over the following curves as they are representative, To
1345 * add tests over more curves, simply add the curve NID and curve name to
1346 * the following arrays and increase the EC_NUM value accordingly.
1348 static unsigned int test_curves[EC_NUM] = {
1350 NID_secp160r1, NID_X9_62_prime192v1, NID_secp224r1,
1351 NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
1353 NID_sect163k1, NID_sect233k1, NID_sect283k1,
1354 NID_sect409k1, NID_sect571k1, NID_sect163r2,
1355 NID_sect233r1, NID_sect283r1, NID_sect409r1,
1360 static const char *test_curves_names[EC_NUM] = {
1362 "secp160r1", "nistp192", "nistp224",
1363 "nistp256", "nistp384", "nistp521",
1365 "nistk163", "nistk233", "nistk283",
1366 "nistk409", "nistk571", "nistb163",
1367 "nistb233", "nistb283", "nistb409",
1372 static int test_curves_bits[EC_NUM] = {
1378 571, 253 /* X25519 */
1381 #ifndef OPENSSL_NO_EC
1382 int ecdsa_doit[EC_NUM];
1383 int secret_size_a, secret_size_b;
1384 int ecdh_checks = 1;
1386 long ecdh_c[EC_NUM][2];
1387 int ecdh_doit[EC_NUM];
1390 memset(results, 0, sizeof(results));
1392 memset(c, 0, sizeof(c));
1393 memset(DES_iv, 0, sizeof(DES_iv));
1394 memset(iv, 0, sizeof(iv));
1396 for (i = 0; i < ALGOR_NUM; i++)
1398 for (i = 0; i < RSA_NUM; i++)
1400 for (i = 0; i < DSA_NUM; i++)
1402 #ifndef OPENSSL_NO_EC
1403 for (i = 0; i < EC_NUM; i++)
1405 for (i = 0; i < EC_NUM; i++)
1411 prog = opt_init(argc, argv, speed_options);
1412 while ((o = opt_next()) != OPT_EOF) {
1417 BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
1420 opt_help(speed_options);
1427 evp_cipher = EVP_get_cipherbyname(opt_arg());
1428 if (evp_cipher == NULL)
1429 evp_md = EVP_get_digestbyname(opt_arg());
1430 if (evp_cipher == NULL && evp_md == NULL) {
1432 "%s: %s an unknown cipher or digest\n",
1443 * In a forked execution, an engine might need to be
1444 * initialised by each child process, not by the parent.
1445 * So store the name here and run setup_engine() later on.
1447 engine_id = opt_arg();
1451 multi = atoi(opt_arg());
1455 #ifndef OPENSSL_NO_ASYNC
1456 async_jobs = atoi(opt_arg());
1457 if (!ASYNC_is_capable()) {
1459 "%s: async_jobs specified but async not supported\n",
1466 if (!opt_int(opt_arg(), &misalign))
1468 if (misalign > MISALIGN) {
1470 "%s: Maximum offset is %d\n", prog, MISALIGN);
1482 argc = opt_num_rest();
1485 /* Remaining arguments are algorithms. */
1486 for ( ; *argv; argv++) {
1487 if (found(*argv, doit_choices, &i)) {
1491 #ifndef OPENSSL_NO_DES
1492 if (strcmp(*argv, "des") == 0) {
1493 doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
1497 if (strcmp(*argv, "sha") == 0) {
1498 doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
1501 #ifndef OPENSSL_NO_RSA
1503 if (strcmp(*argv, "openssl") == 0) {
1504 RSA_set_default_method(RSA_PKCS1_OpenSSL());
1508 if (strcmp(*argv, "rsa") == 0) {
1509 rsa_doit[R_RSA_512] = rsa_doit[R_RSA_1024] =
1510 rsa_doit[R_RSA_2048] = rsa_doit[R_RSA_3072] =
1511 rsa_doit[R_RSA_4096] = rsa_doit[R_RSA_7680] =
1512 rsa_doit[R_RSA_15360] = 1;
1515 if (found(*argv, rsa_choices, &i)) {
1520 #ifndef OPENSSL_NO_DSA
1521 if (strcmp(*argv, "dsa") == 0) {
1522 dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
1523 dsa_doit[R_DSA_2048] = 1;
1526 if (found(*argv, dsa_choices, &i)) {
1531 #ifndef OPENSSL_NO_AES
1532 if (strcmp(*argv, "aes") == 0) {
1533 doit[D_CBC_128_AES] = doit[D_CBC_192_AES] =
1534 doit[D_CBC_256_AES] = 1;
1538 #ifndef OPENSSL_NO_CAMELLIA
1539 if (strcmp(*argv, "camellia") == 0) {
1540 doit[D_CBC_128_CML] = doit[D_CBC_192_CML] =
1541 doit[D_CBC_256_CML] = 1;
1545 #ifndef OPENSSL_NO_EC
1546 if (strcmp(*argv, "ecdsa") == 0) {
1547 for (i = 0; i < EC_NUM; i++)
1551 if (found(*argv, ecdsa_choices, &i)) {
1555 if (strcmp(*argv, "ecdh") == 0) {
1556 for (i = 0; i < EC_NUM; i++)
1560 if (found(*argv, ecdh_choices, &i)) {
1565 BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
1569 /* Initialize the job pool if async mode is enabled */
1570 if (async_jobs > 0) {
1571 if (!ASYNC_init_thread(async_jobs, async_jobs)) {
1572 BIO_printf(bio_err, "Error creating the ASYNC job pool\n");
1577 loopargs_len = (async_jobs == 0 ? 1 : async_jobs);
1578 loopargs = app_malloc(loopargs_len * sizeof(loopargs_t), "array of loopargs");
1579 memset(loopargs, 0, loopargs_len * sizeof(loopargs_t));
1581 for (i = 0; i < loopargs_len; i++) {
1582 if (async_jobs > 0) {
1583 loopargs[i].wait_ctx = ASYNC_WAIT_CTX_new();
1584 if (loopargs[i].wait_ctx == NULL) {
1585 BIO_printf(bio_err, "Error creating the ASYNC_WAIT_CTX\n");
1590 loopargs[i].buf_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1591 loopargs[i].buf2_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1592 /* Align the start of buffers on a 64 byte boundary */
1593 loopargs[i].buf = loopargs[i].buf_malloc + misalign;
1594 loopargs[i].buf2 = loopargs[i].buf2_malloc + misalign;
1595 loopargs[i].siglen = app_malloc(sizeof(unsigned int), "signature length");
1596 #ifndef OPENSSL_NO_EC
1597 loopargs[i].secret_a = app_malloc(MAX_ECDH_SIZE, "ECDH secret a");
1598 loopargs[i].secret_b = app_malloc(MAX_ECDH_SIZE, "ECDH secret b");
1603 if (multi && do_multi(multi))
1607 /* Initialize the engine after the fork */
1608 (void)setup_engine(engine_id, 0);
1610 /* No parameters; turn on everything. */
1611 if ((argc == 0) && !doit[D_EVP]) {
1612 for (i = 0; i < ALGOR_NUM; i++)
1615 for (i = 0; i < RSA_NUM; i++)
1617 for (i = 0; i < DSA_NUM; i++)
1619 #ifndef OPENSSL_NO_EC
1620 for (i = 0; i < EC_NUM; i++)
1622 for (i = 0; i < EC_NUM; i++)
1626 for (i = 0; i < ALGOR_NUM; i++)
1630 if (usertime == 0 && !mr)
1632 "You have chosen to measure elapsed time "
1633 "instead of user CPU time.\n");
1635 #ifndef OPENSSL_NO_RSA
1636 for (i = 0; i < loopargs_len; i++) {
1637 for (k = 0; k < RSA_NUM; k++) {
1638 const unsigned char *p;
1641 loopargs[i].rsa_key[k] = d2i_RSAPrivateKey(NULL, &p, rsa_data_length[k]);
1642 if (loopargs[i].rsa_key[k] == NULL) {
1643 BIO_printf(bio_err, "internal error loading RSA key number %d\n",
1650 #ifndef OPENSSL_NO_DSA
1651 for (i = 0; i < loopargs_len; i++) {
1652 loopargs[i].dsa_key[0] = get_dsa512();
1653 loopargs[i].dsa_key[1] = get_dsa1024();
1654 loopargs[i].dsa_key[2] = get_dsa2048();
1657 #ifndef OPENSSL_NO_DES
1658 DES_set_key_unchecked(&key, &sch);
1659 DES_set_key_unchecked(&key2, &sch2);
1660 DES_set_key_unchecked(&key3, &sch3);
1662 #ifndef OPENSSL_NO_AES
1663 AES_set_encrypt_key(key16, 128, &aes_ks1);
1664 AES_set_encrypt_key(key24, 192, &aes_ks2);
1665 AES_set_encrypt_key(key32, 256, &aes_ks3);
1667 #ifndef OPENSSL_NO_CAMELLIA
1668 Camellia_set_key(key16, 128, &camellia_ks1);
1669 Camellia_set_key(ckey24, 192, &camellia_ks2);
1670 Camellia_set_key(ckey32, 256, &camellia_ks3);
1672 #ifndef OPENSSL_NO_IDEA
1673 idea_set_encrypt_key(key16, &idea_ks);
1675 #ifndef OPENSSL_NO_SEED
1676 SEED_set_key(key16, &seed_ks);
1678 #ifndef OPENSSL_NO_RC4
1679 RC4_set_key(&rc4_ks, 16, key16);
1681 #ifndef OPENSSL_NO_RC2
1682 RC2_set_key(&rc2_ks, 16, key16, 128);
1684 #ifndef OPENSSL_NO_RC5
1685 RC5_32_set_key(&rc5_ks, 16, key16, 12);
1687 #ifndef OPENSSL_NO_BF
1688 BF_set_key(&bf_ks, 16, key16);
1690 #ifndef OPENSSL_NO_CAST
1691 CAST_set_key(&cast_ks, 16, key16);
1693 #ifndef OPENSSL_NO_RSA
1694 memset(rsa_c, 0, sizeof(rsa_c));
1697 # ifndef OPENSSL_NO_DES
1698 BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1704 for (it = count; it; it--)
1705 DES_ecb_encrypt((DES_cblock *)loopargs[0].buf,
1706 (DES_cblock *)loopargs[0].buf, &sch, DES_ENCRYPT);
1710 c[D_MD2][0] = count / 10;
1711 c[D_MDC2][0] = count / 10;
1712 c[D_MD4][0] = count;
1713 c[D_MD5][0] = count;
1714 c[D_HMAC][0] = count;
1715 c[D_SHA1][0] = count;
1716 c[D_RMD160][0] = count;
1717 c[D_RC4][0] = count * 5;
1718 c[D_CBC_DES][0] = count;
1719 c[D_EDE3_DES][0] = count / 3;
1720 c[D_CBC_IDEA][0] = count;
1721 c[D_CBC_SEED][0] = count;
1722 c[D_CBC_RC2][0] = count;
1723 c[D_CBC_RC5][0] = count;
1724 c[D_CBC_BF][0] = count;
1725 c[D_CBC_CAST][0] = count;
1726 c[D_CBC_128_AES][0] = count;
1727 c[D_CBC_192_AES][0] = count;
1728 c[D_CBC_256_AES][0] = count;
1729 c[D_CBC_128_CML][0] = count;
1730 c[D_CBC_192_CML][0] = count;
1731 c[D_CBC_256_CML][0] = count;
1732 c[D_SHA256][0] = count;
1733 c[D_SHA512][0] = count;
1734 c[D_WHIRLPOOL][0] = count;
1735 c[D_IGE_128_AES][0] = count;
1736 c[D_IGE_192_AES][0] = count;
1737 c[D_IGE_256_AES][0] = count;
1738 c[D_GHASH][0] = count;
1740 for (i = 1; i < SIZE_NUM; i++) {
1743 l0 = (long)lengths[0];
1744 l1 = (long)lengths[i];
1746 c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1747 c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1748 c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1749 c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1750 c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1751 c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1752 c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1753 c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1754 c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1755 c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1756 c[D_GHASH][i] = c[D_GHASH][0] * 4 * l0 / l1;
1758 l0 = (long)lengths[i - 1];
1760 c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1761 c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1762 c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1763 c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1764 c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1765 c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1766 c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1767 c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1768 c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1769 c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1770 c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1771 c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1772 c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1773 c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1774 c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1775 c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1776 c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1777 c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1780 # ifndef OPENSSL_NO_RSA
1781 rsa_c[R_RSA_512][0] = count / 2000;
1782 rsa_c[R_RSA_512][1] = count / 400;
1783 for (i = 1; i < RSA_NUM; i++) {
1784 rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1785 rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1786 if ((rsa_doit[i] <= 1) && (rsa_c[i][0] == 0))
1789 if (rsa_c[i][0] == 0) {
1797 # ifndef OPENSSL_NO_DSA
1798 dsa_c[R_DSA_512][0] = count / 1000;
1799 dsa_c[R_DSA_512][1] = count / 1000 / 2;
1800 for (i = 1; i < DSA_NUM; i++) {
1801 dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1802 dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1803 if ((dsa_doit[i] <= 1) && (dsa_c[i][0] == 0))
1806 if (dsa_c[i] == 0) {
1814 # ifndef OPENSSL_NO_EC
1815 ecdsa_c[R_EC_P160][0] = count / 1000;
1816 ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1817 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1818 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1819 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1820 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1823 if (ecdsa_c[i] == 0) {
1829 ecdsa_c[R_EC_K163][0] = count / 1000;
1830 ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1831 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1832 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1833 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1834 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1837 if (ecdsa_c[i] == 0) {
1843 ecdsa_c[R_EC_B163][0] = count / 1000;
1844 ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1845 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1846 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1847 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1848 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1851 if (ecdsa_c[i] == 0) {
1858 ecdh_c[R_EC_P160][0] = count / 1000;
1859 ecdh_c[R_EC_P160][1] = count / 1000;
1860 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1861 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1862 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1863 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1866 if (ecdh_c[i] == 0) {
1872 ecdh_c[R_EC_K163][0] = count / 1000;
1873 ecdh_c[R_EC_K163][1] = count / 1000;
1874 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1875 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1876 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1877 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1880 if (ecdh_c[i] == 0) {
1886 ecdh_c[R_EC_B163][0] = count / 1000;
1887 ecdh_c[R_EC_B163][1] = count / 1000;
1888 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1889 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1890 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1891 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1894 if (ecdh_c[i] == 0) {
1903 /* not worth fixing */
1904 # error "You cannot disable DES on systems without SIGALRM."
1905 # endif /* OPENSSL_NO_DES */
1908 signal(SIGALRM, sig_done);
1910 #endif /* SIGALRM */
1912 #ifndef OPENSSL_NO_MD2
1914 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1915 print_message(names[D_MD2], c[D_MD2][testnum], lengths[testnum]);
1917 count = run_benchmark(async_jobs, EVP_Digest_MD2_loop, loopargs);
1919 print_result(D_MD2, testnum, count, d);
1923 #ifndef OPENSSL_NO_MDC2
1925 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1926 print_message(names[D_MDC2], c[D_MDC2][testnum], lengths[testnum]);
1928 count = run_benchmark(async_jobs, EVP_Digest_MDC2_loop, loopargs);
1930 print_result(D_MDC2, testnum, count, d);
1935 #ifndef OPENSSL_NO_MD4
1937 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1938 print_message(names[D_MD4], c[D_MD4][testnum], lengths[testnum]);
1940 count = run_benchmark(async_jobs, EVP_Digest_MD4_loop, loopargs);
1942 print_result(D_MD4, testnum, count, d);
1947 #ifndef OPENSSL_NO_MD5
1949 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1950 print_message(names[D_MD5], c[D_MD5][testnum], lengths[testnum]);
1952 count = run_benchmark(async_jobs, MD5_loop, loopargs);
1954 print_result(D_MD5, testnum, count, d);
1959 #ifndef OPENSSL_NO_MD5
1961 for (i = 0; i < loopargs_len; i++) {
1962 loopargs[i].hctx = HMAC_CTX_new();
1963 if (loopargs[i].hctx == NULL) {
1964 BIO_printf(bio_err, "HMAC malloc failure, exiting...");
1968 HMAC_Init_ex(loopargs[i].hctx, (unsigned char *)"This is a key...",
1969 16, EVP_md5(), NULL);
1971 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1972 print_message(names[D_HMAC], c[D_HMAC][testnum], lengths[testnum]);
1974 count = run_benchmark(async_jobs, HMAC_loop, loopargs);
1976 print_result(D_HMAC, testnum, count, d);
1978 for (i = 0; i < loopargs_len; i++) {
1979 HMAC_CTX_free(loopargs[i].hctx);
1984 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1985 print_message(names[D_SHA1], c[D_SHA1][testnum], lengths[testnum]);
1987 count = run_benchmark(async_jobs, SHA1_loop, loopargs);
1989 print_result(D_SHA1, testnum, count, d);
1992 if (doit[D_SHA256]) {
1993 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1994 print_message(names[D_SHA256], c[D_SHA256][testnum], lengths[testnum]);
1996 count = run_benchmark(async_jobs, SHA256_loop, loopargs);
1998 print_result(D_SHA256, testnum, count, d);
2001 if (doit[D_SHA512]) {
2002 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2003 print_message(names[D_SHA512], c[D_SHA512][testnum], lengths[testnum]);
2005 count = run_benchmark(async_jobs, SHA512_loop, loopargs);
2007 print_result(D_SHA512, testnum, count, d);
2011 #ifndef OPENSSL_NO_WHIRLPOOL
2012 if (doit[D_WHIRLPOOL]) {
2013 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2014 print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][testnum], lengths[testnum]);
2016 count = run_benchmark(async_jobs, WHIRLPOOL_loop, loopargs);
2018 print_result(D_WHIRLPOOL, testnum, count, d);
2023 #ifndef OPENSSL_NO_RMD160
2024 if (doit[D_RMD160]) {
2025 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2026 print_message(names[D_RMD160], c[D_RMD160][testnum], lengths[testnum]);
2028 count = run_benchmark(async_jobs, EVP_Digest_RMD160_loop, loopargs);
2030 print_result(D_RMD160, testnum, count, d);
2034 #ifndef OPENSSL_NO_RC4
2036 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2037 print_message(names[D_RC4], c[D_RC4][testnum], lengths[testnum]);
2039 count = run_benchmark(async_jobs, RC4_loop, loopargs);
2041 print_result(D_RC4, testnum, count, d);
2045 #ifndef OPENSSL_NO_DES
2046 if (doit[D_CBC_DES]) {
2047 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2048 print_message(names[D_CBC_DES], c[D_CBC_DES][testnum], lengths[testnum]);
2050 count = run_benchmark(async_jobs, DES_ncbc_encrypt_loop, loopargs);
2052 print_result(D_CBC_DES, testnum, count, d);
2056 if (doit[D_EDE3_DES]) {
2057 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2058 print_message(names[D_EDE3_DES], c[D_EDE3_DES][testnum], lengths[testnum]);
2060 count = run_benchmark(async_jobs, DES_ede3_cbc_encrypt_loop, loopargs);
2062 print_result(D_EDE3_DES, testnum, count, d);
2066 #ifndef OPENSSL_NO_AES
2067 if (doit[D_CBC_128_AES]) {
2068 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2069 print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][testnum],
2072 count = run_benchmark(async_jobs, AES_cbc_128_encrypt_loop, loopargs);
2074 print_result(D_CBC_128_AES, testnum, count, d);
2077 if (doit[D_CBC_192_AES]) {
2078 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2079 print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][testnum],
2082 count = run_benchmark(async_jobs, AES_cbc_192_encrypt_loop, loopargs);
2084 print_result(D_CBC_192_AES, testnum, count, d);
2087 if (doit[D_CBC_256_AES]) {
2088 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2089 print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][testnum],
2092 count = run_benchmark(async_jobs, AES_cbc_256_encrypt_loop, loopargs);
2094 print_result(D_CBC_256_AES, testnum, count, d);
2098 if (doit[D_IGE_128_AES]) {
2099 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2100 print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][testnum],
2103 count = run_benchmark(async_jobs, AES_ige_128_encrypt_loop, loopargs);
2105 print_result(D_IGE_128_AES, testnum, count, d);
2108 if (doit[D_IGE_192_AES]) {
2109 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2110 print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][testnum],
2113 count = run_benchmark(async_jobs, AES_ige_192_encrypt_loop, loopargs);
2115 print_result(D_IGE_192_AES, testnum, count, d);
2118 if (doit[D_IGE_256_AES]) {
2119 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2120 print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][testnum],
2123 count = run_benchmark(async_jobs, AES_ige_256_encrypt_loop, loopargs);
2125 print_result(D_IGE_256_AES, testnum, count, d);
2128 if (doit[D_GHASH]) {
2129 for (i = 0; i < loopargs_len; i++) {
2130 loopargs[i].gcm_ctx = CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
2131 CRYPTO_gcm128_setiv(loopargs[i].gcm_ctx, (unsigned char *)"0123456789ab", 12);
2134 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2135 print_message(names[D_GHASH], c[D_GHASH][testnum], lengths[testnum]);
2137 count = run_benchmark(async_jobs, CRYPTO_gcm128_aad_loop, loopargs);
2139 print_result(D_GHASH, testnum, count, d);
2141 for (i = 0; i < loopargs_len; i++)
2142 CRYPTO_gcm128_release(loopargs[i].gcm_ctx);
2145 #ifndef OPENSSL_NO_CAMELLIA
2146 if (doit[D_CBC_128_CML]) {
2147 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2148 print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][testnum],
2150 if (async_jobs > 0) {
2151 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2155 for (count = 0, run = 1; COND(c[D_CBC_128_CML][testnum]); count++)
2156 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2157 (unsigned long)lengths[testnum], &camellia_ks1,
2158 iv, CAMELLIA_ENCRYPT);
2160 print_result(D_CBC_128_CML, testnum, count, d);
2163 if (doit[D_CBC_192_CML]) {
2164 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2165 print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][testnum],
2167 if (async_jobs > 0) {
2168 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2172 for (count = 0, run = 1; COND(c[D_CBC_192_CML][testnum]); count++)
2173 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2174 (unsigned long)lengths[testnum], &camellia_ks2,
2175 iv, CAMELLIA_ENCRYPT);
2177 print_result(D_CBC_192_CML, testnum, count, d);
2180 if (doit[D_CBC_256_CML]) {
2181 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2182 print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][testnum],
2184 if (async_jobs > 0) {
2185 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2189 for (count = 0, run = 1; COND(c[D_CBC_256_CML][testnum]); count++)
2190 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2191 (unsigned long)lengths[testnum], &camellia_ks3,
2192 iv, CAMELLIA_ENCRYPT);
2194 print_result(D_CBC_256_CML, testnum, count, d);
2198 #ifndef OPENSSL_NO_IDEA
2199 if (doit[D_CBC_IDEA]) {
2200 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2201 print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][testnum], lengths[testnum]);
2202 if (async_jobs > 0) {
2203 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2207 for (count = 0, run = 1; COND(c[D_CBC_IDEA][testnum]); count++)
2208 idea_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2209 (unsigned long)lengths[testnum], &idea_ks,
2212 print_result(D_CBC_IDEA, testnum, count, d);
2216 #ifndef OPENSSL_NO_SEED
2217 if (doit[D_CBC_SEED]) {
2218 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2219 print_message(names[D_CBC_SEED], c[D_CBC_SEED][testnum], lengths[testnum]);
2220 if (async_jobs > 0) {
2221 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2225 for (count = 0, run = 1; COND(c[D_CBC_SEED][testnum]); count++)
2226 SEED_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2227 (unsigned long)lengths[testnum], &seed_ks, iv, 1);
2229 print_result(D_CBC_SEED, testnum, count, d);
2233 #ifndef OPENSSL_NO_RC2
2234 if (doit[D_CBC_RC2]) {
2235 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2236 print_message(names[D_CBC_RC2], c[D_CBC_RC2][testnum], lengths[testnum]);
2237 if (async_jobs > 0) {
2238 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2242 for (count = 0, run = 1; COND(c[D_CBC_RC2][testnum]); count++)
2243 RC2_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2244 (unsigned long)lengths[testnum], &rc2_ks,
2247 print_result(D_CBC_RC2, testnum, count, d);
2251 #ifndef OPENSSL_NO_RC5
2252 if (doit[D_CBC_RC5]) {
2253 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2254 print_message(names[D_CBC_RC5], c[D_CBC_RC5][testnum], lengths[testnum]);
2255 if (async_jobs > 0) {
2256 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2260 for (count = 0, run = 1; COND(c[D_CBC_RC5][testnum]); count++)
2261 RC5_32_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2262 (unsigned long)lengths[testnum], &rc5_ks,
2265 print_result(D_CBC_RC5, testnum, count, d);
2269 #ifndef OPENSSL_NO_BF
2270 if (doit[D_CBC_BF]) {
2271 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2272 print_message(names[D_CBC_BF], c[D_CBC_BF][testnum], lengths[testnum]);
2273 if (async_jobs > 0) {
2274 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2278 for (count = 0, run = 1; COND(c[D_CBC_BF][testnum]); count++)
2279 BF_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2280 (unsigned long)lengths[testnum], &bf_ks,
2283 print_result(D_CBC_BF, testnum, count, d);
2287 #ifndef OPENSSL_NO_CAST
2288 if (doit[D_CBC_CAST]) {
2289 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2290 print_message(names[D_CBC_CAST], c[D_CBC_CAST][testnum], lengths[testnum]);
2291 if (async_jobs > 0) {
2292 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2296 for (count = 0, run = 1; COND(c[D_CBC_CAST][testnum]); count++)
2297 CAST_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2298 (unsigned long)lengths[testnum], &cast_ks,
2301 print_result(D_CBC_CAST, testnum, count, d);
2307 #ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
2308 if (multiblock && evp_cipher) {
2310 (EVP_CIPHER_flags(evp_cipher) &
2311 EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
2312 BIO_printf(bio_err, "%s is not multi-block capable\n",
2313 OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher)));
2316 if (async_jobs > 0) {
2317 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2320 multiblock_speed(evp_cipher);
2325 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2328 names[D_EVP] = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
2330 * -O3 -fschedule-insns messes up an optimization here!
2331 * names[D_EVP] somehow becomes NULL
2333 print_message(names[D_EVP], save_count, lengths[testnum]);
2335 for (k = 0; k < loopargs_len; k++) {
2336 loopargs[k].ctx = EVP_CIPHER_CTX_new();
2338 EVP_DecryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
2340 EVP_EncryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
2341 EVP_CIPHER_CTX_set_padding(loopargs[k].ctx, 0);
2345 count = run_benchmark(async_jobs, EVP_Update_loop, loopargs);
2347 for (k = 0; k < loopargs_len; k++) {
2348 EVP_CIPHER_CTX_free(loopargs[k].ctx);
2352 names[D_EVP] = OBJ_nid2ln(EVP_MD_type(evp_md));
2353 print_message(names[D_EVP], save_count, lengths[testnum]);
2355 count = run_benchmark(async_jobs, EVP_Digest_loop, loopargs);
2358 print_result(D_EVP, testnum, count, d);
2362 for (i = 0; i < loopargs_len; i++)
2363 RAND_bytes(loopargs[i].buf, 36);
2365 #ifndef OPENSSL_NO_RSA
2366 for (testnum = 0; testnum < RSA_NUM; testnum++) {
2368 if (!rsa_doit[testnum])
2370 for (i = 0; i < loopargs_len; i++) {
2371 st = RSA_sign(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2372 loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2378 "RSA sign failure. No RSA sign will be done.\n");
2379 ERR_print_errors(bio_err);
2382 pkey_print_message("private", "rsa",
2383 rsa_c[testnum][0], rsa_bits[testnum], RSA_SECONDS);
2384 /* RSA_blinding_on(rsa_key[testnum],NULL); */
2386 count = run_benchmark(async_jobs, RSA_sign_loop, loopargs);
2389 mr ? "+R1:%ld:%d:%.2f\n"
2390 : "%ld %d bit private RSA's in %.2fs\n",
2391 count, rsa_bits[testnum], d);
2392 rsa_results[testnum][0] = d / (double)count;
2396 for (i = 0; i < loopargs_len; i++) {
2397 st = RSA_verify(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2398 *(loopargs[i].siglen), loopargs[i].rsa_key[testnum]);
2404 "RSA verify failure. No RSA verify will be done.\n");
2405 ERR_print_errors(bio_err);
2406 rsa_doit[testnum] = 0;
2408 pkey_print_message("public", "rsa",
2409 rsa_c[testnum][1], rsa_bits[testnum], RSA_SECONDS);
2411 count = run_benchmark(async_jobs, RSA_verify_loop, loopargs);
2414 mr ? "+R2:%ld:%d:%.2f\n"
2415 : "%ld %d bit public RSA's in %.2fs\n",
2416 count, rsa_bits[testnum], d);
2417 rsa_results[testnum][1] = d / (double)count;
2420 if (rsa_count <= 1) {
2421 /* if longer than 10s, don't do any more */
2422 for (testnum++; testnum < RSA_NUM; testnum++)
2423 rsa_doit[testnum] = 0;
2428 for (i = 0; i < loopargs_len; i++)
2429 RAND_bytes(loopargs[i].buf, 36);
2431 #ifndef OPENSSL_NO_DSA
2432 if (RAND_status() != 1) {
2433 RAND_seed(rnd_seed, sizeof rnd_seed);
2436 for (testnum = 0; testnum < DSA_NUM; testnum++) {
2438 if (!dsa_doit[testnum])
2441 /* DSA_generate_key(dsa_key[testnum]); */
2442 /* DSA_sign_setup(dsa_key[testnum],NULL); */
2443 for (i = 0; i < loopargs_len; i++) {
2444 st = DSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2445 loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2451 "DSA sign failure. No DSA sign will be done.\n");
2452 ERR_print_errors(bio_err);
2455 pkey_print_message("sign", "dsa",
2456 dsa_c[testnum][0], dsa_bits[testnum], DSA_SECONDS);
2458 count = run_benchmark(async_jobs, DSA_sign_loop, loopargs);
2461 mr ? "+R3:%ld:%d:%.2f\n"
2462 : "%ld %d bit DSA signs in %.2fs\n",
2463 count, dsa_bits[testnum], d);
2464 dsa_results[testnum][0] = d / (double)count;
2468 for (i = 0; i < loopargs_len; i++) {
2469 st = DSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2470 *(loopargs[i].siglen), loopargs[i].dsa_key[testnum]);
2476 "DSA verify failure. No DSA verify will be done.\n");
2477 ERR_print_errors(bio_err);
2478 dsa_doit[testnum] = 0;
2480 pkey_print_message("verify", "dsa",
2481 dsa_c[testnum][1], dsa_bits[testnum], DSA_SECONDS);
2483 count = run_benchmark(async_jobs, DSA_verify_loop, loopargs);
2486 mr ? "+R4:%ld:%d:%.2f\n"
2487 : "%ld %d bit DSA verify in %.2fs\n",
2488 count, dsa_bits[testnum], d);
2489 dsa_results[testnum][1] = d / (double)count;
2492 if (rsa_count <= 1) {
2493 /* if longer than 10s, don't do any more */
2494 for (testnum++; testnum < DSA_NUM; testnum++)
2495 dsa_doit[testnum] = 0;
2502 #ifndef OPENSSL_NO_EC
2503 if (RAND_status() != 1) {
2504 RAND_seed(rnd_seed, sizeof rnd_seed);
2507 for (testnum = 0; testnum < EC_NUM; testnum++) {
2510 if (!ecdsa_doit[testnum])
2511 continue; /* Ignore Curve */
2512 for (i = 0; i < loopargs_len; i++) {
2513 loopargs[i].ecdsa[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2514 if (loopargs[i].ecdsa[testnum] == NULL) {
2520 BIO_printf(bio_err, "ECDSA failure.\n");
2521 ERR_print_errors(bio_err);
2524 for (i = 0; i < loopargs_len; i++) {
2525 EC_KEY_precompute_mult(loopargs[i].ecdsa[testnum], NULL);
2526 /* Perform ECDSA signature test */
2527 EC_KEY_generate_key(loopargs[i].ecdsa[testnum]);
2528 st = ECDSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2529 loopargs[i].siglen, loopargs[i].ecdsa[testnum]);
2535 "ECDSA sign failure. No ECDSA sign will be done.\n");
2536 ERR_print_errors(bio_err);
2539 pkey_print_message("sign", "ecdsa",
2540 ecdsa_c[testnum][0],
2541 test_curves_bits[testnum], ECDSA_SECONDS);
2543 count = run_benchmark(async_jobs, ECDSA_sign_loop, loopargs);
2547 mr ? "+R5:%ld:%d:%.2f\n" :
2548 "%ld %d bit ECDSA signs in %.2fs \n",
2549 count, test_curves_bits[testnum], d);
2550 ecdsa_results[testnum][0] = d / (double)count;
2554 /* Perform ECDSA verification test */
2555 for (i = 0; i < loopargs_len; i++) {
2556 st = ECDSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2557 *(loopargs[i].siglen), loopargs[i].ecdsa[testnum]);
2563 "ECDSA verify failure. No ECDSA verify will be done.\n");
2564 ERR_print_errors(bio_err);
2565 ecdsa_doit[testnum] = 0;
2567 pkey_print_message("verify", "ecdsa",
2568 ecdsa_c[testnum][1],
2569 test_curves_bits[testnum], ECDSA_SECONDS);
2571 count = run_benchmark(async_jobs, ECDSA_verify_loop, loopargs);
2574 mr ? "+R6:%ld:%d:%.2f\n"
2575 : "%ld %d bit ECDSA verify in %.2fs\n",
2576 count, test_curves_bits[testnum], d);
2577 ecdsa_results[testnum][1] = d / (double)count;
2580 if (rsa_count <= 1) {
2581 /* if longer than 10s, don't do any more */
2582 for (testnum++; testnum < EC_NUM; testnum++)
2583 ecdsa_doit[testnum] = 0;
2591 #ifndef OPENSSL_NO_EC
2592 if (RAND_status() != 1) {
2593 RAND_seed(rnd_seed, sizeof rnd_seed);
2596 for (testnum = 0; testnum < EC_NUM; testnum++) {
2597 if (!ecdh_doit[testnum])
2599 for (i = 0; i < loopargs_len; i++) {
2600 loopargs[i].ecdh_a[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2601 loopargs[i].ecdh_b[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2602 if (loopargs[i].ecdh_a[testnum] == NULL ||
2603 loopargs[i].ecdh_b[testnum] == NULL) {
2608 if (ecdh_checks == 0) {
2609 BIO_printf(bio_err, "ECDH failure.\n");
2610 ERR_print_errors(bio_err);
2613 for (i = 0; i < loopargs_len; i++) {
2614 /* generate two ECDH key pairs */
2615 if (!EC_KEY_generate_key(loopargs[i].ecdh_a[testnum]) ||
2616 !EC_KEY_generate_key(loopargs[i].ecdh_b[testnum])) {
2617 BIO_printf(bio_err, "ECDH key generation failure.\n");
2618 ERR_print_errors(bio_err);
2623 * If field size is not more than 24 octets, then use SHA-1
2624 * hash of result; otherwise, use result (see section 4.8 of
2625 * draft-ietf-tls-ecc-03.txt).
2629 EC_GROUP_get_degree(EC_KEY_get0_group(loopargs[i].ecdh_a[testnum]));
2630 if (field_size <= 24 * 8) {
2631 outlen = KDF1_SHA1_len;
2634 outlen = (field_size + 7) / 8;
2638 ECDH_compute_key(loopargs[i].secret_a, outlen,
2639 EC_KEY_get0_public_key(loopargs[i].ecdh_b[testnum]),
2640 loopargs[i].ecdh_a[testnum], kdf);
2642 ECDH_compute_key(loopargs[i].secret_b, outlen,
2643 EC_KEY_get0_public_key(loopargs[i].ecdh_a[testnum]),
2644 loopargs[i].ecdh_b[testnum], kdf);
2645 if (secret_size_a != secret_size_b)
2650 for (secret_idx = 0; (secret_idx < secret_size_a)
2651 && (ecdh_checks == 1); secret_idx++) {
2652 if (loopargs[i].secret_a[secret_idx] != loopargs[i].secret_b[secret_idx])
2656 if (ecdh_checks == 0) {
2657 BIO_printf(bio_err, "ECDH computations don't match.\n");
2658 ERR_print_errors(bio_err);
2663 if (ecdh_checks != 0) {
2664 pkey_print_message("", "ecdh",
2666 test_curves_bits[testnum], ECDH_SECONDS);
2668 count = run_benchmark(async_jobs, ECDH_compute_key_loop, loopargs);
2671 mr ? "+R7:%ld:%d:%.2f\n" :
2672 "%ld %d-bit ECDH ops in %.2fs\n", count,
2673 test_curves_bits[testnum], d);
2674 ecdh_results[testnum][0] = d / (double)count;
2680 if (rsa_count <= 1) {
2681 /* if longer than 10s, don't do any more */
2682 for (testnum++; testnum < EC_NUM; testnum++)
2683 ecdh_doit[testnum] = 0;
2693 printf("%s\n", OpenSSL_version(OPENSSL_VERSION));
2694 printf("%s\n", OpenSSL_version(OPENSSL_BUILT_ON));
2696 printf("%s ", BN_options());
2697 #ifndef OPENSSL_NO_MD2
2698 printf("%s ", MD2_options());
2700 #ifndef OPENSSL_NO_RC4
2701 printf("%s ", RC4_options());
2703 #ifndef OPENSSL_NO_DES
2704 printf("%s ", DES_options());
2706 #ifndef OPENSSL_NO_AES
2707 printf("%s ", AES_options());
2709 #ifndef OPENSSL_NO_IDEA
2710 printf("%s ", idea_options());
2712 #ifndef OPENSSL_NO_BF
2713 printf("%s ", BF_options());
2715 printf("\n%s\n", OpenSSL_version(OPENSSL_CFLAGS));
2723 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2726 for (testnum = 0; testnum < SIZE_NUM; testnum++)
2727 printf(mr ? ":%d" : "%7d bytes", lengths[testnum]);
2731 for (k = 0; k < ALGOR_NUM; k++) {
2735 printf("+F:%d:%s", k, names[k]);
2737 printf("%-13s", names[k]);
2738 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2739 if (results[k][testnum] > 10000 && !mr)
2740 printf(" %11.2fk", results[k][testnum] / 1e3);
2742 printf(mr ? ":%.2f" : " %11.2f ", results[k][testnum]);
2746 #ifndef OPENSSL_NO_RSA
2748 for (k = 0; k < RSA_NUM; k++) {
2751 if (testnum && !mr) {
2752 printf("%18ssign verify sign/s verify/s\n", " ");
2756 printf("+F2:%u:%u:%f:%f\n",
2757 k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2759 printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2760 rsa_bits[k], rsa_results[k][0], rsa_results[k][1],
2761 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]);
2764 #ifndef OPENSSL_NO_DSA
2766 for (k = 0; k < DSA_NUM; k++) {
2769 if (testnum && !mr) {
2770 printf("%18ssign verify sign/s verify/s\n", " ");
2774 printf("+F3:%u:%u:%f:%f\n",
2775 k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2777 printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2778 dsa_bits[k], dsa_results[k][0], dsa_results[k][1],
2779 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]);
2782 #ifndef OPENSSL_NO_EC
2784 for (k = 0; k < EC_NUM; k++) {
2787 if (testnum && !mr) {
2788 printf("%30ssign verify sign/s verify/s\n", " ");
2793 printf("+F4:%u:%u:%f:%f\n",
2794 k, test_curves_bits[k],
2795 ecdsa_results[k][0], ecdsa_results[k][1]);
2797 printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2798 test_curves_bits[k],
2799 test_curves_names[k],
2800 ecdsa_results[k][0], ecdsa_results[k][1],
2801 1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
2805 #ifndef OPENSSL_NO_EC
2807 for (k = 0; k < EC_NUM; k++) {
2810 if (testnum && !mr) {
2811 printf("%30sop op/s\n", " ");
2815 printf("+F5:%u:%u:%f:%f\n",
2816 k, test_curves_bits[k],
2817 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2820 printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2821 test_curves_bits[k],
2822 test_curves_names[k],
2823 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2830 ERR_print_errors(bio_err);
2831 for (i = 0; i < loopargs_len; i++) {
2832 OPENSSL_free(loopargs[i].buf_malloc);
2833 OPENSSL_free(loopargs[i].buf2_malloc);
2834 OPENSSL_free(loopargs[i].siglen);
2836 #ifndef OPENSSL_NO_RSA
2837 for (i = 0; i < loopargs_len; i++) {
2838 for (k = 0; k < RSA_NUM; k++)
2839 RSA_free(loopargs[i].rsa_key[k]);
2842 #ifndef OPENSSL_NO_DSA
2843 for (i = 0; i < loopargs_len; i++) {
2844 for (k = 0; k < DSA_NUM; k++)
2845 DSA_free(loopargs[i].dsa_key[k]);
2849 #ifndef OPENSSL_NO_EC
2850 for (i = 0; i < loopargs_len; i++) {
2851 for (k = 0; k < EC_NUM; k++) {
2852 EC_KEY_free(loopargs[i].ecdsa[k]);
2853 EC_KEY_free(loopargs[i].ecdh_a[k]);
2854 EC_KEY_free(loopargs[i].ecdh_b[k]);
2856 OPENSSL_free(loopargs[i].secret_a);
2857 OPENSSL_free(loopargs[i].secret_b);
2860 if (async_jobs > 0) {
2861 for (i = 0; i < loopargs_len; i++)
2862 ASYNC_WAIT_CTX_free(loopargs[i].wait_ctx);
2864 ASYNC_cleanup_thread();
2866 OPENSSL_free(loopargs);
2870 static void print_message(const char *s, long num, int length)
2874 mr ? "+DT:%s:%d:%d\n"
2875 : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length);
2876 (void)BIO_flush(bio_err);
2880 mr ? "+DN:%s:%ld:%d\n"
2881 : "Doing %s %ld times on %d size blocks: ", s, num, length);
2882 (void)BIO_flush(bio_err);
2886 static void pkey_print_message(const char *str, const char *str2, long num,
2891 mr ? "+DTP:%d:%s:%s:%d\n"
2892 : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
2893 (void)BIO_flush(bio_err);
2897 mr ? "+DNP:%ld:%d:%s:%s\n"
2898 : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
2899 (void)BIO_flush(bio_err);
2903 static void print_result(int alg, int run_no, int count, double time_used)
2906 mr ? "+R:%d:%s:%f\n"
2907 : "%d %s's in %.2fs\n", count, names[alg], time_used);
2908 results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
2912 static char *sstrsep(char **string, const char *delim)
2915 char *token = *string;
2920 memset(isdelim, 0, sizeof isdelim);
2924 isdelim[(unsigned char)(*delim)] = 1;
2928 while (!isdelim[(unsigned char)(**string)]) {
2940 static int do_multi(int multi)
2945 static char sep[] = ":";
2947 fds = malloc(sizeof(*fds) * multi);
2948 for (n = 0; n < multi; ++n) {
2949 if (pipe(fd) == -1) {
2950 BIO_printf(bio_err, "pipe failure\n");
2954 (void)BIO_flush(bio_err);
2961 if (dup(fd[1]) == -1) {
2962 BIO_printf(bio_err, "dup failed\n");
2971 printf("Forked child %d\n", n);
2974 /* for now, assume the pipe is long enough to take all the output */
2975 for (n = 0; n < multi; ++n) {
2980 f = fdopen(fds[n], "r");
2981 while (fgets(buf, sizeof buf, f)) {
2982 p = strchr(buf, '\n');
2985 if (buf[0] != '+') {
2986 BIO_printf(bio_err, "Don't understand line '%s' from child %d\n",
2990 printf("Got: %s from %d\n", buf, n);
2991 if (strncmp(buf, "+F:", 3) == 0) {
2996 alg = atoi(sstrsep(&p, sep));
2998 for (j = 0; j < SIZE_NUM; ++j)
2999 results[alg][j] += atof(sstrsep(&p, sep));
3000 } else if (strncmp(buf, "+F2:", 4) == 0) {
3005 k = atoi(sstrsep(&p, sep));
3008 d = atof(sstrsep(&p, sep));
3010 rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
3012 rsa_results[k][0] = d;
3014 d = atof(sstrsep(&p, sep));
3016 rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
3018 rsa_results[k][1] = d;
3020 # ifndef OPENSSL_NO_DSA
3021 else if (strncmp(buf, "+F3:", 4) == 0) {
3026 k = atoi(sstrsep(&p, sep));
3029 d = atof(sstrsep(&p, sep));
3031 dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d);
3033 dsa_results[k][0] = d;
3035 d = atof(sstrsep(&p, sep));
3037 dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d);
3039 dsa_results[k][1] = d;
3042 # ifndef OPENSSL_NO_EC
3043 else if (strncmp(buf, "+F4:", 4) == 0) {
3048 k = atoi(sstrsep(&p, sep));
3051 d = atof(sstrsep(&p, sep));
3053 ecdsa_results[k][0] =
3054 1 / (1 / ecdsa_results[k][0] + 1 / d);
3056 ecdsa_results[k][0] = d;
3058 d = atof(sstrsep(&p, sep));
3060 ecdsa_results[k][1] =
3061 1 / (1 / ecdsa_results[k][1] + 1 / d);
3063 ecdsa_results[k][1] = d;
3067 # ifndef OPENSSL_NO_EC
3068 else if (strncmp(buf, "+F5:", 4) == 0) {
3073 k = atoi(sstrsep(&p, sep));
3076 d = atof(sstrsep(&p, sep));
3078 ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
3080 ecdh_results[k][0] = d;
3085 else if (strncmp(buf, "+H:", 3) == 0) {
3088 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf, n);
3098 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
3100 static int mblengths[] =
3101 { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
3102 int j, count, num = OSSL_NELEM(mblengths);
3103 const char *alg_name;
3104 unsigned char *inp, *out, no_key[32], no_iv[16];
3105 EVP_CIPHER_CTX *ctx;
3108 inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
3109 out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
3110 ctx = EVP_CIPHER_CTX_new();
3111 EVP_EncryptInit_ex(ctx, evp_cipher, NULL, no_key, no_iv);
3112 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key),
3114 alg_name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
3116 for (j = 0; j < num; j++) {
3117 print_message(alg_name, 0, mblengths[j]);
3119 for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
3120 unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
3121 EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
3122 size_t len = mblengths[j];
3125 memset(aad, 0, 8); /* avoid uninitialized values */
3126 aad[8] = 23; /* SSL3_RT_APPLICATION_DATA */
3127 aad[9] = 3; /* version */
3129 aad[11] = 0; /* length */
3131 mb_param.out = NULL;
3134 mb_param.interleave = 8;
3136 packlen = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
3137 sizeof(mb_param), &mb_param);
3143 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
3144 sizeof(mb_param), &mb_param);
3148 RAND_bytes(out, 16);
3152 pad = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_TLS1_AAD,
3153 EVP_AEAD_TLS1_AAD_LEN, aad);
3154 EVP_Cipher(ctx, out, inp, len + pad);
3158 BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
3159 : "%d %s's in %.2fs\n", count, "evp", d);
3160 results[D_EVP][j] = ((double)count) / d * mblengths[j];
3164 fprintf(stdout, "+H");
3165 for (j = 0; j < num; j++)
3166 fprintf(stdout, ":%d", mblengths[j]);
3167 fprintf(stdout, "\n");
3168 fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
3169 for (j = 0; j < num; j++)
3170 fprintf(stdout, ":%.2f", results[D_EVP][j]);
3171 fprintf(stdout, "\n");
3174 "The 'numbers' are in 1000s of bytes per second processed.\n");
3175 fprintf(stdout, "type ");
3176 for (j = 0; j < num; j++)
3177 fprintf(stdout, "%7d bytes", mblengths[j]);
3178 fprintf(stdout, "\n");
3179 fprintf(stdout, "%-24s", alg_name);
3181 for (j = 0; j < num; j++) {
3182 if (results[D_EVP][j] > 10000)
3183 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
3185 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
3187 fprintf(stdout, "\n");
3192 EVP_CIPHER_CTX_free(ctx);