apps/speed.c

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