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     ENGINE *e = NULL;
1223     loopargs_t *loopargs = NULL;
1224     int async_init = 0;
1225     int loopargs_len = 0;
1226     char *prog;
1227     const char *engine_id = NULL;
1228     const EVP_CIPHER *evp_cipher = NULL;
1229     double d = 0.0;
1230     OPTION_CHOICE o;
1231     int multiblock = 0, pr_header = 0;
1232     int doit[ALGOR_NUM] = { 0 };
1233     int ret = 1, i, k, misalign = 0;
1234     long count = 0;
1235 #ifndef NO_FORK
1236     int multi = 0;
1237 #endif
1238     unsigned int async_jobs = 0;
1239 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA) \
1240     || !defined(OPENSSL_NO_EC)
1241     long rsa_count = 1;
1242 #endif
1243
1244     /* What follows are the buffers and key material. */
1245 #ifndef OPENSSL_NO_RC5
1246     RC5_32_KEY rc5_ks;
1247 #endif
1248 #ifndef OPENSSL_NO_RC2
1249     RC2_KEY rc2_ks;
1250 #endif
1251 #ifndef OPENSSL_NO_IDEA
1252     IDEA_KEY_SCHEDULE idea_ks;
1253 #endif
1254 #ifndef OPENSSL_NO_SEED
1255     SEED_KEY_SCHEDULE seed_ks;
1256 #endif
1257 #ifndef OPENSSL_NO_BF
1258     BF_KEY bf_ks;
1259 #endif
1260 #ifndef OPENSSL_NO_CAST
1261     CAST_KEY cast_ks;
1262 #endif
1263     static const unsigned char key16[16] = {
1264         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1265         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1266     };
1267     static const unsigned char key24[24] = {
1268         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1269         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1270         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1271     };
1272     static const unsigned char key32[32] = {
1273         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1274         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1275         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1276         0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1277     };
1278 #ifndef OPENSSL_NO_CAMELLIA
1279     static const unsigned char ckey24[24] = {
1280         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1281         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1282         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1283     };
1284     static const unsigned char ckey32[32] = {
1285         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1286         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1287         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1288         0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1289     };
1290     CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
1291 #endif
1292 #ifndef OPENSSL_NO_DES
1293     static DES_cblock key = {
1294         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
1295     };
1296     static DES_cblock key2 = {
1297         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1298     };
1299     static DES_cblock key3 = {
1300         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1301     };
1302 #endif
1303 #ifndef OPENSSL_NO_RSA
1304     static const unsigned int rsa_bits[RSA_NUM] = {
1305         512, 1024, 2048, 3072, 4096, 7680, 15360
1306     };
1307     static const unsigned char *rsa_data[RSA_NUM] = {
1308         test512, test1024, test2048, test3072, test4096, test7680, test15360
1309     };
1310     static const int rsa_data_length[RSA_NUM] = {
1311         sizeof(test512), sizeof(test1024),
1312         sizeof(test2048), sizeof(test3072),
1313         sizeof(test4096), sizeof(test7680),
1314         sizeof(test15360)
1315     };
1316     int rsa_doit[RSA_NUM] = { 0 };
1317 #endif
1318 #ifndef OPENSSL_NO_DSA
1319     static const unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
1320     int dsa_doit[DSA_NUM] = { 0 };
1321 #endif
1322 #ifndef OPENSSL_NO_EC
1323     /*
1324      * We only test over the following curves as they are representative, To
1325      * add tests over more curves, simply add the curve NID and curve name to
1326      * the following arrays and increase the EC_NUM value accordingly.
1327      */
1328     static const unsigned int test_curves[EC_NUM] = {
1329         /* Prime Curves */
1330         NID_secp160r1, NID_X9_62_prime192v1, NID_secp224r1,
1331         NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
1332         /* Binary Curves */
1333         NID_sect163k1, NID_sect233k1, NID_sect283k1,
1334         NID_sect409k1, NID_sect571k1, NID_sect163r2,
1335         NID_sect233r1, NID_sect283r1, NID_sect409r1,
1336         NID_sect571r1,
1337         /* Other */
1338         NID_X25519
1339     };
1340     static const char *test_curves_names[EC_NUM] = {
1341         /* Prime Curves */
1342         "secp160r1", "nistp192", "nistp224",
1343         "nistp256", "nistp384", "nistp521",
1344         /* Binary Curves */
1345         "nistk163", "nistk233", "nistk283",
1346         "nistk409", "nistk571", "nistb163",
1347         "nistb233", "nistb283", "nistb409",
1348         "nistb571",
1349         /* Other */
1350         "X25519"
1351     };
1352     static const int test_curves_bits[EC_NUM] = {
1353         160, 192, 224,
1354         256, 384, 521,
1355         163, 233, 283,
1356         409, 571, 163,
1357         233, 283, 409,
1358         571, 253 /* X25519 */
1359     };
1360
1361     int ecdsa_doit[EC_NUM] = { 0 };
1362     int ecdh_doit[EC_NUM] = { 0 };
1363 #endif                          /* ndef OPENSSL_NO_EC */
1364
1365     prog = opt_init(argc, argv, speed_options);
1366     while ((o = opt_next()) != OPT_EOF) {
1367         switch (o) {
1368         case OPT_EOF:
1369         case OPT_ERR:
1370  opterr:
1371             BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
1372             goto end;
1373         case OPT_HELP:
1374             opt_help(speed_options);
1375             ret = 0;
1376             goto end;
1377         case OPT_ELAPSED:
1378             usertime = 0;
1379             break;
1380         case OPT_EVP:
1381             evp_cipher = EVP_get_cipherbyname(opt_arg());
1382             if (evp_cipher == NULL)
1383                 evp_md = EVP_get_digestbyname(opt_arg());
1384             if (evp_cipher == NULL && evp_md == NULL) {
1385                 BIO_printf(bio_err,
1386                            "%s: %s is an unknown cipher or digest\n",
1387                            prog, opt_arg());
1388                 goto end;
1389             }
1390             doit[D_EVP] = 1;
1391             break;
1392         case OPT_DECRYPT:
1393             decrypt = 1;
1394             break;
1395         case OPT_ENGINE:
1396             /*
1397              * In a forked execution, an engine might need to be
1398              * initialised by each child process, not by the parent.
1399              * So store the name here and run setup_engine() later on.
1400              */
1401             engine_id = opt_arg();
1402             break;
1403         case OPT_MULTI:
1404 #ifndef NO_FORK
1405             multi = atoi(opt_arg());
1406 #endif
1407             break;
1408         case OPT_ASYNCJOBS:
1409 #ifndef OPENSSL_NO_ASYNC
1410             async_jobs = atoi(opt_arg());
1411             if (!ASYNC_is_capable()) {
1412                 BIO_printf(bio_err,
1413                            "%s: async_jobs specified but async not supported\n",
1414                            prog);
1415                 goto opterr;
1416             }
1417             if (async_jobs > 99999) {
1418                 BIO_printf(bio_err,
1419                            "%s: too many async_jobs\n",
1420                            prog);
1421                 goto opterr;
1422             }
1423 #endif
1424             break;
1425         case OPT_MISALIGN:
1426             if (!opt_int(opt_arg(), &misalign))
1427                 goto end;
1428             if (misalign > MISALIGN) {
1429                 BIO_printf(bio_err,
1430                            "%s: Maximum offset is %d\n", prog, MISALIGN);
1431                 goto opterr;
1432             }
1433             break;
1434         case OPT_MR:
1435             mr = 1;
1436             break;
1437         case OPT_MB:
1438             multiblock = 1;
1439 #ifdef OPENSSL_NO_MULTIBLOCK
1440             BIO_printf(bio_err,
1441                        "%s: -mb specified but multi-block support is disabled\n",
1442                        prog);
1443             goto end;
1444 #endif
1445             break;
1446         }
1447     }
1448     argc = opt_num_rest();
1449     argv = opt_rest();
1450
1451     /* Remaining arguments are algorithms. */
1452     for ( ; *argv; argv++) {
1453         if (found(*argv, doit_choices, &i)) {
1454             doit[i] = 1;
1455             continue;
1456         }
1457 #ifndef OPENSSL_NO_DES
1458         if (strcmp(*argv, "des") == 0) {
1459             doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
1460             continue;
1461         }
1462 #endif
1463         if (strcmp(*argv, "sha") == 0) {
1464             doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
1465             continue;
1466         }
1467 #ifndef OPENSSL_NO_RSA
1468         if (strcmp(*argv, "openssl") == 0)
1469             continue;
1470         if (strcmp(*argv, "rsa") == 0) {
1471             rsa_doit[R_RSA_512] = rsa_doit[R_RSA_1024] =
1472                 rsa_doit[R_RSA_2048] = rsa_doit[R_RSA_3072] =
1473                 rsa_doit[R_RSA_4096] = rsa_doit[R_RSA_7680] =
1474                 rsa_doit[R_RSA_15360] = 1;
1475             continue;
1476         }
1477         if (found(*argv, rsa_choices, &i)) {
1478             rsa_doit[i] = 1;
1479             continue;
1480         }
1481 #endif
1482 #ifndef OPENSSL_NO_DSA
1483         if (strcmp(*argv, "dsa") == 0) {
1484             dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
1485                 dsa_doit[R_DSA_2048] = 1;
1486             continue;
1487         }
1488         if (found(*argv, dsa_choices, &i)) {
1489             dsa_doit[i] = 2;
1490             continue;
1491         }
1492 #endif
1493         if (strcmp(*argv, "aes") == 0) {
1494             doit[D_CBC_128_AES] = doit[D_CBC_192_AES] =
1495                 doit[D_CBC_256_AES] = 1;
1496             continue;
1497         }
1498 #ifndef OPENSSL_NO_CAMELLIA
1499         if (strcmp(*argv, "camellia") == 0) {
1500             doit[D_CBC_128_CML] = doit[D_CBC_192_CML] =
1501                 doit[D_CBC_256_CML] = 1;
1502             continue;
1503         }
1504 #endif
1505 #ifndef OPENSSL_NO_EC
1506         if (strcmp(*argv, "ecdsa") == 0) {
1507             for (i = 0; i < EC_NUM; i++)
1508                 ecdsa_doit[i] = 1;
1509             continue;
1510         }
1511         if (found(*argv, ecdsa_choices, &i)) {
1512             ecdsa_doit[i] = 2;
1513             continue;
1514         }
1515         if (strcmp(*argv, "ecdh") == 0) {
1516             for (i = 0; i < EC_NUM; i++)
1517                 ecdh_doit[i] = 1;
1518             continue;
1519         }
1520         if (found(*argv, ecdh_choices, &i)) {
1521             ecdh_doit[i] = 2;
1522             continue;
1523         }
1524 #endif
1525         BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
1526         goto end;
1527     }
1528
1529     /* Initialize the job pool if async mode is enabled */
1530     if (async_jobs > 0) {
1531         async_init = ASYNC_init_thread(async_jobs, async_jobs);
1532         if (!async_init) {
1533             BIO_printf(bio_err, "Error creating the ASYNC job pool\n");
1534             goto end;
1535         }
1536     }
1537
1538     loopargs_len = (async_jobs == 0 ? 1 : async_jobs);
1539     loopargs = app_malloc(loopargs_len * sizeof(loopargs_t), "array of loopargs");
1540     memset(loopargs, 0, loopargs_len * sizeof(loopargs_t));
1541
1542     for (i = 0; i < loopargs_len; i++) {
1543         if (async_jobs > 0) {
1544             loopargs[i].wait_ctx = ASYNC_WAIT_CTX_new();
1545             if (loopargs[i].wait_ctx == NULL) {
1546                 BIO_printf(bio_err, "Error creating the ASYNC_WAIT_CTX\n");
1547                 goto end;
1548             }
1549         }
1550
1551         loopargs[i].buf_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1552         loopargs[i].buf2_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1553         /* Align the start of buffers on a 64 byte boundary */
1554         loopargs[i].buf = loopargs[i].buf_malloc + misalign;
1555         loopargs[i].buf2 = loopargs[i].buf2_malloc + misalign;
1556 #ifndef OPENSSL_NO_EC
1557         loopargs[i].secret_a = app_malloc(MAX_ECDH_SIZE, "ECDH secret a");
1558         loopargs[i].secret_b = app_malloc(MAX_ECDH_SIZE, "ECDH secret b");
1559 #endif
1560     }
1561
1562 #ifndef NO_FORK
1563     if (multi && do_multi(multi))
1564         goto show_res;
1565 #endif
1566
1567     /* Initialize the engine after the fork */
1568     e = setup_engine(engine_id, 0);
1569
1570     /* No parameters; turn on everything. */
1571     if ((argc == 0) && !doit[D_EVP]) {
1572         for (i = 0; i < ALGOR_NUM; i++)
1573             if (i != D_EVP)
1574                 doit[i] = 1;
1575 #ifndef OPENSSL_NO_RSA
1576         for (i = 0; i < RSA_NUM; i++)
1577             rsa_doit[i] = 1;
1578 #endif
1579 #ifndef OPENSSL_NO_DSA
1580         for (i = 0; i < DSA_NUM; i++)
1581             dsa_doit[i] = 1;
1582 #endif
1583 #ifndef OPENSSL_NO_EC
1584         for (i = 0; i < EC_NUM; i++)
1585             ecdsa_doit[i] = 1;
1586         for (i = 0; i < EC_NUM; i++)
1587             ecdh_doit[i] = 1;
1588 #endif
1589     }
1590     for (i = 0; i < ALGOR_NUM; i++)
1591         if (doit[i])
1592             pr_header++;
1593
1594     if (usertime == 0 && !mr)
1595         BIO_printf(bio_err,
1596                    "You have chosen to measure elapsed time "
1597                    "instead of user CPU time.\n");
1598
1599 #ifndef OPENSSL_NO_RSA
1600     for (i = 0; i < loopargs_len; i++) {
1601         for (k = 0; k < RSA_NUM; k++) {
1602             const unsigned char *p;
1603
1604             p = rsa_data[k];
1605             loopargs[i].rsa_key[k] = d2i_RSAPrivateKey(NULL, &p, rsa_data_length[k]);
1606             if (loopargs[i].rsa_key[k] == NULL) {
1607                 BIO_printf(bio_err, "internal error loading RSA key number %d\n",
1608                         k);
1609                 goto end;
1610             }
1611         }
1612     }
1613 #endif
1614 #ifndef OPENSSL_NO_DSA
1615     for (i = 0; i < loopargs_len; i++) {
1616         loopargs[i].dsa_key[0] = get_dsa512();
1617         loopargs[i].dsa_key[1] = get_dsa1024();
1618         loopargs[i].dsa_key[2] = get_dsa2048();
1619     }
1620 #endif
1621 #ifndef OPENSSL_NO_DES
1622     DES_set_key_unchecked(&key, &sch);
1623     DES_set_key_unchecked(&key2, &sch2);
1624     DES_set_key_unchecked(&key3, &sch3);
1625 #endif
1626     AES_set_encrypt_key(key16, 128, &aes_ks1);
1627     AES_set_encrypt_key(key24, 192, &aes_ks2);
1628     AES_set_encrypt_key(key32, 256, &aes_ks3);
1629 #ifndef OPENSSL_NO_CAMELLIA
1630     Camellia_set_key(key16, 128, &camellia_ks1);
1631     Camellia_set_key(ckey24, 192, &camellia_ks2);
1632     Camellia_set_key(ckey32, 256, &camellia_ks3);
1633 #endif
1634 #ifndef OPENSSL_NO_IDEA
1635     IDEA_set_encrypt_key(key16, &idea_ks);
1636 #endif
1637 #ifndef OPENSSL_NO_SEED
1638     SEED_set_key(key16, &seed_ks);
1639 #endif
1640 #ifndef OPENSSL_NO_RC4
1641     RC4_set_key(&rc4_ks, 16, key16);
1642 #endif
1643 #ifndef OPENSSL_NO_RC2
1644     RC2_set_key(&rc2_ks, 16, key16, 128);
1645 #endif
1646 #ifndef OPENSSL_NO_RC5
1647     RC5_32_set_key(&rc5_ks, 16, key16, 12);
1648 #endif
1649 #ifndef OPENSSL_NO_BF
1650     BF_set_key(&bf_ks, 16, key16);
1651 #endif
1652 #ifndef OPENSSL_NO_CAST
1653     CAST_set_key(&cast_ks, 16, key16);
1654 #endif
1655 #ifndef SIGALRM
1656 # ifndef OPENSSL_NO_DES
1657     BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1658     count = 10;
1659     do {
1660         long it;
1661         count *= 2;
1662         Time_F(START);
1663         for (it = count; it; it--)
1664             DES_ecb_encrypt((DES_cblock *)loopargs[0].buf,
1665                             (DES_cblock *)loopargs[0].buf, &sch, DES_ENCRYPT);
1666         d = Time_F(STOP);
1667     } while (d < 3);
1668     save_count = count;
1669     c[D_MD2][0] = count / 10;
1670     c[D_MDC2][0] = count / 10;
1671     c[D_MD4][0] = count;
1672     c[D_MD5][0] = count;
1673     c[D_HMAC][0] = count;
1674     c[D_SHA1][0] = count;
1675     c[D_RMD160][0] = count;
1676     c[D_RC4][0] = count * 5;
1677     c[D_CBC_DES][0] = count;
1678     c[D_EDE3_DES][0] = count / 3;
1679     c[D_CBC_IDEA][0] = count;
1680     c[D_CBC_SEED][0] = count;
1681     c[D_CBC_RC2][0] = count;
1682     c[D_CBC_RC5][0] = count;
1683     c[D_CBC_BF][0] = count;
1684     c[D_CBC_CAST][0] = count;
1685     c[D_CBC_128_AES][0] = count;
1686     c[D_CBC_192_AES][0] = count;
1687     c[D_CBC_256_AES][0] = count;
1688     c[D_CBC_128_CML][0] = count;
1689     c[D_CBC_192_CML][0] = count;
1690     c[D_CBC_256_CML][0] = count;
1691     c[D_SHA256][0] = count;
1692     c[D_SHA512][0] = count;
1693     c[D_WHIRLPOOL][0] = count;
1694     c[D_IGE_128_AES][0] = count;
1695     c[D_IGE_192_AES][0] = count;
1696     c[D_IGE_256_AES][0] = count;
1697     c[D_GHASH][0] = count;
1698
1699     for (i = 1; i < SIZE_NUM; i++) {
1700         long l0, l1;
1701
1702         l0 = (long)lengths[0];
1703         l1 = (long)lengths[i];
1704
1705         c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1706         c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1707         c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1708         c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1709         c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1710         c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1711         c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1712         c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1713         c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1714         c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1715         c[D_GHASH][i] = c[D_GHASH][0] * 4 * l0 / l1;
1716
1717         l0 = (long)lengths[i - 1];
1718
1719         c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1720         c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1721         c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1722         c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1723         c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1724         c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1725         c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1726         c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1727         c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1728         c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1729         c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1730         c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1731         c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1732         c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1733         c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1734         c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1735         c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1736         c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1737     }
1738
1739 #  ifndef OPENSSL_NO_RSA
1740     rsa_c[R_RSA_512][0] = count / 2000;
1741     rsa_c[R_RSA_512][1] = count / 400;
1742     for (i = 1; i < RSA_NUM; i++) {
1743         rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1744         rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1745         if (rsa_doit[i] <= 1 && rsa_c[i][0] == 0)
1746             rsa_doit[i] = 0;
1747         else {
1748             if (rsa_c[i][0] == 0) {
1749                 rsa_c[i][0] = 1;            /* Set minimum iteration Nb to 1. */
1750                 rsa_c[i][1] = 20;
1751             }
1752         }
1753     }
1754 #  endif
1755
1756 #  ifndef OPENSSL_NO_DSA
1757     dsa_c[R_DSA_512][0] = count / 1000;
1758     dsa_c[R_DSA_512][1] = count / 1000 / 2;
1759     for (i = 1; i < DSA_NUM; i++) {
1760         dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1761         dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1762         if (dsa_doit[i] <= 1 && dsa_c[i][0] == 0)
1763             dsa_doit[i] = 0;
1764         else {
1765             if (dsa_c[i][0] == 0) {
1766                 dsa_c[i][0] = 1;            /* Set minimum iteration Nb to 1. */
1767                 dsa_c[i][1] = 1;
1768             }
1769         }
1770     }
1771 #  endif
1772
1773 #  ifndef OPENSSL_NO_EC
1774     ecdsa_c[R_EC_P160][0] = count / 1000;
1775     ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1776     for (i = R_EC_P192; i <= R_EC_P521; i++) {
1777         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1778         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1779         if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1780             ecdsa_doit[i] = 0;
1781         else {
1782             if (ecdsa_c[i][0] == 0) {
1783                 ecdsa_c[i][0] = 1;
1784                 ecdsa_c[i][1] = 1;
1785             }
1786         }
1787     }
1788     ecdsa_c[R_EC_K163][0] = count / 1000;
1789     ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1790     for (i = R_EC_K233; i <= R_EC_K571; i++) {
1791         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1792         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1793         if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1794             ecdsa_doit[i] = 0;
1795         else {
1796             if (ecdsa_c[i][0] == 0) {
1797                 ecdsa_c[i][0] = 1;
1798                 ecdsa_c[i][1] = 1;
1799             }
1800         }
1801     }
1802     ecdsa_c[R_EC_B163][0] = count / 1000;
1803     ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1804     for (i = R_EC_B233; i <= R_EC_B571; i++) {
1805         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1806         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1807         if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1808             ecdsa_doit[i] = 0;
1809         else {
1810             if (ecdsa_c[i][0] == 0) {
1811                 ecdsa_c[i][0] = 1;
1812                 ecdsa_c[i][1] = 1;
1813             }
1814         }
1815     }
1816
1817     ecdh_c[R_EC_P160][0] = count / 1000;
1818     for (i = R_EC_P192; i <= R_EC_P521; i++) {
1819         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1820         if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1821             ecdh_doit[i] = 0;
1822         else {
1823             if (ecdh_c[i][0] == 0) {
1824                 ecdh_c[i][0] = 1;
1825             }
1826         }
1827     }
1828     ecdh_c[R_EC_K163][0] = count / 1000;
1829     for (i = R_EC_K233; i <= R_EC_K571; i++) {
1830         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1831         if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1832             ecdh_doit[i] = 0;
1833         else {
1834             if (ecdh_c[i][0] == 0) {
1835                 ecdh_c[i][0] = 1;
1836             }
1837         }
1838     }
1839     ecdh_c[R_EC_B163][0] = count / 1000;
1840     for (i = R_EC_B233; i <= R_EC_B571; i++) {
1841         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1842         if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1843             ecdh_doit[i] = 0;
1844         else {
1845             if (ecdh_c[i][0] == 0) {
1846                 ecdh_c[i][0] = 1;
1847             }
1848         }
1849     }
1850 #  endif
1851
1852 # else
1853 /* not worth fixing */
1854 #  error "You cannot disable DES on systems without SIGALRM."
1855 # endif                        /* OPENSSL_NO_DES */
1856 #else
1857 # ifndef _WIN32
1858     signal(SIGALRM, sig_done);
1859 # endif
1860 #endif                         /* SIGALRM */
1861
1862 #ifndef OPENSSL_NO_MD2
1863     if (doit[D_MD2]) {
1864         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1865             print_message(names[D_MD2], c[D_MD2][testnum], lengths[testnum]);
1866             Time_F(START);
1867             count = run_benchmark(async_jobs, EVP_Digest_MD2_loop, loopargs);
1868             d = Time_F(STOP);
1869             print_result(D_MD2, testnum, count, d);
1870         }
1871     }
1872 #endif
1873 #ifndef OPENSSL_NO_MDC2
1874     if (doit[D_MDC2]) {
1875         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1876             print_message(names[D_MDC2], c[D_MDC2][testnum], lengths[testnum]);
1877             Time_F(START);
1878             count = run_benchmark(async_jobs, EVP_Digest_MDC2_loop, loopargs);
1879             d = Time_F(STOP);
1880             print_result(D_MDC2, testnum, count, d);
1881         }
1882     }
1883 #endif
1884
1885 #ifndef OPENSSL_NO_MD4
1886     if (doit[D_MD4]) {
1887         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1888             print_message(names[D_MD4], c[D_MD4][testnum], lengths[testnum]);
1889             Time_F(START);
1890             count = run_benchmark(async_jobs, EVP_Digest_MD4_loop, loopargs);
1891             d = Time_F(STOP);
1892             print_result(D_MD4, testnum, count, d);
1893         }
1894     }
1895 #endif
1896
1897 #ifndef OPENSSL_NO_MD5
1898     if (doit[D_MD5]) {
1899         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1900             print_message(names[D_MD5], c[D_MD5][testnum], lengths[testnum]);
1901             Time_F(START);
1902             count = run_benchmark(async_jobs, MD5_loop, loopargs);
1903             d = Time_F(STOP);
1904             print_result(D_MD5, testnum, count, d);
1905         }
1906     }
1907
1908     if (doit[D_HMAC]) {
1909         static const char hmac_key[] = "This is a key...";
1910         int len = strlen(hmac_key);
1911
1912         for (i = 0; i < loopargs_len; i++) {
1913             loopargs[i].hctx = HMAC_CTX_new();
1914             if (loopargs[i].hctx == NULL) {
1915                 BIO_printf(bio_err, "HMAC malloc failure, exiting...");
1916                 exit(1);
1917             }
1918
1919             HMAC_Init_ex(loopargs[i].hctx, hmac_key, len, EVP_md5(), NULL);
1920         }
1921         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1922             print_message(names[D_HMAC], c[D_HMAC][testnum], lengths[testnum]);
1923             Time_F(START);
1924             count = run_benchmark(async_jobs, HMAC_loop, loopargs);
1925             d = Time_F(STOP);
1926             print_result(D_HMAC, testnum, count, d);
1927         }
1928         for (i = 0; i < loopargs_len; i++) {
1929             HMAC_CTX_free(loopargs[i].hctx);
1930         }
1931     }
1932 #endif
1933     if (doit[D_SHA1]) {
1934         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1935             print_message(names[D_SHA1], c[D_SHA1][testnum], lengths[testnum]);
1936             Time_F(START);
1937             count = run_benchmark(async_jobs, SHA1_loop, loopargs);
1938             d = Time_F(STOP);
1939             print_result(D_SHA1, testnum, count, d);
1940         }
1941     }
1942     if (doit[D_SHA256]) {
1943         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1944             print_message(names[D_SHA256], c[D_SHA256][testnum], lengths[testnum]);
1945             Time_F(START);
1946             count = run_benchmark(async_jobs, SHA256_loop, loopargs);
1947             d = Time_F(STOP);
1948             print_result(D_SHA256, testnum, count, d);
1949         }
1950     }
1951     if (doit[D_SHA512]) {
1952         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1953             print_message(names[D_SHA512], c[D_SHA512][testnum], lengths[testnum]);
1954             Time_F(START);
1955             count = run_benchmark(async_jobs, SHA512_loop, loopargs);
1956             d = Time_F(STOP);
1957             print_result(D_SHA512, testnum, count, d);
1958         }
1959     }
1960
1961 #ifndef OPENSSL_NO_WHIRLPOOL
1962     if (doit[D_WHIRLPOOL]) {
1963         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1964             print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][testnum], lengths[testnum]);
1965             Time_F(START);
1966             count = run_benchmark(async_jobs, WHIRLPOOL_loop, loopargs);
1967             d = Time_F(STOP);
1968             print_result(D_WHIRLPOOL, testnum, count, d);
1969         }
1970     }
1971 #endif
1972
1973 #ifndef OPENSSL_NO_RMD160
1974     if (doit[D_RMD160]) {
1975         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1976             print_message(names[D_RMD160], c[D_RMD160][testnum], lengths[testnum]);
1977             Time_F(START);
1978             count = run_benchmark(async_jobs, EVP_Digest_RMD160_loop, loopargs);
1979             d = Time_F(STOP);
1980             print_result(D_RMD160, testnum, count, d);
1981         }
1982     }
1983 #endif
1984 #ifndef OPENSSL_NO_RC4
1985     if (doit[D_RC4]) {
1986         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1987             print_message(names[D_RC4], c[D_RC4][testnum], lengths[testnum]);
1988             Time_F(START);
1989             count = run_benchmark(async_jobs, RC4_loop, loopargs);
1990             d = Time_F(STOP);
1991             print_result(D_RC4, testnum, count, d);
1992         }
1993     }
1994 #endif
1995 #ifndef OPENSSL_NO_DES
1996     if (doit[D_CBC_DES]) {
1997         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1998             print_message(names[D_CBC_DES], c[D_CBC_DES][testnum], lengths[testnum]);
1999             Time_F(START);
2000             count = run_benchmark(async_jobs, DES_ncbc_encrypt_loop, loopargs);
2001             d = Time_F(STOP);
2002             print_result(D_CBC_DES, testnum, count, d);
2003         }
2004     }
2005
2006     if (doit[D_EDE3_DES]) {
2007         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2008             print_message(names[D_EDE3_DES], c[D_EDE3_DES][testnum], lengths[testnum]);
2009             Time_F(START);
2010             count = run_benchmark(async_jobs, DES_ede3_cbc_encrypt_loop, loopargs);
2011             d = Time_F(STOP);
2012             print_result(D_EDE3_DES, testnum, count, d);
2013         }
2014     }
2015 #endif
2016
2017     if (doit[D_CBC_128_AES]) {
2018         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2019             print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][testnum],
2020                           lengths[testnum]);
2021             Time_F(START);
2022             count = run_benchmark(async_jobs, AES_cbc_128_encrypt_loop, loopargs);
2023             d = Time_F(STOP);
2024             print_result(D_CBC_128_AES, testnum, count, d);
2025         }
2026     }
2027     if (doit[D_CBC_192_AES]) {
2028         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2029             print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][testnum],
2030                           lengths[testnum]);
2031             Time_F(START);
2032             count = run_benchmark(async_jobs, AES_cbc_192_encrypt_loop, loopargs);
2033             d = Time_F(STOP);
2034             print_result(D_CBC_192_AES, testnum, count, d);
2035         }
2036     }
2037     if (doit[D_CBC_256_AES]) {
2038         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2039             print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][testnum],
2040                           lengths[testnum]);
2041             Time_F(START);
2042             count = run_benchmark(async_jobs, AES_cbc_256_encrypt_loop, loopargs);
2043             d = Time_F(STOP);
2044             print_result(D_CBC_256_AES, testnum, count, d);
2045         }
2046     }
2047
2048     if (doit[D_IGE_128_AES]) {
2049         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2050             print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][testnum],
2051                           lengths[testnum]);
2052             Time_F(START);
2053             count = run_benchmark(async_jobs, AES_ige_128_encrypt_loop, loopargs);
2054             d = Time_F(STOP);
2055             print_result(D_IGE_128_AES, testnum, count, d);
2056         }
2057     }
2058     if (doit[D_IGE_192_AES]) {
2059         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2060             print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][testnum],
2061                           lengths[testnum]);
2062             Time_F(START);
2063             count = run_benchmark(async_jobs, AES_ige_192_encrypt_loop, loopargs);
2064             d = Time_F(STOP);
2065             print_result(D_IGE_192_AES, testnum, count, d);
2066         }
2067     }
2068     if (doit[D_IGE_256_AES]) {
2069         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2070             print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][testnum],
2071                           lengths[testnum]);
2072             Time_F(START);
2073             count = run_benchmark(async_jobs, AES_ige_256_encrypt_loop, loopargs);
2074             d = Time_F(STOP);
2075             print_result(D_IGE_256_AES, testnum, count, d);
2076         }
2077     }
2078     if (doit[D_GHASH]) {
2079         for (i = 0; i < loopargs_len; i++) {
2080             loopargs[i].gcm_ctx = CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
2081             CRYPTO_gcm128_setiv(loopargs[i].gcm_ctx, (unsigned char *)"0123456789ab", 12);
2082         }
2083
2084         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2085             print_message(names[D_GHASH], c[D_GHASH][testnum], lengths[testnum]);
2086             Time_F(START);
2087             count = run_benchmark(async_jobs, CRYPTO_gcm128_aad_loop, loopargs);
2088             d = Time_F(STOP);
2089             print_result(D_GHASH, testnum, count, d);
2090         }
2091         for (i = 0; i < loopargs_len; i++)
2092             CRYPTO_gcm128_release(loopargs[i].gcm_ctx);
2093     }
2094
2095 #ifndef OPENSSL_NO_CAMELLIA
2096     if (doit[D_CBC_128_CML]) {
2097         if (async_jobs > 0) {
2098             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2099                        names[D_CBC_128_CML]);
2100             doit[D_CBC_128_CML] = 0;
2101         }
2102         for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2103             print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][testnum],
2104                           lengths[testnum]);
2105             Time_F(START);
2106             for (count = 0, run = 1; COND(c[D_CBC_128_CML][testnum]); count++)
2107                 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2108                                      (size_t)lengths[testnum], &camellia_ks1,
2109                                      iv, CAMELLIA_ENCRYPT);
2110             d = Time_F(STOP);
2111             print_result(D_CBC_128_CML, testnum, count, d);
2112         }
2113     }
2114     if (doit[D_CBC_192_CML]) {
2115         if (async_jobs > 0) {
2116             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2117                        names[D_CBC_192_CML]);
2118             doit[D_CBC_192_CML] = 0;
2119         }
2120         for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2121             print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][testnum],
2122                           lengths[testnum]);
2123             if (async_jobs > 0) {
2124                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2125                 exit(1);
2126             }
2127             Time_F(START);
2128             for (count = 0, run = 1; COND(c[D_CBC_192_CML][testnum]); count++)
2129                 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2130                                      (size_t)lengths[testnum], &camellia_ks2,
2131                                      iv, CAMELLIA_ENCRYPT);
2132             d = Time_F(STOP);
2133             print_result(D_CBC_192_CML, testnum, count, d);
2134         }
2135     }
2136     if (doit[D_CBC_256_CML]) {
2137         if (async_jobs > 0) {
2138             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2139                        names[D_CBC_256_CML]);
2140             doit[D_CBC_256_CML] = 0;
2141         }
2142         for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2143             print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][testnum],
2144                           lengths[testnum]);
2145             Time_F(START);
2146             for (count = 0, run = 1; COND(c[D_CBC_256_CML][testnum]); count++)
2147                 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2148                                      (size_t)lengths[testnum], &camellia_ks3,
2149                                      iv, CAMELLIA_ENCRYPT);
2150             d = Time_F(STOP);
2151             print_result(D_CBC_256_CML, testnum, count, d);
2152         }
2153     }
2154 #endif
2155 #ifndef OPENSSL_NO_IDEA
2156     if (doit[D_CBC_IDEA]) {
2157         if (async_jobs > 0) {
2158             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2159                        names[D_CBC_IDEA]);
2160             doit[D_CBC_IDEA] = 0;
2161         }
2162         for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2163             print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][testnum], lengths[testnum]);
2164             Time_F(START);
2165             for (count = 0, run = 1; COND(c[D_CBC_IDEA][testnum]); count++)
2166                 IDEA_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2167                                  (size_t)lengths[testnum], &idea_ks,
2168                                  iv, IDEA_ENCRYPT);
2169             d = Time_F(STOP);
2170             print_result(D_CBC_IDEA, testnum, count, d);
2171         }
2172     }
2173 #endif
2174 #ifndef OPENSSL_NO_SEED
2175     if (doit[D_CBC_SEED]) {
2176         if (async_jobs > 0) {
2177             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2178                        names[D_CBC_SEED]);
2179             doit[D_CBC_SEED] = 0;
2180         }
2181         for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2182             print_message(names[D_CBC_SEED], c[D_CBC_SEED][testnum], lengths[testnum]);
2183             Time_F(START);
2184             for (count = 0, run = 1; COND(c[D_CBC_SEED][testnum]); count++)
2185                 SEED_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2186                                  (size_t)lengths[testnum], &seed_ks, iv, 1);
2187             d = Time_F(STOP);
2188             print_result(D_CBC_SEED, testnum, count, d);
2189         }
2190     }
2191 #endif
2192 #ifndef OPENSSL_NO_RC2
2193     if (doit[D_CBC_RC2]) {
2194         if (async_jobs > 0) {
2195             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2196                        names[D_CBC_RC2]);
2197             doit[D_CBC_RC2] = 0;
2198         }
2199         for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2200             print_message(names[D_CBC_RC2], c[D_CBC_RC2][testnum], lengths[testnum]);
2201             if (async_jobs > 0) {
2202                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2203                 exit(1);
2204             }
2205             Time_F(START);
2206             for (count = 0, run = 1; COND(c[D_CBC_RC2][testnum]); count++)
2207                 RC2_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2208                                 (size_t)lengths[testnum], &rc2_ks,
2209                                 iv, RC2_ENCRYPT);
2210             d = Time_F(STOP);
2211             print_result(D_CBC_RC2, testnum, count, d);
2212         }
2213     }
2214 #endif
2215 #ifndef OPENSSL_NO_RC5
2216     if (doit[D_CBC_RC5]) {
2217         if (async_jobs > 0) {
2218             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2219                        names[D_CBC_RC5]);
2220             doit[D_CBC_RC5] = 0;
2221         }
2222         for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2223             print_message(names[D_CBC_RC5], c[D_CBC_RC5][testnum], lengths[testnum]);
2224             if (async_jobs > 0) {
2225                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2226                 exit(1);
2227             }
2228             Time_F(START);
2229             for (count = 0, run = 1; COND(c[D_CBC_RC5][testnum]); count++)
2230                 RC5_32_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2231                                    (size_t)lengths[testnum], &rc5_ks,
2232                                    iv, RC5_ENCRYPT);
2233             d = Time_F(STOP);
2234             print_result(D_CBC_RC5, testnum, count, d);
2235         }
2236     }
2237 #endif
2238 #ifndef OPENSSL_NO_BF
2239     if (doit[D_CBC_BF]) {
2240         if (async_jobs > 0) {
2241             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2242                        names[D_CBC_BF]);
2243             doit[D_CBC_BF] = 0;
2244         }
2245         for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2246             print_message(names[D_CBC_BF], c[D_CBC_BF][testnum], lengths[testnum]);
2247             Time_F(START);
2248             for (count = 0, run = 1; COND(c[D_CBC_BF][testnum]); count++)
2249                 BF_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2250                                (size_t)lengths[testnum], &bf_ks,
2251                                iv, BF_ENCRYPT);
2252             d = Time_F(STOP);
2253             print_result(D_CBC_BF, testnum, count, d);
2254         }
2255     }
2256 #endif
2257 #ifndef OPENSSL_NO_CAST
2258     if (doit[D_CBC_CAST]) {
2259         if (async_jobs > 0) {
2260             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2261                        names[D_CBC_CAST]);
2262             doit[D_CBC_CAST] = 0;
2263         }
2264         for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2265             print_message(names[D_CBC_CAST], c[D_CBC_CAST][testnum], lengths[testnum]);
2266             Time_F(START);
2267             for (count = 0, run = 1; COND(c[D_CBC_CAST][testnum]); count++)
2268                 CAST_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2269                                  (size_t)lengths[testnum], &cast_ks,
2270                                  iv, CAST_ENCRYPT);
2271             d = Time_F(STOP);
2272             print_result(D_CBC_CAST, testnum, count, d);
2273         }
2274     }
2275 #endif
2276
2277     if (doit[D_EVP]) {
2278         if (multiblock && evp_cipher) {
2279             if (!
2280                 (EVP_CIPHER_flags(evp_cipher) &
2281                  EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
2282                 BIO_printf(bio_err, "%s is not multi-block capable\n",
2283                            OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher)));
2284                 goto end;
2285             }
2286             if (async_jobs > 0) {
2287                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2288                 exit(1);
2289             }
2290             multiblock_speed(evp_cipher);
2291             ret = 0;
2292             goto end;
2293         }
2294         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2295             if (evp_cipher) {
2296
2297                 names[D_EVP] = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
2298                 /*
2299                  * -O3 -fschedule-insns messes up an optimization here!
2300                  * names[D_EVP] somehow becomes NULL
2301                  */
2302                 print_message(names[D_EVP], save_count, lengths[testnum]);
2303
2304                 for (k = 0; k < loopargs_len; k++) {
2305                     loopargs[k].ctx = EVP_CIPHER_CTX_new();
2306                     if (decrypt)
2307                         EVP_DecryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
2308                     else
2309                         EVP_EncryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
2310                     EVP_CIPHER_CTX_set_padding(loopargs[k].ctx, 0);
2311                 }
2312
2313                 Time_F(START);
2314                 count = run_benchmark(async_jobs, EVP_Update_loop, loopargs);
2315                 d = Time_F(STOP);
2316                 for (k = 0; k < loopargs_len; k++) {
2317                     EVP_CIPHER_CTX_free(loopargs[k].ctx);
2318                 }
2319             }
2320             if (evp_md) {
2321                 names[D_EVP] = OBJ_nid2ln(EVP_MD_type(evp_md));
2322                 print_message(names[D_EVP], save_count, lengths[testnum]);
2323                 Time_F(START);
2324                 count = run_benchmark(async_jobs, EVP_Digest_loop, loopargs);
2325                 d = Time_F(STOP);
2326             }
2327             print_result(D_EVP, testnum, count, d);
2328         }
2329     }
2330
2331     for (i = 0; i < loopargs_len; i++)
2332         RAND_bytes(loopargs[i].buf, 36);
2333
2334 #ifndef OPENSSL_NO_RSA
2335     for (testnum = 0; testnum < RSA_NUM; testnum++) {
2336         int st = 0;
2337         if (!rsa_doit[testnum])
2338             continue;
2339         for (i = 0; i < loopargs_len; i++) {
2340             st = RSA_sign(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2341                           &loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2342             if (st == 0)
2343                 break;
2344         }
2345         if (st == 0) {
2346             BIO_printf(bio_err,
2347                        "RSA sign failure.  No RSA sign will be done.\n");
2348             ERR_print_errors(bio_err);
2349             rsa_count = 1;
2350         } else {
2351             pkey_print_message("private", "rsa",
2352                                rsa_c[testnum][0], rsa_bits[testnum], RSA_SECONDS);
2353             /* RSA_blinding_on(rsa_key[testnum],NULL); */
2354             Time_F(START);
2355             count = run_benchmark(async_jobs, RSA_sign_loop, loopargs);
2356             d = Time_F(STOP);
2357             BIO_printf(bio_err,
2358                        mr ? "+R1:%ld:%d:%.2f\n"
2359                        : "%ld %d bit private RSA's in %.2fs\n",
2360                        count, rsa_bits[testnum], d);
2361             rsa_results[testnum][0] = d / (double)count;
2362             rsa_count = count;
2363         }
2364
2365         for (i = 0; i < loopargs_len; i++) {
2366             st = RSA_verify(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2367                             loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2368             if (st <= 0)
2369                 break;
2370         }
2371         if (st <= 0) {
2372             BIO_printf(bio_err,
2373                        "RSA verify failure.  No RSA verify will be done.\n");
2374             ERR_print_errors(bio_err);
2375             rsa_doit[testnum] = 0;
2376         } else {
2377             pkey_print_message("public", "rsa",
2378                                rsa_c[testnum][1], rsa_bits[testnum], RSA_SECONDS);
2379             Time_F(START);
2380             count = run_benchmark(async_jobs, RSA_verify_loop, loopargs);
2381             d = Time_F(STOP);
2382             BIO_printf(bio_err,
2383                        mr ? "+R2:%ld:%d:%.2f\n"
2384                        : "%ld %d bit public RSA's in %.2fs\n",
2385                        count, rsa_bits[testnum], d);
2386             rsa_results[testnum][1] = d / (double)count;
2387         }
2388
2389         if (rsa_count <= 1) {
2390             /* if longer than 10s, don't do any more */
2391             for (testnum++; testnum < RSA_NUM; testnum++)
2392                 rsa_doit[testnum] = 0;
2393         }
2394     }
2395 #endif                          /* OPENSSL_NO_RSA */
2396
2397     for (i = 0; i < loopargs_len; i++)
2398         RAND_bytes(loopargs[i].buf, 36);
2399
2400 #ifndef OPENSSL_NO_DSA
2401     if (RAND_status() != 1) {
2402         RAND_seed(rnd_seed, sizeof rnd_seed);
2403     }
2404     for (testnum = 0; testnum < DSA_NUM; testnum++) {
2405         int st = 0;
2406         if (!dsa_doit[testnum])
2407             continue;
2408
2409         /* DSA_generate_key(dsa_key[testnum]); */
2410         /* DSA_sign_setup(dsa_key[testnum],NULL); */
2411         for (i = 0; i < loopargs_len; i++) {
2412             st = DSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2413                           &loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2414             if (st == 0)
2415                 break;
2416         }
2417         if (st == 0) {
2418             BIO_printf(bio_err,
2419                        "DSA sign failure.  No DSA sign will be done.\n");
2420             ERR_print_errors(bio_err);
2421             rsa_count = 1;
2422         } else {
2423             pkey_print_message("sign", "dsa",
2424                                dsa_c[testnum][0], dsa_bits[testnum], DSA_SECONDS);
2425             Time_F(START);
2426             count = run_benchmark(async_jobs, DSA_sign_loop, loopargs);
2427             d = Time_F(STOP);
2428             BIO_printf(bio_err,
2429                        mr ? "+R3:%ld:%d:%.2f\n"
2430                        : "%ld %d bit DSA signs in %.2fs\n",
2431                        count, dsa_bits[testnum], d);
2432             dsa_results[testnum][0] = d / (double)count;
2433             rsa_count = count;
2434         }
2435
2436         for (i = 0; i < loopargs_len; i++) {
2437             st = DSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2438                             loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2439             if (st <= 0)
2440                 break;
2441         }
2442         if (st <= 0) {
2443             BIO_printf(bio_err,
2444                        "DSA verify failure.  No DSA verify will be done.\n");
2445             ERR_print_errors(bio_err);
2446             dsa_doit[testnum] = 0;
2447         } else {
2448             pkey_print_message("verify", "dsa",
2449                                dsa_c[testnum][1], dsa_bits[testnum], DSA_SECONDS);
2450             Time_F(START);
2451             count = run_benchmark(async_jobs, DSA_verify_loop, loopargs);
2452             d = Time_F(STOP);
2453             BIO_printf(bio_err,
2454                        mr ? "+R4:%ld:%d:%.2f\n"
2455                        : "%ld %d bit DSA verify in %.2fs\n",
2456                        count, dsa_bits[testnum], d);
2457             dsa_results[testnum][1] = d / (double)count;
2458         }
2459
2460         if (rsa_count <= 1) {
2461             /* if longer than 10s, don't do any more */
2462             for (testnum++; testnum < DSA_NUM; testnum++)
2463                 dsa_doit[testnum] = 0;
2464         }
2465     }
2466 #endif                          /* OPENSSL_NO_DSA */
2467
2468 #ifndef OPENSSL_NO_EC
2469     if (RAND_status() != 1) {
2470         RAND_seed(rnd_seed, sizeof rnd_seed);
2471     }
2472     for (testnum = 0; testnum < EC_NUM; testnum++) {
2473         int st = 1;
2474
2475         if (!ecdsa_doit[testnum])
2476             continue;           /* Ignore Curve */
2477         for (i = 0; i < loopargs_len; i++) {
2478             loopargs[i].ecdsa[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2479             if (loopargs[i].ecdsa[testnum] == NULL) {
2480                 st = 0;
2481                 break;
2482             }
2483         }
2484         if (st == 0) {
2485             BIO_printf(bio_err, "ECDSA failure.\n");
2486             ERR_print_errors(bio_err);
2487             rsa_count = 1;
2488         } else {
2489             for (i = 0; i < loopargs_len; i++) {
2490                 EC_KEY_precompute_mult(loopargs[i].ecdsa[testnum], NULL);
2491                 /* Perform ECDSA signature test */
2492                 EC_KEY_generate_key(loopargs[i].ecdsa[testnum]);
2493                 st = ECDSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2494                                 &loopargs[i].siglen, loopargs[i].ecdsa[testnum]);
2495                 if (st == 0)
2496                     break;
2497             }
2498             if (st == 0) {
2499                 BIO_printf(bio_err,
2500                            "ECDSA sign failure.  No ECDSA sign will be done.\n");
2501                 ERR_print_errors(bio_err);
2502                 rsa_count = 1;
2503             } else {
2504                 pkey_print_message("sign", "ecdsa",
2505                                    ecdsa_c[testnum][0],
2506                                    test_curves_bits[testnum], ECDSA_SECONDS);
2507                 Time_F(START);
2508                 count = run_benchmark(async_jobs, ECDSA_sign_loop, loopargs);
2509                 d = Time_F(STOP);
2510
2511                 BIO_printf(bio_err,
2512                            mr ? "+R5:%ld:%d:%.2f\n" :
2513                            "%ld %d bit ECDSA signs in %.2fs \n",
2514                            count, test_curves_bits[testnum], d);
2515                 ecdsa_results[testnum][0] = d / (double)count;
2516                 rsa_count = count;
2517             }
2518
2519             /* Perform ECDSA verification test */
2520             for (i = 0; i < loopargs_len; i++) {
2521                 st = ECDSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2522                                   loopargs[i].siglen, loopargs[i].ecdsa[testnum]);
2523                 if (st != 1)
2524                     break;
2525             }
2526             if (st != 1) {
2527                 BIO_printf(bio_err,
2528                            "ECDSA verify failure.  No ECDSA verify will be done.\n");
2529                 ERR_print_errors(bio_err);
2530                 ecdsa_doit[testnum] = 0;
2531             } else {
2532                 pkey_print_message("verify", "ecdsa",
2533                                    ecdsa_c[testnum][1],
2534                                    test_curves_bits[testnum], ECDSA_SECONDS);
2535                 Time_F(START);
2536                 count = run_benchmark(async_jobs, ECDSA_verify_loop, loopargs);
2537                 d = Time_F(STOP);
2538                 BIO_printf(bio_err,
2539                            mr ? "+R6:%ld:%d:%.2f\n"
2540                            : "%ld %d bit ECDSA verify in %.2fs\n",
2541                            count, test_curves_bits[testnum], d);
2542                 ecdsa_results[testnum][1] = d / (double)count;
2543             }
2544
2545             if (rsa_count <= 1) {
2546                 /* if longer than 10s, don't do any more */
2547                 for (testnum++; testnum < EC_NUM; testnum++)
2548                     ecdsa_doit[testnum] = 0;
2549             }
2550         }
2551     }
2552
2553     if (RAND_status() != 1) {
2554         RAND_seed(rnd_seed, sizeof rnd_seed);
2555     }
2556     for (testnum = 0; testnum < EC_NUM; testnum++) {
2557         int ecdh_checks = 1;
2558
2559         if (!ecdh_doit[testnum])
2560             continue;
2561         for (i = 0; i < loopargs_len; i++) {
2562             loopargs[i].ecdh_a[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2563             loopargs[i].ecdh_b[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2564             if (loopargs[i].ecdh_a[testnum] == NULL ||
2565                 loopargs[i].ecdh_b[testnum] == NULL) {
2566                 ecdh_checks = 0;
2567                 break;
2568             }
2569         }
2570         if (ecdh_checks == 0) {
2571             BIO_printf(bio_err, "ECDH failure.\n");
2572             ERR_print_errors(bio_err);
2573             rsa_count = 1;
2574         } else {
2575             for (i = 0; i < loopargs_len; i++) {
2576                 /* generate two ECDH key pairs */
2577                 if (!EC_KEY_generate_key(loopargs[i].ecdh_a[testnum]) ||
2578                         !EC_KEY_generate_key(loopargs[i].ecdh_b[testnum])) {
2579                     BIO_printf(bio_err, "ECDH key generation failure.\n");
2580                     ERR_print_errors(bio_err);
2581                     ecdh_checks = 0;
2582                     rsa_count = 1;
2583                 } else {
2584                     int secret_size_a, secret_size_b;
2585                     /*
2586                      * If field size is not more than 24 octets, then use SHA-1
2587                      * hash of result; otherwise, use result (see section 4.8 of
2588                      * draft-ietf-tls-ecc-03.txt).
2589                      */
2590                     int field_size = EC_GROUP_get_degree(
2591                             EC_KEY_get0_group(loopargs[i].ecdh_a[testnum]));
2592
2593                     if (field_size <= 24 * 8) {                 /* 192 bits */
2594                         loopargs[i].outlen = KDF1_SHA1_len;
2595                         loopargs[i].kdf = KDF1_SHA1;
2596                     } else {
2597                         loopargs[i].outlen = (field_size + 7) / 8;
2598                         loopargs[i].kdf = NULL;
2599                     }
2600                     secret_size_a =
2601                         ECDH_compute_key(loopargs[i].secret_a, loopargs[i].outlen,
2602                                 EC_KEY_get0_public_key(loopargs[i].ecdh_b[testnum]),
2603                                 loopargs[i].ecdh_a[testnum], loopargs[i].kdf);
2604                     secret_size_b =
2605                         ECDH_compute_key(loopargs[i].secret_b, loopargs[i].outlen,
2606                                 EC_KEY_get0_public_key(loopargs[i].ecdh_a[testnum]),
2607                                 loopargs[i].ecdh_b[testnum], loopargs[i].kdf);
2608                     if (secret_size_a != secret_size_b)
2609                         ecdh_checks = 0;
2610                     else
2611                         ecdh_checks = 1;
2612
2613                     for (k = 0; k < secret_size_a && ecdh_checks == 1; k++) {
2614                         if (loopargs[i].secret_a[k] != loopargs[i].secret_b[k])
2615                             ecdh_checks = 0;
2616                     }
2617
2618                     if (ecdh_checks == 0) {
2619                         BIO_printf(bio_err, "ECDH computations don't match.\n");
2620                         ERR_print_errors(bio_err);
2621                         rsa_count = 1;
2622                         break;
2623                     }
2624                 }
2625             }
2626             if (ecdh_checks != 0) {
2627                 pkey_print_message("", "ecdh",
2628                         ecdh_c[testnum][0],
2629                         test_curves_bits[testnum], ECDH_SECONDS);
2630                 Time_F(START);
2631                 count = run_benchmark(async_jobs, ECDH_compute_key_loop, loopargs);
2632                 d = Time_F(STOP);
2633                 BIO_printf(bio_err,
2634                         mr ? "+R7:%ld:%d:%.2f\n" :
2635                         "%ld %d-bit ECDH ops in %.2fs\n", count,
2636                         test_curves_bits[testnum], d);
2637                 ecdh_results[testnum][0] = d / (double)count;
2638                 rsa_count = count;
2639             }
2640         }
2641
2642         if (rsa_count <= 1) {
2643             /* if longer than 10s, don't do any more */
2644             for (testnum++; testnum < EC_NUM; testnum++)
2645                 ecdh_doit[testnum] = 0;
2646         }
2647     }
2648 #endif                          /* OPENSSL_NO_EC */
2649 #ifndef NO_FORK
2650  show_res:
2651 #endif
2652     if (!mr) {
2653         printf("%s\n", OpenSSL_version(OPENSSL_VERSION));
2654         printf("%s\n", OpenSSL_version(OPENSSL_BUILT_ON));
2655         printf("options:");
2656         printf("%s ", BN_options());
2657 #ifndef OPENSSL_NO_MD2
2658         printf("%s ", MD2_options());
2659 #endif
2660 #ifndef OPENSSL_NO_RC4
2661         printf("%s ", RC4_options());
2662 #endif
2663 #ifndef OPENSSL_NO_DES
2664         printf("%s ", DES_options());
2665 #endif
2666         printf("%s ", AES_options());
2667 #ifndef OPENSSL_NO_IDEA
2668         printf("%s ", IDEA_options());
2669 #endif
2670 #ifndef OPENSSL_NO_BF
2671         printf("%s ", BF_options());
2672 #endif
2673         printf("\n%s\n", OpenSSL_version(OPENSSL_CFLAGS));
2674     }
2675
2676     if (pr_header) {
2677         if (mr)
2678             printf("+H");
2679         else {
2680             printf
2681                 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2682             printf("type        ");
2683         }
2684         for (testnum = 0; testnum < SIZE_NUM; testnum++)
2685             printf(mr ? ":%d" : "%7d bytes", lengths[testnum]);
2686         printf("\n");
2687     }
2688
2689     for (k = 0; k < ALGOR_NUM; k++) {
2690         if (!doit[k])
2691             continue;
2692         if (mr)
2693             printf("+F:%d:%s", k, names[k]);
2694         else
2695             printf("%-13s", names[k]);
2696         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2697             if (results[k][testnum] > 10000 && !mr)
2698                 printf(" %11.2fk", results[k][testnum] / 1e3);
2699             else
2700                 printf(mr ? ":%.2f" : " %11.2f ", results[k][testnum]);
2701         }
2702         printf("\n");
2703     }
2704 #ifndef OPENSSL_NO_RSA
2705     testnum = 1;
2706     for (k = 0; k < RSA_NUM; k++) {
2707         if (!rsa_doit[k])
2708             continue;
2709         if (testnum && !mr) {
2710             printf("%18ssign    verify    sign/s verify/s\n", " ");
2711             testnum = 0;
2712         }
2713         if (mr)
2714             printf("+F2:%u:%u:%f:%f\n",
2715                    k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2716         else
2717             printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2718                    rsa_bits[k], rsa_results[k][0], rsa_results[k][1],
2719                    1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]);
2720     }
2721 #endif
2722 #ifndef OPENSSL_NO_DSA
2723     testnum = 1;
2724     for (k = 0; k < DSA_NUM; k++) {
2725         if (!dsa_doit[k])
2726             continue;
2727         if (testnum && !mr) {
2728             printf("%18ssign    verify    sign/s verify/s\n", " ");
2729             testnum = 0;
2730         }
2731         if (mr)
2732             printf("+F3:%u:%u:%f:%f\n",
2733                    k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2734         else
2735             printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2736                    dsa_bits[k], dsa_results[k][0], dsa_results[k][1],
2737                    1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]);
2738     }
2739 #endif
2740 #ifndef OPENSSL_NO_EC
2741     testnum = 1;
2742     for (k = 0; k < EC_NUM; k++) {
2743         if (!ecdsa_doit[k])
2744             continue;
2745         if (testnum && !mr) {
2746             printf("%30ssign    verify    sign/s verify/s\n", " ");
2747             testnum = 0;
2748         }
2749
2750         if (mr)
2751             printf("+F4:%u:%u:%f:%f\n",
2752                    k, test_curves_bits[k],
2753                    ecdsa_results[k][0], ecdsa_results[k][1]);
2754         else
2755             printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2756                    test_curves_bits[k],
2757                    test_curves_names[k],
2758                    ecdsa_results[k][0], ecdsa_results[k][1],
2759                    1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
2760     }
2761
2762     testnum = 1;
2763     for (k = 0; k < EC_NUM; k++) {
2764         if (!ecdh_doit[k])
2765             continue;
2766         if (testnum && !mr) {
2767             printf("%30sop      op/s\n", " ");
2768             testnum = 0;
2769         }
2770         if (mr)
2771             printf("+F5:%u:%u:%f:%f\n",
2772                    k, test_curves_bits[k],
2773                    ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2774
2775         else
2776             printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2777                    test_curves_bits[k],
2778                    test_curves_names[k],
2779                    ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2780     }
2781 #endif
2782
2783     ret = 0;
2784
2785  end:
2786     ERR_print_errors(bio_err);
2787     for (i = 0; i < loopargs_len; i++) {
2788         OPENSSL_free(loopargs[i].buf_malloc);
2789         OPENSSL_free(loopargs[i].buf2_malloc);
2790
2791 #ifndef OPENSSL_NO_RSA
2792         for (k = 0; k < RSA_NUM; k++)
2793             RSA_free(loopargs[i].rsa_key[k]);
2794 #endif
2795 #ifndef OPENSSL_NO_DSA
2796         for (k = 0; k < DSA_NUM; k++)
2797             DSA_free(loopargs[i].dsa_key[k]);
2798 #endif
2799 #ifndef OPENSSL_NO_EC
2800         for (k = 0; k < EC_NUM; k++) {
2801             EC_KEY_free(loopargs[i].ecdsa[k]);
2802             EC_KEY_free(loopargs[i].ecdh_a[k]);
2803             EC_KEY_free(loopargs[i].ecdh_b[k]);
2804         }
2805         OPENSSL_free(loopargs[i].secret_a);
2806         OPENSSL_free(loopargs[i].secret_b);
2807 #endif
2808     }
2809
2810     if (async_jobs > 0) {
2811         for (i = 0; i < loopargs_len; i++)
2812             ASYNC_WAIT_CTX_free(loopargs[i].wait_ctx);
2813     }
2814
2815     if (async_init) {
2816         ASYNC_cleanup_thread();
2817     }
2818     OPENSSL_free(loopargs);
2819     release_engine(e);
2820     return (ret);
2821 }
2822
2823 static void print_message(const char *s, long num, int length)
2824 {
2825 #ifdef SIGALRM
2826     BIO_printf(bio_err,
2827                mr ? "+DT:%s:%d:%d\n"
2828                : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length);
2829     (void)BIO_flush(bio_err);
2830     alarm(SECONDS);
2831 #else
2832     BIO_printf(bio_err,
2833                mr ? "+DN:%s:%ld:%d\n"
2834                : "Doing %s %ld times on %d size blocks: ", s, num, length);
2835     (void)BIO_flush(bio_err);
2836 #endif
2837 }
2838
2839 static void pkey_print_message(const char *str, const char *str2, long num,
2840                                int bits, int tm)
2841 {
2842 #ifdef SIGALRM
2843     BIO_printf(bio_err,
2844                mr ? "+DTP:%d:%s:%s:%d\n"
2845                : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
2846     (void)BIO_flush(bio_err);
2847     alarm(tm);
2848 #else
2849     BIO_printf(bio_err,
2850                mr ? "+DNP:%ld:%d:%s:%s\n"
2851                : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
2852     (void)BIO_flush(bio_err);
2853 #endif
2854 }
2855
2856 static void print_result(int alg, int run_no, int count, double time_used)
2857 {
2858     if (count == -1) {
2859         BIO_puts(bio_err, "EVP error!\n");
2860         exit(1);
2861     }
2862     BIO_printf(bio_err,
2863                mr ? "+R:%d:%s:%f\n"
2864                : "%d %s's in %.2fs\n", count, names[alg], time_used);
2865     results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
2866 }
2867
2868 #ifndef NO_FORK
2869 static char *sstrsep(char **string, const char *delim)
2870 {
2871     char isdelim[256];
2872     char *token = *string;
2873
2874     if (**string == 0)
2875         return NULL;
2876
2877     memset(isdelim, 0, sizeof isdelim);
2878     isdelim[0] = 1;
2879
2880     while (*delim) {
2881         isdelim[(unsigned char)(*delim)] = 1;
2882         delim++;
2883     }
2884
2885     while (!isdelim[(unsigned char)(**string)]) {
2886         (*string)++;
2887     }
2888
2889     if (**string) {
2890         **string = 0;
2891         (*string)++;
2892     }
2893
2894     return token;
2895 }
2896
2897 static int do_multi(int multi)
2898 {
2899     int n;
2900     int fd[2];
2901     int *fds;
2902     static char sep[] = ":";
2903
2904     fds = malloc(sizeof(*fds) * multi);
2905     for (n = 0; n < multi; ++n) {
2906         if (pipe(fd) == -1) {
2907             BIO_printf(bio_err, "pipe failure\n");
2908             exit(1);
2909         }
2910         fflush(stdout);
2911         (void)BIO_flush(bio_err);
2912         if (fork()) {
2913             close(fd[1]);
2914             fds[n] = fd[0];
2915         } else {
2916             close(fd[0]);
2917             close(1);
2918             if (dup(fd[1]) == -1) {
2919                 BIO_printf(bio_err, "dup failed\n");
2920                 exit(1);
2921             }
2922             close(fd[1]);
2923             mr = 1;
2924             usertime = 0;
2925             free(fds);
2926             return 0;
2927         }
2928         printf("Forked child %d\n", n);
2929     }
2930
2931     /* for now, assume the pipe is long enough to take all the output */
2932     for (n = 0; n < multi; ++n) {
2933         FILE *f;
2934         char buf[1024];
2935         char *p;
2936
2937         f = fdopen(fds[n], "r");
2938         while (fgets(buf, sizeof buf, f)) {
2939             p = strchr(buf, '\n');
2940             if (p)
2941                 *p = '\0';
2942             if (buf[0] != '+') {
2943                 BIO_printf(bio_err, "Don't understand line '%s' from child %d\n",
2944                         buf, n);
2945                 continue;
2946             }
2947             printf("Got: %s from %d\n", buf, n);
2948             if (strncmp(buf, "+F:", 3) == 0) {
2949                 int alg;
2950                 int j;
2951
2952                 p = buf + 3;
2953                 alg = atoi(sstrsep(&p, sep));
2954                 sstrsep(&p, sep);
2955                 for (j = 0; j < SIZE_NUM; ++j)
2956                     results[alg][j] += atof(sstrsep(&p, sep));
2957             } else if (strncmp(buf, "+F2:", 4) == 0) {
2958                 int k;
2959                 double d;
2960
2961                 p = buf + 4;
2962                 k = atoi(sstrsep(&p, sep));
2963                 sstrsep(&p, sep);
2964
2965                 d = atof(sstrsep(&p, sep));
2966                 if (n)
2967                     rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
2968                 else
2969                     rsa_results[k][0] = d;
2970
2971                 d = atof(sstrsep(&p, sep));
2972                 if (n)
2973                     rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
2974                 else
2975                     rsa_results[k][1] = d;
2976             }
2977 # ifndef OPENSSL_NO_DSA
2978             else if (strncmp(buf, "+F3:", 4) == 0) {
2979                 int k;
2980                 double d;
2981
2982                 p = buf + 4;
2983                 k = atoi(sstrsep(&p, sep));
2984                 sstrsep(&p, sep);
2985
2986                 d = atof(sstrsep(&p, sep));
2987                 if (n)
2988                     dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d);
2989                 else
2990                     dsa_results[k][0] = d;
2991
2992                 d = atof(sstrsep(&p, sep));
2993                 if (n)
2994                     dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d);
2995                 else
2996                     dsa_results[k][1] = d;
2997             }
2998 # endif
2999 # ifndef OPENSSL_NO_EC
3000             else if (strncmp(buf, "+F4:", 4) == 0) {
3001                 int k;
3002                 double d;
3003
3004                 p = buf + 4;
3005                 k = atoi(sstrsep(&p, sep));
3006                 sstrsep(&p, sep);
3007
3008                 d = atof(sstrsep(&p, sep));
3009                 if (n)
3010                     ecdsa_results[k][0] =
3011                         1 / (1 / ecdsa_results[k][0] + 1 / d);
3012                 else
3013                     ecdsa_results[k][0] = d;
3014
3015                 d = atof(sstrsep(&p, sep));
3016                 if (n)
3017                     ecdsa_results[k][1] =
3018                         1 / (1 / ecdsa_results[k][1] + 1 / d);
3019                 else
3020                     ecdsa_results[k][1] = d;
3021             } else if (strncmp(buf, "+F5:", 4) == 0) {
3022                 int k;
3023                 double d;
3024
3025                 p = buf + 4;
3026                 k = atoi(sstrsep(&p, sep));
3027                 sstrsep(&p, sep);
3028
3029                 d = atof(sstrsep(&p, sep));
3030                 if (n)
3031                     ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
3032                 else
3033                     ecdh_results[k][0] = d;
3034
3035             }
3036 # endif
3037
3038             else if (strncmp(buf, "+H:", 3) == 0) {
3039                 ;
3040             } else
3041                 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf, n);
3042         }
3043
3044         fclose(f);
3045     }
3046     free(fds);
3047     return 1;
3048 }
3049 #endif
3050
3051 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
3052 {
3053     static int mblengths[] =
3054         { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
3055     int j, count, num = OSSL_NELEM(mblengths);
3056     const char *alg_name;
3057     unsigned char *inp, *out, no_key[32], no_iv[16];
3058     EVP_CIPHER_CTX *ctx;
3059     double d = 0.0;
3060
3061     inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
3062     out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
3063     ctx = EVP_CIPHER_CTX_new();
3064     EVP_EncryptInit_ex(ctx, evp_cipher, NULL, no_key, no_iv);
3065     EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key),
3066                         no_key);
3067     alg_name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
3068
3069     for (j = 0; j < num; j++) {
3070         print_message(alg_name, 0, mblengths[j]);
3071         Time_F(START);
3072         for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
3073             unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
3074             EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
3075             size_t len = mblengths[j];
3076             int packlen;
3077
3078             memset(aad, 0, 8);  /* avoid uninitialized values */
3079             aad[8] = 23;        /* SSL3_RT_APPLICATION_DATA */
3080             aad[9] = 3;         /* version */
3081             aad[10] = 2;
3082             aad[11] = 0;        /* length */
3083             aad[12] = 0;
3084             mb_param.out = NULL;
3085             mb_param.inp = aad;
3086             mb_param.len = len;
3087             mb_param.interleave = 8;
3088
3089             packlen = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
3090                                           sizeof(mb_param), &mb_param);
3091
3092             if (packlen > 0) {
3093                 mb_param.out = out;
3094                 mb_param.inp = inp;
3095                 mb_param.len = len;
3096                 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
3097                                     sizeof(mb_param), &mb_param);
3098             } else {
3099                 int pad;
3100
3101                 RAND_bytes(out, 16);
3102                 len += 16;
3103                 aad[11] = len >> 8;
3104                 aad[12] = len;
3105                 pad = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_TLS1_AAD,
3106                                           EVP_AEAD_TLS1_AAD_LEN, aad);
3107                 EVP_Cipher(ctx, out, inp, len + pad);
3108             }
3109         }
3110         d = Time_F(STOP);
3111         BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
3112                    : "%d %s's in %.2fs\n", count, "evp", d);
3113         results[D_EVP][j] = ((double)count) / d * mblengths[j];
3114     }
3115
3116     if (mr) {
3117         fprintf(stdout, "+H");
3118         for (j = 0; j < num; j++)
3119             fprintf(stdout, ":%d", mblengths[j]);
3120         fprintf(stdout, "\n");
3121         fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
3122         for (j = 0; j < num; j++)
3123             fprintf(stdout, ":%.2f", results[D_EVP][j]);
3124         fprintf(stdout, "\n");
3125     } else {
3126         fprintf(stdout,
3127                 "The 'numbers' are in 1000s of bytes per second processed.\n");
3128         fprintf(stdout, "type                    ");
3129         for (j = 0; j < num; j++)
3130             fprintf(stdout, "%7d bytes", mblengths[j]);
3131         fprintf(stdout, "\n");
3132         fprintf(stdout, "%-24s", alg_name);
3133
3134         for (j = 0; j < num; j++) {
3135             if (results[D_EVP][j] > 10000)
3136                 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
3137             else
3138                 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
3139         }
3140         fprintf(stdout, "\n");
3141     }
3142
3143     OPENSSL_free(inp);
3144     OPENSSL_free(out);
3145     EVP_CIPHER_CTX_free(ctx);
3146 }