apps/speed.c

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