apps/speed.c

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