apps/speed.c

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