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