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