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(ASYNC_SYS_WINDOWS)
1155 #elif defined(ASYNC_SYS_UNIX)
1156 int select_result = 0;
1157 OSSL_ASYNC_FD max_fd = 0;
1159 FD_ZERO(&waitfdset);
1161 for (i = 0; i < async_jobs && num_inprogress > 0; i++) {
1162 if (loopargs[i].inprogress_job == NULL)
1165 if (!ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, NULL, &num_job_fds)
1166 || num_job_fds > 1) {
1167 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1168 ERR_print_errors(bio_err);
1172 ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd, &num_job_fds);
1173 FD_SET(job_fd, &waitfdset);
1174 if (job_fd > max_fd)
1178 select_result = select(max_fd + 1, &waitfdset, NULL, NULL, NULL);
1179 if (select_result == -1 && errno == EINTR)
1182 if (select_result == -1) {
1183 BIO_printf(bio_err, "Failure in the select\n");
1184 ERR_print_errors(bio_err);
1189 if (select_result == 0)
1193 for (i = 0; i < async_jobs; i++) {
1194 if (loopargs[i].inprogress_job == NULL)
1197 if (!ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, NULL, &num_job_fds)
1198 || num_job_fds > 1) {
1199 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1200 ERR_print_errors(bio_err);
1204 ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd, &num_job_fds);
1206 #if defined(OPENSSL_SYS_UNIX)
1207 if (num_job_fds == 1 && !FD_ISSET(job_fd, &waitfdset))
1209 #elif defined(OPENSSL_SYS_WINDOWS)
1210 if (num_job_fds == 1 &&
1211 !PeekNamedPipe(job_fd, NULL, 0, NULL, &avail, NULL) && avail > 0)
1215 switch (ASYNC_start_job(&(loopargs[i].inprogress_job), loopargs[i].wait_ctx,
1216 &job_op_count, loop_function, (void *)(loopargs + i),
1217 sizeof(loopargs_t))) {
1221 if (job_op_count == -1) {
1224 total_op_count += job_op_count;
1227 loopargs[i].inprogress_job = NULL;
1232 loopargs[i].inprogress_job = NULL;
1233 BIO_printf(bio_err, "Failure in the job\n");
1234 ERR_print_errors(bio_err);
1241 return error ? -1 : total_op_count;
1244 int speed_main(int argc, char **argv)
1246 loopargs_t *loopargs = NULL;
1247 int loopargs_len = 0;
1249 const EVP_CIPHER *evp_cipher = NULL;
1252 int multiblock = 0, doit[ALGOR_NUM], pr_header = 0;
1253 int dsa_doit[DSA_NUM], rsa_doit[RSA_NUM];
1254 int ret = 1, i, k, misalign = 0;
1255 long c[ALGOR_NUM][SIZE_NUM], count = 0, save_count = 0;
1260 /* What follows are the buffers and key material. */
1261 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA)
1264 #ifndef OPENSSL_NO_RC5
1267 #ifndef OPENSSL_NO_RC2
1270 #ifndef OPENSSL_NO_IDEA
1271 IDEA_KEY_SCHEDULE idea_ks;
1273 #ifndef OPENSSL_NO_SEED
1274 SEED_KEY_SCHEDULE seed_ks;
1276 #ifndef OPENSSL_NO_BF
1279 #ifndef OPENSSL_NO_CAST
1282 static const unsigned char key16[16] = {
1283 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1284 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1286 #ifndef OPENSSL_NO_AES
1287 static const unsigned char key24[24] = {
1288 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1289 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1290 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1292 static const unsigned char key32[32] = {
1293 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1294 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1295 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1296 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1299 #ifndef OPENSSL_NO_CAMELLIA
1300 static const unsigned char ckey24[24] = {
1301 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1302 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1303 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1305 static const unsigned char ckey32[32] = {
1306 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1307 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1308 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1309 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1311 CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
1313 #ifndef OPENSSL_NO_DES
1314 static DES_cblock key = {
1315 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
1317 static DES_cblock key2 = {
1318 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1320 static DES_cblock key3 = {
1321 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1324 #ifndef OPENSSL_NO_RSA
1325 static unsigned int rsa_bits[RSA_NUM] = {
1326 512, 1024, 2048, 3072, 4096, 7680, 15360
1328 static unsigned char *rsa_data[RSA_NUM] = {
1329 test512, test1024, test2048, test3072, test4096, test7680, test15360
1331 static int rsa_data_length[RSA_NUM] = {
1332 sizeof(test512), sizeof(test1024),
1333 sizeof(test2048), sizeof(test3072),
1334 sizeof(test4096), sizeof(test7680),
1338 #ifndef OPENSSL_NO_DSA
1339 static unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
1341 #ifndef OPENSSL_NO_EC
1343 * We only test over the following curves as they are representative, To
1344 * add tests over more curves, simply add the curve NID and curve name to
1345 * the following arrays and increase the EC_NUM value accordingly.
1347 static unsigned int test_curves[EC_NUM] = {
1349 NID_secp160r1, NID_X9_62_prime192v1, NID_secp224r1,
1350 NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
1352 NID_sect163k1, NID_sect233k1, NID_sect283k1,
1353 NID_sect409k1, NID_sect571k1, NID_sect163r2,
1354 NID_sect233r1, NID_sect283r1, NID_sect409r1,
1359 static const char *test_curves_names[EC_NUM] = {
1361 "secp160r1", "nistp192", "nistp224",
1362 "nistp256", "nistp384", "nistp521",
1364 "nistk163", "nistk233", "nistk283",
1365 "nistk409", "nistk571", "nistb163",
1366 "nistb233", "nistb283", "nistb409",
1371 static int test_curves_bits[EC_NUM] = {
1377 571, 253 /* X25519 */
1380 #ifndef OPENSSL_NO_EC
1381 int ecdsa_doit[EC_NUM];
1382 int secret_size_a, secret_size_b;
1383 int ecdh_checks = 1;
1385 long ecdh_c[EC_NUM][2];
1386 int ecdh_doit[EC_NUM];
1389 memset(results, 0, sizeof(results));
1391 memset(c, 0, sizeof(c));
1392 memset(DES_iv, 0, sizeof(DES_iv));
1393 memset(iv, 0, sizeof(iv));
1395 for (i = 0; i < ALGOR_NUM; i++)
1397 for (i = 0; i < RSA_NUM; i++)
1399 for (i = 0; i < DSA_NUM; i++)
1401 #ifndef OPENSSL_NO_EC
1402 for (i = 0; i < EC_NUM; i++)
1404 for (i = 0; i < EC_NUM; i++)
1410 prog = opt_init(argc, argv, speed_options);
1411 while ((o = opt_next()) != OPT_EOF) {
1416 BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
1419 opt_help(speed_options);
1426 evp_cipher = EVP_get_cipherbyname(opt_arg());
1427 if (evp_cipher == NULL)
1428 evp_md = EVP_get_digestbyname(opt_arg());
1429 if (evp_cipher == NULL && evp_md == NULL) {
1431 "%s: %s an unknown cipher or digest\n",
1442 * In a forked execution, an engine might need to be
1443 * initialised by each child process, not by the parent.
1444 * So store the name here and run setup_engine() later on.
1446 engine_id = opt_arg();
1450 multi = atoi(opt_arg());
1454 #ifndef OPENSSL_NO_ASYNC
1455 async_jobs = atoi(opt_arg());
1456 if (!ASYNC_is_capable()) {
1458 "%s: async_jobs specified but async not supported\n",
1465 if (!opt_int(opt_arg(), &misalign))
1467 if (misalign > MISALIGN) {
1469 "%s: Maximum offset is %d\n", prog, MISALIGN);
1481 argc = opt_num_rest();
1484 /* Remaining arguments are algorithms. */
1485 for ( ; *argv; argv++) {
1486 if (found(*argv, doit_choices, &i)) {
1490 #ifndef OPENSSL_NO_DES
1491 if (strcmp(*argv, "des") == 0) {
1492 doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
1496 if (strcmp(*argv, "sha") == 0) {
1497 doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
1500 #ifndef OPENSSL_NO_RSA
1502 if (strcmp(*argv, "openssl") == 0) {
1503 RSA_set_default_method(RSA_PKCS1_OpenSSL());
1507 if (strcmp(*argv, "rsa") == 0) {
1508 rsa_doit[R_RSA_512] = rsa_doit[R_RSA_1024] =
1509 rsa_doit[R_RSA_2048] = rsa_doit[R_RSA_3072] =
1510 rsa_doit[R_RSA_4096] = rsa_doit[R_RSA_7680] =
1511 rsa_doit[R_RSA_15360] = 1;
1514 if (found(*argv, rsa_choices, &i)) {
1519 #ifndef OPENSSL_NO_DSA
1520 if (strcmp(*argv, "dsa") == 0) {
1521 dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
1522 dsa_doit[R_DSA_2048] = 1;
1525 if (found(*argv, dsa_choices, &i)) {
1530 #ifndef OPENSSL_NO_AES
1531 if (strcmp(*argv, "aes") == 0) {
1532 doit[D_CBC_128_AES] = doit[D_CBC_192_AES] =
1533 doit[D_CBC_256_AES] = 1;
1537 #ifndef OPENSSL_NO_CAMELLIA
1538 if (strcmp(*argv, "camellia") == 0) {
1539 doit[D_CBC_128_CML] = doit[D_CBC_192_CML] =
1540 doit[D_CBC_256_CML] = 1;
1544 #ifndef OPENSSL_NO_EC
1545 if (strcmp(*argv, "ecdsa") == 0) {
1546 for (i = 0; i < EC_NUM; i++)
1550 if (found(*argv, ecdsa_choices, &i)) {
1554 if (strcmp(*argv, "ecdh") == 0) {
1555 for (i = 0; i < EC_NUM; i++)
1559 if (found(*argv, ecdh_choices, &i)) {
1564 BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
1568 /* Initialize the job pool if async mode is enabled */
1569 if (async_jobs > 0) {
1570 if (!ASYNC_init_thread(async_jobs, async_jobs)) {
1571 BIO_printf(bio_err, "Error creating the ASYNC job pool\n");
1576 loopargs_len = (async_jobs == 0 ? 1 : async_jobs);
1577 loopargs = app_malloc(loopargs_len * sizeof(loopargs_t), "array of loopargs");
1578 memset(loopargs, 0, loopargs_len * sizeof(loopargs_t));
1580 for (i = 0; i < loopargs_len; i++) {
1581 if (async_jobs > 0) {
1582 loopargs[i].wait_ctx = ASYNC_WAIT_CTX_new();
1583 if (loopargs[i].wait_ctx == NULL) {
1584 BIO_printf(bio_err, "Error creating the ASYNC_WAIT_CTX\n");
1589 loopargs[i].buf_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1590 loopargs[i].buf2_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1591 /* Align the start of buffers on a 64 byte boundary */
1592 loopargs[i].buf = loopargs[i].buf_malloc + misalign;
1593 loopargs[i].buf2 = loopargs[i].buf2_malloc + misalign;
1594 loopargs[i].siglen = app_malloc(sizeof(unsigned int), "signature length");
1595 #ifndef OPENSSL_NO_EC
1596 loopargs[i].secret_a = app_malloc(MAX_ECDH_SIZE, "ECDH secret a");
1597 loopargs[i].secret_b = app_malloc(MAX_ECDH_SIZE, "ECDH secret b");
1602 if (multi && do_multi(multi))
1606 /* Initialize the engine after the fork */
1607 (void)setup_engine(engine_id, 0);
1609 /* No parameters; turn on everything. */
1610 if ((argc == 0) && !doit[D_EVP]) {
1611 for (i = 0; i < ALGOR_NUM; i++)
1614 for (i = 0; i < RSA_NUM; i++)
1616 for (i = 0; i < DSA_NUM; i++)
1618 #ifndef OPENSSL_NO_EC
1619 for (i = 0; i < EC_NUM; i++)
1621 for (i = 0; i < EC_NUM; i++)
1625 for (i = 0; i < ALGOR_NUM; i++)
1629 if (usertime == 0 && !mr)
1631 "You have chosen to measure elapsed time "
1632 "instead of user CPU time.\n");
1634 #ifndef OPENSSL_NO_RSA
1635 for (i = 0; i < loopargs_len; i++) {
1636 for (k = 0; k < RSA_NUM; k++) {
1637 const unsigned char *p;
1640 loopargs[i].rsa_key[k] = d2i_RSAPrivateKey(NULL, &p, rsa_data_length[k]);
1641 if (loopargs[i].rsa_key[k] == NULL) {
1642 BIO_printf(bio_err, "internal error loading RSA key number %d\n",
1649 #ifndef OPENSSL_NO_DSA
1650 for (i = 0; i < loopargs_len; i++) {
1651 loopargs[i].dsa_key[0] = get_dsa512();
1652 loopargs[i].dsa_key[1] = get_dsa1024();
1653 loopargs[i].dsa_key[2] = get_dsa2048();
1656 #ifndef OPENSSL_NO_DES
1657 DES_set_key_unchecked(&key, &sch);
1658 DES_set_key_unchecked(&key2, &sch2);
1659 DES_set_key_unchecked(&key3, &sch3);
1661 #ifndef OPENSSL_NO_AES
1662 AES_set_encrypt_key(key16, 128, &aes_ks1);
1663 AES_set_encrypt_key(key24, 192, &aes_ks2);
1664 AES_set_encrypt_key(key32, 256, &aes_ks3);
1666 #ifndef OPENSSL_NO_CAMELLIA
1667 Camellia_set_key(key16, 128, &camellia_ks1);
1668 Camellia_set_key(ckey24, 192, &camellia_ks2);
1669 Camellia_set_key(ckey32, 256, &camellia_ks3);
1671 #ifndef OPENSSL_NO_IDEA
1672 idea_set_encrypt_key(key16, &idea_ks);
1674 #ifndef OPENSSL_NO_SEED
1675 SEED_set_key(key16, &seed_ks);
1677 #ifndef OPENSSL_NO_RC4
1678 RC4_set_key(&rc4_ks, 16, key16);
1680 #ifndef OPENSSL_NO_RC2
1681 RC2_set_key(&rc2_ks, 16, key16, 128);
1683 #ifndef OPENSSL_NO_RC5
1684 RC5_32_set_key(&rc5_ks, 16, key16, 12);
1686 #ifndef OPENSSL_NO_BF
1687 BF_set_key(&bf_ks, 16, key16);
1689 #ifndef OPENSSL_NO_CAST
1690 CAST_set_key(&cast_ks, 16, key16);
1692 #ifndef OPENSSL_NO_RSA
1693 memset(rsa_c, 0, sizeof(rsa_c));
1696 # ifndef OPENSSL_NO_DES
1697 BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1703 for (it = count; it; it--)
1704 DES_ecb_encrypt((DES_cblock *)loopargs[0].buf,
1705 (DES_cblock *)loopargs[0].buf, &sch, DES_ENCRYPT);
1709 c[D_MD2][0] = count / 10;
1710 c[D_MDC2][0] = count / 10;
1711 c[D_MD4][0] = count;
1712 c[D_MD5][0] = count;
1713 c[D_HMAC][0] = count;
1714 c[D_SHA1][0] = count;
1715 c[D_RMD160][0] = count;
1716 c[D_RC4][0] = count * 5;
1717 c[D_CBC_DES][0] = count;
1718 c[D_EDE3_DES][0] = count / 3;
1719 c[D_CBC_IDEA][0] = count;
1720 c[D_CBC_SEED][0] = count;
1721 c[D_CBC_RC2][0] = count;
1722 c[D_CBC_RC5][0] = count;
1723 c[D_CBC_BF][0] = count;
1724 c[D_CBC_CAST][0] = count;
1725 c[D_CBC_128_AES][0] = count;
1726 c[D_CBC_192_AES][0] = count;
1727 c[D_CBC_256_AES][0] = count;
1728 c[D_CBC_128_CML][0] = count;
1729 c[D_CBC_192_CML][0] = count;
1730 c[D_CBC_256_CML][0] = count;
1731 c[D_SHA256][0] = count;
1732 c[D_SHA512][0] = count;
1733 c[D_WHIRLPOOL][0] = count;
1734 c[D_IGE_128_AES][0] = count;
1735 c[D_IGE_192_AES][0] = count;
1736 c[D_IGE_256_AES][0] = count;
1737 c[D_GHASH][0] = count;
1739 for (i = 1; i < SIZE_NUM; i++) {
1742 l0 = (long)lengths[0];
1743 l1 = (long)lengths[i];
1745 c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1746 c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1747 c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1748 c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1749 c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1750 c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1751 c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1752 c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1753 c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1754 c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1755 c[D_GHASH][i] = c[D_GHASH][0] * 4 * l0 / l1;
1757 l0 = (long)lengths[i - 1];
1759 c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1760 c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1761 c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1762 c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1763 c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1764 c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1765 c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1766 c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1767 c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1768 c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1769 c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1770 c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1771 c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1772 c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1773 c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1774 c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1775 c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1776 c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1779 # ifndef OPENSSL_NO_RSA
1780 rsa_c[R_RSA_512][0] = count / 2000;
1781 rsa_c[R_RSA_512][1] = count / 400;
1782 for (i = 1; i < RSA_NUM; i++) {
1783 rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1784 rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1785 if ((rsa_doit[i] <= 1) && (rsa_c[i][0] == 0))
1788 if (rsa_c[i][0] == 0) {
1796 # ifndef OPENSSL_NO_DSA
1797 dsa_c[R_DSA_512][0] = count / 1000;
1798 dsa_c[R_DSA_512][1] = count / 1000 / 2;
1799 for (i = 1; i < DSA_NUM; i++) {
1800 dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1801 dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1802 if ((dsa_doit[i] <= 1) && (dsa_c[i][0] == 0))
1805 if (dsa_c[i] == 0) {
1813 # ifndef OPENSSL_NO_EC
1814 ecdsa_c[R_EC_P160][0] = count / 1000;
1815 ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1816 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1817 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1818 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1819 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1822 if (ecdsa_c[i] == 0) {
1828 ecdsa_c[R_EC_K163][0] = count / 1000;
1829 ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1830 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1831 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1832 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1833 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1836 if (ecdsa_c[i] == 0) {
1842 ecdsa_c[R_EC_B163][0] = count / 1000;
1843 ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1844 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1845 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1846 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1847 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1850 if (ecdsa_c[i] == 0) {
1857 ecdh_c[R_EC_P160][0] = count / 1000;
1858 ecdh_c[R_EC_P160][1] = count / 1000;
1859 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1860 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1861 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1862 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1865 if (ecdh_c[i] == 0) {
1871 ecdh_c[R_EC_K163][0] = count / 1000;
1872 ecdh_c[R_EC_K163][1] = count / 1000;
1873 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1874 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1875 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1876 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1879 if (ecdh_c[i] == 0) {
1885 ecdh_c[R_EC_B163][0] = count / 1000;
1886 ecdh_c[R_EC_B163][1] = count / 1000;
1887 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1888 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1889 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1890 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1893 if (ecdh_c[i] == 0) {
1902 /* not worth fixing */
1903 # error "You cannot disable DES on systems without SIGALRM."
1904 # endif /* OPENSSL_NO_DES */
1907 signal(SIGALRM, sig_done);
1909 #endif /* SIGALRM */
1911 #ifndef OPENSSL_NO_MD2
1913 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1914 print_message(names[D_MD2], c[D_MD2][testnum], lengths[testnum]);
1916 count = run_benchmark(async_jobs, EVP_Digest_MD2_loop, loopargs);
1918 print_result(D_MD2, testnum, count, d);
1922 #ifndef OPENSSL_NO_MDC2
1924 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1925 print_message(names[D_MDC2], c[D_MDC2][testnum], lengths[testnum]);
1927 count = run_benchmark(async_jobs, EVP_Digest_MDC2_loop, loopargs);
1929 print_result(D_MDC2, testnum, count, d);
1934 #ifndef OPENSSL_NO_MD4
1936 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1937 print_message(names[D_MD4], c[D_MD4][testnum], lengths[testnum]);
1939 count = run_benchmark(async_jobs, EVP_Digest_MD4_loop, loopargs);
1941 print_result(D_MD4, testnum, count, d);
1946 #ifndef OPENSSL_NO_MD5
1948 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1949 print_message(names[D_MD5], c[D_MD5][testnum], lengths[testnum]);
1951 count = run_benchmark(async_jobs, MD5_loop, loopargs);
1953 print_result(D_MD5, testnum, count, d);
1958 #ifndef OPENSSL_NO_MD5
1960 for (i = 0; i < loopargs_len; i++) {
1961 loopargs[i].hctx = HMAC_CTX_new();
1962 if (loopargs[i].hctx == NULL) {
1963 BIO_printf(bio_err, "HMAC malloc failure, exiting...");
1967 HMAC_Init_ex(loopargs[i].hctx, (unsigned char *)"This is a key...",
1968 16, EVP_md5(), NULL);
1970 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1971 print_message(names[D_HMAC], c[D_HMAC][testnum], lengths[testnum]);
1973 count = run_benchmark(async_jobs, HMAC_loop, loopargs);
1975 print_result(D_HMAC, testnum, count, d);
1977 for (i = 0; i < loopargs_len; i++) {
1978 HMAC_CTX_free(loopargs[i].hctx);
1983 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1984 print_message(names[D_SHA1], c[D_SHA1][testnum], lengths[testnum]);
1986 count = run_benchmark(async_jobs, SHA1_loop, loopargs);
1988 print_result(D_SHA1, testnum, count, d);
1991 if (doit[D_SHA256]) {
1992 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1993 print_message(names[D_SHA256], c[D_SHA256][testnum], lengths[testnum]);
1995 count = run_benchmark(async_jobs, SHA256_loop, loopargs);
1997 print_result(D_SHA256, testnum, count, d);
2000 if (doit[D_SHA512]) {
2001 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2002 print_message(names[D_SHA512], c[D_SHA512][testnum], lengths[testnum]);
2004 count = run_benchmark(async_jobs, SHA512_loop, loopargs);
2006 print_result(D_SHA512, testnum, count, d);
2010 #ifndef OPENSSL_NO_WHIRLPOOL
2011 if (doit[D_WHIRLPOOL]) {
2012 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2013 print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][testnum], lengths[testnum]);
2015 count = run_benchmark(async_jobs, WHIRLPOOL_loop, loopargs);
2017 print_result(D_WHIRLPOOL, testnum, count, d);
2022 #ifndef OPENSSL_NO_RMD160
2023 if (doit[D_RMD160]) {
2024 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2025 print_message(names[D_RMD160], c[D_RMD160][testnum], lengths[testnum]);
2027 count = run_benchmark(async_jobs, EVP_Digest_RMD160_loop, loopargs);
2029 print_result(D_RMD160, testnum, count, d);
2033 #ifndef OPENSSL_NO_RC4
2035 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2036 print_message(names[D_RC4], c[D_RC4][testnum], lengths[testnum]);
2038 count = run_benchmark(async_jobs, RC4_loop, loopargs);
2040 print_result(D_RC4, testnum, count, d);
2044 #ifndef OPENSSL_NO_DES
2045 if (doit[D_CBC_DES]) {
2046 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2047 print_message(names[D_CBC_DES], c[D_CBC_DES][testnum], lengths[testnum]);
2049 count = run_benchmark(async_jobs, DES_ncbc_encrypt_loop, loopargs);
2051 print_result(D_CBC_DES, testnum, count, d);
2055 if (doit[D_EDE3_DES]) {
2056 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2057 print_message(names[D_EDE3_DES], c[D_EDE3_DES][testnum], lengths[testnum]);
2059 count = run_benchmark(async_jobs, DES_ede3_cbc_encrypt_loop, loopargs);
2061 print_result(D_EDE3_DES, testnum, count, d);
2065 #ifndef OPENSSL_NO_AES
2066 if (doit[D_CBC_128_AES]) {
2067 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2068 print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][testnum],
2071 count = run_benchmark(async_jobs, AES_cbc_128_encrypt_loop, loopargs);
2073 print_result(D_CBC_128_AES, testnum, count, d);
2076 if (doit[D_CBC_192_AES]) {
2077 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2078 print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][testnum],
2081 count = run_benchmark(async_jobs, AES_cbc_192_encrypt_loop, loopargs);
2083 print_result(D_CBC_192_AES, testnum, count, d);
2086 if (doit[D_CBC_256_AES]) {
2087 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2088 print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][testnum],
2091 count = run_benchmark(async_jobs, AES_cbc_256_encrypt_loop, loopargs);
2093 print_result(D_CBC_256_AES, testnum, count, d);
2097 if (doit[D_IGE_128_AES]) {
2098 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2099 print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][testnum],
2102 count = run_benchmark(async_jobs, AES_ige_128_encrypt_loop, loopargs);
2104 print_result(D_IGE_128_AES, testnum, count, d);
2107 if (doit[D_IGE_192_AES]) {
2108 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2109 print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][testnum],
2112 count = run_benchmark(async_jobs, AES_ige_192_encrypt_loop, loopargs);
2114 print_result(D_IGE_192_AES, testnum, count, d);
2117 if (doit[D_IGE_256_AES]) {
2118 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2119 print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][testnum],
2122 count = run_benchmark(async_jobs, AES_ige_256_encrypt_loop, loopargs);
2124 print_result(D_IGE_256_AES, testnum, count, d);
2127 if (doit[D_GHASH]) {
2128 for (i = 0; i < loopargs_len; i++) {
2129 loopargs[i].gcm_ctx = CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
2130 CRYPTO_gcm128_setiv(loopargs[i].gcm_ctx, (unsigned char *)"0123456789ab", 12);
2133 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2134 print_message(names[D_GHASH], c[D_GHASH][testnum], lengths[testnum]);
2136 count = run_benchmark(async_jobs, CRYPTO_gcm128_aad_loop, loopargs);
2138 print_result(D_GHASH, testnum, count, d);
2140 for (i = 0; i < loopargs_len; i++)
2141 CRYPTO_gcm128_release(loopargs[i].gcm_ctx);
2144 #ifndef OPENSSL_NO_CAMELLIA
2145 if (doit[D_CBC_128_CML]) {
2146 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2147 print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][testnum],
2149 if (async_jobs > 0) {
2150 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2154 for (count = 0, run = 1; COND(c[D_CBC_128_CML][testnum]); count++)
2155 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2156 (unsigned long)lengths[testnum], &camellia_ks1,
2157 iv, CAMELLIA_ENCRYPT);
2159 print_result(D_CBC_128_CML, testnum, count, d);
2162 if (doit[D_CBC_192_CML]) {
2163 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2164 print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][testnum],
2166 if (async_jobs > 0) {
2167 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2171 for (count = 0, run = 1; COND(c[D_CBC_192_CML][testnum]); count++)
2172 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2173 (unsigned long)lengths[testnum], &camellia_ks2,
2174 iv, CAMELLIA_ENCRYPT);
2176 print_result(D_CBC_192_CML, testnum, count, d);
2179 if (doit[D_CBC_256_CML]) {
2180 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2181 print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][testnum],
2183 if (async_jobs > 0) {
2184 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2188 for (count = 0, run = 1; COND(c[D_CBC_256_CML][testnum]); count++)
2189 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2190 (unsigned long)lengths[testnum], &camellia_ks3,
2191 iv, CAMELLIA_ENCRYPT);
2193 print_result(D_CBC_256_CML, testnum, count, d);
2197 #ifndef OPENSSL_NO_IDEA
2198 if (doit[D_CBC_IDEA]) {
2199 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2200 print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][testnum], lengths[testnum]);
2201 if (async_jobs > 0) {
2202 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2206 for (count = 0, run = 1; COND(c[D_CBC_IDEA][testnum]); count++)
2207 idea_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2208 (unsigned long)lengths[testnum], &idea_ks,
2211 print_result(D_CBC_IDEA, testnum, count, d);
2215 #ifndef OPENSSL_NO_SEED
2216 if (doit[D_CBC_SEED]) {
2217 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2218 print_message(names[D_CBC_SEED], c[D_CBC_SEED][testnum], lengths[testnum]);
2219 if (async_jobs > 0) {
2220 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2224 for (count = 0, run = 1; COND(c[D_CBC_SEED][testnum]); count++)
2225 SEED_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2226 (unsigned long)lengths[testnum], &seed_ks, iv, 1);
2228 print_result(D_CBC_SEED, testnum, count, d);
2232 #ifndef OPENSSL_NO_RC2
2233 if (doit[D_CBC_RC2]) {
2234 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2235 print_message(names[D_CBC_RC2], c[D_CBC_RC2][testnum], lengths[testnum]);
2236 if (async_jobs > 0) {
2237 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2241 for (count = 0, run = 1; COND(c[D_CBC_RC2][testnum]); count++)
2242 RC2_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2243 (unsigned long)lengths[testnum], &rc2_ks,
2246 print_result(D_CBC_RC2, testnum, count, d);
2250 #ifndef OPENSSL_NO_RC5
2251 if (doit[D_CBC_RC5]) {
2252 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2253 print_message(names[D_CBC_RC5], c[D_CBC_RC5][testnum], lengths[testnum]);
2254 if (async_jobs > 0) {
2255 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2259 for (count = 0, run = 1; COND(c[D_CBC_RC5][testnum]); count++)
2260 RC5_32_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2261 (unsigned long)lengths[testnum], &rc5_ks,
2264 print_result(D_CBC_RC5, testnum, count, d);
2268 #ifndef OPENSSL_NO_BF
2269 if (doit[D_CBC_BF]) {
2270 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2271 print_message(names[D_CBC_BF], c[D_CBC_BF][testnum], lengths[testnum]);
2272 if (async_jobs > 0) {
2273 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2277 for (count = 0, run = 1; COND(c[D_CBC_BF][testnum]); count++)
2278 BF_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2279 (unsigned long)lengths[testnum], &bf_ks,
2282 print_result(D_CBC_BF, testnum, count, d);
2286 #ifndef OPENSSL_NO_CAST
2287 if (doit[D_CBC_CAST]) {
2288 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2289 print_message(names[D_CBC_CAST], c[D_CBC_CAST][testnum], lengths[testnum]);
2290 if (async_jobs > 0) {
2291 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2295 for (count = 0, run = 1; COND(c[D_CBC_CAST][testnum]); count++)
2296 CAST_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2297 (unsigned long)lengths[testnum], &cast_ks,
2300 print_result(D_CBC_CAST, testnum, count, d);
2306 #ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
2307 if (multiblock && evp_cipher) {
2309 (EVP_CIPHER_flags(evp_cipher) &
2310 EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
2311 BIO_printf(bio_err, "%s is not multi-block capable\n",
2312 OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher)));
2315 if (async_jobs > 0) {
2316 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2319 multiblock_speed(evp_cipher);
2324 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2327 names[D_EVP] = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
2329 * -O3 -fschedule-insns messes up an optimization here!
2330 * names[D_EVP] somehow becomes NULL
2332 print_message(names[D_EVP], save_count, lengths[testnum]);
2334 for (k = 0; k < loopargs_len; k++) {
2335 loopargs[k].ctx = EVP_CIPHER_CTX_new();
2337 EVP_DecryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
2339 EVP_EncryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
2340 EVP_CIPHER_CTX_set_padding(loopargs[k].ctx, 0);
2344 count = run_benchmark(async_jobs, EVP_Update_loop, loopargs);
2346 for (k = 0; k < loopargs_len; k++) {
2347 EVP_CIPHER_CTX_free(loopargs[k].ctx);
2351 names[D_EVP] = OBJ_nid2ln(EVP_MD_type(evp_md));
2352 print_message(names[D_EVP], save_count, lengths[testnum]);
2354 count = run_benchmark(async_jobs, EVP_Digest_loop, loopargs);
2357 print_result(D_EVP, testnum, count, d);
2361 for (i = 0; i < loopargs_len; i++)
2362 RAND_bytes(loopargs[i].buf, 36);
2364 #ifndef OPENSSL_NO_RSA
2365 for (testnum = 0; testnum < RSA_NUM; testnum++) {
2367 if (!rsa_doit[testnum])
2369 for (i = 0; i < loopargs_len; i++) {
2370 st = RSA_sign(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2371 loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2377 "RSA sign failure. No RSA sign will be done.\n");
2378 ERR_print_errors(bio_err);
2381 pkey_print_message("private", "rsa",
2382 rsa_c[testnum][0], rsa_bits[testnum], RSA_SECONDS);
2383 /* RSA_blinding_on(rsa_key[testnum],NULL); */
2385 count = run_benchmark(async_jobs, RSA_sign_loop, loopargs);
2388 mr ? "+R1:%ld:%d:%.2f\n"
2389 : "%ld %d bit private RSA's in %.2fs\n",
2390 count, rsa_bits[testnum], d);
2391 rsa_results[testnum][0] = d / (double)count;
2395 for (i = 0; i < loopargs_len; i++) {
2396 st = RSA_verify(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2397 *(loopargs[i].siglen), loopargs[i].rsa_key[testnum]);
2403 "RSA verify failure. No RSA verify will be done.\n");
2404 ERR_print_errors(bio_err);
2405 rsa_doit[testnum] = 0;
2407 pkey_print_message("public", "rsa",
2408 rsa_c[testnum][1], rsa_bits[testnum], RSA_SECONDS);
2410 count = run_benchmark(async_jobs, RSA_verify_loop, loopargs);
2413 mr ? "+R2:%ld:%d:%.2f\n"
2414 : "%ld %d bit public RSA's in %.2fs\n",
2415 count, rsa_bits[testnum], d);
2416 rsa_results[testnum][1] = d / (double)count;
2419 if (rsa_count <= 1) {
2420 /* if longer than 10s, don't do any more */
2421 for (testnum++; testnum < RSA_NUM; testnum++)
2422 rsa_doit[testnum] = 0;
2427 for (i = 0; i < loopargs_len; i++)
2428 RAND_bytes(loopargs[i].buf, 36);
2430 #ifndef OPENSSL_NO_DSA
2431 if (RAND_status() != 1) {
2432 RAND_seed(rnd_seed, sizeof rnd_seed);
2435 for (testnum = 0; testnum < DSA_NUM; testnum++) {
2437 if (!dsa_doit[testnum])
2440 /* DSA_generate_key(dsa_key[testnum]); */
2441 /* DSA_sign_setup(dsa_key[testnum],NULL); */
2442 for (i = 0; i < loopargs_len; i++) {
2443 st = DSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2444 loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2450 "DSA sign failure. No DSA sign will be done.\n");
2451 ERR_print_errors(bio_err);
2454 pkey_print_message("sign", "dsa",
2455 dsa_c[testnum][0], dsa_bits[testnum], DSA_SECONDS);
2457 count = run_benchmark(async_jobs, DSA_sign_loop, loopargs);
2460 mr ? "+R3:%ld:%d:%.2f\n"
2461 : "%ld %d bit DSA signs in %.2fs\n",
2462 count, dsa_bits[testnum], d);
2463 dsa_results[testnum][0] = d / (double)count;
2467 for (i = 0; i < loopargs_len; i++) {
2468 st = DSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2469 *(loopargs[i].siglen), loopargs[i].dsa_key[testnum]);
2475 "DSA verify failure. No DSA verify will be done.\n");
2476 ERR_print_errors(bio_err);
2477 dsa_doit[testnum] = 0;
2479 pkey_print_message("verify", "dsa",
2480 dsa_c[testnum][1], dsa_bits[testnum], DSA_SECONDS);
2482 count = run_benchmark(async_jobs, DSA_verify_loop, loopargs);
2485 mr ? "+R4:%ld:%d:%.2f\n"
2486 : "%ld %d bit DSA verify in %.2fs\n",
2487 count, dsa_bits[testnum], d);
2488 dsa_results[testnum][1] = d / (double)count;
2491 if (rsa_count <= 1) {
2492 /* if longer than 10s, don't do any more */
2493 for (testnum++; testnum < DSA_NUM; testnum++)
2494 dsa_doit[testnum] = 0;
2501 #ifndef OPENSSL_NO_EC
2502 if (RAND_status() != 1) {
2503 RAND_seed(rnd_seed, sizeof rnd_seed);
2506 for (testnum = 0; testnum < EC_NUM; testnum++) {
2509 if (!ecdsa_doit[testnum])
2510 continue; /* Ignore Curve */
2511 for (i = 0; i < loopargs_len; i++) {
2512 loopargs[i].ecdsa[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2513 if (loopargs[i].ecdsa[testnum] == NULL) {
2519 BIO_printf(bio_err, "ECDSA failure.\n");
2520 ERR_print_errors(bio_err);
2523 for (i = 0; i < loopargs_len; i++) {
2524 EC_KEY_precompute_mult(loopargs[i].ecdsa[testnum], NULL);
2525 /* Perform ECDSA signature test */
2526 EC_KEY_generate_key(loopargs[i].ecdsa[testnum]);
2527 st = ECDSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2528 loopargs[i].siglen, loopargs[i].ecdsa[testnum]);
2534 "ECDSA sign failure. No ECDSA sign will be done.\n");
2535 ERR_print_errors(bio_err);
2538 pkey_print_message("sign", "ecdsa",
2539 ecdsa_c[testnum][0],
2540 test_curves_bits[testnum], ECDSA_SECONDS);
2542 count = run_benchmark(async_jobs, ECDSA_sign_loop, loopargs);
2546 mr ? "+R5:%ld:%d:%.2f\n" :
2547 "%ld %d bit ECDSA signs in %.2fs \n",
2548 count, test_curves_bits[testnum], d);
2549 ecdsa_results[testnum][0] = d / (double)count;
2553 /* Perform ECDSA verification test */
2554 for (i = 0; i < loopargs_len; i++) {
2555 st = ECDSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2556 *(loopargs[i].siglen), loopargs[i].ecdsa[testnum]);
2562 "ECDSA verify failure. No ECDSA verify will be done.\n");
2563 ERR_print_errors(bio_err);
2564 ecdsa_doit[testnum] = 0;
2566 pkey_print_message("verify", "ecdsa",
2567 ecdsa_c[testnum][1],
2568 test_curves_bits[testnum], ECDSA_SECONDS);
2570 count = run_benchmark(async_jobs, ECDSA_verify_loop, loopargs);
2573 mr ? "+R6:%ld:%d:%.2f\n"
2574 : "%ld %d bit ECDSA verify in %.2fs\n",
2575 count, test_curves_bits[testnum], d);
2576 ecdsa_results[testnum][1] = d / (double)count;
2579 if (rsa_count <= 1) {
2580 /* if longer than 10s, don't do any more */
2581 for (testnum++; testnum < EC_NUM; testnum++)
2582 ecdsa_doit[testnum] = 0;
2590 #ifndef OPENSSL_NO_EC
2591 if (RAND_status() != 1) {
2592 RAND_seed(rnd_seed, sizeof rnd_seed);
2595 for (testnum = 0; testnum < EC_NUM; testnum++) {
2596 if (!ecdh_doit[testnum])
2598 for (i = 0; i < loopargs_len; i++) {
2599 loopargs[i].ecdh_a[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2600 loopargs[i].ecdh_b[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2601 if (loopargs[i].ecdh_a[testnum] == NULL ||
2602 loopargs[i].ecdh_b[testnum] == NULL) {
2607 if (ecdh_checks == 0) {
2608 BIO_printf(bio_err, "ECDH failure.\n");
2609 ERR_print_errors(bio_err);
2612 for (i = 0; i < loopargs_len; i++) {
2613 /* generate two ECDH key pairs */
2614 if (!EC_KEY_generate_key(loopargs[i].ecdh_a[testnum]) ||
2615 !EC_KEY_generate_key(loopargs[i].ecdh_b[testnum])) {
2616 BIO_printf(bio_err, "ECDH key generation failure.\n");
2617 ERR_print_errors(bio_err);
2622 * If field size is not more than 24 octets, then use SHA-1
2623 * hash of result; otherwise, use result (see section 4.8 of
2624 * draft-ietf-tls-ecc-03.txt).
2628 EC_GROUP_get_degree(EC_KEY_get0_group(loopargs[i].ecdh_a[testnum]));
2629 if (field_size <= 24 * 8) {
2630 outlen = KDF1_SHA1_len;
2633 outlen = (field_size + 7) / 8;
2637 ECDH_compute_key(loopargs[i].secret_a, outlen,
2638 EC_KEY_get0_public_key(loopargs[i].ecdh_b[testnum]),
2639 loopargs[i].ecdh_a[testnum], kdf);
2641 ECDH_compute_key(loopargs[i].secret_b, outlen,
2642 EC_KEY_get0_public_key(loopargs[i].ecdh_a[testnum]),
2643 loopargs[i].ecdh_b[testnum], kdf);
2644 if (secret_size_a != secret_size_b)
2649 for (secret_idx = 0; (secret_idx < secret_size_a)
2650 && (ecdh_checks == 1); secret_idx++) {
2651 if (loopargs[i].secret_a[secret_idx] != loopargs[i].secret_b[secret_idx])
2655 if (ecdh_checks == 0) {
2656 BIO_printf(bio_err, "ECDH computations don't match.\n");
2657 ERR_print_errors(bio_err);
2662 if (ecdh_checks != 0) {
2663 pkey_print_message("", "ecdh",
2665 test_curves_bits[testnum], ECDH_SECONDS);
2667 count = run_benchmark(async_jobs, ECDH_compute_key_loop, loopargs);
2670 mr ? "+R7:%ld:%d:%.2f\n" :
2671 "%ld %d-bit ECDH ops in %.2fs\n", count,
2672 test_curves_bits[testnum], d);
2673 ecdh_results[testnum][0] = d / (double)count;
2679 if (rsa_count <= 1) {
2680 /* if longer than 10s, don't do any more */
2681 for (testnum++; testnum < EC_NUM; testnum++)
2682 ecdh_doit[testnum] = 0;
2692 printf("%s\n", OpenSSL_version(OPENSSL_VERSION));
2693 printf("%s\n", OpenSSL_version(OPENSSL_BUILT_ON));
2695 printf("%s ", BN_options());
2696 #ifndef OPENSSL_NO_MD2
2697 printf("%s ", MD2_options());
2699 #ifndef OPENSSL_NO_RC4
2700 printf("%s ", RC4_options());
2702 #ifndef OPENSSL_NO_DES
2703 printf("%s ", DES_options());
2705 #ifndef OPENSSL_NO_AES
2706 printf("%s ", AES_options());
2708 #ifndef OPENSSL_NO_IDEA
2709 printf("%s ", idea_options());
2711 #ifndef OPENSSL_NO_BF
2712 printf("%s ", BF_options());
2714 printf("\n%s\n", OpenSSL_version(OPENSSL_CFLAGS));
2722 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2725 for (testnum = 0; testnum < SIZE_NUM; testnum++)
2726 printf(mr ? ":%d" : "%7d bytes", lengths[testnum]);
2730 for (k = 0; k < ALGOR_NUM; k++) {
2734 printf("+F:%d:%s", k, names[k]);
2736 printf("%-13s", names[k]);
2737 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2738 if (results[k][testnum] > 10000 && !mr)
2739 printf(" %11.2fk", results[k][testnum] / 1e3);
2741 printf(mr ? ":%.2f" : " %11.2f ", results[k][testnum]);
2745 #ifndef OPENSSL_NO_RSA
2747 for (k = 0; k < RSA_NUM; k++) {
2750 if (testnum && !mr) {
2751 printf("%18ssign verify sign/s verify/s\n", " ");
2755 printf("+F2:%u:%u:%f:%f\n",
2756 k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2758 printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2759 rsa_bits[k], rsa_results[k][0], rsa_results[k][1],
2760 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]);
2763 #ifndef OPENSSL_NO_DSA
2765 for (k = 0; k < DSA_NUM; k++) {
2768 if (testnum && !mr) {
2769 printf("%18ssign verify sign/s verify/s\n", " ");
2773 printf("+F3:%u:%u:%f:%f\n",
2774 k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2776 printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2777 dsa_bits[k], dsa_results[k][0], dsa_results[k][1],
2778 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]);
2781 #ifndef OPENSSL_NO_EC
2783 for (k = 0; k < EC_NUM; k++) {
2786 if (testnum && !mr) {
2787 printf("%30ssign verify sign/s verify/s\n", " ");
2792 printf("+F4:%u:%u:%f:%f\n",
2793 k, test_curves_bits[k],
2794 ecdsa_results[k][0], ecdsa_results[k][1]);
2796 printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2797 test_curves_bits[k],
2798 test_curves_names[k],
2799 ecdsa_results[k][0], ecdsa_results[k][1],
2800 1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
2804 #ifndef OPENSSL_NO_EC
2806 for (k = 0; k < EC_NUM; k++) {
2809 if (testnum && !mr) {
2810 printf("%30sop op/s\n", " ");
2814 printf("+F5:%u:%u:%f:%f\n",
2815 k, test_curves_bits[k],
2816 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2819 printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2820 test_curves_bits[k],
2821 test_curves_names[k],
2822 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2829 ERR_print_errors(bio_err);
2830 for (i = 0; i < loopargs_len; i++) {
2831 OPENSSL_free(loopargs[i].buf_malloc);
2832 OPENSSL_free(loopargs[i].buf2_malloc);
2833 OPENSSL_free(loopargs[i].siglen);
2835 #ifndef OPENSSL_NO_RSA
2836 for (i = 0; i < loopargs_len; i++) {
2837 for (k = 0; k < RSA_NUM; k++)
2838 RSA_free(loopargs[i].rsa_key[k]);
2841 #ifndef OPENSSL_NO_DSA
2842 for (i = 0; i < loopargs_len; i++) {
2843 for (k = 0; k < DSA_NUM; k++)
2844 DSA_free(loopargs[i].dsa_key[k]);
2848 #ifndef OPENSSL_NO_EC
2849 for (i = 0; i < loopargs_len; i++) {
2850 for (k = 0; k < EC_NUM; k++) {
2851 EC_KEY_free(loopargs[i].ecdsa[k]);
2852 EC_KEY_free(loopargs[i].ecdh_a[k]);
2853 EC_KEY_free(loopargs[i].ecdh_b[k]);
2855 OPENSSL_free(loopargs[i].secret_a);
2856 OPENSSL_free(loopargs[i].secret_b);
2859 if (async_jobs > 0) {
2860 for (i = 0; i < loopargs_len; i++)
2861 ASYNC_WAIT_CTX_free(loopargs[i].wait_ctx);
2863 ASYNC_cleanup_thread();
2865 OPENSSL_free(loopargs);
2869 static void print_message(const char *s, long num, int length)
2873 mr ? "+DT:%s:%d:%d\n"
2874 : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length);
2875 (void)BIO_flush(bio_err);
2879 mr ? "+DN:%s:%ld:%d\n"
2880 : "Doing %s %ld times on %d size blocks: ", s, num, length);
2881 (void)BIO_flush(bio_err);
2885 static void pkey_print_message(const char *str, const char *str2, long num,
2890 mr ? "+DTP:%d:%s:%s:%d\n"
2891 : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
2892 (void)BIO_flush(bio_err);
2896 mr ? "+DNP:%ld:%d:%s:%s\n"
2897 : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
2898 (void)BIO_flush(bio_err);
2902 static void print_result(int alg, int run_no, int count, double time_used)
2905 mr ? "+R:%d:%s:%f\n"
2906 : "%d %s's in %.2fs\n", count, names[alg], time_used);
2907 results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
2911 static char *sstrsep(char **string, const char *delim)
2914 char *token = *string;
2919 memset(isdelim, 0, sizeof isdelim);
2923 isdelim[(unsigned char)(*delim)] = 1;
2927 while (!isdelim[(unsigned char)(**string)]) {
2939 static int do_multi(int multi)
2944 static char sep[] = ":";
2946 fds = malloc(sizeof(*fds) * multi);
2947 for (n = 0; n < multi; ++n) {
2948 if (pipe(fd) == -1) {
2949 BIO_printf(bio_err, "pipe failure\n");
2953 (void)BIO_flush(bio_err);
2960 if (dup(fd[1]) == -1) {
2961 BIO_printf(bio_err, "dup failed\n");
2970 printf("Forked child %d\n", n);
2973 /* for now, assume the pipe is long enough to take all the output */
2974 for (n = 0; n < multi; ++n) {
2979 f = fdopen(fds[n], "r");
2980 while (fgets(buf, sizeof buf, f)) {
2981 p = strchr(buf, '\n');
2984 if (buf[0] != '+') {
2985 BIO_printf(bio_err, "Don't understand line '%s' from child %d\n",
2989 printf("Got: %s from %d\n", buf, n);
2990 if (strncmp(buf, "+F:", 3) == 0) {
2995 alg = atoi(sstrsep(&p, sep));
2997 for (j = 0; j < SIZE_NUM; ++j)
2998 results[alg][j] += atof(sstrsep(&p, sep));
2999 } else if (strncmp(buf, "+F2:", 4) == 0) {
3004 k = atoi(sstrsep(&p, sep));
3007 d = atof(sstrsep(&p, sep));
3009 rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
3011 rsa_results[k][0] = d;
3013 d = atof(sstrsep(&p, sep));
3015 rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
3017 rsa_results[k][1] = d;
3019 # ifndef OPENSSL_NO_DSA
3020 else if (strncmp(buf, "+F3:", 4) == 0) {
3025 k = atoi(sstrsep(&p, sep));
3028 d = atof(sstrsep(&p, sep));
3030 dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d);
3032 dsa_results[k][0] = d;
3034 d = atof(sstrsep(&p, sep));
3036 dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d);
3038 dsa_results[k][1] = d;
3041 # ifndef OPENSSL_NO_EC
3042 else if (strncmp(buf, "+F4:", 4) == 0) {
3047 k = atoi(sstrsep(&p, sep));
3050 d = atof(sstrsep(&p, sep));
3052 ecdsa_results[k][0] =
3053 1 / (1 / ecdsa_results[k][0] + 1 / d);
3055 ecdsa_results[k][0] = d;
3057 d = atof(sstrsep(&p, sep));
3059 ecdsa_results[k][1] =
3060 1 / (1 / ecdsa_results[k][1] + 1 / d);
3062 ecdsa_results[k][1] = d;
3066 # ifndef OPENSSL_NO_EC
3067 else if (strncmp(buf, "+F5:", 4) == 0) {
3072 k = atoi(sstrsep(&p, sep));
3075 d = atof(sstrsep(&p, sep));
3077 ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
3079 ecdh_results[k][0] = d;
3084 else if (strncmp(buf, "+H:", 3) == 0) {
3087 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf, n);
3097 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
3099 static int mblengths[] =
3100 { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
3101 int j, count, num = OSSL_NELEM(mblengths);
3102 const char *alg_name;
3103 unsigned char *inp, *out, no_key[32], no_iv[16];
3104 EVP_CIPHER_CTX *ctx;
3107 inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
3108 out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
3109 ctx = EVP_CIPHER_CTX_new();
3110 EVP_EncryptInit_ex(ctx, evp_cipher, NULL, no_key, no_iv);
3111 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key),
3113 alg_name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
3115 for (j = 0; j < num; j++) {
3116 print_message(alg_name, 0, mblengths[j]);
3118 for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
3119 unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
3120 EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
3121 size_t len = mblengths[j];
3124 memset(aad, 0, 8); /* avoid uninitialized values */
3125 aad[8] = 23; /* SSL3_RT_APPLICATION_DATA */
3126 aad[9] = 3; /* version */
3128 aad[11] = 0; /* length */
3130 mb_param.out = NULL;
3133 mb_param.interleave = 8;
3135 packlen = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
3136 sizeof(mb_param), &mb_param);
3142 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
3143 sizeof(mb_param), &mb_param);
3147 RAND_bytes(out, 16);
3151 pad = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_TLS1_AAD,
3152 EVP_AEAD_TLS1_AAD_LEN, aad);
3153 EVP_Cipher(ctx, out, inp, len + pad);
3157 BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
3158 : "%d %s's in %.2fs\n", count, "evp", d);
3159 results[D_EVP][j] = ((double)count) / d * mblengths[j];
3163 fprintf(stdout, "+H");
3164 for (j = 0; j < num; j++)
3165 fprintf(stdout, ":%d", mblengths[j]);
3166 fprintf(stdout, "\n");
3167 fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
3168 for (j = 0; j < num; j++)
3169 fprintf(stdout, ":%.2f", results[D_EVP][j]);
3170 fprintf(stdout, "\n");
3173 "The 'numbers' are in 1000s of bytes per second processed.\n");
3174 fprintf(stdout, "type ");
3175 for (j = 0; j < num; j++)
3176 fprintf(stdout, "%7d bytes", mblengths[j]);
3177 fprintf(stdout, "\n");
3178 fprintf(stdout, "%-24s", alg_name);
3180 for (j = 0; j < num; j++) {
3181 if (results[D_EVP][j] > 10000)
3182 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
3184 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
3186 fprintf(stdout, "\n");
3191 EVP_CIPHER_CTX_free(ctx);