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