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