apps/speed.c

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