apps/speed.c

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