apps/speed.c

   1 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   2  * All rights reserved.
   3  *
   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.
   7  *
   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).
  14  *
  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.
  21  *
  22  * Redistribution and use in source and binary forms, with or without
  23  * modification, are permitted provided that the following conditions
  24  * are met:
  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)"
  39  *
  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
  50  * SUCH DAMAGE.
  51  *
  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.]
  56  */
  57 /* ====================================================================
  58  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
  59  *
  60  * Portions of the attached software ("Contribution") are developed by
  61  * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
  62  *
  63  * The Contribution is licensed pursuant to the OpenSSL open source
  64  * license provided above.
  65  *
  66  * The ECDH and ECDSA speed test software is originally written by
  67  * Sumit Gupta of Sun Microsystems Laboratories.
  68  *
  69  */
  70
  71 #undef SECONDS
  72 #define SECONDS                 3
  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
  78
  79 #include <stdio.h>
  80 #include <stdlib.h>
  81 #include <string.h>
  82 #include <math.h>
  83 #include "apps.h"
  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
  92 #endif
  93
  94 #if defined(_WIN32)
  95 # include <windows.h>
  96 #endif
  97
  98 #include <openssl/bn.h>
  99 #ifndef OPENSSL_NO_DES
 100 # include <openssl/des.h>
 101 #endif
 102 #ifndef OPENSSL_NO_AES
 103 # include <openssl/aes.h>
 104 #endif
 105 #ifndef OPENSSL_NO_CAMELLIA
 106 # include <openssl/camellia.h>
 107 #endif
 108 #ifndef OPENSSL_NO_MD2
 109 # include <openssl/md2.h>
 110 #endif
 111 #ifndef OPENSSL_NO_MDC2
 112 # include <openssl/mdc2.h>
 113 #endif
 114 #ifndef OPENSSL_NO_MD4
 115 # include <openssl/md4.h>
 116 #endif
 117 #ifndef OPENSSL_NO_MD5
 118 # include <openssl/md5.h>
 119 #endif
 120 #include <openssl/hmac.h>
 121 #include <openssl/sha.h>
 122 #ifndef OPENSSL_NO_RMD160
 123 # include <openssl/ripemd.h>
 124 #endif
 125 #ifndef OPENSSL_NO_WHIRLPOOL
 126 # include <openssl/whrlpool.h>
 127 #endif
 128 #ifndef OPENSSL_NO_RC4
 129 # include <openssl/rc4.h>
 130 #endif
 131 #ifndef OPENSSL_NO_RC5
 132 # include <openssl/rc5.h>
 133 #endif
 134 #ifndef OPENSSL_NO_RC2
 135 # include <openssl/rc2.h>
 136 #endif
 137 #ifndef OPENSSL_NO_IDEA
 138 # include <openssl/idea.h>
 139 #endif
 140 #ifndef OPENSSL_NO_SEED
 141 # include <openssl/seed.h>
 142 #endif
 143 #ifndef OPENSSL_NO_BF
 144 # include <openssl/blowfish.h>
 145 #endif
 146 #ifndef OPENSSL_NO_CAST
 147 # include <openssl/cast.h>
 148 #endif
 149 #ifndef OPENSSL_NO_RSA
 150 # include <openssl/rsa.h>
 151 # include "./testrsa.h"
 152 #endif
 153 #include <openssl/x509.h>
 154 #ifndef OPENSSL_NO_DSA
 155 # include <openssl/dsa.h>
 156 # include "./testdsa.h"
 157 #endif
 158 #ifndef OPENSSL_NO_EC
 159 # include <openssl/ec.h>
 160 #endif
 161 #include <openssl/modes.h>
 162
 163 #ifndef HAVE_FORK
 164 # if defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_WINDOWS)
 165 #  define HAVE_FORK 0
 166 # else
 167 #  define HAVE_FORK 1
 168 # endif
 169 #endif
 170
 171 #if HAVE_FORK
 172 # undef NO_FORK
 173 #else
 174 # define NO_FORK
 175 #endif
 176
 177 #undef BUFSIZE
 178 #define BUFSIZE (1024*16+1)
 179 #define MAX_MISALIGNMENT 63
 180
 181 #define ALGOR_NUM       30
 182 #define SIZE_NUM        6
 183 #define PRIME_NUM       3
 184 #define RSA_NUM         7
 185 #define DSA_NUM         3
 186
 187 #define EC_NUM          17
 188 #define MAX_ECDH_SIZE   256
 189 #define MISALIGN        64
 190
 191 static volatile int run = 0;
 192
 193 static int mr = 0;
 194 static int usertime = 1;
 195
 196 typedef struct loopargs_st {
 197     ASYNC_JOB *inprogress_job;
 198     ASYNC_WAIT_CTX *wait_ctx;
 199     unsigned char *buf;
 200     unsigned char *buf2;
 201     unsigned char *buf_malloc;
 202     unsigned char *buf2_malloc;
 203     unsigned int *siglen;
 204 #ifndef OPENSSL_NO_RSA
 205     RSA *rsa_key[RSA_NUM];
 206 #endif
 207 #ifndef OPENSSL_NO_DSA
 208     DSA *dsa_key[DSA_NUM];
 209 #endif
 210 #ifndef OPENSSL_NO_EC
 211     EC_KEY *ecdsa[EC_NUM];
 212     EC_KEY *ecdh_a[EC_NUM];
 213     EC_KEY *ecdh_b[EC_NUM];
 214     unsigned char *secret_a;
 215     unsigned char *secret_b;
 216 #endif
 217     EVP_CIPHER_CTX *ctx;
 218     HMAC_CTX *hctx;
 219     GCM128_CONTEXT *gcm_ctx;
 220 } loopargs_t;
 221
 222 #ifndef OPENSSL_NO_MD2
 223 static int EVP_Digest_MD2_loop(void *args);
 224 #endif
 225
 226 #ifndef OPENSSL_NO_MDC2
 227 static int EVP_Digest_MDC2_loop(void *args);
 228 #endif
 229 #ifndef OPENSSL_NO_MD4
 230 static int EVP_Digest_MD4_loop(void *args);
 231 #endif
 232 #ifndef OPENSSL_NO_MD5
 233 static int MD5_loop(void *args);
 234 static int HMAC_loop(void *args);
 235 #endif
 236 static int SHA1_loop(void *args);
 237 static int SHA256_loop(void *args);
 238 static int SHA512_loop(void *args);
 239 #ifndef OPENSSL_NO_WHIRLPOOL
 240 static int WHIRLPOOL_loop(void *args);
 241 #endif
 242 #ifndef OPENSSL_NO_RMD160
 243 static int EVP_Digest_RMD160_loop(void *args);
 244 #endif
 245 #ifndef OPENSSL_NO_RC4
 246 static int RC4_loop(void *args);
 247 #endif
 248 #ifndef OPENSSL_NO_DES
 249 static int DES_ncbc_encrypt_loop(void *args);
 250 static int DES_ede3_cbc_encrypt_loop(void *args);
 251 #endif
 252 #ifndef OPENSSL_NO_AES
 253 static int AES_cbc_128_encrypt_loop(void *args);
 254 static int AES_cbc_192_encrypt_loop(void *args);
 255 static int AES_ige_128_encrypt_loop(void *args);
 256 static int AES_cbc_256_encrypt_loop(void *args);
 257 static int AES_ige_192_encrypt_loop(void *args);
 258 static int AES_ige_256_encrypt_loop(void *args);
 259 static int CRYPTO_gcm128_aad_loop(void *args);
 260 #endif
 261 static int EVP_Update_loop(void *args);
 262 static int EVP_Digest_loop(void *args);
 263 #ifndef OPENSSL_NO_RSA
 264 static int RSA_sign_loop(void *args);
 265 static int RSA_verify_loop(void *args);
 266 #endif
 267 #ifndef OPENSSL_NO_DSA
 268 static int DSA_sign_loop(void *args);
 269 static int DSA_verify_loop(void *args);
 270 #endif
 271 #ifndef OPENSSL_NO_EC
 272 static int ECDSA_sign_loop(void *args);
 273 static int ECDSA_verify_loop(void *args);
 274 static int ECDH_compute_key_loop(void *args);
 275 #endif
 276 static int run_benchmark(int async_jobs, int (*loop_function)(void *), loopargs_t *loopargs);
 277
 278 static double Time_F(int s);
 279 static void print_message(const char *s, long num, int length);
 280 static void pkey_print_message(const char *str, const char *str2,
 281                                long num, int bits, int sec);
 282 static void print_result(int alg, int run_no, int count, double time_used);
 283 #ifndef NO_FORK
 284 static int do_multi(int multi);
 285 #endif
 286
 287 static const char *names[ALGOR_NUM] = {
 288     "md2", "mdc2", "md4", "md5", "hmac(md5)", "sha1", "rmd160", "rc4",
 289     "des cbc", "des ede3", "idea cbc", "seed cbc",
 290     "rc2 cbc", "rc5-32/12 cbc", "blowfish cbc", "cast cbc",
 291     "aes-128 cbc", "aes-192 cbc", "aes-256 cbc",
 292     "camellia-128 cbc", "camellia-192 cbc", "camellia-256 cbc",
 293     "evp", "sha256", "sha512", "whirlpool",
 294     "aes-128 ige", "aes-192 ige", "aes-256 ige", "ghash"
 295 };
 296
 297 static double results[ALGOR_NUM][SIZE_NUM];
 298 static int lengths[SIZE_NUM] = {
 299     16, 64, 256, 1024, 8 * 1024, 16 * 1024
 300 };
 301
 302 #ifndef OPENSSL_NO_RSA
 303 static double rsa_results[RSA_NUM][2];
 304 #endif
 305 #ifndef OPENSSL_NO_DSA
 306 static double dsa_results[DSA_NUM][2];
 307 #endif
 308 #ifndef OPENSSL_NO_EC
 309 static double ecdsa_results[EC_NUM][2];
 310 static double ecdh_results[EC_NUM][1];
 311 #endif
 312
 313 #if defined(OPENSSL_NO_DSA) && !defined(OPENSSL_NO_EC)
 314 static const char rnd_seed[] =
 315     "string to make the random number generator think it has entropy";
 316 static int rnd_fake = 0;
 317 #endif
 318
 319 #ifdef SIGALRM
 320 # if defined(__STDC__) || defined(sgi) || defined(_AIX)
 321 #  define SIGRETTYPE void
 322 # else
 323 #  define SIGRETTYPE int
 324 # endif
 325
 326 static SIGRETTYPE sig_done(int sig);
 327 static SIGRETTYPE sig_done(int sig)
 328 {
 329     signal(SIGALRM, sig_done);
 330     run = 0;
 331 }
 332 #endif
 333
 334 #define START   0
 335 #define STOP    1
 336
 337 #if defined(_WIN32)
 338
 339 # if !defined(SIGALRM)
 340 #  define SIGALRM
 341 # endif
 342 static unsigned int lapse, schlock;
 343 static void alarm_win32(unsigned int secs)
 344 {
 345     lapse = secs * 1000;
 346 }
 347
 348 # define alarm alarm_win32
 349
 350 static DWORD WINAPI sleepy(VOID * arg)
 351 {
 352     schlock = 1;
 353     Sleep(lapse);
 354     run = 0;
 355     return 0;
 356 }
 357
 358 static double Time_F(int s)
 359 {
 360     double ret;
 361     static HANDLE thr;
 362
 363     if (s == START) {
 364         schlock = 0;
 365         thr = CreateThread(NULL, 4096, sleepy, NULL, 0, NULL);
 366         if (thr == NULL) {
 367             DWORD err = GetLastError();
 368             BIO_printf(bio_err, "unable to CreateThread (%lu)", err);
 369             ExitProcess(err);
 370         }
 371         while (!schlock)
 372             Sleep(0);           /* scheduler spinlock */
 373         ret = app_tminterval(s, usertime);
 374     } else {
 375         ret = app_tminterval(s, usertime);
 376         if (run)
 377             TerminateThread(thr, 0);
 378         CloseHandle(thr);
 379     }
 380
 381     return ret;
 382 }
 383 #else
 384
 385 static double Time_F(int s)
 386 {
 387     double ret = app_tminterval(s, usertime);
 388     if (s == STOP)
 389         alarm(0);
 390     return ret;
 391 }
 392 #endif
 393
 394 #ifndef OPENSSL_NO_EC
 395 static const int KDF1_SHA1_len = 20;
 396 static void *KDF1_SHA1(const void *in, size_t inlen, void *out,
 397                        size_t *outlen)
 398 {
 399     if (*outlen < SHA_DIGEST_LENGTH)
 400         return NULL;
 401     *outlen = SHA_DIGEST_LENGTH;
 402     return SHA1(in, inlen, out);
 403 }
 404 #endif                         /* OPENSSL_NO_EC */
 405
 406 static void multiblock_speed(const EVP_CIPHER *evp_cipher);
 407
 408 static int found(const char *name, const OPT_PAIR * pairs, int *result)
 409 {
 410     for (; pairs->name; pairs++)
 411         if (strcmp(name, pairs->name) == 0) {
 412             *result = pairs->retval;
 413             return 1;
 414         }
 415     return 0;
 416 }
 417
 418 typedef enum OPTION_choice {
 419     OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
 420     OPT_ELAPSED, OPT_EVP, OPT_DECRYPT, OPT_ENGINE, OPT_MULTI,
 421     OPT_MR, OPT_MB, OPT_MISALIGN, OPT_ASYNCJOBS
 422 } OPTION_CHOICE;
 423
 424 OPTIONS speed_options[] = {
 425     {OPT_HELP_STR, 1, '-', "Usage: %s [options] ciphers...\n"},
 426     {OPT_HELP_STR, 1, '-', "Valid options are:\n"},
 427     {"help", OPT_HELP, '-', "Display this summary"},
 428     {"evp", OPT_EVP, 's', "Use specified EVP cipher"},
 429     {"decrypt", OPT_DECRYPT, '-',
 430      "Time decryption instead of encryption (only EVP)"},
 431     {"mr", OPT_MR, '-', "Produce machine readable output"},
 432     {"mb", OPT_MB, '-'},
 433     {"misalign", OPT_MISALIGN, 'n', "Amount to mis-align buffers"},
 434     {"elapsed", OPT_ELAPSED, '-',
 435      "Measure time in real time instead of CPU user time"},
 436 #ifndef NO_FORK
 437     {"multi", OPT_MULTI, 'p', "Run benchmarks in parallel"},
 438 #endif
 439 #ifndef OPENSSL_NO_ASYNC
 440     {"async_jobs", OPT_ASYNCJOBS, 'p', "Enable async mode and start pnum jobs"},
 441 #endif
 442 #ifndef OPENSSL_NO_ENGINE
 443     {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
 444 #endif
 445     {NULL},
 446 };
 447
 448 #define D_MD2           0
 449 #define D_MDC2          1
 450 #define D_MD4           2
 451 #define D_MD5           3
 452 #define D_HMAC          4
 453 #define D_SHA1          5
 454 #define D_RMD160        6
 455 #define D_RC4           7
 456 #define D_CBC_DES       8
 457 #define D_EDE3_DES      9
 458 #define D_CBC_IDEA      10
 459 #define D_CBC_SEED      11
 460 #define D_CBC_RC2       12
 461 #define D_CBC_RC5       13
 462 #define D_CBC_BF        14
 463 #define D_CBC_CAST      15
 464 #define D_CBC_128_AES   16
 465 #define D_CBC_192_AES   17
 466 #define D_CBC_256_AES   18
 467 #define D_CBC_128_CML   19
 468 #define D_CBC_192_CML   20
 469 #define D_CBC_256_CML   21
 470 #define D_EVP           22
 471 #define D_SHA256        23
 472 #define D_SHA512        24
 473 #define D_WHIRLPOOL     25
 474 #define D_IGE_128_AES   26
 475 #define D_IGE_192_AES   27
 476 #define D_IGE_256_AES   28
 477 #define D_GHASH         29
 478 static OPT_PAIR doit_choices[] = {
 479 #ifndef OPENSSL_NO_MD2
 480     {"md2", D_MD2},
 481 #endif
 482 #ifndef OPENSSL_NO_MDC2
 483     {"mdc2", D_MDC2},
 484 #endif
 485 #ifndef OPENSSL_NO_MD4
 486     {"md4", D_MD4},
 487 #endif
 488 #ifndef OPENSSL_NO_MD5
 489     {"md5", D_MD5},
 490 #endif
 491 #ifndef OPENSSL_NO_MD5
 492     {"hmac", D_HMAC},
 493 #endif
 494     {"sha1", D_SHA1},
 495     {"sha256", D_SHA256},
 496     {"sha512", D_SHA512},
 497 #ifndef OPENSSL_NO_WHIRLPOOL
 498     {"whirlpool", D_WHIRLPOOL},
 499 #endif
 500 #ifndef OPENSSL_NO_RMD160
 501     {"ripemd", D_RMD160},
 502     {"rmd160", D_RMD160},
 503     {"ripemd160", D_RMD160},
 504 #endif
 505 #ifndef OPENSSL_NO_RC4
 506     {"rc4", D_RC4},
 507 #endif
 508 #ifndef OPENSSL_NO_DES
 509     {"des-cbc", D_CBC_DES},
 510     {"des-ede3", D_EDE3_DES},
 511 #endif
 512 #ifndef OPENSSL_NO_AES
 513     {"aes-128-cbc", D_CBC_128_AES},
 514     {"aes-192-cbc", D_CBC_192_AES},
 515     {"aes-256-cbc", D_CBC_256_AES},
 516     {"aes-128-ige", D_IGE_128_AES},
 517     {"aes-192-ige", D_IGE_192_AES},
 518     {"aes-256-ige", D_IGE_256_AES},
 519 #endif
 520 #ifndef OPENSSL_NO_RC2
 521     {"rc2-cbc", D_CBC_RC2},
 522     {"rc2", D_CBC_RC2},
 523 #endif
 524 #ifndef OPENSSL_NO_RC5
 525     {"rc5-cbc", D_CBC_RC5},
 526     {"rc5", D_CBC_RC5},
 527 #endif
 528 #ifndef OPENSSL_NO_IDEA
 529     {"idea-cbc", D_CBC_IDEA},
 530     {"idea", D_CBC_IDEA},
 531 #endif
 532 #ifndef OPENSSL_NO_SEED
 533     {"seed-cbc", D_CBC_SEED},
 534     {"seed", D_CBC_SEED},
 535 #endif
 536 #ifndef OPENSSL_NO_BF
 537     {"bf-cbc", D_CBC_BF},
 538     {"blowfish", D_CBC_BF},
 539     {"bf", D_CBC_BF},
 540 #endif
 541 #ifndef OPENSSL_NO_CAST
 542     {"cast-cbc", D_CBC_CAST},
 543     {"cast", D_CBC_CAST},
 544     {"cast5", D_CBC_CAST},
 545 #endif
 546     {"ghash", D_GHASH},
 547     {NULL}
 548 };
 549
 550 #ifndef OPENSSL_NO_DSA
 551 # define R_DSA_512       0
 552 # define R_DSA_1024      1
 553 # define R_DSA_2048      2
 554 static OPT_PAIR dsa_choices[] = {
 555     {"dsa512", R_DSA_512},
 556     {"dsa1024", R_DSA_1024},
 557     {"dsa2048", R_DSA_2048},
 558     {NULL},
 559 };
 560 #endif
 561
 562 #define R_RSA_512       0
 563 #define R_RSA_1024      1
 564 #define R_RSA_2048      2
 565 #define R_RSA_3072      3
 566 #define R_RSA_4096      4
 567 #define R_RSA_7680      5
 568 #define R_RSA_15360     6
 569 static OPT_PAIR rsa_choices[] = {
 570     {"rsa512", R_RSA_512},
 571     {"rsa1024", R_RSA_1024},
 572     {"rsa2048", R_RSA_2048},
 573     {"rsa3072", R_RSA_3072},
 574     {"rsa4096", R_RSA_4096},
 575     {"rsa7680", R_RSA_7680},
 576     {"rsa15360", R_RSA_15360},
 577     {NULL}
 578 };
 579
 580 #define R_EC_P160    0
 581 #define R_EC_P192    1
 582 #define R_EC_P224    2
 583 #define R_EC_P256    3
 584 #define R_EC_P384    4
 585 #define R_EC_P521    5
 586 #define R_EC_K163    6
 587 #define R_EC_K233    7
 588 #define R_EC_K283    8
 589 #define R_EC_K409    9
 590 #define R_EC_K571    10
 591 #define R_EC_B163    11
 592 #define R_EC_B233    12
 593 #define R_EC_B283    13
 594 #define R_EC_B409    14
 595 #define R_EC_B571    15
 596 #define R_EC_X25519  16
 597 #ifndef OPENSSL_NO_EC
 598 static OPT_PAIR ecdsa_choices[] = {
 599     {"ecdsap160", R_EC_P160},
 600     {"ecdsap192", R_EC_P192},
 601     {"ecdsap224", R_EC_P224},
 602     {"ecdsap256", R_EC_P256},
 603     {"ecdsap384", R_EC_P384},
 604     {"ecdsap521", R_EC_P521},
 605     {"ecdsak163", R_EC_K163},
 606     {"ecdsak233", R_EC_K233},
 607     {"ecdsak283", R_EC_K283},
 608     {"ecdsak409", R_EC_K409},
 609     {"ecdsak571", R_EC_K571},
 610     {"ecdsab163", R_EC_B163},
 611     {"ecdsab233", R_EC_B233},
 612     {"ecdsab283", R_EC_B283},
 613     {"ecdsab409", R_EC_B409},
 614     {"ecdsab571", R_EC_B571},
 615     {NULL}
 616 };
 617 static OPT_PAIR ecdh_choices[] = {
 618     {"ecdhp160", R_EC_P160},
 619     {"ecdhp192", R_EC_P192},
 620     {"ecdhp224", R_EC_P224},
 621     {"ecdhp256", R_EC_P256},
 622     {"ecdhp384", R_EC_P384},
 623     {"ecdhp521", R_EC_P521},
 624     {"ecdhk163", R_EC_K163},
 625     {"ecdhk233", R_EC_K233},
 626     {"ecdhk283", R_EC_K283},
 627     {"ecdhk409", R_EC_K409},
 628     {"ecdhk571", R_EC_K571},
 629     {"ecdhb163", R_EC_B163},
 630     {"ecdhb233", R_EC_B233},
 631     {"ecdhb283", R_EC_B283},
 632     {"ecdhb409", R_EC_B409},
 633     {"ecdhb571", R_EC_B571},
 634     {"ecdhx25519", R_EC_X25519},
 635     {NULL}
 636 };
 637 #endif
 638
 639 #ifndef SIGALRM
 640 # define COND(d) (count < (d))
 641 # define COUNT(d) (d)
 642 #else
 643 # define COND(c) (run && count<0x7fffffff)
 644 # define COUNT(d) (count)
 645 #endif                         /* SIGALRM */
 646
 647 static int testnum;
 648 static char *engine_id = NULL;
 649
 650
 651 #ifndef OPENSSL_NO_MD2
 652 static int EVP_Digest_MD2_loop(void *args)
 653 {
 654     loopargs_t *tempargs = (loopargs_t *)args;
 655     unsigned char *buf = tempargs->buf;
 656     unsigned char md2[MD2_DIGEST_LENGTH];
 657     int count;
 658     for (count = 0; COND(c[D_MD2][testnum]); count++)
 659         EVP_Digest(buf, (unsigned long)lengths[testnum], &(md2[0]), NULL,
 660                 EVP_md2(), NULL);
 661     return count;
 662 }
 663 #endif
 664
 665 #ifndef OPENSSL_NO_MDC2
 666 static int EVP_Digest_MDC2_loop(void *args)
 667 {
 668     loopargs_t *tempargs = (loopargs_t *)args;
 669     unsigned char *buf = tempargs->buf;
 670     unsigned char mdc2[MDC2_DIGEST_LENGTH];
 671     int count;
 672     for (count = 0; COND(c[D_MDC2][testnum]); count++)
 673         EVP_Digest(buf, (unsigned long)lengths[testnum], &(mdc2[0]), NULL,
 674                 EVP_mdc2(), NULL);
 675     return count;
 676 }
 677 #endif
 678
 679 #ifndef OPENSSL_NO_MD4
 680 static int EVP_Digest_MD4_loop(void *args)
 681 {
 682     loopargs_t *tempargs = (loopargs_t *)args;
 683     unsigned char *buf = tempargs->buf;
 684     unsigned char md4[MD4_DIGEST_LENGTH];
 685     int count;
 686     for (count = 0; COND(c[D_MD4][testnum]); count++)
 687         EVP_Digest(&(buf[0]), (unsigned long)lengths[testnum], &(md4[0]),
 688                 NULL, EVP_md4(), NULL);
 689     return count;
 690 }
 691 #endif
 692
 693 #ifndef OPENSSL_NO_MD5
 694 static int MD5_loop(void *args)
 695 {
 696     loopargs_t *tempargs = (loopargs_t *)args;
 697     unsigned char *buf = tempargs->buf;
 698     unsigned char md5[MD5_DIGEST_LENGTH];
 699     int count;
 700     for (count = 0; COND(c[D_MD5][testnum]); count++)
 701         MD5(buf, lengths[testnum], md5);
 702     return count;
 703 }
 704
 705 static int HMAC_loop(void *args)
 706 {
 707     loopargs_t *tempargs = (loopargs_t *)args;
 708     unsigned char *buf = tempargs->buf;
 709     HMAC_CTX *hctx = tempargs->hctx;
 710     unsigned char hmac[MD5_DIGEST_LENGTH];
 711     int count;
 712     for (count = 0; COND(c[D_HMAC][testnum]); count++) {
 713         HMAC_Init_ex(hctx, NULL, 0, NULL, NULL);
 714         HMAC_Update(hctx, buf, lengths[testnum]);
 715         HMAC_Final(hctx, &(hmac[0]), NULL);
 716     }
 717     return count;
 718 }
 719 #endif
 720
 721 static int SHA1_loop(void *args)
 722 {
 723     loopargs_t *tempargs = (loopargs_t *)args;
 724     unsigned char *buf = tempargs->buf;
 725     unsigned char sha[SHA_DIGEST_LENGTH];
 726     int count;
 727     for (count = 0; COND(c[D_SHA1][testnum]); count++)
 728         SHA1(buf, lengths[testnum], sha);
 729     return count;
 730 }
 731
 732 static int SHA256_loop(void *args)
 733 {
 734     loopargs_t *tempargs = (loopargs_t *)args;
 735     unsigned char *buf = tempargs->buf;
 736     unsigned char sha256[SHA256_DIGEST_LENGTH];
 737     int count;
 738     for (count = 0; COND(c[D_SHA256][testnum]); count++)
 739         SHA256(buf, lengths[testnum], sha256);
 740     return count;
 741 }
 742
 743 static int SHA512_loop(void *args)
 744 {
 745     loopargs_t *tempargs = (loopargs_t *)args;
 746     unsigned char *buf = tempargs->buf;
 747     unsigned char sha512[SHA512_DIGEST_LENGTH];
 748     int count;
 749     for (count = 0; COND(c[D_SHA512][testnum]); count++)
 750         SHA512(buf, lengths[testnum], sha512);
 751     return count;
 752 }
 753
 754 #ifndef OPENSSL_NO_WHIRLPOOL
 755 static int WHIRLPOOL_loop(void *args)
 756 {
 757     loopargs_t *tempargs = (loopargs_t *)args;
 758     unsigned char *buf = tempargs->buf;
 759     unsigned char whirlpool[WHIRLPOOL_DIGEST_LENGTH];
 760     int count;
 761     for (count = 0; COND(c[D_WHIRLPOOL][testnum]); count++)
 762         WHIRLPOOL(buf, lengths[testnum], whirlpool);
 763     return count;
 764 }
 765 #endif
 766
 767 #ifndef OPENSSL_NO_RMD160
 768 static int EVP_Digest_RMD160_loop(void *args)
 769 {
 770     loopargs_t *tempargs = (loopargs_t *)args;
 771     unsigned char *buf = tempargs->buf;
 772     unsigned char rmd160[RIPEMD160_DIGEST_LENGTH];
 773     int count;
 774     for (count = 0; COND(c[D_RMD160][testnum]); count++)
 775         EVP_Digest(buf, (unsigned long)lengths[testnum], &(rmd160[0]), NULL,
 776                 EVP_ripemd160(), NULL);
 777     return count;
 778 }
 779 #endif
 780
 781 #ifndef OPENSSL_NO_RC4
 782 static RC4_KEY rc4_ks;
 783 static int RC4_loop(void *args)
 784 {
 785     loopargs_t *tempargs = (loopargs_t *)args;
 786     unsigned char *buf = tempargs->buf;
 787     int count;
 788     for (count = 0; COND(c[D_RC4][testnum]); count++)
 789         RC4(&rc4_ks, (unsigned int)lengths[testnum], buf, buf);
 790     return count;
 791 }
 792 #endif
 793
 794 #ifndef OPENSSL_NO_DES
 795 static unsigned char DES_iv[8];
 796 static DES_key_schedule sch;
 797 static DES_key_schedule sch2;
 798 static DES_key_schedule sch3;
 799 static int DES_ncbc_encrypt_loop(void *args)
 800 {
 801     loopargs_t *tempargs = (loopargs_t *)args;
 802     unsigned char *buf = tempargs->buf;
 803     int count;
 804     for (count = 0; COND(c[D_CBC_DES][testnum]); count++)
 805         DES_ncbc_encrypt(buf, buf, lengths[testnum], &sch,
 806                 &DES_iv, DES_ENCRYPT);
 807     return count;
 808 }
 809
 810 static int DES_ede3_cbc_encrypt_loop(void *args)
 811 {
 812     loopargs_t *tempargs = (loopargs_t *)args;
 813     unsigned char *buf = tempargs->buf;
 814     int count;
 815     for (count = 0; COND(c[D_EDE3_DES][testnum]); count++)
 816         DES_ede3_cbc_encrypt(buf, buf, lengths[testnum],
 817                 &sch, &sch2, &sch3,
 818                 &DES_iv, DES_ENCRYPT);
 819     return count;
 820 }
 821 #endif
 822
 823 #ifndef OPENSSL_NO_AES
 824 # define MAX_BLOCK_SIZE 128
 825 #else
 826 # define MAX_BLOCK_SIZE 64
 827 #endif
 828
 829 static unsigned char iv[2 * MAX_BLOCK_SIZE / 8];
 830 #ifndef OPENSSL_NO_AES
 831 static AES_KEY aes_ks1, aes_ks2, aes_ks3;
 832 static int AES_cbc_128_encrypt_loop(void *args)
 833 {
 834     loopargs_t *tempargs = (loopargs_t *)args;
 835     unsigned char *buf = tempargs->buf;
 836     int count;
 837     for (count = 0; COND(c[D_CBC_128_AES][testnum]); count++)
 838         AES_cbc_encrypt(buf, buf,
 839                 (unsigned long)lengths[testnum], &aes_ks1,
 840                 iv, AES_ENCRYPT);
 841     return count;
 842 }
 843
 844 static int AES_cbc_192_encrypt_loop(void *args)
 845 {
 846     loopargs_t *tempargs = (loopargs_t *)args;
 847     unsigned char *buf = tempargs->buf;
 848     int count;
 849     for (count = 0; COND(c[D_CBC_192_AES][testnum]); count++)
 850         AES_cbc_encrypt(buf, buf,
 851                 (unsigned long)lengths[testnum], &aes_ks2,
 852                 iv, AES_ENCRYPT);
 853     return count;
 854 }
 855
 856 static int AES_cbc_256_encrypt_loop(void *args)
 857 {
 858     loopargs_t *tempargs = (loopargs_t *)args;
 859     unsigned char *buf = tempargs->buf;
 860     int count;
 861     for (count = 0; COND(c[D_CBC_256_AES][testnum]); count++)
 862         AES_cbc_encrypt(buf, buf,
 863                 (unsigned long)lengths[testnum], &aes_ks3,
 864                 iv, AES_ENCRYPT);
 865     return count;
 866 }
 867
 868 static int AES_ige_128_encrypt_loop(void *args)
 869 {
 870     loopargs_t *tempargs = (loopargs_t *)args;
 871     unsigned char *buf = tempargs->buf;
 872     unsigned char *buf2 = tempargs->buf2;
 873     int count;
 874     for (count = 0; COND(c[D_IGE_128_AES][testnum]); count++)
 875         AES_ige_encrypt(buf, buf2,
 876                 (unsigned long)lengths[testnum], &aes_ks1,
 877                 iv, AES_ENCRYPT);
 878     return count;
 879 }
 880
 881 static int AES_ige_192_encrypt_loop(void *args)
 882 {
 883     loopargs_t *tempargs = (loopargs_t *)args;
 884     unsigned char *buf = tempargs->buf;
 885     unsigned char *buf2 = tempargs->buf2;
 886     int count;
 887     for (count = 0; COND(c[D_IGE_192_AES][testnum]); count++)
 888         AES_ige_encrypt(buf, buf2,
 889                 (unsigned long)lengths[testnum], &aes_ks2,
 890                 iv, AES_ENCRYPT);
 891     return count;
 892 }
 893
 894 static int AES_ige_256_encrypt_loop(void *args)
 895 {
 896     loopargs_t *tempargs = (loopargs_t *)args;
 897     unsigned char *buf = tempargs->buf;
 898     unsigned char *buf2 = tempargs->buf2;
 899     int count;
 900     for (count = 0; COND(c[D_IGE_256_AES][testnum]); count++)
 901         AES_ige_encrypt(buf, buf2,
 902                 (unsigned long)lengths[testnum], &aes_ks3,
 903                 iv, AES_ENCRYPT);
 904     return count;
 905 }
 906
 907 static int CRYPTO_gcm128_aad_loop(void *args)
 908 {
 909     loopargs_t *tempargs = (loopargs_t *)args;
 910     unsigned char *buf = tempargs->buf;
 911     GCM128_CONTEXT *gcm_ctx = tempargs->gcm_ctx;
 912     int count;
 913     for (count = 0; COND(c[D_GHASH][testnum]); count++)
 914         CRYPTO_gcm128_aad(gcm_ctx, buf, lengths[testnum]);
 915     return count;
 916 }
 917
 918 #endif
 919
 920 static int decrypt = 0;
 921 static int EVP_Update_loop(void *args)
 922 {
 923     loopargs_t *tempargs = (loopargs_t *)args;
 924     unsigned char *buf = tempargs->buf;
 925     EVP_CIPHER_CTX *ctx = tempargs->ctx;
 926     int outl, count;
 927     if (decrypt)
 928         for (count = 0;
 929                 COND(save_count * 4 * lengths[0] / lengths[testnum]);
 930                 count++)
 931             EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
 932     else
 933         for (count = 0;
 934                 COND(save_count * 4 * lengths[0] / lengths[testnum]);
 935                 count++)
 936             EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
 937     if (decrypt)
 938         EVP_DecryptFinal_ex(ctx, buf, &outl);
 939     else
 940         EVP_EncryptFinal_ex(ctx, buf, &outl);
 941     return count;
 942 }
 943
 944 static const EVP_MD *evp_md = NULL;
 945 static int EVP_Digest_loop(void *args)
 946 {
 947     loopargs_t *tempargs = (loopargs_t *)args;
 948     unsigned char *buf = tempargs->buf;
 949     unsigned char md[EVP_MAX_MD_SIZE];
 950     int count;
 951     for (count = 0;
 952             COND(save_count * 4 * lengths[0] / lengths[testnum]); count++)
 953         EVP_Digest(buf, lengths[testnum], &(md[0]), NULL, evp_md, NULL);
 954
 955     return count;
 956 }
 957
 958 #ifndef OPENSSL_NO_RSA
 959 static long rsa_c[RSA_NUM][2];
 960
 961 static int RSA_sign_loop(void *args)
 962 {
 963     loopargs_t *tempargs = (loopargs_t *)args;
 964     unsigned char *buf = tempargs->buf;
 965     unsigned char *buf2 = tempargs->buf2;
 966     unsigned int *rsa_num = tempargs->siglen;
 967     RSA **rsa_key = tempargs->rsa_key;
 968     int ret, count;
 969     for (count = 0; COND(rsa_c[testnum][0]); count++) {
 970         ret = RSA_sign(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
 971         if (ret == 0) {
 972             BIO_printf(bio_err, "RSA sign failure\n");
 973             ERR_print_errors(bio_err);
 974             count = -1;
 975             break;
 976         }
 977     }
 978     return count;
 979 }
 980
 981 static int RSA_verify_loop(void *args)
 982 {
 983     loopargs_t *tempargs = (loopargs_t *)args;
 984     unsigned char *buf = tempargs->buf;
 985     unsigned char *buf2 = tempargs->buf2;
 986     unsigned int rsa_num = *(tempargs->siglen);
 987     RSA **rsa_key = tempargs->rsa_key;
 988     int ret, count;
 989     for (count = 0; COND(rsa_c[testnum][1]); count++) {
 990         ret = RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
 991         if (ret <= 0) {
 992             BIO_printf(bio_err, "RSA verify failure\n");
 993             ERR_print_errors(bio_err);
 994             count = -1;
 995             break;
 996         }
 997     }
 998     return count;
 999 }
1000 #endif
1001
1002 #ifndef OPENSSL_NO_DSA
1003 static long dsa_c[DSA_NUM][2];
1004 static int DSA_sign_loop(void *args)
1005 {
1006     loopargs_t *tempargs = (loopargs_t *)args;
1007     unsigned char *buf = tempargs->buf;
1008     unsigned char *buf2 = tempargs->buf2;
1009     DSA **dsa_key = tempargs->dsa_key;
1010     unsigned int *siglen = tempargs->siglen;
1011     int ret, count;
1012     for (count = 0; COND(dsa_c[testnum][0]); count++) {
1013         ret = DSA_sign(0, buf, 20, buf2, siglen, dsa_key[testnum]);
1014         if (ret == 0) {
1015             BIO_printf(bio_err, "DSA sign failure\n");
1016             ERR_print_errors(bio_err);
1017             count = -1;
1018             break;
1019         }
1020     }
1021     return count;
1022 }
1023
1024 static int DSA_verify_loop(void *args)
1025 {
1026     loopargs_t *tempargs = (loopargs_t *)args;
1027     unsigned char *buf = tempargs->buf;
1028     unsigned char *buf2 = tempargs->buf2;
1029     DSA **dsa_key = tempargs->dsa_key;
1030     unsigned int siglen = *(tempargs->siglen);
1031     int ret, count;
1032     for (count = 0; COND(dsa_c[testnum][1]); count++) {
1033         ret = DSA_verify(0, buf, 20, buf2, siglen, dsa_key[testnum]);
1034         if (ret <= 0) {
1035             BIO_printf(bio_err, "DSA verify failure\n");
1036             ERR_print_errors(bio_err);
1037             count = -1;
1038             break;
1039         }
1040     }
1041     return count;
1042 }
1043 #endif
1044
1045 #ifndef OPENSSL_NO_EC
1046 static long ecdsa_c[EC_NUM][2];
1047 static int ECDSA_sign_loop(void *args)
1048 {
1049     loopargs_t *tempargs = (loopargs_t *)args;
1050     unsigned char *buf = tempargs->buf;
1051     EC_KEY **ecdsa = tempargs->ecdsa;
1052     unsigned char *ecdsasig = tempargs->buf2;
1053     unsigned int *ecdsasiglen = tempargs->siglen;
1054     int ret, count;
1055     for (count = 0; COND(ecdsa_c[testnum][0]); count++) {
1056         ret = ECDSA_sign(0, buf, 20,
1057                 ecdsasig, ecdsasiglen, ecdsa[testnum]);
1058         if (ret == 0) {
1059             BIO_printf(bio_err, "ECDSA sign failure\n");
1060             ERR_print_errors(bio_err);
1061             count = -1;
1062             break;
1063         }
1064     }
1065     return count;
1066 }
1067
1068 static int ECDSA_verify_loop(void *args)
1069 {
1070     loopargs_t *tempargs = (loopargs_t *)args;
1071     unsigned char *buf = tempargs->buf;
1072     EC_KEY **ecdsa = tempargs->ecdsa;
1073     unsigned char *ecdsasig = tempargs->buf2;
1074     unsigned int ecdsasiglen = *(tempargs->siglen);
1075     int ret, count;
1076     for (count = 0; COND(ecdsa_c[testnum][1]); count++) {
1077         ret = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen,
1078                 ecdsa[testnum]);
1079         if (ret != 1) {
1080             BIO_printf(bio_err, "ECDSA verify failure\n");
1081             ERR_print_errors(bio_err);
1082             count = -1;
1083             break;
1084         }
1085     }
1086     return count;
1087 }
1088
1089 static int outlen;
1090 static void *(*kdf) (const void *in, size_t inlen, void *out,
1091         size_t *xoutlen);
1092
1093 static int ECDH_compute_key_loop(void *args)
1094 {
1095     loopargs_t *tempargs = (loopargs_t *)args;
1096     EC_KEY **ecdh_a = tempargs->ecdh_a;
1097     EC_KEY **ecdh_b = tempargs->ecdh_b;
1098     unsigned char *secret_a = tempargs->secret_a;
1099     int count;
1100     for (count = 0; COND(ecdh_c[testnum][0]); count++) {
1101         ECDH_compute_key(secret_a, outlen,
1102                 EC_KEY_get0_public_key(ecdh_b[testnum]),
1103                 ecdh_a[testnum], kdf);
1104     }
1105     return count;
1106 }
1107 #endif
1108
1109
1110 static int run_benchmark(int async_jobs, int (*loop_function)(void *), loopargs_t *loopargs)
1111 {
1112     int job_op_count = 0;
1113     int total_op_count = 0;
1114     int num_inprogress = 0;
1115     int error = 0;
1116     int i = 0;
1117     OSSL_ASYNC_FD job_fd = 0;
1118     size_t num_job_fds = 0;
1119
1120     run = 1;
1121
1122     if (async_jobs == 0) {
1123         return loop_function((void *)loopargs);
1124     }
1125
1126
1127     for (i = 0; i < async_jobs && !error; i++) {
1128         switch (ASYNC_start_job(&(loopargs[i].inprogress_job), loopargs[i].wait_ctx,
1129                                 &job_op_count, loop_function,
1130                                 (void *)(loopargs + i), sizeof(loopargs_t))) {
1131             case ASYNC_PAUSE:
1132                 ++num_inprogress;
1133                 break;
1134             case ASYNC_FINISH:
1135                 if (job_op_count == -1) {
1136                     error = 1;
1137                 } else {
1138                     total_op_count += job_op_count;
1139                 }
1140                 break;
1141             case ASYNC_NO_JOBS:
1142             case ASYNC_ERR:
1143                 BIO_printf(bio_err, "Failure in the job\n");
1144                 ERR_print_errors(bio_err);
1145                 error = 1;
1146                 break;
1147         }
1148     }
1149
1150     while (num_inprogress > 0) {
1151 #if defined(OPENSSL_SYS_WINDOWS)
1152         DWORD avail = 0;
1153 #elif defined(OPENSSL_SYS_UNIX)
1154         int select_result = 0;
1155         OSSL_ASYNC_FD max_fd = 0;
1156         fd_set waitfdset;
1157
1158         FD_ZERO(&waitfdset);
1159
1160         for (i = 0; i < async_jobs && num_inprogress > 0; i++) {
1161             if (loopargs[i].inprogress_job == NULL)
1162                 continue;
1163
1164             if (!ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, NULL, &num_job_fds)
1165                     || num_job_fds > 1) {
1166                 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1167                 ERR_print_errors(bio_err);
1168                 error = 1;
1169                 break;
1170             }
1171             ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd, &num_job_fds);
1172             FD_SET(job_fd, &waitfdset);
1173             if (job_fd > max_fd)
1174                 max_fd = job_fd;
1175         }
1176
1177         if (max_fd >= FD_SETSIZE) {
1178             BIO_printf(bio_err,
1179                     "Error: max_fd (%d) must be smaller than FD_SETSIZE (%d). "
1180                     "Decrease the value of async_jobs\n",
1181                     max_fd, FD_SETSIZE);
1182             ERR_print_errors(bio_err);
1183             error = 1;
1184             break;
1185         }
1186
1187         select_result = select(max_fd + 1, &waitfdset, NULL, NULL, NULL);
1188         if (select_result == -1 && errno == EINTR)
1189             continue;
1190
1191         if (select_result == -1) {
1192             BIO_printf(bio_err, "Failure in the select\n");
1193             ERR_print_errors(bio_err);
1194             error = 1;
1195             break;
1196         }
1197
1198         if (select_result == 0)
1199             continue;
1200 #endif
1201
1202         for (i = 0; i < async_jobs; i++) {
1203             if (loopargs[i].inprogress_job == NULL)
1204                 continue;
1205
1206             if (!ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, NULL, &num_job_fds)
1207                     || num_job_fds > 1) {
1208                 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1209                 ERR_print_errors(bio_err);
1210                 error = 1;
1211                 break;
1212             }
1213             ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd, &num_job_fds);
1214
1215 #if defined(OPENSSL_SYS_UNIX)
1216             if (num_job_fds == 1 && !FD_ISSET(job_fd, &waitfdset))
1217                 continue;
1218 #elif defined(OPENSSL_SYS_WINDOWS)
1219             if (num_job_fds == 1 &&
1220                     !PeekNamedPipe(job_fd, NULL, 0, NULL, &avail, NULL) && avail > 0)
1221                 continue;
1222 #endif
1223
1224             switch (ASYNC_start_job(&(loopargs[i].inprogress_job), loopargs[i].wait_ctx,
1225                         &job_op_count, loop_function, (void *)(loopargs + i),
1226                         sizeof(loopargs_t))) {
1227                 case ASYNC_PAUSE:
1228                     break;
1229                 case ASYNC_FINISH:
1230                     if (job_op_count == -1) {
1231                         error = 1;
1232                     } else {
1233                         total_op_count += job_op_count;
1234                     }
1235                     --num_inprogress;
1236                     loopargs[i].inprogress_job = NULL;
1237                     break;
1238                 case ASYNC_NO_JOBS:
1239                 case ASYNC_ERR:
1240                     --num_inprogress;
1241                     loopargs[i].inprogress_job = NULL;
1242                     BIO_printf(bio_err, "Failure in the job\n");
1243                     ERR_print_errors(bio_err);
1244                     error = 1;
1245                     break;
1246             }
1247         }
1248     }
1249
1250     return error ? -1 : total_op_count;
1251 }
1252
1253 int speed_main(int argc, char **argv)
1254 {
1255     loopargs_t *loopargs = NULL;
1256     int loopargs_len = 0;
1257     char *prog;
1258     const EVP_CIPHER *evp_cipher = NULL;
1259     double d = 0.0;
1260     OPTION_CHOICE o;
1261     int multiblock = 0, doit[ALGOR_NUM], pr_header = 0;
1262 #ifndef OPENSSL_NO_DSA
1263     int dsa_doit[DSA_NUM];
1264 #endif
1265     int rsa_doit[RSA_NUM];
1266     int ret = 1, i, k, misalign = 0;
1267     long c[ALGOR_NUM][SIZE_NUM], count = 0, save_count = 0;
1268 #ifndef NO_FORK
1269     int multi = 0;
1270 #endif
1271     int async_jobs = 0;
1272     /* What follows are the buffers and key material. */
1273 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA)
1274     long rsa_count = 1;
1275 #endif
1276 #ifndef OPENSSL_NO_RC5
1277     RC5_32_KEY rc5_ks;
1278 #endif
1279 #ifndef OPENSSL_NO_RC2
1280     RC2_KEY rc2_ks;
1281 #endif
1282 #ifndef OPENSSL_NO_IDEA
1283     IDEA_KEY_SCHEDULE idea_ks;
1284 #endif
1285 #ifndef OPENSSL_NO_SEED
1286     SEED_KEY_SCHEDULE seed_ks;
1287 #endif
1288 #ifndef OPENSSL_NO_BF
1289     BF_KEY bf_ks;
1290 #endif
1291 #ifndef OPENSSL_NO_CAST
1292     CAST_KEY cast_ks;
1293 #endif
1294     static const unsigned char key16[16] = {
1295         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1296         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1297     };
1298 #ifndef OPENSSL_NO_AES
1299     static const unsigned char key24[24] = {
1300         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1301         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1302         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1303     };
1304     static const unsigned char key32[32] = {
1305         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1306         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1307         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1308         0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1309     };
1310 #endif
1311 #ifndef OPENSSL_NO_CAMELLIA
1312     static const unsigned char ckey24[24] = {
1313         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1314         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1315         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1316     };
1317     static const unsigned char ckey32[32] = {
1318         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1319         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1320         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1321         0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1322     };
1323     CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
1324 #endif
1325 #ifndef OPENSSL_NO_DES
1326     static DES_cblock key = {
1327         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
1328     };
1329     static DES_cblock key2 = {
1330         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1331     };
1332     static DES_cblock key3 = {
1333         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1334     };
1335 #endif
1336 #ifndef OPENSSL_NO_RSA
1337     static unsigned int rsa_bits[RSA_NUM] = {
1338         512, 1024, 2048, 3072, 4096, 7680, 15360
1339     };
1340     static unsigned char *rsa_data[RSA_NUM] = {
1341         test512, test1024, test2048, test3072, test4096, test7680, test15360
1342     };
1343     static int rsa_data_length[RSA_NUM] = {
1344         sizeof(test512), sizeof(test1024),
1345         sizeof(test2048), sizeof(test3072),
1346         sizeof(test4096), sizeof(test7680),
1347         sizeof(test15360)
1348     };
1349 #endif
1350 #ifndef OPENSSL_NO_DSA
1351     static unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
1352 #endif
1353 #ifndef OPENSSL_NO_EC
1354     /*
1355      * We only test over the following curves as they are representative, To
1356      * add tests over more curves, simply add the curve NID and curve name to
1357      * the following arrays and increase the EC_NUM value accordingly.
1358      */
1359     static unsigned int test_curves[EC_NUM] = {
1360         /* Prime Curves */
1361         NID_secp160r1, NID_X9_62_prime192v1, NID_secp224r1,
1362         NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
1363         /* Binary Curves */
1364         NID_sect163k1, NID_sect233k1, NID_sect283k1,
1365         NID_sect409k1, NID_sect571k1, NID_sect163r2,
1366         NID_sect233r1, NID_sect283r1, NID_sect409r1,
1367         NID_sect571r1,
1368         /* Other */
1369         NID_X25519
1370     };
1371     static const char *test_curves_names[EC_NUM] = {
1372         /* Prime Curves */
1373         "secp160r1", "nistp192", "nistp224",
1374         "nistp256", "nistp384", "nistp521",
1375         /* Binary Curves */
1376         "nistk163", "nistk233", "nistk283",
1377         "nistk409", "nistk571", "nistb163",
1378         "nistb233", "nistb283", "nistb409",
1379         "nistb571",
1380         /* Other */
1381         "X25519"
1382     };
1383     static int test_curves_bits[EC_NUM] = {
1384         160, 192, 224,
1385         256, 384, 521,
1386         163, 233, 283,
1387         409, 571, 163,
1388         233, 283, 409,
1389         571, 253 /* X25519 */
1390     };
1391 #endif
1392 #ifndef OPENSSL_NO_EC
1393     int ecdsa_doit[EC_NUM];
1394     int secret_size_a, secret_size_b;
1395     int ecdh_checks = 1;
1396     int secret_idx = 0;
1397     long ecdh_c[EC_NUM][2];
1398     int ecdh_doit[EC_NUM];
1399 #endif
1400
1401     memset(results, 0, sizeof(results));
1402
1403     memset(c, 0, sizeof(c));
1404 #ifndef OPENSSL_NO_DES
1405     memset(DES_iv, 0, sizeof(DES_iv));
1406 #endif
1407     memset(iv, 0, sizeof(iv));
1408
1409     for (i = 0; i < ALGOR_NUM; i++)
1410         doit[i] = 0;
1411     for (i = 0; i < RSA_NUM; i++)
1412         rsa_doit[i] = 0;
1413 #ifndef OPENSSL_NO_DSA
1414     for (i = 0; i < DSA_NUM; i++)
1415         dsa_doit[i] = 0;
1416 #endif
1417 #ifndef OPENSSL_NO_EC
1418     for (i = 0; i < EC_NUM; i++)
1419         ecdsa_doit[i] = 0;
1420     for (i = 0; i < EC_NUM; i++)
1421         ecdh_doit[i] = 0;
1422 #endif
1423
1424     misalign = 0;
1425
1426     prog = opt_init(argc, argv, speed_options);
1427     while ((o = opt_next()) != OPT_EOF) {
1428         switch (o) {
1429         case OPT_EOF:
1430         case OPT_ERR:
1431  opterr:
1432             BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
1433             goto end;
1434         case OPT_HELP:
1435             opt_help(speed_options);
1436             ret = 0;
1437             goto end;
1438         case OPT_ELAPSED:
1439             usertime = 0;
1440             break;
1441         case OPT_EVP:
1442             evp_cipher = EVP_get_cipherbyname(opt_arg());
1443             if (evp_cipher == NULL)
1444                 evp_md = EVP_get_digestbyname(opt_arg());
1445             if (evp_cipher == NULL && evp_md == NULL) {
1446                 BIO_printf(bio_err,
1447                            "%s: %s  an unknown cipher or digest\n",
1448                            prog, opt_arg());
1449                 goto end;
1450             }
1451             doit[D_EVP] = 1;
1452             break;
1453         case OPT_DECRYPT:
1454             decrypt = 1;
1455             break;
1456         case OPT_ENGINE:
1457             /*
1458              * In a forked execution, an engine might need to be
1459              * initialised by each child process, not by the parent.
1460              * So store the name here and run setup_engine() later on.
1461              */
1462             engine_id = opt_arg();
1463             break;
1464         case OPT_MULTI:
1465 #ifndef NO_FORK
1466             multi = atoi(opt_arg());
1467 #endif
1468             break;
1469         case OPT_ASYNCJOBS:
1470 #ifndef OPENSSL_NO_ASYNC
1471             async_jobs = atoi(opt_arg());
1472             if (!ASYNC_is_capable()) {
1473                 BIO_printf(bio_err,
1474                            "%s: async_jobs specified but async not supported\n",
1475                            prog);
1476                 goto opterr;
1477             }
1478 #endif
1479             break;
1480         case OPT_MISALIGN:
1481             if (!opt_int(opt_arg(), &misalign))
1482                 goto end;
1483             if (misalign > MISALIGN) {
1484                 BIO_printf(bio_err,
1485                            "%s: Maximum offset is %d\n", prog, MISALIGN);
1486                 goto opterr;
1487             }
1488             break;
1489         case OPT_MR:
1490             mr = 1;
1491             break;
1492         case OPT_MB:
1493             multiblock = 1;
1494             break;
1495         }
1496     }
1497     argc = opt_num_rest();
1498     argv = opt_rest();
1499
1500     /* Remaining arguments are algorithms. */
1501     for ( ; *argv; argv++) {
1502         if (found(*argv, doit_choices, &i)) {
1503             doit[i] = 1;
1504             continue;
1505         }
1506 #ifndef OPENSSL_NO_DES
1507         if (strcmp(*argv, "des") == 0) {
1508             doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
1509             continue;
1510         }
1511 #endif
1512         if (strcmp(*argv, "sha") == 0) {
1513             doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
1514             continue;
1515         }
1516 #ifndef OPENSSL_NO_RSA
1517 # ifndef RSA_NULL
1518         if (strcmp(*argv, "openssl") == 0) {
1519             RSA_set_default_method(RSA_PKCS1_OpenSSL());
1520             continue;
1521         }
1522 # endif
1523         if (strcmp(*argv, "rsa") == 0) {
1524             rsa_doit[R_RSA_512] = rsa_doit[R_RSA_1024] =
1525                 rsa_doit[R_RSA_2048] = rsa_doit[R_RSA_3072] =
1526                 rsa_doit[R_RSA_4096] = rsa_doit[R_RSA_7680] =
1527                 rsa_doit[R_RSA_15360] = 1;
1528             continue;
1529         }
1530         if (found(*argv, rsa_choices, &i)) {
1531             rsa_doit[i] = 1;
1532             continue;
1533         }
1534 #endif
1535 #ifndef OPENSSL_NO_DSA
1536         if (strcmp(*argv, "dsa") == 0) {
1537             dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
1538                 dsa_doit[R_DSA_2048] = 1;
1539             continue;
1540         }
1541         if (found(*argv, dsa_choices, &i)) {
1542             dsa_doit[i] = 2;
1543             continue;
1544         }
1545 #endif
1546 #ifndef OPENSSL_NO_AES
1547         if (strcmp(*argv, "aes") == 0) {
1548             doit[D_CBC_128_AES] = doit[D_CBC_192_AES] =
1549                 doit[D_CBC_256_AES] = 1;
1550             continue;
1551         }
1552 #endif
1553 #ifndef OPENSSL_NO_CAMELLIA
1554         if (strcmp(*argv, "camellia") == 0) {
1555             doit[D_CBC_128_CML] = doit[D_CBC_192_CML] =
1556                 doit[D_CBC_256_CML] = 1;
1557             continue;
1558         }
1559 #endif
1560 #ifndef OPENSSL_NO_EC
1561         if (strcmp(*argv, "ecdsa") == 0) {
1562             for (i = 0; i < EC_NUM; i++)
1563                 ecdsa_doit[i] = 1;
1564             continue;
1565         }
1566         if (found(*argv, ecdsa_choices, &i)) {
1567             ecdsa_doit[i] = 2;
1568             continue;
1569         }
1570         if (strcmp(*argv, "ecdh") == 0) {
1571             for (i = 0; i < EC_NUM; i++)
1572                 ecdh_doit[i] = 1;
1573             continue;
1574         }
1575         if (found(*argv, ecdh_choices, &i)) {
1576             ecdh_doit[i] = 2;
1577             continue;
1578         }
1579 #endif
1580         BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
1581         goto end;
1582     }
1583
1584     /* Initialize the job pool if async mode is enabled */
1585     if (async_jobs > 0) {
1586         if (!ASYNC_init_thread(async_jobs, async_jobs)) {
1587             BIO_printf(bio_err, "Error creating the ASYNC job pool\n");
1588             goto end;
1589         }
1590     }
1591
1592     loopargs_len = (async_jobs == 0 ? 1 : async_jobs);
1593     loopargs = app_malloc(loopargs_len * sizeof(loopargs_t), "array of loopargs");
1594     memset(loopargs, 0, loopargs_len * sizeof(loopargs_t));
1595
1596     for (i = 0; i < loopargs_len; i++) {
1597         if (async_jobs > 0) {
1598             loopargs[i].wait_ctx = ASYNC_WAIT_CTX_new();
1599             if (loopargs[i].wait_ctx == NULL) {
1600                 BIO_printf(bio_err, "Error creating the ASYNC_WAIT_CTX\n");
1601                 goto end;
1602             }
1603         }
1604
1605         loopargs[i].buf_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1606         loopargs[i].buf2_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1607         /* Align the start of buffers on a 64 byte boundary */
1608         loopargs[i].buf = loopargs[i].buf_malloc + misalign;
1609         loopargs[i].buf2 = loopargs[i].buf2_malloc + misalign;
1610         loopargs[i].siglen = app_malloc(sizeof(unsigned int), "signature length");
1611 #ifndef OPENSSL_NO_EC
1612         loopargs[i].secret_a = app_malloc(MAX_ECDH_SIZE, "ECDH secret a");
1613         loopargs[i].secret_b = app_malloc(MAX_ECDH_SIZE, "ECDH secret b");
1614 #endif
1615     }
1616
1617 #ifndef NO_FORK
1618     if (multi && do_multi(multi))
1619         goto show_res;
1620 #endif
1621
1622     /* Initialize the engine after the fork */
1623     (void)setup_engine(engine_id, 0);
1624
1625     /* No parameters; turn on everything. */
1626     if ((argc == 0) && !doit[D_EVP]) {
1627         for (i = 0; i < ALGOR_NUM; i++)
1628             if (i != D_EVP)
1629                 doit[i] = 1;
1630         for (i = 0; i < RSA_NUM; i++)
1631             rsa_doit[i] = 1;
1632 #ifndef OPENSSL_NO_DSA
1633         for (i = 0; i < DSA_NUM; i++)
1634             dsa_doit[i] = 1;
1635 #endif
1636 #ifndef OPENSSL_NO_EC
1637         for (i = 0; i < EC_NUM; i++)
1638             ecdsa_doit[i] = 1;
1639         for (i = 0; i < EC_NUM; i++)
1640             ecdh_doit[i] = 1;
1641 #endif
1642     }
1643     for (i = 0; i < ALGOR_NUM; i++)
1644         if (doit[i])
1645             pr_header++;
1646
1647     if (usertime == 0 && !mr)
1648         BIO_printf(bio_err,
1649                    "You have chosen to measure elapsed time "
1650                    "instead of user CPU time.\n");
1651
1652 #ifndef OPENSSL_NO_RSA
1653     for (i = 0; i < loopargs_len; i++) {
1654         for (k = 0; k < RSA_NUM; k++) {
1655             const unsigned char *p;
1656
1657             p = rsa_data[k];
1658             loopargs[i].rsa_key[k] = d2i_RSAPrivateKey(NULL, &p, rsa_data_length[k]);
1659             if (loopargs[i].rsa_key[k] == NULL) {
1660                 BIO_printf(bio_err, "internal error loading RSA key number %d\n",
1661                         k);
1662                 goto end;
1663             }
1664         }
1665     }
1666 #endif
1667 #ifndef OPENSSL_NO_DSA
1668     for (i = 0; i < loopargs_len; i++) {
1669         loopargs[i].dsa_key[0] = get_dsa512();
1670         loopargs[i].dsa_key[1] = get_dsa1024();
1671         loopargs[i].dsa_key[2] = get_dsa2048();
1672     }
1673 #endif
1674 #ifndef OPENSSL_NO_DES
1675     DES_set_key_unchecked(&key, &sch);
1676     DES_set_key_unchecked(&key2, &sch2);
1677     DES_set_key_unchecked(&key3, &sch3);
1678 #endif
1679 #ifndef OPENSSL_NO_AES
1680     AES_set_encrypt_key(key16, 128, &aes_ks1);
1681     AES_set_encrypt_key(key24, 192, &aes_ks2);
1682     AES_set_encrypt_key(key32, 256, &aes_ks3);
1683 #endif
1684 #ifndef OPENSSL_NO_CAMELLIA
1685     Camellia_set_key(key16, 128, &camellia_ks1);
1686     Camellia_set_key(ckey24, 192, &camellia_ks2);
1687     Camellia_set_key(ckey32, 256, &camellia_ks3);
1688 #endif
1689 #ifndef OPENSSL_NO_IDEA
1690     idea_set_encrypt_key(key16, &idea_ks);
1691 #endif
1692 #ifndef OPENSSL_NO_SEED
1693     SEED_set_key(key16, &seed_ks);
1694 #endif
1695 #ifndef OPENSSL_NO_RC4
1696     RC4_set_key(&rc4_ks, 16, key16);
1697 #endif
1698 #ifndef OPENSSL_NO_RC2
1699     RC2_set_key(&rc2_ks, 16, key16, 128);
1700 #endif
1701 #ifndef OPENSSL_NO_RC5
1702     RC5_32_set_key(&rc5_ks, 16, key16, 12);
1703 #endif
1704 #ifndef OPENSSL_NO_BF
1705     BF_set_key(&bf_ks, 16, key16);
1706 #endif
1707 #ifndef OPENSSL_NO_CAST
1708     CAST_set_key(&cast_ks, 16, key16);
1709 #endif
1710 #ifndef OPENSSL_NO_RSA
1711     memset(rsa_c, 0, sizeof(rsa_c));
1712 #endif
1713 #ifndef SIGALRM
1714 # ifndef OPENSSL_NO_DES
1715     BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1716     count = 10;
1717     do {
1718         long it;
1719         count *= 2;
1720         Time_F(START);
1721         for (it = count; it; it--)
1722             DES_ecb_encrypt((DES_cblock *)loopargs[0].buf,
1723                             (DES_cblock *)loopargs[0].buf, &sch, DES_ENCRYPT);
1724         d = Time_F(STOP);
1725     } while (d < 3);
1726     save_count = count;
1727     c[D_MD2][0] = count / 10;
1728     c[D_MDC2][0] = count / 10;
1729     c[D_MD4][0] = count;
1730     c[D_MD5][0] = count;
1731     c[D_HMAC][0] = count;
1732     c[D_SHA1][0] = count;
1733     c[D_RMD160][0] = count;
1734     c[D_RC4][0] = count * 5;
1735     c[D_CBC_DES][0] = count;
1736     c[D_EDE3_DES][0] = count / 3;
1737     c[D_CBC_IDEA][0] = count;
1738     c[D_CBC_SEED][0] = count;
1739     c[D_CBC_RC2][0] = count;
1740     c[D_CBC_RC5][0] = count;
1741     c[D_CBC_BF][0] = count;
1742     c[D_CBC_CAST][0] = count;
1743     c[D_CBC_128_AES][0] = count;
1744     c[D_CBC_192_AES][0] = count;
1745     c[D_CBC_256_AES][0] = count;
1746     c[D_CBC_128_CML][0] = count;
1747     c[D_CBC_192_CML][0] = count;
1748     c[D_CBC_256_CML][0] = count;
1749     c[D_SHA256][0] = count;
1750     c[D_SHA512][0] = count;
1751     c[D_WHIRLPOOL][0] = count;
1752     c[D_IGE_128_AES][0] = count;
1753     c[D_IGE_192_AES][0] = count;
1754     c[D_IGE_256_AES][0] = count;
1755     c[D_GHASH][0] = count;
1756
1757     for (i = 1; i < SIZE_NUM; i++) {
1758         long l0, l1;
1759
1760         l0 = (long)lengths[0];
1761         l1 = (long)lengths[i];
1762
1763         c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1764         c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1765         c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1766         c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1767         c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1768         c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1769         c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1770         c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1771         c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1772         c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1773         c[D_GHASH][i] = c[D_GHASH][0] * 4 * l0 / l1;
1774
1775         l0 = (long)lengths[i - 1];
1776
1777         c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1778         c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1779         c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1780         c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1781         c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1782         c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1783         c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1784         c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1785         c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1786         c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1787         c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1788         c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1789         c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1790         c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1791         c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1792         c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1793         c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1794         c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1795     }
1796
1797 #  ifndef OPENSSL_NO_RSA
1798     rsa_c[R_RSA_512][0] = count / 2000;
1799     rsa_c[R_RSA_512][1] = count / 400;
1800     for (i = 1; i < RSA_NUM; i++) {
1801         rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1802         rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1803         if ((rsa_doit[i] <= 1) && (rsa_c[i][0] == 0))
1804             rsa_doit[i] = 0;
1805         else {
1806             if (rsa_c[i][0] == 0) {
1807                 rsa_c[i][0] = 1;
1808                 rsa_c[i][1] = 20;
1809             }
1810         }
1811     }
1812 #  endif
1813
1814 #  ifndef OPENSSL_NO_DSA
1815     dsa_c[R_DSA_512][0] = count / 1000;
1816     dsa_c[R_DSA_512][1] = count / 1000 / 2;
1817     for (i = 1; i < DSA_NUM; i++) {
1818         dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1819         dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1820         if ((dsa_doit[i] <= 1) && (dsa_c[i][0] == 0))
1821             dsa_doit[i] = 0;
1822         else {
1823             if (dsa_c[i] == 0) {
1824                 dsa_c[i][0] = 1;
1825                 dsa_c[i][1] = 1;
1826             }
1827         }
1828     }
1829 #  endif
1830
1831 #  ifndef OPENSSL_NO_EC
1832     ecdsa_c[R_EC_P160][0] = count / 1000;
1833     ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1834     for (i = R_EC_P192; i <= R_EC_P521; i++) {
1835         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1836         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1837         if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1838             ecdsa_doit[i] = 0;
1839         else {
1840             if (ecdsa_c[i] == 0) {
1841                 ecdsa_c[i][0] = 1;
1842                 ecdsa_c[i][1] = 1;
1843             }
1844         }
1845     }
1846     ecdsa_c[R_EC_K163][0] = count / 1000;
1847     ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1848     for (i = R_EC_K233; i <= R_EC_K571; i++) {
1849         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1850         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1851         if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1852             ecdsa_doit[i] = 0;
1853         else {
1854             if (ecdsa_c[i] == 0) {
1855                 ecdsa_c[i][0] = 1;
1856                 ecdsa_c[i][1] = 1;
1857             }
1858         }
1859     }
1860     ecdsa_c[R_EC_B163][0] = count / 1000;
1861     ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1862     for (i = R_EC_B233; i <= R_EC_B571; i++) {
1863         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1864         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1865         if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1866             ecdsa_doit[i] = 0;
1867         else {
1868             if (ecdsa_c[i] == 0) {
1869                 ecdsa_c[i][0] = 1;
1870                 ecdsa_c[i][1] = 1;
1871             }
1872         }
1873     }
1874
1875     ecdh_c[R_EC_P160][0] = count / 1000;
1876     ecdh_c[R_EC_P160][1] = count / 1000;
1877     for (i = R_EC_P192; i <= R_EC_P521; i++) {
1878         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1879         ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1880         if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1881             ecdh_doit[i] = 0;
1882         else {
1883             if (ecdh_c[i] == 0) {
1884                 ecdh_c[i][0] = 1;
1885                 ecdh_c[i][1] = 1;
1886             }
1887         }
1888     }
1889     ecdh_c[R_EC_K163][0] = count / 1000;
1890     ecdh_c[R_EC_K163][1] = count / 1000;
1891     for (i = R_EC_K233; i <= R_EC_K571; i++) {
1892         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1893         ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1894         if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1895             ecdh_doit[i] = 0;
1896         else {
1897             if (ecdh_c[i] == 0) {
1898                 ecdh_c[i][0] = 1;
1899                 ecdh_c[i][1] = 1;
1900             }
1901         }
1902     }
1903     ecdh_c[R_EC_B163][0] = count / 1000;
1904     ecdh_c[R_EC_B163][1] = count / 1000;
1905     for (i = R_EC_B233; i <= R_EC_B571; i++) {
1906         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1907         ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1908         if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1909             ecdh_doit[i] = 0;
1910         else {
1911             if (ecdh_c[i] == 0) {
1912                 ecdh_c[i][0] = 1;
1913                 ecdh_c[i][1] = 1;
1914             }
1915         }
1916     }
1917 #  endif
1918
1919 # else
1920 /* not worth fixing */
1921 #  error "You cannot disable DES on systems without SIGALRM."
1922 # endif                        /* OPENSSL_NO_DES */
1923 #else
1924 # ifndef _WIN32
1925     signal(SIGALRM, sig_done);
1926 # endif
1927 #endif                         /* SIGALRM */
1928
1929 #ifndef OPENSSL_NO_MD2
1930     if (doit[D_MD2]) {
1931         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1932             print_message(names[D_MD2], c[D_MD2][testnum], lengths[testnum]);
1933             Time_F(START);
1934             count = run_benchmark(async_jobs, EVP_Digest_MD2_loop, loopargs);
1935             d = Time_F(STOP);
1936             print_result(D_MD2, testnum, count, d);
1937         }
1938     }
1939 #endif
1940 #ifndef OPENSSL_NO_MDC2
1941     if (doit[D_MDC2]) {
1942         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1943             print_message(names[D_MDC2], c[D_MDC2][testnum], lengths[testnum]);
1944             Time_F(START);
1945             count = run_benchmark(async_jobs, EVP_Digest_MDC2_loop, loopargs);
1946             d = Time_F(STOP);
1947             print_result(D_MDC2, testnum, count, d);
1948         }
1949     }
1950 #endif
1951
1952 #ifndef OPENSSL_NO_MD4
1953     if (doit[D_MD4]) {
1954         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1955             print_message(names[D_MD4], c[D_MD4][testnum], lengths[testnum]);
1956             Time_F(START);
1957             count = run_benchmark(async_jobs, EVP_Digest_MD4_loop, loopargs);
1958             d = Time_F(STOP);
1959             print_result(D_MD4, testnum, count, d);
1960         }
1961     }
1962 #endif
1963
1964 #ifndef OPENSSL_NO_MD5
1965     if (doit[D_MD5]) {
1966         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1967             print_message(names[D_MD5], c[D_MD5][testnum], lengths[testnum]);
1968             Time_F(START);
1969             count = run_benchmark(async_jobs, MD5_loop, loopargs);
1970             d = Time_F(STOP);
1971             print_result(D_MD5, testnum, count, d);
1972         }
1973     }
1974 #endif
1975
1976 #ifndef OPENSSL_NO_MD5
1977     if (doit[D_HMAC]) {
1978         for (i = 0; i < loopargs_len; i++) {
1979             loopargs[i].hctx = HMAC_CTX_new();
1980             if (loopargs[i].hctx == NULL) {
1981                 BIO_printf(bio_err, "HMAC malloc failure, exiting...");
1982                 exit(1);
1983             }
1984
1985             HMAC_Init_ex(loopargs[i].hctx, (unsigned char *)"This is a key...",
1986                     16, EVP_md5(), NULL);
1987         }
1988         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1989             print_message(names[D_HMAC], c[D_HMAC][testnum], lengths[testnum]);
1990             Time_F(START);
1991             count = run_benchmark(async_jobs, HMAC_loop, loopargs);
1992             d = Time_F(STOP);
1993             print_result(D_HMAC, testnum, count, d);
1994         }
1995         for (i = 0; i < loopargs_len; i++) {
1996             HMAC_CTX_free(loopargs[i].hctx);
1997         }
1998     }
1999 #endif
2000     if (doit[D_SHA1]) {
2001         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2002             print_message(names[D_SHA1], c[D_SHA1][testnum], lengths[testnum]);
2003             Time_F(START);
2004             count = run_benchmark(async_jobs, SHA1_loop, loopargs);
2005             d = Time_F(STOP);
2006             print_result(D_SHA1, testnum, count, d);
2007         }
2008     }
2009     if (doit[D_SHA256]) {
2010         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2011             print_message(names[D_SHA256], c[D_SHA256][testnum], lengths[testnum]);
2012             Time_F(START);
2013             count = run_benchmark(async_jobs, SHA256_loop, loopargs);
2014             d = Time_F(STOP);
2015             print_result(D_SHA256, testnum, count, d);
2016         }
2017     }
2018     if (doit[D_SHA512]) {
2019         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2020             print_message(names[D_SHA512], c[D_SHA512][testnum], lengths[testnum]);
2021             Time_F(START);
2022             count = run_benchmark(async_jobs, SHA512_loop, loopargs);
2023             d = Time_F(STOP);
2024             print_result(D_SHA512, testnum, count, d);
2025         }
2026     }
2027
2028 #ifndef OPENSSL_NO_WHIRLPOOL
2029     if (doit[D_WHIRLPOOL]) {
2030         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2031             print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][testnum], lengths[testnum]);
2032             Time_F(START);
2033             count = run_benchmark(async_jobs, WHIRLPOOL_loop, loopargs);
2034             d = Time_F(STOP);
2035             print_result(D_WHIRLPOOL, testnum, count, d);
2036         }
2037     }
2038 #endif
2039
2040 #ifndef OPENSSL_NO_RMD160
2041     if (doit[D_RMD160]) {
2042         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2043             print_message(names[D_RMD160], c[D_RMD160][testnum], lengths[testnum]);
2044             Time_F(START);
2045             count = run_benchmark(async_jobs, EVP_Digest_RMD160_loop, loopargs);
2046             d = Time_F(STOP);
2047             print_result(D_RMD160, testnum, count, d);
2048         }
2049     }
2050 #endif
2051 #ifndef OPENSSL_NO_RC4
2052     if (doit[D_RC4]) {
2053         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2054             print_message(names[D_RC4], c[D_RC4][testnum], lengths[testnum]);
2055             Time_F(START);
2056             count = run_benchmark(async_jobs, RC4_loop, loopargs);
2057             d = Time_F(STOP);
2058             print_result(D_RC4, testnum, count, d);
2059         }
2060     }
2061 #endif
2062 #ifndef OPENSSL_NO_DES
2063     if (doit[D_CBC_DES]) {
2064         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2065             print_message(names[D_CBC_DES], c[D_CBC_DES][testnum], lengths[testnum]);
2066             Time_F(START);
2067             count = run_benchmark(async_jobs, DES_ncbc_encrypt_loop, loopargs);
2068             d = Time_F(STOP);
2069             print_result(D_CBC_DES, testnum, count, d);
2070         }
2071     }
2072
2073     if (doit[D_EDE3_DES]) {
2074         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2075             print_message(names[D_EDE3_DES], c[D_EDE3_DES][testnum], lengths[testnum]);
2076             Time_F(START);
2077             count = run_benchmark(async_jobs, DES_ede3_cbc_encrypt_loop, loopargs);
2078             d = Time_F(STOP);
2079             print_result(D_EDE3_DES, testnum, count, d);
2080         }
2081     }
2082 #endif
2083 #ifndef OPENSSL_NO_AES
2084     if (doit[D_CBC_128_AES]) {
2085         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2086             print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][testnum],
2087                           lengths[testnum]);
2088             Time_F(START);
2089             count = run_benchmark(async_jobs, AES_cbc_128_encrypt_loop, loopargs);
2090             d = Time_F(STOP);
2091             print_result(D_CBC_128_AES, testnum, count, d);
2092         }
2093     }
2094     if (doit[D_CBC_192_AES]) {
2095         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2096             print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][testnum],
2097                           lengths[testnum]);
2098             Time_F(START);
2099             count = run_benchmark(async_jobs, AES_cbc_192_encrypt_loop, loopargs);
2100             d = Time_F(STOP);
2101             print_result(D_CBC_192_AES, testnum, count, d);
2102         }
2103     }
2104     if (doit[D_CBC_256_AES]) {
2105         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2106             print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][testnum],
2107                           lengths[testnum]);
2108             Time_F(START);
2109             count = run_benchmark(async_jobs, AES_cbc_256_encrypt_loop, loopargs);
2110             d = Time_F(STOP);
2111             print_result(D_CBC_256_AES, testnum, count, d);
2112         }
2113     }
2114
2115     if (doit[D_IGE_128_AES]) {
2116         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2117             print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][testnum],
2118                           lengths[testnum]);
2119             Time_F(START);
2120             count = run_benchmark(async_jobs, AES_ige_128_encrypt_loop, loopargs);
2121             d = Time_F(STOP);
2122             print_result(D_IGE_128_AES, testnum, count, d);
2123         }
2124     }
2125     if (doit[D_IGE_192_AES]) {
2126         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2127             print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][testnum],
2128                           lengths[testnum]);
2129             Time_F(START);
2130             count = run_benchmark(async_jobs, AES_ige_192_encrypt_loop, loopargs);
2131             d = Time_F(STOP);
2132             print_result(D_IGE_192_AES, testnum, count, d);
2133         }
2134     }
2135     if (doit[D_IGE_256_AES]) {
2136         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2137             print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][testnum],
2138                           lengths[testnum]);
2139             Time_F(START);
2140             count = run_benchmark(async_jobs, AES_ige_256_encrypt_loop, loopargs);
2141             d = Time_F(STOP);
2142             print_result(D_IGE_256_AES, testnum, count, d);
2143         }
2144     }
2145     if (doit[D_GHASH]) {
2146         for (i = 0; i < loopargs_len; i++) {
2147             loopargs[i].gcm_ctx = CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
2148             CRYPTO_gcm128_setiv(loopargs[i].gcm_ctx, (unsigned char *)"0123456789ab", 12);
2149         }
2150
2151         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2152             print_message(names[D_GHASH], c[D_GHASH][testnum], lengths[testnum]);
2153             Time_F(START);
2154             count = run_benchmark(async_jobs, CRYPTO_gcm128_aad_loop, loopargs);
2155             d = Time_F(STOP);
2156             print_result(D_GHASH, testnum, count, d);
2157         }
2158         for (i = 0; i < loopargs_len; i++)
2159             CRYPTO_gcm128_release(loopargs[i].gcm_ctx);
2160     }
2161 #endif
2162 #ifndef OPENSSL_NO_CAMELLIA
2163     if (doit[D_CBC_128_CML]) {
2164         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2165             print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][testnum],
2166                           lengths[testnum]);
2167             if (async_jobs > 0) {
2168                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2169                 exit(1);
2170             }
2171             Time_F(START);
2172             for (count = 0, run = 1; COND(c[D_CBC_128_CML][testnum]); count++)
2173                 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2174                                      (unsigned long)lengths[testnum], &camellia_ks1,
2175                                      iv, CAMELLIA_ENCRYPT);
2176             d = Time_F(STOP);
2177             print_result(D_CBC_128_CML, testnum, count, d);
2178         }
2179     }
2180     if (doit[D_CBC_192_CML]) {
2181         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2182             print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][testnum],
2183                           lengths[testnum]);
2184             if (async_jobs > 0) {
2185                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2186                 exit(1);
2187             }
2188             Time_F(START);
2189             for (count = 0, run = 1; COND(c[D_CBC_192_CML][testnum]); count++)
2190                 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2191                                      (unsigned long)lengths[testnum], &camellia_ks2,
2192                                      iv, CAMELLIA_ENCRYPT);
2193             d = Time_F(STOP);
2194             print_result(D_CBC_192_CML, testnum, count, d);
2195         }
2196     }
2197     if (doit[D_CBC_256_CML]) {
2198         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2199             print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][testnum],
2200                           lengths[testnum]);
2201             if (async_jobs > 0) {
2202                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2203                 exit(1);
2204             }
2205             Time_F(START);
2206             for (count = 0, run = 1; COND(c[D_CBC_256_CML][testnum]); count++)
2207                 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2208                                      (unsigned long)lengths[testnum], &camellia_ks3,
2209                                      iv, CAMELLIA_ENCRYPT);
2210             d = Time_F(STOP);
2211             print_result(D_CBC_256_CML, testnum, count, d);
2212         }
2213     }
2214 #endif
2215 #ifndef OPENSSL_NO_IDEA
2216     if (doit[D_CBC_IDEA]) {
2217         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2218             print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][testnum], lengths[testnum]);
2219             if (async_jobs > 0) {
2220                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2221                 exit(1);
2222             }
2223             Time_F(START);
2224             for (count = 0, run = 1; COND(c[D_CBC_IDEA][testnum]); count++)
2225                 idea_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2226                                  (unsigned long)lengths[testnum], &idea_ks,
2227                                  iv, IDEA_ENCRYPT);
2228             d = Time_F(STOP);
2229             print_result(D_CBC_IDEA, testnum, count, d);
2230         }
2231     }
2232 #endif
2233 #ifndef OPENSSL_NO_SEED
2234     if (doit[D_CBC_SEED]) {
2235         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2236             print_message(names[D_CBC_SEED], c[D_CBC_SEED][testnum], lengths[testnum]);
2237             if (async_jobs > 0) {
2238                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2239                 exit(1);
2240             }
2241             Time_F(START);
2242             for (count = 0, run = 1; COND(c[D_CBC_SEED][testnum]); count++)
2243                 SEED_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2244                                  (unsigned long)lengths[testnum], &seed_ks, iv, 1);
2245             d = Time_F(STOP);
2246             print_result(D_CBC_SEED, testnum, count, d);
2247         }
2248     }
2249 #endif
2250 #ifndef OPENSSL_NO_RC2
2251     if (doit[D_CBC_RC2]) {
2252         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2253             print_message(names[D_CBC_RC2], c[D_CBC_RC2][testnum], lengths[testnum]);
2254             if (async_jobs > 0) {
2255                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2256                 exit(1);
2257             }
2258             Time_F(START);
2259             for (count = 0, run = 1; COND(c[D_CBC_RC2][testnum]); count++)
2260                 RC2_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2261                                 (unsigned long)lengths[testnum], &rc2_ks,
2262                                 iv, RC2_ENCRYPT);
2263             d = Time_F(STOP);
2264             print_result(D_CBC_RC2, testnum, count, d);
2265         }
2266     }
2267 #endif
2268 #ifndef OPENSSL_NO_RC5
2269     if (doit[D_CBC_RC5]) {
2270         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2271             print_message(names[D_CBC_RC5], c[D_CBC_RC5][testnum], lengths[testnum]);
2272             if (async_jobs > 0) {
2273                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2274                 exit(1);
2275             }
2276             Time_F(START);
2277             for (count = 0, run = 1; COND(c[D_CBC_RC5][testnum]); count++)
2278                 RC5_32_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2279                                    (unsigned long)lengths[testnum], &rc5_ks,
2280                                    iv, RC5_ENCRYPT);
2281             d = Time_F(STOP);
2282             print_result(D_CBC_RC5, testnum, count, d);
2283         }
2284     }
2285 #endif
2286 #ifndef OPENSSL_NO_BF
2287     if (doit[D_CBC_BF]) {
2288         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2289             print_message(names[D_CBC_BF], c[D_CBC_BF][testnum], lengths[testnum]);
2290             if (async_jobs > 0) {
2291                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2292                 exit(1);
2293             }
2294             Time_F(START);
2295             for (count = 0, run = 1; COND(c[D_CBC_BF][testnum]); count++)
2296                 BF_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2297                                (unsigned long)lengths[testnum], &bf_ks,
2298                                iv, BF_ENCRYPT);
2299             d = Time_F(STOP);
2300             print_result(D_CBC_BF, testnum, count, d);
2301         }
2302     }
2303 #endif
2304 #ifndef OPENSSL_NO_CAST
2305     if (doit[D_CBC_CAST]) {
2306         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2307             print_message(names[D_CBC_CAST], c[D_CBC_CAST][testnum], lengths[testnum]);
2308             if (async_jobs > 0) {
2309                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2310                 exit(1);
2311             }
2312             Time_F(START);
2313             for (count = 0, run = 1; COND(c[D_CBC_CAST][testnum]); count++)
2314                 CAST_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2315                                  (unsigned long)lengths[testnum], &cast_ks,
2316                                  iv, CAST_ENCRYPT);
2317             d = Time_F(STOP);
2318             print_result(D_CBC_CAST, testnum, count, d);
2319         }
2320     }
2321 #endif
2322
2323     if (doit[D_EVP]) {
2324 #ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
2325         if (multiblock && evp_cipher) {
2326             if (!
2327                 (EVP_CIPHER_flags(evp_cipher) &
2328                  EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
2329                 BIO_printf(bio_err, "%s is not multi-block capable\n",
2330                            OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher)));
2331                 goto end;
2332             }
2333             if (async_jobs > 0) {
2334                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2335                 exit(1);
2336             }
2337             multiblock_speed(evp_cipher);
2338             ret = 0;
2339             goto end;
2340         }
2341 #endif
2342         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2343             if (evp_cipher) {
2344
2345                 names[D_EVP] = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
2346                 /*
2347                  * -O3 -fschedule-insns messes up an optimization here!
2348                  * names[D_EVP] somehow becomes NULL
2349                  */
2350                 print_message(names[D_EVP], save_count, lengths[testnum]);
2351
2352                 for (k = 0; k < loopargs_len; k++) {
2353                     loopargs[k].ctx = EVP_CIPHER_CTX_new();
2354                     if (decrypt)
2355                         EVP_DecryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
2356                     else
2357                         EVP_EncryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
2358                     EVP_CIPHER_CTX_set_padding(loopargs[k].ctx, 0);
2359                 }
2360
2361                 Time_F(START);
2362                 count = run_benchmark(async_jobs, EVP_Update_loop, loopargs);
2363                 d = Time_F(STOP);
2364                 for (k = 0; k < loopargs_len; k++) {
2365                     EVP_CIPHER_CTX_free(loopargs[k].ctx);
2366                 }
2367             }
2368             if (evp_md) {
2369                 names[D_EVP] = OBJ_nid2ln(EVP_MD_type(evp_md));
2370                 print_message(names[D_EVP], save_count, lengths[testnum]);
2371                 Time_F(START);
2372                 count = run_benchmark(async_jobs, EVP_Digest_loop, loopargs);
2373                 d = Time_F(STOP);
2374             }
2375             print_result(D_EVP, testnum, count, d);
2376         }
2377     }
2378
2379     for (i = 0; i < loopargs_len; i++)
2380         RAND_bytes(loopargs[i].buf, 36);
2381
2382 #ifndef OPENSSL_NO_RSA
2383     for (testnum = 0; testnum < RSA_NUM; testnum++) {
2384         int st = 0;
2385         if (!rsa_doit[testnum])
2386             continue;
2387         for (i = 0; i < loopargs_len; i++) {
2388             st = RSA_sign(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2389                           loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2390             if (st == 0)
2391                 break;
2392         }
2393         if (st == 0) {
2394             BIO_printf(bio_err,
2395                        "RSA sign failure.  No RSA sign will be done.\n");
2396             ERR_print_errors(bio_err);
2397             rsa_count = 1;
2398         } else {
2399             pkey_print_message("private", "rsa",
2400                                rsa_c[testnum][0], rsa_bits[testnum], RSA_SECONDS);
2401             /* RSA_blinding_on(rsa_key[testnum],NULL); */
2402             Time_F(START);
2403             count = run_benchmark(async_jobs, RSA_sign_loop, loopargs);
2404             d = Time_F(STOP);
2405             BIO_printf(bio_err,
2406                        mr ? "+R1:%ld:%d:%.2f\n"
2407                        : "%ld %d bit private RSA's in %.2fs\n",
2408                        count, rsa_bits[testnum], d);
2409             rsa_results[testnum][0] = d / (double)count;
2410             rsa_count = count;
2411         }
2412
2413         for (i = 0; i < loopargs_len; i++) {
2414             st = RSA_verify(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2415                             *(loopargs[i].siglen), loopargs[i].rsa_key[testnum]);
2416             if (st <= 0)
2417                 break;
2418         }
2419         if (st <= 0) {
2420             BIO_printf(bio_err,
2421                        "RSA verify failure.  No RSA verify will be done.\n");
2422             ERR_print_errors(bio_err);
2423             rsa_doit[testnum] = 0;
2424         } else {
2425             pkey_print_message("public", "rsa",
2426                                rsa_c[testnum][1], rsa_bits[testnum], RSA_SECONDS);
2427             Time_F(START);
2428             count = run_benchmark(async_jobs, RSA_verify_loop, loopargs);
2429             d = Time_F(STOP);
2430             BIO_printf(bio_err,
2431                        mr ? "+R2:%ld:%d:%.2f\n"
2432                        : "%ld %d bit public RSA's in %.2fs\n",
2433                        count, rsa_bits[testnum], d);
2434             rsa_results[testnum][1] = d / (double)count;
2435         }
2436
2437         if (rsa_count <= 1) {
2438             /* if longer than 10s, don't do any more */
2439             for (testnum++; testnum < RSA_NUM; testnum++)
2440                 rsa_doit[testnum] = 0;
2441         }
2442     }
2443 #endif
2444
2445     for (i = 0; i < loopargs_len; i++)
2446         RAND_bytes(loopargs[i].buf, 36);
2447
2448 #ifndef OPENSSL_NO_DSA
2449     if (RAND_status() != 1) {
2450         RAND_seed(rnd_seed, sizeof rnd_seed);
2451         rnd_fake = 1;
2452     }
2453     for (testnum = 0; testnum < DSA_NUM; testnum++) {
2454         int st = 0;
2455         if (!dsa_doit[testnum])
2456             continue;
2457
2458         /* DSA_generate_key(dsa_key[testnum]); */
2459         /* DSA_sign_setup(dsa_key[testnum],NULL); */
2460         for (i = 0; i < loopargs_len; i++) {
2461             st = DSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2462                           loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2463             if (st == 0)
2464                 break;
2465         }
2466         if (st == 0) {
2467             BIO_printf(bio_err,
2468                        "DSA sign failure.  No DSA sign will be done.\n");
2469             ERR_print_errors(bio_err);
2470             rsa_count = 1;
2471         } else {
2472             pkey_print_message("sign", "dsa",
2473                                dsa_c[testnum][0], dsa_bits[testnum], DSA_SECONDS);
2474             Time_F(START);
2475             count = run_benchmark(async_jobs, DSA_sign_loop, loopargs);
2476             d = Time_F(STOP);
2477             BIO_printf(bio_err,
2478                        mr ? "+R3:%ld:%d:%.2f\n"
2479                        : "%ld %d bit DSA signs in %.2fs\n",
2480                        count, dsa_bits[testnum], d);
2481             dsa_results[testnum][0] = d / (double)count;
2482             rsa_count = count;
2483         }
2484
2485         for (i = 0; i < loopargs_len; i++) {
2486             st = DSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2487                             *(loopargs[i].siglen), loopargs[i].dsa_key[testnum]);
2488             if (st <= 0)
2489                 break;
2490         }
2491         if (st <= 0) {
2492             BIO_printf(bio_err,
2493                        "DSA verify failure.  No DSA verify will be done.\n");
2494             ERR_print_errors(bio_err);
2495             dsa_doit[testnum] = 0;
2496         } else {
2497             pkey_print_message("verify", "dsa",
2498                                dsa_c[testnum][1], dsa_bits[testnum], DSA_SECONDS);
2499             Time_F(START);
2500             count = run_benchmark(async_jobs, DSA_verify_loop, loopargs);
2501             d = Time_F(STOP);
2502             BIO_printf(bio_err,
2503                        mr ? "+R4:%ld:%d:%.2f\n"
2504                        : "%ld %d bit DSA verify in %.2fs\n",
2505                        count, dsa_bits[testnum], d);
2506             dsa_results[testnum][1] = d / (double)count;
2507         }
2508
2509         if (rsa_count <= 1) {
2510             /* if longer than 10s, don't do any more */
2511             for (testnum++; testnum < DSA_NUM; testnum++)
2512                 dsa_doit[testnum] = 0;
2513         }
2514     }
2515     if (rnd_fake)
2516         RAND_cleanup();
2517 #endif
2518
2519 #ifndef OPENSSL_NO_EC
2520     if (RAND_status() != 1) {
2521         RAND_seed(rnd_seed, sizeof rnd_seed);
2522         rnd_fake = 1;
2523     }
2524     for (testnum = 0; testnum < EC_NUM; testnum++) {
2525         int st = 1;
2526
2527         if (!ecdsa_doit[testnum])
2528             continue;           /* Ignore Curve */
2529         for (i = 0; i < loopargs_len; i++) {
2530             loopargs[i].ecdsa[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2531             if (loopargs[i].ecdsa[testnum] == NULL) {
2532                 st = 0;
2533                 break;
2534             }
2535         }
2536         if (st == 0) {
2537             BIO_printf(bio_err, "ECDSA failure.\n");
2538             ERR_print_errors(bio_err);
2539             rsa_count = 1;
2540         } else {
2541             for (i = 0; i < loopargs_len; i++) {
2542                 EC_KEY_precompute_mult(loopargs[i].ecdsa[testnum], NULL);
2543                 /* Perform ECDSA signature test */
2544                 EC_KEY_generate_key(loopargs[i].ecdsa[testnum]);
2545                 st = ECDSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2546                                 loopargs[i].siglen, loopargs[i].ecdsa[testnum]);
2547                 if (st == 0)
2548                     break;
2549             }
2550             if (st == 0) {
2551                 BIO_printf(bio_err,
2552                            "ECDSA sign failure.  No ECDSA sign will be done.\n");
2553                 ERR_print_errors(bio_err);
2554                 rsa_count = 1;
2555             } else {
2556                 pkey_print_message("sign", "ecdsa",
2557                                    ecdsa_c[testnum][0],
2558                                    test_curves_bits[testnum], ECDSA_SECONDS);
2559                 Time_F(START);
2560                 count = run_benchmark(async_jobs, ECDSA_sign_loop, loopargs);
2561                 d = Time_F(STOP);
2562
2563                 BIO_printf(bio_err,
2564                            mr ? "+R5:%ld:%d:%.2f\n" :
2565                            "%ld %d bit ECDSA signs in %.2fs \n",
2566                            count, test_curves_bits[testnum], d);
2567                 ecdsa_results[testnum][0] = d / (double)count;
2568                 rsa_count = count;
2569             }
2570
2571             /* Perform ECDSA verification test */
2572             for (i = 0; i < loopargs_len; i++) {
2573                 st = ECDSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2574                                   *(loopargs[i].siglen), loopargs[i].ecdsa[testnum]);
2575                 if (st != 1)
2576                     break;
2577             }
2578             if (st != 1) {
2579                 BIO_printf(bio_err,
2580                            "ECDSA verify failure.  No ECDSA verify will be done.\n");
2581                 ERR_print_errors(bio_err);
2582                 ecdsa_doit[testnum] = 0;
2583             } else {
2584                 pkey_print_message("verify", "ecdsa",
2585                                    ecdsa_c[testnum][1],
2586                                    test_curves_bits[testnum], ECDSA_SECONDS);
2587                 Time_F(START);
2588                 count = run_benchmark(async_jobs, ECDSA_verify_loop, loopargs);
2589                 d = Time_F(STOP);
2590                 BIO_printf(bio_err,
2591                            mr ? "+R6:%ld:%d:%.2f\n"
2592                            : "%ld %d bit ECDSA verify in %.2fs\n",
2593                            count, test_curves_bits[testnum], d);
2594                 ecdsa_results[testnum][1] = d / (double)count;
2595             }
2596
2597             if (rsa_count <= 1) {
2598                 /* if longer than 10s, don't do any more */
2599                 for (testnum++; testnum < EC_NUM; testnum++)
2600                     ecdsa_doit[testnum] = 0;
2601             }
2602         }
2603     }
2604     if (rnd_fake)
2605         RAND_cleanup();
2606 #endif
2607
2608 #ifndef OPENSSL_NO_EC
2609     if (RAND_status() != 1) {
2610         RAND_seed(rnd_seed, sizeof rnd_seed);
2611         rnd_fake = 1;
2612     }
2613     for (testnum = 0; testnum < EC_NUM; testnum++) {
2614         if (!ecdh_doit[testnum])
2615             continue;
2616         for (i = 0; i < loopargs_len; i++) {
2617             loopargs[i].ecdh_a[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2618             loopargs[i].ecdh_b[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2619             if (loopargs[i].ecdh_a[testnum] == NULL ||
2620                 loopargs[i].ecdh_b[testnum] == NULL) {
2621                 ecdh_checks = 0;
2622                 break;
2623             }
2624         }
2625         if (ecdh_checks == 0) {
2626             BIO_printf(bio_err, "ECDH failure.\n");
2627             ERR_print_errors(bio_err);
2628             rsa_count = 1;
2629         } else {
2630             for (i = 0; i < loopargs_len; i++) {
2631                 /* generate two ECDH key pairs */
2632                 if (!EC_KEY_generate_key(loopargs[i].ecdh_a[testnum]) ||
2633                         !EC_KEY_generate_key(loopargs[i].ecdh_b[testnum])) {
2634                     BIO_printf(bio_err, "ECDH key generation failure.\n");
2635                     ERR_print_errors(bio_err);
2636                     ecdh_checks = 0;
2637                     rsa_count = 1;
2638                 } else {
2639                     /*
2640                      * If field size is not more than 24 octets, then use SHA-1
2641                      * hash of result; otherwise, use result (see section 4.8 of
2642                      * draft-ietf-tls-ecc-03.txt).
2643                      */
2644                     int field_size;
2645                     field_size =
2646                         EC_GROUP_get_degree(EC_KEY_get0_group(loopargs[i].ecdh_a[testnum]));
2647                     if (field_size <= 24 * 8) {
2648                         outlen = KDF1_SHA1_len;
2649                         kdf = KDF1_SHA1;
2650                     } else {
2651                         outlen = (field_size + 7) / 8;
2652                         kdf = NULL;
2653                     }
2654                     secret_size_a =
2655                         ECDH_compute_key(loopargs[i].secret_a, outlen,
2656                                 EC_KEY_get0_public_key(loopargs[i].ecdh_b[testnum]),
2657                                 loopargs[i].ecdh_a[testnum], kdf);
2658                     secret_size_b =
2659                         ECDH_compute_key(loopargs[i].secret_b, outlen,
2660                                 EC_KEY_get0_public_key(loopargs[i].ecdh_a[testnum]),
2661                                 loopargs[i].ecdh_b[testnum], kdf);
2662                     if (secret_size_a != secret_size_b)
2663                         ecdh_checks = 0;
2664                     else
2665                         ecdh_checks = 1;
2666
2667                     for (secret_idx = 0; (secret_idx < secret_size_a)
2668                             && (ecdh_checks == 1); secret_idx++) {
2669                         if (loopargs[i].secret_a[secret_idx] != loopargs[i].secret_b[secret_idx])
2670                             ecdh_checks = 0;
2671                     }
2672
2673                     if (ecdh_checks == 0) {
2674                         BIO_printf(bio_err, "ECDH computations don't match.\n");
2675                         ERR_print_errors(bio_err);
2676                         rsa_count = 1;
2677                         break;
2678                     }
2679                 }
2680                 if (ecdh_checks != 0) {
2681                     pkey_print_message("", "ecdh",
2682                             ecdh_c[testnum][0],
2683                             test_curves_bits[testnum], ECDH_SECONDS);
2684                     Time_F(START);
2685                     count = run_benchmark(async_jobs, ECDH_compute_key_loop, loopargs);
2686                     d = Time_F(STOP);
2687                     BIO_printf(bio_err,
2688                             mr ? "+R7:%ld:%d:%.2f\n" :
2689                             "%ld %d-bit ECDH ops in %.2fs\n", count,
2690                             test_curves_bits[testnum], d);
2691                     ecdh_results[testnum][0] = d / (double)count;
2692                     rsa_count = count;
2693                 }
2694             }
2695         }
2696
2697         if (rsa_count <= 1) {
2698             /* if longer than 10s, don't do any more */
2699             for (testnum++; testnum < EC_NUM; testnum++)
2700                 ecdh_doit[testnum] = 0;
2701         }
2702     }
2703     if (rnd_fake)
2704         RAND_cleanup();
2705 #endif
2706 #ifndef NO_FORK
2707  show_res:
2708 #endif
2709     if (!mr) {
2710         printf("%s\n", OpenSSL_version(OPENSSL_VERSION));
2711         printf("%s\n", OpenSSL_version(OPENSSL_BUILT_ON));
2712         printf("options:");
2713         printf("%s ", BN_options());
2714 #ifndef OPENSSL_NO_MD2
2715         printf("%s ", MD2_options());
2716 #endif
2717 #ifndef OPENSSL_NO_RC4
2718         printf("%s ", RC4_options());
2719 #endif
2720 #ifndef OPENSSL_NO_DES
2721         printf("%s ", DES_options());
2722 #endif
2723 #ifndef OPENSSL_NO_AES
2724         printf("%s ", AES_options());
2725 #endif
2726 #ifndef OPENSSL_NO_IDEA
2727         printf("%s ", idea_options());
2728 #endif
2729 #ifndef OPENSSL_NO_BF
2730         printf("%s ", BF_options());
2731 #endif
2732         printf("\n%s\n", OpenSSL_version(OPENSSL_CFLAGS));
2733     }
2734
2735     if (pr_header) {
2736         if (mr)
2737             printf("+H");
2738         else {
2739             printf
2740                 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2741             printf("type        ");
2742         }
2743         for (testnum = 0; testnum < SIZE_NUM; testnum++)
2744             printf(mr ? ":%d" : "%7d bytes", lengths[testnum]);
2745         printf("\n");
2746     }
2747
2748     for (k = 0; k < ALGOR_NUM; k++) {
2749         if (!doit[k])
2750             continue;
2751         if (mr)
2752             printf("+F:%d:%s", k, names[k]);
2753         else
2754             printf("%-13s", names[k]);
2755         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2756             if (results[k][testnum] > 10000 && !mr)
2757                 printf(" %11.2fk", results[k][testnum] / 1e3);
2758             else
2759                 printf(mr ? ":%.2f" : " %11.2f ", results[k][testnum]);
2760         }
2761         printf("\n");
2762     }
2763 #ifndef OPENSSL_NO_RSA
2764     testnum = 1;
2765     for (k = 0; k < RSA_NUM; k++) {
2766         if (!rsa_doit[k])
2767             continue;
2768         if (testnum && !mr) {
2769             printf("%18ssign    verify    sign/s verify/s\n", " ");
2770             testnum = 0;
2771         }
2772         if (mr)
2773             printf("+F2:%u:%u:%f:%f\n",
2774                    k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2775         else
2776             printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2777                    rsa_bits[k], rsa_results[k][0], rsa_results[k][1],
2778                    1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]);
2779     }
2780 #endif
2781 #ifndef OPENSSL_NO_DSA
2782     testnum = 1;
2783     for (k = 0; k < DSA_NUM; k++) {
2784         if (!dsa_doit[k])
2785             continue;
2786         if (testnum && !mr) {
2787             printf("%18ssign    verify    sign/s verify/s\n", " ");
2788             testnum = 0;
2789         }
2790         if (mr)
2791             printf("+F3:%u:%u:%f:%f\n",
2792                    k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2793         else
2794             printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2795                    dsa_bits[k], dsa_results[k][0], dsa_results[k][1],
2796                    1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]);
2797     }
2798 #endif
2799 #ifndef OPENSSL_NO_EC
2800     testnum = 1;
2801     for (k = 0; k < EC_NUM; k++) {
2802         if (!ecdsa_doit[k])
2803             continue;
2804         if (testnum && !mr) {
2805             printf("%30ssign    verify    sign/s verify/s\n", " ");
2806             testnum = 0;
2807         }
2808
2809         if (mr)
2810             printf("+F4:%u:%u:%f:%f\n",
2811                    k, test_curves_bits[k],
2812                    ecdsa_results[k][0], ecdsa_results[k][1]);
2813         else
2814             printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2815                    test_curves_bits[k],
2816                    test_curves_names[k],
2817                    ecdsa_results[k][0], ecdsa_results[k][1],
2818                    1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
2819     }
2820 #endif
2821
2822 #ifndef OPENSSL_NO_EC
2823     testnum = 1;
2824     for (k = 0; k < EC_NUM; k++) {
2825         if (!ecdh_doit[k])
2826             continue;
2827         if (testnum && !mr) {
2828             printf("%30sop      op/s\n", " ");
2829             testnum = 0;
2830         }
2831         if (mr)
2832             printf("+F5:%u:%u:%f:%f\n",
2833                    k, test_curves_bits[k],
2834                    ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2835
2836         else
2837             printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2838                    test_curves_bits[k],
2839                    test_curves_names[k],
2840                    ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2841     }
2842 #endif
2843
2844     ret = 0;
2845
2846  end:
2847     ERR_print_errors(bio_err);
2848     for (i = 0; i < loopargs_len; i++) {
2849         OPENSSL_free(loopargs[i].buf_malloc);
2850         OPENSSL_free(loopargs[i].buf2_malloc);
2851         OPENSSL_free(loopargs[i].siglen);
2852     }
2853 #ifndef OPENSSL_NO_RSA
2854     for (i = 0; i < loopargs_len; i++) {
2855         for (k = 0; k < RSA_NUM; k++)
2856             RSA_free(loopargs[i].rsa_key[k]);
2857     }
2858 #endif
2859 #ifndef OPENSSL_NO_DSA
2860     for (i = 0; i < loopargs_len; i++) {
2861         for (k = 0; k < DSA_NUM; k++)
2862             DSA_free(loopargs[i].dsa_key[k]);
2863     }
2864 #endif
2865
2866 #ifndef OPENSSL_NO_EC
2867     for (i = 0; i < loopargs_len; i++) {
2868         for (k = 0; k < EC_NUM; k++) {
2869             EC_KEY_free(loopargs[i].ecdsa[k]);
2870             EC_KEY_free(loopargs[i].ecdh_a[k]);
2871             EC_KEY_free(loopargs[i].ecdh_b[k]);
2872         }
2873         OPENSSL_free(loopargs[i].secret_a);
2874         OPENSSL_free(loopargs[i].secret_b);
2875     }
2876 #endif
2877     if (async_jobs > 0) {
2878         for (i = 0; i < loopargs_len; i++)
2879             ASYNC_WAIT_CTX_free(loopargs[i].wait_ctx);
2880
2881         ASYNC_cleanup_thread();
2882     }
2883     OPENSSL_free(loopargs);
2884     return (ret);
2885 }
2886
2887 static void print_message(const char *s, long num, int length)
2888 {
2889 #ifdef SIGALRM
2890     BIO_printf(bio_err,
2891                mr ? "+DT:%s:%d:%d\n"
2892                : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length);
2893     (void)BIO_flush(bio_err);
2894     alarm(SECONDS);
2895 #else
2896     BIO_printf(bio_err,
2897                mr ? "+DN:%s:%ld:%d\n"
2898                : "Doing %s %ld times on %d size blocks: ", s, num, length);
2899     (void)BIO_flush(bio_err);
2900 #endif
2901 }
2902
2903 static void pkey_print_message(const char *str, const char *str2, long num,
2904                                int bits, int tm)
2905 {
2906 #ifdef SIGALRM
2907     BIO_printf(bio_err,
2908                mr ? "+DTP:%d:%s:%s:%d\n"
2909                : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
2910     (void)BIO_flush(bio_err);
2911     alarm(tm);
2912 #else
2913     BIO_printf(bio_err,
2914                mr ? "+DNP:%ld:%d:%s:%s\n"
2915                : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
2916     (void)BIO_flush(bio_err);
2917 #endif
2918 }
2919
2920 static void print_result(int alg, int run_no, int count, double time_used)
2921 {
2922     BIO_printf(bio_err,
2923                mr ? "+R:%d:%s:%f\n"
2924                : "%d %s's in %.2fs\n", count, names[alg], time_used);
2925     results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
2926 }
2927
2928 #ifndef NO_FORK
2929 static char *sstrsep(char **string, const char *delim)
2930 {
2931     char isdelim[256];
2932     char *token = *string;
2933
2934     if (**string == 0)
2935         return NULL;
2936
2937     memset(isdelim, 0, sizeof isdelim);
2938     isdelim[0] = 1;
2939
2940     while (*delim) {
2941         isdelim[(unsigned char)(*delim)] = 1;
2942         delim++;
2943     }
2944
2945     while (!isdelim[(unsigned char)(**string)]) {
2946         (*string)++;
2947     }
2948
2949     if (**string) {
2950         **string = 0;
2951         (*string)++;
2952     }
2953
2954     return token;
2955 }
2956
2957 static int do_multi(int multi)
2958 {
2959     int n;
2960     int fd[2];
2961     int *fds;
2962     static char sep[] = ":";
2963
2964     fds = malloc(sizeof(*fds) * multi);
2965     for (n = 0; n < multi; ++n) {
2966         if (pipe(fd) == -1) {
2967             BIO_printf(bio_err, "pipe failure\n");
2968             exit(1);
2969         }
2970         fflush(stdout);
2971         (void)BIO_flush(bio_err);
2972         if (fork()) {
2973             close(fd[1]);
2974             fds[n] = fd[0];
2975         } else {
2976             close(fd[0]);
2977             close(1);
2978             if (dup(fd[1]) == -1) {
2979                 BIO_printf(bio_err, "dup failed\n");
2980                 exit(1);
2981             }
2982             close(fd[1]);
2983             mr = 1;
2984             usertime = 0;
2985             free(fds);
2986             return 0;
2987         }
2988         printf("Forked child %d\n", n);
2989     }
2990
2991     /* for now, assume the pipe is long enough to take all the output */
2992     for (n = 0; n < multi; ++n) {
2993         FILE *f;
2994         char buf[1024];
2995         char *p;
2996
2997         f = fdopen(fds[n], "r");
2998         while (fgets(buf, sizeof buf, f)) {
2999             p = strchr(buf, '\n');
3000             if (p)
3001                 *p = '\0';
3002             if (buf[0] != '+') {
3003                 BIO_printf(bio_err, "Don't understand line '%s' from child %d\n",
3004                         buf, n);
3005                 continue;
3006             }
3007             printf("Got: %s from %d\n", buf, n);
3008             if (strncmp(buf, "+F:", 3) == 0) {
3009                 int alg;
3010                 int j;
3011
3012                 p = buf + 3;
3013                 alg = atoi(sstrsep(&p, sep));
3014                 sstrsep(&p, sep);
3015                 for (j = 0; j < SIZE_NUM; ++j)
3016                     results[alg][j] += atof(sstrsep(&p, sep));
3017             } else if (strncmp(buf, "+F2:", 4) == 0) {
3018                 int k;
3019                 double d;
3020
3021                 p = buf + 4;
3022                 k = atoi(sstrsep(&p, sep));
3023                 sstrsep(&p, sep);
3024
3025                 d = atof(sstrsep(&p, sep));
3026                 if (n)
3027                     rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
3028                 else
3029                     rsa_results[k][0] = d;
3030
3031                 d = atof(sstrsep(&p, sep));
3032                 if (n)
3033                     rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
3034                 else
3035                     rsa_results[k][1] = d;
3036             }
3037 # ifndef OPENSSL_NO_DSA
3038             else if (strncmp(buf, "+F3:", 4) == 0) {
3039                 int k;
3040                 double d;
3041
3042                 p = buf + 4;
3043                 k = atoi(sstrsep(&p, sep));
3044                 sstrsep(&p, sep);
3045
3046                 d = atof(sstrsep(&p, sep));
3047                 if (n)
3048                     dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d);
3049                 else
3050                     dsa_results[k][0] = d;
3051
3052                 d = atof(sstrsep(&p, sep));
3053                 if (n)
3054                     dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d);
3055                 else
3056                     dsa_results[k][1] = d;
3057             }
3058 # endif
3059 # ifndef OPENSSL_NO_EC
3060             else if (strncmp(buf, "+F4:", 4) == 0) {
3061                 int k;
3062                 double d;
3063
3064                 p = buf + 4;
3065                 k = atoi(sstrsep(&p, sep));
3066                 sstrsep(&p, sep);
3067
3068                 d = atof(sstrsep(&p, sep));
3069                 if (n)
3070                     ecdsa_results[k][0] =
3071                         1 / (1 / ecdsa_results[k][0] + 1 / d);
3072                 else
3073                     ecdsa_results[k][0] = d;
3074
3075                 d = atof(sstrsep(&p, sep));
3076                 if (n)
3077                     ecdsa_results[k][1] =
3078                         1 / (1 / ecdsa_results[k][1] + 1 / d);
3079                 else
3080                     ecdsa_results[k][1] = d;
3081             }
3082 # endif
3083
3084 # ifndef OPENSSL_NO_EC
3085             else if (strncmp(buf, "+F5:", 4) == 0) {
3086                 int k;
3087                 double d;
3088
3089                 p = buf + 4;
3090                 k = atoi(sstrsep(&p, sep));
3091                 sstrsep(&p, sep);
3092
3093                 d = atof(sstrsep(&p, sep));
3094                 if (n)
3095                     ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
3096                 else
3097                     ecdh_results[k][0] = d;
3098
3099             }
3100 # endif
3101
3102             else if (strncmp(buf, "+H:", 3) == 0) {
3103                 ;
3104             } else
3105                 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf, n);
3106         }
3107
3108         fclose(f);
3109     }
3110     free(fds);
3111     return 1;
3112 }
3113 #endif
3114
3115 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
3116 {
3117     static int mblengths[] =
3118         { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
3119     int j, count, num = OSSL_NELEM(mblengths);
3120     const char *alg_name;
3121     unsigned char *inp, *out, no_key[32], no_iv[16];
3122     EVP_CIPHER_CTX *ctx;
3123     double d = 0.0;
3124
3125     inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
3126     out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
3127     ctx = EVP_CIPHER_CTX_new();
3128     EVP_EncryptInit_ex(ctx, evp_cipher, NULL, no_key, no_iv);
3129     EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key),
3130                         no_key);
3131     alg_name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
3132
3133     for (j = 0; j < num; j++) {
3134         print_message(alg_name, 0, mblengths[j]);
3135         Time_F(START);
3136         for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
3137             unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
3138             EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
3139             size_t len = mblengths[j];
3140             int packlen;
3141
3142             memset(aad, 0, 8);  /* avoid uninitialized values */
3143             aad[8] = 23;        /* SSL3_RT_APPLICATION_DATA */
3144             aad[9] = 3;         /* version */
3145             aad[10] = 2;
3146             aad[11] = 0;        /* length */
3147             aad[12] = 0;
3148             mb_param.out = NULL;
3149             mb_param.inp = aad;
3150             mb_param.len = len;
3151             mb_param.interleave = 8;
3152
3153             packlen = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
3154                                           sizeof(mb_param), &mb_param);
3155
3156             if (packlen > 0) {
3157                 mb_param.out = out;
3158                 mb_param.inp = inp;
3159                 mb_param.len = len;
3160                 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
3161                                     sizeof(mb_param), &mb_param);
3162             } else {
3163                 int pad;
3164
3165                 RAND_bytes(out, 16);
3166                 len += 16;
3167                 aad[11] = len >> 8;
3168                 aad[12] = len;
3169                 pad = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_TLS1_AAD,
3170                                           EVP_AEAD_TLS1_AAD_LEN, aad);
3171                 EVP_Cipher(ctx, out, inp, len + pad);
3172             }
3173         }
3174         d = Time_F(STOP);
3175         BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
3176                    : "%d %s's in %.2fs\n", count, "evp", d);
3177         results[D_EVP][j] = ((double)count) / d * mblengths[j];
3178     }
3179
3180     if (mr) {
3181         fprintf(stdout, "+H");
3182         for (j = 0; j < num; j++)
3183             fprintf(stdout, ":%d", mblengths[j]);
3184         fprintf(stdout, "\n");
3185         fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
3186         for (j = 0; j < num; j++)
3187             fprintf(stdout, ":%.2f", results[D_EVP][j]);
3188         fprintf(stdout, "\n");
3189     } else {
3190         fprintf(stdout,
3191                 "The 'numbers' are in 1000s of bytes per second processed.\n");
3192         fprintf(stdout, "type                    ");
3193         for (j = 0; j < num; j++)
3194             fprintf(stdout, "%7d bytes", mblengths[j]);
3195         fprintf(stdout, "\n");
3196         fprintf(stdout, "%-24s", alg_name);
3197
3198         for (j = 0; j < num; j++) {
3199             if (results[D_EVP][j] > 10000)
3200                 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
3201             else
3202                 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
3203         }
3204         fprintf(stdout, "\n");
3205     }
3206
3207     OPENSSL_free(inp);
3208     OPENSSL_free(out);
3209     EVP_CIPHER_CTX_free(ctx);
3210 }