apps/speed.c

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