apps/speed.c

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