apps/speed.c

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