apps/speed.c

   1 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   2  * All rights reserved.
   3  *
   4  * This package is an SSL implementation written
   5  * by Eric Young (eay@cryptsoft.com).
   6  * The implementation was written so as to conform with Netscapes SSL.
   7  *
   8  * This library is free for commercial and non-commercial use as long as
   9  * the following conditions are aheared to.  The following conditions
  10  * apply to all code found in this distribution, be it the RC4, RSA,
  11  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  12  * included with this distribution is covered by the same copyright terms
  13  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  14  *
  15  * Copyright remains Eric Young's, and as such any Copyright notices in
  16  * the code are not to be removed.
  17  * If this package is used in a product, Eric Young should be given attribution
  18  * as the author of the parts of the library used.
  19  * This can be in the form of a textual message at program startup or
  20  * in documentation (online or textual) provided with the package.
  21  *
  22  * Redistribution and use in source and binary forms, with or without
  23  * modification, are permitted provided that the following conditions
  24  * are met:
  25  * 1. Redistributions of source code must retain the copyright
  26  *    notice, this list of conditions and the following disclaimer.
  27  * 2. Redistributions in binary form must reproduce the above copyright
  28  *    notice, this list of conditions and the following disclaimer in the
  29  *    documentation and/or other materials provided with the distribution.
  30  * 3. All advertising materials mentioning features or use of this software
  31  *    must display the following acknowledgement:
  32  *    "This product includes cryptographic software written by
  33  *     Eric Young (eay@cryptsoft.com)"
  34  *    The word 'cryptographic' can be left out if the rouines from the library
  35  *    being used are not cryptographic related :-).
  36  * 4. If you include any Windows specific code (or a derivative thereof) from
  37  *    the apps directory (application code) you must include an acknowledgement:
  38  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  39  *
  40  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  41  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  43  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  44  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  45  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  46  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  48  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  49  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  50  * SUCH DAMAGE.
  51  *
  52  * The licence and distribution terms for any publically available version or
  53  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  54  * copied and put under another distribution licence
  55  * [including the GNU Public Licence.]
  56  */
  57 /* ====================================================================
  58  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
  59  *
  60  * Portions of the attached software ("Contribution") are developed by
  61  * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
  62  *
  63  * The Contribution is licensed pursuant to the OpenSSL open source
  64  * license provided above.
  65  *
  66  * The ECDH and ECDSA speed test software is originally written by
  67  * Sumit Gupta of Sun Microsystems Laboratories.
  68  *
  69  */
  70
  71 #undef SECONDS
  72 #define SECONDS                 3
  73 #define PRIME_SECONDS   10
  74 #define RSA_SECONDS             10
  75 #define DSA_SECONDS             10
  76 #define ECDSA_SECONDS   10
  77 #define ECDH_SECONDS    10
  78
  79 #include <stdio.h>
  80 #include <stdlib.h>
  81 #include <string.h>
  82 #include <math.h>
  83 #include "apps.h"
  84 #include <openssl/crypto.h>
  85 #include <openssl/rand.h>
  86 #include <openssl/err.h>
  87 #include <openssl/evp.h>
  88 #include <openssl/objects.h>
  89 #if !defined(OPENSSL_SYS_MSDOS)
  90 # include OPENSSL_UNISTD
  91 #endif
  92
  93 #ifndef OPENSSL_SYS_NETWARE
  94 # include <signal.h>
  95 #endif
  96
  97 #if defined(_WIN32)
  98 # include <windows.h>
  99 #endif
 100
 101 #include <openssl/bn.h>
 102 #ifndef OPENSSL_NO_DES
 103 # include <openssl/des.h>
 104 #endif
 105 #ifndef OPENSSL_NO_AES
 106 # include <openssl/aes.h>
 107 #endif
 108 #ifndef OPENSSL_NO_CAMELLIA
 109 # include <openssl/camellia.h>
 110 #endif
 111 #ifndef OPENSSL_NO_MD2
 112 # include <openssl/md2.h>
 113 #endif
 114 #ifndef OPENSSL_NO_MDC2
 115 # include <openssl/mdc2.h>
 116 #endif
 117 #ifndef OPENSSL_NO_MD4
 118 # include <openssl/md4.h>
 119 #endif
 120 #ifndef OPENSSL_NO_MD5
 121 # include <openssl/md5.h>
 122 #endif
 123 #include <openssl/hmac.h>
 124 #include <openssl/sha.h>
 125 #ifndef OPENSSL_NO_RMD160
 126 # include <openssl/ripemd.h>
 127 #endif
 128 #ifndef OPENSSL_NO_WHIRLPOOL
 129 # include <openssl/whrlpool.h>
 130 #endif
 131 #ifndef OPENSSL_NO_RC4
 132 # include <openssl/rc4.h>
 133 #endif
 134 #ifndef OPENSSL_NO_RC5
 135 # include <openssl/rc5.h>
 136 #endif
 137 #ifndef OPENSSL_NO_RC2
 138 # include <openssl/rc2.h>
 139 #endif
 140 #ifndef OPENSSL_NO_IDEA
 141 # include <openssl/idea.h>
 142 #endif
 143 #ifndef OPENSSL_NO_SEED
 144 # include <openssl/seed.h>
 145 #endif
 146 #ifndef OPENSSL_NO_BF
 147 # include <openssl/blowfish.h>
 148 #endif
 149 #ifndef OPENSSL_NO_CAST
 150 # include <openssl/cast.h>
 151 #endif
 152 #ifndef OPENSSL_NO_RSA
 153 # include <openssl/rsa.h>
 154 # include "./testrsa.h"
 155 #endif
 156 #include <openssl/x509.h>
 157 #ifndef OPENSSL_NO_DSA
 158 # include <openssl/dsa.h>
 159 # include "./testdsa.h"
 160 #endif
 161 #ifndef OPENSSL_NO_EC
 162 # include <openssl/ec.h>
 163 #endif
 164 #include <openssl/modes.h>
 165
 166 #ifndef HAVE_FORK
 167 # if defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_OS2) || defined(OPENSSL_SYS_NETWARE)
 168 #  define HAVE_FORK 0
 169 # else
 170 #  define HAVE_FORK 1
 171 # endif
 172 #endif
 173
 174 #if HAVE_FORK
 175 # undef NO_FORK
 176 #else
 177 # define NO_FORK
 178 #endif
 179
 180 #undef BUFSIZE
 181 #define BUFSIZE (1024*8+1)
 182 #define MAX_MISALIGNMENT 63
 183
 184 static volatile int run = 0;
 185
 186 static int mr = 0;
 187 static int usertime = 1;
 188
 189 static double Time_F(int s);
 190 static void print_message(const char *s, long num, int length);
 191 static void pkey_print_message(const char *str, const char *str2,
 192                                long num, int bits, int sec);
 193 static void print_result(int alg, int run_no, int count, double time_used);
 194 #ifndef NO_FORK
 195 static int do_multi(int multi);
 196 #endif
 197
 198 #define ALGOR_NUM       30
 199 #define SIZE_NUM        5
 200 #define PRIME_NUM       3
 201 #define RSA_NUM         7
 202 #define DSA_NUM         3
 203
 204 #define EC_NUM       16
 205 #define MAX_ECDH_SIZE 256
 206 #define MISALIGN        64
 207
 208 static const char *names[ALGOR_NUM] = {
 209     "md2", "mdc2", "md4", "md5", "hmac(md5)", "sha1", "rmd160", "rc4",
 210     "des cbc", "des ede3", "idea cbc", "seed cbc",
 211     "rc2 cbc", "rc5-32/12 cbc", "blowfish cbc", "cast cbc",
 212     "aes-128 cbc", "aes-192 cbc", "aes-256 cbc",
 213     "camellia-128 cbc", "camellia-192 cbc", "camellia-256 cbc",
 214     "evp", "sha256", "sha512", "whirlpool",
 215     "aes-128 ige", "aes-192 ige", "aes-256 ige", "ghash"
 216 };
 217
 218 static double results[ALGOR_NUM][SIZE_NUM];
 219 static int lengths[SIZE_NUM] = {
 220     16, 64, 256, 1024, 8 * 1024
 221 };
 222
 223 #ifndef OPENSSL_NO_RSA
 224 static double rsa_results[RSA_NUM][2];
 225 #endif
 226 #ifndef OPENSSL_NO_DSA
 227 static double dsa_results[DSA_NUM][2];
 228 #endif
 229 #ifndef OPENSSL_NO_EC
 230 static double ecdsa_results[EC_NUM][2];
 231 static double ecdh_results[EC_NUM][1];
 232 #endif
 233
 234 #if defined(OPENSSL_NO_DSA) && !defined(OPENSSL_NO_EC)
 235 static const char rnd_seed[] =
 236     "string to make the random number generator think it has entropy";
 237 static int rnd_fake = 0;
 238 #endif
 239
 240 #ifdef SIGALRM
 241 # if defined(__STDC__) || defined(sgi) || defined(_AIX)
 242 #  define SIGRETTYPE void
 243 # else
 244 #  define SIGRETTYPE int
 245 # endif
 246
 247 static SIGRETTYPE sig_done(int sig);
 248 static SIGRETTYPE sig_done(int sig)
 249 {
 250     signal(SIGALRM, sig_done);
 251     run = 0;
 252 }
 253 #endif
 254
 255 #define START   0
 256 #define STOP    1
 257
 258 #if defined(_WIN32)
 259
 260 # if !defined(SIGALRM)
 261 #  define SIGALRM
 262 # endif
 263 static unsigned int lapse, schlock;
 264 static void alarm_win32(unsigned int secs)
 265 {
 266     lapse = secs * 1000;
 267 }
 268
 269 # define alarm alarm_win32
 270
 271 static DWORD WINAPI sleepy(VOID * arg)
 272 {
 273     schlock = 1;
 274     Sleep(lapse);
 275     run = 0;
 276     return 0;
 277 }
 278
 279 static double Time_F(int s)
 280 {
 281     double ret;
 282     static HANDLE thr;
 283
 284     if (s == START) {
 285         schlock = 0;
 286         thr = CreateThread(NULL, 4096, sleepy, NULL, 0, NULL);
 287         if (thr == NULL) {
 288             DWORD err = GetLastError();
 289             BIO_printf(bio_err, "unable to CreateThread (%lu)", err);
 290             ExitProcess(err);
 291         }
 292         while (!schlock)
 293             Sleep(0);           /* scheduler spinlock */
 294         ret = app_tminterval(s, usertime);
 295     } else {
 296         ret = app_tminterval(s, usertime);
 297         if (run)
 298             TerminateThread(thr, 0);
 299         CloseHandle(thr);
 300     }
 301
 302     return ret;
 303 }
 304 #else
 305
 306 static double Time_F(int s)
 307 {
 308     double ret = app_tminterval(s, usertime);
 309     if (s == STOP)
 310         alarm(0);
 311     return ret;
 312 }
 313 #endif
 314
 315 #ifndef OPENSSL_NO_EC
 316 static const int KDF1_SHA1_len = 20;
 317 static void *KDF1_SHA1(const void *in, size_t inlen, void *out,
 318                        size_t *outlen)
 319 {
 320     if (*outlen < SHA_DIGEST_LENGTH)
 321         return NULL;
 322     *outlen = SHA_DIGEST_LENGTH;
 323     return SHA1(in, inlen, out);
 324 }
 325 #endif                         /* OPENSSL_NO_EC */
 326
 327 static void multiblock_speed(const EVP_CIPHER *evp_cipher);
 328
 329 static int found(const char *name, const OPT_PAIR * pairs, int *result)
 330 {
 331     for (; pairs->name; pairs++)
 332         if (strcmp(name, pairs->name) == 0) {
 333             *result = pairs->retval;
 334             return 1;
 335         }
 336     return 0;
 337 }
 338
 339 typedef enum OPTION_choice {
 340     OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
 341     OPT_ELAPSED, OPT_EVP, OPT_DECRYPT, OPT_ENGINE, OPT_MULTI,
 342     OPT_MR, OPT_MB, OPT_MISALIGN
 343 } OPTION_CHOICE;
 344
 345 OPTIONS speed_options[] = {
 346     {OPT_HELP_STR, 1, '-', "Usage: %s [options] ciphers...\n"},
 347     {OPT_HELP_STR, 1, '-', "Valid options are:\n"},
 348     {"help", OPT_HELP, '-', "Display this summary"},
 349     {"evp", OPT_EVP, 's', "Use specified EVP cipher"},
 350     {"decrypt", OPT_DECRYPT, '-',
 351      "Time decryption instead of encryption (only EVP)"},
 352     {"mr", OPT_MR, '-', "Produce machine readable output"},
 353     {"mb", OPT_MB, '-'},
 354     {"misalign", OPT_MISALIGN, 'n', "Amount to mis-align buffers"},
 355     {"elapsed", OPT_ELAPSED, '-',
 356      "Measure time in real time instead of CPU user time"},
 357 #ifndef NO_FORK
 358     {"multi", OPT_MULTI, 'p', "Run benchmarks in parallel"},
 359 #endif
 360 #ifndef OPENSSL_NO_ENGINE
 361     {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
 362 #endif
 363     {NULL},
 364 };
 365
 366 #define D_MD2           0
 367 #define D_MDC2          1
 368 #define D_MD4           2
 369 #define D_MD5           3
 370 #define D_HMAC          4
 371 #define D_SHA1          5
 372 #define D_RMD160        6
 373 #define D_RC4           7
 374 #define D_CBC_DES       8
 375 #define D_EDE3_DES      9
 376 #define D_CBC_IDEA      10
 377 #define D_CBC_SEED      11
 378 #define D_CBC_RC2       12
 379 #define D_CBC_RC5       13
 380 #define D_CBC_BF        14
 381 #define D_CBC_CAST      15
 382 #define D_CBC_128_AES   16
 383 #define D_CBC_192_AES   17
 384 #define D_CBC_256_AES   18
 385 #define D_CBC_128_CML   19
 386 #define D_CBC_192_CML   20
 387 #define D_CBC_256_CML   21
 388 #define D_EVP           22
 389 #define D_SHA256        23
 390 #define D_SHA512        24
 391 #define D_WHIRLPOOL     25
 392 #define D_IGE_128_AES   26
 393 #define D_IGE_192_AES   27
 394 #define D_IGE_256_AES   28
 395 #define D_GHASH         29
 396 static OPT_PAIR doit_choices[] = {
 397 #ifndef OPENSSL_NO_MD2
 398     {"md2", D_MD2},
 399 #endif
 400 #ifndef OPENSSL_NO_MDC2
 401     {"mdc2", D_MDC2},
 402 #endif
 403 #ifndef OPENSSL_NO_MD4
 404     {"md4", D_MD4},
 405 #endif
 406 #ifndef OPENSSL_NO_MD5
 407     {"md5", D_MD5},
 408 #endif
 409 #ifndef OPENSSL_NO_MD5
 410     {"hmac", D_HMAC},
 411 #endif
 412     {"sha1", D_SHA1},
 413     {"sha256", D_SHA256},
 414     {"sha512", D_SHA512},
 415 #ifndef OPENSSL_NO_WHIRLPOOL
 416     {"whirlpool", D_WHIRLPOOL},
 417 #endif
 418 #ifndef OPENSSL_NO_RMD160
 419     {"ripemd", D_RMD160},
 420     {"rmd160", D_RMD160},
 421     {"ripemd160", D_RMD160},
 422 #endif
 423 #ifndef OPENSSL_NO_RC4
 424     {"rc4", D_RC4},
 425 #endif
 426 #ifndef OPENSSL_NO_DES
 427     {"des-cbc", D_CBC_DES},
 428     {"des-ede3", D_EDE3_DES},
 429 #endif
 430 #ifndef OPENSSL_NO_AES
 431     {"aes-128-cbc", D_CBC_128_AES},
 432     {"aes-192-cbc", D_CBC_192_AES},
 433     {"aes-256-cbc", D_CBC_256_AES},
 434     {"aes-128-ige", D_IGE_128_AES},
 435     {"aes-192-ige", D_IGE_192_AES},
 436     {"aes-256-ige", D_IGE_256_AES},
 437 #endif
 438 #ifndef OPENSSL_NO_RC2
 439     {"rc2-cbc", D_CBC_RC2},
 440     {"rc2", D_CBC_RC2},
 441 #endif
 442 #ifndef OPENSSL_NO_RC5
 443     {"rc5-cbc", D_CBC_RC5},
 444     {"rc5", D_CBC_RC5},
 445 #endif
 446 #ifndef OPENSSL_NO_IDEA
 447     {"idea-cbc", D_CBC_IDEA},
 448     {"idea", D_CBC_IDEA},
 449 #endif
 450 #ifndef OPENSSL_NO_SEED
 451     {"seed-cbc", D_CBC_SEED},
 452     {"seed", D_CBC_SEED},
 453 #endif
 454 #ifndef OPENSSL_NO_BF
 455     {"bf-cbc", D_CBC_BF},
 456     {"blowfish", D_CBC_BF},
 457     {"bf", D_CBC_BF},
 458 #endif
 459 #ifndef OPENSSL_NO_CAST
 460     {"cast-cbc", D_CBC_CAST},
 461     {"cast", D_CBC_CAST},
 462     {"cast5", D_CBC_CAST},
 463 #endif
 464     {"ghash", D_GHASH},
 465     {NULL}
 466 };
 467
 468 #define R_DSA_512       0
 469 #define R_DSA_1024      1
 470 #define R_DSA_2048      2
 471 static OPT_PAIR dsa_choices[] = {
 472     {"dsa512", R_DSA_512},
 473     {"dsa1024", R_DSA_1024},
 474     {"dsa2048", R_DSA_2048},
 475     {NULL},
 476 };
 477
 478 #define R_RSA_512       0
 479 #define R_RSA_1024      1
 480 #define R_RSA_2048      2
 481 #define R_RSA_3072      3
 482 #define R_RSA_4096      4
 483 #define R_RSA_7680      5
 484 #define R_RSA_15360     6
 485 static OPT_PAIR rsa_choices[] = {
 486     {"rsa512", R_RSA_512},
 487     {"rsa1024", R_RSA_1024},
 488     {"rsa2048", R_RSA_2048},
 489     {"rsa3072", R_RSA_3072},
 490     {"rsa4096", R_RSA_4096},
 491     {"rsa7680", R_RSA_7680},
 492     {"rsa15360", R_RSA_15360},
 493     {NULL}
 494 };
 495
 496 #define R_EC_P160    0
 497 #define R_EC_P192    1
 498 #define R_EC_P224    2
 499 #define R_EC_P256    3
 500 #define R_EC_P384    4
 501 #define R_EC_P521    5
 502 #define R_EC_K163    6
 503 #define R_EC_K233    7
 504 #define R_EC_K283    8
 505 #define R_EC_K409    9
 506 #define R_EC_K571    10
 507 #define R_EC_B163    11
 508 #define R_EC_B233    12
 509 #define R_EC_B283    13
 510 #define R_EC_B409    14
 511 #define R_EC_B571    15
 512 #ifndef OPENSSL_NO_EC
 513 static OPT_PAIR ecdsa_choices[] = {
 514     {"ecdsap160", R_EC_P160},
 515     {"ecdsap192", R_EC_P192},
 516     {"ecdsap224", R_EC_P224},
 517     {"ecdsap256", R_EC_P256},
 518     {"ecdsap384", R_EC_P384},
 519     {"ecdsap521", R_EC_P521},
 520     {"ecdsak163", R_EC_K163},
 521     {"ecdsak233", R_EC_K233},
 522     {"ecdsak283", R_EC_K283},
 523     {"ecdsak409", R_EC_K409},
 524     {"ecdsak571", R_EC_K571},
 525     {"ecdsab163", R_EC_B163},
 526     {"ecdsab233", R_EC_B233},
 527     {"ecdsab283", R_EC_B283},
 528     {"ecdsab409", R_EC_B409},
 529     {"ecdsab571", R_EC_B571},
 530     {NULL}
 531 };
 532 static OPT_PAIR ecdh_choices[] = {
 533     {"ecdhp160", R_EC_P160},
 534     {"ecdhp192", R_EC_P192},
 535     {"ecdhp224", R_EC_P224},
 536     {"ecdhp256", R_EC_P256},
 537     {"ecdhp384", R_EC_P384},
 538     {"ecdhp521", R_EC_P521},
 539     {"ecdhk163", R_EC_K163},
 540     {"ecdhk233", R_EC_K233},
 541     {"ecdhk283", R_EC_K283},
 542     {"ecdhk409", R_EC_K409},
 543     {"ecdhk571", R_EC_K571},
 544     {"ecdhb163", R_EC_B163},
 545     {"ecdhb233", R_EC_B233},
 546     {"ecdhb283", R_EC_B283},
 547     {"ecdhb409", R_EC_B409},
 548     {"ecdhb571", R_EC_B571},
 549     {NULL}
 550 };
 551 #endif
 552
 553 int speed_main(int argc, char **argv)
 554 {
 555     char *prog;
 556     const EVP_CIPHER *evp_cipher = NULL;
 557     const EVP_MD *evp_md = NULL;
 558     double d = 0.0;
 559     OPTION_CHOICE o;
 560     int decrypt = 0, multiblock = 0, doit[ALGOR_NUM], pr_header = 0;
 561     int dsa_doit[DSA_NUM], rsa_doit[RSA_NUM];
 562     int ret = 1, i, j, k, misalign = MAX_MISALIGNMENT + 1;
 563     long c[ALGOR_NUM][SIZE_NUM], count = 0, save_count = 0;
 564     unsigned char *buf_malloc = NULL, *buf2_malloc = NULL;
 565     unsigned char *buf = NULL, *buf2 = NULL;
 566     unsigned char md[EVP_MAX_MD_SIZE];
 567 #ifndef NO_FORK
 568     int multi = 0;
 569 #endif
 570     /* What follows are the buffers and key material. */
 571 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA)
 572     long rsa_count;
 573 #endif
 574 #ifndef OPENSSL_NO_MD2
 575     unsigned char md2[MD2_DIGEST_LENGTH];
 576 #endif
 577 #ifndef OPENSSL_NO_MDC2
 578     unsigned char mdc2[MDC2_DIGEST_LENGTH];
 579 #endif
 580 #ifndef OPENSSL_NO_MD4
 581     unsigned char md4[MD4_DIGEST_LENGTH];
 582 #endif
 583 #ifndef OPENSSL_NO_MD5
 584     unsigned char md5[MD5_DIGEST_LENGTH];
 585     unsigned char hmac[MD5_DIGEST_LENGTH];
 586 #endif
 587     unsigned char sha[SHA_DIGEST_LENGTH];
 588     unsigned char sha256[SHA256_DIGEST_LENGTH];
 589     unsigned char sha512[SHA512_DIGEST_LENGTH];
 590 #ifndef OPENSSL_NO_WHIRLPOOL
 591     unsigned char whirlpool[WHIRLPOOL_DIGEST_LENGTH];
 592 #endif
 593 #ifndef OPENSSL_NO_RMD160
 594     unsigned char rmd160[RIPEMD160_DIGEST_LENGTH];
 595 #endif
 596 #ifndef OPENSSL_NO_RC4
 597     RC4_KEY rc4_ks;
 598 #endif
 599 #ifndef OPENSSL_NO_RC5
 600     RC5_32_KEY rc5_ks;
 601 #endif
 602 #ifndef OPENSSL_NO_RC2
 603     RC2_KEY rc2_ks;
 604 #endif
 605 #ifndef OPENSSL_NO_IDEA
 606     IDEA_KEY_SCHEDULE idea_ks;
 607 #endif
 608 #ifndef OPENSSL_NO_SEED
 609     SEED_KEY_SCHEDULE seed_ks;
 610 #endif
 611 #ifndef OPENSSL_NO_BF
 612     BF_KEY bf_ks;
 613 #endif
 614 #ifndef OPENSSL_NO_CAST
 615     CAST_KEY cast_ks;
 616 #endif
 617     static const unsigned char key16[16] = {
 618         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
 619         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
 620     };
 621 #ifndef OPENSSL_NO_AES
 622     static const unsigned char key24[24] = {
 623         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
 624         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
 625         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
 626     };
 627     static const unsigned char key32[32] = {
 628         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
 629         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
 630         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
 631         0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
 632     };
 633 #endif
 634 #ifndef OPENSSL_NO_CAMELLIA
 635     static const unsigned char ckey24[24] = {
 636         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
 637         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
 638         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
 639     };
 640     static const unsigned char ckey32[32] = {
 641         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
 642         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
 643         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
 644         0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
 645     };
 646     CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
 647 #endif
 648 #ifndef OPENSSL_NO_AES
 649 # define MAX_BLOCK_SIZE 128
 650 #else
 651 # define MAX_BLOCK_SIZE 64
 652 #endif
 653     unsigned char DES_iv[8];
 654     unsigned char iv[2 * MAX_BLOCK_SIZE / 8];
 655 #ifndef OPENSSL_NO_DES
 656     static DES_cblock key = {
 657         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
 658     };
 659     static DES_cblock key2 = {
 660         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
 661     };
 662     static DES_cblock key3 = {
 663         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
 664     };
 665     DES_key_schedule sch;
 666     DES_key_schedule sch2;
 667     DES_key_schedule sch3;
 668 #endif
 669 #ifndef OPENSSL_NO_AES
 670     AES_KEY aes_ks1, aes_ks2, aes_ks3;
 671 #endif
 672 #ifndef OPENSSL_NO_RSA
 673     unsigned rsa_num;
 674     RSA *rsa_key[RSA_NUM];
 675     long rsa_c[RSA_NUM][2];
 676     static unsigned int rsa_bits[RSA_NUM] = {
 677         512, 1024, 2048, 3072, 4096, 7680, 15360
 678     };
 679     static unsigned char *rsa_data[RSA_NUM] = {
 680         test512, test1024, test2048, test3072, test4096, test7680, test15360
 681     };
 682     static int rsa_data_length[RSA_NUM] = {
 683         sizeof(test512), sizeof(test1024),
 684         sizeof(test2048), sizeof(test3072),
 685         sizeof(test4096), sizeof(test7680),
 686         sizeof(test15360)
 687     };
 688 #endif
 689 #ifndef OPENSSL_NO_DSA
 690     DSA *dsa_key[DSA_NUM];
 691     long dsa_c[DSA_NUM][2];
 692     static unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
 693 #endif
 694 #ifndef OPENSSL_NO_EC
 695     /*
 696      * We only test over the following curves as they are representative, To
 697      * add tests over more curves, simply add the curve NID and curve name to
 698      * the following arrays and increase the EC_NUM value accordingly.
 699      */
 700     static unsigned int test_curves[EC_NUM] = {
 701         /* Prime Curves */
 702         NID_secp160r1, NID_X9_62_prime192v1, NID_secp224r1,
 703         NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
 704         /* Binary Curves */
 705         NID_sect163k1, NID_sect233k1, NID_sect283k1,
 706         NID_sect409k1, NID_sect571k1, NID_sect163r2,
 707         NID_sect233r1, NID_sect283r1, NID_sect409r1,
 708         NID_sect571r1
 709     };
 710     static const char *test_curves_names[EC_NUM] = {
 711         /* Prime Curves */
 712         "secp160r1", "nistp192", "nistp224",
 713         "nistp256", "nistp384", "nistp521",
 714         /* Binary Curves */
 715         "nistk163", "nistk233", "nistk283",
 716         "nistk409", "nistk571", "nistb163",
 717         "nistb233", "nistb283", "nistb409",
 718         "nistb571"
 719     };
 720     static int test_curves_bits[EC_NUM] = {
 721         160, 192, 224,
 722         256, 384, 521,
 723         163, 233, 283,
 724         409, 571, 163,
 725         233, 283, 409,
 726         571
 727     };
 728 #endif
 729 #ifndef OPENSSL_NO_EC
 730     unsigned char ecdsasig[256];
 731     unsigned int ecdsasiglen;
 732     EC_KEY *ecdsa[EC_NUM];
 733     long ecdsa_c[EC_NUM][2];
 734     int ecdsa_doit[EC_NUM];
 735     EC_KEY *ecdh_a[EC_NUM], *ecdh_b[EC_NUM];
 736     unsigned char secret_a[MAX_ECDH_SIZE], secret_b[MAX_ECDH_SIZE];
 737     int secret_size_a, secret_size_b;
 738     int ecdh_checks = 0;
 739     int secret_idx = 0;
 740     long ecdh_c[EC_NUM][2];
 741     int ecdh_doit[EC_NUM];
 742 #endif
 743
 744     memset(results, 0, sizeof(results));
 745 #ifndef OPENSSL_NO_DSA
 746     memset(dsa_key, 0, sizeof(dsa_key));
 747 #endif
 748 #ifndef OPENSSL_NO_EC
 749     for (i = 0; i < EC_NUM; i++)
 750         ecdsa[i] = NULL;
 751     for (i = 0; i < EC_NUM; i++)
 752         ecdh_a[i] = ecdh_b[i] = NULL;
 753 #endif
 754 #ifndef OPENSSL_NO_RSA
 755     memset(rsa_key, 0, sizeof(rsa_key));
 756     for (i = 0; i < RSA_NUM; i++)
 757         rsa_key[i] = NULL;
 758 #endif
 759
 760     memset(c, 0, sizeof(c));
 761     memset(DES_iv, 0, sizeof(DES_iv));
 762     memset(iv, 0, sizeof(iv));
 763
 764     for (i = 0; i < ALGOR_NUM; i++)
 765         doit[i] = 0;
 766     for (i = 0; i < RSA_NUM; i++)
 767         rsa_doit[i] = 0;
 768     for (i = 0; i < DSA_NUM; i++)
 769         dsa_doit[i] = 0;
 770 #ifndef OPENSSL_NO_EC
 771     for (i = 0; i < EC_NUM; i++)
 772         ecdsa_doit[i] = 0;
 773     for (i = 0; i < EC_NUM; i++)
 774         ecdh_doit[i] = 0;
 775 #endif
 776
 777     buf = buf_malloc = app_malloc((int)BUFSIZE + misalign, "input buffer");
 778     buf2 = buf2_malloc = app_malloc((int)BUFSIZE + misalign, "output buffer");
 779     misalign = 0;
 780
 781     prog = opt_init(argc, argv, speed_options);
 782     while ((o = opt_next()) != OPT_EOF) {
 783         switch (o) {
 784         case OPT_EOF:
 785         case OPT_ERR:
 786  opterr:
 787             BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
 788             goto end;
 789         case OPT_HELP:
 790             opt_help(speed_options);
 791             ret = 0;
 792             goto end;
 793         case OPT_ELAPSED:
 794             usertime = 0;
 795             break;
 796         case OPT_EVP:
 797             evp_cipher = EVP_get_cipherbyname(opt_arg());
 798             if (evp_cipher == NULL)
 799                 evp_md = EVP_get_digestbyname(opt_arg());
 800             if (evp_cipher == NULL && evp_md == NULL) {
 801                 BIO_printf(bio_err,
 802                            "%s: %s  an unknown cipher or digest\n",
 803                            prog, opt_arg());
 804                 goto end;
 805             }
 806             doit[D_EVP] = 1;
 807             break;
 808         case OPT_DECRYPT:
 809             decrypt = 1;
 810             break;
 811         case OPT_ENGINE:
 812             (void)setup_engine(opt_arg(), 0);
 813             break;
 814         case OPT_MULTI:
 815 #ifndef NO_FORK
 816             multi = atoi(opt_arg());
 817 #endif
 818             break;
 819         case OPT_MISALIGN:
 820             if (!opt_int(opt_arg(), &misalign))
 821                 goto end;
 822             if (misalign > MISALIGN) {
 823                 BIO_printf(bio_err,
 824                            "%s: Maximum offset is %d\n", prog, MISALIGN);
 825                 goto opterr;
 826             }
 827             buf = buf_malloc + misalign;
 828             buf2 = buf2_malloc + misalign;
 829             break;
 830         case OPT_MR:
 831             mr = 1;
 832             break;
 833         case OPT_MB:
 834             multiblock = 1;
 835             break;
 836         }
 837     }
 838     argc = opt_num_rest();
 839     argv = opt_rest();
 840
 841     /* Remaining arguments are algorithms. */
 842     for ( ; *argv; argv++) {
 843         if (found(*argv, doit_choices, &i)) {
 844             doit[i] = 1;
 845             continue;
 846         }
 847 #ifndef OPENSSL_NO_DES
 848         if (strcmp(*argv, "des") == 0) {
 849             doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
 850             continue;
 851         }
 852 #endif
 853         if (strcmp(*argv, "sha") == 0) {
 854             doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
 855             continue;
 856         }
 857 #ifndef OPENSSL_NO_RSA
 858 # ifndef RSA_NULL
 859         if (strcmp(*argv, "openssl") == 0) {
 860             RSA_set_default_method(RSA_PKCS1_OpenSSL());
 861             continue;
 862         }
 863 # endif
 864         if (strcmp(*argv, "rsa") == 0) {
 865             rsa_doit[R_RSA_512] = rsa_doit[R_RSA_1024] =
 866                 rsa_doit[R_RSA_2048] = rsa_doit[R_RSA_3072] =
 867                 rsa_doit[R_RSA_4096] = rsa_doit[R_RSA_7680] =
 868                 rsa_doit[R_RSA_15360] = 1;
 869             continue;
 870         }
 871         if (found(*argv, rsa_choices, &i)) {
 872             rsa_doit[i] = 1;
 873             continue;
 874         }
 875 #endif
 876 #ifndef OPENSSL_NO_DSA
 877         if (strcmp(*argv, "dsa") == 0) {
 878             dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
 879                 dsa_doit[R_DSA_2048] = 1;
 880             continue;
 881         }
 882         if (found(*argv, dsa_choices, &i)) {
 883             dsa_doit[i] = 2;
 884             continue;
 885         }
 886 #endif
 887 #ifndef OPENSSL_NO_AES
 888         if (strcmp(*argv, "aes") == 0) {
 889             doit[D_CBC_128_AES] = doit[D_CBC_192_AES] =
 890                 doit[D_CBC_256_AES] = 1;
 891             continue;
 892         }
 893 #endif
 894 #ifndef OPENSSL_NO_CAMELLIA
 895         if (strcmp(*argv, "camellia") == 0) {
 896             doit[D_CBC_128_CML] = doit[D_CBC_192_CML] =
 897                 doit[D_CBC_256_CML] = 1;
 898             continue;
 899         }
 900 #endif
 901 #ifndef OPENSSL_NO_EC
 902         if (strcmp(*argv, "ecdsa") == 0) {
 903             for (i = 0; i < EC_NUM; i++)
 904                 ecdsa_doit[i] = 1;
 905             continue;
 906         }
 907         if (found(*argv, ecdsa_choices, &i)) {
 908             ecdsa_doit[i] = 2;
 909             continue;
 910         }
 911         if (strcmp(*argv, "ecdh") == 0) {
 912             for (i = 0; i < EC_NUM; i++)
 913                 ecdh_doit[i] = 1;
 914             continue;
 915         }
 916         if (found(*argv, ecdh_choices, &i)) {
 917             ecdh_doit[i] = 2;
 918             continue;
 919         }
 920 #endif
 921         BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
 922         goto end;
 923     }
 924
 925 #ifndef NO_FORK
 926     if (multi && do_multi(multi))
 927         goto show_res;
 928 #endif
 929
 930     /* No parameters; turn on everything. */
 931     if ((argc == 0) && !doit[D_EVP]) {
 932         for (i = 0; i < ALGOR_NUM; i++)
 933             if (i != D_EVP)
 934                 doit[i] = 1;
 935         for (i = 0; i < RSA_NUM; i++)
 936             rsa_doit[i] = 1;
 937         for (i = 0; i < DSA_NUM; i++)
 938             dsa_doit[i] = 1;
 939 #ifndef OPENSSL_NO_EC
 940         for (i = 0; i < EC_NUM; i++)
 941             ecdsa_doit[i] = 1;
 942         for (i = 0; i < EC_NUM; i++)
 943             ecdh_doit[i] = 1;
 944 #endif
 945     }
 946     for (i = 0; i < ALGOR_NUM; i++)
 947         if (doit[i])
 948             pr_header++;
 949
 950     if (usertime == 0 && !mr)
 951         BIO_printf(bio_err,
 952                    "You have chosen to measure elapsed time "
 953                    "instead of user CPU time.\n");
 954
 955 #ifndef OPENSSL_NO_RSA
 956     for (i = 0; i < RSA_NUM; i++) {
 957         const unsigned char *p;
 958
 959         p = rsa_data[i];
 960         rsa_key[i] = d2i_RSAPrivateKey(NULL, &p, rsa_data_length[i]);
 961         if (rsa_key[i] == NULL) {
 962             BIO_printf(bio_err, "internal error loading RSA key number %d\n",
 963                        i);
 964             goto end;
 965         }
 966     }
 967 #endif
 968
 969 #ifndef OPENSSL_NO_DSA
 970     dsa_key[0] = get_dsa512();
 971     dsa_key[1] = get_dsa1024();
 972     dsa_key[2] = get_dsa2048();
 973 #endif
 974
 975 #ifndef OPENSSL_NO_DES
 976     DES_set_key_unchecked(&key, &sch);
 977     DES_set_key_unchecked(&key2, &sch2);
 978     DES_set_key_unchecked(&key3, &sch3);
 979 #endif
 980 #ifndef OPENSSL_NO_AES
 981     AES_set_encrypt_key(key16, 128, &aes_ks1);
 982     AES_set_encrypt_key(key24, 192, &aes_ks2);
 983     AES_set_encrypt_key(key32, 256, &aes_ks3);
 984 #endif
 985 #ifndef OPENSSL_NO_CAMELLIA
 986     Camellia_set_key(key16, 128, &camellia_ks1);
 987     Camellia_set_key(ckey24, 192, &camellia_ks2);
 988     Camellia_set_key(ckey32, 256, &camellia_ks3);
 989 #endif
 990 #ifndef OPENSSL_NO_IDEA
 991     idea_set_encrypt_key(key16, &idea_ks);
 992 #endif
 993 #ifndef OPENSSL_NO_SEED
 994     SEED_set_key(key16, &seed_ks);
 995 #endif
 996 #ifndef OPENSSL_NO_RC4
 997     RC4_set_key(&rc4_ks, 16, key16);
 998 #endif
 999 #ifndef OPENSSL_NO_RC2
1000     RC2_set_key(&rc2_ks, 16, key16, 128);
1001 #endif
1002 #ifndef OPENSSL_NO_RC5
1003     RC5_32_set_key(&rc5_ks, 16, key16, 12);
1004 #endif
1005 #ifndef OPENSSL_NO_BF
1006     BF_set_key(&bf_ks, 16, key16);
1007 #endif
1008 #ifndef OPENSSL_NO_CAST
1009     CAST_set_key(&cast_ks, 16, key16);
1010 #endif
1011 #ifndef OPENSSL_NO_RSA
1012     memset(rsa_c, 0, sizeof(rsa_c));
1013 #endif
1014 #ifndef SIGALRM
1015 # ifndef OPENSSL_NO_DES
1016     BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1017     count = 10;
1018     do {
1019         long it;
1020         count *= 2;
1021         Time_F(START);
1022         for (it = count; it; it--)
1023             DES_ecb_encrypt((DES_cblock *)buf,
1024                             (DES_cblock *)buf, &sch, DES_ENCRYPT);
1025         d = Time_F(STOP);
1026     } while (d < 3);
1027     save_count = count;
1028     c[D_MD2][0] = count / 10;
1029     c[D_MDC2][0] = count / 10;
1030     c[D_MD4][0] = count;
1031     c[D_MD5][0] = count;
1032     c[D_HMAC][0] = count;
1033     c[D_SHA1][0] = count;
1034     c[D_RMD160][0] = count;
1035     c[D_RC4][0] = count * 5;
1036     c[D_CBC_DES][0] = count;
1037     c[D_EDE3_DES][0] = count / 3;
1038     c[D_CBC_IDEA][0] = count;
1039     c[D_CBC_SEED][0] = count;
1040     c[D_CBC_RC2][0] = count;
1041     c[D_CBC_RC5][0] = count;
1042     c[D_CBC_BF][0] = count;
1043     c[D_CBC_CAST][0] = count;
1044     c[D_CBC_128_AES][0] = count;
1045     c[D_CBC_192_AES][0] = count;
1046     c[D_CBC_256_AES][0] = count;
1047     c[D_CBC_128_CML][0] = count;
1048     c[D_CBC_192_CML][0] = count;
1049     c[D_CBC_256_CML][0] = count;
1050     c[D_SHA256][0] = count;
1051     c[D_SHA512][0] = count;
1052     c[D_WHIRLPOOL][0] = count;
1053     c[D_IGE_128_AES][0] = count;
1054     c[D_IGE_192_AES][0] = count;
1055     c[D_IGE_256_AES][0] = count;
1056     c[D_GHASH][0] = count;
1057
1058     for (i = 1; i < SIZE_NUM; i++) {
1059         long l0, l1;
1060
1061         l0 = (long)lengths[0];
1062         l1 = (long)lengths[i];
1063
1064         c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1065         c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1066         c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1067         c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1068         c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1069         c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1070         c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1071         c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1072         c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1073         c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1074
1075         l0 = (long)lengths[i - 1];
1076
1077         c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1078         c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1079         c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1080         c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1081         c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1082         c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1083         c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1084         c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1085         c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1086         c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1087         c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1088         c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1089         c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1090         c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1091         c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1092         c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1093         c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1094         c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1095     }
1096
1097 #  ifndef OPENSSL_NO_RSA
1098     rsa_c[R_RSA_512][0] = count / 2000;
1099     rsa_c[R_RSA_512][1] = count / 400;
1100     for (i = 1; i < RSA_NUM; i++) {
1101         rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1102         rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1103         if ((rsa_doit[i] <= 1) && (rsa_c[i][0] == 0))
1104             rsa_doit[i] = 0;
1105         else {
1106             if (rsa_c[i][0] == 0) {
1107                 rsa_c[i][0] = 1;
1108                 rsa_c[i][1] = 20;
1109             }
1110         }
1111     }
1112 #  endif
1113
1114 #  ifndef OPENSSL_NO_DSA
1115     dsa_c[R_DSA_512][0] = count / 1000;
1116     dsa_c[R_DSA_512][1] = count / 1000 / 2;
1117     for (i = 1; i < DSA_NUM; i++) {
1118         dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1119         dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1120         if ((dsa_doit[i] <= 1) && (dsa_c[i][0] == 0))
1121             dsa_doit[i] = 0;
1122         else {
1123             if (dsa_c[i] == 0) {
1124                 dsa_c[i][0] = 1;
1125                 dsa_c[i][1] = 1;
1126             }
1127         }
1128     }
1129 #  endif
1130
1131 #  ifndef OPENSSL_NO_EC
1132     ecdsa_c[R_EC_P160][0] = count / 1000;
1133     ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1134     for (i = R_EC_P192; i <= R_EC_P521; i++) {
1135         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1136         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1137         if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1138             ecdsa_doit[i] = 0;
1139         else {
1140             if (ecdsa_c[i] == 0) {
1141                 ecdsa_c[i][0] = 1;
1142                 ecdsa_c[i][1] = 1;
1143             }
1144         }
1145     }
1146     ecdsa_c[R_EC_K163][0] = count / 1000;
1147     ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1148     for (i = R_EC_K233; i <= R_EC_K571; i++) {
1149         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1150         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1151         if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1152             ecdsa_doit[i] = 0;
1153         else {
1154             if (ecdsa_c[i] == 0) {
1155                 ecdsa_c[i][0] = 1;
1156                 ecdsa_c[i][1] = 1;
1157             }
1158         }
1159     }
1160     ecdsa_c[R_EC_B163][0] = count / 1000;
1161     ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1162     for (i = R_EC_B233; i <= R_EC_B571; i++) {
1163         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1164         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1165         if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1166             ecdsa_doit[i] = 0;
1167         else {
1168             if (ecdsa_c[i] == 0) {
1169                 ecdsa_c[i][0] = 1;
1170                 ecdsa_c[i][1] = 1;
1171             }
1172         }
1173     }
1174
1175     ecdh_c[R_EC_P160][0] = count / 1000;
1176     ecdh_c[R_EC_P160][1] = count / 1000;
1177     for (i = R_EC_P192; i <= R_EC_P521; i++) {
1178         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1179         ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1180         if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1181             ecdh_doit[i] = 0;
1182         else {
1183             if (ecdh_c[i] == 0) {
1184                 ecdh_c[i][0] = 1;
1185                 ecdh_c[i][1] = 1;
1186             }
1187         }
1188     }
1189     ecdh_c[R_EC_K163][0] = count / 1000;
1190     ecdh_c[R_EC_K163][1] = count / 1000;
1191     for (i = R_EC_K233; i <= R_EC_K571; i++) {
1192         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1193         ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1194         if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1195             ecdh_doit[i] = 0;
1196         else {
1197             if (ecdh_c[i] == 0) {
1198                 ecdh_c[i][0] = 1;
1199                 ecdh_c[i][1] = 1;
1200             }
1201         }
1202     }
1203     ecdh_c[R_EC_B163][0] = count / 1000;
1204     ecdh_c[R_EC_B163][1] = count / 1000;
1205     for (i = R_EC_B233; i <= R_EC_B571; i++) {
1206         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1207         ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1208         if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1209             ecdh_doit[i] = 0;
1210         else {
1211             if (ecdh_c[i] == 0) {
1212                 ecdh_c[i][0] = 1;
1213                 ecdh_c[i][1] = 1;
1214             }
1215         }
1216     }
1217 #  endif
1218
1219 #  define COND(d) (count < (d))
1220 #  define COUNT(d) (d)
1221 # else
1222 /* not worth fixing */
1223 #  error "You cannot disable DES on systems without SIGALRM."
1224 # endif                        /* OPENSSL_NO_DES */
1225 #else
1226 # define COND(c) (run && count<0x7fffffff)
1227 # define COUNT(d) (count)
1228 # ifndef _WIN32
1229     signal(SIGALRM, sig_done);
1230 # endif
1231 #endif                         /* SIGALRM */
1232
1233 #ifndef OPENSSL_NO_MD2
1234     if (doit[D_MD2]) {
1235         for (j = 0; j < SIZE_NUM; j++) {
1236             print_message(names[D_MD2], c[D_MD2][j], lengths[j]);
1237             Time_F(START);
1238             for (count = 0, run = 1; COND(c[D_MD2][j]); count++)
1239                 EVP_Digest(buf, (unsigned long)lengths[j], &(md2[0]), NULL,
1240                            EVP_md2(), NULL);
1241             d = Time_F(STOP);
1242             print_result(D_MD2, j, count, d);
1243         }
1244     }
1245 #endif
1246 #ifndef OPENSSL_NO_MDC2
1247     if (doit[D_MDC2]) {
1248         for (j = 0; j < SIZE_NUM; j++) {
1249             print_message(names[D_MDC2], c[D_MDC2][j], lengths[j]);
1250             Time_F(START);
1251             for (count = 0, run = 1; COND(c[D_MDC2][j]); count++)
1252                 EVP_Digest(buf, (unsigned long)lengths[j], &(mdc2[0]), NULL,
1253                            EVP_mdc2(), NULL);
1254             d = Time_F(STOP);
1255             print_result(D_MDC2, j, count, d);
1256         }
1257     }
1258 #endif
1259
1260 #ifndef OPENSSL_NO_MD4
1261     if (doit[D_MD4]) {
1262         for (j = 0; j < SIZE_NUM; j++) {
1263             print_message(names[D_MD4], c[D_MD4][j], lengths[j]);
1264             Time_F(START);
1265             for (count = 0, run = 1; COND(c[D_MD4][j]); count++)
1266                 EVP_Digest(&(buf[0]), (unsigned long)lengths[j], &(md4[0]),
1267                            NULL, EVP_md4(), NULL);
1268             d = Time_F(STOP);
1269             print_result(D_MD4, j, count, d);
1270         }
1271     }
1272 #endif
1273
1274 #ifndef OPENSSL_NO_MD5
1275     if (doit[D_MD5]) {
1276         for (j = 0; j < SIZE_NUM; j++) {
1277             print_message(names[D_MD5], c[D_MD5][j], lengths[j]);
1278             Time_F(START);
1279             for (count = 0, run = 1; COND(c[D_MD5][j]); count++)
1280                 MD5(buf, lengths[j], md5);
1281             d = Time_F(STOP);
1282             print_result(D_MD5, j, count, d);
1283         }
1284     }
1285 #endif
1286
1287 #if !defined(OPENSSL_NO_MD5)
1288     if (doit[D_HMAC]) {
1289         HMAC_CTX *hctx = NULL;
1290
1291         hctx = HMAC_CTX_new();
1292         if (hctx == NULL) {
1293             BIO_printf(bio_err, "HMAC malloc failure, exiting...");
1294             exit(1);
1295         }
1296         HMAC_Init_ex(hctx, (unsigned char *)"This is a key...",
1297                      16, EVP_md5(), NULL);
1298
1299         for (j = 0; j < SIZE_NUM; j++) {
1300             print_message(names[D_HMAC], c[D_HMAC][j], lengths[j]);
1301             Time_F(START);
1302             for (count = 0, run = 1; COND(c[D_HMAC][j]); count++) {
1303                 HMAC_Init_ex(hctx, NULL, 0, NULL, NULL);
1304                 HMAC_Update(hctx, buf, lengths[j]);
1305                 HMAC_Final(hctx, &(hmac[0]), NULL);
1306             }
1307             d = Time_F(STOP);
1308             print_result(D_HMAC, j, count, d);
1309         }
1310         HMAC_CTX_free(hctx);
1311     }
1312 #endif
1313     if (doit[D_SHA1]) {
1314         for (j = 0; j < SIZE_NUM; j++) {
1315             print_message(names[D_SHA1], c[D_SHA1][j], lengths[j]);
1316             Time_F(START);
1317             for (count = 0, run = 1; COND(c[D_SHA1][j]); count++)
1318                 SHA1(buf, lengths[j], sha);
1319             d = Time_F(STOP);
1320             print_result(D_SHA1, j, count, d);
1321         }
1322     }
1323     if (doit[D_SHA256]) {
1324         for (j = 0; j < SIZE_NUM; j++) {
1325             print_message(names[D_SHA256], c[D_SHA256][j], lengths[j]);
1326             Time_F(START);
1327             for (count = 0, run = 1; COND(c[D_SHA256][j]); count++)
1328                 SHA256(buf, lengths[j], sha256);
1329             d = Time_F(STOP);
1330             print_result(D_SHA256, j, count, d);
1331         }
1332     }
1333     if (doit[D_SHA512]) {
1334         for (j = 0; j < SIZE_NUM; j++) {
1335             print_message(names[D_SHA512], c[D_SHA512][j], lengths[j]);
1336             Time_F(START);
1337             for (count = 0, run = 1; COND(c[D_SHA512][j]); count++)
1338                 SHA512(buf, lengths[j], sha512);
1339             d = Time_F(STOP);
1340             print_result(D_SHA512, j, count, d);
1341         }
1342     }
1343
1344 #ifndef OPENSSL_NO_WHIRLPOOL
1345     if (doit[D_WHIRLPOOL]) {
1346         for (j = 0; j < SIZE_NUM; j++) {
1347             print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][j], lengths[j]);
1348             Time_F(START);
1349             for (count = 0, run = 1; COND(c[D_WHIRLPOOL][j]); count++)
1350                 WHIRLPOOL(buf, lengths[j], whirlpool);
1351             d = Time_F(STOP);
1352             print_result(D_WHIRLPOOL, j, count, d);
1353         }
1354     }
1355 #endif
1356
1357 #ifndef OPENSSL_NO_RMD160
1358     if (doit[D_RMD160]) {
1359         for (j = 0; j < SIZE_NUM; j++) {
1360             print_message(names[D_RMD160], c[D_RMD160][j], lengths[j]);
1361             Time_F(START);
1362             for (count = 0, run = 1; COND(c[D_RMD160][j]); count++)
1363                 EVP_Digest(buf, (unsigned long)lengths[j], &(rmd160[0]), NULL,
1364                            EVP_ripemd160(), NULL);
1365             d = Time_F(STOP);
1366             print_result(D_RMD160, j, count, d);
1367         }
1368     }
1369 #endif
1370 #ifndef OPENSSL_NO_RC4
1371     if (doit[D_RC4]) {
1372         for (j = 0; j < SIZE_NUM; j++) {
1373             print_message(names[D_RC4], c[D_RC4][j], lengths[j]);
1374             Time_F(START);
1375             for (count = 0, run = 1; COND(c[D_RC4][j]); count++)
1376                 RC4(&rc4_ks, (unsigned int)lengths[j], buf, buf);
1377             d = Time_F(STOP);
1378             print_result(D_RC4, j, count, d);
1379         }
1380     }
1381 #endif
1382 #ifndef OPENSSL_NO_DES
1383     if (doit[D_CBC_DES]) {
1384         for (j = 0; j < SIZE_NUM; j++) {
1385             print_message(names[D_CBC_DES], c[D_CBC_DES][j], lengths[j]);
1386             Time_F(START);
1387             for (count = 0, run = 1; COND(c[D_CBC_DES][j]); count++)
1388                 DES_ncbc_encrypt(buf, buf, lengths[j], &sch,
1389                                  &DES_iv, DES_ENCRYPT);
1390             d = Time_F(STOP);
1391             print_result(D_CBC_DES, j, count, d);
1392         }
1393     }
1394
1395     if (doit[D_EDE3_DES]) {
1396         for (j = 0; j < SIZE_NUM; j++) {
1397             print_message(names[D_EDE3_DES], c[D_EDE3_DES][j], lengths[j]);
1398             Time_F(START);
1399             for (count = 0, run = 1; COND(c[D_EDE3_DES][j]); count++)
1400                 DES_ede3_cbc_encrypt(buf, buf, lengths[j],
1401                                      &sch, &sch2, &sch3,
1402                                      &DES_iv, DES_ENCRYPT);
1403             d = Time_F(STOP);
1404             print_result(D_EDE3_DES, j, count, d);
1405         }
1406     }
1407 #endif
1408 #ifndef OPENSSL_NO_AES
1409     if (doit[D_CBC_128_AES]) {
1410         for (j = 0; j < SIZE_NUM; j++) {
1411             print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][j],
1412                           lengths[j]);
1413             Time_F(START);
1414             for (count = 0, run = 1; COND(c[D_CBC_128_AES][j]); count++)
1415                 AES_cbc_encrypt(buf, buf,
1416                                 (unsigned long)lengths[j], &aes_ks1,
1417                                 iv, AES_ENCRYPT);
1418             d = Time_F(STOP);
1419             print_result(D_CBC_128_AES, j, count, d);
1420         }
1421     }
1422     if (doit[D_CBC_192_AES]) {
1423         for (j = 0; j < SIZE_NUM; j++) {
1424             print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][j],
1425                           lengths[j]);
1426             Time_F(START);
1427             for (count = 0, run = 1; COND(c[D_CBC_192_AES][j]); count++)
1428                 AES_cbc_encrypt(buf, buf,
1429                                 (unsigned long)lengths[j], &aes_ks2,
1430                                 iv, AES_ENCRYPT);
1431             d = Time_F(STOP);
1432             print_result(D_CBC_192_AES, j, count, d);
1433         }
1434     }
1435     if (doit[D_CBC_256_AES]) {
1436         for (j = 0; j < SIZE_NUM; j++) {
1437             print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][j],
1438                           lengths[j]);
1439             Time_F(START);
1440             for (count = 0, run = 1; COND(c[D_CBC_256_AES][j]); count++)
1441                 AES_cbc_encrypt(buf, buf,
1442                                 (unsigned long)lengths[j], &aes_ks3,
1443                                 iv, AES_ENCRYPT);
1444             d = Time_F(STOP);
1445             print_result(D_CBC_256_AES, j, count, d);
1446         }
1447     }
1448
1449     if (doit[D_IGE_128_AES]) {
1450         for (j = 0; j < SIZE_NUM; j++) {
1451             print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][j],
1452                           lengths[j]);
1453             Time_F(START);
1454             for (count = 0, run = 1; COND(c[D_IGE_128_AES][j]); count++)
1455                 AES_ige_encrypt(buf, buf2,
1456                                 (unsigned long)lengths[j], &aes_ks1,
1457                                 iv, AES_ENCRYPT);
1458             d = Time_F(STOP);
1459             print_result(D_IGE_128_AES, j, count, d);
1460         }
1461     }
1462     if (doit[D_IGE_192_AES]) {
1463         for (j = 0; j < SIZE_NUM; j++) {
1464             print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][j],
1465                           lengths[j]);
1466             Time_F(START);
1467             for (count = 0, run = 1; COND(c[D_IGE_192_AES][j]); count++)
1468                 AES_ige_encrypt(buf, buf2,
1469                                 (unsigned long)lengths[j], &aes_ks2,
1470                                 iv, AES_ENCRYPT);
1471             d = Time_F(STOP);
1472             print_result(D_IGE_192_AES, j, count, d);
1473         }
1474     }
1475     if (doit[D_IGE_256_AES]) {
1476         for (j = 0; j < SIZE_NUM; j++) {
1477             print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][j],
1478                           lengths[j]);
1479             Time_F(START);
1480             for (count = 0, run = 1; COND(c[D_IGE_256_AES][j]); count++)
1481                 AES_ige_encrypt(buf, buf2,
1482                                 (unsigned long)lengths[j], &aes_ks3,
1483                                 iv, AES_ENCRYPT);
1484             d = Time_F(STOP);
1485             print_result(D_IGE_256_AES, j, count, d);
1486         }
1487     }
1488     if (doit[D_GHASH]) {
1489         GCM128_CONTEXT *ctx =
1490             CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
1491         CRYPTO_gcm128_setiv(ctx, (unsigned char *)"0123456789ab", 12);
1492
1493         for (j = 0; j < SIZE_NUM; j++) {
1494             print_message(names[D_GHASH], c[D_GHASH][j], lengths[j]);
1495             Time_F(START);
1496             for (count = 0, run = 1; COND(c[D_GHASH][j]); count++)
1497                 CRYPTO_gcm128_aad(ctx, buf, lengths[j]);
1498             d = Time_F(STOP);
1499             print_result(D_GHASH, j, count, d);
1500         }
1501         CRYPTO_gcm128_release(ctx);
1502     }
1503 #endif
1504 #ifndef OPENSSL_NO_CAMELLIA
1505     if (doit[D_CBC_128_CML]) {
1506         for (j = 0; j < SIZE_NUM; j++) {
1507             print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][j],
1508                           lengths[j]);
1509             Time_F(START);
1510             for (count = 0, run = 1; COND(c[D_CBC_128_CML][j]); count++)
1511                 Camellia_cbc_encrypt(buf, buf,
1512                                      (unsigned long)lengths[j], &camellia_ks1,
1513                                      iv, CAMELLIA_ENCRYPT);
1514             d = Time_F(STOP);
1515             print_result(D_CBC_128_CML, j, count, d);
1516         }
1517     }
1518     if (doit[D_CBC_192_CML]) {
1519         for (j = 0; j < SIZE_NUM; j++) {
1520             print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][j],
1521                           lengths[j]);
1522             Time_F(START);
1523             for (count = 0, run = 1; COND(c[D_CBC_192_CML][j]); count++)
1524                 Camellia_cbc_encrypt(buf, buf,
1525                                      (unsigned long)lengths[j], &camellia_ks2,
1526                                      iv, CAMELLIA_ENCRYPT);
1527             d = Time_F(STOP);
1528             print_result(D_CBC_192_CML, j, count, d);
1529         }
1530     }
1531     if (doit[D_CBC_256_CML]) {
1532         for (j = 0; j < SIZE_NUM; j++) {
1533             print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][j],
1534                           lengths[j]);
1535             Time_F(START);
1536             for (count = 0, run = 1; COND(c[D_CBC_256_CML][j]); count++)
1537                 Camellia_cbc_encrypt(buf, buf,
1538                                      (unsigned long)lengths[j], &camellia_ks3,
1539                                      iv, CAMELLIA_ENCRYPT);
1540             d = Time_F(STOP);
1541             print_result(D_CBC_256_CML, j, count, d);
1542         }
1543     }
1544 #endif
1545 #ifndef OPENSSL_NO_IDEA
1546     if (doit[D_CBC_IDEA]) {
1547         for (j = 0; j < SIZE_NUM; j++) {
1548             print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][j], lengths[j]);
1549             Time_F(START);
1550             for (count = 0, run = 1; COND(c[D_CBC_IDEA][j]); count++)
1551                 idea_cbc_encrypt(buf, buf,
1552                                  (unsigned long)lengths[j], &idea_ks,
1553                                  iv, IDEA_ENCRYPT);
1554             d = Time_F(STOP);
1555             print_result(D_CBC_IDEA, j, count, d);
1556         }
1557     }
1558 #endif
1559 #ifndef OPENSSL_NO_SEED
1560     if (doit[D_CBC_SEED]) {
1561         for (j = 0; j < SIZE_NUM; j++) {
1562             print_message(names[D_CBC_SEED], c[D_CBC_SEED][j], lengths[j]);
1563             Time_F(START);
1564             for (count = 0, run = 1; COND(c[D_CBC_SEED][j]); count++)
1565                 SEED_cbc_encrypt(buf, buf,
1566                                  (unsigned long)lengths[j], &seed_ks, iv, 1);
1567             d = Time_F(STOP);
1568             print_result(D_CBC_SEED, j, count, d);
1569         }
1570     }
1571 #endif
1572 #ifndef OPENSSL_NO_RC2
1573     if (doit[D_CBC_RC2]) {
1574         for (j = 0; j < SIZE_NUM; j++) {
1575             print_message(names[D_CBC_RC2], c[D_CBC_RC2][j], lengths[j]);
1576             Time_F(START);
1577             for (count = 0, run = 1; COND(c[D_CBC_RC2][j]); count++)
1578                 RC2_cbc_encrypt(buf, buf,
1579                                 (unsigned long)lengths[j], &rc2_ks,
1580                                 iv, RC2_ENCRYPT);
1581             d = Time_F(STOP);
1582             print_result(D_CBC_RC2, j, count, d);
1583         }
1584     }
1585 #endif
1586 #ifndef OPENSSL_NO_RC5
1587     if (doit[D_CBC_RC5]) {
1588         for (j = 0; j < SIZE_NUM; j++) {
1589             print_message(names[D_CBC_RC5], c[D_CBC_RC5][j], lengths[j]);
1590             Time_F(START);
1591             for (count = 0, run = 1; COND(c[D_CBC_RC5][j]); count++)
1592                 RC5_32_cbc_encrypt(buf, buf,
1593                                    (unsigned long)lengths[j], &rc5_ks,
1594                                    iv, RC5_ENCRYPT);
1595             d = Time_F(STOP);
1596             print_result(D_CBC_RC5, j, count, d);
1597         }
1598     }
1599 #endif
1600 #ifndef OPENSSL_NO_BF
1601     if (doit[D_CBC_BF]) {
1602         for (j = 0; j < SIZE_NUM; j++) {
1603             print_message(names[D_CBC_BF], c[D_CBC_BF][j], lengths[j]);
1604             Time_F(START);
1605             for (count = 0, run = 1; COND(c[D_CBC_BF][j]); count++)
1606                 BF_cbc_encrypt(buf, buf,
1607                                (unsigned long)lengths[j], &bf_ks,
1608                                iv, BF_ENCRYPT);
1609             d = Time_F(STOP);
1610             print_result(D_CBC_BF, j, count, d);
1611         }
1612     }
1613 #endif
1614 #ifndef OPENSSL_NO_CAST
1615     if (doit[D_CBC_CAST]) {
1616         for (j = 0; j < SIZE_NUM; j++) {
1617             print_message(names[D_CBC_CAST], c[D_CBC_CAST][j], lengths[j]);
1618             Time_F(START);
1619             for (count = 0, run = 1; COND(c[D_CBC_CAST][j]); count++)
1620                 CAST_cbc_encrypt(buf, buf,
1621                                  (unsigned long)lengths[j], &cast_ks,
1622                                  iv, CAST_ENCRYPT);
1623             d = Time_F(STOP);
1624             print_result(D_CBC_CAST, j, count, d);
1625         }
1626     }
1627 #endif
1628
1629     if (doit[D_EVP]) {
1630 #ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
1631         if (multiblock && evp_cipher) {
1632             if (!
1633                 (EVP_CIPHER_flags(evp_cipher) &
1634                  EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
1635                 BIO_printf(bio_err, "%s is not multi-block capable\n",
1636                            OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher)));
1637                 goto end;
1638             }
1639             multiblock_speed(evp_cipher);
1640             ret = 0;
1641             goto end;
1642         }
1643 #endif
1644         for (j = 0; j < SIZE_NUM; j++) {
1645             if (evp_cipher) {
1646                 EVP_CIPHER_CTX *ctx;
1647                 int outl;
1648
1649                 names[D_EVP] = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
1650                 /*
1651                  * -O3 -fschedule-insns messes up an optimization here!
1652                  * names[D_EVP] somehow becomes NULL
1653                  */
1654                 print_message(names[D_EVP], save_count, lengths[j]);
1655
1656                 ctx = EVP_CIPHER_CTX_new();
1657                 if (decrypt)
1658                     EVP_DecryptInit_ex(ctx, evp_cipher, NULL, key16, iv);
1659                 else
1660                     EVP_EncryptInit_ex(ctx, evp_cipher, NULL, key16, iv);
1661                 EVP_CIPHER_CTX_set_padding(ctx, 0);
1662
1663                 Time_F(START);
1664                 if (decrypt)
1665                     for (count = 0, run = 1;
1666                          COND(save_count * 4 * lengths[0] / lengths[j]);
1667                          count++)
1668                         EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[j]);
1669                 else
1670                     for (count = 0, run = 1;
1671                          COND(save_count * 4 * lengths[0] / lengths[j]);
1672                          count++)
1673                         EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[j]);
1674                 if (decrypt)
1675                     EVP_DecryptFinal_ex(ctx, buf, &outl);
1676                 else
1677                     EVP_EncryptFinal_ex(ctx, buf, &outl);
1678                 d = Time_F(STOP);
1679                 EVP_CIPHER_CTX_free(ctx);
1680             }
1681             if (evp_md) {
1682                 names[D_EVP] = OBJ_nid2ln(EVP_MD_type(evp_md));
1683                 print_message(names[D_EVP], save_count, lengths[j]);
1684
1685                 Time_F(START);
1686                 for (count = 0, run = 1;
1687                      COND(save_count * 4 * lengths[0] / lengths[j]); count++)
1688                     EVP_Digest(buf, lengths[j], &(md[0]), NULL, evp_md, NULL);
1689
1690                 d = Time_F(STOP);
1691             }
1692             print_result(D_EVP, j, count, d);
1693         }
1694     }
1695
1696     RAND_bytes(buf, 36);
1697 #ifndef OPENSSL_NO_RSA
1698     for (j = 0; j < RSA_NUM; j++) {
1699         int st;
1700         if (!rsa_doit[j])
1701             continue;
1702         st = RSA_sign(NID_md5_sha1, buf, 36, buf2, &rsa_num, rsa_key[j]);
1703         if (st == 0) {
1704             BIO_printf(bio_err,
1705                        "RSA sign failure.  No RSA sign will be done.\n");
1706             ERR_print_errors(bio_err);
1707             rsa_count = 1;
1708         } else {
1709             pkey_print_message("private", "rsa",
1710                                rsa_c[j][0], rsa_bits[j], RSA_SECONDS);
1711             /* RSA_blinding_on(rsa_key[j],NULL); */
1712             Time_F(START);
1713             for (count = 0, run = 1; COND(rsa_c[j][0]); count++) {
1714                 st = RSA_sign(NID_md5_sha1, buf, 36, buf2,
1715                               &rsa_num, rsa_key[j]);
1716                 if (st == 0) {
1717                     BIO_printf(bio_err, "RSA sign failure\n");
1718                     ERR_print_errors(bio_err);
1719                     count = 1;
1720                     break;
1721                 }
1722             }
1723             d = Time_F(STOP);
1724             BIO_printf(bio_err,
1725                        mr ? "+R1:%ld:%d:%.2f\n"
1726                        : "%ld %d bit private RSA's in %.2fs\n",
1727                        count, rsa_bits[j], d);
1728             rsa_results[j][0] = d / (double)count;
1729             rsa_count = count;
1730         }
1731
1732         st = RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[j]);
1733         if (st <= 0) {
1734             BIO_printf(bio_err,
1735                        "RSA verify failure.  No RSA verify will be done.\n");
1736             ERR_print_errors(bio_err);
1737             rsa_doit[j] = 0;
1738         } else {
1739             pkey_print_message("public", "rsa",
1740                                rsa_c[j][1], rsa_bits[j], RSA_SECONDS);
1741             Time_F(START);
1742             for (count = 0, run = 1; COND(rsa_c[j][1]); count++) {
1743                 st = RSA_verify(NID_md5_sha1, buf, 36, buf2,
1744                                 rsa_num, rsa_key[j]);
1745                 if (st <= 0) {
1746                     BIO_printf(bio_err, "RSA verify failure\n");
1747                     ERR_print_errors(bio_err);
1748                     count = 1;
1749                     break;
1750                 }
1751             }
1752             d = Time_F(STOP);
1753             BIO_printf(bio_err,
1754                        mr ? "+R2:%ld:%d:%.2f\n"
1755                        : "%ld %d bit public RSA's in %.2fs\n",
1756                        count, rsa_bits[j], d);
1757             rsa_results[j][1] = d / (double)count;
1758         }
1759
1760         if (rsa_count <= 1) {
1761             /* if longer than 10s, don't do any more */
1762             for (j++; j < RSA_NUM; j++)
1763                 rsa_doit[j] = 0;
1764         }
1765     }
1766 #endif
1767
1768     RAND_bytes(buf, 20);
1769 #ifndef OPENSSL_NO_DSA
1770     if (RAND_status() != 1) {
1771         RAND_seed(rnd_seed, sizeof rnd_seed);
1772         rnd_fake = 1;
1773     }
1774     for (j = 0; j < DSA_NUM; j++) {
1775         unsigned int kk;
1776         int st;
1777
1778         if (!dsa_doit[j])
1779             continue;
1780
1781         /* DSA_generate_key(dsa_key[j]); */
1782         /* DSA_sign_setup(dsa_key[j],NULL); */
1783         st = DSA_sign(EVP_PKEY_DSA, buf, 20, buf2, &kk, dsa_key[j]);
1784         if (st == 0) {
1785             BIO_printf(bio_err,
1786                        "DSA sign failure.  No DSA sign will be done.\n");
1787             ERR_print_errors(bio_err);
1788             rsa_count = 1;
1789         } else {
1790             pkey_print_message("sign", "dsa",
1791                                dsa_c[j][0], dsa_bits[j], DSA_SECONDS);
1792             Time_F(START);
1793             for (count = 0, run = 1; COND(dsa_c[j][0]); count++) {
1794                 st = DSA_sign(EVP_PKEY_DSA, buf, 20, buf2, &kk, dsa_key[j]);
1795                 if (st == 0) {
1796                     BIO_printf(bio_err, "DSA sign failure\n");
1797                     ERR_print_errors(bio_err);
1798                     count = 1;
1799                     break;
1800                 }
1801             }
1802             d = Time_F(STOP);
1803             BIO_printf(bio_err,
1804                        mr ? "+R3:%ld:%d:%.2f\n"
1805                        : "%ld %d bit DSA signs in %.2fs\n",
1806                        count, dsa_bits[j], d);
1807             dsa_results[j][0] = d / (double)count;
1808             rsa_count = count;
1809         }
1810
1811         st = DSA_verify(EVP_PKEY_DSA, buf, 20, buf2, kk, dsa_key[j]);
1812         if (st <= 0) {
1813             BIO_printf(bio_err,
1814                        "DSA verify failure.  No DSA verify will be done.\n");
1815             ERR_print_errors(bio_err);
1816             dsa_doit[j] = 0;
1817         } else {
1818             pkey_print_message("verify", "dsa",
1819                                dsa_c[j][1], dsa_bits[j], DSA_SECONDS);
1820             Time_F(START);
1821             for (count = 0, run = 1; COND(dsa_c[j][1]); count++) {
1822                 st = DSA_verify(EVP_PKEY_DSA, buf, 20, buf2, kk, dsa_key[j]);
1823                 if (st <= 0) {
1824                     BIO_printf(bio_err, "DSA verify failure\n");
1825                     ERR_print_errors(bio_err);
1826                     count = 1;
1827                     break;
1828                 }
1829             }
1830             d = Time_F(STOP);
1831             BIO_printf(bio_err,
1832                        mr ? "+R4:%ld:%d:%.2f\n"
1833                        : "%ld %d bit DSA verify in %.2fs\n",
1834                        count, dsa_bits[j], d);
1835             dsa_results[j][1] = d / (double)count;
1836         }
1837
1838         if (rsa_count <= 1) {
1839             /* if longer than 10s, don't do any more */
1840             for (j++; j < DSA_NUM; j++)
1841                 dsa_doit[j] = 0;
1842         }
1843     }
1844     if (rnd_fake)
1845         RAND_cleanup();
1846 #endif
1847
1848 #ifndef OPENSSL_NO_EC
1849     if (RAND_status() != 1) {
1850         RAND_seed(rnd_seed, sizeof rnd_seed);
1851         rnd_fake = 1;
1852     }
1853     for (j = 0; j < EC_NUM; j++) {
1854         int st;
1855
1856         if (!ecdsa_doit[j])
1857             continue;           /* Ignore Curve */
1858         ecdsa[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1859         if (ecdsa[j] == NULL) {
1860             BIO_printf(bio_err, "ECDSA failure.\n");
1861             ERR_print_errors(bio_err);
1862             rsa_count = 1;
1863         } else {
1864             EC_KEY_precompute_mult(ecdsa[j], NULL);
1865             /* Perform ECDSA signature test */
1866             EC_KEY_generate_key(ecdsa[j]);
1867             st = ECDSA_sign(0, buf, 20, ecdsasig, &ecdsasiglen, ecdsa[j]);
1868             if (st == 0) {
1869                 BIO_printf(bio_err,
1870                            "ECDSA sign failure.  No ECDSA sign will be done.\n");
1871                 ERR_print_errors(bio_err);
1872                 rsa_count = 1;
1873             } else {
1874                 pkey_print_message("sign", "ecdsa",
1875                                    ecdsa_c[j][0],
1876                                    test_curves_bits[j], ECDSA_SECONDS);
1877
1878                 Time_F(START);
1879                 for (count = 0, run = 1; COND(ecdsa_c[j][0]); count++) {
1880                     st = ECDSA_sign(0, buf, 20,
1881                                     ecdsasig, &ecdsasiglen, ecdsa[j]);
1882                     if (st == 0) {
1883                         BIO_printf(bio_err, "ECDSA sign failure\n");
1884                         ERR_print_errors(bio_err);
1885                         count = 1;
1886                         break;
1887                     }
1888                 }
1889                 d = Time_F(STOP);
1890
1891                 BIO_printf(bio_err,
1892                            mr ? "+R5:%ld:%d:%.2f\n" :
1893                            "%ld %d bit ECDSA signs in %.2fs \n",
1894                            count, test_curves_bits[j], d);
1895                 ecdsa_results[j][0] = d / (double)count;
1896                 rsa_count = count;
1897             }
1898
1899             /* Perform ECDSA verification test */
1900             st = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[j]);
1901             if (st != 1) {
1902                 BIO_printf(bio_err,
1903                            "ECDSA verify failure.  No ECDSA verify will be done.\n");
1904                 ERR_print_errors(bio_err);
1905                 ecdsa_doit[j] = 0;
1906             } else {
1907                 pkey_print_message("verify", "ecdsa",
1908                                    ecdsa_c[j][1],
1909                                    test_curves_bits[j], ECDSA_SECONDS);
1910                 Time_F(START);
1911                 for (count = 0, run = 1; COND(ecdsa_c[j][1]); count++) {
1912                     st = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen,
1913                                       ecdsa[j]);
1914                     if (st != 1) {
1915                         BIO_printf(bio_err, "ECDSA verify failure\n");
1916                         ERR_print_errors(bio_err);
1917                         count = 1;
1918                         break;
1919                     }
1920                 }
1921                 d = Time_F(STOP);
1922                 BIO_printf(bio_err,
1923                            mr ? "+R6:%ld:%d:%.2f\n"
1924                            : "%ld %d bit ECDSA verify in %.2fs\n",
1925                            count, test_curves_bits[j], d);
1926                 ecdsa_results[j][1] = d / (double)count;
1927             }
1928
1929             if (rsa_count <= 1) {
1930                 /* if longer than 10s, don't do any more */
1931                 for (j++; j < EC_NUM; j++)
1932                     ecdsa_doit[j] = 0;
1933             }
1934         }
1935     }
1936     if (rnd_fake)
1937         RAND_cleanup();
1938 #endif
1939
1940 #ifndef OPENSSL_NO_EC
1941     if (RAND_status() != 1) {
1942         RAND_seed(rnd_seed, sizeof rnd_seed);
1943         rnd_fake = 1;
1944     }
1945     for (j = 0; j < EC_NUM; j++) {
1946         if (!ecdh_doit[j])
1947             continue;
1948         ecdh_a[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1949         ecdh_b[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1950         if ((ecdh_a[j] == NULL) || (ecdh_b[j] == NULL)) {
1951             BIO_printf(bio_err, "ECDH failure.\n");
1952             ERR_print_errors(bio_err);
1953             rsa_count = 1;
1954         } else {
1955             /* generate two ECDH key pairs */
1956             if (!EC_KEY_generate_key(ecdh_a[j]) ||
1957                 !EC_KEY_generate_key(ecdh_b[j])) {
1958                 BIO_printf(bio_err, "ECDH key generation failure.\n");
1959                 ERR_print_errors(bio_err);
1960                 rsa_count = 1;
1961             } else {
1962                 /*
1963                  * If field size is not more than 24 octets, then use SHA-1
1964                  * hash of result; otherwise, use result (see section 4.8 of
1965                  * draft-ietf-tls-ecc-03.txt).
1966                  */
1967                 int field_size, outlen;
1968                 void *(*kdf) (const void *in, size_t inlen, void *out,
1969                               size_t *xoutlen);
1970                 field_size =
1971                     EC_GROUP_get_degree(EC_KEY_get0_group(ecdh_a[j]));
1972                 if (field_size <= 24 * 8) {
1973                     outlen = KDF1_SHA1_len;
1974                     kdf = KDF1_SHA1;
1975                 } else {
1976                     outlen = (field_size + 7) / 8;
1977                     kdf = NULL;
1978                 }
1979                 secret_size_a =
1980                     ECDH_compute_key(secret_a, outlen,
1981                                      EC_KEY_get0_public_key(ecdh_b[j]),
1982                                      ecdh_a[j], kdf);
1983                 secret_size_b =
1984                     ECDH_compute_key(secret_b, outlen,
1985                                      EC_KEY_get0_public_key(ecdh_a[j]),
1986                                      ecdh_b[j], kdf);
1987                 if (secret_size_a != secret_size_b)
1988                     ecdh_checks = 0;
1989                 else
1990                     ecdh_checks = 1;
1991
1992                 for (secret_idx = 0; (secret_idx < secret_size_a)
1993                      && (ecdh_checks == 1); secret_idx++) {
1994                     if (secret_a[secret_idx] != secret_b[secret_idx])
1995                         ecdh_checks = 0;
1996                 }
1997
1998                 if (ecdh_checks == 0) {
1999                     BIO_printf(bio_err, "ECDH computations don't match.\n");
2000                     ERR_print_errors(bio_err);
2001                     rsa_count = 1;
2002                 }
2003
2004                 pkey_print_message("", "ecdh",
2005                                    ecdh_c[j][0],
2006                                    test_curves_bits[j], ECDH_SECONDS);
2007                 Time_F(START);
2008                 for (count = 0, run = 1; COND(ecdh_c[j][0]); count++) {
2009                     ECDH_compute_key(secret_a, outlen,
2010                                      EC_KEY_get0_public_key(ecdh_b[j]),
2011                                      ecdh_a[j], kdf);
2012                 }
2013                 d = Time_F(STOP);
2014                 BIO_printf(bio_err,
2015                            mr ? "+R7:%ld:%d:%.2f\n" :
2016                            "%ld %d-bit ECDH ops in %.2fs\n", count,
2017                            test_curves_bits[j], d);
2018                 ecdh_results[j][0] = d / (double)count;
2019                 rsa_count = count;
2020             }
2021         }
2022
2023         if (rsa_count <= 1) {
2024             /* if longer than 10s, don't do any more */
2025             for (j++; j < EC_NUM; j++)
2026                 ecdh_doit[j] = 0;
2027         }
2028     }
2029     if (rnd_fake)
2030         RAND_cleanup();
2031 #endif
2032 #ifndef NO_FORK
2033  show_res:
2034 #endif
2035     if (!mr) {
2036         printf("%s\n", OpenSSL_version(OPENSSL_VERSION));
2037         printf("%s\n", OpenSSL_version(OPENSSL_BUILT_ON));
2038         printf("options:");
2039         printf("%s ", BN_options());
2040 #ifndef OPENSSL_NO_MD2
2041         printf("%s ", MD2_options());
2042 #endif
2043 #ifndef OPENSSL_NO_RC4
2044         printf("%s ", RC4_options());
2045 #endif
2046 #ifndef OPENSSL_NO_DES
2047         printf("%s ", DES_options());
2048 #endif
2049 #ifndef OPENSSL_NO_AES
2050         printf("%s ", AES_options());
2051 #endif
2052 #ifndef OPENSSL_NO_IDEA
2053         printf("%s ", idea_options());
2054 #endif
2055 #ifndef OPENSSL_NO_BF
2056         printf("%s ", BF_options());
2057 #endif
2058         printf("\n%s\n", OpenSSL_version(OPENSSL_CFLAGS));
2059     }
2060
2061     if (pr_header) {
2062         if (mr)
2063             printf("+H");
2064         else {
2065             printf
2066                 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2067             printf("type        ");
2068         }
2069         for (j = 0; j < SIZE_NUM; j++)
2070             printf(mr ? ":%d" : "%7d bytes", lengths[j]);
2071         printf("\n");
2072     }
2073
2074     for (k = 0; k < ALGOR_NUM; k++) {
2075         if (!doit[k])
2076             continue;
2077         if (mr)
2078             printf("+F:%d:%s", k, names[k]);
2079         else
2080             printf("%-13s", names[k]);
2081         for (j = 0; j < SIZE_NUM; j++) {
2082             if (results[k][j] > 10000 && !mr)
2083                 printf(" %11.2fk", results[k][j] / 1e3);
2084             else
2085                 printf(mr ? ":%.2f" : " %11.2f ", results[k][j]);
2086         }
2087         printf("\n");
2088     }
2089 #ifndef OPENSSL_NO_RSA
2090     j = 1;
2091     for (k = 0; k < RSA_NUM; k++) {
2092         if (!rsa_doit[k])
2093             continue;
2094         if (j && !mr) {
2095             printf("%18ssign    verify    sign/s verify/s\n", " ");
2096             j = 0;
2097         }
2098         if (mr)
2099             printf("+F2:%u:%u:%f:%f\n",
2100                    k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2101         else
2102             printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2103                    rsa_bits[k], rsa_results[k][0], rsa_results[k][1],
2104                    1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]);
2105     }
2106 #endif
2107 #ifndef OPENSSL_NO_DSA
2108     j = 1;
2109     for (k = 0; k < DSA_NUM; k++) {
2110         if (!dsa_doit[k])
2111             continue;
2112         if (j && !mr) {
2113             printf("%18ssign    verify    sign/s verify/s\n", " ");
2114             j = 0;
2115         }
2116         if (mr)
2117             printf("+F3:%u:%u:%f:%f\n",
2118                    k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2119         else
2120             printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2121                    dsa_bits[k], dsa_results[k][0], dsa_results[k][1],
2122                    1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]);
2123     }
2124 #endif
2125 #ifndef OPENSSL_NO_EC
2126     j = 1;
2127     for (k = 0; k < EC_NUM; k++) {
2128         if (!ecdsa_doit[k])
2129             continue;
2130         if (j && !mr) {
2131             printf("%30ssign    verify    sign/s verify/s\n", " ");
2132             j = 0;
2133         }
2134
2135         if (mr)
2136             printf("+F4:%u:%u:%f:%f\n",
2137                    k, test_curves_bits[k],
2138                    ecdsa_results[k][0], ecdsa_results[k][1]);
2139         else
2140             printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2141                    test_curves_bits[k],
2142                    test_curves_names[k],
2143                    ecdsa_results[k][0], ecdsa_results[k][1],
2144                    1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
2145     }
2146 #endif
2147
2148 #ifndef OPENSSL_NO_EC
2149     j = 1;
2150     for (k = 0; k < EC_NUM; k++) {
2151         if (!ecdh_doit[k])
2152             continue;
2153         if (j && !mr) {
2154             printf("%30sop      op/s\n", " ");
2155             j = 0;
2156         }
2157         if (mr)
2158             printf("+F5:%u:%u:%f:%f\n",
2159                    k, test_curves_bits[k],
2160                    ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2161
2162         else
2163             printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2164                    test_curves_bits[k],
2165                    test_curves_names[k],
2166                    ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2167     }
2168 #endif
2169
2170     ret = 0;
2171
2172  end:
2173     ERR_print_errors(bio_err);
2174     OPENSSL_free(buf_malloc);
2175     OPENSSL_free(buf2_malloc);
2176 #ifndef OPENSSL_NO_RSA
2177     for (i = 0; i < RSA_NUM; i++)
2178         RSA_free(rsa_key[i]);
2179 #endif
2180 #ifndef OPENSSL_NO_DSA
2181     for (i = 0; i < DSA_NUM; i++)
2182         DSA_free(dsa_key[i]);
2183 #endif
2184
2185 #ifndef OPENSSL_NO_EC
2186     for (i = 0; i < EC_NUM; i++) {
2187         EC_KEY_free(ecdsa[i]);
2188         EC_KEY_free(ecdh_a[i]);
2189         EC_KEY_free(ecdh_b[i]);
2190     }
2191 #endif
2192     return (ret);
2193 }
2194
2195 static void print_message(const char *s, long num, int length)
2196 {
2197 #ifdef SIGALRM
2198     BIO_printf(bio_err,
2199                mr ? "+DT:%s:%d:%d\n"
2200                : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length);
2201     (void)BIO_flush(bio_err);
2202     alarm(SECONDS);
2203 #else
2204     BIO_printf(bio_err,
2205                mr ? "+DN:%s:%ld:%d\n"
2206                : "Doing %s %ld times on %d size blocks: ", s, num, length);
2207     (void)BIO_flush(bio_err);
2208 #endif
2209 }
2210
2211 static void pkey_print_message(const char *str, const char *str2, long num,
2212                                int bits, int tm)
2213 {
2214 #ifdef SIGALRM
2215     BIO_printf(bio_err,
2216                mr ? "+DTP:%d:%s:%s:%d\n"
2217                : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
2218     (void)BIO_flush(bio_err);
2219     alarm(tm);
2220 #else
2221     BIO_printf(bio_err,
2222                mr ? "+DNP:%ld:%d:%s:%s\n"
2223                : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
2224     (void)BIO_flush(bio_err);
2225 #endif
2226 }
2227
2228 static void print_result(int alg, int run_no, int count, double time_used)
2229 {
2230     BIO_printf(bio_err,
2231                mr ? "+R:%d:%s:%f\n"
2232                : "%d %s's in %.2fs\n", count, names[alg], time_used);
2233     results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
2234 }
2235
2236 #ifndef NO_FORK
2237 static char *sstrsep(char **string, const char *delim)
2238 {
2239     char isdelim[256];
2240     char *token = *string;
2241
2242     if (**string == 0)
2243         return NULL;
2244
2245     memset(isdelim, 0, sizeof isdelim);
2246     isdelim[0] = 1;
2247
2248     while (*delim) {
2249         isdelim[(unsigned char)(*delim)] = 1;
2250         delim++;
2251     }
2252
2253     while (!isdelim[(unsigned char)(**string)]) {
2254         (*string)++;
2255     }
2256
2257     if (**string) {
2258         **string = 0;
2259         (*string)++;
2260     }
2261
2262     return token;
2263 }
2264
2265 static int do_multi(int multi)
2266 {
2267     int n;
2268     int fd[2];
2269     int *fds;
2270     static char sep[] = ":";
2271
2272     fds = malloc(sizeof(*fds) * multi);
2273     for (n = 0; n < multi; ++n) {
2274         if (pipe(fd) == -1) {
2275             BIO_printf(bio_err, "pipe failure\n");
2276             exit(1);
2277         }
2278         fflush(stdout);
2279         (void)BIO_flush(bio_err);
2280         if (fork()) {
2281             close(fd[1]);
2282             fds[n] = fd[0];
2283         } else {
2284             close(fd[0]);
2285             close(1);
2286             if (dup(fd[1]) == -1) {
2287                 BIO_printf(bio_err, "dup failed\n");
2288                 exit(1);
2289             }
2290             close(fd[1]);
2291             mr = 1;
2292             usertime = 0;
2293             free(fds);
2294             return 0;
2295         }
2296         printf("Forked child %d\n", n);
2297     }
2298
2299     /* for now, assume the pipe is long enough to take all the output */
2300     for (n = 0; n < multi; ++n) {
2301         FILE *f;
2302         char buf[1024];
2303         char *p;
2304
2305         f = fdopen(fds[n], "r");
2306         while (fgets(buf, sizeof buf, f)) {
2307             p = strchr(buf, '\n');
2308             if (p)
2309                 *p = '\0';
2310             if (buf[0] != '+') {
2311                 BIO_printf(bio_err, "Don't understand line '%s' from child %d\n",
2312                         buf, n);
2313                 continue;
2314             }
2315             printf("Got: %s from %d\n", buf, n);
2316             if (strncmp(buf, "+F:", 3) == 0) {
2317                 int alg;
2318                 int j;
2319
2320                 p = buf + 3;
2321                 alg = atoi(sstrsep(&p, sep));
2322                 sstrsep(&p, sep);
2323                 for (j = 0; j < SIZE_NUM; ++j)
2324                     results[alg][j] += atof(sstrsep(&p, sep));
2325             } else if (strncmp(buf, "+F2:", 4) == 0) {
2326                 int k;
2327                 double d;
2328
2329                 p = buf + 4;
2330                 k = atoi(sstrsep(&p, sep));
2331                 sstrsep(&p, sep);
2332
2333                 d = atof(sstrsep(&p, sep));
2334                 if (n)
2335                     rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
2336                 else
2337                     rsa_results[k][0] = d;
2338
2339                 d = atof(sstrsep(&p, sep));
2340                 if (n)
2341                     rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
2342                 else
2343                     rsa_results[k][1] = d;
2344             }
2345 # ifndef OPENSSL_NO_DSA
2346             else if (strncmp(buf, "+F3:", 4) == 0) {
2347                 int k;
2348                 double d;
2349
2350                 p = buf + 4;
2351                 k = atoi(sstrsep(&p, sep));
2352                 sstrsep(&p, sep);
2353
2354                 d = atof(sstrsep(&p, sep));
2355                 if (n)
2356                     dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d);
2357                 else
2358                     dsa_results[k][0] = d;
2359
2360                 d = atof(sstrsep(&p, sep));
2361                 if (n)
2362                     dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d);
2363                 else
2364                     dsa_results[k][1] = d;
2365             }
2366 # endif
2367 # ifndef OPENSSL_NO_EC
2368             else if (strncmp(buf, "+F4:", 4) == 0) {
2369                 int k;
2370                 double d;
2371
2372                 p = buf + 4;
2373                 k = atoi(sstrsep(&p, sep));
2374                 sstrsep(&p, sep);
2375
2376                 d = atof(sstrsep(&p, sep));
2377                 if (n)
2378                     ecdsa_results[k][0] =
2379                         1 / (1 / ecdsa_results[k][0] + 1 / d);
2380                 else
2381                     ecdsa_results[k][0] = d;
2382
2383                 d = atof(sstrsep(&p, sep));
2384                 if (n)
2385                     ecdsa_results[k][1] =
2386                         1 / (1 / ecdsa_results[k][1] + 1 / d);
2387                 else
2388                     ecdsa_results[k][1] = d;
2389             }
2390 # endif
2391
2392 # ifndef OPENSSL_NO_EC
2393             else if (strncmp(buf, "+F5:", 4) == 0) {
2394                 int k;
2395                 double d;
2396
2397                 p = buf + 4;
2398                 k = atoi(sstrsep(&p, sep));
2399                 sstrsep(&p, sep);
2400
2401                 d = atof(sstrsep(&p, sep));
2402                 if (n)
2403                     ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
2404                 else
2405                     ecdh_results[k][0] = d;
2406
2407             }
2408 # endif
2409
2410             else if (strncmp(buf, "+H:", 3) == 0) {
2411                 ;
2412             } else
2413                 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf, n);
2414         }
2415
2416         fclose(f);
2417     }
2418     free(fds);
2419     return 1;
2420 }
2421 #endif
2422
2423 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
2424 {
2425     static int mblengths[] =
2426         { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
2427     int j, count, num = OSSL_NELEM(lengths);
2428     const char *alg_name;
2429     unsigned char *inp, *out, no_key[32], no_iv[16];
2430     EVP_CIPHER_CTX *ctx;
2431     double d = 0.0;
2432
2433     inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
2434     out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
2435     ctx = EVP_CIPHER_CTX_new();
2436     EVP_EncryptInit_ex(ctx, evp_cipher, NULL, no_key, no_iv);
2437     EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key),
2438                         no_key);
2439     alg_name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
2440
2441     for (j = 0; j < num; j++) {
2442         print_message(alg_name, 0, mblengths[j]);
2443         Time_F(START);
2444         for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
2445             unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
2446             EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
2447             size_t len = mblengths[j];
2448             int packlen;
2449
2450             memset(aad, 0, 8);  /* avoid uninitialized values */
2451             aad[8] = 23;        /* SSL3_RT_APPLICATION_DATA */
2452             aad[9] = 3;         /* version */
2453             aad[10] = 2;
2454             aad[11] = 0;        /* length */
2455             aad[12] = 0;
2456             mb_param.out = NULL;
2457             mb_param.inp = aad;
2458             mb_param.len = len;
2459             mb_param.interleave = 8;
2460
2461             packlen = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
2462                                           sizeof(mb_param), &mb_param);
2463
2464             if (packlen > 0) {
2465                 mb_param.out = out;
2466                 mb_param.inp = inp;
2467                 mb_param.len = len;
2468                 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
2469                                     sizeof(mb_param), &mb_param);
2470             } else {
2471                 int pad;
2472
2473                 RAND_bytes(out, 16);
2474                 len += 16;
2475                 aad[11] = len >> 8;
2476                 aad[12] = len;
2477                 pad = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_TLS1_AAD,
2478                                           EVP_AEAD_TLS1_AAD_LEN, aad);
2479                 EVP_Cipher(ctx, out, inp, len + pad);
2480             }
2481         }
2482         d = Time_F(STOP);
2483         BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
2484                    : "%d %s's in %.2fs\n", count, "evp", d);
2485         results[D_EVP][j] = ((double)count) / d * mblengths[j];
2486     }
2487
2488     if (mr) {
2489         fprintf(stdout, "+H");
2490         for (j = 0; j < num; j++)
2491             fprintf(stdout, ":%d", mblengths[j]);
2492         fprintf(stdout, "\n");
2493         fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
2494         for (j = 0; j < num; j++)
2495             fprintf(stdout, ":%.2f", results[D_EVP][j]);
2496         fprintf(stdout, "\n");
2497     } else {
2498         fprintf(stdout,
2499                 "The 'numbers' are in 1000s of bytes per second processed.\n");
2500         fprintf(stdout, "type                    ");
2501         for (j = 0; j < num; j++)
2502             fprintf(stdout, "%7d bytes", mblengths[j]);
2503         fprintf(stdout, "\n");
2504         fprintf(stdout, "%-24s", alg_name);
2505
2506         for (j = 0; j < num; j++) {
2507             if (results[D_EVP][j] > 10000)
2508                 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
2509             else
2510                 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
2511         }
2512         fprintf(stdout, "\n");
2513     }
2514
2515     OPENSSL_free(inp);
2516     OPENSSL_free(out);
2517     EVP_CIPHER_CTX_free(ctx);
2518 }