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