apps/speed.c

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