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     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 #endif
1397             break;
1398         case OPT_MISALIGN:
1399             if (!opt_int(opt_arg(), &misalign))
1400                 goto end;
1401             if (misalign > MISALIGN) {
1402                 BIO_printf(bio_err,
1403                            "%s: Maximum offset is %d\n", prog, MISALIGN);
1404                 goto opterr;
1405             }
1406             break;
1407         case OPT_MR:
1408             mr = 1;
1409             break;
1410         case OPT_MB:
1411             multiblock = 1;
1412 #ifdef OPENSSL_NO_MULTIBLOCK
1413             BIO_printf(bio_err,
1414                        "%s: -mb specified but multi-block support is disabled\n",
1415                        prog);
1416             goto end;
1417 #endif
1418             break;
1419         }
1420     }
1421     argc = opt_num_rest();
1422     argv = opt_rest();
1423
1424     /* Remaining arguments are algorithms. */
1425     for (; *argv; argv++) {
1426         if (found(*argv, doit_choices, &i)) {
1427             doit[i] = 1;
1428             continue;
1429         }
1430 #ifndef OPENSSL_NO_DES
1431         if (strcmp(*argv, "des") == 0) {
1432             doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
1433             continue;
1434         }
1435 #endif
1436         if (strcmp(*argv, "sha") == 0) {
1437             doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
1438             continue;
1439         }
1440 #ifndef OPENSSL_NO_RSA
1441 # ifndef RSA_NULL
1442         if (strcmp(*argv, "openssl") == 0) {
1443             RSA_set_default_method(RSA_PKCS1_OpenSSL());
1444             continue;
1445         }
1446 # endif
1447         if (strcmp(*argv, "rsa") == 0) {
1448             rsa_doit[R_RSA_512] = rsa_doit[R_RSA_1024] =
1449                 rsa_doit[R_RSA_2048] = rsa_doit[R_RSA_3072] =
1450                 rsa_doit[R_RSA_4096] = rsa_doit[R_RSA_7680] =
1451                 rsa_doit[R_RSA_15360] = 1;
1452             continue;
1453         }
1454         if (found(*argv, rsa_choices, &i)) {
1455             rsa_doit[i] = 1;
1456             continue;
1457         }
1458 #endif
1459 #ifndef OPENSSL_NO_DSA
1460         if (strcmp(*argv, "dsa") == 0) {
1461             dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
1462                 dsa_doit[R_DSA_2048] = 1;
1463             continue;
1464         }
1465         if (found(*argv, dsa_choices, &i)) {
1466             dsa_doit[i] = 2;
1467             continue;
1468         }
1469 #endif
1470         if (strcmp(*argv, "aes") == 0) {
1471             doit[D_CBC_128_AES] = doit[D_CBC_192_AES] = doit[D_CBC_256_AES] = 1;
1472             continue;
1473         }
1474 #ifndef OPENSSL_NO_CAMELLIA
1475         if (strcmp(*argv, "camellia") == 0) {
1476             doit[D_CBC_128_CML] = doit[D_CBC_192_CML] = doit[D_CBC_256_CML] = 1;
1477             continue;
1478         }
1479 #endif
1480 #ifndef OPENSSL_NO_EC
1481         if (strcmp(*argv, "ecdsa") == 0) {
1482             for (i = 0; i < EC_NUM; i++)
1483                 ecdsa_doit[i] = 1;
1484             continue;
1485         }
1486         if (found(*argv, ecdsa_choices, &i)) {
1487             ecdsa_doit[i] = 2;
1488             continue;
1489         }
1490         if (strcmp(*argv, "ecdh") == 0) {
1491             for (i = 0; i < EC_NUM; i++)
1492                 ecdh_doit[i] = 1;
1493             continue;
1494         }
1495         if (found(*argv, ecdh_choices, &i)) {
1496             ecdh_doit[i] = 2;
1497             continue;
1498         }
1499 #endif
1500         BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
1501         goto end;
1502     }
1503
1504     /* Initialize the job pool if async mode is enabled */
1505     if (async_jobs > 0) {
1506         async_init = ASYNC_init_thread(async_jobs, async_jobs);
1507         if (!async_init) {
1508             BIO_printf(bio_err, "Error creating the ASYNC job pool\n");
1509             goto end;
1510         }
1511     }
1512
1513     loopargs_len = (async_jobs == 0 ? 1 : async_jobs);
1514     loopargs =
1515         app_malloc(loopargs_len * sizeof(loopargs_t), "array of loopargs");
1516     memset(loopargs, 0, loopargs_len * sizeof(loopargs_t));
1517
1518     for (i = 0; i < loopargs_len; i++) {
1519         if (async_jobs > 0) {
1520             loopargs[i].wait_ctx = ASYNC_WAIT_CTX_new();
1521             if (loopargs[i].wait_ctx == NULL) {
1522                 BIO_printf(bio_err, "Error creating the ASYNC_WAIT_CTX\n");
1523                 goto end;
1524             }
1525         }
1526
1527         loopargs[i].buf_malloc =
1528             app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1529         loopargs[i].buf2_malloc =
1530             app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1531         /* Align the start of buffers on a 64 byte boundary */
1532         loopargs[i].buf = loopargs[i].buf_malloc + misalign;
1533         loopargs[i].buf2 = loopargs[i].buf2_malloc + misalign;
1534 #ifndef OPENSSL_NO_EC
1535         loopargs[i].secret_a = app_malloc(MAX_ECDH_SIZE, "ECDH secret a");
1536         loopargs[i].secret_b = app_malloc(MAX_ECDH_SIZE, "ECDH secret b");
1537 #endif
1538     }
1539
1540 #ifndef NO_FORK
1541     if (multi && do_multi(multi))
1542         goto show_res;
1543 #endif
1544
1545     /* Initialize the engine after the fork */
1546     e = setup_engine(engine_id, 0);
1547
1548     /* No parameters; turn on everything. */
1549     if ((argc == 0) && !doit[D_EVP]) {
1550         for (i = 0; i < ALGOR_NUM; i++)
1551             if (i != D_EVP)
1552                 doit[i] = 1;
1553 #ifndef OPENSSL_NO_RSA
1554         for (i = 0; i < RSA_NUM; i++)
1555             rsa_doit[i] = 1;
1556 #endif
1557 #ifndef OPENSSL_NO_DSA
1558         for (i = 0; i < DSA_NUM; i++)
1559             dsa_doit[i] = 1;
1560 #endif
1561 #ifndef OPENSSL_NO_EC
1562         for (i = 0; i < EC_NUM; i++)
1563             ecdsa_doit[i] = 1;
1564         for (i = 0; i < EC_NUM; i++)
1565             ecdh_doit[i] = 1;
1566 #endif
1567     }
1568     for (i = 0; i < ALGOR_NUM; i++)
1569         if (doit[i])
1570             pr_header++;
1571
1572     if (usertime == 0 && !mr)
1573         BIO_printf(bio_err,
1574                    "You have chosen to measure elapsed time "
1575                    "instead of user CPU time.\n");
1576
1577 #ifndef OPENSSL_NO_RSA
1578     for (i = 0; i < loopargs_len; i++) {
1579         for (k = 0; k < RSA_NUM; k++) {
1580             const unsigned char *p;
1581
1582             p = rsa_data[k];
1583             loopargs[i].rsa_key[k] =
1584                 d2i_RSAPrivateKey(NULL, &p, rsa_data_length[k]);
1585             if (loopargs[i].rsa_key[k] == NULL) {
1586                 BIO_printf(bio_err,
1587                            "internal error loading RSA key number %d\n", k);
1588                 goto end;
1589             }
1590         }
1591     }
1592 #endif
1593 #ifndef OPENSSL_NO_DSA
1594     for (i = 0; i < loopargs_len; i++) {
1595         loopargs[i].dsa_key[0] = get_dsa512();
1596         loopargs[i].dsa_key[1] = get_dsa1024();
1597         loopargs[i].dsa_key[2] = get_dsa2048();
1598     }
1599 #endif
1600 #ifndef OPENSSL_NO_DES
1601     DES_set_key_unchecked(&key, &sch);
1602     DES_set_key_unchecked(&key2, &sch2);
1603     DES_set_key_unchecked(&key3, &sch3);
1604 #endif
1605     AES_set_encrypt_key(key16, 128, &aes_ks1);
1606     AES_set_encrypt_key(key24, 192, &aes_ks2);
1607     AES_set_encrypt_key(key32, 256, &aes_ks3);
1608 #ifndef OPENSSL_NO_CAMELLIA
1609     Camellia_set_key(key16, 128, &camellia_ks1);
1610     Camellia_set_key(ckey24, 192, &camellia_ks2);
1611     Camellia_set_key(ckey32, 256, &camellia_ks3);
1612 #endif
1613 #ifndef OPENSSL_NO_IDEA
1614     IDEA_set_encrypt_key(key16, &idea_ks);
1615 #endif
1616 #ifndef OPENSSL_NO_SEED
1617     SEED_set_key(key16, &seed_ks);
1618 #endif
1619 #ifndef OPENSSL_NO_RC4
1620     RC4_set_key(&rc4_ks, 16, key16);
1621 #endif
1622 #ifndef OPENSSL_NO_RC2
1623     RC2_set_key(&rc2_ks, 16, key16, 128);
1624 #endif
1625 #ifndef OPENSSL_NO_RC5
1626     RC5_32_set_key(&rc5_ks, 16, key16, 12);
1627 #endif
1628 #ifndef OPENSSL_NO_BF
1629     BF_set_key(&bf_ks, 16, key16);
1630 #endif
1631 #ifndef OPENSSL_NO_CAST
1632     CAST_set_key(&cast_ks, 16, key16);
1633 #endif
1634 #ifndef SIGALRM
1635 # ifndef OPENSSL_NO_DES
1636     BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1637     count = 10;
1638     do {
1639         long it;
1640         count *= 2;
1641         Time_F(START);
1642         for (it = count; it; it--)
1643             DES_ecb_encrypt((DES_cblock *)loopargs[0].buf,
1644                             (DES_cblock *)loopargs[0].buf, &sch, DES_ENCRYPT);
1645         d = Time_F(STOP);
1646     } while (d < 3);
1647     save_count = count;
1648     c[D_MD2][0] = count / 10;
1649     c[D_MDC2][0] = count / 10;
1650     c[D_MD4][0] = count;
1651     c[D_MD5][0] = count;
1652     c[D_HMAC][0] = count;
1653     c[D_SHA1][0] = count;
1654     c[D_RMD160][0] = count;
1655     c[D_RC4][0] = count * 5;
1656     c[D_CBC_DES][0] = count;
1657     c[D_EDE3_DES][0] = count / 3;
1658     c[D_CBC_IDEA][0] = count;
1659     c[D_CBC_SEED][0] = count;
1660     c[D_CBC_RC2][0] = count;
1661     c[D_CBC_RC5][0] = count;
1662     c[D_CBC_BF][0] = count;
1663     c[D_CBC_CAST][0] = count;
1664     c[D_CBC_128_AES][0] = count;
1665     c[D_CBC_192_AES][0] = count;
1666     c[D_CBC_256_AES][0] = count;
1667     c[D_CBC_128_CML][0] = count;
1668     c[D_CBC_192_CML][0] = count;
1669     c[D_CBC_256_CML][0] = count;
1670     c[D_SHA256][0] = count;
1671     c[D_SHA512][0] = count;
1672     c[D_WHIRLPOOL][0] = count;
1673     c[D_IGE_128_AES][0] = count;
1674     c[D_IGE_192_AES][0] = count;
1675     c[D_IGE_256_AES][0] = count;
1676     c[D_GHASH][0] = count;
1677
1678     for (i = 1; i < SIZE_NUM; i++) {
1679         long l0, l1;
1680
1681         l0 = (long)lengths[0];
1682         l1 = (long)lengths[i];
1683
1684         c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1685         c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1686         c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1687         c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1688         c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1689         c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1690         c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1691         c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1692         c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1693         c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1694         c[D_GHASH][i] = c[D_GHASH][0] * 4 * l0 / l1;
1695
1696         l0 = (long)lengths[i - 1];
1697
1698         c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1699         c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1700         c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1701         c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1702         c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1703         c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1704         c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1705         c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1706         c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1707         c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1708         c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1709         c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1710         c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1711         c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1712         c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1713         c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1714         c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1715         c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1716     }
1717
1718 #  ifndef OPENSSL_NO_RSA
1719     rsa_c[R_RSA_512][0] = count / 2000;
1720     rsa_c[R_RSA_512][1] = count / 400;
1721     for (i = 1; i < RSA_NUM; i++) {
1722         rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1723         rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1724         if (rsa_doit[i] <= 1 && rsa_c[i][0] == 0)
1725             rsa_doit[i] = 0;
1726         else {
1727             if (rsa_c[i][0] == 0) {
1728                 rsa_c[i][0] = 1; /* Set minimum iteration Nb to 1. */
1729                 rsa_c[i][1] = 20;
1730             }
1731         }
1732     }
1733 #  endif
1734
1735 #  ifndef OPENSSL_NO_DSA
1736     dsa_c[R_DSA_512][0] = count / 1000;
1737     dsa_c[R_DSA_512][1] = count / 1000 / 2;
1738     for (i = 1; i < DSA_NUM; i++) {
1739         dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1740         dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1741         if (dsa_doit[i] <= 1 && dsa_c[i][0] == 0)
1742             dsa_doit[i] = 0;
1743         else {
1744             if (dsa_c[i][0] == 0) {
1745                 dsa_c[i][0] = 1; /* Set minimum iteration Nb to 1. */
1746                 dsa_c[i][1] = 1;
1747             }
1748         }
1749     }
1750 #  endif
1751
1752 #  ifndef OPENSSL_NO_EC
1753     ecdsa_c[R_EC_P160][0] = count / 1000;
1754     ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1755     for (i = R_EC_P192; i <= R_EC_P521; i++) {
1756         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1757         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1758         if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1759             ecdsa_doit[i] = 0;
1760         else {
1761             if (ecdsa_c[i][0] == 0) {
1762                 ecdsa_c[i][0] = 1;
1763                 ecdsa_c[i][1] = 1;
1764             }
1765         }
1766     }
1767     ecdsa_c[R_EC_K163][0] = count / 1000;
1768     ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1769     for (i = R_EC_K233; i <= R_EC_K571; i++) {
1770         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1771         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1772         if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1773             ecdsa_doit[i] = 0;
1774         else {
1775             if (ecdsa_c[i][0] == 0) {
1776                 ecdsa_c[i][0] = 1;
1777                 ecdsa_c[i][1] = 1;
1778             }
1779         }
1780     }
1781     ecdsa_c[R_EC_B163][0] = count / 1000;
1782     ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1783     for (i = R_EC_B233; i <= R_EC_B571; i++) {
1784         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1785         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1786         if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1787             ecdsa_doit[i] = 0;
1788         else {
1789             if (ecdsa_c[i][0] == 0) {
1790                 ecdsa_c[i][0] = 1;
1791                 ecdsa_c[i][1] = 1;
1792             }
1793         }
1794     }
1795
1796     ecdh_c[R_EC_P160][0] = count / 1000;
1797     for (i = R_EC_P192; i <= R_EC_P521; i++) {
1798         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1799         if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1800             ecdh_doit[i] = 0;
1801         else {
1802             if (ecdh_c[i][0] == 0) {
1803                 ecdh_c[i][0] = 1;
1804             }
1805         }
1806     }
1807     ecdh_c[R_EC_K163][0] = count / 1000;
1808     for (i = R_EC_K233; i <= R_EC_K571; i++) {
1809         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1810         if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1811             ecdh_doit[i] = 0;
1812         else {
1813             if (ecdh_c[i][0] == 0) {
1814                 ecdh_c[i][0] = 1;
1815             }
1816         }
1817     }
1818     ecdh_c[R_EC_B163][0] = count / 1000;
1819     for (i = R_EC_B233; i <= R_EC_B571; i++) {
1820         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1821         if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1822             ecdh_doit[i] = 0;
1823         else {
1824             if (ecdh_c[i][0] == 0) {
1825                 ecdh_c[i][0] = 1;
1826             }
1827         }
1828     }
1829 #  endif
1830
1831 # else
1832 /* not worth fixing */
1833 #  error "You cannot disable DES on systems without SIGALRM."
1834 # endif                         /* OPENSSL_NO_DES */
1835 #else
1836 # ifndef _WIN32
1837     signal(SIGALRM, sig_done);
1838 # endif
1839 #endif                          /* SIGALRM */
1840
1841 #ifndef OPENSSL_NO_MD2
1842     if (doit[D_MD2]) {
1843         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1844             print_message(names[D_MD2], c[D_MD2][testnum], lengths[testnum]);
1845             Time_F(START);
1846             count = run_benchmark(async_jobs, EVP_Digest_MD2_loop, loopargs);
1847             d = Time_F(STOP);
1848             print_result(D_MD2, testnum, count, d);
1849         }
1850     }
1851 #endif
1852 #ifndef OPENSSL_NO_MDC2
1853     if (doit[D_MDC2]) {
1854         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1855             print_message(names[D_MDC2], c[D_MDC2][testnum], lengths[testnum]);
1856             Time_F(START);
1857             count = run_benchmark(async_jobs, EVP_Digest_MDC2_loop, loopargs);
1858             d = Time_F(STOP);
1859             print_result(D_MDC2, testnum, count, d);
1860         }
1861     }
1862 #endif
1863
1864 #ifndef OPENSSL_NO_MD4
1865     if (doit[D_MD4]) {
1866         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1867             print_message(names[D_MD4], c[D_MD4][testnum], lengths[testnum]);
1868             Time_F(START);
1869             count = run_benchmark(async_jobs, EVP_Digest_MD4_loop, loopargs);
1870             d = Time_F(STOP);
1871             print_result(D_MD4, testnum, count, d);
1872         }
1873     }
1874 #endif
1875
1876 #ifndef OPENSSL_NO_MD5
1877     if (doit[D_MD5]) {
1878         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1879             print_message(names[D_MD5], c[D_MD5][testnum], lengths[testnum]);
1880             Time_F(START);
1881             count = run_benchmark(async_jobs, MD5_loop, loopargs);
1882             d = Time_F(STOP);
1883             print_result(D_MD5, testnum, count, d);
1884         }
1885     }
1886
1887     if (doit[D_HMAC]) {
1888         static const char hmac_key[] = "This is a key...";
1889         int len = strlen(hmac_key);
1890
1891         for (i = 0; i < loopargs_len; i++) {
1892             loopargs[i].hctx = HMAC_CTX_new();
1893             if (loopargs[i].hctx == NULL) {
1894                 BIO_printf(bio_err, "HMAC malloc failure, exiting...");
1895                 exit(1);
1896             }
1897
1898             HMAC_Init_ex(loopargs[i].hctx, hmac_key, len, EVP_md5(), NULL);
1899         }
1900         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1901             print_message(names[D_HMAC], c[D_HMAC][testnum], lengths[testnum]);
1902             Time_F(START);
1903             count = run_benchmark(async_jobs, HMAC_loop, loopargs);
1904             d = Time_F(STOP);
1905             print_result(D_HMAC, testnum, count, d);
1906         }
1907         for (i = 0; i < loopargs_len; i++) {
1908             HMAC_CTX_free(loopargs[i].hctx);
1909         }
1910     }
1911 #endif
1912     if (doit[D_SHA1]) {
1913         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1914             print_message(names[D_SHA1], c[D_SHA1][testnum], lengths[testnum]);
1915             Time_F(START);
1916             count = run_benchmark(async_jobs, SHA1_loop, loopargs);
1917             d = Time_F(STOP);
1918             print_result(D_SHA1, testnum, count, d);
1919         }
1920     }
1921     if (doit[D_SHA256]) {
1922         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1923             print_message(names[D_SHA256], c[D_SHA256][testnum],
1924                           lengths[testnum]);
1925             Time_F(START);
1926             count = run_benchmark(async_jobs, SHA256_loop, loopargs);
1927             d = Time_F(STOP);
1928             print_result(D_SHA256, testnum, count, d);
1929         }
1930     }
1931     if (doit[D_SHA512]) {
1932         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1933             print_message(names[D_SHA512], c[D_SHA512][testnum],
1934                           lengths[testnum]);
1935             Time_F(START);
1936             count = run_benchmark(async_jobs, SHA512_loop, loopargs);
1937             d = Time_F(STOP);
1938             print_result(D_SHA512, testnum, count, d);
1939         }
1940     }
1941 #ifndef OPENSSL_NO_WHIRLPOOL
1942     if (doit[D_WHIRLPOOL]) {
1943         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1944             print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][testnum],
1945                           lengths[testnum]);
1946             Time_F(START);
1947             count = run_benchmark(async_jobs, WHIRLPOOL_loop, loopargs);
1948             d = Time_F(STOP);
1949             print_result(D_WHIRLPOOL, testnum, count, d);
1950         }
1951     }
1952 #endif
1953
1954 #ifndef OPENSSL_NO_RMD160
1955     if (doit[D_RMD160]) {
1956         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1957             print_message(names[D_RMD160], c[D_RMD160][testnum],
1958                           lengths[testnum]);
1959             Time_F(START);
1960             count = run_benchmark(async_jobs, EVP_Digest_RMD160_loop, loopargs);
1961             d = Time_F(STOP);
1962             print_result(D_RMD160, testnum, count, d);
1963         }
1964     }
1965 #endif
1966 #ifndef OPENSSL_NO_RC4
1967     if (doit[D_RC4]) {
1968         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1969             print_message(names[D_RC4], c[D_RC4][testnum], lengths[testnum]);
1970             Time_F(START);
1971             count = run_benchmark(async_jobs, RC4_loop, loopargs);
1972             d = Time_F(STOP);
1973             print_result(D_RC4, testnum, count, d);
1974         }
1975     }
1976 #endif
1977 #ifndef OPENSSL_NO_DES
1978     if (doit[D_CBC_DES]) {
1979         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1980             print_message(names[D_CBC_DES], c[D_CBC_DES][testnum],
1981                           lengths[testnum]);
1982             Time_F(START);
1983             count = run_benchmark(async_jobs, DES_ncbc_encrypt_loop, loopargs);
1984             d = Time_F(STOP);
1985             print_result(D_CBC_DES, testnum, count, d);
1986         }
1987     }
1988
1989     if (doit[D_EDE3_DES]) {
1990         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1991             print_message(names[D_EDE3_DES], c[D_EDE3_DES][testnum],
1992                           lengths[testnum]);
1993             Time_F(START);
1994             count =
1995                 run_benchmark(async_jobs, DES_ede3_cbc_encrypt_loop, loopargs);
1996             d = Time_F(STOP);
1997             print_result(D_EDE3_DES, testnum, count, d);
1998         }
1999     }
2000 #endif
2001
2002     if (doit[D_CBC_128_AES]) {
2003         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2004             print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][testnum],
2005                           lengths[testnum]);
2006             Time_F(START);
2007             count =
2008                 run_benchmark(async_jobs, AES_cbc_128_encrypt_loop, loopargs);
2009             d = Time_F(STOP);
2010             print_result(D_CBC_128_AES, testnum, count, d);
2011         }
2012     }
2013     if (doit[D_CBC_192_AES]) {
2014         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2015             print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][testnum],
2016                           lengths[testnum]);
2017             Time_F(START);
2018             count =
2019                 run_benchmark(async_jobs, AES_cbc_192_encrypt_loop, loopargs);
2020             d = Time_F(STOP);
2021             print_result(D_CBC_192_AES, testnum, count, d);
2022         }
2023     }
2024     if (doit[D_CBC_256_AES]) {
2025         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2026             print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][testnum],
2027                           lengths[testnum]);
2028             Time_F(START);
2029             count =
2030                 run_benchmark(async_jobs, AES_cbc_256_encrypt_loop, loopargs);
2031             d = Time_F(STOP);
2032             print_result(D_CBC_256_AES, testnum, count, d);
2033         }
2034     }
2035
2036     if (doit[D_IGE_128_AES]) {
2037         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2038             print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][testnum],
2039                           lengths[testnum]);
2040             Time_F(START);
2041             count =
2042                 run_benchmark(async_jobs, AES_ige_128_encrypt_loop, loopargs);
2043             d = Time_F(STOP);
2044             print_result(D_IGE_128_AES, testnum, count, d);
2045         }
2046     }
2047     if (doit[D_IGE_192_AES]) {
2048         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2049             print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][testnum],
2050                           lengths[testnum]);
2051             Time_F(START);
2052             count =
2053                 run_benchmark(async_jobs, AES_ige_192_encrypt_loop, loopargs);
2054             d = Time_F(STOP);
2055             print_result(D_IGE_192_AES, testnum, count, d);
2056         }
2057     }
2058     if (doit[D_IGE_256_AES]) {
2059         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2060             print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][testnum],
2061                           lengths[testnum]);
2062             Time_F(START);
2063             count =
2064                 run_benchmark(async_jobs, AES_ige_256_encrypt_loop, loopargs);
2065             d = Time_F(STOP);
2066             print_result(D_IGE_256_AES, testnum, count, d);
2067         }
2068     }
2069     if (doit[D_GHASH]) {
2070         for (i = 0; i < loopargs_len; i++) {
2071             loopargs[i].gcm_ctx =
2072                 CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
2073             CRYPTO_gcm128_setiv(loopargs[i].gcm_ctx,
2074                                 (unsigned char *)"0123456789ab", 12);
2075         }
2076
2077         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2078             print_message(names[D_GHASH], c[D_GHASH][testnum],
2079                           lengths[testnum]);
2080             Time_F(START);
2081             count = run_benchmark(async_jobs, CRYPTO_gcm128_aad_loop, loopargs);
2082             d = Time_F(STOP);
2083             print_result(D_GHASH, testnum, count, d);
2084         }
2085         for (i = 0; i < loopargs_len; i++)
2086             CRYPTO_gcm128_release(loopargs[i].gcm_ctx);
2087     }
2088 #ifndef OPENSSL_NO_CAMELLIA
2089     if (doit[D_CBC_128_CML]) {
2090         if (async_jobs > 0) {
2091             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2092                        names[D_CBC_128_CML]);
2093             doit[D_CBC_128_CML] = 0;
2094         }
2095         for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2096             print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][testnum],
2097                           lengths[testnum]);
2098             Time_F(START);
2099             for (count = 0, run = 1; COND(c[D_CBC_128_CML][testnum]); count++)
2100                 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2101                                      (size_t)lengths[testnum], &camellia_ks1,
2102                                      iv, CAMELLIA_ENCRYPT);
2103             d = Time_F(STOP);
2104             print_result(D_CBC_128_CML, testnum, count, d);
2105         }
2106     }
2107     if (doit[D_CBC_192_CML]) {
2108         if (async_jobs > 0) {
2109             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2110                        names[D_CBC_192_CML]);
2111             doit[D_CBC_192_CML] = 0;
2112         }
2113         for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2114             print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][testnum],
2115                           lengths[testnum]);
2116             if (async_jobs > 0) {
2117                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2118                 exit(1);
2119             }
2120             Time_F(START);
2121             for (count = 0, run = 1; COND(c[D_CBC_192_CML][testnum]); count++)
2122                 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2123                                      (size_t)lengths[testnum], &camellia_ks2,
2124                                      iv, CAMELLIA_ENCRYPT);
2125             d = Time_F(STOP);
2126             print_result(D_CBC_192_CML, testnum, count, d);
2127         }
2128     }
2129     if (doit[D_CBC_256_CML]) {
2130         if (async_jobs > 0) {
2131             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2132                        names[D_CBC_256_CML]);
2133             doit[D_CBC_256_CML] = 0;
2134         }
2135         for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2136             print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][testnum],
2137                           lengths[testnum]);
2138             Time_F(START);
2139             for (count = 0, run = 1; COND(c[D_CBC_256_CML][testnum]); count++)
2140                 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2141                                      (size_t)lengths[testnum], &camellia_ks3,
2142                                      iv, CAMELLIA_ENCRYPT);
2143             d = Time_F(STOP);
2144             print_result(D_CBC_256_CML, testnum, count, d);
2145         }
2146     }
2147 #endif
2148 #ifndef OPENSSL_NO_IDEA
2149     if (doit[D_CBC_IDEA]) {
2150         if (async_jobs > 0) {
2151             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2152                        names[D_CBC_IDEA]);
2153             doit[D_CBC_IDEA] = 0;
2154         }
2155         for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2156             print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][testnum],
2157                           lengths[testnum]);
2158             Time_F(START);
2159             for (count = 0, run = 1; COND(c[D_CBC_IDEA][testnum]); count++)
2160                 IDEA_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2161                                  (size_t)lengths[testnum], &idea_ks,
2162                                  iv, IDEA_ENCRYPT);
2163             d = Time_F(STOP);
2164             print_result(D_CBC_IDEA, testnum, count, d);
2165         }
2166     }
2167 #endif
2168 #ifndef OPENSSL_NO_SEED
2169     if (doit[D_CBC_SEED]) {
2170         if (async_jobs > 0) {
2171             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2172                        names[D_CBC_SEED]);
2173             doit[D_CBC_SEED] = 0;
2174         }
2175         for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2176             print_message(names[D_CBC_SEED], c[D_CBC_SEED][testnum],
2177                           lengths[testnum]);
2178             Time_F(START);
2179             for (count = 0, run = 1; COND(c[D_CBC_SEED][testnum]); count++)
2180                 SEED_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2181                                  (size_t)lengths[testnum], &seed_ks, iv, 1);
2182             d = Time_F(STOP);
2183             print_result(D_CBC_SEED, testnum, count, d);
2184         }
2185     }
2186 #endif
2187 #ifndef OPENSSL_NO_RC2
2188     if (doit[D_CBC_RC2]) {
2189         if (async_jobs > 0) {
2190             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2191                        names[D_CBC_RC2]);
2192             doit[D_CBC_RC2] = 0;
2193         }
2194         for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2195             print_message(names[D_CBC_RC2], c[D_CBC_RC2][testnum],
2196                           lengths[testnum]);
2197             if (async_jobs > 0) {
2198                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2199                 exit(1);
2200             }
2201             Time_F(START);
2202             for (count = 0, run = 1; COND(c[D_CBC_RC2][testnum]); count++)
2203                 RC2_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2204                                 (size_t)lengths[testnum], &rc2_ks,
2205                                 iv, RC2_ENCRYPT);
2206             d = Time_F(STOP);
2207             print_result(D_CBC_RC2, testnum, count, d);
2208         }
2209     }
2210 #endif
2211 #ifndef OPENSSL_NO_RC5
2212     if (doit[D_CBC_RC5]) {
2213         if (async_jobs > 0) {
2214             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2215                        names[D_CBC_RC5]);
2216             doit[D_CBC_RC5] = 0;
2217         }
2218         for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2219             print_message(names[D_CBC_RC5], c[D_CBC_RC5][testnum],
2220                           lengths[testnum]);
2221             if (async_jobs > 0) {
2222                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2223                 exit(1);
2224             }
2225             Time_F(START);
2226             for (count = 0, run = 1; COND(c[D_CBC_RC5][testnum]); count++)
2227                 RC5_32_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2228                                    (size_t)lengths[testnum], &rc5_ks,
2229                                    iv, RC5_ENCRYPT);
2230             d = Time_F(STOP);
2231             print_result(D_CBC_RC5, testnum, count, d);
2232         }
2233     }
2234 #endif
2235 #ifndef OPENSSL_NO_BF
2236     if (doit[D_CBC_BF]) {
2237         if (async_jobs > 0) {
2238             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2239                        names[D_CBC_BF]);
2240             doit[D_CBC_BF] = 0;
2241         }
2242         for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2243             print_message(names[D_CBC_BF], c[D_CBC_BF][testnum],
2244                           lengths[testnum]);
2245             Time_F(START);
2246             for (count = 0, run = 1; COND(c[D_CBC_BF][testnum]); count++)
2247                 BF_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2248                                (size_t)lengths[testnum], &bf_ks,
2249                                iv, BF_ENCRYPT);
2250             d = Time_F(STOP);
2251             print_result(D_CBC_BF, testnum, count, d);
2252         }
2253     }
2254 #endif
2255 #ifndef OPENSSL_NO_CAST
2256     if (doit[D_CBC_CAST]) {
2257         if (async_jobs > 0) {
2258             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2259                        names[D_CBC_CAST]);
2260             doit[D_CBC_CAST] = 0;
2261         }
2262         for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2263             print_message(names[D_CBC_CAST], c[D_CBC_CAST][testnum],
2264                           lengths[testnum]);
2265             Time_F(START);
2266             for (count = 0, run = 1; COND(c[D_CBC_CAST][testnum]); count++)
2267                 CAST_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2268                                  (size_t)lengths[testnum], &cast_ks,
2269                                  iv, CAST_ENCRYPT);
2270             d = Time_F(STOP);
2271             print_result(D_CBC_CAST, testnum, count, d);
2272         }
2273     }
2274 #endif
2275
2276     if (doit[D_EVP]) {
2277 #ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
2278         if (multiblock && evp_cipher) {
2279             if (!
2280                 (EVP_CIPHER_flags(evp_cipher) &
2281                  EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
2282                 BIO_printf(bio_err, "%s is not multi-block capable\n",
2283                            OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher)));
2284                 goto end;
2285             }
2286             if (async_jobs > 0) {
2287                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2288                 exit(1);
2289             }
2290             multiblock_speed(evp_cipher);
2291             ret = 0;
2292             goto end;
2293         }
2294 #endif
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] = d / (double)count;
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] = d / (double)count;
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] = d / (double)count;
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] = d / (double)count;
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] = d / (double)count;
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] = d / (double)count;
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] = d / (double)count;
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], rsa_results[k][0], rsa_results[k][1],
2795                    1.0 / rsa_results[k][0], 1.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], dsa_results[k][0], dsa_results[k][1],
2813                    1.0 / dsa_results[k][0], 1.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                    ecdsa_results[k][0], ecdsa_results[k][1],
2835                    1.0 / ecdsa_results[k][0], 1.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                    ecdh_results[k][0], 1.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                 if (n)
3043                     rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
3044                 else
3045                     rsa_results[k][0] = d;
3046
3047                 d = atof(sstrsep(&p, sep));
3048                 if (n)
3049                     rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
3050                 else
3051                     rsa_results[k][1] = d;
3052             }
3053 # ifndef OPENSSL_NO_DSA
3054             else if (strncmp(buf, "+F3:", 4) == 0) {
3055                 int k;
3056                 double d;
3057
3058                 p = buf + 4;
3059                 k = atoi(sstrsep(&p, sep));
3060                 sstrsep(&p, sep);
3061
3062                 d = atof(sstrsep(&p, sep));
3063                 if (n)
3064                     dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d);
3065                 else
3066                     dsa_results[k][0] = d;
3067
3068                 d = atof(sstrsep(&p, sep));
3069                 if (n)
3070                     dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d);
3071                 else
3072                     dsa_results[k][1] = d;
3073             }
3074 # endif
3075 # ifndef OPENSSL_NO_EC
3076             else if (strncmp(buf, "+F4:", 4) == 0) {
3077                 int k;
3078                 double d;
3079
3080                 p = buf + 4;
3081                 k = atoi(sstrsep(&p, sep));
3082                 sstrsep(&p, sep);
3083
3084                 d = atof(sstrsep(&p, sep));
3085                 if (n)
3086                     ecdsa_results[k][0] = 1 / (1 / ecdsa_results[k][0] + 1 / d);
3087                 else
3088                     ecdsa_results[k][0] = d;
3089
3090                 d = atof(sstrsep(&p, sep));
3091                 if (n)
3092                     ecdsa_results[k][1] = 1 / (1 / ecdsa_results[k][1] + 1 / d);
3093                 else
3094                     ecdsa_results[k][1] = d;
3095             } else if (strncmp(buf, "+F5:", 4) == 0) {
3096                 int k;
3097                 double d;
3098
3099                 p = buf + 4;
3100                 k = atoi(sstrsep(&p, sep));
3101                 sstrsep(&p, sep);
3102
3103                 d = atof(sstrsep(&p, sep));
3104                 if (n)
3105                     ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
3106                 else
3107                     ecdh_results[k][0] = d;
3108
3109             }
3110 # endif
3111
3112             else if (strncmp(buf, "+H:", 3) == 0) {
3113                 ;
3114             } else
3115                 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf,
3116                            n);
3117         }
3118
3119         fclose(f);
3120     }
3121     free(fds);
3122     return 1;
3123 }
3124 #endif
3125
3126 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
3127 {
3128     static int mblengths[] =
3129         { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
3130     int j, count, num = OSSL_NELEM(mblengths);
3131     const char *alg_name;
3132     unsigned char *inp, *out, no_key[32], no_iv[16];
3133     EVP_CIPHER_CTX *ctx;
3134     double d = 0.0;
3135
3136     inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
3137     out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
3138     ctx = EVP_CIPHER_CTX_new();
3139     EVP_EncryptInit_ex(ctx, evp_cipher, NULL, no_key, no_iv);
3140     EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key), no_key);
3141     alg_name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
3142
3143     for (j = 0; j < num; j++) {
3144         print_message(alg_name, 0, mblengths[j]);
3145         Time_F(START);
3146         for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
3147             unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
3148             EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
3149             size_t len = mblengths[j];
3150             int packlen;
3151
3152             memset(aad, 0, 8);  /* avoid uninitialized values */
3153             aad[8] = 23;        /* SSL3_RT_APPLICATION_DATA */
3154             aad[9] = 3;         /* version */
3155             aad[10] = 2;
3156             aad[11] = 0;        /* length */
3157             aad[12] = 0;
3158             mb_param.out = NULL;
3159             mb_param.inp = aad;
3160             mb_param.len = len;
3161             mb_param.interleave = 8;
3162
3163             packlen = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
3164                                           sizeof(mb_param), &mb_param);
3165
3166             if (packlen > 0) {
3167                 mb_param.out = out;
3168                 mb_param.inp = inp;
3169                 mb_param.len = len;
3170                 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
3171                                     sizeof(mb_param), &mb_param);
3172             } else {
3173                 int pad;
3174
3175                 RAND_bytes(out, 16);
3176                 len += 16;
3177                 aad[11] = len >> 8;
3178                 aad[12] = len;
3179                 pad = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_TLS1_AAD,
3180                                           EVP_AEAD_TLS1_AAD_LEN, aad);
3181                 EVP_Cipher(ctx, out, inp, len + pad);
3182             }
3183         }
3184         d = Time_F(STOP);
3185         BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
3186                    : "%d %s's in %.2fs\n", count, "evp", d);
3187         results[D_EVP][j] = ((double)count) / d * mblengths[j];
3188     }
3189
3190     if (mr) {
3191         fprintf(stdout, "+H");
3192         for (j = 0; j < num; j++)
3193             fprintf(stdout, ":%d", mblengths[j]);
3194         fprintf(stdout, "\n");
3195         fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
3196         for (j = 0; j < num; j++)
3197             fprintf(stdout, ":%.2f", results[D_EVP][j]);
3198         fprintf(stdout, "\n");
3199     } else {
3200         fprintf(stdout,
3201                 "The 'numbers' are in 1000s of bytes per second processed.\n");
3202         fprintf(stdout, "type                    ");
3203         for (j = 0; j < num; j++)
3204             fprintf(stdout, "%7d bytes", mblengths[j]);
3205         fprintf(stdout, "\n");
3206         fprintf(stdout, "%-24s", alg_name);
3207
3208         for (j = 0; j < num; j++) {
3209             if (results[D_EVP][j] > 10000)
3210                 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
3211             else
3212                 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
3213         }
3214         fprintf(stdout, "\n");
3215     }
3216
3217     OPENSSL_free(inp);
3218     OPENSSL_free(out);
3219     EVP_CIPHER_CTX_free(ctx);
3220 }